atm: remove deprecated use of pci api · tjh.dev/kernel@ede58ef

+19 -14

drivers/atm/eni.c

··· 354 354 eni_vcc = ENI_VCC(vcc); 355 355 paddr = 0; /* GCC, shut up */ 356 356 if (skb) { 357 - paddr = pci_map_single(eni_dev->pci_dev,skb->data,skb->len, 358 - PCI_DMA_FROMDEVICE); 359 - if (pci_dma_mapping_error(eni_dev->pci_dev, paddr)) 357 + paddr = dma_map_single(&eni_dev->pci_dev->dev,skb->data,skb->len, 358 + DMA_FROM_DEVICE); 359 + if (dma_mapping_error(&eni_dev->pci_dev->dev, paddr)) 360 360 goto dma_map_error; 361 361 ENI_PRV_PADDR(skb) = paddr; 362 362 if (paddr & 3) ··· 481 481 482 482 trouble: 483 483 if (paddr) 484 - pci_unmap_single(eni_dev->pci_dev,paddr,skb->len, 485 - PCI_DMA_FROMDEVICE); 484 + dma_unmap_single(&eni_dev->pci_dev->dev,paddr,skb->len, 485 + DMA_FROM_DEVICE); 486 486 dma_map_error: 487 487 if (skb) dev_kfree_skb_irq(skb); 488 488 return -1; ··· 758 758 } 759 759 eni_vcc->rxing--; 760 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, 762 - PCI_DMA_TODEVICE); 761 + dma_unmap_single(&eni_dev->pci_dev->dev,ENI_PRV_PADDR(skb),skb->len, 762 + DMA_TO_DEVICE); 763 763 if (!skb->len) dev_kfree_skb_irq(skb); 764 764 else { 765 765 EVENT("pushing (len=%ld)\n",skb->len,0); ··· 1112 1112 vcc->dev->number); 1113 1113 return enq_jam; 1114 1114 } 1115 - paddr = pci_map_single(eni_dev->pci_dev,skb->data,skb->len, 1116 - PCI_DMA_TODEVICE); 1115 + paddr = dma_map_single(&eni_dev->pci_dev->dev,skb->data,skb->len, 1116 + DMA_TO_DEVICE); 1117 1117 ENI_PRV_PADDR(skb) = paddr; 1118 1118 /* prepare DMA queue entries */ 1119 1119 j = 0; ··· 1226 1226 break; 1227 1227 } 1228 1228 ENI_VCC(vcc)->txing -= ENI_PRV_SIZE(skb); 1229 - pci_unmap_single(eni_dev->pci_dev,ENI_PRV_PADDR(skb),skb->len, 1230 - PCI_DMA_TODEVICE); 1229 + dma_unmap_single(&eni_dev->pci_dev->dev,ENI_PRV_PADDR(skb),skb->len, 1230 + DMA_TO_DEVICE); 1231 1231 if (vcc->pop) vcc->pop(vcc,skb); 1232 1232 else dev_kfree_skb_irq(skb); 1233 1233 atomic_inc(&vcc->stats->tx); ··· 2240 2240 if (rc < 0) 2241 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 2247 rc = -ENOMEM; 2244 2248 eni_dev = kmalloc(sizeof(struct eni_dev), GFP_KERNEL); 2245 2249 if (!eni_dev) 2246 2250 goto err_disable; 2247 2251 2248 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 2255 if (!zero->addr) 2251 2256 goto err_kfree; 2252 2257 ··· 2282 2277 err_unregister: 2283 2278 atm_dev_deregister(dev); 2284 2279 err_free_consistent: 2285 - pci_free_consistent(pci_dev, ENI_ZEROES_SIZE, zero->addr, zero->dma); 2280 + dma_free_coherent(&pci_dev->dev, ENI_ZEROES_SIZE, zero->addr, zero->dma); 2286 2281 err_kfree: 2287 2282 kfree(eni_dev); 2288 2283 err_disable: ··· 2307 2302 2308 2303 eni_do_release(dev); 2309 2304 atm_dev_deregister(dev); 2310 - pci_free_consistent(pdev, ENI_ZEROES_SIZE, zero->addr, zero->dma); 2305 + dma_free_coherent(&pdev->dev, ENI_ZEROES_SIZE, zero->addr, zero->dma); 2311 2306 kfree(ed); 2312 2307 pci_disable_device(pdev); 2313 2308 }

+14 -8

drivers/atm/fore200e.c

