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