projects / openwrt / staging / chunkeey.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ipq40xx: only include ath10k-board-qca4019 for the generic subtarget
[openwrt/staging/chunkeey.git] / target / linux / generic / files / drivers / net / phy / rtl8366_smi.c
1 /*
2 * Realtek RTL8366 SMI interface driver
3 *
4 * Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published
8 * by the Free Software Foundation.
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/device.h>
14 #include <linux/delay.h>
15 #include <linux/gpio.h>
16 #include <linux/spinlock.h>
17 #include <linux/skbuff.h>
18 #include <linux/of.h>
19 #include <linux/of_platform.h>
20 #include <linux/of_gpio.h>
21 #include <linux/rtl8366.h>
22 #include <linux/version.h>
23 #include <linux/of_mdio.h>
24
25 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
26 #include <linux/debugfs.h>
27 #endif
28
29 #include "rtl8366_smi.h"
30
31 #define RTL8366_SMI_ACK_RETRY_COUNT 5
32
33 #define RTL8366_SMI_HW_STOP_DELAY 25 /* msecs */
34 #define RTL8366_SMI_HW_START_DELAY 100 /* msecs */
35
36 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
37 {
38 ndelay(smi->clk_delay);
39 }
40
41 static void rtl8366_smi_start(struct rtl8366_smi *smi)
42 {
43 unsigned int sda = smi->gpio_sda;
44 unsigned int sck = smi->gpio_sck;
45
46 /*
47 * Set GPIO pins to output mode, with initial state:
48 * SCK = 0, SDA = 1
49 */
50 gpio_direction_output(sck, 0);
51 gpio_direction_output(sda, 1);
52 rtl8366_smi_clk_delay(smi);
53
54 /* CLK 1: 0 -> 1, 1 -> 0 */
55 gpio_set_value(sck, 1);
56 rtl8366_smi_clk_delay(smi);
57 gpio_set_value(sck, 0);
58 rtl8366_smi_clk_delay(smi);
59
60 /* CLK 2: */
61 gpio_set_value(sck, 1);
62 rtl8366_smi_clk_delay(smi);
63 gpio_set_value(sda, 0);
64 rtl8366_smi_clk_delay(smi);
65 gpio_set_value(sck, 0);
66 rtl8366_smi_clk_delay(smi);
67 gpio_set_value(sda, 1);
68 }
69
70 static void rtl8366_smi_stop(struct rtl8366_smi *smi)
71 {
72 unsigned int sda = smi->gpio_sda;
73 unsigned int sck = smi->gpio_sck;
74
75 rtl8366_smi_clk_delay(smi);
76 gpio_set_value(sda, 0);
77 gpio_set_value(sck, 1);
78 rtl8366_smi_clk_delay(smi);
79 gpio_set_value(sda, 1);
80 rtl8366_smi_clk_delay(smi);
81 gpio_set_value(sck, 1);
82 rtl8366_smi_clk_delay(smi);
83 gpio_set_value(sck, 0);
84 rtl8366_smi_clk_delay(smi);
85 gpio_set_value(sck, 1);
86
87 /* add a click */
88 rtl8366_smi_clk_delay(smi);
89 gpio_set_value(sck, 0);
90 rtl8366_smi_clk_delay(smi);
91 gpio_set_value(sck, 1);
92
93 /* set GPIO pins to input mode */
94 gpio_direction_input(sda);
95 gpio_direction_input(sck);
96 }
97
98 static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
99 {
100 unsigned int sda = smi->gpio_sda;
101 unsigned int sck = smi->gpio_sck;
102
103 for (; len > 0; len--) {
104 rtl8366_smi_clk_delay(smi);
105
106 /* prepare data */
107 gpio_set_value(sda, !!(data & ( 1 << (len - 1))));
108 rtl8366_smi_clk_delay(smi);
109
110 /* clocking */
111 gpio_set_value(sck, 1);
112 rtl8366_smi_clk_delay(smi);
113 gpio_set_value(sck, 0);
114 }
115 }
116
117 static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
118 {
119 unsigned int sda = smi->gpio_sda;
120 unsigned int sck = smi->gpio_sck;
121
122 gpio_direction_input(sda);
123
124 for (*data = 0; len > 0; len--) {
125 u32 u;
126
127 rtl8366_smi_clk_delay(smi);
128
129 /* clocking */
130 gpio_set_value(sck, 1);
131 rtl8366_smi_clk_delay(smi);
132 u = !!gpio_get_value(sda);
133 gpio_set_value(sck, 0);
134
135 *data |= (u << (len - 1));
136 }
137
138 gpio_direction_output(sda, 0);
139 }
140
141 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
142 {
143 int retry_cnt;
144
145 retry_cnt = 0;
146 do {
147 u32 ack;
148
149 rtl8366_smi_read_bits(smi, 1, &ack);
150 if (ack == 0)
151 break;
152
153 if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT) {
154 dev_err(smi->parent, "ACK timeout\n");
155 return -ETIMEDOUT;
156 }
157 } while (1);
158
159 return 0;
160 }
161
162 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
163 {
164 rtl8366_smi_write_bits(smi, data, 8);
165 return rtl8366_smi_wait_for_ack(smi);
166 }
167
168 static int rtl8366_smi_write_byte_noack(struct rtl8366_smi *smi, u8 data)
169 {
170 rtl8366_smi_write_bits(smi, data, 8);
171 return 0;
172 }
173
174 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
175 {
176 u32 t;
177
178 /* read data */
179 rtl8366_smi_read_bits(smi, 8, &t);
180 *data = (t & 0xff);
181
182 /* send an ACK */
183 rtl8366_smi_write_bits(smi, 0x00, 1);
184
185 return 0;
186 }
187
188 static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
189 {
190 u32 t;
191
192 /* read data */
193 rtl8366_smi_read_bits(smi, 8, &t);
194 *data = (t & 0xff);
195
196 /* send an ACK */
197 rtl8366_smi_write_bits(smi, 0x01, 1);
198
199 return 0;
200 }
201
202 static int __rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
203 {
204 unsigned long flags;
205 u8 lo = 0;
206 u8 hi = 0;
207 int ret;
208
209 spin_lock_irqsave(&smi->lock, flags);
210
211 rtl8366_smi_start(smi);
212
213 /* send READ command */
214 ret = rtl8366_smi_write_byte(smi, smi->cmd_read);
215 if (ret)
216 goto out;
217
218 /* set ADDR[7:0] */
219 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
220 if (ret)
221 goto out;
222
223 /* set ADDR[15:8] */
224 ret = rtl8366_smi_write_byte(smi, addr >> 8);
225 if (ret)
226 goto out;
227
228 /* read DATA[7:0] */
229 rtl8366_smi_read_byte0(smi, &lo);
230 /* read DATA[15:8] */
231 rtl8366_smi_read_byte1(smi, &hi);
232
233 *data = ((u32) lo) | (((u32) hi) << 8);
234
235 ret = 0;
236
237 out:
238 rtl8366_smi_stop(smi);
239 spin_unlock_irqrestore(&smi->lock, flags);
240
241 return ret;
242 }
243 /* Read/write via mdiobus */
244 #define MDC_MDIO_CTRL0_REG 31
245 #define MDC_MDIO_START_REG 29
246 #define MDC_MDIO_CTRL1_REG 21
247 #define MDC_MDIO_ADDRESS_REG 23
248 #define MDC_MDIO_DATA_WRITE_REG 24
249 #define MDC_MDIO_DATA_READ_REG 25
250
251 #define MDC_MDIO_START_OP 0xFFFF
252 #define MDC_MDIO_ADDR_OP 0x000E
253 #define MDC_MDIO_READ_OP 0x0001
254 #define MDC_MDIO_WRITE_OP 0x0003
255 #define MDC_REALTEK_PHY_ADDR 0x0
256
257 int __rtl8366_mdio_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
258 {
259 u32 phy_id = MDC_REALTEK_PHY_ADDR;
260 struct mii_bus *mbus = smi->ext_mbus;
261
262 BUG_ON(in_interrupt());
263
264 mutex_lock(&mbus->mdio_lock);
265 /* Write Start command to register 29 */
266 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
267
268 /* Write address control code to register 31 */
269 mbus->write(mbus, phy_id, MDC_MDIO_CTRL0_REG, MDC_MDIO_ADDR_OP);
270
271 /* Write Start command to register 29 */
272 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
273
274 /* Write address to register 23 */
275 mbus->write(mbus, phy_id, MDC_MDIO_ADDRESS_REG, addr);
276
277 /* Write Start command to register 29 */
278 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
279
280 /* Write read control code to register 21 */
281 mbus->write(mbus, phy_id, MDC_MDIO_CTRL1_REG, MDC_MDIO_READ_OP);
282
283 /* Write Start command to register 29 */
284 mbus->write(smi->ext_mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
285
286 /* Read data from register 25 */
287 *data = mbus->read(mbus, phy_id, MDC_MDIO_DATA_READ_REG);
288
289 mutex_unlock(&mbus->mdio_lock);
290
291 return 0;
292 }
293
294 static int __rtl8366_mdio_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
295 {
296 u32 phy_id = MDC_REALTEK_PHY_ADDR;
297 struct mii_bus *mbus = smi->ext_mbus;
298
299 BUG_ON(in_interrupt());
300
301 mutex_lock(&mbus->mdio_lock);
302
303 /* Write Start command to register 29 */
304 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
305
306 /* Write address control code to register 31 */
307 mbus->write(mbus, phy_id, MDC_MDIO_CTRL0_REG, MDC_MDIO_ADDR_OP);
308
309 /* Write Start command to register 29 */
310 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
311
312 /* Write address to register 23 */
313 mbus->write(mbus, phy_id, MDC_MDIO_ADDRESS_REG, addr);
314
315 /* Write Start command to register 29 */
316 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
317
318 /* Write data to register 24 */
319 mbus->write(mbus, phy_id, MDC_MDIO_DATA_WRITE_REG, data);
320
321 /* Write Start command to register 29 */
322 mbus->write(mbus, phy_id, MDC_MDIO_START_REG, MDC_MDIO_START_OP);
323
324 /* Write data control code to register 21 */
325 mbus->write(mbus, phy_id, MDC_MDIO_CTRL1_REG, MDC_MDIO_WRITE_OP);
326
327 mutex_unlock(&mbus->mdio_lock);
328 return 0;
329 }
330
331 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
332 {
333 if (smi->ext_mbus)
334 return __rtl8366_mdio_read_reg(smi, addr, data);
335 else
336 return __rtl8366_smi_read_reg(smi, addr, data);
337 }
338 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
339
340 static int __rtl8366_smi_write_reg(struct rtl8366_smi *smi,
341 u32 addr, u32 data, bool ack)
342 {
343 unsigned long flags;
344 int ret;
345
346 spin_lock_irqsave(&smi->lock, flags);
347
348 rtl8366_smi_start(smi);
349
350 /* send WRITE command */
351 ret = rtl8366_smi_write_byte(smi, smi->cmd_write);
352 if (ret)
353 goto out;
354
355 /* set ADDR[7:0] */
356 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
357 if (ret)
358 goto out;
359
360 /* set ADDR[15:8] */
361 ret = rtl8366_smi_write_byte(smi, addr >> 8);
362 if (ret)
363 goto out;
364
365 /* write DATA[7:0] */
366 ret = rtl8366_smi_write_byte(smi, data & 0xff);
367 if (ret)
368 goto out;
369
370 /* write DATA[15:8] */
371 if (ack)
372 ret = rtl8366_smi_write_byte(smi, data >> 8);
373 else
374 ret = rtl8366_smi_write_byte_noack(smi, data >> 8);
375 if (ret)
376 goto out;
377
378 ret = 0;
379
380 out:
381 rtl8366_smi_stop(smi);
382 spin_unlock_irqrestore(&smi->lock, flags);
383
384 return ret;
385 }
386
387 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
388 {
389 if (smi->ext_mbus)
390 return __rtl8366_mdio_write_reg(smi, addr, data);
391 else
392 return __rtl8366_smi_write_reg(smi, addr, data, true);
393 }
394 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
395
396 int rtl8366_smi_write_reg_noack(struct rtl8366_smi *smi, u32 addr, u32 data)
397 {
398 return __rtl8366_smi_write_reg(smi, addr, data, false);
399 }
400 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack);
401
402 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
403 {
404 u32 t;
405 int err;
406
407 err = rtl8366_smi_read_reg(smi, addr, &t);
408 if (err)
409 return err;
410
411 err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
412 return err;
413
414 }
415 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
416
417 static int rtl8366_reset(struct rtl8366_smi *smi)
418 {
419 if (smi->hw_reset) {
420 smi->hw_reset(smi, true);
421 msleep(RTL8366_SMI_HW_STOP_DELAY);
422 smi->hw_reset(smi, false);
423 msleep(RTL8366_SMI_HW_START_DELAY);
424 return 0;
425 }
426
427 return smi->ops->reset_chip(smi);
428 }
429
430 static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
431 {
432 int err;
433 int i;
434
435 *used = 0;
436 for (i = 0; i < smi->num_ports; i++) {
437 int index = 0;
438
439 err = smi->ops->get_mc_index(smi, i, &index);
440 if (err)
441 return err;
442
443 if (mc_index == index) {
444 *used = 1;
445 break;
446 }
447 }
448
449 return 0;
450 }
451
452 static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
453 u32 untag, u32 fid)
454 {
455 struct rtl8366_vlan_4k vlan4k;
456 int err;
457 int i;
458
459 /* Update the 4K table */
460 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
461 if (err)
462 return err;
463
464 vlan4k.member = member;
465 vlan4k.untag = untag;
466 vlan4k.fid = fid;
467 err = smi->ops->set_vlan_4k(smi, &vlan4k);
468 if (err)
469 return err;
470
471 /* Try to find an existing MC entry for this VID */
472 for (i = 0; i < smi->num_vlan_mc; i++) {
473 struct rtl8366_vlan_mc vlanmc;
474
475 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
476 if (err)
477 return err;
478
479 if (vid == vlanmc.vid) {
480 /* update the MC entry */
481 vlanmc.member = member;
482 vlanmc.untag = untag;
483 vlanmc.fid = fid;
484
485 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
486 break;
487 }
488 }
489
490 return err;
491 }
492
493 static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
494 {
495 struct rtl8366_vlan_mc vlanmc;
496 int err;
497 int index;
498
499 err = smi->ops->get_mc_index(smi, port, &index);
500 if (err)
501 return err;
502
503 err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
504 if (err)
505 return err;
506
507 *val = vlanmc.vid;
508 return 0;
509 }
510
511 static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
512 unsigned vid)
513 {
514 struct rtl8366_vlan_mc vlanmc;
515 struct rtl8366_vlan_4k vlan4k;
516 int err;
517 int i;
518
519 /* Try to find an existing MC entry for this VID */
520 for (i = 0; i < smi->num_vlan_mc; i++) {
521 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
522 if (err)
523 return err;
524
525 if (vid == vlanmc.vid) {
526 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
527 if (err)
528 return err;
529
530 err = smi->ops->set_mc_index(smi, port, i);
531 return err;
532 }
533 }
534
535 /* We have no MC entry for this VID, try to find an empty one */
536 for (i = 0; i < smi->num_vlan_mc; i++) {
537 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
538 if (err)
539 return err;
540
541 if (vlanmc.vid == 0 && vlanmc.member == 0) {
542 /* Update the entry from the 4K table */
543 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
544 if (err)
545 return err;
546
547 vlanmc.vid = vid;
548 vlanmc.member = vlan4k.member;
549 vlanmc.untag = vlan4k.untag;
550 vlanmc.fid = vlan4k.fid;
551 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
552 if (err)
553 return err;
554
555 err = smi->ops->set_mc_index(smi, port, i);
556 return err;
557 }
558 }
559
560 /* MC table is full, try to find an unused entry and replace it */
561 for (i = 0; i < smi->num_vlan_mc; i++) {
562 int used;
563
564 err = rtl8366_mc_is_used(smi, i, &used);
565 if (err)
566 return err;
567
568 if (!used) {
569 /* Update the entry from the 4K table */
570 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
571 if (err)
572 return err;
573
574 vlanmc.vid = vid;
575 vlanmc.member = vlan4k.member;
576 vlanmc.untag = vlan4k.untag;
577 vlanmc.fid = vlan4k.fid;
578 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
579 if (err)
580 return err;
581
582 err = smi->ops->set_mc_index(smi, port, i);
583 return err;
584 }
585 }
586
587 dev_err(smi->parent,
588 "all VLAN member configurations are in use\n");
589
590 return -ENOSPC;
591 }
592
593 int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
594 {
595 int err;
596
597 err = smi->ops->enable_vlan(smi, enable);
598 if (err)
599 return err;
600
601 smi->vlan_enabled = enable;
602
603 if (!enable) {
604 smi->vlan4k_enabled = 0;
605 err = smi->ops->enable_vlan4k(smi, enable);
606 }
607
608 return err;
609 }
610 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
611
612 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
613 {
614 int err;
615
616 if (enable) {
617 err = smi->ops->enable_vlan(smi, enable);
618 if (err)
619 return err;
620
621 smi->vlan_enabled = enable;
622 }
623
624 err = smi->ops->enable_vlan4k(smi, enable);
625 if (err)
626 return err;
627
628 smi->vlan4k_enabled = enable;
629 return 0;
630 }
631
632 int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
633 {
634 int port;
635 int err;
636
637 for (port = 0; port < smi->num_ports; port++) {
638 err = smi->ops->enable_port(smi, port, enable);
639 if (err)
640 return err;
641 }
642
643 return 0;
644 }
645 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
646
647 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
648 {
649 struct rtl8366_vlan_mc vlanmc;
650 int err;
651 int i;
652
653 rtl8366_enable_vlan(smi, 0);
654 rtl8366_enable_vlan4k(smi, 0);
655
656 /* clear VLAN member configurations */
657 vlanmc.vid = 0;
658 vlanmc.priority = 0;
659 vlanmc.member = 0;
660 vlanmc.untag = 0;
661 vlanmc.fid = 0;
662 for (i = 0; i < smi->num_vlan_mc; i++) {
663 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
664 if (err)
665 return err;
666 }
667
668 return 0;
669 }
670 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
671
672 static int rtl8366_init_vlan(struct rtl8366_smi *smi)
673 {
674 int port;
675 int err;
676
677 err = rtl8366_reset_vlan(smi);
678 if (err)
679 return err;
680
681 for (port = 0; port < smi->num_ports; port++) {
682 u32 mask;
683
684 if (port == smi->cpu_port)
685 mask = (1 << smi->num_ports) - 1;
686 else
687 mask = (1 << port) | (1 << smi->cpu_port);
688
689 err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
690 if (err)
691 return err;
692
693 err = rtl8366_set_pvid(smi, port, (port + 1));
694 if (err)
695 return err;
696 }
697
698 return rtl8366_enable_vlan(smi, 1);
699 }
700
701 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
702 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
703 {
704 file->private_data = inode->i_private;
705 return 0;
706 }
707 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
708
709 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
710 char __user *user_buf,
711 size_t count, loff_t *ppos)
712 {
713 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
714 int i, len = 0;
715 char *buf = smi->buf;
716
717 len += snprintf(buf + len, sizeof(smi->buf) - len,
718 "%2s %6s %4s %6s %6s %3s\n",
719 "id", "vid","prio", "member", "untag", "fid");
720
721 for (i = 0; i < smi->num_vlan_mc; ++i) {
722 struct rtl8366_vlan_mc vlanmc;
723
724 smi->ops->get_vlan_mc(smi, i, &vlanmc);
725
726 len += snprintf(buf + len, sizeof(smi->buf) - len,
727 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
728 i, vlanmc.vid, vlanmc.priority,
729 vlanmc.member, vlanmc.untag, vlanmc.fid);
730 }
731
732 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
733 }
734
735 #define RTL8366_VLAN4K_PAGE_SIZE 64
736 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
737
738 static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
739 char __user *user_buf,
740 size_t count, loff_t *ppos)
741 {
742 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
743 int i, len = 0;
744 int offset;
745 char *buf = smi->buf;
746
747 if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
748 len += snprintf(buf + len, sizeof(smi->buf) - len,
749 "invalid page: %u\n", smi->dbg_vlan_4k_page);
750 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
751 }
752
753 len += snprintf(buf + len, sizeof(smi->buf) - len,
754 "%4s %6s %6s %3s\n",
755 "vid", "member", "untag", "fid");
756
757 offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
758 for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
759 struct rtl8366_vlan_4k vlan4k;
760
761 smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
762
763 len += snprintf(buf + len, sizeof(smi->buf) - len,
764 "%4d 0x%04x 0x%04x %3d\n",
765 vlan4k.vid, vlan4k.member,
766 vlan4k.untag, vlan4k.fid);
767 }
768
769 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
770 }
771
772 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
773 char __user *user_buf,
774 size_t count, loff_t *ppos)
775 {
776 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
777 char *buf = smi->buf;
778 int len = 0;
779 int i;
780
781 len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
782 "port", "pvid");
783
784 for (i = 0; i < smi->num_ports; i++) {
785 int pvid;
786 int err;
787
788 err = rtl8366_get_pvid(smi, i, &pvid);
789 if (err)
790 len += snprintf(buf + len, sizeof(smi->buf) - len,
791 "%4d error\n", i);
792 else
793 len += snprintf(buf + len, sizeof(smi->buf) - len,
794 "%4d %4d\n", i, pvid);
795 }
796
797 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
798 }
799
800 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
801 char __user *user_buf,
802 size_t count, loff_t *ppos)
803 {
804 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
805 u32 t, reg = smi->dbg_reg;
806 int err, len = 0;
807 char *buf = smi->buf;
808
809 memset(buf, '\0', sizeof(smi->buf));
810
811 err = rtl8366_smi_read_reg(smi, reg, &t);
812 if (err) {
813 len += snprintf(buf, sizeof(smi->buf),
814 "Read failed (reg: 0x%04x)\n", reg);
815 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
816 }
817
818 len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
819 reg, t);
820
821 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
822 }
823
824 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
825 const char __user *user_buf,
826 size_t count, loff_t *ppos)
827 {
828 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
829 unsigned long data;
830 u32 reg = smi->dbg_reg;
831 int err;
832 size_t len;
833 char *buf = smi->buf;
834
835 len = min(count, sizeof(smi->buf) - 1);
836 if (copy_from_user(buf, user_buf, len)) {
837 dev_err(smi->parent, "copy from user failed\n");
838 return -EFAULT;
839 }
840
841 buf[len] = '\0';
842 if (len > 0 && buf[len - 1] == '\n')
843 buf[len - 1] = '\0';
844
845
846 if (kstrtoul(buf, 16, &data)) {
847 dev_err(smi->parent, "Invalid reg value %s\n", buf);
848 } else {
849 err = rtl8366_smi_write_reg(smi, reg, data);
850 if (err) {
851 dev_err(smi->parent,
852 "writing reg 0x%04x val 0x%04lx failed\n",
853 reg, data);
854 }
855 }
856
857 return count;
858 }
859
860 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
861 char __user *user_buf,
862 size_t count, loff_t *ppos)
863 {
864 struct rtl8366_smi *smi = file->private_data;
865 int i, j, len = 0;
866 char *buf = smi->buf;
867
868 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
869 "Counter");
870
871 for (i = 0; i < smi->num_ports; i++) {
872 char port_buf[10];
873
874 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
875 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
876 port_buf);
877 }
878 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
879
880 for (i = 0; i < smi->num_mib_counters; i++) {
881 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
882 smi->mib_counters[i].name);
883 for (j = 0; j < smi->num_ports; j++) {
884 unsigned long long counter = 0;
885
886 if (!smi->ops->get_mib_counter(smi, i, j, &counter))
887 len += snprintf(buf + len,
888 sizeof(smi->buf) - len,
889 "%12llu ", counter);
890 else
891 len += snprintf(buf + len,
892 sizeof(smi->buf) - len,
893 "%12s ", "error");
894 }
895 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
896 }
897
898 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
899 }
900
901 static const struct file_operations fops_rtl8366_regs = {
902 .read = rtl8366_read_debugfs_reg,
903 .write = rtl8366_write_debugfs_reg,
904 .open = rtl8366_debugfs_open,
905 .owner = THIS_MODULE
906 };
907
908 static const struct file_operations fops_rtl8366_vlan_mc = {
909 .read = rtl8366_read_debugfs_vlan_mc,
910 .open = rtl8366_debugfs_open,
911 .owner = THIS_MODULE
912 };
913
914 static const struct file_operations fops_rtl8366_vlan_4k = {
915 .read = rtl8366_read_debugfs_vlan_4k,
916 .open = rtl8366_debugfs_open,
917 .owner = THIS_MODULE
918 };
919
920 static const struct file_operations fops_rtl8366_pvid = {
921 .read = rtl8366_read_debugfs_pvid,
922 .open = rtl8366_debugfs_open,
923 .owner = THIS_MODULE
924 };
925
926 static const struct file_operations fops_rtl8366_mibs = {
927 .read = rtl8366_read_debugfs_mibs,
928 .open = rtl8366_debugfs_open,
929 .owner = THIS_MODULE
930 };
931
932 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
933 {
934 struct dentry *node;
935 struct dentry *root;
936
937 if (!smi->debugfs_root)
938 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
939 NULL);
940
941 if (!smi->debugfs_root) {
942 dev_err(smi->parent, "Unable to create debugfs dir\n");
943 return;
944 }
945 root = smi->debugfs_root;
946
947 node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
948 &smi->dbg_reg);
949 if (!node) {
950 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
951 "reg");
952 return;
953 }
954
955 node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
956 &fops_rtl8366_regs);
957 if (!node) {
958 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
959 "val");
960 return;
961 }
962
963 node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
964 &fops_rtl8366_vlan_mc);
965 if (!node) {
966 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
967 "vlan_mc");
968 return;
969 }
970
971 node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
972 &smi->dbg_vlan_4k_page);
973 if (!node) {
974 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
975 "vlan_4k_page");
976 return;
977 }
978
979 node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
980 &fops_rtl8366_vlan_4k);
981 if (!node) {
982 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
983 "vlan_4k");
984 return;
985 }
986
987 node = debugfs_create_file("pvid", S_IRUSR, root, smi,
988 &fops_rtl8366_pvid);
989 if (!node) {
990 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
991 "pvid");
992 return;
993 }
994
995 node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
996 &fops_rtl8366_mibs);
997 if (!node)
998 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
999 "mibs");
1000 }
1001
1002 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
1003 {
1004 if (smi->debugfs_root) {
1005 debugfs_remove_recursive(smi->debugfs_root);
1006 smi->debugfs_root = NULL;
1007 }
1008 }
1009 #else
1010 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
1011 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
1012 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
1013
1014 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
1015 {
1016 int ret;
1017
1018 #ifdef CONFIG_OF
1019 struct device_node *np = NULL;
1020
1021 np = of_get_child_by_name(smi->parent->of_node, "mdio-bus");
1022 #endif
1023
1024 smi->mii_bus = mdiobus_alloc();
1025 if (smi->mii_bus == NULL) {
1026 ret = -ENOMEM;
1027 goto err;
1028 }
1029
1030 smi->mii_bus->priv = (void *) smi;
1031 smi->mii_bus->name = dev_name(smi->parent);
1032 smi->mii_bus->read = smi->ops->mii_read;
1033 smi->mii_bus->write = smi->ops->mii_write;
1034 snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
1035 dev_name(smi->parent));
1036 smi->mii_bus->parent = smi->parent;
1037 smi->mii_bus->phy_mask = ~(0x1f);
1038
1039 #ifdef CONFIG_OF
1040 if (np)
1041 ret = of_mdiobus_register(smi->mii_bus, np);
1042 else
1043 #endif
1044 ret = mdiobus_register(smi->mii_bus);
1045
1046 if (ret)
1047 goto err_free;
1048
1049 return 0;
1050
1051 err_free:
1052 mdiobus_free(smi->mii_bus);
1053 err:
1054 return ret;
1055 }
1056
1057 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
1058 {
1059 mdiobus_unregister(smi->mii_bus);
1060 mdiobus_free(smi->mii_bus);
1061 }
1062
1063 int rtl8366_sw_reset_switch(struct switch_dev *dev)
1064 {
1065 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1066 int err;
1067
1068 err = rtl8366_reset(smi);
1069 if (err)
1070 return err;
1071
1072 err = smi->ops->setup(smi);
1073 if (err)
1074 return err;
1075
1076 err = rtl8366_reset_vlan(smi);
1077 if (err)
1078 return err;
1079
1080 err = rtl8366_enable_vlan(smi, 1);
1081 if (err)
1082 return err;
1083
1084 return rtl8366_enable_all_ports(smi, 1);
1085 }
1086 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch);
1087
1088 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
1089 {
1090 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1091 return rtl8366_get_pvid(smi, port, val);
1092 }
1093 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
1094
1095 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
1096 {
1097 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1098 return rtl8366_set_pvid(smi, port, val);
1099 }
1100 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
1101
1102 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
1103 const struct switch_attr *attr,
1104 struct switch_val *val)
1105 {
1106 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1107 int i, len = 0;
1108 unsigned long long counter = 0;
1109 char *buf = smi->buf;
1110
1111 if (val->port_vlan >= smi->num_ports)
1112 return -EINVAL;
1113
1114 len += snprintf(buf + len, sizeof(smi->buf) - len,
1115 "Port %d MIB counters\n",
1116 val->port_vlan);
1117
1118 for (i = 0; i < smi->num_mib_counters; ++i) {
1119 len += snprintf(buf + len, sizeof(smi->buf) - len,
1120 "%-36s: ", smi->mib_counters[i].name);
1121 if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
1122 &counter))
1123 len += snprintf(buf + len, sizeof(smi->buf) - len,
1124 "%llu\n", counter);
1125 else
1126 len += snprintf(buf + len, sizeof(smi->buf) - len,
1127 "%s\n", "error");
1128 }
1129
1130 val->value.s = buf;
1131 val->len = len;
1132 return 0;
1133 }
1134 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
1135
1136 int rtl8366_sw_get_port_stats(struct switch_dev *dev, int port,
1137 struct switch_port_stats *stats,
1138 int txb_id, int rxb_id)
1139 {
1140 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1141 unsigned long long counter = 0;
1142 int ret;
1143
1144 if (port >= smi->num_ports)
1145 return -EINVAL;
1146
1147 ret = smi->ops->get_mib_counter(smi, txb_id, port, &counter);
1148 if (ret)
1149 return ret;
1150
1151 stats->tx_bytes = counter;
1152
1153 ret = smi->ops->get_mib_counter(smi, rxb_id, port, &counter);
1154 if (ret)
1155 return ret;
1156
1157 stats->rx_bytes = counter;
1158
1159 return 0;
1160 }
1161 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_stats);
1162
1163 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
1164 const struct switch_attr *attr,
1165 struct switch_val *val)
1166 {
1167 int i;
1168 u32 len = 0;
1169 struct rtl8366_vlan_4k vlan4k;
1170 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1171 char *buf = smi->buf;
1172 int err;
1173
1174 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1175 return -EINVAL;
1176
1177 memset(buf, '\0', sizeof(smi->buf));
1178
1179 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1180 if (err)
1181 return err;
1182
1183 len += snprintf(buf + len, sizeof(smi->buf) - len,
1184 "VLAN %d: Ports: '", vlan4k.vid);
1185
1186 for (i = 0; i < smi->num_ports; i++) {
1187 if (!(vlan4k.member & (1 << i)))
1188 continue;
1189
1190 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1191 (vlan4k.untag & (1 << i)) ? "" : "t");
1192 }
1193
1194 len += snprintf(buf + len, sizeof(smi->buf) - len,
1195 "', members=%04x, untag=%04x, fid=%u",
1196 vlan4k.member, vlan4k.untag, vlan4k.fid);
1197
1198 val->value.s = buf;
1199 val->len = len;
1200
1201 return 0;
1202 }
1203 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1204
1205 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1206 {
1207 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1208 struct switch_port *port;
1209 struct rtl8366_vlan_4k vlan4k;
1210 int i;
1211
1212 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1213 return -EINVAL;
1214
1215 smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1216
1217 port = &val->value.ports[0];
1218 val->len = 0;
1219 for (i = 0; i < smi->num_ports; i++) {
1220 if (!(vlan4k.member & BIT(i)))
1221 continue;
1222
1223 port->id = i;
1224 port->flags = (vlan4k.untag & BIT(i)) ?
1225 0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1226 val->len++;
1227 port++;
1228 }
1229 return 0;
1230 }
1231 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1232
1233 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1234 {
1235 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1236 struct switch_port *port;
1237 u32 member = 0;
1238 u32 untag = 0;
1239 int err;
1240 int i;
1241
1242 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1243 return -EINVAL;
1244
1245 port = &val->value.ports[0];
1246 for (i = 0; i < val->len; i++, port++) {
1247 int pvid = 0;
1248 member |= BIT(port->id);
1249
1250 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1251 untag |= BIT(port->id);
1252
1253 /*
1254 * To ensure that we have a valid MC entry for this VLAN,
1255 * initialize the port VLAN ID here.
1256 */
1257 err = rtl8366_get_pvid(smi, port->id, &pvid);
1258 if (err < 0)
1259 return err;
1260 if (pvid == 0) {
1261 err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1262 if (err < 0)
1263 return err;
1264 }
1265 }
1266
1267 return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1268 }
1269 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1270
1271 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1272 const struct switch_attr *attr,
1273 struct switch_val *val)
1274 {
1275 struct rtl8366_vlan_4k vlan4k;
1276 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1277 int err;
1278
1279 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1280 return -EINVAL;
1281
1282 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1283 if (err)
1284 return err;
1285
1286 val->value.i = vlan4k.fid;
1287
1288 return 0;
1289 }
1290 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1291
1292 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1293 const struct switch_attr *attr,
1294 struct switch_val *val)
1295 {
1296 struct rtl8366_vlan_4k vlan4k;
1297 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1298 int err;
1299
1300 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1301 return -EINVAL;
1302
1303 if (val->value.i < 0 || val->value.i > attr->max)
1304 return -EINVAL;
1305
1306 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1307 if (err)
1308 return err;
1309
1310 return rtl8366_set_vlan(smi, val->port_vlan,
1311 vlan4k.member,
1312 vlan4k.untag,
1313 val->value.i);
1314 }
1315 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1316
1317 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1318 const struct switch_attr *attr,
1319 struct switch_val *val)
1320 {
1321 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1322
1323 if (attr->ofs > 2)
1324 return -EINVAL;
1325
1326 if (attr->ofs == 1)
1327 val->value.i = smi->vlan_enabled;
1328 else
1329 val->value.i = smi->vlan4k_enabled;
1330
1331 return 0;
1332 }
1333 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1334
1335 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1336 const struct switch_attr *attr,
1337 struct switch_val *val)
1338 {
1339 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1340 int err;
1341
1342 if (attr->ofs > 2)
1343 return -EINVAL;
1344
1345 if (attr->ofs == 1)
1346 err = rtl8366_enable_vlan(smi, val->value.i);
1347 else
1348 err = rtl8366_enable_vlan4k(smi, val->value.i);
1349
1350 return err;
1351 }
1352 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1353
1354 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1355 {
1356 struct rtl8366_smi *smi;
1357
1358 BUG_ON(!parent);
1359
1360 smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1361 if (!smi) {
1362 dev_err(parent, "no memory for private data\n");
1363 return NULL;
1364 }
1365
1366 smi->parent = parent;
1367 return smi;
1368 }
1369 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1370
1371 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1372 {
1373 int err;
1374
1375 if (!smi->ext_mbus) {
1376 err = gpio_request(smi->gpio_sda, name);
1377 if (err) {
1378 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1379 smi->gpio_sda, err);
1380 goto err_out;
1381 }
1382
1383 err = gpio_request(smi->gpio_sck, name);
1384 if (err) {
1385 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1386 smi->gpio_sck, err);
1387 goto err_free_sda;
1388 }
1389 }
1390
1391 spin_lock_init(&smi->lock);
1392
1393 /* start the switch */
1394 if (smi->hw_reset) {
1395 smi->hw_reset(smi, false);
1396 msleep(RTL8366_SMI_HW_START_DELAY);
1397 }
1398
1399 return 0;
1400
1401 err_free_sda:
1402 gpio_free(smi->gpio_sda);
1403 err_out:
1404 return err;
1405 }
1406
1407 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1408 {
1409 if (smi->hw_reset)
1410 smi->hw_reset(smi, true);
1411
1412 if (!smi->ext_mbus) {
1413 gpio_free(smi->gpio_sck);
1414 gpio_free(smi->gpio_sda);
1415 }
1416 }
1417
1418 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1419 {
1420 static struct rtl8366_smi smi;
1421 enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1422 u32 reg = 0;
1423
1424 memset(&smi, 0, sizeof(smi));
1425 smi.gpio_sda = pdata->gpio_sda;
1426 smi.gpio_sck = pdata->gpio_sck;
1427 smi.clk_delay = 10;
1428 smi.cmd_read = 0xa9;
1429 smi.cmd_write = 0xa8;
1430
1431 if (__rtl8366_smi_init(&smi, "rtl8366"))
1432 goto out;
1433
1434 if (rtl8366_smi_read_reg(&smi, 0x5c, &reg))
1435 goto cleanup;
1436
1437 switch(reg) {
1438 case 0x6027:
1439 printk("Found an RTL8366S switch\n");
1440 type = RTL8366_TYPE_S;
1441 break;
1442 case 0x5937:
1443 printk("Found an RTL8366RB switch\n");
1444 type = RTL8366_TYPE_RB;
1445 break;
1446 default:
1447 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1448 break;
1449 }
1450
1451 cleanup:
1452 __rtl8366_smi_cleanup(&smi);
1453 out:
1454 return type;
1455 }
1456
1457 int rtl8366_smi_init(struct rtl8366_smi *smi)
1458 {
1459 int err;
1460
1461 if (!smi->ops)
1462 return -EINVAL;
1463
1464 err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1465 if (err)
1466 goto err_out;
1467
1468 if (!smi->ext_mbus)
1469 dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1470 smi->gpio_sda, smi->gpio_sck);
1471 else
1472 dev_info(smi->parent, "using MDIO bus '%s'\n", smi->ext_mbus->name);
1473
1474 err = smi->ops->detect(smi);
1475 if (err) {
1476 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1477 goto err_free_sck;
1478 }
1479
1480 err = rtl8366_reset(smi);
1481 if (err)
1482 goto err_free_sck;
1483
1484 err = smi->ops->setup(smi);
1485 if (err) {
1486 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1487 goto err_free_sck;
1488 }
1489
1490 err = rtl8366_init_vlan(smi);
1491 if (err) {
1492 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1493 err);
1494 goto err_free_sck;
1495 }
1496
1497 err = rtl8366_enable_all_ports(smi, 1);
1498 if (err)
1499 goto err_free_sck;
1500
1501 err = rtl8366_smi_mii_init(smi);
1502 if (err)
1503 goto err_free_sck;
1504
1505 rtl8366_debugfs_init(smi);
1506
1507 return 0;
1508
1509 err_free_sck:
1510 __rtl8366_smi_cleanup(smi);
1511 err_out:
1512 return err;
1513 }
1514 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1515
1516 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1517 {
1518 rtl8366_debugfs_remove(smi);
1519 rtl8366_smi_mii_cleanup(smi);
1520 __rtl8366_smi_cleanup(smi);
1521 }
1522 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1523
1524 #ifdef CONFIG_OF
1525 static void rtl8366_smi_reset(struct rtl8366_smi *smi, bool active)
1526 {
1527 if (active)
1528 reset_control_assert(smi->reset);
1529 else
1530 reset_control_deassert(smi->reset);
1531 }
1532
1533 int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1534 {
1535 int sck = of_get_named_gpio(pdev->dev.of_node, "gpio-sck", 0);
1536 int sda = of_get_named_gpio(pdev->dev.of_node, "gpio-sda", 0);
1537 struct device_node *np = pdev->dev.of_node;
1538 struct device_node *mdio_node;
1539
1540 mdio_node = of_parse_phandle(np, "mii-bus", 0);
1541 if (!mdio_node) {
1542 dev_err(&pdev->dev, "cannot find mdio node phandle");
1543 goto try_gpio;
1544 }
1545
1546 smi->ext_mbus = of_mdio_find_bus(mdio_node);
1547 if (!smi->ext_mbus) {
1548 dev_info(&pdev->dev,
1549 "cannot find mdio bus from bus handle (yet)");
1550 goto try_gpio;
1551 }
1552
1553 return 0;
1554
1555 try_gpio:
1556 if (!gpio_is_valid(sck) || !gpio_is_valid(sda)) {
1557 if (!mdio_node) {
1558 dev_err(&pdev->dev, "gpios missing in devictree\n");
1559 return -EINVAL;
1560 } else {
1561 return -EPROBE_DEFER;
1562 }
1563 }
1564
1565 smi->gpio_sda = sda;
1566 smi->gpio_sck = sck;
1567 smi->reset = devm_reset_control_get(&pdev->dev, "switch");
1568 if (!IS_ERR(smi->reset))
1569 smi->hw_reset = rtl8366_smi_reset;
1570
1571 return 0;
1572 }
1573 #else
1574 static inline int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1575 {
1576 return -ENODEV;
1577 }
1578 #endif
1579
1580 int rtl8366_smi_probe_plat(struct platform_device *pdev, struct rtl8366_smi *smi)
1581 {
1582 struct rtl8366_platform_data *pdata = pdev->dev.platform_data;
1583
1584 if (!pdev->dev.platform_data) {
1585 dev_err(&pdev->dev, "no platform data specified\n");
1586 return -EINVAL;
1587 }
1588
1589 smi->gpio_sda = pdata->gpio_sda;
1590 smi->gpio_sck = pdata->gpio_sck;
1591 smi->hw_reset = pdata->hw_reset;
1592
1593 return 0;
1594 }
1595
1596
1597 struct rtl8366_smi *rtl8366_smi_probe(struct platform_device *pdev)
1598 {
1599 struct rtl8366_smi *smi;
1600 int err;
1601
1602 smi = rtl8366_smi_alloc(&pdev->dev);
1603 if (!smi)
1604 return NULL;
1605
1606 if (pdev->dev.of_node)
1607 err = rtl8366_smi_probe_of(pdev, smi);
1608 else
1609 err = rtl8366_smi_probe_plat(pdev, smi);
1610
1611 if (err)
1612 goto free_smi;
1613
1614 return smi;
1615
1616 free_smi:
1617 kfree(smi);
1618 return ERR_PTR(err);
1619 }
1620 EXPORT_SYMBOL_GPL(rtl8366_smi_probe);
1621
1622 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1623 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1624 MODULE_LICENSE("GPL v2");
Staging tree of Christian Lamparter