··· 425 425 static u32 426 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 430 DPRINTK(3, "PCI DVMA mapping: virt_addr = 0x%p, size = %d, direction = %d, --> dma_addr = 0x%08x\n", 431 431 virt_addr, size, direction, dma_addr); ··· 440 440 DPRINTK(3, "PCI DVMA unmapping: dma_addr = 0x%08x, size = %d, direction = %d\n", 441 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 449 { 450 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 455 static void ··· 457 457 { 458 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 470 { 471 471 /* returned chunks are page-aligned */ 472 472 chunk->alloc_size = size * nbr; 473 - chunk->alloc_addr = pci_alloc_consistent((struct pci_dev*)fore200e->bus_dev, 474 - chunk->alloc_size, 475 - &chunk->dma_addr); 473 + chunk->alloc_addr = dma_alloc_coherent(&((struct pci_dev *) fore200e->bus_dev)->dev, 474 + chunk->alloc_size, 475 + &chunk->dma_addr, 476 + GFP_KERNEL); 476 477 477 478 if ((chunk->alloc_addr == NULL) || (chunk->dma_addr == 0)) 478 479 return -ENOMEM; ··· 489 488 static void 490 489 fore200e_pca_dma_chunk_free(struct fore200e* fore200e, struct chunk* chunk) 491 490 { 492 - pci_free_consistent((struct pci_dev*)fore200e->bus_dev, 491 + dma_free_coherent(&((struct pci_dev *) fore200e->bus_dev)->dev, 493 492 chunk->alloc_size, 494 493 chunk->alloc_addr, 495 494 chunk->dma_addr); ··· 2705 2704 static int index = 0; 2706 2705 2707 2706 if (pci_enable_device(pci_dev)) { 2707 + err = -EINVAL; 2708 + goto out; 2709 + } 2710 + 2711 + if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) { 2708 2712 err = -EINVAL; 2709 2713 goto out; 2710 2714 }

+64 -61

drivers/atm/he.c

··· 359 359 360 360 if (pci_enable_device(pci_dev)) 361 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 363 printk(KERN_WARNING "he: no suitable dma available\n"); 364 364 err = -EIO; 365 365 goto init_one_failure; ··· 533 533 534 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, 537 - CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq), 538 - &he_dev->tpdrq_phys); 536 + he_dev->tpdrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 537 + CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq), 538 + &he_dev->tpdrq_phys, GFP_KERNEL); 539 539 if (he_dev->tpdrq_base == NULL) { 540 540 hprintk("failed to alloc tpdrq\n"); 541 541 return -ENOMEM; ··· 796 796 } 797 797 798 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 800 CONFIG_RBPL_BUFSIZE, 64, 0); 801 801 if (he_dev->rbpl_pool == NULL) { 802 802 hprintk("unable to create rbpl pool\n"); 803 803 goto out_free_rbpl_virt; 804 804 } 805 805 806 - he_dev->rbpl_base = pci_zalloc_consistent(he_dev->pci_dev, 807 - CONFIG_RBPL_SIZE * sizeof(struct he_rbp), 808 - &he_dev->rbpl_phys); 806 + he_dev->rbpl_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 807 + CONFIG_RBPL_SIZE * sizeof(struct he_rbp), 808 + &he_dev->rbpl_phys, GFP_KERNEL); 809 809 if (he_dev->rbpl_base == NULL) { 810 810 hprintk("failed to alloc rbpl_base\n"); 811 811 goto out_destroy_rbpl_pool; ··· 815 815 816 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 819 if (!heb) 820 820 goto out_free_rbpl; 821 821 heb->mapping = mapping; ··· 842 842 843 843 /* rx buffer ready queue */ 844 844 845 - he_dev->rbrq_base = pci_zalloc_consistent(he_dev->pci_dev, 846 - CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), 847 - &he_dev->rbrq_phys); 845 + he_dev->rbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 846 + CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), 847 + &he_dev->rbrq_phys, GFP_KERNEL); 848 848 if (he_dev->rbrq_base == NULL) { 849 849 hprintk("failed to allocate rbrq\n"); 850 850 goto out_free_rbpl; ··· 866 866 867 867 /* tx buffer ready queue */ 868 868 869 - he_dev->tbrq_base = pci_zalloc_consistent(he_dev->pci_dev, 870 - CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 871 - &he_dev->tbrq_phys); 869 + he_dev->tbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 870 + CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 871 + &he_dev->tbrq_phys, GFP_KERNEL); 872 872 if (he_dev->tbrq_base == NULL) { 873 873 hprintk("failed to allocate tbrq\n"); 874 874 goto out_free_rbpq_base; ··· 884 884 return 0; 885 885 886 886 out_free_rbpq_base: 887 - pci_free_consistent(he_dev->pci_dev, CONFIG_RBRQ_SIZE * 888 - sizeof(struct he_rbrq), he_dev->rbrq_base, 889 - he_dev->rbrq_phys); 887 + dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * 888 + sizeof(struct he_rbrq), he_dev->rbrq_base, 889 + he_dev->rbrq_phys); 890 890 out_free_rbpl: 891 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 * 895 - sizeof(struct he_rbp), he_dev->rbpl_base, 896 - he_dev->rbpl_phys); 894 + dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE * 895 + sizeof(struct he_rbp), he_dev->rbpl_base, 896 + he_dev->rbpl_phys); 897 897 out_destroy_rbpl_pool: 898 - pci_pool_destroy(he_dev->rbpl_pool); 898 + dma_pool_destroy(he_dev->rbpl_pool); 899 899 out_free_rbpl_virt: 900 900 kfree(he_dev->rbpl_virt); 901 901 out_free_rbpl_table: ··· 911 911 /* 2.9.3.5 tail offset for each interrupt queue is located after the 912 912 end of the interrupt queue */ 913 913 914 - he_dev->irq_base = pci_alloc_consistent(he_dev->pci_dev, 915 - (CONFIG_IRQ_SIZE+1) * sizeof(struct he_irq), &he_dev->irq_phys); 914 + he_dev->irq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev, 915 + (CONFIG_IRQ_SIZE + 1) 916 + * sizeof(struct he_irq), 917 + &he_dev->irq_phys, 918 + GFP_KERNEL); 916 919 if (he_dev->irq_base == NULL) { 917 920 hprintk("failed to allocate irq\n"); 918 921 return -ENOMEM; ··· 1422 1419 1423 1420 he_init_tpdrq(he_dev); 1424 1421 1425 - he_dev->tpd_pool = pci_pool_create("tpd", he_dev->pci_dev, 1426 - sizeof(struct he_tpd), TPD_ALIGNMENT, 0); 1422 + he_dev->tpd_pool = dma_pool_create("tpd", &he_dev->pci_dev->dev, 1423 + sizeof(struct he_tpd), TPD_ALIGNMENT, 0); 1427 1424 if (he_dev->tpd_pool == NULL) { 1428 - hprintk("unable to create tpd pci_pool\n"); 1425 + hprintk("unable to create tpd dma_pool\n"); 1429 1426 return -ENOMEM; 1430 1427 } 1431 1428 ··· 1462 1459 1463 1460 /* host status page */ 1464 1461 1465 - he_dev->hsp = pci_zalloc_consistent(he_dev->pci_dev, 1466 - sizeof(struct he_hsp), 1467 - &he_dev->hsp_phys); 1462 + he_dev->hsp = dma_zalloc_coherent(&he_dev->pci_dev->dev, 1463 + sizeof(struct he_hsp), 1464 + &he_dev->hsp_phys, GFP_KERNEL); 1468 1465 if (he_dev->hsp == NULL) { 1469 1466 hprintk("failed to allocate host status page\n"); 1470 1467 return -ENOMEM; ··· 1561 1558 free_irq(he_dev->irq, he_dev); 1562 1559 1563 1560 if (he_dev->irq_base) 1564 - pci_free_consistent(he_dev->pci_dev, (CONFIG_IRQ_SIZE+1) 1565 - * sizeof(struct he_irq), he_dev->irq_base, he_dev->irq_phys); 1561 + 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); 1566 1563 1567 1564 if (he_dev->hsp) 1568 - pci_free_consistent(he_dev->pci_dev, sizeof(struct he_hsp), 1569 - he_dev->hsp, he_dev->hsp_phys); 1565 + dma_free_coherent(&he_dev->pci_dev->dev, sizeof(struct he_hsp), 1566 + he_dev->hsp, he_dev->hsp_phys); 1570 1567 1571 1568 if (he_dev->rbpl_base) { 1572 1569 list_for_each_entry_safe(heb, next, &he_dev->rbpl_outstanding, entry) 1573 - pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1570 + dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1574 1571 1575 - pci_free_consistent(he_dev->pci_dev, CONFIG_RBPL_SIZE 1576 - * sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys); 1572 + dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBPL_SIZE 1573 + * sizeof(struct he_rbp), he_dev->rbpl_base, he_dev->rbpl_phys); 1577 1574 } 1578 1575 1579 1576 kfree(he_dev->rbpl_virt); 1580 1577 kfree(he_dev->rbpl_table); 1581 1578 1582 1579 if (he_dev->rbpl_pool) 1583 - pci_pool_destroy(he_dev->rbpl_pool); 1580 + dma_pool_destroy(he_dev->rbpl_pool); 1584 1581 1585 1582 if (he_dev->rbrq_base) 1586 - pci_free_consistent(he_dev->pci_dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), 1587 - he_dev->rbrq_base, he_dev->rbrq_phys); 1583 + dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq), 1584 + he_dev->rbrq_base, he_dev->rbrq_phys); 1588 1585 1589 1586 if (he_dev->tbrq_base) 1590 - pci_free_consistent(he_dev->pci_dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 1591 - he_dev->tbrq_base, he_dev->tbrq_phys); 1587 + dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 1588 + he_dev->tbrq_base, he_dev->tbrq_phys); 1592 1589 1593 1590 if (he_dev->tpdrq_base) 1594 - pci_free_consistent(he_dev->pci_dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 1595 - he_dev->tpdrq_base, he_dev->tpdrq_phys); 1591 + dma_free_coherent(&he_dev->pci_dev->dev, CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq), 1592 + he_dev->tpdrq_base, he_dev->tpdrq_phys); 1596 1593 1597 1594 if (he_dev->tpd_pool) 1598 - pci_pool_destroy(he_dev->tpd_pool); 1595 + dma_pool_destroy(he_dev->tpd_pool); 1599 1596 1600 1597 if (he_dev->pci_dev) { 1601 1598 pci_read_config_word(he_dev->pci_dev, PCI_COMMAND, &command); ··· 1613 1610 struct he_tpd *tpd; 1614 1611 dma_addr_t mapping; 1615 1612 1616 - tpd = pci_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC|GFP_DMA, &mapping); 1613 + tpd = dma_pool_alloc(he_dev->tpd_pool, GFP_ATOMIC, &mapping); 1617 1614 if (tpd == NULL) 1618 1615 return NULL; 1619 1616 ··· 1684 1681 if (!RBRQ_HBUF_ERR(he_dev->rbrq_head)) { 1685 1682 clear_bit(i, he_dev->rbpl_table); 1686 1683 list_del(&heb->entry); 1687 - pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1684 + dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1688 1685 } 1689 1686 1690 1687 goto next_rbrq_entry; ··· 1777 1774 ++pdus_assembled; 1778 1775 1779 1776 list_for_each_entry_safe(heb, next, &he_vcc->buffers, entry) 1780 - pci_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1777 + dma_pool_free(he_dev->rbpl_pool, heb, heb->mapping); 1781 1778 INIT_LIST_HEAD(&he_vcc->buffers); 1782 1779 he_vcc->pdu_len = 0; 1783 1780 ··· 1846 1843 1847 1844 for (slot = 0; slot < TPD_MAXIOV; ++slot) { 1848 1845 if (tpd->iovec[slot].addr) 1849 - pci_unmap_single(he_dev->pci_dev, 1846 + dma_unmap_single(&he_dev->pci_dev->dev, 1850 1847 tpd->iovec[slot].addr, 1851 1848 tpd->iovec[slot].len & TPD_LEN_MASK, 1852 - PCI_DMA_TODEVICE); 1849 + DMA_TO_DEVICE); 1853 1850 if (tpd->iovec[slot].len & TPD_LST) 1854 1851 break; 1855 1852 ··· 1864 1861 1865 1862 next_tbrq_entry: 1866 1863 if (tpd) 1867 - pci_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); 1864 + dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); 1868 1865 he_dev->tbrq_head = (struct he_tbrq *) 1869 1866 ((unsigned long) he_dev->tbrq_base | 1870 1867 TBRQ_MASK(he_dev->tbrq_head + 1)); ··· 1908 1905 } 1909 1906 he_dev->rbpl_hint = i + 1; 1910 1907 1911 - heb = pci_pool_alloc(he_dev->rbpl_pool, GFP_ATOMIC|GFP_DMA, &mapping); 1908 + heb = dma_pool_alloc(he_dev->rbpl_pool, GFP_ATOMIC, &mapping); 1912 1909 if (!heb) 1913 1910 break; 1914 1911 heb->mapping = mapping; ··· 2087 2084 */ 2088 2085 for (slot = 0; slot < TPD_MAXIOV; ++slot) { 2089 2086 if (tpd->iovec[slot].addr) 2090 - pci_unmap_single(he_dev->pci_dev, 2087 + dma_unmap_single(&he_dev->pci_dev->dev, 2091 2088 tpd->iovec[slot].addr, 2092 2089 tpd->iovec[slot].len & TPD_LEN_MASK, 2093 - PCI_DMA_TODEVICE); 2090 + DMA_TO_DEVICE); 2094 2091 } 2095 2092 if (tpd->skb) { 2096 2093 if (tpd->vcc->pop) ··· 2099 2096 dev_kfree_skb_any(tpd->skb); 2100 2097 atomic_inc(&tpd->vcc->stats->tx_err); 2101 2098 } 2102 - pci_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); 2099 + dma_pool_free(he_dev->tpd_pool, tpd, TPD_ADDR(tpd->status)); 2103 2100 return; 2104 2101 } 2105 2102 } ··· 2553 2550 } 2554 2551 2555 2552 #ifdef USE_SCATTERGATHER 2556 - tpd->iovec[slot].addr = pci_map_single(he_dev->pci_dev, skb->data, 2557 - skb_headlen(skb), PCI_DMA_TODEVICE); 2553 + tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, skb->data, 2554 + skb_headlen(skb), DMA_TO_DEVICE); 2558 2555 tpd->iovec[slot].len = skb_headlen(skb); 2559 2556 ++slot; 2560 2557 ··· 2582 2579 slot = 0; 2583 2580 } 2584 2581 2585 - tpd->iovec[slot].addr = pci_map_single(he_dev->pci_dev, 2582 + tpd->iovec[slot].addr = dma_map_single(&he_dev->pci_dev->dev, 2586 2583 (void *) page_address(frag->page) + frag->page_offset, 2587 - frag->size, PCI_DMA_TODEVICE); 2584 + frag->size, DMA_TO_DEVICE); 2588 2585 tpd->iovec[slot].len = frag->size; 2589 2586 ++slot; 2590 2587 ··· 2592 2589 2593 2590 tpd->iovec[slot - 1].len |= TPD_LST; 2594 2591 #else 2595 - tpd->address0 = pci_map_single(he_dev->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE); 2592 + tpd->address0 = dma_map_single(&he_dev->pci_dev->dev, skb->data, skb->len, DMA_TO_DEVICE); 2596 2593 tpd->length0 = skb->len | TPD_LST; 2597 2594 #endif 2598 2595 tpd->status |= TPD_INT;

