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