308 lines
7.0 KiB
C
308 lines
7.0 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* UCSI driver for Cypress CCGx Type-C controller
|
|
*
|
|
* Copyright (C) 2017-2018 NVIDIA Corporation. All rights reserved.
|
|
* Author: Ajay Gupta <ajayg@nvidia.com>
|
|
*
|
|
* Some code borrowed from drivers/usb/typec/ucsi/ucsi_acpi.c
|
|
*/
|
|
#include <linux/acpi.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
#include "ucsi.h"
|
|
|
|
struct ucsi_ccg {
|
|
struct device *dev;
|
|
struct ucsi *ucsi;
|
|
struct ucsi_ppm ppm;
|
|
struct i2c_client *client;
|
|
};
|
|
|
|
#define CCGX_RAB_INTR_REG 0x06
|
|
#define CCGX_RAB_UCSI_CONTROL 0x39
|
|
#define CCGX_RAB_UCSI_CONTROL_START BIT(0)
|
|
#define CCGX_RAB_UCSI_CONTROL_STOP BIT(1)
|
|
#define CCGX_RAB_UCSI_DATA_BLOCK(offset) (0xf000 | ((offset) & 0xff))
|
|
|
|
static int ccg_read(struct ucsi_ccg *uc, u16 rab, u8 *data, u32 len)
|
|
{
|
|
struct i2c_client *client = uc->client;
|
|
const struct i2c_adapter_quirks *quirks = client->adapter->quirks;
|
|
unsigned char buf[2];
|
|
struct i2c_msg msgs[] = {
|
|
{
|
|
.addr = client->addr,
|
|
.flags = 0x0,
|
|
.len = sizeof(buf),
|
|
.buf = buf,
|
|
},
|
|
{
|
|
.addr = client->addr,
|
|
.flags = I2C_M_RD,
|
|
.buf = data,
|
|
},
|
|
};
|
|
u32 rlen, rem_len = len, max_read_len = len;
|
|
int status;
|
|
|
|
/* check any max_read_len limitation on i2c adapter */
|
|
if (quirks && quirks->max_read_len)
|
|
max_read_len = quirks->max_read_len;
|
|
|
|
while (rem_len > 0) {
|
|
msgs[1].buf = &data[len - rem_len];
|
|
rlen = min_t(u16, rem_len, max_read_len);
|
|
msgs[1].len = rlen;
|
|
put_unaligned_le16(rab, buf);
|
|
status = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
|
|
if (status < 0) {
|
|
dev_err(uc->dev, "i2c_transfer failed %d\n", status);
|
|
return status;
|
|
}
|
|
rab += rlen;
|
|
rem_len -= rlen;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ccg_write(struct ucsi_ccg *uc, u16 rab, u8 *data, u32 len)
|
|
{
|
|
struct i2c_client *client = uc->client;
|
|
unsigned char *buf;
|
|
struct i2c_msg msgs[] = {
|
|
{
|
|
.addr = client->addr,
|
|
.flags = 0x0,
|
|
}
|
|
};
|
|
int status;
|
|
|
|
buf = kzalloc(len + sizeof(rab), GFP_KERNEL);
|
|
if (!buf)
|
|
return -ENOMEM;
|
|
|
|
put_unaligned_le16(rab, buf);
|
|
memcpy(buf + sizeof(rab), data, len);
|
|
|
|
msgs[0].len = len + sizeof(rab);
|
|
msgs[0].buf = buf;
|
|
|
|
status = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
|
|
if (status < 0) {
|
|
dev_err(uc->dev, "i2c_transfer failed %d\n", status);
|
|
kfree(buf);
|
|
return status;
|
|
}
|
|
|
|
kfree(buf);
|
|
return 0;
|
|
}
|
|
|
|
static int ucsi_ccg_init(struct ucsi_ccg *uc)
|
|
{
|
|
unsigned int count = 10;
|
|
u8 data;
|
|
int status;
|
|
|
|
data = CCGX_RAB_UCSI_CONTROL_STOP;
|
|
status = ccg_write(uc, CCGX_RAB_UCSI_CONTROL, &data, sizeof(data));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
data = CCGX_RAB_UCSI_CONTROL_START;
|
|
status = ccg_write(uc, CCGX_RAB_UCSI_CONTROL, &data, sizeof(data));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
/*
|
|
* Flush CCGx RESPONSE queue by acking interrupts. Above ucsi control
|
|
* register write will push response which must be cleared.
|
|
*/
|
|
do {
|
|
status = ccg_read(uc, CCGX_RAB_INTR_REG, &data, sizeof(data));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
if (!data)
|
|
return 0;
|
|
|
|
status = ccg_write(uc, CCGX_RAB_INTR_REG, &data, sizeof(data));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
usleep_range(10000, 11000);
|
|
} while (--count);
|
|
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
static int ucsi_ccg_send_data(struct ucsi_ccg *uc)
|
|
{
|
|
u8 *ppm = (u8 *)uc->ppm.data;
|
|
int status;
|
|
u16 rab;
|
|
|
|
rab = CCGX_RAB_UCSI_DATA_BLOCK(offsetof(struct ucsi_data, message_out));
|
|
status = ccg_write(uc, rab, ppm +
|
|
offsetof(struct ucsi_data, message_out),
|
|
sizeof(uc->ppm.data->message_out));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
rab = CCGX_RAB_UCSI_DATA_BLOCK(offsetof(struct ucsi_data, ctrl));
|
|
return ccg_write(uc, rab, ppm + offsetof(struct ucsi_data, ctrl),
|
|
sizeof(uc->ppm.data->ctrl));
|
|
}
|
|
|
|
static int ucsi_ccg_recv_data(struct ucsi_ccg *uc)
|
|
{
|
|
u8 *ppm = (u8 *)uc->ppm.data;
|
|
int status;
|
|
u16 rab;
|
|
|
|
rab = CCGX_RAB_UCSI_DATA_BLOCK(offsetof(struct ucsi_data, cci));
|
|
status = ccg_read(uc, rab, ppm + offsetof(struct ucsi_data, cci),
|
|
sizeof(uc->ppm.data->cci));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
rab = CCGX_RAB_UCSI_DATA_BLOCK(offsetof(struct ucsi_data, message_in));
|
|
return ccg_read(uc, rab, ppm + offsetof(struct ucsi_data, message_in),
|
|
sizeof(uc->ppm.data->message_in));
|
|
}
|
|
|
|
static int ucsi_ccg_ack_interrupt(struct ucsi_ccg *uc)
|
|
{
|
|
int status;
|
|
unsigned char data;
|
|
|
|
status = ccg_read(uc, CCGX_RAB_INTR_REG, &data, sizeof(data));
|
|
if (status < 0)
|
|
return status;
|
|
|
|
return ccg_write(uc, CCGX_RAB_INTR_REG, &data, sizeof(data));
|
|
}
|
|
|
|
static int ucsi_ccg_sync(struct ucsi_ppm *ppm)
|
|
{
|
|
struct ucsi_ccg *uc = container_of(ppm, struct ucsi_ccg, ppm);
|
|
int status;
|
|
|
|
status = ucsi_ccg_recv_data(uc);
|
|
if (status < 0)
|
|
return status;
|
|
|
|
/* ack interrupt to allow next command to run */
|
|
return ucsi_ccg_ack_interrupt(uc);
|
|
}
|
|
|
|
static int ucsi_ccg_cmd(struct ucsi_ppm *ppm, struct ucsi_control *ctrl)
|
|
{
|
|
struct ucsi_ccg *uc = container_of(ppm, struct ucsi_ccg, ppm);
|
|
|
|
ppm->data->ctrl.raw_cmd = ctrl->raw_cmd;
|
|
return ucsi_ccg_send_data(uc);
|
|
}
|
|
|
|
static irqreturn_t ccg_irq_handler(int irq, void *data)
|
|
{
|
|
struct ucsi_ccg *uc = data;
|
|
|
|
ucsi_notify(uc->ucsi);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int ucsi_ccg_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct device *dev = &client->dev;
|
|
struct ucsi_ccg *uc;
|
|
int status;
|
|
u16 rab;
|
|
|
|
uc = devm_kzalloc(dev, sizeof(*uc), GFP_KERNEL);
|
|
if (!uc)
|
|
return -ENOMEM;
|
|
|
|
uc->ppm.data = devm_kzalloc(dev, sizeof(struct ucsi_data), GFP_KERNEL);
|
|
if (!uc->ppm.data)
|
|
return -ENOMEM;
|
|
|
|
uc->ppm.cmd = ucsi_ccg_cmd;
|
|
uc->ppm.sync = ucsi_ccg_sync;
|
|
uc->dev = dev;
|
|
uc->client = client;
|
|
|
|
/* reset ccg device and initialize ucsi */
|
|
status = ucsi_ccg_init(uc);
|
|
if (status < 0) {
|
|
dev_err(uc->dev, "ucsi_ccg_init failed - %d\n", status);
|
|
return status;
|
|
}
|
|
|
|
status = devm_request_threaded_irq(dev, client->irq, NULL,
|
|
ccg_irq_handler,
|
|
IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
|
|
dev_name(dev), uc);
|
|
if (status < 0) {
|
|
dev_err(uc->dev, "request_threaded_irq failed - %d\n", status);
|
|
return status;
|
|
}
|
|
|
|
uc->ucsi = ucsi_register_ppm(dev, &uc->ppm);
|
|
if (IS_ERR(uc->ucsi)) {
|
|
dev_err(uc->dev, "ucsi_register_ppm failed\n");
|
|
return PTR_ERR(uc->ucsi);
|
|
}
|
|
|
|
rab = CCGX_RAB_UCSI_DATA_BLOCK(offsetof(struct ucsi_data, version));
|
|
status = ccg_read(uc, rab, (u8 *)(uc->ppm.data) +
|
|
offsetof(struct ucsi_data, version),
|
|
sizeof(uc->ppm.data->version));
|
|
if (status < 0) {
|
|
ucsi_unregister_ppm(uc->ucsi);
|
|
return status;
|
|
}
|
|
|
|
i2c_set_clientdata(client, uc);
|
|
return 0;
|
|
}
|
|
|
|
static int ucsi_ccg_remove(struct i2c_client *client)
|
|
{
|
|
struct ucsi_ccg *uc = i2c_get_clientdata(client);
|
|
|
|
ucsi_unregister_ppm(uc->ucsi);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct i2c_device_id ucsi_ccg_device_id[] = {
|
|
{"ccgx-ucsi", 0},
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, ucsi_ccg_device_id);
|
|
|
|
static struct i2c_driver ucsi_ccg_driver = {
|
|
.driver = {
|
|
.name = "ucsi_ccg",
|
|
},
|
|
.probe = ucsi_ccg_probe,
|
|
.remove = ucsi_ccg_remove,
|
|
.id_table = ucsi_ccg_device_id,
|
|
};
|
|
|
|
module_i2c_driver(ucsi_ccg_driver);
|
|
|
|
MODULE_AUTHOR("Ajay Gupta <ajayg@nvidia.com>");
|
|
MODULE_DESCRIPTION("UCSI driver for Cypress CCGx Type-C controller");
|
|
MODULE_LICENSE("GPL v2");
|