/**************************************************************************************** * dda_common.c * Linux atm module implementation. * * 2006 (c) Texas Instruments Inc. * * 8/15/2006 MK CQ10844: Added DDA_dsldk_proc_version function to display DSLDK * version. * 8/24/2006 EP Added DDA_dsl_DspImageAddrGet function to display DSLDK * version. * 8/25/2006 AV Making the changes for the new SAR. * 8/26/2006 AV Fixing warnings. * 10/10/2006 AV Fixing the interrupt lines definitions for UR8. * 10/19/2006 EP Adding DDA_dsl_DspImageFree() for UR8. * 10/27/2006 AV CQ11118: Adding a DDA_sleep_interruptible(). * 01/09/2007 EP Change DSP firmware name from 'ar07' to 'ur08'. * 01/29/2007 CZ CQ11430: port DSLHAL App to Linux ****************************************************************************************/ #include "dda_ti_dsl.h" #include "version.h" #include "dda_input.h" #include "dsldk_version.h" //bk DSP FW Location wird als Param übergeben //#define DSP_FIRMWARE_PATH "/lib/modules/ur0800xx.bin" extern char *firmware_load_file; //end bk /* cz add Mfg Diag Analog Test interface */ #ifdef AFE_DIAG #include "ddc_mfgdiag.h" #define DSP_DIAG_FIRMWARE_PATH "/lib/modules/afe_diag.bin" #define LOAD_AFE_DSP "load_afe_dsp" extern int runningAfeDiag; #endif #ifdef DHALAPP_LINUX extern void dhalapp_execute_dbg_cmd(void *ptidsl_liunx, char *cmdbuf); #endif static int DDA_dsl_process_oam_string (int *type, int *pvpi, int *pvci, int *pdelay, char *in_cmd); static int DDA_dsl_dump_memory(char *input_str); static void DDA_dsl_write_memory(char *input_str); static int DDA_dsl_process_txflush_string (int *pqueue, char *in_cmd); /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int os_atoi(const char *pStr) { int MulNeg = (*pStr == '-' ? -1 : 1); return (MulNeg * (simple_strtoul(pStr, (char **)NULL, 10))); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int os_atoh(const char *pStr) { int MulNeg = (*pStr == '-' ? -1 : 1); return (MulNeg * (simple_strtoul(pStr, (char **)NULL, 16))); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_sar_malloc(unsigned int size) { return(kmalloc(size, GFP_KERNEL)); } /************************************************************ NEED FN HEADER ************************************************************/ static spinlock_t sar_lock; static unsigned long lockflags; __inline__ void DDA_sar_critical_on(void) { spin_lock_irqsave(&sar_lock,lockflags); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_sar_critical_off(void) { spin_unlock_irqrestore(&sar_lock,lockflags); } /************************************************************ NEED FN HEADER ************************************************************/ /*AV_26 The IOCTL numbers have been modified. These should already be defined in the atmdev.h header file */ int DDA_atm_ioctl (struct atm_dev *dev, unsigned int cmd, void *arg) { Tn7AtmPrivate *priv = (Tn7AtmPrivate *) dev->dev_data; // printk("DDA_atm_ioctl cmd =%x\n", cmd); switch (cmd) { case ATM_TXSTOP: /* temp fix for SAR tear down problem */ // printk("ioctl cmd = 0x%x (%u), arg = 0x%p (%lu)\n", cmd, cmd, arg, (unsigned long)arg); // printk("arg = %d\n", *(int*)arg); priv->xmitStop = *(int *) arg; // printk("Executing ATM_SETLOOP for DDA_ \n"); // printk("Stop variable = :%d: \n",priv->xmitStop); return 0; // case SAR_DSL_RESET_SOFTBOOT: // return DDA_atm_dsl_clean_reboot(); case ATM_TXFLUSH: { int dmachan; tx_flush_t *pflush; struct atm_vcc *vcc; pflush = (tx_flush_t *) arg; vcc = pflush->vcc; dmachan = DDC_atm_lut_find (priv->dslPriv, vcc->vpi, vcc->vci); if (pflush->queue == 2) { DDC_sar_tx_flush ((void *) priv, dmachan, 0, pflush->skip_num); DDC_sar_tx_flush ((void *) priv, dmachan, 1, pflush->skip_num); } DDC_sar_tx_flush ((void *) priv, dmachan, pflush->queue, pflush->skip_num); return 0; } case ATM_DSL_READ_WRITE: { dsl_read_write_t *pGeneric; pGeneric = (dsl_read_write_t *) arg; if (pGeneric->action == 0) { return DDC_dsl_generic_read (priv->dslPriv, pGeneric->offsetnum, pGeneric->offset, &priv->dslPriv->dslReg); } else { return DDC_dsl_generic_write (priv->dslPriv, pGeneric->offsetnum, pGeneric->offset, pGeneric->data); } } #ifdef DHALAPP_LINUX case ATM_DHALAPP_CMD: { //printk("in ATM_DHALAPP_CMD\n"); dhalapp_execute_dbg_cmd((void *)priv->dslPriv->pIhw, (char *)arg); return 0; } #endif /* cz add Mfg Diag Analog Test interface */ #ifdef AFE_DIAG case ATM_DIAG_RUNTEST: { //printk("in ATM_DIAG_RUNTEST\n"); return DDC_diag_runtest(priv->dslPriv, arg); } case ATM_DIAG_GETRESULT: { //printk("in ATM_DIAG_GETRESULT\n"); return DDC_diag_getresult(priv->dslPriv, arg); } #endif // end AFE_DIAG case 0: return 0; } return -ENOSYS; } /************************************************************ NEED FN HEADER ************************************************************/ unsigned int shim_osGetCpuFrequency(void) { unsigned int CpuFrequency; dgprintf(6, "shim_osGetCpuFrequency()\n"); if(DDA_get_value_from_offset(cpufrequency, &CpuFrequency)) return CpuFrequency; else { DDA_printf("%s: Failed to read cpufrequency from env\n", __FUNCTION__); return 0; } } /************************************************************ NEED FN HEADER ************************************************************/ int shim_osLoadFWImage(unsigned char *ptr) { unsigned int bytesRead; mm_segment_t oldfs; static struct file *filp; unsigned int imageLength=0x5ffff; //AV_26 loff_t pos; //bk //char *fileName = DSP_FIRMWARE_PATH; char *fileName = firmware_load_file; //end bk //CZ path for datapump #ifdef AFE_DIAG int result = 0; if (DDA_get_value_from_name(LOAD_AFE_DSP, &result)) { if (result) { fileName = DSP_DIAG_FIRMWARE_PATH; runningAfeDiag = 1; } } #endif char *path = NULL; if (DDA_get_value_from_offset(datapump_path, &path)) { if (path != NULL) { fileName = path; } } printk("datapump path (%s)\n", fileName); filp = filp_open(fileName,00,O_RDONLY); //AV_26 #if 0 if(filp ==NULL) { printk("Failed: Could not open DSP binary file\n"); return -1; } if (filp->f_dentry != NULL) { if (filp->f_dentry->d_inode != NULL) { printk ("DSP binary filesize = %d bytes\n", (int) filp->f_dentry->d_inode->i_size); imageLength = (unsigned int)filp->f_dentry->d_inode->i_size + 0x200; } } if (filp->f_op->read==NULL) return -1; /* File(system) doesn't allow reads */ /* * Disable parameter checking */ oldfs = get_fs(); set_fs(KERNEL_DS); /* * Now read bytes from postion "StartPos" */ filp->f_pos = 0; bytesRead = filp->f_op->read(filp,ptr,imageLength,&filp->f_pos); dgprintf(4,"file length = %d\n", bytesRead); set_fs(oldfs); /* * Close the file */ fput(filp); #endif if (IS_ERR(filp)) { //bk //printk(KERN_INFO "Unable to load '%s'.\n", DSP_FIRMWARE_PATH); printk(KERN_INFO "Unable to load '%s'.\n", firmware_load_file); //end bk return -1; } if (filp->f_dentry != NULL) { if (filp->f_dentry->d_inode != NULL) { printk ("DSP binary filesize = %d bytes\n", (int) filp->f_dentry->d_inode->i_size); //imageLength = (unsigned int)filp->f_dentry->d_inode->i_size + 0x200; imageLength = (unsigned int)filp->f_dentry->d_inode->i_size; } } /* * Disable parameter checking */ oldfs = get_fs(); set_fs(KERNEL_DS); pos = 0; bytesRead = vfs_read(filp, ptr, imageLength, &pos); if (bytesRead != imageLength) { //bk //printk(KERN_INFO "Failed to read '%s' read only %d bytes.\n", DSP_FIRMWARE_PATH, bytesRead); printk(KERN_INFO "Failed to read '%s' read only %d bytes.\n", firmware_load_file, bytesRead); //end bk filp_close(filp, current->files); set_fs(oldfs); return -1; } set_fs(oldfs); filp_close(filp, current->files); //AV_DBG printk("%s: Completed \n", __FUNCTION__); return bytesRead; } /************************************************************ NEED FN HEADER ************************************************************/ unsigned int shim_read_overlay_page (void *ptr, unsigned int secOffset, unsigned int secLength) { unsigned int bytesRead; mm_segment_t oldfs; struct file *filp; dgprintf(4,"shim_read_overlay_page\n"); //dgprintf(4,"sec offset=%d, sec length =%d\n", secOffset, secLength); //bk //filp=filp_open(DSP_FIRMWARE_PATH,00,O_RDONLY); filp=filp_open(firmware_load_file,00,O_RDONLY); //end bk if(filp ==NULL) { printk("Failed: Could not open DSP binary file\n"); return -1; } if (filp->f_op->read==NULL) return -1; /* File(system) doesn't allow reads */ /* * Now read bytes from postion "StartPos" */ if(filp->f_op->llseek) filp->f_op->llseek(filp,secOffset, 0); oldfs = get_fs(); set_fs(KERNEL_DS); filp->f_pos = secOffset; bytesRead = filp->f_op->read(filp,ptr,secLength,&filp->f_pos); set_fs(oldfs); /* * Close the file */ fput(filp); return bytesRead; } /************************************************************ NEED FN HEADER ************************************************************/ int shim_osLoadDebugFWImage(unsigned char *ptr) { return 0; } /************************************************************ NEED FN HEADER ************************************************************/ int shim_osStringCmp(const char *s1, const char *s2) { return strcmp(s1, s2); } /************************************************************ NEED FN HEADER ************************************************************/ void *shim_osAllocateMemory(unsigned int size) { return ((void *)kmalloc(size, GFP_KERNEL)); } /************************************************************ NEED FN HEADER ************************************************************/ void *shim_osAllocateDmaMemory(unsigned int size) { void *ptr; ptr = kmalloc(size, GFP_ATOMIC); if(ptr==NULL) { printk("failed atomic\n"); ptr = kmalloc(size, GFP_KERNEL); if(ptr==NULL) { printk("failed kernel\n"); ptr = kmalloc(size, GFP_KERNEL|GFP_DMA); } } //printk("size=%d\n", size); return ptr; } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osFreeMemory(void *ptr, unsigned int size) { kfree(ptr); } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osFreeDmaMemory(void *ptr, unsigned int size) { kfree(ptr); } /************************************************************ NEED FN HEADER ************************************************************/ void *shim_osAllocateVMemory(unsigned int size) { return ((void *)vmalloc(size)); } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osFreeVMemory(void *ptr, unsigned int size) { vfree(ptr); } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osMoveMemory(char *dst, char *src, unsigned int numBytes) { DDA_atm_memcpy(dst, src, numBytes); } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osZeroMemory(char *dst, unsigned int numBytes) { memset(dst, 0, numBytes); } /************************************************************ NEED FN HEADER ************************************************************/ /* AV: Moved this definition to a central location. */ void shim_osWriteBackCache(void *addr, unsigned int size) { DDC_atm_data_writeback(addr, size); } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osClockWait(int val) { unsigned int chkvalue; chkvalue=val/64; if(chkvalue > 1000) { mdelay(chkvalue/1000); return; } else udelay(val/64); } /* end of cwait() */ /************************************************************ NEED FN HEADER ************************************************************/ unsigned int shim_osClockTick(void) { return jiffies; } /************************************************************ NEED FN HEADER ************************************************************/ int flags; spinlock_t shimLock; void shim_osCriticalEnter(void) { spin_lock_irqsave(&shimLock, flags); } /************************************************************ NEED FN HEADER ************************************************************/ void shim_osCriticalExit(void) { spin_unlock_irqrestore(&shimLock, flags); } /************************************************************ NEED FN HEADER ************************************************************/ //AV_26 // int dslmod_sysctl(ctl_table *ctl, int write, struct file * filp, // void *buffer, size_t *lenp) int dslmod_sysctl(ctl_table *ctl, int write, struct file * filp, void *buffer, size_t *lenp, loff_t *ppos) { char *ptr; int ret, len = 0; int chan; int type; int vpi,vci,timeout,queue; int i; phySettings curr_setting; char mod_req[16] = { '\t' }; char fst_byt; extern char info[MAX_STR_SIZE]; //AV_DDM THIS NEEDS TO BE FIXED. if (!*lenp || (filp->f_pos && !write)) { *lenp = 0; return 0; } /* * Command sent to module to do... */ if(write) { //AV_26 //ret = proc_dostring(ctl, write, filp, buffer, lenp); ret = proc_dostring(ctl, write, filp, buffer, lenp, ppos); switch (ctl->ctl_name) { case DEV_DSLMOD: ptr = strpbrk(info, " \t"); strcpy(mod_req, info); /* * parse the string to determine the action */ if (!strcmp (info, "dspfreq")) { printk("dsp_freq = %d\n", Local_priv->dslPriv->sar_freq * 4); break; } else if (!strncmp(info,"nohost", 6)) { if (strlen(info)==6) // read printk("nohost=%d\n", Local_priv->dslPriv->nohost_flag); else // write { Local_priv->dslPriv->nohost_flag = mod_req[6]-'0'; printk("nohost<-%d\n", Local_priv->dslPriv->nohost_flag); } } else if (!strcmp(info,"dslctl")) { for (i=0; i<2; i++) { memset(&curr_setting, 0, sizeof(curr_setting)); dslhal_api_readPhyFeatureSettings(Local_priv->dslPriv->pIhw, INTEROP_FEATURELIST0_PARAMID+i, (void *) &curr_setting); printk("phy_feature_%d=0x%08x, phy_cntl_mask_%d=0x%08x\n", i, curr_setting.phyEnableDisableWord, i, curr_setting.phyControlWord); } break; } /* Now for the famous ioctl commands */ fst_byt = toupper(mod_req[0]); switch (fst_byt) { case 'S': /* Deliberate fall through for this condition. */ case 'E': chan = DDA_dsl_process_oam_string (&type, &vpi, &vci, &timeout, mod_req); if( fst_byt == 'S') type = type | (1 << 1); ret = DDC_sar_oam_generation (Local_priv->dslPriv, chan, type, vpi, vci, timeout); break; case 'F': chan = DDA_dsl_process_txflush_string (&queue, mod_req); if (chan < 16) DDC_sar_tx_flush (Local_priv->dslPriv, chan, queue, 0); break; case 'D': DDA_dsl_dump_memory (&mod_req[1]); break; case 'W': DDA_dsl_write_memory(&mod_req[1]); break; default: DDC_dsl_chng_modulation (Local_priv->dslPriv, info); } } } else { len += sprintf(info+len, mod_req); //AV_26 //ret = proc_dostring(ctl, write, filp, buffer, lenp); ret = proc_dostring(ctl, write, filp, buffer, lenp, ppos); } return ret; } /************************************************************ NEED FN HEADER ************************************************************/ /* Input format: xAAAAAAAApBBBBBBc where AAAAAAAA is the vpi in hex and BBBBBB is the vci. */ static int DDA_dsl_parse_cmd_vc(int *vpi, int *vci, char *in_cmd) { int i=1; int j=0; char tmp[16]; while(j<8) { tmp[j] = in_cmd[i]; //printk("tmp[%d]=%c, %d\n", j, tmp[j], tmp[j]); if (tmp[j] == 'p' || tmp[j] == 'P') break; j++; i++; } tmp[j] = 0; *vpi = os_atoi (tmp); i++; j=0; while(j<8) { tmp[j] = in_cmd[i]; //printk("tmp[%d]=%c, %d\n", j, tmp[j], tmp[j]); if (tmp[j] == 'c' || tmp[j] == 'C') break; j++; i++; } *vci = os_atoi (tmp); return i; } /************************************************************ NEED FN HEADER ************************************************************/ static int DDA_dsl_process_txflush_string (int *pqueue, char *in_cmd) { int i = 1; int j = 0; int vci, vpi; char tmp[16]; int chan; int tt; i = DDA_dsl_parse_cmd_vc(&vpi, &vci, in_cmd); if(!i) return (ATM_NO_DMA_CHAN); i++; j=0; tmp[j] = in_cmd[i]; while(j<8) { tmp[j] = in_cmd[i]; if (tmp[j] == 'q' || tmp[j] == 'Q') break; j++; i++; } tt = os_atoi(tmp); chan = DDC_atm_lut_find(Local_priv->dslPriv, vpi, vci); *pqueue =tt; return chan; } /************************************************************ NEED FN HEADER ************************************************************/ static int DDA_dsl_process_oam_string (int *type, int *pvpi, int *pvci, int *pdelay, char *in_cmd) { int i=1; int j=0; int vci, vpi; char tmp[16]; int chan; int tt; i = DDA_dsl_parse_cmd_vc(&vpi, &vci, in_cmd); if(!i) return (ATM_NO_DMA_CHAN); if(vci==0) // f4 oam *type = 1; else *type = 0; tt=5000; i++; j=0; tmp[j] = in_cmd[i]; if (tmp[j] == 'd' || tmp[j] == 'D') { i++; while(j<8) { tmp[j] = in_cmd[i]; //printk("tmp[%d]=%c, %d\n", j, tmp[j], tmp[j]); if (tmp[j] == 't' || tmp[j] == 'T') break; j++; i++; } tt = os_atoi(tmp); } chan = DDC_atm_lut_find(Local_priv->dslPriv, vpi, vci); *pvci=vci; *pvpi=vpi; *pdelay =tt; dgprintf(2, "oam chan=%d, type =%d\n", chan, *type); return chan; } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_atm_change_qos (struct atm_vcc *vcc, struct atm_qos *qos, int flags) { dgprintf (1, "Enter DDA_atm_change_qos\n"); dgprintf (1, "Leave DDA_atm_change_qos\n"); return 0; } /* TASKLET MODE */ /************************************************************ NEED FN HEADER ************************************************************/ #ifdef CPATM_TASKLET_MODE void DDA_atm_handle_tasklet (unsigned long data) { struct atm_dev *atmdev = (struct atm_dev *) data; Tn7AtmPrivate *priv; int more = 0; dgprintf (6, "DDA_atm_sar_irq\n"); priv = (Tn7AtmPrivate *) atmdev->dev_data; DDA_sar_handle_interrupt (atmdev, priv, &more); if (more) { tasklet_schedule (&DDA_atm_tasklet); } } #endif /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * Function: int DDA_atm_sar_irq(void) * * Description: tnetd73xx SAR interrupt. * *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ //AV_26 //static void DDA_atm_sar_irq (int irq, void *voiddev, struct pt_regs *regs) #ifdef AR7_SAR irqreturn_t DDA_atm_sar_irq (int irq, void *voiddev, struct pt_regs *regs) { struct atm_dev *atmdev; Tn7AtmPrivate *priv; int more; int retval; dgprintf (6, "DDA_atm_sar_irq\n"); #ifdef TIATM_INST_SUPP psp_trace (ATM_DRV_SAR_ISR_ENTER); #endif atmdev = (struct atm_dev *) voiddev; priv = (Tn7AtmPrivate *) atmdev->dev_data; #ifdef CPATM_TASKLET_MODE tasklet_schedule (&DDA_atm_tasklet); #else retval = DDC_sar_handle_interrupt (priv->dslPriv, irq, &more); #endif dgprintf (6, "Leaving DDA_atm_sar_irq\n"); #ifdef TIATM_INST_SUPP psp_trace_par (ATM_DRV_SAR_ISR_EXIT, retval); #endif //AV_26 Temp till this is figured out. //return IRQ_RETVAL(retval); return IRQ_HANDLED; } #endif /* AR7_SAR */ /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * Function: int DDA_atm_dsl_irq(void) * * Description: tnetd73xx DSL interrupt. * *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ //AV_26 //static void DDA_atm_dsl_irq (int irq, void *voiddev, struct pt_regs *regs) irqreturn_t DDA_atm_dsl_irq (int irq, void *voiddev, struct pt_regs *regs) { struct atm_dev *atmdev; Tn7AtmPrivate *priv; int retval; dgprintf (4, "DDA_atm_dsl_irq\n"); #ifdef TIATM_INST_SUPP psp_trace (ATM_DRV_DSL_ISR_ENTER); #endif atmdev = (struct atm_dev *) voiddev; priv = (Tn7AtmPrivate *) atmdev->dev_data; retval = DDC_dsl_handle_interrupt (priv->dslPriv); dgprintf (4, "Leaving DDA_atm_dsl_irq\n"); #ifdef TIATM_INST_SUPP psp_trace_par (ATM_DRV_DSL_ISR_EXIT, retval); #endif //bk // printk("[bk] %s: DSL interrupt handler return = %d\n",__FUNCTION__,(int)retval); //end bk //bk return IRQ_HANDLED; ///AV_26 // return IRQ_RETVAL(retval); //end bk } /************************************************************ NEED FN HEADER ************************************************************/ /* Input format: wAAAAAAAAVVVVVVVV where AAAAAAAA is the address in hex and VVVVVVVV is the value to write. */ static void DDA_dsl_write_memory(char *input_str) { volatile int *pUi; int i = 0; volatile int addr; volatile int value; volatile int read; char tmp[16]; /* Read the first 8 characters for the address */ for(i = 0; i < 8; i++) tmp[i] = input_str[i]; tmp[i] = '\0'; addr = os_atoh(tmp); pUi = (volatile int *)addr; /* Read the remaining characters as the value */ value = os_atoh(&input_str[8]); /* Write the value into the memory location */ printk("Writing %#08x to address = 0x%p\n", value, pUi); DDC_atm_data_writeback((int *)pUi, 1); *pUi = value; /* Read back the value that was written */ DDC_atm_data_invalidate((int *)pUi, 1); read = *pUi; if(value != read) printk("The value at address %#08x is %#8.8x\n", addr, read); } /************************************************************ NEED FN HEADER ************************************************************/ /* Input format: rAAAAAAAAVVVVVVVV where AAAAAAAA is the address in hex and VVVVVVVV is the number of words to read back. */ static int DDA_dsl_dump_memory(char *input_str) { volatile int *pUi; int i = 0; volatile int addr; volatile int wrd_to_read; char tmp[16]; /* Read the first 8 characters for the address */ for(i = 0; i < 8; i++) tmp[i] = input_str[i]; tmp[i] = '\0'; addr = os_atoh(tmp); pUi = (volatile int *)addr; /* Read the remaining characters as the value */ wrd_to_read = os_atoh(&input_str[8]); /* Read back the values from the memory location */ printk("Reading %d words from address = 0x%p\n", wrd_to_read, pUi); for(i = 0; i < wrd_to_read; i++, pUi++) { if(!(i % 4)) printk("\n"); /* Read back the value that was written */ DDC_atm_data_invalidate((int *)pUi, 1); printk("%#8.8x ", *pUi); } printk("\n"); return(4 * i); } /************************************************************ NEED FN HEADER ************************************************************/ static int EnableQoS = FALSE; int DDA_atm_proc_qos_read(char *buf, char **start, off_t offset, int count, int *eof, void *data) { int len = 0; len += sprintf (buf + len, "\nEnableQoS = %d\n", EnableQoS); return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_atm_proc_qos_write(struct file *fp, const char *buf, unsigned long count, void *data) { char local_buf[32]; if(count > 30) { printk("Error : Buffer Overflow\n"); printk("Use \"echo 1> avsar_qos_enable \" to enable the QoS \n"); return -1; } copy_from_user(local_buf,buf,count); if(local_buf[count - 1] =='\n') local_buf[count - 1] ='\0'; /* Ignoring last \n char */ if(!strcmp("0",local_buf)) EnableQoS = FALSE; else if(!strcmp("1",local_buf)) EnableQoS = TRUE; else { printk("\nError: Unknown Command sent.\n"); printk("Use \"echo 1 > avsar_qos_enable\" to enable the QoS\n"); printk("\nOR\nUse \"echo 0 > avsar_qos_enable\" to disable the QoS\n"); return -1; } return count; } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_write_stats (struct file *fp, const char *buf, unsigned long count, void *data) { char local_buf[31]; int ret_val = 0; //AV_DDM DDA_atm_private_t * priv = Local_priv; if(count > 30) { printk("Error : Buffer Overflow\n"); printk("Use \"echo 0> avsar_modem_stats \" to reset the statistics\n"); return -1; } copy_from_user(local_buf,buf,count); local_buf[count-1]='\0'; /* Ignoring last \n char */ ret_val = count; if(strcmp("0",local_buf)==0) { /* *INDENT-OFF* */ /* * Valid command */ printk("Resetting AAL5 statistics.\n"); DDC_sar_stat_reset(); //AV_26 priv->stats->tx_dropped = 0; priv->stats->tx_errors = 0; priv->stats->rx_errors = 0; /* *INDENT-ON* */ } else { printk("\nError: Unknown operation on DSL/AAL5 statistics\n"); printk("Use \"echo 0 > avsar_modem_stats\" to reset the statistics\n"); return -1; } return ret_val; } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsldk_proc_version (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; int len = 0; char *ptr = buf + offset; len += sprintf (ptr + len, "DSLDK version:[%03d.%03d.%03d.%03d]\n", DSLDK_VERSION_MAJOR, DSLDK_VERSION_MINOR, DSLDK_VERSION_BUGFIX, DSLDK_VERSION_BUILDNUM); len += sprintf (ptr+ len, "ATM Driver version:[%03d.%03d.%03d.%03d]\n", LINUXATM_VERSION_MAJOR, LINUXATM_VERSION_MINOR, LINUXATM_VERSION_BUGFIX, LINUXATM_VERSION_BUILDNUM); return (len + (DDC_atm_proc_version((ptr + len), (count - len), eof, priv->dslPriv))); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_atm_proc_channels (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_atm_proc_channels((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_sar_proc_sar_stat(char* buf, char **start, off_t offset, int count,int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_sar_proc_sar_stat((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_sar_proc_oam_ping(char* buf, char **start, off_t offset, int count,int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_sar_proc_oam_ping((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_sar_proc_pvc_table(char* buf, char **start, off_t offset, int count,int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_sar_proc_pvc_table((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ //@Added SNR per bin info per customer request. 05-14-2004 int DDA_dsl_proc_snr0 (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_snr0((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ //@Added SNR per bin info per customer request. 05-14-2004 int DDA_dsl_proc_snr1 (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_snr1((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ //@Added SNR per bin info per customer request. 05-14-2004 int DDA_dsl_proc_snr2 (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_snr2((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_eoc (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_eoc((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ //@Added bit allocation table per customer request. 05-14-2004 int DDA_dsl_proc_bit_allocation (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_bit_allocation((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_train_mode_export (char *buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_train_mode_export((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ #ifndef NO_ADV_STATS int DDA_dsl_proc_SNRpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_SNRpsds((buf + offset), count, eof, ddc_priv)); } #endif /************************************************************ NEED FN HEADER ************************************************************/ #ifndef NO_ADV_STATS int DDA_dsl_proc_QLNpsds(char* buf, char **start, off_t offset, int count,int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_QLNpsds((buf + offset), count, eof, ddc_priv)); } #endif /************************************************************ NEED FN HEADER ************************************************************/ int DDA_atm_proc_private (char *buf, char **start, off_t offset, int count, int *eof, void *data) { int len = 0; int limit = count - 80; DDA_DslPriv *priv = (DDA_DslPriv *)data; if (len <= limit) len += sprintf (buf + len, "\nPrivate Data Structure(TI DSL):\n"); if (len <= limit) len += sprintf (buf + len, "----------------------------------------\n"); if (len <= limit) len += sprintf (buf + len, "\tDDA priv: 0x%p\n", priv); if (len <= limit) len += sprintf (buf + len, "\tDDC priv: 0x%p\n", priv->dslPriv); if (len <= limit) len += sprintf (buf + len, "\tdev: 0x%p\n", priv->dev); #ifdef AR7_SAR if (len <= limit) len += sprintf (buf + len, "\tsar_irq: %02d", priv->sar_irq); #endif #ifdef UR8_SAR if (len <= limit) len += sprintf (buf + len, "\tsar_tx_irq: %02d", priv->sar_tx_irq); if (len <= limit) len += sprintf (buf + len, "\tsar_rx_irq: %02d", priv->sar_rx_irq); if (len <= limit) len += sprintf (buf + len, "\tsar_oam_tx_irq: %02d", priv->sar_oam_tx_irq); if (len <= limit) len += sprintf (buf + len, "\tsar_oam_rx_irq: %02d", priv->sar_oam_rx_irq); #endif if (len <= limit) len += sprintf (buf + len, "\tdsl_irq: %02d\n", priv->dsl_irq); return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_modem(char* buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_modem((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_stats(char* buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; int len = 0; int limit = count - 80; len += DDC_dsl_proc_stats((buf + offset), (count - len), eof, priv->dslPriv); //AV_26 if (len <= limit) len += sprintf (buf + len, "\tTx Packets Dropped Count:\t%lu\n\tTx Bad Packets Count:\t%lu\n", priv->stats->tx_dropped, priv->stats->tx_errors); if (len <= limit) len += sprintf (buf + len, "\tRx Packets Dropped Count:\t%lu\n\tRx Bad Packets Count:\t%lu\n\n", priv->stats->rx_dropped, priv->stats->rx_errors); /* Make sure that we didn't cross the count threshold. */ if ((len > limit) && (*eof == DDC_DSL_FINISHED)) *eof = DDC_DSL_NOT_FINISHED; return len; } #ifdef ADV_DIAG_STATS //CQ10275 /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_adv_stats1(char* buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_adv_stats1((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_adv_stats2(char* buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_adv_stats2((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_dsl_proc_adv_stats3(char* buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_adv_stats3((buf + offset), count, eof, ddc_priv)); } /************************************************************ NEED FN HEADER ************************************************************/ //AV_DDM This is not used. #if 0 int DDA_dsl_proc_adv_stats(char* buf, char **start, off_t offset, int count, int *eof, void *data) { DDA_DslPriv *priv = (DDA_DslPriv *)data; DDC_DslPriv *ddc_priv = priv->dslPriv; return (DDC_dsl_proc_adv_stats((buf + offset), count, eof, ddc_priv)); } #endif #endif /* ADV_DIAG_STATS CQ10275 */ /************************************************************ NEED FN HEADER ************************************************************/ /* Optimized memcpy for 32-bit processors. */ void * DDA_atm_memcpy(void * dst, void const * src, size_t len) { long * plDst = (long *) dst; long const * plSrc = (long const *) src; char * pcDst; char const * pcSrc; if (!((int)src & 0xFFFFFFFC) && !((int)dst & 0xFFFFFFFC)) { while (len >= 4) { *plDst++ = *plSrc++; len -= 4; } } pcDst = (char *) plDst; pcSrc = (char const *) plSrc; while (len--) { *pcDst++ = *pcSrc++; } return (dst); } /************************************************************ NEED FN HEADER ************************************************************/ /* Optimized memcmp for 32-bit processors. */ int DDA_atm_memcmp(void * dst, void const * src, size_t len) { long * plDst = (long *) dst; long const * plSrc = (long const *) src; char * pcDst; char const * pcSrc; if (!((int)src & 0xFFFFFFFC) && !((int)dst & 0xFFFFFFFC)) { while (len >= 4) { if(*plDst++ != *plSrc++) return -1; /* Not equal*/ len -= 4; } } pcDst = (char *) plDst; pcSrc = (char const *) plSrc; while (len--) { if(*pcDst++ != *pcSrc++) return -1; /* Not equal*/ } /* They are equal */ return 0; } //AV: to get around compile errors temp to be mapped to PAL functions if possible. /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_memcmp(int * dst, int const * src, int len) { return (DDA_atm_memcmp(dst, src, len)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_memcpy(int * dst, int const * src, int len) { return (DDA_atm_memcpy(dst, src,len)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_malloc(unsigned int size) { return (size ? kmalloc(size, GFP_KERNEL | GFP_ATOMIC): NULL); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_vmalloc(unsigned int size) { return (size ? vmalloc(size): NULL); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_free(void *mem) { if(mem) kfree(mem); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_vfree(void *mem) { if(mem) vfree(mem); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_atoi(char *p) { return (p ? os_atoi(p) : 0); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_atoh(char *p) { return (p ? os_atoh(p) : 0); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_strcmp(const char *String1, const char *String2) { return(strcmp(String1, String2)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_strncmp(const char *String1, const char *String2, int size) { return(strncmp(String1, String2, size)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ unsigned int DDA_strlen(const char *String) { return (strlen(String)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ char * DDA_strcpy(char *String1, const char *String2) { return (char *)(strcpy(String1, String2)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_memset(void *Dest, int val, unsigned int size) { return (memset(Dest, val, size)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ char *DDA_strstr(const char *String1, const char *String2) { return(strstr(String1, String2)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_toupper(int i) { return (toupper(i)); } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_printf(const char *fmt, ...) { va_list args; int r; va_start(args, fmt); r = vprintk(fmt, args); va_end(args); return r; } /************************************************************ NEED FN HEADER ************************************************************/ #ifdef DEBUG_BUILD void DDA_dprintf (int uDbgLevel, char *szFmt, ...) { va_list args; if( __guDbgLevel < uDbgLevel) return; va_start(args, szFmt); vprintk(szFmt, args); va_end(args); } #endif /************************************************************ NEED FN HEADER ************************************************************/ int DDA_sprintf ( char * buffer, const char * format, ...) { va_list args; int i; va_start(args, format); i = vsprintf(buffer,format,args); va_end(args); return i; } /************************************************************ NEED FN HEADER ************************************************************/ int DDA_snprintf ( char * buffer, unsigned int len, const char * format, ...) { va_list args; int i; va_start(args, format); i = vsnprintf(buffer,len,format,args); va_end(args); return i; } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ char *DDA_prom_getenv(char *String) { return (prom_getenv(String)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_mdelay(unsigned long delay) { mdelay(delay); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_critical_on(void) { DDA_sar_critical_on(); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_critical_off(void) { DDA_sar_critical_off(); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ unsigned long DDA_strtoul(const char *str, char **endptr, int base) { return (simple_strtoul(str, endptr, base)); } /************************************************************ NEED FN HEADER ************************************************************/ #ifdef AR7_SAR __inline__ void DDA_free_buffer(OS_RECEIVEINFO *OSRecieveInfo, void *memptr) { DDA_atm_free_rx_skb(OSRecieveInfo, memptr); } #endif #ifdef UR8_SAR __inline__ void DDA_free_buffer(void *OSRecieveInfo, void *memptr) { DDA_atm_free_rx_skb(OSRecieveInfo, memptr); } #endif /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_free_dev(void *mem) { kfree(mem); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_malloc_dev(unsigned int size) { return (kmalloc(size, GFP_KERNEL)); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void DDA_free_dma_transfer(void *mem) { kfree(mem); } /************************************************************ NEED FN HEADER ************************************************************/ __inline__ void *DDA_malloc_dma_transfer(unsigned int size, void *base, unsigned int memrange) { return (kmalloc(size, GFP_DMA |GFP_KERNEL)); } /************************************************************ NEED FN HEADER ************************************************************/ #ifdef AR7_SAR __inline__ void * DDA_malloc_rxbuffer(unsigned int size, void *mem_base, unsigned int mem_range, void *osSetup, HAL_RECEIVEINFO *hal_info, OS_RECEIVEINFO **os_receive_info, OS_DEVICE *os_dev) { return (DDA_atm_allocate_rx_skb(os_dev, os_receive_info, size, osSetup)); } #endif #ifdef UR8_SAR __inline__ void * DDA_malloc_rxbuffer(unsigned int size, void *mem_base, unsigned int mem_range, void *osSetup, void *hal_info, void**os_receive_info, void *os_dev) { return (DDA_atm_allocate_rx_skb(os_dev, os_receive_info, size, osSetup)); } #endif /************************************************************ NEED FN HEADER ************************************************************/ #ifdef AR7_SAR __inline__ int DDA_send_complete(OS_SENDINFO *OsSendInfo, int numTokens) { //return(DDA_atm_send_complete(OsSendInfo)); unsigned int cnt; for (cnt = 0; cnt < numTokens; cnt++) { struct sk_buff *skb = (struct sk_buff *) OsSendInfo[cnt]; if (skb == NULL) continue; DDA_atm_send_complete(OsSendInfo[cnt]); } return (0); } #endif #ifdef UR8_SAR __inline__ int DDA_send_complete(void *OsSendInfo, int numTokens) { //return(DDA_atm_send_complete(OsSendInfo)); unsigned int cnt; struct sk_buff *skb = (struct sk_buff *) OsSendInfo; for (cnt = 0; cnt < numTokens; cnt++, skb++) { if (skb == NULL) { DDA_printf("%s: Got NULL skb \n", __FUNCTION__); continue; } DDA_atm_send_complete(skb); } return (0); } #endif /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_request_interrupt_pacing(ti_dsl_int_t intr, unsigned int pace_val) { switch (intr) { case TI_SAR_INT: return (avalanche_request_pacing(LNXINTNUM(ATM_SAR_INT), ATM_SAR_INT_PACING_BLOCK_NUM, pace_val)); case TI_DSL_INT: default: return -1; //Interrupt pacing is not supported on DSL interrupt. } } /************************************************************ NEED FN HEADER ************************************************************/ #ifdef YAMUNA static unsigned char *gDspImageBuf = NULL; unsigned int DDA_dsl_DspImageAddrGet(void) { void *ptr = 0; if (gDspImageBuf == NULL) { /* 1MB memory reserved for run-time DSP */ gDspImageBuf = (char *)__get_free_pages(GFP_ATOMIC, 8); } if (gDspImageBuf) { /*initialization*/ unsigned int index = 0; DDA_memset(gDspImageBuf, 0, sizeof(gDspImageBuf)); index = (unsigned int)(&gDspImageBuf[0]) & 0x3F; if (index) { index = 0x40 - index; } ptr = (void *)(&gDspImageBuf[index]); } printk("DSP image page address: (%08X)\n", (unsigned int)ptr); return (unsigned int)ptr; } /************************************************************ NEED FN HEADER ************************************************************/ void DDA_dsl_DspImageFree(void) { if (gDspImageBuf) { free_pages((unsigned long)gDspImageBuf, 8); gDspImageBuf = NULL; } } #endif /************************************************************ NEED FN HEADER ************************************************************/ __inline__ int DDA_sleep_interruptible(unsigned long millisecs) { int ret; set_current_state(TASK_INTERRUPTIBLE); ret = schedule_timeout(millisecs); if(!ret) printk("%s: Got back 0 from schedule_timeout\n\n",__FUNCTION__); return ret; }