tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[netdrvr] use dev_xxx() printk helpers, rather than dev_printk(KERN_xxx, ...

Suggested by Jiri Slaby.

Signed-off-by: Jeff Garzik <jeff@garzik.org>

Jeff Garzik 9b91cf9d 2e8a538d

+88 -134
+7 -10
drivers/net/8139cp.c
··· 1836 1836 1837 1837 if (pdev->vendor == PCI_VENDOR_ID_REALTEK && 1838 1838 pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev < 0x20) { 1839 - dev_printk(KERN_ERR, &pdev->dev, 1839 + dev_err(&pdev->dev, 1840 1840 "This (id %04x:%04x rev %02x) is not an 8139C+ compatible chip\n", 1841 1841 pdev->vendor, pdev->device, pci_rev); 1842 - dev_printk(KERN_ERR, &pdev->dev, 1843 - "Try the \"8139too\" driver instead.\n"); 1842 + dev_err(&pdev->dev, "Try the \"8139too\" driver instead.\n"); 1844 1843 return -ENODEV; 1845 1844 } 1846 1845 ··· 1877 1878 pciaddr = pci_resource_start(pdev, 1); 1878 1879 if (!pciaddr) { 1879 1880 rc = -EIO; 1880 - dev_printk(KERN_ERR, &pdev->dev, "no MMIO resource\n"); 1881 + dev_err(&pdev->dev, "no MMIO resource\n"); 1881 1882 goto err_out_res; 1882 1883 } 1883 1884 if (pci_resource_len(pdev, 1) < CP_REGS_SIZE) { 1884 1885 rc = -EIO; 1885 - dev_printk(KERN_ERR, &pdev->dev, 1886 - "MMIO resource (%llx) too small\n", 1886 + dev_err(&pdev->dev, "MMIO resource (%llx) too small\n", 1887 1887 (unsigned long long)pci_resource_len(pdev, 1)); 1888 1888 goto err_out_res; 1889 1889 } ··· 1897 1899 1898 1900 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); 1899 1901 if (rc) { 1900 - dev_printk(KERN_ERR, &pdev->dev, 1902 + dev_err(&pdev->dev, 1901 1903 "No usable DMA configuration, aborting.\n"); 1902 1904 goto err_out_res; 1903 1905 } 1904 1906 rc = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK); 1905 1907 if (rc) { 1906 - dev_printk(KERN_ERR, &pdev->dev, 1908 + dev_err(&pdev->dev, 1907 1909 "No usable consistent DMA configuration, " 1908 1910 "aborting.\n"); 1909 1911 goto err_out_res; ··· 1916 1918 regs = ioremap(pciaddr, CP_REGS_SIZE); 1917 1919 if (!regs) { 1918 1920 rc = -EIO; 1919 - dev_printk(KERN_ERR, &pdev->dev, 1920 - "Cannot map PCI MMIO (%llx@%llx)\n", 1921 + dev_err(&pdev->dev, "Cannot map PCI MMIO (%lx@%lx)\n", 1921 1922 (unsigned long long)pci_resource_len(pdev, 1), 1922 1923 (unsigned long long)pciaddr); 1923 1924 goto err_out_res;
+10 -17
drivers/net/8139too.c
··· 768 768 /* dev and priv zeroed in alloc_etherdev */ 769 769 dev = alloc_etherdev (sizeof (*tp)); 770 770 if (dev == NULL) { 771 - dev_printk (KERN_ERR, &pdev->dev, 772 - "Unable to alloc new net device\n"); 771 + dev_err(&pdev->dev, "Unable to alloc new net device\n"); 773 772 return -ENOMEM; 774 773 } 775 774 SET_MODULE_OWNER(dev); ··· 800 801 #ifdef USE_IO_OPS 801 802 /* make sure PCI base addr 0 is PIO */ 802 803 if (!(pio_flags & IORESOURCE_IO)) { 803 - dev_printk (KERN_ERR, &pdev->dev, 804 - "region #0 not a PIO resource, aborting\n"); 804 + dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n"); 805 805 rc = -ENODEV; 806 806 goto err_out; 807 807 } 808 808 /* check for weird/broken PCI region reporting */ 809 809 if (pio_len < RTL_MIN_IO_SIZE) { 810 - dev_printk (KERN_ERR, &pdev->dev, 811 - "Invalid PCI I/O region size(s), aborting\n"); 810 + dev_err(&pdev->dev, "Invalid PCI I/O region size(s), aborting\n"); 812 811 rc = -ENODEV; 813 812 goto err_out; 814 813 } 815 814 #else 816 815 /* make sure PCI base addr 1 is MMIO */ 817 816 if (!(mmio_flags & IORESOURCE_MEM)) { 818 - dev_printk (KERN_ERR, &pdev->dev, 819 - "region #1 not an MMIO resource, aborting\n"); 817 + dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n"); 820 818 rc = -ENODEV; 821 819 goto err_out; 822 820 } 823 821 if (mmio_len < RTL_MIN_IO_SIZE) { 824 - dev_printk (KERN_ERR, &pdev->dev, 825 - "Invalid PCI mem region size(s), aborting\n"); 822 + dev_err(&pdev->dev, "Invalid PCI mem region size(s), aborting\n"); 826 823 rc = -ENODEV; 827 824 goto err_out; 828 825 } ··· 835 840 #ifdef USE_IO_OPS 836 841 ioaddr = ioport_map(pio_start, pio_len); 837 842 if (!ioaddr) { 838 - dev_printk (KERN_ERR, &pdev->dev, "cannot map PIO, aborting\n"); 843 + dev_err(&pdev->dev, "cannot map PIO, aborting\n"); 839 844 rc = -EIO; 840 845 goto err_out; 841 846 } ··· 846 851 /* ioremap MMIO region */ 847 852 ioaddr = pci_iomap(pdev, 1, 0); 848 853 if (ioaddr == NULL) { 849 - dev_printk (KERN_ERR, &pdev->dev, 850 - "cannot remap MMIO, aborting\n"); 854 + dev_err(&pdev->dev, "cannot remap MMIO, aborting\n"); 851 855 rc = -EIO; 852 856 goto err_out; 853 857 } ··· 860 866 861 867 /* check for missing/broken hardware */ 862 868 if (RTL_R32 (TxConfig) == 0xFFFFFFFF) { 863 - dev_printk (KERN_ERR, &pdev->dev, 864 - "Chip not responding, ignoring board\n"); 869 + dev_err(&pdev->dev, "Chip not responding, ignoring board\n"); 865 870 rc = -EIO; 866 871 goto err_out; 867 872 } ··· 954 961 955 962 if (pdev->vendor == PCI_VENDOR_ID_REALTEK && 956 963 pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev >= 0x20) { 957 - dev_printk(KERN_INFO, &pdev->dev, 964 + dev_info(&pdev->dev, 958 965 "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip\n", 959 966 pdev->vendor, pdev->device, pci_rev); 960 - dev_printk(KERN_INFO, &pdev->dev, 967 + dev_info(&pdev->dev, 961 968 "Use the \"8139cp\" driver for improved performance and stability.\n"); 962 969 } 963 970
+9 -14
drivers/net/b44.c
··· 2120 2120 2121 2121 err = pci_enable_device(pdev); 2122 2122 if (err) { 2123 - dev_printk(KERN_ERR, &pdev->dev, "Cannot enable PCI device, " 2123 + dev_err(&pdev->dev, "Cannot enable PCI device, " 2124 2124 "aborting.\n"); 2125 2125 return err; 2126 2126 } 2127 2127 2128 2128 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 2129 - dev_printk(KERN_ERR, &pdev->dev, 2129 + dev_err(&pdev->dev, 2130 2130 "Cannot find proper PCI device " 2131 2131 "base address, aborting.\n"); 2132 2132 err = -ENODEV; ··· 2135 2135 2136 2136 err = pci_request_regions(pdev, DRV_MODULE_NAME); 2137 2137 if (err) { 2138 - dev_printk(KERN_ERR, &pdev->dev, 2138 + dev_err(&pdev->dev, 2139 2139 "Cannot obtain PCI resources, aborting.\n"); 2140 2140 goto err_out_disable_pdev; 2141 2141 } ··· 2144 2144 2145 2145 err = pci_set_dma_mask(pdev, (u64) B44_DMA_MASK); 2146 2146 if (err) { 2147 - dev_printk(KERN_ERR, &pdev->dev, 2148 - "No usable DMA configuration, aborting.\n"); 2147 + dev_err(&pdev->dev, "No usable DMA configuration, aborting.\n"); 2149 2148 goto err_out_free_res; 2150 2149 } 2151 2150 2152 2151 err = pci_set_consistent_dma_mask(pdev, (u64) B44_DMA_MASK); 2153 2152 if (err) { 2154 - dev_printk(KERN_ERR, &pdev->dev, 2155 - "No usable DMA configuration, aborting.\n"); 2153 + dev_err(&pdev->dev, "No usable DMA configuration, aborting.\n"); 2156 2154 goto err_out_free_res; 2157 2155 } 2158 2156 ··· 2159 2161 2160 2162 dev = alloc_etherdev(sizeof(*bp)); 2161 2163 if (!dev) { 2162 - dev_printk(KERN_ERR, &pdev->dev, 2163 - "Etherdev alloc failed, aborting.\n"); 2164 + dev_err(&pdev->dev, "Etherdev alloc failed, aborting.\n"); 2164 2165 err = -ENOMEM; 2165 2166 goto err_out_free_res; 2166 2167 } ··· 2180 2183 2181 2184 bp->regs = ioremap(b44reg_base, b44reg_len); 2182 2185 if (bp->regs == 0UL) { 2183 - dev_printk(KERN_ERR, &pdev->dev, "Cannot map device registers, " 2184 - "aborting.\n"); 2186 + dev_err(&pdev->dev, "Cannot map device registers, aborting.\n"); 2185 2187 err = -ENOMEM; 2186 2188 goto err_out_free_dev; 2187 2189 } ··· 2210 2214 2211 2215 err = b44_get_invariants(bp); 2212 2216 if (err) { 2213 - dev_printk(KERN_ERR, &pdev->dev, 2217 + dev_err(&pdev->dev, 2214 2218 "Problem fetching invariants of chip, aborting.\n"); 2215 2219 goto err_out_iounmap; 2216 2220 } ··· 2231 2235 2232 2236 err = register_netdev(dev); 2233 2237 if (err) { 2234 - dev_printk(KERN_ERR, &pdev->dev, "Cannot register net device, " 2235 - "aborting.\n"); 2238 + dev_err(&pdev->dev, "Cannot register net device, aborting.\n"); 2236 2239 goto err_out_iounmap; 2237 2240 } 2238 2241
+11 -18
drivers/net/bnx2.c
··· 5575 5575 /* enable device (incl. PCI PM wakeup), and bus-mastering */ 5576 5576 rc = pci_enable_device(pdev); 5577 5577 if (rc) { 5578 - dev_printk(KERN_ERR, &pdev->dev, 5579 - "Cannot enable PCI device, aborting."); 5578 + dev_err(&pdev->dev, "Cannot enable PCI device, aborting."); 5580 5579 goto err_out; 5581 5580 } 5582 5581 5583 5582 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 5584 - dev_printk(KERN_ERR, &pdev->dev, 5583 + dev_err(&pdev->dev, 5585 5584 "Cannot find PCI device base address, aborting.\n"); 5586 5585 rc = -ENODEV; 5587 5586 goto err_out_disable; ··· 5588 5589 5589 5590 rc = pci_request_regions(pdev, DRV_MODULE_NAME); 5590 5591 if (rc) { 5591 - dev_printk(KERN_ERR, &pdev->dev, 5592 - "Cannot obtain PCI resources, aborting.\n"); 5592 + dev_err(&pdev->dev, "Cannot obtain PCI resources, aborting.\n"); 5593 5593 goto err_out_disable; 5594 5594 } 5595 5595 ··· 5596 5598 5597 5599 bp->pm_cap = pci_find_capability(pdev, PCI_CAP_ID_PM); 5598 5600 if (bp->pm_cap == 0) { 5599 - dev_printk(KERN_ERR, &pdev->dev, 5601 + dev_err(&pdev->dev, 5600 5602 "Cannot find power management capability, aborting.\n"); 5601 5603 rc = -EIO; 5602 5604 goto err_out_release; ··· 5604 5606 5605 5607 bp->pcix_cap = pci_find_capability(pdev, PCI_CAP_ID_PCIX); 5606 5608 if (bp->pcix_cap == 0) { 5607 - dev_printk(KERN_ERR, &pdev->dev, 5608 - "Cannot find PCIX capability, aborting.\n"); 5609 + dev_err(&pdev->dev, "Cannot find PCIX capability, aborting.\n"); 5609 5610 rc = -EIO; 5610 5611 goto err_out_release; 5611 5612 } ··· 5612 5615 if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) == 0) { 5613 5616 bp->flags |= USING_DAC_FLAG; 5614 5617 if (pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK) != 0) { 5615 - dev_printk(KERN_ERR, &pdev->dev, 5618 + dev_err(&pdev->dev, 5616 5619 "pci_set_consistent_dma_mask failed, aborting.\n"); 5617 5620 rc = -EIO; 5618 5621 goto err_out_release; 5619 5622 } 5620 5623 } 5621 5624 else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0) { 5622 - dev_printk(KERN_ERR, &pdev->dev, 5623 - "System does not support DMA, aborting.\n"); 5625 + dev_err(&pdev->dev, "System does not support DMA, aborting.\n"); 5624 5626 rc = -EIO; 5625 5627 goto err_out_release; 5626 5628 } ··· 5639 5643 bp->regview = ioremap_nocache(dev->base_addr, mem_len); 5640 5644 5641 5645 if (!bp->regview) { 5642 - dev_printk(KERN_ERR, &pdev->dev, 5643 - "Cannot map register space, aborting.\n"); 5646 + dev_err(&pdev->dev, "Cannot map register space, aborting.\n"); 5644 5647 rc = -ENOMEM; 5645 5648 goto err_out_release; 5646 5649 } ··· 5711 5716 else if ((CHIP_ID(bp) == CHIP_ID_5706_A1) && 5712 5717 !(bp->flags & PCIX_FLAG)) { 5713 5718 5714 - dev_printk(KERN_ERR, &pdev->dev, 5719 + dev_err(&pdev->dev, 5715 5720 "5706 A1 can only be used in a PCIX bus, aborting.\n"); 5716 5721 goto err_out_unmap; 5717 5722 } ··· 5733 5738 5734 5739 if ((reg & BNX2_DEV_INFO_SIGNATURE_MAGIC_MASK) != 5735 5740 BNX2_DEV_INFO_SIGNATURE_MAGIC) { 5736 - dev_printk(KERN_ERR, &pdev->dev, 5737 - "Firmware not running, aborting.\n"); 5741 + dev_err(&pdev->dev, "Firmware not running, aborting.\n"); 5738 5742 rc = -ENODEV; 5739 5743 goto err_out_unmap; 5740 5744 } ··· 5895 5901 #endif 5896 5902 5897 5903 if ((rc = register_netdev(dev))) { 5898 - dev_printk(KERN_ERR, &pdev->dev, 5899 - "Cannot register net device\n"); 5904 + dev_err(&pdev->dev, "Cannot register net device\n"); 5900 5905 if (bp->regview) 5901 5906 iounmap(bp->regview); 5902 5907 pci_release_regions(pdev);
+10 -15
drivers/net/cassini.c
··· 4887 4887 4888 4888 err = pci_enable_device(pdev); 4889 4889 if (err) { 4890 - dev_printk(KERN_ERR, &pdev->dev, "Cannot enable PCI device, " 4891 - "aborting.\n"); 4890 + dev_err(&pdev->dev, "Cannot enable PCI device, aborting.\n"); 4892 4891 return err; 4893 4892 } 4894 4893 4895 4894 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 4896 - dev_printk(KERN_ERR, &pdev->dev, "Cannot find proper PCI device " 4895 + dev_err(&pdev->dev, "Cannot find proper PCI device " 4897 4896 "base address, aborting.\n"); 4898 4897 err = -ENODEV; 4899 4898 goto err_out_disable_pdev; ··· 4900 4901 4901 4902 dev = alloc_etherdev(sizeof(*cp)); 4902 4903 if (!dev) { 4903 - dev_printk(KERN_ERR, &pdev->dev, "Etherdev alloc failed, aborting.\n"); 4904 + dev_err(&pdev->dev, "Etherdev alloc failed, aborting.\n"); 4904 4905 err = -ENOMEM; 4905 4906 goto err_out_disable_pdev; 4906 4907 } ··· 4909 4910 4910 4911 err = pci_request_regions(pdev, dev->name); 4911 4912 if (err) { 4912 - dev_printk(KERN_ERR, &pdev->dev, "Cannot obtain PCI resources, " 4913 - "aborting.\n"); 4913 + dev_err(&pdev->dev, "Cannot obtain PCI resources, aborting.\n"); 4914 4914 goto err_out_free_netdev; 4915 4915 } 4916 4916 pci_set_master(pdev); ··· 4939 4941 if (pci_write_config_byte(pdev, 4940 4942 PCI_CACHE_LINE_SIZE, 4941 4943 cas_cacheline_size)) { 4942 - dev_printk(KERN_ERR, &pdev->dev, "Could not set PCI cache " 4944 + dev_err(&pdev->dev, "Could not set PCI cache " 4943 4945 "line size\n"); 4944 4946 goto err_write_cacheline; 4945 4947 } ··· 4953 4955 err = pci_set_consistent_dma_mask(pdev, 4954 4956 DMA_64BIT_MASK); 4955 4957 if (err < 0) { 4956 - dev_printk(KERN_ERR, &pdev->dev, "Unable to obtain 64-bit DMA " 4958 + dev_err(&pdev->dev, "Unable to obtain 64-bit DMA " 4957 4959 "for consistent allocations\n"); 4958 4960 goto err_out_free_res; 4959 4961 } ··· 4961 4963 } else { 4962 4964 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK); 4963 4965 if (err) { 4964 - dev_printk(KERN_ERR, &pdev->dev, "No usable DMA configuration, " 4966 + dev_err(&pdev->dev, "No usable DMA configuration, " 4965 4967 "aborting.\n"); 4966 4968 goto err_out_free_res; 4967 4969 } ··· 5021 5023 /* give us access to cassini registers */ 5022 5024 cp->regs = pci_iomap(pdev, 0, casreg_len); 5023 5025 if (cp->regs == 0UL) { 5024 - dev_printk(KERN_ERR, &pdev->dev, "Cannot map device registers, " 5025 - "aborting.\n"); 5026 + dev_err(&pdev->dev, "Cannot map device registers, aborting.\n"); 5026 5027 goto err_out_free_res; 5027 5028 } 5028 5029 cp->casreg_len = casreg_len; ··· 5037 5040 pci_alloc_consistent(pdev, sizeof(struct cas_init_block), 5038 5041 &cp->block_dvma); 5039 5042 if (!cp->init_block) { 5040 - dev_printk(KERN_ERR, &pdev->dev, "Cannot allocate init block, " 5041 - "aborting.\n"); 5043 + dev_err(&pdev->dev, "Cannot allocate init block, aborting.\n"); 5042 5044 goto err_out_iounmap; 5043 5045 } 5044 5046 ··· 5081 5085 dev->features |= NETIF_F_HIGHDMA; 5082 5086 5083 5087 if (register_netdev(dev)) { 5084 - dev_printk(KERN_ERR, &pdev->dev, "Cannot register net device, " 5085 - "aborting.\n"); 5088 + dev_err(&pdev->dev, "Cannot register net device, aborting.\n"); 5086 5089 goto err_out_free_consistent; 5087 5090 } 5088 5091
+3 -5
drivers/net/eepro100.c
··· 555 555 556 556 if (!request_region(pci_resource_start(pdev, 1), 557 557 pci_resource_len(pdev, 1), "eepro100")) { 558 - dev_printk (KERN_ERR, &pdev->dev, 559 - "eepro100: cannot reserve I/O ports\n"); 558 + dev_err(&pdev->dev, "eepro100: cannot reserve I/O ports\n"); 560 559 goto err_out_none; 561 560 } 562 561 if (!request_mem_region(pci_resource_start(pdev, 0), 563 562 pci_resource_len(pdev, 0), "eepro100")) { 564 - dev_printk (KERN_ERR, &pdev->dev, 565 - "eepro100: cannot reserve MMIO region\n"); 563 + dev_err(&pdev->dev, "eepro100: cannot reserve MMIO region\n"); 566 564 goto err_out_free_pio_region; 567 565 } 568 566 ··· 573 575 574 576 ioaddr = pci_iomap(pdev, pci_bar, 0); 575 577 if (!ioaddr) { 576 - dev_printk (KERN_ERR, &pdev->dev, "eepro100: cannot remap IO\n"); 578 + dev_err(&pdev->dev, "eepro100: cannot remap IO\n"); 577 579 goto err_out_free_mmio_region; 578 580 } 579 581
+7 -8
drivers/net/epic100.c
··· 335 335 irq = pdev->irq; 336 336 337 337 if (pci_resource_len(pdev, 0) < EPIC_TOTAL_SIZE) { 338 - dev_printk(KERN_ERR, &pdev->dev, "no PCI region space\n"); 338 + dev_err(&pdev->dev, "no PCI region space\n"); 339 339 ret = -ENODEV; 340 340 goto err_out_disable; 341 341 } ··· 350 350 351 351 dev = alloc_etherdev(sizeof (*ep)); 352 352 if (!dev) { 353 - dev_printk(KERN_ERR, &pdev->dev, "no memory for eth device\n"); 353 + dev_err(&pdev->dev, "no memory for eth device\n"); 354 354 goto err_out_free_res; 355 355 } 356 356 SET_MODULE_OWNER(dev); ··· 362 362 ioaddr = pci_resource_start (pdev, 1); 363 363 ioaddr = (long) ioremap (ioaddr, pci_resource_len (pdev, 1)); 364 364 if (!ioaddr) { 365 - dev_printk(KERN_ERR, &pdev->dev, "ioremap failed\n"); 365 + dev_err(&pdev->dev, "ioremap failed\n"); 366 366 goto err_out_free_netdev; 367 367 } 368 368 #endif ··· 444 444 int mii_status = mdio_read(dev, phy, MII_BMSR); 445 445 if (mii_status != 0xffff && mii_status != 0x0000) { 446 446 ep->phys[phy_idx++] = phy; 447 - dev_printk(KERN_INFO, &pdev->dev, 447 + dev_info(&pdev->dev, 448 448 "MII transceiver #%d control " 449 449 "%4.4x status %4.4x.\n", 450 450 phy, mdio_read(dev, phy, 0), mii_status); ··· 454 454 if (phy_idx != 0) { 455 455 phy = ep->phys[0]; 456 456 ep->mii.advertising = mdio_read(dev, phy, MII_ADVERTISE); 457 - dev_printk(KERN_INFO, &pdev->dev, 457 + dev_info(&pdev->dev, 458 458 "Autonegotiation advertising %4.4x link " 459 459 "partner %4.4x.\n", 460 460 ep->mii.advertising, mdio_read(dev, phy, 5)); 461 461 } else if ( ! (ep->chip_flags & NO_MII)) { 462 - dev_printk(KERN_WARNING, &pdev->dev, 462 + dev_warn(&pdev->dev, 463 463 "***WARNING***: No MII transceiver found!\n"); 464 464 /* Use the known PHY address of the EPII. */ 465 465 ep->phys[0] = 3; ··· 475 475 /* The lower four bits are the media type. */ 476 476 if (duplex) { 477 477 ep->mii.force_media = ep->mii.full_duplex = 1; 478 - dev_printk(KERN_INFO, &pdev->dev, 479 - "Forced full duplex operation requested.\n"); 478 + dev_info(&pdev->dev, "Forced full duplex requested.\n"); 480 479 } 481 480 dev->if_port = ep->default_port = option; 482 481
+4 -5
drivers/net/fealnx.c
··· 505 505 506 506 len = pci_resource_len(pdev, bar); 507 507 if (len < MIN_REGION_SIZE) { 508 - dev_printk(KERN_ERR, &pdev->dev, 508 + dev_err(&pdev->dev, 509 509 "region size %ld too small, aborting\n", len); 510 510 return -ENODEV; 511 511 } ··· 578 578 579 579 if (mii_status != 0xffff && mii_status != 0x0000) { 580 580 np->phys[phy_idx++] = phy; 581 - dev_printk(KERN_INFO, &pdev->dev, 581 + dev_info(&pdev->dev, 582 582 "MII PHY found at address %d, status " 583 583 "0x%4.4x.\n", phy, mii_status); 584 584 /* get phy type */ ··· 604 604 605 605 np->mii_cnt = phy_idx; 606 606 if (phy_idx == 0) 607 - dev_printk(KERN_WARNING, &pdev->dev, 607 + dev_warn(&pdev->dev, 608 608 "MII PHY not found -- this device may " 609 609 "not operate correctly.\n"); 610 610 } else { ··· 632 632 np->mii.full_duplex = full_duplex[card_idx]; 633 633 634 634 if (np->mii.full_duplex) { 635 - dev_printk(KERN_INFO, &pdev->dev, 636 - "Media type forced to Full Duplex.\n"); 635 + dev_info(&pdev->dev, "Media type forced to Full Duplex.\n"); 637 636 /* 89/6/13 add, (begin) */ 638 637 // if (np->PHYType==MarvellPHY) 639 638 if ((np->PHYType == MarvellPHY) || (np->PHYType == LevelOnePHY)) {
+4 -7
drivers/net/ne2k-pci.c
··· 231 231 irq = pdev->irq; 232 232 233 233 if (!ioaddr || ((pci_resource_flags (pdev, 0) & IORESOURCE_IO) == 0)) { 234 - dev_printk (KERN_ERR, &pdev->dev, 235 - "no I/O resource at PCI BAR #0\n"); 234 + dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n"); 236 235 return -ENODEV; 237 236 } 238 237 239 238 if (request_region (ioaddr, NE_IO_EXTENT, DRV_NAME) == NULL) { 240 - dev_printk (KERN_ERR, &pdev->dev, 241 - "I/O resource 0x%x @ 0x%lx busy\n", 239 + dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n", 242 240 NE_IO_EXTENT, ioaddr); 243 241 return -EBUSY; 244 242 } ··· 263 265 /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */ 264 266 dev = alloc_ei_netdev(); 265 267 if (!dev) { 266 - dev_printk (KERN_ERR, &pdev->dev, 267 - "cannot allocate ethernet device\n"); 268 + dev_err(&pdev->dev, "cannot allocate ethernet device\n"); 268 269 goto err_out_free_res; 269 270 } 270 271 SET_MODULE_OWNER(dev); ··· 281 284 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0) 282 285 /* Limit wait: '2' avoids jiffy roll-over. */ 283 286 if (jiffies - reset_start_time > 2) { 284 - dev_printk(KERN_ERR, &pdev->dev, 287 + dev_err(&pdev->dev, 285 288 "Card failure (no reset ack).\n"); 286 289 goto err_out_free_netdev; 287 290 }
+4 -8
drivers/net/ns83820.c
··· 1832 1832 } else if (!pci_set_dma_mask(pci_dev, DMA_32BIT_MASK)) { 1833 1833 using_dac = 0; 1834 1834 } else { 1835 - dev_printk(KERN_WARNING, &pci_dev->dev, 1836 - "pci_set_dma_mask failed!\n"); 1835 + dev_warn(&pci_dev->dev, "pci_set_dma_mask failed!\n"); 1837 1836 return -ENODEV; 1838 1837 } 1839 1838 ··· 1855 1856 1856 1857 err = pci_enable_device(pci_dev); 1857 1858 if (err) { 1858 - dev_printk(KERN_INFO, &pci_dev->dev, 1859 - "pci_enable_dev failed: %d\n", err); 1859 + dev_info(&pci_dev->dev, "pci_enable_dev failed: %d\n", err); 1860 1860 goto out_free; 1861 1861 } 1862 1862 ··· 1884 1886 err = request_irq(pci_dev->irq, ns83820_irq, IRQF_SHARED, 1885 1887 DRV_NAME, ndev); 1886 1888 if (err) { 1887 - dev_printk(KERN_INFO, &pci_dev->dev, 1888 - "unable to register irq %d, err %d\n", 1889 + dev_info(&pci_dev->dev, "unable to register irq %d, err %d\n", 1889 1890 pci_dev->irq, err); 1890 1891 goto out_disable; 1891 1892 } ··· 1899 1902 rtnl_lock(); 1900 1903 err = dev_alloc_name(ndev, ndev->name); 1901 1904 if (err < 0) { 1902 - dev_printk(KERN_INFO, &pci_dev->dev, 1903 - "unable to get netdev name: %d\n", err); 1905 + dev_info(&pci_dev->dev, "unable to get netdev name: %d\n", err); 1904 1906 goto out_free_irq; 1905 1907 } 1906 1908
+5 -10
drivers/net/pci-skeleton.c
··· 601 601 /* dev zeroed in alloc_etherdev */ 602 602 dev = alloc_etherdev (sizeof (*tp)); 603 603 if (dev == NULL) { 604 - dev_printk (KERN_ERR, &pdev->dev, 605 - "unable to alloc new ethernet\n"); 604 + dev_err(&pdev->dev, "unable to alloc new ethernet\n"); 606 605 DPRINTK ("EXIT, returning -ENOMEM\n"); 607 606 return -ENOMEM; 608 607 } ··· 631 632 632 633 /* make sure PCI base addr 0 is PIO */ 633 634 if (!(pio_flags & IORESOURCE_IO)) { 634 - dev_printk (KERN_ERR, &pdev->dev, 635 - "region #0 not a PIO resource, aborting\n"); 635 + dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n"); 636 636 rc = -ENODEV; 637 637 goto err_out; 638 638 } 639 639 640 640 /* make sure PCI base addr 1 is MMIO */ 641 641 if (!(mmio_flags & IORESOURCE_MEM)) { 642 - dev_printk (KERN_ERR, &pdev->dev, 643 - "region #1 not an MMIO resource, aborting\n"); 642 + dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n"); 644 643 rc = -ENODEV; 645 644 goto err_out; 646 645 } ··· 646 649 /* check for weird/broken PCI region reporting */ 647 650 if ((pio_len < NETDRV_MIN_IO_SIZE) || 648 651 (mmio_len < NETDRV_MIN_IO_SIZE)) { 649 - dev_printk (KERN_ERR, &pdev->dev, 650 - "Invalid PCI region size(s), aborting\n"); 652 + dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n"); 651 653 rc = -ENODEV; 652 654 goto err_out; 653 655 } ··· 663 667 /* ioremap MMIO region */ 664 668 ioaddr = ioremap (mmio_start, mmio_len); 665 669 if (ioaddr == NULL) { 666 - dev_printk (KERN_ERR, &pdev->dev, 667 - "cannot remap MMIO, aborting\n"); 670 + dev_err(&pdev->dev, "cannot remap MMIO, aborting\n"); 668 671 rc = -EIO; 669 672 goto err_out_free_res; 670 673 }
+8 -11
drivers/net/r8169.c
··· 1406 1406 dev = alloc_etherdev(sizeof (*tp)); 1407 1407 if (dev == NULL) { 1408 1408 if (netif_msg_drv(&debug)) 1409 - dev_printk(KERN_ERR, &pdev->dev, 1410 - "unable to alloc new ethernet\n"); 1409 + dev_err(&pdev->dev, "unable to alloc new ethernet\n"); 1411 1410 goto err_out; 1412 1411 } 1413 1412 ··· 1419 1420 rc = pci_enable_device(pdev); 1420 1421 if (rc < 0) { 1421 1422 if (netif_msg_probe(tp)) 1422 - dev_printk(KERN_ERR, &pdev->dev, "enable failure\n"); 1423 + dev_err(&pdev->dev, "enable failure\n"); 1423 1424 goto err_out_free_dev; 1424 1425 } 1425 1426 ··· 1436 1437 acpi_idle_state = pwr_command & PCI_PM_CTRL_STATE_MASK; 1437 1438 } else { 1438 1439 if (netif_msg_probe(tp)) 1439 - dev_printk(KERN_ERR, &pdev->dev, 1440 + dev_err(&pdev->dev, 1440 1441 "PowerManagement capability not found.\n"); 1441 1442 } 1442 1443 1443 1444 /* make sure PCI base addr 1 is MMIO */ 1444 1445 if (!(pci_resource_flags(pdev, 1) & IORESOURCE_MEM)) { 1445 1446 if (netif_msg_probe(tp)) 1446 - dev_printk(KERN_ERR, &pdev->dev, 1447 + dev_err(&pdev->dev, 1447 1448 "region #1 not an MMIO resource, aborting\n"); 1448 1449 rc = -ENODEV; 1449 1450 goto err_out_mwi; ··· 1451 1452 /* check for weird/broken PCI region reporting */ 1452 1453 if (pci_resource_len(pdev, 1) < R8169_REGS_SIZE) { 1453 1454 if (netif_msg_probe(tp)) 1454 - dev_printk(KERN_ERR, &pdev->dev, 1455 + dev_err(&pdev->dev, 1455 1456 "Invalid PCI region size(s), aborting\n"); 1456 1457 rc = -ENODEV; 1457 1458 goto err_out_mwi; ··· 1460 1461 rc = pci_request_regions(pdev, MODULENAME); 1461 1462 if (rc < 0) { 1462 1463 if (netif_msg_probe(tp)) 1463 - dev_printk(KERN_ERR, &pdev->dev, 1464 - "could not request regions.\n"); 1464 + dev_err(&pdev->dev, "could not request regions.\n"); 1465 1465 goto err_out_mwi; 1466 1466 } 1467 1467 ··· 1474 1476 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK); 1475 1477 if (rc < 0) { 1476 1478 if (netif_msg_probe(tp)) 1477 - dev_printk(KERN_ERR, &pdev->dev, 1479 + dev_err(&pdev->dev, 1478 1480 "DMA configuration failed.\n"); 1479 1481 goto err_out_free_res; 1480 1482 } ··· 1486 1488 ioaddr = ioremap(pci_resource_start(pdev, 1), R8169_REGS_SIZE); 1487 1489 if (ioaddr == NULL) { 1488 1490 if (netif_msg_probe(tp)) 1489 - dev_printk(KERN_ERR, &pdev->dev, 1490 - "cannot remap MMIO, aborting\n"); 1491 + dev_err(&pdev->dev, "cannot remap MMIO, aborting\n"); 1491 1492 rc = -EIO; 1492 1493 goto err_out_free_res; 1493 1494 }
+6 -6
drivers/net/via-velocity.c
··· 695 695 * can support more than MAX_UNITS. 696 696 */ 697 697 if (velocity_nics >= MAX_UNITS) { 698 - dev_printk(KERN_NOTICE, &pdev->dev, "already found %d NICs.\n", 698 + dev_notice(&pdev->dev, "already found %d NICs.\n", 699 699 velocity_nics); 700 700 return -ENODEV; 701 701 } 702 702 703 703 dev = alloc_etherdev(sizeof(struct velocity_info)); 704 704 if (!dev) { 705 - dev_printk(KERN_ERR, &pdev->dev, "allocate net device failed.\n"); 705 + dev_err(&pdev->dev, "allocate net device failed.\n"); 706 706 goto out; 707 707 } 708 708 ··· 739 739 740 740 ret = pci_request_regions(pdev, VELOCITY_NAME); 741 741 if (ret < 0) { 742 - dev_printk(KERN_ERR, &pdev->dev, "No PCI resources.\n"); 742 + dev_err(&pdev->dev, "No PCI resources.\n"); 743 743 goto err_disable; 744 744 } 745 745 ··· 895 895 vptr->memaddr = pci_resource_start(pdev, 1); 896 896 897 897 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) { 898 - dev_printk(KERN_ERR, &pdev->dev, 898 + dev_err(&pdev->dev, 899 899 "region #0 is not an I/O resource, aborting.\n"); 900 900 return -EINVAL; 901 901 } 902 902 903 903 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) { 904 - dev_printk(KERN_ERR, &pdev->dev, 904 + dev_err(&pdev->dev, 905 905 "region #1 is an I/O resource, aborting.\n"); 906 906 return -EINVAL; 907 907 } 908 908 909 909 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) { 910 - dev_printk(KERN_ERR, &pdev->dev, "region #1 is too small.\n"); 910 + dev_err(&pdev->dev, "region #1 is too small.\n"); 911 911 return -EINVAL; 912 912 } 913 913 vptr->pdev = pdev;