1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *
4  * device driver for philips saa7134 based TV cards
5  * i2c interface support
6  *
7  * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
8  */
9 
10 #include "saa7134.h"
11 #include "saa7134-reg.h"
12 
13 #include <linux/init.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/delay.h>
18 
19 #include <media/v4l2-common.h>
20 
21 /* ----------------------------------------------------------- */
22 
23 static unsigned int i2c_debug;
24 module_param(i2c_debug, int, 0644);
25 MODULE_PARM_DESC(i2c_debug,"enable debug messages [i2c]");
26 
27 static unsigned int i2c_scan;
28 module_param(i2c_scan, int, 0444);
29 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
30 
31 #define i2c_dbg(level, fmt, arg...) do { \
32 	if (i2c_debug == level) \
33 		printk(KERN_DEBUG pr_fmt("i2c: " fmt), ## arg); \
34 	} while (0)
35 
36 #define i2c_cont(level, fmt, arg...) do { \
37 	if (i2c_debug == level) \
38 		pr_cont(fmt, ## arg); \
39 	} while (0)
40 
41 #define I2C_WAIT_DELAY  32
42 #define I2C_WAIT_RETRY  16
43 
44 /* ----------------------------------------------------------- */
45 
46 static char *str_i2c_status[] = {
47 	"IDLE", "DONE_STOP", "BUSY", "TO_SCL", "TO_ARB", "DONE_WRITE",
48 	"DONE_READ", "DONE_WRITE_TO", "DONE_READ_TO", "NO_DEVICE",
49 	"NO_ACKN", "BUS_ERR", "ARB_LOST", "SEQ_ERR", "ST_ERR", "SW_ERR"
50 };
51 
52 enum i2c_status {
53 	IDLE          = 0,  // no I2C command pending
54 	DONE_STOP     = 1,  // I2C command done and STOP executed
55 	BUSY          = 2,  // executing I2C command
56 	TO_SCL        = 3,  // executing I2C command, time out on clock stretching
57 	TO_ARB        = 4,  // time out on arbitration trial, still trying
58 	DONE_WRITE    = 5,  // I2C command done and awaiting next write command
59 	DONE_READ     = 6,  // I2C command done and awaiting next read command
60 	DONE_WRITE_TO = 7,  // see 5, and time out on status echo
61 	DONE_READ_TO  = 8,  // see 6, and time out on status echo
62 	NO_DEVICE     = 9,  // no acknowledge on device slave address
63 	NO_ACKN       = 10, // no acknowledge after data byte transfer
64 	BUS_ERR       = 11, // bus error
65 	ARB_LOST      = 12, // arbitration lost during transfer
66 	SEQ_ERR       = 13, // erroneous programming sequence
67 	ST_ERR        = 14, // wrong status echoing
68 	SW_ERR        = 15  // software error
69 };
70 
71 static char *str_i2c_attr[] = {
72 	"NOP", "STOP", "CONTINUE", "START"
73 };
74 
75 enum i2c_attr {
76 	NOP           = 0,  // no operation on I2C bus
77 	STOP          = 1,  // stop condition, no associated byte transfer
78 	CONTINUE      = 2,  // continue with byte transfer
79 	START         = 3   // start condition with byte transfer
80 };
81 
82 static inline enum i2c_status i2c_get_status(struct saa7134_dev *dev)
83 {
84 	enum i2c_status status;
85 
86 	status = saa_readb(SAA7134_I2C_ATTR_STATUS) & 0x0f;
87 	i2c_dbg(2, "i2c stat <= %s\n", str_i2c_status[status]);
88 	return status;
89 }
90 
91 static inline void i2c_set_status(struct saa7134_dev *dev,
92 				  enum i2c_status status)
93 {
94 	i2c_dbg(2, "i2c stat => %s\n", str_i2c_status[status]);
95 	saa_andorb(SAA7134_I2C_ATTR_STATUS,0x0f,status);
96 }
97 
98 static inline void i2c_set_attr(struct saa7134_dev *dev, enum i2c_attr attr)
99 {
100 	i2c_dbg(2, "i2c attr => %s\n", str_i2c_attr[attr]);
101 	saa_andorb(SAA7134_I2C_ATTR_STATUS,0xc0,attr << 6);
102 }
103 
104 static inline int i2c_is_error(enum i2c_status status)
105 {
106 	switch (status) {
107 	case NO_DEVICE:
108 	case NO_ACKN:
109 	case BUS_ERR:
110 	case ARB_LOST:
111 	case SEQ_ERR:
112 	case ST_ERR:
113 		return true;
114 	default:
115 		return false;
116 	}
117 }
118 
119 static inline int i2c_is_idle(enum i2c_status status)
120 {
121 	switch (status) {
122 	case IDLE:
123 	case DONE_STOP:
124 		return true;
125 	default:
126 		return false;
127 	}
128 }
129 
130 static inline int i2c_is_busy(enum i2c_status status)
131 {
132 	switch (status) {
133 	case BUSY:
134 	case TO_SCL:
135 	case TO_ARB:
136 		return true;
137 	default:
138 		return false;
139 	}
140 }
141 
142 static int i2c_is_busy_wait(struct saa7134_dev *dev)
143 {
144 	enum i2c_status status;
145 	int count;
146 
147 	for (count = 0; count < I2C_WAIT_RETRY; count++) {
148 		status = i2c_get_status(dev);
149 		if (!i2c_is_busy(status))
150 			break;
151 		saa_wait(I2C_WAIT_DELAY);
152 	}
153 	if (I2C_WAIT_RETRY == count)
154 		return false;
155 	return true;
156 }
157 
158 static int i2c_reset(struct saa7134_dev *dev)
159 {
160 	enum i2c_status status;
161 	int count;
162 
163 	i2c_dbg(2, "i2c reset\n");
164 	status = i2c_get_status(dev);
165 	if (!i2c_is_error(status))
166 		return true;
167 	i2c_set_status(dev,status);
168 
169 	for (count = 0; count < I2C_WAIT_RETRY; count++) {
170 		status = i2c_get_status(dev);
171 		if (!i2c_is_error(status))
172 			break;
173 		udelay(I2C_WAIT_DELAY);
174 	}
175 	if (I2C_WAIT_RETRY == count)
176 		return false;
177 
178 	if (!i2c_is_idle(status))
179 		return false;
180 
181 	i2c_set_attr(dev,NOP);
182 	return true;
183 }
184 
185 static inline int i2c_send_byte(struct saa7134_dev *dev,
186 				enum i2c_attr attr,
187 				unsigned char data)
188 {
189 	enum i2c_status status;
190 	__u32 dword;
191 
192 	/* have to write both attr + data in one 32bit word */
193 	dword  = saa_readl(SAA7134_I2C_ATTR_STATUS >> 2);
194 	dword &= 0x0f;
195 	dword |= (attr << 6);
196 	dword |= ((__u32)data << 8);
197 	dword |= 0x00 << 16;  /* 100 kHz */
198 //	dword |= 0x40 << 16;  /* 400 kHz */
199 	dword |= 0xf0 << 24;
200 	saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword);
201 	i2c_dbg(2, "i2c data => 0x%x\n", data);
202 
203 	if (!i2c_is_busy_wait(dev))
204 		return -EIO;
205 	status = i2c_get_status(dev);
206 	if (i2c_is_error(status))
207 		return -EIO;
208 	return 0;
209 }
210 
211 static inline int i2c_recv_byte(struct saa7134_dev *dev)
212 {
213 	enum i2c_status status;
214 	unsigned char data;
215 
216 	i2c_set_attr(dev,CONTINUE);
217 	if (!i2c_is_busy_wait(dev))
218 		return -EIO;
219 	status = i2c_get_status(dev);
220 	if (i2c_is_error(status))
221 		return -EIO;
222 	data = saa_readb(SAA7134_I2C_DATA);
223 	i2c_dbg(2, "i2c data <= 0x%x\n", data);
224 	return data;
225 }
226 
227 static int saa7134_i2c_xfer(struct i2c_adapter *i2c_adap,
228 			    struct i2c_msg *msgs, int num)
229 {
230 	struct saa7134_dev *dev = i2c_adap->algo_data;
231 	enum i2c_status status;
232 	unsigned char data;
233 	int addr,rc,i,byte;
234 
235 	status = i2c_get_status(dev);
236 	if (!i2c_is_idle(status))
237 		if (!i2c_reset(dev))
238 			return -EIO;
239 
240 	i2c_dbg(2, "start xfer\n");
241 	i2c_dbg(1, "i2c xfer:");
242 	for (i = 0; i < num; i++) {
243 		if (!(msgs[i].flags & I2C_M_NOSTART) || 0 == i) {
244 			/* send address */
245 			i2c_dbg(2, "send address\n");
246 			addr  = msgs[i].addr << 1;
247 			if (msgs[i].flags & I2C_M_RD)
248 				addr |= 1;
249 			if (i > 0 && msgs[i].flags &
250 			    I2C_M_RD && msgs[i].addr != 0x40 &&
251 			    msgs[i].addr != 0x41 &&
252 			    msgs[i].addr != 0x19) {
253 				/* workaround for a saa7134 i2c bug
254 				 * needed to talk to the mt352 demux
255 				 * thanks to pinnacle for the hint */
256 				int quirk = 0xfe;
257 				i2c_cont(1, " [%02x quirk]", quirk);
258 				i2c_send_byte(dev,START,quirk);
259 				i2c_recv_byte(dev);
260 			}
261 			i2c_cont(1, " < %02x", addr);
262 			rc = i2c_send_byte(dev,START,addr);
263 			if (rc < 0)
264 				 goto err;
265 		}
266 		if (msgs[i].flags & I2C_M_RD) {
267 			/* read bytes */
268 			i2c_dbg(2, "read bytes\n");
269 			for (byte = 0; byte < msgs[i].len; byte++) {
270 				i2c_cont(1, " =");
271 				rc = i2c_recv_byte(dev);
272 				if (rc < 0)
273 					goto err;
274 				i2c_cont(1, "%02x", rc);
275 				msgs[i].buf[byte] = rc;
276 			}
277 			/* discard mysterious extra byte when reading
278 			   from Samsung S5H1411.  i2c bus gets error
279 			   if we do not. */
280 			if (0x19 == msgs[i].addr) {
281 				i2c_cont(1, " ?");
282 				rc = i2c_recv_byte(dev);
283 				if (rc < 0)
284 					goto err;
285 				i2c_cont(1, "%02x", rc);
286 			}
287 		} else {
288 			/* write bytes */
289 			i2c_dbg(2, "write bytes\n");
290 			for (byte = 0; byte < msgs[i].len; byte++) {
291 				data = msgs[i].buf[byte];
292 				i2c_cont(1, " %02x", data);
293 				rc = i2c_send_byte(dev,CONTINUE,data);
294 				if (rc < 0)
295 					goto err;
296 			}
297 		}
298 	}
299 	i2c_dbg(2, "xfer done\n");
300 	i2c_cont(1, " >");
301 	i2c_set_attr(dev,STOP);
302 	rc = -EIO;
303 	if (!i2c_is_busy_wait(dev))
304 		goto err;
305 	status = i2c_get_status(dev);
306 	if (i2c_is_error(status))
307 		goto err;
308 	/* ensure that the bus is idle for at least one bit slot */
309 	msleep(1);
310 
311 	i2c_cont(1, "\n");
312 	return num;
313  err:
314 	if (1 == i2c_debug) {
315 		status = i2c_get_status(dev);
316 		i2c_cont(1, " ERROR: %s\n", str_i2c_status[status]);
317 	}
318 	return rc;
319 }
320 
321 /* ----------------------------------------------------------- */
322 
323 static u32 functionality(struct i2c_adapter *adap)
324 {
325 	return I2C_FUNC_SMBUS_EMUL;
326 }
327 
328 static const struct i2c_algorithm saa7134_algo = {
329 	.master_xfer   = saa7134_i2c_xfer,
330 	.functionality = functionality,
331 };
332 
333 static const struct i2c_adapter saa7134_adap_template = {
334 	.owner         = THIS_MODULE,
335 	.name          = "saa7134",
336 	.algo          = &saa7134_algo,
337 };
338 
339 static const struct i2c_client saa7134_client_template = {
340 	.name	= "saa7134 internal",
341 };
342 
343 /* ----------------------------------------------------------- */
344 
345 /* On Medion 7134 reading EEPROM needs DVB-T demod i2c gate open */
346 static void saa7134_i2c_eeprom_md7134_gate(struct saa7134_dev *dev)
347 {
348 	u8 subaddr = 0x7, dmdregval;
349 	u8 data[2];
350 	int ret;
351 	struct i2c_msg i2cgatemsg_r[] = { {.addr = 0x08, .flags = 0,
352 					   .buf = &subaddr, .len = 1},
353 					  {.addr = 0x08,
354 					   .flags = I2C_M_RD,
355 					   .buf = &dmdregval, .len = 1}
356 					};
357 	struct i2c_msg i2cgatemsg_w[] = { {.addr = 0x08, .flags = 0,
358 					   .buf = data, .len = 2} };
359 
360 	ret = i2c_transfer(&dev->i2c_adap, i2cgatemsg_r, 2);
361 	if ((ret == 2) && (dmdregval & 0x2)) {
362 		pr_debug("%s: DVB-T demod i2c gate was left closed\n",
363 			 dev->name);
364 
365 		data[0] = subaddr;
366 		data[1] = (dmdregval & ~0x2);
367 		if (i2c_transfer(&dev->i2c_adap, i2cgatemsg_w, 1) != 1)
368 			pr_err("%s: EEPROM i2c gate open failure\n",
369 			  dev->name);
370 	}
371 }
372 
373 static int
374 saa7134_i2c_eeprom(struct saa7134_dev *dev, unsigned char *eedata, int len)
375 {
376 	unsigned char buf;
377 	int i,err;
378 
379 	if (dev->board == SAA7134_BOARD_MD7134)
380 		saa7134_i2c_eeprom_md7134_gate(dev);
381 
382 	dev->i2c_client.addr = 0xa0 >> 1;
383 	buf = 0;
384 	if (1 != (err = i2c_master_send(&dev->i2c_client,&buf,1))) {
385 		pr_info("%s: Huh, no eeprom present (err=%d)?\n",
386 		       dev->name,err);
387 		return -1;
388 	}
389 	if (len != (err = i2c_master_recv(&dev->i2c_client,eedata,len))) {
390 		pr_warn("%s: i2c eeprom read error (err=%d)\n",
391 		       dev->name,err);
392 		return -1;
393 	}
394 
395 	for (i = 0; i < len; i += 16) {
396 		int size = (len - i) > 16 ? 16 : len - i;
397 
398 		pr_info("i2c eeprom %02x: %*ph\n", i, size, &eedata[i]);
399 	}
400 
401 	return 0;
402 }
403 
404 static char *i2c_devs[128] = {
405 	[ 0x20      ] = "mpeg encoder (saa6752hs)",
406 	[ 0xa0 >> 1 ] = "eeprom",
407 	[ 0xc0 >> 1 ] = "tuner (analog)",
408 	[ 0x86 >> 1 ] = "tda9887",
409 	[ 0x5a >> 1 ] = "remote control",
410 };
411 
412 static void do_i2c_scan(struct i2c_client *c)
413 {
414 	unsigned char buf;
415 	int i,rc;
416 
417 	for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
418 		c->addr = i;
419 		rc = i2c_master_recv(c,&buf,0);
420 		if (rc < 0)
421 			continue;
422 		pr_info("i2c scan: found device @ 0x%x  [%s]\n",
423 			 i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
424 	}
425 }
426 
427 int saa7134_i2c_register(struct saa7134_dev *dev)
428 {
429 	dev->i2c_adap = saa7134_adap_template;
430 	dev->i2c_adap.dev.parent = &dev->pci->dev;
431 	strscpy(dev->i2c_adap.name, dev->name, sizeof(dev->i2c_adap.name));
432 	dev->i2c_adap.algo_data = dev;
433 	i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
434 	i2c_add_adapter(&dev->i2c_adap);
435 
436 	dev->i2c_client = saa7134_client_template;
437 	dev->i2c_client.adapter = &dev->i2c_adap;
438 
439 	saa7134_i2c_eeprom(dev,dev->eedata,sizeof(dev->eedata));
440 	if (i2c_scan)
441 		do_i2c_scan(&dev->i2c_client);
442 
443 	/* Instantiate the IR receiver device, if present */
444 	saa7134_probe_i2c_ir(dev);
445 	return 0;
446 }
447 
448 int saa7134_i2c_unregister(struct saa7134_dev *dev)
449 {
450 	i2c_del_adapter(&dev->i2c_adap);
451 	return 0;
452 }
453