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