1// SPDX-License-Identifier: GPL-2.0
   2#include <linux/acpi.h>
   3#include <linux/ctype.h>
 
   4#include <linux/delay.h>
   5#include <linux/gpio/consumer.h>
   6#include <linux/hwmon.h>
   7#include <linux/i2c.h>
   8#include <linux/interrupt.h>
   9#include <linux/jiffies.h>
 
  10#include <linux/module.h>
  11#include <linux/mutex.h>
  12#include <linux/of.h>
  13#include <linux/phy.h>
  14#include <linux/platform_device.h>
  15#include <linux/rtnetlink.h>
  16#include <linux/slab.h>
  17#include <linux/workqueue.h>
  18
  19#include "mdio-i2c.h"
  20#include "sfp.h"
  21#include "swphy.h"
  22
  23enum {
  24	GPIO_MODDEF0,
  25	GPIO_LOS,
  26	GPIO_TX_FAULT,
  27	GPIO_TX_DISABLE,
  28	GPIO_RATE_SELECT,
  29	GPIO_MAX,
  30
  31	SFP_F_PRESENT = BIT(GPIO_MODDEF0),
  32	SFP_F_LOS = BIT(GPIO_LOS),
  33	SFP_F_TX_FAULT = BIT(GPIO_TX_FAULT),
  34	SFP_F_TX_DISABLE = BIT(GPIO_TX_DISABLE),
  35	SFP_F_RATE_SELECT = BIT(GPIO_RATE_SELECT),
  36
  37	SFP_E_INSERT = 0,
  38	SFP_E_REMOVE,
 
 
  39	SFP_E_DEV_DOWN,
  40	SFP_E_DEV_UP,
  41	SFP_E_TX_FAULT,
  42	SFP_E_TX_CLEAR,
  43	SFP_E_LOS_HIGH,
  44	SFP_E_LOS_LOW,
  45	SFP_E_TIMEOUT,
  46
  47	SFP_MOD_EMPTY = 0,
 
  48	SFP_MOD_PROBE,
 
  49	SFP_MOD_HPOWER,
 
  50	SFP_MOD_PRESENT,
  51	SFP_MOD_ERROR,
  52
  53	SFP_DEV_DOWN = 0,
 
  54	SFP_DEV_UP,
  55
  56	SFP_S_DOWN = 0,
 
 
  57	SFP_S_INIT,
 
 
  58	SFP_S_WAIT_LOS,
  59	SFP_S_LINK_UP,
  60	SFP_S_TX_FAULT,
  61	SFP_S_REINIT,
  62	SFP_S_TX_DISABLE,
  63};
  64
  65static const char  * const mod_state_strings[] = {
  66	[SFP_MOD_EMPTY] = "empty",
 
  67	[SFP_MOD_PROBE] = "probe",
 
  68	[SFP_MOD_HPOWER] = "hpower",
 
  69	[SFP_MOD_PRESENT] = "present",
  70	[SFP_MOD_ERROR] = "error",
  71};
  72
  73static const char *mod_state_to_str(unsigned short mod_state)
  74{
  75	if (mod_state >= ARRAY_SIZE(mod_state_strings))
  76		return "Unknown module state";
  77	return mod_state_strings[mod_state];
  78}
  79
  80static const char * const dev_state_strings[] = {
 
  81	[SFP_DEV_DOWN] = "down",
  82	[SFP_DEV_UP] = "up",
  83};
  84
  85static const char *dev_state_to_str(unsigned short dev_state)
  86{
  87	if (dev_state >= ARRAY_SIZE(dev_state_strings))
  88		return "Unknown device state";
  89	return dev_state_strings[dev_state];
  90}
  91
  92static const char * const event_strings[] = {
  93	[SFP_E_INSERT] = "insert",
  94	[SFP_E_REMOVE] = "remove",
 
 
  95	[SFP_E_DEV_DOWN] = "dev_down",
  96	[SFP_E_DEV_UP] = "dev_up",
  97	[SFP_E_TX_FAULT] = "tx_fault",
  98	[SFP_E_TX_CLEAR] = "tx_clear",
  99	[SFP_E_LOS_HIGH] = "los_high",
 100	[SFP_E_LOS_LOW] = "los_low",
 101	[SFP_E_TIMEOUT] = "timeout",
 102};
 103
 104static const char *event_to_str(unsigned short event)
 105{
 106	if (event >= ARRAY_SIZE(event_strings))
 107		return "Unknown event";
 108	return event_strings[event];
 109}
 110
 111static const char * const sm_state_strings[] = {
 112	[SFP_S_DOWN] = "down",
 
 
 113	[SFP_S_INIT] = "init",
 
 
 114	[SFP_S_WAIT_LOS] = "wait_los",
 115	[SFP_S_LINK_UP] = "link_up",
 116	[SFP_S_TX_FAULT] = "tx_fault",
 117	[SFP_S_REINIT] = "reinit",
 118	[SFP_S_TX_DISABLE] = "rx_disable",
 119};
 120
 121static const char *sm_state_to_str(unsigned short sm_state)
 122{
 123	if (sm_state >= ARRAY_SIZE(sm_state_strings))
 124		return "Unknown state";
 125	return sm_state_strings[sm_state];
 126}
 127
 128static const char *gpio_of_names[] = {
 129	"mod-def0",
 130	"los",
 131	"tx-fault",
 132	"tx-disable",
 133	"rate-select0",
 134};
 135
 136static const enum gpiod_flags gpio_flags[] = {
 137	GPIOD_IN,
 138	GPIOD_IN,
 139	GPIOD_IN,
 140	GPIOD_ASIS,
 141	GPIOD_ASIS,
 142};
 143
 144#define T_INIT_JIFFIES	msecs_to_jiffies(300)
 145#define T_RESET_US	10
 146#define T_FAULT_RECOVER	msecs_to_jiffies(1000)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 147
 148/* SFP module presence detection is poor: the three MOD DEF signals are
 149 * the same length on the PCB, which means it's possible for MOD DEF 0 to
 150 * connect before the I2C bus on MOD DEF 1/2.
 151 *
 152 * The SFP MSA specifies 300ms as t_init (the time taken for TX_FAULT to
 153 * be deasserted) but makes no mention of the earliest time before we can
 154 * access the I2C EEPROM.  However, Avago modules require 300ms.
 155 */
 156#define T_PROBE_INIT	msecs_to_jiffies(300)
 157#define T_HPOWER_LEVEL	msecs_to_jiffies(300)
 158#define T_PROBE_RETRY	msecs_to_jiffies(100)
 
 
 
 159
 160/* SFP modules appear to always have their PHY configured for bus address
 161 * 0x56 (which with mdio-i2c, translates to a PHY address of 22).
 162 */
 163#define SFP_PHY_ADDR	22
 164
 165/* Give this long for the PHY to reset. */
 166#define T_PHY_RESET_MS	50
 167
 168struct sff_data {
 169	unsigned int gpios;
 170	bool (*module_supported)(const struct sfp_eeprom_id *id);
 171};
 172
 173struct sfp {
 174	struct device *dev;
 175	struct i2c_adapter *i2c;
 176	struct mii_bus *i2c_mii;
 177	struct sfp_bus *sfp_bus;
 178	struct phy_device *mod_phy;
 179	const struct sff_data *type;
 
 180	u32 max_power_mW;
 181
 182	unsigned int (*get_state)(struct sfp *);
 183	void (*set_state)(struct sfp *, unsigned int);
 184	int (*read)(struct sfp *, bool, u8, void *, size_t);
 185	int (*write)(struct sfp *, bool, u8, void *, size_t);
 186
 187	struct gpio_desc *gpio[GPIO_MAX];
 188	int gpio_irq[GPIO_MAX];
 189
 190	bool attached;
 
 191	struct mutex st_mutex;			/* Protects state */
 
 192	unsigned int state;
 193	struct delayed_work poll;
 194	struct delayed_work timeout;
 195	struct mutex sm_mutex;			/* Protects state machine */
 196	unsigned char sm_mod_state;
 
 
 197	unsigned char sm_dev_state;
 198	unsigned short sm_state;
 199	unsigned int sm_retries;
 
 200
 201	struct sfp_eeprom_id id;
 
 
 
 202#if IS_ENABLED(CONFIG_HWMON)
 203	struct sfp_diag diag;
 
 
 204	struct device *hwmon_dev;
 205	char *hwmon_name;
 206#endif
 207
 
 
 
 208};
 209
 210static bool sff_module_supported(const struct sfp_eeprom_id *id)
 211{
 212	return id->base.phys_id == SFP_PHYS_ID_SFF &&
 213	       id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
 214}
 215
 216static const struct sff_data sff_data = {
 217	.gpios = SFP_F_LOS | SFP_F_TX_FAULT | SFP_F_TX_DISABLE,
 218	.module_supported = sff_module_supported,
 219};
 220
 221static bool sfp_module_supported(const struct sfp_eeprom_id *id)
 222{
 223	return id->base.phys_id == SFP_PHYS_ID_SFP &&
 224	       id->base.phys_ext_id == SFP_PHYS_EXT_ID_SFP;
 
 
 
 
 
 
 
 
 
 
 
 
 
 225}
 226
 227static const struct sff_data sfp_data = {
 228	.gpios = SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT |
 229		 SFP_F_TX_DISABLE | SFP_F_RATE_SELECT,
 230	.module_supported = sfp_module_supported,
 231};
 232
 233static const struct of_device_id sfp_of_match[] = {
 234	{ .compatible = "sff,sff", .data = &sff_data, },
 235	{ .compatible = "sff,sfp", .data = &sfp_data, },
 236	{ },
 237};
 238MODULE_DEVICE_TABLE(of, sfp_of_match);
 239
 240static unsigned long poll_jiffies;
 241
 242static unsigned int sfp_gpio_get_state(struct sfp *sfp)
 243{
 244	unsigned int i, state, v;
 245
 246	for (i = state = 0; i < GPIO_MAX; i++) {
 247		if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i])
 248			continue;
 249
 250		v = gpiod_get_value_cansleep(sfp->gpio[i]);
 251		if (v)
 252			state |= BIT(i);
 253	}
 254
 255	return state;
 256}
 257
 258static unsigned int sff_gpio_get_state(struct sfp *sfp)
 259{
 260	return sfp_gpio_get_state(sfp) | SFP_F_PRESENT;
 261}
 262
 263static void sfp_gpio_set_state(struct sfp *sfp, unsigned int state)
 264{
 265	if (state & SFP_F_PRESENT) {
 266		/* If the module is present, drive the signals */
 267		if (sfp->gpio[GPIO_TX_DISABLE])
 268			gpiod_direction_output(sfp->gpio[GPIO_TX_DISABLE],
 269					       state & SFP_F_TX_DISABLE);
 270		if (state & SFP_F_RATE_SELECT)
 271			gpiod_direction_output(sfp->gpio[GPIO_RATE_SELECT],
 272					       state & SFP_F_RATE_SELECT);
 273	} else {
 274		/* Otherwise, let them float to the pull-ups */
 275		if (sfp->gpio[GPIO_TX_DISABLE])
 276			gpiod_direction_input(sfp->gpio[GPIO_TX_DISABLE]);
 277		if (state & SFP_F_RATE_SELECT)
 278			gpiod_direction_input(sfp->gpio[GPIO_RATE_SELECT]);
 279	}
 280}
 281
 282static int sfp_i2c_read(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,
 283			size_t len)
 284{
 285	struct i2c_msg msgs[2];
 286	u8 bus_addr = a2 ? 0x51 : 0x50;
 
 287	size_t this_len;
 288	int ret;
 289
 290	msgs[0].addr = bus_addr;
 291	msgs[0].flags = 0;
 292	msgs[0].len = 1;
 293	msgs[0].buf = &dev_addr;
 294	msgs[1].addr = bus_addr;
 295	msgs[1].flags = I2C_M_RD;
 296	msgs[1].len = len;
 297	msgs[1].buf = buf;
 298
 299	while (len) {
 300		this_len = len;
 301		if (this_len > 16)
 302			this_len = 16;
 303
 304		msgs[1].len = this_len;
 305
 306		ret = i2c_transfer(sfp->i2c, msgs, ARRAY_SIZE(msgs));
 307		if (ret < 0)
 308			return ret;
 309
 310		if (ret != ARRAY_SIZE(msgs))
 311			break;
 312
 313		msgs[1].buf += this_len;
 314		dev_addr += this_len;
 315		len -= this_len;
 316	}
 317
 318	return msgs[1].buf - (u8 *)buf;
 319}
 320
 321static int sfp_i2c_write(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,
 322	size_t len)
 323{
 324	struct i2c_msg msgs[1];
 325	u8 bus_addr = a2 ? 0x51 : 0x50;
 326	int ret;
 327
 328	msgs[0].addr = bus_addr;
 329	msgs[0].flags = 0;
 330	msgs[0].len = 1 + len;
 331	msgs[0].buf = kmalloc(1 + len, GFP_KERNEL);
 332	if (!msgs[0].buf)
 333		return -ENOMEM;
 334
 335	msgs[0].buf[0] = dev_addr;
 336	memcpy(&msgs[0].buf[1], buf, len);
 337
 338	ret = i2c_transfer(sfp->i2c, msgs, ARRAY_SIZE(msgs));
 339
 340	kfree(msgs[0].buf);
 341
 342	if (ret < 0)
 343		return ret;
 344
 345	return ret == ARRAY_SIZE(msgs) ? len : 0;
 346}
 347
 348static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c)
 349{
 350	struct mii_bus *i2c_mii;
 351	int ret;
 352
 353	if (!i2c_check_functionality(i2c, I2C_FUNC_I2C))
 354		return -EINVAL;
 355
 356	sfp->i2c = i2c;
 357	sfp->read = sfp_i2c_read;
 358	sfp->write = sfp_i2c_write;
 359
 360	i2c_mii = mdio_i2c_alloc(sfp->dev, i2c);
 361	if (IS_ERR(i2c_mii))
 362		return PTR_ERR(i2c_mii);
 363
 364	i2c_mii->name = "SFP I2C Bus";
 365	i2c_mii->phy_mask = ~0;
 366
 367	ret = mdiobus_register(i2c_mii);
 368	if (ret < 0) {
 369		mdiobus_free(i2c_mii);
 370		return ret;
 371	}
 372
 373	sfp->i2c_mii = i2c_mii;
 374
 375	return 0;
 376}
 377
 378/* Interface */
 379static unsigned int sfp_get_state(struct sfp *sfp)
 380{
 381	return sfp->get_state(sfp);
 382}
 383
 384static void sfp_set_state(struct sfp *sfp, unsigned int state)
 385{
 386	sfp->set_state(sfp, state);
 387}
 388
 389static int sfp_read(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len)
 390{
 391	return sfp->read(sfp, a2, addr, buf, len);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 392}
 393
 394static int sfp_write(struct sfp *sfp, bool a2, u8 addr, void *buf, size_t len)
 395{
 396	return sfp->write(sfp, a2, addr, buf, len);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 397}
 398
 399static unsigned int sfp_check(void *buf, size_t len)
 400{
 401	u8 *p, check;
 402
 403	for (p = buf, check = 0; len; p++, len--)
 404		check += *p;
 405
 406	return check;
 407}
 408
 409/* hwmon */
 410#if IS_ENABLED(CONFIG_HWMON)
 411static umode_t sfp_hwmon_is_visible(const void *data,
 412				    enum hwmon_sensor_types type,
 413				    u32 attr, int channel)
 414{
 415	const struct sfp *sfp = data;
 416
 417	switch (type) {
 418	case hwmon_temp:
 419		switch (attr) {
 420		case hwmon_temp_min_alarm:
 421		case hwmon_temp_max_alarm:
 422		case hwmon_temp_lcrit_alarm:
 423		case hwmon_temp_crit_alarm:
 424		case hwmon_temp_min:
 425		case hwmon_temp_max:
 426		case hwmon_temp_lcrit:
 427		case hwmon_temp_crit:
 428			if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
 429				return 0;
 430			/* fall through */
 431		case hwmon_temp_input:
 432		case hwmon_temp_label:
 433			return 0444;
 434		default:
 435			return 0;
 436		}
 437	case hwmon_in:
 438		switch (attr) {
 439		case hwmon_in_min_alarm:
 440		case hwmon_in_max_alarm:
 441		case hwmon_in_lcrit_alarm:
 442		case hwmon_in_crit_alarm:
 443		case hwmon_in_min:
 444		case hwmon_in_max:
 445		case hwmon_in_lcrit:
 446		case hwmon_in_crit:
 447			if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
 448				return 0;
 449			/* fall through */
 450		case hwmon_in_input:
 451		case hwmon_in_label:
 452			return 0444;
 453		default:
 454			return 0;
 455		}
 456	case hwmon_curr:
 457		switch (attr) {
 458		case hwmon_curr_min_alarm:
 459		case hwmon_curr_max_alarm:
 460		case hwmon_curr_lcrit_alarm:
 461		case hwmon_curr_crit_alarm:
 462		case hwmon_curr_min:
 463		case hwmon_curr_max:
 464		case hwmon_curr_lcrit:
 465		case hwmon_curr_crit:
 466			if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
 467				return 0;
 468			/* fall through */
 469		case hwmon_curr_input:
 470		case hwmon_curr_label:
 471			return 0444;
 472		default:
 473			return 0;
 474		}
 475	case hwmon_power:
 476		/* External calibration of receive power requires
 477		 * floating point arithmetic. Doing that in the kernel
 478		 * is not easy, so just skip it. If the module does
 479		 * not require external calibration, we can however
 480		 * show receiver power, since FP is then not needed.
 481		 */
 482		if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL &&
 483		    channel == 1)
 484			return 0;
 485		switch (attr) {
 486		case hwmon_power_min_alarm:
 487		case hwmon_power_max_alarm:
 488		case hwmon_power_lcrit_alarm:
 489		case hwmon_power_crit_alarm:
 490		case hwmon_power_min:
 491		case hwmon_power_max:
 492		case hwmon_power_lcrit:
 493		case hwmon_power_crit:
 494			if (!(sfp->id.ext.enhopts & SFP_ENHOPTS_ALARMWARN))
 495				return 0;
 496			/* fall through */
 497		case hwmon_power_input:
 498		case hwmon_power_label:
 499			return 0444;
 500		default:
 501			return 0;
 502		}
 503	default:
 504		return 0;
 505	}
 506}
 507
 508static int sfp_hwmon_read_sensor(struct sfp *sfp, int reg, long *value)
 509{
 510	__be16 val;
 511	int err;
 512
 513	err = sfp_read(sfp, true, reg, &val, sizeof(val));
 514	if (err < 0)
 515		return err;
 516
 517	*value = be16_to_cpu(val);
 518
 519	return 0;
 520}
 521
 522static void sfp_hwmon_to_rx_power(long *value)
 523{
 524	*value = DIV_ROUND_CLOSEST(*value, 10);
 525}
 526
 527static void sfp_hwmon_calibrate(struct sfp *sfp, unsigned int slope, int offset,
 528				long *value)
 529{
 530	if (sfp->id.ext.diagmon & SFP_DIAGMON_EXT_CAL)
 531		*value = DIV_ROUND_CLOSEST(*value * slope, 256) + offset;
 532}
 533
 534static void sfp_hwmon_calibrate_temp(struct sfp *sfp, long *value)
 535{
 536	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_t_slope),
 537			    be16_to_cpu(sfp->diag.cal_t_offset), value);
 538
 539	if (*value >= 0x8000)
 540		*value -= 0x10000;
 541
 542	*value = DIV_ROUND_CLOSEST(*value * 1000, 256);
 543}
 544
 545static void sfp_hwmon_calibrate_vcc(struct sfp *sfp, long *value)
 546{
 547	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_v_slope),
 548			    be16_to_cpu(sfp->diag.cal_v_offset), value);
 549
 550	*value = DIV_ROUND_CLOSEST(*value, 10);
 551}
 552
 553static void sfp_hwmon_calibrate_bias(struct sfp *sfp, long *value)
 554{
 555	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txi_slope),
 556			    be16_to_cpu(sfp->diag.cal_txi_offset), value);
 557
 558	*value = DIV_ROUND_CLOSEST(*value, 500);
 559}
 560
 561static void sfp_hwmon_calibrate_tx_power(struct sfp *sfp, long *value)
 562{
 563	sfp_hwmon_calibrate(sfp, be16_to_cpu(sfp->diag.cal_txpwr_slope),
 564			    be16_to_cpu(sfp->diag.cal_txpwr_offset), value);
 565
 566	*value = DIV_ROUND_CLOSEST(*value, 10);
 567}
 568
 569static int sfp_hwmon_read_temp(struct sfp *sfp, int reg, long *value)
 570{
 571	int err;
 572
 573	err = sfp_hwmon_read_sensor(sfp, reg, value);
 574	if (err < 0)
 575		return err;
 576
 577	sfp_hwmon_calibrate_temp(sfp, value);
 578
 579	return 0;
 580}
 581
 582static int sfp_hwmon_read_vcc(struct sfp *sfp, int reg, long *value)
 583{
 584	int err;
 585
 586	err = sfp_hwmon_read_sensor(sfp, reg, value);
 587	if (err < 0)
 588		return err;
 589
 590	sfp_hwmon_calibrate_vcc(sfp, value);
 591
 592	return 0;
 593}
 594
 595static int sfp_hwmon_read_bias(struct sfp *sfp, int reg, long *value)
 596{
 597	int err;
 598
 599	err = sfp_hwmon_read_sensor(sfp, reg, value);
 600	if (err < 0)
 601		return err;
 602
 603	sfp_hwmon_calibrate_bias(sfp, value);
 604
 605	return 0;
 606}
 607
 608static int sfp_hwmon_read_tx_power(struct sfp *sfp, int reg, long *value)
 609{
 610	int err;
 611
 612	err = sfp_hwmon_read_sensor(sfp, reg, value);
 613	if (err < 0)
 614		return err;
 615
 616	sfp_hwmon_calibrate_tx_power(sfp, value);
 617
 618	return 0;
 619}
 620
 621static int sfp_hwmon_read_rx_power(struct sfp *sfp, int reg, long *value)
 622{
 623	int err;
 624
 625	err = sfp_hwmon_read_sensor(sfp, reg, value);
 626	if (err < 0)
 627		return err;
 628
 629	sfp_hwmon_to_rx_power(value);
 630
 631	return 0;
 632}
 633
 634static int sfp_hwmon_temp(struct sfp *sfp, u32 attr, long *value)
 635{
 636	u8 status;
 637	int err;
 638
 639	switch (attr) {
 640	case hwmon_temp_input:
 641		return sfp_hwmon_read_temp(sfp, SFP_TEMP, value);
 642
 643	case hwmon_temp_lcrit:
 644		*value = be16_to_cpu(sfp->diag.temp_low_alarm);
 645		sfp_hwmon_calibrate_temp(sfp, value);
 646		return 0;
 647
 648	case hwmon_temp_min:
 649		*value = be16_to_cpu(sfp->diag.temp_low_warn);
 650		sfp_hwmon_calibrate_temp(sfp, value);
 651		return 0;
 652	case hwmon_temp_max:
 653		*value = be16_to_cpu(sfp->diag.temp_high_warn);
 654		sfp_hwmon_calibrate_temp(sfp, value);
 655		return 0;
 656
 657	case hwmon_temp_crit:
 658		*value = be16_to_cpu(sfp->diag.temp_high_alarm);
 659		sfp_hwmon_calibrate_temp(sfp, value);
 660		return 0;
 661
 662	case hwmon_temp_lcrit_alarm:
 663		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 664		if (err < 0)
 665			return err;
 666
 667		*value = !!(status & SFP_ALARM0_TEMP_LOW);
 668		return 0;
 669
 670	case hwmon_temp_min_alarm:
 671		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 672		if (err < 0)
 673			return err;
 674
 675		*value = !!(status & SFP_WARN0_TEMP_LOW);
 676		return 0;
 677
 678	case hwmon_temp_max_alarm:
 679		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 680		if (err < 0)
 681			return err;
 682
 683		*value = !!(status & SFP_WARN0_TEMP_HIGH);
 684		return 0;
 685
 686	case hwmon_temp_crit_alarm:
 687		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 688		if (err < 0)
 689			return err;
 690
 691		*value = !!(status & SFP_ALARM0_TEMP_HIGH);
 692		return 0;
 693	default:
 694		return -EOPNOTSUPP;
 695	}
 696
 697	return -EOPNOTSUPP;
 698}
 699
 700static int sfp_hwmon_vcc(struct sfp *sfp, u32 attr, long *value)
 701{
 702	u8 status;
 703	int err;
 704
 705	switch (attr) {
 706	case hwmon_in_input:
 707		return sfp_hwmon_read_vcc(sfp, SFP_VCC, value);
 708
 709	case hwmon_in_lcrit:
 710		*value = be16_to_cpu(sfp->diag.volt_low_alarm);
 711		sfp_hwmon_calibrate_vcc(sfp, value);
 712		return 0;
 713
 714	case hwmon_in_min:
 715		*value = be16_to_cpu(sfp->diag.volt_low_warn);
 716		sfp_hwmon_calibrate_vcc(sfp, value);
 717		return 0;
 718
 719	case hwmon_in_max:
 720		*value = be16_to_cpu(sfp->diag.volt_high_warn);
 721		sfp_hwmon_calibrate_vcc(sfp, value);
 722		return 0;
 723
 724	case hwmon_in_crit:
 725		*value = be16_to_cpu(sfp->diag.volt_high_alarm);
 726		sfp_hwmon_calibrate_vcc(sfp, value);
 727		return 0;
 728
 729	case hwmon_in_lcrit_alarm:
 730		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 731		if (err < 0)
 732			return err;
 733
 734		*value = !!(status & SFP_ALARM0_VCC_LOW);
 735		return 0;
 736
 737	case hwmon_in_min_alarm:
 738		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 739		if (err < 0)
 740			return err;
 741
 742		*value = !!(status & SFP_WARN0_VCC_LOW);
 743		return 0;
 744
 745	case hwmon_in_max_alarm:
 746		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 747		if (err < 0)
 748			return err;
 749
 750		*value = !!(status & SFP_WARN0_VCC_HIGH);
 751		return 0;
 752
 753	case hwmon_in_crit_alarm:
 754		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 755		if (err < 0)
 756			return err;
 757
 758		*value = !!(status & SFP_ALARM0_VCC_HIGH);
 759		return 0;
 760	default:
 761		return -EOPNOTSUPP;
 762	}
 763
 764	return -EOPNOTSUPP;
 765}
 766
 767static int sfp_hwmon_bias(struct sfp *sfp, u32 attr, long *value)
 768{
 769	u8 status;
 770	int err;
 771
 772	switch (attr) {
 773	case hwmon_curr_input:
 774		return sfp_hwmon_read_bias(sfp, SFP_TX_BIAS, value);
 775
 776	case hwmon_curr_lcrit:
 777		*value = be16_to_cpu(sfp->diag.bias_low_alarm);
 778		sfp_hwmon_calibrate_bias(sfp, value);
 779		return 0;
 780
 781	case hwmon_curr_min:
 782		*value = be16_to_cpu(sfp->diag.bias_low_warn);
 783		sfp_hwmon_calibrate_bias(sfp, value);
 784		return 0;
 785
 786	case hwmon_curr_max:
 787		*value = be16_to_cpu(sfp->diag.bias_high_warn);
 788		sfp_hwmon_calibrate_bias(sfp, value);
 789		return 0;
 790
 791	case hwmon_curr_crit:
 792		*value = be16_to_cpu(sfp->diag.bias_high_alarm);
 793		sfp_hwmon_calibrate_bias(sfp, value);
 794		return 0;
 795
 796	case hwmon_curr_lcrit_alarm:
 797		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 798		if (err < 0)
 799			return err;
 800
 801		*value = !!(status & SFP_ALARM0_TX_BIAS_LOW);
 802		return 0;
 803
 804	case hwmon_curr_min_alarm:
 805		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 806		if (err < 0)
 807			return err;
 808
 809		*value = !!(status & SFP_WARN0_TX_BIAS_LOW);
 810		return 0;
 811
 812	case hwmon_curr_max_alarm:
 813		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 814		if (err < 0)
 815			return err;
 816
 817		*value = !!(status & SFP_WARN0_TX_BIAS_HIGH);
 818		return 0;
 819
 820	case hwmon_curr_crit_alarm:
 821		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 822		if (err < 0)
 823			return err;
 824
 825		*value = !!(status & SFP_ALARM0_TX_BIAS_HIGH);
 826		return 0;
 827	default:
 828		return -EOPNOTSUPP;
 829	}
 830
 831	return -EOPNOTSUPP;
 832}
 833
 834static int sfp_hwmon_tx_power(struct sfp *sfp, u32 attr, long *value)
 835{
 836	u8 status;
 837	int err;
 838
 839	switch (attr) {
 840	case hwmon_power_input:
 841		return sfp_hwmon_read_tx_power(sfp, SFP_TX_POWER, value);
 842
 843	case hwmon_power_lcrit:
 844		*value = be16_to_cpu(sfp->diag.txpwr_low_alarm);
 845		sfp_hwmon_calibrate_tx_power(sfp, value);
 846		return 0;
 847
 848	case hwmon_power_min:
 849		*value = be16_to_cpu(sfp->diag.txpwr_low_warn);
 850		sfp_hwmon_calibrate_tx_power(sfp, value);
 851		return 0;
 852
 853	case hwmon_power_max:
 854		*value = be16_to_cpu(sfp->diag.txpwr_high_warn);
 855		sfp_hwmon_calibrate_tx_power(sfp, value);
 856		return 0;
 857
 858	case hwmon_power_crit:
 859		*value = be16_to_cpu(sfp->diag.txpwr_high_alarm);
 860		sfp_hwmon_calibrate_tx_power(sfp, value);
 861		return 0;
 862
 863	case hwmon_power_lcrit_alarm:
 864		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 865		if (err < 0)
 866			return err;
 867
 868		*value = !!(status & SFP_ALARM0_TXPWR_LOW);
 869		return 0;
 870
 871	case hwmon_power_min_alarm:
 872		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 873		if (err < 0)
 874			return err;
 875
 876		*value = !!(status & SFP_WARN0_TXPWR_LOW);
 877		return 0;
 878
 879	case hwmon_power_max_alarm:
 880		err = sfp_read(sfp, true, SFP_WARN0, &status, sizeof(status));
 881		if (err < 0)
 882			return err;
 883
 884		*value = !!(status & SFP_WARN0_TXPWR_HIGH);
 885		return 0;
 886
 887	case hwmon_power_crit_alarm:
 888		err = sfp_read(sfp, true, SFP_ALARM0, &status, sizeof(status));
 889		if (err < 0)
 890			return err;
 891
 892		*value = !!(status & SFP_ALARM0_TXPWR_HIGH);
 893		return 0;
 894	default:
 895		return -EOPNOTSUPP;
 896	}
 897
 898	return -EOPNOTSUPP;
 899}
 900
 901static int sfp_hwmon_rx_power(struct sfp *sfp, u32 attr, long *value)
 902{
 903	u8 status;
 904	int err;
 905
 906	switch (attr) {
 907	case hwmon_power_input:
 908		return sfp_hwmon_read_rx_power(sfp, SFP_RX_POWER, value);
 909
 910	case hwmon_power_lcrit:
 911		*value = be16_to_cpu(sfp->diag.rxpwr_low_alarm);
 912		sfp_hwmon_to_rx_power(value);
 913		return 0;
 914
 915	case hwmon_power_min:
 916		*value = be16_to_cpu(sfp->diag.rxpwr_low_warn);
 917		sfp_hwmon_to_rx_power(value);
 918		return 0;
 919
 920	case hwmon_power_max:
 921		*value = be16_to_cpu(sfp->diag.rxpwr_high_warn);
 922		sfp_hwmon_to_rx_power(value);
 923		return 0;
 924
 925	case hwmon_power_crit:
 926		*value = be16_to_cpu(sfp->diag.rxpwr_high_alarm);
 927		sfp_hwmon_to_rx_power(value);
 928		return 0;
 929
 930	case hwmon_power_lcrit_alarm:
 931		err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status));
 932		if (err < 0)
 933			return err;
 934
 935		*value = !!(status & SFP_ALARM1_RXPWR_LOW);
 936		return 0;
 937
 938	case hwmon_power_min_alarm:
 939		err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status));
 940		if (err < 0)
 941			return err;
 942
 943		*value = !!(status & SFP_WARN1_RXPWR_LOW);
 944		return 0;
 945
 946	case hwmon_power_max_alarm:
 947		err = sfp_read(sfp, true, SFP_WARN1, &status, sizeof(status));
 948		if (err < 0)
 949			return err;
 950
 951		*value = !!(status & SFP_WARN1_RXPWR_HIGH);
 952		return 0;
 953
 954	case hwmon_power_crit_alarm:
 955		err = sfp_read(sfp, true, SFP_ALARM1, &status, sizeof(status));
 956		if (err < 0)
 957			return err;
 958
 959		*value = !!(status & SFP_ALARM1_RXPWR_HIGH);
 960		return 0;
 961	default:
 962		return -EOPNOTSUPP;
 963	}
 964
 965	return -EOPNOTSUPP;
 966}
 967
 968static int sfp_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
 969			  u32 attr, int channel, long *value)
 970{
 971	struct sfp *sfp = dev_get_drvdata(dev);
 972
 973	switch (type) {
 974	case hwmon_temp:
 975		return sfp_hwmon_temp(sfp, attr, value);
 976	case hwmon_in:
 977		return sfp_hwmon_vcc(sfp, attr, value);
 978	case hwmon_curr:
 979		return sfp_hwmon_bias(sfp, attr, value);
 980	case hwmon_power:
 981		switch (channel) {
 982		case 0:
 983			return sfp_hwmon_tx_power(sfp, attr, value);
 984		case 1:
 985			return sfp_hwmon_rx_power(sfp, attr, value);
 986		default:
 987			return -EOPNOTSUPP;
 988		}
 989	default:
 990		return -EOPNOTSUPP;
 991	}
 992}
 993
 994static const char *const sfp_hwmon_power_labels[] = {
 995	"TX_power",
 996	"RX_power",
 997};
 998
 999static int sfp_hwmon_read_string(struct device *dev,
1000				 enum hwmon_sensor_types type,
1001				 u32 attr, int channel, const char **str)
1002{
1003	switch (type) {
1004	case hwmon_curr:
1005		switch (attr) {
1006		case hwmon_curr_label:
1007			*str = "bias";
1008			return 0;
1009		default:
1010			return -EOPNOTSUPP;
1011		}
1012		break;
1013	case hwmon_temp:
1014		switch (attr) {
1015		case hwmon_temp_label:
1016			*str = "temperature";
1017			return 0;
1018		default:
1019			return -EOPNOTSUPP;
1020		}
1021		break;
1022	case hwmon_in:
1023		switch (attr) {
1024		case hwmon_in_label:
1025			*str = "VCC";
1026			return 0;
1027		default:
1028			return -EOPNOTSUPP;
1029		}
1030		break;
1031	case hwmon_power:
1032		switch (attr) {
1033		case hwmon_power_label:
1034			*str = sfp_hwmon_power_labels[channel];
1035			return 0;
1036		default:
1037			return -EOPNOTSUPP;
1038		}
1039		break;
1040	default:
1041		return -EOPNOTSUPP;
1042	}
1043
1044	return -EOPNOTSUPP;
1045}
1046
1047static const struct hwmon_ops sfp_hwmon_ops = {
1048	.is_visible = sfp_hwmon_is_visible,
1049	.read = sfp_hwmon_read,
1050	.read_string = sfp_hwmon_read_string,
1051};
1052
1053static u32 sfp_hwmon_chip_config[] = {
1054	HWMON_C_REGISTER_TZ,
1055	0,
1056};
1057
1058static const struct hwmon_channel_info sfp_hwmon_chip = {
1059	.type = hwmon_chip,
1060	.config = sfp_hwmon_chip_config,
1061};
1062
1063static u32 sfp_hwmon_temp_config[] = {
1064	HWMON_T_INPUT |
1065	HWMON_T_MAX | HWMON_T_MIN |
1066	HWMON_T_MAX_ALARM | HWMON_T_MIN_ALARM |
1067	HWMON_T_CRIT | HWMON_T_LCRIT |
1068	HWMON_T_CRIT_ALARM | HWMON_T_LCRIT_ALARM |
1069	HWMON_T_LABEL,
1070	0,
1071};
1072
1073static const struct hwmon_channel_info sfp_hwmon_temp_channel_info = {
1074	.type = hwmon_temp,
1075	.config = sfp_hwmon_temp_config,
1076};
1077
1078static u32 sfp_hwmon_vcc_config[] = {
1079	HWMON_I_INPUT |
1080	HWMON_I_MAX | HWMON_I_MIN |
1081	HWMON_I_MAX_ALARM | HWMON_I_MIN_ALARM |
1082	HWMON_I_CRIT | HWMON_I_LCRIT |
1083	HWMON_I_CRIT_ALARM | HWMON_I_LCRIT_ALARM |
1084	HWMON_I_LABEL,
1085	0,
1086};
1087
1088static const struct hwmon_channel_info sfp_hwmon_vcc_channel_info = {
1089	.type = hwmon_in,
1090	.config = sfp_hwmon_vcc_config,
1091};
1092
1093static u32 sfp_hwmon_bias_config[] = {
1094	HWMON_C_INPUT |
1095	HWMON_C_MAX | HWMON_C_MIN |
1096	HWMON_C_MAX_ALARM | HWMON_C_MIN_ALARM |
1097	HWMON_C_CRIT | HWMON_C_LCRIT |
1098	HWMON_C_CRIT_ALARM | HWMON_C_LCRIT_ALARM |
1099	HWMON_C_LABEL,
1100	0,
1101};
1102
1103static const struct hwmon_channel_info sfp_hwmon_bias_channel_info = {
1104	.type = hwmon_curr,
1105	.config = sfp_hwmon_bias_config,
1106};
1107
1108static u32 sfp_hwmon_power_config[] = {
1109	/* Transmit power */
1110	HWMON_P_INPUT |
1111	HWMON_P_MAX | HWMON_P_MIN |
1112	HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM |
1113	HWMON_P_CRIT | HWMON_P_LCRIT |
1114	HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM |
1115	HWMON_P_LABEL,
1116	/* Receive power */
1117	HWMON_P_INPUT |
1118	HWMON_P_MAX | HWMON_P_MIN |
1119	HWMON_P_MAX_ALARM | HWMON_P_MIN_ALARM |
1120	HWMON_P_CRIT | HWMON_P_LCRIT |
1121	HWMON_P_CRIT_ALARM | HWMON_P_LCRIT_ALARM |
1122	HWMON_P_LABEL,
1123	0,
1124};
1125
1126static const struct hwmon_channel_info sfp_hwmon_power_channel_info = {
1127	.type = hwmon_power,
1128	.config = sfp_hwmon_power_config,
1129};
1130
1131static const struct hwmon_channel_info *sfp_hwmon_info[] = {
1132	&sfp_hwmon_chip,
1133	&sfp_hwmon_vcc_channel_info,
1134	&sfp_hwmon_temp_channel_info,
1135	&sfp_hwmon_bias_channel_info,
1136	&sfp_hwmon_power_channel_info,
1137	NULL,
1138};
1139
1140static const struct hwmon_chip_info sfp_hwmon_chip_info = {
1141	.ops = &sfp_hwmon_ops,
1142	.info = sfp_hwmon_info,
1143};
1144
1145static int sfp_hwmon_insert(struct sfp *sfp)
1146{
 
1147	int err, i;
1148
1149	if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE)
1150		return 0;
1151
1152	if (!(sfp->id.ext.diagmon & SFP_DIAGMON_DDM))
1153		return 0;
1154
1155	if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)
1156		/* This driver in general does not support address
1157		 * change.
1158		 */
1159		return 0;
 
 
1160
1161	err = sfp_read(sfp, true, 0, &sfp->diag, sizeof(sfp->diag));
1162	if (err < 0)
1163		return err;
 
 
 
 
 
 
 
