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