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