projects / openwrt.git / blob
? search:


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