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