1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * MDIO I2C bridge |
4 | * |
5 | * Copyright (C) 2015-2016 Russell King |
6 | * Copyright (C) 2021 Marek Behun |
7 | * |
8 | * Network PHYs can appear on I2C buses when they are part of SFP module. |
9 | * This driver exposes these PHYs to the networking PHY code, allowing |
10 | * our PHY drivers access to these PHYs, and so allowing configuration |
11 | * of their settings. |
12 | */ |
13 | #include <linux/i2c.h> |
14 | #include <linux/mdio/mdio-i2c.h> |
15 | #include <linux/phy.h> |
16 | #include <linux/sfp.h> |
17 | |
18 | /* |
19 | * I2C bus addresses 0x50 and 0x51 are normally an EEPROM, which is |
20 | * specified to be present in SFP modules. These correspond with PHY |
21 | * addresses 16 and 17. Disallow access to these "phy" addresses. |
22 | */ |
23 | static bool i2c_mii_valid_phy_id(int phy_id) |
24 | { |
25 | return phy_id != 0x10 && phy_id != 0x11; |
26 | } |
27 | |
28 | static unsigned int i2c_mii_phy_addr(int phy_id) |
29 | { |
30 | return phy_id + 0x40; |
31 | } |
32 | |
33 | static int i2c_mii_read_default_c45(struct mii_bus *bus, int phy_id, int devad, |
34 | int reg) |
35 | { |
36 | struct i2c_adapter *i2c = bus->priv; |
37 | struct i2c_msg msgs[2]; |
38 | u8 addr[3], data[2], *p; |
39 | int bus_addr, ret; |
40 | |
41 | if (!i2c_mii_valid_phy_id(phy_id)) |
42 | return 0xffff; |
43 | |
44 | p = addr; |
45 | if (devad >= 0) { |
46 | *p++ = 0x20 | devad; |
47 | *p++ = reg >> 8; |
48 | } |
49 | *p++ = reg; |
50 | |
51 | bus_addr = i2c_mii_phy_addr(phy_id); |
52 | msgs[0].addr = bus_addr; |
53 | msgs[0].flags = 0; |
54 | msgs[0].len = p - addr; |
55 | msgs[0].buf = addr; |
56 | msgs[1].addr = bus_addr; |
57 | msgs[1].flags = I2C_M_RD; |
58 | msgs[1].len = sizeof(data); |
59 | msgs[1].buf = data; |
60 | |
61 | ret = i2c_transfer(adap: i2c, msgs, ARRAY_SIZE(msgs)); |
62 | if (ret != ARRAY_SIZE(msgs)) |
63 | return 0xffff; |
64 | |
65 | return data[0] << 8 | data[1]; |
66 | } |
67 | |
68 | static int i2c_mii_write_default_c45(struct mii_bus *bus, int phy_id, |
69 | int devad, int reg, u16 val) |
70 | { |
71 | struct i2c_adapter *i2c = bus->priv; |
72 | struct i2c_msg msg; |
73 | int ret; |
74 | u8 data[5], *p; |
75 | |
76 | if (!i2c_mii_valid_phy_id(phy_id)) |
77 | return 0; |
78 | |
79 | p = data; |
80 | if (devad >= 0) { |
81 | *p++ = devad; |
82 | *p++ = reg >> 8; |
83 | } |
84 | *p++ = reg; |
85 | *p++ = val >> 8; |
86 | *p++ = val; |
87 | |
88 | msg.addr = i2c_mii_phy_addr(phy_id); |
89 | msg.flags = 0; |
90 | msg.len = p - data; |
91 | msg.buf = data; |
92 | |
93 | ret = i2c_transfer(adap: i2c, msgs: &msg, num: 1); |
94 | |
95 | return ret < 0 ? ret : 0; |
96 | } |
97 | |
98 | static int i2c_mii_read_default_c22(struct mii_bus *bus, int phy_id, int reg) |
99 | { |
100 | return i2c_mii_read_default_c45(bus, phy_id, devad: -1, reg); |
101 | } |
102 | |
103 | static int i2c_mii_write_default_c22(struct mii_bus *bus, int phy_id, int reg, |
104 | u16 val) |
105 | { |
106 | return i2c_mii_write_default_c45(bus, phy_id, devad: -1, reg, val); |
107 | } |
108 | |
109 | /* RollBall SFPs do not access internal PHY via I2C address 0x56, but |
110 | * instead via address 0x51, when SFP page is set to 0x03 and password to |
111 | * 0xffffffff. |
112 | * |
113 | * address size contents description |
114 | * ------- ---- -------- ----------- |
115 | * 0x80 1 CMD 0x01/0x02/0x04 for write/read/done |
116 | * 0x81 1 DEV Clause 45 device |
117 | * 0x82 2 REG Clause 45 register |
118 | * 0x84 2 VAL Register value |
119 | */ |
120 | #define ROLLBALL_PHY_I2C_ADDR 0x51 |
121 | |
122 | #define ROLLBALL_PASSWORD (SFP_VSL + 3) |
123 | |
124 | #define ROLLBALL_CMD_ADDR 0x80 |
125 | #define ROLLBALL_DATA_ADDR 0x81 |
126 | |
127 | #define ROLLBALL_CMD_WRITE 0x01 |
128 | #define ROLLBALL_CMD_READ 0x02 |
129 | #define ROLLBALL_CMD_DONE 0x04 |
130 | |
131 | #define SFP_PAGE_ROLLBALL_MDIO 3 |
132 | |
133 | static int __i2c_transfer_err(struct i2c_adapter *i2c, struct i2c_msg *msgs, |
134 | int num) |
135 | { |
136 | int ret; |
137 | |
138 | ret = __i2c_transfer(adap: i2c, msgs, num); |
139 | if (ret < 0) |
140 | return ret; |
141 | else if (ret != num) |
142 | return -EIO; |
143 | else |
144 | return 0; |
145 | } |
146 | |
147 | static int __i2c_rollball_get_page(struct i2c_adapter *i2c, int bus_addr, |
148 | u8 *page) |
149 | { |
150 | struct i2c_msg msgs[2]; |
151 | u8 addr = SFP_PAGE; |
152 | |
153 | msgs[0].addr = bus_addr; |
154 | msgs[0].flags = 0; |
155 | msgs[0].len = 1; |
156 | msgs[0].buf = &addr; |
157 | |
158 | msgs[1].addr = bus_addr; |
159 | msgs[1].flags = I2C_M_RD; |
160 | msgs[1].len = 1; |
161 | msgs[1].buf = page; |
162 | |
163 | return __i2c_transfer_err(i2c, msgs, num: 2); |
164 | } |
165 | |
166 | static int __i2c_rollball_set_page(struct i2c_adapter *i2c, int bus_addr, |
167 | u8 page) |
168 | { |
169 | struct i2c_msg msg; |
170 | u8 buf[2]; |
171 | |
172 | buf[0] = SFP_PAGE; |
173 | buf[1] = page; |
174 | |
175 | msg.addr = bus_addr; |
176 | msg.flags = 0; |
177 | msg.len = 2; |
178 | msg.buf = buf; |
179 | |
180 | return __i2c_transfer_err(i2c, msgs: &msg, num: 1); |
181 | } |
182 | |
183 | /* In order to not interfere with other SFP code (which possibly may manipulate |
184 | * SFP_PAGE), for every transfer we do this: |
185 | * 1. lock the bus |
186 | * 2. save content of SFP_PAGE |
187 | * 3. set SFP_PAGE to 3 |
188 | * 4. do the transfer |
189 | * 5. restore original SFP_PAGE |
190 | * 6. unlock the bus |
191 | * Note that one might think that steps 2 to 5 could be theoretically done all |
192 | * in one call to i2c_transfer (by constructing msgs array in such a way), but |
193 | * unfortunately tests show that this does not work :-( Changed SFP_PAGE does |
194 | * not take into account until i2c_transfer() is done. |
195 | */ |
196 | static int i2c_transfer_rollball(struct i2c_adapter *i2c, |
197 | struct i2c_msg *msgs, int num) |
198 | { |
199 | int ret, main_err = 0; |
200 | u8 saved_page; |
201 | |
202 | i2c_lock_bus(adapter: i2c, I2C_LOCK_SEGMENT); |
203 | |
204 | /* save original page */ |
205 | ret = __i2c_rollball_get_page(i2c, bus_addr: msgs->addr, page: &saved_page); |
206 | if (ret) |
207 | goto unlock; |
208 | |
209 | /* change to RollBall MDIO page */ |
210 | ret = __i2c_rollball_set_page(i2c, bus_addr: msgs->addr, SFP_PAGE_ROLLBALL_MDIO); |
211 | if (ret) |
212 | goto unlock; |
213 | |
214 | /* do the transfer; we try to restore original page if this fails */ |
215 | ret = __i2c_transfer_err(i2c, msgs, num); |
216 | if (ret) |
217 | main_err = ret; |
218 | |
219 | /* restore original page */ |
220 | ret = __i2c_rollball_set_page(i2c, bus_addr: msgs->addr, page: saved_page); |
221 | |
222 | unlock: |
223 | i2c_unlock_bus(adapter: i2c, I2C_LOCK_SEGMENT); |
224 | |
225 | return main_err ? : ret; |
226 | } |
227 | |
228 | static int i2c_rollball_mii_poll(struct mii_bus *bus, int bus_addr, u8 *buf, |
229 | size_t len) |
230 | { |
231 | struct i2c_adapter *i2c = bus->priv; |
232 | struct i2c_msg msgs[2]; |
233 | u8 cmd_addr, tmp, *res; |
234 | int i, ret; |
235 | |
236 | cmd_addr = ROLLBALL_CMD_ADDR; |
237 | |
238 | res = buf ? buf : &tmp; |
239 | len = buf ? len : 1; |
240 | |
241 | msgs[0].addr = bus_addr; |
242 | msgs[0].flags = 0; |
243 | msgs[0].len = 1; |
244 | msgs[0].buf = &cmd_addr; |
245 | |
246 | msgs[1].addr = bus_addr; |
247 | msgs[1].flags = I2C_M_RD; |
248 | msgs[1].len = len; |
249 | msgs[1].buf = res; |
250 | |
251 | /* By experiment it takes up to 70 ms to access a register for these |
252 | * SFPs. Sleep 20ms between iterations and try 10 times. |
253 | */ |
254 | i = 10; |
255 | do { |
256 | msleep(msecs: 20); |
257 | |
258 | ret = i2c_transfer_rollball(i2c, msgs, ARRAY_SIZE(msgs)); |
259 | if (ret) |
260 | return ret; |
261 | |
262 | if (*res == ROLLBALL_CMD_DONE) |
263 | return 0; |
264 | } while (i-- > 0); |
265 | |
266 | dev_dbg(&bus->dev, "poll timed out\n" ); |
267 | |
268 | return -ETIMEDOUT; |
269 | } |
270 | |
271 | static int i2c_rollball_mii_cmd(struct mii_bus *bus, int bus_addr, u8 cmd, |
272 | u8 *data, size_t len) |
273 | { |
274 | struct i2c_adapter *i2c = bus->priv; |
275 | struct i2c_msg msgs[2]; |
276 | u8 cmdbuf[2]; |
277 | |
278 | cmdbuf[0] = ROLLBALL_CMD_ADDR; |
279 | cmdbuf[1] = cmd; |
280 | |
281 | msgs[0].addr = bus_addr; |
282 | msgs[0].flags = 0; |
283 | msgs[0].len = len; |
284 | msgs[0].buf = data; |
285 | |
286 | msgs[1].addr = bus_addr; |
287 | msgs[1].flags = 0; |
288 | msgs[1].len = sizeof(cmdbuf); |
289 | msgs[1].buf = cmdbuf; |
290 | |
291 | return i2c_transfer_rollball(i2c, msgs, ARRAY_SIZE(msgs)); |
292 | } |
293 | |
294 | static int i2c_mii_read_rollball(struct mii_bus *bus, int phy_id, int devad, |
295 | int reg) |
296 | { |
297 | u8 buf[4], res[6]; |
298 | int bus_addr, ret; |
299 | u16 val; |
300 | |
301 | bus_addr = i2c_mii_phy_addr(phy_id); |
302 | if (bus_addr != ROLLBALL_PHY_I2C_ADDR) |
303 | return 0xffff; |
304 | |
305 | buf[0] = ROLLBALL_DATA_ADDR; |
306 | buf[1] = devad; |
307 | buf[2] = (reg >> 8) & 0xff; |
308 | buf[3] = reg & 0xff; |
309 | |
310 | ret = i2c_rollball_mii_cmd(bus, bus_addr, ROLLBALL_CMD_READ, data: buf, |
311 | len: sizeof(buf)); |
312 | if (ret < 0) |
313 | return ret; |
314 | |
315 | ret = i2c_rollball_mii_poll(bus, bus_addr, buf: res, len: sizeof(res)); |
316 | if (ret == -ETIMEDOUT) |
317 | return 0xffff; |
318 | else if (ret < 0) |
319 | return ret; |
320 | |
321 | val = res[4] << 8 | res[5]; |
322 | |
323 | return val; |
324 | } |
325 | |
326 | static int i2c_mii_write_rollball(struct mii_bus *bus, int phy_id, int devad, |
327 | int reg, u16 val) |
328 | { |
329 | int bus_addr, ret; |
330 | u8 buf[6]; |
331 | |
332 | bus_addr = i2c_mii_phy_addr(phy_id); |
333 | if (bus_addr != ROLLBALL_PHY_I2C_ADDR) |
334 | return 0; |
335 | |
336 | buf[0] = ROLLBALL_DATA_ADDR; |
337 | buf[1] = devad; |
338 | buf[2] = (reg >> 8) & 0xff; |
339 | buf[3] = reg & 0xff; |
340 | buf[4] = val >> 8; |
341 | buf[5] = val & 0xff; |
342 | |
343 | ret = i2c_rollball_mii_cmd(bus, bus_addr, ROLLBALL_CMD_WRITE, data: buf, |
344 | len: sizeof(buf)); |
345 | if (ret < 0) |
346 | return ret; |
347 | |
348 | ret = i2c_rollball_mii_poll(bus, bus_addr, NULL, len: 0); |
349 | if (ret < 0) |
350 | return ret; |
351 | |
352 | return 0; |
353 | } |
354 | |
355 | static int i2c_mii_init_rollball(struct i2c_adapter *i2c) |
356 | { |
357 | struct i2c_msg msg; |
358 | u8 pw[5]; |
359 | int ret; |
360 | |
361 | pw[0] = ROLLBALL_PASSWORD; |
362 | pw[1] = 0xff; |
363 | pw[2] = 0xff; |
364 | pw[3] = 0xff; |
365 | pw[4] = 0xff; |
366 | |
367 | msg.addr = ROLLBALL_PHY_I2C_ADDR; |
368 | msg.flags = 0; |
369 | msg.len = sizeof(pw); |
370 | msg.buf = pw; |
371 | |
372 | ret = i2c_transfer(adap: i2c, msgs: &msg, num: 1); |
373 | if (ret < 0) |
374 | return ret; |
375 | else if (ret != 1) |
376 | return -EIO; |
377 | else |
378 | return 0; |
379 | } |
380 | |
381 | struct mii_bus *mdio_i2c_alloc(struct device *parent, struct i2c_adapter *i2c, |
382 | enum mdio_i2c_proto protocol) |
383 | { |
384 | struct mii_bus *mii; |
385 | int ret; |
386 | |
387 | if (!i2c_check_functionality(adap: i2c, I2C_FUNC_I2C)) |
388 | return ERR_PTR(error: -EINVAL); |
389 | |
390 | mii = mdiobus_alloc(); |
391 | if (!mii) |
392 | return ERR_PTR(error: -ENOMEM); |
393 | |
394 | snprintf(buf: mii->id, MII_BUS_ID_SIZE, fmt: "i2c:%s" , dev_name(dev: parent)); |
395 | mii->parent = parent; |
396 | mii->priv = i2c; |
397 | |
398 | switch (protocol) { |
399 | case MDIO_I2C_ROLLBALL: |
400 | ret = i2c_mii_init_rollball(i2c); |
401 | if (ret < 0) { |
402 | dev_err(parent, |
403 | "Cannot initialize RollBall MDIO I2C protocol: %d\n" , |
404 | ret); |
405 | mdiobus_free(bus: mii); |
406 | return ERR_PTR(error: ret); |
407 | } |
408 | |
409 | mii->read_c45 = i2c_mii_read_rollball; |
410 | mii->write_c45 = i2c_mii_write_rollball; |
411 | break; |
412 | default: |
413 | mii->read = i2c_mii_read_default_c22; |
414 | mii->write = i2c_mii_write_default_c22; |
415 | mii->read_c45 = i2c_mii_read_default_c45; |
416 | mii->write_c45 = i2c_mii_write_default_c45; |
417 | break; |
418 | } |
419 | |
420 | return mii; |
421 | } |
422 | EXPORT_SYMBOL_GPL(mdio_i2c_alloc); |
423 | |
424 | MODULE_AUTHOR("Russell King" ); |
425 | MODULE_DESCRIPTION("MDIO I2C bridge library" ); |
426 | MODULE_LICENSE("GPL v2" ); |
427 | |