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