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