1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2010 ASIX Electronics Corporation
4  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
5  *
6  * ASIX AX88796C SPI Fast Ethernet Linux driver
7  */
8 
9 #define pr_fmt(fmt)	"ax88796c: " fmt
10 
11 #include "ax88796c_main.h"
12 #include "ax88796c_ioctl.h"
13 
14 #include <linux/bitmap.h>
15 #include <linux/etherdevice.h>
16 #include <linux/iopoll.h>
17 #include <linux/lockdep.h>
18 #include <linux/mdio.h>
19 #include <linux/minmax.h>
20 #include <linux/module.h>
21 #include <linux/netdevice.h>
22 #include <linux/of.h>
23 #include <linux/phy.h>
24 #include <linux/skbuff.h>
25 #include <linux/spi/spi.h>
26 
27 static int comp = IS_ENABLED(CONFIG_SPI_AX88796C_COMPRESSION);
28 static int msg_enable = NETIF_MSG_PROBE |
29 			NETIF_MSG_LINK |
30 			NETIF_MSG_RX_ERR |
31 			NETIF_MSG_TX_ERR;
32 
33 static const char *no_regs_list = "80018001,e1918001,8001a001,fc0d0000";
34 unsigned long ax88796c_no_regs_mask[AX88796C_REGDUMP_LEN / (sizeof(unsigned long) * 8)];
35 
36 module_param(msg_enable, int, 0444);
37 MODULE_PARM_DESC(msg_enable, "Message mask (see linux/netdevice.h for bitmap)");
38 
39 static int ax88796c_soft_reset(struct ax88796c_device *ax_local)
40 {
41 	u16 temp;
42 	int ret;
43 
44 	lockdep_assert_held(&ax_local->spi_lock);
45 
46 	AX_WRITE(&ax_local->ax_spi, PSR_RESET, P0_PSR);
47 	AX_WRITE(&ax_local->ax_spi, PSR_RESET_CLR, P0_PSR);
48 
49 	ret = read_poll_timeout(AX_READ, ret,
50 				(ret & PSR_DEV_READY),
51 				0, jiffies_to_usecs(160 * HZ / 1000), false,
52 				&ax_local->ax_spi, P0_PSR);
53 	if (ret)
54 		return ret;
55 
56 	temp = AX_READ(&ax_local->ax_spi, P4_SPICR);
57 	if (ax_local->priv_flags & AX_CAP_COMP) {
58 		AX_WRITE(&ax_local->ax_spi,
59 			 (temp | SPICR_RCEN | SPICR_QCEN), P4_SPICR);
60 		ax_local->ax_spi.comp = 1;
61 	} else {
62 		AX_WRITE(&ax_local->ax_spi,
63 			 (temp & ~(SPICR_RCEN | SPICR_QCEN)), P4_SPICR);
64 		ax_local->ax_spi.comp = 0;
65 	}
66 
67 	return 0;
68 }
69 
70 static int ax88796c_reload_eeprom(struct ax88796c_device *ax_local)
71 {
72 	int ret;
73 
74 	lockdep_assert_held(&ax_local->spi_lock);
75 
76 	AX_WRITE(&ax_local->ax_spi, EECR_RELOAD, P3_EECR);
77 
78 	ret = read_poll_timeout(AX_READ, ret,
79 				(ret & PSR_DEV_READY),
80 				0, jiffies_to_usecs(2 * HZ / 1000), false,
81 				&ax_local->ax_spi, P0_PSR);
82 	if (ret) {
83 		dev_err(&ax_local->spi->dev,
84 			"timeout waiting for reload eeprom\n");
85 		return ret;
86 	}
87 
88 	return 0;
89 }
90 
91 static void ax88796c_set_hw_multicast(struct net_device *ndev)
92 {
93 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
94 	int mc_count = netdev_mc_count(ndev);
95 	u16 rx_ctl = RXCR_AB;
96 
97 	lockdep_assert_held(&ax_local->spi_lock);
98 
99 	memset(ax_local->multi_filter, 0, AX_MCAST_FILTER_SIZE);
100 
101 	if (ndev->flags & IFF_PROMISC) {
102 		rx_ctl |= RXCR_PRO;
103 
104 	} else if (ndev->flags & IFF_ALLMULTI || mc_count > AX_MAX_MCAST) {
105 		rx_ctl |= RXCR_AMALL;
106 
107 	} else if (mc_count == 0) {
108 		/* just broadcast and directed */
109 	} else {
110 		u32 crc_bits;
111 		int i;
112 		struct netdev_hw_addr *ha;
113 
114 		netdev_for_each_mc_addr(ha, ndev) {
115 			crc_bits = ether_crc(ETH_ALEN, ha->addr);
116 			ax_local->multi_filter[crc_bits >> 29] |=
117 						(1 << ((crc_bits >> 26) & 7));
118 		}
119 
120 		for (i = 0; i < 4; i++) {
121 			AX_WRITE(&ax_local->ax_spi,
122 				 ((ax_local->multi_filter[i * 2 + 1] << 8) |
123 				  ax_local->multi_filter[i * 2]), P3_MFAR(i));
124 		}
125 	}
126 
127 	AX_WRITE(&ax_local->ax_spi, rx_ctl, P2_RXCR);
128 }
129 
130 static void ax88796c_set_mac_addr(struct net_device *ndev)
131 {
132 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
133 
134 	lockdep_assert_held(&ax_local->spi_lock);
135 
136 	AX_WRITE(&ax_local->ax_spi, ((u16)(ndev->dev_addr[4] << 8) |
137 			(u16)ndev->dev_addr[5]), P3_MACASR0);
138 	AX_WRITE(&ax_local->ax_spi, ((u16)(ndev->dev_addr[2] << 8) |
139 			(u16)ndev->dev_addr[3]), P3_MACASR1);
140 	AX_WRITE(&ax_local->ax_spi, ((u16)(ndev->dev_addr[0] << 8) |
141 			(u16)ndev->dev_addr[1]), P3_MACASR2);
142 }
143 
144 static void ax88796c_load_mac_addr(struct net_device *ndev)
145 {
146 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
147 	u8 addr[ETH_ALEN];
148 	u16 temp;
149 
150 	lockdep_assert_held(&ax_local->spi_lock);
151 
152 	/* Try the device tree first */
153 	if (!platform_get_ethdev_address(&ax_local->spi->dev, ndev) &&
154 	    is_valid_ether_addr(ndev->dev_addr)) {
155 		if (netif_msg_probe(ax_local))
156 			dev_info(&ax_local->spi->dev,
157 				 "MAC address read from device tree\n");
158 		return;
159 	}
160 
161 	/* Read the MAC address from AX88796C */
162 	temp = AX_READ(&ax_local->ax_spi, P3_MACASR0);
163 	addr[5] = (u8)temp;
164 	addr[4] = (u8)(temp >> 8);
165 
166 	temp = AX_READ(&ax_local->ax_spi, P3_MACASR1);
167 	addr[3] = (u8)temp;
168 	addr[2] = (u8)(temp >> 8);
169 
170 	temp = AX_READ(&ax_local->ax_spi, P3_MACASR2);
171 	addr[1] = (u8)temp;
172 	addr[0] = (u8)(temp >> 8);
173 
174 	if (is_valid_ether_addr(addr)) {
175 		eth_hw_addr_set(ndev, addr);
176 		if (netif_msg_probe(ax_local))
177 			dev_info(&ax_local->spi->dev,
178 				 "MAC address read from ASIX chip\n");
179 		return;
180 	}
181 
182 	/* Use random address if none found */
183 	if (netif_msg_probe(ax_local))
184 		dev_info(&ax_local->spi->dev, "Use random MAC address\n");
185 	eth_hw_addr_random(ndev);
186 }
187 
188 static void ax88796c_proc_tx_hdr(struct tx_pkt_info *info, u8 ip_summed)
189 {
190 	u16 pkt_len_bar = (~info->pkt_len & TX_HDR_SOP_PKTLENBAR);
191 
192 	/* Prepare SOP header */
193 	info->sop.flags_len = info->pkt_len |
194 		((ip_summed == CHECKSUM_NONE) ||
195 		 (ip_summed == CHECKSUM_UNNECESSARY) ? TX_HDR_SOP_DICF : 0);
196 
197 	info->sop.seq_lenbar = ((info->seq_num << 11) & TX_HDR_SOP_SEQNUM)
198 				| pkt_len_bar;
199 	cpu_to_be16s(&info->sop.flags_len);
200 	cpu_to_be16s(&info->sop.seq_lenbar);
201 
202 	/* Prepare Segment header */
203 	info->seg.flags_seqnum_seglen = TX_HDR_SEG_FS | TX_HDR_SEG_LS
204 						| info->pkt_len;
205 
206 	info->seg.eo_so_seglenbar = pkt_len_bar;
207 
208 	cpu_to_be16s(&info->seg.flags_seqnum_seglen);
209 	cpu_to_be16s(&info->seg.eo_so_seglenbar);
210 
211 	/* Prepare EOP header */
212 	info->eop.seq_len = ((info->seq_num << 11) &
213 			     TX_HDR_EOP_SEQNUM) | info->pkt_len;
214 	info->eop.seqbar_lenbar = ((~info->seq_num << 11) &
215 				   TX_HDR_EOP_SEQNUMBAR) | pkt_len_bar;
216 
217 	cpu_to_be16s(&info->eop.seq_len);
218 	cpu_to_be16s(&info->eop.seqbar_lenbar);
219 }
220 
221 static int
222 ax88796c_check_free_pages(struct ax88796c_device *ax_local, u8 need_pages)
223 {
224 	u8 free_pages;
225 	u16 tmp;
226 
227 	lockdep_assert_held(&ax_local->spi_lock);
228 
229 	free_pages = AX_READ(&ax_local->ax_spi, P0_TFBFCR) & TX_FREEBUF_MASK;
230 	if (free_pages < need_pages) {
231 		/* schedule free page interrupt */
232 		tmp = AX_READ(&ax_local->ax_spi, P0_TFBFCR)
233 				& TFBFCR_SCHE_FREE_PAGE;
234 		AX_WRITE(&ax_local->ax_spi, tmp | TFBFCR_TX_PAGE_SET |
235 				TFBFCR_SET_FREE_PAGE(need_pages),
236 				P0_TFBFCR);
237 		return -ENOMEM;
238 	}
239 
240 	return 0;
241 }
242 
243 static struct sk_buff *
244 ax88796c_tx_fixup(struct net_device *ndev, struct sk_buff_head *q)
245 {
246 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
247 	u8 spi_len = ax_local->ax_spi.comp ? 1 : 4;
248 	struct sk_buff *skb;
249 	struct tx_pkt_info info;
250 	struct skb_data *entry;
251 	u16 pkt_len;
252 	u8 padlen, seq_num;
253 	u8 need_pages;
254 	int headroom;
255 	int tailroom;
256 
257 	if (skb_queue_empty(q))
258 		return NULL;
259 
260 	skb = skb_peek(q);
261 	pkt_len = skb->len;
262 	need_pages = (pkt_len + TX_OVERHEAD + 127) >> 7;
263 	if (ax88796c_check_free_pages(ax_local, need_pages) != 0)
264 		return NULL;
265 
266 	headroom = skb_headroom(skb);
267 	tailroom = skb_tailroom(skb);
268 	padlen = round_up(pkt_len, 4) - pkt_len;
269 	seq_num = ++ax_local->seq_num & 0x1F;
270 
271 	info.pkt_len = pkt_len;
272 
273 	if (skb_cloned(skb) ||
274 	    (headroom < (TX_OVERHEAD + spi_len)) ||
275 	    (tailroom < (padlen + TX_EOP_SIZE))) {
276 		size_t h = max((TX_OVERHEAD + spi_len) - headroom, 0);
277 		size_t t = max((padlen + TX_EOP_SIZE) - tailroom, 0);
278 
279 		if (pskb_expand_head(skb, h, t, GFP_KERNEL))
280 			return NULL;
281 	}
282 
283 	info.seq_num = seq_num;
284 	ax88796c_proc_tx_hdr(&info, skb->ip_summed);
285 
286 	/* SOP and SEG header */
287 	memcpy(skb_push(skb, TX_OVERHEAD), &info.sop, TX_OVERHEAD);
288 
289 	/* Write SPI TXQ header */
290 	memcpy(skb_push(skb, spi_len), ax88796c_tx_cmd_buf, spi_len);
291 
292 	/* Make 32-bit alignment */
293 	skb_put(skb, padlen);
294 
295 	/* EOP header */
296 	skb_put_data(skb, &info.eop, TX_EOP_SIZE);
297 
298 	skb_unlink(skb, q);
299 
300 	entry = (struct skb_data *)skb->cb;
301 	memset(entry, 0, sizeof(*entry));
302 	entry->len = pkt_len;
303 
304 	if (netif_msg_pktdata(ax_local)) {
305 		char pfx[IFNAMSIZ + 7];
306 
307 		snprintf(pfx, sizeof(pfx), "%s:     ", ndev->name);
308 
309 		netdev_info(ndev, "TX packet len %d, total len %d, seq %d\n",
310 			    pkt_len, skb->len, seq_num);
311 
312 		netdev_info(ndev, "  SPI Header:\n");
313 		print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
314 			       skb->data, 4, 0);
315 
316 		netdev_info(ndev, "  TX SOP:\n");
317 		print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
318 			       skb->data + 4, TX_OVERHEAD, 0);
319 
320 		netdev_info(ndev, "  TX packet:\n");
321 		print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
322 			       skb->data + 4 + TX_OVERHEAD,
323 			       skb->len - TX_EOP_SIZE - 4 - TX_OVERHEAD, 0);
324 
325 		netdev_info(ndev, "  TX EOP:\n");
326 		print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
327 			       skb->data + skb->len - 4, 4, 0);
328 	}
329 
330 	return skb;
331 }
332 
333 static int ax88796c_hard_xmit(struct ax88796c_device *ax_local)
334 {
335 	struct ax88796c_pcpu_stats *stats;
336 	struct sk_buff *tx_skb;
337 	struct skb_data *entry;
338 	unsigned long flags;
339 
340 	lockdep_assert_held(&ax_local->spi_lock);
341 
342 	stats = this_cpu_ptr(ax_local->stats);
343 	tx_skb = ax88796c_tx_fixup(ax_local->ndev, &ax_local->tx_wait_q);
344 
345 	if (!tx_skb) {
346 		this_cpu_inc(ax_local->stats->tx_dropped);
347 		return 0;
348 	}
349 	entry = (struct skb_data *)tx_skb->cb;
350 
351 	AX_WRITE(&ax_local->ax_spi,
352 		 (TSNR_TXB_START | TSNR_PKT_CNT(1)), P0_TSNR);
353 
354 	axspi_write_txq(&ax_local->ax_spi, tx_skb->data, tx_skb->len);
355 
356 	if (((AX_READ(&ax_local->ax_spi, P0_TSNR) & TXNR_TXB_IDLE) == 0) ||
357 	    ((ISR_TXERR & AX_READ(&ax_local->ax_spi, P0_ISR)) != 0)) {
358 		/* Ack tx error int */
359 		AX_WRITE(&ax_local->ax_spi, ISR_TXERR, P0_ISR);
360 
361 		this_cpu_inc(ax_local->stats->tx_dropped);
362 
363 		if (net_ratelimit())
364 			netif_err(ax_local, tx_err, ax_local->ndev,
365 				  "TX FIFO error, re-initialize the TX bridge\n");
366 
367 		/* Reinitial tx bridge */
368 		AX_WRITE(&ax_local->ax_spi, TXNR_TXB_REINIT |
369 			AX_READ(&ax_local->ax_spi, P0_TSNR), P0_TSNR);
370 		ax_local->seq_num = 0;
371 	} else {
372 		flags = u64_stats_update_begin_irqsave(&stats->syncp);
373 		u64_stats_inc(&stats->tx_packets);
374 		u64_stats_add(&stats->tx_bytes, entry->len);
375 		u64_stats_update_end_irqrestore(&stats->syncp, flags);
376 	}
377 
378 	entry->state = tx_done;
379 	dev_kfree_skb(tx_skb);
380 
381 	return 1;
382 }
383 
384 static netdev_tx_t
385 ax88796c_start_xmit(struct sk_buff *skb, struct net_device *ndev)
386 {
387 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
388 
389 	skb_queue_tail(&ax_local->tx_wait_q, skb);
390 	if (skb_queue_len(&ax_local->tx_wait_q) > TX_QUEUE_HIGH_WATER)
391 		netif_stop_queue(ndev);
392 
393 	set_bit(EVENT_TX, &ax_local->flags);
394 	schedule_work(&ax_local->ax_work);
395 
396 	return NETDEV_TX_OK;
397 }
398 
399 static void
400 ax88796c_skb_return(struct ax88796c_device *ax_local,
401 		    struct sk_buff *skb, struct rx_header *rxhdr)
402 {
403 	struct net_device *ndev = ax_local->ndev;
404 	struct ax88796c_pcpu_stats *stats;
405 	unsigned long flags;
406 	int status;
407 
408 	stats = this_cpu_ptr(ax_local->stats);
409 
410 	do {
411 		if (!(ndev->features & NETIF_F_RXCSUM))
412 			break;
413 
414 		/* checksum error bit is set */
415 		if ((rxhdr->flags & RX_HDR3_L3_ERR) ||
416 		    (rxhdr->flags & RX_HDR3_L4_ERR))
417 			break;
418 
419 		/* Other types may be indicated by more than one bit. */
420 		if ((rxhdr->flags & RX_HDR3_L4_TYPE_TCP) ||
421 		    (rxhdr->flags & RX_HDR3_L4_TYPE_UDP))
422 			skb->ip_summed = CHECKSUM_UNNECESSARY;
423 	} while (0);
424 
425 	flags = u64_stats_update_begin_irqsave(&stats->syncp);
426 	u64_stats_inc(&stats->rx_packets);
427 	u64_stats_add(&stats->rx_bytes, skb->len);
428 	u64_stats_update_end_irqrestore(&stats->syncp, flags);
429 
430 	skb->dev = ndev;
431 	skb->protocol = eth_type_trans(skb, ax_local->ndev);
432 
433 	netif_info(ax_local, rx_status, ndev, "< rx, len %zu, type 0x%x\n",
434 		   skb->len + sizeof(struct ethhdr), skb->protocol);
435 
436 	status = netif_rx(skb);
437 	if (status != NET_RX_SUCCESS && net_ratelimit())
438 		netif_info(ax_local, rx_err, ndev,
439 			   "netif_rx status %d\n", status);
440 }
441 
442 static void
443 ax88796c_rx_fixup(struct ax88796c_device *ax_local, struct sk_buff *rx_skb)
444 {
445 	struct rx_header *rxhdr = (struct rx_header *)rx_skb->data;
446 	struct net_device *ndev = ax_local->ndev;
447 	u16 len;
448 
449 	be16_to_cpus(&rxhdr->flags_len);
450 	be16_to_cpus(&rxhdr->seq_lenbar);
451 	be16_to_cpus(&rxhdr->flags);
452 
453 	if ((rxhdr->flags_len & RX_HDR1_PKT_LEN) !=
454 			 (~rxhdr->seq_lenbar & 0x7FF)) {
455 		netif_err(ax_local, rx_err, ndev, "Header error\n");
456 
457 		this_cpu_inc(ax_local->stats->rx_frame_errors);
458 		kfree_skb(rx_skb);
459 		return;
460 	}
461 
462 	if ((rxhdr->flags_len & RX_HDR1_MII_ERR) ||
463 	    (rxhdr->flags_len & RX_HDR1_CRC_ERR)) {
464 		netif_err(ax_local, rx_err, ndev, "CRC or MII error\n");
465 
466 		this_cpu_inc(ax_local->stats->rx_crc_errors);
467 		kfree_skb(rx_skb);
468 		return;
469 	}
470 
471 	len = rxhdr->flags_len & RX_HDR1_PKT_LEN;
472 	if (netif_msg_pktdata(ax_local)) {
473 		char pfx[IFNAMSIZ + 7];
474 
475 		snprintf(pfx, sizeof(pfx), "%s:     ", ndev->name);
476 		netdev_info(ndev, "RX data, total len %d, packet len %d\n",
477 			    rx_skb->len, len);
478 
479 		netdev_info(ndev, "  Dump RX packet header:");
480 		print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
481 			       rx_skb->data, sizeof(*rxhdr), 0);
482 
483 		netdev_info(ndev, "  Dump RX packet:");
484 		print_hex_dump(KERN_INFO, pfx, DUMP_PREFIX_OFFSET, 16, 1,
485 			       rx_skb->data + sizeof(*rxhdr), len, 0);
486 	}
487 
488 	skb_pull(rx_skb, sizeof(*rxhdr));
489 	pskb_trim(rx_skb, len);
490 
491 	ax88796c_skb_return(ax_local, rx_skb, rxhdr);
492 }
493 
494 static int ax88796c_receive(struct net_device *ndev)
495 {
496 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
497 	struct skb_data *entry;
498 	u16 w_count, pkt_len;
499 	struct sk_buff *skb;
500 	u8 pkt_cnt;
501 
502 	lockdep_assert_held(&ax_local->spi_lock);
503 
504 	/* check rx packet and total word count */
505 	AX_WRITE(&ax_local->ax_spi, AX_READ(&ax_local->ax_spi, P0_RTWCR)
506 		  | RTWCR_RX_LATCH, P0_RTWCR);
507 
508 	pkt_cnt = AX_READ(&ax_local->ax_spi, P0_RXBCR2) & RXBCR2_PKT_MASK;
509 	if (!pkt_cnt)
510 		return 0;
511 
512 	pkt_len = AX_READ(&ax_local->ax_spi, P0_RCPHR) & 0x7FF;
513 
514 	w_count = round_up(pkt_len + 6, 4) >> 1;
515 
516 	skb = netdev_alloc_skb(ndev, w_count * 2);
517 	if (!skb) {
518 		AX_WRITE(&ax_local->ax_spi, RXBCR1_RXB_DISCARD, P0_RXBCR1);
519 		this_cpu_inc(ax_local->stats->rx_dropped);
520 		return 0;
521 	}
522 	entry = (struct skb_data *)skb->cb;
523 
524 	AX_WRITE(&ax_local->ax_spi, RXBCR1_RXB_START | w_count, P0_RXBCR1);
525 
526 	axspi_read_rxq(&ax_local->ax_spi,
527 		       skb_put(skb, w_count * 2), skb->len);
528 
529 	/* Check if rx bridge is idle */
530 	if ((AX_READ(&ax_local->ax_spi, P0_RXBCR2) & RXBCR2_RXB_IDLE) == 0) {
531 		if (net_ratelimit())
532 			netif_err(ax_local, rx_err, ndev,
533 				  "Rx Bridge is not idle\n");
534 		AX_WRITE(&ax_local->ax_spi, RXBCR2_RXB_REINIT, P0_RXBCR2);
535 
536 		entry->state = rx_err;
537 	} else {
538 		entry->state = rx_done;
539 	}
540 
541 	AX_WRITE(&ax_local->ax_spi, ISR_RXPKT, P0_ISR);
542 
543 	ax88796c_rx_fixup(ax_local, skb);
544 
545 	return 1;
546 }
547 
548 static int ax88796c_process_isr(struct ax88796c_device *ax_local)
549 {
550 	struct net_device *ndev = ax_local->ndev;
551 	int todo = 0;
552 	u16 isr;
553 
554 	lockdep_assert_held(&ax_local->spi_lock);
555 
556 	isr = AX_READ(&ax_local->ax_spi, P0_ISR);
557 	AX_WRITE(&ax_local->ax_spi, isr, P0_ISR);
558 
559 	netif_dbg(ax_local, intr, ndev, "  ISR 0x%04x\n", isr);
560 
561 	if (isr & ISR_TXERR) {
562 		netif_dbg(ax_local, intr, ndev, "  TXERR interrupt\n");
563 		AX_WRITE(&ax_local->ax_spi, TXNR_TXB_REINIT, P0_TSNR);
564 		ax_local->seq_num = 0x1f;
565 	}
566 
567 	if (isr & ISR_TXPAGES) {
568 		netif_dbg(ax_local, intr, ndev, "  TXPAGES interrupt\n");
569 		set_bit(EVENT_TX, &ax_local->flags);
570 	}
571 
572 	if (isr & ISR_LINK) {
573 		netif_dbg(ax_local, intr, ndev, "  Link change interrupt\n");
574 		phy_mac_interrupt(ax_local->ndev->phydev);
575 	}
576 
577 	if (isr & ISR_RXPKT) {
578 		netif_dbg(ax_local, intr, ndev, "  RX interrupt\n");
579 		todo = ax88796c_receive(ax_local->ndev);
580 	}
581 
582 	return todo;
583 }
584 
585 static irqreturn_t ax88796c_interrupt(int irq, void *dev_instance)
586 {
587 	struct ax88796c_device *ax_local;
588 	struct net_device *ndev;
589 
590 	ndev = dev_instance;
591 	if (!ndev) {
592 		pr_err("irq %d for unknown device.\n", irq);
593 		return IRQ_RETVAL(0);
594 	}
595 	ax_local = to_ax88796c_device(ndev);
596 
597 	disable_irq_nosync(irq);
598 
599 	netif_dbg(ax_local, intr, ndev, "Interrupt occurred\n");
600 
601 	set_bit(EVENT_INTR, &ax_local->flags);
602 	schedule_work(&ax_local->ax_work);
603 
604 	return IRQ_HANDLED;
605 }
606 
607 static void ax88796c_work(struct work_struct *work)
608 {
609 	struct ax88796c_device *ax_local =
610 			container_of(work, struct ax88796c_device, ax_work);
611 
612 	mutex_lock(&ax_local->spi_lock);
613 
614 	if (test_bit(EVENT_SET_MULTI, &ax_local->flags)) {
615 		ax88796c_set_hw_multicast(ax_local->ndev);
616 		clear_bit(EVENT_SET_MULTI, &ax_local->flags);
617 	}
618 
619 	if (test_bit(EVENT_INTR, &ax_local->flags)) {
620 		AX_WRITE(&ax_local->ax_spi, IMR_MASKALL, P0_IMR);
621 
622 		while (ax88796c_process_isr(ax_local))
623 			/* nothing */;
624 
625 		clear_bit(EVENT_INTR, &ax_local->flags);
626 
627 		AX_WRITE(&ax_local->ax_spi, IMR_DEFAULT, P0_IMR);
628 
629 		enable_irq(ax_local->ndev->irq);
630 	}
631 
632 	if (test_bit(EVENT_TX, &ax_local->flags)) {
633 		while (skb_queue_len(&ax_local->tx_wait_q)) {
634 			if (!ax88796c_hard_xmit(ax_local))
635 				break;
636 		}
637 
638 		clear_bit(EVENT_TX, &ax_local->flags);
639 
640 		if (netif_queue_stopped(ax_local->ndev) &&
641 		    (skb_queue_len(&ax_local->tx_wait_q) < TX_QUEUE_LOW_WATER))
642 			netif_wake_queue(ax_local->ndev);
643 	}
644 
645 	mutex_unlock(&ax_local->spi_lock);
646 }
647 
648 static void ax88796c_get_stats64(struct net_device *ndev,
649 				 struct rtnl_link_stats64 *stats)
650 {
651 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
652 	u32 rx_frame_errors = 0, rx_crc_errors = 0;
653 	u32 rx_dropped = 0, tx_dropped = 0;
654 	unsigned int start;
655 	int cpu;
656 
657 	for_each_possible_cpu(cpu) {
658 		struct ax88796c_pcpu_stats *s;
659 		u64 rx_packets, rx_bytes;
660 		u64 tx_packets, tx_bytes;
661 
662 		s = per_cpu_ptr(ax_local->stats, cpu);
663 
664 		do {
665 			start = u64_stats_fetch_begin(&s->syncp);
666 			rx_packets = u64_stats_read(&s->rx_packets);
667 			rx_bytes   = u64_stats_read(&s->rx_bytes);
668 			tx_packets = u64_stats_read(&s->tx_packets);
669 			tx_bytes   = u64_stats_read(&s->tx_bytes);
670 		} while (u64_stats_fetch_retry(&s->syncp, start));
671 
672 		stats->rx_packets += rx_packets;
673 		stats->rx_bytes   += rx_bytes;
674 		stats->tx_packets += tx_packets;
675 		stats->tx_bytes   += tx_bytes;
676 
677 		rx_dropped      += s->rx_dropped;
678 		tx_dropped      += s->tx_dropped;
679 		rx_frame_errors += s->rx_frame_errors;
680 		rx_crc_errors   += s->rx_crc_errors;
681 	}
682 
683 	stats->rx_dropped = rx_dropped;
684 	stats->tx_dropped = tx_dropped;
685 	stats->rx_frame_errors = rx_frame_errors;
686 	stats->rx_crc_errors = rx_crc_errors;
687 }
688 
689 static void ax88796c_set_mac(struct  ax88796c_device *ax_local)
690 {
691 	u16 maccr;
692 
693 	maccr = (ax_local->link) ? MACCR_RXEN : 0;
694 
695 	switch (ax_local->speed) {
696 	case SPEED_100:
697 		maccr |= MACCR_SPEED_100;
698 		break;
699 	case SPEED_10:
700 	case SPEED_UNKNOWN:
701 		break;
702 	default:
703 		return;
704 	}
705 
706 	switch (ax_local->duplex) {
707 	case DUPLEX_FULL:
708 		maccr |= MACCR_SPEED_100;
709 		break;
710 	case DUPLEX_HALF:
711 	case DUPLEX_UNKNOWN:
712 		break;
713 	default:
714 		return;
715 	}
716 
717 	if (ax_local->flowctrl & AX_FC_ANEG &&
718 	    ax_local->phydev->autoneg) {
719 		maccr |= ax_local->pause ? MACCR_RXFC_ENABLE : 0;
720 		maccr |= !ax_local->pause != !ax_local->asym_pause ?
721 			MACCR_TXFC_ENABLE : 0;
722 	} else {
723 		maccr |= (ax_local->flowctrl & AX_FC_RX) ? MACCR_RXFC_ENABLE : 0;
724 		maccr |= (ax_local->flowctrl & AX_FC_TX) ? MACCR_TXFC_ENABLE : 0;
725 	}
726 
727 	mutex_lock(&ax_local->spi_lock);
728 
729 	maccr |= AX_READ(&ax_local->ax_spi, P0_MACCR) &
730 		~(MACCR_DUPLEX_FULL | MACCR_SPEED_100 |
731 		  MACCR_TXFC_ENABLE | MACCR_RXFC_ENABLE);
732 	AX_WRITE(&ax_local->ax_spi, maccr, P0_MACCR);
733 
734 	mutex_unlock(&ax_local->spi_lock);
735 }
736 
737 static void ax88796c_handle_link_change(struct net_device *ndev)
738 {
739 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
740 	struct phy_device *phydev = ndev->phydev;
741 	bool update = false;
742 
743 	if (phydev->link && (ax_local->speed != phydev->speed ||
744 			     ax_local->duplex != phydev->duplex ||
745 			     ax_local->pause != phydev->pause ||
746 			     ax_local->asym_pause != phydev->asym_pause)) {
747 		ax_local->speed = phydev->speed;
748 		ax_local->duplex = phydev->duplex;
749 		ax_local->pause = phydev->pause;
750 		ax_local->asym_pause = phydev->asym_pause;
751 		update = true;
752 	}
753 
754 	if (phydev->link != ax_local->link) {
755 		if (!phydev->link) {
756 			ax_local->speed = SPEED_UNKNOWN;
757 			ax_local->duplex = DUPLEX_UNKNOWN;
758 		}
759 
760 		ax_local->link = phydev->link;
761 		update = true;
762 	}
763 
764 	if (update)
765 		ax88796c_set_mac(ax_local);
766 
767 	if (net_ratelimit())
768 		phy_print_status(ndev->phydev);
769 }
770 
771 static void ax88796c_set_csums(struct ax88796c_device *ax_local)
772 {
773 	struct net_device *ndev = ax_local->ndev;
774 
775 	lockdep_assert_held(&ax_local->spi_lock);
776 
777 	if (ndev->features & NETIF_F_RXCSUM) {
778 		AX_WRITE(&ax_local->ax_spi, COERCR0_DEFAULT, P4_COERCR0);
779 		AX_WRITE(&ax_local->ax_spi, COERCR1_DEFAULT, P4_COERCR1);
780 	} else {
781 		AX_WRITE(&ax_local->ax_spi, 0, P4_COERCR0);
782 		AX_WRITE(&ax_local->ax_spi, 0, P4_COERCR1);
783 	}
784 
785 	if (ndev->features & NETIF_F_HW_CSUM) {
786 		AX_WRITE(&ax_local->ax_spi, COETCR0_DEFAULT, P4_COETCR0);
787 		AX_WRITE(&ax_local->ax_spi, COETCR1_TXPPPE, P4_COETCR1);
788 	} else {
789 		AX_WRITE(&ax_local->ax_spi, 0, P4_COETCR0);
790 		AX_WRITE(&ax_local->ax_spi, 0, P4_COETCR1);
791 	}
792 }
793 
794 static int
795 ax88796c_open(struct net_device *ndev)
796 {
797 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
798 	unsigned long irq_flag = 0;
799 	int fc = AX_FC_NONE;
800 	int ret;
801 	u16 t;
802 
803 	ret = request_irq(ndev->irq, ax88796c_interrupt,
804 			  irq_flag, ndev->name, ndev);
805 	if (ret) {
806 		netdev_err(ndev, "unable to get IRQ %d (errno=%d).\n",
807 			   ndev->irq, ret);
808 		return ret;
809 	}
810 
811 	mutex_lock(&ax_local->spi_lock);
812 
813 	ret = ax88796c_soft_reset(ax_local);
814 	if (ret < 0) {
815 		free_irq(ndev->irq, ndev);
816 		mutex_unlock(&ax_local->spi_lock);
817 		return ret;
818 	}
819 	ax_local->seq_num = 0x1f;
820 
821 	ax88796c_set_mac_addr(ndev);
822 	ax88796c_set_csums(ax_local);
823 
824 	/* Disable stuffing packet */
825 	t = AX_READ(&ax_local->ax_spi, P1_RXBSPCR);
826 	t &= ~RXBSPCR_STUF_ENABLE;
827 	AX_WRITE(&ax_local->ax_spi, t, P1_RXBSPCR);
828 
829 	/* Enable RX packet process */
830 	AX_WRITE(&ax_local->ax_spi, RPPER_RXEN, P1_RPPER);
831 
832 	t = AX_READ(&ax_local->ax_spi, P0_FER);
833 	t |= FER_RXEN | FER_TXEN | FER_BSWAP | FER_IRQ_PULL;
834 	AX_WRITE(&ax_local->ax_spi, t, P0_FER);
835 
836 	/* Setup LED mode */
837 	AX_WRITE(&ax_local->ax_spi,
838 		 (LCR_LED0_EN | LCR_LED0_DUPLEX | LCR_LED1_EN |
839 		 LCR_LED1_100MODE), P2_LCR0);
840 	AX_WRITE(&ax_local->ax_spi,
841 		 (AX_READ(&ax_local->ax_spi, P2_LCR1) & LCR_LED2_MASK) |
842 		 LCR_LED2_EN | LCR_LED2_LINK, P2_LCR1);
843 
844 	/* Disable PHY auto-polling */
845 	AX_WRITE(&ax_local->ax_spi, PCR_PHYID(AX88796C_PHY_ID), P2_PCR);
846 
847 	/* Enable MAC interrupts */
848 	AX_WRITE(&ax_local->ax_spi, IMR_DEFAULT, P0_IMR);
849 
850 	mutex_unlock(&ax_local->spi_lock);
851 
852 	/* Setup flow-control configuration */
853 	phy_support_asym_pause(ax_local->phydev);
854 
855 	if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
856 			      ax_local->phydev->advertising) ||
857 	    linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
858 			      ax_local->phydev->advertising))
859 		fc |= AX_FC_ANEG;
860 
861 	fc |= linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
862 				ax_local->phydev->advertising) ? AX_FC_RX : 0;
863 	fc |= (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
864 				 ax_local->phydev->advertising) !=
865 	       linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
866 				 ax_local->phydev->advertising)) ? AX_FC_TX : 0;
867 	ax_local->flowctrl = fc;
868 
869 	phy_start(ax_local->ndev->phydev);
870 
871 	netif_start_queue(ndev);
872 
873 	spi_message_init(&ax_local->ax_spi.rx_msg);
874 
875 	return 0;
876 }
877 
878 static int
879 ax88796c_close(struct net_device *ndev)
880 {
881 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
882 
883 	phy_stop(ndev->phydev);
884 
885 	/* We lock the mutex early not only to protect the device
886 	 * against concurrent access, but also avoid waking up the
887 	 * queue in ax88796c_work(). phy_stop() needs to be called
888 	 * before because it locks the mutex to access SPI.
889 	 */
890 	mutex_lock(&ax_local->spi_lock);
891 
892 	netif_stop_queue(ndev);
893 
894 	/* No more work can be scheduled now. Make any pending work,
895 	 * including one already waiting for the mutex to be unlocked,
896 	 * NOP.
897 	 */
898 	netif_dbg(ax_local, ifdown, ndev, "clearing bits\n");
899 	clear_bit(EVENT_SET_MULTI, &ax_local->flags);
900 	clear_bit(EVENT_INTR, &ax_local->flags);
901 	clear_bit(EVENT_TX, &ax_local->flags);
902 
903 	/* Disable MAC interrupts */
904 	AX_WRITE(&ax_local->ax_spi, IMR_MASKALL, P0_IMR);
905 	__skb_queue_purge(&ax_local->tx_wait_q);
906 	ax88796c_soft_reset(ax_local);
907 
908 	mutex_unlock(&ax_local->spi_lock);
909 
910 	cancel_work_sync(&ax_local->ax_work);
911 
912 	free_irq(ndev->irq, ndev);
913 
914 	return 0;
915 }
916 
917 static int
918 ax88796c_set_features(struct net_device *ndev, netdev_features_t features)
919 {
920 	struct ax88796c_device *ax_local = to_ax88796c_device(ndev);
921 	netdev_features_t changed = features ^ ndev->features;
922 
923 	if (!(changed & (NETIF_F_RXCSUM | NETIF_F_HW_CSUM)))
924 		return 0;
925 
926 	ndev->features = features;
927 
928 	if (changed & (NETIF_F_RXCSUM | NETIF_F_HW_CSUM))
929 		ax88796c_set_csums(ax_local);
930 
931 	return 0;
932 }
933 
934 static const struct net_device_ops ax88796c_netdev_ops = {
935 	.ndo_open		= ax88796c_open,
936 	.ndo_stop		= ax88796c_close,
937 	.ndo_start_xmit		= ax88796c_start_xmit,
938 	.ndo_get_stats64	= ax88796c_get_stats64,
939 	.ndo_eth_ioctl		= ax88796c_ioctl,
940 	.ndo_set_mac_address	= eth_mac_addr,
941 	.ndo_set_features	= ax88796c_set_features,
942 };
943 
944 static int ax88796c_hard_reset(struct ax88796c_device *ax_local)
945 {
946 	struct device *dev = (struct device *)&ax_local->spi->dev;
947 	struct gpio_desc *reset_gpio;
948 
949 	/* reset info */
950 	reset_gpio = gpiod_get(dev, "reset", 0);
951 	if (IS_ERR(reset_gpio)) {
952 		dev_err(dev, "Could not get 'reset' GPIO: %ld", PTR_ERR(reset_gpio));
953 		return PTR_ERR(reset_gpio);
954 	}
955 
956 	/* set reset */
957 	gpiod_direction_output(reset_gpio, 1);
958 	msleep(100);
959 	gpiod_direction_output(reset_gpio, 0);
960 	gpiod_put(reset_gpio);
961 	msleep(20);
962 
963 	return 0;
964 }
965 
966 static int ax88796c_probe(struct spi_device *spi)
967 {
968 	char phy_id[MII_BUS_ID_SIZE + 3];
969 	struct ax88796c_device *ax_local;
970 	struct net_device *ndev;
971 	u16 temp;
972 	int ret;
973 
974 	ndev = devm_alloc_etherdev(&spi->dev, sizeof(*ax_local));
975 	if (!ndev)
976 		return -ENOMEM;
977 
978 	SET_NETDEV_DEV(ndev, &spi->dev);
979 
980 	ax_local = to_ax88796c_device(ndev);
981 
982 	dev_set_drvdata(&spi->dev, ax_local);
983 	ax_local->spi = spi;
984 	ax_local->ax_spi.spi = spi;
985 
986 	ax_local->stats =
987 		devm_netdev_alloc_pcpu_stats(&spi->dev,
988 					     struct ax88796c_pcpu_stats);
989 	if (!ax_local->stats)
990 		return -ENOMEM;
991 
992 	ax_local->ndev = ndev;
993 	ax_local->priv_flags |= comp ? AX_CAP_COMP : 0;
994 	ax_local->msg_enable = msg_enable;
995 	mutex_init(&ax_local->spi_lock);
996 
997 	ax_local->mdiobus = devm_mdiobus_alloc(&spi->dev);
998 	if (!ax_local->mdiobus)
999 		return -ENOMEM;
1000 
1001 	ax_local->mdiobus->priv = ax_local;
1002 	ax_local->mdiobus->read = ax88796c_mdio_read;
1003 	ax_local->mdiobus->write = ax88796c_mdio_write;
1004 	ax_local->mdiobus->name = "ax88976c-mdiobus";
1005 	ax_local->mdiobus->phy_mask = (u32)~BIT(AX88796C_PHY_ID);
1006 	ax_local->mdiobus->parent = &spi->dev;
1007 
1008 	snprintf(ax_local->mdiobus->id, MII_BUS_ID_SIZE,
1009 		 "ax88796c-%s.%u", dev_name(&spi->dev), spi->chip_select);
1010 
1011 	ret = devm_mdiobus_register(&spi->dev, ax_local->mdiobus);
1012 	if (ret < 0) {
1013 		dev_err(&spi->dev, "Could not register MDIO bus\n");
1014 		return ret;
1015 	}
1016 
1017 	if (netif_msg_probe(ax_local)) {
1018 		dev_info(&spi->dev, "AX88796C-SPI Configuration:\n");
1019 		dev_info(&spi->dev, "    Compression : %s\n",
1020 			 ax_local->priv_flags & AX_CAP_COMP ? "ON" : "OFF");
1021 	}
1022 
1023 	ndev->irq = spi->irq;
1024 	ndev->netdev_ops = &ax88796c_netdev_ops;
1025 	ndev->ethtool_ops = &ax88796c_ethtool_ops;
1026 	ndev->hw_features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1027 	ndev->features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1028 	ndev->needed_headroom = TX_OVERHEAD;
1029 	ndev->needed_tailroom = TX_EOP_SIZE;
1030 
1031 	mutex_lock(&ax_local->spi_lock);
1032 
1033 	/* ax88796c gpio reset */
1034 	ax88796c_hard_reset(ax_local);
1035 
1036 	/* Reset AX88796C */
1037 	ret = ax88796c_soft_reset(ax_local);
1038 	if (ret < 0) {
1039 		ret = -ENODEV;
1040 		mutex_unlock(&ax_local->spi_lock);
1041 		goto err;
1042 	}
1043 	/* Check board revision */
1044 	temp = AX_READ(&ax_local->ax_spi, P2_CRIR);
1045 	if ((temp & 0xF) != 0x0) {
1046 		dev_err(&spi->dev, "spi read failed: %d\n", temp);
1047 		ret = -ENODEV;
1048 		mutex_unlock(&ax_local->spi_lock);
1049 		goto err;
1050 	}
1051 
1052 	/*Reload EEPROM*/
1053 	ax88796c_reload_eeprom(ax_local);
1054 
1055 	ax88796c_load_mac_addr(ndev);
1056 
1057 	if (netif_msg_probe(ax_local))
1058 		dev_info(&spi->dev,
1059 			 "irq %d, MAC addr %02X:%02X:%02X:%02X:%02X:%02X\n",
1060 			 ndev->irq,
1061 			 ndev->dev_addr[0], ndev->dev_addr[1],
1062 			 ndev->dev_addr[2], ndev->dev_addr[3],
1063 			 ndev->dev_addr[4], ndev->dev_addr[5]);
1064 
1065 	/* Disable power saving */
1066 	AX_WRITE(&ax_local->ax_spi, (AX_READ(&ax_local->ax_spi, P0_PSCR)
1067 				     & PSCR_PS_MASK) | PSCR_PS_D0, P0_PSCR);
1068 
1069 	mutex_unlock(&ax_local->spi_lock);
1070 
1071 	INIT_WORK(&ax_local->ax_work, ax88796c_work);
1072 
1073 	skb_queue_head_init(&ax_local->tx_wait_q);
1074 
1075 	snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT,
1076 		 ax_local->mdiobus->id, AX88796C_PHY_ID);
1077 	ax_local->phydev = phy_connect(ax_local->ndev, phy_id,
1078 				       ax88796c_handle_link_change,
1079 				       PHY_INTERFACE_MODE_MII);
1080 	if (IS_ERR(ax_local->phydev)) {
1081 		ret = PTR_ERR(ax_local->phydev);
1082 		goto err;
1083 	}
1084 	ax_local->phydev->irq = PHY_POLL;
1085 
1086 	ret = devm_register_netdev(&spi->dev, ndev);
1087 	if (ret) {
1088 		dev_err(&spi->dev, "failed to register a network device\n");
1089 		goto err_phy_dis;
1090 	}
1091 
1092 	netif_info(ax_local, probe, ndev, "%s %s registered\n",
1093 		   dev_driver_string(&spi->dev),
1094 		   dev_name(&spi->dev));
1095 	phy_attached_info(ax_local->phydev);
1096 
1097 	return 0;
1098 
1099 err_phy_dis:
1100 	phy_disconnect(ax_local->phydev);
1101 err:
1102 	return ret;
1103 }
1104 
1105 static void ax88796c_remove(struct spi_device *spi)
1106 {
1107 	struct ax88796c_device *ax_local = dev_get_drvdata(&spi->dev);
1108 	struct net_device *ndev = ax_local->ndev;
1109 
1110 	phy_disconnect(ndev->phydev);
1111 
1112 	netif_info(ax_local, probe, ndev, "removing network device %s %s\n",
1113 		   dev_driver_string(&spi->dev),
1114 		   dev_name(&spi->dev));
1115 }
1116 
1117 #ifdef CONFIG_OF
1118 static const struct of_device_id ax88796c_dt_ids[] = {
1119 	{ .compatible = "asix,ax88796c" },
1120 	{},
1121 };
1122 MODULE_DEVICE_TABLE(of, ax88796c_dt_ids);
1123 #endif
1124 
1125 static const struct spi_device_id asix_id[] = {
1126 	{ "ax88796c", 0 },
1127 	{ }
1128 };
1129 MODULE_DEVICE_TABLE(spi, asix_id);
1130 
1131 static struct spi_driver ax88796c_spi_driver = {
1132 	.driver = {
1133 		.name = DRV_NAME,
1134 		.of_match_table = of_match_ptr(ax88796c_dt_ids),
1135 	},
1136 	.probe = ax88796c_probe,
1137 	.remove = ax88796c_remove,
1138 	.id_table = asix_id,
1139 };
1140 
1141 static __init int ax88796c_spi_init(void)
1142 {
1143 	int ret;
1144 
1145 	bitmap_zero(ax88796c_no_regs_mask, AX88796C_REGDUMP_LEN);
1146 	ret = bitmap_parse(no_regs_list, 35,
1147 			   ax88796c_no_regs_mask, AX88796C_REGDUMP_LEN);
1148 	if (ret) {
1149 		bitmap_fill(ax88796c_no_regs_mask, AX88796C_REGDUMP_LEN);
1150 		pr_err("Invalid bitmap description, masking all registers\n");
1151 	}
1152 
1153 	return spi_register_driver(&ax88796c_spi_driver);
1154 }
1155 
1156 static __exit void ax88796c_spi_exit(void)
1157 {
1158 	spi_unregister_driver(&ax88796c_spi_driver);
1159 }
1160 
1161 module_init(ax88796c_spi_init);
1162 module_exit(ax88796c_spi_exit);
1163 
1164 MODULE_AUTHOR("Łukasz Stelmach <l.stelmach@samsung.com>");
1165 MODULE_DESCRIPTION("ASIX AX88796C SPI Ethernet driver");
1166 MODULE_LICENSE("GPL");
1167