atm: [nicstar] remove virt_to_bus() and support 64-bit platforms

+1 -1

drivers/atm/Kconfig

··· 177 177 178 178 config ATM_NICSTAR 179 179 tristate "IDT 77201 (NICStAR) (ForeRunnerLE)" 180 - depends on PCI && !64BIT && VIRT_TO_BUS 180 + depends on PCI 181 181 help 182 182 The NICStAR chipset family is used in a large number of ATM NICs for 183 183 25 and for 155 Mbps, including IDT cards and the Fore ForeRunnerLE

+218 -162

drivers/atm/nicstar.c

··· 38 38 #include <linux/atmdev.h> 39 39 #include <linux/atm.h> 40 40 #include <linux/pci.h> 41 + #include <linux/dma-mapping.h> 41 42 #include <linux/types.h> 42 43 #include <linux/string.h> 43 44 #include <linux/delay.h> ··· 48 47 #include <linux/interrupt.h> 49 48 #include <linux/bitops.h> 50 49 #include <linux/slab.h> 50 + #include <linux/idr.h> 51 51 #include <asm/io.h> 52 52 #include <asm/uaccess.h> 53 53 #include <asm/atomic.h> ··· 59 57 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105 60 58 #include "idt77105.h" 61 59 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */ 62 - 63 - #if BITS_PER_LONG != 32 64 - # error FIXME: this driver requires a 32-bit platform 65 - #endif 66 60 67 61 /* Additional code */ 68 62 ··· 107 109 108 110 #define NS_DELAY mdelay(1) 109 111 110 - #define ALIGN_BUS_ADDR(addr, alignment) \ 111 - ((((u32) (addr)) + (((u32) (alignment)) - 1)) & ~(((u32) (alignment)) - 1)) 112 - #define ALIGN_ADDRESS(addr, alignment) \ 113 - bus_to_virt(ALIGN_BUS_ADDR(virt_to_bus(addr), alignment)) 114 - 115 - #undef CEIL 112 + #define PTR_DIFF(a, b) ((u32)((unsigned long)(a) - (unsigned long)(b))) 116 113 117 114 #ifndef ATM_SKB 118 115 #define ATM_SKB(s) (&(s)->atm) 119 116 #endif 117 + 118 + #define scq_virt_to_bus(scq, p) \ 119 + (scq->dma + ((unsigned long)(p) - (unsigned long)(scq)->org)) 120 120 121 121 /* Function declarations */ 122 122 ··· 123 127 int count); 124 128 static int __devinit ns_init_card(int i, struct pci_dev *pcidev); 125 129 static void __devinit ns_init_card_error(ns_dev * card, int error); 126 - static scq_info *get_scq(int size, u32 scd); 127 - static void free_scq(scq_info * scq, struct atm_vcc *vcc); 130 + static scq_info *get_scq(ns_dev *card, int size, u32 scd); 131 + static void free_scq(ns_dev *card, scq_info * scq, struct atm_vcc *vcc); 128 132 static void push_rxbufs(ns_dev *, struct sk_buff *); 129 133 static irqreturn_t ns_irq_handler(int irq, void *dev_id); 130 134 static int ns_open(struct atm_vcc *vcc); ··· 149 153 static void dequeue_lg_buf(ns_dev * card, struct sk_buff *lb); 150 154 static int ns_proc_read(struct atm_dev *dev, loff_t * pos, char *page); 151 155 static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user * arg); 156 + #ifdef EXTRA_DEBUG 152 157 static void which_list(ns_dev * card, struct sk_buff *skb); 158 + #endif 153 159 static void ns_poll(unsigned long arg); 154 160 static int ns_parse_mac(char *mac, unsigned char *esi); 155 161 static short ns_h2i(char c); ··· 247 249 dev_kfree_skb_any(lb); 248 250 while ((sb = skb_dequeue(&card->sbpool.queue)) != NULL) 249 251 dev_kfree_skb_any(sb); 250 - free_scq(card->scq0, NULL); 252 + free_scq(card, card->scq0, NULL); 251 253 for (j = 0; j < NS_FRSCD_NUM; j++) { 252 254 if (card->scd2vc[j] != NULL) 253 - free_scq(card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc); 255 + free_scq(card, card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc); 254 256 } 255 - kfree(card->rsq.org); 256 - kfree(card->tsq.org); 257 + idr_remove_all(&card->idr); 258 + idr_destroy(&card->idr); 259 + pci_free_consistent(card->pcidev, NS_RSQSIZE + NS_RSQ_ALIGNMENT, 260 + card->rsq.org, card->rsq.dma); 261 + pci_free_consistent(card->pcidev, NS_TSQSIZE + NS_TSQ_ALIGNMENT, 262 + card->tsq.org, card->tsq.dma); 257 263 free_irq(card->pcidev->irq, card); 258 264 iounmap(card->membase); 259 265 kfree(card); ··· 373 371 ns_init_card_error(card, error); 374 372 return error; 375 373 } 374 + if ((pci_set_dma_mask(pcidev, DMA_BIT_MASK(32)) != 0) || 375 + (pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32)) != 0)) { 376 + printk(KERN_WARNING 377 + "nicstar%d: No suitable DMA available.\n", i); 378 + error = 2; 379 + ns_init_card_error(card, error); 380 + return error; 381 + } 376 382 377 383 if ((card = kmalloc(sizeof(ns_dev), GFP_KERNEL)) == NULL) { 378 384 printk ··· 407 397 ns_init_card_error(card, error); 408 398 return error; 409 399 } 410 - PRINTK("nicstar%d: membase at 0x%x.\n", i, card->membase); 400 + PRINTK("nicstar%d: membase at 0x%p.\n", i, card->membase); 411 401 412 402 pci_set_master(pcidev); 413 403 ··· 538 528 writel(0x00000000, card->membase + VPM); 539 529 540 530 /* Initialize TSQ */ 541 - card->tsq.org = kmalloc(NS_TSQSIZE + NS_TSQ_ALIGNMENT, GFP_KERNEL); 531 + card->tsq.org = pci_alloc_consistent(card->pcidev, 532 + NS_TSQSIZE + NS_TSQ_ALIGNMENT, 533 + &card->tsq.dma); 542 534 if (card->tsq.org == NULL) { 543 535 printk("nicstar%d: can't allocate TSQ.\n", i); 544 536 error = 10; 545 537 ns_init_card_error(card, error); 546 538 return error; 547 539 } 548 - card->tsq.base = 549 - (ns_tsi *) ALIGN_ADDRESS(card->tsq.org, NS_TSQ_ALIGNMENT); 540 + card->tsq.base = PTR_ALIGN(card->tsq.org, NS_TSQ_ALIGNMENT); 550 541 card->tsq.next = card->tsq.base; 551 542 card->tsq.last = card->tsq.base + (NS_TSQ_NUM_ENTRIES - 1); 552 543 for (j = 0; j < NS_TSQ_NUM_ENTRIES; j++) 553 544 ns_tsi_init(card->tsq.base + j); 554 545 writel(0x00000000, card->membase + TSQH); 555 - writel((u32) virt_to_bus(card->tsq.base), card->membase + TSQB); 556 - PRINTK("nicstar%d: TSQ base at 0x%x 0x%x 0x%x.\n", i, 557 - (u32) card->tsq.base, (u32) virt_to_bus(card->tsq.base), 558 - readl(card->membase + TSQB)); 546 + writel(ALIGN(card->tsq.dma, NS_TSQ_ALIGNMENT), card->membase + TSQB); 547 + PRINTK("nicstar%d: TSQ base at 0x%p.\n", i, card->tsq.base); 559 548 560 549 /* Initialize RSQ */ 561 - card->rsq.org = kmalloc(NS_RSQSIZE + NS_RSQ_ALIGNMENT, GFP_KERNEL); 550 + card->rsq.org = pci_alloc_consistent(card->pcidev, 551 + NS_RSQSIZE + NS_RSQ_ALIGNMENT, 552 + &card->rsq.dma); 562 553 if (card->rsq.org == NULL) { 563 554 printk("nicstar%d: can't allocate RSQ.\n", i); 564 555 error = 11; 565 556 ns_init_card_error(card, error); 566 557 return error; 567 558 } 568 - card->rsq.base = 569 - (ns_rsqe *) ALIGN_ADDRESS(card->rsq.org, NS_RSQ_ALIGNMENT); 559 + card->rsq.base = PTR_ALIGN(card->rsq.org, NS_RSQ_ALIGNMENT); 570 560 card->rsq.next = card->rsq.base; 571 561 card->rsq.last = card->rsq.base + (NS_RSQ_NUM_ENTRIES - 1); 572 562 for (j = 0; j < NS_RSQ_NUM_ENTRIES; j++) 573 563 ns_rsqe_init(card->rsq.base + j); 574 564 writel(0x00000000, card->membase + RSQH); 575 - writel((u32) virt_to_bus(card->rsq.base), card->membase + RSQB); 576 - PRINTK("nicstar%d: RSQ base at 0x%x.\n", i, (u32) card->rsq.base); 565 + writel(ALIGN(card->rsq.dma, NS_RSQ_ALIGNMENT), card->membase + RSQB); 566 + PRINTK("nicstar%d: RSQ base at 0x%p.\n", i, card->rsq.base); 577 567 578 568 /* Initialize SCQ0, the only VBR SCQ used */ 579 569 card->scq1 = NULL; 580 570 card->scq2 = NULL; 581 - card->scq0 = get_scq(VBR_SCQSIZE, NS_VRSCD0); 571 + card->scq0 = get_scq(card, VBR_SCQSIZE, NS_VRSCD0); 582 572 if (card->scq0 == NULL) { 583 573 printk("nicstar%d: can't get SCQ0.\n", i); 584 574 error = 12; 585 575 ns_init_card_error(card, error); 586 576 return error; 587 577 } 588 - u32d[0] = (u32) virt_to_bus(card->scq0->base); 578 + u32d[0] = scq_virt_to_bus(card->scq0, card->scq0->base); 589 579 u32d[1] = (u32) 0x00000000; 590 580 u32d[2] = (u32) 0xffffffff; 591 581 u32d[3] = (u32) 0x00000000; ··· 593 583 ns_write_sram(card, NS_VRSCD1, u32d, 4); /* These last two won't be used */ 594 584 ns_write_sram(card, NS_VRSCD2, u32d, 4); /* but are initialized, just in case... */ 595 585 card->scq0->scd = NS_VRSCD0; 596 - PRINTK("nicstar%d: VBR-SCQ0 base at 0x%x.\n", i, 597 - (u32) card->scq0->base); 586 + PRINTK("nicstar%d: VBR-SCQ0 base at 0x%p.\n", i, card->scq0->base); 598 587 599 588 /* Initialize TSTs */ 600 589 card->tst_addr = NS_TST0; ··· 649 640 650 641 card->efbie = 1; /* To prevent push_rxbufs from enabling the interrupt */ 651 642 643 + idr_init(&card->idr); 644 + 652 645 /* Pre-allocate some huge buffers */ 653 646 skb_queue_head_init(&card->hbpool.queue); 654 647 card->hbpool.count = 0; ··· 665 654 ns_init_card_error(card, error); 666 655 return error; 667 656 } 668 - NS_SKB_CB(hb)->buf_type = BUF_NONE; 657 + NS_PRV_BUFTYPE(hb) = BUF_NONE; 669 658 skb_queue_tail(&card->hbpool.queue, hb); 670 659 card->hbpool.count++; 671 660 } ··· 684 673 ns_init_card_error(card, error); 685 674 return error; 686 675 } 687 - NS_SKB_CB(lb)->buf_type = BUF_LG; 676 + NS_PRV_BUFTYPE(lb) = BUF_LG; 688 677 skb_queue_tail(&card->lbpool.queue, lb); 689 678 skb_reserve(lb, NS_SMBUFSIZE); 690 679 push_rxbufs(card, lb); 691 680 /* Due to the implementation of push_rxbufs() this is 1, not 0 */ 692 681 if (j == 1) { 693 682 card->rcbuf = lb; 694 - card->rawch = (u32) virt_to_bus(lb->data); 683 + card->rawcell = (struct ns_rcqe *) lb->data; 684 + card->rawch = NS_PRV_DMA(lb); 695 685 } 696 686 } 697 687 /* Test for strange behaviour which leads to crashes */ ··· 720 708 ns_init_card_error(card, error); 721 709 return error; 722 710 } 723 - NS_SKB_CB(sb)->buf_type = BUF_SM; 711 + NS_PRV_BUFTYPE(sb) = BUF_SM; 724 712 skb_queue_tail(&card->sbpool.queue, sb); 725 713 skb_reserve(sb, NS_AAL0_HEADER); 726 714 push_rxbufs(card, sb); ··· 750 738 ns_init_card_error(card, error); 751 739 return error; 752 740 } 753 - NS_SKB_CB(iovb)->buf_type = BUF_NONE; 741 + NS_PRV_BUFTYPE(iovb) = BUF_NONE; 754 742 skb_queue_tail(&card->iovpool.queue, iovb); 755 743 card->iovpool.count++; 756 744 } ··· 837 825 struct sk_buff *sb; 838 826 while ((sb = skb_dequeue(&card->sbpool.queue)) != NULL) 839 827 dev_kfree_skb_any(sb); 840 - free_scq(card->scq0, NULL); 828 + free_scq(card, card->scq0, NULL); 841 829 } 842 830 if (error >= 14) { 843 831 struct sk_buff *lb; ··· 867 855 } 868 856 } 869 857 870 - static scq_info *get_scq(int size, u32 scd) 858 + static scq_info *get_scq(ns_dev *card, int size, u32 scd) 871 859 { 872 860 scq_info *scq; 873 861 int i; ··· 876 864 return NULL; 877 865 878 866 scq = kmalloc(sizeof(scq_info), GFP_KERNEL); 879 - if (scq == NULL) 867 + if (!scq) 880 868 return NULL; 881 - scq->org = kmalloc(2 * size, GFP_KERNEL); 882 - if (scq->org == NULL) { 869 + scq->org = pci_alloc_consistent(card->pcidev, 2 * size, &scq->dma); 870 + if (!scq->org) { 883 871 kfree(scq); 884 872 return NULL; 885 873 } 886 874 scq->skb = kmalloc(sizeof(struct sk_buff *) * 887 875 (size / NS_SCQE_SIZE), GFP_KERNEL); 888 - if (scq->skb == NULL) { 876 + if (!scq->skb) { 889 877 kfree(scq->org); 890 878 kfree(scq); 891 879 return NULL; 892 880 } 893 881 scq->num_entries = size / NS_SCQE_SIZE; 894 - scq->base = (ns_scqe *) ALIGN_ADDRESS(scq->org, size); 882 + scq->base = PTR_ALIGN(scq->org, size); 895 883 scq->next = scq->base; 896 884 scq->last = scq->base + (scq->num_entries - 1); 897 885 scq->tail = scq->last; ··· 909 897 } 910 898 911 899 /* For variable rate SCQ vcc must be NULL */ 912 - static void free_scq(scq_info * scq, struct atm_vcc *vcc) 900 + static void free_scq(ns_dev *card, scq_info *scq, struct atm_vcc *vcc) 913 901 { 914 902 int i; 915 903 ··· 940 928 } 941 929 } 942 930 kfree(scq->skb); 943 - kfree(scq->org); 931 + pci_free_consistent(card->pcidev, 932 + 2 * (scq->num_entries == VBR_SCQ_NUM_ENTRIES ? 933 + VBR_SCQSIZE : CBR_SCQSIZE), 934 + scq->org, scq->dma); 944 935 kfree(scq); 945 936 } 946 937 ··· 951 936 or large buffer(s) cast to u32. */ 952 937 static void push_rxbufs(ns_dev * card, struct sk_buff *skb) 953 938 { 954 - struct ns_skb_cb *cb = NS_SKB_CB(skb); 955 - u32 handle1, addr1; 956 - u32 handle2, addr2; 939 + struct sk_buff *handle1, *handle2; 940 + u32 id1 = 0, id2 = 0; 941 + u32 addr1, addr2; 957 942 u32 stat; 958 943 unsigned long flags; 944 + int err; 959 945 960 946 /* *BARF* */ 961 - handle2 = addr2 = 0; 962 - handle1 = (u32) skb; 963 - addr1 = (u32) virt_to_bus(skb->data); 947 + handle2 = NULL; 948 + addr2 = 0; 949 + handle1 = skb; 950 + addr1 = pci_map_single(card->pcidev, 951 + skb->data, 952 + (NS_PRV_BUFTYPE(skb) == BUF_SM 953 + ? NS_SMSKBSIZE : NS_LGSKBSIZE), 954 + PCI_DMA_TODEVICE); 955 + NS_PRV_DMA(skb) = addr1; /* save so we can unmap later */ 964 956 965 957 #ifdef GENERAL_DEBUG 966 958 if (!addr1) ··· 978 956 stat = readl(card->membase + STAT); 979 957 card->sbfqc = ns_stat_sfbqc_get(stat); 980 958 card->lbfqc = ns_stat_lfbqc_get(stat); 981 - if (cb->buf_type == BUF_SM) { 959 + if (NS_PRV_BUFTYPE(skb) == BUF_SM) { 982 960 if (!addr2) { 983 961 if (card->sm_addr) { 984 962 addr2 = card->sm_addr; ··· 1008 986 } 1009 987 1010 988 if (addr2) { 1011 - if (cb->buf_type == BUF_SM) { 989 + if (NS_PRV_BUFTYPE(skb) == BUF_SM) { 1012 990 if (card->sbfqc >= card->sbnr.max) { 1013 - skb_unlink((struct sk_buff *)handle1, 1014 - &card->sbpool.queue); 1015 - dev_kfree_skb_any((struct sk_buff *)handle1); 1016 - skb_unlink((struct sk_buff *)handle2, 1017 - &card->sbpool.queue); 1018 - dev_kfree_skb_any((struct sk_buff *)handle2); 991 + skb_unlink(handle1, &card->sbpool.queue); 992 + dev_kfree_skb_any(handle1); 993 + skb_unlink(handle2, &card->sbpool.queue); 994 + dev_kfree_skb_any(handle2); 1019 995 return; 1020 996 } else 1021 997 card->sbfqc += 2; 1022 998 } else { /* (buf_type == BUF_LG) */ 1023 999 1024 1000 if (card->lbfqc >= card->lbnr.max) { 1025 - skb_unlink((struct sk_buff *)handle1, 1026 - &card->lbpool.queue); 1027 - dev_kfree_skb_any((struct sk_buff *)handle1); 1028 - skb_unlink((struct sk_buff *)handle2, 1029 - &card->lbpool.queue); 1030 - dev_kfree_skb_any((struct sk_buff *)handle2); 1001 + skb_unlink(handle1, &card->lbpool.queue); 1002 + dev_kfree_skb_any(handle1); 1003 + skb_unlink(handle2, &card->lbpool.queue); 1004 + dev_kfree_skb_any(handle2); 1031 1005 return; 1032 1006 } else 1033 1007 card->lbfqc += 2; 1034 1008 } 1035 1009 1036 - spin_lock_irqsave(&card->res_lock, flags); 1010 + do { 1011 + if (!idr_pre_get(&card->idr, GFP_ATOMIC)) { 1012 + printk(KERN_ERR 1013 + "nicstar%d: no free memory for idr\n", 1014 + card->index); 1015 + goto out; 1016 + } 1037 1017 1018 + if (!id1) 1019 + err = idr_get_new_above(&card->idr, handle1, 0, &id1); 1020 + 1021 + if (!id2 && err == 0) 1022 + err = idr_get_new_above(&card->idr, handle2, 0, &id2); 1023 + 1024 + } while (err == -EAGAIN); 1025 + 1026 + if (err) 1027 + goto out; 1028 + 1029 + spin_lock_irqsave(&card->res_lock, flags); 1038 1030 while (CMD_BUSY(card)) ; 1039 1031 writel(addr2, card->membase + DR3); 1040 - writel(handle2, card->membase + DR2); 1032 + writel(id2, card->membase + DR2); 1041 1033 writel(addr1, card->membase + DR1); 1042 - writel(handle1, card->membase + DR0); 1043 - writel(NS_CMD_WRITE_FREEBUFQ | cb->buf_type, 1034 + writel(id1, card->membase + DR0); 1035 + writel(NS_CMD_WRITE_FREEBUFQ | NS_PRV_BUFTYPE(skb), 1044 1036 card->membase + CMD); 1045 - 1046 1037 spin_unlock_irqrestore(&card->res_lock, flags); 1047 1038 1048 1039 XPRINTK("nicstar%d: Pushing %s buffers at 0x%x and 0x%x.\n", 1049 1040 card->index, 1050 - (cb->buf_type == BUF_SM ? "small" : "large"), addr1, 1051 - addr2); 1041 + (NS_PRV_BUFTYPE(skb) == BUF_SM ? "small" : "large"), 1042 + addr1, addr2); 1052 1043 } 1053 1044 1054 1045 if (!card->efbie && card->sbfqc >= card->sbnr.min && ··· 1071 1036 card->membase + CFG); 1072 1037 } 1073 1038 1039 + out: 1074 1040 return; 1075 1041 } 1076 1042 ··· 1167 1131 next interrupt. As this preliminary support is only meant to 1168 1132 avoid buffer leakage, this is not an issue. */ 1169 1133 while (readl(card->membase + RAWCT) != card->rawch) { 1170 - ns_rcqe *rawcell; 1171 1134 1172 - rawcell = (ns_rcqe *) bus_to_virt(card->rawch); 1173 - if (ns_rcqe_islast(rawcell)) { 1135 + if (ns_rcqe_islast(card->rawcell)) { 1174 1136 struct sk_buff *oldbuf; 1175 1137 1176 1138 oldbuf = card->rcbuf; 1177 - card->rcbuf = 1178 - (struct sk_buff *) 1179 - ns_rcqe_nextbufhandle(rawcell); 1180 - card->rawch = 1181 - (u32) virt_to_bus(card->rcbuf->data); 1139 + card->rcbuf = idr_find(&card->idr, 1140 + ns_rcqe_nextbufhandle(card->rawcell)); 1141 + card->rawch = NS_PRV_DMA(card->rcbuf); 1142 + card->rawcell = (struct ns_rcqe *) 1143 + card->rcbuf->data; 1182 1144 recycle_rx_buf(card, oldbuf); 1183 - } else 1145 + } else { 1184 1146 card->rawch += NS_RCQE_SIZE; 1147 + card->rawcell++; 1148 + } 1185 1149 } 1186 1150 } 1187 1151 ··· 1201 1165 card->efbie = 0; 1202 1166 break; 1203 1167 } 1204 - NS_SKB_CB(sb)->buf_type = BUF_SM; 1168 + NS_PRV_BUFTYPE(sb) = BUF_SM; 1205 1169 skb_queue_tail(&card->sbpool.queue, sb); 1206 1170 skb_reserve(sb, NS_AAL0_HEADER); 1207 1171 push_rxbufs(card, sb); ··· 1226 1190 card->efbie = 0; 1227 1191 break; 1228 1192 } 1229 - NS_SKB_CB(lb)->buf_type = BUF_LG; 1193 + NS_PRV_BUFTYPE(lb) = BUF_LG; 1230 1194 skb_queue_tail(&card->lbpool.queue, lb); 1231 1195 skb_reserve(lb, NS_SMBUFSIZE); 1232 1196 push_rxbufs(card, lb); ··· 1374 1338 1375 1339 vc->cbr_scd = NS_FRSCD + frscdi * NS_FRSCD_SIZE; 1376 1340 1377 - scq = get_scq(CBR_SCQSIZE, vc->cbr_scd); 1341 + scq = get_scq(card, CBR_SCQSIZE, vc->cbr_scd); 1378 1342 if (scq == NULL) { 1379 1343 PRINTK("nicstar%d: can't get fixed rate SCQ.\n", 1380 1344 card->index); ··· 1385 1349 return -ENOMEM; 1386 1350 } 1387 1351 vc->scq = scq; 1388 - u32d[0] = (u32) virt_to_bus(scq->base); 1352 + u32d[0] = scq_virt_to_bus(scq, scq->base); 1389 1353 u32d[1] = (u32) 0x00000000; 1390 1354 u32d[2] = (u32) 0xffffffff; 1391 1355 u32d[3] = (u32) 0x00000000; ··· 1470 1434 card->index); 1471 1435 iovb = vc->rx_iov; 1472 1436 recycle_iovec_rx_bufs(card, (struct iovec *)iovb->data, 1473 - NS_SKB(iovb)->iovcnt); 1474 - NS_SKB(iovb)->iovcnt = 0; 1475 - NS_SKB(iovb)->vcc = NULL; 1437 + NS_PRV_IOVCNT(iovb)); 1438 + NS_PRV_IOVCNT(iovb) = 0; 1476 1439 spin_lock_irqsave(&card->int_lock, flags); 1477 1440 recycle_iov_buf(card, iovb); 1478 1441 spin_unlock_irqrestore(&card->int_lock, flags); ··· 1522 1487 scq->next = scq->base; 1523 1488 else 1524 1489 scq->next++; 1525 - data = (u32) virt_to_bus(scq->next); 1490 + data = scq_virt_to_bus(scq, scq->next); 1526 1491 ns_write_sram(card, scq->scd, &data, 1); 1527 1492 } 1528 1493 spin_unlock_irqrestore(&scq->lock, flags); ··· 1541 1506 } 1542 1507 1543 1508 card->scd2vc[(vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE] = NULL; 1544 - free_scq(vc->scq, vcc); 1509 + free_scq(card, vc->scq, vcc); 1545 1510 } 1546 1511 1547 1512 /* remove all references to vcc before deleting it */ ··· 1574 1539 cfg = readl(card->membase + CFG); 1575 1540 printk("STAT = 0x%08X CFG = 0x%08X \n", stat, cfg); 1576 1541 printk 1577 - ("TSQ: base = 0x%08X next = 0x%08X last = 0x%08X TSQT = 0x%08X \n", 1578 - (u32) card->tsq.base, (u32) card->tsq.next, 1579 - (u32) card->tsq.last, readl(card->membase + TSQT)); 1542 + ("TSQ: base = 0x%p next = 0x%p last = 0x%p TSQT = 0x%08X \n", 1543 + card->tsq.base, card->tsq.next, 1544 + card->tsq.last, readl(card->membase + TSQT)); 1580 1545 printk 1581 - ("RSQ: base = 0x%08X next = 0x%08X last = 0x%08X RSQT = 0x%08X \n", 1582 - (u32) card->rsq.base, (u32) card->rsq.next, 1583 - (u32) card->rsq.last, readl(card->membase + RSQT)); 1546 + ("RSQ: base = 0x%p next = 0x%p last = 0x%p RSQT = 0x%08X \n", 1547 + card->rsq.base, card->rsq.next, 1548 + card->rsq.last, readl(card->membase + RSQT)); 1584 1549 printk("Empty free buffer queue interrupt %s \n", 1585 1550 card->efbie ? "enabled" : "disabled"); 1586 1551 printk("SBCNT = %d count = %d LBCNT = %d count = %d \n", ··· 1686 1651 1687 1652 ATM_SKB(skb)->vcc = vcc; 1688 1653 1654 + NS_PRV_DMA(skb) = pci_map_single(card->pcidev, skb->data, 1655 + skb->len, PCI_DMA_TODEVICE); 1656 + 1689 1657 if (vcc->qos.aal == ATM_AAL5) { 1690 1658 buflen = (skb->len + 47 + 8) / 48 * 48; /* Multiple of 48 */ 1691 1659 flags = NS_TBD_AAL5; 1692 - scqe.word_2 = cpu_to_le32((u32) virt_to_bus(skb->data)); 1693 - scqe.word_3 = cpu_to_le32((u32) skb->len); 1660 + scqe.word_2 = cpu_to_le32(NS_PRV_DMA(skb)); 1661 + scqe.word_3 = cpu_to_le32(skb->len); 1694 1662 scqe.word_4 = 1695 1663 ns_tbd_mkword_4(0, (u32) vcc->vpi, (u32) vcc->vci, 0, 1696 1664 ATM_SKB(skb)-> ··· 1703 1665 1704 1666 buflen = ATM_CELL_PAYLOAD; /* i.e., 48 bytes */ 1705 1667 flags = NS_TBD_AAL0; 1706 - scqe.word_2 = 1707 - cpu_to_le32((u32) virt_to_bus(skb->data) + NS_AAL0_HEADER); 1668 + scqe.word_2 = cpu_to_le32(NS_PRV_DMA(skb) + NS_AAL0_HEADER); 1708 1669 scqe.word_3 = cpu_to_le32(0x00000000); 1709 1670 if (*skb->data & 0x02) /* Payload type 1 - end of pdu */ 1710 1671 flags |= NS_TBD_EOPDU; ··· 1770 1733 *scq->next = *tbd; 1771 1734 index = (int)(scq->next - scq->base); 1772 1735 scq->skb[index] = skb; 1773 - XPRINTK("nicstar%d: sending skb at 0x%x (pos %d).\n", 1774 - card->index, (u32) skb, index); 1775 - XPRINTK("nicstar%d: TBD written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%x.\n", 1736 + XPRINTK("nicstar%d: sending skb at 0x%p (pos %d).\n", 1737 + card->index, skb, index); 1738 + XPRINTK("nicstar%d: TBD written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%p.\n", 1776 1739 card->index, le32_to_cpu(tbd->word_1), le32_to_cpu(tbd->word_2), 1777 1740 le32_to_cpu(tbd->word_3), le32_to_cpu(tbd->word_4), 1778 - (u32) scq->next); 1741 + scq->next); 1779 1742 if (scq->next == scq->last) 1780 1743 scq->next = scq->base; 1781 1744 else ··· 1794 1757 1795 1758 while (scq->tail == scq->next) { 1796 1759 if (in_interrupt()) { 1797 - data = (u32) virt_to_bus(scq->next); 1760 + data = scq_virt_to_bus(scq, scq->next); 1798 1761 ns_write_sram(card, scq->scd, &data, 1); 1799 1762 spin_unlock_irqrestore(&scq->lock, flags); 1800 1763 printk("nicstar%d: Error pushing TSR.\n", ··· 1826 1789 index = (int)scqi; 1827 1790 scq->skb[index] = NULL; 1828 1791 XPRINTK 1829 - ("nicstar%d: TSR written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%x.\n", 1792 + ("nicstar%d: TSR written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%p.\n", 1830 1793 card->index, le32_to_cpu(tsr.word_1), 1831 1794 le32_to_cpu(tsr.word_2), le32_to_cpu(tsr.word_3), 1832 - le32_to_cpu(tsr.word_4), (u32) scq->next); 1795 + le32_to_cpu(tsr.word_4), scq->next); 1833 1796 if (scq->next == scq->last) 1834 1797 scq->next = scq->base; 1835 1798 else ··· 1840 1803 PRINTK("nicstar%d: Timeout pushing TSR.\n", 1841 1804 card->index); 1842 1805 } 1843 - data = (u32) virt_to_bus(scq->next); 1806 + data = scq_virt_to_bus(scq, scq->next); 1844 1807 ns_write_sram(card, scq->scd, &data, 1); 1845 1808 1846 1809 spin_unlock_irqrestore(&scq->lock, flags); ··· 1918 1881 two_ahead = one_ahead + 1; 1919 1882 } 1920 1883 1921 - if (serviced_entries) { 1922 - writel((((u32) previous) - ((u32) card->tsq.base)), 1884 + if (serviced_entries) 1885 + writel(PTR_DIFF(previous, card->tsq.base), 1923 1886 card->membase + TSQH); 1924 - } 1925 1887 } 1926 1888 1927 1889 static void drain_scq(ns_dev * card, scq_info * scq, int pos) ··· 1930 1894 int i; 1931 1895 unsigned long flags; 1932 1896 1933 - XPRINTK("nicstar%d: drain_scq() called, scq at 0x%x, pos %d.\n", 1934 - card->index, (u32) scq, pos); 1897 + XPRINTK("nicstar%d: drain_scq() called, scq at 0x%p, pos %d.\n", 1898 + card->index, scq, pos); 1935 1899 if (pos >= scq->num_entries) { 1936 1900 printk("nicstar%d: Bad index on drain_scq().\n", card->index); 1937 1901 return; ··· 1943 1907 i = 0; 1944 1908 while (i != pos) { 1945 1909 skb = scq->skb[i]; 1946 - XPRINTK("nicstar%d: freeing skb at 0x%x (index %d).\n", 1947 - card->index, (u32) skb, i); 1910 + XPRINTK("nicstar%d: freeing skb at 0x%p (index %d).\n", 1911 + card->index, skb, i); 1948 1912 if (skb != NULL) { 1913 + pci_unmap_single(card->pcidev, 1914 + NS_PRV_DMA(skb), 1915 + skb->len, 1916 + PCI_DMA_TODEVICE); 1949 1917 vcc = ATM_SKB(skb)->vcc; 1950 1918 if (vcc && vcc->pop != NULL) { 1951 1919 vcc->pop(vcc, skb); ··· 1980 1940 else 1981 1941 card->rsq.next++; 1982 1942 } while (ns_rsqe_valid(card->rsq.next)); 1983 - writel((((u32) previous) - ((u32) card->rsq.base)), 1984 - card->membase + RSQH); 1943 + writel(PTR_DIFF(previous, card->rsq.base), card->membase + RSQH); 1985 1944 } 1986 1945 1987 1946 static void dequeue_rx(ns_dev * card, ns_rsqe * rsqe) ··· 1994 1955 unsigned short aal5_len; 1995 1956 int len; 1996 1957 u32 stat; 1958 + u32 id; 1997 1959 1998 1960 stat = readl(card->membase + STAT); 1999 1961 card->sbfqc = ns_stat_sfbqc_get(stat); 2000 1962 card->lbfqc = ns_stat_lfbqc_get(stat); 2001 1963 2002 - skb = (struct sk_buff *)le32_to_cpu(rsqe->buffer_handle); 1964 + id = le32_to_cpu(rsqe->buffer_handle); 1965 + skb = idr_find(&card->idr, id); 1966 + if (!skb) { 1967 + RXPRINTK(KERN_ERR 1968 + "nicstar%d: idr_find() failed!\n", card->index); 1969 + return; 1970 + } 1971 + idr_remove(&card->idr, id); 1972 + pci_dma_sync_single_for_cpu(card->pcidev, 1973 + NS_PRV_DMA(skb), 1974 + (NS_PRV_BUFTYPE(skb) == BUF_SM 1975 + ? NS_SMSKBSIZE : NS_LGSKBSIZE), 1976 + PCI_DMA_FROMDEVICE); 1977 + pci_unmap_single(card->pcidev, 1978 + NS_PRV_DMA(skb), 1979 + (NS_PRV_BUFTYPE(skb) == BUF_SM 1980 + ? NS_SMSKBSIZE : NS_LGSKBSIZE), 1981 + PCI_DMA_FROMDEVICE); 2003 1982 vpi = ns_rsqe_vpi(rsqe); 2004 1983 vci = ns_rsqe_vci(rsqe); 2005 1984 if (vpi >= 1UL << card->vpibits || vci >= 1UL << card->vcibits) { ··· 2091 2034 recycle_rx_buf(card, skb); 2092 2035 return; 2093 2036 } 2094 - NS_SKB_CB(iovb)->buf_type = BUF_NONE; 2037 + NS_PRV_BUFTYPE(iovb) = BUF_NONE; 2095 2038 } else if (--card->iovpool.count < card->iovnr.min) { 2096 2039 struct sk_buff *new_iovb; 2097 2040 if ((new_iovb = 2098 2041 alloc_skb(NS_IOVBUFSIZE, GFP_ATOMIC)) != NULL) { 2099 - NS_SKB_CB(iovb)->buf_type = BUF_NONE; 2042 + NS_PRV_BUFTYPE(iovb) = BUF_NONE; 2100 2043 skb_queue_tail(&card->iovpool.queue, new_iovb); 2101 2044 card->iovpool.count++; 2102 2045 } 2103 2046 } 2104 2047 vc->rx_iov = iovb; 2105 - NS_SKB(iovb)->iovcnt = 0; 2048 + NS_PRV_IOVCNT(iovb) = 0; 2106 2049 iovb->len = 0; 2107 2050 iovb->data = iovb->head; 2108 2051 skb_reset_tail_pointer(iovb); 2109 - NS_SKB(iovb)->vcc = vcc; 2110 2052 /* IMPORTANT: a pointer to the sk_buff containing the small or large 2111 2053 buffer is stored as iovec base, NOT a pointer to the 2112 2054 small or large buffer itself. */ 2113 - } else if (NS_SKB(iovb)->iovcnt >= NS_MAX_IOVECS) { 2055 + } else if (NS_PRV_IOVCNT(iovb) >= NS_MAX_IOVECS) { 2114 2056 printk("nicstar%d: received too big AAL5 SDU.\n", card->index); 2115 2057 atomic_inc(&vcc->stats->rx_err); 2116 2058 recycle_iovec_rx_bufs(card, (struct iovec *)iovb->data, 2117 2059 NS_MAX_IOVECS); 2118 - NS_SKB(iovb)->iovcnt = 0; 2060 + NS_PRV_IOVCNT(iovb) = 0; 2119 2061 iovb->len = 0; 2120 2062 iovb->data = iovb->head; 2121 2063 skb_reset_tail_pointer(iovb); 2122 - NS_SKB(iovb)->vcc = vcc; 2123 2064 } 2124 - iov = &((struct iovec *)iovb->data)[NS_SKB(iovb)->iovcnt++]; 2065 + iov = &((struct iovec *)iovb->data)[NS_PRV_IOVCNT(iovb)++]; 2125 2066 iov->iov_base = (void *)skb; 2126 2067 iov->iov_len = ns_rsqe_cellcount(rsqe) * 48; 2127 2068 iovb->len += iov->iov_len; 2128 2069 2129 - if (NS_SKB(iovb)->iovcnt == 1) { 2130 - if (NS_SKB_CB(skb)->buf_type != BUF_SM) { 2070 + #ifdef EXTRA_DEBUG 2071 + if (NS_PRV_IOVCNT(iovb) == 1) { 2072 + if (NS_PRV_BUFTYPE(skb) != BUF_SM) { 2131 2073 printk 2132 2074 ("nicstar%d: Expected a small buffer, and this is not one.\n", 2133 2075 card->index); ··· 2137 2081 recycle_iov_buf(card, iovb); 2138 2082 return; 2139 2083 } 2140 - } else { /* NS_SKB(iovb)->iovcnt >= 2 */ 2084 + } else { /* NS_PRV_IOVCNT(iovb) >= 2 */ 2141 2085 2142 - if (NS_SKB_CB(skb)->buf_type != BUF_LG) { 2086 + if (NS_PRV_BUFTYPE(skb) != BUF_LG) { 2143 2087 printk 2144 2088 ("nicstar%d: Expected a large buffer, and this is not one.\n", 2145 2089 card->index); 2146 2090 which_list(card, skb); 2147 2091 atomic_inc(&vcc->stats->rx_err); 2148 2092 recycle_iovec_rx_bufs(card, (struct iovec *)iovb->data, 2149 - NS_SKB(iovb)->iovcnt); 2093 + NS_PRV_IOVCNT(iovb)); 2150 2094 vc->rx_iov = NULL; 2151 2095 recycle_iov_buf(card, iovb); 2152 2096 return; 2153 2097 } 2154 2098 } 2099 + #endif /* EXTRA_DEBUG */ 2155 2100 2156 2101 if (ns_rsqe_eopdu(rsqe)) { 2157 2102 /* This works correctly regardless of the endianness of the host */ 2158 - unsigned char *L1L2 = (unsigned char *)((u32) skb->data + 2159 - iov->iov_len - 6); 2103 + unsigned char *L1L2 = (unsigned char *) 2104 + (skb->data + iov->iov_len - 6); 2160 2105 aal5_len = L1L2[0] << 8 | L1L2[1]; 2161 2106 len = (aal5_len == 0x0000) ? 0x10000 : aal5_len; 2162 2107 if (ns_rsqe_crcerr(rsqe) || ··· 2169 2112 printk(".\n"); 2170 2113 atomic_inc(&vcc->stats->rx_err); 2171 2114 recycle_iovec_rx_bufs(card, (struct iovec *)iovb->data, 2172 - NS_SKB(iovb)->iovcnt); 2115 + NS_PRV_IOVCNT(iovb)); 2173 2116 vc->rx_iov = NULL; 2174 2117 recycle_iov_buf(card, iovb); 2175 2118 return; ··· 2177 2120 2178 2121 /* By this point we (hopefully) have a complete SDU without errors. */ 2179 2122 2180 - if (NS_SKB(iovb)->iovcnt == 1) { /* Just a small buffer */ 2123 + if (NS_PRV_IOVCNT(iovb) == 1) { /* Just a small buffer */ 2181 2124 /* skb points to a small buffer */ 2182 2125 if (!atm_charge(vcc, skb->truesize)) { 2183 2126 push_rxbufs(card, skb); ··· 2193 2136 vcc->push(vcc, skb); 2194 2137 atomic_inc(&vcc->stats->rx); 2195 2138 } 2196 - } else if (NS_SKB(iovb)->iovcnt == 2) { /* One small plus one large buffer */ 2139 + } else if (NS_PRV_IOVCNT(iovb) == 2) { /* One small plus one large buffer */ 2197 2140 struct sk_buff *sb; 2198 2141 2199 2142 sb = (struct sk_buff *)(iov - 1)->iov_base; ··· 2259 2202 recycle_iovec_rx_bufs(card, 2260 2203 (struct iovec *) 2261 2204 iovb->data, 2262 - NS_SKB(iovb)-> 2263 - iovcnt); 2205 + NS_PRV_IOVCNT(iovb)); 2264 2206 vc->rx_iov = NULL; 2265 2207 recycle_iov_buf(card, iovb); 2266 2208 return; ··· 2273 2217 card->hbpool.count++; 2274 2218 } 2275 2219 } 2276 - NS_SKB_CB(hb)->buf_type = BUF_NONE; 2220 + NS_PRV_BUFTYPE(hb) = BUF_NONE; 2277 2221 } else if (--card->hbpool.count < card->hbnr.min) { 2278 2222 struct sk_buff *new_hb; 2279 2223 if ((new_hb = 2280 2224 dev_alloc_skb(NS_HBUFSIZE)) != NULL) { 2281 - NS_SKB_CB(new_hb)->buf_type = BUF_NONE; 2225 + NS_PRV_BUFTYPE(new_hb) = BUF_NONE; 2282 2226 skb_queue_tail(&card->hbpool.queue, 2283 2227 new_hb); 2284 2228 card->hbpool.count++; ··· 2287 2231 if ((new_hb = 2288 2232 dev_alloc_skb(NS_HBUFSIZE)) != 2289 2233 NULL) { 2290 - NS_SKB_CB(new_hb)->buf_type = 2234 + NS_PRV_BUFTYPE(new_hb) = 2291 2235 BUF_NONE; 2292 2236 skb_queue_tail(&card->hbpool. 2293 2237 queue, new_hb); ··· 2300 2244 2301 2245 if (!atm_charge(vcc, hb->truesize)) { 2302 2246 recycle_iovec_rx_bufs(card, iov, 2303 - NS_SKB(iovb)->iovcnt); 2247 + NS_PRV_IOVCNT(iovb)); 2304 2248 if (card->hbpool.count < card->hbnr.max) { 2305 2249 skb_queue_tail(&card->hbpool.queue, hb); 2306 2250 card->hbpool.count++; ··· 2319 2263 push_rxbufs(card, sb); 2320 2264 2321 2265 /* Copy all large buffers to the huge buffer and free them */ 2322 - for (j = 1; j < NS_SKB(iovb)->iovcnt; j++) { 2266 + for (j = 1; j < NS_PRV_IOVCNT(iovb); j++) { 2323 2267 lb = (struct sk_buff *)iov->iov_base; 2324 2268 tocopy = 2325 2269 min_t(int, remaining, iov->iov_len); ··· 2369 2313 sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL); 2370 2314 if (sb == NULL) 2371 2315 break; 2372 - NS_SKB_CB(sb)->buf_type = BUF_SM; 2316 + NS_PRV_BUFTYPE(sb) = BUF_SM; 2373 2317 skb_queue_tail(&card->sbpool.queue, sb); 2374 2318 skb_reserve(sb, NS_AAL0_HEADER); 2375 2319 push_rxbufs(card, sb); ··· 2390 2334 lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL); 2391 2335 if (lb == NULL) 2392 2336 break; 2393 - NS_SKB_CB(lb)->buf_type = BUF_LG; 2337 + NS_PRV_BUFTYPE(lb) = BUF_LG; 2394 2338 skb_queue_tail(&card->lbpool.queue, lb); 2395 2339 skb_reserve(lb, NS_SMBUFSIZE); 2396 2340 push_rxbufs(card, lb); ··· 2407 2351 hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL); 2408 2352 if (hb == NULL) 2409 2353 break; 2410 - NS_SKB_CB(hb)->buf_type = BUF_NONE; 2354 + NS_PRV_BUFTYPE(hb) = BUF_NONE; 2411 2355 skb_queue_tail(&card->hbpool.queue, hb); 2412 2356 card->hbpool.count++; 2413 2357 } ··· 2417 2361 2418 2362 static void recycle_rx_buf(ns_dev * card, struct sk_buff *skb) 2419 2363 { 2420 - struct ns_skb_cb *cb = NS_SKB_CB(skb); 2421 - 2422 - if (unlikely(cb->buf_type == BUF_NONE)) { 2364 + if (unlikely(NS_PRV_BUFTYPE(skb) == BUF_NONE)) { 2423 2365 printk("nicstar%d: What kind of rx buffer is this?\n", 2424 2366 card->index); 2425 2367 dev_kfree_skb_any(skb); ··· 2449 2395 if (card->sbfqc < card->sbnr.init) { 2450 2396 struct sk_buff *new_sb; 2451 2397 if ((new_sb = dev_alloc_skb(NS_SMSKBSIZE)) != NULL) { 2452 - NS_SKB_CB(new_sb)->buf_type = BUF_SM; 2398 + NS_PRV_BUFTYPE(new_sb) = BUF_SM; 2453 2399 skb_queue_tail(&card->sbpool.queue, new_sb); 2454 2400 skb_reserve(new_sb, NS_AAL0_HEADER); 2455 2401 push_rxbufs(card, new_sb); ··· 2460 2406 { 2461 2407 struct sk_buff *new_sb; 2462 2408 if ((new_sb = dev_alloc_skb(NS_SMSKBSIZE)) != NULL) { 2463 - NS_SKB_CB(new_sb)->buf_type = BUF_SM; 2409 + NS_PRV_BUFTYPE(new_sb) = BUF_SM; 2464 2410 skb_queue_tail(&card->sbpool.queue, new_sb); 2465 2411 skb_reserve(new_sb, NS_AAL0_HEADER); 2466 2412 push_rxbufs(card, new_sb); ··· 2477 2423 if (card->lbfqc < card->lbnr.init) { 2478 2424 struct sk_buff *new_lb; 2479 2425 if ((new_lb = dev_alloc_skb(NS_LGSKBSIZE)) != NULL) { 2480 - NS_SKB_CB(new_lb)->buf_type = BUF_LG; 2426 + NS_PRV_BUFTYPE(new_lb) = BUF_LG; 2481 2427 skb_queue_tail(&card->lbpool.queue, new_lb); 2482 2428 skb_reserve(new_lb, NS_SMBUFSIZE); 2483 2429 push_rxbufs(card, new_lb); ··· 2488 2434 { 2489 2435 struct sk_buff *new_lb; 2490 2436 if ((new_lb = dev_alloc_skb(NS_LGSKBSIZE)) != NULL) { 2491 - NS_SKB_CB(new_lb)->buf_type = BUF_LG; 2437 + NS_PRV_BUFTYPE(new_lb) = BUF_LG; 2492 2438 skb_queue_tail(&card->lbpool.queue, new_lb); 2493 2439 skb_reserve(new_lb, NS_SMBUFSIZE); 2494 2440 push_rxbufs(card, new_lb); ··· 2679 2625 sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL); 2680 2626 if (sb == NULL) 2681 2627 return -ENOMEM; 2682 - NS_SKB_CB(sb)->buf_type = BUF_SM; 2628 + NS_PRV_BUFTYPE(sb) = BUF_SM; 2683 2629 skb_queue_tail(&card->sbpool.queue, sb); 2684 2630 skb_reserve(sb, NS_AAL0_HEADER); 2685 2631 push_rxbufs(card, sb); ··· 2693 2639 lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL); 2694 2640 if (lb == NULL) 2695 2641 return -ENOMEM; 2696 - NS_SKB_CB(lb)->buf_type = BUF_LG; 2642 + NS_PRV_BUFTYPE(lb) = BUF_LG; 2697 2643 skb_queue_tail(&card->lbpool.queue, lb); 2698 2644 skb_reserve(lb, NS_SMBUFSIZE); 2699 2645 push_rxbufs(card, lb); ··· 2722 2668 hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL); 2723 2669 if (hb == NULL) 2724 2670 return -ENOMEM; 2725 - NS_SKB_CB(hb)->buf_type = BUF_NONE; 2671 + NS_PRV_BUFTYPE(hb) = BUF_NONE; 2726 2672 spin_lock_irqsave(&card->int_lock, flags); 2727 2673 skb_queue_tail(&card->hbpool.queue, hb); 2728 2674 card->hbpool.count++; ··· 2752 2698 iovb = alloc_skb(NS_IOVBUFSIZE, GFP_KERNEL); 2753 2699 if (iovb == NULL) 2754 2700 return -ENOMEM; 2755 - NS_SKB_CB(iovb)->buf_type = BUF_NONE; 2701 + NS_PRV_BUFTYPE(iovb) = BUF_NONE; 2756 2702 spin_lock_irqsave(&card->int_lock, flags); 2757 2703 skb_queue_tail(&card->iovpool.queue, iovb); 2758 2704 card->iovpool.count++; ··· 2777 2723 } 2778 2724 } 2779 2725 2726 + #ifdef EXTRA_DEBUG 2780 2727 static void which_list(ns_dev * card, struct sk_buff *skb) 2781 2728 { 2782 - printk("skb buf_type: 0x%08x\n", NS_SKB_CB(skb)->buf_type); 2729 + printk("skb buf_type: 0x%08x\n", NS_PRV_BUFTYPE(skb)); 2783 2730 } 2731 + #endif /* EXTRA_DEBUG */ 2784 2732 2785 2733 static void ns_poll(unsigned long arg) 2786 2734 { ··· 2859 2803 card = dev->dev_data; 2860 2804 spin_lock_irqsave(&card->res_lock, flags); 2861 2805 while (CMD_BUSY(card)) ; 2862 - writel((unsigned long)value, card->membase + DR0); 2806 + writel((u32) value, card->membase + DR0); 2863 2807 writel(NS_CMD_WRITE_UTILITY | 0x00000200 | (addr & 0x000000FF), 2864 2808 card->membase + CMD); 2865 2809 spin_unlock_irqrestore(&card->res_lock, flags); ··· 2869 2813 { 2870 2814 ns_dev *card; 2871 2815 unsigned long flags; 2872 - unsigned long data; 2816 + u32 data; 2873 2817 2874 2818 card = dev->dev_data; 2875 2819 spin_lock_irqsave(&card->res_lock, flags);

