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