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
30static int nds_count;
31static struct net_device **nds;
32static int nds_open;
33static void (*set_port_admin_status)(int port, int up);
34
35static struct ixpdev_rx_desc * const rx_desc =
36	(struct ixpdev_rx_desc *)(IXP2000_SRAM0_VIRT_BASE + RX_BUF_DESC_BASE);
37static struct ixpdev_tx_desc * const tx_desc =
38	(struct ixpdev_tx_desc *)(IXP2000_SRAM0_VIRT_BASE + TX_BUF_DESC_BASE);
39static int tx_pointer;
40
41
42static 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
78static 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
121err:
122		ixp2000_reg_write(RING_RX_PENDING, _desc);
123		processed++;
124	}
125
126	return processed;
127}
128
129/* dev always points to nds[0].  */
130static 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
151static 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
191static 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
226static 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
234static 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
258static 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
274static 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
283static 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
296struct 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
318int 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), %pM.\n",
402				 nds[i]->name, i, nds[i]->dev_addr);
403	}
404
405	return 0;
406
407err_free_tx:
408	for (i = 0; i < TX_BUF_COUNT; i++)
409		free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
410
411err_free_rx:
412	for (i = 0; i < RX_BUF_COUNT; i++)
413		free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
414
415err_out:
416	return err;
417}
418
419void ixpdev_deinit(void)
420{
421	int i;
422
423	/* @@@ Flush out pending packets.  */
424
425	for (i = 0; i < nds_count; i++)
426		unregister_netdev(nds[i]);
427
428	ixp2000_uengine_stop_contexts(1, 0xff);
429	ixp2000_uengine_stop_contexts(0, 0xff);
430	ixp2000_uengine_reset(0x3);
431
432	for (i = 0; i < TX_BUF_COUNT; i++)
433		free_page((unsigned long)phys_to_virt(tx_desc[i].buf_addr));
434
435	for (i = 0; i < RX_BUF_COUNT; i++)
436		free_page((unsigned long)phys_to_virt(rx_desc[i].buf_addr));
437}
438