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/of_platform.h>
19 #include <linux/of_gpio.h>
20 #include <linux/rtl8366.h>
22 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
23 #include <linux/debugfs.h>
26 #include "rtl8366_smi.h"
28 #define RTL8366_SMI_ACK_RETRY_COUNT 5
30 #define RTL8366_SMI_HW_STOP_DELAY 25 /* msecs */
31 #define RTL8366_SMI_HW_START_DELAY 100 /* msecs */
33 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi *smi)
35 ndelay(smi->clk_delay);
38 static void rtl8366_smi_start(struct rtl8366_smi *smi)
40 unsigned int sda = smi->gpio_sda;
41 unsigned int sck = smi->gpio_sck;
44 * Set GPIO pins to output mode, with initial state:
47 gpio_direction_output(sck, 0);
48 gpio_direction_output(sda, 1);
49 rtl8366_smi_clk_delay(smi);
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);
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);
67 static void rtl8366_smi_stop(struct rtl8366_smi *smi)
69 unsigned int sda = smi->gpio_sda;
70 unsigned int sck = smi->gpio_sck;
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);
85 rtl8366_smi_clk_delay(smi);
86 gpio_set_value(sck, 0);
87 rtl8366_smi_clk_delay(smi);
88 gpio_set_value(sck, 1);
90 /* set GPIO pins to input mode */
91 gpio_direction_input(sda);
92 gpio_direction_input(sck);
95 static void rtl8366_smi_write_bits(struct rtl8366_smi *smi, u32 data, u32 len)
97 unsigned int sda = smi->gpio_sda;
98 unsigned int sck = smi->gpio_sck;
100 for (; len > 0; len--) {
101 rtl8366_smi_clk_delay(smi);
104 gpio_set_value(sda, !!(data & ( 1 << (len - 1))));
105 rtl8366_smi_clk_delay(smi);
108 gpio_set_value(sck, 1);
109 rtl8366_smi_clk_delay(smi);
110 gpio_set_value(sck, 0);
114 static void rtl8366_smi_read_bits(struct rtl8366_smi *smi, u32 len, u32 *data)
116 unsigned int sda = smi->gpio_sda;
117 unsigned int sck = smi->gpio_sck;
119 gpio_direction_input(sda);
121 for (*data = 0; len > 0; len--) {
124 rtl8366_smi_clk_delay(smi);
127 gpio_set_value(sck, 1);
128 rtl8366_smi_clk_delay(smi);
129 u = !!gpio_get_value(sda);
130 gpio_set_value(sck, 0);
132 *data |= (u << (len - 1));
135 gpio_direction_output(sda, 0);
138 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi *smi)
146 rtl8366_smi_read_bits(smi, 1, &ack);
150 if (++retry_cnt > RTL8366_SMI_ACK_RETRY_COUNT) {
151 dev_err(smi->parent, "ACK timeout\n");
159 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
161 rtl8366_smi_write_bits(smi, data, 8);
162 return rtl8366_smi_wait_for_ack(smi);
165 static int rtl8366_smi_write_byte_noack(struct rtl8366_smi *smi, u8 data)
167 rtl8366_smi_write_bits(smi, data, 8);
171 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
176 rtl8366_smi_read_bits(smi, 8, &t);
180 rtl8366_smi_write_bits(smi, 0x00, 1);
185 static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
190 rtl8366_smi_read_bits(smi, 8, &t);
194 rtl8366_smi_write_bits(smi, 0x01, 1);
199 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
206 spin_lock_irqsave(&smi->lock, flags);
208 rtl8366_smi_start(smi);
210 /* send READ command */
211 ret = rtl8366_smi_write_byte(smi, smi->cmd_read);
216 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
221 ret = rtl8366_smi_write_byte(smi, addr >> 8);
226 rtl8366_smi_read_byte0(smi, &lo);
227 /* read DATA[15:8] */
228 rtl8366_smi_read_byte1(smi, &hi);
230 *data = ((u32) lo) | (((u32) hi) << 8);
235 rtl8366_smi_stop(smi);
236 spin_unlock_irqrestore(&smi->lock, flags);
240 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
242 static int __rtl8366_smi_write_reg(struct rtl8366_smi *smi,
243 u32 addr, u32 data, bool ack)
248 spin_lock_irqsave(&smi->lock, flags);
250 rtl8366_smi_start(smi);
252 /* send WRITE command */
253 ret = rtl8366_smi_write_byte(smi, smi->cmd_write);
258 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
263 ret = rtl8366_smi_write_byte(smi, addr >> 8);
267 /* write DATA[7:0] */
268 ret = rtl8366_smi_write_byte(smi, data & 0xff);
272 /* write DATA[15:8] */
274 ret = rtl8366_smi_write_byte(smi, data >> 8);
276 ret = rtl8366_smi_write_byte_noack(smi, data >> 8);
283 rtl8366_smi_stop(smi);
284 spin_unlock_irqrestore(&smi->lock, flags);
289 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
291 return __rtl8366_smi_write_reg(smi, addr, data, true);
293 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
295 int rtl8366_smi_write_reg_noack(struct rtl8366_smi *smi, u32 addr, u32 data)
297 return __rtl8366_smi_write_reg(smi, addr, data, false);
299 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack);
301 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
306 err = rtl8366_smi_read_reg(smi, addr, &t);
310 err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
314 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
316 static int rtl8366_reset(struct rtl8366_smi *smi)
320 msleep(RTL8366_SMI_HW_STOP_DELAY);
321 smi->hw_reset(false);
322 msleep(RTL8366_SMI_HW_START_DELAY);
326 return smi->ops->reset_chip(smi);
329 static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
335 for (i = 0; i < smi->num_ports; i++) {
338 err = smi->ops->get_mc_index(smi, i, &index);
342 if (mc_index == index) {
351 static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
354 struct rtl8366_vlan_4k vlan4k;
358 /* Update the 4K table */
359 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
363 vlan4k.member = member;
364 vlan4k.untag = untag;
366 err = smi->ops->set_vlan_4k(smi, &vlan4k);
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;
374 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
378 if (vid == vlanmc.vid) {
379 /* update the MC entry */
380 vlanmc.member = member;
381 vlanmc.untag = untag;
384 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
392 static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
394 struct rtl8366_vlan_mc vlanmc;
398 err = smi->ops->get_mc_index(smi, port, &index);
402 err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
410 static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
413 struct rtl8366_vlan_mc vlanmc;
414 struct rtl8366_vlan_4k vlan4k;
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);
424 if (vid == vlanmc.vid) {
425 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
429 err = smi->ops->set_mc_index(smi, port, i);
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);
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);
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);
454 err = smi->ops->set_mc_index(smi, port, i);
459 /* MC table is full, try to find an unused entry and replace it */
460 for (i = 0; i < smi->num_vlan_mc; i++) {
463 err = rtl8366_mc_is_used(smi, i, &used);
468 /* Update the entry from the 4K table */
469 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
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);
481 err = smi->ops->set_mc_index(smi, port, i);
487 "all VLAN member configurations are in use\n");
492 int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
496 err = smi->ops->enable_vlan(smi, enable);
500 smi->vlan_enabled = enable;
503 smi->vlan4k_enabled = 0;
504 err = smi->ops->enable_vlan4k(smi, enable);
509 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
511 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
516 err = smi->ops->enable_vlan(smi, enable);
520 smi->vlan_enabled = enable;
523 err = smi->ops->enable_vlan4k(smi, enable);
527 smi->vlan4k_enabled = enable;
531 int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
536 for (port = 0; port < smi->num_ports; port++) {
537 err = smi->ops->enable_port(smi, port, enable);
544 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
546 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
548 struct rtl8366_vlan_mc vlanmc;
552 rtl8366_enable_vlan(smi, 0);
553 rtl8366_enable_vlan4k(smi, 0);
555 /* clear VLAN member configurations */
561 for (i = 0; i < smi->num_vlan_mc; i++) {
562 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
569 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
571 static int rtl8366_init_vlan(struct rtl8366_smi *smi)
576 err = rtl8366_reset_vlan(smi);
580 for (port = 0; port < smi->num_ports; port++) {
583 if (port == smi->cpu_port)
584 mask = (1 << smi->num_ports) - 1;
586 mask = (1 << port) | (1 << smi->cpu_port);
588 err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
592 err = rtl8366_set_pvid(smi, port, (port + 1));
597 return rtl8366_enable_vlan(smi, 1);
600 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
601 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
603 file->private_data = inode->i_private;
606 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
608 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
609 char __user *user_buf,
610 size_t count, loff_t *ppos)
612 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
614 char *buf = smi->buf;
616 len += snprintf(buf + len, sizeof(smi->buf) - len,
617 "%2s %6s %4s %6s %6s %3s\n",
618 "id", "vid","prio", "member", "untag", "fid");
620 for (i = 0; i < smi->num_vlan_mc; ++i) {
621 struct rtl8366_vlan_mc vlanmc;
623 smi->ops->get_vlan_mc(smi, i, &vlanmc);
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);
631 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
634 #define RTL8366_VLAN4K_PAGE_SIZE 64
635 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
637 static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
638 char __user *user_buf,
639 size_t count, loff_t *ppos)
641 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
644 char *buf = smi->buf;
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);
652 len += snprintf(buf + len, sizeof(smi->buf) - len,
654 "vid", "member", "untag", "fid");
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;
660 smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
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);
668 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
671 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
672 char __user *user_buf,
673 size_t count, loff_t *ppos)
675 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
676 char *buf = smi->buf;
680 len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
683 for (i = 0; i < smi->num_ports; i++) {
687 err = rtl8366_get_pvid(smi, i, &pvid);
689 len += snprintf(buf + len, sizeof(smi->buf) - len,
692 len += snprintf(buf + len, sizeof(smi->buf) - len,
693 "%4d %4d\n", i, pvid);
696 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
699 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
700 char __user *user_buf,
701 size_t count, loff_t *ppos)
703 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
704 u32 t, reg = smi->dbg_reg;
706 char *buf = smi->buf;
708 memset(buf, '\0', sizeof(smi->buf));
710 err = rtl8366_smi_read_reg(smi, reg, &t);
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);
717 len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
720 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
723 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
724 const char __user *user_buf,
725 size_t count, loff_t *ppos)
727 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
729 u32 reg = smi->dbg_reg;
732 char *buf = smi->buf;
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");
741 if (len > 0 && buf[len - 1] == '\n')
745 if (strict_strtoul(buf, 16, &data)) {
746 dev_err(smi->parent, "Invalid reg value %s\n", buf);
748 err = rtl8366_smi_write_reg(smi, reg, data);
751 "writing reg 0x%04x val 0x%04lx failed\n",
759 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
760 char __user *user_buf,
761 size_t count, loff_t *ppos)
763 struct rtl8366_smi *smi = file->private_data;
765 char *buf = smi->buf;
767 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
770 for (i = 0; i < smi->num_ports; i++) {
773 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
774 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
777 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
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;
785 if (!smi->ops->get_mib_counter(smi, i, j, &counter))
786 len += snprintf(buf + len,
787 sizeof(smi->buf) - len,
790 len += snprintf(buf + len,
791 sizeof(smi->buf) - len,
794 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
797 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
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,
807 static const struct file_operations fops_rtl8366_vlan_mc = {
808 .read = rtl8366_read_debugfs_vlan_mc,
809 .open = rtl8366_debugfs_open,
813 static const struct file_operations fops_rtl8366_vlan_4k = {
814 .read = rtl8366_read_debugfs_vlan_4k,
815 .open = rtl8366_debugfs_open,
819 static const struct file_operations fops_rtl8366_pvid = {
820 .read = rtl8366_read_debugfs_pvid,
821 .open = rtl8366_debugfs_open,
825 static const struct file_operations fops_rtl8366_mibs = {
826 .read = rtl8366_read_debugfs_mibs,
827 .open = rtl8366_debugfs_open,
831 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
836 if (!smi->debugfs_root)
837 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
840 if (!smi->debugfs_root) {
841 dev_err(smi->parent, "Unable to create debugfs dir\n");
844 root = smi->debugfs_root;
846 node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
849 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
854 node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
857 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
862 node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
863 &fops_rtl8366_vlan_mc);
865 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
870 node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
871 &smi->dbg_vlan_4k_page);
873 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
878 node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
879 &fops_rtl8366_vlan_4k);
881 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
886 node = debugfs_create_file("pvid", S_IRUSR, root, smi,
889 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
894 node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
897 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
901 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
903 if (smi->debugfs_root) {
904 debugfs_remove_recursive(smi->debugfs_root);
905 smi->debugfs_root = NULL;
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 */
913 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
918 smi->mii_bus = mdiobus_alloc();
919 if (smi->mii_bus == NULL) {
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;
936 ret = mdiobus_register(smi->mii_bus);
943 mdiobus_free(smi->mii_bus);
948 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
950 mdiobus_unregister(smi->mii_bus);
951 mdiobus_free(smi->mii_bus);
954 int rtl8366_sw_reset_switch(struct switch_dev *dev)
956 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
959 err = rtl8366_reset(smi);
963 err = smi->ops->setup(smi);
967 err = rtl8366_reset_vlan(smi);
971 err = rtl8366_enable_vlan(smi, 1);
975 return rtl8366_enable_all_ports(smi, 1);
977 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch);
979 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
981 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
982 return rtl8366_get_pvid(smi, port, val);
984 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
986 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
988 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
989 return rtl8366_set_pvid(smi, port, val);
991 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
993 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
994 const struct switch_attr *attr,
995 struct switch_val *val)
997 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
999 unsigned long long counter = 0;
1000 char *buf = smi->buf;
1002 if (val->port_vlan >= smi->num_ports)
1005 len += snprintf(buf + len, sizeof(smi->buf) - len,
1006 "Port %d MIB counters\n",
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,
1014 len += snprintf(buf + len, sizeof(smi->buf) - len,
1017 len += snprintf(buf + len, sizeof(smi->buf) - len,
1025 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
1027 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
1028 const struct switch_attr *attr,
1029 struct switch_val *val)
1033 struct rtl8366_vlan_4k vlan4k;
1034 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1035 char *buf = smi->buf;
1038 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1041 memset(buf, '\0', sizeof(smi->buf));
1043 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1047 len += snprintf(buf + len, sizeof(smi->buf) - len,
1048 "VLAN %d: Ports: '", vlan4k.vid);
1050 for (i = 0; i < smi->num_ports; i++) {
1051 if (!(vlan4k.member & (1 << i)))
1054 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1055 (vlan4k.untag & (1 << i)) ? "" : "t");
1058 len += snprintf(buf + len, sizeof(smi->buf) - len,
1059 "', members=%04x, untag=%04x, fid=%u",
1060 vlan4k.member, vlan4k.untag, vlan4k.fid);
1067 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1069 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1071 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1072 struct switch_port *port;
1073 struct rtl8366_vlan_4k vlan4k;
1076 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1079 smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1081 port = &val->value.ports[0];
1083 for (i = 0; i < smi->num_ports; i++) {
1084 if (!(vlan4k.member & BIT(i)))
1088 port->flags = (vlan4k.untag & BIT(i)) ?
1089 0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1095 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1097 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1099 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1100 struct switch_port *port;
1106 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1109 port = &val->value.ports[0];
1110 for (i = 0; i < val->len; i++, port++) {
1111 member |= BIT(port->id);
1113 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1114 untag |= BIT(port->id);
1117 * To ensure that we have a valid MC entry for this VLAN,
1118 * initialize the port VLAN ID here.
1120 err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1125 return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1127 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1129 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1130 const struct switch_attr *attr,
1131 struct switch_val *val)
1133 struct rtl8366_vlan_4k vlan4k;
1134 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1137 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1140 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1144 val->value.i = vlan4k.fid;
1148 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1150 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1151 const struct switch_attr *attr,
1152 struct switch_val *val)
1154 struct rtl8366_vlan_4k vlan4k;
1155 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1158 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1161 if (val->value.i < 0 || val->value.i > attr->max)
1164 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1168 return rtl8366_set_vlan(smi, val->port_vlan,
1173 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1175 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1176 const struct switch_attr *attr,
1177 struct switch_val *val)
1179 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1185 val->value.i = smi->vlan_enabled;
1187 val->value.i = smi->vlan4k_enabled;
1191 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1193 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1194 const struct switch_attr *attr,
1195 struct switch_val *val)
1197 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1204 err = rtl8366_enable_vlan(smi, val->value.i);
1206 err = rtl8366_enable_vlan4k(smi, val->value.i);
1210 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1212 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1214 struct rtl8366_smi *smi;
1218 smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1220 dev_err(parent, "no memory for private data\n");
1224 smi->parent = parent;
1227 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1229 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1233 err = gpio_request(smi->gpio_sda, name);
1235 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1236 smi->gpio_sda, err);
1240 err = gpio_request(smi->gpio_sck, name);
1242 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1243 smi->gpio_sck, err);
1247 spin_lock_init(&smi->lock);
1249 /* start the switch */
1250 if (smi->hw_reset) {
1251 smi->hw_reset(false);
1252 msleep(RTL8366_SMI_HW_START_DELAY);
1258 gpio_free(smi->gpio_sda);
1263 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1266 smi->hw_reset(true);
1268 gpio_free(smi->gpio_sck);
1269 gpio_free(smi->gpio_sda);
1272 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1274 static struct rtl8366_smi smi;
1275 enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1278 memset(&smi, 0, sizeof(smi));
1279 smi.gpio_sda = pdata->gpio_sda;
1280 smi.gpio_sck = pdata->gpio_sck;
1282 smi.cmd_read = 0xa9;
1283 smi.cmd_write = 0xa8;
1285 if (__rtl8366_smi_init(&smi, "rtl8366"))
1288 if (rtl8366_smi_read_reg(&smi, 0x5c, ®))
1293 printk("Found an RTL8366S switch\n");
1294 type = RTL8366_TYPE_S;
1297 printk("Found an RTL8366RB switch\n");
1298 type = RTL8366_TYPE_RB;
1301 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1306 __rtl8366_smi_cleanup(&smi);
1311 int rtl8366_smi_init(struct rtl8366_smi *smi)
1318 err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1322 dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1323 smi->gpio_sda, smi->gpio_sck);
1325 err = smi->ops->detect(smi);
1327 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1331 err = rtl8366_reset(smi);
1335 err = smi->ops->setup(smi);
1337 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1341 err = rtl8366_init_vlan(smi);
1343 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1348 err = rtl8366_enable_all_ports(smi, 1);
1352 err = rtl8366_smi_mii_init(smi);
1356 rtl8366_debugfs_init(smi);
1361 __rtl8366_smi_cleanup(smi);
1365 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1367 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1369 rtl8366_debugfs_remove(smi);
1370 rtl8366_smi_mii_cleanup(smi);
1371 __rtl8366_smi_cleanup(smi);
1373 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1376 int rtl8366_smi_probe_of(struct platform_device *pdev, struct rtl8366_smi *smi)
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);
1382 dev_err(&pdev->dev, "gpios missing in devictree\n");
1386 smi->gpio_sda = sda;
1387 smi->gpio_sck = sck;
1392 static inline int rtl8366_smi_probe_of(struct device_node *np, struct rtl8366_smi *smi)
1398 int rtl8366_smi_probe_plat(struct platform_device *pdev, struct rtl8366_smi *smi)
1400 struct rtl8366_platform_data *pdata = pdev->dev.platform_data;
1402 if (!pdev->dev.platform_data) {
1403 dev_err(&pdev->dev, "no platform data specified\n");
1407 smi->gpio_sda = pdata->gpio_sda;
1408 smi->gpio_sck = pdata->gpio_sck;
1409 smi->hw_reset = pdata->hw_reset;
1415 struct rtl8366_smi *rtl8366_smi_probe(struct platform_device *pdev)
1417 struct rtl8366_smi *smi;
1420 smi = rtl8366_smi_alloc(&pdev->dev);
1424 if (pdev->dev.of_node)
1425 err = rtl8366_smi_probe_of(pdev, smi);
1427 err = rtl8366_smi_probe_plat(pdev, smi);
1438 EXPORT_SYMBOL_GPL(rtl8366_smi_probe);
1440 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1441 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1442 MODULE_LICENSE("GPL v2");