aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2008-10-12 14:40:55 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2008-10-12 14:40:55 -0400
commit07104839597803ccd9b2c4f543ee4651522b4aa1 (patch)
treeb3b569c955fb7abe10d1b89139c0f4a388933609 /drivers/net
parent589acce53e235055806e81e330af1e8f115bfcc2 (diff)
parent56c5d900dbb8e042bfad035d18433476931d8f93 (diff)
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-next-2.6: (180 commits) leo: disable cursor when leaving graphics mode cg6: disable cursor when leaving graphics mode sparc32: sun4m interrupt mask cleanup drivers/rtc/Kconfig: don't build rtc-cmos.o on sparc32 sparc: arch/sparc/kernel/pmc.c -- extra #include? sparc32: Add more extensive documentation of sun4m interrupts. sparc32: Kill irq_rcvreg from sun4m_irq.c sparc32: Delete master_l10_limit. sparc32: Use PROM device probing for sun4c timers. sparc32: Use PROM device probing for sun4c interrupt register. sparc32: Delete claim_ticker14(). sparc32: Stop calling claim_ticker14() from sun4c_irq.c sparc32: Kill clear_profile_irq btfixup entry. sparc32: Call sun4m_clear_profile_irq() directly from sun4m_smp.c sparc32: Remove #if 0'd code from sun4c_irq.c sparc32: Remove some SMP ifdefs in sun4d_irq.c sparc32: Use PROM infrastructure for probing and mapping sun4d timers. sparc32: Use PROM device probing for sun4m irq registers. sparc32: Use PROM device probing for sun4m timer registers. sparc: Fix user_regset 'n' field values. ...
Diffstat (limited to 'drivers/net')
-rw-r--r--drivers/net/myri_sbus.c196
-rw-r--r--drivers/net/myri_sbus.h2
-rw-r--r--drivers/net/niu.c2
-rw-r--r--drivers/net/sunbmac.c204
-rw-r--r--drivers/net/sunbmac.h4
-rw-r--r--drivers/net/sunhme.c322
-rw-r--r--drivers/net/sunhme.h7
-rw-r--r--drivers/net/sunlance.c180
-rw-r--r--drivers/net/sunqe.c162
-rw-r--r--drivers/net/sunqe.h4
-rw-r--r--drivers/net/sunvnet.c4
11 files changed, 470 insertions, 617 deletions
diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index 06e682334c7e..3ad7589d6a1c 100644
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -1,6 +1,6 @@
1/* myri_sbus.c: MyriCOM MyriNET SBUS card driver. 1/* myri_sbus.c: MyriCOM MyriNET SBUS card driver.
2 * 2 *
3 * Copyright (C) 1996, 1999, 2006 David S. Miller (davem@davemloft.net) 3 * Copyright (C) 1996, 1999, 2006, 2008 David S. Miller (davem@davemloft.net)
4 */ 4 */
5 5
6static char version[] = 6static char version[] =
@@ -22,6 +22,9 @@ static char version[] =
22#include <linux/etherdevice.h> 22#include <linux/etherdevice.h>
23#include <linux/skbuff.h> 23#include <linux/skbuff.h>
24#include <linux/bitops.h> 24#include <linux/bitops.h>
25#include <linux/dma-mapping.h>
26#include <linux/of.h>
27#include <linux/of_device.h>
25 28
26#include <net/dst.h> 29#include <net/dst.h>
27#include <net/arp.h> 30#include <net/arp.h>
@@ -33,7 +36,6 @@ static char version[] =
33#include <asm/dma.h> 36#include <asm/dma.h>
34#include <asm/byteorder.h> 37#include <asm/byteorder.h>
35#include <asm/idprom.h> 38#include <asm/idprom.h>
36#include <asm/sbus.h>
37#include <asm/openprom.h> 39#include <asm/openprom.h>
38#include <asm/oplib.h> 40#include <asm/oplib.h>
39#include <asm/auxio.h> 41#include <asm/auxio.h>
@@ -243,7 +245,8 @@ static void myri_clean_rings(struct myri_eth *mp)
243 u32 dma_addr; 245 u32 dma_addr;
244 246
245 dma_addr = sbus_readl(&rxd->myri_scatters[0].addr); 247 dma_addr = sbus_readl(&rxd->myri_scatters[0].addr);
246 sbus_unmap_single(mp->myri_sdev, dma_addr, RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE); 248 dma_unmap_single(&mp->myri_op->dev, dma_addr,
249 RX_ALLOC_SIZE, DMA_FROM_DEVICE);
247 dev_kfree_skb(mp->rx_skbs[i]); 250 dev_kfree_skb(mp->rx_skbs[i]);
248 mp->rx_skbs[i] = NULL; 251 mp->rx_skbs[i] = NULL;
249 } 252 }
@@ -259,7 +262,9 @@ static void myri_clean_rings(struct myri_eth *mp)
259 u32 dma_addr; 262 u32 dma_addr;
260 263
261 dma_addr = sbus_readl(&txd->myri_gathers[0].addr); 264 dma_addr = sbus_readl(&txd->myri_gathers[0].addr);
262 sbus_unmap_single(mp->myri_sdev, dma_addr, (skb->len + 3) & ~3, SBUS_DMA_TODEVICE); 265 dma_unmap_single(&mp->myri_op->dev, dma_addr,
266 (skb->len + 3) & ~3,
267 DMA_TO_DEVICE);
263 dev_kfree_skb(mp->tx_skbs[i]); 268 dev_kfree_skb(mp->tx_skbs[i]);
264 mp->tx_skbs[i] = NULL; 269 mp->tx_skbs[i] = NULL;
265 } 270 }
@@ -288,7 +293,9 @@ static void myri_init_rings(struct myri_eth *mp, int from_irq)
288 skb->dev = dev; 293 skb->dev = dev;
289 skb_put(skb, RX_ALLOC_SIZE); 294 skb_put(skb, RX_ALLOC_SIZE);
290 295
291 dma_addr = sbus_map_single(mp->myri_sdev, skb->data, RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE); 296 dma_addr = dma_map_single(&mp->myri_op->dev,
297 skb->data, RX_ALLOC_SIZE,
298 DMA_FROM_DEVICE);
292 sbus_writel(dma_addr, &rxd[i].myri_scatters[0].addr); 299 sbus_writel(dma_addr, &rxd[i].myri_scatters[0].addr);
293 sbus_writel(RX_ALLOC_SIZE, &rxd[i].myri_scatters[0].len); 300 sbus_writel(RX_ALLOC_SIZE, &rxd[i].myri_scatters[0].len);
294 sbus_writel(i, &rxd[i].ctx); 301 sbus_writel(i, &rxd[i].ctx);
@@ -344,7 +351,8 @@ static void myri_tx(struct myri_eth *mp, struct net_device *dev)
344 351
345 DTX(("SKB[%d] ", entry)); 352 DTX(("SKB[%d] ", entry));
346 dma_addr = sbus_readl(&sq->myri_txd[entry].myri_gathers[0].addr); 353 dma_addr = sbus_readl(&sq->myri_txd[entry].myri_gathers[0].addr);
347 sbus_unmap_single(mp->myri_sdev, dma_addr, skb->len, SBUS_DMA_TODEVICE); 354 dma_unmap_single(&mp->myri_op->dev, dma_addr,
355 skb->len, DMA_TO_DEVICE);
348 dev_kfree_skb(skb); 356 dev_kfree_skb(skb);
349 mp->tx_skbs[entry] = NULL; 357 mp->tx_skbs[entry] = NULL;
350 dev->stats.tx_packets++; 358 dev->stats.tx_packets++;
@@ -423,9 +431,9 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
423 431
424 /* Check for errors. */ 432 /* Check for errors. */
425 DRX(("rxd[%d]: %p len[%d] csum[%08x] ", entry, rxd, len, csum)); 433 DRX(("rxd[%d]: %p len[%d] csum[%08x] ", entry, rxd, len, csum));
426 sbus_dma_sync_single_for_cpu(mp->myri_sdev, 434 dma_sync_single_for_cpu(&mp->myri_op->dev,
427 sbus_readl(&rxd->myri_scatters[0].addr), 435 sbus_readl(&rxd->myri_scatters[0].addr),
428 RX_ALLOC_SIZE, SBUS_DMA_FROMDEVICE); 436 RX_ALLOC_SIZE, DMA_FROM_DEVICE);
429 if (len < (ETH_HLEN + MYRI_PAD_LEN) || (skb->data[0] != MYRI_PAD_LEN)) { 437 if (len < (ETH_HLEN + MYRI_PAD_LEN) || (skb->data[0] != MYRI_PAD_LEN)) {
430 DRX(("ERROR[")); 438 DRX(("ERROR["));
431 dev->stats.rx_errors++; 439 dev->stats.rx_errors++;
@@ -442,10 +450,10 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
442 drops++; 450 drops++;
443 DRX(("DROP ")); 451 DRX(("DROP "));
444 dev->stats.rx_dropped++; 452 dev->stats.rx_dropped++;
445 sbus_dma_sync_single_for_device(mp->myri_sdev, 453 dma_sync_single_for_device(&mp->myri_op->dev,
446 sbus_readl(&rxd->myri_scatters[0].addr), 454 sbus_readl(&rxd->myri_scatters[0].addr),
447 RX_ALLOC_SIZE, 455 RX_ALLOC_SIZE,
448 SBUS_DMA_FROMDEVICE); 456 DMA_FROM_DEVICE);
449 sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len); 457 sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
450 sbus_writel(index, &rxd->ctx); 458 sbus_writel(index, &rxd->ctx);
451 sbus_writel(1, &rxd->num_sg); 459 sbus_writel(1, &rxd->num_sg);
@@ -464,17 +472,17 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
464 DRX(("skb_alloc(FAILED) ")); 472 DRX(("skb_alloc(FAILED) "));
465 goto drop_it; 473 goto drop_it;
466 } 474 }
467 sbus_unmap_single(mp->myri_sdev, 475 dma_unmap_single(&mp->myri_op->dev,
468 sbus_readl(&rxd->myri_scatters[0].addr), 476 sbus_readl(&rxd->myri_scatters[0].addr),
469 RX_ALLOC_SIZE, 477 RX_ALLOC_SIZE,
470 SBUS_DMA_FROMDEVICE); 478 DMA_FROM_DEVICE);
471 mp->rx_skbs[index] = new_skb; 479 mp->rx_skbs[index] = new_skb;
472 new_skb->dev = dev; 480 new_skb->dev = dev;
473 skb_put(new_skb, RX_ALLOC_SIZE); 481 skb_put(new_skb, RX_ALLOC_SIZE);
474 dma_addr = sbus_map_single(mp->myri_sdev, 482 dma_addr = dma_map_single(&mp->myri_op->dev,
475 new_skb->data, 483 new_skb->data,
476 RX_ALLOC_SIZE, 484 RX_ALLOC_SIZE,
477 SBUS_DMA_FROMDEVICE); 485 DMA_FROM_DEVICE);
478 sbus_writel(dma_addr, &rxd->myri_scatters[0].addr); 486 sbus_writel(dma_addr, &rxd->myri_scatters[0].addr);
479 sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len); 487 sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
480 sbus_writel(index, &rxd->ctx); 488 sbus_writel(index, &rxd->ctx);
@@ -500,10 +508,10 @@ static void myri_rx(struct myri_eth *mp, struct net_device *dev)
500 508
501 /* Reuse original ring buffer. */ 509 /* Reuse original ring buffer. */
502 DRX(("reuse ")); 510 DRX(("reuse "));
503 sbus_dma_sync_single_for_device(mp->myri_sdev, 511 dma_sync_single_for_device(&mp->myri_op->dev,
504 sbus_readl(&rxd->myri_scatters[0].addr), 512 sbus_readl(&rxd->myri_scatters[0].addr),
505 RX_ALLOC_SIZE, 513 RX_ALLOC_SIZE,
506 SBUS_DMA_FROMDEVICE); 514 DMA_FROM_DEVICE);
507 sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len); 515 sbus_writel(RX_ALLOC_SIZE, &rxd->myri_scatters[0].len);
508 sbus_writel(index, &rxd->ctx); 516 sbus_writel(index, &rxd->ctx);
509 sbus_writel(1, &rxd->num_sg); 517 sbus_writel(1, &rxd->num_sg);
@@ -652,7 +660,8 @@ static int myri_start_xmit(struct sk_buff *skb, struct net_device *dev)
652 sbus_writew((skb->data[4] << 8) | skb->data[5], &txd->addr[3]); 660 sbus_writew((skb->data[4] << 8) | skb->data[5], &txd->addr[3]);
653 } 661 }
654 662
655 dma_addr = sbus_map_single(mp->myri_sdev, skb->data, len, SBUS_DMA_TODEVICE); 663 dma_addr = dma_map_single(&mp->myri_op->dev, skb->data,
664 len, DMA_TO_DEVICE);
656 sbus_writel(dma_addr, &txd->myri_gathers[0].addr); 665 sbus_writel(dma_addr, &txd->myri_gathers[0].addr);
657 sbus_writel(len, &txd->myri_gathers[0].len); 666 sbus_writel(len, &txd->myri_gathers[0].len);
658 sbus_writel(1, &txd->num_sg); 667 sbus_writel(1, &txd->num_sg);
@@ -891,30 +900,30 @@ static const struct header_ops myri_header_ops = {
891 .cache_update = myri_header_cache_update, 900 .cache_update = myri_header_cache_update,
892}; 901};
893 902
894static int __devinit myri_ether_init(struct sbus_dev *sdev) 903static int __devinit myri_sbus_probe(struct of_device *op, const struct of_device_id *match)
895{ 904{
896 static int num; 905 struct device_node *dp = op->node;
897 static unsigned version_printed; 906 static unsigned version_printed;
898 struct net_device *dev; 907 struct net_device *dev;
899 struct myri_eth *mp;
900 unsigned char prop_buf[32];
901 int i;
902 DECLARE_MAC_BUF(mac); 908 DECLARE_MAC_BUF(mac);
909 struct myri_eth *mp;
910 const void *prop;
911 static int num;
912 int i, len;
903 913
904 DET(("myri_ether_init(%p,%d):\n", sdev, num)); 914 DET(("myri_ether_init(%p,%d):\n", op, num));
905 dev = alloc_etherdev(sizeof(struct myri_eth)); 915 dev = alloc_etherdev(sizeof(struct myri_eth));
906
907 if (!dev) 916 if (!dev)
908 return -ENOMEM; 917 return -ENOMEM;
909 918
910 if (version_printed++ == 0) 919 if (version_printed++ == 0)
911 printk(version); 920 printk(version);
912 921
913 SET_NETDEV_DEV(dev, &sdev->ofdev.dev); 922 SET_NETDEV_DEV(dev, &op->dev);
914 923
915 mp = (struct myri_eth *) dev->priv; 924 mp = netdev_priv(dev);
916 spin_lock_init(&mp->irq_lock); 925 spin_lock_init(&mp->irq_lock);
917 mp->myri_sdev = sdev; 926 mp->myri_op = op;
918 927
919 /* Clean out skb arrays. */ 928 /* Clean out skb arrays. */
920 for (i = 0; i < (RX_RING_SIZE + 1); i++) 929 for (i = 0; i < (RX_RING_SIZE + 1); i++)
@@ -924,55 +933,44 @@ static int __devinit myri_ether_init(struct sbus_dev *sdev)
924 mp->tx_skbs[i] = NULL; 933 mp->tx_skbs[i] = NULL;
925 934
926 /* First check for EEPROM information. */ 935 /* First check for EEPROM information. */
927 i = prom_getproperty(sdev->prom_node, "myrinet-eeprom-info", 936 prop = of_get_property(dp, "myrinet-eeprom-info", &len);
928 (char *)&mp->eeprom, sizeof(struct myri_eeprom)); 937
929 DET(("prom_getprop(myrinet-eeprom-info) returns %d\n", i)); 938 if (prop)
930 if (i == 0 || i == -1) { 939 memcpy(&mp->eeprom, prop, sizeof(struct myri_eeprom));
940 if (!prop) {
931 /* No eeprom property, must cook up the values ourselves. */ 941 /* No eeprom property, must cook up the values ourselves. */
932 DET(("No EEPROM: ")); 942 DET(("No EEPROM: "));
933 mp->eeprom.bus_type = BUS_TYPE_SBUS; 943 mp->eeprom.bus_type = BUS_TYPE_SBUS;
934 mp->eeprom.cpuvers = prom_getintdefault(sdev->prom_node,"cpu_version",0); 944 mp->eeprom.cpuvers =
935 mp->eeprom.cval = prom_getintdefault(sdev->prom_node,"clock_value",0); 945 of_getintprop_default(dp, "cpu_version", 0);
936 mp->eeprom.ramsz = prom_getintdefault(sdev->prom_node,"sram_size",0); 946 mp->eeprom.cval =
937 DET(("cpuvers[%d] cval[%d] ramsz[%d]\n", mp->eeprom.cpuvers, 947 of_getintprop_default(dp, "clock_value", 0);
938 mp->eeprom.cval, mp->eeprom.ramsz)); 948 mp->eeprom.ramsz = of_getintprop_default(dp, "sram_size", 0);
939 if (mp->eeprom.cpuvers == 0) { 949 if (!mp->eeprom.cpuvers)
940 DET(("EEPROM: cpuvers was zero, setting to %04x\n",CPUVERS_2_3));
941 mp->eeprom.cpuvers = CPUVERS_2_3; 950 mp->eeprom.cpuvers = CPUVERS_2_3;
942 } 951 if (mp->eeprom.cpuvers < CPUVERS_3_0)
943 if (mp->eeprom.cpuvers < CPUVERS_3_0) {
944 DET(("EEPROM: cpuvers < CPUVERS_3_0, clockval set to zero.\n"));
945 mp->eeprom.cval = 0; 952 mp->eeprom.cval = 0;
946 } 953 if (!mp->eeprom.ramsz)
947 if (mp->eeprom.ramsz == 0) {
948 DET(("EEPROM: ramsz == 0, setting to 128k\n"));
949 mp->eeprom.ramsz = (128 * 1024); 954 mp->eeprom.ramsz = (128 * 1024);
950 } 955
951 i = prom_getproperty(sdev->prom_node, "myrinet-board-id", 956 prop = of_get_property(dp, "myrinet-board-id", &len);
952 &prop_buf[0], 10); 957 if (prop)
953 DET(("EEPROM: prom_getprop(myrinet-board-id) returns %d\n", i)); 958 memcpy(&mp->eeprom.id[0], prop, 6);
954 if ((i != 0) && (i != -1))
955 memcpy(&mp->eeprom.id[0], &prop_buf[0], 6);
956 else 959 else
957 set_boardid_from_idprom(mp, num); 960 set_boardid_from_idprom(mp, num);
958 i = prom_getproperty(sdev->prom_node, "fpga_version", 961
959 &mp->eeprom.fvers[0], 32); 962 prop = of_get_property(dp, "fpga_version", &len);
960 DET(("EEPROM: prom_getprop(fpga_version) returns %d\n", i)); 963 if (prop)
961 if (i == 0 || i == -1) 964 memcpy(&mp->eeprom.fvers[0], prop, 32);
965 else
962 memset(&mp->eeprom.fvers[0], 0, 32); 966 memset(&mp->eeprom.fvers[0], 0, 32);
963 967
964 if (mp->eeprom.cpuvers == CPUVERS_4_1) { 968 if (mp->eeprom.cpuvers == CPUVERS_4_1) {
965 DET(("EEPROM: cpuvers CPUVERS_4_1, ")); 969 if (mp->eeprom.ramsz == (128 * 1024))
966 if (mp->eeprom.ramsz == (128 * 1024)) {
967 DET(("ramsize 128k, setting to 256k, "));
968 mp->eeprom.ramsz = (256 * 1024); 970 mp->eeprom.ramsz = (256 * 1024);
969 } 971 if ((mp->eeprom.cval == 0x40414041) ||
970 if ((mp->eeprom.cval==0x40414041)||(mp->eeprom.cval==0x90449044)){ 972 (mp->eeprom.cval == 0x90449044))
971 DET(("changing cval from %08x to %08x ",
972 mp->eeprom.cval, 0x50e450e4));
973 mp->eeprom.cval = 0x50e450e4; 973 mp->eeprom.cval = 0x50e450e4;
974 }
975 DET(("\n"));
976 } 974 }
977 } 975 }
978#ifdef DEBUG_DETECT 976#ifdef DEBUG_DETECT
@@ -991,8 +989,8 @@ static int __devinit myri_ether_init(struct sbus_dev *sdev)
991 * XXX only a valid version for PCI cards? Ask feldy... 989 * XXX only a valid version for PCI cards? Ask feldy...
992 */ 990 */
993 DET(("Mapping regs for cpuvers < CPUVERS_4_0\n")); 991 DET(("Mapping regs for cpuvers < CPUVERS_4_0\n"));
994 mp->regs = sbus_ioremap(&sdev->resource[0], 0, 992 mp->regs = of_ioremap(&op->resource[0], 0,
995 mp->reg_size, "MyriCOM Regs"); 993 mp->reg_size, "MyriCOM Regs");
996 if (!mp->regs) { 994 if (!mp->regs) {
997 printk("MyriCOM: Cannot map MyriCOM registers.\n"); 995 printk("MyriCOM: Cannot map MyriCOM registers.\n");
998 goto err; 996 goto err;
@@ -1001,13 +999,12 @@ static int __devinit myri_ether_init(struct sbus_dev *sdev)
1001 mp->lregs = mp->lanai + (0x10000 * 2); 999 mp->lregs = mp->lanai + (0x10000 * 2);
1002 } else { 1000 } else {
1003 DET(("Mapping regs for cpuvers >= CPUVERS_4_0\n")); 1001 DET(("Mapping regs for cpuvers >= CPUVERS_4_0\n"));
1004 mp->cregs = sbus_ioremap(&sdev->resource[0], 0, 1002 mp->cregs = of_ioremap(&op->resource[0], 0,
1005 PAGE_SIZE, "MyriCOM Control Regs"); 1003 PAGE_SIZE, "MyriCOM Control Regs");
1006 mp->lregs = sbus_ioremap(&sdev->resource[0], (256 * 1024), 1004 mp->lregs = of_ioremap(&op->resource[0], (256 * 1024),
1007 PAGE_SIZE, "MyriCOM LANAI Regs"); 1005 PAGE_SIZE, "MyriCOM LANAI Regs");
1008 mp->lanai = 1006 mp->lanai = of_ioremap(&op->resource[0], (512 * 1024),
1009 sbus_ioremap(&sdev->resource[0], (512 * 1024), 1007 mp->eeprom.ramsz, "MyriCOM SRAM");
1010 mp->eeprom.ramsz, "MyriCOM SRAM");
1011 } 1008 }
1012 DET(("Registers mapped: cregs[%p] lregs[%p] lanai[%p]\n", 1009 DET(("Registers mapped: cregs[%p] lregs[%p] lanai[%p]\n",
1013 mp->cregs, mp->lregs, mp->lanai)); 1010 mp->cregs, mp->lregs, mp->lanai));
@@ -1039,16 +1036,15 @@ static int __devinit myri_ether_init(struct sbus_dev *sdev)
1039 myri_reset_on(mp->cregs); 1036 myri_reset_on(mp->cregs);
1040 1037
1041 /* Get the supported DVMA burst sizes from our SBUS. */ 1038 /* Get the supported DVMA burst sizes from our SBUS. */
1042 mp->myri_bursts = prom_getintdefault(mp->myri_sdev->bus->prom_node, 1039 mp->myri_bursts = of_getintprop_default(dp->parent,
1043 "burst-sizes", 0x00); 1040 "burst-sizes", 0x00);
1044 1041 if (!sbus_can_burst64())
1045 if (!sbus_can_burst64(sdev))
1046 mp->myri_bursts &= ~(DMA_BURST64); 1042 mp->myri_bursts &= ~(DMA_BURST64);
1047 1043
1048 DET(("MYRI bursts %02x\n", mp->myri_bursts)); 1044 DET(("MYRI bursts %02x\n", mp->myri_bursts));
1049 1045
1050 /* Encode SBUS interrupt level in second control register. */ 1046 /* Encode SBUS interrupt level in second control register. */
1051 i = prom_getint(sdev->prom_node, "interrupts"); 1047 i = of_getintprop_default(dp, "interrupts", 0);
1052 if (i == 0) 1048 if (i == 0)
1053 i = 4; 1049 i = 4;
1054 DET(("prom_getint(interrupts)==%d, irqlvl set to %04x\n", 1050 DET(("prom_getint(interrupts)==%d, irqlvl set to %04x\n",
@@ -1063,7 +1059,7 @@ static int __devinit myri_ether_init(struct sbus_dev *sdev)
1063 dev->tx_timeout = &myri_tx_timeout; 1059 dev->tx_timeout = &myri_tx_timeout;
1064 dev->watchdog_timeo = 5*HZ; 1060 dev->watchdog_timeo = 5*HZ;
1065 dev->set_multicast_list = &myri_set_multicast; 1061 dev->set_multicast_list = &myri_set_multicast;
1066 dev->irq = sdev->irqs[0]; 1062 dev->irq = op->irqs[0];
1067 1063
1068 /* Register interrupt handler now. */ 1064 /* Register interrupt handler now. */
1069 DET(("Requesting MYRIcom IRQ line.\n")); 1065 DET(("Requesting MYRIcom IRQ line.\n"));
@@ -1088,7 +1084,7 @@ static int __devinit myri_ether_init(struct sbus_dev *sdev)
1088 goto err_free_irq; 1084 goto err_free_irq;
1089 } 1085 }
1090 1086
1091 dev_set_drvdata(&sdev->ofdev.dev, mp); 1087 dev_set_drvdata(&op->dev, mp);
1092 1088
1093 num++; 1089 num++;
1094 1090
@@ -1105,17 +1101,9 @@ err:
1105 return -ENODEV; 1101 return -ENODEV;
1106} 1102}
1107 1103
1108 1104static int __devexit myri_sbus_remove(struct of_device *op)
1109static int __devinit myri_sbus_probe(struct of_device *dev, const struct of_device_id *match)
1110{
1111 struct sbus_dev *sdev = to_sbus_device(&dev->dev);
1112
1113 return myri_ether_init(sdev);
1114}
1115
1116static int __devexit myri_sbus_remove(struct of_device *dev)
1117{ 1105{
1118 struct myri_eth *mp = dev_get_drvdata(&dev->dev); 1106 struct myri_eth *mp = dev_get_drvdata(&op->dev);
1119 struct net_device *net_dev = mp->dev; 1107 struct net_device *net_dev = mp->dev;
1120 1108
1121 unregister_netdev(net_dev); 1109 unregister_netdev(net_dev);
@@ -1123,21 +1111,21 @@ static int __devexit myri_sbus_remove(struct of_device *dev)
1123 free_irq(net_dev->irq, net_dev); 1111 free_irq(net_dev->irq, net_dev);
1124 1112
1125 if (mp->eeprom.cpuvers < CPUVERS_4_0) { 1113 if (mp->eeprom.cpuvers < CPUVERS_4_0) {
1126 sbus_iounmap(mp->regs, mp->reg_size); 1114 of_iounmap(&op->resource[0], mp->regs, mp->reg_size);
1127 } else { 1115 } else {
1128 sbus_iounmap(mp->cregs, PAGE_SIZE); 1116 of_iounmap(&op->resource[0], mp->cregs, PAGE_SIZE);
1129 sbus_iounmap(mp->lregs, (256 * 1024)); 1117 of_iounmap(&op->resource[0], mp->lregs, (256 * 1024));
1130 sbus_iounmap(mp->lanai, (512 * 1024)); 1118 of_iounmap(&op->resource[0], mp->lanai, (512 * 1024));
1131 } 1119 }
1132 1120
1133 free_netdev(net_dev); 1121 free_netdev(net_dev);
1134 1122
1135 dev_set_drvdata(&dev->dev, NULL); 1123 dev_set_drvdata(&op->dev, NULL);
1136 1124
1137 return 0; 1125 return 0;
1138} 1126}
1139 1127
1140static struct of_device_id myri_sbus_match[] = { 1128static const struct of_device_id myri_sbus_match[] = {
1141 { 1129 {
1142 .name = "MYRICOM,mlanai", 1130 .name = "MYRICOM,mlanai",
1143 }, 1131 },
@@ -1158,7 +1146,7 @@ static struct of_platform_driver myri_sbus_driver = {
1158 1146
1159static int __init myri_sbus_init(void) 1147static int __init myri_sbus_init(void)
1160{ 1148{
1161 return of_register_driver(&myri_sbus_driver, &sbus_bus_type); 1149 return of_register_driver(&myri_sbus_driver, &of_bus_type);
1162} 1150}
1163 1151
1164static void __exit myri_sbus_exit(void) 1152static void __exit myri_sbus_exit(void)
diff --git a/drivers/net/myri_sbus.h b/drivers/net/myri_sbus.h
index 5d93fcc95d55..ff363e95d9cf 100644
--- a/drivers/net/myri_sbus.h
+++ b/drivers/net/myri_sbus.h
@@ -288,7 +288,7 @@ struct myri_eth {
288 struct myri_eeprom eeprom; /* Local copy of EEPROM. */ 288 struct myri_eeprom eeprom; /* Local copy of EEPROM. */
289 unsigned int reg_size; /* Size of register space. */ 289 unsigned int reg_size; /* Size of register space. */
290 unsigned int shmem_base; /* Offset to shared ram. */ 290 unsigned int shmem_base; /* Offset to shared ram. */
291 struct sbus_dev *myri_sdev; /* Our SBUS device struct. */ 291 struct of_device *myri_op; /* Our OF device struct. */
292}; 292};
293 293
294/* We use this to acquire receive skb's that we can DMA directly into. */ 294/* We use this to acquire receive skb's that we can DMA directly into. */
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index e3be81eba8a4..ebc812702903 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -9130,7 +9130,7 @@ static int __devexit niu_of_remove(struct of_device *op)
9130 return 0; 9130 return 0;
9131} 9131}
9132 9132
9133static struct of_device_id niu_match[] = { 9133static const struct of_device_id niu_match[] = {
9134 { 9134 {
9135 .name = "network", 9135 .name = "network",
9136 .compatible = "SUNW,niusl", 9136 .compatible = "SUNW,niusl",
diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index 31e7384e312a..018d0fca9422 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -1,7 +1,6 @@
1/* $Id: sunbmac.c,v 1.30 2002/01/15 06:48:55 davem Exp $ 1/* sunbmac.c: Driver for Sparc BigMAC 100baseT ethernet adapters.
2 * sunbmac.c: Driver for Sparc BigMAC 100baseT ethernet adapters.
3 * 2 *
4 * Copyright (C) 1997, 1998, 1999, 2003 David S. Miller (davem@redhat.com) 3 * Copyright (C) 1997, 1998, 1999, 2003, 2008 David S. Miller (davem@davemloft.net)
5 */ 4 */
6 5
7#include <linux/module.h> 6#include <linux/module.h>
@@ -23,6 +22,9 @@
23#include <linux/etherdevice.h> 22#include <linux/etherdevice.h>
24#include <linux/skbuff.h> 23#include <linux/skbuff.h>
25#include <linux/bitops.h> 24#include <linux/bitops.h>
25#include <linux/dma-mapping.h>
26#include <linux/of.h>
27#include <linux/of_device.h>
26 28
27#include <asm/auxio.h> 29#include <asm/auxio.h>
28#include <asm/byteorder.h> 30#include <asm/byteorder.h>
@@ -32,15 +34,14 @@
32#include <asm/openprom.h> 34#include <asm/openprom.h>
33#include <asm/oplib.h> 35#include <asm/oplib.h>
34#include <asm/pgtable.h> 36#include <asm/pgtable.h>
35#include <asm/sbus.h>
36#include <asm/system.h> 37#include <asm/system.h>
37 38
38#include "sunbmac.h" 39#include "sunbmac.h"
39 40
40#define DRV_NAME "sunbmac" 41#define DRV_NAME "sunbmac"
41#define DRV_VERSION "2.0" 42#define DRV_VERSION "2.1"
42#define DRV_RELDATE "11/24/03" 43#define DRV_RELDATE "August 26, 2008"
43#define DRV_AUTHOR "David S. Miller (davem@redhat.com)" 44#define DRV_AUTHOR "David S. Miller (davem@davemloft.net)"
44 45
45static char version[] = 46static char version[] =
46 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " " DRV_AUTHOR "\n"; 47 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " " DRV_AUTHOR "\n";
@@ -96,8 +97,8 @@ static int qec_global_reset(void __iomem *gregs)
96 97
97static void qec_init(struct bigmac *bp) 98static void qec_init(struct bigmac *bp)
98{ 99{
100 struct of_device *qec_op = bp->qec_op;
99 void __iomem *gregs = bp->gregs; 101 void __iomem *gregs = bp->gregs;
100 struct sbus_dev *qec_sdev = bp->qec_sdev;
101 u8 bsizes = bp->bigmac_bursts; 102 u8 bsizes = bp->bigmac_bursts;
102 u32 regval; 103 u32 regval;
103 104
@@ -112,13 +113,13 @@ static void qec_init(struct bigmac *bp)
112 sbus_writel(GLOB_PSIZE_2048, gregs + GLOB_PSIZE); 113 sbus_writel(GLOB_PSIZE_2048, gregs + GLOB_PSIZE);
113 114
114 /* All of memsize is given to bigmac. */ 115 /* All of memsize is given to bigmac. */
115 sbus_writel(qec_sdev->reg_addrs[1].reg_size, 116 sbus_writel(resource_size(&qec_op->resource[1]),
116 gregs + GLOB_MSIZE); 117 gregs + GLOB_MSIZE);
117 118
118 /* Half to the transmitter, half to the receiver. */ 119 /* Half to the transmitter, half to the receiver. */
119 sbus_writel(qec_sdev->reg_addrs[1].reg_size >> 1, 120 sbus_writel(resource_size(&qec_op->resource[1]) >> 1,
120 gregs + GLOB_TSIZE); 121 gregs + GLOB_TSIZE);
121 sbus_writel(qec_sdev->reg_addrs[1].reg_size >> 1, 122 sbus_writel(resource_size(&qec_op->resource[1]) >> 1,
122 gregs + GLOB_RSIZE); 123 gregs + GLOB_RSIZE);
123} 124}
124 125
@@ -239,9 +240,10 @@ static void bigmac_init_rings(struct bigmac *bp, int from_irq)
239 skb_reserve(skb, 34); 240 skb_reserve(skb, 34);
240 241
241 bb->be_rxd[i].rx_addr = 242 bb->be_rxd[i].rx_addr =
242 sbus_map_single(bp->bigmac_sdev, skb->data, 243 dma_map_single(&bp->bigmac_op->dev,
243 RX_BUF_ALLOC_SIZE - 34, 244 skb->data,
244 SBUS_DMA_FROMDEVICE); 245 RX_BUF_ALLOC_SIZE - 34,
246 DMA_FROM_DEVICE);
245 bb->be_rxd[i].rx_flags = 247 bb->be_rxd[i].rx_flags =
246 (RXD_OWN | ((RX_BUF_ALLOC_SIZE - 34) & RXD_LENGTH)); 248 (RXD_OWN | ((RX_BUF_ALLOC_SIZE - 34) & RXD_LENGTH));
247 } 249 }
@@ -776,9 +778,9 @@ static void bigmac_tx(struct bigmac *bp)
776 skb = bp->tx_skbs[elem]; 778 skb = bp->tx_skbs[elem];
777 bp->enet_stats.tx_packets++; 779 bp->enet_stats.tx_packets++;
778 bp->enet_stats.tx_bytes += skb->len; 780 bp->enet_stats.tx_bytes += skb->len;
779 sbus_unmap_single(bp->bigmac_sdev, 781 dma_unmap_single(&bp->bigmac_op->dev,
780 this->tx_addr, skb->len, 782 this->tx_addr, skb->len,
781 SBUS_DMA_TODEVICE); 783 DMA_TO_DEVICE);
782 784
783 DTX(("skb(%p) ", skb)); 785 DTX(("skb(%p) ", skb));
784 bp->tx_skbs[elem] = NULL; 786 bp->tx_skbs[elem] = NULL;
@@ -831,18 +833,19 @@ static void bigmac_rx(struct bigmac *bp)
831 drops++; 833 drops++;
832 goto drop_it; 834 goto drop_it;
833 } 835 }
834 sbus_unmap_single(bp->bigmac_sdev, 836 dma_unmap_single(&bp->bigmac_op->dev,
835 this->rx_addr, 837 this->rx_addr,
836 RX_BUF_ALLOC_SIZE - 34, 838 RX_BUF_ALLOC_SIZE - 34,
837 SBUS_DMA_FROMDEVICE); 839 DMA_FROM_DEVICE);
838 bp->rx_skbs[elem] = new_skb; 840 bp->rx_skbs[elem] = new_skb;
839 new_skb->dev = bp->dev; 841 new_skb->dev = bp->dev;
840 skb_put(new_skb, ETH_FRAME_LEN); 842 skb_put(new_skb, ETH_FRAME_LEN);
841 skb_reserve(new_skb, 34); 843 skb_reserve(new_skb, 34);
842 this->rx_addr = sbus_map_single(bp->bigmac_sdev, 844 this->rx_addr =
843 new_skb->data, 845 dma_map_single(&bp->bigmac_op->dev,
844 RX_BUF_ALLOC_SIZE - 34, 846 new_skb->data,
845 SBUS_DMA_FROMDEVICE); 847 RX_BUF_ALLOC_SIZE - 34,
848 DMA_FROM_DEVICE);
846 this->rx_flags = 849 this->rx_flags =
847 (RXD_OWN | ((RX_BUF_ALLOC_SIZE - 34) & RXD_LENGTH)); 850 (RXD_OWN | ((RX_BUF_ALLOC_SIZE - 34) & RXD_LENGTH));
848 851
@@ -857,13 +860,13 @@ static void bigmac_rx(struct bigmac *bp)
857 } 860 }
858 skb_reserve(copy_skb, 2); 861 skb_reserve(copy_skb, 2);
859 skb_put(copy_skb, len); 862 skb_put(copy_skb, len);
860 sbus_dma_sync_single_for_cpu(bp->bigmac_sdev, 863 dma_sync_single_for_cpu(&bp->bigmac_op->dev,
861 this->rx_addr, len, 864 this->rx_addr, len,
862 SBUS_DMA_FROMDEVICE); 865 DMA_FROM_DEVICE);
863 skb_copy_to_linear_data(copy_skb, (unsigned char *)skb->data, len); 866 skb_copy_to_linear_data(copy_skb, (unsigned char *)skb->data, len);
864 sbus_dma_sync_single_for_device(bp->bigmac_sdev, 867 dma_sync_single_for_device(&bp->bigmac_op->dev,
865 this->rx_addr, len, 868 this->rx_addr, len,
866 SBUS_DMA_FROMDEVICE); 869 DMA_FROM_DEVICE);
867 870
868 /* Reuse original ring buffer. */ 871 /* Reuse original ring buffer. */
869 this->rx_flags = 872 this->rx_flags =
@@ -959,7 +962,8 @@ static int bigmac_start_xmit(struct sk_buff *skb, struct net_device *dev)
959 u32 mapping; 962 u32 mapping;
960 963
961 len = skb->len; 964 len = skb->len;
962 mapping = sbus_map_single(bp->bigmac_sdev, skb->data, len, SBUS_DMA_TODEVICE); 965 mapping = dma_map_single(&bp->bigmac_op->dev, skb->data,
966 len, DMA_TO_DEVICE);
963 967
964 /* Avoid a race... */ 968 /* Avoid a race... */
965 spin_lock_irq(&bp->lock); 969 spin_lock_irq(&bp->lock);
@@ -1051,12 +1055,8 @@ static void bigmac_set_multicast(struct net_device *dev)
1051/* Ethtool support... */ 1055/* Ethtool support... */
1052static void bigmac_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 1056static void bigmac_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1053{ 1057{
1054 struct bigmac *bp = dev->priv;
1055
1056 strcpy(info->driver, "sunbmac"); 1058 strcpy(info->driver, "sunbmac");
1057 strcpy(info->version, "2.0"); 1059 strcpy(info->version, "2.0");
1058 sprintf(info->bus_info, "SBUS:%d",
1059 bp->qec_sdev->slot);
1060} 1060}
1061 1061
1062static u32 bigmac_get_link(struct net_device *dev) 1062static u32 bigmac_get_link(struct net_device *dev)
@@ -1075,14 +1075,15 @@ static const struct ethtool_ops bigmac_ethtool_ops = {
1075 .get_link = bigmac_get_link, 1075 .get_link = bigmac_get_link,
1076}; 1076};
1077 1077
1078static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev) 1078static int __devinit bigmac_ether_init(struct of_device *op,
1079 struct of_device *qec_op)
1079{ 1080{
1080 struct net_device *dev;
1081 static int version_printed; 1081 static int version_printed;
1082 struct bigmac *bp; 1082 struct net_device *dev;
1083 u8 bsizes, bsizes_more; 1083 u8 bsizes, bsizes_more;
1084 int i;
1085 DECLARE_MAC_BUF(mac); 1084 DECLARE_MAC_BUF(mac);
1085 struct bigmac *bp;
1086 int i;
1086 1087
1087 /* Get a new device struct for this interface. */ 1088 /* Get a new device struct for this interface. */
1088 dev = alloc_etherdev(sizeof(struct bigmac)); 1089 dev = alloc_etherdev(sizeof(struct bigmac));
@@ -1092,32 +1093,21 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1092 if (version_printed++ == 0) 1093 if (version_printed++ == 0)
1093 printk(KERN_INFO "%s", version); 1094 printk(KERN_INFO "%s", version);
1094 1095
1095 dev->base_addr = (long) qec_sdev;
1096 for (i = 0; i < 6; i++) 1096 for (i = 0; i < 6; i++)
1097 dev->dev_addr[i] = idprom->id_ethaddr[i]; 1097 dev->dev_addr[i] = idprom->id_ethaddr[i];
1098 1098
1099 /* Setup softc, with backpointers to QEC and BigMAC SBUS device structs. */ 1099 /* Setup softc, with backpointers to QEC and BigMAC SBUS device structs. */
1100 bp = dev->priv; 1100 bp = netdev_priv(dev);
1101 bp->qec_sdev = qec_sdev; 1101 bp->qec_op = qec_op;
1102 bp->bigmac_sdev = qec_sdev->child; 1102 bp->bigmac_op = op;
1103 1103
1104 SET_NETDEV_DEV(dev, &bp->bigmac_sdev->ofdev.dev); 1104 SET_NETDEV_DEV(dev, &op->dev);
1105 1105
1106 spin_lock_init(&bp->lock); 1106 spin_lock_init(&bp->lock);
1107 1107
1108 /* Verify the registers we expect, are actually there. */
1109 if ((bp->bigmac_sdev->num_registers != 3) ||
1110 (bp->qec_sdev->num_registers != 2)) {
1111 printk(KERN_ERR "BIGMAC: Device does not have 2 and 3 regs, it has %d and %d.\n",
1112 bp->qec_sdev->num_registers,
1113 bp->bigmac_sdev->num_registers);
1114 printk(KERN_ERR "BIGMAC: Would you like that for here or to go?\n");
1115 goto fail_and_cleanup;
1116 }
1117
1118 /* Map in QEC global control registers. */ 1108 /* Map in QEC global control registers. */
1119 bp->gregs = sbus_ioremap(&bp->qec_sdev->resource[0], 0, 1109 bp->gregs = of_ioremap(&qec_op->resource[0], 0,
1120 GLOB_REG_SIZE, "BigMAC QEC GLobal Regs"); 1110 GLOB_REG_SIZE, "BigMAC QEC GLobal Regs");
1121 if (!bp->gregs) { 1111 if (!bp->gregs) {
1122 printk(KERN_ERR "BIGMAC: Cannot map QEC global registers.\n"); 1112 printk(KERN_ERR "BIGMAC: Cannot map QEC global registers.\n");
1123 goto fail_and_cleanup; 1113 goto fail_and_cleanup;
@@ -1134,13 +1124,8 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1134 goto fail_and_cleanup; 1124 goto fail_and_cleanup;
1135 1125
1136 /* Get supported SBUS burst sizes. */ 1126 /* Get supported SBUS burst sizes. */
1137 bsizes = prom_getintdefault(bp->qec_sdev->prom_node, 1127 bsizes = of_getintprop_default(qec_op->node, "burst-sizes", 0xff);
1138 "burst-sizes", 1128 bsizes_more = of_getintprop_default(qec_op->node, "burst-sizes", 0xff);
1139 0xff);
1140
1141 bsizes_more = prom_getintdefault(bp->qec_sdev->bus->prom_node,
1142 "burst-sizes",
1143 0xff);
1144 1129
1145 bsizes &= 0xff; 1130 bsizes &= 0xff;
1146 if (bsizes_more != 0xff) 1131 if (bsizes_more != 0xff)
@@ -1154,16 +1139,16 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1154 qec_init(bp); 1139 qec_init(bp);
1155 1140
1156 /* Map in the BigMAC channel registers. */ 1141 /* Map in the BigMAC channel registers. */
1157 bp->creg = sbus_ioremap(&bp->bigmac_sdev->resource[0], 0, 1142 bp->creg = of_ioremap(&op->resource[0], 0,
1158 CREG_REG_SIZE, "BigMAC QEC Channel Regs"); 1143 CREG_REG_SIZE, "BigMAC QEC Channel Regs");
1159 if (!bp->creg) { 1144 if (!bp->creg) {
1160 printk(KERN_ERR "BIGMAC: Cannot map QEC channel registers.\n"); 1145 printk(KERN_ERR "BIGMAC: Cannot map QEC channel registers.\n");
1161 goto fail_and_cleanup; 1146 goto fail_and_cleanup;
1162 } 1147 }
1163 1148
1164 /* Map in the BigMAC control registers. */ 1149 /* Map in the BigMAC control registers. */
1165 bp->bregs = sbus_ioremap(&bp->bigmac_sdev->resource[1], 0, 1150 bp->bregs = of_ioremap(&op->resource[1], 0,
1166 BMAC_REG_SIZE, "BigMAC Primary Regs"); 1151 BMAC_REG_SIZE, "BigMAC Primary Regs");
1167 if (!bp->bregs) { 1152 if (!bp->bregs) {
1168 printk(KERN_ERR "BIGMAC: Cannot map BigMAC primary registers.\n"); 1153 printk(KERN_ERR "BIGMAC: Cannot map BigMAC primary registers.\n");
1169 goto fail_and_cleanup; 1154 goto fail_and_cleanup;
@@ -1172,8 +1157,8 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1172 /* Map in the BigMAC transceiver registers, this is how you poke at 1157 /* Map in the BigMAC transceiver registers, this is how you poke at
1173 * the BigMAC's PHY. 1158 * the BigMAC's PHY.
1174 */ 1159 */
1175 bp->tregs = sbus_ioremap(&bp->bigmac_sdev->resource[2], 0, 1160 bp->tregs = of_ioremap(&op->resource[2], 0,
1176 TCVR_REG_SIZE, "BigMAC Transceiver Regs"); 1161 TCVR_REG_SIZE, "BigMAC Transceiver Regs");
1177 if (!bp->tregs) { 1162 if (!bp->tregs) {
1178 printk(KERN_ERR "BIGMAC: Cannot map BigMAC transceiver registers.\n"); 1163 printk(KERN_ERR "BIGMAC: Cannot map BigMAC transceiver registers.\n");
1179 goto fail_and_cleanup; 1164 goto fail_and_cleanup;
@@ -1183,17 +1168,17 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1183 bigmac_stop(bp); 1168 bigmac_stop(bp);
1184 1169
1185 /* Allocate transmit/receive descriptor DVMA block. */ 1170 /* Allocate transmit/receive descriptor DVMA block. */
1186 bp->bmac_block = sbus_alloc_consistent(bp->bigmac_sdev, 1171 bp->bmac_block = dma_alloc_coherent(&bp->bigmac_op->dev,
1187 PAGE_SIZE, 1172 PAGE_SIZE,
1188 &bp->bblock_dvma); 1173 &bp->bblock_dvma, GFP_ATOMIC);
1189 if (bp->bmac_block == NULL || bp->bblock_dvma == 0) { 1174 if (bp->bmac_block == NULL || bp->bblock_dvma == 0) {
1190 printk(KERN_ERR "BIGMAC: Cannot allocate consistent DMA.\n"); 1175 printk(KERN_ERR "BIGMAC: Cannot allocate consistent DMA.\n");
1191 goto fail_and_cleanup; 1176 goto fail_and_cleanup;
1192 } 1177 }
1193 1178
1194 /* Get the board revision of this BigMAC. */ 1179 /* Get the board revision of this BigMAC. */
1195 bp->board_rev = prom_getintdefault(bp->bigmac_sdev->prom_node, 1180 bp->board_rev = of_getintprop_default(bp->bigmac_op->node,
1196 "board-version", 1); 1181 "board-version", 1);
1197 1182
1198 /* Init auto-negotiation timer state. */ 1183 /* Init auto-negotiation timer state. */
1199 init_timer(&bp->bigmac_timer); 1184 init_timer(&bp->bigmac_timer);
@@ -1217,7 +1202,7 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1217 dev->watchdog_timeo = 5*HZ; 1202 dev->watchdog_timeo = 5*HZ;
1218 1203
1219 /* Finish net device registration. */ 1204 /* Finish net device registration. */
1220 dev->irq = bp->bigmac_sdev->irqs[0]; 1205 dev->irq = bp->bigmac_op->irqs[0];
1221 dev->dma = 0; 1206 dev->dma = 0;
1222 1207
1223 if (register_netdev(dev)) { 1208 if (register_netdev(dev)) {
@@ -1225,7 +1210,7 @@ static int __devinit bigmac_ether_init(struct sbus_dev *qec_sdev)
1225 goto fail_and_cleanup; 1210 goto fail_and_cleanup;
1226 } 1211 }
1227 1212
1228 dev_set_drvdata(&bp->bigmac_sdev->ofdev.dev, bp); 1213 dev_set_drvdata(&bp->bigmac_op->dev, bp);
1229 1214
1230 printk(KERN_INFO "%s: BigMAC 100baseT Ethernet %s\n", 1215 printk(KERN_INFO "%s: BigMAC 100baseT Ethernet %s\n",
1231 dev->name, print_mac(mac, dev->dev_addr)); 1216 dev->name, print_mac(mac, dev->dev_addr));
@@ -1236,66 +1221,67 @@ fail_and_cleanup:
1236 /* Something went wrong, undo whatever we did so far. */ 1221 /* Something went wrong, undo whatever we did so far. */
1237 /* Free register mappings if any. */ 1222 /* Free register mappings if any. */
1238 if (bp->gregs) 1223 if (bp->gregs)
1239 sbus_iounmap(bp->gregs, GLOB_REG_SIZE); 1224 of_iounmap(&qec_op->resource[0], bp->gregs, GLOB_REG_SIZE);
1240 if (bp->creg) 1225 if (bp->creg)
1241 sbus_iounmap(bp->creg, CREG_REG_SIZE); 1226 of_iounmap(&op->resource[0], bp->creg, CREG_REG_SIZE);
1242 if (bp->bregs) 1227 if (bp->bregs)
1243 sbus_iounmap(bp->bregs, BMAC_REG_SIZE); 1228 of_iounmap(&op->resource[1], bp->bregs, BMAC_REG_SIZE);
1244 if (bp->tregs) 1229 if (bp->tregs)
1245 sbus_iounmap(bp->tregs, TCVR_REG_SIZE); 1230 of_iounmap(&op->resource[2], bp->tregs, TCVR_REG_SIZE);
1246 1231
1247 if (bp->bmac_block) 1232 if (bp->bmac_block)
1248 sbus_free_consistent(bp->bigmac_sdev, 1233 dma_free_coherent(&bp->bigmac_op->dev,
1249 PAGE_SIZE, 1234 PAGE_SIZE,
1250 bp->bmac_block, 1235 bp->bmac_block,
1251 bp->bblock_dvma); 1236 bp->bblock_dvma);
1252 1237
1253 /* This also frees the co-located 'dev->priv' */ 1238 /* This also frees the co-located 'dev->priv' */
1254 free_netdev(dev); 1239 free_netdev(dev);
1255 return -ENODEV; 1240 return -ENODEV;
1256} 1241}
1257 1242
1258/* QEC can be the parent of either QuadEthernet or 1243/* QEC can be the parent of either QuadEthernet or a BigMAC. We want
1259 * a BigMAC. We want the latter. 1244 * the latter.
1260 */ 1245 */
1261static int __devinit bigmac_sbus_probe(struct of_device *dev, const struct of_device_id *match) 1246static int __devinit bigmac_sbus_probe(struct of_device *op,
1247 const struct of_device_id *match)
1262{ 1248{
1263 struct sbus_dev *sdev = to_sbus_device(&dev->dev); 1249 struct device *parent = op->dev.parent;
1264 struct device_node *dp = dev->node; 1250 struct of_device *qec_op;
1265 1251
1266 if (!strcmp(dp->name, "be")) 1252 qec_op = to_of_device(parent);
1267 sdev = sdev->parent;
1268 1253
1269 return bigmac_ether_init(sdev); 1254 return bigmac_ether_init(op, qec_op);
1270} 1255}
1271 1256
1272static int __devexit bigmac_sbus_remove(struct of_device *dev) 1257static int __devexit bigmac_sbus_remove(struct of_device *op)
1273{ 1258{
1274 struct bigmac *bp = dev_get_drvdata(&dev->dev); 1259 struct bigmac *bp = dev_get_drvdata(&op->dev);
1260 struct device *parent = op->dev.parent;
1275 struct net_device *net_dev = bp->dev; 1261 struct net_device *net_dev = bp->dev;
1262 struct of_device *qec_op;
1263
1264 qec_op = to_of_device(parent);
1276 1265
1277 unregister_netdev(net_dev); 1266 unregister_netdev(net_dev);
1278 1267
1279 sbus_iounmap(bp->gregs, GLOB_REG_SIZE); 1268 of_iounmap(&qec_op->resource[0], bp->gregs, GLOB_REG_SIZE);
1280 sbus_iounmap(bp->creg, CREG_REG_SIZE); 1269 of_iounmap(&op->resource[0], bp->creg, CREG_REG_SIZE);
1281 sbus_iounmap(bp->bregs, BMAC_REG_SIZE); 1270 of_iounmap(&op->resource[1], bp->bregs, BMAC_REG_SIZE);
1282 sbus_iounmap(bp->tregs, TCVR_REG_SIZE); 1271 of_iounmap(&op->resource[2], bp->tregs, TCVR_REG_SIZE);
1283 sbus_free_consistent(bp->bigmac_sdev, 1272 dma_free_coherent(&op->dev,
1284 PAGE_SIZE, 1273 PAGE_SIZE,
1285 bp->bmac_block, 1274 bp->bmac_block,
1286 bp->bblock_dvma); 1275 bp->bblock_dvma);
1287 1276
1288 free_netdev(net_dev); 1277 free_netdev(net_dev);
1289 1278
1290 dev_set_drvdata(&dev->dev, NULL); 1279 dev_set_drvdata(&op->dev, NULL);
1291 1280
1292 return 0; 1281 return 0;
1293} 1282}
1294 1283
1295static struct of_device_id bigmac_sbus_match[] = { 1284static const struct of_device_id bigmac_sbus_match[] = {
1296 {
1297 .name = "qec",
1298 },
1299 { 1285 {
1300 .name = "be", 1286 .name = "be",
1301 }, 1287 },
@@ -1313,7 +1299,7 @@ static struct of_platform_driver bigmac_sbus_driver = {
1313 1299
1314static int __init bigmac_init(void) 1300static int __init bigmac_init(void)
1315{ 1301{
1316 return of_register_driver(&bigmac_sbus_driver, &sbus_bus_type); 1302 return of_register_driver(&bigmac_sbus_driver, &of_bus_type);
1317} 1303}
1318 1304
1319static void __exit bigmac_exit(void) 1305static void __exit bigmac_exit(void)
diff --git a/drivers/net/sunbmac.h b/drivers/net/sunbmac.h
index b563d3c2993e..8840bc0b840b 100644
--- a/drivers/net/sunbmac.h
+++ b/drivers/net/sunbmac.h
@@ -329,8 +329,8 @@ struct bigmac {
329 unsigned int timer_ticks; 329 unsigned int timer_ticks;
330 330
331 struct net_device_stats enet_stats; 331 struct net_device_stats enet_stats;
332 struct sbus_dev *qec_sdev; 332 struct of_device *qec_op;
333 struct sbus_dev *bigmac_sdev; 333 struct of_device *bigmac_op;
334 struct net_device *dev; 334 struct net_device *dev;
335}; 335};
336 336
diff --git a/drivers/net/sunhme.c b/drivers/net/sunhme.c
index b79d5f018f79..f1ebeb5f65b2 100644
--- a/drivers/net/sunhme.c
+++ b/drivers/net/sunhme.c
@@ -3,7 +3,7 @@
3 * "Happy Meal Ethernet" found on SunSwift SBUS cards. 3 * "Happy Meal Ethernet" found on SunSwift SBUS cards.
4 * 4 *
5 * Copyright (C) 1996, 1998, 1999, 2002, 2003, 5 * Copyright (C) 1996, 1998, 1999, 2002, 2003,
6 2006 David S. Miller (davem@davemloft.net) 6 * 2006, 2008 David S. Miller (davem@davemloft.net)
7 * 7 *
8 * Changes : 8 * Changes :
9 * 2000/11/11 Willy Tarreau <willy AT meta-x.org> 9 * 2000/11/11 Willy Tarreau <willy AT meta-x.org>
@@ -34,6 +34,7 @@
34#include <linux/skbuff.h> 34#include <linux/skbuff.h>
35#include <linux/mm.h> 35#include <linux/mm.h>
36#include <linux/bitops.h> 36#include <linux/bitops.h>
37#include <linux/dma-mapping.h>
37 38
38#include <asm/system.h> 39#include <asm/system.h>
39#include <asm/io.h> 40#include <asm/io.h>
@@ -41,8 +42,9 @@
41#include <asm/byteorder.h> 42#include <asm/byteorder.h>
42 43
43#ifdef CONFIG_SPARC 44#ifdef CONFIG_SPARC
45#include <linux/of.h>
46#include <linux/of_device.h>
44#include <asm/idprom.h> 47#include <asm/idprom.h>
45#include <asm/sbus.h>
46#include <asm/openprom.h> 48#include <asm/openprom.h>
47#include <asm/oplib.h> 49#include <asm/oplib.h>
48#include <asm/prom.h> 50#include <asm/prom.h>
@@ -60,8 +62,8 @@
60#include "sunhme.h" 62#include "sunhme.h"
61 63
62#define DRV_NAME "sunhme" 64#define DRV_NAME "sunhme"
63#define DRV_VERSION "3.00" 65#define DRV_VERSION "3.10"
64#define DRV_RELDATE "June 23, 2006" 66#define DRV_RELDATE "August 26, 2008"
65#define DRV_AUTHOR "David S. Miller (davem@davemloft.net)" 67#define DRV_AUTHOR "David S. Miller (davem@davemloft.net)"
66 68
67static char version[] = 69static char version[] =
@@ -251,13 +253,13 @@ static u32 pci_hme_read_desc32(hme32 *p)
251#define hme_read_desc32(__hp, __p) \ 253#define hme_read_desc32(__hp, __p) \
252 ((__hp)->read_desc32(__p)) 254 ((__hp)->read_desc32(__p))
253#define hme_dma_map(__hp, __ptr, __size, __dir) \ 255#define hme_dma_map(__hp, __ptr, __size, __dir) \
254 ((__hp)->dma_map((__hp)->happy_dev, (__ptr), (__size), (__dir))) 256 ((__hp)->dma_map((__hp)->dma_dev, (__ptr), (__size), (__dir)))
255#define hme_dma_unmap(__hp, __addr, __size, __dir) \ 257#define hme_dma_unmap(__hp, __addr, __size, __dir) \
256 ((__hp)->dma_unmap((__hp)->happy_dev, (__addr), (__size), (__dir))) 258 ((__hp)->dma_unmap((__hp)->dma_dev, (__addr), (__size), (__dir)))
257#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \ 259#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \
258 ((__hp)->dma_sync_for_cpu((__hp)->happy_dev, (__addr), (__size), (__dir))) 260 ((__hp)->dma_sync_for_cpu((__hp)->dma_dev, (__addr), (__size), (__dir)))
259#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \ 261#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \
260 ((__hp)->dma_sync_for_device((__hp)->happy_dev, (__addr), (__size), (__dir))) 262 ((__hp)->dma_sync_for_device((__hp)->dma_dev, (__addr), (__size), (__dir)))
261#else 263#else
262#ifdef CONFIG_SBUS 264#ifdef CONFIG_SBUS
263/* SBUS only compilation */ 265/* SBUS only compilation */
@@ -277,13 +279,13 @@ do { (__txd)->tx_addr = (__force hme32)(u32)(__addr); \
277} while(0) 279} while(0)
278#define hme_read_desc32(__hp, __p) ((__force u32)(hme32)*(__p)) 280#define hme_read_desc32(__hp, __p) ((__force u32)(hme32)*(__p))
279#define hme_dma_map(__hp, __ptr, __size, __dir) \ 281#define hme_dma_map(__hp, __ptr, __size, __dir) \
280 sbus_map_single((__hp)->happy_dev, (__ptr), (__size), (__dir)) 282 dma_map_single((__hp)->dma_dev, (__ptr), (__size), (__dir))
281#define hme_dma_unmap(__hp, __addr, __size, __dir) \ 283#define hme_dma_unmap(__hp, __addr, __size, __dir) \
282 sbus_unmap_single((__hp)->happy_dev, (__addr), (__size), (__dir)) 284 dma_unmap_single((__hp)->dma_dev, (__addr), (__size), (__dir))
283#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \ 285#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \
284 sbus_dma_sync_single_for_cpu((__hp)->happy_dev, (__addr), (__size), (__dir)) 286 dma_dma_sync_single_for_cpu((__hp)->dma_dev, (__addr), (__size), (__dir))
285#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \ 287#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \
286 sbus_dma_sync_single_for_device((__hp)->happy_dev, (__addr), (__size), (__dir)) 288 dma_dma_sync_single_for_device((__hp)->dma_dev, (__addr), (__size), (__dir))
287#else 289#else
288/* PCI only compilation */ 290/* PCI only compilation */
289#define hme_write32(__hp, __reg, __val) \ 291#define hme_write32(__hp, __reg, __val) \
@@ -305,36 +307,17 @@ static inline u32 hme_read_desc32(struct happy_meal *hp, hme32 *p)
305 return le32_to_cpup((__le32 *)p); 307 return le32_to_cpup((__le32 *)p);
306} 308}
307#define hme_dma_map(__hp, __ptr, __size, __dir) \ 309#define hme_dma_map(__hp, __ptr, __size, __dir) \
308 pci_map_single((__hp)->happy_dev, (__ptr), (__size), (__dir)) 310 pci_map_single((__hp)->dma_dev, (__ptr), (__size), (__dir))
309#define hme_dma_unmap(__hp, __addr, __size, __dir) \ 311#define hme_dma_unmap(__hp, __addr, __size, __dir) \
310 pci_unmap_single((__hp)->happy_dev, (__addr), (__size), (__dir)) 312 pci_unmap_single((__hp)->dma_dev, (__addr), (__size), (__dir))
311#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \ 313#define hme_dma_sync_for_cpu(__hp, __addr, __size, __dir) \
312 pci_dma_sync_single_for_cpu((__hp)->happy_dev, (__addr), (__size), (__dir)) 314 pci_dma_sync_single_for_cpu((__hp)->dma_dev, (__addr), (__size), (__dir))
313#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \ 315#define hme_dma_sync_for_device(__hp, __addr, __size, __dir) \
314 pci_dma_sync_single_for_device((__hp)->happy_dev, (__addr), (__size), (__dir)) 316 pci_dma_sync_single_for_device((__hp)->dma_dev, (__addr), (__size), (__dir))
315#endif 317#endif
316#endif 318#endif
317 319
318 320
319#ifdef SBUS_DMA_BIDIRECTIONAL
320# define DMA_BIDIRECTIONAL SBUS_DMA_BIDIRECTIONAL
321#else
322# define DMA_BIDIRECTIONAL 0
323#endif
324
325#ifdef SBUS_DMA_FROMDEVICE
326# define DMA_FROMDEVICE SBUS_DMA_FROMDEVICE
327#else
328# define DMA_TODEVICE 1
329#endif
330
331#ifdef SBUS_DMA_TODEVICE
332# define DMA_TODEVICE SBUS_DMA_TODEVICE
333#else
334# define DMA_FROMDEVICE 2
335#endif
336
337
338/* Oh yes, the MIF BitBang is mighty fun to program. BitBucket is more like it. */ 321/* Oh yes, the MIF BitBang is mighty fun to program. BitBucket is more like it. */
339static void BB_PUT_BIT(struct happy_meal *hp, void __iomem *tregs, int bit) 322static void BB_PUT_BIT(struct happy_meal *hp, void __iomem *tregs, int bit)
340{ 323{
@@ -1224,7 +1207,8 @@ static void happy_meal_clean_rings(struct happy_meal *hp)
1224 1207
1225 rxd = &hp->happy_block->happy_meal_rxd[i]; 1208 rxd = &hp->happy_block->happy_meal_rxd[i];
1226 dma_addr = hme_read_desc32(hp, &rxd->rx_addr); 1209 dma_addr = hme_read_desc32(hp, &rxd->rx_addr);
1227 hme_dma_unmap(hp, dma_addr, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE); 1210 dma_unmap_single(hp->dma_dev, dma_addr,
1211 RX_BUF_ALLOC_SIZE, DMA_FROM_DEVICE);
1228 dev_kfree_skb_any(skb); 1212 dev_kfree_skb_any(skb);
1229 hp->rx_skbs[i] = NULL; 1213 hp->rx_skbs[i] = NULL;
1230 } 1214 }
@@ -1242,10 +1226,10 @@ static void happy_meal_clean_rings(struct happy_meal *hp)
1242 for (frag = 0; frag <= skb_shinfo(skb)->nr_frags; frag++) { 1226 for (frag = 0; frag <= skb_shinfo(skb)->nr_frags; frag++) {
1243 txd = &hp->happy_block->happy_meal_txd[i]; 1227 txd = &hp->happy_block->happy_meal_txd[i];
1244 dma_addr = hme_read_desc32(hp, &txd->tx_addr); 1228 dma_addr = hme_read_desc32(hp, &txd->tx_addr);
1245 hme_dma_unmap(hp, dma_addr, 1229 dma_unmap_single(hp->dma_dev, dma_addr,
1246 (hme_read_desc32(hp, &txd->tx_flags) 1230 (hme_read_desc32(hp, &txd->tx_flags)
1247 & TXFLAG_SIZE), 1231 & TXFLAG_SIZE),
1248 DMA_TODEVICE); 1232 DMA_TO_DEVICE);
1249 1233
1250 if (frag != skb_shinfo(skb)->nr_frags) 1234 if (frag != skb_shinfo(skb)->nr_frags)
1251 i++; 1235 i++;
@@ -1287,7 +1271,8 @@ static void happy_meal_init_rings(struct happy_meal *hp)
1287 skb_put(skb, (ETH_FRAME_LEN + RX_OFFSET + 4)); 1271 skb_put(skb, (ETH_FRAME_LEN + RX_OFFSET + 4));
1288 hme_write_rxd(hp, &hb->happy_meal_rxd[i], 1272 hme_write_rxd(hp, &hb->happy_meal_rxd[i],
1289 (RXFLAG_OWN | ((RX_BUF_ALLOC_SIZE - RX_OFFSET) << 16)), 1273 (RXFLAG_OWN | ((RX_BUF_ALLOC_SIZE - RX_OFFSET) << 16)),
1290 hme_dma_map(hp, skb->data, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE)); 1274 dma_map_single(hp->dma_dev, skb->data, RX_BUF_ALLOC_SIZE,
1275 DMA_FROM_DEVICE));
1291 skb_reserve(skb, RX_OFFSET); 1276 skb_reserve(skb, RX_OFFSET);
1292 } 1277 }
1293 1278
@@ -1593,7 +1578,7 @@ static int happy_meal_init(struct happy_meal *hp)
1593 if ((hp->happy_bursts & DMA_BURST64) && 1578 if ((hp->happy_bursts & DMA_BURST64) &&
1594 ((hp->happy_flags & HFLAG_PCI) != 0 1579 ((hp->happy_flags & HFLAG_PCI) != 0
1595#ifdef CONFIG_SBUS 1580#ifdef CONFIG_SBUS
1596 || sbus_can_burst64(hp->happy_dev) 1581 || sbus_can_burst64()
1597#endif 1582#endif
1598 || 0)) { 1583 || 0)) {
1599 u32 gcfg = GREG_CFG_BURST64; 1584 u32 gcfg = GREG_CFG_BURST64;
@@ -1603,11 +1588,13 @@ static int happy_meal_init(struct happy_meal *hp)
1603 * do not. -DaveM 1588 * do not. -DaveM
1604 */ 1589 */
1605#ifdef CONFIG_SBUS 1590#ifdef CONFIG_SBUS
1606 if ((hp->happy_flags & HFLAG_PCI) == 0 && 1591 if ((hp->happy_flags & HFLAG_PCI) == 0) {
1607 sbus_can_dma_64bit(hp->happy_dev)) { 1592 struct of_device *op = hp->happy_dev;
1608 sbus_set_sbus64(hp->happy_dev, 1593 if (sbus_can_dma_64bit()) {
1609 hp->happy_bursts); 1594 sbus_set_sbus64(&op->dev,
1610 gcfg |= GREG_CFG_64BIT; 1595 hp->happy_bursts);
1596 gcfg |= GREG_CFG_64BIT;
1597 }
1611 } 1598 }
1612#endif 1599#endif
1613 1600
@@ -1966,7 +1953,7 @@ static void happy_meal_tx(struct happy_meal *hp)
1966 dma_len = hme_read_desc32(hp, &this->tx_flags); 1953 dma_len = hme_read_desc32(hp, &this->tx_flags);
1967 1954
1968 dma_len &= TXFLAG_SIZE; 1955 dma_len &= TXFLAG_SIZE;
1969 hme_dma_unmap(hp, dma_addr, dma_len, DMA_TODEVICE); 1956 dma_unmap_single(hp->dma_dev, dma_addr, dma_len, DMA_TO_DEVICE);
1970 1957
1971 elem = NEXT_TX(elem); 1958 elem = NEXT_TX(elem);
1972 this = &txbase[elem]; 1959 this = &txbase[elem];
@@ -2044,13 +2031,14 @@ static void happy_meal_rx(struct happy_meal *hp, struct net_device *dev)
2044 drops++; 2031 drops++;
2045 goto drop_it; 2032 goto drop_it;
2046 } 2033 }
2047 hme_dma_unmap(hp, dma_addr, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE); 2034 dma_unmap_single(hp->dma_dev, dma_addr, RX_BUF_ALLOC_SIZE, DMA_FROM_DEVICE);
2048 hp->rx_skbs[elem] = new_skb; 2035 hp->rx_skbs[elem] = new_skb;
2049 new_skb->dev = dev; 2036 new_skb->dev = dev;
2050 skb_put(new_skb, (ETH_FRAME_LEN + RX_OFFSET + 4)); 2037 skb_put(new_skb, (ETH_FRAME_LEN + RX_OFFSET + 4));
2051 hme_write_rxd(hp, this, 2038 hme_write_rxd(hp, this,
2052 (RXFLAG_OWN|((RX_BUF_ALLOC_SIZE-RX_OFFSET)<<16)), 2039 (RXFLAG_OWN|((RX_BUF_ALLOC_SIZE-RX_OFFSET)<<16)),
2053 hme_dma_map(hp, new_skb->data, RX_BUF_ALLOC_SIZE, DMA_FROMDEVICE)); 2040 dma_map_single(hp->dma_dev, new_skb->data, RX_BUF_ALLOC_SIZE,
2041 DMA_FROM_DEVICE));
2054 skb_reserve(new_skb, RX_OFFSET); 2042 skb_reserve(new_skb, RX_OFFSET);
2055 2043
2056 /* Trim the original skb for the netif. */ 2044 /* Trim the original skb for the netif. */
@@ -2065,10 +2053,9 @@ static void happy_meal_rx(struct happy_meal *hp, struct net_device *dev)
2065 2053
2066 skb_reserve(copy_skb, 2); 2054 skb_reserve(copy_skb, 2);
2067 skb_put(copy_skb, len); 2055 skb_put(copy_skb, len);
2068 hme_dma_sync_for_cpu(hp, dma_addr, len, DMA_FROMDEVICE); 2056 dma_sync_single_for_cpu(hp->dma_dev, dma_addr, len, DMA_FROM_DEVICE);
2069 skb_copy_from_linear_data(skb, copy_skb->data, len); 2057 skb_copy_from_linear_data(skb, copy_skb->data, len);
2070 hme_dma_sync_for_device(hp, dma_addr, len, DMA_FROMDEVICE); 2058 dma_sync_single_for_device(hp->dma_dev, dma_addr, len, DMA_FROM_DEVICE);
2071
2072 /* Reuse original ring buffer. */ 2059 /* Reuse original ring buffer. */
2073 hme_write_rxd(hp, this, 2060 hme_write_rxd(hp, this,
2074 (RXFLAG_OWN|((RX_BUF_ALLOC_SIZE-RX_OFFSET)<<16)), 2061 (RXFLAG_OWN|((RX_BUF_ALLOC_SIZE-RX_OFFSET)<<16)),
@@ -2300,7 +2287,7 @@ static int happy_meal_start_xmit(struct sk_buff *skb, struct net_device *dev)
2300 u32 mapping, len; 2287 u32 mapping, len;
2301 2288
2302 len = skb->len; 2289 len = skb->len;
2303 mapping = hme_dma_map(hp, skb->data, len, DMA_TODEVICE); 2290 mapping = dma_map_single(hp->dma_dev, skb->data, len, DMA_TO_DEVICE);
2304 tx_flags |= (TXFLAG_SOP | TXFLAG_EOP); 2291 tx_flags |= (TXFLAG_SOP | TXFLAG_EOP);
2305 hme_write_txd(hp, &hp->happy_block->happy_meal_txd[entry], 2292 hme_write_txd(hp, &hp->happy_block->happy_meal_txd[entry],
2306 (tx_flags | (len & TXFLAG_SIZE)), 2293 (tx_flags | (len & TXFLAG_SIZE)),
@@ -2314,7 +2301,8 @@ static int happy_meal_start_xmit(struct sk_buff *skb, struct net_device *dev)
2314 * Otherwise we could race with the device. 2301 * Otherwise we could race with the device.
2315 */ 2302 */
2316 first_len = skb_headlen(skb); 2303 first_len = skb_headlen(skb);
2317 first_mapping = hme_dma_map(hp, skb->data, first_len, DMA_TODEVICE); 2304 first_mapping = dma_map_single(hp->dma_dev, skb->data, first_len,
2305 DMA_TO_DEVICE);
2318 entry = NEXT_TX(entry); 2306 entry = NEXT_TX(entry);
2319 2307
2320 for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) { 2308 for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
@@ -2322,10 +2310,9 @@ static int happy_meal_start_xmit(struct sk_buff *skb, struct net_device *dev)
2322 u32 len, mapping, this_txflags; 2310 u32 len, mapping, this_txflags;
2323 2311
2324 len = this_frag->size; 2312 len = this_frag->size;
2325 mapping = hme_dma_map(hp, 2313 mapping = dma_map_page(hp->dma_dev, this_frag->page,
2326 ((void *) page_address(this_frag->page) + 2314 this_frag->page_offset, len,
2327 this_frag->page_offset), 2315 DMA_TO_DEVICE);
2328 len, DMA_TODEVICE);
2329 this_txflags = tx_flags; 2316 this_txflags = tx_flags;
2330 if (frag == skb_shinfo(skb)->nr_frags - 1) 2317 if (frag == skb_shinfo(skb)->nr_frags - 1)
2331 this_txflags |= TXFLAG_EOP; 2318 this_txflags |= TXFLAG_EOP;
@@ -2493,9 +2480,12 @@ static void hme_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info
2493 } 2480 }
2494#ifdef CONFIG_SBUS 2481#ifdef CONFIG_SBUS
2495 else { 2482 else {
2496 struct sbus_dev *sdev = hp->happy_dev; 2483 const struct linux_prom_registers *regs;
2497 sprintf(info->bus_info, "SBUS:%d", 2484 struct of_device *op = hp->happy_dev;
2498 sdev->slot); 2485 regs = of_get_property(op->node, "regs", NULL);
2486 if (regs)
2487 sprintf(info->bus_info, "SBUS:%d",
2488 regs->which_io);
2499 } 2489 }
2500#endif 2490#endif
2501} 2491}
@@ -2521,63 +2511,21 @@ static const struct ethtool_ops hme_ethtool_ops = {
2521static int hme_version_printed; 2511static int hme_version_printed;
2522 2512
2523#ifdef CONFIG_SBUS 2513#ifdef CONFIG_SBUS
2524void __devinit quattro_get_ranges(struct quattro *qp)
2525{
2526 struct sbus_dev *sdev = qp->quattro_dev;
2527 int err;
2528
2529 err = prom_getproperty(sdev->prom_node,
2530 "ranges",
2531 (char *)&qp->ranges[0],
2532 sizeof(qp->ranges));
2533 if (err == 0 || err == -1) {
2534 qp->nranges = 0;
2535 return;
2536 }
2537 qp->nranges = (err / sizeof(struct linux_prom_ranges));
2538}
2539
2540static void __devinit quattro_apply_ranges(struct quattro *qp, struct happy_meal *hp)
2541{
2542 struct sbus_dev *sdev = hp->happy_dev;
2543 int rng;
2544
2545 for (rng = 0; rng < qp->nranges; rng++) {
2546 struct linux_prom_ranges *rngp = &qp->ranges[rng];
2547 int reg;
2548
2549 for (reg = 0; reg < 5; reg++) {
2550 if (sdev->reg_addrs[reg].which_io ==
2551 rngp->ot_child_space)
2552 break;
2553 }
2554 if (reg == 5)
2555 continue;
2556
2557 sdev->reg_addrs[reg].which_io = rngp->ot_parent_space;
2558 sdev->reg_addrs[reg].phys_addr += rngp->ot_parent_base;
2559 }
2560}
2561
2562/* Given a happy meal sbus device, find it's quattro parent. 2514/* Given a happy meal sbus device, find it's quattro parent.
2563 * If none exist, allocate and return a new one. 2515 * If none exist, allocate and return a new one.
2564 * 2516 *
2565 * Return NULL on failure. 2517 * Return NULL on failure.
2566 */ 2518 */
2567static struct quattro * __devinit quattro_sbus_find(struct sbus_dev *goal_sdev) 2519static struct quattro * __devinit quattro_sbus_find(struct of_device *child)
2568{ 2520{
2569 struct sbus_dev *sdev; 2521 struct device *parent = child->dev.parent;
2522 struct of_device *op;
2570 struct quattro *qp; 2523 struct quattro *qp;
2571 int i;
2572 2524
2573 for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) { 2525 op = to_of_device(parent);
2574 for (i = 0, sdev = qp->quattro_dev; 2526 qp = dev_get_drvdata(&op->dev);
2575 (sdev != NULL) && (i < 4); 2527 if (qp)
2576 sdev = sdev->next, i++) { 2528 return qp;
2577 if (sdev == goal_sdev)
2578 return qp;
2579 }
2580 }
2581 2529
2582 qp = kmalloc(sizeof(struct quattro), GFP_KERNEL); 2530 qp = kmalloc(sizeof(struct quattro), GFP_KERNEL);
2583 if (qp != NULL) { 2531 if (qp != NULL) {
@@ -2586,10 +2534,11 @@ static struct quattro * __devinit quattro_sbus_find(struct sbus_dev *goal_sdev)
2586 for (i = 0; i < 4; i++) 2534 for (i = 0; i < 4; i++)
2587 qp->happy_meals[i] = NULL; 2535 qp->happy_meals[i] = NULL;
2588 2536
2589 qp->quattro_dev = goal_sdev; 2537 qp->quattro_dev = child;
2590 qp->next = qfe_sbus_list; 2538 qp->next = qfe_sbus_list;
2591 qfe_sbus_list = qp; 2539 qfe_sbus_list = qp;
2592 quattro_get_ranges(qp); 2540
2541 dev_set_drvdata(&op->dev, qp);
2593 } 2542 }
2594 return qp; 2543 return qp;
2595} 2544}
@@ -2602,10 +2551,10 @@ static void __init quattro_sbus_register_irqs(void)
2602 struct quattro *qp; 2551 struct quattro *qp;
2603 2552
2604 for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) { 2553 for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) {
2605 struct sbus_dev *sdev = qp->quattro_dev; 2554 struct of_device *op = qp->quattro_dev;
2606 int err; 2555 int err;
2607 2556
2608 err = request_irq(sdev->irqs[0], 2557 err = request_irq(op->irqs[0],
2609 quattro_sbus_interrupt, 2558 quattro_sbus_interrupt,
2610 IRQF_SHARED, "Quattro", 2559 IRQF_SHARED, "Quattro",
2611 qp); 2560 qp);
@@ -2621,9 +2570,9 @@ static void quattro_sbus_free_irqs(void)
2621 struct quattro *qp; 2570 struct quattro *qp;
2622 2571
2623 for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) { 2572 for (qp = qfe_sbus_list; qp != NULL; qp = qp->next) {
2624 struct sbus_dev *sdev = qp->quattro_dev; 2573 struct of_device *op = qp->quattro_dev;
2625 2574
2626 free_irq(sdev->irqs[0], qp); 2575 free_irq(op->irqs[0], qp);
2627 } 2576 }
2628} 2577}
2629#endif /* CONFIG_SBUS */ 2578#endif /* CONFIG_SBUS */
@@ -2660,9 +2609,9 @@ static struct quattro * __devinit quattro_pci_find(struct pci_dev *pdev)
2660#endif /* CONFIG_PCI */ 2609#endif /* CONFIG_PCI */
2661 2610
2662#ifdef CONFIG_SBUS 2611#ifdef CONFIG_SBUS
2663static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe) 2612static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
2664{ 2613{
2665 struct device_node *dp = sdev->ofdev.node; 2614 struct device_node *dp = op->node, *sbus_dp;
2666 struct quattro *qp = NULL; 2615 struct quattro *qp = NULL;
2667 struct happy_meal *hp; 2616 struct happy_meal *hp;
2668 struct net_device *dev; 2617 struct net_device *dev;
@@ -2671,7 +2620,7 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2671 DECLARE_MAC_BUF(mac); 2620 DECLARE_MAC_BUF(mac);
2672 2621
2673 if (is_qfe) { 2622 if (is_qfe) {
2674 qp = quattro_sbus_find(sdev); 2623 qp = quattro_sbus_find(op);
2675 if (qp == NULL) 2624 if (qp == NULL)
2676 goto err_out; 2625 goto err_out;
2677 for (qfe_slot = 0; qfe_slot < 4; qfe_slot++) 2626 for (qfe_slot = 0; qfe_slot < 4; qfe_slot++)
@@ -2685,7 +2634,7 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2685 dev = alloc_etherdev(sizeof(struct happy_meal)); 2634 dev = alloc_etherdev(sizeof(struct happy_meal));
2686 if (!dev) 2635 if (!dev)
2687 goto err_out; 2636 goto err_out;
2688 SET_NETDEV_DEV(dev, &sdev->ofdev.dev); 2637 SET_NETDEV_DEV(dev, &op->dev);
2689 2638
2690 if (hme_version_printed++ == 0) 2639 if (hme_version_printed++ == 0)
2691 printk(KERN_INFO "%s", version); 2640 printk(KERN_INFO "%s", version);
@@ -2713,56 +2662,50 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2713 memcpy(dev->dev_addr, idprom->id_ethaddr, 6); 2662 memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
2714 } 2663 }
2715 2664
2716 hp = dev->priv; 2665 hp = netdev_priv(dev);
2717 2666
2718 hp->happy_dev = sdev; 2667 hp->happy_dev = op;
2668 hp->dma_dev = &op->dev;
2719 2669
2720 spin_lock_init(&hp->happy_lock); 2670 spin_lock_init(&hp->happy_lock);
2721 2671
2722 err = -ENODEV; 2672 err = -ENODEV;
2723 if (sdev->num_registers != 5) {
2724 printk(KERN_ERR "happymeal: Device needs 5 regs, has %d.\n",
2725 sdev->num_registers);
2726 goto err_out_free_netdev;
2727 }
2728
2729 if (qp != NULL) { 2673 if (qp != NULL) {
2730 hp->qfe_parent = qp; 2674 hp->qfe_parent = qp;
2731 hp->qfe_ent = qfe_slot; 2675 hp->qfe_ent = qfe_slot;
2732 qp->happy_meals[qfe_slot] = dev; 2676 qp->happy_meals[qfe_slot] = dev;
2733 quattro_apply_ranges(qp, hp);
2734 } 2677 }
2735 2678
2736 hp->gregs = sbus_ioremap(&sdev->resource[0], 0, 2679 hp->gregs = of_ioremap(&op->resource[0], 0,
2737 GREG_REG_SIZE, "HME Global Regs"); 2680 GREG_REG_SIZE, "HME Global Regs");
2738 if (!hp->gregs) { 2681 if (!hp->gregs) {
2739 printk(KERN_ERR "happymeal: Cannot map global registers.\n"); 2682 printk(KERN_ERR "happymeal: Cannot map global registers.\n");
2740 goto err_out_free_netdev; 2683 goto err_out_free_netdev;
2741 } 2684 }
2742 2685
2743 hp->etxregs = sbus_ioremap(&sdev->resource[1], 0, 2686 hp->etxregs = of_ioremap(&op->resource[1], 0,
2744 ETX_REG_SIZE, "HME TX Regs"); 2687 ETX_REG_SIZE, "HME TX Regs");
2745 if (!hp->etxregs) { 2688 if (!hp->etxregs) {
2746 printk(KERN_ERR "happymeal: Cannot map MAC TX registers.\n"); 2689 printk(KERN_ERR "happymeal: Cannot map MAC TX registers.\n");
2747 goto err_out_iounmap; 2690 goto err_out_iounmap;
2748 } 2691 }
2749 2692
2750 hp->erxregs = sbus_ioremap(&sdev->resource[2], 0, 2693 hp->erxregs = of_ioremap(&op->resource[2], 0,
2751 ERX_REG_SIZE, "HME RX Regs"); 2694 ERX_REG_SIZE, "HME RX Regs");
2752 if (!hp->erxregs) { 2695 if (!hp->erxregs) {
2753 printk(KERN_ERR "happymeal: Cannot map MAC RX registers.\n"); 2696 printk(KERN_ERR "happymeal: Cannot map MAC RX registers.\n");
2754 goto err_out_iounmap; 2697 goto err_out_iounmap;
2755 } 2698 }
2756 2699
2757 hp->bigmacregs = sbus_ioremap(&sdev->resource[3], 0, 2700 hp->bigmacregs = of_ioremap(&op->resource[3], 0,
2758 BMAC_REG_SIZE, "HME BIGMAC Regs"); 2701 BMAC_REG_SIZE, "HME BIGMAC Regs");
2759 if (!hp->bigmacregs) { 2702 if (!hp->bigmacregs) {
2760 printk(KERN_ERR "happymeal: Cannot map BIGMAC registers.\n"); 2703 printk(KERN_ERR "happymeal: Cannot map BIGMAC registers.\n");
2761 goto err_out_iounmap; 2704 goto err_out_iounmap;
2762 } 2705 }
2763 2706
2764 hp->tcvregs = sbus_ioremap(&sdev->resource[4], 0, 2707 hp->tcvregs = of_ioremap(&op->resource[4], 0,
2765 TCVR_REG_SIZE, "HME Tranceiver Regs"); 2708 TCVR_REG_SIZE, "HME Tranceiver Regs");
2766 if (!hp->tcvregs) { 2709 if (!hp->tcvregs) {
2767 printk(KERN_ERR "happymeal: Cannot map TCVR registers.\n"); 2710 printk(KERN_ERR "happymeal: Cannot map TCVR registers.\n");
2768 goto err_out_iounmap; 2711 goto err_out_iounmap;
@@ -2781,13 +2724,18 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2781 if (qp != NULL) 2724 if (qp != NULL)
2782 hp->happy_flags |= HFLAG_QUATTRO; 2725 hp->happy_flags |= HFLAG_QUATTRO;
2783 2726
2727 sbus_dp = to_of_device(op->dev.parent)->node;
2728 if (is_qfe)
2729 sbus_dp = to_of_device(op->dev.parent->parent)->node;
2730
2784 /* Get the supported DVMA burst sizes from our Happy SBUS. */ 2731 /* Get the supported DVMA burst sizes from our Happy SBUS. */
2785 hp->happy_bursts = of_getintprop_default(sdev->bus->ofdev.node, 2732 hp->happy_bursts = of_getintprop_default(sbus_dp,
2786 "burst-sizes", 0x00); 2733 "burst-sizes", 0x00);
2787 2734
2788 hp->happy_block = sbus_alloc_consistent(hp->happy_dev, 2735 hp->happy_block = dma_alloc_coherent(hp->dma_dev,
2789 PAGE_SIZE, 2736 PAGE_SIZE,
2790 &hp->hblock_dvma); 2737 &hp->hblock_dvma,
2738 GFP_ATOMIC);
2791 err = -ENOMEM; 2739 err = -ENOMEM;
2792 if (!hp->happy_block) { 2740 if (!hp->happy_block) {
2793 printk(KERN_ERR "happymeal: Cannot allocate descriptors.\n"); 2741 printk(KERN_ERR "happymeal: Cannot allocate descriptors.\n");
@@ -2816,19 +2764,13 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2816 /* Happy Meal can do it all... */ 2764 /* Happy Meal can do it all... */
2817 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM; 2765 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
2818 2766
2819 dev->irq = sdev->irqs[0]; 2767 dev->irq = op->irqs[0];
2820 2768
2821#if defined(CONFIG_SBUS) && defined(CONFIG_PCI) 2769#if defined(CONFIG_SBUS) && defined(CONFIG_PCI)
2822 /* Hook up PCI register/dma accessors. */ 2770 /* Hook up SBUS register/descriptor accessors. */
2823 hp->read_desc32 = sbus_hme_read_desc32; 2771 hp->read_desc32 = sbus_hme_read_desc32;
2824 hp->write_txd = sbus_hme_write_txd; 2772 hp->write_txd = sbus_hme_write_txd;
2825 hp->write_rxd = sbus_hme_write_rxd; 2773 hp->write_rxd = sbus_hme_write_rxd;
2826 hp->dma_map = (u32 (*)(void *, void *, long, int))sbus_map_single;
2827 hp->dma_unmap = (void (*)(void *, u32, long, int))sbus_unmap_single;
2828 hp->dma_sync_for_cpu = (void (*)(void *, u32, long, int))
2829 sbus_dma_sync_single_for_cpu;
2830 hp->dma_sync_for_device = (void (*)(void *, u32, long, int))
2831 sbus_dma_sync_single_for_device;
2832 hp->read32 = sbus_hme_read32; 2774 hp->read32 = sbus_hme_read32;
2833 hp->write32 = sbus_hme_write32; 2775 hp->write32 = sbus_hme_write32;
2834#endif 2776#endif
@@ -2843,10 +2785,10 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2843 if (register_netdev(hp->dev)) { 2785 if (register_netdev(hp->dev)) {
2844 printk(KERN_ERR "happymeal: Cannot register net device, " 2786 printk(KERN_ERR "happymeal: Cannot register net device, "
2845 "aborting.\n"); 2787 "aborting.\n");
2846 goto err_out_free_consistent; 2788 goto err_out_free_coherent;
2847 } 2789 }
2848 2790
2849 dev_set_drvdata(&sdev->ofdev.dev, hp); 2791 dev_set_drvdata(&op->dev, hp);
2850 2792
2851 if (qfe_slot != -1) 2793 if (qfe_slot != -1)
2852 printk(KERN_INFO "%s: Quattro HME slot %d (SBUS) 10/100baseT Ethernet ", 2794 printk(KERN_INFO "%s: Quattro HME slot %d (SBUS) 10/100baseT Ethernet ",
@@ -2859,23 +2801,23 @@ static int __devinit happy_meal_sbus_probe_one(struct sbus_dev *sdev, int is_qfe
2859 2801
2860 return 0; 2802 return 0;
2861 2803
2862err_out_free_consistent: 2804err_out_free_coherent:
2863 sbus_free_consistent(hp->happy_dev, 2805 dma_free_coherent(hp->dma_dev,
2864 PAGE_SIZE, 2806 PAGE_SIZE,
2865 hp->happy_block, 2807 hp->happy_block,
2866 hp->hblock_dvma); 2808 hp->hblock_dvma);
2867 2809
2868err_out_iounmap: 2810err_out_iounmap:
2869 if (hp->gregs) 2811 if (hp->gregs)
2870 sbus_iounmap(hp->gregs, GREG_REG_SIZE); 2812 of_iounmap(&op->resource[0], hp->gregs, GREG_REG_SIZE);
2871 if (hp->etxregs) 2813 if (hp->etxregs)
2872 sbus_iounmap(hp->etxregs, ETX_REG_SIZE); 2814 of_iounmap(&op->resource[1], hp->etxregs, ETX_REG_SIZE);
2873 if (hp->erxregs) 2815 if (hp->erxregs)
2874 sbus_iounmap(hp->erxregs, ERX_REG_SIZE); 2816 of_iounmap(&op->resource[2], hp->erxregs, ERX_REG_SIZE);
2875 if (hp->bigmacregs) 2817 if (hp->bigmacregs)
2876 sbus_iounmap(hp->bigmacregs, BMAC_REG_SIZE); 2818 of_iounmap(&op->resource[3], hp->bigmacregs, BMAC_REG_SIZE);
2877 if (hp->tcvregs) 2819 if (hp->tcvregs)
2878 sbus_iounmap(hp->tcvregs, TCVR_REG_SIZE); 2820 of_iounmap(&op->resource[4], hp->tcvregs, TCVR_REG_SIZE);
2879 2821
2880err_out_free_netdev: 2822err_out_free_netdev:
2881 free_netdev(dev); 2823 free_netdev(dev);
@@ -3035,6 +2977,7 @@ static int __devinit happy_meal_pci_probe(struct pci_dev *pdev,
3035 memset(hp, 0, sizeof(*hp)); 2977 memset(hp, 0, sizeof(*hp));
3036 2978
3037 hp->happy_dev = pdev; 2979 hp->happy_dev = pdev;
2980 hp->dma_dev = &pdev->dev;
3038 2981
3039 spin_lock_init(&hp->happy_lock); 2982 spin_lock_init(&hp->happy_lock);
3040 2983
@@ -3121,7 +3064,7 @@ static int __devinit happy_meal_pci_probe(struct pci_dev *pdev,
3121#endif 3064#endif
3122 3065
3123 hp->happy_block = (struct hmeal_init_block *) 3066 hp->happy_block = (struct hmeal_init_block *)
3124 pci_alloc_consistent(pdev, PAGE_SIZE, &hp->hblock_dvma); 3067 dma_alloc_coherent(&pdev->dev, PAGE_SIZE, &hp->hblock_dvma, GFP_KERNEL);
3125 3068
3126 err = -ENODEV; 3069 err = -ENODEV;
3127 if (!hp->happy_block) { 3070 if (!hp->happy_block) {
@@ -3151,16 +3094,10 @@ static int __devinit happy_meal_pci_probe(struct pci_dev *pdev,
3151 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM; 3094 dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
3152 3095
3153#if defined(CONFIG_SBUS) && defined(CONFIG_PCI) 3096#if defined(CONFIG_SBUS) && defined(CONFIG_PCI)
3154 /* Hook up PCI register/dma accessors. */ 3097 /* Hook up PCI register/descriptor accessors. */
3155 hp->read_desc32 = pci_hme_read_desc32; 3098 hp->read_desc32 = pci_hme_read_desc32;
3156 hp->write_txd = pci_hme_write_txd; 3099 hp->write_txd = pci_hme_write_txd;
3157 hp->write_rxd = pci_hme_write_rxd; 3100 hp->write_rxd = pci_hme_write_rxd;
3158 hp->dma_map = (u32 (*)(void *, void *, long, int))pci_map_single;
3159 hp->dma_unmap = (void (*)(void *, u32, long, int))pci_unmap_single;
3160 hp->dma_sync_for_cpu = (void (*)(void *, u32, long, int))
3161 pci_dma_sync_single_for_cpu;
3162 hp->dma_sync_for_device = (void (*)(void *, u32, long, int))
3163 pci_dma_sync_single_for_device;
3164 hp->read32 = pci_hme_read32; 3101 hp->read32 = pci_hme_read32;
3165 hp->write32 = pci_hme_write32; 3102 hp->write32 = pci_hme_write32;
3166#endif 3103#endif
@@ -3231,10 +3168,8 @@ static void __devexit happy_meal_pci_remove(struct pci_dev *pdev)
3231 3168
3232 unregister_netdev(net_dev); 3169 unregister_netdev(net_dev);
3233 3170
3234 pci_free_consistent(hp->happy_dev, 3171 dma_free_coherent(hp->dma_dev, PAGE_SIZE,
3235 PAGE_SIZE, 3172 hp->happy_block, hp->hblock_dvma);
3236 hp->happy_block,
3237 hp->hblock_dvma);
3238 iounmap(hp->gregs); 3173 iounmap(hp->gregs);
3239 pci_release_regions(hp->happy_dev); 3174 pci_release_regions(hp->happy_dev);
3240 3175
@@ -3279,46 +3214,45 @@ static void happy_meal_pci_exit(void)
3279#endif 3214#endif
3280 3215
3281#ifdef CONFIG_SBUS 3216#ifdef CONFIG_SBUS
3282static int __devinit hme_sbus_probe(struct of_device *dev, const struct of_device_id *match) 3217static int __devinit hme_sbus_probe(struct of_device *op, const struct of_device_id *match)
3283{ 3218{
3284 struct sbus_dev *sdev = to_sbus_device(&dev->dev); 3219 struct device_node *dp = op->node;
3285 struct device_node *dp = dev->node;
3286 const char *model = of_get_property(dp, "model", NULL); 3220 const char *model = of_get_property(dp, "model", NULL);
3287 int is_qfe = (match->data != NULL); 3221 int is_qfe = (match->data != NULL);
3288 3222
3289 if (!is_qfe && model && !strcmp(model, "SUNW,sbus-qfe")) 3223 if (!is_qfe && model && !strcmp(model, "SUNW,sbus-qfe"))
3290 is_qfe = 1; 3224 is_qfe = 1;
3291 3225
3292 return happy_meal_sbus_probe_one(sdev, is_qfe); 3226 return happy_meal_sbus_probe_one(op, is_qfe);
3293} 3227}
3294 3228
3295static int __devexit hme_sbus_remove(struct of_device *dev) 3229static int __devexit hme_sbus_remove(struct of_device *op)
3296{ 3230{
3297 struct happy_meal *hp = dev_get_drvdata(&dev->dev); 3231 struct happy_meal *hp = dev_get_drvdata(&op->dev);
3298 struct net_device *net_dev = hp->dev; 3232 struct net_device *net_dev = hp->dev;
3299 3233
3300 unregister_netdev(net_dev); 3234 unregister_netdev(net_dev);
3301 3235
3302 /* XXX qfe parent interrupt... */ 3236 /* XXX qfe parent interrupt... */
3303 3237
3304 sbus_iounmap(hp->gregs, GREG_REG_SIZE); 3238 of_iounmap(&op->resource[0], hp->gregs, GREG_REG_SIZE);
3305 sbus_iounmap(hp->etxregs, ETX_REG_SIZE); 3239 of_iounmap(&op->resource[1], hp->etxregs, ETX_REG_SIZE);
3306 sbus_iounmap(hp->erxregs, ERX_REG_SIZE); 3240 of_iounmap(&op->resource[2], hp->erxregs, ERX_REG_SIZE);
3307 sbus_iounmap(hp->bigmacregs, BMAC_REG_SIZE); 3241 of_iounmap(&op->resource[3], hp->bigmacregs, BMAC_REG_SIZE);
3308 sbus_iounmap(hp->tcvregs, TCVR_REG_SIZE); 3242 of_iounmap(&op->resource[4], hp->tcvregs, TCVR_REG_SIZE);
3309 sbus_free_consistent(hp->happy_dev, 3243 dma_free_coherent(hp->dma_dev,
3310 PAGE_SIZE, 3244 PAGE_SIZE,
3311 hp->happy_block, 3245 hp->happy_block,
3312 hp->hblock_dvma); 3246 hp->hblock_dvma);
3313 3247
3314 free_netdev(net_dev); 3248 free_netdev(net_dev);
3315 3249
3316 dev_set_drvdata(&dev->dev, NULL); 3250 dev_set_drvdata(&op->dev, NULL);
3317 3251
3318 return 0; 3252 return 0;
3319} 3253}
3320 3254
3321static struct of_device_id hme_sbus_match[] = { 3255static const struct of_device_id hme_sbus_match[] = {
3322 { 3256 {
3323 .name = "SUNW,hme", 3257 .name = "SUNW,hme",
3324 }, 3258 },
@@ -3346,7 +3280,7 @@ static int __init happy_meal_sbus_init(void)
3346{ 3280{
3347 int err; 3281 int err;
3348 3282
3349 err = of_register_driver(&hme_sbus_driver, &sbus_bus_type); 3283 err = of_register_driver(&hme_sbus_driver, &of_bus_type);
3350 if (!err) 3284 if (!err)
3351 quattro_sbus_register_irqs(); 3285 quattro_sbus_register_irqs();
3352 3286
diff --git a/drivers/net/sunhme.h b/drivers/net/sunhme.h
index 4da5539fac7b..efd2ca0fcad3 100644
--- a/drivers/net/sunhme.h
+++ b/drivers/net/sunhme.h
@@ -405,14 +405,11 @@ struct happy_meal {
405 u32 (*read_desc32)(hme32 *); 405 u32 (*read_desc32)(hme32 *);
406 void (*write_txd)(struct happy_meal_txd *, u32, u32); 406 void (*write_txd)(struct happy_meal_txd *, u32, u32);
407 void (*write_rxd)(struct happy_meal_rxd *, u32, u32); 407 void (*write_rxd)(struct happy_meal_rxd *, u32, u32);
408 u32 (*dma_map)(void *, void *, long, int);
409 void (*dma_unmap)(void *, u32, long, int);
410 void (*dma_sync_for_cpu)(void *, u32, long, int);
411 void (*dma_sync_for_device)(void *, u32, long, int);
412#endif 408#endif
413 409
414 /* This is either a sbus_dev or a pci_dev. */ 410 /* This is either an of_device or a pci_dev. */
415 void *happy_dev; 411 void *happy_dev;
412 struct device *dma_dev;
416 413
417 spinlock_t happy_lock; 414 spinlock_t happy_lock;
418 415
diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index 4e994f87469e..704301a5a7ff 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -91,6 +91,9 @@ static char lancestr[] = "LANCE";
91#include <linux/skbuff.h> 91#include <linux/skbuff.h>
92#include <linux/ethtool.h> 92#include <linux/ethtool.h>
93#include <linux/bitops.h> 93#include <linux/bitops.h>
94#include <linux/dma-mapping.h>
95#include <linux/of.h>
96#include <linux/of_device.h>
94 97
95#include <asm/system.h> 98#include <asm/system.h>
96#include <asm/io.h> 99#include <asm/io.h>
@@ -98,7 +101,6 @@ static char lancestr[] = "LANCE";
98#include <asm/pgtable.h> 101#include <asm/pgtable.h>
99#include <asm/byteorder.h> /* Used by the checksum routines */ 102#include <asm/byteorder.h> /* Used by the checksum routines */
100#include <asm/idprom.h> 103#include <asm/idprom.h>
101#include <asm/sbus.h>
102#include <asm/prom.h> 104#include <asm/prom.h>
103#include <asm/auxio.h> /* For tpe-link-test? setting */ 105#include <asm/auxio.h> /* For tpe-link-test? setting */
104#include <asm/irq.h> 106#include <asm/irq.h>
@@ -248,7 +250,7 @@ struct lance_private {
248 int rx_new, tx_new; 250 int rx_new, tx_new;
249 int rx_old, tx_old; 251 int rx_old, tx_old;
250 252
251 struct sbus_dma *ledma; /* If set this points to ledma */ 253 struct of_device *ledma; /* If set this points to ledma */
252 char tpe; /* cable-selection is TPE */ 254 char tpe; /* cable-selection is TPE */
253 char auto_select; /* cable-selection by carrier */ 255 char auto_select; /* cable-selection by carrier */
254 char burst_sizes; /* ledma SBus burst sizes */ 256 char burst_sizes; /* ledma SBus burst sizes */
@@ -263,7 +265,8 @@ struct lance_private {
263 char *name; 265 char *name;
264 dma_addr_t init_block_dvma; 266 dma_addr_t init_block_dvma;
265 struct net_device *dev; /* Backpointer */ 267 struct net_device *dev; /* Backpointer */
266 struct sbus_dev *sdev; 268 struct of_device *op;
269 struct of_device *lebuffer;
267 struct timer_list multicast_timer; 270 struct timer_list multicast_timer;
268}; 271};
269 272
@@ -1272,27 +1275,29 @@ static void lance_set_multicast_retry(unsigned long _opaque)
1272static void lance_free_hwresources(struct lance_private *lp) 1275static void lance_free_hwresources(struct lance_private *lp)
1273{ 1276{
1274 if (lp->lregs) 1277 if (lp->lregs)
1275 sbus_iounmap(lp->lregs, LANCE_REG_SIZE); 1278 of_iounmap(&lp->op->resource[0], lp->lregs, LANCE_REG_SIZE);
1279 if (lp->dregs) {
1280 struct of_device *ledma = lp->ledma;
1281
1282 of_iounmap(&ledma->resource[0], lp->dregs,
1283 resource_size(&ledma->resource[0]));
1284 }
1276 if (lp->init_block_iomem) { 1285 if (lp->init_block_iomem) {
1277 sbus_iounmap(lp->init_block_iomem, 1286 of_iounmap(&lp->lebuffer->resource[0], lp->init_block_iomem,
1278 sizeof(struct lance_init_block)); 1287 sizeof(struct lance_init_block));
1279 } else if (lp->init_block_mem) { 1288 } else if (lp->init_block_mem) {
1280 sbus_free_consistent(lp->sdev, 1289 dma_free_coherent(&lp->op->dev,
1281 sizeof(struct lance_init_block), 1290 sizeof(struct lance_init_block),
1282 lp->init_block_mem, 1291 lp->init_block_mem,
1283 lp->init_block_dvma); 1292 lp->init_block_dvma);
1284 } 1293 }
1285} 1294}
1286 1295
1287/* Ethtool support... */ 1296/* Ethtool support... */
1288static void sparc_lance_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 1297static void sparc_lance_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1289{ 1298{
1290 struct lance_private *lp = netdev_priv(dev);
1291
1292 strcpy(info->driver, "sunlance"); 1299 strcpy(info->driver, "sunlance");
1293 strcpy(info->version, "2.02"); 1300 strcpy(info->version, "2.02");
1294 sprintf(info->bus_info, "SBUS:%d",
1295 lp->sdev->slot);
1296} 1301}
1297 1302
1298static u32 sparc_lance_get_link(struct net_device *dev) 1303static u32 sparc_lance_get_link(struct net_device *dev)
@@ -1308,16 +1313,16 @@ static const struct ethtool_ops sparc_lance_ethtool_ops = {
1308 .get_link = sparc_lance_get_link, 1313 .get_link = sparc_lance_get_link,
1309}; 1314};
1310 1315
1311static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev, 1316static int __devinit sparc_lance_probe_one(struct of_device *op,
1312 struct sbus_dma *ledma, 1317 struct of_device *ledma,
1313 struct sbus_dev *lebuffer) 1318 struct of_device *lebuffer)
1314{ 1319{
1320 struct device_node *dp = op->node;
1315 static unsigned version_printed; 1321 static unsigned version_printed;
1316 struct device_node *dp = sdev->ofdev.node;
1317 struct net_device *dev;
1318 struct lance_private *lp; 1322 struct lance_private *lp;
1319 int i; 1323 struct net_device *dev;
1320 DECLARE_MAC_BUF(mac); 1324 DECLARE_MAC_BUF(mac);
1325 int i;
1321 1326
1322 dev = alloc_etherdev(sizeof(struct lance_private) + 8); 1327 dev = alloc_etherdev(sizeof(struct lance_private) + 8);
1323 if (!dev) 1328 if (!dev)
@@ -1338,14 +1343,27 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
1338 dev->dev_addr[i] = idprom->id_ethaddr[i]; 1343 dev->dev_addr[i] = idprom->id_ethaddr[i];
1339 1344
1340 /* Get the IO region */ 1345 /* Get the IO region */
1341 lp->lregs = sbus_ioremap(&sdev->resource[0], 0, 1346 lp->lregs = of_ioremap(&op->resource[0], 0,
1342 LANCE_REG_SIZE, lancestr); 1347 LANCE_REG_SIZE, lancestr);
1343 if (!lp->lregs) { 1348 if (!lp->lregs) {
1344 printk(KERN_ERR "SunLance: Cannot map registers.\n"); 1349 printk(KERN_ERR "SunLance: Cannot map registers.\n");
1345 goto fail; 1350 goto fail;
1346 } 1351 }
1347 1352
1348 lp->sdev = sdev; 1353 lp->ledma = ledma;
1354 if (lp->ledma) {
1355 lp->dregs = of_ioremap(&ledma->resource[0], 0,
1356 resource_size(&ledma->resource[0]),
1357 "ledma");
1358 if (!lp->dregs) {
1359 printk(KERN_ERR "SunLance: Cannot map "
1360 "ledma registers.\n");
1361 goto fail;
1362 }
1363 }
1364
1365 lp->op = op;
1366 lp->lebuffer = lebuffer;
1349 if (lebuffer) { 1367 if (lebuffer) {
1350 /* sanity check */ 1368 /* sanity check */
1351 if (lebuffer->resource[0].start & 7) { 1369 if (lebuffer->resource[0].start & 7) {
@@ -1353,8 +1371,8 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
1353 goto fail; 1371 goto fail;
1354 } 1372 }
1355 lp->init_block_iomem = 1373 lp->init_block_iomem =
1356 sbus_ioremap(&lebuffer->resource[0], 0, 1374 of_ioremap(&lebuffer->resource[0], 0,
1357 sizeof(struct lance_init_block), "lebuffer"); 1375 sizeof(struct lance_init_block), "lebuffer");
1358 if (!lp->init_block_iomem) { 1376 if (!lp->init_block_iomem) {
1359 printk(KERN_ERR "SunLance: Cannot map PIO buffer.\n"); 1377 printk(KERN_ERR "SunLance: Cannot map PIO buffer.\n");
1360 goto fail; 1378 goto fail;
@@ -1366,9 +1384,10 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
1366 lp->tx = lance_tx_pio; 1384 lp->tx = lance_tx_pio;
1367 } else { 1385 } else {
1368 lp->init_block_mem = 1386 lp->init_block_mem =
1369 sbus_alloc_consistent(sdev, sizeof(struct lance_init_block), 1387 dma_alloc_coherent(&op->dev,
1370 &lp->init_block_dvma); 1388 sizeof(struct lance_init_block),
1371 if (!lp->init_block_mem || lp->init_block_dvma == 0) { 1389 &lp->init_block_dvma, GFP_ATOMIC);
1390 if (!lp->init_block_mem) {
1372 printk(KERN_ERR "SunLance: Cannot allocate consistent DMA memory.\n"); 1391 printk(KERN_ERR "SunLance: Cannot allocate consistent DMA memory.\n");
1373 goto fail; 1392 goto fail;
1374 } 1393 }
@@ -1383,13 +1402,13 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
1383 LE_C3_BCON)); 1402 LE_C3_BCON));
1384 1403
1385 lp->name = lancestr; 1404 lp->name = lancestr;
1386 lp->ledma = ledma;
1387 1405
1388 lp->burst_sizes = 0; 1406 lp->burst_sizes = 0;
1389 if (lp->ledma) { 1407 if (lp->ledma) {
1390 struct device_node *ledma_dp = ledma->sdev->ofdev.node; 1408 struct device_node *ledma_dp = ledma->node;
1391 const char *prop; 1409 struct device_node *sbus_dp;
1392 unsigned int sbmask; 1410 unsigned int sbmask;
1411 const char *prop;
1393 u32 csr; 1412 u32 csr;
1394 1413
1395 /* Find burst-size property for ledma */ 1414 /* Find burst-size property for ledma */
@@ -1397,7 +1416,8 @@ static int __devinit sparc_lance_probe_one(struct sbus_dev *sdev,
1397 "burst-sizes", 0); 1416 "burst-sizes", 0);
1398 1417
1399 /* ledma may be capable of fast bursts, but sbus may not. */ 1418 /* ledma may be capable of fast bursts, but sbus may not. */
1400 sbmask = of_getintprop_default(ledma_dp, "burst-sizes", 1419 sbus_dp = ledma_dp->parent;
1420 sbmask = of_getintprop_default(sbus_dp, "burst-sizes",
1401 DMA_BURSTBITS); 1421 DMA_BURSTBITS);
1402 lp->burst_sizes &= sbmask; 1422 lp->burst_sizes &= sbmask;
1403 1423
@@ -1435,8 +1455,6 @@ no_link_test:
1435 lp->tpe = 1; 1455 lp->tpe = 1;
1436 } 1456 }
1437 1457
1438 lp->dregs = ledma->regs;
1439
1440 /* Reset ledma */ 1458 /* Reset ledma */
1441 csr = sbus_readl(lp->dregs + DMA_CSR); 1459 csr = sbus_readl(lp->dregs + DMA_CSR);
1442 sbus_writel(csr | DMA_RST_ENET, lp->dregs + DMA_CSR); 1460 sbus_writel(csr | DMA_RST_ENET, lp->dregs + DMA_CSR);
@@ -1446,7 +1464,7 @@ no_link_test:
1446 lp->dregs = NULL; 1464 lp->dregs = NULL;
1447 1465
1448 lp->dev = dev; 1466 lp->dev = dev;
1449 SET_NETDEV_DEV(dev, &sdev->ofdev.dev); 1467 SET_NETDEV_DEV(dev, &op->dev);
1450 dev->open = &lance_open; 1468 dev->open = &lance_open;
1451 dev->stop = &lance_close; 1469 dev->stop = &lance_close;
1452 dev->hard_start_xmit = &lance_start_xmit; 1470 dev->hard_start_xmit = &lance_start_xmit;
@@ -1455,9 +1473,7 @@ no_link_test:
1455 dev->set_multicast_list = &lance_set_multicast; 1473 dev->set_multicast_list = &lance_set_multicast;
1456 dev->ethtool_ops = &sparc_lance_ethtool_ops; 1474 dev->ethtool_ops = &sparc_lance_ethtool_ops;
1457 1475
1458 dev->irq = sdev->irqs[0]; 1476 dev->irq = op->irqs[0];
1459
1460 dev->dma = 0;
1461 1477
1462 /* We cannot sleep if the chip is busy during a 1478 /* We cannot sleep if the chip is busy during a
1463 * multicast list update event, because such events 1479 * multicast list update event, because such events
@@ -1473,7 +1489,7 @@ no_link_test:
1473 goto fail; 1489 goto fail;
1474 } 1490 }
1475 1491
1476 dev_set_drvdata(&sdev->ofdev.dev, lp); 1492 dev_set_drvdata(&op->dev, lp);
1477 1493
1478 printk(KERN_INFO "%s: LANCE %s\n", 1494 printk(KERN_INFO "%s: LANCE %s\n",
1479 dev->name, print_mac(mac, dev->dev_addr)); 1495 dev->name, print_mac(mac, dev->dev_addr));
@@ -1486,80 +1502,25 @@ fail:
1486 return -ENODEV; 1502 return -ENODEV;
1487} 1503}
1488 1504
1489/* On 4m, find the associated dma for the lance chip */ 1505static int __devinit sunlance_sbus_probe(struct of_device *op, const struct of_device_id *match)
1490static struct sbus_dma * __devinit find_ledma(struct sbus_dev *sdev)
1491{
1492 struct sbus_dma *p;
1493
1494 for_each_dvma(p) {
1495 if (p->sdev == sdev)
1496 return p;
1497 }
1498 return NULL;
1499}
1500
1501#ifdef CONFIG_SUN4
1502
1503#include <asm/sun4paddr.h>
1504#include <asm/machines.h>
1505
1506/* Find all the lance cards on the system and initialize them */
1507static struct sbus_dev sun4_sdev;
1508static int __devinit sparc_lance_init(void)
1509{
1510 if ((idprom->id_machtype == (SM_SUN4|SM_4_330)) ||
1511 (idprom->id_machtype == (SM_SUN4|SM_4_470))) {
1512 memset(&sun4_sdev, 0, sizeof(struct sbus_dev));
1513 sun4_sdev.reg_addrs[0].phys_addr = sun4_eth_physaddr;
1514 sun4_sdev.irqs[0] = 6;
1515 return sparc_lance_probe_one(&sun4_sdev, NULL, NULL);
1516 }
1517 return -ENODEV;
1518}
1519
1520static int __exit sunlance_sun4_remove(void)
1521{ 1506{
1522 struct lance_private *lp = dev_get_drvdata(&sun4_sdev.ofdev.dev); 1507 struct of_device *parent = to_of_device(op->dev.parent);
1523 struct net_device *net_dev = lp->dev; 1508 struct device_node *parent_dp = parent->node;
1524
1525 unregister_netdev(net_dev);
1526
1527 lance_free_hwresources(lp);
1528
1529 free_netdev(net_dev);
1530
1531 dev_set_drvdata(&sun4_sdev.ofdev.dev, NULL);
1532
1533 return 0;
1534}
1535
1536#else /* !CONFIG_SUN4 */
1537
1538static int __devinit sunlance_sbus_probe(struct of_device *dev, const struct of_device_id *match)
1539{
1540 struct sbus_dev *sdev = to_sbus_device(&dev->dev);
1541 int err; 1509 int err;
1542 1510
1543 if (sdev->parent) { 1511 if (!strcmp(parent_dp->name, "ledma")) {
1544 struct of_device *parent = &sdev->parent->ofdev; 1512 err = sparc_lance_probe_one(op, parent, NULL);
1545 1513 } else if (!strcmp(parent_dp->name, "lebuffer")) {
1546 if (!strcmp(parent->node->name, "ledma")) { 1514 err = sparc_lance_probe_one(op, NULL, parent);
1547 struct sbus_dma *ledma = find_ledma(to_sbus_device(&parent->dev));
1548
1549 err = sparc_lance_probe_one(sdev, ledma, NULL);
1550 } else if (!strcmp(parent->node->name, "lebuffer")) {
1551 err = sparc_lance_probe_one(sdev, NULL, to_sbus_device(&parent->dev));
1552 } else
1553 err = sparc_lance_probe_one(sdev, NULL, NULL);
1554 } else 1515 } else
1555 err = sparc_lance_probe_one(sdev, NULL, NULL); 1516 err = sparc_lance_probe_one(op, NULL, NULL);
1556 1517
1557 return err; 1518 return err;
1558} 1519}
1559 1520
1560static int __devexit sunlance_sbus_remove(struct of_device *dev) 1521static int __devexit sunlance_sbus_remove(struct of_device *op)
1561{ 1522{
1562 struct lance_private *lp = dev_get_drvdata(&dev->dev); 1523 struct lance_private *lp = dev_get_drvdata(&op->dev);
1563 struct net_device *net_dev = lp->dev; 1524 struct net_device *net_dev = lp->dev;
1564 1525
1565 unregister_netdev(net_dev); 1526 unregister_netdev(net_dev);
@@ -1568,12 +1529,12 @@ static int __devexit sunlance_sbus_remove(struct of_device *dev)
1568 1529
1569 free_netdev(net_dev); 1530 free_netdev(net_dev);
1570 1531
1571 dev_set_drvdata(&dev->dev, NULL); 1532 dev_set_drvdata(&op->dev, NULL);
1572 1533
1573 return 0; 1534 return 0;
1574} 1535}
1575 1536
1576static struct of_device_id sunlance_sbus_match[] = { 1537static const struct of_device_id sunlance_sbus_match[] = {
1577 { 1538 {
1578 .name = "le", 1539 .name = "le",
1579 }, 1540 },
@@ -1593,17 +1554,12 @@ static struct of_platform_driver sunlance_sbus_driver = {
1593/* Find all the lance cards on the system and initialize them */ 1554/* Find all the lance cards on the system and initialize them */
1594static int __init sparc_lance_init(void) 1555static int __init sparc_lance_init(void)
1595{ 1556{
1596 return of_register_driver(&sunlance_sbus_driver, &sbus_bus_type); 1557 return of_register_driver(&sunlance_sbus_driver, &of_bus_type);
1597} 1558}
1598#endif /* !CONFIG_SUN4 */
1599 1559
1600static void __exit sparc_lance_exit(void) 1560static void __exit sparc_lance_exit(void)
1601{ 1561{
1602#ifdef CONFIG_SUN4
1603 sunlance_sun4_remove();
1604#else
1605 of_unregister_driver(&sunlance_sbus_driver); 1562 of_unregister_driver(&sunlance_sbus_driver);
1606#endif
1607} 1563}
1608 1564
1609module_init(sparc_lance_init); 1565module_init(sparc_lance_init);
diff --git a/drivers/net/sunqe.c b/drivers/net/sunqe.c
index e811331d4608..f63644744ff9 100644
--- a/drivers/net/sunqe.c
+++ b/drivers/net/sunqe.c
@@ -3,7 +3,7 @@
3 * controller out there can be most efficiently programmed 3 * controller out there can be most efficiently programmed
4 * if you make it look like a LANCE. 4 * if you make it look like a LANCE.
5 * 5 *
6 * Copyright (C) 1996, 1999, 2003, 2006 David S. Miller (davem@davemloft.net) 6 * Copyright (C) 1996, 1999, 2003, 2006, 2008 David S. Miller (davem@davemloft.net)
7 */ 7 */
8 8
9#include <linux/module.h> 9#include <linux/module.h>
@@ -24,13 +24,15 @@
24#include <linux/skbuff.h> 24#include <linux/skbuff.h>
25#include <linux/ethtool.h> 25#include <linux/ethtool.h>
26#include <linux/bitops.h> 26#include <linux/bitops.h>
27#include <linux/dma-mapping.h>
28#include <linux/of.h>
29#include <linux/of_device.h>
27 30
28#include <asm/system.h> 31#include <asm/system.h>
29#include <asm/io.h> 32#include <asm/io.h>
30#include <asm/dma.h> 33#include <asm/dma.h>
31#include <asm/byteorder.h> 34#include <asm/byteorder.h>
32#include <asm/idprom.h> 35#include <asm/idprom.h>
33#include <asm/sbus.h>
34#include <asm/openprom.h> 36#include <asm/openprom.h>
35#include <asm/oplib.h> 37#include <asm/oplib.h>
36#include <asm/auxio.h> 38#include <asm/auxio.h>
@@ -40,8 +42,8 @@
40#include "sunqe.h" 42#include "sunqe.h"
41 43
42#define DRV_NAME "sunqe" 44#define DRV_NAME "sunqe"
43#define DRV_VERSION "4.0" 45#define DRV_VERSION "4.1"
44#define DRV_RELDATE "June 23, 2006" 46#define DRV_RELDATE "August 27, 2008"
45#define DRV_AUTHOR "David S. Miller (davem@davemloft.net)" 47#define DRV_AUTHOR "David S. Miller (davem@davemloft.net)"
46 48
47static char version[] = 49static char version[] =
@@ -690,12 +692,18 @@ static void qe_set_multicast(struct net_device *dev)
690/* Ethtool support... */ 692/* Ethtool support... */
691static void qe_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 693static void qe_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
692{ 694{
695 const struct linux_prom_registers *regs;
693 struct sunqe *qep = dev->priv; 696 struct sunqe *qep = dev->priv;
697 struct of_device *op;
694 698
695 strcpy(info->driver, "sunqe"); 699 strcpy(info->driver, "sunqe");
696 strcpy(info->version, "3.0"); 700 strcpy(info->version, "3.0");
697 sprintf(info->bus_info, "SBUS:%d", 701
698 qep->qe_sdev->slot); 702 op = qep->op;
703 regs = of_get_property(op->node, "reg", NULL);
704 if (regs)
705 sprintf(info->bus_info, "SBUS:%d", regs->which_io);
706
699} 707}
700 708
701static u32 qe_get_link(struct net_device *dev) 709static u32 qe_get_link(struct net_device *dev)
@@ -717,11 +725,11 @@ static const struct ethtool_ops qe_ethtool_ops = {
717}; 725};
718 726
719/* This is only called once at boot time for each card probed. */ 727/* This is only called once at boot time for each card probed. */
720static inline void qec_init_once(struct sunqec *qecp, struct sbus_dev *qsdev) 728static void qec_init_once(struct sunqec *qecp, struct of_device *op)
721{ 729{
722 u8 bsizes = qecp->qec_bursts; 730 u8 bsizes = qecp->qec_bursts;
723 731
724 if (sbus_can_burst64(qsdev) && (bsizes & DMA_BURST64)) { 732 if (sbus_can_burst64() && (bsizes & DMA_BURST64)) {
725 sbus_writel(GLOB_CTRL_B64, qecp->gregs + GLOB_CTRL); 733 sbus_writel(GLOB_CTRL_B64, qecp->gregs + GLOB_CTRL);
726 } else if (bsizes & DMA_BURST32) { 734 } else if (bsizes & DMA_BURST32) {
727 sbus_writel(GLOB_CTRL_B32, qecp->gregs + GLOB_CTRL); 735 sbus_writel(GLOB_CTRL_B32, qecp->gregs + GLOB_CTRL);
@@ -735,15 +743,15 @@ static inline void qec_init_once(struct sunqec *qecp, struct sbus_dev *qsdev)
735 sbus_writel(GLOB_PSIZE_2048, qecp->gregs + GLOB_PSIZE); 743 sbus_writel(GLOB_PSIZE_2048, qecp->gregs + GLOB_PSIZE);
736 744
737 /* Set the local memsize register, divided up to one piece per QE channel. */ 745 /* Set the local memsize register, divided up to one piece per QE channel. */
738 sbus_writel((qsdev->reg_addrs[1].reg_size >> 2), 746 sbus_writel((resource_size(&op->resource[1]) >> 2),
739 qecp->gregs + GLOB_MSIZE); 747 qecp->gregs + GLOB_MSIZE);
740 748
741 /* Divide up the local QEC memory amongst the 4 QE receiver and 749 /* Divide up the local QEC memory amongst the 4 QE receiver and
742 * transmitter FIFOs. Basically it is (total / 2 / num_channels). 750 * transmitter FIFOs. Basically it is (total / 2 / num_channels).
743 */ 751 */
744 sbus_writel((qsdev->reg_addrs[1].reg_size >> 2) >> 1, 752 sbus_writel((resource_size(&op->resource[1]) >> 2) >> 1,
745 qecp->gregs + GLOB_TSIZE); 753 qecp->gregs + GLOB_TSIZE);
746 sbus_writel((qsdev->reg_addrs[1].reg_size >> 2) >> 1, 754 sbus_writel((resource_size(&op->resource[1]) >> 2) >> 1,
747 qecp->gregs + GLOB_RSIZE); 755 qecp->gregs + GLOB_RSIZE);
748} 756}
749 757
@@ -767,24 +775,21 @@ static u8 __devinit qec_get_burst(struct device_node *dp)
767 return bsizes; 775 return bsizes;
768} 776}
769 777
770static struct sunqec * __devinit get_qec(struct sbus_dev *child_sdev) 778static struct sunqec * __devinit get_qec(struct of_device *child)
771{ 779{
772 struct sbus_dev *qec_sdev = child_sdev->parent; 780 struct of_device *op = to_of_device(child->dev.parent);
773 struct sunqec *qecp; 781 struct sunqec *qecp;
774 782
775 for (qecp = root_qec_dev; qecp; qecp = qecp->next_module) { 783 qecp = dev_get_drvdata(&op->dev);
776 if (qecp->qec_sdev == qec_sdev)
777 break;
778 }
779 if (!qecp) { 784 if (!qecp) {
780 qecp = kzalloc(sizeof(struct sunqec), GFP_KERNEL); 785 qecp = kzalloc(sizeof(struct sunqec), GFP_KERNEL);
781 if (qecp) { 786 if (qecp) {
782 u32 ctrl; 787 u32 ctrl;
783 788
784 qecp->qec_sdev = qec_sdev; 789 qecp->op = op;
785 qecp->gregs = sbus_ioremap(&qec_sdev->resource[0], 0, 790 qecp->gregs = of_ioremap(&op->resource[0], 0,
786 GLOB_REG_SIZE, 791 GLOB_REG_SIZE,
787 "QEC Global Registers"); 792 "QEC Global Registers");
788 if (!qecp->gregs) 793 if (!qecp->gregs)
789 goto fail; 794 goto fail;
790 795
@@ -799,16 +804,18 @@ static struct sunqec * __devinit get_qec(struct sbus_dev *child_sdev)
799 if (qec_global_reset(qecp->gregs)) 804 if (qec_global_reset(qecp->gregs))
800 goto fail; 805 goto fail;
801 806
802 qecp->qec_bursts = qec_get_burst(qec_sdev->ofdev.node); 807 qecp->qec_bursts = qec_get_burst(op->node);
803 808
804 qec_init_once(qecp, qec_sdev); 809 qec_init_once(qecp, op);
805 810
806 if (request_irq(qec_sdev->irqs[0], &qec_interrupt, 811 if (request_irq(op->irqs[0], &qec_interrupt,
807 IRQF_SHARED, "qec", (void *) qecp)) { 812 IRQF_SHARED, "qec", (void *) qecp)) {
808 printk(KERN_ERR "qec: Can't register irq.\n"); 813 printk(KERN_ERR "qec: Can't register irq.\n");
809 goto fail; 814 goto fail;
810 } 815 }
811 816
817 dev_set_drvdata(&op->dev, qecp);
818
812 qecp->next_module = root_qec_dev; 819 qecp->next_module = root_qec_dev;
813 root_qec_dev = qecp; 820 root_qec_dev = qecp;
814 } 821 }
@@ -818,17 +825,17 @@ static struct sunqec * __devinit get_qec(struct sbus_dev *child_sdev)
818 825
819fail: 826fail:
820 if (qecp->gregs) 827 if (qecp->gregs)
821 sbus_iounmap(qecp->gregs, GLOB_REG_SIZE); 828 of_iounmap(&op->resource[0], qecp->gregs, GLOB_REG_SIZE);
822 kfree(qecp); 829 kfree(qecp);
823 return NULL; 830 return NULL;
824} 831}
825 832
826static int __devinit qec_ether_init(struct sbus_dev *sdev) 833static int __devinit qec_ether_init(struct of_device *op)
827{ 834{
828 static unsigned version_printed; 835 static unsigned version_printed;
829 struct net_device *dev; 836 struct net_device *dev;
830 struct sunqe *qe;
831 struct sunqec *qecp; 837 struct sunqec *qecp;
838 struct sunqe *qe;
832 int i, res; 839 int i, res;
833 840
834 if (version_printed++ == 0) 841 if (version_printed++ == 0)
@@ -842,49 +849,42 @@ static int __devinit qec_ether_init(struct sbus_dev *sdev)
842 849
843 qe = netdev_priv(dev); 850 qe = netdev_priv(dev);
844 851
845 i = of_getintprop_default(sdev->ofdev.node, "channel#", -1); 852 res = -ENODEV;
846 if (i == -1) { 853
847 struct sbus_dev *td = sdev->parent->child; 854 i = of_getintprop_default(op->node, "channel#", -1);
848 i = 0; 855 if (i == -1)
849 while (td != sdev) { 856 goto fail;
850 td = td->next;
851 i++;
852 }
853 }
854 qe->channel = i; 857 qe->channel = i;
855 spin_lock_init(&qe->lock); 858 spin_lock_init(&qe->lock);
856 859
857 res = -ENODEV; 860 qecp = get_qec(op);
858 qecp = get_qec(sdev);
859 if (!qecp) 861 if (!qecp)
860 goto fail; 862 goto fail;
861 863
862 qecp->qes[qe->channel] = qe; 864 qecp->qes[qe->channel] = qe;
863 qe->dev = dev; 865 qe->dev = dev;
864 qe->parent = qecp; 866 qe->parent = qecp;
865 qe->qe_sdev = sdev; 867 qe->op = op;
866 868
867 res = -ENOMEM; 869 res = -ENOMEM;
868 qe->qcregs = sbus_ioremap(&qe->qe_sdev->resource[0], 0, 870 qe->qcregs = of_ioremap(&op->resource[0], 0,
869 CREG_REG_SIZE, "QEC Channel Registers"); 871 CREG_REG_SIZE, "QEC Channel Registers");
870 if (!qe->qcregs) { 872 if (!qe->qcregs) {
871 printk(KERN_ERR "qe: Cannot map channel registers.\n"); 873 printk(KERN_ERR "qe: Cannot map channel registers.\n");
872 goto fail; 874 goto fail;
873 } 875 }
874 876
875 qe->mregs = sbus_ioremap(&qe->qe_sdev->resource[1], 0, 877 qe->mregs = of_ioremap(&op->resource[1], 0,
876 MREGS_REG_SIZE, "QE MACE Registers"); 878 MREGS_REG_SIZE, "QE MACE Registers");
877 if (!qe->mregs) { 879 if (!qe->mregs) {
878 printk(KERN_ERR "qe: Cannot map MACE registers.\n"); 880 printk(KERN_ERR "qe: Cannot map MACE registers.\n");
879 goto fail; 881 goto fail;
880 } 882 }
881 883
882 qe->qe_block = sbus_alloc_consistent(qe->qe_sdev, 884 qe->qe_block = dma_alloc_coherent(&op->dev, PAGE_SIZE,
883 PAGE_SIZE, 885 &qe->qblock_dvma, GFP_ATOMIC);
884 &qe->qblock_dvma); 886 qe->buffers = dma_alloc_coherent(&op->dev, sizeof(struct sunqe_buffers),
885 qe->buffers = sbus_alloc_consistent(qe->qe_sdev, 887 &qe->buffers_dvma, GFP_ATOMIC);
886 sizeof(struct sunqe_buffers),
887 &qe->buffers_dvma);
888 if (qe->qe_block == NULL || qe->qblock_dvma == 0 || 888 if (qe->qe_block == NULL || qe->qblock_dvma == 0 ||
889 qe->buffers == NULL || qe->buffers_dvma == 0) 889 qe->buffers == NULL || qe->buffers_dvma == 0)
890 goto fail; 890 goto fail;
@@ -892,7 +892,7 @@ static int __devinit qec_ether_init(struct sbus_dev *sdev)
892 /* Stop this QE. */ 892 /* Stop this QE. */
893 qe_stop(qe); 893 qe_stop(qe);
894 894
895 SET_NETDEV_DEV(dev, &sdev->ofdev.dev); 895 SET_NETDEV_DEV(dev, &op->dev);
896 896
897 dev->open = qe_open; 897 dev->open = qe_open;
898 dev->stop = qe_close; 898 dev->stop = qe_close;
@@ -900,7 +900,7 @@ static int __devinit qec_ether_init(struct sbus_dev *sdev)
900 dev->set_multicast_list = qe_set_multicast; 900 dev->set_multicast_list = qe_set_multicast;
901 dev->tx_timeout = qe_tx_timeout; 901 dev->tx_timeout = qe_tx_timeout;
902 dev->watchdog_timeo = 5*HZ; 902 dev->watchdog_timeo = 5*HZ;
903 dev->irq = sdev->irqs[0]; 903 dev->irq = op->irqs[0];
904 dev->dma = 0; 904 dev->dma = 0;
905 dev->ethtool_ops = &qe_ethtool_ops; 905 dev->ethtool_ops = &qe_ethtool_ops;
906 906
@@ -908,7 +908,7 @@ static int __devinit qec_ether_init(struct sbus_dev *sdev)
908 if (res) 908 if (res)
909 goto fail; 909 goto fail;
910 910
911 dev_set_drvdata(&sdev->ofdev.dev, qe); 911 dev_set_drvdata(&op->dev, qe);
912 912
913 printk(KERN_INFO "%s: qe channel[%d] ", dev->name, qe->channel); 913 printk(KERN_INFO "%s: qe channel[%d] ", dev->name, qe->channel);
914 for (i = 0; i < 6; i++) 914 for (i = 0; i < 6; i++)
@@ -922,58 +922,50 @@ static int __devinit qec_ether_init(struct sbus_dev *sdev)
922 922
923fail: 923fail:
924 if (qe->qcregs) 924 if (qe->qcregs)
925 sbus_iounmap(qe->qcregs, CREG_REG_SIZE); 925 of_iounmap(&op->resource[0], qe->qcregs, CREG_REG_SIZE);
926 if (qe->mregs) 926 if (qe->mregs)
927 sbus_iounmap(qe->mregs, MREGS_REG_SIZE); 927 of_iounmap(&op->resource[1], qe->mregs, MREGS_REG_SIZE);
928 if (qe->qe_block) 928 if (qe->qe_block)
929 sbus_free_consistent(qe->qe_sdev, 929 dma_free_coherent(&op->dev, PAGE_SIZE,
930 PAGE_SIZE, 930 qe->qe_block, qe->qblock_dvma);
931 qe->qe_block,
932 qe->qblock_dvma);
933 if (qe->buffers) 931 if (qe->buffers)
934 sbus_free_consistent(qe->qe_sdev, 932 dma_free_coherent(&op->dev,
935 sizeof(struct sunqe_buffers), 933 sizeof(struct sunqe_buffers),
936 qe->buffers, 934 qe->buffers,
937 qe->buffers_dvma); 935 qe->buffers_dvma);
938 936
939 free_netdev(dev); 937 free_netdev(dev);
940 938
941 return res; 939 return res;
942} 940}
943 941
944static int __devinit qec_sbus_probe(struct of_device *dev, const struct of_device_id *match) 942static int __devinit qec_sbus_probe(struct of_device *op, const struct of_device_id *match)
945{ 943{
946 struct sbus_dev *sdev = to_sbus_device(&dev->dev); 944 return qec_ether_init(op);
947
948 return qec_ether_init(sdev);
949} 945}
950 946
951static int __devexit qec_sbus_remove(struct of_device *dev) 947static int __devexit qec_sbus_remove(struct of_device *op)
952{ 948{
953 struct sunqe *qp = dev_get_drvdata(&dev->dev); 949 struct sunqe *qp = dev_get_drvdata(&op->dev);
954 struct net_device *net_dev = qp->dev; 950 struct net_device *net_dev = qp->dev;
955 951
956 unregister_netdev(net_dev); 952 unregister_netdev(net_dev);
957 953
958 sbus_iounmap(qp->qcregs, CREG_REG_SIZE); 954 of_iounmap(&op->resource[0], qp->qcregs, CREG_REG_SIZE);
959 sbus_iounmap(qp->mregs, MREGS_REG_SIZE); 955 of_iounmap(&op->resource[1], qp->mregs, MREGS_REG_SIZE);
960 sbus_free_consistent(qp->qe_sdev, 956 dma_free_coherent(&op->dev, PAGE_SIZE,
961 PAGE_SIZE, 957 qp->qe_block, qp->qblock_dvma);
962 qp->qe_block, 958 dma_free_coherent(&op->dev, sizeof(struct sunqe_buffers),
963 qp->qblock_dvma); 959 qp->buffers, qp->buffers_dvma);
964 sbus_free_consistent(qp->qe_sdev,
965 sizeof(struct sunqe_buffers),
966 qp->buffers,
967 qp->buffers_dvma);
968 960
969 free_netdev(net_dev); 961 free_netdev(net_dev);
970 962
971 dev_set_drvdata(&dev->dev, NULL); 963 dev_set_drvdata(&op->dev, NULL);
972 964
973 return 0; 965 return 0;
974} 966}
975 967
976static struct of_device_id qec_sbus_match[] = { 968static const struct of_device_id qec_sbus_match[] = {
977 { 969 {
978 .name = "qe", 970 .name = "qe",
979 }, 971 },
@@ -991,7 +983,7 @@ static struct of_platform_driver qec_sbus_driver = {
991 983
992static int __init qec_init(void) 984static int __init qec_init(void)
993{ 985{
994 return of_register_driver(&qec_sbus_driver, &sbus_bus_type); 986 return of_register_driver(&qec_sbus_driver, &of_bus_type);
995} 987}
996 988
997static void __exit qec_exit(void) 989static void __exit qec_exit(void)
@@ -1000,11 +992,11 @@ static void __exit qec_exit(void)
1000 992
1001 while (root_qec_dev) { 993 while (root_qec_dev) {
1002 struct sunqec *next = root_qec_dev->next_module; 994 struct sunqec *next = root_qec_dev->next_module;
995 struct of_device *op = root_qec_dev->op;
1003 996
1004 free_irq(root_qec_dev->qec_sdev->irqs[0], 997 free_irq(op->irqs[0], (void *) root_qec_dev);
1005 (void *) root_qec_dev); 998 of_iounmap(&op->resource[0], root_qec_dev->gregs,
1006 sbus_iounmap(root_qec_dev->gregs, GLOB_REG_SIZE); 999 GLOB_REG_SIZE);
1007
1008 kfree(root_qec_dev); 1000 kfree(root_qec_dev);
1009 1001
1010 root_qec_dev = next; 1002 root_qec_dev = next;
diff --git a/drivers/net/sunqe.h b/drivers/net/sunqe.h
index 347c8ddc1592..5813a7b2faa5 100644
--- a/drivers/net/sunqe.h
+++ b/drivers/net/sunqe.h
@@ -314,7 +314,7 @@ struct sunqec {
314 void __iomem *gregs; /* QEC Global Registers */ 314 void __iomem *gregs; /* QEC Global Registers */
315 struct sunqe *qes[4]; /* Each child MACE */ 315 struct sunqe *qes[4]; /* Each child MACE */
316 unsigned int qec_bursts; /* Support burst sizes */ 316 unsigned int qec_bursts; /* Support burst sizes */
317 struct sbus_dev *qec_sdev; /* QEC's SBUS device */ 317 struct of_device *op; /* QEC's OF device */
318 struct sunqec *next_module; /* List of all QECs in system */ 318 struct sunqec *next_module; /* List of all QECs in system */
319}; 319};
320 320
@@ -342,7 +342,7 @@ struct sunqe {
342 __u32 buffers_dvma; /* DVMA visible address. */ 342 __u32 buffers_dvma; /* DVMA visible address. */
343 struct sunqec *parent; 343 struct sunqec *parent;
344 u8 mconfig; /* Base MACE mconfig value */ 344 u8 mconfig; /* Base MACE mconfig value */
345 struct sbus_dev *qe_sdev; /* QE's SBUS device struct */ 345 struct of_device *op; /* QE's OF device struct */
346 struct net_device *dev; /* QE's netdevice struct */ 346 struct net_device *dev; /* QE's netdevice struct */
347 int channel; /* Who am I? */ 347 int channel; /* Who am I? */
348}; 348};
diff --git a/drivers/net/sunvnet.c b/drivers/net/sunvnet.c
index 6415ce15c2ef..a720065553df 100644
--- a/drivers/net/sunvnet.c
+++ b/drivers/net/sunvnet.c
@@ -1,6 +1,6 @@
1/* sunvnet.c: Sun LDOM Virtual Network Driver. 1/* sunvnet.c: Sun LDOM Virtual Network Driver.
2 * 2 *
3 * Copyright (C) 2007 David S. Miller <davem@davemloft.net> 3 * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
4 */ 4 */
5 5
6#include <linux/module.h> 6#include <linux/module.h>
@@ -1260,7 +1260,7 @@ static int vnet_port_remove(struct vio_dev *vdev)
1260 return 0; 1260 return 0;
1261} 1261}
1262 1262
1263static struct vio_device_id vnet_port_match[] = { 1263static const struct vio_device_id vnet_port_match[] = {
1264 { 1264 {
1265 .type = "vnet-port", 1265 .type = "vnet-port",
1266 }, 1266 },
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-17 23:56:10 -0500