static int rmi_spi_probe(struct spi_device *spi)
{
struct rmi_spi_xport *rmi_spi;
struct rmi_device_platform_data *pdata;
struct rmi_device_platform_data *spi_pdata = spi->dev.platform_data;
int retval;
if (spi->master->flags & SPI_MASTER_HALF_DUPLEX)
return -EINVAL;
rmi_spi = devm_kzalloc(&spi->dev, sizeof(struct rmi_spi_xport),
GFP_KERNEL);
if (!rmi_spi)
return -ENOMEM;
pdata = &rmi_spi->xport.pdata;
if (spi->dev.of_node) {
retval = rmi_spi_of_probe(spi, pdata);
if (retval)
return retval;
} else if (spi_pdata) {
*pdata = *spi_pdata;
}
if (pdata->spi_data.bits_per_word)
spi->bits_per_word = pdata->spi_data.bits_per_word;
if (pdata->spi_data.mode)
spi->mode = pdata->spi_data.mode;
retval = spi_setup(spi);
if (retval < 0) {
dev_err(&spi->dev, "spi_setup failed!\n");
return retval;
}
if (spi->irq > 0)
rmi_spi->irq = spi->irq;
rmi_spi->spi = spi;
mutex_init(&rmi_spi->page_mutex);
rmi_spi->xport.dev = &spi->dev;
rmi_spi->xport.proto_name = "spi";
rmi_spi->xport.ops = &rmi_spi_ops;
spi_set_drvdata(spi, rmi_spi);
retval = rmi_spi_manage_pools(rmi_spi, RMI_SPI_DEFAULT_XFER_BUF_SIZE);
if (retval)
return retval;
/*
* Setting the page to zero will (a) make sure the PSR is in a
* known state, and (b) make sure we can talk to the device.
*/
retval = rmi_set_page(rmi_spi, 0);
if (retval) {
dev_err(&spi->dev, "Failed to set page select to 0.\n");
return retval;
}
retval = rmi_register_transport_device(&rmi_spi->xport);
if (retval) {
dev_err(&spi->dev, "failed to register transport.\n");
return retval;
}
retval = rmi_spi_init_irq(spi);
if (retval < 0)
return retval;
dev_info(&spi->dev, "registered RMI SPI driver\n");
return 0;
}
static int rmi_hid_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
struct rmi_transport_device *xport = NULL;
struct rmi_hid_data *data = NULL;
unsigned int connect_mask = HID_CONNECT_HIDRAW | HID_CONNECT_HIDDEV;
int ret;
dev_dbg(&hdev->dev, "%s\n", __func__);
xport = devm_kzalloc(&hdev->dev, sizeof(struct rmi_transport_device),
GFP_KERNEL);
if (!xport) {
ret = -ENOMEM;
goto err;
}
data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_hid_data),
GFP_KERNEL);
if (!data) {
ret =-ENOMEM;
goto err;
}
data->xport = xport;
xport->data = data;
xport->dev = &hdev->dev;
xport->write_block = rmi_hid_write_block;
xport->read_block = rmi_hid_read_block;
xport->info.proto_type = RMI_PROTOCOL_HID;
xport->info.proto = transport_proto_name;
xport->post_reset = rmi_hid_post_reset;
hid_set_drvdata(hdev, xport);
ret = hid_parse(hdev);
if (ret) {
hid_err(hdev, "parse failed\n");
goto err;
}
data->input_report_size =
(hdev->report_enum[HID_INPUT_REPORT]
.report_id_hash[RMI_ATTN_REPORT_ID]->size >> 3)
+ 1 /* report id */;
data->output_report_size =
(hdev->report_enum[HID_OUTPUT_REPORT]
.report_id_hash[RMI_WRITE_REPORT_ID]->size >> 3)
+ 1 /* report id */;
data->feature_report_size =
(hdev->report_enum[HID_FEATURE_REPORT]
.report_id_hash[RMI_SET_RMI_MODE_REPORT_ID]->size >> 3)
+ 1 /* report id */;
dev_dbg(&hdev->dev, "input report size %d\n", data->input_report_size);
dev_dbg(&hdev->dev, "output report size %d\n",
data->output_report_size);
dev_dbg(&hdev->dev, "feature report size %d\n",
data->feature_report_size);
data->input_queue = devm_kzalloc(&hdev->dev, data->input_report_size
* RMI_HID_INPUT_REPORT_QUEUE_LEN, GFP_KERNEL);
if (!data->input_queue) {
ret = -ENOMEM;
goto err;
}
data->writeReport = devm_kzalloc(&hdev->dev, data->output_report_size,
GFP_KERNEL);
if (!data->writeReport) {
ret = -ENOMEM;
goto err;
}
data->readReport = devm_kzalloc(&hdev->dev, data->input_report_size,
GFP_KERNEL);
if (!data->readReport) {
ret = -ENOMEM;
goto err;
}
data->attnReport = devm_kzalloc(&hdev->dev, data->input_report_size,
GFP_KERNEL);
if (!data->attnReport) {
ret = -ENOMEM;
goto err;
}
tp_platformdata.pm_data = hdev;
xport->dev->platform_data = &tp_platformdata;
#ifdef TOUCHPAD_WAKE_SYSTEM
if (tp_platformdata.f11_sensor_data[0].sensor_type == rmi_sensor_touchpad) {
device_init_wakeup(hdev->dev.parent, 1);
}
#endif
spin_lock_init(&data->input_queue_consumer_lock);
spin_lock_init(&data->input_queue_producer_lock);
data->input_queue_head = 0;
data->input_queue_tail = 0;
INIT_WORK(&data->attn_report_work, rmi_hid_attn_report_work);
INIT_WORK(&data->reset_work, rmi_hid_reset_work);
init_waitqueue_head(&data->wait);
mutex_init(&data->page_mutex);
ret = hid_hw_start(hdev, connect_mask);
if (ret) {
hid_err(hdev, "hw start failed\n");
goto err;
}
dev_dbg(&hdev->dev, "Opening low level driver\n");
hdev->ll_driver->open(hdev);
/* Allow incoming hid reports */
hid_device_io_start(hdev);
ret = rmi_hid_set_mode(hdev, RMI_HID_MODE_ATTN_REPORTS);
if (ret < 0) {
dev_err(&hdev->dev, "failed to set rmi mode\n");
goto rmi_read_failed;
}
ret = rmi_set_page(xport, 0);
if (ret < 0) {
dev_err(&hdev->dev, "failed to set page select to 0.\n");
goto rmi_read_failed;
}
ret = rmi_register_transport_device(xport);
if (ret) {
dev_err(&hdev->dev, "failed to register transport device at %s\n",
hdev->phys);
goto rmi_read_failed;
}
if (!xport->probe_succeeded) {
dev_err(&hdev->dev, "Probe failed in rmi_driver\n");
ret = -ENODEV;
goto rmi_driver_probe_failed;
}
set_bit(RMI_HID_STARTED, &data->flags);
if (IS_ENABLED(CONFIG_RMI4_DEBUG))
ret = setup_debugfs(xport->rmi_dev, data);
dev_info(&hdev->dev, "registered rmi hid driver at %s\n", hdev->phys);
return 0;
rmi_driver_probe_failed:
rmi_unregister_transport_device(xport);
rmi_read_failed:
hdev->ll_driver->close(hdev);
hid_hw_stop(hdev);
err:
return ret;
}
static int rmi_smb_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct rmi_device_platform_data *pdata = dev_get_platdata(&client->dev);
struct rmi_smb_xport *rmi_smb;
int retval;
int smbus_version;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_READ_BLOCK_DATA |
I2C_FUNC_SMBUS_HOST_NOTIFY)) {
dev_err(&client->dev,
"adapter does not support required functionality.\n");
return -ENODEV;
}
if (client->irq <= 0) {
dev_err(&client->dev, "no IRQ provided, giving up.\n");
return client->irq ? client->irq : -ENODEV;
}
rmi_smb = devm_kzalloc(&client->dev, sizeof(struct rmi_smb_xport),
GFP_KERNEL);
if (!rmi_smb)
return -ENOMEM;
if (!pdata) {
dev_err(&client->dev, "no platform data, aborting\n");
return -ENOMEM;
}
rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s.\n",
dev_name(&client->dev));
rmi_smb->client = client;
mutex_init(&rmi_smb->page_mutex);
mutex_init(&rmi_smb->mappingtable_mutex);
rmi_smb->xport.dev = &client->dev;
rmi_smb->xport.pdata = *pdata;
rmi_smb->xport.pdata.irq = client->irq;
rmi_smb->xport.proto_name = "smb2";
rmi_smb->xport.ops = &rmi_smb_ops;
retval = rmi_smb_get_version(rmi_smb);
if (retval < 0)
return retval;
smbus_version = retval;
rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Smbus version is %d",
smbus_version);
if (smbus_version != 2) {
dev_err(&client->dev, "Unrecognized SMB version %d.\n",
smbus_version);
return -ENODEV;
}
i2c_set_clientdata(client, rmi_smb);
retval = rmi_register_transport_device(&rmi_smb->xport);
if (retval) {
dev_err(&client->dev, "Failed to register transport driver at 0x%.2X.\n",
client->addr);
i2c_set_clientdata(client, NULL);
return retval;
}
dev_info(&client->dev, "registered rmi smb driver at %#04x.\n",
client->addr);
return 0;
}
