1
2
3
4
5
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
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
29enum 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
40struct __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
48struct __packed cp2615_iop_accessory_info {
49 __be16 part_id, option_id, proto_ver;
50};
51
52struct __packed cp2615_i2c_transfer {
53 u8 tag, i2caddr, read_len, write_len;
54 u8 data[MAX_I2C_SIZE];
55};
56
57
58enum cp2615_i2c_status {
59
60 CP2615_CFG_LOCKED = -6,
61
62 CP2615_INVALID_PARAM = -4,
63
64 CP2615_TIMEOUT,
65
66 CP2615_BUS_BUSY,
67
68 CP2615_BUS_ERROR,
69 CP2615_SUCCESS
70};
71
72struct __packed cp2615_i2c_transfer_result {
73 u8 tag, i2caddr;
74 s8 status;
75 u8 read_len;
76 u8 data[MAX_I2C_SIZE];
77};
78
79static 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 = 0x2A2A;
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
96static 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
102static 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
119 return -EPROTO;
120}
121
122
123
124static int
125cp2615_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
138static int
139cp2615_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
172static 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
208out:
209 kfree(msg);
210 return res;
211}
212
213static int
214cp2615_i2c_master_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
246static u32
247cp2615_i2c_func(struct i2c_adapter *adap)
248{
249 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
250}
251
252static const struct i2c_algorithm cp2615_i2c_algo = {
253 .master_xfer = cp2615_i2c_master_xfer,
254 .functionality = cp2615_i2c_func,
255};
256
257
258
259
260
261
262
263
264
265static 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
273static void
274cp2615_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
282static int
283cp2615_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 strncpy(adap->name, usbdev->serial, sizeof(adap->name) - 1);
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
318static const struct usb_device_id id_table[] = {
319 { USB_DEVICE_INTERFACE_NUMBER(CP2615_VID, CP2615_PID, IOP_IFN) },
320 { }
321};
322
323MODULE_DEVICE_TABLE(usb, id_table);
324
325static 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
332module_usb_driver(cp2615_i2c_driver);
333
334MODULE_AUTHOR("Bence Csókás <bence98@sch.bme.hu>");
335MODULE_DESCRIPTION("CP2615 I2C bus driver");
336MODULE_LICENSE("GPL");
337