1164
1165	sfp->hwmon_name = kstrdup(dev_name(sfp->dev), GFP_KERNEL);
1166	if (!sfp->hwmon_name)
1167		return -ENODEV;
 
 
1168
1169	for (i = 0; sfp->hwmon_name[i]; i++)
1170		if (hwmon_is_bad_char(sfp->hwmon_name[i]))
1171			sfp->hwmon_name[i] = '_';
1172
1173	sfp->hwmon_dev = hwmon_device_register_with_info(sfp->dev,
1174							 sfp->hwmon_name, sfp,
1175							 &sfp_hwmon_chip_info,
1176							 NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1177
1178	return PTR_ERR_OR_ZERO(sfp->hwmon_dev);
1179}
1180
1181static void sfp_hwmon_remove(struct sfp *sfp)
1182{
 
1183	if (!IS_ERR_OR_NULL(sfp->hwmon_dev)) {
1184		hwmon_device_unregister(sfp->hwmon_dev);
1185		sfp->hwmon_dev = NULL;
1186		kfree(sfp->hwmon_name);
1187	}
1188}
 
 
 
 
 
 
 
 
 
 
 
 
1189#else
1190static int sfp_hwmon_insert(struct sfp *sfp)
1191{
1192	return 0;
1193}
1194
1195static void sfp_hwmon_remove(struct sfp *sfp)
1196{
1197}
 
 
 
 
 
 
 
 
 
