+2 -2

MAINTAINERS

reviewed

··· 3177 3177 S: Supported 3178 3178 3179 3179 SPIDERNET NETWORK DRIVER for CELL 3180 3180 - P: Jim Lewis 3181 3181 - M: jim@jklewis.com 3180 3180 + P: Linas Vepstas 3181 3181 + M: linas@austin.ibm.com 3182 3182 L: netdev@vger.kernel.org 3183 3183 S: Supported 3184 3184

+1 -1

drivers/net/Kconfig

reviewed

··· 2245 2245 2246 2246 config SPIDER_NET 2247 2247 tristate "Spider Gigabit Ethernet driver" 2248 2248 - depends on PCI && PPC_IBM_CELL_BLADE 2248 2248 + depends on PCI && (PPC_IBM_CELL_BLADE || PPC_CELLEB) 2249 2249 select FW_LOADER 2250 2250 help 2251 2251 This driver supports the Gigabit Ethernet chips present on the

+1

drivers/net/chelsio/sge.c

reviewed

··· 1696 1696 { 1697 1697 int work_done; 1698 1698 struct adapter *adapter = cookie; 1699 1699 + struct respQ *Q = &adapter->sge->respQ; 1699 1700 1700 1701 spin_lock(&adapter->async_lock); 1701 1702

+10 -1

drivers/net/cxgb3/adapter.h

reviewed

··· 74 74 struct rx_desc; 75 75 struct rx_sw_desc; 76 76 77 77 + struct sge_fl_page { 78 78 + struct skb_frag_struct frag; 79 79 + unsigned char *va; 80 80 + }; 81 81 + 77 82 struct sge_fl { /* SGE per free-buffer list state */ 78 83 unsigned int buf_size; /* size of each Rx buffer */ 79 84 unsigned int credits; /* # of available Rx buffers */ ··· 86 81 unsigned int cidx; /* consumer index */ 87 82 unsigned int pidx; /* producer index */ 88 83 unsigned int gen; /* free list generation */ 84 84 + unsigned int cntxt_id; /* SGE context id for the free list */ 85 85 + struct sge_fl_page page; 89 86 struct rx_desc *desc; /* address of HW Rx descriptor ring */ 90 87 struct rx_sw_desc *sdesc; /* address of SW Rx descriptor ring */ 91 88 dma_addr_t phys_addr; /* physical address of HW ring start */ 92 92 - unsigned int cntxt_id; /* SGE context id for the free list */ 93 89 unsigned long empty; /* # of times queue ran out of buffers */ 90 90 + unsigned long alloc_failed; /* # of times buffer allocation failed */ 94 91 }; 95 92 96 93 /* ··· 128 121 unsigned long empty; /* # of times queue ran out of credits */ 129 122 unsigned long nomem; /* # of responses deferred due to no mem */ 130 123 unsigned long unhandled_irqs; /* # of spurious intrs */ 124 124 + unsigned long starved; 125 125 + unsigned long restarted; 131 126 }; 132 127 133 128 struct tx_desc;

+11 -22

drivers/net/cxgb3/cxgb3_ioctl.h

reviewed

··· 36 36 * Ioctl commands specific to this driver. 37 37 */ 38 38 enum { 39 39 - CHELSIO_SETREG = 1024, 40 40 - CHELSIO_GETREG, 41 41 - CHELSIO_SETTPI, 42 42 - CHELSIO_GETTPI, 43 43 - CHELSIO_GETMTUTAB, 44 44 - CHELSIO_SETMTUTAB, 45 45 - CHELSIO_GETMTU, 46 46 - CHELSIO_SET_PM, 47 47 - CHELSIO_GET_PM, 48 48 - CHELSIO_GET_TCAM, 49 49 - CHELSIO_SET_TCAM, 50 50 - CHELSIO_GET_TCB, 51 51 - CHELSIO_GET_MEM, 52 52 - CHELSIO_LOAD_FW, 53 53 - CHELSIO_GET_PROTO, 54 54 - CHELSIO_SET_PROTO, 55 55 - CHELSIO_SET_TRACE_FILTER, 56 56 - CHELSIO_SET_QSET_PARAMS, 57 57 - CHELSIO_GET_QSET_PARAMS, 58 58 - CHELSIO_SET_QSET_NUM, 59 59 - CHELSIO_GET_QSET_NUM, 60 60 - CHELSIO_SET_PKTSCHED, 39 39 + CHELSIO_GETMTUTAB = 1029, 40 40 + CHELSIO_SETMTUTAB = 1030, 41 41 + CHELSIO_SET_PM = 1032, 42 42 + CHELSIO_GET_PM = 1033, 43 43 + CHELSIO_GET_MEM = 1038, 44 44 + CHELSIO_LOAD_FW = 1041, 45 45 + CHELSIO_SET_TRACE_FILTER = 1044, 46 46 + CHELSIO_SET_QSET_PARAMS = 1045, 47 47 + CHELSIO_GET_QSET_PARAMS = 1046, 48 48 + CHELSIO_SET_QSET_NUM = 1047, 49 49 + CHELSIO_GET_QSET_NUM = 1048, 61 50 }; 62 51 63 52 struct ch_reg {

+16 -53

drivers/net/cxgb3/cxgb3_main.c

reviewed

··· 434 434 435 435 static ssize_t attr_show(struct device *d, struct device_attribute *attr, 436 436 char *buf, 437 437 - ssize_t(*format) (struct adapter *, char *)) 437 437 + ssize_t(*format) (struct net_device *, char *)) 438 438 { 439 439 ssize_t len; 440 440 - struct adapter *adap = to_net_dev(d)->priv; 441 440 442 441 /* Synchronize with ioctls that may shut down the device */ 443 442 rtnl_lock(); 444 444 - len = (*format) (adap, buf); 443 443 + len = (*format) (to_net_dev(d), buf); 445 444 rtnl_unlock(); 446 445 return len; 447 446 } 448 447 449 448 static ssize_t attr_store(struct device *d, struct device_attribute *attr, 450 449 const char *buf, size_t len, 451 451 - ssize_t(*set) (struct adapter *, unsigned int), 450 450 + ssize_t(*set) (struct net_device *, unsigned int), 452 451 unsigned int min_val, unsigned int max_val) 453 452 { 454 453 char *endp; 455 454 ssize_t ret; 456 455 unsigned int val; 457 457 - struct adapter *adap = to_net_dev(d)->priv; 458 456 459 457 if (!capable(CAP_NET_ADMIN)) 460 458 return -EPERM; ··· 462 464 return -EINVAL; 463 465 464 466 rtnl_lock(); 465 465 - ret = (*set) (adap, val); 467 467 + ret = (*set) (to_net_dev(d), val); 466 468 if (!ret) 467 469 ret = len; 468 470 rtnl_unlock(); ··· 470 472 } 471 473 472 474 #define CXGB3_SHOW(name, val_expr) \ 473 473 - static ssize_t format_##name(struct adapter *adap, char *buf) \ 475 475 + static ssize_t format_##name(struct net_device *dev, char *buf) \ 474 476 { \ 477 477 + struct adapter *adap = dev->priv; \ 475 478 return sprintf(buf, "%u\n", val_expr); \ 476 479 } \ 477 480 static ssize_t show_##name(struct device *d, struct device_attribute *attr, \ ··· 481 482 return attr_show(d, attr, buf, format_##name); \ 482 483 } 483 484 484 484 - static ssize_t set_nfilters(struct adapter *adap, unsigned int val) 485 485 + static ssize_t set_nfilters(struct net_device *dev, unsigned int val) 485 486 { 487 487 + struct adapter *adap = dev->priv; 488 488 + 486 489 if (adap->flags & FULL_INIT_DONE) 487 490 return -EBUSY; 488 491 if (val && adap->params.rev == 0) ··· 501 500 return attr_store(d, attr, buf, len, set_nfilters, 0, ~0); 502 501 } 503 502 504 504 - static ssize_t set_nservers(struct adapter *adap, unsigned int val) 503 503 + static ssize_t set_nservers(struct net_device *dev, unsigned int val) 505 504 { 505 505 + struct adapter *adap = dev->priv; 506 506 + 506 507 if (adap->flags & FULL_INIT_DONE) 507 508 return -EBUSY; 508 509 if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nfilters) ··· 1552 1549 return -EFAULT; 1553 1550 1554 1551 switch (cmd) { 1555 1555 - case CHELSIO_SETREG:{ 1556 1556 - struct ch_reg edata; 1557 1557 - 1558 1558 - if (!capable(CAP_NET_ADMIN)) 1559 1559 - return -EPERM; 1560 1560 - if (copy_from_user(&edata, useraddr, sizeof(edata))) 1561 1561 - return -EFAULT; 1562 1562 - if ((edata.addr & 3) != 0 1563 1563 - || edata.addr >= adapter->mmio_len) 1564 1564 - return -EINVAL; 1565 1565 - writel(edata.val, adapter->regs + edata.addr); 1566 1566 - break; 1567 1567 - } 1568 1568 - case CHELSIO_GETREG:{ 1569 1569 - struct ch_reg edata; 1570 1570 - 1571 1571 - if (copy_from_user(&edata, useraddr, sizeof(edata))) 1572 1572 - return -EFAULT; 1573 1573 - if ((edata.addr & 3) != 0 1574 1574 - || edata.addr >= adapter->mmio_len) 1575 1575 - return -EINVAL; 1576 1576 - edata.val = readl(adapter->regs + edata.addr); 1577 1577 - if (copy_to_user(useraddr, &edata, sizeof(edata))) 1578 1578 - return -EFAULT; 1579 1579 - break; 1580 1580 - } 1581 1552 case CHELSIO_SET_QSET_PARAMS:{ 1582 1553 int i; 1583 1554 struct qset_params *q; ··· 1815 1838 return -EINVAL; 1816 1839 1817 1840 /* 1818 1818 - * Version scheme: 1819 1819 - * bits 0..9: chip version 1820 1820 - * bits 10..15: chip revision 1821 1821 - */ 1841 1841 + * Version scheme: 1842 1842 + * bits 0..9: chip version 1843 1843 + * bits 10..15: chip revision 1844 1844 + */ 1822 1845 t.version = 3 | (adapter->params.rev << 10); 1823 1846 if (copy_to_user(useraddr, &t, sizeof(t))) 1824 1847 return -EFAULT; ··· 1866 1889 t.invert_match, 1867 1890 t.trace_rx); 1868 1891 break; 1869 1869 - } 1870 1870 - case CHELSIO_SET_PKTSCHED:{ 1871 1871 - struct ch_pktsched_params p; 1872 1872 - 1873 1873 - if (!capable(CAP_NET_ADMIN)) 1874 1874 - return -EPERM; 1875 1875 - if (!adapter->open_device_map) 1876 1876 - return -EAGAIN; /* uP and SGE must be running */ 1877 1877 - if (copy_from_user(&p, useraddr, sizeof(p))) 1878 1878 - return -EFAULT; 1879 1879 - send_pktsched_cmd(adapter, p.sched, p.idx, p.min, p.max, 1880 1880 - p.binding); 1881 1881 - break; 1882 1882 - 1883 1892 } 1884 1893 default: 1885 1894 return -EOPNOTSUPP;

+299 -91

drivers/net/cxgb3/sge.c

reviewed

··· 45 45 #define USE_GTS 0 46 46 47 47 #define SGE_RX_SM_BUF_SIZE 1536 48 48 + 49 49 + /* 50 50 + * If USE_RX_PAGE is defined, the small freelist populated with (partial) 51 51 + * pages instead of skbs. Pages are carved up into RX_PAGE_SIZE chunks (must 52 52 + * be a multiple of the host page size). 53 53 + */ 54 54 + #define USE_RX_PAGE 55 55 + #define RX_PAGE_SIZE 2048 56 56 + 57 57 + /* 58 58 + * skb freelist packets are copied into a new skb (and the freelist one is 59 59 + * reused) if their len is <= 60 60 + */ 48 61 #define SGE_RX_COPY_THRES 256 49 62 50 50 - # define SGE_RX_DROP_THRES 16 63 63 + /* 64 64 + * Minimum number of freelist entries before we start dropping TUNNEL frames. 65 65 + */ 66 66 + #define SGE_RX_DROP_THRES 16 51 67 52 68 /* 53 69 * Period of the Tx buffer reclaim timer. This timer does not need to run ··· 101 85 }; 102 86 103 87 struct rx_sw_desc { /* SW state per Rx descriptor */ 104 104 - struct sk_buff *skb; 88 88 + union { 89 89 + struct sk_buff *skb; 90 90 + struct sge_fl_page page; 91 91 + } t; 105 92 DECLARE_PCI_UNMAP_ADDR(dma_addr); 106 93 }; 107 94 ··· 121 102 u16 fragidx; /* first page fragment in current Tx descriptor */ 122 103 u16 addr_idx; /* buffer index of first SGL entry in descriptor */ 123 104 u32 len; /* mapped length of skb main body */ 105 105 + }; 106 106 + 107 107 + /* 108 108 + * Holds unmapping information for Tx packets that need deferred unmapping. 109 109 + * This structure lives at skb->head and must be allocated by callers. 110 110 + */ 111 111 + struct deferred_unmap_info { 112 112 + struct pci_dev *pdev; 113 113 + dma_addr_t addr[MAX_SKB_FRAGS + 1]; 124 114 }; 125 115 126 116 /* ··· 280 252 struct pci_dev *pdev = adapter->pdev; 281 253 unsigned int cidx = q->cidx; 282 254 255 255 + const int need_unmap = need_skb_unmap() && 256 256 + q->cntxt_id >= FW_TUNNEL_SGEEC_START; 257 257 + 283 258 d = &q->sdesc[cidx]; 284 259 while (n--) { 285 260 if (d->skb) { /* an SGL is present */ 286 286 - if (need_skb_unmap()) 261 261 + if (need_unmap) 287 262 unmap_skb(d->skb, q, cidx, pdev); 288 263 if (d->skb->priority == cidx) 289 264 kfree_skb(d->skb); ··· 351 320 352 321 pci_unmap_single(pdev, pci_unmap_addr(d, dma_addr), 353 322 q->buf_size, PCI_DMA_FROMDEVICE); 354 354 - kfree_skb(d->skb); 355 355 - d->skb = NULL; 323 323 + 324 324 + if (q->buf_size != RX_PAGE_SIZE) { 325 325 + kfree_skb(d->t.skb); 326 326 + d->t.skb = NULL; 327 327 + } else { 328 328 + if (d->t.page.frag.page) 329 329 + put_page(d->t.page.frag.page); 330 330 + d->t.page.frag.page = NULL; 331 331 + } 356 332 if (++cidx == q->size) 357 333 cidx = 0; 358 334 } 335 335 + 336 336 + if (q->page.frag.page) 337 337 + put_page(q->page.frag.page); 338 338 + q->page.frag.page = NULL; 359 339 } 360 340 361 341 /** 362 342 * add_one_rx_buf - add a packet buffer to a free-buffer list 363 363 - * @skb: the buffer to add 343 343 + * @va: va of the buffer to add 364 344 * @len: the buffer length 365 345 * @d: the HW Rx descriptor to write 366 346 * @sd: the SW Rx descriptor to write ··· 381 339 * Add a buffer of the given length to the supplied HW and SW Rx 382 340 * descriptors. 383 341 */ 384 384 - static inline void add_one_rx_buf(struct sk_buff *skb, unsigned int len, 342 342 + static inline void add_one_rx_buf(unsigned char *va, unsigned int len, 385 343 struct rx_desc *d, struct rx_sw_desc *sd, 386 344 unsigned int gen, struct pci_dev *pdev) 387 345 { 388 346 dma_addr_t mapping; 389 347 390 390 - sd->skb = skb; 391 391 - mapping = pci_map_single(pdev, skb->data, len, PCI_DMA_FROMDEVICE); 348 348 + mapping = pci_map_single(pdev, va, len, PCI_DMA_FROMDEVICE); 392 349 pci_unmap_addr_set(sd, dma_addr, mapping); 393 350 394 351 d->addr_lo = cpu_to_be32(mapping); ··· 412 371 { 413 372 struct rx_sw_desc *sd = &q->sdesc[q->pidx]; 414 373 struct rx_desc *d = &q->desc[q->pidx]; 374 374 + struct sge_fl_page *p = &q->page; 415 375 416 376 while (n--) { 417 417 - struct sk_buff *skb = alloc_skb(q->buf_size, gfp); 377 377 + unsigned char *va; 418 378 419 419 - if (!skb) 420 420 - break; 379 379 + if (unlikely(q->buf_size != RX_PAGE_SIZE)) { 380 380 + struct sk_buff *skb = alloc_skb(q->buf_size, gfp); 421 381 422 422 - add_one_rx_buf(skb, q->buf_size, d, sd, q->gen, adap->pdev); 382 382 + if (!skb) { 383 383 + q->alloc_failed++; 384 384 + break; 385 385 + } 386 386 + va = skb->data; 387 387 + sd->t.skb = skb; 388 388 + } else { 389 389 + if (!p->frag.page) { 390 390 + p->frag.page = alloc_pages(gfp, 0); 391 391 + if (unlikely(!p->frag.page)) { 392 392 + q->alloc_failed++; 393 393 + break; 394 394 + } else { 395 395 + p->frag.size = RX_PAGE_SIZE; 396 396 + p->frag.page_offset = 0; 397 397 + p->va = page_address(p->frag.page); 398 398 + } 399 399 + } 400 400 + 401 401 + memcpy(&sd->t, p, sizeof(*p)); 402 402 + va = p->va; 403 403 + 404 404 + p->frag.page_offset += RX_PAGE_SIZE; 405 405 + BUG_ON(p->frag.page_offset > PAGE_SIZE); 406 406 + p->va += RX_PAGE_SIZE; 407 407 + if (p->frag.page_offset == PAGE_SIZE) 408 408 + p->frag.page = NULL; 409 409 + else 410 410 + get_page(p->frag.page); 411 411 + } 412 412 + 413 413 + add_one_rx_buf(va, q->buf_size, d, sd, q->gen, adap->pdev); 414 414 + 423 415 d++; 424 416 sd++; 425 417 if (++q->pidx == q->size) { ··· 487 413 struct rx_desc *from = &q->desc[idx]; 488 414 struct rx_desc *to = &q->desc[q->pidx]; 489 415 490 490 - q->sdesc[q->pidx] = q->sdesc[idx]; 416 416 + memcpy(&q->sdesc[q->pidx], &q->sdesc[idx], sizeof(struct rx_sw_desc)); 491 417 to->addr_lo = from->addr_lo; /* already big endian */ 492 418 to->addr_hi = from->addr_hi; /* likewise */ 493 419 wmb(); ··· 520 446 * of the SW ring. 521 447 */ 522 448 static void *alloc_ring(struct pci_dev *pdev, size_t nelem, size_t elem_size, 523 523 - size_t sw_size, dma_addr_t *phys, void *metadata) 449 449 + size_t sw_size, dma_addr_t * phys, void *metadata) 524 450 { 525 451 size_t len = nelem * elem_size; 526 452 void *s = NULL; ··· 647 573 { 648 574 BUG_ON(n >= ARRAY_SIZE(flit_desc_map)); 649 575 return flit_desc_map[n]; 650 650 - } 651 651 - 652 652 - /** 653 653 - * get_packet - return the next ingress packet buffer from a free list 654 654 - * @adap: the adapter that received the packet 655 655 - * @fl: the SGE free list holding the packet 656 656 - * @len: the packet length including any SGE padding 657 657 - * @drop_thres: # of remaining buffers before we start dropping packets 658 658 - * 659 659 - * Get the next packet from a free list and complete setup of the 660 660 - * sk_buff. If the packet is small we make a copy and recycle the 661 661 - * original buffer, otherwise we use the original buffer itself. If a 662 662 - * positive drop threshold is supplied packets are dropped and their 663 663 - * buffers recycled if (a) the number of remaining buffers is under the 664 664 - * threshold and the packet is too big to copy, or (b) the packet should 665 665 - * be copied but there is no memory for the copy. 666 666 - */ 667 667 - static struct sk_buff *get_packet(struct adapter *adap, struct sge_fl *fl, 668 668 - unsigned int len, unsigned int drop_thres) 669 669 - { 670 670 - struct sk_buff *skb = NULL; 671 671 - struct rx_sw_desc *sd = &fl->sdesc[fl->cidx]; 672 672 - 673 673 - prefetch(sd->skb->data); 674 674 - 675 675 - if (len <= SGE_RX_COPY_THRES) { 676 676 - skb = alloc_skb(len, GFP_ATOMIC); 677 677 - if (likely(skb != NULL)) { 678 678 - __skb_put(skb, len); 679 679 - pci_dma_sync_single_for_cpu(adap->pdev, 680 680 - pci_unmap_addr(sd, 681 681 - dma_addr), 682 682 - len, PCI_DMA_FROMDEVICE); 683 683 - memcpy(skb->data, sd->skb->data, len); 684 684 - pci_dma_sync_single_for_device(adap->pdev, 685 685 - pci_unmap_addr(sd, 686 686 - dma_addr), 687 687 - len, PCI_DMA_FROMDEVICE); 688 688 - } else if (!drop_thres) 689 689 - goto use_orig_buf; 690 690 - recycle: 691 691 - recycle_rx_buf(adap, fl, fl->cidx); 692 692 - return skb; 693 693 - } 694 694 - 695 695 - if (unlikely(fl->credits < drop_thres)) 696 696 - goto recycle; 697 697 - 698 698 - use_orig_buf: 699 699 - pci_unmap_single(adap->pdev, pci_unmap_addr(sd, dma_addr), 700 700 - fl->buf_size, PCI_DMA_FROMDEVICE); 701 701 - skb = sd->skb; 702 702 - skb_put(skb, len); 703 703 - __refill_fl(adap, fl); 704 704 - return skb; 705 576 } 706 577 707 578 /** ··· 1246 1227 } 1247 1228 1248 1229 /** 1230 1230 + * deferred_unmap_destructor - unmap a packet when it is freed 1231 1231 + * @skb: the packet 1232 1232 + * 1233 1233 + * This is the packet destructor used for Tx packets that need to remain 1234 1234 + * mapped until they are freed rather than until their Tx descriptors are 1235 1235 + * freed. 1236 1236 + */ 1237 1237 + static void deferred_unmap_destructor(struct sk_buff *skb) 1238 1238 + { 1239 1239 + int i; 1240 1240 + const dma_addr_t *p; 1241 1241 + const struct skb_shared_info *si; 1242 1242 + const struct deferred_unmap_info *dui; 1243 1243 + const struct unmap_info *ui = (struct unmap_info *)skb->cb; 1244 1244 + 1245 1245 + dui = (struct deferred_unmap_info *)skb->head; 1246 1246 + p = dui->addr; 1247 1247 + 1248 1248 + if (ui->len) 1249 1249 + pci_unmap_single(dui->pdev, *p++, ui->len, PCI_DMA_TODEVICE); 1250 1250 + 1251 1251 + si = skb_shinfo(skb); 1252 1252 + for (i = 0; i < si->nr_frags; i++) 1253 1253 + pci_unmap_page(dui->pdev, *p++, si->frags[i].size, 1254 1254 + PCI_DMA_TODEVICE); 1255 1255 + } 1256 1256 + 1257 1257 + static void setup_deferred_unmapping(struct sk_buff *skb, struct pci_dev *pdev, 1258 1258 + const struct sg_ent *sgl, int sgl_flits) 1259 1259 + { 1260 1260 + dma_addr_t *p; 1261 1261 + struct deferred_unmap_info *dui; 1262 1262 + 1263 1263 + dui = (struct deferred_unmap_info *)skb->head; 1264 1264 + dui->pdev = pdev; 1265 1265 + for (p = dui->addr; sgl_flits >= 3; sgl++, sgl_flits -= 3) { 1266 1266 + *p++ = be64_to_cpu(sgl->addr[0]); 1267 1267 + *p++ = be64_to_cpu(sgl->addr[1]); 1268 1268 + } 1269 1269 + if (sgl_flits) 1270 1270 + *p = be64_to_cpu(sgl->addr[0]); 1271 1271 + } 1272 1272 + 1273 1273 + /** 1249 1274 * write_ofld_wr - write an offload work request 1250 1275 * @adap: the adapter 1251 1276 * @skb: the packet to send ··· 1325 1262 sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl; 1326 1263 sgl_flits = make_sgl(skb, sgp, skb->h.raw, skb->tail - skb->h.raw, 1327 1264 adap->pdev); 1328 1328 - if (need_skb_unmap()) 1265 1265 + if (need_skb_unmap()) { 1266 1266 + setup_deferred_unmapping(skb, adap->pdev, sgp, sgl_flits); 1267 1267 + skb->destructor = deferred_unmap_destructor; 1329 1268 ((struct unmap_info *)skb->cb)->len = skb->tail - skb->h.raw; 1269 1269 + } 1330 1270 1331 1271 write_wr_hdr_sgl(ndesc, skb, d, pidx, q, sgl, flits, sgl_flits, 1332 1272 gen, from->wr_hi, from->wr_lo); ··· 1683 1617 struct cpl_rx_pkt *p = (struct cpl_rx_pkt *)(skb->data + pad); 1684 1618 struct port_info *pi; 1685 1619 1686 1686 - rq->eth_pkts++; 1687 1620 skb_pull(skb, sizeof(*p) + pad); 1688 1621 skb->dev = adap->port[p->iff]; 1689 1622 skb->dev->last_rx = jiffies; ··· 1708 1643 netif_receive_skb(skb); 1709 1644 else 1710 1645 netif_rx(skb); 1646 1646 + } 1647 1647 + 1648 1648 + #define SKB_DATA_SIZE 128 1649 1649 + 1650 1650 + static void skb_data_init(struct sk_buff *skb, struct sge_fl_page *p, 1651 1651 + unsigned int len) 1652 1652 + { 1653 1653 + skb->len = len; 1654 1654 + if (len <= SKB_DATA_SIZE) { 1655 1655 + memcpy(skb->data, p->va, len); 1656 1656 + skb->tail += len; 1657 1657 + put_page(p->frag.page); 1658 1658 + } else { 1659 1659 + memcpy(skb->data, p->va, SKB_DATA_SIZE); 1660 1660 + skb_shinfo(skb)->frags[0].page = p->frag.page; 1661 1661 + skb_shinfo(skb)->frags[0].page_offset = 1662 1662 + p->frag.page_offset + SKB_DATA_SIZE; 1663 1663 + skb_shinfo(skb)->frags[0].size = len - SKB_DATA_SIZE; 1664 1664 + skb_shinfo(skb)->nr_frags = 1; 1665 1665 + skb->data_len = len - SKB_DATA_SIZE; 1666 1666 + skb->tail += SKB_DATA_SIZE; 1667 1667 + skb->truesize += skb->data_len; 1668 1668 + } 1669 1669 + } 1670 1670 + 1671 1671 + /** 1672 1672 + * get_packet - return the next ingress packet buffer from a free list 1673 1673 + * @adap: the adapter that received the packet 1674 1674 + * @fl: the SGE free list holding the packet 1675 1675 + * @len: the packet length including any SGE padding 1676 1676 + * @drop_thres: # of remaining buffers before we start dropping packets 1677 1677 + * 1678 1678 + * Get the next packet from a free list and complete setup of the 1679 1679 + * sk_buff. If the packet is small we make a copy and recycle the 1680 1680 + * original buffer, otherwise we use the original buffer itself. If a 1681 1681 + * positive drop threshold is supplied packets are dropped and their 1682 1682 + * buffers recycled if (a) the number of remaining buffers is under the 1683 1683 + * threshold and the packet is too big to copy, or (b) the packet should 1684 1684 + * be copied but there is no memory for the copy. 1685 1685 + */ 1686 1686 + static struct sk_buff *get_packet(struct adapter *adap, struct sge_fl *fl, 1687 1687 + unsigned int len, unsigned int drop_thres) 1688 1688 + { 1689 1689 + struct sk_buff *skb = NULL; 1690 1690 + struct rx_sw_desc *sd = &fl->sdesc[fl->cidx]; 1691 1691 + 1692 1692 + prefetch(sd->t.skb->data); 1693 1693 + 1694 1694 + if (len <= SGE_RX_COPY_THRES) { 1695 1695 + skb = alloc_skb(len, GFP_ATOMIC); 1696 1696 + if (likely(skb != NULL)) { 1697 1697 + struct rx_desc *d = &fl->desc[fl->cidx]; 1698 1698 + dma_addr_t mapping = 1699 1699 + (dma_addr_t)((u64) be32_to_cpu(d->addr_hi) << 32 | 1700 1700 + be32_to_cpu(d->addr_lo)); 1701 1701 + 1702 1702 + __skb_put(skb, len); 1703 1703 + pci_dma_sync_single_for_cpu(adap->pdev, mapping, len, 1704 1704 + PCI_DMA_FROMDEVICE); 1705 1705 + memcpy(skb->data, sd->t.skb->data, len); 1706 1706 + pci_dma_sync_single_for_device(adap->pdev, mapping, len, 1707 1707 + PCI_DMA_FROMDEVICE); 1708 1708 + } else if (!drop_thres) 1709 1709 + goto use_orig_buf; 1710 1710 + recycle: 1711 1711 + recycle_rx_buf(adap, fl, fl->cidx); 1712 1712 + return skb; 1713 1713 + } 1714 1714 + 1715 1715 + if (unlikely(fl->credits < drop_thres)) 1716 1716 + goto recycle; 1717 1717 + 1718 1718 + use_orig_buf: 1719 1719 + pci_unmap_single(adap->pdev, pci_unmap_addr(sd, dma_addr), 1720 1720 + fl->buf_size, PCI_DMA_FROMDEVICE); 1721 1721 + skb = sd->t.skb; 1722 1722 + skb_put(skb, len); 1723 1723 + __refill_fl(adap, fl); 1724 1724 + return skb; 1711 1725 } 1712 1726 1713 1727 /** ··· 1911 1767 q->next_holdoff = q->holdoff_tmr; 1912 1768 1913 1769 while (likely(budget_left && is_new_response(r, q))) { 1914 1914 - int eth, ethpad = 0; 1770 1770 + int eth, ethpad = 2; 1915 1771 struct sk_buff *skb = NULL; 1916 1772 u32 len, flags = ntohl(r->flags); 1917 1773 u32 rss_hi = *(const u32 *)r, rss_lo = r->rss_hdr.rss_hash_val; ··· 1938 1794 break; 1939 1795 } 1940 1796 q->imm_data++; 1797 1797 + ethpad = 0; 1941 1798 } else if ((len = ntohl(r->len_cq)) != 0) { 1942 1942 - struct sge_fl *fl; 1799 1799 + struct sge_fl *fl = 1800 1800 + (len & F_RSPD_FLQ) ? &qs->fl[1] : &qs->fl[0]; 1943 1801 1944 1944 - fl = (len & F_RSPD_FLQ) ? &qs->fl[1] : &qs->fl[0]; 1945 1945 - fl->credits--; 1946 1946 - skb = get_packet(adap, fl, G_RSPD_LEN(len), 1947 1947 - eth ? SGE_RX_DROP_THRES : 0); 1948 1948 - if (!skb) 1949 1949 - q->rx_drops++; 1950 1950 - else if (r->rss_hdr.opcode == CPL_TRACE_PKT) 1951 1951 - __skb_pull(skb, 2); 1952 1952 - ethpad = 2; 1802 1802 + if (fl->buf_size == RX_PAGE_SIZE) { 1803 1803 + struct rx_sw_desc *sd = &fl->sdesc[fl->cidx]; 1804 1804 + struct sge_fl_page *p = &sd->t.page; 1805 1805 + 1806 1806 + prefetch(p->va); 1807 1807 + prefetch(p->va + L1_CACHE_BYTES); 1808 1808 + 1809 1809 + __refill_fl(adap, fl); 1810 1810 + 1811 1811 + pci_unmap_single(adap->pdev, 1812 1812 + pci_unmap_addr(sd, dma_addr), 1813 1813 + fl->buf_size, 1814 1814 + PCI_DMA_FROMDEVICE); 1815 1815 + 1816 1816 + if (eth) { 1817 1817 + if (unlikely(fl->credits < 1818 1818 + SGE_RX_DROP_THRES)) 1819 1819 + goto eth_recycle; 1820 1820 + 1821 1821 + skb = alloc_skb(SKB_DATA_SIZE, 1822 1822 + GFP_ATOMIC); 1823 1823 + if (unlikely(!skb)) { 1824 1824 + eth_recycle: 1825 1825 + q->rx_drops++; 1826 1826 + recycle_rx_buf(adap, fl, 1827 1827 + fl->cidx); 1828 1828 + goto eth_done; 1829 1829 + } 1830 1830 + } else { 1831 1831 + skb = alloc_skb(SKB_DATA_SIZE, 1832 1832 + GFP_ATOMIC); 1833 1833 + if (unlikely(!skb)) 1834 1834 + goto no_mem; 1835 1835 + } 1836 1836 + 1837 1837 + skb_data_init(skb, p, G_RSPD_LEN(len)); 1838 1838 + eth_done: 1839 1839 + fl->credits--; 1840 1840 + q->eth_pkts++; 1841 1841 + } else { 1842 1842 + fl->credits--; 1843 1843 + skb = get_packet(adap, fl, G_RSPD_LEN(len), 1844 1844 + eth ? SGE_RX_DROP_THRES : 0); 1845 1845 + } 1846 1846 + 1953 1847 if (++fl->cidx == fl->size) 1954 1848 fl->cidx = 0; 1955 1849 } else ··· 2011 1829 q->credits = 0; 2012 1830 } 2013 1831 2014 2014 - if (likely(skb != NULL)) { 1832 1832 + if (skb) { 1833 1833 + /* Preserve the RSS info in csum & priority */ 1834 1834 + skb->csum = rss_hi; 1835 1835 + skb->priority = rss_lo; 1836 1836 + 2015 1837 if (eth) 2016 1838 rx_eth(adap, q, skb, ethpad); 2017 1839 else { 2018 2018 - /* Preserve the RSS info in csum & priority */ 2019 2019 - skb->csum = rss_hi; 2020 2020 - skb->priority = rss_lo; 2021 2021 - ngathered = rx_offload(&adap->tdev, q, skb, 2022 2022 - offload_skbs, ngathered); 1840 1840 + if (unlikely(r->rss_hdr.opcode == 1841 1841 + CPL_TRACE_PKT)) 1842 1842 + __skb_pull(skb, ethpad); 1843 1843 + 1844 1844 + ngathered = rx_offload(&adap->tdev, q, 1845 1845 + skb, offload_skbs, 1846 1846 + ngathered); 2023 1847 } 2024 1848 } 2025 2025 - 2026 1849 --budget_left; 2027 1850 } 2028 1851 ··· 2507 2320 &adap->sge.qs[0].rspq.lock; 2508 2321 if (spin_trylock_irq(lock)) { 2509 2322 if (!napi_is_scheduled(qs->netdev)) { 2323 2323 + u32 status = t3_read_reg(adap, A_SG_RSPQ_FL_STATUS); 2324 2324 + 2510 2325 if (qs->fl[0].credits < qs->fl[0].size) 2511 2326 __refill_fl(adap, &qs->fl[0]); 2512 2327 if (qs->fl[1].credits < qs->fl[1].size) 2513 2328 __refill_fl(adap, &qs->fl[1]); 2329 2329 + 2330 2330 + if (status & (1 << qs->rspq.cntxt_id)) { 2331 2331 + qs->rspq.starved++; 2332 2332 + if (qs->rspq.credits) { 2333 2333 + refill_rspq(adap, &qs->rspq, 1); 2334 2334 + qs->rspq.credits--; 2335 2335 + qs->rspq.restarted++; 2336 2336 + t3_write_reg(adap, A_SG_RSPQ_FL_STATUS, 2337 2337 + 1 << qs->rspq.cntxt_id); 2338 2338 + } 2339 2339 + } 2514 2340 } 2515 2341 spin_unlock_irq(lock); 2516 2342 } ··· 2632 2432 flits_to_desc(sgl_len(MAX_SKB_FRAGS + 1) + 3); 2633 2433 2634 2434 if (ntxq == 1) { 2435 2435 + #ifdef USE_RX_PAGE 2436 2436 + q->fl[0].buf_size = RX_PAGE_SIZE; 2437 2437 + #else 2635 2438 q->fl[0].buf_size = SGE_RX_SM_BUF_SIZE + 2 + 2636 2439 sizeof(struct cpl_rx_pkt); 2440 2440 + #endif 2637 2441 q->fl[1].buf_size = MAX_FRAME_SIZE + 2 + 2638 2442 sizeof(struct cpl_rx_pkt); 2639 2443 } else { 2444 2444 + #ifdef USE_RX_PAGE 2445 2445 + q->fl[0].buf_size = RX_PAGE_SIZE; 2446 2446 + #else 2640 2447 q->fl[0].buf_size = SGE_RX_SM_BUF_SIZE + 2641 2448 sizeof(struct cpl_rx_data); 2449 2449 + #endif 2642 2450 q->fl[1].buf_size = (16 * 1024) - 2643 2451 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); 2644 2452 } ··· 2840 2632 q->polling = adap->params.rev > 0; 2841 2633 q->coalesce_usecs = 5; 2842 2634 q->rspq_size = 1024; 2843 2843 - q->fl_size = 4096; 2635 2635 + q->fl_size = 1024; 2844 2636 q->jumbo_size = 512; 2845 2637 q->txq_size[TXQ_ETH] = 1024; 2846 2638 q->txq_size[TXQ_OFLD] = 1024;

