1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (C) 2021 in-tech smart charging GmbH 3 * 4 * driver is based on micrel/ks8851_spi.c 5 */ 6 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/interrupt.h> 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/netdevice.h> 13 #include <linux/etherdevice.h> 14 #include <linux/ethtool.h> 15 #include <linux/cache.h> 16 #include <linux/debugfs.h> 17 #include <linux/seq_file.h> 18 19 #include <linux/spi/spi.h> 20 #include <linux/of_net.h> 21 22 #define MSG_DEFAULT (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK | \ 23 NETIF_MSG_TIMER) 24 25 #define DRV_NAME "mse102x" 26 27 #define DET_CMD 0x0001 28 #define DET_SOF 0x0002 29 #define DET_DFT 0x55AA 30 31 #define CMD_SHIFT 12 32 #define CMD_RTS (0x1 << CMD_SHIFT) 33 #define CMD_CTR (0x2 << CMD_SHIFT) 34 35 #define CMD_MASK GENMASK(15, CMD_SHIFT) 36 #define LEN_MASK GENMASK(CMD_SHIFT - 1, 0) 37 38 #define DET_CMD_LEN 4 39 #define DET_SOF_LEN 2 40 #define DET_DFT_LEN 2 41 42 #define MIN_FREQ_HZ 6000000 43 #define MAX_FREQ_HZ 7142857 44 45 struct mse102x_stats { 46 u64 xfer_err; 47 u64 invalid_cmd; 48 u64 invalid_ctr; 49 u64 invalid_dft; 50 u64 invalid_len; 51 u64 invalid_rts; 52 u64 invalid_sof; 53 u64 tx_timeout; 54 }; 55 56 static const char mse102x_gstrings_stats[][ETH_GSTRING_LEN] = { 57 "SPI transfer errors", 58 "Invalid command", 59 "Invalid CTR", 60 "Invalid DFT", 61 "Invalid frame length", 62 "Invalid RTS", 63 "Invalid SOF", 64 "TX timeout", 65 }; 66 67 struct mse102x_net { 68 struct net_device *ndev; 69 70 u8 rxd[8]; 71 u8 txd[8]; 72 73 u32 msg_enable ____cacheline_aligned; 74 75 struct sk_buff_head txq; 76 struct mse102x_stats stats; 77 }; 78 79 struct mse102x_net_spi { 80 struct mse102x_net mse102x; 81 struct mutex lock; /* Protect SPI frame transfer */ 82 struct work_struct tx_work; 83 struct spi_device *spidev; 84 struct spi_message spi_msg; 85 struct spi_transfer spi_xfer; 86 87 #ifdef CONFIG_DEBUG_FS 88 struct dentry *device_root; 89 #endif 90 }; 91 92 #define to_mse102x_spi(mse) container_of((mse), struct mse102x_net_spi, mse102x) 93 94 #ifdef CONFIG_DEBUG_FS 95 96 static int mse102x_info_show(struct seq_file *s, void *what) 97 { 98 struct mse102x_net_spi *mses = s->private; 99 100 seq_printf(s, "TX ring size : %u\n", 101 skb_queue_len(&mses->mse102x.txq)); 102 103 seq_printf(s, "IRQ : %d\n", 104 mses->spidev->irq); 105 106 seq_printf(s, "SPI effective speed : %lu\n", 107 (unsigned long)mses->spi_xfer.effective_speed_hz); 108 seq_printf(s, "SPI mode : %x\n", 109 mses->spidev->mode); 110 111 return 0; 112 } 113 DEFINE_SHOW_ATTRIBUTE(mse102x_info); 114 115 static void mse102x_init_device_debugfs(struct mse102x_net_spi *mses) 116 { 117 mses->device_root = debugfs_create_dir(dev_name(&mses->mse102x.ndev->dev), 118 NULL); 119 120 debugfs_create_file("info", S_IFREG | 0444, mses->device_root, mses, 121 &mse102x_info_fops); 122 } 123 124 static void mse102x_remove_device_debugfs(struct mse102x_net_spi *mses) 125 { 126 debugfs_remove_recursive(mses->device_root); 127 } 128 129 #else /* CONFIG_DEBUG_FS */ 130 131 static void mse102x_init_device_debugfs(struct mse102x_net_spi *mses) 132 { 133 } 134 135 static void mse102x_remove_device_debugfs(struct mse102x_net_spi *mses) 136 { 137 } 138 139 #endif 140 141 /* SPI register read/write calls. 142 * 143 * All these calls issue SPI transactions to access the chip's registers. They 144 * all require that the necessary lock is held to prevent accesses when the 145 * chip is busy transferring packet data. 146 */ 147 148 static void mse102x_tx_cmd_spi(struct mse102x_net *mse, u16 cmd) 149 { 150 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 151 struct spi_transfer *xfer = &mses->spi_xfer; 152 struct spi_message *msg = &mses->spi_msg; 153 __be16 txb[2]; 154 int ret; 155 156 txb[0] = cpu_to_be16(DET_CMD); 157 txb[1] = cpu_to_be16(cmd); 158 159 xfer->tx_buf = txb; 160 xfer->rx_buf = NULL; 161 xfer->len = DET_CMD_LEN; 162 163 ret = spi_sync(mses->spidev, msg); 164 if (ret < 0) { 165 netdev_err(mse->ndev, "%s: spi_sync() failed: %d\n", 166 __func__, ret); 167 mse->stats.xfer_err++; 168 } 169 } 170 171 static int mse102x_rx_cmd_spi(struct mse102x_net *mse, u8 *rxb) 172 { 173 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 174 struct spi_transfer *xfer = &mses->spi_xfer; 175 struct spi_message *msg = &mses->spi_msg; 176 __be16 *txb = (__be16 *)mse->txd; 177 __be16 *cmd = (__be16 *)mse->rxd; 178 u8 *trx = mse->rxd; 179 int ret; 180 181 txb[0] = 0; 182 txb[1] = 0; 183 184 xfer->tx_buf = txb; 185 xfer->rx_buf = trx; 186 xfer->len = DET_CMD_LEN; 187 188 ret = spi_sync(mses->spidev, msg); 189 if (ret < 0) { 190 netdev_err(mse->ndev, "%s: spi_sync() failed: %d\n", 191 __func__, ret); 192 mse->stats.xfer_err++; 193 } else if (*cmd != cpu_to_be16(DET_CMD)) { 194 net_dbg_ratelimited("%s: Unexpected response (0x%04x)\n", 195 __func__, *cmd); 196 mse->stats.invalid_cmd++; 197 ret = -EIO; 198 } else { 199 memcpy(rxb, trx + 2, 2); 200 } 201 202 return ret; 203 } 204 205 static inline void mse102x_push_header(struct sk_buff *skb) 206 { 207 __be16 *header = skb_push(skb, DET_SOF_LEN); 208 209 *header = cpu_to_be16(DET_SOF); 210 } 211 212 static inline void mse102x_put_footer(struct sk_buff *skb) 213 { 214 __be16 *footer = skb_put(skb, DET_DFT_LEN); 215 216 *footer = cpu_to_be16(DET_DFT); 217 } 218 219 static int mse102x_tx_frame_spi(struct mse102x_net *mse, struct sk_buff *txp, 220 unsigned int pad) 221 { 222 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 223 struct spi_transfer *xfer = &mses->spi_xfer; 224 struct spi_message *msg = &mses->spi_msg; 225 struct sk_buff *tskb = NULL; 226 int ret; 227 228 netif_dbg(mse, tx_queued, mse->ndev, "%s: skb %p, %d@%p\n", 229 __func__, txp, txp->len, txp->data); 230 231 if ((skb_headroom(txp) < DET_SOF_LEN) || 232 (skb_tailroom(txp) < DET_DFT_LEN + pad)) { 233 tskb = skb_copy_expand(txp, DET_SOF_LEN, DET_DFT_LEN + pad, 234 GFP_KERNEL); 235 if (!tskb) 236 return -ENOMEM; 237 238 txp = tskb; 239 } 240 241 mse102x_push_header(txp); 242 243 if (pad) 244 skb_put_zero(txp, pad); 245 246 mse102x_put_footer(txp); 247 248 xfer->tx_buf = txp->data; 249 xfer->rx_buf = NULL; 250 xfer->len = txp->len; 251 252 ret = spi_sync(mses->spidev, msg); 253 if (ret < 0) { 254 netdev_err(mse->ndev, "%s: spi_sync() failed: %d\n", 255 __func__, ret); 256 mse->stats.xfer_err++; 257 } 258 259 dev_kfree_skb(tskb); 260 261 return ret; 262 } 263 264 static int mse102x_rx_frame_spi(struct mse102x_net *mse, u8 *buff, 265 unsigned int frame_len) 266 { 267 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 268 struct spi_transfer *xfer = &mses->spi_xfer; 269 struct spi_message *msg = &mses->spi_msg; 270 __be16 *sof = (__be16 *)buff; 271 __be16 *dft = (__be16 *)(buff + DET_SOF_LEN + frame_len); 272 int ret; 273 274 xfer->rx_buf = buff; 275 xfer->tx_buf = NULL; 276 xfer->len = DET_SOF_LEN + frame_len + DET_DFT_LEN; 277 278 ret = spi_sync(mses->spidev, msg); 279 if (ret < 0) { 280 netdev_err(mse->ndev, "%s: spi_sync() failed: %d\n", 281 __func__, ret); 282 mse->stats.xfer_err++; 283 } else if (*sof != cpu_to_be16(DET_SOF)) { 284 netdev_dbg(mse->ndev, "%s: SPI start of frame is invalid (0x%04x)\n", 285 __func__, *sof); 286 mse->stats.invalid_sof++; 287 ret = -EIO; 288 } else if (*dft != cpu_to_be16(DET_DFT)) { 289 netdev_dbg(mse->ndev, "%s: SPI frame tail is invalid (0x%04x)\n", 290 __func__, *dft); 291 mse->stats.invalid_dft++; 292 ret = -EIO; 293 } 294 295 return ret; 296 } 297 298 static void mse102x_dump_packet(const char *msg, int len, const char *data) 299 { 300 printk(KERN_DEBUG ": %s - packet len:%d\n", msg, len); 301 print_hex_dump(KERN_DEBUG, "pk data: ", DUMP_PREFIX_OFFSET, 16, 1, 302 data, len, true); 303 } 304 305 static void mse102x_rx_pkt_spi(struct mse102x_net *mse) 306 { 307 struct sk_buff *skb; 308 unsigned int rxalign; 309 unsigned int rxlen; 310 __be16 rx = 0; 311 u16 cmd_resp; 312 u8 *rxpkt; 313 int ret; 314 315 mse102x_tx_cmd_spi(mse, CMD_CTR); 316 ret = mse102x_rx_cmd_spi(mse, (u8 *)&rx); 317 cmd_resp = be16_to_cpu(rx); 318 319 if (ret || ((cmd_resp & CMD_MASK) != CMD_RTS)) { 320 usleep_range(50, 100); 321 322 mse102x_tx_cmd_spi(mse, CMD_CTR); 323 ret = mse102x_rx_cmd_spi(mse, (u8 *)&rx); 324 if (ret) 325 return; 326 327 cmd_resp = be16_to_cpu(rx); 328 if ((cmd_resp & CMD_MASK) != CMD_RTS) { 329 net_dbg_ratelimited("%s: Unexpected response (0x%04x)\n", 330 __func__, cmd_resp); 331 mse->stats.invalid_rts++; 332 return; 333 } 334 335 net_dbg_ratelimited("%s: Unexpected response to first CMD\n", 336 __func__); 337 } 338 339 rxlen = cmd_resp & LEN_MASK; 340 if (!rxlen) { 341 net_dbg_ratelimited("%s: No frame length defined\n", __func__); 342 mse->stats.invalid_len++; 343 return; 344 } 345 346 rxalign = ALIGN(rxlen + DET_SOF_LEN + DET_DFT_LEN, 4); 347 skb = netdev_alloc_skb_ip_align(mse->ndev, rxalign); 348 if (!skb) 349 return; 350 351 /* 2 bytes Start of frame (before ethernet header) 352 * 2 bytes Data frame tail (after ethernet frame) 353 * They are copied, but ignored. 354 */ 355 rxpkt = skb_put(skb, rxlen) - DET_SOF_LEN; 356 if (mse102x_rx_frame_spi(mse, rxpkt, rxlen)) { 357 mse->ndev->stats.rx_errors++; 358 dev_kfree_skb(skb); 359 return; 360 } 361 362 if (netif_msg_pktdata(mse)) 363 mse102x_dump_packet(__func__, skb->len, skb->data); 364 365 skb->protocol = eth_type_trans(skb, mse->ndev); 366 netif_rx(skb); 367 368 mse->ndev->stats.rx_packets++; 369 mse->ndev->stats.rx_bytes += rxlen; 370 } 371 372 static int mse102x_tx_pkt_spi(struct mse102x_net *mse, struct sk_buff *txb, 373 unsigned long work_timeout) 374 { 375 unsigned int pad = 0; 376 __be16 rx = 0; 377 u16 cmd_resp; 378 int ret; 379 bool first = true; 380 381 if (txb->len < 60) 382 pad = 60 - txb->len; 383 384 while (1) { 385 mse102x_tx_cmd_spi(mse, CMD_RTS | (txb->len + pad)); 386 ret = mse102x_rx_cmd_spi(mse, (u8 *)&rx); 387 cmd_resp = be16_to_cpu(rx); 388 389 if (!ret) { 390 /* ready to send frame ? */ 391 if (cmd_resp == CMD_CTR) 392 break; 393 394 net_dbg_ratelimited("%s: Unexpected response (0x%04x)\n", 395 __func__, cmd_resp); 396 mse->stats.invalid_ctr++; 397 } 398 399 /* It's not predictable how long / many retries it takes to 400 * send at least one packet, so TX timeouts are possible. 401 * That's the reason why the netdev watchdog is not used here. 402 */ 403 if (time_after(jiffies, work_timeout)) 404 return -ETIMEDOUT; 405 406 if (first) { 407 /* throttle at first issue */ 408 netif_stop_queue(mse->ndev); 409 /* fast retry */ 410 usleep_range(50, 100); 411 first = false; 412 } else { 413 msleep(20); 414 } 415 } 416 417 ret = mse102x_tx_frame_spi(mse, txb, pad); 418 if (ret) 419 net_dbg_ratelimited("%s: Failed to send (%d), drop frame\n", 420 __func__, ret); 421 422 return ret; 423 } 424 425 #define TX_QUEUE_MAX 10 426 427 static void mse102x_tx_work(struct work_struct *work) 428 { 429 /* Make sure timeout is sufficient to transfer TX_QUEUE_MAX frames */ 430 unsigned long work_timeout = jiffies + msecs_to_jiffies(1000); 431 struct mse102x_net_spi *mses; 432 struct mse102x_net *mse; 433 struct sk_buff *txb; 434 int ret = 0; 435 436 mses = container_of(work, struct mse102x_net_spi, tx_work); 437 mse = &mses->mse102x; 438 439 while ((txb = skb_dequeue(&mse->txq))) { 440 unsigned int len = max_t(unsigned int, txb->len, ETH_ZLEN); 441 442 mutex_lock(&mses->lock); 443 ret = mse102x_tx_pkt_spi(mse, txb, work_timeout); 444 mutex_unlock(&mses->lock); 445 if (ret) { 446 mse->ndev->stats.tx_dropped++; 447 } else { 448 mse->ndev->stats.tx_bytes += len; 449 mse->ndev->stats.tx_packets++; 450 } 451 452 dev_kfree_skb(txb); 453 } 454 455 if (ret == -ETIMEDOUT) { 456 if (netif_msg_timer(mse)) 457 netdev_err(mse->ndev, "tx work timeout\n"); 458 459 mse->stats.tx_timeout++; 460 } 461 462 netif_wake_queue(mse->ndev); 463 } 464 465 static netdev_tx_t mse102x_start_xmit_spi(struct sk_buff *skb, 466 struct net_device *ndev) 467 { 468 struct mse102x_net *mse = netdev_priv(ndev); 469 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 470 471 netif_dbg(mse, tx_queued, ndev, 472 "%s: skb %p, %d@%p\n", __func__, skb, skb->len, skb->data); 473 474 skb_queue_tail(&mse->txq, skb); 475 476 if (skb_queue_len(&mse->txq) >= TX_QUEUE_MAX) 477 netif_stop_queue(ndev); 478 479 schedule_work(&mses->tx_work); 480 481 return NETDEV_TX_OK; 482 } 483 484 static void mse102x_init_mac(struct mse102x_net *mse, struct device_node *np) 485 { 486 struct net_device *ndev = mse->ndev; 487 int ret = of_get_ethdev_address(np, ndev); 488 489 if (ret) { 490 eth_hw_addr_random(ndev); 491 netdev_err(ndev, "Using random MAC address: %pM\n", 492 ndev->dev_addr); 493 } 494 } 495 496 /* Assumption: this is called for every incoming packet */ 497 static irqreturn_t mse102x_irq(int irq, void *_mse) 498 { 499 struct mse102x_net *mse = _mse; 500 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 501 502 mutex_lock(&mses->lock); 503 mse102x_rx_pkt_spi(mse); 504 mutex_unlock(&mses->lock); 505 506 return IRQ_HANDLED; 507 } 508 509 static int mse102x_net_open(struct net_device *ndev) 510 { 511 struct mse102x_net *mse = netdev_priv(ndev); 512 int ret; 513 514 ret = request_threaded_irq(ndev->irq, NULL, mse102x_irq, IRQF_ONESHOT, 515 ndev->name, mse); 516 if (ret < 0) { 517 netdev_err(ndev, "Failed to get irq: %d\n", ret); 518 return ret; 519 } 520 521 netif_dbg(mse, ifup, ndev, "opening\n"); 522 523 netif_start_queue(ndev); 524 525 netif_carrier_on(ndev); 526 527 netif_dbg(mse, ifup, ndev, "network device up\n"); 528 529 return 0; 530 } 531 532 static int mse102x_net_stop(struct net_device *ndev) 533 { 534 struct mse102x_net *mse = netdev_priv(ndev); 535 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 536 537 netif_info(mse, ifdown, ndev, "shutting down\n"); 538 539 netif_carrier_off(mse->ndev); 540 541 /* stop any outstanding work */ 542 flush_work(&mses->tx_work); 543 544 netif_stop_queue(ndev); 545 546 skb_queue_purge(&mse->txq); 547 548 free_irq(ndev->irq, mse); 549 550 return 0; 551 } 552 553 static const struct net_device_ops mse102x_netdev_ops = { 554 .ndo_open = mse102x_net_open, 555 .ndo_stop = mse102x_net_stop, 556 .ndo_start_xmit = mse102x_start_xmit_spi, 557 .ndo_set_mac_address = eth_mac_addr, 558 .ndo_validate_addr = eth_validate_addr, 559 }; 560 561 /* ethtool support */ 562 563 static void mse102x_get_drvinfo(struct net_device *ndev, 564 struct ethtool_drvinfo *di) 565 { 566 strscpy(di->driver, DRV_NAME, sizeof(di->driver)); 567 strscpy(di->bus_info, dev_name(ndev->dev.parent), sizeof(di->bus_info)); 568 } 569 570 static u32 mse102x_get_msglevel(struct net_device *ndev) 571 { 572 struct mse102x_net *mse = netdev_priv(ndev); 573 574 return mse->msg_enable; 575 } 576 577 static void mse102x_set_msglevel(struct net_device *ndev, u32 to) 578 { 579 struct mse102x_net *mse = netdev_priv(ndev); 580 581 mse->msg_enable = to; 582 } 583 584 static void mse102x_get_ethtool_stats(struct net_device *ndev, 585 struct ethtool_stats *estats, u64 *data) 586 { 587 struct mse102x_net *mse = netdev_priv(ndev); 588 struct mse102x_stats *st = &mse->stats; 589 590 memcpy(data, st, ARRAY_SIZE(mse102x_gstrings_stats) * sizeof(u64)); 591 } 592 593 static void mse102x_get_strings(struct net_device *ndev, u32 stringset, u8 *buf) 594 { 595 switch (stringset) { 596 case ETH_SS_STATS: 597 memcpy(buf, &mse102x_gstrings_stats, 598 sizeof(mse102x_gstrings_stats)); 599 break; 600 default: 601 WARN_ON(1); 602 break; 603 } 604 } 605 606 static int mse102x_get_sset_count(struct net_device *ndev, int sset) 607 { 608 switch (sset) { 609 case ETH_SS_STATS: 610 return ARRAY_SIZE(mse102x_gstrings_stats); 611 default: 612 return -EINVAL; 613 } 614 } 615 616 static const struct ethtool_ops mse102x_ethtool_ops = { 617 .get_drvinfo = mse102x_get_drvinfo, 618 .get_link = ethtool_op_get_link, 619 .get_msglevel = mse102x_get_msglevel, 620 .set_msglevel = mse102x_set_msglevel, 621 .get_ethtool_stats = mse102x_get_ethtool_stats, 622 .get_strings = mse102x_get_strings, 623 .get_sset_count = mse102x_get_sset_count, 624 }; 625 626 /* driver bus management functions */ 627 628 #ifdef CONFIG_PM_SLEEP 629 630 static int mse102x_suspend(struct device *dev) 631 { 632 struct mse102x_net *mse = dev_get_drvdata(dev); 633 struct net_device *ndev = mse->ndev; 634 635 if (netif_running(ndev)) { 636 netif_device_detach(ndev); 637 mse102x_net_stop(ndev); 638 } 639 640 return 0; 641 } 642 643 static int mse102x_resume(struct device *dev) 644 { 645 struct mse102x_net *mse = dev_get_drvdata(dev); 646 struct net_device *ndev = mse->ndev; 647 648 if (netif_running(ndev)) { 649 mse102x_net_open(ndev); 650 netif_device_attach(ndev); 651 } 652 653 return 0; 654 } 655 #endif 656 657 static SIMPLE_DEV_PM_OPS(mse102x_pm_ops, mse102x_suspend, mse102x_resume); 658 659 static int mse102x_probe_spi(struct spi_device *spi) 660 { 661 struct device *dev = &spi->dev; 662 struct mse102x_net_spi *mses; 663 struct net_device *ndev; 664 struct mse102x_net *mse; 665 int ret; 666 667 spi->bits_per_word = 8; 668 spi->mode |= SPI_MODE_3; 669 /* enforce minimum speed to ensure device functionality */ 670 spi->master->min_speed_hz = MIN_FREQ_HZ; 671 672 if (!spi->max_speed_hz) 673 spi->max_speed_hz = MAX_FREQ_HZ; 674 675 if (spi->max_speed_hz < MIN_FREQ_HZ || 676 spi->max_speed_hz > MAX_FREQ_HZ) { 677 dev_err(&spi->dev, "SPI max frequency out of range (min: %u, max: %u)\n", 678 MIN_FREQ_HZ, MAX_FREQ_HZ); 679 return -EINVAL; 680 } 681 682 ret = spi_setup(spi); 683 if (ret < 0) { 684 dev_err(&spi->dev, "Unable to setup SPI device: %d\n", ret); 685 return ret; 686 } 687 688 ndev = devm_alloc_etherdev(dev, sizeof(struct mse102x_net_spi)); 689 if (!ndev) 690 return -ENOMEM; 691 692 ndev->needed_tailroom += ALIGN(DET_DFT_LEN, 4); 693 ndev->needed_headroom += ALIGN(DET_SOF_LEN, 4); 694 ndev->priv_flags &= ~IFF_TX_SKB_SHARING; 695 ndev->tx_queue_len = 100; 696 697 mse = netdev_priv(ndev); 698 mses = to_mse102x_spi(mse); 699 700 mses->spidev = spi; 701 mutex_init(&mses->lock); 702 INIT_WORK(&mses->tx_work, mse102x_tx_work); 703 704 /* initialise pre-made spi transfer messages */ 705 spi_message_init(&mses->spi_msg); 706 spi_message_add_tail(&mses->spi_xfer, &mses->spi_msg); 707 708 ndev->irq = spi->irq; 709 mse->ndev = ndev; 710 711 /* set the default message enable */ 712 mse->msg_enable = netif_msg_init(-1, MSG_DEFAULT); 713 714 skb_queue_head_init(&mse->txq); 715 716 SET_NETDEV_DEV(ndev, dev); 717 718 dev_set_drvdata(dev, mse); 719 720 netif_carrier_off(mse->ndev); 721 ndev->netdev_ops = &mse102x_netdev_ops; 722 ndev->ethtool_ops = &mse102x_ethtool_ops; 723 724 mse102x_init_mac(mse, dev->of_node); 725 726 ret = register_netdev(ndev); 727 if (ret) { 728 dev_err(dev, "failed to register network device: %d\n", ret); 729 return ret; 730 } 731 732 mse102x_init_device_debugfs(mses); 733 734 return 0; 735 } 736 737 static void mse102x_remove_spi(struct spi_device *spi) 738 { 739 struct mse102x_net *mse = dev_get_drvdata(&spi->dev); 740 struct mse102x_net_spi *mses = to_mse102x_spi(mse); 741 742 if (netif_msg_drv(mse)) 743 dev_info(&spi->dev, "remove\n"); 744 745 mse102x_remove_device_debugfs(mses); 746 unregister_netdev(mse->ndev); 747 } 748 749 static const struct of_device_id mse102x_match_table[] = { 750 { .compatible = "vertexcom,mse1021" }, 751 { .compatible = "vertexcom,mse1022" }, 752 { } 753 }; 754 MODULE_DEVICE_TABLE(of, mse102x_match_table); 755 756 static const struct spi_device_id mse102x_ids[] = { 757 { "mse1021" }, 758 { "mse1022" }, 759 { } 760 }; 761 MODULE_DEVICE_TABLE(spi, mse102x_ids); 762 763 static struct spi_driver mse102x_driver = { 764 .driver = { 765 .name = DRV_NAME, 766 .of_match_table = mse102x_match_table, 767 .pm = &mse102x_pm_ops, 768 }, 769 .probe = mse102x_probe_spi, 770 .remove = mse102x_remove_spi, 771 .id_table = mse102x_ids, 772 }; 773 module_spi_driver(mse102x_driver); 774 775 MODULE_DESCRIPTION("MSE102x Network driver"); 776 MODULE_AUTHOR("Stefan Wahren <stefan.wahren@chargebyte.com>"); 777 MODULE_LICENSE("GPL"); 778 MODULE_ALIAS("spi:" DRV_NAME); 779