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
48struct 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
58static 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
68struct 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
80struct 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
99static int mse102x_info_show(struct seq_file *s, void *what)
100{
101 struct mse102x_net_spi *mses = s->private;
102
103 seq_printf(m: s, fmt: "TX ring size : %u\n",
104 skb_queue_len(list_: &mses->mse102x.txq));
105
106 seq_printf(m: s, fmt: "IRQ : %d\n",
107 mses->spidev->irq);
108
109 seq_printf(m: s, fmt: "SPI effective speed : %lu\n",
110 (unsigned long)mses->spi_xfer.effective_speed_hz);
111 seq_printf(m: s, fmt: "SPI mode : %x\n",
112 mses->spidev->mode);
113 seq_printf(m: s, fmt: "Received valid CMD once : %s\n",
114 str_yes_no(v: mses->valid_cmd_received));
115
116 return 0;
117}
118DEFINE_SHOW_ATTRIBUTE(mse102x_info);
119
120static void mse102x_init_device_debugfs(struct mse102x_net_spi *mses)
121{
122 mses->device_root = debugfs_create_dir(name: dev_name(dev: &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
129static void mse102x_remove_device_debugfs(struct mse102x_net_spi *mses)
130{
131 debugfs_remove_recursive(dentry: mses->device_root);
132}
133
134#else /* CONFIG_DEBUG_FS */
135
136static void mse102x_init_device_debugfs(struct mse102x_net_spi *mses)
137{
138}
139
140static 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
153static 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(spi: mses->spidev, message: msg);
169 if (ret < 0) {
170 netdev_err(dev: mse->ndev, format: "%s: spi_sync() failed: %d\n",
171 __func__, ret);
172 mse->stats.xfer_err++;
173 }
174}
175
176static 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(spi: mses->spidev, message: msg);
194 if (ret < 0) {
195 netdev_err(dev: mse->ndev, format: "%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
210static 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
217static 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
224static 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(skb: txp) < DET_SOF_LEN) ||
237 (skb_tailroom(skb: txp) < DET_DFT_LEN + pad)) {
238 tskb = skb_copy_expand(skb: 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(skb: txp);
247
248 if (pad)
249 skb_put_zero(skb: txp, len: pad);
250
251 mse102x_put_footer(skb: txp);
252
253 xfer->tx_buf = txp->data;
254 xfer->rx_buf = NULL;
255 xfer->len = txp->len;
256
257 ret = spi_sync(spi: mses->spidev, message: msg);
258 if (ret < 0) {
259 netdev_err(dev: mse->ndev, format: "%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
269static 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(spi: mses->spidev, message: msg);
284 if (ret < 0) {
285 netdev_err(dev: mse->ndev, format: "%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
306static 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, prefix_str: "pk data: ", prefix_type: DUMP_PREFIX_OFFSET, rowsize: 16, groupsize: 1,
310 buf: data, len, ascii: true);
311}
312
313static 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, rxb: (u8 *)&rx)) {
325 usleep_range(min: 50, max: 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 */
349drop:
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(dev: mse->ndev, length: 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, len: rxlen) - DET_SOF_LEN;
363 if (mse102x_rx_frame_spi(mse, buff: rxpkt, frame_len: 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(msg: __func__, len: skb->len, data: skb->data);
371
372 skb->protocol = eth_type_trans(skb, dev: 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
381static 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, rxb: (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(dev: mse->ndev);
418 /* fast retry */
419 usleep_range(min: 50, max: 100);
420 first = false;
421 } else {
422 msleep(msecs: 20);
423 }
424 }
425
426 ret = mse102x_tx_frame_spi(mse, txp: 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
436static 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(m: 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(list: &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(lock: &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(dev: mse->ndev);
472}
473
474static netdev_tx_t mse102x_start_xmit_spi(struct sk_buff *skb,
475 struct net_device *ndev)
476{
477 struct mse102x_net *mse = netdev_priv(dev: 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(list: &mse->txq, newsk: skb);
484
485 if (skb_queue_len(list_: &mse->txq) >= TX_QUEUE_MAX)
486 netif_stop_queue(dev: ndev);
487
488 schedule_work(work: &mses->tx_work);
489
490 return NETDEV_TX_OK;
491}
492
493static 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, dev: ndev);
497
498 if (ret) {
499 eth_hw_addr_random(dev: 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 */
506static 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(lock: &mses->lock);
515
516 return ret;
517}
518
519static int mse102x_net_open(struct net_device *ndev)
520{
521 struct irq_data *irq_data = irq_get_irq_data(irq: ndev->irq);
522 struct mse102x_net *mse = netdev_priv(dev: ndev);
523 struct mse102x_net_spi *mses = to_mse102x_spi(mse);
524 int ret;
525
526 if (!irq_data) {
527 netdev_err(dev: ndev, format: "Invalid IRQ: %d\n", ndev->irq);
528 return -EINVAL;
529 }
530
531 switch (irqd_get_trigger_type(d: 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(irq: ndev->irq, NULL, thread_fn: mse102x_irq, IRQF_ONESHOT,
541 name: ndev->name, dev: mse);
542 if (ret < 0) {
543 netdev_err(dev: ndev, format: "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(dev: ndev);
550
551 netif_carrier_on(dev: 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(lock: &mses->lock);
560
561 netif_dbg(mse, ifup, ndev, "network device up\n");
562
563 return 0;
564}
565
566static int mse102x_net_stop(struct net_device *ndev)
567{
568 struct mse102x_net *mse = netdev_priv(dev: 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(dev: mse->ndev);
574
575 /* stop any outstanding work */
576 flush_work(work: &mses->tx_work);
577
578 netif_stop_queue(dev: ndev);
579
580 skb_queue_purge(list: &mse->txq);
581
582 free_irq(ndev->irq, mse);
583
584 return 0;
585}
586
587static 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
597static 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
604static u32 mse102x_get_msglevel(struct net_device *ndev)
605{
606 struct mse102x_net *mse = netdev_priv(dev: ndev);
607
608 return mse->msg_enable;
609}
610
611static void mse102x_set_msglevel(struct net_device *ndev, u32 to)
612{
613 struct mse102x_net *mse = netdev_priv(dev: ndev);
614
615 mse->msg_enable = to;
616}
617
618static void mse102x_get_ethtool_stats(struct net_device *ndev,
619 struct ethtool_stats *estats, u64 *data)
620{
621 struct mse102x_net *mse = netdev_priv(dev: ndev);
622 struct mse102x_stats *st = &mse->stats;
623
624 memcpy(data, st, ARRAY_SIZE(mse102x_gstrings_stats) * sizeof(u64));
625}
626
627static 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
640static 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
650static 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
662static 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(dev: ndev)) {
668 netif_device_detach(dev: ndev);
669 mse102x_net_stop(ndev);
670 }
671
672 return 0;
673}
674
675static 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(dev: ndev)) {
681 mse102x_net_open(ndev);
682 netif_device_attach(dev: ndev);
683 }
684
685 return 0;
686}
687
688static DEFINE_SIMPLE_DEV_PM_OPS(mse102x_pm_ops, mse102x_suspend, mse102x_resume);
689
690static 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(dev: 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(m: &mses->spi_msg);
737 spi_message_add_tail(t: &mses->spi_xfer, m: &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(debug_value: -1, MSG_DEFAULT);
744
745 skb_queue_head_init(list: &mse->txq);
746
747 SET_NETDEV_DEV(ndev, dev);
748
749 dev_set_drvdata(dev, data: mse);
750
751 netif_carrier_off(dev: mse->ndev);
752 ndev->netdev_ops = &mse102x_netdev_ops;
753 ndev->ethtool_ops = &mse102x_ethtool_ops;
754
755 mse102x_init_mac(mse, np: dev->of_node);
756
757 ret = register_netdev(dev: 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
768static void mse102x_remove_spi(struct spi_device *spi)
769{
770 struct mse102x_net *mse = dev_get_drvdata(dev: &spi->dev);
771 struct mse102x_net_spi *mses = to_mse102x_spi(mse);
772
773 mse102x_remove_device_debugfs(mses);
774 unregister_netdev(dev: mse->ndev);
775}
776
777static const struct of_device_id mse102x_match_table[] = {
778 { .compatible = "vertexcom,mse1021" },
779 { .compatible = "vertexcom,mse1022" },
780 { }
781};
782MODULE_DEVICE_TABLE(of, mse102x_match_table);
783
784static const struct spi_device_id mse102x_ids[] = {
785 { "mse1021" },
786 { "mse1022" },
787 { }
788};
789MODULE_DEVICE_TABLE(spi, mse102x_ids);
790
791static 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};
801module_spi_driver(mse102x_driver);
802
803MODULE_DESCRIPTION("MSE102x Network driver");
804MODULE_AUTHOR("Stefan Wahren <stefan.wahren@chargebyte.com>");
805MODULE_LICENSE("GPL");
806MODULE_ALIAS("spi:" DRV_NAME);
807

source code of linux/drivers/net/ethernet/vertexcom/mse102x.c