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 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 447 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 448 strlcpy(info->fw_version, "n/a", sizeof(info->fw_version)); 449 strlcpy(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 u16 device_id; 486 const size_t rionet_active_bytes = sizeof(void *) * 487 RIO_MAX_ROUTE_ENTRIES(mport->sys_size); 488 489 nets[mport->id].active = (struct rio_dev **)__get_free_pages(GFP_KERNEL, 490 get_order(rionet_active_bytes)); 491 if (!nets[mport->id].active) { 492 rc = -ENOMEM; 493 goto out; 494 } 495 memset((void *)nets[mport->id].active, 0, rionet_active_bytes); 496 497 /* Set up private area */ 498 rnet = netdev_priv(ndev); 499 rnet->mport = mport; 500 rnet->open = false; 501 502 /* Set the default MAC address */ 503 device_id = rio_local_get_device_id(mport); 504 ndev->dev_addr[0] = 0x00; 505 ndev->dev_addr[1] = 0x01; 506 ndev->dev_addr[2] = 0x00; 507 ndev->dev_addr[3] = 0x01; 508 ndev->dev_addr[4] = device_id >> 8; 509 ndev->dev_addr[5] = device_id & 0xff; 510 511 ndev->netdev_ops = &rionet_netdev_ops; 512 ndev->mtu = RIONET_MAX_MTU; 513 /* MTU range: 68 - 4082 */ 514 ndev->min_mtu = ETH_MIN_MTU; 515 ndev->max_mtu = RIONET_MAX_MTU; 516 ndev->features = NETIF_F_LLTX; 517 SET_NETDEV_DEV(ndev, &mport->dev); 518 ndev->ethtool_ops = &rionet_ethtool_ops; 519 520 spin_lock_init(&rnet->lock); 521 spin_lock_init(&rnet->tx_lock); 522 523 rnet->msg_enable = RIONET_DEFAULT_MSGLEVEL; 524 525 rc = register_netdev(ndev); 526 if (rc != 0) { 527 free_pages((unsigned long)nets[mport->id].active, 528 get_order(rionet_active_bytes)); 529 goto out; 530 } 531 532 printk(KERN_INFO "%s: %s %s Version %s, MAC %pM, %s\n", 533 ndev->name, 534 DRV_NAME, 535 DRV_DESC, 536 DRV_VERSION, 537 ndev->dev_addr, 538 mport->name); 539 540 out: 541 return rc; 542 } 543 544 static int rionet_add_dev(struct device *dev, struct subsys_interface *sif) 545 { 546 int rc = -ENODEV; 547 u32 lsrc_ops, ldst_ops; 548 struct rionet_peer *peer; 549 struct net_device *ndev = NULL; 550 struct rio_dev *rdev = to_rio_dev(dev); 551 unsigned char netid = rdev->net->hport->id; 552 553 if (netid >= RIONET_MAX_NETS) 554 return rc; 555 556 /* 557 * If first time through this net, make sure local device is rionet 558 * capable and setup netdev (this step will be skipped in later probes 559 * on the same net). 560 */ 561 if (!nets[netid].ndev) { 562 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR, 563 &lsrc_ops); 564 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR, 565 &ldst_ops); 566 if (!is_rionet_capable(lsrc_ops, ldst_ops)) { 567 printk(KERN_ERR 568 "%s: local device %s is not network capable\n", 569 DRV_NAME, rdev->net->hport->name); 570 goto out; 571 } 572 573 /* Allocate our net_device structure */ 574 ndev = alloc_etherdev(sizeof(struct rionet_private)); 575 if (ndev == NULL) { 576 rc = -ENOMEM; 577 goto out; 578 } 579 580 rc = rionet_setup_netdev(rdev->net->hport, ndev); 581 if (rc) { 582 printk(KERN_ERR "%s: failed to setup netdev (rc=%d)\n", 583 DRV_NAME, rc); 584 free_netdev(ndev); 585 goto out; 586 } 587 588 INIT_LIST_HEAD(&nets[netid].peers); 589 spin_lock_init(&nets[netid].lock); 590 nets[netid].nact = 0; 591 nets[netid].ndev = ndev; 592 } 593 594 /* 595 * If the remote device has mailbox/doorbell capabilities, 596 * add it to the peer list. 597 */ 598 if (dev_rionet_capable(rdev)) { 599 struct rionet_private *rnet; 600 unsigned long flags; 601 602 rnet = netdev_priv(nets[netid].ndev); 603 604 peer = kzalloc(sizeof(*peer), GFP_KERNEL); 605 if (!peer) { 606 rc = -ENOMEM; 607 goto out; 608 } 609 peer->rdev = rdev; 610 peer->res = rio_request_outb_dbell(peer->rdev, 611 RIONET_DOORBELL_JOIN, 612 RIONET_DOORBELL_LEAVE); 613 if (!peer->res) { 614 pr_err("%s: error requesting doorbells\n", DRV_NAME); 615 kfree(peer); 616 rc = -ENOMEM; 617 goto out; 618 } 619 620 spin_lock_irqsave(&nets[netid].lock, flags); 621 list_add_tail(&peer->node, &nets[netid].peers); 622 spin_unlock_irqrestore(&nets[netid].lock, flags); 623 pr_debug("%s: %s add peer %s\n", 624 DRV_NAME, __func__, rio_name(rdev)); 625 626 /* If netdev is already opened, send join request to new peer */ 627 if (rnet->open) 628 rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN); 629 } 630 631 return 0; 632 out: 633 return rc; 634 } 635 636 static int rionet_shutdown(struct notifier_block *nb, unsigned long code, 637 void *unused) 638 { 639 struct rionet_peer *peer; 640 unsigned long flags; 641 int i; 642 643 pr_debug("%s: %s\n", DRV_NAME, __func__); 644 645 for (i = 0; i < RIONET_MAX_NETS; i++) { 646 if (!nets[i].ndev) 647 continue; 648 649 spin_lock_irqsave(&nets[i].lock, flags); 650 list_for_each_entry(peer, &nets[i].peers, node) { 651 if (nets[i].active[peer->rdev->destid]) { 652 rio_send_doorbell(peer->rdev, 653 RIONET_DOORBELL_LEAVE); 654 nets[i].active[peer->rdev->destid] = NULL; 655 } 656 } 657 spin_unlock_irqrestore(&nets[i].lock, flags); 658 } 659 660 return NOTIFY_DONE; 661 } 662 663 static void rionet_remove_mport(struct device *dev, 664 struct class_interface *class_intf) 665 { 666 struct rio_mport *mport = to_rio_mport(dev); 667 struct net_device *ndev; 668 int id = mport->id; 669 670 pr_debug("%s %s\n", __func__, mport->name); 671 672 WARN(nets[id].nact, "%s called when connected to %d peers\n", 673 __func__, nets[id].nact); 674 WARN(!nets[id].ndev, "%s called for mport without NDEV\n", 675 __func__); 676 677 if (nets[id].ndev) { 678 ndev = nets[id].ndev; 679 netif_stop_queue(ndev); 680 unregister_netdev(ndev); 681 682 free_pages((unsigned long)nets[id].active, 683 get_order(sizeof(void *) * 684 RIO_MAX_ROUTE_ENTRIES(mport->sys_size))); 685 nets[id].active = NULL; 686 free_netdev(ndev); 687 nets[id].ndev = NULL; 688 } 689 } 690 691 #ifdef MODULE 692 static struct rio_device_id rionet_id_table[] = { 693 {RIO_DEVICE(RIO_ANY_ID, RIO_ANY_ID)}, 694 { 0, } /* terminate list */ 695 }; 696 697 MODULE_DEVICE_TABLE(rapidio, rionet_id_table); 698 #endif 699 700 static struct subsys_interface rionet_interface = { 701 .name = "rionet", 702 .subsys = &rio_bus_type, 703 .add_dev = rionet_add_dev, 704 .remove_dev = rionet_remove_dev, 705 }; 706 707 static struct notifier_block rionet_notifier = { 708 .notifier_call = rionet_shutdown, 709 }; 710 711 /* the rio_mport_interface is used to handle local mport devices */ 712 static struct class_interface rio_mport_interface __refdata = { 713 .class = &rio_mport_class, 714 .add_dev = NULL, 715 .remove_dev = rionet_remove_mport, 716 }; 717 718 static int __init rionet_init(void) 719 { 720 int ret; 721 722 ret = register_reboot_notifier(&rionet_notifier); 723 if (ret) { 724 pr_err("%s: failed to register reboot notifier (err=%d)\n", 725 DRV_NAME, ret); 726 return ret; 727 } 728 729 ret = class_interface_register(&rio_mport_interface); 730 if (ret) { 731 pr_err("%s: class_interface_register error: %d\n", 732 DRV_NAME, ret); 733 return ret; 734 } 735 736 return subsys_interface_register(&rionet_interface); 737 } 738 739 static void __exit rionet_exit(void) 740 { 741 unregister_reboot_notifier(&rionet_notifier); 742 subsys_interface_unregister(&rionet_interface); 743 class_interface_unregister(&rio_mport_interface); 744 } 745 746 late_initcall(rionet_init); 747 module_exit(rionet_exit); 748