1// SPDX-License-Identifier: GPL-2.0
2// tm6000-i2c.c - driver for TM5600/TM6000/TM6010 USB video capture devices
3//
4// Copyright (c) 2006-2007 Mauro Carvalho Chehab <mchehab@kernel.org>
5//
6// Copyright (c) 2007 Michel Ludwig <michel.ludwig@gmail.com>
7//	- Fix SMBus Read Byte command
8
9#include <linux/module.h>
10#include <linux/kernel.h>
11#include <linux/usb.h>
12#include <linux/i2c.h>
13
14#include "tm6000.h"
15#include "tm6000-regs.h"
16#include <media/v4l2-common.h>
17#include <media/tuner.h>
18#include "tuner-xc2028.h"
19
20
21/* ----------------------------------------------------------- */
22
23static unsigned int i2c_debug;
24module_param(i2c_debug, int, 0644);
25MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
26
27#define i2c_dprintk(lvl, fmt, args...) if (i2c_debug >= lvl) do { \
28			printk(KERN_DEBUG "%s at %s: " fmt, \
29			dev->name, __func__, ##args); } while (0)
30
31static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
32				__u8 reg, char *buf, int len)
33{
34	int rc;
35	unsigned int i2c_packet_limit = 16;
36
37	if (dev->dev_type == TM6010)
38		i2c_packet_limit = 80;
39
40	if (!buf)
41		return -1;
42
43	if (len < 1 || len > i2c_packet_limit) {
44		printk(KERN_ERR "Incorrect length of i2c packet = %d, limit set to %d\n",
45			len, i2c_packet_limit);
46		return -1;
47	}
48
49	/* capture mutex */
50	rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
51		USB_RECIP_DEVICE, REQ_16_SET_GET_I2C_WR1_RDN,
52		addr | reg << 8, 0, buf, len);
53
54	if (rc < 0) {
55		/* release mutex */
56		return rc;
57	}
58
59	/* release mutex */
60	return rc;
61}
62
63/* Generic read - doesn't work fine with 16bit registers */
64static int tm6000_i2c_recv_regs(struct tm6000_core *dev, unsigned char addr,
65				__u8 reg, char *buf, int len)
66{
67	int rc;
68	u8 b[2];
69	unsigned int i2c_packet_limit = 16;
70
71	if (dev->dev_type == TM6010)
72		i2c_packet_limit = 64;
73
74	if (!buf)
75		return -1;
76
77	if (len < 1 || len > i2c_packet_limit) {
78		printk(KERN_ERR "Incorrect length of i2c packet = %d, limit set to %d\n",
79			len, i2c_packet_limit);
80		return -1;
81	}
82
83	/* capture mutex */
84	if ((dev->caps.has_zl10353) && (dev->demod_addr << 1 == addr) && (reg % 2 == 0)) {
85		/*
86		 * Workaround an I2C bug when reading from zl10353
87		 */
88		reg -= 1;
89		len += 1;
90
91		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
92			REQ_16_SET_GET_I2C_WR1_RDN, addr | reg << 8, 0, b, len);
93
94		*buf = b[1];
95	} else {
96		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
97			REQ_16_SET_GET_I2C_WR1_RDN, addr | reg << 8, 0, buf, len);
98	}
99
100	/* release mutex */
101	return rc;
102}
103
104/*
105 * read from a 16bit register
106 * for example xc2028, xc3028 or xc3028L
107 */
108static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
109				  __u16 reg, char *buf, int len)
110{
111	int rc;
112	unsigned char ureg;
113
114	if (!buf || len != 2)
115		return -1;
116
117	/* capture mutex */
118	if (dev->dev_type == TM6010) {
119		ureg = reg & 0xFF;
120		rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
121			USB_RECIP_DEVICE, REQ_16_SET_GET_I2C_WR1_RDN,
122			addr | (reg & 0xFF00), 0, &ureg, 1);
123
124		if (rc < 0) {
125			/* release mutex */
126			return rc;
127		}
128
129		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
130			USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
131			reg, 0, buf, len);
132	} else {
133		rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
134			USB_RECIP_DEVICE, REQ_14_SET_GET_I2C_WR2_RDN,
135			addr, reg, buf, len);
136	}
137
138	/* release mutex */
139	return rc;
140}
141
142static int tm6000_i2c_xfer(struct i2c_adapter *i2c_adap,
143			   struct i2c_msg msgs[], int num)
144{
145	struct tm6000_core *dev = i2c_adap->algo_data;
146	int addr, rc, i, byte;
147
148	for (i = 0; i < num; i++) {
149		addr = (msgs[i].addr << 1) & 0xff;
150		i2c_dprintk(2, "%s %s addr=0x%x len=%d:",
151			 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
152			 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
153		if (msgs[i].flags & I2C_M_RD) {
154			/* read request without preceding register selection */
155			/*
156			 * The TM6000 only supports a read transaction
157			 * immediately after a 1 or 2 byte write to select
158			 * a register.  We cannot fulfill this request.
159			 */
160			i2c_dprintk(2, " read without preceding write not supported");
161			rc = -EOPNOTSUPP;
162			goto err;
163		} else if (i + 1 < num && msgs[i].len <= 2 &&
164			   (msgs[i + 1].flags & I2C_M_RD) &&
165			   msgs[i].addr == msgs[i + 1].addr) {
166			/* 1 or 2 byte write followed by a read */
167			if (i2c_debug >= 2)
168				for (byte = 0; byte < msgs[i].len; byte++)
169					printk(KERN_CONT " %02x", msgs[i].buf[byte]);
170			i2c_dprintk(2, "; joined to read %s len=%d:",
171				    i == num - 2 ? "stop" : "nonstop",
172				    msgs[i + 1].len);
173
174			if (msgs[i].len == 2) {
175				rc = tm6000_i2c_recv_regs16(dev, addr,
176					msgs[i].buf[0] << 8 | msgs[i].buf[1],
177					msgs[i + 1].buf, msgs[i + 1].len);
178			} else {
179				rc = tm6000_i2c_recv_regs(dev, addr, msgs[i].buf[0],
180					msgs[i + 1].buf, msgs[i + 1].len);
181			}
182
183			i++;
184
185			if (addr == dev->tuner_addr << 1) {
186				tm6000_set_reg(dev, REQ_50_SET_START, 0, 0);
187				tm6000_set_reg(dev, REQ_51_SET_STOP, 0, 0);
188			}
189			if (i2c_debug >= 2)
190				for (byte = 0; byte < msgs[i].len; byte++)
191					printk(KERN_CONT " %02x", msgs[i].buf[byte]);
192		} else {
193			/* write bytes */
194			if (i2c_debug >= 2)
195				for (byte = 0; byte < msgs[i].len; byte++)
196					printk(KERN_CONT " %02x", msgs[i].buf[byte]);
197			rc = tm6000_i2c_send_regs(dev, addr, msgs[i].buf[0],
198				msgs[i].buf + 1, msgs[i].len - 1);
199		}
200		if (i2c_debug >= 2)
201			printk(KERN_CONT "\n");
202		if (rc < 0)
203			goto err;
204	}
205
206	return num;
207err:
208	i2c_dprintk(2, " ERROR: %i\n", rc);
209	return rc;
210}
211
212static int tm6000_i2c_eeprom(struct tm6000_core *dev)
213{
214	int i, rc;
215	unsigned char *p = dev->eedata;
216	unsigned char bytes[17];
217
218	dev->i2c_client.addr = 0xa0 >> 1;
219	dev->eedata_size = 0;
220
221	bytes[16] = '\0';
222	for (i = 0; i < sizeof(dev->eedata); ) {
223		*p = i;
224		rc = tm6000_i2c_recv_regs(dev, 0xa0, i, p, 1);
225		if (rc < 1) {
226			if (p == dev->eedata)
227				goto noeeprom;
228			else {
229				printk(KERN_WARNING
230				"%s: i2c eeprom read error (err=%d)\n",
231				dev->name, rc);
232			}
233			return -EINVAL;
234		}
235		dev->eedata_size++;
236		p++;
237		if (0 == (i % 16))
238			printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
239		printk(KERN_CONT " %02x", dev->eedata[i]);
240		if ((dev->eedata[i] >= ' ') && (dev->eedata[i] <= 'z'))
241			bytes[i%16] = dev->eedata[i];
242		else
243			bytes[i%16] = '.';
244
245		i++;
246
247		if (0 == (i % 16)) {
248			bytes[16] = '\0';
249			printk(KERN_CONT "  %s\n", bytes);
250		}
251	}
252	if (0 != (i%16)) {
253		bytes[i%16] = '\0';
254		for (i %= 16; i < 16; i++)
255			printk(KERN_CONT "   ");
256		printk(KERN_CONT "  %s\n", bytes);
257	}
258
259	return 0;
260
261noeeprom:
262	printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
263	       dev->name, rc);
264	return -EINVAL;
265}
266
267/* ----------------------------------------------------------- */
268
269/*
270 * functionality()
271 */
272static u32 functionality(struct i2c_adapter *adap)
273{
274	return I2C_FUNC_SMBUS_EMUL;
275}
276
277static const struct i2c_algorithm tm6000_algo = {
278	.master_xfer   = tm6000_i2c_xfer,
279	.functionality = functionality,
280};
281
282/* ----------------------------------------------------------- */
283
284/*
285 * tm6000_i2c_register()
286 * register i2c bus
287 */
288int tm6000_i2c_register(struct tm6000_core *dev)
289{
290	int rc;
291
292	dev->i2c_adap.owner = THIS_MODULE;
293	dev->i2c_adap.algo = &tm6000_algo;
294	dev->i2c_adap.dev.parent = &dev->udev->dev;
295	strscpy(dev->i2c_adap.name, dev->name, sizeof(dev->i2c_adap.name));
296	dev->i2c_adap.algo_data = dev;
297	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
298	rc = i2c_add_adapter(&dev->i2c_adap);
299	if (rc)
300		return rc;
301
302	dev->i2c_client.adapter = &dev->i2c_adap;
303	strscpy(dev->i2c_client.name, "tm6000 internal", I2C_NAME_SIZE);
304	tm6000_i2c_eeprom(dev);
305
306	return 0;
307}
308
309/*
310 * tm6000_i2c_unregister()
311 * unregister i2c_bus
312 */
313int tm6000_i2c_unregister(struct tm6000_core *dev)
314{
315	i2c_del_adapter(&dev->i2c_adap);
316	return 0;
317}
318