1
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
21enum 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
30#define MAX_CLK_COUNT 5
31
32
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
49#define LDO9_REG 0x49
50#define LDO10_REG 0x4a
51#define LDO11_REG 0x4b
52
53#define LDO_2P8V_ON 0x2f
54#define LDO_2P8V_OFF 0x2e
55
56#define LDO_1P8V_ON 0x59
57#define LDO_1P8V_OFF 0x58
58
59
60#define CRYSTAL_1P8V_REG 0x57
61#define CRYSTAL_2P8V_REG 0x5d
62#define CRYSTAL_ON 0x63
63#define CRYSTAL_OFF 0x62
64
65struct gmin_subdev {
66 struct v4l2_subdev *subdev;
67 enum clock_rate clock_src;
68 struct clk *pmc_clk;
69 struct gpio_desc *gpio0;
70 struct gpio_desc *gpio1;
71 struct regulator *v1p8_reg;
72 struct regulator *v2p8_reg;
73 struct regulator *v1p2_reg;
74 struct regulator *v2p8_vcm_reg;
75 enum atomisp_camera_port csi_port;
76 unsigned int csi_lanes;
77 enum atomisp_input_format csi_fmt;
78 enum atomisp_bayer_order csi_bayer;
79
80 bool clock_on;
81 bool v1p8_on;
82 bool v2p8_on;
83 bool v1p2_on;
84 bool v2p8_vcm_on;
85
86 int v1p8_gpio;
87 int v2p8_gpio;
88
89 u8 pwm_i2c_addr;
90
91
92 int eldo1_sel_reg, eldo1_1p6v, eldo1_ctrl_shift;
93 int eldo2_sel_reg, eldo2_1p8v, eldo2_ctrl_shift;
94};
95
96static struct gmin_subdev gmin_subdevs[MAX_SUBDEVS];
97
98
99#define PMIC_ACPI_AXP "INT33F4"
100#define PMIC_ACPI_TI "INT33F5"
101#define PMIC_ACPI_CRYSTALCOVE "INT33FD"
102
103#define PMIC_PLATFORM_TI "intel_soc_pmic_chtdc_ti"
104
105static enum {
106 PMIC_UNSET = 0,
107 PMIC_REGULATOR,
108 PMIC_AXP,
109 PMIC_TI,
110 PMIC_CRYSTALCOVE
111} pmic_id;
112
113static const char *pmic_name[] = {
114 [PMIC_UNSET] = "ACPI device PM",
115 [PMIC_REGULATOR] = "regulator driver",
116 [PMIC_AXP] = "XPower AXP288 PMIC",
117 [PMIC_TI] = "Dollar Cove TI PMIC",
118 [PMIC_CRYSTALCOVE] = "Crystal Cove PMIC",
119};
120
121static DEFINE_MUTEX(gmin_regulator_mutex);
122static int gmin_v1p8_enable_count;
123static int gmin_v2p8_enable_count;
124
125
126static struct intel_v4l2_subdev_table pdata_subdevs[MAX_SUBDEVS + 1];
127
128static const struct atomisp_platform_data pdata = {
129 .subdevs = pdata_subdevs,
130};
131
132static LIST_HEAD(vcm_devices);
133static DEFINE_MUTEX(vcm_lock);
134
135static struct gmin_subdev *find_gmin_subdev(struct v4l2_subdev *subdev);
136
137
138
139
140
141
142
143const struct atomisp_camera_caps *atomisp_get_default_camera_caps(void)
144{
145 static const struct atomisp_camera_caps caps = {
146 .sensor_num = 1,
147 .sensor = {
148 { .stream_num = 1, },
149 },
150 };
151 return ∩︀
152}
153EXPORT_SYMBOL_GPL(atomisp_get_default_camera_caps);
154
155const struct atomisp_platform_data *atomisp_get_platform_data(void)
156{
157 return &pdata;
158}
159EXPORT_SYMBOL_GPL(atomisp_get_platform_data);
160
161int atomisp_register_i2c_module(struct v4l2_subdev *subdev,
162 struct camera_sensor_platform_data *plat_data,
163 enum intel_v4l2_subdev_type type)
164{
165 int i;
166 struct i2c_board_info *bi;
167 struct gmin_subdev *gs;
168 struct i2c_client *client = v4l2_get_subdevdata(subdev);
169 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
170
171 dev_info(&client->dev, "register atomisp i2c module type %d\n", type);
172
173
174
175
176
177
178
179 adev->power.flags.power_resources = 0;
180
181 for (i = 0; i < MAX_SUBDEVS; i++)
182 if (!pdata.subdevs[i].type)
183 break;
184
185 if (pdata.subdevs[i].type)
186 return -ENOMEM;
187
188
189
190
191
192
193 gs = find_gmin_subdev(subdev);
194 if (!gs)
195 return -ENODEV;
196
197 pdata.subdevs[i].type = type;
198 pdata.subdevs[i].port = gs->csi_port;
199 pdata.subdevs[i].subdev = subdev;
200 pdata.subdevs[i].v4l2_subdev.i2c_adapter_id = client->adapter->nr;
201
202
203 bi = &pdata.subdevs[i].v4l2_subdev.board_info;
204 memcpy(bi->type, client->name, I2C_NAME_SIZE);
205 bi->flags = client->flags;
206 bi->addr = client->addr;
207 bi->irq = client->irq;
208 bi->platform_data = plat_data;
209
210 return 0;
211}
212EXPORT_SYMBOL_GPL(atomisp_register_i2c_module);
213
214struct v4l2_subdev *atomisp_gmin_find_subdev(struct i2c_adapter *adapter,
215 struct i2c_board_info *board_info)
216{
217 int i;
218
219 for (i = 0; i < MAX_SUBDEVS && pdata.subdevs[i].type; i++) {
220 struct intel_v4l2_subdev_table *sd = &pdata.subdevs[i];
221
222 if (sd->v4l2_subdev.i2c_adapter_id == adapter->nr &&
223 sd->v4l2_subdev.board_info.addr == board_info->addr)
224 return sd->subdev;
225 }
226 return NULL;
227}
228EXPORT_SYMBOL_GPL(atomisp_gmin_find_subdev);
229
230int atomisp_gmin_remove_subdev(struct v4l2_subdev *sd)
231{
232 int i, j;
233
234 if (!sd)
235 return 0;
236
237 for (i = 0; i < MAX_SUBDEVS; i++) {
238 if (pdata.subdevs[i].subdev == sd) {
239 for (j = i + 1; j <= MAX_SUBDEVS; j++)
240 pdata.subdevs[j - 1] = pdata.subdevs[j];
241 }
242 if (gmin_subdevs[i].subdev == sd) {
243 if (gmin_subdevs[i].gpio0)
244 gpiod_put(gmin_subdevs[i].gpio0);
245 gmin_subdevs[i].gpio0 = NULL;
246 if (gmin_subdevs[i].gpio1)
247 gpiod_put(gmin_subdevs[i].gpio1);
248 gmin_subdevs[i].gpio1 = NULL;
249 if (pmic_id == PMIC_REGULATOR) {
250 regulator_put(gmin_subdevs[i].v1p8_reg);
251 regulator_put(gmin_subdevs[i].v2p8_reg);
252 regulator_put(gmin_subdevs[i].v1p2_reg);
253 regulator_put(gmin_subdevs[i].v2p8_vcm_reg);
254 }
255 gmin_subdevs[i].subdev = NULL;
256 }
257 }
258 return 0;
259}
260EXPORT_SYMBOL_GPL(atomisp_gmin_remove_subdev);
261
262struct gmin_cfg_var {
263 const char *name, *val;
264};
265
266static struct gmin_cfg_var ffrd8_vars[] = {
267 { "INTCF1B:00_ImxId", "0x134" },
268 { "INTCF1B:00_CsiPort", "1" },
269 { "INTCF1B:00_CsiLanes", "4" },
270 { "INTCF1B:00_CamClk", "0" },
271 {},
272};
273
274
275
276
277static struct gmin_cfg_var t100_vars[] = {
278 { "INT33F0:00_CsiPort", "0" },
279 { "INT33F0:00_CsiLanes", "1" },
280 { "INT33F0:00_CamClk", "1" },
281 {},
282};
283
284static struct gmin_cfg_var mrd7_vars[] = {
285 {"INT33F8:00_CamType", "1"},
286 {"INT33F8:00_CsiPort", "1"},
287 {"INT33F8:00_CsiLanes", "2"},
288 {"INT33F8:00_CsiFmt", "13"},
289 {"INT33F8:00_CsiBayer", "0"},
290 {"INT33F8:00_CamClk", "0"},
291
292 {"INT33F9:00_CamType", "1"},
293 {"INT33F9:00_CsiPort", "0"},
294 {"INT33F9:00_CsiLanes", "1"},
295 {"INT33F9:00_CsiFmt", "13"},
296 {"INT33F9:00_CsiBayer", "0"},
297 {"INT33F9:00_CamClk", "1"},
298 {},
299};
300
301static struct gmin_cfg_var ecs7_vars[] = {
302 {"INT33BE:00_CsiPort", "1"},
303 {"INT33BE:00_CsiLanes", "2"},
304 {"INT33BE:00_CsiFmt", "13"},
305 {"INT33BE:00_CsiBayer", "2"},
306 {"INT33BE:00_CamClk", "0"},
307
308 {"INT33F0:00_CsiPort", "0"},
309 {"INT33F0:00_CsiLanes", "1"},
310 {"INT33F0:00_CsiFmt", "13"},
311 {"INT33F0:00_CsiBayer", "0"},
312 {"INT33F0:00_CamClk", "1"},
313 {"gmin_V2P8GPIO", "402"},
314 {},
315};
316
317static struct gmin_cfg_var i8880_vars[] = {
318 {"XXOV2680:00_CsiPort", "1"},
319 {"XXOV2680:00_CsiLanes", "1"},
320 {"XXOV2680:00_CamClk", "0"},
321
322 {"XXGC0310:00_CsiPort", "0"},
323 {"XXGC0310:00_CsiLanes", "1"},
324 {"XXGC0310:00_CamClk", "1"},
325 {},
326};
327
328
329
330
331static struct gmin_cfg_var surface3_vars[] = {
332 {"APTA0330:00_CsiPort", "0"},
333 {"APTA0330:00_CsiLanes", "2"},
334
335 {"OVTI8835:00_CsiPort", "1"},
336 {"OVTI8835:00_CsiLanes", "4"},
337 {},
338};
339
340static const struct dmi_system_id gmin_vars[] = {
341 {
342 .ident = "BYT-T FFD8",
343 .matches = {
344 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"),
345 },
346 .driver_data = ffrd8_vars,
347 },
348 {
349 .ident = "T100TA",
350 .matches = {
351 DMI_MATCH(DMI_BOARD_NAME, "T100TA"),
352 },
353 .driver_data = t100_vars,
354 },
355 {
356 .ident = "MRD7",
357 .matches = {
358 DMI_MATCH(DMI_BOARD_NAME, "TABLET"),
359 DMI_MATCH(DMI_BOARD_VERSION, "MRD 7"),
360 },
361 .driver_data = mrd7_vars,
362 },
363 {
364 .ident = "ST70408",
365 .matches = {
366 DMI_MATCH(DMI_BOARD_NAME, "ST70408"),
367 },
368 .driver_data = ecs7_vars,
369 },
370 {
371 .ident = "VTA0803",
372 .matches = {
373 DMI_MATCH(DMI_BOARD_NAME, "VTA0803"),
374 },
375 .driver_data = i8880_vars,
376 },
377 {
378 .ident = "Surface 3",
379 .matches = {
380 DMI_MATCH(DMI_BOARD_NAME, "Surface 3"),
381 },
382 .driver_data = surface3_vars,
383 },
384 {}
385};
386
387#define GMIN_CFG_VAR_EFI_GUID EFI_GUID(0xecb54cd9, 0xe5ae, 0x4fdc, \
388 0xa9, 0x71, 0xe8, 0x77, \
389 0x75, 0x60, 0x68, 0xf7)
390
391static const guid_t atomisp_dsm_guid = GUID_INIT(0xdc2f6c4f, 0x045b, 0x4f1d,
392 0x97, 0xb9, 0x88, 0x2a,
393 0x68, 0x60, 0xa4, 0xbe);
394
395#define CFG_VAR_NAME_MAX 64
396
397#define GMIN_PMC_CLK_NAME 14
398static char gmin_pmc_clk_name[GMIN_PMC_CLK_NAME];
399
400static struct i2c_client *gmin_i2c_dev_exists(struct device *dev, char *name,
401 struct i2c_client **client)
402{
403 struct acpi_device *adev;
404 struct device *d;
405
406 adev = acpi_dev_get_first_match_dev(name, NULL, -1);
407 if (!adev)
408 return NULL;
409
410 d = bus_find_device_by_acpi_dev(&i2c_bus_type, adev);
411 acpi_dev_put(adev);
412 if (!d)
413 return NULL;
414
415 *client = i2c_verify_client(d);
416 put_device(d);
417
418 dev_dbg(dev, "found '%s' at address 0x%02x, adapter %d\n",
419 (*client)->name, (*client)->addr, (*client)->adapter->nr);
420 return *client;
421}
422
423static int gmin_i2c_write(struct device *dev, u16 i2c_addr, u8 reg,
424 u32 value, u32 mask)
425{
426 int ret;
427
428
429
430
431
432
433
434
435 dev_dbg(dev,
436 "I2C write, addr: 0x%02x, reg: 0x%02x, value: 0x%02x, mask: 0x%02x\n",
437 i2c_addr, reg, value, mask);
438
439 ret = intel_soc_pmic_exec_mipi_pmic_seq_element(i2c_addr, reg, value, mask);
440 if (ret == -EOPNOTSUPP)
441 dev_err(dev,
442 "ACPI didn't mapped the OpRegion needed to access I2C address 0x%02x.\n"
443 "Need to compile the kernel using CONFIG_*_PMIC_OPREGION settings\n",
444 i2c_addr);
445
446 return ret;
447}
448
449static int atomisp_get_acpi_power(struct device *dev)
450{
451 char name[5];
452 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
453 struct acpi_buffer b_name = { sizeof(name), name };
454 union acpi_object *package, *element;
455 acpi_handle handle = ACPI_HANDLE(dev);
456 acpi_handle rhandle;
457 acpi_status status;
458 int clock_num = -1;
459 int i;
460
461 status = acpi_evaluate_object(handle, "_PR0", NULL, &buffer);
462 if (!ACPI_SUCCESS(status))
463 return -1;
464
465 package = buffer.pointer;
466
467 if (!buffer.length || !package
468 || package->type != ACPI_TYPE_PACKAGE
469 || !package->package.count)
470 goto fail;
471
472 for (i = 0; i < package->package.count; i++) {
473 element = &package->package.elements[i];
474
475 if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
476 continue;
477
478 rhandle = element->reference.handle;
479 if (!rhandle)
480 goto fail;
481
482 acpi_get_name(rhandle, ACPI_SINGLE_NAME, &b_name);
483
484 dev_dbg(dev, "Found PM resource '%s'\n", name);
485 if (strlen(name) == 4 && !strncmp(name, "CLK", 3)) {
486 if (name[3] >= '0' && name[3] <= '4')
487 clock_num = name[3] - '0';
488#if 0
489
490
491
492
493 if (clock_num >= 0)
494 break;
495#endif
496 }
497 }
498
499fail:
500 ACPI_FREE(buffer.pointer);
501
502 return clock_num;
503}
504
505static u8 gmin_get_pmic_id_and_addr(struct device *dev)
506{
507 struct i2c_client *power = NULL;
508 static u8 pmic_i2c_addr;
509
510 if (pmic_id)
511 return pmic_i2c_addr;
512
513 if (gmin_i2c_dev_exists(dev, PMIC_ACPI_TI, &power))
514 pmic_id = PMIC_TI;
515 else if (gmin_i2c_dev_exists(dev, PMIC_ACPI_AXP, &power))
516 pmic_id = PMIC_AXP;
517 else if (gmin_i2c_dev_exists(dev, PMIC_ACPI_CRYSTALCOVE, &power))
518 pmic_id = PMIC_CRYSTALCOVE;
519 else
520 pmic_id = PMIC_REGULATOR;
521
522 pmic_i2c_addr = power ? power->addr : 0;
523 return pmic_i2c_addr;
524}
525
526static int gmin_detect_pmic(struct v4l2_subdev *subdev)
527{
528 struct i2c_client *client = v4l2_get_subdevdata(subdev);
529 struct device *dev = &client->dev;
530 u8 pmic_i2c_addr;
531
532 pmic_i2c_addr = gmin_get_pmic_id_and_addr(dev);
533 dev_info(dev, "gmin: power management provided via %s (i2c addr 0x%02x)\n",
534 pmic_name[pmic_id], pmic_i2c_addr);
535 return pmic_i2c_addr;
536}
537
538static int gmin_subdev_add(struct gmin_subdev *gs)
539{
540 struct i2c_client *client = v4l2_get_subdevdata(gs->subdev);
541 struct device *dev = &client->dev;
542 struct acpi_device *adev = ACPI_COMPANION(dev);
543 int ret, default_val, clock_num = -1;
544
545 dev_info(dev, "%s: ACPI path is %pfw\n", __func__, dev_fwnode(dev));
546
547
548 gs->clock_src = gmin_get_var_int(dev, false, "ClkSrc",
549 VLV2_CLK_PLL_19P2MHZ);
550
551
552
553
554
555 if (acpi_device_power_manageable(adev))
556 clock_num = atomisp_get_acpi_power(dev);
557
558
559 if (IS_ISP2401)
560 default_val = clock_num == 4 ? 1 : 0;
561 else
562 default_val = clock_num == 0 ? 1 : 0;
563
564 gs->csi_port = gmin_get_var_int(dev, false, "CsiPort", default_val);
565 gs->csi_lanes = gmin_get_var_int(dev, false, "CsiLanes", 1);
566
567 gs->gpio0 = gpiod_get_index(dev, NULL, 0, GPIOD_OUT_LOW);
568 if (IS_ERR(gs->gpio0))
569 gs->gpio0 = NULL;
570 else
571 dev_info(dev, "will handle gpio0 via ACPI\n");
572
573 gs->gpio1 = gpiod_get_index(dev, NULL, 1, GPIOD_OUT_LOW);
574 if (IS_ERR(gs->gpio1))
575 gs->gpio1 = NULL;
576 else
577 dev_info(dev, "will handle gpio1 via ACPI\n");
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593 gs->v1p8_gpio = gmin_get_var_int(dev, true, "V1P8GPIO", -1);
594 gs->v2p8_gpio = gmin_get_var_int(dev, true, "V2P8GPIO", -1);
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618 if (acpi_device_can_wakeup(adev) &&
619 acpi_device_can_poweroff(adev)) {
620 dev_info(dev,
621 "gmin: power management provided via device PM\n");
622 return 0;
623 }
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646 if (clock_num < 0)
647 clock_num = gmin_get_var_int(dev, false, "CamClk", 0);
648
649 if (clock_num < 0 || clock_num > MAX_CLK_COUNT) {
650 dev_err(dev, "Invalid clock number\n");
651 return -EINVAL;
652 }
653
654 snprintf(gmin_pmc_clk_name, sizeof(gmin_pmc_clk_name),
655 "%s_%d", "pmc_plt_clk", clock_num);
656
657 gs->pmc_clk = devm_clk_get(dev, gmin_pmc_clk_name);
658 if (IS_ERR(gs->pmc_clk)) {
659 ret = PTR_ERR(gs->pmc_clk);
660 dev_err(dev, "Failed to get clk from %s: %d\n", gmin_pmc_clk_name, ret);
661 return ret;
662 }
663 dev_info(dev, "Will use CLK%d (%s)\n", clock_num, gmin_pmc_clk_name);
664
665
666
667
668
669
670
671
672
673
674
675 ret = clk_prepare_enable(gs->pmc_clk);
676 if (!ret)
677 clk_disable_unprepare(gs->pmc_clk);
678
679 switch (pmic_id) {
680 case PMIC_REGULATOR:
681 gs->v1p8_reg = regulator_get(dev, "V1P8SX");
682 gs->v2p8_reg = regulator_get(dev, "V2P8SX");
683
684 gs->v1p2_reg = regulator_get(dev, "V1P2A");
685 gs->v2p8_vcm_reg = regulator_get(dev, "VPROG4B");
686
687
688
689
690
691
692
693
694 break;
695
696 case PMIC_AXP:
697 gs->eldo1_1p6v = gmin_get_var_int(dev, false,
698 "eldo1_1p8v",
699 ELDO1_1P6V);
700 gs->eldo1_sel_reg = gmin_get_var_int(dev, false,
701 "eldo1_sel_reg",
702 ELDO1_SEL_REG);
703 gs->eldo1_ctrl_shift = gmin_get_var_int(dev, false,
704 "eldo1_ctrl_shift",
705 ELDO1_CTRL_SHIFT);
706 gs->eldo2_1p8v = gmin_get_var_int(dev, false,
707 "eldo2_1p8v",
708 ELDO2_1P8V);
709 gs->eldo2_sel_reg = gmin_get_var_int(dev, false,
710 "eldo2_sel_reg",
711 ELDO2_SEL_REG);
712 gs->eldo2_ctrl_shift = gmin_get_var_int(dev, false,
713 "eldo2_ctrl_shift",
714 ELDO2_CTRL_SHIFT);
715 break;
716
717 default:
718 break;
719 }
720
721 return 0;
722}
723
724static struct gmin_subdev *find_gmin_subdev(struct v4l2_subdev *subdev)
725{
726 int i;
727
728 for (i = 0; i < MAX_SUBDEVS; i++)
729 if (gmin_subdevs[i].subdev == subdev)
730 return &gmin_subdevs[i];
731 return NULL;
732}
733
734static struct gmin_subdev *find_free_gmin_subdev_slot(void)
735{
736 unsigned int i;
737
738 for (i = 0; i < MAX_SUBDEVS; i++)
739 if (gmin_subdevs[i].subdev == NULL)
740 return &gmin_subdevs[i];
741 return NULL;
742}
743
744static int axp_regulator_set(struct device *dev, struct gmin_subdev *gs,
745 int sel_reg, u8 setting,
746 int ctrl_reg, int shift, bool on)
747{
748 int ret;
749 int val;
750
751 ret = gmin_i2c_write(dev, gs->pwm_i2c_addr, sel_reg, setting, 0xff);
752 if (ret)
753 return ret;
754
755 val = on ? 1 << shift : 0;
756
757 ret = gmin_i2c_write(dev, gs->pwm_i2c_addr, ctrl_reg, val, 1 << shift);
758 if (ret)
759 return ret;
760
761 return 0;
762}
763
764
765
766
767
768
769static const struct dmi_system_id axp_leave_eldo2_on_ids[] = {
770 {
771 .matches = {
772 DMI_MATCH(DMI_SYS_VENDOR, "TrekStor"),
773 DMI_MATCH(DMI_PRODUCT_NAME, "SurfTab duo W1 10.1 (VT4)"),
774 },
775 },
776 { }
777};
778
779static int axp_v1p8_on(struct device *dev, struct gmin_subdev *gs)
780{
781 int ret;
782
783 ret = axp_regulator_set(dev, gs, gs->eldo2_sel_reg, gs->eldo2_1p8v,
784 ELDO_CTRL_REG, gs->eldo2_ctrl_shift, true);
785 if (ret)
786 return ret;
787
788
789
790
791
792 usleep_range(110, 150);
793
794 ret = axp_regulator_set(dev, gs, gs->eldo1_sel_reg, gs->eldo1_1p6v,
795 ELDO_CTRL_REG, gs->eldo1_ctrl_shift, true);
796 return ret;
797}
798
799static int axp_v1p8_off(struct device *dev, struct gmin_subdev *gs)
800{
801 int ret;
802
803 ret = axp_regulator_set(dev, gs, gs->eldo1_sel_reg, gs->eldo1_1p6v,
804 ELDO_CTRL_REG, gs->eldo1_ctrl_shift, false);
805 if (ret)
806 return ret;
807
808 if (dmi_check_system(axp_leave_eldo2_on_ids))
809 return 0;
810
811 ret = axp_regulator_set(dev, gs, gs->eldo2_sel_reg, gs->eldo2_1p8v,
812 ELDO_CTRL_REG, gs->eldo2_ctrl_shift, false);
813 return ret;
814}
815
816static int gmin_gpio0_ctrl(struct v4l2_subdev *subdev, int on)
817{
818 struct gmin_subdev *gs = find_gmin_subdev(subdev);
819
820 if (gs) {
821 gpiod_set_value(gs->gpio0, on);
822 return 0;
823 }
824 return -EINVAL;
825}
826
827static int gmin_gpio1_ctrl(struct v4l2_subdev *subdev, int on)
828{
829 struct gmin_subdev *gs = find_gmin_subdev(subdev);
830
831 if (gs) {
832 gpiod_set_value(gs->gpio1, on);
833 return 0;
834 }
835 return -EINVAL;
836}
837
838static int gmin_v1p2_ctrl(struct v4l2_subdev *subdev, int on)
839{
840 struct gmin_subdev *gs = find_gmin_subdev(subdev);
841
842 if (!gs || gs->v1p2_on == on)
843 return 0;
844 gs->v1p2_on = on;
845
846
847 if (gs->v1p2_reg) {
848 if (on)
849 return regulator_enable(gs->v1p2_reg);
850 else
851 return regulator_disable(gs->v1p2_reg);
852 }
853
854
855
856 return -EINVAL;
857}
858
859static int gmin_v1p8_ctrl(struct v4l2_subdev *subdev, int on)
860{
861 struct gmin_subdev *gs = find_gmin_subdev(subdev);
862 int ret;
863 int value;
864
865 if (!gs || gs->v1p8_on == on)
866 return 0;
867
868 if (gs->v1p8_gpio >= 0) {
869 pr_info("atomisp_gmin_platform: 1.8v power on GPIO %d\n",
870 gs->v1p8_gpio);
871 ret = gpio_request(gs->v1p8_gpio, "camera_v1p8_en");
872 if (!ret)
873 ret = gpio_direction_output(gs->v1p8_gpio, 0);
874 if (ret)
875 pr_err("V1P8 GPIO initialization failed\n");
876 }
877
878 gs->v1p8_on = on;
879
880 ret = 0;
881 mutex_lock(&gmin_regulator_mutex);
882 if (on) {
883 gmin_v1p8_enable_count++;
884 if (gmin_v1p8_enable_count > 1)
885 goto out;
886 } else {
887 gmin_v1p8_enable_count--;
888 if (gmin_v1p8_enable_count > 0)
889 goto out;
890 }
891
892 if (gs->v1p8_gpio >= 0)
893 gpio_set_value(gs->v1p8_gpio, on);
894
895 if (gs->v1p8_reg) {
896 regulator_set_voltage(gs->v1p8_reg, 1800000, 1800000);
897 if (on)
898 ret = regulator_enable(gs->v1p8_reg);
899 else
900 ret = regulator_disable(gs->v1p8_reg);
901
902 goto out;
903 }
904
905 switch (pmic_id) {
906 case PMIC_AXP:
907 if (on)
908 ret = axp_v1p8_on(subdev->dev, gs);
909 else
910 ret = axp_v1p8_off(subdev->dev, gs);
911 break;
912 case PMIC_TI:
913 value = on ? LDO_1P8V_ON : LDO_1P8V_OFF;
914
915 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr,
916 LDO10_REG, value, 0xff);
917 break;
918 case PMIC_CRYSTALCOVE:
919 value = on ? CRYSTAL_ON : CRYSTAL_OFF;
920
921 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr,
922 CRYSTAL_1P8V_REG, value, 0xff);
923 break;
924 default:
925 dev_err(subdev->dev, "Couldn't set power mode for v1p8\n");
926 ret = -EINVAL;
927 }
928
929out:
930 mutex_unlock(&gmin_regulator_mutex);
931 return ret;
932}
933
934static int gmin_v2p8_ctrl(struct v4l2_subdev *subdev, int on)
935{
936 struct gmin_subdev *gs = find_gmin_subdev(subdev);
937 int ret;
938 int value;
939
940 if (WARN_ON(!gs))
941 return -ENODEV;
942
943 if (gs->v2p8_gpio >= 0) {
944 pr_info("atomisp_gmin_platform: 2.8v power on GPIO %d\n",
945 gs->v2p8_gpio);
946 ret = gpio_request(gs->v2p8_gpio, "camera_v2p8");
947 if (!ret)
948 ret = gpio_direction_output(gs->v2p8_gpio, 0);
949 if (ret)
950 pr_err("V2P8 GPIO initialization failed\n");
951 }
952
953 if (gs->v2p8_on == on)
954 return 0;
955 gs->v2p8_on = on;
956
957 ret = 0;
958 mutex_lock(&gmin_regulator_mutex);
959 if (on) {
960 gmin_v2p8_enable_count++;
961 if (gmin_v2p8_enable_count > 1)
962 goto out;
963 } else {
964 gmin_v2p8_enable_count--;
965 if (gmin_v2p8_enable_count > 0)
966 goto out;
967 }
968
969 if (gs->v2p8_gpio >= 0)
970 gpio_set_value(gs->v2p8_gpio, on);
971
972 if (gs->v2p8_reg) {
973 regulator_set_voltage(gs->v2p8_reg, 2900000, 2900000);
974 if (on)
975 ret = regulator_enable(gs->v2p8_reg);
976 else
977 ret = regulator_disable(gs->v2p8_reg);
978
979 goto out;
980 }
981
982 switch (pmic_id) {
983 case PMIC_AXP:
984 ret = axp_regulator_set(subdev->dev, gs, ALDO1_SEL_REG,
985 ALDO1_2P8V, ALDO1_CTRL3_REG,
986 ALDO1_CTRL3_SHIFT, on);
987 break;
988 case PMIC_TI:
989 value = on ? LDO_2P8V_ON : LDO_2P8V_OFF;
990
991 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr,
992 LDO9_REG, value, 0xff);
993 break;
994 case PMIC_CRYSTALCOVE:
995 value = on ? CRYSTAL_ON : CRYSTAL_OFF;
996
997 ret = gmin_i2c_write(subdev->dev, gs->pwm_i2c_addr,
998 CRYSTAL_2P8V_REG, value, 0xff);
999 break;
1000 default:
1001 dev_err(subdev->dev, "Couldn't set power mode for v2p8\n");
1002 ret = -EINVAL;
1003 }
1004
1005out:
1006 mutex_unlock(&gmin_regulator_mutex);
1007 return ret;
1008}
1009
1010static int gmin_acpi_pm_ctrl(struct v4l2_subdev *subdev, int on)
1011{
1012 int ret = 0;
1013 struct gmin_subdev *gs = find_gmin_subdev(subdev);
1014 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1015 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
1016
1017
1018 on = !!on;
1019 if (gs->clock_on == on)
1020 return 0;
1021
1022 dev_dbg(subdev->dev, "Setting power state to %s\n",
1023 on ? "on" : "off");
1024
1025 if (on)
1026 ret = acpi_device_set_power(adev,
1027 ACPI_STATE_D0);
1028 else
1029 ret = acpi_device_set_power(adev,
1030 ACPI_STATE_D3_COLD);
1031
1032 if (!ret)
1033 gs->clock_on = on;
1034 else
1035 dev_err(subdev->dev, "Couldn't set power state to %s\n",
1036 on ? "on" : "off");
1037
1038 return ret;
1039}
1040
1041static int gmin_flisclk_ctrl(struct v4l2_subdev *subdev, int on)
1042{
1043 int ret = 0;
1044 struct gmin_subdev *gs = find_gmin_subdev(subdev);
1045 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1046
1047 if (gs->clock_on == !!on)
1048 return 0;
1049
1050 if (on) {
1051 ret = clk_set_rate(gs->pmc_clk,
1052 gs->clock_src ? CLK_RATE_19_2MHZ : CLK_RATE_25_0MHZ);
1053
1054 if (ret)
1055 dev_err(&client->dev, "unable to set PMC rate %d\n",
1056 gs->clock_src);
1057
1058 ret = clk_prepare_enable(gs->pmc_clk);
1059 if (ret == 0)
1060 gs->clock_on = true;
1061 } else {
1062 clk_disable_unprepare(gs->pmc_clk);
1063 gs->clock_on = false;
1064 }
1065
1066 return ret;
1067}
1068
1069static int gmin_csi_cfg(struct v4l2_subdev *sd, int flag)
1070{
1071 struct i2c_client *client = v4l2_get_subdevdata(sd);
1072 struct gmin_subdev *gs = find_gmin_subdev(sd);
1073
1074 if (!client || !gs)
1075 return -ENODEV;
1076
1077 return camera_sensor_csi(sd, gs->csi_port, gs->csi_lanes,
1078 gs->csi_fmt, gs->csi_bayer, flag);
1079}
1080
1081static struct camera_vcm_control *gmin_get_vcm_ctrl(struct v4l2_subdev *subdev,
1082 char *camera_module)
1083{
1084 struct i2c_client *client = v4l2_get_subdevdata(subdev);
1085 struct gmin_subdev *gs = find_gmin_subdev(subdev);
1086 struct camera_vcm_control *vcm;
1087
1088 if (!client || !gs)
1089 return NULL;
1090
1091 if (!camera_module)
1092 return NULL;
1093
1094 mutex_lock(&vcm_lock);
1095 list_for_each_entry(vcm, &vcm_devices, list) {
1096 if (!strcmp(camera_module, vcm->camera_module)) {
1097 mutex_unlock(&vcm_lock);
1098 return vcm;
1099 }
1100 }
1101
1102 mutex_unlock(&vcm_lock);
1103 return NULL;
1104}
1105
1106static struct camera_sensor_platform_data pmic_gmin_plat = {
1107 .gpio0_ctrl = gmin_gpio0_ctrl,
1108 .gpio1_ctrl = gmin_gpio1_ctrl,
1109 .v1p8_ctrl = gmin_v1p8_ctrl,
1110 .v2p8_ctrl = gmin_v2p8_ctrl,
1111 .v1p2_ctrl = gmin_v1p2_ctrl,
1112 .flisclk_ctrl = gmin_flisclk_ctrl,
1113 .csi_cfg = gmin_csi_cfg,
1114 .get_vcm_ctrl = gmin_get_vcm_ctrl,
1115};
1116
1117static struct camera_sensor_platform_data acpi_gmin_plat = {
1118 .gpio0_ctrl = gmin_gpio0_ctrl,
1119 .gpio1_ctrl = gmin_gpio1_ctrl,
1120 .v1p8_ctrl = gmin_acpi_pm_ctrl,
1121 .v2p8_ctrl = gmin_acpi_pm_ctrl,
1122 .v1p2_ctrl = gmin_acpi_pm_ctrl,
1123 .flisclk_ctrl = gmin_acpi_pm_ctrl,
1124 .csi_cfg = gmin_csi_cfg,
1125 .get_vcm_ctrl = gmin_get_vcm_ctrl,
1126};
1127
1128struct camera_sensor_platform_data *
1129gmin_camera_platform_data(struct v4l2_subdev *subdev,
1130 enum atomisp_input_format csi_format,
1131 enum atomisp_bayer_order csi_bayer)
1132{
1133 u8 pmic_i2c_addr = gmin_detect_pmic(subdev);
1134 struct gmin_subdev *gs;
1135
1136 gs = find_free_gmin_subdev_slot();
1137 gs->subdev = subdev;
1138 gs->csi_fmt = csi_format;
1139 gs->csi_bayer = csi_bayer;
1140 gs->pwm_i2c_addr = pmic_i2c_addr;
1141
1142 gmin_subdev_add(gs);
1143 if (gs->pmc_clk)
1144 return &pmic_gmin_plat;
1145 else
1146 return &acpi_gmin_plat;
1147}
1148EXPORT_SYMBOL_GPL(gmin_camera_platform_data);
1149
1150int atomisp_gmin_register_vcm_control(struct camera_vcm_control *vcmCtrl)
1151{
1152 if (!vcmCtrl)
1153 return -EINVAL;
1154
1155 mutex_lock(&vcm_lock);
1156 list_add_tail(&vcmCtrl->list, &vcm_devices);
1157 mutex_unlock(&vcm_lock);
1158
1159 return 0;
1160}
1161EXPORT_SYMBOL_GPL(atomisp_gmin_register_vcm_control);
1162
1163static int gmin_get_hardcoded_var(struct device *dev,
1164 struct gmin_cfg_var *varlist,
1165 const char *var8, char *out, size_t *out_len)
1166{
1167 struct gmin_cfg_var *gv;
1168
1169 for (gv = varlist; gv->name; gv++) {
1170 size_t vl;
1171
1172 if (strcmp(var8, gv->name))
1173 continue;
1174
1175 dev_info(dev, "Found DMI entry for '%s'\n", var8);
1176
1177 vl = strlen(gv->val);
1178 if (vl > *out_len - 1)
1179 return -ENOSPC;
1180
1181 strscpy(out, gv->val, *out_len);
1182 *out_len = vl;
1183 return 0;
1184 }
1185
1186 return -EINVAL;
1187}
1188
1189
1190static int gmin_get_config_dsm_var(struct device *dev,
1191 const char *var,
1192 char *out, size_t *out_len)
1193{
1194 acpi_handle handle = ACPI_HANDLE(dev);
1195 union acpi_object *obj, *cur = NULL;
1196 int i;
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207 if (!strcmp(var, "CamClk"))
1208 return -EINVAL;
1209
1210 obj = acpi_evaluate_dsm(handle, &atomisp_dsm_guid, 0, 0, NULL);
1211 if (!obj) {
1212 dev_info_once(dev, "Didn't find ACPI _DSM table.\n");
1213 return -EINVAL;
1214 }
1215
1216
1217 if (obj->type != ACPI_TYPE_PACKAGE)
1218 return -EINVAL;
1219
1220#if 0
1221 for (i = 0; i < obj->package.count; i++) {
1222 union acpi_object *cur = &obj->package.elements[i];
1223
1224 if (cur->type == ACPI_TYPE_INTEGER)
1225 dev_info(dev, "object #%d, type %d, value: %lld\n",
1226 i, cur->type, cur->integer.value);
1227 else if (cur->type == ACPI_TYPE_STRING)
1228 dev_info(dev, "object #%d, type %d, string: %s\n",
1229 i, cur->type, cur->string.pointer);
1230 else
1231 dev_info(dev, "object #%d, type %d\n",
1232 i, cur->type);
1233 }
1234#endif
1235
1236
1237 for (i = 0; i < obj->package.count - 1; i += 2) {
1238 if (obj->package.elements[i].type == ACPI_TYPE_STRING &&
1239 !strcmp(obj->package.elements[i].string.pointer, var)) {
1240
1241 cur = &obj->package.elements[i + 1];
1242 break;
1243 }
1244 }
1245
1246 if (!cur) {
1247 dev_info(dev, "didn't found _DSM entry for '%s'\n", var);
1248 ACPI_FREE(obj);
1249 return -EINVAL;
1250 }
1251
1252
1253
1254
1255
1256
1257
1258
1259 if (cur && cur->type != ACPI_TYPE_STRING) {
1260 dev_info(dev, "found non-string _DSM entry for '%s'\n", var);
1261 ACPI_FREE(obj);
1262 return -EINVAL;
1263 }
1264
1265 dev_info(dev, "found _DSM entry for '%s': %s\n", var,
1266 cur->string.pointer);
1267 strscpy(out, cur->string.pointer, *out_len);
1268 *out_len = strlen(cur->string.pointer);
1269
1270 ACPI_FREE(obj);
1271 return 0;
1272}
1273
1274
1275
1276
1277
1278static int gmin_get_config_var(struct device *maindev,
1279 bool is_gmin,
1280 const char *var,
1281 char *out, size_t *out_len)
1282{
1283 efi_char16_t var16[CFG_VAR_NAME_MAX];
1284 const struct dmi_system_id *id;
1285 struct device *dev = maindev;
1286 char var8[CFG_VAR_NAME_MAX];
1287 struct efivar_entry *ev;
1288 int i, ret;
1289
1290
1291 if (!is_gmin) {
1292 ret = gmin_get_config_dsm_var(maindev, var, out, out_len);
1293 if (!ret)
1294 return 0;
1295 }
1296
1297
1298
1299 if (!is_gmin && ACPI_COMPANION(dev))
1300 dev = &ACPI_COMPANION(dev)->dev;
1301
1302 if (!is_gmin)
1303 ret = snprintf(var8, sizeof(var8), "%s_%s", dev_name(dev), var);
1304 else
1305 ret = snprintf(var8, sizeof(var8), "gmin_%s", var);
1306
1307 if (ret < 0 || ret >= sizeof(var8) - 1)
1308 return -EINVAL;
1309
1310
1311
1312
1313
1314 id = dmi_first_match(gmin_vars);
1315 if (id) {
1316 ret = gmin_get_hardcoded_var(maindev, id->driver_data, var8,
1317 out, out_len);
1318 if (!ret)
1319 return 0;
1320 }
1321
1322
1323
1324
1325 memset(var16, 0, sizeof(var16));
1326 for (i = 0; i < sizeof(var8) && var8[i]; i++)
1327 var16[i] = var8[i];
1328
1329
1330
1331
1332
1333
1334
1335 ev = kzalloc(sizeof(*ev), GFP_KERNEL);
1336 if (!ev)
1337 return -ENOMEM;
1338 memcpy(&ev->var.VariableName, var16, sizeof(var16));
1339 ev->var.VendorGuid = GMIN_CFG_VAR_EFI_GUID;
1340 ev->var.DataSize = *out_len;
1341
1342 ret = efivar_entry_get(ev, &ev->var.Attributes,
1343 &ev->var.DataSize, ev->var.Data);
1344 if (ret == 0) {
1345 memcpy(out, ev->var.Data, ev->var.DataSize);
1346 *out_len = ev->var.DataSize;
1347 dev_info(maindev, "found EFI entry for '%s'\n", var8);
1348 } else if (is_gmin) {
1349 dev_info(maindev, "Failed to find EFI gmin variable %s\n", var8);
1350 } else {
1351 dev_info(maindev, "Failed to find EFI variable %s\n", var8);
1352 }
1353
1354 kfree(ev);
1355
1356 return ret;
1357}
1358
1359int gmin_get_var_int(struct device *dev, bool is_gmin, const char *var, int def)
1360{
1361 char val[CFG_VAR_NAME_MAX];
1362 size_t len = sizeof(val);
1363 long result;
1364 int ret;
1365
1366 ret = gmin_get_config_var(dev, is_gmin, var, val, &len);
1367 if (!ret) {
1368 val[len] = 0;
1369 ret = kstrtol(val, 0, &result);
1370 } else {
1371 dev_info(dev, "%s: using default (%d)\n", var, def);
1372 }
1373
1374 return ret ? def : result;
1375}
1376EXPORT_SYMBOL_GPL(gmin_get_var_int);
1377
1378int camera_sensor_csi(struct v4l2_subdev *sd, u32 port,
1379 u32 lanes, u32 format, u32 bayer_order, int flag)
1380{
1381 struct i2c_client *client = v4l2_get_subdevdata(sd);
1382 struct camera_mipi_info *csi = NULL;
1383
1384 if (flag) {
1385 csi = kzalloc(sizeof(*csi), GFP_KERNEL);
1386 if (!csi)
1387 return -ENOMEM;
1388 csi->port = port;
1389 csi->num_lanes = lanes;
1390 csi->input_format = format;
1391 csi->raw_bayer_order = bayer_order;
1392 v4l2_set_subdev_hostdata(sd, (void *)csi);
1393 csi->metadata_format = ATOMISP_INPUT_FORMAT_EMBEDDED;
1394 csi->metadata_effective_width = NULL;
1395 dev_info(&client->dev,
1396 "camera pdata: port: %d lanes: %d order: %8.8x\n",
1397 port, lanes, bayer_order);
1398 } else {
1399 csi = v4l2_get_subdev_hostdata(sd);
1400 kfree(csi);
1401 }
1402
1403 return 0;
1404}
1405EXPORT_SYMBOL_GPL(camera_sensor_csi);
1406
1407
1408
1409
1410
1411
1412static void isp_pm_cap_fixup(struct pci_dev *pdev)
1413{
1414 dev_info(&pdev->dev, "Disabling PCI power management on camera ISP\n");
1415 pdev->pm_cap = 0;
1416}
1417DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0f38, isp_pm_cap_fixup);
1418
1419MODULE_DESCRIPTION("Ancillary routines for binding ACPI devices");
1420MODULE_LICENSE("GPL");
1421