SPI dynamic busid generation bugfix
[sfrench/cifs-2.6.git] / drivers / net / mipsnet.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  */
6
7 #define DEBUG
8
9 #include <linux/init.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/netdevice.h>
13 #include <linux/etherdevice.h>
14 #include <linux/netdevice.h>
15 #include <linux/platform_device.h>
16 #include <asm/io.h>
17 #include <asm/mips-boards/simint.h>
18
19 #include "mipsnet.h"            /* actual device IO mapping */
20
21 #define MIPSNET_VERSION "2005-06-20"
22
23 #define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
24
25 struct mipsnet_priv {
26         struct net_device_stats stats;
27 };
28
29 static char mipsnet_string[] = "mipsnet";
30
31 /*
32  * Copy data from the MIPSNET rx data port
33  */
34 static int ioiocpy_frommipsnet(struct net_device *dev, unsigned char *kdata,
35                         int len)
36 {
37         uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
38         if (available_len < len)
39                 return -EFAULT;
40
41         for (; len > 0; len--, kdata++) {
42                 *kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
43         }
44
45         return inl(mipsnet_reg_address(dev, rxDataCount));
46 }
47
48 static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
49         struct sk_buff *skb)
50 {
51         int count_to_go = skb->len;
52         char *buf_ptr = skb->data;
53         struct mipsnet_priv *mp = netdev_priv(dev);
54
55         pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
56                  dev->name, __FUNCTION__, skb->len);
57
58         outl(skb->len, mipsnet_reg_address(dev, txDataCount));
59
60         pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
61                  dev->name, __FUNCTION__, skb->len);
62
63         for (; count_to_go; buf_ptr++, count_to_go--) {
64                 outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
65         }
66
67         mp->stats.tx_packets++;
68         mp->stats.tx_bytes += skb->len;
69
70         return skb->len;
71 }
72
73 static int mipsnet_xmit(struct sk_buff *skb, struct net_device *dev)
74 {
75         pr_debug("%s:%s(): transmitting %d bytes\n",
76                  dev->name, __FUNCTION__, skb->len);
77
78         /* Only one packet at a time. Once TXDONE interrupt is serviced, the
79          * queue will be restarted.
80          */
81         netif_stop_queue(dev);
82         mipsnet_put_todevice(dev, skb);
83
84         return 0;
85 }
86
87 static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
88 {
89         struct sk_buff *skb;
90         size_t len = count;
91         struct mipsnet_priv *mp = netdev_priv(dev);
92
93         if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {
94                 mp->stats.rx_dropped++;
95                 return -ENOMEM;
96         }
97
98         skb_reserve(skb, 2);
99         if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
100                 return -EFAULT;
101
102         skb->protocol = eth_type_trans(skb, dev);
103         skb->ip_summed = CHECKSUM_UNNECESSARY;
104
105         pr_debug("%s:%s(): pushing RXed data to kernel\n",
106                  dev->name, __FUNCTION__);
107         netif_rx(skb);
108
109         mp->stats.rx_packets++;
110         mp->stats.rx_bytes += len;
111
112         return count;
113 }
114
115 static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
116 {
117         struct net_device *dev = dev_id;
118
119         irqreturn_t retval = IRQ_NONE;
120         uint64_t interruptFlags;
121
122         if (irq == dev->irq) {
123                 pr_debug("%s:%s(): irq %d for device\n",
124                          dev->name, __FUNCTION__, irq);
125
126                 retval = IRQ_HANDLED;
127
128                 interruptFlags =
129                     inl(mipsnet_reg_address(dev, interruptControl));
130                 pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
131                          __FUNCTION__, interruptFlags);
132
133                 if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
134                         pr_debug("%s:%s(): got TXDone\n",
135                                  dev->name, __FUNCTION__);
136                         outl(MIPSNET_INTCTL_TXDONE,
137                              mipsnet_reg_address(dev, interruptControl));
138                         // only one packet at a time, we are done.
139                         netif_wake_queue(dev);
140                 } else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
141                         pr_debug("%s:%s(): got RX data\n",
142                                  dev->name, __FUNCTION__);
143                         mipsnet_get_fromdev(dev,
144                                     inl(mipsnet_reg_address(dev, rxDataCount)));
145                         pr_debug("%s:%s(): clearing RX int\n",
146                                  dev->name, __FUNCTION__);
147                         outl(MIPSNET_INTCTL_RXDONE,
148                              mipsnet_reg_address(dev, interruptControl));
149
150                 } else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
151                         pr_debug("%s:%s(): got test interrupt\n",
152                                  dev->name, __FUNCTION__);
153                         // TESTBIT is cleared on read.
154                         //    And takes effect after a write with 0
155                         outl(0, mipsnet_reg_address(dev, interruptControl));
156                 } else {
157                         pr_debug("%s:%s(): no valid fags 0x%016llx\n",
158                                  dev->name, __FUNCTION__, interruptFlags);
159                         // Maybe shared IRQ, just ignore, no clearing.
160                         retval = IRQ_NONE;
161                 }
162
163         } else {
164                 printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
165                        dev->name, __FUNCTION__, irq);
166                 retval = IRQ_NONE;
167         }
168         return retval;
169 }                               //mipsnet_interrupt()
170
171 static int mipsnet_open(struct net_device *dev)
172 {
173         int err;
174         pr_debug("%s: mipsnet_open\n", dev->name);
175
176         err = request_irq(dev->irq, &mipsnet_interrupt,
177                           IRQF_SHARED, dev->name, (void *) dev);
178
179         if (err) {
180                 pr_debug("%s: %s(): can't get irq %d\n",
181                          dev->name, __FUNCTION__, dev->irq);
182                 release_region(dev->base_addr, MIPSNET_IO_EXTENT);
183                 return err;
184         }
185
186         pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
187                  dev->name, __FUNCTION__, dev->base_addr, dev->irq);
188
189
190         netif_start_queue(dev);
191
192         // test interrupt handler
193         outl(MIPSNET_INTCTL_TESTBIT,
194              mipsnet_reg_address(dev, interruptControl));
195
196
197         return 0;
198 }
199
200 static int mipsnet_close(struct net_device *dev)
201 {
202         pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
203         netif_stop_queue(dev);
204         return 0;
205 }
206
207 static struct net_device_stats *mipsnet_get_stats(struct net_device *dev)
208 {
209         struct mipsnet_priv *mp = netdev_priv(dev);
210
211         return &mp->stats;
212 }
213
214 static void mipsnet_set_mclist(struct net_device *dev)
215 {
216         // we don't do anything
217         return;
218 }
219
220 static int __init mipsnet_probe(struct device *dev)
221 {
222         struct net_device *netdev;
223         int err;
224
225         netdev = alloc_etherdev(sizeof(struct mipsnet_priv));
226         if (!netdev) {
227                 err = -ENOMEM;
228                 goto out;
229         }
230
231         dev_set_drvdata(dev, netdev);
232
233         netdev->open                    = mipsnet_open;
234         netdev->stop                    = mipsnet_close;
235         netdev->hard_start_xmit         = mipsnet_xmit;
236         netdev->get_stats               = mipsnet_get_stats;
237         netdev->set_multicast_list      = mipsnet_set_mclist;
238
239         /*
240          * TODO: probe for these or load them from PARAM
241          */
242         netdev->base_addr = 0x4200;
243         netdev->irq = MIPSCPU_INT_BASE + MIPSCPU_INT_MB0 +
244                       inl(mipsnet_reg_address(netdev, interruptInfo));
245
246         // Get the io region now, get irq on open()
247         if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
248                 pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
249                          "for dev is not availble.\n", netdev->name,
250                          __FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
251                 err = -EBUSY;
252                 goto out_free_netdev;
253         }
254
255         /*
256          * Lacking any better mechanism to allocate a MAC address we use a
257          * random one ...
258          */
259         random_ether_addr(netdev->dev_addr);
260
261         err = register_netdev(netdev);
262         if (err) {
263                 printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
264                 goto out_free_region;
265         }
266
267         return 0;
268
269 out_free_region:
270         release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
271
272 out_free_netdev:
273         free_netdev(netdev);
274
275 out:
276         return err;
277 }
278
279 static int __devexit mipsnet_device_remove(struct device *device)
280 {
281         struct net_device *dev = dev_get_drvdata(device);
282
283         unregister_netdev(dev);
284         release_region(dev->base_addr, MIPSNET_IO_EXTENT);
285         free_netdev(dev);
286         dev_set_drvdata(device, NULL);
287
288         return 0;
289 }
290
291 static struct device_driver mipsnet_driver = {
292         .name   = mipsnet_string,
293         .bus    = &platform_bus_type,
294         .probe  = mipsnet_probe,
295         .remove = __devexit_p(mipsnet_device_remove),
296 };
297
298 static int __init mipsnet_init_module(void)
299 {
300         int err;
301
302         printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
303                "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
304
305         err = driver_register(&mipsnet_driver);
306         if (err)
307                 printk(KERN_ERR "Driver registration failed\n");
308
309         return err;
310 }
311
312 static void __exit mipsnet_exit_module(void)
313 {
314         pr_debug("MIPSNet Ethernet driver exiting\n");
315
316         driver_unregister(&mipsnet_driver);
317 }
318
319 module_init(mipsnet_init_module);
320 module_exit(mipsnet_exit_module);