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>
19 #include <linux/of_platform.h>
20 #include <linux/of_gpio.h>
21 #include <linux/rtl8366.h>
23 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
24 #include <linux/debugfs.h>
27 #include "rtl8366_smi.h"
29 #define RTL8366_SMI_ACK_RETRY_COUNT 5
31 #define RTL8366_SMI_HW_STOP_DELAY 25 /* msecs */
32 #define RTL8366_SMI_HW_START_DELAY 100 /* msecs */
34 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
36 ndelay(smi->clk_delay);
39 static void rtl8366_smi_start(struct rtl8366_smi *smi)
41 unsigned int sda = smi->gpio_sda;
42 unsigned int sck = smi->gpio_sck;
45 * Set GPIO pins to output mode, with initial state:
48 gpio_direction_output(sck, 0);
49 gpio_direction_output(sda, 1);
50 rtl8366_smi_clk_delay(smi);
52 /* CLK 1: 0 -> 1, 1 -> 0 */
53 gpio_set_value(sck, 1);
54 rtl8366_smi_clk_delay(smi);
55 gpio_set_value(sck, 0);
56 rtl8366_smi_clk_delay(smi);
59 gpio_set_value(sck, 1);
60 rtl8366_smi_clk_delay(smi);
61 gpio_set_value(sda, 0);
62 rtl8366_smi_clk_delay(smi);
63 gpio_set_value(sck, 0);
64 rtl8366_smi_clk_delay(smi);
65 gpio_set_value(sda, 1);
68 static void rtl8366_smi_stop(struct rtl8366_smi *smi)
70 unsigned int sda = smi->gpio_sda;
71 unsigned int sck = smi->gpio_sck;
73 rtl8366_smi_clk_delay(smi);
74 gpio_set_value(sda, 0);
75 gpio_set_value(sck, 1);
76 rtl8366_smi_clk_delay(smi);
77 gpio_set_value(sda, 1);
78 rtl8366_smi_clk_delay(smi);
79 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);
86 rtl8366_smi_clk_delay(smi);
87 gpio_set_value(sck, 0);
88 rtl8366_smi_clk_delay(smi);
89 gpio_set_value(sck, 1);
91 /* set GPIO pins to input mode */
92 gpio_direction_input(sda);
93 gpio_direction_input(sck);
96 static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
98 unsigned int sda = smi->gpio_sda;
99 unsigned int sck = smi->gpio_sck;
101 for (; len > 0; len--) {
102 rtl8366_smi_clk_delay(smi);
105 gpio_set_value(sda, !!(data & ( 1 << (len - 1))));
106 rtl8366_smi_clk_delay(smi);
109 gpio_set_value(sck, 1);
110 rtl8366_smi_clk_delay(smi);
111 gpio_set_value(sck, 0);
115 static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
117 unsigned int sda = smi->gpio_sda;
118 unsigned int sck = smi->gpio_sck;
120 gpio_direction_input(sda);
122 for (*data = 0; len > 0; len--) {
125 rtl8366_smi_clk_delay(smi);
128 gpio_set_value(sck, 1);
129 rtl8366_smi_clk_delay(smi);
130 u = !!gpio_get_value(sda);
131 gpio_set_value(sck, 0);
133 *data |= (u << (len - 1));
136 gpio_direction_output(sda, 0);
139 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
147 rtl8366_smi_read_bits(smi, 1, &ack);
151 if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT) {
152 dev_err(smi->parent, "ACK timeout\n");
160 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
162 rtl8366_smi_write_bits(smi, data, 8);
163 return rtl8366_smi_wait_for_ack(smi);
166 static int rtl8366_smi_write_byte_noack(struct rtl8366_smi *smi, u8 data)
168 rtl8366_smi_write_bits(smi, data, 8);
172 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
177 rtl8366_smi_read_bits(smi, 8, &t);
181 rtl8366_smi_write_bits(smi, 0x00, 1);
186 static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
191 rtl8366_smi_read_bits(smi, 8, &t);
195 rtl8366_smi_write_bits(smi, 0x01, 1);
200 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
207 spin_lock_irqsave(&smi->lock, flags);
209 rtl8366_smi_start(smi);
211 /* send READ command */
212 ret = rtl8366_smi_write_byte(smi, smi->cmd_read);
217 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
222 ret = rtl8366_smi_write_byte(smi, addr >> 8);
227 rtl8366_smi_read_byte0(smi, &lo);
228 /* read DATA[15:8] */
229 rtl8366_smi_read_byte1(smi, &hi);
231 *data = ((u32) lo) | (((u32) hi) << 8);
236 rtl8366_smi_stop(smi);
237 spin_unlock_irqrestore(&smi->lock, flags);
241 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
243 static int __rtl8366_smi_write_reg(struct rtl8366_smi *smi,
244 u32 addr, u32 data, bool ack)
249 spin_lock_irqsave(&smi->lock, flags);
251 rtl8366_smi_start(smi);
253 /* send WRITE command */
254 ret = rtl8366_smi_write_byte(smi, smi->cmd_write);
259 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
264 ret = rtl8366_smi_write_byte(smi, addr >> 8);
268 /* write DATA[7:0] */
269 ret = rtl8366_smi_write_byte(smi, data & 0xff);
273 /* write DATA[15:8] */
275 ret = rtl8366_smi_write_byte(smi, data >> 8);
277 ret = rtl8366_smi_write_byte_noack(smi, data >> 8);
284 rtl8366_smi_stop(smi);
285 spin_unlock_irqrestore(&smi->lock, flags);
290 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
292 return __rtl8366_smi_write_reg(smi, addr, data, true);
294 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
296 int rtl8366_smi_write_reg_noack(struct rtl8366_smi *smi, u32 addr, u32 data)
298 return __rtl8366_smi_write_reg(smi, addr, data, false);
300 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack);
302 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
307 err = rtl8366_smi_read_reg(smi, addr, &t);
311 err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
315 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
317 static int rtl8366_reset(struct rtl8366_smi *smi)
321 msleep(RTL8366_SMI_HW_STOP_DELAY);
322 smi->hw_reset(false);
323 msleep(RTL8366_SMI_HW_START_DELAY);
327 return smi->ops->reset_chip(smi);
330 static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
336 for (i = 0; i < smi->num_ports; i++) {
339 err = smi->ops->get_mc_index(smi, i, &index);
343 if (mc_index == index) {
352 static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
355 struct rtl8366_vlan_4k vlan4k;
359 /* Update the 4K table */
360 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
364 vlan4k.member = member;
365 vlan4k.untag = untag;
367 err = smi->ops->set_vlan_4k(smi, &vlan4k);
371 /* Try to find an existing MC entry for this VID */
372 for (i = 0; i < smi->num_vlan_mc; i++) {
373 struct rtl8366_vlan_mc vlanmc;
375 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
379 if (vid == vlanmc.vid) {
380 /* update the MC entry */
381 vlanmc.member = member;
382 vlanmc.untag = untag;
385 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
393 static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
395 struct rtl8366_vlan_mc vlanmc;
399 err = smi->ops->get_mc_index(smi, port, &index);
403 err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
411 static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
414 struct rtl8366_vlan_mc vlanmc;
415 struct rtl8366_vlan_4k vlan4k;
419 /* Try to find an existing MC entry for this VID */
420 for (i = 0; i < smi->num_vlan_mc; i++) {
421 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
425 if (vid == vlanmc.vid) {
426 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
430 err = smi->ops->set_mc_index(smi, port, i);
435 /* We have no MC entry for this VID, try to find an empty one */
436 for (i = 0; i < smi->num_vlan_mc; i++) {
437 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
441 if (vlanmc.vid == 0 && vlanmc.member == 0) {
442 /* Update the entry from the 4K table */
443 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
448 vlanmc.member = vlan4k.member;
449 vlanmc.untag = vlan4k.untag;
450 vlanmc.fid = vlan4k.fid;
451 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
455 err = smi->ops->set_mc_index(smi, port, i);
460 /* MC table is full, try to find an unused entry and replace it */
461 for (i = 0; i < smi->num_vlan_mc; i++) {
464 err = rtl8366_mc_is_used(smi, i, &used);
469 /* Update the entry from the 4K table */
470 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
475 vlanmc.member = vlan4k.member;
476 vlanmc.untag = vlan4k.untag;
477 vlanmc.fid = vlan4k.fid;
478 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
482 err = smi->ops->set_mc_index(smi, port, i);
488 "all VLAN member configurations are in use\n");
493 int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
497 err = smi->ops->enable_vlan(smi, enable);
501 smi->vlan_enabled = enable;
504 smi->vlan4k_enabled = 0;
505 err = smi->ops->enable_vlan4k(smi, enable);
510 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
512 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
517 err = smi->ops->enable_vlan(smi, enable);
521 smi->vlan_enabled = enable;
524 err = smi->ops->enable_vlan4k(smi, enable);
528 smi->vlan4k_enabled = enable;
532 int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
537 for (port = 0; port < smi->num_ports; port++) {
538 err = smi->ops->enable_port(smi, port, enable);
545 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
547 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
549 struct rtl8366_vlan_mc vlanmc;
553 rtl8366_enable_vlan(smi, 0);
554 rtl8366_enable_vlan4k(smi, 0);
556 /* clear VLAN member configurations */
562 for (i = 0; i < smi->num_vlan_mc; i++) {
563 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
570 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
572 static int rtl8366_init_vlan(struct rtl8366_smi *smi)
577 err = rtl8366_reset_vlan(smi);
581 for (port = 0; port < smi->num_ports; port++) {
584 if (port == smi->cpu_port)
585 mask = (1 << smi->num_ports) - 1;
587 mask = (1 << port) | (1 << smi->cpu_port);
589 err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
593 err = rtl8366_set_pvid(smi, port, (port + 1));
598 return rtl8366_enable_vlan(smi, 1);
601 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
602 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
604 file->private_data = inode->i_private;
607 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
609 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
610 char __user *user_buf,
611 size_t count, loff_t *ppos)
613 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
615 char *buf = smi->buf;
617 len += snprintf(buf + len, sizeof(smi->buf) - len,
618 "%2s %6s %4s %6s %6s %3s\n",
619 "id", "vid","prio", "member", "untag", "fid");
621 for (i = 0; i < smi->num_vlan_mc; ++i) {
622 struct rtl8366_vlan_mc vlanmc;
624 smi->ops->get_vlan_mc(smi, i, &vlanmc);
626 len += snprintf(buf + len, sizeof(smi->buf) - len,
627 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
628 i, vlanmc.vid, vlanmc.priority,
629 vlanmc.member, vlanmc.untag, vlanmc.fid);
632 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
635 #define RTL8366_VLAN4K_PAGE_SIZE 64
636 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
638 static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
639 char __user *user_buf,
640 size_t count, loff_t *ppos)
642 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
645 char *buf = smi->buf;
647 if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
648 len += snprintf(buf + len, sizeof(smi->buf) - len,
649 "invalid page: %u\n", smi->dbg_vlan_4k_page);
650 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
653 len += snprintf(buf + len, sizeof(smi->buf) - len,
655 "vid", "member", "untag", "fid");
657 offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
658 for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
659 struct rtl8366_vlan_4k vlan4k;
661 smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
663 len += snprintf(buf + len, sizeof(smi->buf) - len,
664 "%4d 0x%04x 0x%04x %3d\n",
665 vlan4k.vid, vlan4k.member,
666 vlan4k.untag, vlan4k.fid);
669 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
672 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
673 char __user *user_buf,
674 size_t count, loff_t *ppos)
676 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
677 char *buf = smi->buf;
681 len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
684 for (i = 0; i < smi->num_ports; i++) {
688 err = rtl8366_get_pvid(smi, i, &pvid);
690 len += snprintf(buf + len, sizeof(smi->buf) - len,
693 len += snprintf(buf + len, sizeof(smi->buf) - len,
694 "%4d %4d\n", i, pvid);
697 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
700 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
701 char __user *user_buf,
702 size_t count, loff_t *ppos)
704 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
705 u32 t, reg = smi->dbg_reg;
707 char *buf = smi->buf;
709 memset(buf, '\0', sizeof(smi->buf));
711 err = rtl8366_smi_read_reg(smi, reg, &t);
713 len += snprintf(buf, sizeof(smi->buf),
714 "Read failed (reg: 0x%04x)\n", reg);
715 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
718 len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
721 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
724 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
725 const char __user *user_buf,
726 size_t count, loff_t *ppos)
728 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
730 u32 reg = smi->dbg_reg;
733 char *buf = smi->buf;
735 len = min(count, sizeof(smi->buf) - 1);
736 if (copy_from_user(buf, user_buf, len)) {
737 dev_err(smi->parent, "copy from user failed\n");
742 if (len > 0 && buf[len - 1] == '\n')
746 if (strict_strtoul(buf, 16, &data)) {
747 dev_err(smi->parent, "Invalid reg value %s\n", buf);
749 err = rtl8366_smi_write_reg(smi, reg, data);
752 "writing reg 0x%04x val 0x%04lx failed\n",
760 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
761 char __user *user_buf,
762 size_t count, loff_t *ppos)
764 struct rtl8366_smi *smi = file->private_data;
766 char *buf = smi->buf;
768 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
771 for (i = 0; i < smi->num_ports; i++) {
774 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
775 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
778 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
780 for (i = 0; i < smi->num_mib_counters; i++) {
781 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
782 smi->mib_counters[i].name);
783 for (j = 0; j < smi->num_ports; j++) {
784 unsigned long long counter = 0;
786 if (!smi->ops->get_mib_counter(smi, i, j, &counter))
787 len += snprintf(buf + len,
788 sizeof(smi->buf) - len,
791 len += snprintf(buf + len,
792 sizeof(smi->buf) - len,
795 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
798 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
801 static const struct file_operations fops_rtl8366_regs = {
802 .read = rtl8366_read_debugfs_reg,
803 .write = rtl8366_write_debugfs_reg,
804 .open = rtl8366_debugfs_open,
808 static const struct file_operations fops_rtl8366_vlan_mc = {
809 .read = rtl8366_read_debugfs_vlan_mc,
810 .open = rtl8366_debugfs_open,
814 static const struct file_operations fops_rtl8366_vlan_4k = {
815 .read = rtl8366_read_debugfs_vlan_4k,
816 .open = rtl8366_debugfs_open,
820 static const struct file_operations fops_rtl8366_pvid = {
821 .read = rtl8366_read_debugfs_pvid,
822 .open = rtl8366_debugfs_open,
826 static const struct file_operations fops_rtl8366_mibs = {
827 .read = rtl8366_read_debugfs_mibs,
828 .open = rtl8366_debugfs_open,
832 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
837 if (!smi->debugfs_root)
838 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
841 if (!smi->debugfs_root) {
842 dev_err(smi->parent, "Unable to create debugfs dir\n");
845 root = smi->debugfs_root;
847 node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
850 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
855 node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
858 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
863 node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
864 &fops_rtl8366_vlan_mc);
866 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
871 node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
872 &smi->dbg_vlan_4k_page);
874 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
879 node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
880 &fops_rtl8366_vlan_4k);
882 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
887 node = debugfs_create_file("pvid", S_IRUSR, root, smi,
890 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
895 node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
898 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
902 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
904 if (smi->debugfs_root) {
905 debugfs_remove_recursive(smi->debugfs_root);
906 smi->debugfs_root = NULL;
910 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
911 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
912 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
914 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
919 smi->mii_bus = mdiobus_alloc();
920 if (smi->mii_bus == NULL) {
925 smi->mii_bus->priv = (void *) smi;
926 smi->mii_bus->name = dev_name(smi->parent);
927 smi->mii_bus->read = smi->ops->mii_read;
928 smi->mii_bus->write = smi->ops->mii_write;
929 snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
930 dev_name(smi->parent));
931 smi->mii_bus->parent = smi->parent;
932 smi->mii_bus->phy_mask = ~(0x1f);
933 smi->mii_bus->irq = smi->mii_irq;
934 for (i = 0; i < PHY_MAX_ADDR; i++)
935 smi->mii_irq[i] = PHY_POLL;
937 ret = mdiobus_register(smi->mii_bus);
944 mdiobus_free(smi->mii_bus);
949 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
951 mdiobus_unregister(smi->mii_bus);
952 mdiobus_free(smi->mii_bus);
955 int rtl8366_sw_reset_switch(struct switch_dev *dev)
957 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
960 err = rtl8366_reset(smi);
964 err = smi->ops->setup(smi);
968 err = rtl8366_reset_vlan(smi);
972 err = rtl8366_enable_vlan(smi, 1);
976 return rtl8366_enable_all_ports(smi, 1);
978 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch);
980 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
982 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
983 return rtl8366_get_pvid(smi, port, val);
985 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
987 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
989 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
990 return rtl8366_set_pvid(smi, port, val);
992 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
994 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
995 const struct switch_attr *attr,
996 struct switch_val *val)
998 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1000 unsigned long long counter = 0;
1001 char *buf = smi->buf;
1003 if (val->port_vlan >= smi->num_ports)
1006 len += snprintf(buf + len, sizeof(smi->buf) - len,
1007 "Port %d MIB counters\n",
1010 for (i = 0; i < smi->num_mib_counters; ++i) {
1011 len += snprintf(buf + len, sizeof(smi->buf) - len,
1012 "%-36s: ", smi->mib_counters[i].name);
1013 if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
1015 len += snprintf(buf + len, sizeof(smi->buf) - len,
1018 len += snprintf(buf + len, sizeof(smi->buf) - len,
1026 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
1028 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
1029 const struct switch_attr *attr,
1030 struct switch_val *val)
1034 struct rtl8366_vlan_4k vlan4k;
1035 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1036 char *buf = smi->buf;
1039 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1042 memset(buf, '\0', sizeof(smi->buf));
1044 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1048 len += snprintf(buf + len, sizeof(smi->buf) - len,
1049 "VLAN %d: Ports: '", vlan4k.vid);
1051 for (i = 0; i < smi->num_ports; i++) {
1052 if (!(vlan4k.member & (1 << i)))
1055 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1056 (vlan4k.untag & (1 << i)) ? "" : "t");
1059 len += snprintf(buf + len, sizeof(smi->buf) - len,
1060 "', members=%04x, untag=%04x, fid=%u",
1061 vlan4k.member, vlan4k.untag, vlan4k.fid);
1068 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1070 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1072 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1073 struct switch_port *port;
1074 struct rtl8366_vlan_4k vlan4k;
1077 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1080 smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1082 port = &val->value.ports[0];
1084 for (i = 0; i < smi->num_ports; i++) {
1085 if (!(vlan4k.member & BIT(i)))
1089 port->flags = (vlan4k.untag & BIT(i)) ?
1090 0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1096 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1098 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1100 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1101 struct switch_port *port;
1107 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1110 port = &val->value.ports[0];
1111 for (i = 0; i < val->len; i++, port++) {
1112 member |= BIT(port->id);
1114 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1115 untag |= BIT(port->id);
1118 * To ensure that we have a valid MC entry for this VLAN,
1119 * initialize the port VLAN ID here.
1121 err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1126 return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1128 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1130 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1131 const struct switch_attr *attr,
1132 struct switch_val *val)
1134 struct rtl8366_vlan_4k vlan4k;
1135 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1138 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1141 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1145 val->value.i = vlan4k.fid;
1149 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1151 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1152 const struct switch_attr *attr,
1153 struct switch_val *val)
1155 struct rtl8366_vlan_4k vlan4k;
1156 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1159 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1162 if (val->value.i < 0 || val->value.i > attr->max)
1165 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1169 return rtl8366_set_vlan(smi, val->port_vlan,
1174 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1176 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1177 const struct switch_attr *attr,
1178 struct switch_val *val)
1180 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1186 val->value.i = smi->vlan_enabled;
1188 val->value.i = smi->vlan4k_enabled;
1192 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1194 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1195 const struct switch_attr *attr,
1196 struct switch_val *val)
1198 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1205 err = rtl8366_enable_vlan(smi, val->value.i);
1207 err = rtl8366_enable_vlan4k(smi, val->value.i);
1211 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1213 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1215 struct rtl8366_smi *smi;
1219 smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1221 dev_err(parent, "no memory for private data\n");
1225 smi->parent = parent;
1228 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1230 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1234 err = gpio_request(smi->gpio_sda, name);
1236 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1237 smi->gpio_sda, err);
1241 err = gpio_request(smi->gpio_sck, name);
1243 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1244 smi->gpio_sck, err);
1248 spin_lock_init(&smi->lock);
1250 /* start the switch */
1251 if (smi->hw_reset) {
1252 smi->hw_reset(false);
1253 msleep(RTL8366_SMI_HW_START_DELAY);
1259 gpio_free(smi->gpio_sda);
1264 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1267 smi->hw_reset(true);
1269 gpio_free(smi->gpio_sck);
1270 gpio_free(smi->gpio_sda);
1273 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1275 static struct rtl8366_smi smi;
1276 enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1279 memset(&smi, 0, sizeof(smi));
1280 smi.gpio_sda = pdata->gpio_sda;
1281 smi.gpio_sck = pdata->gpio_sck;
1283 smi.cmd_read = 0xa9;
1284 smi.cmd_write = 0xa8;
1286 if (__rtl8366_smi_init(&smi, "rtl8366"))
1289 if (rtl8366_smi_read_reg(&smi, 0x5c, ®))
1294 printk("Found an RTL8366S switch\n");
1295 type = RTL8366_TYPE_S;
1298 printk("Found an RTL8366RB switch\n");
1299 type = RTL8366_TYPE_RB;
1302 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1307 __rtl8366_smi_cleanup(&smi);
1312 int rtl8366_smi_init(struct rtl8366_smi *smi)
1319 err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1323 dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1324 smi->gpio_sda, smi->gpio_sck);
1326 err = smi->ops->detect(smi);
1328 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1332 err = rtl8366_reset(smi);
1336 err = smi->ops->setup(smi);
1338 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1342 err = rtl8366_init_vlan(smi);
1344 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1349 err = rtl8366_enable_all_ports(smi, 1);
1353 err = rtl8366_smi_mii_init(smi);
1357 rtl8366_debugfs_init(smi);
1362 __rtl8366_smi_cleanup(smi);
1366 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1368 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1370 rtl8366_debugfs_remove(smi);
1371 rtl8366_smi_mii_cleanup(smi);
1372 __rtl8366_smi_cleanup(smi);
1374 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1377 int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1379 int sck = of_get_named_gpio(pdev->dev.of_node, "gpio-sck", 0);
1380 int sda = of_get_named_gpio(pdev->dev.of_node, "gpio-sda", 0);
1382 if (!gpio_is_valid(sck) || !gpio_is_valid(sda)) {
1383 dev_err(&pdev->dev, "gpios missing in devictree\n");
1387 smi->gpio_sda = sda;
1388 smi->gpio_sck = sck;
1393 static inline int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
1399 int rtl8366_smi_probe_plat(struct platform_device *pdev, struct rtl8366_smi *smi)
1401 struct rtl8366_platform_data *pdata = pdev->dev.platform_data;
1403 if (!pdev->dev.platform_data) {
1404 dev_err(&pdev->dev, "no platform data specified\n");
1408 smi->gpio_sda = pdata->gpio_sda;
1409 smi->gpio_sck = pdata->gpio_sck;
1410 smi->hw_reset = pdata->hw_reset;
1416 struct rtl8366_smi *rtl8366_smi_probe(struct platform_device *pdev)
1418 struct rtl8366_smi *smi;
1421 smi = rtl8366_smi_alloc(&pdev->dev);
1425 if (pdev->dev.of_node)
1426 err = rtl8366_smi_probe_of(pdev, smi);
1428 err = rtl8366_smi_probe_plat(pdev, smi);
1439 EXPORT_SYMBOL_GPL(rtl8366_smi_probe);
1441 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1442 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1443 MODULE_LICENSE("GPL v2");