drivers/staging/media/atomisp/pci/atomisp_gmin_platform.c

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