+4 -2

drivers/net/cxgb3/t3_hw.c

reviewed

··· 884 884 major = G_FW_VERSION_MAJOR(vers); 885 885 minor = G_FW_VERSION_MINOR(vers); 886 886 887 887 - if (type == FW_VERSION_T3 && major == 3 && minor == 1) 887 887 + if (type == FW_VERSION_T3 && major == FW_VERSION_MAJOR && 888 888 + minor == FW_VERSION_MINOR) 888 889 return 0; 889 890 890 891 CH_ERR(adapter, "found wrong FW version(%u.%u), " 891 891 - "driver needs version 3.1\n", major, minor); 892 892 + "driver needs version %u.%u\n", major, minor, 893 893 + FW_VERSION_MAJOR, FW_VERSION_MINOR); 892 894 return -EINVAL; 893 895 } 894 896

+2

drivers/net/cxgb3/version.h

reviewed

··· 36 36 #define DRV_NAME "cxgb3" 37 37 /* Driver version */ 38 38 #define DRV_VERSION "1.0" 39 39 + #define FW_VERSION_MAJOR 3 40 40 + #define FW_VERSION_MINOR 2 39 41 #endif /* __CHELSIO_VERSION_H */

-6

drivers/net/de600.c

reviewed

··· 38 38 /* Add more time here if your adapter won't work OK: */ 39 39 #define DE600_SLOW_DOWN udelay(delay_time) 40 40 41 41 - /* 42 42 - * If you still have trouble reading/writing to the adapter, 43 43 - * modify the following "#define": (see <asm/io.h> for more info) 44 44 - #define REALLY_SLOW_IO 45 45 - */ 46 46 - 47 41 /* use 0 for production, 1 for verification, >2 for debug */ 48 42 #ifdef DE600_DEBUG 49 43 #define PRINTK(x) if (de600_debug >= 2) printk x

+12 -8

drivers/net/forcedeth.c

reviewed

··· 839 839 NV_MSIX_INT_DISABLED, 840 840 NV_MSIX_INT_ENABLED 841 841 }; 842 842 - static int msix = NV_MSIX_INT_ENABLED; 842 842 + static int msix = NV_MSIX_INT_DISABLED; 843 843 844 844 /* 845 845 * DMA 64bit ··· 3104 3104 struct fe_priv *np = netdev_priv(dev); 3105 3105 u8 __iomem *base = get_hwbase(dev); 3106 3106 unsigned long flags; 3107 3107 + int retcode; 3107 3108 3108 3108 - if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) 3109 3109 + if (np->desc_ver == DESC_VER_1 || np->desc_ver == DESC_VER_2) { 3109 3110 pkts = nv_rx_process(dev, limit); 3110 3110 - else 3111 3111 + retcode = nv_alloc_rx(dev); 3112 3112 + } else { 3111 3113 pkts = nv_rx_process_optimized(dev, limit); 3114 3114 + retcode = nv_alloc_rx_optimized(dev); 3115 3115 + } 3112 3116 3113 3113 - if (nv_alloc_rx(dev)) { 3117 3117 + if (retcode) { 3114 3118 spin_lock_irqsave(&np->lock, flags); 3115 3119 if (!np->in_shutdown) 3116 3120 mod_timer(&np->oom_kick, jiffies + OOM_REFILL); ··· 5374 5370 }, 5375 5371 { /* MCP65 Ethernet Controller */ 5376 5372 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_20), 5377 5377 - .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5373 5373 + .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5378 5374 }, 5379 5375 { /* MCP65 Ethernet Controller */ 5380 5376 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_21), 5381 5381 - .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5377 5377 + .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5382 5378 }, 5383 5379 { /* MCP65 Ethernet Controller */ 5384 5380 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_22), 5385 5385 - .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5381 5381 + .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5386 5382 }, 5387 5383 { /* MCP65 Ethernet Controller */ 5388 5384 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_23), 5389 5389 - .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5385 5385 + .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT, 5390 5386 }, 5391 5387 { /* MCP67 Ethernet Controller */ 5392 5388 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_24),

+3 -3

drivers/net/mv643xx_eth.c

reviewed

