2 * Realtek RTL8366 SMI interface driver
4 * Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org>
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.
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>
20 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
21 #include <linux/debugfs.h>
24 #include "rtl8366_smi.h"
26 #define RTL8366_SMI_ACK_RETRY_COUNT 5
28 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi
*smi
)
30 ndelay(smi
->clk_delay
);
33 static void rtl8366_smi_start(struct rtl8366_smi
*smi
)
35 unsigned int sda
= smi
->gpio_sda
;
36 unsigned int sck
= smi
->gpio_sck
;
39 * Set GPIO pins to output mode, with initial state:
42 gpio_direction_output(sck
, 0);
43 gpio_direction_output(sda
, 1);
44 rtl8366_smi_clk_delay(smi
);
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
);
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);
62 static void rtl8366_smi_stop(struct rtl8366_smi
*smi
)
64 unsigned int sda
= smi
->gpio_sda
;
65 unsigned int sck
= smi
->gpio_sck
;
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);
80 rtl8366_smi_clk_delay(smi
);
81 gpio_set_value(sck
, 0);
82 rtl8366_smi_clk_delay(smi
);
83 gpio_set_value(sck
, 1);
85 /* set GPIO pins to input mode */
86 gpio_direction_input(sda
);
87 gpio_direction_input(sck
);
90 static void rtl8366_smi_write_bits(struct rtl8366_smi
*smi
, u32 data
, u32 len
)
92 unsigned int sda
= smi
->gpio_sda
;
93 unsigned int sck
= smi
->gpio_sck
;
95 for (; len
> 0; len
--) {
96 rtl8366_smi_clk_delay(smi
);
99 gpio_set_value(sda
, !!(data
& ( 1 << (len
- 1))));
100 rtl8366_smi_clk_delay(smi
);
103 gpio_set_value(sck
, 1);
104 rtl8366_smi_clk_delay(smi
);
105 gpio_set_value(sck
, 0);
109 static void rtl8366_smi_read_bits(struct rtl8366_smi
*smi
, u32 len
, u32
*data
)
111 unsigned int sda
= smi
->gpio_sda
;
112 unsigned int sck
= smi
->gpio_sck
;
114 gpio_direction_input(sda
);
116 for (*data
= 0; len
> 0; len
--) {
119 rtl8366_smi_clk_delay(smi
);
122 gpio_set_value(sck
, 1);
123 rtl8366_smi_clk_delay(smi
);
124 u
= !!gpio_get_value(sda
);
125 gpio_set_value(sck
, 0);
127 *data
|= (u
<< (len
- 1));
130 gpio_direction_output(sda
, 0);
133 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi
*smi
)
141 rtl8366_smi_read_bits(smi
, 1, &ack
);
145 if (++retry_cnt
> RTL8366_SMI_ACK_RETRY_COUNT
) {
146 dev_err(smi
->parent
, "ACK timeout\n");
154 static int rtl8366_smi_write_byte(struct rtl8366_smi
*smi
, u8 data
)
156 rtl8366_smi_write_bits(smi
, data
, 8);
157 return rtl8366_smi_wait_for_ack(smi
);
160 static int rtl8366_smi_write_byte_noack(struct rtl8366_smi
*smi
, u8 data
)
162 rtl8366_smi_write_bits(smi
, data
, 8);
166 static int rtl8366_smi_read_byte0(struct rtl8366_smi
*smi
, u8
*data
)
171 rtl8366_smi_read_bits(smi
, 8, &t
);
175 rtl8366_smi_write_bits(smi
, 0x00, 1);
180 static int rtl8366_smi_read_byte1(struct rtl8366_smi
*smi
, u8
*data
)
185 rtl8366_smi_read_bits(smi
, 8, &t
);
189 rtl8366_smi_write_bits(smi
, 0x01, 1);
194 int rtl8366_smi_read_reg(struct rtl8366_smi
*smi
, u32 addr
, u32
*data
)
201 spin_lock_irqsave(&smi
->lock
, flags
);
203 rtl8366_smi_start(smi
);
205 /* send READ command */
206 ret
= rtl8366_smi_write_byte(smi
, smi
->cmd_read
);
211 ret
= rtl8366_smi_write_byte(smi
, addr
& 0xff);
216 ret
= rtl8366_smi_write_byte(smi
, addr
>> 8);
221 rtl8366_smi_read_byte0(smi
, &lo
);
222 /* read DATA[15:8] */
223 rtl8366_smi_read_byte1(smi
, &hi
);
225 *data
= ((u32
) lo
) | (((u32
) hi
) << 8);
230 rtl8366_smi_stop(smi
);
231 spin_unlock_irqrestore(&smi
->lock
, flags
);
235 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg
);
237 static int __rtl8366_smi_write_reg(struct rtl8366_smi
*smi
,
238 u32 addr
, u32 data
, bool ack
)
243 spin_lock_irqsave(&smi
->lock
, flags
);
245 rtl8366_smi_start(smi
);
247 /* send WRITE command */
248 ret
= rtl8366_smi_write_byte(smi
, smi
->cmd_write
);
253 ret
= rtl8366_smi_write_byte(smi
, addr
& 0xff);
258 ret
= rtl8366_smi_write_byte(smi
, addr
>> 8);
262 /* write DATA[7:0] */
263 ret
= rtl8366_smi_write_byte(smi
, data
& 0xff);
267 /* write DATA[15:8] */
269 ret
= rtl8366_smi_write_byte(smi
, data
>> 8);
271 ret
= rtl8366_smi_write_byte_noack(smi
, data
>> 8);
278 rtl8366_smi_stop(smi
);
279 spin_unlock_irqrestore(&smi
->lock
, flags
);
284 int rtl8366_smi_write_reg(struct rtl8366_smi
*smi
, u32 addr
, u32 data
)
286 return __rtl8366_smi_write_reg(smi
, addr
, data
, true);
288 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg
);
290 int rtl8366_smi_write_reg_noack(struct rtl8366_smi
*smi
, u32 addr
, u32 data
)
292 return __rtl8366_smi_write_reg(smi
, addr
, data
, false);
294 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack
);
296 int rtl8366_smi_rmwr(struct rtl8366_smi
*smi
, u32 addr
, u32 mask
, u32 data
)
301 err
= rtl8366_smi_read_reg(smi
, addr
, &t
);
305 err
= rtl8366_smi_write_reg(smi
, addr
, (t
& ~mask
) | data
);
309 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr
);
311 static int rtl8366_reset(struct rtl8366_smi
*smi
)
316 smi
->hw_reset(false);
321 return smi
->ops
->reset_chip(smi
);
324 static int rtl8366_mc_is_used(struct rtl8366_smi
*smi
, int mc_index
, int *used
)
330 for (i
= 0; i
< smi
->num_ports
; i
++) {
333 err
= smi
->ops
->get_mc_index(smi
, i
, &index
);
337 if (mc_index
== index
) {
346 static int rtl8366_set_vlan(struct rtl8366_smi
*smi
, int vid
, u32 member
,
349 struct rtl8366_vlan_4k vlan4k
;
353 /* Update the 4K table */
354 err
= smi
->ops
->get_vlan_4k(smi
, vid
, &vlan4k
);
358 vlan4k
.member
= member
;
359 vlan4k
.untag
= untag
;
361 err
= smi
->ops
->set_vlan_4k(smi
, &vlan4k
);
365 /* Try to find an existing MC entry for this VID */
366 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
367 struct rtl8366_vlan_mc vlanmc
;
369 err
= smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
373 if (vid
== vlanmc
.vid
) {
374 /* update the MC entry */
375 vlanmc
.member
= member
;
376 vlanmc
.untag
= untag
;
379 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
387 static int rtl8366_get_pvid(struct rtl8366_smi
*smi
, int port
, int *val
)
389 struct rtl8366_vlan_mc vlanmc
;
393 err
= smi
->ops
->get_mc_index(smi
, port
, &index
);
397 err
= smi
->ops
->get_vlan_mc(smi
, index
, &vlanmc
);
405 static int rtl8366_set_pvid(struct rtl8366_smi
*smi
, unsigned port
,
408 struct rtl8366_vlan_mc vlanmc
;
409 struct rtl8366_vlan_4k vlan4k
;
413 /* Try to find an existing MC entry for this VID */
414 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
415 err
= smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
419 if (vid
== vlanmc
.vid
) {
420 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
424 err
= smi
->ops
->set_mc_index(smi
, port
, i
);
429 /* We have no MC entry for this VID, try to find an empty one */
430 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
431 err
= smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
435 if (vlanmc
.vid
== 0 && vlanmc
.member
== 0) {
436 /* Update the entry from the 4K table */
437 err
= smi
->ops
->get_vlan_4k(smi
, vid
, &vlan4k
);
442 vlanmc
.member
= vlan4k
.member
;
443 vlanmc
.untag
= vlan4k
.untag
;
444 vlanmc
.fid
= vlan4k
.fid
;
445 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
449 err
= smi
->ops
->set_mc_index(smi
, port
, i
);
454 /* MC table is full, try to find an unused entry and replace it */
455 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
458 err
= rtl8366_mc_is_used(smi
, i
, &used
);
463 /* Update the entry from the 4K table */
464 err
= smi
->ops
->get_vlan_4k(smi
, vid
, &vlan4k
);
469 vlanmc
.member
= vlan4k
.member
;
470 vlanmc
.untag
= vlan4k
.untag
;
471 vlanmc
.fid
= vlan4k
.fid
;
472 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
476 err
= smi
->ops
->set_mc_index(smi
, port
, i
);
482 "all VLAN member configurations are in use\n");
487 int rtl8366_enable_vlan(struct rtl8366_smi
*smi
, int enable
)
491 err
= smi
->ops
->enable_vlan(smi
, enable
);
495 smi
->vlan_enabled
= enable
;
498 smi
->vlan4k_enabled
= 0;
499 err
= smi
->ops
->enable_vlan4k(smi
, enable
);
504 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan
);
506 static int rtl8366_enable_vlan4k(struct rtl8366_smi
*smi
, int enable
)
511 err
= smi
->ops
->enable_vlan(smi
, enable
);
515 smi
->vlan_enabled
= enable
;
518 err
= smi
->ops
->enable_vlan4k(smi
, enable
);
522 smi
->vlan4k_enabled
= enable
;
526 int rtl8366_enable_all_ports(struct rtl8366_smi
*smi
, int enable
)
531 for (port
= 0; port
< smi
->num_ports
; port
++) {
532 err
= smi
->ops
->enable_port(smi
, port
, enable
);
539 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports
);
541 int rtl8366_reset_vlan(struct rtl8366_smi
*smi
)
543 struct rtl8366_vlan_mc vlanmc
;
547 rtl8366_enable_vlan(smi
, 0);
548 rtl8366_enable_vlan4k(smi
, 0);
550 /* clear VLAN member configurations */
556 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
557 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
564 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan
);
566 static int rtl8366_init_vlan(struct rtl8366_smi
*smi
)
571 err
= rtl8366_reset_vlan(smi
);
575 for (port
= 0; port
< smi
->num_ports
; port
++) {
578 if (port
== smi
->cpu_port
)
579 mask
= (1 << smi
->num_ports
) - 1;
581 mask
= (1 << port
) | (1 << smi
->cpu_port
);
583 err
= rtl8366_set_vlan(smi
, (port
+ 1), mask
, mask
, 0);
587 err
= rtl8366_set_pvid(smi
, port
, (port
+ 1));
592 return rtl8366_enable_vlan(smi
, 1);
595 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
596 int rtl8366_debugfs_open(struct inode
*inode
, struct file
*file
)
598 file
->private_data
= inode
->i_private
;
601 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open
);
603 static ssize_t
rtl8366_read_debugfs_vlan_mc(struct file
*file
,
604 char __user
*user_buf
,
605 size_t count
, loff_t
*ppos
)
607 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
609 char *buf
= smi
->buf
;
611 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
612 "%2s %6s %4s %6s %6s %3s\n",
613 "id", "vid","prio", "member", "untag", "fid");
615 for (i
= 0; i
< smi
->num_vlan_mc
; ++i
) {
616 struct rtl8366_vlan_mc vlanmc
;
618 smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
620 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
621 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
622 i
, vlanmc
.vid
, vlanmc
.priority
,
623 vlanmc
.member
, vlanmc
.untag
, vlanmc
.fid
);
626 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
629 #define RTL8366_VLAN4K_PAGE_SIZE 64
630 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
632 static ssize_t
rtl8366_read_debugfs_vlan_4k(struct file
*file
,
633 char __user
*user_buf
,
634 size_t count
, loff_t
*ppos
)
636 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
639 char *buf
= smi
->buf
;
641 if (smi
->dbg_vlan_4k_page
>= RTL8366_VLAN4K_NUM_PAGES
) {
642 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
643 "invalid page: %u\n", smi
->dbg_vlan_4k_page
);
644 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
647 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
649 "vid", "member", "untag", "fid");
651 offset
= RTL8366_VLAN4K_PAGE_SIZE
* smi
->dbg_vlan_4k_page
;
652 for (i
= 0; i
< RTL8366_VLAN4K_PAGE_SIZE
; i
++) {
653 struct rtl8366_vlan_4k vlan4k
;
655 smi
->ops
->get_vlan_4k(smi
, offset
+ i
, &vlan4k
);
657 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
658 "%4d 0x%04x 0x%04x %3d\n",
659 vlan4k
.vid
, vlan4k
.member
,
660 vlan4k
.untag
, vlan4k
.fid
);
663 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
666 static ssize_t
rtl8366_read_debugfs_pvid(struct file
*file
,
667 char __user
*user_buf
,
668 size_t count
, loff_t
*ppos
)
670 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
671 char *buf
= smi
->buf
;
675 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%4s %4s\n",
678 for (i
= 0; i
< smi
->num_ports
; i
++) {
682 err
= rtl8366_get_pvid(smi
, i
, &pvid
);
684 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
687 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
688 "%4d %4d\n", i
, pvid
);
691 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
694 static ssize_t
rtl8366_read_debugfs_reg(struct file
*file
,
695 char __user
*user_buf
,
696 size_t count
, loff_t
*ppos
)
698 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
699 u32 t
, reg
= smi
->dbg_reg
;
701 char *buf
= smi
->buf
;
703 memset(buf
, '\0', sizeof(smi
->buf
));
705 err
= rtl8366_smi_read_reg(smi
, reg
, &t
);
707 len
+= snprintf(buf
, sizeof(smi
->buf
),
708 "Read failed (reg: 0x%04x)\n", reg
);
709 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
712 len
+= snprintf(buf
, sizeof(smi
->buf
), "reg = 0x%04x, val = 0x%04x\n",
715 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
718 static ssize_t
rtl8366_write_debugfs_reg(struct file
*file
,
719 const char __user
*user_buf
,
720 size_t count
, loff_t
*ppos
)
722 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
724 u32 reg
= smi
->dbg_reg
;
727 char *buf
= smi
->buf
;
729 len
= min(count
, sizeof(smi
->buf
) - 1);
730 if (copy_from_user(buf
, user_buf
, len
)) {
731 dev_err(smi
->parent
, "copy from user failed\n");
736 if (len
> 0 && buf
[len
- 1] == '\n')
740 if (strict_strtoul(buf
, 16, &data
)) {
741 dev_err(smi
->parent
, "Invalid reg value %s\n", buf
);
743 err
= rtl8366_smi_write_reg(smi
, reg
, data
);
746 "writing reg 0x%04x val 0x%04lx failed\n",
754 static ssize_t
rtl8366_read_debugfs_mibs(struct file
*file
,
755 char __user
*user_buf
,
756 size_t count
, loff_t
*ppos
)
758 struct rtl8366_smi
*smi
= file
->private_data
;
760 char *buf
= smi
->buf
;
762 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%-36s",
765 for (i
= 0; i
< smi
->num_ports
; i
++) {
768 snprintf(port_buf
, sizeof(port_buf
), "Port %d", i
);
769 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, " %12s",
772 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "\n");
774 for (i
= 0; i
< smi
->num_mib_counters
; i
++) {
775 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%-36s ",
776 smi
->mib_counters
[i
].name
);
777 for (j
= 0; j
< smi
->num_ports
; j
++) {
778 unsigned long long counter
= 0;
780 if (!smi
->ops
->get_mib_counter(smi
, i
, j
, &counter
))
781 len
+= snprintf(buf
+ len
,
782 sizeof(smi
->buf
) - len
,
785 len
+= snprintf(buf
+ len
,
786 sizeof(smi
->buf
) - len
,
789 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "\n");
792 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
795 static const struct file_operations fops_rtl8366_regs
= {
796 .read
= rtl8366_read_debugfs_reg
,
797 .write
= rtl8366_write_debugfs_reg
,
798 .open
= rtl8366_debugfs_open
,
802 static const struct file_operations fops_rtl8366_vlan_mc
= {
803 .read
= rtl8366_read_debugfs_vlan_mc
,
804 .open
= rtl8366_debugfs_open
,
808 static const struct file_operations fops_rtl8366_vlan_4k
= {
809 .read
= rtl8366_read_debugfs_vlan_4k
,
810 .open
= rtl8366_debugfs_open
,
814 static const struct file_operations fops_rtl8366_pvid
= {
815 .read
= rtl8366_read_debugfs_pvid
,
816 .open
= rtl8366_debugfs_open
,
820 static const struct file_operations fops_rtl8366_mibs
= {
821 .read
= rtl8366_read_debugfs_mibs
,
822 .open
= rtl8366_debugfs_open
,
826 static void rtl8366_debugfs_init(struct rtl8366_smi
*smi
)
831 if (!smi
->debugfs_root
)
832 smi
->debugfs_root
= debugfs_create_dir(dev_name(smi
->parent
),
835 if (!smi
->debugfs_root
) {
836 dev_err(smi
->parent
, "Unable to create debugfs dir\n");
839 root
= smi
->debugfs_root
;
841 node
= debugfs_create_x16("reg", S_IRUGO
| S_IWUSR
, root
,
844 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
849 node
= debugfs_create_file("val", S_IRUGO
| S_IWUSR
, root
, smi
,
852 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
857 node
= debugfs_create_file("vlan_mc", S_IRUSR
, root
, smi
,
858 &fops_rtl8366_vlan_mc
);
860 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
865 node
= debugfs_create_u8("vlan_4k_page", S_IRUGO
| S_IWUSR
, root
,
866 &smi
->dbg_vlan_4k_page
);
868 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
873 node
= debugfs_create_file("vlan_4k", S_IRUSR
, root
, smi
,
874 &fops_rtl8366_vlan_4k
);
876 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
881 node
= debugfs_create_file("pvid", S_IRUSR
, root
, smi
,
884 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
889 node
= debugfs_create_file("mibs", S_IRUSR
, smi
->debugfs_root
, smi
,
892 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
896 static void rtl8366_debugfs_remove(struct rtl8366_smi
*smi
)
898 if (smi
->debugfs_root
) {
899 debugfs_remove_recursive(smi
->debugfs_root
);
900 smi
->debugfs_root
= NULL
;
904 static inline void rtl8366_debugfs_init(struct rtl8366_smi
*smi
) {}
905 static inline void rtl8366_debugfs_remove(struct rtl8366_smi
*smi
) {}
906 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
908 static int rtl8366_smi_mii_init(struct rtl8366_smi
*smi
)
913 smi
->mii_bus
= mdiobus_alloc();
914 if (smi
->mii_bus
== NULL
) {
919 smi
->mii_bus
->priv
= (void *) smi
;
920 smi
->mii_bus
->name
= dev_name(smi
->parent
);
921 smi
->mii_bus
->read
= smi
->ops
->mii_read
;
922 smi
->mii_bus
->write
= smi
->ops
->mii_write
;
923 snprintf(smi
->mii_bus
->id
, MII_BUS_ID_SIZE
, "%s",
924 dev_name(smi
->parent
));
925 smi
->mii_bus
->parent
= smi
->parent
;
926 smi
->mii_bus
->phy_mask
= ~(0x1f);
927 smi
->mii_bus
->irq
= smi
->mii_irq
;
928 for (i
= 0; i
< PHY_MAX_ADDR
; i
++)
929 smi
->mii_irq
[i
] = PHY_POLL
;
931 ret
= mdiobus_register(smi
->mii_bus
);
938 mdiobus_free(smi
->mii_bus
);
943 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi
*smi
)
945 mdiobus_unregister(smi
->mii_bus
);
946 mdiobus_free(smi
->mii_bus
);
949 int rtl8366_sw_reset_switch(struct switch_dev
*dev
)
951 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
954 err
= rtl8366_reset(smi
);
958 err
= smi
->ops
->setup(smi
);
962 err
= rtl8366_reset_vlan(smi
);
966 err
= rtl8366_enable_vlan(smi
, 1);
970 return rtl8366_enable_all_ports(smi
, 1);
972 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch
);
974 int rtl8366_sw_get_port_pvid(struct switch_dev
*dev
, int port
, int *val
)
976 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
977 return rtl8366_get_pvid(smi
, port
, val
);
979 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid
);
981 int rtl8366_sw_set_port_pvid(struct switch_dev
*dev
, int port
, int val
)
983 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
984 return rtl8366_set_pvid(smi
, port
, val
);
986 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid
);
988 int rtl8366_sw_get_port_mib(struct switch_dev
*dev
,
989 const struct switch_attr
*attr
,
990 struct switch_val
*val
)
992 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
994 unsigned long long counter
= 0;
995 char *buf
= smi
->buf
;
997 if (val
->port_vlan
>= smi
->num_ports
)
1000 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1001 "Port %d MIB counters\n",
1004 for (i
= 0; i
< smi
->num_mib_counters
; ++i
) {
1005 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1006 "%-36s: ", smi
->mib_counters
[i
].name
);
1007 if (!smi
->ops
->get_mib_counter(smi
, i
, val
->port_vlan
,
1009 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1012 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1020 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib
);
1022 int rtl8366_sw_get_vlan_info(struct switch_dev
*dev
,
1023 const struct switch_attr
*attr
,
1024 struct switch_val
*val
)
1028 struct rtl8366_vlan_4k vlan4k
;
1029 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1030 char *buf
= smi
->buf
;
1033 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1036 memset(buf
, '\0', sizeof(smi
->buf
));
1038 err
= smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1042 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1043 "VLAN %d: Ports: '", vlan4k
.vid
);
1045 for (i
= 0; i
< smi
->num_ports
; i
++) {
1046 if (!(vlan4k
.member
& (1 << i
)))
1049 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%d%s", i
,
1050 (vlan4k
.untag
& (1 << i
)) ? "" : "t");
1053 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1054 "', members=%04x, untag=%04x, fid=%u",
1055 vlan4k
.member
, vlan4k
.untag
, vlan4k
.fid
);
1062 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info
);
1064 int rtl8366_sw_get_vlan_ports(struct switch_dev
*dev
, struct switch_val
*val
)
1066 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1067 struct switch_port
*port
;
1068 struct rtl8366_vlan_4k vlan4k
;
1071 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1074 smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1076 port
= &val
->value
.ports
[0];
1078 for (i
= 0; i
< smi
->num_ports
; i
++) {
1079 if (!(vlan4k
.member
& BIT(i
)))
1083 port
->flags
= (vlan4k
.untag
& BIT(i
)) ?
1084 0 : BIT(SWITCH_PORT_FLAG_TAGGED
);
1090 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports
);
1092 int rtl8366_sw_set_vlan_ports(struct switch_dev
*dev
, struct switch_val
*val
)
1094 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1095 struct switch_port
*port
;
1101 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1104 port
= &val
->value
.ports
[0];
1105 for (i
= 0; i
< val
->len
; i
++, port
++) {
1106 member
|= BIT(port
->id
);
1108 if (!(port
->flags
& BIT(SWITCH_PORT_FLAG_TAGGED
)))
1109 untag
|= BIT(port
->id
);
1112 * To ensure that we have a valid MC entry for this VLAN,
1113 * initialize the port VLAN ID here.
1115 err
= rtl8366_set_pvid(smi
, port
->id
, val
->port_vlan
);
1120 return rtl8366_set_vlan(smi
, val
->port_vlan
, member
, untag
, 0);
1122 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports
);
1124 int rtl8366_sw_get_vlan_fid(struct switch_dev
*dev
,
1125 const struct switch_attr
*attr
,
1126 struct switch_val
*val
)
1128 struct rtl8366_vlan_4k vlan4k
;
1129 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1132 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1135 err
= smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1139 val
->value
.i
= vlan4k
.fid
;
1143 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid
);
1145 int rtl8366_sw_set_vlan_fid(struct switch_dev
*dev
,
1146 const struct switch_attr
*attr
,
1147 struct switch_val
*val
)
1149 struct rtl8366_vlan_4k vlan4k
;
1150 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1153 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1156 if (val
->value
.i
< 0 || val
->value
.i
> attr
->max
)
1159 err
= smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1163 return rtl8366_set_vlan(smi
, val
->port_vlan
,
1168 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid
);
1170 int rtl8366_sw_get_vlan_enable(struct switch_dev
*dev
,
1171 const struct switch_attr
*attr
,
1172 struct switch_val
*val
)
1174 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1180 val
->value
.i
= smi
->vlan_enabled
;
1182 val
->value
.i
= smi
->vlan4k_enabled
;
1186 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable
);
1188 int rtl8366_sw_set_vlan_enable(struct switch_dev
*dev
,
1189 const struct switch_attr
*attr
,
1190 struct switch_val
*val
)
1192 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1199 err
= rtl8366_enable_vlan(smi
, val
->value
.i
);
1201 err
= rtl8366_enable_vlan4k(smi
, val
->value
.i
);
1205 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable
);
1207 struct rtl8366_smi
*rtl8366_smi_alloc(struct device
*parent
)
1209 struct rtl8366_smi
*smi
;
1213 smi
= kzalloc(sizeof(*smi
), GFP_KERNEL
);
1215 dev_err(parent
, "no memory for private data\n");
1219 smi
->parent
= parent
;
1222 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc
);
1224 static int __rtl8366_smi_init(struct rtl8366_smi
*smi
, const char *name
)
1228 err
= gpio_request(smi
->gpio_sda
, name
);
1230 printk(KERN_ERR
"rtl8366_smi: gpio_request failed for %u, err=%d\n",
1231 smi
->gpio_sda
, err
);
1235 err
= gpio_request(smi
->gpio_sck
, name
);
1237 printk(KERN_ERR
"rtl8366_smi: gpio_request failed for %u, err=%d\n",
1238 smi
->gpio_sck
, err
);
1242 spin_lock_init(&smi
->lock
);
1244 /* start the switch */
1245 if (smi
->hw_reset
) {
1246 smi
->hw_reset(false);
1253 gpio_free(smi
->gpio_sda
);
1258 static void __rtl8366_smi_cleanup(struct rtl8366_smi
*smi
)
1261 smi
->hw_reset(true);
1263 gpio_free(smi
->gpio_sck
);
1264 gpio_free(smi
->gpio_sda
);
1267 enum rtl8366_type
rtl8366_smi_detect(struct rtl8366_platform_data
*pdata
)
1269 static struct rtl8366_smi smi
;
1270 enum rtl8366_type type
= RTL8366_TYPE_UNKNOWN
;
1273 memset(&smi
, 0, sizeof(smi
));
1274 smi
.gpio_sda
= pdata
->gpio_sda
;
1275 smi
.gpio_sck
= pdata
->gpio_sck
;
1277 smi
.cmd_read
= 0xa9;
1278 smi
.cmd_write
= 0xa8;
1280 if (__rtl8366_smi_init(&smi
, "rtl8366"))
1283 if (rtl8366_smi_read_reg(&smi
, 0x5c, ®
))
1288 printk("Found an RTL8366S switch\n");
1289 type
= RTL8366_TYPE_S
;
1292 printk("Found an RTL8366RB switch\n");
1293 type
= RTL8366_TYPE_RB
;
1296 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg
);
1301 __rtl8366_smi_cleanup(&smi
);
1306 int rtl8366_smi_init(struct rtl8366_smi
*smi
)
1313 err
= __rtl8366_smi_init(smi
, dev_name(smi
->parent
));
1317 dev_info(smi
->parent
, "using GPIO pins %u (SDA) and %u (SCK)\n",
1318 smi
->gpio_sda
, smi
->gpio_sck
);
1320 err
= smi
->ops
->detect(smi
);
1322 dev_err(smi
->parent
, "chip detection failed, err=%d\n", err
);
1326 err
= rtl8366_reset(smi
);
1330 err
= smi
->ops
->setup(smi
);
1332 dev_err(smi
->parent
, "chip setup failed, err=%d\n", err
);
1336 err
= rtl8366_init_vlan(smi
);
1338 dev_err(smi
->parent
, "VLAN initialization failed, err=%d\n",
1343 err
= rtl8366_enable_all_ports(smi
, 1);
1347 err
= rtl8366_smi_mii_init(smi
);
1351 rtl8366_debugfs_init(smi
);
1356 __rtl8366_smi_cleanup(smi
);
1360 EXPORT_SYMBOL_GPL(rtl8366_smi_init
);
1362 void rtl8366_smi_cleanup(struct rtl8366_smi
*smi
)
1364 rtl8366_debugfs_remove(smi
);
1365 rtl8366_smi_mii_cleanup(smi
);
1366 __rtl8366_smi_cleanup(smi
);
1368 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup
);
1370 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1371 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1372 MODULE_LICENSE("GPL v2");