projects / openwrt / staging / pepe2k.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
kernel: rtl8366_smi: explicitly set phy addr for switch
[openwrt/staging/pepe2k.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 = smi->phy_id;
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 = smi->phy_id;
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 static int rtl8366_smi_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
611 static int rtl8366_smi_enable_vlan4k(struct rtl8366_smi *smi, int enable)
612 {
613 int err;
614
615 if (enable) {
616 err = smi->ops->enable_vlan(smi, enable);
617 if (err)
618 return err;
619
620 smi->vlan_enabled = enable;
621 }
622
623 err = smi->ops->enable_vlan4k(smi, enable);
624 if (err)
625 return err;
626
627 smi->vlan4k_enabled = enable;
628 return 0;
629 }
630
631 static int rtl8366_smi_enable_all_ports(struct rtl8366_smi *smi, int enable)
632 {
633 int port;
634 int err;
635
636 for (port = 0; port < smi->num_ports; port++) {
637 err = smi->ops->enable_port(smi, port, enable);
638 if (err)
639 return err;
640 }
641
642 return 0;
643 }
644
645 static int rtl8366_smi_reset_vlan(struct rtl8366_smi *smi)
646 {
647 struct rtl8366_vlan_mc vlanmc;
648 int err;
649 int i;
650
651 rtl8366_smi_enable_vlan(smi, 0);
652 rtl8366_smi_enable_vlan4k(smi, 0);
653
654 /* clear VLAN member configurations */
655 vlanmc.vid = 0;
656 vlanmc.priority = 0;
657 vlanmc.member = 0;
658 vlanmc.untag = 0;
659 vlanmc.fid = 0;
660 for (i = 0; i < smi->num_vlan_mc; i++) {
661 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
662 if (err)
663 return err;
664 }
665
666 return 0;
667 }
668
669 static int rtl8366_init_vlan(struct rtl8366_smi *smi)
670 {
671 int port;
672 int err;
673
674 err = rtl8366_smi_reset_vlan(smi);
675 if (err)
676 return err;
677
678 for (port = 0; port < smi->num_ports; port++) {
679 u32 mask;
680
681 if (port == smi->cpu_port)
682 mask = (1 << smi->num_ports) - 1;
683 else
684 mask = (1 << port) | (1 << smi->cpu_port);
685
686 err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
687 if (err)
688 return err;
689
690 err = rtl8366_set_pvid(smi, port, (port + 1));
691 if (err)
692 return err;
693 }
694
695 return rtl8366_smi_enable_vlan(smi, 1);
696 }
697
698 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
699 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
700 {
701 file->private_data = inode->i_private;
702 return 0;
703 }
704 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
705
706 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
707 char __user *user_buf,
708 size_t count, loff_t *ppos)
709 {
710 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
711 int i, len = 0;
712 char *buf = smi->buf;
713
714 len += snprintf(buf + len, sizeof(smi->buf) - len,
715 "%2s %6s %4s %6s %6s %3s\n",
716 "id", "vid","prio", "member", "untag", "fid");
717
718 for (i = 0; i < smi->num_vlan_mc; ++i) {
719 struct rtl8366_vlan_mc vlanmc;
720
721 smi->ops->get_vlan_mc(smi, i, &vlanmc);
722
723 len += snprintf(buf + len, sizeof(smi->buf) - len,
724 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
725 i, vlanmc.vid, vlanmc.priority,
726 vlanmc.member, vlanmc.untag, vlanmc.fid);
727 }
728
729 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
730 }
731
732 #define RTL8366_VLAN4K_PAGE_SIZE 64
733 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
734
735 static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
736 char __user *user_buf,
737 size_t count, loff_t *ppos)
738 {
739 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
740 int i, len = 0;
741 int offset;
742 char *buf = smi->buf;
743
744 if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
745 len += snprintf(buf + len, sizeof(smi->buf) - len,
746 "invalid page: %u\n", smi->dbg_vlan_4k_page);
747 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
748 }
749
750 len += snprintf(buf + len, sizeof(smi->buf) - len,
751 "%4s %6s %6s %3s\n",
752 "vid", "member", "untag", "fid");
753
754 offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
755 for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
756 struct rtl8366_vlan_4k vlan4k;
757
758 smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
759
760 len += snprintf(buf + len, sizeof(smi->buf) - len,
761 "%4d 0x%04x 0x%04x %3d\n",
762 vlan4k.vid, vlan4k.member,
763 vlan4k.untag, vlan4k.fid);
764 }
765
766 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
767 }
768
769 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
770 char __user *user_buf,
771 size_t count, loff_t *ppos)
772 {
773 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
774 char *buf = smi->buf;
775 int len = 0;
776 int i;
777
778 len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
779 "port", "pvid");
780
781 for (i = 0; i < smi->num_ports; i++) {
782 int pvid;
783 int err;
784
785 err = rtl8366_get_pvid(smi, i, &pvid);
786 if (err)
787 len += snprintf(buf + len, sizeof(smi->buf) - len,
788 "%4d error\n", i);
789 else
790 len += snprintf(buf + len, sizeof(smi->buf) - len,
791 "%4d %4d\n", i, pvid);
792 }
793
794 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
795 }
796
797 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
798 char __user *user_buf,
799 size_t count, loff_t *ppos)
800 {
801 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
802 u32 t, reg = smi->dbg_reg;
803 int err, len = 0;
804 char *buf = smi->buf;
805
806 memset(buf, '\0', sizeof(smi->buf));
807
808 err = rtl8366_smi_read_reg(smi, reg, &t);
809 if (err) {
810 len += snprintf(buf, sizeof(smi->buf),
811 "Read failed (reg: 0x%04x)\n", reg);
812 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
813 }
814
815 len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
816 reg, t);
817
818 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
819 }
820
821 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
822 const char __user *user_buf,
823 size_t count, loff_t *ppos)
824 {
825 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
826 unsigned long data;
827 u32 reg = smi->dbg_reg;
828 int err;
829 size_t len;
830 char *buf = smi->buf;
831
832 len = min(count, sizeof(smi->buf) - 1);
833 if (copy_from_user(buf, user_buf, len)) {
834 dev_err(smi->parent, "copy from user failed\n");
835 return -EFAULT;
836 }
837
838 buf[len] = '\0';
839 if (len > 0 && buf[len - 1] == '\n')
840 buf[len - 1] = '\0';
841
842
843 if (kstrtoul(buf, 16, &data)) {
844 dev_err(smi->parent, "Invalid reg value %s\n", buf);
845 } else {
846 err = rtl8366_smi_write_reg(smi, reg, data);
847 if (err) {
848 dev_err(smi->parent,
849 "writing reg 0x%04x val 0x%04lx failed\n",
850 reg, data);
851 }
852 }
853
854 return count;
855 }
856
857 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
858 char __user *user_buf,
859 size_t count, loff_t *ppos)
860 {
861 struct rtl8366_smi *smi = file->private_data;
862 int i, j, len = 0;
863 char *buf = smi->buf;
864
865 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
866 "Counter");
867
868 for (i = 0; i < smi->num_ports; i++) {
869 char port_buf[10];
870
871 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
872 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
873 port_buf);
874 }
875 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
876
877 for (i = 0; i < smi->num_mib_counters; i++) {
878 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
879 smi->mib_counters[i].name);
880 for (j = 0; j < smi->num_ports; j++) {
881 unsigned long long counter = 0;
882
883 if (!smi->ops->get_mib_counter(smi, i, j, &counter))
884 len += snprintf(buf + len,
885 sizeof(smi->buf) - len,
886 "%12llu ", counter);
887 else
888 len += snprintf(buf + len,
889 sizeof(smi->buf) - len,
890 "%12s ", "error");
891 }
892 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
893 }
894
895 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
896 }
897
898 static const struct file_operations fops_rtl8366_regs = {
899 .read = rtl8366_read_debugfs_reg,
900 .write = rtl8366_write_debugfs_reg,
901 .open = rtl8366_debugfs_open,
902 .owner = THIS_MODULE
903 };
904
905 static const struct file_operations fops_rtl8366_vlan_mc = {
906 .read = rtl8366_read_debugfs_vlan_mc,
907 .open = rtl8366_debugfs_open,
908 .owner = THIS_MODULE
909 };
910
911 static const struct file_operations fops_rtl8366_vlan_4k = {
912 .read = rtl8366_read_debugfs_vlan_4k,
913 .open = rtl8366_debugfs_open,
914 .owner = THIS_MODULE
915 };
916
917 static const struct file_operations fops_rtl8366_pvid = {
918 .read = rtl8366_read_debugfs_pvid,
919 .open = rtl8366_debugfs_open,
920 .owner = THIS_MODULE
921 };
922
923 static const struct file_operations fops_rtl8366_mibs = {
924 .read = rtl8366_read_debugfs_mibs,
925 .open = rtl8366_debugfs_open,
926 .owner = THIS_MODULE
927 };
928
929 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
930 {
931 struct dentry *node;
932 struct dentry *root;
933
934 if (!smi->debugfs_root)
935 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
936 NULL);
937
938 if (!smi->debugfs_root) {
939 dev_err(smi->parent, "Unable to create debugfs dir\n");
940 return;
941 }
942 root = smi->debugfs_root;
943
944 node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
945 &smi->dbg_reg);
946 if (!node) {
947 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
948 "reg");
949 return;
950 }
951
952 node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
953 &fops_rtl8366_regs);
954 if (!node) {
955 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
956 "val");
957 return;
958 }
959
960 node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
961 &fops_rtl8366_vlan_mc);
962 if (!node) {
963 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
964 "vlan_mc");
965 return;
966 }
967
968 node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
969 &smi->dbg_vlan_4k_page);
970 if (!node) {
971 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
972 "vlan_4k_page");
973 return;
974 }
975
976 node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
977 &fops_rtl8366_vlan_4k);
978 if (!node) {
979 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
980 "vlan_4k");
981 return;
982 }
983
984 node = debugfs_create_file("pvid", S_IRUSR, root, smi,
985 &fops_rtl8366_pvid);
986 if (!node) {
987 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
988 "pvid");
989 return;
990 }
991
992 node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
993 &fops_rtl8366_mibs);
994 if (!node)
995 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
996 "mibs");
997 }
998
999 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
1000 {
1001 if (smi->debugfs_root) {
1002 debugfs_remove_recursive(smi->debugfs_root);
1003 smi->debugfs_root = NULL;
1004 }
1005 }
1006 #else
1007 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
1008 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
1009 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
1010
1011 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
1012 {
1013 int ret;
1014
1015 #ifdef CONFIG_OF
1016 struct device_node *np = NULL;
1017
1018 np = of_get_child_by_name(smi->parent->of_node, "mdio-bus");
1019 #endif
1020
1021 smi->mii_bus = mdiobus_alloc();
1022 if (smi->mii_bus == NULL) {
1023 ret = -ENOMEM;
1024 goto err;
1025 }
1026
1027 smi->mii_bus->priv = (void *) smi;
1028 smi->mii_bus->name = dev_name(smi->parent);
1029 smi->mii_bus->read = smi->ops->mii_read;
1030 smi->mii_bus->write = smi->ops->mii_write;
1031 snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
1032 dev_name(smi->parent));
1033 smi->mii_bus->parent = smi->parent;
1034 smi->mii_bus->phy_mask = ~(0x1f);
1035
1036 #ifdef CONFIG_OF
1037 if (np)
1038 ret = of_mdiobus_register(smi->mii_bus, np);
1039 else
1040 #endif
1041 ret = mdiobus_register(smi->mii_bus);
1042
1043 if (ret)
1044 goto err_free;
1045
1046 return 0;
1047
1048 err_free:
1049 mdiobus_free(smi->mii_bus);
1050 err:
1051 return ret;
1052 }
1053
1054 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
1055 {
1056 mdiobus_unregister(smi->mii_bus);
1057 mdiobus_free(smi->mii_bus);
1058 }
1059
1060 int rtl8366_sw_reset_switch(struct switch_dev *dev)
1061 {
1062 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1063 int err;
1064
1065 err = rtl8366_reset(smi);
1066 if (err)
1067 return err;
1068
1069 err = smi->ops->setup(smi);
1070 if (err)
1071 return err;
1072
1073 err = rtl8366_smi_reset_vlan(smi);
1074 if (err)
1075 return err;
1076
1077 err = rtl8366_smi_enable_vlan(smi, 1);
1078 if (err)
1079 return err;
1080
1081 return rtl8366_smi_enable_all_ports(smi, 1);
1082 }
1083 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch);
1084
1085 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
1086 {
1087 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1088 return rtl8366_get_pvid(smi, port, val);
1089 }
1090 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
1091
1092 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
1093 {
1094 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1095 return rtl8366_set_pvid(smi, port, val);
1096 }
1097 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
1098
1099 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
1100 const struct switch_attr *attr,
1101 struct switch_val *val)
1102 {
1103 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1104 int i, len = 0;
1105 unsigned long long counter = 0;
1106 char *buf = smi->buf;
1107
1108 if (val->port_vlan >= smi->num_ports)
1109 return -EINVAL;
1110
1111 len += snprintf(buf + len, sizeof(smi->buf) - len,
1112 "Port %d MIB counters\n",
1113 val->port_vlan);
1114
1115 for (i = 0; i < smi->num_mib_counters; ++i) {
1116 len += snprintf(buf + len, sizeof(smi->buf) - len,
1117 "%-36s: ", smi->mib_counters[i].name);
1118 if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
1119 &counter))
1120 len += snprintf(buf + len, sizeof(smi->buf) - len,
1121 "%llu\n", counter);
1122 else
1123 len += snprintf(buf + len, sizeof(smi->buf) - len,
1124 "%s\n", "error");
1125 }
1126
1127 val->value.s = buf;
1128 val->len = len;
1129 return 0;
1130 }
1131 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
1132
1133 int rtl8366_sw_get_port_stats(struct switch_dev *dev, int port,
1134 struct switch_port_stats *stats,
1135 int txb_id, int rxb_id)
1136 {
1137 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1138 unsigned long long counter = 0;
1139 int ret;
1140
1141 if (port >= smi->num_ports)
1142 return -EINVAL;
1143
1144 ret = smi->ops->get_mib_counter(smi, txb_id, port, &counter);
1145 if (ret)
1146 return ret;
1147
1148 stats->tx_bytes = counter;
1149
1150 ret = smi->ops->get_mib_counter(smi, rxb_id, port, &counter);
1151 if (ret)
1152 return ret;
1153
1154 stats->rx_bytes = counter;
1155
1156 return 0;
1157 }
1158 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_stats);
1159
1160 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
1161 const struct switch_attr *attr,
1162 struct switch_val *val)
1163 {
1164 int i;
1165 u32 len = 0;
1166 struct rtl8366_vlan_4k vlan4k;
1167 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1168 char *buf = smi->buf;
1169 int err;
1170
1171 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1172 return -EINVAL;
1173
1174 memset(buf, '\0', sizeof(smi->buf));
1175
1176 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1177 if (err)
1178 return err;
1179
1180 len += snprintf(buf + len, sizeof(smi->buf) - len,
1181 "VLAN %d: Ports: '", vlan4k.vid);
1182
1183 for (i = 0; i < smi->num_ports; i++) {
1184 if (!(vlan4k.member & (1 << i)))
1185 continue;
1186
1187 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1188 (vlan4k.untag & (1 << i)) ? "" : "t");
1189 }
1190
1191 len += snprintf(buf + len, sizeof(smi->buf) - len,
1192 "', members=%04x, untag=%04x, fid=%u",
1193 vlan4k.member, vlan4k.untag, vlan4k.fid);
1194
1195 val->value.s = buf;
1196 val->len = len;
1197
1198 return 0;
1199 }
1200 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1201
1202 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1203 {
1204 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1205 struct switch_port *port;
1206 struct rtl8366_vlan_4k vlan4k;
1207 int i;
1208
1209 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1210 return -EINVAL;
1211
1212 smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1213
1214 port = &val->value.ports[0];
1215 val->len = 0;
1216 for (i = 0; i < smi->num_ports; i++) {
1217 if (!(vlan4k.member & BIT(i)))
1218 continue;
1219
1220 port->id = i;
1221 port->flags = (vlan4k.untag & BIT(i)) ?
1222 0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1223 val->len++;
1224 port++;
1225 }
1226 return 0;
1227 }
1228 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1229
1230 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1231 {
1232 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1233 struct switch_port *port;
1234 u32 member = 0;
1235 u32 untag = 0;
1236 int err;
1237 int i;
1238
1239 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1240 return -EINVAL;
1241
1242 port = &val->value.ports[0];
1243 for (i = 0; i < val->len; i++, port++) {
1244 int pvid = 0;
1245 member |= BIT(port->id);
1246
1247 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1248 untag |= BIT(port->id);
1249
1250 /*
1251 * To ensure that we have a valid MC entry for this VLAN,
1252 * initialize the port VLAN ID here.
1253 */
1254 err = rtl8366_get_pvid(smi, port->id, &pvid);
1255 if (err < 0)
1256 return err;
1257 if (pvid == 0) {
1258 err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1259 if (err < 0)
1260 return err;
1261 }
1262 }
1263
1264 return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1265 }
1266 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1267
1268 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1269 const struct switch_attr *attr,
1270 struct switch_val *val)
1271 {
1272 struct rtl8366_vlan_4k vlan4k;
1273 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1274 int err;
1275
1276 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1277 return -EINVAL;
1278
1279 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1280 if (err)
1281 return err;
1282
1283 val->value.i = vlan4k.fid;
1284
1285 return 0;
1286 }
1287 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1288
1289 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1290 const struct switch_attr *attr,
1291 struct switch_val *val)
1292 {
1293 struct rtl8366_vlan_4k vlan4k;
1294 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1295 int err;
1296
1297 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1298 return -EINVAL;
1299
1300 if (val->value.i < 0 || val->value.i > attr->max)
1301 return -EINVAL;
1302
1303 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1304 if (err)
1305 return err;
1306
1307 return rtl8366_set_vlan(smi, val->port_vlan,
1308 vlan4k.member,
1309 vlan4k.untag,
1310 val->value.i);
1311 }
1312 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1313
1314 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1315 const struct switch_attr *attr,
1316 struct switch_val *val)
1317 {
1318 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1319
1320 if (attr->ofs > 2)
1321 return -EINVAL;
1322
1323 if (attr->ofs == 1)
1324 val->value.i = smi->vlan_enabled;
1325 else
1326 val->value.i = smi->vlan4k_enabled;
1327
1328 return 0;
1329 }
1330 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1331
1332 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1333 const struct switch_attr *attr,
1334 struct switch_val *val)
1335 {
1336 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1337 int err;
1338
1339 if (attr->ofs > 2)
1340 return -EINVAL;
1341
1342 if (attr->ofs == 1)
1343 err = rtl8366_smi_enable_vlan(smi, val->value.i);
1344 else
1345 err = rtl8366_smi_enable_vlan4k(smi, val->value.i);
1346
1347 return err;
1348 }
1349 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1350
1351 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1352 {
1353 struct rtl8366_smi *smi;
1354
1355 BUG_ON(!parent);
1356
1357 smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1358 if (!smi) {
1359 dev_err(parent, "no memory for private data\n");
1360 return NULL;
1361 }
1362
1363 smi->parent = parent;
1364 return smi;
1365 }
1366 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1367
1368 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1369 {
1370 int err;
1371
1372 if (!smi->ext_mbus) {
1373 err = gpio_request(smi->gpio_sda, name);
1374 if (err) {
1375 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1376 smi->gpio_sda, err);
1377 goto err_out;
1378 }
1379
1380 err = gpio_request(smi->gpio_sck, name);
1381 if (err) {
1382 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1383 smi->gpio_sck, err);
1384 goto err_free_sda;
1385 }
1386 }
1387
1388 spin_lock_init(&smi->lock);
1389
1390 /* start the switch */
1391 if (smi->hw_reset) {
1392 smi->hw_reset(smi, false);
1393 msleep(RTL8366_SMI_HW_START_DELAY);
1394 }
1395
1396 return 0;
1397
1398 err_free_sda:
1399 gpio_free(smi->gpio_sda);
1400 err_out:
1401 return err;
1402 }
1403
1404 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1405 {
1406 if (smi->hw_reset)
1407 smi->hw_reset(smi, true);
1408
1409 if (!smi->ext_mbus) {
1410 gpio_free(smi->gpio_sck);
1411 gpio_free(smi->gpio_sda);
1412 }
1413 }
1414
1415 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1416 {
1417 static struct rtl8366_smi smi;
1418 enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1419 u32 reg = 0;
1420
1421 memset(&smi, 0, sizeof(smi));
1422 smi.gpio_sda = pdata->gpio_sda;
1423 smi.gpio_sck = pdata->gpio_sck;
1424 smi.clk_delay = 10;
1425 smi.cmd_read = 0xa9;
1426 smi.cmd_write = 0xa8;
1427
1428 if (__rtl8366_smi_init(&smi, "rtl8366"))
1429 goto out;
1430
1431 if (rtl8366_smi_read_reg(&smi, 0x5c, &reg))
1432 goto cleanup;
1433
1434 switch(reg) {
1435 case 0x6027:
1436 printk("Found an RTL8366S switch\n");
1437 type = RTL8366_TYPE_S;
1438 break;
1439 case 0x5937:
1440 printk("Found an RTL8366RB switch\n");
1441 type = RTL8366_TYPE_RB;
1442 break;
1443 default:
1444 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1445 break;
1446 }
1447
1448 cleanup:
1449 __rtl8366_smi_cleanup(&smi);
1450 out:
1451 return type;
1452 }
1453
1454 int rtl8366_smi_init(struct rtl8366_smi *smi)
1455 {
1456 int err;
1457
1458 if (!smi->ops)
1459 return -EINVAL;
1460
1461 err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1462 if (err)
1463 goto err_out;
1464
1465 if (!smi->ext_mbus)
1466 dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1467 smi->gpio_sda, smi->gpio_sck);
1468 else
1469 dev_info(smi->parent, "using MDIO bus '%s'\n", smi->ext_mbus->name);
1470
1471 err = smi->ops->detect(smi);
1472 if (err) {
1473 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1474 goto err_free_sck;
1475 }
1476
1477 err = rtl8366_reset(smi);
1478 if (err)
1479 goto err_free_sck;
1480
1481 err = smi->ops->setup(smi);
1482 if (err) {
1483 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1484 goto err_free_sck;
1485 }
1486
1487 err = rtl8366_init_vlan(smi);
1488 if (err) {
1489 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1490 err);
1491 goto err_free_sck;
1492 }
1493
1494 err = rtl8366_smi_enable_all_ports(smi, 1);
1495 if (err)
1496 goto err_free_sck;
1497
1498 err = rtl8366_smi_mii_init(smi);
1499 if (err)
1500 goto err_free_sck;
1501
1502 rtl8366_debugfs_init(smi);
1503
1504 return 0;
1505
1506 err_free_sck:
1507 __rtl8366_smi_cleanup(smi);
1508 err_out:
1509 return err;
1510 }
1511 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1512
1513 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1514 {
1515 rtl8366_debugfs_remove(smi);
1516 rtl8366_smi_mii_cleanup(smi);
1517 __rtl8366_smi_cleanup(smi);
1518 }
1519 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1520
1521 #ifdef CONFIG_OF
1522 static void rtl8366_smi_reset(struct rtl8366_smi *smi, bool active)
1523 {
1524 if (active)
1525 reset_control_assert(smi->reset);
1526 else
1527 reset_control_deassert(smi->reset);
1528 }
1529
1530 int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1531 {
1532 int sck = of_get_named_gpio(pdev->dev.of_node, "gpio-sck", 0);
1533 int sda = of_get_named_gpio(pdev->dev.of_node, "gpio-sda", 0);
1534 struct device_node *np = pdev->dev.of_node;
1535 struct device_node *mdio_node;
1536
1537 mdio_node = of_parse_phandle(np, "mii-bus", 0);
1538 if (!mdio_node) {
1539 dev_err(&pdev->dev, "cannot find mdio node phandle");
1540 goto try_gpio;
1541 }
1542
1543 smi->ext_mbus = of_mdio_find_bus(mdio_node);
1544 if (!smi->ext_mbus) {
1545 dev_info(&pdev->dev,
1546 "cannot find mdio bus from bus handle (yet)");
1547 goto try_gpio;
1548 }
1549
1550 if (of_property_read_u32(np, "phy-id", &smi->phy_id))
1551 smi->phy_id = MDC_REALTEK_PHY_ADDR;
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 smi->phy_id = MDC_REALTEK_PHY_ADDR;
1593
1594 return 0;
1595 }
1596
1597
1598 struct rtl8366_smi *rtl8366_smi_probe(struct platform_device *pdev)
1599 {
1600 struct rtl8366_smi *smi;
1601 int err;
1602
1603 smi = rtl8366_smi_alloc(&pdev->dev);
1604 if (!smi)
1605 return NULL;
1606
1607 if (pdev->dev.of_node)
1608 err = rtl8366_smi_probe_of(pdev, smi);
1609 else
1610 err = rtl8366_smi_probe_plat(pdev, smi);
1611
1612 if (err)
1613 goto free_smi;
1614
1615 return smi;
1616
1617 free_smi:
1618 kfree(smi);
1619 return ERR_PTR(err);
1620 }
1621 EXPORT_SYMBOL_GPL(rtl8366_smi_probe);
1622
1623 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1624 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1625 MODULE_LICENSE("GPL v2");
Staging tree of Piotr Dymacz