![Heiner Kallweit](/assets/img/avatar_default.png)
Use new helper pci_dev_id() to simplify the code. Signed-off-by: Heiner Kallweit <hkallweit1@gmail.com> Signed-off-by: Bjorn Helgaas <bhelgaas@google.com> Acked-By: Benson Leung <bleung@chromium.org>
941 lines
22 KiB
C
941 lines
22 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
// Driver to instantiate Chromebook i2c/smbus devices.
|
|
//
|
|
// Copyright (C) 2012 Google, Inc.
|
|
// Author: Benson Leung <bleung@chromium.org>
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/dmi.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/input.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/property.h>
|
|
|
|
#define ATMEL_TP_I2C_ADDR 0x4b
|
|
#define ATMEL_TP_I2C_BL_ADDR 0x25
|
|
#define ATMEL_TS_I2C_ADDR 0x4a
|
|
#define ATMEL_TS_I2C_BL_ADDR 0x26
|
|
#define CYAPA_TP_I2C_ADDR 0x67
|
|
#define ELAN_TP_I2C_ADDR 0x15
|
|
#define ISL_ALS_I2C_ADDR 0x44
|
|
#define TAOS_ALS_I2C_ADDR 0x29
|
|
|
|
static const char *i2c_adapter_names[] = {
|
|
"SMBus I801 adapter",
|
|
"i915 gmbus vga",
|
|
"i915 gmbus panel",
|
|
"Synopsys DesignWare I2C adapter",
|
|
};
|
|
|
|
/* Keep this enum consistent with i2c_adapter_names */
|
|
enum i2c_adapter_type {
|
|
I2C_ADAPTER_SMBUS = 0,
|
|
I2C_ADAPTER_VGADDC,
|
|
I2C_ADAPTER_PANEL,
|
|
I2C_ADAPTER_DESIGNWARE,
|
|
};
|
|
|
|
struct i2c_peripheral {
|
|
struct i2c_board_info board_info;
|
|
unsigned short alt_addr;
|
|
|
|
const char *dmi_name;
|
|
unsigned long irqflags;
|
|
struct resource irq_resource;
|
|
|
|
enum i2c_adapter_type type;
|
|
u32 pci_devid;
|
|
|
|
struct i2c_client *client;
|
|
};
|
|
|
|
struct acpi_peripheral {
|
|
char hid[ACPI_ID_LEN];
|
|
const struct property_entry *properties;
|
|
};
|
|
|
|
struct chromeos_laptop {
|
|
/*
|
|
* Note that we can't mark this pointer as const because
|
|
* i2c_new_probed_device() changes passed in I2C board info, so.
|
|
*/
|
|
struct i2c_peripheral *i2c_peripherals;
|
|
unsigned int num_i2c_peripherals;
|
|
|
|
const struct acpi_peripheral *acpi_peripherals;
|
|
unsigned int num_acpi_peripherals;
|
|
};
|
|
|
|
static const struct chromeos_laptop *cros_laptop;
|
|
|
|
static struct i2c_client *
|
|
chromes_laptop_instantiate_i2c_device(struct i2c_adapter *adapter,
|
|
struct i2c_board_info *info,
|
|
unsigned short alt_addr)
|
|
{
|
|
const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END };
|
|
struct i2c_client *client;
|
|
|
|
/*
|
|
* Add the i2c device. If we can't detect it at the primary
|
|
* address we scan secondary addresses. In any case the client
|
|
* structure gets assigned primary address.
|
|
*/
|
|
client = i2c_new_probed_device(adapter, info, addr_list, NULL);
|
|
if (!client && alt_addr) {
|
|
struct i2c_board_info dummy_info = {
|
|
I2C_BOARD_INFO("dummy", info->addr),
|
|
};
|
|
const unsigned short alt_addr_list[] = {
|
|
alt_addr, I2C_CLIENT_END
|
|
};
|
|
struct i2c_client *dummy;
|
|
|
|
dummy = i2c_new_probed_device(adapter, &dummy_info,
|
|
alt_addr_list, NULL);
|
|
if (dummy) {
|
|
pr_debug("%d-%02x is probed at %02x\n",
|
|
adapter->nr, info->addr, dummy->addr);
|
|
i2c_unregister_device(dummy);
|
|
client = i2c_new_device(adapter, info);
|
|
}
|
|
}
|
|
|
|
if (!client)
|
|
pr_debug("failed to register device %d-%02x\n",
|
|
adapter->nr, info->addr);
|
|
else
|
|
pr_debug("added i2c device %d-%02x\n",
|
|
adapter->nr, info->addr);
|
|
|
|
return client;
|
|
}
|
|
|
|
static bool chromeos_laptop_match_adapter_devid(struct device *dev, u32 devid)
|
|
{
|
|
struct pci_dev *pdev;
|
|
|
|
if (!dev_is_pci(dev))
|
|
return false;
|
|
|
|
pdev = to_pci_dev(dev);
|
|
return devid == pci_dev_id(pdev);
|
|
}
|
|
|
|
static void chromeos_laptop_check_adapter(struct i2c_adapter *adapter)
|
|
{
|
|
struct i2c_peripheral *i2c_dev;
|
|
int i;
|
|
|
|
for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
|
|
i2c_dev = &cros_laptop->i2c_peripherals[i];
|
|
|
|
/* Skip devices already created */
|
|
if (i2c_dev->client)
|
|
continue;
|
|
|
|
if (strncmp(adapter->name, i2c_adapter_names[i2c_dev->type],
|
|
strlen(i2c_adapter_names[i2c_dev->type])))
|
|
continue;
|
|
|
|
if (i2c_dev->pci_devid &&
|
|
!chromeos_laptop_match_adapter_devid(adapter->dev.parent,
|
|
i2c_dev->pci_devid)) {
|
|
continue;
|
|
}
|
|
|
|
i2c_dev->client =
|
|
chromes_laptop_instantiate_i2c_device(adapter,
|
|
&i2c_dev->board_info,
|
|
i2c_dev->alt_addr);
|
|
}
|
|
}
|
|
|
|
static bool chromeos_laptop_adjust_client(struct i2c_client *client)
|
|
{
|
|
const struct acpi_peripheral *acpi_dev;
|
|
struct acpi_device_id acpi_ids[2] = { };
|
|
int i;
|
|
int error;
|
|
|
|
if (!has_acpi_companion(&client->dev))
|
|
return false;
|
|
|
|
for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) {
|
|
acpi_dev = &cros_laptop->acpi_peripherals[i];
|
|
|
|
memcpy(acpi_ids[0].id, acpi_dev->hid, ACPI_ID_LEN);
|
|
|
|
if (acpi_match_device(acpi_ids, &client->dev)) {
|
|
error = device_add_properties(&client->dev,
|
|
acpi_dev->properties);
|
|
if (error) {
|
|
dev_err(&client->dev,
|
|
"failed to add properties: %d\n",
|
|
error);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void chromeos_laptop_detach_i2c_client(struct i2c_client *client)
|
|
{
|
|
struct i2c_peripheral *i2c_dev;
|
|
int i;
|
|
|
|
for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
|
|
i2c_dev = &cros_laptop->i2c_peripherals[i];
|
|
|
|
if (i2c_dev->client == client)
|
|
i2c_dev->client = NULL;
|
|
}
|
|
}
|
|
|
|
static int chromeos_laptop_i2c_notifier_call(struct notifier_block *nb,
|
|
unsigned long action, void *data)
|
|
{
|
|
struct device *dev = data;
|
|
|
|
switch (action) {
|
|
case BUS_NOTIFY_ADD_DEVICE:
|
|
if (dev->type == &i2c_adapter_type)
|
|
chromeos_laptop_check_adapter(to_i2c_adapter(dev));
|
|
else if (dev->type == &i2c_client_type)
|
|
chromeos_laptop_adjust_client(to_i2c_client(dev));
|
|
break;
|
|
|
|
case BUS_NOTIFY_REMOVED_DEVICE:
|
|
if (dev->type == &i2c_client_type)
|
|
chromeos_laptop_detach_i2c_client(to_i2c_client(dev));
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct notifier_block chromeos_laptop_i2c_notifier = {
|
|
.notifier_call = chromeos_laptop_i2c_notifier_call,
|
|
};
|
|
|
|
#define DECLARE_CROS_LAPTOP(_name) \
|
|
static const struct chromeos_laptop _name __initconst = { \
|
|
.i2c_peripherals = _name##_peripherals, \
|
|
.num_i2c_peripherals = ARRAY_SIZE(_name##_peripherals), \
|
|
}
|
|
|
|
#define DECLARE_ACPI_CROS_LAPTOP(_name) \
|
|
static const struct chromeos_laptop _name __initconst = { \
|
|
.acpi_peripherals = _name##_peripherals, \
|
|
.num_acpi_peripherals = ARRAY_SIZE(_name##_peripherals), \
|
|
}
|
|
|
|
static struct i2c_peripheral samsung_series_5_550_peripherals[] __initdata = {
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
/* Light Sensor. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
|
|
},
|
|
.dmi_name = "lightsensor",
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(samsung_series_5_550);
|
|
|
|
static struct i2c_peripheral samsung_series_5_peripherals[] __initdata = {
|
|
/* Light Sensor. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
|
|
},
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(samsung_series_5);
|
|
|
|
static const int chromebook_pixel_tp_keys[] __initconst = {
|
|
KEY_RESERVED,
|
|
KEY_RESERVED,
|
|
KEY_RESERVED,
|
|
KEY_RESERVED,
|
|
KEY_RESERVED,
|
|
BTN_LEFT
|
|
};
|
|
|
|
static const struct property_entry
|
|
chromebook_pixel_trackpad_props[] __initconst = {
|
|
PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
|
|
PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", chromebook_pixel_tp_keys),
|
|
{ }
|
|
};
|
|
|
|
static const struct property_entry
|
|
chromebook_atmel_touchscreen_props[] __initconst = {
|
|
PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
|
|
{ }
|
|
};
|
|
|
|
static struct i2c_peripheral chromebook_pixel_peripherals[] __initdata = {
|
|
/* Touch Screen. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("atmel_mxt_ts",
|
|
ATMEL_TS_I2C_ADDR),
|
|
.properties =
|
|
chromebook_atmel_touchscreen_props,
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "touchscreen",
|
|
.irqflags = IRQF_TRIGGER_FALLING,
|
|
.type = I2C_ADAPTER_PANEL,
|
|
.alt_addr = ATMEL_TS_I2C_BL_ADDR,
|
|
},
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("atmel_mxt_tp",
|
|
ATMEL_TP_I2C_ADDR),
|
|
.properties =
|
|
chromebook_pixel_trackpad_props,
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.irqflags = IRQF_TRIGGER_FALLING,
|
|
.type = I2C_ADAPTER_VGADDC,
|
|
.alt_addr = ATMEL_TP_I2C_BL_ADDR,
|
|
},
|
|
/* Light Sensor. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
|
|
},
|
|
.dmi_name = "lightsensor",
|
|
.type = I2C_ADAPTER_PANEL,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(chromebook_pixel);
|
|
|
|
static struct i2c_peripheral hp_chromebook_14_peripherals[] __initdata = {
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(hp_chromebook_14);
|
|
|
|
static struct i2c_peripheral dell_chromebook_11_peripherals[] __initdata = {
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
},
|
|
/* Elan Touchpad option. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(dell_chromebook_11);
|
|
|
|
static struct i2c_peripheral toshiba_cb35_peripherals[] __initdata = {
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(toshiba_cb35);
|
|
|
|
static struct i2c_peripheral acer_c7_chromebook_peripherals[] __initdata = {
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(acer_c7_chromebook);
|
|
|
|
static struct i2c_peripheral acer_ac700_peripherals[] __initdata = {
|
|
/* Light Sensor. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
|
|
},
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(acer_ac700);
|
|
|
|
static struct i2c_peripheral acer_c720_peripherals[] __initdata = {
|
|
/* Touchscreen. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("atmel_mxt_ts",
|
|
ATMEL_TS_I2C_ADDR),
|
|
.properties =
|
|
chromebook_atmel_touchscreen_props,
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "touchscreen",
|
|
.irqflags = IRQF_TRIGGER_FALLING,
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
.pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)),
|
|
.alt_addr = ATMEL_TS_I2C_BL_ADDR,
|
|
},
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
.pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)),
|
|
},
|
|
/* Elan Touchpad option. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
.pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)),
|
|
},
|
|
/* Light Sensor. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
|
|
},
|
|
.dmi_name = "lightsensor",
|
|
.type = I2C_ADAPTER_DESIGNWARE,
|
|
.pci_devid = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)),
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(acer_c720);
|
|
|
|
static struct i2c_peripheral
|
|
hp_pavilion_14_chromebook_peripherals[] __initdata = {
|
|
/* Touchpad. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
|
|
.flags = I2C_CLIENT_WAKE,
|
|
},
|
|
.dmi_name = "trackpad",
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(hp_pavilion_14_chromebook);
|
|
|
|
static struct i2c_peripheral cr48_peripherals[] __initdata = {
|
|
/* Light Sensor. */
|
|
{
|
|
.board_info = {
|
|
I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR),
|
|
},
|
|
.type = I2C_ADAPTER_SMBUS,
|
|
},
|
|
};
|
|
DECLARE_CROS_LAPTOP(cr48);
|
|
|
|
static const u32 samus_touchpad_buttons[] __initconst = {
|
|
KEY_RESERVED,
|
|
KEY_RESERVED,
|
|
KEY_RESERVED,
|
|
BTN_LEFT
|
|
};
|
|
|
|
static const struct property_entry samus_trackpad_props[] __initconst = {
|
|
PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
|
|
PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", samus_touchpad_buttons),
|
|
{ }
|
|
};
|
|
|
|
static struct acpi_peripheral samus_peripherals[] __initdata = {
|
|
/* Touchpad */
|
|
{
|
|
.hid = "ATML0000",
|
|
.properties = samus_trackpad_props,
|
|
},
|
|
/* Touchsceen */
|
|
{
|
|
.hid = "ATML0001",
|
|
.properties = chromebook_atmel_touchscreen_props,
|
|
},
|
|
};
|
|
DECLARE_ACPI_CROS_LAPTOP(samus);
|
|
|
|
static struct acpi_peripheral generic_atmel_peripherals[] __initdata = {
|
|
/* Touchpad */
|
|
{
|
|
.hid = "ATML0000",
|
|
.properties = chromebook_pixel_trackpad_props,
|
|
},
|
|
/* Touchsceen */
|
|
{
|
|
.hid = "ATML0001",
|
|
.properties = chromebook_atmel_touchscreen_props,
|
|
},
|
|
};
|
|
DECLARE_ACPI_CROS_LAPTOP(generic_atmel);
|
|
|
|
static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
|
|
{
|
|
.ident = "Samsung Series 5 550",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"),
|
|
},
|
|
.driver_data = (void *)&samsung_series_5_550,
|
|
},
|
|
{
|
|
.ident = "Samsung Series 5",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Alex"),
|
|
},
|
|
.driver_data = (void *)&samsung_series_5,
|
|
},
|
|
{
|
|
.ident = "Chromebook Pixel",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
|
|
},
|
|
.driver_data = (void *)&chromebook_pixel,
|
|
},
|
|
{
|
|
.ident = "Wolf",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"),
|
|
},
|
|
.driver_data = (void *)&dell_chromebook_11,
|
|
},
|
|
{
|
|
.ident = "HP Chromebook 14",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Falco"),
|
|
},
|
|
.driver_data = (void *)&hp_chromebook_14,
|
|
},
|
|
{
|
|
.ident = "Toshiba CB35",
|
|
.matches = {
|
|
DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Leon"),
|
|
},
|
|
.driver_data = (void *)&toshiba_cb35,
|
|
},
|
|
{
|
|
.ident = "Acer C7 Chromebook",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"),
|
|
},
|
|
.driver_data = (void *)&acer_c7_chromebook,
|
|
},
|
|
{
|
|
.ident = "Acer AC700",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"),
|
|
},
|
|
.driver_data = (void *)&acer_ac700,
|
|
},
|
|
{
|
|
.ident = "Acer C720",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
|
|
},
|
|
.driver_data = (void *)&acer_c720,
|
|
},
|
|
{
|
|
.ident = "HP Pavilion 14 Chromebook",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"),
|
|
},
|
|
.driver_data = (void *)&hp_pavilion_14_chromebook,
|
|
},
|
|
{
|
|
.ident = "Cr-48",
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
|
|
},
|
|
.driver_data = (void *)&cr48,
|
|
},
|
|
/* Devices with peripherals incompletely described in ACPI */
|
|
{
|
|
.ident = "Chromebook Pro",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Google"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Caroline"),
|
|
},
|
|
.driver_data = (void *)&samus,
|
|
},
|
|
{
|
|
.ident = "Google Pixel 2 (2015)",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
|
|
},
|
|
.driver_data = (void *)&samus,
|
|
},
|
|
{
|
|
.ident = "Samsung Chromebook 3",
|
|
.matches = {
|
|
DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Celes"),
|
|
},
|
|
.driver_data = (void *)&samus,
|
|
},
|
|
{
|
|
/*
|
|
* Other Chromebooks with Atmel touch controllers:
|
|
* - Winky (touchpad)
|
|
* - Clapper, Expresso, Rambi, Glimmer (touchscreen)
|
|
*/
|
|
.ident = "Other Chromebook",
|
|
.matches = {
|
|
/*
|
|
* This will match all Google devices, not only devices
|
|
* with Atmel, but we will validate that the device
|
|
* actually has matching peripherals.
|
|
*/
|
|
DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
|
|
},
|
|
.driver_data = (void *)&generic_atmel,
|
|
},
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table);
|
|
|
|
static int __init chromeos_laptop_scan_peripherals(struct device *dev, void *data)
|
|
{
|
|
int error;
|
|
|
|
if (dev->type == &i2c_adapter_type) {
|
|
chromeos_laptop_check_adapter(to_i2c_adapter(dev));
|
|
} else if (dev->type == &i2c_client_type) {
|
|
if (chromeos_laptop_adjust_client(to_i2c_client(dev))) {
|
|
/*
|
|
* Now that we have needed properties re-trigger
|
|
* driver probe in case driver was initialized
|
|
* earlier and probe failed.
|
|
*/
|
|
error = device_attach(dev);
|
|
if (error < 0)
|
|
dev_warn(dev,
|
|
"%s: device_attach() failed: %d\n",
|
|
__func__, error);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init chromeos_laptop_get_irq_from_dmi(const char *dmi_name)
|
|
{
|
|
const struct dmi_device *dmi_dev;
|
|
const struct dmi_dev_onboard *dev_data;
|
|
|
|
dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, dmi_name, NULL);
|
|
if (!dmi_dev) {
|
|
pr_err("failed to find DMI device '%s'\n", dmi_name);
|
|
return -ENOENT;
|
|
}
|
|
|
|
dev_data = dmi_dev->device_data;
|
|
if (!dev_data) {
|
|
pr_err("failed to get data from DMI for '%s'\n", dmi_name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return dev_data->instance;
|
|
}
|
|
|
|
static int __init chromeos_laptop_setup_irq(struct i2c_peripheral *i2c_dev)
|
|
{
|
|
int irq;
|
|
|
|
if (i2c_dev->dmi_name) {
|
|
irq = chromeos_laptop_get_irq_from_dmi(i2c_dev->dmi_name);
|
|
if (irq < 0)
|
|
return irq;
|
|
|
|
i2c_dev->irq_resource = (struct resource)
|
|
DEFINE_RES_NAMED(irq, 1, NULL,
|
|
IORESOURCE_IRQ | i2c_dev->irqflags);
|
|
i2c_dev->board_info.resources = &i2c_dev->irq_resource;
|
|
i2c_dev->board_info.num_resources = 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __init
|
|
chromeos_laptop_prepare_i2c_peripherals(struct chromeos_laptop *cros_laptop,
|
|
const struct chromeos_laptop *src)
|
|
{
|
|
struct i2c_peripheral *i2c_dev;
|
|
struct i2c_board_info *info;
|
|
int i;
|
|
int error;
|
|
|
|
if (!src->num_i2c_peripherals)
|
|
return 0;
|
|
|
|
cros_laptop->i2c_peripherals = kmemdup(src->i2c_peripherals,
|
|
src->num_i2c_peripherals *
|
|
sizeof(*src->i2c_peripherals),
|
|
GFP_KERNEL);
|
|
if (!cros_laptop->i2c_peripherals)
|
|
return -ENOMEM;
|
|
|
|
cros_laptop->num_i2c_peripherals = src->num_i2c_peripherals;
|
|
|
|
for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
|
|
i2c_dev = &cros_laptop->i2c_peripherals[i];
|
|
info = &i2c_dev->board_info;
|
|
|
|
error = chromeos_laptop_setup_irq(i2c_dev);
|
|
if (error)
|
|
goto err_out;
|
|
|
|
/* We need to deep-copy properties */
|
|
if (info->properties) {
|
|
info->properties =
|
|
property_entries_dup(info->properties);
|
|
if (IS_ERR(info->properties)) {
|
|
error = PTR_ERR(info->properties);
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
err_out:
|
|
while (--i >= 0) {
|
|
i2c_dev = &cros_laptop->i2c_peripherals[i];
|
|
info = &i2c_dev->board_info;
|
|
if (info->properties)
|
|
property_entries_free(info->properties);
|
|
}
|
|
kfree(cros_laptop->i2c_peripherals);
|
|
return error;
|
|
}
|
|
|
|
static int __init
|
|
chromeos_laptop_prepare_acpi_peripherals(struct chromeos_laptop *cros_laptop,
|
|
const struct chromeos_laptop *src)
|
|
{
|
|
struct acpi_peripheral *acpi_peripherals;
|
|
struct acpi_peripheral *acpi_dev;
|
|
const struct acpi_peripheral *src_dev;
|
|
int n_peripherals = 0;
|
|
int i;
|
|
int error;
|
|
|
|
for (i = 0; i < src->num_acpi_peripherals; i++) {
|
|
if (acpi_dev_present(src->acpi_peripherals[i].hid, NULL, -1))
|
|
n_peripherals++;
|
|
}
|
|
|
|
if (!n_peripherals)
|
|
return 0;
|
|
|
|
acpi_peripherals = kcalloc(n_peripherals,
|
|
sizeof(*src->acpi_peripherals),
|
|
GFP_KERNEL);
|
|
if (!acpi_peripherals)
|
|
return -ENOMEM;
|
|
|
|
acpi_dev = acpi_peripherals;
|
|
for (i = 0; i < src->num_acpi_peripherals; i++) {
|
|
src_dev = &src->acpi_peripherals[i];
|
|
if (!acpi_dev_present(src_dev->hid, NULL, -1))
|
|
continue;
|
|
|
|
*acpi_dev = *src_dev;
|
|
|
|
/* We need to deep-copy properties */
|
|
if (src_dev->properties) {
|
|
acpi_dev->properties =
|
|
property_entries_dup(src_dev->properties);
|
|
if (IS_ERR(acpi_dev->properties)) {
|
|
error = PTR_ERR(acpi_dev->properties);
|
|
goto err_out;
|
|
}
|
|
}
|
|
|
|
acpi_dev++;
|
|
}
|
|
|
|
cros_laptop->acpi_peripherals = acpi_peripherals;
|
|
cros_laptop->num_acpi_peripherals = n_peripherals;
|
|
|
|
return 0;
|
|
|
|
err_out:
|
|
while (--i >= 0) {
|
|
acpi_dev = &acpi_peripherals[i];
|
|
if (acpi_dev->properties)
|
|
property_entries_free(acpi_dev->properties);
|
|
}
|
|
|
|
kfree(acpi_peripherals);
|
|
return error;
|
|
}
|
|
|
|
static void chromeos_laptop_destroy(const struct chromeos_laptop *cros_laptop)
|
|
{
|
|
const struct acpi_peripheral *acpi_dev;
|
|
struct i2c_peripheral *i2c_dev;
|
|
struct i2c_board_info *info;
|
|
int i;
|
|
|
|
for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
|
|
i2c_dev = &cros_laptop->i2c_peripherals[i];
|
|
info = &i2c_dev->board_info;
|
|
|
|
if (i2c_dev->client)
|
|
i2c_unregister_device(i2c_dev->client);
|
|
|
|
if (info->properties)
|
|
property_entries_free(info->properties);
|
|
}
|
|
|
|
for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) {
|
|
acpi_dev = &cros_laptop->acpi_peripherals[i];
|
|
|
|
if (acpi_dev->properties)
|
|
property_entries_free(acpi_dev->properties);
|
|
}
|
|
|
|
kfree(cros_laptop->i2c_peripherals);
|
|
kfree(cros_laptop->acpi_peripherals);
|
|
kfree(cros_laptop);
|
|
}
|
|
|
|
static struct chromeos_laptop * __init
|
|
chromeos_laptop_prepare(const struct chromeos_laptop *src)
|
|
{
|
|
struct chromeos_laptop *cros_laptop;
|
|
int error;
|
|
|
|
cros_laptop = kzalloc(sizeof(*cros_laptop), GFP_KERNEL);
|
|
if (!cros_laptop)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
error = chromeos_laptop_prepare_i2c_peripherals(cros_laptop, src);
|
|
if (!error)
|
|
error = chromeos_laptop_prepare_acpi_peripherals(cros_laptop,
|
|
src);
|
|
|
|
if (error) {
|
|
chromeos_laptop_destroy(cros_laptop);
|
|
return ERR_PTR(error);
|
|
}
|
|
|
|
return cros_laptop;
|
|
}
|
|
|
|
static int __init chromeos_laptop_init(void)
|
|
{
|
|
const struct dmi_system_id *dmi_id;
|
|
int error;
|
|
|
|
dmi_id = dmi_first_match(chromeos_laptop_dmi_table);
|
|
if (!dmi_id) {
|
|
pr_debug("unsupported system\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
pr_debug("DMI Matched %s\n", dmi_id->ident);
|
|
|
|
cros_laptop = chromeos_laptop_prepare((void *)dmi_id->driver_data);
|
|
if (IS_ERR(cros_laptop))
|
|
return PTR_ERR(cros_laptop);
|
|
|
|
if (!cros_laptop->num_i2c_peripherals &&
|
|
!cros_laptop->num_acpi_peripherals) {
|
|
pr_debug("no relevant devices detected\n");
|
|
error = -ENODEV;
|
|
goto err_destroy_cros_laptop;
|
|
}
|
|
|
|
error = bus_register_notifier(&i2c_bus_type,
|
|
&chromeos_laptop_i2c_notifier);
|
|
if (error) {
|
|
pr_err("failed to register i2c bus notifier: %d\n",
|
|
error);
|
|
goto err_destroy_cros_laptop;
|
|
}
|
|
|
|
/*
|
|
* Scan adapters that have been registered and clients that have
|
|
* been created before we installed the notifier to make sure
|
|
* we do not miss any devices.
|
|
*/
|
|
i2c_for_each_dev(NULL, chromeos_laptop_scan_peripherals);
|
|
|
|
return 0;
|
|
|
|
err_destroy_cros_laptop:
|
|
chromeos_laptop_destroy(cros_laptop);
|
|
return error;
|
|
}
|
|
|
|
static void __exit chromeos_laptop_exit(void)
|
|
{
|
|
bus_unregister_notifier(&i2c_bus_type, &chromeos_laptop_i2c_notifier);
|
|
chromeos_laptop_destroy(cros_laptop);
|
|
}
|
|
|
|
module_init(chromeos_laptop_init);
|
|
module_exit(chromeos_laptop_exit);
|
|
|
|
MODULE_DESCRIPTION("Chrome OS Laptop driver");
|
|
MODULE_AUTHOR("Benson Leung <bleung@chromium.org>");
|
|
MODULE_LICENSE("GPL");
|