1198#endif
1199
1200/* Helpers */
1201static void sfp_module_tx_disable(struct sfp *sfp)
1202{
1203	dev_dbg(sfp->dev, "tx disable %u -> %u\n",
1204		sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 1);
1205	sfp->state |= SFP_F_TX_DISABLE;
1206	sfp_set_state(sfp, sfp->state);
1207}
1208
1209static void sfp_module_tx_enable(struct sfp *sfp)
1210{
1211	dev_dbg(sfp->dev, "tx disable %u -> %u\n",
1212		sfp->state & SFP_F_TX_DISABLE ? 1 : 0, 0);
1213	sfp->state &= ~SFP_F_TX_DISABLE;
1214	sfp_set_state(sfp, sfp->state);
1215}
1216
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1217static void sfp_module_tx_fault_reset(struct sfp *sfp)
1218{
1219	unsigned int state = sfp->state;
1220
1221	if (state & SFP_F_TX_DISABLE)
1222		return;
1223
1224	sfp_set_state(sfp, state | SFP_F_TX_DISABLE);
1225
1226	udelay(T_RESET_US);
1227
1228	sfp_set_state(sfp, state);
1229}
1230
1231/* SFP state machine */
1232static void sfp_sm_set_timer(struct sfp *sfp, unsigned int timeout)
1233{
1234	if (timeout)
1235		mod_delayed_work(system_power_efficient_wq, &sfp->timeout,
1236				 timeout);
1237	else
1238		cancel_delayed_work(&sfp->timeout);
1239}
1240
1241static void sfp_sm_next(struct sfp *sfp, unsigned int state,
1242			unsigned int timeout)
1243{
1244	sfp->sm_state = state;
1245	sfp_sm_set_timer(sfp, timeout);
1246}
1247
1248static void sfp_sm_ins_next(struct sfp *sfp, unsigned int state,
1249			    unsigned int timeout)
1250{
1251	sfp->sm_mod_state = state;
1252	sfp_sm_set_timer(sfp, timeout);
1253}
1254
1255static void sfp_sm_phy_detach(struct sfp *sfp)
1256{
1257	phy_stop(sfp->mod_phy);
1258	sfp_remove_phy(sfp->sfp_bus);
1259	phy_device_remove(sfp->mod_phy);
1260	phy_device_free(sfp->mod_phy);
1261	sfp->mod_phy = NULL;
1262}
1263
1264static void sfp_sm_probe_phy(struct sfp *sfp)
1265{
1266	struct phy_device *phy;
1267	int err;
1268
1269	msleep(T_PHY_RESET_MS);
1270
1271	phy = mdiobus_scan(sfp->i2c_mii, SFP_PHY_ADDR);
1272	if (phy == ERR_PTR(-ENODEV)) {
1273		dev_info(sfp->dev, "no PHY detected\n");
1274		return;
1275	}
1276	if (IS_ERR(phy)) {
1277		dev_err(sfp->dev, "mdiobus scan returned %ld\n", PTR_ERR(phy));
1278		return;
 
 
 
 
 
 
 
1279	}
1280
1281	err = sfp_add_phy(sfp->sfp_bus, phy);
1282	if (err) {
1283		phy_device_remove(phy);
1284		phy_device_free(phy);
1285		dev_err(sfp->dev, "sfp_add_phy failed: %d\n", err);
1286		return;
1287	}
1288
1289	sfp->mod_phy = phy;
1290	phy_start(phy);
 
1291}
1292
1293static void sfp_sm_link_up(struct sfp *sfp)
1294{
1295	sfp_link_up(sfp->sfp_bus);
1296	sfp_sm_next(sfp, SFP_S_LINK_UP, 0);
1297}
1298
1299static void sfp_sm_link_down(struct sfp *sfp)
1300{
1301	sfp_link_down(sfp->sfp_bus);
1302}
1303
1304static void sfp_sm_link_check_los(struct sfp *sfp)
1305{
1306	unsigned int los = sfp->state & SFP_F_LOS;
 
 
 
1307
1308	/* If neither SFP_OPTIONS_LOS_INVERTED nor SFP_OPTIONS_LOS_NORMAL
1309	 * are set, we assume that no LOS signal is available.
 
1310	 */
1311	if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED))
1312		los ^= SFP_F_LOS;
1313	else if (!(sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL)))
1314		los = 0;
1315
1316	if (los)
1317		sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
1318	else
1319		sfp_sm_link_up(sfp);
1320}
1321
1322static bool sfp_los_event_active(struct sfp *sfp, unsigned int event)
1323{
1324	return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) &&
1325		event == SFP_E_LOS_LOW) ||
1326	       (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) &&
1327		event == SFP_E_LOS_HIGH);
 
 
1328}
1329
1330static bool sfp_los_event_inactive(struct sfp *sfp, unsigned int event)
1331{
1332	return (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_INVERTED) &&
1333		event == SFP_E_LOS_HIGH) ||
1334	       (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_LOS_NORMAL) &&
1335		event == SFP_E_LOS_LOW);
 
 
1336}
1337
1338static void sfp_sm_fault(struct sfp *sfp, bool warn)
1339{
1340	if (sfp->sm_retries && !--sfp->sm_retries) {
1341		dev_err(sfp->dev,
1342			"module persistently indicates fault, disabling\n");
1343		sfp_sm_next(sfp, SFP_S_TX_DISABLE, 0);
1344	} else {
1345		if (warn)
1346			dev_err(sfp->dev, "module transmit fault indicated\n");
1347
1348		sfp_sm_next(sfp, SFP_S_TX_FAULT, T_FAULT_RECOVER);
1349	}
1350}
1351
1352static void sfp_sm_mod_init(struct sfp *sfp)
 
 
 
 
 
 
 
 
 
 
 