+17 -11

drivers/atm/nicstar.h

··· 16 16 17 17 #include <linux/types.h> 18 18 #include <linux/pci.h> 19 + #include <linux/idr.h> 19 20 #include <linux/uio.h> 20 21 #include <linux/skbuff.h> 21 22 #include <linux/atmdev.h> ··· 637 636 638 637 /* Device driver structures */ 639 638 640 - struct ns_skb_cb { 639 + struct ns_skb_prv { 641 640 u32 buf_type; /* BUF_SM/BUF_LG/BUF_NONE */ 641 + u32 dma; 642 + int iovcnt; 642 643 }; 643 644 644 - #define NS_SKB_CB(skb) ((struct ns_skb_cb *)((skb)->cb)) 645 + #define NS_PRV_BUFTYPE(skb) \ 646 + (((struct ns_skb_prv *)(ATM_SKB(skb)+1))->buf_type) 647 + #define NS_PRV_DMA(skb) \ 648 + (((struct ns_skb_prv *)(ATM_SKB(skb)+1))->dma) 649 + #define NS_PRV_IOVCNT(skb) \ 650 + (((struct ns_skb_prv *)(ATM_SKB(skb)+1))->iovcnt) 645 651 646 652 typedef struct tsq_info { 647 653 void *org; 654 + dma_addr_t dma; 648 655 ns_tsi *base; 649 656 ns_tsi *next; 650 657 ns_tsi *last; ··· 660 651 661 652 typedef struct scq_info { 662 653 void *org; 654 + dma_addr_t dma; 663 655 ns_scqe *base; 664 656 ns_scqe *last; 665 657 ns_scqe *next; ··· 678 668 679 669 typedef struct rsq_info { 680 670 void *org; 671 + dma_addr_t dma; 681 672 ns_rsqe *base; 682 673 ns_rsqe *next; 683 674 ns_rsqe *last; ··· 704 693 int tbd_count; 705 694 } vc_map; 706 695 707 - struct ns_skb_data { 708 - struct atm_vcc *vcc; 709 - int iovcnt; 710 - }; 711 - 712 - #define NS_SKB(skb) (((struct ns_skb_data *) (skb)->cb)) 713 - 714 696 typedef struct ns_dev { 715 697 int index; /* Card ID to the device driver */ 716 698 int sram_size; /* In k x 32bit words. 32 or 128 */ ··· 713 709 int vpibits; 714 710 int vcibits; 715 711 struct pci_dev *pcidev; 712 + struct idr idr; 716 713 struct atm_dev *atmdev; 717 714 tsq_info tsq; 718 715 rsq_info rsq; ··· 734 729 buf_nr iovnr; 735 730 int sbfqc; 736 731 int lbfqc; 737 - u32 sm_handle; 732 + struct sk_buff *sm_handle; 738 733 u32 sm_addr; 739 - u32 lg_handle; 734 + struct sk_buff *lg_handle; 740 735 u32 lg_addr; 741 736 struct sk_buff *rcbuf; /* Current raw cell buffer */ 737 + struct ns_rcqe *rawcell; 742 738 u32 rawch; /* Raw cell queue head */ 743 739 unsigned intcnt; /* Interrupt counter */ 744 740 spinlock_t int_lock; /* Interrupt lock */