net: wireless: sd8797: Marvell sd8797 Wi-Fi driver
[linux-2.6.git] / drivers / net / ixp2000 / ixpdev.c
1 /*
2  * IXP2000 MSF network device driver
3  * Copyright (C) 2004, 2005 Lennert Buytenhek <buytenh@wantstofly.org>
4  * Dedicated to Marija Kulikova.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/netdevice.h>
15 #include <linux/etherdevice.h>
16 #include <linux/init.h>
17 #include <linux/interrupt.h>
18 #include <linux/moduleparam.h>
19 #include <linux/gfp.h>
20 #include <asm/hardware/uengine.h>
21 #include <asm/io.h>
22 #include "ixp2400_rx.ucode"
23 #include "ixp2400_tx.ucode"
24 #include "ixpdev_priv.h"
25 #include "ixpdev.h"
26 #include "pm3386.h"
27
28 #define DRV_MODULE_VERSION      "0.2"
29
30 static int nds_count;
31 static struct net_device **nds;
32 static int nds_open;
33 static void (*set_port_admin_status)(int port, int up);
34
35 static struct ixpdev_rx_desc * const rx_desc =
36         (struct ixpdev_rx_desc *)(IXP2000_SRAM0_VIRT_BASE + RX_BUF_DESC_BASE);
37 static struct ixpdev_tx_desc * const tx_desc =
38         (struct ixpdev_tx_desc *)(IXP2000_SRAM0_VIRT_BASE + TX_BUF_DESC_BASE);
39 static int tx_pointer;
40
41
42 static int ixpdev_xmit(struct sk_buff *skb, struct net_device *dev)
43 {
44         struct ixpdev_priv *ip = netdev_priv(dev);
45         struct ixpdev_tx_desc *desc;
46         int entry;
47         unsigned long flags;
48
49         if (unlikely(skb->len > PAGE_SIZE)) {
50                 /* @@@ Count drops.  */
51                 dev_kfree_skb(skb);
52                 return NETDEV_TX_OK;
53         }
54
55         entry = tx_pointer;
56         tx_pointer = (tx_pointer + 1) % TX_BUF_COUNT;
57
58         desc = tx_desc + entry;
59         desc->pkt_length = skb->len;
60         desc->channel = ip->channel;
61
62         skb_copy_and_csum_dev(skb, phys_to_virt(desc->buf_addr));
63         dev_kfree_skb(skb);
64
65         ixp2000_reg_write(RING_TX_PENDING,
66                 TX_BUF_DESC_BASE + (entry * sizeof(struct ixpdev_tx_desc)));
67
68         local_irq_save(flags);
69         ip->tx_queue_entries++;
70         if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN)
71                 netif_stop_queue(dev);
72         local_irq_restore(flags);
73
74         return NETDEV_TX_OK;
75 }
76
77
78 static int ixpdev_rx(struct net_device *dev, int processed, int budget)
79 {
80         while (processed < budget) {
81                 struct ixpdev_rx_desc *desc;
82                 struct sk_buff *skb;
83                 void *buf;
84                 u32 _desc;
85
86                 _desc = ixp2000_reg_read(RING_RX_DONE);
87                 if (_desc == 0)
88                         return 0;
89
90                 desc = rx_desc +
91                         ((_desc - RX_BUF_DESC_BASE) / sizeof(struct ixpdev_rx_desc));
92                 buf = phys_to_virt(desc->buf_addr);
93
94                 if (desc->pkt_length < 4 || desc->pkt_length > PAGE_SIZE) {
95                         printk(KERN_ERR "ixp2000: rx err, length %d\n",
96                                         desc->pkt_length);
97                         goto err;
98                 }
99
100                 if (desc->channel < 0 || desc->channel >= nds_count) {
101                         printk(KERN_ERR "ixp2000: rx err, channel %d\n",
102                                         desc->channel);
103                         goto err;
104                 }
105
106                 /* @@@ Make FCS stripping configurable.  */
107                 desc->pkt_length -= 4;
108
109                 if (unlikely(!netif_running(nds[desc->channel])))
110                         goto err;
111
112                 skb = netdev_alloc_skb_ip_align(dev, desc->pkt_length);
113                 if (likely(skb != NULL)) {
114                         skb_copy_to_linear_data(skb, buf, desc->pkt_length);
115                         skb_put(skb, desc->pkt_length);
116                         skb->protocol = eth_type_trans(skb, nds[desc->channel]);
117
118                         netif_receive_skb(skb);
119                 }
120
121 err:
122                 ixp2000_reg_write(RING_RX_PENDING, _desc);
123                 processed++;
124         }
125
126         return processed;
127 }
128
129 /* dev always points to nds[0].  */
130 static int ixpdev_poll(struct napi_struct *napi, int budget)
131 {
132         struct ixpdev_priv *ip = container_of(napi, struct ixpdev_priv, napi);
133         struct net_device *dev = ip->dev;
134         int rx;
135
136         rx = 0;
137         do {
138                 ixp2000_reg_write(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0x00ff);
139
140                 rx = ixpdev_rx(dev, rx, budget);
141                 if (rx >= budget)
142                         break;
143         } while (ixp2000_reg_read(IXP2000_IRQ_THD_RAW_STATUS_A_0) & 0x00ff);
144
145         napi_complete(napi);
146         ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0x00ff);
147
148         return rx;
149 }
150
151 static void ixpdev_tx_complete(void)
152 {
153         int channel;
154         u32 wake;
155
156         wake = 0;
157         while (1) {
158                 struct ixpdev_priv *ip;
159                 u32 desc;
160                 int entry;
161
162                 desc = ixp2000_reg_read(RING_TX_DONE);
163                 if (desc == 0)
164                         break;
165
166                 /* @@@ Check whether entries come back in order.  */
167                 entry = (desc - TX_BUF_DESC_BASE) / sizeof(struct ixpdev_tx_desc);
168                 channel = tx_desc[entry].channel;
169
170                 if (channel < 0 || channel >= nds_count) {
171                         printk(KERN_ERR "ixp2000: txcomp channel index "
172                                         "out of bounds (%d, %.8i, %d)\n",
173                                         channel, (unsigned int)desc, entry);
174                         continue;
175                 }
176
177                 ip = netdev_priv(nds[channel]);
178                 if (ip->tx_queue_entries == TX_BUF_COUNT_PER_CHAN)
179                         wake |= 1 << channel;
180                 ip->tx_queue_entries--;
181         }
182
183         for (channel = 0; wake != 0; channel++) {
184                 if (wake & (1 << channel)) {
185                         netif_wake_queue(nds[channel]);
186                         wake &= ~(1 << channel);
187                 }
188         }
189 }
190
191 static irqreturn_t ixpdev_interrupt(int irq, void *dev_id)
192 {
193         u32 status;
194
195         status = ixp2000_reg_read(IXP2000_IRQ_THD_STATUS_A_0);
196         if (status == 0)
197                 return IRQ_NONE;
198
199         /*
200          * Any of the eight receive units signaled RX?
201          */
202         if (status & 0x00ff) {
203                 struct net_device *dev = nds[0];
204                 struct ixpdev_priv *ip = netdev_priv(dev);
205
206                 ixp2000_reg_wrb(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0x00ff);
207                 if (likely(napi_schedule_prep(&ip->napi))) {
208                         __napi_schedule(&ip->napi);
209                 } else {
210                         printk(KERN_CRIT "ixp2000: irq while polling!!\n");
211                 }
212         }
213
214         /*
215          * Any of the eight transmit units signaled TXdone?
216          */
217         if (status & 0xff00) {
218                 ixp2000_reg_wrb(IXP2000_IRQ_THD_RAW_STATUS_A_0, 0xff00);
219                 ixpdev_tx_complete();
220         }
221
222         return IRQ_HANDLED;
223 }
224
225 #ifdef CONFIG_NET_POLL_CONTROLLER
226 static void ixpdev_poll_controller(struct net_device *dev)
227 {
228         disable_irq(IRQ_IXP2000_THDA0);
229         ixpdev_interrupt(IRQ_IXP2000_THDA0, dev);
230         enable_irq(IRQ_IXP2000_THDA0);
231 }
232 #endif
233
234 static int ixpdev_open(struct net_device *dev)
235 {
236         struct ixpdev_priv *ip = netdev_priv(dev);
237         int err;
238
239         napi_enable(&ip->napi);
240         if (!nds_open++) {
241                 err = request_irq(IRQ_IXP2000_THDA0, ixpdev_interrupt,
242                                         IRQF_SHARED, "ixp2000_eth", nds);
243                 if (err) {
244                         nds_open--;
245                         napi_disable(&ip->napi);
246                         return err;
247                 }
248
249                 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0, 0xffff);
250         }
251
252         set_port_admin_status(ip->channel, 1);
253         netif_start_queue(dev);
254
255         return 0;
256 }
257
258 static int ixpdev_close(struct net_device *dev)
259 {
260         struct ixpdev_priv *ip = netdev_priv(dev);
261
262         netif_stop_queue(dev);
263         napi_disable(&ip->napi);
264         set_port_admin_status(ip->channel, 0);
265
266         if (!--nds_open) {
267                 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0, 0xffff);
268                 free_irq(IRQ_IXP2000_THDA0, nds);
269         }
270
271         return 0;
272 }
273
274 static struct net_device_stats *ixpdev_get_stats(struct net_device *dev)
275 {
276         struct ixpdev_priv *ip = netdev_priv(dev);
277
278         pm3386_get_stats(ip->channel, &(dev->stats));
279
280         return &(dev->stats);
281 }
282
283 static const struct net_device_ops ixpdev_netdev_ops = {
284         .ndo_open               = ixpdev_open,
285         .ndo_stop               = ixpdev_close,
286         .ndo_start_xmit         = ixpdev_xmit,
287         .ndo_change_mtu         = eth_change_mtu,
288         .ndo_validate_addr      = eth_validate_addr,
289         .ndo_set_mac_address    = eth_mac_addr,
290         .ndo_get_stats          = ixpdev_get_stats,
291 #ifdef CONFIG_NET_POLL_CONTROLLER
292         .ndo_poll_controller    = ixpdev_poll_controller,
293 #endif
294 };
295
296 struct net_device *ixpdev_alloc(int channel, int sizeof_priv)
297 {
298         struct net_device *dev;
299         struct ixpdev_priv *ip;
300
301         dev = alloc_etherdev(sizeof_priv);
302         if (dev == NULL)
303                 return NULL;
304
305         dev->netdev_ops = &ixpdev_netdev_ops;
306
307         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
308
309         ip = netdev_priv(dev);
310         ip->dev = dev;
311         netif_napi_add(dev, &ip->napi, ixpdev_poll, 64);
312         ip->channel = channel;
313         ip->tx_queue_entries = 0;
314
315         return dev;
316 }
317
318 int ixpdev_init(int __nds_count, struct net_device **__nds,
319                 void (*__set_port_admin_status)(int port, int up))
320 {
321         int i;
322         int err;
323
324         BUILD_BUG_ON(RX_BUF_COUNT > 192 || TX_BUF_COUNT > 192);
325
326         printk(KERN_INFO "IXP2000 MSF ethernet driver %s\n", DRV_MODULE_VERSION);
327
328         nds_count = __nds_count;
329         nds = __nds;
330         set_port_admin_status = __set_port_admin_status;
331
332         for (i = 0; i < RX_BUF_COUNT; i++) {
333                 void *buf;
334
335                 buf = (void *)get_zeroed_page(GFP_KERNEL);
336                 if (buf == NULL) {
337                         err = -ENOMEM;
338                         while (--i >= 0)
339                                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
340                         goto err_out;
341                 }
342                 rx_desc[i].buf_addr = virt_to_phys(buf);
343                 rx_desc[i].buf_length = PAGE_SIZE;
344         }
345
346         /* @@@ Maybe we shouldn't be preallocating TX buffers.  */
347         for (i = 0; i < TX_BUF_COUNT; i++) {
348                 void *buf;
349
350                 buf = (void *)get_zeroed_page(GFP_KERNEL);
351                 if (buf == NULL) {
352                         err = -ENOMEM;
353                         while (--i >= 0)
354                                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
355                         goto err_free_rx;
356                 }
357                 tx_desc[i].buf_addr = virt_to_phys(buf);
358         }
359
360         /* 256 entries, ring status set means 'empty', base address 0x0000.  */
361         ixp2000_reg_write(RING_RX_PENDING_BASE, 0x44000000);
362         ixp2000_reg_write(RING_RX_PENDING_HEAD, 0x00000000);
363         ixp2000_reg_write(RING_RX_PENDING_TAIL, 0x00000000);
364
365         /* 256 entries, ring status set means 'full', base address 0x0400.  */
366         ixp2000_reg_write(RING_RX_DONE_BASE, 0x40000400);
367         ixp2000_reg_write(RING_RX_DONE_HEAD, 0x00000000);
368         ixp2000_reg_write(RING_RX_DONE_TAIL, 0x00000000);
369
370         for (i = 0; i < RX_BUF_COUNT; i++) {
371                 ixp2000_reg_write(RING_RX_PENDING,
372                         RX_BUF_DESC_BASE + (i * sizeof(struct ixpdev_rx_desc)));
373         }
374
375         ixp2000_uengine_load(0, &ixp2400_rx);
376         ixp2000_uengine_start_contexts(0, 0xff);
377
378         /* 256 entries, ring status set means 'empty', base address 0x0800.  */
379         ixp2000_reg_write(RING_TX_PENDING_BASE, 0x44000800);
380         ixp2000_reg_write(RING_TX_PENDING_HEAD, 0x00000000);
381         ixp2000_reg_write(RING_TX_PENDING_TAIL, 0x00000000);
382
383         /* 256 entries, ring status set means 'full', base address 0x0c00.  */
384         ixp2000_reg_write(RING_TX_DONE_BASE, 0x40000c00);
385         ixp2000_reg_write(RING_TX_DONE_HEAD, 0x00000000);
386         ixp2000_reg_write(RING_TX_DONE_TAIL, 0x00000000);
387
388         ixp2000_uengine_load(1, &ixp2400_tx);
389         ixp2000_uengine_start_contexts(1, 0xff);
390
391         for (i = 0; i < nds_count; i++) {
392                 err = register_netdev(nds[i]);
393                 if (err) {
394                         while (--i >= 0)
395                                 unregister_netdev(nds[i]);
396                         goto err_free_tx;
397                 }
398         }
399
400         for (i = 0; i < nds_count; i++) {
401                 printk(KERN_INFO "%s: IXP2000 MSF ethernet (port %d), "
402                         "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x.\n", nds[i]->name, i,
403                         nds[i]->dev_addr[0], nds[i]->dev_addr[1],
404                         nds[i]->dev_addr[2], nds[i]->dev_addr[3],
405                         nds[i]->dev_addr[4], nds[i]->dev_addr[5]);
406         }
407
408         return 0;
409
410 err_free_tx:
411         for (i = 0; i < TX_BUF_COUNT; i++)
412                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
413
414 err_free_rx:
415         for (i = 0; i < RX_BUF_COUNT; i++)
416                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
417
418 err_out:
419         return err;
420
421
422 void ixpdev_deinit(void)
423 {
424         int i;
425
426         /* @@@ Flush out pending packets.  */
427
428         for (i = 0; i < nds_count; i++)
429                 unregister_netdev(nds[i]);
430
431         ixp2000_uengine_stop_contexts(1, 0xff);
432         ixp2000_uengine_stop_contexts(0, 0xff);
433         ixp2000_uengine_reset(0x3);
434
435         for (i = 0; i < TX_BUF_COUNT; i++)
436                 free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
437
438         for (i = 0; i < RX_BUF_COUNT; i++)
439                 free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
440 }