1 /* 2 3 he.c 4 5 ForeRunnerHE ATM Adapter driver for ATM on Linux 6 Copyright (C) 1999-2001 Naval Research Laboratory 7 8 This library is free software; you can redistribute it and/or 9 modify it under the terms of the GNU Lesser General Public 10 License as published by the Free Software Foundation; either 11 version 2.1 of the License, or (at your option) any later version. 12 13 This library is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 Lesser General Public License for more details. 17 18 You should have received a copy of the GNU Lesser General Public 19 License along with this library; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 22 */ 23 24 /* 25 26 he.c 27 28 ForeRunnerHE ATM Adapter driver for ATM on Linux 29 Copyright (C) 1999-2001 Naval Research Laboratory 30 31 Permission to use, copy, modify and distribute this software and its 32 documentation is hereby granted, provided that both the copyright 33 notice and this permission notice appear in all copies of the software, 34 derivative works or modified versions, and any portions thereof, and 35 that both notices appear in supporting documentation. 36 37 NRL ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION AND 38 DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER 39 RESULTING FROM THE USE OF THIS SOFTWARE. 40 41 This driver was written using the "Programmer's Reference Manual for 42 ForeRunnerHE(tm)", MANU0361-01 - Rev. A, 08/21/98. 43 44 AUTHORS: 45 chas williams <chas@cmf.nrl.navy.mil> 46 eric kinzie <ekinzie@cmf.nrl.navy.mil> 47 48 NOTES: 49 4096 supported 'connections' 50 group 0 is used for all traffic 51 interrupt queue 0 is used for all interrupts 52 aal0 support (based on work from ulrich.u.muller@nokia.com) 53 54 */ 55 56 #include <linux/module.h> 57 #include <linux/kernel.h> 58 #include <linux/skbuff.h> 59 #include <linux/pci.h> 60 #include <linux/errno.h> 61 #include <linux/types.h> 62 #include <linux/string.h> 63 #include <linux/delay.h> 64 #include <linux/init.h> 65 #include <linux/mm.h> 66 #include <linux/sched.h> 67 #include <linux/timer.h> 68 #include <linux/interrupt.h> 69 #include <linux/dma-mapping.h> 70 #include <linux/bitmap.h> 71 #include <linux/slab.h> 72 #include <asm/io.h> 73 #include <asm/byteorder.h> 74 #include <asm/uaccess.h> 75 76 #include <linux/atmdev.h> 77 #include <linux/atm.h> 78 #include <linux/sonet.h> 79 80 #undef USE_SCATTERGATHER 81 #undef USE_CHECKSUM_HW /* still confused about this */ 82 /* #undef HE_DEBUG */ 83 84 #include "he.h" 85 #include "suni.h" 86 #include <linux/atm_he.h> 87 88 #define hprintk(fmt,args...) printk(KERN_ERR DEV_LABEL "%d: " fmt, he_dev->number , ##args) 89 90 #ifdef HE_DEBUG 91 #define HPRINTK(fmt,args...) printk(KERN_DEBUG DEV_LABEL "%d: " fmt, he_dev->number , ##args) 92 #else /* !HE_DEBUG */ 93 #define HPRINTK(fmt,args...) do { } while (0) 94 #endif /* HE_DEBUG */ 95 96 /* declarations */ 97 98 static int he_open(struct atm_vcc *vcc); 99 static void he_close(struct atm_vcc *vcc); 100 static int he_send(struct atm_vcc *vcc, struct sk_buff *skb); 101 static int he_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg); 102 static irqreturn_t he_irq_handler(int irq, void *dev_id); 103 static void he_tasklet(unsigned long data); 104 static int he_proc_read(struct atm_dev *dev,loff_t *pos,char *page); 105 static int he_start(struct atm_dev *dev); 106 static void he_stop(struct he_dev *dev); 107 static void he_phy_put(struct atm_dev *, unsigned char, unsigned long); 108 static unsigned char he_phy_get(struct atm_dev *, unsigned long); 109 110 static u8 read_prom_byte(struct he_dev *he_dev, int addr); 111 112 /* globals */ 113 114 static struct he_dev *he_devs; 115 static bool disable64; 116 static short nvpibits = -1; 117 static short nvcibits = -1; 118 static short rx_skb_reserve = 16; 119 static bool irq_coalesce = true; 120 static bool sdh; 121 122 /* Read from EEPROM = 0000 0011b */ 123 static unsigned int readtab[] = { 124 CS_HIGH | CLK_HIGH, 125 CS_LOW | CLK_LOW, 126 CLK_HIGH, /* 0 */ 127 CLK_LOW, 128 CLK_HIGH, /* 0 */ 129 CLK_LOW, 130 CLK_HIGH, /* 0 */ 131 CLK_LOW, 132 CLK_HIGH, /* 0 */ 133 CLK_LOW, 134 CLK_HIGH, /* 0 */ 135 CLK_LOW, 136 CLK_HIGH, /* 0 */ 137 CLK_LOW | SI_HIGH, 138 CLK_HIGH | SI_HIGH, /* 1 */ 139 CLK_LOW | SI_HIGH, 140 CLK_HIGH | SI_HIGH /* 1 */ 141 }; 142 143 /* Clock to read from/write to the EEPROM */ 144 static unsigned int clocktab[] = { 145 CLK_LOW, 146 CLK_HIGH, 147 CLK_LOW, 148 CLK_HIGH, 149 CLK_LOW, 150 CLK_HIGH, 151 CLK_LOW, 152 CLK_HIGH, 153 CLK_LOW, 154 CLK_HIGH, 155 CLK_LOW, 156 CLK_HIGH, 157 CLK_LOW, 158 CLK_HIGH, 159 CLK_LOW, 160 CLK_HIGH, 161 CLK_LOW 162 }; 163 164 static struct atmdev_ops he_ops = 165 { 166 .open = he_open, 167 .close = he_close, 168 .ioctl = he_ioctl, 169 .send = he_send, 170 .phy_put = he_phy_put, 171 .phy_get = he_phy_get, 172 .proc_read = he_proc_read, 173 .owner = THIS_MODULE 174 }; 175 176 #define he_writel(dev, val, reg) do { writel(val, (dev)->membase + (reg)); wmb(); } while (0) 177 #define he_readl(dev, reg) readl((dev)->membase + (reg)) 178 179 /* section 2.12 connection memory access */ 180 181 static __inline__ void 182 he_writel_internal(struct he_dev *he_dev, unsigned val, unsigned addr, 183 unsigned flags) 184 { 185 he_writel(he_dev, val, CON_DAT); 186 (void) he_readl(he_dev, CON_DAT); /* flush posted writes */ 187 he_writel(he_dev, flags | CON_CTL_WRITE | CON_CTL_ADDR(addr), CON_CTL); 188 while (he_readl(he_dev, CON_CTL) & CON_CTL_BUSY); 189 } 190 191 #define he_writel_rcm(dev, val, reg) \ 192 he_writel_internal(dev, val, reg, CON_CTL_RCM) 193 194 #define he_writel_tcm(dev, val, reg) \ 195 he_writel_internal(dev, val, reg, CON_CTL_TCM) 196 197 #define he_writel_mbox(dev, val, reg) \ 198 he_writel_internal(dev, val, reg, CON_CTL_MBOX) 199 200 static unsigned 201 he_readl_internal(struct he_dev *he_dev, unsigned addr, unsigned flags) 202 { 203 he_writel(he_dev, flags | CON_CTL_READ | CON_CTL_ADDR(addr), CON_CTL); 204 while (he_readl(he_dev, CON_CTL) & CON_CTL_BUSY); 205 return he_readl(he_dev, CON_DAT); 206 } 207 208 #define he_readl_rcm(dev, reg) \ 209 he_readl_internal(dev, reg, CON_CTL_RCM) 210 211 #define he_readl_tcm(dev, reg) \ 212 he_readl_internal(dev, reg, CON_CTL_TCM) 213 214 #define he_readl_mbox(dev, reg) \ 215 he_readl_internal(dev, reg, CON_CTL_MBOX) 216 217 218 /* figure 2.2 connection id */ 219 220 #define he_mkcid(dev, vpi, vci) (((vpi << (dev)->vcibits) | vci) & 0x1fff) 221 222 /* 2.5.1 per connection transmit state registers */ 223 224 #define he_writel_tsr0(dev, val, cid) \ 225 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 0) 226 #define he_readl_tsr0(dev, cid) \ 227 he_readl_tcm(dev, CONFIG_TSRA | (cid << 3) | 0) 228 229 #define he_writel_tsr1(dev, val, cid) \ 230 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 1) 231 232 #define he_writel_tsr2(dev, val, cid) \ 233 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 2) 234 235 #define he_writel_tsr3(dev, val, cid) \ 236 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 3) 237 238 #define he_writel_tsr4(dev, val, cid) \ 239 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 4) 240 241 /* from page 2-20 242 * 243 * NOTE While the transmit connection is active, bits 23 through 0 244 * of this register must not be written by the host. Byte 245 * enables should be used during normal operation when writing 246 * the most significant byte. 247 */ 248 249 #define he_writel_tsr4_upper(dev, val, cid) \ 250 he_writel_internal(dev, val, CONFIG_TSRA | (cid << 3) | 4, \ 251 CON_CTL_TCM \ 252 | CON_BYTE_DISABLE_2 \ 253 | CON_BYTE_DISABLE_1 \ 254 | CON_BYTE_DISABLE_0) 255 256 #define he_readl_tsr4(dev, cid) \ 257 he_readl_tcm(dev, CONFIG_TSRA | (cid << 3) | 4) 258 259 #define he_writel_tsr5(dev, val, cid) \ 260 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 5) 261 262 #define he_writel_tsr6(dev, val, cid) \ 263 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 6) 264 265 #define he_writel_tsr7(dev, val, cid) \ 266 he_writel_tcm(dev, val, CONFIG_TSRA | (cid << 3) | 7) 267 268 269 #define he_writel_tsr8(dev, val, cid) \ 270 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 0) 271 272 #define he_writel_tsr9(dev, val, cid) \ 273 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 1) 274 275 #define he_writel_tsr10(dev, val, cid) \ 276 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 2) 277 278 #define he_writel_tsr11(dev, val, cid) \ 279 he_writel_tcm(dev, val, CONFIG_TSRB | (cid << 2) | 3) 280 281 282 #define he_writel_tsr12(dev, val, cid) \ 283 he_writel_tcm(dev, val, CONFIG_TSRC | (cid << 1) | 0) 284 285 #define he_writel_tsr13(dev, val, cid) \ 286 he_writel_tcm(dev, val, CONFIG_TSRC | (cid << 1) | 1) 287 288 289 #define he_writel_tsr14(dev, val, cid) \ 290 he_writel_tcm(dev, val, CONFIG_TSRD | cid) 291 292 #define he_writel_tsr14_upper(dev, val, cid) \ 293 he_writel_internal(dev, val, CONFIG_TSRD | cid, \ 294 CON_CTL_TCM \ 295 | CON_BYTE_DISABLE_2 \ 296 | CON_BYTE_DISABLE_1 \ 297 | CON_BYTE_DISABLE_0) 298 299 /* 2.7.1 per connection receive state registers */ 300 301 #define he_writel_rsr0(dev, val, cid) \ 302 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 0) 303 #define he_readl_rsr0(dev, cid) \ 304 he_readl_rcm(dev, 0x00000 | (cid << 3) | 0) 305 306 #define he_writel_rsr1(dev, val, cid) \ 307 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 1) 308 309 #define he_writel_rsr2(dev, val, cid) \ 310 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 2) 311 312 #define he_writel_rsr3(dev, val, cid) \ 313 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 3) 314 315 #define he_writel_rsr4(dev, val, cid) \ 316 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 4) 317 318 #define he_writel_rsr5(dev, val, cid) \ 319 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 5) 320 321 #define he_writel_rsr6(dev, val, cid) \ 322 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 6) 323 324 #define he_writel_rsr7(dev, val, cid) \ 325 he_writel_rcm(dev, val, 0x00000 | (cid << 3) | 7) 326 327 static __inline__ struct atm_vcc* 328 __find_vcc(struct he_dev *he_dev, unsigned cid) 329 { 330 struct hlist_head *head; 331 struct atm_vcc *vcc; 332 struct sock *s; 333 short vpi; 334 int vci; 335 336 vpi = cid >> he_dev->vcibits; 337 vci = cid & ((1 << he_dev->vcibits) - 1); 338 head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)]; 339 340 sk_for_each(s, head) { 341 vcc = atm_sk(s); 342 if (vcc->dev == he_dev->atm_dev && 343 vcc->vci == vci && vcc->vpi == vpi && 344 vcc->qos.rxtp.traffic_class != ATM_NONE) { 345 return vcc; 346 } 347 } 348 return NULL; 349 } 350 351 static int he_init_one(struct pci_dev *pci_dev, 352 const struct pci_device_id *pci_ent) 353 { 354 struct atm_dev *atm_dev = NULL; 355 struct he_dev *he_dev = NULL; 356 int err = 0; 357 358 printk(KERN_INFO "ATM he driver\n"); 359 360 if (pci_enable_device(pci_dev)) 361 return -EIO; 362 if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)) != 0) { 363 printk(KERN_WARNING "he: no suitable dma available\n"); 364 err = -EIO; 365 goto init_one_failure; 366 } 367 368 atm_dev = atm_dev_register(DEV_LABEL, &pci_dev->dev, &he_ops, -1, NULL); 369 if (!atm_dev) { 370 err = -ENODEV; 371 goto init_one_failure; 372 } 373 pci_set_drvdata(pci_dev, atm_dev); 374 375 he_dev = kzalloc(sizeof(struct he_dev), 376 GFP_KERNEL); 377 if (!he_dev) { 378 err = -ENOMEM; 379 goto init_one_failure; 380 } 381 he_dev->pci_dev = pci_dev; 382 he_dev->atm_dev = atm_dev; 383 he_dev->atm_dev->dev_data = he_dev; 384 atm_dev->dev_data = he_dev; 385 he_dev->number = atm_dev->number; 386 tasklet_init(&he_dev->tasklet, he_tasklet, (unsigned long) he_dev); 387 spin_lock_init(&he_dev->global_lock); 388 389 if (he_start(atm_dev)) { 390 he_stop(he_dev); 391 err = -ENODEV; 392 goto init_one_failure; 393 } 394 he_dev->next = NULL; 395 if (he_devs) 396 he_dev->next = he_devs; 397 he_devs = he_dev; 398 return 0; 399 400 init_one_failure: 401 if (atm_dev) 402 atm_dev_deregister(atm_dev); 403 kfree(he_dev); 404 pci_disable_device(pci_dev); 405 return err; 406 } 407 408 static void he_remove_one(struct pci_dev *pci_dev) 409 { 410 struct atm_dev *atm_dev; 411 struct he_dev *he_dev; 412 413 atm_dev = pci_get_drvdata(pci_dev); 414 he_dev = HE_DEV(atm_dev); 415 416 /* need to remove from he_devs */ 417 418 he_stop(he_dev); 419 atm_dev_deregister(atm_dev); 420 kfree(he_dev); 421 422 pci_disable_device(pci_dev); 423 } 424 425 426 static unsigned 427 rate_to_atmf(unsigned rate) /* cps to atm forum format */ 428 { 429 #define NONZERO (1 << 14) 430 431 unsigned exp = 0; 432 433 if (rate == 0) 434 return 0; 435 436 rate <<= 9; 437 while (rate > 0x3ff) { 438 ++exp; 439 rate >>= 1; 440 } 441 442 return (NONZERO | (exp << 9) | (rate & 0x1ff)); 443 } 444 445 static void he_init_rx_lbfp0(struct he_dev *he_dev) 446 { 447 unsigned i, lbm_offset, lbufd_index, lbuf_addr, lbuf_count; 448 unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf; 449 unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD; 450 unsigned row_offset = he_dev->r0_startrow * he_dev->bytes_per_row; 451 452 lbufd_index = 0; 453 lbm_offset = he_readl(he_dev, RCMLBM_BA); 454 455 he_writel(he_dev, lbufd_index, RLBF0_H); 456 457 for (i = 0, lbuf_count = 0; i < he_dev->r0_numbuffs; ++i) { 458 lbufd_index += 2; 459 lbuf_addr = (row_offset + (lbuf_count * lbuf_bufsize)) / 32; 460 461 he_writel_rcm(he_dev, lbuf_addr, lbm_offset); 462 he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1); 463 464 if (++lbuf_count == lbufs_per_row) { 465 lbuf_count = 0; 466 row_offset += he_dev->bytes_per_row; 467 } 468 lbm_offset += 4; 469 } 470 471 he_writel(he_dev, lbufd_index - 2, RLBF0_T); 472 he_writel(he_dev, he_dev->r0_numbuffs, RLBF0_C); 473 } 474 475 static void he_init_rx_lbfp1(struct he_dev *he_dev) 476 { 477 unsigned i, lbm_offset, lbufd_index, lbuf_addr, lbuf_count; 478 unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf; 479 unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD; 480 unsigned row_offset = he_dev->r1_startrow * he_dev->bytes_per_row; 481 482 lbufd_index = 1; 483 lbm_offset = he_readl(he_dev, RCMLBM_BA) + (2 * lbufd_index); 484 485 he_writel(he_dev, lbufd_index, RLBF1_H); 486 487 for (i = 0, lbuf_count = 0; i < he_dev->r1_numbuffs; ++i) { 488 lbufd_index += 2; 489 lbuf_addr = (row_offset + (lbuf_count * lbuf_bufsize)) / 32; 490 491 he_writel_rcm(he_dev, lbuf_addr, lbm_offset); 492 he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1); 493 494 if (++lbuf_count == lbufs_per_row) { 495 lbuf_count = 0; 496 row_offset += he_dev->bytes_per_row; 497 } 498 lbm_offset += 4; 499 } 500 501 he_writel(he_dev, lbufd_index - 2, RLBF1_T); 502 he_writel(he_dev, he_dev->r1_numbuffs, RLBF1_C); 503 } 504 505 static void he_init_tx_lbfp(struct he_dev *he_dev) 506 { 507 unsigned i, lbm_offset, lbufd_index, lbuf_addr, lbuf_count; 508 unsigned lbufs_per_row = he_dev->cells_per_row / he_dev->cells_per_lbuf; 509 unsigned lbuf_bufsize = he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD; 510 unsigned row_offset = he_dev->tx_startrow * he_dev->bytes_per_row; 511 512 lbufd_index = he_dev->r0_numbuffs + he_dev->r1_numbuffs; 513 lbm_offset = he_readl(he_dev, RCMLBM_BA) + (2 * lbufd_index); 514 515 he_writel(he_dev, lbufd_index, TLBF_H); 516 517 for (i = 0, lbuf_count = 0; i < he_dev->tx_numbuffs; ++i) { 518 lbufd_index += 1; 519 lbuf_addr = (row_offset + (lbuf_count * lbuf_bufsize)) / 32; 520 521 he_writel_rcm(he_dev, lbuf_addr, lbm_offset); 522 he_writel_rcm(he_dev, lbufd_index, lbm_offset + 1); 523 524 if (++lbuf_count == lbufs_per_row) { 525 lbuf_count = 0; 526 row_offset += he_dev->bytes_per_row; 527 } 528 lbm_offset += 2; 529 } 530 531 he_writel(he_dev, lbufd_index - 1, TLBF_T); 532 } 533 534 static int he_init_tpdrq(struct he_dev *he_dev) 535 { 536 he_dev->tpdrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 537 CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq), 538 &he_dev->tpdrq_phys, GFP_KERNEL); 539 if (he_dev->tpdrq_base == NULL) { 540 hprintk("failed to alloc tpdrq\n"); 541 return -ENOMEM; 542 } 543 544 he_dev->tpdrq_tail = he_dev->tpdrq_base; 545 he_dev->tpdrq_head = he_dev->tpdrq_base; 546 547 he_writel(he_dev, he_dev->tpdrq_phys, TPDRQ_B_H); 548 he_writel(he_dev, 0, TPDRQ_T); 549 he_writel(he_dev, CONFIG_TPDRQ_SIZE - 1, TPDRQ_S); 550 551 return 0; 552 } 553 554 static void he_init_cs_block(struct he_dev *he_dev) 555 { 556 unsigned clock, rate, delta; 557 int reg; 558 559 /* 5.1.7 cs block initialization */ 560 561 for (reg = 0; reg < 0x20; ++reg) 562 he_writel_mbox(he_dev, 0x0, CS_STTIM0 + reg); 563 564 /* rate grid timer reload values */ 565 566 clock = he_is622(he_dev) ? 66667000 : 50000000; 567 rate = he_dev->atm_dev->link_rate; 568 delta = rate / 16 / 2; 569 570 for (reg = 0; reg < 0x10; ++reg) { 571 /* 2.4 internal transmit function 572 * 573 * we initialize the first row in the rate grid. 574 * values are period (in clock cycles) of timer 575 */ 576 unsigned period = clock / rate; 577 578 he_writel_mbox(he_dev, period, CS_TGRLD0 + reg); 579 rate -= delta; 580 } 581 582 if (he_is622(he_dev)) { 583 /* table 5.2 (4 cells per lbuf) */ 584 he_writel_mbox(he_dev, 0x000800fa, CS_ERTHR0); 585 he_writel_mbox(he_dev, 0x000c33cb, CS_ERTHR1); 586 he_writel_mbox(he_dev, 0x0010101b, CS_ERTHR2); 587 he_writel_mbox(he_dev, 0x00181dac, CS_ERTHR3); 588 he_writel_mbox(he_dev, 0x00280600, CS_ERTHR4); 589 590 /* table 5.3, 5.4, 5.5, 5.6, 5.7 */ 591 he_writel_mbox(he_dev, 0x023de8b3, CS_ERCTL0); 592 he_writel_mbox(he_dev, 0x1801, CS_ERCTL1); 593 he_writel_mbox(he_dev, 0x68b3, CS_ERCTL2); 594 he_writel_mbox(he_dev, 0x1280, CS_ERSTAT0); 595 he_writel_mbox(he_dev, 0x68b3, CS_ERSTAT1); 596 he_writel_mbox(he_dev, 0x14585, CS_RTFWR); 597 598 he_writel_mbox(he_dev, 0x4680, CS_RTATR); 599 600 /* table 5.8 */ 601 he_writel_mbox(he_dev, 0x00159ece, CS_TFBSET); 602 he_writel_mbox(he_dev, 0x68b3, CS_WCRMAX); 603 he_writel_mbox(he_dev, 0x5eb3, CS_WCRMIN); 604 he_writel_mbox(he_dev, 0xe8b3, CS_WCRINC); 605 he_writel_mbox(he_dev, 0xdeb3, CS_WCRDEC); 606 he_writel_mbox(he_dev, 0x68b3, CS_WCRCEIL); 607 608 /* table 5.9 */ 609 he_writel_mbox(he_dev, 0x5, CS_OTPPER); 610 he_writel_mbox(he_dev, 0x14, CS_OTWPER); 611 } else { 612 /* table 5.1 (4 cells per lbuf) */ 613 he_writel_mbox(he_dev, 0x000400ea, CS_ERTHR0); 614 he_writel_mbox(he_dev, 0x00063388, CS_ERTHR1); 615 he_writel_mbox(he_dev, 0x00081018, CS_ERTHR2); 616 he_writel_mbox(he_dev, 0x000c1dac, CS_ERTHR3); 617 he_writel_mbox(he_dev, 0x0014051a, CS_ERTHR4); 618 619 /* table 5.3, 5.4, 5.5, 5.6, 5.7 */ 620 he_writel_mbox(he_dev, 0x0235e4b1, CS_ERCTL0); 621 he_writel_mbox(he_dev, 0x4701, CS_ERCTL1); 622 he_writel_mbox(he_dev, 0x64b1, CS_ERCTL2); 623 he_writel_mbox(he_dev, 0x1280, CS_ERSTAT0); 624 he_writel_mbox(he_dev, 0x64b1, CS_ERSTAT1); 625 he_writel_mbox(he_dev, 0xf424, CS_RTFWR); 626 627 he_writel_mbox(he_dev, 0x4680, CS_RTATR); 628 629 /* table 5.8 */ 630 he_writel_mbox(he_dev, 0x000563b7, CS_TFBSET); 631 he_writel_mbox(he_dev, 0x64b1, CS_WCRMAX); 632 he_writel_mbox(he_dev, 0x5ab1, CS_WCRMIN); 633 he_writel_mbox(he_dev, 0xe4b1, CS_WCRINC); 634 he_writel_mbox(he_dev, 0xdab1, CS_WCRDEC); 635 he_writel_mbox(he_dev, 0x64b1, CS_WCRCEIL); 636 637 /* table 5.9 */ 638 he_writel_mbox(he_dev, 0x6, CS_OTPPER); 639 he_writel_mbox(he_dev, 0x1e, CS_OTWPER); 640 } 641 642 he_writel_mbox(he_dev, 0x8, CS_OTTLIM); 643 644 for (reg = 0; reg < 0x8; ++reg) 645 he_writel_mbox(he_dev, 0x0, CS_HGRRT0 + reg); 646 647 } 648 649 static int he_init_cs_block_rcm(struct he_dev *he_dev) 650 { 651 unsigned (*rategrid)[16][16]; 652 unsigned rate, delta; 653 int i, j, reg; 654 655 unsigned rate_atmf, exp, man; 656 unsigned long long rate_cps; 657 int mult, buf, buf_limit = 4; 658 659 rategrid = kmalloc( sizeof(unsigned) * 16 * 16, GFP_KERNEL); 660 if (!rategrid) 661 return -ENOMEM; 662 663 /* initialize rate grid group table */ 664 665 for (reg = 0x0; reg < 0xff; ++reg) 666 he_writel_rcm(he_dev, 0x0, CONFIG_RCMABR + reg); 667 668 /* initialize rate controller groups */ 669 670 for (reg = 0x100; reg < 0x1ff; ++reg) 671 he_writel_rcm(he_dev, 0x0, CONFIG_RCMABR + reg); 672 673 /* initialize tNrm lookup table */ 674 675 /* the manual makes reference to a routine in a sample driver 676 for proper configuration; fortunately, we only need this 677 in order to support abr connection */ 678 679 /* initialize rate to group table */ 680 681 rate = he_dev->atm_dev->link_rate; 682 delta = rate / 32; 683 684 /* 685 * 2.4 transmit internal functions 686 * 687 * we construct a copy of the rate grid used by the scheduler 688 * in order to construct the rate to group table below 689 */ 690 691 for (j = 0; j < 16; j++) { 692 (*rategrid)[0][j] = rate; 693 rate -= delta; 694 } 695 696 for (i = 1; i < 16; i++) 697 for (j = 0; j < 16; j++) 698 if (i > 14) 699 (*rategrid)[i][j] = (*rategrid)[i - 1][j] / 4; 700 else 701 (*rategrid)[i][j] = (*rategrid)[i - 1][j] / 2; 702 703 /* 704 * 2.4 transmit internal function 705 * 706 * this table maps the upper 5 bits of exponent and mantissa 707 * of the atm forum representation of the rate into an index 708 * on rate grid 709 */ 710 711 rate_atmf = 0; 712 while (rate_atmf < 0x400) { 713 man = (rate_atmf & 0x1f) << 4; 714 exp = rate_atmf >> 5; 715 716 /* 717 instead of '/ 512', use '>> 9' to prevent a call 718 to divdu3 on x86 platforms 719 */ 720 rate_cps = (unsigned long long) (1 << exp) * (man + 512) >> 9; 721 722 if (rate_cps < 10) 723 rate_cps = 10; /* 2.2.1 minimum payload rate is 10 cps */ 724 725 for (i = 255; i > 0; i--) 726 if ((*rategrid)[i/16][i%16] >= rate_cps) 727 break; /* pick nearest rate instead? */ 728 729 /* 730 * each table entry is 16 bits: (rate grid index (8 bits) 731 * and a buffer limit (8 bits) 732 * there are two table entries in each 32-bit register 733 */ 734 735 #ifdef notdef 736 buf = rate_cps * he_dev->tx_numbuffs / 737 (he_dev->atm_dev->link_rate * 2); 738 #else 739 /* this is pretty, but avoids _divdu3 and is mostly correct */ 740 mult = he_dev->atm_dev->link_rate / ATM_OC3_PCR; 741 if (rate_cps > (272 * mult)) 742 buf = 4; 743 else if (rate_cps > (204 * mult)) 744 buf = 3; 745 else if (rate_cps > (136 * mult)) 746 buf = 2; 747 else if (rate_cps > (68 * mult)) 748 buf = 1; 749 else 750 buf = 0; 751 #endif 752 if (buf > buf_limit) 753 buf = buf_limit; 754 reg = (reg << 16) | ((i << 8) | buf); 755 756 #define RTGTBL_OFFSET 0x400 757 758 if (rate_atmf & 0x1) 759 he_writel_rcm(he_dev, reg, 760 CONFIG_RCMABR + RTGTBL_OFFSET + (rate_atmf >> 1)); 761 762 ++rate_atmf; 763 } 764 765 kfree(rategrid); 766 return 0; 767 } 768 769 static int he_init_group(struct he_dev *he_dev, int group) 770 { 771 struct he_buff *heb, *next; 772 dma_addr_t mapping; 773 int i; 774 775 he_writel(he_dev, 0x0, G0_RBPS_S + (group * 32)); 776 he_writel(he_dev, 0x0, G0_RBPS_T + (group * 32)); 777 he_writel(he_dev, 0x0, G0_RBPS_QI + (group * 32)); 778 he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0), 779 G0_RBPS_BS + (group * 32)); 780 781 /* bitmap table */ 782 he_dev->rbpl_table = kmalloc(BITS_TO_LONGS(RBPL_TABLE_SIZE) 783 * sizeof(unsigned long), GFP_KERNEL); 784 if (!he_dev->rbpl_table) { 785 hprintk("unable to allocate rbpl bitmap table\n"); 786 return -ENOMEM; 787 } 788 bitmap_zero(he_dev->rbpl_table, RBPL_TABLE_SIZE); 789 790 /* rbpl_virt 64-bit pointers */ 791 he_dev->rbpl_virt = kmalloc(RBPL_TABLE_SIZE 792 * sizeof(struct he_buff *), GFP_KERNEL); 793 if (!he_dev->rbpl_virt) { 794 hprintk("unable to allocate rbpl virt table\n"); 795 goto out_free_rbpl_table; 796 } 797 798 /* large buffer pool */ 799 he_dev->rbpl_pool = dma_pool_create("rbpl", &he_dev->pci_dev->dev, 800 CONFIG_RBPL_BUFSIZE, 64, 0); 801 if (he_dev->rbpl_pool == NULL) { 802 hprintk("unable to create rbpl pool\n"); 803 goto out_free_rbpl_virt; 804 } 805 806 he_dev->rbpl_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 807 CONFIG_RBPL_SIZE * sizeof(struct he_rbp), 808 &he_dev->rbpl_phys, GFP_KERNEL); 809 if (he_dev->rbpl_base == NULL) { 810 hprintk("failed to alloc rbpl_base\n"); 811 goto out_destroy_rbpl_pool; 812 } 813 814 INIT_LIST_HEAD(&he_dev->rbpl_outstanding); 815 816 for (i = 0; i < CONFIG_RBPL_SIZE; ++i) { 817 818 heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_KERNEL, &mapping); 819 if (!heb) 820 goto out_free_rbpl; 821 heb->mapping = mapping; 822 list_add(&heb->entry, &he_dev->rbpl_outstanding); 823 824 set_bit(i, he_dev->rbpl_table); 825 he_dev->rbpl_virt[i] = heb; 826 he_dev->rbpl_hint = i + 1; 827 he_dev->rbpl_base[i].idx = i << RBP_IDX_OFFSET; 828 he_dev->rbpl_base[i].phys = mapping + offsetof(struct he_buff, data); 829 } 830 he_dev->rbpl_tail = &he_dev->rbpl_base[CONFIG_RBPL_SIZE - 1]; 831 832 he_writel(he_dev, he_dev->rbpl_phys, G0_RBPL_S + (group * 32)); 833 he_writel(he_dev, RBPL_MASK(he_dev->rbpl_tail), 834 G0_RBPL_T + (group * 32)); 835 he_writel(he_dev, (CONFIG_RBPL_BUFSIZE - sizeof(struct he_buff))/4, 836 G0_RBPL_BS + (group * 32)); 837 he_writel(he_dev, 838 RBP_THRESH(CONFIG_RBPL_THRESH) | 839 RBP_QSIZE(CONFIG_RBPL_SIZE - 1) | 840 RBP_INT_ENB, 841 G0_RBPL_QI + (group * 32)); 842 843 /* rx buffer ready queue */ 844 845 he_dev->rbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 846 CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), 847 &he_dev->rbrq_phys, GFP_KERNEL); 848 if (he_dev->rbrq_base == NULL) { 849 hprintk("failed to allocate rbrq\n"); 850 goto out_free_rbpl; 851 } 852 853 he_dev->rbrq_head = he_dev->rbrq_base; 854 he_writel(he_dev, he_dev->rbrq_phys, G0_RBRQ_ST + (group * 16)); 855 he_writel(he_dev, 0, G0_RBRQ_H + (group * 16)); 856 he_writel(he_dev, 857 RBRQ_THRESH(CONFIG_RBRQ_THRESH) | RBRQ_SIZE(CONFIG_RBRQ_SIZE - 1), 858 G0_RBRQ_Q + (group * 16)); 859 if (irq_coalesce) { 860 hprintk("coalescing interrupts\n"); 861 he_writel(he_dev, RBRQ_TIME(768) | RBRQ_COUNT(7), 862 G0_RBRQ_I + (group * 16)); 863 } else 864 he_writel(he_dev, RBRQ_TIME(0) | RBRQ_COUNT(1), 865 G0_RBRQ_I + (group * 16)); 866 867 /* tx buffer ready queue */ 868 869 he_dev->tbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 870 CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 871 &he_dev->tbrq_phys, GFP_KERNEL); 872 if (he_dev->tbrq_base == NULL) { 873 hprintk("failed to allocate tbrq\n"); 874 goto out_free_rbpq_base; 875 } 876 877 he_dev->tbrq_head = he_dev->tbrq_base; 878 879 he_writel(he_dev, he_dev->tbrq_phys, G0_TBRQ_B_T + (group * 16)); 880 he_writel(he_dev, 0, G0_TBRQ_H + (group * 16)); 881 he_writel(he_dev, CONFIG_TBRQ_SIZE - 1, G0_TBRQ_S + (group * 16)); 882 he_writel(he_dev, CONFIG_TBRQ_THRESH, G0_TBRQ_THRESH + (group * 16)); 883 884 return 0; 885 886 out_free_rbpq_base: 887 dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * 888 sizeof(struct he_rbrq), he_dev->rbrq_base, 889 he_dev->rbrq_phys); 890 out_free_rbpl: 891 list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) 892 dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 893 894 dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE * 895 sizeof(struct he_rbp), he_dev->rbpl_base, 896 he_dev->rbpl_phys); 897 out_destroy_rbpl_pool: 898 dma_pool_destroy(he_dev->rbpl_pool); 899 out_free_rbpl_virt: 900 kfree(he_dev->rbpl_virt); 901 out_free_rbpl_table: 902 kfree(he_dev->rbpl_table); 903 904 return -ENOMEM; 905 } 906 907 static int he_init_irq(struct he_dev *he_dev) 908 { 909 int i; 910 911 /* 2.9.3.5 tail offset for each interrupt queue is located after the 912 end of the interrupt queue */ 913 914 he_dev->irq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 915 (CONFIG_IRQ_SIZE + 1) 916 * sizeof(struct he_irq), 917 &he_dev->irq_phys, 918 GFP_KERNEL); 919 if (he_dev->irq_base == NULL) { 920 hprintk("failed to allocate irq\n"); 921 return -ENOMEM; 922 } 923 he_dev->irq_tailoffset = (unsigned *) 924 &he_dev->irq_base[CONFIG_IRQ_SIZE]; 925 *he_dev->irq_tailoffset = 0; 926 he_dev->irq_head = he_dev->irq_base; 927 he_dev->irq_tail = he_dev->irq_base; 928 929 for (i = 0; i < CONFIG_IRQ_SIZE; ++i) 930 he_dev->irq_base[i].isw = ITYPE_INVALID; 931 932 he_writel(he_dev, he_dev->irq_phys, IRQ0_BASE); 933 he_writel(he_dev, 934 IRQ_SIZE(CONFIG_IRQ_SIZE) | IRQ_THRESH(CONFIG_IRQ_THRESH), 935 IRQ0_HEAD); 936 he_writel(he_dev, IRQ_INT_A | IRQ_TYPE_LINE, IRQ0_CNTL); 937 he_writel(he_dev, 0x0, IRQ0_DATA); 938 939 he_writel(he_dev, 0x0, IRQ1_BASE); 940 he_writel(he_dev, 0x0, IRQ1_HEAD); 941 he_writel(he_dev, 0x0, IRQ1_CNTL); 942 he_writel(he_dev, 0x0, IRQ1_DATA); 943 944 he_writel(he_dev, 0x0, IRQ2_BASE); 945 he_writel(he_dev, 0x0, IRQ2_HEAD); 946 he_writel(he_dev, 0x0, IRQ2_CNTL); 947 he_writel(he_dev, 0x0, IRQ2_DATA); 948 949 he_writel(he_dev, 0x0, IRQ3_BASE); 950 he_writel(he_dev, 0x0, IRQ3_HEAD); 951 he_writel(he_dev, 0x0, IRQ3_CNTL); 952 he_writel(he_dev, 0x0, IRQ3_DATA); 953 954 /* 2.9.3.2 interrupt queue mapping registers */ 955 956 he_writel(he_dev, 0x0, GRP_10_MAP); 957 he_writel(he_dev, 0x0, GRP_32_MAP); 958 he_writel(he_dev, 0x0, GRP_54_MAP); 959 he_writel(he_dev, 0x0, GRP_76_MAP); 960 961 if (request_irq(he_dev->pci_dev->irq, 962 he_irq_handler, IRQF_SHARED, DEV_LABEL, he_dev)) { 963 hprintk("irq %d already in use\n", he_dev->pci_dev->irq); 964 return -EINVAL; 965 } 966 967 he_dev->irq = he_dev->pci_dev->irq; 968 969 return 0; 970 } 971 972 static int he_start(struct atm_dev *dev) 973 { 974 struct he_dev *he_dev; 975 struct pci_dev *pci_dev; 976 unsigned long membase; 977 978 u16 command; 979 u32 gen_cntl_0, host_cntl, lb_swap; 980 u8 cache_size, timer; 981 982 unsigned err; 983 unsigned int status, reg; 984 int i, group; 985 986 he_dev = HE_DEV(dev); 987 pci_dev = he_dev->pci_dev; 988 989 membase = pci_resource_start(pci_dev, 0); 990 HPRINTK("membase = 0x%lx irq = %d.\n", membase, pci_dev->irq); 991 992 /* 993 * pci bus controller initialization 994 */ 995 996 /* 4.3 pci bus controller-specific initialization */ 997 if (pci_read_config_dword(pci_dev, GEN_CNTL_0, &gen_cntl_0) != 0) { 998 hprintk("can't read GEN_CNTL_0\n"); 999 return -EINVAL; 1000 } 1001 gen_cntl_0 |= (MRL_ENB | MRM_ENB | IGNORE_TIMEOUT); 1002 if (pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0) != 0) { 1003 hprintk("can't write GEN_CNTL_0.\n"); 1004 return -EINVAL; 1005 } 1006 1007 if (pci_read_config_word(pci_dev, PCI_COMMAND, &command) != 0) { 1008 hprintk("can't read PCI_COMMAND.\n"); 1009 return -EINVAL; 1010 } 1011 1012 command |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE); 1013 if (pci_write_config_word(pci_dev, PCI_COMMAND, command) != 0) { 1014 hprintk("can't enable memory.\n"); 1015 return -EINVAL; 1016 } 1017 1018 if (pci_read_config_byte(pci_dev, PCI_CACHE_LINE_SIZE, &cache_size)) { 1019 hprintk("can't read cache line size?\n"); 1020 return -EINVAL; 1021 } 1022 1023 if (cache_size < 16) { 1024 cache_size = 16; 1025 if (pci_write_config_byte(pci_dev, PCI_CACHE_LINE_SIZE, cache_size)) 1026 hprintk("can't set cache line size to %d\n", cache_size); 1027 } 1028 1029 if (pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &timer)) { 1030 hprintk("can't read latency timer?\n"); 1031 return -EINVAL; 1032 } 1033 1034 /* from table 3.9 1035 * 1036 * LAT_TIMER = 1 + AVG_LAT + BURST_SIZE/BUS_SIZE 1037 * 1038 * AVG_LAT: The average first data read/write latency [maximum 16 clock cycles] 1039 * BURST_SIZE: 1536 bytes (read) for 622, 768 bytes (read) for 155 [192 clock cycles] 1040 * 1041 */ 1042 #define LAT_TIMER 209 1043 if (timer < LAT_TIMER) { 1044 HPRINTK("latency timer was %d, setting to %d\n", timer, LAT_TIMER); 1045 timer = LAT_TIMER; 1046 if (pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, timer)) 1047 hprintk("can't set latency timer to %d\n", timer); 1048 } 1049 1050 if (!(he_dev->membase = ioremap(membase, HE_REGMAP_SIZE))) { 1051 hprintk("can't set up page mapping\n"); 1052 return -EINVAL; 1053 } 1054 1055 /* 4.4 card reset */ 1056 he_writel(he_dev, 0x0, RESET_CNTL); 1057 he_writel(he_dev, 0xff, RESET_CNTL); 1058 1059 msleep(16); /* 16 ms */ 1060 status = he_readl(he_dev, RESET_CNTL); 1061 if ((status & BOARD_RST_STATUS) == 0) { 1062 hprintk("reset failed\n"); 1063 return -EINVAL; 1064 } 1065 1066 /* 4.5 set bus width */ 1067 host_cntl = he_readl(he_dev, HOST_CNTL); 1068 if (host_cntl & PCI_BUS_SIZE64) 1069 gen_cntl_0 |= ENBL_64; 1070 else 1071 gen_cntl_0 &= ~ENBL_64; 1072 1073 if (disable64 == 1) { 1074 hprintk("disabling 64-bit pci bus transfers\n"); 1075 gen_cntl_0 &= ~ENBL_64; 1076 } 1077 1078 if (gen_cntl_0 & ENBL_64) 1079 hprintk("64-bit transfers enabled\n"); 1080 1081 pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0); 1082 1083 /* 4.7 read prom contents */ 1084 for (i = 0; i < PROD_ID_LEN; ++i) 1085 he_dev->prod_id[i] = read_prom_byte(he_dev, PROD_ID + i); 1086 1087 he_dev->media = read_prom_byte(he_dev, MEDIA); 1088 1089 for (i = 0; i < 6; ++i) 1090 dev->esi[i] = read_prom_byte(he_dev, MAC_ADDR + i); 1091 1092 hprintk("%s%s, %pM\n", he_dev->prod_id, 1093 he_dev->media & 0x40 ? "SM" : "MM", dev->esi); 1094 he_dev->atm_dev->link_rate = he_is622(he_dev) ? 1095 ATM_OC12_PCR : ATM_OC3_PCR; 1096 1097 /* 4.6 set host endianess */ 1098 lb_swap = he_readl(he_dev, LB_SWAP); 1099 if (he_is622(he_dev)) 1100 lb_swap &= ~XFER_SIZE; /* 4 cells */ 1101 else 1102 lb_swap |= XFER_SIZE; /* 8 cells */ 1103 #ifdef __BIG_ENDIAN 1104 lb_swap |= DESC_WR_SWAP | INTR_SWAP | BIG_ENDIAN_HOST; 1105 #else 1106 lb_swap &= ~(DESC_WR_SWAP | INTR_SWAP | BIG_ENDIAN_HOST | 1107 DATA_WR_SWAP | DATA_RD_SWAP | DESC_RD_SWAP); 1108 #endif /* __BIG_ENDIAN */ 1109 he_writel(he_dev, lb_swap, LB_SWAP); 1110 1111 /* 4.8 sdram controller initialization */ 1112 he_writel(he_dev, he_is622(he_dev) ? LB_64_ENB : 0x0, SDRAM_CTL); 1113 1114 /* 4.9 initialize rnum value */ 1115 lb_swap |= SWAP_RNUM_MAX(0xf); 1116 he_writel(he_dev, lb_swap, LB_SWAP); 1117 1118 /* 4.10 initialize the interrupt queues */ 1119 if ((err = he_init_irq(he_dev)) != 0) 1120 return err; 1121 1122 /* 4.11 enable pci bus controller state machines */ 1123 host_cntl |= (OUTFF_ENB | CMDFF_ENB | 1124 QUICK_RD_RETRY | QUICK_WR_RETRY | PERR_INT_ENB); 1125 he_writel(he_dev, host_cntl, HOST_CNTL); 1126 1127 gen_cntl_0 |= INT_PROC_ENBL|INIT_ENB; 1128 pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0); 1129 1130 /* 1131 * atm network controller initialization 1132 */ 1133 1134 /* 5.1.1 generic configuration state */ 1135 1136 /* 1137 * local (cell) buffer memory map 1138 * 1139 * HE155 HE622 1140 * 1141 * 0 ____________1023 bytes 0 _______________________2047 bytes 1142 * | | | | | 1143 * | utility | | rx0 | | 1144 * 5|____________| 255|___________________| u | 1145 * 6| | 256| | t | 1146 * | | | | i | 1147 * | rx0 | row | tx | l | 1148 * | | | | i | 1149 * | | 767|___________________| t | 1150 * 517|____________| 768| | y | 1151 * row 518| | | rx1 | | 1152 * | | 1023|___________________|___| 1153 * | | 1154 * | tx | 1155 * | | 1156 * | | 1157 * 1535|____________| 1158 * 1536| | 1159 * | rx1 | 1160 * 2047|____________| 1161 * 1162 */ 1163 1164 /* total 4096 connections */ 1165 he_dev->vcibits = CONFIG_DEFAULT_VCIBITS; 1166 he_dev->vpibits = CONFIG_DEFAULT_VPIBITS; 1167 1168 if (nvpibits != -1 && nvcibits != -1 && nvpibits+nvcibits != HE_MAXCIDBITS) { 1169 hprintk("nvpibits + nvcibits != %d\n", HE_MAXCIDBITS); 1170 return -ENODEV; 1171 } 1172 1173 if (nvpibits != -1) { 1174 he_dev->vpibits = nvpibits; 1175 he_dev->vcibits = HE_MAXCIDBITS - nvpibits; 1176 } 1177 1178 if (nvcibits != -1) { 1179 he_dev->vcibits = nvcibits; 1180 he_dev->vpibits = HE_MAXCIDBITS - nvcibits; 1181 } 1182 1183 1184 if (he_is622(he_dev)) { 1185 he_dev->cells_per_row = 40; 1186 he_dev->bytes_per_row = 2048; 1187 he_dev->r0_numrows = 256; 1188 he_dev->tx_numrows = 512; 1189 he_dev->r1_numrows = 256; 1190 he_dev->r0_startrow = 0; 1191 he_dev->tx_startrow = 256; 1192 he_dev->r1_startrow = 768; 1193 } else { 1194 he_dev->cells_per_row = 20; 1195 he_dev->bytes_per_row = 1024; 1196 he_dev->r0_numrows = 512; 1197 he_dev->tx_numrows = 1018; 1198 he_dev->r1_numrows = 512; 1199 he_dev->r0_startrow = 6; 1200 he_dev->tx_startrow = 518; 1201 he_dev->r1_startrow = 1536; 1202 } 1203 1204 he_dev->cells_per_lbuf = 4; 1205 he_dev->buffer_limit = 4; 1206 he_dev->r0_numbuffs = he_dev->r0_numrows * 1207 he_dev->cells_per_row / he_dev->cells_per_lbuf; 1208 if (he_dev->r0_numbuffs > 2560) 1209 he_dev->r0_numbuffs = 2560; 1210 1211 he_dev->r1_numbuffs = he_dev->r1_numrows * 1212 he_dev->cells_per_row / he_dev->cells_per_lbuf; 1213 if (he_dev->r1_numbuffs > 2560) 1214 he_dev->r1_numbuffs = 2560; 1215 1216 he_dev->tx_numbuffs = he_dev->tx_numrows * 1217 he_dev->cells_per_row / he_dev->cells_per_lbuf; 1218 if (he_dev->tx_numbuffs > 5120) 1219 he_dev->tx_numbuffs = 5120; 1220 1221 /* 5.1.2 configure hardware dependent registers */ 1222 1223 he_writel(he_dev, 1224 SLICE_X(0x2) | ARB_RNUM_MAX(0xf) | TH_PRTY(0x3) | 1225 RH_PRTY(0x3) | TL_PRTY(0x2) | RL_PRTY(0x1) | 1226 (he_is622(he_dev) ? BUS_MULTI(0x28) : BUS_MULTI(0x46)) | 1227 (he_is622(he_dev) ? NET_PREF(0x50) : NET_PREF(0x8c)), 1228 LBARB); 1229 1230 he_writel(he_dev, BANK_ON | 1231 (he_is622(he_dev) ? (REF_RATE(0x384) | WIDE_DATA) : REF_RATE(0x150)), 1232 SDRAMCON); 1233 1234 he_writel(he_dev, 1235 (he_is622(he_dev) ? RM_BANK_WAIT(1) : RM_BANK_WAIT(0)) | 1236 RM_RW_WAIT(1), RCMCONFIG); 1237 he_writel(he_dev, 1238 (he_is622(he_dev) ? TM_BANK_WAIT(2) : TM_BANK_WAIT(1)) | 1239 TM_RW_WAIT(1), TCMCONFIG); 1240 1241 he_writel(he_dev, he_dev->cells_per_lbuf * ATM_CELL_PAYLOAD, LB_CONFIG); 1242 1243 he_writel(he_dev, 1244 (he_is622(he_dev) ? UT_RD_DELAY(8) : UT_RD_DELAY(0)) | 1245 (he_is622(he_dev) ? RC_UT_MODE(0) : RC_UT_MODE(1)) | 1246 RX_VALVP(he_dev->vpibits) | 1247 RX_VALVC(he_dev->vcibits), RC_CONFIG); 1248 1249 he_writel(he_dev, DRF_THRESH(0x20) | 1250 (he_is622(he_dev) ? TX_UT_MODE(0) : TX_UT_MODE(1)) | 1251 TX_VCI_MASK(he_dev->vcibits) | 1252 LBFREE_CNT(he_dev->tx_numbuffs), TX_CONFIG); 1253 1254 he_writel(he_dev, 0x0, TXAAL5_PROTO); 1255 1256 he_writel(he_dev, PHY_INT_ENB | 1257 (he_is622(he_dev) ? PTMR_PRE(67 - 1) : PTMR_PRE(50 - 1)), 1258 RH_CONFIG); 1259 1260 /* 5.1.3 initialize connection memory */ 1261 1262 for (i = 0; i < TCM_MEM_SIZE; ++i) 1263 he_writel_tcm(he_dev, 0, i); 1264 1265 for (i = 0; i < RCM_MEM_SIZE; ++i) 1266 he_writel_rcm(he_dev, 0, i); 1267 1268 /* 1269 * transmit connection memory map 1270 * 1271 * tx memory 1272 * 0x0 ___________________ 1273 * | | 1274 * | | 1275 * | TSRa | 1276 * | | 1277 * | | 1278 * 0x8000|___________________| 1279 * | | 1280 * | TSRb | 1281 * 0xc000|___________________| 1282 * | | 1283 * | TSRc | 1284 * 0xe000|___________________| 1285 * | TSRd | 1286 * 0xf000|___________________| 1287 * | tmABR | 1288 * 0x10000|___________________| 1289 * | | 1290 * | tmTPD | 1291 * |___________________| 1292 * | | 1293 * .... 1294 * 0x1ffff|___________________| 1295 * 1296 * 1297 */ 1298 1299 he_writel(he_dev, CONFIG_TSRB, TSRB_BA); 1300 he_writel(he_dev, CONFIG_TSRC, TSRC_BA); 1301 he_writel(he_dev, CONFIG_TSRD, TSRD_BA); 1302 he_writel(he_dev, CONFIG_TMABR, TMABR_BA); 1303 he_writel(he_dev, CONFIG_TPDBA, TPD_BA); 1304 1305 1306 /* 1307 * receive connection memory map 1308 * 1309 * 0x0 ___________________ 1310 * | | 1311 * | | 1312 * | RSRa | 1313 * | | 1314 * | | 1315 * 0x8000|___________________| 1316 * | | 1317 * | rx0/1 | 1318 * | LBM | link lists of local 1319 * | tx | buffer memory 1320 * | | 1321 * 0xd000|___________________| 1322 * | | 1323 * | rmABR | 1324 * 0xe000|___________________| 1325 * | | 1326 * | RSRb | 1327 * |___________________| 1328 * | | 1329 * .... 1330 * 0xffff|___________________| 1331 */ 1332 1333 he_writel(he_dev, 0x08000, RCMLBM_BA); 1334 he_writel(he_dev, 0x0e000, RCMRSRB_BA); 1335 he_writel(he_dev, 0x0d800, RCMABR_BA); 1336 1337 /* 5.1.4 initialize local buffer free pools linked lists */ 1338 1339 he_init_rx_lbfp0(he_dev); 1340 he_init_rx_lbfp1(he_dev); 1341 1342 he_writel(he_dev, 0x0, RLBC_H); 1343 he_writel(he_dev, 0x0, RLBC_T); 1344 he_writel(he_dev, 0x0, RLBC_H2); 1345 1346 he_writel(he_dev, 512, RXTHRSH); /* 10% of r0+r1 buffers */ 1347 he_writel(he_dev, 256, LITHRSH); /* 5% of r0+r1 buffers */ 1348 1349 he_init_tx_lbfp(he_dev); 1350 1351 he_writel(he_dev, he_is622(he_dev) ? 0x104780 : 0x800, UBUFF_BA); 1352 1353 /* 5.1.5 initialize intermediate receive queues */ 1354 1355 if (he_is622(he_dev)) { 1356 he_writel(he_dev, 0x000f, G0_INMQ_S); 1357 he_writel(he_dev, 0x200f, G0_INMQ_L); 1358 1359 he_writel(he_dev, 0x001f, G1_INMQ_S); 1360 he_writel(he_dev, 0x201f, G1_INMQ_L); 1361 1362 he_writel(he_dev, 0x002f, G2_INMQ_S); 1363 he_writel(he_dev, 0x202f, G2_INMQ_L); 1364 1365 he_writel(he_dev, 0x003f, G3_INMQ_S); 1366 he_writel(he_dev, 0x203f, G3_INMQ_L); 1367 1368 he_writel(he_dev, 0x004f, G4_INMQ_S); 1369 he_writel(he_dev, 0x204f, G4_INMQ_L); 1370 1371 he_writel(he_dev, 0x005f, G5_INMQ_S); 1372 he_writel(he_dev, 0x205f, G5_INMQ_L); 1373 1374 he_writel(he_dev, 0x006f, G6_INMQ_S); 1375 he_writel(he_dev, 0x206f, G6_INMQ_L); 1376 1377 he_writel(he_dev, 0x007f, G7_INMQ_S); 1378 he_writel(he_dev, 0x207f, G7_INMQ_L); 1379 } else { 1380 he_writel(he_dev, 0x0000, G0_INMQ_S); 1381 he_writel(he_dev, 0x0008, G0_INMQ_L); 1382 1383 he_writel(he_dev, 0x0001, G1_INMQ_S); 1384 he_writel(he_dev, 0x0009, G1_INMQ_L); 1385 1386 he_writel(he_dev, 0x0002, G2_INMQ_S); 1387 he_writel(he_dev, 0x000a, G2_INMQ_L); 1388 1389 he_writel(he_dev, 0x0003, G3_INMQ_S); 1390 he_writel(he_dev, 0x000b, G3_INMQ_L); 1391 1392 he_writel(he_dev, 0x0004, G4_INMQ_S); 1393 he_writel(he_dev, 0x000c, G4_INMQ_L); 1394 1395 he_writel(he_dev, 0x0005, G5_INMQ_S); 1396 he_writel(he_dev, 0x000d, G5_INMQ_L); 1397 1398 he_writel(he_dev, 0x0006, G6_INMQ_S); 1399 he_writel(he_dev, 0x000e, G6_INMQ_L); 1400 1401 he_writel(he_dev, 0x0007, G7_INMQ_S); 1402 he_writel(he_dev, 0x000f, G7_INMQ_L); 1403 } 1404 1405 /* 5.1.6 application tunable parameters */ 1406 1407 he_writel(he_dev, 0x0, MCC); 1408 he_writel(he_dev, 0x0, OEC); 1409 he_writel(he_dev, 0x0, DCC); 1410 he_writel(he_dev, 0x0, CEC); 1411 1412 /* 5.1.7 cs block initialization */ 1413 1414 he_init_cs_block(he_dev); 1415 1416 /* 5.1.8 cs block connection memory initialization */ 1417 1418 if (he_init_cs_block_rcm(he_dev) < 0) 1419 return -ENOMEM; 1420 1421 /* 5.1.10 initialize host structures */ 1422 1423 he_init_tpdrq(he_dev); 1424 1425 he_dev->tpd_pool = dma_pool_create("tpd", &he_dev->pci_dev->dev, 1426 sizeof(struct he_tpd), TPD_ALIGNMENT, 0); 1427 if (he_dev->tpd_pool == NULL) { 1428 hprintk("unable to create tpd dma_pool\n"); 1429 return -ENOMEM; 1430 } 1431 1432 INIT_LIST_HEAD(&he_dev->outstanding_tpds); 1433 1434 if (he_init_group(he_dev, 0) != 0) 1435 return -ENOMEM; 1436 1437 for (group = 1; group < HE_NUM_GROUPS; ++group) { 1438 he_writel(he_dev, 0x0, G0_RBPS_S + (group * 32)); 1439 he_writel(he_dev, 0x0, G0_RBPS_T + (group * 32)); 1440 he_writel(he_dev, 0x0, G0_RBPS_QI + (group * 32)); 1441 he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0), 1442 G0_RBPS_BS + (group * 32)); 1443 1444 he_writel(he_dev, 0x0, G0_RBPL_S + (group * 32)); 1445 he_writel(he_dev, 0x0, G0_RBPL_T + (group * 32)); 1446 he_writel(he_dev, RBP_THRESH(0x1) | RBP_QSIZE(0x0), 1447 G0_RBPL_QI + (group * 32)); 1448 he_writel(he_dev, 0x0, G0_RBPL_BS + (group * 32)); 1449 1450 he_writel(he_dev, 0x0, G0_RBRQ_ST + (group * 16)); 1451 he_writel(he_dev, 0x0, G0_RBRQ_H + (group * 16)); 1452 he_writel(he_dev, RBRQ_THRESH(0x1) | RBRQ_SIZE(0x0), 1453 G0_RBRQ_Q + (group * 16)); 1454 he_writel(he_dev, 0x0, G0_RBRQ_I + (group * 16)); 1455 1456 he_writel(he_dev, 0x0, G0_TBRQ_B_T + (group * 16)); 1457 he_writel(he_dev, 0x0, G0_TBRQ_H + (group * 16)); 1458 he_writel(he_dev, TBRQ_THRESH(0x1), 1459 G0_TBRQ_THRESH + (group * 16)); 1460 he_writel(he_dev, 0x0, G0_TBRQ_S + (group * 16)); 1461 } 1462 1463 /* host status page */ 1464 1465 he_dev->hsp = dma_zalloc_coherent(&he_dev->pci_dev->dev, 1466 sizeof(struct he_hsp), 1467 &he_dev->hsp_phys, GFP_KERNEL); 1468 if (he_dev->hsp == NULL) { 1469 hprintk("failed to allocate host status page\n"); 1470 return -ENOMEM; 1471 } 1472 he_writel(he_dev, he_dev->hsp_phys, HSP_BA); 1473 1474 /* initialize framer */ 1475 1476 #ifdef CONFIG_ATM_HE_USE_SUNI 1477 if (he_isMM(he_dev)) 1478 suni_init(he_dev->atm_dev); 1479 if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->start) 1480 he_dev->atm_dev->phy->start(he_dev->atm_dev); 1481 #endif /* CONFIG_ATM_HE_USE_SUNI */ 1482 1483 if (sdh) { 1484 /* this really should be in suni.c but for now... */ 1485 int val; 1486 1487 val = he_phy_get(he_dev->atm_dev, SUNI_TPOP_APM); 1488 val = (val & ~SUNI_TPOP_APM_S) | (SUNI_TPOP_S_SDH << SUNI_TPOP_APM_S_SHIFT); 1489 he_phy_put(he_dev->atm_dev, val, SUNI_TPOP_APM); 1490 he_phy_put(he_dev->atm_dev, SUNI_TACP_IUCHP_CLP, SUNI_TACP_IUCHP); 1491 } 1492 1493 /* 5.1.12 enable transmit and receive */ 1494 1495 reg = he_readl_mbox(he_dev, CS_ERCTL0); 1496 reg |= TX_ENABLE|ER_ENABLE; 1497 he_writel_mbox(he_dev, reg, CS_ERCTL0); 1498 1499 reg = he_readl(he_dev, RC_CONFIG); 1500 reg |= RX_ENABLE; 1501 he_writel(he_dev, reg, RC_CONFIG); 1502 1503 for (i = 0; i < HE_NUM_CS_STPER; ++i) { 1504 he_dev->cs_stper[i].inuse = 0; 1505 he_dev->cs_stper[i].pcr = -1; 1506 } 1507 he_dev->total_bw = 0; 1508 1509 1510 /* atm linux initialization */ 1511 1512 he_dev->atm_dev->ci_range.vpi_bits = he_dev->vpibits; 1513 he_dev->atm_dev->ci_range.vci_bits = he_dev->vcibits; 1514 1515 he_dev->irq_peak = 0; 1516 he_dev->rbrq_peak = 0; 1517 he_dev->rbpl_peak = 0; 1518 he_dev->tbrq_peak = 0; 1519 1520 HPRINTK("hell bent for leather!\n"); 1521 1522 return 0; 1523 } 1524 1525 static void 1526 he_stop(struct he_dev *he_dev) 1527 { 1528 struct he_buff *heb, *next; 1529 struct pci_dev *pci_dev; 1530 u32 gen_cntl_0, reg; 1531 u16 command; 1532 1533 pci_dev = he_dev->pci_dev; 1534 1535 /* disable interrupts */ 1536 1537 if (he_dev->membase) { 1538 pci_read_config_dword(pci_dev, GEN_CNTL_0, &gen_cntl_0); 1539 gen_cntl_0 &= ~(INT_PROC_ENBL | INIT_ENB); 1540 pci_write_config_dword(pci_dev, GEN_CNTL_0, gen_cntl_0); 1541 1542 tasklet_disable(&he_dev->tasklet); 1543 1544 /* disable recv and transmit */ 1545 1546 reg = he_readl_mbox(he_dev, CS_ERCTL0); 1547 reg &= ~(TX_ENABLE|ER_ENABLE); 1548 he_writel_mbox(he_dev, reg, CS_ERCTL0); 1549 1550 reg = he_readl(he_dev, RC_CONFIG); 1551 reg &= ~(RX_ENABLE); 1552 he_writel(he_dev, reg, RC_CONFIG); 1553 } 1554 1555 #ifdef CONFIG_ATM_HE_USE_SUNI 1556 if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->stop) 1557 he_dev->atm_dev->phy->stop(he_dev->atm_dev); 1558 #endif /* CONFIG_ATM_HE_USE_SUNI */ 1559 1560 if (he_dev->irq) 1561 free_irq(he_dev->irq, he_dev); 1562 1563 if (he_dev->irq_base) 1564 dma_free_coherent(&he_dev->pci_dev->dev, (CONFIG_IRQ_SIZE + 1) 1565 * sizeof(struct he_irq), he_dev->irq_base, he_dev->irq_phys); 1566 1567 if (he_dev->hsp) 1568 dma_free_coherent(&he_dev->pci_dev->dev, sizeof(struct he_hsp), 1569 he_dev->hsp, he_dev->hsp_phys); 1570 1571 if (he_dev->rbpl_base) { 1572 list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) 1573 dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1574 1575 dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE 1576 * sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys); 1577 } 1578 1579 kfree(he_dev->rbpl_virt); 1580 kfree(he_dev->rbpl_table); 1581 dma_pool_destroy(he_dev->rbpl_pool); 1582 1583 if (he_dev->rbrq_base) 1584 dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), 1585 he_dev->rbrq_base, he_dev->rbrq_phys); 1586 1587 if (he_dev->tbrq_base) 1588 dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 1589 he_dev->tbrq_base, he_dev->tbrq_phys); 1590 1591 if (he_dev->tpdrq_base) 1592 dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 1593 he_dev->tpdrq_base, he_dev->tpdrq_phys); 1594 1595 dma_pool_destroy(he_dev->tpd_pool); 1596 1597 if (he_dev->pci_dev) { 1598 pci_read_config_word(he_dev->pci_dev, PCI_COMMAND, &command); 1599 command &= ~(PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER); 1600 pci_write_config_word(he_dev->pci_dev, PCI_COMMAND, command); 1601 } 1602 1603 if (he_dev->membase) 1604 iounmap(he_dev->membase); 1605 } 1606 1607 static struct he_tpd * 1608 __alloc_tpd(struct he_dev *he_dev) 1609 { 1610 struct he_tpd *tpd; 1611 dma_addr_t mapping; 1612 1613 tpd = dma_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC, &mapping); 1614 if (tpd == NULL) 1615 return NULL; 1616 1617 tpd->status = TPD_ADDR(mapping); 1618 tpd->reserved = 0; 1619 tpd->iovec[0].addr = 0; tpd->iovec[0].len = 0; 1620 tpd->iovec[1].addr = 0; tpd->iovec[1].len = 0; 1621 tpd->iovec[2].addr = 0; tpd->iovec[2].len = 0; 1622 1623 return tpd; 1624 } 1625 1626 #define AAL5_LEN(buf,len) \ 1627 ((((unsigned char *)(buf))[(len)-6] << 8) | \ 1628 (((unsigned char *)(buf))[(len)-5])) 1629 1630 /* 2.10.1.2 receive 1631 * 1632 * aal5 packets can optionally return the tcp checksum in the lower 1633 * 16 bits of the crc (RSR0_TCP_CKSUM) 1634 */ 1635 1636 #define TCP_CKSUM(buf,len) \ 1637 ((((unsigned char *)(buf))[(len)-2] << 8) | \ 1638 (((unsigned char *)(buf))[(len-1)])) 1639 1640 static int 1641 he_service_rbrq(struct he_dev *he_dev, int group) 1642 { 1643 struct he_rbrq *rbrq_tail = (struct he_rbrq *) 1644 ((unsigned long)he_dev->rbrq_base | 1645 he_dev->hsp->group[group].rbrq_tail); 1646 unsigned cid, lastcid = -1; 1647 struct sk_buff *skb; 1648 struct atm_vcc *vcc = NULL; 1649 struct he_vcc *he_vcc; 1650 struct he_buff *heb, *next; 1651 int i; 1652 int pdus_assembled = 0; 1653 int updated = 0; 1654 1655 read_lock(&vcc_sklist_lock); 1656 while (he_dev->rbrq_head != rbrq_tail) { 1657 ++updated; 1658 1659 HPRINTK("%p rbrq%d 0x%x len=%d cid=0x%x %s%s%s%s%s%s\n", 1660 he_dev->rbrq_head, group, 1661 RBRQ_ADDR(he_dev->rbrq_head), 1662 RBRQ_BUFLEN(he_dev->rbrq_head), 1663 RBRQ_CID(he_dev->rbrq_head), 1664 RBRQ_CRC_ERR(he_dev->rbrq_head) ? " CRC_ERR" : "", 1665 RBRQ_LEN_ERR(he_dev->rbrq_head) ? " LEN_ERR" : "", 1666 RBRQ_END_PDU(he_dev->rbrq_head) ? " END_PDU" : "", 1667 RBRQ_AAL5_PROT(he_dev->rbrq_head) ? " AAL5_PROT" : "", 1668 RBRQ_CON_CLOSED(he_dev->rbrq_head) ? " CON_CLOSED" : "", 1669 RBRQ_HBUF_ERR(he_dev->rbrq_head) ? " HBUF_ERR" : ""); 1670 1671 i = RBRQ_ADDR(he_dev->rbrq_head) >> RBP_IDX_OFFSET; 1672 heb = he_dev->rbpl_virt[i]; 1673 1674 cid = RBRQ_CID(he_dev->rbrq_head); 1675 if (cid != lastcid) 1676 vcc = __find_vcc(he_dev, cid); 1677 lastcid = cid; 1678 1679 if (vcc == NULL || (he_vcc = HE_VCC(vcc)) == NULL) { 1680 hprintk("vcc/he_vcc == NULL (cid 0x%x)\n", cid); 1681 if (!RBRQ_HBUF_ERR(he_dev->rbrq_head)) { 1682 clear_bit(i, he_dev->rbpl_table); 1683 list_del(&heb->entry); 1684 dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1685 } 1686 1687 goto next_rbrq_entry; 1688 } 1689 1690 if (RBRQ_HBUF_ERR(he_dev->rbrq_head)) { 1691 hprintk("HBUF_ERR! (cid 0x%x)\n", cid); 1692 atomic_inc(&vcc->stats->rx_drop); 1693 goto return_host_buffers; 1694 } 1695 1696 heb->len = RBRQ_BUFLEN(he_dev->rbrq_head) * 4; 1697 clear_bit(i, he_dev->rbpl_table); 1698 list_move_tail(&heb->entry, &he_vcc->buffers); 1699 he_vcc->pdu_len += heb->len; 1700 1701 if (RBRQ_CON_CLOSED(he_dev->rbrq_head)) { 1702 lastcid = -1; 1703 HPRINTK("wake_up rx_waitq (cid 0x%x)\n", cid); 1704 wake_up(&he_vcc->rx_waitq); 1705 goto return_host_buffers; 1706 } 1707 1708 if (!RBRQ_END_PDU(he_dev->rbrq_head)) 1709 goto next_rbrq_entry; 1710 1711 if (RBRQ_LEN_ERR(he_dev->rbrq_head) 1712 || RBRQ_CRC_ERR(he_dev->rbrq_head)) { 1713 HPRINTK("%s%s (%d.%d)\n", 1714 RBRQ_CRC_ERR(he_dev->rbrq_head) 1715 ? "CRC_ERR " : "", 1716 RBRQ_LEN_ERR(he_dev->rbrq_head) 1717 ? "LEN_ERR" : "", 1718 vcc->vpi, vcc->vci); 1719 atomic_inc(&vcc->stats->rx_err); 1720 goto return_host_buffers; 1721 } 1722 1723 skb = atm_alloc_charge(vcc, he_vcc->pdu_len + rx_skb_reserve, 1724 GFP_ATOMIC); 1725 if (!skb) { 1726 HPRINTK("charge failed (%d.%d)\n", vcc->vpi, vcc->vci); 1727 goto return_host_buffers; 1728 } 1729 1730 if (rx_skb_reserve > 0) 1731 skb_reserve(skb, rx_skb_reserve); 1732 1733 __net_timestamp(skb); 1734 1735 list_for_each_entry(heb, &he_vcc->buffers, entry) 1736 memcpy(skb_put(skb, heb->len), &heb->data, heb->len); 1737 1738 switch (vcc->qos.aal) { 1739 case ATM_AAL0: 1740 /* 2.10.1.5 raw cell receive */ 1741 skb->len = ATM_AAL0_SDU; 1742 skb_set_tail_pointer(skb, skb->len); 1743 break; 1744 case ATM_AAL5: 1745 /* 2.10.1.2 aal5 receive */ 1746 1747 skb->len = AAL5_LEN(skb->data, he_vcc->pdu_len); 1748 skb_set_tail_pointer(skb, skb->len); 1749 #ifdef USE_CHECKSUM_HW 1750 if (vcc->vpi == 0 && vcc->vci >= ATM_NOT_RSV_VCI) { 1751 skb->ip_summed = CHECKSUM_COMPLETE; 1752 skb->csum = TCP_CKSUM(skb->data, 1753 he_vcc->pdu_len); 1754 } 1755 #endif 1756 break; 1757 } 1758 1759 #ifdef should_never_happen 1760 if (skb->len > vcc->qos.rxtp.max_sdu) 1761 hprintk("pdu_len (%d) > vcc->qos.rxtp.max_sdu (%d)! cid 0x%x\n", skb->len, vcc->qos.rxtp.max_sdu, cid); 1762 #endif 1763 1764 #ifdef notdef 1765 ATM_SKB(skb)->vcc = vcc; 1766 #endif 1767 spin_unlock(&he_dev->global_lock); 1768 vcc->push(vcc, skb); 1769 spin_lock(&he_dev->global_lock); 1770 1771 atomic_inc(&vcc->stats->rx); 1772 1773 return_host_buffers: 1774 ++pdus_assembled; 1775 1776 list_for_each_entry_safe(heb, next, &he_vcc->buffers, entry) 1777 dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1778 INIT_LIST_HEAD(&he_vcc->buffers); 1779 he_vcc->pdu_len = 0; 1780 1781 next_rbrq_entry: 1782 he_dev->rbrq_head = (struct he_rbrq *) 1783 ((unsigned long) he_dev->rbrq_base | 1784 RBRQ_MASK(he_dev->rbrq_head + 1)); 1785 1786 } 1787 read_unlock(&vcc_sklist_lock); 1788 1789 if (updated) { 1790 if (updated > he_dev->rbrq_peak) 1791 he_dev->rbrq_peak = updated; 1792 1793 he_writel(he_dev, RBRQ_MASK(he_dev->rbrq_head), 1794 G0_RBRQ_H + (group * 16)); 1795 } 1796 1797 return pdus_assembled; 1798 } 1799 1800 static void 1801 he_service_tbrq(struct he_dev *he_dev, int group) 1802 { 1803 struct he_tbrq *tbrq_tail = (struct he_tbrq *) 1804 ((unsigned long)he_dev->tbrq_base | 1805 he_dev->hsp->group[group].tbrq_tail); 1806 struct he_tpd *tpd; 1807 int slot, updated = 0; 1808 struct he_tpd *__tpd; 1809 1810 /* 2.1.6 transmit buffer return queue */ 1811 1812 while (he_dev->tbrq_head != tbrq_tail) { 1813 ++updated; 1814 1815 HPRINTK("tbrq%d 0x%x%s%s\n", 1816 group, 1817 TBRQ_TPD(he_dev->tbrq_head), 1818 TBRQ_EOS(he_dev->tbrq_head) ? " EOS" : "", 1819 TBRQ_MULTIPLE(he_dev->tbrq_head) ? " MULTIPLE" : ""); 1820 tpd = NULL; 1821 list_for_each_entry(__tpd, &he_dev->outstanding_tpds, entry) { 1822 if (TPD_ADDR(__tpd->status) == TBRQ_TPD(he_dev->tbrq_head)) { 1823 tpd = __tpd; 1824 list_del(&__tpd->entry); 1825 break; 1826 } 1827 } 1828 1829 if (tpd == NULL) { 1830 hprintk("unable to locate tpd for dma buffer %x\n", 1831 TBRQ_TPD(he_dev->tbrq_head)); 1832 goto next_tbrq_entry; 1833 } 1834 1835 if (TBRQ_EOS(he_dev->tbrq_head)) { 1836 HPRINTK("wake_up(tx_waitq) cid 0x%x\n", 1837 he_mkcid(he_dev, tpd->vcc->vpi, tpd->vcc->vci)); 1838 if (tpd->vcc) 1839 wake_up(&HE_VCC(tpd->vcc)->tx_waitq); 1840 1841 goto next_tbrq_entry; 1842 } 1843 1844 for (slot = 0; slot < TPD_MAXIOV; ++slot) { 1845 if (tpd->iovec[slot].addr) 1846 dma_unmap_single(&he_dev->pci_dev->dev, 1847 tpd->iovec[slot].addr, 1848 tpd->iovec[slot].len & TPD_LEN_MASK, 1849 DMA_TO_DEVICE); 1850 if (tpd->iovec[slot].len & TPD_LST) 1851 break; 1852 1853 } 1854 1855 if (tpd->skb) { /* && !TBRQ_MULTIPLE(he_dev->tbrq_head) */ 1856 if (tpd->vcc && tpd->vcc->pop) 1857 tpd->vcc->pop(tpd->vcc, tpd->skb); 1858 else 1859 dev_kfree_skb_any(tpd->skb); 1860 } 1861 1862 next_tbrq_entry: 1863 if (tpd) 1864 dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); 1865 he_dev->tbrq_head = (struct he_tbrq *) 1866 ((unsigned long) he_dev->tbrq_base | 1867 TBRQ_MASK(he_dev->tbrq_head + 1)); 1868 } 1869 1870 if (updated) { 1871 if (updated > he_dev->tbrq_peak) 1872 he_dev->tbrq_peak = updated; 1873 1874 he_writel(he_dev, TBRQ_MASK(he_dev->tbrq_head), 1875 G0_TBRQ_H + (group * 16)); 1876 } 1877 } 1878 1879 static void 1880 he_service_rbpl(struct he_dev *he_dev, int group) 1881 { 1882 struct he_rbp *new_tail; 1883 struct he_rbp *rbpl_head; 1884 struct he_buff *heb; 1885 dma_addr_t mapping; 1886 int i; 1887 int moved = 0; 1888 1889 rbpl_head = (struct he_rbp *) ((unsigned long)he_dev->rbpl_base | 1890 RBPL_MASK(he_readl(he_dev, G0_RBPL_S))); 1891 1892 for (;;) { 1893 new_tail = (struct he_rbp *) ((unsigned long)he_dev->rbpl_base | 1894 RBPL_MASK(he_dev->rbpl_tail+1)); 1895 1896 /* table 3.42 -- rbpl_tail should never be set to rbpl_head */ 1897 if (new_tail == rbpl_head) 1898 break; 1899 1900 i = find_next_zero_bit(he_dev->rbpl_table, RBPL_TABLE_SIZE, he_dev->rbpl_hint); 1901 if (i > (RBPL_TABLE_SIZE - 1)) { 1902 i = find_first_zero_bit(he_dev->rbpl_table, RBPL_TABLE_SIZE); 1903 if (i > (RBPL_TABLE_SIZE - 1)) 1904 break; 1905 } 1906 he_dev->rbpl_hint = i + 1; 1907 1908 heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_ATOMIC, &mapping); 1909 if (!heb) 1910 break; 1911 heb->mapping = mapping; 1912 list_add(&heb->entry, &he_dev->rbpl_outstanding); 1913 he_dev->rbpl_virt[i] = heb; 1914 set_bit(i, he_dev->rbpl_table); 1915 new_tail->idx = i << RBP_IDX_OFFSET; 1916 new_tail->phys = mapping + offsetof(struct he_buff, data); 1917 1918 he_dev->rbpl_tail = new_tail; 1919 ++moved; 1920 } 1921 1922 if (moved) 1923 he_writel(he_dev, RBPL_MASK(he_dev->rbpl_tail), G0_RBPL_T); 1924 } 1925 1926 static void 1927 he_tasklet(unsigned long data) 1928 { 1929 unsigned long flags; 1930 struct he_dev *he_dev = (struct he_dev *) data; 1931 int group, type; 1932 int updated = 0; 1933 1934 HPRINTK("tasklet (0x%lx)\n", data); 1935 spin_lock_irqsave(&he_dev->global_lock, flags); 1936 1937 while (he_dev->irq_head != he_dev->irq_tail) { 1938 ++updated; 1939 1940 type = ITYPE_TYPE(he_dev->irq_head->isw); 1941 group = ITYPE_GROUP(he_dev->irq_head->isw); 1942 1943 switch (type) { 1944 case ITYPE_RBRQ_THRESH: 1945 HPRINTK("rbrq%d threshold\n", group); 1946 /* fall through */ 1947 case ITYPE_RBRQ_TIMER: 1948 if (he_service_rbrq(he_dev, group)) 1949 he_service_rbpl(he_dev, group); 1950 break; 1951 case ITYPE_TBRQ_THRESH: 1952 HPRINTK("tbrq%d threshold\n", group); 1953 /* fall through */ 1954 case ITYPE_TPD_COMPLETE: 1955 he_service_tbrq(he_dev, group); 1956 break; 1957 case ITYPE_RBPL_THRESH: 1958 he_service_rbpl(he_dev, group); 1959 break; 1960 case ITYPE_RBPS_THRESH: 1961 /* shouldn't happen unless small buffers enabled */ 1962 break; 1963 case ITYPE_PHY: 1964 HPRINTK("phy interrupt\n"); 1965 #ifdef CONFIG_ATM_HE_USE_SUNI 1966 spin_unlock_irqrestore(&he_dev->global_lock, flags); 1967 if (he_dev->atm_dev->phy && he_dev->atm_dev->phy->interrupt) 1968 he_dev->atm_dev->phy->interrupt(he_dev->atm_dev); 1969 spin_lock_irqsave(&he_dev->global_lock, flags); 1970 #endif 1971 break; 1972 case ITYPE_OTHER: 1973 switch (type|group) { 1974 case ITYPE_PARITY: 1975 hprintk("parity error\n"); 1976 break; 1977 case ITYPE_ABORT: 1978 hprintk("abort 0x%x\n", he_readl(he_dev, ABORT_ADDR)); 1979 break; 1980 } 1981 break; 1982 case ITYPE_TYPE(ITYPE_INVALID): 1983 /* see 8.1.1 -- check all queues */ 1984 1985 HPRINTK("isw not updated 0x%x\n", he_dev->irq_head->isw); 1986 1987 he_service_rbrq(he_dev, 0); 1988 he_service_rbpl(he_dev, 0); 1989 he_service_tbrq(he_dev, 0); 1990 break; 1991 default: 1992 hprintk("bad isw 0x%x?\n", he_dev->irq_head->isw); 1993 } 1994 1995 he_dev->irq_head->isw = ITYPE_INVALID; 1996 1997 he_dev->irq_head = (struct he_irq *) NEXT_ENTRY(he_dev->irq_base, he_dev->irq_head, IRQ_MASK); 1998 } 1999 2000 if (updated) { 2001 if (updated > he_dev->irq_peak) 2002 he_dev->irq_peak = updated; 2003 2004 he_writel(he_dev, 2005 IRQ_SIZE(CONFIG_IRQ_SIZE) | 2006 IRQ_THRESH(CONFIG_IRQ_THRESH) | 2007 IRQ_TAIL(he_dev->irq_tail), IRQ0_HEAD); 2008 (void) he_readl(he_dev, INT_FIFO); /* 8.1.2 controller errata; flush posted writes */ 2009 } 2010 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2011 } 2012 2013 static irqreturn_t 2014 he_irq_handler(int irq, void *dev_id) 2015 { 2016 unsigned long flags; 2017 struct he_dev *he_dev = (struct he_dev * )dev_id; 2018 int handled = 0; 2019 2020 if (he_dev == NULL) 2021 return IRQ_NONE; 2022 2023 spin_lock_irqsave(&he_dev->global_lock, flags); 2024 2025 he_dev->irq_tail = (struct he_irq *) (((unsigned long)he_dev->irq_base) | 2026 (*he_dev->irq_tailoffset << 2)); 2027 2028 if (he_dev->irq_tail == he_dev->irq_head) { 2029 HPRINTK("tailoffset not updated?\n"); 2030 he_dev->irq_tail = (struct he_irq *) ((unsigned long)he_dev->irq_base | 2031 ((he_readl(he_dev, IRQ0_BASE) & IRQ_MASK) << 2)); 2032 (void) he_readl(he_dev, INT_FIFO); /* 8.1.2 controller errata */ 2033 } 2034 2035 #ifdef DEBUG 2036 if (he_dev->irq_head == he_dev->irq_tail /* && !IRQ_PENDING */) 2037 hprintk("spurious (or shared) interrupt?\n"); 2038 #endif 2039 2040 if (he_dev->irq_head != he_dev->irq_tail) { 2041 handled = 1; 2042 tasklet_schedule(&he_dev->tasklet); 2043 he_writel(he_dev, INT_CLEAR_A, INT_FIFO); /* clear interrupt */ 2044 (void) he_readl(he_dev, INT_FIFO); /* flush posted writes */ 2045 } 2046 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2047 return IRQ_RETVAL(handled); 2048 2049 } 2050 2051 static __inline__ void 2052 __enqueue_tpd(struct he_dev *he_dev, struct he_tpd *tpd, unsigned cid) 2053 { 2054 struct he_tpdrq *new_tail; 2055 2056 HPRINTK("tpdrq %p cid 0x%x -> tpdrq_tail %p\n", 2057 tpd, cid, he_dev->tpdrq_tail); 2058 2059 /* new_tail = he_dev->tpdrq_tail; */ 2060 new_tail = (struct he_tpdrq *) ((unsigned long) he_dev->tpdrq_base | 2061 TPDRQ_MASK(he_dev->tpdrq_tail+1)); 2062 2063 /* 2064 * check to see if we are about to set the tail == head 2065 * if true, update the head pointer from the adapter 2066 * to see if this is really the case (reading the queue 2067 * head for every enqueue would be unnecessarily slow) 2068 */ 2069 2070 if (new_tail == he_dev->tpdrq_head) { 2071 he_dev->tpdrq_head = (struct he_tpdrq *) 2072 (((unsigned long)he_dev->tpdrq_base) | 2073 TPDRQ_MASK(he_readl(he_dev, TPDRQ_B_H))); 2074 2075 if (new_tail == he_dev->tpdrq_head) { 2076 int slot; 2077 2078 hprintk("tpdrq full (cid 0x%x)\n", cid); 2079 /* 2080 * FIXME 2081 * push tpd onto a transmit backlog queue 2082 * after service_tbrq, service the backlog 2083 * for now, we just drop the pdu 2084 */ 2085 for (slot = 0; slot < TPD_MAXIOV; ++slot) { 2086 if (tpd->iovec[slot].addr) 2087 dma_unmap_single(&he_dev->pci_dev->dev, 2088 tpd->iovec[slot].addr, 2089 tpd->iovec[slot].len & TPD_LEN_MASK, 2090 DMA_TO_DEVICE); 2091 } 2092 if (tpd->skb) { 2093 if (tpd->vcc->pop) 2094 tpd->vcc->pop(tpd->vcc, tpd->skb); 2095 else 2096 dev_kfree_skb_any(tpd->skb); 2097 atomic_inc(&tpd->vcc->stats->tx_err); 2098 } 2099 dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); 2100 return; 2101 } 2102 } 2103 2104 /* 2.1.5 transmit packet descriptor ready queue */ 2105 list_add_tail(&tpd->entry, &he_dev->outstanding_tpds); 2106 he_dev->tpdrq_tail->tpd = TPD_ADDR(tpd->status); 2107 he_dev->tpdrq_tail->cid = cid; 2108 wmb(); 2109 2110 he_dev->tpdrq_tail = new_tail; 2111 2112 he_writel(he_dev, TPDRQ_MASK(he_dev->tpdrq_tail), TPDRQ_T); 2113 (void) he_readl(he_dev, TPDRQ_T); /* flush posted writes */ 2114 } 2115 2116 static int 2117 he_open(struct atm_vcc *vcc) 2118 { 2119 unsigned long flags; 2120 struct he_dev *he_dev = HE_DEV(vcc->dev); 2121 struct he_vcc *he_vcc; 2122 int err = 0; 2123 unsigned cid, rsr0, rsr1, rsr4, tsr0, tsr0_aal, tsr4, period, reg, clock; 2124 short vpi = vcc->vpi; 2125 int vci = vcc->vci; 2126 2127 if (vci == ATM_VCI_UNSPEC || vpi == ATM_VPI_UNSPEC) 2128 return 0; 2129 2130 HPRINTK("open vcc %p %d.%d\n", vcc, vpi, vci); 2131 2132 set_bit(ATM_VF_ADDR, &vcc->flags); 2133 2134 cid = he_mkcid(he_dev, vpi, vci); 2135 2136 he_vcc = kmalloc(sizeof(struct he_vcc), GFP_ATOMIC); 2137 if (he_vcc == NULL) { 2138 hprintk("unable to allocate he_vcc during open\n"); 2139 return -ENOMEM; 2140 } 2141 2142 INIT_LIST_HEAD(&he_vcc->buffers); 2143 he_vcc->pdu_len = 0; 2144 he_vcc->rc_index = -1; 2145 2146 init_waitqueue_head(&he_vcc->rx_waitq); 2147 init_waitqueue_head(&he_vcc->tx_waitq); 2148 2149 vcc->dev_data = he_vcc; 2150 2151 if (vcc->qos.txtp.traffic_class != ATM_NONE) { 2152 int pcr_goal; 2153 2154 pcr_goal = atm_pcr_goal(&vcc->qos.txtp); 2155 if (pcr_goal == 0) 2156 pcr_goal = he_dev->atm_dev->link_rate; 2157 if (pcr_goal < 0) /* means round down, technically */ 2158 pcr_goal = -pcr_goal; 2159 2160 HPRINTK("open tx cid 0x%x pcr_goal %d\n", cid, pcr_goal); 2161 2162 switch (vcc->qos.aal) { 2163 case ATM_AAL5: 2164 tsr0_aal = TSR0_AAL5; 2165 tsr4 = TSR4_AAL5; 2166 break; 2167 case ATM_AAL0: 2168 tsr0_aal = TSR0_AAL0_SDU; 2169 tsr4 = TSR4_AAL0_SDU; 2170 break; 2171 default: 2172 err = -EINVAL; 2173 goto open_failed; 2174 } 2175 2176 spin_lock_irqsave(&he_dev->global_lock, flags); 2177 tsr0 = he_readl_tsr0(he_dev, cid); 2178 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2179 2180 if (TSR0_CONN_STATE(tsr0) != 0) { 2181 hprintk("cid 0x%x not idle (tsr0 = 0x%x)\n", cid, tsr0); 2182 err = -EBUSY; 2183 goto open_failed; 2184 } 2185 2186 switch (vcc->qos.txtp.traffic_class) { 2187 case ATM_UBR: 2188 /* 2.3.3.1 open connection ubr */ 2189 2190 tsr0 = TSR0_UBR | TSR0_GROUP(0) | tsr0_aal | 2191 TSR0_USE_WMIN | TSR0_UPDATE_GER; 2192 break; 2193 2194 case ATM_CBR: 2195 /* 2.3.3.2 open connection cbr */ 2196 2197 /* 8.2.3 cbr scheduler wrap problem -- limit to 90% total link rate */ 2198 if ((he_dev->total_bw + pcr_goal) 2199 > (he_dev->atm_dev->link_rate * 9 / 10)) 2200 { 2201 err = -EBUSY; 2202 goto open_failed; 2203 } 2204 2205 spin_lock_irqsave(&he_dev->global_lock, flags); /* also protects he_dev->cs_stper[] */ 2206 2207 /* find an unused cs_stper register */ 2208 for (reg = 0; reg < HE_NUM_CS_STPER; ++reg) 2209 if (he_dev->cs_stper[reg].inuse == 0 || 2210 he_dev->cs_stper[reg].pcr == pcr_goal) 2211 break; 2212 2213 if (reg == HE_NUM_CS_STPER) { 2214 err = -EBUSY; 2215 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2216 goto open_failed; 2217 } 2218 2219 he_dev->total_bw += pcr_goal; 2220 2221 he_vcc->rc_index = reg; 2222 ++he_dev->cs_stper[reg].inuse; 2223 he_dev->cs_stper[reg].pcr = pcr_goal; 2224 2225 clock = he_is622(he_dev) ? 66667000 : 50000000; 2226 period = clock / pcr_goal; 2227 2228 HPRINTK("rc_index = %d period = %d\n", 2229 reg, period); 2230 2231 he_writel_mbox(he_dev, rate_to_atmf(period/2), 2232 CS_STPER0 + reg); 2233 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2234 2235 tsr0 = TSR0_CBR | TSR0_GROUP(0) | tsr0_aal | 2236 TSR0_RC_INDEX(reg); 2237 2238 break; 2239 default: 2240 err = -EINVAL; 2241 goto open_failed; 2242 } 2243 2244 spin_lock_irqsave(&he_dev->global_lock, flags); 2245 2246 he_writel_tsr0(he_dev, tsr0, cid); 2247 he_writel_tsr4(he_dev, tsr4 | 1, cid); 2248 he_writel_tsr1(he_dev, TSR1_MCR(rate_to_atmf(0)) | 2249 TSR1_PCR(rate_to_atmf(pcr_goal)), cid); 2250 he_writel_tsr2(he_dev, TSR2_ACR(rate_to_atmf(pcr_goal)), cid); 2251 he_writel_tsr9(he_dev, TSR9_OPEN_CONN, cid); 2252 2253 he_writel_tsr3(he_dev, 0x0, cid); 2254 he_writel_tsr5(he_dev, 0x0, cid); 2255 he_writel_tsr6(he_dev, 0x0, cid); 2256 he_writel_tsr7(he_dev, 0x0, cid); 2257 he_writel_tsr8(he_dev, 0x0, cid); 2258 he_writel_tsr10(he_dev, 0x0, cid); 2259 he_writel_tsr11(he_dev, 0x0, cid); 2260 he_writel_tsr12(he_dev, 0x0, cid); 2261 he_writel_tsr13(he_dev, 0x0, cid); 2262 he_writel_tsr14(he_dev, 0x0, cid); 2263 (void) he_readl_tsr0(he_dev, cid); /* flush posted writes */ 2264 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2265 } 2266 2267 if (vcc->qos.rxtp.traffic_class != ATM_NONE) { 2268 unsigned aal; 2269 2270 HPRINTK("open rx cid 0x%x (rx_waitq %p)\n", cid, 2271 &HE_VCC(vcc)->rx_waitq); 2272 2273 switch (vcc->qos.aal) { 2274 case ATM_AAL5: 2275 aal = RSR0_AAL5; 2276 break; 2277 case ATM_AAL0: 2278 aal = RSR0_RAWCELL; 2279 break; 2280 default: 2281 err = -EINVAL; 2282 goto open_failed; 2283 } 2284 2285 spin_lock_irqsave(&he_dev->global_lock, flags); 2286 2287 rsr0 = he_readl_rsr0(he_dev, cid); 2288 if (rsr0 & RSR0_OPEN_CONN) { 2289 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2290 2291 hprintk("cid 0x%x not idle (rsr0 = 0x%x)\n", cid, rsr0); 2292 err = -EBUSY; 2293 goto open_failed; 2294 } 2295 2296 rsr1 = RSR1_GROUP(0) | RSR1_RBPL_ONLY; 2297 rsr4 = RSR4_GROUP(0) | RSR4_RBPL_ONLY; 2298 rsr0 = vcc->qos.rxtp.traffic_class == ATM_UBR ? 2299 (RSR0_EPD_ENABLE|RSR0_PPD_ENABLE) : 0; 2300 2301 #ifdef USE_CHECKSUM_HW 2302 if (vpi == 0 && vci >= ATM_NOT_RSV_VCI) 2303 rsr0 |= RSR0_TCP_CKSUM; 2304 #endif 2305 2306 he_writel_rsr4(he_dev, rsr4, cid); 2307 he_writel_rsr1(he_dev, rsr1, cid); 2308 /* 5.1.11 last parameter initialized should be 2309 the open/closed indication in rsr0 */ 2310 he_writel_rsr0(he_dev, 2311 rsr0 | RSR0_START_PDU | RSR0_OPEN_CONN | aal, cid); 2312 (void) he_readl_rsr0(he_dev, cid); /* flush posted writes */ 2313 2314 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2315 } 2316 2317 open_failed: 2318 2319 if (err) { 2320 kfree(he_vcc); 2321 clear_bit(ATM_VF_ADDR, &vcc->flags); 2322 } 2323 else 2324 set_bit(ATM_VF_READY, &vcc->flags); 2325 2326 return err; 2327 } 2328 2329 static void 2330 he_close(struct atm_vcc *vcc) 2331 { 2332 unsigned long flags; 2333 DECLARE_WAITQUEUE(wait, current); 2334 struct he_dev *he_dev = HE_DEV(vcc->dev); 2335 struct he_tpd *tpd; 2336 unsigned cid; 2337 struct he_vcc *he_vcc = HE_VCC(vcc); 2338 #define MAX_RETRY 30 2339 int retry = 0, sleep = 1, tx_inuse; 2340 2341 HPRINTK("close vcc %p %d.%d\n", vcc, vcc->vpi, vcc->vci); 2342 2343 clear_bit(ATM_VF_READY, &vcc->flags); 2344 cid = he_mkcid(he_dev, vcc->vpi, vcc->vci); 2345 2346 if (vcc->qos.rxtp.traffic_class != ATM_NONE) { 2347 int timeout; 2348 2349 HPRINTK("close rx cid 0x%x\n", cid); 2350 2351 /* 2.7.2.2 close receive operation */ 2352 2353 /* wait for previous close (if any) to finish */ 2354 2355 spin_lock_irqsave(&he_dev->global_lock, flags); 2356 while (he_readl(he_dev, RCC_STAT) & RCC_BUSY) { 2357 HPRINTK("close cid 0x%x RCC_BUSY\n", cid); 2358 udelay(250); 2359 } 2360 2361 set_current_state(TASK_UNINTERRUPTIBLE); 2362 add_wait_queue(&he_vcc->rx_waitq, &wait); 2363 2364 he_writel_rsr0(he_dev, RSR0_CLOSE_CONN, cid); 2365 (void) he_readl_rsr0(he_dev, cid); /* flush posted writes */ 2366 he_writel_mbox(he_dev, cid, RXCON_CLOSE); 2367 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2368 2369 timeout = schedule_timeout(30*HZ); 2370 2371 remove_wait_queue(&he_vcc->rx_waitq, &wait); 2372 set_current_state(TASK_RUNNING); 2373 2374 if (timeout == 0) 2375 hprintk("close rx timeout cid 0x%x\n", cid); 2376 2377 HPRINTK("close rx cid 0x%x complete\n", cid); 2378 2379 } 2380 2381 if (vcc->qos.txtp.traffic_class != ATM_NONE) { 2382 volatile unsigned tsr4, tsr0; 2383 int timeout; 2384 2385 HPRINTK("close tx cid 0x%x\n", cid); 2386 2387 /* 2.1.2 2388 * 2389 * ... the host must first stop queueing packets to the TPDRQ 2390 * on the connection to be closed, then wait for all outstanding 2391 * packets to be transmitted and their buffers returned to the 2392 * TBRQ. When the last packet on the connection arrives in the 2393 * TBRQ, the host issues the close command to the adapter. 2394 */ 2395 2396 while (((tx_inuse = atomic_read(&sk_atm(vcc)->sk_wmem_alloc)) > 1) && 2397 (retry < MAX_RETRY)) { 2398 msleep(sleep); 2399 if (sleep < 250) 2400 sleep = sleep * 2; 2401 2402 ++retry; 2403 } 2404 2405 if (tx_inuse > 1) 2406 hprintk("close tx cid 0x%x tx_inuse = %d\n", cid, tx_inuse); 2407 2408 /* 2.3.1.1 generic close operations with flush */ 2409 2410 spin_lock_irqsave(&he_dev->global_lock, flags); 2411 he_writel_tsr4_upper(he_dev, TSR4_FLUSH_CONN, cid); 2412 /* also clears TSR4_SESSION_ENDED */ 2413 2414 switch (vcc->qos.txtp.traffic_class) { 2415 case ATM_UBR: 2416 he_writel_tsr1(he_dev, 2417 TSR1_MCR(rate_to_atmf(200000)) 2418 | TSR1_PCR(0), cid); 2419 break; 2420 case ATM_CBR: 2421 he_writel_tsr14_upper(he_dev, TSR14_DELETE, cid); 2422 break; 2423 } 2424 (void) he_readl_tsr4(he_dev, cid); /* flush posted writes */ 2425 2426 tpd = __alloc_tpd(he_dev); 2427 if (tpd == NULL) { 2428 hprintk("close tx he_alloc_tpd failed cid 0x%x\n", cid); 2429 goto close_tx_incomplete; 2430 } 2431 tpd->status |= TPD_EOS | TPD_INT; 2432 tpd->skb = NULL; 2433 tpd->vcc = vcc; 2434 wmb(); 2435 2436 set_current_state(TASK_UNINTERRUPTIBLE); 2437 add_wait_queue(&he_vcc->tx_waitq, &wait); 2438 __enqueue_tpd(he_dev, tpd, cid); 2439 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2440 2441 timeout = schedule_timeout(30*HZ); 2442 2443 remove_wait_queue(&he_vcc->tx_waitq, &wait); 2444 set_current_state(TASK_RUNNING); 2445 2446 spin_lock_irqsave(&he_dev->global_lock, flags); 2447 2448 if (timeout == 0) { 2449 hprintk("close tx timeout cid 0x%x\n", cid); 2450 goto close_tx_incomplete; 2451 } 2452 2453 while (!((tsr4 = he_readl_tsr4(he_dev, cid)) & TSR4_SESSION_ENDED)) { 2454 HPRINTK("close tx cid 0x%x !TSR4_SESSION_ENDED (tsr4 = 0x%x)\n", cid, tsr4); 2455 udelay(250); 2456 } 2457 2458 while (TSR0_CONN_STATE(tsr0 = he_readl_tsr0(he_dev, cid)) != 0) { 2459 HPRINTK("close tx cid 0x%x TSR0_CONN_STATE != 0 (tsr0 = 0x%x)\n", cid, tsr0); 2460 udelay(250); 2461 } 2462 2463 close_tx_incomplete: 2464 2465 if (vcc->qos.txtp.traffic_class == ATM_CBR) { 2466 int reg = he_vcc->rc_index; 2467 2468 HPRINTK("cs_stper reg = %d\n", reg); 2469 2470 if (he_dev->cs_stper[reg].inuse == 0) 2471 hprintk("cs_stper[%d].inuse = 0!\n", reg); 2472 else 2473 --he_dev->cs_stper[reg].inuse; 2474 2475 he_dev->total_bw -= he_dev->cs_stper[reg].pcr; 2476 } 2477 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2478 2479 HPRINTK("close tx cid 0x%x complete\n", cid); 2480 } 2481 2482 kfree(he_vcc); 2483 2484 clear_bit(ATM_VF_ADDR, &vcc->flags); 2485 } 2486 2487 static int 2488 he_send(struct atm_vcc *vcc, struct sk_buff *skb) 2489 { 2490 unsigned long flags; 2491 struct he_dev *he_dev = HE_DEV(vcc->dev); 2492 unsigned cid = he_mkcid(he_dev, vcc->vpi, vcc->vci); 2493 struct he_tpd *tpd; 2494 #ifdef USE_SCATTERGATHER 2495 int i, slot = 0; 2496 #endif 2497 2498 #define HE_TPD_BUFSIZE 0xffff 2499 2500 HPRINTK("send %d.%d\n", vcc->vpi, vcc->vci); 2501 2502 if ((skb->len > HE_TPD_BUFSIZE) || 2503 ((vcc->qos.aal == ATM_AAL0) && (skb->len != ATM_AAL0_SDU))) { 2504 hprintk("buffer too large (or small) -- %d bytes\n", skb->len ); 2505 if (vcc->pop) 2506 vcc->pop(vcc, skb); 2507 else 2508 dev_kfree_skb_any(skb); 2509 atomic_inc(&vcc->stats->tx_err); 2510 return -EINVAL; 2511 } 2512 2513 #ifndef USE_SCATTERGATHER 2514 if (skb_shinfo(skb)->nr_frags) { 2515 hprintk("no scatter/gather support\n"); 2516 if (vcc->pop) 2517 vcc->pop(vcc, skb); 2518 else 2519 dev_kfree_skb_any(skb); 2520 atomic_inc(&vcc->stats->tx_err); 2521 return -EINVAL; 2522 } 2523 #endif 2524 spin_lock_irqsave(&he_dev->global_lock, flags); 2525 2526 tpd = __alloc_tpd(he_dev); 2527 if (tpd == NULL) { 2528 if (vcc->pop) 2529 vcc->pop(vcc, skb); 2530 else 2531 dev_kfree_skb_any(skb); 2532 atomic_inc(&vcc->stats->tx_err); 2533 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2534 return -ENOMEM; 2535 } 2536 2537 if (vcc->qos.aal == ATM_AAL5) 2538 tpd->status |= TPD_CELLTYPE(TPD_USERCELL); 2539 else { 2540 char *pti_clp = (void *) (skb->data + 3); 2541 int clp, pti; 2542 2543 pti = (*pti_clp & ATM_HDR_PTI_MASK) >> ATM_HDR_PTI_SHIFT; 2544 clp = (*pti_clp & ATM_HDR_CLP); 2545 tpd->status |= TPD_CELLTYPE(pti); 2546 if (clp) 2547 tpd->status |= TPD_CLP; 2548 2549 skb_pull(skb, ATM_AAL0_SDU - ATM_CELL_PAYLOAD); 2550 } 2551 2552 #ifdef USE_SCATTERGATHER 2553 tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, skb->data, 2554 skb_headlen(skb), DMA_TO_DEVICE); 2555 tpd->iovec[slot].len = skb_headlen(skb); 2556 ++slot; 2557 2558 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 2559 skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 2560 2561 if (slot == TPD_MAXIOV) { /* queue tpd; start new tpd */ 2562 tpd->vcc = vcc; 2563 tpd->skb = NULL; /* not the last fragment 2564 so dont ->push() yet */ 2565 wmb(); 2566 2567 __enqueue_tpd(he_dev, tpd, cid); 2568 tpd = __alloc_tpd(he_dev); 2569 if (tpd == NULL) { 2570 if (vcc->pop) 2571 vcc->pop(vcc, skb); 2572 else 2573 dev_kfree_skb_any(skb); 2574 atomic_inc(&vcc->stats->tx_err); 2575 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2576 return -ENOMEM; 2577 } 2578 tpd->status |= TPD_USERCELL; 2579 slot = 0; 2580 } 2581 2582 tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, 2583 (void *) page_address(frag->page) + frag->page_offset, 2584 frag->size, DMA_TO_DEVICE); 2585 tpd->iovec[slot].len = frag->size; 2586 ++slot; 2587 2588 } 2589 2590 tpd->iovec[slot - 1].len |= TPD_LST; 2591 #else 2592 tpd->address0 = dma_map_single(&he_dev->pci_dev->dev, skb->data, skb->len, DMA_TO_DEVICE); 2593 tpd->length0 = skb->len | TPD_LST; 2594 #endif 2595 tpd->status |= TPD_INT; 2596 2597 tpd->vcc = vcc; 2598 tpd->skb = skb; 2599 wmb(); 2600 ATM_SKB(skb)->vcc = vcc; 2601 2602 __enqueue_tpd(he_dev, tpd, cid); 2603 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2604 2605 atomic_inc(&vcc->stats->tx); 2606 2607 return 0; 2608 } 2609 2610 static int 2611 he_ioctl(struct atm_dev *atm_dev, unsigned int cmd, void __user *arg) 2612 { 2613 unsigned long flags; 2614 struct he_dev *he_dev = HE_DEV(atm_dev); 2615 struct he_ioctl_reg reg; 2616 int err = 0; 2617 2618 switch (cmd) { 2619 case HE_GET_REG: 2620 if (!capable(CAP_NET_ADMIN)) 2621 return -EPERM; 2622 2623 if (copy_from_user(®, arg, 2624 sizeof(struct he_ioctl_reg))) 2625 return -EFAULT; 2626 2627 spin_lock_irqsave(&he_dev->global_lock, flags); 2628 switch (reg.type) { 2629 case HE_REGTYPE_PCI: 2630 if (reg.addr >= HE_REGMAP_SIZE) { 2631 err = -EINVAL; 2632 break; 2633 } 2634 2635 reg.val = he_readl(he_dev, reg.addr); 2636 break; 2637 case HE_REGTYPE_RCM: 2638 reg.val = 2639 he_readl_rcm(he_dev, reg.addr); 2640 break; 2641 case HE_REGTYPE_TCM: 2642 reg.val = 2643 he_readl_tcm(he_dev, reg.addr); 2644 break; 2645 case HE_REGTYPE_MBOX: 2646 reg.val = 2647 he_readl_mbox(he_dev, reg.addr); 2648 break; 2649 default: 2650 err = -EINVAL; 2651 break; 2652 } 2653 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2654 if (err == 0) 2655 if (copy_to_user(arg, ®, 2656 sizeof(struct he_ioctl_reg))) 2657 return -EFAULT; 2658 break; 2659 default: 2660 #ifdef CONFIG_ATM_HE_USE_SUNI 2661 if (atm_dev->phy && atm_dev->phy->ioctl) 2662 err = atm_dev->phy->ioctl(atm_dev, cmd, arg); 2663 #else /* CONFIG_ATM_HE_USE_SUNI */ 2664 err = -EINVAL; 2665 #endif /* CONFIG_ATM_HE_USE_SUNI */ 2666 break; 2667 } 2668 2669 return err; 2670 } 2671 2672 static void 2673 he_phy_put(struct atm_dev *atm_dev, unsigned char val, unsigned long addr) 2674 { 2675 unsigned long flags; 2676 struct he_dev *he_dev = HE_DEV(atm_dev); 2677 2678 HPRINTK("phy_put(val 0x%x, addr 0x%lx)\n", val, addr); 2679 2680 spin_lock_irqsave(&he_dev->global_lock, flags); 2681 he_writel(he_dev, val, FRAMER + (addr*4)); 2682 (void) he_readl(he_dev, FRAMER + (addr*4)); /* flush posted writes */ 2683 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2684 } 2685 2686 2687 static unsigned char 2688 he_phy_get(struct atm_dev *atm_dev, unsigned long addr) 2689 { 2690 unsigned long flags; 2691 struct he_dev *he_dev = HE_DEV(atm_dev); 2692 unsigned reg; 2693 2694 spin_lock_irqsave(&he_dev->global_lock, flags); 2695 reg = he_readl(he_dev, FRAMER + (addr*4)); 2696 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2697 2698 HPRINTK("phy_get(addr 0x%lx) =0x%x\n", addr, reg); 2699 return reg; 2700 } 2701 2702 static int 2703 he_proc_read(struct atm_dev *dev, loff_t *pos, char *page) 2704 { 2705 unsigned long flags; 2706 struct he_dev *he_dev = HE_DEV(dev); 2707 int left, i; 2708 #ifdef notdef 2709 struct he_rbrq *rbrq_tail; 2710 struct he_tpdrq *tpdrq_head; 2711 int rbpl_head, rbpl_tail; 2712 #endif 2713 static long mcc = 0, oec = 0, dcc = 0, cec = 0; 2714 2715 2716 left = *pos; 2717 if (!left--) 2718 return sprintf(page, "ATM he driver\n"); 2719 2720 if (!left--) 2721 return sprintf(page, "%s%s\n\n", 2722 he_dev->prod_id, he_dev->media & 0x40 ? "SM" : "MM"); 2723 2724 if (!left--) 2725 return sprintf(page, "Mismatched Cells VPI/VCI Not Open Dropped Cells RCM Dropped Cells\n"); 2726 2727 spin_lock_irqsave(&he_dev->global_lock, flags); 2728 mcc += he_readl(he_dev, MCC); 2729 oec += he_readl(he_dev, OEC); 2730 dcc += he_readl(he_dev, DCC); 2731 cec += he_readl(he_dev, CEC); 2732 spin_unlock_irqrestore(&he_dev->global_lock, flags); 2733 2734 if (!left--) 2735 return sprintf(page, "%16ld %16ld %13ld %17ld\n\n", 2736 mcc, oec, dcc, cec); 2737 2738 if (!left--) 2739 return sprintf(page, "irq_size = %d inuse = ? peak = %d\n", 2740 CONFIG_IRQ_SIZE, he_dev->irq_peak); 2741 2742 if (!left--) 2743 return sprintf(page, "tpdrq_size = %d inuse = ?\n", 2744 CONFIG_TPDRQ_SIZE); 2745 2746 if (!left--) 2747 return sprintf(page, "rbrq_size = %d inuse = ? peak = %d\n", 2748 CONFIG_RBRQ_SIZE, he_dev->rbrq_peak); 2749 2750 if (!left--) 2751 return sprintf(page, "tbrq_size = %d peak = %d\n", 2752 CONFIG_TBRQ_SIZE, he_dev->tbrq_peak); 2753 2754 2755 #ifdef notdef 2756 rbpl_head = RBPL_MASK(he_readl(he_dev, G0_RBPL_S)); 2757 rbpl_tail = RBPL_MASK(he_readl(he_dev, G0_RBPL_T)); 2758 2759 inuse = rbpl_head - rbpl_tail; 2760 if (inuse < 0) 2761 inuse += CONFIG_RBPL_SIZE * sizeof(struct he_rbp); 2762 inuse /= sizeof(struct he_rbp); 2763 2764 if (!left--) 2765 return sprintf(page, "rbpl_size = %d inuse = %d\n\n", 2766 CONFIG_RBPL_SIZE, inuse); 2767 #endif 2768 2769 if (!left--) 2770 return sprintf(page, "rate controller periods (cbr)\n pcr #vc\n"); 2771 2772 for (i = 0; i < HE_NUM_CS_STPER; ++i) 2773 if (!left--) 2774 return sprintf(page, "cs_stper%-2d %8ld %3d\n", i, 2775 he_dev->cs_stper[i].pcr, 2776 he_dev->cs_stper[i].inuse); 2777 2778 if (!left--) 2779 return sprintf(page, "total bw (cbr): %d (limit %d)\n", 2780 he_dev->total_bw, he_dev->atm_dev->link_rate * 10 / 9); 2781 2782 return 0; 2783 } 2784 2785 /* eeprom routines -- see 4.7 */ 2786 2787 static u8 read_prom_byte(struct he_dev *he_dev, int addr) 2788 { 2789 u32 val = 0, tmp_read = 0; 2790 int i, j = 0; 2791 u8 byte_read = 0; 2792 2793 val = readl(he_dev->membase + HOST_CNTL); 2794 val &= 0xFFFFE0FF; 2795 2796 /* Turn on write enable */ 2797 val |= 0x800; 2798 he_writel(he_dev, val, HOST_CNTL); 2799 2800 /* Send READ instruction */ 2801 for (i = 0; i < ARRAY_SIZE(readtab); i++) { 2802 he_writel(he_dev, val | readtab[i], HOST_CNTL); 2803 udelay(EEPROM_DELAY); 2804 } 2805 2806 /* Next, we need to send the byte address to read from */ 2807 for (i = 7; i >= 0; i--) { 2808 he_writel(he_dev, val | clocktab[j++] | (((addr >> i) & 1) << 9), HOST_CNTL); 2809 udelay(EEPROM_DELAY); 2810 he_writel(he_dev, val | clocktab[j++] | (((addr >> i) & 1) << 9), HOST_CNTL); 2811 udelay(EEPROM_DELAY); 2812 } 2813 2814 j = 0; 2815 2816 val &= 0xFFFFF7FF; /* Turn off write enable */ 2817 he_writel(he_dev, val, HOST_CNTL); 2818 2819 /* Now, we can read data from the EEPROM by clocking it in */ 2820 for (i = 7; i >= 0; i--) { 2821 he_writel(he_dev, val | clocktab[j++], HOST_CNTL); 2822 udelay(EEPROM_DELAY); 2823 tmp_read = he_readl(he_dev, HOST_CNTL); 2824 byte_read |= (unsigned char) 2825 ((tmp_read & ID_DOUT) >> ID_DOFFSET << i); 2826 he_writel(he_dev, val | clocktab[j++], HOST_CNTL); 2827 udelay(EEPROM_DELAY); 2828 } 2829 2830 he_writel(he_dev, val | ID_CS, HOST_CNTL); 2831 udelay(EEPROM_DELAY); 2832 2833 return byte_read; 2834 } 2835 2836 MODULE_LICENSE("GPL"); 2837 MODULE_AUTHOR("chas williams <chas@cmf.nrl.navy.mil>"); 2838 MODULE_DESCRIPTION("ForeRunnerHE ATM Adapter driver"); 2839 module_param(disable64, bool, 0); 2840 MODULE_PARM_DESC(disable64, "disable 64-bit pci bus transfers"); 2841 module_param(nvpibits, short, 0); 2842 MODULE_PARM_DESC(nvpibits, "numbers of bits for vpi (default 0)"); 2843 module_param(nvcibits, short, 0); 2844 MODULE_PARM_DESC(nvcibits, "numbers of bits for vci (default 12)"); 2845 module_param(rx_skb_reserve, short, 0); 2846 MODULE_PARM_DESC(rx_skb_reserve, "padding for receive skb (default 16)"); 2847 module_param(irq_coalesce, bool, 0); 2848 MODULE_PARM_DESC(irq_coalesce, "use interrupt coalescing (default 1)"); 2849 module_param(sdh, bool, 0); 2850 MODULE_PARM_DESC(sdh, "use SDH framing (default 0)"); 2851 2852 static struct pci_device_id he_pci_tbl[] = { 2853 { PCI_VDEVICE(FORE, PCI_DEVICE_ID_FORE_HE), 0 }, 2854 { 0, } 2855 }; 2856 2857 MODULE_DEVICE_TABLE(pci, he_pci_tbl); 2858 2859 static struct pci_driver he_driver = { 2860 .name = "he", 2861 .probe = he_init_one, 2862 .remove = he_remove_one, 2863 .id_table = he_pci_tbl, 2864 }; 2865 2866 module_pci_driver(he_driver); 2867