··· 147 147 int unaligned; 148 148 149 149 while (mp->rx_desc_count < mp->rx_ring_size) { 150 150 - skb = dev_alloc_skb(ETH_RX_SKB_SIZE + ETH_DMA_ALIGN); 150 150 + skb = dev_alloc_skb(ETH_RX_SKB_SIZE + dma_get_cache_alignment()); 151 151 if (!skb) 152 152 break; 153 153 mp->rx_desc_count++; 154 154 - unaligned = (u32)skb->data & (ETH_DMA_ALIGN - 1); 154 154 + unaligned = (u32)skb->data & (dma_get_cache_alignment() - 1); 155 155 if (unaligned) 156 156 - skb_reserve(skb, ETH_DMA_ALIGN - unaligned); 156 156 + skb_reserve(skb, dma_get_cache_alignment() - unaligned); 157 157 pkt_info.cmd_sts = ETH_RX_ENABLE_INTERRUPT; 158 158 pkt_info.byte_cnt = ETH_RX_SKB_SIZE; 159 159 pkt_info.buf_ptr = dma_map_single(NULL, skb->data,

-11

drivers/net/mv643xx_eth.h

reviewed

··· 42 42 #define MAX_DESCS_PER_SKB 1 43 43 #endif 44 44 45 45 - /* 46 46 - * The MV643XX HW requires 8-byte alignment. However, when I/O 47 47 - * is non-cache-coherent, we need to ensure that the I/O buffers 48 48 - * we use don't share cache lines with other data. 49 49 - */ 50 50 - #if defined(CONFIG_DMA_NONCOHERENT) || defined(CONFIG_NOT_COHERENT_CACHE) 51 51 - #define ETH_DMA_ALIGN L1_CACHE_BYTES 52 52 - #else 53 53 - #define ETH_DMA_ALIGN 8 54 54 - #endif 55 55 - 56 45 #define ETH_VLAN_HLEN 4 57 46 #define ETH_FCS_LEN 4 58 47 #define ETH_HW_IP_ALIGN 2 /* hw aligns IP header */

+23 -4

drivers/net/myri10ge/myri10ge.c

reviewed

··· 195 195 char *fw_name; 196 196 char eeprom_strings[MYRI10GE_EEPROM_STRINGS_SIZE]; 197 197 char fw_version[128]; 198 198 + int fw_ver_major; 199 199 + int fw_ver_minor; 200 200 + int fw_ver_tiny; 201 201 + int adopted_rx_filter_bug; 198 202 u8 mac_addr[6]; /* eeprom mac address */ 199 203 unsigned long serial_number; 200 204 int vendor_specific_offset; ··· 451 447 struct mcp_gen_header *hdr) 452 448 { 453 449 struct device *dev = &mgp->pdev->dev; 454 454 - int major, minor; 455 450 456 451 /* check firmware type */ 457 452 if (ntohl(hdr->mcp_type) != MCP_TYPE_ETH) { ··· 461 458 /* save firmware version for ethtool */ 462 459 strncpy(mgp->fw_version, hdr->version, sizeof(mgp->fw_version)); 463 460 464 464 - sscanf(mgp->fw_version, "%d.%d", &major, &minor); 461 461 + sscanf(mgp->fw_version, "%d.%d.%d", &mgp->fw_ver_major, 462 462 + &mgp->fw_ver_minor, &mgp->fw_ver_tiny); 465 463 466 466 - if (!(major == MXGEFW_VERSION_MAJOR && minor == MXGEFW_VERSION_MINOR)) { 464 464 + if (!(mgp->fw_ver_major == MXGEFW_VERSION_MAJOR 465 465 + && mgp->fw_ver_minor == MXGEFW_VERSION_MINOR)) { 467 466 dev_err(dev, "Found firmware version %s\n", mgp->fw_version); 468 467 dev_err(dev, "Driver needs %d.%d\n", MXGEFW_VERSION_MAJOR, 469 468 MXGEFW_VERSION_MINOR); ··· 566 561 memcpy_fromio(hdr, mgp->sram + hdr_offset, bytes); 567 562 status = myri10ge_validate_firmware(mgp, hdr); 568 563 kfree(hdr); 564 564 + 565 565 + /* check to see if adopted firmware has bug where adopting 566 566 + * it will cause broadcasts to be filtered unless the NIC 567 567 + * is kept in ALLMULTI mode */ 568 568 + if (mgp->fw_ver_major == 1 && mgp->fw_ver_minor == 4 && 569 569 + mgp->fw_ver_tiny >= 4 && mgp->fw_ver_tiny <= 11) { 570 570 + mgp->adopted_rx_filter_bug = 1; 571 571 + dev_warn(dev, "Adopting fw %d.%d.%d: " 572 572 + "working around rx filter bug\n", 573 573 + mgp->fw_ver_major, mgp->fw_ver_minor, 574 574 + mgp->fw_ver_tiny); 575 575 + } 569 576 return status; 570 577 } 571 578 ··· 811 794 status = myri10ge_update_mac_address(mgp, mgp->dev->dev_addr); 812 795 myri10ge_change_promisc(mgp, 0, 0); 813 796 myri10ge_change_pause(mgp, mgp->pause); 797 797 + if (mgp->adopted_rx_filter_bug) 798 798 + (void)myri10ge_send_cmd(mgp, MXGEFW_ENABLE_ALLMULTI, &cmd, 1); 814 799 return status; 815 800 } 816 801 ··· 2258 2239 myri10ge_change_promisc(mgp, dev->flags & IFF_PROMISC, 1); 2259 2240 2260 2241 /* This firmware is known to not support multicast */ 2261 2261 - if (!mgp->fw_multicast_support) 2242 2242 + if (!mgp->fw_multicast_support || mgp->adopted_rx_filter_bug) 2262 2243 return; 2263 2244 2264 2245 /* Disable multicast filtering */

+1 -1

drivers/net/natsemi.c

reviewed

··· 260 260 261 261 static const struct pci_device_id natsemi_pci_tbl[] __devinitdata = { 262 262 { PCI_VENDOR_ID_NS, 0x0020, 0x12d9, 0x000c, 0, 0, 0 }, 263 263 - { PCI_VENDOR_ID_NS, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 263 263 + { PCI_VENDOR_ID_NS, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 }, 264 264 { } /* terminate list */ 265 265 }; 266 266 MODULE_DEVICE_TABLE(pci, natsemi_pci_tbl);

+5 -4

drivers/net/netxen/netxen_nic_hw.c

reviewed

··· 242 242 adapter->cmd_consumer = (uint32_t *) (((char *)addr) + 243 243 sizeof(struct netxen_ring_ctx)); 244 244 245 245 - addr = pci_alloc_consistent(adapter->ahw.pdev, 246 246 - sizeof(struct cmd_desc_type0) * 247 247 - adapter->max_tx_desc_count, 248 248 - (dma_addr_t *) & hw->cmd_desc_phys_addr); 245 245 + addr = netxen_alloc(adapter->ahw.pdev, 246 246 + sizeof(struct cmd_desc_type0) * 247 247 + adapter->max_tx_desc_count, 248 248 + (dma_addr_t *) & hw->cmd_desc_phys_addr, 249 249 + &adapter->ahw.cmd_desc_pdev); 249 250 printk("cmd_desc_phys_addr: 0x%llx\n", (u64) hw->cmd_desc_phys_addr); 250 251 251 252 if (addr == NULL) {

+4 -1

drivers/net/netxen/netxen_nic_init.c

reviewed

··· 499 499 while(1) { 500 500 int data1; 501 501 502 502 - do_rom_fast_read(adapter, addridx, &data1); 502 502 + ret = do_rom_fast_read(adapter, addridx, &data1); 503 503 + if (ret < 0) 504 504 + return ret; 505 505 + 503 506 if (data1 == data) 504 507 break; 505 508

+3 -3

drivers/net/netxen/netxen_nic_main.c

reviewed

··· 525 525 if (adapter == NULL) 526 526 return; 527 527 528 528 + if (adapter->irq) 529 529 + free_irq(adapter->irq, adapter); 528 530 netxen_nic_stop_all_ports(adapter); 529 531 /* leave the hw in the same state as reboot */ 530 532 netxen_pinit_from_rom(adapter, 0); ··· 674 672 675 673 if (!adapter->active_ports) { 676 674 netxen_nic_disable_int(adapter); 677 677 - if (adapter->irq) 678 678 - free_irq(adapter->irq, adapter); 679 675 cmd_buff = adapter->cmd_buf_arr; 680 676 for (i = 0; i < adapter->max_tx_desc_count; i++) { 681 677 buffrag = cmd_buff->frag_array; ··· 1155 1155 /* 1156 1156 * Wait for some time to allow the dma to drain, if any. 1157 1157 */ 1158 1158 - destroy_workqueue(netxen_workq); 1159 1158 pci_unregister_driver(&netxen_driver); 1159 1159 + destroy_workqueue(netxen_workq); 1160 1160 } 1161 1161 1162 1162 module_exit(netxen_exit_module);

-2

drivers/net/ni52.c

reviewed

··· 104 104 static int rfdadd; /* rfdadd=1 may be better for 8K MEM cards */ 105 105 static int fifo=0x8; /* don't change */ 106 106 107 107 - /* #define REALLY_SLOW_IO */ 108 108 - 109 107 #include <linux/module.h> 110 108 #include <linux/kernel.h> 111 109 #include <linux/string.h>

+352 -200

drivers/net/qla3xxx.c

reviewed

··· 39 39 40 40 #define DRV_NAME "qla3xxx" 41 41 #define DRV_STRING "QLogic ISP3XXX Network Driver" 42 42 - #define DRV_VERSION "v2.02.00-k36" 42 42 + #define DRV_VERSION "v2.03.00-k3" 43 43 #define PFX DRV_NAME " " 44 44 45 45 static const char ql3xxx_driver_name[] = DRV_NAME; ··· 276 276 static void ql_release_to_lrg_buf_free_list(struct ql3_adapter *qdev, 277 277 struct ql_rcv_buf_cb *lrg_buf_cb) 278 278 { 279 279 - u64 map; 279 279 + dma_addr_t map; 280 280 + int err; 280 281 lrg_buf_cb->next = NULL; 281 282 282 283 if (qdev->lrg_buf_free_tail == NULL) { /* The list is empty */ ··· 288 287 } 289 288 290 289 if (!lrg_buf_cb->skb) { 291 291 - lrg_buf_cb->skb = dev_alloc_skb(qdev->lrg_buffer_len); 290 290 + lrg_buf_cb->skb = netdev_alloc_skb(qdev->ndev, 291 291 + qdev->lrg_buffer_len); 292 292 if (unlikely(!lrg_buf_cb->skb)) { 293 293 - printk(KERN_ERR PFX "%s: failed dev_alloc_skb().\n", 293 293 + printk(KERN_ERR PFX "%s: failed netdev_alloc_skb().\n", 294 294 qdev->ndev->name); 295 295 qdev->lrg_buf_skb_check++; 296 296 } else { ··· 305 303 qdev->lrg_buffer_len - 306 304 QL_HEADER_SPACE, 307 305 PCI_DMA_FROMDEVICE); 306 306 + err = pci_dma_mapping_error(map); 307 307 + if(err) { 308 308 + printk(KERN_ERR "%s: PCI mapping failed with error: %d\n", 309 309 + qdev->ndev->name, err); 310 310 + dev_kfree_skb(lrg_buf_cb->skb); 311 311 + lrg_buf_cb->skb = NULL; 312 312 + 313 313 + qdev->lrg_buf_skb_check++; 314 314 + return; 315 315 + } 316 316 + 308 317 lrg_buf_cb->buf_phy_addr_low = 309 318 cpu_to_le32(LS_64BITS(map)); 310 319 lrg_buf_cb->buf_phy_addr_high = ··· 1400 1387 printk(KERN_INFO PFX 1401 1388 "%s: Reset in progress, skip processing link " 1402 1389 "state.\n", qdev->ndev->name); 1390 1390 + 1391 1391 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 1403 1392 return; 1404 1393 } 1405 1394 ··· 1533 1518 spin_lock_irqsave(&qdev->hw_lock, hw_flags); 1534 1519 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK, 1535 1520 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) * 1536 1536 - 2) << 7)) 1521 1521 + 2) << 7)) { 1522 1522 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 1537 1523 return 0; 1524 1524 + } 1538 1525 status = ql_is_auto_cfg(qdev); 1539 1526 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK); 1540 1527 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); ··· 1550 1533 spin_lock_irqsave(&qdev->hw_lock, hw_flags); 1551 1534 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK, 1552 1535 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) * 1553 1553 - 2) << 7)) 1536 1536 + 2) << 7)) { 1537 1537 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 1554 1538 return 0; 1539 1539 + } 1555 1540 status = ql_get_link_speed(qdev); 1556 1541 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK); 1557 1542 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); ··· 1567 1548 spin_lock_irqsave(&qdev->hw_lock, hw_flags); 1568 1549 if(ql_sem_spinlock(qdev, QL_PHY_GIO_SEM_MASK, 1569 1550 (QL_RESOURCE_BITS_BASE_CODE | (qdev->mac_index) * 1570 1570 - 2) << 7)) 1551 1551 + 2) << 7)) { 1552 1552 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 1571 1553 return 0; 1554 1554 + } 1572 1555 status = ql_is_link_full_dup(qdev); 1573 1556 ql_sem_unlock(qdev, QL_PHY_GIO_SEM_MASK); 1574 1557 spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); ··· 1636 1615 static int ql_populate_free_queue(struct ql3_adapter *qdev) 1637 1616 { 1638 1617 struct ql_rcv_buf_cb *lrg_buf_cb = qdev->lrg_buf_free_head; 1639 1639 - u64 map; 1618 1618 + dma_addr_t map; 1619 1619 + int err; 1640 1620 1641 1621 while (lrg_buf_cb) { 1642 1622 if (!lrg_buf_cb->skb) { 1643 1643 - lrg_buf_cb->skb = dev_alloc_skb(qdev->lrg_buffer_len); 1623 1623 + lrg_buf_cb->skb = netdev_alloc_skb(qdev->ndev, 1624 1624 + qdev->lrg_buffer_len); 1644 1625 if (unlikely(!lrg_buf_cb->skb)) { 1645 1626 printk(KERN_DEBUG PFX 1646 1646 - "%s: Failed dev_alloc_skb().\n", 1627 1627 + "%s: Failed netdev_alloc_skb().\n", 1647 1628 qdev->ndev->name); 1648 1629 break; 1649 1630 } else { ··· 1659 1636 qdev->lrg_buffer_len - 1660 1637 QL_HEADER_SPACE, 1661 1638 PCI_DMA_FROMDEVICE); 1639 1639 + 1640 1640 + err = pci_dma_mapping_error(map); 1641 1641 + if(err) { 1642 1642 + printk(KERN_ERR "%s: PCI mapping failed with error: %d\n", 1643 1643 + qdev->ndev->name, err); 1644 1644 + dev_kfree_skb(lrg_buf_cb->skb); 1645 1645 + lrg_buf_cb->skb = NULL; 1646 1646 + break; 1647 1647 + } 1648 1648 + 1649 1649 + 1662 1650 lrg_buf_cb->buf_phy_addr_low = 1663 1651 cpu_to_le32(LS_64BITS(map)); 1664 1652 lrg_buf_cb->buf_phy_addr_high = ··· 1724 1690 1725 1691 qdev->lrg_buf_q_producer_index++; 1726 1692 1727 1727 - if (qdev->lrg_buf_q_producer_index == NUM_LBUFQ_ENTRIES) 1693 1693 + if (qdev->lrg_buf_q_producer_index == qdev->num_lbufq_entries) 1728 1694 qdev->lrg_buf_q_producer_index = 0; 1729 1695 1730 1696 if (qdev->lrg_buf_q_producer_index == 1731 1731 - (NUM_LBUFQ_ENTRIES - 1)) { 1697 1697 + (qdev->num_lbufq_entries - 1)) { 1732 1698 lrg_buf_q_ele = qdev->lrg_buf_q_virt_addr; 1733 1699 } 1734 1700 } ··· 1747 1713 { 1748 1714 struct ql_tx_buf_cb *tx_cb; 1749 1715 int i; 1716 1716 + int retval = 0; 1750 1717 1718 1718 + if(mac_rsp->flags & OB_MAC_IOCB_RSP_S) { 1719 1719 + printk(KERN_WARNING "Frame short but, frame was padded and sent.\n"); 1720 1720 + } 1721 1721 + 1751 1722 tx_cb = &qdev->tx_buf[mac_rsp->transaction_id]; 1723 1723 + 1724 1724 + /* Check the transmit response flags for any errors */ 1725 1725 + if(mac_rsp->flags & OB_MAC_IOCB_RSP_S) { 1726 1726 + printk(KERN_ERR "Frame too short to be legal, frame not sent.\n"); 1727 1727 + 1728 1728 + qdev->stats.tx_errors++; 1729 1729 + retval = -EIO; 1730 1730 + goto frame_not_sent; 1731 1731 + } 1732 1732 + 1733 1733 + if(tx_cb->seg_count == 0) { 1734 1734 + printk(KERN_ERR "tx_cb->seg_count == 0: %d\n", mac_rsp->transaction_id); 1735 1735 + 1736 1736 + qdev->stats.tx_errors++; 1737 1737 + retval = -EIO; 1738 1738 + goto invalid_seg_count; 1739 1739 + } 1740 1740 + 1752 1741 pci_unmap_single(qdev->pdev, 1753 1742 pci_unmap_addr(&tx_cb->map[0], mapaddr), 1754 1743 pci_unmap_len(&tx_cb->map[0], maplen), ··· 1788 1731 } 1789 1732 qdev->stats.tx_packets++; 1790 1733 qdev->stats.tx_bytes += tx_cb->skb->len; 1734 1734 + 1735 1735 + frame_not_sent: 1791 1736 dev_kfree_skb_irq(tx_cb->skb); 1792 1737 tx_cb->skb = NULL; 1738 1738 + 1739 1739 + invalid_seg_count: 1793 1740 atomic_inc(&qdev->tx_count); 1741 1741 + } 1742 1742 + 1743 1743 + void ql_get_sbuf(struct ql3_adapter *qdev) 1744 1744 + { 1745 1745 + if (++qdev->small_buf_index == NUM_SMALL_BUFFERS) 1746 1746 + qdev->small_buf_index = 0; 1747 1747 + qdev->small_buf_release_cnt++; 1748 1748 + } 1749 1749 + 1750 1750 + struct ql_rcv_buf_cb *ql_get_lbuf(struct ql3_adapter *qdev) 1751 1751 + { 1752 1752 + struct ql_rcv_buf_cb *lrg_buf_cb = NULL; 1753 1753 + lrg_buf_cb = &qdev->lrg_buf[qdev->lrg_buf_index]; 1754 1754 + qdev->lrg_buf_release_cnt++; 1755 1755 + if (++qdev->lrg_buf_index == qdev->num_large_buffers) 1756 1756 + qdev->lrg_buf_index = 0; 1757 1757 + return(lrg_buf_cb); 1794 1758 } 1795 1759 1796 1760 /* ··· 1829 1751 static void ql_process_mac_rx_intr(struct ql3_adapter *qdev, 1830 1752 struct ib_mac_iocb_rsp *ib_mac_rsp_ptr) 1831 1753 { 1832 1832 - long int offset; 1833 1833 - u32 lrg_buf_phy_addr_low = 0; 1834 1754 struct ql_rcv_buf_cb *lrg_buf_cb1 = NULL; 1835 1755 struct ql_rcv_buf_cb *lrg_buf_cb2 = NULL; 1836 1836 - u32 *curr_ial_ptr; 1837 1756 struct sk_buff *skb; 1838 1757 u16 length = le16_to_cpu(ib_mac_rsp_ptr->length); 1839 1758 1840 1759 /* 1841 1760 * Get the inbound address list (small buffer). 1842 1761 */ 1843 1843 - offset = qdev->small_buf_index * QL_SMALL_BUFFER_SIZE; 1844 1844 - if (++qdev->small_buf_index == NUM_SMALL_BUFFERS) 1845 1845 - qdev->small_buf_index = 0; 1762 1762 + ql_get_sbuf(qdev); 1846 1763 1847 1847 - curr_ial_ptr = (u32 *) (qdev->small_buf_virt_addr + offset); 1848 1848 - qdev->last_rsp_offset = qdev->small_buf_phy_addr_low + offset; 1849 1849 - qdev->small_buf_release_cnt++; 1850 1850 - 1851 1851 - if (qdev->device_id == QL3022_DEVICE_ID) { 1852 1852 - /* start of first buffer (3022 only) */ 1853 1853 - lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr); 1854 1854 - lrg_buf_cb1 = &qdev->lrg_buf[qdev->lrg_buf_index]; 1855 1855 - qdev->lrg_buf_release_cnt++; 1856 1856 - if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS) { 1857 1857 - qdev->lrg_buf_index = 0; 1858 1858 - } 1859 1859 - curr_ial_ptr++; /* 64-bit pointers require two incs. */ 1860 1860 - curr_ial_ptr++; 1861 1861 - } 1764 1764 + if (qdev->device_id == QL3022_DEVICE_ID) 1765 1765 + lrg_buf_cb1 = ql_get_lbuf(qdev); 1862 1766 1863 1767 /* start of second buffer */ 1864 1864 - lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr); 1865 1865 - lrg_buf_cb2 = &qdev->lrg_buf[qdev->lrg_buf_index]; 1866 1866 - 1867 1867 - /* 1868 1868 - * Second buffer gets sent up the stack. 1869 1869 - */ 1870 1870 - qdev->lrg_buf_release_cnt++; 1871 1871 - if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS) 1872 1872 - qdev->lrg_buf_index = 0; 1768 1768 + lrg_buf_cb2 = ql_get_lbuf(qdev); 1873 1769 skb = lrg_buf_cb2->skb; 1874 1770 1875 1771 qdev->stats.rx_packets++; ··· 1871 1819 static void ql_process_macip_rx_intr(struct ql3_adapter *qdev, 1872 1820 struct ib_ip_iocb_rsp *ib_ip_rsp_ptr) 1873 1821 { 1874 1874 - long int offset; 1875 1875 - u32 lrg_buf_phy_addr_low = 0; 1876 1822 struct ql_rcv_buf_cb *lrg_buf_cb1 = NULL; 1877 1823 struct ql_rcv_buf_cb *lrg_buf_cb2 = NULL; 1878 1878 - u32 *curr_ial_ptr; 1879 1824 struct sk_buff *skb1 = NULL, *skb2; 1880 1825 struct net_device *ndev = qdev->ndev; 1881 1826 u16 length = le16_to_cpu(ib_ip_rsp_ptr->length); ··· 1882 1833 * Get the inbound address list (small buffer). 1883 1834 */ 1884 1835 1885 1885 - offset = qdev->small_buf_index * QL_SMALL_BUFFER_SIZE; 1886 1886 - if (++qdev->small_buf_index == NUM_SMALL_BUFFERS) 1887 1887 - qdev->small_buf_index = 0; 1888 1888 - curr_ial_ptr = (u32 *) (qdev->small_buf_virt_addr + offset); 1889 1889 - qdev->last_rsp_offset = qdev->small_buf_phy_addr_low + offset; 1890 1890 - qdev->small_buf_release_cnt++; 1836 1836 + ql_get_sbuf(qdev); 1891 1837 1892 1838 if (qdev->device_id == QL3022_DEVICE_ID) { 1893 1839 /* start of first buffer on 3022 */ 1894 1894 - lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr); 1895 1895 - lrg_buf_cb1 = &qdev->lrg_buf[qdev->lrg_buf_index]; 1896 1896 - qdev->lrg_buf_release_cnt++; 1897 1897 - if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS) 1898 1898 - qdev->lrg_buf_index = 0; 1840 1840 + lrg_buf_cb1 = ql_get_lbuf(qdev); 1899 1841 skb1 = lrg_buf_cb1->skb; 1900 1900 - curr_ial_ptr++; /* 64-bit pointers require two incs. */ 1901 1901 - curr_ial_ptr++; 1902 1842 size = ETH_HLEN; 1903 1843 if (*((u16 *) skb1->data) != 0xFFFF) 1904 1844 size += VLAN_ETH_HLEN - ETH_HLEN; 1905 1845 } 1906 1846 1907 1847 /* start of second buffer */ 1908 1908 - lrg_buf_phy_addr_low = le32_to_cpu(*curr_ial_ptr); 1909 1909 - lrg_buf_cb2 = &qdev->lrg_buf[qdev->lrg_buf_index]; 1848 1848 + lrg_buf_cb2 = ql_get_lbuf(qdev); 1910 1849 skb2 = lrg_buf_cb2->skb; 1911 1911 - qdev->lrg_buf_release_cnt++; 1912 1912 - if (++qdev->lrg_buf_index == NUM_LARGE_BUFFERS) 1913 1913 - qdev->lrg_buf_index = 0; 1914 1850 1915 1851 skb_put(skb2, length); /* Just the second buffer length here. */ 1916 1852 pci_unmap_single(qdev->pdev, ··· 1948 1914 struct net_rsp_iocb *net_rsp; 1949 1915 struct net_device *ndev = qdev->ndev; 1950 1916 unsigned long hw_flags; 1917 1917 + int work_done = 0; 1918 1918 + 1919 1919 + u32 rsp_producer_index = le32_to_cpu(*(qdev->prsp_producer_index)); 1951 1920 1952 1921 /* While there are entries in the completion queue. */ 1953 1953 - while ((cpu_to_le32(*(qdev->prsp_producer_index)) != 1954 1954 - qdev->rsp_consumer_index) && (*rx_cleaned < work_to_do)) { 1922 1922 + while ((rsp_producer_index != 1923 1923 + qdev->rsp_consumer_index) && (work_done < work_to_do)) { 1955 1924 1956 1925 net_rsp = qdev->rsp_current; 1957 1926 switch (net_rsp->opcode) { ··· 2005 1968 } else { 2006 1969 qdev->rsp_current++; 2007 1970 } 1971 1971 + 1972 1972 + work_done = *tx_cleaned + *rx_cleaned; 2008 1973 } 2009 1974 2010 2010 - spin_lock_irqsave(&qdev->hw_lock, hw_flags); 1975 1975 + if(work_done) { 1976 1976 + spin_lock_irqsave(&qdev->hw_lock, hw_flags); 2011 1977 2012 2012 - ql_update_lrg_bufq_prod_index(qdev); 1978 1978 + ql_update_lrg_bufq_prod_index(qdev); 2013 1979 2014 2014 - if (qdev->small_buf_release_cnt >= 16) { 2015 2015 - while (qdev->small_buf_release_cnt >= 16) { 2016 2016 - qdev->small_buf_q_producer_index++; 1980 1980 + if (qdev->small_buf_release_cnt >= 16) { 1981 1981 + while (qdev->small_buf_release_cnt >= 16) { 1982 1982 + qdev->small_buf_q_producer_index++; 2017 1983 2018 2018 - if (qdev->small_buf_q_producer_index == 2019 2019 - NUM_SBUFQ_ENTRIES) 2020 2020 - qdev->small_buf_q_producer_index = 0; 2021 2021 - qdev->small_buf_release_cnt -= 8; 1984 1984 + if (qdev->small_buf_q_producer_index == 1985 1985 + NUM_SBUFQ_ENTRIES) 1986 1986 + qdev->small_buf_q_producer_index = 0; 1987 1987 + qdev->small_buf_release_cnt -= 8; 1988 1988 + } 1989 1989 + 1990 1990 + wmb(); 1991 1991 + ql_write_common_reg(qdev, 1992 1992 + &port_regs->CommonRegs. 1993 1993 + rxSmallQProducerIndex, 1994 1994 + qdev->small_buf_q_producer_index); 1995 1995 + 2022 1996 } 2023 1997 2024 2024 - ql_write_common_reg(qdev, 2025 2025 - &port_regs->CommonRegs. 2026 2026 - rxSmallQProducerIndex, 2027 2027 - qdev->small_buf_q_producer_index); 2028 2028 - } 2029 2029 - 2030 2030 - ql_write_common_reg(qdev, 2031 2031 - &port_regs->CommonRegs.rspQConsumerIndex, 2032 2032 - qdev->rsp_consumer_index); 2033 2033 - spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 2034 2034 - 2035 2035 - if (unlikely(netif_queue_stopped(qdev->ndev))) { 2036 2036 - if (netif_queue_stopped(qdev->ndev) && 2037 2037 - (atomic_read(&qdev->tx_count) > (NUM_REQ_Q_ENTRIES / 4))) 2038 2038 - netif_wake_queue(qdev->ndev); 1998 1998 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 2039 1999 } 2040 2000 2041 2001 return *tx_cleaned + *rx_cleaned; ··· 2043 2009 struct ql3_adapter *qdev = netdev_priv(ndev); 2044 2010 int work_to_do = min(*budget, ndev->quota); 2045 2011 int rx_cleaned = 0, tx_cleaned = 0; 2012 2012 + unsigned long hw_flags; 2013 2013 + struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers; 2046 2014 2047 2015 if (!netif_carrier_ok(ndev)) 2048 2016 goto quit_polling; ··· 2053 2017 *budget -= rx_cleaned; 2054 2018 ndev->quota -= rx_cleaned; 2055 2019 2056 2056 - if ((!tx_cleaned && !rx_cleaned) || !netif_running(ndev)) { 2020 2020 + if( tx_cleaned + rx_cleaned != work_to_do || 2021 2021 + !netif_running(ndev)) { 2057 2022 quit_polling: 2058 2023 netif_rx_complete(ndev); 2024 2024 + 2025 2025 + spin_lock_irqsave(&qdev->hw_lock, hw_flags); 2026 2026 + ql_write_common_reg(qdev, 2027 2027 + &port_regs->CommonRegs.rspQConsumerIndex, 2028 2028 + qdev->rsp_consumer_index); 2029 2029 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 2030 2030 + 2059 2031 ql_enable_interrupts(qdev); 2060 2032 return 0; 2061 2033 } ··· 2117 2073 spin_unlock(&qdev->adapter_lock); 2118 2074 } else if (value & ISP_IMR_DISABLE_CMPL_INT) { 2119 2075 ql_disable_interrupts(qdev); 2120 2120 - if (likely(netif_rx_schedule_prep(ndev))) 2076 2076 + if (likely(netif_rx_schedule_prep(ndev))) { 2121 2077 __netif_rx_schedule(ndev); 2122 2122 - else 2123 2123 - ql_enable_interrupts(qdev); 2078 2078 + } 2124 2079 } else { 2125 2080 return IRQ_NONE; 2126 2081 } ··· 2136 2093 * the next AOL if more frags are coming. 2137 2094 * That is why the frags:segment count ratio is not linear. 2138 2095 */ 2139 2139 - static int ql_get_seg_count(unsigned short frags) 2096 2096 + static int ql_get_seg_count(struct ql3_adapter *qdev, 2097 2097 + unsigned short frags) 2140 2098 { 2099 2099 + if (qdev->device_id == QL3022_DEVICE_ID) 2100 2100 + return 1; 2101 2101 + 2141 2102 switch(frags) { 2142 2103 case 0: return 1; /* just the skb->data seg */ 2143 2104 case 1: return 2; /* skb->data + 1 frag */ ··· 2186 2139 2187 2140 if (ip) { 2188 2141 if (ip->protocol == IPPROTO_TCP) { 2189 2189 - mac_iocb_ptr->flags1 |= OB_3032MAC_IOCB_REQ_TC; 2142 2142 + mac_iocb_ptr->flags1 |= OB_3032MAC_IOCB_REQ_TC | 2143 2143 + OB_3032MAC_IOCB_REQ_IC; 2190 2144 mac_iocb_ptr->ip_hdr_off = offset; 2191 2145 mac_iocb_ptr->ip_hdr_len = ip->ihl; 2192 2146 } else if (ip->protocol == IPPROTO_UDP) { 2193 2193 - mac_iocb_ptr->flags1 |= OB_3032MAC_IOCB_REQ_UC; 2147 2147 + mac_iocb_ptr->flags1 |= OB_3032MAC_IOCB_REQ_UC | 2148 2148 + OB_3032MAC_IOCB_REQ_IC; 2194 2149 mac_iocb_ptr->ip_hdr_off = offset; 2195 2150 mac_iocb_ptr->ip_hdr_len = ip->ihl; 2196 2151 } 2197 2152 } 2153 2153 + } 2154 2154 + 2155 2155 + /* 2156 2156 + * Map the buffers for this transmit. This will return 2157 2157 + * NETDEV_TX_BUSY or NETDEV_TX_OK based on success. 2158 2158 + */ 2159 2159 + static int ql_send_map(struct ql3_adapter *qdev, 2160 2160 + struct ob_mac_iocb_req *mac_iocb_ptr, 2161 2161 + struct ql_tx_buf_cb *tx_cb, 2162 2162 + struct sk_buff *skb) 2163 2163 + { 2164 2164 + struct oal *oal; 2165 2165 + struct oal_entry *oal_entry; 2166 2166 + int len = skb->len; 2167 2167 + dma_addr_t map; 2168 2168 + int err; 2169 2169 + int completed_segs, i; 2170 2170 + int seg_cnt, seg = 0; 2171 2171 + int frag_cnt = (int)skb_shinfo(skb)->nr_frags; 2172 2172 + 2173 2173 + seg_cnt = tx_cb->seg_count = ql_get_seg_count(qdev, 2174 2174 + (skb_shinfo(skb)->nr_frags)); 2175 2175 + if(seg_cnt == -1) { 2176 2176 + printk(KERN_ERR PFX"%s: invalid segment count!\n",__func__); 2177 2177 + return NETDEV_TX_BUSY; 2178 2178 + } 2179 2179 + /* 2180 2180 + * Map the skb buffer first. 2181 2181 + */ 2182 2182 + map = pci_map_single(qdev->pdev, skb->data, len, PCI_DMA_TODEVICE); 2183 2183 + 2184 2184 + err = pci_dma_mapping_error(map); 2185 2185 + if(err) { 2186 2186 + printk(KERN_ERR "%s: PCI mapping failed with error: %d\n", 2187 2187 + qdev->ndev->name, err); 2188 2188 + 2189 2189 + return NETDEV_TX_BUSY; 2190 2190 + } 2191 2191 + 2192 2192 + oal_entry = (struct oal_entry *)&mac_iocb_ptr->buf_addr0_low; 2193 2193 + oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map)); 2194 2194 + oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map)); 2195 2195 + oal_entry->len = cpu_to_le32(len); 2196 2196 + pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, map); 2197 2197 + pci_unmap_len_set(&tx_cb->map[seg], maplen, len); 2198 2198 + seg++; 2199 2199 + 2200 2200 + if (seg_cnt == 1) { 2201 2201 + /* Terminate the last segment. */ 2202 2202 + oal_entry->len = 2203 2203 + cpu_to_le32(le32_to_cpu(oal_entry->len) | OAL_LAST_ENTRY); 2204 2204 + } else { 2205 2205 + oal = tx_cb->oal; 2206 2206 + for (completed_segs=0; completed_segs<frag_cnt; completed_segs++,seg++) { 2207 2207 + skb_frag_t *frag = &skb_shinfo(skb)->frags[completed_segs]; 2208 2208 + oal_entry++; 2209 2209 + if ((seg == 2 && seg_cnt > 3) || /* Check for continuation */ 2210 2210 + (seg == 7 && seg_cnt > 8) || /* requirements. It's strange */ 2211 2211 + (seg == 12 && seg_cnt > 13) || /* but necessary. */ 2212 2212 + (seg == 17 && seg_cnt > 18)) { 2213 2213 + /* Continuation entry points to outbound address list. */ 2214 2214 + map = pci_map_single(qdev->pdev, oal, 2215 2215 + sizeof(struct oal), 2216 2216 + PCI_DMA_TODEVICE); 2217 2217 + 2218 2218 + err = pci_dma_mapping_error(map); 2219 2219 + if(err) { 2220 2220 + 2221 2221 + printk(KERN_ERR "%s: PCI mapping outbound address list with error: %d\n", 2222 2222 + qdev->ndev->name, err); 2223 2223 + goto map_error; 2224 2224 + } 2225 2225 + 2226 2226 + oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map)); 2227 2227 + oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map)); 2228 2228 + oal_entry->len = 2229 2229 + cpu_to_le32(sizeof(struct oal) | 2230 2230 + OAL_CONT_ENTRY); 2231 2231 + pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, 2232 2232 + map); 2233 2233 + pci_unmap_len_set(&tx_cb->map[seg], maplen, 2234 2234 + len); 2235 2235 + oal_entry = (struct oal_entry *)oal; 2236 2236 + oal++; 2237 2237 + seg++; 2238 2238 + } 2239 2239 + 2240 2240 + map = 2241 2241 + pci_map_page(qdev->pdev, frag->page, 2242 2242 + frag->page_offset, frag->size, 2243 2243 + PCI_DMA_TODEVICE); 2244 2244 + 2245 2245 + err = pci_dma_mapping_error(map); 2246 2246 + if(err) { 2247 2247 + printk(KERN_ERR "%s: PCI mapping frags failed with error: %d\n", 2248 2248 + qdev->ndev->name, err); 2249 2249 + goto map_error; 2250 2250 + } 2251 2251 + 2252 2252 + oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map)); 2253 2253 + oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map)); 2254 2254 + oal_entry->len = cpu_to_le32(frag->size); 2255 2255 + pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, map); 2256 2256 + pci_unmap_len_set(&tx_cb->map[seg], maplen, 2257 2257 + frag->size); 2258 2258 + } 2259 2259 + /* Terminate the last segment. */ 2260 2260 + oal_entry->len = 2261 2261 + cpu_to_le32(le32_to_cpu(oal_entry->len) | OAL_LAST_ENTRY); 2262 2262 + } 2263 2263 + 2264 2264 + return NETDEV_TX_OK; 2265 2265 + 2266 2266 + map_error: 2267 2267 + /* A PCI mapping failed and now we will need to back out 2268 2268 + * We need to traverse through the oal's and associated pages which 2269 2269 + * have been mapped and now we must unmap them to clean up properly 2270 2270 + */ 2271 2271 + 2272 2272 + seg = 1; 2273 2273 + oal_entry = (struct oal_entry *)&mac_iocb_ptr->buf_addr0_low; 2274 2274 + oal = tx_cb->oal; 2275 2275 + for (i=0; i<completed_segs; i++,seg++) { 2276 2276 + oal_entry++; 2277 2277 + 2278 2278 + if((seg == 2 && seg_cnt > 3) || /* Check for continuation */ 2279 2279 + (seg == 7 && seg_cnt > 8) || /* requirements. It's strange */ 2280 2280 + (seg == 12 && seg_cnt > 13) || /* but necessary. */ 2281 2281 + (seg == 17 && seg_cnt > 18)) { 2282 2282 + pci_unmap_single(qdev->pdev, 2283 2283 + pci_unmap_addr(&tx_cb->map[seg], mapaddr), 2284 2284 + pci_unmap_len(&tx_cb->map[seg], maplen), 2285 2285 + PCI_DMA_TODEVICE); 2286 2286 + oal++; 2287 2287 + seg++; 2288 2288 + } 2289 2289 + 2290 2290 + pci_unmap_page(qdev->pdev, 2291 2291 + pci_unmap_addr(&tx_cb->map[seg], mapaddr), 2292 2292 + pci_unmap_len(&tx_cb->map[seg], maplen), 2293 2293 + PCI_DMA_TODEVICE); 2294 2294 + } 2295 2295 + 2296 2296 + pci_unmap_single(qdev->pdev, 2297 2297 + pci_unmap_addr(&tx_cb->map[0], mapaddr), 2298 2298 + pci_unmap_addr(&tx_cb->map[0], maplen), 2299 2299 + PCI_DMA_TODEVICE); 2300 2300 + 2301 2301 + return NETDEV_TX_BUSY; 2302 2302 + 2198 2303 } 2199 2304 2200 2305 /* ··· 2366 2167 struct ql3xxx_port_registers __iomem *port_regs = qdev->mem_map_registers; 2367 2168 struct ql_tx_buf_cb *tx_cb; 2368 2169 u32 tot_len = skb->len; 2369 2369 - struct oal *oal; 2370 2370 - struct oal_entry *oal_entry; 2371 2371 - int len; 2372 2170 struct ob_mac_iocb_req *mac_iocb_ptr; 2373 2373 - u64 map; 2374 2374 - int seg_cnt, seg = 0; 2375 2375 - int frag_cnt = (int)skb_shinfo(skb)->nr_frags; 2376 2171 2377 2172 if (unlikely(atomic_read(&qdev->tx_count) < 2)) { 2378 2378 - if (!netif_queue_stopped(ndev)) 2379 2379 - netif_stop_queue(ndev); 2380 2173 return NETDEV_TX_BUSY; 2381 2174 } 2175 2175 + 2382 2176 tx_cb = &qdev->tx_buf[qdev->req_producer_index] ; 2383 2383 - seg_cnt = tx_cb->seg_count = ql_get_seg_count((skb_shinfo(skb)->nr_frags)); 2384 2384 - if(seg_cnt == -1) { 2177 2177 + if((tx_cb->seg_count = ql_get_seg_count(qdev, 2178 2178 + (skb_shinfo(skb)->nr_frags))) == -1) { 2385 2179 printk(KERN_ERR PFX"%s: invalid segment count!\n",__func__); 2386 2180 return NETDEV_TX_OK; 2387 2387 - 2388 2181 } 2182 2182 + 2389 2183 mac_iocb_ptr = tx_cb->queue_entry; 2390 2390 - memset((void *)mac_iocb_ptr, 0, sizeof(struct ob_mac_iocb_req)); 2391 2184 mac_iocb_ptr->opcode = qdev->mac_ob_opcode; 2185 2185 + mac_iocb_ptr->flags = OB_MAC_IOCB_REQ_X; 2392 2186 mac_iocb_ptr->flags |= qdev->mb_bit_mask; 2393 2187 mac_iocb_ptr->transaction_id = qdev->req_producer_index; 2394 2188 mac_iocb_ptr->data_len = cpu_to_le16((u16) tot_len); 2395 2189 tx_cb->skb = skb; 2396 2396 - if (skb->ip_summed == CHECKSUM_PARTIAL) 2190 2190 + if (qdev->device_id == QL3032_DEVICE_ID && 2191 2191 + skb->ip_summed == CHECKSUM_PARTIAL) 2397 2192 ql_hw_csum_setup(skb, mac_iocb_ptr); 2398 2398 - len = skb_headlen(skb); 2399 2399 - map = pci_map_single(qdev->pdev, skb->data, len, PCI_DMA_TODEVICE); 2400 2400 - oal_entry = (struct oal_entry *)&mac_iocb_ptr->buf_addr0_low; 2401 2401 - oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map)); 2402 2402 - oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map)); 2403 2403 - oal_entry->len = cpu_to_le32(len); 2404 2404 - pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, map); 2405 2405 - pci_unmap_len_set(&tx_cb->map[seg], maplen, len); 2406 2406 - seg++; 2407 2407 - 2408 2408 - if (!skb_shinfo(skb)->nr_frags) { 2409 2409 - /* Terminate the last segment. */ 2410 2410 - oal_entry->len = 2411 2411 - cpu_to_le32(le32_to_cpu(oal_entry->len) | OAL_LAST_ENTRY); 2412 2412 - } else { 2413 2413 - int i; 2414 2414 - oal = tx_cb->oal; 2415 2415 - for (i=0; i<frag_cnt; i++,seg++) { 2416 2416 - skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 2417 2417 - oal_entry++; 2418 2418 - if ((seg == 2 && seg_cnt > 3) || /* Check for continuation */ 2419 2419 - (seg == 7 && seg_cnt > 8) || /* requirements. It's strange */ 2420 2420 - (seg == 12 && seg_cnt > 13) || /* but necessary. */ 2421 2421 - (seg == 17 && seg_cnt > 18)) { 2422 2422 - /* Continuation entry points to outbound address list. */ 2423 2423 - map = pci_map_single(qdev->pdev, oal, 2424 2424 - sizeof(struct oal), 2425 2425 - PCI_DMA_TODEVICE); 2426 2426 - oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map)); 2427 2427 - oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map)); 2428 2428 - oal_entry->len = 2429 2429 - cpu_to_le32(sizeof(struct oal) | 2430 2430 - OAL_CONT_ENTRY); 2431 2431 - pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, 2432 2432 - map); 2433 2433 - pci_unmap_len_set(&tx_cb->map[seg], maplen, 2434 2434 - len); 2435 2435 - oal_entry = (struct oal_entry *)oal; 2436 2436 - oal++; 2437 2437 - seg++; 2438 2438 - } 2439 2439 - 2440 2440 - map = 2441 2441 - pci_map_page(qdev->pdev, frag->page, 2442 2442 - frag->page_offset, frag->size, 2443 2443 - PCI_DMA_TODEVICE); 2444 2444 - oal_entry->dma_lo = cpu_to_le32(LS_64BITS(map)); 2445 2445 - oal_entry->dma_hi = cpu_to_le32(MS_64BITS(map)); 2446 2446 - oal_entry->len = cpu_to_le32(frag->size); 2447 2447 - pci_unmap_addr_set(&tx_cb->map[seg], mapaddr, map); 2448 2448 - pci_unmap_len_set(&tx_cb->map[seg], maplen, 2449 2449 - frag->size); 2450 2450 - } 2451 2451 - /* Terminate the last segment. */ 2452 2452 - oal_entry->len = 2453 2453 - cpu_to_le32(le32_to_cpu(oal_entry->len) | OAL_LAST_ENTRY); 2193 2193 + 2194 2194 + if(ql_send_map(qdev,mac_iocb_ptr,tx_cb,skb) != NETDEV_TX_OK) { 2195 2195 + printk(KERN_ERR PFX"%s: Could not map the segments!\n",__func__); 2196 2196 + return NETDEV_TX_BUSY; 2454 2197 } 2198 2198 + 2455 2199 wmb(); 2456 2200 qdev->req_producer_index++; 2457 2201 if (qdev->req_producer_index == NUM_REQ_Q_ENTRIES) ··· 2480 2338 { 2481 2339 /* Create Large Buffer Queue */ 2482 2340 qdev->lrg_buf_q_size = 2483 2483 - NUM_LBUFQ_ENTRIES * sizeof(struct lrg_buf_q_entry); 2341 2341 + qdev->num_lbufq_entries * sizeof(struct lrg_buf_q_entry); 2484 2342 if (qdev->lrg_buf_q_size < PAGE_SIZE) 2485 2343 qdev->lrg_buf_q_alloc_size = PAGE_SIZE; 2486 2344 else 2487 2345 qdev->lrg_buf_q_alloc_size = qdev->lrg_buf_q_size * 2; 2488 2346 2347 2347 + qdev->lrg_buf = kmalloc(qdev->num_large_buffers * sizeof(struct ql_rcv_buf_cb),GFP_KERNEL); 2348 2348 + if (qdev->lrg_buf == NULL) { 2349 2349 + printk(KERN_ERR PFX 2350 2350 + "%s: qdev->lrg_buf alloc failed.\n", qdev->ndev->name); 2351 2351 + return -ENOMEM; 2352 2352 + } 2353 2353 + 2489 2354 qdev->lrg_buf_q_alloc_virt_addr = 2490 2355 pci_alloc_consistent(qdev->pdev, 2491 2356 qdev->lrg_buf_q_alloc_size, ··· 2542 2393 "%s: Already done.\n", qdev->ndev->name); 2543 2394 return; 2544 2395 } 2545 2545 - 2396 2396 + if(qdev->lrg_buf) kfree(qdev->lrg_buf); 2546 2397 pci_free_consistent(qdev->pdev, 2547 2398 qdev->lrg_buf_q_alloc_size, 2548 2399 qdev->lrg_buf_q_alloc_virt_addr, ··· 2587 2438 2588 2439 small_buf_q_entry = qdev->small_buf_q_virt_addr; 2589 2440 2590 2590 - qdev->last_rsp_offset = qdev->small_buf_phy_addr_low; 2591 2591 - 2592 2441 /* Initialize the small buffer queue. */ 2593 2442 for (i = 0; i < (QL_ADDR_ELE_PER_BUFQ_ENTRY * NUM_SBUFQ_ENTRIES); i++) { 2594 2443 small_buf_q_entry->addr_high = ··· 2623 2476 int i = 0; 2624 2477 struct ql_rcv_buf_cb *lrg_buf_cb; 2625 2478 2626 2626 - for (i = 0; i < NUM_LARGE_BUFFERS; i++) { 2479 2479 + for (i = 0; i < qdev->num_large_buffers; i++) { 2627 2480 lrg_buf_cb = &qdev->lrg_buf[i]; 2628 2481 if (lrg_buf_cb->skb) { 2629 2482 dev_kfree_skb(lrg_buf_cb->skb); ··· 2644 2497 struct ql_rcv_buf_cb *lrg_buf_cb; 2645 2498 struct bufq_addr_element *buf_addr_ele = qdev->lrg_buf_q_virt_addr; 2646 2499 2647 2647 - for (i = 0; i < NUM_LARGE_BUFFERS; i++) { 2500 2500 + for (i = 0; i < qdev->num_large_buffers; i++) { 2648 2501 lrg_buf_cb = &qdev->lrg_buf[i]; 2649 2502 buf_addr_ele->addr_high = lrg_buf_cb->buf_phy_addr_high; 2650 2503 buf_addr_ele->addr_low = lrg_buf_cb->buf_phy_addr_low; ··· 2659 2512 int i; 2660 2513 struct ql_rcv_buf_cb *lrg_buf_cb; 2661 2514 struct sk_buff *skb; 2662 2662 - u64 map; 2515 2515 + dma_addr_t map; 2516 2516 + int err; 2663 2517 2664 2664 - for (i = 0; i < NUM_LARGE_BUFFERS; i++) { 2665 2665 - skb = dev_alloc_skb(qdev->lrg_buffer_len); 2518 2518 + for (i = 0; i < qdev->num_large_buffers; i++) { 2519 2519 + skb = netdev_alloc_skb(qdev->ndev, 2520 2520 + qdev->lrg_buffer_len); 2666 2521 if (unlikely(!skb)) { 2667 2522 /* Better luck next round */ 2668 2523 printk(KERN_ERR PFX ··· 2690 2541 qdev->lrg_buffer_len - 2691 2542 QL_HEADER_SPACE, 2692 2543 PCI_DMA_FROMDEVICE); 2544 2544 + 2545 2545 + err = pci_dma_mapping_error(map); 2546 2546 + if(err) { 2547 2547 + printk(KERN_ERR "%s: PCI mapping failed with error: %d\n", 2548 2548 + qdev->ndev->name, err); 2549 2549 + ql_free_large_buffers(qdev); 2550 2550 + return -ENOMEM; 2551 2551 + } 2552 2552 + 2693 2553 pci_unmap_addr_set(lrg_buf_cb, mapaddr, map); 2694 2554 pci_unmap_len_set(lrg_buf_cb, maplen, 2695 2555 qdev->lrg_buffer_len - ··· 2750 2592 2751 2593 static int ql_alloc_mem_resources(struct ql3_adapter *qdev) 2752 2594 { 2753 2753 - if (qdev->ndev->mtu == NORMAL_MTU_SIZE) 2595 2595 + if (qdev->ndev->mtu == NORMAL_MTU_SIZE) { 2596 2596 + qdev->num_lbufq_entries = NUM_LBUFQ_ENTRIES; 2754 2597 qdev->lrg_buffer_len = NORMAL_MTU_SIZE; 2598 2598 + } 2755 2599 else if (qdev->ndev->mtu == JUMBO_MTU_SIZE) { 2600 2600 + /* 2601 2601 + * Bigger buffers, so less of them. 2602 2602 + */ 2603 2603 + qdev->num_lbufq_entries = JUMBO_NUM_LBUFQ_ENTRIES; 2756 2604 qdev->lrg_buffer_len = JUMBO_MTU_SIZE; 2757 2605 } else { 2758 2606 printk(KERN_ERR PFX ··· 2766 2602 qdev->ndev->name); 2767 2603 return -ENOMEM; 2768 2604 } 2605 2605 + qdev->num_large_buffers = qdev->num_lbufq_entries * QL_ADDR_ELE_PER_BUFQ_ENTRY; 2769 2606 qdev->lrg_buffer_len += VLAN_ETH_HLEN + VLAN_ID_LEN + QL_HEADER_SPACE; 2770 2607 qdev->max_frame_size = 2771 2608 (qdev->lrg_buffer_len - QL_HEADER_SPACE) + ETHERNET_CRC_SIZE; ··· 2999 2834 &hmem_regs->rxLargeQBaseAddrLow, 3000 2835 LS_64BITS(qdev->lrg_buf_q_phy_addr)); 3001 2836 3002 3002 - ql_write_page1_reg(qdev, &hmem_regs->rxLargeQLength, NUM_LBUFQ_ENTRIES); 2837 2837 + ql_write_page1_reg(qdev, &hmem_regs->rxLargeQLength, qdev->num_lbufq_entries); 3003 2838 3004 2839 ql_write_page1_reg(qdev, 3005 2840 &hmem_regs->rxLargeBufferLength, ··· 3021 2856 3022 2857 qdev->small_buf_q_producer_index = NUM_SBUFQ_ENTRIES - 1; 3023 2858 qdev->small_buf_release_cnt = 8; 3024 3024 - qdev->lrg_buf_q_producer_index = NUM_LBUFQ_ENTRIES - 1; 2859 2859 + qdev->lrg_buf_q_producer_index = qdev->num_lbufq_entries - 1; 3025 2860 qdev->lrg_buf_release_cnt = 8; 3026 2861 qdev->lrg_buf_next_free = 3027 2862 (struct bufq_addr_element *)qdev->lrg_buf_q_virt_addr; ··· 3457 3292 err_init: 3458 3293 ql_sem_unlock(qdev, QL_DRVR_SEM_MASK); 3459 3294 err_lock: 3295 3295 + spin_unlock_irqrestore(&qdev->hw_lock, hw_flags); 3460 3296 free_irq(qdev->pdev->irq, ndev); 3461 3297 err_irq: 3462 3298 if (qdev->msi && test_bit(QL_MSI_ENABLED,&qdev->flags)) { ··· 3507 3341 { 3508 3342 struct ql3_adapter *qdev = (struct ql3_adapter *)dev->priv; 3509 3343 return &qdev->stats; 3510 3510 - } 3511 3511 - 3512 3512 - static int ql3xxx_change_mtu(struct net_device *ndev, int new_mtu) 3513 3513 - { 3514 3514 - struct ql3_adapter *qdev = netdev_priv(ndev); 3515 3515 - printk(KERN_ERR PFX "%s: new mtu size = %d.\n", ndev->name, new_mtu); 3516 3516 - if (new_mtu != NORMAL_MTU_SIZE && new_mtu != JUMBO_MTU_SIZE) { 3517 3517 - printk(KERN_ERR PFX 3518 3518 - "%s: mtu size of %d is not valid. Use exactly %d or " 3519 3519 - "%d.\n", ndev->name, new_mtu, NORMAL_MTU_SIZE, 3520 3520 - JUMBO_MTU_SIZE); 3521 3521 - return -EINVAL; 3522 3522 - } 3523 3523 - 3524 3524 - if (!netif_running(ndev)) { 3525 3525 - ndev->mtu = new_mtu; 3526 3526 - return 0; 3527 3527 - } 3528 3528 - 3529 3529 - ndev->mtu = new_mtu; 3530 3530 - return ql_cycle_adapter(qdev,QL_DO_RESET); 3531 3344 } 3532 3345 3533 3346 static void ql3xxx_set_multicast_list(struct net_device *ndev) ··· 3754 3609 } 3755 3610 3756 3611 ndev = alloc_etherdev(sizeof(struct ql3_adapter)); 3757 3757 - if (!ndev) 3612 3612 + if (!ndev) { 3613 3613 + printk(KERN_ERR PFX "%s could not alloc etherdev\n", 3614 3614 + pci_name(pdev)); 3615 3615 + err = -ENOMEM; 3758 3616 goto err_out_free_regions; 3617 3617 + } 3759 3618 3760 3619 SET_MODULE_OWNER(ndev); 3761 3620 SET_NETDEV_DEV(ndev, &pdev->dev); ··· 3788 3639 if (!qdev->mem_map_registers) { 3789 3640 printk(KERN_ERR PFX "%s: cannot map device registers\n", 3790 3641 pci_name(pdev)); 3642 3642 + err = -EIO; 3791 3643 goto err_out_free_ndev; 3792 3644 } 3793 3645 ··· 3800 3650 ndev->hard_start_xmit = ql3xxx_send; 3801 3651 ndev->stop = ql3xxx_close; 3802 3652 ndev->get_stats = ql3xxx_get_stats; 3803 3803 - ndev->change_mtu = ql3xxx_change_mtu; 3804 3653 ndev->set_multicast_list = ql3xxx_set_multicast_list; 3805 3654 SET_ETHTOOL_OPS(ndev, &ql3xxx_ethtool_ops); 3806 3655 ndev->set_mac_address = ql3xxx_set_mac_address; ··· 3816 3667 printk(KERN_ALERT PFX 3817 3668 "ql3xxx_probe: Adapter #%d, Invalid NVRAM parameters.\n", 3818 3669 qdev->index); 3670 3670 + err = -EIO; 3819 3671 goto err_out_iounmap; 3820 3672 } 3821 3673 ··· 3824 3674 3825 3675 /* Validate and set parameters */ 3826 3676 if (qdev->mac_index) { 3677 3677 + ndev->mtu = qdev->nvram_data.macCfg_port1.etherMtu_mac ; 3827 3678 memcpy(ndev->dev_addr, &qdev->nvram_data.funcCfg_fn2.macAddress, 3828 3679 ETH_ALEN); 3829 3680 } else { 3681 3681 + ndev->mtu = qdev->nvram_data.macCfg_port0.etherMtu_mac ; 3830 3682 memcpy(ndev->dev_addr, &qdev->nvram_data.funcCfg_fn0.macAddress, 3831 3683 ETH_ALEN); 3832 3684 }

+7 -4

drivers/net/qla3xxx.h

reviewed

··· 1014 1014 1015 1015 /* Transmit and Receive Buffers */ 1016 1016 #define NUM_LBUFQ_ENTRIES 128 1017 1017 + #define JUMBO_NUM_LBUFQ_ENTRIES \ 1018 1018 + (NUM_LBUFQ_ENTRIES/(JUMBO_MTU_SIZE/NORMAL_MTU_SIZE)) 1017 1019 #define NUM_SBUFQ_ENTRIES 64 1018 1020 #define QL_SMALL_BUFFER_SIZE 32 1019 1021 #define QL_ADDR_ELE_PER_BUFQ_ENTRY \ 1020 1022 (sizeof(struct lrg_buf_q_entry) / sizeof(struct bufq_addr_element)) 1021 1023 /* Each send has at least control block. This is how many we keep. */ 1022 1024 #define NUM_SMALL_BUFFERS NUM_SBUFQ_ENTRIES * QL_ADDR_ELE_PER_BUFQ_ENTRY 1023 1023 - #define NUM_LARGE_BUFFERS NUM_LBUFQ_ENTRIES * QL_ADDR_ELE_PER_BUFQ_ENTRY 1025 1025 + 1024 1026 #define QL_HEADER_SPACE 32 /* make header space at top of skb. */ 1025 1027 /* 1026 1028 * Large & Small Buffers for Receives ··· 1094 1092 u32 len; 1095 1093 #define OAL_LAST_ENTRY 0x80000000 /* Last valid buffer in list. */ 1096 1094 #define OAL_CONT_ENTRY 0x40000000 /* points to an OAL. (continuation) */ 1097 1097 - u32 reserved; 1098 1095 }; 1099 1096 1100 1097 struct oal { ··· 1194 1193 struct net_rsp_iocb *rsp_current; 1195 1194 u16 rsp_consumer_index; 1196 1195 u16 reserved_06; 1197 1197 - u32 *prsp_producer_index; 1196 1196 + volatile u32 *prsp_producer_index; 1198 1197 u32 rsp_producer_index_phy_addr_high; 1199 1198 u32 rsp_producer_index_phy_addr_low; 1200 1199 ··· 1208 1207 u32 lrg_buf_q_producer_index; 1209 1208 u32 lrg_buf_release_cnt; 1210 1209 struct bufq_addr_element *lrg_buf_next_free; 1210 1210 + u32 num_large_buffers; 1211 1211 + u32 num_lbufq_entries; 1211 1212 1212 1213 /* Large (Receive) Buffers */ 1213 1213 - struct ql_rcv_buf_cb lrg_buf[NUM_LARGE_BUFFERS]; 1214 1214 + struct ql_rcv_buf_cb *lrg_buf; 1214 1215 struct ql_rcv_buf_cb *lrg_buf_free_head; 1215 1216 struct ql_rcv_buf_cb *lrg_buf_free_tail; 1216 1217 u32 lrg_buf_free_count;

+1

drivers/net/s2io-regs.h

reviewed

··· 430 430 #define TX_PA_CFG_IGNORE_SNAP_OUI BIT(2) 431 431 #define TX_PA_CFG_IGNORE_LLC_CTRL BIT(3) 432 432 #define TX_PA_CFG_IGNORE_L2_ERR BIT(6) 433 433 + #define RX_PA_CFG_STRIP_VLAN_TAG BIT(15) 433 434 434 435 /* Recent add, used only debug purposes. */ 435 436 u64 pcc_enable;

+243 -56

drivers/net/s2io.c

reviewed

··· 42 42 * Possible values '1' for enable '0' for disable. Default is '0' 43 43 * lro_max_pkts: This parameter defines maximum number of packets can be 44 44 * aggregated as a single large packet 45 45 + * napi: This parameter used to enable/disable NAPI (polling Rx) 46 46 + * Possible values '1' for enable and '0' for disable. Default is '1' 47 47 + * ufo: This parameter used to enable/disable UDP Fragmentation Offload(UFO) 48 48 + * Possible values '1' for enable and '0' for disable. Default is '0' 49 49 + * vlan_tag_strip: This can be used to enable or disable vlan stripping. 50 50 + * Possible values '1' for enable , '0' for disable. 51 51 + * Default is '2' - which means disable in promisc mode 52 52 + * and enable in non-promiscuous mode. 45 53 ************************************************************************/ 46 54 47 55 #include <linux/module.h> ··· 84 76 #include "s2io.h" 85 77 #include "s2io-regs.h" 86 78 87 87 - #define DRV_VERSION "2.0.16.1" 79 79 + #define DRV_VERSION "2.0.17.1" 88 80 89 81 /* S2io Driver name & version. */ 90 82 static char s2io_driver_name[] = "Neterion"; ··· 139 131 "BIST Test\t(offline)" 140 132 }; 141 133 142 142 - static char ethtool_stats_keys[][ETH_GSTRING_LEN] = { 134 134 + static char ethtool_xena_stats_keys[][ETH_GSTRING_LEN] = { 143 135 {"tmac_frms"}, 144 136 {"tmac_data_octets"}, 145 137 {"tmac_drop_frms"}, ··· 233 225 {"rxd_rd_cnt"}, 234 226 {"rxd_wr_cnt"}, 235 227 {"txf_rd_cnt"}, 236 236 - {"rxf_wr_cnt"}, 228 228 + {"rxf_wr_cnt"} 229 229 + }; 230 230 + 231 231 + static char ethtool_enhanced_stats_keys[][ETH_GSTRING_LEN] = { 237 232 {"rmac_ttl_1519_4095_frms"}, 238 233 {"rmac_ttl_4096_8191_frms"}, 239 234 {"rmac_ttl_8192_max_frms"}, ··· 252 241 {"rmac_red_discard"}, 253 242 {"rmac_rts_discard"}, 254 243 {"rmac_ingm_full_discard"}, 255 255 - {"link_fault_cnt"}, 244 244 + {"link_fault_cnt"} 245 245 + }; 246 246 + 247 247 + static char ethtool_driver_stats_keys[][ETH_GSTRING_LEN] = { 256 248 {"\n DRIVER STATISTICS"}, 257 249 {"single_bit_ecc_errs"}, 258 250 {"double_bit_ecc_errs"}, ··· 283 269 ("lro_avg_aggr_pkts"), 284 270 }; 285 271 286 286 - #define S2IO_STAT_LEN sizeof(ethtool_stats_keys)/ ETH_GSTRING_LEN 287 287 - #define S2IO_STAT_STRINGS_LEN S2IO_STAT_LEN * ETH_GSTRING_LEN 272 272 + #define S2IO_XENA_STAT_LEN sizeof(ethtool_xena_stats_keys)/ ETH_GSTRING_LEN 273 273 + #define S2IO_ENHANCED_STAT_LEN sizeof(ethtool_enhanced_stats_keys)/ \ 274 274 + ETH_GSTRING_LEN 275 275 + #define S2IO_DRIVER_STAT_LEN sizeof(ethtool_driver_stats_keys)/ ETH_GSTRING_LEN 276 276 + 277 277 + #define XFRAME_I_STAT_LEN (S2IO_XENA_STAT_LEN + S2IO_DRIVER_STAT_LEN ) 278 278 + #define XFRAME_II_STAT_LEN (XFRAME_I_STAT_LEN + S2IO_ENHANCED_STAT_LEN ) 279 279 + 280 280 + #define XFRAME_I_STAT_STRINGS_LEN ( XFRAME_I_STAT_LEN * ETH_GSTRING_LEN ) 281 281 + #define XFRAME_II_STAT_STRINGS_LEN ( XFRAME_II_STAT_LEN * ETH_GSTRING_LEN ) 288 282 289 283 #define S2IO_TEST_LEN sizeof(s2io_gstrings) / ETH_GSTRING_LEN 290 284 #define S2IO_STRINGS_LEN S2IO_TEST_LEN * ETH_GSTRING_LEN ··· 314 292 nic->vlgrp = grp; 315 293 spin_unlock_irqrestore(&nic->tx_lock, flags); 316 294 } 295 295 + 296 296 + /* A flag indicating whether 'RX_PA_CFG_STRIP_VLAN_TAG' bit is set or not */ 297 297 + int vlan_strip_flag; 317 298 318 299 /* Unregister the vlan */ 319 300 static void s2io_vlan_rx_kill_vid(struct net_device *dev, unsigned long vid) ··· 429 404 430 405 S2IO_PARM_INT(napi, 1); 431 406 S2IO_PARM_INT(ufo, 0); 407 407 + S2IO_PARM_INT(vlan_tag_strip, NO_STRIP_IN_PROMISC); 432 408 433 409 static unsigned int tx_fifo_len[MAX_TX_FIFOS] = 434 410 {DEFAULT_FIFO_0_LEN, [1 ...(MAX_TX_FIFOS - 1)] = DEFAULT_FIFO_1_7_LEN}; ··· 1397 1371 &bar0->rts_frm_len_n[i]); 1398 1372 } 1399 1373 } 1374 1374 + 1375 1375 + /* Disable differentiated services steering logic */ 1376 1376 + for (i = 0; i < 64; i++) { 1377 1377 + if (rts_ds_steer(nic, i, 0) == FAILURE) { 1378 1378 + DBG_PRINT(ERR_DBG, "%s: failed rts ds steering", 1379 1379 + dev->name); 1380 1380 + DBG_PRINT(ERR_DBG, "set on codepoint %d\n", i); 1381 1381 + return FAILURE; 1382 1382 + } 1383 1383 + } 1400 1384 1401 1385 /* Program statistics memory */ 1402 1386 writeq(mac_control->stats_mem_phy, &bar0->stat_addr); ··· 1977 1941 val64 = readq(&bar0->rx_pa_cfg); 1978 1942 val64 |= RX_PA_CFG_IGNORE_L2_ERR; 1979 1943 writeq(val64, &bar0->rx_pa_cfg); 1944 1944 + } 1945 1945 + 1946 1946 + if (vlan_tag_strip == 0) { 1947 1947 + val64 = readq(&bar0->rx_pa_cfg); 1948 1948 + val64 &= ~RX_PA_CFG_STRIP_VLAN_TAG; 1949 1949 + writeq(val64, &bar0->rx_pa_cfg); 1950 1950 + vlan_strip_flag = 0; 1980 1951 } 1981 1952 1982 1953 /* ··· 3238 3195 * SUCCESS on success and FAILURE on failure. 3239 3196 */ 3240 3197 3241 3241 - static int wait_for_cmd_complete(void __iomem *addr, u64 busy_bit) 3198 3198 + static int wait_for_cmd_complete(void __iomem *addr, u64 busy_bit, 3199 3199 + int bit_state) 3242 3200 { 3243 3243 - int ret = FAILURE, cnt = 0; 3201 3201 + int ret = FAILURE, cnt = 0, delay = 1; 3244 3202 u64 val64; 3245 3203 3246 3246 - while (TRUE) { 3204 3204 + if ((bit_state != S2IO_BIT_RESET) && (bit_state != S2IO_BIT_SET)) 3205 3205 + return FAILURE; 3206 3206 + 3207 3207 + do { 3247 3208 val64 = readq(addr); 3248 3248 - if (!(val64 & busy_bit)) { 3249 3249 - ret = SUCCESS; 3250 3250 - break; 3209 3209 + if (bit_state == S2IO_BIT_RESET) { 3210 3210 + if (!(val64 & busy_bit)) { 3211 3211 + ret = SUCCESS; 3212 3212 + break; 3213 3213 + } 3214 3214 + } else { 3215 3215 + if (!(val64 & busy_bit)) { 3216 3216 + ret = SUCCESS; 3217 3217 + break; 3218 3218 + } 3251 3219 } 3252 3220 3253 3221 if(in_interrupt()) 3254 3254 - mdelay(50); 3222 3222 + mdelay(delay); 3255 3223 else 3256 3256 - msleep(50); 3224 3224 + msleep(delay); 3257 3225 3258 3258 - if (cnt++ > 10) 3259 3259 - break; 3260 3260 - } 3226 3226 + if (++cnt >= 10) 3227 3227 + delay = 50; 3228 3228 + } while (cnt < 20); 3261 3229 return ret; 3262 3230 } 3263 3231 /* ··· 3393 3339 val64 = readq(&bar0->pcc_err_reg); 3394 3340 writeq(val64, &bar0->pcc_err_reg); 3395 3341 } 3342 3342 + 3343 3343 + /* restore the previously assigned mac address */ 3344 3344 + s2io_set_mac_addr(sp->dev, (u8 *)&sp->def_mac_addr[0].mac_addr); 3396 3345 3397 3346 sp->device_enabled_once = FALSE; 3398 3347 } ··· 4144 4087 val64 &= ~GPIO_INT_MASK_LINK_UP; 4145 4088 val64 |= GPIO_INT_MASK_LINK_DOWN; 4146 4089 writeq(val64, &bar0->gpio_int_mask); 4090 4090 + 4091 4091 + /* turn off LED */ 4092 4092 + val64 = readq(&bar0->adapter_control); 4093 4093 + val64 = val64 &(~ADAPTER_LED_ON); 4094 4094 + writeq(val64, &bar0->adapter_control); 4147 4095 } 4148 4096 } 4149 4097 val64 = readq(&bar0->gpio_int_mask); ··· 4358 4296 writeq(val64, &bar0->rmac_addr_cmd_mem); 4359 4297 /* Wait till command completes */ 4360 4298 wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem, 4361 4361 - RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING); 4299 4299 + RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, 4300 4300 + S2IO_BIT_RESET); 4362 4301 4363 4302 sp->m_cast_flg = 1; 4364 4303 sp->all_multi_pos = MAC_MC_ALL_MC_ADDR_OFFSET; ··· 4375 4312 writeq(val64, &bar0->rmac_addr_cmd_mem); 4376 4313 /* Wait till command completes */ 4377 4314 wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem, 4378 4378 - RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING); 4315 4315 + RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, 4316 4316 + S2IO_BIT_RESET); 4379 4317 4380 4318 sp->m_cast_flg = 0; 4381 4319 sp->all_multi_pos = 0; ··· 4393 4329 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key); 4394 4330 writel((u32) (val64 >> 32), (add + 4)); 4395 4331 4332 4332 + if (vlan_tag_strip != 1) { 4333 4333 + val64 = readq(&bar0->rx_pa_cfg); 4334 4334 + val64 &= ~RX_PA_CFG_STRIP_VLAN_TAG; 4335 4335 + writeq(val64, &bar0->rx_pa_cfg); 4336 4336 + vlan_strip_flag = 0; 4337 4337 + } 4338 4338 + 4396 4339 val64 = readq(&bar0->mac_cfg); 4397 4340 sp->promisc_flg = 1; 4398 4341 DBG_PRINT(INFO_DBG, "%s: entered promiscuous mode\n", ··· 4414 4343 writel((u32) val64, add); 4415 4344 writeq(RMAC_CFG_KEY(0x4C0D), &bar0->rmac_cfg_key); 4416 4345 writel((u32) (val64 >> 32), (add + 4)); 4346 4346 + 4347 4347 + if (vlan_tag_strip != 0) { 4348 4348 + val64 = readq(&bar0->rx_pa_cfg); 4349 4349 + val64 |= RX_PA_CFG_STRIP_VLAN_TAG; 4350 4350 + writeq(val64, &bar0->rx_pa_cfg); 4351 4351 + vlan_strip_flag = 1; 4352 4352 + } 4417 4353 4418 4354 val64 = readq(&bar0->mac_cfg); 4419 4355 sp->promisc_flg = 0; ··· 4456 4378 4457 4379 /* Wait for command completes */ 4458 4380 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem, 4459 4459 - RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING)) { 4381 4381 + RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, 4382 4382 + S2IO_BIT_RESET)) { 4460 4383 DBG_PRINT(ERR_DBG, "%s: Adding ", 4461 4384 dev->name); 4462 4385 DBG_PRINT(ERR_DBG, "Multicasts failed\n"); ··· 4488 4409 4489 4410 /* Wait for command completes */ 4490 4411 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem, 4491 4491 - RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING)) { 4412 4412 + RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, 4413 4413 + S2IO_BIT_RESET)) { 4492 4414 DBG_PRINT(ERR_DBG, "%s: Adding ", 4493 4415 dev->name); 4494 4416 DBG_PRINT(ERR_DBG, "Multicasts failed\n"); ··· 4515 4435 struct XENA_dev_config __iomem *bar0 = sp->bar0; 4516 4436 register u64 val64, mac_addr = 0; 4517 4437 int i; 4438 4438 + u64 old_mac_addr = 0; 4518 4439 4519 4440 /* 4520 4441 * Set the new MAC address as the new unicast filter and reflect this ··· 4525 4444 for (i = 0; i < ETH_ALEN; i++) { 4526 4445 mac_addr <<= 8; 4527 4446 mac_addr |= addr[i]; 4447 4447 + old_mac_addr <<= 8; 4448 4448 + old_mac_addr |= sp->def_mac_addr[0].mac_addr[i]; 4449 4449 + } 4450 4450 + 4451 4451 + if(0 == mac_addr) 4452 4452 + return SUCCESS; 4453 4453 + 4454 4454 + /* Update the internal structure with this new mac address */ 4455 4455 + if(mac_addr != old_mac_addr) { 4456 4456 + memset(sp->def_mac_addr[0].mac_addr, 0, sizeof(ETH_ALEN)); 4457 4457 + sp->def_mac_addr[0].mac_addr[5] = (u8) (mac_addr); 4458 4458 + sp->def_mac_addr[0].mac_addr[4] = (u8) (mac_addr >> 8); 4459 4459 + sp->def_mac_addr[0].mac_addr[3] = (u8) (mac_addr >> 16); 4460 4460 + sp->def_mac_addr[0].mac_addr[2] = (u8) (mac_addr >> 24); 4461 4461 + sp->def_mac_addr[0].mac_addr[1] = (u8) (mac_addr >> 32); 4462 4462 + sp->def_mac_addr[0].mac_addr[0] = (u8) (mac_addr >> 40); 4528 4463 } 4529 4464 4530 4465 writeq(RMAC_ADDR_DATA0_MEM_ADDR(mac_addr), ··· 4552 4455 writeq(val64, &bar0->rmac_addr_cmd_mem); 4553 4456 /* Wait till command completes */ 4554 4457 if (wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem, 4555 4555 - RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING)) { 4458 4458 + RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, S2IO_BIT_RESET)) { 4556 4459 DBG_PRINT(ERR_DBG, "%s: set_mac_addr failed\n", dev->name); 4557 4460 return FAILURE; 4558 4461 } ··· 4643 4546 info->regdump_len = XENA_REG_SPACE; 4644 4547 info->eedump_len = XENA_EEPROM_SPACE; 4645 4548 info->testinfo_len = S2IO_TEST_LEN; 4646 4646 - info->n_stats = S2IO_STAT_LEN; 4549 4549 + 4550 4550 + if (sp->device_type == XFRAME_I_DEVICE) 4551 4551 + info->n_stats = XFRAME_I_STAT_LEN; 4552 4552 + else 4553 4553 + info->n_stats = XFRAME_II_STAT_LEN; 4647 4554 } 4648 4555 4649 4556 /** ··· 5669 5568 tmp_stats[i++] = le32_to_cpu(stat_info->rxd_wr_cnt); 5670 5569 tmp_stats[i++] = le32_to_cpu(stat_info->txf_rd_cnt); 5671 5570 tmp_stats[i++] = le32_to_cpu(stat_info->rxf_wr_cnt); 5672 5672 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_1519_4095_frms); 5673 5673 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_4096_8191_frms); 5674 5674 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_8192_max_frms); 5675 5675 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_gt_max_frms); 5676 5676 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_osized_alt_frms); 5677 5677 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_jabber_alt_frms); 5678 5678 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_gt_max_alt_frms); 5679 5679 - tmp_stats[i++] = le64_to_cpu(stat_info->rmac_vlan_frms); 5680 5680 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_len_discard); 5681 5681 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_fcs_discard); 5682 5682 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_pf_discard); 5683 5683 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_da_discard); 5684 5684 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_red_discard); 5685 5685 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_rts_discard); 5686 5686 - tmp_stats[i++] = le32_to_cpu(stat_info->rmac_ingm_full_discard); 5687 5687 - tmp_stats[i++] = le32_to_cpu(stat_info->link_fault_cnt); 5571 5571 + 5572 5572 + /* Enhanced statistics exist only for Hercules */ 5573 5573 + if(sp->device_type == XFRAME_II_DEVICE) { 5574 5574 + tmp_stats[i++] = 5575 5575 + le64_to_cpu(stat_info->rmac_ttl_1519_4095_frms); 5576 5576 + tmp_stats[i++] = 5577 5577 + le64_to_cpu(stat_info->rmac_ttl_4096_8191_frms); 5578 5578 + tmp_stats[i++] = 5579 5579 + le64_to_cpu(stat_info->rmac_ttl_8192_max_frms); 5580 5580 + tmp_stats[i++] = le64_to_cpu(stat_info->rmac_ttl_gt_max_frms); 5581 5581 + tmp_stats[i++] = le64_to_cpu(stat_info->rmac_osized_alt_frms); 5582 5582 + tmp_stats[i++] = le64_to_cpu(stat_info->rmac_jabber_alt_frms); 5583 5583 + tmp_stats[i++] = le64_to_cpu(stat_info->rmac_gt_max_alt_frms); 5584 5584 + tmp_stats[i++] = le64_to_cpu(stat_info->rmac_vlan_frms); 5585 5585 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_len_discard); 5586 5586 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_fcs_discard); 5587 5587 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_pf_discard); 5588 5588 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_da_discard); 5589 5589 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_red_discard); 5590 5590 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_rts_discard); 5591 5591 + tmp_stats[i++] = le32_to_cpu(stat_info->rmac_ingm_full_discard); 5592 5592 + tmp_stats[i++] = le32_to_cpu(stat_info->link_fault_cnt); 5593 5593 + } 5594 5594 + 5688 5595 tmp_stats[i++] = 0; 5689 5596 tmp_stats[i++] = stat_info->sw_stat.single_ecc_errs; 5690 5597 tmp_stats[i++] = stat_info->sw_stat.double_ecc_errs; ··· 5772 5663 static void s2io_ethtool_get_strings(struct net_device *dev, 5773 5664 u32 stringset, u8 * data) 5774 5665 { 5666 5666 + int stat_size = 0; 5667 5667 + struct s2io_nic *sp = dev->priv; 5668 5668 + 5775 5669 switch (stringset) { 5776 5670 case ETH_SS_TEST: 5777 5671 memcpy(data, s2io_gstrings, S2IO_STRINGS_LEN); 5778 5672 break; 5779 5673 case ETH_SS_STATS: 5780 5780 - memcpy(data, &ethtool_stats_keys, 5781 5781 - sizeof(ethtool_stats_keys)); 5674 5674 + stat_size = sizeof(ethtool_xena_stats_keys); 5675 5675 + memcpy(data, &ethtool_xena_stats_keys,stat_size); 5676 5676 + if(sp->device_type == XFRAME_II_DEVICE) { 5677 5677 + memcpy(data + stat_size, 5678 5678 + &ethtool_enhanced_stats_keys, 5679 5679 + sizeof(ethtool_enhanced_stats_keys)); 5680 5680 + stat_size += sizeof(ethtool_enhanced_stats_keys); 5681 5681 + } 5682 5682 + 5683 5683 + memcpy(data + stat_size, &ethtool_driver_stats_keys, 5684 5684 + sizeof(ethtool_driver_stats_keys)); 5782 5685 } 5783 5686 } 5784 5687 static int s2io_ethtool_get_stats_count(struct net_device *dev) 5785 5688 { 5786 5786 - return (S2IO_STAT_LEN); 5689 5689 + struct s2io_nic *sp = dev->priv; 5690 5690 + int stat_count = 0; 5691 5691 + switch(sp->device_type) { 5692 5692 + case XFRAME_I_DEVICE: 5693 5693 + stat_count = XFRAME_I_STAT_LEN; 5694 5694 + break; 5695 5695 + 5696 5696 + case XFRAME_II_DEVICE: 5697 5697 + stat_count = XFRAME_II_STAT_LEN; 5698 5698 + break; 5699 5699 + } 5700 5700 + 5701 5701 + return stat_count; 5787 5702 } 5788 5703 5789 5704 static int s2io_ethtool_op_set_tx_csum(struct net_device *dev, u32 data) ··· 6042 5909 clear_bit(0, &(nic->link_state)); 6043 5910 6044 5911 out_unlock: 6045 6045 - rtnl_lock(); 5912 5912 + rtnl_unlock(); 6046 5913 } 6047 5914 6048 5915 static int set_rxd_buffer_pointer(struct s2io_nic *sp, struct RxD_t *rxdp, ··· 6199 6066 rx_blocks[j].rxds[k].virt_addr; 6200 6067 if(sp->rxd_mode >= RXD_MODE_3A) 6201 6068 ba = &mac_control->rings[i].ba[j][k]; 6202 6202 - set_rxd_buffer_pointer(sp, rxdp, ba, 6069 6069 + if (set_rxd_buffer_pointer(sp, rxdp, ba, 6203 6070 &skb,(u64 *)&temp0_64, 6204 6071 (u64 *)&temp1_64, 6205 6205 - (u64 *)&temp2_64, size); 6072 6072 + (u64 *)&temp2_64, 6073 6073 + size) == ENOMEM) { 6074 6074 + return 0; 6075 6075 + } 6206 6076 6207 6077 set_rxd_buffer_size(sp, rxdp, size); 6208 6078 wmb(); ··· 6248 6112 } 6249 6113 } 6250 6114 if (sp->intr_type == MSI_X) { 6251 6251 - int i; 6115 6115 + int i, msix_tx_cnt=0,msix_rx_cnt=0; 6252 6116 6253 6117 for (i=1; (sp->s2io_entries[i].in_use == MSIX_FLG); i++) { 6254 6118 if (sp->s2io_entries[i].type == MSIX_FIFO_TYPE) { ··· 6257 6121 err = request_irq(sp->entries[i].vector, 6258 6122 s2io_msix_fifo_handle, 0, sp->desc[i], 6259 6123 sp->s2io_entries[i].arg); 6260 6260 - DBG_PRINT(ERR_DBG, "%s @ 0x%llx\n", sp->desc[i], 6261 6261 - (unsigned long long)sp->msix_info[i].addr); 6124 6124 + /* If either data or addr is zero print it */ 6125 6125 + if(!(sp->msix_info[i].addr && 6126 6126 + sp->msix_info[i].data)) { 6127 6127 + DBG_PRINT(ERR_DBG, "%s @ Addr:0x%llx" 6128 6128 + "Data:0x%lx\n",sp->desc[i], 6129 6129 + (unsigned long long) 6130 6130 + sp->msix_info[i].addr, 6131 6131 + (unsigned long) 6132 6132 + ntohl(sp->msix_info[i].data)); 6133 6133 + } else { 6134 6134 + msix_tx_cnt++; 6135 6135 + } 6262 6136 } else { 6263 6137 sprintf(sp->desc[i], "%s:MSI-X-%d-RX", 6264 6138 dev->name, i); 6265 6139 err = request_irq(sp->entries[i].vector, 6266 6140 s2io_msix_ring_handle, 0, sp->desc[i], 6267 6141 sp->s2io_entries[i].arg); 6268 6268 - DBG_PRINT(ERR_DBG, "%s @ 0x%llx\n", sp->desc[i], 6269 6269 - (unsigned long long)sp->msix_info[i].addr); 6142 6142 + /* If either data or addr is zero print it */ 6143 6143 + if(!(sp->msix_info[i].addr && 6144 6144 + sp->msix_info[i].data)) { 6145 6145 + DBG_PRINT(ERR_DBG, "%s @ Addr:0x%llx" 6146 6146 + "Data:0x%lx\n",sp->desc[i], 6147 6147 + (unsigned long long) 6148 6148 + sp->msix_info[i].addr, 6149 6149 + (unsigned long) 6150 6150 + ntohl(sp->msix_info[i].data)); 6151 6151 + } else { 6152 6152 + msix_rx_cnt++; 6153 6153 + } 6270 6154 } 6271 6155 if (err) { 6272 6156 DBG_PRINT(ERR_DBG,"%s:MSI-X-%d registration " ··· 6296 6140 } 6297 6141 sp->s2io_entries[i].in_use = MSIX_REGISTERED_SUCCESS; 6298 6142 } 6143 6143 + printk("MSI-X-TX %d entries enabled\n",msix_tx_cnt); 6144 6144 + printk("MSI-X-RX %d entries enabled\n",msix_rx_cnt); 6299 6145 } 6300 6146 if (sp->intr_type == INTA) { 6301 6147 err = request_irq((int) sp->pdev->irq, s2io_isr, IRQF_SHARED, ··· 6725 6567 6726 6568 if (!sp->lro) { 6727 6569 skb->protocol = eth_type_trans(skb, dev); 6728 6728 - if (sp->vlgrp && RXD_GET_VLAN_TAG(rxdp->Control_2)) { 6570 6570 + if ((sp->vlgrp && RXD_GET_VLAN_TAG(rxdp->Control_2) && 6571 6571 + vlan_strip_flag)) { 6729 6572 /* Queueing the vlan frame to the upper layer */ 6730 6573 if (napi) 6731 6574 vlan_hwaccel_receive_skb(skb, sp->vlgrp, ··· 6863 6704 "Defaulting to INTA\n"); 6864 6705 *dev_intr_type = INTA; 6865 6706 } 6866 6866 - if ( (rx_ring_num > 1) && (*dev_intr_type != INTA) ) 6867 6867 - napi = 0; 6707 6707 + 6868 6708 if (rx_ring_mode > 3) { 6869 6709 DBG_PRINT(ERR_DBG, "s2io: Requested ring mode not supported\n"); 6870 6710 DBG_PRINT(ERR_DBG, "s2io: Defaulting to 3-buffer mode\n"); 6871 6711 rx_ring_mode = 3; 6872 6712 } 6873 6713 return SUCCESS; 6714 6714 + } 6715 6715 + 6716 6716 + /** 6717 6717 + * rts_ds_steer - Receive traffic steering based on IPv4 or IPv6 TOS 6718 6718 + * or Traffic class respectively. 6719 6719 + * @nic: device peivate variable 6720 6720 + * Description: The function configures the receive steering to 6721 6721 + * desired receive ring. 6722 6722 + * Return Value: SUCCESS on success and 6723 6723 + * '-1' on failure (endian settings incorrect). 6724 6724 + */ 6725 6725 + static int rts_ds_steer(struct s2io_nic *nic, u8 ds_codepoint, u8 ring) 6726 6726 + { 6727 6727 + struct XENA_dev_config __iomem *bar0 = nic->bar0; 6728 6728 + register u64 val64 = 0; 6729 6729 + 6730 6730 + if (ds_codepoint > 63) 6731 6731 + return FAILURE; 6732 6732 + 6733 6733 + val64 = RTS_DS_MEM_DATA(ring); 6734 6734 + writeq(val64, &bar0->rts_ds_mem_data); 6735 6735 + 6736 6736 + val64 = RTS_DS_MEM_CTRL_WE | 6737 6737 + RTS_DS_MEM_CTRL_STROBE_NEW_CMD | 6738 6738 + RTS_DS_MEM_CTRL_OFFSET(ds_codepoint); 6739 6739 + 6740 6740 + writeq(val64, &bar0->rts_ds_mem_ctrl); 6741 6741 + 6742 6742 + return wait_for_cmd_complete(&bar0->rts_ds_mem_ctrl, 6743 6743 + RTS_DS_MEM_CTRL_STROBE_CMD_BEING_EXECUTED, 6744 6744 + S2IO_BIT_RESET); 6874 6745 } 6875 6746 6876 6747 /** ··· 7197 7008 RMAC_ADDR_CMD_MEM_OFFSET(0 + MAC_MAC_ADDR_START_OFFSET); 7198 7009 writeq(val64, &bar0->rmac_addr_cmd_mem); 7199 7010 wait_for_cmd_complete(&bar0->rmac_addr_cmd_mem, 7200 7200 - RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING); 7011 7011 + RMAC_ADDR_CMD_MEM_STROBE_CMD_EXECUTING, S2IO_BIT_RESET); 7201 7012 tmp64 = readq(&bar0->rmac_addr_data0_mem); 7202 7013 mac_down = (u32) tmp64; 7203 7014 mac_up = (u32) (tmp64 >> 32); 7204 7204 - 7205 7205 - memset(sp->def_mac_addr[0].mac_addr, 0, sizeof(ETH_ALEN)); 7206 7015 7207 7016 sp->def_mac_addr[0].mac_addr[3] = (u8) (mac_up); 7208 7017 sp->def_mac_addr[0].mac_addr[2] = (u8) (mac_up >> 8);

+8 -2

drivers/net/s2io.h

reviewed

··· 32 32 #define FAILURE -1 33 33 #define S2IO_MINUS_ONE 0xFFFFFFFFFFFFFFFFULL 34 34 #define S2IO_MAX_PCI_CONFIG_SPACE_REINIT 100 35 35 - 35 35 + #define S2IO_BIT_RESET 1 36 36 + #define S2IO_BIT_SET 2 36 37 #define CHECKBIT(value, nbit) (value & (1 << nbit)) 37 38 38 39 /* Maximum time to flicker LED when asked to identify NIC using ethtool */ ··· 296 295 struct swStat sw_stat; 297 296 struct xpakStat xpak_stat; 298 297 }; 298 298 + 299 299 + /* Default value for 'vlan_strip_tag' configuration parameter */ 300 300 + #define NO_STRIP_IN_PROMISC 2 299 301 300 302 /* 301 303 * Structures representing different init time configuration ··· 1009 1005 static void s2io_card_down(struct s2io_nic *nic); 1010 1006 static int s2io_card_up(struct s2io_nic *nic); 1011 1007 static int get_xena_rev_id(struct pci_dev *pdev); 1012 1012 - static int wait_for_cmd_complete(void __iomem *addr, u64 busy_bit); 1008 1008 + static int wait_for_cmd_complete(void __iomem *addr, u64 busy_bit, 1009 1009 + int bit_state); 1013 1010 static int s2io_add_isr(struct s2io_nic * sp); 1014 1011 static void s2io_rem_isr(struct s2io_nic * sp); 1015 1012 ··· 1024 1019 static void update_L3L4_header(struct s2io_nic *sp, struct lro *lro); 1025 1020 static void lro_append_pkt(struct s2io_nic *sp, struct lro *lro, 1026 1021 struct sk_buff *skb, u32 tcp_len); 1022 1022 + static int rts_ds_steer(struct s2io_nic *nic, u8 ds_codepoint, u8 ring); 1027 1023 1028 1024 #define s2io_tcp_mss(skb) skb_shinfo(skb)->gso_size 1029 1025 #define s2io_udp_mss(skb) skb_shinfo(skb)->gso_size

-11

drivers/net/sgiseeq.c

reviewed

··· 12 12 #include <linux/init.h> 13 13 #include <linux/types.h> 14 14 #include <linux/interrupt.h> 15 15 - #include <linux/ioport.h> 16 16 - #include <linux/socket.h> 17 17 - #include <linux/in.h> 18 18 - #include <linux/route.h> 19 15 #include <linux/slab.h> 20 16 #include <linux/string.h> 21 17 #include <linux/delay.h> 22 18 #include <linux/netdevice.h> 23 19 #include <linux/etherdevice.h> 24 20 #include <linux/skbuff.h> 25 25 - #include <linux/bitops.h> 26 21 27 27 - #include <asm/byteorder.h> 28 28 - #include <asm/io.h> 29 29 - #include <asm/system.h> 30 30 - #include <asm/page.h> 31 31 - #include <asm/pgtable.h> 32 22 #include <asm/sgi/hpc3.h> 33 23 #include <asm/sgi/ip22.h> 34 34 - #include <asm/sgialib.h> 35 24 36 25 #include "sgiseeq.h" 37 26

+1 -1

drivers/net/skfp/cfm.c

reviewed

··· 73 73 /* 74 74 * map from state to downstream port type 75 75 */ 76 76 - static const u_char cf_to_ptype[] = { 76 76 + static const unsigned char cf_to_ptype[] = { 77 77 TNONE,TNONE,TNONE,TNONE,TNONE, 78 78 TNONE,TB,TB,TS, 79 79 TA,TB,TS,TB

+34 -13

drivers/net/skge.c

reviewed

··· 77 77 { PCI_DEVICE(PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C940B) }, 78 78 { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE) }, 79 79 { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_YU) }, 80 80 - { PCI_DEVICE(PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_DGE510T), }, 80 80 + { PCI_DEVICE(PCI_VENDOR_ID_DLINK, PCI_DEVICE_ID_DLINK_DGE510T) }, 81 81 { PCI_DEVICE(PCI_VENDOR_ID_DLINK, 0x4b01) }, /* DGE-530T */ 82 82 { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x4320) }, 83 83 { PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5005) }, /* Belkin */ 84 84 { PCI_DEVICE(PCI_VENDOR_ID_CNET, PCI_DEVICE_ID_CNET_GIGACARD) }, 85 85 { PCI_DEVICE(PCI_VENDOR_ID_LINKSYS, PCI_DEVICE_ID_LINKSYS_EG1064) }, 86 86 - { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0015, }, 86 86 + { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0015 }, 87 87 { 0 } 88 88 }; 89 89 MODULE_DEVICE_TABLE(pci, skge_id_table); ··· 2767 2767 return err; 2768 2768 } 2769 2769 2770 2770 + static const u8 pause_mc_addr[ETH_ALEN] = { 0x1, 0x80, 0xc2, 0x0, 0x0, 0x1 }; 2771 2771 + 2772 2772 + static void genesis_add_filter(u8 filter[8], const u8 *addr) 2773 2773 + { 2774 2774 + u32 crc, bit; 2775 2775 + 2776 2776 + crc = ether_crc_le(ETH_ALEN, addr); 2777 2777 + bit = ~crc & 0x3f; 2778 2778 + filter[bit/8] |= 1 << (bit%8); 2779 2779 + } 2780 2780 + 2770 2781 static void genesis_set_multicast(struct net_device *dev) 2771 2782 { 2772 2783 struct skge_port *skge = netdev_priv(dev); ··· 2799 2788 memset(filter, 0xff, sizeof(filter)); 2800 2789 else { 2801 2790 memset(filter, 0, sizeof(filter)); 2802 2802 - for (i = 0; list && i < count; i++, list = list->next) { 2803 2803 - u32 crc, bit; 2804 2804 - crc = ether_crc_le(ETH_ALEN, list->dmi_addr); 2805 2805 - bit = ~crc & 0x3f; 2806 2806 - filter[bit/8] |= 1 << (bit%8); 2807 2807 - } 2791 2791 + 2792 2792 + if (skge->flow_status == FLOW_STAT_REM_SEND 2793 2793 + || skge->flow_status == FLOW_STAT_SYMMETRIC) 2794 2794 + genesis_add_filter(filter, pause_mc_addr); 2795 2795 + 2796 2796 + for (i = 0; list && i < count; i++, list = list->next) 2797 2797 + genesis_add_filter(filter, list->dmi_addr); 2808 2798 } 2809 2799 2810 2800 xm_write32(hw, port, XM_MODE, mode); 2811 2801 xm_outhash(hw, port, XM_HSM, filter); 2802 2802 + } 2803 2803 + 2804 2804 + static void yukon_add_filter(u8 filter[8], const u8 *addr) 2805 2805 + { 2806 2806 + u32 bit = ether_crc(ETH_ALEN, addr) & 0x3f; 2807 2807 + filter[bit/8] |= 1 << (bit%8); 2812 2808 } 2813 2809 2814 2810 static void yukon_set_multicast(struct net_device *dev) ··· 2824 2806 struct skge_hw *hw = skge->hw; 2825 2807 int port = skge->port; 2826 2808 struct dev_mc_list *list = dev->mc_list; 2809 2809 + int rx_pause = (skge->flow_status == FLOW_STAT_REM_SEND 2810 2810 + || skge->flow_status == FLOW_STAT_SYMMETRIC); 2827 2811 u16 reg; 2828 2812 u8 filter[8]; 2829 2813 ··· 2838 2818 reg &= ~(GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA); 2839 2819 else if (dev->flags & IFF_ALLMULTI) /* all multicast */ 2840 2820 memset(filter, 0xff, sizeof(filter)); 2841 2841 - else if (dev->mc_count == 0) /* no multicast */ 2821 2821 + else if (dev->mc_count == 0 && !rx_pause)/* no multicast */ 2842 2822 reg &= ~GM_RXCR_MCF_ENA; 2843 2823 else { 2844 2824 int i; 2845 2825 reg |= GM_RXCR_MCF_ENA; 2846 2826 2847 2847 - for (i = 0; list && i < dev->mc_count; i++, list = list->next) { 2848 2848 - u32 bit = ether_crc(ETH_ALEN, list->dmi_addr) & 0x3f; 2849 2849 - filter[bit/8] |= 1 << (bit%8); 2850 2850 - } 2827 2827 + if (rx_pause) 2828 2828 + yukon_add_filter(filter, pause_mc_addr); 2829 2829 + 2830 2830 + for (i = 0; list && i < dev->mc_count; i++, list = list->next) 2831 2831 + yukon_add_filter(filter, list->dmi_addr); 2851 2832 } 2852 2833 2853 2834

+1 -2

drivers/net/skge.h

reviewed

··· 1849 1849 GMR_FS_JABBER, 1850 1850 /* Rx GMAC FIFO Flush Mask (default) */ 1851 1851 RX_FF_FL_DEF_MSK = GMR_FS_CRC_ERR | GMR_FS_RX_FF_OV |GMR_FS_MII_ERR | 1852 1852 - GMR_FS_BAD_FC | GMR_FS_GOOD_FC | GMR_FS_UN_SIZE | 1853 1853 - GMR_FS_JABBER, 1852 1852 + GMR_FS_BAD_FC | GMR_FS_UN_SIZE | GMR_FS_JABBER, 1854 1853 }; 1855 1854 1856 1855 /* RX_GMF_CTRL_T 32 bit Rx GMAC FIFO Control/Test */

+366 -188

drivers/net/spider_net.c

reviewed

··· 1 1 /* 2 2 - * Network device driver for Cell Processor-Based Blade 2 2 + * Network device driver for Cell Processor-Based Blade and Celleb platform 3 3 * 4 4 * (C) Copyright IBM Corp. 2005 5 5 + * (C) Copyright 2006 TOSHIBA CORPORATION 5 6 * 6 7 * Authors : Utz Bacher <utz.bacher@de.ibm.com> 7 8 * Jens Osterkamp <Jens.Osterkamp@de.ibm.com> ··· 167 166 } 168 167 169 168 /** 169 169 + * spider_net_setup_aneg - initial auto-negotiation setup 170 170 + * @card: device structure 171 171 + **/ 172 172 + static void 173 173 + spider_net_setup_aneg(struct spider_net_card *card) 174 174 + { 175 175 + struct mii_phy *phy = &card->phy; 176 176 + u32 advertise = 0; 177 177 + u16 bmcr, bmsr, stat1000, estat; 178 178 + 179 179 + bmcr = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMCR); 180 180 + bmsr = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR); 181 181 + stat1000 = spider_net_read_phy(card->netdev, phy->mii_id, MII_STAT1000); 182 182 + estat = spider_net_read_phy(card->netdev, phy->mii_id, MII_ESTATUS); 183 183 + 184 184 + if (bmsr & BMSR_10HALF) 185 185 + advertise |= ADVERTISED_10baseT_Half; 186 186 + if (bmsr & BMSR_10FULL) 187 187 + advertise |= ADVERTISED_10baseT_Full; 188 188 + if (bmsr & BMSR_100HALF) 189 189 + advertise |= ADVERTISED_100baseT_Half; 190 190 + if (bmsr & BMSR_100FULL) 191 191 + advertise |= ADVERTISED_100baseT_Full; 192 192 + 193 193 + if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_TFULL)) 194 194 + advertise |= SUPPORTED_1000baseT_Full; 195 195 + if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_THALF)) 196 196 + advertise |= SUPPORTED_1000baseT_Half; 197 197 + 198 198 + mii_phy_probe(phy, phy->mii_id); 199 199 + phy->def->ops->setup_aneg(phy, advertise); 200 200 + 201 201 + } 202 202 + 203 203 + /** 170 204 * spider_net_rx_irq_off - switch off rx irq on this spider card 171 205 * @card: device structure 172 206 * ··· 299 263 * returns the status as in the dmac_cmd_status field of the descriptor 300 264 */ 301 265 static inline int 302 302 - spider_net_get_descr_status(struct spider_net_descr *descr) 266 266 + spider_net_get_descr_status(struct spider_net_hw_descr *hwdescr) 303 267 { 304 304 - return descr->dmac_cmd_status & SPIDER_NET_DESCR_IND_PROC_MASK; 268 268 + return hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_IND_PROC_MASK; 305 269 } 306 270 307 271 /** ··· 319 283 descr = chain->ring; 320 284 do { 321 285 descr->bus_addr = 0; 322 322 - descr->next_descr_addr = 0; 286 286 + descr->hwdescr->next_descr_addr = 0; 323 287 descr = descr->next; 324 288 } while (descr != chain->ring); 325 289 326 290 dma_free_coherent(&card->pdev->dev, chain->num_desc, 327 327 - chain->ring, chain->dma_addr); 291 291 + chain->hwring, chain->dma_addr); 328 292 } 329 293 330 294 /** ··· 343 307 { 344 308 int i; 345 309 struct spider_net_descr *descr; 310 310 + struct spider_net_hw_descr *hwdescr; 346 311 dma_addr_t buf; 347 312 size_t alloc_size; 348 313 349 349 - alloc_size = chain->num_desc * sizeof (struct spider_net_descr); 314 314 + alloc_size = chain->num_desc * sizeof(struct spider_net_hw_descr); 350 315 351 351 - chain->ring = dma_alloc_coherent(&card->pdev->dev, alloc_size, 316 316 + chain->hwring = dma_alloc_coherent(&card->pdev->dev, alloc_size, 352 317 &chain->dma_addr, GFP_KERNEL); 353 318 354 354 - if (!chain->ring) 319 319 + if (!chain->hwring) 355 320 return -ENOMEM; 356 321 357 357 - descr = chain->ring; 358 358 - memset(descr, 0, alloc_size); 322 322 + memset(chain->ring, 0, chain->num_desc * sizeof(struct spider_net_descr)); 359 323 360 324 /* Set up the hardware pointers in each descriptor */ 325 325 + descr = chain->ring; 326 326 + hwdescr = chain->hwring; 361 327 buf = chain->dma_addr; 362 362 - for (i=0; i < chain->num_desc; i++, descr++) { 363 363 - descr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 328 328 + for (i=0; i < chain->num_desc; i++, descr++, hwdescr++) { 329 329 + hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 330 330 + hwdescr->next_descr_addr = 0; 364 331 332 332 + descr->hwdescr = hwdescr; 365 333 descr->bus_addr = buf; 366 366 - descr->next_descr_addr = 0; 367 334 descr->next = descr + 1; 368 335 descr->prev = descr - 1; 369 336 370 370 - buf += sizeof(struct spider_net_descr); 337 337 + buf += sizeof(struct spider_net_hw_descr); 371 338 } 372 339 /* do actual circular list */ 373 340 (descr-1)->next = chain->ring; ··· 396 357 descr = card->rx_chain.head; 397 358 do { 398 359 if (descr->skb) { 399 399 - dev_kfree_skb(descr->skb); 400 400 - pci_unmap_single(card->pdev, descr->buf_addr, 360 360 + pci_unmap_single(card->pdev, descr->hwdescr->buf_addr, 401 361 SPIDER_NET_MAX_FRAME, 402 362 PCI_DMA_BIDIRECTIONAL); 363 363 + dev_kfree_skb(descr->skb); 364 364 + descr->skb = NULL; 403 365 } 404 366 descr = descr->next; 405 367 } while (descr != card->rx_chain.head); ··· 420 380 spider_net_prepare_rx_descr(struct spider_net_card *card, 421 381 struct spider_net_descr *descr) 422 382 { 383 383 + struct spider_net_hw_descr *hwdescr = descr->hwdescr; 423 384 dma_addr_t buf; 424 385 int offset; 425 386 int bufsize; ··· 439 398 card->spider_stats.alloc_rx_skb_error++; 440 399 return -ENOMEM; 441 400 } 442 442 - descr->buf_size = bufsize; 443 443 - descr->result_size = 0; 444 444 - descr->valid_size = 0; 445 445 - descr->data_status = 0; 446 446 - descr->data_error = 0; 401 401 + hwdescr->buf_size = bufsize; 402 402 + hwdescr->result_size = 0; 403 403 + hwdescr->valid_size = 0; 404 404 + hwdescr->data_status = 0; 405 405 + hwdescr->data_error = 0; 447 406 448 407 offset = ((unsigned long)descr->skb->data) & 449 408 (SPIDER_NET_RXBUF_ALIGN - 1); ··· 452 411 /* iommu-map the skb */ 453 412 buf = pci_map_single(card->pdev, descr->skb->data, 454 413 SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE); 455 455 - descr->buf_addr = buf; 456 414 if (pci_dma_mapping_error(buf)) { 457 415 dev_kfree_skb_any(descr->skb); 416 416 + descr->skb = NULL; 458 417 if (netif_msg_rx_err(card) && net_ratelimit()) 459 418 pr_err("Could not iommu-map rx buffer\n"); 460 419 card->spider_stats.rx_iommu_map_error++; 461 461 - descr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 420 420 + hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 462 421 } else { 463 463 - descr->next_descr_addr = 0; 422 422 + hwdescr->buf_addr = buf; 423 423 + hwdescr->next_descr_addr = 0; 464 424 wmb(); 465 465 - descr->dmac_cmd_status = SPIDER_NET_DESCR_CARDOWNED | 425 425 + hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_CARDOWNED | 466 426 SPIDER_NET_DMAC_NOINTR_COMPLETE; 467 427 468 428 wmb(); 469 469 - descr->prev->next_descr_addr = descr->bus_addr; 429 429 + descr->prev->hwdescr->next_descr_addr = descr->bus_addr; 470 430 } 471 431 472 432 return 0; ··· 523 481 if (!spin_trylock_irqsave(&chain->lock, flags)) 524 482 return; 525 483 526 526 - while (spider_net_get_descr_status(chain->head) == 484 484 + while (spider_net_get_descr_status(chain->head->hwdescr) == 527 485 SPIDER_NET_DESCR_NOT_IN_USE) { 528 486 if (spider_net_prepare_rx_descr(card, chain->head)) 529 487 break; ··· 684 642 spider_net_prepare_tx_descr(struct spider_net_card *card, 685 643 struct sk_buff *skb) 686 644 { 645 645 + struct spider_net_descr_chain *chain = &card->tx_chain; 687 646 struct spider_net_descr *descr; 647 647 + struct spider_net_hw_descr *hwdescr; 688 648 dma_addr_t buf; 689 649 unsigned long flags; 690 650 ··· 699 655 return -ENOMEM; 700 656 } 701 657 702 702 - spin_lock_irqsave(&card->tx_chain.lock, flags); 658 658 + spin_lock_irqsave(&chain->lock, flags); 703 659 descr = card->tx_chain.head; 704 704 - card->tx_chain.head = descr->next; 660 660 + if (descr->next == chain->tail->prev) { 661 661 + spin_unlock_irqrestore(&chain->lock, flags); 662 662 + pci_unmap_single(card->pdev, buf, skb->len, PCI_DMA_TODEVICE); 663 663 + return -ENOMEM; 664 664 + } 665 665 + hwdescr = descr->hwdescr; 666 666 + chain->head = descr->next; 705 667 706 706 - descr->buf_addr = buf; 707 707 - descr->buf_size = skb->len; 708 708 - descr->next_descr_addr = 0; 709 668 descr->skb = skb; 710 710 - descr->data_status = 0; 669 669 + hwdescr->buf_addr = buf; 670 670 + hwdescr->buf_size = skb->len; 671 671 + hwdescr->next_descr_addr = 0; 672 672 + hwdescr->data_status = 0; 711 673 712 712 - descr->dmac_cmd_status = 674 674 + hwdescr->dmac_cmd_status = 713 675 SPIDER_NET_DESCR_CARDOWNED | SPIDER_NET_DMAC_NOCS; 714 714 - spin_unlock_irqrestore(&card->tx_chain.lock, flags); 676 676 + spin_unlock_irqrestore(&chain->lock, flags); 715 677 716 678 if (skb->protocol == htons(ETH_P_IP)) 717 679 switch (skb->nh.iph->protocol) { 718 680 case IPPROTO_TCP: 719 719 - descr->dmac_cmd_status |= SPIDER_NET_DMAC_TCP; 681 681 + hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_TCP; 720 682 break; 721 683 case IPPROTO_UDP: 722 722 - descr->dmac_cmd_status |= SPIDER_NET_DMAC_UDP; 684 684 + hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_UDP; 723 685 break; 724 686 } 725 687 726 688 /* Chain the bus address, so that the DMA engine finds this descr. */ 727 727 - descr->prev->next_descr_addr = descr->bus_addr; 689 689 + wmb(); 690 690 + descr->prev->hwdescr->next_descr_addr = descr->bus_addr; 728 691 729 692 card->netdev->trans_start = jiffies; /* set netdev watchdog timer */ 730 693 return 0; ··· 740 689 static int 741 690 spider_net_set_low_watermark(struct spider_net_card *card) 742 691 { 692 692 + struct spider_net_descr *descr = card->tx_chain.tail; 693 693 + struct spider_net_hw_descr *hwdescr; 743 694 unsigned long flags; 744 695 int status; 745 696 int cnt=0; 746 697 int i; 747 747 - struct spider_net_descr *descr = card->tx_chain.tail; 748 698 749 699 /* Measure the length of the queue. Measurement does not 750 700 * need to be precise -- does not need a lock. */ 751 701 while (descr != card->tx_chain.head) { 752 752 - status = descr->dmac_cmd_status & SPIDER_NET_DESCR_NOT_IN_USE; 702 702 + status = descr->hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_NOT_IN_USE; 753 703 if (status == SPIDER_NET_DESCR_NOT_IN_USE) 754 704 break; 755 705 descr = descr->next; ··· 769 717 770 718 /* Set the new watermark, clear the old watermark */ 771 719 spin_lock_irqsave(&card->tx_chain.lock, flags); 772 772 - descr->dmac_cmd_status |= SPIDER_NET_DESCR_TXDESFLG; 773 773 - if (card->low_watermark && card->low_watermark != descr) 774 774 - card->low_watermark->dmac_cmd_status = 775 775 - card->low_watermark->dmac_cmd_status & ~SPIDER_NET_DESCR_TXDESFLG; 720 720 + descr->hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_TXDESFLG; 721 721 + if (card->low_watermark && card->low_watermark != descr) { 722 722 + hwdescr = card->low_watermark->hwdescr; 723 723 + hwdescr->dmac_cmd_status = 724 724 + hwdescr->dmac_cmd_status & ~SPIDER_NET_DESCR_TXDESFLG; 725 725 + } 776 726 card->low_watermark = descr; 777 727 spin_unlock_irqrestore(&card->tx_chain.lock, flags); 778 728 return cnt; ··· 797 743 { 798 744 struct spider_net_descr_chain *chain = &card->tx_chain; 799 745 struct spider_net_descr *descr; 746 746 + struct spider_net_hw_descr *hwdescr; 800 747 struct sk_buff *skb; 801 748 u32 buf_addr; 802 749 unsigned long flags; 803 750 int status; 804 751 805 805 - while (chain->tail != chain->head) { 752 752 + while (1) { 806 753 spin_lock_irqsave(&chain->lock, flags); 754 754 + if (chain->tail == chain->head) { 755 755 + spin_unlock_irqrestore(&chain->lock, flags); 756 756 + return 0; 757 757 + } 807 758 descr = chain->tail; 759 759 + hwdescr = descr->hwdescr; 808 760 809 809 - status = spider_net_get_descr_status(descr); 761 761 + status = spider_net_get_descr_status(hwdescr); 810 762 switch (status) { 811 763 case SPIDER_NET_DESCR_COMPLETE: 812 764 card->netdev_stats.tx_packets++; ··· 848 788 } 849 789 850 790 chain->tail = descr->next; 851 851 - descr->dmac_cmd_status |= SPIDER_NET_DESCR_NOT_IN_USE; 791 791 + hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_NOT_IN_USE; 852 792 skb = descr->skb; 853 853 - buf_addr = descr->buf_addr; 793 793 + descr->skb = NULL; 794 794 + buf_addr = hwdescr->buf_addr; 854 795 spin_unlock_irqrestore(&chain->lock, flags); 855 796 856 797 /* unmap the skb */ ··· 887 826 888 827 descr = card->tx_chain.tail; 889 828 for (;;) { 890 890 - if (spider_net_get_descr_status(descr) == 829 829 + if (spider_net_get_descr_status(descr->hwdescr) == 891 830 SPIDER_NET_DESCR_CARDOWNED) { 892 831 spider_net_write_reg(card, SPIDER_NET_GDTDCHA, 893 832 descr->bus_addr); ··· 916 855 { 917 856 int cnt; 918 857 struct spider_net_card *card = netdev_priv(netdev); 919 919 - struct spider_net_descr_chain *chain = &card->tx_chain; 920 858 921 859 spider_net_release_tx_chain(card, 0); 922 860 923 923 - if ((chain->head->next == chain->tail->prev) || 924 924 - (spider_net_prepare_tx_descr(card, skb) != 0)) { 925 925 - 861 861 + if (spider_net_prepare_tx_descr(card, skb) != 0) { 926 862 card->netdev_stats.tx_dropped++; 927 863 netif_stop_queue(netdev); 928 864 return NETDEV_TX_BUSY; ··· 980 922 spider_net_pass_skb_up(struct spider_net_descr *descr, 981 923 struct spider_net_card *card) 982 924 { 925 925 + struct spider_net_hw_descr *hwdescr= descr->hwdescr; 983 926 struct sk_buff *skb; 984 927 struct net_device *netdev; 985 928 u32 data_status, data_error; 986 929 987 987 - data_status = descr->data_status; 988 988 - data_error = descr->data_error; 930 930 + data_status = hwdescr->data_status; 931 931 + data_error = hwdescr->data_error; 989 932 netdev = card->netdev; 990 933 991 934 skb = descr->skb; 992 935 skb->dev = netdev; 993 993 - skb_put(skb, descr->valid_size); 936 936 + skb_put(skb, hwdescr->valid_size); 994 937 995 938 /* the card seems to add 2 bytes of junk in front 996 939 * of the ethernet frame */ ··· 1053 994 #endif 1054 995 1055 996 /** 1056 1056 - * spider_net_decode_one_descr - processes an rx descriptor 997 997 + * spider_net_decode_one_descr - processes an RX descriptor 1057 998 * @card: card structure 1058 999 * 1059 1059 - * Returns 1 if a packet has been sent to the stack, otherwise 0 1000 1000 + * Returns 1 if a packet has been sent to the stack, otherwise 0. 1060 1001 * 1061 1061 - * Processes an rx descriptor by iommu-unmapping the data buffer and passing 1062 1062 - * the packet up to the stack. This function is called in softirq 1063 1063 - * context, e.g. either bottom half from interrupt or NAPI polling context 1002 1002 + * Processes an RX descriptor by iommu-unmapping the data buffer 1003 1003 + * and passing the packet up to the stack. This function is called 1004 1004 + * in softirq context, e.g. either bottom half from interrupt or 1005 1005 + * NAPI polling context. 1064 1006 */ 1065 1007 static int 1066 1008 spider_net_decode_one_descr(struct spider_net_card *card) 1067 1009 { 1068 1010 struct spider_net_descr_chain *chain = &card->rx_chain; 1069 1011 struct spider_net_descr *descr = chain->tail; 1012 1012 + struct spider_net_hw_descr *hwdescr = descr->hwdescr; 1070 1013 int status; 1071 1014 1072 1072 - status = spider_net_get_descr_status(descr); 1015 1015 + status = spider_net_get_descr_status(hwdescr); 1073 1016 1074 1017 /* Nothing in the descriptor, or ring must be empty */ 1075 1018 if ((status == SPIDER_NET_DESCR_CARDOWNED) || ··· 1082 1021 chain->tail = descr->next; 1083 1022 1084 1023 /* unmap descriptor */ 1085 1085 - pci_unmap_single(card->pdev, descr->buf_addr, 1024 1024 + pci_unmap_single(card->pdev, hwdescr->buf_addr, 1086 1025 SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE); 1087 1026 1088 1027 if ( (status == SPIDER_NET_DESCR_RESPONSE_ERROR) || ··· 1098 1037 if ( (status != SPIDER_NET_DESCR_COMPLETE) && 1099 1038 (status != SPIDER_NET_DESCR_FRAME_END) ) { 1100 1039 if (netif_msg_rx_err(card)) 1101 1101 - pr_err("%s: RX descriptor with unkown state %d\n", 1040 1040 + pr_err("%s: RX descriptor with unknown state %d\n", 1102 1041 card->netdev->name, status); 1103 1042 card->spider_stats.rx_desc_unk_state++; 1104 1043 goto bad_desc; 1105 1044 } 1106 1045 1107 1046 /* The cases we'll throw away the packet immediately */ 1108 1108 - if (descr->data_error & SPIDER_NET_DESTROY_RX_FLAGS) { 1047 1047 + if (hwdescr->data_error & SPIDER_NET_DESTROY_RX_FLAGS) { 1109 1048 if (netif_msg_rx_err(card)) 1110 1049 pr_err("%s: error in received descriptor found, " 1111 1050 "data_status=x%08x, data_error=x%08x\n", 1112 1051 card->netdev->name, 1113 1113 - descr->data_status, descr->data_error); 1052 1052 + hwdescr->data_status, hwdescr->data_error); 1114 1053 goto bad_desc; 1115 1054 } 1116 1055 1117 1117 - if (descr->dmac_cmd_status & 0xfefe) { 1056 1056 + if (hwdescr->dmac_cmd_status & 0xfefe) { 1118 1057 pr_err("%s: bad status, cmd_status=x%08x\n", 1119 1058 card->netdev->name, 1120 1120 - descr->dmac_cmd_status); 1121 1121 - pr_err("buf_addr=x%08x\n", descr->buf_addr); 1122 1122 - pr_err("buf_size=x%08x\n", descr->buf_size); 1123 1123 - pr_err("next_descr_addr=x%08x\n", descr->next_descr_addr); 1124 1124 - pr_err("result_size=x%08x\n", descr->result_size); 1125 1125 - pr_err("valid_size=x%08x\n", descr->valid_size); 1126 1126 - pr_err("data_status=x%08x\n", descr->data_status); 1127 1127 - pr_err("data_error=x%08x\n", descr->data_error); 1128 1128 - pr_err("bus_addr=x%08x\n", descr->bus_addr); 1059 1059 + hwdescr->dmac_cmd_status); 1060 1060 + pr_err("buf_addr=x%08x\n", hwdescr->buf_addr); 1061 1061 + pr_err("buf_size=x%08x\n", hwdescr->buf_size); 1062 1062 + pr_err("next_descr_addr=x%08x\n", hwdescr->next_descr_addr); 1063 1063 + pr_err("result_size=x%08x\n", hwdescr->result_size); 1064 1064 + pr_err("valid_size=x%08x\n", hwdescr->valid_size); 1065 1065 + pr_err("data_status=x%08x\n", hwdescr->data_status); 1066 1066 + pr_err("data_error=x%08x\n", hwdescr->data_error); 1129 1067 pr_err("which=%ld\n", descr - card->rx_chain.ring); 1130 1068 1131 1069 card->spider_stats.rx_desc_error++; ··· 1133 1073 1134 1074 /* Ok, we've got a packet in descr */ 1135 1075 spider_net_pass_skb_up(descr, card); 1136 1136 - descr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 1076 1076 + hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 1137 1077 return 1; 1138 1078 1139 1079 bad_desc: 1140 1080 dev_kfree_skb_irq(descr->skb); 1141 1141 - descr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 1081 1081 + descr->skb = NULL; 1082 1082 + hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE; 1142 1083 return 0; 1143 1084 } 1144 1085 ··· 1309 1248 } 1310 1249 1311 1250 /** 1251 1251 + * spider_net_link_reset 1252 1252 + * @netdev: net device structure 1253 1253 + * 1254 1254 + * This is called when the PHY_LINK signal is asserted. For the blade this is 1255 1255 + * not connected so we should never get here. 1256 1256 + * 1257 1257 + */ 1258 1258 + static void 1259 1259 + spider_net_link_reset(struct net_device *netdev) 1260 1260 + { 1261 1261 + 1262 1262 + struct spider_net_card *card = netdev_priv(netdev); 1263 1263 + 1264 1264 + del_timer_sync(&card->aneg_timer); 1265 1265 + 1266 1266 + /* clear interrupt, block further interrupts */ 1267 1267 + spider_net_write_reg(card, SPIDER_NET_GMACST, 1268 1268 + spider_net_read_reg(card, SPIDER_NET_GMACST)); 1269 1269 + spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0); 1270 1270 + 1271 1271 + /* reset phy and setup aneg */ 1272 1272 + spider_net_setup_aneg(card); 1273 1273 + mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 1274 1274 + 1275 1275 + } 1276 1276 + 1277 1277 + /** 1312 1278 * spider_net_handle_error_irq - handles errors raised by an interrupt 1313 1279 * @card: card structure 1314 1280 * @status_reg: interrupt status register 0 (GHIINT0STS) ··· 1447 1359 switch (i) 1448 1360 { 1449 1361 case SPIDER_NET_GTMFLLINT: 1450 1450 - if (netif_msg_intr(card) && net_ratelimit()) 1451 1451 - pr_err("Spider TX RAM full\n"); 1362 1362 + /* TX RAM full may happen on a usual case. 1363 1363 + * Logging is not needed. */ 1452 1364 show_error = 0; 1453 1365 break; 1454 1366 case SPIDER_NET_GRFDFLLINT: /* fallthrough */ ··· 1588 1500 if (status_reg & SPIDER_NET_TXINT) 1589 1501 netif_rx_schedule(netdev); 1590 1502 1503 1503 + if (status_reg & SPIDER_NET_LINKINT) 1504 1504 + spider_net_link_reset(netdev); 1505 1505 + 1591 1506 if (status_reg & SPIDER_NET_ERRINT ) 1592 1507 spider_net_handle_error_irq(card, status_reg); 1593 1508 ··· 1631 1540 1632 1541 spider_net_write_reg(card, SPIDER_NET_CKRCTRL, 1633 1542 SPIDER_NET_CKRCTRL_RUN_VALUE); 1543 1543 + 1544 1544 + /* trigger ETOMOD signal */ 1545 1545 + spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, 1546 1546 + spider_net_read_reg(card, SPIDER_NET_GMACOPEMD) | 0x4); 1547 1547 + 1634 1548 } 1635 1549 1636 1550 /** ··· 1720 1624 1721 1625 spider_net_write_reg(card, SPIDER_NET_GMACLENLMT, 1722 1626 SPIDER_NET_LENLMT_VALUE); 1723 1723 - spider_net_write_reg(card, SPIDER_NET_GMACMODE, 1724 1724 - SPIDER_NET_MACMODE_VALUE); 1725 1627 spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, 1726 1628 SPIDER_NET_OPMODE_VALUE); 1727 1629 ··· 1733 1639 1734 1640 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR, 1735 1641 SPIDER_NET_GDTBSTA); 1736 1736 - } 1737 1737 - 1738 1738 - /** 1739 1739 - * spider_net_open - called upon ifonfig up 1740 1740 - * @netdev: interface device structure 1741 1741 - * 1742 1742 - * returns 0 on success, <0 on failure 1743 1743 - * 1744 1744 - * spider_net_open allocates all the descriptors and memory needed for 1745 1745 - * operation, sets up multicast list and enables interrupts 1746 1746 - */ 1747 1747 - int 1748 1748 - spider_net_open(struct net_device *netdev) 1749 1749 - { 1750 1750 - struct spider_net_card *card = netdev_priv(netdev); 1751 1751 - int result; 1752 1752 - 1753 1753 - result = spider_net_init_chain(card, &card->tx_chain); 1754 1754 - if (result) 1755 1755 - goto alloc_tx_failed; 1756 1756 - card->low_watermark = NULL; 1757 1757 - 1758 1758 - result = spider_net_init_chain(card, &card->rx_chain); 1759 1759 - if (result) 1760 1760 - goto alloc_rx_failed; 1761 1761 - 1762 1762 - /* Allocate rx skbs */ 1763 1763 - if (spider_net_alloc_rx_skbs(card)) 1764 1764 - goto alloc_skbs_failed; 1765 1765 - 1766 1766 - spider_net_set_multi(netdev); 1767 1767 - 1768 1768 - /* further enhancement: setup hw vlan, if needed */ 1769 1769 - 1770 1770 - result = -EBUSY; 1771 1771 - if (request_irq(netdev->irq, spider_net_interrupt, 1772 1772 - IRQF_SHARED, netdev->name, netdev)) 1773 1773 - goto register_int_failed; 1774 1774 - 1775 1775 - spider_net_enable_card(card); 1776 1776 - 1777 1777 - netif_start_queue(netdev); 1778 1778 - netif_carrier_on(netdev); 1779 1779 - netif_poll_enable(netdev); 1780 1780 - 1781 1781 - return 0; 1782 1782 - 1783 1783 - register_int_failed: 1784 1784 - spider_net_free_rx_chain_contents(card); 1785 1785 - alloc_skbs_failed: 1786 1786 - spider_net_free_chain(card, &card->rx_chain); 1787 1787 - alloc_rx_failed: 1788 1788 - spider_net_free_chain(card, &card->tx_chain); 1789 1789 - alloc_tx_failed: 1790 1790 - return result; 1791 1791 - } 1792 1792 - 1793 1793 - /** 1794 1794 - * spider_net_setup_phy - setup PHY 1795 1795 - * @card: card structure 1796 1796 - * 1797 1797 - * returns 0 on success, <0 on failure 1798 1798 - * 1799 1799 - * spider_net_setup_phy is used as part of spider_net_probe. Sets 1800 1800 - * the PHY to 1000 Mbps 1801 1801 - **/ 1802 1802 - static int 1803 1803 - spider_net_setup_phy(struct spider_net_card *card) 1804 1804 - { 1805 1805 - struct mii_phy *phy = &card->phy; 1806 1806 - 1807 1807 - spider_net_write_reg(card, SPIDER_NET_GDTDMASEL, 1808 1808 - SPIDER_NET_DMASEL_VALUE); 1809 1809 - spider_net_write_reg(card, SPIDER_NET_GPCCTRL, 1810 1810 - SPIDER_NET_PHY_CTRL_VALUE); 1811 1811 - phy->mii_id = 1; 1812 1812 - phy->dev = card->netdev; 1813 1813 - phy->mdio_read = spider_net_read_phy; 1814 1814 - phy->mdio_write = spider_net_write_phy; 1815 1815 - 1816 1816 - mii_phy_probe(phy, phy->mii_id); 1817 1817 - 1818 1818 - if (phy->def->ops->setup_forced) 1819 1819 - phy->def->ops->setup_forced(phy, SPEED_1000, DUPLEX_FULL); 1820 1820 - 1821 1821 - phy->def->ops->enable_fiber(phy); 1822 1822 - 1823 1823 - phy->def->ops->read_link(phy); 1824 1824 - pr_info("Found %s with %i Mbps, %s-duplex.\n", phy->def->name, 1825 1825 - phy->speed, phy->duplex==1 ? "Full" : "Half"); 1826 1826 - 1827 1827 - return 0; 1828 1642 } 1829 1643 1830 1644 /** ··· 1854 1852 } 1855 1853 1856 1854 /** 1855 1855 + * spider_net_open - called upon ifonfig up 1856 1856 + * @netdev: interface device structure 1857 1857 + * 1858 1858 + * returns 0 on success, <0 on failure 1859 1859 + * 1860 1860 + * spider_net_open allocates all the descriptors and memory needed for 1861 1861 + * operation, sets up multicast list and enables interrupts 1862 1862 + */ 1863 1863 + int 1864 1864 + spider_net_open(struct net_device *netdev) 1865 1865 + { 1866 1866 + struct spider_net_card *card = netdev_priv(netdev); 1867 1867 + int result; 1868 1868 + 1869 1869 + result = spider_net_init_firmware(card); 1870 1870 + if (result) 1871 1871 + goto init_firmware_failed; 1872 1872 + 1873 1873 + /* start probing with copper */ 1874 1874 + spider_net_setup_aneg(card); 1875 1875 + if (card->phy.def->phy_id) 1876 1876 + mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 1877 1877 + 1878 1878 + result = spider_net_init_chain(card, &card->tx_chain); 1879 1879 + if (result) 1880 1880 + goto alloc_tx_failed; 1881 1881 + card->low_watermark = NULL; 1882 1882 + 1883 1883 + result = spider_net_init_chain(card, &card->rx_chain); 1884 1884 + if (result) 1885 1885 + goto alloc_rx_failed; 1886 1886 + 1887 1887 + /* Allocate rx skbs */ 1888 1888 + if (spider_net_alloc_rx_skbs(card)) 1889 1889 + goto alloc_skbs_failed; 1890 1890 + 1891 1891 + spider_net_set_multi(netdev); 1892 1892 + 1893 1893 + /* further enhancement: setup hw vlan, if needed */ 1894 1894 + 1895 1895 + result = -EBUSY; 1896 1896 + if (request_irq(netdev->irq, spider_net_interrupt, 1897 1897 + IRQF_SHARED, netdev->name, netdev)) 1898 1898 + goto register_int_failed; 1899 1899 + 1900 1900 + spider_net_enable_card(card); 1901 1901 + 1902 1902 + netif_start_queue(netdev); 1903 1903 + netif_carrier_on(netdev); 1904 1904 + netif_poll_enable(netdev); 1905 1905 + 1906 1906 + return 0; 1907 1907 + 1908 1908 + register_int_failed: 1909 1909 + spider_net_free_rx_chain_contents(card); 1910 1910 + alloc_skbs_failed: 1911 1911 + spider_net_free_chain(card, &card->rx_chain); 1912 1912 + alloc_rx_failed: 1913 1913 + spider_net_free_chain(card, &card->tx_chain); 1914 1914 + alloc_tx_failed: 1915 1915 + del_timer_sync(&card->aneg_timer); 1916 1916 + init_firmware_failed: 1917 1917 + return result; 1918 1918 + } 1919 1919 + 1920 1920 + /** 1921 1921 + * spider_net_link_phy 1922 1922 + * @data: used for pointer to card structure 1923 1923 + * 1924 1924 + */ 1925 1925 + static void spider_net_link_phy(unsigned long data) 1926 1926 + { 1927 1927 + struct spider_net_card *card = (struct spider_net_card *)data; 1928 1928 + struct mii_phy *phy = &card->phy; 1929 1929 + 1930 1930 + /* if link didn't come up after SPIDER_NET_ANEG_TIMEOUT tries, setup phy again */ 1931 1931 + if (card->aneg_count > SPIDER_NET_ANEG_TIMEOUT) { 1932 1932 + 1933 1933 + pr_info("%s: link is down trying to bring it up\n", card->netdev->name); 1934 1934 + 1935 1935 + switch (card->medium) { 1936 1936 + case BCM54XX_COPPER: 1937 1937 + /* enable fiber with autonegotiation first */ 1938 1938 + if (phy->def->ops->enable_fiber) 1939 1939 + phy->def->ops->enable_fiber(phy, 1); 1940 1940 + card->medium = BCM54XX_FIBER; 1941 1941 + break; 1942 1942 + 1943 1943 + case BCM54XX_FIBER: 1944 1944 + /* fiber didn't come up, try to disable fiber autoneg */ 1945 1945 + if (phy->def->ops->enable_fiber) 1946 1946 + phy->def->ops->enable_fiber(phy, 0); 1947 1947 + card->medium = BCM54XX_UNKNOWN; 1948 1948 + break; 1949 1949 + 1950 1950 + case BCM54XX_UNKNOWN: 1951 1951 + /* copper, fiber with and without failed, 1952 1952 + * retry from beginning */ 1953 1953 + spider_net_setup_aneg(card); 1954 1954 + card->medium = BCM54XX_COPPER; 1955 1955 + break; 1956 1956 + } 1957 1957 + 1958 1958 + card->aneg_count = 0; 1959 1959 + mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 1960 1960 + return; 1961 1961 + } 1962 1962 + 1963 1963 + /* link still not up, try again later */ 1964 1964 + if (!(phy->def->ops->poll_link(phy))) { 1965 1965 + card->aneg_count++; 1966 1966 + mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER); 1967 1967 + return; 1968 1968 + } 1969 1969 + 1970 1970 + /* link came up, get abilities */ 1971 1971 + phy->def->ops->read_link(phy); 1972 1972 + 1973 1973 + spider_net_write_reg(card, SPIDER_NET_GMACST, 1974 1974 + spider_net_read_reg(card, SPIDER_NET_GMACST)); 1975 1975 + spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0x4); 1976 1976 + 1977 1977 + if (phy->speed == 1000) 1978 1978 + spider_net_write_reg(card, SPIDER_NET_GMACMODE, 0x00000001); 1979 1979 + else 1980 1980 + spider_net_write_reg(card, SPIDER_NET_GMACMODE, 0); 1981 1981 + 1982 1982 + card->aneg_count = 0; 1983 1983 + 1984 1984 + pr_debug("Found %s with %i Mbps, %s-duplex %sautoneg.\n", 1985 1985 + phy->def->name, phy->speed, phy->duplex==1 ? "Full" : "Half", 1986 1986 + phy->autoneg==1 ? "" : "no "); 1987 1987 + 1988 1988 + return; 1989 1989 + } 1990 1990 + 1991 1991 + /** 1992 1992 + * spider_net_setup_phy - setup PHY 1993 1993 + * @card: card structure 1994 1994 + * 1995 1995 + * returns 0 on success, <0 on failure 1996 1996 + * 1997 1997 + * spider_net_setup_phy is used as part of spider_net_probe. 1998 1998 + **/ 1999 1999 + static int 2000 2000 + spider_net_setup_phy(struct spider_net_card *card) 2001 2001 + { 2002 2002 + struct mii_phy *phy = &card->phy; 2003 2003 + 2004 2004 + spider_net_write_reg(card, SPIDER_NET_GDTDMASEL, 2005 2005 + SPIDER_NET_DMASEL_VALUE); 2006 2006 + spider_net_write_reg(card, SPIDER_NET_GPCCTRL, 2007 2007 + SPIDER_NET_PHY_CTRL_VALUE); 2008 2008 + 2009 2009 + phy->dev = card->netdev; 2010 2010 + phy->mdio_read = spider_net_read_phy; 2011 2011 + phy->mdio_write = spider_net_write_phy; 2012 2012 + 2013 2013 + for (phy->mii_id = 1; phy->mii_id <= 31; phy->mii_id++) { 2014 2014 + unsigned short id; 2015 2015 + id = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR); 2016 2016 + if (id != 0x0000 && id != 0xffff) { 2017 2017 + if (!mii_phy_probe(phy, phy->mii_id)) { 2018 2018 + pr_info("Found %s.\n", phy->def->name); 2019 2019 + break; 2020 2020 + } 2021 2021 + } 2022 2022 + } 2023 2023 + 2024 2024 + return 0; 2025 2025 + } 2026 2026 + 2027 2027 + /** 1857 2028 * spider_net_workaround_rxramfull - work around firmware bug 1858 2029 * @card: card structure 1859 2030 * ··· 2075 1900 netif_carrier_off(netdev); 2076 1901 netif_stop_queue(netdev); 2077 1902 del_timer_sync(&card->tx_timer); 1903 1903 + del_timer_sync(&card->aneg_timer); 2078 1904 2079 1905 /* disable/mask all interrupts */ 2080 1906 spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, 0); 2081 1907 spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK, 0); 2082 1908 spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK, 0); 1909 1909 + spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0); 2083 1910 2084 2084 - /* free_irq(netdev->irq, netdev);*/ 2085 2085 - free_irq(to_pci_dev(netdev->dev.parent)->irq, netdev); 1911 1911 + free_irq(netdev->irq, netdev); 2086 1912 2087 1913 spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR, 2088 1914 SPIDER_NET_DMA_TX_FEND_VALUE); ··· 2093 1917 2094 1918 /* release chains */ 2095 1919 spider_net_release_tx_chain(card, 1); 2096 2096 - spider_net_free_rx_chain_contents(card); 2097 2097 - 2098 1920 spider_net_free_rx_chain_contents(card); 2099 1921 2100 1922 spider_net_free_chain(card, &card->tx_chain); ··· 2125 1951 spider_net_init_card(card); 2126 1952 2127 1953 if (spider_net_setup_phy(card)) 2128 2128 - goto out; 2129 2129 - if (spider_net_init_firmware(card)) 2130 1954 goto out; 2131 1955 2132 1956 spider_net_open(netdev); ··· 2218 2046 card->tx_timer.data = (unsigned long) card; 2219 2047 netdev->irq = card->pdev->irq; 2220 2048 2221 2221 - card->options.rx_csum = SPIDER_NET_RX_CSUM_DEFAULT; 2049 2049 + card->aneg_count = 0; 2050 2050 + init_timer(&card->aneg_timer); 2051 2051 + card->aneg_timer.function = spider_net_link_phy; 2052 2052 + card->aneg_timer.data = (unsigned long) card; 2222 2053 2223 2223 - card->tx_chain.num_desc = tx_descriptors; 2224 2224 - card->rx_chain.num_desc = rx_descriptors; 2054 2054 + card->options.rx_csum = SPIDER_NET_RX_CSUM_DEFAULT; 2225 2055 2226 2056 spider_net_setup_netdev_ops(netdev); 2227 2057 ··· 2272 2098 { 2273 2099 struct net_device *netdev; 2274 2100 struct spider_net_card *card; 2101 2101 + size_t alloc_size; 2275 2102 2276 2276 - netdev = alloc_etherdev(sizeof(struct spider_net_card)); 2103 2103 + alloc_size = sizeof(struct spider_net_card) + 2104 2104 + (tx_descriptors + rx_descriptors) * sizeof(struct spider_net_descr); 2105 2105 + netdev = alloc_etherdev(alloc_size); 2277 2106 if (!netdev) 2278 2107 return NULL; 2279 2108 ··· 2286 2109 INIT_WORK(&card->tx_timeout_task, spider_net_tx_timeout_task); 2287 2110 init_waitqueue_head(&card->waitq); 2288 2111 atomic_set(&card->tx_timeout_task_counter, 0); 2112 2112 + 2113 2113 + card->rx_chain.num_desc = rx_descriptors; 2114 2114 + card->rx_chain.ring = card->darray; 2115 2115 + card->tx_chain.num_desc = tx_descriptors; 2116 2116 + card->tx_chain.ring = card->darray + rx_descriptors; 2289 2117 2290 2118 return card; 2291 2119 } ··· 2399 2217 spider_net_init_card(card); 2400 2218 2401 2219 err = spider_net_setup_phy(card); 2402 2402 - if (err) 2403 2403 - goto out_undo_pci; 2404 2404 - 2405 2405 - err = spider_net_init_firmware(card); 2406 2220 if (err) 2407 2221 goto out_undo_pci; 2408 2222

+26 -8

drivers/net/spider_net.h

reviewed

··· 1 1 /* 2 2 - * Network device driver for Cell Processor-Based Blade 2 2 + * Network device driver for Cell Processor-Based Blade and Celleb platform 3 3 * 4 4 * (C) Copyright IBM Corp. 2005 5 5 + * (C) Copyright 2006 TOSHIBA CORPORATION 5 6 * 6 7 * Authors : Utz Bacher <utz.bacher@de.ibm.com> 7 8 * Jens Osterkamp <Jens.Osterkamp@de.ibm.com> ··· 25 24 #ifndef _SPIDER_NET_H 26 25 #define _SPIDER_NET_H 27 26 28 28 - #define VERSION "1.6 B" 27 27 + #define VERSION "2.0 A" 29 28 30 29 #include "sungem_phy.h" 31 30 ··· 51 50 #define SPIDER_NET_TX_DESCRIPTORS_MAX 512 52 51 53 52 #define SPIDER_NET_TX_TIMER (HZ/5) 53 53 + #define SPIDER_NET_ANEG_TIMER (HZ) 54 54 + #define SPIDER_NET_ANEG_TIMEOUT 2 54 55 55 56 #define SPIDER_NET_RX_CSUM_DEFAULT 1 56 57 ··· 107 104 108 105 #define SPIDER_NET_GMACOPEMD 0x00000100 109 106 #define SPIDER_NET_GMACLENLMT 0x00000108 107 107 + #define SPIDER_NET_GMACST 0x00000110 110 108 #define SPIDER_NET_GMACINTEN 0x00000118 111 109 #define SPIDER_NET_GMACPHYCTRL 0x00000120 112 110 ··· 185 181 186 182 /* pause frames: automatic, no upper retransmission count */ 187 183 /* outside loopback mode: ETOMOD signal dont matter, not connected */ 188 188 - #define SPIDER_NET_OPMODE_VALUE 0x00000063 184 184 + /* ETOMOD signal is brought to PHY reset. bit 2 must be 1 in Celleb */ 185 185 + #define SPIDER_NET_OPMODE_VALUE 0x00000067 189 186 /*#define SPIDER_NET_OPMODE_VALUE 0x001b0062*/ 190 187 #define SPIDER_NET_LENLMT_VALUE 0x00000908 191 188 ··· 338 333 /* We rely on flagged descriptor interrupts */ 339 334 #define SPIDER_NET_RXINT ( (1 << SPIDER_NET_GDAFDCINT) ) 340 335 336 336 + #define SPIDER_NET_LINKINT ( 1 << SPIDER_NET_GMAC2INT ) 337 337 + 341 338 #define SPIDER_NET_ERRINT ( 0xffffffff & \ 342 339 (~SPIDER_NET_TXINT) & \ 343 343 - (~SPIDER_NET_RXINT) ) 340 340 + (~SPIDER_NET_RXINT) & \ 341 341 + (~SPIDER_NET_LINKINT) ) 344 342 345 343 #define SPIDER_NET_GPREXEC 0x80000000 346 344 #define SPIDER_NET_GPRDAT_MASK 0x0000ffff ··· 364 356 #define SPIDER_NET_DESCR_NOT_IN_USE 0xF0000000 365 357 #define SPIDER_NET_DESCR_TXDESFLG 0x00800000 366 358 367 367 - struct spider_net_descr { 368 368 - /* as defined by the hardware */ 359 359 + /* Descriptor, as defined by the hardware */ 360 360 + struct spider_net_hw_descr { 369 361 u32 buf_addr; 370 362 u32 buf_size; 371 363 u32 next_descr_addr; ··· 374 366 u32 valid_size; /* all zeroes for tx */ 375 367 u32 data_status; 376 368 u32 data_error; /* all zeroes for tx */ 369 369 + } __attribute__((aligned(32))); 377 370 378 378 - /* used in the driver */ 371 371 + struct spider_net_descr { 372 372 + struct spider_net_hw_descr *hwdescr; 379 373 struct sk_buff *skb; 380 374 u32 bus_addr; 381 375 struct spider_net_descr *next; 382 376 struct spider_net_descr *prev; 383 383 - } __attribute__((aligned(32))); 377 377 + }; 384 378 385 379 struct spider_net_descr_chain { 386 380 spinlock_t lock; ··· 390 380 struct spider_net_descr *tail; 391 381 struct spider_net_descr *ring; 392 382 int num_desc; 383 383 + struct spider_net_hw_descr *hwring; 393 384 dma_addr_t dma_addr; 394 385 }; 395 386 ··· 447 436 struct pci_dev *pdev; 448 437 struct mii_phy phy; 449 438 439 439 + int medium; 440 440 + 450 441 void __iomem *regs; 451 442 452 443 struct spider_net_descr_chain tx_chain; 453 444 struct spider_net_descr_chain rx_chain; 454 445 struct spider_net_descr *low_watermark; 455 446 447 447 + int aneg_count; 448 448 + struct timer_list aneg_timer; 456 449 struct timer_list tx_timer; 457 450 struct work_struct tx_timeout_task; 458 451 atomic_t tx_timeout_task_counter; ··· 467 452 struct net_device_stats netdev_stats; 468 453 struct spider_net_extra_stats spider_stats; 469 454 struct spider_net_options options; 455 455 + 456 456 + /* Must be last item in struct */ 457 457 + struct spider_net_descr darray[0]; 470 458 }; 471 459 472 460 #define pr_err(fmt,arg...) \

-2

drivers/net/sun3_82586.c

reviewed

··· 28 28 static int rfdadd = 0; /* rfdadd=1 may be better for 8K MEM cards */ 29 29 static int fifo=0x8; /* don't change */ 30 30 31 31 - /* #define REALLY_SLOW_IO */ 32 32 - 33 31 #include <linux/module.h> 34 32 #include <linux/kernel.h> 35 33 #include <linux/string.h>

+254 -135

drivers/net/sungem_phy.c

reviewed

··· 310 310 return 0; 311 311 } 312 312 313 313 + static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise) 314 314 + { 315 315 + u16 ctl, adv; 316 316 + 317 317 + phy->autoneg = 1; 318 318 + phy->speed = SPEED_10; 319 319 + phy->duplex = DUPLEX_HALF; 320 320 + phy->pause = 0; 321 321 + phy->advertising = advertise; 322 322 + 323 323 + /* Setup standard advertise */ 324 324 + adv = phy_read(phy, MII_ADVERTISE); 325 325 + adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4); 326 326 + if (advertise & ADVERTISED_10baseT_Half) 327 327 + adv |= ADVERTISE_10HALF; 328 328 + if (advertise & ADVERTISED_10baseT_Full) 329 329 + adv |= ADVERTISE_10FULL; 330 330 + if (advertise & ADVERTISED_100baseT_Half) 331 331 + adv |= ADVERTISE_100HALF; 332 332 + if (advertise & ADVERTISED_100baseT_Full) 333 333 + adv |= ADVERTISE_100FULL; 334 334 + phy_write(phy, MII_ADVERTISE, adv); 335 335 + 336 336 + /* Start/Restart aneg */ 337 337 + ctl = phy_read(phy, MII_BMCR); 338 338 + ctl |= (BMCR_ANENABLE | BMCR_ANRESTART); 339 339 + phy_write(phy, MII_BMCR, ctl); 340 340 + 341 341 + return 0; 342 342 + } 343 343 + 344 344 + static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd) 345 345 + { 346 346 + u16 ctl; 347 347 + 348 348 + phy->autoneg = 0; 349 349 + phy->speed = speed; 350 350 + phy->duplex = fd; 351 351 + phy->pause = 0; 352 352 + 353 353 + ctl = phy_read(phy, MII_BMCR); 354 354 + ctl &= ~(BMCR_FULLDPLX|BMCR_SPEED100|BMCR_ANENABLE); 355 355 + 356 356 + /* First reset the PHY */ 357 357 + phy_write(phy, MII_BMCR, ctl | BMCR_RESET); 358 358 + 359 359 + /* Select speed & duplex */ 360 360 + switch(speed) { 361 361 + case SPEED_10: 362 362 + break; 363 363 + case SPEED_100: 364 364 + ctl |= BMCR_SPEED100; 365 365 + break; 366 366 + case SPEED_1000: 367 367 + default: 368 368 + return -EINVAL; 369 369 + } 370 370 + if (fd == DUPLEX_FULL) 371 371 + ctl |= BMCR_FULLDPLX; 372 372 + phy_write(phy, MII_BMCR, ctl); 373 373 + 374 374 + return 0; 375 375 + } 376 376 + 377 377 + static int genmii_poll_link(struct mii_phy *phy) 378 378 + { 379 379 + u16 status; 380 380 + 381 381 + (void)phy_read(phy, MII_BMSR); 382 382 + status = phy_read(phy, MII_BMSR); 383 383 + if ((status & BMSR_LSTATUS) == 0) 384 384 + return 0; 385 385 + if (phy->autoneg && !(status & BMSR_ANEGCOMPLETE)) 386 386 + return 0; 387 387 + return 1; 388 388 + } 389 389 + 390 390 + static int genmii_read_link(struct mii_phy *phy) 391 391 + { 392 392 + u16 lpa; 393 393 + 394 394 + if (phy->autoneg) { 395 395 + lpa = phy_read(phy, MII_LPA); 396 396 + 397 397 + if (lpa & (LPA_10FULL | LPA_100FULL)) 398 398 + phy->duplex = DUPLEX_FULL; 399 399 + else 400 400 + phy->duplex = DUPLEX_HALF; 401 401 + if (lpa & (LPA_100FULL | LPA_100HALF)) 402 402 + phy->speed = SPEED_100; 403 403 + else 404 404 + phy->speed = SPEED_10; 405 405 + phy->pause = 0; 406 406 + } 407 407 + /* On non-aneg, we assume what we put in BMCR is the speed, 408 408 + * though magic-aneg shouldn't prevent this case from occurring 409 409 + */ 410 410 + 411 411 + return 0; 412 412 + } 413 413 + 313 414 static int generic_suspend(struct mii_phy* phy) 314 415 { 315 416 phy_write(phy, MII_BMCR, BMCR_PDOWN); ··· 461 360 } 462 361 } 463 362 #endif /* CONFIG_PPC_PMAC */ 464 464 - 465 465 - return 0; 466 466 - } 467 467 - 468 468 - static int bcm5421_enable_fiber(struct mii_phy* phy) 469 469 - { 470 470 - /* enable fiber mode */ 471 471 - phy_write(phy, MII_NCONFIG, 0x9020); 472 472 - /* LEDs active in both modes, autosense prio = fiber */ 473 473 - phy_write(phy, MII_NCONFIG, 0x945f); 474 474 - 475 475 - /* switch off fibre autoneg */ 476 476 - phy_write(phy, MII_NCONFIG, 0xfc01); 477 477 - phy_write(phy, 0x0b, 0x0004); 478 478 - 479 479 - return 0; 480 480 - } 481 481 - 482 482 - static int bcm5461_enable_fiber(struct mii_phy* phy) 483 483 - { 484 484 - phy_write(phy, MII_NCONFIG, 0xfc0c); 485 485 - phy_write(phy, MII_BMCR, 0x4140); 486 486 - phy_write(phy, MII_NCONFIG, 0xfc0b); 487 487 - phy_write(phy, MII_BMCR, 0x0140); 488 363 489 364 return 0; 490 365 } ··· 589 512 phy_write(phy, 0x1d, 0x0004); 590 513 phy_write(phy, 0x1e, 0x4850); 591 514 } 515 515 + return 0; 516 516 + } 517 517 + 518 518 + #define BCM5421_MODE_MASK (1 << 5) 519 519 + 520 520 + static int bcm5421_poll_link(struct mii_phy* phy) 521 521 + { 522 522 + u32 phy_reg; 523 523 + int mode; 524 524 + 525 525 + /* find out in what mode we are */ 526 526 + phy_write(phy, MII_NCONFIG, 0x1000); 527 527 + phy_reg = phy_read(phy, MII_NCONFIG); 528 528 + 529 529 + mode = (phy_reg & BCM5421_MODE_MASK) >> 5; 530 530 + 531 531 + if ( mode == BCM54XX_COPPER) 532 532 + return genmii_poll_link(phy); 533 533 + 534 534 + /* try to find out wether we have a link */ 535 535 + phy_write(phy, MII_NCONFIG, 0x2000); 536 536 + phy_reg = phy_read(phy, MII_NCONFIG); 537 537 + 538 538 + if (phy_reg & 0x0020) 539 539 + return 0; 540 540 + else 541 541 + return 1; 542 542 + } 543 543 + 544 544 + static int bcm5421_read_link(struct mii_phy* phy) 545 545 + { 546 546 + u32 phy_reg; 547 547 + int mode; 548 548 + 549 549 + /* find out in what mode we are */ 550 550 + phy_write(phy, MII_NCONFIG, 0x1000); 551 551 + phy_reg = phy_read(phy, MII_NCONFIG); 552 552 + 553 553 + mode = (phy_reg & BCM5421_MODE_MASK ) >> 5; 554 554 + 555 555 + if ( mode == BCM54XX_COPPER) 556 556 + return bcm54xx_read_link(phy); 557 557 + 558 558 + phy->speed = SPEED_1000; 559 559 + 560 560 + /* find out wether we are running half- or full duplex */ 561 561 + phy_write(phy, MII_NCONFIG, 0x2000); 562 562 + phy_reg = phy_read(phy, MII_NCONFIG); 563 563 + 564 564 + if ( (phy_reg & 0x0080) >> 7) 565 565 + phy->duplex |= DUPLEX_HALF; 566 566 + else 567 567 + phy->duplex |= DUPLEX_FULL; 568 568 + 569 569 + return 0; 570 570 + } 571 571 + 572 572 + static int bcm5421_enable_fiber(struct mii_phy* phy, int autoneg) 573 573 + { 574 574 + /* enable fiber mode */ 575 575 + phy_write(phy, MII_NCONFIG, 0x9020); 576 576 + /* LEDs active in both modes, autosense prio = fiber */ 577 577 + phy_write(phy, MII_NCONFIG, 0x945f); 578 578 + 579 579 + if (!autoneg) { 580 580 + /* switch off fibre autoneg */ 581 581 + phy_write(phy, MII_NCONFIG, 0xfc01); 582 582 + phy_write(phy, 0x0b, 0x0004); 583 583 + } 584 584 + 585 585 + phy->autoneg = autoneg; 586 586 + 587 587 + return 0; 588 588 + } 589 589 + 590 590 + #define BCM5461_FIBER_LINK (1 << 2) 591 591 + #define BCM5461_MODE_MASK (3 << 1) 592 592 + 593 593 + static int bcm5461_poll_link(struct mii_phy* phy) 594 594 + { 595 595 + u32 phy_reg; 596 596 + int mode; 597 597 + 598 598 + /* find out in what mode we are */ 599 599 + phy_write(phy, MII_NCONFIG, 0x7c00); 600 600 + phy_reg = phy_read(phy, MII_NCONFIG); 601 601 + 602 602 + mode = (phy_reg & BCM5461_MODE_MASK ) >> 1; 603 603 + 604 604 + if ( mode == BCM54XX_COPPER) 605 605 + return genmii_poll_link(phy); 606 606 + 607 607 + /* find out wether we have a link */ 608 608 + phy_write(phy, MII_NCONFIG, 0x7000); 609 609 + phy_reg = phy_read(phy, MII_NCONFIG); 610 610 + 611 611 + if (phy_reg & BCM5461_FIBER_LINK) 612 612 + return 1; 613 613 + else 614 614 + return 0; 615 615 + } 616 616 + 617 617 + #define BCM5461_FIBER_DUPLEX (1 << 3) 618 618 + 619 619 + static int bcm5461_read_link(struct mii_phy* phy) 620 620 + { 621 621 + u32 phy_reg; 622 622 + int mode; 623 623 + 624 624 + /* find out in what mode we are */ 625 625 + phy_write(phy, MII_NCONFIG, 0x7c00); 626 626 + phy_reg = phy_read(phy, MII_NCONFIG); 627 627 + 628 628 + mode = (phy_reg & BCM5461_MODE_MASK ) >> 1; 629 629 + 630 630 + if ( mode == BCM54XX_COPPER) { 631 631 + return bcm54xx_read_link(phy); 632 632 + } 633 633 + 634 634 + phy->speed = SPEED_1000; 635 635 + 636 636 + /* find out wether we are running half- or full duplex */ 637 637 + phy_write(phy, MII_NCONFIG, 0x7000); 638 638 + phy_reg = phy_read(phy, MII_NCONFIG); 639 639 + 640 640 + if (phy_reg & BCM5461_FIBER_DUPLEX) 641 641 + phy->duplex |= DUPLEX_FULL; 642 642 + else 643 643 + phy->duplex |= DUPLEX_HALF; 644 644 + 645 645 + return 0; 646 646 + } 647 647 + 648 648 + static int bcm5461_enable_fiber(struct mii_phy* phy, int autoneg) 649 649 + { 650 650 + /* select fiber mode, enable 1000 base-X registers */ 651 651 + phy_write(phy, MII_NCONFIG, 0xfc0b); 652 652 + 653 653 + if (autoneg) { 654 654 + /* enable fiber with no autonegotiation */ 655 655 + phy_write(phy, MII_ADVERTISE, 0x01e0); 656 656 + phy_write(phy, MII_BMCR, 0x1140); 657 657 + } else { 658 658 + /* enable fiber with autonegotiation */ 659 659 + phy_write(phy, MII_BMCR, 0x0140); 660 660 + } 661 661 + 662 662 + phy->autoneg = autoneg; 663 663 + 592 664 return 0; 593 665 } 594 666 ··· 870 644 871 645 return 0; 872 646 } 873 873 - 874 874 - static int genmii_setup_aneg(struct mii_phy *phy, u32 advertise) 875 875 - { 876 876 - u16 ctl, adv; 877 877 - 878 878 - phy->autoneg = 1; 879 879 - phy->speed = SPEED_10; 880 880 - phy->duplex = DUPLEX_HALF; 881 881 - phy->pause = 0; 882 882 - phy->advertising = advertise; 883 883 - 884 884 - /* Setup standard advertise */ 885 885 - adv = phy_read(phy, MII_ADVERTISE); 886 886 - adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4); 887 887 - if (advertise & ADVERTISED_10baseT_Half) 888 888 - adv |= ADVERTISE_10HALF; 889 889 - if (advertise & ADVERTISED_10baseT_Full) 890 890 - adv |= ADVERTISE_10FULL; 891 891 - if (advertise & ADVERTISED_100baseT_Half) 892 892 - adv |= ADVERTISE_100HALF; 893 893 - if (advertise & ADVERTISED_100baseT_Full) 894 894 - adv |= ADVERTISE_100FULL; 895 895 - if (advertise & ADVERTISED_Pause) 896 896 - adv |= ADVERTISE_PAUSE_CAP; 897 897 - if (advertise & ADVERTISED_Asym_Pause) 898 898 - adv |= ADVERTISE_PAUSE_ASYM; 899 899 - phy_write(phy, MII_ADVERTISE, adv); 900 900 - 901 901 - /* Start/Restart aneg */ 902 902 - ctl = phy_read(phy, MII_BMCR); 903 903 - ctl |= (BMCR_ANENABLE | BMCR_ANRESTART); 904 904 - phy_write(phy, MII_BMCR, ctl); 905 905 - 906 906 - return 0; 907 907 - } 908 908 - 909 909 - static int genmii_setup_forced(struct mii_phy *phy, int speed, int fd) 910 910 - { 911 911 - u16 ctl; 912 912 - 913 913 - phy->autoneg = 0; 914 914 - phy->speed = speed; 915 915 - phy->duplex = fd; 916 916 - phy->pause = 0; 917 917 - 918 918 - ctl = phy_read(phy, MII_BMCR); 919 919 - ctl &= ~(BMCR_FULLDPLX|BMCR_SPEED100|BMCR_ANENABLE); 920 920 - 921 921 - /* First reset the PHY */ 922 922 - phy_write(phy, MII_BMCR, ctl | BMCR_RESET); 923 923 - 924 924 - /* Select speed & duplex */ 925 925 - switch(speed) { 926 926 - case SPEED_10: 927 927 - break; 928 928 - case SPEED_100: 929 929 - ctl |= BMCR_SPEED100; 930 930 - break; 931 931 - case SPEED_1000: 932 932 - default: 933 933 - return -EINVAL; 934 934 - } 935 935 - if (fd == DUPLEX_FULL) 936 936 - ctl |= BMCR_FULLDPLX; 937 937 - phy_write(phy, MII_BMCR, ctl); 938 938 - 939 939 - return 0; 940 940 - } 941 941 - 942 942 - static int genmii_poll_link(struct mii_phy *phy) 943 943 - { 944 944 - u16 status; 945 945 - 946 946 - (void)phy_read(phy, MII_BMSR); 947 947 - status = phy_read(phy, MII_BMSR); 948 948 - if ((status & BMSR_LSTATUS) == 0) 949 949 - return 0; 950 950 - if (phy->autoneg && !(status & BMSR_ANEGCOMPLETE)) 951 951 - return 0; 952 952 - return 1; 953 953 - } 954 954 - 955 955 - static int genmii_read_link(struct mii_phy *phy) 956 956 - { 957 957 - u16 lpa; 958 958 - 959 959 - if (phy->autoneg) { 960 960 - lpa = phy_read(phy, MII_LPA); 961 961 - 962 962 - if (lpa & (LPA_10FULL | LPA_100FULL)) 963 963 - phy->duplex = DUPLEX_FULL; 964 964 - else 965 965 - phy->duplex = DUPLEX_HALF; 966 966 - if (lpa & (LPA_100FULL | LPA_100HALF)) 967 967 - phy->speed = SPEED_100; 968 968 - else 969 969 - phy->speed = SPEED_10; 970 970 - phy->pause = (phy->duplex == DUPLEX_FULL) && 971 971 - ((lpa & LPA_PAUSE) != 0); 972 972 - } 973 973 - /* On non-aneg, we assume what we put in BMCR is the speed, 974 974 - * though magic-aneg shouldn't prevent this case from occurring 975 975 - */ 976 976 - 977 977 - return 0; 978 978 - } 979 979 - 980 647 981 648 #define MII_BASIC_FEATURES \ 982 649 (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full | \ ··· 1004 885 .suspend = generic_suspend, 1005 886 .setup_aneg = bcm54xx_setup_aneg, 1006 887 .setup_forced = bcm54xx_setup_forced, 1007 1007 - .poll_link = genmii_poll_link, 1008 1008 - .read_link = bcm54xx_read_link, 888 888 + .poll_link = bcm5421_poll_link, 889 889 + .read_link = bcm5421_read_link, 1009 890 .enable_fiber = bcm5421_enable_fiber, 1010 891 }; 1011 892 ··· 1042 923 .suspend = generic_suspend, 1043 924 .setup_aneg = bcm54xx_setup_aneg, 1044 925 .setup_forced = bcm54xx_setup_forced, 1045 1045 - .poll_link = genmii_poll_link, 1046 1046 - .read_link = bcm54xx_read_link, 926 926 + .poll_link = bcm5461_poll_link, 927 927 + .read_link = bcm5461_read_link, 1047 928 .enable_fiber = bcm5461_enable_fiber, 1048 929 }; 1049 930

+9 -1

drivers/net/sungem_phy.h

reviewed

··· 12 12 int (*setup_forced)(struct mii_phy *phy, int speed, int fd); 13 13 int (*poll_link)(struct mii_phy *phy); 14 14 int (*read_link)(struct mii_phy *phy); 15 15 - int (*enable_fiber)(struct mii_phy *phy); 15 15 + int (*enable_fiber)(struct mii_phy *phy, int autoneg); 16 16 }; 17 17 18 18 /* Structure used to statically define an mii/gii based PHY */ ··· 24 24 int magic_aneg; /* Autoneg does all speed test for us */ 25 25 const char* name; 26 26 const struct mii_phy_ops* ops; 27 27 + }; 28 28 + 29 29 + enum { 30 30 + BCM54XX_COPPER, 31 31 + BCM54XX_FIBER, 32 32 + BCM54XX_GBIC, 33 33 + BCM54XX_SGMII, 34 34 + BCM54XX_UNKNOWN, 27 35 }; 28 36 29 37 /* An instance of a PHY, partially borrowed from mii_if_info */

+9 -1

drivers/net/tc35815.c

reviewed

··· 657 657 dma_cache_wback_inv((unsigned long)lp->fd_buf, PAGE_SIZE * FD_PAGE_NUM); 658 658 #endif 659 659 } else { 660 660 - clear_page(lp->fd_buf); 660 660 + memset(lp->fd_buf, 0, PAGE_SIZE * FD_PAGE_NUM); 661 661 #ifdef __mips__ 662 662 dma_cache_wback_inv((unsigned long)lp->fd_buf, PAGE_SIZE * FD_PAGE_NUM); 663 663 #endif ··· 1732 1732 { 1733 1733 struct net_device *next_dev; 1734 1734 1735 1735 + /* 1736 1736 + * TODO: implement a tc35815_driver.remove hook, and 1737 1737 + * move this code into that function. Then, delete 1738 1738 + * all root_tc35815_dev list handling code. 1739 1739 + */ 1735 1740 while (root_tc35815_dev) { 1736 1741 struct net_device *dev = root_tc35815_dev; 1737 1742 next_dev = ((struct tc35815_local *)dev->priv)->next_module; ··· 1745 1740 free_netdev(dev); 1746 1741 root_tc35815_dev = next_dev; 1747 1742 } 1743 1743 + 1744 1744 + pci_unregister_driver(&tc35815_driver); 1748 1745 } 1746 1746 + 1749 1747 module_init(tc35815_init_module); 1750 1748 module_exit(tc35815_cleanup_module);

+1 -3

drivers/net/ucc_geth.c

reviewed

··· 4199 4199 ugeth->ug_info = ug_info; 4200 4200 ugeth->dev = dev; 4201 4201 4202 4202 - mac_addr = get_property(np, "mac-address", NULL); 4203 4203 - if (mac_addr == NULL) 4204 4204 - mac_addr = get_property(np, "local-mac-address", NULL); 4202 4202 + mac_addr = of_get_mac_address(np); 4205 4203 if (mac_addr) 4206 4204 memcpy(dev->dev_addr, mac_addr, 6); 4207 4205

-1

drivers/net/wan/cosa.c

reviewed

··· 94 94 #include <linux/device.h> 95 95 96 96 #undef COSA_SLOW_IO /* for testing purposes only */ 97 97 - #undef REALLY_SLOW_IO 98 97 99 98 #include <asm/io.h> 100 99 #include <asm/dma.h>

-1

drivers/net/wireless/wl3501_cs.c

reviewed

··· 26 26 * Tested with Planet AP in 2.5.73-bk, 216 Kbytes/s in Infrastructure mode 27 27 * with a SMP machine (dual pentium 100), using pktgen, 432 pps (pkt_size = 60) 28 28 */ 29 29 - #undef REALLY_SLOW_IO /* most systems can safely undef this */ 30 29 31 30 #include <linux/delay.h> 32 31 #include <linux/types.h>