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/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(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}
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(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
129static 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
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(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
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(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
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(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
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(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
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, "pk data: ", DUMP_PREFIX_OFFSET, 16, 1,
310		       data, len, 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, (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	 */
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(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
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, (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
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(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
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(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
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, 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 */
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(&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(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
566static 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
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(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(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(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(ndev)) {
668		netif_device_detach(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(ndev)) {
681		mse102x_net_open(ndev);
682		netif_device_attach(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(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
768static 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
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);