1353{
1354	sfp_module_tx_enable(sfp);
1355
1356	/* Wait t_init before indicating that the link is up, provided the
1357	 * current state indicates no TX_FAULT.  If TX_FAULT clears before
1358	 * this time, that's fine too.
1359	 */
1360	sfp_sm_next(sfp, SFP_S_INIT, T_INIT_JIFFIES);
1361	sfp->sm_retries = 5;
 
1362
1363	/* Setting the serdes link mode is guesswork: there's no
1364	 * field in the EEPROM which indicates what mode should
1365	 * be used.
1366	 *
1367	 * If it's a gigabit-only fiber module, it probably does
1368	 * not have a PHY, so switch to 802.3z negotiation mode.
1369	 * Otherwise, switch to SGMII mode (which is required to
1370	 * support non-gigabit speeds) and probe for a PHY.
1371	 */
1372	if (sfp->id.base.e1000_base_t ||
1373	    sfp->id.base.e100_base_lx ||
1374	    sfp->id.base.e100_base_fx)
1375		sfp_sm_probe_phy(sfp);
1376}
1377
1378static int sfp_sm_mod_hpower(struct sfp *sfp)
1379{
1380	u32 power;
1381	u8 val;
1382	int err;
1383
1384	power = 1000;
1385	if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_POWER_DECL))
1386		power = 1500;
1387	if (sfp->id.ext.options & cpu_to_be16(SFP_OPTIONS_HIGH_POWER_LEVEL))
1388		power = 2000;
1389
1390	if (sfp->id.ext.sff8472_compliance == SFP_SFF8472_COMPLIANCE_NONE &&
1391	    (sfp->id.ext.diagmon & (SFP_DIAGMON_DDM | SFP_DIAGMON_ADDRMODE)) !=
1392	    SFP_DIAGMON_DDM) {
1393		/* The module appears not to implement bus address 0xa2,
1394		 * or requires an address change sequence, so assume that
1395		 * the module powers up in the indicated power mode.
1396		 */
1397		if (power > sfp->max_power_mW) {
 
1398			dev_err(sfp->dev,
1399				"Host does not support %u.%uW modules\n",
1400				power / 1000, (power / 100) % 10);
1401			return -EINVAL;
 
 
 
 
 
1402		}
1403		return 0;
1404	}
1405
1406	if (power > sfp->max_power_mW) {
 
 
 
 
1407		dev_warn(sfp->dev,
1408			 "Host does not support %u.%uW modules, module left in power mode 1\n",
1409			 power / 1000, (power / 100) % 10);
1410		return 0;
1411	}
1412
1413	if (power <= 1000)
1414		return 0;
 
 
 
 
 
 
 
