Merge tag 'platform-drivers-x86-v4.20-1' of git://git.infradead.org/linux-platform...
[sfrench/cifs-2.6.git] / drivers / platform / chrome / chromeos_laptop.c
1 // SPDX-License-Identifier: GPL-2.0+
2 // Driver to instantiate Chromebook i2c/smbus devices.
3 //
4 // Copyright (C) 2012 Google, Inc.
5 // Author: Benson Leung <bleung@chromium.org>
6
7 #define pr_fmt(fmt)             KBUILD_MODNAME ": " fmt
8
9 #include <linux/acpi.h>
10 #include <linux/dmi.h>
11 #include <linux/i2c.h>
12 #include <linux/input.h>
13 #include <linux/interrupt.h>
14 #include <linux/ioport.h>
15 #include <linux/module.h>
16 #include <linux/pci.h>
17 #include <linux/platform_device.h>
18 #include <linux/property.h>
19
20 #define ATMEL_TP_I2C_ADDR       0x4b
21 #define ATMEL_TP_I2C_BL_ADDR    0x25
22 #define ATMEL_TS_I2C_ADDR       0x4a
23 #define ATMEL_TS_I2C_BL_ADDR    0x26
24 #define CYAPA_TP_I2C_ADDR       0x67
25 #define ELAN_TP_I2C_ADDR        0x15
26 #define ISL_ALS_I2C_ADDR        0x44
27 #define TAOS_ALS_I2C_ADDR       0x29
28
29 static const char *i2c_adapter_names[] = {
30         "SMBus I801 adapter",
31         "i915 gmbus vga",
32         "i915 gmbus panel",
33         "Synopsys DesignWare I2C adapter",
34 };
35
36 /* Keep this enum consistent with i2c_adapter_names */
37 enum i2c_adapter_type {
38         I2C_ADAPTER_SMBUS = 0,
39         I2C_ADAPTER_VGADDC,
40         I2C_ADAPTER_PANEL,
41         I2C_ADAPTER_DESIGNWARE,
42 };
43
44 struct i2c_peripheral {
45         struct i2c_board_info board_info;
46         unsigned short alt_addr;
47
48         const char *dmi_name;
49         unsigned long irqflags;
50         struct resource irq_resource;
51
52         enum i2c_adapter_type type;
53         u32 pci_devid;
54
55         struct i2c_client *client;
56 };
57
58 struct acpi_peripheral {
59         char hid[ACPI_ID_LEN];
60         const struct property_entry *properties;
61 };
62
63 struct chromeos_laptop {
64         /*
65          * Note that we can't mark this pointer as const because
66          * i2c_new_probed_device() changes passed in I2C board info, so.
67          */
68         struct i2c_peripheral *i2c_peripherals;
69         unsigned int num_i2c_peripherals;
70
71         const struct acpi_peripheral *acpi_peripherals;
72         unsigned int num_acpi_peripherals;
73 };
74
75 static const struct chromeos_laptop *cros_laptop;
76
77 static struct i2c_client *
78 chromes_laptop_instantiate_i2c_device(struct i2c_adapter *adapter,
79                                       struct i2c_board_info *info,
80                                       unsigned short alt_addr)
81 {
82         const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END };
83         struct i2c_client *client;
84
85         /*
86          * Add the i2c device. If we can't detect it at the primary
87          * address we scan secondary addresses. In any case the client
88          * structure gets assigned primary address.
89          */
90         client = i2c_new_probed_device(adapter, info, addr_list, NULL);
91         if (!client && alt_addr) {
92                 struct i2c_board_info dummy_info = {
93                         I2C_BOARD_INFO("dummy", info->addr),
94                 };
95                 const unsigned short alt_addr_list[] = {
96                         alt_addr, I2C_CLIENT_END
97                 };
98                 struct i2c_client *dummy;
99
100                 dummy = i2c_new_probed_device(adapter, &dummy_info,
101                                               alt_addr_list, NULL);
102                 if (dummy) {
103                         pr_debug("%d-%02x is probed at %02x\n",
104                                  adapter->nr, info->addr, dummy->addr);
105                         i2c_unregister_device(dummy);
106                         client = i2c_new_device(adapter, info);
107                 }
108         }
109
110         if (!client)
111                 pr_debug("failed to register device %d-%02x\n",
112                          adapter->nr, info->addr);
113         else
114                 pr_debug("added i2c device %d-%02x\n",
115                          adapter->nr, info->addr);
116
117         return client;
118 }
119
120 static bool chromeos_laptop_match_adapter_devid(struct device *dev, u32 devid)
121 {
122         struct pci_dev *pdev;
123
124         if (!dev_is_pci(dev))
125                 return false;
126
127         pdev = to_pci_dev(dev);
128         return devid == PCI_DEVID(pdev->bus->number, pdev->devfn);
129 }
130
131 static void chromeos_laptop_check_adapter(struct i2c_adapter *adapter)
132 {
133         struct i2c_peripheral *i2c_dev;
134         int i;
135
136         for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
137                 i2c_dev = &cros_laptop->i2c_peripherals[i];
138
139                 /* Skip devices already created */
140                 if (i2c_dev->client)
141                         continue;
142
143                 if (strncmp(adapter->name, i2c_adapter_names[i2c_dev->type],
144                             strlen(i2c_adapter_names[i2c_dev->type])))
145                         continue;
146
147                 if (i2c_dev->pci_devid &&
148                     !chromeos_laptop_match_adapter_devid(adapter->dev.parent,
149                                                          i2c_dev->pci_devid)) {
150                         continue;
151                 }
152
153                 i2c_dev->client =
154                         chromes_laptop_instantiate_i2c_device(adapter,
155                                                         &i2c_dev->board_info,
156                                                         i2c_dev->alt_addr);
157         }
158 }
159
160 static bool chromeos_laptop_adjust_client(struct i2c_client *client)
161 {
162         const struct acpi_peripheral *acpi_dev;
163         struct acpi_device_id acpi_ids[2] = { };
164         int i;
165         int error;
166
167         if (!has_acpi_companion(&client->dev))
168                 return false;
169
170         for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) {
171                 acpi_dev = &cros_laptop->acpi_peripherals[i];
172
173                 memcpy(acpi_ids[0].id, acpi_dev->hid, ACPI_ID_LEN);
174
175                 if (acpi_match_device(acpi_ids, &client->dev)) {
176                         error = device_add_properties(&client->dev,
177                                                       acpi_dev->properties);
178                         if (error) {
179                                 dev_err(&client->dev,
180                                         "failed to add properties: %d\n",
181                                         error);
182                                 break;
183                         }
184
185                         return true;
186                 }
187         }
188
189         return false;
190 }
191
192 static void chromeos_laptop_detach_i2c_client(struct i2c_client *client)
193 {
194         struct i2c_peripheral *i2c_dev;
195         int i;
196
197         for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
198                 i2c_dev = &cros_laptop->i2c_peripherals[i];
199
200                 if (i2c_dev->client == client)
201                         i2c_dev->client = NULL;
202         }
203 }
204
205 static int chromeos_laptop_i2c_notifier_call(struct notifier_block *nb,
206                                              unsigned long action, void *data)
207 {
208         struct device *dev = data;
209
210         switch (action) {
211         case BUS_NOTIFY_ADD_DEVICE:
212                 if (dev->type == &i2c_adapter_type)
213                         chromeos_laptop_check_adapter(to_i2c_adapter(dev));
214                 else if (dev->type == &i2c_client_type)
215                         chromeos_laptop_adjust_client(to_i2c_client(dev));
216                 break;
217
218         case BUS_NOTIFY_REMOVED_DEVICE:
219                 if (dev->type == &i2c_client_type)
220                         chromeos_laptop_detach_i2c_client(to_i2c_client(dev));
221                 break;
222         }
223
224         return 0;
225 }
226
227 static struct notifier_block chromeos_laptop_i2c_notifier = {
228         .notifier_call = chromeos_laptop_i2c_notifier_call,
229 };
230
231 #define DECLARE_CROS_LAPTOP(_name)                                      \
232 static const struct chromeos_laptop _name __initconst = {               \
233         .i2c_peripherals        = _name##_peripherals,                  \
234         .num_i2c_peripherals    = ARRAY_SIZE(_name##_peripherals),      \
235 }
236
237 #define DECLARE_ACPI_CROS_LAPTOP(_name)                                 \
238 static const struct chromeos_laptop _name __initconst = {               \
239         .acpi_peripherals       = _name##_peripherals,                  \
240         .num_acpi_peripherals   = ARRAY_SIZE(_name##_peripherals),      \
241 }
242
243 static struct i2c_peripheral samsung_series_5_550_peripherals[] __initdata = {
244         /* Touchpad. */
245         {
246                 .board_info     = {
247                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
248                         .flags          = I2C_CLIENT_WAKE,
249                 },
250                 .dmi_name       = "trackpad",
251                 .type           = I2C_ADAPTER_SMBUS,
252         },
253         /* Light Sensor. */
254         {
255                 .board_info     = {
256                         I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
257                 },
258                 .dmi_name       = "lightsensor",
259                 .type           = I2C_ADAPTER_SMBUS,
260         },
261 };
262 DECLARE_CROS_LAPTOP(samsung_series_5_550);
263
264 static struct i2c_peripheral samsung_series_5_peripherals[] __initdata = {
265         /* Light Sensor. */
266         {
267                 .board_info     = {
268                         I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
269                 },
270                 .type           = I2C_ADAPTER_SMBUS,
271         },
272 };
273 DECLARE_CROS_LAPTOP(samsung_series_5);
274
275 static const int chromebook_pixel_tp_keys[] __initconst = {
276         KEY_RESERVED,
277         KEY_RESERVED,
278         KEY_RESERVED,
279         KEY_RESERVED,
280         KEY_RESERVED,
281         BTN_LEFT
282 };
283
284 static const struct property_entry
285 chromebook_pixel_trackpad_props[] __initconst = {
286         PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
287         PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", chromebook_pixel_tp_keys),
288         { }
289 };
290
291 static const struct property_entry
292 chromebook_atmel_touchscreen_props[] __initconst = {
293         PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
294         { }
295 };
296
297 static struct i2c_peripheral chromebook_pixel_peripherals[] __initdata = {
298         /* Touch Screen. */
299         {
300                 .board_info     = {
301                         I2C_BOARD_INFO("atmel_mxt_ts",
302                                         ATMEL_TS_I2C_ADDR),
303                         .properties     =
304                                 chromebook_atmel_touchscreen_props,
305                         .flags          = I2C_CLIENT_WAKE,
306                 },
307                 .dmi_name       = "touchscreen",
308                 .irqflags       = IRQF_TRIGGER_FALLING,
309                 .type           = I2C_ADAPTER_PANEL,
310                 .alt_addr       = ATMEL_TS_I2C_BL_ADDR,
311         },
312         /* Touchpad. */
313         {
314                 .board_info     = {
315                         I2C_BOARD_INFO("atmel_mxt_tp",
316                                         ATMEL_TP_I2C_ADDR),
317                         .properties     =
318                                 chromebook_pixel_trackpad_props,
319                         .flags          = I2C_CLIENT_WAKE,
320                 },
321                 .dmi_name       = "trackpad",
322                 .irqflags       = IRQF_TRIGGER_FALLING,
323                 .type           = I2C_ADAPTER_VGADDC,
324                 .alt_addr       = ATMEL_TP_I2C_BL_ADDR,
325         },
326         /* Light Sensor. */
327         {
328                 .board_info     = {
329                         I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
330                 },
331                 .dmi_name       = "lightsensor",
332                 .type           = I2C_ADAPTER_PANEL,
333         },
334 };
335 DECLARE_CROS_LAPTOP(chromebook_pixel);
336
337 static struct i2c_peripheral hp_chromebook_14_peripherals[] __initdata = {
338         /* Touchpad. */
339         {
340                 .board_info     = {
341                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
342                         .flags          = I2C_CLIENT_WAKE,
343                 },
344                 .dmi_name       = "trackpad",
345                 .type           = I2C_ADAPTER_DESIGNWARE,
346         },
347 };
348 DECLARE_CROS_LAPTOP(hp_chromebook_14);
349
350 static struct i2c_peripheral dell_chromebook_11_peripherals[] __initdata = {
351         /* Touchpad. */
352         {
353                 .board_info     = {
354                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
355                         .flags          = I2C_CLIENT_WAKE,
356                 },
357                 .dmi_name       = "trackpad",
358                 .type           = I2C_ADAPTER_DESIGNWARE,
359         },
360         /* Elan Touchpad option. */
361         {
362                 .board_info     = {
363                         I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
364                         .flags          = I2C_CLIENT_WAKE,
365                 },
366                 .dmi_name       = "trackpad",
367                 .type           = I2C_ADAPTER_DESIGNWARE,
368         },
369 };
370 DECLARE_CROS_LAPTOP(dell_chromebook_11);
371
372 static struct i2c_peripheral toshiba_cb35_peripherals[] __initdata = {
373         /* Touchpad. */
374         {
375                 .board_info     = {
376                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
377                         .flags          = I2C_CLIENT_WAKE,
378                 },
379                 .dmi_name       = "trackpad",
380                 .type           = I2C_ADAPTER_DESIGNWARE,
381         },
382 };
383 DECLARE_CROS_LAPTOP(toshiba_cb35);
384
385 static struct i2c_peripheral acer_c7_chromebook_peripherals[] __initdata = {
386         /* Touchpad. */
387         {
388                 .board_info     = {
389                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
390                         .flags          = I2C_CLIENT_WAKE,
391                 },
392                 .dmi_name       = "trackpad",
393                 .type           = I2C_ADAPTER_SMBUS,
394         },
395 };
396 DECLARE_CROS_LAPTOP(acer_c7_chromebook);
397
398 static struct i2c_peripheral acer_ac700_peripherals[] __initdata = {
399         /* Light Sensor. */
400         {
401                 .board_info     = {
402                         I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
403                 },
404                 .type           = I2C_ADAPTER_SMBUS,
405         },
406 };
407 DECLARE_CROS_LAPTOP(acer_ac700);
408
409 static struct i2c_peripheral acer_c720_peripherals[] __initdata = {
410         /* Touchscreen. */
411         {
412                 .board_info     = {
413                         I2C_BOARD_INFO("atmel_mxt_ts",
414                                         ATMEL_TS_I2C_ADDR),
415                         .properties     =
416                                 chromebook_atmel_touchscreen_props,
417                         .flags          = I2C_CLIENT_WAKE,
418                 },
419                 .dmi_name       = "touchscreen",
420                 .irqflags       = IRQF_TRIGGER_FALLING,
421                 .type           = I2C_ADAPTER_DESIGNWARE,
422                 .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)),
423                 .alt_addr       = ATMEL_TS_I2C_BL_ADDR,
424         },
425         /* Touchpad. */
426         {
427                 .board_info     = {
428                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
429                         .flags          = I2C_CLIENT_WAKE,
430                 },
431                 .dmi_name       = "trackpad",
432                 .type           = I2C_ADAPTER_DESIGNWARE,
433                 .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)),
434         },
435         /* Elan Touchpad option. */
436         {
437                 .board_info     = {
438                         I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
439                         .flags          = I2C_CLIENT_WAKE,
440                 },
441                 .dmi_name       = "trackpad",
442                 .type           = I2C_ADAPTER_DESIGNWARE,
443                 .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)),
444         },
445         /* Light Sensor. */
446         {
447                 .board_info     = {
448                         I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
449                 },
450                 .dmi_name       = "lightsensor",
451                 .type           = I2C_ADAPTER_DESIGNWARE,
452                 .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)),
453         },
454 };
455 DECLARE_CROS_LAPTOP(acer_c720);
456
457 static struct i2c_peripheral
458 hp_pavilion_14_chromebook_peripherals[] __initdata = {
459         /* Touchpad. */
460         {
461                 .board_info     = {
462                         I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
463                         .flags          = I2C_CLIENT_WAKE,
464                 },
465                 .dmi_name       = "trackpad",
466                 .type           = I2C_ADAPTER_SMBUS,
467         },
468 };
469 DECLARE_CROS_LAPTOP(hp_pavilion_14_chromebook);
470
471 static struct i2c_peripheral cr48_peripherals[] __initdata = {
472         /* Light Sensor. */
473         {
474                 .board_info     = {
475                         I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR),
476                 },
477                 .type           = I2C_ADAPTER_SMBUS,
478         },
479 };
480 DECLARE_CROS_LAPTOP(cr48);
481
482 static const u32 samus_touchpad_buttons[] __initconst = {
483         KEY_RESERVED,
484         KEY_RESERVED,
485         KEY_RESERVED,
486         BTN_LEFT
487 };
488
489 static const struct property_entry samus_trackpad_props[] __initconst = {
490         PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
491         PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", samus_touchpad_buttons),
492         { }
493 };
494
495 static struct acpi_peripheral samus_peripherals[] __initdata = {
496         /* Touchpad */
497         {
498                 .hid            = "ATML0000",
499                 .properties     = samus_trackpad_props,
500         },
501         /* Touchsceen */
502         {
503                 .hid            = "ATML0001",
504                 .properties     = chromebook_atmel_touchscreen_props,
505         },
506 };
507 DECLARE_ACPI_CROS_LAPTOP(samus);
508
509 static struct acpi_peripheral generic_atmel_peripherals[] __initdata = {
510         /* Touchpad */
511         {
512                 .hid            = "ATML0000",
513                 .properties     = chromebook_pixel_trackpad_props,
514         },
515         /* Touchsceen */
516         {
517                 .hid            = "ATML0001",
518                 .properties     = chromebook_atmel_touchscreen_props,
519         },
520 };
521 DECLARE_ACPI_CROS_LAPTOP(generic_atmel);
522
523 static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
524         {
525                 .ident = "Samsung Series 5 550",
526                 .matches = {
527                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"),
528                         DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"),
529                 },
530                 .driver_data = (void *)&samsung_series_5_550,
531         },
532         {
533                 .ident = "Samsung Series 5",
534                 .matches = {
535                         DMI_MATCH(DMI_PRODUCT_NAME, "Alex"),
536                 },
537                 .driver_data = (void *)&samsung_series_5,
538         },
539         {
540                 .ident = "Chromebook Pixel",
541                 .matches = {
542                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
543                         DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
544                 },
545                 .driver_data = (void *)&chromebook_pixel,
546         },
547         {
548                 .ident = "Wolf",
549                 .matches = {
550                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
551                         DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"),
552                 },
553                 .driver_data = (void *)&dell_chromebook_11,
554         },
555         {
556                 .ident = "HP Chromebook 14",
557                 .matches = {
558                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
559                         DMI_MATCH(DMI_PRODUCT_NAME, "Falco"),
560                 },
561                 .driver_data = (void *)&hp_chromebook_14,
562         },
563         {
564                 .ident = "Toshiba CB35",
565                 .matches = {
566                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
567                         DMI_MATCH(DMI_PRODUCT_NAME, "Leon"),
568                 },
569                 .driver_data = (void *)&toshiba_cb35,
570         },
571         {
572                 .ident = "Acer C7 Chromebook",
573                 .matches = {
574                         DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"),
575                 },
576                 .driver_data = (void *)&acer_c7_chromebook,
577         },
578         {
579                 .ident = "Acer AC700",
580                 .matches = {
581                         DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"),
582                 },
583                 .driver_data = (void *)&acer_ac700,
584         },
585         {
586                 .ident = "Acer C720",
587                 .matches = {
588                         DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
589                 },
590                 .driver_data = (void *)&acer_c720,
591         },
592         {
593                 .ident = "HP Pavilion 14 Chromebook",
594                 .matches = {
595                         DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"),
596                 },
597                 .driver_data = (void *)&hp_pavilion_14_chromebook,
598         },
599         {
600                 .ident = "Cr-48",
601                 .matches = {
602                         DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
603                 },
604                 .driver_data = (void *)&cr48,
605         },
606         /* Devices with peripherals incompletely described in ACPI */
607         {
608                 .ident = "Chromebook Pro",
609                 .matches = {
610                         DMI_MATCH(DMI_SYS_VENDOR, "Google"),
611                         DMI_MATCH(DMI_PRODUCT_NAME, "Caroline"),
612                 },
613                 .driver_data = (void *)&samus,
614         },
615         {
616                 .ident = "Google Pixel 2 (2015)",
617                 .matches = {
618                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
619                         DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
620                 },
621                 .driver_data = (void *)&samus,
622         },
623         {
624                 .ident = "Samsung Chromebook 3",
625                 .matches = {
626                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
627                         DMI_MATCH(DMI_PRODUCT_NAME, "Celes"),
628                 },
629                 .driver_data = (void *)&samus,
630         },
631         {
632                 /*
633                  * Other Chromebooks with Atmel touch controllers:
634                  * - Winky (touchpad)
635                  * - Clapper, Expresso, Rambi, Glimmer (touchscreen)
636                  */
637                 .ident = "Other Chromebook",
638                 .matches = {
639                         /*
640                          * This will match all Google devices, not only devices
641                          * with Atmel, but we will validate that the device
642                          * actually has matching peripherals.
643                          */
644                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
645                 },
646                 .driver_data = (void *)&generic_atmel,
647         },
648         { }
649 };
650 MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table);
651
652 static int __init chromeos_laptop_scan_peripherals(struct device *dev, void *data)
653 {
654         int error;
655
656         if (dev->type == &i2c_adapter_type) {
657                 chromeos_laptop_check_adapter(to_i2c_adapter(dev));
658         } else if (dev->type == &i2c_client_type) {
659                 if (chromeos_laptop_adjust_client(to_i2c_client(dev))) {
660                         /*
661                          * Now that we have needed properties re-trigger
662                          * driver probe in case driver was initialized
663                          * earlier and probe failed.
664                          */
665                         error = device_attach(dev);
666                         if (error < 0)
667                                 dev_warn(dev,
668                                          "%s: device_attach() failed: %d\n",
669                                          __func__, error);
670                 }
671         }
672
673         return 0;
674 }
675
676 static int __init chromeos_laptop_get_irq_from_dmi(const char *dmi_name)
677 {
678         const struct dmi_device *dmi_dev;
679         const struct dmi_dev_onboard *dev_data;
680
681         dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, dmi_name, NULL);
682         if (!dmi_dev) {
683                 pr_err("failed to find DMI device '%s'\n", dmi_name);
684                 return -ENOENT;
685         }
686
687         dev_data = dmi_dev->device_data;
688         if (!dev_data) {
689                 pr_err("failed to get data from DMI for '%s'\n", dmi_name);
690                 return -EINVAL;
691         }
692
693         return dev_data->instance;
694 }
695
696 static int __init chromeos_laptop_setup_irq(struct i2c_peripheral *i2c_dev)
697 {
698         int irq;
699
700         if (i2c_dev->dmi_name) {
701                 irq = chromeos_laptop_get_irq_from_dmi(i2c_dev->dmi_name);
702                 if (irq < 0)
703                         return irq;
704
705                 i2c_dev->irq_resource  = (struct resource)
706                         DEFINE_RES_NAMED(irq, 1, NULL,
707                                          IORESOURCE_IRQ | i2c_dev->irqflags);
708                 i2c_dev->board_info.resources = &i2c_dev->irq_resource;
709                 i2c_dev->board_info.num_resources = 1;
710         }
711
712         return 0;
713 }
714
715 static int __init
716 chromeos_laptop_prepare_i2c_peripherals(struct chromeos_laptop *cros_laptop,
717                                         const struct chromeos_laptop *src)
718 {
719         struct i2c_peripheral *i2c_dev;
720         struct i2c_board_info *info;
721         int i;
722         int error;
723
724         if (!src->num_i2c_peripherals)
725                 return 0;
726
727         cros_laptop->i2c_peripherals = kmemdup(src->i2c_peripherals,
728                                                src->num_i2c_peripherals *
729                                                 sizeof(*src->i2c_peripherals),
730                                                GFP_KERNEL);
731         if (!cros_laptop->i2c_peripherals)
732                 return -ENOMEM;
733
734         cros_laptop->num_i2c_peripherals = src->num_i2c_peripherals;
735
736         for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
737                 i2c_dev = &cros_laptop->i2c_peripherals[i];
738                 info = &i2c_dev->board_info;
739
740                 error = chromeos_laptop_setup_irq(i2c_dev);
741                 if (error)
742                         goto err_out;
743
744                 /* We need to deep-copy properties */
745                 if (info->properties) {
746                         info->properties =
747                                 property_entries_dup(info->properties);
748                         if (IS_ERR(info->properties)) {
749                                 error = PTR_ERR(info->properties);
750                                 goto err_out;
751                         }
752                 }
753         }
754
755         return 0;
756
757 err_out:
758         while (--i >= 0) {
759                 i2c_dev = &cros_laptop->i2c_peripherals[i];
760                 info = &i2c_dev->board_info;
761                 if (info->properties)
762                         property_entries_free(info->properties);
763         }
764         kfree(cros_laptop->i2c_peripherals);
765         return error;
766 }
767
768 static int __init
769 chromeos_laptop_prepare_acpi_peripherals(struct chromeos_laptop *cros_laptop,
770                                         const struct chromeos_laptop *src)
771 {
772         struct acpi_peripheral *acpi_peripherals;
773         struct acpi_peripheral *acpi_dev;
774         const struct acpi_peripheral *src_dev;
775         int n_peripherals = 0;
776         int i;
777         int error;
778
779         for (i = 0; i < src->num_acpi_peripherals; i++) {
780                 if (acpi_dev_present(src->acpi_peripherals[i].hid, NULL, -1))
781                         n_peripherals++;
782         }
783
784         if (!n_peripherals)
785                 return 0;
786
787         acpi_peripherals = kcalloc(n_peripherals,
788                                    sizeof(*src->acpi_peripherals),
789                                    GFP_KERNEL);
790         if (!acpi_peripherals)
791                 return -ENOMEM;
792
793         acpi_dev = acpi_peripherals;
794         for (i = 0; i < src->num_acpi_peripherals; i++) {
795                 src_dev = &src->acpi_peripherals[i];
796                 if (!acpi_dev_present(src_dev->hid, NULL, -1))
797                         continue;
798
799                 *acpi_dev = *src_dev;
800
801                 /* We need to deep-copy properties */
802                 if (src_dev->properties) {
803                         acpi_dev->properties =
804                                 property_entries_dup(src_dev->properties);
805                         if (IS_ERR(acpi_dev->properties)) {
806                                 error = PTR_ERR(acpi_dev->properties);
807                                 goto err_out;
808                         }
809                 }
810
811                 acpi_dev++;
812         }
813
814         cros_laptop->acpi_peripherals = acpi_peripherals;
815         cros_laptop->num_acpi_peripherals = n_peripherals;
816
817         return 0;
818
819 err_out:
820         while (--i >= 0) {
821                 acpi_dev = &acpi_peripherals[i];
822                 if (acpi_dev->properties)
823                         property_entries_free(acpi_dev->properties);
824         }
825
826         kfree(acpi_peripherals);
827         return error;
828 }
829
830 static void chromeos_laptop_destroy(const struct chromeos_laptop *cros_laptop)
831 {
832         const struct acpi_peripheral *acpi_dev;
833         struct i2c_peripheral *i2c_dev;
834         struct i2c_board_info *info;
835         int i;
836
837         for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
838                 i2c_dev = &cros_laptop->i2c_peripherals[i];
839                 info = &i2c_dev->board_info;
840
841                 if (i2c_dev->client)
842                         i2c_unregister_device(i2c_dev->client);
843
844                 if (info->properties)
845                         property_entries_free(info->properties);
846         }
847
848         for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) {
849                 acpi_dev = &cros_laptop->acpi_peripherals[i];
850
851                 if (acpi_dev->properties)
852                         property_entries_free(acpi_dev->properties);
853         }
854
855         kfree(cros_laptop->i2c_peripherals);
856         kfree(cros_laptop->acpi_peripherals);
857         kfree(cros_laptop);
858 }
859
860 static struct chromeos_laptop * __init
861 chromeos_laptop_prepare(const struct chromeos_laptop *src)
862 {
863         struct chromeos_laptop *cros_laptop;
864         int error;
865
866         cros_laptop = kzalloc(sizeof(*cros_laptop), GFP_KERNEL);
867         if (!cros_laptop)
868                 return ERR_PTR(-ENOMEM);
869
870         error = chromeos_laptop_prepare_i2c_peripherals(cros_laptop, src);
871         if (!error)
872                 error = chromeos_laptop_prepare_acpi_peripherals(cros_laptop,
873                                                                  src);
874
875         if (error) {
876                 chromeos_laptop_destroy(cros_laptop);
877                 return ERR_PTR(error);
878         }
879
880         return cros_laptop;
881 }
882
883 static int __init chromeos_laptop_init(void)
884 {
885         const struct dmi_system_id *dmi_id;
886         int error;
887
888         dmi_id = dmi_first_match(chromeos_laptop_dmi_table);
889         if (!dmi_id) {
890                 pr_debug("unsupported system\n");
891                 return -ENODEV;
892         }
893
894         pr_debug("DMI Matched %s\n", dmi_id->ident);
895
896         cros_laptop = chromeos_laptop_prepare((void *)dmi_id->driver_data);
897         if (IS_ERR(cros_laptop))
898                 return PTR_ERR(cros_laptop);
899
900         if (!cros_laptop->num_i2c_peripherals &&
901             !cros_laptop->num_acpi_peripherals) {
902                 pr_debug("no relevant devices detected\n");
903                 error = -ENODEV;
904                 goto err_destroy_cros_laptop;
905         }
906
907         error = bus_register_notifier(&i2c_bus_type,
908                                       &chromeos_laptop_i2c_notifier);
909         if (error) {
910                 pr_err("failed to register i2c bus notifier: %d\n",
911                        error);
912                 goto err_destroy_cros_laptop;
913         }
914
915         /*
916          * Scan adapters that have been registered and clients that have
917          * been created before we installed the notifier to make sure
918          * we do not miss any devices.
919          */
920         i2c_for_each_dev(NULL, chromeos_laptop_scan_peripherals);
921
922         return 0;
923
924 err_destroy_cros_laptop:
925         chromeos_laptop_destroy(cros_laptop);
926         return error;
927 }
928
929 static void __exit chromeos_laptop_exit(void)
930 {
931         bus_unregister_notifier(&i2c_bus_type, &chromeos_laptop_i2c_notifier);
932         chromeos_laptop_destroy(cros_laptop);
933 }
934
935 module_init(chromeos_laptop_init);
936 module_exit(chromeos_laptop_exit);
937
938 MODULE_DESCRIPTION("Chrome OS Laptop driver");
939 MODULE_AUTHOR("Benson Leung <bleung@chromium.org>");
940 MODULE_LICENSE("GPL");