diff options
-rw-r--r-- | drivers/atm/eni.c | 33 | ||||
-rw-r--r-- | drivers/atm/fore200e.c | 22 | ||||
-rw-r--r-- | drivers/atm/he.c | 125 | ||||
-rw-r--r-- | drivers/atm/he.h | 4 | ||||
-rw-r--r-- | drivers/atm/idt77252.c | 107 | ||||
-rw-r--r-- | drivers/atm/iphase.c | 54 | ||||
-rw-r--r-- | drivers/atm/lanai.c | 14 | ||||
-rw-r--r-- | drivers/atm/nicstar.c | 60 | ||||
-rw-r--r-- | drivers/atm/solos-pci.c | 26 | ||||
-rw-r--r-- | drivers/atm/zatm.c | 17 |
10 files changed, 243 insertions, 219 deletions
diff --git a/drivers/atm/eni.c b/drivers/atm/eni.c index c7fab3ee14ee..6339efd32697 100644 --- a/drivers/atm/eni.c +++ b/drivers/atm/eni.c | |||
@@ -354,9 +354,9 @@ static int do_rx_dma(struct atm_vcc *vcc,struct sk_buff *skb, | |||
354 | eni_vcc = ENI_VCC(vcc); | 354 | eni_vcc = ENI_VCC(vcc); |
355 | paddr = 0; /* GCC, shut up */ | 355 | paddr = 0; /* GCC, shut up */ |
356 | if (skb) { | 356 | if (skb) { |
357 | paddr = pci_map_single(eni_dev->pci_dev,skb->data,skb->len, | 357 | paddr = dma_map_single(&eni_dev->pci_dev->dev,skb->data,skb->len, |
358 | PCI_DMA_FROMDEVICE); | 358 | DMA_FROM_DEVICE); |
359 | if (pci_dma_mapping_error(eni_dev->pci_dev, paddr)) | 359 | if (dma_mapping_error(&eni_dev->pci_dev->dev, paddr)) |
360 | goto dma_map_error; | 360 | goto dma_map_error; |
361 | ENI_PRV_PADDR(skb) = paddr; | 361 | ENI_PRV_PADDR(skb) = paddr; |
362 | if (paddr & 3) | 362 | if (paddr & 3) |
@@ -481,8 +481,8 @@ rx_enqueued++; | |||
481 | 481 | ||
482 | trouble: | 482 | trouble: |
483 | if (paddr) | 483 | if (paddr) |
484 | pci_unmap_single(eni_dev->pci_dev,paddr,skb->len, | 484 | dma_unmap_single(&eni_dev->pci_dev->dev,paddr,skb->len, |
485 | PCI_DMA_FROMDEVICE); | 485 | DMA_FROM_DEVICE); |
486 | dma_map_error: | 486 | dma_map_error: |
487 | if (skb) dev_kfree_skb_irq(skb); | 487 | if (skb) dev_kfree_skb_irq(skb); |
488 | return -1; | 488 | return -1; |
@@ -758,8 +758,8 @@ rx_dequeued++; | |||
758 | } | 758 | } |
759 | eni_vcc->rxing--; | 759 | eni_vcc->rxing--; |
760 | eni_vcc->rx_pos = ENI_PRV_POS(skb) & (eni_vcc->words-1); | 760 | eni_vcc->rx_pos = ENI_PRV_POS(skb) & (eni_vcc->words-1); |
761 | pci_unmap_single(eni_dev->pci_dev,ENI_PRV_PADDR(skb),skb->len, | 761 | dma_unmap_single(&eni_dev->pci_dev->dev,ENI_PRV_PADDR(skb),skb->len, |
762 | PCI_DMA_TODEVICE); | 762 | DMA_TO_DEVICE); |
763 | if (!skb->len) dev_kfree_skb_irq(skb); | 763 | if (!skb->len) dev_kfree_skb_irq(skb); |
764 | else { | 764 | else { |
765 | EVENT("pushing (len=%ld)\n",skb->len,0); | 765 | EVENT("pushing (len=%ld)\n",skb->len,0); |
@@ -1112,8 +1112,8 @@ DPRINTK("iovcnt = %d\n",skb_shinfo(skb)->nr_frags); | |||
1112 | vcc->dev->number); | 1112 | vcc->dev->number); |
1113 | return enq_jam; | 1113 | return enq_jam; |
1114 | } | 1114 | } |
1115 | paddr = pci_map_single(eni_dev->pci_dev,skb->data,skb->len, | 1115 | paddr = dma_map_single(&eni_dev->pci_dev->dev,skb->data,skb->len, |
1116 | PCI_DMA_TODEVICE); | 1116 | DMA_TO_DEVICE); |
1117 | ENI_PRV_PADDR(skb) = paddr; | 1117 | ENI_PRV_PADDR(skb) = paddr; |
1118 | /* prepare DMA queue entries */ | 1118 | /* prepare DMA queue entries */ |
1119 | j = 0; | 1119 | j = 0; |
@@ -1226,8 +1226,8 @@ static void dequeue_tx(struct atm_dev *dev) | |||
1226 | break; | 1226 | break; |
1227 | } | 1227 | } |
1228 | ENI_VCC(vcc)->txing -= ENI_PRV_SIZE(skb); | 1228 | ENI_VCC(vcc)->txing -= ENI_PRV_SIZE(skb); |
1229 | pci_unmap_single(eni_dev->pci_dev,ENI_PRV_PADDR(skb),skb->len, | 1229 | dma_unmap_single(&eni_dev->pci_dev->dev,ENI_PRV_PADDR(skb),skb->len, |
1230 | PCI_DMA_TODEVICE); | 1230 | DMA_TO_DEVICE); |
1231 | if (vcc->pop) vcc->pop(vcc,skb); | 1231 | if (vcc->pop) vcc->pop(vcc,skb); |
1232 | else dev_kfree_skb_irq(skb); | 1232 | else dev_kfree_skb_irq(skb); |
1233 | atomic_inc(&vcc->stats->tx); | 1233 | atomic_inc(&vcc->stats->tx); |
@@ -2240,13 +2240,18 @@ static int eni_init_one(struct pci_dev *pci_dev, | |||
2240 | if (rc < 0) | 2240 | if (rc < 0) |
2241 | goto out; | 2241 | goto out; |
2242 | 2242 | ||
2243 | rc = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)); | ||
2244 | if (rc < 0) | ||
2245 | goto out; | ||
2246 | |||
2243 | rc = -ENOMEM; | 2247 | rc = -ENOMEM; |
2244 | eni_dev = kmalloc(sizeof(struct eni_dev), GFP_KERNEL); | 2248 | eni_dev = kmalloc(sizeof(struct eni_dev), GFP_KERNEL); |
2245 | if (!eni_dev) | 2249 | if (!eni_dev) |
2246 | goto err_disable; | 2250 | goto err_disable; |
2247 | 2251 | ||
2248 | zero = &eni_dev->zero; | 2252 | zero = &eni_dev->zero; |
2249 | zero->addr = pci_alloc_consistent(pci_dev, ENI_ZEROES_SIZE, &zero->dma); | 2253 | zero->addr = dma_alloc_coherent(&pci_dev->dev, |
2254 | ENI_ZEROES_SIZE, &zero->dma, GFP_KERNEL); | ||
2250 | if (!zero->addr) | 2255 | if (!zero->addr) |
2251 | goto err_kfree; | 2256 | goto err_kfree; |
2252 | 2257 | ||
@@ -2277,7 +2282,7 @@ err_eni_release: | |||
2277 | err_unregister: | 2282 | err_unregister: |
2278 | atm_dev_deregister(dev); | 2283 | atm_dev_deregister(dev); |
2279 | err_free_consistent: | 2284 | err_free_consistent: |
2280 | pci_free_consistent(pci_dev, ENI_ZEROES_SIZE, zero->addr, zero->dma); | 2285 | dma_free_coherent(&pci_dev->dev, ENI_ZEROES_SIZE, zero->addr, zero->dma); |
2281 | err_kfree: | 2286 | err_kfree: |
2282 | kfree(eni_dev); | 2287 | kfree(eni_dev); |
2283 | err_disable: | 2288 | err_disable: |
@@ -2302,7 +2307,7 @@ static void eni_remove_one(struct pci_dev *pdev) | |||
2302 | 2307 | ||
2303 | eni_do_release(dev); | 2308 | eni_do_release(dev); |
2304 | atm_dev_deregister(dev); | 2309 | atm_dev_deregister(dev); |
2305 | pci_free_consistent(pdev, ENI_ZEROES_SIZE, zero->addr, zero->dma); | 2310 | dma_free_coherent(&pdev->dev, ENI_ZEROES_SIZE, zero->addr, zero->dma); |
2306 | kfree(ed); | 2311 | kfree(ed); |
2307 | pci_disable_device(pdev); | 2312 | pci_disable_device(pdev); |
2308 | } | 2313 | } |
diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c index d5d9eafbbfcf..75dde903b238 100644 --- a/drivers/atm/fore200e.c +++ b/drivers/atm/fore200e.c | |||
@@ -425,7 +425,7 @@ static void fore200e_pca_write(u32 val, volatile u32 __iomem *addr) | |||
425 | static u32 | 425 | static u32 |
426 | fore200e_pca_dma_map(struct fore200e* fore200e, void* virt_addr, int size, int direction) | 426 | fore200e_pca_dma_map(struct fore200e* fore200e, void* virt_addr, int size, int direction) |
427 | { | 427 | { |
428 | u32 dma_addr = pci_map_single((struct pci_dev*)fore200e->bus_dev, virt_addr, size, direction); | 428 | u32 dma_addr = dma_map_single(&((struct pci_dev *) fore200e->bus_dev)->dev, virt_addr, size, direction); |
429 | 429 | ||
430 | DPRINTK(3, "PCI DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d, --> dma_addr = 0x%08x\n", | 430 | DPRINTK(3, "PCI DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d, --> dma_addr = 0x%08x\n", |
431 | virt_addr, size, direction, dma_addr); | 431 | virt_addr, size, direction, dma_addr); |
@@ -440,7 +440,7 @@ fore200e_pca_dma_unmap(struct fore200e* fore200e, u32 dma_addr, int size, int di | |||
440 | DPRINTK(3, "PCI DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d\n", | 440 | DPRINTK(3, "PCI DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d\n", |
441 | dma_addr, size, direction); | 441 | dma_addr, size, direction); |
442 | 442 | ||
443 | pci_unmap_single((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction); | 443 | dma_unmap_single(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction); |
444 | } | 444 | } |
445 | 445 | ||
446 | 446 | ||
@@ -449,7 +449,7 @@ fore200e_pca_dma_sync_for_cpu(struct fore200e* fore200e, u32 dma_addr, int size, | |||
449 | { | 449 | { |
450 | DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); | 450 | DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); |
451 | 451 | ||
452 | pci_dma_sync_single_for_cpu((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction); | 452 | dma_sync_single_for_cpu(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction); |
453 | } | 453 | } |
454 | 454 | ||
455 | static void | 455 | static void |
@@ -457,7 +457,7 @@ fore200e_pca_dma_sync_for_device(struct fore200e* fore200e, u32 dma_addr, int si | |||
457 | { | 457 | { |
458 | DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); | 458 | DPRINTK(3, "PCI DVMA sync: dma_addr = 0x%08x, size = %d, direction = %d\n", dma_addr, size, direction); |
459 | 459 | ||
460 | pci_dma_sync_single_for_device((struct pci_dev*)fore200e->bus_dev, dma_addr, size, direction); | 460 | dma_sync_single_for_device(&((struct pci_dev *) fore200e->bus_dev)->dev, dma_addr, size, direction); |
461 | } | 461 | } |
462 | 462 | ||
463 | 463 | ||
@@ -470,9 +470,10 @@ fore200e_pca_dma_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, | |||
470 | { | 470 | { |
471 | /* returned chunks are page-aligned */ | 471 | /* returned chunks are page-aligned */ |
472 | chunk->alloc_size = size * nbr; | 472 | chunk->alloc_size = size * nbr; |
473 | chunk->alloc_addr = pci_alloc_consistent((struct pci_dev*)fore200e->bus_dev, | 473 | chunk->alloc_addr = dma_alloc_coherent(&((struct pci_dev *) fore200e->bus_dev)->dev, |
474 | chunk->alloc_size, | 474 | chunk->alloc_size, |
475 | &chunk->dma_addr); | 475 | &chunk->dma_addr, |
476 | GFP_KERNEL); | ||
476 | 477 | ||
477 | if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0)) | 478 | if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0)) |
478 | return -ENOMEM; | 479 | return -ENOMEM; |
@@ -488,7 +489,7 @@ fore200e_pca_dma_chunk_alloc(struct fore200e* fore200e, struct chunk* chunk, | |||
488 | static void | 489 | static void |
489 | fore200e_pca_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk) | 490 | fore200e_pca_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk) |
490 | { | 491 | { |
491 | pci_free_consistent((struct pci_dev*)fore200e->bus_dev, | 492 | dma_free_coherent(&((struct pci_dev *) fore200e->bus_dev)->dev, |
492 | chunk->alloc_size, | 493 | chunk->alloc_size, |
493 | chunk->alloc_addr, | 494 | chunk->alloc_addr, |
494 | chunk->dma_addr); | 495 | chunk->dma_addr); |
@@ -2707,6 +2708,11 @@ static int fore200e_pca_detect(struct pci_dev *pci_dev, | |||
2707 | err = -EINVAL; | 2708 | err = -EINVAL; |
2708 | goto out; | 2709 | goto out; |
2709 | } | 2710 | } |
2711 | |||
2712 | if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) { | ||
2713 | err = -EINVAL; | ||
2714 | goto out; | ||
2715 | } | ||
2710 | 2716 | ||
2711 | fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL); | 2717 | fore200e = kzalloc(sizeof(struct fore200e), GFP_KERNEL); |
2712 | if (fore200e == NULL) { | 2718 | if (fore200e == NULL) { |
diff --git a/drivers/atm/he.c b/drivers/atm/he.c index c39702bc279d..93dca2e73bf5 100644 --- a/drivers/atm/he.c +++ b/drivers/atm/he.c | |||
@@ -359,7 +359,7 @@ static int he_init_one(struct pci_dev *pci_dev, | |||
359 | 359 | ||
360 | if (pci_enable_device(pci_dev)) | 360 | if (pci_enable_device(pci_dev)) |
361 | return -EIO; | 361 | return -EIO; |
362 | if (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)) != 0) { | 362 | if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)) != 0) { |
363 | printk(KERN_WARNING "he: no suitable dma available\n"); | 363 | printk(KERN_WARNING "he: no suitable dma available\n"); |
364 | err = -EIO; | 364 | err = -EIO; |
365 | goto init_one_failure; | 365 | goto init_one_failure; |
@@ -533,9 +533,9 @@ static void he_init_tx_lbfp(struct he_dev *he_dev) | |||
533 | 533 | ||
534 | static int he_init_tpdrq(struct he_dev *he_dev) | 534 | static int he_init_tpdrq(struct he_dev *he_dev) |
535 | { | 535 | { |
536 | he_dev->tpdrq_base = pci_zalloc_consistent(he_dev->pci_dev, | 536 | he_dev->tpdrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, |
537 | CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq), | 537 | CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq), |
538 | &he_dev->tpdrq_phys); | 538 | &he_dev->tpdrq_phys, GFP_KERNEL); |
539 | if (he_dev->tpdrq_base == NULL) { | 539 | if (he_dev->tpdrq_base == NULL) { |
540 | hprintk("failed to alloc tpdrq\n"); | 540 | hprintk("failed to alloc tpdrq\n"); |
541 | return -ENOMEM; | 541 | return -ENOMEM; |
@@ -796,16 +796,16 @@ static int he_init_group(struct he_dev *he_dev, int group) | |||
796 | } | 796 | } |
797 | 797 | ||
798 | /* large buffer pool */ | 798 | /* large buffer pool */ |
799 | he_dev->rbpl_pool = pci_pool_create("rbpl", he_dev->pci_dev, | 799 | he_dev->rbpl_pool = dma_pool_create("rbpl", &he_dev->pci_dev->dev, |
800 | CONFIG_RBPL_BUFSIZE, 64, 0); | 800 | CONFIG_RBPL_BUFSIZE, 64, 0); |
801 | if (he_dev->rbpl_pool == NULL) { | 801 | if (he_dev->rbpl_pool == NULL) { |
802 | hprintk("unable to create rbpl pool\n"); | 802 | hprintk("unable to create rbpl pool\n"); |
803 | goto out_free_rbpl_virt; | 803 | goto out_free_rbpl_virt; |
804 | } | 804 | } |
805 | 805 | ||
806 | he_dev->rbpl_base = pci_zalloc_consistent(he_dev->pci_dev, | 806 | he_dev->rbpl_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, |
807 | CONFIG_RBPL_SIZE * sizeof(struct he_rbp), | 807 | CONFIG_RBPL_SIZE * sizeof(struct he_rbp), |
808 | &he_dev->rbpl_phys); | 808 | &he_dev->rbpl_phys, GFP_KERNEL); |
809 | if (he_dev->rbpl_base == NULL) { | 809 | if (he_dev->rbpl_base == NULL) { |
810 | hprintk("failed to alloc rbpl_base\n"); | 810 | hprintk("failed to alloc rbpl_base\n"); |
811 | goto out_destroy_rbpl_pool; | 811 | goto out_destroy_rbpl_pool; |
@@ -815,7 +815,7 @@ static int he_init_group(struct he_dev *he_dev, int group) | |||
815 | 815 | ||
816 | for (i = 0; i < CONFIG_RBPL_SIZE; ++i) { | 816 | for (i = 0; i < CONFIG_RBPL_SIZE; ++i) { |
817 | 817 | ||
818 | heb = pci_pool_alloc(he_dev->rbpl_pool, GFP_KERNEL|GFP_DMA, &mapping); | 818 | heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_KERNEL, &mapping); |
819 | if (!heb) | 819 | if (!heb) |
820 | goto out_free_rbpl; | 820 | goto out_free_rbpl; |
821 | heb->mapping = mapping; | 821 | heb->mapping = mapping; |
@@ -842,9 +842,9 @@ static int he_init_group(struct he_dev *he_dev, int group) | |||
842 | 842 | ||
843 | /* rx buffer ready queue */ | 843 | /* rx buffer ready queue */ |
844 | 844 | ||
845 | he_dev->rbrq_base = pci_zalloc_consistent(he_dev->pci_dev, | 845 | he_dev->rbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, |
846 | CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), | 846 | CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), |
847 | &he_dev->rbrq_phys); | 847 | &he_dev->rbrq_phys, GFP_KERNEL); |
848 | if (he_dev->rbrq_base == NULL) { | 848 | if (he_dev->rbrq_base == NULL) { |
849 | hprintk("failed to allocate rbrq\n"); | 849 | hprintk("failed to allocate rbrq\n"); |
850 | goto out_free_rbpl; | 850 | goto out_free_rbpl; |
@@ -866,9 +866,9 @@ static int he_init_group(struct he_dev *he_dev, int group) | |||
866 | 866 | ||
867 | /* tx buffer ready queue */ | 867 | /* tx buffer ready queue */ |
868 | 868 | ||
869 | he_dev->tbrq_base = pci_zalloc_consistent(he_dev->pci_dev, | 869 | he_dev->tbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, |
870 | CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), | 870 | CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), |
871 | &he_dev->tbrq_phys); | 871 | &he_dev->tbrq_phys, GFP_KERNEL); |
872 | if (he_dev->tbrq_base == NULL) { | 872 | if (he_dev->tbrq_base == NULL) { |
873 | hprintk("failed to allocate tbrq\n"); | 873 | hprintk("failed to allocate tbrq\n"); |
874 | goto out_free_rbpq_base; | 874 | goto out_free_rbpq_base; |
@@ -884,18 +884,18 @@ static int he_init_group(struct he_dev *he_dev, int group) | |||
884 | return 0; | 884 | return 0; |
885 | 885 | ||
886 | out_free_rbpq_base: | 886 | out_free_rbpq_base: |
887 | pci_free_consistent(he_dev->pci_dev, CONFIG_RBRQ_SIZE * | 887 | dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * |
888 | sizeof(struct he_rbrq), he_dev->rbrq_base, | 888 | sizeof(struct he_rbrq), he_dev->rbrq_base, |
889 | he_dev->rbrq_phys); | 889 | he_dev->rbrq_phys); |
890 | out_free_rbpl: | 890 | out_free_rbpl: |
891 | list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) | 891 | list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) |
892 | pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); | 892 | dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); |
893 | 893 | ||
894 | pci_free_consistent(he_dev->pci_dev, CONFIG_RBPL_SIZE * | 894 | dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE * |
895 | sizeof(struct he_rbp), he_dev->rbpl_base, | 895 | sizeof(struct he_rbp), he_dev->rbpl_base, |
896 | he_dev->rbpl_phys); | 896 | he_dev->rbpl_phys); |
897 | out_destroy_rbpl_pool: | 897 | out_destroy_rbpl_pool: |
898 | pci_pool_destroy(he_dev->rbpl_pool); | 898 | dma_pool_destroy(he_dev->rbpl_pool); |
899 | out_free_rbpl_virt: | 899 | out_free_rbpl_virt: |
900 | kfree(he_dev->rbpl_virt); | 900 | kfree(he_dev->rbpl_virt); |
901 | out_free_rbpl_table: | 901 | out_free_rbpl_table: |
@@ -911,8 +911,11 @@ static int he_init_irq(struct he_dev *he_dev) | |||
911 | /* 2.9.3.5 tail offset for each interrupt queue is located after the | 911 | /* 2.9.3.5 tail offset for each interrupt queue is located after the |
912 | end of the interrupt queue */ | 912 | end of the interrupt queue */ |
913 | 913 | ||
914 | he_dev->irq_base = pci_alloc_consistent(he_dev->pci_dev, | 914 | he_dev->irq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, |
915 | (CONFIG_IRQ_SIZE+1) * sizeof(struct he_irq), &he_dev->irq_phys); | 915 | (CONFIG_IRQ_SIZE + 1) |
916 | * sizeof(struct he_irq), | ||
917 | &he_dev->irq_phys, | ||
918 | GFP_KERNEL); | ||
916 | if (he_dev->irq_base == NULL) { | 919 | if (he_dev->irq_base == NULL) { |
917 | hprintk("failed to allocate irq\n"); | 920 | hprintk("failed to allocate irq\n"); |
918 | return -ENOMEM; | 921 | return -ENOMEM; |
@@ -1419,10 +1422,10 @@ static int he_start(struct atm_dev *dev) | |||
1419 | 1422 | ||
1420 | he_init_tpdrq(he_dev); | 1423 | he_init_tpdrq(he_dev); |
1421 | 1424 | ||
1422 | he_dev->tpd_pool = pci_pool_create("tpd", he_dev->pci_dev, | 1425 | he_dev->tpd_pool = dma_pool_create("tpd", &he_dev->pci_dev->dev, |
1423 | sizeof(struct he_tpd), TPD_ALIGNMENT, 0); | 1426 | sizeof(struct he_tpd), TPD_ALIGNMENT, 0); |
1424 | if (he_dev->tpd_pool == NULL) { | 1427 | if (he_dev->tpd_pool == NULL) { |
1425 | hprintk("unable to create tpd pci_pool\n"); | 1428 | hprintk("unable to create tpd dma_pool\n"); |
1426 | return -ENOMEM; | 1429 | return -ENOMEM; |
1427 | } | 1430 | } |
1428 | 1431 | ||
@@ -1459,9 +1462,9 @@ static int he_start(struct atm_dev *dev) | |||
1459 | 1462 | ||
1460 | /* host status page */ | 1463 | /* host status page */ |
1461 | 1464 | ||
1462 | he_dev->hsp = pci_zalloc_consistent(he_dev->pci_dev, | 1465 | he_dev->hsp = dma_zalloc_coherent(&he_dev->pci_dev->dev, |
1463 | sizeof(struct he_hsp), | 1466 | sizeof(struct he_hsp), |
1464 | &he_dev->hsp_phys); | 1467 | &he_dev->hsp_phys, GFP_KERNEL); |
1465 | if (he_dev->hsp == NULL) { | 1468 | if (he_dev->hsp == NULL) { |
1466 | hprintk("failed to allocate host status page\n"); | 1469 | hprintk("failed to allocate host status page\n"); |
1467 | return -ENOMEM; | 1470 | return -ENOMEM; |
@@ -1558,41 +1561,41 @@ he_stop(struct he_dev *he_dev) | |||
1558 | free_irq(he_dev->irq, he_dev); | 1561 | free_irq(he_dev->irq, he_dev); |
1559 | 1562 | ||
1560 | if (he_dev->irq_base) | 1563 | if (he_dev->irq_base) |
1561 | pci_free_consistent(he_dev->pci_dev, (CONFIG_IRQ_SIZE+1) | 1564 | dma_free_coherent(&he_dev->pci_dev->dev, (CONFIG_IRQ_SIZE + 1) |
1562 | * sizeof(struct he_irq), he_dev->irq_base, he_dev->irq_phys); | 1565 | * sizeof(struct he_irq), he_dev->irq_base, he_dev->irq_phys); |
1563 | 1566 | ||
1564 | if (he_dev->hsp) | 1567 | if (he_dev->hsp) |
1565 | pci_free_consistent(he_dev->pci_dev, sizeof(struct he_hsp), | 1568 | dma_free_coherent(&he_dev->pci_dev->dev, sizeof(struct he_hsp), |
1566 | he_dev->hsp, he_dev->hsp_phys); | 1569 | he_dev->hsp, he_dev->hsp_phys); |
1567 | 1570 | ||
1568 | if (he_dev->rbpl_base) { | 1571 | if (he_dev->rbpl_base) { |
1569 | list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) | 1572 | list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) |
1570 | pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); | 1573 | dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); |
1571 | 1574 | ||
1572 | pci_free_consistent(he_dev->pci_dev, CONFIG_RBPL_SIZE | 1575 | dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE |
1573 | * sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys); | 1576 | * sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys); |
1574 | } | 1577 | } |
1575 | 1578 | ||
1576 | kfree(he_dev->rbpl_virt); | 1579 | kfree(he_dev->rbpl_virt); |
1577 | kfree(he_dev->rbpl_table); | 1580 | kfree(he_dev->rbpl_table); |
1578 | 1581 | ||
1579 | if (he_dev->rbpl_pool) | 1582 | if (he_dev->rbpl_pool) |
1580 | pci_pool_destroy(he_dev->rbpl_pool); | 1583 | dma_pool_destroy(he_dev->rbpl_pool); |
1581 | 1584 | ||
1582 | if (he_dev->rbrq_base) | 1585 | if (he_dev->rbrq_base) |
1583 | pci_free_consistent(he_dev->pci_dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), | 1586 | dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), |
1584 | he_dev->rbrq_base, he_dev->rbrq_phys); | 1587 | he_dev->rbrq_base, he_dev->rbrq_phys); |
1585 | 1588 | ||
1586 | if (he_dev->tbrq_base) | 1589 | if (he_dev->tbrq_base) |
1587 | pci_free_consistent(he_dev->pci_dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), | 1590 | dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), |
1588 | he_dev->tbrq_base, he_dev->tbrq_phys); | 1591 | he_dev->tbrq_base, he_dev->tbrq_phys); |
1589 | 1592 | ||
1590 | if (he_dev->tpdrq_base) | 1593 | if (he_dev->tpdrq_base) |
1591 | pci_free_consistent(he_dev->pci_dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), | 1594 | dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), |
1592 | he_dev->tpdrq_base, he_dev->tpdrq_phys); | 1595 | he_dev->tpdrq_base, he_dev->tpdrq_phys); |
1593 | 1596 | ||
1594 | if (he_dev->tpd_pool) | 1597 | if (he_dev->tpd_pool) |
1595 | pci_pool_destroy(he_dev->tpd_pool); | 1598 | dma_pool_destroy(he_dev->tpd_pool); |
1596 | 1599 | ||
1597 | if (he_dev->pci_dev) { | 1600 | if (he_dev->pci_dev) { |
1598 | pci_read_config_word(he_dev->pci_dev, PCI_COMMAND, &command); | 1601 | pci_read_config_word(he_dev->pci_dev, PCI_COMMAND, &command); |
@@ -1610,7 +1613,7 @@ __alloc_tpd(struct he_dev *he_dev) | |||
1610 | struct he_tpd *tpd; | 1613 | struct he_tpd *tpd; |
1611 | dma_addr_t mapping; | 1614 | dma_addr_t mapping; |
1612 | 1615 | ||
1613 | tpd = pci_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC|GFP_DMA, &mapping); | 1616 | tpd = dma_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC, &mapping); |
1614 | if (tpd == NULL) | 1617 | if (tpd == NULL) |
1615 | return NULL; | 1618 | return NULL; |
1616 | 1619 | ||
@@ -1681,7 +1684,7 @@ he_service_rbrq(struct he_dev *he_dev, int group) | |||
1681 | if (!RBRQ_HBUF_ERR(he_dev->rbrq_head)) { | 1684 | if (!RBRQ_HBUF_ERR(he_dev->rbrq_head)) { |
1682 | clear_bit(i, he_dev->rbpl_table); | 1685 | clear_bit(i, he_dev->rbpl_table); |
1683 | list_del(&heb->entry); | 1686 | list_del(&heb->entry); |
1684 | pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); | 1687 | dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); |
1685 | } | 1688 | } |
1686 | 1689 | ||
1687 | goto next_rbrq_entry; | 1690 | goto next_rbrq_entry; |
@@ -1774,7 +1777,7 @@ return_host_buffers: | |||
1774 | ++pdus_assembled; | 1777 | ++pdus_assembled; |
1775 | 1778 | ||
1776 | list_for_each_entry_safe(heb, next, &he_vcc->buffers, entry) | 1779 | list_for_each_entry_safe(heb, next, &he_vcc->buffers, entry) |
1777 | pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); | 1780 | dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); |
1778 | INIT_LIST_HEAD(&he_vcc->buffers); | 1781 | INIT_LIST_HEAD(&he_vcc->buffers); |
1779 | he_vcc->pdu_len = 0; | 1782 | he_vcc->pdu_len = 0; |
1780 | 1783 | ||
@@ -1843,10 +1846,10 @@ he_service_tbrq(struct he_dev *he_dev, int group) | |||
1843 | 1846 | ||
1844 | for (slot = 0; slot < TPD_MAXIOV; ++slot) { | 1847 | for (slot = 0; slot < TPD_MAXIOV; ++slot) { |
1845 | if (tpd->iovec[slot].addr) | 1848 | if (tpd->iovec[slot].addr) |
1846 | pci_unmap_single(he_dev->pci_dev, | 1849 | dma_unmap_single(&he_dev->pci_dev->dev, |
1847 | tpd->iovec[slot].addr, | 1850 | tpd->iovec[slot].addr, |
1848 | tpd->iovec[slot].len & TPD_LEN_MASK, | 1851 | tpd->iovec[slot].len & TPD_LEN_MASK, |
1849 | PCI_DMA_TODEVICE); | 1852 | DMA_TO_DEVICE); |
1850 | if (tpd->iovec[slot].len & TPD_LST) | 1853 | if (tpd->iovec[slot].len & TPD_LST) |
1851 | break; | 1854 | break; |
1852 | 1855 | ||
@@ -1861,7 +1864,7 @@ he_service_tbrq(struct he_dev *he_dev, int group) | |||
1861 | 1864 | ||
1862 | next_tbrq_entry: | 1865 | next_tbrq_entry: |
1863 | if (tpd) | 1866 | if (tpd) |
1864 | pci_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); | 1867 | dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); |
1865 | he_dev->tbrq_head = (struct he_tbrq *) | 1868 | he_dev->tbrq_head = (struct he_tbrq *) |
1866 | ((unsigned long) he_dev->tbrq_base | | 1869 | ((unsigned long) he_dev->tbrq_base | |
1867 | TBRQ_MASK(he_dev->tbrq_head + 1)); | 1870 | TBRQ_MASK(he_dev->tbrq_head + 1)); |
@@ -1905,7 +1908,7 @@ he_service_rbpl(struct he_dev *he_dev, int group) | |||
1905 | } | 1908 | } |
1906 | he_dev->rbpl_hint = i + 1; | 1909 | he_dev->rbpl_hint = i + 1; |
1907 | 1910 | ||
1908 | heb = pci_pool_alloc(he_dev->rbpl_pool, GFP_ATOMIC|GFP_DMA, &mapping); | 1911 | heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_ATOMIC, &mapping); |
1909 | if (!heb) | 1912 | if (!heb) |
1910 | break; | 1913 | break; |
1911 | heb->mapping = mapping; | 1914 | heb->mapping = mapping; |
@@ -2084,10 +2087,10 @@ __enqueue_tpd(struct he_dev *he_dev, struct he_tpd *tpd, unsigned cid) | |||
2084 | */ | 2087 | */ |
2085 | for (slot = 0; slot < TPD_MAXIOV; ++slot) { | 2088 | for (slot = 0; slot < TPD_MAXIOV; ++slot) { |
2086 | if (tpd->iovec[slot].addr) | 2089 | if (tpd->iovec[slot].addr) |
2087 | pci_unmap_single(he_dev->pci_dev, | 2090 | dma_unmap_single(&he_dev->pci_dev->dev, |
2088 | tpd->iovec[slot].addr, | 2091 | tpd->iovec[slot].addr, |
2089 | tpd->iovec[slot].len & TPD_LEN_MASK, | 2092 | tpd->iovec[slot].len & TPD_LEN_MASK, |
2090 | PCI_DMA_TODEVICE); | 2093 | DMA_TO_DEVICE); |
2091 | } | 2094 | } |
2092 | if (tpd->skb) { | 2095 | if (tpd->skb) { |
2093 | if (tpd->vcc->pop) | 2096 | if (tpd->vcc->pop) |
@@ -2096,7 +2099,7 @@ __enqueue_tpd(struct he_dev *he_dev, struct he_tpd *tpd, unsigned cid) | |||
2096 | dev_kfree_skb_any(tpd->skb); | 2099 | dev_kfree_skb_any(tpd->skb); |
2097 | atomic_inc(&tpd->vcc->stats->tx_err); | 2100 | atomic_inc(&tpd->vcc->stats->tx_err); |
2098 | } | 2101 | } |
2099 | pci_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); | 2102 | dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); |
2100 | return; | 2103 | return; |
2101 | } | 2104 | } |
2102 | } | 2105 | } |
@@ -2550,8 +2553,8 @@ he_send(struct atm_vcc *vcc, struct sk_buff *skb) | |||
2550 | } | 2553 | } |
2551 | 2554 | ||
2552 | #ifdef USE_SCATTERGATHER | 2555 | #ifdef USE_SCATTERGATHER |
2553 | tpd->iovec[slot].addr = pci_map_single(he_dev->pci_dev, skb->data, | 2556 | tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, skb->data, |
2554 | skb_headlen(skb), PCI_DMA_TODEVICE); | 2557 | skb_headlen(skb), DMA_TO_DEVICE); |
2555 | tpd->iovec[slot].len = skb_headlen(skb); | 2558 | tpd->iovec[slot].len = skb_headlen(skb); |
2556 | ++slot; | 2559 | ++slot; |
2557 | 2560 | ||
@@ -2579,9 +2582,9 @@ he_send(struct atm_vcc *vcc, struct sk_buff *skb) | |||
2579 | slot = 0; | 2582 | slot = 0; |
2580 | } | 2583 | } |
2581 | 2584 | ||
2582 | tpd->iovec[slot].addr = pci_map_single(he_dev->pci_dev, | 2585 | tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, |
2583 | (void *) page_address(frag->page) + frag->page_offset, | 2586 | (void *) page_address(frag->page) + frag->page_offset, |
2584 | frag->size, PCI_DMA_TODEVICE); | 2587 | frag->size, DMA_TO_DEVICE); |
2585 | tpd->iovec[slot].len = frag->size; | 2588 | tpd->iovec[slot].len = frag->size; |
2586 | ++slot; | 2589 | ++slot; |
2587 | 2590 | ||
@@ -2589,7 +2592,7 @@ he_send(struct atm_vcc *vcc, struct sk_buff *skb) | |||
2589 | 2592 | ||
2590 | tpd->iovec[slot - 1].len |= TPD_LST; | 2593 | tpd->iovec[slot - 1].len |= TPD_LST; |
2591 | #else | 2594 | #else |
2592 | tpd->address0 = pci_map_single(he_dev->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE); | 2595 | tpd->address0 = dma_map_single(&he_dev->pci_dev->dev, skb->data, skb->len, DMA_TO_DEVICE); |
2593 | tpd->length0 = skb->len | TPD_LST; | 2596 | tpd->length0 = skb->len | TPD_LST; |
2594 | #endif | 2597 | #endif |
2595 | tpd->status |= TPD_INT; | 2598 | tpd->status |= TPD_INT; |
diff --git a/drivers/atm/he.h b/drivers/atm/he.h index 110a27d2ecfc..f3f53674ef3f 100644 --- a/drivers/atm/he.h +++ b/drivers/atm/he.h | |||
@@ -281,7 +281,7 @@ struct he_dev { | |||
281 | int irq_peak; | 281 | int irq_peak; |
282 | 282 | ||
283 | struct tasklet_struct tasklet; | 283 | struct tasklet_struct tasklet; |
284 | struct pci_pool *tpd_pool; | 284 | struct dma_pool *tpd_pool; |
285 | struct list_head outstanding_tpds; | 285 | struct list_head outstanding_tpds; |
286 | 286 | ||
287 | dma_addr_t tpdrq_phys; | 287 | dma_addr_t tpdrq_phys; |
@@ -296,7 +296,7 @@ struct he_dev { | |||
296 | struct he_buff **rbpl_virt; | 296 | struct he_buff **rbpl_virt; |
297 | unsigned long *rbpl_table; | 297 | unsigned long *rbpl_table; |
298 | unsigned long rbpl_hint; | 298 | unsigned long rbpl_hint; |
299 | struct pci_pool *rbpl_pool; | 299 | struct dma_pool *rbpl_pool; |
300 | dma_addr_t rbpl_phys; | 300 | dma_addr_t rbpl_phys; |
301 | struct he_rbp *rbpl_base, *rbpl_tail; | 301 | struct he_rbp *rbpl_base, *rbpl_tail; |
302 | struct list_head rbpl_outstanding; | 302 | struct list_head rbpl_outstanding; |
diff --git a/drivers/atm/idt77252.c b/drivers/atm/idt77252.c index 2b24ed056728..074616b39f4d 100644 --- a/drivers/atm/idt77252.c +++ b/drivers/atm/idt77252.c | |||
@@ -641,7 +641,8 @@ alloc_scq(struct idt77252_dev *card, int class) | |||
641 | scq = kzalloc(sizeof(struct scq_info), GFP_KERNEL); | 641 | scq = kzalloc(sizeof(struct scq_info), GFP_KERNEL); |
642 | if (!scq) | 642 | if (!scq) |
643 | return NULL; | 643 | return NULL; |
644 | scq->base = pci_zalloc_consistent(card->pcidev, SCQ_SIZE, &scq->paddr); | 644 | scq->base = dma_zalloc_coherent(&card->pcidev->dev, SCQ_SIZE, |
645 | &scq->paddr, GFP_KERNEL); | ||
645 | if (scq->base == NULL) { | 646 | if (scq->base == NULL) { |
646 | kfree(scq); | 647 | kfree(scq); |
647 | return NULL; | 648 | return NULL; |
@@ -669,12 +670,12 @@ free_scq(struct idt77252_dev *card, struct scq_info *scq) | |||
669 | struct sk_buff *skb; | 670 | struct sk_buff *skb; |
670 | struct atm_vcc *vcc; | 671 | struct atm_vcc *vcc; |
671 | 672 | ||
672 | pci_free_consistent(card->pcidev, SCQ_SIZE, | 673 | dma_free_coherent(&card->pcidev->dev, SCQ_SIZE, |
673 | scq->base, scq->paddr); | 674 | scq->base, scq->paddr); |
674 | 675 | ||
675 | while ((skb = skb_dequeue(&scq->transmit))) { | 676 | while ((skb = skb_dequeue(&scq->transmit))) { |
676 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 677 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
677 | skb->len, PCI_DMA_TODEVICE); | 678 | skb->len, DMA_TO_DEVICE); |
678 | 679 | ||
679 | vcc = ATM_SKB(skb)->vcc; | 680 | vcc = ATM_SKB(skb)->vcc; |
680 | if (vcc->pop) | 681 | if (vcc->pop) |
@@ -684,8 +685,8 @@ free_scq(struct idt77252_dev *card, struct scq_info *scq) | |||
684 | } | 685 | } |
685 | 686 | ||
686 | while ((skb = skb_dequeue(&scq->pending))) { | 687 | while ((skb = skb_dequeue(&scq->pending))) { |
687 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 688 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
688 | skb->len, PCI_DMA_TODEVICE); | 689 | skb->len, DMA_TO_DEVICE); |
689 | 690 | ||
690 | vcc = ATM_SKB(skb)->vcc; | 691 | vcc = ATM_SKB(skb)->vcc; |
691 | if (vcc->pop) | 692 | if (vcc->pop) |
@@ -800,8 +801,8 @@ drain_scq(struct idt77252_dev *card, struct vc_map *vc) | |||
800 | if (skb) { | 801 | if (skb) { |
801 | TXPRINTK("%s: freeing skb at %p.\n", card->name, skb); | 802 | TXPRINTK("%s: freeing skb at %p.\n", card->name, skb); |
802 | 803 | ||
803 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 804 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
804 | skb->len, PCI_DMA_TODEVICE); | 805 | skb->len, DMA_TO_DEVICE); |
805 | 806 | ||
806 | vcc = ATM_SKB(skb)->vcc; | 807 | vcc = ATM_SKB(skb)->vcc; |
807 | 808 | ||
@@ -846,8 +847,8 @@ queue_skb(struct idt77252_dev *card, struct vc_map *vc, | |||
846 | tbd = &IDT77252_PRV_TBD(skb); | 847 | tbd = &IDT77252_PRV_TBD(skb); |
847 | vcc = ATM_SKB(skb)->vcc; | 848 | vcc = ATM_SKB(skb)->vcc; |
848 | 849 | ||
849 | IDT77252_PRV_PADDR(skb) = pci_map_single(card->pcidev, skb->data, | 850 | IDT77252_PRV_PADDR(skb) = dma_map_single(&card->pcidev->dev, skb->data, |
850 | skb->len, PCI_DMA_TODEVICE); | 851 | skb->len, DMA_TO_DEVICE); |
851 | 852 | ||
852 | error = -EINVAL; | 853 | error = -EINVAL; |
853 | 854 | ||
@@ -924,8 +925,8 @@ done: | |||
924 | return 0; | 925 | return 0; |
925 | 926 | ||
926 | errout: | 927 | errout: |
927 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 928 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
928 | skb->len, PCI_DMA_TODEVICE); | 929 | skb->len, DMA_TO_DEVICE); |
929 | return error; | 930 | return error; |
930 | } | 931 | } |
931 | 932 | ||
@@ -970,8 +971,8 @@ init_rsq(struct idt77252_dev *card) | |||
970 | { | 971 | { |
971 | struct rsq_entry *rsqe; | 972 | struct rsq_entry *rsqe; |
972 | 973 | ||
973 | card->rsq.base = pci_zalloc_consistent(card->pcidev, RSQSIZE, | 974 | card->rsq.base = dma_zalloc_coherent(&card->pcidev->dev, RSQSIZE, |
974 | &card->rsq.paddr); | 975 | &card->rsq.paddr, GFP_KERNEL); |
975 | if (card->rsq.base == NULL) { | 976 | if (card->rsq.base == NULL) { |
976 | printk("%s: can't allocate RSQ.\n", card->name); | 977 | printk("%s: can't allocate RSQ.\n", card->name); |
977 | return -1; | 978 | return -1; |
@@ -1001,8 +1002,8 @@ init_rsq(struct idt77252_dev *card) | |||
1001 | static void | 1002 | static void |
1002 | deinit_rsq(struct idt77252_dev *card) | 1003 | deinit_rsq(struct idt77252_dev *card) |
1003 | { | 1004 | { |
1004 | pci_free_consistent(card->pcidev, RSQSIZE, | 1005 | dma_free_coherent(&card->pcidev->dev, RSQSIZE, |
1005 | card->rsq.base, card->rsq.paddr); | 1006 | card->rsq.base, card->rsq.paddr); |
1006 | } | 1007 | } |
1007 | 1008 | ||
1008 | static void | 1009 | static void |
@@ -1057,9 +1058,9 @@ dequeue_rx(struct idt77252_dev *card, struct rsq_entry *rsqe) | |||
1057 | 1058 | ||
1058 | vcc = vc->rx_vcc; | 1059 | vcc = vc->rx_vcc; |
1059 | 1060 | ||
1060 | pci_dma_sync_single_for_cpu(card->pcidev, IDT77252_PRV_PADDR(skb), | 1061 | dma_sync_single_for_cpu(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
1061 | skb_end_pointer(skb) - skb->data, | 1062 | skb_end_pointer(skb) - skb->data, |
1062 | PCI_DMA_FROMDEVICE); | 1063 | DMA_FROM_DEVICE); |
1063 | 1064 | ||
1064 | if ((vcc->qos.aal == ATM_AAL0) || | 1065 | if ((vcc->qos.aal == ATM_AAL0) || |
1065 | (vcc->qos.aal == ATM_AAL34)) { | 1066 | (vcc->qos.aal == ATM_AAL34)) { |
@@ -1180,9 +1181,9 @@ dequeue_rx(struct idt77252_dev *card, struct rsq_entry *rsqe) | |||
1180 | return; | 1181 | return; |
1181 | } | 1182 | } |
1182 | 1183 | ||
1183 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 1184 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
1184 | skb_end_pointer(skb) - skb->data, | 1185 | skb_end_pointer(skb) - skb->data, |
1185 | PCI_DMA_FROMDEVICE); | 1186 | DMA_FROM_DEVICE); |
1186 | sb_pool_remove(card, skb); | 1187 | sb_pool_remove(card, skb); |
1187 | 1188 | ||
1188 | skb_trim(skb, len); | 1189 | skb_trim(skb, len); |
@@ -1254,9 +1255,9 @@ idt77252_rx_raw(struct idt77252_dev *card) | |||
1254 | head = IDT77252_PRV_PADDR(queue) + (queue->data - queue->head - 16); | 1255 | head = IDT77252_PRV_PADDR(queue) + (queue->data - queue->head - 16); |
1255 | tail = readl(SAR_REG_RAWCT); | 1256 | tail = readl(SAR_REG_RAWCT); |
1256 | 1257 | ||
1257 | pci_dma_sync_single_for_cpu(card->pcidev, IDT77252_PRV_PADDR(queue), | 1258 | dma_sync_single_for_cpu(&card->pcidev->dev, IDT77252_PRV_PADDR(queue), |
1258 | skb_end_offset(queue) - 16, | 1259 | skb_end_offset(queue) - 16, |
1259 | PCI_DMA_FROMDEVICE); | 1260 | DMA_FROM_DEVICE); |
1260 | 1261 | ||
1261 | while (head != tail) { | 1262 | while (head != tail) { |
1262 | unsigned int vpi, vci; | 1263 | unsigned int vpi, vci; |
@@ -1348,11 +1349,11 @@ drop: | |||
1348 | if (next) { | 1349 | if (next) { |
1349 | card->raw_cell_head = next; | 1350 | card->raw_cell_head = next; |
1350 | queue = card->raw_cell_head; | 1351 | queue = card->raw_cell_head; |
1351 | pci_dma_sync_single_for_cpu(card->pcidev, | 1352 | dma_sync_single_for_cpu(&card->pcidev->dev, |
1352 | IDT77252_PRV_PADDR(queue), | 1353 | IDT77252_PRV_PADDR(queue), |
1353 | (skb_end_pointer(queue) - | 1354 | (skb_end_pointer(queue) - |
1354 | queue->data), | 1355 | queue->data), |
1355 | PCI_DMA_FROMDEVICE); | 1356 | DMA_FROM_DEVICE); |
1356 | } else { | 1357 | } else { |
1357 | card->raw_cell_head = NULL; | 1358 | card->raw_cell_head = NULL; |
1358 | printk("%s: raw cell queue overrun\n", | 1359 | printk("%s: raw cell queue overrun\n", |
@@ -1375,8 +1376,8 @@ init_tsq(struct idt77252_dev *card) | |||
1375 | { | 1376 | { |
1376 | struct tsq_entry *tsqe; | 1377 | struct tsq_entry *tsqe; |
1377 | 1378 | ||
1378 | card->tsq.base = pci_alloc_consistent(card->pcidev, RSQSIZE, | 1379 | card->tsq.base = dma_alloc_coherent(&card->pcidev->dev, RSQSIZE, |
1379 | &card->tsq.paddr); | 1380 | &card->tsq.paddr, GFP_KERNEL); |
1380 | if (card->tsq.base == NULL) { | 1381 | if (card->tsq.base == NULL) { |
1381 | printk("%s: can't allocate TSQ.\n", card->name); | 1382 | printk("%s: can't allocate TSQ.\n", card->name); |
1382 | return -1; | 1383 | return -1; |
@@ -1398,8 +1399,8 @@ init_tsq(struct idt77252_dev *card) | |||
1398 | static void | 1399 | static void |
1399 | deinit_tsq(struct idt77252_dev *card) | 1400 | deinit_tsq(struct idt77252_dev *card) |
1400 | { | 1401 | { |
1401 | pci_free_consistent(card->pcidev, TSQSIZE, | 1402 | dma_free_coherent(&card->pcidev->dev, TSQSIZE, |
1402 | card->tsq.base, card->tsq.paddr); | 1403 | card->tsq.base, card->tsq.paddr); |
1403 | } | 1404 | } |
1404 | 1405 | ||
1405 | static void | 1406 | static void |
@@ -1861,9 +1862,9 @@ add_rx_skb(struct idt77252_dev *card, int queue, | |||
1861 | goto outfree; | 1862 | goto outfree; |
1862 | } | 1863 | } |
1863 | 1864 | ||
1864 | paddr = pci_map_single(card->pcidev, skb->data, | 1865 | paddr = dma_map_single(&card->pcidev->dev, skb->data, |
1865 | skb_end_pointer(skb) - skb->data, | 1866 | skb_end_pointer(skb) - skb->data, |
1866 | PCI_DMA_FROMDEVICE); | 1867 | DMA_FROM_DEVICE); |
1867 | IDT77252_PRV_PADDR(skb) = paddr; | 1868 | IDT77252_PRV_PADDR(skb) = paddr; |
1868 | 1869 | ||
1869 | if (push_rx_skb(card, skb, queue)) { | 1870 | if (push_rx_skb(card, skb, queue)) { |
@@ -1875,8 +1876,8 @@ add_rx_skb(struct idt77252_dev *card, int queue, | |||
1875 | return; | 1876 | return; |
1876 | 1877 | ||
1877 | outunmap: | 1878 | outunmap: |
1878 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 1879 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
1879 | skb_end_pointer(skb) - skb->data, PCI_DMA_FROMDEVICE); | 1880 | skb_end_pointer(skb) - skb->data, DMA_FROM_DEVICE); |
1880 | 1881 | ||
1881 | handle = IDT77252_PRV_POOL(skb); | 1882 | handle = IDT77252_PRV_POOL(skb); |
1882 | card->sbpool[POOL_QUEUE(handle)].skb[POOL_INDEX(handle)] = NULL; | 1883 | card->sbpool[POOL_QUEUE(handle)].skb[POOL_INDEX(handle)] = NULL; |
@@ -1892,15 +1893,15 @@ recycle_rx_skb(struct idt77252_dev *card, struct sk_buff *skb) | |||
1892 | u32 handle = IDT77252_PRV_POOL(skb); | 1893 | u32 handle = IDT77252_PRV_POOL(skb); |
1893 | int err; | 1894 | int err; |
1894 | 1895 | ||
1895 | pci_dma_sync_single_for_device(card->pcidev, IDT77252_PRV_PADDR(skb), | 1896 | dma_sync_single_for_device(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
1896 | skb_end_pointer(skb) - skb->data, | 1897 | skb_end_pointer(skb) - skb->data, |
1897 | PCI_DMA_FROMDEVICE); | 1898 | DMA_FROM_DEVICE); |
1898 | 1899 | ||
1899 | err = push_rx_skb(card, skb, POOL_QUEUE(handle)); | 1900 | err = push_rx_skb(card, skb, POOL_QUEUE(handle)); |
1900 | if (err) { | 1901 | if (err) { |
1901 | pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), | 1902 | dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), |
1902 | skb_end_pointer(skb) - skb->data, | 1903 | skb_end_pointer(skb) - skb->data, |
1903 | PCI_DMA_FROMDEVICE); | 1904 | DMA_FROM_DEVICE); |
1904 | sb_pool_remove(card, skb); | 1905 | sb_pool_remove(card, skb); |
1905 | dev_kfree_skb(skb); | 1906 | dev_kfree_skb(skb); |
1906 | } | 1907 | } |
@@ -3058,11 +3059,11 @@ deinit_card(struct idt77252_dev *card) | |||
3058 | for (j = 0; j < FBQ_SIZE; j++) { | 3059 | for (j = 0; j < FBQ_SIZE; j++) { |
3059 | skb = card->sbpool[i].skb[j]; | 3060 | skb = card->sbpool[i].skb[j]; |
3060 | if (skb) { | 3061 | if (skb) { |
3061 | pci_unmap_single(card->pcidev, | 3062 | dma_unmap_single(&card->pcidev->dev, |
3062 | IDT77252_PRV_PADDR(skb), | 3063 | IDT77252_PRV_PADDR(skb), |
3063 | (skb_end_pointer(skb) - | 3064 | (skb_end_pointer(skb) - |
3064 | skb->data), | 3065 | skb->data), |
3065 | PCI_DMA_FROMDEVICE); | 3066 | DMA_FROM_DEVICE); |
3066 | card->sbpool[i].skb[j] = NULL; | 3067 | card->sbpool[i].skb[j] = NULL; |
3067 | dev_kfree_skb(skb); | 3068 | dev_kfree_skb(skb); |
3068 | } | 3069 | } |
@@ -3076,8 +3077,8 @@ deinit_card(struct idt77252_dev *card) | |||
3076 | vfree(card->vcs); | 3077 | vfree(card->vcs); |
3077 | 3078 | ||
3078 | if (card->raw_cell_hnd) { | 3079 | if (card->raw_cell_hnd) { |
3079 | pci_free_consistent(card->pcidev, 2 * sizeof(u32), | 3080 | dma_free_coherent(&card->pcidev->dev, 2 * sizeof(u32), |
3080 | card->raw_cell_hnd, card->raw_cell_paddr); | 3081 | card->raw_cell_hnd, card->raw_cell_paddr); |
3081 | } | 3082 | } |
3082 | 3083 | ||
3083 | if (card->rsq.base) { | 3084 | if (card->rsq.base) { |
@@ -3397,9 +3398,10 @@ static int init_card(struct atm_dev *dev) | |||
3397 | writel(0, SAR_REG_GP); | 3398 | writel(0, SAR_REG_GP); |
3398 | 3399 | ||
3399 | /* Initialize RAW Cell Handle Register */ | 3400 | /* Initialize RAW Cell Handle Register */ |
3400 | card->raw_cell_hnd = pci_zalloc_consistent(card->pcidev, | 3401 | card->raw_cell_hnd = dma_zalloc_coherent(&card->pcidev->dev, |
3401 | 2 * sizeof(u32), | 3402 | 2 * sizeof(u32), |
3402 | &card->raw_cell_paddr); | 3403 | &card->raw_cell_paddr, |
3404 | GFP_KERNEL); | ||
3403 | if (!card->raw_cell_hnd) { | 3405 | if (!card->raw_cell_hnd) { |
3404 | printk("%s: memory allocation failure.\n", card->name); | 3406 | printk("%s: memory allocation failure.\n", card->name); |
3405 | deinit_card(card); | 3407 | deinit_card(card); |
@@ -3611,6 +3613,11 @@ static int idt77252_init_one(struct pci_dev *pcidev, | |||
3611 | return err; | 3613 | return err; |
3612 | } | 3614 | } |
3613 | 3615 | ||
3616 | if ((err = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32)))) { | ||
3617 | printk("idt77252: can't enable DMA for PCI device at %s\n", pci_name(pcidev)); | ||
3618 | return err; | ||
3619 | } | ||
3620 | |||
3614 | card = kzalloc(sizeof(struct idt77252_dev), GFP_KERNEL); | 3621 | card = kzalloc(sizeof(struct idt77252_dev), GFP_KERNEL); |
3615 | if (!card) { | 3622 | if (!card) { |
3616 | printk("idt77252-%d: can't allocate private data\n", index); | 3623 | printk("idt77252-%d: can't allocate private data\n", index); |
diff --git a/drivers/atm/iphase.c b/drivers/atm/iphase.c index 4217f29a85e0..924f8e26789d 100644 --- a/drivers/atm/iphase.c +++ b/drivers/atm/iphase.c | |||
@@ -1185,8 +1185,8 @@ static int rx_pkt(struct atm_dev *dev) | |||
1185 | 1185 | ||
1186 | /* Build the DLE structure */ | 1186 | /* Build the DLE structure */ |
1187 | wr_ptr = iadev->rx_dle_q.write; | 1187 | wr_ptr = iadev->rx_dle_q.write; |
1188 | wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data, | 1188 | wr_ptr->sys_pkt_addr = dma_map_single(&iadev->pci->dev, skb->data, |
1189 | len, PCI_DMA_FROMDEVICE); | 1189 | len, DMA_FROM_DEVICE); |
1190 | wr_ptr->local_pkt_addr = buf_addr; | 1190 | wr_ptr->local_pkt_addr = buf_addr; |
1191 | wr_ptr->bytes = len; /* We don't know this do we ?? */ | 1191 | wr_ptr->bytes = len; /* We don't know this do we ?? */ |
1192 | wr_ptr->mode = DMA_INT_ENABLE; | 1192 | wr_ptr->mode = DMA_INT_ENABLE; |
@@ -1306,8 +1306,8 @@ static void rx_dle_intr(struct atm_dev *dev) | |||
1306 | u_short length; | 1306 | u_short length; |
1307 | struct ia_vcc *ia_vcc; | 1307 | struct ia_vcc *ia_vcc; |
1308 | 1308 | ||
1309 | pci_unmap_single(iadev->pci, iadev->rx_dle_q.write->sys_pkt_addr, | 1309 | dma_unmap_single(&iadev->pci->dev, iadev->rx_dle_q.write->sys_pkt_addr, |
1310 | len, PCI_DMA_FROMDEVICE); | 1310 | len, DMA_FROM_DEVICE); |
1311 | /* no VCC related housekeeping done as yet. lets see */ | 1311 | /* no VCC related housekeeping done as yet. lets see */ |
1312 | vcc = ATM_SKB(skb)->vcc; | 1312 | vcc = ATM_SKB(skb)->vcc; |
1313 | if (!vcc) { | 1313 | if (!vcc) { |
@@ -1430,8 +1430,8 @@ static int rx_init(struct atm_dev *dev) | |||
1430 | // spin_lock_init(&iadev->rx_lock); | 1430 | // spin_lock_init(&iadev->rx_lock); |
1431 | 1431 | ||
1432 | /* Allocate 4k bytes - more aligned than needed (4k boundary) */ | 1432 | /* Allocate 4k bytes - more aligned than needed (4k boundary) */ |
1433 | dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE, | 1433 | dle_addr = dma_alloc_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, |
1434 | &iadev->rx_dle_dma); | 1434 | &iadev->rx_dle_dma, GFP_KERNEL); |
1435 | if (!dle_addr) { | 1435 | if (!dle_addr) { |
1436 | printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); | 1436 | printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); |
1437 | goto err_out; | 1437 | goto err_out; |
@@ -1631,8 +1631,8 @@ static int rx_init(struct atm_dev *dev) | |||
1631 | return 0; | 1631 | return 0; |
1632 | 1632 | ||
1633 | err_free_dle: | 1633 | err_free_dle: |
1634 | pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, | 1634 | dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, |
1635 | iadev->rx_dle_dma); | 1635 | iadev->rx_dle_dma); |
1636 | err_out: | 1636 | err_out: |
1637 | return -ENOMEM; | 1637 | return -ENOMEM; |
1638 | } | 1638 | } |
@@ -1702,8 +1702,8 @@ static void tx_dle_intr(struct atm_dev *dev) | |||
1702 | 1702 | ||
1703 | /* Revenge of the 2 dle (skb + trailer) used in ia_pkt_tx() */ | 1703 | /* Revenge of the 2 dle (skb + trailer) used in ia_pkt_tx() */ |
1704 | if (!((dle - iadev->tx_dle_q.start)%(2*sizeof(struct dle)))) { | 1704 | if (!((dle - iadev->tx_dle_q.start)%(2*sizeof(struct dle)))) { |
1705 | pci_unmap_single(iadev->pci, dle->sys_pkt_addr, skb->len, | 1705 | dma_unmap_single(&iadev->pci->dev, dle->sys_pkt_addr, skb->len, |
1706 | PCI_DMA_TODEVICE); | 1706 | DMA_TO_DEVICE); |
1707 | } | 1707 | } |
1708 | vcc = ATM_SKB(skb)->vcc; | 1708 | vcc = ATM_SKB(skb)->vcc; |
1709 | if (!vcc) { | 1709 | if (!vcc) { |
@@ -1917,8 +1917,8 @@ static int tx_init(struct atm_dev *dev) | |||
1917 | readw(iadev->seg_reg+SEG_MASK_REG));) | 1917 | readw(iadev->seg_reg+SEG_MASK_REG));) |
1918 | 1918 | ||
1919 | /* Allocate 4k (boundary aligned) bytes */ | 1919 | /* Allocate 4k (boundary aligned) bytes */ |
1920 | dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE, | 1920 | dle_addr = dma_alloc_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, |
1921 | &iadev->tx_dle_dma); | 1921 | &iadev->tx_dle_dma, GFP_KERNEL); |
1922 | if (!dle_addr) { | 1922 | if (!dle_addr) { |
1923 | printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); | 1923 | printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); |
1924 | goto err_out; | 1924 | goto err_out; |
@@ -1989,8 +1989,10 @@ static int tx_init(struct atm_dev *dev) | |||
1989 | goto err_free_tx_bufs; | 1989 | goto err_free_tx_bufs; |
1990 | } | 1990 | } |
1991 | iadev->tx_buf[i].cpcs = cpcs; | 1991 | iadev->tx_buf[i].cpcs = cpcs; |
1992 | iadev->tx_buf[i].dma_addr = pci_map_single(iadev->pci, | 1992 | iadev->tx_buf[i].dma_addr = dma_map_single(&iadev->pci->dev, |
1993 | cpcs, sizeof(*cpcs), PCI_DMA_TODEVICE); | 1993 | cpcs, |
1994 | sizeof(*cpcs), | ||
1995 | DMA_TO_DEVICE); | ||
1994 | } | 1996 | } |
1995 | iadev->desc_tbl = kmalloc(iadev->num_tx_desc * | 1997 | iadev->desc_tbl = kmalloc(iadev->num_tx_desc * |
1996 | sizeof(struct desc_tbl_t), GFP_KERNEL); | 1998 | sizeof(struct desc_tbl_t), GFP_KERNEL); |
@@ -2198,14 +2200,14 @@ err_free_tx_bufs: | |||
2198 | while (--i >= 0) { | 2200 | while (--i >= 0) { |
2199 | struct cpcs_trailer_desc *desc = iadev->tx_buf + i; | 2201 | struct cpcs_trailer_desc *desc = iadev->tx_buf + i; |
2200 | 2202 | ||
2201 | pci_unmap_single(iadev->pci, desc->dma_addr, | 2203 | dma_unmap_single(&iadev->pci->dev, desc->dma_addr, |
2202 | sizeof(*desc->cpcs), PCI_DMA_TODEVICE); | 2204 | sizeof(*desc->cpcs), DMA_TO_DEVICE); |
2203 | kfree(desc->cpcs); | 2205 | kfree(desc->cpcs); |
2204 | } | 2206 | } |
2205 | kfree(iadev->tx_buf); | 2207 | kfree(iadev->tx_buf); |
2206 | err_free_dle: | 2208 | err_free_dle: |
2207 | pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, | 2209 | dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, |
2208 | iadev->tx_dle_dma); | 2210 | iadev->tx_dle_dma); |
2209 | err_out: | 2211 | err_out: |
2210 | return -ENOMEM; | 2212 | return -ENOMEM; |
2211 | } | 2213 | } |
@@ -2476,20 +2478,20 @@ static void ia_free_tx(IADEV *iadev) | |||
2476 | for (i = 0; i < iadev->num_tx_desc; i++) { | 2478 | for (i = 0; i < iadev->num_tx_desc; i++) { |
2477 | struct cpcs_trailer_desc *desc = iadev->tx_buf + i; | 2479 | struct cpcs_trailer_desc *desc = iadev->tx_buf + i; |
2478 | 2480 | ||
2479 | pci_unmap_single(iadev->pci, desc->dma_addr, | 2481 | dma_unmap_single(&iadev->pci->dev, desc->dma_addr, |
2480 | sizeof(*desc->cpcs), PCI_DMA_TODEVICE); | 2482 | sizeof(*desc->cpcs), DMA_TO_DEVICE); |
2481 | kfree(desc->cpcs); | 2483 | kfree(desc->cpcs); |
2482 | } | 2484 | } |
2483 | kfree(iadev->tx_buf); | 2485 | kfree(iadev->tx_buf); |
2484 | pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, | 2486 | dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, |
2485 | iadev->tx_dle_dma); | 2487 | iadev->tx_dle_dma); |
2486 | } | 2488 | } |
2487 | 2489 | ||
2488 | static void ia_free_rx(IADEV *iadev) | 2490 | static void ia_free_rx(IADEV *iadev) |
2489 | { | 2491 | { |
2490 | kfree(iadev->rx_open); | 2492 | kfree(iadev->rx_open); |
2491 | pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, | 2493 | dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, |
2492 | iadev->rx_dle_dma); | 2494 | iadev->rx_dle_dma); |
2493 | } | 2495 | } |
2494 | 2496 | ||
2495 | static int ia_start(struct atm_dev *dev) | 2497 | static int ia_start(struct atm_dev *dev) |
@@ -3009,8 +3011,8 @@ static int ia_pkt_tx (struct atm_vcc *vcc, struct sk_buff *skb) { | |||
3009 | /* Build the DLE structure */ | 3011 | /* Build the DLE structure */ |
3010 | wr_ptr = iadev->tx_dle_q.write; | 3012 | wr_ptr = iadev->tx_dle_q.write; |
3011 | memset((caddr_t)wr_ptr, 0, sizeof(*wr_ptr)); | 3013 | memset((caddr_t)wr_ptr, 0, sizeof(*wr_ptr)); |
3012 | wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data, | 3014 | wr_ptr->sys_pkt_addr = dma_map_single(&iadev->pci->dev, skb->data, |
3013 | skb->len, PCI_DMA_TODEVICE); | 3015 | skb->len, DMA_TO_DEVICE); |
3014 | wr_ptr->local_pkt_addr = (buf_desc_ptr->buf_start_hi << 16) | | 3016 | wr_ptr->local_pkt_addr = (buf_desc_ptr->buf_start_hi << 16) | |
3015 | buf_desc_ptr->buf_start_lo; | 3017 | buf_desc_ptr->buf_start_lo; |
3016 | /* wr_ptr->bytes = swap_byte_order(total_len); didn't seem to affect?? */ | 3018 | /* wr_ptr->bytes = swap_byte_order(total_len); didn't seem to affect?? */ |
diff --git a/drivers/atm/lanai.c b/drivers/atm/lanai.c index d2e9ea8d504e..ce43ae3e87b3 100644 --- a/drivers/atm/lanai.c +++ b/drivers/atm/lanai.c | |||
@@ -346,7 +346,8 @@ static void lanai_buf_allocate(struct lanai_buffer *buf, | |||
346 | * everything, but the way the lanai uses DMA memory would | 346 | * everything, but the way the lanai uses DMA memory would |
347 | * make that a terrific pain. This is much simpler. | 347 | * make that a terrific pain. This is much simpler. |
348 | */ | 348 | */ |
349 | buf->start = pci_alloc_consistent(pci, size, &buf->dmaaddr); | 349 | buf->start = dma_alloc_coherent(&pci->dev, |
350 | size, &buf->dmaaddr, GFP_KERNEL); | ||
350 | if (buf->start != NULL) { /* Success */ | 351 | if (buf->start != NULL) { /* Success */ |
351 | /* Lanai requires 256-byte alignment of DMA bufs */ | 352 | /* Lanai requires 256-byte alignment of DMA bufs */ |
352 | APRINTK((buf->dmaaddr & ~0xFFFFFF00) == 0, | 353 | APRINTK((buf->dmaaddr & ~0xFFFFFF00) == 0, |
@@ -372,8 +373,8 @@ static void lanai_buf_deallocate(struct lanai_buffer *buf, | |||
372 | struct pci_dev *pci) | 373 | struct pci_dev *pci) |
373 | { | 374 | { |
374 | if (buf->start != NULL) { | 375 | if (buf->start != NULL) { |
375 | pci_free_consistent(pci, lanai_buf_size(buf), | 376 | dma_free_coherent(&pci->dev, lanai_buf_size(buf), |
376 | buf->start, buf->dmaaddr); | 377 | buf->start, buf->dmaaddr); |
377 | buf->start = buf->end = buf->ptr = NULL; | 378 | buf->start = buf->end = buf->ptr = NULL; |
378 | } | 379 | } |
379 | } | 380 | } |
@@ -1944,12 +1945,7 @@ static int lanai_pci_start(struct lanai_dev *lanai) | |||
1944 | return -ENXIO; | 1945 | return -ENXIO; |
1945 | } | 1946 | } |
1946 | pci_set_master(pci); | 1947 | pci_set_master(pci); |
1947 | if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) != 0) { | 1948 | if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32)) != 0) { |
1948 | printk(KERN_WARNING DEV_LABEL | ||
1949 | "(itf %d): No suitable DMA available.\n", lanai->number); | ||
1950 | return -EBUSY; | ||
1951 | } | ||
1952 | if (pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) != 0) { | ||
1953 | printk(KERN_WARNING DEV_LABEL | 1949 | printk(KERN_WARNING DEV_LABEL |
1954 | "(itf %d): No suitable DMA available.\n", lanai->number); | 1950 | "(itf %d): No suitable DMA available.\n", lanai->number); |
1955 | return -EBUSY; | 1951 | return -EBUSY; |
diff --git a/drivers/atm/nicstar.c b/drivers/atm/nicstar.c index 9988ac98b6d8..b7e1cc0a97c8 100644 --- a/drivers/atm/nicstar.c +++ b/drivers/atm/nicstar.c | |||
@@ -252,10 +252,10 @@ static void nicstar_remove_one(struct pci_dev *pcidev) | |||
252 | free_scq(card, card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc); | 252 | free_scq(card, card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc); |
253 | } | 253 | } |
254 | idr_destroy(&card->idr); | 254 | idr_destroy(&card->idr); |
255 | pci_free_consistent(card->pcidev, NS_RSQSIZE + NS_RSQ_ALIGNMENT, | 255 | dma_free_coherent(&card->pcidev->dev, NS_RSQSIZE + NS_RSQ_ALIGNMENT, |
256 | card->rsq.org, card->rsq.dma); | 256 | card->rsq.org, card->rsq.dma); |
257 | pci_free_consistent(card->pcidev, NS_TSQSIZE + NS_TSQ_ALIGNMENT, | 257 | dma_free_coherent(&card->pcidev->dev, NS_TSQSIZE + NS_TSQ_ALIGNMENT, |
258 | card->tsq.org, card->tsq.dma); | 258 | card->tsq.org, card->tsq.dma); |
259 | free_irq(card->pcidev->irq, card); | 259 | free_irq(card->pcidev->irq, card); |
260 | iounmap(card->membase); | 260 | iounmap(card->membase); |
261 | kfree(card); | 261 | kfree(card); |
@@ -370,8 +370,7 @@ static int ns_init_card(int i, struct pci_dev *pcidev) | |||
370 | ns_init_card_error(card, error); | 370 | ns_init_card_error(card, error); |
371 | return error; | 371 | return error; |
372 | } | 372 | } |
373 | if ((pci_set_dma_mask(pcidev, DMA_BIT_MASK(32)) != 0) || | 373 | if (dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32)) != 0) { |
374 | (pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32)) != 0)) { | ||
375 | printk(KERN_WARNING | 374 | printk(KERN_WARNING |
376 | "nicstar%d: No suitable DMA available.\n", i); | 375 | "nicstar%d: No suitable DMA available.\n", i); |
377 | error = 2; | 376 | error = 2; |
@@ -535,9 +534,9 @@ static int ns_init_card(int i, struct pci_dev *pcidev) | |||
535 | writel(0x00000000, card->membase + VPM); | 534 | writel(0x00000000, card->membase + VPM); |
536 | 535 | ||
537 | /* Initialize TSQ */ | 536 | /* Initialize TSQ */ |
538 | card->tsq.org = pci_alloc_consistent(card->pcidev, | 537 | card->tsq.org = dma_alloc_coherent(&card->pcidev->dev, |
539 | NS_TSQSIZE + NS_TSQ_ALIGNMENT, | 538 | NS_TSQSIZE + NS_TSQ_ALIGNMENT, |
540 | &card->tsq.dma); | 539 | &card->tsq.dma, GFP_KERNEL); |
541 | if (card->tsq.org == NULL) { | 540 | if (card->tsq.org == NULL) { |
542 | printk("nicstar%d: can't allocate TSQ.\n", i); | 541 | printk("nicstar%d: can't allocate TSQ.\n", i); |
543 | error = 10; | 542 | error = 10; |
@@ -554,9 +553,9 @@ static int ns_init_card(int i, struct pci_dev *pcidev) | |||
554 | PRINTK("nicstar%d: TSQ base at 0x%p.\n", i, card->tsq.base); | 553 | PRINTK("nicstar%d: TSQ base at 0x%p.\n", i, card->tsq.base); |
555 | 554 | ||
556 | /* Initialize RSQ */ | 555 | /* Initialize RSQ */ |
557 | card->rsq.org = pci_alloc_consistent(card->pcidev, | 556 | card->rsq.org = dma_alloc_coherent(&card->pcidev->dev, |
558 | NS_RSQSIZE + NS_RSQ_ALIGNMENT, | 557 | NS_RSQSIZE + NS_RSQ_ALIGNMENT, |
559 | &card->rsq.dma); | 558 | &card->rsq.dma, GFP_KERNEL); |
560 | if (card->rsq.org == NULL) { | 559 | if (card->rsq.org == NULL) { |
561 | printk("nicstar%d: can't allocate RSQ.\n", i); | 560 | printk("nicstar%d: can't allocate RSQ.\n", i); |
562 | error = 11; | 561 | error = 11; |
@@ -874,7 +873,8 @@ static scq_info *get_scq(ns_dev *card, int size, u32 scd) | |||
874 | scq = kmalloc(sizeof(scq_info), GFP_KERNEL); | 873 | scq = kmalloc(sizeof(scq_info), GFP_KERNEL); |
875 | if (!scq) | 874 | if (!scq) |
876 | return NULL; | 875 | return NULL; |
877 | scq->org = pci_alloc_consistent(card->pcidev, 2 * size, &scq->dma); | 876 | scq->org = dma_alloc_coherent(&card->pcidev->dev, |
877 | 2 * size, &scq->dma, GFP_KERNEL); | ||
878 | if (!scq->org) { | 878 | if (!scq->org) { |
879 | kfree(scq); | 879 | kfree(scq); |
880 | return NULL; | 880 | return NULL; |
@@ -936,10 +936,10 @@ static void free_scq(ns_dev *card, scq_info *scq, struct atm_vcc *vcc) | |||
936 | } | 936 | } |
937 | } | 937 | } |
938 | kfree(scq->skb); | 938 | kfree(scq->skb); |
939 | pci_free_consistent(card->pcidev, | 939 | dma_free_coherent(&card->pcidev->dev, |
940 | 2 * (scq->num_entries == VBR_SCQ_NUM_ENTRIES ? | 940 | 2 * (scq->num_entries == VBR_SCQ_NUM_ENTRIES ? |
941 | VBR_SCQSIZE : CBR_SCQSIZE), | 941 | VBR_SCQSIZE : CBR_SCQSIZE), |
942 | scq->org, scq->dma); | 942 | scq->org, scq->dma); |
943 | kfree(scq); | 943 | kfree(scq); |
944 | } | 944 | } |
945 | 945 | ||
@@ -957,11 +957,11 @@ static void push_rxbufs(ns_dev * card, struct sk_buff *skb) | |||
957 | handle2 = NULL; | 957 | handle2 = NULL; |
958 | addr2 = 0; | 958 | addr2 = 0; |
959 | handle1 = skb; | 959 | handle1 = skb; |
960 | addr1 = pci_map_single(card->pcidev, | 960 | addr1 = dma_map_single(&card->pcidev->dev, |
961 | skb->data, | 961 | skb->data, |
962 | (NS_PRV_BUFTYPE(skb) == BUF_SM | 962 | (NS_PRV_BUFTYPE(skb) == BUF_SM |
963 | ? NS_SMSKBSIZE : NS_LGSKBSIZE), | 963 | ? NS_SMSKBSIZE : NS_LGSKBSIZE), |
964 | PCI_DMA_TODEVICE); | 964 | DMA_TO_DEVICE); |
965 | NS_PRV_DMA(skb) = addr1; /* save so we can unmap later */ | 965 | NS_PRV_DMA(skb) = addr1; /* save so we can unmap later */ |
966 | 966 | ||
967 | #ifdef GENERAL_DEBUG | 967 | #ifdef GENERAL_DEBUG |
@@ -1670,8 +1670,8 @@ static int ns_send(struct atm_vcc *vcc, struct sk_buff *skb) | |||
1670 | 1670 | ||
1671 | ATM_SKB(skb)->vcc = vcc; | 1671 | ATM_SKB(skb)->vcc = vcc; |
1672 | 1672 | ||
1673 | NS_PRV_DMA(skb) = pci_map_single(card->pcidev, skb->data, | 1673 | NS_PRV_DMA(skb) = dma_map_single(&card->pcidev->dev, skb->data, |
1674 | skb->len, PCI_DMA_TODEVICE); | 1674 | skb->len, DMA_TO_DEVICE); |
1675 | 1675 | ||
1676 | if (vcc->qos.aal == ATM_AAL5) { | 1676 | if (vcc->qos.aal == ATM_AAL5) { |
1677 | buflen = (skb->len + 47 + 8) / 48 * 48; /* Multiple of 48 */ | 1677 | buflen = (skb->len + 47 + 8) / 48 * 48; /* Multiple of 48 */ |
@@ -1930,10 +1930,10 @@ static void drain_scq(ns_dev * card, scq_info * scq, int pos) | |||
1930 | XPRINTK("nicstar%d: freeing skb at 0x%p (index %d).\n", | 1930 | XPRINTK("nicstar%d: freeing skb at 0x%p (index %d).\n", |
1931 | card->index, skb, i); | 1931 | card->index, skb, i); |
1932 | if (skb != NULL) { | 1932 | if (skb != NULL) { |
1933 | pci_unmap_single(card->pcidev, | 1933 | dma_unmap_single(&card->pcidev->dev, |
1934 | NS_PRV_DMA(skb), | 1934 | NS_PRV_DMA(skb), |
1935 | skb->len, | 1935 | skb->len, |
1936 | PCI_DMA_TODEVICE); | 1936 | DMA_TO_DEVICE); |
1937 | vcc = ATM_SKB(skb)->vcc; | 1937 | vcc = ATM_SKB(skb)->vcc; |
1938 | if (vcc && vcc->pop != NULL) { | 1938 | if (vcc && vcc->pop != NULL) { |
1939 | vcc->pop(vcc, skb); | 1939 | vcc->pop(vcc, skb); |
@@ -1992,16 +1992,16 @@ static void dequeue_rx(ns_dev * card, ns_rsqe * rsqe) | |||
1992 | return; | 1992 | return; |
1993 | } | 1993 | } |
1994 | idr_remove(&card->idr, id); | 1994 | idr_remove(&card->idr, id); |
1995 | pci_dma_sync_single_for_cpu(card->pcidev, | 1995 | dma_sync_single_for_cpu(&card->pcidev->dev, |
1996 | NS_PRV_DMA(skb), | 1996 | NS_PRV_DMA(skb), |
1997 | (NS_PRV_BUFTYPE(skb) == BUF_SM | 1997 | (NS_PRV_BUFTYPE(skb) == BUF_SM |
1998 | ? NS_SMSKBSIZE : NS_LGSKBSIZE), | 1998 | ? NS_SMSKBSIZE : NS_LGSKBSIZE), |
1999 | PCI_DMA_FROMDEVICE); | 1999 | DMA_FROM_DEVICE); |
2000 | pci_unmap_single(card->pcidev, | 2000 | dma_unmap_single(&card->pcidev->dev, |
2001 | NS_PRV_DMA(skb), | 2001 | NS_PRV_DMA(skb), |
2002 | (NS_PRV_BUFTYPE(skb) == BUF_SM | 2002 | (NS_PRV_BUFTYPE(skb) == BUF_SM |
2003 | ? NS_SMSKBSIZE : NS_LGSKBSIZE), | 2003 | ? NS_SMSKBSIZE : NS_LGSKBSIZE), |
2004 | PCI_DMA_FROMDEVICE); | 2004 | DMA_FROM_DEVICE); |
2005 | vpi = ns_rsqe_vpi(rsqe); | 2005 | vpi = ns_rsqe_vpi(rsqe); |
2006 | vci = ns_rsqe_vci(rsqe); | 2006 | vci = ns_rsqe_vci(rsqe); |
2007 | if (vpi >= 1UL << card->vpibits || vci >= 1UL << card->vcibits) { | 2007 | if (vpi >= 1UL << card->vpibits || vci >= 1UL << card->vcibits) { |
diff --git a/drivers/atm/solos-pci.c b/drivers/atm/solos-pci.c index 21b0bc6a9c96..74e18b0a6d89 100644 --- a/drivers/atm/solos-pci.c +++ b/drivers/atm/solos-pci.c | |||
@@ -785,8 +785,8 @@ static void solos_bh(unsigned long card_arg) | |||
785 | skb = card->rx_skb[port]; | 785 | skb = card->rx_skb[port]; |
786 | card->rx_skb[port] = NULL; | 786 | card->rx_skb[port] = NULL; |
787 | 787 | ||
788 | pci_unmap_single(card->dev, SKB_CB(skb)->dma_addr, | 788 | dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, |
789 | RX_DMA_SIZE, PCI_DMA_FROMDEVICE); | 789 | RX_DMA_SIZE, DMA_FROM_DEVICE); |
790 | 790 | ||
791 | header = (void *)skb->data; | 791 | header = (void *)skb->data; |
792 | size = le16_to_cpu(header->size); | 792 | size = le16_to_cpu(header->size); |
@@ -872,8 +872,8 @@ static void solos_bh(unsigned long card_arg) | |||
872 | struct sk_buff *skb = alloc_skb(RX_DMA_SIZE, GFP_ATOMIC); | 872 | struct sk_buff *skb = alloc_skb(RX_DMA_SIZE, GFP_ATOMIC); |
873 | if (skb) { | 873 | if (skb) { |
874 | SKB_CB(skb)->dma_addr = | 874 | SKB_CB(skb)->dma_addr = |
875 | pci_map_single(card->dev, skb->data, | 875 | dma_map_single(&card->dev->dev, skb->data, |
876 | RX_DMA_SIZE, PCI_DMA_FROMDEVICE); | 876 | RX_DMA_SIZE, DMA_FROM_DEVICE); |
877 | iowrite32(SKB_CB(skb)->dma_addr, | 877 | iowrite32(SKB_CB(skb)->dma_addr, |
878 | card->config_regs + RX_DMA_ADDR(port)); | 878 | card->config_regs + RX_DMA_ADDR(port)); |
879 | card->rx_skb[port] = skb; | 879 | card->rx_skb[port] = skb; |
@@ -1069,8 +1069,8 @@ static uint32_t fpga_tx(struct solos_card *card) | |||
1069 | if (tx_pending & 1) { | 1069 | if (tx_pending & 1) { |
1070 | struct sk_buff *oldskb = card->tx_skb[port]; | 1070 | struct sk_buff *oldskb = card->tx_skb[port]; |
1071 | if (oldskb) { | 1071 | if (oldskb) { |
1072 | pci_unmap_single(card->dev, SKB_CB(oldskb)->dma_addr, | 1072 | dma_unmap_single(&card->dev->dev, SKB_CB(oldskb)->dma_addr, |
1073 | oldskb->len, PCI_DMA_TODEVICE); | 1073 | oldskb->len, DMA_TO_DEVICE); |
1074 | card->tx_skb[port] = NULL; | 1074 | card->tx_skb[port] = NULL; |
1075 | } | 1075 | } |
1076 | spin_lock(&card->tx_queue_lock); | 1076 | spin_lock(&card->tx_queue_lock); |
@@ -1089,8 +1089,8 @@ static uint32_t fpga_tx(struct solos_card *card) | |||
1089 | data = card->dma_bounce + (BUF_SIZE * port); | 1089 | data = card->dma_bounce + (BUF_SIZE * port); |
1090 | memcpy(data, skb->data, skb->len); | 1090 | memcpy(data, skb->data, skb->len); |
1091 | } | 1091 | } |
1092 | SKB_CB(skb)->dma_addr = pci_map_single(card->dev, data, | 1092 | SKB_CB(skb)->dma_addr = dma_map_single(&card->dev->dev, data, |
1093 | skb->len, PCI_DMA_TODEVICE); | 1093 | skb->len, DMA_TO_DEVICE); |
1094 | card->tx_skb[port] = skb; | 1094 | card->tx_skb[port] = skb; |
1095 | iowrite32(SKB_CB(skb)->dma_addr, | 1095 | iowrite32(SKB_CB(skb)->dma_addr, |
1096 | card->config_regs + TX_DMA_ADDR(port)); | 1096 | card->config_regs + TX_DMA_ADDR(port)); |
@@ -1210,7 +1210,7 @@ static int fpga_probe(struct pci_dev *dev, const struct pci_device_id *id) | |||
1210 | goto out; | 1210 | goto out; |
1211 | } | 1211 | } |
1212 | 1212 | ||
1213 | err = pci_set_dma_mask(dev, DMA_BIT_MASK(32)); | 1213 | err = dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32)); |
1214 | if (err) { | 1214 | if (err) { |
1215 | dev_warn(&dev->dev, "Failed to set 32-bit DMA mask\n"); | 1215 | dev_warn(&dev->dev, "Failed to set 32-bit DMA mask\n"); |
1216 | goto out; | 1216 | goto out; |
@@ -1411,14 +1411,14 @@ static void atm_remove(struct solos_card *card) | |||
1411 | 1411 | ||
1412 | skb = card->rx_skb[i]; | 1412 | skb = card->rx_skb[i]; |
1413 | if (skb) { | 1413 | if (skb) { |
1414 | pci_unmap_single(card->dev, SKB_CB(skb)->dma_addr, | 1414 | dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, |
1415 | RX_DMA_SIZE, PCI_DMA_FROMDEVICE); | 1415 | RX_DMA_SIZE, DMA_FROM_DEVICE); |
1416 | dev_kfree_skb(skb); | 1416 | dev_kfree_skb(skb); |
1417 | } | 1417 | } |
1418 | skb = card->tx_skb[i]; | 1418 | skb = card->tx_skb[i]; |
1419 | if (skb) { | 1419 | if (skb) { |
1420 | pci_unmap_single(card->dev, SKB_CB(skb)->dma_addr, | 1420 | dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, |
1421 | skb->len, PCI_DMA_TODEVICE); | 1421 | skb->len, DMA_TO_DEVICE); |
1422 | dev_kfree_skb(skb); | 1422 | dev_kfree_skb(skb); |
1423 | } | 1423 | } |
1424 | while ((skb = skb_dequeue(&card->tx_queue[i]))) | 1424 | while ((skb = skb_dequeue(&card->tx_queue[i]))) |
diff --git a/drivers/atm/zatm.c b/drivers/atm/zatm.c index 969c3c29000c..cecfb943762f 100644 --- a/drivers/atm/zatm.c +++ b/drivers/atm/zatm.c | |||
@@ -1306,19 +1306,20 @@ static int zatm_start(struct atm_dev *dev) | |||
1306 | 1306 | ||
1307 | if (!mbx_entries[i]) | 1307 | if (!mbx_entries[i]) |
1308 | continue; | 1308 | continue; |
1309 | mbx = pci_alloc_consistent(pdev, 2*MBX_SIZE(i), &mbx_dma); | 1309 | mbx = dma_alloc_coherent(&pdev->dev, |
1310 | 2 * MBX_SIZE(i), &mbx_dma, GFP_KERNEL); | ||
1310 | if (!mbx) { | 1311 | if (!mbx) { |
1311 | error = -ENOMEM; | 1312 | error = -ENOMEM; |
1312 | goto out; | 1313 | goto out; |
1313 | } | 1314 | } |
1314 | /* | 1315 | /* |
1315 | * Alignment provided by pci_alloc_consistent() isn't enough | 1316 | * Alignment provided by dma_alloc_coherent() isn't enough |
1316 | * for this device. | 1317 | * for this device. |
1317 | */ | 1318 | */ |
1318 | if (((unsigned long)mbx ^ mbx_dma) & 0xffff) { | 1319 | if (((unsigned long)mbx ^ mbx_dma) & 0xffff) { |
1319 | printk(KERN_ERR DEV_LABEL "(itf %d): system " | 1320 | printk(KERN_ERR DEV_LABEL "(itf %d): system " |
1320 | "bus incompatible with driver\n", dev->number); | 1321 | "bus incompatible with driver\n", dev->number); |
1321 | pci_free_consistent(pdev, 2*MBX_SIZE(i), mbx, mbx_dma); | 1322 | dma_free_coherent(&pdev->dev, 2*MBX_SIZE(i), mbx, mbx_dma); |
1322 | error = -ENODEV; | 1323 | error = -ENODEV; |
1323 | goto out; | 1324 | goto out; |
1324 | } | 1325 | } |
@@ -1354,9 +1355,9 @@ out_tx: | |||
1354 | kfree(zatm_dev->tx_map); | 1355 | kfree(zatm_dev->tx_map); |
1355 | out: | 1356 | out: |
1356 | while (i-- > 0) { | 1357 | while (i-- > 0) { |
1357 | pci_free_consistent(pdev, 2*MBX_SIZE(i), | 1358 | dma_free_coherent(&pdev->dev, 2 * MBX_SIZE(i), |
1358 | (void *)zatm_dev->mbx_start[i], | 1359 | (void *)zatm_dev->mbx_start[i], |
1359 | zatm_dev->mbx_dma[i]); | 1360 | zatm_dev->mbx_dma[i]); |
1360 | } | 1361 | } |
1361 | free_irq(zatm_dev->irq, dev); | 1362 | free_irq(zatm_dev->irq, dev); |
1362 | goto done; | 1363 | goto done; |
@@ -1608,6 +1609,10 @@ static int zatm_init_one(struct pci_dev *pci_dev, | |||
1608 | if (ret < 0) | 1609 | if (ret < 0) |
1609 | goto out_disable; | 1610 | goto out_disable; |
1610 | 1611 | ||
1612 | ret = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)); | ||
1613 | if (ret < 0) | ||
1614 | goto out_disable; | ||
1615 | |||
1611 | zatm_dev->pci_dev = pci_dev; | 1616 | zatm_dev->pci_dev = pci_dev; |
1612 | dev->dev_data = zatm_dev; | 1617 | dev->dev_data = zatm_dev; |
1613 | zatm_dev->copper = (int)ent->driver_data; | 1618 | zatm_dev->copper = (int)ent->driver_data; |