drivers/staging/media/atomisp/platform/intel-mid/atomisp_gmin_platform.c

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