1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Nano River Technologies viperboard i2c controller driver 4 * 5 * (C) 2012 by Lemonage GmbH 6 * Author: Lars Poeschel <poeschel@lemonage.de> 7 * All rights reserved. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/errno.h> 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/string_choices.h> 15 #include <linux/types.h> 16 #include <linux/mutex.h> 17 #include <linux/platform_device.h> 18 19 #include <linux/usb.h> 20 #include <linux/i2c.h> 21 22 #include <linux/mfd/viperboard.h> 23 24 struct vprbrd_i2c { 25 struct i2c_adapter i2c; 26 u8 bus_freq_param; 27 }; 28 29 /* i2c bus frequency module parameter */ 30 static u8 i2c_bus_param; 31 static unsigned int i2c_bus_freq = 100; 32 module_param(i2c_bus_freq, int, 0); 33 MODULE_PARM_DESC(i2c_bus_freq, 34 "i2c bus frequency in khz (default is 100) valid values: 10, 100, 200, 400, 1000, 3000, 6000"); 35 36 static int vprbrd_i2c_status(struct i2c_adapter *i2c, 37 struct vprbrd_i2c_status *status, bool prev_error) 38 { 39 u16 bytes_xfer; 40 int ret; 41 struct vprbrd *vb = (struct vprbrd *)i2c->algo_data; 42 43 /* check for protocol error */ 44 bytes_xfer = sizeof(struct vprbrd_i2c_status); 45 46 ret = usb_control_msg(vb->usb_dev, usb_rcvctrlpipe(vb->usb_dev, 0), 47 VPRBRD_USB_REQUEST_I2C, VPRBRD_USB_TYPE_IN, 0x0000, 0x0000, 48 status, bytes_xfer, VPRBRD_USB_TIMEOUT_MS); 49 50 if (ret != bytes_xfer) 51 prev_error = true; 52 53 if (prev_error) { 54 dev_err(&i2c->dev, "failure in usb communication\n"); 55 return -EREMOTEIO; 56 } 57 58 dev_dbg(&i2c->dev, " status = %d\n", status->status); 59 if (status->status != 0x00) { 60 dev_err(&i2c->dev, "failure: i2c protocol error\n"); 61 return -EPROTO; 62 } 63 return 0; 64 } 65 66 static int vprbrd_i2c_receive(struct usb_device *usb_dev, 67 struct vprbrd_i2c_read_msg *rmsg, int bytes_xfer) 68 { 69 int ret, bytes_actual; 70 int error = 0; 71 72 /* send the read request */ 73 ret = usb_bulk_msg(usb_dev, 74 usb_sndbulkpipe(usb_dev, VPRBRD_EP_OUT), rmsg, 75 sizeof(struct vprbrd_i2c_read_hdr), &bytes_actual, 76 VPRBRD_USB_TIMEOUT_MS); 77 78 if ((ret < 0) 79 || (bytes_actual != sizeof(struct vprbrd_i2c_read_hdr))) { 80 dev_err(&usb_dev->dev, "failure transmitting usb\n"); 81 error = -EREMOTEIO; 82 } 83 84 /* read the actual data */ 85 ret = usb_bulk_msg(usb_dev, 86 usb_rcvbulkpipe(usb_dev, VPRBRD_EP_IN), rmsg, 87 bytes_xfer, &bytes_actual, VPRBRD_USB_TIMEOUT_MS); 88 89 if ((ret < 0) || (bytes_xfer != bytes_actual)) { 90 dev_err(&usb_dev->dev, "failure receiving usb\n"); 91 error = -EREMOTEIO; 92 } 93 return error; 94 } 95 96 static int vprbrd_i2c_addr(struct usb_device *usb_dev, 97 struct vprbrd_i2c_addr_msg *amsg) 98 { 99 int ret, bytes_actual; 100 101 ret = usb_bulk_msg(usb_dev, 102 usb_sndbulkpipe(usb_dev, VPRBRD_EP_OUT), amsg, 103 sizeof(struct vprbrd_i2c_addr_msg), &bytes_actual, 104 VPRBRD_USB_TIMEOUT_MS); 105 106 if ((ret < 0) || 107 (sizeof(struct vprbrd_i2c_addr_msg) != bytes_actual)) { 108 dev_err(&usb_dev->dev, "failure transmitting usb\n"); 109 return -EREMOTEIO; 110 } 111 return 0; 112 } 113 114 static int vprbrd_i2c_read(struct vprbrd *vb, struct i2c_msg *msg) 115 { 116 int ret; 117 u16 remain_len, len1, len2, start = 0x0000; 118 struct vprbrd_i2c_read_msg *rmsg = 119 (struct vprbrd_i2c_read_msg *)vb->buf; 120 121 remain_len = msg->len; 122 rmsg->header.cmd = VPRBRD_I2C_CMD_READ; 123 while (remain_len > 0) { 124 rmsg->header.addr = cpu_to_le16(start + 0x4000); 125 if (remain_len <= 255) { 126 len1 = remain_len; 127 len2 = 0x00; 128 rmsg->header.len0 = remain_len; 129 rmsg->header.len1 = 0x00; 130 rmsg->header.len2 = 0x00; 131 rmsg->header.len3 = 0x00; 132 rmsg->header.len4 = 0x00; 133 rmsg->header.len5 = 0x00; 134 remain_len = 0; 135 } else if (remain_len <= 510) { 136 len1 = remain_len; 137 len2 = 0x00; 138 rmsg->header.len0 = remain_len - 255; 139 rmsg->header.len1 = 0xff; 140 rmsg->header.len2 = 0x00; 141 rmsg->header.len3 = 0x00; 142 rmsg->header.len4 = 0x00; 143 rmsg->header.len5 = 0x00; 144 remain_len = 0; 145 } else if (remain_len <= 512) { 146 len1 = remain_len; 147 len2 = 0x00; 148 rmsg->header.len0 = remain_len - 510; 149 rmsg->header.len1 = 0xff; 150 rmsg->header.len2 = 0xff; 151 rmsg->header.len3 = 0x00; 152 rmsg->header.len4 = 0x00; 153 rmsg->header.len5 = 0x00; 154 remain_len = 0; 155 } else if (remain_len <= 767) { 156 len1 = 512; 157 len2 = remain_len - 512; 158 rmsg->header.len0 = 0x02; 159 rmsg->header.len1 = 0xff; 160 rmsg->header.len2 = 0xff; 161 rmsg->header.len3 = remain_len - 512; 162 rmsg->header.len4 = 0x00; 163 rmsg->header.len5 = 0x00; 164 remain_len = 0; 165 } else if (remain_len <= 1022) { 166 len1 = 512; 167 len2 = remain_len - 512; 168 rmsg->header.len0 = 0x02; 169 rmsg->header.len1 = 0xff; 170 rmsg->header.len2 = 0xff; 171 rmsg->header.len3 = remain_len - 767; 172 rmsg->header.len4 = 0xff; 173 rmsg->header.len5 = 0x00; 174 remain_len = 0; 175 } else if (remain_len <= 1024) { 176 len1 = 512; 177 len2 = remain_len - 512; 178 rmsg->header.len0 = 0x02; 179 rmsg->header.len1 = 0xff; 180 rmsg->header.len2 = 0xff; 181 rmsg->header.len3 = remain_len - 1022; 182 rmsg->header.len4 = 0xff; 183 rmsg->header.len5 = 0xff; 184 remain_len = 0; 185 } else { 186 len1 = 512; 187 len2 = 512; 188 rmsg->header.len0 = 0x02; 189 rmsg->header.len1 = 0xff; 190 rmsg->header.len2 = 0xff; 191 rmsg->header.len3 = 0x02; 192 rmsg->header.len4 = 0xff; 193 rmsg->header.len5 = 0xff; 194 remain_len -= 1024; 195 start += 1024; 196 } 197 rmsg->header.tf1 = cpu_to_le16(len1); 198 rmsg->header.tf2 = cpu_to_le16(len2); 199 200 /* first read transfer */ 201 ret = vprbrd_i2c_receive(vb->usb_dev, rmsg, len1); 202 if (ret < 0) 203 return ret; 204 /* copy the received data */ 205 memcpy(msg->buf + start, rmsg, len1); 206 207 /* second read transfer if neccessary */ 208 if (len2 > 0) { 209 ret = vprbrd_i2c_receive(vb->usb_dev, rmsg, len2); 210 if (ret < 0) 211 return ret; 212 /* copy the received data */ 213 memcpy(msg->buf + start + 512, rmsg, len2); 214 } 215 } 216 return 0; 217 } 218 219 static int vprbrd_i2c_write(struct vprbrd *vb, struct i2c_msg *msg) 220 { 221 int ret, bytes_actual; 222 u16 remain_len, bytes_xfer, 223 start = 0x0000; 224 struct vprbrd_i2c_write_msg *wmsg = 225 (struct vprbrd_i2c_write_msg *)vb->buf; 226 227 remain_len = msg->len; 228 wmsg->header.cmd = VPRBRD_I2C_CMD_WRITE; 229 wmsg->header.last = 0x00; 230 wmsg->header.chan = 0x00; 231 wmsg->header.spi = 0x0000; 232 while (remain_len > 0) { 233 wmsg->header.addr = cpu_to_le16(start + 0x4000); 234 if (remain_len > 503) { 235 wmsg->header.len1 = 0xff; 236 wmsg->header.len2 = 0xf8; 237 remain_len -= 503; 238 bytes_xfer = 503 + sizeof(struct vprbrd_i2c_write_hdr); 239 start += 503; 240 } else if (remain_len > 255) { 241 wmsg->header.len1 = 0xff; 242 wmsg->header.len2 = (remain_len - 255); 243 bytes_xfer = remain_len + 244 sizeof(struct vprbrd_i2c_write_hdr); 245 remain_len = 0; 246 } else { 247 wmsg->header.len1 = remain_len; 248 wmsg->header.len2 = 0x00; 249 bytes_xfer = remain_len + 250 sizeof(struct vprbrd_i2c_write_hdr); 251 remain_len = 0; 252 } 253 memcpy(wmsg->data, msg->buf + start, 254 bytes_xfer - sizeof(struct vprbrd_i2c_write_hdr)); 255 256 ret = usb_bulk_msg(vb->usb_dev, 257 usb_sndbulkpipe(vb->usb_dev, 258 VPRBRD_EP_OUT), wmsg, 259 bytes_xfer, &bytes_actual, VPRBRD_USB_TIMEOUT_MS); 260 if ((ret < 0) || (bytes_xfer != bytes_actual)) 261 return -EREMOTEIO; 262 } 263 return 0; 264 } 265 266 static int vprbrd_i2c_xfer(struct i2c_adapter *i2c, struct i2c_msg *msgs, 267 int num) 268 { 269 struct i2c_msg *pmsg; 270 int i, ret, 271 error = 0; 272 struct vprbrd *vb = (struct vprbrd *)i2c->algo_data; 273 struct vprbrd_i2c_addr_msg *amsg = 274 (struct vprbrd_i2c_addr_msg *)vb->buf; 275 struct vprbrd_i2c_status *smsg = (struct vprbrd_i2c_status *)vb->buf; 276 277 for (i = 0 ; i < num ; i++) { 278 pmsg = &msgs[i]; 279 280 dev_dbg(&i2c->dev, 281 " %d: %s (flags %d) %d bytes to 0x%02x\n", 282 i, str_read_write(pmsg->flags & I2C_M_RD), 283 pmsg->flags, pmsg->len, pmsg->addr); 284 285 mutex_lock(&vb->lock); 286 /* directly send the message */ 287 if (pmsg->flags & I2C_M_RD) { 288 /* read data */ 289 amsg->cmd = VPRBRD_I2C_CMD_ADDR; 290 amsg->unknown2 = 0x00; 291 amsg->unknown3 = 0x00; 292 amsg->addr = pmsg->addr; 293 amsg->unknown1 = 0x01; 294 amsg->len = cpu_to_le16(pmsg->len); 295 /* send the addr and len, we're interested to board */ 296 ret = vprbrd_i2c_addr(vb->usb_dev, amsg); 297 if (ret < 0) 298 error = ret; 299 300 ret = vprbrd_i2c_read(vb, pmsg); 301 if (ret < 0) 302 error = ret; 303 304 ret = vprbrd_i2c_status(i2c, smsg, error); 305 if (ret < 0) 306 error = ret; 307 /* in case of protocol error, return the error */ 308 if (error < 0) 309 goto error; 310 } else { 311 /* write data */ 312 ret = vprbrd_i2c_write(vb, pmsg); 313 314 amsg->cmd = VPRBRD_I2C_CMD_ADDR; 315 amsg->unknown2 = 0x00; 316 amsg->unknown3 = 0x00; 317 amsg->addr = pmsg->addr; 318 amsg->unknown1 = 0x00; 319 amsg->len = cpu_to_le16(pmsg->len); 320 /* send the addr, the data goes to to board */ 321 ret = vprbrd_i2c_addr(vb->usb_dev, amsg); 322 if (ret < 0) 323 error = ret; 324 325 ret = vprbrd_i2c_status(i2c, smsg, error); 326 if (ret < 0) 327 error = ret; 328 329 if (error < 0) 330 goto error; 331 } 332 mutex_unlock(&vb->lock); 333 } 334 return num; 335 error: 336 mutex_unlock(&vb->lock); 337 return error; 338 } 339 340 static u32 vprbrd_i2c_func(struct i2c_adapter *i2c) 341 { 342 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 343 } 344 345 /* This is the actual algorithm we define */ 346 static const struct i2c_algorithm vprbrd_algorithm = { 347 .xfer = vprbrd_i2c_xfer, 348 .functionality = vprbrd_i2c_func, 349 }; 350 351 static const struct i2c_adapter_quirks vprbrd_quirks = { 352 .max_read_len = 2048, 353 .max_write_len = 2048, 354 }; 355 356 static int vprbrd_i2c_probe(struct platform_device *pdev) 357 { 358 struct vprbrd *vb = dev_get_drvdata(pdev->dev.parent); 359 struct vprbrd_i2c *vb_i2c; 360 int ret; 361 int pipe; 362 363 vb_i2c = devm_kzalloc(&pdev->dev, sizeof(*vb_i2c), GFP_KERNEL); 364 if (vb_i2c == NULL) 365 return -ENOMEM; 366 367 /* setup i2c adapter description */ 368 vb_i2c->i2c.owner = THIS_MODULE; 369 vb_i2c->i2c.class = I2C_CLASS_HWMON; 370 vb_i2c->i2c.algo = &vprbrd_algorithm; 371 vb_i2c->i2c.quirks = &vprbrd_quirks; 372 vb_i2c->i2c.algo_data = vb; 373 /* save the param in usb capabable memory */ 374 vb_i2c->bus_freq_param = i2c_bus_param; 375 376 snprintf(vb_i2c->i2c.name, sizeof(vb_i2c->i2c.name), 377 "viperboard at bus %03d device %03d", 378 vb->usb_dev->bus->busnum, vb->usb_dev->devnum); 379 380 /* setting the bus frequency */ 381 if ((i2c_bus_param <= VPRBRD_I2C_FREQ_10KHZ) 382 && (i2c_bus_param >= VPRBRD_I2C_FREQ_6MHZ)) { 383 pipe = usb_sndctrlpipe(vb->usb_dev, 0); 384 ret = usb_control_msg(vb->usb_dev, pipe, 385 VPRBRD_USB_REQUEST_I2C_FREQ, VPRBRD_USB_TYPE_OUT, 386 0x0000, 0x0000, &vb_i2c->bus_freq_param, 1, 387 VPRBRD_USB_TIMEOUT_MS); 388 if (ret != 1) 389 return dev_err_probe(&pdev->dev, -EIO, 390 "failure setting i2c_bus_freq to %d\n", 391 i2c_bus_freq); 392 } else { 393 return dev_err_probe(&pdev->dev, -EIO, 394 "invalid i2c_bus_freq setting:%d\n", i2c_bus_freq); 395 } 396 397 vb_i2c->i2c.dev.parent = &pdev->dev; 398 399 /* attach to i2c layer */ 400 i2c_add_adapter(&vb_i2c->i2c); 401 402 platform_set_drvdata(pdev, vb_i2c); 403 404 return 0; 405 } 406 407 static void vprbrd_i2c_remove(struct platform_device *pdev) 408 { 409 struct vprbrd_i2c *vb_i2c = platform_get_drvdata(pdev); 410 411 i2c_del_adapter(&vb_i2c->i2c); 412 } 413 414 static struct platform_driver vprbrd_i2c_driver = { 415 .driver.name = "viperboard-i2c", 416 .probe = vprbrd_i2c_probe, 417 .remove = vprbrd_i2c_remove, 418 }; 419 420 static int __init vprbrd_i2c_init(void) 421 { 422 switch (i2c_bus_freq) { 423 case 6000: 424 i2c_bus_param = VPRBRD_I2C_FREQ_6MHZ; 425 break; 426 case 3000: 427 i2c_bus_param = VPRBRD_I2C_FREQ_3MHZ; 428 break; 429 case 1000: 430 i2c_bus_param = VPRBRD_I2C_FREQ_1MHZ; 431 break; 432 case 400: 433 i2c_bus_param = VPRBRD_I2C_FREQ_400KHZ; 434 break; 435 case 200: 436 i2c_bus_param = VPRBRD_I2C_FREQ_200KHZ; 437 break; 438 case 100: 439 i2c_bus_param = VPRBRD_I2C_FREQ_100KHZ; 440 break; 441 case 10: 442 i2c_bus_param = VPRBRD_I2C_FREQ_10KHZ; 443 break; 444 default: 445 pr_warn("invalid i2c_bus_freq (%d)\n", i2c_bus_freq); 446 i2c_bus_param = VPRBRD_I2C_FREQ_100KHZ; 447 } 448 449 return platform_driver_register(&vprbrd_i2c_driver); 450 } 451 subsys_initcall(vprbrd_i2c_init); 452 453 static void __exit vprbrd_i2c_exit(void) 454 { 455 platform_driver_unregister(&vprbrd_i2c_driver); 456 } 457 module_exit(vprbrd_i2c_exit); 458 459 MODULE_AUTHOR("Lars Poeschel <poeschel@lemonage.de>"); 460 MODULE_DESCRIPTION("I2C controller driver for Nano River Techs Viperboard"); 461 MODULE_LICENSE("GPL"); 462 MODULE_ALIAS("platform:viperboard-i2c"); 463