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
 31struct 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
 50static 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
 82static 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
110static 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 {
128		/* do write-then-read */
129		retval = hdpvr_i2c_read(dev, 1, addr, msgs[0].buf, msgs[0].len,
130					msgs[1].buf, msgs[1].len);
131	}
132
133	mutex_unlock(&dev->i2c_mutex);
134
135	return retval ? retval : num;
136}
137
138static u32 hdpvr_functionality(struct i2c_adapter *adapter)
139{
140	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
141}
142
143static const struct i2c_algorithm hdpvr_algo = {
144	.master_xfer   = hdpvr_transfer,
145	.functionality = hdpvr_functionality,
146};
147
148/* prevent invalid 0-length usb_control_msg and support only write-then-read */
149static const struct i2c_adapter_quirks hdpvr_quirks = {
150	.flags = I2C_AQ_NO_ZERO_LEN_READ | I2C_AQ_COMB_WRITE_THEN_READ,
151};
152
153static const struct i2c_adapter hdpvr_i2c_adapter_template = {
154	.name   = "Hauppauge HD PVR I2C",
155	.owner  = THIS_MODULE,
156	.algo   = &hdpvr_algo,
157	.quirks = &hdpvr_quirks,
158};
159
160static int hdpvr_activate_ir(struct hdpvr_device *dev)
161{
162	char buffer[2];
163
164	mutex_lock(&dev->i2c_mutex);
165
166	hdpvr_i2c_read(dev, 0, 0x54, NULL, 0, buffer, 1);
167
168	buffer[0] = 0;
169	buffer[1] = 0x8;
170	hdpvr_i2c_write(dev, 1, 0x54, buffer, 2);
171
172	buffer[1] = 0x18;
173	hdpvr_i2c_write(dev, 1, 0x54, buffer, 2);
174
175	mutex_unlock(&dev->i2c_mutex);
176
177	return 0;
178}
179
180int hdpvr_register_i2c_adapter(struct hdpvr_device *dev)
181{
182	hdpvr_activate_ir(dev);
183
184	dev->i2c_adapter = hdpvr_i2c_adapter_template;
185	dev->i2c_adapter.dev.parent = &dev->udev->dev;
186
187	i2c_set_adapdata(&dev->i2c_adapter, dev);
188
189	return i2c_add_adapter(&dev->i2c_adapter);
190}
191
192#endif