1415
1416	err = sfp_read(sfp, true, SFP_EXT_STATUS, &val, sizeof(val));
1417	if (err != sizeof(val)) {
1418		dev_err(sfp->dev, "Failed to read EEPROM: %d\n", err);
1419		err = -EAGAIN;
1420		goto err;
1421	}
1422
1423	val |= BIT(0);
 
 
 
 
 
 
 
 
 
 
1424
1425	err = sfp_write(sfp, true, SFP_EXT_STATUS, &val, sizeof(val));
1426	if (err != sizeof(val)) {
1427		dev_err(sfp->dev, "Failed to write EEPROM: %d\n", err);
1428		err = -EAGAIN;
1429		goto err;
1430	}
1431
1432	dev_info(sfp->dev, "Module switched to %u.%uW power level\n",
1433		 power / 1000, (power / 100) % 10);
1434	return T_HPOWER_LEVEL;
 
1435
1436err:
1437	return err;
1438}
1439
1440static int sfp_sm_mod_probe(struct sfp *sfp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1441{
1442	/* SFP module inserted - read I2C data */
1443	struct sfp_eeprom_id id;
 
1444	bool cotsworks;
1445	u8 check;
1446	int ret;
1447
1448	ret = sfp_read(sfp, false, 0, &id, sizeof(id));
 
 
 
 
 
 
1449	if (ret < 0) {
1450		dev_err(sfp->dev, "failed to read EEPROM: %d\n", ret);
 
1451		return -EAGAIN;
1452	}
1453
1454	if (ret != sizeof(id)) {
1455		dev_err(sfp->dev, "EEPROM short read: %d\n", ret);
1456		return -EAGAIN;
1457	}
1458
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1459	/* Cotsworks do not seem to update the checksums when they
1460	 * do the final programming with the final module part number,
1461	 * serial number and date code.
1462	 */
1463	cotsworks = !memcmp(id.base.vendor_name, "COTSWORKS       ", 16);
 
 
 
 
 
 
 
 
 
 
 
1464
1465	/* Validate the checksum over the base structure */
1466	check = sfp_check(&id.base, sizeof(id.base) - 1);
1467	if (check != id.base.cc_base) {
1468		if (cotsworks) {
1469			dev_warn(sfp->dev,
1470				 "EEPROM base structure checksum failure (0x%02x != 0x%02x)\n",
1471				 check, id.base.cc_base);
1472		} else {
1473			dev_err(sfp->dev,
1474				"EEPROM base structure checksum failure: 0x%02x != 0x%02x\n",
1475				check, id.base.cc_base);
1476			print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET,
1477				       16, 1, &id, sizeof(id), true);
1478			return -EINVAL;
1479		}
1480	}
1481
 
 
 
 
 
 
 
 
 
 
 
 
1482	check = sfp_check(&id.ext, sizeof(id.ext) - 1);
1483	if (check != id.ext.cc_ext) {
1484		if (cotsworks) {
1485			dev_warn(sfp->dev,
1486				 "EEPROM extended structure checksum failure (0x%02x != 0x%02x)\n",
1487				 check, id.ext.cc_ext);
1488		} else {
1489			dev_err(sfp->dev,
1490				"EEPROM extended structure checksum failure: 0x%02x != 0x%02x\n",
1491				check, id.ext.cc_ext);
1492			print_hex_dump(KERN_ERR, "sfp EE: ", DUMP_PREFIX_OFFSET,
1493				       16, 1, &id, sizeof(id), true);
1494			memset(&id.ext, 0, sizeof(id.ext));
1495		}
1496	}
1497
1498	sfp->id = id;
1499
1500	dev_info(sfp->dev, "module %.*s %.*s rev %.*s sn %.*s dc %.*s\n",
1501		 (int)sizeof(id.base.vendor_name), id.base.vendor_name,
1502		 (int)sizeof(id.base.vendor_pn), id.base.vendor_pn,
1503		 (int)sizeof(id.base.vendor_rev), id.base.vendor_rev,
1504		 (int)sizeof(id.ext.vendor_sn), id.ext.vendor_sn,
1505		 (int)sizeof(id.ext.datecode), id.ext.datecode);
1506
1507	/* Check whether we support this module */
1508	if (!sfp->type->module_supported(&sfp->id)) {
1509		dev_err(sfp->dev,
1510			"module is not supported - phys id 0x%02x 0x%02x\n",
1511			sfp->id.base.phys_id, sfp->id.base.phys_ext_id);
1512		return -EINVAL;
1513	}
1514
1515	/* If the module requires address swap mode, warn about it */
1516	if (sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)
1517		dev_warn(sfp->dev,
1518			 "module address swap to access page 0xA2 is not supported.\n");
1519
1520	ret = sfp_hwmon_insert(sfp);
 
1521	if (ret < 0)
1522		return ret;
1523
1524	ret = sfp_module_insert(sfp->sfp_bus, &sfp->id);
1525	if (ret < 0)
1526		return ret;
 
 
1527
1528	return sfp_sm_mod_hpower(sfp);
1529}
1530
1531static void sfp_sm_mod_remove(struct sfp *sfp)
1532{
1533	sfp_module_remove(sfp->sfp_bus);
 
1534
1535	sfp_hwmon_remove(sfp);
1536
1537	if (sfp->mod_phy)
1538		sfp_sm_phy_detach(sfp);
1539
1540	sfp_module_tx_disable(sfp);
1541
1542	memset(&sfp->id, 0, sizeof(sfp->id));
 
1543
1544	dev_info(sfp->dev, "module removed\n");
1545}
1546
1547static void sfp_sm_event(struct sfp *sfp, unsigned int event)
 
