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_RTL8366S_PHY_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");
155 static int rtl8366_smi_write_byte(struct rtl8366_smi *smi, u8 data)
157 rtl8366_smi_write_bits(smi, data, 8);
158 return rtl8366_smi_wait_for_ack(smi);
161 static int rtl8366_smi_write_byte_noack(struct rtl8366_smi *smi, u8 data)
163 rtl8366_smi_write_bits(smi, data, 8);
167 static int rtl8366_smi_read_byte0(struct rtl8366_smi *smi, u8 *data)
172 rtl8366_smi_read_bits(smi, 8, &t);
176 rtl8366_smi_write_bits(smi, 0x00, 1);
181 static int rtl8366_smi_read_byte1(struct rtl8366_smi *smi, u8 *data)
186 rtl8366_smi_read_bits(smi, 8, &t);
190 rtl8366_smi_write_bits(smi, 0x01, 1);
195 int rtl8366_smi_read_reg(struct rtl8366_smi *smi, u32 addr, u32 *data)
202 spin_lock_irqsave(&smi->lock, flags);
204 rtl8366_smi_start(smi);
206 /* send READ command */
207 ret = rtl8366_smi_write_byte(smi, smi->cmd_read);
212 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
217 ret = rtl8366_smi_write_byte(smi, addr >> 8);
222 rtl8366_smi_read_byte0(smi, &lo);
223 /* read DATA[15:8] */
224 rtl8366_smi_read_byte1(smi, &hi);
226 *data = ((u32) lo) | (((u32) hi) << 8);
231 rtl8366_smi_stop(smi);
232 spin_unlock_irqrestore(&smi->lock, flags);
236 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg);
238 static int __rtl8366_smi_write_reg(struct rtl8366_smi *smi,
239 u32 addr, u32 data, bool ack)
244 spin_lock_irqsave(&smi->lock, flags);
246 rtl8366_smi_start(smi);
248 /* send WRITE command */
249 ret = rtl8366_smi_write_byte(smi, smi->cmd_write);
254 ret = rtl8366_smi_write_byte(smi, addr & 0xff);
259 ret = rtl8366_smi_write_byte(smi, addr >> 8);
263 /* write DATA[7:0] */
264 ret = rtl8366_smi_write_byte(smi, data & 0xff);
268 /* write DATA[15:8] */
270 ret = rtl8366_smi_write_byte(smi, data >> 8);
272 ret = rtl8366_smi_write_byte_noack(smi, data >> 8);
279 rtl8366_smi_stop(smi);
280 spin_unlock_irqrestore(&smi->lock, flags);
285 int rtl8366_smi_write_reg(struct rtl8366_smi *smi, u32 addr, u32 data)
287 return __rtl8366_smi_write_reg(smi, addr, data, true);
289 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg);
291 int rtl8366_smi_write_reg_noack(struct rtl8366_smi *smi, u32 addr, u32 data)
293 return __rtl8366_smi_write_reg(smi, addr, data, false);
295 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack);
297 int rtl8366_smi_rmwr(struct rtl8366_smi *smi, u32 addr, u32 mask, u32 data)
302 err = rtl8366_smi_read_reg(smi, addr, &t);
306 err = rtl8366_smi_write_reg(smi, addr, (t & ~mask) | data);
310 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr);
312 static int rtl8366_mc_is_used(struct rtl8366_smi *smi, int mc_index, int *used)
318 for (i = 0; i < smi->num_ports; i++) {
321 err = smi->ops->get_mc_index(smi, i, &index);
325 if (mc_index == index) {
334 static int rtl8366_set_vlan(struct rtl8366_smi *smi, int vid, u32 member,
337 struct rtl8366_vlan_4k vlan4k;
341 /* Update the 4K table */
342 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
346 vlan4k.member = member;
347 vlan4k.untag = untag;
349 err = smi->ops->set_vlan_4k(smi, &vlan4k);
353 /* Try to find an existing MC entry for this VID */
354 for (i = 0; i < smi->num_vlan_mc; i++) {
355 struct rtl8366_vlan_mc vlanmc;
357 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
361 if (vid == vlanmc.vid) {
362 /* update the MC entry */
363 vlanmc.member = member;
364 vlanmc.untag = untag;
367 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
375 static int rtl8366_get_pvid(struct rtl8366_smi *smi, int port, int *val)
377 struct rtl8366_vlan_mc vlanmc;
381 err = smi->ops->get_mc_index(smi, port, &index);
385 err = smi->ops->get_vlan_mc(smi, index, &vlanmc);
393 static int rtl8366_set_pvid(struct rtl8366_smi *smi, unsigned port,
396 struct rtl8366_vlan_mc vlanmc;
397 struct rtl8366_vlan_4k vlan4k;
401 /* Try to find an existing MC entry for this VID */
402 for (i = 0; i < smi->num_vlan_mc; i++) {
403 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
407 if (vid == vlanmc.vid) {
408 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
412 err = smi->ops->set_mc_index(smi, port, i);
417 /* We have no MC entry for this VID, try to find an empty one */
418 for (i = 0; i < smi->num_vlan_mc; i++) {
419 err = smi->ops->get_vlan_mc(smi, i, &vlanmc);
423 if (vlanmc.vid == 0 && vlanmc.member == 0) {
424 /* Update the entry from the 4K table */
425 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
430 vlanmc.member = vlan4k.member;
431 vlanmc.untag = vlan4k.untag;
432 vlanmc.fid = vlan4k.fid;
433 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
437 err = smi->ops->set_mc_index(smi, port, i);
442 /* MC table is full, try to find an unused entry and replace it */
443 for (i = 0; i < smi->num_vlan_mc; i++) {
446 err = rtl8366_mc_is_used(smi, i, &used);
451 /* Update the entry from the 4K table */
452 err = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
457 vlanmc.member = vlan4k.member;
458 vlanmc.untag = vlan4k.untag;
459 vlanmc.fid = vlan4k.fid;
460 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
464 err = smi->ops->set_mc_index(smi, port, i);
470 "all VLAN member configurations are in use\n");
475 int rtl8366_enable_vlan(struct rtl8366_smi *smi, int enable)
479 err = smi->ops->enable_vlan(smi, enable);
483 smi->vlan_enabled = enable;
486 smi->vlan4k_enabled = 0;
487 err = smi->ops->enable_vlan4k(smi, enable);
492 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
494 static int rtl8366_enable_vlan4k(struct rtl8366_smi *smi, int enable)
499 err = smi->ops->enable_vlan(smi, enable);
503 smi->vlan_enabled = enable;
506 err = smi->ops->enable_vlan4k(smi, enable);
510 smi->vlan4k_enabled = enable;
514 int rtl8366_enable_all_ports(struct rtl8366_smi *smi, int enable)
519 for (port = 0; port < smi->num_ports; port++) {
520 err = smi->ops->enable_port(smi, port, enable);
527 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports);
529 int rtl8366_reset_vlan(struct rtl8366_smi *smi)
531 struct rtl8366_vlan_mc vlanmc;
535 rtl8366_enable_vlan(smi, 0);
536 rtl8366_enable_vlan4k(smi, 0);
538 /* clear VLAN member configurations */
544 for (i = 0; i < smi->num_vlan_mc; i++) {
545 err = smi->ops->set_vlan_mc(smi, i, &vlanmc);
552 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
554 static int rtl8366_init_vlan(struct rtl8366_smi *smi)
559 err = rtl8366_reset_vlan(smi);
563 for (port = 0; port < smi->num_ports; port++) {
566 if (port == smi->cpu_port)
567 mask = (1 << smi->num_ports) - 1;
569 mask = (1 << port) | (1 << smi->cpu_port);
571 err = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
575 err = rtl8366_set_pvid(smi, port, (port + 1));
580 return rtl8366_enable_vlan(smi, 1);
583 #ifdef CONFIG_RTL8366S_PHY_DEBUG_FS
584 int rtl8366_debugfs_open(struct inode *inode, struct file *file)
586 file->private_data = inode->i_private;
589 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open);
591 static ssize_t rtl8366_read_debugfs_vlan_mc(struct file *file,
592 char __user *user_buf,
593 size_t count, loff_t *ppos)
595 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
597 char *buf = smi->buf;
599 len += snprintf(buf + len, sizeof(smi->buf) - len,
600 "%2s %6s %4s %6s %6s %3s\n",
601 "id", "vid","prio", "member", "untag", "fid");
603 for (i = 0; i < smi->num_vlan_mc; ++i) {
604 struct rtl8366_vlan_mc vlanmc;
606 smi->ops->get_vlan_mc(smi, i, &vlanmc);
608 len += snprintf(buf + len, sizeof(smi->buf) - len,
609 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
610 i, vlanmc.vid, vlanmc.priority,
611 vlanmc.member, vlanmc.untag, vlanmc.fid);
614 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
617 #define RTL8366_VLAN4K_PAGE_SIZE 64
618 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
620 static ssize_t rtl8366_read_debugfs_vlan_4k(struct file *file,
621 char __user *user_buf,
622 size_t count, loff_t *ppos)
624 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
627 char *buf = smi->buf;
629 if (smi->dbg_vlan_4k_page >= RTL8366_VLAN4K_NUM_PAGES) {
630 len += snprintf(buf + len, sizeof(smi->buf) - len,
631 "invalid page: %u\n", smi->dbg_vlan_4k_page);
632 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
635 len += snprintf(buf + len, sizeof(smi->buf) - len,
637 "vid", "member", "untag", "fid");
639 offset = RTL8366_VLAN4K_PAGE_SIZE * smi->dbg_vlan_4k_page;
640 for (i = 0; i < RTL8366_VLAN4K_PAGE_SIZE; i++) {
641 struct rtl8366_vlan_4k vlan4k;
643 smi->ops->get_vlan_4k(smi, offset + i, &vlan4k);
645 len += snprintf(buf + len, sizeof(smi->buf) - len,
646 "%4d 0x%04x 0x%04x %3d\n",
647 vlan4k.vid, vlan4k.member,
648 vlan4k.untag, vlan4k.fid);
651 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
654 static ssize_t rtl8366_read_debugfs_pvid(struct file *file,
655 char __user *user_buf,
656 size_t count, loff_t *ppos)
658 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
659 char *buf = smi->buf;
663 len += snprintf(buf + len, sizeof(smi->buf) - len, "%4s %4s\n",
666 for (i = 0; i < smi->num_ports; i++) {
670 err = rtl8366_get_pvid(smi, i, &pvid);
672 len += snprintf(buf + len, sizeof(smi->buf) - len,
675 len += snprintf(buf + len, sizeof(smi->buf) - len,
676 "%4d %4d\n", i, pvid);
679 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
682 static ssize_t rtl8366_read_debugfs_reg(struct file *file,
683 char __user *user_buf,
684 size_t count, loff_t *ppos)
686 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
687 u32 t, reg = smi->dbg_reg;
689 char *buf = smi->buf;
691 memset(buf, '\0', sizeof(smi->buf));
693 err = rtl8366_smi_read_reg(smi, reg, &t);
695 len += snprintf(buf, sizeof(smi->buf),
696 "Read failed (reg: 0x%04x)\n", reg);
697 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
700 len += snprintf(buf, sizeof(smi->buf), "reg = 0x%04x, val = 0x%04x\n",
703 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
706 static ssize_t rtl8366_write_debugfs_reg(struct file *file,
707 const char __user *user_buf,
708 size_t count, loff_t *ppos)
710 struct rtl8366_smi *smi = (struct rtl8366_smi *)file->private_data;
712 u32 reg = smi->dbg_reg;
715 char *buf = smi->buf;
717 len = min(count, sizeof(smi->buf) - 1);
718 if (copy_from_user(buf, user_buf, len)) {
719 dev_err(smi->parent, "copy from user failed\n");
724 if (len > 0 && buf[len - 1] == '\n')
728 if (strict_strtoul(buf, 16, &data)) {
729 dev_err(smi->parent, "Invalid reg value %s\n", buf);
731 err = rtl8366_smi_write_reg(smi, reg, data);
734 "writing reg 0x%04x val 0x%04lx failed\n",
742 static ssize_t rtl8366_read_debugfs_mibs(struct file *file,
743 char __user *user_buf,
744 size_t count, loff_t *ppos)
746 struct rtl8366_smi *smi = file->private_data;
748 char *buf = smi->buf;
750 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s",
753 for (i = 0; i < smi->num_ports; i++) {
756 snprintf(port_buf, sizeof(port_buf), "Port %d", i);
757 len += snprintf(buf + len, sizeof(smi->buf) - len, " %12s",
760 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
762 for (i = 0; i < smi->num_mib_counters; i++) {
763 len += snprintf(buf + len, sizeof(smi->buf) - len, "%-36s ",
764 smi->mib_counters[i].name);
765 for (j = 0; j < smi->num_ports; j++) {
766 unsigned long long counter = 0;
768 if (!smi->ops->get_mib_counter(smi, i, j, &counter))
769 len += snprintf(buf + len,
770 sizeof(smi->buf) - len,
773 len += snprintf(buf + len,
774 sizeof(smi->buf) - len,
777 len += snprintf(buf + len, sizeof(smi->buf) - len, "\n");
780 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
783 static const struct file_operations fops_rtl8366_regs = {
784 .read = rtl8366_read_debugfs_reg,
785 .write = rtl8366_write_debugfs_reg,
786 .open = rtl8366_debugfs_open,
790 static const struct file_operations fops_rtl8366_vlan_mc = {
791 .read = rtl8366_read_debugfs_vlan_mc,
792 .open = rtl8366_debugfs_open,
796 static const struct file_operations fops_rtl8366_vlan_4k = {
797 .read = rtl8366_read_debugfs_vlan_4k,
798 .open = rtl8366_debugfs_open,
802 static const struct file_operations fops_rtl8366_pvid = {
803 .read = rtl8366_read_debugfs_pvid,
804 .open = rtl8366_debugfs_open,
808 static const struct file_operations fops_rtl8366_mibs = {
809 .read = rtl8366_read_debugfs_mibs,
810 .open = rtl8366_debugfs_open,
814 static void rtl8366_debugfs_init(struct rtl8366_smi *smi)
819 if (!smi->debugfs_root)
820 smi->debugfs_root = debugfs_create_dir(dev_name(smi->parent),
823 if (!smi->debugfs_root) {
824 dev_err(smi->parent, "Unable to create debugfs dir\n");
827 root = smi->debugfs_root;
829 node = debugfs_create_x16("reg", S_IRUGO | S_IWUSR, root,
832 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
837 node = debugfs_create_file("val", S_IRUGO | S_IWUSR, root, smi,
840 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
845 node = debugfs_create_file("vlan_mc", S_IRUSR, root, smi,
846 &fops_rtl8366_vlan_mc);
848 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
853 node = debugfs_create_u8("vlan_4k_page", S_IRUGO | S_IWUSR, root,
854 &smi->dbg_vlan_4k_page);
856 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
861 node = debugfs_create_file("vlan_4k", S_IRUSR, root, smi,
862 &fops_rtl8366_vlan_4k);
864 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
869 node = debugfs_create_file("pvid", S_IRUSR, root, smi,
872 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
877 node = debugfs_create_file("mibs", S_IRUSR, smi->debugfs_root, smi,
880 dev_err(smi->parent, "Creating debugfs file '%s' failed\n",
884 static void rtl8366_debugfs_remove(struct rtl8366_smi *smi)
886 if (smi->debugfs_root) {
887 debugfs_remove_recursive(smi->debugfs_root);
888 smi->debugfs_root = NULL;
892 static inline void rtl8366_debugfs_init(struct rtl8366_smi *smi) {}
893 static inline void rtl8366_debugfs_remove(struct rtl8366_smi *smi) {}
894 #endif /* CONFIG_RTL8366S_PHY_DEBUG_FS */
896 static int rtl8366_smi_mii_init(struct rtl8366_smi *smi)
901 smi->mii_bus = mdiobus_alloc();
902 if (smi->mii_bus == NULL) {
907 smi->mii_bus->priv = (void *) smi;
908 smi->mii_bus->name = dev_name(smi->parent);
909 smi->mii_bus->read = smi->ops->mii_read;
910 smi->mii_bus->write = smi->ops->mii_write;
911 snprintf(smi->mii_bus->id, MII_BUS_ID_SIZE, "%s",
912 dev_name(smi->parent));
913 smi->mii_bus->parent = smi->parent;
914 smi->mii_bus->phy_mask = ~(0x1f);
915 smi->mii_bus->irq = smi->mii_irq;
916 for (i = 0; i < PHY_MAX_ADDR; i++)
917 smi->mii_irq[i] = PHY_POLL;
919 ret = mdiobus_register(smi->mii_bus);
926 mdiobus_free(smi->mii_bus);
931 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi *smi)
933 mdiobus_unregister(smi->mii_bus);
934 mdiobus_free(smi->mii_bus);
937 int rtl8366_sw_get_port_pvid(struct switch_dev *dev, int port, int *val)
939 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
940 return rtl8366_get_pvid(smi, port, val);
942 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid);
944 int rtl8366_sw_set_port_pvid(struct switch_dev *dev, int port, int val)
946 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
947 return rtl8366_set_pvid(smi, port, val);
949 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid);
951 int rtl8366_sw_get_port_mib(struct switch_dev *dev,
952 const struct switch_attr *attr,
953 struct switch_val *val)
955 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
957 unsigned long long counter = 0;
958 char *buf = smi->buf;
960 if (val->port_vlan >= smi->num_ports)
963 len += snprintf(buf + len, sizeof(smi->buf) - len,
964 "Port %d MIB counters\n",
967 for (i = 0; i < smi->num_mib_counters; ++i) {
968 len += snprintf(buf + len, sizeof(smi->buf) - len,
969 "%-36s: ", smi->mib_counters[i].name);
970 if (!smi->ops->get_mib_counter(smi, i, val->port_vlan,
972 len += snprintf(buf + len, sizeof(smi->buf) - len,
975 len += snprintf(buf + len, sizeof(smi->buf) - len,
983 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib);
985 int rtl8366_sw_get_vlan_info(struct switch_dev *dev,
986 const struct switch_attr *attr,
987 struct switch_val *val)
991 struct rtl8366_vlan_4k vlan4k;
992 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
993 char *buf = smi->buf;
996 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
999 memset(buf, '\0', sizeof(smi->buf));
1001 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1005 len += snprintf(buf + len, sizeof(smi->buf) - len,
1006 "VLAN %d: Ports: '", vlan4k.vid);
1008 for (i = 0; i < smi->num_ports; i++) {
1009 if (!(vlan4k.member & (1 << i)))
1012 len += snprintf(buf + len, sizeof(smi->buf) - len, "%d%s", i,
1013 (vlan4k.untag & (1 << i)) ? "" : "t");
1016 len += snprintf(buf + len, sizeof(smi->buf) - len,
1017 "', members=%04x, untag=%04x, fid=%u",
1018 vlan4k.member, vlan4k.untag, vlan4k.fid);
1025 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info);
1027 int rtl8366_sw_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1029 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1030 struct switch_port *port;
1031 struct rtl8366_vlan_4k vlan4k;
1034 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1037 smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1039 port = &val->value.ports[0];
1041 for (i = 0; i < smi->num_ports; i++) {
1042 if (!(vlan4k.member & BIT(i)))
1046 port->flags = (vlan4k.untag & BIT(i)) ?
1047 0 : BIT(SWITCH_PORT_FLAG_TAGGED);
1053 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports);
1055 int rtl8366_sw_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
1057 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1058 struct switch_port *port;
1064 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1067 port = &val->value.ports[0];
1068 for (i = 0; i < val->len; i++, port++) {
1069 member |= BIT(port->id);
1071 if (!(port->flags & BIT(SWITCH_PORT_FLAG_TAGGED)))
1072 untag |= BIT(port->id);
1075 * To ensure that we have a valid MC entry for this VLAN,
1076 * initialize the port VLAN ID here.
1078 err = rtl8366_set_pvid(smi, port->id, val->port_vlan);
1083 return rtl8366_set_vlan(smi, val->port_vlan, member, untag, 0);
1085 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports);
1087 int rtl8366_sw_get_vlan_fid(struct switch_dev *dev,
1088 const struct switch_attr *attr,
1089 struct switch_val *val)
1091 struct rtl8366_vlan_4k vlan4k;
1092 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1095 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1098 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1102 val->value.i = vlan4k.fid;
1106 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid);
1108 int rtl8366_sw_set_vlan_fid(struct switch_dev *dev,
1109 const struct switch_attr *attr,
1110 struct switch_val *val)
1112 struct rtl8366_vlan_4k vlan4k;
1113 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1116 if (!smi->ops->is_vlan_valid(smi, val->port_vlan))
1119 if (val->value.i < 0 || val->value.i > attr->max)
1122 err = smi->ops->get_vlan_4k(smi, val->port_vlan, &vlan4k);
1126 return rtl8366_set_vlan(smi, val->port_vlan,
1131 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid);
1133 int rtl8366_sw_get_vlan_enable(struct switch_dev *dev,
1134 const struct switch_attr *attr,
1135 struct switch_val *val)
1137 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1143 val->value.i = smi->vlan_enabled;
1145 val->value.i = smi->vlan4k_enabled;
1149 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable);
1151 int rtl8366_sw_set_vlan_enable(struct switch_dev *dev,
1152 const struct switch_attr *attr,
1153 struct switch_val *val)
1155 struct rtl8366_smi *smi = sw_to_rtl8366_smi(dev);
1162 err = rtl8366_enable_vlan(smi, val->value.i);
1164 err = rtl8366_enable_vlan4k(smi, val->value.i);
1168 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable);
1170 struct rtl8366_smi *rtl8366_smi_alloc(struct device *parent)
1172 struct rtl8366_smi *smi;
1176 smi = kzalloc(sizeof(*smi), GFP_KERNEL);
1178 dev_err(parent, "no memory for private data\n");
1182 smi->parent = parent;
1185 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc);
1187 static int __rtl8366_smi_init(struct rtl8366_smi *smi, const char *name)
1191 err = gpio_request(smi->gpio_sda, name);
1193 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1194 smi->gpio_sda, err);
1198 err = gpio_request(smi->gpio_sck, name);
1200 printk(KERN_ERR "rtl8366_smi: gpio_request failed for %u, err=%d\n",
1201 smi->gpio_sck, err);
1205 spin_lock_init(&smi->lock);
1209 gpio_free(smi->gpio_sda);
1214 static void __rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1216 gpio_free(smi->gpio_sck);
1217 gpio_free(smi->gpio_sda);
1220 enum rtl8366_type rtl8366_smi_detect(struct rtl8366_platform_data *pdata)
1222 static struct rtl8366_smi smi;
1223 enum rtl8366_type type = RTL8366_TYPE_UNKNOWN;
1226 memset(&smi, 0, sizeof(smi));
1227 smi.gpio_sda = pdata->gpio_sda;
1228 smi.gpio_sck = pdata->gpio_sck;
1230 smi.cmd_read = 0xa9;
1231 smi.cmd_write = 0xa8;
1233 if (__rtl8366_smi_init(&smi, "rtl8366"))
1236 if (rtl8366_smi_read_reg(&smi, 0x5c, ®))
1241 printk("Found an RTL8366S switch\n");
1242 type = RTL8366_TYPE_S;
1245 printk("Found an RTL8366RB switch\n");
1246 type = RTL8366_TYPE_RB;
1249 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg);
1254 __rtl8366_smi_cleanup(&smi);
1259 int rtl8366_smi_init(struct rtl8366_smi *smi)
1266 err = __rtl8366_smi_init(smi, dev_name(smi->parent));
1270 spin_lock_init(&smi->lock);
1272 dev_info(smi->parent, "using GPIO pins %u (SDA) and %u (SCK)\n",
1273 smi->gpio_sda, smi->gpio_sck);
1275 err = smi->ops->detect(smi);
1277 dev_err(smi->parent, "chip detection failed, err=%d\n", err);
1281 err = smi->ops->setup(smi);
1283 dev_err(smi->parent, "chip setup failed, err=%d\n", err);
1287 err = rtl8366_init_vlan(smi);
1289 dev_err(smi->parent, "VLAN initialization failed, err=%d\n",
1294 err = rtl8366_enable_all_ports(smi, 1);
1298 err = rtl8366_smi_mii_init(smi);
1302 rtl8366_debugfs_init(smi);
1307 __rtl8366_smi_cleanup(smi);
1311 EXPORT_SYMBOL_GPL(rtl8366_smi_init);
1313 void rtl8366_smi_cleanup(struct rtl8366_smi *smi)
1315 rtl8366_debugfs_remove(smi);
1316 rtl8366_smi_mii_cleanup(smi);
1317 gpio_free(smi->gpio_sck);
1318 gpio_free(smi->gpio_sda);
1320 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup);
1322 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1323 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1324 MODULE_LICENSE("GPL v2");