/**************************************************************************************** * ddc_common.c * * 2006 (c) Texas Instruments Inc. * * 10/10/2006 AV Fixing the interrupt lines definitions for UR8 and SAR stats. * 10/12/2006 AV Fixing the UR8 PDSP version number reading for now. * 10/31/2006 AV Adding DDC_sar_handle_tx_process() and DDC_sar_handle_rx_process(). * 10/31/2006 EP Fixed SAR version display. * 02/01/2007 EP Added DSL interrupt entry/exit acknowledgement. * 02/07/2007 MK/EP CQ11291: Added OAM ping support. ****************************************************************************************/ #include "ddc_ti_dsl.h" /* PDSP Firmware files */ #ifdef AR7_SAR #include "tnetd7300_sar_firm.h" #endif #ifdef UR8_SAR #include "av_sar_firm.h" #endif extern unsigned int oamFarLBCount[4]; static void DDC_sar_record_pvc(int atmheader); static int DDC_sar_get_stats(DDC_DslPriv *priv); static int DDC_sar_get_near_end_loopback_count(unsigned int *pF4count, unsigned int *pF5count); static void DDC_sar_get_sar_firmware_version(unsigned int *pdsp_version_ms, unsigned int *pdsp_version_ls); typedef struct _pvc_table { int bInUse; int vpi; int vci; }pvc_table; static int led_on; static pvc_table pvc_result[MAX_PVC_TABLE_ENTRY]; static int oam_type; static int oamAtmHdr; static unsigned int oamPingStatus = OAM_PING_NOT_STARTED; static int CanSuppADSL2 = TRUE; /************************************************************ NEED FN HEADER ************************************************************/ /* * This function returns a boolean value to indicate whether the chip supports ADSL2 and ADSL2+. */ int DDC_atm_read_can_support_adsl2 (void) { return (CanSuppADSL2); } /************************************************************ NEED FN HEADER ************************************************************/ /* * This function sets a boolean value to indicate whether the chip supports ADSL2 and ADSL2+. */ int DDC_atm_set_can_support_adsl2 (int can) { if ((!can == FALSE) || (can == TRUE)) CanSuppADSL2 = can; else return FALSE; return TRUE; } #ifdef ADV_DIAG_STATS //CQ10275 /************************************************************ NEED FN HEADER ************************************************************/ static int proc_adv_stats_header(char* buf, int limit) { int len = 0; int i = 0; /* * Read Ax5 Stats */ dslhal_api_gatherStatistics(pIhw); if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem Advanced Statistics:\n"); if(len<=limit) { if(pIhw->lConnected != 1) { pIhw->AppData.USConRate = 0; pIhw->AppData.DSConRate = 0; } len += DDA_sprintf (buf + len, "\t[Connection Rate]\tUS:\t%u\tDS:\t%u\n", (unsigned int)pIhw->AppData.USConRate, (unsigned int)pIhw->AppData.DSConRate ); } if(len<=limit) len += DDA_sprintf (buf + len, "\t[Margin]\tUS:\t%u\tDS:\t\t%u\n", (unsigned int)pIhw->AppData.usMargin, (unsigned int)pIhw->AppData.dsMargin/2 ); /* * Downstream/Upstream Interleaved Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\t[Interleave path] US (TX):\tCRC: \t%u\tFEC: \t%u\n", (unsigned int)pIhw->AppData.usICRC_errors, (unsigned int)pIhw->AppData.usIFEC_errors); if(len<=limit) len += DDA_sprintf(buf+len, "\t[Interleave path] DS (RX):\tCRC: \t%u\tFEC: \t%u\n", (unsigned int)pIhw->AppData.dsICRC_errors, (unsigned int)pIhw->AppData.dsIFEC_errors); /* * Upstream/Downstream Fast Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\t[Fast path] US (TX): \tCRC: \t%u\tFEC: \t%u\n", (unsigned int)pIhw->AppData.usFCRC_errors, (unsigned int)pIhw->AppData.usFFEC_errors); if(len<=limit) len += DDA_sprintf(buf+len, "\t[Fast path] DS (RX):\tCRC: \t%u\tFEC: \t%u\n", (unsigned int)pIhw->AppData.dsFCRC_errors, (unsigned int)pIhw->AppData.dsFFEC_errors); return len; } //AV_DDM This is not used. #if 0 /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_adv_stats(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; //char *cp = buf + offset; char *cp = buf; int i = 0; int strt = 32; static int ctr = 0; DDA_printf("proc_adv_stats: buf=0x%X, ctr=%d, offset=%d, count=%d, eof=%d\n", (unsigned int)buf, ctr, offset, count, *eof); if( ctr == 0) { len = proc_adv_stats_header( cp, limit); if( len<=limit) len += DDA_sprintf(cp+len, "\n\tBin No.\tBits:\tMargin:\tSNR\n"); } else { strt = ctr; } for( i =strt; i<512; i++) { if(len<=limit) { len += DDA_sprintf(cp+len, "\t%u\t%u\t%u\t%d\n", i, (unsigned int)pIhw->AppData.BitAllocTblDstrm[i], (unsigned int)pIhw->AppData.marginTblDstrm[i], (int)pIhw->AppData.rxSnrPerBin0[i]); } else { ctr = i; //*eof = 0; *(cp + len) = '\0'; DDA_printf("proc_adv_stats - return: ctr=%d, len=%d\n", ctr, len); return len; } } ctr = 0; *eof = 1; DDA_printf("proc_adv_stats - return: ctr=%d, len=%d\n", ctr, len); return len; } #endif /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_adv_stats1(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; int i; PITIDSLHW_T pIhw = priv->pIhw; len = proc_adv_stats_header(buf+len, limit); if(len<=limit) len += DDA_sprintf(buf+len, "\tBin No.\tBits:\tMargin:\tSNR (Part 1 of 3)\n"); for( i =32; i<128; i++) { if(len<=limit) len += DDA_sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i, (unsigned int)pIhw->AppData.BitAllocTblDstrm[i], (unsigned int)pIhw->AppData.marginTblDstrm[i], (int)pIhw->AppData.rxSnrPerBin0[i]); } if (len <= limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_adv_stats2(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; int i; PITIDSLHW_T pIhw = priv->pIhw; dslhal_api_gatherStatistics(pIhw); if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem Advanced Statistics (Part 2 of 3):\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tBin No.\tBits:\tMargin:\tSNR\n"); for( i =128; i<320; i++) { if(len<=limit) len += DDA_sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i, (unsigned int)pIhw->AppData.BitAllocTblDstrm[i], (unsigned int)pIhw->AppData.marginTblDstrm[i], (int)pIhw->AppData.rxSnrPerBin0[i]); } if (len <= limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_adv_stats3(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; int i; PITIDSLHW_T pIhw = priv->pIhw; dslhal_api_gatherStatistics(pIhw); if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem Advanced Statistics (Part 3 of 3):\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tBin No.\tBits:\tMargin:\tSNR\n"); for( i =320; i<512; i++) { if(len<=limit) len += DDA_sprintf(buf+len, "\t%u\t%u\t%u\t%d\n", i, (unsigned int)pIhw->AppData.BitAllocTblDstrm[i], (unsigned int)pIhw->AppData.marginTblDstrm[i], (int)pIhw->AppData.rxSnrPerBin0[i]); } if (len <= limit) *eof = DDC_DSL_FINISHED; return len; } #endif /* ADV_DIAG_STATS CQ10275 */ /************************************************************ NEED FN HEADER ************************************************************/ static char *DDC_dsl_AnnexFromNum(unsigned short annex_selected) { static char *pUnknown= "Unknown"; /* *INDENT-OFF* */ static struct { char *annex_str; unsigned int bitMask; } annex_Table[] = { {"AnxA", 0x1}, {"AnxB", 0x2}, {"AnxC", 0x4}, {"AnxI", 0x8}, {"AnxJ", 0x10}, {"AnxL", 0x20}, {"AnxM", 0x40}, }; /* *INDENT-ON* */ unsigned int i; for (i=0;idev_data; PITIDSLHW_T pIhw = priv->pIhw; volatile int *OAM_ping_drp_cnt = (volatile int *) 0xa30085b0; /* * Read Ax5 Stats */ dslhal_api_gatherStatistics(pIhw); if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem Statistics:\n"); if(len<=limit) len += DDA_sprintf(buf+len, "--------------------------------\n"); /* * us and ds Connection Rates */ if(len<=limit) len += DDA_sprintf(buf+len, "[DSL Modem Stats]\n"); if(len<=limit) { if(pIhw->lConnected != 1) { pIhw->AppData.USConRate = 0; pIhw->AppData.DSConRate = 0; } len += DDA_sprintf (buf + len, "\tUS Connection Rate:\t%u\tDS Connection Rate:\t%u\n", (unsigned int)pIhw->AppData.USConRate, (unsigned int)pIhw->AppData.DSConRate ); } if(len<=limit) len += DDA_sprintf (buf + len, "\tDS Line Attenuation:\t%u\tDS Margin:\t\t%u\n", (unsigned int)pIhw->AppData.dsLineAttn/2, (unsigned int)pIhw->AppData.dsMargin/2 ); if(len<=limit) len += DDA_sprintf (buf + len, "\tUS Line Attenuation:\t%u\tUS Margin:\t\t%u\n", (unsigned int)pIhw->AppData.usLineAttn/2, (unsigned int)pIhw->AppData.usMargin ); if(len<=limit) len += DDA_sprintf(buf+len, "\tUS Payload :\t\t%u\tDS Payload:\t\t%u\n", ((unsigned int) pIhw->AppData.usAtm_count[0] + (unsigned int) pIhw->AppData.usAtm_count[1]) * 48, ((unsigned int) pIhw->AppData.dsGood_count[0] + (unsigned int) pIhw->AppData.dsGood_count[1]) * 48); /* * Superframe Count */ if(len<=limit) len += DDA_sprintf (buf + len, "\tUS Superframe Cnt :\t%u\tDS Superframe Cnt:\t%u\n", (unsigned int)pIhw->AppData.usSuperFrmCnt, (unsigned int)pIhw->AppData.dsSuperFrmCnt ); /* * US and DS power */ if(len<=limit) { if(pIhw->AppData.bState != RSTATE_SHOWTIME) { pIhw->AppData.usTxPower = 0; pIhw->AppData.dsTxPower = 0; } len += DDA_sprintf (buf + len, "\tUS Transmit Power :\t%u\tDS Transmit Power:\t%u\n", (unsigned int)pIhw->AppData.usTxPower/256, (unsigned int)pIhw->AppData.dsTxPower/256 ); } /* * DSL Stats Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\tLOS errors:\t\t%u\tSEF errors:\t\t%u\n", (unsigned int)pIhw->AppData.LOS_errors, (unsigned int)pIhw->AppData.SEF_errors ); if(len<=limit) len += DDA_sprintf(buf+len, "\tFrame mode:\t\t%u\tMax Frame mode:\t\t%u\n", (unsigned int)pIhw->AppData.FrmMode, (unsigned int)pIhw->AppData.MaxFrmMode ); if(len<=limit) len += DDA_sprintf (buf + len, "\tTrained Path:\t\t%u\tUS Peak Cell Rate:\t%u\n", (unsigned int)pIhw->AppData.TrainedPath, (unsigned int)pIhw->AppData.USConRate*1000/8/53 ); if(len<=limit) len += DDA_sprintf (buf + len, "\tTrained Mode:\t\t%u\tSelected Mode:\t\t%u\n", (unsigned int) pIhw->AppData.TrainedMode, (unsigned int) pIhw->AppData.StdMode); if(len<=limit) len += DDA_sprintf (buf + len, "\tATUC Vendor Code:\t%X\tATUC Revision:\t%u\n", (unsigned int) pIhw->AppData.atucVendorId, pIhw->AppData.atucRevisionNum); if(len<=limit) len += DDA_sprintf(buf+len, "\tHybrid Selected:\t%u\tTrellis:\t\t%u\n", (unsigned int)pIhw->AppData.currentHybridNum, pIhw->AppData.trellis); //@Added Maximum attainable bit rate information. 05-14-2004 //if(pIhw->AppData.TrainedMode > 5) if ((pIhw->AppData.TrainedMode & (DDC_DSL_ADSL2PLUS_MASKS|DDC_DSL_ADSL2_MASKS)) ) { DDA_memcpy((int *)&maxRate, (int *)&pIhw->adsl2TrainingMessages.rParams[6],4); maxRate /= 1000; DDA_memcpy((int *)&us_maxRate, (int *)&pIhw->adsl2TrainingMessages.cParams[6],4); } else { unsigned numPayloadBytes = 0; numPayloadBytes = ((pIhw->AppData.rMsgRa[6] & 0x01) << 8) | pIhw->AppData.rMsgRa[5]; numPayloadBytes = dslhal_support_byteSwap32 ((unsigned int) numPayloadBytes); numPayloadBytes *= 32; maxRate = (numPayloadBytes > pIhw->AppData.DSConRate) ? numPayloadBytes : pIhw->AppData.DSConRate; } if(len<=limit) len += DDA_sprintf (buf + len, "\tShowtime Count:\t\t%u\tDS Max Attainable Bit Rate: %u kbps\n", (unsigned int)pIhw->AppData.showtimeCount, maxRate); if(len<=limit) { unsigned int usBitswap = pIhw->AppData.usBitSwap; unsigned int dsBitswap = pIhw->AppData.dsBitSwap; //if(pIhw->AppData.TrainedMode > 5) if ((pIhw->AppData.TrainedMode & (DDC_DSL_ADSL2PLUS_MASKS|DDC_DSL_ADSL2_MASKS)) ) len += DDA_sprintf (buf + len, "\tBitSwap:\t\t%u\tUS Max Attainable Bit Rate: %u kbps\n", (unsigned int)(usBitswap && dsBitswap), us_maxRate); else len += DDA_sprintf (buf + len, "\tBitSwap:\t\t%u\tUS Max Attainable Bit Rate:\tn/a\n", (unsigned int)(usBitswap && dsBitswap)); } #if 1 // TR69 if(len<=limit) len += DDA_sprintf (buf + len, "\tAnnex: \t\t\t%s\tpsd_mask_qualifier: 0x%04x\n", DDC_dsl_AnnexFromNum(pIhw->AppData.annex_selected), pIhw->AppData.psd_mask_qualifier); if (len<=limit) { len += DDA_sprintf(buf+len,"\tATUC ghsVid: "); for (i=0; i<8; i++) len+= DDA_sprintf(buf+len, " %02x", pIhw->AppData.ghsATUCVendorId[i]); } if (len<=limit) { len += DDA_sprintf (buf + len, "\n"); } if (len <= limit) { len += DDA_sprintf (buf + len, "\tT1413Vid: %02x %02x\t\tT1413Rev: %02x\t\tVendorRev: %02x\n", pIhw->AppData.t1413ATUC.VendorId[0], pIhw->AppData.t1413ATUC.VendorId[1], pIhw->AppData.t1413ATUC.t1413Revision, pIhw->AppData.t1413ATUC.VendorRevision); } if (len<=limit) { len += DDA_sprintf(buf+len,"\tATUR ghsVid: "); for (i=0; i<8; i++) len+= DDA_sprintf(buf+len, " %02x", pIhw->AppData.ghsATURVendorId[i]); } if (len<=limit) { len += DDA_sprintf (buf + len, "\n"); } if (len <= limit) { len += DDA_sprintf (buf + len, "\tT1413Vid: %02x %02x\tT1413Rev: %02x\tVendorRev: %02x\n", pIhw->AppData.t1413ATUR.VendorId[0], pIhw->AppData.t1413ATUR.VendorId[1], pIhw->AppData.t1413ATUR.t1413Revision, pIhw->AppData.t1413ATUR.VendorRevision); } #endif /* * Upstream Interleaved Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\n\t[Upstream (TX) Interleave path]\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n", (unsigned int)pIhw->AppData.usICRC_errors, (unsigned int)pIhw->AppData.usIFEC_errors, (unsigned int)pIhw->AppData.usINCD_error); if(len<=limit) len += DDA_sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n", (unsigned int)pIhw->AppData.usILCD_errors, (unsigned int)pIhw->AppData.usIHEC_errors); /* * Downstream Interleaved Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\n\t[Downstream (RX) Interleave path]\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n", (unsigned int)pIhw->AppData.dsICRC_errors, (unsigned int)pIhw->AppData.dsIFEC_errors, (unsigned int)pIhw->AppData.dsINCD_error); if(len<=limit) len += DDA_sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n", (unsigned int)pIhw->AppData.dsILCD_errors, (unsigned int)pIhw->AppData.dsIHEC_errors); /* * Upstream Fast Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\n\t[Upstream (TX) Fast path]\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n", (unsigned int)pIhw->AppData.usFCRC_errors, (unsigned int)pIhw->AppData.usFFEC_errors, (unsigned int)pIhw->AppData.usFNCD_error); if(len<=limit) len += DDA_sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n", (unsigned int)pIhw->AppData.usFLCD_errors, (unsigned int)pIhw->AppData.usFHEC_errors); /* * Downstream Fast Errors */ if(len<=limit) len += DDA_sprintf(buf+len, "\n\t[Downstream (RX) Fast path]\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tCRC: \t%u\tFEC: \t%u\tNCD: \t%u\n", (unsigned int)pIhw->AppData.dsFCRC_errors, (unsigned int)pIhw->AppData.dsFFEC_errors, (unsigned int)pIhw->AppData.dsFNCD_error); if(len<=limit) len += DDA_sprintf(buf+len, "\tLCD: \t%u\tHEC: \t%u\n", (unsigned int)pIhw->AppData.dsFLCD_errors, (unsigned int)pIhw->AppData.dsFHEC_errors); /* * ATM stats upstream */ if(len<=limit) len += DDA_sprintf(buf+len, "\n[ATM Stats]"); if(len<=limit) len += DDA_sprintf(buf+len, "\n\t[Upstream/TX]\n"); if(len<=limit) len += DDA_sprintf (buf + len, "\tGood Cell Cnt:\t%u\n\tIdle Cell Cnt:\t%u\n\n", (unsigned int) pIhw->AppData.usAtm_count[0] + (unsigned int) pIhw->AppData.usAtm_count[1], (unsigned int) pIhw->AppData.usIdle_count[0] + (unsigned int) pIhw->AppData.usIdle_count[1]); /* * ATM stats downstream */ if(len<=limit) len += DDA_sprintf(buf+len, "\n\t[Downstream/RX)]\n"); if(len<=limit) len += DDA_sprintf (buf + len, "\tGood Cell Cnt:\t%u\n\tIdle Cell Cnt:\t%u\n\tBad Hec Cell Cnt:\t%u\n", (unsigned int) pIhw->AppData.dsGood_count[0] + (unsigned int) pIhw->AppData.dsGood_count[1], (unsigned int) pIhw->AppData.dsIdle_count[0] + (unsigned int) pIhw->AppData.dsIdle_count[1], (unsigned int) pIhw->AppData.dsBadHec_count[0] + (unsigned int) pIhw->AppData.dsBadHec_count[1]); if(len<=limit) len += DDA_sprintf(buf+len, "\tOverflow Dropped Cell Cnt:\t%u\n", (unsigned int) pIhw->AppData.dsOVFDrop_count[0] + (unsigned int) pIhw->AppData.dsOVFDrop_count[1]); #ifdef AR7_SAR DDC_sar_get_stats(pIhw->pOsContext); #endif if(len<=limit) len += DDA_sprintf(buf+len, "\n[SAR AAL5 Stats]\n"); if(len<=limit) len += DDA_sprintf(buf+len, "\tTx PDU's:\t%u\n\tRx PDU's:\t%u\n", sarStat.txPktCnt, sarStat.rxPktCnt); if(len<=limit) len += DDA_sprintf (buf + len, "\tTx Total Bytes:\t%u\n\tRx Total Bytes:\t%u\n", sarStat.txBytes, sarStat.rxBytes); if (len <= limit) len += DDA_sprintf (buf + len, "\tTx Total Error Counts:\t%u\n\tRx Total Error Counts:\t%u\n\n", sarStat.txErrors, sarStat.rxErrors); /* * oam loopback info */ if(len<=limit) len += DDA_sprintf(buf+len, "\n[OAM Stats]\n"); DDC_sar_get_near_end_loopback_count(&F4count, &F5count); if(len<=limit) { len += DDA_sprintf (buf + len, "\tNear End F5 Loop Back Count:\t%u\n\tNear End F4 Loop Back Count:\t%u\n\tFar End F5 Loop Back Count:\t%u\n\tFar End F4 Loop Back Count:\t%u\n", F5count, F4count, oamFarLBCount[0] + oamFarLBCount[2], oamFarLBCount[1] + oamFarLBCount[3]); } #define USE_OAM_DROP_COUNT //CQ10273 //Read OAM ping responses count: #ifdef USE_OAM_DROP_COUNT if(len<=limit) { /* len += DDA_sprintf (buf + len, "\tSAR OAM Retry in 0x%X cycles, Drop Count=%d\n", DDC_dsl_get_memory(0xa30085cc), DDC_dsl_get_memory(0xa30085c4)); */ len += DDA_sprintf (buf + len, "\tSAR OAM Ping Response Drop Count %d\n", *OAM_ping_drp_cnt); } #endif // USE_OAM_DROP_COUNT if (len <= limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_modem(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; PITIDSLHW_T pIhw = priv->pIhw; char *state; dslhal_api_pollTrainingStatus(pIhw); switch (pIhw->AppData.bState) { case RSTATE_IDLE: state = "IDLE"; break; case RSTATE_INIT: state = "INIT"; break; case RSTATE_HS: state = "HS"; break; case RSTATE_SHOWTIME: state = "SHOWTIME"; break; default: state = "unknown"; break; } if(pIhw->lConnected == 1) state = "SHOWTIME"; if(len<=limit) len += DDA_sprintf(buf+len,"%s\n",state); if(len<=limit) len += DDA_sprintf(buf+len, "%d\n", priv->dslReg); if(len<=limit) len += DDA_sprintf(buf+len, "failTrains=%d\n", pIhw->AppData.trainFails); if (len <= limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_atm_proc_channels (char *buf, int count, int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; int i; if (len <= limit) len += DDA_sprintf (buf + len, "Chan Inuse ChanID VPI VCI \n"); if (len <= limit) len += DDA_sprintf (buf + len, "------------------------------------------------------------------\n"); for (i = 0; i <= MAX_DMA_CHAN; i++) { if (len <= limit) { len += DDA_sprintf (buf + len, " %02d %05d %05d %05d %05d \n", i, priv->lut[i].inuse, priv->lut[i].chanid, priv->lut[i].vpi, priv->lut[i].vci); } } if (len <= limit) len += DDA_sprintf (buf + len, "------------------------------------------------------------------\n"); if (len <= limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ #ifdef AR7_SAR void DDC_atm_sarhal_isr_register(OS_DEVICE *os_dev, int (*hal_isr)(HAL_DEVICE*, int*), int interrupt_num) { DDC_DslPriv *priv = (DDC_DslPriv *)os_dev; dgprintf (4, "DDC_atm_sarhal_isr_register()\n"); priv->halIsr = (void *) hal_isr; priv->int_num = interrupt_num; } #endif /************************************************************ NEED FN HEADER ************************************************************/ #ifdef AR7_SAR void DDC_sar_get_sar_version(DDC_DslPriv *priv, char **pVer) { HAL_FUNCTIONS *pHalFunc; HAL_DEVICE *pHalDev; dgprintf(4, "DDC_sar_get_sar_version()\n"); pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc; pHalDev = (HAL_DEVICE *)priv->pSarHalDev; pHalFunc->Control(pHalDev, "Version", "Get", pVer); } #endif /************************************************************ NEED FN HEADER ************************************************************/ int DDC_atm_proc_version (char *buf, int count, int *eof, DDC_DslPriv *priv) { int len = 0; char dslVer[8]; char dspVer[4]; char chipsetID[32]; //CT CQ10076 - Added temporary buffer to store chipset Id #ifdef AR7_SAR char *pSarVer; int i; #endif unsigned int pdspV1, pdspV2; dslhal_api_getDslHalVersion (dslVer); len += DDA_sprintf (buf + len, "DSL HAL version: [%d.%02d.%02d.%02d]\n", dslVer[0], dslVer[1], dslVer[2], dslVer[3]); dslhal_api_getDspVersion (priv->pIhw, dspVer); len += DDA_sprintf (buf + len, "DSP Datapump version: [%d.%02d.%02d.%02d] ", dspVer[0], dspVer[1], dspVer[2], dspVer[3]); if (priv->pIhw->netService == 2) // annex B len += DDA_sprintf (buf + len, "Annex B\n"); else if (priv->pIhw->netService == 3) // annex C len += DDA_sprintf (buf + len, "Annex C\n"); else len += DDA_sprintf (buf + len, "Annex A\n"); len += DDA_sprintf (buf + len, "SAR HAL version: ["); //MK -Fixed incorrect display of SARHAL version for UR8. #ifdef AR7_SAR DDC_sar_get_sar_version (priv, &pSarVer); for (i = 0; i < 8; i++) { len += DDA_sprintf (buf + len, "%c", pSarVer[i + 7]); } #endif #ifdef UR8_SAR len += DDA_sprintf(buf + len, "%d.%d", CPSAR_DDC_MAJOR_VERSION, CPSAR_DDC_MINOR_VERSION); #endif len += DDA_sprintf (buf + len, "]\n"); DDC_sar_get_sar_firmware_version (&pdspV1, &pdspV2); len += DDA_sprintf (buf + len, "PDSP Firmware version:[%01x.%02x]\n", pdspV1, pdspV2); //CT CQ10076 - Added code to report chipset ID using proc file system DDC_atm_get_chipsetId(chipsetID); len += DDA_sprintf (buf + len, "Chipset ID: [%s]\n",chipsetID); *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ static int DDC_sar_get_stats(DDC_DslPriv *priv) { #ifdef AR7_SAR HAL_FUNCTIONS *pHalFunc; HAL_DEVICE *pHalDev; int i, j; unsigned int *pSarStat, *pStateBase; char statString[64]; int len; char *temp; dgprintf(2, "DDC_sar_get_stats\n"); //AV_DDM //priv = (Tn7AtmPrivate *)priv1; pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc; pHalDev = (HAL_DEVICE *)priv->pSarHalDev; //DDA_memset(&sarStat, 0, sizeof(sarStat)); sarStat.txErrors = 0; sarStat.rxErrors = 0; for(i=0;ilut[i].inuse) { for(j=0;j<1;j++) { len=DDA_sprintf(statString, "Stats;0;%d", priv->lut[i].chanid); statString[len]=0; dgprintf(2, "statString=%s\n",statString); pHalFunc->Control(pHalDev, statString, "Get", &pSarStat); pStateBase = pSarStat; while(pSarStat) { if((char *)*pSarStat == NULL) break; dgprintf(2, "%s\n", (char *) *pSarStat); pSarStat++; dgprintf(2, "%s\n", (char *) *pSarStat); sarStat.rxErrors += DDA_strtoul((const char *) *pSarStat, &temp, 10); pSarStat++; } DDA_free(pStateBase); } } } #endif /* AR7_SAR */ #ifdef UR8_SAR DDC_CpsarDevice *SarDev = priv->SarDev; int count; DDA_printf("UR8 SAR Stats for %d channels : \n", CPSAR_MAX_CHANNELS); /* Assuming that the number of TX chanels is the same as the RX channels. */ for(count = 0; count < CPSAR_MAX_CHANNELS; count++) { if(SarDev->txIsOpen & (1 << count)) { ddc_cpsarDDCStats(SarDev, count); } } DDA_printf("\nFor the above %d channels:\n", count); DDA_printf("Total Tx Packets sent %d \n", sarStat.txPktCnt); DDA_printf("Total Rx Packets Received %d \n", sarStat.rxPktCnt); DDA_printf("Total Tx Bytes sent %d \n", sarStat.txBytes); DDA_printf("Total Rx Bytes Received %d \n", sarStat.rxBytes); DDA_printf("Total Tx Packet Errors %d \n", sarStat.txErrors); DDA_printf("Total Rx Packet Errors %d \n", sarStat.rxErrors); #endif /* UR8_SAR */ return 0; } /************************************************************ NEED FN HEADER ************************************************************/ static int DDC_dsl_proc_snr_print (char *buf, int count, int *eof, int data, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; int i, j; int bin = (int) data; unsigned short *rxSnrPerBin; PITIDSLHW_T pIhw = priv->pIhw; /* Which bin to use */ switch (bin) { case 0: rxSnrPerBin = pIhw->AppData.rxSnrPerBin0; break; case 1: rxSnrPerBin = pIhw->AppData.rxSnrPerBin1; break; case 2: rxSnrPerBin = pIhw->AppData.rxSnrPerBin2; break; default: if(len<=limit) len += DDA_sprintf (buf + len, "\nInvalid bin selected Bin%d :\n", bin); return len; } if(len<=limit) len += DDA_sprintf (buf + len, "\nDSL Modem Rx SNR Per Bin for Bin%d :\n", bin); for (i=0; iAppData.max_ds_tones/16; i++) { for(j=0;j<16;j++) { if(len <=limit) len += DDA_sprintf (buf + len, "%04x ", (unsigned short) rxSnrPerBin[i * 16 + j]); } if(len <=limit) len += DDA_sprintf(buf+len, "\n"); } if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ //@Added SNR per bin info per customer request. 05-14-2004 int DDC_dsl_proc_snr0 (char *buf, int count, int *eof, DDC_DslPriv *priv) { return DDC_dsl_proc_snr_print(buf, count, eof, 0, priv); } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_snr1 (char *buf, int count, int *eof, DDC_DslPriv *priv) { return DDC_dsl_proc_snr_print(buf, count, eof, 1, priv); } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_snr2 (char *buf, int count, int *eof, DDC_DslPriv *priv) { return DDC_dsl_proc_snr_print(buf, count, eof, 2, priv); } /************************************************************ NEED FN HEADER ************************************************************/ //@Added bit allocation table per customer request. 05-14-2004 int DDC_dsl_proc_bit_allocation (char *buf, int count, int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; int i, j; PITIDSLHW_T pIhw = priv->pIhw; if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem US Bit Allocation:"); for(i=0; iAppData.max_us_tones; i++) { if (!(i%16)) { if(len <=limit) len += DDA_sprintf(buf+len, "\n"); } if(len <=limit) len += DDA_sprintf (buf + len, "%02x ", (unsigned char) pIhw->AppData.BitAllocTblUstrm[i]); } if(len<=limit) len += DDA_sprintf(buf+len, "\n\nDSL Modem DS Bit Allocation:\n"); for (i=0; iAppData.max_ds_tones/16; i++) { for(j=0;j<16;j++) { if(len <=limit) len += DDA_sprintf (buf + len, "%02x ", (unsigned char) pIhw->AppData.BitAllocTblDstrm[i * 16 + j]); } if(len <=limit) len += DDA_sprintf(buf+len, "\n"); } if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ #ifndef NO_ACT int DDC_dsl_proc_ds_noise(char* buf, char **start, off_t offset, int count, int *eof, void *data) { int len = 0; int limit = count - 80; int i, j; DDC_DslPriv *priv = (DDC_DslPriv *)data; PITIDSLHW_T pIhw = priv->pIhw; if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem DS Noise:\n"); for (i=0; i< 512/16; i++) { for(j=0;j<16;j++) { if(len <=limit) len += DDA_sprintf (buf + len, "%d ", (unsigned int) pIhw->AppData.dsNoise[i * 16 + j]); } if(len <=limit) len += DDA_sprintf(buf+len, "\n"); } return len; } #endif /************************************************************ NEED FN HEADER ************************************************************/ /************************************************************ NEED FN HEADER ************************************************************/ #ifdef AR7_SAR int DDC_sar_control(void *dev_info, const char *key, const char *action, void *value) { int ret_val = -1; DDC_DslPriv *priv = (DDC_DslPriv *) dev_info; if (DDA_strcmp(key, "Firmware") == 0) { if (DDA_strcmp(action, "Get") == 0) { *(int **)value = &SarPdspFirmware[0]; } ret_val=0; } if (DDA_strcmp(key, "FirmwareSize") == 0) { if (DDA_strcmp(action, "Get") == 0) { *(int *)value = sizeof(SarPdspFirmware); } ret_val=0; } if (DDA_strcmp(key, "OamLbResult") == 0) { dgprintf(2, "get looback source call back\n"); if (DDA_strcmp(action, "Set") == 0) { dgprintf(2, "oam result = %d\n", *(unsigned int *)value); oamFarLBCount[oam_type] = oamFarLBCount[oam_type] + *(unsigned int *)value; //DDA_printf("DDC_sar_control: pingStat %d, oamHdr %X result %d\n", oamPingStatus, oamAtmHdr, *(unsigned int *)value); if( oamPingStatus == OAM_PING_PENDING_RECVD) //jz: CQ#9861, this state is only set in the Receive func. { //jz: CQ#9861, it indiactes the unmatched oam ping success oamPingStatus = OAM_PING_SUCCESS; } else if(oamPingStatus == OAM_PING_PENDING) { oamPingStatus = *(unsigned int *)value; if(oamPingStatus == OAM_PING_SUCCESS) { /* record pvc */ DDC_sar_record_pvc(oamAtmHdr); } } } ret_val=0; } if (DDA_strcmp(key, "SarFreq") == 0) { if (DDA_strcmp(action, "Get") == 0) { *(int *)value = priv->sar_freq; } ret_val=0; } return(ret_val); } #endif /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_oam_generation(DDC_DslPriv *priv, int chan, int type, int vpi, int vci, int timeout) { #ifdef AR7_SAR unsigned int regv = 0; static unsigned int tag; HAL_FUNCTIONS *pHalFunc; HAL_DEVICE *pHalDev; //DDC_DslPriv *priv = (DDC_DslPriv *)privContext; unsigned int llid[4]={0xffffffff,0xffffffff,0xffffffff,0xffffffff}; char cphal_cmd[40]; dgprintf(2, "DDC_sar_oam_generation()\n"); //AV_DDM //priv = (Tn7AtmPrivate *)privContext; pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc; pHalDev = (HAL_DEVICE *)priv->pSarHalDev; if(timeout >= 5000) { if(timeout == 6000) { DDC_sar_clear_pvc_table(); return 0; } timeout = oamLbTimeout; } //jz CQ9861: Protect the SAR from multiple oam pings, returning EBUSY error code if( (oamPingStatus == OAM_PING_PENDING) || (oamPingStatus == OAM_PING_PENDING_RECVD)) { DDA_printf("DDC_sar_oam_generation: OAM Ping Dropped! pingStat %d, oamHdr %X vpi-vci: (%d,%d)\n", oamPingStatus, oamAtmHdr, vpi, vci); return -DDC_DSL_EBUSY; } pHalFunc->Control(pHalDev,"OamLbTimeout", "Set", &timeout); /* calculate atm header */ oamAtmHdr = DDC_sar_atm_header(vpi,vci); if(chan == ATM_NO_DMA_CHAN) { //DDC_sar_unmatched_oam_generation(priv, vpi, vci, type); //return 0; if(vci==0) { oamPingStatus = OAM_PING_FAILED; return -DDC_DSL_EINVAL; //jz: Now returning error code instead of success code 0; } chan = RESERVED_OAM_CHANNEL; //15; /* config the atm header */ //pHalFunc->Control(pHalDev,"TxVc_AtmHeader.15", "Set", &oamAtmHdr); DDA_sprintf( cphal_cmd, "TxVc_AtmHeader.%d", RESERVED_OAM_CHANNEL); pHalFunc->Control(pHalDev, cphal_cmd, "Set", &oamAtmHdr); } oam_type = type; regv = (0xff & chan); switch(type) { case 0: regv |= (1<<12); //f5 end dgprintf(2, "f5 loop back\n"); break; case 1: regv |= (1<<13); // f4 end break; case 2: regv |= (1<<14); //f5 seg break; case 3: regv |= (1<<15); //f4 seg break; default: break; } oamPingStatus = OAM_PING_PENDING; pHalFunc->OamLoopbackConfig(pHalDev, regv, llid, tag); tag++; #endif #ifdef UR8_SAR unsigned int regv = 0; static unsigned int tag; //HAL_FUNCTIONS *pHalFunc; //HAL_DEVICE *pHalDev; //DDC_DslPriv *priv = (DDC_DslPriv *)privContext; unsigned int llid[4]={0xffffffff,0xffffffff,0xffffffff,0xffffffff}; dgprintf(2, "DDC_sar_oam_generation()\n"); //AV_DDM //priv = (Tn7AtmPrivate *)privContext; //pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc; //pHalDev = (HAL_DEVICE *)priv->pSarHalDev; #if 0 if(timeout >= 5000) { if(timeout == 6000) { DDC_sar_clear_pvc_table(); return 0; } timeout = oamLbTimeout; } #endif #if 0 //jz CQ9861: Protect the SAR from multiple oam pings, returning EBUSY error code if( (oamPingStatus == OAM_PING_PENDING) || (oamPingStatus == OAM_PING_PENDING_RECVD)) { DDA_printf("DDC_sar_oam_generation: OAM Ping Dropped! pingStat %d, oamHdr %X vpi-vci: (%d,%d)\n", oamPingStatus, oamAtmHdr, vpi, vci); return -DDC_DSL_EBUSY; } #endif //DDC_cpsarControl(priv->SarDev,"OamLbTimeout", "Set", &timeout); if (priv->SarDev->state == DDC_OPENED) { //*((volatile unsigned *)(0xA31302E0 + 4)) = ((priv->sar_freq/1000) * timeout); priv->SarDev->scratchpad_regs->PDSP_CH_RAM[5].PDSP_General_Use[1] = ((priv->sar_freq/1000) * timeout); } /* calculate atm header */ oamAtmHdr = DDC_sar_atm_header(vpi,vci); //printk("DDC_sar_oam_generation, chan=%d, oamHdr=%08x\n", chan, oamAtmHdr); if(chan == ATM_NO_DMA_CHAN) { //DDC_sar_unmatched_oam_generation(priv, vpi, vci, type); //return 0; if(vci==0) { oamPingStatus = OAM_PING_FAILED; return -DDC_DSL_EINVAL; //jz: Now returning error code instead of success code 0; } chan = RESERVED_OAM_CHANNEL; //15; /* config the atm header */ //pHalFunc->Control(pHalDev,"TxVc_AtmHeader.15", "Set", &oamAtmHdr); //DDA_sprintf( cphal_cmd, "TxVc_AtmHeader.%d", RESERVED_OAM_CHANNEL); //DDC_cpsarControl(priv->SarDev, cphal_cmd, "Set", &oamAtmHdr); if (priv->SarDev->state == DDC_OPENED) { //printk("oamAtmHdr=%08x\n", oamAtmHdr); #if 0 priv->SarDev->scratchpad_regs->AtmHeader[chan] = oamAtmHdr; #else priv->SarDev->scratchpad_regs->PDSP_CH_RAM[chan].AAL5_Tx_State[6] = oamAtmHdr; #endif } } oam_type = type; regv = (0xff & chan); switch(type) { case 0: regv |= (1<<12); //f5 end dgprintf(2, "f5 loop back\n"); break; case 1: regv |= (1<<13); // f4 end break; case 2: regv |= (1<<14); //f5 seg break; case 3: regv |= (1<<15); //f4 seg break; default: break; } oamPingStatus = OAM_PING_PENDING; cpsarOamLoopbackConfig(priv->SarDev, regv, llid, tag); tag++; #if 0 DDA_printf("DDC_sar_oam_generation: pingStat %d, oamHdr %X vpi-vci: (%d,%d), chan(%d), type(%d)\n", oamPingStatus, oamAtmHdr, vpi, vci, chan, type); #endif #endif return 0; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_proc_oam_ping(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; unsigned int oam_ps = oamPingStatus; if( oam_ps == OAM_PING_PENDING_RECVD ) oam_ps = OAM_PING_PENDING; //jz CQ9861: Only export the PENDING status, not internal state len += DDA_sprintf(buf+len, "%d\n", oam_ps); //oamPingStatus); if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_proc_pvc_table(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int i; int limit = count - 80; for(i = 0; i < 16; i++) { if(pvc_result[i].bInUse) { len += DDA_sprintf(buf+len, "%d,%d\n", pvc_result[i].vpi,pvc_result[i].vci); } else { len += DDA_sprintf(buf+len, "0,0\n"); } } if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_proc_sar_stat(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; int limit = count - 80; #ifdef AR7_SAR int i, j, k; int stat_len; char statString[32]; unsigned int *pStateBase, *pSarStat; HAL_FUNCTIONS *pHalFunc; HAL_DEVICE *pHalDev; int dBytes; pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc; pHalDev = (HAL_DEVICE *)priv->pSarHalDev; len += DDA_sprintf(buf+len, "SAR HAL Statistics"); for(i = 0; i < MAX_DMA_CHAN; i++) { if(priv->lut[i].inuse) { if(len <= limit) len += DDA_sprintf(buf+len, "\nChannel %d:\n",priv->lut[i].chanid); k=0; for(j = 0; j < 4; j++) { stat_len =DDA_sprintf(statString, "Stats;%d;%d", j,priv->lut[i].chanid); statString[stat_len]=0; pHalFunc->Control(pHalDev, statString, "Get", &pSarStat); pStateBase = pSarStat; while(pSarStat) { if((char *)*pSarStat == NULL) break; if(len<=limit) { dBytes = DDA_sprintf(buf+len, "%s: ",(char *) *pSarStat); len += dBytes; k += dBytes; } pSarStat++; if(len<=limit) { dBytes = DDA_sprintf(buf+len, "%s; \n",(char *) *pSarStat); len += dBytes; k += dBytes; } pSarStat++; if(k > 60) { k=0; if(len<=limit) len += DDA_sprintf(buf+len, "\n"); } } DDA_free(pStateBase); } } } #endif /* AR7_SAR */ #ifdef UR8_SAR DDC_sar_get_stats(priv); #endif /* UR8_SAR */ if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } /************************************************************ NEED FN HEADER ************************************************************/ static void DDC_sar_get_sar_firmware_version(unsigned int *pdsp_version_ms, unsigned int *pdsp_version_ls) { #ifdef AR7_SAR *pdsp_version_ms = (SarPdspFirmware[9]>>20) & 0xF; *pdsp_version_ls = (SarPdspFirmware[9]>>12) & 0xFF; #endif #ifdef UR8_SAR *pdsp_version_ms = (SarPdspFirmware[9]>>16) & 0xF; *pdsp_version_ls = (SarPdspFirmware[9]>>8) & 0xFF; #endif return; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_tx_flush(DDC_DslPriv *priv, int chan, int queue, int skip) { #ifdef AR7_SAR HAL_FUNCTIONS *pHalFunc; HAL_DEVICE *pHalDev; int value=0; dgprintf(4, "DDC_sar_tx_flush()\n"); //DDA_printf("DDC_sar_tx_flush\n"); pHalFunc = (HAL_FUNCTIONS *)priv->pSarHalFunc; pHalDev = (HAL_DEVICE *)priv->pSarHalDev; value = (skip << 16) | (queue << 8) | (chan); pHalFunc->Control(pHalDev, "TxFlush", "Set", &value); #endif #ifdef UR8_SAR cpsarFlushTxChannel(priv->SarDev, chan, NULL); #endif return 0; } /************************************************************ NEED FN HEADER ************************************************************/ void DDC_dsl_chng_modulation(DDC_DslPriv *priv, void* data) { unsigned char tmp1[64], tmp2[64], *p; int k, m; PITIDSLHW_T pIhw = priv->pIhw; if(!DDA_strcmp(data, "trellison")) { //DDA_printf("set Trellis on\n"); dslhal_api_setTrellisFlag(pIhw, 1); pIhw->AppData.trellis = 1; dslhal_api_sendQuiet(pIhw); return; } if(!DDA_strcmp(data, "trellisoff")) { //DDA_printf("set Trellis off\n"); dslhal_api_setTrellisFlag(pIhw, 0); pIhw->AppData.trellis = 0; dslhal_api_sendQuiet(pIhw); return; } // pair selection if(!DDA_strcmp(data, "innerpair")) { //DDA_printf("set inner pair\n"); dslhal_api_selectInnerOuterPair(pIhw, 0); dslhal_api_sendQuiet(pIhw); return; } if(!DDA_strcmp(data, "outerpair")) { //DDA_printf("set outer pair\n"); dslhal_api_selectInnerOuterPair(pIhw, 1); dslhal_api_sendQuiet(pIhw); return; } //@Send modem to Idle. if(!DDA_strcmp(data, "idle")) { //DDA_printf("send idle\n"); dslhal_api_sendIdle(pIhw); return; } //@Send modem to retrain. if(!DDA_strcmp(data, "retrain")) { //DDA_printf("retrain\n"); dslhal_api_sendQuiet(pIhw); return; } //@reset modem. if(!DDA_strcmp(data, "reset")) { dslhal_api_dslShutdown(priv->pIhw); dslhal_api_dslStartup(&priv->pIhw); return; } //fine gain if(!DDA_strcmp(data, "gainctlon")) { //DDA_printf("gain control on\n"); dslhal_api_setFineGainCtrl(pIhw, 1); dslhal_api_sendQuiet(pIhw); return; } if(!DDA_strcmp(data, "gainctloff")) { //DDA_printf("gain control off\n"); dslhal_api_setFineGainCtrl(pIhw, 0); dslhal_api_sendQuiet(pIhw); return; } //dgas polarity if(!DDA_strcmp(data, "gaspolarityon")) { DDA_printf("gaspolarityon\n"); dslhal_api_configureDgaspLpr(pIhw, 1, 1); dslhal_api_configureDgaspLpr(pIhw, 0, 1); return; } if(!DDA_strcmp(data, "gaspolarityoff")) { DDA_printf("gaspolarityoff\n"); dslhal_api_configureDgaspLpr(pIhw, 1, 1); dslhal_api_configureDgaspLpr(pIhw, 0, 0); return; } if(!DDA_strcmp(data, "losalarmon")) { DDA_printf("losalarmon\n"); dslhal_api_disableLosAlarm(pIhw, 0); return; } if(!DDA_strcmp(data, "losalarmoff")) { DDA_printf("losalarmoff\n"); dslhal_api_disableLosAlarm(pIhw, 1); return; } if(!DDA_strcmp(data, "bitswapon")) { dslhal_api_usBitSwap(pIhw, 0, 1/*enabled*/); dslhal_api_dsBitSwap(pIhw, 0, 1/*enabled*/); dslhal_api_sendQuiet(pIhw); return; } if(!DDA_strcmp(data, "bitswapoff")) { dslhal_api_usBitSwap(pIhw, 0, 0/*disabled*/); dslhal_api_dsBitSwap(pIhw, 0, 0/*disabled*/); dslhal_api_sendQuiet(pIhw); return; } if(!DDA_strcmp(data, "rmsgsra")) { int i; DDA_printf("rMsgsRA = 0x"); for (i=0; i<12; i++) { DDA_printf("%02x ", pIhw->AppData.rMsgRa[i]); } DDA_printf("\n"); } p=(unsigned char *)data; // fine gain for(k=0;k<5;k++) { tmp1[k]=p[k]; } tmp1[k]=0; if(!DDA_strcmp(tmp1, "gainv")) { unsigned value; for(m=0;m<4;m++) { tmp2[m]=p[m+k]; } tmp2[m]=0; //DDA_printf("name =%s, %d\n", tmp1, DDA_atoh(tmp2)); value = (unsigned)DDA_atoh(tmp2); if (value) { dslhal_api_setFineGainValue(priv->pIhw, value); } return; } // interleave depth for(k=0;k<6;k++) { tmp1[k]=p[k]; } tmp1[k]=0; if(!DDA_strcmp(tmp1, "idepth")) { for(m=0;m<1;m++) { tmp2[m]=p[m+k]; } tmp2[m]=0; DDA_printf("name =%s, %d\n", tmp1, DDA_atoi(tmp2)); dslhal_api_setMaxInterleaverDepth(pIhw, DDA_atoi(tmp2)); dslhal_api_sendQuiet(pIhw); return; } // carrier per bit for(k=0;k<13;k++) { tmp1[k]=p[k]; } tmp1[k]=0; if(!DDA_strcmp(tmp1, "carrierperbit")) { for(m=0;m<4;m++) { tmp2[m]=p[m+k]; } tmp2[m]=0; //DDA_printf("name =%s, %d\n", tmp1, DDA_atoh(tmp2)); dslhal_api_setMaxBitsPerCarrierUpstream(priv->pIhw, DDA_atoh(tmp2)); dslhal_api_sendQuiet(pIhw); return; } p=(unsigned char *)data; if(p[0]==0x58 || p[0]==0x78) //"X" or "x" { unsigned int dAddr; //DDA_printf("main address = 0x%x\n", pIhw->pmainAddr); for(k=0;k<8;k++) { tmp1[k]=p[k+1]; } tmp1[k]=0; dAddr=DDA_atoh(tmp1); DDA_printf("address =0x%x\n", DDA_atoh(tmp1)); if(p[k+1]==0x4c || p[k+1]==0x6c) { unsigned int dVal; k++; for(m=0;m<8;m++) { tmp2[m]=p[m+k+1]; } tmp2[m]=0; dVal=DDA_atoh(tmp2); DDA_printf("writing value =0x%x\n",dVal); dslhal_support_blockWrite((void *)&(dVal), (void *)dAddr, 4); } else { dslhal_support_blockRead((void *)dAddr, &priv->dslReg, 4); DDA_printf("dslReg=0x%x\n", priv->dslReg); } } p=(unsigned char *)data; if(p[0]==0x59 || p[0]==0x79) //"Y" or "y" { for(k=0;k<8;k++) { tmp1[k]=p[k+1]; if(p[k+1]== 0) break; } tmp1[k]=0; DDA_printf("write mail box cmd =%d\n", DDA_atoi(tmp1)); dslhal_support_writeHostMailbox(pIhw, DDA_atoi(tmp1), 0, 0, 0); } /* * The command is to set the modulation. */ if(!DDC_dsl_set_modulation(priv, data, TRUE)) { dslhal_api_sendQuiet(pIhw); return; } } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_atm_header(int vpi, int vci) { union { unsigned char byte[4]; unsigned int dword; }atm_h; int itmp = 0; //vci itmp = vci &0xf; atm_h.byte[0] = 0; atm_h.byte[0] |= (itmp << 4); atm_h.byte[1] = ((vci & 0xff0) >> 4); atm_h.byte[2] = 0; atm_h.byte[2] |= ((vci & 0xf000) >>12);; atm_h.byte[2] |= ((vpi & 0xf) << 4); atm_h.byte[3] = 0; atm_h.byte[3] = ((vpi & 0xff0) >> 4); /* EP20061120: ATM header is endian-dependent */ atm_h.dword = BYTE_SWAP32(atm_h.dword); return atm_h.dword; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_proc_train_mode_export (char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; char *cp = buf; int i = 0; static int ctr = 0; PITIDSLHW_T pIhw = priv->pIhw; typedef struct { unsigned char mode_name[20]; unsigned int mode_value; } dsl_modes_t; /* *INDENT-OFF* */ /* AV: Relocated code for performance. */ dsl_modes_t dsl_modes[] = { {"NO_MODE", NO_MODE}, {"ADSL_G.dmt", OLD_TRAINING_VAL_GDMT}, {"ADSL_G.lite", GLITE_MODE}, {"ADSL_G.dmt.bis", ADSL2_MODE}, {"ADSL_G.dmt.bis_DELT", ADSL2_DELT}, {"ADSL_2plus", ADSL2_PLUS}, {"ADSL_2plus_DELT", ADSL2_PLUS_DELT}, {"ADSL_re-adsl", READSL_MODE}, {"ADSL_re-adsl_DELT", READSL_PLUS_DELT}, {"ADSL_ANSI_T1.413", OLD_TRAINING_VAL_T1413}, {"MULTI_MODE", OLD_TRAINING_VAL_MMODE}, {"ADSL_G.dmt.bis_AnxI", 0}, // ADSL2 AnxI 0x0100 {"ADSL_G.dmt.bis_AnxJ", 0}, // ADSL2 AnxJ 0x0200 {"ADSL_G.dmt.bis_AnxM", ADSL2_ANNEX_M}, // ADSL2 AnxM 0x0400 {"ADSL_2plus_AnxI", 0}, // ADSL2+ AnxI 0x0800 {"ADSL_2plus_AnxJ", 0}, // ADSL2+ AnxJ 0x1000 {"ADSL_2plus_AnxM", ADSL2_PLUS_ANNEX_M}, // ADSL2+ AnxM 0x2000 {"G.shdsl", 0}, {"IDSL", 0}, {"HDSL", 0}, {"SDSL", 0}, {"VDSL", 0} }; /* Offsets in the dsl_modes structure */ #define G_DMT_OFFSET 1 #define G_LITE_OFFSET 2 #define G_DMT_BIS_OFFSET 3 #define G_DMT_BIS_DELT_OFFSET 4 #define ADSL_2PLUS_OFFSET 5 #define ADSL_2PLUS__DELT_OFFSET 6 #define ADSL_READSL_OFFSET 7 #define ADSL_READSL_DELT_OFFSET 8 #define T1413_OFFSET 9 #define MMODE_OFFSET 10 #define ADSL2_ANNEXM_OFFSET 13 #define ADSL2PLUS_ANNEXM_OFFSET 16 /* *INDENT-ON* */ int num_entries = sizeof (dsl_modes) / sizeof (dsl_modes[0]); /* Check to see if we need to use the new bit mode scheme */ if (pIhw->AppData.useBitField) { dsl_modes[G_DMT_OFFSET].mode_value = NEW_TRAINING_VAL_GDMT; dsl_modes[T1413_OFFSET].mode_value = NEW_TRAINING_VAL_T1413; dsl_modes[MMODE_OFFSET].mode_value = NEW_TRAINING_VAL_MMODE; } /* Check to see if we are in POTS or ISDN mode. */ if (pIhw->netService == 2) // 1=POTS, 2=ISDN { dsl_modes[ADSL2_ANNEXM_OFFSET].mode_value = 0; dsl_modes[ADSL2PLUS_ANNEXM_OFFSET].mode_value = 0; } /* * Change value, since we don't support these modes on this chip */ if (!DDC_atm_read_can_support_adsl2()) { dsl_modes[ADSL_2PLUS_OFFSET].mode_value = 0; dsl_modes[ADSL_2PLUS__DELT_OFFSET].mode_value = 0; dsl_modes[ADSL_READSL_OFFSET].mode_value = 0; dsl_modes[ADSL_READSL_DELT_OFFSET].mode_value = 0; } if(len <= count) { for (i = ctr; ((i < num_entries)&& (len <= count)) ; i++) { /* * Write the current string only if we can fit it into the buffer */ if((DDA_strlen(dsl_modes[i].mode_name) + 6 + len) <= count) { len += DDA_snprintf(cp+len, (count - len), "%s\t\t\t%#x\n", dsl_modes[i].mode_name, dsl_modes[i].mode_value); } else break; } } /* * Data was completely written */ if (i >= num_entries) { /* * We are done with this */ *eof = DDC_DSL_FINISHED; ctr = 0; } else { /* * We have not been able to write the complete data, and we have to nul * terminate the buffer. */ *(cp + len) = '\0'; /* * Save the value of the counter for the next read for the rest of the * data. */ ctr = i; } return len; } /************************************************************ NEED FN HEADER ************************************************************/ #ifndef NO_ADV_STATS int DDC_dsl_proc_SNRpsds(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; PITIDSLHW_T pIhw = priv->pIhw; int limit = count - 80; int i, retval; unsigned char SNRpsds[512]; if(len <= limit) len += DDA_sprintf(buf+len, "\nDSL Modem SNRpsds:"); retval = dslhal_api_getSNRpsds(pIhw, SNRpsds, 1); if (retval) { DDA_printf("dslhal_api_getSNRpsds failed with %d\n", retval); return len; } for (i=0; iAppData.max_ds_tones; i++) { if (!(i%16)) { if(len <=limit) len += DDA_sprintf(buf+len, "\n"); } if(len <=limit) len += DDA_sprintf(buf+len, "%d ", (unsigned char)SNRpsds[i]); } if(len <=limit) len += DDA_sprintf(buf+len, "\n"); if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } #endif /************************************************************ NEED FN HEADER ************************************************************/ #ifndef NO_ADV_STATS int DDC_dsl_proc_QLNpsds(char* buf, int count,int *eof, DDC_DslPriv *priv) { int len = 0; PITIDSLHW_T pIhw = priv->pIhw; int limit = count - 80; unsigned char QLNpsds[512]; int i, retval; if(len<=limit) len += DDA_sprintf(buf+len, "\nDSL Modem QLNpsds:"); // call API instead of access internal buf directly retval = dslhal_api_getQLNpsds(pIhw, QLNpsds, 0); if (retval) { DDA_printf("dslhal_api_getQLNpsds failed with %d\n", retval); return len; } for (i = 0; i < pIhw->AppData.max_ds_tones; i++) { if (!(i%16)) { if(len <=limit) len += DDA_sprintf(buf+len, "\n"); } if(len <=limit) len += DDA_sprintf(buf+len, "%d ", (unsigned char)QLNpsds[i]); } if(len <=limit) len += DDA_sprintf(buf+len, "\n"); if(len <=limit) *eof = DDC_DSL_FINISHED; return len; } #endif /** * \brief DDC_dsl_handle_interrupt * * This function handles DSL interrupt */ int DDC_dsl_handle_interrupt(DDC_DslPriv *dslPrivP) { PITIDSLHW_T pIhw = dslPrivP->pIhw; dgprintf(4, "DDC_dsl_handle_dsl_interrupt()\n"); if(pIhw) { int intsrc = 0; #ifdef YAMUNA dslhal_api_acknowledgeInterrupt_entry(pIhw); #else intsrc = dslhal_api_acknowledgeInterrupt(pIhw); #endif if (dslPrivP->nohost_flag) return 0; dslhal_api_handleTrainingInterrupt(pIhw, intsrc); if(pIhw->lConnected == LINE_CONNECTED) { if(dslPrivP->dslInSync == 0) { DDA_printf("DSL in Sync\n"); dslPrivP->lConnected = 1; dslhal_api_gatherStatistics(pIhw); //AV_26 //#if 0 #if defined (CONFIG_LED_MODULE) || defined (CONFIG_MIPS_AVALANCHE_COLORED_LED) if(dslPrivP->hnd_LED_0) DDA_Led_func(DDC_DEF_ADSL_SYNC); led_on = DDC_DEF_ADSL_SYNC; #endif //#endif /* * add auto margin retrain */ //if(pIhw->AppData.TrainedMode < 5) if (!(pIhw->AppData.TrainedMode & (DDC_DSL_ADSL2PLUS_MASKS|DDC_DSL_ADSL2_MASKS)) ) { if (dslPrivP->bMarginRetrainEnable) { unsigned char *cMsgRa; short margin; cMsgRa = &(pIhw->AppData.cMsgRa[0]); margin = *(unsigned short *)&cMsgRa[4]; margin = (margin >> 6) & 0x3f; if(margin & 0x20) // highest bit is 1 { margin = -(margin & 0x1f); } // DDA_printf("margin = %d, cmsg-ra = %02x %02x %02x %02x %02x // %02x\n", margin, // cMsgRa[0],cMsgRa[1],cMsgRa[2],cMsgRa[3],cMsgRa[4],cMsgRa[5]); dslhal_api_setMarginThreshold (pIhw, margin * 2); /* DSL margin * is in * 0.5db */ } } else if(pIhw->AppData.TrainedMode == ADSL2_PLUS_ANNEX_M) { /* Higher Pacing rate is required for AnnexM 2+ mode. */ if(dslPrivP->def_sar_inter_pace != ANNEX_M_2PLUS_PACEMAX_VAL) { DDA_request_interrupt_pacing(TI_SAR_INT, ANNEX_M_2PLUS_PACEMAX_VAL); } } } dslPrivP->dslInSync = 1; } else { if(dslPrivP->dslInSync == 1) { dslPrivP->dslInSync = 0; dslPrivP->lConnected = 0; //up(&adsl_sem_overlay); DDA_printf("DSL out of sync\n"); } //AV_26 //#if 0 #if defined (CONFIG_LED_MODULE) || defined (CONFIG_MIPS_AVALANCHE_COLORED_LED) if(pIhw->AppData.bState == RSTATE_IDLE) { if(led_on != DDC_DEF_ADSL_IDLE) { if(dslPrivP->hnd_LED_0) DDA_Led_func(DDC_DEF_ADSL_IDLE); led_on = DDC_DEF_ADSL_IDLE; } } else { if(led_on != DDC_DEF_ADSL_TRAINING) { if(dslPrivP->hnd_LED_0) DDA_Led_func(DDC_DEF_ADSL_TRAINING); led_on = DDC_DEF_ADSL_TRAINING; } } #endif //#endif } if (pIhw->AppData.clear_eoc) { DDC_dsl_clear_eoc_receive(dslPrivP); pIhw->AppData.clear_eoc = 0; } #ifdef YAMUNA dslhal_api_acknowledgeInterrupt_exit(pIhw); #endif } return 0; } #ifdef AR7_SAR /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_handle_interrupt(DDC_DslPriv *priv, int irq, int *more) { int rc = 0; int (*halIsr)(HAL_DEVICE *halDev, int *work); halIsr = priv->halIsr; rc = halIsr((HAL_DEVICE *)priv->pSarHalDev, more); /* Do EOI if the interrupt was from a valid source. */ if(rc != EC_VAL_INTERRUPT_NOT_FOUND) { #ifdef CPATM_TASKLET_MODE if(*more == 0) { ((HAL_FUNCTIONS *)priv->pSarHalFunc)->PacketProcessEnd((HAL_DEVICE *)priv->pSarHalDev); } #else ((HAL_FUNCTIONS *)priv->pSarHalFunc)->PacketProcessEnd((HAL_DEVICE *)priv->pSarHalDev); #endif } return rc; } #endif /* AR7_SAR */ #ifdef UR8_SAR /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_handle_tx_process(DDC_DslPriv *priv, int irq, int *more) { int rc; int tx_queue = irq - (CPPI4_MIN_TX_INT_LINE); //AV: Service Max is not used per channel, it is assumed to be same for all channels. int pktsToBeProcessed = priv->sarTxMax; rc = cpsarTxPktProcess (priv->SarDev, tx_queue, pktsToBeProcessed, more); return rc; } #endif /* UR8_SAR */ #ifdef UR8_SAR /************************************************************ NEED FN HEADER ************************************************************/ int DDC_sar_handle_rx_process(DDC_DslPriv *priv, int irq, int *more) { int rc; int rx_queue = irq - (CPPI4_MIN_RX_INT_LINE); //AV: Service Max is not used per channel, it is assumed to be same for all channels. int pktsToBeProcessed = priv->sarRxMax; rc = cpsarRxPktProcess (priv->SarDev, rx_queue, pktsToBeProcessed, more); return rc; } #endif /* UR8_SAR */ /************************************************************ NEED FN HEADER ************************************************************/ static int DDC_sar_get_near_end_loopback_count(unsigned int *pF4count, unsigned int *pF5count) { unsigned int f4c, f5c; f4c = *(volatile unsigned int *)SAR_PDSP_OAM_F4LB_COUNT_REG_ADDR; f5c = *(volatile unsigned int *)SAR_PDSP_OAM_F5LB_COUNT_REG_ADDR; *pF4count = f4c; *pF5count = f5c; return 0; } /************************************************************ NEED FN HEADER ************************************************************/ //#define PRTK_UNWANTED_CELLS_2_HOST 1 #ifdef AR7_SAR int DDC_sar_process_unmatched_oam(FRAGLIST *frag_list, unsigned int frag_count, unsigned int packet_size, unsigned int mode) { FRAGLIST *local_list; unsigned int i; unsigned int atmHdr; local_list = frag_list; for(i = 0; i < frag_count; i++) { DDC_atm_data_invalidate(local_list->data, (int)local_list->len); local_list ++; } local_list = frag_list; #ifdef PRTK_UNWANTED_CELLS_2_HOST DDA_printf("DDC_sar_process_unmatched_oam - (ALL)cells: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, *(unsigned int *)frag_list->data, oamAtmHdr); #endif //PRTK_UNWANTED_CELLS_2_HOST if((mode>>31)) /*vci, vpi is attached */ { atmHdr = *(unsigned int *)frag_list->data; //DDA_printf("DDC_sar_process_unmatched_oam: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, atmHdr, oamAtmHdr); //DDC_sar_record_pvc(atmHdr); jz: moved down for only receiving the expected oam pings, CQ#9861 if(atmHdr & 0x8) //oam cell { #ifdef PRTK_UNWANTED_CELLS_2_HOST DDA_printf("DDC_sar_process_unmatched_oam - (OAM)cells: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, *(unsigned int *)frag_list->data, oamAtmHdr); #endif //PRTK_UNWANTED_CELLS_2_HOST atmHdr &= 0xfffffff0; if(atmHdr == oamAtmHdr) { #ifdef PRTK_UNWANTED_CELLS_2_HOST DDA_printf("DDC_sar_process_unmatched_oam - (Response OAM)cells: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, atmHdr, oamAtmHdr); #endif //PRTK_UNWANTED_CELLS_2_HOST DDC_sar_record_pvc(atmHdr); //jz: moved here for CQ#9861 if(oamPingStatus == OAM_PING_PENDING) { // oamPingStatus = OAM_PING_SUCCESS; oamPingStatus = OAM_PING_PENDING_RECVD; //jz: CQ#9861: received the unconfigured VCC oam pings oamFarLBCount[oam_type] = oamFarLBCount[oam_type] + 1; } return 0; } } #ifdef PRTK_UNWANTED_CELLS_2_HOST else{ DDA_printf("---------DBG-ERR: DDC_sar_process_unmatched_oam - NOT AN UNMATCHED OAM Cell!!!------------\n"); } #endif //PRTK_UNWANTED_CELLS_2_HOST } return 0; } #endif /* AR7_SAR */ #ifdef UR8_SAR //Note : Assume that the data invalidation has already been done before this call, and ATM header is attached. int DDC_sar_process_unmatched_oam(unsigned char *data, unsigned int packet_size) { unsigned int atmHdr; #ifdef PRTK_UNWANTED_CELLS_2_HOST DDA_printf("DDC_sar_process_unmatched_oam - (ALL)cells: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, *(unsigned int *)frag_list->data, oamAtmHdr); #endif //PRTK_UNWANTED_CELLS_2_HOST atmHdr = *(unsigned int *)data; //DDA_printf("DDC_sar_process_unmatched_oam: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, atmHdr, oamAtmHdr); //DDC_sar_record_pvc(atmHdr); jz: moved down for only receiving the expected oam pings, CQ#9861 if(atmHdr & 0x8) //oam cell { #ifdef PRTK_UNWANTED_CELLS_2_HOST DDA_printf("DDC_sar_process_unmatched_oam - (OAM)cells: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, *(unsigned int *)frag_list->data, oamAtmHdr); #endif //PRTK_UNWANTED_CELLS_2_HOST atmHdr &= 0xfffffff0; if(atmHdr == oamAtmHdr) { #ifdef PRTK_UNWANTED_CELLS_2_HOST DDA_printf("DDC_sar_process_unmatched_oam - (Response OAM)cells: pingStat %d, atmHdr %X, oamHdr %X \n", oamPingStatus, atmHdr, oamAtmHdr); #endif //PRTK_UNWANTED_CELLS_2_HOST DDC_sar_record_pvc(atmHdr); //jz: moved here for CQ#9861 if(oamPingStatus == OAM_PING_PENDING) { // oamPingStatus = OAM_PING_SUCCESS; oamPingStatus = OAM_PING_PENDING_RECVD; //jz: CQ#9861: received the unconfigured VCC oam pings oamFarLBCount[oam_type] = oamFarLBCount[oam_type] + 1; } return 0; } } #ifdef PRTK_UNWANTED_CELLS_2_HOST else{ DDA_printf("---------DBG-ERR: DDC_sar_process_unmatched_oam - NOT AN UNMATCHED OAM Cell!!!------------\n"); } #endif //PRTK_UNWANTED_CELLS_2_HOST return 0; } #endif /* UR8_SAR */ /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_generic_read(DDC_DslPriv * priv, int offsetnum, int *offset, unsigned* value) { PITIDSLHW_T pIhw = priv->pIhw; dslhal_api_dspInterfaceRead (pIhw, (unsigned int) pIhw->pmainAddr, offsetnum, (unsigned int *) offset, (unsigned char *) value, 4); //DDA_printf("value = %d\n", dslReg); return 0; } /************************************************************ NEED FN HEADER ************************************************************/ int DDC_dsl_generic_write(DDC_DslPriv * priv, int offsetnum, int *offset, unsigned data) { PITIDSLHW_T pIhw = priv->pIhw; dslhal_api_dspInterfaceWrite (pIhw, (unsigned int) pIhw->pmainAddr, offsetnum, (unsigned int *) offset, (unsigned char *) &data, 4); return 0; } /** * \brief DDC_atm_lut_find * * Find a TX DMA channel that matches a vpi/vci pair * * @param vpi VPI * @param vci VCI * @return DMA channel number */ int DDC_atm_lut_find (DDC_DslPriv *priv, short vpi, int vci) { int i; //AV_DDM //Tn7AtmPrivate *priv; //priv = (Tn7AtmPrivate *) mydev->dev_data; if (vci == 0) // find first vpi channel { for (i = 0; i < MAX_DMA_CHAN; i++) { if ((priv->lut[i].vpi == vpi)) return i; } } dgprintf (4, "vpi=%d, vci=%d\n", vpi, vci); for (i = 0; i < MAX_DMA_CHAN; i++) { if ((priv->lut[i].vpi == vpi) && (priv->lut[i].vci == vci)) return i; } return ATM_NO_DMA_CHAN; } /** * \brief DDC_atm_lut_clear * * Clear one TX DMA channel * * @param chan Channel number */ int DDC_atm_lut_clear (DDC_DslPriv *priv, int chan) { //Tn7AtmPrivate *priv; //priv = (Tn7AtmPrivate *) vcc->dev->dev_data; DDA_memset (&priv->lut[chan], 0, sizeof (priv->lut[chan])); return 0; } /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * Function: int DDC_atm_walk_vccs(struct atm_dev *dev, short *vcc, int *vci) * * Description: retrieve VPI/VCI for connection * *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ //AV_26 #if 0 int DDC_atm_walk_vccs (struct atm_vcc *vcc, short *vpi, int *vci) { struct atm_vcc *walk; /* * find a free VPI */ if (*vpi == ATM_VPI_ANY) { for (*vpi = 0, walk = vcc->dev->vccs; walk; walk = walk->next) { if ((walk->vci == *vci) && (walk->vpi == *vpi)) { (*vpi)++; walk = vcc->dev->vccs; } } } /* * find a free VCI */ if (*vci == ATM_VCI_ANY) { for (*vci = ATM_NOT_RSV_VCI, walk = vcc->dev->vccs; walk; walk = walk->next) { if ((walk->vpi = *vpi) && (walk->vci == *vci)) { *vci = walk->vci + 1; walk = vcc->dev->vccs; } } } return 0; } #endif /** * \brief DDC_atm_walk_lut * * Find a TX DMA channel that is not used * * @return DMA channel number */ int DDC_atm_walk_lut (DDC_DslPriv * priv) { int i; for (i = 0; i < MAX_DMA_CHAN; i++) { if (!priv->lut[i].inuse) { return i; /* return available dma channel number */ } } return ATM_NO_DMA_CHAN; /* no tx dma channels available */ } /** * \brief DDC_atm_set_lut * * Initialize one TX DMA channel * * @param vcc VCC * @param vpi VPI * @param vci VCI * @param chan Channel number * @return 0: Success * -1: Failure */ int DDC_atm_set_lut (DDC_DslPriv * priv, void *vcc, int vpi, int vci, int chan) { int retval; if (!priv->lut[chan].inuse) { priv->lut[chan].vpi = vpi; priv->lut[chan].vci = vci; priv->lut[chan].chanid = chan; priv->lut[chan].inuse = 1; /* claim the channel */ priv->lut[chan].vcc = vcc; priv->lut[chan].bClosing = 0; priv->lut[chan].ready = 0; //priv->lut[chan].tx_total_bufs = TX_BUFFER_NUM; //priv->lut[chan].tx_used_bufs[0] = 0; //priv->lut[chan].tx_used_bufs[1] = 0; retval = 0; } else retval = -1; /* no tx dma channels available */ return retval; } #if 0 /*ep*/ /************************************************************ NEED FN HEADER ************************************************************/ int DDC_atm_device_connect_status (DDC_DslPriv *priv, int state) { dgprintf (5, "DDC_atm_device_connect_status()\n"); priv->lConnected = state; dgprintf (5, "priv1->lConnected=%d\n", priv->lConnected); return 0; } #endif /************************************************************ NEED FN HEADER ************************************************************/ static void DDC_sar_record_pvc(int atmheader) { int vci,vpi; int i; vci = 0xffff & (atmheader >> 4); vpi = 0xff & (atmheader >> 20); for(i = 0; i < MAX_PVC_TABLE_ENTRY; i++) { if(pvc_result[i].bInUse) { if(pvc_result[i].vpi == vpi && pvc_result[i].vci == vci) { return; } } } for(i = 0; i < MAX_PVC_TABLE_ENTRY; i++) { if(pvc_result[i].bInUse == 0) { pvc_result[i].bInUse = 1; pvc_result[i].vpi = vpi; pvc_result[i].vci = vci; return; } } return; } /************************************************************ NEED FN HEADER ************************************************************/ void DDC_sar_clear_pvc_table(void) { int i; for(i = 0; i < MAX_PVC_TABLE_ENTRY; i++) { pvc_result[i].bInUse = 0; pvc_result[i].vpi = 0; pvc_result[i].vci = 0; } } /************************************************************ NEED FN HEADER ************************************************************/ #if defined (CONFIG_MIPS_AVALANCHE_COLORED_LED) || defined (CONFIG_LED_MODULE) void DDC_dsl_led_on(DDC_DslPriv *priv) { //DDC_DslPriv *priv = (DDC_DslPriv *) parm; dslhal_api_configureLed(priv->pIhw,1, 0); } /************************************************************ NEED FN HEADER ************************************************************/ void DDC_dsl_led_off(DDC_DslPriv *priv) { //DDC_DslPriv *priv = (DDC_DslPriv *) parm; dslhal_api_configureLed(priv->pIhw,1, 1); } /************************************************************ NEED FN HEADER ************************************************************/ void DDC_dsl_led_init(DDC_DslPriv *priv) { //DDC_DslPriv *priv = (DDC_DslPriv *) parm; dslhal_api_configureLed(priv->pIhw,1, 2); } #endif /** * \brief Reset AAL5 statistics. * * @return None. */ void DDC_sar_stat_reset(void) { sarStat.txPktCnt = 0; sarStat.rxPktCnt = 0; sarStat.txBytes = 0; sarStat.rxBytes = 0; sarStat.txErrors = 0; sarStat.rxErrors = 0; }