1548{
1549	mutex_lock(&sfp->sm_mutex);
 
 
 
 
1550
1551	dev_dbg(sfp->dev, "SM: enter %s:%s:%s event %s\n",
1552		mod_state_to_str(sfp->sm_mod_state),
1553		dev_state_to_str(sfp->sm_dev_state),
1554		sm_state_to_str(sfp->sm_state),
1555		event_to_str(event));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1556
1557	/* This state machine tracks the insert/remove state of
1558	 * the module, and handles probing the on-board EEPROM.
1559	 */
1560	switch (sfp->sm_mod_state) {
1561	default:
1562		if (event == SFP_E_INSERT && sfp->attached) {
1563			sfp_module_tx_disable(sfp);
1564			sfp_sm_ins_next(sfp, SFP_MOD_PROBE, T_PROBE_INIT);
 
1565		}
1566		break;
1567
1568	case SFP_MOD_PROBE:
1569		if (event == SFP_E_REMOVE) {
1570			sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0);
1571		} else if (event == SFP_E_TIMEOUT) {
1572			int val = sfp_sm_mod_probe(sfp);
1573
1574			if (val == 0)
1575				sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0);
1576			else if (val > 0)
1577				sfp_sm_ins_next(sfp, SFP_MOD_HPOWER, val);
1578			else if (val != -EAGAIN)
1579				sfp_sm_ins_next(sfp, SFP_MOD_ERROR, 0);
1580			else
1581				sfp_sm_set_timer(sfp, T_PROBE_RETRY);
 
 
 
 
 
 
 
 
1582		}
1583		break;
1584
1585	case SFP_MOD_HPOWER:
1586		if (event == SFP_E_TIMEOUT) {
1587			sfp_sm_ins_next(sfp, SFP_MOD_PRESENT, 0);
 
 
 
 
 
 
 
 
 
 
 
 
1588			break;
1589		}
1590		/* fallthrough */
1591	case SFP_MOD_PRESENT:
1592	case SFP_MOD_ERROR:
1593		if (event == SFP_E_REMOVE) {
1594			sfp_sm_mod_remove(sfp);
1595			sfp_sm_ins_next(sfp, SFP_MOD_EMPTY, 0);
 
 
 
 
 
 
 
 
 
 
 
 
1596		}
 
 
1597		break;
1598	}
1599
1600	/* This state machine tracks the netdev up/down state */
1601	switch (sfp->sm_dev_state) {
1602	default:
1603		if (event == SFP_E_DEV_UP)
1604			sfp->sm_dev_state = SFP_DEV_UP;
 
 
1605		break;
1606
1607	case SFP_DEV_UP:
1608		if (event == SFP_E_DEV_DOWN) {
1609			/* If the module has a PHY, avoid raising TX disable
1610			 * as this resets the PHY. Otherwise, raise it to
1611			 * turn the laser off.
1612			 */
1613			if (!sfp->mod_phy)
1614				sfp_module_tx_disable(sfp);
1615			sfp->sm_dev_state = SFP_DEV_DOWN;
1616		}
1617		break;
1618	}
 
 
 
 
 
 
1619
1620	/* Some events are global */
1621	if (sfp->sm_state != SFP_S_DOWN &&
1622	    (sfp->sm_mod_state != SFP_MOD_PRESENT ||
1623	     sfp->sm_dev_state != SFP_DEV_UP)) {
1624		if (sfp->sm_state == SFP_S_LINK_UP &&
1625		    sfp->sm_dev_state == SFP_DEV_UP)
1626			sfp_sm_link_down(sfp);
 
 
1627		if (sfp->mod_phy)
1628			sfp_sm_phy_detach(sfp);
 
 
1629		sfp_sm_next(sfp, SFP_S_DOWN, 0);
1630		mutex_unlock(&sfp->sm_mutex);
1631		return;
1632	}
1633
1634	/* The main state machine */
1635	switch (sfp->sm_state) {
1636	case SFP_S_DOWN:
1637		if (sfp->sm_mod_state == SFP_MOD_PRESENT &&
1638		    sfp->sm_dev_state == SFP_DEV_UP)
1639			sfp_sm_mod_init(sfp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1640		break;
1641
1642	case SFP_S_INIT:
1643		if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT)
1644			sfp_sm_fault(sfp, true);
1645		else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR)
1646			sfp_sm_link_check_los(sfp);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1647		break;
1648
1649	case SFP_S_WAIT_LOS:
1650		if (event == SFP_E_TX_FAULT)
1651			sfp_sm_fault(sfp, true);
1652		else if (sfp_los_event_inactive(sfp, event))
1653			sfp_sm_link_up(sfp);
1654		break;
1655
1656	case SFP_S_LINK_UP:
1657		if (event == SFP_E_TX_FAULT) {
1658			sfp_sm_link_down(sfp);
1659			sfp_sm_fault(sfp, true);
1660		} else if (sfp_los_event_active(sfp, event)) {
1661			sfp_sm_link_down(sfp);
1662			sfp_sm_next(sfp, SFP_S_WAIT_LOS, 0);
1663		}
1664		break;
1665
1666	case SFP_S_TX_FAULT:
1667		if (event == SFP_E_TIMEOUT) {
1668			sfp_module_tx_fault_reset(sfp);
1669			sfp_sm_next(sfp, SFP_S_REINIT, T_INIT_JIFFIES);
1670		}
1671		break;
1672
1673	case SFP_S_REINIT:
1674		if (event == SFP_E_TIMEOUT && sfp->state & SFP_F_TX_FAULT) {
1675			sfp_sm_fault(sfp, false);
1676		} else if (event == SFP_E_TIMEOUT || event == SFP_E_TX_CLEAR) {
1677			dev_info(sfp->dev, "module transmit fault recovered\n");
1678			sfp_sm_link_check_los(sfp);
1679		}
1680		break;
1681
1682	case SFP_S_TX_DISABLE:
1683		break;
1684	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1685
1686	dev_dbg(sfp->dev, "SM: exit %s:%s:%s\n",
1687		mod_state_to_str(sfp->sm_mod_state),
1688		dev_state_to_str(sfp->sm_dev_state),
1689		sm_state_to_str(sfp->sm_state));
1690
1691	mutex_unlock(&sfp->sm_mutex);
1692}
1693
1694static void sfp_attach(struct sfp *sfp)
1695{
1696	sfp->attached = true;
1697	if (sfp->state & SFP_F_PRESENT)
1698		sfp_sm_event(sfp, SFP_E_INSERT);
1699}
1700
1701static void sfp_detach(struct sfp *sfp)
1702{
1703	sfp->attached = false;
1704	sfp_sm_event(sfp, SFP_E_REMOVE);
1705}
1706
1707static void sfp_start(struct sfp *sfp)
1708{
1709	sfp_sm_event(sfp, SFP_E_DEV_UP);
1710}
1711
1712static void sfp_stop(struct sfp *sfp)
1713{
1714	sfp_sm_event(sfp, SFP_E_DEV_DOWN);
1715}
1716
1717static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo)
1718{
1719	/* locking... and check module is present */
1720
1721	if (sfp->id.ext.sff8472_compliance &&
1722	    !(sfp->id.ext.diagmon & SFP_DIAGMON_ADDRMODE)) {
1723		modinfo->type = ETH_MODULE_SFF_8472;
1724		modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1725	} else {
1726		modinfo->type = ETH_MODULE_SFF_8079;
1727		modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
1728	}
1729	return 0;
1730}
1731
1732static int sfp_module_eeprom(struct sfp *sfp, struct ethtool_eeprom *ee,
1733			     u8 *data)
1734{
1735	unsigned int first, last, len;
1736	int ret;
1737
1738	if (ee->len == 0)
1739		return -EINVAL;
1740
1741	first = ee->offset;
1742	last = ee->offset + ee->len;
1743	if (first < ETH_MODULE_SFF_8079_LEN) {
1744		len = min_t(unsigned int, last, ETH_MODULE_SFF_8079_LEN);
1745		len -= first;
1746
1747		ret = sfp_read(sfp, false, first, data, len);
1748		if (ret < 0)
1749			return ret;
1750
1751		first += len;
1752		data += len;
1753	}
1754	if (first < ETH_MODULE_SFF_8472_LEN && last > ETH_MODULE_SFF_8079_LEN) {
1755		len = min_t(unsigned int, last, ETH_MODULE_SFF_8472_LEN);
1756		len -= first;
1757		first -= ETH_MODULE_SFF_8079_LEN;
1758
1759		ret = sfp_read(sfp, true, first, data, len);
1760		if (ret < 0)
1761			return ret;
1762	}
1763	return 0;
1764}
1765
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1766static const struct sfp_socket_ops sfp_module_ops = {
1767	.attach = sfp_attach,
1768	.detach = sfp_detach,
1769	.start = sfp_start,
1770	.stop = sfp_stop,
1771	.module_info = sfp_module_info,
1772	.module_eeprom = sfp_module_eeprom,
 
1773};
1774
1775static void sfp_timeout(struct work_struct *work)
1776{
1777	struct sfp *sfp = container_of(work, struct sfp, timeout.work);
1778
1779	rtnl_lock();
1780	sfp_sm_event(sfp, SFP_E_TIMEOUT);
1781	rtnl_unlock();
1782}
1783
1784static void sfp_check_state(struct sfp *sfp)
1785{
1786	unsigned int state, i, changed;
1787
1788	mutex_lock(&sfp->st_mutex);
1789	state = sfp_get_state(sfp);
1790	changed = state ^ sfp->state;
1791	changed &= SFP_F_PRESENT | SFP_F_LOS | SFP_F_TX_FAULT;
1792
1793	for (i = 0; i < GPIO_MAX; i++)
1794		if (changed & BIT(i))
1795			dev_dbg(sfp->dev, "%s %u -> %u\n", gpio_of_names[i],
1796				!!(sfp->state & BIT(i)), !!(state & BIT(i)));
1797
1798	state |= sfp->state & (SFP_F_TX_DISABLE | SFP_F_RATE_SELECT);
1799	sfp->state = state;
1800
1801	rtnl_lock();
1802	if (changed & SFP_F_PRESENT)
1803		sfp_sm_event(sfp, state & SFP_F_PRESENT ?
1804				SFP_E_INSERT : SFP_E_REMOVE);
1805
1806	if (changed & SFP_F_TX_FAULT)
1807		sfp_sm_event(sfp, state & SFP_F_TX_FAULT ?
1808				SFP_E_TX_FAULT : SFP_E_TX_CLEAR);
1809
1810	if (changed & SFP_F_LOS)
1811		sfp_sm_event(sfp, state & SFP_F_LOS ?
1812				SFP_E_LOS_HIGH : SFP_E_LOS_LOW);
1813	rtnl_unlock();
1814	mutex_unlock(&sfp->st_mutex);
1815}
1816
1817static irqreturn_t sfp_irq(int irq, void *data)
1818{
1819	struct sfp *sfp = data;
1820
1821	sfp_check_state(sfp);
1822
1823	return IRQ_HANDLED;
1824}
1825
1826static void sfp_poll(struct work_struct *work)
1827{
1828	struct sfp *sfp = container_of(work, struct sfp, poll.work);
1829
1830	sfp_check_state(sfp);
1831	mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
 
 
 
1832}
1833
1834static struct sfp *sfp_alloc(struct device *dev)
1835{
1836	struct sfp *sfp;
1837
1838	sfp = kzalloc(sizeof(*sfp), GFP_KERNEL);
1839	if (!sfp)
1840		return ERR_PTR(-ENOMEM);
1841
1842	sfp->dev = dev;
1843
1844	mutex_init(&sfp->sm_mutex);
1845	mutex_init(&sfp->st_mutex);
1846	INIT_DELAYED_WORK(&sfp->poll, sfp_poll);
1847	INIT_DELAYED_WORK(&sfp->timeout, sfp_timeout);
1848
 
 
1849	return sfp;
1850}
1851
1852static void sfp_cleanup(void *data)
1853{
1854	struct sfp *sfp = data;
1855
 
 
1856	cancel_delayed_work_sync(&sfp->poll);
1857	cancel_delayed_work_sync(&sfp->timeout);
1858	if (sfp->i2c_mii) {
1859		mdiobus_unregister(sfp->i2c_mii);
1860		mdiobus_free(sfp->i2c_mii);
1861	}
1862	if (sfp->i2c)
1863		i2c_put_adapter(sfp->i2c);
1864	kfree(sfp);
1865}
1866
1867static int sfp_probe(struct platform_device *pdev)
1868{
1869	const struct sff_data *sff;
1870	struct i2c_adapter *i2c;
 
1871	struct sfp *sfp;
1872	bool poll = false;
1873	int err, i;
1874
1875	sfp = sfp_alloc(&pdev->dev);
1876	if (IS_ERR(sfp))
1877		return PTR_ERR(sfp);
1878
1879	platform_set_drvdata(pdev, sfp);
1880
1881	err = devm_add_action(sfp->dev, sfp_cleanup, sfp);
1882	if (err < 0)
1883		return err;
1884
1885	sff = sfp->type = &sfp_data;
1886
1887	if (pdev->dev.of_node) {
1888		struct device_node *node = pdev->dev.of_node;
1889		const struct of_device_id *id;
1890		struct device_node *np;
1891
1892		id = of_match_node(sfp_of_match, node);
1893		if (WARN_ON(!id))
1894			return -EINVAL;
1895
1896		sff = sfp->type = id->data;
1897
1898		np = of_parse_phandle(node, "i2c-bus", 0);
1899		if (!np) {
1900			dev_err(sfp->dev, "missing 'i2c-bus' property\n");
1901			return -ENODEV;
1902		}
1903
1904		i2c = of_find_i2c_adapter_by_node(np);
1905		of_node_put(np);
1906	} else if (has_acpi_companion(&pdev->dev)) {
1907		struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
1908		struct fwnode_handle *fw = acpi_fwnode_handle(adev);
1909		struct fwnode_reference_args args;
1910		struct acpi_handle *acpi_handle;
1911		int ret;
1912
1913		ret = acpi_node_get_property_reference(fw, "i2c-bus", 0, &args);
1914		if (ret || !is_acpi_device_node(args.fwnode)) {
1915			dev_err(&pdev->dev, "missing 'i2c-bus' property\n");
1916			return -ENODEV;
1917		}
1918
1919		acpi_handle = ACPI_HANDLE_FWNODE(args.fwnode);
1920		i2c = i2c_acpi_find_adapter_by_handle(acpi_handle);
1921	} else {
1922		return -EINVAL;
1923	}
1924
1925	if (!i2c)
1926		return -EPROBE_DEFER;
1927
1928	err = sfp_i2c_configure(sfp, i2c);
1929	if (err < 0) {
1930		i2c_put_adapter(i2c);
1931		return err;
1932	}
1933
1934	for (i = 0; i < GPIO_MAX; i++)
1935		if (sff->gpios & BIT(i)) {
1936			sfp->gpio[i] = devm_gpiod_get_optional(sfp->dev,
1937					   gpio_of_names[i], gpio_flags[i]);
1938			if (IS_ERR(sfp->gpio[i]))
1939				return PTR_ERR(sfp->gpio[i]);
1940		}
1941
1942	sfp->get_state = sfp_gpio_get_state;
1943	sfp->set_state = sfp_gpio_set_state;
1944
1945	/* Modules that have no detect signal are always present */
1946	if (!(sfp->gpio[GPIO_MODDEF0]))
1947		sfp->get_state = sff_gpio_get_state;
1948
1949	device_property_read_u32(&pdev->dev, "maximum-power-milliwatt",
1950				 &sfp->max_power_mW);
1951	if (!sfp->max_power_mW)
1952		sfp->max_power_mW = 1000;
1953
1954	dev_info(sfp->dev, "Host maximum power %u.%uW\n",
1955		 sfp->max_power_mW / 1000, (sfp->max_power_mW / 100) % 10);
1956
1957	/* Get the initial state, and always signal TX disable,
1958	 * since the network interface will not be up.
1959	 */
1960	sfp->state = sfp_get_state(sfp) | SFP_F_TX_DISABLE;
1961
1962	if (sfp->gpio[GPIO_RATE_SELECT] &&
1963	    gpiod_get_value_cansleep(sfp->gpio[GPIO_RATE_SELECT]))
1964		sfp->state |= SFP_F_RATE_SELECT;
1965	sfp_set_state(sfp, sfp->state);
1966	sfp_module_tx_disable(sfp);
 
 
 
 
 
1967
1968	for (i = 0; i < GPIO_MAX; i++) {
1969		if (gpio_flags[i] != GPIOD_IN || !sfp->gpio[i])
1970			continue;
1971
1972		sfp->gpio_irq[i] = gpiod_to_irq(sfp->gpio[i]);
1973		if (!sfp->gpio_irq[i]) {
1974			poll = true;
 
1975			continue;
1976		}
1977
 
 
 
 
 
 
 
1978		err = devm_request_threaded_irq(sfp->dev, sfp->gpio_irq[i],
1979						NULL, sfp_irq,
1980						IRQF_ONESHOT |
1981						IRQF_TRIGGER_RISING |
1982						IRQF_TRIGGER_FALLING,
1983						dev_name(sfp->dev), sfp);
1984		if (err) {
1985			sfp->gpio_irq[i] = 0;
1986			poll = true;
1987		}
1988	}
1989
1990	if (poll)
1991		mod_delayed_work(system_wq, &sfp->poll, poll_jiffies);
1992
1993	/* We could have an issue in cases no Tx disable pin is available or
1994	 * wired as modules using a laser as their light source will continue to
1995	 * be active when the fiber is removed. This could be a safety issue and
1996	 * we should at least warn the user about that.
1997	 */
1998	if (!sfp->gpio[GPIO_TX_DISABLE])
1999		dev_warn(sfp->dev,
2000			 "No tx_disable pin: SFP modules will always be emitting.\n");
2001
2002	sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops);
2003	if (!sfp->sfp_bus)
2004		return -ENOMEM;
2005
 
 
2006	return 0;
2007}
2008
2009static int sfp_remove(struct platform_device *pdev)
2010{
2011	struct sfp *sfp = platform_get_drvdata(pdev);
2012
 
2013	sfp_unregister_socket(sfp->sfp_bus);
 
 
 
 
2014
2015	return 0;
2016}
2017
2018static void sfp_shutdown(struct platform_device *pdev)
2019{
2020	struct sfp *sfp = platform_get_drvdata(pdev);
2021	int i;
2022
2023	for (i = 0; i < GPIO_MAX; i++) {
2024		if (!sfp->gpio_irq[i])
2025			continue;
2026
2027		devm_free_irq(sfp->dev, sfp->gpio_irq[i], sfp);
2028	}
2029
2030	cancel_delayed_work_sync(&sfp->poll);
2031	cancel_delayed_work_sync(&sfp->timeout);
2032}
2033
2034static struct platform_driver sfp_driver = {
2035	.probe = sfp_probe,
2036	.remove = sfp_remove,
2037	.shutdown = sfp_shutdown,
2038	.driver = {
2039		.name = "sfp",
2040		.of_match_table = sfp_of_match,
2041	},
2042};
2043
2044static int sfp_init(void)
2045{
2046	poll_jiffies = msecs_to_jiffies(100);
2047
2048	return platform_driver_register(&sfp_driver);
2049}
2050module_init(sfp_init);
2051
2052static void sfp_exit(void)
2053{
2054	platform_driver_unregister(&sfp_driver);
2055}
2056module_exit(sfp_exit);
2057
2058MODULE_ALIAS("platform:sfp");
2059MODULE_AUTHOR("Russell King");
2060MODULE_LICENSE("GPL v2");