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