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