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