1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/module.h> 3 #include <linux/i2c.h> 4 #include <linux/dmi.h> 5 #include <linux/efi.h> 6 #include <linux/pci.h> 7 #include <linux/acpi.h> 8 #include <linux/clk.h> 9 #include <linux/delay.h> 10 #include <media/v4l2-subdev.h> 11 #include <linux/mfd/intel_soc_pmic.h> 12 #include <linux/regulator/consumer.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/gpio.h> 15 #include <linux/platform_device.h> 16 #include "../../include/linux/atomisp_platform.h" 17 #include "../../include/linux/atomisp_gmin_platform.h" 18 19 #define MAX_SUBDEVS 8 20 21 enum clock_rate { 22 VLV2_CLK_XTAL_25_0MHz = 0, 23 VLV2_CLK_PLL_19P2MHZ = 1 24 }; 25 26 #define CLK_RATE_19_2MHZ 19200000 27 #define CLK_RATE_25_0MHZ 25000000 28 29 /* Valid clock number range from 0 to 5 */ 30 #define MAX_CLK_COUNT 5 31 32 /* X-Powers AXP288 register set */ 33 #define ALDO1_SEL_REG 0x28 34 #define ALDO1_CTRL3_REG 0x13 35 #define ALDO1_2P8V 0x16 36 #define ALDO1_CTRL3_SHIFT 0x05 37 38 #define ELDO_CTRL_REG 0x12 39 40 #define ELDO1_SEL_REG 0x19 41 #define ELDO1_1P6V 0x12 42 #define ELDO1_CTRL_SHIFT 0x00 43 44 #define ELDO2_SEL_REG 0x1a 45 #define ELDO2_1P8V 0x16 46 #define ELDO2_CTRL_SHIFT 0x01 47 48 /* TI SND9039 PMIC register set */ 49 #define LDO9_REG 0x49 50 #define LDO10_REG 0x4a 51 #define LDO11_REG 0x4b 52 53 #define LDO_2P8V_ON 0x2f /* 0x2e selects 2.85V ... */ 54 #define LDO_2P8V_OFF 0x2e /* ... bottom bit is "enabled" */ 55 56 #define LDO_1P8V_ON 0x59 /* 0x58 selects 1.80V ... */ 57 #define LDO_1P8V_OFF 0x58 /* ... bottom bit is "enabled" */ 58 59 /* CRYSTAL COVE PMIC register set */ 60 #define CRYSTAL_BYT_1P8V_REG 0x5d 61 #define CRYSTAL_BYT_2P8V_REG 0x66 62 63 #define CRYSTAL_CHT_1P8V_REG 0x57 64 #define CRYSTAL_CHT_2P8V_REG 0x5d 65 66 #define CRYSTAL_ON 0x63 67 #define CRYSTAL_OFF 0x62 68 69 struct gmin_subdev { 70 struct v4l2_subdev *subdev; 71 enum clock_rate clock_src; 72 struct clk *pmc_clk; 73 struct gpio_desc *gpio0; 74 struct gpio_desc *gpio1; 75 struct regulator *v1p8_reg; 76 struct regulator *v2p8_reg; 77 struct regulator *v1p2_reg; 78 struct regulator *v2p8_vcm_reg; 79 enum atomisp_camera_port csi_port; 80 unsigned int csi_lanes; 81 enum atomisp_input_format csi_fmt; 82 enum atomisp_bayer_order csi_bayer; 83 84 bool clock_on; 85 bool v1p8_on; 86 bool v2p8_on; 87 bool v1p2_on; 88 bool v2p8_vcm_on; 89 90 int v1p8_gpio; 91 int v2p8_gpio; 92 93 u8 pwm_i2c_addr; 94 95 /* For PMIC AXP */ 96 int eldo1_sel_reg, eldo1_1p6v, eldo1_ctrl_shift; 97 int eldo2_sel_reg, eldo2_1p8v, eldo2_ctrl_shift; 98 }; 99 100 static struct gmin_subdev gmin_subdevs[MAX_SUBDEVS]; 101 102 /* ACPI HIDs for the PMICs that could be used by this driver */ 103 #define PMIC_ACPI_AXP "INT33F4" /* XPower AXP288 PMIC */ 104 #define PMIC_ACPI_TI "INT33F5" /* Dollar Cove TI PMIC */ 105 #define PMIC_ACPI_CRYSTALCOVE "INT33FD" /* Crystal Cove PMIC */ 106 107 #define PMIC_PLATFORM_TI "intel_soc_pmic_chtdc_ti" 108 109 static enum { 110 PMIC_UNSET = 0, 111 PMIC_REGULATOR, 112 PMIC_AXP, 113 PMIC_TI, 114 PMIC_CRYSTALCOVE 115 } pmic_id; 116 117 static const char *pmic_name[] = { 118 [PMIC_UNSET] = "ACPI device PM", 119 [PMIC_REGULATOR] = "regulator driver", 120 [PMIC_AXP] = "XPower AXP288 PMIC", 121 [PMIC_TI] = "Dollar Cove TI PMIC", 122 [PMIC_CRYSTALCOVE] = "Crystal Cove PMIC", 123 }; 124 125 static DEFINE_MUTEX(gmin_regulator_mutex); 126 static int gmin_v1p8_enable_count; 127 static int gmin_v2p8_enable_count; 128 129 /* The atomisp uses type==0 for the end-of-list marker, so leave space. */ 130 static struct intel_v4l2_subdev_table pdata_subdevs[MAX_SUBDEVS + 1]; 131 132 static const struct atomisp_platform_data pdata = { 133 .subdevs = pdata_subdevs, 134 }; 135 136 static LIST_HEAD(vcm_devices); 137 static DEFINE_MUTEX(vcm_lock); 138 139 static struct gmin_subdev *find_gmin_subdev(struct v4l2_subdev *subdev); 140 141 const struct atomisp_platform_data *atomisp_get_platform_data(void) 142 { 143 return &pdata; 144 } 145 EXPORT_SYMBOL_GPL(atomisp_get_platform_data); 146 147 int atomisp_register_i2c_module(struct v4l2_subdev *subdev, 148 struct camera_sensor_platform_data *plat_data, 149 enum intel_v4l2_subdev_type type) 150 { 151 int i; 152 struct i2c_board_info *bi; 153 struct gmin_subdev *gs; 154 struct i2c_client *client = v4l2_get_subdevdata(subdev); 155 struct acpi_device *adev = ACPI_COMPANION(&client->dev); 156 157 dev_info(&client->dev, "register atomisp i2c module type %d\n", type); 158 159 /* The windows driver model (and thus most BIOSes by default) 160 * uses ACPI runtime power management for camera devices, but 161 * we don't. Disable it, or else the rails will be needlessly 162 * tickled during suspend/resume. This has caused power and 163 * performance issues on multiple devices. 164 */ 165 adev->power.flags.power_resources = 0; 166 167 for (i = 0; i < MAX_SUBDEVS; i++) 168 if (!pdata.subdevs[i].type) 169 break; 170 171 if (pdata.subdevs[i].type) 172 return -ENOMEM; 173 174 /* Note subtlety of initialization order: at the point where 175 * this registration API gets called, the platform data 176 * callbacks have probably already been invoked, so the 177 * gmin_subdev struct is already initialized for us. 178 */ 179 gs = find_gmin_subdev(subdev); 180 if (!gs) 181 return -ENODEV; 182 183 pdata.subdevs[i].type = type; 184 pdata.subdevs[i].port = gs->csi_port; 185 pdata.subdevs[i].subdev = subdev; 186 pdata.subdevs[i].v4l2_subdev.i2c_adapter_id = client->adapter->nr; 187 188 /* Convert i2c_client to i2c_board_info */ 189 bi = &pdata.subdevs[i].v4l2_subdev.board_info; 190 memcpy(bi->type, client->name, I2C_NAME_SIZE); 191 bi->flags = client->flags; 192 bi->addr = client->addr; 193 bi->irq = client->irq; 194 bi->platform_data = plat_data; 195 196 return 0; 197 } 198 EXPORT_SYMBOL_GPL(atomisp_register_i2c_module); 199 200 struct v4l2_subdev *atomisp_gmin_find_subdev(struct i2c_adapter *adapter, 201 struct i2c_board_info *board_info) 202 { 203 int i; 204 205 for (i = 0; i < MAX_SUBDEVS && pdata.subdevs[i].type; i++) { 206 struct intel_v4l2_subdev_table *sd = &pdata.subdevs[i]; 207 208 if (sd->v4l2_subdev.i2c_adapter_id == adapter->nr && 209 sd->v4l2_subdev.board_info.addr == board_info->addr) 210 return sd->subdev; 211 } 212 return NULL; 213 } 214 EXPORT_SYMBOL_GPL(atomisp_gmin_find_subdev); 215 216 int atomisp_gmin_remove_subdev(struct v4l2_subdev *sd) 217 { 218 int i, j; 219 220 if (!sd) 221 return 0; 222 223 for (i = 0; i < MAX_SUBDEVS; i++) { 224 if (pdata.subdevs[i].subdev == sd) { 225 for (j = i + 1; j <= MAX_SUBDEVS; j++) 226 pdata.subdevs[j - 1] = pdata.subdevs[j]; 227 } 228 if (gmin_subdevs[i].subdev == sd) { 229 if (gmin_subdevs[i].gpio0) 230 gpiod_put(gmin_subdevs[i].gpio0); 231 gmin_subdevs[i].gpio0 = NULL; 232 if (gmin_subdevs[i].gpio1) 233 gpiod_put(gmin_subdevs[i].gpio1); 234 gmin_subdevs[i].gpio1 = NULL; 235 if (pmic_id == PMIC_REGULATOR) { 236 regulator_put(gmin_subdevs[i].v1p8_reg); 237 regulator_put(gmin_subdevs[i].v2p8_reg); 238 regulator_put(gmin_subdevs[i].v1p2_reg); 239 regulator_put(gmin_subdevs[i].v2p8_vcm_reg); 240 } 241 gmin_subdevs[i].subdev = NULL; 242 } 243 } 244 return 0; 245 } 246 EXPORT_SYMBOL_GPL(atomisp_gmin_remove_subdev); 247 248 struct gmin_cfg_var { 249 const char *name, *val; 250 }; 251 252 static struct gmin_cfg_var ffrd8_vars[] = { 253 { "INTCF1B:00_ImxId", "0x134" }, 254 { "INTCF1B:00_CsiPort", "1" }, 255 { "INTCF1B:00_CsiLanes", "4" }, 256 { "INTCF1B:00_CamClk", "0" }, 257 {}, 258 }; 259 260 /* Cribbed from MCG defaults in the mt9m114 driver, not actually verified 261 * vs. T100 hardware 262 */ 263 static struct gmin_cfg_var t100_vars[] = { 264 { "INT33F0:00_CsiPort", "0" }, 265 { "INT33F0:00_CsiLanes", "1" }, 266 { "INT33F0:00_CamClk", "1" }, 267 {}, 268 }; 269 270 static struct gmin_cfg_var mrd7_vars[] = { 271 {"INT33F8:00_CamType", "1"}, 272 {"INT33F8:00_CsiPort", "1"}, 273 {"INT33F8:00_CsiLanes", "2"}, 274 {"INT33F8:00_CsiFmt", "13"}, 275 {"INT33F8:00_CsiBayer", "0"}, 276 {"INT33F8:00_CamClk", "0"}, 277 278 {"INT33F9:00_CamType", "1"}, 279 {"INT33F9:00_CsiPort", "0"}, 280 {"INT33F9:00_CsiLanes", "1"}, 281 {"INT33F9:00_CsiFmt", "13"}, 282 {"INT33F9:00_CsiBayer", "0"}, 283 {"INT33F9:00_CamClk", "1"}, 284 {}, 285 }; 286 287 static struct gmin_cfg_var ecs7_vars[] = { 288 {"INT33BE:00_CsiPort", "1"}, 289 {"INT33BE:00_CsiLanes", "2"}, 290 {"INT33BE:00_CsiFmt", "13"}, 291 {"INT33BE:00_CsiBayer", "2"}, 292 {"INT33BE:00_CamClk", "0"}, 293 294 {"INT33F0:00_CsiPort", "0"}, 295 {"INT33F0:00_CsiLanes", "1"}, 296 {"INT33F0:00_CsiFmt", "13"}, 297 {"INT33F0:00_CsiBayer", "0"}, 298 {"INT33F0:00_CamClk", "1"}, 299 {"gmin_V2P8GPIO", "402"}, 300 {}, 301 }; 302 303 static struct gmin_cfg_var i8880_vars[] = { 304 {"XXOV2680:00_CsiPort", "1"}, 305 {"XXOV2680:00_CsiLanes", "1"}, 306 {"XXOV2680:00_CamClk", "0"}, 307 308 {"XXGC0310:00_CsiPort", "0"}, 309 {"XXGC0310:00_CsiLanes", "1"}, 310 {"XXGC0310:00_CamClk", "1"}, 311 {}, 312 }; 313 314 /* 315 * Surface 3 does not describe CsiPort/CsiLanes in both DSDT and EFI. 316 */ 317 static struct gmin_cfg_var surface3_vars[] = { 318 {"APTA0330:00_CsiPort", "0"}, 319 {"APTA0330:00_CsiLanes", "2"}, 320 321 {"OVTI8835:00_CsiPort", "1"}, 322 {"OVTI8835:00_CsiLanes", "4"}, 323 {}, 324 }; 325 326 static const struct dmi_system_id gmin_vars[] = { 327 { 328 .ident = "BYT-T FFD8", 329 .matches = { 330 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"), 331 }, 332 .driver_data = ffrd8_vars, 333 }, 334 { 335 .ident = "T100TA", 336 .matches = { 337 DMI_MATCH(DMI_BOARD_NAME, "T100TA"), 338 }, 339 .driver_data = t100_vars, 340 }, 341 { 342 .ident = "MRD7", 343 .matches = { 344 DMI_MATCH(DMI_BOARD_NAME, "TABLET"), 345 DMI_MATCH(DMI_BOARD_VERSION, "MRD 7"), 346 }, 347 .driver_data = mrd7_vars, 348 }, 349 { 350 .ident = "ST70408", 351 .matches = { 352 DMI_MATCH(DMI_BOARD_NAME, "ST70408"), 353 }, 354 .driver_data = ecs7_vars, 355 }, 356 { 357 .ident = "VTA0803", 358 .matches = { 359 DMI_MATCH(DMI_BOARD_NAME, "VTA0803"), 360 }, 361 .driver_data = i8880_vars, 362 }, 363 { 364 .ident = "Surface 3", 365 .matches = { 366 DMI_MATCH(DMI_BOARD_NAME, "Surface 3"), 367 }, 368 .driver_data = surface3_vars, 369 }, 370 {} 371 }; 372 373 #define GMIN_CFG_VAR_EFI_GUID EFI_GUID(0xecb54cd9, 0xe5ae, 0x4fdc, \ 374 0xa9, 0x71, 0xe8, 0x77, \ 375 0x75, 0x60, 0x68, 0xf7) 376 377 static const guid_t atomisp_dsm_guid = GUID_INIT(0xdc2f6c4f, 0x045b, 0x4f1d, 378 0x97, 0xb9, 0x88, 0x2a, 379 0x68, 0x60, 0xa4, 0xbe); 380 381 #define CFG_VAR_NAME_MAX 64 382 383 #define GMIN_PMC_CLK_NAME 14 /* "pmc_plt_clk_[0..5]" */ 384 static char gmin_pmc_clk_name[GMIN_PMC_CLK_NAME]; 385 386 static struct i2c_client *gmin_i2c_dev_exists(struct device *dev, char *name, 387 struct i2c_client **client) 388 { 389 struct acpi_device *adev; 390 struct device *d; 391 392 adev = acpi_dev_get_first_match_dev(name, NULL, -1); 393 if (!adev) 394 return NULL; 395 396 d = bus_find_device_by_acpi_dev(&i2c_bus_type, adev); 397 acpi_dev_put(adev); 398 if (!d) 399 return NULL; 400 401 *client = i2c_verify_client(d); 402 put_device(d); 403 404 dev_dbg(dev, "found '%s' at address 0x%02x, adapter %d\n", 405 (*client)->name, (*client)->addr, (*client)->adapter->nr); 406 return *client; 407 } 408 409 static int gmin_i2c_write(struct device *dev, u16 i2c_addr, u8 reg, 410 u32 value, u32 mask) 411 { 412 int ret; 413 414 /* 415 * FIXME: Right now, the intel_pmic driver just write values 416 * directly at the regmap, instead of properly implementing 417 * i2c_transfer() mechanism. Let's use the same interface here, 418 * as otherwise we may face issues. 419 */ 420 421 dev_dbg(dev, 422 "I2C write, addr: 0x%02x, reg: 0x%02x, value: 0x%02x, mask: 0x%02x\n", 423 i2c_addr, reg, value, mask); 424 425 ret = intel_soc_pmic_exec_mipi_pmic_seq_element(i2c_addr, reg, value, mask); 426 if (ret == -EOPNOTSUPP) 427 dev_err(dev, 428 "ACPI didn't mapped the OpRegion needed to access I2C address 0x%02x.\n" 429 "Need to compile the kernel using CONFIG_*_PMIC_OPREGION settings\n", 430 i2c_addr); 431 432 return ret; 433 } 434 435 static int atomisp_get_acpi_power(struct device *dev) 436 { 437 char name[5]; 438 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 439 struct acpi_buffer b_name = { sizeof(name), name }; 440 union acpi_object *package, *element; 441 acpi_handle handle = ACPI_HANDLE(dev); 442 acpi_handle rhandle; 443 acpi_status status; 444 int clock_num = -1; 445 int i; 446 447 status = acpi_evaluate_object(handle, "_PR0", NULL, &buffer); 448 if (!ACPI_SUCCESS(status)) 449 return -1; 450 451 package = buffer.pointer; 452 453 if (!buffer.length || !package 454 || package->type != ACPI_TYPE_PACKAGE 455 || !package->package.count) 456 goto fail; 457 458 for (i = 0; i < package->package.count; i++) { 459 element = &package->package.elements[i]; 460 461 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) 462 continue; 463 464 rhandle = element->reference.handle; 465 if (!rhandle) 466 goto fail; 467 468 acpi_get_name(rhandle, ACPI_SINGLE_NAME, &b_name); 469 470 dev_dbg(dev, "Found PM resource '%s'\n", name); 471 if (strlen(name) == 4 && !strncmp(name, "CLK", 3)) { 472 if (name[3] >= '0' && name[3] <= '4') 473 clock_num = name[3] - '0'; 474 #if 0 475 /* 476 * We could abort here, but let's parse all resources, 477 * as this is helpful for debugging purposes 478 */ 479 if (clock_num >= 0) 480 break; 481 #endif 482 } 483 } 484 485 fail: 486 ACPI_FREE(buffer.pointer); 487 488 return clock_num; 489 } 490 491 static u8 gmin_get_pmic_id_and_addr(struct device *dev) 492 { 493 struct i2c_client *power = NULL; 494 static u8 pmic_i2c_addr; 495 496 if (pmic_id) 497 return pmic_i2c_addr; 498 499 if (gmin_i2c_dev_exists(dev, PMIC_ACPI_TI, &power)) 500 pmic_id = PMIC_TI; 501 else if (gmin_i2c_dev_exists(dev, PMIC_ACPI_AXP, &power)) 502 pmic_id = PMIC_AXP; 503 else if (gmin_i2c_dev_exists(dev, PMIC_ACPI_CRYSTALCOVE, &power)) 504 pmic_id = PMIC_CRYSTALCOVE; 505 else 506 pmic_id = PMIC_REGULATOR; 507 508 pmic_i2c_addr = power ? power->addr : 0; 509 return pmic_i2c_addr; 510 } 511 512 static int gmin_detect_pmic(struct v4l2_subdev *subdev) 513 { 514 struct i2c_client *client = v4l2_get_subdevdata(subdev); 515 struct device *dev = &client->dev; 516 u8 pmic_i2c_addr; 517 518 pmic_i2c_addr = gmin_get_pmic_id_and_addr(dev); 519 dev_info(dev, "gmin: power management provided via %s (i2c addr 0x%02x)\n", 520 pmic_name[pmic_id], pmic_i2c_addr); 521 return pmic_i2c_addr; 522 } 523 524 static int gmin_subdev_add(struct gmin_subdev *gs) 525 { 526 struct i2c_client *client = v4l2_get_subdevdata(gs->subdev); 527 struct device *dev = &client->dev; 528 struct acpi_device *adev = ACPI_COMPANION(dev); 529 int ret, default_val, clock_num = -1; 530 531 dev_info(dev, "%s: ACPI path is %pfw\n", __func__, dev_fwnode(dev)); 532 533 /*WA:CHT requires XTAL clock as PLL is not stable.*/ 534 gs->clock_src = gmin_get_var_int(dev, false, "ClkSrc", 535 VLV2_CLK_PLL_19P2MHZ); 536 537 /* 538 * Get ACPI _PR0 derived clock here already because it is used 539 * to determine the csi_port default. 540 */ 541 if (acpi_device_power_manageable(adev)) 542 clock_num = atomisp_get_acpi_power(dev); 543 544 /* Compare clock to CsiPort 1 pmc-clock used in the CHT/BYT reference designs */ 545 if (IS_ISP2401) 546 default_val = clock_num == 4 ? 1 : 0; 547 else 548 default_val = clock_num == 0 ? 1 : 0; 549 550 gs->csi_port = gmin_get_var_int(dev, false, "CsiPort", default_val); 551 gs->csi_lanes = gmin_get_var_int(dev, false, "CsiLanes", 1); 552 553 gs->gpio0 = gpiod_get_index(dev, NULL, 0, GPIOD_OUT_LOW); 554 if (IS_ERR(gs->gpio0)) 555 gs->gpio0 = NULL; 556 else 557 dev_info(dev, "will handle gpio0 via ACPI\n"); 558 559 gs->gpio1 = gpiod_get_index(dev, NULL, 1, GPIOD_OUT_LOW); 560 if (IS_ERR(gs->gpio1)) 561 gs->gpio1 = NULL; 562 else 563 dev_info(dev, "will handle gpio1 via ACPI\n"); 564 565 /* 566 * Those are used only when there is an external regulator apart 567 * from the PMIC that would be providing power supply, like on the 568 * two cases below: 569 * 570 * The ECS E7 board drives camera 2.8v from an external regulator 571 * instead of the PMIC. There's a gmin_CamV2P8 config variable 572 * that specifies the GPIO to handle this particular case, 573 * but this needs a broader architecture for handling camera power. 574 * 575 * The CHT RVP board drives camera 1.8v from an* external regulator 576 * instead of the PMIC just like ECS E7 board. 577 */ 578 579 gs->v1p8_gpio = gmin_get_var_int(dev, true, "V1P8GPIO", -1); 580 gs->v2p8_gpio = gmin_get_var_int(dev, true, "V2P8GPIO", -1); 581 582 /* 583 * FIXME: 584 * 585 * The ACPI handling code checks for the _PR? tables in order to 586 * know what is required to switch the device from power state 587 * D0 (_PR0) up to D3COLD (_PR3). 588 * 589 * The adev->flags.power_manageable is set to true if the device 590 * has a _PR0 table, which can be checked by calling 591 * acpi_device_power_manageable(adev). 592 * 593 * However, this only says that the device can be set to power off 594 * mode. 595 * 596 * At least on the DSDT tables we've seen so far, there's no _PR3, 597 * nor _PS3 (which would have a somewhat similar effect). 598 * So, using ACPI for power management won't work, except if adding 599 * an ACPI override logic somewhere. 600 * 601 * So, at least for the existing devices we know, the check below 602 * will always be false. 603 */ 604 if (acpi_device_can_wakeup(adev) && 605 acpi_device_can_poweroff(adev)) { 606 dev_info(dev, 607 "gmin: power management provided via device PM\n"); 608 return 0; 609 } 610 611 /* 612 * The code below is here due to backward compatibility with devices 613 * whose ACPI BIOS may not contain everything that would be needed 614 * in order to set clocks and do power management. 615 */ 616 617 /* 618 * According with : 619 * https://github.com/projectceladon/hardware-intel-kernelflinger/blob/master/doc/fastboot.md 620 * 621 * The "CamClk" EFI var is set via fastboot on some Android devices, 622 * and seems to contain the number of the clock used to feed the 623 * sensor. 624 * 625 * On systems with a proper ACPI table, this is given via the _PR0 626 * power resource table. The logic below should first check if there 627 * is a power resource already, falling back to the EFI vars detection 628 * otherwise. 629 */ 630 631 /* If getting the clock from _PR0 above failed, fall-back to EFI and/or DMI match */ 632 if (clock_num < 0) 633 clock_num = gmin_get_var_int(dev, false, "CamClk", 0); 634 635 if (clock_num < 0 || clock_num > MAX_CLK_COUNT) { 636 dev_err(dev, "Invalid clock number\n"); 637 return -EINVAL; 638 } 639 640 snprintf(gmin_pmc_clk_name, sizeof(gmin_pmc_clk_name), 641 "%s_%d", "pmc_plt_clk", clock_num); 642 643 gs->pmc_clk = devm_clk_get(dev, gmin_pmc_clk_name); 644 if (IS_ERR(gs->pmc_clk)) { 645 ret = PTR_ERR(gs->pmc_clk); 646 dev_err(dev, "Failed to get clk from %s: %d\n", gmin_pmc_clk_name, ret); 647 return ret; 648 } 649 dev_info(dev, "Will use CLK%d (%s)\n", clock_num, gmin_pmc_clk_name); 650 651 /* 652 * The firmware might enable the clock at 653 * boot (this information may or may not 654 * be reflected in the enable clock register). 655 * To change the rate we must disable the clock 656 * first to cover these cases. Due to common 657 * clock framework restrictions that do not allow 658 * to disable a clock that has not been enabled, 659 * we need to enable the clock first. 660 */ 661 ret = clk_prepare_enable(gs->pmc_clk); 662 if (!ret) 663 clk_disable_unprepare(gs->pmc_clk); 664 665 switch (pmic_id) { 666 case PMIC_REGULATOR: 667 gs->v1p8_reg = regulator_get(dev, "V1P8SX"); 668 gs->v2p8_reg = regulator_get(dev, "V2P8SX"); 669 670 gs->v1p2_reg = regulator_get(dev, "V1P2A"); 671 gs->v2p8_vcm_reg = regulator_get(dev, "VPROG4B"); 672 673 /* Note: ideally we would initialize v[12]p8_on to the 674 * output of regulator_is_enabled(), but sadly that 675 * API is broken with the current drivers, returning 676 * "1" for a regulator that will then emit a 677 * "unbalanced disable" WARNing if we try to disable 678 * it. 679 */ 680 break; 681 682 case PMIC_AXP: 683 gs->eldo1_1p6v = gmin_get_var_int(dev, false, 684 "eldo1_1p8v", 685 ELDO1_1P6V); 686 gs->eldo1_sel_reg = gmin_get_var_int(dev, false, 687 "eldo1_sel_reg", 688 ELDO1_SEL_REG); 689 gs->eldo1_ctrl_shift = gmin_get_var_int(dev, false, 690 "eldo1_ctrl_shift", 691 ELDO1_CTRL_SHIFT); 692 gs->eldo2_1p8v = gmin_get_var_int(dev, false, 693 "eldo2_1p8v", 694 ELDO2_1P8V); 695 gs->eldo2_sel_reg = gmin_get_var_int(dev, false, 696 "eldo2_sel_reg", 697 ELDO2_SEL_REG); 698 gs->eldo2_ctrl_shift = gmin_get_var_int(dev, false, 699 "eldo2_ctrl_shift", 700 ELDO2_CTRL_SHIFT); 701 break; 702 703 default: 704 break; 705 } 706 707 return 0; 708 } 709 710 static struct gmin_subdev *find_gmin_subdev(struct v4l2_subdev *subdev) 711 { 712 int i; 713 714 for (i = 0; i < MAX_SUBDEVS; i++) 715 if (gmin_subdevs[i].subdev == subdev) 716 return &gmin_subdevs[i]; 717 return NULL; 718 } 719 720 static struct gmin_subdev *find_free_gmin_subdev_slot(void) 721 { 722 unsigned int i; 723 724 for (i = 0; i < MAX_SUBDEVS; i++) 725 if (gmin_subdevs[i].subdev == NULL) 726 return &gmin_subdevs[i]; 727 return NULL; 728 } 729 730 static int axp_regulator_set(struct device *dev, struct gmin_subdev *gs, 731 int sel_reg, u8 setting, 732 int ctrl_reg, int shift, bool on) 733 { 734 int ret; 735 int val; 736 737 ret = gmin_i2c_write(dev, gs->pwm_i2c_addr, sel_reg, setting, 0xff); 738 if (ret) 739 return ret; 740 741 val = on ? 1 << shift : 0; 742 743 ret = gmin_i2c_write(dev, gs->pwm_i2c_addr, ctrl_reg, val, 1 << shift); 744 if (ret) 745 return ret; 746 747 return 0; 748 } 749 750 /* 751 * Some boards contain a hw-bug where turning eldo2 back on after having turned 752 * it off causes the CPLM3218 ambient-light-sensor on the image-sensor's I2C bus 753 * to crash, hanging the bus. Do not turn eldo2 off on these systems. 754 */ 755 static const struct dmi_system_id axp_leave_eldo2_on_ids[] = { 756 { 757 .matches = { 758 DMI_MATCH(DMI_SYS_VENDOR, "TrekStor"), 759 DMI_MATCH(DMI_PRODUCT_NAME, "SurfTab duo W1 10.1 (VT4)"), 760 }, 761 }, 762 { } 763 }; 764 765 static int axp_v1p8_on(struct device *dev, struct gmin_subdev *gs) 766 { 767 int ret; 768 769 ret = axp_regulator_set(dev, gs, gs->eldo2_sel_reg, gs->eldo2_1p8v, 770 ELDO_CTRL_REG, gs->eldo2_ctrl_shift, true); 771 if (ret) 772 return ret; 773 774 /* 775 * This sleep comes out of the gc2235 driver, which is the 776 * only one I currently see that wants to set both 1.8v rails. 777 */ 778 usleep_range(110, 150); 779 780 ret = axp_regulator_set(dev, gs, gs->eldo1_sel_reg, gs->eldo1_1p6v, 781 ELDO_CTRL_REG, gs->eldo1_ctrl_shift, true); 782 return ret; 783 } 784 785 static int axp_v1p8_off(struct device *dev, struct gmin_subdev *gs) 786 { 787 int ret; 788 789 ret = axp_regulator_set(dev, gs, gs->eldo1_sel_reg, gs->eldo1_1p6v, 790 ELDO_CTRL_REG, gs->eldo1_ctrl_shift, false); 791 if (ret) 792 return ret; 793 794 if (dmi_check_system(axp_leave_eldo2_on_ids)) 795 return 0; 796 797 ret = axp_regulator_set(dev, gs, gs->eldo2_sel_reg, gs->eldo2_1p8v, 798 ELDO_CTRL_REG, gs->eldo2_ctrl_shift, false); 799 return ret; 800 } 801 802 static int gmin_gpio0_ctrl(struct v4l2_subdev *subdev, int on) 803 { 804 struct gmin_subdev *gs = find_gmin_subdev(subdev); 805 806 if (gs) { 807 gpiod_set_value(gs->gpio0, on); 808 return 0; 809 } 810 return -EINVAL; 811 } 812 813 static int gmin_gpio1_ctrl(struct v4l2_subdev *subdev, int on) 814 { 815 struct gmin_subdev *gs = find_gmin_subdev(subdev); 816 817 if (gs) { 818 gpiod_set_value(gs->gpio1, on); 819 return 0; 820 } 821 return -EINVAL; 822 } 823 824 static int gmin_v1p2_ctrl(struct v4l2_subdev *subdev, int on) 825 { 826 struct gmin_subdev *gs = find_gmin_subdev(subdev); 827 828 if (!gs || gs->v1p2_on == on) 829 return 0; 830 gs->v1p2_on = on; 831 832 /* use regulator for PMIC */ 833 if (gs->v1p2_reg) { 834 if (on) 835 return regulator_enable(gs->v1p2_reg); 836 else 837 return regulator_disable(gs->v1p2_reg); 838 } 839 840 /* TODO:v1p2 may need to extend to other PMICs */ 841 842 return -EINVAL; 843 } 844 845 static int gmin_v1p8_ctrl(struct v4l2_subdev *subdev, int on) 846 { 847 struct gmin_subdev *gs = find_gmin_subdev(subdev); 848 int ret; 849 int value; 850 int reg; 851 852 if (!gs || gs->v1p8_on == on) 853 return 0; 854 855 if (gs->v1p8_gpio >= 0) { 856 pr_info("atomisp_gmin_platform: 1.8v power on GPIO %d\n", 857 gs->v1p8_gpio); 858 ret = gpio_request(gs->v1p8_gpio, "camera_v1p8_en"); 859 if (!ret) 860 ret = gpio_direction_output(gs->v1p8_gpio, 0); 861 if (ret) 862 pr_err("V1P8 GPIO initialization failed\n"); 863 } 864 865 gs->v1p8_on = on; 866 867 ret = 0; 868 mutex_lock(&gmin_regulator_mutex); 869 if (on) { 870 gmin_v1p8_enable_count++; 871 if (gmin_v1p8_enable_count > 1) 872 goto out; /* Already on */ 873 } else { 874 gmin_v1p8_enable_count--; 875 if (gmin_v1p8_enable_count > 0) 876 goto out; /* Still needed */ 877 } 878 879 if (gs->v1p8_gpio >= 0) 880 gpio_set_value(gs->v1p8_gpio, on); 881 882 if (gs->v1p8_reg) { 883 regulator_set_voltage(gs->v1p8_reg, 1800000, 1800000); 884 if (on) 885 ret = regulator_enable(gs->v1p8_reg); 886 else 887 ret = regulator_disable(gs->v1p8_reg); 888 889 goto out; 890 } 891 892 switch (pmic_id) { 893 case PMIC_AXP: 894 if (on) 895 ret = axp_v1p8_on(subdev->dev, gs); 896 else 897 ret = axp_v1p8_off(subdev->dev, gs); 898 break; 899 case PMIC_TI: 900 value = on ? LDO_1P8V_ON : LDO_1P8V_OFF; 901 902 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr, 903 LDO10_REG, value, 0xff); 904 break; 905 case PMIC_CRYSTALCOVE: 906 if (IS_ISP2401) 907 reg = CRYSTAL_CHT_1P8V_REG; 908 else 909 reg = CRYSTAL_BYT_1P8V_REG; 910 911 value = on ? CRYSTAL_ON : CRYSTAL_OFF; 912 913 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr, 914 reg, value, 0xff); 915 break; 916 default: 917 dev_err(subdev->dev, "Couldn't set power mode for v1p8\n"); 918 ret = -EINVAL; 919 } 920 921 out: 922 mutex_unlock(&gmin_regulator_mutex); 923 return ret; 924 } 925 926 static int gmin_v2p8_ctrl(struct v4l2_subdev *subdev, int on) 927 { 928 struct gmin_subdev *gs = find_gmin_subdev(subdev); 929 int ret; 930 int value; 931 int reg; 932 933 if (WARN_ON(!gs)) 934 return -ENODEV; 935 936 if (gs->v2p8_gpio >= 0) { 937 pr_info("atomisp_gmin_platform: 2.8v power on GPIO %d\n", 938 gs->v2p8_gpio); 939 ret = gpio_request(gs->v2p8_gpio, "camera_v2p8"); 940 if (!ret) 941 ret = gpio_direction_output(gs->v2p8_gpio, 0); 942 if (ret) 943 pr_err("V2P8 GPIO initialization failed\n"); 944 } 945 946 if (gs->v2p8_on == on) 947 return 0; 948 gs->v2p8_on = on; 949 950 ret = 0; 951 mutex_lock(&gmin_regulator_mutex); 952 if (on) { 953 gmin_v2p8_enable_count++; 954 if (gmin_v2p8_enable_count > 1) 955 goto out; /* Already on */ 956 } else { 957 gmin_v2p8_enable_count--; 958 if (gmin_v2p8_enable_count > 0) 959 goto out; /* Still needed */ 960 } 961 962 if (gs->v2p8_gpio >= 0) 963 gpio_set_value(gs->v2p8_gpio, on); 964 965 if (gs->v2p8_reg) { 966 regulator_set_voltage(gs->v2p8_reg, 2900000, 2900000); 967 if (on) 968 ret = regulator_enable(gs->v2p8_reg); 969 else 970 ret = regulator_disable(gs->v2p8_reg); 971 972 goto out; 973 } 974 975 switch (pmic_id) { 976 case PMIC_AXP: 977 ret = axp_regulator_set(subdev->dev, gs, ALDO1_SEL_REG, 978 ALDO1_2P8V, ALDO1_CTRL3_REG, 979 ALDO1_CTRL3_SHIFT, on); 980 break; 981 case PMIC_TI: 982 value = on ? LDO_2P8V_ON : LDO_2P8V_OFF; 983 984 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr, 985 LDO9_REG, value, 0xff); 986 break; 987 case PMIC_CRYSTALCOVE: 988 if (IS_ISP2401) 989 reg = CRYSTAL_CHT_2P8V_REG; 990 else 991 reg = CRYSTAL_BYT_2P8V_REG; 992 993 value = on ? CRYSTAL_ON : CRYSTAL_OFF; 994 995 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr, 996 reg, value, 0xff); 997 break; 998 default: 999 dev_err(subdev->dev, "Couldn't set power mode for v2p8\n"); 1000 ret = -EINVAL; 1001 } 1002 1003 out: 1004 mutex_unlock(&gmin_regulator_mutex); 1005 return ret; 1006 } 1007 1008 static int gmin_acpi_pm_ctrl(struct v4l2_subdev *subdev, int on) 1009 { 1010 int ret = 0; 1011 struct gmin_subdev *gs = find_gmin_subdev(subdev); 1012 struct i2c_client *client = v4l2_get_subdevdata(subdev); 1013 struct acpi_device *adev = ACPI_COMPANION(&client->dev); 1014 1015 /* Use the ACPI power management to control it */ 1016 on = !!on; 1017 if (gs->clock_on == on) 1018 return 0; 1019 1020 dev_dbg(subdev->dev, "Setting power state to %s\n", 1021 on ? "on" : "off"); 1022 1023 if (on) 1024 ret = acpi_device_set_power(adev, 1025 ACPI_STATE_D0); 1026 else 1027 ret = acpi_device_set_power(adev, 1028 ACPI_STATE_D3_COLD); 1029 1030 if (!ret) 1031 gs->clock_on = on; 1032 else 1033 dev_err(subdev->dev, "Couldn't set power state to %s\n", 1034 on ? "on" : "off"); 1035 1036 return ret; 1037 } 1038 1039 static int gmin_flisclk_ctrl(struct v4l2_subdev *subdev, int on) 1040 { 1041 int ret = 0; 1042 struct gmin_subdev *gs = find_gmin_subdev(subdev); 1043 struct i2c_client *client = v4l2_get_subdevdata(subdev); 1044 1045 if (gs->clock_on == !!on) 1046 return 0; 1047 1048 if (on) { 1049 ret = clk_set_rate(gs->pmc_clk, 1050 gs->clock_src ? CLK_RATE_19_2MHZ : CLK_RATE_25_0MHZ); 1051 1052 if (ret) 1053 dev_err(&client->dev, "unable to set PMC rate %d\n", 1054 gs->clock_src); 1055 1056 ret = clk_prepare_enable(gs->pmc_clk); 1057 if (ret == 0) 1058 gs->clock_on = true; 1059 } else { 1060 clk_disable_unprepare(gs->pmc_clk); 1061 gs->clock_on = false; 1062 } 1063 1064 return ret; 1065 } 1066 1067 static int camera_sensor_csi_alloc(struct v4l2_subdev *sd, u32 port, u32 lanes, 1068 u32 format, u32 bayer_order) 1069 { 1070 struct i2c_client *client = v4l2_get_subdevdata(sd); 1071 struct camera_mipi_info *csi; 1072 1073 csi = kzalloc(sizeof(*csi), GFP_KERNEL); 1074 if (!csi) 1075 return -ENOMEM; 1076 1077 csi->port = port; 1078 csi->num_lanes = lanes; 1079 csi->input_format = format; 1080 csi->raw_bayer_order = bayer_order; 1081 v4l2_set_subdev_hostdata(sd, csi); 1082 csi->metadata_format = ATOMISP_INPUT_FORMAT_EMBEDDED; 1083 csi->metadata_effective_width = NULL; 1084 dev_info(&client->dev, 1085 "camera pdata: port: %d lanes: %d order: %8.8x\n", 1086 port, lanes, bayer_order); 1087 1088 return 0; 1089 } 1090 1091 static void camera_sensor_csi_free(struct v4l2_subdev *sd) 1092 { 1093 struct camera_mipi_info *csi; 1094 1095 csi = v4l2_get_subdev_hostdata(sd); 1096 kfree(csi); 1097 } 1098 1099 static int gmin_csi_cfg(struct v4l2_subdev *sd, int flag) 1100 { 1101 struct i2c_client *client = v4l2_get_subdevdata(sd); 1102 struct gmin_subdev *gs = find_gmin_subdev(sd); 1103 1104 if (!client || !gs) 1105 return -ENODEV; 1106 1107 if (flag) 1108 return camera_sensor_csi_alloc(sd, gs->csi_port, gs->csi_lanes, 1109 gs->csi_fmt, gs->csi_bayer); 1110 camera_sensor_csi_free(sd); 1111 return 0; 1112 } 1113 1114 static struct camera_vcm_control *gmin_get_vcm_ctrl(struct v4l2_subdev *subdev, 1115 char *camera_module) 1116 { 1117 struct i2c_client *client = v4l2_get_subdevdata(subdev); 1118 struct gmin_subdev *gs = find_gmin_subdev(subdev); 1119 struct camera_vcm_control *vcm; 1120 1121 if (!client || !gs) 1122 return NULL; 1123 1124 if (!camera_module) 1125 return NULL; 1126 1127 mutex_lock(&vcm_lock); 1128 list_for_each_entry(vcm, &vcm_devices, list) { 1129 if (!strcmp(camera_module, vcm->camera_module)) { 1130 mutex_unlock(&vcm_lock); 1131 return vcm; 1132 } 1133 } 1134 1135 mutex_unlock(&vcm_lock); 1136 return NULL; 1137 } 1138 1139 static struct camera_sensor_platform_data pmic_gmin_plat = { 1140 .gpio0_ctrl = gmin_gpio0_ctrl, 1141 .gpio1_ctrl = gmin_gpio1_ctrl, 1142 .v1p8_ctrl = gmin_v1p8_ctrl, 1143 .v2p8_ctrl = gmin_v2p8_ctrl, 1144 .v1p2_ctrl = gmin_v1p2_ctrl, 1145 .flisclk_ctrl = gmin_flisclk_ctrl, 1146 .csi_cfg = gmin_csi_cfg, 1147 .get_vcm_ctrl = gmin_get_vcm_ctrl, 1148 }; 1149 1150 static struct camera_sensor_platform_data acpi_gmin_plat = { 1151 .gpio0_ctrl = gmin_gpio0_ctrl, 1152 .gpio1_ctrl = gmin_gpio1_ctrl, 1153 .v1p8_ctrl = gmin_acpi_pm_ctrl, 1154 .v2p8_ctrl = gmin_acpi_pm_ctrl, 1155 .v1p2_ctrl = gmin_acpi_pm_ctrl, 1156 .flisclk_ctrl = gmin_acpi_pm_ctrl, 1157 .csi_cfg = gmin_csi_cfg, 1158 .get_vcm_ctrl = gmin_get_vcm_ctrl, 1159 }; 1160 1161 struct camera_sensor_platform_data * 1162 gmin_camera_platform_data(struct v4l2_subdev *subdev, 1163 enum atomisp_input_format csi_format, 1164 enum atomisp_bayer_order csi_bayer) 1165 { 1166 u8 pmic_i2c_addr = gmin_detect_pmic(subdev); 1167 struct gmin_subdev *gs; 1168 1169 gs = find_free_gmin_subdev_slot(); 1170 gs->subdev = subdev; 1171 gs->csi_fmt = csi_format; 1172 gs->csi_bayer = csi_bayer; 1173 gs->pwm_i2c_addr = pmic_i2c_addr; 1174 1175 gmin_subdev_add(gs); 1176 if (gs->pmc_clk) 1177 return &pmic_gmin_plat; 1178 else 1179 return &acpi_gmin_plat; 1180 } 1181 EXPORT_SYMBOL_GPL(gmin_camera_platform_data); 1182 1183 int atomisp_gmin_register_vcm_control(struct camera_vcm_control *vcmCtrl) 1184 { 1185 if (!vcmCtrl) 1186 return -EINVAL; 1187 1188 mutex_lock(&vcm_lock); 1189 list_add_tail(&vcmCtrl->list, &vcm_devices); 1190 mutex_unlock(&vcm_lock); 1191 1192 return 0; 1193 } 1194 EXPORT_SYMBOL_GPL(atomisp_gmin_register_vcm_control); 1195 1196 static int gmin_get_hardcoded_var(struct device *dev, 1197 struct gmin_cfg_var *varlist, 1198 const char *var8, char *out, size_t *out_len) 1199 { 1200 struct gmin_cfg_var *gv; 1201 1202 for (gv = varlist; gv->name; gv++) { 1203 size_t vl; 1204 1205 if (strcmp(var8, gv->name)) 1206 continue; 1207 1208 dev_info(dev, "Found DMI entry for '%s'\n", var8); 1209 1210 vl = strlen(gv->val); 1211 if (vl > *out_len - 1) 1212 return -ENOSPC; 1213 1214 strscpy(out, gv->val, *out_len); 1215 *out_len = vl; 1216 return 0; 1217 } 1218 1219 return -EINVAL; 1220 } 1221 1222 1223 static int gmin_get_config_dsm_var(struct device *dev, 1224 const char *var, 1225 char *out, size_t *out_len) 1226 { 1227 acpi_handle handle = ACPI_HANDLE(dev); 1228 union acpi_object *obj, *cur = NULL; 1229 int i; 1230 1231 /* 1232 * The data reported by "CamClk" seems to be either 0 or 1 at the 1233 * _DSM table. 1234 * 1235 * At the ACPI tables we looked so far, this is not related to the 1236 * actual clock source for the sensor, which is given by the 1237 * _PR0 ACPI table. So, ignore it, as otherwise this will be 1238 * set to a wrong value. 1239 */ 1240 if (!strcmp(var, "CamClk")) 1241 return -EINVAL; 1242 1243 /* Return on unexpected object type */ 1244 obj = acpi_evaluate_dsm_typed(handle, &atomisp_dsm_guid, 0, 0, NULL, 1245 ACPI_TYPE_PACKAGE); 1246 if (!obj) { 1247 dev_info_once(dev, "Didn't find ACPI _DSM table.\n"); 1248 return -EINVAL; 1249 } 1250 1251 #if 0 /* Just for debugging purposes */ 1252 for (i = 0; i < obj->package.count; i++) { 1253 union acpi_object *cur = &obj->package.elements[i]; 1254 1255 if (cur->type == ACPI_TYPE_INTEGER) 1256 dev_info(dev, "object #%d, type %d, value: %lld\n", 1257 i, cur->type, cur->integer.value); 1258 else if (cur->type == ACPI_TYPE_STRING) 1259 dev_info(dev, "object #%d, type %d, string: %s\n", 1260 i, cur->type, cur->string.pointer); 1261 else 1262 dev_info(dev, "object #%d, type %d\n", 1263 i, cur->type); 1264 } 1265 #endif 1266 1267 /* Seek for the desired var */ 1268 for (i = 0; i < obj->package.count - 1; i += 2) { 1269 if (obj->package.elements[i].type == ACPI_TYPE_STRING && 1270 !strcmp(obj->package.elements[i].string.pointer, var)) { 1271 /* Next element should be the required value */ 1272 cur = &obj->package.elements[i + 1]; 1273 break; 1274 } 1275 } 1276 1277 if (!cur) { 1278 dev_info(dev, "didn't found _DSM entry for '%s'\n", var); 1279 ACPI_FREE(obj); 1280 return -EINVAL; 1281 } 1282 1283 /* 1284 * While it could be possible to have an ACPI_TYPE_INTEGER, 1285 * and read the value from cur->integer.value, the table 1286 * seen so far uses the string type. So, produce a warning 1287 * if it founds something different than string, letting it 1288 * to fall back to the old code. 1289 */ 1290 if (cur && cur->type != ACPI_TYPE_STRING) { 1291 dev_info(dev, "found non-string _DSM entry for '%s'\n", var); 1292 ACPI_FREE(obj); 1293 return -EINVAL; 1294 } 1295 1296 dev_info(dev, "found _DSM entry for '%s': %s\n", var, 1297 cur->string.pointer); 1298 strscpy(out, cur->string.pointer, *out_len); 1299 *out_len = strlen(cur->string.pointer); 1300 1301 ACPI_FREE(obj); 1302 return 0; 1303 } 1304 1305 /* Retrieves a device-specific configuration variable. The dev 1306 * argument should be a device with an ACPI companion, as all 1307 * configuration is based on firmware ID. 1308 */ 1309 static int gmin_get_config_var(struct device *maindev, 1310 bool is_gmin, 1311 const char *var, 1312 char *out, size_t *out_len) 1313 { 1314 efi_char16_t var16[CFG_VAR_NAME_MAX]; 1315 const struct dmi_system_id *id; 1316 struct device *dev = maindev; 1317 char var8[CFG_VAR_NAME_MAX]; 1318 efi_status_t status; 1319 int i, ret; 1320 1321 /* For sensors, try first to use the _DSM table */ 1322 if (!is_gmin) { 1323 ret = gmin_get_config_dsm_var(maindev, var, out, out_len); 1324 if (!ret) 1325 return 0; 1326 } 1327 1328 /* Fall-back to other approaches */ 1329 1330 if (!is_gmin && ACPI_COMPANION(dev)) 1331 dev = &ACPI_COMPANION(dev)->dev; 1332 1333 if (!is_gmin) 1334 ret = snprintf(var8, sizeof(var8), "%s_%s", dev_name(dev), var); 1335 else 1336 ret = snprintf(var8, sizeof(var8), "gmin_%s", var); 1337 1338 if (ret < 0 || ret >= sizeof(var8) - 1) 1339 return -EINVAL; 1340 1341 /* First check a hard-coded list of board-specific variables. 1342 * Some device firmwares lack the ability to set EFI variables at 1343 * runtime. 1344 */ 1345 id = dmi_first_match(gmin_vars); 1346 if (id) { 1347 ret = gmin_get_hardcoded_var(maindev, id->driver_data, var8, 1348 out, out_len); 1349 if (!ret) 1350 return 0; 1351 } 1352 1353 /* Our variable names are ASCII by construction, but EFI names 1354 * are wide chars. Convert and zero-pad. 1355 */ 1356 memset(var16, 0, sizeof(var16)); 1357 for (i = 0; i < sizeof(var8) && var8[i]; i++) 1358 var16[i] = var8[i]; 1359 1360 status = EFI_UNSUPPORTED; 1361 if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE)) 1362 status = efi.get_variable(var16, &GMIN_CFG_VAR_EFI_GUID, NULL, 1363 (unsigned long *)out_len, out); 1364 if (status == EFI_SUCCESS) { 1365 dev_info(maindev, "found EFI entry for '%s'\n", var8); 1366 } else if (is_gmin) { 1367 dev_info(maindev, "Failed to find EFI gmin variable %s\n", var8); 1368 } else { 1369 dev_info(maindev, "Failed to find EFI variable %s\n", var8); 1370 } 1371 1372 return ret; 1373 } 1374 1375 int gmin_get_var_int(struct device *dev, bool is_gmin, const char *var, int def) 1376 { 1377 char val[CFG_VAR_NAME_MAX]; 1378 size_t len = sizeof(val); 1379 long result; 1380 int ret; 1381 1382 ret = gmin_get_config_var(dev, is_gmin, var, val, &len); 1383 if (!ret) { 1384 val[len] = 0; 1385 ret = kstrtol(val, 0, &result); 1386 } else { 1387 dev_info(dev, "%s: using default (%d)\n", var, def); 1388 } 1389 1390 return ret ? def : result; 1391 } 1392 EXPORT_SYMBOL_GPL(gmin_get_var_int); 1393 1394 /* PCI quirk: The BYT ISP advertises PCI runtime PM but it doesn't 1395 * work. Disable so the kernel framework doesn't hang the device 1396 * trying. The driver itself does direct calls to the PUNIT to manage 1397 * ISP power. 1398 */ 1399 static void isp_pm_cap_fixup(struct pci_dev *pdev) 1400 { 1401 dev_info(&pdev->dev, "Disabling PCI power management on camera ISP\n"); 1402 pdev->pm_cap = 0; 1403 } 1404 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0f38, isp_pm_cap_fixup); 1405 1406 MODULE_DESCRIPTION("Ancillary routines for binding ACPI devices"); 1407 MODULE_LICENSE("GPL"); 1408