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