Merge tag 'trace-v5.6-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt...
[linux-2.6-microblaze.git] / drivers / net / rionet.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * rionet - Ethernet driver over RapidIO messaging services
4  *
5  * Copyright 2005 MontaVista Software, Inc.
6  * Matt Porter <mporter@kernel.crashing.org>
7  */
8
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/delay.h>
13 #include <linux/rio.h>
14 #include <linux/rio_drv.h>
15 #include <linux/slab.h>
16 #include <linux/rio_ids.h>
17
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/skbuff.h>
21 #include <linux/crc32.h>
22 #include <linux/ethtool.h>
23 #include <linux/reboot.h>
24
25 #define DRV_NAME        "rionet"
26 #define DRV_VERSION     "0.3"
27 #define DRV_AUTHOR      "Matt Porter <mporter@kernel.crashing.org>"
28 #define DRV_DESC        "Ethernet over RapidIO"
29
30 MODULE_AUTHOR(DRV_AUTHOR);
31 MODULE_DESCRIPTION(DRV_DESC);
32 MODULE_LICENSE("GPL");
33
34 #define RIONET_DEFAULT_MSGLEVEL \
35                         (NETIF_MSG_DRV          | \
36                          NETIF_MSG_LINK         | \
37                          NETIF_MSG_RX_ERR       | \
38                          NETIF_MSG_TX_ERR)
39
40 #define RIONET_DOORBELL_JOIN    0x1000
41 #define RIONET_DOORBELL_LEAVE   0x1001
42
43 #define RIONET_MAILBOX          0
44
45 #define RIONET_TX_RING_SIZE     CONFIG_RIONET_TX_SIZE
46 #define RIONET_RX_RING_SIZE     CONFIG_RIONET_RX_SIZE
47 #define RIONET_MAX_NETS         8
48 #define RIONET_MSG_SIZE         RIO_MAX_MSG_SIZE
49 #define RIONET_MAX_MTU          (RIONET_MSG_SIZE - ETH_HLEN)
50
51 struct rionet_private {
52         struct rio_mport *mport;
53         struct sk_buff *rx_skb[RIONET_RX_RING_SIZE];
54         struct sk_buff *tx_skb[RIONET_TX_RING_SIZE];
55         int rx_slot;
56         int tx_slot;
57         int tx_cnt;
58         int ack_slot;
59         spinlock_t lock;
60         spinlock_t tx_lock;
61         u32 msg_enable;
62         bool open;
63 };
64
65 struct rionet_peer {
66         struct list_head node;
67         struct rio_dev *rdev;
68         struct resource *res;
69 };
70
71 struct rionet_net {
72         struct net_device *ndev;
73         struct list_head peers;
74         spinlock_t lock;        /* net info access lock */
75         struct rio_dev **active;
76         int nact;       /* number of active peers */
77 };
78
79 static struct rionet_net nets[RIONET_MAX_NETS];
80
81 #define is_rionet_capable(src_ops, dst_ops)                     \
82                         ((src_ops & RIO_SRC_OPS_DATA_MSG) &&    \
83                          (dst_ops & RIO_DST_OPS_DATA_MSG) &&    \
84                          (src_ops & RIO_SRC_OPS_DOORBELL) &&    \
85                          (dst_ops & RIO_DST_OPS_DOORBELL))
86 #define dev_rionet_capable(dev) \
87         is_rionet_capable(dev->src_ops, dev->dst_ops)
88
89 #define RIONET_MAC_MATCH(x)     (!memcmp((x), "\00\01\00\01", 4))
90 #define RIONET_GET_DESTID(x)    ((*((u8 *)x + 4) << 8) | *((u8 *)x + 5))
91
92 static int rionet_rx_clean(struct net_device *ndev)
93 {
94         int i;
95         int error = 0;
96         struct rionet_private *rnet = netdev_priv(ndev);
97         void *data;
98
99         i = rnet->rx_slot;
100
101         do {
102                 if (!rnet->rx_skb[i])
103                         continue;
104
105                 if (!(data = rio_get_inb_message(rnet->mport, RIONET_MAILBOX)))
106                         break;
107
108                 rnet->rx_skb[i]->data = data;
109                 skb_put(rnet->rx_skb[i], RIO_MAX_MSG_SIZE);
110                 rnet->rx_skb[i]->protocol =
111                     eth_type_trans(rnet->rx_skb[i], ndev);
112                 error = netif_rx(rnet->rx_skb[i]);
113
114                 if (error == NET_RX_DROP) {
115                         ndev->stats.rx_dropped++;
116                 } else {
117                         ndev->stats.rx_packets++;
118                         ndev->stats.rx_bytes += RIO_MAX_MSG_SIZE;
119                 }
120
121         } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != rnet->rx_slot);
122
123         return i;
124 }
125
126 static void rionet_rx_fill(struct net_device *ndev, int end)
127 {
128         int i;
129         struct rionet_private *rnet = netdev_priv(ndev);
130
131         i = rnet->rx_slot;
132         do {
133                 rnet->rx_skb[i] = dev_alloc_skb(RIO_MAX_MSG_SIZE);
134
135                 if (!rnet->rx_skb[i])
136                         break;
137
138                 rio_add_inb_buffer(rnet->mport, RIONET_MAILBOX,
139                                    rnet->rx_skb[i]->data);
140         } while ((i = (i + 1) % RIONET_RX_RING_SIZE) != end);
141
142         rnet->rx_slot = i;
143 }
144
145 static int rionet_queue_tx_msg(struct sk_buff *skb, struct net_device *ndev,
146                                struct rio_dev *rdev)
147 {
148         struct rionet_private *rnet = netdev_priv(ndev);
149
150         rio_add_outb_message(rnet->mport, rdev, 0, skb->data, skb->len);
151         rnet->tx_skb[rnet->tx_slot] = skb;
152
153         ndev->stats.tx_packets++;
154         ndev->stats.tx_bytes += skb->len;
155
156         if (++rnet->tx_cnt == RIONET_TX_RING_SIZE)
157                 netif_stop_queue(ndev);
158
159         ++rnet->tx_slot;
160         rnet->tx_slot &= (RIONET_TX_RING_SIZE - 1);
161
162         if (netif_msg_tx_queued(rnet))
163                 printk(KERN_INFO "%s: queued skb len %8.8x\n", DRV_NAME,
164                        skb->len);
165
166         return 0;
167 }
168
169 static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
170 {
171         int i;
172         struct rionet_private *rnet = netdev_priv(ndev);
173         struct ethhdr *eth = (struct ethhdr *)skb->data;
174         u16 destid;
175         unsigned long flags;
176         int add_num = 1;
177
178         spin_lock_irqsave(&rnet->tx_lock, flags);
179
180         if (is_multicast_ether_addr(eth->h_dest))
181                 add_num = nets[rnet->mport->id].nact;
182
183         if ((rnet->tx_cnt + add_num) > RIONET_TX_RING_SIZE) {
184                 netif_stop_queue(ndev);
185                 spin_unlock_irqrestore(&rnet->tx_lock, flags);
186                 printk(KERN_ERR "%s: BUG! Tx Ring full when queue awake!\n",
187                        ndev->name);
188                 return NETDEV_TX_BUSY;
189         }
190
191         if (is_multicast_ether_addr(eth->h_dest)) {
192                 int count = 0;
193
194                 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rnet->mport->sys_size);
195                                 i++)
196                         if (nets[rnet->mport->id].active[i]) {
197                                 rionet_queue_tx_msg(skb, ndev,
198                                         nets[rnet->mport->id].active[i]);
199                                 if (count)
200                                         refcount_inc(&skb->users);
201                                 count++;
202                         }
203         } else if (RIONET_MAC_MATCH(eth->h_dest)) {
204                 destid = RIONET_GET_DESTID(eth->h_dest);
205                 if (nets[rnet->mport->id].active[destid])
206                         rionet_queue_tx_msg(skb, ndev,
207                                         nets[rnet->mport->id].active[destid]);
208                 else {
209                         /*
210                          * If the target device was removed from the list of
211                          * active peers but we still have TX packets targeting
212                          * it just report sending a packet to the target
213                          * (without actual packet transfer).
214                          */
215                         ndev->stats.tx_packets++;
216                         ndev->stats.tx_bytes += skb->len;
217                         dev_kfree_skb_any(skb);
218                 }
219         }
220
221         spin_unlock_irqrestore(&rnet->tx_lock, flags);
222
223         return NETDEV_TX_OK;
224 }
225
226 static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u16 tid,
227                                u16 info)
228 {
229         struct net_device *ndev = dev_id;
230         struct rionet_private *rnet = netdev_priv(ndev);
231         struct rionet_peer *peer;
232         unsigned char netid = rnet->mport->id;
233
234         if (netif_msg_intr(rnet))
235                 printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x",
236                        DRV_NAME, sid, tid, info);
237         if (info == RIONET_DOORBELL_JOIN) {
238                 if (!nets[netid].active[sid]) {
239                         spin_lock(&nets[netid].lock);
240                         list_for_each_entry(peer, &nets[netid].peers, node) {
241                                 if (peer->rdev->destid == sid) {
242                                         nets[netid].active[sid] = peer->rdev;
243                                         nets[netid].nact++;
244                                 }
245                         }
246                         spin_unlock(&nets[netid].lock);
247
248                         rio_mport_send_doorbell(mport, sid,
249                                                 RIONET_DOORBELL_JOIN);
250                 }
251         } else if (info == RIONET_DOORBELL_LEAVE) {
252                 spin_lock(&nets[netid].lock);
253                 if (nets[netid].active[sid]) {
254                         nets[netid].active[sid] = NULL;
255                         nets[netid].nact--;
256                 }
257                 spin_unlock(&nets[netid].lock);
258         } else {
259                 if (netif_msg_intr(rnet))
260                         printk(KERN_WARNING "%s: unhandled doorbell\n",
261                                DRV_NAME);
262         }
263 }
264
265 static void rionet_inb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot)
266 {
267         int n;
268         struct net_device *ndev = dev_id;
269         struct rionet_private *rnet = netdev_priv(ndev);
270
271         if (netif_msg_intr(rnet))
272                 printk(KERN_INFO "%s: inbound message event, mbox %d slot %d\n",
273                        DRV_NAME, mbox, slot);
274
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);
279 }
280
281 static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot)
282 {
283         struct net_device *ndev = dev_id;
284         struct rionet_private *rnet = netdev_priv(ndev);
285
286         spin_lock(&rnet->tx_lock);
287
288         if (netif_msg_intr(rnet))
289                 printk(KERN_INFO
290                        "%s: outbound message event, mbox %d slot %d\n",
291                        DRV_NAME, mbox, slot);
292
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;
297                 ++rnet->ack_slot;
298                 rnet->ack_slot &= (RIONET_TX_RING_SIZE - 1);
299                 rnet->tx_cnt--;
300         }
301
302         if (rnet->tx_cnt < RIONET_TX_RING_SIZE)
303                 netif_wake_queue(ndev);
304
305         spin_unlock(&rnet->tx_lock);
306 }
307
308 static int rionet_open(struct net_device *ndev)
309 {
310         int i, rc = 0;
311         struct rionet_peer *peer;
312         struct rionet_private *rnet = netdev_priv(ndev);
313         unsigned char netid = rnet->mport->id;
314         unsigned long flags;
315
316         if (netif_msg_ifup(rnet))
317                 printk(KERN_INFO "%s: open\n", DRV_NAME);
318
319         if ((rc = rio_request_inb_dbell(rnet->mport,
320                                         (void *)ndev,
321                                         RIONET_DOORBELL_JOIN,
322                                         RIONET_DOORBELL_LEAVE,
323                                         rionet_dbell_event)) < 0)
324                 goto out;
325
326         if ((rc = rio_request_inb_mbox(rnet->mport,
327                                        (void *)ndev,
328                                        RIONET_MAILBOX,
329                                        RIONET_RX_RING_SIZE,
330                                        rionet_inb_msg_event)) < 0)
331                 goto out;
332
333         if ((rc = rio_request_outb_mbox(rnet->mport,
334                                         (void *)ndev,
335                                         RIONET_MAILBOX,
336                                         RIONET_TX_RING_SIZE,
337                                         rionet_outb_msg_event)) < 0)
338                 goto out;
339
340         /* Initialize inbound message ring */
341         for (i = 0; i < RIONET_RX_RING_SIZE; i++)
342                 rnet->rx_skb[i] = NULL;
343         rnet->rx_slot = 0;
344         rionet_rx_fill(ndev, 0);
345
346         rnet->tx_slot = 0;
347         rnet->tx_cnt = 0;
348         rnet->ack_slot = 0;
349
350         netif_carrier_on(ndev);
351         netif_start_queue(ndev);
352
353         spin_lock_irqsave(&nets[netid].lock, flags);
354         list_for_each_entry(peer, &nets[netid].peers, node) {
355                 /* Send a join message */
356                 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
357         }
358         spin_unlock_irqrestore(&nets[netid].lock, flags);
359         rnet->open = true;
360
361       out:
362         return rc;
363 }
364
365 static int rionet_close(struct net_device *ndev)
366 {
367         struct rionet_private *rnet = netdev_priv(ndev);
368         struct rionet_peer *peer;
369         unsigned char netid = rnet->mport->id;
370         unsigned long flags;
371         int i;
372
373         if (netif_msg_ifup(rnet))
374                 printk(KERN_INFO "%s: close %s\n", DRV_NAME, ndev->name);
375
376         netif_stop_queue(ndev);
377         netif_carrier_off(ndev);
378         rnet->open = false;
379
380         for (i = 0; i < RIONET_RX_RING_SIZE; i++)
381                 kfree_skb(rnet->rx_skb[i]);
382
383         spin_lock_irqsave(&nets[netid].lock, flags);
384         list_for_each_entry(peer, &nets[netid].peers, node) {
385                 if (nets[netid].active[peer->rdev->destid]) {
386                         rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE);
387                         nets[netid].active[peer->rdev->destid] = NULL;
388                 }
389                 if (peer->res)
390                         rio_release_outb_dbell(peer->rdev, peer->res);
391         }
392         spin_unlock_irqrestore(&nets[netid].lock, flags);
393
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);
398
399         return 0;
400 }
401
402 static void rionet_remove_dev(struct device *dev, struct subsys_interface *sif)
403 {
404         struct rio_dev *rdev = to_rio_dev(dev);
405         unsigned char netid = rdev->net->hport->id;
406         struct rionet_peer *peer;
407         int state, found = 0;
408         unsigned long flags;
409
410         if (!dev_rionet_capable(rdev))
411                 return;
412
413         spin_lock_irqsave(&nets[netid].lock, flags);
414         list_for_each_entry(peer, &nets[netid].peers, node) {
415                 if (peer->rdev == rdev) {
416                         list_del(&peer->node);
417                         if (nets[netid].active[rdev->destid]) {
418                                 state = atomic_read(&rdev->state);
419                                 if (state != RIO_DEVICE_GONE &&
420                                     state != RIO_DEVICE_INITIALIZING) {
421                                         rio_send_doorbell(rdev,
422                                                         RIONET_DOORBELL_LEAVE);
423                                 }
424                                 nets[netid].active[rdev->destid] = NULL;
425                                 nets[netid].nact--;
426                         }
427                         found = 1;
428                         break;
429                 }
430         }
431         spin_unlock_irqrestore(&nets[netid].lock, flags);
432
433         if (found) {
434                 if (peer->res)
435                         rio_release_outb_dbell(rdev, peer->res);
436                 kfree(peer);
437         }
438 }
439
440 static void rionet_get_drvinfo(struct net_device *ndev,
441                                struct ethtool_drvinfo *info)
442 {
443         struct rionet_private *rnet = netdev_priv(ndev);
444
445         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
446         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
447         strlcpy(info->fw_version, "n/a", sizeof(info->fw_version));
448         strlcpy(info->bus_info, rnet->mport->name, sizeof(info->bus_info));
449 }
450
451 static u32 rionet_get_msglevel(struct net_device *ndev)
452 {
453         struct rionet_private *rnet = netdev_priv(ndev);
454
455         return rnet->msg_enable;
456 }
457
458 static void rionet_set_msglevel(struct net_device *ndev, u32 value)
459 {
460         struct rionet_private *rnet = netdev_priv(ndev);
461
462         rnet->msg_enable = value;
463 }
464
465 static const struct ethtool_ops rionet_ethtool_ops = {
466         .get_drvinfo = rionet_get_drvinfo,
467         .get_msglevel = rionet_get_msglevel,
468         .set_msglevel = rionet_set_msglevel,
469         .get_link = ethtool_op_get_link,
470 };
471
472 static const struct net_device_ops rionet_netdev_ops = {
473         .ndo_open               = rionet_open,
474         .ndo_stop               = rionet_close,
475         .ndo_start_xmit         = rionet_start_xmit,
476         .ndo_validate_addr      = eth_validate_addr,
477         .ndo_set_mac_address    = eth_mac_addr,
478 };
479
480 static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
481 {
482         int rc = 0;
483         struct rionet_private *rnet;
484         u16 device_id;
485         const size_t rionet_active_bytes = sizeof(void *) *
486                                 RIO_MAX_ROUTE_ENTRIES(mport->sys_size);
487
488         nets[mport->id].active = (struct rio_dev **)__get_free_pages(GFP_KERNEL,
489                                                 get_order(rionet_active_bytes));
490         if (!nets[mport->id].active) {
491                 rc = -ENOMEM;
492                 goto out;
493         }
494         memset((void *)nets[mport->id].active, 0, rionet_active_bytes);
495
496         /* Set up private area */
497         rnet = netdev_priv(ndev);
498         rnet->mport = mport;
499         rnet->open = false;
500
501         /* Set the default MAC address */
502         device_id = rio_local_get_device_id(mport);
503         ndev->dev_addr[0] = 0x00;
504         ndev->dev_addr[1] = 0x01;
505         ndev->dev_addr[2] = 0x00;
506         ndev->dev_addr[3] = 0x01;
507         ndev->dev_addr[4] = device_id >> 8;
508         ndev->dev_addr[5] = device_id & 0xff;
509
510         ndev->netdev_ops = &rionet_netdev_ops;
511         ndev->mtu = RIONET_MAX_MTU;
512         /* MTU range: 68 - 4082 */
513         ndev->min_mtu = ETH_MIN_MTU;
514         ndev->max_mtu = RIONET_MAX_MTU;
515         ndev->features = NETIF_F_LLTX;
516         SET_NETDEV_DEV(ndev, &mport->dev);
517         ndev->ethtool_ops = &rionet_ethtool_ops;
518
519         spin_lock_init(&rnet->lock);
520         spin_lock_init(&rnet->tx_lock);
521
522         rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL;
523
524         rc = register_netdev(ndev);
525         if (rc != 0) {
526                 free_pages((unsigned long)nets[mport->id].active,
527                            get_order(rionet_active_bytes));
528                 goto out;
529         }
530
531         printk(KERN_INFO "%s: %s %s Version %s, MAC %pM, %s\n",
532                ndev->name,
533                DRV_NAME,
534                DRV_DESC,
535                DRV_VERSION,
536                ndev->dev_addr,
537                mport->name);
538
539       out:
540         return rc;
541 }
542
543 static int rionet_add_dev(struct device *dev, struct subsys_interface *sif)
544 {
545         int rc = -ENODEV;
546         u32 lsrc_ops, ldst_ops;
547         struct rionet_peer *peer;
548         struct net_device *ndev = NULL;
549         struct rio_dev *rdev = to_rio_dev(dev);
550         unsigned char netid = rdev->net->hport->id;
551
552         if (netid >= RIONET_MAX_NETS)
553                 return rc;
554
555         /*
556          * If first time through this net, make sure local device is rionet
557          * capable and setup netdev (this step will be skipped in later probes
558          * on the same net).
559          */
560         if (!nets[netid].ndev) {
561                 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
562                                          &lsrc_ops);
563                 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
564                                          &ldst_ops);
565                 if (!is_rionet_capable(lsrc_ops, ldst_ops)) {
566                         printk(KERN_ERR
567                                "%s: local device %s is not network capable\n",
568                                DRV_NAME, rdev->net->hport->name);
569                         goto out;
570                 }
571
572                 /* Allocate our net_device structure */
573                 ndev = alloc_etherdev(sizeof(struct rionet_private));
574                 if (ndev == NULL) {
575                         rc = -ENOMEM;
576                         goto out;
577                 }
578
579                 rc = rionet_setup_netdev(rdev->net->hport, ndev);
580                 if (rc) {
581                         printk(KERN_ERR "%s: failed to setup netdev (rc=%d)\n",
582                                DRV_NAME, rc);
583                         free_netdev(ndev);
584                         goto out;
585                 }
586
587                 INIT_LIST_HEAD(&nets[netid].peers);
588                 spin_lock_init(&nets[netid].lock);
589                 nets[netid].nact = 0;
590                 nets[netid].ndev = ndev;
591         }
592
593         /*
594          * If the remote device has mailbox/doorbell capabilities,
595          * add it to the peer list.
596          */
597         if (dev_rionet_capable(rdev)) {
598                 struct rionet_private *rnet;
599                 unsigned long flags;
600
601                 rnet = netdev_priv(nets[netid].ndev);
602
603                 peer = kzalloc(sizeof(*peer), GFP_KERNEL);
604                 if (!peer) {
605                         rc = -ENOMEM;
606                         goto out;
607                 }
608                 peer->rdev = rdev;
609                 peer->res = rio_request_outb_dbell(peer->rdev,
610                                                 RIONET_DOORBELL_JOIN,
611                                                 RIONET_DOORBELL_LEAVE);
612                 if (!peer->res) {
613                         pr_err("%s: error requesting doorbells\n", DRV_NAME);
614                         kfree(peer);
615                         rc = -ENOMEM;
616                         goto out;
617                 }
618
619                 spin_lock_irqsave(&nets[netid].lock, flags);
620                 list_add_tail(&peer->node, &nets[netid].peers);
621                 spin_unlock_irqrestore(&nets[netid].lock, flags);
622                 pr_debug("%s: %s add peer %s\n",
623                          DRV_NAME, __func__, rio_name(rdev));
624
625                 /* If netdev is already opened, send join request to new peer */
626                 if (rnet->open)
627                         rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
628         }
629
630         return 0;
631 out:
632         return rc;
633 }
634
635 static int rionet_shutdown(struct notifier_block *nb, unsigned long code,
636                            void *unused)
637 {
638         struct rionet_peer *peer;
639         unsigned long flags;
640         int i;
641
642         pr_debug("%s: %s\n", DRV_NAME, __func__);
643
644         for (i = 0; i < RIONET_MAX_NETS; i++) {
645                 if (!nets[i].ndev)
646                         continue;
647
648                 spin_lock_irqsave(&nets[i].lock, flags);
649                 list_for_each_entry(peer, &nets[i].peers, node) {
650                         if (nets[i].active[peer->rdev->destid]) {
651                                 rio_send_doorbell(peer->rdev,
652                                                   RIONET_DOORBELL_LEAVE);
653                                 nets[i].active[peer->rdev->destid] = NULL;
654                         }
655                 }
656                 spin_unlock_irqrestore(&nets[i].lock, flags);
657         }
658
659         return NOTIFY_DONE;
660 }
661
662 static void rionet_remove_mport(struct device *dev,
663                                 struct class_interface *class_intf)
664 {
665         struct rio_mport *mport = to_rio_mport(dev);
666         struct net_device *ndev;
667         int id = mport->id;
668
669         pr_debug("%s %s\n", __func__, mport->name);
670
671         WARN(nets[id].nact, "%s called when connected to %d peers\n",
672              __func__, nets[id].nact);
673         WARN(!nets[id].ndev, "%s called for mport without NDEV\n",
674              __func__);
675
676         if (nets[id].ndev) {
677                 ndev = nets[id].ndev;
678                 netif_stop_queue(ndev);
679                 unregister_netdev(ndev);
680
681                 free_pages((unsigned long)nets[id].active,
682                            get_order(sizeof(void *) *
683                            RIO_MAX_ROUTE_ENTRIES(mport->sys_size)));
684                 nets[id].active = NULL;
685                 free_netdev(ndev);
686                 nets[id].ndev = NULL;
687         }
688 }
689
690 #ifdef MODULE
691 static struct rio_device_id rionet_id_table[] = {
692         {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)},
693         { 0, }  /* terminate list */
694 };
695
696 MODULE_DEVICE_TABLE(rapidio, rionet_id_table);
697 #endif
698
699 static struct subsys_interface rionet_interface = {
700         .name           = "rionet",
701         .subsys         = &rio_bus_type,
702         .add_dev        = rionet_add_dev,
703         .remove_dev     = rionet_remove_dev,
704 };
705
706 static struct notifier_block rionet_notifier = {
707         .notifier_call = rionet_shutdown,
708 };
709
710 /* the rio_mport_interface is used to handle local mport devices */
711 static struct class_interface rio_mport_interface __refdata = {
712         .class = &rio_mport_class,
713         .add_dev = NULL,
714         .remove_dev = rionet_remove_mport,
715 };
716
717 static int __init rionet_init(void)
718 {
719         int ret;
720
721         ret = register_reboot_notifier(&rionet_notifier);
722         if (ret) {
723                 pr_err("%s: failed to register reboot notifier (err=%d)\n",
724                        DRV_NAME, ret);
725                 return ret;
726         }
727
728         ret = class_interface_register(&rio_mport_interface);
729         if (ret) {
730                 pr_err("%s: class_interface_register error: %d\n",
731                        DRV_NAME, ret);
732                 return ret;
733         }
734
735         return subsys_interface_register(&rionet_interface);
736 }
737
738 static void __exit rionet_exit(void)
739 {
740         unregister_reboot_notifier(&rionet_notifier);
741         subsys_interface_unregister(&rionet_interface);
742         class_interface_unregister(&rio_mport_interface);
743 }
744
745 late_initcall(rionet_init);
746 module_exit(rionet_exit);