i2c/busses/i2c-viperboard.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Nano River Technologies viperboard i2c master driver
0004  *
0005  *  (C) 2012 by Lemonage GmbH
0006  *  Author: Lars Poeschel <poeschel@lemonage.de>
0007  *  All rights reserved.
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/errno.h>
0012 #include <linux/module.h>
0013 #include <linux/slab.h>
0014 #include <linux/types.h>
0015 #include <linux/mutex.h>
0016 #include <linux/platform_device.h>
0017
0018 #include <linux/usb.h>
0019 #include <linux/i2c.h>
0020
0021 #include <linux/mfd/viperboard.h>
0022
0023 struct vprbrd_i2c {
0024     struct i2c_adapter i2c;
0025     u8 bus_freq_param;
0026 };
0027
0028 /* i2c bus frequency module parameter */
0029 static u8 i2c_bus_param;
0030 static unsigned int i2c_bus_freq = 100;
0031 module_param(i2c_bus_freq, int, 0);
0032 MODULE_PARM_DESC(i2c_bus_freq,
0033     "i2c bus frequency in khz (default is 100) valid values: 10, 100, 200, 400, 1000, 3000, 6000");
0034
0035 static int vprbrd_i2c_status(struct i2c_adapter *i2c,
0036     struct vprbrd_i2c_status *status, bool prev_error)
0037 {
0038     u16 bytes_xfer;
0039     int ret;
0040     struct vprbrd *vb = (struct vprbrd *)i2c->algo_data;
0041
0042     /* check for protocol error */
0043     bytes_xfer = sizeof(struct vprbrd_i2c_status);
0044
0045     ret = usb_control_msg(vb->usb_dev, usb_rcvctrlpipe(vb->usb_dev, 0),
0046         VPRBRD_USB_REQUEST_I2C, VPRBRD_USB_TYPE_IN, 0x0000, 0x0000,
0047         status, bytes_xfer, VPRBRD_USB_TIMEOUT_MS);
0048
0049     if (ret != bytes_xfer)
0050         prev_error = true;
0051
0052     if (prev_error) {
0053         dev_err(&i2c->dev, "failure in usb communication\n");
0054         return -EREMOTEIO;
0055     }
0056
0057     dev_dbg(&i2c->dev, "  status = %d\n", status->status);
0058     if (status->status != 0x00) {
0059         dev_err(&i2c->dev, "failure: i2c protocol error\n");
0060         return -EPROTO;
0061     }
0062     return 0;
0063 }
0064
0065 static int vprbrd_i2c_receive(struct usb_device *usb_dev,
0066     struct vprbrd_i2c_read_msg *rmsg, int bytes_xfer)
0067 {
0068     int ret, bytes_actual;
0069     int error = 0;
0070
0071     /* send the read request */
0072     ret = usb_bulk_msg(usb_dev,
0073         usb_sndbulkpipe(usb_dev, VPRBRD_EP_OUT), rmsg,
0074         sizeof(struct vprbrd_i2c_read_hdr), &bytes_actual,
0075         VPRBRD_USB_TIMEOUT_MS);
0076
0077     if ((ret < 0)
0078         || (bytes_actual != sizeof(struct vprbrd_i2c_read_hdr))) {
0079         dev_err(&usb_dev->dev, "failure transmitting usb\n");
0080         error = -EREMOTEIO;
0081     }
0082
0083     /* read the actual data */
0084     ret = usb_bulk_msg(usb_dev,
0085         usb_rcvbulkpipe(usb_dev, VPRBRD_EP_IN), rmsg,
0086         bytes_xfer, &bytes_actual, VPRBRD_USB_TIMEOUT_MS);
0087
0088     if ((ret < 0) || (bytes_xfer != bytes_actual)) {
0089         dev_err(&usb_dev->dev, "failure receiving usb\n");
0090         error = -EREMOTEIO;
0091     }
0092     return error;
0093 }
0094
0095 static int vprbrd_i2c_addr(struct usb_device *usb_dev,
0096     struct vprbrd_i2c_addr_msg *amsg)
0097 {
0098     int ret, bytes_actual;
0099
0100     ret = usb_bulk_msg(usb_dev,
0101         usb_sndbulkpipe(usb_dev, VPRBRD_EP_OUT), amsg,
0102         sizeof(struct vprbrd_i2c_addr_msg), &bytes_actual,
0103         VPRBRD_USB_TIMEOUT_MS);
0104
0105     if ((ret < 0) ||
0106             (sizeof(struct vprbrd_i2c_addr_msg) != bytes_actual)) {
0107         dev_err(&usb_dev->dev, "failure transmitting usb\n");
0108         return -EREMOTEIO;
0109     }
0110     return 0;
0111 }
0112
0113 static int vprbrd_i2c_read(struct vprbrd *vb, struct i2c_msg *msg)
0114 {
0115     int ret;
0116     u16 remain_len, len1, len2, start = 0x0000;
0117     struct vprbrd_i2c_read_msg *rmsg =
0118         (struct vprbrd_i2c_read_msg *)vb->buf;
0119
0120     remain_len = msg->len;
0121     rmsg->header.cmd = VPRBRD_I2C_CMD_READ;
0122     while (remain_len > 0) {
0123         rmsg->header.addr = cpu_to_le16(start + 0x4000);
0124         if (remain_len <= 255) {
0125             len1 = remain_len;
0126             len2 = 0x00;
0127             rmsg->header.len0 = remain_len;
0128             rmsg->header.len1 = 0x00;
0129             rmsg->header.len2 = 0x00;
0130             rmsg->header.len3 = 0x00;
0131             rmsg->header.len4 = 0x00;
0132             rmsg->header.len5 = 0x00;
0133             remain_len = 0;
0134         } else if (remain_len <= 510) {
0135             len1 = remain_len;
0136             len2 = 0x00;
0137             rmsg->header.len0 = remain_len - 255;
0138             rmsg->header.len1 = 0xff;
0139             rmsg->header.len2 = 0x00;
0140             rmsg->header.len3 = 0x00;
0141             rmsg->header.len4 = 0x00;
0142             rmsg->header.len5 = 0x00;
0143             remain_len = 0;
0144         } else if (remain_len <= 512) {
0145             len1 = remain_len;
0146             len2 = 0x00;
0147             rmsg->header.len0 = remain_len - 510;
0148             rmsg->header.len1 = 0xff;
0149             rmsg->header.len2 = 0xff;
0150             rmsg->header.len3 = 0x00;
0151             rmsg->header.len4 = 0x00;
0152             rmsg->header.len5 = 0x00;
0153             remain_len = 0;
0154         } else if (remain_len <= 767) {
0155             len1 = 512;
0156             len2 = remain_len - 512;
0157             rmsg->header.len0 = 0x02;
0158             rmsg->header.len1 = 0xff;
0159             rmsg->header.len2 = 0xff;
0160             rmsg->header.len3 = remain_len - 512;
0161             rmsg->header.len4 = 0x00;
0162             rmsg->header.len5 = 0x00;
0163             remain_len = 0;
0164         } else if (remain_len <= 1022) {
0165             len1 = 512;
0166             len2 = remain_len - 512;
0167             rmsg->header.len0 = 0x02;
0168             rmsg->header.len1 = 0xff;
0169             rmsg->header.len2 = 0xff;
0170             rmsg->header.len3 = remain_len - 767;
0171             rmsg->header.len4 = 0xff;
0172             rmsg->header.len5 = 0x00;
0173             remain_len = 0;
0174         } else if (remain_len <= 1024) {
0175             len1 = 512;
0176             len2 = remain_len - 512;
0177             rmsg->header.len0 = 0x02;
0178             rmsg->header.len1 = 0xff;
0179             rmsg->header.len2 = 0xff;
0180             rmsg->header.len3 = remain_len - 1022;
0181             rmsg->header.len4 = 0xff;
0182             rmsg->header.len5 = 0xff;
0183             remain_len = 0;
0184         } else {
0185             len1 = 512;
0186             len2 = 512;
0187             rmsg->header.len0 = 0x02;
0188             rmsg->header.len1 = 0xff;
0189             rmsg->header.len2 = 0xff;
0190             rmsg->header.len3 = 0x02;
0191             rmsg->header.len4 = 0xff;
0192             rmsg->header.len5 = 0xff;
0193             remain_len -= 1024;
0194             start += 1024;
0195         }
0196         rmsg->header.tf1 = cpu_to_le16(len1);
0197         rmsg->header.tf2 = cpu_to_le16(len2);
0198
0199         /* first read transfer */
0200         ret = vprbrd_i2c_receive(vb->usb_dev, rmsg, len1);
0201         if (ret < 0)
0202             return ret;
0203         /* copy the received data */
0204         memcpy(msg->buf + start, rmsg, len1);
0205
0206         /* second read transfer if neccessary */
0207         if (len2 > 0) {
0208             ret = vprbrd_i2c_receive(vb->usb_dev, rmsg, len2);
0209             if (ret < 0)
0210                 return ret;
0211             /* copy the received data */
0212             memcpy(msg->buf + start + 512, rmsg, len2);
0213         }
0214     }
0215     return 0;
0216 }
0217
0218 static int vprbrd_i2c_write(struct vprbrd *vb, struct i2c_msg *msg)
0219 {
0220     int ret, bytes_actual;
0221     u16 remain_len, bytes_xfer,
0222         start = 0x0000;
0223     struct vprbrd_i2c_write_msg *wmsg =
0224         (struct vprbrd_i2c_write_msg *)vb->buf;
0225
0226     remain_len = msg->len;
0227     wmsg->header.cmd = VPRBRD_I2C_CMD_WRITE;
0228     wmsg->header.last = 0x00;
0229     wmsg->header.chan = 0x00;
0230     wmsg->header.spi = 0x0000;
0231     while (remain_len > 0) {
0232         wmsg->header.addr = cpu_to_le16(start + 0x4000);
0233         if (remain_len > 503) {
0234             wmsg->header.len1 = 0xff;
0235             wmsg->header.len2 = 0xf8;
0236             remain_len -= 503;
0237             bytes_xfer = 503 + sizeof(struct vprbrd_i2c_write_hdr);
0238             start += 503;
0239         } else if (remain_len > 255) {
0240             wmsg->header.len1 = 0xff;
0241             wmsg->header.len2 = (remain_len - 255);
0242             bytes_xfer = remain_len +
0243                 sizeof(struct vprbrd_i2c_write_hdr);
0244             remain_len = 0;
0245         } else {
0246             wmsg->header.len1 = remain_len;
0247             wmsg->header.len2 = 0x00;
0248             bytes_xfer = remain_len +
0249                 sizeof(struct vprbrd_i2c_write_hdr);
0250             remain_len = 0;
0251         }
0252         memcpy(wmsg->data, msg->buf + start,
0253             bytes_xfer - sizeof(struct vprbrd_i2c_write_hdr));
0254
0255         ret = usb_bulk_msg(vb->usb_dev,
0256             usb_sndbulkpipe(vb->usb_dev,
0257             VPRBRD_EP_OUT), wmsg,
0258             bytes_xfer, &bytes_actual, VPRBRD_USB_TIMEOUT_MS);
0259         if ((ret < 0) || (bytes_xfer != bytes_actual))
0260             return -EREMOTEIO;
0261     }
0262     return 0;
0263 }
0264
0265 static int vprbrd_i2c_xfer(struct i2c_adapter *i2c, struct i2c_msg *msgs,
0266         int num)
0267 {
0268     struct i2c_msg *pmsg;
0269     int i, ret,
0270         error = 0;
0271     struct vprbrd *vb = (struct vprbrd *)i2c->algo_data;
0272     struct vprbrd_i2c_addr_msg *amsg =
0273         (struct vprbrd_i2c_addr_msg *)vb->buf;
0274     struct vprbrd_i2c_status *smsg = (struct vprbrd_i2c_status *)vb->buf;
0275
0276     dev_dbg(&i2c->dev, "master xfer %d messages:\n", num);
0277
0278     for (i = 0 ; i < num ; i++) {
0279         pmsg = &msgs[i];
0280
0281         dev_dbg(&i2c->dev,
0282             "  %d: %s (flags %d) %d bytes to 0x%02x\n",
0283             i, pmsg->flags & I2C_M_RD ? "read" : "write",
0284             pmsg->flags, pmsg->len, pmsg->addr);
0285
0286         mutex_lock(&vb->lock);
0287         /* directly send the message */
0288         if (pmsg->flags & I2C_M_RD) {
0289             /* read data */
0290             amsg->cmd = VPRBRD_I2C_CMD_ADDR;
0291             amsg->unknown2 = 0x00;
0292             amsg->unknown3 = 0x00;
0293             amsg->addr = pmsg->addr;
0294             amsg->unknown1 = 0x01;
0295             amsg->len = cpu_to_le16(pmsg->len);
0296             /* send the addr and len, we're interested to board */
0297             ret = vprbrd_i2c_addr(vb->usb_dev, amsg);
0298             if (ret < 0)
0299                 error = ret;
0300
0301             ret = vprbrd_i2c_read(vb, pmsg);
0302             if (ret < 0)
0303                 error = ret;
0304
0305             ret = vprbrd_i2c_status(i2c, smsg, error);
0306             if (ret < 0)
0307                 error = ret;
0308             /* in case of protocol error, return the error */
0309             if (error < 0)
0310                 goto error;
0311         } else {
0312             /* write data */
0313             ret = vprbrd_i2c_write(vb, pmsg);
0314
0315             amsg->cmd = VPRBRD_I2C_CMD_ADDR;
0316             amsg->unknown2 = 0x00;
0317             amsg->unknown3 = 0x00;
0318             amsg->addr = pmsg->addr;
0319             amsg->unknown1 = 0x00;
0320             amsg->len = cpu_to_le16(pmsg->len);
0321             /* send the addr, the data goes to to board */
0322             ret = vprbrd_i2c_addr(vb->usb_dev, amsg);
0323             if (ret < 0)
0324                 error = ret;
0325
0326             ret = vprbrd_i2c_status(i2c, smsg, error);
0327             if (ret < 0)
0328                 error = ret;
0329
0330             if (error < 0)
0331                 goto error;
0332         }
0333         mutex_unlock(&vb->lock);
0334     }
0335     return num;
0336 error:
0337     mutex_unlock(&vb->lock);
0338     return error;
0339 }
0340
0341 static u32 vprbrd_i2c_func(struct i2c_adapter *i2c)
0342 {
0343     return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
0344 }
0345
0346 /* This is the actual algorithm we define */
0347 static const struct i2c_algorithm vprbrd_algorithm = {
0348     .master_xfer    = vprbrd_i2c_xfer,
0349     .functionality  = vprbrd_i2c_func,
0350 };
0351
0352 static const struct i2c_adapter_quirks vprbrd_quirks = {
0353     .max_read_len = 2048,
0354     .max_write_len = 2048,
0355 };
0356
0357 static int vprbrd_i2c_probe(struct platform_device *pdev)
0358 {
0359     struct vprbrd *vb = dev_get_drvdata(pdev->dev.parent);
0360     struct vprbrd_i2c *vb_i2c;
0361     int ret;
0362     int pipe;
0363
0364     vb_i2c = devm_kzalloc(&pdev->dev, sizeof(*vb_i2c), GFP_KERNEL);
0365     if (vb_i2c == NULL)
0366         return -ENOMEM;
0367
0368     /* setup i2c adapter description */
0369     vb_i2c->i2c.owner = THIS_MODULE;
0370     vb_i2c->i2c.class = I2C_CLASS_HWMON;
0371     vb_i2c->i2c.algo = &vprbrd_algorithm;
0372     vb_i2c->i2c.quirks = &vprbrd_quirks;
0373     vb_i2c->i2c.algo_data = vb;
0374     /* save the param in usb capabable memory */
0375     vb_i2c->bus_freq_param = i2c_bus_param;
0376
0377     snprintf(vb_i2c->i2c.name, sizeof(vb_i2c->i2c.name),
0378          "viperboard at bus %03d device %03d",
0379          vb->usb_dev->bus->busnum, vb->usb_dev->devnum);
0380
0381     /* setting the bus frequency */
0382     if ((i2c_bus_param <= VPRBRD_I2C_FREQ_10KHZ)
0383         && (i2c_bus_param >= VPRBRD_I2C_FREQ_6MHZ)) {
0384         pipe = usb_sndctrlpipe(vb->usb_dev, 0);
0385         ret = usb_control_msg(vb->usb_dev, pipe,
0386             VPRBRD_USB_REQUEST_I2C_FREQ, VPRBRD_USB_TYPE_OUT,
0387             0x0000, 0x0000, &vb_i2c->bus_freq_param, 1,
0388             VPRBRD_USB_TIMEOUT_MS);
0389         if (ret != 1) {
0390             dev_err(&pdev->dev, "failure setting i2c_bus_freq to %d\n",
0391                 i2c_bus_freq);
0392             return -EIO;
0393         }
0394     } else {
0395         dev_err(&pdev->dev,
0396             "invalid i2c_bus_freq setting:%d\n", i2c_bus_freq);
0397         return -EIO;
0398     }
0399
0400     vb_i2c->i2c.dev.parent = &pdev->dev;
0401
0402     /* attach to i2c layer */
0403     i2c_add_adapter(&vb_i2c->i2c);
0404
0405     platform_set_drvdata(pdev, vb_i2c);
0406
0407     return 0;
0408 }
0409
0410 static int vprbrd_i2c_remove(struct platform_device *pdev)
0411 {
0412     struct vprbrd_i2c *vb_i2c = platform_get_drvdata(pdev);
0413
0414     i2c_del_adapter(&vb_i2c->i2c);
0415
0416     return 0;
0417 }
0418
0419 static struct platform_driver vprbrd_i2c_driver = {
0420     .driver.name    = "viperboard-i2c",
0421     .driver.owner   = THIS_MODULE,
0422     .probe      = vprbrd_i2c_probe,
0423     .remove     = vprbrd_i2c_remove,
0424 };
0425
0426 static int __init vprbrd_i2c_init(void)
0427 {
0428     switch (i2c_bus_freq) {
0429     case 6000:
0430         i2c_bus_param = VPRBRD_I2C_FREQ_6MHZ;
0431         break;
0432     case 3000:
0433         i2c_bus_param = VPRBRD_I2C_FREQ_3MHZ;
0434         break;
0435     case 1000:
0436         i2c_bus_param = VPRBRD_I2C_FREQ_1MHZ;
0437         break;
0438     case 400:
0439         i2c_bus_param = VPRBRD_I2C_FREQ_400KHZ;
0440         break;
0441     case 200:
0442         i2c_bus_param = VPRBRD_I2C_FREQ_200KHZ;
0443         break;
0444     case 100:
0445         i2c_bus_param = VPRBRD_I2C_FREQ_100KHZ;
0446         break;
0447     case 10:
0448         i2c_bus_param = VPRBRD_I2C_FREQ_10KHZ;
0449         break;
0450     default:
0451         pr_warn("invalid i2c_bus_freq (%d)\n", i2c_bus_freq);
0452         i2c_bus_param = VPRBRD_I2C_FREQ_100KHZ;
0453     }
0454
0455     return platform_driver_register(&vprbrd_i2c_driver);
0456 }
0457 subsys_initcall(vprbrd_i2c_init);
0458
0459 static void __exit vprbrd_i2c_exit(void)
0460 {
0461     platform_driver_unregister(&vprbrd_i2c_driver);
0462 }
0463 module_exit(vprbrd_i2c_exit);
0464
0465 MODULE_AUTHOR("Lars Poeschel <poeschel@lemonage.de>");
0466 MODULE_DESCRIPTION("I2C master driver for Nano River Techs Viperboard");
0467 MODULE_LICENSE("GPL");
0468 MODULE_ALIAS("platform:viperboard-i2c");