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); 747