projects / openwrt / staging / noltari.git / blob
? search:


42928bab075dd04607e8699135d7a04126d486fd
[openwrt/staging/noltari.git] / target / linux / generic / files / drivers / net / phy / adm6996.c
1 /*
2 * ADM6996 switch driver
3 *
4 * swconfig interface based on ar8216.c
5 *
6 * Copyright (c) 2008 Felix Fietkau <nbd@nbd.name>
7 * VLAN support Copyright (c) 2010, 2011 Peter Lebbing <peter@digitalbrains.com>
8 * Copyright (c) 2013 Hauke Mehrtens <hauke@hauke-m.de>
9 * Copyright (c) 2014 Matti Laakso <malaakso@elisanet.fi>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License v2 as published by the
13 * Free Software Foundation
14 */
15
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18 /*#define DEBUG 1*/
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/errno.h>
22 #include <linux/unistd.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/gpio.h>
28 #include <linux/netdevice.h>
29 #include <linux/etherdevice.h>
30 #include <linux/skbuff.h>
31 #include <linux/spinlock.h>
32 #include <linux/mm.h>
33 #include <linux/module.h>
34 #include <linux/mii.h>
35 #include <linux/platform_device.h>
36 #include <linux/platform_data/adm6996-gpio.h>
37 #include <linux/ethtool.h>
38 #include <linux/phy.h>
39 #include <linux/switch.h>
40
41 #include <asm/io.h>
42 #include <asm/irq.h>
43 #include <asm/uaccess.h>
44 #include "adm6996.h"
45
46 MODULE_DESCRIPTION("Infineon ADM6996 Switch");
47 MODULE_AUTHOR("Felix Fietkau, Peter Lebbing <peter@digitalbrains.com>");
48 MODULE_LICENSE("GPL");
49
50 static const char * const adm6996_model_name[] =
51 {
52 NULL,
53 "ADM6996FC",
54 "ADM6996M",
55 "ADM6996L"
56 };
57
58 struct adm6996_mib_desc {
59 unsigned int offset;
60 const char *name;
61 };
62
63 struct adm6996_priv {
64 struct switch_dev dev;
65 void *priv;
66
67 u8 eecs;
68 u8 eesk;
69 u8 eedi;
70
71 enum adm6996_model model;
72
73 bool enable_vlan;
74 bool vlan_enabled; /* Current hardware state */
75
76 #ifdef DEBUG
77 u16 addr; /* Debugging: register address to operate on */
78 #endif
79
80 u16 pvid[ADM_NUM_PORTS]; /* Primary VLAN ID */
81 u8 tagged_ports;
82
83 u16 vlan_id[ADM_NUM_VLANS];
84 u8 vlan_table[ADM_NUM_VLANS]; /* bitmap, 1 = port is member */
85 u8 vlan_tagged[ADM_NUM_VLANS]; /* bitmap, 1 = tagged member */
86
87 struct mutex mib_lock;
88 char buf[2048];
89
90 struct mutex reg_mutex;
91
92 /* use abstraction for regops, we want to add gpio support in the future */
93 u16 (*read)(struct adm6996_priv *priv, enum admreg reg);
94 void (*write)(struct adm6996_priv *priv, enum admreg reg, u16 val);
95 };
96
97 #define to_adm(_dev) container_of(_dev, struct adm6996_priv, dev)
98 #define phy_to_adm(_phy) ((struct adm6996_priv *) (_phy)->priv)
99
100 #define MIB_DESC(_o, _n) \
101 { \
102 .offset = (_o), \
103 .name = (_n), \
104 }
105
106 static const struct adm6996_mib_desc adm6996_mibs[] = {
107 MIB_DESC(ADM_CL0, "RxPacket"),
108 MIB_DESC(ADM_CL6, "RxByte"),
109 MIB_DESC(ADM_CL12, "TxPacket"),
110 MIB_DESC(ADM_CL18, "TxByte"),
111 MIB_DESC(ADM_CL24, "Collision"),
112 MIB_DESC(ADM_CL30, "Error"),
113 };
114
115 #define ADM6996_MIB_RXB_ID 1
116 #define ADM6996_MIB_TXB_ID 3
117
118 static inline u16
119 r16(struct adm6996_priv *priv, enum admreg reg)
120 {
121 return priv->read(priv, reg);
122 }
123
124 static inline void
125 w16(struct adm6996_priv *priv, enum admreg reg, u16 val)
126 {
127 priv->write(priv, reg, val);
128 }
129
130 /* Minimum timing constants */
131 #define EECK_EDGE_TIME 3 /* 3us - max(adm 2.5us, 93c 1us) */
132 #define EEDI_SETUP_TIME 1 /* 1us - max(adm 10ns, 93c 400ns) */
133 #define EECS_SETUP_TIME 1 /* 1us - max(adm no, 93c 200ns) */
134
135 static void adm6996_gpio_write(struct adm6996_priv *priv, int cs, char *buf, unsigned int bits)
136 {
137 int i, len = (bits + 7) / 8;
138 u8 mask;
139
140 gpio_set_value(priv->eecs, cs);
141 udelay(EECK_EDGE_TIME);
142
143 /* Byte assemble from MSB to LSB */
144 for (i = 0; i < len; i++) {
145 /* Bit bang from MSB to LSB */
146 for (mask = 0x80; mask && bits > 0; mask >>= 1, bits --) {
147 /* Clock low */
148 gpio_set_value(priv->eesk, 0);
149 udelay(EECK_EDGE_TIME);
150
151 /* Output on rising edge */
152 gpio_set_value(priv->eedi, (mask & buf[i]));
153 udelay(EEDI_SETUP_TIME);
154
155 /* Clock high */
156 gpio_set_value(priv->eesk, 1);
157 udelay(EECK_EDGE_TIME);
158 }
159 }
160
161 /* Clock low */
162 gpio_set_value(priv->eesk, 0);
163 udelay(EECK_EDGE_TIME);
164
165 if (cs)
166 gpio_set_value(priv->eecs, 0);
167 }
168
169 static void adm6996_gpio_read(struct adm6996_priv *priv, int cs, char *buf, unsigned int bits)
170 {
171 int i, len = (bits + 7) / 8;
172 u8 mask;
173
174 gpio_set_value(priv->eecs, cs);
175 udelay(EECK_EDGE_TIME);
176
177 /* Byte assemble from MSB to LSB */
178 for (i = 0; i < len; i++) {
179 u8 byte;
180
181 /* Bit bang from MSB to LSB */
182 for (mask = 0x80, byte = 0; mask && bits > 0; mask >>= 1, bits --) {
183 u8 gp;
184
185 /* Clock low */
186 gpio_set_value(priv->eesk, 0);
187 udelay(EECK_EDGE_TIME);
188
189 /* Input on rising edge */
190 gp = gpio_get_value(priv->eedi);
191 if (gp)
192 byte |= mask;
193
194 /* Clock high */
195 gpio_set_value(priv->eesk, 1);
196 udelay(EECK_EDGE_TIME);
197 }
198
199 *buf++ = byte;
200 }
201
202 /* Clock low */
203 gpio_set_value(priv->eesk, 0);
204 udelay(EECK_EDGE_TIME);
205
206 if (cs)
207 gpio_set_value(priv->eecs, 0);
208 }
209
210 /* Advance clock(s) */
211 static void adm6996_gpio_adclk(struct adm6996_priv *priv, int clocks)
212 {
213 int i;
214 for (i = 0; i < clocks; i++) {
215 /* Clock high */
216 gpio_set_value(priv->eesk, 1);
217 udelay(EECK_EDGE_TIME);
218
219 /* Clock low */
220 gpio_set_value(priv->eesk, 0);
221 udelay(EECK_EDGE_TIME);
222 }
223 }
224
225 static u16
226 adm6996_read_gpio_reg(struct adm6996_priv *priv, enum admreg reg)
227 {
228 /* cmd: 01 10 T DD R RRRRRR */
229 u8 bits[6] = {
230 0xFF, 0xFF, 0xFF, 0xFF,
231 (0x06 << 4) | ((0 & 0x01) << 3 | (reg&64)>>6),
232 ((reg&63)<<2)
233 };
234
235 u8 rbits[4];
236
237 /* Enable GPIO outputs with all pins to 0 */
238 gpio_direction_output(priv->eecs, 0);
239 gpio_direction_output(priv->eesk, 0);
240 gpio_direction_output(priv->eedi, 0);
241
242 adm6996_gpio_write(priv, 0, bits, 46);
243 gpio_direction_input(priv->eedi);
244 adm6996_gpio_adclk(priv, 2);
245 adm6996_gpio_read(priv, 0, rbits, 32);
246
247 /* Extra clock(s) required per datasheet */
248 adm6996_gpio_adclk(priv, 2);
249
250 /* Disable GPIO outputs */
251 gpio_direction_input(priv->eecs);
252 gpio_direction_input(priv->eesk);
253
254 /* EEPROM has 16-bit registers, but pumps out two registers in one request */
255 return (reg & 0x01 ? (rbits[0]<<8) | rbits[1] : (rbits[2]<<8) | (rbits[3]));
256 }
257
258 /* Write chip configuration register */
259 /* Follow 93c66 timing and chip's min EEPROM timing requirement */
260 static void
261 adm6996_write_gpio_reg(struct adm6996_priv *priv, enum admreg reg, u16 val)
262 {
263 /* cmd(27bits): sb(1) + opc(01) + addr(bbbbbbbb) + data(bbbbbbbbbbbbbbbb) */
264 u8 bits[4] = {
265 (0x05 << 5) | (reg >> 3),
266 (reg << 5) | (u8)(val >> 11),
267 (u8)(val >> 3),
268 (u8)(val << 5)
269 };
270
271 /* Enable GPIO outputs with all pins to 0 */
272 gpio_direction_output(priv->eecs, 0);
273 gpio_direction_output(priv->eesk, 0);
274 gpio_direction_output(priv->eedi, 0);
275
276 /* Write cmd. Total 27 bits */
277 adm6996_gpio_write(priv, 1, bits, 27);
278
279 /* Extra clock(s) required per datasheet */
280 adm6996_gpio_adclk(priv, 2);
281
282 /* Disable GPIO outputs */
283 gpio_direction_input(priv->eecs);
284 gpio_direction_input(priv->eesk);
285 gpio_direction_input(priv->eedi);
286 }
287
288 static u16
289 adm6996_read_mii_reg(struct adm6996_priv *priv, enum admreg reg)
290 {
291 struct phy_device *phydev = priv->priv;
292 struct mii_bus *bus = phydev->mdio.bus;
293
294 return bus->read(bus, PHYADDR(reg));
295 }
296
297 static void
298 adm6996_write_mii_reg(struct adm6996_priv *priv, enum admreg reg, u16 val)
299 {
300 struct phy_device *phydev = priv->priv;
301 struct mii_bus *bus = phydev->mdio.bus;
302
303 bus->write(bus, PHYADDR(reg), val);
304 }
305
306 static int
307 adm6996_set_enable_vlan(struct switch_dev *dev, const struct switch_attr *attr,
308 struct switch_val *val)
309 {
310 struct adm6996_priv *priv = to_adm(dev);
311
312 if (val->value.i > 1)
313 return -EINVAL;
314
315 priv->enable_vlan = val->value.i;
316
317 return 0;
318 };
319
320 static int
321 adm6996_get_enable_vlan(struct switch_dev *dev, const struct switch_attr *attr,
322 struct switch_val *val)
323 {
324 struct adm6996_priv *priv = to_adm(dev);
325
326 val->value.i = priv->enable_vlan;
327
328 return 0;
329 };
330
331 #ifdef DEBUG
332
333 static int
334 adm6996_set_addr(struct switch_dev *dev, const struct switch_attr *attr,
335 struct switch_val *val)
336 {
337 struct adm6996_priv *priv = to_adm(dev);
338
339 if (val->value.i > 1023)
340 return -EINVAL;
341
342 priv->addr = val->value.i;
343
344 return 0;
345 };
346
347 static int
348 adm6996_get_addr(struct switch_dev *dev, const struct switch_attr *attr,
349 struct switch_val *val)
350 {
351 struct adm6996_priv *priv = to_adm(dev);
352
353 val->value.i = priv->addr;
354
355 return 0;
356 };
357
358 static int
359 adm6996_set_data(struct switch_dev *dev, const struct switch_attr *attr,
360 struct switch_val *val)
361 {
362 struct adm6996_priv *priv = to_adm(dev);
363
364 if (val->value.i > 65535)
365 return -EINVAL;
366
367 w16(priv, priv->addr, val->value.i);
368
369 return 0;
370 };
371
372 static int
373 adm6996_get_data(struct switch_dev *dev, const struct switch_attr *attr,
374 struct switch_val *val)
375 {
376 struct adm6996_priv *priv = to_adm(dev);
377
378 val->value.i = r16(priv, priv->addr);
379
380 return 0;
381 };
382
383 #endif /* def DEBUG */
384
385 static int
386 adm6996_set_pvid(struct switch_dev *dev, int port, int vlan)
387 {
388 struct adm6996_priv *priv = to_adm(dev);
389
390 pr_devel("set_pvid port %d vlan %d\n", port, vlan);
391
392 if (vlan > ADM_VLAN_MAX_ID)
393 return -EINVAL;
394
395 priv->pvid[port] = vlan;
396
397 return 0;
398 }
399
400 static int
401 adm6996_get_pvid(struct switch_dev *dev, int port, int *vlan)
402 {
403 struct adm6996_priv *priv = to_adm(dev);
404
405 pr_devel("get_pvid port %d\n", port);
406 *vlan = priv->pvid[port];
407
408 return 0;
409 }
410
411 static int
412 adm6996_set_vid(struct switch_dev *dev, const struct switch_attr *attr,
413 struct switch_val *val)
414 {
415 struct adm6996_priv *priv = to_adm(dev);
416
417 pr_devel("set_vid port %d vid %d\n", val->port_vlan, val->value.i);
418
419 if (val->value.i > ADM_VLAN_MAX_ID)
420 return -EINVAL;
421
422 priv->vlan_id[val->port_vlan] = val->value.i;
423
424 return 0;
425 };
426
427 static int
428 adm6996_get_vid(struct switch_dev *dev, const struct switch_attr *attr,
429 struct switch_val *val)
430 {
431 struct adm6996_priv *priv = to_adm(dev);
432
433 pr_devel("get_vid port %d\n", val->port_vlan);
434
435 val->value.i = priv->vlan_id[val->port_vlan];
436
437 return 0;
438 };
439
440 static int
441 adm6996_get_ports(struct switch_dev *dev, struct switch_val *val)
442 {
443 struct adm6996_priv *priv = to_adm(dev);
444 u8 ports = priv->vlan_table[val->port_vlan];
445 u8 tagged = priv->vlan_tagged[val->port_vlan];
446 int i;
447
448 pr_devel("get_ports port_vlan %d\n", val->port_vlan);
449
450 val->len = 0;
451
452 for (i = 0; i < ADM_NUM_PORTS; i++) {
453 struct switch_port *p;
454
455 if (!(ports & (1 << i)))
456 continue;
457
458 p = &val->value.ports[val->len++];
459 p->id = i;
460 if (tagged & (1 << i))
461 p->flags = (1 << SWITCH_PORT_FLAG_TAGGED);
462 else
463 p->flags = 0;
464 }
465
466 return 0;
467 };
468
469 static int
470 adm6996_set_ports(struct switch_dev *dev, struct switch_val *val)
471 {
472 struct adm6996_priv *priv = to_adm(dev);
473 u8 *ports = &priv->vlan_table[val->port_vlan];
474 u8 *tagged = &priv->vlan_tagged[val->port_vlan];
475 int i;
476
477 pr_devel("set_ports port_vlan %d ports", val->port_vlan);
478
479 *ports = 0;
480 *tagged = 0;
481
482 for (i = 0; i < val->len; i++) {
483 struct switch_port *p = &val->value.ports[i];
484
485 #ifdef DEBUG
486 pr_cont(" %d%s", p->id,
487 ((p->flags & (1 << SWITCH_PORT_FLAG_TAGGED)) ? "T" :
488 ""));
489 #endif
490
491 if (p->flags & (1 << SWITCH_PORT_FLAG_TAGGED)) {
492 *tagged |= (1 << p->id);
493 priv->tagged_ports |= (1 << p->id);
494 }
495
496 *ports |= (1 << p->id);
497 }
498
499 #ifdef DEBUG
500 pr_cont("\n");
501 #endif
502
503 return 0;
504 };
505
506 /*
507 * Precondition: reg_mutex must be held
508 */
509 static void
510 adm6996_enable_vlan(struct adm6996_priv *priv)
511 {
512 u16 reg;
513
514 reg = r16(priv, ADM_OTBE_P2_PVID);
515 reg &= ~(ADM_OTBE_MASK);
516 w16(priv, ADM_OTBE_P2_PVID, reg);
517 reg = r16(priv, ADM_IFNTE);
518 reg &= ~(ADM_IFNTE_MASK);
519 w16(priv, ADM_IFNTE, reg);
520 reg = r16(priv, ADM_VID_CHECK);
521 reg |= ADM_VID_CHECK_MASK;
522 w16(priv, ADM_VID_CHECK, reg);
523 reg = r16(priv, ADM_SYSC0);
524 reg |= ADM_NTTE;
525 reg &= ~(ADM_RVID1);
526 w16(priv, ADM_SYSC0, reg);
527 reg = r16(priv, ADM_SYSC3);
528 reg |= ADM_TBV;
529 w16(priv, ADM_SYSC3, reg);
530 }
531
532 static void
533 adm6996_enable_vlan_6996l(struct adm6996_priv *priv)
534 {
535 u16 reg;
536
537 reg = r16(priv, ADM_SYSC3);
538 reg |= ADM_TBV;
539 reg |= ADM_MAC_CLONE;
540 w16(priv, ADM_SYSC3, reg);
541 }
542
543 /*
544 * Disable VLANs
545 *
546 * Sets VLAN mapping for port-based VLAN with all ports connected to
547 * eachother (this is also the power-on default).
548 *
549 * Precondition: reg_mutex must be held
550 */
551 static void
552 adm6996_disable_vlan(struct adm6996_priv *priv)
553 {
554 u16 reg;
555 int i;
556
557 for (i = 0; i < ADM_NUM_VLANS; i++) {
558 reg = ADM_VLAN_FILT_MEMBER_MASK;
559 w16(priv, ADM_VLAN_FILT_L(i), reg);
560 reg = ADM_VLAN_FILT_VALID | ADM_VLAN_FILT_VID(1);
561 w16(priv, ADM_VLAN_FILT_H(i), reg);
562 }
563
564 reg = r16(priv, ADM_OTBE_P2_PVID);
565 reg |= ADM_OTBE_MASK;
566 w16(priv, ADM_OTBE_P2_PVID, reg);
567 reg = r16(priv, ADM_IFNTE);
568 reg |= ADM_IFNTE_MASK;
569 w16(priv, ADM_IFNTE, reg);
570 reg = r16(priv, ADM_VID_CHECK);
571 reg &= ~(ADM_VID_CHECK_MASK);
572 w16(priv, ADM_VID_CHECK, reg);
573 reg = r16(priv, ADM_SYSC0);
574 reg &= ~(ADM_NTTE);
575 reg |= ADM_RVID1;
576 w16(priv, ADM_SYSC0, reg);
577 reg = r16(priv, ADM_SYSC3);
578 reg &= ~(ADM_TBV);
579 w16(priv, ADM_SYSC3, reg);
580 }
581
582 /*
583 * Disable VLANs
584 *
585 * Sets VLAN mapping for port-based VLAN with all ports connected to
586 * eachother (this is also the power-on default).
587 *
588 * Precondition: reg_mutex must be held
589 */
590 static void
591 adm6996_disable_vlan_6996l(struct adm6996_priv *priv)
592 {
593 u16 reg;
594 int i;
595
596 for (i = 0; i < ADM_NUM_VLANS; i++) {
597 w16(priv, ADM_VLAN_MAP(i), 0);
598 }
599
600 reg = r16(priv, ADM_SYSC3);
601 reg &= ~(ADM_TBV);
602 reg &= ~(ADM_MAC_CLONE);
603 w16(priv, ADM_SYSC3, reg);
604 }
605
606 /*
607 * Precondition: reg_mutex must be held
608 */
609 static void
610 adm6996_apply_port_pvids(struct adm6996_priv *priv)
611 {
612 u16 reg;
613 int i;
614
615 for (i = 0; i < ADM_NUM_PORTS; i++) {
616 reg = r16(priv, adm_portcfg[i]);
617 reg &= ~(ADM_PORTCFG_PVID_MASK);
618 reg |= ADM_PORTCFG_PVID(priv->pvid[i]);
619 if (priv->model == ADM6996L) {
620 if (priv->tagged_ports & (1 << i))
621 reg |= (1 << 4);
622 else
623 reg &= ~(1 << 4);
624 }
625 w16(priv, adm_portcfg[i], reg);
626 }
627
628 w16(priv, ADM_P0_PVID, ADM_P0_PVID_VAL(priv->pvid[0]));
629 w16(priv, ADM_P1_PVID, ADM_P1_PVID_VAL(priv->pvid[1]));
630 reg = r16(priv, ADM_OTBE_P2_PVID);
631 reg &= ~(ADM_P2_PVID_MASK);
632 reg |= ADM_P2_PVID_VAL(priv->pvid[2]);
633 w16(priv, ADM_OTBE_P2_PVID, reg);
634 reg = ADM_P3_PVID_VAL(priv->pvid[3]);
635 reg |= ADM_P4_PVID_VAL(priv->pvid[4]);
636 w16(priv, ADM_P3_P4_PVID, reg);
637 reg = r16(priv, ADM_P5_PVID);
638 reg &= ~(ADM_P2_PVID_MASK);
639 reg |= ADM_P5_PVID_VAL(priv->pvid[5]);
640 w16(priv, ADM_P5_PVID, reg);
641 }
642
643 /*
644 * Precondition: reg_mutex must be held
645 */
646 static void
647 adm6996_apply_vlan_filters(struct adm6996_priv *priv)
648 {
649 u8 ports, tagged;
650 u16 vid, reg;
651 int i;
652
653 for (i = 0; i < ADM_NUM_VLANS; i++) {
654 vid = priv->vlan_id[i];
655 ports = priv->vlan_table[i];
656 tagged = priv->vlan_tagged[i];
657
658 if (ports == 0) {
659 /* Disable VLAN entry */
660 w16(priv, ADM_VLAN_FILT_H(i), 0);
661 w16(priv, ADM_VLAN_FILT_L(i), 0);
662 continue;
663 }
664
665 reg = ADM_VLAN_FILT_MEMBER(ports);
666 reg |= ADM_VLAN_FILT_TAGGED(tagged);
667 w16(priv, ADM_VLAN_FILT_L(i), reg);
668 reg = ADM_VLAN_FILT_VALID | ADM_VLAN_FILT_VID(vid);
669 w16(priv, ADM_VLAN_FILT_H(i), reg);
670 }
671 }
672
673 static void
674 adm6996_apply_vlan_filters_6996l(struct adm6996_priv *priv)
675 {
676 u8 ports;
677 u16 reg;
678 int i;
679
680 for (i = 0; i < ADM_NUM_VLANS; i++) {
681 ports = priv->vlan_table[i];
682
683 if (ports == 0) {
684 /* Disable VLAN entry */
685 w16(priv, ADM_VLAN_MAP(i), 0);
686 continue;
687 } else {
688 reg = ADM_VLAN_FILT(ports);
689 w16(priv, ADM_VLAN_MAP(i), reg);
690 }
691 }
692 }
693
694 static int
695 adm6996_hw_apply(struct switch_dev *dev)
696 {
697 struct adm6996_priv *priv = to_adm(dev);
698
699 pr_devel("hw_apply\n");
700
701 mutex_lock(&priv->reg_mutex);
702
703 if (!priv->enable_vlan) {
704 if (priv->vlan_enabled) {
705 if (priv->model == ADM6996L)
706 adm6996_disable_vlan_6996l(priv);
707 else
708 adm6996_disable_vlan(priv);
709 priv->vlan_enabled = 0;
710 }
711 goto out;
712 }
713
714 if (!priv->vlan_enabled) {
715 if (priv->model == ADM6996L)
716 adm6996_enable_vlan_6996l(priv);
717 else
718 adm6996_enable_vlan(priv);
719 priv->vlan_enabled = 1;
720 }
721
722 adm6996_apply_port_pvids(priv);
723 if (priv->model == ADM6996L)
724 adm6996_apply_vlan_filters_6996l(priv);
725 else
726 adm6996_apply_vlan_filters(priv);
727
728 out:
729 mutex_unlock(&priv->reg_mutex);
730
731 return 0;
732 }
733
734 /*
735 * Reset the switch
736 *
737 * The ADM6996 can't do a software-initiated reset, so we just initialise the
738 * registers we support in this driver.
739 *
740 * Precondition: reg_mutex must be held
741 */
742 static void
743 adm6996_perform_reset (struct adm6996_priv *priv)
744 {
745 int i;
746
747 /* initialize port and vlan settings */
748 for (i = 0; i < ADM_NUM_PORTS - 1; i++) {
749 w16(priv, adm_portcfg[i], ADM_PORTCFG_INIT |
750 ADM_PORTCFG_PVID(0));
751 }
752 w16(priv, adm_portcfg[5], ADM_PORTCFG_CPU);
753
754 if (priv->model == ADM6996M || priv->model == ADM6996FC) {
755 /* reset all PHY ports */
756 for (i = 0; i < ADM_PHY_PORTS; i++) {
757 w16(priv, ADM_PHY_PORT(i), ADM_PHYCFG_INIT);
758 }
759 }
760
761 priv->enable_vlan = 0;
762 priv->vlan_enabled = 0;
763
764 for (i = 0; i < ADM_NUM_PORTS; i++) {
765 priv->pvid[i] = 0;
766 }
767
768 for (i = 0; i < ADM_NUM_VLANS; i++) {
769 priv->vlan_id[i] = i;
770 priv->vlan_table[i] = 0;
771 priv->vlan_tagged[i] = 0;
772 }
773
774 if (priv->model == ADM6996M) {
775 /* Clear VLAN priority map so prio's are unused */
776 w16 (priv, ADM_VLAN_PRIOMAP, 0);
777
778 adm6996_disable_vlan(priv);
779 adm6996_apply_port_pvids(priv);
780 } else if (priv->model == ADM6996L) {
781 /* Clear VLAN priority map so prio's are unused */
782 w16 (priv, ADM_VLAN_PRIOMAP, 0);
783
784 adm6996_disable_vlan_6996l(priv);
785 adm6996_apply_port_pvids(priv);
786 }
787 }
788
789 static int
790 adm6996_reset_switch(struct switch_dev *dev)
791 {
792 struct adm6996_priv *priv = to_adm(dev);
793
794 pr_devel("reset\n");
795
796 mutex_lock(&priv->reg_mutex);
797 adm6996_perform_reset (priv);
798 mutex_unlock(&priv->reg_mutex);
799 return 0;
800 }
801
802 static int
803 adm6996_get_port_link(struct switch_dev *dev, int port,
804 struct switch_port_link *link)
805 {
806 struct adm6996_priv *priv = to_adm(dev);
807
808 u16 reg = 0;
809
810 if (port >= ADM_NUM_PORTS)
811 return -EINVAL;
812
813 switch (port) {
814 case 0:
815 reg = r16(priv, ADM_PS0);
816 break;
817 case 1:
818 reg = r16(priv, ADM_PS0);
819 reg = reg >> 8;
820 break;
821 case 2:
822 reg = r16(priv, ADM_PS1);
823 break;
824 case 3:
825 reg = r16(priv, ADM_PS1);
826 reg = reg >> 8;
827 break;
828 case 4:
829 reg = r16(priv, ADM_PS1);
830 reg = reg >> 12;
831 break;
832 case 5:
833 reg = r16(priv, ADM_PS2);
834 /* Bits 0, 1, 3 and 4. */
835 reg = (reg & 3) | ((reg & 24) >> 1);
836 break;
837 default:
838 return -EINVAL;
839 }
840
841 link->link = reg & ADM_PS_LS;
842 if (!link->link)
843 return 0;
844 link->aneg = true;
845 link->duplex = reg & ADM_PS_DS;
846 link->tx_flow = reg & ADM_PS_FCS;
847 link->rx_flow = reg & ADM_PS_FCS;
848 if (reg & ADM_PS_SS)
849 link->speed = SWITCH_PORT_SPEED_100;
850 else
851 link->speed = SWITCH_PORT_SPEED_10;
852
853 return 0;
854 }
855
856 static int
857 adm6996_sw_get_port_mib(struct switch_dev *dev,
858 const struct switch_attr *attr,
859 struct switch_val *val)
860 {
861 struct adm6996_priv *priv = to_adm(dev);
862 int port;
863 char *buf = priv->buf;
864 int i, len = 0;
865 u32 reg = 0;
866
867 port = val->port_vlan;
868 if (port >= ADM_NUM_PORTS)
869 return -EINVAL;
870
871 mutex_lock(&priv->mib_lock);
872
873 len += snprintf(buf + len, sizeof(priv->buf) - len,
874 "Port %d MIB counters\n",
875 port);
876
877 for (i = 0; i < ARRAY_SIZE(adm6996_mibs); i++) {
878 reg = r16(priv, adm6996_mibs[i].offset + ADM_OFFSET_PORT(port));
879 reg += r16(priv, adm6996_mibs[i].offset + ADM_OFFSET_PORT(port) + 1) << 16;
880 len += snprintf(buf + len, sizeof(priv->buf) - len,
881 "%-12s: %u\n",
882 adm6996_mibs[i].name,
883 reg);
884 }
885
886 mutex_unlock(&priv->mib_lock);
887
888 val->value.s = buf;
889 val->len = len;
890
891 return 0;
892 }
893
894 static int
895 adm6996_get_port_stats(struct switch_dev *dev, int port,
896 struct switch_port_stats *stats)
897 {
898 struct adm6996_priv *priv = to_adm(dev);
899 int id;
900 u32 reg = 0;
901
902 if (port >= ADM_NUM_PORTS)
903 return -EINVAL;
904
905 mutex_lock(&priv->mib_lock);
906
907 id = ADM6996_MIB_TXB_ID;
908 reg = r16(priv, adm6996_mibs[id].offset + ADM_OFFSET_PORT(port));
909 reg += r16(priv, adm6996_mibs[id].offset + ADM_OFFSET_PORT(port) + 1) << 16;
910 stats->tx_bytes = reg;
911
912 id = ADM6996_MIB_RXB_ID;
913 reg = r16(priv, adm6996_mibs[id].offset + ADM_OFFSET_PORT(port));
914 reg += r16(priv, adm6996_mibs[id].offset + ADM_OFFSET_PORT(port) + 1) << 16;
915 stats->rx_bytes = reg;
916
917 mutex_unlock(&priv->mib_lock);
918
919 return 0;
920 }
921
922 static struct switch_attr adm6996_globals[] = {
923 {
924 .type = SWITCH_TYPE_INT,
925 .name = "enable_vlan",
926 .description = "Enable VLANs",
927 .set = adm6996_set_enable_vlan,
928 .get = adm6996_get_enable_vlan,
929 },
930 #ifdef DEBUG
931 {
932 .type = SWITCH_TYPE_INT,
933 .name = "addr",
934 .description =
935 "Direct register access: set register address (0 - 1023)",
936 .set = adm6996_set_addr,
937 .get = adm6996_get_addr,
938 },
939 {
940 .type = SWITCH_TYPE_INT,
941 .name = "data",
942 .description =
943 "Direct register access: read/write to register (0 - 65535)",
944 .set = adm6996_set_data,
945 .get = adm6996_get_data,
946 },
947 #endif /* def DEBUG */
948 };
949
950 static struct switch_attr adm6996_port[] = {
951 {
952 .type = SWITCH_TYPE_STRING,
953 .name = "mib",
954 .description = "Get port's MIB counters",
955 .set = NULL,
956 .get = adm6996_sw_get_port_mib,
957 },
958 };
959
960 static struct switch_attr adm6996_vlan[] = {
961 {
962 .type = SWITCH_TYPE_INT,
963 .name = "vid",
964 .description = "VLAN ID",
965 .set = adm6996_set_vid,
966 .get = adm6996_get_vid,
967 },
968 };
969
970 static struct switch_dev_ops adm6996_ops = {
971 .attr_global = {
972 .attr = adm6996_globals,
973 .n_attr = ARRAY_SIZE(adm6996_globals),
974 },
975 .attr_port = {
976 .attr = adm6996_port,
977 .n_attr = ARRAY_SIZE(adm6996_port),
978 },
979 .attr_vlan = {
980 .attr = adm6996_vlan,
981 .n_attr = ARRAY_SIZE(adm6996_vlan),
982 },
983 .get_port_pvid = adm6996_get_pvid,
984 .set_port_pvid = adm6996_set_pvid,
985 .get_vlan_ports = adm6996_get_ports,
986 .set_vlan_ports = adm6996_set_ports,
987 .apply_config = adm6996_hw_apply,
988 .reset_switch = adm6996_reset_switch,
989 .get_port_link = adm6996_get_port_link,
990 .get_port_stats = adm6996_get_port_stats,
991 };
992
993 static int adm6996_switch_init(struct adm6996_priv *priv, const char *alias, struct net_device *netdev)
994 {
995 struct switch_dev *swdev;
996 u16 test, old;
997
998 if (!priv->model) {
999 /* Detect type of chip */
1000 old = r16(priv, ADM_VID_CHECK);
1001 test = old ^ (1 << 12);
1002 w16(priv, ADM_VID_CHECK, test);
1003 test ^= r16(priv, ADM_VID_CHECK);
1004 if (test & (1 << 12)) {
1005 /*
1006 * Bit 12 of this register is read-only.
1007 * This is the FC model.
1008 */
1009 priv->model = ADM6996FC;
1010 } else {
1011 /* Bit 12 is read-write. This is the M model. */
1012 priv->model = ADM6996M;
1013 w16(priv, ADM_VID_CHECK, old);
1014 }
1015 }
1016
1017 swdev = &priv->dev;
1018 swdev->name = (adm6996_model_name[priv->model]);
1019 swdev->cpu_port = ADM_CPU_PORT;
1020 swdev->ports = ADM_NUM_PORTS;
1021 swdev->vlans = ADM_NUM_VLANS;
1022 swdev->ops = &adm6996_ops;
1023 swdev->alias = alias;
1024
1025 /* The ADM6996L connected through GPIOs does not support any switch
1026 status calls */
1027 if (priv->model == ADM6996L) {
1028 adm6996_ops.attr_port.n_attr = 0;
1029 adm6996_ops.get_port_link = NULL;
1030 }
1031
1032 pr_info ("%s: %s model PHY found.\n", alias, swdev->name);
1033
1034 mutex_lock(&priv->reg_mutex);
1035 adm6996_perform_reset (priv);
1036 mutex_unlock(&priv->reg_mutex);
1037
1038 if (priv->model == ADM6996M || priv->model == ADM6996L) {
1039 return register_switch(swdev, netdev);
1040 }
1041
1042 return -ENODEV;
1043 }
1044
1045 static int adm6996_config_init(struct phy_device *pdev)
1046 {
1047 struct adm6996_priv *priv;
1048 int ret;
1049
1050 pdev->supported = ADVERTISED_100baseT_Full;
1051 pdev->advertising = ADVERTISED_100baseT_Full;
1052
1053 if (pdev->mdio.addr != 0) {
1054 pr_info ("%s: PHY overlaps ADM6996, providing fixed PHY 0x%x.\n"
1055 , pdev->attached_dev->name, pdev->mdio.addr);
1056 return 0;
1057 }
1058
1059 priv = devm_kzalloc(&pdev->mdio.dev, sizeof(struct adm6996_priv), GFP_KERNEL);
1060 if (!priv)
1061 return -ENOMEM;
1062
1063 mutex_init(&priv->reg_mutex);
1064 mutex_init(&priv->mib_lock);
1065 priv->priv = pdev;
1066 priv->read = adm6996_read_mii_reg;
1067 priv->write = adm6996_write_mii_reg;
1068
1069 ret = adm6996_switch_init(priv, pdev->attached_dev->name, pdev->attached_dev);
1070 if (ret < 0)
1071 return ret;
1072
1073 pdev->priv = priv;
1074
1075 return 0;
1076 }
1077
1078 /*
1079 * Warning: phydev->priv is NULL if phydev->mdio.addr != 0
1080 */
1081 static int adm6996_read_status(struct phy_device *phydev)
1082 {
1083 phydev->speed = SPEED_100;
1084 phydev->duplex = DUPLEX_FULL;
1085 phydev->link = 1;
1086
1087 phydev->state = PHY_RUNNING;
1088 netif_carrier_on(phydev->attached_dev);
1089 phydev->adjust_link(phydev->attached_dev);
1090
1091 return 0;
1092 }
1093
1094 /*
1095 * Warning: phydev->priv is NULL if phydev->mdio.addr != 0
1096 */
1097 static int adm6996_config_aneg(struct phy_device *phydev)
1098 {
1099 return 0;
1100 }
1101
1102 static int adm6996_fixup(struct phy_device *dev)
1103 {
1104 struct mii_bus *bus = dev->mdio.bus;
1105 u16 reg;
1106
1107 /* Our custom registers are at PHY addresses 0-10. Claim those. */
1108 if (dev->mdio.addr > 10)
1109 return 0;
1110
1111 /* look for the switch on the bus */
1112 reg = bus->read(bus, PHYADDR(ADM_SIG0)) & ADM_SIG0_MASK;
1113 if (reg != ADM_SIG0_VAL)
1114 return 0;
1115
1116 reg = bus->read(bus, PHYADDR(ADM_SIG1)) & ADM_SIG1_MASK;
1117 if (reg != ADM_SIG1_VAL)
1118 return 0;
1119
1120 dev->phy_id = (ADM_SIG0_VAL << 16) | ADM_SIG1_VAL;
1121
1122 return 0;
1123 }
1124
1125 static int adm6996_probe(struct phy_device *pdev)
1126 {
1127 return 0;
1128 }
1129
1130 static void adm6996_remove(struct phy_device *pdev)
1131 {
1132 struct adm6996_priv *priv = phy_to_adm(pdev);
1133
1134 if (priv && (priv->model == ADM6996M || priv->model == ADM6996L))
1135 unregister_switch(&priv->dev);
1136 }
1137
1138 static int adm6996_soft_reset(struct phy_device *phydev)
1139 {
1140 /* we don't need an extra reset */
1141 return 0;
1142 }
1143
1144 static struct phy_driver adm6996_phy_driver = {
1145 .name = "Infineon ADM6996",
1146 .phy_id = (ADM_SIG0_VAL << 16) | ADM_SIG1_VAL,
1147 .phy_id_mask = 0xffffffff,
1148 .features = PHY_BASIC_FEATURES,
1149 .probe = adm6996_probe,
1150 .remove = adm6996_remove,
1151 .config_init = &adm6996_config_init,
1152 .config_aneg = &adm6996_config_aneg,
1153 .read_status = &adm6996_read_status,
1154 .soft_reset = adm6996_soft_reset,
1155 };
1156
1157 static int adm6996_gpio_probe(struct platform_device *pdev)
1158 {
1159 struct adm6996_gpio_platform_data *pdata = pdev->dev.platform_data;
1160 struct adm6996_priv *priv;
1161 int ret;
1162
1163 if (!pdata)
1164 return -EINVAL;
1165
1166 priv = devm_kzalloc(&pdev->dev, sizeof(struct adm6996_priv), GFP_KERNEL);
1167 if (!priv)
1168 return -ENOMEM;
1169
1170 mutex_init(&priv->reg_mutex);
1171 mutex_init(&priv->mib_lock);
1172
1173 priv->eecs = pdata->eecs;
1174 priv->eedi = pdata->eedi;
1175 priv->eesk = pdata->eesk;
1176
1177 priv->model = pdata->model;
1178 priv->read = adm6996_read_gpio_reg;
1179 priv->write = adm6996_write_gpio_reg;
1180
1181 ret = devm_gpio_request(&pdev->dev, priv->eecs, "adm_eecs");
1182 if (ret)
1183 return ret;
1184 ret = devm_gpio_request(&pdev->dev, priv->eedi, "adm_eedi");
1185 if (ret)
1186 return ret;
1187 ret = devm_gpio_request(&pdev->dev, priv->eesk, "adm_eesk");
1188 if (ret)
1189 return ret;
1190
1191 ret = adm6996_switch_init(priv, dev_name(&pdev->dev), NULL);
1192 if (ret < 0)
1193 return ret;
1194
1195 platform_set_drvdata(pdev, priv);
1196
1197 return 0;
1198 }
1199
1200 static int adm6996_gpio_remove(struct platform_device *pdev)
1201 {
1202 struct adm6996_priv *priv = platform_get_drvdata(pdev);
1203
1204 if (priv && (priv->model == ADM6996M || priv->model == ADM6996L))
1205 unregister_switch(&priv->dev);
1206
1207 return 0;
1208 }
1209
1210 static struct platform_driver adm6996_gpio_driver = {
1211 .probe = adm6996_gpio_probe,
1212 .remove = adm6996_gpio_remove,
1213 .driver = {
1214 .name = "adm6996_gpio",
1215 },
1216 };
1217
1218 static int __init adm6996_init(void)
1219 {
1220 int err;
1221
1222 phy_register_fixup_for_id(PHY_ANY_ID, adm6996_fixup);
1223 err = phy_driver_register(&adm6996_phy_driver, THIS_MODULE);
1224 if (err)
1225 return err;
1226
1227 err = platform_driver_register(&adm6996_gpio_driver);
1228 if (err)
1229 phy_driver_unregister(&adm6996_phy_driver);
1230
1231 return err;
1232 }
1233
1234 static void __exit adm6996_exit(void)
1235 {
1236 platform_driver_unregister(&adm6996_gpio_driver);
1237 phy_driver_unregister(&adm6996_phy_driver);
1238 }
1239
1240 module_init(adm6996_init);
1241 module_exit(adm6996_exit);
Staging tree of Alvaro Fernandez Rojas