GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / net / phy / realtek.c
1 /*
2  * drivers/net/phy/realtek.c
3  *
4  * Driver for Realtek PHYs
5  *
6  * Author: Johnson Leung <r58129@freescale.com>
7  *
8  * Copyright (c) 2004 Freescale Semiconductor, Inc.
9  *
10  * This program is free software; you can redistribute  it and/or modify it
11  * under  the terms of  the GNU General  Public License as published by the
12  * Free Software Foundation;  either version 2 of the  License, or (at your
13  * option) any later version.
14  *
15  */
16 #include <linux/bitops.h>
17 #include <linux/phy.h>
18 #include <linux/module.h>
19
20 #define RTL821x_PHYSR                           0x11
21 #define RTL821x_PHYSR_DUPLEX                    BIT(13)
22 #define RTL821x_PHYSR_SPEED                     GENMASK(15, 14)
23
24 #define RTL821x_INER                            0x12
25 #define RTL8211B_INER_INIT                      0x6400
26 #define RTL8211E_INER_LINK_STATUS               BIT(10)
27 #define RTL8211F_INER_LINK_STATUS               BIT(4)
28
29 #define RTL821x_INSR                            0x13
30
31 #define RTL821x_PAGE_SELECT                     0x1f
32
33 #define RTL8211F_INSR                           0x1d
34
35 #define RTL8211F_TX_DELAY                       BIT(8)
36
37 #define RTL8201F_ISR                            0x1e
38 #define RTL8201F_IER                            0x13
39
40 #define RTL8366RB_POWER_SAVE                    0x15
41 #define RTL8366RB_POWER_SAVE_ON                 BIT(12)
42
43 MODULE_DESCRIPTION("Realtek PHY driver");
44 MODULE_AUTHOR("Johnson Leung");
45 MODULE_LICENSE("GPL");
46
47 static int rtl821x_read_page(struct phy_device *phydev)
48 {
49         return __phy_read(phydev, RTL821x_PAGE_SELECT);
50 }
51
52 static int rtl821x_write_page(struct phy_device *phydev, int page)
53 {
54         return __phy_write(phydev, RTL821x_PAGE_SELECT, page);
55 }
56
57 static int rtl8201_ack_interrupt(struct phy_device *phydev)
58 {
59         int err;
60
61         err = phy_read(phydev, RTL8201F_ISR);
62
63         return (err < 0) ? err : 0;
64 }
65
66 static int rtl821x_ack_interrupt(struct phy_device *phydev)
67 {
68         int err;
69
70         err = phy_read(phydev, RTL821x_INSR);
71
72         return (err < 0) ? err : 0;
73 }
74
75 static int rtl8211f_ack_interrupt(struct phy_device *phydev)
76 {
77         int err;
78
79         err = phy_read_paged(phydev, 0xa43, RTL8211F_INSR);
80
81         return (err < 0) ? err : 0;
82 }
83
84 static int rtl8201_config_intr(struct phy_device *phydev)
85 {
86         u16 val;
87
88         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
89                 val = BIT(13) | BIT(12) | BIT(11);
90         else
91                 val = 0;
92
93         return phy_write_paged(phydev, 0x7, RTL8201F_IER, val);
94 }
95
96 static int rtl8211b_config_intr(struct phy_device *phydev)
97 {
98         int err;
99
100         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
101                 err = phy_write(phydev, RTL821x_INER,
102                                 RTL8211B_INER_INIT);
103         else
104                 err = phy_write(phydev, RTL821x_INER, 0);
105
106         return err;
107 }
108
109 static int rtl8211e_config_intr(struct phy_device *phydev)
110 {
111         int err;
112
113         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
114                 err = phy_write(phydev, RTL821x_INER,
115                                 RTL8211E_INER_LINK_STATUS);
116         else
117                 err = phy_write(phydev, RTL821x_INER, 0);
118
119         return err;
120 }
121
122 static int rtl8211f_config_intr(struct phy_device *phydev)
123 {
124         u16 val;
125
126         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
127                 val = RTL8211F_INER_LINK_STATUS;
128         else
129                 val = 0;
130
131         return phy_write_paged(phydev, 0xa42, RTL821x_INER, val);
132 }
133
134 static int rtl8211_config_aneg(struct phy_device *phydev)
135 {
136         int ret;
137
138         ret = genphy_config_aneg(phydev);
139         if (ret < 0)
140                 return ret;
141
142         /* Quirk was copied from vendor driver. Unfortunately it includes no
143          * description of the magic numbers.
144          */
145         if (phydev->speed == SPEED_100 && phydev->autoneg == AUTONEG_DISABLE) {
146                 phy_write(phydev, 0x17, 0x2138);
147                 phy_write(phydev, 0x0e, 0x0260);
148         } else {
149                 phy_write(phydev, 0x17, 0x2108);
150                 phy_write(phydev, 0x0e, 0x0000);
151         }
152
153         return 0;
154 }
155
156 static int rtl8211c_config_init(struct phy_device *phydev)
157 {
158         /* RTL8211C has an issue when operating in Gigabit slave mode */
159         phy_set_bits(phydev, MII_CTRL1000,
160                      CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER);
161
162         return genphy_config_init(phydev);
163 }
164
165 static int rtl8211f_config_init(struct phy_device *phydev)
166 {
167         int ret;
168         u16 val = 0;
169
170         ret = genphy_config_init(phydev);
171         if (ret < 0)
172                 return ret;
173
174         /* enable TX-delay for rgmii-id and rgmii-txid, otherwise disable it */
175         if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
176             phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
177                 val = RTL8211F_TX_DELAY;
178
179         return phy_modify_paged(phydev, 0xd08, 0x11, RTL8211F_TX_DELAY, val);
180 }
181
182 static int rtl8211b_suspend(struct phy_device *phydev)
183 {
184         phy_write(phydev, MII_MMD_DATA, BIT(9));
185
186         return genphy_suspend(phydev);
187 }
188
189 static int rtl8211b_resume(struct phy_device *phydev)
190 {
191         phy_write(phydev, MII_MMD_DATA, 0);
192
193         return genphy_resume(phydev);
194 }
195
196 static int rtl8366rb_config_init(struct phy_device *phydev)
197 {
198         int ret;
199
200         ret = genphy_config_init(phydev);
201         if (ret < 0)
202                 return ret;
203
204         ret = phy_set_bits(phydev, RTL8366RB_POWER_SAVE,
205                            RTL8366RB_POWER_SAVE_ON);
206         if (ret) {
207                 dev_err(&phydev->mdio.dev,
208                         "error enabling power management\n");
209         }
210
211         return ret;
212 }
213
214 static struct phy_driver realtek_drvs[] = {
215         {
216                 .phy_id         = 0x00008201,
217                 .name           = "RTL8201CP Ethernet",
218                 .phy_id_mask    = 0x0000ffff,
219                 .features       = PHY_BASIC_FEATURES,
220                 .flags          = PHY_HAS_INTERRUPT,
221         }, {
222                 .phy_id         = 0x001cc816,
223                 .name           = "RTL8201F Fast Ethernet",
224                 .phy_id_mask    = 0x001fffff,
225                 .features       = PHY_BASIC_FEATURES,
226                 .flags          = PHY_HAS_INTERRUPT,
227                 .ack_interrupt  = &rtl8201_ack_interrupt,
228                 .config_intr    = &rtl8201_config_intr,
229                 .suspend        = genphy_suspend,
230                 .resume         = genphy_resume,
231                 .read_page      = rtl821x_read_page,
232                 .write_page     = rtl821x_write_page,
233         }, {
234                 .phy_id         = 0x001cc910,
235                 .name           = "RTL8211 Gigabit Ethernet",
236                 .phy_id_mask    = 0x001fffff,
237                 .features       = PHY_GBIT_FEATURES,
238                 .config_aneg    = rtl8211_config_aneg,
239                 .read_mmd       = &genphy_read_mmd_unsupported,
240                 .write_mmd      = &genphy_write_mmd_unsupported,
241         }, {
242                 .phy_id         = 0x001cc912,
243                 .name           = "RTL8211B Gigabit Ethernet",
244                 .phy_id_mask    = 0x001fffff,
245                 .features       = PHY_GBIT_FEATURES,
246                 .flags          = PHY_HAS_INTERRUPT,
247                 .ack_interrupt  = &rtl821x_ack_interrupt,
248                 .config_intr    = &rtl8211b_config_intr,
249                 .read_mmd       = &genphy_read_mmd_unsupported,
250                 .write_mmd      = &genphy_write_mmd_unsupported,
251                 .suspend        = rtl8211b_suspend,
252                 .resume         = rtl8211b_resume,
253         }, {
254                 .phy_id         = 0x001cc913,
255                 .name           = "RTL8211C Gigabit Ethernet",
256                 .phy_id_mask    = 0x001fffff,
257                 .features       = PHY_GBIT_FEATURES,
258                 .config_init    = rtl8211c_config_init,
259                 .read_mmd       = &genphy_read_mmd_unsupported,
260                 .write_mmd      = &genphy_write_mmd_unsupported,
261         }, {
262                 .phy_id         = 0x001cc914,
263                 .name           = "RTL8211DN Gigabit Ethernet",
264                 .phy_id_mask    = 0x001fffff,
265                 .features       = PHY_GBIT_FEATURES,
266                 .flags          = PHY_HAS_INTERRUPT,
267                 .ack_interrupt  = rtl821x_ack_interrupt,
268                 .config_intr    = rtl8211e_config_intr,
269                 .suspend        = genphy_suspend,
270                 .resume         = genphy_resume,
271         }, {
272                 .phy_id         = 0x001cc915,
273                 .name           = "RTL8211E Gigabit Ethernet",
274                 .phy_id_mask    = 0x001fffff,
275                 .features       = PHY_GBIT_FEATURES,
276                 .flags          = PHY_HAS_INTERRUPT,
277                 .ack_interrupt  = &rtl821x_ack_interrupt,
278                 .config_intr    = &rtl8211e_config_intr,
279                 .suspend        = genphy_suspend,
280                 .resume         = genphy_resume,
281         }, {
282                 .phy_id         = 0x001cc916,
283                 .name           = "RTL8211F Gigabit Ethernet",
284                 .phy_id_mask    = 0x001fffff,
285                 .features       = PHY_GBIT_FEATURES,
286                 .flags          = PHY_HAS_INTERRUPT,
287                 .config_init    = &rtl8211f_config_init,
288                 .ack_interrupt  = &rtl8211f_ack_interrupt,
289                 .config_intr    = &rtl8211f_config_intr,
290                 .suspend        = genphy_suspend,
291                 .resume         = genphy_resume,
292                 .read_page      = rtl821x_read_page,
293                 .write_page     = rtl821x_write_page,
294         }, {
295                 .phy_id         = 0x001cc961,
296                 .name           = "RTL8366RB Gigabit Ethernet",
297                 .phy_id_mask    = 0x001fffff,
298                 .features       = PHY_GBIT_FEATURES,
299                 .flags          = PHY_HAS_INTERRUPT,
300                 .config_init    = &rtl8366rb_config_init,
301                 .suspend        = genphy_suspend,
302                 .resume         = genphy_resume,
303         },
304 };
305
306 module_phy_driver(realtek_drvs);
307
308 static struct mdio_device_id __maybe_unused realtek_tbl[] = {
309         { 0x001cc816, 0x001fffff },
310         { 0x001cc910, 0x001fffff },
311         { 0x001cc912, 0x001fffff },
312         { 0x001cc913, 0x001fffff },
313         { 0x001cc914, 0x001fffff },
314         { 0x001cc915, 0x001fffff },
315         { 0x001cc916, 0x001fffff },
316         { 0x001cc961, 0x001fffff },
317         { }
318 };
319
320 MODULE_DEVICE_TABLE(mdio, realtek_tbl);