1#include <linux/delay.h>
2#include <linux/gpio/consumer.h>
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
19enum {
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
60static const char *gpio_of_names[] = {
61 "mod-def0",
62 "los",
63 "tx-fault",
64 "tx-disable",
65 "rate-select0",
66};
67
68static 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
81
82
83
84
85
86
87
88#define T_PROBE_INIT msecs_to_jiffies(300)
89#define T_PROBE_RETRY msecs_to_jiffies(100)
90
91
92
93
94#define SFP_PHY_ADDR 22
95
96
97#define T_PHY_RESET_MS 50
98
99static DEFINE_MUTEX(sfp_mutex);
100
101struct 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
126static unsigned long poll_jiffies;
127
128static 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
144static void sfp_gpio_set_state(struct sfp *sfp, unsigned int state)
145{
146 if (state & SFP_F_PRESENT) {
147
148 if (sfp->gpio[GPIO_TX_DISABLE])
149 gpiod_direction_output(sfp->gpio[GPIO_TX_DISABLE],
150 state & SFP_F_TX_DISABLE);
151 if (state & SFP_F_RATE_SELECT)
152 gpiod_direction_output(sfp->gpio[GPIO_RATE_SELECT],
153 state & SFP_F_RATE_SELECT);
154 } else {
155
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
163static int sfp__i2c_read(struct i2c_adapter *i2c, u8 bus_addr, u8 dev_addr,
164 void *buf, size_t len)
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
185static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 addr, void *buf,
186 size_t len)
187{
188 return sfp__i2c_read(sfp->i2c, a2 ? 0x51 : 0x50, addr, buf, len);
189}
190
191static 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
220
221static unsigned int sfp_get_state(struct sfp *sfp)
222{
223 return sfp->get_state(sfp);
224}
225
226static void sfp_set_state(struct sfp *sfp, unsigned int state)
227{
228 sfp->set_state(sfp, state);
229}
230
231static 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
236static 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
247static 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
255static 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
263static 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
278static 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
287static 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
294static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state,
295 unsigned int timeout)
296{
297 sfp->sm_mod_state = state;
298 sfp_sm_set_timer(sfp, timeout);
299}
300
301static 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
310static 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
339static 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
345static void sfp_sm_link_down(struct sfp *sfp)
346{
347 sfp_link_down(sfp->sfp_bus);
348}
349
350static void sfp_sm_link_check_los(struct sfp *sfp)
351{
352 unsigned int los = sfp->state & SFP_F_LOS;
353
354
355
356
357 if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED))
358 los ^= SFP_F_LOS;
359 else if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL)))
360 los = 0;
361
362 if (los)
363 sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
364 else
365 sfp_sm_link_up(sfp);
366}
367
368static 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
376static 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
384static void sfp_sm_fault(struct sfp *sfp, bool warn)
385{
386 if (sfp->sm_retries && !--sfp->sm_retries) {
387 dev_err(sfp->dev,
388 "module persistently indicates fault, disabling\n");
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
398static void sfp_sm_mod_init(struct sfp *sfp)
399{
400 sfp_module_tx_enable(sfp);
401
402
403
404
405
406 sfp_sm_next(sfp, SFP_S_INIT, T_INIT_JIFFIES);
407 sfp->sm_retries = 5;
408
409
410
411
412
413
414
415
416
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
424static int sfp_sm_mod_probe(struct sfp *sfp)
425{
426
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
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
479 dev_info(sfp->dev, "module %s %s rev %s sn %s dc %s\n",
480 vendor, part, rev, sn, date);
481
482
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
490
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
495 return sfp_module_insert(sfp->sfp_bus, &sfp->id);
496}
497
498static 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
512static 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
520
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
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
564
565
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
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
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);
606 else if (sfp_los_event_inactive(sfp, event))
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);
614 } else if (sfp_los_event_active(sfp, event)) {
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
646static void sfp_start(struct sfp *sfp)
647{
648 sfp_sm_event(sfp, SFP_E_DEV_UP);
649}
650
651static void sfp_stop(struct sfp *sfp)
652{
653 sfp_sm_event(sfp, SFP_E_DEV_DOWN);
654}
655
656static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo)
657{
658
659
660 if (sfp->id.ext.sff8472_compliance &&
661 !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) {
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
671static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee,
672 u8 *data)
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
706static 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
713static 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
722static 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
753static 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
762static 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
770static 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
787static 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
802static 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
854
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
893static 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
902static const struct of_device_id sfp_of_match[] = {
903 { .compatible = "sff,sfp", },
904 { },
905};
906MODULE_DEVICE_TABLE(of, sfp_of_match);
907
908static 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
917static int sfp_init(void)
918{
919 poll_jiffies = msecs_to_jiffies(100);
920
921 return platform_driver_register(&sfp_driver);
922}
923module_init(sfp_init);
924
925static void sfp_exit(void)
926{
927 platform_driver_unregister(&sfp_driver);
928}
929module_exit(sfp_exit);
930
931MODULE_ALIAS("platform:sfp");
932MODULE_AUTHOR("Russell King");
933MODULE_LICENSE("GPL v2");
934
