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>
22 #include <linux/version.h>
23 #include <linux/of_mdio.h>
25 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
26 #include <linux/debugfs.h>
29 #include "rtl8366_smi.h"
31 #define RTL8366_SMI_ACK_RETRY_COUNT 5
33 #define RTL8366_SMI_HW_STOP_DELAY 25 /* msecs */
34 #define RTL8366_SMI_HW_START_DELAY 100 /* msecs */
36 static inline void rtl8366_smi_clk_delay(struct rtl8366_smi
*smi
)
38 ndelay(smi
->clk_delay
);
41 static void rtl8366_smi_start(struct rtl8366_smi
*smi
)
43 unsigned int sda
= smi
->gpio_sda
;
44 unsigned int sck
= smi
->gpio_sck
;
47 * Set GPIO pins to output mode, with initial state:
50 gpio_direction_output(sck
, 0);
51 gpio_direction_output(sda
, 1);
52 rtl8366_smi_clk_delay(smi
);
54 /* CLK 1: 0 -> 1, 1 -> 0 */
55 gpio_set_value(sck
, 1);
56 rtl8366_smi_clk_delay(smi
);
57 gpio_set_value(sck
, 0);
58 rtl8366_smi_clk_delay(smi
);
61 gpio_set_value(sck
, 1);
62 rtl8366_smi_clk_delay(smi
);
63 gpio_set_value(sda
, 0);
64 rtl8366_smi_clk_delay(smi
);
65 gpio_set_value(sck
, 0);
66 rtl8366_smi_clk_delay(smi
);
67 gpio_set_value(sda
, 1);
70 static void rtl8366_smi_stop(struct rtl8366_smi
*smi
)
72 unsigned int sda
= smi
->gpio_sda
;
73 unsigned int sck
= smi
->gpio_sck
;
75 rtl8366_smi_clk_delay(smi
);
76 gpio_set_value(sda
, 0);
77 gpio_set_value(sck
, 1);
78 rtl8366_smi_clk_delay(smi
);
79 gpio_set_value(sda
, 1);
80 rtl8366_smi_clk_delay(smi
);
81 gpio_set_value(sck
, 1);
82 rtl8366_smi_clk_delay(smi
);
83 gpio_set_value(sck
, 0);
84 rtl8366_smi_clk_delay(smi
);
85 gpio_set_value(sck
, 1);
88 rtl8366_smi_clk_delay(smi
);
89 gpio_set_value(sck
, 0);
90 rtl8366_smi_clk_delay(smi
);
91 gpio_set_value(sck
, 1);
93 /* set GPIO pins to input mode */
94 gpio_direction_input(sda
);
95 gpio_direction_input(sck
);
98 static void rtl8366_smi_write_bits(struct rtl8366_smi
*smi
, u32 data
, u32 len
)
100 unsigned int sda
= smi
->gpio_sda
;
101 unsigned int sck
= smi
->gpio_sck
;
103 for (; len
> 0; len
--) {
104 rtl8366_smi_clk_delay(smi
);
107 gpio_set_value(sda
, !!(data
& ( 1 << (len
- 1))));
108 rtl8366_smi_clk_delay(smi
);
111 gpio_set_value(sck
, 1);
112 rtl8366_smi_clk_delay(smi
);
113 gpio_set_value(sck
, 0);
117 static void rtl8366_smi_read_bits(struct rtl8366_smi
*smi
, u32 len
, u32
*data
)
119 unsigned int sda
= smi
->gpio_sda
;
120 unsigned int sck
= smi
->gpio_sck
;
122 gpio_direction_input(sda
);
124 for (*data
= 0; len
> 0; len
--) {
127 rtl8366_smi_clk_delay(smi
);
130 gpio_set_value(sck
, 1);
131 rtl8366_smi_clk_delay(smi
);
132 u
= !!gpio_get_value(sda
);
133 gpio_set_value(sck
, 0);
135 *data
|= (u
<< (len
- 1));
138 gpio_direction_output(sda
, 0);
141 static int rtl8366_smi_wait_for_ack(struct rtl8366_smi
*smi
)
149 rtl8366_smi_read_bits(smi
, 1, &ack
);
153 if (++retry_cnt
> RTL8366_SMI_ACK_RETRY_COUNT
) {
154 dev_err(smi
->parent
, "ACK timeout\n");
162 static int rtl8366_smi_write_byte(struct rtl8366_smi
*smi
, u8 data
)
164 rtl8366_smi_write_bits(smi
, data
, 8);
165 return rtl8366_smi_wait_for_ack(smi
);
168 static int rtl8366_smi_write_byte_noack(struct rtl8366_smi
*smi
, u8 data
)
170 rtl8366_smi_write_bits(smi
, data
, 8);
174 static int rtl8366_smi_read_byte0(struct rtl8366_smi
*smi
, u8
*data
)
179 rtl8366_smi_read_bits(smi
, 8, &t
);
183 rtl8366_smi_write_bits(smi
, 0x00, 1);
188 static int rtl8366_smi_read_byte1(struct rtl8366_smi
*smi
, u8
*data
)
193 rtl8366_smi_read_bits(smi
, 8, &t
);
197 rtl8366_smi_write_bits(smi
, 0x01, 1);
202 static int __rtl8366_smi_read_reg(struct rtl8366_smi
*smi
, u32 addr
, u32
*data
)
209 spin_lock_irqsave(&smi
->lock
, flags
);
211 rtl8366_smi_start(smi
);
213 /* send READ command */
214 ret
= rtl8366_smi_write_byte(smi
, smi
->cmd_read
);
219 ret
= rtl8366_smi_write_byte(smi
, addr
& 0xff);
224 ret
= rtl8366_smi_write_byte(smi
, addr
>> 8);
229 rtl8366_smi_read_byte0(smi
, &lo
);
230 /* read DATA[15:8] */
231 rtl8366_smi_read_byte1(smi
, &hi
);
233 *data
= ((u32
) lo
) | (((u32
) hi
) << 8);
238 rtl8366_smi_stop(smi
);
239 spin_unlock_irqrestore(&smi
->lock
, flags
);
243 /* Read/write via mdiobus */
244 #define MDC_MDIO_CTRL0_REG 31
245 #define MDC_MDIO_START_REG 29
246 #define MDC_MDIO_CTRL1_REG 21
247 #define MDC_MDIO_ADDRESS_REG 23
248 #define MDC_MDIO_DATA_WRITE_REG 24
249 #define MDC_MDIO_DATA_READ_REG 25
251 #define MDC_MDIO_START_OP 0xFFFF
252 #define MDC_MDIO_ADDR_OP 0x000E
253 #define MDC_MDIO_READ_OP 0x0001
254 #define MDC_MDIO_WRITE_OP 0x0003
255 #define MDC_REALTEK_PHY_ADDR 0x0
257 int __rtl8366_mdio_read_reg(struct rtl8366_smi
*smi
, u32 addr
, u32
*data
)
259 u32 phy_id
= MDC_REALTEK_PHY_ADDR
;
260 struct mii_bus
*mbus
= smi
->ext_mbus
;
262 BUG_ON(in_interrupt());
264 mutex_lock(&mbus
->mdio_lock
);
265 /* Write Start command to register 29 */
266 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
268 /* Write address control code to register 31 */
269 mbus
->write(mbus
, phy_id
, MDC_MDIO_CTRL0_REG
, MDC_MDIO_ADDR_OP
);
271 /* Write Start command to register 29 */
272 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
274 /* Write address to register 23 */
275 mbus
->write(mbus
, phy_id
, MDC_MDIO_ADDRESS_REG
, addr
);
277 /* Write Start command to register 29 */
278 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
280 /* Write read control code to register 21 */
281 mbus
->write(mbus
, phy_id
, MDC_MDIO_CTRL1_REG
, MDC_MDIO_READ_OP
);
283 /* Write Start command to register 29 */
284 mbus
->write(smi
->ext_mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
286 /* Read data from register 25 */
287 *data
= mbus
->read(mbus
, phy_id
, MDC_MDIO_DATA_READ_REG
);
289 mutex_unlock(&mbus
->mdio_lock
);
294 static int __rtl8366_mdio_write_reg(struct rtl8366_smi
*smi
, u32 addr
, u32 data
)
296 u32 phy_id
= MDC_REALTEK_PHY_ADDR
;
297 struct mii_bus
*mbus
= smi
->ext_mbus
;
299 BUG_ON(in_interrupt());
301 mutex_lock(&mbus
->mdio_lock
);
303 /* Write Start command to register 29 */
304 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
306 /* Write address control code to register 31 */
307 mbus
->write(mbus
, phy_id
, MDC_MDIO_CTRL0_REG
, MDC_MDIO_ADDR_OP
);
309 /* Write Start command to register 29 */
310 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
312 /* Write address to register 23 */
313 mbus
->write(mbus
, phy_id
, MDC_MDIO_ADDRESS_REG
, addr
);
315 /* Write Start command to register 29 */
316 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
318 /* Write data to register 24 */
319 mbus
->write(mbus
, phy_id
, MDC_MDIO_DATA_WRITE_REG
, data
);
321 /* Write Start command to register 29 */
322 mbus
->write(mbus
, phy_id
, MDC_MDIO_START_REG
, MDC_MDIO_START_OP
);
324 /* Write data control code to register 21 */
325 mbus
->write(mbus
, phy_id
, MDC_MDIO_CTRL1_REG
, MDC_MDIO_WRITE_OP
);
327 mutex_unlock(&mbus
->mdio_lock
);
331 int rtl8366_smi_read_reg(struct rtl8366_smi
*smi
, u32 addr
, u32
*data
)
334 return __rtl8366_mdio_read_reg(smi
, addr
, data
);
336 return __rtl8366_smi_read_reg(smi
, addr
, data
);
338 EXPORT_SYMBOL_GPL(rtl8366_smi_read_reg
);
340 static int __rtl8366_smi_write_reg(struct rtl8366_smi
*smi
,
341 u32 addr
, u32 data
, bool ack
)
346 spin_lock_irqsave(&smi
->lock
, flags
);
348 rtl8366_smi_start(smi
);
350 /* send WRITE command */
351 ret
= rtl8366_smi_write_byte(smi
, smi
->cmd_write
);
356 ret
= rtl8366_smi_write_byte(smi
, addr
& 0xff);
361 ret
= rtl8366_smi_write_byte(smi
, addr
>> 8);
365 /* write DATA[7:0] */
366 ret
= rtl8366_smi_write_byte(smi
, data
& 0xff);
370 /* write DATA[15:8] */
372 ret
= rtl8366_smi_write_byte(smi
, data
>> 8);
374 ret
= rtl8366_smi_write_byte_noack(smi
, data
>> 8);
381 rtl8366_smi_stop(smi
);
382 spin_unlock_irqrestore(&smi
->lock
, flags
);
387 int rtl8366_smi_write_reg(struct rtl8366_smi
*smi
, u32 addr
, u32 data
)
390 return __rtl8366_mdio_write_reg(smi
, addr
, data
);
392 return __rtl8366_smi_write_reg(smi
, addr
, data
, true);
394 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg
);
396 int rtl8366_smi_write_reg_noack(struct rtl8366_smi
*smi
, u32 addr
, u32 data
)
398 return __rtl8366_smi_write_reg(smi
, addr
, data
, false);
400 EXPORT_SYMBOL_GPL(rtl8366_smi_write_reg_noack
);
402 int rtl8366_smi_rmwr(struct rtl8366_smi
*smi
, u32 addr
, u32 mask
, u32 data
)
407 err
= rtl8366_smi_read_reg(smi
, addr
, &t
);
411 err
= rtl8366_smi_write_reg(smi
, addr
, (t
& ~mask
) | data
);
415 EXPORT_SYMBOL_GPL(rtl8366_smi_rmwr
);
417 static int rtl8366_reset(struct rtl8366_smi
*smi
)
420 smi
->hw_reset(smi
, true);
421 msleep(RTL8366_SMI_HW_STOP_DELAY
);
422 smi
->hw_reset(smi
, false);
423 msleep(RTL8366_SMI_HW_START_DELAY
);
427 return smi
->ops
->reset_chip(smi
);
430 static int rtl8366_mc_is_used(struct rtl8366_smi
*smi
, int mc_index
, int *used
)
436 for (i
= 0; i
< smi
->num_ports
; i
++) {
439 err
= smi
->ops
->get_mc_index(smi
, i
, &index
);
443 if (mc_index
== index
) {
452 static int rtl8366_set_vlan(struct rtl8366_smi
*smi
, int vid
, u32 member
,
455 struct rtl8366_vlan_4k vlan4k
;
459 /* Update the 4K table */
460 err
= smi
->ops
->get_vlan_4k(smi
, vid
, &vlan4k
);
464 vlan4k
.member
= member
;
465 vlan4k
.untag
= untag
;
467 err
= smi
->ops
->set_vlan_4k(smi
, &vlan4k
);
471 /* Try to find an existing MC entry for this VID */
472 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
473 struct rtl8366_vlan_mc vlanmc
;
475 err
= smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
479 if (vid
== vlanmc
.vid
) {
480 /* update the MC entry */
481 vlanmc
.member
= member
;
482 vlanmc
.untag
= untag
;
485 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
493 static int rtl8366_get_pvid(struct rtl8366_smi
*smi
, int port
, int *val
)
495 struct rtl8366_vlan_mc vlanmc
;
499 err
= smi
->ops
->get_mc_index(smi
, port
, &index
);
503 err
= smi
->ops
->get_vlan_mc(smi
, index
, &vlanmc
);
511 static int rtl8366_set_pvid(struct rtl8366_smi
*smi
, unsigned port
,
514 struct rtl8366_vlan_mc vlanmc
;
515 struct rtl8366_vlan_4k vlan4k
;
519 /* Try to find an existing MC entry for this VID */
520 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
521 err
= smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
525 if (vid
== vlanmc
.vid
) {
526 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
530 err
= smi
->ops
->set_mc_index(smi
, port
, i
);
535 /* We have no MC entry for this VID, try to find an empty one */
536 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
537 err
= smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
541 if (vlanmc
.vid
== 0 && vlanmc
.member
== 0) {
542 /* Update the entry from the 4K table */
543 err
= smi
->ops
->get_vlan_4k(smi
, vid
, &vlan4k
);
548 vlanmc
.member
= vlan4k
.member
;
549 vlanmc
.untag
= vlan4k
.untag
;
550 vlanmc
.fid
= vlan4k
.fid
;
551 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
555 err
= smi
->ops
->set_mc_index(smi
, port
, i
);
560 /* MC table is full, try to find an unused entry and replace it */
561 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
564 err
= rtl8366_mc_is_used(smi
, i
, &used
);
569 /* Update the entry from the 4K table */
570 err
= smi
->ops
->get_vlan_4k(smi
, vid
, &vlan4k
);
575 vlanmc
.member
= vlan4k
.member
;
576 vlanmc
.untag
= vlan4k
.untag
;
577 vlanmc
.fid
= vlan4k
.fid
;
578 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
582 err
= smi
->ops
->set_mc_index(smi
, port
, i
);
588 "all VLAN member configurations are in use\n");
593 int rtl8366_enable_vlan(struct rtl8366_smi
*smi
, int enable
)
597 err
= smi
->ops
->enable_vlan(smi
, enable
);
601 smi
->vlan_enabled
= enable
;
604 smi
->vlan4k_enabled
= 0;
605 err
= smi
->ops
->enable_vlan4k(smi
, enable
);
610 EXPORT_SYMBOL_GPL(rtl8366_enable_vlan
);
612 static int rtl8366_enable_vlan4k(struct rtl8366_smi
*smi
, int enable
)
617 err
= smi
->ops
->enable_vlan(smi
, enable
);
621 smi
->vlan_enabled
= enable
;
624 err
= smi
->ops
->enable_vlan4k(smi
, enable
);
628 smi
->vlan4k_enabled
= enable
;
632 int rtl8366_enable_all_ports(struct rtl8366_smi
*smi
, int enable
)
637 for (port
= 0; port
< smi
->num_ports
; port
++) {
638 err
= smi
->ops
->enable_port(smi
, port
, enable
);
645 EXPORT_SYMBOL_GPL(rtl8366_enable_all_ports
);
647 int rtl8366_reset_vlan(struct rtl8366_smi
*smi
)
649 struct rtl8366_vlan_mc vlanmc
;
653 rtl8366_enable_vlan(smi
, 0);
654 rtl8366_enable_vlan4k(smi
, 0);
656 /* clear VLAN member configurations */
662 for (i
= 0; i
< smi
->num_vlan_mc
; i
++) {
663 err
= smi
->ops
->set_vlan_mc(smi
, i
, &vlanmc
);
670 EXPORT_SYMBOL_GPL(rtl8366_reset_vlan
);
672 static int rtl8366_init_vlan(struct rtl8366_smi
*smi
)
677 err
= rtl8366_reset_vlan(smi
);
681 for (port
= 0; port
< smi
->num_ports
; port
++) {
684 if (port
== smi
->cpu_port
)
685 mask
= (1 << smi
->num_ports
) - 1;
687 mask
= (1 << port
) | (1 << smi
->cpu_port
);
689 err
= rtl8366_set_vlan(smi
, (port
+ 1), mask
, mask
, 0);
693 err
= rtl8366_set_pvid(smi
, port
, (port
+ 1));
698 return rtl8366_enable_vlan(smi
, 1);
701 #ifdef CONFIG_RTL8366_SMI_DEBUG_FS
702 int rtl8366_debugfs_open(struct inode
*inode
, struct file
*file
)
704 file
->private_data
= inode
->i_private
;
707 EXPORT_SYMBOL_GPL(rtl8366_debugfs_open
);
709 static ssize_t
rtl8366_read_debugfs_vlan_mc(struct file
*file
,
710 char __user
*user_buf
,
711 size_t count
, loff_t
*ppos
)
713 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
715 char *buf
= smi
->buf
;
717 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
718 "%2s %6s %4s %6s %6s %3s\n",
719 "id", "vid","prio", "member", "untag", "fid");
721 for (i
= 0; i
< smi
->num_vlan_mc
; ++i
) {
722 struct rtl8366_vlan_mc vlanmc
;
724 smi
->ops
->get_vlan_mc(smi
, i
, &vlanmc
);
726 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
727 "%2d %6d %4d 0x%04x 0x%04x %3d\n",
728 i
, vlanmc
.vid
, vlanmc
.priority
,
729 vlanmc
.member
, vlanmc
.untag
, vlanmc
.fid
);
732 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
735 #define RTL8366_VLAN4K_PAGE_SIZE 64
736 #define RTL8366_VLAN4K_NUM_PAGES (4096 / RTL8366_VLAN4K_PAGE_SIZE)
738 static ssize_t
rtl8366_read_debugfs_vlan_4k(struct file
*file
,
739 char __user
*user_buf
,
740 size_t count
, loff_t
*ppos
)
742 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
745 char *buf
= smi
->buf
;
747 if (smi
->dbg_vlan_4k_page
>= RTL8366_VLAN4K_NUM_PAGES
) {
748 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
749 "invalid page: %u\n", smi
->dbg_vlan_4k_page
);
750 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
753 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
755 "vid", "member", "untag", "fid");
757 offset
= RTL8366_VLAN4K_PAGE_SIZE
* smi
->dbg_vlan_4k_page
;
758 for (i
= 0; i
< RTL8366_VLAN4K_PAGE_SIZE
; i
++) {
759 struct rtl8366_vlan_4k vlan4k
;
761 smi
->ops
->get_vlan_4k(smi
, offset
+ i
, &vlan4k
);
763 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
764 "%4d 0x%04x 0x%04x %3d\n",
765 vlan4k
.vid
, vlan4k
.member
,
766 vlan4k
.untag
, vlan4k
.fid
);
769 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
772 static ssize_t
rtl8366_read_debugfs_pvid(struct file
*file
,
773 char __user
*user_buf
,
774 size_t count
, loff_t
*ppos
)
776 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
777 char *buf
= smi
->buf
;
781 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%4s %4s\n",
784 for (i
= 0; i
< smi
->num_ports
; i
++) {
788 err
= rtl8366_get_pvid(smi
, i
, &pvid
);
790 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
793 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
794 "%4d %4d\n", i
, pvid
);
797 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
800 static ssize_t
rtl8366_read_debugfs_reg(struct file
*file
,
801 char __user
*user_buf
,
802 size_t count
, loff_t
*ppos
)
804 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
805 u32 t
, reg
= smi
->dbg_reg
;
807 char *buf
= smi
->buf
;
809 memset(buf
, '\0', sizeof(smi
->buf
));
811 err
= rtl8366_smi_read_reg(smi
, reg
, &t
);
813 len
+= snprintf(buf
, sizeof(smi
->buf
),
814 "Read failed (reg: 0x%04x)\n", reg
);
815 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
818 len
+= snprintf(buf
, sizeof(smi
->buf
), "reg = 0x%04x, val = 0x%04x\n",
821 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
824 static ssize_t
rtl8366_write_debugfs_reg(struct file
*file
,
825 const char __user
*user_buf
,
826 size_t count
, loff_t
*ppos
)
828 struct rtl8366_smi
*smi
= (struct rtl8366_smi
*)file
->private_data
;
830 u32 reg
= smi
->dbg_reg
;
833 char *buf
= smi
->buf
;
835 len
= min(count
, sizeof(smi
->buf
) - 1);
836 if (copy_from_user(buf
, user_buf
, len
)) {
837 dev_err(smi
->parent
, "copy from user failed\n");
842 if (len
> 0 && buf
[len
- 1] == '\n')
846 if (kstrtoul(buf
, 16, &data
)) {
847 dev_err(smi
->parent
, "Invalid reg value %s\n", buf
);
849 err
= rtl8366_smi_write_reg(smi
, reg
, data
);
852 "writing reg 0x%04x val 0x%04lx failed\n",
860 static ssize_t
rtl8366_read_debugfs_mibs(struct file
*file
,
861 char __user
*user_buf
,
862 size_t count
, loff_t
*ppos
)
864 struct rtl8366_smi
*smi
= file
->private_data
;
866 char *buf
= smi
->buf
;
868 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%-36s",
871 for (i
= 0; i
< smi
->num_ports
; i
++) {
874 snprintf(port_buf
, sizeof(port_buf
), "Port %d", i
);
875 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, " %12s",
878 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "\n");
880 for (i
= 0; i
< smi
->num_mib_counters
; i
++) {
881 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%-36s ",
882 smi
->mib_counters
[i
].name
);
883 for (j
= 0; j
< smi
->num_ports
; j
++) {
884 unsigned long long counter
= 0;
886 if (!smi
->ops
->get_mib_counter(smi
, i
, j
, &counter
))
887 len
+= snprintf(buf
+ len
,
888 sizeof(smi
->buf
) - len
,
891 len
+= snprintf(buf
+ len
,
892 sizeof(smi
->buf
) - len
,
895 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "\n");
898 return simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
901 static const struct file_operations fops_rtl8366_regs
= {
902 .read
= rtl8366_read_debugfs_reg
,
903 .write
= rtl8366_write_debugfs_reg
,
904 .open
= rtl8366_debugfs_open
,
908 static const struct file_operations fops_rtl8366_vlan_mc
= {
909 .read
= rtl8366_read_debugfs_vlan_mc
,
910 .open
= rtl8366_debugfs_open
,
914 static const struct file_operations fops_rtl8366_vlan_4k
= {
915 .read
= rtl8366_read_debugfs_vlan_4k
,
916 .open
= rtl8366_debugfs_open
,
920 static const struct file_operations fops_rtl8366_pvid
= {
921 .read
= rtl8366_read_debugfs_pvid
,
922 .open
= rtl8366_debugfs_open
,
926 static const struct file_operations fops_rtl8366_mibs
= {
927 .read
= rtl8366_read_debugfs_mibs
,
928 .open
= rtl8366_debugfs_open
,
932 static void rtl8366_debugfs_init(struct rtl8366_smi
*smi
)
937 if (!smi
->debugfs_root
)
938 smi
->debugfs_root
= debugfs_create_dir(dev_name(smi
->parent
),
941 if (!smi
->debugfs_root
) {
942 dev_err(smi
->parent
, "Unable to create debugfs dir\n");
945 root
= smi
->debugfs_root
;
947 node
= debugfs_create_x16("reg", S_IRUGO
| S_IWUSR
, root
,
950 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
955 node
= debugfs_create_file("val", S_IRUGO
| S_IWUSR
, root
, smi
,
958 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
963 node
= debugfs_create_file("vlan_mc", S_IRUSR
, root
, smi
,
964 &fops_rtl8366_vlan_mc
);
966 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
971 node
= debugfs_create_u8("vlan_4k_page", S_IRUGO
| S_IWUSR
, root
,
972 &smi
->dbg_vlan_4k_page
);
974 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
979 node
= debugfs_create_file("vlan_4k", S_IRUSR
, root
, smi
,
980 &fops_rtl8366_vlan_4k
);
982 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
987 node
= debugfs_create_file("pvid", S_IRUSR
, root
, smi
,
990 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
995 node
= debugfs_create_file("mibs", S_IRUSR
, smi
->debugfs_root
, smi
,
998 dev_err(smi
->parent
, "Creating debugfs file '%s' failed\n",
1002 static void rtl8366_debugfs_remove(struct rtl8366_smi
*smi
)
1004 if (smi
->debugfs_root
) {
1005 debugfs_remove_recursive(smi
->debugfs_root
);
1006 smi
->debugfs_root
= NULL
;
1010 static inline void rtl8366_debugfs_init(struct rtl8366_smi
*smi
) {}
1011 static inline void rtl8366_debugfs_remove(struct rtl8366_smi
*smi
) {}
1012 #endif /* CONFIG_RTL8366_SMI_DEBUG_FS */
1014 static int rtl8366_smi_mii_init(struct rtl8366_smi
*smi
)
1019 struct device_node
*np
= NULL
;
1021 np
= of_get_child_by_name(smi
->parent
->of_node
, "mdio-bus");
1024 smi
->mii_bus
= mdiobus_alloc();
1025 if (smi
->mii_bus
== NULL
) {
1030 smi
->mii_bus
->priv
= (void *) smi
;
1031 smi
->mii_bus
->name
= dev_name(smi
->parent
);
1032 smi
->mii_bus
->read
= smi
->ops
->mii_read
;
1033 smi
->mii_bus
->write
= smi
->ops
->mii_write
;
1034 snprintf(smi
->mii_bus
->id
, MII_BUS_ID_SIZE
, "%s",
1035 dev_name(smi
->parent
));
1036 smi
->mii_bus
->parent
= smi
->parent
;
1037 smi
->mii_bus
->phy_mask
= ~(0x1f);
1038 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,5,0)
1041 smi
->mii_bus
->irq
= smi
->mii_irq
;
1042 for (i
= 0; i
< PHY_MAX_ADDR
; i
++)
1043 smi
->mii_irq
[i
] = PHY_POLL
;
1049 ret
= of_mdiobus_register(smi
->mii_bus
, np
);
1052 ret
= mdiobus_register(smi
->mii_bus
);
1060 mdiobus_free(smi
->mii_bus
);
1065 static void rtl8366_smi_mii_cleanup(struct rtl8366_smi
*smi
)
1067 mdiobus_unregister(smi
->mii_bus
);
1068 mdiobus_free(smi
->mii_bus
);
1071 int rtl8366_sw_reset_switch(struct switch_dev
*dev
)
1073 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1076 err
= rtl8366_reset(smi
);
1080 err
= smi
->ops
->setup(smi
);
1084 err
= rtl8366_reset_vlan(smi
);
1088 err
= rtl8366_enable_vlan(smi
, 1);
1092 return rtl8366_enable_all_ports(smi
, 1);
1094 EXPORT_SYMBOL_GPL(rtl8366_sw_reset_switch
);
1096 int rtl8366_sw_get_port_pvid(struct switch_dev
*dev
, int port
, int *val
)
1098 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1099 return rtl8366_get_pvid(smi
, port
, val
);
1101 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_pvid
);
1103 int rtl8366_sw_set_port_pvid(struct switch_dev
*dev
, int port
, int val
)
1105 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1106 return rtl8366_set_pvid(smi
, port
, val
);
1108 EXPORT_SYMBOL_GPL(rtl8366_sw_set_port_pvid
);
1110 int rtl8366_sw_get_port_mib(struct switch_dev
*dev
,
1111 const struct switch_attr
*attr
,
1112 struct switch_val
*val
)
1114 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1116 unsigned long long counter
= 0;
1117 char *buf
= smi
->buf
;
1119 if (val
->port_vlan
>= smi
->num_ports
)
1122 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1123 "Port %d MIB counters\n",
1126 for (i
= 0; i
< smi
->num_mib_counters
; ++i
) {
1127 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1128 "%-36s: ", smi
->mib_counters
[i
].name
);
1129 if (!smi
->ops
->get_mib_counter(smi
, i
, val
->port_vlan
,
1131 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1134 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1142 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_mib
);
1144 int rtl8366_sw_get_port_stats(struct switch_dev
*dev
, int port
,
1145 struct switch_port_stats
*stats
,
1146 int txb_id
, int rxb_id
)
1148 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1149 unsigned long long counter
= 0;
1152 if (port
>= smi
->num_ports
)
1155 ret
= smi
->ops
->get_mib_counter(smi
, txb_id
, port
, &counter
);
1159 stats
->tx_bytes
= counter
;
1161 ret
= smi
->ops
->get_mib_counter(smi
, rxb_id
, port
, &counter
);
1165 stats
->rx_bytes
= counter
;
1169 EXPORT_SYMBOL_GPL(rtl8366_sw_get_port_stats
);
1171 int rtl8366_sw_get_vlan_info(struct switch_dev
*dev
,
1172 const struct switch_attr
*attr
,
1173 struct switch_val
*val
)
1177 struct rtl8366_vlan_4k vlan4k
;
1178 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1179 char *buf
= smi
->buf
;
1182 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1185 memset(buf
, '\0', sizeof(smi
->buf
));
1187 err
= smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1191 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1192 "VLAN %d: Ports: '", vlan4k
.vid
);
1194 for (i
= 0; i
< smi
->num_ports
; i
++) {
1195 if (!(vlan4k
.member
& (1 << i
)))
1198 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
, "%d%s", i
,
1199 (vlan4k
.untag
& (1 << i
)) ? "" : "t");
1202 len
+= snprintf(buf
+ len
, sizeof(smi
->buf
) - len
,
1203 "', members=%04x, untag=%04x, fid=%u",
1204 vlan4k
.member
, vlan4k
.untag
, vlan4k
.fid
);
1211 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_info
);
1213 int rtl8366_sw_get_vlan_ports(struct switch_dev
*dev
, struct switch_val
*val
)
1215 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1216 struct switch_port
*port
;
1217 struct rtl8366_vlan_4k vlan4k
;
1220 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1223 smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1225 port
= &val
->value
.ports
[0];
1227 for (i
= 0; i
< smi
->num_ports
; i
++) {
1228 if (!(vlan4k
.member
& BIT(i
)))
1232 port
->flags
= (vlan4k
.untag
& BIT(i
)) ?
1233 0 : BIT(SWITCH_PORT_FLAG_TAGGED
);
1239 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_ports
);
1241 int rtl8366_sw_set_vlan_ports(struct switch_dev
*dev
, struct switch_val
*val
)
1243 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1244 struct switch_port
*port
;
1250 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1253 port
= &val
->value
.ports
[0];
1254 for (i
= 0; i
< val
->len
; i
++, port
++) {
1256 member
|= BIT(port
->id
);
1258 if (!(port
->flags
& BIT(SWITCH_PORT_FLAG_TAGGED
)))
1259 untag
|= BIT(port
->id
);
1262 * To ensure that we have a valid MC entry for this VLAN,
1263 * initialize the port VLAN ID here.
1265 err
= rtl8366_get_pvid(smi
, port
->id
, &pvid
);
1269 err
= rtl8366_set_pvid(smi
, port
->id
, val
->port_vlan
);
1275 return rtl8366_set_vlan(smi
, val
->port_vlan
, member
, untag
, 0);
1277 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_ports
);
1279 int rtl8366_sw_get_vlan_fid(struct switch_dev
*dev
,
1280 const struct switch_attr
*attr
,
1281 struct switch_val
*val
)
1283 struct rtl8366_vlan_4k vlan4k
;
1284 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1287 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1290 err
= smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1294 val
->value
.i
= vlan4k
.fid
;
1298 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_fid
);
1300 int rtl8366_sw_set_vlan_fid(struct switch_dev
*dev
,
1301 const struct switch_attr
*attr
,
1302 struct switch_val
*val
)
1304 struct rtl8366_vlan_4k vlan4k
;
1305 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1308 if (!smi
->ops
->is_vlan_valid(smi
, val
->port_vlan
))
1311 if (val
->value
.i
< 0 || val
->value
.i
> attr
->max
)
1314 err
= smi
->ops
->get_vlan_4k(smi
, val
->port_vlan
, &vlan4k
);
1318 return rtl8366_set_vlan(smi
, val
->port_vlan
,
1323 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_fid
);
1325 int rtl8366_sw_get_vlan_enable(struct switch_dev
*dev
,
1326 const struct switch_attr
*attr
,
1327 struct switch_val
*val
)
1329 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1335 val
->value
.i
= smi
->vlan_enabled
;
1337 val
->value
.i
= smi
->vlan4k_enabled
;
1341 EXPORT_SYMBOL_GPL(rtl8366_sw_get_vlan_enable
);
1343 int rtl8366_sw_set_vlan_enable(struct switch_dev
*dev
,
1344 const struct switch_attr
*attr
,
1345 struct switch_val
*val
)
1347 struct rtl8366_smi
*smi
= sw_to_rtl8366_smi(dev
);
1354 err
= rtl8366_enable_vlan(smi
, val
->value
.i
);
1356 err
= rtl8366_enable_vlan4k(smi
, val
->value
.i
);
1360 EXPORT_SYMBOL_GPL(rtl8366_sw_set_vlan_enable
);
1362 struct rtl8366_smi
*rtl8366_smi_alloc(struct device
*parent
)
1364 struct rtl8366_smi
*smi
;
1368 smi
= kzalloc(sizeof(*smi
), GFP_KERNEL
);
1370 dev_err(parent
, "no memory for private data\n");
1374 smi
->parent
= parent
;
1377 EXPORT_SYMBOL_GPL(rtl8366_smi_alloc
);
1379 static int __rtl8366_smi_init(struct rtl8366_smi
*smi
, const char *name
)
1383 if (!smi
->ext_mbus
) {
1384 err
= gpio_request(smi
->gpio_sda
, name
);
1386 printk(KERN_ERR
"rtl8366_smi: gpio_request failed for %u, err=%d\n",
1387 smi
->gpio_sda
, err
);
1391 err
= gpio_request(smi
->gpio_sck
, name
);
1393 printk(KERN_ERR
"rtl8366_smi: gpio_request failed for %u, err=%d\n",
1394 smi
->gpio_sck
, err
);
1399 spin_lock_init(&smi
->lock
);
1401 /* start the switch */
1402 if (smi
->hw_reset
) {
1403 smi
->hw_reset(smi
, false);
1404 msleep(RTL8366_SMI_HW_START_DELAY
);
1410 gpio_free(smi
->gpio_sda
);
1415 static void __rtl8366_smi_cleanup(struct rtl8366_smi
*smi
)
1418 smi
->hw_reset(smi
, true);
1420 if (!smi
->ext_mbus
) {
1421 gpio_free(smi
->gpio_sck
);
1422 gpio_free(smi
->gpio_sda
);
1426 enum rtl8366_type
rtl8366_smi_detect(struct rtl8366_platform_data
*pdata
)
1428 static struct rtl8366_smi smi
;
1429 enum rtl8366_type type
= RTL8366_TYPE_UNKNOWN
;
1432 memset(&smi
, 0, sizeof(smi
));
1433 smi
.gpio_sda
= pdata
->gpio_sda
;
1434 smi
.gpio_sck
= pdata
->gpio_sck
;
1436 smi
.cmd_read
= 0xa9;
1437 smi
.cmd_write
= 0xa8;
1439 if (__rtl8366_smi_init(&smi
, "rtl8366"))
1442 if (rtl8366_smi_read_reg(&smi
, 0x5c, ®
))
1447 printk("Found an RTL8366S switch\n");
1448 type
= RTL8366_TYPE_S
;
1451 printk("Found an RTL8366RB switch\n");
1452 type
= RTL8366_TYPE_RB
;
1455 printk("Found an Unknown RTL8366 switch (id=0x%04x)\n", reg
);
1460 __rtl8366_smi_cleanup(&smi
);
1465 int rtl8366_smi_init(struct rtl8366_smi
*smi
)
1472 err
= __rtl8366_smi_init(smi
, dev_name(smi
->parent
));
1477 dev_info(smi
->parent
, "using GPIO pins %u (SDA) and %u (SCK)\n",
1478 smi
->gpio_sda
, smi
->gpio_sck
);
1480 dev_info(smi
->parent
, "using MDIO bus '%s'\n", smi
->ext_mbus
->name
);
1482 err
= smi
->ops
->detect(smi
);
1484 dev_err(smi
->parent
, "chip detection failed, err=%d\n", err
);
1488 err
= rtl8366_reset(smi
);
1492 err
= smi
->ops
->setup(smi
);
1494 dev_err(smi
->parent
, "chip setup failed, err=%d\n", err
);
1498 err
= rtl8366_init_vlan(smi
);
1500 dev_err(smi
->parent
, "VLAN initialization failed, err=%d\n",
1505 err
= rtl8366_enable_all_ports(smi
, 1);
1509 err
= rtl8366_smi_mii_init(smi
);
1513 rtl8366_debugfs_init(smi
);
1518 __rtl8366_smi_cleanup(smi
);
1522 EXPORT_SYMBOL_GPL(rtl8366_smi_init
);
1524 void rtl8366_smi_cleanup(struct rtl8366_smi
*smi
)
1526 rtl8366_debugfs_remove(smi
);
1527 rtl8366_smi_mii_cleanup(smi
);
1528 __rtl8366_smi_cleanup(smi
);
1530 EXPORT_SYMBOL_GPL(rtl8366_smi_cleanup
);
1533 static void rtl8366_smi_reset(struct rtl8366_smi
*smi
, bool active
)
1536 reset_control_assert(smi
->reset
);
1538 reset_control_deassert(smi
->reset
);
1541 int rtl8366_smi_probe_of(struct platform_device
*pdev
, struct rtl8366_smi
*smi
)
1543 int sck
= of_get_named_gpio(pdev
->dev
.of_node
, "gpio-sck", 0);
1544 int sda
= of_get_named_gpio(pdev
->dev
.of_node
, "gpio-sda", 0);
1545 struct device_node
*np
= pdev
->dev
.of_node
;
1546 struct device_node
*mdio_node
;
1548 mdio_node
= of_parse_phandle(np
, "mii-bus", 0);
1550 dev_err(&pdev
->dev
, "cannot find mdio node phandle");
1554 smi
->ext_mbus
= of_mdio_find_bus(mdio_node
);
1555 if (!smi
->ext_mbus
) {
1556 dev_info(&pdev
->dev
,
1557 "cannot find mdio bus from bus handle (yet)");
1564 if (!gpio_is_valid(sck
) || !gpio_is_valid(sda
)) {
1566 dev_err(&pdev
->dev
, "gpios missing in devictree\n");
1569 return -EPROBE_DEFER
;
1573 smi
->gpio_sda
= sda
;
1574 smi
->gpio_sck
= sck
;
1575 smi
->reset
= devm_reset_control_get(&pdev
->dev
, "switch");
1576 if (!IS_ERR(smi
->reset
))
1577 smi
->hw_reset
= rtl8366_smi_reset
;
1582 static inline int rtl8366_smi_probe_of(struct platform_device
*pdev
, struct rtl8366_smi
*smi
)
1588 int rtl8366_smi_probe_plat(struct platform_device
*pdev
, struct rtl8366_smi
*smi
)
1590 struct rtl8366_platform_data
*pdata
= pdev
->dev
.platform_data
;
1592 if (!pdev
->dev
.platform_data
) {
1593 dev_err(&pdev
->dev
, "no platform data specified\n");
1597 smi
->gpio_sda
= pdata
->gpio_sda
;
1598 smi
->gpio_sck
= pdata
->gpio_sck
;
1599 smi
->hw_reset
= pdata
->hw_reset
;
1605 struct rtl8366_smi
*rtl8366_smi_probe(struct platform_device
*pdev
)
1607 struct rtl8366_smi
*smi
;
1610 smi
= rtl8366_smi_alloc(&pdev
->dev
);
1614 if (pdev
->dev
.of_node
)
1615 err
= rtl8366_smi_probe_of(pdev
, smi
);
1617 err
= rtl8366_smi_probe_plat(pdev
, smi
);
1626 return ERR_PTR(err
);
1628 EXPORT_SYMBOL_GPL(rtl8366_smi_probe
);
1630 MODULE_DESCRIPTION("Realtek RTL8366 SMI interface driver");
1631 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
1632 MODULE_LICENSE("GPL v2");