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