drivers/media/usb/hdpvr/hdpvr-i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 /*
   4  * Hauppauge HD PVR USB driver
   5  *
   6  * Copyright (C) 2008      Janne Grunau (j@jannau.net)
   7  *
   8  * IR device registration code is
   9  * Copyright (C) 2010   Andy Walls <awalls@md.metrocast.net>
  10  */
  11
  12 #if IS_ENABLED(CONFIG_I2C)
  13
  14 #include <linux/i2c.h>
  15 #include <linux/slab.h>
  16 #include <linux/export.h>
  17
  18 #include "hdpvr.h"
  19
  20 #define CTRL_READ_REQUEST       0xb8
  21 #define CTRL_WRITE_REQUEST      0x38
  22
  23 #define REQTYPE_I2C_READ        0xb1
  24 #define REQTYPE_I2C_WRITE       0xb0
  25 #define REQTYPE_I2C_WRITE_STATT 0xd0
  26
  27 #define Z8F0811_IR_TX_I2C_ADDR  0x70
  28 #define Z8F0811_IR_RX_I2C_ADDR  0x71
  29
  30
  31 struct i2c_client *hdpvr_register_ir_i2c(struct hdpvr_device *dev)
  32 {
  33         struct IR_i2c_init_data *init_data = &dev->ir_i2c_init_data;
  34         struct i2c_board_info info = {
  35                 I2C_BOARD_INFO("ir_z8f0811_hdpvr", Z8F0811_IR_RX_I2C_ADDR),
  36         };
  37
  38         /* Our default information for ir-kbd-i2c.c to use */
  39         init_data->ir_codes = RC_MAP_HAUPPAUGE;
  40         init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
  41         init_data->type = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE |
  42                           RC_PROTO_BIT_RC6_6A_32;
  43         init_data->name = "HD-PVR";
  44         init_data->polling_interval = 405; /* ms, duplicated from Windows */
  45         info.platform_data = init_data;
  46
  47         return i2c_new_client_device(&dev->i2c_adapter, &info);
  48 }
  49
  50 static int hdpvr_i2c_read(struct hdpvr_device *dev, int bus,
  51                           unsigned char addr, char *wdata, int wlen,
  52                           char *data, int len)
  53 {
  54         int ret;
  55
  56         if ((len > sizeof(dev->i2c_buf)) || (wlen > sizeof(dev->i2c_buf)))
  57                 return -EINVAL;
  58
  59         if (wlen) {
  60                 memcpy(dev->i2c_buf, wdata, wlen);
  61                 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
  62                                       REQTYPE_I2C_WRITE, CTRL_WRITE_REQUEST,
  63                                       (bus << 8) | addr, 0, dev->i2c_buf,
  64                                       wlen, 1000);
  65                 if (ret < 0)
  66                         return ret;
  67         }
  68
  69         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
  70                               REQTYPE_I2C_READ, CTRL_READ_REQUEST,
  71                               (bus << 8) | addr, 0, dev->i2c_buf, len, 1000);
  72
  73         if (ret == len) {
  74                 memcpy(data, dev->i2c_buf, len);
  75                 ret = 0;
  76         } else if (ret >= 0)
  77                 ret = -EIO;
  78
  79         return ret;
  80 }
  81
  82 static int hdpvr_i2c_write(struct hdpvr_device *dev, int bus,
  83                            unsigned char addr, char *data, int len)
  84 {
  85         int ret;
  86
  87         if (len > sizeof(dev->i2c_buf))
  88                 return -EINVAL;
  89
  90         memcpy(dev->i2c_buf, data, len);
  91         ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
  92                               REQTYPE_I2C_WRITE, CTRL_WRITE_REQUEST,
  93                               (bus << 8) | addr, 0, dev->i2c_buf, len, 1000);
  94
  95         if (ret < 0)
  96                 return ret;
  97
  98         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
  99                               REQTYPE_I2C_WRITE_STATT, CTRL_READ_REQUEST,
 100                               0, 0, dev->i2c_buf, 2, 1000);
 101
 102         if ((ret == 2) && (dev->i2c_buf[1] == (len - 1)))
 103                 ret = 0;
 104         else if (ret >= 0)
 105                 ret = -EIO;
 106
 107         return ret;
 108 }
 109
 110 static int hdpvr_transfer(struct i2c_adapter *i2c_adapter, struct i2c_msg *msgs,
 111                           int num)
 112 {
 113         struct hdpvr_device *dev = i2c_get_adapdata(i2c_adapter);
 114         int retval = 0, addr;
 115
 116         mutex_lock(&dev->i2c_mutex);
 117
 118         addr = msgs[0].addr << 1;
 119
 120         if (num == 1) {
 121                 if (msgs[0].flags & I2C_M_RD)
 122                         retval = hdpvr_i2c_read(dev, 1, addr, NULL, 0,
 123                                                 msgs[0].buf, msgs[0].len);
 124                 else
 125                         retval = hdpvr_i2c_write(dev, 1, addr, msgs[0].buf,
 126                                                  msgs[0].len);
 127         } else if (num == 2) {
 128                 if (msgs[0].addr != msgs[1].addr) {
 129                         v4l2_warn(&dev->v4l2_dev, "refusing 2-phase i2c xfer with conflicting target addresses\n");
 130                         retval = -EINVAL;
 131                         goto out;
 132                 }
 133
 134                 if ((msgs[0].flags & I2C_M_RD) || !(msgs[1].flags & I2C_M_RD)) {
 135                         v4l2_warn(&dev->v4l2_dev, "refusing complex xfer with r0=%d, r1=%d\n",
 136                                   msgs[0].flags & I2C_M_RD,
 137                                   msgs[1].flags & I2C_M_RD);
 138                         retval = -EINVAL;
 139                         goto out;
 140                 }
 141
 142                 /*
 143                  * Write followed by atomic read is the only complex xfer that
 144                  * we actually support here.
 145                  */
 146                 retval = hdpvr_i2c_read(dev, 1, addr, msgs[0].buf, msgs[0].len,
 147                                         msgs[1].buf, msgs[1].len);
 148         } else {
 149                 v4l2_warn(&dev->v4l2_dev, "refusing %d-phase i2c xfer\n", num);
 150         }
 151
 152 out:
 153         mutex_unlock(&dev->i2c_mutex);
 154
 155         return retval ? retval : num;
 156 }
 157
 158 static u32 hdpvr_functionality(struct i2c_adapter *adapter)
 159 {
 160         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 161 }
 162
 163 static const struct i2c_algorithm hdpvr_algo = {
 164         .master_xfer   = hdpvr_transfer,
 165         .functionality = hdpvr_functionality,
 166 };
 167
 168 static const struct i2c_adapter hdpvr_i2c_adapter_template = {
 169         .name   = "Hauppauge HD PVR I2C",
 170         .owner  = THIS_MODULE,
 171         .algo   = &hdpvr_algo,
 172 };
 173
 174 static int hdpvr_activate_ir(struct hdpvr_device *dev)
 175 {
 176         char buffer[2];
 177
 178         mutex_lock(&dev->i2c_mutex);
 179
 180         hdpvr_i2c_read(dev, 0, 0x54, NULL, 0, buffer, 1);
 181
 182         buffer[0] = 0;
 183         buffer[1] = 0x8;
 184         hdpvr_i2c_write(dev, 1, 0x54, buffer, 2);
 185
 186         buffer[1] = 0x18;
 187         hdpvr_i2c_write(dev, 1, 0x54, buffer, 2);
 188
 189         mutex_unlock(&dev->i2c_mutex);
 190
 191         return 0;
 192 }
 193
 194 int hdpvr_register_i2c_adapter(struct hdpvr_device *dev)
 195 {
 196         hdpvr_activate_ir(dev);
 197
 198         dev->i2c_adapter = hdpvr_i2c_adapter_template;
 199         dev->i2c_adapter.dev.parent = &dev->udev->dev;
 200
 201         i2c_set_adapdata(&dev->i2c_adapter, dev);
 202
 203         return i2c_add_adapter(&dev->i2c_adapter);
 204 }
 205
 206 #endif