rooty/cube_i10_debian
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
cube_i10_debian/gslx680-acpi/gslx680_ts_acpi.c

776 lines
20 KiB
C
Raw Permalink Blame History

/*
* Silead GSL1680/3680 touchscreen driver
*
* Copyright (c) 2015 Gregor Riepl <onitake@gmail.com>
*
* This driver is based on gslx680_ts.c and elan_ts.c
* Copyright (c) 2012 Shanghai Basewin
* Guan Yuwei<guanyuwei@basewin.com>
* Copyright (c) 2013 Joe Burmeister
* Joe Burmeister<joe.a.burmeister@googlemail.com>
* Copyright (C) 2014 Elan Microelectronics Corporation.
* Scott Liu <scott.liu@emc.com.tw>
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*/
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/input/mt.h>
#include <linux/acpi.h>
#include <linux/of.h>
#include <linux/gpio/consumer.h>
#include <linux/version.h>
/* Device and driver information */
#define DEVICE_NAME "gslx680"
#define DRIVER_VERSION "0.2.1"
/* Hardware API constants */
#define GSL_DATA_REG 0x80
#define GSL_STATUS_REG 0xe0
#define GSL_PAGE_REG 0xf0
#define GSL_TOUCH_STATUS_REG 0xbc
#define GSL_PAGE_SIZE 128
/* Why 126? */
#define GSL_MAX_READ 126
/* Actually 129: 1 command byte and 128 data bytes
* this was 125 originally - using 128 to allow firmware transfers
*/
#define GSL_MAX_WRITE 128
#define GSL_STATUS_FW 0x80
#define GSL_STATUS_TOUCH 0x00
#define GSL_PWR_GPIO "power"
#define GSL_MAX_CONTACTS 10
#define GSL_MAX_AXIS 0xfff
#define GSL_DMAX 0
#define GSL_JITTER 0
#define GSL_DEADZONE 0
#define GSL_PACKET_SIZE ( \
GSL_MAX_CONTACTS * sizeof(struct gsl_ts_packet_touch) + \
sizeof(struct gsl_ts_packet_header) \
)
#define GSL_FW_NAME_MAXLEN 32
#define GSL_FW_NAME_DEFAULT "silead_ts.fw"
#define GSL_FW_VERSION 1
#define GSL_FW_ID_LIT(a, b, c, d) ( \
((a) & 0xff) | \
(((b) & 0xff) << 8) | \
(((c) & 0xff) << 16) | \
(((d) & 0xff) << 24) \
)
#define GSL_FW_MAGIC GSL_FW_ID_LIT('G', 'S', 'L', 'X')
#define GSL_FW_MODEL_LIT(m) GSL_FW_ID_LIT( \
(m)/1000%10+'0', \
(m)/100%10+'0', \
(m)/10%10+'0', \
(m)%10+'0' \
)
#define GSL_FW_MODEL_1680 GSL_FW_MODEL_LIT(1680)
/* Module Parameters (optional) */
static char *gsl_fw_name = NULL;
module_param_named(fw_name, gsl_fw_name, charp, 0);
/* Driver state */
enum gsl_ts_state {
GSL_TS_INIT,
GSL_TS_SHUTDOWN,
GSL_TS_GREEN,
};
/* Driver instance data structure */
struct gsl_ts_data {
struct i2c_client *client;
struct input_dev *input;
struct gpio_desc *gpio;
char fw_name[GSL_FW_NAME_MAXLEN];
enum gsl_ts_state state;
bool wake_irq_enabled;
unsigned int x_max;
unsigned int y_max;
unsigned int multi_touches;
bool x_reversed;
bool y_reversed;
bool xy_swapped;
bool soft_tracking;
int jitter;
int deadzone;
};
/* Firmware header */
struct gsl_ts_fw_header {
u32 magic;
u32 model;
u16 version;
u16 touches;
u16 width;
u16 height;
u8 swapped;
u8 xflipped;
u8 yflipped;
u8 tracking;
u32 pages;
} __packed;
/* Firmware data page */
struct gsl_ts_fw_page {
u16 address;
u16 size;
u8 data[128];
} __packed;
/* TODO use get_unaligned_le16 instead of packed structures */
/* Hardware touch event data header */
struct gsl_ts_packet_header {
u8 num_fingers;
u8 reserved;
u16 time_stamp; /* little-endian */
} __packed;
/* Hardware touch event data per finger */
struct gsl_ts_packet_touch {
u16 y_z; /* little endian, lower 12 bits = y, upper 4 bits = pressure (?) */
u16 x_id; /* little endian, lower 12 bits = x, upper 4 bits = id */
} __packed;
static int gsl_ts_init(struct gsl_ts_data *ts, const struct firmware *fw)
{
struct gsl_ts_fw_header *header;
u32 magic;
u16 version;
dev_dbg(&ts->client->dev, "%s: initialising driver state\n", __func__);
ts->wake_irq_enabled = false;
ts->state = GSL_TS_INIT;
if (fw->size < sizeof(struct gsl_ts_fw_header)) {
dev_err(&ts->client->dev, "%s: invalid firmware: file too small.\n", __func__);
return -EINVAL;
}
header = (struct gsl_ts_fw_header *) fw->data;
magic = le32_to_cpu(header->magic);
if (magic != GSL_FW_MAGIC) {
dev_err(&ts->client->dev, "%s: invalid firmware: invalid magic 0x%08x.\n", __func__, magic);
return -EINVAL;
}
version = le16_to_cpu(header->version);
if (version != GSL_FW_VERSION) {
dev_err(&ts->client->dev, "%s: invalid firmware: unsupported version %d.\n", __func__, version);
return -EINVAL;
}
ts->x_max = le16_to_cpu(header->width);
ts->y_max = le16_to_cpu(header->height);
ts->multi_touches = le16_to_cpu(header->touches);
if (ts->x_max == 0 || ts->y_max == 0 || ts->multi_touches == 0) {
dev_err(&ts->client->dev, "%s: invalid firmware: panel width, height or number of touch points is zero.\n", __func__);
return -EINVAL;
}
if (ts->x_max > GSL_MAX_AXIS || ts->y_max > GSL_MAX_AXIS || ts->multi_touches > GSL_MAX_CONTACTS) {
dev_err(&ts->client->dev, "%s: invalid firmware: maximum panel width, height or number of touch points exceeded.\n", __func__);
return -EINVAL;
}
ts->x_reversed = header->xflipped ? 1 : 0;
ts->y_reversed = header->yflipped ? 1 : 0;
ts->xy_swapped = header->swapped ? 1 : 0;
ts->soft_tracking = header->tracking ? 1 : 0;
ts->jitter = GSL_JITTER;
ts->deadzone = GSL_DEADZONE;
return 0;
}
static int gsl_ts_write(struct i2c_client *client, u8 reg, const u8 *pdata, int datalen)
{
u8 buf[GSL_PAGE_SIZE + 1];
unsigned int bytelen = 0;
if (datalen > GSL_MAX_WRITE) {
dev_err(&client->dev, "%s: data transfer too large (%d > %d)\n", __func__, datalen, GSL_MAX_WRITE);
return -EINVAL;
}
buf[0] = reg;
bytelen++;
if (datalen != 0 && pdata != NULL) {
memcpy(&buf[bytelen], pdata, datalen);
bytelen += datalen;
}
return i2c_master_send(client, buf, bytelen);
}
static int gsl_ts_read(struct i2c_client *client, u8 reg, u8 *pdata, unsigned int datalen)
{
int ret = 0;
if (datalen > GSL_MAX_READ) {
dev_err(&client->dev, "%s: data transfer too large (%d > %d)\n", __func__, datalen, GSL_MAX_READ);
return -EINVAL;
}
ret = gsl_ts_write(client, reg, NULL, 0);
if (ret < 0) {
dev_err(&client->dev, "%s: sending register location failed\n", __func__);
return ret;
}
return i2c_master_recv(client, pdata, datalen);
}
static int gsl_ts_startup_chip(struct i2c_client *client)
{
int rc;
u8 tmp = 0x00;
dev_dbg(&client->dev, "%s: starting up\n", __func__);
rc = gsl_ts_write(client, 0xe0, &tmp, 1);
usleep_range(10000, 20000);
return rc;
}
static int gsl_ts_reset_chip(struct i2c_client *client)
{
int rc;
u8 arg[4] = { 0x00, 0x00, 0x00, 0x00 };
dev_dbg(&client->dev, "%s: resetting\n", __func__);
arg[0] = 0x88;
rc = gsl_ts_write(client, 0xe0, arg, 1);
if (rc < 0) {
dev_err(&client->dev, "%s: gsl_ts_write 1 fail!\n", __func__);
return rc;
}
usleep_range(10000, 20000);
arg[0] = 0x04;
rc = gsl_ts_write(client, 0xe4, arg, 1);
if (rc < 0) {
dev_err(&client->dev, "%s: gsl_ts_write 2 fail!\n", __func__);
return rc;
}
usleep_range(10000, 20000);
arg[0] = 0x00;
rc = gsl_ts_write(client, 0xbc, arg, 4);
if (rc < 0) {
dev_err(&client->dev, "%s: gsl_ts_write 3 fail!\n", __func__);
return rc;
}
usleep_range(10000, 20000);
return 0;
}
static int gsl_ts_write_fw(struct gsl_ts_data *ts, const struct firmware *fw)
{
int rc = 0;
struct i2c_client *client = ts->client;
const struct gsl_ts_fw_header *header;
const struct gsl_ts_fw_page *page;
u32 pages, address;
u16 size;
size_t i;
dev_dbg(&client->dev, "%s: sending firmware\n", __func__);
header = (const struct gsl_ts_fw_header *) fw->data;
pages = le32_to_cpu(header->pages);
if (fw->size < sizeof(struct gsl_ts_fw_header) + pages * sizeof(struct gsl_ts_fw_page)) {
dev_err(&client->dev, "%s: firmware page data too small.\n", __func__);
return -EINVAL;
}
for (i = 0; rc >= 0 && i < pages; i++) {
page = (const struct gsl_ts_fw_page *) &fw->data[sizeof(struct gsl_ts_fw_header) + i * sizeof(struct gsl_ts_fw_page)];
/* The controller expects a little endian address */
address = cpu_to_le32(le16_to_cpu(page->address));
size = le16_to_cpu(page->size);
rc = gsl_ts_write(client, GSL_PAGE_REG, (u8 *) &address, sizeof(address));
if (rc < 0) {
dev_err(&client->dev, "%s: error setting page register. (page = 0x%x)\n", __func__, le32_to_cpu(address));
} else {
rc = gsl_ts_write(client, 0, page->data, size);
if (rc < 0) {
dev_err(&client->dev, "%s: error writing page data. (page = 0x%x)\n", __func__, le32_to_cpu(address));
}
}
}
if (rc < 0) {
return rc;
}
return 0;
}
static void gsl_ts_mt_event(struct gsl_ts_data *ts, u8 *buf)
{
int rc;
struct input_dev *input = ts->input;
struct device *dev = &ts->client->dev;
struct gsl_ts_packet_header *header;
struct gsl_ts_packet_touch *touch;
u8 i;
u16 touches, tseq, x, y, id, pressure;
struct input_mt_pos positions[GSL_MAX_CONTACTS];
int slots[GSL_MAX_CONTACTS];
header = (struct gsl_ts_packet_header *) buf;
touches = header->num_fingers;
tseq = le16_to_cpu(header->time_stamp);
/* time_stamp is 0 on zero-touch events, seems to wrap around 21800 */
dev_vdbg(dev, "%s: got touch events for %u fingers @%u\n", __func__, touches, tseq);
if (touches > GSL_MAX_CONTACTS) {
touches = GSL_MAX_CONTACTS;
}
for (i = 0; i < touches; i++) {
touch = (struct gsl_ts_packet_touch *) &buf[sizeof(*header) + i * sizeof(*touch)];
y = le16_to_cpu(touch->y_z);
x = le16_to_cpu(touch->x_id);
id = x >> 12;
x &= 0xfff;
pressure = y >> 12;
y &= 0xfff;
if (ts->xy_swapped) {
swap(x, y);
}
if (ts->x_reversed) {
x = ts->x_max - x;
}
if (ts->y_reversed) {
y = ts->y_max - y;
}
dev_vdbg(dev, "%s: touch event %u: x=%u y=%u id=0x%x p=%u\n", __func__, i, x, y, id, pressure);
positions[i].x = x;
positions[i].y = y;
if (!ts->soft_tracking) {
slots[i] = id;
}
}
if (ts->soft_tracking) {
/* This platform does not support finger tracking.
* Use the input core finger tracker instead.
*/
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
rc = input_mt_assign_slots(input, slots, positions, touches);
#else
rc = input_mt_assign_slots(input, slots, positions, touches, GSL_DMAX);
#endif
if (rc < 0) {
dev_err(dev, "%s: input_mt_assign_slots returned %d\n", __func__, rc);
return;
}
}
for (i = 0; i < touches; i++) {
input_mt_slot(input, slots[i]);
input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
input_report_abs(input, ABS_MT_POSITION_X, positions[i].x);
input_report_abs(input, ABS_MT_POSITION_Y, positions[i].y);
}
input_mt_sync_frame(input);
input_sync(input);
}
static irqreturn_t gsl_ts_irq(int irq, void *arg)
{
int rc;
struct gsl_ts_data *ts = (struct gsl_ts_data *) arg;
struct i2c_client *client = ts->client;
struct device *dev = &client->dev;
u8 status[4] = { 0, 0, 0, 0 };
u8 event[GSL_PACKET_SIZE];
dev_dbg(&client->dev, "%s: IRQ received\n", __func__);
if (ts->state == GSL_TS_SHUTDOWN) {
dev_warn(&client->dev, "%s: device supended, not handling interrupt\n", __func__);
return IRQ_HANDLED;
}
rc = gsl_ts_read(client, GSL_STATUS_REG, status, sizeof(status));
if (rc < 0) {
dev_err(dev, "%s: error reading chip status\n", __func__);
return IRQ_HANDLED;
}
if (status[0] == GSL_STATUS_FW) {
/* TODO: Send firmware here instead of during init */
dev_info(dev, "%s: device waiting for firmware\n", __func__);
} else if (status[0] == GSL_STATUS_TOUCH) {
dev_vdbg(dev, "%s: touch event\n", __func__);
rc = gsl_ts_read(client, GSL_DATA_REG, event, sizeof(event));
if (rc < 0) {
dev_err(dev, "%s: touch data read failed\n", __func__);
return IRQ_HANDLED;
}
if (event[0] == 0xff) {
dev_warn(dev, "%s: ignoring invalid touch record (0xff)\n", __func__);
return IRQ_HANDLED;
}
rc = gsl_ts_read(client, GSL_TOUCH_STATUS_REG, status, sizeof(status));
if (rc < 0) {
dev_err(dev, "%s: reading touch status register failed\n", __func__);
return IRQ_HANDLED;
}
if ((status[0] | status[1] | status[2] | status[3]) == 0) {
gsl_ts_mt_event(ts, event);
} else {
dev_warn(dev, "%s: device seems to be stuck, resetting\n", __func__);
rc = gsl_ts_reset_chip(ts->client);
if (rc < 0) {
dev_err(dev, "%s: reset_chip failed\n", __func__);
return IRQ_HANDLED;
}
rc = gsl_ts_startup_chip(ts->client);
if (rc < 0) {
dev_err(dev, "%s: startup_chip failed\n", __func__);
return IRQ_HANDLED;
}
}
} else {
dev_warn(&client->dev, "%s: IRQ received, unknown status 0x%02x\n", __func__, status[0]);
}
return IRQ_HANDLED;
}
static void gsl_ts_power(struct i2c_client *client, bool turnoff)
{
struct gsl_ts_data *data = i2c_get_clientdata(client);
#ifdef CONFIG_ACPI
int error;
#endif
if (data) {
if (data->gpio) {
gpiod_set_value_cansleep(data->gpio, turnoff ? 0 : 1);
#ifdef CONFIG_ACPI
} else {
error = acpi_bus_set_power(ACPI_HANDLE(&client->dev), turnoff ? ACPI_STATE_D3 : ACPI_STATE_D0);
if (error) {
dev_warn(&client->dev, "%s: error changing power state: %d\n", __func__, error);
}
#endif
}
usleep_range(20000, 50000);
}
}
static int gsl_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct gsl_ts_data *ts;
const struct firmware *fw = NULL;
unsigned long irqflags;
int error;
bool acpipower;
dev_warn(&client->dev, "%s: got a device named %s at address 0x%x, IRQ %d, flags 0x%x\n", __func__, client->name, client->addr, client->irq, client->flags);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "%s: i2c check functionality error\n", __func__);
error = -ENXIO;
goto release;
}
if (client->irq <= 0) {
dev_err(&client->dev, "%s: missing IRQ configuration\n", __func__);
error = -ENODEV;
goto release;
}
ts = devm_kzalloc(&client->dev, sizeof(struct gsl_ts_data), GFP_KERNEL);
if (!ts) {
error = -ENOMEM;
goto release;
}
ts->client = client;
i2c_set_clientdata(client, ts);
if (gsl_fw_name != NULL) {
strncpy(ts->fw_name, gsl_fw_name, sizeof(ts->fw_name));
} else {
strncpy(ts->fw_name, GSL_FW_NAME_DEFAULT, sizeof(ts->fw_name));
}
error = request_firmware(&fw, ts->fw_name, &ts->client->dev);
if (error < 0) {
dev_err(&client->dev, "%s: failed to load firmware: %d\n", __func__, error);
goto release;
}
error = gsl_ts_init(ts, fw);
if (error < 0) {
dev_err(&client->dev, "%s: failed to initialize: %d\n", __func__, error);
goto release;
}
ts->input = devm_input_allocate_device(&client->dev);
if (!ts->input) {
dev_err(&client->dev, "%s: failed to allocate input device\n", __func__);
error = -ENOMEM;
goto release;
}
ts->input->name = "Silead GSLx680 Touchscreen";
ts->input->id.bustype = BUS_I2C;
ts->input->phys = "input/ts";
input_set_capability(ts->input, EV_ABS, ABS_X);
input_set_capability(ts->input, EV_ABS, ABS_Y);
input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, ts->x_max, ts->jitter, ts->deadzone);
input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, ts->y_max, ts->jitter, ts->deadzone);
input_mt_init_slots(ts->input, ts->multi_touches, INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED | INPUT_MT_TRACK);
input_set_drvdata(ts->input, ts);
error = input_register_device(ts->input);
if (error) {
dev_err(&client->dev, "%s: unable to register input device: %d\n", __func__, error);
goto release;
}
/* Try to use ACPI power methods first */
acpipower = false;
#ifdef CONFIG_ACPI
if (ACPI_COMPANION(&client->dev)) {
/* Wake the device up with a power on reset */
if (acpi_bus_set_power(ACPI_HANDLE(&client->dev), ACPI_STATE_D3)) {
dev_warn(&client->dev, "%s: failed to wake up device through ACPI: %d, using GPIO controls instead\n", __func__, error);
} else {
acpipower = true;
}
}
#endif
/* Not available, use GPIO settings from DSDT/DT instead */
if (!acpipower) {
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)
ts->gpio = devm_gpiod_get_index(&client->dev, GSL_PWR_GPIO, 0);
#else
ts->gpio = devm_gpiod_get_index(&client->dev, GSL_PWR_GPIO, 0, GPIOD_OUT_LOW);
#endif
if (IS_ERR(ts->gpio)) {
dev_err(&client->dev, "%s: error obtaining power pin GPIO resource\n", __func__);
error = PTR_ERR(ts->gpio);
goto release;
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0)
error = gpiod_direction_output(ts->gpio, 0);
if (error < 0) {
dev_err(&client->dev, "%s: error setting GPIO pin direction\n", __func__);
goto release;
}
#endif
} else {
ts->gpio = NULL;
}
/* Enable power */
gsl_ts_power(client, false);
/* Execute the controller startup sequence */
error = gsl_ts_reset_chip(client);
if (error < 0) {
dev_err(&client->dev, "%s: chip reset failed\n", __func__);
goto release;
}
error = gsl_ts_write_fw(ts, fw);
if (error < 0) {
dev_err(&client->dev, "%s: firmware transfer failed\n", __func__);
goto release;
}
error = gsl_ts_startup_chip(client);
if (error < 0) {
dev_err(&client->dev, "%s: chip startup failed\n", __func__);
goto release;
}
/*
* Systems using device tree should set up interrupt via DTS,
* the rest will use the default falling edge interrupts.
*/
irqflags = client->dev.of_node ? 0 : IRQF_TRIGGER_FALLING;
/* Set up interrupt handler - do we still need to account for shared interrupts? */
error = devm_request_threaded_irq(
&client->dev,
client->irq,
NULL,
gsl_ts_irq,
irqflags | IRQF_ONESHOT,
client->name,
ts
);
if (error) {
dev_err(&client->dev, "%s: failed to register interrupt\n", __func__);
goto release;
}
/*
* Systems using device tree should set up wakeup via DTS,
* the rest will configure device as wakeup source by default.
*/
if (!client->dev.of_node) {
device_init_wakeup(&client->dev, true);
}
ts->state = GSL_TS_GREEN;
release:
if (fw) {
release_firmware(fw);
}
if (error < 0) {
return error;
}
return 0;
}
int gsl_ts_remove(struct i2c_client *client) {
/* Power the device off */
gsl_ts_power(client, true);
return 0;
}
static int __maybe_unused gsl_ts_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct gsl_ts_data *ts = i2c_get_clientdata(client);
dev_warn(&client->dev, "%s: suspending device\n", __func__);
disable_irq(client->irq);
gsl_ts_reset_chip(client);
usleep_range(10000, 20000);
gsl_ts_power(client, true);
if (device_may_wakeup(dev)) {
ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
}
ts->state = GSL_TS_SHUTDOWN;
return 0;
}
static int __maybe_unused gsl_ts_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct gsl_ts_data *ts = i2c_get_clientdata(client);
dev_warn(&client->dev, "%s: resuming device\n", __func__);
if (device_may_wakeup(dev) && ts->wake_irq_enabled) {
disable_irq_wake(client->irq);
}
gsl_ts_power(client, false);
gsl_ts_reset_chip(client);
gsl_ts_startup_chip(client);
enable_irq(client->irq);
ts->state = GSL_TS_GREEN;
return 0;
}
static const struct i2c_device_id gsl_ts_i2c_id[] = {
{ DEVICE_NAME, 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, gsl_ts_i2c_id);
#ifdef CONFIG_PM
static SIMPLE_DEV_PM_OPS(gsl_ts_pm_ops, gsl_ts_suspend, gsl_ts_resume);
#endif
#ifdef CONFIG_ACPI
/* GSL3680 ACPI IDs are untested */
static const struct acpi_device_id gsl_ts_acpi_match[] = {
{ "MSSL1680", 0 },
{ "MSSL3680", 0 },
{ "PNP1680", 0 },
{ "PNP3680", 0 },
{ },
};
MODULE_DEVICE_TABLE(acpi, gsl_ts_acpi_match);
#endif
#ifdef CONFIG_OF
/* These should work, but more testing is needed */
static const struct of_device_id gsl_ts_of_match[] = {
{ .compatible = "silead,gsl1680" },
{ .compatible = "silead,gsl3680" },
{ .compatible = "silead,gslx680" },
{ }
};
MODULE_DEVICE_TABLE(of, gsl_ts_of_match);
#endif
static struct i2c_driver gslx680_ts_driver = {
.probe = gsl_ts_probe,
.remove = gsl_ts_remove,
.id_table = gsl_ts_i2c_id,
.driver = {
.name = DEVICE_NAME,
.owner = THIS_MODULE,
#ifdef CONFIG_PM
.pm = &gsl_ts_pm_ops,
#endif
#ifdef CONFIG_ACPI
.acpi_match_table = ACPI_PTR(gsl_ts_acpi_match),
#endif
#ifdef CONFIG_OF
.of_match_table = of_match_ptr(gsl_ts_of_match),
#endif
},
};
module_i2c_driver(gslx680_ts_driver);
MODULE_DESCRIPTION("GSLX680 touchscreen controller driver");
MODULE_AUTHOR("Gregor Riepl <onitake@gmail.com>");
MODULE_PARM_DESC(fw_name, "firmware file name (default: " GSL_FW_NAME_DEFAULT ")");
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink