2 * rionet - Ethernet driver over RapidIO messaging services
4 * Copyright 2005 MontaVista Software, Inc.
5 * Matt Porter <mporter@kernel.crashing.org>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/delay.h>
17 #include <linux/rio.h>
18 #include <linux/rio_drv.h>
19 #include <linux/slab.h>
20 #include <linux/rio_ids.h>
22 #include <linux/netdevice.h>
23 #include <linux/etherdevice.h>
24 #include <linux/skbuff.h>
25 #include <linux/crc32.h>
26 #include <linux/ethtool.h>
27 #include <linux/reboot.h>
29 #define DRV_NAME "rionet"
30 #define DRV_VERSION "0.3"
31 #define DRV_AUTHOR "Matt Porter <mporter@kernel.crashing.org>"
32 #define DRV_DESC "Ethernet over RapidIO"
34 MODULE_AUTHOR(DRV_AUTHOR
);
35 MODULE_DESCRIPTION(DRV_DESC
);
36 MODULE_LICENSE("GPL");
38 #define RIONET_DEFAULT_MSGLEVEL \
44 #define RIONET_DOORBELL_JOIN 0x1000
45 #define RIONET_DOORBELL_LEAVE 0x1001
47 #define RIONET_MAILBOX 0
49 #define RIONET_TX_RING_SIZE CONFIG_RIONET_TX_SIZE
50 #define RIONET_RX_RING_SIZE CONFIG_RIONET_RX_SIZE
51 #define RIONET_MAX_NETS 8
52 #define RIONET_MSG_SIZE RIO_MAX_MSG_SIZE
53 #define RIONET_MAX_MTU (RIONET_MSG_SIZE - ETH_HLEN)
55 struct rionet_private
{
56 struct rio_mport
*mport
;
57 struct sk_buff
*rx_skb
[RIONET_RX_RING_SIZE
];
58 struct sk_buff
*tx_skb
[RIONET_TX_RING_SIZE
];
69 struct list_head node
;
75 struct net_device
*ndev
;
76 struct list_head peers
;
77 struct rio_dev
**active
;
78 int nact
; /* number of active peers */
81 static struct rionet_net nets
[RIONET_MAX_NETS
];
83 #define is_rionet_capable(src_ops, dst_ops) \
84 ((src_ops & RIO_SRC_OPS_DATA_MSG) && \
85 (dst_ops & RIO_DST_OPS_DATA_MSG) && \
86 (src_ops & RIO_SRC_OPS_DOORBELL) && \
87 (dst_ops & RIO_DST_OPS_DOORBELL))
88 #define dev_rionet_capable(dev) \
89 is_rionet_capable(dev->src_ops, dev->dst_ops)
91 #define RIONET_MAC_MATCH(x) (!memcmp((x), "\00\01\00\01", 4))
92 #define RIONET_GET_DESTID(x) ((*((u8 *)x + 4) << 8) | *((u8 *)x + 5))
94 static int rionet_rx_clean(struct net_device
*ndev
)
98 struct rionet_private
*rnet
= netdev_priv(ndev
);
104 if (!rnet
->rx_skb
[i
])
107 if (!(data
= rio_get_inb_message(rnet
->mport
, RIONET_MAILBOX
)))
110 rnet
->rx_skb
[i
]->data
= data
;
111 skb_put(rnet
->rx_skb
[i
], RIO_MAX_MSG_SIZE
);
112 rnet
->rx_skb
[i
]->protocol
=
113 eth_type_trans(rnet
->rx_skb
[i
], ndev
);
114 error
= netif_rx(rnet
->rx_skb
[i
]);
116 if (error
== NET_RX_DROP
) {
117 ndev
->stats
.rx_dropped
++;
119 ndev
->stats
.rx_packets
++;
120 ndev
->stats
.rx_bytes
+= RIO_MAX_MSG_SIZE
;
123 } while ((i
= (i
+ 1) % RIONET_RX_RING_SIZE
) != rnet
->rx_slot
);
128 static void rionet_rx_fill(struct net_device
*ndev
, int end
)
131 struct rionet_private
*rnet
= netdev_priv(ndev
);
135 rnet
->rx_skb
[i
] = dev_alloc_skb(RIO_MAX_MSG_SIZE
);
137 if (!rnet
->rx_skb
[i
])
140 rio_add_inb_buffer(rnet
->mport
, RIONET_MAILBOX
,
141 rnet
->rx_skb
[i
]->data
);
142 } while ((i
= (i
+ 1) % RIONET_RX_RING_SIZE
) != end
);
147 static int rionet_queue_tx_msg(struct sk_buff
*skb
, struct net_device
*ndev
,
148 struct rio_dev
*rdev
)
150 struct rionet_private
*rnet
= netdev_priv(ndev
);
152 rio_add_outb_message(rnet
->mport
, rdev
, 0, skb
->data
, skb
->len
);
153 rnet
->tx_skb
[rnet
->tx_slot
] = skb
;
155 ndev
->stats
.tx_packets
++;
156 ndev
->stats
.tx_bytes
+= skb
->len
;
158 if (++rnet
->tx_cnt
== RIONET_TX_RING_SIZE
)
159 netif_stop_queue(ndev
);
162 rnet
->tx_slot
&= (RIONET_TX_RING_SIZE
- 1);
164 if (netif_msg_tx_queued(rnet
))
165 printk(KERN_INFO
"%s: queued skb len %8.8x\n", DRV_NAME
,
171 static int rionet_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
174 struct rionet_private
*rnet
= netdev_priv(ndev
);
175 struct ethhdr
*eth
= (struct ethhdr
*)skb
->data
;
180 local_irq_save(flags
);
181 if (!spin_trylock(&rnet
->tx_lock
)) {
182 local_irq_restore(flags
);
183 return NETDEV_TX_LOCKED
;
186 if (is_multicast_ether_addr(eth
->h_dest
))
187 add_num
= nets
[rnet
->mport
->id
].nact
;
189 if ((rnet
->tx_cnt
+ add_num
) > RIONET_TX_RING_SIZE
) {
190 netif_stop_queue(ndev
);
191 spin_unlock_irqrestore(&rnet
->tx_lock
, flags
);
192 printk(KERN_ERR
"%s: BUG! Tx Ring full when queue awake!\n",
194 return NETDEV_TX_BUSY
;
197 if (is_multicast_ether_addr(eth
->h_dest
)) {
200 for (i
= 0; i
< RIO_MAX_ROUTE_ENTRIES(rnet
->mport
->sys_size
);
202 if (nets
[rnet
->mport
->id
].active
[i
]) {
203 rionet_queue_tx_msg(skb
, ndev
,
204 nets
[rnet
->mport
->id
].active
[i
]);
206 atomic_inc(&skb
->users
);
209 } else if (RIONET_MAC_MATCH(eth
->h_dest
)) {
210 destid
= RIONET_GET_DESTID(eth
->h_dest
);
211 if (nets
[rnet
->mport
->id
].active
[destid
])
212 rionet_queue_tx_msg(skb
, ndev
,
213 nets
[rnet
->mport
->id
].active
[destid
]);
216 * If the target device was removed from the list of
217 * active peers but we still have TX packets targeting
218 * it just report sending a packet to the target
219 * (without actual packet transfer).
221 dev_kfree_skb_any(skb
);
222 ndev
->stats
.tx_packets
++;
223 ndev
->stats
.tx_bytes
+= skb
->len
;
227 spin_unlock_irqrestore(&rnet
->tx_lock
, flags
);
232 static void rionet_dbell_event(struct rio_mport
*mport
, void *dev_id
, u16 sid
, u16 tid
,
235 struct net_device
*ndev
= dev_id
;
236 struct rionet_private
*rnet
= netdev_priv(ndev
);
237 struct rionet_peer
*peer
;
239 if (netif_msg_intr(rnet
))
240 printk(KERN_INFO
"%s: doorbell sid %4.4x tid %4.4x info %4.4x",
241 DRV_NAME
, sid
, tid
, info
);
242 if (info
== RIONET_DOORBELL_JOIN
) {
243 if (!nets
[rnet
->mport
->id
].active
[sid
]) {
244 list_for_each_entry(peer
,
245 &nets
[rnet
->mport
->id
].peers
, node
) {
246 if (peer
->rdev
->destid
== sid
) {
247 nets
[rnet
->mport
->id
].active
[sid
] =
249 nets
[rnet
->mport
->id
].nact
++;
252 rio_mport_send_doorbell(mport
, sid
,
253 RIONET_DOORBELL_JOIN
);
255 } else if (info
== RIONET_DOORBELL_LEAVE
) {
256 nets
[rnet
->mport
->id
].active
[sid
] = NULL
;
257 nets
[rnet
->mport
->id
].nact
--;
259 if (netif_msg_intr(rnet
))
260 printk(KERN_WARNING
"%s: unhandled doorbell\n",
265 static void rionet_inb_msg_event(struct rio_mport
*mport
, void *dev_id
, int mbox
, int slot
)
268 struct net_device
*ndev
= dev_id
;
269 struct rionet_private
*rnet
= netdev_priv(ndev
);
271 if (netif_msg_intr(rnet
))
272 printk(KERN_INFO
"%s: inbound message event, mbox %d slot %d\n",
273 DRV_NAME
, mbox
, slot
);
275 spin_lock(&rnet
->lock
);
276 if ((n
= rionet_rx_clean(ndev
)) != rnet
->rx_slot
)
277 rionet_rx_fill(ndev
, n
);
278 spin_unlock(&rnet
->lock
);
281 static void rionet_outb_msg_event(struct rio_mport
*mport
, void *dev_id
, int mbox
, int slot
)
283 struct net_device
*ndev
= dev_id
;
284 struct rionet_private
*rnet
= netdev_priv(ndev
);
286 spin_lock(&rnet
->tx_lock
);
288 if (netif_msg_intr(rnet
))
290 "%s: outbound message event, mbox %d slot %d\n",
291 DRV_NAME
, mbox
, slot
);
293 while (rnet
->tx_cnt
&& (rnet
->ack_slot
!= slot
)) {
294 /* dma unmap single */
295 dev_kfree_skb_irq(rnet
->tx_skb
[rnet
->ack_slot
]);
296 rnet
->tx_skb
[rnet
->ack_slot
] = NULL
;
298 rnet
->ack_slot
&= (RIONET_TX_RING_SIZE
- 1);
302 if (rnet
->tx_cnt
< RIONET_TX_RING_SIZE
)
303 netif_wake_queue(ndev
);
305 spin_unlock(&rnet
->tx_lock
);
308 static int rionet_open(struct net_device
*ndev
)
311 struct rionet_peer
*peer
, *tmp
;
312 struct rionet_private
*rnet
= netdev_priv(ndev
);
314 if (netif_msg_ifup(rnet
))
315 printk(KERN_INFO
"%s: open\n", DRV_NAME
);
317 if ((rc
= rio_request_inb_dbell(rnet
->mport
,
319 RIONET_DOORBELL_JOIN
,
320 RIONET_DOORBELL_LEAVE
,
321 rionet_dbell_event
)) < 0)
324 if ((rc
= rio_request_inb_mbox(rnet
->mport
,
328 rionet_inb_msg_event
)) < 0)
331 if ((rc
= rio_request_outb_mbox(rnet
->mport
,
335 rionet_outb_msg_event
)) < 0)
338 /* Initialize inbound message ring */
339 for (i
= 0; i
< RIONET_RX_RING_SIZE
; i
++)
340 rnet
->rx_skb
[i
] = NULL
;
342 rionet_rx_fill(ndev
, 0);
348 netif_carrier_on(ndev
);
349 netif_start_queue(ndev
);
351 list_for_each_entry_safe(peer
, tmp
,
352 &nets
[rnet
->mport
->id
].peers
, node
) {
353 if (!(peer
->res
= rio_request_outb_dbell(peer
->rdev
,
354 RIONET_DOORBELL_JOIN
,
355 RIONET_DOORBELL_LEAVE
)))
357 printk(KERN_ERR
"%s: error requesting doorbells\n",
362 /* Send a join message */
363 rio_send_doorbell(peer
->rdev
, RIONET_DOORBELL_JOIN
);
370 static int rionet_close(struct net_device
*ndev
)
372 struct rionet_private
*rnet
= netdev_priv(ndev
);
373 struct rionet_peer
*peer
, *tmp
;
376 if (netif_msg_ifup(rnet
))
377 printk(KERN_INFO
"%s: close %s\n", DRV_NAME
, ndev
->name
);
379 netif_stop_queue(ndev
);
380 netif_carrier_off(ndev
);
382 for (i
= 0; i
< RIONET_RX_RING_SIZE
; i
++)
383 kfree_skb(rnet
->rx_skb
[i
]);
385 list_for_each_entry_safe(peer
, tmp
,
386 &nets
[rnet
->mport
->id
].peers
, node
) {
387 if (nets
[rnet
->mport
->id
].active
[peer
->rdev
->destid
]) {
388 rio_send_doorbell(peer
->rdev
, RIONET_DOORBELL_LEAVE
);
389 nets
[rnet
->mport
->id
].active
[peer
->rdev
->destid
] = NULL
;
391 rio_release_outb_dbell(peer
->rdev
, peer
->res
);
394 rio_release_inb_dbell(rnet
->mport
, RIONET_DOORBELL_JOIN
,
395 RIONET_DOORBELL_LEAVE
);
396 rio_release_inb_mbox(rnet
->mport
, RIONET_MAILBOX
);
397 rio_release_outb_mbox(rnet
->mport
, RIONET_MAILBOX
);
402 static void rionet_remove_dev(struct device
*dev
, struct subsys_interface
*sif
)
404 struct rio_dev
*rdev
= to_rio_dev(dev
);
405 unsigned char netid
= rdev
->net
->hport
->id
;
406 struct rionet_peer
*peer
, *tmp
;
408 if (dev_rionet_capable(rdev
)) {
409 list_for_each_entry_safe(peer
, tmp
, &nets
[netid
].peers
, node
) {
410 if (peer
->rdev
== rdev
) {
411 if (nets
[netid
].active
[rdev
->destid
]) {
412 nets
[netid
].active
[rdev
->destid
] = NULL
;
416 list_del(&peer
->node
);
424 static void rionet_get_drvinfo(struct net_device
*ndev
,
425 struct ethtool_drvinfo
*info
)
427 struct rionet_private
*rnet
= netdev_priv(ndev
);
429 strlcpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
));
430 strlcpy(info
->version
, DRV_VERSION
, sizeof(info
->version
));
431 strlcpy(info
->fw_version
, "n/a", sizeof(info
->fw_version
));
432 strlcpy(info
->bus_info
, rnet
->mport
->name
, sizeof(info
->bus_info
));
435 static u32
rionet_get_msglevel(struct net_device
*ndev
)
437 struct rionet_private
*rnet
= netdev_priv(ndev
);
439 return rnet
->msg_enable
;
442 static void rionet_set_msglevel(struct net_device
*ndev
, u32 value
)
444 struct rionet_private
*rnet
= netdev_priv(ndev
);
446 rnet
->msg_enable
= value
;
449 static int rionet_change_mtu(struct net_device
*ndev
, int new_mtu
)
451 if ((new_mtu
< 68) || (new_mtu
> RIONET_MAX_MTU
)) {
452 printk(KERN_ERR
"%s: Invalid MTU size %d\n",
453 ndev
->name
, new_mtu
);
460 static const struct ethtool_ops rionet_ethtool_ops
= {
461 .get_drvinfo
= rionet_get_drvinfo
,
462 .get_msglevel
= rionet_get_msglevel
,
463 .set_msglevel
= rionet_set_msglevel
,
464 .get_link
= ethtool_op_get_link
,
467 static const struct net_device_ops rionet_netdev_ops
= {
468 .ndo_open
= rionet_open
,
469 .ndo_stop
= rionet_close
,
470 .ndo_start_xmit
= rionet_start_xmit
,
471 .ndo_change_mtu
= rionet_change_mtu
,
472 .ndo_validate_addr
= eth_validate_addr
,
473 .ndo_set_mac_address
= eth_mac_addr
,
476 static int rionet_setup_netdev(struct rio_mport
*mport
, struct net_device
*ndev
)
479 struct rionet_private
*rnet
;
481 const size_t rionet_active_bytes
= sizeof(void *) *
482 RIO_MAX_ROUTE_ENTRIES(mport
->sys_size
);
484 nets
[mport
->id
].active
= (struct rio_dev
**)__get_free_pages(GFP_KERNEL
,
485 get_order(rionet_active_bytes
));
486 if (!nets
[mport
->id
].active
) {
490 memset((void *)nets
[mport
->id
].active
, 0, rionet_active_bytes
);
492 /* Set up private area */
493 rnet
= netdev_priv(ndev
);
496 /* Set the default MAC address */
497 device_id
= rio_local_get_device_id(mport
);
498 ndev
->dev_addr
[0] = 0x00;
499 ndev
->dev_addr
[1] = 0x01;
500 ndev
->dev_addr
[2] = 0x00;
501 ndev
->dev_addr
[3] = 0x01;
502 ndev
->dev_addr
[4] = device_id
>> 8;
503 ndev
->dev_addr
[5] = device_id
& 0xff;
505 ndev
->netdev_ops
= &rionet_netdev_ops
;
506 ndev
->mtu
= RIONET_MAX_MTU
;
507 ndev
->features
= NETIF_F_LLTX
;
508 SET_NETDEV_DEV(ndev
, &mport
->dev
);
509 ndev
->ethtool_ops
= &rionet_ethtool_ops
;
511 spin_lock_init(&rnet
->lock
);
512 spin_lock_init(&rnet
->tx_lock
);
514 rnet
->msg_enable
= RIONET_DEFAULT_MSGLEVEL
;
516 rc
= register_netdev(ndev
);
520 printk(KERN_INFO
"%s: %s %s Version %s, MAC %pM, %s\n",
532 static unsigned long net_table
[RIONET_MAX_NETS
/sizeof(unsigned long) + 1];
534 static int rionet_add_dev(struct device
*dev
, struct subsys_interface
*sif
)
537 u32 lsrc_ops
, ldst_ops
;
538 struct rionet_peer
*peer
;
539 struct net_device
*ndev
= NULL
;
540 struct rio_dev
*rdev
= to_rio_dev(dev
);
541 unsigned char netid
= rdev
->net
->hport
->id
;
544 if (netid
>= RIONET_MAX_NETS
)
547 oldnet
= test_and_set_bit(netid
, net_table
);
550 * If first time through this net, make sure local device is rionet
551 * capable and setup netdev (this step will be skipped in later probes
555 rio_local_read_config_32(rdev
->net
->hport
, RIO_SRC_OPS_CAR
,
557 rio_local_read_config_32(rdev
->net
->hport
, RIO_DST_OPS_CAR
,
559 if (!is_rionet_capable(lsrc_ops
, ldst_ops
)) {
561 "%s: local device %s is not network capable\n",
562 DRV_NAME
, rdev
->net
->hport
->name
);
566 /* Allocate our net_device structure */
567 ndev
= alloc_etherdev(sizeof(struct rionet_private
));
572 nets
[netid
].ndev
= ndev
;
573 rc
= rionet_setup_netdev(rdev
->net
->hport
, ndev
);
575 printk(KERN_ERR
"%s: failed to setup netdev (rc=%d)\n",
580 INIT_LIST_HEAD(&nets
[netid
].peers
);
581 nets
[netid
].nact
= 0;
582 } else if (nets
[netid
].ndev
== NULL
)
586 * If the remote device has mailbox/doorbell capabilities,
587 * add it to the peer list.
589 if (dev_rionet_capable(rdev
)) {
590 if (!(peer
= kmalloc(sizeof(struct rionet_peer
), GFP_KERNEL
))) {
595 list_add_tail(&peer
->node
, &nets
[netid
].peers
);
603 static int rionet_shutdown(struct notifier_block
*nb
, unsigned long code
,
606 struct rionet_peer
*peer
, *tmp
;
609 pr_debug("%s: %s\n", DRV_NAME
, __func__
);
611 for (i
= 0; i
< RIONET_MAX_NETS
; i
++) {
615 list_for_each_entry_safe(peer
, tmp
, &nets
[i
].peers
, node
) {
616 if (nets
[i
].active
[peer
->rdev
->destid
]) {
617 rio_send_doorbell(peer
->rdev
,
618 RIONET_DOORBELL_LEAVE
);
619 nets
[i
].active
[peer
->rdev
->destid
] = NULL
;
628 static struct rio_device_id rionet_id_table
[] = {
629 {RIO_DEVICE(RIO_ANY_ID
, RIO_ANY_ID
)},
630 { 0, } /* terminate list */
633 MODULE_DEVICE_TABLE(rapidio
, rionet_id_table
);
636 static struct subsys_interface rionet_interface
= {
638 .subsys
= &rio_bus_type
,
639 .add_dev
= rionet_add_dev
,
640 .remove_dev
= rionet_remove_dev
,
643 static struct notifier_block rionet_notifier
= {
644 .notifier_call
= rionet_shutdown
,
647 static int __init
rionet_init(void)
651 ret
= register_reboot_notifier(&rionet_notifier
);
653 pr_err("%s: failed to register reboot notifier (err=%d)\n",
657 return subsys_interface_register(&rionet_interface
);
660 static void __exit
rionet_exit(void)
662 struct rionet_private
*rnet
;
663 struct net_device
*ndev
;
664 struct rionet_peer
*peer
, *tmp
;
667 for (i
= 0; i
< RIONET_MAX_NETS
; i
++) {
668 if (nets
[i
].ndev
!= NULL
) {
670 rnet
= netdev_priv(ndev
);
671 unregister_netdev(ndev
);
673 list_for_each_entry_safe(peer
,
674 tmp
, &nets
[i
].peers
, node
) {
675 list_del(&peer
->node
);
679 free_pages((unsigned long)nets
[i
].active
,
680 get_order(sizeof(void *) *
681 RIO_MAX_ROUTE_ENTRIES(rnet
->mport
->sys_size
)));
682 nets
[i
].active
= NULL
;
688 unregister_reboot_notifier(&rionet_notifier
);
689 subsys_interface_unregister(&rionet_interface
);
692 late_initcall(rionet_init
);
693 module_exit(rionet_exit
);