+2 -2

drivers/atm/he.h

··· 281 281 int irq_peak; 282 282 283 283 struct tasklet_struct tasklet; 284 - struct pci_pool *tpd_pool; 284 + struct dma_pool *tpd_pool; 285 285 struct list_head outstanding_tpds; 286 286 287 287 dma_addr_t tpdrq_phys; ··· 296 296 struct he_buff **rbpl_virt; 297 297 unsigned long *rbpl_table; 298 298 unsigned long rbpl_hint; 299 - struct pci_pool *rbpl_pool; 299 + struct dma_pool *rbpl_pool; 300 300 dma_addr_t rbpl_phys; 301 301 struct he_rbp *rbpl_base, *rbpl_tail; 302 302 struct list_head rbpl_outstanding;

+57 -50

drivers/atm/idt77252.c

··· 641 641 scq = kzalloc(sizeof(struct scq_info), GFP_KERNEL); 642 642 if (!scq) 643 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 646 if (scq->base == NULL) { 646 647 kfree(scq); 647 648 return NULL; ··· 670 669 struct sk_buff *skb; 671 670 struct atm_vcc *vcc; 672 671 673 - pci_free_consistent(card->pcidev, SCQ_SIZE, 674 - scq->base, scq->paddr); 672 + dma_free_coherent(&card->pcidev->dev, SCQ_SIZE, 673 + scq->base, scq->paddr); 675 674 676 675 while ((skb = skb_dequeue(&scq->transmit))) { 677 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 678 - skb->len, PCI_DMA_TODEVICE); 676 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 677 + skb->len, DMA_TO_DEVICE); 679 678 680 679 vcc = ATM_SKB(skb)->vcc; 681 680 if (vcc->pop) ··· 685 684 } 686 685 687 686 while ((skb = skb_dequeue(&scq->pending))) { 688 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 689 - skb->len, PCI_DMA_TODEVICE); 687 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 688 + skb->len, DMA_TO_DEVICE); 690 689 691 690 vcc = ATM_SKB(skb)->vcc; 692 691 if (vcc->pop) ··· 801 800 if (skb) { 802 801 TXPRINTK("%s: freeing skb at %p.\n", card->name, skb); 803 802 804 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 805 - skb->len, PCI_DMA_TODEVICE); 803 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 804 + skb->len, DMA_TO_DEVICE); 806 805 807 806 vcc = ATM_SKB(skb)->vcc; 808 807 ··· 847 846 tbd = &IDT77252_PRV_TBD(skb); 848 847 vcc = ATM_SKB(skb)->vcc; 849 848 850 - IDT77252_PRV_PADDR(skb) = pci_map_single(card->pcidev, skb->data, 851 - skb->len, PCI_DMA_TODEVICE); 849 + IDT77252_PRV_PADDR(skb) = dma_map_single(&card->pcidev->dev, skb->data, 850 + skb->len, DMA_TO_DEVICE); 852 851 853 852 error = -EINVAL; 854 853 ··· 925 924 return 0; 926 925 927 926 errout: 928 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 929 - skb->len, PCI_DMA_TODEVICE); 927 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 928 + skb->len, DMA_TO_DEVICE); 930 929 return error; 931 930 } 932 931 ··· 971 970 { 972 971 struct rsq_entry *rsqe; 973 972 974 - card->rsq.base = pci_zalloc_consistent(card->pcidev, RSQSIZE, 975 - &card->rsq.paddr); 973 + card->rsq.base = dma_zalloc_coherent(&card->pcidev->dev, RSQSIZE, 974 + &card->rsq.paddr, GFP_KERNEL); 976 975 if (card->rsq.base == NULL) { 977 976 printk("%s: can't allocate RSQ.\n", card->name); 978 977 return -1; ··· 1002 1001 static void 1003 1002 deinit_rsq(struct idt77252_dev *card) 1004 1003 { 1005 - pci_free_consistent(card->pcidev, RSQSIZE, 1006 - card->rsq.base, card->rsq.paddr); 1004 + dma_free_coherent(&card->pcidev->dev, RSQSIZE, 1005 + card->rsq.base, card->rsq.paddr); 1007 1006 } 1008 1007 1009 1008 static void ··· 1058 1057 1059 1058 vcc = vc->rx_vcc; 1060 1059 1061 - pci_dma_sync_single_for_cpu(card->pcidev, IDT77252_PRV_PADDR(skb), 1062 - skb_end_pointer(skb) - skb->data, 1063 - PCI_DMA_FROMDEVICE); 1060 + dma_sync_single_for_cpu(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 1061 + skb_end_pointer(skb) - skb->data, 1062 + DMA_FROM_DEVICE); 1064 1063 1065 1064 if ((vcc->qos.aal == ATM_AAL0) || 1066 1065 (vcc->qos.aal == ATM_AAL34)) { ··· 1181 1180 return; 1182 1181 } 1183 1182 1184 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 1183 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 1185 1184 skb_end_pointer(skb) - skb->data, 1186 - PCI_DMA_FROMDEVICE); 1185 + DMA_FROM_DEVICE); 1187 1186 sb_pool_remove(card, skb); 1188 1187 1189 1188 skb_trim(skb, len); ··· 1255 1254 head = IDT77252_PRV_PADDR(queue) + (queue->data - queue->head - 16); 1256 1255 tail = readl(SAR_REG_RAWCT); 1257 1256 1258 - pci_dma_sync_single_for_cpu(card->pcidev, IDT77252_PRV_PADDR(queue), 1259 - skb_end_offset(queue) - 16, 1260 - PCI_DMA_FROMDEVICE); 1257 + dma_sync_single_for_cpu(&card->pcidev->dev, IDT77252_PRV_PADDR(queue), 1258 + skb_end_offset(queue) - 16, 1259 + DMA_FROM_DEVICE); 1261 1260 1262 1261 while (head != tail) { 1263 1262 unsigned int vpi, vci; ··· 1349 1348 if (next) { 1350 1349 card->raw_cell_head = next; 1351 1350 queue = card->raw_cell_head; 1352 - pci_dma_sync_single_for_cpu(card->pcidev, 1353 - IDT77252_PRV_PADDR(queue), 1354 - (skb_end_pointer(queue) - 1355 - queue->data), 1356 - PCI_DMA_FROMDEVICE); 1351 + dma_sync_single_for_cpu(&card->pcidev->dev, 1352 + IDT77252_PRV_PADDR(queue), 1353 + (skb_end_pointer(queue) - 1354 + queue->data), 1355 + DMA_FROM_DEVICE); 1357 1356 } else { 1358 1357 card->raw_cell_head = NULL; 1359 1358 printk("%s: raw cell queue overrun\n", ··· 1376 1375 { 1377 1376 struct tsq_entry *tsqe; 1378 1377 1379 - card->tsq.base = pci_alloc_consistent(card->pcidev, RSQSIZE, 1380 - &card->tsq.paddr); 1378 + card->tsq.base = dma_alloc_coherent(&card->pcidev->dev, RSQSIZE, 1379 + &card->tsq.paddr, GFP_KERNEL); 1381 1380 if (card->tsq.base == NULL) { 1382 1381 printk("%s: can't allocate TSQ.\n", card->name); 1383 1382 return -1; ··· 1399 1398 static void 1400 1399 deinit_tsq(struct idt77252_dev *card) 1401 1400 { 1402 - pci_free_consistent(card->pcidev, TSQSIZE, 1403 - card->tsq.base, card->tsq.paddr); 1401 + dma_free_coherent(&card->pcidev->dev, TSQSIZE, 1402 + card->tsq.base, card->tsq.paddr); 1404 1403 } 1405 1404 1406 1405 static void ··· 1862 1861 goto outfree; 1863 1862 } 1864 1863 1865 - paddr = pci_map_single(card->pcidev, skb->data, 1864 + paddr = dma_map_single(&card->pcidev->dev, skb->data, 1866 1865 skb_end_pointer(skb) - skb->data, 1867 - PCI_DMA_FROMDEVICE); 1866 + DMA_FROM_DEVICE); 1868 1867 IDT77252_PRV_PADDR(skb) = paddr; 1869 1868 1870 1869 if (push_rx_skb(card, skb, queue)) { ··· 1876 1875 return; 1877 1876 1878 1877 outunmap: 1879 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 1880 - skb_end_pointer(skb) - skb->data, PCI_DMA_FROMDEVICE); 1878 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 1879 + skb_end_pointer(skb) - skb->data, DMA_FROM_DEVICE); 1881 1880 1882 1881 handle = IDT77252_PRV_POOL(skb); 1883 1882 card->sbpool[POOL_QUEUE(handle)].skb[POOL_INDEX(handle)] = NULL; ··· 1893 1892 u32 handle = IDT77252_PRV_POOL(skb); 1894 1893 int err; 1895 1894 1896 - pci_dma_sync_single_for_device(card->pcidev, IDT77252_PRV_PADDR(skb), 1897 - skb_end_pointer(skb) - skb->data, 1898 - PCI_DMA_FROMDEVICE); 1895 + dma_sync_single_for_device(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 1896 + skb_end_pointer(skb) - skb->data, 1897 + DMA_FROM_DEVICE); 1899 1898 1900 1899 err = push_rx_skb(card, skb, POOL_QUEUE(handle)); 1901 1900 if (err) { 1902 - pci_unmap_single(card->pcidev, IDT77252_PRV_PADDR(skb), 1901 + dma_unmap_single(&card->pcidev->dev, IDT77252_PRV_PADDR(skb), 1903 1902 skb_end_pointer(skb) - skb->data, 1904 - PCI_DMA_FROMDEVICE); 1903 + DMA_FROM_DEVICE); 1905 1904 sb_pool_remove(card, skb); 1906 1905 dev_kfree_skb(skb); 1907 1906 } ··· 3059 3058 for (j = 0; j < FBQ_SIZE; j++) { 3060 3059 skb = card->sbpool[i].skb[j]; 3061 3060 if (skb) { 3062 - pci_unmap_single(card->pcidev, 3061 + dma_unmap_single(&card->pcidev->dev, 3063 3062 IDT77252_PRV_PADDR(skb), 3064 3063 (skb_end_pointer(skb) - 3065 3064 skb->data), 3066 - PCI_DMA_FROMDEVICE); 3065 + DMA_FROM_DEVICE); 3067 3066 card->sbpool[i].skb[j] = NULL; 3068 3067 dev_kfree_skb(skb); 3069 3068 } ··· 3077 3076 vfree(card->vcs); 3078 3077 3079 3078 if (card->raw_cell_hnd) { 3080 - pci_free_consistent(card->pcidev, 2 * sizeof(u32), 3081 - card->raw_cell_hnd, card->raw_cell_paddr); 3079 + dma_free_coherent(&card->pcidev->dev, 2 * sizeof(u32), 3080 + card->raw_cell_hnd, card->raw_cell_paddr); 3082 3081 } 3083 3082 3084 3083 if (card->rsq.base) { ··· 3398 3397 writel(0, SAR_REG_GP); 3399 3398 3400 3399 /* Initialize RAW Cell Handle Register */ 3401 - card->raw_cell_hnd = pci_zalloc_consistent(card->pcidev, 3402 - 2 * sizeof(u32), 3403 - &card->raw_cell_paddr); 3400 + card->raw_cell_hnd = dma_zalloc_coherent(&card->pcidev->dev, 3401 + 2 * sizeof(u32), 3402 + &card->raw_cell_paddr, 3403 + GFP_KERNEL); 3404 3404 if (!card->raw_cell_hnd) { 3405 3405 printk("%s: memory allocation failure.\n", card->name); 3406 3406 deinit_card(card); ··· 3610 3608 3611 3609 if ((err = pci_enable_device(pcidev))) { 3612 3610 printk("idt77252: can't enable PCI device at %s\n", pci_name(pcidev)); 3611 + return err; 3612 + } 3613 + 3614 + if ((err = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32)))) { 3615 + printk("idt77252: can't enable DMA for PCI device at %s\n", pci_name(pcidev)); 3613 3616 return err; 3614 3617 } 3615 3618

+28 -26

drivers/atm/iphase.c

··· 1185 1185 1186 1186 /* Build the DLE structure */ 1187 1187 wr_ptr = iadev->rx_dle_q.write; 1188 - wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data, 1189 - len, PCI_DMA_FROMDEVICE); 1188 + wr_ptr->sys_pkt_addr = dma_map_single(&iadev->pci->dev, skb->data, 1189 + len, DMA_FROM_DEVICE); 1190 1190 wr_ptr->local_pkt_addr = buf_addr; 1191 1191 wr_ptr->bytes = len; /* We don't know this do we ?? */ 1192 1192 wr_ptr->mode = DMA_INT_ENABLE; ··· 1306 1306 u_short length; 1307 1307 struct ia_vcc *ia_vcc; 1308 1308 1309 - pci_unmap_single(iadev->pci, iadev->rx_dle_q.write->sys_pkt_addr, 1310 - len, PCI_DMA_FROMDEVICE); 1309 + dma_unmap_single(&iadev->pci->dev, iadev->rx_dle_q.write->sys_pkt_addr, 1310 + len, DMA_FROM_DEVICE); 1311 1311 /* no VCC related housekeeping done as yet. lets see */ 1312 1312 vcc = ATM_SKB(skb)->vcc; 1313 1313 if (!vcc) { ··· 1430 1430 // spin_lock_init(&iadev->rx_lock); 1431 1431 1432 1432 /* Allocate 4k bytes - more aligned than needed (4k boundary) */ 1433 - dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE, 1434 - &iadev->rx_dle_dma); 1433 + dle_addr = dma_alloc_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, 1434 + &iadev->rx_dle_dma, GFP_KERNEL); 1435 1435 if (!dle_addr) { 1436 1436 printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); 1437 1437 goto err_out; ··· 1631 1631 return 0; 1632 1632 1633 1633 err_free_dle: 1634 - pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, 1635 - iadev->rx_dle_dma); 1634 + dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, 1635 + iadev->rx_dle_dma); 1636 1636 err_out: 1637 1637 return -ENOMEM; 1638 1638 } ··· 1702 1702 1703 1703 /* Revenge of the 2 dle (skb + trailer) used in ia_pkt_tx() */ 1704 1704 if (!((dle - iadev->tx_dle_q.start)%(2*sizeof(struct dle)))) { 1705 - pci_unmap_single(iadev->pci, dle->sys_pkt_addr, skb->len, 1706 - PCI_DMA_TODEVICE); 1705 + dma_unmap_single(&iadev->pci->dev, dle->sys_pkt_addr, skb->len, 1706 + DMA_TO_DEVICE); 1707 1707 } 1708 1708 vcc = ATM_SKB(skb)->vcc; 1709 1709 if (!vcc) { ··· 1917 1917 readw(iadev->seg_reg+SEG_MASK_REG));) 1918 1918 1919 1919 /* Allocate 4k (boundary aligned) bytes */ 1920 - dle_addr = pci_alloc_consistent(iadev->pci, DLE_TOTAL_SIZE, 1921 - &iadev->tx_dle_dma); 1920 + dle_addr = dma_alloc_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, 1921 + &iadev->tx_dle_dma, GFP_KERNEL); 1922 1922 if (!dle_addr) { 1923 1923 printk(KERN_ERR DEV_LABEL "can't allocate DLEs\n"); 1924 1924 goto err_out; ··· 1989 1989 goto err_free_tx_bufs; 1990 1990 } 1991 1991 iadev->tx_buf[i].cpcs = cpcs; 1992 - iadev->tx_buf[i].dma_addr = pci_map_single(iadev->pci, 1993 - cpcs, sizeof(*cpcs), PCI_DMA_TODEVICE); 1992 + iadev->tx_buf[i].dma_addr = dma_map_single(&iadev->pci->dev, 1993 + cpcs, 1994 + sizeof(*cpcs), 1995 + DMA_TO_DEVICE); 1994 1996 } 1995 1997 iadev->desc_tbl = kmalloc(iadev->num_tx_desc * 1996 1998 sizeof(struct desc_tbl_t), GFP_KERNEL); ··· 2200 2198 while (--i >= 0) { 2201 2199 struct cpcs_trailer_desc *desc = iadev->tx_buf + i; 2202 2200 2203 - pci_unmap_single(iadev->pci, desc->dma_addr, 2204 - sizeof(*desc->cpcs), PCI_DMA_TODEVICE); 2201 + dma_unmap_single(&iadev->pci->dev, desc->dma_addr, 2202 + sizeof(*desc->cpcs), DMA_TO_DEVICE); 2205 2203 kfree(desc->cpcs); 2206 2204 } 2207 2205 kfree(iadev->tx_buf); 2208 2206 err_free_dle: 2209 - pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, 2210 - iadev->tx_dle_dma); 2207 + dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, 2208 + iadev->tx_dle_dma); 2211 2209 err_out: 2212 2210 return -ENOMEM; 2213 2211 } ··· 2478 2476 for (i = 0; i < iadev->num_tx_desc; i++) { 2479 2477 struct cpcs_trailer_desc *desc = iadev->tx_buf + i; 2480 2478 2481 - pci_unmap_single(iadev->pci, desc->dma_addr, 2482 - sizeof(*desc->cpcs), PCI_DMA_TODEVICE); 2479 + dma_unmap_single(&iadev->pci->dev, desc->dma_addr, 2480 + sizeof(*desc->cpcs), DMA_TO_DEVICE); 2483 2481 kfree(desc->cpcs); 2484 2482 } 2485 2483 kfree(iadev->tx_buf); 2486 - pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, 2487 - iadev->tx_dle_dma); 2484 + dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->tx_dle_q.start, 2485 + iadev->tx_dle_dma); 2488 2486 } 2489 2487 2490 2488 static void ia_free_rx(IADEV *iadev) 2491 2489 { 2492 2490 kfree(iadev->rx_open); 2493 - pci_free_consistent(iadev->pci, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, 2494 - iadev->rx_dle_dma); 2491 + dma_free_coherent(&iadev->pci->dev, DLE_TOTAL_SIZE, iadev->rx_dle_q.start, 2492 + iadev->rx_dle_dma); 2495 2493 } 2496 2494 2497 2495 static int ia_start(struct atm_dev *dev) ··· 3011 3009 /* Build the DLE structure */ 3012 3010 wr_ptr = iadev->tx_dle_q.write; 3013 3011 memset((caddr_t)wr_ptr, 0, sizeof(*wr_ptr)); 3014 - wr_ptr->sys_pkt_addr = pci_map_single(iadev->pci, skb->data, 3015 - skb->len, PCI_DMA_TODEVICE); 3012 + wr_ptr->sys_pkt_addr = dma_map_single(&iadev->pci->dev, skb->data, 3013 + skb->len, DMA_TO_DEVICE); 3016 3014 wr_ptr->local_pkt_addr = (buf_desc_ptr->buf_start_hi << 16) | 3017 3015 buf_desc_ptr->buf_start_lo; 3018 3016 /* wr_ptr->bytes = swap_byte_order(total_len); didn't seem to affect?? */

+5 -9

drivers/atm/lanai.c

··· 346 346 * everything, but the way the lanai uses DMA memory would 347 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 351 if (buf->start != NULL) { /* Success */ 351 352 /* Lanai requires 256-byte alignment of DMA bufs */ 352 353 APRINTK((buf->dmaaddr & ~0xFFFFFF00) == 0, ··· 373 372 struct pci_dev *pci) 374 373 { 375 374 if (buf->start != NULL) { 376 - pci_free_consistent(pci, lanai_buf_size(buf), 377 - buf->start, buf->dmaaddr); 375 + dma_free_coherent(&pci->dev, lanai_buf_size(buf), 376 + buf->start, buf->dmaaddr); 378 377 buf->start = buf->end = buf->ptr = NULL; 379 378 } 380 379 } ··· 1945 1944 return -ENXIO; 1946 1945 } 1947 1946 pci_set_master(pci); 1948 - if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) != 0) { 1949 - printk(KERN_WARNING DEV_LABEL 1950 - "(itf %d): No suitable DMA available.\n", lanai->number); 1951 - return -EBUSY; 1952 - } 1953 - if (pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) != 0) { 1947 + if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32)) != 0) { 1954 1948 printk(KERN_WARNING DEV_LABEL 1955 1949 "(itf %d): No suitable DMA available.\n", lanai->number); 1956 1950 return -EBUSY;

+30 -30

drivers/atm/nicstar.c

··· 252 252 free_scq(card, card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc); 253 253 } 254 254 idr_destroy(&card->idr); 255 - pci_free_consistent(card->pcidev, NS_RSQSIZE + NS_RSQ_ALIGNMENT, 256 - card->rsq.org, card->rsq.dma); 257 - pci_free_consistent(card->pcidev, NS_TSQSIZE + NS_TSQ_ALIGNMENT, 258 - card->tsq.org, card->tsq.dma); 255 + dma_free_coherent(&card->pcidev->dev, NS_RSQSIZE + NS_RSQ_ALIGNMENT, 256 + card->rsq.org, card->rsq.dma); 257 + dma_free_coherent(&card->pcidev->dev, NS_TSQSIZE + NS_TSQ_ALIGNMENT, 258 + card->tsq.org, card->tsq.dma); 259 259 free_irq(card->pcidev->irq, card); 260 260 iounmap(card->membase); 261 261 kfree(card); ··· 370 370 ns_init_card_error(card, error); 371 371 return error; 372 372 } 373 - if ((pci_set_dma_mask(pcidev, DMA_BIT_MASK(32)) != 0) || 374 - (pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32)) != 0)) { 373 + if (dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32)) != 0) { 375 374 printk(KERN_WARNING 376 375 "nicstar%d: No suitable DMA available.\n", i); 377 376 error = 2; ··· 534 535 writel(0x00000000, card->membase + VPM); 535 536 536 537 /* Initialize TSQ */ 537 - card->tsq.org = pci_alloc_consistent(card->pcidev, 538 - NS_TSQSIZE + NS_TSQ_ALIGNMENT, 539 - &card->tsq.dma); 538 + card->tsq.org = dma_alloc_coherent(&card->pcidev->dev, 539 + NS_TSQSIZE + NS_TSQ_ALIGNMENT, 540 + &card->tsq.dma, GFP_KERNEL); 540 541 if (card->tsq.org == NULL) { 541 542 printk("nicstar%d: can't allocate TSQ.\n", i); 542 543 error = 10; ··· 553 554 PRINTK("nicstar%d: TSQ base at 0x%p.\n", i, card->tsq.base); 554 555 555 556 /* Initialize RSQ */ 556 - card->rsq.org = pci_alloc_consistent(card->pcidev, 557 - NS_RSQSIZE + NS_RSQ_ALIGNMENT, 558 - &card->rsq.dma); 557 + card->rsq.org = dma_alloc_coherent(&card->pcidev->dev, 558 + NS_RSQSIZE + NS_RSQ_ALIGNMENT, 559 + &card->rsq.dma, GFP_KERNEL); 559 560 if (card->rsq.org == NULL) { 560 561 printk("nicstar%d: can't allocate RSQ.\n", i); 561 562 error = 11; ··· 873 874 scq = kmalloc(sizeof(scq_info), GFP_KERNEL); 874 875 if (!scq) 875 876 return NULL; 876 - scq->org = pci_alloc_consistent(card->pcidev, 2 * size, &scq->dma); 877 + scq->org = dma_alloc_coherent(&card->pcidev->dev, 878 + 2 * size, &scq->dma, GFP_KERNEL); 877 879 if (!scq->org) { 878 880 kfree(scq); 879 881 return NULL; ··· 936 936 } 937 937 } 938 938 kfree(scq->skb); 939 - pci_free_consistent(card->pcidev, 940 - 2 * (scq->num_entries == VBR_SCQ_NUM_ENTRIES ? 941 - VBR_SCQSIZE : CBR_SCQSIZE), 942 - scq->org, scq->dma); 939 + dma_free_coherent(&card->pcidev->dev, 940 + 2 * (scq->num_entries == VBR_SCQ_NUM_ENTRIES ? 941 + VBR_SCQSIZE : CBR_SCQSIZE), 942 + scq->org, scq->dma); 943 943 kfree(scq); 944 944 } 945 945 ··· 957 957 handle2 = NULL; 958 958 addr2 = 0; 959 959 handle1 = skb; 960 - addr1 = pci_map_single(card->pcidev, 960 + addr1 = dma_map_single(&card->pcidev->dev, 961 961 skb->data, 962 962 (NS_PRV_BUFTYPE(skb) == BUF_SM 963 963 ? NS_SMSKBSIZE : NS_LGSKBSIZE), 964 - PCI_DMA_TODEVICE); 964 + DMA_TO_DEVICE); 965 965 NS_PRV_DMA(skb) = addr1; /* save so we can unmap later */ 966 966 967 967 #ifdef GENERAL_DEBUG ··· 1670 1670 1671 1671 ATM_SKB(skb)->vcc = vcc; 1672 1672 1673 - NS_PRV_DMA(skb) = pci_map_single(card->pcidev, skb->data, 1674 - skb->len, PCI_DMA_TODEVICE); 1673 + NS_PRV_DMA(skb) = dma_map_single(&card->pcidev->dev, skb->data, 1674 + skb->len, DMA_TO_DEVICE); 1675 1675 1676 1676 if (vcc->qos.aal == ATM_AAL5) { 1677 1677 buflen = (skb->len + 47 + 8) / 48 * 48; /* Multiple of 48 */ ··· 1930 1930 XPRINTK("nicstar%d: freeing skb at 0x%p (index %d).\n", 1931 1931 card->index, skb, i); 1932 1932 if (skb != NULL) { 1933 - pci_unmap_single(card->pcidev, 1933 + dma_unmap_single(&card->pcidev->dev, 1934 1934 NS_PRV_DMA(skb), 1935 1935 skb->len, 1936 - PCI_DMA_TODEVICE); 1936 + DMA_TO_DEVICE); 1937 1937 vcc = ATM_SKB(skb)->vcc; 1938 1938 if (vcc && vcc->pop != NULL) { 1939 1939 vcc->pop(vcc, skb); ··· 1992 1992 return; 1993 1993 } 1994 1994 idr_remove(&card->idr, id); 1995 - pci_dma_sync_single_for_cpu(card->pcidev, 1996 - NS_PRV_DMA(skb), 1997 - (NS_PRV_BUFTYPE(skb) == BUF_SM 1998 - ? NS_SMSKBSIZE : NS_LGSKBSIZE), 1999 - PCI_DMA_FROMDEVICE); 2000 - pci_unmap_single(card->pcidev, 1995 + dma_sync_single_for_cpu(&card->pcidev->dev, 1996 + NS_PRV_DMA(skb), 1997 + (NS_PRV_BUFTYPE(skb) == BUF_SM 1998 + ? NS_SMSKBSIZE : NS_LGSKBSIZE), 1999 + DMA_FROM_DEVICE); 2000 + dma_unmap_single(&card->pcidev->dev, 2001 2001 NS_PRV_DMA(skb), 2002 2002 (NS_PRV_BUFTYPE(skb) == BUF_SM 2003 2003 ? NS_SMSKBSIZE : NS_LGSKBSIZE), 2004 - PCI_DMA_FROMDEVICE); 2004 + DMA_FROM_DEVICE); 2005 2005 vpi = ns_rsqe_vpi(rsqe); 2006 2006 vci = ns_rsqe_vci(rsqe); 2007 2007 if (vpi >= 1UL << card->vpibits || vci >= 1UL << card->vcibits) {

+13 -13

drivers/atm/solos-pci.c

··· 785 785 skb = card->rx_skb[port]; 786 786 card->rx_skb[port] = NULL; 787 787 788 - pci_unmap_single(card->dev, SKB_CB(skb)->dma_addr, 789 - RX_DMA_SIZE, PCI_DMA_FROMDEVICE); 788 + dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, 789 + RX_DMA_SIZE, DMA_FROM_DEVICE); 790 790 791 791 header = (void *)skb->data; 792 792 size = le16_to_cpu(header->size); ··· 872 872 struct sk_buff *skb = alloc_skb(RX_DMA_SIZE, GFP_ATOMIC); 873 873 if (skb) { 874 874 SKB_CB(skb)->dma_addr = 875 - pci_map_single(card->dev, skb->data, 876 - RX_DMA_SIZE, PCI_DMA_FROMDEVICE); 875 + dma_map_single(&card->dev->dev, skb->data, 876 + RX_DMA_SIZE, DMA_FROM_DEVICE); 877 877 iowrite32(SKB_CB(skb)->dma_addr, 878 878 card->config_regs + RX_DMA_ADDR(port)); 879 879 card->rx_skb[port] = skb; ··· 1069 1069 if (tx_pending & 1) { 1070 1070 struct sk_buff *oldskb = card->tx_skb[port]; 1071 1071 if (oldskb) { 1072 - pci_unmap_single(card->dev, SKB_CB(oldskb)->dma_addr, 1073 - oldskb->len, PCI_DMA_TODEVICE); 1072 + dma_unmap_single(&card->dev->dev, SKB_CB(oldskb)->dma_addr, 1073 + oldskb->len, DMA_TO_DEVICE); 1074 1074 card->tx_skb[port] = NULL; 1075 1075 } 1076 1076 spin_lock(&card->tx_queue_lock); ··· 1089 1089 data = card->dma_bounce + (BUF_SIZE * port); 1090 1090 memcpy(data, skb->data, skb->len); 1091 1091 } 1092 - SKB_CB(skb)->dma_addr = pci_map_single(card->dev, data, 1093 - skb->len, PCI_DMA_TODEVICE); 1092 + SKB_CB(skb)->dma_addr = dma_map_single(&card->dev->dev, data, 1093 + skb->len, DMA_TO_DEVICE); 1094 1094 card->tx_skb[port] = skb; 1095 1095 iowrite32(SKB_CB(skb)->dma_addr, 1096 1096 card->config_regs + TX_DMA_ADDR(port)); ··· 1210 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 1214 if (err) { 1215 1215 dev_warn(&dev->dev, "Failed to set 32-bit DMA mask\n"); 1216 1216 goto out; ··· 1411 1411 1412 1412 skb = card->rx_skb[i]; 1413 1413 if (skb) { 1414 - pci_unmap_single(card->dev, SKB_CB(skb)->dma_addr, 1415 - RX_DMA_SIZE, PCI_DMA_FROMDEVICE); 1414 + dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, 1415 + RX_DMA_SIZE, DMA_FROM_DEVICE); 1416 1416 dev_kfree_skb(skb); 1417 1417 } 1418 1418 skb = card->tx_skb[i]; 1419 1419 if (skb) { 1420 - pci_unmap_single(card->dev, SKB_CB(skb)->dma_addr, 1421 - skb->len, PCI_DMA_TODEVICE); 1420 + dma_unmap_single(&card->dev->dev, SKB_CB(skb)->dma_addr, 1421 + skb->len, DMA_TO_DEVICE); 1422 1422 dev_kfree_skb(skb); 1423 1423 } 1424 1424 while ((skb = skb_dequeue(&card->tx_queue[i])))

+11 -6

drivers/atm/zatm.c

··· 1306 1306 1307 1307 if (!mbx_entries[i]) 1308 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 1311 if (!mbx) { 1311 1312 error = -ENOMEM; 1312 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 1317 * for this device. 1317 1318 */ 1318 1319 if (((unsigned long)mbx ^ mbx_dma) & 0xffff) { 1319 1320 printk(KERN_ERR DEV_LABEL "(itf %d): system " 1320 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 1323 error = -ENODEV; 1323 1324 goto out; 1324 1325 } ··· 1355 1354 kfree(zatm_dev->tx_map); 1356 1355 out: 1357 1356 while (i-- > 0) { 1358 - pci_free_consistent(pdev, 2*MBX_SIZE(i), 1359 - (void *)zatm_dev->mbx_start[i], 1360 - zatm_dev->mbx_dma[i]); 1357 + dma_free_coherent(&pdev->dev, 2 * MBX_SIZE(i), 1358 + (void *)zatm_dev->mbx_start[i], 1359 + zatm_dev->mbx_dma[i]); 1361 1360 } 1362 1361 free_irq(zatm_dev->irq, dev); 1363 1362 goto done; ··· 1606 1605 goto out_deregister; 1607 1606 1608 1607 ret = pci_request_regions(pci_dev, DEV_LABEL); 1608 + if (ret < 0) 1609 + goto out_disable; 1610 + 1611 + ret = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)); 1609 1612 if (ret < 0) 1610 1613 goto out_disable; 1611 1614