2 * IXP2000 MSF network device driver
3 * Copyright (C) 2004, 2005 Lennert Buytenhek <buytenh@wantstofly.org>
4 * Dedicated to Marija Kulikova.
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.
12 #include <linux/config.h>
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/init.h>
18 #include <linux/moduleparam.h>
19 #include <asm/arch/uengine.h>
20 #include <asm/mach-types.h>
22 #include "ixp2400_rx.ucode"
23 #include "ixp2400_tx.ucode"
24 #include "ixpdev_priv.h"
28 static struct net_device
**nds
;
30 static void (*set_port_admin_status
)(int port
, int up
);
32 static struct ixpdev_rx_desc
* const rx_desc
=
33 (struct ixpdev_rx_desc
*)(IXP2000_SRAM0_VIRT_BASE
+ RX_BUF_DESC_BASE
);
34 static struct ixpdev_tx_desc
* const tx_desc
=
35 (struct ixpdev_tx_desc
*)(IXP2000_SRAM0_VIRT_BASE
+ TX_BUF_DESC_BASE
);
36 static int tx_pointer
;
39 static int ixpdev_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
41 struct ixpdev_priv
*ip
= netdev_priv(dev
);
42 struct ixpdev_tx_desc
*desc
;
45 if (unlikely(skb
->len
> PAGE_SIZE
)) {
46 /* @@@ Count drops. */
52 tx_pointer
= (tx_pointer
+ 1) % TX_BUF_COUNT
;
54 desc
= tx_desc
+ entry
;
55 desc
->pkt_length
= skb
->len
;
56 desc
->channel
= ip
->channel
;
58 skb_copy_and_csum_dev(skb
, phys_to_virt(desc
->buf_addr
));
61 ixp2000_reg_write(RING_TX_PENDING
,
62 TX_BUF_DESC_BASE
+ (entry
* sizeof(struct ixpdev_tx_desc
)));
64 dev
->trans_start
= jiffies
;
67 ip
->tx_queue_entries
++;
68 if (ip
->tx_queue_entries
== TX_BUF_COUNT_PER_CHAN
)
69 netif_stop_queue(dev
);
76 static int ixpdev_rx(struct net_device
*dev
, int *budget
)
79 struct ixpdev_rx_desc
*desc
;
84 _desc
= ixp2000_reg_read(RING_RX_DONE
);
89 ((_desc
- RX_BUF_DESC_BASE
) / sizeof(struct ixpdev_rx_desc
));
90 buf
= phys_to_virt(desc
->buf_addr
);
92 if (desc
->pkt_length
< 4 || desc
->pkt_length
> PAGE_SIZE
) {
93 printk(KERN_ERR
"ixp2000: rx err, length %d\n",
98 if (desc
->channel
< 0 || desc
->channel
>= nds_count
) {
99 printk(KERN_ERR
"ixp2000: rx err, channel %d\n",
104 /* @@@ Make FCS stripping configurable. */
105 desc
->pkt_length
-= 4;
107 if (unlikely(!netif_running(nds
[desc
->channel
])))
110 skb
= dev_alloc_skb(desc
->pkt_length
+ 2);
111 if (likely(skb
!= NULL
)) {
112 skb
->dev
= nds
[desc
->channel
];
114 eth_copy_and_sum(skb
, buf
, desc
->pkt_length
, 0);
115 skb_put(skb
, desc
->pkt_length
);
116 skb
->protocol
= eth_type_trans(skb
, skb
->dev
);
118 skb
->dev
->last_rx
= jiffies
;
120 netif_receive_skb(skb
);
124 ixp2000_reg_write(RING_RX_PENDING
, _desc
);
132 /* dev always points to nds[0]. */
133 static int ixpdev_poll(struct net_device
*dev
, int *budget
)
135 /* @@@ Have to stop polling when nds[0] is administratively
136 * downed while we are polling. */
138 ixp2000_reg_write(IXP2000_IRQ_THD_RAW_STATUS_A_0
, 0x00ff);
140 if (ixpdev_rx(dev
, budget
))
142 } while (ixp2000_reg_read(IXP2000_IRQ_THD_RAW_STATUS_A_0
) & 0x00ff);
144 netif_rx_complete(dev
);
145 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0
, 0x00ff);
150 static void ixpdev_tx_complete(void)
157 struct ixpdev_priv
*ip
;
161 desc
= ixp2000_reg_read(RING_TX_DONE
);
165 /* @@@ Check whether entries come back in order. */
166 entry
= (desc
- TX_BUF_DESC_BASE
) / sizeof(struct ixpdev_tx_desc
);
167 channel
= tx_desc
[entry
].channel
;
169 if (channel
< 0 || channel
>= nds_count
) {
170 printk(KERN_ERR
"ixp2000: txcomp channel index "
171 "out of bounds (%d, %.8i, %d)\n",
172 channel
, (unsigned int)desc
, entry
);
176 ip
= netdev_priv(nds
[channel
]);
177 if (ip
->tx_queue_entries
== TX_BUF_COUNT_PER_CHAN
)
178 wake
|= 1 << channel
;
179 ip
->tx_queue_entries
--;
182 for (channel
= 0; wake
!= 0; channel
++) {
183 if (wake
& (1 << channel
)) {
184 netif_wake_queue(nds
[channel
]);
185 wake
&= ~(1 << channel
);
190 static irqreturn_t
ixpdev_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
194 status
= ixp2000_reg_read(IXP2000_IRQ_THD_STATUS_A_0
);
199 * Any of the eight receive units signaled RX?
201 if (status
& 0x00ff) {
202 ixp2000_reg_wrb(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0
, 0x00ff);
203 if (likely(netif_rx_schedule_test(nds
[0]))) {
204 __netif_rx_schedule(nds
[0]);
206 printk(KERN_CRIT
"ixp2000: irq while polling!!\n");
211 * Any of the eight transmit units signaled TXdone?
213 if (status
& 0xff00) {
214 ixp2000_reg_wrb(IXP2000_IRQ_THD_RAW_STATUS_A_0
, 0xff00);
215 ixpdev_tx_complete();
221 #ifdef CONFIG_NET_POLL_CONTROLLER
222 static void ixpdev_poll_controller(struct net_device
*dev
)
224 disable_irq(IRQ_IXP2000_THDA0
);
225 ixpdev_interrupt(IRQ_IXP2000_THDA0
, dev
, NULL
);
226 enable_irq(IRQ_IXP2000_THDA0
);
230 static int ixpdev_open(struct net_device
*dev
)
232 struct ixpdev_priv
*ip
= netdev_priv(dev
);
236 err
= request_irq(IRQ_IXP2000_THDA0
, ixpdev_interrupt
,
237 SA_SHIRQ
, "ixp2000_eth", nds
);
243 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_SET_A_0
, 0xffff);
246 set_port_admin_status(ip
->channel
, 1);
247 netif_start_queue(dev
);
252 static int ixpdev_close(struct net_device
*dev
)
254 struct ixpdev_priv
*ip
= netdev_priv(dev
);
256 netif_stop_queue(dev
);
257 set_port_admin_status(ip
->channel
, 0);
260 ixp2000_reg_write(IXP2000_IRQ_THD_ENABLE_CLEAR_A_0
, 0xffff);
261 free_irq(IRQ_IXP2000_THDA0
, nds
);
267 struct net_device
*ixpdev_alloc(int channel
, int sizeof_priv
)
269 struct net_device
*dev
;
270 struct ixpdev_priv
*ip
;
272 dev
= alloc_etherdev(sizeof_priv
);
276 dev
->hard_start_xmit
= ixpdev_xmit
;
277 dev
->poll
= ixpdev_poll
;
278 dev
->open
= ixpdev_open
;
279 dev
->stop
= ixpdev_close
;
280 #ifdef CONFIG_NET_POLL_CONTROLLER
281 dev
->poll_controller
= ixpdev_poll_controller
;
284 dev
->features
|= NETIF_F_SG
| NETIF_F_HW_CSUM
;
287 ip
= netdev_priv(dev
);
288 ip
->channel
= channel
;
289 ip
->tx_queue_entries
= 0;
294 int ixpdev_init(int __nds_count
, struct net_device
**__nds
,
295 void (*__set_port_admin_status
)(int port
, int up
))
300 if (RX_BUF_COUNT
> 192 || TX_BUF_COUNT
> 192) {
301 static void __too_many_rx_or_tx_buffers(void);
302 __too_many_rx_or_tx_buffers();
305 nds_count
= __nds_count
;
307 set_port_admin_status
= __set_port_admin_status
;
309 for (i
= 0; i
< RX_BUF_COUNT
; i
++) {
312 buf
= (void *)get_zeroed_page(GFP_KERNEL
);
316 free_page((unsigned long)phys_to_virt(rx_desc
[i
].buf_addr
));
319 rx_desc
[i
].buf_addr
= virt_to_phys(buf
);
320 rx_desc
[i
].buf_length
= PAGE_SIZE
;
323 /* @@@ Maybe we shouldn't be preallocating TX buffers. */
324 for (i
= 0; i
< TX_BUF_COUNT
; i
++) {
327 buf
= (void *)get_zeroed_page(GFP_KERNEL
);
331 free_page((unsigned long)phys_to_virt(tx_desc
[i
].buf_addr
));
334 tx_desc
[i
].buf_addr
= virt_to_phys(buf
);
337 /* 256 entries, ring status set means 'empty', base address 0x0000. */
338 ixp2000_reg_write(RING_RX_PENDING_BASE
, 0x44000000);
339 ixp2000_reg_write(RING_RX_PENDING_HEAD
, 0x00000000);
340 ixp2000_reg_write(RING_RX_PENDING_TAIL
, 0x00000000);
342 /* 256 entries, ring status set means 'full', base address 0x0400. */
343 ixp2000_reg_write(RING_RX_DONE_BASE
, 0x40000400);
344 ixp2000_reg_write(RING_RX_DONE_HEAD
, 0x00000000);
345 ixp2000_reg_write(RING_RX_DONE_TAIL
, 0x00000000);
347 for (i
= 0; i
< RX_BUF_COUNT
; i
++) {
348 ixp2000_reg_write(RING_RX_PENDING
,
349 RX_BUF_DESC_BASE
+ (i
* sizeof(struct ixpdev_rx_desc
)));
352 ixp2000_uengine_load(0, &ixp2400_rx
);
353 ixp2000_uengine_start_contexts(0, 0xff);
355 /* 256 entries, ring status set means 'empty', base address 0x0800. */
356 ixp2000_reg_write(RING_TX_PENDING_BASE
, 0x44000800);
357 ixp2000_reg_write(RING_TX_PENDING_HEAD
, 0x00000000);
358 ixp2000_reg_write(RING_TX_PENDING_TAIL
, 0x00000000);
360 /* 256 entries, ring status set means 'full', base address 0x0c00. */
361 ixp2000_reg_write(RING_TX_DONE_BASE
, 0x40000c00);
362 ixp2000_reg_write(RING_TX_DONE_HEAD
, 0x00000000);
363 ixp2000_reg_write(RING_TX_DONE_TAIL
, 0x00000000);
365 ixp2000_uengine_load(1, &ixp2400_tx
);
366 ixp2000_uengine_start_contexts(1, 0xff);
368 for (i
= 0; i
< nds_count
; i
++) {
369 err
= register_netdev(nds
[i
]);
372 unregister_netdev(nds
[i
]);
377 for (i
= 0; i
< nds_count
; i
++) {
378 printk(KERN_INFO
"%s: IXP2000 MSF ethernet (port %d), "
379 "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x.\n", nds
[i
]->name
, i
,
380 nds
[i
]->dev_addr
[0], nds
[i
]->dev_addr
[1],
381 nds
[i
]->dev_addr
[2], nds
[i
]->dev_addr
[3],
382 nds
[i
]->dev_addr
[4], nds
[i
]->dev_addr
[5]);
388 for (i
= 0; i
< TX_BUF_COUNT
; i
++)
389 free_page((unsigned long)phys_to_virt(tx_desc
[i
].buf_addr
));
392 for (i
= 0; i
< RX_BUF_COUNT
; i
++)
393 free_page((unsigned long)phys_to_virt(rx_desc
[i
].buf_addr
));
399 void ixpdev_deinit(void)
403 /* @@@ Flush out pending packets. */
405 for (i
= 0; i
< nds_count
; i
++)
406 unregister_netdev(nds
[i
]);
408 ixp2000_uengine_stop_contexts(1, 0xff);
409 ixp2000_uengine_stop_contexts(0, 0xff);
410 ixp2000_uengine_reset(0x3);
412 for (i
= 0; i
< TX_BUF_COUNT
; i
++)
413 free_page((unsigned long)phys_to_virt(tx_desc
[i
].buf_addr
));
415 for (i
= 0; i
< RX_BUF_COUNT
; i
++)
416 free_page((unsigned long)phys_to_virt(rx_desc
[i
].buf_addr
));