Commit | Line | Data |
---|---|---|
73970055 | 1 | #include <linux/delay.h> |
54a2fc62 | 2 | #include <linux/gpio/consumer.h> |
73970055 RK |
3 | #include <linux/i2c.h> |
4 | #include <linux/interrupt.h> | |
5 | #include <linux/jiffies.h> | |
6 | #include <linux/module.h> | |
7 | #include <linux/mutex.h> | |
8 | #include <linux/of.h> | |
9 | #include <linux/phy.h> | |
10 | #include <linux/platform_device.h> | |
11 | #include <linux/rtnetlink.h> | |
12 | #include <linux/slab.h> | |
13 | #include <linux/workqueue.h> | |
14 | ||
15 | #include "mdio-i2c.h" | |
16 | #include "sfp.h" | |
17 | #include "swphy.h" | |
18 | ||
19 | enum { | |
20 | GPIO_MODDEF0, | |
21 | GPIO_LOS, | |
22 | GPIO_TX_FAULT, | |
23 | GPIO_TX_DISABLE, | |
24 | GPIO_RATE_SELECT, | |
25 | GPIO_MAX, | |
26 | ||
27 | SFP_F_PRESENT = BIT(GPIO_MODDEF0), | |
28 | SFP_F_LOS = BIT(GPIO_LOS), | |
29 | SFP_F_TX_FAULT = BIT(GPIO_TX_FAULT), | |
30 | SFP_F_TX_DISABLE = BIT(GPIO_TX_DISABLE), | |
31 | SFP_F_RATE_SELECT = BIT(GPIO_RATE_SELECT), | |
32 | ||
33 | SFP_E_INSERT = 0, | |
34 | SFP_E_REMOVE, | |
35 | SFP_E_DEV_DOWN, | |
36 | SFP_E_DEV_UP, | |
37 | SFP_E_TX_FAULT, | |
38 | SFP_E_TX_CLEAR, | |
39 | SFP_E_LOS_HIGH, | |
40 | SFP_E_LOS_LOW, | |
41 | SFP_E_TIMEOUT, | |
42 | ||
43 | SFP_MOD_EMPTY = 0, | |
44 | SFP_MOD_PROBE, | |
45 | SFP_MOD_PRESENT, | |
46 | SFP_MOD_ERROR, | |
47 | ||
48 | SFP_DEV_DOWN = 0, | |
49 | SFP_DEV_UP, | |
50 | ||
51 | SFP_S_DOWN = 0, | |
52 | SFP_S_INIT, | |
53 | SFP_S_WAIT_LOS, | |
54 | SFP_S_LINK_UP, | |
55 | SFP_S_TX_FAULT, | |
56 | SFP_S_REINIT, | |
57 | SFP_S_TX_DISABLE, | |
58 | }; | |
59 | ||
60 | static const char *gpio_of_names[] = { | |
25ee0793 | 61 | "mod-def0", |
73970055 RK |
62 | "los", |
63 | "tx-fault", | |
64 | "tx-disable", | |
25ee0793 | 65 | "rate-select0", |
73970055 RK |
66 | }; |
67 | ||
68 | static const enum gpiod_flags gpio_flags[] = { | |
69 | GPIOD_IN, | |
70 | GPIOD_IN, | |
71 | GPIOD_IN, | |
72 | GPIOD_ASIS, | |
73 | GPIOD_ASIS, | |
74 | }; | |
75 | ||
76 | #define T_INIT_JIFFIES msecs_to_jiffies(300) | |
77 | #define T_RESET_US 10 | |
78 | #define T_FAULT_RECOVER msecs_to_jiffies(1000) | |
79 | ||
80 | /* SFP module presence detection is poor: the three MOD DEF signals are | |
81 | * the same length on the PCB, which means it's possible for MOD DEF 0 to | |
82 | * connect before the I2C bus on MOD DEF 1/2. | |
83 | * | |
84 | * The SFP MSA specifies 300ms as t_init (the time taken for TX_FAULT to | |
85 | * be deasserted) but makes no mention of the earliest time before we can | |
86 | * access the I2C EEPROM. However, Avago modules require 300ms. | |
87 | */ | |
88 | #define T_PROBE_INIT msecs_to_jiffies(300) | |
89 | #define T_PROBE_RETRY msecs_to_jiffies(100) | |
90 | ||
516b29ed | 91 | /* SFP modules appear to always have their PHY configured for bus address |
73970055 RK |
92 | * 0x56 (which with mdio-i2c, translates to a PHY address of 22). |
93 | */ | |
94 | #define SFP_PHY_ADDR 22 | |
95 | ||
516b29ed | 96 | /* Give this long for the PHY to reset. */ |
73970055 RK |
97 | #define T_PHY_RESET_MS 50 |
98 | ||
99 | static DEFINE_MUTEX(sfp_mutex); | |
100 | ||
101 | struct sfp { | |
102 | struct device *dev; | |
103 | struct i2c_adapter *i2c; | |
104 | struct mii_bus *i2c_mii; | |
105 | struct sfp_bus *sfp_bus; | |
106 | struct phy_device *mod_phy; | |
107 | ||
108 | unsigned int (*get_state)(struct sfp *); | |
109 | void (*set_state)(struct sfp *, unsigned int); | |
110 | int (*read)(struct sfp *, bool, u8, void *, size_t); | |
111 | ||
112 | struct gpio_desc *gpio[GPIO_MAX]; | |
113 | ||
114 | unsigned int state; | |
115 | struct delayed_work poll; | |
116 | struct delayed_work timeout; | |
117 | struct mutex sm_mutex; | |
118 | unsigned char sm_mod_state; | |
119 | unsigned char sm_dev_state; | |
120 | unsigned short sm_state; | |
121 | unsigned int sm_retries; | |
122 | ||
123 | struct sfp_eeprom_id id; | |
124 | }; | |
125 | ||
126 | static unsigned long poll_jiffies; | |
127 | ||
128 | static unsigned int sfp_gpio_get_state(struct sfp *sfp) | |
129 | { | |
130 | unsigned int i, state, v; | |
131 | ||
132 | for (i = state = 0; i < GPIO_MAX; i++) { | |
133 | if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i]) | |
134 | continue; | |
135 | ||
136 | v = gpiod_get_value_cansleep(sfp->gpio[i]); | |
137 | if (v) | |
138 | state |= BIT(i); | |
139 | } | |
140 | ||
141 | return state; | |
142 | } | |
143 | ||
144 | static void sfp_gpio_set_state(struct sfp *sfp, unsigned int state) | |
145 | { | |
146 | if (state & SFP_F_PRESENT) { | |
147 | /* If the module is present, drive the signals */ | |
148 | if (sfp->gpio[GPIO_TX_DISABLE]) | |
149 | gpiod_direction_output(sfp->gpio[GPIO_TX_DISABLE], | |
516b29ed | 150 | state & SFP_F_TX_DISABLE); |
73970055 RK |
151 | if (state & SFP_F_RATE_SELECT) |
152 | gpiod_direction_output(sfp->gpio[GPIO_RATE_SELECT], | |
516b29ed | 153 | state & SFP_F_RATE_SELECT); |
73970055 RK |
154 | } else { |
155 | /* Otherwise, let them float to the pull-ups */ | |
156 | if (sfp->gpio[GPIO_TX_DISABLE]) | |
157 | gpiod_direction_input(sfp->gpio[GPIO_TX_DISABLE]); | |
158 | if (state & SFP_F_RATE_SELECT) | |
159 | gpiod_direction_input(sfp->gpio[GPIO_RATE_SELECT]); | |
160 | } | |
161 | } | |
162 | ||
163 | static int sfp__i2c_read(struct i2c_adapter *i2c, u8 bus_addr, u8 dev_addr, | |
516b29ed | 164 | void *buf, size_t len) |
73970055 RK |
165 | { |
166 | struct i2c_msg msgs[2]; | |
167 | int ret; | |
168 | ||
169 | msgs[0].addr = bus_addr; | |
170 | msgs[0].flags = 0; | |
171 | msgs[0].len = 1; | |
172 | msgs[0].buf = &dev_addr; | |
173 | msgs[1].addr = bus_addr; | |
174 | msgs[1].flags = I2C_M_RD; | |
175 | msgs[1].len = len; | |
176 | msgs[1].buf = buf; | |
177 | ||
178 | ret = i2c_transfer(i2c, msgs, ARRAY_SIZE(msgs)); | |
179 | if (ret < 0) | |
180 | return ret; | |
181 | ||
182 | return ret == ARRAY_SIZE(msgs) ? len : 0; | |
183 | } | |
184 | ||
185 | static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 addr, void *buf, | |
516b29ed | 186 | size_t len) |
73970055 RK |
187 | { |
188 | return sfp__i2c_read(sfp->i2c, a2 ? 0x51 : 0x50, addr, buf, len); | |
189 | } | |
190 | ||
191 | static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c) | |
192 | { | |
193 | struct mii_bus *i2c_mii; | |
194 | int ret; | |
195 | ||
196 | if (!i2c_check_functionality(i2c, I2C_FUNC_I2C)) | |
197 | return -EINVAL; | |
198 | ||
199 | sfp->i2c = i2c; | |
200 | sfp->read = sfp_i2c_read; | |
201 | ||
202 | i2c_mii = mdio_i2c_alloc(sfp->dev, i2c); | |
203 | if (IS_ERR(i2c_mii)) | |
204 | return PTR_ERR(i2c_mii); | |
205 | ||
206 | i2c_mii->name = "SFP I2C Bus"; | |
207 | i2c_mii->phy_mask = ~0; | |
208 | ||
209 | ret = mdiobus_register(i2c_mii); | |
210 | if (ret < 0) { | |
211 | mdiobus_free(i2c_mii); | |
212 | return ret; | |
213 | } | |
214 | ||
215 | sfp->i2c_mii = i2c_mii; | |
216 | ||
217 | return 0; | |
218 | } | |
219 | ||
73970055 RK |
220 | /* Interface */ |
221 | static unsigned int sfp_get_state(struct sfp *sfp) | |
222 | { | |
223 | return sfp->get_state(sfp); | |
224 | } | |
225 | ||
226 | static void sfp_set_state(struct sfp *sfp, unsigned int state) | |
227 | { | |
228 | sfp->set_state(sfp, state); | |
229 | } | |
230 | ||
231 | static int sfp_read(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len) | |
232 | { | |
233 | return sfp->read(sfp, a2, addr, buf, len); | |
234 | } | |
235 | ||
236 | static unsigned int sfp_check(void *buf, size_t len) | |
237 | { | |
238 | u8 *p, check; | |
239 | ||
240 | for (p = buf, check = 0; len; p++, len--) | |
241 | check += *p; | |
242 | ||
243 | return check; | |
244 | } | |
245 | ||
246 | /* Helpers */ | |
247 | static void sfp_module_tx_disable(struct sfp *sfp) | |
248 | { | |
249 | dev_dbg(sfp->dev, "tx disable %u -> %u\n", | |
250 | sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 1); | |
251 | sfp->state |= SFP_F_TX_DISABLE; | |
252 | sfp_set_state(sfp, sfp->state); | |
253 | } | |
254 | ||
255 | static void sfp_module_tx_enable(struct sfp *sfp) | |
256 | { | |
257 | dev_dbg(sfp->dev, "tx disable %u -> %u\n", | |
258 | sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 0); | |
259 | sfp->state &= ~SFP_F_TX_DISABLE; | |
260 | sfp_set_state(sfp, sfp->state); | |
261 | } | |
262 | ||
263 | static void sfp_module_tx_fault_reset(struct sfp *sfp) | |
264 | { | |
265 | unsigned int state = sfp->state; | |
266 | ||
267 | if (state & SFP_F_TX_DISABLE) | |
268 | return; | |
269 | ||
270 | sfp_set_state(sfp, state | SFP_F_TX_DISABLE); | |
271 | ||
272 | udelay(T_RESET_US); | |
273 | ||
274 | sfp_set_state(sfp, state); | |
275 | } | |
276 | ||
277 | /* SFP state machine */ | |
278 | static void sfp_sm_set_timer(struct sfp *sfp, unsigned int timeout) | |
279 | { | |
280 | if (timeout) | |
281 | mod_delayed_work(system_power_efficient_wq, &sfp->timeout, | |
282 | timeout); | |
283 | else | |
284 | cancel_delayed_work(&sfp->timeout); | |
285 | } | |
286 | ||
287 | static void sfp_sm_next(struct sfp *sfp, unsigned int state, | |
288 | unsigned int timeout) | |
289 | { | |
290 | sfp->sm_state = state; | |
291 | sfp_sm_set_timer(sfp, timeout); | |
292 | } | |
293 | ||
516b29ed FF |
294 | static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state, |
295 | unsigned int timeout) | |
73970055 RK |
296 | { |
297 | sfp->sm_mod_state = state; | |
298 | sfp_sm_set_timer(sfp, timeout); | |
299 | } | |
300 | ||
301 | static void sfp_sm_phy_detach(struct sfp *sfp) | |
302 | { | |
303 | phy_stop(sfp->mod_phy); | |
304 | sfp_remove_phy(sfp->sfp_bus); | |
305 | phy_device_remove(sfp->mod_phy); | |
306 | phy_device_free(sfp->mod_phy); | |
307 | sfp->mod_phy = NULL; | |
308 | } | |
309 | ||
310 | static void sfp_sm_probe_phy(struct sfp *sfp) | |
311 | { | |
312 | struct phy_device *phy; | |
313 | int err; | |
314 | ||
315 | msleep(T_PHY_RESET_MS); | |
316 | ||
317 | phy = mdiobus_scan(sfp->i2c_mii, SFP_PHY_ADDR); | |
318 | if (IS_ERR(phy)) { | |
319 | dev_err(sfp->dev, "mdiobus scan returned %ld\n", PTR_ERR(phy)); | |
320 | return; | |
321 | } | |
322 | if (!phy) { | |
323 | dev_info(sfp->dev, "no PHY detected\n"); | |
324 | return; | |
325 | } | |
326 | ||
327 | err = sfp_add_phy(sfp->sfp_bus, phy); | |
328 | if (err) { | |
329 | phy_device_remove(phy); | |
330 | phy_device_free(phy); | |
331 | dev_err(sfp->dev, "sfp_add_phy failed: %d\n", err); | |
332 | return; | |
333 | } | |
334 | ||
335 | sfp->mod_phy = phy; | |
336 | phy_start(phy); | |
337 | } | |
338 | ||
339 | static void sfp_sm_link_up(struct sfp *sfp) | |
340 | { | |
341 | sfp_link_up(sfp->sfp_bus); | |
342 | sfp_sm_next(sfp, SFP_S_LINK_UP, 0); | |
343 | } | |
344 | ||
345 | static void sfp_sm_link_down(struct sfp *sfp) | |
346 | { | |
347 | sfp_link_down(sfp->sfp_bus); | |
348 | } | |
349 | ||
350 | static void sfp_sm_link_check_los(struct sfp *sfp) | |
351 | { | |
352 | unsigned int los = sfp->state & SFP_F_LOS; | |
353 | ||
710dfbb0 RK |
354 | /* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL |
355 | * are set, we assume that no LOS signal is available. | |
73970055 | 356 | */ |
acf1c02f | 357 | if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED)) |
73970055 | 358 | los ^= SFP_F_LOS; |
710dfbb0 RK |
359 | else if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL))) |
360 | los = 0; | |
73970055 RK |
361 | |
362 | if (los) | |
363 | sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); | |
364 | else | |
365 | sfp_sm_link_up(sfp); | |
366 | } | |
367 | ||
710dfbb0 RK |
368 | static bool sfp_los_event_active(struct sfp *sfp, unsigned int event) |
369 | { | |
370 | return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) && | |
371 | event == SFP_E_LOS_LOW) || | |
372 | (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) && | |
373 | event == SFP_E_LOS_HIGH); | |
374 | } | |
375 | ||
376 | static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event) | |
377 | { | |
378 | return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) && | |
379 | event == SFP_E_LOS_HIGH) || | |
380 | (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) && | |
381 | event == SFP_E_LOS_LOW); | |
382 | } | |
383 | ||
73970055 RK |
384 | static void sfp_sm_fault(struct sfp *sfp, bool warn) |
385 | { | |
386 | if (sfp->sm_retries && !--sfp->sm_retries) { | |
516b29ed FF |
387 | dev_err(sfp->dev, |
388 | "module persistently indicates fault, disabling\n"); | |
73970055 RK |
389 | sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0); |
390 | } else { | |
391 | if (warn) | |
392 | dev_err(sfp->dev, "module transmit fault indicated\n"); | |
393 | ||
394 | sfp_sm_next(sfp, SFP_S_TX_FAULT, T_FAULT_RECOVER); | |
395 | } | |
396 | } | |
397 | ||
398 | static void sfp_sm_mod_init(struct sfp *sfp) | |
399 | { | |
400 | sfp_module_tx_enable(sfp); | |
401 | ||
402 | /* Wait t_init before indicating that the link is up, provided the | |
403 | * current state indicates no TX_FAULT. If TX_FAULT clears before | |
404 | * this time, that's fine too. | |
405 | */ | |
406 | sfp_sm_next(sfp, SFP_S_INIT, T_INIT_JIFFIES); | |
407 | sfp->sm_retries = 5; | |
408 | ||
409 | /* Setting the serdes link mode is guesswork: there's no | |
410 | * field in the EEPROM which indicates what mode should | |
411 | * be used. | |
412 | * | |
413 | * If it's a gigabit-only fiber module, it probably does | |
414 | * not have a PHY, so switch to 802.3z negotiation mode. | |
415 | * Otherwise, switch to SGMII mode (which is required to | |
416 | * support non-gigabit speeds) and probe for a PHY. | |
417 | */ | |
418 | if (sfp->id.base.e1000_base_t || | |
419 | sfp->id.base.e100_base_lx || | |
420 | sfp->id.base.e100_base_fx) | |
421 | sfp_sm_probe_phy(sfp); | |
422 | } | |
423 | ||
424 | static int sfp_sm_mod_probe(struct sfp *sfp) | |
425 | { | |
426 | /* SFP module inserted - read I2C data */ | |
427 | struct sfp_eeprom_id id; | |
428 | char vendor[17]; | |
429 | char part[17]; | |
430 | char sn[17]; | |
431 | char date[9]; | |
432 | char rev[5]; | |
433 | u8 check; | |
434 | int err; | |
435 | ||
436 | err = sfp_read(sfp, false, 0, &id, sizeof(id)); | |
437 | if (err < 0) { | |
438 | dev_err(sfp->dev, "failed to read EEPROM: %d\n", err); | |
439 | return -EAGAIN; | |
440 | } | |
441 | ||
442 | if (err != sizeof(id)) { | |
443 | dev_err(sfp->dev, "EEPROM short read: %d\n", err); | |
444 | return -EAGAIN; | |
445 | } | |
446 | ||
447 | /* Validate the checksum over the base structure */ | |
448 | check = sfp_check(&id.base, sizeof(id.base) - 1); | |
449 | if (check != id.base.cc_base) { | |
450 | dev_err(sfp->dev, | |
451 | "EEPROM base structure checksum failure: 0x%02x\n", | |
452 | check); | |
453 | print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET, | |
454 | 16, 1, &id, sizeof(id.base) - 1, true); | |
455 | return -EINVAL; | |
456 | } | |
457 | ||
458 | check = sfp_check(&id.ext, sizeof(id.ext) - 1); | |
459 | if (check != id.ext.cc_ext) { | |
460 | dev_err(sfp->dev, | |
461 | "EEPROM extended structure checksum failure: 0x%02x\n", | |
462 | check); | |
463 | memset(&id.ext, 0, sizeof(id.ext)); | |
464 | } | |
465 | ||
466 | sfp->id = id; | |
467 | ||
468 | memcpy(vendor, sfp->id.base.vendor_name, 16); | |
469 | vendor[16] = '\0'; | |
470 | memcpy(part, sfp->id.base.vendor_pn, 16); | |
471 | part[16] = '\0'; | |
472 | memcpy(rev, sfp->id.base.vendor_rev, 4); | |
473 | rev[4] = '\0'; | |
474 | memcpy(sn, sfp->id.ext.vendor_sn, 16); | |
475 | sn[16] = '\0'; | |
476 | memcpy(date, sfp->id.ext.datecode, 8); | |
477 | date[8] = '\0'; | |
478 | ||
516b29ed FF |
479 | dev_info(sfp->dev, "module %s %s rev %s sn %s dc %s\n", |
480 | vendor, part, rev, sn, date); | |
73970055 RK |
481 | |
482 | /* We only support SFP modules, not the legacy GBIC modules. */ | |
483 | if (sfp->id.base.phys_id != SFP_PHYS_ID_SFP || | |
484 | sfp->id.base.phys_ext_id != SFP_PHYS_EXT_ID_SFP) { | |
485 | dev_err(sfp->dev, "module is not SFP - phys id 0x%02x 0x%02x\n", | |
486 | sfp->id.base.phys_id, sfp->id.base.phys_ext_id); | |
487 | return -EINVAL; | |
488 | } | |
489 | ||
ec7681bd RK |
490 | /* If the module requires address swap mode, warn about it */ |
491 | if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE) | |
492 | dev_warn(sfp->dev, | |
493 | "module address swap to access page 0xA2 is not supported.\n"); | |
494 | ||
73970055 RK |
495 | return sfp_module_insert(sfp->sfp_bus, &sfp->id); |
496 | } | |
497 | ||
498 | static void sfp_sm_mod_remove(struct sfp *sfp) | |
499 | { | |
500 | sfp_module_remove(sfp->sfp_bus); | |
501 | ||
502 | if (sfp->mod_phy) | |
503 | sfp_sm_phy_detach(sfp); | |
504 | ||
505 | sfp_module_tx_disable(sfp); | |
506 | ||
507 | memset(&sfp->id, 0, sizeof(sfp->id)); | |
508 | ||
509 | dev_info(sfp->dev, "module removed\n"); | |
510 | } | |
511 | ||
512 | static void sfp_sm_event(struct sfp *sfp, unsigned int event) | |
513 | { | |
514 | mutex_lock(&sfp->sm_mutex); | |
515 | ||
516 | dev_dbg(sfp->dev, "SM: enter %u:%u:%u event %u\n", | |
517 | sfp->sm_mod_state, sfp->sm_dev_state, sfp->sm_state, event); | |
518 | ||
519 | /* This state machine tracks the insert/remove state of | |
520 | * the module, and handles probing the on-board EEPROM. | |
521 | */ | |
522 | switch (sfp->sm_mod_state) { | |
523 | default: | |
524 | if (event == SFP_E_INSERT) { | |
525 | sfp_module_tx_disable(sfp); | |
526 | sfp_sm_ins_next(sfp, SFP_MOD_PROBE, T_PROBE_INIT); | |
527 | } | |
528 | break; | |
529 | ||
530 | case SFP_MOD_PROBE: | |
531 | if (event == SFP_E_REMOVE) { | |
532 | sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0); | |
533 | } else if (event == SFP_E_TIMEOUT) { | |
534 | int err = sfp_sm_mod_probe(sfp); | |
535 | ||
536 | if (err == 0) | |
537 | sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0); | |
538 | else if (err == -EAGAIN) | |
539 | sfp_sm_set_timer(sfp, T_PROBE_RETRY); | |
540 | else | |
541 | sfp_sm_ins_next(sfp, SFP_MOD_ERROR, 0); | |
542 | } | |
543 | break; | |
544 | ||
545 | case SFP_MOD_PRESENT: | |
546 | case SFP_MOD_ERROR: | |
547 | if (event == SFP_E_REMOVE) { | |
548 | sfp_sm_mod_remove(sfp); | |
549 | sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0); | |
550 | } | |
551 | break; | |
552 | } | |
553 | ||
554 | /* This state machine tracks the netdev up/down state */ | |
555 | switch (sfp->sm_dev_state) { | |
556 | default: | |
557 | if (event == SFP_E_DEV_UP) | |
558 | sfp->sm_dev_state = SFP_DEV_UP; | |
559 | break; | |
560 | ||
561 | case SFP_DEV_UP: | |
562 | if (event == SFP_E_DEV_DOWN) { | |
563 | /* If the module has a PHY, avoid raising TX disable | |
564 | * as this resets the PHY. Otherwise, raise it to | |
565 | * turn the laser off. | |
566 | */ | |
567 | if (!sfp->mod_phy) | |
568 | sfp_module_tx_disable(sfp); | |
569 | sfp->sm_dev_state = SFP_DEV_DOWN; | |
570 | } | |
571 | break; | |
572 | } | |
573 | ||
574 | /* Some events are global */ | |
575 | if (sfp->sm_state != SFP_S_DOWN && | |
576 | (sfp->sm_mod_state != SFP_MOD_PRESENT || | |
577 | sfp->sm_dev_state != SFP_DEV_UP)) { | |
578 | if (sfp->sm_state == SFP_S_LINK_UP && | |
579 | sfp->sm_dev_state == SFP_DEV_UP) | |
580 | sfp_sm_link_down(sfp); | |
581 | if (sfp->mod_phy) | |
582 | sfp_sm_phy_detach(sfp); | |
583 | sfp_sm_next(sfp, SFP_S_DOWN, 0); | |
584 | mutex_unlock(&sfp->sm_mutex); | |
585 | return; | |
586 | } | |
587 | ||
588 | /* The main state machine */ | |
589 | switch (sfp->sm_state) { | |
590 | case SFP_S_DOWN: | |
591 | if (sfp->sm_mod_state == SFP_MOD_PRESENT && | |
592 | sfp->sm_dev_state == SFP_DEV_UP) | |
593 | sfp_sm_mod_init(sfp); | |
594 | break; | |
595 | ||
596 | case SFP_S_INIT: | |
597 | if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) | |
598 | sfp_sm_fault(sfp, true); | |
599 | else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) | |
600 | sfp_sm_link_check_los(sfp); | |
601 | break; | |
602 | ||
603 | case SFP_S_WAIT_LOS: | |
604 | if (event == SFP_E_TX_FAULT) | |
605 | sfp_sm_fault(sfp, true); | |
710dfbb0 | 606 | else if (sfp_los_event_inactive(sfp, event)) |
73970055 RK |
607 | sfp_sm_link_up(sfp); |
608 | break; | |
609 | ||
610 | case SFP_S_LINK_UP: | |
611 | if (event == SFP_E_TX_FAULT) { | |
612 | sfp_sm_link_down(sfp); | |
613 | sfp_sm_fault(sfp, true); | |
710dfbb0 | 614 | } else if (sfp_los_event_active(sfp, event)) { |
73970055 RK |
615 | sfp_sm_link_down(sfp); |
616 | sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0); | |
617 | } | |
618 | break; | |
619 | ||
620 | case SFP_S_TX_FAULT: | |
621 | if (event == SFP_E_TIMEOUT) { | |
622 | sfp_module_tx_fault_reset(sfp); | |
623 | sfp_sm_next(sfp, SFP_S_REINIT, T_INIT_JIFFIES); | |
624 | } | |
625 | break; | |
626 | ||
627 | case SFP_S_REINIT: | |
628 | if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) { | |
629 | sfp_sm_fault(sfp, false); | |
630 | } else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) { | |
631 | dev_info(sfp->dev, "module transmit fault recovered\n"); | |
632 | sfp_sm_link_check_los(sfp); | |
633 | } | |
634 | break; | |
635 | ||
636 | case SFP_S_TX_DISABLE: | |
637 | break; | |
638 | } | |
639 | ||
640 | dev_dbg(sfp->dev, "SM: exit %u:%u:%u\n", | |
641 | sfp->sm_mod_state, sfp->sm_dev_state, sfp->sm_state); | |
642 | ||
643 | mutex_unlock(&sfp->sm_mutex); | |
644 | } | |
645 | ||
646 | static void sfp_start(struct sfp *sfp) | |
647 | { | |
648 | sfp_sm_event(sfp, SFP_E_DEV_UP); | |
649 | } | |
650 | ||
651 | static void sfp_stop(struct sfp *sfp) | |
652 | { | |
653 | sfp_sm_event(sfp, SFP_E_DEV_DOWN); | |
654 | } | |
655 | ||
656 | static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo) | |
657 | { | |
658 | /* locking... and check module is present */ | |
659 | ||
ec7681bd RK |
660 | if (sfp->id.ext.sff8472_compliance && |
661 | !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) { | |
73970055 RK |
662 | modinfo->type = ETH_MODULE_SFF_8472; |
663 | modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; | |
664 | } else { | |
665 | modinfo->type = ETH_MODULE_SFF_8079; | |
666 | modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN; | |
667 | } | |
668 | return 0; | |
669 | } | |
670 | ||
671 | static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee, | |
516b29ed | 672 | u8 *data) |
73970055 RK |
673 | { |
674 | unsigned int first, last, len; | |
675 | int ret; | |
676 | ||
677 | if (ee->len == 0) | |
678 | return -EINVAL; | |
679 | ||
680 | first = ee->offset; | |
681 | last = ee->offset + ee->len; | |
682 | if (first < ETH_MODULE_SFF_8079_LEN) { | |
683 | len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN); | |
684 | len -= first; | |
685 | ||
686 | ret = sfp->read(sfp, false, first, data, len); | |
687 | if (ret < 0) | |
688 | return ret; | |
689 | ||
690 | first += len; | |
691 | data += len; | |
692 | } | |
693 | if (first >= ETH_MODULE_SFF_8079_LEN && | |
694 | first < ETH_MODULE_SFF_8472_LEN) { | |
695 | len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN); | |
696 | len -= first; | |
697 | first -= ETH_MODULE_SFF_8079_LEN; | |
698 | ||
699 | ret = sfp->read(sfp, true, first, data, len); | |
700 | if (ret < 0) | |
701 | return ret; | |
702 | } | |
703 | return 0; | |
704 | } | |
705 | ||
706 | static const struct sfp_socket_ops sfp_module_ops = { | |
707 | .start = sfp_start, | |
708 | .stop = sfp_stop, | |
709 | .module_info = sfp_module_info, | |
710 | .module_eeprom = sfp_module_eeprom, | |
711 | }; | |
712 | ||
713 | static void sfp_timeout(struct work_struct *work) | |
714 | { | |
715 | struct sfp *sfp = container_of(work, struct sfp, timeout.work); | |
716 | ||
717 | rtnl_lock(); | |
718 | sfp_sm_event(sfp, SFP_E_TIMEOUT); | |
719 | rtnl_unlock(); | |
720 | } | |
721 | ||
722 | static void sfp_check_state(struct sfp *sfp) | |
723 | { | |
724 | unsigned int state, i, changed; | |
725 | ||
726 | state = sfp_get_state(sfp); | |
727 | changed = state ^ sfp->state; | |
728 | changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT; | |
729 | ||
730 | for (i = 0; i < GPIO_MAX; i++) | |
731 | if (changed & BIT(i)) | |
732 | dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_of_names[i], | |
733 | !!(sfp->state & BIT(i)), !!(state & BIT(i))); | |
734 | ||
735 | state |= sfp->state & (SFP_F_TX_DISABLE | SFP_F_RATE_SELECT); | |
736 | sfp->state = state; | |
737 | ||
738 | rtnl_lock(); | |
739 | if (changed & SFP_F_PRESENT) | |
740 | sfp_sm_event(sfp, state & SFP_F_PRESENT ? | |
741 | SFP_E_INSERT : SFP_E_REMOVE); | |
742 | ||
743 | if (changed & SFP_F_TX_FAULT) | |
744 | sfp_sm_event(sfp, state & SFP_F_TX_FAULT ? | |
745 | SFP_E_TX_FAULT : SFP_E_TX_CLEAR); | |
746 | ||
747 | if (changed & SFP_F_LOS) | |
748 | sfp_sm_event(sfp, state & SFP_F_LOS ? | |
749 | SFP_E_LOS_HIGH : SFP_E_LOS_LOW); | |
750 | rtnl_unlock(); | |
751 | } | |
752 | ||
753 | static irqreturn_t sfp_irq(int irq, void *data) | |
754 | { | |
755 | struct sfp *sfp = data; | |
756 | ||
757 | sfp_check_state(sfp); | |
758 | ||
759 | return IRQ_HANDLED; | |
760 | } | |
761 | ||
762 | static void sfp_poll(struct work_struct *work) | |
763 | { | |
764 | struct sfp *sfp = container_of(work, struct sfp, poll.work); | |
765 | ||
766 | sfp_check_state(sfp); | |
767 | mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); | |
768 | } | |
769 | ||
770 | static struct sfp *sfp_alloc(struct device *dev) | |
771 | { | |
772 | struct sfp *sfp; | |
773 | ||
774 | sfp = kzalloc(sizeof(*sfp), GFP_KERNEL); | |
775 | if (!sfp) | |
776 | return ERR_PTR(-ENOMEM); | |
777 | ||
778 | sfp->dev = dev; | |
779 | ||
780 | mutex_init(&sfp->sm_mutex); | |
781 | INIT_DELAYED_WORK(&sfp->poll, sfp_poll); | |
782 | INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout); | |
783 | ||
784 | return sfp; | |
785 | } | |
786 | ||
787 | static void sfp_cleanup(void *data) | |
788 | { | |
789 | struct sfp *sfp = data; | |
790 | ||
791 | cancel_delayed_work_sync(&sfp->poll); | |
792 | cancel_delayed_work_sync(&sfp->timeout); | |
793 | if (sfp->i2c_mii) { | |
794 | mdiobus_unregister(sfp->i2c_mii); | |
795 | mdiobus_free(sfp->i2c_mii); | |
796 | } | |
797 | if (sfp->i2c) | |
798 | i2c_put_adapter(sfp->i2c); | |
799 | kfree(sfp); | |
800 | } | |
801 | ||
802 | static int sfp_probe(struct platform_device *pdev) | |
803 | { | |
804 | struct sfp *sfp; | |
805 | bool poll = false; | |
806 | int irq, err, i; | |
807 | ||
808 | sfp = sfp_alloc(&pdev->dev); | |
809 | if (IS_ERR(sfp)) | |
810 | return PTR_ERR(sfp); | |
811 | ||
812 | platform_set_drvdata(pdev, sfp); | |
813 | ||
814 | err = devm_add_action(sfp->dev, sfp_cleanup, sfp); | |
815 | if (err < 0) | |
816 | return err; | |
817 | ||
818 | if (pdev->dev.of_node) { | |
819 | struct device_node *node = pdev->dev.of_node; | |
820 | struct device_node *np; | |
821 | ||
822 | np = of_parse_phandle(node, "i2c-bus", 0); | |
823 | if (np) { | |
824 | struct i2c_adapter *i2c; | |
825 | ||
826 | i2c = of_find_i2c_adapter_by_node(np); | |
827 | of_node_put(np); | |
828 | if (!i2c) | |
829 | return -EPROBE_DEFER; | |
830 | ||
831 | err = sfp_i2c_configure(sfp, i2c); | |
832 | if (err < 0) { | |
833 | i2c_put_adapter(i2c); | |
834 | return err; | |
835 | } | |
836 | } | |
837 | ||
838 | for (i = 0; i < GPIO_MAX; i++) { | |
839 | sfp->gpio[i] = devm_gpiod_get_optional(sfp->dev, | |
840 | gpio_of_names[i], gpio_flags[i]); | |
841 | if (IS_ERR(sfp->gpio[i])) | |
842 | return PTR_ERR(sfp->gpio[i]); | |
843 | } | |
844 | ||
845 | sfp->get_state = sfp_gpio_get_state; | |
846 | sfp->set_state = sfp_gpio_set_state; | |
847 | } | |
848 | ||
849 | sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops); | |
850 | if (!sfp->sfp_bus) | |
851 | return -ENOMEM; | |
852 | ||
853 | /* Get the initial state, and always signal TX disable, | |
854 | * since the network interface will not be up. | |
855 | */ | |
856 | sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE; | |
857 | ||
858 | if (sfp->gpio[GPIO_RATE_SELECT] && | |
859 | gpiod_get_value_cansleep(sfp->gpio[GPIO_RATE_SELECT])) | |
860 | sfp->state |= SFP_F_RATE_SELECT; | |
861 | sfp_set_state(sfp, sfp->state); | |
862 | sfp_module_tx_disable(sfp); | |
863 | rtnl_lock(); | |
864 | if (sfp->state & SFP_F_PRESENT) | |
865 | sfp_sm_event(sfp, SFP_E_INSERT); | |
866 | rtnl_unlock(); | |
867 | ||
868 | for (i = 0; i < GPIO_MAX; i++) { | |
869 | if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i]) | |
870 | continue; | |
871 | ||
872 | irq = gpiod_to_irq(sfp->gpio[i]); | |
873 | if (!irq) { | |
874 | poll = true; | |
875 | continue; | |
876 | } | |
877 | ||
878 | err = devm_request_threaded_irq(sfp->dev, irq, NULL, sfp_irq, | |
879 | IRQF_ONESHOT | | |
880 | IRQF_TRIGGER_RISING | | |
881 | IRQF_TRIGGER_FALLING, | |
882 | dev_name(sfp->dev), sfp); | |
883 | if (err) | |
884 | poll = true; | |
885 | } | |
886 | ||
887 | if (poll) | |
888 | mod_delayed_work(system_wq, &sfp->poll, poll_jiffies); | |
889 | ||
890 | return 0; | |
891 | } | |
892 | ||
893 | static int sfp_remove(struct platform_device *pdev) | |
894 | { | |
895 | struct sfp *sfp = platform_get_drvdata(pdev); | |
896 | ||
897 | sfp_unregister_socket(sfp->sfp_bus); | |
898 | ||
899 | return 0; | |
900 | } | |
901 | ||
902 | static const struct of_device_id sfp_of_match[] = { | |
903 | { .compatible = "sff,sfp", }, | |
904 | { }, | |
905 | }; | |
906 | MODULE_DEVICE_TABLE(of, sfp_of_match); | |
907 | ||
908 | static struct platform_driver sfp_driver = { | |
909 | .probe = sfp_probe, | |
910 | .remove = sfp_remove, | |
911 | .driver = { | |
912 | .name = "sfp", | |
913 | .of_match_table = sfp_of_match, | |
914 | }, | |
915 | }; | |
916 | ||
917 | static int sfp_init(void) | |
918 | { | |
919 | poll_jiffies = msecs_to_jiffies(100); | |
920 | ||
921 | return platform_driver_register(&sfp_driver); | |
922 | } | |
923 | module_init(sfp_init); | |
924 | ||
925 | static void sfp_exit(void) | |
926 | { | |
927 | platform_driver_unregister(&sfp_driver); | |
928 | } | |
929 | module_exit(sfp_exit); | |
930 | ||
931 | MODULE_ALIAS("platform:sfp"); | |
932 | MODULE_AUTHOR("Russell King"); | |
933 | MODULE_LICENSE("GPL v2"); |