]> Git Repo - linux.git/blob - drivers/net/ethernet/vertexcom/mse102x.c
Linux 6.14-rc3
[linux.git] / drivers / net / ethernet / vertexcom / mse102x.c
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 < ETH_ZLEN)
382                 pad = ETH_ZLEN - 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_once(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                 dev_warn(ndev->dev.parent, "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 static int mse102x_suspend(struct device *dev)
629 {
630         struct mse102x_net *mse = dev_get_drvdata(dev);
631         struct net_device *ndev = mse->ndev;
632
633         if (netif_running(ndev)) {
634                 netif_device_detach(ndev);
635                 mse102x_net_stop(ndev);
636         }
637
638         return 0;
639 }
640
641 static int mse102x_resume(struct device *dev)
642 {
643         struct mse102x_net *mse = dev_get_drvdata(dev);
644         struct net_device *ndev = mse->ndev;
645
646         if (netif_running(ndev)) {
647                 mse102x_net_open(ndev);
648                 netif_device_attach(ndev);
649         }
650
651         return 0;
652 }
653
654 static DEFINE_SIMPLE_DEV_PM_OPS(mse102x_pm_ops, mse102x_suspend, mse102x_resume);
655
656 static int mse102x_probe_spi(struct spi_device *spi)
657 {
658         struct device *dev = &spi->dev;
659         struct mse102x_net_spi *mses;
660         struct net_device *ndev;
661         struct mse102x_net *mse;
662         int ret;
663
664         spi->bits_per_word = 8;
665         spi->mode |= SPI_MODE_3;
666         /* enforce minimum speed to ensure device functionality */
667         spi->controller->min_speed_hz = MIN_FREQ_HZ;
668
669         if (!spi->max_speed_hz)
670                 spi->max_speed_hz = MAX_FREQ_HZ;
671
672         if (spi->max_speed_hz < MIN_FREQ_HZ ||
673             spi->max_speed_hz > MAX_FREQ_HZ) {
674                 dev_err(&spi->dev, "SPI max frequency out of range (min: %u, max: %u)\n",
675                         MIN_FREQ_HZ, MAX_FREQ_HZ);
676                 return -EINVAL;
677         }
678
679         ret = spi_setup(spi);
680         if (ret < 0) {
681                 dev_err(&spi->dev, "Unable to setup SPI device: %d\n", ret);
682                 return ret;
683         }
684
685         ndev = devm_alloc_etherdev(dev, sizeof(struct mse102x_net_spi));
686         if (!ndev)
687                 return -ENOMEM;
688
689         ndev->needed_tailroom += ALIGN(DET_DFT_LEN, 4);
690         ndev->needed_headroom += ALIGN(DET_SOF_LEN, 4);
691         ndev->priv_flags &= ~IFF_TX_SKB_SHARING;
692         ndev->tx_queue_len = 100;
693
694         mse = netdev_priv(ndev);
695         mses = to_mse102x_spi(mse);
696
697         mses->spidev = spi;
698         mutex_init(&mses->lock);
699         INIT_WORK(&mses->tx_work, mse102x_tx_work);
700
701         /* initialise pre-made spi transfer messages */
702         spi_message_init(&mses->spi_msg);
703         spi_message_add_tail(&mses->spi_xfer, &mses->spi_msg);
704
705         ndev->irq = spi->irq;
706         mse->ndev = ndev;
707
708         /* set the default message enable */
709         mse->msg_enable = netif_msg_init(-1, MSG_DEFAULT);
710
711         skb_queue_head_init(&mse->txq);
712
713         SET_NETDEV_DEV(ndev, dev);
714
715         dev_set_drvdata(dev, mse);
716
717         netif_carrier_off(mse->ndev);
718         ndev->netdev_ops = &mse102x_netdev_ops;
719         ndev->ethtool_ops = &mse102x_ethtool_ops;
720
721         mse102x_init_mac(mse, dev->of_node);
722
723         ret = register_netdev(ndev);
724         if (ret) {
725                 dev_err(dev, "failed to register network device: %d\n", ret);
726                 return ret;
727         }
728
729         mse102x_init_device_debugfs(mses);
730
731         return 0;
732 }
733
734 static void mse102x_remove_spi(struct spi_device *spi)
735 {
736         struct mse102x_net *mse = dev_get_drvdata(&spi->dev);
737         struct mse102x_net_spi *mses = to_mse102x_spi(mse);
738
739         mse102x_remove_device_debugfs(mses);
740         unregister_netdev(mse->ndev);
741 }
742
743 static const struct of_device_id mse102x_match_table[] = {
744         { .compatible = "vertexcom,mse1021" },
745         { .compatible = "vertexcom,mse1022" },
746         { }
747 };
748 MODULE_DEVICE_TABLE(of, mse102x_match_table);
749
750 static const struct spi_device_id mse102x_ids[] = {
751         { "mse1021" },
752         { "mse1022" },
753         { }
754 };
755 MODULE_DEVICE_TABLE(spi, mse102x_ids);
756
757 static struct spi_driver mse102x_driver = {
758         .driver = {
759                 .name = DRV_NAME,
760                 .of_match_table = mse102x_match_table,
761                 .pm = pm_sleep_ptr(&mse102x_pm_ops),
762         },
763         .probe = mse102x_probe_spi,
764         .remove = mse102x_remove_spi,
765         .id_table = mse102x_ids,
766 };
767 module_spi_driver(mse102x_driver);
768
769 MODULE_DESCRIPTION("MSE102x Network driver");
770 MODULE_AUTHOR("Stefan Wahren <[email protected]>");
771 MODULE_LICENSE("GPL");
772 MODULE_ALIAS("spi:" DRV_NAME);
This page took 0.076121 seconds and 4 git commands to generate.