1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Nvidia line card driver 4 * 5 * Copyright (C) 2020 Nvidia Technologies Ltd. 6 */ 7 8 #include <linux/device.h> 9 #include <linux/i2c.h> 10 #include <linux/module.h> 11 #include <linux/platform_data/mlxcpld.h> 12 #include <linux/platform_data/mlxreg.h> 13 #include <linux/platform_device.h> 14 #include <linux/regmap.h> 15 16 /* I2C bus IO offsets */ 17 #define MLXREG_LC_REG_CPLD1_VER_OFFSET 0x2500 18 #define MLXREG_LC_REG_FPGA1_VER_OFFSET 0x2501 19 #define MLXREG_LC_REG_CPLD1_PN_OFFSET 0x2504 20 #define MLXREG_LC_REG_FPGA1_PN_OFFSET 0x2506 21 #define MLXREG_LC_REG_RESET_CAUSE_OFFSET 0x251d 22 #define MLXREG_LC_REG_LED1_OFFSET 0x2520 23 #define MLXREG_LC_REG_GP0_OFFSET 0x252e 24 #define MLXREG_LC_REG_FIELD_UPGRADE 0x2534 25 #define MLXREG_LC_CHANNEL_I2C_REG 0x25dc 26 #define MLXREG_LC_REG_CPLD1_MVER_OFFSET 0x25de 27 #define MLXREG_LC_REG_FPGA1_MVER_OFFSET 0x25df 28 #define MLXREG_LC_REG_MAX_POWER_OFFSET 0x25f1 29 #define MLXREG_LC_REG_CONFIG_OFFSET 0x25fb 30 #define MLXREG_LC_REG_MAX 0x3fff 31 32 /** 33 * enum mlxreg_lc_type - line cards types 34 * 35 * @MLXREG_LC_SN4800_C16: 100GbE line card with 16 QSFP28 ports; 36 */ 37 enum mlxreg_lc_type { 38 MLXREG_LC_SN4800_C16 = 0x0000, 39 }; 40 41 /** 42 * enum mlxreg_lc_state - line cards state 43 * 44 * @MLXREG_LC_INITIALIZED: line card is initialized; 45 * @MLXREG_LC_POWERED: line card is powered; 46 * @MLXREG_LC_SYNCED: line card is synchronized between hardware and firmware; 47 */ 48 enum mlxreg_lc_state { 49 MLXREG_LC_INITIALIZED = BIT(0), 50 MLXREG_LC_POWERED = BIT(1), 51 MLXREG_LC_SYNCED = BIT(2), 52 }; 53 54 #define MLXREG_LC_CONFIGURED (MLXREG_LC_INITIALIZED | MLXREG_LC_POWERED | MLXREG_LC_SYNCED) 55 56 /* mlxreg_lc - device private data 57 * @dev: platform device; 58 * @lock: line card lock; 59 * @par_regmap: parent device regmap handle; 60 * @data: pltaform core data; 61 * @io_data: register access platform data; 62 * @led_data: LED platform data ; 63 * @mux_data: MUX platform data; 64 * @led: LED device; 65 * @io_regs: register access device; 66 * @mux_brdinfo: mux configuration; 67 * @mux: mux devices; 68 * @aux_devs: I2C devices feeding by auxiliary power; 69 * @aux_devs_num: number of I2C devices feeding by auxiliary power; 70 * @main_devs: I2C devices feeding by main power; 71 * @main_devs_num: number of I2C devices feeding by main power; 72 * @state: line card state; 73 */ 74 struct mlxreg_lc { 75 struct device *dev; 76 struct mutex lock; /* line card access lock */ 77 void *par_regmap; 78 struct mlxreg_core_data *data; 79 struct mlxreg_core_platform_data *io_data; 80 struct mlxreg_core_platform_data *led_data; 81 struct mlxcpld_mux_plat_data *mux_data; 82 struct platform_device *led; 83 struct platform_device *io_regs; 84 struct i2c_board_info *mux_brdinfo; 85 struct platform_device *mux; 86 struct mlxreg_hotplug_device *aux_devs; 87 int aux_devs_num; 88 struct mlxreg_hotplug_device *main_devs; 89 int main_devs_num; 90 enum mlxreg_lc_state state; 91 }; 92 93 static bool mlxreg_lc_writeable_reg(struct device *dev, unsigned int reg) 94 { 95 switch (reg) { 96 case MLXREG_LC_REG_LED1_OFFSET: 97 case MLXREG_LC_REG_GP0_OFFSET: 98 case MLXREG_LC_REG_FIELD_UPGRADE: 99 case MLXREG_LC_CHANNEL_I2C_REG: 100 return true; 101 } 102 return false; 103 } 104 105 static bool mlxreg_lc_readable_reg(struct device *dev, unsigned int reg) 106 { 107 switch (reg) { 108 case MLXREG_LC_REG_CPLD1_VER_OFFSET: 109 case MLXREG_LC_REG_FPGA1_VER_OFFSET: 110 case MLXREG_LC_REG_CPLD1_PN_OFFSET: 111 case MLXREG_LC_REG_FPGA1_PN_OFFSET: 112 case MLXREG_LC_REG_RESET_CAUSE_OFFSET: 113 case MLXREG_LC_REG_LED1_OFFSET: 114 case MLXREG_LC_REG_GP0_OFFSET: 115 case MLXREG_LC_REG_FIELD_UPGRADE: 116 case MLXREG_LC_CHANNEL_I2C_REG: 117 case MLXREG_LC_REG_CPLD1_MVER_OFFSET: 118 case MLXREG_LC_REG_FPGA1_MVER_OFFSET: 119 case MLXREG_LC_REG_MAX_POWER_OFFSET: 120 case MLXREG_LC_REG_CONFIG_OFFSET: 121 return true; 122 } 123 return false; 124 } 125 126 static bool mlxreg_lc_volatile_reg(struct device *dev, unsigned int reg) 127 { 128 switch (reg) { 129 case MLXREG_LC_REG_CPLD1_VER_OFFSET: 130 case MLXREG_LC_REG_FPGA1_VER_OFFSET: 131 case MLXREG_LC_REG_CPLD1_PN_OFFSET: 132 case MLXREG_LC_REG_FPGA1_PN_OFFSET: 133 case MLXREG_LC_REG_RESET_CAUSE_OFFSET: 134 case MLXREG_LC_REG_LED1_OFFSET: 135 case MLXREG_LC_REG_GP0_OFFSET: 136 case MLXREG_LC_REG_FIELD_UPGRADE: 137 case MLXREG_LC_CHANNEL_I2C_REG: 138 case MLXREG_LC_REG_CPLD1_MVER_OFFSET: 139 case MLXREG_LC_REG_FPGA1_MVER_OFFSET: 140 case MLXREG_LC_REG_MAX_POWER_OFFSET: 141 case MLXREG_LC_REG_CONFIG_OFFSET: 142 return true; 143 } 144 return false; 145 } 146 147 static const struct reg_default mlxreg_lc_regmap_default[] = { 148 { MLXREG_LC_CHANNEL_I2C_REG, 0x00 }, 149 }; 150 151 /* Configuration for the register map of a device with 2 bytes address space. */ 152 static const struct regmap_config mlxreg_lc_regmap_conf = { 153 .reg_bits = 16, 154 .val_bits = 8, 155 .max_register = MLXREG_LC_REG_MAX, 156 .cache_type = REGCACHE_FLAT, 157 .writeable_reg = mlxreg_lc_writeable_reg, 158 .readable_reg = mlxreg_lc_readable_reg, 159 .volatile_reg = mlxreg_lc_volatile_reg, 160 .reg_defaults = mlxreg_lc_regmap_default, 161 .num_reg_defaults = ARRAY_SIZE(mlxreg_lc_regmap_default), 162 }; 163 164 /* Default channels vector. 165 * It contains only the channels, which physically connected to the devices, 166 * empty channels are skipped. 167 */ 168 static int mlxreg_lc_chan[] = { 169 0x04, 0x05, 0x06, 0x07, 0x08, 0x10, 0x20, 0x21, 0x22, 0x23, 0x40, 0x41, 170 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 171 0x4e, 0x4f 172 }; 173 174 /* Defaul mux configuration. */ 175 static struct mlxcpld_mux_plat_data mlxreg_lc_mux_data[] = { 176 { 177 .chan_ids = mlxreg_lc_chan, 178 .num_adaps = ARRAY_SIZE(mlxreg_lc_chan), 179 .sel_reg_addr = MLXREG_LC_CHANNEL_I2C_REG, 180 .reg_size = 2, 181 }, 182 }; 183 184 /* Defaul mux board info. */ 185 static struct i2c_board_info mlxreg_lc_mux_brdinfo = { 186 I2C_BOARD_INFO("i2c-mux-mlxcpld", 0x32), 187 }; 188 189 /* Line card default auxiliary power static devices. */ 190 static struct i2c_board_info mlxreg_lc_aux_pwr_devices[] = { 191 { 192 I2C_BOARD_INFO("24c32", 0x51), 193 }, 194 { 195 I2C_BOARD_INFO("24c32", 0x51), 196 }, 197 }; 198 199 /* Line card default auxiliary power board info. */ 200 static struct mlxreg_hotplug_device mlxreg_lc_aux_pwr_brdinfo[] = { 201 { 202 .brdinfo = &mlxreg_lc_aux_pwr_devices[0], 203 .nr = 3, 204 }, 205 { 206 .brdinfo = &mlxreg_lc_aux_pwr_devices[1], 207 .nr = 4, 208 }, 209 }; 210 211 /* Line card default main power static devices. */ 212 static struct i2c_board_info mlxreg_lc_main_pwr_devices[] = { 213 { 214 I2C_BOARD_INFO("mp2975", 0x62), 215 }, 216 { 217 I2C_BOARD_INFO("mp2975", 0x64), 218 }, 219 { 220 I2C_BOARD_INFO("max11603", 0x6d), 221 }, 222 { 223 I2C_BOARD_INFO("lm25066", 0x15), 224 }, 225 }; 226 227 /* Line card default main power board info. */ 228 static struct mlxreg_hotplug_device mlxreg_lc_main_pwr_brdinfo[] = { 229 { 230 .brdinfo = &mlxreg_lc_main_pwr_devices[0], 231 .nr = 0, 232 }, 233 { 234 .brdinfo = &mlxreg_lc_main_pwr_devices[1], 235 .nr = 0, 236 }, 237 { 238 .brdinfo = &mlxreg_lc_main_pwr_devices[2], 239 .nr = 1, 240 }, 241 { 242 .brdinfo = &mlxreg_lc_main_pwr_devices[3], 243 .nr = 2, 244 }, 245 }; 246 247 /* LED default data. */ 248 static struct mlxreg_core_data mlxreg_lc_led_data[] = { 249 { 250 .label = "status:green", 251 .reg = MLXREG_LC_REG_LED1_OFFSET, 252 .mask = GENMASK(7, 4), 253 }, 254 { 255 .label = "status:orange", 256 .reg = MLXREG_LC_REG_LED1_OFFSET, 257 .mask = GENMASK(7, 4), 258 }, 259 }; 260 261 static struct mlxreg_core_platform_data mlxreg_lc_led = { 262 .identity = "pci", 263 .data = mlxreg_lc_led_data, 264 .counter = ARRAY_SIZE(mlxreg_lc_led_data), 265 }; 266 267 /* Default register access data. */ 268 static struct mlxreg_core_data mlxreg_lc_io_data[] = { 269 { 270 .label = "cpld1_version", 271 .reg = MLXREG_LC_REG_CPLD1_VER_OFFSET, 272 .bit = GENMASK(7, 0), 273 .mode = 0444, 274 }, 275 { 276 .label = "fpga1_version", 277 .reg = MLXREG_LC_REG_FPGA1_VER_OFFSET, 278 .bit = GENMASK(7, 0), 279 .mode = 0444, 280 }, 281 { 282 .label = "cpld1_pn", 283 .reg = MLXREG_LC_REG_CPLD1_PN_OFFSET, 284 .bit = GENMASK(15, 0), 285 .mode = 0444, 286 .regnum = 2, 287 }, 288 { 289 .label = "fpga1_pn", 290 .reg = MLXREG_LC_REG_FPGA1_PN_OFFSET, 291 .bit = GENMASK(15, 0), 292 .mode = 0444, 293 .regnum = 2, 294 }, 295 { 296 .label = "cpld1_version_min", 297 .reg = MLXREG_LC_REG_CPLD1_MVER_OFFSET, 298 .bit = GENMASK(7, 0), 299 .mode = 0444, 300 }, 301 { 302 .label = "fpga1_version_min", 303 .reg = MLXREG_LC_REG_FPGA1_MVER_OFFSET, 304 .bit = GENMASK(7, 0), 305 .mode = 0444, 306 }, 307 { 308 .label = "reset_fpga_not_done", 309 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 310 .mask = GENMASK(7, 0) & ~BIT(1), 311 .mode = 0444, 312 }, 313 { 314 .label = "reset_aux_pwr_or_ref", 315 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 316 .mask = GENMASK(7, 0) & ~BIT(2), 317 .mode = 0444, 318 }, 319 { 320 .label = "reset_dc_dc_pwr_fail", 321 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 322 .mask = GENMASK(7, 0) & ~BIT(3), 323 .mode = 0444, 324 }, 325 { 326 .label = "reset_from_chassis", 327 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 328 .mask = GENMASK(7, 0) & ~BIT(4), 329 .mode = 0444, 330 }, 331 { 332 .label = "reset_pwr_off_from_chassis", 333 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 334 .mask = GENMASK(7, 0) & ~BIT(5), 335 .mode = 0444, 336 }, 337 { 338 .label = "reset_line_card", 339 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 340 .mask = GENMASK(7, 0) & ~BIT(6), 341 .mode = 0444, 342 }, 343 { 344 .label = "reset_line_card_pwr_en", 345 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET, 346 .mask = GENMASK(7, 0) & ~BIT(7), 347 .mode = 0444, 348 }, 349 { 350 .label = "cpld_upgrade_en", 351 .reg = MLXREG_LC_REG_FIELD_UPGRADE, 352 .mask = GENMASK(7, 0) & ~BIT(0), 353 .mode = 0644, 354 .secured = 1, 355 }, 356 { 357 .label = "fpga_upgrade_en", 358 .reg = MLXREG_LC_REG_FIELD_UPGRADE, 359 .mask = GENMASK(7, 0) & ~BIT(1), 360 .mode = 0644, 361 .secured = 1, 362 }, 363 { 364 .label = "qsfp_pwr_en", 365 .reg = MLXREG_LC_REG_GP0_OFFSET, 366 .mask = GENMASK(7, 0) & ~BIT(0), 367 .mode = 0644, 368 }, 369 { 370 .label = "vpd_wp", 371 .reg = MLXREG_LC_REG_GP0_OFFSET, 372 .mask = GENMASK(7, 0) & ~BIT(3), 373 .mode = 0644, 374 .secured = 1, 375 }, 376 { 377 .label = "agb_spi_burn_en", 378 .reg = MLXREG_LC_REG_GP0_OFFSET, 379 .mask = GENMASK(7, 0) & ~BIT(5), 380 .mode = 0644, 381 .secured = 1, 382 }, 383 { 384 .label = "fpga_spi_burn_en", 385 .reg = MLXREG_LC_REG_GP0_OFFSET, 386 .mask = GENMASK(7, 0) & ~BIT(6), 387 .mode = 0644, 388 .secured = 1, 389 }, 390 { 391 .label = "max_power", 392 .reg = MLXREG_LC_REG_MAX_POWER_OFFSET, 393 .bit = GENMASK(15, 0), 394 .mode = 0444, 395 .regnum = 2, 396 }, 397 { 398 .label = "config", 399 .reg = MLXREG_LC_REG_CONFIG_OFFSET, 400 .bit = GENMASK(15, 0), 401 .mode = 0444, 402 .regnum = 2, 403 }, 404 }; 405 406 static struct mlxreg_core_platform_data mlxreg_lc_regs_io = { 407 .data = mlxreg_lc_io_data, 408 .counter = ARRAY_SIZE(mlxreg_lc_io_data), 409 }; 410 411 static int 412 mlxreg_lc_create_static_devices(struct mlxreg_lc *mlxreg_lc, struct mlxreg_hotplug_device *devs, 413 int size) 414 { 415 struct mlxreg_hotplug_device *dev = devs; 416 int i, ret; 417 418 /* Create static I2C device feeding by auxiliary or main power. */ 419 for (i = 0; i < size; i++, dev++) { 420 dev->client = i2c_new_client_device(dev->adapter, dev->brdinfo); 421 if (IS_ERR(dev->client)) { 422 dev_err(mlxreg_lc->dev, "Failed to create client %s at bus %d at addr 0x%02x\n", 423 dev->brdinfo->type, dev->nr, dev->brdinfo->addr); 424 425 dev->adapter = NULL; 426 ret = PTR_ERR(dev->client); 427 goto fail_create_static_devices; 428 } 429 } 430 431 return 0; 432 433 fail_create_static_devices: 434 while (--i >= 0) { 435 dev = devs + i; 436 i2c_unregister_device(dev->client); 437 dev->client = NULL; 438 } 439 return ret; 440 } 441 442 static void 443 mlxreg_lc_destroy_static_devices(struct mlxreg_lc *mlxreg_lc, struct mlxreg_hotplug_device *devs, 444 int size) 445 { 446 struct mlxreg_hotplug_device *dev = devs; 447 int i; 448 449 /* Destroy static I2C device feeding by auxiliary or main power. */ 450 for (i = 0; i < size; i++, dev++) { 451 if (dev->client) { 452 i2c_unregister_device(dev->client); 453 dev->client = NULL; 454 } 455 } 456 } 457 458 static int mlxreg_lc_power_on_off(struct mlxreg_lc *mlxreg_lc, u8 action) 459 { 460 u32 regval; 461 int err; 462 463 mutex_lock(&mlxreg_lc->lock); 464 465 err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_pwr, ®val); 466 if (err) 467 goto regmap_read_fail; 468 469 if (action) 470 regval |= BIT(mlxreg_lc->data->slot - 1); 471 else 472 regval &= ~BIT(mlxreg_lc->data->slot - 1); 473 474 err = regmap_write(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_pwr, regval); 475 476 regmap_read_fail: 477 mutex_unlock(&mlxreg_lc->lock); 478 return err; 479 } 480 481 static int mlxreg_lc_enable_disable(struct mlxreg_lc *mlxreg_lc, bool action) 482 { 483 u32 regval; 484 int err; 485 486 /* 487 * Hardware holds the line card after powering on in the disabled state. Holding line card 488 * in disabled state protects access to the line components, like FPGA and gearboxes. 489 * Line card should be enabled in order to get it in operational state. Line card could be 490 * disabled for moving it to non-operational state. Enabling line card does not affect the 491 * line card which is already has been enabled. Disabling does not affect the disabled line 492 * card. 493 */ 494 mutex_lock(&mlxreg_lc->lock); 495 496 err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_ena, ®val); 497 if (err) 498 goto regmap_read_fail; 499 500 if (action) 501 regval |= BIT(mlxreg_lc->data->slot - 1); 502 else 503 regval &= ~BIT(mlxreg_lc->data->slot - 1); 504 505 err = regmap_write(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_ena, regval); 506 507 regmap_read_fail: 508 mutex_unlock(&mlxreg_lc->lock); 509 return err; 510 } 511 512 static int 513 mlxreg_lc_sn4800_c16_config_init(struct mlxreg_lc *mlxreg_lc, void *regmap, 514 struct mlxreg_core_data *data) 515 { 516 struct device *dev = &data->hpdev.client->dev; 517 518 /* Set line card configuration according to the type. */ 519 mlxreg_lc->mux_data = mlxreg_lc_mux_data; 520 mlxreg_lc->io_data = &mlxreg_lc_regs_io; 521 mlxreg_lc->led_data = &mlxreg_lc_led; 522 mlxreg_lc->mux_brdinfo = &mlxreg_lc_mux_brdinfo; 523 524 mlxreg_lc->aux_devs = devm_kmemdup(dev, mlxreg_lc_aux_pwr_brdinfo, 525 sizeof(mlxreg_lc_aux_pwr_brdinfo), GFP_KERNEL); 526 if (!mlxreg_lc->aux_devs) 527 return -ENOMEM; 528 mlxreg_lc->aux_devs_num = ARRAY_SIZE(mlxreg_lc_aux_pwr_brdinfo); 529 mlxreg_lc->main_devs = devm_kmemdup(dev, mlxreg_lc_main_pwr_brdinfo, 530 sizeof(mlxreg_lc_main_pwr_brdinfo), GFP_KERNEL); 531 if (!mlxreg_lc->main_devs) 532 return -ENOMEM; 533 mlxreg_lc->main_devs_num = ARRAY_SIZE(mlxreg_lc_main_pwr_brdinfo); 534 535 return 0; 536 } 537 538 static void 539 mlxreg_lc_state_update(struct mlxreg_lc *mlxreg_lc, enum mlxreg_lc_state state, u8 action) 540 { 541 mutex_lock(&mlxreg_lc->lock); 542 543 if (action) 544 mlxreg_lc->state |= state; 545 else 546 mlxreg_lc->state &= ~state; 547 548 mutex_unlock(&mlxreg_lc->lock); 549 } 550 551 /* 552 * Callback is to be called from mlxreg-hotplug driver to notify about line card about received 553 * event. 554 */ 555 static int mlxreg_lc_event_handler(void *handle, enum mlxreg_hotplug_kind kind, u8 action) 556 { 557 struct mlxreg_lc *mlxreg_lc = handle; 558 int err = 0; 559 560 dev_info(mlxreg_lc->dev, "linecard#%d state %d event kind %d action %d\n", 561 mlxreg_lc->data->slot, mlxreg_lc->state, kind, action); 562 563 if (!(mlxreg_lc->state & MLXREG_LC_INITIALIZED)) 564 return 0; 565 566 switch (kind) { 567 case MLXREG_HOTPLUG_LC_SYNCED: 568 /* 569 * Synchronization event - hardware and firmware are synchronized. Power on/off 570 * line card - to allow/disallow main power source. 571 */ 572 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_SYNCED, action); 573 /* Power line card if it is not powered yet. */ 574 if (!(mlxreg_lc->state & MLXREG_LC_POWERED) && action) { 575 err = mlxreg_lc_power_on_off(mlxreg_lc, 1); 576 if (err) 577 return err; 578 } 579 /* In case line card is configured - enable it. */ 580 if (mlxreg_lc->state & MLXREG_LC_CONFIGURED && action) 581 err = mlxreg_lc_enable_disable(mlxreg_lc, 1); 582 break; 583 case MLXREG_HOTPLUG_LC_POWERED: 584 /* Power event - attach or de-attach line card device feeding by the main power. */ 585 if (action) { 586 /* Do not create devices, if line card is already powered. */ 587 if (mlxreg_lc->state & MLXREG_LC_POWERED) { 588 /* In case line card is configured - enable it. */ 589 if (mlxreg_lc->state & MLXREG_LC_CONFIGURED) 590 err = mlxreg_lc_enable_disable(mlxreg_lc, 1); 591 return err; 592 } 593 err = mlxreg_lc_create_static_devices(mlxreg_lc, mlxreg_lc->main_devs, 594 mlxreg_lc->main_devs_num); 595 if (err) 596 return err; 597 598 /* In case line card is already in ready state - enable it. */ 599 if (mlxreg_lc->state & MLXREG_LC_CONFIGURED) 600 err = mlxreg_lc_enable_disable(mlxreg_lc, 1); 601 } else { 602 mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->main_devs, 603 mlxreg_lc->main_devs_num); 604 } 605 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_POWERED, action); 606 break; 607 case MLXREG_HOTPLUG_LC_READY: 608 /* 609 * Ready event – enable line card by releasing it from reset or disable it by put 610 * to reset state. 611 */ 612 err = mlxreg_lc_enable_disable(mlxreg_lc, !!action); 613 break; 614 case MLXREG_HOTPLUG_LC_THERMAL: 615 /* Thermal shutdown event – power off line card. */ 616 if (action) 617 err = mlxreg_lc_power_on_off(mlxreg_lc, 0); 618 break; 619 default: 620 break; 621 } 622 623 return err; 624 } 625 626 /* 627 * Callback is to be called from i2c-mux-mlxcpld driver to indicate that all adapter devices has 628 * been created. 629 */ 630 static int mlxreg_lc_completion_notify(void *handle, struct i2c_adapter *parent, 631 struct i2c_adapter *adapters[]) 632 { 633 struct mlxreg_hotplug_device *main_dev, *aux_dev; 634 struct mlxreg_lc *mlxreg_lc = handle; 635 u32 regval; 636 int i, err; 637 638 /* Update I2C devices feeding by auxiliary power. */ 639 aux_dev = mlxreg_lc->aux_devs; 640 for (i = 0; i < mlxreg_lc->aux_devs_num; i++, aux_dev++) { 641 aux_dev->adapter = adapters[aux_dev->nr]; 642 aux_dev->nr = adapters[aux_dev->nr]->nr; 643 } 644 645 err = mlxreg_lc_create_static_devices(mlxreg_lc, mlxreg_lc->aux_devs, 646 mlxreg_lc->aux_devs_num); 647 if (err) 648 return err; 649 650 /* Update I2C devices feeding by main power. */ 651 main_dev = mlxreg_lc->main_devs; 652 for (i = 0; i < mlxreg_lc->main_devs_num; i++, main_dev++) { 653 main_dev->adapter = adapters[main_dev->nr]; 654 main_dev->nr = adapters[main_dev->nr]->nr; 655 } 656 657 /* Verify if line card is powered. */ 658 err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_pwr, ®val); 659 if (err) 660 goto mlxreg_lc_regmap_read_power_fail; 661 662 if (regval & mlxreg_lc->data->mask) { 663 err = mlxreg_lc_create_static_devices(mlxreg_lc, mlxreg_lc->main_devs, 664 mlxreg_lc->main_devs_num); 665 if (err) 666 goto mlxreg_lc_create_static_devices_failed; 667 668 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_POWERED, 1); 669 } 670 671 /* Verify if line card is synchronized. */ 672 err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_sync, ®val); 673 if (err) 674 goto mlxreg_lc_regmap_read_sync_fail; 675 676 /* Power on line card if necessary. */ 677 if (regval & mlxreg_lc->data->mask) { 678 mlxreg_lc->state |= MLXREG_LC_SYNCED; 679 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_SYNCED, 1); 680 if (mlxreg_lc->state & ~MLXREG_LC_POWERED) { 681 err = mlxreg_lc_power_on_off(mlxreg_lc, 1); 682 if (err) 683 goto mlxreg_lc_regmap_power_on_off_fail; 684 } 685 } 686 687 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_INITIALIZED, 1); 688 689 return 0; 690 691 mlxreg_lc_regmap_power_on_off_fail: 692 mlxreg_lc_regmap_read_sync_fail: 693 if (mlxreg_lc->state & MLXREG_LC_POWERED) 694 mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->main_devs, 695 mlxreg_lc->main_devs_num); 696 mlxreg_lc_create_static_devices_failed: 697 mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->aux_devs, mlxreg_lc->aux_devs_num); 698 mlxreg_lc_regmap_read_power_fail: 699 return err; 700 } 701 702 static int 703 mlxreg_lc_config_init(struct mlxreg_lc *mlxreg_lc, void *regmap, 704 struct mlxreg_core_data *data) 705 { 706 struct device *dev = &data->hpdev.client->dev; 707 int lsb, err; 708 u32 regval; 709 710 /* Validate line card type. */ 711 err = regmap_read(regmap, MLXREG_LC_REG_CONFIG_OFFSET, &lsb); 712 err = (!err) ? regmap_read(regmap, MLXREG_LC_REG_CONFIG_OFFSET, ®val) : err; 713 if (err) 714 return err; 715 regval = (regval & GENMASK(7, 0)) << 8 | (lsb & GENMASK(7, 0)); 716 switch (regval) { 717 case MLXREG_LC_SN4800_C16: 718 err = mlxreg_lc_sn4800_c16_config_init(mlxreg_lc, regmap, data); 719 if (err) 720 return err; 721 break; 722 default: 723 return -ENODEV; 724 } 725 726 /* Create mux infrastructure. */ 727 mlxreg_lc->mux_data->handle = mlxreg_lc; 728 mlxreg_lc->mux_data->completion_notify = mlxreg_lc_completion_notify; 729 mlxreg_lc->mux_brdinfo->platform_data = mlxreg_lc->mux_data; 730 mlxreg_lc->mux = platform_device_register_resndata(dev, "i2c-mux-mlxcpld", data->hpdev.nr, 731 NULL, 0, mlxreg_lc->mux_data, 732 sizeof(*mlxreg_lc->mux_data)); 733 if (IS_ERR(mlxreg_lc->mux)) 734 return PTR_ERR(mlxreg_lc->mux); 735 736 /* Register IO access driver. */ 737 if (mlxreg_lc->io_data) { 738 mlxreg_lc->io_data->regmap = regmap; 739 mlxreg_lc->io_regs = 740 platform_device_register_resndata(dev, "mlxreg-io", data->hpdev.nr, NULL, 0, 741 mlxreg_lc->io_data, sizeof(*mlxreg_lc->io_data)); 742 if (IS_ERR(mlxreg_lc->io_regs)) { 743 err = PTR_ERR(mlxreg_lc->io_regs); 744 goto fail_register_io; 745 } 746 } 747 748 /* Register LED driver. */ 749 if (mlxreg_lc->led_data) { 750 mlxreg_lc->led_data->regmap = regmap; 751 mlxreg_lc->led = 752 platform_device_register_resndata(dev, "leds-mlxreg", data->hpdev.nr, NULL, 0, 753 mlxreg_lc->led_data, 754 sizeof(*mlxreg_lc->led_data)); 755 if (IS_ERR(mlxreg_lc->led)) { 756 err = PTR_ERR(mlxreg_lc->led); 757 goto fail_register_led; 758 } 759 } 760 761 return 0; 762 763 fail_register_led: 764 if (mlxreg_lc->io_regs) 765 platform_device_unregister(mlxreg_lc->io_regs); 766 fail_register_io: 767 if (mlxreg_lc->mux) 768 platform_device_unregister(mlxreg_lc->mux); 769 770 return err; 771 } 772 773 static void mlxreg_lc_config_exit(struct mlxreg_lc *mlxreg_lc) 774 { 775 /* Unregister LED driver. */ 776 if (mlxreg_lc->led) 777 platform_device_unregister(mlxreg_lc->led); 778 /* Unregister IO access driver. */ 779 if (mlxreg_lc->io_regs) 780 platform_device_unregister(mlxreg_lc->io_regs); 781 /* Remove mux infrastructure. */ 782 if (mlxreg_lc->mux) 783 platform_device_unregister(mlxreg_lc->mux); 784 } 785 786 static int mlxreg_lc_probe(struct platform_device *pdev) 787 { 788 struct mlxreg_core_hotplug_platform_data *par_pdata; 789 struct mlxreg_core_data *data; 790 struct mlxreg_lc *mlxreg_lc; 791 void *regmap; 792 int i, err; 793 794 data = dev_get_platdata(&pdev->dev); 795 if (!data) 796 return -EINVAL; 797 798 mlxreg_lc = devm_kzalloc(&pdev->dev, sizeof(*mlxreg_lc), GFP_KERNEL); 799 if (!mlxreg_lc) 800 return -ENOMEM; 801 802 mutex_init(&mlxreg_lc->lock); 803 /* Set event notification callback. */ 804 if (data->notifier) { 805 data->notifier->user_handler = mlxreg_lc_event_handler; 806 data->notifier->handle = mlxreg_lc; 807 } 808 data->hpdev.adapter = i2c_get_adapter(data->hpdev.nr); 809 if (!data->hpdev.adapter) { 810 dev_err(&pdev->dev, "Failed to get adapter for bus %d\n", 811 data->hpdev.nr); 812 return -EFAULT; 813 } 814 815 /* Create device at the top of line card I2C tree.*/ 816 data->hpdev.client = i2c_new_client_device(data->hpdev.adapter, 817 data->hpdev.brdinfo); 818 if (IS_ERR(data->hpdev.client)) { 819 dev_err(&pdev->dev, "Failed to create client %s at bus %d at addr 0x%02x\n", 820 data->hpdev.brdinfo->type, data->hpdev.nr, data->hpdev.brdinfo->addr); 821 822 i2c_put_adapter(data->hpdev.adapter); 823 data->hpdev.adapter = NULL; 824 return PTR_ERR(data->hpdev.client); 825 } 826 827 regmap = devm_regmap_init_i2c(data->hpdev.client, 828 &mlxreg_lc_regmap_conf); 829 if (IS_ERR(regmap)) { 830 err = PTR_ERR(regmap); 831 goto mlxreg_lc_probe_fail; 832 } 833 834 /* Set default registers. */ 835 for (i = 0; i < mlxreg_lc_regmap_conf.num_reg_defaults; i++) { 836 err = regmap_write(regmap, mlxreg_lc_regmap_default[i].reg, 837 mlxreg_lc_regmap_default[i].def); 838 if (err) 839 goto mlxreg_lc_probe_fail; 840 } 841 842 /* Sync registers with hardware. */ 843 regcache_mark_dirty(regmap); 844 err = regcache_sync(regmap); 845 if (err) 846 goto mlxreg_lc_probe_fail; 847 848 par_pdata = data->hpdev.brdinfo->platform_data; 849 mlxreg_lc->par_regmap = par_pdata->regmap; 850 mlxreg_lc->data = data; 851 mlxreg_lc->dev = &pdev->dev; 852 platform_set_drvdata(pdev, mlxreg_lc); 853 854 /* Configure line card. */ 855 err = mlxreg_lc_config_init(mlxreg_lc, regmap, data); 856 if (err) 857 goto mlxreg_lc_probe_fail; 858 859 return err; 860 861 mlxreg_lc_probe_fail: 862 i2c_put_adapter(data->hpdev.adapter); 863 return err; 864 } 865 866 static int mlxreg_lc_remove(struct platform_device *pdev) 867 { 868 struct mlxreg_core_data *data = dev_get_platdata(&pdev->dev); 869 struct mlxreg_lc *mlxreg_lc = platform_get_drvdata(pdev); 870 871 /* Clear event notification callback. */ 872 if (data->notifier) { 873 data->notifier->user_handler = NULL; 874 data->notifier->handle = NULL; 875 } 876 877 /* Destroy static I2C device feeding by main power. */ 878 mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->main_devs, 879 mlxreg_lc->main_devs_num); 880 /* Destroy static I2C device feeding by auxiliary power. */ 881 mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->aux_devs, mlxreg_lc->aux_devs_num); 882 /* Unregister underlying drivers. */ 883 mlxreg_lc_config_exit(mlxreg_lc); 884 if (data->hpdev.client) { 885 i2c_unregister_device(data->hpdev.client); 886 data->hpdev.client = NULL; 887 i2c_put_adapter(data->hpdev.adapter); 888 data->hpdev.adapter = NULL; 889 } 890 891 return 0; 892 } 893 894 static struct platform_driver mlxreg_lc_driver = { 895 .probe = mlxreg_lc_probe, 896 .remove = mlxreg_lc_remove, 897 .driver = { 898 .name = "mlxreg-lc", 899 }, 900 }; 901 902 module_platform_driver(mlxreg_lc_driver); 903 904 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>"); 905 MODULE_DESCRIPTION("Nvidia line card platform driver"); 906 MODULE_LICENSE("Dual BSD/GPL"); 907 MODULE_ALIAS("platform:mlxreg-lc"); 908