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