drivers/i2c/busses/i2c-viperboard.c

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