Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/**
3 * Microchip ENCX24J600 ethernet driver
4 *
5 * Copyright (C) 2015 Gridpoint
6 * Author: Jon Ringle <jringle@gridpoint.com>
7 */
8
9#include <linux/device.h>
10#include <linux/errno.h>
11#include <linux/etherdevice.h>
12#include <linux/ethtool.h>
13#include <linux/interrupt.h>
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/netdevice.h>
17#include <linux/regmap.h>
18#include <linux/skbuff.h>
19#include <linux/spi/spi.h>
20
21#include "encx24j600_hw.h"
22
23#define DRV_NAME "encx24j600"
24#define DRV_VERSION "1.0"
25
26#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
27static int debug = -1;
28module_param(debug, int, 0000);
29MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
30
31/* SRAM memory layout:
32 *
33 * 0x0000-0x05ff TX buffers 1.5KB (1*1536) reside in the GP area in SRAM
34 * 0x0600-0x5fff RX buffers 22.5KB (15*1536) reside in the RX area in SRAM
35 */
36#define ENC_TX_BUF_START 0x0000U
37#define ENC_RX_BUF_START 0x0600U
38#define ENC_RX_BUF_END 0x5fffU
39#define ENC_SRAM_SIZE 0x6000U
40
41enum {
42 RXFILTER_NORMAL,
43 RXFILTER_MULTI,
44 RXFILTER_PROMISC
45};
46
47struct encx24j600_priv {
48 struct net_device *ndev;
49 struct mutex lock; /* device access lock */
50 struct encx24j600_context ctx;
51 struct sk_buff *tx_skb;
52 struct task_struct *kworker_task;
53 struct kthread_worker kworker;
54 struct kthread_work tx_work;
55 struct kthread_work setrx_work;
56 u16 next_packet;
57 bool hw_enabled;
58 bool full_duplex;
59 bool autoneg;
60 u16 speed;
61 int rxfilter;
62 u32 msg_enable;
63};
64
65static void dump_packet(const char *msg, int len, const char *data)
66{
67 pr_debug(DRV_NAME ": %s - packet len:%d\n", msg, len);
68 print_hex_dump_bytes("pk data: ", DUMP_PREFIX_OFFSET, data, len);
69}
70
71static void encx24j600_dump_rsv(struct encx24j600_priv *priv, const char *msg,
72 struct rsv *rsv)
73{
74 struct net_device *dev = priv->ndev;
75
76 netdev_info(dev, "RX packet Len:%d\n", rsv->len);
77 netdev_dbg(dev, "%s - NextPk: 0x%04x\n", msg,
78 rsv->next_packet);
79 netdev_dbg(dev, "RxOK: %d, DribbleNibble: %d\n",
80 RSV_GETBIT(rsv->rxstat, RSV_RXOK),
81 RSV_GETBIT(rsv->rxstat, RSV_DRIBBLENIBBLE));
82 netdev_dbg(dev, "CRCErr:%d, LenChkErr: %d, LenOutOfRange: %d\n",
83 RSV_GETBIT(rsv->rxstat, RSV_CRCERROR),
84 RSV_GETBIT(rsv->rxstat, RSV_LENCHECKERR),
85 RSV_GETBIT(rsv->rxstat, RSV_LENOUTOFRANGE));
86 netdev_dbg(dev, "Multicast: %d, Broadcast: %d, LongDropEvent: %d, CarrierEvent: %d\n",
87 RSV_GETBIT(rsv->rxstat, RSV_RXMULTICAST),
88 RSV_GETBIT(rsv->rxstat, RSV_RXBROADCAST),
89 RSV_GETBIT(rsv->rxstat, RSV_RXLONGEVDROPEV),
90 RSV_GETBIT(rsv->rxstat, RSV_CARRIEREV));
91 netdev_dbg(dev, "ControlFrame: %d, PauseFrame: %d, UnknownOp: %d, VLanTagFrame: %d\n",
92 RSV_GETBIT(rsv->rxstat, RSV_RXCONTROLFRAME),
93 RSV_GETBIT(rsv->rxstat, RSV_RXPAUSEFRAME),
94 RSV_GETBIT(rsv->rxstat, RSV_RXUNKNOWNOPCODE),
95 RSV_GETBIT(rsv->rxstat, RSV_RXTYPEVLAN));
96}
97
98static u16 encx24j600_read_reg(struct encx24j600_priv *priv, u8 reg)
99{
100 struct net_device *dev = priv->ndev;
101 unsigned int val = 0;
102 int ret = regmap_read(priv->ctx.regmap, reg, &val);
103
104 if (unlikely(ret))
105 netif_err(priv, drv, dev, "%s: error %d reading reg %02x\n",
106 __func__, ret, reg);
107 return val;
108}
109
110static void encx24j600_write_reg(struct encx24j600_priv *priv, u8 reg, u16 val)
111{
112 struct net_device *dev = priv->ndev;
113 int ret = regmap_write(priv->ctx.regmap, reg, val);
114
115 if (unlikely(ret))
116 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
117 __func__, ret, reg, val);
118}
119
120static void encx24j600_update_reg(struct encx24j600_priv *priv, u8 reg,
121 u16 mask, u16 val)
122{
123 struct net_device *dev = priv->ndev;
124 int ret = regmap_update_bits(priv->ctx.regmap, reg, mask, val);
125
126 if (unlikely(ret))
127 netif_err(priv, drv, dev, "%s: error %d updating reg %02x=%04x~%04x\n",
128 __func__, ret, reg, val, mask);
129}
130
131static u16 encx24j600_read_phy(struct encx24j600_priv *priv, u8 reg)
132{
133 struct net_device *dev = priv->ndev;
134 unsigned int val = 0;
135 int ret = regmap_read(priv->ctx.phymap, reg, &val);
136
137 if (unlikely(ret))
138 netif_err(priv, drv, dev, "%s: error %d reading %02x\n",
139 __func__, ret, reg);
140 return val;
141}
142
143static void encx24j600_write_phy(struct encx24j600_priv *priv, u8 reg, u16 val)
144{
145 struct net_device *dev = priv->ndev;
146 int ret = regmap_write(priv->ctx.phymap, reg, val);
147
148 if (unlikely(ret))
149 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
150 __func__, ret, reg, val);
151}
152
153static void encx24j600_clr_bits(struct encx24j600_priv *priv, u8 reg, u16 mask)
154{
155 encx24j600_update_reg(priv, reg, mask, 0);
156}
157
158static void encx24j600_set_bits(struct encx24j600_priv *priv, u8 reg, u16 mask)
159{
160 encx24j600_update_reg(priv, reg, mask, mask);
161}
162
163static void encx24j600_cmd(struct encx24j600_priv *priv, u8 cmd)
164{
165 struct net_device *dev = priv->ndev;
166 int ret = regmap_write(priv->ctx.regmap, cmd, 0);
167
168 if (unlikely(ret))
169 netif_err(priv, drv, dev, "%s: error %d with cmd %02x\n",
170 __func__, ret, cmd);
171}
172
173static int encx24j600_raw_read(struct encx24j600_priv *priv, u8 reg, u8 *data,
174 size_t count)
175{
176 int ret;
177
178 mutex_lock(&priv->ctx.mutex);
179 ret = regmap_encx24j600_spi_read(&priv->ctx, reg, data, count);
180 mutex_unlock(&priv->ctx.mutex);
181
182 return ret;
183}
184
185static int encx24j600_raw_write(struct encx24j600_priv *priv, u8 reg,
186 const u8 *data, size_t count)
187{
188 int ret;
189
190 mutex_lock(&priv->ctx.mutex);
191 ret = regmap_encx24j600_spi_write(&priv->ctx, reg, data, count);
192 mutex_unlock(&priv->ctx.mutex);
193
194 return ret;
195}
196
197static void encx24j600_update_phcon1(struct encx24j600_priv *priv)
198{
199 u16 phcon1 = encx24j600_read_phy(priv, PHCON1);
200
201 if (priv->autoneg == AUTONEG_ENABLE) {
202 phcon1 |= ANEN | RENEG;
203 } else {
204 phcon1 &= ~ANEN;
205 if (priv->speed == SPEED_100)
206 phcon1 |= SPD100;
207 else
208 phcon1 &= ~SPD100;
209
210 if (priv->full_duplex)
211 phcon1 |= PFULDPX;
212 else
213 phcon1 &= ~PFULDPX;
214 }
215 encx24j600_write_phy(priv, PHCON1, phcon1);
216}
217
218/* Waits for autonegotiation to complete. */
219static int encx24j600_wait_for_autoneg(struct encx24j600_priv *priv)
220{
221 struct net_device *dev = priv->ndev;
222 unsigned long timeout = jiffies + msecs_to_jiffies(2000);
223 u16 phstat1;
224 u16 estat;
225 int ret = 0;
226
227 phstat1 = encx24j600_read_phy(priv, PHSTAT1);
228 while ((phstat1 & ANDONE) == 0) {
229 if (time_after(jiffies, timeout)) {
230 u16 phstat3;
231
232 netif_notice(priv, drv, dev, "timeout waiting for autoneg done\n");
233
234 priv->autoneg = AUTONEG_DISABLE;
235 phstat3 = encx24j600_read_phy(priv, PHSTAT3);
236 priv->speed = (phstat3 & PHY3SPD100)
237 ? SPEED_100 : SPEED_10;
238 priv->full_duplex = (phstat3 & PHY3DPX) ? 1 : 0;
239 encx24j600_update_phcon1(priv);
240 netif_notice(priv, drv, dev, "Using parallel detection: %s/%s",
241 priv->speed == SPEED_100 ? "100" : "10",
242 priv->full_duplex ? "Full" : "Half");
243
244 return -ETIMEDOUT;
245 }
246 cpu_relax();
247 phstat1 = encx24j600_read_phy(priv, PHSTAT1);
248 }
249
250 estat = encx24j600_read_reg(priv, ESTAT);
251 if (estat & PHYDPX) {
252 encx24j600_set_bits(priv, MACON2, FULDPX);
253 encx24j600_write_reg(priv, MABBIPG, 0x15);
254 } else {
255 encx24j600_clr_bits(priv, MACON2, FULDPX);
256 encx24j600_write_reg(priv, MABBIPG, 0x12);
257 /* Max retransmittions attempt */
258 encx24j600_write_reg(priv, MACLCON, 0x370f);
259 }
260
261 return ret;
262}
263
264/* Access the PHY to determine link status */
265static void encx24j600_check_link_status(struct encx24j600_priv *priv)
266{
267 struct net_device *dev = priv->ndev;
268 u16 estat;
269
270 estat = encx24j600_read_reg(priv, ESTAT);
271
272 if (estat & PHYLNK) {
273 if (priv->autoneg == AUTONEG_ENABLE)
274 encx24j600_wait_for_autoneg(priv);
275
276 netif_carrier_on(dev);
277 netif_info(priv, ifup, dev, "link up\n");
278 } else {
279 netif_info(priv, ifdown, dev, "link down\n");
280
281 /* Re-enable autoneg since we won't know what we might be
282 * connected to when the link is brought back up again.
283 */
284 priv->autoneg = AUTONEG_ENABLE;
285 priv->full_duplex = true;
286 priv->speed = SPEED_100;
287 netif_carrier_off(dev);
288 }
289}
290
291static void encx24j600_int_link_handler(struct encx24j600_priv *priv)
292{
293 struct net_device *dev = priv->ndev;
294
295 netif_dbg(priv, intr, dev, "%s", __func__);
296 encx24j600_check_link_status(priv);
297 encx24j600_clr_bits(priv, EIR, LINKIF);
298}
299
300static void encx24j600_tx_complete(struct encx24j600_priv *priv, bool err)
301{
302 struct net_device *dev = priv->ndev;
303
304 if (!priv->tx_skb) {
305 BUG();
306 return;
307 }
308
309 mutex_lock(&priv->lock);
310
311 if (err)
312 dev->stats.tx_errors++;
313 else
314 dev->stats.tx_packets++;
315
316 dev->stats.tx_bytes += priv->tx_skb->len;
317
318 encx24j600_clr_bits(priv, EIR, TXIF | TXABTIF);
319
320 netif_dbg(priv, tx_done, dev, "TX Done%s\n", err ? ": Err" : "");
321
322 dev_kfree_skb(priv->tx_skb);
323 priv->tx_skb = NULL;
324
325 netif_wake_queue(dev);
326
327 mutex_unlock(&priv->lock);
328}
329
330static int encx24j600_receive_packet(struct encx24j600_priv *priv,
331 struct rsv *rsv)
332{
333 struct net_device *dev = priv->ndev;
334 struct sk_buff *skb = netdev_alloc_skb(dev, rsv->len + NET_IP_ALIGN);
335
336 if (!skb) {
337 pr_err_ratelimited("RX: OOM: packet dropped\n");
338 dev->stats.rx_dropped++;
339 return -ENOMEM;
340 }
341 skb_reserve(skb, NET_IP_ALIGN);
342 encx24j600_raw_read(priv, RRXDATA, skb_put(skb, rsv->len), rsv->len);
343
344 if (netif_msg_pktdata(priv))
345 dump_packet("RX", skb->len, skb->data);
346
347 skb->dev = dev;
348 skb->protocol = eth_type_trans(skb, dev);
349 skb->ip_summed = CHECKSUM_COMPLETE;
350
351 /* Maintain stats */
352 dev->stats.rx_packets++;
353 dev->stats.rx_bytes += rsv->len;
354
355 netif_rx(skb);
356
357 return 0;
358}
359
360static void encx24j600_rx_packets(struct encx24j600_priv *priv, u8 packet_count)
361{
362 struct net_device *dev = priv->ndev;
363
364 while (packet_count--) {
365 struct rsv rsv;
366 u16 newrxtail;
367
368 encx24j600_write_reg(priv, ERXRDPT, priv->next_packet);
369 encx24j600_raw_read(priv, RRXDATA, (u8 *)&rsv, sizeof(rsv));
370
371 if (netif_msg_rx_status(priv))
372 encx24j600_dump_rsv(priv, __func__, &rsv);
373
374 if (!RSV_GETBIT(rsv.rxstat, RSV_RXOK) ||
375 (rsv.len > MAX_FRAMELEN)) {
376 netif_err(priv, rx_err, dev, "RX Error %04x\n",
377 rsv.rxstat);
378 dev->stats.rx_errors++;
379
380 if (RSV_GETBIT(rsv.rxstat, RSV_CRCERROR))
381 dev->stats.rx_crc_errors++;
382 if (RSV_GETBIT(rsv.rxstat, RSV_LENCHECKERR))
383 dev->stats.rx_frame_errors++;
384 if (rsv.len > MAX_FRAMELEN)
385 dev->stats.rx_over_errors++;
386 } else {
387 encx24j600_receive_packet(priv, &rsv);
388 }
389
390 priv->next_packet = rsv.next_packet;
391
392 newrxtail = priv->next_packet - 2;
393 if (newrxtail == ENC_RX_BUF_START)
394 newrxtail = SRAM_SIZE - 2;
395
396 encx24j600_cmd(priv, SETPKTDEC);
397 encx24j600_write_reg(priv, ERXTAIL, newrxtail);
398 }
399}
400
401static irqreturn_t encx24j600_isr(int irq, void *dev_id)
402{
403 struct encx24j600_priv *priv = dev_id;
404 struct net_device *dev = priv->ndev;
405 int eir;
406
407 /* Clear interrupts */
408 encx24j600_cmd(priv, CLREIE);
409
410 eir = encx24j600_read_reg(priv, EIR);
411
412 if (eir & LINKIF)
413 encx24j600_int_link_handler(priv);
414
415 if (eir & TXIF)
416 encx24j600_tx_complete(priv, false);
417
418 if (eir & TXABTIF)
419 encx24j600_tx_complete(priv, true);
420
421 if (eir & RXABTIF) {
422 if (eir & PCFULIF) {
423 /* Packet counter is full */
424 netif_err(priv, rx_err, dev, "Packet counter full\n");
425 }
426 dev->stats.rx_dropped++;
427 encx24j600_clr_bits(priv, EIR, RXABTIF);
428 }
429
430 if (eir & PKTIF) {
431 u8 packet_count;
432
433 mutex_lock(&priv->lock);
434
435 packet_count = encx24j600_read_reg(priv, ESTAT) & 0xff;
436 while (packet_count) {
437 encx24j600_rx_packets(priv, packet_count);
438 packet_count = encx24j600_read_reg(priv, ESTAT) & 0xff;
439 }
440
441 mutex_unlock(&priv->lock);
442 }
443
444 /* Enable interrupts */
445 encx24j600_cmd(priv, SETEIE);
446
447 return IRQ_HANDLED;
448}
449
450static int encx24j600_soft_reset(struct encx24j600_priv *priv)
451{
452 int ret = 0;
453 int timeout;
454 u16 eudast;
455
456 /* Write and verify a test value to EUDAST */
457 regcache_cache_bypass(priv->ctx.regmap, true);
458 timeout = 10;
459 do {
460 encx24j600_write_reg(priv, EUDAST, EUDAST_TEST_VAL);
461 eudast = encx24j600_read_reg(priv, EUDAST);
462 usleep_range(25, 100);
463 } while ((eudast != EUDAST_TEST_VAL) && --timeout);
464 regcache_cache_bypass(priv->ctx.regmap, false);
465
466 if (timeout == 0) {
467 ret = -ETIMEDOUT;
468 goto err_out;
469 }
470
471 /* Wait for CLKRDY to become set */
472 timeout = 10;
473 while (!(encx24j600_read_reg(priv, ESTAT) & CLKRDY) && --timeout)
474 usleep_range(25, 100);
475
476 if (timeout == 0) {
477 ret = -ETIMEDOUT;
478 goto err_out;
479 }
480
481 /* Issue a System Reset command */
482 encx24j600_cmd(priv, SETETHRST);
483 usleep_range(25, 100);
484
485 /* Confirm that EUDAST has 0000h after system reset */
486 if (encx24j600_read_reg(priv, EUDAST) != 0) {
487 ret = -EINVAL;
488 goto err_out;
489 }
490
491 /* Wait for PHY register and status bits to become available */
492 usleep_range(256, 1000);
493
494err_out:
495 return ret;
496}
497
498static int encx24j600_hw_reset(struct encx24j600_priv *priv)
499{
500 int ret;
501
502 mutex_lock(&priv->lock);
503 ret = encx24j600_soft_reset(priv);
504 mutex_unlock(&priv->lock);
505
506 return ret;
507}
508
509static void encx24j600_reset_hw_tx(struct encx24j600_priv *priv)
510{
511 encx24j600_set_bits(priv, ECON2, TXRST);
512 encx24j600_clr_bits(priv, ECON2, TXRST);
513}
514
515static void encx24j600_hw_init_tx(struct encx24j600_priv *priv)
516{
517 /* Reset TX */
518 encx24j600_reset_hw_tx(priv);
519
520 /* Clear the TXIF flag if were previously set */
521 encx24j600_clr_bits(priv, EIR, TXIF | TXABTIF);
522
523 /* Write the Tx Buffer pointer */
524 encx24j600_write_reg(priv, EGPWRPT, ENC_TX_BUF_START);
525}
526
527static void encx24j600_hw_init_rx(struct encx24j600_priv *priv)
528{
529 encx24j600_cmd(priv, DISABLERX);
530
531 /* Set up RX packet start address in the SRAM */
532 encx24j600_write_reg(priv, ERXST, ENC_RX_BUF_START);
533
534 /* Preload the RX Data pointer to the beginning of the RX area */
535 encx24j600_write_reg(priv, ERXRDPT, ENC_RX_BUF_START);
536
537 priv->next_packet = ENC_RX_BUF_START;
538
539 /* Set up RX end address in the SRAM */
540 encx24j600_write_reg(priv, ERXTAIL, ENC_SRAM_SIZE - 2);
541
542 /* Reset the user data pointers */
543 encx24j600_write_reg(priv, EUDAST, ENC_SRAM_SIZE);
544 encx24j600_write_reg(priv, EUDAND, ENC_SRAM_SIZE + 1);
545
546 /* Set Max Frame length */
547 encx24j600_write_reg(priv, MAMXFL, MAX_FRAMELEN);
548}
549
550static void encx24j600_dump_config(struct encx24j600_priv *priv,
551 const char *msg)
552{
553 pr_info(DRV_NAME ": %s\n", msg);
554
555 /* CHIP configuration */
556 pr_info(DRV_NAME " ECON1: %04X\n", encx24j600_read_reg(priv, ECON1));
557 pr_info(DRV_NAME " ECON2: %04X\n", encx24j600_read_reg(priv, ECON2));
558 pr_info(DRV_NAME " ERXFCON: %04X\n", encx24j600_read_reg(priv,
559 ERXFCON));
560 pr_info(DRV_NAME " ESTAT: %04X\n", encx24j600_read_reg(priv, ESTAT));
561 pr_info(DRV_NAME " EIR: %04X\n", encx24j600_read_reg(priv, EIR));
562 pr_info(DRV_NAME " EIDLED: %04X\n", encx24j600_read_reg(priv, EIDLED));
563
564 /* MAC layer configuration */
565 pr_info(DRV_NAME " MACON1: %04X\n", encx24j600_read_reg(priv, MACON1));
566 pr_info(DRV_NAME " MACON2: %04X\n", encx24j600_read_reg(priv, MACON2));
567 pr_info(DRV_NAME " MAIPG: %04X\n", encx24j600_read_reg(priv, MAIPG));
568 pr_info(DRV_NAME " MACLCON: %04X\n", encx24j600_read_reg(priv,
569 MACLCON));
570 pr_info(DRV_NAME " MABBIPG: %04X\n", encx24j600_read_reg(priv,
571 MABBIPG));
572
573 /* PHY configuation */
574 pr_info(DRV_NAME " PHCON1: %04X\n", encx24j600_read_phy(priv, PHCON1));
575 pr_info(DRV_NAME " PHCON2: %04X\n", encx24j600_read_phy(priv, PHCON2));
576 pr_info(DRV_NAME " PHANA: %04X\n", encx24j600_read_phy(priv, PHANA));
577 pr_info(DRV_NAME " PHANLPA: %04X\n", encx24j600_read_phy(priv,
578 PHANLPA));
579 pr_info(DRV_NAME " PHANE: %04X\n", encx24j600_read_phy(priv, PHANE));
580 pr_info(DRV_NAME " PHSTAT1: %04X\n", encx24j600_read_phy(priv,
581 PHSTAT1));
582 pr_info(DRV_NAME " PHSTAT2: %04X\n", encx24j600_read_phy(priv,
583 PHSTAT2));
584 pr_info(DRV_NAME " PHSTAT3: %04X\n", encx24j600_read_phy(priv,
585 PHSTAT3));
586}
587
588static void encx24j600_set_rxfilter_mode(struct encx24j600_priv *priv)
589{
590 switch (priv->rxfilter) {
591 case RXFILTER_PROMISC:
592 encx24j600_set_bits(priv, MACON1, PASSALL);
593 encx24j600_write_reg(priv, ERXFCON, UCEN | MCEN | NOTMEEN);
594 break;
595 case RXFILTER_MULTI:
596 encx24j600_clr_bits(priv, MACON1, PASSALL);
597 encx24j600_write_reg(priv, ERXFCON, UCEN | CRCEN | BCEN | MCEN);
598 break;
599 case RXFILTER_NORMAL:
600 default:
601 encx24j600_clr_bits(priv, MACON1, PASSALL);
602 encx24j600_write_reg(priv, ERXFCON, UCEN | CRCEN | BCEN);
603 break;
604 }
605}
606
607static int encx24j600_hw_init(struct encx24j600_priv *priv)
608{
609 int ret = 0;
610 u16 macon2;
611
612 priv->hw_enabled = false;
613
614 /* PHY Leds: link status,
615 * LEDA: Link State + collision events
616 * LEDB: Link State + transmit/receive events
617 */
618 encx24j600_update_reg(priv, EIDLED, 0xff00, 0xcb00);
619
620 /* Loopback disabled */
621 encx24j600_write_reg(priv, MACON1, 0x9);
622
623 /* interpacket gap value */
624 encx24j600_write_reg(priv, MAIPG, 0x0c12);
625
626 /* Write the auto negotiation pattern */
627 encx24j600_write_phy(priv, PHANA, PHANA_DEFAULT);
628
629 encx24j600_update_phcon1(priv);
630 encx24j600_check_link_status(priv);
631
632 macon2 = MACON2_RSV1 | TXCRCEN | PADCFG0 | PADCFG2 | MACON2_DEFER;
633 if ((priv->autoneg == AUTONEG_DISABLE) && priv->full_duplex)
634 macon2 |= FULDPX;
635
636 encx24j600_set_bits(priv, MACON2, macon2);
637
638 priv->rxfilter = RXFILTER_NORMAL;
639 encx24j600_set_rxfilter_mode(priv);
640
641 /* Program the Maximum frame length */
642 encx24j600_write_reg(priv, MAMXFL, MAX_FRAMELEN);
643
644 /* Init Tx pointers */
645 encx24j600_hw_init_tx(priv);
646
647 /* Init Rx pointers */
648 encx24j600_hw_init_rx(priv);
649
650 if (netif_msg_hw(priv))
651 encx24j600_dump_config(priv, "Hw is initialized");
652
653 return ret;
654}
655
656static void encx24j600_hw_enable(struct encx24j600_priv *priv)
657{
658 /* Clear the interrupt flags in case was set */
659 encx24j600_clr_bits(priv, EIR, (PCFULIF | RXABTIF | TXABTIF | TXIF |
660 PKTIF | LINKIF));
661
662 /* Enable the interrupts */
663 encx24j600_write_reg(priv, EIE, (PCFULIE | RXABTIE | TXABTIE | TXIE |
664 PKTIE | LINKIE | INTIE));
665
666 /* Enable RX */
667 encx24j600_cmd(priv, ENABLERX);
668
669 priv->hw_enabled = true;
670}
671
672static void encx24j600_hw_disable(struct encx24j600_priv *priv)
673{
674 /* Disable all interrupts */
675 encx24j600_write_reg(priv, EIE, 0);
676
677 /* Disable RX */
678 encx24j600_cmd(priv, DISABLERX);
679
680 priv->hw_enabled = false;
681}
682
683static int encx24j600_setlink(struct net_device *dev, u8 autoneg, u16 speed,
684 u8 duplex)
685{
686 struct encx24j600_priv *priv = netdev_priv(dev);
687 int ret = 0;
688
689 if (!priv->hw_enabled) {
690 /* link is in low power mode now; duplex setting
691 * will take effect on next encx24j600_hw_init()
692 */
693 if (speed == SPEED_10 || speed == SPEED_100) {
694 priv->autoneg = (autoneg == AUTONEG_ENABLE);
695 priv->full_duplex = (duplex == DUPLEX_FULL);
696 priv->speed = (speed == SPEED_100);
697 } else {
698 netif_warn(priv, link, dev, "unsupported link speed setting\n");
699 /*speeds other than SPEED_10 and SPEED_100 */
700 /*are not supported by chip */
701 ret = -EOPNOTSUPP;
702 }
703 } else {
704 netif_warn(priv, link, dev, "Warning: hw must be disabled to set link mode\n");
705 ret = -EBUSY;
706 }
707 return ret;
708}
709
710static void encx24j600_hw_get_macaddr(struct encx24j600_priv *priv,
711 unsigned char *ethaddr)
712{
713 unsigned short val;
714
715 val = encx24j600_read_reg(priv, MAADR1);
716
717 ethaddr[0] = val & 0x00ff;
718 ethaddr[1] = (val & 0xff00) >> 8;
719
720 val = encx24j600_read_reg(priv, MAADR2);
721
722 ethaddr[2] = val & 0x00ffU;
723 ethaddr[3] = (val & 0xff00U) >> 8;
724
725 val = encx24j600_read_reg(priv, MAADR3);
726
727 ethaddr[4] = val & 0x00ffU;
728 ethaddr[5] = (val & 0xff00U) >> 8;
729}
730
731/* Program the hardware MAC address from dev->dev_addr.*/
732static int encx24j600_set_hw_macaddr(struct net_device *dev)
733{
734 struct encx24j600_priv *priv = netdev_priv(dev);
735
736 if (priv->hw_enabled) {
737 netif_info(priv, drv, dev, "Hardware must be disabled to set Mac address\n");
738 return -EBUSY;
739 }
740
741 mutex_lock(&priv->lock);
742
743 netif_info(priv, drv, dev, "%s: Setting MAC address to %pM\n",
744 dev->name, dev->dev_addr);
745
746 encx24j600_write_reg(priv, MAADR3, (dev->dev_addr[4] |
747 dev->dev_addr[5] << 8));
748 encx24j600_write_reg(priv, MAADR2, (dev->dev_addr[2] |
749 dev->dev_addr[3] << 8));
750 encx24j600_write_reg(priv, MAADR1, (dev->dev_addr[0] |
751 dev->dev_addr[1] << 8));
752
753 mutex_unlock(&priv->lock);
754
755 return 0;
756}
757
758/* Store the new hardware address in dev->dev_addr, and update the MAC.*/
759static int encx24j600_set_mac_address(struct net_device *dev, void *addr)
760{
761 struct sockaddr *address = addr;
762
763 if (netif_running(dev))
764 return -EBUSY;
765 if (!is_valid_ether_addr(address->sa_data))
766 return -EADDRNOTAVAIL;
767
768 memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
769 return encx24j600_set_hw_macaddr(dev);
770}
771
772static int encx24j600_open(struct net_device *dev)
773{
774 struct encx24j600_priv *priv = netdev_priv(dev);
775
776 int ret = request_threaded_irq(priv->ctx.spi->irq, NULL, encx24j600_isr,
777 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
778 DRV_NAME, priv);
779 if (unlikely(ret < 0)) {
780 netdev_err(dev, "request irq %d failed (ret = %d)\n",
781 priv->ctx.spi->irq, ret);
782 return ret;
783 }
784
785 encx24j600_hw_disable(priv);
786 encx24j600_hw_init(priv);
787 encx24j600_hw_enable(priv);
788 netif_start_queue(dev);
789
790 return 0;
791}
792
793static int encx24j600_stop(struct net_device *dev)
794{
795 struct encx24j600_priv *priv = netdev_priv(dev);
796
797 netif_stop_queue(dev);
798 free_irq(priv->ctx.spi->irq, priv);
799 return 0;
800}
801
802static void encx24j600_setrx_proc(struct kthread_work *ws)
803{
804 struct encx24j600_priv *priv =
805 container_of(ws, struct encx24j600_priv, setrx_work);
806
807 mutex_lock(&priv->lock);
808 encx24j600_set_rxfilter_mode(priv);
809 mutex_unlock(&priv->lock);
810}
811
812static void encx24j600_set_multicast_list(struct net_device *dev)
813{
814 struct encx24j600_priv *priv = netdev_priv(dev);
815 int oldfilter = priv->rxfilter;
816
817 if (dev->flags & IFF_PROMISC) {
818 netif_dbg(priv, link, dev, "promiscuous mode\n");
819 priv->rxfilter = RXFILTER_PROMISC;
820 } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
821 netif_dbg(priv, link, dev, "%smulticast mode\n",
822 (dev->flags & IFF_ALLMULTI) ? "all-" : "");
823 priv->rxfilter = RXFILTER_MULTI;
824 } else {
825 netif_dbg(priv, link, dev, "normal mode\n");
826 priv->rxfilter = RXFILTER_NORMAL;
827 }
828
829 if (oldfilter != priv->rxfilter)
830 kthread_queue_work(&priv->kworker, &priv->setrx_work);
831}
832
833static void encx24j600_hw_tx(struct encx24j600_priv *priv)
834{
835 struct net_device *dev = priv->ndev;
836
837 netif_info(priv, tx_queued, dev, "TX Packet Len:%d\n",
838 priv->tx_skb->len);
839
840 if (netif_msg_pktdata(priv))
841 dump_packet("TX", priv->tx_skb->len, priv->tx_skb->data);
842
843 if (encx24j600_read_reg(priv, EIR) & TXABTIF)
844 /* Last transmition aborted due to error. Reset TX interface */
845 encx24j600_reset_hw_tx(priv);
846
847 /* Clear the TXIF flag if were previously set */
848 encx24j600_clr_bits(priv, EIR, TXIF);
849
850 /* Set the data pointer to the TX buffer address in the SRAM */
851 encx24j600_write_reg(priv, EGPWRPT, ENC_TX_BUF_START);
852
853 /* Copy the packet into the SRAM */
854 encx24j600_raw_write(priv, WGPDATA, (u8 *)priv->tx_skb->data,
855 priv->tx_skb->len);
856
857 /* Program the Tx buffer start pointer */
858 encx24j600_write_reg(priv, ETXST, ENC_TX_BUF_START);
859
860 /* Program the packet length */
861 encx24j600_write_reg(priv, ETXLEN, priv->tx_skb->len);
862
863 /* Start the transmission */
864 encx24j600_cmd(priv, SETTXRTS);
865}
866
867static void encx24j600_tx_proc(struct kthread_work *ws)
868{
869 struct encx24j600_priv *priv =
870 container_of(ws, struct encx24j600_priv, tx_work);
871
872 mutex_lock(&priv->lock);
873 encx24j600_hw_tx(priv);
874 mutex_unlock(&priv->lock);
875}
876
877static netdev_tx_t encx24j600_tx(struct sk_buff *skb, struct net_device *dev)
878{
879 struct encx24j600_priv *priv = netdev_priv(dev);
880
881 netif_stop_queue(dev);
882
883 /* save the timestamp */
884 netif_trans_update(dev);
885
886 /* Remember the skb for deferred processing */
887 priv->tx_skb = skb;
888
889 kthread_queue_work(&priv->kworker, &priv->tx_work);
890
891 return NETDEV_TX_OK;
892}
893
894/* Deal with a transmit timeout */
895static void encx24j600_tx_timeout(struct net_device *dev)
896{
897 struct encx24j600_priv *priv = netdev_priv(dev);
898
899 netif_err(priv, tx_err, dev, "TX timeout at %ld, latency %ld\n",
900 jiffies, jiffies - dev_trans_start(dev));
901
902 dev->stats.tx_errors++;
903 netif_wake_queue(dev);
904}
905
906static int encx24j600_get_regs_len(struct net_device *dev)
907{
908 return SFR_REG_COUNT;
909}
910
911static void encx24j600_get_regs(struct net_device *dev,
912 struct ethtool_regs *regs, void *p)
913{
914 struct encx24j600_priv *priv = netdev_priv(dev);
915 u16 *buff = p;
916 u8 reg;
917
918 regs->version = 1;
919 mutex_lock(&priv->lock);
920 for (reg = 0; reg < SFR_REG_COUNT; reg += 2) {
921 unsigned int val = 0;
922 /* ignore errors for unreadable registers */
923 regmap_read(priv->ctx.regmap, reg, &val);
924 buff[reg] = val & 0xffff;
925 }
926 mutex_unlock(&priv->lock);
927}
928
929static void encx24j600_get_drvinfo(struct net_device *dev,
930 struct ethtool_drvinfo *info)
931{
932 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
933 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
934 strlcpy(info->bus_info, dev_name(dev->dev.parent),
935 sizeof(info->bus_info));
936}
937
938static int encx24j600_get_link_ksettings(struct net_device *dev,
939 struct ethtool_link_ksettings *cmd)
940{
941 struct encx24j600_priv *priv = netdev_priv(dev);
942 u32 supported;
943
944 supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
945 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
946 SUPPORTED_Autoneg | SUPPORTED_TP;
947
948 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
949 supported);
950
951 cmd->base.speed = priv->speed;
952 cmd->base.duplex = priv->full_duplex ? DUPLEX_FULL : DUPLEX_HALF;
953 cmd->base.port = PORT_TP;
954 cmd->base.autoneg = priv->autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
955
956 return 0;
957}
958
959static int
960encx24j600_set_link_ksettings(struct net_device *dev,
961 const struct ethtool_link_ksettings *cmd)
962{
963 return encx24j600_setlink(dev, cmd->base.autoneg,
964 cmd->base.speed, cmd->base.duplex);
965}
966
967static u32 encx24j600_get_msglevel(struct net_device *dev)
968{
969 struct encx24j600_priv *priv = netdev_priv(dev);
970
971 return priv->msg_enable;
972}
973
974static void encx24j600_set_msglevel(struct net_device *dev, u32 val)
975{
976 struct encx24j600_priv *priv = netdev_priv(dev);
977
978 priv->msg_enable = val;
979}
980
981static const struct ethtool_ops encx24j600_ethtool_ops = {
982 .get_drvinfo = encx24j600_get_drvinfo,
983 .get_msglevel = encx24j600_get_msglevel,
984 .set_msglevel = encx24j600_set_msglevel,
985 .get_regs_len = encx24j600_get_regs_len,
986 .get_regs = encx24j600_get_regs,
987 .get_link_ksettings = encx24j600_get_link_ksettings,
988 .set_link_ksettings = encx24j600_set_link_ksettings,
989};
990
991static const struct net_device_ops encx24j600_netdev_ops = {
992 .ndo_open = encx24j600_open,
993 .ndo_stop = encx24j600_stop,
994 .ndo_start_xmit = encx24j600_tx,
995 .ndo_set_rx_mode = encx24j600_set_multicast_list,
996 .ndo_set_mac_address = encx24j600_set_mac_address,
997 .ndo_tx_timeout = encx24j600_tx_timeout,
998 .ndo_validate_addr = eth_validate_addr,
999};
1000
1001static int encx24j600_spi_probe(struct spi_device *spi)
1002{
1003 int ret;
1004
1005 struct net_device *ndev;
1006 struct encx24j600_priv *priv;
1007 u16 eidled;
1008
1009 ndev = alloc_etherdev(sizeof(struct encx24j600_priv));
1010
1011 if (!ndev) {
1012 ret = -ENOMEM;
1013 goto error_out;
1014 }
1015
1016 priv = netdev_priv(ndev);
1017 spi_set_drvdata(spi, priv);
1018 dev_set_drvdata(&spi->dev, priv);
1019 SET_NETDEV_DEV(ndev, &spi->dev);
1020
1021 priv->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
1022 priv->ndev = ndev;
1023
1024 /* Default configuration PHY configuration */
1025 priv->full_duplex = true;
1026 priv->autoneg = AUTONEG_ENABLE;
1027 priv->speed = SPEED_100;
1028
1029 priv->ctx.spi = spi;
1030 devm_regmap_init_encx24j600(&spi->dev, &priv->ctx);
1031 ndev->irq = spi->irq;
1032 ndev->netdev_ops = &encx24j600_netdev_ops;
1033
1034 mutex_init(&priv->lock);
1035
1036 /* Reset device and check if it is connected */
1037 if (encx24j600_hw_reset(priv)) {
1038 netif_err(priv, probe, ndev,
1039 DRV_NAME ": Chip is not detected\n");
1040 ret = -EIO;
1041 goto out_free;
1042 }
1043
1044 /* Initialize the device HW to the consistent state */
1045 if (encx24j600_hw_init(priv)) {
1046 netif_err(priv, probe, ndev,
1047 DRV_NAME ": HW initialization error\n");
1048 ret = -EIO;
1049 goto out_free;
1050 }
1051
1052 kthread_init_worker(&priv->kworker);
1053 kthread_init_work(&priv->tx_work, encx24j600_tx_proc);
1054 kthread_init_work(&priv->setrx_work, encx24j600_setrx_proc);
1055
1056 priv->kworker_task = kthread_run(kthread_worker_fn, &priv->kworker,
1057 "encx24j600");
1058
1059 if (IS_ERR(priv->kworker_task)) {
1060 ret = PTR_ERR(priv->kworker_task);
1061 goto out_free;
1062 }
1063
1064 /* Get the MAC address from the chip */
1065 encx24j600_hw_get_macaddr(priv, ndev->dev_addr);
1066
1067 ndev->ethtool_ops = &encx24j600_ethtool_ops;
1068
1069 ret = register_netdev(ndev);
1070 if (unlikely(ret)) {
1071 netif_err(priv, probe, ndev, "Error %d initializing card encx24j600 card\n",
1072 ret);
1073 goto out_free;
1074 }
1075
1076 eidled = encx24j600_read_reg(priv, EIDLED);
1077 if (((eidled & DEVID_MASK) >> DEVID_SHIFT) != ENCX24J600_DEV_ID) {
1078 ret = -EINVAL;
1079 goto out_unregister;
1080 }
1081
1082 netif_info(priv, probe, ndev, "Silicon rev ID: 0x%02x\n",
1083 (eidled & REVID_MASK) >> REVID_SHIFT);
1084
1085 netif_info(priv, drv, priv->ndev, "MAC address %pM\n", ndev->dev_addr);
1086
1087 return ret;
1088
1089out_unregister:
1090 unregister_netdev(priv->ndev);
1091out_free:
1092 free_netdev(ndev);
1093
1094error_out:
1095 return ret;
1096}
1097
1098static int encx24j600_spi_remove(struct spi_device *spi)
1099{
1100 struct encx24j600_priv *priv = dev_get_drvdata(&spi->dev);
1101
1102 unregister_netdev(priv->ndev);
1103
1104 free_netdev(priv->ndev);
1105
1106 return 0;
1107}
1108
1109static const struct spi_device_id encx24j600_spi_id_table[] = {
1110 { .name = "encx24j600" },
1111 { /* sentinel */ }
1112};
1113MODULE_DEVICE_TABLE(spi, encx24j600_spi_id_table);
1114
1115static struct spi_driver encx24j600_spi_net_driver = {
1116 .driver = {
1117 .name = DRV_NAME,
1118 .owner = THIS_MODULE,
1119 .bus = &spi_bus_type,
1120 },
1121 .probe = encx24j600_spi_probe,
1122 .remove = encx24j600_spi_remove,
1123 .id_table = encx24j600_spi_id_table,
1124};
1125
1126static int __init encx24j600_init(void)
1127{
1128 return spi_register_driver(&encx24j600_spi_net_driver);
1129}
1130module_init(encx24j600_init);
1131
1132static void encx24j600_exit(void)
1133{
1134 spi_unregister_driver(&encx24j600_spi_net_driver);
1135}
1136module_exit(encx24j600_exit);
1137
1138MODULE_DESCRIPTION(DRV_NAME " ethernet driver");
1139MODULE_AUTHOR("Jon Ringle <jringle@gridpoint.com>");
1140MODULE_LICENSE("GPL");
1141MODULE_ALIAS("spi:" DRV_NAME);
1/**
2 * Microchip ENCX24J600 ethernet driver
3 *
4 * Copyright (C) 2015 Gridpoint
5 * Author: Jon Ringle <jringle@gridpoint.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 */
13
14#include <linux/device.h>
15#include <linux/errno.h>
16#include <linux/etherdevice.h>
17#include <linux/ethtool.h>
18#include <linux/interrupt.h>
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/netdevice.h>
22#include <linux/regmap.h>
23#include <linux/skbuff.h>
24#include <linux/spi/spi.h>
25
26#include "encx24j600_hw.h"
27
28#define DRV_NAME "encx24j600"
29#define DRV_VERSION "1.0"
30
31#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)
32static int debug = -1;
33module_param(debug, int, 0);
34MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
35
36/* SRAM memory layout:
37 *
38 * 0x0000-0x05ff TX buffers 1.5KB (1*1536) reside in the GP area in SRAM
39 * 0x0600-0x5fff RX buffers 22.5KB (15*1536) reside in the RX area in SRAM
40 */
41#define ENC_TX_BUF_START 0x0000U
42#define ENC_RX_BUF_START 0x0600U
43#define ENC_RX_BUF_END 0x5fffU
44#define ENC_SRAM_SIZE 0x6000U
45
46enum {
47 RXFILTER_NORMAL,
48 RXFILTER_MULTI,
49 RXFILTER_PROMISC
50};
51
52struct encx24j600_priv {
53 struct net_device *ndev;
54 struct mutex lock; /* device access lock */
55 struct encx24j600_context ctx;
56 struct sk_buff *tx_skb;
57 struct task_struct *kworker_task;
58 struct kthread_worker kworker;
59 struct kthread_work tx_work;
60 struct kthread_work setrx_work;
61 u16 next_packet;
62 bool hw_enabled;
63 bool full_duplex;
64 bool autoneg;
65 u16 speed;
66 int rxfilter;
67 u32 msg_enable;
68};
69
70static void dump_packet(const char *msg, int len, const char *data)
71{
72 pr_debug(DRV_NAME ": %s - packet len:%d\n", msg, len);
73 print_hex_dump_bytes("pk data: ", DUMP_PREFIX_OFFSET, data, len);
74}
75
76static void encx24j600_dump_rsv(struct encx24j600_priv *priv, const char *msg,
77 struct rsv *rsv)
78{
79 struct net_device *dev = priv->ndev;
80
81 netdev_info(dev, "RX packet Len:%d\n", rsv->len);
82 netdev_dbg(dev, "%s - NextPk: 0x%04x\n", msg,
83 rsv->next_packet);
84 netdev_dbg(dev, "RxOK: %d, DribbleNibble: %d\n",
85 RSV_GETBIT(rsv->rxstat, RSV_RXOK),
86 RSV_GETBIT(rsv->rxstat, RSV_DRIBBLENIBBLE));
87 netdev_dbg(dev, "CRCErr:%d, LenChkErr: %d, LenOutOfRange: %d\n",
88 RSV_GETBIT(rsv->rxstat, RSV_CRCERROR),
89 RSV_GETBIT(rsv->rxstat, RSV_LENCHECKERR),
90 RSV_GETBIT(rsv->rxstat, RSV_LENOUTOFRANGE));
91 netdev_dbg(dev, "Multicast: %d, Broadcast: %d, LongDropEvent: %d, CarrierEvent: %d\n",
92 RSV_GETBIT(rsv->rxstat, RSV_RXMULTICAST),
93 RSV_GETBIT(rsv->rxstat, RSV_RXBROADCAST),
94 RSV_GETBIT(rsv->rxstat, RSV_RXLONGEVDROPEV),
95 RSV_GETBIT(rsv->rxstat, RSV_CARRIEREV));
96 netdev_dbg(dev, "ControlFrame: %d, PauseFrame: %d, UnknownOp: %d, VLanTagFrame: %d\n",
97 RSV_GETBIT(rsv->rxstat, RSV_RXCONTROLFRAME),
98 RSV_GETBIT(rsv->rxstat, RSV_RXPAUSEFRAME),
99 RSV_GETBIT(rsv->rxstat, RSV_RXUNKNOWNOPCODE),
100 RSV_GETBIT(rsv->rxstat, RSV_RXTYPEVLAN));
101}
102
103static u16 encx24j600_read_reg(struct encx24j600_priv *priv, u8 reg)
104{
105 struct net_device *dev = priv->ndev;
106 unsigned int val = 0;
107 int ret = regmap_read(priv->ctx.regmap, reg, &val);
108 if (unlikely(ret))
109 netif_err(priv, drv, dev, "%s: error %d reading reg %02x\n",
110 __func__, ret, reg);
111 return val;
112}
113
114static void encx24j600_write_reg(struct encx24j600_priv *priv, u8 reg, u16 val)
115{
116 struct net_device *dev = priv->ndev;
117 int ret = regmap_write(priv->ctx.regmap, reg, val);
118 if (unlikely(ret))
119 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
120 __func__, ret, reg, val);
121}
122
123static void encx24j600_update_reg(struct encx24j600_priv *priv, u8 reg,
124 u16 mask, u16 val)
125{
126 struct net_device *dev = priv->ndev;
127 int ret = regmap_update_bits(priv->ctx.regmap, reg, mask, val);
128 if (unlikely(ret))
129 netif_err(priv, drv, dev, "%s: error %d updating reg %02x=%04x~%04x\n",
130 __func__, ret, reg, val, mask);
131}
132
133static u16 encx24j600_read_phy(struct encx24j600_priv *priv, u8 reg)
134{
135 struct net_device *dev = priv->ndev;
136 unsigned int val = 0;
137 int ret = regmap_read(priv->ctx.phymap, reg, &val);
138 if (unlikely(ret))
139 netif_err(priv, drv, dev, "%s: error %d reading %02x\n",
140 __func__, ret, reg);
141 return val;
142}
143
144static void encx24j600_write_phy(struct encx24j600_priv *priv, u8 reg, u16 val)
145{
146 struct net_device *dev = priv->ndev;
147 int ret = regmap_write(priv->ctx.phymap, reg, val);
148 if (unlikely(ret))
149 netif_err(priv, drv, dev, "%s: error %d writing reg %02x=%04x\n",
150 __func__, ret, reg, val);
151}
152
153static void encx24j600_clr_bits(struct encx24j600_priv *priv, u8 reg, u16 mask)
154{
155 encx24j600_update_reg(priv, reg, mask, 0);
156}
157
158static void encx24j600_set_bits(struct encx24j600_priv *priv, u8 reg, u16 mask)
159{
160 encx24j600_update_reg(priv, reg, mask, mask);
161}
162
163static void encx24j600_cmd(struct encx24j600_priv *priv, u8 cmd)
164{
165 struct net_device *dev = priv->ndev;
166 int ret = regmap_write(priv->ctx.regmap, cmd, 0);
167 if (unlikely(ret))
168 netif_err(priv, drv, dev, "%s: error %d with cmd %02x\n",
169 __func__, ret, cmd);
170}
171
172static int encx24j600_raw_read(struct encx24j600_priv *priv, u8 reg, u8 *data,
173 size_t count)
174{
175 int ret;
176 mutex_lock(&priv->ctx.mutex);
177 ret = regmap_encx24j600_spi_read(&priv->ctx, reg, data, count);
178 mutex_unlock(&priv->ctx.mutex);
179
180 return ret;
181}
182
183static int encx24j600_raw_write(struct encx24j600_priv *priv, u8 reg,
184 const u8 *data, size_t count)
185{
186 int ret;
187 mutex_lock(&priv->ctx.mutex);
188 ret = regmap_encx24j600_spi_write(&priv->ctx, reg, data, count);
189 mutex_unlock(&priv->ctx.mutex);
190
191 return ret;
192}
193
194static void encx24j600_update_phcon1(struct encx24j600_priv *priv)
195{
196 u16 phcon1 = encx24j600_read_phy(priv, PHCON1);
197 if (priv->autoneg == AUTONEG_ENABLE) {
198 phcon1 |= ANEN | RENEG;
199 } else {
200 phcon1 &= ~ANEN;
201 if (priv->speed == SPEED_100)
202 phcon1 |= SPD100;
203 else
204 phcon1 &= ~SPD100;
205
206 if (priv->full_duplex)
207 phcon1 |= PFULDPX;
208 else
209 phcon1 &= ~PFULDPX;
210 }
211 encx24j600_write_phy(priv, PHCON1, phcon1);
212}
213
214/* Waits for autonegotiation to complete. */
215static int encx24j600_wait_for_autoneg(struct encx24j600_priv *priv)
216{
217 struct net_device *dev = priv->ndev;
218 unsigned long timeout = jiffies + msecs_to_jiffies(2000);
219 u16 phstat1;
220 u16 estat;
221 int ret = 0;
222
223 phstat1 = encx24j600_read_phy(priv, PHSTAT1);
224 while ((phstat1 & ANDONE) == 0) {
225 if (time_after(jiffies, timeout)) {
226 u16 phstat3;
227
228 netif_notice(priv, drv, dev, "timeout waiting for autoneg done\n");
229
230 priv->autoneg = AUTONEG_DISABLE;
231 phstat3 = encx24j600_read_phy(priv, PHSTAT3);
232 priv->speed = (phstat3 & PHY3SPD100)
233 ? SPEED_100 : SPEED_10;
234 priv->full_duplex = (phstat3 & PHY3DPX) ? 1 : 0;
235 encx24j600_update_phcon1(priv);
236 netif_notice(priv, drv, dev, "Using parallel detection: %s/%s",
237 priv->speed == SPEED_100 ? "100" : "10",
238 priv->full_duplex ? "Full" : "Half");
239
240 return -ETIMEDOUT;
241 }
242 cpu_relax();
243 phstat1 = encx24j600_read_phy(priv, PHSTAT1);
244 }
245
246 estat = encx24j600_read_reg(priv, ESTAT);
247 if (estat & PHYDPX) {
248 encx24j600_set_bits(priv, MACON2, FULDPX);
249 encx24j600_write_reg(priv, MABBIPG, 0x15);
250 } else {
251 encx24j600_clr_bits(priv, MACON2, FULDPX);
252 encx24j600_write_reg(priv, MABBIPG, 0x12);
253 /* Max retransmittions attempt */
254 encx24j600_write_reg(priv, MACLCON, 0x370f);
255 }
256
257 return ret;
258}
259
260/* Access the PHY to determine link status */
261static void encx24j600_check_link_status(struct encx24j600_priv *priv)
262{
263 struct net_device *dev = priv->ndev;
264 u16 estat;
265
266 estat = encx24j600_read_reg(priv, ESTAT);
267
268 if (estat & PHYLNK) {
269 if (priv->autoneg == AUTONEG_ENABLE)
270 encx24j600_wait_for_autoneg(priv);
271
272 netif_carrier_on(dev);
273 netif_info(priv, ifup, dev, "link up\n");
274 } else {
275 netif_info(priv, ifdown, dev, "link down\n");
276
277 /* Re-enable autoneg since we won't know what we might be
278 * connected to when the link is brought back up again.
279 */
280 priv->autoneg = AUTONEG_ENABLE;
281 priv->full_duplex = true;
282 priv->speed = SPEED_100;
283 netif_carrier_off(dev);
284 }
285}
286
287static void encx24j600_int_link_handler(struct encx24j600_priv *priv)
288{
289 struct net_device *dev = priv->ndev;
290
291 netif_dbg(priv, intr, dev, "%s", __func__);
292 encx24j600_check_link_status(priv);
293 encx24j600_clr_bits(priv, EIR, LINKIF);
294}
295
296static void encx24j600_tx_complete(struct encx24j600_priv *priv, bool err)
297{
298 struct net_device *dev = priv->ndev;
299
300 if (!priv->tx_skb) {
301 BUG();
302 return;
303 }
304
305 mutex_lock(&priv->lock);
306
307 if (err)
308 dev->stats.tx_errors++;
309 else
310 dev->stats.tx_packets++;
311
312 dev->stats.tx_bytes += priv->tx_skb->len;
313
314 encx24j600_clr_bits(priv, EIR, TXIF | TXABTIF);
315
316 netif_dbg(priv, tx_done, dev, "TX Done%s\n", err ? ": Err" : "");
317
318 dev_kfree_skb(priv->tx_skb);
319 priv->tx_skb = NULL;
320
321 netif_wake_queue(dev);
322
323 mutex_unlock(&priv->lock);
324}
325
326static int encx24j600_receive_packet(struct encx24j600_priv *priv,
327 struct rsv *rsv)
328{
329 struct net_device *dev = priv->ndev;
330 struct sk_buff *skb = netdev_alloc_skb(dev, rsv->len + NET_IP_ALIGN);
331 if (!skb) {
332 pr_err_ratelimited("RX: OOM: packet dropped\n");
333 dev->stats.rx_dropped++;
334 return -ENOMEM;
335 }
336 skb_reserve(skb, NET_IP_ALIGN);
337 encx24j600_raw_read(priv, RRXDATA, skb_put(skb, rsv->len), rsv->len);
338
339 if (netif_msg_pktdata(priv))
340 dump_packet("RX", skb->len, skb->data);
341
342 skb->dev = dev;
343 skb->protocol = eth_type_trans(skb, dev);
344 skb->ip_summed = CHECKSUM_COMPLETE;
345
346 /* Maintain stats */
347 dev->stats.rx_packets++;
348 dev->stats.rx_bytes += rsv->len;
349 priv->next_packet = rsv->next_packet;
350
351 netif_rx(skb);
352
353 return 0;
354}
355
356static void encx24j600_rx_packets(struct encx24j600_priv *priv, u8 packet_count)
357{
358 struct net_device *dev = priv->ndev;
359
360 while (packet_count--) {
361 struct rsv rsv;
362 u16 newrxtail;
363
364 encx24j600_write_reg(priv, ERXRDPT, priv->next_packet);
365 encx24j600_raw_read(priv, RRXDATA, (u8 *)&rsv, sizeof(rsv));
366
367 if (netif_msg_rx_status(priv))
368 encx24j600_dump_rsv(priv, __func__, &rsv);
369
370 if (!RSV_GETBIT(rsv.rxstat, RSV_RXOK) ||
371 (rsv.len > MAX_FRAMELEN)) {
372 netif_err(priv, rx_err, dev, "RX Error %04x\n",
373 rsv.rxstat);
374 dev->stats.rx_errors++;
375
376 if (RSV_GETBIT(rsv.rxstat, RSV_CRCERROR))
377 dev->stats.rx_crc_errors++;
378 if (RSV_GETBIT(rsv.rxstat, RSV_LENCHECKERR))
379 dev->stats.rx_frame_errors++;
380 if (rsv.len > MAX_FRAMELEN)
381 dev->stats.rx_over_errors++;
382 } else {
383 encx24j600_receive_packet(priv, &rsv);
384 }
385
386 newrxtail = priv->next_packet - 2;
387 if (newrxtail == ENC_RX_BUF_START)
388 newrxtail = SRAM_SIZE - 2;
389
390 encx24j600_cmd(priv, SETPKTDEC);
391 encx24j600_write_reg(priv, ERXTAIL, newrxtail);
392 }
393}
394
395static irqreturn_t encx24j600_isr(int irq, void *dev_id)
396{
397 struct encx24j600_priv *priv = dev_id;
398 struct net_device *dev = priv->ndev;
399 int eir;
400
401 /* Clear interrupts */
402 encx24j600_cmd(priv, CLREIE);
403
404 eir = encx24j600_read_reg(priv, EIR);
405
406 if (eir & LINKIF)
407 encx24j600_int_link_handler(priv);
408
409 if (eir & TXIF)
410 encx24j600_tx_complete(priv, false);
411
412 if (eir & TXABTIF)
413 encx24j600_tx_complete(priv, true);
414
415 if (eir & RXABTIF) {
416 if (eir & PCFULIF) {
417 /* Packet counter is full */
418 netif_err(priv, rx_err, dev, "Packet counter full\n");
419 }
420 dev->stats.rx_dropped++;
421 encx24j600_clr_bits(priv, EIR, RXABTIF);
422 }
423
424 if (eir & PKTIF) {
425 u8 packet_count;
426
427 mutex_lock(&priv->lock);
428
429 packet_count = encx24j600_read_reg(priv, ESTAT) & 0xff;
430 while (packet_count) {
431 encx24j600_rx_packets(priv, packet_count);
432 packet_count = encx24j600_read_reg(priv, ESTAT) & 0xff;
433 }
434
435 mutex_unlock(&priv->lock);
436 }
437
438 /* Enable interrupts */
439 encx24j600_cmd(priv, SETEIE);
440
441 return IRQ_HANDLED;
442}
443
444static int encx24j600_soft_reset(struct encx24j600_priv *priv)
445{
446 int ret = 0;
447 int timeout;
448 u16 eudast;
449
450 /* Write and verify a test value to EUDAST */
451 regcache_cache_bypass(priv->ctx.regmap, true);
452 timeout = 10;
453 do {
454 encx24j600_write_reg(priv, EUDAST, EUDAST_TEST_VAL);
455 eudast = encx24j600_read_reg(priv, EUDAST);
456 usleep_range(25, 100);
457 } while ((eudast != EUDAST_TEST_VAL) && --timeout);
458 regcache_cache_bypass(priv->ctx.regmap, false);
459
460 if (timeout == 0) {
461 ret = -ETIMEDOUT;
462 goto err_out;
463 }
464
465 /* Wait for CLKRDY to become set */
466 timeout = 10;
467 while (!(encx24j600_read_reg(priv, ESTAT) & CLKRDY) && --timeout)
468 usleep_range(25, 100);
469
470 if (timeout == 0) {
471 ret = -ETIMEDOUT;
472 goto err_out;
473 }
474
475 /* Issue a System Reset command */
476 encx24j600_cmd(priv, SETETHRST);
477 usleep_range(25, 100);
478
479 /* Confirm that EUDAST has 0000h after system reset */
480 if (encx24j600_read_reg(priv, EUDAST) != 0) {
481 ret = -EINVAL;
482 goto err_out;
483 }
484
485 /* Wait for PHY register and status bits to become available */
486 usleep_range(256, 1000);
487
488err_out:
489 return ret;
490}
491
492static int encx24j600_hw_reset(struct encx24j600_priv *priv)
493{
494 int ret;
495
496 mutex_lock(&priv->lock);
497 ret = encx24j600_soft_reset(priv);
498 mutex_unlock(&priv->lock);
499
500 return ret;
501}
502
503static void encx24j600_reset_hw_tx(struct encx24j600_priv *priv)
504{
505 encx24j600_set_bits(priv, ECON2, TXRST);
506 encx24j600_clr_bits(priv, ECON2, TXRST);
507}
508
509static void encx24j600_hw_init_tx(struct encx24j600_priv *priv)
510{
511 /* Reset TX */
512 encx24j600_reset_hw_tx(priv);
513
514 /* Clear the TXIF flag if were previously set */
515 encx24j600_clr_bits(priv, EIR, TXIF | TXABTIF);
516
517 /* Write the Tx Buffer pointer */
518 encx24j600_write_reg(priv, EGPWRPT, ENC_TX_BUF_START);
519}
520
521static void encx24j600_hw_init_rx(struct encx24j600_priv *priv)
522{
523 encx24j600_cmd(priv, DISABLERX);
524
525 /* Set up RX packet start address in the SRAM */
526 encx24j600_write_reg(priv, ERXST, ENC_RX_BUF_START);
527
528 /* Preload the RX Data pointer to the beginning of the RX area */
529 encx24j600_write_reg(priv, ERXRDPT, ENC_RX_BUF_START);
530
531 priv->next_packet = ENC_RX_BUF_START;
532
533 /* Set up RX end address in the SRAM */
534 encx24j600_write_reg(priv, ERXTAIL, ENC_SRAM_SIZE - 2);
535
536 /* Reset the user data pointers */
537 encx24j600_write_reg(priv, EUDAST, ENC_SRAM_SIZE);
538 encx24j600_write_reg(priv, EUDAND, ENC_SRAM_SIZE + 1);
539
540 /* Set Max Frame length */
541 encx24j600_write_reg(priv, MAMXFL, MAX_FRAMELEN);
542}
543
544static void encx24j600_dump_config(struct encx24j600_priv *priv,
545 const char *msg)
546{
547 pr_info(DRV_NAME ": %s\n", msg);
548
549 /* CHIP configuration */
550 pr_info(DRV_NAME " ECON1: %04X\n", encx24j600_read_reg(priv, ECON1));
551 pr_info(DRV_NAME " ECON2: %04X\n", encx24j600_read_reg(priv, ECON2));
552 pr_info(DRV_NAME " ERXFCON: %04X\n", encx24j600_read_reg(priv,
553 ERXFCON));
554 pr_info(DRV_NAME " ESTAT: %04X\n", encx24j600_read_reg(priv, ESTAT));
555 pr_info(DRV_NAME " EIR: %04X\n", encx24j600_read_reg(priv, EIR));
556 pr_info(DRV_NAME " EIDLED: %04X\n", encx24j600_read_reg(priv, EIDLED));
557
558 /* MAC layer configuration */
559 pr_info(DRV_NAME " MACON1: %04X\n", encx24j600_read_reg(priv, MACON1));
560 pr_info(DRV_NAME " MACON2: %04X\n", encx24j600_read_reg(priv, MACON2));
561 pr_info(DRV_NAME " MAIPG: %04X\n", encx24j600_read_reg(priv, MAIPG));
562 pr_info(DRV_NAME " MACLCON: %04X\n", encx24j600_read_reg(priv,
563 MACLCON));
564 pr_info(DRV_NAME " MABBIPG: %04X\n", encx24j600_read_reg(priv,
565 MABBIPG));
566
567 /* PHY configuation */
568 pr_info(DRV_NAME " PHCON1: %04X\n", encx24j600_read_phy(priv, PHCON1));
569 pr_info(DRV_NAME " PHCON2: %04X\n", encx24j600_read_phy(priv, PHCON2));
570 pr_info(DRV_NAME " PHANA: %04X\n", encx24j600_read_phy(priv, PHANA));
571 pr_info(DRV_NAME " PHANLPA: %04X\n", encx24j600_read_phy(priv,
572 PHANLPA));
573 pr_info(DRV_NAME " PHANE: %04X\n", encx24j600_read_phy(priv, PHANE));
574 pr_info(DRV_NAME " PHSTAT1: %04X\n", encx24j600_read_phy(priv,
575 PHSTAT1));
576 pr_info(DRV_NAME " PHSTAT2: %04X\n", encx24j600_read_phy(priv,
577 PHSTAT2));
578 pr_info(DRV_NAME " PHSTAT3: %04X\n", encx24j600_read_phy(priv,
579 PHSTAT3));
580}
581
582static void encx24j600_set_rxfilter_mode(struct encx24j600_priv *priv)
583{
584 switch (priv->rxfilter) {
585 case RXFILTER_PROMISC:
586 encx24j600_set_bits(priv, MACON1, PASSALL);
587 encx24j600_write_reg(priv, ERXFCON, UCEN | MCEN | NOTMEEN);
588 break;
589 case RXFILTER_MULTI:
590 encx24j600_clr_bits(priv, MACON1, PASSALL);
591 encx24j600_write_reg(priv, ERXFCON, UCEN | CRCEN | BCEN | MCEN);
592 break;
593 case RXFILTER_NORMAL:
594 default:
595 encx24j600_clr_bits(priv, MACON1, PASSALL);
596 encx24j600_write_reg(priv, ERXFCON, UCEN | CRCEN | BCEN);
597 break;
598 }
599}
600
601static int encx24j600_hw_init(struct encx24j600_priv *priv)
602{
603 int ret = 0;
604 u16 macon2;
605
606 priv->hw_enabled = false;
607
608 /* PHY Leds: link status,
609 * LEDA: Link State + collision events
610 * LEDB: Link State + transmit/receive events
611 */
612 encx24j600_update_reg(priv, EIDLED, 0xff00, 0xcb00);
613
614 /* Loopback disabled */
615 encx24j600_write_reg(priv, MACON1, 0x9);
616
617 /* interpacket gap value */
618 encx24j600_write_reg(priv, MAIPG, 0x0c12);
619
620 /* Write the auto negotiation pattern */
621 encx24j600_write_phy(priv, PHANA, PHANA_DEFAULT);
622
623 encx24j600_update_phcon1(priv);
624 encx24j600_check_link_status(priv);
625
626 macon2 = MACON2_RSV1 | TXCRCEN | PADCFG0 | PADCFG2 | MACON2_DEFER;
627 if ((priv->autoneg == AUTONEG_DISABLE) && priv->full_duplex)
628 macon2 |= FULDPX;
629
630 encx24j600_set_bits(priv, MACON2, macon2);
631
632 priv->rxfilter = RXFILTER_NORMAL;
633 encx24j600_set_rxfilter_mode(priv);
634
635 /* Program the Maximum frame length */
636 encx24j600_write_reg(priv, MAMXFL, MAX_FRAMELEN);
637
638 /* Init Tx pointers */
639 encx24j600_hw_init_tx(priv);
640
641 /* Init Rx pointers */
642 encx24j600_hw_init_rx(priv);
643
644 if (netif_msg_hw(priv))
645 encx24j600_dump_config(priv, "Hw is initialized");
646
647 return ret;
648}
649
650static void encx24j600_hw_enable(struct encx24j600_priv *priv)
651{
652 /* Clear the interrupt flags in case was set */
653 encx24j600_clr_bits(priv, EIR, (PCFULIF | RXABTIF | TXABTIF | TXIF |
654 PKTIF | LINKIF));
655
656 /* Enable the interrupts */
657 encx24j600_write_reg(priv, EIE, (PCFULIE | RXABTIE | TXABTIE | TXIE |
658 PKTIE | LINKIE | INTIE));
659
660 /* Enable RX */
661 encx24j600_cmd(priv, ENABLERX);
662
663 priv->hw_enabled = true;
664}
665
666static void encx24j600_hw_disable(struct encx24j600_priv *priv)
667{
668 /* Disable all interrupts */
669 encx24j600_write_reg(priv, EIE, 0);
670
671 /* Disable RX */
672 encx24j600_cmd(priv, DISABLERX);
673
674 priv->hw_enabled = false;
675}
676
677static int encx24j600_setlink(struct net_device *dev, u8 autoneg, u16 speed,
678 u8 duplex)
679{
680 struct encx24j600_priv *priv = netdev_priv(dev);
681 int ret = 0;
682
683 if (!priv->hw_enabled) {
684 /* link is in low power mode now; duplex setting
685 * will take effect on next encx24j600_hw_init()
686 */
687 if (speed == SPEED_10 || speed == SPEED_100) {
688 priv->autoneg = (autoneg == AUTONEG_ENABLE);
689 priv->full_duplex = (duplex == DUPLEX_FULL);
690 priv->speed = (speed == SPEED_100);
691 } else {
692 netif_warn(priv, link, dev, "unsupported link speed setting\n");
693 /*speeds other than SPEED_10 and SPEED_100 */
694 /*are not supported by chip */
695 ret = -EOPNOTSUPP;
696 }
697 } else {
698 netif_warn(priv, link, dev, "Warning: hw must be disabled to set link mode\n");
699 ret = -EBUSY;
700 }
701 return ret;
702}
703
704static void encx24j600_hw_get_macaddr(struct encx24j600_priv *priv,
705 unsigned char *ethaddr)
706{
707 unsigned short val;
708
709 val = encx24j600_read_reg(priv, MAADR1);
710
711 ethaddr[0] = val & 0x00ff;
712 ethaddr[1] = (val & 0xff00) >> 8;
713
714 val = encx24j600_read_reg(priv, MAADR2);
715
716 ethaddr[2] = val & 0x00ffU;
717 ethaddr[3] = (val & 0xff00U) >> 8;
718
719 val = encx24j600_read_reg(priv, MAADR3);
720
721 ethaddr[4] = val & 0x00ffU;
722 ethaddr[5] = (val & 0xff00U) >> 8;
723}
724
725/* Program the hardware MAC address from dev->dev_addr.*/
726static int encx24j600_set_hw_macaddr(struct net_device *dev)
727{
728 struct encx24j600_priv *priv = netdev_priv(dev);
729
730 if (priv->hw_enabled) {
731 netif_info(priv, drv, dev, "Hardware must be disabled to set Mac address\n");
732 return -EBUSY;
733 }
734
735 mutex_lock(&priv->lock);
736
737 netif_info(priv, drv, dev, "%s: Setting MAC address to %pM\n",
738 dev->name, dev->dev_addr);
739
740 encx24j600_write_reg(priv, MAADR3, (dev->dev_addr[4] |
741 dev->dev_addr[5] << 8));
742 encx24j600_write_reg(priv, MAADR2, (dev->dev_addr[2] |
743 dev->dev_addr[3] << 8));
744 encx24j600_write_reg(priv, MAADR1, (dev->dev_addr[0] |
745 dev->dev_addr[1] << 8));
746
747 mutex_unlock(&priv->lock);
748
749 return 0;
750}
751
752/* Store the new hardware address in dev->dev_addr, and update the MAC.*/
753static int encx24j600_set_mac_address(struct net_device *dev, void *addr)
754{
755 struct sockaddr *address = addr;
756
757 if (netif_running(dev))
758 return -EBUSY;
759 if (!is_valid_ether_addr(address->sa_data))
760 return -EADDRNOTAVAIL;
761
762 memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
763 return encx24j600_set_hw_macaddr(dev);
764}
765
766static int encx24j600_open(struct net_device *dev)
767{
768 struct encx24j600_priv *priv = netdev_priv(dev);
769
770 int ret = request_threaded_irq(priv->ctx.spi->irq, NULL, encx24j600_isr,
771 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
772 DRV_NAME, priv);
773 if (unlikely(ret < 0)) {
774 netdev_err(dev, "request irq %d failed (ret = %d)\n",
775 priv->ctx.spi->irq, ret);
776 return ret;
777 }
778
779 encx24j600_hw_disable(priv);
780 encx24j600_hw_init(priv);
781 encx24j600_hw_enable(priv);
782 netif_start_queue(dev);
783
784 return 0;
785}
786
787static int encx24j600_stop(struct net_device *dev)
788{
789 struct encx24j600_priv *priv = netdev_priv(dev);
790
791 netif_stop_queue(dev);
792 free_irq(priv->ctx.spi->irq, priv);
793 return 0;
794}
795
796static void encx24j600_setrx_proc(struct kthread_work *ws)
797{
798 struct encx24j600_priv *priv =
799 container_of(ws, struct encx24j600_priv, setrx_work);
800
801 mutex_lock(&priv->lock);
802 encx24j600_set_rxfilter_mode(priv);
803 mutex_unlock(&priv->lock);
804}
805
806static void encx24j600_set_multicast_list(struct net_device *dev)
807{
808 struct encx24j600_priv *priv = netdev_priv(dev);
809 int oldfilter = priv->rxfilter;
810
811 if (dev->flags & IFF_PROMISC) {
812 netif_dbg(priv, link, dev, "promiscuous mode\n");
813 priv->rxfilter = RXFILTER_PROMISC;
814 } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
815 netif_dbg(priv, link, dev, "%smulticast mode\n",
816 (dev->flags & IFF_ALLMULTI) ? "all-" : "");
817 priv->rxfilter = RXFILTER_MULTI;
818 } else {
819 netif_dbg(priv, link, dev, "normal mode\n");
820 priv->rxfilter = RXFILTER_NORMAL;
821 }
822
823 if (oldfilter != priv->rxfilter)
824 queue_kthread_work(&priv->kworker, &priv->setrx_work);
825}
826
827static void encx24j600_hw_tx(struct encx24j600_priv *priv)
828{
829 struct net_device *dev = priv->ndev;
830 netif_info(priv, tx_queued, dev, "TX Packet Len:%d\n",
831 priv->tx_skb->len);
832
833 if (netif_msg_pktdata(priv))
834 dump_packet("TX", priv->tx_skb->len, priv->tx_skb->data);
835
836 if (encx24j600_read_reg(priv, EIR) & TXABTIF)
837 /* Last transmition aborted due to error. Reset TX interface */
838 encx24j600_reset_hw_tx(priv);
839
840 /* Clear the TXIF flag if were previously set */
841 encx24j600_clr_bits(priv, EIR, TXIF);
842
843 /* Set the data pointer to the TX buffer address in the SRAM */
844 encx24j600_write_reg(priv, EGPWRPT, ENC_TX_BUF_START);
845
846 /* Copy the packet into the SRAM */
847 encx24j600_raw_write(priv, WGPDATA, (u8 *)priv->tx_skb->data,
848 priv->tx_skb->len);
849
850 /* Program the Tx buffer start pointer */
851 encx24j600_write_reg(priv, ETXST, ENC_TX_BUF_START);
852
853 /* Program the packet length */
854 encx24j600_write_reg(priv, ETXLEN, priv->tx_skb->len);
855
856 /* Start the transmission */
857 encx24j600_cmd(priv, SETTXRTS);
858}
859
860static void encx24j600_tx_proc(struct kthread_work *ws)
861{
862 struct encx24j600_priv *priv =
863 container_of(ws, struct encx24j600_priv, tx_work);
864
865 mutex_lock(&priv->lock);
866 encx24j600_hw_tx(priv);
867 mutex_unlock(&priv->lock);
868}
869
870static netdev_tx_t encx24j600_tx(struct sk_buff *skb, struct net_device *dev)
871{
872 struct encx24j600_priv *priv = netdev_priv(dev);
873
874 netif_stop_queue(dev);
875
876 /* save the timestamp */
877 dev->trans_start = jiffies;
878
879 /* Remember the skb for deferred processing */
880 priv->tx_skb = skb;
881
882 queue_kthread_work(&priv->kworker, &priv->tx_work);
883
884 return NETDEV_TX_OK;
885}
886
887/* Deal with a transmit timeout */
888static void encx24j600_tx_timeout(struct net_device *dev)
889{
890 struct encx24j600_priv *priv = netdev_priv(dev);
891
892 netif_err(priv, tx_err, dev, "TX timeout at %ld, latency %ld\n",
893 jiffies, jiffies - dev->trans_start);
894
895 dev->stats.tx_errors++;
896 netif_wake_queue(dev);
897 return;
898}
899
900static int encx24j600_get_regs_len(struct net_device *dev)
901{
902 return SFR_REG_COUNT;
903}
904
905static void encx24j600_get_regs(struct net_device *dev,
906 struct ethtool_regs *regs, void *p)
907{
908 struct encx24j600_priv *priv = netdev_priv(dev);
909 u16 *buff = p;
910 u8 reg;
911
912 regs->version = 1;
913 mutex_lock(&priv->lock);
914 for (reg = 0; reg < SFR_REG_COUNT; reg += 2) {
915 unsigned int val = 0;
916 /* ignore errors for unreadable registers */
917 regmap_read(priv->ctx.regmap, reg, &val);
918 buff[reg] = val & 0xffff;
919 }
920 mutex_unlock(&priv->lock);
921}
922
923static void encx24j600_get_drvinfo(struct net_device *dev,
924 struct ethtool_drvinfo *info)
925{
926 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
927 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
928 strlcpy(info->bus_info, dev_name(dev->dev.parent),
929 sizeof(info->bus_info));
930}
931
932static int encx24j600_get_settings(struct net_device *dev,
933 struct ethtool_cmd *cmd)
934{
935 struct encx24j600_priv *priv = netdev_priv(dev);
936
937 cmd->transceiver = XCVR_INTERNAL;
938 cmd->supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
939 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
940 SUPPORTED_Autoneg | SUPPORTED_TP;
941
942 ethtool_cmd_speed_set(cmd, priv->speed);
943 cmd->duplex = priv->full_duplex ? DUPLEX_FULL : DUPLEX_HALF;
944 cmd->port = PORT_TP;
945 cmd->autoneg = priv->autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
946
947 return 0;
948}
949
950static int encx24j600_set_settings(struct net_device *dev,
951 struct ethtool_cmd *cmd)
952{
953 return encx24j600_setlink(dev, cmd->autoneg,
954 ethtool_cmd_speed(cmd), cmd->duplex);
955}
956
957static u32 encx24j600_get_msglevel(struct net_device *dev)
958{
959 struct encx24j600_priv *priv = netdev_priv(dev);
960 return priv->msg_enable;
961}
962
963static void encx24j600_set_msglevel(struct net_device *dev, u32 val)
964{
965 struct encx24j600_priv *priv = netdev_priv(dev);
966 priv->msg_enable = val;
967}
968
969static const struct ethtool_ops encx24j600_ethtool_ops = {
970 .get_settings = encx24j600_get_settings,
971 .set_settings = encx24j600_set_settings,
972 .get_drvinfo = encx24j600_get_drvinfo,
973 .get_msglevel = encx24j600_get_msglevel,
974 .set_msglevel = encx24j600_set_msglevel,
975 .get_regs_len = encx24j600_get_regs_len,
976 .get_regs = encx24j600_get_regs,
977};
978
979static const struct net_device_ops encx24j600_netdev_ops = {
980 .ndo_open = encx24j600_open,
981 .ndo_stop = encx24j600_stop,
982 .ndo_start_xmit = encx24j600_tx,
983 .ndo_set_rx_mode = encx24j600_set_multicast_list,
984 .ndo_set_mac_address = encx24j600_set_mac_address,
985 .ndo_tx_timeout = encx24j600_tx_timeout,
986 .ndo_validate_addr = eth_validate_addr,
987};
988
989static int encx24j600_spi_probe(struct spi_device *spi)
990{
991 int ret;
992
993 struct net_device *ndev;
994 struct encx24j600_priv *priv;
995 u16 eidled;
996
997 ndev = alloc_etherdev(sizeof(struct encx24j600_priv));
998
999 if (!ndev) {
1000 ret = -ENOMEM;
1001 goto error_out;
1002 }
1003
1004 priv = netdev_priv(ndev);
1005 spi_set_drvdata(spi, priv);
1006 dev_set_drvdata(&spi->dev, priv);
1007 SET_NETDEV_DEV(ndev, &spi->dev);
1008
1009 priv->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
1010 priv->ndev = ndev;
1011
1012 /* Default configuration PHY configuration */
1013 priv->full_duplex = true;
1014 priv->autoneg = AUTONEG_ENABLE;
1015 priv->speed = SPEED_100;
1016
1017 priv->ctx.spi = spi;
1018 devm_regmap_init_encx24j600(&spi->dev, &priv->ctx);
1019 ndev->irq = spi->irq;
1020 ndev->netdev_ops = &encx24j600_netdev_ops;
1021
1022 mutex_init(&priv->lock);
1023
1024 /* Reset device and check if it is connected */
1025 if (encx24j600_hw_reset(priv)) {
1026 netif_err(priv, probe, ndev,
1027 DRV_NAME ": Chip is not detected\n");
1028 ret = -EIO;
1029 goto out_free;
1030 }
1031
1032 /* Initialize the device HW to the consistent state */
1033 if (encx24j600_hw_init(priv)) {
1034 netif_err(priv, probe, ndev,
1035 DRV_NAME ": HW initialization error\n");
1036 ret = -EIO;
1037 goto out_free;
1038 }
1039
1040 init_kthread_worker(&priv->kworker);
1041 init_kthread_work(&priv->tx_work, encx24j600_tx_proc);
1042 init_kthread_work(&priv->setrx_work, encx24j600_setrx_proc);
1043
1044 priv->kworker_task = kthread_run(kthread_worker_fn, &priv->kworker,
1045 "encx24j600");
1046
1047 if (IS_ERR(priv->kworker_task)) {
1048 ret = PTR_ERR(priv->kworker_task);
1049 goto out_free;
1050 }
1051
1052 /* Get the MAC address from the chip */
1053 encx24j600_hw_get_macaddr(priv, ndev->dev_addr);
1054
1055 ndev->ethtool_ops = &encx24j600_ethtool_ops;
1056
1057 ret = register_netdev(ndev);
1058 if (unlikely(ret)) {
1059 netif_err(priv, probe, ndev, "Error %d initializing card encx24j600 card\n",
1060 ret);
1061 goto out_free;
1062 }
1063
1064 eidled = encx24j600_read_reg(priv, EIDLED);
1065 if (((eidled & DEVID_MASK) >> DEVID_SHIFT) != ENCX24J600_DEV_ID) {
1066 ret = -EINVAL;
1067 goto out_unregister;
1068 }
1069
1070 netif_info(priv, probe, ndev, "Silicon rev ID: 0x%02x\n",
1071 (eidled & REVID_MASK) >> REVID_SHIFT);
1072
1073 netif_info(priv, drv, priv->ndev, "MAC address %pM\n", ndev->dev_addr);
1074
1075 return ret;
1076
1077out_unregister:
1078 unregister_netdev(priv->ndev);
1079out_free:
1080 free_netdev(ndev);
1081
1082error_out:
1083 return ret;
1084}
1085
1086static int encx24j600_spi_remove(struct spi_device *spi)
1087{
1088 struct encx24j600_priv *priv = dev_get_drvdata(&spi->dev);
1089
1090 unregister_netdev(priv->ndev);
1091
1092 free_netdev(priv->ndev);
1093
1094 return 0;
1095}
1096
1097static const struct spi_device_id encx24j600_spi_id_table[] = {
1098 { .name = "encx24j600" },
1099 { /* sentinel */ }
1100};
1101MODULE_DEVICE_TABLE(spi, encx24j600_spi_id_table);
1102
1103static struct spi_driver encx24j600_spi_net_driver = {
1104 .driver = {
1105 .name = DRV_NAME,
1106 .owner = THIS_MODULE,
1107 .bus = &spi_bus_type,
1108 },
1109 .probe = encx24j600_spi_probe,
1110 .remove = encx24j600_spi_remove,
1111 .id_table = encx24j600_spi_id_table,
1112};
1113
1114static int __init encx24j600_init(void)
1115{
1116 return spi_register_driver(&encx24j600_spi_net_driver);
1117}
1118module_init(encx24j600_init);
1119
1120static void encx24j600_exit(void)
1121{
1122 spi_unregister_driver(&encx24j600_spi_net_driver);
1123}
1124module_exit(encx24j600_exit);
1125
1126MODULE_DESCRIPTION(DRV_NAME " ethernet driver");
1127MODULE_AUTHOR("Jon Ringle <jringle@gridpoint.com>");
1128MODULE_LICENSE("GPL");
1129MODULE_ALIAS("spi:" DRV_NAME);