1 #include <linux/module.h> 2 #include <linux/i2c.h> 3 #include <linux/dmi.h> 4 #include <linux/efi.h> 5 #include <linux/pci.h> 6 #include <linux/acpi.h> 7 #include <linux/clk.h> 8 #include <linux/delay.h> 9 #include <media/v4l2-subdev.h> 10 #include <linux/mfd/intel_soc_pmic.h> 11 #include <linux/regulator/consumer.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/gpio.h> 14 #include <linux/platform_device.h> 15 #include "../../include/linux/atomisp_platform.h" 16 #include "../../include/linux/atomisp_gmin_platform.h" 17 18 #define MAX_SUBDEVS 8 19 20 enum clock_rate { 21 VLV2_CLK_XTAL_25_0MHz = 0, 22 VLV2_CLK_PLL_19P2MHZ = 1 23 }; 24 25 #define CLK_RATE_19_2MHZ 19200000 26 #define CLK_RATE_25_0MHZ 25000000 27 28 #define ELDO1_SEL_REG 0x19 29 #define ELDO1_1P8V 0x16 30 #define ELDO1_CTRL_SHIFT 0x00 31 #define ELDO2_SEL_REG 0x1a 32 #define ELDO2_1P8V 0x16 33 #define ELDO2_CTRL_SHIFT 0x01 34 35 struct gmin_subdev { 36 struct v4l2_subdev *subdev; 37 int clock_num; 38 enum clock_rate clock_src; 39 bool clock_on; 40 struct clk *pmc_clk; 41 struct gpio_desc *gpio0; 42 struct gpio_desc *gpio1; 43 struct regulator *v1p8_reg; 44 struct regulator *v2p8_reg; 45 struct regulator *v1p2_reg; 46 struct regulator *v2p8_vcm_reg; 47 enum atomisp_camera_port csi_port; 48 unsigned int csi_lanes; 49 enum atomisp_input_format csi_fmt; 50 enum atomisp_bayer_order csi_bayer; 51 bool v1p8_on; 52 bool v2p8_on; 53 bool v1p2_on; 54 bool v2p8_vcm_on; 55 }; 56 57 static struct gmin_subdev gmin_subdevs[MAX_SUBDEVS]; 58 59 /* ACPI HIDs for the PMICs that could be used by this driver */ 60 #define PMIC_ACPI_AXP "INT33F4:00" /* XPower AXP288 PMIC */ 61 #define PMIC_ACPI_TI "INT33F5:00" /* Dollar Cove TI PMIC */ 62 #define PMIC_ACPI_CRYSTALCOVE "INT33FD:00" /* Crystal Cove PMIC */ 63 64 static enum { 65 PMIC_UNSET = 0, 66 PMIC_REGULATOR, 67 PMIC_AXP, 68 PMIC_TI, 69 PMIC_CRYSTALCOVE 70 } pmic_id; 71 72 static const char *pmic_name[] = { 73 [PMIC_UNSET] = "unset", 74 [PMIC_REGULATOR] = "regulator driver", 75 [PMIC_AXP] = "XPower AXP288 PMIC", 76 [PMIC_TI] = "Dollar Cove TI PMIC", 77 [PMIC_CRYSTALCOVE] = "Crystal Cove PMIC", 78 }; 79 80 /* The atomisp uses type==0 for the end-of-list marker, so leave space. */ 81 static struct intel_v4l2_subdev_table pdata_subdevs[MAX_SUBDEVS + 1]; 82 83 static const struct atomisp_platform_data pdata = { 84 .subdevs = pdata_subdevs, 85 }; 86 87 /* 88 * Something of a hack. The ECS E7 board drives camera 2.8v from an 89 * external regulator instead of the PMIC. There's a gmin_CamV2P8 90 * config variable that specifies the GPIO to handle this particular 91 * case, but this needs a broader architecture for handling camera 92 * power. 93 */ 94 enum { V2P8_GPIO_UNSET = -2, V2P8_GPIO_NONE = -1 }; 95 static int v2p8_gpio = V2P8_GPIO_UNSET; 96 97 /* 98 * Something of a hack. The CHT RVP board drives camera 1.8v from an 99 * external regulator instead of the PMIC just like ECS E7 board, see the 100 * comments above. 101 */ 102 enum { V1P8_GPIO_UNSET = -2, V1P8_GPIO_NONE = -1 }; 103 static int v1p8_gpio = V1P8_GPIO_UNSET; 104 105 static LIST_HEAD(vcm_devices); 106 static DEFINE_MUTEX(vcm_lock); 107 108 static struct gmin_subdev *find_gmin_subdev(struct v4l2_subdev *subdev); 109 110 /* 111 * Legacy/stub behavior copied from upstream platform_camera.c. The 112 * atomisp driver relies on these values being non-NULL in a few 113 * places, even though they are hard-coded in all current 114 * implementations. 115 */ 116 const struct atomisp_camera_caps *atomisp_get_default_camera_caps(void) 117 { 118 static const struct atomisp_camera_caps caps = { 119 .sensor_num = 1, 120 .sensor = { 121 { .stream_num = 1, }, 122 }, 123 }; 124 return ∩︀ 125 } 126 EXPORT_SYMBOL_GPL(atomisp_get_default_camera_caps); 127 128 const struct atomisp_platform_data *atomisp_get_platform_data(void) 129 { 130 return &pdata; 131 } 132 EXPORT_SYMBOL_GPL(atomisp_get_platform_data); 133 134 int atomisp_register_i2c_module(struct v4l2_subdev *subdev, 135 struct camera_sensor_platform_data *plat_data, 136 enum intel_v4l2_subdev_type type) 137 { 138 int i; 139 struct i2c_board_info *bi; 140 struct gmin_subdev *gs; 141 struct i2c_client *client = v4l2_get_subdevdata(subdev); 142 struct acpi_device *adev = ACPI_COMPANION(&client->dev); 143 144 dev_info(&client->dev, "register atomisp i2c module type %d\n", type); 145 146 /* The windows driver model (and thus most BIOSes by default) 147 * uses ACPI runtime power management for camera devices, but 148 * we don't. Disable it, or else the rails will be needlessly 149 * tickled during suspend/resume. This has caused power and 150 * performance issues on multiple devices. 151 */ 152 adev->power.flags.power_resources = 0; 153 154 for (i = 0; i < MAX_SUBDEVS; i++) 155 if (!pdata.subdevs[i].type) 156 break; 157 158 if (pdata.subdevs[i].type) 159 return -ENOMEM; 160 161 /* Note subtlety of initialization order: at the point where 162 * this registration API gets called, the platform data 163 * callbacks have probably already been invoked, so the 164 * gmin_subdev struct is already initialized for us. 165 */ 166 gs = find_gmin_subdev(subdev); 167 168 pdata.subdevs[i].type = type; 169 pdata.subdevs[i].port = gs->csi_port; 170 pdata.subdevs[i].subdev = subdev; 171 pdata.subdevs[i].v4l2_subdev.i2c_adapter_id = client->adapter->nr; 172 173 /* Convert i2c_client to i2c_board_info */ 174 bi = &pdata.subdevs[i].v4l2_subdev.board_info; 175 memcpy(bi->type, client->name, I2C_NAME_SIZE); 176 bi->flags = client->flags; 177 bi->addr = client->addr; 178 bi->irq = client->irq; 179 bi->platform_data = plat_data; 180 181 return 0; 182 } 183 EXPORT_SYMBOL_GPL(atomisp_register_i2c_module); 184 185 struct v4l2_subdev *atomisp_gmin_find_subdev(struct i2c_adapter *adapter, 186 struct i2c_board_info *board_info) 187 { 188 int i; 189 190 for (i = 0; i < MAX_SUBDEVS && pdata.subdevs[i].type; i++) { 191 struct intel_v4l2_subdev_table *sd = &pdata.subdevs[i]; 192 193 if (sd->v4l2_subdev.i2c_adapter_id == adapter->nr && 194 sd->v4l2_subdev.board_info.addr == board_info->addr) 195 return sd->subdev; 196 } 197 return NULL; 198 } 199 EXPORT_SYMBOL_GPL(atomisp_gmin_find_subdev); 200 201 int atomisp_gmin_remove_subdev(struct v4l2_subdev *sd) 202 { 203 int i, j; 204 205 if (!sd) 206 return 0; 207 208 for (i = 0; i < MAX_SUBDEVS; i++) { 209 if (pdata.subdevs[i].subdev == sd) { 210 for (j = i + 1; j <= MAX_SUBDEVS; j++) 211 pdata.subdevs[j - 1] = pdata.subdevs[j]; 212 } 213 if (gmin_subdevs[i].subdev == sd) { 214 if (gmin_subdevs[i].gpio0) 215 gpiod_put(gmin_subdevs[i].gpio0); 216 gmin_subdevs[i].gpio0 = NULL; 217 if (gmin_subdevs[i].gpio1) 218 gpiod_put(gmin_subdevs[i].gpio1); 219 gmin_subdevs[i].gpio1 = NULL; 220 if (pmic_id == PMIC_REGULATOR) { 221 regulator_put(gmin_subdevs[i].v1p8_reg); 222 regulator_put(gmin_subdevs[i].v2p8_reg); 223 regulator_put(gmin_subdevs[i].v1p2_reg); 224 regulator_put(gmin_subdevs[i].v2p8_vcm_reg); 225 } 226 gmin_subdevs[i].subdev = NULL; 227 } 228 } 229 return 0; 230 } 231 EXPORT_SYMBOL_GPL(atomisp_gmin_remove_subdev); 232 233 struct gmin_cfg_var { 234 const char *name, *val; 235 }; 236 237 static struct gmin_cfg_var ffrd8_vars[] = { 238 { "INTCF1B:00_ImxId", "0x134" }, 239 { "INTCF1B:00_CsiPort", "1" }, 240 { "INTCF1B:00_CsiLanes", "4" }, 241 { "INTCF1B:00_CamClk", "0" }, 242 {}, 243 }; 244 245 /* Cribbed from MCG defaults in the mt9m114 driver, not actually verified 246 * vs. T100 hardware 247 */ 248 static struct gmin_cfg_var t100_vars[] = { 249 { "INT33F0:00_CsiPort", "0" }, 250 { "INT33F0:00_CsiLanes", "1" }, 251 { "INT33F0:00_CamClk", "1" }, 252 {}, 253 }; 254 255 static struct gmin_cfg_var mrd7_vars[] = { 256 {"INT33F8:00_CamType", "1"}, 257 {"INT33F8:00_CsiPort", "1"}, 258 {"INT33F8:00_CsiLanes", "2"}, 259 {"INT33F8:00_CsiFmt", "13"}, 260 {"INT33F8:00_CsiBayer", "0"}, 261 {"INT33F8:00_CamClk", "0"}, 262 {"INT33F9:00_CamType", "1"}, 263 {"INT33F9:00_CsiPort", "0"}, 264 {"INT33F9:00_CsiLanes", "1"}, 265 {"INT33F9:00_CsiFmt", "13"}, 266 {"INT33F9:00_CsiBayer", "0"}, 267 {"INT33F9:00_CamClk", "1"}, 268 {}, 269 }; 270 271 static struct gmin_cfg_var ecs7_vars[] = { 272 {"INT33BE:00_CsiPort", "1"}, 273 {"INT33BE:00_CsiLanes", "2"}, 274 {"INT33BE:00_CsiFmt", "13"}, 275 {"INT33BE:00_CsiBayer", "2"}, 276 {"INT33BE:00_CamClk", "0"}, 277 {"INT33F0:00_CsiPort", "0"}, 278 {"INT33F0:00_CsiLanes", "1"}, 279 {"INT33F0:00_CsiFmt", "13"}, 280 {"INT33F0:00_CsiBayer", "0"}, 281 {"INT33F0:00_CamClk", "1"}, 282 {"gmin_V2P8GPIO", "402"}, 283 {}, 284 }; 285 286 static struct gmin_cfg_var i8880_vars[] = { 287 {"XXOV2680:00_CsiPort", "1"}, 288 {"XXOV2680:00_CsiLanes", "1"}, 289 {"XXOV2680:00_CamClk", "0"}, 290 {"XXGC0310:00_CsiPort", "0"}, 291 {"XXGC0310:00_CsiLanes", "1"}, 292 {"XXGC0310:00_CamClk", "1"}, 293 {}, 294 }; 295 296 static struct gmin_cfg_var asus_vars[] = { 297 {"OVTI2680:00_CsiPort", "1"}, 298 {"OVTI2680:00_CsiLanes", "1"}, 299 {"OVTI2680:00_CsiFmt", "15"}, 300 {"OVTI2680:00_CsiBayer", "0"}, 301 {"OVTI2680:00_CamClk", "0"}, 302 {}, 303 }; 304 305 static const struct dmi_system_id gmin_vars[] = { 306 { 307 .ident = "BYT-T FFD8", 308 .matches = { 309 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"), 310 }, 311 .driver_data = ffrd8_vars, 312 }, 313 { 314 .ident = "T100TA", 315 .matches = { 316 DMI_MATCH(DMI_BOARD_NAME, "T100TA"), 317 }, 318 .driver_data = t100_vars, 319 }, 320 { 321 .ident = "MRD7", 322 .matches = { 323 DMI_MATCH(DMI_BOARD_NAME, "TABLET"), 324 DMI_MATCH(DMI_BOARD_VERSION, "MRD 7"), 325 }, 326 .driver_data = mrd7_vars, 327 }, 328 { 329 .ident = "ST70408", 330 .matches = { 331 DMI_MATCH(DMI_BOARD_NAME, "ST70408"), 332 }, 333 .driver_data = ecs7_vars, 334 }, 335 { 336 .ident = "VTA0803", 337 .matches = { 338 DMI_MATCH(DMI_BOARD_NAME, "VTA0803"), 339 }, 340 .driver_data = i8880_vars, 341 }, 342 { 343 .ident = "T101HA", 344 .matches = { 345 DMI_MATCH(DMI_BOARD_NAME, "T101HA"), 346 }, 347 .driver_data = asus_vars, 348 }, 349 {} 350 }; 351 352 #define GMIN_CFG_VAR_EFI_GUID EFI_GUID(0xecb54cd9, 0xe5ae, 0x4fdc, \ 353 0xa9, 0x71, 0xe8, 0x77, \ 354 0x75, 0x60, 0x68, 0xf7) 355 356 #define CFG_VAR_NAME_MAX 64 357 358 #define GMIN_PMC_CLK_NAME 14 /* "pmc_plt_clk_[0..5]" */ 359 static char gmin_pmc_clk_name[GMIN_PMC_CLK_NAME]; 360 361 struct gmin_match_name { 362 const char *name; 363 struct device *dev; 364 }; 365 366 static int gmin_match_one(struct device *dev, void *data) 367 { 368 struct gmin_match_name *match = data; 369 const char *name = match->name; 370 struct i2c_client *client; 371 372 if (dev->type != &i2c_client_type) 373 return 0; 374 375 client = to_i2c_client(dev); 376 377 dev_info(match->dev, "found '%s' at address 0x%02x, adapter %d\n", 378 client->name, client->addr, client->adapter->nr); 379 380 return (!strcmp(name, client->name)); 381 } 382 383 static bool gmin_i2c_dev_exists(struct device *dev, char *name) 384 { 385 struct gmin_match_name match; 386 bool found; 387 int ret = 0; 388 389 match.dev = dev; 390 match.name = name; 391 392 ret = i2c_for_each_dev(&match, gmin_match_one); 393 394 found = !!ret; 395 396 if (found) 397 dev_info(dev, "%s found on I2C\n", name); 398 else 399 dev_info(dev, "%s not found on I2C\n", name); 400 401 return found; 402 } 403 404 static struct gmin_subdev *gmin_subdev_add(struct v4l2_subdev *subdev) 405 { 406 int i, ret; 407 struct device *dev; 408 struct i2c_client *client = v4l2_get_subdevdata(subdev); 409 410 if (!client) 411 return NULL; 412 413 dev = &client->dev; 414 415 if (!pmic_id) { 416 if (gmin_i2c_dev_exists(dev, PMIC_ACPI_TI)) 417 pmic_id = PMIC_TI; 418 else if (gmin_i2c_dev_exists(dev, PMIC_ACPI_AXP)) 419 pmic_id = PMIC_AXP; 420 else if (gmin_i2c_dev_exists(dev, PMIC_ACPI_CRYSTALCOVE)) 421 pmic_id = PMIC_CRYSTALCOVE; 422 else 423 pmic_id = PMIC_REGULATOR; 424 } 425 426 for (i = 0; i < MAX_SUBDEVS && gmin_subdevs[i].subdev; i++) 427 ; 428 if (i >= MAX_SUBDEVS) 429 return NULL; 430 431 dev_info(dev, 432 "gmin: power management provided via %s\n", 433 pmic_name[pmic_id]); 434 435 gmin_subdevs[i].subdev = subdev; 436 gmin_subdevs[i].clock_num = gmin_get_var_int(dev, false, "CamClk", 0); 437 /*WA:CHT requires XTAL clock as PLL is not stable.*/ 438 gmin_subdevs[i].clock_src = gmin_get_var_int(dev, false, "ClkSrc", 439 VLV2_CLK_PLL_19P2MHZ); 440 gmin_subdevs[i].csi_port = gmin_get_var_int(dev, false, "CsiPort", 0); 441 gmin_subdevs[i].csi_lanes = gmin_get_var_int(dev, false, "CsiLanes", 1); 442 443 /* get PMC clock with clock framework */ 444 snprintf(gmin_pmc_clk_name, 445 sizeof(gmin_pmc_clk_name), 446 "%s_%d", "pmc_plt_clk", gmin_subdevs[i].clock_num); 447 448 gmin_subdevs[i].pmc_clk = devm_clk_get(dev, gmin_pmc_clk_name); 449 if (IS_ERR(gmin_subdevs[i].pmc_clk)) { 450 ret = PTR_ERR(gmin_subdevs[i].pmc_clk); 451 452 dev_err(dev, 453 "Failed to get clk from %s : %d\n", 454 gmin_pmc_clk_name, 455 ret); 456 457 return NULL; 458 } 459 460 /* 461 * The firmware might enable the clock at 462 * boot (this information may or may not 463 * be reflected in the enable clock register). 464 * To change the rate we must disable the clock 465 * first to cover these cases. Due to common 466 * clock framework restrictions that do not allow 467 * to disable a clock that has not been enabled, 468 * we need to enable the clock first. 469 */ 470 ret = clk_prepare_enable(gmin_subdevs[i].pmc_clk); 471 if (!ret) 472 clk_disable_unprepare(gmin_subdevs[i].pmc_clk); 473 474 gmin_subdevs[i].gpio0 = gpiod_get_index(dev, NULL, 0, GPIOD_OUT_LOW); 475 if (IS_ERR(gmin_subdevs[i].gpio0)) 476 gmin_subdevs[i].gpio0 = NULL; 477 478 gmin_subdevs[i].gpio1 = gpiod_get_index(dev, NULL, 1, GPIOD_OUT_LOW); 479 if (IS_ERR(gmin_subdevs[i].gpio1)) 480 gmin_subdevs[i].gpio1 = NULL; 481 482 if (pmic_id == PMIC_REGULATOR) { 483 /* Those regulators may have different names depending on the BIOS */ 484 gmin_subdevs[i].v1p8_reg = regulator_get_optional(dev, "V1P8SX"); 485 gmin_subdevs[i].v2p8_reg = regulator_get_optional(dev, "V2P8SX"); 486 487 488 gmin_subdevs[i].v1p2_reg = regulator_get(dev, "V1P2A"); 489 gmin_subdevs[i].v2p8_vcm_reg = regulator_get(dev, "VPROG4B"); 490 491 /* 492 * Based on DTST dumps on newer Atom E3800 devices, it seems that 493 * the regulators data now have new names. 494 */ 495 if (IS_ERR(gmin_subdevs[i].v1p8_reg)) 496 gmin_subdevs[i].v1p8_reg = regulator_get(dev, "Regulator1p8v"); 497 498 if (IS_ERR(gmin_subdevs[i].v2p8_reg)) 499 gmin_subdevs[i].v2p8_reg = regulator_get(dev, "Regulator2p8v"); 500 501 502 /* Note: ideally we would initialize v[12]p8_on to the 503 * output of regulator_is_enabled(), but sadly that 504 * API is broken with the current drivers, returning 505 * "1" for a regulator that will then emit a 506 * "unbalanced disable" WARNing if we try to disable 507 * it. 508 */ 509 } 510 511 return &gmin_subdevs[i]; 512 } 513 514 static struct gmin_subdev *find_gmin_subdev(struct v4l2_subdev *subdev) 515 { 516 int i; 517 518 for (i = 0; i < MAX_SUBDEVS; i++) 519 if (gmin_subdevs[i].subdev == subdev) 520 return &gmin_subdevs[i]; 521 return gmin_subdev_add(subdev); 522 } 523 524 static int gmin_gpio0_ctrl(struct v4l2_subdev *subdev, int on) 525 { 526 struct gmin_subdev *gs = find_gmin_subdev(subdev); 527 528 if (gs) { 529 gpiod_set_value(gs->gpio0, on); 530 return 0; 531 } 532 return -EINVAL; 533 } 534 535 static int gmin_gpio1_ctrl(struct v4l2_subdev *subdev, int on) 536 { 537 struct gmin_subdev *gs = find_gmin_subdev(subdev); 538 539 if (gs) { 540 gpiod_set_value(gs->gpio1, on); 541 return 0; 542 } 543 return -EINVAL; 544 } 545 546 static int gmin_v1p2_ctrl(struct v4l2_subdev *subdev, int on) 547 { 548 struct gmin_subdev *gs = find_gmin_subdev(subdev); 549 550 if (!gs || gs->v1p2_on == on) 551 return 0; 552 gs->v1p2_on = on; 553 554 if (gs->v1p2_reg) { 555 if (on) 556 return regulator_enable(gs->v1p2_reg); 557 else 558 return regulator_disable(gs->v1p2_reg); 559 } 560 561 /*TODO:v1p2 needs to extend to other PMICs*/ 562 563 return -EINVAL; 564 } 565 566 static int gmin_v1p8_ctrl(struct v4l2_subdev *subdev, int on) 567 { 568 struct gmin_subdev *gs = find_gmin_subdev(subdev); 569 int ret; 570 struct device *dev; 571 struct i2c_client *client = v4l2_get_subdevdata(subdev); 572 573 dev = &client->dev; 574 575 if (v1p8_gpio == V1P8_GPIO_UNSET) { 576 v1p8_gpio = gmin_get_var_int(dev, true, 577 "V1P8GPIO", V1P8_GPIO_NONE); 578 if (v1p8_gpio != V1P8_GPIO_NONE) { 579 pr_info("atomisp_gmin_platform: 1.8v power on GPIO %d\n", 580 v1p8_gpio); 581 ret = gpio_request(v1p8_gpio, "camera_v1p8_en"); 582 if (!ret) 583 ret = gpio_direction_output(v1p8_gpio, 0); 584 if (ret) 585 pr_err("V1P8 GPIO initialization failed\n"); 586 } 587 } 588 589 if (!gs || gs->v1p8_on == on) 590 return 0; 591 gs->v1p8_on = on; 592 593 if (v1p8_gpio >= 0) 594 gpio_set_value(v1p8_gpio, on); 595 596 if (gs->v1p8_reg) { 597 regulator_set_voltage(gs->v1p8_reg, 1800000, 1800000); 598 if (on) 599 return regulator_enable(gs->v1p8_reg); 600 else 601 return regulator_disable(gs->v1p8_reg); 602 } 603 604 return -EINVAL; 605 } 606 607 static int gmin_v2p8_ctrl(struct v4l2_subdev *subdev, int on) 608 { 609 struct gmin_subdev *gs = find_gmin_subdev(subdev); 610 int ret; 611 struct device *dev; 612 struct i2c_client *client = v4l2_get_subdevdata(subdev); 613 614 dev = &client->dev; 615 616 if (v2p8_gpio == V2P8_GPIO_UNSET) { 617 v2p8_gpio = gmin_get_var_int(dev, true, 618 "V2P8GPIO", V2P8_GPIO_NONE); 619 if (v2p8_gpio != V2P8_GPIO_NONE) { 620 pr_info("atomisp_gmin_platform: 2.8v power on GPIO %d\n", 621 v2p8_gpio); 622 ret = gpio_request(v2p8_gpio, "camera_v2p8"); 623 if (!ret) 624 ret = gpio_direction_output(v2p8_gpio, 0); 625 if (ret) 626 pr_err("V2P8 GPIO initialization failed\n"); 627 } 628 } 629 630 if (!gs || gs->v2p8_on == on) 631 return 0; 632 gs->v2p8_on = on; 633 634 if (v2p8_gpio >= 0) 635 gpio_set_value(v2p8_gpio, on); 636 637 if (gs->v2p8_reg) { 638 regulator_set_voltage(gs->v2p8_reg, 2900000, 2900000); 639 if (on) 640 return regulator_enable(gs->v2p8_reg); 641 else 642 return regulator_disable(gs->v2p8_reg); 643 } 644 645 return -EINVAL; 646 } 647 648 static int gmin_flisclk_ctrl(struct v4l2_subdev *subdev, int on) 649 { 650 int ret = 0; 651 struct gmin_subdev *gs = find_gmin_subdev(subdev); 652 struct i2c_client *client = v4l2_get_subdevdata(subdev); 653 654 if (gs->clock_on == !!on) 655 return 0; 656 657 if (on) { 658 ret = clk_set_rate(gs->pmc_clk, gs->clock_src ? CLK_RATE_19_2MHZ : CLK_RATE_25_0MHZ); 659 660 if (ret) 661 dev_err(&client->dev, "unable to set PMC rate %d\n", 662 gs->clock_src); 663 664 ret = clk_prepare_enable(gs->pmc_clk); 665 if (ret == 0) 666 gs->clock_on = true; 667 } else { 668 clk_disable_unprepare(gs->pmc_clk); 669 gs->clock_on = false; 670 } 671 672 return ret; 673 } 674 675 static int gmin_csi_cfg(struct v4l2_subdev *sd, int flag) 676 { 677 struct i2c_client *client = v4l2_get_subdevdata(sd); 678 struct gmin_subdev *gs = find_gmin_subdev(sd); 679 680 if (!client || !gs) 681 return -ENODEV; 682 683 return camera_sensor_csi(sd, gs->csi_port, gs->csi_lanes, 684 gs->csi_fmt, gs->csi_bayer, flag); 685 } 686 687 static struct camera_vcm_control *gmin_get_vcm_ctrl(struct v4l2_subdev *subdev, 688 char *camera_module) 689 { 690 struct i2c_client *client = v4l2_get_subdevdata(subdev); 691 struct gmin_subdev *gs = find_gmin_subdev(subdev); 692 struct camera_vcm_control *vcm; 693 694 if (!client || !gs) 695 return NULL; 696 697 if (!camera_module) 698 return NULL; 699 700 mutex_lock(&vcm_lock); 701 list_for_each_entry(vcm, &vcm_devices, list) { 702 if (!strcmp(camera_module, vcm->camera_module)) { 703 mutex_unlock(&vcm_lock); 704 return vcm; 705 } 706 } 707 708 mutex_unlock(&vcm_lock); 709 return NULL; 710 } 711 712 static struct camera_sensor_platform_data gmin_plat = { 713 .gpio0_ctrl = gmin_gpio0_ctrl, 714 .gpio1_ctrl = gmin_gpio1_ctrl, 715 .v1p8_ctrl = gmin_v1p8_ctrl, 716 .v2p8_ctrl = gmin_v2p8_ctrl, 717 .v1p2_ctrl = gmin_v1p2_ctrl, 718 .flisclk_ctrl = gmin_flisclk_ctrl, 719 .csi_cfg = gmin_csi_cfg, 720 .get_vcm_ctrl = gmin_get_vcm_ctrl, 721 }; 722 723 struct camera_sensor_platform_data *gmin_camera_platform_data( 724 struct v4l2_subdev *subdev, 725 enum atomisp_input_format csi_format, 726 enum atomisp_bayer_order csi_bayer) 727 { 728 struct gmin_subdev *gs = find_gmin_subdev(subdev); 729 730 gs->csi_fmt = csi_format; 731 gs->csi_bayer = csi_bayer; 732 733 return &gmin_plat; 734 } 735 EXPORT_SYMBOL_GPL(gmin_camera_platform_data); 736 737 int atomisp_gmin_register_vcm_control(struct camera_vcm_control *vcmCtrl) 738 { 739 if (!vcmCtrl) 740 return -EINVAL; 741 742 mutex_lock(&vcm_lock); 743 list_add_tail(&vcmCtrl->list, &vcm_devices); 744 mutex_unlock(&vcm_lock); 745 746 return 0; 747 } 748 EXPORT_SYMBOL_GPL(atomisp_gmin_register_vcm_control); 749 750 static int gmin_get_hardcoded_var(struct gmin_cfg_var *varlist, 751 const char *var8, char *out, size_t *out_len) 752 { 753 struct gmin_cfg_var *gv; 754 755 for (gv = varlist; gv->name; gv++) { 756 size_t vl; 757 758 if (strcmp(var8, gv->name)) 759 continue; 760 761 vl = strlen(gv->val); 762 if (vl > *out_len - 1) 763 return -ENOSPC; 764 765 strcpy(out, gv->val); 766 *out_len = vl; 767 return 0; 768 } 769 770 return -EINVAL; 771 } 772 773 /* Retrieves a device-specific configuration variable. The dev 774 * argument should be a device with an ACPI companion, as all 775 * configuration is based on firmware ID. 776 */ 777 static int gmin_get_config_var(struct device *maindev, 778 bool is_gmin, 779 const char *var, 780 char *out, size_t *out_len) 781 { 782 char var8[CFG_VAR_NAME_MAX]; 783 efi_char16_t var16[CFG_VAR_NAME_MAX]; 784 struct efivar_entry *ev; 785 const struct dmi_system_id *id; 786 int i, ret; 787 struct device *dev = maindev; 788 789 if (!is_gmin && ACPI_COMPANION(dev)) 790 dev = &ACPI_COMPANION(dev)->dev; 791 792 if (!is_gmin) 793 ret = snprintf(var8, sizeof(var8), "%s_%s", dev_name(dev), var); 794 else 795 ret = snprintf(var8, sizeof(var8), "gmin_%s", var); 796 797 if (ret < 0 || ret >= sizeof(var8) - 1) 798 return -EINVAL; 799 800 /* First check a hard-coded list of board-specific variables. 801 * Some device firmwares lack the ability to set EFI variables at 802 * runtime. 803 */ 804 id = dmi_first_match(gmin_vars); 805 if (id) { 806 dev_info(maindev, "Found DMI entry for '%s'\n", var8); 807 return gmin_get_hardcoded_var(id->driver_data, var8, out, out_len); 808 } 809 810 /* Our variable names are ASCII by construction, but EFI names 811 * are wide chars. Convert and zero-pad. 812 */ 813 memset(var16, 0, sizeof(var16)); 814 for (i = 0; i < sizeof(var8) && var8[i]; i++) 815 var16[i] = var8[i]; 816 817 /* Not sure this API usage is kosher; efivar_entry_get()'s 818 * implementation simply uses VariableName and VendorGuid from 819 * the struct and ignores the rest, but it seems like there 820 * ought to be an "official" efivar_entry registered 821 * somewhere? 822 */ 823 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 824 if (!ev) 825 return -ENOMEM; 826 memcpy(&ev->var.VariableName, var16, sizeof(var16)); 827 ev->var.VendorGuid = GMIN_CFG_VAR_EFI_GUID; 828 ev->var.DataSize = *out_len; 829 830 ret = efivar_entry_get(ev, &ev->var.Attributes, 831 &ev->var.DataSize, ev->var.Data); 832 if (ret == 0) { 833 memcpy(out, ev->var.Data, ev->var.DataSize); 834 *out_len = ev->var.DataSize; 835 dev_info(maindev, "found EFI entry for '%s'\n", var8); 836 } else if (is_gmin) { 837 dev_warn(maindev, "Failed to find gmin variable %s\n", var8); 838 } else { 839 dev_warn(maindev, "Failed to find variable %s\n", var8); 840 } 841 842 kfree(ev); 843 844 return ret; 845 } 846 847 int gmin_get_var_int(struct device *dev, bool is_gmin, const char *var, int def) 848 { 849 char val[CFG_VAR_NAME_MAX]; 850 size_t len = sizeof(val); 851 long result; 852 int ret; 853 854 ret = gmin_get_config_var(dev, is_gmin, var, val, &len); 855 if (!ret) { 856 val[len] = 0; 857 ret = kstrtol(val, 0, &result); 858 } 859 860 return ret ? def : result; 861 } 862 EXPORT_SYMBOL_GPL(gmin_get_var_int); 863 864 int camera_sensor_csi(struct v4l2_subdev *sd, u32 port, 865 u32 lanes, u32 format, u32 bayer_order, int flag) 866 { 867 struct i2c_client *client = v4l2_get_subdevdata(sd); 868 struct camera_mipi_info *csi = NULL; 869 870 if (flag) { 871 csi = kzalloc(sizeof(*csi), GFP_KERNEL); 872 if (!csi) 873 return -ENOMEM; 874 csi->port = port; 875 csi->num_lanes = lanes; 876 csi->input_format = format; 877 csi->raw_bayer_order = bayer_order; 878 v4l2_set_subdev_hostdata(sd, (void *)csi); 879 csi->metadata_format = ATOMISP_INPUT_FORMAT_EMBEDDED; 880 csi->metadata_effective_width = NULL; 881 dev_info(&client->dev, 882 "camera pdata: port: %d lanes: %d order: %8.8x\n", 883 port, lanes, bayer_order); 884 } else { 885 csi = v4l2_get_subdev_hostdata(sd); 886 kfree(csi); 887 } 888 889 return 0; 890 } 891 EXPORT_SYMBOL_GPL(camera_sensor_csi); 892 893 /* PCI quirk: The BYT ISP advertises PCI runtime PM but it doesn't 894 * work. Disable so the kernel framework doesn't hang the device 895 * trying. The driver itself does direct calls to the PUNIT to manage 896 * ISP power. 897 */ 898 static void isp_pm_cap_fixup(struct pci_dev *dev) 899 { 900 dev_info(&dev->dev, "Disabling PCI power management on camera ISP\n"); 901 dev->pm_cap = 0; 902 } 903 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0f38, isp_pm_cap_fixup); 904