drivers/i2c/busses/i2c-cp2615.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * i2c support for Silicon Labs' CP2615 Digital Audio Bridge
   4  *
   5  * (c) 2021, Bence Csókás <bence98@sch.bme.hu>
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/i2c.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/string.h>
  13 #include <linux/usb.h>
  14
  15 /** CP2615 I/O Protocol implementation */
  16
  17 #define CP2615_VID 0x10c4
  18 #define CP2615_PID 0xeac1
  19
  20 #define IOP_EP_IN  0x82
  21 #define IOP_EP_OUT 0x02
  22 #define IOP_IFN 1
  23 #define IOP_ALTSETTING 2
  24
  25 #define MAX_IOP_SIZE 64
  26 #define MAX_IOP_PAYLOAD_SIZE (MAX_IOP_SIZE - 6)
  27 #define MAX_I2C_SIZE (MAX_IOP_PAYLOAD_SIZE - 4)
  28
  29 enum cp2615_iop_msg_type {
  30         iop_GetAccessoryInfo = 0xD100,
  31         iop_AccessoryInfo = 0xA100,
  32         iop_GetPortConfiguration = 0xD203,
  33         iop_PortConfiguration = 0xA203,
  34         iop_DoI2cTransfer = 0xD400,
  35         iop_I2cTransferResult = 0xA400,
  36         iop_GetSerialState = 0xD501,
  37         iop_SerialState = 0xA501
  38 };
  39
  40 struct __packed cp2615_iop_msg {
  41         __be16 preamble, length, msg;
  42         u8 data[MAX_IOP_PAYLOAD_SIZE];
  43 };
  44
  45 #define PART_ID_A01 0x1400
  46 #define PART_ID_A02 0x1500
  47
  48 struct __packed cp2615_iop_accessory_info {
  49         __be16 part_id, option_id, proto_ver;
  50 };
  51
  52 struct __packed cp2615_i2c_transfer {
  53         u8 tag, i2caddr, read_len, write_len;
  54         u8 data[MAX_I2C_SIZE];
  55 };
  56
  57 /* Possible values for struct cp2615_i2c_transfer_result.status */
  58 enum cp2615_i2c_status {
  59         /* Writing to the internal EEPROM failed, because it is locked */
  60         CP2615_CFG_LOCKED = -6,
  61         /* read_len or write_len out of range */
  62         CP2615_INVALID_PARAM = -4,
  63         /* I2C target did not ACK in time */
  64         CP2615_TIMEOUT,
  65         /* I2C bus busy */
  66         CP2615_BUS_BUSY,
  67         /* I2C bus error (ie. target NAK'd the request) */
  68         CP2615_BUS_ERROR,
  69         CP2615_SUCCESS
  70 };
  71
  72 struct __packed cp2615_i2c_transfer_result {
  73         u8 tag, i2caddr;
  74         s8 status;
  75         u8 read_len;
  76         u8 data[MAX_I2C_SIZE];
  77 };
  78
  79 static int cp2615_init_iop_msg(struct cp2615_iop_msg *ret, enum cp2615_iop_msg_type msg,
  80                         const void *data, size_t data_len)
  81 {
  82         if (data_len > MAX_IOP_PAYLOAD_SIZE)
  83                 return -EFBIG;
  84
  85         if (!ret)
  86                 return -EINVAL;
  87
  88         ret->preamble = htons(0x2A2AU);
  89         ret->length = htons(data_len + 6);
  90         ret->msg = htons(msg);
  91         if (data && data_len)
  92                 memcpy(&ret->data, data, data_len);
  93         return 0;
  94 }
  95
  96 static int cp2615_init_i2c_msg(struct cp2615_iop_msg *ret, const struct cp2615_i2c_transfer *data)
  97 {
  98         return cp2615_init_iop_msg(ret, iop_DoI2cTransfer, data, 4 + data->write_len);
  99 }
 100
 101 /* Translates status codes to Linux errno's */
 102 static int cp2615_check_status(enum cp2615_i2c_status status)
 103 {
 104         switch (status) {
 105         case CP2615_SUCCESS:
 106                         return 0;
 107         case CP2615_BUS_ERROR:
 108                 return -ENXIO;
 109         case CP2615_BUS_BUSY:
 110                 return -EAGAIN;
 111         case CP2615_TIMEOUT:
 112                 return -ETIMEDOUT;
 113         case CP2615_INVALID_PARAM:
 114                 return -EINVAL;
 115         case CP2615_CFG_LOCKED:
 116                 return -EPERM;
 117         }
 118         /* Unknown error code */
 119         return -EPROTO;
 120 }
 121
 122 /** Driver code */
 123
 124 static int
 125 cp2615_i2c_send(struct usb_interface *usbif, struct cp2615_i2c_transfer *i2c_w)
 126 {
 127         struct cp2615_iop_msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL);
 128         struct usb_device *usbdev = interface_to_usbdev(usbif);
 129         int res = cp2615_init_i2c_msg(msg, i2c_w);
 130
 131         if (!res)
 132                 res = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, IOP_EP_OUT),
 133                                    msg, ntohs(msg->length), NULL, 0);
 134         kfree(msg);
 135         return res;
 136 }
 137
 138 static int
 139 cp2615_i2c_recv(struct usb_interface *usbif, unsigned char tag, void *buf)
 140 {
 141         struct usb_device *usbdev = interface_to_usbdev(usbif);
 142         struct cp2615_iop_msg *msg;
 143         struct cp2615_i2c_transfer_result *i2c_r;
 144         int res;
 145
 146         msg = kzalloc(sizeof(*msg), GFP_KERNEL);
 147         if (!msg)
 148                 return -ENOMEM;
 149
 150         res = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, IOP_EP_IN), msg,
 151                            sizeof(struct cp2615_iop_msg), NULL, 0);
 152         if (res < 0) {
 153                 kfree(msg);
 154                 return res;
 155         }
 156
 157         i2c_r = (struct cp2615_i2c_transfer_result *)&msg->data;
 158         if (msg->msg != htons(iop_I2cTransferResult) || i2c_r->tag != tag) {
 159                 kfree(msg);
 160                 return -EIO;
 161         }
 162
 163         res = cp2615_check_status(i2c_r->status);
 164         if (!res)
 165                 memcpy(buf, &i2c_r->data, i2c_r->read_len);
 166
 167         kfree(msg);
 168         return res;
 169 }
 170
 171 /* Checks if the IOP is functional by querying the part's ID */
 172 static int cp2615_check_iop(struct usb_interface *usbif)
 173 {
 174         struct cp2615_iop_msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL);
 175         struct cp2615_iop_accessory_info *info = (struct cp2615_iop_accessory_info *)&msg->data;
 176         struct usb_device *usbdev = interface_to_usbdev(usbif);
 177         int res = cp2615_init_iop_msg(msg, iop_GetAccessoryInfo, NULL, 0);
 178
 179         if (res)
 180                 goto out;
 181
 182         res = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, IOP_EP_OUT),
 183                                    msg, ntohs(msg->length), NULL, 0);
 184         if (res)
 185                 goto out;
 186
 187         res = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, IOP_EP_IN),
 188                                msg, sizeof(struct cp2615_iop_msg), NULL, 0);
 189         if (res)
 190                 goto out;
 191
 192         if (msg->msg != htons(iop_AccessoryInfo)) {
 193                 res = -EIO;
 194                 goto out;
 195         }
 196
 197         switch (ntohs(info->part_id)) {
 198         case PART_ID_A01:
 199                 dev_dbg(&usbif->dev, "Found A01 part. (WARNING: errata exists!)\n");
 200                 break;
 201         case PART_ID_A02:
 202                 dev_dbg(&usbif->dev, "Found good A02 part.\n");
 203                 break;
 204         default:
 205                 dev_warn(&usbif->dev, "Unknown part ID %04X\n", ntohs(info->part_id));
 206         }
 207
 208 out:
 209         kfree(msg);
 210         return res;
 211 }
 212
 213 static int
 214 cp2615_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 215 {
 216         struct usb_interface *usbif = adap->algo_data;
 217         int i = 0, ret = 0;
 218         struct i2c_msg *msg;
 219         struct cp2615_i2c_transfer i2c_w = {0};
 220
 221         dev_dbg(&usbif->dev, "Doing %d I2C transactions\n", num);
 222
 223         for (; !ret && i < num; i++) {
 224                 msg = &msgs[i];
 225
 226                 i2c_w.tag = 0xdd;
 227                 i2c_w.i2caddr = i2c_8bit_addr_from_msg(msg);
 228                 if (msg->flags & I2C_M_RD) {
 229                         i2c_w.read_len = msg->len;
 230                         i2c_w.write_len = 0;
 231                 } else {
 232                         i2c_w.read_len = 0;
 233                         i2c_w.write_len = msg->len;
 234                         memcpy(&i2c_w.data, msg->buf, i2c_w.write_len);
 235                 }
 236                 ret = cp2615_i2c_send(usbif, &i2c_w);
 237                 if (ret)
 238                         break;
 239                 ret = cp2615_i2c_recv(usbif, i2c_w.tag, msg->buf);
 240         }
 241         if (ret < 0)
 242                 return ret;
 243         return i;
 244 }
 245
 246 static u32
 247 cp2615_i2c_func(struct i2c_adapter *adap)
 248 {
 249         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 250 }
 251
 252 static const struct i2c_algorithm cp2615_i2c_algo = {
 253         .xfer = cp2615_i2c_xfer,
 254         .functionality = cp2615_i2c_func,
 255 };
 256
 257 /*
 258  * This chip has some limitations: one is that the USB endpoint
 259  * can only receive 64 bytes/transfer, that leaves 54 bytes for
 260  * the I2C transfer. On top of that, EITHER read_len OR write_len
 261  * may be zero, but not both. If both are non-zero, the adapter
 262  * issues a write followed by a read. And the chip does not
 263  * support repeated START between the write and read phases.
 264  */
 265 static struct i2c_adapter_quirks cp2615_i2c_quirks = {
 266         .max_write_len = MAX_I2C_SIZE,
 267         .max_read_len = MAX_I2C_SIZE,
 268         .flags = I2C_AQ_COMB_WRITE_THEN_READ | I2C_AQ_NO_ZERO_LEN | I2C_AQ_NO_REP_START,
 269         .max_comb_1st_msg_len = MAX_I2C_SIZE,
 270         .max_comb_2nd_msg_len = MAX_I2C_SIZE
 271 };
 272
 273 static void
 274 cp2615_i2c_remove(struct usb_interface *usbif)
 275 {
 276         struct i2c_adapter *adap = usb_get_intfdata(usbif);
 277
 278         usb_set_intfdata(usbif, NULL);
 279         i2c_del_adapter(adap);
 280 }
 281
 282 static int
 283 cp2615_i2c_probe(struct usb_interface *usbif, const struct usb_device_id *id)
 284 {
 285         int ret = 0;
 286         struct i2c_adapter *adap;
 287         struct usb_device *usbdev = interface_to_usbdev(usbif);
 288
 289         ret = usb_set_interface(usbdev, IOP_IFN, IOP_ALTSETTING);
 290         if (ret)
 291                 return ret;
 292
 293         ret = cp2615_check_iop(usbif);
 294         if (ret)
 295                 return ret;
 296
 297         adap = devm_kzalloc(&usbif->dev, sizeof(struct i2c_adapter), GFP_KERNEL);
 298         if (!adap)
 299                 return -ENOMEM;
 300
 301         strscpy(adap->name, usbdev->serial, sizeof(adap->name));
 302         adap->owner = THIS_MODULE;
 303         adap->dev.parent = &usbif->dev;
 304         adap->dev.of_node = usbif->dev.of_node;
 305         adap->timeout = HZ;
 306         adap->algo = &cp2615_i2c_algo;
 307         adap->quirks = &cp2615_i2c_quirks;
 308         adap->algo_data = usbif;
 309
 310         ret = i2c_add_adapter(adap);
 311         if (ret)
 312                 return ret;
 313
 314         usb_set_intfdata(usbif, adap);
 315         return 0;
 316 }
 317
 318 static const struct usb_device_id id_table[] = {
 319         { USB_DEVICE_INTERFACE_NUMBER(CP2615_VID, CP2615_PID, IOP_IFN) },
 320         { }
 321 };
 322
 323 MODULE_DEVICE_TABLE(usb, id_table);
 324
 325 static struct usb_driver cp2615_i2c_driver = {
 326         .name = "i2c-cp2615",
 327         .probe = cp2615_i2c_probe,
 328         .disconnect = cp2615_i2c_remove,
 329         .id_table = id_table,
 330 };
 331
 332 module_usb_driver(cp2615_i2c_driver);
 333
 334 MODULE_AUTHOR("Bence Csókás <bence98@sch.bme.hu>");
 335 MODULE_DESCRIPTION("CP2615 I2C bus driver");
 336 MODULE_LICENSE("GPL");