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