2 * Modified in order to keep it compatible both with new and old videotext IOCTLs by
3 * Michael Geng <linux@MichaelGeng.de>
5 * Cleaned up to use existing videodev interface and allow the idea
6 * of multiple teletext decoders on the video4linux iface. Changed i2c
7 * to cover addressing clashes on device busses. It's also rebuilt so
8 * you can add arbitary multiple teletext devices to Linux video4linux
9 * now (well 32 anyway).
11 * Alan Cox <alan@lxorguk.ukuu.org.uk>
13 * The original driver was heavily modified to match the i2c interface
14 * It was truncated to use the WinTV boards, too.
16 * Copyright (c) 1998 Richard Guenther <richard.guenther@student.uni-tuebingen.de>
21 * This is a loadable character-device-driver for videotext-interfaces
22 * (aka teletext). Please check the Makefile/README for a list of supported
25 * Copyright (c) 1994-97 Martin Buck <martin-2.buck@student.uni-ulm.de>
28 * This program is free software; you can redistribute it and/or modify
29 * it under the terms of the GNU General Public License as published by
30 * the Free Software Foundation; either version 2 of the License, or
31 * (at your option) any later version.
33 * This program is distributed in the hope that it will be useful,
34 * but WITHOUT ANY WARRANTY; without even the implied warranty of
35 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36 * GNU General Public License for more details.
38 * You should have received a copy of the GNU General Public License
39 * along with this program; if not, write to the Free Software
40 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
44 #include <linux/module.h>
45 #include <linux/kernel.h>
47 #include <linux/init.h>
48 #include <linux/i2c.h>
49 #include <linux/mutex.h>
50 #include <linux/delay.h>
51 #include <linux/videotext.h>
52 #include <linux/videodev2.h>
53 #include <linux/slab.h>
54 #include <media/v4l2-device.h>
55 #include <media/v4l2-chip-ident.h>
56 #include <media/v4l2-ioctl.h>
57 #include <media/v4l2-i2c-drv.h>
59 MODULE_AUTHOR("Michael Geng <linux@MichaelGeng.de>");
60 MODULE_DESCRIPTION("Philips SAA5249 Teletext decoder driver");
61 MODULE_LICENSE("GPL");
71 static const int disp_modes
[8][3] =
73 { 0x46, 0x03, 0x03 }, /* DISPOFF */
74 { 0x46, 0xcc, 0xcc }, /* DISPNORM */
75 { 0x44, 0x0f, 0x0f }, /* DISPTRANS */
76 { 0x46, 0xcc, 0x46 }, /* DISPINS */
77 { 0x44, 0x03, 0x03 }, /* DISPOFF, interlaced */
78 { 0x44, 0xcc, 0xcc }, /* DISPNORM, interlaced */
79 { 0x44, 0x0f, 0x0f }, /* DISPTRANS, interlaced */
80 { 0x44, 0xcc, 0x46 } /* DISPINS, interlaced */
85 #define PAGE_WAIT msecs_to_jiffies(300) /* Time between requesting page and */
86 /* checking status bits */
87 #define PGBUF_EXPIRE msecs_to_jiffies(15000) /* Time to wait before retransmitting */
88 /* page regardless of infobits */
90 u8 pgbuf
[VTX_VIRTUALSIZE
]; /* Page-buffer */
91 u8 laststat
[10]; /* Last value of infobits for DAU */
92 u8 sregs
[7]; /* Page-request registers */
93 unsigned long expire
; /* Time when page will be expired */
94 unsigned clrfound
: 1; /* VTXIOCCLRFOUND has been called */
95 unsigned stopped
: 1; /* VTXIOCSTOPDAU has been called */
100 struct v4l2_subdev sd
;
101 struct video_device
*vdev
;
102 vdau_t vdau
[NUM_DAUS
]; /* Data for virtual DAUs (the 5249 only has one */
103 /* real DAU, so we have to simulate some more) */
105 int is_searching
[NUM_DAUS
];
108 unsigned long in_use
;
112 static inline struct saa5249_device
*to_dev(struct v4l2_subdev
*sd
)
114 return container_of(sd
, struct saa5249_device
, sd
);
118 #define CCTWR 34 /* I²C write/read-address of vtx-chip */
120 #define NOACK_REPEAT 10 /* Retry access this many times on failure */
121 #define CLEAR_DELAY msecs_to_jiffies(50) /* Time required to clear a page */
122 #define READY_TIMEOUT msecs_to_jiffies(30) /* Time to wait for ready signal of I2C-bus interface */
123 #define INIT_DELAY 500 /* Time in usec to wait at initialization of CEA interface */
124 #define START_DELAY 10 /* Time in usec to wait before starting write-cycle (CEA) */
126 #define VTX_DEV_MINOR 0
128 static struct video_device saa_template
; /* Declared near bottom */
131 * Wait the given number of jiffies (10ms). This calls the scheduler, so the actual
132 * delay may be longer.
135 static void jdelay(unsigned long delay
)
137 sigset_t oldblocked
= current
->blocked
;
139 spin_lock_irq(¤t
->sighand
->siglock
);
140 sigfillset(¤t
->blocked
);
142 spin_unlock_irq(¤t
->sighand
->siglock
);
143 msleep_interruptible(jiffies_to_msecs(delay
));
145 spin_lock_irq(¤t
->sighand
->siglock
);
146 current
->blocked
= oldblocked
;
148 spin_unlock_irq(¤t
->sighand
->siglock
);
156 static int i2c_sendbuf(struct saa5249_device
*t
, int reg
, int count
, u8
*data
)
158 struct i2c_client
*client
= v4l2_get_subdevdata(&t
->sd
);
162 memcpy(buf
+1, data
, count
);
164 if (i2c_master_send(client
, buf
, count
+ 1) == count
+ 1)
169 static int i2c_senddata(struct saa5249_device
*t
, ...)
171 unsigned char buf
[64];
177 while ((v
= va_arg(argp
, int)) != -1)
181 return i2c_sendbuf(t
, buf
[0], ct
-1, buf
+1);
184 /* Get count number of bytes from I²C-device at address adr, store them in buf. Start & stop
185 * handshaking is done by this routine, ack will be sent after the last byte to inhibit further
186 * sending of data. If uaccess is 'true', data is written to user-space with put_user.
187 * Returns -1 if I²C-device didn't send acknowledge, 0 otherwise
190 static int i2c_getdata(struct saa5249_device
*t
, int count
, u8
*buf
)
192 struct i2c_client
*client
= v4l2_get_subdevdata(&t
->sd
);
194 if (i2c_master_recv(client
, buf
, count
) != count
)
201 * Standard character-device-driver functions
204 static long do_saa5249_ioctl(struct file
*file
, unsigned int cmd
, void *arg
)
206 static int virtual_mode
= false;
207 struct saa5249_device
*t
= video_drvdata(file
);
212 vtx_info_t
*info
= arg
;
213 info
->version_major
= VTX_VER_MAJ
;
214 info
->version_minor
= VTX_VER_MIN
;
215 info
->numpages
= NUM_DAUS
;
216 /*info->cct_type = CCT_TYPE;*/
222 vtx_pagereq_t
*req
= arg
;
224 if (req
->pgbuf
< 0 || req
->pgbuf
>= NUM_DAUS
)
226 memset(t
->vdau
[req
->pgbuf
].pgbuf
, ' ', sizeof(t
->vdau
[0].pgbuf
));
227 t
->vdau
[req
->pgbuf
].clrfound
= true;
233 vtx_pagereq_t
*req
= arg
;
235 if (req
->pgbuf
< 0 || req
->pgbuf
>= NUM_DAUS
)
237 t
->vdau
[req
->pgbuf
].clrfound
= true;
243 vtx_pagereq_t
*req
= arg
;
244 if (!(req
->pagemask
& PGMASK_PAGE
))
246 if (!(req
->pagemask
& PGMASK_HOUR
))
248 if (!(req
->pagemask
& PGMASK_MINUTE
))
250 if (req
->page
< 0 || req
->page
> 0x8ff) /* 7FF ?? */
253 if (req
->hour
< 0 || req
->hour
> 0x3f || req
->minute
< 0 || req
->minute
> 0x7f ||
254 req
->pagemask
< 0 || req
->pagemask
>= PGMASK_MAX
|| req
->pgbuf
< 0 || req
->pgbuf
>= NUM_DAUS
)
256 t
->vdau
[req
->pgbuf
].sregs
[0] = (req
->pagemask
& PG_HUND
? 0x10 : 0) | (req
->page
/ 0x100);
257 t
->vdau
[req
->pgbuf
].sregs
[1] = (req
->pagemask
& PG_TEN
? 0x10 : 0) | ((req
->page
/ 0x10) & 0xf);
258 t
->vdau
[req
->pgbuf
].sregs
[2] = (req
->pagemask
& PG_UNIT
? 0x10 : 0) | (req
->page
& 0xf);
259 t
->vdau
[req
->pgbuf
].sregs
[3] = (req
->pagemask
& HR_TEN
? 0x10 : 0) | (req
->hour
/ 0x10);
260 t
->vdau
[req
->pgbuf
].sregs
[4] = (req
->pagemask
& HR_UNIT
? 0x10 : 0) | (req
->hour
& 0xf);
261 t
->vdau
[req
->pgbuf
].sregs
[5] = (req
->pagemask
& MIN_TEN
? 0x10 : 0) | (req
->minute
/ 0x10);
262 t
->vdau
[req
->pgbuf
].sregs
[6] = (req
->pagemask
& MIN_UNIT
? 0x10 : 0) | (req
->minute
& 0xf);
263 t
->vdau
[req
->pgbuf
].stopped
= false;
264 t
->vdau
[req
->pgbuf
].clrfound
= true;
265 t
->is_searching
[req
->pgbuf
] = true;
271 vtx_pagereq_t
*req
= arg
;
276 if (req
->pgbuf
< 0 || req
->pgbuf
>= NUM_DAUS
)
278 if (!t
->vdau
[req
->pgbuf
].stopped
) {
279 if (i2c_senddata(t
, 2, 0, -1) ||
280 i2c_sendbuf(t
, 3, sizeof(t
->vdau
[0].sregs
), t
->vdau
[req
->pgbuf
].sregs
) ||
281 i2c_senddata(t
, 8, 0, 25, 0, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', -1) ||
282 i2c_senddata(t
, 2, 0, t
->vdau
[req
->pgbuf
].sregs
[0] | 8, -1) ||
283 i2c_senddata(t
, 8, 0, 25, 0, -1))
286 if (i2c_getdata(t
, 10, infobits
))
289 if (!(infobits
[8] & 0x10) && !(infobits
[7] & 0xf0) && /* check FOUND-bit */
290 (memcmp(infobits
, t
->vdau
[req
->pgbuf
].laststat
, sizeof(infobits
)) ||
291 time_after_eq(jiffies
, t
->vdau
[req
->pgbuf
].expire
)))
292 { /* check if new page arrived */
293 if (i2c_senddata(t
, 8, 0, 0, 0, -1) ||
294 i2c_getdata(t
, VTX_PAGESIZE
, t
->vdau
[req
->pgbuf
].pgbuf
))
296 t
->vdau
[req
->pgbuf
].expire
= jiffies
+ PGBUF_EXPIRE
;
297 memset(t
->vdau
[req
->pgbuf
].pgbuf
+ VTX_PAGESIZE
, ' ', VTX_VIRTUALSIZE
- VTX_PAGESIZE
);
298 if (t
->virtual_mode
) {
300 if (i2c_senddata(t
, 8, 0, 0x20, 0, -1) ||
301 i2c_getdata(t
, 40, t
->vdau
[req
->pgbuf
].pgbuf
+ VTX_PAGESIZE
+ 20 * 40))
304 if (i2c_senddata(t
, 8, 0, 0x21, 0, -1) ||
305 i2c_getdata(t
, 40, t
->vdau
[req
->pgbuf
].pgbuf
+ VTX_PAGESIZE
+ 16 * 40))
307 if (i2c_senddata(t
, 8, 0, 0x22, 0, -1) ||
308 i2c_getdata(t
, 40, t
->vdau
[req
->pgbuf
].pgbuf
+ VTX_PAGESIZE
+ 23 * 40))
311 t
->vdau
[req
->pgbuf
].clrfound
= false;
312 memcpy(t
->vdau
[req
->pgbuf
].laststat
, infobits
, sizeof(infobits
));
314 memcpy(infobits
, t
->vdau
[req
->pgbuf
].laststat
, sizeof(infobits
));
317 memcpy(infobits
, t
->vdau
[req
->pgbuf
].laststat
, sizeof(infobits
));
320 info
.pagenum
= ((infobits
[8] << 8) & 0x700) | ((infobits
[1] << 4) & 0xf0) | (infobits
[0] & 0x0f);
321 if (info
.pagenum
< 0x100)
322 info
.pagenum
+= 0x800;
323 info
.hour
= ((infobits
[5] << 4) & 0x30) | (infobits
[4] & 0x0f);
324 info
.minute
= ((infobits
[3] << 4) & 0x70) | (infobits
[2] & 0x0f);
325 info
.charset
= ((infobits
[7] >> 1) & 7);
326 info
.delete = !!(infobits
[3] & 8);
327 info
.headline
= !!(infobits
[5] & 4);
328 info
.subtitle
= !!(infobits
[5] & 8);
329 info
.supp_header
= !!(infobits
[6] & 1);
330 info
.update
= !!(infobits
[6] & 2);
331 info
.inter_seq
= !!(infobits
[6] & 4);
332 info
.dis_disp
= !!(infobits
[6] & 8);
333 info
.serial
= !!(infobits
[7] & 1);
334 info
.notfound
= !!(infobits
[8] & 0x10);
335 info
.pblf
= !!(infobits
[9] & 0x20);
337 for (a
= 0; a
<= 7; a
++) {
338 if (infobits
[a
] & 0xf0) {
343 if (t
->vdau
[req
->pgbuf
].clrfound
)
345 if (copy_to_user(req
->buffer
, &info
, sizeof(vtx_pageinfo_t
)))
347 if (!info
.hamming
&& !info
.notfound
)
348 t
->is_searching
[req
->pgbuf
] = false;
354 vtx_pagereq_t
*req
= arg
;
357 if (req
->pgbuf
< 0 || req
->pgbuf
>= NUM_DAUS
|| req
->start
< 0 ||
358 req
->start
> req
->end
|| req
->end
>= (virtual_mode
? VTX_VIRTUALSIZE
: VTX_PAGESIZE
))
360 if (copy_to_user(req
->buffer
, &t
->vdau
[req
->pgbuf
].pgbuf
[req
->start
], req
->end
- req
->start
+ 1))
364 * Always read the time directly from SAA5249
367 if (req
->start
<= 39 && req
->end
>= 32) {
370 start
= max(req
->start
, 32);
371 end
= min(req
->end
, 39);
372 len
= end
- start
+ 1;
373 if (i2c_senddata(t
, 8, 0, 0, start
, -1) ||
374 i2c_getdata(t
, len
, buf
))
376 if (copy_to_user(req
->buffer
+ start
- req
->start
, buf
, len
))
379 /* Insert the current header if DAU is still searching for a page */
380 if (req
->start
<= 31 && req
->end
>= 7 && t
->is_searching
[req
->pgbuf
]) {
384 start
= max(req
->start
, 7);
385 end
= min(req
->end
, 31);
386 len
= end
- start
+ 1;
387 if (i2c_senddata(t
, 8, 0, 0, start
, -1) ||
388 i2c_getdata(t
, len
, buf
))
390 if (copy_to_user(req
->buffer
+ start
- req
->start
, buf
, len
))
398 vtx_pagereq_t
*req
= arg
;
400 if (req
->pgbuf
< 0 || req
->pgbuf
>= NUM_DAUS
)
402 t
->vdau
[req
->pgbuf
].stopped
= true;
403 t
->is_searching
[req
->pgbuf
] = false;
414 if (i2c_senddata(t
, 0, NUM_DAUS
, 0, 8, -1) || i2c_senddata(t
, 11,
415 ' ', ' ', ' ', ' ', ' ', ' ',
416 ' ', ' ', ' ', ' ', ' ', ' ',
417 ' ', ' ', ' ', ' ', ' ', ' ',
418 ' ', ' ', ' ', ' ', ' ', ' ',
421 if (i2c_senddata(t
, 3, 0x20, -1))
423 jdelay(10 * CLEAR_DELAY
); /* I have no idea how long we have to wait here */
429 /* The SAA5249 has virtual-row reception turned on always */
430 t
->virtual_mode
= (int)(long)arg
;
438 * Translates old vtx IOCTLs to new ones
440 * This keeps new kernel versions compatible with old userspace programs.
442 static inline unsigned int vtx_fix_command(unsigned int cmd
)
445 case VTXIOCGETINFO_OLD
:
448 case VTXIOCCLRPAGE_OLD
:
451 case VTXIOCCLRFOUND_OLD
:
452 cmd
= VTXIOCCLRFOUND
;
454 case VTXIOCPAGEREQ_OLD
:
457 case VTXIOCGETSTAT_OLD
:
460 case VTXIOCGETPAGE_OLD
:
463 case VTXIOCSTOPDAU_OLD
:
466 case VTXIOCPUTPAGE_OLD
:
469 case VTXIOCSETDISP_OLD
:
472 case VTXIOCPUTSTAT_OLD
:
475 case VTXIOCCLRCACHE_OLD
:
476 cmd
= VTXIOCCLRCACHE
;
478 case VTXIOCSETVIRT_OLD
:
489 static long saa5249_ioctl(struct file
*file
,
490 unsigned int cmd
, unsigned long arg
)
492 struct saa5249_device
*t
= video_drvdata(file
);
495 cmd
= vtx_fix_command(cmd
);
496 mutex_lock(&t
->lock
);
497 err
= video_usercopy(file
, cmd
, arg
, do_saa5249_ioctl
);
498 mutex_unlock(&t
->lock
);
502 static int saa5249_open(struct file
*file
)
504 struct saa5249_device
*t
= video_drvdata(file
);
507 if (test_and_set_bit(0, &t
->in_use
))
510 if (i2c_senddata(t
, 0, 0, -1) || /* Select R11 */
511 /* Turn off parity checks (we do this ourselves) */
512 i2c_senddata(t
, 1, disp_modes
[t
->disp_mode
][0], 0, -1) ||
513 /* Display TV-picture, no virtual rows */
514 i2c_senddata(t
, 4, NUM_DAUS
, disp_modes
[t
->disp_mode
][1], disp_modes
[t
->disp_mode
][2], 7, -1))
515 /* Set display to page 4 */
517 clear_bit(0, &t
->in_use
);
521 for (pgbuf
= 0; pgbuf
< NUM_DAUS
; pgbuf
++) {
522 memset(t
->vdau
[pgbuf
].pgbuf
, ' ', sizeof(t
->vdau
[0].pgbuf
));
523 memset(t
->vdau
[pgbuf
].sregs
, 0, sizeof(t
->vdau
[0].sregs
));
524 memset(t
->vdau
[pgbuf
].laststat
, 0, sizeof(t
->vdau
[0].laststat
));
525 t
->vdau
[pgbuf
].expire
= 0;
526 t
->vdau
[pgbuf
].clrfound
= true;
527 t
->vdau
[pgbuf
].stopped
= true;
528 t
->is_searching
[pgbuf
] = false;
530 t
->virtual_mode
= false;
536 static int saa5249_release(struct file
*file
)
538 struct saa5249_device
*t
= video_drvdata(file
);
540 i2c_senddata(t
, 1, 0x20, -1); /* Turn off CCT */
541 i2c_senddata(t
, 5, 3, 3, -1); /* Turn off TV-display */
542 clear_bit(0, &t
->in_use
);
546 static const struct v4l2_file_operations saa_fops
= {
547 .owner
= THIS_MODULE
,
548 .open
= saa5249_open
,
549 .release
= saa5249_release
,
550 .ioctl
= saa5249_ioctl
,
553 static struct video_device saa_template
=
557 .release
= video_device_release
,
560 static int saa5249_g_chip_ident(struct v4l2_subdev
*sd
, struct v4l2_dbg_chip_ident
*chip
)
562 struct i2c_client
*client
= v4l2_get_subdevdata(sd
);
564 return v4l2_chip_ident_i2c_client(client
, chip
, V4L2_IDENT_SAA5249
, 0);
567 static const struct v4l2_subdev_core_ops saa5249_core_ops
= {
568 .g_chip_ident
= saa5249_g_chip_ident
,
571 static const struct v4l2_subdev_ops saa5249_ops
= {
572 .core
= &saa5249_core_ops
,
575 static int saa5249_probe(struct i2c_client
*client
,
576 const struct i2c_device_id
*id
)
580 struct saa5249_device
*t
;
581 struct v4l2_subdev
*sd
;
583 v4l_info(client
, "chip found @ 0x%x (%s)\n",
584 client
->addr
<< 1, client
->adapter
->name
);
585 v4l_info(client
, "VideoText version %d.%d\n",
586 VTX_VER_MAJ
, VTX_VER_MIN
);
587 t
= kzalloc(sizeof(*t
), GFP_KERNEL
);
591 v4l2_i2c_subdev_init(sd
, client
, &saa5249_ops
);
592 mutex_init(&t
->lock
);
594 /* Now create a video4linux device */
595 t
->vdev
= video_device_alloc();
596 if (t
->vdev
== NULL
) {
601 memcpy(t
->vdev
, &saa_template
, sizeof(*t
->vdev
));
603 for (pgbuf
= 0; pgbuf
< NUM_DAUS
; pgbuf
++) {
604 memset(t
->vdau
[pgbuf
].pgbuf
, ' ', sizeof(t
->vdau
[0].pgbuf
));
605 memset(t
->vdau
[pgbuf
].sregs
, 0, sizeof(t
->vdau
[0].sregs
));
606 memset(t
->vdau
[pgbuf
].laststat
, 0, sizeof(t
->vdau
[0].laststat
));
607 t
->vdau
[pgbuf
].expire
= 0;
608 t
->vdau
[pgbuf
].clrfound
= true;
609 t
->vdau
[pgbuf
].stopped
= true;
610 t
->is_searching
[pgbuf
] = false;
612 video_set_drvdata(t
->vdev
, t
);
615 err
= video_register_device(t
->vdev
, VFL_TYPE_VTX
, -1);
617 video_device_release(t
->vdev
);
624 static int saa5249_remove(struct i2c_client
*client
)
626 struct v4l2_subdev
*sd
= i2c_get_clientdata(client
);
627 struct saa5249_device
*t
= to_dev(sd
);
629 video_unregister_device(t
->vdev
);
630 v4l2_device_unregister_subdev(sd
);
635 static const struct i2c_device_id saa5249_id
[] = {
639 MODULE_DEVICE_TABLE(i2c
, saa5249_id
);
641 static struct v4l2_i2c_driver_data v4l2_i2c_data
= {
643 .probe
= saa5249_probe
,
644 .remove
= saa5249_remove
,
645 .id_table
= saa5249_id
,