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 netdev_tx_t rionet_start_xmit(struct sk_buff *skb, 170 struct net_device *ndev) 171 { 172 int i; 173 struct rionet_private *rnet = netdev_priv(ndev); 174 struct ethhdr *eth = (struct ethhdr *)skb->data; 175 u16 destid; 176 unsigned long flags; 177 int add_num = 1; 178 179 spin_lock_irqsave(&rnet->tx_lock, flags); 180 181 if (is_multicast_ether_addr(eth->h_dest)) 182 add_num = nets[rnet->mport->id].nact; 183 184 if ((rnet->tx_cnt + add_num) > RIONET_TX_RING_SIZE) { 185 netif_stop_queue(ndev); 186 spin_unlock_irqrestore(&rnet->tx_lock, flags); 187 printk(KERN_ERR "%s: BUG! Tx Ring full when queue awake!\n", 188 ndev->name); 189 return NETDEV_TX_BUSY; 190 } 191 192 if (is_multicast_ether_addr(eth->h_dest)) { 193 int count = 0; 194 195 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rnet->mport->sys_size); 196 i++) 197 if (nets[rnet->mport->id].active[i]) { 198 rionet_queue_tx_msg(skb, ndev, 199 nets[rnet->mport->id].active[i]); 200 if (count) 201 refcount_inc(&skb->users); 202 count++; 203 } 204 } else if (RIONET_MAC_MATCH(eth->h_dest)) { 205 destid = RIONET_GET_DESTID(eth->h_dest); 206 if (nets[rnet->mport->id].active[destid]) 207 rionet_queue_tx_msg(skb, ndev, 208 nets[rnet->mport->id].active[destid]); 209 else { 210 /* 211 * If the target device was removed from the list of 212 * active peers but we still have TX packets targeting 213 * it just report sending a packet to the target 214 * (without actual packet transfer). 215 */ 216 ndev->stats.tx_packets++; 217 ndev->stats.tx_bytes += skb->len; 218 dev_kfree_skb_any(skb); 219 } 220 } 221 222 spin_unlock_irqrestore(&rnet->tx_lock, flags); 223 224 return NETDEV_TX_OK; 225 } 226 227 static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u16 tid, 228 u16 info) 229 { 230 struct net_device *ndev = dev_id; 231 struct rionet_private *rnet = netdev_priv(ndev); 232 struct rionet_peer *peer; 233 unsigned char netid = rnet->mport->id; 234 235 if (netif_msg_intr(rnet)) 236 printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x", 237 DRV_NAME, sid, tid, info); 238 if (info == RIONET_DOORBELL_JOIN) { 239 if (!nets[netid].active[sid]) { 240 spin_lock(&nets[netid].lock); 241 list_for_each_entry(peer, &nets[netid].peers, node) { 242 if (peer->rdev->destid == sid) { 243 nets[netid].active[sid] = peer->rdev; 244 nets[netid].nact++; 245 } 246 } 247 spin_unlock(&nets[netid].lock); 248 249 rio_mport_send_doorbell(mport, sid, 250 RIONET_DOORBELL_JOIN); 251 } 252 } else if (info == RIONET_DOORBELL_LEAVE) { 253 spin_lock(&nets[netid].lock); 254 if (nets[netid].active[sid]) { 255 nets[netid].active[sid] = NULL; 256 nets[netid].nact--; 257 } 258 spin_unlock(&nets[netid].lock); 259 } else { 260 if (netif_msg_intr(rnet)) 261 printk(KERN_WARNING "%s: unhandled doorbell\n", 262 DRV_NAME); 263 } 264 } 265 266 static void rionet_inb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot) 267 { 268 int n; 269 struct net_device *ndev = dev_id; 270 struct rionet_private *rnet = netdev_priv(ndev); 271 272 if (netif_msg_intr(rnet)) 273 printk(KERN_INFO "%s: inbound message event, mbox %d slot %d\n", 274 DRV_NAME, mbox, slot); 275 276 spin_lock(&rnet->lock); 277 if ((n = rionet_rx_clean(ndev)) != rnet->rx_slot) 278 rionet_rx_fill(ndev, n); 279 spin_unlock(&rnet->lock); 280 } 281 282 static void rionet_outb_msg_event(struct rio_mport *mport, void *dev_id, int mbox, int slot) 283 { 284 struct net_device *ndev = dev_id; 285 struct rionet_private *rnet = netdev_priv(ndev); 286 287 spin_lock(&rnet->tx_lock); 288 289 if (netif_msg_intr(rnet)) 290 printk(KERN_INFO 291 "%s: outbound message event, mbox %d slot %d\n", 292 DRV_NAME, mbox, slot); 293 294 while (rnet->tx_cnt && (rnet->ack_slot != slot)) { 295 /* dma unmap single */ 296 dev_kfree_skb_irq(rnet->tx_skb[rnet->ack_slot]); 297 rnet->tx_skb[rnet->ack_slot] = NULL; 298 ++rnet->ack_slot; 299 rnet->ack_slot &= (RIONET_TX_RING_SIZE - 1); 300 rnet->tx_cnt--; 301 } 302 303 if (rnet->tx_cnt < RIONET_TX_RING_SIZE) 304 netif_wake_queue(ndev); 305 306 spin_unlock(&rnet->tx_lock); 307 } 308 309 static int rionet_open(struct net_device *ndev) 310 { 311 int i, rc = 0; 312 struct rionet_peer *peer; 313 struct rionet_private *rnet = netdev_priv(ndev); 314 unsigned char netid = rnet->mport->id; 315 unsigned long flags; 316 317 if (netif_msg_ifup(rnet)) 318 printk(KERN_INFO "%s: open\n", DRV_NAME); 319 320 if ((rc = rio_request_inb_dbell(rnet->mport, 321 (void *)ndev, 322 RIONET_DOORBELL_JOIN, 323 RIONET_DOORBELL_LEAVE, 324 rionet_dbell_event)) < 0) 325 goto out; 326 327 if ((rc = rio_request_inb_mbox(rnet->mport, 328 (void *)ndev, 329 RIONET_MAILBOX, 330 RIONET_RX_RING_SIZE, 331 rionet_inb_msg_event)) < 0) 332 goto out; 333 334 if ((rc = rio_request_outb_mbox(rnet->mport, 335 (void *)ndev, 336 RIONET_MAILBOX, 337 RIONET_TX_RING_SIZE, 338 rionet_outb_msg_event)) < 0) 339 goto out; 340 341 /* Initialize inbound message ring */ 342 for (i = 0; i < RIONET_RX_RING_SIZE; i++) 343 rnet->rx_skb[i] = NULL; 344 rnet->rx_slot = 0; 345 rionet_rx_fill(ndev, 0); 346 347 rnet->tx_slot = 0; 348 rnet->tx_cnt = 0; 349 rnet->ack_slot = 0; 350 351 netif_carrier_on(ndev); 352 netif_start_queue(ndev); 353 354 spin_lock_irqsave(&nets[netid].lock, flags); 355 list_for_each_entry(peer, &nets[netid].peers, node) { 356 /* Send a join message */ 357 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN); 358 } 359 spin_unlock_irqrestore(&nets[netid].lock, flags); 360 rnet->open = true; 361 362 out: 363 return rc; 364 } 365 366 static int rionet_close(struct net_device *ndev) 367 { 368 struct rionet_private *rnet = netdev_priv(ndev); 369 struct rionet_peer *peer; 370 unsigned char netid = rnet->mport->id; 371 unsigned long flags; 372 int i; 373 374 if (netif_msg_ifup(rnet)) 375 printk(KERN_INFO "%s: close %s\n", DRV_NAME, ndev->name); 376 377 netif_stop_queue(ndev); 378 netif_carrier_off(ndev); 379 rnet->open = false; 380 381 for (i = 0; i < RIONET_RX_RING_SIZE; i++) 382 kfree_skb(rnet->rx_skb[i]); 383 384 spin_lock_irqsave(&nets[netid].lock, flags); 385 list_for_each_entry(peer, &nets[netid].peers, node) { 386 if (nets[netid].active[peer->rdev->destid]) { 387 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE); 388 nets[netid].active[peer->rdev->destid] = NULL; 389 } 390 if (peer->res) 391 rio_release_outb_dbell(peer->rdev, peer->res); 392 } 393 spin_unlock_irqrestore(&nets[netid].lock, flags); 394 395 rio_release_inb_dbell(rnet->mport, RIONET_DOORBELL_JOIN, 396 RIONET_DOORBELL_LEAVE); 397 rio_release_inb_mbox(rnet->mport, RIONET_MAILBOX); 398 rio_release_outb_mbox(rnet->mport, RIONET_MAILBOX); 399 400 return 0; 401 } 402 403 static void rionet_remove_dev(struct device *dev, struct subsys_interface *sif) 404 { 405 struct rio_dev *rdev = to_rio_dev(dev); 406 unsigned char netid = rdev->net->hport->id; 407 struct rionet_peer *peer; 408 int state, found = 0; 409 unsigned long flags; 410 411 if (!dev_rionet_capable(rdev)) 412 return; 413 414 spin_lock_irqsave(&nets[netid].lock, flags); 415 list_for_each_entry(peer, &nets[netid].peers, node) { 416 if (peer->rdev == rdev) { 417 list_del(&peer->node); 418 if (nets[netid].active[rdev->destid]) { 419 state = atomic_read(&rdev->state); 420 if (state != RIO_DEVICE_GONE && 421 state != RIO_DEVICE_INITIALIZING) { 422 rio_send_doorbell(rdev, 423 RIONET_DOORBELL_LEAVE); 424 } 425 nets[netid].active[rdev->destid] = NULL; 426 nets[netid].nact--; 427 } 428 found = 1; 429 break; 430 } 431 } 432 spin_unlock_irqrestore(&nets[netid].lock, flags); 433 434 if (found) { 435 if (peer->res) 436 rio_release_outb_dbell(rdev, peer->res); 437 kfree(peer); 438 } 439 } 440 441 static void rionet_get_drvinfo(struct net_device *ndev, 442 struct ethtool_drvinfo *info) 443 { 444 struct rionet_private *rnet = netdev_priv(ndev); 445 446 strscpy(info->driver, DRV_NAME, sizeof(info->driver)); 447 strscpy(info->version, DRV_VERSION, sizeof(info->version)); 448 strscpy(info->fw_version, "n/a", sizeof(info->fw_version)); 449 strscpy(info->bus_info, rnet->mport->name, sizeof(info->bus_info)); 450 } 451 452 static u32 rionet_get_msglevel(struct net_device *ndev) 453 { 454 struct rionet_private *rnet = netdev_priv(ndev); 455 456 return rnet->msg_enable; 457 } 458 459 static void rionet_set_msglevel(struct net_device *ndev, u32 value) 460 { 461 struct rionet_private *rnet = netdev_priv(ndev); 462 463 rnet->msg_enable = value; 464 } 465 466 static const struct ethtool_ops rionet_ethtool_ops = { 467 .get_drvinfo = rionet_get_drvinfo, 468 .get_msglevel = rionet_get_msglevel, 469 .set_msglevel = rionet_set_msglevel, 470 .get_link = ethtool_op_get_link, 471 }; 472 473 static const struct net_device_ops rionet_netdev_ops = { 474 .ndo_open = rionet_open, 475 .ndo_stop = rionet_close, 476 .ndo_start_xmit = rionet_start_xmit, 477 .ndo_validate_addr = eth_validate_addr, 478 .ndo_set_mac_address = eth_mac_addr, 479 }; 480 481 static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev) 482 { 483 int rc = 0; 484 struct rionet_private *rnet; 485 u8 addr[ETH_ALEN]; 486 u16 device_id; 487 const size_t rionet_active_bytes = sizeof(void *) * 488 RIO_MAX_ROUTE_ENTRIES(mport->sys_size); 489 490 nets[mport->id].active = (struct rio_dev **)__get_free_pages(GFP_KERNEL, 491 get_order(rionet_active_bytes)); 492 if (!nets[mport->id].active) { 493 rc = -ENOMEM; 494 goto out; 495 } 496 memset((void *)nets[mport->id].active, 0, rionet_active_bytes); 497 498 /* Set up private area */ 499 rnet = netdev_priv(ndev); 500 rnet->mport = mport; 501 rnet->open = false; 502 503 /* Set the default MAC address */ 504 device_id = rio_local_get_device_id(mport); 505 addr[0] = 0x00; 506 addr[1] = 0x01; 507 addr[2] = 0x00; 508 addr[3] = 0x01; 509 addr[4] = device_id >> 8; 510 addr[5] = device_id & 0xff; 511 eth_hw_addr_set(ndev, addr); 512 513 ndev->netdev_ops = &rionet_netdev_ops; 514 ndev->mtu = RIONET_MAX_MTU; 515 /* MTU range: 68 - 4082 */ 516 ndev->min_mtu = ETH_MIN_MTU; 517 ndev->max_mtu = RIONET_MAX_MTU; 518 ndev->features = NETIF_F_LLTX; 519 SET_NETDEV_DEV(ndev, &mport->dev); 520 ndev->ethtool_ops = &rionet_ethtool_ops; 521 522 spin_lock_init(&rnet->lock); 523 spin_lock_init(&rnet->tx_lock); 524 525 rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL; 526 527 rc = register_netdev(ndev); 528 if (rc != 0) { 529 free_pages((unsigned long)nets[mport->id].active, 530 get_order(rionet_active_bytes)); 531 goto out; 532 } 533 534 printk(KERN_INFO "%s: %s %s Version %s, MAC %pM, %s\n", 535 ndev->name, 536 DRV_NAME, 537 DRV_DESC, 538 DRV_VERSION, 539 ndev->dev_addr, 540 mport->name); 541 542 out: 543 return rc; 544 } 545 546 static int rionet_add_dev(struct device *dev, struct subsys_interface *sif) 547 { 548 int rc = -ENODEV; 549 u32 lsrc_ops, ldst_ops; 550 struct rionet_peer *peer; 551 struct net_device *ndev = NULL; 552 struct rio_dev *rdev = to_rio_dev(dev); 553 unsigned char netid = rdev->net->hport->id; 554 555 if (netid >= RIONET_MAX_NETS) 556 return rc; 557 558 /* 559 * If first time through this net, make sure local device is rionet 560 * capable and setup netdev (this step will be skipped in later probes 561 * on the same net). 562 */ 563 if (!nets[netid].ndev) { 564 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR, 565 &lsrc_ops); 566 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR, 567 &ldst_ops); 568 if (!is_rionet_capable(lsrc_ops, ldst_ops)) { 569 printk(KERN_ERR 570 "%s: local device %s is not network capable\n", 571 DRV_NAME, rdev->net->hport->name); 572 goto out; 573 } 574 575 /* Allocate our net_device structure */ 576 ndev = alloc_etherdev(sizeof(struct rionet_private)); 577 if (ndev == NULL) { 578 rc = -ENOMEM; 579 goto out; 580 } 581 582 rc = rionet_setup_netdev(rdev->net->hport, ndev); 583 if (rc) { 584 printk(KERN_ERR "%s: failed to setup netdev (rc=%d)\n", 585 DRV_NAME, rc); 586 free_netdev(ndev); 587 goto out; 588 } 589 590 INIT_LIST_HEAD(&nets[netid].peers); 591 spin_lock_init(&nets[netid].lock); 592 nets[netid].nact = 0; 593 nets[netid].ndev = ndev; 594 } 595 596 /* 597 * If the remote device has mailbox/doorbell capabilities, 598 * add it to the peer list. 599 */ 600 if (dev_rionet_capable(rdev)) { 601 struct rionet_private *rnet; 602 unsigned long flags; 603 604 rnet = netdev_priv(nets[netid].ndev); 605 606 peer = kzalloc(sizeof(*peer), GFP_KERNEL); 607 if (!peer) { 608 rc = -ENOMEM; 609 goto out; 610 } 611 peer->rdev = rdev; 612 peer->res = rio_request_outb_dbell(peer->rdev, 613 RIONET_DOORBELL_JOIN, 614 RIONET_DOORBELL_LEAVE); 615 if (!peer->res) { 616 pr_err("%s: error requesting doorbells\n", DRV_NAME); 617 kfree(peer); 618 rc = -ENOMEM; 619 goto out; 620 } 621 622 spin_lock_irqsave(&nets[netid].lock, flags); 623 list_add_tail(&peer->node, &nets[netid].peers); 624 spin_unlock_irqrestore(&nets[netid].lock, flags); 625 pr_debug("%s: %s add peer %s\n", 626 DRV_NAME, __func__, rio_name(rdev)); 627 628 /* If netdev is already opened, send join request to new peer */ 629 if (rnet->open) 630 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN); 631 } 632 633 return 0; 634 out: 635 return rc; 636 } 637 638 static int rionet_shutdown(struct notifier_block *nb, unsigned long code, 639 void *unused) 640 { 641 struct rionet_peer *peer; 642 unsigned long flags; 643 int i; 644 645 pr_debug("%s: %s\n", DRV_NAME, __func__); 646 647 for (i = 0; i < RIONET_MAX_NETS; i++) { 648 if (!nets[i].ndev) 649 continue; 650 651 spin_lock_irqsave(&nets[i].lock, flags); 652 list_for_each_entry(peer, &nets[i].peers, node) { 653 if (nets[i].active[peer->rdev->destid]) { 654 rio_send_doorbell(peer->rdev, 655 RIONET_DOORBELL_LEAVE); 656 nets[i].active[peer->rdev->destid] = NULL; 657 } 658 } 659 spin_unlock_irqrestore(&nets[i].lock, flags); 660 } 661 662 return NOTIFY_DONE; 663 } 664 665 static void rionet_remove_mport(struct device *dev) 666 { 667 struct rio_mport *mport = to_rio_mport(dev); 668 struct net_device *ndev; 669 int id = mport->id; 670 671 pr_debug("%s %s\n", __func__, mport->name); 672 673 WARN(nets[id].nact, "%s called when connected to %d peers\n", 674 __func__, nets[id].nact); 675 WARN(!nets[id].ndev, "%s called for mport without NDEV\n", 676 __func__); 677 678 if (nets[id].ndev) { 679 ndev = nets[id].ndev; 680 netif_stop_queue(ndev); 681 unregister_netdev(ndev); 682 683 free_pages((unsigned long)nets[id].active, 684 get_order(sizeof(void *) * 685 RIO_MAX_ROUTE_ENTRIES(mport->sys_size))); 686 nets[id].active = NULL; 687 free_netdev(ndev); 688 nets[id].ndev = NULL; 689 } 690 } 691 692 #ifdef MODULE 693 static struct rio_device_id rionet_id_table[] = { 694 {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)}, 695 { 0, } /* terminate list */ 696 }; 697 698 MODULE_DEVICE_TABLE(rapidio, rionet_id_table); 699 #endif 700 701 static struct subsys_interface rionet_interface = { 702 .name = "rionet", 703 .subsys = &rio_bus_type, 704 .add_dev = rionet_add_dev, 705 .remove_dev = rionet_remove_dev, 706 }; 707 708 static struct notifier_block rionet_notifier = { 709 .notifier_call = rionet_shutdown, 710 }; 711 712 /* the rio_mport_interface is used to handle local mport devices */ 713 static struct class_interface rio_mport_interface __refdata = { 714 .class = &rio_mport_class, 715 .add_dev = NULL, 716 .remove_dev = rionet_remove_mport, 717 }; 718 719 static int __init rionet_init(void) 720 { 721 int ret; 722 723 ret = register_reboot_notifier(&rionet_notifier); 724 if (ret) { 725 pr_err("%s: failed to register reboot notifier (err=%d)\n", 726 DRV_NAME, ret); 727 return ret; 728 } 729 730 ret = class_interface_register(&rio_mport_interface); 731 if (ret) { 732 pr_err("%s: class_interface_register error: %d\n", 733 DRV_NAME, ret); 734 return ret; 735 } 736 737 return subsys_interface_register(&rionet_interface); 738 } 739 740 static void __exit rionet_exit(void) 741 { 742 unregister_reboot_notifier(&rionet_notifier); 743 subsys_interface_unregister(&rionet_interface); 744 class_interface_unregister(&rio_mport_interface); 745 } 746 747 late_initcall(rionet_init); 748 module_exit(rionet_exit); 749