11da177e4SLinus Torvalds /****************************************************************************** 21da177e4SLinus Torvalds iphase.c: Device driver for Interphase ATM PCI adapter cards 31da177e4SLinus Torvalds Author: Peter Wang <pwang@iphase.com> 41da177e4SLinus Torvalds Some fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br> 51da177e4SLinus Torvalds Interphase Corporation <www.iphase.com> 61da177e4SLinus Torvalds Version: 1.0 71da177e4SLinus Torvalds ******************************************************************************* 81da177e4SLinus Torvalds 91da177e4SLinus Torvalds This software may be used and distributed according to the terms 101da177e4SLinus Torvalds of the GNU General Public License (GPL), incorporated herein by reference. 111da177e4SLinus Torvalds Drivers based on this skeleton fall under the GPL and must retain 121da177e4SLinus Torvalds the authorship (implicit copyright) notice. 131da177e4SLinus Torvalds 141da177e4SLinus Torvalds This program is distributed in the hope that it will be useful, but 151da177e4SLinus Torvalds WITHOUT ANY WARRANTY; without even the implied warranty of 161da177e4SLinus Torvalds MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 171da177e4SLinus Torvalds General Public License for more details. 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds Modified from an incomplete driver for Interphase 5575 1KVC 1M card which 201da177e4SLinus Torvalds was originally written by Monalisa Agrawal at UNH. Now this driver 211da177e4SLinus Torvalds supports a variety of varients of Interphase ATM PCI (i)Chip adapter 221da177e4SLinus Torvalds card family (See www.iphase.com/products/ClassSheet.cfm?ClassID=ATM) 231da177e4SLinus Torvalds in terms of PHY type, the size of control memory and the size of 241da177e4SLinus Torvalds packet memory. The followings are the change log and history: 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds Bugfix the Mona's UBR driver. 271da177e4SLinus Torvalds Modify the basic memory allocation and dma logic. 281da177e4SLinus Torvalds Port the driver to the latest kernel from 2.0.46. 291da177e4SLinus Torvalds Complete the ABR logic of the driver, and added the ABR work- 301da177e4SLinus Torvalds around for the hardware anormalies. 311da177e4SLinus Torvalds Add the CBR support. 321da177e4SLinus Torvalds Add the flow control logic to the driver to allow rate-limit VC. 331da177e4SLinus Torvalds Add 4K VC support to the board with 512K control memory. 341da177e4SLinus Torvalds Add the support of all the variants of the Interphase ATM PCI 351da177e4SLinus Torvalds (i)Chip adapter cards including x575 (155M OC3 and UTP155), x525 361da177e4SLinus Torvalds (25M UTP25) and x531 (DS3 and E3). 371da177e4SLinus Torvalds Add SMP support. 381da177e4SLinus Torvalds 391da177e4SLinus Torvalds Support and updates available at: ftp://ftp.iphase.com/pub/atm 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds *******************************************************************************/ 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds #include <linux/module.h> 441da177e4SLinus Torvalds #include <linux/kernel.h> 451da177e4SLinus Torvalds #include <linux/mm.h> 461da177e4SLinus Torvalds #include <linux/pci.h> 471da177e4SLinus Torvalds #include <linux/errno.h> 481da177e4SLinus Torvalds #include <linux/atm.h> 491da177e4SLinus Torvalds #include <linux/atmdev.h> 501da177e4SLinus Torvalds #include <linux/sonet.h> 511da177e4SLinus Torvalds #include <linux/skbuff.h> 521da177e4SLinus Torvalds #include <linux/time.h> 531da177e4SLinus Torvalds #include <linux/delay.h> 541da177e4SLinus Torvalds #include <linux/uio.h> 551da177e4SLinus Torvalds #include <linux/init.h> 561da177e4SLinus Torvalds #include <linux/wait.h> 571da177e4SLinus Torvalds #include <asm/system.h> 581da177e4SLinus Torvalds #include <asm/io.h> 591da177e4SLinus Torvalds #include <asm/atomic.h> 601da177e4SLinus Torvalds #include <asm/uaccess.h> 611da177e4SLinus Torvalds #include <asm/string.h> 621da177e4SLinus Torvalds #include <asm/byteorder.h> 631da177e4SLinus Torvalds #include <linux/vmalloc.h> 64420635f5SJulia Lawall #include <linux/jiffies.h> 651da177e4SLinus Torvalds #include "iphase.h" 661da177e4SLinus Torvalds #include "suni.h" 671da177e4SLinus Torvalds #define swap(x) (((x & 0xff) << 8) | ((x & 0xff00) >> 8)) 682be63b87SJorge Boncompte [DTI2] 691da177e4SLinus Torvalds #define PRIV(dev) ((struct suni_priv *) dev->phy_data) 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds static unsigned char ia_phy_get(struct atm_dev *dev, unsigned long addr); 721da177e4SLinus Torvalds static void desc_dbg(IADEV *iadev); 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds static IADEV *ia_dev[8]; 751da177e4SLinus Torvalds static struct atm_dev *_ia_dev[8]; 761da177e4SLinus Torvalds static int iadev_count; 771da177e4SLinus Torvalds static void ia_led_timer(unsigned long arg); 788d06afabSIngo Molnar static DEFINE_TIMER(ia_timer, ia_led_timer, 0, 0); 791da177e4SLinus Torvalds static int IA_TX_BUF = DFL_TX_BUFFERS, IA_TX_BUF_SZ = DFL_TX_BUF_SZ; 801da177e4SLinus Torvalds static int IA_RX_BUF = DFL_RX_BUFFERS, IA_RX_BUF_SZ = DFL_RX_BUF_SZ; 811da177e4SLinus Torvalds static uint IADebugFlag = /* IF_IADBG_ERR | IF_IADBG_CBR| IF_IADBG_INIT_ADAPTER 821da177e4SLinus Torvalds |IF_IADBG_ABR | IF_IADBG_EVENT*/ 0; 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds module_param(IA_TX_BUF, int, 0); 851da177e4SLinus Torvalds module_param(IA_TX_BUF_SZ, int, 0); 861da177e4SLinus Torvalds module_param(IA_RX_BUF, int, 0); 871da177e4SLinus Torvalds module_param(IA_RX_BUF_SZ, int, 0); 881da177e4SLinus Torvalds module_param(IADebugFlag, uint, 0644); 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds /**************************** IA_LIB **********************************/ 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds static void ia_init_rtn_q (IARTN_Q *que) 951da177e4SLinus Torvalds { 961da177e4SLinus Torvalds que->next = NULL; 971da177e4SLinus Torvalds que->tail = NULL; 981da177e4SLinus Torvalds } 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds static void ia_enque_head_rtn_q (IARTN_Q *que, IARTN_Q * data) 1011da177e4SLinus Torvalds { 1021da177e4SLinus Torvalds data->next = NULL; 1031da177e4SLinus Torvalds if (que->next == NULL) 1041da177e4SLinus Torvalds que->next = que->tail = data; 1051da177e4SLinus Torvalds else { 1061da177e4SLinus Torvalds data->next = que->next; 1071da177e4SLinus Torvalds que->next = data; 1081da177e4SLinus Torvalds } 1091da177e4SLinus Torvalds return; 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds static int ia_enque_rtn_q (IARTN_Q *que, struct desc_tbl_t data) { 1131da177e4SLinus Torvalds IARTN_Q *entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 1141da177e4SLinus Torvalds if (!entry) return -1; 1151da177e4SLinus Torvalds entry->data = data; 1161da177e4SLinus Torvalds entry->next = NULL; 1171da177e4SLinus Torvalds if (que->next == NULL) 1181da177e4SLinus Torvalds que->next = que->tail = entry; 1191da177e4SLinus Torvalds else { 1201da177e4SLinus Torvalds que->tail->next = entry; 1211da177e4SLinus Torvalds que->tail = que->tail->next; 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds return 1; 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds static IARTN_Q * ia_deque_rtn_q (IARTN_Q *que) { 1271da177e4SLinus Torvalds IARTN_Q *tmpdata; 1281da177e4SLinus Torvalds if (que->next == NULL) 1291da177e4SLinus Torvalds return NULL; 1301da177e4SLinus Torvalds tmpdata = que->next; 1311da177e4SLinus Torvalds if ( que->next == que->tail) 1321da177e4SLinus Torvalds que->next = que->tail = NULL; 1331da177e4SLinus Torvalds else 1341da177e4SLinus Torvalds que->next = que->next->next; 1351da177e4SLinus Torvalds return tmpdata; 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds static void ia_hack_tcq(IADEV *dev) { 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds u_short desc1; 1411da177e4SLinus Torvalds u_short tcq_wr; 1421da177e4SLinus Torvalds struct ia_vcc *iavcc_r = NULL; 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds tcq_wr = readl(dev->seg_reg+TCQ_WR_PTR) & 0xffff; 1451da177e4SLinus Torvalds while (dev->host_tcq_wr != tcq_wr) { 1461da177e4SLinus Torvalds desc1 = *(u_short *)(dev->seg_ram + dev->host_tcq_wr); 1471da177e4SLinus Torvalds if (!desc1) ; 1481da177e4SLinus Torvalds else if (!dev->desc_tbl[desc1 -1].timestamp) { 1491da177e4SLinus Torvalds IF_ABR(printk(" Desc %d is reset at %ld\n", desc1 -1, jiffies);) 1501da177e4SLinus Torvalds *(u_short *) (dev->seg_ram + dev->host_tcq_wr) = 0; 1511da177e4SLinus Torvalds } 1521da177e4SLinus Torvalds else if (dev->desc_tbl[desc1 -1].timestamp) { 1531da177e4SLinus Torvalds if (!(iavcc_r = dev->desc_tbl[desc1 -1].iavcc)) { 1541da177e4SLinus Torvalds printk("IA: Fatal err in get_desc\n"); 1551da177e4SLinus Torvalds continue; 1561da177e4SLinus Torvalds } 1571da177e4SLinus Torvalds iavcc_r->vc_desc_cnt--; 1581da177e4SLinus Torvalds dev->desc_tbl[desc1 -1].timestamp = 0; 1591da177e4SLinus Torvalds IF_EVENT(printk("ia_hack: return_q skb = 0x%x desc = %d\n", 1601da177e4SLinus Torvalds (u32)dev->desc_tbl[desc1 -1].txskb, desc1);) 1611da177e4SLinus Torvalds if (iavcc_r->pcr < dev->rate_limit) { 1621da177e4SLinus Torvalds IA_SKB_STATE (dev->desc_tbl[desc1-1].txskb) |= IA_TX_DONE; 1631da177e4SLinus Torvalds if (ia_enque_rtn_q(&dev->tx_return_q, dev->desc_tbl[desc1 -1]) < 0) 1641da177e4SLinus Torvalds printk("ia_hack_tcq: No memory available\n"); 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds dev->desc_tbl[desc1 -1].iavcc = NULL; 1671da177e4SLinus Torvalds dev->desc_tbl[desc1 -1].txskb = NULL; 1681da177e4SLinus Torvalds } 1691da177e4SLinus Torvalds dev->host_tcq_wr += 2; 1701da177e4SLinus Torvalds if (dev->host_tcq_wr > dev->ffL.tcq_ed) 1711da177e4SLinus Torvalds dev->host_tcq_wr = dev->ffL.tcq_st; 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds } /* ia_hack_tcq */ 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds static u16 get_desc (IADEV *dev, struct ia_vcc *iavcc) { 1761da177e4SLinus Torvalds u_short desc_num, i; 1771da177e4SLinus Torvalds struct sk_buff *skb; 1781da177e4SLinus Torvalds struct ia_vcc *iavcc_r = NULL; 1791da177e4SLinus Torvalds unsigned long delta; 1801da177e4SLinus Torvalds static unsigned long timer = 0; 1811da177e4SLinus Torvalds int ltimeout; 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds ia_hack_tcq (dev); 184420635f5SJulia Lawall if((time_after(jiffies,timer+50)) || ((dev->ffL.tcq_rd==dev->host_tcq_wr))) { 1851da177e4SLinus Torvalds timer = jiffies; 1861da177e4SLinus Torvalds i=0; 1871da177e4SLinus Torvalds while (i < dev->num_tx_desc) { 1881da177e4SLinus Torvalds if (!dev->desc_tbl[i].timestamp) { 1891da177e4SLinus Torvalds i++; 1901da177e4SLinus Torvalds continue; 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds ltimeout = dev->desc_tbl[i].iavcc->ltimeout; 1931da177e4SLinus Torvalds delta = jiffies - dev->desc_tbl[i].timestamp; 1941da177e4SLinus Torvalds if (delta >= ltimeout) { 1951da177e4SLinus Torvalds IF_ABR(printk("RECOVER run!! desc_tbl %d = %d delta = %ld, time = %ld\n", i,dev->desc_tbl[i].timestamp, delta, jiffies);) 1961da177e4SLinus Torvalds if (dev->ffL.tcq_rd == dev->ffL.tcq_st) 1971da177e4SLinus Torvalds dev->ffL.tcq_rd = dev->ffL.tcq_ed; 1981da177e4SLinus Torvalds else 1991da177e4SLinus Torvalds dev->ffL.tcq_rd -= 2; 2001da177e4SLinus Torvalds *(u_short *)(dev->seg_ram + dev->ffL.tcq_rd) = i+1; 2011da177e4SLinus Torvalds if (!(skb = dev->desc_tbl[i].txskb) || 2021da177e4SLinus Torvalds !(iavcc_r = dev->desc_tbl[i].iavcc)) 2031da177e4SLinus Torvalds printk("Fatal err, desc table vcc or skb is NULL\n"); 2041da177e4SLinus Torvalds else 2051da177e4SLinus Torvalds iavcc_r->vc_desc_cnt--; 2061da177e4SLinus Torvalds dev->desc_tbl[i].timestamp = 0; 2071da177e4SLinus Torvalds dev->desc_tbl[i].iavcc = NULL; 2081da177e4SLinus Torvalds dev->desc_tbl[i].txskb = NULL; 2091da177e4SLinus Torvalds } 2101da177e4SLinus Torvalds i++; 2111da177e4SLinus Torvalds } /* while */ 2121da177e4SLinus Torvalds } 2131da177e4SLinus Torvalds if (dev->ffL.tcq_rd == dev->host_tcq_wr) 2141da177e4SLinus Torvalds return 0xFFFF; 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds /* Get the next available descriptor number from TCQ */ 2171da177e4SLinus Torvalds desc_num = *(u_short *)(dev->seg_ram + dev->ffL.tcq_rd); 2181da177e4SLinus Torvalds 2191da177e4SLinus Torvalds while (!desc_num || (dev->desc_tbl[desc_num -1]).timestamp) { 2201da177e4SLinus Torvalds dev->ffL.tcq_rd += 2; 2211da177e4SLinus Torvalds if (dev->ffL.tcq_rd > dev->ffL.tcq_ed) 2221da177e4SLinus Torvalds dev->ffL.tcq_rd = dev->ffL.tcq_st; 2231da177e4SLinus Torvalds if (dev->ffL.tcq_rd == dev->host_tcq_wr) 2241da177e4SLinus Torvalds return 0xFFFF; 2251da177e4SLinus Torvalds desc_num = *(u_short *)(dev->seg_ram + dev->ffL.tcq_rd); 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds /* get system time */ 2291da177e4SLinus Torvalds dev->desc_tbl[desc_num -1].timestamp = jiffies; 2301da177e4SLinus Torvalds return desc_num; 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds static void clear_lockup (struct atm_vcc *vcc, IADEV *dev) { 2341da177e4SLinus Torvalds u_char foundLockUp; 2351da177e4SLinus Torvalds vcstatus_t *vcstatus; 2361da177e4SLinus Torvalds u_short *shd_tbl; 2371da177e4SLinus Torvalds u_short tempCellSlot, tempFract; 2381da177e4SLinus Torvalds struct main_vc *abr_vc = (struct main_vc *)dev->MAIN_VC_TABLE_ADDR; 2391da177e4SLinus Torvalds struct ext_vc *eabr_vc = (struct ext_vc *)dev->EXT_VC_TABLE_ADDR; 2401da177e4SLinus Torvalds u_int i; 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_ABR) { 2431da177e4SLinus Torvalds vcstatus = (vcstatus_t *) &(dev->testTable[vcc->vci]->vc_status); 2441da177e4SLinus Torvalds vcstatus->cnt++; 2451da177e4SLinus Torvalds foundLockUp = 0; 2461da177e4SLinus Torvalds if( vcstatus->cnt == 0x05 ) { 2471da177e4SLinus Torvalds abr_vc += vcc->vci; 2481da177e4SLinus Torvalds eabr_vc += vcc->vci; 2491da177e4SLinus Torvalds if( eabr_vc->last_desc ) { 2501da177e4SLinus Torvalds if( (abr_vc->status & 0x07) == ABR_STATE /* 0x2 */ ) { 2511da177e4SLinus Torvalds /* Wait for 10 Micro sec */ 2521da177e4SLinus Torvalds udelay(10); 2531da177e4SLinus Torvalds if ((eabr_vc->last_desc)&&((abr_vc->status & 0x07)==ABR_STATE)) 2541da177e4SLinus Torvalds foundLockUp = 1; 2551da177e4SLinus Torvalds } 2561da177e4SLinus Torvalds else { 2571da177e4SLinus Torvalds tempCellSlot = abr_vc->last_cell_slot; 2581da177e4SLinus Torvalds tempFract = abr_vc->fraction; 2591da177e4SLinus Torvalds if((tempCellSlot == dev->testTable[vcc->vci]->lastTime) 2601da177e4SLinus Torvalds && (tempFract == dev->testTable[vcc->vci]->fract)) 2611da177e4SLinus Torvalds foundLockUp = 1; 2621da177e4SLinus Torvalds dev->testTable[vcc->vci]->lastTime = tempCellSlot; 2631da177e4SLinus Torvalds dev->testTable[vcc->vci]->fract = tempFract; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds } /* last descriptor */ 2661da177e4SLinus Torvalds vcstatus->cnt = 0; 2671da177e4SLinus Torvalds } /* vcstatus->cnt */ 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds if (foundLockUp) { 2701da177e4SLinus Torvalds IF_ABR(printk("LOCK UP found\n");) 2711da177e4SLinus Torvalds writew(0xFFFD, dev->seg_reg+MODE_REG_0); 2721da177e4SLinus Torvalds /* Wait for 10 Micro sec */ 2731da177e4SLinus Torvalds udelay(10); 2741da177e4SLinus Torvalds abr_vc->status &= 0xFFF8; 2751da177e4SLinus Torvalds abr_vc->status |= 0x0001; /* state is idle */ 2761da177e4SLinus Torvalds shd_tbl = (u_short *)dev->ABR_SCHED_TABLE_ADDR; 2771da177e4SLinus Torvalds for( i = 0; ((i < dev->num_vc) && (shd_tbl[i])); i++ ); 2781da177e4SLinus Torvalds if (i < dev->num_vc) 2791da177e4SLinus Torvalds shd_tbl[i] = vcc->vci; 2801da177e4SLinus Torvalds else 2811da177e4SLinus Torvalds IF_ERR(printk("ABR Seg. may not continue on VC %x\n",vcc->vci);) 2821da177e4SLinus Torvalds writew(T_ONLINE, dev->seg_reg+MODE_REG_0); 2831da177e4SLinus Torvalds writew(~(TRANSMIT_DONE|TCQ_NOT_EMPTY), dev->seg_reg+SEG_MASK_REG); 2841da177e4SLinus Torvalds writew(TRANSMIT_DONE, dev->seg_reg+SEG_INTR_STATUS_REG); 2851da177e4SLinus Torvalds vcstatus->cnt = 0; 2861da177e4SLinus Torvalds } /* foundLockUp */ 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds } /* if an ABR VC */ 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds } 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds /* 2941da177e4SLinus Torvalds ** Conversion of 24-bit cellrate (cells/sec) to 16-bit floating point format. 2951da177e4SLinus Torvalds ** 2961da177e4SLinus Torvalds ** +----+----+------------------+-------------------------------+ 2971da177e4SLinus Torvalds ** | R | NZ | 5-bit exponent | 9-bit mantissa | 2981da177e4SLinus Torvalds ** +----+----+------------------+-------------------------------+ 2991da177e4SLinus Torvalds ** 3000779bf2dSMatt LaPlante ** R = reserved (written as 0) 3011da177e4SLinus Torvalds ** NZ = 0 if 0 cells/sec; 1 otherwise 3021da177e4SLinus Torvalds ** 3031da177e4SLinus Torvalds ** if NZ = 1, rate = 1.mmmmmmmmm x 2^(eeeee) cells/sec 3041da177e4SLinus Torvalds */ 3051da177e4SLinus Torvalds static u16 3061da177e4SLinus Torvalds cellrate_to_float(u32 cr) 3071da177e4SLinus Torvalds { 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds #define NZ 0x4000 3101da177e4SLinus Torvalds #define M_BITS 9 /* Number of bits in mantissa */ 3111da177e4SLinus Torvalds #define E_BITS 5 /* Number of bits in exponent */ 3121da177e4SLinus Torvalds #define M_MASK 0x1ff 3131da177e4SLinus Torvalds #define E_MASK 0x1f 3141da177e4SLinus Torvalds u16 flot; 3151da177e4SLinus Torvalds u32 tmp = cr & 0x00ffffff; 3161da177e4SLinus Torvalds int i = 0; 3171da177e4SLinus Torvalds if (cr == 0) 3181da177e4SLinus Torvalds return 0; 3191da177e4SLinus Torvalds while (tmp != 1) { 3201da177e4SLinus Torvalds tmp >>= 1; 3211da177e4SLinus Torvalds i++; 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds if (i == M_BITS) 3241da177e4SLinus Torvalds flot = NZ | (i << M_BITS) | (cr & M_MASK); 3251da177e4SLinus Torvalds else if (i < M_BITS) 3261da177e4SLinus Torvalds flot = NZ | (i << M_BITS) | ((cr << (M_BITS - i)) & M_MASK); 3271da177e4SLinus Torvalds else 3281da177e4SLinus Torvalds flot = NZ | (i << M_BITS) | ((cr >> (i - M_BITS)) & M_MASK); 3291da177e4SLinus Torvalds return flot; 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds #if 0 3331da177e4SLinus Torvalds /* 3341da177e4SLinus Torvalds ** Conversion of 16-bit floating point format to 24-bit cellrate (cells/sec). 3351da177e4SLinus Torvalds */ 3361da177e4SLinus Torvalds static u32 3371da177e4SLinus Torvalds float_to_cellrate(u16 rate) 3381da177e4SLinus Torvalds { 3391da177e4SLinus Torvalds u32 exp, mantissa, cps; 3401da177e4SLinus Torvalds if ((rate & NZ) == 0) 3411da177e4SLinus Torvalds return 0; 3421da177e4SLinus Torvalds exp = (rate >> M_BITS) & E_MASK; 3431da177e4SLinus Torvalds mantissa = rate & M_MASK; 3441da177e4SLinus Torvalds if (exp == 0) 3451da177e4SLinus Torvalds return 1; 3461da177e4SLinus Torvalds cps = (1 << M_BITS) | mantissa; 3471da177e4SLinus Torvalds if (exp == M_BITS) 3481da177e4SLinus Torvalds cps = cps; 3491da177e4SLinus Torvalds else if (exp > M_BITS) 3501da177e4SLinus Torvalds cps <<= (exp - M_BITS); 3511da177e4SLinus Torvalds else 3521da177e4SLinus Torvalds cps >>= (M_BITS - exp); 3531da177e4SLinus Torvalds return cps; 3541da177e4SLinus Torvalds } 3551da177e4SLinus Torvalds #endif 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds static void init_abr_vc (IADEV *dev, srv_cls_param_t *srv_p) { 3581da177e4SLinus Torvalds srv_p->class_type = ATM_ABR; 3591da177e4SLinus Torvalds srv_p->pcr = dev->LineRate; 3601da177e4SLinus Torvalds srv_p->mcr = 0; 3611da177e4SLinus Torvalds srv_p->icr = 0x055cb7; 3621da177e4SLinus Torvalds srv_p->tbe = 0xffffff; 3631da177e4SLinus Torvalds srv_p->frtt = 0x3a; 3641da177e4SLinus Torvalds srv_p->rif = 0xf; 3651da177e4SLinus Torvalds srv_p->rdf = 0xb; 3661da177e4SLinus Torvalds srv_p->nrm = 0x4; 3671da177e4SLinus Torvalds srv_p->trm = 0x7; 3681da177e4SLinus Torvalds srv_p->cdf = 0x3; 3691da177e4SLinus Torvalds srv_p->adtf = 50; 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds static int 3731da177e4SLinus Torvalds ia_open_abr_vc(IADEV *dev, srv_cls_param_t *srv_p, 3741da177e4SLinus Torvalds struct atm_vcc *vcc, u8 flag) 3751da177e4SLinus Torvalds { 3761da177e4SLinus Torvalds f_vc_abr_entry *f_abr_vc; 3771da177e4SLinus Torvalds r_vc_abr_entry *r_abr_vc; 3781da177e4SLinus Torvalds u32 icr; 3791da177e4SLinus Torvalds u8 trm, nrm, crm; 3801da177e4SLinus Torvalds u16 adtf, air, *ptr16; 3811da177e4SLinus Torvalds f_abr_vc =(f_vc_abr_entry *)dev->MAIN_VC_TABLE_ADDR; 3821da177e4SLinus Torvalds f_abr_vc += vcc->vci; 3831da177e4SLinus Torvalds switch (flag) { 3841da177e4SLinus Torvalds case 1: /* FFRED initialization */ 3851da177e4SLinus Torvalds #if 0 /* sanity check */ 3861da177e4SLinus Torvalds if (srv_p->pcr == 0) 3871da177e4SLinus Torvalds return INVALID_PCR; 3881da177e4SLinus Torvalds if (srv_p->pcr > dev->LineRate) 3891da177e4SLinus Torvalds srv_p->pcr = dev->LineRate; 3901da177e4SLinus Torvalds if ((srv_p->mcr + dev->sum_mcr) > dev->LineRate) 3911da177e4SLinus Torvalds return MCR_UNAVAILABLE; 3921da177e4SLinus Torvalds if (srv_p->mcr > srv_p->pcr) 3931da177e4SLinus Torvalds return INVALID_MCR; 3941da177e4SLinus Torvalds if (!(srv_p->icr)) 3951da177e4SLinus Torvalds srv_p->icr = srv_p->pcr; 3961da177e4SLinus Torvalds if ((srv_p->icr < srv_p->mcr) || (srv_p->icr > srv_p->pcr)) 3971da177e4SLinus Torvalds return INVALID_ICR; 3981da177e4SLinus Torvalds if ((srv_p->tbe < MIN_TBE) || (srv_p->tbe > MAX_TBE)) 3991da177e4SLinus Torvalds return INVALID_TBE; 4001da177e4SLinus Torvalds if ((srv_p->frtt < MIN_FRTT) || (srv_p->frtt > MAX_FRTT)) 4011da177e4SLinus Torvalds return INVALID_FRTT; 4021da177e4SLinus Torvalds if (srv_p->nrm > MAX_NRM) 4031da177e4SLinus Torvalds return INVALID_NRM; 4041da177e4SLinus Torvalds if (srv_p->trm > MAX_TRM) 4051da177e4SLinus Torvalds return INVALID_TRM; 4061da177e4SLinus Torvalds if (srv_p->adtf > MAX_ADTF) 4071da177e4SLinus Torvalds return INVALID_ADTF; 4081da177e4SLinus Torvalds else if (srv_p->adtf == 0) 4091da177e4SLinus Torvalds srv_p->adtf = 1; 4101da177e4SLinus Torvalds if (srv_p->cdf > MAX_CDF) 4111da177e4SLinus Torvalds return INVALID_CDF; 4121da177e4SLinus Torvalds if (srv_p->rif > MAX_RIF) 4131da177e4SLinus Torvalds return INVALID_RIF; 4141da177e4SLinus Torvalds if (srv_p->rdf > MAX_RDF) 4151da177e4SLinus Torvalds return INVALID_RDF; 4161da177e4SLinus Torvalds #endif 4171da177e4SLinus Torvalds memset ((caddr_t)f_abr_vc, 0, sizeof(*f_abr_vc)); 4181da177e4SLinus Torvalds f_abr_vc->f_vc_type = ABR; 4191da177e4SLinus Torvalds nrm = 2 << srv_p->nrm; /* (2 ** (srv_p->nrm +1)) */ 4201da177e4SLinus Torvalds /* i.e 2**n = 2 << (n-1) */ 4211da177e4SLinus Torvalds f_abr_vc->f_nrm = nrm << 8 | nrm; 4221da177e4SLinus Torvalds trm = 100000/(2 << (16 - srv_p->trm)); 4231da177e4SLinus Torvalds if ( trm == 0) trm = 1; 4241da177e4SLinus Torvalds f_abr_vc->f_nrmexp =(((srv_p->nrm +1) & 0x0f) << 12)|(MRM << 8) | trm; 4251da177e4SLinus Torvalds crm = srv_p->tbe / nrm; 4261da177e4SLinus Torvalds if (crm == 0) crm = 1; 4271da177e4SLinus Torvalds f_abr_vc->f_crm = crm & 0xff; 4281da177e4SLinus Torvalds f_abr_vc->f_pcr = cellrate_to_float(srv_p->pcr); 4291da177e4SLinus Torvalds icr = min( srv_p->icr, (srv_p->tbe > srv_p->frtt) ? 4301da177e4SLinus Torvalds ((srv_p->tbe/srv_p->frtt)*1000000) : 4311da177e4SLinus Torvalds (1000000/(srv_p->frtt/srv_p->tbe))); 4321da177e4SLinus Torvalds f_abr_vc->f_icr = cellrate_to_float(icr); 4331da177e4SLinus Torvalds adtf = (10000 * srv_p->adtf)/8192; 4341da177e4SLinus Torvalds if (adtf == 0) adtf = 1; 4351da177e4SLinus Torvalds f_abr_vc->f_cdf = ((7 - srv_p->cdf) << 12 | adtf) & 0xfff; 4361da177e4SLinus Torvalds f_abr_vc->f_mcr = cellrate_to_float(srv_p->mcr); 4371da177e4SLinus Torvalds f_abr_vc->f_acr = f_abr_vc->f_icr; 4381da177e4SLinus Torvalds f_abr_vc->f_status = 0x0042; 4391da177e4SLinus Torvalds break; 4401da177e4SLinus Torvalds case 0: /* RFRED initialization */ 4411da177e4SLinus Torvalds ptr16 = (u_short *)(dev->reass_ram + REASS_TABLE*dev->memSize); 4421da177e4SLinus Torvalds *(ptr16 + vcc->vci) = NO_AAL5_PKT | REASS_ABR; 4431da177e4SLinus Torvalds r_abr_vc = (r_vc_abr_entry*)(dev->reass_ram+ABR_VC_TABLE*dev->memSize); 4441da177e4SLinus Torvalds r_abr_vc += vcc->vci; 4451da177e4SLinus Torvalds r_abr_vc->r_status_rdf = (15 - srv_p->rdf) & 0x000f; 4461da177e4SLinus Torvalds air = srv_p->pcr << (15 - srv_p->rif); 4471da177e4SLinus Torvalds if (air == 0) air = 1; 4481da177e4SLinus Torvalds r_abr_vc->r_air = cellrate_to_float(air); 4491da177e4SLinus Torvalds dev->testTable[vcc->vci]->vc_status = VC_ACTIVE | VC_ABR; 4501da177e4SLinus Torvalds dev->sum_mcr += srv_p->mcr; 4511da177e4SLinus Torvalds dev->n_abr++; 4521da177e4SLinus Torvalds break; 4531da177e4SLinus Torvalds default: 4541da177e4SLinus Torvalds break; 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds return 0; 4571da177e4SLinus Torvalds } 4581da177e4SLinus Torvalds static int ia_cbr_setup (IADEV *dev, struct atm_vcc *vcc) { 4591da177e4SLinus Torvalds u32 rateLow=0, rateHigh, rate; 4601da177e4SLinus Torvalds int entries; 4611da177e4SLinus Torvalds struct ia_vcc *ia_vcc; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds int idealSlot =0, testSlot, toBeAssigned, inc; 4641da177e4SLinus Torvalds u32 spacing; 4651da177e4SLinus Torvalds u16 *SchedTbl, *TstSchedTbl; 4661da177e4SLinus Torvalds u16 cbrVC, vcIndex; 4671da177e4SLinus Torvalds u32 fracSlot = 0; 4681da177e4SLinus Torvalds u32 sp_mod = 0; 4691da177e4SLinus Torvalds u32 sp_mod2 = 0; 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds /* IpAdjustTrafficParams */ 4721da177e4SLinus Torvalds if (vcc->qos.txtp.max_pcr <= 0) { 4731da177e4SLinus Torvalds IF_ERR(printk("PCR for CBR not defined\n");) 4741da177e4SLinus Torvalds return -1; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds rate = vcc->qos.txtp.max_pcr; 4771da177e4SLinus Torvalds entries = rate / dev->Granularity; 4781da177e4SLinus Torvalds IF_CBR(printk("CBR: CBR entries=0x%x for rate=0x%x & Gran=0x%x\n", 4791da177e4SLinus Torvalds entries, rate, dev->Granularity);) 4801da177e4SLinus Torvalds if (entries < 1) 4811da177e4SLinus Torvalds IF_CBR(printk("CBR: Bandwidth smaller than granularity of CBR table\n");) 4821da177e4SLinus Torvalds rateLow = entries * dev->Granularity; 4831da177e4SLinus Torvalds rateHigh = (entries + 1) * dev->Granularity; 4841da177e4SLinus Torvalds if (3*(rate - rateLow) > (rateHigh - rate)) 4851da177e4SLinus Torvalds entries++; 4861da177e4SLinus Torvalds if (entries > dev->CbrRemEntries) { 4871da177e4SLinus Torvalds IF_CBR(printk("CBR: Not enough bandwidth to support this PCR.\n");) 4881da177e4SLinus Torvalds IF_CBR(printk("Entries = 0x%x, CbrRemEntries = 0x%x.\n", 4891da177e4SLinus Torvalds entries, dev->CbrRemEntries);) 4901da177e4SLinus Torvalds return -EBUSY; 4911da177e4SLinus Torvalds } 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds ia_vcc = INPH_IA_VCC(vcc); 4941da177e4SLinus Torvalds ia_vcc->NumCbrEntry = entries; 4951da177e4SLinus Torvalds dev->sum_mcr += entries * dev->Granularity; 4961da177e4SLinus Torvalds /* IaFFrednInsertCbrSched */ 4971da177e4SLinus Torvalds // Starting at an arbitrary location, place the entries into the table 4981da177e4SLinus Torvalds // as smoothly as possible 4991da177e4SLinus Torvalds cbrVC = 0; 5001da177e4SLinus Torvalds spacing = dev->CbrTotEntries / entries; 5011da177e4SLinus Torvalds sp_mod = dev->CbrTotEntries % entries; // get modulo 5021da177e4SLinus Torvalds toBeAssigned = entries; 5031da177e4SLinus Torvalds fracSlot = 0; 5041da177e4SLinus Torvalds vcIndex = vcc->vci; 5051da177e4SLinus Torvalds IF_CBR(printk("Vci=0x%x,Spacing=0x%x,Sp_mod=0x%x\n",vcIndex,spacing,sp_mod);) 5061da177e4SLinus Torvalds while (toBeAssigned) 5071da177e4SLinus Torvalds { 5081da177e4SLinus Torvalds // If this is the first time, start the table loading for this connection 5091da177e4SLinus Torvalds // as close to entryPoint as possible. 5101da177e4SLinus Torvalds if (toBeAssigned == entries) 5111da177e4SLinus Torvalds { 5121da177e4SLinus Torvalds idealSlot = dev->CbrEntryPt; 5131da177e4SLinus Torvalds dev->CbrEntryPt += 2; // Adding 2 helps to prevent clumping 5141da177e4SLinus Torvalds if (dev->CbrEntryPt >= dev->CbrTotEntries) 5151da177e4SLinus Torvalds dev->CbrEntryPt -= dev->CbrTotEntries;// Wrap if necessary 5161da177e4SLinus Torvalds } else { 5171da177e4SLinus Torvalds idealSlot += (u32)(spacing + fracSlot); // Point to the next location 5181da177e4SLinus Torvalds // in the table that would be smoothest 5191da177e4SLinus Torvalds fracSlot = ((sp_mod + sp_mod2) / entries); // get new integer part 5201da177e4SLinus Torvalds sp_mod2 = ((sp_mod + sp_mod2) % entries); // calc new fractional part 5211da177e4SLinus Torvalds } 5221da177e4SLinus Torvalds if (idealSlot >= (int)dev->CbrTotEntries) 5231da177e4SLinus Torvalds idealSlot -= dev->CbrTotEntries; 5241da177e4SLinus Torvalds // Continuously check around this ideal value until a null 5251da177e4SLinus Torvalds // location is encountered. 5261da177e4SLinus Torvalds SchedTbl = (u16*)(dev->seg_ram+CBR_SCHED_TABLE*dev->memSize); 5271da177e4SLinus Torvalds inc = 0; 5281da177e4SLinus Torvalds testSlot = idealSlot; 5291da177e4SLinus Torvalds TstSchedTbl = (u16*)(SchedTbl+testSlot); //set index and read in value 5301da177e4SLinus Torvalds IF_CBR(printk("CBR Testslot 0x%x AT Location 0x%x, NumToAssign=%d\n", 5311da177e4SLinus Torvalds testSlot, (u32)TstSchedTbl,toBeAssigned);) 5321da177e4SLinus Torvalds memcpy((caddr_t)&cbrVC,(caddr_t)TstSchedTbl,sizeof(cbrVC)); 5331da177e4SLinus Torvalds while (cbrVC) // If another VC at this location, we have to keep looking 5341da177e4SLinus Torvalds { 5351da177e4SLinus Torvalds inc++; 5361da177e4SLinus Torvalds testSlot = idealSlot - inc; 5371da177e4SLinus Torvalds if (testSlot < 0) { // Wrap if necessary 5381da177e4SLinus Torvalds testSlot += dev->CbrTotEntries; 5391da177e4SLinus Torvalds IF_CBR(printk("Testslot Wrap. STable Start=0x%x,Testslot=%d\n", 5401da177e4SLinus Torvalds (u32)SchedTbl,testSlot);) 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds TstSchedTbl = (u16 *)(SchedTbl + testSlot); // set table index 5431da177e4SLinus Torvalds memcpy((caddr_t)&cbrVC,(caddr_t)TstSchedTbl,sizeof(cbrVC)); 5441da177e4SLinus Torvalds if (!cbrVC) 5451da177e4SLinus Torvalds break; 5461da177e4SLinus Torvalds testSlot = idealSlot + inc; 5471da177e4SLinus Torvalds if (testSlot >= (int)dev->CbrTotEntries) { // Wrap if necessary 5481da177e4SLinus Torvalds testSlot -= dev->CbrTotEntries; 5491da177e4SLinus Torvalds IF_CBR(printk("TotCbrEntries=%d",dev->CbrTotEntries);) 5501da177e4SLinus Torvalds IF_CBR(printk(" Testslot=0x%x ToBeAssgned=%d\n", 5511da177e4SLinus Torvalds testSlot, toBeAssigned);) 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds // set table index and read in value 5541da177e4SLinus Torvalds TstSchedTbl = (u16*)(SchedTbl + testSlot); 5551da177e4SLinus Torvalds IF_CBR(printk("Reading CBR Tbl from 0x%x, CbrVal=0x%x Iteration %d\n", 5561da177e4SLinus Torvalds (u32)TstSchedTbl,cbrVC,inc);) 5571da177e4SLinus Torvalds memcpy((caddr_t)&cbrVC,(caddr_t)TstSchedTbl,sizeof(cbrVC)); 5581da177e4SLinus Torvalds } /* while */ 5591da177e4SLinus Torvalds // Move this VCI number into this location of the CBR Sched table. 5601da177e4SLinus Torvalds memcpy((caddr_t)TstSchedTbl, (caddr_t)&vcIndex,sizeof(TstSchedTbl)); 5611da177e4SLinus Torvalds dev->CbrRemEntries--; 5621da177e4SLinus Torvalds toBeAssigned--; 5631da177e4SLinus Torvalds } /* while */ 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds /* IaFFrednCbrEnable */ 5661da177e4SLinus Torvalds dev->NumEnabledCBR++; 5671da177e4SLinus Torvalds if (dev->NumEnabledCBR == 1) { 5681da177e4SLinus Torvalds writew((CBR_EN | UBR_EN | ABR_EN | (0x23 << 2)), dev->seg_reg+STPARMS); 5691da177e4SLinus Torvalds IF_CBR(printk("CBR is enabled\n");) 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds return 0; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds static void ia_cbrVc_close (struct atm_vcc *vcc) { 5741da177e4SLinus Torvalds IADEV *iadev; 5751da177e4SLinus Torvalds u16 *SchedTbl, NullVci = 0; 5761da177e4SLinus Torvalds u32 i, NumFound; 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 5791da177e4SLinus Torvalds iadev->NumEnabledCBR--; 5801da177e4SLinus Torvalds SchedTbl = (u16*)(iadev->seg_ram+CBR_SCHED_TABLE*iadev->memSize); 5811da177e4SLinus Torvalds if (iadev->NumEnabledCBR == 0) { 5821da177e4SLinus Torvalds writew((UBR_EN | ABR_EN | (0x23 << 2)), iadev->seg_reg+STPARMS); 5831da177e4SLinus Torvalds IF_CBR (printk("CBR support disabled\n");) 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds NumFound = 0; 5861da177e4SLinus Torvalds for (i=0; i < iadev->CbrTotEntries; i++) 5871da177e4SLinus Torvalds { 5881da177e4SLinus Torvalds if (*SchedTbl == vcc->vci) { 5891da177e4SLinus Torvalds iadev->CbrRemEntries++; 5901da177e4SLinus Torvalds *SchedTbl = NullVci; 5911da177e4SLinus Torvalds IF_CBR(NumFound++;) 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds SchedTbl++; 5941da177e4SLinus Torvalds } 5951da177e4SLinus Torvalds IF_CBR(printk("Exit ia_cbrVc_close, NumRemoved=%d\n",NumFound);) 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds static int ia_avail_descs(IADEV *iadev) { 5991da177e4SLinus Torvalds int tmp = 0; 6001da177e4SLinus Torvalds ia_hack_tcq(iadev); 6011da177e4SLinus Torvalds if (iadev->host_tcq_wr >= iadev->ffL.tcq_rd) 6021da177e4SLinus Torvalds tmp = (iadev->host_tcq_wr - iadev->ffL.tcq_rd) / 2; 6031da177e4SLinus Torvalds else 6041da177e4SLinus Torvalds tmp = (iadev->ffL.tcq_ed - iadev->ffL.tcq_rd + 2 + iadev->host_tcq_wr - 6051da177e4SLinus Torvalds iadev->ffL.tcq_st) / 2; 6061da177e4SLinus Torvalds return tmp; 6071da177e4SLinus Torvalds } 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds static int ia_pkt_tx (struct atm_vcc *vcc, struct sk_buff *skb); 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds static int ia_que_tx (IADEV *iadev) { 6121da177e4SLinus Torvalds struct sk_buff *skb; 6131da177e4SLinus Torvalds int num_desc; 6141da177e4SLinus Torvalds struct atm_vcc *vcc; 6151da177e4SLinus Torvalds struct ia_vcc *iavcc; 6161da177e4SLinus Torvalds num_desc = ia_avail_descs(iadev); 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds while (num_desc && (skb = skb_dequeue(&iadev->tx_backlog))) { 6191da177e4SLinus Torvalds if (!(vcc = ATM_SKB(skb)->vcc)) { 6201da177e4SLinus Torvalds dev_kfree_skb_any(skb); 6211da177e4SLinus Torvalds printk("ia_que_tx: Null vcc\n"); 6221da177e4SLinus Torvalds break; 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds if (!test_bit(ATM_VF_READY,&vcc->flags)) { 6251da177e4SLinus Torvalds dev_kfree_skb_any(skb); 6261da177e4SLinus Torvalds printk("Free the SKB on closed vci %d \n", vcc->vci); 6271da177e4SLinus Torvalds break; 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds iavcc = INPH_IA_VCC(vcc); 6301da177e4SLinus Torvalds if (ia_pkt_tx (vcc, skb)) { 6311da177e4SLinus Torvalds skb_queue_head(&iadev->tx_backlog, skb); 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds num_desc--; 6341da177e4SLinus Torvalds } 6351da177e4SLinus Torvalds return 0; 6361da177e4SLinus Torvalds } 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds static void ia_tx_poll (IADEV *iadev) { 6391da177e4SLinus Torvalds struct atm_vcc *vcc = NULL; 6401da177e4SLinus Torvalds struct sk_buff *skb = NULL, *skb1 = NULL; 6411da177e4SLinus Torvalds struct ia_vcc *iavcc; 6421da177e4SLinus Torvalds IARTN_Q * rtne; 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds ia_hack_tcq(iadev); 6451da177e4SLinus Torvalds while ( (rtne = ia_deque_rtn_q(&iadev->tx_return_q))) { 6461da177e4SLinus Torvalds skb = rtne->data.txskb; 6471da177e4SLinus Torvalds if (!skb) { 6481da177e4SLinus Torvalds printk("ia_tx_poll: skb is null\n"); 6491da177e4SLinus Torvalds goto out; 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds vcc = ATM_SKB(skb)->vcc; 6521da177e4SLinus Torvalds if (!vcc) { 6531da177e4SLinus Torvalds printk("ia_tx_poll: vcc is null\n"); 6541da177e4SLinus Torvalds dev_kfree_skb_any(skb); 6551da177e4SLinus Torvalds goto out; 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds iavcc = INPH_IA_VCC(vcc); 6591da177e4SLinus Torvalds if (!iavcc) { 6601da177e4SLinus Torvalds printk("ia_tx_poll: iavcc is null\n"); 6611da177e4SLinus Torvalds dev_kfree_skb_any(skb); 6621da177e4SLinus Torvalds goto out; 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds skb1 = skb_dequeue(&iavcc->txing_skb); 6661da177e4SLinus Torvalds while (skb1 && (skb1 != skb)) { 6671da177e4SLinus Torvalds if (!(IA_SKB_STATE(skb1) & IA_TX_DONE)) { 6681da177e4SLinus Torvalds printk("IA_tx_intr: Vci %d lost pkt!!!\n", vcc->vci); 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds IF_ERR(printk("Release the SKB not match\n");) 6711da177e4SLinus Torvalds if ((vcc->pop) && (skb1->len != 0)) 6721da177e4SLinus Torvalds { 6731da177e4SLinus Torvalds vcc->pop(vcc, skb1); 6741da177e4SLinus Torvalds IF_EVENT(printk("Tansmit Done - skb 0x%lx return\n", 6751da177e4SLinus Torvalds (long)skb1);) 6761da177e4SLinus Torvalds } 6771da177e4SLinus Torvalds else 6781da177e4SLinus Torvalds dev_kfree_skb_any(skb1); 6791da177e4SLinus Torvalds skb1 = skb_dequeue(&iavcc->txing_skb); 6801da177e4SLinus Torvalds } 6811da177e4SLinus Torvalds if (!skb1) { 6821da177e4SLinus Torvalds IF_EVENT(printk("IA: Vci %d - skb not found requed\n",vcc->vci);) 6831da177e4SLinus Torvalds ia_enque_head_rtn_q (&iadev->tx_return_q, rtne); 6841da177e4SLinus Torvalds break; 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds if ((vcc->pop) && (skb->len != 0)) 6871da177e4SLinus Torvalds { 6881da177e4SLinus Torvalds vcc->pop(vcc, skb); 6891da177e4SLinus Torvalds IF_EVENT(printk("Tx Done - skb 0x%lx return\n",(long)skb);) 6901da177e4SLinus Torvalds } 6911da177e4SLinus Torvalds else 6921da177e4SLinus Torvalds dev_kfree_skb_any(skb); 6931da177e4SLinus Torvalds kfree(rtne); 6941da177e4SLinus Torvalds } 6951da177e4SLinus Torvalds ia_que_tx(iadev); 6961da177e4SLinus Torvalds out: 6971da177e4SLinus Torvalds return; 6981da177e4SLinus Torvalds } 6991da177e4SLinus Torvalds #if 0 7001da177e4SLinus Torvalds static void ia_eeprom_put (IADEV *iadev, u32 addr, u_short val) 7011da177e4SLinus Torvalds { 7021da177e4SLinus Torvalds u32 t; 7031da177e4SLinus Torvalds int i; 7041da177e4SLinus Torvalds /* 7051da177e4SLinus Torvalds * Issue a command to enable writes to the NOVRAM 7061da177e4SLinus Torvalds */ 7071da177e4SLinus Torvalds NVRAM_CMD (EXTEND + EWEN); 7081da177e4SLinus Torvalds NVRAM_CLR_CE; 7091da177e4SLinus Torvalds /* 7101da177e4SLinus Torvalds * issue the write command 7111da177e4SLinus Torvalds */ 7121da177e4SLinus Torvalds NVRAM_CMD(IAWRITE + addr); 7131da177e4SLinus Torvalds /* 7141da177e4SLinus Torvalds * Send the data, starting with D15, then D14, and so on for 16 bits 7151da177e4SLinus Torvalds */ 7161da177e4SLinus Torvalds for (i=15; i>=0; i--) { 7171da177e4SLinus Torvalds NVRAM_CLKOUT (val & 0x8000); 7181da177e4SLinus Torvalds val <<= 1; 7191da177e4SLinus Torvalds } 7201da177e4SLinus Torvalds NVRAM_CLR_CE; 7211da177e4SLinus Torvalds CFG_OR(NVCE); 7221da177e4SLinus Torvalds t = readl(iadev->reg+IPHASE5575_EEPROM_ACCESS); 7231da177e4SLinus Torvalds while (!(t & NVDO)) 7241da177e4SLinus Torvalds t = readl(iadev->reg+IPHASE5575_EEPROM_ACCESS); 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds NVRAM_CLR_CE; 7271da177e4SLinus Torvalds /* 7281da177e4SLinus Torvalds * disable writes again 7291da177e4SLinus Torvalds */ 7301da177e4SLinus Torvalds NVRAM_CMD(EXTEND + EWDS) 7311da177e4SLinus Torvalds NVRAM_CLR_CE; 7321da177e4SLinus Torvalds CFG_AND(~NVDI); 7331da177e4SLinus Torvalds } 7341da177e4SLinus Torvalds #endif 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds static u16 ia_eeprom_get (IADEV *iadev, u32 addr) 7371da177e4SLinus Torvalds { 7381da177e4SLinus Torvalds u_short val; 7391da177e4SLinus Torvalds u32 t; 7401da177e4SLinus Torvalds int i; 7411da177e4SLinus Torvalds /* 7421da177e4SLinus Torvalds * Read the first bit that was clocked with the falling edge of the 7431da177e4SLinus Torvalds * the last command data clock 7441da177e4SLinus Torvalds */ 7451da177e4SLinus Torvalds NVRAM_CMD(IAREAD + addr); 7461da177e4SLinus Torvalds /* 7471da177e4SLinus Torvalds * Now read the rest of the bits, the next bit read is D14, then D13, 7481da177e4SLinus Torvalds * and so on. 7491da177e4SLinus Torvalds */ 7501da177e4SLinus Torvalds val = 0; 7511da177e4SLinus Torvalds for (i=15; i>=0; i--) { 7521da177e4SLinus Torvalds NVRAM_CLKIN(t); 7531da177e4SLinus Torvalds val |= (t << i); 7541da177e4SLinus Torvalds } 7551da177e4SLinus Torvalds NVRAM_CLR_CE; 7561da177e4SLinus Torvalds CFG_AND(~NVDI); 7571da177e4SLinus Torvalds return val; 7581da177e4SLinus Torvalds } 7591da177e4SLinus Torvalds 7601da177e4SLinus Torvalds static void ia_hw_type(IADEV *iadev) { 7611da177e4SLinus Torvalds u_short memType = ia_eeprom_get(iadev, 25); 7621da177e4SLinus Torvalds iadev->memType = memType; 7631da177e4SLinus Torvalds if ((memType & MEM_SIZE_MASK) == MEM_SIZE_1M) { 7641da177e4SLinus Torvalds iadev->num_tx_desc = IA_TX_BUF; 7651da177e4SLinus Torvalds iadev->tx_buf_sz = IA_TX_BUF_SZ; 7661da177e4SLinus Torvalds iadev->num_rx_desc = IA_RX_BUF; 7671da177e4SLinus Torvalds iadev->rx_buf_sz = IA_RX_BUF_SZ; 7681da177e4SLinus Torvalds } else if ((memType & MEM_SIZE_MASK) == MEM_SIZE_512K) { 7691da177e4SLinus Torvalds if (IA_TX_BUF == DFL_TX_BUFFERS) 7701da177e4SLinus Torvalds iadev->num_tx_desc = IA_TX_BUF / 2; 7711da177e4SLinus Torvalds else 7721da177e4SLinus Torvalds iadev->num_tx_desc = IA_TX_BUF; 7731da177e4SLinus Torvalds iadev->tx_buf_sz = IA_TX_BUF_SZ; 7741da177e4SLinus Torvalds if (IA_RX_BUF == DFL_RX_BUFFERS) 7751da177e4SLinus Torvalds iadev->num_rx_desc = IA_RX_BUF / 2; 7761da177e4SLinus Torvalds else 7771da177e4SLinus Torvalds iadev->num_rx_desc = IA_RX_BUF; 7781da177e4SLinus Torvalds iadev->rx_buf_sz = IA_RX_BUF_SZ; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds else { 7811da177e4SLinus Torvalds if (IA_TX_BUF == DFL_TX_BUFFERS) 7821da177e4SLinus Torvalds iadev->num_tx_desc = IA_TX_BUF / 8; 7831da177e4SLinus Torvalds else 7841da177e4SLinus Torvalds iadev->num_tx_desc = IA_TX_BUF; 7851da177e4SLinus Torvalds iadev->tx_buf_sz = IA_TX_BUF_SZ; 7861da177e4SLinus Torvalds if (IA_RX_BUF == DFL_RX_BUFFERS) 7871da177e4SLinus Torvalds iadev->num_rx_desc = IA_RX_BUF / 8; 7881da177e4SLinus Torvalds else 7891da177e4SLinus Torvalds iadev->num_rx_desc = IA_RX_BUF; 7901da177e4SLinus Torvalds iadev->rx_buf_sz = IA_RX_BUF_SZ; 7911da177e4SLinus Torvalds } 7921da177e4SLinus Torvalds iadev->rx_pkt_ram = TX_PACKET_RAM + (iadev->num_tx_desc * iadev->tx_buf_sz); 7931da177e4SLinus Torvalds IF_INIT(printk("BUF: tx=%d,sz=%d rx=%d sz= %d rx_pkt_ram=%d\n", 7941da177e4SLinus Torvalds iadev->num_tx_desc, iadev->tx_buf_sz, iadev->num_rx_desc, 7951da177e4SLinus Torvalds iadev->rx_buf_sz, iadev->rx_pkt_ram);) 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds #if 0 7981da177e4SLinus Torvalds if ((memType & FE_MASK) == FE_SINGLE_MODE) { 7991da177e4SLinus Torvalds iadev->phy_type = PHY_OC3C_S; 8001da177e4SLinus Torvalds else if ((memType & FE_MASK) == FE_UTP_OPTION) 8011da177e4SLinus Torvalds iadev->phy_type = PHY_UTP155; 8021da177e4SLinus Torvalds else 8031da177e4SLinus Torvalds iadev->phy_type = PHY_OC3C_M; 8041da177e4SLinus Torvalds #endif 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds iadev->phy_type = memType & FE_MASK; 8071da177e4SLinus Torvalds IF_INIT(printk("memType = 0x%x iadev->phy_type = 0x%x\n", 8081da177e4SLinus Torvalds memType,iadev->phy_type);) 8091da177e4SLinus Torvalds if (iadev->phy_type == FE_25MBIT_PHY) 8101da177e4SLinus Torvalds iadev->LineRate = (u32)(((25600000/8)*26)/(27*53)); 8111da177e4SLinus Torvalds else if (iadev->phy_type == FE_DS3_PHY) 8121da177e4SLinus Torvalds iadev->LineRate = (u32)(((44736000/8)*26)/(27*53)); 8131da177e4SLinus Torvalds else if (iadev->phy_type == FE_E3_PHY) 8141da177e4SLinus Torvalds iadev->LineRate = (u32)(((34368000/8)*26)/(27*53)); 8151da177e4SLinus Torvalds else 8161da177e4SLinus Torvalds iadev->LineRate = (u32)(ATM_OC3_PCR); 8171da177e4SLinus Torvalds IF_INIT(printk("iadev->LineRate = %d \n", iadev->LineRate);) 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds } 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds static void IaFrontEndIntr(IADEV *iadev) { 8221da177e4SLinus Torvalds volatile IA_SUNI *suni; 8231da177e4SLinus Torvalds volatile ia_mb25_t *mb25; 8241da177e4SLinus Torvalds volatile suni_pm7345_t *suni_pm7345; 8251da177e4SLinus Torvalds u32 intr_status; 8261da177e4SLinus Torvalds u_int frmr_intr; 8271da177e4SLinus Torvalds 8281da177e4SLinus Torvalds if(iadev->phy_type & FE_25MBIT_PHY) { 8291da177e4SLinus Torvalds mb25 = (ia_mb25_t*)iadev->phy; 8301da177e4SLinus Torvalds iadev->carrier_detect = Boolean(mb25->mb25_intr_status & MB25_IS_GSB); 8311da177e4SLinus Torvalds } else if (iadev->phy_type & FE_DS3_PHY) { 8321da177e4SLinus Torvalds suni_pm7345 = (suni_pm7345_t *)iadev->phy; 8331da177e4SLinus Torvalds /* clear FRMR interrupts */ 8341da177e4SLinus Torvalds frmr_intr = suni_pm7345->suni_ds3_frm_intr_stat; 8351da177e4SLinus Torvalds iadev->carrier_detect = 8361da177e4SLinus Torvalds Boolean(!(suni_pm7345->suni_ds3_frm_stat & SUNI_DS3_LOSV)); 8371da177e4SLinus Torvalds } else if (iadev->phy_type & FE_E3_PHY ) { 8381da177e4SLinus Torvalds suni_pm7345 = (suni_pm7345_t *)iadev->phy; 8391da177e4SLinus Torvalds frmr_intr = suni_pm7345->suni_e3_frm_maint_intr_ind; 8401da177e4SLinus Torvalds iadev->carrier_detect = 8411da177e4SLinus Torvalds Boolean(!(suni_pm7345->suni_e3_frm_fram_intr_ind_stat&SUNI_E3_LOS)); 8421da177e4SLinus Torvalds } 8431da177e4SLinus Torvalds else { 8441da177e4SLinus Torvalds suni = (IA_SUNI *)iadev->phy; 8451da177e4SLinus Torvalds intr_status = suni->suni_rsop_status & 0xff; 8461da177e4SLinus Torvalds iadev->carrier_detect = Boolean(!(suni->suni_rsop_status & SUNI_LOSV)); 8471da177e4SLinus Torvalds } 8481da177e4SLinus Torvalds if (iadev->carrier_detect) 8491da177e4SLinus Torvalds printk("IA: SUNI carrier detected\n"); 8501da177e4SLinus Torvalds else 8511da177e4SLinus Torvalds printk("IA: SUNI carrier lost signal\n"); 8521da177e4SLinus Torvalds return; 8531da177e4SLinus Torvalds } 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds static void ia_mb25_init (IADEV *iadev) 8561da177e4SLinus Torvalds { 8571da177e4SLinus Torvalds volatile ia_mb25_t *mb25 = (ia_mb25_t*)iadev->phy; 8581da177e4SLinus Torvalds #if 0 8591da177e4SLinus Torvalds mb25->mb25_master_ctrl = MB25_MC_DRIC | MB25_MC_DREC | MB25_MC_ENABLED; 8601da177e4SLinus Torvalds #endif 8611da177e4SLinus Torvalds mb25->mb25_master_ctrl = MB25_MC_DRIC | MB25_MC_DREC; 8621da177e4SLinus Torvalds mb25->mb25_diag_control = 0; 8631da177e4SLinus Torvalds /* 8641da177e4SLinus Torvalds * Initialize carrier detect state 8651da177e4SLinus Torvalds */ 8661da177e4SLinus Torvalds iadev->carrier_detect = Boolean(mb25->mb25_intr_status & MB25_IS_GSB); 8671da177e4SLinus Torvalds return; 8681da177e4SLinus Torvalds } 8691da177e4SLinus Torvalds 8701da177e4SLinus Torvalds static void ia_suni_pm7345_init (IADEV *iadev) 8711da177e4SLinus Torvalds { 8721da177e4SLinus Torvalds volatile suni_pm7345_t *suni_pm7345 = (suni_pm7345_t *)iadev->phy; 8731da177e4SLinus Torvalds if (iadev->phy_type & FE_DS3_PHY) 8741da177e4SLinus Torvalds { 8751da177e4SLinus Torvalds iadev->carrier_detect = 8761da177e4SLinus Torvalds Boolean(!(suni_pm7345->suni_ds3_frm_stat & SUNI_DS3_LOSV)); 8771da177e4SLinus Torvalds suni_pm7345->suni_ds3_frm_intr_enbl = 0x17; 8781da177e4SLinus Torvalds suni_pm7345->suni_ds3_frm_cfg = 1; 8791da177e4SLinus Torvalds suni_pm7345->suni_ds3_tran_cfg = 1; 8801da177e4SLinus Torvalds suni_pm7345->suni_config = 0; 8811da177e4SLinus Torvalds suni_pm7345->suni_splr_cfg = 0; 8821da177e4SLinus Torvalds suni_pm7345->suni_splt_cfg = 0; 8831da177e4SLinus Torvalds } 8841da177e4SLinus Torvalds else 8851da177e4SLinus Torvalds { 8861da177e4SLinus Torvalds iadev->carrier_detect = 8871da177e4SLinus Torvalds Boolean(!(suni_pm7345->suni_e3_frm_fram_intr_ind_stat & SUNI_E3_LOS)); 8881da177e4SLinus Torvalds suni_pm7345->suni_e3_frm_fram_options = 0x4; 8891da177e4SLinus Torvalds suni_pm7345->suni_e3_frm_maint_options = 0x20; 8901da177e4SLinus Torvalds suni_pm7345->suni_e3_frm_fram_intr_enbl = 0x1d; 8911da177e4SLinus Torvalds suni_pm7345->suni_e3_frm_maint_intr_enbl = 0x30; 8921da177e4SLinus Torvalds suni_pm7345->suni_e3_tran_stat_diag_options = 0x0; 8931da177e4SLinus Torvalds suni_pm7345->suni_e3_tran_fram_options = 0x1; 8941da177e4SLinus Torvalds suni_pm7345->suni_config = SUNI_PM7345_E3ENBL; 8951da177e4SLinus Torvalds suni_pm7345->suni_splr_cfg = 0x41; 8961da177e4SLinus Torvalds suni_pm7345->suni_splt_cfg = 0x41; 8971da177e4SLinus Torvalds } 8981da177e4SLinus Torvalds /* 8991da177e4SLinus Torvalds * Enable RSOP loss of signal interrupt. 9001da177e4SLinus Torvalds */ 9011da177e4SLinus Torvalds suni_pm7345->suni_intr_enbl = 0x28; 9021da177e4SLinus Torvalds 9031da177e4SLinus Torvalds /* 9041da177e4SLinus Torvalds * Clear error counters 9051da177e4SLinus Torvalds */ 9061da177e4SLinus Torvalds suni_pm7345->suni_id_reset = 0; 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds /* 9091da177e4SLinus Torvalds * Clear "PMCTST" in master test register. 9101da177e4SLinus Torvalds */ 9111da177e4SLinus Torvalds suni_pm7345->suni_master_test = 0; 9121da177e4SLinus Torvalds 9131da177e4SLinus Torvalds suni_pm7345->suni_rxcp_ctrl = 0x2c; 9141da177e4SLinus Torvalds suni_pm7345->suni_rxcp_fctrl = 0x81; 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_pat_h1 = 9171da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_pat_h2 = 9181da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_pat_h3 = 0; 9191da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_pat_h4 = 1; 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_mask_h1 = 0xff; 9221da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_mask_h2 = 0xff; 9231da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_mask_h3 = 0xff; 9241da177e4SLinus Torvalds suni_pm7345->suni_rxcp_idle_mask_h4 = 0xfe; 9251da177e4SLinus Torvalds 9261da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_pat_h1 = 9271da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_pat_h2 = 9281da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_pat_h3 = 0; 9291da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_pat_h4 = 1; 9301da177e4SLinus Torvalds 9311da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_mask_h1 = 9321da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_mask_h2 = 9331da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_mask_h3 = 9341da177e4SLinus Torvalds suni_pm7345->suni_rxcp_cell_mask_h4 = 0xff; 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds suni_pm7345->suni_txcp_ctrl = 0xa4; 9371da177e4SLinus Torvalds suni_pm7345->suni_txcp_intr_en_sts = 0x10; 9381da177e4SLinus Torvalds suni_pm7345->suni_txcp_idle_pat_h5 = 0x55; 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds suni_pm7345->suni_config &= ~(SUNI_PM7345_LLB | 9411da177e4SLinus Torvalds SUNI_PM7345_CLB | 9421da177e4SLinus Torvalds SUNI_PM7345_DLB | 9431da177e4SLinus Torvalds SUNI_PM7345_PLB); 9441da177e4SLinus Torvalds #ifdef __SNMP__ 9451da177e4SLinus Torvalds suni_pm7345->suni_rxcp_intr_en_sts |= SUNI_OOCDE; 9461da177e4SLinus Torvalds #endif /* __SNMP__ */ 9471da177e4SLinus Torvalds return; 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds /***************************** IA_LIB END *****************************/ 9521da177e4SLinus Torvalds 953a22eb6faSLeonardo Potenza #ifdef CONFIG_ATM_IA_DEBUG 9541da177e4SLinus Torvalds static int tcnter = 0; 9551da177e4SLinus Torvalds static void xdump( u_char* cp, int length, char* prefix ) 9561da177e4SLinus Torvalds { 9571da177e4SLinus Torvalds int col, count; 9581da177e4SLinus Torvalds u_char prntBuf[120]; 9591da177e4SLinus Torvalds u_char* pBuf = prntBuf; 9601da177e4SLinus Torvalds count = 0; 9611da177e4SLinus Torvalds while(count < length){ 9621da177e4SLinus Torvalds pBuf += sprintf( pBuf, "%s", prefix ); 9631da177e4SLinus Torvalds for(col = 0;count + col < length && col < 16; col++){ 9641da177e4SLinus Torvalds if (col != 0 && (col % 4) == 0) 9651da177e4SLinus Torvalds pBuf += sprintf( pBuf, " " ); 9661da177e4SLinus Torvalds pBuf += sprintf( pBuf, "%02X ", cp[count + col] ); 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds while(col++ < 16){ /* pad end of buffer with blanks */ 9691da177e4SLinus Torvalds if ((col % 4) == 0) 9701da177e4SLinus Torvalds sprintf( pBuf, " " ); 9711da177e4SLinus Torvalds pBuf += sprintf( pBuf, " " ); 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds pBuf += sprintf( pBuf, " " ); 9741da177e4SLinus Torvalds for(col = 0;count + col < length && col < 16; col++){ 9751da177e4SLinus Torvalds if (isprint((int)cp[count + col])) 9761da177e4SLinus Torvalds pBuf += sprintf( pBuf, "%c", cp[count + col] ); 9771da177e4SLinus Torvalds else 9781da177e4SLinus Torvalds pBuf += sprintf( pBuf, "." ); 9791da177e4SLinus Torvalds } 9801da177e4SLinus Torvalds sprintf( pBuf, "\n" ); 9811da177e4SLinus Torvalds // SPrint(prntBuf); 9821da177e4SLinus Torvalds printk(prntBuf); 9831da177e4SLinus Torvalds count += col; 9841da177e4SLinus Torvalds pBuf = prntBuf; 9851da177e4SLinus Torvalds } 9861da177e4SLinus Torvalds 9871da177e4SLinus Torvalds } /* close xdump(... */ 988a22eb6faSLeonardo Potenza #endif /* CONFIG_ATM_IA_DEBUG */ 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds 9911da177e4SLinus Torvalds static struct atm_dev *ia_boards = NULL; 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds #define ACTUAL_RAM_BASE \ 9941da177e4SLinus Torvalds RAM_BASE*((iadev->mem)/(128 * 1024)) 9951da177e4SLinus Torvalds #define ACTUAL_SEG_RAM_BASE \ 9961da177e4SLinus Torvalds IPHASE5575_FRAG_CONTROL_RAM_BASE*((iadev->mem)/(128 * 1024)) 9971da177e4SLinus Torvalds #define ACTUAL_REASS_RAM_BASE \ 9981da177e4SLinus Torvalds IPHASE5575_REASS_CONTROL_RAM_BASE*((iadev->mem)/(128 * 1024)) 9991da177e4SLinus Torvalds 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds /*-- some utilities and memory allocation stuff will come here -------------*/ 10021da177e4SLinus Torvalds 10031da177e4SLinus Torvalds static void desc_dbg(IADEV *iadev) { 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds u_short tcq_wr_ptr, tcq_st_ptr, tcq_ed_ptr; 10061da177e4SLinus Torvalds u32 i; 10071da177e4SLinus Torvalds void __iomem *tmp; 10081da177e4SLinus Torvalds // regval = readl((u32)ia_cmds->maddr); 10091da177e4SLinus Torvalds tcq_wr_ptr = readw(iadev->seg_reg+TCQ_WR_PTR); 10101da177e4SLinus Torvalds printk("B_tcq_wr = 0x%x desc = %d last desc = %d\n", 10111da177e4SLinus Torvalds tcq_wr_ptr, readw(iadev->seg_ram+tcq_wr_ptr), 10121da177e4SLinus Torvalds readw(iadev->seg_ram+tcq_wr_ptr-2)); 10131da177e4SLinus Torvalds printk(" host_tcq_wr = 0x%x host_tcq_rd = 0x%x \n", iadev->host_tcq_wr, 10141da177e4SLinus Torvalds iadev->ffL.tcq_rd); 10151da177e4SLinus Torvalds tcq_st_ptr = readw(iadev->seg_reg+TCQ_ST_ADR); 10161da177e4SLinus Torvalds tcq_ed_ptr = readw(iadev->seg_reg+TCQ_ED_ADR); 10171da177e4SLinus Torvalds printk("tcq_st_ptr = 0x%x tcq_ed_ptr = 0x%x \n", tcq_st_ptr, tcq_ed_ptr); 10181da177e4SLinus Torvalds i = 0; 10191da177e4SLinus Torvalds while (tcq_st_ptr != tcq_ed_ptr) { 10201da177e4SLinus Torvalds tmp = iadev->seg_ram+tcq_st_ptr; 10211da177e4SLinus Torvalds printk("TCQ slot %d desc = %d Addr = %p\n", i++, readw(tmp), tmp); 10221da177e4SLinus Torvalds tcq_st_ptr += 2; 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds for(i=0; i <iadev->num_tx_desc; i++) 10251da177e4SLinus Torvalds printk("Desc_tbl[%d] = %d \n", i, iadev->desc_tbl[i].timestamp); 10261da177e4SLinus Torvalds } 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds /*----------------------------- Recieving side stuff --------------------------*/ 10301da177e4SLinus Torvalds 10311da177e4SLinus Torvalds static void rx_excp_rcvd(struct atm_dev *dev) 10321da177e4SLinus Torvalds { 10331da177e4SLinus Torvalds #if 0 /* closing the receiving size will cause too many excp int */ 10341da177e4SLinus Torvalds IADEV *iadev; 10351da177e4SLinus Torvalds u_short state; 10361da177e4SLinus Torvalds u_short excpq_rd_ptr; 10371da177e4SLinus Torvalds //u_short *ptr; 10381da177e4SLinus Torvalds int vci, error = 1; 10391da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 10401da177e4SLinus Torvalds state = readl(iadev->reass_reg + STATE_REG) & 0xffff; 10411da177e4SLinus Torvalds while((state & EXCPQ_EMPTY) != EXCPQ_EMPTY) 10421da177e4SLinus Torvalds { printk("state = %x \n", state); 10431da177e4SLinus Torvalds excpq_rd_ptr = readw(iadev->reass_reg + EXCP_Q_RD_PTR) & 0xffff; 10441da177e4SLinus Torvalds printk("state = %x excpq_rd_ptr = %x \n", state, excpq_rd_ptr); 10451da177e4SLinus Torvalds if (excpq_rd_ptr == *(u16*)(iadev->reass_reg + EXCP_Q_WR_PTR)) 10461da177e4SLinus Torvalds IF_ERR(printk("excpq_rd_ptr is wrong!!!\n");) 10471da177e4SLinus Torvalds // TODO: update exception stat 10481da177e4SLinus Torvalds vci = readw(iadev->reass_ram+excpq_rd_ptr); 10491da177e4SLinus Torvalds error = readw(iadev->reass_ram+excpq_rd_ptr+2) & 0x0007; 10501da177e4SLinus Torvalds // pwang_test 10511da177e4SLinus Torvalds excpq_rd_ptr += 4; 10521da177e4SLinus Torvalds if (excpq_rd_ptr > (readw(iadev->reass_reg + EXCP_Q_ED_ADR)& 0xffff)) 10531da177e4SLinus Torvalds excpq_rd_ptr = readw(iadev->reass_reg + EXCP_Q_ST_ADR)& 0xffff; 10541da177e4SLinus Torvalds writew( excpq_rd_ptr, iadev->reass_reg + EXCP_Q_RD_PTR); 10551da177e4SLinus Torvalds state = readl(iadev->reass_reg + STATE_REG) & 0xffff; 10561da177e4SLinus Torvalds } 10571da177e4SLinus Torvalds #endif 10581da177e4SLinus Torvalds } 10591da177e4SLinus Torvalds 10601da177e4SLinus Torvalds static void free_desc(struct atm_dev *dev, int desc) 10611da177e4SLinus Torvalds { 10621da177e4SLinus Torvalds IADEV *iadev; 10631da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 10641da177e4SLinus Torvalds writew(desc, iadev->reass_ram+iadev->rfL.fdq_wr); 10651da177e4SLinus Torvalds iadev->rfL.fdq_wr +=2; 10661da177e4SLinus Torvalds if (iadev->rfL.fdq_wr > iadev->rfL.fdq_ed) 10671da177e4SLinus Torvalds iadev->rfL.fdq_wr = iadev->rfL.fdq_st; 10681da177e4SLinus Torvalds writew(iadev->rfL.fdq_wr, iadev->reass_reg+FREEQ_WR_PTR); 10691da177e4SLinus Torvalds } 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds static int rx_pkt(struct atm_dev *dev) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds IADEV *iadev; 10751da177e4SLinus Torvalds struct atm_vcc *vcc; 10761da177e4SLinus Torvalds unsigned short status; 10771da177e4SLinus Torvalds struct rx_buf_desc __iomem *buf_desc_ptr; 10781da177e4SLinus Torvalds int desc; 10791da177e4SLinus Torvalds struct dle* wr_ptr; 10801da177e4SLinus Torvalds int len; 10811da177e4SLinus Torvalds struct sk_buff *skb; 10821da177e4SLinus Torvalds u_int buf_addr, dma_addr; 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 10851da177e4SLinus Torvalds if (iadev->rfL.pcq_rd == (readw(iadev->reass_reg+PCQ_WR_PTR)&0xffff)) 10861da177e4SLinus Torvalds { 10871da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "(itf %d) Receive queue empty\n", dev->number); 10881da177e4SLinus Torvalds return -EINVAL; 10891da177e4SLinus Torvalds } 10901da177e4SLinus Torvalds /* mask 1st 3 bits to get the actual descno. */ 10911da177e4SLinus Torvalds desc = readw(iadev->reass_ram+iadev->rfL.pcq_rd) & 0x1fff; 10921da177e4SLinus Torvalds IF_RX(printk("reass_ram = %p iadev->rfL.pcq_rd = 0x%x desc = %d\n", 10931da177e4SLinus Torvalds iadev->reass_ram, iadev->rfL.pcq_rd, desc); 10941da177e4SLinus Torvalds printk(" pcq_wr_ptr = 0x%x\n", 10951da177e4SLinus Torvalds readw(iadev->reass_reg+PCQ_WR_PTR)&0xffff);) 10961da177e4SLinus Torvalds /* update the read pointer - maybe we shud do this in the end*/ 10971da177e4SLinus Torvalds if ( iadev->rfL.pcq_rd== iadev->rfL.pcq_ed) 10981da177e4SLinus Torvalds iadev->rfL.pcq_rd = iadev->rfL.pcq_st; 10991da177e4SLinus Torvalds else 11001da177e4SLinus Torvalds iadev->rfL.pcq_rd += 2; 11011da177e4SLinus Torvalds writew(iadev->rfL.pcq_rd, iadev->reass_reg+PCQ_RD_PTR); 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds /* get the buffer desc entry. 11041da177e4SLinus Torvalds update stuff. - doesn't seem to be any update necessary 11051da177e4SLinus Torvalds */ 11061da177e4SLinus Torvalds buf_desc_ptr = iadev->RX_DESC_BASE_ADDR; 11071da177e4SLinus Torvalds /* make the ptr point to the corresponding buffer desc entry */ 11081da177e4SLinus Torvalds buf_desc_ptr += desc; 11091da177e4SLinus Torvalds if (!desc || (desc > iadev->num_rx_desc) || 11101da177e4SLinus Torvalds ((buf_desc_ptr->vc_index & 0xffff) > iadev->num_vc)) { 11111da177e4SLinus Torvalds free_desc(dev, desc); 11121da177e4SLinus Torvalds IF_ERR(printk("IA: bad descriptor desc = %d \n", desc);) 11131da177e4SLinus Torvalds return -1; 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds vcc = iadev->rx_open[buf_desc_ptr->vc_index & 0xffff]; 11161da177e4SLinus Torvalds if (!vcc) 11171da177e4SLinus Torvalds { 11181da177e4SLinus Torvalds free_desc(dev, desc); 11191da177e4SLinus Torvalds printk("IA: null vcc, drop PDU\n"); 11201da177e4SLinus Torvalds return -1; 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds /* might want to check the status bits for errors */ 11251da177e4SLinus Torvalds status = (u_short) (buf_desc_ptr->desc_mode); 11261da177e4SLinus Torvalds if (status & (RX_CER | RX_PTE | RX_OFL)) 11271da177e4SLinus Torvalds { 11281da177e4SLinus Torvalds atomic_inc(&vcc->stats->rx_err); 11291da177e4SLinus Torvalds IF_ERR(printk("IA: bad packet, dropping it");) 11301da177e4SLinus Torvalds if (status & RX_CER) { 11311da177e4SLinus Torvalds IF_ERR(printk(" cause: packet CRC error\n");) 11321da177e4SLinus Torvalds } 11331da177e4SLinus Torvalds else if (status & RX_PTE) { 11341da177e4SLinus Torvalds IF_ERR(printk(" cause: packet time out\n");) 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds else { 11371da177e4SLinus Torvalds IF_ERR(printk(" cause: buffer over flow\n");) 11381da177e4SLinus Torvalds } 11391da177e4SLinus Torvalds goto out_free_desc; 11401da177e4SLinus Torvalds } 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds /* 11431da177e4SLinus Torvalds build DLE. 11441da177e4SLinus Torvalds */ 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds buf_addr = (buf_desc_ptr->buf_start_hi << 16) | buf_desc_ptr->buf_start_lo; 11471da177e4SLinus Torvalds dma_addr = (buf_desc_ptr->dma_start_hi << 16) | buf_desc_ptr->dma_start_lo; 11481da177e4SLinus Torvalds len = dma_addr - buf_addr; 11491da177e4SLinus Torvalds if (len > iadev->rx_buf_sz) { 11501da177e4SLinus Torvalds printk("Over %d bytes sdu received, dropped!!!\n", iadev->rx_buf_sz); 11511da177e4SLinus Torvalds atomic_inc(&vcc->stats->rx_err); 11521da177e4SLinus Torvalds goto out_free_desc; 11531da177e4SLinus Torvalds } 11541da177e4SLinus Torvalds 11551da177e4SLinus Torvalds if (!(skb = atm_alloc_charge(vcc, len, GFP_ATOMIC))) { 11561da177e4SLinus Torvalds if (vcc->vci < 32) 11571da177e4SLinus Torvalds printk("Drop control packets\n"); 11581da177e4SLinus Torvalds goto out_free_desc; 11591da177e4SLinus Torvalds } 11601da177e4SLinus Torvalds skb_put(skb,len); 11611da177e4SLinus Torvalds // pwang_test 11621da177e4SLinus Torvalds ATM_SKB(skb)->vcc = vcc; 11631da177e4SLinus Torvalds ATM_DESC(skb) = desc; 11641da177e4SLinus Torvalds skb_queue_tail(&iadev->rx_dma_q, skb); 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds /* Build the DLE structure */ 11671da177e4SLinus Torvalds wr_ptr = iadev->rx_dle_q.write; 11681da177e4SLinus Torvalds wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data, 11691da177e4SLinus Torvalds len, PCI_DMA_FROMDEVICE); 11701da177e4SLinus Torvalds wr_ptr->local_pkt_addr = buf_addr; 11711da177e4SLinus Torvalds wr_ptr->bytes = len; /* We don't know this do we ?? */ 11721da177e4SLinus Torvalds wr_ptr->mode = DMA_INT_ENABLE; 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds /* shud take care of wrap around here too. */ 11751da177e4SLinus Torvalds if(++wr_ptr == iadev->rx_dle_q.end) 11761da177e4SLinus Torvalds wr_ptr = iadev->rx_dle_q.start; 11771da177e4SLinus Torvalds iadev->rx_dle_q.write = wr_ptr; 11781da177e4SLinus Torvalds udelay(1); 11791da177e4SLinus Torvalds /* Increment transaction counter */ 11801da177e4SLinus Torvalds writel(1, iadev->dma+IPHASE5575_RX_COUNTER); 11811da177e4SLinus Torvalds out: return 0; 11821da177e4SLinus Torvalds out_free_desc: 11831da177e4SLinus Torvalds free_desc(dev, desc); 11841da177e4SLinus Torvalds goto out; 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds static void rx_intr(struct atm_dev *dev) 11881da177e4SLinus Torvalds { 11891da177e4SLinus Torvalds IADEV *iadev; 11901da177e4SLinus Torvalds u_short status; 11911da177e4SLinus Torvalds u_short state, i; 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 11941da177e4SLinus Torvalds status = readl(iadev->reass_reg+REASS_INTR_STATUS_REG) & 0xffff; 11951da177e4SLinus Torvalds IF_EVENT(printk("rx_intr: status = 0x%x\n", status);) 11961da177e4SLinus Torvalds if (status & RX_PKT_RCVD) 11971da177e4SLinus Torvalds { 11981da177e4SLinus Torvalds /* do something */ 11991da177e4SLinus Torvalds /* Basically recvd an interrupt for receving a packet. 12001da177e4SLinus Torvalds A descriptor would have been written to the packet complete 12011da177e4SLinus Torvalds queue. Get all the descriptors and set up dma to move the 12021da177e4SLinus Torvalds packets till the packet complete queue is empty.. 12031da177e4SLinus Torvalds */ 12041da177e4SLinus Torvalds state = readl(iadev->reass_reg + STATE_REG) & 0xffff; 12051da177e4SLinus Torvalds IF_EVENT(printk("Rx intr status: RX_PKT_RCVD %08x\n", status);) 12061da177e4SLinus Torvalds while(!(state & PCQ_EMPTY)) 12071da177e4SLinus Torvalds { 12081da177e4SLinus Torvalds rx_pkt(dev); 12091da177e4SLinus Torvalds state = readl(iadev->reass_reg + STATE_REG) & 0xffff; 12101da177e4SLinus Torvalds } 12111da177e4SLinus Torvalds iadev->rxing = 1; 12121da177e4SLinus Torvalds } 12131da177e4SLinus Torvalds if (status & RX_FREEQ_EMPT) 12141da177e4SLinus Torvalds { 12151da177e4SLinus Torvalds if (iadev->rxing) { 12161da177e4SLinus Torvalds iadev->rx_tmp_cnt = iadev->rx_pkt_cnt; 12171da177e4SLinus Torvalds iadev->rx_tmp_jif = jiffies; 12181da177e4SLinus Torvalds iadev->rxing = 0; 12191da177e4SLinus Torvalds } 1220420635f5SJulia Lawall else if ((time_after(jiffies, iadev->rx_tmp_jif + 50)) && 12211da177e4SLinus Torvalds ((iadev->rx_pkt_cnt - iadev->rx_tmp_cnt) == 0)) { 12221da177e4SLinus Torvalds for (i = 1; i <= iadev->num_rx_desc; i++) 12231da177e4SLinus Torvalds free_desc(dev, i); 12241da177e4SLinus Torvalds printk("Test logic RUN!!!!\n"); 12251da177e4SLinus Torvalds writew( ~(RX_FREEQ_EMPT|RX_EXCP_RCVD),iadev->reass_reg+REASS_MASK_REG); 12261da177e4SLinus Torvalds iadev->rxing = 1; 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds IF_EVENT(printk("Rx intr status: RX_FREEQ_EMPT %08x\n", status);) 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds if (status & RX_EXCP_RCVD) 12321da177e4SLinus Torvalds { 12331da177e4SLinus Torvalds /* probably need to handle the exception queue also. */ 12341da177e4SLinus Torvalds IF_EVENT(printk("Rx intr status: RX_EXCP_RCVD %08x\n", status);) 12351da177e4SLinus Torvalds rx_excp_rcvd(dev); 12361da177e4SLinus Torvalds } 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds 12391da177e4SLinus Torvalds if (status & RX_RAW_RCVD) 12401da177e4SLinus Torvalds { 12411da177e4SLinus Torvalds /* need to handle the raw incoming cells. This deepnds on 12421da177e4SLinus Torvalds whether we have programmed to receive the raw cells or not. 12431da177e4SLinus Torvalds Else ignore. */ 12441da177e4SLinus Torvalds IF_EVENT(printk("Rx intr status: RX_RAW_RCVD %08x\n", status);) 12451da177e4SLinus Torvalds } 12461da177e4SLinus Torvalds } 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds static void rx_dle_intr(struct atm_dev *dev) 12501da177e4SLinus Torvalds { 12511da177e4SLinus Torvalds IADEV *iadev; 12521da177e4SLinus Torvalds struct atm_vcc *vcc; 12531da177e4SLinus Torvalds struct sk_buff *skb; 12541da177e4SLinus Torvalds int desc; 12551da177e4SLinus Torvalds u_short state; 12561da177e4SLinus Torvalds struct dle *dle, *cur_dle; 12571da177e4SLinus Torvalds u_int dle_lp; 12581da177e4SLinus Torvalds int len; 12591da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds /* free all the dles done, that is just update our own dle read pointer 12621da177e4SLinus Torvalds - do we really need to do this. Think not. */ 12631da177e4SLinus Torvalds /* DMA is done, just get all the recevie buffers from the rx dma queue 12641da177e4SLinus Torvalds and push them up to the higher layer protocol. Also free the desc 12651da177e4SLinus Torvalds associated with the buffer. */ 12661da177e4SLinus Torvalds dle = iadev->rx_dle_q.read; 12671da177e4SLinus Torvalds dle_lp = readl(iadev->dma+IPHASE5575_RX_LIST_ADDR) & (sizeof(struct dle)*DLE_ENTRIES - 1); 12681da177e4SLinus Torvalds cur_dle = (struct dle*)(iadev->rx_dle_q.start + (dle_lp >> 4)); 12691da177e4SLinus Torvalds while(dle != cur_dle) 12701da177e4SLinus Torvalds { 12711da177e4SLinus Torvalds /* free the DMAed skb */ 12721da177e4SLinus Torvalds skb = skb_dequeue(&iadev->rx_dma_q); 12731da177e4SLinus Torvalds if (!skb) 12741da177e4SLinus Torvalds goto INCR_DLE; 12751da177e4SLinus Torvalds desc = ATM_DESC(skb); 12761da177e4SLinus Torvalds free_desc(dev, desc); 12771da177e4SLinus Torvalds 12781da177e4SLinus Torvalds if (!(len = skb->len)) 12791da177e4SLinus Torvalds { 12801da177e4SLinus Torvalds printk("rx_dle_intr: skb len 0\n"); 12811da177e4SLinus Torvalds dev_kfree_skb_any(skb); 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds else 12841da177e4SLinus Torvalds { 12851da177e4SLinus Torvalds struct cpcs_trailer *trailer; 12861da177e4SLinus Torvalds u_short length; 12871da177e4SLinus Torvalds struct ia_vcc *ia_vcc; 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds pci_unmap_single(iadev->pci, iadev->rx_dle_q.write->sys_pkt_addr, 12901da177e4SLinus Torvalds len, PCI_DMA_FROMDEVICE); 12911da177e4SLinus Torvalds /* no VCC related housekeeping done as yet. lets see */ 12921da177e4SLinus Torvalds vcc = ATM_SKB(skb)->vcc; 12931da177e4SLinus Torvalds if (!vcc) { 12941da177e4SLinus Torvalds printk("IA: null vcc\n"); 12951da177e4SLinus Torvalds dev_kfree_skb_any(skb); 12961da177e4SLinus Torvalds goto INCR_DLE; 12971da177e4SLinus Torvalds } 12981da177e4SLinus Torvalds ia_vcc = INPH_IA_VCC(vcc); 12991da177e4SLinus Torvalds if (ia_vcc == NULL) 13001da177e4SLinus Torvalds { 13011da177e4SLinus Torvalds atomic_inc(&vcc->stats->rx_err); 13021da177e4SLinus Torvalds dev_kfree_skb_any(skb); 13031da177e4SLinus Torvalds atm_return(vcc, atm_guess_pdu2truesize(len)); 13041da177e4SLinus Torvalds goto INCR_DLE; 13051da177e4SLinus Torvalds } 13061da177e4SLinus Torvalds // get real pkt length pwang_test 13071da177e4SLinus Torvalds trailer = (struct cpcs_trailer*)((u_char *)skb->data + 13081da177e4SLinus Torvalds skb->len - sizeof(*trailer)); 13091da177e4SLinus Torvalds length = swap(trailer->length); 13101da177e4SLinus Torvalds if ((length > iadev->rx_buf_sz) || (length > 13111da177e4SLinus Torvalds (skb->len - sizeof(struct cpcs_trailer)))) 13121da177e4SLinus Torvalds { 13131da177e4SLinus Torvalds atomic_inc(&vcc->stats->rx_err); 13141da177e4SLinus Torvalds IF_ERR(printk("rx_dle_intr: Bad AAL5 trailer %d (skb len %d)", 13151da177e4SLinus Torvalds length, skb->len);) 13161da177e4SLinus Torvalds dev_kfree_skb_any(skb); 13171da177e4SLinus Torvalds atm_return(vcc, atm_guess_pdu2truesize(len)); 13181da177e4SLinus Torvalds goto INCR_DLE; 13191da177e4SLinus Torvalds } 13201da177e4SLinus Torvalds skb_trim(skb, length); 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds /* Display the packet */ 13231da177e4SLinus Torvalds IF_RXPKT(printk("\nDmad Recvd data: len = %d \n", skb->len); 13241da177e4SLinus Torvalds xdump(skb->data, skb->len, "RX: "); 13251da177e4SLinus Torvalds printk("\n");) 13261da177e4SLinus Torvalds 13271da177e4SLinus Torvalds IF_RX(printk("rx_dle_intr: skb push");) 13281da177e4SLinus Torvalds vcc->push(vcc,skb); 13291da177e4SLinus Torvalds atomic_inc(&vcc->stats->rx); 13301da177e4SLinus Torvalds iadev->rx_pkt_cnt++; 13311da177e4SLinus Torvalds } 13321da177e4SLinus Torvalds INCR_DLE: 13331da177e4SLinus Torvalds if (++dle == iadev->rx_dle_q.end) 13341da177e4SLinus Torvalds dle = iadev->rx_dle_q.start; 13351da177e4SLinus Torvalds } 13361da177e4SLinus Torvalds iadev->rx_dle_q.read = dle; 13371da177e4SLinus Torvalds 13381da177e4SLinus Torvalds /* if the interrupts are masked because there were no free desc available, 13391da177e4SLinus Torvalds unmask them now. */ 13401da177e4SLinus Torvalds if (!iadev->rxing) { 13411da177e4SLinus Torvalds state = readl(iadev->reass_reg + STATE_REG) & 0xffff; 13421da177e4SLinus Torvalds if (!(state & FREEQ_EMPTY)) { 13431da177e4SLinus Torvalds state = readl(iadev->reass_reg + REASS_MASK_REG) & 0xffff; 13441da177e4SLinus Torvalds writel(state & ~(RX_FREEQ_EMPT |/* RX_EXCP_RCVD |*/ RX_PKT_RCVD), 13451da177e4SLinus Torvalds iadev->reass_reg+REASS_MASK_REG); 13461da177e4SLinus Torvalds iadev->rxing++; 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds } 13491da177e4SLinus Torvalds } 13501da177e4SLinus Torvalds 13511da177e4SLinus Torvalds 13521da177e4SLinus Torvalds static int open_rx(struct atm_vcc *vcc) 13531da177e4SLinus Torvalds { 13541da177e4SLinus Torvalds IADEV *iadev; 13551da177e4SLinus Torvalds u_short __iomem *vc_table; 13561da177e4SLinus Torvalds u_short __iomem *reass_ptr; 13571da177e4SLinus Torvalds IF_EVENT(printk("iadev: open_rx %d.%d\n", vcc->vpi, vcc->vci);) 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds if (vcc->qos.rxtp.traffic_class == ATM_NONE) return 0; 13601da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 13611da177e4SLinus Torvalds if (vcc->qos.rxtp.traffic_class == ATM_ABR) { 13621da177e4SLinus Torvalds if (iadev->phy_type & FE_25MBIT_PHY) { 13631da177e4SLinus Torvalds printk("IA: ABR not support\n"); 13641da177e4SLinus Torvalds return -EINVAL; 13651da177e4SLinus Torvalds } 13661da177e4SLinus Torvalds } 13671da177e4SLinus Torvalds /* Make only this VCI in the vc table valid and let all 13681da177e4SLinus Torvalds others be invalid entries */ 13691da177e4SLinus Torvalds vc_table = iadev->reass_ram+RX_VC_TABLE*iadev->memSize; 13701da177e4SLinus Torvalds vc_table += vcc->vci; 13711da177e4SLinus Torvalds /* mask the last 6 bits and OR it with 3 for 1K VCs */ 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds *vc_table = vcc->vci << 6; 13741da177e4SLinus Torvalds /* Also keep a list of open rx vcs so that we can attach them with 13751da177e4SLinus Torvalds incoming PDUs later. */ 13761da177e4SLinus Torvalds if ((vcc->qos.rxtp.traffic_class == ATM_ABR) || 13771da177e4SLinus Torvalds (vcc->qos.txtp.traffic_class == ATM_ABR)) 13781da177e4SLinus Torvalds { 13791da177e4SLinus Torvalds srv_cls_param_t srv_p; 13801da177e4SLinus Torvalds init_abr_vc(iadev, &srv_p); 13811da177e4SLinus Torvalds ia_open_abr_vc(iadev, &srv_p, vcc, 0); 13821da177e4SLinus Torvalds } 13831da177e4SLinus Torvalds else { /* for UBR later may need to add CBR logic */ 13841da177e4SLinus Torvalds reass_ptr = iadev->reass_ram+REASS_TABLE*iadev->memSize; 13851da177e4SLinus Torvalds reass_ptr += vcc->vci; 13861da177e4SLinus Torvalds *reass_ptr = NO_AAL5_PKT; 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds if (iadev->rx_open[vcc->vci]) 13901da177e4SLinus Torvalds printk(KERN_CRIT DEV_LABEL "(itf %d): VCI %d already open\n", 13911da177e4SLinus Torvalds vcc->dev->number, vcc->vci); 13921da177e4SLinus Torvalds iadev->rx_open[vcc->vci] = vcc; 13931da177e4SLinus Torvalds return 0; 13941da177e4SLinus Torvalds } 13951da177e4SLinus Torvalds 13961da177e4SLinus Torvalds static int rx_init(struct atm_dev *dev) 13971da177e4SLinus Torvalds { 13981da177e4SLinus Torvalds IADEV *iadev; 13991da177e4SLinus Torvalds struct rx_buf_desc __iomem *buf_desc_ptr; 14001da177e4SLinus Torvalds unsigned long rx_pkt_start = 0; 14011da177e4SLinus Torvalds void *dle_addr; 14021da177e4SLinus Torvalds struct abr_vc_table *abr_vc_table; 14031da177e4SLinus Torvalds u16 *vc_table; 14041da177e4SLinus Torvalds u16 *reass_table; 14051da177e4SLinus Torvalds int i,j, vcsize_sel; 14061da177e4SLinus Torvalds u_short freeq_st_adr; 14071da177e4SLinus Torvalds u_short *freeq_start; 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 14101da177e4SLinus Torvalds // spin_lock_init(&iadev->rx_lock); 14111da177e4SLinus Torvalds 14121da177e4SLinus Torvalds /* Allocate 4k bytes - more aligned than needed (4k boundary) */ 14131da177e4SLinus Torvalds dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE, 14141da177e4SLinus Torvalds &iadev->rx_dle_dma); 14151da177e4SLinus Torvalds if (!dle_addr) { 14161da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); 14171da177e4SLinus Torvalds goto err_out; 14181da177e4SLinus Torvalds } 14191da177e4SLinus Torvalds iadev->rx_dle_q.start = (struct dle *)dle_addr; 14201da177e4SLinus Torvalds iadev->rx_dle_q.read = iadev->rx_dle_q.start; 14211da177e4SLinus Torvalds iadev->rx_dle_q.write = iadev->rx_dle_q.start; 142297928f70SAlan Cox iadev->rx_dle_q.end = (struct dle*)((unsigned long)dle_addr+sizeof(struct dle)*DLE_ENTRIES); 14231da177e4SLinus Torvalds /* the end of the dle q points to the entry after the last 14241da177e4SLinus Torvalds DLE that can be used. */ 14251da177e4SLinus Torvalds 14261da177e4SLinus Torvalds /* write the upper 20 bits of the start address to rx list address register */ 142797928f70SAlan Cox /* We know this is 32bit bus addressed so the following is safe */ 14281da177e4SLinus Torvalds writel(iadev->rx_dle_dma & 0xfffff000, 14291da177e4SLinus Torvalds iadev->dma + IPHASE5575_RX_LIST_ADDR); 14301da177e4SLinus Torvalds IF_INIT(printk("Tx Dle list addr: 0x%08x value: 0x%0x\n", 14311da177e4SLinus Torvalds (u32)(iadev->dma+IPHASE5575_TX_LIST_ADDR), 14321da177e4SLinus Torvalds *(u32*)(iadev->dma+IPHASE5575_TX_LIST_ADDR)); 14331da177e4SLinus Torvalds printk("Rx Dle list addr: 0x%08x value: 0x%0x\n", 14341da177e4SLinus Torvalds (u32)(iadev->dma+IPHASE5575_RX_LIST_ADDR), 14351da177e4SLinus Torvalds *(u32*)(iadev->dma+IPHASE5575_RX_LIST_ADDR));) 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds writew(0xffff, iadev->reass_reg+REASS_MASK_REG); 14381da177e4SLinus Torvalds writew(0, iadev->reass_reg+MODE_REG); 14391da177e4SLinus Torvalds writew(RESET_REASS, iadev->reass_reg+REASS_COMMAND_REG); 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds /* Receive side control memory map 14421da177e4SLinus Torvalds ------------------------------- 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds Buffer descr 0x0000 (736 - 23K) 14451da177e4SLinus Torvalds VP Table 0x5c00 (256 - 512) 14461da177e4SLinus Torvalds Except q 0x5e00 (128 - 512) 14471da177e4SLinus Torvalds Free buffer q 0x6000 (1K - 2K) 14481da177e4SLinus Torvalds Packet comp q 0x6800 (1K - 2K) 14491da177e4SLinus Torvalds Reass Table 0x7000 (1K - 2K) 14501da177e4SLinus Torvalds VC Table 0x7800 (1K - 2K) 14511da177e4SLinus Torvalds ABR VC Table 0x8000 (1K - 32K) 14521da177e4SLinus Torvalds */ 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds /* Base address for Buffer Descriptor Table */ 14551da177e4SLinus Torvalds writew(RX_DESC_BASE >> 16, iadev->reass_reg+REASS_DESC_BASE); 14561da177e4SLinus Torvalds /* Set the buffer size register */ 14571da177e4SLinus Torvalds writew(iadev->rx_buf_sz, iadev->reass_reg+BUF_SIZE); 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds /* Initialize each entry in the Buffer Descriptor Table */ 14601da177e4SLinus Torvalds iadev->RX_DESC_BASE_ADDR = iadev->reass_ram+RX_DESC_BASE*iadev->memSize; 14611da177e4SLinus Torvalds buf_desc_ptr = iadev->RX_DESC_BASE_ADDR; 14621da177e4SLinus Torvalds memset_io(buf_desc_ptr, 0, sizeof(*buf_desc_ptr)); 14631da177e4SLinus Torvalds buf_desc_ptr++; 14641da177e4SLinus Torvalds rx_pkt_start = iadev->rx_pkt_ram; 14651da177e4SLinus Torvalds for(i=1; i<=iadev->num_rx_desc; i++) 14661da177e4SLinus Torvalds { 14671da177e4SLinus Torvalds memset_io(buf_desc_ptr, 0, sizeof(*buf_desc_ptr)); 14681da177e4SLinus Torvalds buf_desc_ptr->buf_start_hi = rx_pkt_start >> 16; 14691da177e4SLinus Torvalds buf_desc_ptr->buf_start_lo = rx_pkt_start & 0x0000ffff; 14701da177e4SLinus Torvalds buf_desc_ptr++; 14711da177e4SLinus Torvalds rx_pkt_start += iadev->rx_buf_sz; 14721da177e4SLinus Torvalds } 14731da177e4SLinus Torvalds IF_INIT(printk("Rx Buffer desc ptr: 0x%0x\n", (u32)(buf_desc_ptr));) 14741da177e4SLinus Torvalds i = FREE_BUF_DESC_Q*iadev->memSize; 14751da177e4SLinus Torvalds writew(i >> 16, iadev->reass_reg+REASS_QUEUE_BASE); 14761da177e4SLinus Torvalds writew(i, iadev->reass_reg+FREEQ_ST_ADR); 14771da177e4SLinus Torvalds writew(i+iadev->num_rx_desc*sizeof(u_short), 14781da177e4SLinus Torvalds iadev->reass_reg+FREEQ_ED_ADR); 14791da177e4SLinus Torvalds writew(i, iadev->reass_reg+FREEQ_RD_PTR); 14801da177e4SLinus Torvalds writew(i+iadev->num_rx_desc*sizeof(u_short), 14811da177e4SLinus Torvalds iadev->reass_reg+FREEQ_WR_PTR); 14821da177e4SLinus Torvalds /* Fill the FREEQ with all the free descriptors. */ 14831da177e4SLinus Torvalds freeq_st_adr = readw(iadev->reass_reg+FREEQ_ST_ADR); 14841da177e4SLinus Torvalds freeq_start = (u_short *)(iadev->reass_ram+freeq_st_adr); 14851da177e4SLinus Torvalds for(i=1; i<=iadev->num_rx_desc; i++) 14861da177e4SLinus Torvalds { 14871da177e4SLinus Torvalds *freeq_start = (u_short)i; 14881da177e4SLinus Torvalds freeq_start++; 14891da177e4SLinus Torvalds } 14901da177e4SLinus Torvalds IF_INIT(printk("freeq_start: 0x%0x\n", (u32)freeq_start);) 14911da177e4SLinus Torvalds /* Packet Complete Queue */ 14921da177e4SLinus Torvalds i = (PKT_COMP_Q * iadev->memSize) & 0xffff; 14931da177e4SLinus Torvalds writew(i, iadev->reass_reg+PCQ_ST_ADR); 14941da177e4SLinus Torvalds writew(i+iadev->num_vc*sizeof(u_short), iadev->reass_reg+PCQ_ED_ADR); 14951da177e4SLinus Torvalds writew(i, iadev->reass_reg+PCQ_RD_PTR); 14961da177e4SLinus Torvalds writew(i, iadev->reass_reg+PCQ_WR_PTR); 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds /* Exception Queue */ 14991da177e4SLinus Torvalds i = (EXCEPTION_Q * iadev->memSize) & 0xffff; 15001da177e4SLinus Torvalds writew(i, iadev->reass_reg+EXCP_Q_ST_ADR); 15011da177e4SLinus Torvalds writew(i + NUM_RX_EXCP * sizeof(RX_ERROR_Q), 15021da177e4SLinus Torvalds iadev->reass_reg+EXCP_Q_ED_ADR); 15031da177e4SLinus Torvalds writew(i, iadev->reass_reg+EXCP_Q_RD_PTR); 15041da177e4SLinus Torvalds writew(i, iadev->reass_reg+EXCP_Q_WR_PTR); 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds /* Load local copy of FREEQ and PCQ ptrs */ 15071da177e4SLinus Torvalds iadev->rfL.fdq_st = readw(iadev->reass_reg+FREEQ_ST_ADR) & 0xffff; 15081da177e4SLinus Torvalds iadev->rfL.fdq_ed = readw(iadev->reass_reg+FREEQ_ED_ADR) & 0xffff ; 15091da177e4SLinus Torvalds iadev->rfL.fdq_rd = readw(iadev->reass_reg+FREEQ_RD_PTR) & 0xffff; 15101da177e4SLinus Torvalds iadev->rfL.fdq_wr = readw(iadev->reass_reg+FREEQ_WR_PTR) & 0xffff; 15111da177e4SLinus Torvalds iadev->rfL.pcq_st = readw(iadev->reass_reg+PCQ_ST_ADR) & 0xffff; 15121da177e4SLinus Torvalds iadev->rfL.pcq_ed = readw(iadev->reass_reg+PCQ_ED_ADR) & 0xffff; 15131da177e4SLinus Torvalds iadev->rfL.pcq_rd = readw(iadev->reass_reg+PCQ_RD_PTR) & 0xffff; 15141da177e4SLinus Torvalds iadev->rfL.pcq_wr = readw(iadev->reass_reg+PCQ_WR_PTR) & 0xffff; 15151da177e4SLinus Torvalds 15161da177e4SLinus Torvalds IF_INIT(printk("INIT:pcq_st:0x%x pcq_ed:0x%x pcq_rd:0x%x pcq_wr:0x%x", 15171da177e4SLinus Torvalds iadev->rfL.pcq_st, iadev->rfL.pcq_ed, iadev->rfL.pcq_rd, 15181da177e4SLinus Torvalds iadev->rfL.pcq_wr);) 15191da177e4SLinus Torvalds /* just for check - no VP TBL */ 15201da177e4SLinus Torvalds /* VP Table */ 15211da177e4SLinus Torvalds /* writew(0x0b80, iadev->reass_reg+VP_LKUP_BASE); */ 15221da177e4SLinus Torvalds /* initialize VP Table for invalid VPIs 15231da177e4SLinus Torvalds - I guess we can write all 1s or 0x000f in the entire memory 15241da177e4SLinus Torvalds space or something similar. 15251da177e4SLinus Torvalds */ 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds /* This seems to work and looks right to me too !!! */ 15281da177e4SLinus Torvalds i = REASS_TABLE * iadev->memSize; 15291da177e4SLinus Torvalds writew((i >> 3), iadev->reass_reg+REASS_TABLE_BASE); 15301da177e4SLinus Torvalds /* initialize Reassembly table to I don't know what ???? */ 15311da177e4SLinus Torvalds reass_table = (u16 *)(iadev->reass_ram+i); 15321da177e4SLinus Torvalds j = REASS_TABLE_SZ * iadev->memSize; 15331da177e4SLinus Torvalds for(i=0; i < j; i++) 15341da177e4SLinus Torvalds *reass_table++ = NO_AAL5_PKT; 15351da177e4SLinus Torvalds i = 8*1024; 15361da177e4SLinus Torvalds vcsize_sel = 0; 15371da177e4SLinus Torvalds while (i != iadev->num_vc) { 15381da177e4SLinus Torvalds i /= 2; 15391da177e4SLinus Torvalds vcsize_sel++; 15401da177e4SLinus Torvalds } 15411da177e4SLinus Torvalds i = RX_VC_TABLE * iadev->memSize; 15421da177e4SLinus Torvalds writew(((i>>3) & 0xfff8) | vcsize_sel, iadev->reass_reg+VC_LKUP_BASE); 15431da177e4SLinus Torvalds vc_table = (u16 *)(iadev->reass_ram+RX_VC_TABLE*iadev->memSize); 15441da177e4SLinus Torvalds j = RX_VC_TABLE_SZ * iadev->memSize; 15451da177e4SLinus Torvalds for(i = 0; i < j; i++) 15461da177e4SLinus Torvalds { 15471da177e4SLinus Torvalds /* shift the reassembly pointer by 3 + lower 3 bits of 15481da177e4SLinus Torvalds vc_lkup_base register (=3 for 1K VCs) and the last byte 15491da177e4SLinus Torvalds is those low 3 bits. 15501da177e4SLinus Torvalds Shall program this later. 15511da177e4SLinus Torvalds */ 15521da177e4SLinus Torvalds *vc_table = (i << 6) | 15; /* for invalid VCI */ 15531da177e4SLinus Torvalds vc_table++; 15541da177e4SLinus Torvalds } 15551da177e4SLinus Torvalds /* ABR VC table */ 15561da177e4SLinus Torvalds i = ABR_VC_TABLE * iadev->memSize; 15571da177e4SLinus Torvalds writew(i >> 3, iadev->reass_reg+ABR_LKUP_BASE); 15581da177e4SLinus Torvalds 15591da177e4SLinus Torvalds i = ABR_VC_TABLE * iadev->memSize; 15601da177e4SLinus Torvalds abr_vc_table = (struct abr_vc_table *)(iadev->reass_ram+i); 15611da177e4SLinus Torvalds j = REASS_TABLE_SZ * iadev->memSize; 15621da177e4SLinus Torvalds memset ((char*)abr_vc_table, 0, j * sizeof(*abr_vc_table)); 15631da177e4SLinus Torvalds for(i = 0; i < j; i++) { 15641da177e4SLinus Torvalds abr_vc_table->rdf = 0x0003; 15651da177e4SLinus Torvalds abr_vc_table->air = 0x5eb1; 15661da177e4SLinus Torvalds abr_vc_table++; 15671da177e4SLinus Torvalds } 15681da177e4SLinus Torvalds 15691da177e4SLinus Torvalds /* Initialize other registers */ 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds /* VP Filter Register set for VC Reassembly only */ 15721da177e4SLinus Torvalds writew(0xff00, iadev->reass_reg+VP_FILTER); 15731da177e4SLinus Torvalds writew(0, iadev->reass_reg+XTRA_RM_OFFSET); 15741da177e4SLinus Torvalds writew(0x1, iadev->reass_reg+PROTOCOL_ID); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds /* Packet Timeout Count related Registers : 15771da177e4SLinus Torvalds Set packet timeout to occur in about 3 seconds 15781da177e4SLinus Torvalds Set Packet Aging Interval count register to overflow in about 4 us 15791da177e4SLinus Torvalds */ 15801da177e4SLinus Torvalds writew(0xF6F8, iadev->reass_reg+PKT_TM_CNT ); 158197928f70SAlan Cox 158297928f70SAlan Cox i = (j >> 6) & 0xFF; 158397928f70SAlan Cox j += 2 * (j - 1); 158497928f70SAlan Cox i |= ((j << 2) & 0xFF00); 15851da177e4SLinus Torvalds writew(i, iadev->reass_reg+TMOUT_RANGE); 158697928f70SAlan Cox 15871da177e4SLinus Torvalds /* initiate the desc_tble */ 15881da177e4SLinus Torvalds for(i=0; i<iadev->num_tx_desc;i++) 15891da177e4SLinus Torvalds iadev->desc_tbl[i].timestamp = 0; 15901da177e4SLinus Torvalds 15911da177e4SLinus Torvalds /* to clear the interrupt status register - read it */ 15921da177e4SLinus Torvalds readw(iadev->reass_reg+REASS_INTR_STATUS_REG); 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds /* Mask Register - clear it */ 15951da177e4SLinus Torvalds writew(~(RX_FREEQ_EMPT|RX_PKT_RCVD), iadev->reass_reg+REASS_MASK_REG); 15961da177e4SLinus Torvalds 15971da177e4SLinus Torvalds skb_queue_head_init(&iadev->rx_dma_q); 15981da177e4SLinus Torvalds iadev->rx_free_desc_qhead = NULL; 1599f7141761SMariusz Kozlowski 1600f7141761SMariusz Kozlowski iadev->rx_open = kzalloc(4 * iadev->num_vc, GFP_KERNEL); 1601f7141761SMariusz Kozlowski if (!iadev->rx_open) { 16021da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "itf %d couldn't get free page\n", 16031da177e4SLinus Torvalds dev->number); 16041da177e4SLinus Torvalds goto err_free_dle; 16051da177e4SLinus Torvalds } 1606f7141761SMariusz Kozlowski 16071da177e4SLinus Torvalds iadev->rxing = 1; 16081da177e4SLinus Torvalds iadev->rx_pkt_cnt = 0; 16091da177e4SLinus Torvalds /* Mode Register */ 16101da177e4SLinus Torvalds writew(R_ONLINE, iadev->reass_reg+MODE_REG); 16111da177e4SLinus Torvalds return 0; 16121da177e4SLinus Torvalds 16131da177e4SLinus Torvalds err_free_dle: 16141da177e4SLinus Torvalds pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, 16151da177e4SLinus Torvalds iadev->rx_dle_dma); 16161da177e4SLinus Torvalds err_out: 16171da177e4SLinus Torvalds return -ENOMEM; 16181da177e4SLinus Torvalds } 16191da177e4SLinus Torvalds 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds /* 16221da177e4SLinus Torvalds The memory map suggested in appendix A and the coding for it. 16231da177e4SLinus Torvalds Keeping it around just in case we change our mind later. 16241da177e4SLinus Torvalds 16251da177e4SLinus Torvalds Buffer descr 0x0000 (128 - 4K) 16261da177e4SLinus Torvalds UBR sched 0x1000 (1K - 4K) 16271da177e4SLinus Torvalds UBR Wait q 0x2000 (1K - 4K) 16281da177e4SLinus Torvalds Commn queues 0x3000 Packet Ready, Trasmit comp(0x3100) 16291da177e4SLinus Torvalds (128 - 256) each 16301da177e4SLinus Torvalds extended VC 0x4000 (1K - 8K) 16311da177e4SLinus Torvalds ABR sched 0x6000 and ABR wait queue (1K - 2K) each 16321da177e4SLinus Torvalds CBR sched 0x7000 (as needed) 16331da177e4SLinus Torvalds VC table 0x8000 (1K - 32K) 16341da177e4SLinus Torvalds */ 16351da177e4SLinus Torvalds 16361da177e4SLinus Torvalds static void tx_intr(struct atm_dev *dev) 16371da177e4SLinus Torvalds { 16381da177e4SLinus Torvalds IADEV *iadev; 16391da177e4SLinus Torvalds unsigned short status; 16401da177e4SLinus Torvalds unsigned long flags; 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds status = readl(iadev->seg_reg+SEG_INTR_STATUS_REG); 16451da177e4SLinus Torvalds if (status & TRANSMIT_DONE){ 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds IF_EVENT(printk("Tansmit Done Intr logic run\n");) 16481da177e4SLinus Torvalds spin_lock_irqsave(&iadev->tx_lock, flags); 16491da177e4SLinus Torvalds ia_tx_poll(iadev); 16501da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 16511da177e4SLinus Torvalds writew(TRANSMIT_DONE, iadev->seg_reg+SEG_INTR_STATUS_REG); 16521da177e4SLinus Torvalds if (iadev->close_pending) 16531da177e4SLinus Torvalds wake_up(&iadev->close_wait); 16541da177e4SLinus Torvalds } 16551da177e4SLinus Torvalds if (status & TCQ_NOT_EMPTY) 16561da177e4SLinus Torvalds { 16571da177e4SLinus Torvalds IF_EVENT(printk("TCQ_NOT_EMPTY int received\n");) 16581da177e4SLinus Torvalds } 16591da177e4SLinus Torvalds } 16601da177e4SLinus Torvalds 16611da177e4SLinus Torvalds static void tx_dle_intr(struct atm_dev *dev) 16621da177e4SLinus Torvalds { 16631da177e4SLinus Torvalds IADEV *iadev; 16641da177e4SLinus Torvalds struct dle *dle, *cur_dle; 16651da177e4SLinus Torvalds struct sk_buff *skb; 16661da177e4SLinus Torvalds struct atm_vcc *vcc; 16671da177e4SLinus Torvalds struct ia_vcc *iavcc; 16681da177e4SLinus Torvalds u_int dle_lp; 16691da177e4SLinus Torvalds unsigned long flags; 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 16721da177e4SLinus Torvalds spin_lock_irqsave(&iadev->tx_lock, flags); 16731da177e4SLinus Torvalds dle = iadev->tx_dle_q.read; 16741da177e4SLinus Torvalds dle_lp = readl(iadev->dma+IPHASE5575_TX_LIST_ADDR) & 16751da177e4SLinus Torvalds (sizeof(struct dle)*DLE_ENTRIES - 1); 16761da177e4SLinus Torvalds cur_dle = (struct dle*)(iadev->tx_dle_q.start + (dle_lp >> 4)); 16771da177e4SLinus Torvalds while (dle != cur_dle) 16781da177e4SLinus Torvalds { 16791da177e4SLinus Torvalds /* free the DMAed skb */ 16801da177e4SLinus Torvalds skb = skb_dequeue(&iadev->tx_dma_q); 16811da177e4SLinus Torvalds if (!skb) break; 16821da177e4SLinus Torvalds 16831da177e4SLinus Torvalds /* Revenge of the 2 dle (skb + trailer) used in ia_pkt_tx() */ 16841da177e4SLinus Torvalds if (!((dle - iadev->tx_dle_q.start)%(2*sizeof(struct dle)))) { 16851da177e4SLinus Torvalds pci_unmap_single(iadev->pci, dle->sys_pkt_addr, skb->len, 16861da177e4SLinus Torvalds PCI_DMA_TODEVICE); 16871da177e4SLinus Torvalds } 16881da177e4SLinus Torvalds vcc = ATM_SKB(skb)->vcc; 16891da177e4SLinus Torvalds if (!vcc) { 16901da177e4SLinus Torvalds printk("tx_dle_intr: vcc is null\n"); 16911da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 16921da177e4SLinus Torvalds dev_kfree_skb_any(skb); 16931da177e4SLinus Torvalds 16941da177e4SLinus Torvalds return; 16951da177e4SLinus Torvalds } 16961da177e4SLinus Torvalds iavcc = INPH_IA_VCC(vcc); 16971da177e4SLinus Torvalds if (!iavcc) { 16981da177e4SLinus Torvalds printk("tx_dle_intr: iavcc is null\n"); 16991da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 17001da177e4SLinus Torvalds dev_kfree_skb_any(skb); 17011da177e4SLinus Torvalds return; 17021da177e4SLinus Torvalds } 17031da177e4SLinus Torvalds if (vcc->qos.txtp.pcr >= iadev->rate_limit) { 17041da177e4SLinus Torvalds if ((vcc->pop) && (skb->len != 0)) 17051da177e4SLinus Torvalds { 17061da177e4SLinus Torvalds vcc->pop(vcc, skb); 17071da177e4SLinus Torvalds } 17081da177e4SLinus Torvalds else { 17091da177e4SLinus Torvalds dev_kfree_skb_any(skb); 17101da177e4SLinus Torvalds } 17111da177e4SLinus Torvalds } 17121da177e4SLinus Torvalds else { /* Hold the rate-limited skb for flow control */ 17131da177e4SLinus Torvalds IA_SKB_STATE(skb) |= IA_DLED; 17141da177e4SLinus Torvalds skb_queue_tail(&iavcc->txing_skb, skb); 17151da177e4SLinus Torvalds } 17161da177e4SLinus Torvalds IF_EVENT(printk("tx_dle_intr: enque skb = 0x%x \n", (u32)skb);) 17171da177e4SLinus Torvalds if (++dle == iadev->tx_dle_q.end) 17181da177e4SLinus Torvalds dle = iadev->tx_dle_q.start; 17191da177e4SLinus Torvalds } 17201da177e4SLinus Torvalds iadev->tx_dle_q.read = dle; 17211da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 17221da177e4SLinus Torvalds } 17231da177e4SLinus Torvalds 17241da177e4SLinus Torvalds static int open_tx(struct atm_vcc *vcc) 17251da177e4SLinus Torvalds { 17261da177e4SLinus Torvalds struct ia_vcc *ia_vcc; 17271da177e4SLinus Torvalds IADEV *iadev; 17281da177e4SLinus Torvalds struct main_vc *vc; 17291da177e4SLinus Torvalds struct ext_vc *evc; 17301da177e4SLinus Torvalds int ret; 17311da177e4SLinus Torvalds IF_EVENT(printk("iadev: open_tx entered vcc->vci = %d\n", vcc->vci);) 17321da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_NONE) return 0; 17331da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 17341da177e4SLinus Torvalds 17351da177e4SLinus Torvalds if (iadev->phy_type & FE_25MBIT_PHY) { 17361da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_ABR) { 17371da177e4SLinus Torvalds printk("IA: ABR not support\n"); 17381da177e4SLinus Torvalds return -EINVAL; 17391da177e4SLinus Torvalds } 17401da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_CBR) { 17411da177e4SLinus Torvalds printk("IA: CBR not support\n"); 17421da177e4SLinus Torvalds return -EINVAL; 17431da177e4SLinus Torvalds } 17441da177e4SLinus Torvalds } 17451da177e4SLinus Torvalds ia_vcc = INPH_IA_VCC(vcc); 17461da177e4SLinus Torvalds memset((caddr_t)ia_vcc, 0, sizeof(*ia_vcc)); 17471da177e4SLinus Torvalds if (vcc->qos.txtp.max_sdu > 17481da177e4SLinus Torvalds (iadev->tx_buf_sz - sizeof(struct cpcs_trailer))){ 17491da177e4SLinus Torvalds printk("IA: SDU size over (%d) the configured SDU size %d\n", 17501da177e4SLinus Torvalds vcc->qos.txtp.max_sdu,iadev->tx_buf_sz); 17511da177e4SLinus Torvalds vcc->dev_data = NULL; 17521da177e4SLinus Torvalds kfree(ia_vcc); 17531da177e4SLinus Torvalds return -EINVAL; 17541da177e4SLinus Torvalds } 17551da177e4SLinus Torvalds ia_vcc->vc_desc_cnt = 0; 17561da177e4SLinus Torvalds ia_vcc->txing = 1; 17571da177e4SLinus Torvalds 17581da177e4SLinus Torvalds /* find pcr */ 17591da177e4SLinus Torvalds if (vcc->qos.txtp.max_pcr == ATM_MAX_PCR) 17601da177e4SLinus Torvalds vcc->qos.txtp.pcr = iadev->LineRate; 17611da177e4SLinus Torvalds else if ((vcc->qos.txtp.max_pcr == 0)&&( vcc->qos.txtp.pcr <= 0)) 17621da177e4SLinus Torvalds vcc->qos.txtp.pcr = iadev->LineRate; 17631da177e4SLinus Torvalds else if ((vcc->qos.txtp.max_pcr > vcc->qos.txtp.pcr) && (vcc->qos.txtp.max_pcr> 0)) 17641da177e4SLinus Torvalds vcc->qos.txtp.pcr = vcc->qos.txtp.max_pcr; 17651da177e4SLinus Torvalds if (vcc->qos.txtp.pcr > iadev->LineRate) 17661da177e4SLinus Torvalds vcc->qos.txtp.pcr = iadev->LineRate; 17671da177e4SLinus Torvalds ia_vcc->pcr = vcc->qos.txtp.pcr; 17681da177e4SLinus Torvalds 17691da177e4SLinus Torvalds if (ia_vcc->pcr > (iadev->LineRate / 6) ) ia_vcc->ltimeout = HZ / 10; 17701da177e4SLinus Torvalds else if (ia_vcc->pcr > (iadev->LineRate / 130)) ia_vcc->ltimeout = HZ; 17711da177e4SLinus Torvalds else if (ia_vcc->pcr <= 170) ia_vcc->ltimeout = 16 * HZ; 17721da177e4SLinus Torvalds else ia_vcc->ltimeout = 2700 * HZ / ia_vcc->pcr; 17731da177e4SLinus Torvalds if (ia_vcc->pcr < iadev->rate_limit) 17741da177e4SLinus Torvalds skb_queue_head_init (&ia_vcc->txing_skb); 17751da177e4SLinus Torvalds if (ia_vcc->pcr < iadev->rate_limit) { 17761da177e4SLinus Torvalds struct sock *sk = sk_atm(vcc); 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds if (vcc->qos.txtp.max_sdu != 0) { 17791da177e4SLinus Torvalds if (ia_vcc->pcr > 60000) 17801da177e4SLinus Torvalds sk->sk_sndbuf = vcc->qos.txtp.max_sdu * 5; 17811da177e4SLinus Torvalds else if (ia_vcc->pcr > 2000) 17821da177e4SLinus Torvalds sk->sk_sndbuf = vcc->qos.txtp.max_sdu * 4; 17831da177e4SLinus Torvalds else 17841da177e4SLinus Torvalds sk->sk_sndbuf = vcc->qos.txtp.max_sdu * 3; 17851da177e4SLinus Torvalds } 17861da177e4SLinus Torvalds else 17871da177e4SLinus Torvalds sk->sk_sndbuf = 24576; 17881da177e4SLinus Torvalds } 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds vc = (struct main_vc *)iadev->MAIN_VC_TABLE_ADDR; 17911da177e4SLinus Torvalds evc = (struct ext_vc *)iadev->EXT_VC_TABLE_ADDR; 17921da177e4SLinus Torvalds vc += vcc->vci; 17931da177e4SLinus Torvalds evc += vcc->vci; 17941da177e4SLinus Torvalds memset((caddr_t)vc, 0, sizeof(*vc)); 17951da177e4SLinus Torvalds memset((caddr_t)evc, 0, sizeof(*evc)); 17961da177e4SLinus Torvalds 17971da177e4SLinus Torvalds /* store the most significant 4 bits of vci as the last 4 bits 17981da177e4SLinus Torvalds of first part of atm header. 17991da177e4SLinus Torvalds store the last 12 bits of vci as first 12 bits of the second 18001da177e4SLinus Torvalds part of the atm header. 18011da177e4SLinus Torvalds */ 18021da177e4SLinus Torvalds evc->atm_hdr1 = (vcc->vci >> 12) & 0x000f; 18031da177e4SLinus Torvalds evc->atm_hdr2 = (vcc->vci & 0x0fff) << 4; 18041da177e4SLinus Torvalds 18051da177e4SLinus Torvalds /* check the following for different traffic classes */ 18061da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_UBR) 18071da177e4SLinus Torvalds { 18081da177e4SLinus Torvalds vc->type = UBR; 18091da177e4SLinus Torvalds vc->status = CRC_APPEND; 18101da177e4SLinus Torvalds vc->acr = cellrate_to_float(iadev->LineRate); 18111da177e4SLinus Torvalds if (vcc->qos.txtp.pcr > 0) 18121da177e4SLinus Torvalds vc->acr = cellrate_to_float(vcc->qos.txtp.pcr); 18131da177e4SLinus Torvalds IF_UBR(printk("UBR: txtp.pcr = 0x%x f_rate = 0x%x\n", 18141da177e4SLinus Torvalds vcc->qos.txtp.max_pcr,vc->acr);) 18151da177e4SLinus Torvalds } 18161da177e4SLinus Torvalds else if (vcc->qos.txtp.traffic_class == ATM_ABR) 18171da177e4SLinus Torvalds { srv_cls_param_t srv_p; 18181da177e4SLinus Torvalds IF_ABR(printk("Tx ABR VCC\n");) 18191da177e4SLinus Torvalds init_abr_vc(iadev, &srv_p); 18201da177e4SLinus Torvalds if (vcc->qos.txtp.pcr > 0) 18211da177e4SLinus Torvalds srv_p.pcr = vcc->qos.txtp.pcr; 18221da177e4SLinus Torvalds if (vcc->qos.txtp.min_pcr > 0) { 18231da177e4SLinus Torvalds int tmpsum = iadev->sum_mcr+iadev->sum_cbr+vcc->qos.txtp.min_pcr; 18241da177e4SLinus Torvalds if (tmpsum > iadev->LineRate) 18251da177e4SLinus Torvalds return -EBUSY; 18261da177e4SLinus Torvalds srv_p.mcr = vcc->qos.txtp.min_pcr; 18271da177e4SLinus Torvalds iadev->sum_mcr += vcc->qos.txtp.min_pcr; 18281da177e4SLinus Torvalds } 18291da177e4SLinus Torvalds else srv_p.mcr = 0; 18301da177e4SLinus Torvalds if (vcc->qos.txtp.icr) 18311da177e4SLinus Torvalds srv_p.icr = vcc->qos.txtp.icr; 18321da177e4SLinus Torvalds if (vcc->qos.txtp.tbe) 18331da177e4SLinus Torvalds srv_p.tbe = vcc->qos.txtp.tbe; 18341da177e4SLinus Torvalds if (vcc->qos.txtp.frtt) 18351da177e4SLinus Torvalds srv_p.frtt = vcc->qos.txtp.frtt; 18361da177e4SLinus Torvalds if (vcc->qos.txtp.rif) 18371da177e4SLinus Torvalds srv_p.rif = vcc->qos.txtp.rif; 18381da177e4SLinus Torvalds if (vcc->qos.txtp.rdf) 18391da177e4SLinus Torvalds srv_p.rdf = vcc->qos.txtp.rdf; 18401da177e4SLinus Torvalds if (vcc->qos.txtp.nrm_pres) 18411da177e4SLinus Torvalds srv_p.nrm = vcc->qos.txtp.nrm; 18421da177e4SLinus Torvalds if (vcc->qos.txtp.trm_pres) 18431da177e4SLinus Torvalds srv_p.trm = vcc->qos.txtp.trm; 18441da177e4SLinus Torvalds if (vcc->qos.txtp.adtf_pres) 18451da177e4SLinus Torvalds srv_p.adtf = vcc->qos.txtp.adtf; 18461da177e4SLinus Torvalds if (vcc->qos.txtp.cdf_pres) 18471da177e4SLinus Torvalds srv_p.cdf = vcc->qos.txtp.cdf; 18481da177e4SLinus Torvalds if (srv_p.icr > srv_p.pcr) 18491da177e4SLinus Torvalds srv_p.icr = srv_p.pcr; 18501da177e4SLinus Torvalds IF_ABR(printk("ABR:vcc->qos.txtp.max_pcr = %d mcr = %d\n", 18511da177e4SLinus Torvalds srv_p.pcr, srv_p.mcr);) 18521da177e4SLinus Torvalds ia_open_abr_vc(iadev, &srv_p, vcc, 1); 18531da177e4SLinus Torvalds } else if (vcc->qos.txtp.traffic_class == ATM_CBR) { 18541da177e4SLinus Torvalds if (iadev->phy_type & FE_25MBIT_PHY) { 18551da177e4SLinus Torvalds printk("IA: CBR not support\n"); 18561da177e4SLinus Torvalds return -EINVAL; 18571da177e4SLinus Torvalds } 18581da177e4SLinus Torvalds if (vcc->qos.txtp.max_pcr > iadev->LineRate) { 18591da177e4SLinus Torvalds IF_CBR(printk("PCR is not availble\n");) 18601da177e4SLinus Torvalds return -1; 18611da177e4SLinus Torvalds } 18621da177e4SLinus Torvalds vc->type = CBR; 18631da177e4SLinus Torvalds vc->status = CRC_APPEND; 18641da177e4SLinus Torvalds if ((ret = ia_cbr_setup (iadev, vcc)) < 0) { 18651da177e4SLinus Torvalds return ret; 18661da177e4SLinus Torvalds } 18671da177e4SLinus Torvalds } 18681da177e4SLinus Torvalds else 18691da177e4SLinus Torvalds printk("iadev: Non UBR, ABR and CBR traffic not supportedn"); 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds iadev->testTable[vcc->vci]->vc_status |= VC_ACTIVE; 18721da177e4SLinus Torvalds IF_EVENT(printk("ia open_tx returning \n");) 18731da177e4SLinus Torvalds return 0; 18741da177e4SLinus Torvalds } 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds static int tx_init(struct atm_dev *dev) 18781da177e4SLinus Torvalds { 18791da177e4SLinus Torvalds IADEV *iadev; 18801da177e4SLinus Torvalds struct tx_buf_desc *buf_desc_ptr; 18811da177e4SLinus Torvalds unsigned int tx_pkt_start; 18821da177e4SLinus Torvalds void *dle_addr; 18831da177e4SLinus Torvalds int i; 18841da177e4SLinus Torvalds u_short tcq_st_adr; 18851da177e4SLinus Torvalds u_short *tcq_start; 18861da177e4SLinus Torvalds u_short prq_st_adr; 18871da177e4SLinus Torvalds u_short *prq_start; 18881da177e4SLinus Torvalds struct main_vc *vc; 18891da177e4SLinus Torvalds struct ext_vc *evc; 18901da177e4SLinus Torvalds u_short tmp16; 18911da177e4SLinus Torvalds u32 vcsize_sel; 18921da177e4SLinus Torvalds 18931da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 18941da177e4SLinus Torvalds spin_lock_init(&iadev->tx_lock); 18951da177e4SLinus Torvalds 18961da177e4SLinus Torvalds IF_INIT(printk("Tx MASK REG: 0x%0x\n", 18971da177e4SLinus Torvalds readw(iadev->seg_reg+SEG_MASK_REG));) 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds /* Allocate 4k (boundary aligned) bytes */ 19001da177e4SLinus Torvalds dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE, 19011da177e4SLinus Torvalds &iadev->tx_dle_dma); 19021da177e4SLinus Torvalds if (!dle_addr) { 19031da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); 19041da177e4SLinus Torvalds goto err_out; 19051da177e4SLinus Torvalds } 19061da177e4SLinus Torvalds iadev->tx_dle_q.start = (struct dle*)dle_addr; 19071da177e4SLinus Torvalds iadev->tx_dle_q.read = iadev->tx_dle_q.start; 19081da177e4SLinus Torvalds iadev->tx_dle_q.write = iadev->tx_dle_q.start; 190997928f70SAlan Cox iadev->tx_dle_q.end = (struct dle*)((unsigned long)dle_addr+sizeof(struct dle)*DLE_ENTRIES); 19101da177e4SLinus Torvalds 19111da177e4SLinus Torvalds /* write the upper 20 bits of the start address to tx list address register */ 19121da177e4SLinus Torvalds writel(iadev->tx_dle_dma & 0xfffff000, 19131da177e4SLinus Torvalds iadev->dma + IPHASE5575_TX_LIST_ADDR); 19141da177e4SLinus Torvalds writew(0xffff, iadev->seg_reg+SEG_MASK_REG); 19151da177e4SLinus Torvalds writew(0, iadev->seg_reg+MODE_REG_0); 19161da177e4SLinus Torvalds writew(RESET_SEG, iadev->seg_reg+SEG_COMMAND_REG); 19171da177e4SLinus Torvalds iadev->MAIN_VC_TABLE_ADDR = iadev->seg_ram+MAIN_VC_TABLE*iadev->memSize; 19181da177e4SLinus Torvalds iadev->EXT_VC_TABLE_ADDR = iadev->seg_ram+EXT_VC_TABLE*iadev->memSize; 19191da177e4SLinus Torvalds iadev->ABR_SCHED_TABLE_ADDR=iadev->seg_ram+ABR_SCHED_TABLE*iadev->memSize; 19201da177e4SLinus Torvalds 19211da177e4SLinus Torvalds /* 19221da177e4SLinus Torvalds Transmit side control memory map 19231da177e4SLinus Torvalds -------------------------------- 19241da177e4SLinus Torvalds Buffer descr 0x0000 (128 - 4K) 19251da177e4SLinus Torvalds Commn queues 0x1000 Transmit comp, Packet ready(0x1400) 19261da177e4SLinus Torvalds (512 - 1K) each 19271da177e4SLinus Torvalds TCQ - 4K, PRQ - 5K 19281da177e4SLinus Torvalds CBR Table 0x1800 (as needed) - 6K 19291da177e4SLinus Torvalds UBR Table 0x3000 (1K - 4K) - 12K 19301da177e4SLinus Torvalds UBR Wait queue 0x4000 (1K - 4K) - 16K 19311da177e4SLinus Torvalds ABR sched 0x5000 and ABR wait queue (1K - 2K) each 19321da177e4SLinus Torvalds ABR Tbl - 20K, ABR Wq - 22K 19331da177e4SLinus Torvalds extended VC 0x6000 (1K - 8K) - 24K 19341da177e4SLinus Torvalds VC Table 0x8000 (1K - 32K) - 32K 19351da177e4SLinus Torvalds 19361da177e4SLinus Torvalds Between 0x2000 (8K) and 0x3000 (12K) there is 4K space left for VBR Tbl 19371da177e4SLinus Torvalds and Wait q, which can be allotted later. 19381da177e4SLinus Torvalds */ 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds /* Buffer Descriptor Table Base address */ 19411da177e4SLinus Torvalds writew(TX_DESC_BASE, iadev->seg_reg+SEG_DESC_BASE); 19421da177e4SLinus Torvalds 19431da177e4SLinus Torvalds /* initialize each entry in the buffer descriptor table */ 19441da177e4SLinus Torvalds buf_desc_ptr =(struct tx_buf_desc *)(iadev->seg_ram+TX_DESC_BASE); 19451da177e4SLinus Torvalds memset((caddr_t)buf_desc_ptr, 0, sizeof(*buf_desc_ptr)); 19461da177e4SLinus Torvalds buf_desc_ptr++; 19471da177e4SLinus Torvalds tx_pkt_start = TX_PACKET_RAM; 19481da177e4SLinus Torvalds for(i=1; i<=iadev->num_tx_desc; i++) 19491da177e4SLinus Torvalds { 19501da177e4SLinus Torvalds memset((caddr_t)buf_desc_ptr, 0, sizeof(*buf_desc_ptr)); 19511da177e4SLinus Torvalds buf_desc_ptr->desc_mode = AAL5; 19521da177e4SLinus Torvalds buf_desc_ptr->buf_start_hi = tx_pkt_start >> 16; 19531da177e4SLinus Torvalds buf_desc_ptr->buf_start_lo = tx_pkt_start & 0x0000ffff; 19541da177e4SLinus Torvalds buf_desc_ptr++; 19551da177e4SLinus Torvalds tx_pkt_start += iadev->tx_buf_sz; 19561da177e4SLinus Torvalds } 19571da177e4SLinus Torvalds iadev->tx_buf = kmalloc(iadev->num_tx_desc*sizeof(struct cpcs_trailer_desc), GFP_KERNEL); 19581da177e4SLinus Torvalds if (!iadev->tx_buf) { 19591da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL " couldn't get mem\n"); 19601da177e4SLinus Torvalds goto err_free_dle; 19611da177e4SLinus Torvalds } 19621da177e4SLinus Torvalds for (i= 0; i< iadev->num_tx_desc; i++) 19631da177e4SLinus Torvalds { 19641da177e4SLinus Torvalds struct cpcs_trailer *cpcs; 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds cpcs = kmalloc(sizeof(*cpcs), GFP_KERNEL|GFP_DMA); 19671da177e4SLinus Torvalds if(!cpcs) { 19681da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL " couldn't get freepage\n"); 19691da177e4SLinus Torvalds goto err_free_tx_bufs; 19701da177e4SLinus Torvalds } 19711da177e4SLinus Torvalds iadev->tx_buf[i].cpcs = cpcs; 19721da177e4SLinus Torvalds iadev->tx_buf[i].dma_addr = pci_map_single(iadev->pci, 19731da177e4SLinus Torvalds cpcs, sizeof(*cpcs), PCI_DMA_TODEVICE); 19741da177e4SLinus Torvalds } 19751da177e4SLinus Torvalds iadev->desc_tbl = kmalloc(iadev->num_tx_desc * 19761da177e4SLinus Torvalds sizeof(struct desc_tbl_t), GFP_KERNEL); 19771da177e4SLinus Torvalds if (!iadev->desc_tbl) { 19781da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL " couldn't get mem\n"); 19791da177e4SLinus Torvalds goto err_free_all_tx_bufs; 19801da177e4SLinus Torvalds } 19811da177e4SLinus Torvalds 19821da177e4SLinus Torvalds /* Communication Queues base address */ 19831da177e4SLinus Torvalds i = TX_COMP_Q * iadev->memSize; 19841da177e4SLinus Torvalds writew(i >> 16, iadev->seg_reg+SEG_QUEUE_BASE); 19851da177e4SLinus Torvalds 19861da177e4SLinus Torvalds /* Transmit Complete Queue */ 19871da177e4SLinus Torvalds writew(i, iadev->seg_reg+TCQ_ST_ADR); 19881da177e4SLinus Torvalds writew(i, iadev->seg_reg+TCQ_RD_PTR); 19891da177e4SLinus Torvalds writew(i+iadev->num_tx_desc*sizeof(u_short),iadev->seg_reg+TCQ_WR_PTR); 19901da177e4SLinus Torvalds iadev->host_tcq_wr = i + iadev->num_tx_desc*sizeof(u_short); 19911da177e4SLinus Torvalds writew(i+2 * iadev->num_tx_desc * sizeof(u_short), 19921da177e4SLinus Torvalds iadev->seg_reg+TCQ_ED_ADR); 19931da177e4SLinus Torvalds /* Fill the TCQ with all the free descriptors. */ 19941da177e4SLinus Torvalds tcq_st_adr = readw(iadev->seg_reg+TCQ_ST_ADR); 19951da177e4SLinus Torvalds tcq_start = (u_short *)(iadev->seg_ram+tcq_st_adr); 19961da177e4SLinus Torvalds for(i=1; i<=iadev->num_tx_desc; i++) 19971da177e4SLinus Torvalds { 19981da177e4SLinus Torvalds *tcq_start = (u_short)i; 19991da177e4SLinus Torvalds tcq_start++; 20001da177e4SLinus Torvalds } 20011da177e4SLinus Torvalds 20021da177e4SLinus Torvalds /* Packet Ready Queue */ 20031da177e4SLinus Torvalds i = PKT_RDY_Q * iadev->memSize; 20041da177e4SLinus Torvalds writew(i, iadev->seg_reg+PRQ_ST_ADR); 20051da177e4SLinus Torvalds writew(i+2 * iadev->num_tx_desc * sizeof(u_short), 20061da177e4SLinus Torvalds iadev->seg_reg+PRQ_ED_ADR); 20071da177e4SLinus Torvalds writew(i, iadev->seg_reg+PRQ_RD_PTR); 20081da177e4SLinus Torvalds writew(i, iadev->seg_reg+PRQ_WR_PTR); 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds /* Load local copy of PRQ and TCQ ptrs */ 20111da177e4SLinus Torvalds iadev->ffL.prq_st = readw(iadev->seg_reg+PRQ_ST_ADR) & 0xffff; 20121da177e4SLinus Torvalds iadev->ffL.prq_ed = readw(iadev->seg_reg+PRQ_ED_ADR) & 0xffff; 20131da177e4SLinus Torvalds iadev->ffL.prq_wr = readw(iadev->seg_reg+PRQ_WR_PTR) & 0xffff; 20141da177e4SLinus Torvalds 20151da177e4SLinus Torvalds iadev->ffL.tcq_st = readw(iadev->seg_reg+TCQ_ST_ADR) & 0xffff; 20161da177e4SLinus Torvalds iadev->ffL.tcq_ed = readw(iadev->seg_reg+TCQ_ED_ADR) & 0xffff; 20171da177e4SLinus Torvalds iadev->ffL.tcq_rd = readw(iadev->seg_reg+TCQ_RD_PTR) & 0xffff; 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds /* Just for safety initializing the queue to have desc 1 always */ 20201da177e4SLinus Torvalds /* Fill the PRQ with all the free descriptors. */ 20211da177e4SLinus Torvalds prq_st_adr = readw(iadev->seg_reg+PRQ_ST_ADR); 20221da177e4SLinus Torvalds prq_start = (u_short *)(iadev->seg_ram+prq_st_adr); 20231da177e4SLinus Torvalds for(i=1; i<=iadev->num_tx_desc; i++) 20241da177e4SLinus Torvalds { 20251da177e4SLinus Torvalds *prq_start = (u_short)0; /* desc 1 in all entries */ 20261da177e4SLinus Torvalds prq_start++; 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds /* CBR Table */ 20291da177e4SLinus Torvalds IF_INIT(printk("Start CBR Init\n");) 20301da177e4SLinus Torvalds #if 1 /* for 1K VC board, CBR_PTR_BASE is 0 */ 20311da177e4SLinus Torvalds writew(0,iadev->seg_reg+CBR_PTR_BASE); 20321da177e4SLinus Torvalds #else /* Charlie's logic is wrong ? */ 20331da177e4SLinus Torvalds tmp16 = (iadev->seg_ram+CBR_SCHED_TABLE*iadev->memSize)>>17; 20341da177e4SLinus Torvalds IF_INIT(printk("cbr_ptr_base = 0x%x ", tmp16);) 20351da177e4SLinus Torvalds writew(tmp16,iadev->seg_reg+CBR_PTR_BASE); 20361da177e4SLinus Torvalds #endif 20371da177e4SLinus Torvalds 20381da177e4SLinus Torvalds IF_INIT(printk("value in register = 0x%x\n", 20391da177e4SLinus Torvalds readw(iadev->seg_reg+CBR_PTR_BASE));) 20401da177e4SLinus Torvalds tmp16 = (CBR_SCHED_TABLE*iadev->memSize) >> 1; 20411da177e4SLinus Torvalds writew(tmp16, iadev->seg_reg+CBR_TAB_BEG); 20421da177e4SLinus Torvalds IF_INIT(printk("cbr_tab_beg = 0x%x in reg = 0x%x \n", tmp16, 20431da177e4SLinus Torvalds readw(iadev->seg_reg+CBR_TAB_BEG));) 20441da177e4SLinus Torvalds writew(tmp16, iadev->seg_reg+CBR_TAB_END+1); // CBR_PTR; 20451da177e4SLinus Torvalds tmp16 = (CBR_SCHED_TABLE*iadev->memSize + iadev->num_vc*6 - 2) >> 1; 20461da177e4SLinus Torvalds writew(tmp16, iadev->seg_reg+CBR_TAB_END); 20471da177e4SLinus Torvalds IF_INIT(printk("iadev->seg_reg = 0x%x CBR_PTR_BASE = 0x%x\n", 20481da177e4SLinus Torvalds (u32)iadev->seg_reg, readw(iadev->seg_reg+CBR_PTR_BASE));) 20491da177e4SLinus Torvalds IF_INIT(printk("CBR_TAB_BEG = 0x%x, CBR_TAB_END = 0x%x, CBR_PTR = 0x%x\n", 20501da177e4SLinus Torvalds readw(iadev->seg_reg+CBR_TAB_BEG), readw(iadev->seg_reg+CBR_TAB_END), 20511da177e4SLinus Torvalds readw(iadev->seg_reg+CBR_TAB_END+1));) 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds /* Initialize the CBR Schedualing Table */ 20541da177e4SLinus Torvalds memset_io(iadev->seg_ram+CBR_SCHED_TABLE*iadev->memSize, 20551da177e4SLinus Torvalds 0, iadev->num_vc*6); 20561da177e4SLinus Torvalds iadev->CbrRemEntries = iadev->CbrTotEntries = iadev->num_vc*3; 20571da177e4SLinus Torvalds iadev->CbrEntryPt = 0; 20581da177e4SLinus Torvalds iadev->Granularity = MAX_ATM_155 / iadev->CbrTotEntries; 20591da177e4SLinus Torvalds iadev->NumEnabledCBR = 0; 20601da177e4SLinus Torvalds 20611da177e4SLinus Torvalds /* UBR scheduling Table and wait queue */ 20621da177e4SLinus Torvalds /* initialize all bytes of UBR scheduler table and wait queue to 0 20631da177e4SLinus Torvalds - SCHEDSZ is 1K (# of entries). 20641da177e4SLinus Torvalds - UBR Table size is 4K 20651da177e4SLinus Torvalds - UBR wait queue is 4K 20661da177e4SLinus Torvalds since the table and wait queues are contiguous, all the bytes 20671da177e4SLinus Torvalds can be initialized by one memeset. 20681da177e4SLinus Torvalds */ 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds vcsize_sel = 0; 20711da177e4SLinus Torvalds i = 8*1024; 20721da177e4SLinus Torvalds while (i != iadev->num_vc) { 20731da177e4SLinus Torvalds i /= 2; 20741da177e4SLinus Torvalds vcsize_sel++; 20751da177e4SLinus Torvalds } 20761da177e4SLinus Torvalds 20771da177e4SLinus Torvalds i = MAIN_VC_TABLE * iadev->memSize; 20781da177e4SLinus Torvalds writew(vcsize_sel | ((i >> 8) & 0xfff8),iadev->seg_reg+VCT_BASE); 20791da177e4SLinus Torvalds i = EXT_VC_TABLE * iadev->memSize; 20801da177e4SLinus Torvalds writew((i >> 8) & 0xfffe, iadev->seg_reg+VCTE_BASE); 20811da177e4SLinus Torvalds i = UBR_SCHED_TABLE * iadev->memSize; 20821da177e4SLinus Torvalds writew((i & 0xffff) >> 11, iadev->seg_reg+UBR_SBPTR_BASE); 20831da177e4SLinus Torvalds i = UBR_WAIT_Q * iadev->memSize; 20841da177e4SLinus Torvalds writew((i >> 7) & 0xffff, iadev->seg_reg+UBRWQ_BASE); 20851da177e4SLinus Torvalds memset((caddr_t)(iadev->seg_ram+UBR_SCHED_TABLE*iadev->memSize), 20861da177e4SLinus Torvalds 0, iadev->num_vc*8); 20871da177e4SLinus Torvalds /* ABR scheduling Table(0x5000-0x57ff) and wait queue(0x5800-0x5fff)*/ 20881da177e4SLinus Torvalds /* initialize all bytes of ABR scheduler table and wait queue to 0 20891da177e4SLinus Torvalds - SCHEDSZ is 1K (# of entries). 20901da177e4SLinus Torvalds - ABR Table size is 2K 20911da177e4SLinus Torvalds - ABR wait queue is 2K 20921da177e4SLinus Torvalds since the table and wait queues are contiguous, all the bytes 20931da177e4SLinus Torvalds can be intialized by one memeset. 20941da177e4SLinus Torvalds */ 20951da177e4SLinus Torvalds i = ABR_SCHED_TABLE * iadev->memSize; 20961da177e4SLinus Torvalds writew((i >> 11) & 0xffff, iadev->seg_reg+ABR_SBPTR_BASE); 20971da177e4SLinus Torvalds i = ABR_WAIT_Q * iadev->memSize; 20981da177e4SLinus Torvalds writew((i >> 7) & 0xffff, iadev->seg_reg+ABRWQ_BASE); 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds i = ABR_SCHED_TABLE*iadev->memSize; 21011da177e4SLinus Torvalds memset((caddr_t)(iadev->seg_ram+i), 0, iadev->num_vc*4); 21021da177e4SLinus Torvalds vc = (struct main_vc *)iadev->MAIN_VC_TABLE_ADDR; 21031da177e4SLinus Torvalds evc = (struct ext_vc *)iadev->EXT_VC_TABLE_ADDR; 21041da177e4SLinus Torvalds iadev->testTable = kmalloc(sizeof(long)*iadev->num_vc, GFP_KERNEL); 21051da177e4SLinus Torvalds if (!iadev->testTable) { 21061da177e4SLinus Torvalds printk("Get freepage failed\n"); 21071da177e4SLinus Torvalds goto err_free_desc_tbl; 21081da177e4SLinus Torvalds } 21091da177e4SLinus Torvalds for(i=0; i<iadev->num_vc; i++) 21101da177e4SLinus Torvalds { 21111da177e4SLinus Torvalds memset((caddr_t)vc, 0, sizeof(*vc)); 21121da177e4SLinus Torvalds memset((caddr_t)evc, 0, sizeof(*evc)); 21131da177e4SLinus Torvalds iadev->testTable[i] = kmalloc(sizeof(struct testTable_t), 21141da177e4SLinus Torvalds GFP_KERNEL); 21151da177e4SLinus Torvalds if (!iadev->testTable[i]) 21161da177e4SLinus Torvalds goto err_free_test_tables; 21171da177e4SLinus Torvalds iadev->testTable[i]->lastTime = 0; 21181da177e4SLinus Torvalds iadev->testTable[i]->fract = 0; 21191da177e4SLinus Torvalds iadev->testTable[i]->vc_status = VC_UBR; 21201da177e4SLinus Torvalds vc++; 21211da177e4SLinus Torvalds evc++; 21221da177e4SLinus Torvalds } 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds /* Other Initialization */ 21251da177e4SLinus Torvalds 21261da177e4SLinus Torvalds /* Max Rate Register */ 21271da177e4SLinus Torvalds if (iadev->phy_type & FE_25MBIT_PHY) { 21281da177e4SLinus Torvalds writew(RATE25, iadev->seg_reg+MAXRATE); 21291da177e4SLinus Torvalds writew((UBR_EN | (0x23 << 2)), iadev->seg_reg+STPARMS); 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds else { 21321da177e4SLinus Torvalds writew(cellrate_to_float(iadev->LineRate),iadev->seg_reg+MAXRATE); 21331da177e4SLinus Torvalds writew((UBR_EN | ABR_EN | (0x23 << 2)), iadev->seg_reg+STPARMS); 21341da177e4SLinus Torvalds } 21351da177e4SLinus Torvalds /* Set Idle Header Reigisters to be sure */ 21361da177e4SLinus Torvalds writew(0, iadev->seg_reg+IDLEHEADHI); 21371da177e4SLinus Torvalds writew(0, iadev->seg_reg+IDLEHEADLO); 21381da177e4SLinus Torvalds 21391da177e4SLinus Torvalds /* Program ABR UBR Priority Register as PRI_ABR_UBR_EQUAL */ 21401da177e4SLinus Torvalds writew(0xaa00, iadev->seg_reg+ABRUBR_ARB); 21411da177e4SLinus Torvalds 21421da177e4SLinus Torvalds iadev->close_pending = 0; 21431da177e4SLinus Torvalds init_waitqueue_head(&iadev->close_wait); 21441da177e4SLinus Torvalds init_waitqueue_head(&iadev->timeout_wait); 21451da177e4SLinus Torvalds skb_queue_head_init(&iadev->tx_dma_q); 21461da177e4SLinus Torvalds ia_init_rtn_q(&iadev->tx_return_q); 21471da177e4SLinus Torvalds 21481da177e4SLinus Torvalds /* RM Cell Protocol ID and Message Type */ 21491da177e4SLinus Torvalds writew(RM_TYPE_4_0, iadev->seg_reg+RM_TYPE); 21501da177e4SLinus Torvalds skb_queue_head_init (&iadev->tx_backlog); 21511da177e4SLinus Torvalds 21521da177e4SLinus Torvalds /* Mode Register 1 */ 21531da177e4SLinus Torvalds writew(MODE_REG_1_VAL, iadev->seg_reg+MODE_REG_1); 21541da177e4SLinus Torvalds 21551da177e4SLinus Torvalds /* Mode Register 0 */ 21561da177e4SLinus Torvalds writew(T_ONLINE, iadev->seg_reg+MODE_REG_0); 21571da177e4SLinus Torvalds 21581da177e4SLinus Torvalds /* Interrupt Status Register - read to clear */ 21591da177e4SLinus Torvalds readw(iadev->seg_reg+SEG_INTR_STATUS_REG); 21601da177e4SLinus Torvalds 21611da177e4SLinus Torvalds /* Interrupt Mask Reg- don't mask TCQ_NOT_EMPTY interrupt generation */ 21621da177e4SLinus Torvalds writew(~(TRANSMIT_DONE | TCQ_NOT_EMPTY), iadev->seg_reg+SEG_MASK_REG); 21631da177e4SLinus Torvalds writew(TRANSMIT_DONE, iadev->seg_reg+SEG_INTR_STATUS_REG); 21641da177e4SLinus Torvalds iadev->tx_pkt_cnt = 0; 21651da177e4SLinus Torvalds iadev->rate_limit = iadev->LineRate / 3; 21661da177e4SLinus Torvalds 21671da177e4SLinus Torvalds return 0; 21681da177e4SLinus Torvalds 21691da177e4SLinus Torvalds err_free_test_tables: 21701da177e4SLinus Torvalds while (--i >= 0) 21711da177e4SLinus Torvalds kfree(iadev->testTable[i]); 21721da177e4SLinus Torvalds kfree(iadev->testTable); 21731da177e4SLinus Torvalds err_free_desc_tbl: 21741da177e4SLinus Torvalds kfree(iadev->desc_tbl); 21751da177e4SLinus Torvalds err_free_all_tx_bufs: 21761da177e4SLinus Torvalds i = iadev->num_tx_desc; 21771da177e4SLinus Torvalds err_free_tx_bufs: 21781da177e4SLinus Torvalds while (--i >= 0) { 21791da177e4SLinus Torvalds struct cpcs_trailer_desc *desc = iadev->tx_buf + i; 21801da177e4SLinus Torvalds 21811da177e4SLinus Torvalds pci_unmap_single(iadev->pci, desc->dma_addr, 21821da177e4SLinus Torvalds sizeof(*desc->cpcs), PCI_DMA_TODEVICE); 21831da177e4SLinus Torvalds kfree(desc->cpcs); 21841da177e4SLinus Torvalds } 21851da177e4SLinus Torvalds kfree(iadev->tx_buf); 21861da177e4SLinus Torvalds err_free_dle: 21871da177e4SLinus Torvalds pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, 21881da177e4SLinus Torvalds iadev->tx_dle_dma); 21891da177e4SLinus Torvalds err_out: 21901da177e4SLinus Torvalds return -ENOMEM; 21911da177e4SLinus Torvalds } 21921da177e4SLinus Torvalds 21937d12e780SDavid Howells static irqreturn_t ia_int(int irq, void *dev_id) 21941da177e4SLinus Torvalds { 21951da177e4SLinus Torvalds struct atm_dev *dev; 21961da177e4SLinus Torvalds IADEV *iadev; 21971da177e4SLinus Torvalds unsigned int status; 21981da177e4SLinus Torvalds int handled = 0; 21991da177e4SLinus Torvalds 22001da177e4SLinus Torvalds dev = dev_id; 22011da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 22021da177e4SLinus Torvalds while( (status = readl(iadev->reg+IPHASE5575_BUS_STATUS_REG) & 0x7f)) 22031da177e4SLinus Torvalds { 22041da177e4SLinus Torvalds handled = 1; 22051da177e4SLinus Torvalds IF_EVENT(printk("ia_int: status = 0x%x\n", status);) 22061da177e4SLinus Torvalds if (status & STAT_REASSINT) 22071da177e4SLinus Torvalds { 22081da177e4SLinus Torvalds /* do something */ 22091da177e4SLinus Torvalds IF_EVENT(printk("REASSINT Bus status reg: %08x\n", status);) 22101da177e4SLinus Torvalds rx_intr(dev); 22111da177e4SLinus Torvalds } 22121da177e4SLinus Torvalds if (status & STAT_DLERINT) 22131da177e4SLinus Torvalds { 22141da177e4SLinus Torvalds /* Clear this bit by writing a 1 to it. */ 22151da177e4SLinus Torvalds *(u_int *)(iadev->reg+IPHASE5575_BUS_STATUS_REG) = STAT_DLERINT; 22161da177e4SLinus Torvalds rx_dle_intr(dev); 22171da177e4SLinus Torvalds } 22181da177e4SLinus Torvalds if (status & STAT_SEGINT) 22191da177e4SLinus Torvalds { 22201da177e4SLinus Torvalds /* do something */ 22211da177e4SLinus Torvalds IF_EVENT(printk("IA: tx_intr \n");) 22221da177e4SLinus Torvalds tx_intr(dev); 22231da177e4SLinus Torvalds } 22241da177e4SLinus Torvalds if (status & STAT_DLETINT) 22251da177e4SLinus Torvalds { 22261da177e4SLinus Torvalds *(u_int *)(iadev->reg+IPHASE5575_BUS_STATUS_REG) = STAT_DLETINT; 22271da177e4SLinus Torvalds tx_dle_intr(dev); 22281da177e4SLinus Torvalds } 22291da177e4SLinus Torvalds if (status & (STAT_FEINT | STAT_ERRINT | STAT_MARKINT)) 22301da177e4SLinus Torvalds { 22311da177e4SLinus Torvalds if (status & STAT_FEINT) 22321da177e4SLinus Torvalds IaFrontEndIntr(iadev); 22331da177e4SLinus Torvalds } 22341da177e4SLinus Torvalds } 22351da177e4SLinus Torvalds return IRQ_RETVAL(handled); 22361da177e4SLinus Torvalds } 22371da177e4SLinus Torvalds 22381da177e4SLinus Torvalds 22391da177e4SLinus Torvalds 22401da177e4SLinus Torvalds /*----------------------------- entries --------------------------------*/ 22411da177e4SLinus Torvalds static int get_esi(struct atm_dev *dev) 22421da177e4SLinus Torvalds { 22431da177e4SLinus Torvalds IADEV *iadev; 22441da177e4SLinus Torvalds int i; 22451da177e4SLinus Torvalds u32 mac1; 22461da177e4SLinus Torvalds u16 mac2; 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 22491da177e4SLinus Torvalds mac1 = cpu_to_be32(le32_to_cpu(readl( 22501da177e4SLinus Torvalds iadev->reg+IPHASE5575_MAC1))); 22511da177e4SLinus Torvalds mac2 = cpu_to_be16(le16_to_cpu(readl(iadev->reg+IPHASE5575_MAC2))); 22521da177e4SLinus Torvalds IF_INIT(printk("ESI: 0x%08x%04x\n", mac1, mac2);) 22531da177e4SLinus Torvalds for (i=0; i<MAC1_LEN; i++) 22541da177e4SLinus Torvalds dev->esi[i] = mac1 >>(8*(MAC1_LEN-1-i)); 22551da177e4SLinus Torvalds 22561da177e4SLinus Torvalds for (i=0; i<MAC2_LEN; i++) 22571da177e4SLinus Torvalds dev->esi[i+MAC1_LEN] = mac2 >>(8*(MAC2_LEN - 1 -i)); 22581da177e4SLinus Torvalds return 0; 22591da177e4SLinus Torvalds } 22601da177e4SLinus Torvalds 22611da177e4SLinus Torvalds static int reset_sar(struct atm_dev *dev) 22621da177e4SLinus Torvalds { 22631da177e4SLinus Torvalds IADEV *iadev; 22641da177e4SLinus Torvalds int i, error = 1; 22651da177e4SLinus Torvalds unsigned int pci[64]; 22661da177e4SLinus Torvalds 22671da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 22681da177e4SLinus Torvalds for(i=0; i<64; i++) 22691da177e4SLinus Torvalds if ((error = pci_read_config_dword(iadev->pci, 22701da177e4SLinus Torvalds i*4, &pci[i])) != PCIBIOS_SUCCESSFUL) 22711da177e4SLinus Torvalds return error; 22721da177e4SLinus Torvalds writel(0, iadev->reg+IPHASE5575_EXT_RESET); 22731da177e4SLinus Torvalds for(i=0; i<64; i++) 22741da177e4SLinus Torvalds if ((error = pci_write_config_dword(iadev->pci, 22751da177e4SLinus Torvalds i*4, pci[i])) != PCIBIOS_SUCCESSFUL) 22761da177e4SLinus Torvalds return error; 22771da177e4SLinus Torvalds udelay(5); 22781da177e4SLinus Torvalds return 0; 22791da177e4SLinus Torvalds } 22801da177e4SLinus Torvalds 22811da177e4SLinus Torvalds 2282249c14b5SChas Williams static int __devinit ia_init(struct atm_dev *dev) 22831da177e4SLinus Torvalds { 22841da177e4SLinus Torvalds IADEV *iadev; 22851da177e4SLinus Torvalds unsigned long real_base; 22861da177e4SLinus Torvalds void __iomem *base; 22871da177e4SLinus Torvalds unsigned short command; 22881da177e4SLinus Torvalds int error, i; 22891da177e4SLinus Torvalds 22901da177e4SLinus Torvalds /* The device has been identified and registered. Now we read 22911da177e4SLinus Torvalds necessary configuration info like memory base address, 22921da177e4SLinus Torvalds interrupt number etc */ 22931da177e4SLinus Torvalds 22941da177e4SLinus Torvalds IF_INIT(printk(">ia_init\n");) 22951da177e4SLinus Torvalds dev->ci_range.vpi_bits = 0; 22961da177e4SLinus Torvalds dev->ci_range.vci_bits = NR_VCI_LD; 22971da177e4SLinus Torvalds 22981da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 22991da177e4SLinus Torvalds real_base = pci_resource_start (iadev->pci, 0); 23001da177e4SLinus Torvalds iadev->irq = iadev->pci->irq; 23011da177e4SLinus Torvalds 230244c10138SAuke Kok error = pci_read_config_word(iadev->pci, PCI_COMMAND, &command); 230344c10138SAuke Kok if (error) { 23041da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "(itf %d): init error 0x%x\n", 23051da177e4SLinus Torvalds dev->number,error); 23061da177e4SLinus Torvalds return -EINVAL; 23071da177e4SLinus Torvalds } 23081da177e4SLinus Torvalds IF_INIT(printk(DEV_LABEL "(itf %d): rev.%d,realbase=0x%lx,irq=%d\n", 230944c10138SAuke Kok dev->number, iadev->pci->revision, real_base, iadev->irq);) 23101da177e4SLinus Torvalds 23111da177e4SLinus Torvalds /* find mapping size of board */ 23121da177e4SLinus Torvalds 23131da177e4SLinus Torvalds iadev->pci_map_size = pci_resource_len(iadev->pci, 0); 23141da177e4SLinus Torvalds 23151da177e4SLinus Torvalds if (iadev->pci_map_size == 0x100000){ 23161da177e4SLinus Torvalds iadev->num_vc = 4096; 23171da177e4SLinus Torvalds dev->ci_range.vci_bits = NR_VCI_4K_LD; 23181da177e4SLinus Torvalds iadev->memSize = 4; 23191da177e4SLinus Torvalds } 23201da177e4SLinus Torvalds else if (iadev->pci_map_size == 0x40000) { 23211da177e4SLinus Torvalds iadev->num_vc = 1024; 23221da177e4SLinus Torvalds iadev->memSize = 1; 23231da177e4SLinus Torvalds } 23241da177e4SLinus Torvalds else { 23251da177e4SLinus Torvalds printk("Unknown pci_map_size = 0x%x\n", iadev->pci_map_size); 23261da177e4SLinus Torvalds return -EINVAL; 23271da177e4SLinus Torvalds } 23281da177e4SLinus Torvalds IF_INIT(printk (DEV_LABEL "map size: %i\n", iadev->pci_map_size);) 23291da177e4SLinus Torvalds 23301da177e4SLinus Torvalds /* enable bus mastering */ 23311da177e4SLinus Torvalds pci_set_master(iadev->pci); 23321da177e4SLinus Torvalds 23331da177e4SLinus Torvalds /* 23341da177e4SLinus Torvalds * Delay at least 1us before doing any mem accesses (how 'bout 10?) 23351da177e4SLinus Torvalds */ 23361da177e4SLinus Torvalds udelay(10); 23371da177e4SLinus Torvalds 23381da177e4SLinus Torvalds /* mapping the physical address to a virtual address in address space */ 23391da177e4SLinus Torvalds base = ioremap(real_base,iadev->pci_map_size); /* ioremap is not resolved ??? */ 23401da177e4SLinus Torvalds 23411da177e4SLinus Torvalds if (!base) 23421da177e4SLinus Torvalds { 23431da177e4SLinus Torvalds printk(DEV_LABEL " (itf %d): can't set up page mapping\n", 23441da177e4SLinus Torvalds dev->number); 23451da177e4SLinus Torvalds return error; 23461da177e4SLinus Torvalds } 23471da177e4SLinus Torvalds IF_INIT(printk(DEV_LABEL " (itf %d): rev.%d,base=%p,irq=%d\n", 234844c10138SAuke Kok dev->number, iadev->pci->revision, base, iadev->irq);) 23491da177e4SLinus Torvalds 23501da177e4SLinus Torvalds /* filling the iphase dev structure */ 23511da177e4SLinus Torvalds iadev->mem = iadev->pci_map_size /2; 23521da177e4SLinus Torvalds iadev->real_base = real_base; 23531da177e4SLinus Torvalds iadev->base = base; 23541da177e4SLinus Torvalds 23551da177e4SLinus Torvalds /* Bus Interface Control Registers */ 23561da177e4SLinus Torvalds iadev->reg = base + REG_BASE; 23571da177e4SLinus Torvalds /* Segmentation Control Registers */ 23581da177e4SLinus Torvalds iadev->seg_reg = base + SEG_BASE; 23591da177e4SLinus Torvalds /* Reassembly Control Registers */ 23601da177e4SLinus Torvalds iadev->reass_reg = base + REASS_BASE; 23611da177e4SLinus Torvalds /* Front end/ DMA control registers */ 23621da177e4SLinus Torvalds iadev->phy = base + PHY_BASE; 23631da177e4SLinus Torvalds iadev->dma = base + PHY_BASE; 23641da177e4SLinus Torvalds /* RAM - Segmentation RAm and Reassembly RAM */ 23651da177e4SLinus Torvalds iadev->ram = base + ACTUAL_RAM_BASE; 23661da177e4SLinus Torvalds iadev->seg_ram = base + ACTUAL_SEG_RAM_BASE; 23671da177e4SLinus Torvalds iadev->reass_ram = base + ACTUAL_REASS_RAM_BASE; 23681da177e4SLinus Torvalds 23691da177e4SLinus Torvalds /* lets print out the above */ 23701da177e4SLinus Torvalds IF_INIT(printk("Base addrs: %p %p %p \n %p %p %p %p\n", 23711da177e4SLinus Torvalds iadev->reg,iadev->seg_reg,iadev->reass_reg, 23721da177e4SLinus Torvalds iadev->phy, iadev->ram, iadev->seg_ram, 23731da177e4SLinus Torvalds iadev->reass_ram);) 23741da177e4SLinus Torvalds 23751da177e4SLinus Torvalds /* lets try reading the MAC address */ 23761da177e4SLinus Torvalds error = get_esi(dev); 23771da177e4SLinus Torvalds if (error) { 23781da177e4SLinus Torvalds iounmap(iadev->base); 23791da177e4SLinus Torvalds return error; 23801da177e4SLinus Torvalds } 23811da177e4SLinus Torvalds printk("IA: "); 23821da177e4SLinus Torvalds for (i=0; i < ESI_LEN; i++) 23831da177e4SLinus Torvalds printk("%s%02X",i ? "-" : "",dev->esi[i]); 23841da177e4SLinus Torvalds printk("\n"); 23851da177e4SLinus Torvalds 23861da177e4SLinus Torvalds /* reset SAR */ 23871da177e4SLinus Torvalds if (reset_sar(dev)) { 23881da177e4SLinus Torvalds iounmap(iadev->base); 23891da177e4SLinus Torvalds printk("IA: reset SAR fail, please try again\n"); 23901da177e4SLinus Torvalds return 1; 23911da177e4SLinus Torvalds } 23921da177e4SLinus Torvalds return 0; 23931da177e4SLinus Torvalds } 23941da177e4SLinus Torvalds 23951da177e4SLinus Torvalds static void ia_update_stats(IADEV *iadev) { 23961da177e4SLinus Torvalds if (!iadev->carrier_detect) 23971da177e4SLinus Torvalds return; 23981da177e4SLinus Torvalds iadev->rx_cell_cnt += readw(iadev->reass_reg+CELL_CTR0)&0xffff; 23991da177e4SLinus Torvalds iadev->rx_cell_cnt += (readw(iadev->reass_reg+CELL_CTR1) & 0xffff) << 16; 24001da177e4SLinus Torvalds iadev->drop_rxpkt += readw(iadev->reass_reg + DRP_PKT_CNTR ) & 0xffff; 24011da177e4SLinus Torvalds iadev->drop_rxcell += readw(iadev->reass_reg + ERR_CNTR) & 0xffff; 24021da177e4SLinus Torvalds iadev->tx_cell_cnt += readw(iadev->seg_reg + CELL_CTR_LO_AUTO)&0xffff; 24031da177e4SLinus Torvalds iadev->tx_cell_cnt += (readw(iadev->seg_reg+CELL_CTR_HIGH_AUTO)&0xffff)<<16; 24041da177e4SLinus Torvalds return; 24051da177e4SLinus Torvalds } 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds static void ia_led_timer(unsigned long arg) { 24081da177e4SLinus Torvalds unsigned long flags; 24091da177e4SLinus Torvalds static u_char blinking[8] = {0, 0, 0, 0, 0, 0, 0, 0}; 24101da177e4SLinus Torvalds u_char i; 24111da177e4SLinus Torvalds static u32 ctrl_reg; 24121da177e4SLinus Torvalds for (i = 0; i < iadev_count; i++) { 24131da177e4SLinus Torvalds if (ia_dev[i]) { 24141da177e4SLinus Torvalds ctrl_reg = readl(ia_dev[i]->reg+IPHASE5575_BUS_CONTROL_REG); 24151da177e4SLinus Torvalds if (blinking[i] == 0) { 24161da177e4SLinus Torvalds blinking[i]++; 24171da177e4SLinus Torvalds ctrl_reg &= (~CTRL_LED); 24181da177e4SLinus Torvalds writel(ctrl_reg, ia_dev[i]->reg+IPHASE5575_BUS_CONTROL_REG); 24191da177e4SLinus Torvalds ia_update_stats(ia_dev[i]); 24201da177e4SLinus Torvalds } 24211da177e4SLinus Torvalds else { 24221da177e4SLinus Torvalds blinking[i] = 0; 24231da177e4SLinus Torvalds ctrl_reg |= CTRL_LED; 24241da177e4SLinus Torvalds writel(ctrl_reg, ia_dev[i]->reg+IPHASE5575_BUS_CONTROL_REG); 24251da177e4SLinus Torvalds spin_lock_irqsave(&ia_dev[i]->tx_lock, flags); 24261da177e4SLinus Torvalds if (ia_dev[i]->close_pending) 24271da177e4SLinus Torvalds wake_up(&ia_dev[i]->close_wait); 24281da177e4SLinus Torvalds ia_tx_poll(ia_dev[i]); 24291da177e4SLinus Torvalds spin_unlock_irqrestore(&ia_dev[i]->tx_lock, flags); 24301da177e4SLinus Torvalds } 24311da177e4SLinus Torvalds } 24321da177e4SLinus Torvalds } 24331da177e4SLinus Torvalds mod_timer(&ia_timer, jiffies + HZ / 4); 24341da177e4SLinus Torvalds return; 24351da177e4SLinus Torvalds } 24361da177e4SLinus Torvalds 24371da177e4SLinus Torvalds static void ia_phy_put(struct atm_dev *dev, unsigned char value, 24381da177e4SLinus Torvalds unsigned long addr) 24391da177e4SLinus Torvalds { 24401da177e4SLinus Torvalds writel(value, INPH_IA_DEV(dev)->phy+addr); 24411da177e4SLinus Torvalds } 24421da177e4SLinus Torvalds 24431da177e4SLinus Torvalds static unsigned char ia_phy_get(struct atm_dev *dev, unsigned long addr) 24441da177e4SLinus Torvalds { 24451da177e4SLinus Torvalds return readl(INPH_IA_DEV(dev)->phy+addr); 24461da177e4SLinus Torvalds } 24471da177e4SLinus Torvalds 24481da177e4SLinus Torvalds static void ia_free_tx(IADEV *iadev) 24491da177e4SLinus Torvalds { 24501da177e4SLinus Torvalds int i; 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds kfree(iadev->desc_tbl); 24531da177e4SLinus Torvalds for (i = 0; i < iadev->num_vc; i++) 24541da177e4SLinus Torvalds kfree(iadev->testTable[i]); 24551da177e4SLinus Torvalds kfree(iadev->testTable); 24561da177e4SLinus Torvalds for (i = 0; i < iadev->num_tx_desc; i++) { 24571da177e4SLinus Torvalds struct cpcs_trailer_desc *desc = iadev->tx_buf + i; 24581da177e4SLinus Torvalds 24591da177e4SLinus Torvalds pci_unmap_single(iadev->pci, desc->dma_addr, 24601da177e4SLinus Torvalds sizeof(*desc->cpcs), PCI_DMA_TODEVICE); 24611da177e4SLinus Torvalds kfree(desc->cpcs); 24621da177e4SLinus Torvalds } 24631da177e4SLinus Torvalds kfree(iadev->tx_buf); 24641da177e4SLinus Torvalds pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, 24651da177e4SLinus Torvalds iadev->tx_dle_dma); 24661da177e4SLinus Torvalds } 24671da177e4SLinus Torvalds 24681da177e4SLinus Torvalds static void ia_free_rx(IADEV *iadev) 24691da177e4SLinus Torvalds { 24701da177e4SLinus Torvalds kfree(iadev->rx_open); 24711da177e4SLinus Torvalds pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, 24721da177e4SLinus Torvalds iadev->rx_dle_dma); 24731da177e4SLinus Torvalds } 24741da177e4SLinus Torvalds 2475249c14b5SChas Williams static int __devinit ia_start(struct atm_dev *dev) 24761da177e4SLinus Torvalds { 24771da177e4SLinus Torvalds IADEV *iadev; 24781da177e4SLinus Torvalds int error; 24791da177e4SLinus Torvalds unsigned char phy; 24801da177e4SLinus Torvalds u32 ctrl_reg; 24811da177e4SLinus Torvalds IF_EVENT(printk(">ia_start\n");) 24821da177e4SLinus Torvalds iadev = INPH_IA_DEV(dev); 2483dace1453SThomas Gleixner if (request_irq(iadev->irq, &ia_int, IRQF_SHARED, DEV_LABEL, dev)) { 24841da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "(itf %d): IRQ%d is already in use\n", 24851da177e4SLinus Torvalds dev->number, iadev->irq); 24861da177e4SLinus Torvalds error = -EAGAIN; 24871da177e4SLinus Torvalds goto err_out; 24881da177e4SLinus Torvalds } 24891da177e4SLinus Torvalds /* @@@ should release IRQ on error */ 24901da177e4SLinus Torvalds /* enabling memory + master */ 24911da177e4SLinus Torvalds if ((error = pci_write_config_word(iadev->pci, 24921da177e4SLinus Torvalds PCI_COMMAND, 24931da177e4SLinus Torvalds PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER ))) 24941da177e4SLinus Torvalds { 24951da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL "(itf %d): can't enable memory+" 24961da177e4SLinus Torvalds "master (0x%x)\n",dev->number, error); 24971da177e4SLinus Torvalds error = -EIO; 24981da177e4SLinus Torvalds goto err_free_irq; 24991da177e4SLinus Torvalds } 25001da177e4SLinus Torvalds udelay(10); 25011da177e4SLinus Torvalds 25021da177e4SLinus Torvalds /* Maybe we should reset the front end, initialize Bus Interface Control 25031da177e4SLinus Torvalds Registers and see. */ 25041da177e4SLinus Torvalds 25051da177e4SLinus Torvalds IF_INIT(printk("Bus ctrl reg: %08x\n", 25061da177e4SLinus Torvalds readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG));) 25071da177e4SLinus Torvalds ctrl_reg = readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG); 25081da177e4SLinus Torvalds ctrl_reg = (ctrl_reg & (CTRL_LED | CTRL_FE_RST)) 25091da177e4SLinus Torvalds | CTRL_B8 25101da177e4SLinus Torvalds | CTRL_B16 25111da177e4SLinus Torvalds | CTRL_B32 25121da177e4SLinus Torvalds | CTRL_B48 25131da177e4SLinus Torvalds | CTRL_B64 25141da177e4SLinus Torvalds | CTRL_B128 25151da177e4SLinus Torvalds | CTRL_ERRMASK 25161da177e4SLinus Torvalds | CTRL_DLETMASK /* shud be removed l8r */ 25171da177e4SLinus Torvalds | CTRL_DLERMASK 25181da177e4SLinus Torvalds | CTRL_SEGMASK 25191da177e4SLinus Torvalds | CTRL_REASSMASK 25201da177e4SLinus Torvalds | CTRL_FEMASK 25211da177e4SLinus Torvalds | CTRL_CSPREEMPT; 25221da177e4SLinus Torvalds 25231da177e4SLinus Torvalds writel(ctrl_reg, iadev->reg+IPHASE5575_BUS_CONTROL_REG); 25241da177e4SLinus Torvalds 25251da177e4SLinus Torvalds IF_INIT(printk("Bus ctrl reg after initializing: %08x\n", 25261da177e4SLinus Torvalds readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG)); 25271da177e4SLinus Torvalds printk("Bus status reg after init: %08x\n", 25281da177e4SLinus Torvalds readl(iadev->reg+IPHASE5575_BUS_STATUS_REG));) 25291da177e4SLinus Torvalds 25301da177e4SLinus Torvalds ia_hw_type(iadev); 25311da177e4SLinus Torvalds error = tx_init(dev); 25321da177e4SLinus Torvalds if (error) 25331da177e4SLinus Torvalds goto err_free_irq; 25341da177e4SLinus Torvalds error = rx_init(dev); 25351da177e4SLinus Torvalds if (error) 25361da177e4SLinus Torvalds goto err_free_tx; 25371da177e4SLinus Torvalds 25381da177e4SLinus Torvalds ctrl_reg = readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG); 25391da177e4SLinus Torvalds writel(ctrl_reg | CTRL_FE_RST, iadev->reg+IPHASE5575_BUS_CONTROL_REG); 25401da177e4SLinus Torvalds IF_INIT(printk("Bus ctrl reg after initializing: %08x\n", 25411da177e4SLinus Torvalds readl(iadev->reg+IPHASE5575_BUS_CONTROL_REG));) 25421da177e4SLinus Torvalds phy = 0; /* resolve compiler complaint */ 25431da177e4SLinus Torvalds IF_INIT ( 25441da177e4SLinus Torvalds if ((phy=ia_phy_get(dev,0)) == 0x30) 25451da177e4SLinus Torvalds printk("IA: pm5346,rev.%d\n",phy&0x0f); 25461da177e4SLinus Torvalds else 25471da177e4SLinus Torvalds printk("IA: utopia,rev.%0x\n",phy);) 25481da177e4SLinus Torvalds 25491da177e4SLinus Torvalds if (iadev->phy_type & FE_25MBIT_PHY) 25501da177e4SLinus Torvalds ia_mb25_init(iadev); 25511da177e4SLinus Torvalds else if (iadev->phy_type & (FE_DS3_PHY | FE_E3_PHY)) 25521da177e4SLinus Torvalds ia_suni_pm7345_init(iadev); 25531da177e4SLinus Torvalds else { 25541da177e4SLinus Torvalds error = suni_init(dev); 25551da177e4SLinus Torvalds if (error) 25561da177e4SLinus Torvalds goto err_free_rx; 2557d6c1d704SJorge Boncompte [DTI2] if (dev->phy->start) { 25581da177e4SLinus Torvalds error = dev->phy->start(dev); 25591da177e4SLinus Torvalds if (error) 25601da177e4SLinus Torvalds goto err_free_rx; 2561d6c1d704SJorge Boncompte [DTI2] } 25621da177e4SLinus Torvalds /* Get iadev->carrier_detect status */ 25631da177e4SLinus Torvalds IaFrontEndIntr(iadev); 25641da177e4SLinus Torvalds } 25651da177e4SLinus Torvalds return 0; 25661da177e4SLinus Torvalds 25671da177e4SLinus Torvalds err_free_rx: 25681da177e4SLinus Torvalds ia_free_rx(iadev); 25691da177e4SLinus Torvalds err_free_tx: 25701da177e4SLinus Torvalds ia_free_tx(iadev); 25711da177e4SLinus Torvalds err_free_irq: 25721da177e4SLinus Torvalds free_irq(iadev->irq, dev); 25731da177e4SLinus Torvalds err_out: 25741da177e4SLinus Torvalds return error; 25751da177e4SLinus Torvalds } 25761da177e4SLinus Torvalds 25771da177e4SLinus Torvalds static void ia_close(struct atm_vcc *vcc) 25781da177e4SLinus Torvalds { 25791da177e4SLinus Torvalds DEFINE_WAIT(wait); 25801da177e4SLinus Torvalds u16 *vc_table; 25811da177e4SLinus Torvalds IADEV *iadev; 25821da177e4SLinus Torvalds struct ia_vcc *ia_vcc; 25831da177e4SLinus Torvalds struct sk_buff *skb = NULL; 25841da177e4SLinus Torvalds struct sk_buff_head tmp_tx_backlog, tmp_vcc_backlog; 25851da177e4SLinus Torvalds unsigned long closetime, flags; 25861da177e4SLinus Torvalds 25871da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 25881da177e4SLinus Torvalds ia_vcc = INPH_IA_VCC(vcc); 25891da177e4SLinus Torvalds if (!ia_vcc) return; 25901da177e4SLinus Torvalds 25911da177e4SLinus Torvalds IF_EVENT(printk("ia_close: ia_vcc->vc_desc_cnt = %d vci = %d\n", 25921da177e4SLinus Torvalds ia_vcc->vc_desc_cnt,vcc->vci);) 25931da177e4SLinus Torvalds clear_bit(ATM_VF_READY,&vcc->flags); 25941da177e4SLinus Torvalds skb_queue_head_init (&tmp_tx_backlog); 25951da177e4SLinus Torvalds skb_queue_head_init (&tmp_vcc_backlog); 25961da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class != ATM_NONE) { 25971da177e4SLinus Torvalds iadev->close_pending++; 25981da177e4SLinus Torvalds prepare_to_wait(&iadev->timeout_wait, &wait, TASK_UNINTERRUPTIBLE); 25991da177e4SLinus Torvalds schedule_timeout(50); 26001da177e4SLinus Torvalds finish_wait(&iadev->timeout_wait, &wait); 26011da177e4SLinus Torvalds spin_lock_irqsave(&iadev->tx_lock, flags); 26021da177e4SLinus Torvalds while((skb = skb_dequeue(&iadev->tx_backlog))) { 26031da177e4SLinus Torvalds if (ATM_SKB(skb)->vcc == vcc){ 26041da177e4SLinus Torvalds if (vcc->pop) vcc->pop(vcc, skb); 26051da177e4SLinus Torvalds else dev_kfree_skb_any(skb); 26061da177e4SLinus Torvalds } 26071da177e4SLinus Torvalds else 26081da177e4SLinus Torvalds skb_queue_tail(&tmp_tx_backlog, skb); 26091da177e4SLinus Torvalds } 26101da177e4SLinus Torvalds while((skb = skb_dequeue(&tmp_tx_backlog))) 26111da177e4SLinus Torvalds skb_queue_tail(&iadev->tx_backlog, skb); 26121da177e4SLinus Torvalds IF_EVENT(printk("IA TX Done decs_cnt = %d\n", ia_vcc->vc_desc_cnt);) 26131da177e4SLinus Torvalds closetime = 300000 / ia_vcc->pcr; 26141da177e4SLinus Torvalds if (closetime == 0) 26151da177e4SLinus Torvalds closetime = 1; 26161da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 26171da177e4SLinus Torvalds wait_event_timeout(iadev->close_wait, (ia_vcc->vc_desc_cnt <= 0), closetime); 26181da177e4SLinus Torvalds spin_lock_irqsave(&iadev->tx_lock, flags); 26191da177e4SLinus Torvalds iadev->close_pending--; 26201da177e4SLinus Torvalds iadev->testTable[vcc->vci]->lastTime = 0; 26211da177e4SLinus Torvalds iadev->testTable[vcc->vci]->fract = 0; 26221da177e4SLinus Torvalds iadev->testTable[vcc->vci]->vc_status = VC_UBR; 26231da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_ABR) { 26241da177e4SLinus Torvalds if (vcc->qos.txtp.min_pcr > 0) 26251da177e4SLinus Torvalds iadev->sum_mcr -= vcc->qos.txtp.min_pcr; 26261da177e4SLinus Torvalds } 26271da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_CBR) { 26281da177e4SLinus Torvalds ia_vcc = INPH_IA_VCC(vcc); 26291da177e4SLinus Torvalds iadev->sum_mcr -= ia_vcc->NumCbrEntry*iadev->Granularity; 26301da177e4SLinus Torvalds ia_cbrVc_close (vcc); 26311da177e4SLinus Torvalds } 26321da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 26331da177e4SLinus Torvalds } 26341da177e4SLinus Torvalds 26351da177e4SLinus Torvalds if (vcc->qos.rxtp.traffic_class != ATM_NONE) { 26361da177e4SLinus Torvalds // reset reass table 26371da177e4SLinus Torvalds vc_table = (u16 *)(iadev->reass_ram+REASS_TABLE*iadev->memSize); 26381da177e4SLinus Torvalds vc_table += vcc->vci; 26391da177e4SLinus Torvalds *vc_table = NO_AAL5_PKT; 26401da177e4SLinus Torvalds // reset vc table 26411da177e4SLinus Torvalds vc_table = (u16 *)(iadev->reass_ram+RX_VC_TABLE*iadev->memSize); 26421da177e4SLinus Torvalds vc_table += vcc->vci; 26431da177e4SLinus Torvalds *vc_table = (vcc->vci << 6) | 15; 26441da177e4SLinus Torvalds if (vcc->qos.rxtp.traffic_class == ATM_ABR) { 26451da177e4SLinus Torvalds struct abr_vc_table __iomem *abr_vc_table = 26461da177e4SLinus Torvalds (iadev->reass_ram+ABR_VC_TABLE*iadev->memSize); 26471da177e4SLinus Torvalds abr_vc_table += vcc->vci; 26481da177e4SLinus Torvalds abr_vc_table->rdf = 0x0003; 26491da177e4SLinus Torvalds abr_vc_table->air = 0x5eb1; 26501da177e4SLinus Torvalds } 26511da177e4SLinus Torvalds // Drain the packets 26521da177e4SLinus Torvalds rx_dle_intr(vcc->dev); 26531da177e4SLinus Torvalds iadev->rx_open[vcc->vci] = NULL; 26541da177e4SLinus Torvalds } 26551da177e4SLinus Torvalds kfree(INPH_IA_VCC(vcc)); 26561da177e4SLinus Torvalds ia_vcc = NULL; 26571da177e4SLinus Torvalds vcc->dev_data = NULL; 26581da177e4SLinus Torvalds clear_bit(ATM_VF_ADDR,&vcc->flags); 26591da177e4SLinus Torvalds return; 26601da177e4SLinus Torvalds } 26611da177e4SLinus Torvalds 26621da177e4SLinus Torvalds static int ia_open(struct atm_vcc *vcc) 26631da177e4SLinus Torvalds { 26641da177e4SLinus Torvalds IADEV *iadev; 26651da177e4SLinus Torvalds struct ia_vcc *ia_vcc; 26661da177e4SLinus Torvalds int error; 26671da177e4SLinus Torvalds if (!test_bit(ATM_VF_PARTIAL,&vcc->flags)) 26681da177e4SLinus Torvalds { 26691da177e4SLinus Torvalds IF_EVENT(printk("ia: not partially allocated resources\n");) 26701da177e4SLinus Torvalds vcc->dev_data = NULL; 26711da177e4SLinus Torvalds } 26721da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 26731da177e4SLinus Torvalds if (vcc->vci != ATM_VPI_UNSPEC && vcc->vpi != ATM_VCI_UNSPEC) 26741da177e4SLinus Torvalds { 26751da177e4SLinus Torvalds IF_EVENT(printk("iphase open: unspec part\n");) 26761da177e4SLinus Torvalds set_bit(ATM_VF_ADDR,&vcc->flags); 26771da177e4SLinus Torvalds } 26781da177e4SLinus Torvalds if (vcc->qos.aal != ATM_AAL5) 26791da177e4SLinus Torvalds return -EINVAL; 26801da177e4SLinus Torvalds IF_EVENT(printk(DEV_LABEL "(itf %d): open %d.%d\n", 26811da177e4SLinus Torvalds vcc->dev->number, vcc->vpi, vcc->vci);) 26821da177e4SLinus Torvalds 26831da177e4SLinus Torvalds /* Device dependent initialization */ 26841da177e4SLinus Torvalds ia_vcc = kmalloc(sizeof(*ia_vcc), GFP_KERNEL); 26851da177e4SLinus Torvalds if (!ia_vcc) return -ENOMEM; 26861da177e4SLinus Torvalds vcc->dev_data = ia_vcc; 26871da177e4SLinus Torvalds 26881da177e4SLinus Torvalds if ((error = open_rx(vcc))) 26891da177e4SLinus Torvalds { 26901da177e4SLinus Torvalds IF_EVENT(printk("iadev: error in open_rx, closing\n");) 26911da177e4SLinus Torvalds ia_close(vcc); 26921da177e4SLinus Torvalds return error; 26931da177e4SLinus Torvalds } 26941da177e4SLinus Torvalds 26951da177e4SLinus Torvalds if ((error = open_tx(vcc))) 26961da177e4SLinus Torvalds { 26971da177e4SLinus Torvalds IF_EVENT(printk("iadev: error in open_tx, closing\n");) 26981da177e4SLinus Torvalds ia_close(vcc); 26991da177e4SLinus Torvalds return error; 27001da177e4SLinus Torvalds } 27011da177e4SLinus Torvalds 27021da177e4SLinus Torvalds set_bit(ATM_VF_READY,&vcc->flags); 27031da177e4SLinus Torvalds 27041da177e4SLinus Torvalds #if 0 27051da177e4SLinus Torvalds { 27061da177e4SLinus Torvalds static u8 first = 1; 27071da177e4SLinus Torvalds if (first) { 27081da177e4SLinus Torvalds ia_timer.expires = jiffies + 3*HZ; 27091da177e4SLinus Torvalds add_timer(&ia_timer); 27101da177e4SLinus Torvalds first = 0; 27111da177e4SLinus Torvalds } 27121da177e4SLinus Torvalds } 27131da177e4SLinus Torvalds #endif 27141da177e4SLinus Torvalds IF_EVENT(printk("ia open returning\n");) 27151da177e4SLinus Torvalds return 0; 27161da177e4SLinus Torvalds } 27171da177e4SLinus Torvalds 27181da177e4SLinus Torvalds static int ia_change_qos(struct atm_vcc *vcc, struct atm_qos *qos, int flags) 27191da177e4SLinus Torvalds { 27201da177e4SLinus Torvalds IF_EVENT(printk(">ia_change_qos\n");) 27211da177e4SLinus Torvalds return 0; 27221da177e4SLinus Torvalds } 27231da177e4SLinus Torvalds 27241da177e4SLinus Torvalds static int ia_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg) 27251da177e4SLinus Torvalds { 27261da177e4SLinus Torvalds IA_CMDBUF ia_cmds; 27271da177e4SLinus Torvalds IADEV *iadev; 27281da177e4SLinus Torvalds int i, board; 27291da177e4SLinus Torvalds u16 __user *tmps; 27301da177e4SLinus Torvalds IF_EVENT(printk(">ia_ioctl\n");) 27311da177e4SLinus Torvalds if (cmd != IA_CMD) { 27321da177e4SLinus Torvalds if (!dev->phy->ioctl) return -EINVAL; 27331da177e4SLinus Torvalds return dev->phy->ioctl(dev,cmd,arg); 27341da177e4SLinus Torvalds } 27351da177e4SLinus Torvalds if (copy_from_user(&ia_cmds, arg, sizeof ia_cmds)) return -EFAULT; 27361da177e4SLinus Torvalds board = ia_cmds.status; 27371da177e4SLinus Torvalds if ((board < 0) || (board > iadev_count)) 27381da177e4SLinus Torvalds board = 0; 27391da177e4SLinus Torvalds iadev = ia_dev[board]; 27401da177e4SLinus Torvalds switch (ia_cmds.cmd) { 27411da177e4SLinus Torvalds case MEMDUMP: 27421da177e4SLinus Torvalds { 27431da177e4SLinus Torvalds switch (ia_cmds.sub_cmd) { 27441da177e4SLinus Torvalds case MEMDUMP_DEV: 27451da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 27461da177e4SLinus Torvalds if (copy_to_user(ia_cmds.buf, iadev, sizeof(IADEV))) 27471da177e4SLinus Torvalds return -EFAULT; 27481da177e4SLinus Torvalds ia_cmds.status = 0; 27491da177e4SLinus Torvalds break; 27501da177e4SLinus Torvalds case MEMDUMP_SEGREG: 27511da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 27521da177e4SLinus Torvalds tmps = (u16 __user *)ia_cmds.buf; 27531da177e4SLinus Torvalds for(i=0; i<0x80; i+=2, tmps++) 27541da177e4SLinus Torvalds if(put_user((u16)(readl(iadev->seg_reg+i) & 0xffff), tmps)) return -EFAULT; 27551da177e4SLinus Torvalds ia_cmds.status = 0; 27561da177e4SLinus Torvalds ia_cmds.len = 0x80; 27571da177e4SLinus Torvalds break; 27581da177e4SLinus Torvalds case MEMDUMP_REASSREG: 27591da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 27601da177e4SLinus Torvalds tmps = (u16 __user *)ia_cmds.buf; 27611da177e4SLinus Torvalds for(i=0; i<0x80; i+=2, tmps++) 27621da177e4SLinus Torvalds if(put_user((u16)(readl(iadev->reass_reg+i) & 0xffff), tmps)) return -EFAULT; 27631da177e4SLinus Torvalds ia_cmds.status = 0; 27641da177e4SLinus Torvalds ia_cmds.len = 0x80; 27651da177e4SLinus Torvalds break; 27661da177e4SLinus Torvalds case MEMDUMP_FFL: 27671da177e4SLinus Torvalds { 27681da177e4SLinus Torvalds ia_regs_t *regs_local; 27691da177e4SLinus Torvalds ffredn_t *ffL; 27701da177e4SLinus Torvalds rfredn_t *rfL; 27711da177e4SLinus Torvalds 27721da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 27731da177e4SLinus Torvalds regs_local = kmalloc(sizeof(*regs_local), GFP_KERNEL); 27741da177e4SLinus Torvalds if (!regs_local) return -ENOMEM; 27751da177e4SLinus Torvalds ffL = ®s_local->ffredn; 27761da177e4SLinus Torvalds rfL = ®s_local->rfredn; 27771da177e4SLinus Torvalds /* Copy real rfred registers into the local copy */ 27781da177e4SLinus Torvalds for (i=0; i<(sizeof (rfredn_t))/4; i++) 27791da177e4SLinus Torvalds ((u_int *)rfL)[i] = readl(iadev->reass_reg + i) & 0xffff; 27801da177e4SLinus Torvalds /* Copy real ffred registers into the local copy */ 27811da177e4SLinus Torvalds for (i=0; i<(sizeof (ffredn_t))/4; i++) 27821da177e4SLinus Torvalds ((u_int *)ffL)[i] = readl(iadev->seg_reg + i) & 0xffff; 27831da177e4SLinus Torvalds 27841da177e4SLinus Torvalds if (copy_to_user(ia_cmds.buf, regs_local,sizeof(ia_regs_t))) { 27851da177e4SLinus Torvalds kfree(regs_local); 27861da177e4SLinus Torvalds return -EFAULT; 27871da177e4SLinus Torvalds } 27881da177e4SLinus Torvalds kfree(regs_local); 27891da177e4SLinus Torvalds printk("Board %d registers dumped\n", board); 27901da177e4SLinus Torvalds ia_cmds.status = 0; 27911da177e4SLinus Torvalds } 27921da177e4SLinus Torvalds break; 27931da177e4SLinus Torvalds case READ_REG: 27941da177e4SLinus Torvalds { 27951da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 27961da177e4SLinus Torvalds desc_dbg(iadev); 27971da177e4SLinus Torvalds ia_cmds.status = 0; 27981da177e4SLinus Torvalds } 27991da177e4SLinus Torvalds break; 28001da177e4SLinus Torvalds case 0x6: 28011da177e4SLinus Torvalds { 28021da177e4SLinus Torvalds ia_cmds.status = 0; 28031da177e4SLinus Torvalds printk("skb = 0x%lx\n", (long)skb_peek(&iadev->tx_backlog)); 28041da177e4SLinus Torvalds printk("rtn_q: 0x%lx\n",(long)ia_deque_rtn_q(&iadev->tx_return_q)); 28051da177e4SLinus Torvalds } 28061da177e4SLinus Torvalds break; 28071da177e4SLinus Torvalds case 0x8: 28081da177e4SLinus Torvalds { 28091da177e4SLinus Torvalds struct k_sonet_stats *stats; 28101da177e4SLinus Torvalds stats = &PRIV(_ia_dev[board])->sonet_stats; 28111da177e4SLinus Torvalds printk("section_bip: %d\n", atomic_read(&stats->section_bip)); 28121da177e4SLinus Torvalds printk("line_bip : %d\n", atomic_read(&stats->line_bip)); 28131da177e4SLinus Torvalds printk("path_bip : %d\n", atomic_read(&stats->path_bip)); 28141da177e4SLinus Torvalds printk("line_febe : %d\n", atomic_read(&stats->line_febe)); 28151da177e4SLinus Torvalds printk("path_febe : %d\n", atomic_read(&stats->path_febe)); 28161da177e4SLinus Torvalds printk("corr_hcs : %d\n", atomic_read(&stats->corr_hcs)); 28171da177e4SLinus Torvalds printk("uncorr_hcs : %d\n", atomic_read(&stats->uncorr_hcs)); 28181da177e4SLinus Torvalds printk("tx_cells : %d\n", atomic_read(&stats->tx_cells)); 28191da177e4SLinus Torvalds printk("rx_cells : %d\n", atomic_read(&stats->rx_cells)); 28201da177e4SLinus Torvalds } 28211da177e4SLinus Torvalds ia_cmds.status = 0; 28221da177e4SLinus Torvalds break; 28231da177e4SLinus Torvalds case 0x9: 28241da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 28251da177e4SLinus Torvalds for (i = 1; i <= iadev->num_rx_desc; i++) 28261da177e4SLinus Torvalds free_desc(_ia_dev[board], i); 28271da177e4SLinus Torvalds writew( ~(RX_FREEQ_EMPT | RX_EXCP_RCVD), 28281da177e4SLinus Torvalds iadev->reass_reg+REASS_MASK_REG); 28291da177e4SLinus Torvalds iadev->rxing = 1; 28301da177e4SLinus Torvalds 28311da177e4SLinus Torvalds ia_cmds.status = 0; 28321da177e4SLinus Torvalds break; 28331da177e4SLinus Torvalds 28341da177e4SLinus Torvalds case 0xb: 28351da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 28361da177e4SLinus Torvalds IaFrontEndIntr(iadev); 28371da177e4SLinus Torvalds break; 28381da177e4SLinus Torvalds case 0xa: 28391da177e4SLinus Torvalds if (!capable(CAP_NET_ADMIN)) return -EPERM; 28401da177e4SLinus Torvalds { 28411da177e4SLinus Torvalds ia_cmds.status = 0; 28421da177e4SLinus Torvalds IADebugFlag = ia_cmds.maddr; 28431da177e4SLinus Torvalds printk("New debug option loaded\n"); 28441da177e4SLinus Torvalds } 28451da177e4SLinus Torvalds break; 28461da177e4SLinus Torvalds default: 28471da177e4SLinus Torvalds ia_cmds.status = 0; 28481da177e4SLinus Torvalds break; 28491da177e4SLinus Torvalds } 28501da177e4SLinus Torvalds } 28511da177e4SLinus Torvalds break; 28521da177e4SLinus Torvalds default: 28531da177e4SLinus Torvalds break; 28541da177e4SLinus Torvalds 28551da177e4SLinus Torvalds } 28561da177e4SLinus Torvalds return 0; 28571da177e4SLinus Torvalds } 28581da177e4SLinus Torvalds 28591da177e4SLinus Torvalds static int ia_getsockopt(struct atm_vcc *vcc, int level, int optname, 28601da177e4SLinus Torvalds void __user *optval, int optlen) 28611da177e4SLinus Torvalds { 28621da177e4SLinus Torvalds IF_EVENT(printk(">ia_getsockopt\n");) 28631da177e4SLinus Torvalds return -EINVAL; 28641da177e4SLinus Torvalds } 28651da177e4SLinus Torvalds 28661da177e4SLinus Torvalds static int ia_setsockopt(struct atm_vcc *vcc, int level, int optname, 28671da177e4SLinus Torvalds void __user *optval, int optlen) 28681da177e4SLinus Torvalds { 28691da177e4SLinus Torvalds IF_EVENT(printk(">ia_setsockopt\n");) 28701da177e4SLinus Torvalds return -EINVAL; 28711da177e4SLinus Torvalds } 28721da177e4SLinus Torvalds 28731da177e4SLinus Torvalds static int ia_pkt_tx (struct atm_vcc *vcc, struct sk_buff *skb) { 28741da177e4SLinus Torvalds IADEV *iadev; 28751da177e4SLinus Torvalds struct dle *wr_ptr; 28761da177e4SLinus Torvalds struct tx_buf_desc __iomem *buf_desc_ptr; 28771da177e4SLinus Torvalds int desc; 28781da177e4SLinus Torvalds int comp_code; 28791da177e4SLinus Torvalds int total_len; 28801da177e4SLinus Torvalds struct cpcs_trailer *trailer; 28811da177e4SLinus Torvalds struct ia_vcc *iavcc; 28821da177e4SLinus Torvalds 28831da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 28841da177e4SLinus Torvalds iavcc = INPH_IA_VCC(vcc); 28851da177e4SLinus Torvalds if (!iavcc->txing) { 28861da177e4SLinus Torvalds printk("discard packet on closed VC\n"); 28871da177e4SLinus Torvalds if (vcc->pop) 28881da177e4SLinus Torvalds vcc->pop(vcc, skb); 28891da177e4SLinus Torvalds else 28901da177e4SLinus Torvalds dev_kfree_skb_any(skb); 28911da177e4SLinus Torvalds return 0; 28921da177e4SLinus Torvalds } 28931da177e4SLinus Torvalds 28941da177e4SLinus Torvalds if (skb->len > iadev->tx_buf_sz - 8) { 28951da177e4SLinus Torvalds printk("Transmit size over tx buffer size\n"); 28961da177e4SLinus Torvalds if (vcc->pop) 28971da177e4SLinus Torvalds vcc->pop(vcc, skb); 28981da177e4SLinus Torvalds else 28991da177e4SLinus Torvalds dev_kfree_skb_any(skb); 29001da177e4SLinus Torvalds return 0; 29011da177e4SLinus Torvalds } 290297928f70SAlan Cox if ((unsigned long)skb->data & 3) { 29031da177e4SLinus Torvalds printk("Misaligned SKB\n"); 29041da177e4SLinus Torvalds if (vcc->pop) 29051da177e4SLinus Torvalds vcc->pop(vcc, skb); 29061da177e4SLinus Torvalds else 29071da177e4SLinus Torvalds dev_kfree_skb_any(skb); 29081da177e4SLinus Torvalds return 0; 29091da177e4SLinus Torvalds } 29101da177e4SLinus Torvalds /* Get a descriptor number from our free descriptor queue 29111da177e4SLinus Torvalds We get the descr number from the TCQ now, since I am using 29121da177e4SLinus Torvalds the TCQ as a free buffer queue. Initially TCQ will be 29131da177e4SLinus Torvalds initialized with all the descriptors and is hence, full. 29141da177e4SLinus Torvalds */ 29151da177e4SLinus Torvalds desc = get_desc (iadev, iavcc); 29161da177e4SLinus Torvalds if (desc == 0xffff) 29171da177e4SLinus Torvalds return 1; 29181da177e4SLinus Torvalds comp_code = desc >> 13; 29191da177e4SLinus Torvalds desc &= 0x1fff; 29201da177e4SLinus Torvalds 29211da177e4SLinus Torvalds if ((desc == 0) || (desc > iadev->num_tx_desc)) 29221da177e4SLinus Torvalds { 29231da177e4SLinus Torvalds IF_ERR(printk(DEV_LABEL "invalid desc for send: %d\n", desc);) 29241da177e4SLinus Torvalds atomic_inc(&vcc->stats->tx); 29251da177e4SLinus Torvalds if (vcc->pop) 29261da177e4SLinus Torvalds vcc->pop(vcc, skb); 29271da177e4SLinus Torvalds else 29281da177e4SLinus Torvalds dev_kfree_skb_any(skb); 29291da177e4SLinus Torvalds return 0; /* return SUCCESS */ 29301da177e4SLinus Torvalds } 29311da177e4SLinus Torvalds 29321da177e4SLinus Torvalds if (comp_code) 29331da177e4SLinus Torvalds { 29341da177e4SLinus Torvalds IF_ERR(printk(DEV_LABEL "send desc:%d completion code %d error\n", 29351da177e4SLinus Torvalds desc, comp_code);) 29361da177e4SLinus Torvalds } 29371da177e4SLinus Torvalds 29381da177e4SLinus Torvalds /* remember the desc and vcc mapping */ 29391da177e4SLinus Torvalds iavcc->vc_desc_cnt++; 29401da177e4SLinus Torvalds iadev->desc_tbl[desc-1].iavcc = iavcc; 29411da177e4SLinus Torvalds iadev->desc_tbl[desc-1].txskb = skb; 29421da177e4SLinus Torvalds IA_SKB_STATE(skb) = 0; 29431da177e4SLinus Torvalds 29441da177e4SLinus Torvalds iadev->ffL.tcq_rd += 2; 29451da177e4SLinus Torvalds if (iadev->ffL.tcq_rd > iadev->ffL.tcq_ed) 29461da177e4SLinus Torvalds iadev->ffL.tcq_rd = iadev->ffL.tcq_st; 29471da177e4SLinus Torvalds writew(iadev->ffL.tcq_rd, iadev->seg_reg+TCQ_RD_PTR); 29481da177e4SLinus Torvalds 29491da177e4SLinus Torvalds /* Put the descriptor number in the packet ready queue 29501da177e4SLinus Torvalds and put the updated write pointer in the DLE field 29511da177e4SLinus Torvalds */ 29521da177e4SLinus Torvalds *(u16*)(iadev->seg_ram+iadev->ffL.prq_wr) = desc; 29531da177e4SLinus Torvalds 29541da177e4SLinus Torvalds iadev->ffL.prq_wr += 2; 29551da177e4SLinus Torvalds if (iadev->ffL.prq_wr > iadev->ffL.prq_ed) 29561da177e4SLinus Torvalds iadev->ffL.prq_wr = iadev->ffL.prq_st; 29571da177e4SLinus Torvalds 29581da177e4SLinus Torvalds /* Figure out the exact length of the packet and padding required to 29591da177e4SLinus Torvalds make it aligned on a 48 byte boundary. */ 29601da177e4SLinus Torvalds total_len = skb->len + sizeof(struct cpcs_trailer); 29611da177e4SLinus Torvalds total_len = ((total_len + 47) / 48) * 48; 29621da177e4SLinus Torvalds IF_TX(printk("ia packet len:%d padding:%d\n", total_len, total_len - skb->len);) 29631da177e4SLinus Torvalds 29641da177e4SLinus Torvalds /* Put the packet in a tx buffer */ 29651da177e4SLinus Torvalds trailer = iadev->tx_buf[desc-1].cpcs; 29661da177e4SLinus Torvalds IF_TX(printk("Sent: skb = 0x%x skb->data: 0x%x len: %d, desc: %d\n", 29671da177e4SLinus Torvalds (u32)skb, (u32)skb->data, skb->len, desc);) 29681da177e4SLinus Torvalds trailer->control = 0; 29691da177e4SLinus Torvalds /*big endian*/ 29701da177e4SLinus Torvalds trailer->length = ((skb->len & 0xff) << 8) | ((skb->len & 0xff00) >> 8); 29711da177e4SLinus Torvalds trailer->crc32 = 0; /* not needed - dummy bytes */ 29721da177e4SLinus Torvalds 29731da177e4SLinus Torvalds /* Display the packet */ 29741da177e4SLinus Torvalds IF_TXPKT(printk("Sent data: len = %d MsgNum = %d\n", 29751da177e4SLinus Torvalds skb->len, tcnter++); 29761da177e4SLinus Torvalds xdump(skb->data, skb->len, "TX: "); 29771da177e4SLinus Torvalds printk("\n");) 29781da177e4SLinus Torvalds 29791da177e4SLinus Torvalds /* Build the buffer descriptor */ 29801da177e4SLinus Torvalds buf_desc_ptr = iadev->seg_ram+TX_DESC_BASE; 29811da177e4SLinus Torvalds buf_desc_ptr += desc; /* points to the corresponding entry */ 29821da177e4SLinus Torvalds buf_desc_ptr->desc_mode = AAL5 | EOM_EN | APP_CRC32 | CMPL_INT; 29831da177e4SLinus Torvalds /* Huh ? p.115 of users guide describes this as a read-only register */ 29841da177e4SLinus Torvalds writew(TRANSMIT_DONE, iadev->seg_reg+SEG_INTR_STATUS_REG); 29851da177e4SLinus Torvalds buf_desc_ptr->vc_index = vcc->vci; 29861da177e4SLinus Torvalds buf_desc_ptr->bytes = total_len; 29871da177e4SLinus Torvalds 29881da177e4SLinus Torvalds if (vcc->qos.txtp.traffic_class == ATM_ABR) 29891da177e4SLinus Torvalds clear_lockup (vcc, iadev); 29901da177e4SLinus Torvalds 29911da177e4SLinus Torvalds /* Build the DLE structure */ 29921da177e4SLinus Torvalds wr_ptr = iadev->tx_dle_q.write; 29931da177e4SLinus Torvalds memset((caddr_t)wr_ptr, 0, sizeof(*wr_ptr)); 29941da177e4SLinus Torvalds wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data, 29951da177e4SLinus Torvalds skb->len, PCI_DMA_TODEVICE); 29961da177e4SLinus Torvalds wr_ptr->local_pkt_addr = (buf_desc_ptr->buf_start_hi << 16) | 29971da177e4SLinus Torvalds buf_desc_ptr->buf_start_lo; 29981da177e4SLinus Torvalds /* wr_ptr->bytes = swap(total_len); didn't seem to affect ?? */ 29991da177e4SLinus Torvalds wr_ptr->bytes = skb->len; 30001da177e4SLinus Torvalds 30011da177e4SLinus Torvalds /* hw bug - DLEs of 0x2d, 0x2e, 0x2f cause DMA lockup */ 30021da177e4SLinus Torvalds if ((wr_ptr->bytes >> 2) == 0xb) 30031da177e4SLinus Torvalds wr_ptr->bytes = 0x30; 30041da177e4SLinus Torvalds 30051da177e4SLinus Torvalds wr_ptr->mode = TX_DLE_PSI; 30061da177e4SLinus Torvalds wr_ptr->prq_wr_ptr_data = 0; 30071da177e4SLinus Torvalds 30081da177e4SLinus Torvalds /* end is not to be used for the DLE q */ 30091da177e4SLinus Torvalds if (++wr_ptr == iadev->tx_dle_q.end) 30101da177e4SLinus Torvalds wr_ptr = iadev->tx_dle_q.start; 30111da177e4SLinus Torvalds 30121da177e4SLinus Torvalds /* Build trailer dle */ 30131da177e4SLinus Torvalds wr_ptr->sys_pkt_addr = iadev->tx_buf[desc-1].dma_addr; 30141da177e4SLinus Torvalds wr_ptr->local_pkt_addr = ((buf_desc_ptr->buf_start_hi << 16) | 30151da177e4SLinus Torvalds buf_desc_ptr->buf_start_lo) + total_len - sizeof(struct cpcs_trailer); 30161da177e4SLinus Torvalds 30171da177e4SLinus Torvalds wr_ptr->bytes = sizeof(struct cpcs_trailer); 30181da177e4SLinus Torvalds wr_ptr->mode = DMA_INT_ENABLE; 30191da177e4SLinus Torvalds wr_ptr->prq_wr_ptr_data = iadev->ffL.prq_wr; 30201da177e4SLinus Torvalds 30211da177e4SLinus Torvalds /* end is not to be used for the DLE q */ 30221da177e4SLinus Torvalds if (++wr_ptr == iadev->tx_dle_q.end) 30231da177e4SLinus Torvalds wr_ptr = iadev->tx_dle_q.start; 30241da177e4SLinus Torvalds 30251da177e4SLinus Torvalds iadev->tx_dle_q.write = wr_ptr; 30261da177e4SLinus Torvalds ATM_DESC(skb) = vcc->vci; 30271da177e4SLinus Torvalds skb_queue_tail(&iadev->tx_dma_q, skb); 30281da177e4SLinus Torvalds 30291da177e4SLinus Torvalds atomic_inc(&vcc->stats->tx); 30301da177e4SLinus Torvalds iadev->tx_pkt_cnt++; 30311da177e4SLinus Torvalds /* Increment transaction counter */ 30321da177e4SLinus Torvalds writel(2, iadev->dma+IPHASE5575_TX_COUNTER); 30331da177e4SLinus Torvalds 30341da177e4SLinus Torvalds #if 0 30351da177e4SLinus Torvalds /* add flow control logic */ 30361da177e4SLinus Torvalds if (atomic_read(&vcc->stats->tx) % 20 == 0) { 30371da177e4SLinus Torvalds if (iavcc->vc_desc_cnt > 10) { 30381da177e4SLinus Torvalds vcc->tx_quota = vcc->tx_quota * 3 / 4; 30391da177e4SLinus Torvalds printk("Tx1: vcc->tx_quota = %d \n", (u32)vcc->tx_quota ); 30401da177e4SLinus Torvalds iavcc->flow_inc = -1; 30411da177e4SLinus Torvalds iavcc->saved_tx_quota = vcc->tx_quota; 30421da177e4SLinus Torvalds } else if ((iavcc->flow_inc < 0) && (iavcc->vc_desc_cnt < 3)) { 30431da177e4SLinus Torvalds // vcc->tx_quota = 3 * iavcc->saved_tx_quota / 4; 30441da177e4SLinus Torvalds printk("Tx2: vcc->tx_quota = %d \n", (u32)vcc->tx_quota ); 30451da177e4SLinus Torvalds iavcc->flow_inc = 0; 30461da177e4SLinus Torvalds } 30471da177e4SLinus Torvalds } 30481da177e4SLinus Torvalds #endif 30491da177e4SLinus Torvalds IF_TX(printk("ia send done\n");) 30501da177e4SLinus Torvalds return 0; 30511da177e4SLinus Torvalds } 30521da177e4SLinus Torvalds 30531da177e4SLinus Torvalds static int ia_send(struct atm_vcc *vcc, struct sk_buff *skb) 30541da177e4SLinus Torvalds { 30551da177e4SLinus Torvalds IADEV *iadev; 30561da177e4SLinus Torvalds struct ia_vcc *iavcc; 30571da177e4SLinus Torvalds unsigned long flags; 30581da177e4SLinus Torvalds 30591da177e4SLinus Torvalds iadev = INPH_IA_DEV(vcc->dev); 30601da177e4SLinus Torvalds iavcc = INPH_IA_VCC(vcc); 30611da177e4SLinus Torvalds if ((!skb)||(skb->len>(iadev->tx_buf_sz-sizeof(struct cpcs_trailer)))) 30621da177e4SLinus Torvalds { 30631da177e4SLinus Torvalds if (!skb) 30641da177e4SLinus Torvalds printk(KERN_CRIT "null skb in ia_send\n"); 30651da177e4SLinus Torvalds else dev_kfree_skb_any(skb); 30661da177e4SLinus Torvalds return -EINVAL; 30671da177e4SLinus Torvalds } 30681da177e4SLinus Torvalds spin_lock_irqsave(&iadev->tx_lock, flags); 30691da177e4SLinus Torvalds if (!test_bit(ATM_VF_READY,&vcc->flags)){ 30701da177e4SLinus Torvalds dev_kfree_skb_any(skb); 30711da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 30721da177e4SLinus Torvalds return -EINVAL; 30731da177e4SLinus Torvalds } 30741da177e4SLinus Torvalds ATM_SKB(skb)->vcc = vcc; 30751da177e4SLinus Torvalds 30761da177e4SLinus Torvalds if (skb_peek(&iadev->tx_backlog)) { 30771da177e4SLinus Torvalds skb_queue_tail(&iadev->tx_backlog, skb); 30781da177e4SLinus Torvalds } 30791da177e4SLinus Torvalds else { 30801da177e4SLinus Torvalds if (ia_pkt_tx (vcc, skb)) { 30811da177e4SLinus Torvalds skb_queue_tail(&iadev->tx_backlog, skb); 30821da177e4SLinus Torvalds } 30831da177e4SLinus Torvalds } 30841da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->tx_lock, flags); 30851da177e4SLinus Torvalds return 0; 30861da177e4SLinus Torvalds 30871da177e4SLinus Torvalds } 30881da177e4SLinus Torvalds 30891da177e4SLinus Torvalds static int ia_proc_read(struct atm_dev *dev,loff_t *pos,char *page) 30901da177e4SLinus Torvalds { 30911da177e4SLinus Torvalds int left = *pos, n; 30921da177e4SLinus Torvalds char *tmpPtr; 30931da177e4SLinus Torvalds IADEV *iadev = INPH_IA_DEV(dev); 30941da177e4SLinus Torvalds if(!left--) { 30951da177e4SLinus Torvalds if (iadev->phy_type == FE_25MBIT_PHY) { 30961da177e4SLinus Torvalds n = sprintf(page, " Board Type : Iphase5525-1KVC-128K\n"); 30971da177e4SLinus Torvalds return n; 30981da177e4SLinus Torvalds } 30991da177e4SLinus Torvalds if (iadev->phy_type == FE_DS3_PHY) 31001da177e4SLinus Torvalds n = sprintf(page, " Board Type : Iphase-ATM-DS3"); 31011da177e4SLinus Torvalds else if (iadev->phy_type == FE_E3_PHY) 31021da177e4SLinus Torvalds n = sprintf(page, " Board Type : Iphase-ATM-E3"); 31031da177e4SLinus Torvalds else if (iadev->phy_type == FE_UTP_OPTION) 31041da177e4SLinus Torvalds n = sprintf(page, " Board Type : Iphase-ATM-UTP155"); 31051da177e4SLinus Torvalds else 31061da177e4SLinus Torvalds n = sprintf(page, " Board Type : Iphase-ATM-OC3"); 31071da177e4SLinus Torvalds tmpPtr = page + n; 31081da177e4SLinus Torvalds if (iadev->pci_map_size == 0x40000) 31091da177e4SLinus Torvalds n += sprintf(tmpPtr, "-1KVC-"); 31101da177e4SLinus Torvalds else 31111da177e4SLinus Torvalds n += sprintf(tmpPtr, "-4KVC-"); 31121da177e4SLinus Torvalds tmpPtr = page + n; 31131da177e4SLinus Torvalds if ((iadev->memType & MEM_SIZE_MASK) == MEM_SIZE_1M) 31141da177e4SLinus Torvalds n += sprintf(tmpPtr, "1M \n"); 31151da177e4SLinus Torvalds else if ((iadev->memType & MEM_SIZE_MASK) == MEM_SIZE_512K) 31161da177e4SLinus Torvalds n += sprintf(tmpPtr, "512K\n"); 31171da177e4SLinus Torvalds else 31181da177e4SLinus Torvalds n += sprintf(tmpPtr, "128K\n"); 31191da177e4SLinus Torvalds return n; 31201da177e4SLinus Torvalds } 31211da177e4SLinus Torvalds if (!left) { 31221da177e4SLinus Torvalds return sprintf(page, " Number of Tx Buffer: %u\n" 31231da177e4SLinus Torvalds " Size of Tx Buffer : %u\n" 31241da177e4SLinus Torvalds " Number of Rx Buffer: %u\n" 31251da177e4SLinus Torvalds " Size of Rx Buffer : %u\n" 31261da177e4SLinus Torvalds " Packets Receiverd : %u\n" 31271da177e4SLinus Torvalds " Packets Transmitted: %u\n" 31281da177e4SLinus Torvalds " Cells Received : %u\n" 31291da177e4SLinus Torvalds " Cells Transmitted : %u\n" 31301da177e4SLinus Torvalds " Board Dropped Cells: %u\n" 31311da177e4SLinus Torvalds " Board Dropped Pkts : %u\n", 31321da177e4SLinus Torvalds iadev->num_tx_desc, iadev->tx_buf_sz, 31331da177e4SLinus Torvalds iadev->num_rx_desc, iadev->rx_buf_sz, 31341da177e4SLinus Torvalds iadev->rx_pkt_cnt, iadev->tx_pkt_cnt, 31351da177e4SLinus Torvalds iadev->rx_cell_cnt, iadev->tx_cell_cnt, 31361da177e4SLinus Torvalds iadev->drop_rxcell, iadev->drop_rxpkt); 31371da177e4SLinus Torvalds } 31381da177e4SLinus Torvalds return 0; 31391da177e4SLinus Torvalds } 31401da177e4SLinus Torvalds 31411da177e4SLinus Torvalds static const struct atmdev_ops ops = { 31421da177e4SLinus Torvalds .open = ia_open, 31431da177e4SLinus Torvalds .close = ia_close, 31441da177e4SLinus Torvalds .ioctl = ia_ioctl, 31451da177e4SLinus Torvalds .getsockopt = ia_getsockopt, 31461da177e4SLinus Torvalds .setsockopt = ia_setsockopt, 31471da177e4SLinus Torvalds .send = ia_send, 31481da177e4SLinus Torvalds .phy_put = ia_phy_put, 31491da177e4SLinus Torvalds .phy_get = ia_phy_get, 31501da177e4SLinus Torvalds .change_qos = ia_change_qos, 31511da177e4SLinus Torvalds .proc_read = ia_proc_read, 31521da177e4SLinus Torvalds .owner = THIS_MODULE, 31531da177e4SLinus Torvalds }; 31541da177e4SLinus Torvalds 31551da177e4SLinus Torvalds static int __devinit ia_init_one(struct pci_dev *pdev, 31561da177e4SLinus Torvalds const struct pci_device_id *ent) 31571da177e4SLinus Torvalds { 31581da177e4SLinus Torvalds struct atm_dev *dev; 31591da177e4SLinus Torvalds IADEV *iadev; 31601da177e4SLinus Torvalds unsigned long flags; 31611da177e4SLinus Torvalds int ret; 31621da177e4SLinus Torvalds 3163f7141761SMariusz Kozlowski iadev = kzalloc(sizeof(*iadev), GFP_KERNEL); 31641da177e4SLinus Torvalds if (!iadev) { 31651da177e4SLinus Torvalds ret = -ENOMEM; 31661da177e4SLinus Torvalds goto err_out; 31671da177e4SLinus Torvalds } 3168f7141761SMariusz Kozlowski 31691da177e4SLinus Torvalds iadev->pci = pdev; 31701da177e4SLinus Torvalds 31711da177e4SLinus Torvalds IF_INIT(printk("ia detected at bus:%d dev: %d function:%d\n", 31721da177e4SLinus Torvalds pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));) 31731da177e4SLinus Torvalds if (pci_enable_device(pdev)) { 31741da177e4SLinus Torvalds ret = -ENODEV; 31751da177e4SLinus Torvalds goto err_out_free_iadev; 31761da177e4SLinus Torvalds } 31771da177e4SLinus Torvalds dev = atm_dev_register(DEV_LABEL, &ops, -1, NULL); 31781da177e4SLinus Torvalds if (!dev) { 31791da177e4SLinus Torvalds ret = -ENOMEM; 31801da177e4SLinus Torvalds goto err_out_disable_dev; 31811da177e4SLinus Torvalds } 31821da177e4SLinus Torvalds dev->dev_data = iadev; 31831da177e4SLinus Torvalds IF_INIT(printk(DEV_LABEL "registered at (itf :%d)\n", dev->number);) 31841da177e4SLinus Torvalds IF_INIT(printk("dev_id = 0x%x iadev->LineRate = %d \n", (u32)dev, 31851da177e4SLinus Torvalds iadev->LineRate);) 31861da177e4SLinus Torvalds 3187c0ed0b60SJorge Boncompte [DTI2] pci_set_drvdata(pdev, dev); 3188c0ed0b60SJorge Boncompte [DTI2] 31891da177e4SLinus Torvalds ia_dev[iadev_count] = iadev; 31901da177e4SLinus Torvalds _ia_dev[iadev_count] = dev; 31911da177e4SLinus Torvalds iadev_count++; 31921da177e4SLinus Torvalds spin_lock_init(&iadev->misc_lock); 31931da177e4SLinus Torvalds /* First fixes first. I don't want to think about this now. */ 31941da177e4SLinus Torvalds spin_lock_irqsave(&iadev->misc_lock, flags); 31951da177e4SLinus Torvalds if (ia_init(dev) || ia_start(dev)) { 31961da177e4SLinus Torvalds IF_INIT(printk("IA register failed!\n");) 31971da177e4SLinus Torvalds iadev_count--; 31981da177e4SLinus Torvalds ia_dev[iadev_count] = NULL; 31991da177e4SLinus Torvalds _ia_dev[iadev_count] = NULL; 32001da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->misc_lock, flags); 32011da177e4SLinus Torvalds ret = -EINVAL; 32021da177e4SLinus Torvalds goto err_out_deregister_dev; 32031da177e4SLinus Torvalds } 32041da177e4SLinus Torvalds spin_unlock_irqrestore(&iadev->misc_lock, flags); 32051da177e4SLinus Torvalds IF_EVENT(printk("iadev_count = %d\n", iadev_count);) 32061da177e4SLinus Torvalds 32071da177e4SLinus Torvalds iadev->next_board = ia_boards; 32081da177e4SLinus Torvalds ia_boards = dev; 32091da177e4SLinus Torvalds 32101da177e4SLinus Torvalds return 0; 32111da177e4SLinus Torvalds 32121da177e4SLinus Torvalds err_out_deregister_dev: 32131da177e4SLinus Torvalds atm_dev_deregister(dev); 32141da177e4SLinus Torvalds err_out_disable_dev: 32151da177e4SLinus Torvalds pci_disable_device(pdev); 32161da177e4SLinus Torvalds err_out_free_iadev: 32171da177e4SLinus Torvalds kfree(iadev); 32181da177e4SLinus Torvalds err_out: 32191da177e4SLinus Torvalds return ret; 32201da177e4SLinus Torvalds } 32211da177e4SLinus Torvalds 32221da177e4SLinus Torvalds static void __devexit ia_remove_one(struct pci_dev *pdev) 32231da177e4SLinus Torvalds { 32241da177e4SLinus Torvalds struct atm_dev *dev = pci_get_drvdata(pdev); 32251da177e4SLinus Torvalds IADEV *iadev = INPH_IA_DEV(dev); 32261da177e4SLinus Torvalds 3227d6c1d704SJorge Boncompte [DTI2] /* Disable phy interrupts */ 3228d6c1d704SJorge Boncompte [DTI2] ia_phy_put(dev, ia_phy_get(dev, SUNI_RSOP_CIE) & ~(SUNI_RSOP_CIE_LOSE), 3229d6c1d704SJorge Boncompte [DTI2] SUNI_RSOP_CIE); 32301da177e4SLinus Torvalds udelay(1); 32311da177e4SLinus Torvalds 3232d6c1d704SJorge Boncompte [DTI2] if (dev->phy && dev->phy->stop) 3233d6c1d704SJorge Boncompte [DTI2] dev->phy->stop(dev); 3234d6c1d704SJorge Boncompte [DTI2] 32351da177e4SLinus Torvalds /* De-register device */ 32361da177e4SLinus Torvalds free_irq(iadev->irq, dev); 32371da177e4SLinus Torvalds iadev_count--; 32381da177e4SLinus Torvalds ia_dev[iadev_count] = NULL; 32391da177e4SLinus Torvalds _ia_dev[iadev_count] = NULL; 32401da177e4SLinus Torvalds IF_EVENT(printk("deregistering iav at (itf:%d)\n", dev->number);) 32411da177e4SLinus Torvalds atm_dev_deregister(dev); 32421da177e4SLinus Torvalds 32431da177e4SLinus Torvalds iounmap(iadev->base); 32441da177e4SLinus Torvalds pci_disable_device(pdev); 32451da177e4SLinus Torvalds 32461da177e4SLinus Torvalds ia_free_rx(iadev); 32471da177e4SLinus Torvalds ia_free_tx(iadev); 32481da177e4SLinus Torvalds 32491da177e4SLinus Torvalds kfree(iadev); 32501da177e4SLinus Torvalds } 32511da177e4SLinus Torvalds 32521da177e4SLinus Torvalds static struct pci_device_id ia_pci_tbl[] = { 32531da177e4SLinus Torvalds { PCI_VENDOR_ID_IPHASE, 0x0008, PCI_ANY_ID, PCI_ANY_ID, }, 32541da177e4SLinus Torvalds { PCI_VENDOR_ID_IPHASE, 0x0009, PCI_ANY_ID, PCI_ANY_ID, }, 32551da177e4SLinus Torvalds { 0,} 32561da177e4SLinus Torvalds }; 32571da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, ia_pci_tbl); 32581da177e4SLinus Torvalds 32591da177e4SLinus Torvalds static struct pci_driver ia_driver = { 32601da177e4SLinus Torvalds .name = DEV_LABEL, 32611da177e4SLinus Torvalds .id_table = ia_pci_tbl, 32621da177e4SLinus Torvalds .probe = ia_init_one, 32631da177e4SLinus Torvalds .remove = __devexit_p(ia_remove_one), 32641da177e4SLinus Torvalds }; 32651da177e4SLinus Torvalds 32661da177e4SLinus Torvalds static int __init ia_module_init(void) 32671da177e4SLinus Torvalds { 32681da177e4SLinus Torvalds int ret; 32691da177e4SLinus Torvalds 32701da177e4SLinus Torvalds ret = pci_register_driver(&ia_driver); 32711da177e4SLinus Torvalds if (ret >= 0) { 32721da177e4SLinus Torvalds ia_timer.expires = jiffies + 3*HZ; 32731da177e4SLinus Torvalds add_timer(&ia_timer); 32741da177e4SLinus Torvalds } else 32751da177e4SLinus Torvalds printk(KERN_ERR DEV_LABEL ": no adapter found\n"); 32761da177e4SLinus Torvalds return ret; 32771da177e4SLinus Torvalds } 32781da177e4SLinus Torvalds 32791da177e4SLinus Torvalds static void __exit ia_module_exit(void) 32801da177e4SLinus Torvalds { 32811da177e4SLinus Torvalds pci_unregister_driver(&ia_driver); 32821da177e4SLinus Torvalds 32831da177e4SLinus Torvalds del_timer(&ia_timer); 32841da177e4SLinus Torvalds } 32851da177e4SLinus Torvalds 32861da177e4SLinus Torvalds module_init(ia_module_init); 32871da177e4SLinus Torvalds module_exit(ia_module_exit); 3288