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