Attachment #60450 for bug #94814

View | Details | Raw Unified | Return to bug 94814
Collapse All | Expand All





README for the SCSI media changer driver
========================================

This is a driver for SCSI Medium Changer devices, which are listed
with "Type: Medium Changer" in /proc/scsi/scsi.

This is for *real* Jukeboxes.  It is *not* supported to work with
common small CD-ROM changers, neither one-lun-per-slot SCSI changers
nor IDE drives.

Userland tools available from here:
	http://linux.bytesex.org/misc/changer.html


General Information
-------------------

First some words about how changers work: A changer has 2 (possibly
more) SCSI ID's. One for the changer device which controls the robot,
and one for the device which actually reads and writes the data. The
later may be anything, a MOD, a CD-ROM, a tape or whatever. For the
changer device this is a "don't care", he *only* shuffles around the
media, nothing else.


The SCSI changer model is complex, compared to - for example - IDE-CD
changers. But it allows to handle nearly all possible cases. It knows
4 different types of changer elements:

  media transport - this one shuffles around the media, i.e. the
                    transport arm.  Also known as "picker".
  storage         - a slot which can hold a media.
  import/export   - the same as above, but is accessable from outside,
                    i.e. there the operator (you !) can use this to
                    fill in and remove media from the changer.
		    Sometimes named "mailslot".
  data transfer   - this is the device which reads/writes, i.e. the
		    CD-ROM / Tape / whatever drive.

None of these is limited to one: A huge Jukebox could have slots for
123 CD-ROM's, 5 CD-ROM readers (and therefore 6 SCSI ID's: the changer
and each CD-ROM) and 2 transport arms. No problem to handle.


How it is implemented
---------------------

I implemented the driver as character device driver with a NetBSD-like
ioctl interface. Just grabbed NetBSD's header file and one of the
other linux SCSI device drivers as starting point. The interface
should be source code compatible with NetBSD. So if there is any
software (anybody knows ???) which supports a BSDish changer driver,
it should work with this driver too.

Over time a few more ioctls where added, volume tag support for example
wasn't covered by the NetBSD ioctl API.


Current State
-------------

Support for more than one transport arm is not implemented yet (and
nobody asked for it so far...).

I test and use the driver myself with a 35 slot cdrom jukebox from
Grundig.  I got some reports telling it works ok with tape autoloaders
(Exabyte, HP and DEC).  Some People use this driver with amanda.  It
works fine with small (11 slots) and a huge (4 MOs, 88 slots)
magneto-optical Jukebox.  Probably with lots of other changers too, most
(but not all :-) people mail me only if it does *not* work...

I don't have any device lists, neither black-list nor white-list.  Thus
it is quite useless to ask me whenever a specific device is supported or
not.  In theory every changer device which supports the SCSI-2 media
changer command set should work out-of-the-box with this driver.  If it
doesn't, it is a bug.  Either within the driver or within the firmware
of the changer device.


Using it
--------

This is a character device with major number is 86, so use
"mknod /dev/sch0 c 86 0" to create the special file for the driver.

If the module finds the changer, it prints some messages about the
device [ try "dmesg" if you don't see anything ] and should show up in
/proc/devices. If not....  some changers use ID ? / LUN 0 for the
device and ID ? / LUN 1 for the robot mechanism. But Linux does *not*
look for LUN's other than 0 as default, becauce there are to many
broken devices. So you can try:

  1) echo "scsi add-single-device 0 0 ID 1" > /proc/scsi/scsi
     (replace ID with the SCSI-ID of the device)
  2) boot the kernel with "max_scsi_luns=1" on the command line
     (append="max_scsi_luns=1" in lilo.conf should do the trick)


Trouble?
--------

If you insmod the driver with "insmod debug=1", it will be verbose and
prints a lot of stuff to the syslog.  Compiling the kernel with
CONFIG_SCSI_CONSTANTS=y improves the quality of the error messages alot
because the kernel will translate the error codes into human-readable
strings then.

You can display these messages with the dmesg command (or check the
logfiles).  If you email me some question becauce of a problem with the
driver, please include these messages.


Insmod options
--------------

debug=0/1
	Enable debug messages (see above, default: 0).

verbose=0/1
	Be verbose (default: 1).

init=0/1
	Send INITIALIZE ELEMENT STATUS command to the changer
	at insmod time (default: 1).

timeout_init=<seconds>
	timeout for the INITIALIZE ELEMENT STATUS command
	(default: 3600).

timeout_move=<seconds>
	timeout for all other commands (default: 120).

dt_id=<id1>,<id2>,...
dt_lun=<lun1>,<lun2>,...
	These two allow to specify the SCSI ID and LUN for the data
	transfer elements.  You likely don't need this as the jukebox
	should provide this information.  But some devices don't ...

vendor_firsts=
vendor_counts=
vendor_labels=
	These insmod options can be used to tell the driver that there
	are some vendor-specific element types.  Grundig for example
	does this.  Some jukeboxes have a printer to label fresh burned
	CDs, which is addressed as element 0xc000 (type 5).  To tell the
	driver about this vendor-specific element, use this:
		$ insmod ch			\
			vendor_firsts=0xc000	\
			vendor_counts=1		\
			vendor_labels=printer
	All three insmod options accept up to four comma-separated
	values, this way you can configure the element types 5-8.
	You likely need the SCSI specs for the device in question to
	find the correct values as they are not covered by the SCSI-2
	standard.


Credits
-------

I wrote this driver using the famous mailing-patches-around-the-world
method.  With (more or less) help from:

	Daniel Moehwald <moehwald@hdg.de>
	Dane Jasper <dane@sonic.net>
	R. Scott Bailey <sbailey@dsddi.eds.com>
	Jonathan Corbet <corbet@lwn.net>

Special thanks go to
	Martin Kuehne <martin.kuehne@bnbt.de>
for a old, second-hand (but full functional) cdrom jukebox which I use
to develop/test driver and tools now.

Have fun,

   Gerd

-- 
Gerd Knorr <kraxel@bytesex.org>




  5 -> SKNet Monster TV                         [1131:4e85]
  6 -> Tevion MD 9717                          
  7 -> KNC One TV-Station RDS / Typhoon TV Tuner RDS [1131:fe01,1894:fe01]
  8 -> Terratec Cinergy 400 TV                  [153B:1142]
  9 -> Medion 5044                             
 10 -> Kworld/KuroutoShikou SAA7130-TVPCI      
 11 -> Terratec Cinergy 600 TV                  [153B:1143]
 12 -> Medion 7134                              [16be:0003]
 13 -> Typhoon TV+Radio 90031                  
 14 -> ELSA EX-VISION 300TV                     [1048:226b]
 15 -> ELSA EX-VISION 500TV                     [1048:226b]
 16 -> ASUS TV-FM 7134                          [1043:4842,1043:4830,1043:4840]
 17 -> AOPEN VA1000 POWER                       [1131:7133]
 18 -> BMK MPEX No Tuner                       
 19 -> Compro VideoMate TV                      [185b:c100]
 20 -> Matrox CronosPlus                        [102B:48d0]
 21 -> 10MOONS PCI TV CAPTURE CARD              [1131:2001]
 22 -> Medion 2819/ AverMedia M156              [1461:a70b,1461:2115]
 23 -> BMK MPEX Tuner                          
 24 -> KNC One TV-Station DVR                   [1894:a006]
 25 -> ASUS TV-FM 7133                          [1043:4843]
 26 -> Pinnacle PCTV Stereo (saa7134)           [11bd:002b]
 27 -> Manli MuchTV M-TV002                    
 28 -> Manli MuchTV M-TV001                    
 29 -> Nagase Sangyo TransGear 3000TV           [1461:050c]
 30 -> Elitegroup ECS TVP3XP FM1216 Tuner Card(PAL-BG,FM)  [1019:4cb4]
 31 -> Elitegroup ECS TVP3XP FM1236 Tuner Card (NTSC,FM) [1019:4cb5]
 32 -> AVACS SmartTV                           
 33 -> AVerMedia DVD EZMaker                    [1461:10ff]
 34 -> LifeView FlyTV Platinum33 mini           [5168:0212]

Lines 11-19 current status Link Here

(-)linux-2.6.11.orig/Documentation/video4linux/README.cx88 (-3 lines)
11	video	11	video
12	- Basically works.	12	- Basically works.
13	- Some minor image quality glitches.	13	- Some minor image quality glitches.
14	- Red and blue are swapped sometimes for not-yet known
15	reasons (seems to depend on the image size, try to resize
16	your tv app window as workaround ...).
17	- For now only capture, overlay support isn't completed yet.	14	- For now only capture, overlay support isn't completed yet.
18		15
19	audio	16	audio

Lines 1-9 Link Here

(-)linux-2.6.11.orig/Documentation/video4linux/bttv/Cards (-2 / +5 lines)
1		1
2	Gunther Mayer's bttv card gallery (graphical version of this text file :-)	2	Gunther Mayer's bttv card gallery (graphical version of this text file :-)
3	is available at: http://mayerg.gmxhome.de/bttv/bttv-gallery.html	3	is available at: http://www.bttv-gallery.de/
4		4
5		5
6	Suppported cards:	6	Supported cards:
7	Bt848/Bt848a/Bt849/Bt878/Bt879 cards	7	Bt848/Bt848a/Bt849/Bt878/Bt879 cards
8	------------------------------------	8	------------------------------------
9		9
Lines 166-171 Lifeview Flyvideo Series: Link Here
166	or Flyvideo 3000 (SAA7134) w/Stereo TV	166	or Flyvideo 3000 (SAA7134) w/Stereo TV
167	These exist in variations w/FM and w/Remote sometimes denoted	167	These exist in variations w/FM and w/Remote sometimes denoted
168	by suffixes "FM" and "R".	168	by suffixes "FM" and "R".
		169	3) You have a laptop (miniPCI card):
		170	Product = FlyTV Platinum Mini
		171	Model/Chip = LR212/saa7135
169		172
170	Lifeview.com.tw states (Feb. 2002):	173	Lifeview.com.tw states (Feb. 2002):
171	"The FlyVideo2000 and FlyVideo2000s product name have renamed to FlyVideo98."	174	"The FlyVideo2000 and FlyVideo2000s product name have renamed to FlyVideo98."

Lines 22-28 very likely specified the wrong (or no) Link Here

(-)linux-2.6.11.orig/Documentation/video4linux/bttv/README (-1 / +1 lines)
22	cards is in CARDLIST.bttv	22	cards is in CARDLIST.bttv
23		23
24	If bttv takes very long to load (happens sometimes with the cheap	24	If bttv takes very long to load (happens sometimes with the cheap
25	cards which have no tuner), try adding this to your modprobe.conf:	25	cards which have no tuner), try adding this to your modules.conf:
26	options i2c-algo-bit bit_test=1	26	options i2c-algo-bit bit_test=1
27		27
28	For the WinTV/PVR you need one firmware file from the driver CD:	28	For the WinTV/PVR you need one firmware file from the driver CD:

Lines 501-507 P: Gerd Knorr Link Here

(-)linux-2.6.11.orig/MAINTAINERS (-2 / +3 lines)
501	M: kraxel@bytesex.org	501	M: kraxel@bytesex.org
502	L: video4linux-list@redhat.com	502	L: video4linux-list@redhat.com
503	W: http://bytesex.org/bttv/	503	W: http://bytesex.org/bttv/
504	S: Maintained	504	S: Orphan
505		505
506	BUSLOGIC SCSI DRIVER	506	BUSLOGIC SCSI DRIVER
507	P: Leonard N. Zubkoff	507	P: Leonard N. Zubkoff
Lines 2534-2540 S: Maintained Link Here
2534	VIDEO FOR LINUX	2534	VIDEO FOR LINUX
2535	P: Gerd Knorr	2535	P: Gerd Knorr
2536	M: kraxel@bytesex.org	2536	M: kraxel@bytesex.org
2537	S: Maintained	2537	L: video4linux-list@redhat.com
		2538	S: Orphan
2538		2539
2539	W1 DALLAS'S 1-WIRE BUS	2540	W1 DALLAS'S 1-WIRE BUS
2540	P: Evgeniy Polyakov	2541	P: Evgeniy Polyakov




#define CODE
#include "compat_ioctl.c"
  
#ifndef TIOCGDEV
#define TIOCGDEV       _IOR('T',0x32, unsigned int)
#endif
static int tiocgdev(unsigned fd, unsigned cmd,  unsigned int __user *ptr) 
{ 

	struct file *file = fget(fd);
	struct tty_struct *real_tty;

	if (!file)
		return -EBADF;
	if (file->f_op->ioctl != tty_ioctl)
		return -EINVAL; 
	real_tty = (struct tty_struct *)file->private_data;
	if (!real_tty) 	
		return -EINVAL; 
	return put_user(new_encode_dev(tty_devnum(real_tty)), ptr); 
} 

#define RTC_IRQP_READ32	_IOR('p', 0x0b, unsigned int)	 /* Read IRQ rate   */
#define RTC_IRQP_SET32	_IOW('p', 0x0c, unsigned int)	 /* Set IRQ rate    */
#define RTC_EPOCH_READ32	_IOR('p', 0x0d, unsigned)	 /* Read epoch      */

COMPATIBLE_IOCTL(FIOQSIZE)

/* And these ioctls need translation */
HANDLE_IOCTL(TIOCGDEV, tiocgdev)
/* realtime device */
HANDLE_IOCTL(RTC_IRQP_READ,  rtc32_ioctl)
HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl)




		case TIOCMBIC:
		case TIOCMBIS:
			return tty_tiocmset(tty, file, cmd, p);
		/*
		 * Without the real device to which /dev/console is connected,
		 * blogd can not work.
		 *	blogd spawns a pty/tty pair,
		 *	set /dev/console to the tty of that pair (ioctl TIOCCONS),
		 *	then reads in all input from the current /dev/console,
		 *	buffer or write the readed data to /var/log/boot.msg
		 *	_and_ to the original real device.
		 */
		case TIOCGDEV:
		{
			unsigned int ret = new_encode_dev(tty_devnum(real_tty));
			return put_user(ret, (unsigned int __user *)p);
		}

	}
	if (tty->driver->ioctl) {
		retval = (tty->driver->ioctl)(tty, file, cmd, arg);

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/common/ir-common.c (-2 / +162 lines)
1	/*	1	/*
2	* $Id: ir-common.c,v 1.6 2004/12/10 12:33:39 kraxel Exp $	2	* $Id: ir-common.c,v 1.8 2005/02/22 12:28:40 kraxel Exp $
3	*	3	*
4	* some common structs and functions to handle infrared remotes via	4	* some common structs and functions to handle infrared remotes via
5	* input layer ...	5	* input layer ...
Lines 23-29 Link Here
23		23
24	#include <linux/module.h>	24	#include <linux/module.h>
25	#include <linux/moduleparam.h>	25	#include <linux/moduleparam.h>
26
27	#include <media/ir-common.h>	26	#include <media/ir-common.h>
28		27
29	/* -------------------------------------------------------------------------- */	28	/* -------------------------------------------------------------------------- */
Lines 45-50 module_param(debug, int, 0644); Link Here
45		44
46	/* generic RC5 keytable */	45	/* generic RC5 keytable */
47	/* see http://users.pandora.be/nenya/electronics/rc5/codes00.htm */	46	/* see http://users.pandora.be/nenya/electronics/rc5/codes00.htm */
		47	/* used by old (black) Hauppauge remotes */
48	IR_KEYTAB_TYPE ir_codes_rc5_tv[IR_KEYTAB_SIZE] = {	48	IR_KEYTAB_TYPE ir_codes_rc5_tv[IR_KEYTAB_SIZE] = {
49	[ 0x00 ] = KEY_KP0, // 0	49	[ 0x00 ] = KEY_KP0, // 0
50	[ 0x01 ] = KEY_KP1, // 1	50	[ 0x01 ] = KEY_KP1, // 1
Lines 117-128 IR_KEYTAB_TYPE ir_codes_rc5_tv[IR_KEYTAB Link Here
117	};	117	};
118	EXPORT_SYMBOL_GPL(ir_codes_rc5_tv);	118	EXPORT_SYMBOL_GPL(ir_codes_rc5_tv);
119		119
		120	/* Table for Leadtek Winfast Remote Controls - used by both bttv and cx88 */
		121	IR_KEYTAB_TYPE ir_codes_winfast[IR_KEYTAB_SIZE] = {
		122	[ 5 ] = KEY_KP1,
		123	[ 6 ] = KEY_KP2,
		124	[ 7 ] = KEY_KP3,
		125	[ 9 ] = KEY_KP4,
		126	[ 10 ] = KEY_KP5,
		127	[ 11 ] = KEY_KP6,
		128	[ 13 ] = KEY_KP7,
		129	[ 14 ] = KEY_KP8,
		130	[ 15 ] = KEY_KP9,
		131	[ 18 ] = KEY_KP0,
		132
		133	[ 0 ] = KEY_POWER,
		134	// [ 27 ] = MTS button
		135	[ 2 ] = KEY_TUNER, // TV/FM
		136	[ 30 ] = KEY_VIDEO,
		137	// [ 22 ] = display button
		138	[ 4 ] = KEY_VOLUMEUP,
		139	[ 8 ] = KEY_VOLUMEDOWN,
		140	[ 12 ] = KEY_CHANNELUP,
		141	[ 16 ] = KEY_CHANNELDOWN,
		142	[ 3 ] = KEY_ZOOM, // fullscreen
		143	[ 31 ] = KEY_SUBTITLE, // closed caption/teletext
		144	[ 32 ] = KEY_SLEEP,
		145	// [ 41 ] = boss key
		146	[ 20 ] = KEY_MUTE,
		147	[ 43 ] = KEY_RED,
		148	[ 44 ] = KEY_GREEN,
		149	[ 45 ] = KEY_YELLOW,
		150	[ 46 ] = KEY_BLUE,
		151	[ 24 ] = KEY_KPPLUS, //fine tune +
		152	[ 25 ] = KEY_KPMINUS, //fine tune -
		153	// [ 42 ] = picture in picture
		154	[ 33 ] = KEY_KPDOT,
		155	[ 19 ] = KEY_KPENTER,
		156	// [ 17 ] = recall
		157	[ 34 ] = KEY_BACK,
		158	[ 35 ] = KEY_PLAYPAUSE,
		159	[ 36 ] = KEY_NEXT,
		160	// [ 37 ] = time shifting
		161	[ 38 ] = KEY_STOP,
		162	[ 39 ] = KEY_RECORD
		163	// [ 40 ] = snapshot
		164	};
		165	EXPORT_SYMBOL_GPL(ir_codes_winfast);
		166
120	/* empty keytable, can be used as placeholder for not-yet created keytables */	167	/* empty keytable, can be used as placeholder for not-yet created keytables */
121	IR_KEYTAB_TYPE ir_codes_empty[IR_KEYTAB_SIZE] = {	168	IR_KEYTAB_TYPE ir_codes_empty[IR_KEYTAB_SIZE] = {
122	[ 42 ] = KEY_COFFEE,	169	[ 42 ] = KEY_COFFEE,
123	};	170	};
124	EXPORT_SYMBOL_GPL(ir_codes_empty);	171	EXPORT_SYMBOL_GPL(ir_codes_empty);
125		172
		173	/* Hauppauge: the newer, gray remotes (seems there are multiple
		174	* slightly different versions), shipped with cx88+ivtv cards.
		175	* almost rc5 coding, but some non-standard keys */
		176	IR_KEYTAB_TYPE ir_codes_hauppauge_new[IR_KEYTAB_SIZE] = {
		177	[ 0x00 ] = KEY_KP0, // 0
		178	[ 0x01 ] = KEY_KP1, // 1
		179	[ 0x02 ] = KEY_KP2, // 2
		180	[ 0x03 ] = KEY_KP3, // 3
		181	[ 0x04 ] = KEY_KP4, // 4
		182	[ 0x05 ] = KEY_KP5, // 5
		183	[ 0x06 ] = KEY_KP6, // 6
		184	[ 0x07 ] = KEY_KP7, // 7
		185	[ 0x08 ] = KEY_KP8, // 8
		186	[ 0x09 ] = KEY_KP9, // 9
		187	[ 0x0b ] = KEY_RED, // red button
		188	[ 0x0c ] = KEY_OPTION, // black key without text
		189	[ 0x0d ] = KEY_MENU, // menu
		190	[ 0x0f ] = KEY_MUTE, // mute
		191	[ 0x10 ] = KEY_VOLUMEUP, // volume +
		192	[ 0x11 ] = KEY_VOLUMEDOWN, // volume -
		193	[ 0x1e ] = KEY_NEXT, // skip >\|
		194	[ 0x1f ] = KEY_EXIT, // back/exit
		195	[ 0x20 ] = KEY_CHANNELUP, // channel / program +
		196	[ 0x21 ] = KEY_CHANNELDOWN, // channel / program -
		197	[ 0x22 ] = KEY_CHANNEL, // source (old black remote)
		198	[ 0x24 ] = KEY_PREVIOUS, // replay \|<
		199	[ 0x25 ] = KEY_ENTER, // OK
		200	[ 0x26 ] = KEY_SLEEP, // minimize (old black remote)
		201	[ 0x29 ] = KEY_BLUE, // blue key
		202	[ 0x2e ] = KEY_GREEN, // green button
		203	[ 0x30 ] = KEY_PAUSE, // pause
		204	[ 0x32 ] = KEY_REWIND, // backward <<
		205	[ 0x34 ] = KEY_FASTFORWARD, // forward >>
		206	[ 0x35 ] = KEY_PLAY, // play
		207	[ 0x36 ] = KEY_STOP, // stop
		208	[ 0x37 ] = KEY_RECORD, // recording
		209	[ 0x38 ] = KEY_YELLOW, // yellow key
		210	[ 0x3b ] = KEY_SELECT, // top right button
		211	[ 0x3c ] = KEY_ZOOM, // full
		212	[ 0x3d ] = KEY_POWER, // system power (green button)
		213	};
		214	EXPORT_SYMBOL(ir_codes_hauppauge_new);
		215
126	/* -------------------------------------------------------------------------- */	216	/* -------------------------------------------------------------------------- */
127		217
128	static void ir_input_key_event(struct input_dev dev, struct ir_input_state ir)	218	static void ir_input_key_event(struct input_dev dev, struct ir_input_state ir)
Lines 192-197 void ir_input_keydown(struct input_dev * Link Here
192	#endif	282	#endif
193	}	283	}
194		284
		285	/* -------------------------------------------------------------------------- */
		286
195	u32 ir_extract_bits(u32 data, u32 mask)	287	u32 ir_extract_bits(u32 data, u32 mask)
196	{	288	{
197	int mbit, vbit;	289	int mbit, vbit;
Lines 209-218 u32 ir_extract_bits(u32 data, u32 mask) Link Here
209	return value;	301	return value;
210	}	302	}
211		303
		304	static int inline getbit(u32 *samples, int bit)
		305	{
		306	return (samples[bit/32] & (1 << (31-(bit%32)))) ? 1 : 0;
		307	}
		308
		309	/* sump raw samples for visual debugging ;) */
		310	int ir_dump_samples(u32 *samples, int count)
		311	{
		312	int i, bit, start;
		313
		314	printk(KERN_DEBUG "ir samples: ");
		315	start = 0;
		316	for (i = 0; i < count * 32; i++) {
		317	bit = getbit(samples,i);
		318	if (bit)
		319	start = 1;
		320	if (0 == start)
		321	continue;
		322	printk("%s", bit ? "#" : "_");
		323	}
		324	printk("\n");
		325	return 0;
		326	}
		327
		328	/* decode raw samples, biphase coding, used by rc5 for example */
		329	int ir_decode_biphase(u32 *samples, int count, int low, int high)
		330	{
		331	int i,last,bit,len,flips;
		332	u32 value;
		333
		334	/* find start bit (1) */
		335	for (i = 0; i < 32; i++) {
		336	bit = getbit(samples,i);
		337	if (bit)
		338	break;
		339	}
		340
		341	/* go decoding */
		342	len = 0;
		343	flips = 0;
		344	value = 1;
		345	for (; i < count * 32; i++) {
		346	if (len > high)
		347	break;
		348	if (flips > 1)
		349	break;
		350	last = bit;
		351	bit = getbit(samples,i);
		352	if (last == bit) {
		353	len++;
		354	continue;
		355	}
		356	if (len < low) {
		357	len++;
		358	flips++;
		359	continue;
		360	}
		361	value <<= 1;
		362	value \|= bit;
		363	flips = 0;
		364	len = 1;
		365	}
		366	return value;
		367	}
368
212	EXPORT_SYMBOL_GPL(ir_input_init);	369	EXPORT_SYMBOL_GPL(ir_input_init);
213	EXPORT_SYMBOL_GPL(ir_input_nokey);	370	EXPORT_SYMBOL_GPL(ir_input_nokey);
214	EXPORT_SYMBOL_GPL(ir_input_keydown);	371	EXPORT_SYMBOL_GPL(ir_input_keydown);
		372
215	EXPORT_SYMBOL_GPL(ir_extract_bits);	373	EXPORT_SYMBOL_GPL(ir_extract_bits);
		374	EXPORT_SYMBOL_GPL(ir_dump_samples);
		375	EXPORT_SYMBOL_GPL(ir_decode_biphase);
216		376
217	/*	377	/*
218	* Local variables:	378	* Local variables:




	return 0;
}
EXPORT_SYMBOL(dvb_unregister_frontend);

void dvb_suspend_frontend(struct dvb_frontend* fe)
{
	if (fe->ops->sleep)
		fe->ops->sleep(fe);
}
EXPORT_SYMBOL(dvb_suspend_frontend);

void dvb_resume_frontend(struct dvb_frontend* fe)
{
	struct dvb_frontend_private *fepriv = fe->frontend_priv;

	if (fe->ops->init)
		fe->ops->init(fe);
	fepriv->state = FESTATE_RETUNE;
	dvb_frontend_wakeup(fe);
	dvb_frontend_add_event (fe, 0);	    
	fepriv->status = 0;
}
EXPORT_SYMBOL(dvb_resume_frontend);


Lines 122-126 extern int dvb_register_frontend(struct Link Here

(-)linux-2.6.11.orig/drivers/media/dvb/dvb-core/dvb_frontend.h (+2 lines)
122	struct dvb_frontend* fe);	122	struct dvb_frontend* fe);
123		123
124	extern int dvb_unregister_frontend(struct dvb_frontend* fe);	124	extern int dvb_unregister_frontend(struct dvb_frontend* fe);
		125	extern void dvb_suspend_frontend(struct dvb_frontend* fe);
		126	extern void dvb_resume_frontend(struct dvb_frontend* fe);
125		127
126	#endif	128	#endif

Lines 157-160 config DVB_NXT2002 Link Here

(-)linux-2.6.11.orig/drivers/media/dvb/frontends/Kconfig (+4 lines)
157	help	157	help
158	An ATSC 8VSB tuner module. Say Y when you want to support this frontend.	158	An ATSC 8VSB tuner module. Say Y when you want to support this frontend.
159		159
		160	config DVB_OR51132
		161	tristate "OR51132 based (pcHDTV)"
		162	depends on DVB_CORE
		163
160	endmenu	164	endmenu

Lines 4-9 Link Here

(-)linux-2.6.11.orig/drivers/media/dvb/frontends/Makefile (-1 / +2 lines)
4		4
5	EXTRA_CFLAGS = -Idrivers/media/dvb/dvb-core/	5	EXTRA_CFLAGS = -Idrivers/media/dvb/dvb-core/
6		6
		7	obj-$(CONFIG_DVB_CORE) += dvb-pll.o
7	obj-$(CONFIG_DVB_STV0299) += stv0299.o	8	obj-$(CONFIG_DVB_STV0299) += stv0299.o
8	obj-$(CONFIG_DVB_SP8870) += sp8870.o	9	obj-$(CONFIG_DVB_SP8870) += sp8870.o
9	obj-$(CONFIG_DVB_CX22700) += cx22700.o	10	obj-$(CONFIG_DVB_CX22700) += cx22700.o
Lines 25-28 obj-$(CONFIG_DVB_TDA80XX) += tda80xx.o Link Here
25	obj-$(CONFIG_DVB_TDA10021) += tda10021.o	26	obj-$(CONFIG_DVB_TDA10021) += tda10021.o
26	obj-$(CONFIG_DVB_STV0297) += stv0297.o	27	obj-$(CONFIG_DVB_STV0297) += stv0297.o
27	obj-$(CONFIG_DVB_NXT2002) += nxt2002.o	28	obj-$(CONFIG_DVB_NXT2002) += nxt2002.o
28		29	obj-$(CONFIG_DVB_OR51132) += or51132.o




/*
    Conexant 22702 DVB OFDM frontend driver

    based on:
        Alps TDMB7 DVB OFDM frontend driver

    Copyright (C) 2001-2002 Convergence Integrated Media GmbH
	  Holger Waechtler <holger@convergence.de>

#include <linux/string.h>
#include <linux/slab.h>
#include <linux/delay.h>

#include "dvb_frontend.h"
#include "dvb-pll.h"
#include "cx22702.h"

#define FRONTEND_NAME "dvbfe_cx22702"

#define dprintk	if (debug) printk

	struct i2c_adapter* i2c;

	struct dvb_frontend_ops ops;

static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "Enable verbose debug messages");

/* ------------------------------------------------------------------ */

struct cx22702_state {
	const struct cx22702_config     *config;
	struct i2c_client               demod;
	struct i2c_client               pll;
	struct dvb_frontend             fe;
	struct dvb_frontend_ops         ops;
	u8 prevUCBlocks;
};

static struct i2c_client demod_template;
static struct i2c_client pll_template;

/* Register values to initialise the demod */
static u8 init_tab[] = {
	0x00, 0x00, /* Stop aquisition */
	0x0B, 0x06,
	0x09, 0x01,

	0xfd, 0x00,
};

/* ------------------------------------------------------------------ */

static int writereg(struct i2c_client *c, u8 reg, u8 data)
{
	u8 buf[] = { reg, data };
	int ret;
	u8 buf [] = { reg, data };
	struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };

	ret = i2c_master_send(c, buf, 2);
	if (ret != 2) {
	if (ret != 1)
		printk("%s: writereg error (reg == 0x%02x, val == 0x%02x, ret == %i)\n",
		       __FUNCTION__, reg, data, ret);
		return -1;
	}
	return 0;
}

static int readreg(struct i2c_client *c, u8 reg)
{
	u8 wr [] = { reg };
	u8 rd [] = { 0 };
	struct i2c_msg msg [] = {
		{ .addr = c->addr, .flags = 0,        .buf = wr, .len = 1 },
		{ .addr = c->addr, .flags = I2C_M_RD, .buf = rd, .len = 1 },
	};
	int ret;

	ret = i2c_transfer(c->adapter, msg, 2);
	if (ret != 2) {
		printk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
		return -1;
	}
	return rd[0];
}

/* ------------------------------------------------------------------ */

#define PLL_ENABLE(cx)  writereg(&cx->demod, 0x0D, readreg(&cx->demod, 0x0D) & 0xfe)
#define PLL_DISABLE(cx) writereg(&cx->demod, 0x0D, readreg(&cx->demod, 0x0D) | 0x01)

static int pll_write4(struct i2c_client *c, u8 *data)
{
	int ret;
	u8 b0 [] = { reg };
	u8 b1 [] = { 0 };

	ret = i2c_master_send(c, data, 4);
	if (ret != 4) {
		printk("%s: i/o error (addr == 0x%02x, ret == %i)\n",
		       __FUNCTION__, c->addr, ret);
		return -EIO;
	}
	return 0;
}

/* ------------------------------------------------------------------ */

static int cx22702_reset(struct cx22702_state *state)
{
	int i;

	dprintk("%s\n",__FUNCTION__);
	writereg(&state->demod, 0x00, 0x02);
	msleep(10);

	for (i=0; i<ARRAY_SIZE(init_tab); i+=2)
		writereg(&state->demod, init_tab[i], init_tab[i+1]);
	return 0;
}

static int cx22702_set_inversion(struct cx22702_state *state, int inversion)
{
	u8 val;

	switch (inversion) {
	case INVERSION_AUTO:
		return -EOPNOTSUPP;

	case INVERSION_ON:
		val = readreg(&state->demod, 0x0C);
		return writereg(&state->demod, 0x0C, val | 0x01);
		case INVERSION_ON:
			val = cx22702_readreg (state, 0x0C);
			return cx22702_writereg (state, 0x0C, val | 0x01);

		case INVERSION_OFF:
			val = cx22702_readreg (state, 0x0C);
			return cx22702_writereg (state, 0x0C, val & 0xfe);

	case INVERSION_OFF:
		val = readreg(&state->demod, 0x0C);
		return writereg(&state->demod, 0x0C, val & 0xfe);

	default:
		return -EINVAL;
	}

}

/* Retrieve the demod settings */
static int cx22702_get_tps(struct cx22702_state *state,
			   struct dvb_ofdm_parameters *p)
{
	u8 val;

	/* Make sure the TPS regs are valid */
	if (!(readreg(&state->demod, 0x0A) & 0x20))
		return -EAGAIN;

	val = readreg(&state->demod, 0x01);
	switch( (val&0x18)>>3) {
		case 0: p->constellation =   QPSK; break;
		case 1: p->constellation = QAM_16; break;

		case 3: p->hierarchy_information =    HIERARCHY_4; break;
	}

	val = readreg(&state->demod, 0x02);
	val = cx22702_readreg (state, 0x02);
	switch( (val&0x38)>>3 ) {
		case 0: p->code_rate_HP = FEC_1_2; break;
		case 1: p->code_rate_HP = FEC_2_3; break;

		case 4: p->code_rate_LP = FEC_7_8; break;
	}

	val = readreg(&state->demod, 0x03);
	val = cx22702_readreg (state, 0x03);
	switch( (val&0x0c)>>2 ) {
		case 0: p->guard_interval = GUARD_INTERVAL_1_32; break;
		case 1: p->guard_interval = GUARD_INTERVAL_1_16; break;
		case 2: p->guard_interval =  GUARD_INTERVAL_1_8; break;
		case 3: p->guard_interval =  GUARD_INTERVAL_1_4; break;
	}
	switch( val&0x03 ) {
		case 0: p->transmission_mode = TRANSMISSION_MODE_2K; break;
		case 1: p->transmission_mode = TRANSMISSION_MODE_8K; break;

	return 0;
}













/* Talk to the demod, set the FEC, GUARD, QAM settings etc */
static int cx22702_set_tps(struct cx22702_state *state,
			   struct dvb_frontend_parameters *p)
{
	u8 val;
	u8 pllbuf[4];

	dprintk("%s\n",__FUNCTION__);

	/* set PLL */
	dvb_pll_configure(state->config->pll_desc, pllbuf,
			  p->frequency,
			  p->u.ofdm.bandwidth);
	PLL_ENABLE(state);
	pll_write4(&state->pll,pllbuf);
	PLL_DISABLE(state);

	/* set inversion */
	cx22702_set_inversion(state, p->inversion);

	/* set bandwidth */
	switch(p->u.ofdm.bandwidth) {
	case BANDWIDTH_6_MHZ:
		writereg(&state->demod, 0x0C, (readreg(&state->demod, 0x0C) & 0xcf) | 0x20 );
		break;
	case BANDWIDTH_7_MHZ:
		writereg(&state->demod, 0x0C, (readreg(&state->demod, 0x0C) & 0xcf) | 0x10 );
		break;
	case BANDWIDTH_8_MHZ:
		writereg(&state->demod, 0x0C, readreg(&state->demod, 0x0C) &0xcf );
		break;
	default:
		dprintk ("%s: invalid bandwidth\n",__FUNCTION__);

	   (p->u.ofdm.transmission_mode==TRANSMISSION_MODE_AUTO) ) {

		/* TPS Source - use hardware driven values */
		writereg(&state->demod, 0x06, 0x10);
		writereg(&state->demod, 0x07, 0x9);
		writereg(&state->demod, 0x08, 0xC1);
		writereg(&state->demod, 0x0B, readreg(&state->demod, 0x0B) & 0xfc );
		writereg(&state->demod, 0x0C, (readreg(&state->demod, 0x0C) & 0xBF) | 0x40 );
		writereg(&state->demod, 0x00, 0x01); /* Begin aquisition */
		dprintk("%s: Autodetecting\n",__FUNCTION__);
		return 0;
	}


			dprintk ("%s: invalid hierarchy\n",__FUNCTION__);
			return -EINVAL;
	}
	writereg(&state->demod, 0x06, val);

	val=0;
	switch(p->u.ofdm.code_rate_HP) {

			dprintk ("%s: invalid code_rate_LP\n",__FUNCTION__);
			return -EINVAL;
	}
	writereg(&state->demod, 0x07, val);

	val=0;
	switch(p->u.ofdm.guard_interval) {

			dprintk ("%s: invalid transmission_mode\n",__FUNCTION__);
			return -EINVAL;
	}
	writereg(&state->demod, 0x08, val);
	writereg(&state->demod, 0x0B, (readreg(&state->demod, 0x0B) & 0xfc) | 0x02 );
	writereg(&state->demod, 0x0C, (readreg(&state->demod, 0x0C) & 0xBF) | 0x40 );

	/* Begin channel aquisition */
	writereg(&state->demod, 0x00, 0x01);

	return 0;
}

/* ------------------------------------------------------------------ */

static int cx22702_init(struct dvb_frontend* fe)
   to a default state. */
static int cx22702_init (struct dvb_frontend* fe)
{
	struct cx22702_state *state = fe->demodulator_priv;
	struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;

	cx22702_writereg (state, 0x00, 0x02);

	msleep(10);

	for (i=0; i<sizeof(init_tab); i+=2)
		cx22702_writereg (state, init_tab[i], init_tab[i+1]);


	/* init PLL */
	if (state->config->pll_init) {
	        cx22702_writereg (state, 0x0D, cx22702_readreg(state,0x0D) &0xfe);
		state->config->pll_init(fe);
		cx22702_writereg (state, 0x0D, cx22702_readreg(state,0x0D) | 1);
	}

	cx22702_reset(state);
	return 0;
}

static int cx22702_read_status(struct dvb_frontend* fe, fe_status_t* status)
{
	struct cx22702_state *state = fe->demodulator_priv;
	u8 reg0A = readreg(&state->demod, 0x0A);
	u8 reg23 = readreg(&state->demod, 0x23);

			*status = 0;

	reg0A = cx22702_readreg (state, 0x0A);
	reg23 = cx22702_readreg (state, 0x23);

			dprintk ("%s: status demod=0x%02x agc=0x%02x\n"
				,__FUNCTION__,reg0A,reg23);

			if(reg0A & 0x10) {
				*status |= FE_HAS_LOCK;
				*status |= FE_HAS_VITERBI;
				*status |= FE_HAS_SYNC;
			}

			if(reg0A & 0x20)
				*status |= FE_HAS_CARRIER;

	*status = 0;
	if (reg0A & 0x10)
		*status |= FE_HAS_LOCK| FE_HAS_VITERBI | FE_HAS_SYNC;
	if (reg0A & 0x20)
		*status |= FE_HAS_CARRIER;
	if (reg23 < 0xf0)
		*status |= FE_HAS_SIGNAL;

	dprintk ("%s: status demod=0x%02x agc=0x%02x status=0x%x\n",
		 __FUNCTION__,reg0A,reg23,*status);
	return 0;
}

static int cx22702_read_ber(struct dvb_frontend* fe, u32* ber)
{
	struct cx22702_state *state = fe->demodulator_priv;

	if(cx22702_readreg (state, 0xE4) & 0x02) {
				/* Realtime statistics */
		*ber = (cx22702_readreg (state, 0xDE) & 0x7F) << 7
			| (cx22702_readreg (state, 0xDF)&0x7F);
			} else {
		/* Averagtine statistics */
		*ber = (cx22702_readreg (state, 0xDE) & 0x7F) << 7
			| cx22702_readreg (state, 0xDF);
		}

	*ber = (readreg(&state->demod, 0xDE) & 0x7F) << 7;
	*ber |= readreg(&state->demod, 0xDF) & 0x7F;
	return 0;
}

static int cx22702_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
		{
	struct cx22702_state* state = (struct cx22702_state*) fe->demodulator_priv;

static int cx22702_read_signal_strength(struct dvb_frontend* fe, u16* strength)
{
	struct cx22702_state *state = fe->demodulator_priv;
	u8 signal;

	signal = readreg(&state->demod, 0x23);
	*strength = ((signal<<8) | signal);
	return 0;
}

static int cx22702_read_snr(struct dvb_frontend* fe, u16* snr)
{
	u32 ber;

	u16 rs_ber=0;
	if(cx22702_readreg (state, 0xE4) & 0x02) {
		/* Realtime statistics */
		rs_ber = (cx22702_readreg (state, 0xDE) & 0x7F) << 7
			| (cx22702_readreg (state, 0xDF)& 0x7F);
	} else {
		/* Averagine statistics */
		rs_ber = (cx22702_readreg (state, 0xDE) & 0x7F) << 8
			| cx22702_readreg (state, 0xDF);
	}
	*snr = ~rs_ber;

	/* We don't have an register for this         */
	/* We'll take the inverse of the BER register */
	cx22702_read_ber(fe, &ber);
	*snr = ~ber;
	return 0;
}

static int cx22702_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
{
	struct cx22702_state *state = fe->demodulator_priv;
	u8 ucb;
	u8 _ucblocks;

	/* RS Uncorrectable Packet Count then reset */
	ucb = readreg(&state->demod, 0xE3);
	if (state->prevUCBlocks <= ucb)
		*ucblocks = (ucb - state->prevUCBlocks);
	else
		*ucblocks = 256 + ucb - state->prevUCBlocks;
	state->prevUCBlocks = ucb;
	return 0;
}

static int cx22702_get_frontend(struct dvb_frontend* fe,
				struct dvb_frontend_parameters* params)
{
	struct cx22702_state *state = fe->demodulator_priv;
	u8 reg0C = readreg(&state->demod, 0x0C);
	params->inversion = reg0C & 0x1 ? INVERSION_ON : INVERSION_OFF;
	return cx22702_get_tps(state, &params->u.ofdm);
}

static int cx22702_set_frontend(struct dvb_frontend* fe,
				struct dvb_frontend_parameters* params)
{
	struct cx22702_state *state = fe->demodulator_priv;
	int ret;

	ret=cx22702_set_tps(state, params);
	if (debug && ret < 0)
		printk("%s: set_tps failed ret=%d\n",__FUNCTION__,ret);
	return ret;
}

static void cx22702_release(struct dvb_frontend* fe)
{
	struct cx22702_state *state = fe->demodulator_priv;
		kfree(state);
	}

	i2c_detach_client(&state->demod);
	i2c_detach_client(&state->pll);
	kfree(state);
}

static int cx22702_sleep(struct dvb_frontend* fe)
				    struct i2c_adapter* i2c)
{
	struct cx22702_state *state = fe->demodulator_priv;
	u8 pllbuf[4];
	/* allocate memory for the internal state */
	state = (struct cx22702_state*) kmalloc(sizeof(struct cx22702_state), GFP_KERNEL);
	if (state == NULL) goto error;

	/* setup the state */
	state->config = config;
	state->i2c = i2c;
	memcpy(&state->ops, &cx22702_ops, sizeof(struct dvb_frontend_ops));
	state->prevUCBlocks = 0;

	/* check if the demod is there */
	if (cx22702_readreg(state, 0x1f) != 0x3) goto error;

	dprintk("%s\n",__FUNCTION__);
	state->frontend.ops = &state->ops;
	state->frontend.demodulator_priv = state;
	return &state->frontend;

	dvb_pll_configure(state->config->pll_desc, pllbuf, 0, 0);
	PLL_ENABLE(state);
	pll_write4(&state->pll,pllbuf);
	PLL_DISABLE(state);
	return 0;
}

static struct dvb_frontend_ops cx22702_fe_ops = {

	.info = {
		.name			= "cx22702 demod",
		.type			= FE_OFDM,
		.frequency_min		= 177000000,
		.frequency_max		= 858000000,
		.frequency_stepsize	= 166666,
		.caps =
		FE_CAN_FEC_1_2 |
		FE_CAN_FEC_2_3 |
		FE_CAN_FEC_3_4 |
		FE_CAN_FEC_5_6 |
		FE_CAN_FEC_7_8 |
		FE_CAN_FEC_AUTO |
		FE_CAN_QPSK |
		FE_CAN_QAM_16 |
		FE_CAN_QAM_64 |
		FE_CAN_QAM_AUTO |
		FE_CAN_HIERARCHY_AUTO |
		FE_CAN_GUARD_INTERVAL_AUTO |
		FE_CAN_TRANSMISSION_MODE_AUTO |
		FE_CAN_RECOVER,
	},
	.init                 = cx22702_init,
	.sleep                = cx22702_sleep,
	.set_frontend         = cx22702_set_frontend,
	.get_frontend         = cx22702_get_frontend,
	.read_status          = cx22702_read_status,
	.read_ber             = cx22702_read_ber,
	.read_signal_strength = cx22702_read_signal_strength,
	.read_snr             = cx22702_read_snr,
	.read_ucblocks        = cx22702_read_ucblocks,
	.release              = cx22702_release,
};

/* ------------------------------------------------------------------ */

/* Validate the demod, make sure we understand the hardware */
static int cx22702_validate_demod(struct i2c_client *c)
{
	int type = readreg(c, 0x1f);

	if (0x03 != type) {
		printk ("%s i2c demod type 0x%02x not known\n",
			__FUNCTION__, type);
		return -ENODEV;
	}
	return 0;
}

/* Validate the tuner PLL, make sure we understand the hardware */
static int cx22702_validate_pll(struct cx22702_state *state)
{
	int result=0;

	PLL_ENABLE(state);
	result = readreg(&state->pll,0xc2);
	PLL_DISABLE(state);
	return result;
}

struct dvb_frontend* cx22702_attach(const struct cx22702_config* config,
				    struct i2c_adapter* i2c)
{
	struct cx22702_state *state;
	int ret;

	state = kmalloc(sizeof(*state), GFP_KERNEL);
	if (NULL == state)
		return NULL;
	memset(state, 0, sizeof(*state));

	state->config              = config;
	state->ops                 = cx22702_fe_ops;
	state->fe.demodulator_priv = state;
	state->fe.ops              = &state->ops;

	state->demod         = demod_template;
	state->demod.adapter = i2c;
	state->demod.addr    = config->demod_address;
	state->pll           = pll_template;
	strlcpy(state->pll.name, config->pll_desc->name, sizeof(state->pll.name));
	state->pll.adapter   = i2c;
	state->pll.addr      = config->pll_address;
	i2c_set_clientdata(&state->demod, state);
	i2c_set_clientdata(&state->pll, state);

	/* verify devices */
	ret=cx22702_validate_demod(&state->demod);
	if (ret < 0)
		goto fail_free;
	ret=cx22702_validate_pll(state);
	if(ret < 0)
		goto fail_free;

	/* register i2c */
	ret = i2c_attach_client(&state->demod);
	if (0 != ret) {
		printk("cx22702: i2c demod register failed (%d)\n", ret);
		goto fail_free;
	}
	ret = i2c_attach_client(&state->pll);
	if (0 != ret) {
		printk("cx22702: i2c pll register failed (%d)\n", ret);
		goto fail_unreg1;
	}

	/* all fine ;) */
	return &state->fe;

fail_unreg1:
	i2c_detach_client(&state->demod);
fail_free:
	kfree(state);
	return NULL;
}
EXPORT_SYMBOL(cx22702_attach);

/* ------------------------------------------------------------------ */

static struct i2c_driver demod_driver = {
	.owner = THIS_MODULE,
	.name  = __stringify(KBUILD_MODNAME) " demod",
	.id    = I2C_DRIVERID_DVBFE_CX22702,
};
static struct i2c_client demod_template = {
	.name   = "cx22702",
	.flags  = I2C_CLIENT_ALLOW_USE,
	.driver = &demod_driver,
};

static struct i2c_driver pll_driver = {
	.owner = THIS_MODULE,
	.name  = __stringify(KBUILD_MODNAME) " pll",
	.id    = I2C_DRIVERID_DVBFE_CX22702,
};
static struct i2c_client pll_template = {
	.name   = "unset",
	.flags  = I2C_CLIENT_ALLOW_USE,
	.driver = &pll_driver,
};

static int __init init_cx22702 (void)
{
	i2c_add_driver(&demod_driver);
	i2c_add_driver(&pll_driver);
	return 0;
}

static void __exit exit_cx22702 (void)
{
	i2c_del_driver(&pll_driver);
	i2c_del_driver(&demod_driver);
}

module_init (init_cx22702);
module_exit (exit_cx22702);

MODULE_DESCRIPTION("CX22702 DVB Frontend driver");
MODULE_AUTHOR("Steven Toth");
MODULE_AUTHOR("Gerd Knorr");
MODULE_LICENSE("GPL");

/*
 * Local variables:
 * c-basic-offset: 8
 * compile-command: "make DVB=1"
 * End:
 */

Lines 36-43 struct cx22702_config Link Here

(-)linux-2.6.11.orig/drivers/media/dvb/frontends/cx22702.h (+6 lines)
36	u8 demod_address;	36	u8 demod_address;
37		37
38	/* PLL maintenance */	38	/* PLL maintenance */
		39	u8 pll_address;
		40	struct dvb_pll_desc *pll_desc;
		41
		42	#if 0 /* disabled for now, but maybe we'll need it again for plls
		43	* which don't fit into the dvb_pll_desc model ... */
39	int (pll_init)(struct dvb_frontend fe);	44	int (pll_init)(struct dvb_frontend fe);
40	int (pll_set)(struct dvb_frontend fe, struct dvb_frontend_parameters* params);	45	int (pll_set)(struct dvb_frontend fe, struct dvb_frontend_parameters* params);
		46	#endif
41	};	47	};
42		48
43	extern struct dvb_frontend* cx22702_attach(const struct cx22702_config* config,	49	extern struct dvb_frontend* cx22702_attach(const struct cx22702_config* config,




/*
 * $Id: dvb-pll.c,v 1.7 2005/02/10 11:52:02 kraxel Exp $
 *
 * descriptions + helper functions for simple dvb plls.
 *
 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/dvb/frontend.h>
#include <asm/types.h>

#include "dvb-pll.h"

/* ----------------------------------------------------------- */
/* descriptions                                                */

struct dvb_pll_desc dvb_pll_thomson_dtt7579 = {
	.name  = "Thomson dtt7579",
	.min   = 177000000,
	.max   = 858000000,
	.count = 5,
	.entries = {
		{          0, 36166667, 166666, 0xb4, 0x03 }, /* go sleep */
		{  443250000, 36166667, 166666, 0xb4, 0x02 },
		{  542000000, 36166667, 166666, 0xb4, 0x08 },
		{  771000000, 36166667, 166666, 0xbc, 0x08 },
		{  999999999, 36166667, 166666, 0xf4, 0x08 },
	},
};
EXPORT_SYMBOL(dvb_pll_thomson_dtt7579);

struct dvb_pll_desc dvb_pll_thomson_dtt7610 = {
	.name  = "Thomson dtt7610",
	.min   =  44000000,
	.max   = 958000000,
	.count = 3,
	.entries = {
		{ 157250000, 44000000, 62500, 0x8e, 0x39 },
		{ 454000000, 44000000, 62500, 0x8e, 0x3a },
		{ 999999999, 44000000, 62500, 0x8e, 0x3c },
	},
};
EXPORT_SYMBOL(dvb_pll_thomson_dtt7610);

static void thomson_dtt759x_bw(u8 *buf, int bandwidth)
{
	if (BANDWIDTH_7_MHZ == bandwidth)
		buf[3] |= 0x10;
}

struct dvb_pll_desc dvb_pll_thomson_dtt759x = {
	.name  = "Thomson dtt759x",
	.min   = 177000000,
	.max   = 896000000,
	.setbw = thomson_dtt759x_bw,
	.count = 6,
	.entries = {
		{          0, 36166667, 166666, 0x84, 0x03 },
		{  264000000, 36166667, 166666, 0xb4, 0x02 },
		{  470000000, 36166667, 166666, 0xbc, 0x02 },
		{  735000000, 36166667, 166666, 0xbc, 0x08 },
		{  835000000, 36166667, 166666, 0xf4, 0x08 },
		{  999999999, 36166667, 166666, 0xfc, 0x08 },
	},
};
EXPORT_SYMBOL(dvb_pll_thomson_dtt759x);

struct dvb_pll_desc dvb_pll_lg_z201 = {
	.name  = "LG z201",
	.min   = 174000000,
	.max   = 862000000,
	.count = 5,
	.entries = {
		{          0, 36166667, 166666, 0xbc, 0x03 },
		{  443250000, 36166667, 166666, 0xbc, 0x01 },
		{  542000000, 36166667, 166666, 0xbc, 0x02 },
		{  830000000, 36166667, 166666, 0xf4, 0x02 },
		{  999999999, 36166667, 166666, 0xfc, 0x02 },
	},
};
EXPORT_SYMBOL(dvb_pll_lg_z201);

struct dvb_pll_desc dvb_pll_unknown_1 = {
	.name  = "unknown 1", /* used by dntv live dvb-t */
	.min   = 174000000,
	.max   = 862000000,
	.count = 9,
	.entries = {
		{  150000000, 36166667, 166666, 0xb4, 0x01 },
		{  173000000, 36166667, 166666, 0xbc, 0x01 },
		{  250000000, 36166667, 166666, 0xb4, 0x02 },
		{  400000000, 36166667, 166666, 0xbc, 0x02 },
		{  420000000, 36166667, 166666, 0xf4, 0x02 },
		{  470000000, 36166667, 166666, 0xfc, 0x02 },
		{  600000000, 36166667, 166666, 0xbc, 0x08 },
		{  730000000, 36166667, 166666, 0xf4, 0x08 },
		{  999999999, 36166667, 166666, 0xfc, 0x08 },
	},
};
EXPORT_SYMBOL(dvb_pll_unknown_1);

/* ----------------------------------------------------------- */
/* code                                                        */

static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable verbose debug messages");

int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf,
		      u32 freq, int bandwidth)
{
	u32 div;
	int i;

	if (freq != 0 && (freq < desc->min || freq > desc->max))
	    return -EINVAL;

	for (i = 0; i < desc->count; i++) {
		if (freq > desc->entries[i].limit)
			continue;
		break;
	}
	if (debug)
		printk("pll: %s: freq=%d bw=%d | i=%d/%d\n",
		       desc->name, freq, bandwidth, i, desc->count);
	BUG_ON(i == desc->count);

	div = (freq + desc->entries[i].offset) / desc->entries[i].stepsize;
	buf[0] = div >> 8;
	buf[1] = div & 0xff;
	buf[2] = desc->entries[i].cb1;
	buf[3] = desc->entries[i].cb2;

	if (desc->setbw)
		desc->setbw(buf, bandwidth);

	if (debug)
		printk("pll: %s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
		       desc->name, div, buf[0], buf[1], buf[2], buf[3]);

	return 0;
}
EXPORT_SYMBOL(dvb_pll_configure);

MODULE_DESCRIPTION("dvb pll library");
MODULE_AUTHOR("Gerd Knorr");
MODULE_LICENSE("GPL");

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */




/*
 * $Id: dvb-pll.h,v 1.2 2005/02/10 11:43:41 kraxel Exp $
 */

struct dvb_pll_desc {
	char *name;
	u32  min;
	u32  max;
	void (*setbw)(u8 *buf, int bandwidth);
	int  count;
	struct {
		u32 limit;
		u32 offset;
		u32 stepsize;
		u8  cb1;
		u8  cb2;
	} entries[];
};

extern struct dvb_pll_desc dvb_pll_thomson_dtt7579;
extern struct dvb_pll_desc dvb_pll_thomson_dtt759x;
extern struct dvb_pll_desc dvb_pll_thomson_dtt7610;
extern struct dvb_pll_desc dvb_pll_lg_z201;
extern struct dvb_pll_desc dvb_pll_unknown_1;

int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf,
		      u32 freq, int bandwidth);

/*
 * Local variables:
 * c-basic-offset: 8
 * compile-command: "make DVB=1"
 * End:
 */




#include "mt352.h"

struct mt352_state {

	struct i2c_adapter* i2c;

	struct dvb_frontend_ops ops;

	/* configuration settings */
	const struct mt352_config* config;
	int s0,s1,s3;

	struct dvb_frontend frontend;
};

			       .buf = buf, .len = 2 };
	int err = i2c_transfer(state->i2c, &msg, 1);
	if (err != 1) {
		printk("mt352_write() to reg %x failed (err = %d)!\n", reg, err);
		return err;
	}
	return 0;
}

int mt352_write(struct dvb_frontend* fe, u8* ibuf, int ilen)
{
	int err,i;
	for (i=0; i < ilen-1; i++)
		if ((err = mt352_single_write(fe,ibuf[0]+i,ibuf[i+1])))
			return err;

	return 0;
}

static int mt352_read_register(struct mt352_state* state, u8 reg)
{
	int ret;
	u8 b0 [] = { reg };


	ret = i2c_transfer(state->i2c, msg, 2);

	if (ret != 2) {
		printk("%s: readreg error (reg=%d, ret==%i)\n",
		       __FUNCTION__, reg, ret);
		return ret;
	}

	return b1[0];
}

int mt352_read(struct dvb_frontend *fe, u8 reg)
{
	return mt352_read_register(fe->demodulator_priv,reg);
}

static int mt352_sleep(struct dvb_frontend* fe)
{
	static u8 mt352_softdown[] = { CLOCK_CTL, 0x20, 0x08 };

	mt352_write(fe, mt352_softdown, sizeof(mt352_softdown));
	return 0;
}

static void mt352_calc_nominal_rate(struct mt352_state* state,
				    enum fe_bandwidth bandwidth,
				    unsigned char *buf)
{
	u32 adc_clock = 20480; /* 20.340 MHz */
	u32 bw,value;

	switch (bandwidth) {
	case BANDWIDTH_6_MHZ:
		bw = 6;
		break;
	case BANDWIDTH_7_MHZ:
		bw = 7;
		break;
	case BANDWIDTH_8_MHZ:
	default:
		bw = 8;
		break;
	}
	if (state->config->adc_clock)
		adc_clock = state->config->adc_clock;

	value = 64 * bw * (1<<16) / (7 * 8);
	value = value * 1000 / adc_clock;
	dprintk("%s: bw %d, adc_clock %d => 0x%x\n",
		__FUNCTION__, bw, adc_clock, value);
	buf[0] = msb(value);
	buf[1] = lsb(value);
}

static void mt352_calc_input_freq(struct mt352_state* state,
				  unsigned char *buf)
static int mt352_sleep(struct dvb_frontend* fe)
{
	int adc_clock = 20480; /* 20.480000 MHz */
	int if2       = 36167; /* 36.166667 MHz */
	int ife,value;

	if (state->config->adc_clock)
		adc_clock = state->config->adc_clock;
	if (state->config->if2)
		if2 = state->config->if2;

	ife = (2*adc_clock - if2);
	value = -16374 * ife / adc_clock;
	dprintk("%s: if2 %d, ife %d, adc_clock %d => %d / 0x%x\n",
		__FUNCTION__, if2, ife, adc_clock, value, value & 0x3fff);
	buf[0] = msb(value);
	buf[1] = lsb(value);
}

static int mt352_set_parameters(struct dvb_frontend* fe,
				struct dvb_frontend_parameters *param)
{
	struct mt352_state* state = (struct mt352_state*) fe->demodulator_priv;
	unsigned char buf[13];
	static unsigned char tuner_go[] = { 0x5d, 0x01 };
	static unsigned char fsm_go[]   = { 0x5e, 0x01 };
	unsigned int tps = 0;
	struct dvb_ofdm_parameters *op = &param->u.ofdm;
	int i;

	switch (op->code_rate_HP) {
		case FEC_2_3:

	buf[1] = msb(tps);      /* TPS_GIVEN_(1|0) */
	buf[2] = lsb(tps);

	buf[3] = 0x50;  // old
//	buf[3] = 0xf4;  // pinnacle
	/**
	 *  these settings assume 20.48MHz f_ADC, for other tuners you might
	 *  need other values. See p. 33 in the MT352 Design Manual.
	 */
	if (op->bandwidth == BANDWIDTH_8_MHZ) {
		buf[4] = 0x72;  /* TRL_NOMINAL_RATE_(1|0) */
		buf[5] = 0x49;
	} else if (op->bandwidth == BANDWIDTH_7_MHZ) {
		buf[4] = 0x64;
		buf[5] = 0x00;
	} else {		/* 6MHz */
		buf[4] = 0x55;
		buf[5] = 0xb7;
	}

	buf[6] = 0x31;  /* INPUT_FREQ_(1|0), 20.48MHz clock, 36.166667MHz IF */
	buf[7] = 0x05;  /* see MT352 Design Manual page 32 for details */

	mt352_calc_nominal_rate(state, op->bandwidth, buf+4);
	mt352_calc_input_freq(state, buf+6);
	state->config->pll_set(fe, param, buf+8);

#if 0 /* FIXME: should be catched elsewhere ... */

	/* Only send the tuning request if the tuner doesn't have the requested
	 * parameters already set.  Enhances tuning time and prevents stream
	 * breakup when retuning the same transponder. */
	for (i = 1; i < 13; i++)
		if (buf[i] != mt352_read_register(state, i + 0x50))
			mt352_write(fe, buf, sizeof(buf));
			break;
	if (13 == i)
		/* no changes */
		return 0;
#endif

	mt352_write(fe, buf, sizeof(buf));
	if (state->config->no_tuner) {
		/* start decoding */
		mt352_write(fe, fsm_go, 2);
	} else {
		/* start tuning */
		mt352_write(fe, tuner_go, 2);
	}
	return 0;
}


static int mt352_read_status(struct dvb_frontend* fe, fe_status_t* status)
{
	struct mt352_state* state = (struct mt352_state*) fe->demodulator_priv;
#if 1
	int val;
		*status = 0;
	r = mt352_read_register (state, STATUS_0);
		if (r & (1 << 4))
			*status = FE_HAS_CARRIER;
		if (r & (1 << 1))
			*status |= FE_HAS_VITERBI;
		if (r & (1 << 5))
			*status |= FE_HAS_LOCK;

	if (0 != mt352_read_register(state, INTERRUPT_0)) {
		val = mt352_read_register(state, STATUS_0);
		if (-1 != val)
			state->s0 = val;
		val = mt352_read_register(state, STATUS_1);
		if (-1 != val)
			state->s1 = val;
		val = mt352_read_register(state, STATUS_3);
		if (-1 != val)
			state->s3 = val;
	}
#else
	state->s0 = mt352_read_register(state, STATUS_0);
	state->s1 = mt352_read_register(state, STATUS_1);
	state->s3 = mt352_read_register(state, STATUS_3);
	if (-1 == state->s0 || -1 == state->s1 || -1 == state->s3)
		return -EIO;
#endif

	*status = 0;
	if (state->s0 & (1 << 4))
		*status |= FE_HAS_CARRIER;
	if (state->s0 & (1 << 1))
		*status |= FE_HAS_VITERBI;
	if (state->s0 & (1 << 5))
		*status |= FE_HAS_LOCK;
	if (state->s1 & (1 << 1))
		*status |= FE_HAS_SYNC;
	if (state->s3 & (1 << 6))
		*status |= FE_HAS_SIGNAL;

	if ((*status & (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC)) !=
		      (FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC))

	fe_tune_settings->max_drift = 0;

	return 0;
}

static int mt352_init(struct dvb_frontend* fe)
{


	static u8 mt352_reset_attach [] = { RESET, 0xC0 };

	dprintk("%s: hello\n",__FUNCTION__);

	if ((mt352_read_register(state, CLOCK_CTL) & 0x10) == 0 ||
	    (mt352_read_register(state, CONFIG) & 0x20) == 0) {

		/* Do a "hard" reset */
		mt352_write(fe, mt352_reset_attach, sizeof(mt352_reset_attach));
		return state->config->demod_init(fe);
	}

	return 0;
}

static void mt352_release(struct dvb_frontend* fe)
{
	struct mt352_state* state = (struct mt352_state*) fe->demodulator_priv;
	kfree(state);
}

static struct dvb_frontend_ops mt352_ops;


	/* allocate memory for the internal state */
	state = (struct mt352_state*) kmalloc(sizeof(struct mt352_state), GFP_KERNEL);
	if (state == NULL) goto error;
	memset(state,0,sizeof(*state));

	/* setup the state */
	state->config = config;

EXPORT_SYMBOL(mt352_attach);
EXPORT_SYMBOL(mt352_write);
EXPORT_SYMBOL(mt352_read);
/*
 * Local variables:
 * c-basic-offset: 8
 * compile-command: "make DVB=1"
 * End:
 */

Lines 40-45 struct mt352_config Link Here

(-)linux-2.6.11.orig/drivers/media/dvb/frontends/mt352.h (-1 / +14 lines)
40	/* the demodulator's i2c address */	40	/* the demodulator's i2c address */
41	u8 demod_address;	41	u8 demod_address;
42		42
		43	/* frequencies in kHz */
		44	int adc_clock; // default: 20480
		45	int if2; // default: 36166
		46
		47	/* set if no pll is connected to the secondary i2c bus */
		48	int no_tuner;
		49
43	/* Initialise the demodulator and PLL. Cannot be NULL */	50	/* Initialise the demodulator and PLL. Cannot be NULL */
44	int (demod_init)(struct dvb_frontend fe);	51	int (demod_init)(struct dvb_frontend fe);
45		52
Lines 54-59 extern struct dvb_frontend* mt352_attach Link Here
54	struct i2c_adapter* i2c);	61	struct i2c_adapter* i2c);
55		62
56	extern int mt352_write(struct dvb_frontend* fe, u8* ibuf, int ilen);	63	extern int mt352_write(struct dvb_frontend* fe, u8* ibuf, int ilen);
57	extern u8 mt352_read(struct dvb_frontend *fe, u8 reg);	64	extern int mt352_read(struct dvb_frontend *fe, u8 reg);
58		65
59	#endif // MT352_H	66	#endif // MT352_H
		67
		68	/*
		69	* Local variables:
		70	* c-basic-offset: 8
		71	* End:
		72	*/




/*
 *    Support for OR51132 (pcHDTV HD-3000) - VSB/QAM
 *
 *    Copyright (C) 2005 Kirk Lapray <kirk_lapray@bigfoot.com>
 *
 *    Based on code from Jack Kelliher (kelliher@xmission.com)
 *                           Copyright (C) 2002 & pcHDTV, inc.
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
*/

/*
 * This driver needs two external firmware files. Please copy
 * "dvb-fe-or51132-vsb.fw" and "dvb-fe-or51132-qam.fw" to
 * /usr/lib/hotplug/firmware/ or /lib/firmware/
 * (depending on configuration of firmware hotplug).
 */
#define OR51132_VSB_FIRMWARE "dvb-fe-or51132-vsb.fw"
#define OR51132_QAM_FIRMWARE "dvb-fe-or51132-qam.fw"

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/byteorder.h>

#include "dvb_frontend.h"
#include "dvb-pll.h"
#include "or51132.h"

static int debug;
#define dprintk(args...) \
	do { \
		if (debug) printk(KERN_DEBUG "or51132: " args); \
	} while (0)


struct or51132_state
{
	struct i2c_adapter* i2c;
	struct dvb_frontend_ops ops;

	/* Configuration settings */
	const struct or51132_config* config;

	struct dvb_frontend frontend;
	
	/* Demodulator private data */
	fe_modulation_t current_modulation;

	/* Tuner private data */
	u32 current_frequency;
};

static int i2c_writebytes (struct or51132_state* state, u8 reg, u8 *buf, int len)
{
	int err;
	struct i2c_msg msg;
	msg.addr  = reg;
	msg.flags = 0;
	msg.len   = len;
	msg.buf   = buf;

	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
		printk(KERN_WARNING "or51132: i2c_writebytes error (addr %02x, err == %i)\n", reg, err);
		return -EREMOTEIO;
	}

	return 0;
}

static u8 i2c_readbytes (struct or51132_state* state, u8 reg, u8* buf, int len)
{
	int err;
	struct i2c_msg msg;
	msg.addr   = reg;
	msg.flags = I2C_M_RD;
	msg.len = len;
	msg.buf = buf;

	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
		printk(KERN_WARNING "or51132: i2c_readbytes error (addr %02x, err == %i)\n", reg, err);
		return -EREMOTEIO;
	}

	return 0;
}

static int or51132_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
{
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	static u8 run_buf[] = {0x7F,0x01};
	static u8 get_ver_buf[] = {0x04,0x00,0x30,0x00,0x00};
	u8 rec_buf[14];
	u8 cmd_buf[14];
	u32 firmwareAsize, firmwareBsize;
	int i,ret;

	dprintk("Firmware is %ld bytes\n",fw->size);

	/* Get size of firmware A and B */
	firmwareAsize = le32_to_cpu(*((u32*)fw->data));
	dprintk("FirmwareA is %i bytes\n",firmwareAsize);
	firmwareBsize = le32_to_cpu(*((u32*)(fw->data+4)));
	dprintk("FirmwareB is %i bytes\n",firmwareBsize);

	/* Upload firmware */
	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 &fw->data[8],firmwareAsize))) {
		printk(KERN_WARNING "or51132: load_firmware error 1\n");
		return ret;
	}
	msleep(1); /* 1ms */
	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 &fw->data[8+firmwareAsize],firmwareBsize))) {
		printk(KERN_WARNING "or51132: load_firmware error 2\n");
		return ret;
	}
	msleep(1); /* 1ms */

	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 run_buf,2))) {
		printk(KERN_WARNING "or51132: load_firmware error 3\n");
		return ret;
	}

	/* Wait at least 5 msec */ 
	msleep(20); /* 10ms */

	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 run_buf,2))) {
		printk(KERN_WARNING "or51132: load_firmware error 4\n");
		return ret;
	}

	/* 50ms for operation to begin */
	msleep(50);

	/* Read back ucode version to besure we loaded correctly and are really up and running */
	/* Get uCode version */
	cmd_buf[0] = 0x10;
	cmd_buf[1] = 0x10;
	cmd_buf[2] = 0x00;
	cmd_buf[3] = 0x00;
	msleep(20); /* 20ms */
	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 cmd_buf,3))) {
		printk(KERN_WARNING "or51132: load_firmware error a\n");
		return ret;
	}

	cmd_buf[0] = 0x04;
	cmd_buf[1] = 0x17;
	cmd_buf[2] = 0x00;
	cmd_buf[3] = 0x00;
	msleep(20); /* 20ms */
	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 cmd_buf,2))) {
		printk(KERN_WARNING "or51132: load_firmware error b\n");
		return ret;
	}

	cmd_buf[0] = 0x00;
	cmd_buf[1] = 0x00;
	cmd_buf[2] = 0x00;
	cmd_buf[3] = 0x00;
	msleep(20); /* 20ms */
	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 cmd_buf,2))) {
		printk(KERN_WARNING "or51132: load_firmware error c\n");
		return ret;
	}

	for(i=0;i<4;i++) {
		msleep(20); /* 20ms */
		get_ver_buf[4] = i+1;
		if ((ret = i2c_readbytes(state,state->config->demod_address,
					&rec_buf[i*2],2))) {
			printk(KERN_WARNING 
			       "or51132: load_firmware error d - %d\n",i);
			return ret;
		}
	}

	printk(KERN_WARNING
	       "or51132: Version: %02X%02X%02X%02X-%02X%02X%02X%02X (%02X%01X-%01X-%02X%01X-%01X)\n",
	       rec_buf[1],rec_buf[0],rec_buf[3],rec_buf[2],
	       rec_buf[5],rec_buf[4],rec_buf[7],rec_buf[6],
	       rec_buf[3],rec_buf[2]>>4,rec_buf[2]&0x0f,
	       rec_buf[5],rec_buf[4]>>4,rec_buf[4]&0x0f);

	cmd_buf[0] = 0x10;
	cmd_buf[1] = 0x00;
	cmd_buf[2] = 0x00;
	cmd_buf[3] = 0x00;
	msleep(20); /* 20ms */
	if ((ret = i2c_writebytes(state,state->config->demod_address,
				 cmd_buf,3))) {
		printk(KERN_WARNING "or51132: load_firmware error e\n");
		return ret;
	}
	return 0;
};

static int or51132_init(struct dvb_frontend* fe)
{
	return 0;
}

static int or51132_read_ber(struct dvb_frontend* fe, u32* ber)
{
	*ber = 0;
	return 0;
}

static int or51132_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
{
	*ucblocks = 0;
	return 0;
}

static int or51132_sleep(struct dvb_frontend* fe)
{
	return 0;
}

static int or51132_setmode(struct dvb_frontend* fe)
{
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	unsigned char cmd_buf[4];

	dprintk("setmode %d\n",(int)state->current_modulation);
	/* set operation mode in Receiver 1 register; */
	cmd_buf[0] = 0x04;
	cmd_buf[1] = 0x01;
	switch (state->current_modulation) {
	case QAM_256:
	case QAM_64:
	case QAM_AUTO:
		/* Auto-deinterleave; MPEG ser, MPEG2tr, phase noise-high*/
		cmd_buf[2] = 0x5F;
		break;
	case VSB_8:
		/* Auto CH, Auto NTSC rej, MPEGser, MPEG2tr, phase noise-high*/
		cmd_buf[2] = 0x50;
		break;
	default:
		printk("setmode:Modulation set to unsupported value\n");
	};
	cmd_buf[3] = 0x00;
	if (i2c_writebytes(state,state->config->demod_address,
			   cmd_buf,3)) {
		printk(KERN_WARNING "or51132: set_mode error 1\n");
		return -1;
	}
	dprintk("or51132: set #1 to %02x\n", cmd_buf[2]);

	/* Set operation mode in Receiver 6 register */
	cmd_buf[0] = 0x1C;
	switch (state->current_modulation) {
	case QAM_AUTO:
		/* REC MODE Normal Carrier Lock */
		cmd_buf[1] = 0x00;
		/* Channel MODE Auto QAM64/256 */
		cmd_buf[2] = 0x4f;
		break;
	case QAM_256:
		/* REC MODE Normal Carrier Lock */
		cmd_buf[1] = 0x00;
		/* Channel MODE QAM256 */
		cmd_buf[2] = 0x45;
		break;
	case QAM_64:
		/* REC MODE Normal Carrier Lock */
		cmd_buf[1] = 0x00;
		/* Channel MODE QAM64 */
		cmd_buf[2] = 0x43;
		break;
	case VSB_8:
		 /* REC MODE inv IF spectrum, Normal */
		cmd_buf[1] = 0x03;
		/* Channel MODE ATSC/VSB8 */
		cmd_buf[2] = 0x06;
		break;
	default:
		printk("setmode: Modulation set to unsupported value\n");
	};
	cmd_buf[3] = 0x00;
	msleep(20); /* 20ms */
	if (i2c_writebytes(state,state->config->demod_address,
			   cmd_buf,3)) {
		printk(KERN_WARNING "or51132: set_mode error 2\n");
		return -1;
	}
	dprintk("or51132: set #6 to 0x%02x%02x\n", cmd_buf[1], cmd_buf[2]);

	return 0;
}

static int or51132_set_parameters(struct dvb_frontend* fe,
				  struct dvb_frontend_parameters *param)
{
	int ret;
	u8 buf[4];
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	const struct firmware *fw;

	/* Change only if we are actually changing the modulation */
	if (state->current_modulation != param->u.vsb.modulation) {
		switch(param->u.vsb.modulation) {
		case VSB_8:
			dprintk("set_parameters VSB MODE\n");
			printk("or51132: Waiting for firmware upload(%s)...\n",
			       OR51132_VSB_FIRMWARE);
			ret = request_firmware(&fw, OR51132_VSB_FIRMWARE, 
					       &state->i2c->dev);
			if (ret){
				printk(KERN_WARNING "or51132: No firmware up"
				       "loaded(timeout or file not found?)\n");
				return ret;
			}
			/* Set non-punctured clock for VSB */
			state->config->set_ts_params(fe, 0);
			break;
		case QAM_AUTO:
		case QAM_64:
		case QAM_256:
			dprintk("set_parameters QAM MODE\n");
			printk("or51132: Waiting for firmware upload(%s)...\n",
			       OR51132_QAM_FIRMWARE);
			ret = request_firmware(&fw, OR51132_QAM_FIRMWARE, 
					       &state->i2c->dev);
			if (ret){
				printk(KERN_WARNING "or51132: No firmware up"
				       "loaded(timeout or file not found?)\n");
				return ret;
			}
			/* Set punctured clock for QAM */
			state->config->set_ts_params(fe, 1);
			break;
		default:
			printk("or51132:Modulation type(%d) UNSUPPORTED\n",
			       param->u.vsb.modulation);
			return -1;
		};
		ret = or51132_load_firmware(fe, fw);
		release_firmware(fw);
		if (ret) {
			printk(KERN_WARNING "or51132: Writing firmware to "
			       "device failed!\n");
			return ret;
		}
		printk("or51132: Firmware upload complete.\n");

		state->current_modulation = param->u.vsb.modulation;
		or51132_setmode(fe);
	}

	/* Change only if we are actually changing the channel */
	if (state->current_frequency != param->frequency) {
		dvb_pll_configure(state->config->pll_desc, buf,
				  param->frequency, 0);
		dprintk("set_parameters tuner bytes: 0x%02x 0x%02x "
			"0x%02x 0x%02x\n",buf[0],buf[1],buf[2],buf[3]);
		if (i2c_writebytes(state, state->config->pll_address ,buf, 4))
			printk(KERN_WARNING "or51132: set_parameters error "
			       "writing to tuner\n");
	
		/* Set to current mode */
		or51132_setmode(fe);
	
		/* Update current frequency */
		state->current_frequency = param->frequency;
	}
	return 0;
}

static int or51132_read_status(struct dvb_frontend* fe, fe_status_t* status)
{
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	unsigned char rec_buf[2];
	unsigned char snd_buf[2];
	*status = 0;

	/* Receiver Status */
	snd_buf[0]=0x04;
	snd_buf[1]=0x00;
	msleep(30); /* 30ms */
	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
		printk(KERN_WARNING "or51132: read_status write error\n");
		return -1;
	}
	msleep(30); /* 30ms */
	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
		printk(KERN_WARNING "or51132: read_status read error\n");
		return -1;
	}
	dprintk("read_status %x %x\n",rec_buf[0],rec_buf[1]);

	if (rec_buf[1] & 0x01) { /* Receiver Lock */
		*status |= FE_HAS_SIGNAL;
		*status |= FE_HAS_CARRIER;
		*status |= FE_HAS_VITERBI;
		*status |= FE_HAS_SYNC;
		*status |= FE_HAS_LOCK;
	}
	return 0;
}

/* log10-1 table at .5 increments from 1 to 100.5 */
unsigned int i100x20log10[] = {
     0,  352,  602,  795,  954, 1088, 1204, 1306, 1397, 1480,
  1556, 1625, 1690, 1750, 1806, 1858, 1908, 1955, 2000, 2042,
  2082, 2121, 2158, 2193, 2227, 2260, 2292, 2322, 2352, 2380,
  2408, 2434, 2460, 2486, 2510, 2534, 2557, 2580, 2602, 2623,
  2644, 2664, 2684, 2704, 2723, 2742, 2760, 2778, 2795, 2813,
  2829, 2846, 2862, 2878, 2894, 2909, 2924, 2939, 2954, 2968,
  2982, 2996, 3010, 3023, 3037, 3050, 3062, 3075, 3088, 3100,
  3112, 3124, 3136, 3148, 3159, 3170, 3182, 3193, 3204, 3214,
  3225, 3236, 3246, 3256, 3266, 3276, 3286, 3296, 3306, 3316,
  3325, 3334, 3344, 3353, 3362, 3371, 3380, 3389, 3397, 3406,
  3415, 3423, 3432, 3440, 3448, 3456, 3464, 3472, 3480, 3488,
  3496, 3504, 3511, 3519, 3526, 3534, 3541, 3549, 3556, 3563,
  3570, 3577, 3584, 3591, 3598, 3605, 3612, 3619, 3625, 3632,
  3639, 3645, 3652, 3658, 3665, 3671, 3677, 3683, 3690, 3696,
  3702, 3708, 3714, 3720, 3726, 3732, 3738, 3744, 3750, 3755,
  3761, 3767, 3772, 3778, 3784, 3789, 3795, 3800, 3806, 3811,
  3816, 3822, 3827, 3832, 3838, 3843, 3848, 3853, 3858, 3863,
  3868, 3874, 3879, 3884, 3888, 3893, 3898, 3903, 3908, 3913,
  3918, 3922, 3927, 3932, 3936, 3941, 3946, 3950, 3955, 3960,
  3964, 3969, 3973, 3978, 3982, 3986, 3991, 3995, 4000, 4004,
};

unsigned int denom[] = {1,1,100,1000,10000,100000,1000000,10000000,100000000};

unsigned int i20Log10(unsigned short val)
{
	unsigned int rntval = 100;
	unsigned int tmp = val;
	unsigned int exp = 1;

	while(tmp > 100) {tmp /= 100; exp++;}

	val = (2 * val)/denom[exp];
	if (exp > 1) rntval = 2000*exp;

	rntval += i100x20log10[val];
	return rntval;
}

static int or51132_read_signal_strength(struct dvb_frontend* fe, u16* strength)
{
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	unsigned char rec_buf[2];
	unsigned char snd_buf[2];
	u8 rcvr_stat;
	u16 snr_equ;
	int usK;
	
	snd_buf[0]=0x04;
	snd_buf[1]=0x02; /* SNR after Equalizer */
	msleep(30); /* 30ms */
	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
		printk(KERN_WARNING "or51132: read_status write error\n");
		return -1;
	}
	msleep(30); /* 30ms */
	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
		printk(KERN_WARNING "or51132: read_status read error\n");
		return -1;
	}
	snr_equ = rec_buf[0] | (rec_buf[1] << 8);
	dprintk("read_signal_strength snr_equ %x %x (%i)\n",rec_buf[0],rec_buf[1],snr_equ);

	/* Receiver Status */
	snd_buf[0]=0x04;
	snd_buf[1]=0x00;
	msleep(30); /* 30ms */
	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
		printk(KERN_WARNING "or51132: read_signal_strength read_status write error\n");
		return -1;
	}
	msleep(30); /* 30ms */
	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
		printk(KERN_WARNING "or51132: read_signal_strength read_status read error\n");
		return -1;
	}
	dprintk("read_signal_strength read_status %x %x\n",rec_buf[0],rec_buf[1]);
	rcvr_stat = rec_buf[1];
	usK = (rcvr_stat & 0x10) ? 3 : 0;

        /* The value reported back from the frontend will be FFFF=100% 0000=0% */
	*strength = (((8952 - i20Log10(snr_equ) - usK*100)/3+5)*65535)/1000;
	dprintk("read_signal_strength %i\n",*strength);

	return 0;
}

static int or51132_read_snr(struct dvb_frontend* fe, u16* snr)
{
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	unsigned char rec_buf[2];
	unsigned char snd_buf[2];
	u16 snr_equ;

	snd_buf[0]=0x04;
	snd_buf[1]=0x02; /* SNR after Equalizer */
	msleep(30); /* 30ms */
	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
		printk(KERN_WARNING "or51132: read_snr write error\n");
		return -1;
	}
	msleep(30); /* 30ms */
	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
		printk(KERN_WARNING "or51132: read_snr dvr read error\n");
		return -1;
	}
	snr_equ = rec_buf[0] | (rec_buf[1] << 8);
	dprintk("read_snr snr_equ %x %x (%i)\n",rec_buf[0],rec_buf[1],snr_equ);

	*snr = 0xFFFF - snr_equ;
	dprintk("read_snr %i\n",*snr);

	return 0;
}

static int or51132_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
{
	fe_tune_settings->min_delay_ms = 500;
	fe_tune_settings->step_size = 0;
	fe_tune_settings->max_drift = 0;

	return 0;
}

static void or51132_release(struct dvb_frontend* fe)
{
	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
	kfree(state);
}

static struct dvb_frontend_ops or51132_ops;

struct dvb_frontend* or51132_attach(const struct or51132_config* config,
				    struct i2c_adapter* i2c)
{
	struct or51132_state* state = NULL;

	/* Allocate memory for the internal state */
	state = kmalloc(sizeof(struct or51132_state), GFP_KERNEL);
	if (state == NULL)
		goto error;

	/* Setup the state */
	state->config = config;
	state->i2c = i2c;
	memcpy(&state->ops, &or51132_ops, sizeof(struct dvb_frontend_ops));
	state->current_frequency = -1;
	state->current_modulation = -1;

	/* Create dvb_frontend */
	state->frontend.ops = &state->ops;
	state->frontend.demodulator_priv = state;
	return &state->frontend;

error:
	if (state)
		kfree(state);
	return NULL;
}

static struct dvb_frontend_ops or51132_ops = {

	.info = {
		.name			= "Oren OR51132 VSB/QAM Frontend",
		.type 			= FE_ATSC,
		.frequency_min		= 44000000,
		.frequency_max		= 958000000,
		.frequency_stepsize	= 166666,
		.caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
			FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
			FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_QAM_AUTO |
			FE_CAN_8VSB
	},

	.release = or51132_release,

	.init = or51132_init,
	.sleep = or51132_sleep,

	.set_frontend = or51132_set_parameters,
	.get_tune_settings = or51132_get_tune_settings,

	.read_status = or51132_read_status,
	.read_ber = or51132_read_ber,
	.read_signal_strength = or51132_read_signal_strength,
	.read_snr = or51132_read_snr,
	.read_ucblocks = or51132_read_ucblocks,
};

module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");

MODULE_DESCRIPTION("OR51132 ATSC [pcHDTV HD-3000] (8VSB & ITU J83 AnnexB FEC QAM64/256) Demodulator Driver");
MODULE_AUTHOR("Kirk Lapray");
MODULE_LICENSE("GPL");

EXPORT_SYMBOL(or51132_attach);

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */




/*
 *    Support for OR51132 (pcHDTV HD-3000) - VSB/QAM
 *
 *    Copyright (C) 2005 Kirk Lapray <kirk_lapray@bigfoot.com>
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
*/

#ifndef OR51132_H
#define OR51132_H

#include <linux/firmware.h>
#include <linux/dvb/frontend.h>

struct or51132_config
{
	/* The demodulator's i2c address */
	u8 demod_address;
	u8 pll_address;
	struct dvb_pll_desc *pll_desc;

	/* Need to set device param for start_dma */
	int (*set_ts_params)(struct dvb_frontend* fe, int is_punctured);
};

extern struct dvb_frontend* or51132_attach(const struct or51132_config* config,
					   struct i2c_adapter* i2c);

#endif // OR51132_H

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */





	if ((i=aci_rw_cmd(ACI_READ_TUNERSTATION, -1, -1))<0)
		return i;
	pr_debug("check_sig: 0x%x\n", i);
	printk("check_sig: 0x%x\n", i);
#endif
	if (i & 0x80) {
		/* no signal from tuner */
		*flags=0;


	if ((i=aci_rds_cmd(RDS_RXVALUE, &buf, 1))<0)
		return i;
	pr_debug("rds-signal: %d\n", buf);
	printk("rds-signal: %d\n", buf);
#endif
	if (buf > 15) {
		printk("miropcm20-radio: RX strengths unexpected high...\n");
		buf=15;

			unsigned long *freq = arg;
			pcm20->freq = *freq;
			i=pcm20_setfreq(pcm20, pcm20->freq);
			pr_debug("First view (setfreq): 0x%x\n", i);
			printk("First view (setfreq): 0x%x\n", i);
#endif
			return i;
		}
		case VIDIOCGAUDIO:




#include <linux/module.h>	/* Modules                        */
#include <linux/init.h>		/* Initdata                       */
#include <linux/ioport.h>	/* check_region, request_region   */
#include <linux/delay.h>	/* udelay, msleep                 */
#include <asm/io.h>		/* outb, outb_p                   */
#include <asm/uaccess.h>	/* copy to/from user              */
#include <linux/videodev.h>	/* kernel radio structs           */

	struct semaphore lock;
};


/* local things */

static void sleep_delay(void)
{
	/* Sleep nicely for +/- 10 mS */
	schedule();
}

static int zol_setvol(struct zol_device *dev, int vol)
{
	dev->curvol = vol;

	}

	outb(dev->curvol-1, io);
	msleep(10);
	inb(io + 2);
	up(&dev->lock);
	return 0;

	down(&dev->lock);
	outb(0x00, io);         /* This stuff I found to do nothing */
	outb(dev->curvol, io);
	msleep(20);
	sleep_delay();

	a = inb(io);
	msleep(10);
	b = inb(io);

	up(&dev->lock);

	
	outb(0x00, io);
	outb(dev->curvol, io);
	msleep(20);
	sleep_delay();

	x1 = inb(io);
	msleep(10);
	x2 = inb(io);

	up(&dev->lock);


	outb(0, io);
	outb(0, io);
	msleep(20);
	sleep_delay();
	inb(io + 3);

	zoltrix_unit.curvol = 0;

Lines 249-255 config VIDEO_SAA7134 Link Here

(-)linux-2.6.11.orig/drivers/media/video/Kconfig (-4 / +12 lines)
249		249
250	config VIDEO_SAA7134_DVB	250	config VIDEO_SAA7134_DVB
251	tristate "DVB Support for saa7134 based TV cards"	251	tristate "DVB Support for saa7134 based TV cards"
252	depends on VIDEO_SAA7134 && DVB_CORE && BROKEN	252	depends on VIDEO_SAA7134 && DVB_CORE
		253	select VIDEO_BUF_DVB
		254	select DVB_MT352
253	---help---	255	---help---
254	This adds support for DVB cards based on the	256	This adds support for DVB cards based on the
255	Philips saa7134 chip.	257	Philips saa7134 chip.
Lines 305-315 config VIDEO_HEXIUM_GEMINI Link Here
305		307
306	config VIDEO_CX88	308	config VIDEO_CX88
307	tristate "Conexant 2388x (bt878 successor) support"	309	tristate "Conexant 2388x (bt878 successor) support"
308	depends on VIDEO_DEV && PCI && EXPERIMENTAL	310	depends on VIDEO_DEV && PCI && I2C && EXPERIMENTAL
309	select I2C_ALGOBIT	311	select I2C_ALGOBIT
		312	select FW_LOADER
310	select VIDEO_BTCX	313	select VIDEO_BTCX
311	select VIDEO_BUF	314	select VIDEO_BUF
312	select VIDEO_TUNER	315	select VIDEO_TUNER
		316	select VIDEO_TVEEPROM
		317	select VIDEO_IR
313	---help---	318	---help---
314	This is a video4linux driver for Conexant 2388x based	319	This is a video4linux driver for Conexant 2388x based
315	TV cards.	320	TV cards.
Lines 319-328 config VIDEO_CX88 Link Here
319		324
320	config VIDEO_CX88_DVB	325	config VIDEO_CX88_DVB
321	tristate "DVB Support for cx2388x based TV cards"	326	tristate "DVB Support for cx2388x based TV cards"
322	depends on VIDEO_CX88 && DVB_CORE && BROKEN	327	depends on VIDEO_CX88 && DVB_CORE
323	select VIDEO_BUF_DVB	328	select VIDEO_BUF_DVB
		329	select DVB_MT352
		330	select DVB_CX22702
		331	select DVB_OR51132
324	---help---	332	---help---
325	This adds support for DVB cards based on the	333	This adds support for DVB/ATSC cards based on the
326	Connexant 2388x chip.	334	Connexant 2388x chip.
327		335
328	config VIDEO_OVCAMCHIP	336	config VIDEO_OVCAMCHIP

Lines 7-12 bttv-objs := bttv-driver.o bttv-cards.o Link Here

(-)linux-2.6.11.orig/drivers/media/video/Makefile (+1 lines)
7	zoran-objs := zr36120.o zr36120_i2c.o zr36120_mem.o	7	zoran-objs := zr36120.o zr36120_i2c.o zr36120_mem.o
8	zr36067-objs := zoran_procfs.o zoran_device.o \	8	zr36067-objs := zoran_procfs.o zoran_device.o \
9	zoran_driver.o zoran_card.o	9	zoran_driver.o zoran_card.o
		10	tuner-objs := tuner-core.o tuner-simple.o mt20xx.o tda8290.o
10		11
11	obj-$(CONFIG_VIDEO_DEV) += videodev.o v4l2-common.o v4l1-compat.o	12	obj-$(CONFIG_VIDEO_DEV) += videodev.o v4l2-common.o v4l1-compat.o
12		13




  It outputs an 8-bit 4:2:2 YUV or YCrCb video signal which can be directly
  connected to bt848/bt878 GPIO pins on this purpose.
  (see: VLSI Vision Ltd. www.vvl.co.uk for camera datasheets)

  Supported Cards:
  -  Pixelview Rev.4E: 0x8a
		GPIO 0x400000 toggles Bt832 RESET, and the chip changes to i2c 0x88 !

#include <linux/errno.h>
#include <linux/slab.h>

#include <media/audiochip.h>
#include <media/id.h>
#include "bttv.h"
#include "bt832.h"



	buf=kmalloc(65,GFP_KERNEL);
	bt832_hexdump(i2c_client_s,buf);

	if(buf[0x40] != 0x31) {
		printk("bt832: this i2c chip is no bt832 (id=%02x). Detaching.\n",buf[0x40]);
		kfree(buf);

	buf[1]= 0x27 & (~0x01); // Default | !skip
	if (2 != (rc = i2c_master_send(i2c_client_s,buf,2)))
                printk("bt832: i2c i/o error EO: rc == %d (should be 2)\n",rc);

        bt832_hexdump(i2c_client_s,buf);

#if 0




static int bt832_attach(struct i2c_adapter *adap, int addr, int kind)
			  unsigned short flags, int kind)
{
	struct bt832 *t;


                return -ENOMEM;
	memset(t,0,sizeof(*t));
	t->client = client_template;
        i2c_set_clientdata(&t->client, t);
        i2c_attach_client(&t->client);

	if(! bt832_init(&t->client)) {
		bt832_detach(&t->client);
		return -1;
	}

	return 0;
}

static int bt832_probe(struct i2c_adapter *adap)
{
#ifdef I2C_CLASS_TV_ANALOG
	if (adap->class & I2C_CLASS_TV_ANALOG)
		return i2c_probe(adap, &addr_data, bt832_attach);
#else
	if (adap->id == (I2C_ALGO_BIT | I2C_HW_B_BT848))
		return i2c_probe(adap, &addr_data, bt832_attach);
#endif
	return 0;
}

static int bt832_detach(struct i2c_client *client)
{
	struct bt832 *t = i2c_get_clientdata(client);

	printk("bt832: detach.\n");
	i2c_detach_client(client);

static int
bt832_command(struct i2c_client *client, unsigned int cmd, void *arg)
{
	struct bt832 *t = i2c_get_clientdata(client);

	printk("bt832: command %x\n",cmd);


};
static struct i2c_client client_template =
{
	I2C_DEVNAME("bt832"),
	.flags      = I2C_CLIENT_ALLOW_USE,
        .driver     = &driver,
};


static int __init bt832_init_module(void)
{
	return i2c_add_driver(&driver);
	return 0;
}

static void __exit bt832_cleanup_module(void)
{
	i2c_del_driver(&driver);
}

module_init(bt832_init_module);
module_exit(bt832_cleanup_module);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */




/* Bt832 CMOS Camera Video Processor (VP)

 The Bt832 CMOS Camera Video Processor chip connects a Quartsight CMOS
  color digital camera directly to video capture devices via an 8-bit,
  4:2:2 YUV or YCrCb video interface.


#define BT832_DEVICE_ID		63
# define BT832_DEVICE_ID__31		0x31 // Bt832 has ID 0x31

/* STMicroelectronivcs VV5404 camera module
   i2c: 0x20: sensor address
   i2c: 0xa0: eeprom for ccd defect map
 */

//===========================================================================
// Timing generator SRAM table values for CCIR601 720x480 NTSC
//===========================================================================
// For NTSC CCIR656
BYTE BtCard::SRAMTable_NTSC[] =
{
    // SRAM Timing Table for NTSC
    0x0c, 0xc0, 0x00,
    0x00, 0x90, 0xc2,
    0x03, 0x10, 0x03,
    0x06, 0x10, 0x34,
    0x12, 0x12, 0x65,
    0x02, 0x13, 0x24,
    0x19, 0x00, 0x24,
    0x39, 0x00, 0x96,
    0x59, 0x08, 0x93,
    0x83, 0x08, 0x97,
    0x03, 0x50, 0x30,
    0xc0, 0x40, 0x30,
    0x86, 0x01, 0x01,
    0xa6, 0x0d, 0x62,
    0x03, 0x11, 0x61,
    0x05, 0x37, 0x30,
    0xac, 0x21, 0x50
};





/*
    $Id: btcx-risc.c,v 1.6 2005/02/21 13:57:59 kraxel Exp $

    btcx-risc.c


{
	if (NULL == risc->cpu)
		return;
	pci_free_consistent(pci, risc->size, risc->cpu, risc->dma);
	memset(risc,0,sizeof(*risc));
	if (debug) {
		memcnt--;
		printk("btcx: riscmem free [%d] dma=%lx\n",
		       memcnt, (unsigned long)risc->dma);
	}
	pci_free_consistent(pci, risc->size, risc->cpu, risc->dma);
	memset(risc,0,sizeof(*risc));
}

int btcx_riscmem_alloc(struct pci_dev *pci,

		risc->size = size;
		if (debug) {
			memcnt++;
			printk("btcx: riscmem alloc [%d] dma=%lx cpu=%p size=%d\n",
			       memcnt, (unsigned long)dma, cpu, size);
		}
	}
	memset(risc->cpu,0,risc->size);

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bttv-cards.c (-2 / +175 lines)
1	/*	1	/*
2	$Id: bttv-cards.c,v 1.42 2005/01/13 17:22:33 kraxel Exp $	2	$Id: bttv-cards.c,v 1.47 2005/02/22 14:06:32 kraxel Exp $
3		3
4	bttv-cards.c	4	bttv-cards.c
5		5
Lines 80-85 static void picolo_tetra_init(struct btt Link Here
80	static void tibetCS16_muxsel(struct bttv *btv, unsigned int input);	80	static void tibetCS16_muxsel(struct bttv *btv, unsigned int input);
81	static void tibetCS16_init(struct bttv *btv);	81	static void tibetCS16_init(struct bttv *btv);
82		82
		83	static void kodicom4400r_muxsel(struct bttv *btv, unsigned int input);
		84	static void kodicom4400r_init(struct bttv *btv);
		85
83	static void sigmaSLC_muxsel(struct bttv *btv, unsigned int input);	86	static void sigmaSLC_muxsel(struct bttv *btv, unsigned int input);
84	static void sigmaSQ_muxsel(struct bttv *btv, unsigned int input);	87	static void sigmaSQ_muxsel(struct bttv *btv, unsigned int input);
85		88
Lines 101-106 static unsigned int pll[BTTV_MAX] = { Link Here
101	static unsigned int tuner[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = UNSET };	104	static unsigned int tuner[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = UNSET };
102	static unsigned int svhs[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = UNSET };	105	static unsigned int svhs[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = UNSET };
103	static unsigned int remote[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = UNSET };	106	static unsigned int remote[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = UNSET };
		107	static struct bttv *master[BTTV_MAX] = { [ 0 ... (BTTV_MAX-1) ] = NULL };
104	#ifdef MODULE	108	#ifdef MODULE
105	static unsigned int autoload = 1;	109	static unsigned int autoload = 1;
106	#else	110	#else
Lines 170-175 static struct CARD { Link Here
170	// some cards ship with byteswapped IDs ...	174	// some cards ship with byteswapped IDs ...
171	{ 0x1200bd11, BTTV_PINNACLE, "Pinnacle PCTV [bswap]" },	175	{ 0x1200bd11, BTTV_PINNACLE, "Pinnacle PCTV [bswap]" },
172	{ 0xff00bd11, BTTV_PINNACLE, "Pinnacle PCTV [bswap]" },	176	{ 0xff00bd11, BTTV_PINNACLE, "Pinnacle PCTV [bswap]" },
		177	// this seems to happen as well ...
		178	{ 0xff1211bd, BTTV_PINNACLE, "Pinnacle PCTV" },
173		179
174	{ 0x3000121a, BTTV_VOODOOTV_FM, "3Dfx VoodooTV FM/ VoodooTV 200" },	180	{ 0x3000121a, BTTV_VOODOOTV_FM, "3Dfx VoodooTV FM/ VoodooTV 200" },
175	{ 0x263710b4, BTTV_VOODOOTV_FM, "3Dfx VoodooTV FM/ VoodooTV 200" },	181	{ 0x263710b4, BTTV_VOODOOTV_FM, "3Dfx VoodooTV FM/ VoodooTV 200" },
Lines 291-297 static struct CARD { Link Here
291	{ 0x07611461, BTTV_AVDVBT_761, "AverMedia AverTV DVB-T 761" },	297	{ 0x07611461, BTTV_AVDVBT_761, "AverMedia AverTV DVB-T 761" },
292	{ 0x001c11bd, BTTV_PINNACLESAT, "Pinnacle PCTV Sat" },	298	{ 0x001c11bd, BTTV_PINNACLESAT, "Pinnacle PCTV Sat" },
293	{ 0x002611bd, BTTV_TWINHAN_DST, "Pinnacle PCTV SAT CI" },	299	{ 0x002611bd, BTTV_TWINHAN_DST, "Pinnacle PCTV SAT CI" },
294	{ 0x00011822, BTTV_TWINHAN_DST, "Twinhan VisionPlus DVB-T" },	300	{ 0x00011822, BTTV_TWINHAN_DST, "Twinhan VisionPlus DVB" },
295	{ 0xfc00270f, BTTV_TWINHAN_DST, "ChainTech digitop DST-1000 DVB-S" },	301	{ 0xfc00270f, BTTV_TWINHAN_DST, "ChainTech digitop DST-1000 DVB-S" },
296	{ 0x07711461, BTTV_AVDVBT_771, "AVermedia AverTV DVB-T 771" },	302	{ 0x07711461, BTTV_AVDVBT_771, "AVermedia AverTV DVB-T 771" },
297	{ 0xdb1018ac, BTTV_DVICO_DVBT_LITE, "DVICO FusionHDTV DVB-T Lite" },	303	{ 0xdb1018ac, BTTV_DVICO_DVBT_LITE, "DVICO FusionHDTV DVB-T Lite" },
Lines 1920-1925 struct tvcard bttv_tvcards[] = { Link Here
1920	.svhs = 2,	1926	.svhs = 2,
1921	.muxsel = { 2, 3, 1, 0},	1927	.muxsel = { 2, 3, 1, 0},
1922	.tuner_type = TUNER_PHILIPS_ATSC,	1928	.tuner_type = TUNER_PHILIPS_ATSC,
		1929	.has_dvb = 1,
1923	},{	1930	},{
1924	.name = "Twinhan DST + clones",	1931	.name = "Twinhan DST + clones",
1925	.no_msp34xx = 1,	1932	.no_msp34xx = 1,
Lines 2188-2193 struct tvcard bttv_tvcards[] = { Link Here
2188	.no_tda7432 = 1,	2195	.no_tda7432 = 1,
2189	.tuner_type = -1,	2196	.tuner_type = -1,
2190	.muxsel_hook = tibetCS16_muxsel,	2197	.muxsel_hook = tibetCS16_muxsel,
		2198	},
		2199	{
		2200	/* Bill Brack <wbrack@mmm.com.hk> */
		2201	/*
		2202	* Note that, because of the card's wiring, the "master"
		2203	* BT878A chip (i.e. the one which controls the analog switch
		2204	* and must use this card type) is the 2nd one detected. The
		2205	* other 3 chips should use card type 0x85, whose description
		2206	* follows this one. There is a EEPROM on the card (which is
		2207	* connected to the I2C of one of those other chips), but is
		2208	* not currently handled. There is also a facility for a
		2209	* "monitor", which is also not currently implemented.
		2210	*/
		2211	.name = "Kodicom 4400R (master)",
		2212	.video_inputs = 16,
		2213	.audio_inputs = 0,
		2214	.tuner = -1,
		2215	.tuner_type = -1,
		2216	.svhs = -1,
		2217	/* GPIO bits 0-9 used for analog switch:
		2218	* 00 - 03: camera selector
		2219	* 04 - 06: channel (controller) selector
		2220	* 07: data (1->on, 0->off)
		2221	* 08: strobe
		2222	* 09: reset
		2223	* bit 16 is input from sync separator for the channel
		2224	*/
		2225	.gpiomask = 0x0003ff,
		2226	.no_gpioirq = 1,
		2227	.muxsel = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
		2228	.pll = PLL_28,
		2229	.no_msp34xx = 1,
		2230	.no_tda7432 = 1,
		2231	.no_tda9875 = 1,
		2232	.muxsel_hook = kodicom4400r_muxsel,
		2233	},
		2234	{
		2235	/* Bill Brack <wbrack@mmm.com.hk> */
		2236	/* Note that, for reasons unknown, the "master" BT878A chip (i.e. the
		2237	* one which controls the analog switch, and must use the card type)
		2238	* is the 2nd one detected. The other 3 chips should use this card
		2239	* type
		2240	*/
		2241	.name = "Kodicom 4400R (slave)",
		2242	.video_inputs = 16,
		2243	.audio_inputs = 0,
		2244	.tuner = -1,
		2245	.tuner_type = -1,
		2246	.svhs = -1,
		2247	.gpiomask = 0x010000,
		2248	.no_gpioirq = 1,
		2249	.muxsel = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
		2250	.pll = PLL_28,
		2251	.no_msp34xx = 1,
		2252	.no_tda7432 = 1,
		2253	.no_tda9875 = 1,
		2254	.muxsel_hook = kodicom4400r_muxsel,
2191	}};	2255	}};
2192		2256
2193	static const unsigned int bttv_num_tvcards = ARRAY_SIZE(bttv_tvcards);	2257	static const unsigned int bttv_num_tvcards = ARRAY_SIZE(bttv_tvcards);
Lines 2682-2687 void __devinit bttv_init_card2(struct bt Link Here
2682	case BTTV_TIBET_CS16:	2746	case BTTV_TIBET_CS16:
2683	tibetCS16_init(btv);	2747	tibetCS16_init(btv);
2684	break;	2748	break;
		2749	case BTTV_KODICOM_4400R:
		2750	kodicom4400r_init(btv);
		2751	break;
2685	}	2752	}
2686		2753
2687	/* pll configuration */	2754	/* pll configuration */
Lines 3894-3899 static void tibetCS16_init(struct bttv * Link Here
3894	gpio_write(0x0f7fff);	3961	gpio_write(0x0f7fff);
3895	}	3962	}
3896		3963
		3964	/*
		3965	* The following routines for the Kodicom-4400r get a little mind-twisting.
		3966	* There is a "master" controller and three "slave" controllers, together
		3967	* an analog switch which connects any of 16 cameras to any of the BT87A's.
		3968	* The analog switch is controlled by the "master", but the detection order
		3969	* of the four BT878A chips is in an order which I just don't understand.
		3970	* The "master" is actually the second controller to be detected. The
		3971	* logic on the board uses logical numbers for the 4 controlers, but
		3972	* those numbers are different from the detection sequence. When working
		3973	* with the analog switch, we need to "map" from the detection sequence
		3974	* over to the board's logical controller number. This mapping sequence
		3975	* is {3, 0, 2, 1}, i.e. the first controller to be detected is logical
		3976	* unit 3, the second (which is the master) is logical unit 0, etc.
		3977	* We need to maintain the status of the analog switch (which of the 16
		3978	* cameras is connected to which of the 4 controllers). Rather than
		3979	* add to the bttv structure for this, we use the data reserved for
		3980	* the mbox (unused for this card type).
		3981	*/
		3982
		3983	/*
		3984	* First a routine to set the analog switch, which controls which camera
		3985	* is routed to which controller. The switch comprises an X-address
		3986	* (gpio bits 0-3, representing the camera, ranging from 0-15), and a
		3987	* Y-address (gpio bits 4-6, representing the controller, ranging from 0-3).
		3988	* A data value (gpio bit 7) of '1' enables the switch, and '0' disables
		3989	* the switch. A STROBE bit (gpio bit 8) latches the data value into the
		3990	* specified address. The idea is to set the address and data, then bring
		3991	* STROBE high, and finally bring STROBE back to low.
		3992	*/
		3993	static void kodicom4400r_write(struct bttv *btv,
		3994	unsigned char xaddr,
		3995	unsigned char yaddr,
		3996	unsigned char data) {
		3997	unsigned int udata;
		3998
		3999	udata = (data << 7) \| ((yaddr&3) << 4) \| (xaddr&0xf);
		4000	gpio_bits(0x1ff, udata); /* write ADDR and DAT */
		4001	gpio_bits(0x1ff, udata \| (1 << 8)); /* strobe high */
		4002	gpio_bits(0x1ff, udata); /* strobe low */
		4003	}
		4004
		4005	/*
		4006	* Next the mux select. Both the "master" and "slave" 'cards' (controllers)
		4007	* use this routine. The routine finds the "master" for the card, maps
		4008	* the controller number from the detected position over to the logical
		4009	* number, writes the appropriate data to the analog switch, and housekeeps
		4010	* the local copy of the switch information. The parameter 'input' is the
		4011	* requested camera number (0 - 15).
		4012	*/
		4013	static void kodicom4400r_muxsel(struct bttv *btv, unsigned int input)
		4014	{
		4015	char *sw_status;
		4016	int xaddr, yaddr;
		4017	struct bttv *mctlr;
		4018	static unsigned char map[4] = {3, 0, 2, 1};
		4019
		4020	mctlr = master[btv->c.nr];
		4021	if (mctlr == NULL) { /* ignore if master not yet detected */
		4022	return;
		4023	}
		4024	yaddr = (btv->c.nr - mctlr->c.nr + 1) & 3; /* the '&' is for safety */
		4025	yaddr = map[yaddr];
		4026	sw_status = (char *)(&mctlr->mbox_we);
		4027	xaddr = input & 0xf;
4028	/* Check if the controller/camera pair has changed, else ignore */
4029	if (sw_status[yaddr] != xaddr)
4030	{
4031	/* "open" the old switch, "close" the new one, save the new */
4032	kodicom4400r_write(mctlr, sw_status[yaddr], yaddr, 0);
4033	sw_status[yaddr] = xaddr;
4034	kodicom4400r_write(mctlr, xaddr, yaddr, 1);
4035	}
4036	}
4037
4038	/*
4039	* During initialisation, we need to reset the analog switch. We
4040	* also preset the switch to map the 4 connectors on the card to the
4041	* user's (see above description of kodicom4400r_muxsel) channels
4042	* 0 through 3
4043	*/
4044	static void kodicom4400r_init(struct bttv *btv)
4045	{
4046	char sw_status = (char )(&btv->mbox_we);
4047	int ix;
4048
4049	gpio_inout(0x0003ff, 0x0003ff);
4050	gpio_write(1 << 9); /* reset MUX */
4051	gpio_write(0);
4052	/* Preset camera 0 to the 4 controllers */
4053	for (ix=0; ix<4; ix++) {
4054	sw_status[ix] = ix;
4055	kodicom4400r_write(btv, ix, ix, 1);
4056	}
4057	/*
4058	* Since this is the "master", we need to set up the
4059	* other three controller chips' pointers to this structure
4060	* for later use in the muxsel routine.
4061	*/
4062	if ((btv->c.nr<1) \|\| (btv->c.nr>BTTV_MAX-3))
4063	return;
4064	master[btv->c.nr-1] = btv;
4065	master[btv->c.nr] = btv;
4066	master[btv->c.nr+1] = btv;
4067	master[btv->c.nr+2] = btv;
4068	}
4069
3897	// The Grandtec X-Guard framegrabber card uses two Dual 4-channel	4070	// The Grandtec X-Guard framegrabber card uses two Dual 4-channel
3898	// video multiplexers to provide up to 16 video inputs. These	4071	// video multiplexers to provide up to 16 video inputs. These
3899	// multiplexers are controlled by the lower 8 GPIO pins of the	4072	// multiplexers are controlled by the lower 8 GPIO pins of the




/*
    $Id: bttv-driver.c,v 1.37 2005/02/21 13:57:59 kraxel Exp $

    bttv - Bt848 frame grabber driver


};

/* ----------------------------------------------------------------------- */
/* some debug code                                                         */

int bttv_risc_decode(u32 risc)
{
	static char *instr[16] = {
		[ BT848_RISC_WRITE     >> 28 ] = "write",
		[ BT848_RISC_SKIP      >> 28 ] = "skip",
		[ BT848_RISC_WRITEC    >> 28 ] = "writec",
		[ BT848_RISC_JUMP      >> 28 ] = "jump",
		[ BT848_RISC_SYNC      >> 28 ] = "sync",
		[ BT848_RISC_WRITE123  >> 28 ] = "write123",
		[ BT848_RISC_SKIP123   >> 28 ] = "skip123",
		[ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
	};
	static int incr[16] = {
		[ BT848_RISC_WRITE     >> 28 ] = 2,
		[ BT848_RISC_JUMP      >> 28 ] = 2,
		[ BT848_RISC_SYNC      >> 28 ] = 2,
		[ BT848_RISC_WRITE123  >> 28 ] = 5,
		[ BT848_RISC_SKIP123   >> 28 ] = 2,
		[ BT848_RISC_WRITE1S23 >> 28 ] = 3,
	};
	static char *bits[] = {
		"be0",  "be1",  "be2",  "be3/resync",
		"set0", "set1", "set2", "set3",
		"clr0", "clr1", "clr2", "clr3",
		"irq",  "res",  "eol",  "sol",
	};
	int i;

	printk("0x%08x [ %s", risc,
	       instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
	for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
		if (risc & (1 << (i + 12)))
			printk(" %s",bits[i]);
	printk(" count=%d ]\n", risc & 0xfff);
	return incr[risc >> 28] ? incr[risc >> 28] : 1;
}

void bttv_risc_disasm(struct bttv *btv,
		      struct btcx_riscmem *risc)
{
	unsigned int i,j,n;

	printk("%s: risc disasm: %p [dma=0x%08lx]\n",
	       btv->c.name, risc->cpu, (unsigned long)risc->dma);
	for (i = 0; i < (risc->size >> 2); i += n) {
		printk("%s:   0x%lx: ", btv->c.name,
		       (unsigned long)(risc->dma + (i<<2)));
		n = bttv_risc_decode(risc->cpu[i]);
		for (j = 1; j < n; j++)
			printk("%s:   0x%lx: 0x%08x [ arg #%d ]\n",
			       btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
			       risc->cpu[i+j], j);
		if (0 == risc->cpu[i])
			break;
	}
}

static void bttv_print_riscaddr(struct bttv *btv)
{
	printk("  main: %08Lx\n",
	       (unsigned long long)btv->main.dma);
	printk("  vbi : o=%08Lx e=%08Lx\n",
	       btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
	       btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
	printk("  cap : o=%08Lx e=%08Lx\n",
	       btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
	       btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
	printk("  scr : o=%08Lx e=%08Lx\n",
	       btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
	       btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
	bttv_risc_disasm(btv, &btv->main);
}

/* ----------------------------------------------------------------------- */
/* irq handler                                                             */

static char *irq_name[] = {

	}
}

static void bttv_print_riscaddr(struct bttv *btv)
{
	printk("  main: %08Lx\n",
	       (unsigned long long)btv->main.dma);
	printk("  vbi : o=%08Lx e=%08Lx\n",
	       btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
	       btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
	printk("  cap : o=%08Lx e=%08Lx\n",
	       btv->curr.top    ? (unsigned long long)btv->curr.top->top.dma : 0,
	       btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
	printk("  scr : o=%08Lx e=%08Lx\n",
	       btv->screen ? (unsigned long long)btv->screen->top.dma  : 0,
	       btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
}

static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
{
	printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",

        return;
}

static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
{
        struct bttv *btv = pci_get_drvdata(pci_dev);
	struct bttv_buffer_set idle;




/*
    $Id: bttv-gpio.c,v 1.7 2005/02/16 12:14:10 kraxel Exp $

    bttv-gpio.c  --  gpio sub drivers



	list_for_each_safe(item,save,&core->subs) {
		sub = list_entry(item,struct bttv_sub_device,list);
		list_del(&sub->list);
		device_unregister(&sub->dev);
	}
	return 0;

	}
}

void bttv_i2c_info(struct bttv_core *core, struct i2c_client *client, int attach)
{
	struct bttv_sub_driver *drv;
	struct bttv_sub_device *dev;
	struct list_head *item;

	list_for_each(item,&core->subs) {
		dev = list_entry(item,struct bttv_sub_device,list);
		drv = to_bttv_sub_drv(dev->dev.driver);
		if (drv && drv->i2c_info)
			drv->i2c_info(dev,client,attach);
	}
}

/* ----------------------------------------------------------------------- */
/* external: sub-driver register/unregister                                */





/*
    $Id: bttv-i2c.c,v 1.18 2005/02/16 12:14:10 kraxel Exp $

    bttv-i2c.c  --  all the i2c code is here


static struct i2c_client bttv_i2c_client_template;

static int attach_inform(struct i2c_client *client);
static int detach_inform(struct i2c_client *client);

static int i2c_debug = 0;
static int i2c_hw = 0;

	I2C_DEVNAME("bt848"),
	.id                = I2C_HW_B_BT848,
	.client_register   = attach_inform,
	.client_unregister = detach_inform,
};

/* ----------------------------------------------------------------------- */

	.id            = I2C_ALGO_BIT | I2C_HW_B_BT848 /* FIXME */,
	.algo          = &bttv_algo,
	.client_register = attach_inform,
	.client_unregister = detach_inform,
};

/* ----------------------------------------------------------------------- */

	if (btv->pinnacle_id != UNSET)
		bttv_call_i2c_clients(btv,AUDC_CONFIG_PINNACLE,
				      &btv->pinnacle_id);
	bttv_i2c_info(&btv->c, client, 1);

        if (bttv_debug)
		printk("bttv%d: i2c attach [client=%s]\n",
		       btv->c.nr, i2c_clientname(client));
        return 0;
}

static int detach_inform(struct i2c_client *client)
{
        struct bttv *btv = i2c_get_adapdata(client->adapter);

	bttv_i2c_info(&btv->c, client, 0);
	return 0;
}

void bttv_call_i2c_clients(struct bttv *btv, unsigned int cmd, void *arg)
{
	if (0 != btv->i2c_rc)




/*
 * $Id: bttv.h,v 1.17 2005/02/22 14:06:32 kraxel Exp $
 *
 *  bttv - Bt848 frame grabber driver
 *

#define BTTV_APAC_VIEWCOMP  0x7f
#define BTTV_DVICO_DVBT_LITE  0x80
#define BTTV_TIBET_CS16  0x83
#define BTTV_KODICOM_4400R  0x84

/* i2c address list */
#define I2C_TSA5522        0xc2

	struct device_driver   drv;
	char                   wanted[BUS_ID_SIZE];
	void                   (*gpio_irq)(struct bttv_sub_device *sub);
	void                   (*i2c_info)(struct bttv_sub_device *sub,
					   struct i2c_client *client, int attach);
};
#define to_bttv_sub_drv(x) container_of((x), struct bttv_sub_driver, drv)


Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bttvp.h (-2 / +1 lines)
1	/*	1	/*
2	$Id: bttvp.h,v 1.15 2004/12/14 15:33:30 kraxel Exp $	2	$Id: bttvp.h,v 1.17 2005/02/16 12:14:10 kraxel Exp $
3		3
4	bttv - Bt848 frame grabber driver	4	bttv - Bt848 frame grabber driver
5		5
Lines 209-215 extern struct bus_type bttv_sub_bus_type Link Here
209	int bttv_sub_add_device(struct bttv_core core, char name);	209	int bttv_sub_add_device(struct bttv_core core, char name);
210	int bttv_sub_del_devices(struct bttv_core *core);	210	int bttv_sub_del_devices(struct bttv_core *core);
211	void bttv_gpio_irq(struct bttv_core *core);	211	void bttv_gpio_irq(struct bttv_core *core);
212	void bttv_i2c_info(struct bttv_core core, struct i2c_client client, int attach);
213		212
214		213
215	/* ---------------------------------------------------------- */	214	/* ---------------------------------------------------------- */

Lines 1-4 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/Makefile (-1 / +2 lines)
1	cx88xx-objs := cx88-cards.o cx88-core.o cx88-i2c.o cx88-tvaudio.o	1	cx88xx-objs := cx88-cards.o cx88-core.o cx88-i2c.o cx88-tvaudio.o \
		2	cx88-input.o
2	cx8800-objs := cx88-video.o cx88-vbi.o	3	cx8800-objs := cx88-video.o cx88-vbi.o
3	cx8802-objs := cx88-mpeg.o	4	cx8802-objs := cx88-mpeg.o
4		5




/*
 * $Id: cx88-blackbird.c,v 1.26 2005/03/07 15:58:05 kraxel Exp $
 *
 *  Support for a cx23416 mpeg encoder via cx2388x host port.
 *  "blackbird" reference design.

 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/delay.h>

	cx_read(P1_RADDR0);

	return wait_ready_gpio0_bit1(core,1);
#if 0
	udelay(1000); /* without this, things don't go right (subsequent memory_write()'s don't get through */
	/* ? would this be safe here? set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(1); */
#endif
}



	timeout = jiffies + msecs_to_jiffies(10);
	for (;;) {
		memory_read(dev->core, dev->mailbox, &flag);
		if (0 != (flag & 4))
			break;
		if (time_after(jiffies,timeout)) {
			dprintk(0, "ERROR: API Mailbox timeout\n");

			signaturecnt = 0;
		if (4 == signaturecnt) {
			dprintk(1, "Mailbox signature found\n");
			return i+1;
		}
	}
	dprintk(0, "Mailbox signature values not found!\n");

        blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAMERATE, 1, 0, 0);

        /* assign frame size */
        blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAME_SIZE, 2, 0,
			  dev->height, dev->width);

        /* assign aspect ratio */
        blackbird_api_cmd(dev, IVTV_API_ASSIGN_ASPECT_RATIO, 1, 0, 2);


		memset(f,0,sizeof(*f));
		f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		f->fmt.pix.width        = dev->width;
		f->fmt.pix.height       = dev->height;
		f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
		f->fmt.pix.sizeimage    = 1024 * 512 /* FIXME: BUFFER_SIZE */;
	}

	file->private_data = fh;
	fh->dev      = dev;

	/* FIXME: locking against other video device */
	cx88_set_scale(dev->core, dev->width, dev->height,
		       V4L2_FIELD_INTERLACED);

	videobuf_queue_init(&fh->mpegq, &blackbird_qops,
			    dev->pci, &dev->slock,
			    V4L2_BUF_TYPE_VIDEO_CAPTURE,

	if (fh->mpegq.reading)
		videobuf_read_stop(&fh->mpegq);

	videobuf_mmap_free(&fh->mpegq);
	file->private_data = NULL;
	kfree(fh);
	return 0;

	memset(dev,0,sizeof(*dev));
	dev->pci = pci_dev;
	dev->core = core;
	dev->width = 720;
	dev->height = 480;

	err = cx8802_init_common(dev);
	if (0 != err)


	/* common */
	cx8802_fini_common(dev);
	cx88_core_put(dev->core,dev->pci);
	kfree(dev);
}

static struct pci_device_id cx8802_pci_tbl[] = {

	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
	       SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
#endif
	return pci_register_driver(&blackbird_pci_driver);
}

static void blackbird_fini(void)




/*
 * $Id: cx88-cards.c,v 1.66 2005/03/04 09:12:23 kraxel Exp $
 *
 * device driver for Conexant 2388x based TV cards
 * card-specific stuff.

#include <linux/pci.h>
#include <linux/delay.h>

#if defined(CONFIG_VIDEO_CX88_DVB) || defined(CONFIG_VIDEO_CX88_DVB_MODULE)
# define WITH_DVB 1
#endif

#include "cx88.h"
#ifdef WITH_DVB
#include "cx22702.h"
#endif

/* ------------------------------------------------------------------ */
/* board config info                                                  */

	[CX88_BOARD_HAUPPAUGE] = {
		.name		= "Hauppauge WinTV 34xxx models",
		.tuner_type     = UNSET,
		.tda9887_conf   = TDA9887_PRESENT,
		.input          = {{
			.type   = CX88_VMUX_TELEVISION,
			.vmux   = 0,

	},
	[CX88_BOARD_PIXELVIEW] = {
		.name           = "PixelView",
		.tuner_type     = 5,
		.input          = {{
			.type   = CX88_VMUX_TELEVISION,
			.vmux   = 0,

                        .gpio0  = 0x03fe,
		}},
	},
        [CX88_BOARD_WINFAST2000XP_EXPERT] = {
                .name           = "Leadtek Winfast 2000XP Expert",
                .tuner_type     = 44,
		.tda9887_conf   = TDA9887_PRESENT,

                .input          = {{
                        .type   = CX88_VMUX_TELEVISION,
                        .vmux   = 0,
			.gpio0  = 0x0035e700,
			.gpio1  = 0x00003004,
			.gpio2  = 0x0035e700,
			.gpio3  = 0x02000000,
		},{

			.type   = CX88_VMUX_COMPOSITE1,
			.vmux   = 1,
			.gpio0  = 0x0035c700,
			.gpio1  = 0x00003004,
			.gpio2  = 0x0035c700,
			.gpio3  = 0x02000000,
		},{
			.type   = CX88_VMUX_SVIDEO,
			.vmux   = 2,
			.gpio0  = 0x0035c700,
			.gpio1  = 0x0035c700,
			.gpio2  = 0x02000000,
			.gpio3  = 0x02000000,
		}},
                .radio = {
			.type   = CX88_RADIO,
			.gpio0  = 0x0035d700,
			.gpio1  = 0x00007004,
			.gpio2  = 0x0035d700,
			.gpio3  = 0x02000000,
		 },
        },
        [CX88_BOARD_LEADTEK_PVR2000] = {
		// gpio values for PAL version from regspy by DScaler
                .name           = "Leadtek PVR 2000",
                .tuner_type     = 38,
		.tda9887_conf   = TDA9887_PRESENT,
                .input          = {{
                        .type   = CX88_VMUX_TELEVISION,
                        .vmux   = 0,
                        .gpio0  = 0x0000bde6,
                },{
                        .type   = CX88_VMUX_COMPOSITE1,
                        .vmux   = 1,
                        .gpio0  = 0x0000bde6,
                },{
                        .type   = CX88_VMUX_SVIDEO,
                        .vmux   = 2,
                        .gpio0  = 0x0000bde6,
                }},
                .radio = {
                        .type   = CX88_RADIO,
                        .gpio0  = 0x0000bd62,
                },
		.blackbird = 1,
        },

                .name           = "KWorld/VStream XPert DVB-T",
		.tuner_type     = TUNER_ABSENT,
                .input          = {{
                        .type   = CX88_VMUX_DVB,
                        .vmux   = 0,
                },{
                        .type   = CX88_VMUX_COMPOSITE1,
                        .vmux   = 1,
			.gpio0  = 0x0700,
			.gpio2  = 0x0101,
                },{
                        .type   = CX88_VMUX_SVIDEO,
                        .vmux   = 2,
			.gpio0  = 0x0700,
			.gpio2  = 0x0101,
                }},
		.dvb            = 1,
	},

		}},
		.dvb            = 1,
	},
	[CX88_BOARD_DNTV_LIVE_DVB_T] = {
		.name	        = "digitalnow DNTV Live! DVB-T",
		.tuner_type     = TUNER_ABSENT,
		.input	        = {{
			.type   = CX88_VMUX_COMPOSITE1,
			.vmux   = 1,
			.gpio0  = 0x00000700,
			.gpio2  = 0x00000101,
		},{
			.type   = CX88_VMUX_SVIDEO,
			.vmux   = 2,
			.gpio0  = 0x00000700,
			.gpio2  = 0x00000101,
		}},
		.dvb            = 1,
	},
	[CX88_BOARD_PCHDTV_HD3000] = {
		.name           = "pcHDTV HD3000 HDTV",
		.tuner_type     = TUNER_THOMSON_DTT7610,
		.input          = {{
			.type   = CX88_VMUX_TELEVISION,
			.vmux   = 0,
			.gpio0  = 0x00008484,
			.gpio1  = 0x00000000,
			.gpio2  = 0x00000000,
			.gpio3  = 0x00000000,
		},{
			.type   = CX88_VMUX_COMPOSITE1,
			.vmux   = 1,
			.gpio0  = 0x00008400,
			.gpio1  = 0x00000000,
			.gpio2  = 0x00000000,
			.gpio3  = 0x00000000,
		},{
			.type   = CX88_VMUX_SVIDEO,
			.vmux   = 2,
			.gpio0  = 0x00008400,
			.gpio1  = 0x00000000,
			.gpio2  = 0x00000000,
			.gpio3  = 0x00000000,
		}},
		.radio = {
			.type   = CX88_RADIO,
			.vmux   = 2,
			.gpio0  = 0x00008400,
			.gpio1  = 0x00000000,
			.gpio2  = 0x00000000,
			.gpio3  = 0x00000000,
		},
		.dvb            = 1,
	},
	[CX88_BOARD_HAUPPAUGE_ROSLYN] = {
		// entry added by Kaustubh D. Bhalerao <bhalerao.1@osu.edu>
		// GPIO values obtained from regspy, courtesy Sean Covel
		.name        = "Hauppauge WinTV 28xxx (Roslyn) models",
		.tuner_type  = UNSET,
		.input          = {{
			.type   = CX88_VMUX_TELEVISION,
			.vmux   = 0,
			.gpio0  = 0xed12,  // internal decoder
			.gpio2  = 0x00ff,
		},{
			.type   = CX88_VMUX_DEBUG,
			.vmux   = 0,
			.gpio0  = 0xff01,  // mono from tuner chip
		},{
			.type   = CX88_VMUX_COMPOSITE1,
			.vmux   = 1,
			.gpio0  = 0xff02,
		},{
			.type   = CX88_VMUX_SVIDEO,
			.vmux   = 2,
			.gpio0  = 0xed92,
			.gpio2  = 0x00ff,
		}},
		.radio = {
			 .type   = CX88_RADIO,
			 .gpio0  = 0xed96,
			 .gpio2  = 0x00ff,
		 },
		.blackbird = 1,
	},
	[CX88_BOARD_DIGITALLOGIC_MEC] = {
		/* params copied over from Leadtek PVR 2000 */
		.name           = "Digital-Logic MICROSPACE Entertainment Center (MEC)",
		/* not sure yet about the tuner type */
		.tuner_type     = 38,
		.tda9887_conf   = TDA9887_PRESENT,
		.input          = {{
			.type   = CX88_VMUX_TELEVISION,
			.vmux   = 0,
			.gpio0  = 0x0000bde6,
		},{
			.type   = CX88_VMUX_COMPOSITE1,
			.vmux   = 1,
			.gpio0  = 0x0000bde6,
		},{
			.type   = CX88_VMUX_SVIDEO,
			.vmux   = 2,
			.gpio0  = 0x0000bde6,
		}},
		.radio = {
			.type   = CX88_RADIO,
			.gpio0  = 0x0000bd62,
		},
		.blackbird = 1,
	},
	[CX88_BOARD_IODATA_GVBCTV7E] = {
		.name           = "IODATA GV/BCTV7E",
		.tuner_type     = TUNER_PHILIPS_FQ1286,
		.tda9887_conf   = TDA9887_PRESENT,
		.input          = {{
			.type   = CX88_VMUX_TELEVISION,
			.vmux   = 1,
			.gpio1  = 0x0000e03f,
		},{
			.type   = CX88_VMUX_COMPOSITE1,
			.vmux   = 2,
			.gpio1  = 0x0000e07f,
		},{
			.type   = CX88_VMUX_SVIDEO,
			.vmux   = 3,
			.gpio1  = 0x0000e07f,
		}}
	},
};
const unsigned int cx88_bcount = ARRAY_SIZE(cx88_boards);


	},{
                .subvendor = 0x107d,
                .subdevice = 0x6611,
                .card      = CX88_BOARD_WINFAST2000XP_EXPERT,
	},{
                .subvendor = 0x107d,
                .subdevice = 0x6613,	/* NTSC */
                .card      = CX88_BOARD_WINFAST2000XP_EXPERT,
	},{
		.subvendor = 0x107d,
                .subdevice = 0x6620,

		.subvendor = 0x18AC,
		.subdevice = 0xDB10,
		.card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS,
	},{
                .subvendor = 0x1554,
                .subdevice = 0x4811,
                .card      = CX88_BOARD_PIXELVIEW,
	},{
		.subvendor = 0x7063,
		.subdevice = 0x3000, /* HD-3000 card */
		.card      = CX88_BOARD_PCHDTV_HD3000,
	},{
		.subvendor = 0x17DE,
		.subdevice = 0xA8A6,
		.card      = CX88_BOARD_DNTV_LIVE_DVB_T,
	},{
		.subvendor = 0x0070,
		.subdevice = 0x2801,
		.card      = CX88_BOARD_HAUPPAUGE_ROSLYN,
	},{
		.subvendor = 0x14F1,
		.subdevice = 0x0342,
		.card      = CX88_BOARD_DIGITALLOGIC_MEC,
	},{
		.subvendor = 0x10fc,
		.subdevice = 0xd035,
		.card      = CX88_BOARD_IODATA_GVBCTV7E,
	}
};
const unsigned int cx88_idcount = ARRAY_SIZE(cx88_subids);


static void __devinit leadtek_eeprom(struct cx88_core *core, u8 *eeprom_data)
{
	/* This is just for the "Winfast 2000XP Expert" board ATM; I don't have data on
	 * any others.
	 *
	 * Byte 0 is 1 on the NTSC board.

	core->has_radio  = 1;
	core->tuner_type = (eeprom_data[6] == 0x13) ? 43 : 38;

	printk(KERN_INFO "%s: Leadtek Winfast 2000XP Expert config: "
	       "tuner=%d, eeprom[0]=0x%02x\n",
	       core->name, core->tuner_type, eeprom_data[0]);
}


/* ----------------------------------------------------------------------- */
/* some hauppauge specific stuff                                           */

static struct {
        int  id;
        char *name;
} hauppauge_tuner[] __devinitdata = {
        { TUNER_ABSENT,        "" },
        { TUNER_ABSENT,        "External" },
        { TUNER_ABSENT,        "Unspecified" },
        { TUNER_PHILIPS_PAL,   "Philips FI1216" },
        { TUNER_PHILIPS_SECAM, "Philips FI1216MF" },
        { TUNER_PHILIPS_NTSC,  "Philips FI1236" },
        { TUNER_PHILIPS_PAL_I, "Philips FI1246" },
        { TUNER_PHILIPS_PAL_DK,"Philips FI1256" },
        { TUNER_PHILIPS_PAL,   "Philips FI1216 MK2" },
        { TUNER_PHILIPS_SECAM, "Philips FI1216MF MK2" },
        { TUNER_PHILIPS_NTSC,  "Philips FI1236 MK2" },
        { TUNER_PHILIPS_PAL_I, "Philips FI1246 MK2" },
        { TUNER_PHILIPS_PAL_DK,"Philips FI1256 MK2" },
        { TUNER_TEMIC_NTSC,    "Temic 4032FY5" },
        { TUNER_TEMIC_PAL,     "Temic 4002FH5" },
        { TUNER_TEMIC_PAL_I,   "Temic 4062FY5" },
        { TUNER_PHILIPS_PAL,   "Philips FR1216 MK2" },
        { TUNER_PHILIPS_SECAM, "Philips FR1216MF MK2" },
        { TUNER_PHILIPS_NTSC,  "Philips FR1236 MK2" },
        { TUNER_PHILIPS_PAL_I, "Philips FR1246 MK2" },
        { TUNER_PHILIPS_PAL_DK,"Philips FR1256 MK2" },
        { TUNER_PHILIPS_PAL,   "Philips FM1216" },
        { TUNER_PHILIPS_SECAM, "Philips FM1216MF" },
        { TUNER_PHILIPS_NTSC,  "Philips FM1236" },
        { TUNER_PHILIPS_PAL_I, "Philips FM1246" },
        { TUNER_PHILIPS_PAL_DK,"Philips FM1256" },
        { TUNER_TEMIC_4036FY5_NTSC, "Temic 4036FY5" },
        { TUNER_ABSENT,        "Samsung TCPN9082D" },
        { TUNER_ABSENT,        "Samsung TCPM9092P" },
        { TUNER_TEMIC_4006FH5_PAL, "Temic 4006FH5" },
        { TUNER_ABSENT,        "Samsung TCPN9085D" },
        { TUNER_ABSENT,        "Samsung TCPB9085P" },
        { TUNER_ABSENT,        "Samsung TCPL9091P" },
        { TUNER_TEMIC_4039FR5_NTSC, "Temic 4039FR5" },
        { TUNER_PHILIPS_FQ1216ME,   "Philips FQ1216 ME" },
        { TUNER_TEMIC_4066FY5_PAL_I, "Temic 4066FY5" },
        { TUNER_PHILIPS_NTSC,        "Philips TD1536" },
        { TUNER_PHILIPS_NTSC,        "Philips TD1536D" },
	{ TUNER_PHILIPS_NTSC,  "Philips FMR1236" }, /* mono radio */
        { TUNER_ABSENT,        "Philips FI1256MP" },
        { TUNER_ABSENT,        "Samsung TCPQ9091P" },
        { TUNER_TEMIC_4006FN5_MULTI_PAL, "Temic 4006FN5" },
        { TUNER_TEMIC_4009FR5_PAL, "Temic 4009FR5" },
        { TUNER_TEMIC_4046FM5,     "Temic 4046FM5" },
	{ TUNER_TEMIC_4009FN5_MULTI_PAL_FM, "Temic 4009FN5" },
	{ TUNER_ABSENT,        "Philips TD1536D_FH_44"},
	{ TUNER_LG_NTSC_FM,    "LG TPI8NSR01F"},
	{ TUNER_LG_PAL_FM,     "LG TPI8PSB01D"},
	{ TUNER_LG_PAL,        "LG TPI8PSB11D"},
	{ TUNER_LG_PAL_I_FM,   "LG TAPC-I001D"},
	{ TUNER_LG_PAL_I,      "LG TAPC-I701D"}
};

static void hauppauge_eeprom(struct cx88_core *core, u8 *eeprom_data)
{
	struct tveeprom tv;

	if (eeprom_data[0] != 0x84 || eeprom_data[2] != 0) {
		printk(KERN_WARNING "%s: Hauppauge eeprom: invalid\n",
		       core->name);
		return;
	}

	/* Block 2 starts after len+3 bytes header */
	blk2 = eeprom_data[1] + 3;

	/* decode + use some config infos */
	model = eeprom_data[12] << 8 | eeprom_data[11];
	tuner = eeprom_data[9];
	radio = eeprom_data[blk2-1] & 0x01;

        if (tuner < ARRAY_SIZE(hauppauge_tuner))
                core->tuner_type = hauppauge_tuner[tuner].id;
	if (radio)
		core->has_radio = 1;

	tveeprom_hauppauge_analog(&tv, eeprom_data);
	core->tuner_type = tv.tuner_type;
	core->has_radio  = tv.has_radio;
				   ? hauppauge_tuner[tuner].name : "?"),
	       core->tuner_type, radio ? "yes" : "no");
}

#ifdef WITH_DVB
static int hauppauge_eeprom_dvb(struct cx88_core *core, u8 *ee)
{
	int model;
	int tuner;
	char *tname;

	/* Make sure we support the board model */
	model = ee[0x1f] << 24 | ee[0x1e] << 16 | ee[0x1d] << 8 | ee[0x1c];

	/* Make sure we support the tuner */
	tuner = ee[0x2d];
	switch(tuner) {
	case 0x4B: /* dtt 7595 */
	case 0x4C: /* dtt 7592 */
		core->pll_type = PLLTYPE_DTT7595;
		break;
	case 0x4C:
		tname = "Thomson DTT 7592";
		core->pll_type = PLLTYPE_DTT7592;
		break;
	default:
		printk("%s: error: unknown hauppauge tuner 0x%02x\n",
		       core->name, tuner);
		return -ENODEV;
	}
	printk(KERN_INFO "%s: hauppauge eeprom: model=%d, tuner=%d\n",
	       core->name, model, tuner);
	return 0;
	core->pll_addr = 0x61;
	core->demod_addr = 0x43;
}
#endif

/* ----------------------------------------------------------------------- */
/* some GDI (was: Modular Technology) specific stuff                       */


/* ----------------------------------------------------------------------- */

static int
i2c_eeprom(struct i2c_client *c, unsigned char *eedata, int len)
{
	unsigned char buf;
	int err;

	c->addr = 0xa0 >> 1;
	buf = 0;
	if (1 != (err = i2c_master_send(c,&buf,1))) {
		printk(KERN_INFO "cx88: Huh, no eeprom present (err=%d)?\n",
		       err);
		return -1;
	}
	if (len != (err = i2c_master_recv(c,eedata,len))) {
		printk(KERN_WARNING "cx88: i2c eeprom read error (err=%d)\n",
		       err);
		return -1;
	}
#if 0
	for (i = 0; i < len; i++) {
		if (0 == (i % 16))
			printk(KERN_INFO "cx88 ee: %02x:",i);
		printk(" %02x",eedata[i]);
		if (15 == (i % 16))
			printk("\n");
	}
#endif
	return 0;
}

void cx88_card_list(struct cx88_core *core, struct pci_dev *pci)
{
	int i;

{
	static u8 eeprom[128];

	if (0 == core->i2c_rc) {
		core->i2c_client.addr = 0xa0 >> 1;
		tveeprom_read(&core->i2c_client,eeprom,sizeof(eeprom));
	}

	switch (core->board) {
	case CX88_BOARD_HAUPPAUGE:
	case CX88_BOARD_HAUPPAUGE_ROSLYN:
		if (0 == core->i2c_rc)
			hauppauge_eeprom(core,eeprom+8);
		hauppauge_eeprom(core,eeprom+8);
		break;
	case CX88_BOARD_GDI:
		if (0 == core->i2c_rc)
			gdi_eeprom(core,eeprom);
		gdi_eeprom(core,eeprom);
		break;
	case CX88_BOARD_WINFAST2000XP_EXPERT:
		if (0 == core->i2c_rc)
			leadtek_eeprom(core,eeprom);
		break;
	case CX88_BOARD_HAUPPAUGE_DVB_T1:
		if (0 == core->i2c_rc)
			hauppauge_eeprom_dvb(core,eeprom);
		break;
	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:
	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:
		/* GPIO0:0 is hooked to mt352 reset pin */
		cx_set(MO_GP0_IO, 0x00000101);
		cx_clear(MO_GP0_IO, 0x00000001);
		msleep(1);
		cx_set(MO_GP0_IO, 0x00000101);
		break;
	case CX88_BOARD_KWORLD_DVB_T:
	case CX88_BOARD_DNTV_LIVE_DVB_T:
		cx_set(MO_GP0_IO, 0x00000707);
		cx_set(MO_GP2_IO, 0x00000101);
		cx_clear(MO_GP2_IO, 0x00000001);
		msleep(1);
		cx_clear(MO_GP0_IO, 0x00000007);
		cx_set(MO_GP2_IO, 0x00000101);
		core->pll_addr   = 0x60;
		core->demod_addr = 0x43;
		break;
#endif
	}
	if (cx88_boards[core->board].radio.type == CX88_RADIO)
		core->has_radio = 1;

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-core.c (-10 / +32 lines)
1	/*	1	/*
2	* $Id: cx88-core.c,v 1.15 2004/10/25 11:26:36 kraxel Exp $	2	* $Id: cx88-core.c,v 1.24 2005/01/19 12:01:55 kraxel Exp $
3	*	3	*
4	* device driver for Conexant 2388x based TV cards	4	* device driver for Conexant 2388x based TV cards
5	* driver core	5	* driver core
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29	#include <linux/kmod.h>	30	#include <linux/kmod.h>
Lines 62-67 static unsigned int nicam = 0; Link Here
62	module_param(nicam,int,0644);	63	module_param(nicam,int,0644);
63	MODULE_PARM_DESC(nicam,"tv audio is nicam");	64	MODULE_PARM_DESC(nicam,"tv audio is nicam");
64		65
		66	static unsigned int nocomb = 0;
		67	module_param(nocomb,int,0644);
		68	MODULE_PARM_DESC(nocomb,"disable comb filter");
		69
65	#define dprintk(level,fmt, arg...) if (core_debug >= level) \	70	#define dprintk(level,fmt, arg...) if (core_debug >= level) \
66	printk(KERN_DEBUG "%s: " fmt, core->name , ## arg)	71	printk(KERN_DEBUG "%s: " fmt, core->name , ## arg)
67		72
Lines 462-467 int cx88_risc_decode(u32 risc) Link Here
462	return incr[risc >> 28] ? incr[risc >> 28] : 1;	467	return incr[risc >> 28] ? incr[risc >> 28] : 1;
463	}	468	}
464		469
		470	#if 0 /* currently unused, but useful for debugging */
465	void cx88_risc_disasm(struct cx88_core *core,	471	void cx88_risc_disasm(struct cx88_core *core,
466	struct btcx_riscmem *risc)	472	struct btcx_riscmem *risc)
467	{	473	{
Lines 479-484 void cx88_risc_disasm(struct cx88_core * Link Here
479	break;	485	break;
480	}	486	}
481	}	487	}
		488	#endif
482		489
483	void cx88_sram_channel_dump(struct cx88_core *core,	490	void cx88_sram_channel_dump(struct cx88_core *core,
484	struct sram_channel *ch)	491	struct sram_channel *ch)
Lines 579-588 void cx88_print_irqbits(char *name, char Link Here
579		586
580	/* ------------------------------------------------------------------ */	587	/* ------------------------------------------------------------------ */
581		588
582	void cx88_irq(struct cx88_core *core, u32 status, u32 mask)	589	int cx88_core_irq(struct cx88_core *core, u32 status)
583	{	590	{
584	cx88_print_irqbits(core->name, "irq pci",	591	int handled = 0;
585	cx88_pci_irqs, status, mask);	592
		593	if (status & (1<<18)) {
		594	cx88_ir_irq(core);
		595	handled++;
		596	}
		597	if (!handled)
		598	cx88_print_irqbits(core->name, "irq pci",
		599	cx88_pci_irqs, status,
		600	core->pci_irqmask);
		601	return handled;
586	}	602	}
587		603
588	void cx88_wakeup(struct cx88_core *core,	604	void cx88_wakeup(struct cx88_core *core,
Lines 800-805 int cx88_set_scale(struct cx88_core *cor Link Here
800	value \|= (1 << 0); // 3-tap interpolation	816	value \|= (1 << 0); // 3-tap interpolation
801	if (width < 193)	817	if (width < 193)
802	value \|= (1 << 1); // 5-tap interpolation	818	value \|= (1 << 1); // 5-tap interpolation
		819	if (nocomb)
		820	value \|= (3 << 5); // disable comb filter
803		821
804	cx_write(MO_FILTER_EVEN, value);	822	cx_write(MO_FILTER_EVEN, value);
805	cx_write(MO_FILTER_ODD, value);	823	cx_write(MO_FILTER_ODD, value);
Lines 887-894 static int set_tvaudio(struct cx88_core Link Here
887	cx88_set_tvaudio(core);	905	cx88_set_tvaudio(core);
888	// cx88_set_stereo(dev,V4L2_TUNER_MODE_STEREO);	906	// cx88_set_stereo(dev,V4L2_TUNER_MODE_STEREO);
889		907
890	cx_write(MO_AUDD_LNGTH, 128/8); /* fifo size */	908	cx_write(MO_AUDD_LNGTH, 128); /* fifo size */
891	cx_write(MO_AUDR_LNGTH, 128/8); /* fifo size */	909	cx_write(MO_AUDR_LNGTH, 128); /* fifo size */
892	cx_write(MO_AUD_DMACNTRL, 0x03); /* need audio fifo */	910	cx_write(MO_AUD_DMACNTRL, 0x03); /* need audio fifo */
893	return 0;	911	return 0;
894	}	912	}
Lines 969-974 int cx88_set_tvnorm(struct cx88_core *co Link Here
969	cx_write(MO_VBI_PACKET, ((1 << 11) \| /* (norm_vdelay(norm) << 11) \| */	987	cx_write(MO_VBI_PACKET, ((1 << 11) \| /* (norm_vdelay(norm) << 11) \| */
970	norm_vbipack(norm)));	988	norm_vbipack(norm)));
971		989
		990	// this is needed as well to set all tvnorm parameter
		991	cx88_set_scale(core, 320, 240, V4L2_FIELD_INTERLACED);
		992
972	// audio	993	// audio
973	set_tvaudio(core);	994	set_tvaudio(core);
974		995
Lines 1105-1113 struct cx88_core* cx88_core_get(struct p Link Here
1105	goto fail_unlock;	1126	goto fail_unlock;
1106		1127
1107	memset(core,0,sizeof(*core));	1128	memset(core,0,sizeof(*core));
		1129	atomic_inc(&core->refcount);
1108	core->pci_bus = pci->bus->number;	1130	core->pci_bus = pci->bus->number;
1109	core->pci_slot = PCI_SLOT(pci->devfn);	1131	core->pci_slot = PCI_SLOT(pci->devfn);
1110	atomic_inc(&core->refcount);	1132	core->pci_irqmask = 0x00fc00;
1111		1133
1112	core->nr = cx88_devcount++;	1134	core->nr = cx88_devcount++;
1113	sprintf(core->name,"cx88[%d]",core->nr);	1135	sprintf(core->name,"cx88[%d]",core->nr);
Lines 1150-1155 struct cx88_core* cx88_core_get(struct p Link Here
1150	cx88_reset(core);	1172	cx88_reset(core);
1151	cx88_i2c_init(core,pci);	1173	cx88_i2c_init(core,pci);
1152	cx88_card_setup(core);	1174	cx88_card_setup(core);
		1175	cx88_ir_init(core,pci);
1153		1176
1154	up(&devlist);	1177	up(&devlist);
1155	return core;	1178	return core;
Lines 1170-1175 void cx88_core_put(struct cx88_core *cor Link Here
1170	return;	1193	return;
1171		1194
1172	down(&devlist);	1195	down(&devlist);
		1196	cx88_ir_fini(core);
1173	if (0 == core->i2c_rc)	1197	if (0 == core->i2c_rc)
1174	i2c_bit_del_bus(&core->i2c_adap);	1198	i2c_bit_del_bus(&core->i2c_adap);
1175	list_del(&core->devlist);	1199	list_del(&core->devlist);
Lines 1187-1193 EXPORT_SYMBOL(cx88_vid_irqs); Link Here
1187	EXPORT_SYMBOL(cx88_mpeg_irqs);	1211	EXPORT_SYMBOL(cx88_mpeg_irqs);
1188	EXPORT_SYMBOL(cx88_print_irqbits);	1212	EXPORT_SYMBOL(cx88_print_irqbits);
1189		1213
1190	EXPORT_SYMBOL(cx88_irq);	1214	EXPORT_SYMBOL(cx88_core_irq);
1191	EXPORT_SYMBOL(cx88_wakeup);	1215	EXPORT_SYMBOL(cx88_wakeup);
1192	EXPORT_SYMBOL(cx88_reset);	1216	EXPORT_SYMBOL(cx88_reset);
1193	EXPORT_SYMBOL(cx88_shutdown);	1217	EXPORT_SYMBOL(cx88_shutdown);
Lines 1197-1204 EXPORT_SYMBOL(cx88_risc_databuffer); Link Here
1197	EXPORT_SYMBOL(cx88_risc_stopper);	1221	EXPORT_SYMBOL(cx88_risc_stopper);
1198	EXPORT_SYMBOL(cx88_free_buffer);	1222	EXPORT_SYMBOL(cx88_free_buffer);
1199		1223
1200	EXPORT_SYMBOL(cx88_risc_disasm);
1201
1202	EXPORT_SYMBOL(cx88_sram_channels);	1224	EXPORT_SYMBOL(cx88_sram_channels);
1203	EXPORT_SYMBOL(cx88_sram_channel_setup);	1225	EXPORT_SYMBOL(cx88_sram_channel_setup);
1204	EXPORT_SYMBOL(cx88_sram_channel_dump);	1226	EXPORT_SYMBOL(cx88_sram_channel_dump);

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-dvb.c (-72 / +115 lines)
1	/*	1	/*
2	* $Id: cx88-dvb.c,v 1.19 2004/11/07 14:44:59 kraxel Exp $	2	* $Id: cx88-dvb.c,v 1.31 2005/03/07 15:58:05 kraxel Exp $
3	*	3	*
4	* device driver for Conexant 2388x based TV cards	4	* device driver for Conexant 2388x based TV cards
5	* MPEG Transport Stream (DVB) routines	5	* MPEG Transport Stream (DVB) routines
Lines 30-39 Link Here
30	#include <linux/file.h>	30	#include <linux/file.h>
31	#include <linux/suspend.h>	31	#include <linux/suspend.h>
32		32
		33	/* those two frontends need merging via linuxtv cvs ... */
		34	#define HAVE_CX22702 1
		35	#define HAVE_OR51132 1
		36
33	#include "cx88.h"	37	#include "cx88.h"
34	#include "cx22702.h"	38	#include "dvb-pll.h"
35	#include "mt352.h"	39	#include "mt352.h"
36	#include "mt352_priv.h" /* FIXME */	40	#include "mt352_priv.h"
		41	#if HAVE_CX22702
		42	# include "cx22702.h"
		43	#endif
		44	#if HAVE_OR51132
		45	# include "or51132.h"
		46	#endif
37		47
38	MODULE_DESCRIPTION("driver for cx2388x based DVB cards");	48	MODULE_DESCRIPTION("driver for cx2388x based DVB cards");
39	MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");	49	MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
Lines 110-220 static int dvico_fusionhdtv_demod_init(s Link Here
110	return 0;	120	return 0;
111	}	121	}
112		122
113	#define IF_FREQUENCYx6 217 /* 6 * 36.16666666667MHz */	123	static int dntv_live_dvbt_demod_init(struct dvb_frontend* fe)
114
115	static int lg_z201_pll_set(struct dvb_frontend* fe,
116	struct dvb_frontend_parameters* params, u8* pllbuf)
117	{	124	{
118	u32 div;	125	static u8 clock_config [] = { 0x89, 0x38, 0x39 };
119	unsigned char cp = 0;	126	static u8 reset [] = { 0x50, 0x80 };
120	unsigned char bs = 0;	127	static u8 adc_ctl_1_cfg [] = { 0x8E, 0x40 };
121		128	static u8 agc_cfg [] = { 0x67, 0x10, 0x23, 0x00, 0xFF, 0xFF,
122	div = (((params->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;	129	0x00, 0xFF, 0x00, 0x40, 0x40 };
123		130	static u8 dntv_extra[] = { 0xB5, 0x7A };
124	if (params->frequency < 542000000) cp = 0xbc;	131	static u8 capt_range_cfg[] = { 0x75, 0x32 };
125	else if (params->frequency < 830000000) cp = 0xf4;
126	else cp = 0xfc;
127		132
128	if (params->frequency == 0) bs = 0x03;	133	mt352_write(fe, clock_config, sizeof(clock_config));
129	else if (params->frequency < 157500000) bs = 0x01;	134	udelay(2000);
130	else if (params->frequency < 443250000) bs = 0x02;	135	mt352_write(fe, reset, sizeof(reset));
131	else bs = 0x04;	136	mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
132		137
133	pllbuf[0] = 0xC2; /* Note: non-linux standard PLL I2C address */	138	mt352_write(fe, agc_cfg, sizeof(agc_cfg));
134	pllbuf[1] = div >> 8;	139	udelay(2000);
135	pllbuf[2] = div & 0xff;	140	mt352_write(fe, dntv_extra, sizeof(dntv_extra));
136	pllbuf[3] = cp;	141	mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
137	pllbuf[4] = bs;
138		142
139	return 0;	143	return 0;
140	}	144	}
141		145
142	static int thomson_dtt7579_pll_set(struct dvb_frontend* fe,	146	static int mt352_pll_set(struct dvb_frontend* fe,
143	struct dvb_frontend_parameters* params,	147	struct dvb_frontend_parameters* params,
144	u8* pllbuf)	148	u8* pllbuf)
145	{	149	{
146	u32 div;	150	struct cx8802_dev *dev= fe->dvb->priv;
147	unsigned char cp = 0;
148	unsigned char bs = 0;
149
150	div = (((params->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
151
152	if (params->frequency < 542000000) cp = 0xb4;
153	else if (params->frequency < 771000000) cp = 0xbc;
154	else cp = 0xf4;
155
156	if (params->frequency == 0) bs = 0x03;
157	else if (params->frequency < 443250000) bs = 0x02;
158	else bs = 0x08;
159
160	pllbuf[0] = 0xc0; // Note: non-linux standard PLL i2c address
161	pllbuf[1] = div >> 8;
162	pllbuf[2] = div & 0xff;
163	pllbuf[3] = cp;
164	pllbuf[4] = bs;
165		151
		152	pllbuf[0] = dev->core->pll_addr << 1;
		153	dvb_pll_configure(dev->core->pll_desc, pllbuf+1,
		154	params->frequency,
		155	params->u.ofdm.bandwidth);
166	return 0;	156	return 0;
167	}	157	}
168		158
169	struct mt352_config dvico_fusionhdtv_dvbt1 = {	159	static struct mt352_config dvico_fusionhdtv = {
170	.demod_address = 0x0F,	160	.demod_address = 0x0F,
171	.demod_init = dvico_fusionhdtv_demod_init,	161	.demod_init = dvico_fusionhdtv_demod_init,
172	.pll_set = lg_z201_pll_set,	162	.pll_set = mt352_pll_set,
173	};	163	};
174		164
175	struct mt352_config dvico_fusionhdtv_dvbt_plus = {	165	static struct mt352_config dntv_live_dvbt_config = {
176	.demod_address = 0x0F,	166	.demod_address = 0x0f,
177	.demod_init = dvico_fusionhdtv_demod_init,	167	.demod_init = dntv_live_dvbt_demod_init,
178	.pll_set = thomson_dtt7579_pll_set,	168	.pll_set = mt352_pll_set,
		169	};
		170
		171	#if HAVE_CX22702
		172	static struct cx22702_config connexant_refboard_config = {
		173	.demod_address = 0x43,
		174	.pll_address = 0x60,
		175	.pll_desc = &dvb_pll_thomson_dtt7579,
		176	};
		177
		178	static struct cx22702_config hauppauge_novat_config = {
		179	.demod_address = 0x43,
		180	.pll_address = 0x61,
		181	.pll_desc = &dvb_pll_thomson_dtt759x,
179	};	182	};
		183	#endif
		184
		185	#if HAVE_OR51132
		186	static int or51132_set_ts_param(struct dvb_frontend* fe,
		187	int is_punctured)
		188	{
		189	struct cx8802_dev *dev= fe->dvb->priv;
		190	dev->ts_gen_cntrl = is_punctured ? 0x04 : 0x00;
		191	return 0;
		192	}
		193
		194	struct or51132_config pchdtv_hd3000 = {
		195	.demod_address = 0x15,
		196	.pll_address = 0x61,
		197	.pll_desc = &dvb_pll_thomson_dtt7610,
		198	.set_ts_params = or51132_set_ts_param,
		199	};
		200	#endif
180		201
181	static int dvb_register(struct cx8802_dev *dev)	202	static int dvb_register(struct cx8802_dev *dev)
182	{	203	{
183	/* init struct videobuf_dvb */	204	/* init struct videobuf_dvb */
184	dev->dvb.name = dev->core->name;	205	dev->dvb.name = dev->core->name;
		206	dev->ts_gen_cntrl = 0x0c;
185		207
186	/* init frontend */	208	/* init frontend */
187	switch (dev->core->board) {	209	switch (dev->core->board) {
		210	#if HAVE_CX22702
188	case CX88_BOARD_HAUPPAUGE_DVB_T1:	211	case CX88_BOARD_HAUPPAUGE_DVB_T1:
		212	dev->dvb.frontend = cx22702_attach(&hauppauge_novat_config,
		213	&dev->core->i2c_adap);
		214	break;
189	case CX88_BOARD_CONEXANT_DVB_T1:	215	case CX88_BOARD_CONEXANT_DVB_T1:
190	dev->dvb.frontend = cx22702_create(&dev->core->i2c_adap,	216	dev->dvb.frontend = cx22702_attach(&connexant_refboard_config,
191	dev->core->pll_addr,	217	&dev->core->i2c_adap);
192	dev->core->pll_type,
193	dev->core->demod_addr);
194	break;	218	break;
		219	#endif
195	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:	220	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:
196	dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv_dvbt1,	221	dev->core->pll_addr = 0x61;
		222	dev->core->pll_desc = &dvb_pll_lg_z201;
		223	dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv,
197	&dev->core->i2c_adap);	224	&dev->core->i2c_adap);
198	if (dev->dvb.frontend) {
199	dev->dvb.frontend->ops->info.frequency_min = 174000000;
200	dev->dvb.frontend->ops->info.frequency_max = 862000000;
201	}
202	break;	225	break;
203	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:	226	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:
204	dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv_dvbt_plus,	227	dev->core->pll_addr = 0x60;
		228	dev->core->pll_desc = &dvb_pll_thomson_dtt7579;
		229	dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv,
		230	&dev->core->i2c_adap);
		231	break;
		232	case CX88_BOARD_KWORLD_DVB_T:
		233	case CX88_BOARD_DNTV_LIVE_DVB_T:
		234	dev->core->pll_addr = 0x61;
		235	dev->core->pll_desc = &dvb_pll_unknown_1;
		236	dev->dvb.frontend = mt352_attach(&dntv_live_dvbt_config,
		237	&dev->core->i2c_adap);
		238	break;
		239	#if HAVE_OR51132
		240	case CX88_BOARD_PCHDTV_HD3000:
		241	dev->dvb.frontend = or51132_attach(&pchdtv_hd3000,
205	&dev->core->i2c_adap);	242	&dev->core->i2c_adap);
206	if (dev->dvb.frontend) {
207	dev->dvb.frontend->ops->info.frequency_min = 174000000;
208	dev->dvb.frontend->ops->info.frequency_max = 862000000;
209	}
210	break;	243	break;
		244	#endif
211	default:	245	default:
212	printk("%s: FIXME: frontend handling not here yet ...\n",	246	printk("%s: The frontend of your DVB/ATSC card isn't supported yet\n"
213	dev->core->name);	247	"%s: you might want to look out for patches here:\n"
		248	"%s: http://dl.bytesex.org/patches/\n",
		249	dev->core->name, dev->core->name, dev->core->name);
214	break;	250	break;
215	}	251	}
216	if (NULL == dev->dvb.frontend)	252	if (NULL == dev->dvb.frontend) {
		253	printk("%s: frontend initialization failed\n",dev->core->name);
217	return -1;	254	return -1;
		255	}
		256
		257	if (dev->core->pll_desc) {
		258	dev->dvb.frontend->ops->info.frequency_min = dev->core->pll_desc->min;
		259	dev->dvb.frontend->ops->info.frequency_max = dev->core->pll_desc->max;
		260	}
218		261
219	/* Copy the board name into the DVB structure */	262	/* Copy the board name into the DVB structure */
220	strlcpy(dev->dvb.frontend->ops->info.name,	263	strlcpy(dev->dvb.frontend->ops->info.name,
Lines 222-228 static int dvb_register(struct cx8802_de Link Here
222	sizeof(dev->dvb.frontend->ops->info.name));	265	sizeof(dev->dvb.frontend->ops->info.name));
223		266
224	/* register everything */	267	/* register everything */
225	return videobuf_dvb_register(&dev->dvb);	268	return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev);
226	}	269	}
227		270
228	/* ----------------------------------------------------------- */	271	/* ----------------------------------------------------------- */
Lines 319-325 static int dvb_init(void) Link Here
319	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",	362	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
320	SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);	363	SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
321	#endif	364	#endif
322	return pci_module_init(&dvb_pci_driver);	365	return pci_register_driver(&dvb_pci_driver);
323	}	366	}
324		367
325	static void dvb_fini(void)	368	static void dvb_fini(void)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-i2c.c (-1 / +2 lines)
1	/*	1	/*
2	$Id: cx88-i2c.c,v 1.18 2004/10/13 10:39:00 kraxel Exp $	2	$Id: cx88-i2c.c,v 1.20 2005/02/15 15:59:35 kraxel Exp $
3		3
4	cx88-i2c.c -- all the i2c code is here	4	cx88-i2c.c -- all the i2c code is here
5		5
Lines 25-30 Link Here
25	*/	25	*/
26		26
27	#include <linux/module.h>	27	#include <linux/module.h>
		28	#include <linux/moduleparam.h>
28	#include <linux/init.h>	29	#include <linux/init.h>
29		30
30	#include <asm/io.h>	31	#include <asm/io.h>




/*
 * $Id: cx88-input.c,v 1.9 2005/03/04 09:12:23 kraxel Exp $
 *
 * Device driver for GPIO attached remote control interfaces
 * on Conexant 2388x based TV/DVB cards.
 *
 * Copyright (c) 2003 Pavel Machek
 * Copyright (c) 2004 Gerd Knorr
 * Copyright (c) 2004 Chris Pascoe
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/pci.h>
#include <linux/module.h>
#include <linux/moduleparam.h>

#include <media/ir-common.h>

#include "cx88.h"

/* ---------------------------------------------------------------------- */

/* DigitalNow DNTV Live DVB-T Remote */
static IR_KEYTAB_TYPE ir_codes_dntv_live_dvb_t[IR_KEYTAB_SIZE] = {
	[ 0x00 ] = KEY_ESC,         // 'go up a level?'
	[ 0x01 ] = KEY_KP1,         // '1'
	[ 0x02 ] = KEY_KP2,         // '2'
	[ 0x03 ] = KEY_KP3,         // '3'
	[ 0x04 ] = KEY_KP4,         // '4'
	[ 0x05 ] = KEY_KP5,         // '5'
	[ 0x06 ] = KEY_KP6,         // '6'
	[ 0x07 ] = KEY_KP7,         // '7'
	[ 0x08 ] = KEY_KP8,         // '8'
	[ 0x09 ] = KEY_KP9,         // '9'
	[ 0x0a ] = KEY_KP0,         // '0'
	[ 0x0b ] = KEY_TUNER,       // 'tv/fm'
	[ 0x0c ] = KEY_SEARCH,      // 'scan'
	[ 0x0d ] = KEY_STOP,        // 'stop'
	[ 0x0e ] = KEY_PAUSE,       // 'pause'
	[ 0x0f ] = KEY_LIST,        // 'source'

	[ 0x10 ] = KEY_MUTE,        // 'mute'
	[ 0x11 ] = KEY_REWIND,      // 'backward <<'
	[ 0x12 ] = KEY_POWER,       // 'power'
	[ 0x13 ] = KEY_S,           // 'snap'
	[ 0x14 ] = KEY_AUDIO,       // 'stereo'
	[ 0x15 ] = KEY_CLEAR,       // 'reset'
	[ 0x16 ] = KEY_PLAY,        // 'play'
	[ 0x17 ] = KEY_ENTER,       // 'enter'
	[ 0x18 ] = KEY_ZOOM,        // 'full screen'
	[ 0x19 ] = KEY_FASTFORWARD, // 'forward >>'
	[ 0x1a ] = KEY_CHANNELUP,   // 'channel +'
	[ 0x1b ] = KEY_VOLUMEUP,    // 'volume +'
	[ 0x1c ] = KEY_INFO,        // 'preview'
	[ 0x1d ] = KEY_RECORD,      // 'record'
	[ 0x1e ] = KEY_CHANNELDOWN, // 'channel -'
	[ 0x1f ] = KEY_VOLUMEDOWN,  // 'volume -'
};

/* ---------------------------------------------------------------------- */

/* IO-DATA BCTV7E Remote */
static IR_KEYTAB_TYPE ir_codes_iodata_bctv7e[IR_KEYTAB_SIZE] = {
	[ 0x40 ] = KEY_TV,              // TV
	[ 0x20 ] = KEY_RADIO,           // FM
	[ 0x60 ] = KEY_EPG,             // EPG
	[ 0x00 ] = KEY_POWER,           // power

	[ 0x50 ] = KEY_KP1,             // 1
	[ 0x30 ] = KEY_KP2,             // 2
	[ 0x70 ] = KEY_KP3,             // 3
	[ 0x10 ] = KEY_L,               // Live

	[ 0x48 ] = KEY_KP4,             // 4
	[ 0x28 ] = KEY_KP5,             // 5
	[ 0x68 ] = KEY_KP6,             // 6
	[ 0x08 ] = KEY_T,               // Time Shift

	[ 0x58 ] = KEY_KP7,             // 7
	[ 0x38 ] = KEY_KP8,             // 8
	[ 0x78 ] = KEY_KP9,             // 9
	[ 0x18 ] = KEY_PLAYPAUSE,       // Play

	[ 0x44 ] = KEY_KP0,             // 10
	[ 0x24 ] = KEY_ENTER,           // 11
	[ 0x64 ] = KEY_ESC,             // 12
	[ 0x04 ] = KEY_M,               // Multi

	[ 0x54 ] = KEY_VIDEO,           // VIDEO
	[ 0x34 ] = KEY_CHANNELUP,       // channel +
	[ 0x74 ] = KEY_VOLUMEUP,        // volume +
	[ 0x14 ] = KEY_MUTE,            // Mute

	[ 0x4c ] = KEY_S,               // SVIDEO
	[ 0x2c ] = KEY_CHANNELDOWN,     // channel -
	[ 0x6c ] = KEY_VOLUMEDOWN,      // volume -
	[ 0x0c ] = KEY_ZOOM,            // Zoom

	[ 0x5c ] = KEY_PAUSE,           // pause
	[ 0x3c ] = KEY_C,               // || (red)
	[ 0x7c ] = KEY_RECORD,          // recording
	[ 0x1c ] = KEY_STOP,            // stop

	[ 0x41 ] = KEY_REWIND,          // backward <<
	[ 0x21 ] = KEY_PLAY,            // play
	[ 0x61 ] = KEY_FASTFORWARD,     // forward >>
	[ 0x01 ] = KEY_NEXT,            // skip >|
};

/* ---------------------------------------------------------------------- */

struct cx88_IR {
	struct cx88_core	*core;
	struct input_dev        input;
	struct ir_input_state   ir;
	char                    name[32];
	char                    phys[32];

	/* sample from gpio pin 16 */
	int                     sampling;
	u32                     samples[16];
	int                     scount;
	unsigned long           release;

	/* poll external decoder */
	int                     polling;
	struct work_struct      work;
	struct timer_list       timer;
	u32			gpio_addr;
	u32                     last_gpio;
	u32                     mask_keycode;
	u32                     mask_keydown;
	u32                     mask_keyup;
};

static int ir_debug = 0;
module_param(ir_debug, int, 0644);    /* debug level [IR] */
MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");

#define ir_dprintk(fmt, arg...)	if (ir_debug) \
	printk(KERN_DEBUG "%s IR: " fmt , ir->core->name, ## arg)

/* ---------------------------------------------------------------------- */

static void cx88_ir_handle_key(struct cx88_IR *ir)
{
	struct cx88_core *core = ir->core;
	u32 gpio, data;

	/* read gpio value */
	gpio = cx_read(ir->gpio_addr);
	if (ir->polling) {
		if (ir->last_gpio == gpio)
			return;
		ir->last_gpio = gpio;
	}

	/* extract data */
	data = ir_extract_bits(gpio, ir->mask_keycode);
	ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n",
		gpio, data,
		ir->polling               ? "poll"  : "irq",
		(gpio & ir->mask_keydown) ? " down" : "",
		(gpio & ir->mask_keyup)   ? " up"   : "");

	if (ir->mask_keydown) {
		/* bit set on keydown */
		if (gpio & ir->mask_keydown) {
			ir_input_keydown(&ir->input,&ir->ir,data,data);
		} else {
			ir_input_nokey(&ir->input,&ir->ir);
		}

	} else if (ir->mask_keyup) {
		/* bit cleared on keydown */
		if (0 == (gpio & ir->mask_keyup)) {
			ir_input_keydown(&ir->input,&ir->ir,data,data);
		} else {
			ir_input_nokey(&ir->input,&ir->ir);
		}

	} else {
		/* can't distinguish keydown/up :-/ */
		ir_input_keydown(&ir->input,&ir->ir,data,data);
		ir_input_nokey(&ir->input,&ir->ir);
	}
}

static void ir_timer(unsigned long data)
{
	struct cx88_IR *ir = (struct cx88_IR*)data;

	schedule_work(&ir->work);
}

static void cx88_ir_work(void *data)
{
	struct cx88_IR *ir = data;
	unsigned long timeout;

	cx88_ir_handle_key(ir);
	timeout = jiffies + (ir->polling * HZ / 1000);
	mod_timer(&ir->timer, timeout);
}

/* ---------------------------------------------------------------------- */

int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
{
	struct cx88_IR *ir;
	IR_KEYTAB_TYPE *ir_codes = NULL;
	int ir_type = IR_TYPE_OTHER;

	ir = kmalloc(sizeof(*ir),GFP_KERNEL);
	if (NULL == ir)
		return -ENOMEM;
	memset(ir,0,sizeof(*ir));

	/* detect & configure */
	switch (core->board) {
	case CX88_BOARD_DNTV_LIVE_DVB_T:
		ir_codes         = ir_codes_dntv_live_dvb_t;
		ir->gpio_addr    = MO_GP1_IO;
		ir->mask_keycode = 0x1f;
		ir->mask_keyup   = 0x60;
		ir->polling      = 50; // ms
		break;
	case CX88_BOARD_HAUPPAUGE:
	case CX88_BOARD_HAUPPAUGE_DVB_T1:
		ir_codes         = ir_codes_hauppauge_new;
		ir_type          = IR_TYPE_RC5;
		ir->sampling     = 1;
		break;
	case CX88_BOARD_WINFAST2000XP_EXPERT:
		ir_codes         = ir_codes_winfast;
		ir->gpio_addr    = MO_GP0_IO;
		ir->mask_keycode = 0x8f8; 
		ir->mask_keyup   = 0x100;
		ir->polling      = 1; // ms
		break;
	case CX88_BOARD_IODATA_GVBCTV7E:
		ir_codes         = ir_codes_iodata_bctv7e;
		ir->gpio_addr    = MO_GP0_IO;
		ir->mask_keycode = 0xfd;
		ir->mask_keydown = 0x02;
		ir->polling      = 5; // ms
		break;
	}
	if (NULL == ir_codes) {
		kfree(ir);
		return -ENODEV;
	}

	/* init input device */
	snprintf(ir->name, sizeof(ir->name), "cx88 IR (%s)",
		 cx88_boards[core->board].name);
	snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
		 pci_name(pci));

	ir_input_init(&ir->input, &ir->ir, ir_type, ir_codes);
	ir->input.name = ir->name;
	ir->input.phys = ir->phys;
	ir->input.id.bustype = BUS_PCI;
	ir->input.id.version = 1;
	if (pci->subsystem_vendor) {
		ir->input.id.vendor  = pci->subsystem_vendor;
		ir->input.id.product = pci->subsystem_device;
	} else {
		ir->input.id.vendor  = pci->vendor;
		ir->input.id.product = pci->device;
	}

	/* record handles to ourself */
	ir->core = core;
	core->ir = ir;

	if (ir->polling) {
		INIT_WORK(&ir->work, cx88_ir_work, ir);
		init_timer(&ir->timer);
		ir->timer.function = ir_timer;
		ir->timer.data     = (unsigned long)ir;
		schedule_work(&ir->work);
	}
	if (ir->sampling) {
		core->pci_irqmask |= (1<<18);   // IR_SMP_INT
		cx_write(MO_DDS_IO, 0xa80a80);  // 4 kHz sample rate
		cx_write(MO_DDSCFG_IO,   0x5);  // enable
	}

	/* all done */
	input_register_device(&ir->input);
	printk("%s: registered IR remote control\n", core->name);

	return 0;
}

int cx88_ir_fini(struct cx88_core *core)
{
	struct cx88_IR *ir = core->ir;

	/* skip detach on non attached boards */
	if (NULL == ir)
		return 0;

	if (ir->polling) {
		del_timer(&ir->timer);
		flush_scheduled_work();
	}

	input_unregister_device(&ir->input);
	kfree(ir);

	/* done */
	core->ir = NULL;
	return 0;
}

/* ---------------------------------------------------------------------- */

void cx88_ir_irq(struct cx88_core *core)
{
	struct cx88_IR *ir = core->ir;
	u32 samples,rc5;
	int i;

	if (NULL == ir)
		return;
	if (!ir->sampling)
		return;

	samples = cx_read(MO_SAMPLE_IO);
	if (0 != samples  &&  0xffffffff != samples) {
		/* record sample data */
		if (ir->scount < ARRAY_SIZE(ir->samples))
			ir->samples[ir->scount++] = samples;
		return;
	}
	if (!ir->scount) {
		/* nothing to sample */
		if (ir->ir.keypressed && time_after(jiffies,ir->release))
			ir_input_nokey(&ir->input,&ir->ir);
		return;
	}

	/* have a complete sample */
	if (ir->scount < ARRAY_SIZE(ir->samples))
		ir->samples[ir->scount++] = samples;
	for (i = 0; i < ir->scount; i++)
		ir->samples[i] = ~ir->samples[i];
	if (ir_debug)
		ir_dump_samples(ir->samples,ir->scount);

	/* decode it */
	switch (core->board) {
	case CX88_BOARD_HAUPPAUGE:
	case CX88_BOARD_HAUPPAUGE_DVB_T1:
		rc5 = ir_decode_biphase(ir->samples,ir->scount,5,7);
		ir_dprintk("biphase decoded: %x\n",rc5);
		if ((rc5 & 0xfffff000) != 0x3000)
			break;
		ir_input_keydown(&ir->input, &ir->ir, rc5 & 0x3f, rc5);
		ir->release = jiffies + msecs_to_jiffies(120);
		break;
	}

	ir->scount = 0;
	return;
}

/* ---------------------------------------------------------------------- */

MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe");
MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls");
MODULE_LICENSE("GPL");

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-mpeg.c (-23 / +21 lines)
1	/*	1	/*
2	* $Id: cx88-mpeg.c,v 1.14 2004/10/25 11:26:36 kraxel Exp $	2	* $Id: cx88-mpeg.c,v 1.25 2005/03/07 14:18:00 kraxel Exp $
3	*	3	*
4	* Support for the mpeg transport stream transfers	4	* Support for the mpeg transport stream transfers
5	* PCI function #2 of the cx2388x.	5	* PCI function #2 of the cx2388x.
Lines 24-29 Link Here
24	*/	24	*/
25		25
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/init.h>	28	#include <linux/init.h>
28	#include <linux/device.h>	29	#include <linux/device.h>
29	#include <linux/interrupt.h>	30	#include <linux/interrupt.h>
Lines 68-75 static int cx8802_start_dma(struct cx880 Link Here
68	* also: move to cx88-blackbird + cx88-dvb source files? */	69	* also: move to cx88-blackbird + cx88-dvb source files? */
69		70
70	if (cx88_boards[core->board].dvb) {	71	if (cx88_boards[core->board].dvb) {
71	/* Setup TS portion of chip */	72	/* negedge driven & software reset */
72	cx_write(TS_GEN_CNTRL, 0x0c);	73	cx_write(TS_GEN_CNTRL, 0x40);
		74	udelay(100);
		75	cx_write(MO_PINMUX_IO, 0x00);
		76	cx_write(TS_HW_SOP_CNTRL,47<<16\|188<<4\|0x00);
		77	cx_write(TS_SOP_STAT,0x00);
		78	cx_write(TS_GEN_CNTRL, dev->ts_gen_cntrl);
		79	udelay(100);
73	}	80	}
74		81
75	if (cx88_boards[core->board].blackbird) {	82	if (cx88_boards[core->board].blackbird) {
Lines 93-99 static int cx8802_start_dma(struct cx880 Link Here
93	q->count = 1;	100	q->count = 1;
94		101
95	/* enable irqs */	102	/* enable irqs */
96	cx_set(MO_PCI_INTMSK, 0x00fc04);	103	cx_set(MO_PCI_INTMSK, core->pci_irqmask \| 0x04);
97	cx_write(MO_TS_INTMSK, 0x1f0011);	104	cx_write(MO_TS_INTMSK, 0x1f0011);
98		105
99	/* start dma */	106	/* start dma */
Lines 292-310 static irqreturn_t cx8802_irq(int irq, v Link Here
292	{	299	{
293	struct cx8802_dev *dev = dev_id;	300	struct cx8802_dev *dev = dev_id;
294	struct cx88_core *core = dev->core;	301	struct cx88_core *core = dev->core;
295	u32 status, mask;	302	u32 status;
296	int loop, handled = 0;	303	int loop, handled = 0;
297		304
298	for (loop = 0; loop < 10; loop++) {	305	for (loop = 0; loop < 10; loop++) {
299	status = cx_read(MO_PCI_INTSTAT) & (~0x1f \| 0x04);	306	status = cx_read(MO_PCI_INTSTAT) & (core->pci_irqmask \| 0x04);
300	mask = cx_read(MO_PCI_INTMSK);	307	if (0 == status)
301	if (0 == (status & mask))
302	goto out;	308	goto out;
303	handled = 1;	309	handled = 1;
304	cx_write(MO_PCI_INTSTAT, status);	310	cx_write(MO_PCI_INTSTAT, status);
305		311
306	if (status & mask & ~0x1f)	312	if (status & core->pci_irqmask)
307	cx88_irq(core,status,mask);	313	cx88_core_irq(core,status);
308	if (status & 0x04)	314	if (status & 0x04)
309	cx8802_mpeg_irq(dev);	315	cx8802_mpeg_irq(dev);
310	};	316	};
Lines 323-328 static irqreturn_t cx8802_irq(int irq, v Link Here
323		329
324	int cx8802_init_common(struct cx8802_dev *dev)	330	int cx8802_init_common(struct cx8802_dev *dev)
325	{	331	{
		332	struct cx88_core *core = dev->core;
326	int err;	333	int err;
327		334
328	/* pci init */	335	/* pci init */
Lines 354-364 int cx8802_init_common(struct cx8802_dev Link Here
354	cx88_risc_stopper(dev->pci,&dev->mpegq.stopper,	361	cx88_risc_stopper(dev->pci,&dev->mpegq.stopper,
355	MO_TS_DMACNTRL,0x11,0x00);	362	MO_TS_DMACNTRL,0x11,0x00);
356		363
357	#if 0 /* FIXME */
358	/* initialize hardware */
359	cx8802_reset(dev);
360	#endif
361
362	/* get irq */	364	/* get irq */
363	err = request_irq(dev->pci->irq, cx8802_irq,	365	err = request_irq(dev->pci->irq, cx8802_irq,
364	SA_SHIRQ \| SA_INTERRUPT, dev->core->name, dev);	366	SA_SHIRQ \| SA_INTERRUPT, dev->core->name, dev);
Lines 367-377 int cx8802_init_common(struct cx8802_dev Link Here
367	dev->core->name, dev->pci->irq);	369	dev->core->name, dev->pci->irq);
368	return err;	370	return err;
369	}	371	}
370		372	cx_set(MO_PCI_INTMSK, core->pci_irqmask);
371	#if 0 /* FIXME */
372	/* register i2c bus + load i2c helpers */
373	cx88_card_setup(dev);
374	#endif
375		373
376	/* everything worked */	374	/* everything worked */
377	pci_set_drvdata(dev->pci,dev);	375	pci_set_drvdata(dev->pci,dev);
Lines 393-399 void cx8802_fini_common(struct cx8802_de Link Here
393		391
394	/* ----------------------------------------------------------- */	392	/* ----------------------------------------------------------- */
395		393
396	int cx8802_suspend_common(struct pci_dev *pci_dev, u32 state)	394	int cx8802_suspend_common(struct pci_dev *pci_dev, pm_message_t state)
397	{	395	{
398	struct cx8802_dev *dev = pci_get_drvdata(pci_dev);	396	struct cx8802_dev *dev = pci_get_drvdata(pci_dev);
399	struct cx88_core *core = dev->core;	397	struct cx88_core *core = dev->core;
Lines 413-419 int cx8802_suspend_common(struct pci_dev Link Here
413	#endif	411	#endif
414		412
415	pci_save_state(pci_dev);	413	pci_save_state(pci_dev);
416	if (0 != pci_set_power_state(pci_dev, state)) {	414	if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
417	pci_disable_device(pci_dev);	415	pci_disable_device(pci_dev);
418	dev->state.disabled = 1;	416	dev->state.disabled = 1;
419	}	417	}
Lines 429-435 int cx8802_resume_common(struct pci_dev Link Here
429	pci_enable_device(pci_dev);	427	pci_enable_device(pci_dev);
430	dev->state.disabled = 0;	428	dev->state.disabled = 0;
431	}	429	}
432	pci_set_power_state(pci_dev, 0);	430	pci_set_power_state(pci_dev, PCI_D0);
433	pci_restore_state(pci_dev);	431	pci_restore_state(pci_dev);
434		432
435	#if 1	433	#if 1

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-tvaudio.c (-136 / +319 lines)
1	/*	1	/*
2	$Id: cx88-tvaudio.c,v 1.24 2004/10/25 11:51:00 kraxel Exp $	2	$Id: cx88-tvaudio.c,v 1.34 2005/03/07 16:10:51 kraxel Exp $
3		3
4	cx88x-audio.c - Conexant CX23880/23881 audio downstream driver driver	4	cx88x-audio.c - Conexant CX23880/23881 audio downstream driver driver
5		5
Lines 37-42 Link Here
37	*/	37	*/
38		38
39	#include <linux/module.h>	39	#include <linux/module.h>
		40	#include <linux/moduleparam.h>
40	#include <linux/errno.h>	41	#include <linux/errno.h>
41	#include <linux/kernel.h>	42	#include <linux/kernel.h>
42	#include <linux/slab.h>	43	#include <linux/slab.h>
Lines 56-62 Link Here
56		57
57	#include "cx88.h"	58	#include "cx88.h"
58		59
59	static unsigned int audio_debug = 1;	60	static unsigned int audio_debug = 0;
60	module_param(audio_debug,int,0644);	61	module_param(audio_debug,int,0644);
61	MODULE_PARM_DESC(audio_debug,"enable debug messages [audio]");	62	MODULE_PARM_DESC(audio_debug,"enable debug messages [audio]");
62		63
Lines 141-146 static void set_audio_finish(struct cx88 Link Here
141	{	142	{
142	u32 volume;	143	u32 volume;
143		144
		145	if (cx88_boards[core->board].blackbird) {
		146	// 'pass-thru mode': this enables the i2s output to the mpeg encoder
		147	cx_set(AUD_CTL, 0x2000);
		148	cx_write(AUD_I2SOUTPUTCNTL, 1);
		149	//cx_write(AUD_APB_IN_RATE_ADJ, 0);
		150	}
		151
144	// finish programming	152	// finish programming
145	cx_write(AUD_SOFT_RESET, 0x0000);	153	cx_write(AUD_SOFT_RESET, 0x0000);
146		154
Lines 263-268 static void set_audio_standard_BTSC(stru Link Here
263	set_audio_finish(core);	271	set_audio_finish(core);
264	}	272	}
265		273
		274	#if 0
266	static void set_audio_standard_NICAM(struct cx88_core *core)	275	static void set_audio_standard_NICAM(struct cx88_core *core)
267	{	276	{
268	static const struct rlist nicam_common[] = {	277	static const struct rlist nicam_common[] = {
Lines 335-462 static void set_audio_standard_NICAM(str Link Here
335	};	344	};
336	set_audio_finish(core);	345	set_audio_finish(core);
337	}	346	}
		347	#endif
338		348
339	static void set_audio_standard_NICAM_L(struct cx88_core *core)	349	static void set_audio_standard_NICAM_L(struct cx88_core *core, int stereo)
340	{	350	{
341	/* This is officially weird.. register dumps indicate windows	351	/* This is probably weird..
342	* uses audio mode 4.. A2. Let's operate and find out. */	352	* Let's operate and find out. */
343		353
344	static const struct rlist nicam_l[] = {	354	static const struct rlist nicam_l_mono[] = {
345	// setup QAM registers	355	{ AUD_ERRLOGPERIOD_R, 0x00000064 },
346	{ AUD_PDF_DDS_CNST_BYTE2, 0x48 },	356	{ AUD_ERRINTRPTTHSHLD1_R, 0x00000FFF },
347	{ AUD_PDF_DDS_CNST_BYTE1, 0x3d },	357	{ AUD_ERRINTRPTTHSHLD2_R, 0x0000001F },
348	{ AUD_PDF_DDS_CNST_BYTE0, 0xf5 },	358	{ AUD_ERRINTRPTTHSHLD3_R, 0x0000000F },
349	{ AUD_QAM_MODE, 0x00 },
350	{ AUD_PHACC_FREQ_8MSB, 0x3a },
351	{ AUD_PHACC_FREQ_8LSB, 0x4a },
352		359
353	{ AUD_POLY0_DDS_CONSTANT, 0x000e4db2 },	360	{ AUD_PDF_DDS_CNST_BYTE2, 0x48 },
354	{ AUD_IIR1_0_SEL, 0x00000000 },	361	{ AUD_PDF_DDS_CNST_BYTE1, 0x3D },
355	{ AUD_IIR1_1_SEL, 0x00000002 },	362	{ AUD_QAM_MODE, 0x00 },
356	{ AUD_IIR1_2_SEL, 0x00000023 },	363	{ AUD_PDF_DDS_CNST_BYTE0, 0xf5 },
357	{ AUD_IIR1_3_SEL, 0x00000004 },	364	{ AUD_PHACC_FREQ_8MSB, 0x3a },
358	{ AUD_IIR1_4_SEL, 0x00000005 },	365	{ AUD_PHACC_FREQ_8LSB, 0x4a },
359	{ AUD_IIR1_5_SEL, 0x00000007 },
360	{ AUD_IIR1_0_SHIFT, 0x00000007 },
361	{ AUD_IIR1_1_SHIFT, 0x00000000 },
362	{ AUD_IIR1_2_SHIFT, 0x00000000 },
363	{ AUD_IIR1_3_SHIFT, 0x00000007 },
364	{ AUD_IIR1_4_SHIFT, 0x00000007 },
365	{ AUD_IIR1_5_SHIFT, 0x00000007 },
366	{ AUD_IIR2_0_SEL, 0x00000002 },
367	{ AUD_IIR2_1_SEL, 0x00000003 },
368	{ AUD_IIR2_2_SEL, 0x00000004 },
369	{ AUD_IIR2_3_SEL, 0x00000005 },
370	{ AUD_IIR3_0_SEL, 0x00000007 },
371	{ AUD_IIR3_1_SEL, 0x00000023 },
372	{ AUD_IIR3_2_SEL, 0x00000016 },
373	{ AUD_IIR4_0_SHIFT, 0x00000000 },
374	{ AUD_IIR4_1_SHIFT, 0x00000000 },
375	{ AUD_IIR3_2_SHIFT, 0x00000002 },
376	{ AUD_IIR4_0_SEL, 0x0000001d },
377	{ AUD_IIR4_1_SEL, 0x00000019 },
378	{ AUD_IIR4_2_SEL, 0x00000008 },
379	{ AUD_IIR4_0_SHIFT, 0x00000000 },
380	{ AUD_IIR4_1_SHIFT, 0x00000007 },
381	{ AUD_IIR4_2_SHIFT, 0x00000007 },
382	{ AUD_IIR4_0_CA0, 0x0003e57e },
383	{ AUD_IIR4_0_CA1, 0x00005e11 },
384	{ AUD_IIR4_0_CA2, 0x0003a7cf },
385	{ AUD_IIR4_0_CB0, 0x00002368 },
386	{ AUD_IIR4_0_CB1, 0x0003bf1b },
387	{ AUD_IIR4_1_CA0, 0x00006349 },
388	{ AUD_IIR4_1_CA1, 0x00006f27 },
389	{ AUD_IIR4_1_CA2, 0x0000e7a3 },
390	{ AUD_IIR4_1_CB0, 0x00005653 },
391	{ AUD_IIR4_1_CB1, 0x0000cf97 },
392	{ AUD_IIR4_2_CA0, 0x00006349 },
393	{ AUD_IIR4_2_CA1, 0x00006f27 },
394	{ AUD_IIR4_2_CA2, 0x0000e7a3 },
395	{ AUD_IIR4_2_CB0, 0x00005653 },
396	{ AUD_IIR4_2_CB1, 0x0000cf97 },
397	{ AUD_HP_MD_IIR4_1, 0x00000001 },
398	{ AUD_HP_PROG_IIR4_1, 0x0000001a },
399	{ AUD_DN0_FREQ, 0x00000000 },
400	{ AUD_DN1_FREQ, 0x00003318 },
401	{ AUD_DN1_SRC_SEL, 0x00000017 },
402	{ AUD_DN1_SHFT, 0x00000007 },
403	{ AUD_DN1_AFC, 0x00000000 },
404	{ AUD_DN1_FREQ_SHIFT, 0x00000000 },
405	{ AUD_DN2_FREQ, 0x00003551 },
406	{ AUD_DN2_SRC_SEL, 0x00000001 },
407	{ AUD_DN2_SHFT, 0x00000000 },
408	{ AUD_DN2_AFC, 0x00000002 },
409	{ AUD_DN2_FREQ_SHIFT, 0x00000000 },
410	{ AUD_PDET_SRC, 0x00000014 },
411	{ AUD_PDET_SHIFT, 0x00000000 },
412	{ AUD_DEEMPH0_SRC_SEL, 0x00000011 },
413	{ AUD_DEEMPH1_SRC_SEL, 0x00000011 },
414	{ AUD_DEEMPH0_SHIFT, 0x00000000 },
415	{ AUD_DEEMPH1_SHIFT, 0x00000000 },
416	{ AUD_DEEMPH0_G0, 0x00007000 },
417	{ AUD_DEEMPH0_A0, 0x00000000 },
418	{ AUD_DEEMPH0_B0, 0x00000000 },
419	{ AUD_DEEMPH0_A1, 0x00000000 },
420	{ AUD_DEEMPH0_B1, 0x00000000 },
421	{ AUD_DEEMPH1_G0, 0x00007000 },
422	{ AUD_DEEMPH1_A0, 0x00000000 },
423	{ AUD_DEEMPH1_B0, 0x00000000 },
424	{ AUD_DEEMPH1_A1, 0x00000000 },
425	{ AUD_DEEMPH1_B1, 0x00000000 },
426	{ AUD_DMD_RA_DDS, 0x00f5c285 },
427	{ AUD_RATE_ADJ1, 0x00000100 },
428	{ AUD_RATE_ADJ2, 0x00000200 },
429	{ AUD_RATE_ADJ3, 0x00000300 },
430	{ AUD_RATE_ADJ4, 0x00000400 },
431	{ AUD_RATE_ADJ5, 0x00000500 },
432	{ AUD_C2_UP_THR, 0x00005400 },
433	{ AUD_C2_LO_THR, 0x00003000 },
434	{ AUD_C1_UP_THR, 0x00007000 },
435	{ AUD_C2_LO_THR, 0x00005400 },
436	{ AUD_CTL, 0x0000100c },
437	{ AUD_DCOC_0_SRC, 0x00000021 },
438	{ AUD_DCOC_1_SRC, 0x00000003 },
439	{ AUD_DCOC1_SHIFT, 0x00000000 },
440	{ AUD_DCOC_1_SHIFT_IN0, 0x0000000a },
441	{ AUD_DCOC_1_SHIFT_IN1, 0x00000008 },
442	{ AUD_DCOC_PASS_IN, 0x00000000 },
443	{ AUD_DCOC_2_SRC, 0x0000001b },
444	{ AUD_IIR4_0_SEL, 0x0000001d },
445	{ AUD_POLY0_DDS_CONSTANT, 0x000e4db2 },
446	{ AUD_PHASE_FIX_CTL, 0x00000000 },
447	{ AUD_CORDIC_SHIFT_1, 0x00000007 },
448	{ AUD_PLL_EN, 0x00000000 },
449	{ AUD_PLL_PRESCALE, 0x00000002 },
450	{ AUD_PLL_INT, 0x0000001e },
451	{ AUD_OUT1_SHIFT, 0x00000000 },
452		366
453	{ /* end of list */ },	367	{ AUD_DEEMPHGAIN_R, 0x6680 },
454	};	368	{ AUD_DEEMPHNUMER1_R, 0x353DE },
		369	{ AUD_DEEMPHNUMER2_R, 0x1B1 },
		370	{ AUD_DEEMPHDENOM1_R, 0x0F3D0 },
		371	{ AUD_DEEMPHDENOM2_R, 0x0 },
		372	{ AUD_FM_MODE_ENABLE, 0x7 },
		373	{ AUD_POLYPH80SCALEFAC, 0x3 },
		374	{ AUD_AFE_12DB_EN, 0x1 },
		375	{ AAGC_GAIN, 0x0 },
		376	{ AAGC_HYST, 0x18 },
		377	{ AAGC_DEF, 0x20 },
		378	{ AUD_DN0_FREQ, 0x0 },
		379	{ AUD_POLY0_DDS_CONSTANT, 0x0E4DB2 },
		380	{ AUD_DCOC_0_SRC, 0x21 },
		381	{ AUD_IIR1_0_SEL, 0x0 },
		382	{ AUD_IIR1_0_SHIFT, 0x7 },
		383	{ AUD_IIR1_1_SEL, 0x2 },
		384	{ AUD_IIR1_1_SHIFT, 0x0 },
		385	{ AUD_DCOC_1_SRC, 0x3 },
		386	{ AUD_DCOC1_SHIFT, 0x0 },
		387	{ AUD_DCOC_PASS_IN, 0x0 },
		388	{ AUD_IIR1_2_SEL, 0x23 },
		389	{ AUD_IIR1_2_SHIFT, 0x0 },
		390	{ AUD_IIR1_3_SEL, 0x4 },
		391	{ AUD_IIR1_3_SHIFT, 0x7 },
		392	{ AUD_IIR1_4_SEL, 0x5 },
		393	{ AUD_IIR1_4_SHIFT, 0x7 },
		394	{ AUD_IIR3_0_SEL, 0x7 },
		395	{ AUD_IIR3_0_SHIFT, 0x0 },
		396	{ AUD_DEEMPH0_SRC_SEL, 0x11 },
		397	{ AUD_DEEMPH0_SHIFT, 0x0 },
		398	{ AUD_DEEMPH0_G0, 0x7000 },
		399	{ AUD_DEEMPH0_A0, 0x0 },
		400	{ AUD_DEEMPH0_B0, 0x0 },
		401	{ AUD_DEEMPH0_A1, 0x0 },
		402	{ AUD_DEEMPH0_B1, 0x0 },
		403	{ AUD_DEEMPH1_SRC_SEL, 0x11 },
		404	{ AUD_DEEMPH1_SHIFT, 0x0 },
		405	{ AUD_DEEMPH1_G0, 0x7000 },
		406	{ AUD_DEEMPH1_A0, 0x0 },
		407	{ AUD_DEEMPH1_B0, 0x0 },
		408	{ AUD_DEEMPH1_A1, 0x0 },
		409	{ AUD_DEEMPH1_B1, 0x0 },
		410	{ AUD_OUT0_SEL, 0x3F },
		411	{ AUD_OUT1_SEL, 0x3F },
		412	{ AUD_DMD_RA_DDS, 0x0F5C285 },
		413	{ AUD_PLL_INT, 0x1E },
		414	{ AUD_PLL_DDS, 0x0 },
		415	{ AUD_PLL_FRAC, 0x0E542 },
455		416
456	dprintk("%s (status: unknown)\n",__FUNCTION__);	417	// setup QAM registers
457	set_audio_start(core, 0x0004,	418	{ AUD_RATE_ADJ1, 0x00000100 },
458	0 /* FIXME */);	419	{ AUD_RATE_ADJ2, 0x00000200 },
459	set_audio_registers(core, nicam_l);	420	{ AUD_RATE_ADJ3, 0x00000300 },
		421	{ AUD_RATE_ADJ4, 0x00000400 },
		422	{ AUD_RATE_ADJ5, 0x00000500 },
		423	{ AUD_RATE_THRES_DMD, 0x000000C0 },
		424	{ /* end of list */ },
		425	};
		426
		427	static const struct rlist nicam_l[] = {
		428	// setup QAM registers
		429	{ AUD_RATE_ADJ1, 0x00000060 },
		430	{ AUD_RATE_ADJ2, 0x000000F9 },
		431	{ AUD_RATE_ADJ3, 0x000001CC },
		432	{ AUD_RATE_ADJ4, 0x000002B3 },
		433	{ AUD_RATE_ADJ5, 0x00000726 },
		434	{ AUD_DEEMPHDENOM1_R, 0x0000F3D0 },
		435	{ AUD_DEEMPHDENOM2_R, 0x00000000 },
		436	{ AUD_ERRLOGPERIOD_R, 0x00000064 },
		437	{ AUD_ERRINTRPTTHSHLD1_R, 0x00000FFF },
		438	{ AUD_ERRINTRPTTHSHLD2_R, 0x0000001F },
		439	{ AUD_ERRINTRPTTHSHLD3_R, 0x0000000F },
		440	{ AUD_POLYPH80SCALEFAC, 0x00000003 },
		441	{ AUD_DMD_RA_DDS, 0x00C00000 },
		442	{ AUD_PLL_INT, 0x0000001E },
		443	{ AUD_PLL_DDS, 0x00000000 },
		444	{ AUD_PLL_FRAC, 0x0000E542 },
		445	{ AUD_START_TIMER, 0x00000000 },
		446	{ AUD_DEEMPHNUMER1_R, 0x000353DE },
		447	{ AUD_DEEMPHNUMER2_R, 0x000001B1 },
		448	{ AUD_PDF_DDS_CNST_BYTE2, 0x06 },
		449	{ AUD_PDF_DDS_CNST_BYTE1, 0x82 },
		450	{ AUD_QAM_MODE, 0x05 },
		451	{ AUD_PDF_DDS_CNST_BYTE0, 0x12 },
		452	{ AUD_PHACC_FREQ_8MSB, 0x34 },
		453	{ AUD_PHACC_FREQ_8LSB, 0x4C },
		454	{ AUD_DEEMPHGAIN_R, 0x00006680 },
		455	{ AUD_RATE_THRES_DMD, 0x000000C0 },
		456	{ /* end of list */ },
		457	} ;
		458	dprintk("%s (status: devel), stereo : %d\n",__FUNCTION__,stereo);
		459
		460	if (!stereo) {
		461	/* AM mono sound */
		462	set_audio_start(core, 0x0004,
		463	0x100c /* FIXME again */);
		464	set_audio_registers(core, nicam_l_mono);
		465	} else {
		466	set_audio_start(core, 0x0010,
		467	0x1924 /* FIXME again */);
		468	set_audio_registers(core, nicam_l);
		469	}
		470	set_audio_finish(core);
		471
		472	}
		473
		474	static void set_audio_standard_PAL_I(struct cx88_core *core, int stereo)
		475	{
		476	static const struct rlist pal_i_fm_mono[] = {
		477	{AUD_ERRLOGPERIOD_R, 0x00000064},
		478	{AUD_ERRINTRPTTHSHLD1_R, 0x00000fff},
		479	{AUD_ERRINTRPTTHSHLD2_R, 0x0000001f},
		480	{AUD_ERRINTRPTTHSHLD3_R, 0x0000000f},
		481	{AUD_PDF_DDS_CNST_BYTE2, 0x06},
		482	{AUD_PDF_DDS_CNST_BYTE1, 0x82},
		483	{AUD_PDF_DDS_CNST_BYTE0, 0x12},
		484	{AUD_QAM_MODE, 0x05},
485	{AUD_PHACC_FREQ_8MSB, 0x3a},
486	{AUD_PHACC_FREQ_8LSB, 0x93},
487	{AUD_DMD_RA_DDS, 0x002a4f2f},
488	{AUD_PLL_INT, 0x0000001e},
489	{AUD_PLL_DDS, 0x00000004},
490	{AUD_PLL_FRAC, 0x0000e542},
491	{AUD_RATE_ADJ1, 0x00000100},
492	{AUD_RATE_ADJ2, 0x00000200},
493	{AUD_RATE_ADJ3, 0x00000300},
494	{AUD_RATE_ADJ4, 0x00000400},
495	{AUD_RATE_ADJ5, 0x00000500},
496	{AUD_THR_FR, 0x00000000},
497	{AUD_PILOT_BQD_1_K0, 0x0000755b},
498	{AUD_PILOT_BQD_1_K1, 0x00551340},
499	{AUD_PILOT_BQD_1_K2, 0x006d30be},
500	{AUD_PILOT_BQD_1_K3, 0xffd394af},
501	{AUD_PILOT_BQD_1_K4, 0x00400000},
502	{AUD_PILOT_BQD_2_K0, 0x00040000},
503	{AUD_PILOT_BQD_2_K1, 0x002a4841},
504	{AUD_PILOT_BQD_2_K2, 0x00400000},
505	{AUD_PILOT_BQD_2_K3, 0x00000000},
506	{AUD_PILOT_BQD_2_K4, 0x00000000},
507	{AUD_MODE_CHG_TIMER, 0x00000060},
508	{AUD_AFE_12DB_EN, 0x00000001},
509	{AAGC_HYST, 0x0000000a},
510	{AUD_CORDIC_SHIFT_0, 0x00000007},
511	{AUD_CORDIC_SHIFT_1, 0x00000007},
512	{AUD_C1_UP_THR, 0x00007000},
513	{AUD_C1_LO_THR, 0x00005400},
514	{AUD_C2_UP_THR, 0x00005400},
515	{AUD_C2_LO_THR, 0x00003000},
516	{AUD_DCOC_0_SRC, 0x0000001a},
517	{AUD_DCOC0_SHIFT, 0x00000000},
518	{AUD_DCOC_0_SHIFT_IN0, 0x0000000a},
519	{AUD_DCOC_0_SHIFT_IN1, 0x00000008},
520	{AUD_DCOC_PASS_IN, 0x00000003},
521	{AUD_IIR3_0_SEL, 0x00000021},
522	{AUD_DN2_AFC, 0x00000002},
523	{AUD_DCOC_1_SRC, 0x0000001b},
524	{AUD_DCOC1_SHIFT, 0x00000000},
525	{AUD_DCOC_1_SHIFT_IN0, 0x0000000a},
526	{AUD_DCOC_1_SHIFT_IN1, 0x00000008},
527	{AUD_IIR3_1_SEL, 0x00000023},
528	{AUD_DN0_FREQ, 0x000035a3},
529	{AUD_DN2_FREQ, 0x000029c7},
530	{AUD_CRDC0_SRC_SEL, 0x00000511},
531	{AUD_IIR1_0_SEL, 0x00000001},
532	{AUD_IIR1_1_SEL, 0x00000000},
533	{AUD_IIR3_2_SEL, 0x00000003},
534	{AUD_IIR3_2_SHIFT, 0x00000000},
535	{AUD_IIR3_0_SEL, 0x00000002},
536	{AUD_IIR2_0_SEL, 0x00000021},
537	{AUD_IIR2_0_SHIFT, 0x00000002},
538	{AUD_DEEMPH0_SRC_SEL, 0x0000000b},
539	{AUD_DEEMPH1_SRC_SEL, 0x0000000b},
540	{AUD_POLYPH80SCALEFAC, 0x00000001},
541	{AUD_START_TIMER, 0x00000000},
542	{ /* end of list */ },
543	};
544
545	static const struct rlist pal_i_nicam[] = {
546	{ AUD_RATE_ADJ1, 0x00000010 },
547	{ AUD_RATE_ADJ2, 0x00000040 },
548	{ AUD_RATE_ADJ3, 0x00000100 },
549	{ AUD_RATE_ADJ4, 0x00000400 },
550	{ AUD_RATE_ADJ5, 0x00001000 },
551	// { AUD_DMD_RA_DDS, 0x00c0d5ce },
552	{ AUD_DEEMPHGAIN_R, 0x000023c2 },
553	{ AUD_DEEMPHNUMER1_R, 0x0002a7bc },
554	{ AUD_DEEMPHNUMER2_R, 0x0003023e },
555	{ AUD_DEEMPHDENOM1_R, 0x0000f3d0 },
556	{ AUD_DEEMPHDENOM2_R, 0x00000000 },
557	{ AUD_DEEMPHDENOM2_R, 0x00000000 },
558	{ AUD_ERRLOGPERIOD_R, 0x00000fff },
559	{ AUD_ERRINTRPTTHSHLD1_R, 0x000003ff },
560	{ AUD_ERRINTRPTTHSHLD2_R, 0x000000ff },
561	{ AUD_ERRINTRPTTHSHLD3_R, 0x0000003f },
562	{ AUD_POLYPH80SCALEFAC, 0x00000003 },
563	{ AUD_PDF_DDS_CNST_BYTE2, 0x06 },
564	{ AUD_PDF_DDS_CNST_BYTE1, 0x82 },
565	{ AUD_PDF_DDS_CNST_BYTE0, 0x16 },
566	{ AUD_QAM_MODE, 0x05 },
567	{ AUD_PDF_DDS_CNST_BYTE0, 0x12 },
568	{ AUD_PHACC_FREQ_8MSB, 0x3a },
569	{ AUD_PHACC_FREQ_8LSB, 0x93 },
570	{ /* end of list */ },
571	};
572
573	dprintk("%s (status: devel), stereo : %d\n",__FUNCTION__,stereo);
574
575	if (!stereo) {
576	// FM mono
577	set_audio_start(core, 0x0004, EN_DMTRX_SUMDIFF \| EN_A2_FORCE_MONO1);
578	set_audio_registers(core, pal_i_fm_mono);
579	} else {
580	// Nicam Stereo
581	set_audio_start(core, 0x0010, EN_DMTRX_LR \| EN_DMTRX_BYPASS \| EN_NICAM_AUTO_STEREO);
582	set_audio_registers(core, pal_i_nicam);
583	}
460	set_audio_finish(core);	584	set_audio_finish(core);
461	}	585	}
462		586
Lines 553-565 static void set_audio_standard_A2(struct Link Here
553	set_audio_start(core, 0x0004, EN_DMTRX_SUMDIFF \| EN_A2_AUTO_STEREO);	677	set_audio_start(core, 0x0004, EN_DMTRX_SUMDIFF \| EN_A2_AUTO_STEREO);
554	set_audio_registers(core, a2_common);	678	set_audio_registers(core, a2_common);
555	switch (core->tvaudio) {	679	switch (core->tvaudio) {
556	case WW_NICAM_I:
557	/* gives at least mono according to the dscaler guys */
558	/* so use use that while nicam is broken ... */
559	dprintk("%s PAL-I mono (status: unknown)\n",__FUNCTION__);
560	set_audio_registers(core, a2_table1);
561	cx_write(AUD_CTL, EN_A2_FORCE_MONO1);
562	break;
563	case WW_A2_BG:	680	case WW_A2_BG:
564	dprintk("%s PAL-BG A2 (status: known-good)\n",__FUNCTION__);	681	dprintk("%s PAL-BG A2 (status: known-good)\n",__FUNCTION__);
565	set_audio_registers(core, a2_table1);	682	set_audio_registers(core, a2_table1);
Lines 646-656 void cx88_set_tvaudio(struct cx88_core * Link Here
646	case WW_BTSC:	763	case WW_BTSC:
647	set_audio_standard_BTSC(core,0);	764	set_audio_standard_BTSC(core,0);
648	break;	765	break;
649	// case WW_NICAM_I:
650	case WW_NICAM_BGDKL:	766	case WW_NICAM_BGDKL:
651	set_audio_standard_NICAM(core);	767	set_audio_standard_NICAM_L(core,0);
652	break;	768	break;
653	case WW_NICAM_I:	769	case WW_NICAM_I:
		770	set_audio_standard_PAL_I(core,0);
		771	break;
654	case WW_A2_BG:	772	case WW_A2_BG:
655	case WW_A2_DK:	773	case WW_A2_DK:
656	case WW_A2_M:	774	case WW_A2_M:
Lines 663-669 void cx88_set_tvaudio(struct cx88_core * Link Here
663	set_audio_standard_FM(core);	781	set_audio_standard_FM(core);
664	break;	782	break;
665	case WW_SYSTEM_L_AM:	783	case WW_SYSTEM_L_AM:
666	set_audio_standard_NICAM_L(core);	784	set_audio_standard_NICAM_L(core, 1);
667	break;	785	break;
668	case WW_NONE:	786	case WW_NONE:
669	default:	787	default:
Lines 674-679 void cx88_set_tvaudio(struct cx88_core * Link Here
674	return;	792	return;
675	}	793	}
676		794
		795	void cx88_newstation(struct cx88_core *core)
		796	{
		797	core->audiomode_manual = UNSET;
		798
		799	switch (core->tvaudio) {
		800	case WW_SYSTEM_L_AM:
		801	/* try nicam ... */
		802	core->audiomode_current = V4L2_TUNER_MODE_STEREO;
		803	set_audio_standard_NICAM_L(core, 1);
		804	break;
		805	}
		806	}
		807
677	void cx88_get_stereo(struct cx88_core core, struct v4l2_tuner t)	808	void cx88_get_stereo(struct cx88_core core, struct v4l2_tuner t)
678	{	809	{
679	static char *m[] = {"stereo", "dual mono", "mono", "sap"};	810	static char *m[] = {"stereo", "dual mono", "mono", "sap"};
Lines 721-742 void cx88_get_stereo(struct cx88_core *c Link Here
721	}	852	}
722	break;	853	break;
723	case WW_NICAM_BGDKL:	854	case WW_NICAM_BGDKL:
724	if (0 == mode)	855	if (0 == mode) {
725	t->audmode = V4L2_TUNER_MODE_STEREO;	856	t->audmode = V4L2_TUNER_MODE_STEREO;
		857	t->rxsubchans \|= V4L2_TUNER_SUB_STEREO;
		858	}
726	break;	859	break;
		860	case WW_SYSTEM_L_AM:
		861	if (0x0 == mode && !(cx_read(AUD_INIT) & 0x04)) {
		862	t->audmode = V4L2_TUNER_MODE_STEREO;
		863	t->rxsubchans \|= V4L2_TUNER_SUB_STEREO;
		864	}
		865	break ;
727	default:	866	default:
728	t->rxsubchans = V4L2_TUNER_SUB_MONO;	867	/* nothing */
729	t->audmode = V4L2_TUNER_MODE_MONO;
730	break;	868	break;
731	}	869	}
732	return;	870	return;
733	}	871	}
734		872
735	void cx88_set_stereo(struct cx88_core *core, u32 mode)	873	void cx88_set_stereo(struct cx88_core *core, u32 mode, int manual)
736	{	874	{
737	u32 ctl = UNSET;	875	u32 ctl = UNSET;
738	u32 mask = UNSET;	876	u32 mask = UNSET;
739		877
		878	if (manual) {
		879	core->audiomode_manual = mode;
		880	} else {
		881	if (UNSET != core->audiomode_manual)
		882	return;
		883	}
		884	core->audiomode_current = mode;
		885
740	switch (core->tvaudio) {	886	switch (core->tvaudio) {
741	case WW_BTSC:	887	case WW_BTSC:
742	switch (mode) {	888	switch (mode) {
Lines 789-794 void cx88_set_stereo(struct cx88_core *c Link Here
789	break;	935	break;
790	}	936	}
791	break;	937	break;
		938	case WW_SYSTEM_L_AM:
		939	switch (mode) {
		940	case V4L2_TUNER_MODE_MONO:
		941	case V4L2_TUNER_MODE_LANG1: /* FIXME */
		942	set_audio_standard_NICAM_L(core, 0);
		943	break;
		944	case V4L2_TUNER_MODE_STEREO:
		945	set_audio_standard_NICAM_L(core, 1);
		946	break;
		947	}
		948	break;
		949	case WW_NICAM_I:
		950	switch (mode) {
		951	case V4L2_TUNER_MODE_MONO:
		952	case V4L2_TUNER_MODE_LANG1:
		953	set_audio_standard_PAL_I(core, 0);
		954	break;
		955	case V4L2_TUNER_MODE_STEREO:
		956	set_audio_standard_PAL_I(core, 1);
		957	break;
		958	}
		959	break;
792	case WW_FM:	960	case WW_FM:
793	switch (mode) {	961	switch (mode) {
794	case V4L2_TUNER_MODE_MONO:	962	case V4L2_TUNER_MODE_MONO:
Lines 804-816 void cx88_set_stereo(struct cx88_core *c Link Here
804	}	972	}
805		973
806	if (UNSET != ctl) {	974	if (UNSET != ctl) {
807	cx_write(AUD_SOFT_RESET, 0x0001);
808	cx_andor(AUD_CTL, mask, ctl);
809	cx_write(AUD_SOFT_RESET, 0x0000);
810	dprintk("cx88_set_stereo: mask 0x%x, ctl 0x%x "	975	dprintk("cx88_set_stereo: mask 0x%x, ctl 0x%x "
811	"[status=0x%x,ctl=0x%x,vol=0x%x]\n",	976	"[status=0x%x,ctl=0x%x,vol=0x%x]\n",
812	mask, ctl, cx_read(AUD_STATUS),	977	mask, ctl, cx_read(AUD_STATUS),
813	cx_read(AUD_CTL), cx_sread(SHADOW_AUD_VOL_CTL));	978	cx_read(AUD_CTL), cx_sread(SHADOW_AUD_VOL_CTL));
		979	cx_andor(AUD_CTL, mask, ctl);
814	}	980	}
815	return;	981	return;
816	}	982	}
Lines 819-834 int cx88_audio_thread(void *data) Link Here
819	{	985	{
820	struct cx88_core *core = data;	986	struct cx88_core *core = data;
821	struct v4l2_tuner t;	987	struct v4l2_tuner t;
		988	u32 mode = 0;
822		989
823	dprintk("cx88: tvaudio thread started\n");	990	dprintk("cx88: tvaudio thread started\n");
824	for (;;) {	991	for (;;) {
		992	msleep_interruptible(1000);
825	if (kthread_should_stop())	993	if (kthread_should_stop())
826	break;	994	break;
827		995
828	/* just monitor the audio status for now ... */	996	/* just monitor the audio status for now ... */
829	memset(&t,0,sizeof(t));	997	memset(&t,0,sizeof(t));
830	cx88_get_stereo(core,&t);	998	cx88_get_stereo(core,&t);
831	msleep_interruptible(1000);	999
		1000	if (UNSET != core->audiomode_manual)
		1001	/* manually set, don't do anything. */
		1002	continue;
		1003
		1004	/* monitor signal */
		1005	if (t.rxsubchans & V4L2_TUNER_SUB_STEREO)
		1006	mode = V4L2_TUNER_MODE_STEREO;
		1007	else
		1008	mode = V4L2_TUNER_MODE_MONO;
		1009	if (mode == core->audiomode_current)
		1010	continue;
		1011
		1012	/* automatically switch to best available mode */
		1013	cx88_set_stereo(core, mode, 0);
832	}	1014	}
833		1015
834	dprintk("cx88: tvaudio thread exiting\n");	1016	dprintk("cx88: tvaudio thread exiting\n");
Lines 838-843 int cx88_audio_thread(void *data) Link Here
838	/* ----------------------------------------------------------- */	1020	/* ----------------------------------------------------------- */
839		1021
840	EXPORT_SYMBOL(cx88_set_tvaudio);	1022	EXPORT_SYMBOL(cx88_set_tvaudio);
		1023	EXPORT_SYMBOL(cx88_newstation);
841	EXPORT_SYMBOL(cx88_set_stereo);	1024	EXPORT_SYMBOL(cx88_set_stereo);
842	EXPORT_SYMBOL(cx88_get_stereo);	1025	EXPORT_SYMBOL(cx88_get_stereo);
843	EXPORT_SYMBOL(cx88_audio_thread);	1026	EXPORT_SYMBOL(cx88_audio_thread);




/*
 * $Id: cx88-vbi.c,v 1.16 2004/12/10 12:33:39 kraxel Exp $
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/slab.h>


	q->count = 1;

	/* enable irqs */
	cx_set(MO_PCI_INTMSK, core->pci_irqmask | 0x01);
	cx_set(MO_VID_INTMSK, 0x0f0088);

	/* enable capture */




/*
 * $Id: cx88-video.c,v 1.58 2005/03/07 15:58:05 kraxel Exp $
 *
 * device driver for Conexant 2388x based TV cards
 * video4linux video interface

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kmod.h>
#include <linux/kernel.h>
#include <linux/slab.h>

	q->count = 1;

	/* enable irqs */
	cx_set(MO_PCI_INTMSK, core->pci_irqmask | 0x01);
	cx_set(MO_VID_INTMSK, 0x0f0011);

	/* enable capture */

		cx_write(MO_GP3_IO, cx88_boards[board].radio.gpio3);
		dev->core->tvaudio = WW_FM;
		cx88_set_tvaudio(core);
		cx88_set_stereo(core,V4L2_TUNER_MODE_STEREO,1);
		cx88_call_i2c_clients(dev->core,AUDC_SET_RADIO,NULL);
	}


}

static ssize_t
video_read(struct file *file, char *data, size_t count, loff_t *ppos)
{
	struct cx8800_fh *fh = file->private_data;


		res_free(dev,fh,RESOURCE_VBI);
	}

	videobuf_mmap_free(&fh->vidq);
	videobuf_mmap_free(&fh->vbiq);
	file->private_data = NULL;
	kfree(fh);
	return 0;

			0;
		if (UNSET != core->tuner_type)
			cap->capabilities |= V4L2_CAP_TUNER;

		return 0;
	}


		if (*i >= 4)
			return -EINVAL;
		down(&dev->lock);
		cx88_newstation(core);
		video_mux(dev,*i);
		up(&dev->lock);
		return 0;

			return -EINVAL;
		if (0 != t->index)
			return -EINVAL;
		cx88_set_stereo(core, t->audmode, 1);
		return 0;
	}
	case VIDIOC_G_FREQUENCY:

			return -EINVAL;
		down(&dev->lock);
		dev->freq = f->frequency;
		cx88_newstation(core);
#ifdef V4L2_I2C_CLIENTS
		cx88_call_i2c_clients(dev->core,VIDIOC_S_FREQUENCY,f);
#else

{
	struct cx8800_dev *dev = dev_id;
	struct cx88_core *core = dev->core;
	u32 status;
	int loop, handled = 0;

	for (loop = 0; loop < 10; loop++) {
		status = cx_read(MO_PCI_INTSTAT) & (core->pci_irqmask | 0x01);
		if (0 == status)
		if (0 == (status & mask))
			goto out;
		cx_write(MO_PCI_INTSTAT, status);
		handled = 1;

		if (status & core->pci_irqmask)
			cx88_core_irq(core,status);
		if (status & 0x01)
			cx8800_vid_irq(dev);
	};

		       core->name,pci_dev->irq);
		goto fail_core;
	}
	cx_set(MO_PCI_INTMSK, core->pci_irqmask);

	/* load and configure helper modules */
	if (TUNER_ABSENT != core->tuner_type)

	kfree(dev);
}

static int cx8800_suspend(struct pci_dev *pci_dev, pm_message_t state)
{
        struct cx8800_dev *dev = pci_get_drvdata(pci_dev);
	struct cx88_core *core = dev->core;

#endif

	pci_save_state(pci_dev);
	if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
		pci_disable_device(pci_dev);
		dev->state.disabled = 1;
	}

		pci_enable_device(pci_dev);
		dev->state.disabled = 0;
	}
	pci_set_power_state(pci_dev, PCI_D0);
	pci_restore_state(pci_dev);

#if 1

	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
	       SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
#endif
	return pci_register_driver(&cx8800_pci_driver);
}

static void cx8800_fini(void)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88.h (-7 / +31 lines)
1	/*	1	/*
2	* $Id: cx88.h,v 1.40 2004/11/03 09:04:51 kraxel Exp $	2	* $Id: cx88.h,v 1.56 2005/03/04 09:12:23 kraxel Exp $
3	*	3	*
4	* v4l2 device driver for cx2388x based TV cards	4	* v4l2 device driver for cx2388x based TV cards
5	*	5	*
Lines 27-32 Link Here
27	#include <linux/kdev_t.h>	27	#include <linux/kdev_t.h>
28		28
29	#include <media/tuner.h>	29	#include <media/tuner.h>
		30	#include <media/tveeprom.h>
30	#include <media/audiochip.h>	31	#include <media/audiochip.h>
31	#include <media/video-buf.h>	32	#include <media/video-buf.h>
32	#include <media/video-buf-dvb.h>	33	#include <media/video-buf-dvb.h>
Lines 139-145 extern struct sram_channel cx88_sram_cha Link Here
139	#define CX88_BOARD_GDI 2	140	#define CX88_BOARD_GDI 2
140	#define CX88_BOARD_PIXELVIEW 3	141	#define CX88_BOARD_PIXELVIEW 3
141	#define CX88_BOARD_ATI_WONDER_PRO 4	142	#define CX88_BOARD_ATI_WONDER_PRO 4
142	#define CX88_BOARD_WINFAST2000XP 5	143	#define CX88_BOARD_WINFAST2000XP_EXPERT 5
143	#define CX88_BOARD_AVERTV_303 6	144	#define CX88_BOARD_AVERTV_303 6
144	#define CX88_BOARD_MSI_TVANYWHERE_MASTER 7	145	#define CX88_BOARD_MSI_TVANYWHERE_MASTER 7
145	#define CX88_BOARD_WINFAST_DV2000 8	146	#define CX88_BOARD_WINFAST_DV2000 8
Lines 156-161 extern struct sram_channel cx88_sram_cha Link Here
156	#define CX88_BOARD_CONEXANT_DVB_T1 19	157	#define CX88_BOARD_CONEXANT_DVB_T1 19
157	#define CX88_BOARD_PROVIDEO_PV259 20	158	#define CX88_BOARD_PROVIDEO_PV259 20
158	#define CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS 21	159	#define CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS 21
		160	#define CX88_BOARD_PCHDTV_HD3000 22
		161	#define CX88_BOARD_DNTV_LIVE_DVB_T 23
		162	#define CX88_BOARD_HAUPPAUGE_ROSLYN 24
		163	#define CX88_BOARD_DIGITALLOGIC_MEC 25
		164	#define CX88_BOARD_IODATA_GVBCTV7E 26
159		165
160	enum cx88_itype {	166	enum cx88_itype {
161	CX88_VMUX_COMPOSITE1 = 1,	167	CX88_VMUX_COMPOSITE1 = 1,
Lines 238-243 struct cx88_core { Link Here
238	u32 __iomem *lmmio;	244	u32 __iomem *lmmio;
239	u8 __iomem *bmmio;	245	u8 __iomem *bmmio;
240	u32 shadow[SHADOW_MAX];	246	u32 shadow[SHADOW_MAX];
		247	int pci_irqmask;
241		248
242	/* i2c i/o */	249	/* i2c i/o */
243	struct i2c_adapter i2c_adap;	250	struct i2c_adapter i2c_adap;
Lines 252-267 struct cx88_core { Link Here
252	unsigned int has_radio;	259	unsigned int has_radio;
253		260
254	/* config info -- dvb */	261	/* config info -- dvb */
255	unsigned int pll_type;	262	struct dvb_pll_desc *pll_desc;
256	unsigned int pll_addr;	263	unsigned int pll_addr;
257	unsigned int demod_addr;
258		264
259	/* state info */	265	/* state info */
260	struct task_struct *kthread;	266	struct task_struct *kthread;
261	struct cx88_tvnorm *tvnorm;	267	struct cx88_tvnorm *tvnorm;
262	u32 tvaudio;	268	u32 tvaudio;
		269	u32 audiomode_manual;
		270	u32 audiomode_current;
263	u32 input;	271	u32 input;
264	u32 astat;	272	u32 astat;
		273
		274	/* IR remote control state */
		275	struct cx88_IR *ir;
265	};	276	};
266		277
267	struct cx8800_dev;	278	struct cx8800_dev;
Lines 371-381 struct cx8802_dev { Link Here
371	struct list_head devlist;	382	struct list_head devlist;
372	struct video_device *mpeg_dev;	383	struct video_device *mpeg_dev;
373	u32 mailbox;	384	u32 mailbox;
		385	int width;
		386	int height;
374		387
375	/* for dvb only */	388	/* for dvb only */
376	struct videobuf_dvb dvb;	389	struct videobuf_dvb dvb;
377	void* fe_handle;	390	void* fe_handle;
378	int (fe_release)(void handle);	391	int (fe_release)(void handle);
		392
		393	/* for switching modulation types */
		394	unsigned char ts_gen_cntrl;
379	};	395	};
380		396
381	/* ----------------------------------------------------------- */	397	/* ----------------------------------------------------------- */
Lines 411-417 extern void cx88_print_irqbits(char *nam Link Here
411	u32 bits, u32 mask);	427	u32 bits, u32 mask);
412	extern void cx88_print_ioctl(char *name, unsigned int cmd);	428	extern void cx88_print_ioctl(char *name, unsigned int cmd);
413		429
414	extern void cx88_irq(struct cx88_core *core, u32 status, u32 mask);	430	extern int cx88_core_irq(struct cx88_core *core, u32 status);
415	extern void cx88_wakeup(struct cx88_core *core,	431	extern void cx88_wakeup(struct cx88_core *core,
416	struct cx88_dmaqueue *q, u32 count);	432	struct cx88_dmaqueue *q, u32 count);
417	extern void cx88_shutdown(struct cx88_core *core);	433	extern void cx88_shutdown(struct cx88_core *core);
Lines 503-513 extern void cx88_card_setup(struct cx88_ Link Here
503	#define WW_FM 12	519	#define WW_FM 12
504		520
505	void cx88_set_tvaudio(struct cx88_core *core);	521	void cx88_set_tvaudio(struct cx88_core *core);
		522	void cx88_newstation(struct cx88_core *core);
506	void cx88_get_stereo(struct cx88_core core, struct v4l2_tuner t);	523	void cx88_get_stereo(struct cx88_core core, struct v4l2_tuner t);
507	void cx88_set_stereo(struct cx88_core *core, u32 mode);	524	void cx88_set_stereo(struct cx88_core *core, u32 mode, int manual);
508	int cx88_audio_thread(void *data);	525	int cx88_audio_thread(void *data);
509		526
510	/* ----------------------------------------------------------- */	527	/* ----------------------------------------------------------- */
		528	/* cx88-input.c */
		529
		530	int cx88_ir_init(struct cx88_core core, struct pci_dev pci);
		531	int cx88_ir_fini(struct cx88_core *core);
		532	void cx88_ir_irq(struct cx88_core *core);
		533
		534	/* ----------------------------------------------------------- */
511	/* cx88-mpeg.c */	535	/* cx88-mpeg.c */
512		536
513	int cx8802_buf_prepare(struct cx8802_dev dev, struct cx88_buffer buf);	537	int cx8802_buf_prepare(struct cx8802_dev dev, struct cx88_buffer buf);
Lines 517-523 void cx8802_cancel_buffers(struct cx8802 Link Here
517	int cx8802_init_common(struct cx8802_dev *dev);	541	int cx8802_init_common(struct cx8802_dev *dev);
518	void cx8802_fini_common(struct cx8802_dev *dev);	542	void cx8802_fini_common(struct cx8802_dev *dev);
519		543
520	int cx8802_suspend_common(struct pci_dev *pci_dev, u32 state);	544	int cx8802_suspend_common(struct pci_dev *pci_dev, pm_message_t state);
521	int cx8802_resume_common(struct pci_dev *pci_dev);	545	int cx8802_resume_common(struct pci_dev *pci_dev);
522		546
523	/*	547	/*




/*
 * $Id: ir-kbd-gpio.c,v 1.12 2005/02/22 12:28:40 kraxel Exp $
 *
 * Copyright (c) 2003 Gerd Knorr
 * Copyright (c) 2003 Pavel Machek

	[ 0x3e ] = KEY_VOLUMEUP,    // 'volume +'
};

static IR_KEYTAB_TYPE winfast_codes[IR_KEYTAB_SIZE] = {
	[  5 ] = KEY_KP1,
	[  6 ] = KEY_KP2,
	[  7 ] = KEY_KP3,
	[  9 ] = KEY_KP4,
	[ 10 ] = KEY_KP5,
	[ 11 ] = KEY_KP6,
	[ 13 ] = KEY_KP7,
	[ 14 ] = KEY_KP8,
	[ 15 ] = KEY_KP9,
	[ 18 ] = KEY_KP0,

	[  0 ] = KEY_POWER,
//      [ 27 ] = MTS button
	[  2 ] = KEY_TUNER,     // TV/FM
	[ 30 ] = KEY_VIDEO,
//      [ 22 ] = display button
	[  4 ] = KEY_VOLUMEUP,
	[  8 ] = KEY_VOLUMEDOWN,
	[ 12 ] = KEY_CHANNELUP,
	[ 16 ] = KEY_CHANNELDOWN,
	[  3 ] = KEY_ZOOM,      // fullscreen
	[ 31 ] = KEY_SUBTITLE,  // closed caption/teletext
	[ 32 ] = KEY_SLEEP,
//      [ 41 ] = boss key
	[ 20 ] = KEY_MUTE,
	[ 43 ] = KEY_RED,
	[ 44 ] = KEY_GREEN,
	[ 45 ] = KEY_YELLOW,
	[ 46 ] = KEY_BLUE,
	[ 24 ] = KEY_KPPLUS,    //fine tune +
	[ 25 ] = KEY_KPMINUS,   //fine tune -
//      [ 42 ] = picture in picture
        [ 33 ] = KEY_KPDOT,
	[ 19 ] = KEY_KPENTER,
//      [ 17 ] = recall
	[ 34 ] = KEY_BACK,
	[ 35 ] = KEY_PLAYPAUSE,
	[ 36 ] = KEY_NEXT,
//      [ 37 ] = time shifting
	[ 38 ] = KEY_STOP,
	[ 39 ] = KEY_RECORD
//      [ 40 ] = snapshot
};

static IR_KEYTAB_TYPE ir_codes_pixelview[IR_KEYTAB_SIZE] = {
	[  2 ] = KEY_KP0,
	[  1 ] = KEY_KP1,

                break;

	case BTTV_WINFAST2000:
		ir_codes         = ir_codes_winfast;
		ir->mask_keycode = 0x1f8;
		break;
	case BTTV_MAGICTVIEW061:
	case BTTV_MAGICTVIEW063:
		ir_codes         = ir_codes_winfast;
		ir->mask_keycode = 0x0008e000;
		ir->mask_keydown = 0x00200000;
		break;

Lines 380-386 static void msp3400c_setvolume(struct i2 Link Here

(-)linux-2.6.11.orig/drivers/media/video/msp3400.c (-10 / +18 lines)
380	int val = 0, bal = 0;	380	int val = 0, bal = 0;
381		381
382	if (!muted) {	382	if (!muted) {
383	val = (volume * 0x7F / 65535) << 8;	383	/* 0x7f instead if 0x73 here has sound quality issues,
		384	* probably due to overmodulation + clipping ... */
		385	val = (volume * 0x73 / 65535) << 8;
384	}	386	}
385	if (val) {	387	if (val) {
386	bal = (balance / 256) - 128;	388	bal = (balance / 256) - 128;
Lines 993-999 static int msp34xx_modus(int norm) Link Here
993	{	995	{
994	switch (norm) {	996	switch (norm) {
995	case VIDEO_MODE_PAL:	997	case VIDEO_MODE_PAL:
		998	#if 1
		999	/* experimental: not sure this works with all chip versions */
		1000	return 0x7003;
		1001	#else
		1002	/* previous value, try this if it breaks ... */
996	return 0x1003;	1003	return 0x1003;
		1004	#endif
997	case VIDEO_MODE_NTSC: /* BTSC */	1005	case VIDEO_MODE_NTSC: /* BTSC */
998	return 0x2003;	1006	return 0x2003;
999	case VIDEO_MODE_SECAM:	1007	case VIDEO_MODE_SECAM:
Lines 1260-1265 static int msp34xxg_thread(void *data) Link Here
1260	int val, std, i;	1268	int val, std, i;
1261		1269
1262	printk("msp34xxg: daemon started\n");	1270	printk("msp34xxg: daemon started\n");
		1271	msp->source = 1; /* default */
1263	for (;;) {	1272	for (;;) {
1264	d2printk(KERN_DEBUG "msp34xxg: thread: sleep\n");	1273	d2printk(KERN_DEBUG "msp34xxg: thread: sleep\n");
1265	msp34xx_sleep(msp,-1);	1274	msp34xx_sleep(msp,-1);
Lines 1330-1337 static void msp34xxg_set_source(struct i Link Here
1330		1339
1331	/* fix matrix mode to stereo and let the msp choose what	1340	/* fix matrix mode to stereo and let the msp choose what
1332	* to output according to 'source', as recommended	1341	* to output according to 'source', as recommended
		1342	* for MONO (source==0) downmixing set bit[7:0] to 0x30
1333	*/	1343	*/
1334	int value = (source&0x07)<<8\|(source==0 ? 0x00:0x20);	1344	int value = (source&0x07)<<8\|(source==0 ? 0x30:0x20);
1335	dprintk("msp34xxg: set source to %d (0x%x)\n", source, value);	1345	dprintk("msp34xxg: set source to %d (0x%x)\n", source, value);
1336	msp3400c_write(client,	1346	msp3400c_write(client,
1337	I2C_MSP3400C_DFP,	1347	I2C_MSP3400C_DFP,
Lines 1355-1361 static void msp34xxg_set_source(struct i Link Here
1355	msp3400c_write(client,	1365	msp3400c_write(client,
1356	I2C_MSP3400C_DEM,	1366	I2C_MSP3400C_DEM,
1357	0x22, /* a2 threshold for stereo/bilingual */	1367	0x22, /* a2 threshold for stereo/bilingual */
1358	source==0 ? 0x7f0:stereo_threshold);	1368	stereo_threshold);
1359	msp->source=source;	1369	msp->source=source;
1360	}	1370	}
1361		1371
Lines 1390-1396 static void msp34xxg_detect_stereo(struc Link Here
1390	static void msp34xxg_set_audmode(struct i2c_client *client, int audmode)	1400	static void msp34xxg_set_audmode(struct i2c_client *client, int audmode)
1391	{	1401	{
1392	struct msp3400c *msp = i2c_get_clientdata(client);	1402	struct msp3400c *msp = i2c_get_clientdata(client);
1393	int source = 0;	1403	int source;
1394		1404
1395	switch (audmode) {	1405	switch (audmode) {
1396	case V4L2_TUNER_MODE_MONO:	1406	case V4L2_TUNER_MODE_MONO:
Lines 1406-1414 static void msp34xxg_set_audmode(struct Link Here
1406	case V4L2_TUNER_MODE_LANG2:	1416	case V4L2_TUNER_MODE_LANG2:
1407	source=4; /* stereo or B */	1417	source=4; /* stereo or B */
1408	break;	1418	break;
1409	default: /* doing nothing: a safe, sane default */	1419	default:
1410	audmode = 0;	1420	audmode = 0;
1411	return;	1421	source = 1;
		1422	break;
1412	}	1423	}
1413	msp->audmode = audmode;	1424	msp->audmode = audmode;
1414	msp34xxg_set_source(client, source);	1425	msp34xxg_set_source(client, source);
Lines 1510-1521 static int msp_attach(struct i2c_adapter Link Here
1510		1521
1511	msp->opmode = opmode;	1522	msp->opmode = opmode;
1512	if (OPMODE_AUTO == msp->opmode) {	1523	if (OPMODE_AUTO == msp->opmode) {
1513	#if 0 /* seems to work for ivtv only, disable by default for now ... */
1514	if (HAVE_SIMPLER(msp))	1524	if (HAVE_SIMPLER(msp))
1515	msp->opmode = OPMODE_SIMPLER;	1525	msp->opmode = OPMODE_SIMPLER;
1516	else	1526	else if (HAVE_SIMPLE(msp))
1517	#endif
1518	if (HAVE_SIMPLE(msp))
1519	msp->opmode = OPMODE_SIMPLE;	1527	msp->opmode = OPMODE_SIMPLE;
1520	else	1528	else
1521	msp->opmode = OPMODE_MANUAL;	1529	msp->opmode = OPMODE_MANUAL;




/*
 * $Id: mt20xx.c,v 1.4 2005/03/04 09:24:56 kraxel Exp $
 *
 * i2c tv tuner chip device driver
 * controls microtune tuners, mt2032 + mt2050 at the moment.
 */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/videodev.h>
#include <linux/moduleparam.h>
#include <media/tuner.h>

/* ---------------------------------------------------------------------- */

static unsigned int optimize_vco  = 1;
module_param(optimize_vco,      int, 0644);

static unsigned int tv_antenna    = 1;
module_param(tv_antenna,        int, 0644);

static unsigned int radio_antenna = 0;
module_param(radio_antenna,     int, 0644);

/* ---------------------------------------------------------------------- */

#define MT2032 0x04
#define MT2030 0x06
#define MT2040 0x07
#define MT2050 0x42

static char *microtune_part[] = {
	[ MT2030 ] = "MT2030",
	[ MT2032 ] = "MT2032",
	[ MT2040 ] = "MT2040",
	[ MT2050 ] = "MT2050",
};

// IsSpurInBand()?
static int mt2032_spurcheck(struct i2c_client *c,
			    int f1, int f2, int spectrum_from,int spectrum_to)
{
	struct tuner *t = i2c_get_clientdata(c);
	int n1=1,n2,f;

	f1=f1/1000; //scale to kHz to avoid 32bit overflows
	f2=f2/1000;
	spectrum_from/=1000;
	spectrum_to/=1000;

	tuner_dbg("spurcheck f1=%d f2=%d  from=%d to=%d\n",
		  f1,f2,spectrum_from,spectrum_to);

	do {
	    n2=-n1;
	    f=n1*(f1-f2);
	    do {
		n2--;
		f=f-f2;
		tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);

		if( (f>spectrum_from) && (f<spectrum_to))
			tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
	    } while ( (f>(f2-spectrum_to)) || (n2>-5));
	    n1++;
	} while (n1<5);

	return 1;
}

static int mt2032_compute_freq(struct i2c_client *c,
			       unsigned int rfin,
			       unsigned int if1, unsigned int if2,
			       unsigned int spectrum_from,
			       unsigned int spectrum_to,
			       unsigned char *buf,
			       int *ret_sel,
			       unsigned int xogc) //all in Hz
{
	struct tuner *t = i2c_get_clientdata(c);
        unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
		desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;

        fref= 5250 *1000; //5.25MHz
	desired_lo1=rfin+if1;

	lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
        lo1n=lo1/8;
        lo1a=lo1-(lo1n*8);

        s=rfin/1000/1000+1090;

	if(optimize_vco) {
		if(s>1890) sel=0;
		else if(s>1720) sel=1;
		else if(s>1530) sel=2;
		else if(s>1370) sel=3;
		else sel=4; // >1090
	}
	else {
        	if(s>1790) sel=0; // <1958
        	else if(s>1617) sel=1;
        	else if(s>1449) sel=2;
        	else if(s>1291) sel=3;
        	else sel=4; // >1090
	}
	*ret_sel=sel;

        lo1freq=(lo1a+8*lo1n)*fref;

	tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
		  rfin,lo1,lo1n,lo1a,sel,lo1freq);

        desired_lo2=lo1freq-rfin-if2;
        lo2=(desired_lo2)/fref;
        lo2n=lo2/8;
        lo2a=lo2-(lo2n*8);
        lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
        lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;

	tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
		  rfin,lo2,lo2n,lo2a,lo2num,lo2freq);

        if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
		tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
			   lo1a, lo1n, lo2a,lo2n);
                return(-1);
        }

	mt2032_spurcheck(c, lo1freq, desired_lo2,  spectrum_from, spectrum_to);
	// should recalculate lo1 (one step up/down)

	// set up MT2032 register map for transfer over i2c
	buf[0]=lo1n-1;
	buf[1]=lo1a | (sel<<4);
	buf[2]=0x86; // LOGC
	buf[3]=0x0f; //reserved
	buf[4]=0x1f;
	buf[5]=(lo2n-1) | (lo2a<<5);
 	if(rfin >400*1000*1000)
                buf[6]=0xe4;
        else
                buf[6]=0xf4; // set PKEN per rev 1.2
	buf[7]=8+xogc;
	buf[8]=0xc3; //reserved
	buf[9]=0x4e; //reserved
	buf[10]=0xec; //reserved
	buf[11]=(lo2num&0xff);
	buf[12]=(lo2num>>8) |0x80; // Lo2RST

	return 0;
}

static int mt2032_check_lo_lock(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
	int try,lock=0;
	unsigned char buf[2];

	for(try=0;try<10;try++) {
		buf[0]=0x0e;
		i2c_master_send(c,buf,1);
		i2c_master_recv(c,buf,1);
		tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
		lock=buf[0] &0x06;

		if (lock==6)
			break;

		tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
		udelay(1000);
	}
        return lock;
}

static int mt2032_optimize_vco(struct i2c_client *c,int sel,int lock)
{
	struct tuner *t = i2c_get_clientdata(c);
	unsigned char buf[2];
	int tad1;

	buf[0]=0x0f;
	i2c_master_send(c,buf,1);
	i2c_master_recv(c,buf,1);
	tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
	tad1=buf[0]&0x07;

	if(tad1 ==0) return lock;
	if(tad1 ==1) return lock;

	if(tad1==2) {
		if(sel==0)
			return lock;
		else sel--;
	}
	else {
		if(sel<4)
			sel++;
		else
			return lock;
	}

	tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);

	buf[0]=0x0f;
	buf[1]=sel;
        i2c_master_send(c,buf,2);
	lock=mt2032_check_lo_lock(c);
	return lock;
}


static void mt2032_set_if_freq(struct i2c_client *c, unsigned int rfin,
			       unsigned int if1, unsigned int if2,
			       unsigned int from, unsigned int to)
{
	unsigned char buf[21];
	int lint_try,ret,sel,lock=0;
	struct tuner *t = i2c_get_clientdata(c);

	tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
		  rfin,if1,if2,from,to);

        buf[0]=0;
        ret=i2c_master_send(c,buf,1);
        i2c_master_recv(c,buf,21);

	buf[0]=0;
	ret=mt2032_compute_freq(c,rfin,if1,if2,from,to,&buf[1],&sel,t->xogc);
	if (ret<0)
		return;

        // send only the relevant registers per Rev. 1.2
        buf[0]=0;
        ret=i2c_master_send(c,buf,4);
        buf[5]=5;
        ret=i2c_master_send(c,buf+5,4);
        buf[11]=11;
        ret=i2c_master_send(c,buf+11,3);
        if(ret!=3)
		tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);

	// wait for PLLs to lock (per manual), retry LINT if not.
	for(lint_try=0; lint_try<2; lint_try++) {
		lock=mt2032_check_lo_lock(c);

		if(optimize_vco)
			lock=mt2032_optimize_vco(c,sel,lock);
		if(lock==6) break;

		tuner_dbg("mt2032: re-init PLLs by LINT\n");
		buf[0]=7;
		buf[1]=0x80 +8+t->xogc; // set LINT to re-init PLLs
		i2c_master_send(c,buf,2);
		mdelay(10);
		buf[1]=8+t->xogc;
		i2c_master_send(c,buf,2);
        }

	if (lock!=6)
		tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");

	buf[0]=2;
	buf[1]=0x20; // LOGC for optimal phase noise
	ret=i2c_master_send(c,buf,2);
	if (ret!=2)
		tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
}


static void mt2032_set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	int if2,from,to;

	// signal bandwidth and picture carrier
	if (t->std & V4L2_STD_525_60) {
		// NTSC
		from = 40750*1000;
		to   = 46750*1000;
		if2  = 45750*1000;
	} else {
		// PAL
		from = 32900*1000;
		to   = 39900*1000;
		if2  = 38900*1000;
	}

        mt2032_set_if_freq(c, freq*62500 /* freq*1000*1000/16 */,
			   1090*1000*1000, if2, from, to);
}

static void mt2032_set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	int if2 = t->radio_if2;

	// per Manual for FM tuning: first if center freq. 1085 MHz
        mt2032_set_if_freq(c, freq*62500 /* freq*1000*1000/16 */,
			   1085*1000*1000,if2,if2,if2);
}

// Initalization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
static int mt2032_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
        unsigned char buf[21];
        int ret,xogc,xok=0;

	// Initialize Registers per spec.
        buf[1]=2; // Index to register 2
        buf[2]=0xff;
        buf[3]=0x0f;
        buf[4]=0x1f;
        ret=i2c_master_send(c,buf+1,4);

        buf[5]=6; // Index register 6
        buf[6]=0xe4;
        buf[7]=0x8f;
        buf[8]=0xc3;
        buf[9]=0x4e;
        buf[10]=0xec;
        ret=i2c_master_send(c,buf+5,6);

        buf[12]=13;  // Index register 13
        buf[13]=0x32;
        ret=i2c_master_send(c,buf+12,2);

        // Adjust XOGC (register 7), wait for XOK
        xogc=7;
        do {
		tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
                mdelay(10);
                buf[0]=0x0e;
                i2c_master_send(c,buf,1);
                i2c_master_recv(c,buf,1);
                xok=buf[0]&0x01;
                tuner_dbg("mt2032: xok = 0x%02x\n",xok);
                if (xok == 1) break;

                xogc--;
                tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
                if (xogc == 3) {
                        xogc=4; // min. 4 per spec
                        break;
                }
                buf[0]=0x07;
                buf[1]=0x88 + xogc;
                ret=i2c_master_send(c,buf,2);
                if (ret!=2)
			tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
        } while (xok != 1 );
	t->xogc=xogc;

	t->tv_freq    = mt2032_set_tv_freq;
	t->radio_freq = mt2032_set_radio_freq;
        return(1);
}

static void mt2050_set_antenna(struct i2c_client *c, unsigned char antenna)
{
	struct tuner *t = i2c_get_clientdata(c);
       unsigned char buf[2];
       int ret;

       buf[0] = 6;
       buf[1] = antenna ? 0x11 : 0x10;
       ret=i2c_master_send(c,buf,2);
       tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
}

static void mt2050_set_if_freq(struct i2c_client *c,unsigned int freq, unsigned int if2)
{
	struct tuner *t = i2c_get_clientdata(c);
	unsigned int if1=1218*1000*1000;
	unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
	int ret;
	unsigned char buf[6];

	tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
		  freq,if1,if2);

	f_lo1=freq+if1;
	f_lo1=(f_lo1/1000000)*1000000;

	f_lo2=f_lo1-freq-if2;
	f_lo2=(f_lo2/50000)*50000;

	lo1=f_lo1/4000000;
	lo2=f_lo2/4000000;

	f_lo1_modulo= f_lo1-(lo1*4000000);
	f_lo2_modulo= f_lo2-(lo2*4000000);

	num1=4*f_lo1_modulo/4000000;
	num2=4096*(f_lo2_modulo/1000)/4000;

	// todo spurchecks

	div1a=(lo1/12)-1;
	div1b=lo1-(div1a+1)*12;

	div2a=(lo2/8)-1;
	div2b=lo2-(div2a+1)*8;

	if (tuner_debug > 1) {
		tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
		tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
			  num1,num2,div1a,div1b,div2a,div2b);
	}

	buf[0]=1;
	buf[1]= 4*div1b + num1;
	if(freq<275*1000*1000) buf[1] = buf[1]|0x80;

	buf[2]=div1a;
	buf[3]=32*div2b + num2/256;
	buf[4]=num2-(num2/256)*256;
	buf[5]=div2a;
	if(num2!=0) buf[5]=buf[5]|0x40;

	if (tuner_debug > 1) {
		int i;
		tuner_dbg("bufs is: ");
		for(i=0;i<6;i++)
			printk("%x ",buf[i]);
		printk("\n");
	}

	ret=i2c_master_send(c,buf,6);
        if (ret!=6)
		tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
}

static void mt2050_set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	unsigned int if2;

	if (t->std & V4L2_STD_525_60) {
		// NTSC
                if2 = 45750*1000;
        } else {
                // PAL
                if2 = 38900*1000;
        }
	if (V4L2_TUNER_DIGITAL_TV == t->mode) {
		// DVB (pinnacle 300i)
		if2 = 36150*1000;
	}
	mt2050_set_if_freq(c, freq*62500, if2);
	mt2050_set_antenna(c, tv_antenna);
}

static void mt2050_set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	int if2 = t->radio_if2;

	mt2050_set_if_freq(c, freq*62500, if2);
	mt2050_set_antenna(c, radio_antenna);
}

static int mt2050_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
	unsigned char buf[2];
	int ret;

	buf[0]=6;
	buf[1]=0x10;
	ret=i2c_master_send(c,buf,2); //  power

	buf[0]=0x0f;
	buf[1]=0x0f;
	ret=i2c_master_send(c,buf,2); // m1lo

	buf[0]=0x0d;
	ret=i2c_master_send(c,buf,1);
	i2c_master_recv(c,buf,1);

	tuner_dbg("mt2050: sro is %x\n",buf[0]);
	t->tv_freq    = mt2050_set_tv_freq;
	t->radio_freq = mt2050_set_radio_freq;
	return 0;
}

int microtune_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
	char *name;
        unsigned char buf[21];
	int company_code;

	memset(buf,0,sizeof(buf));
	t->tv_freq    = NULL;
	t->radio_freq = NULL;
	name = "unknown";

        i2c_master_send(c,buf,1);
        i2c_master_recv(c,buf,21);
        if (tuner_debug) {
                int i;
		tuner_dbg("MT20xx hexdump:");
                for(i=0;i<21;i++) {
                        printk(" %02x",buf[i]);
                        if(((i+1)%8)==0) printk(" ");
                }
                printk("\n");
        }
	company_code = buf[0x11] << 8 | buf[0x12];
	tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
		   company_code,buf[0x13],buf[0x14]);

#if 0
	/* seems to cause more problems than it solves ... */
	switch (company_code) {
	case 0x30bf:
	case 0x3cbf:
	case 0x3dbf:
	case 0x4d54:
	case 0x8e81:
	case 0x8e91:
		/* ok (?) */
		break;
	default:
		tuner_warn("tuner: microtune: unknown companycode\n");
		return 0;
	}
#endif

	if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
	    NULL != microtune_part[buf[0x13]])
		name = microtune_part[buf[0x13]];
	switch (buf[0x13]) {
	case MT2032:
		mt2032_init(c);
		break;
	case MT2050:
		mt2050_init(c);
		break;
	default:
		tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
			   name);
                return 0;
        }

	strlcpy(c->name, name, sizeof(c->name));
	tuner_info("microtune %s found, OK\n",name);
	return 0;
}

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Lines 40-45 Link Here

(-)linux-2.6.11.orig/drivers/media/video/planb.c (-2 / +2 lines)
40	#include <linux/mm.h>	40	#include <linux/mm.h>
41	#include <linux/sched.h>	41	#include <linux/sched.h>
42	#include <linux/videodev.h>	42	#include <linux/videodev.h>
		43	#include <linux/wait.h>
43	#include <asm/uaccess.h>	44	#include <asm/uaccess.h>
44	#include <asm/io.h>	45	#include <asm/io.h>
45	#include <asm/prom.h>	46	#include <asm/prom.h>
Lines 1609-1616 static int planb_ioctl(struct video_devi Link Here
1609	}	1610	}
1610	planb_lock(pb);	1611	planb_lock(pb);
1611	/* empty the grabbing queue */	1612	/* empty the grabbing queue */
1612	while(pb->grabbing)	1613	wait_event(pb->capq, !pb->grabbing);
1613	interruptible_sleep_on(&pb->capq);
1614	pb->maxlines = maxlines;	1614	pb->maxlines = maxlines;
1615	pb->win.norm = v.norm;	1615	pb->win.norm = v.norm;
1616	/* Stop overlay if running */	1616	/* Stop overlay if running */




/* Addresses to scan */
static unsigned short normal_i2c[]	 = { I2C_ADDRESS, I2C_CLIENT_END };
static unsigned short normal_i2c_range[] = { I2C_CLIENT_END };
I2C_CLIENT_INSMOD;
static unsigned short probe_range[2]	 = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short ignore[2]		 = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short ignore_range[2]	 = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short force[2]		 = { I2C_CLIENT_END, I2C_CLIENT_END };

static struct i2c_client_address_data addr_data = {
	normal_i2c, normal_i2c_range,
	probe, probe_range,
	ignore, ignore_range,
	force
};

static struct i2c_client client_template;





/* Addresses to scan */
static unsigned short normal_i2c[] = {34>>1,I2C_CLIENT_END};
static unsigned short normal_i2c_range[] = {I2C_CLIENT_END};
I2C_CLIENT_INSMOD;
static unsigned short probe_range[2]  = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short ignore[2]       = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };
static unsigned short force[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };

static struct i2c_client_address_data addr_data = {
	normal_i2c, normal_i2c_range, 
	probe, probe_range, 
	ignore, ignore_range, 
	force
};

static struct i2c_client client_template;


Lines 30-35 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7110.c (-2 / +8 lines)
30	#include <linux/types.h>	30	#include <linux/types.h>
31	#include <linux/delay.h>	31	#include <linux/delay.h>
32	#include <linux/slab.h>	32	#include <linux/slab.h>
		33	#include <linux/wait.h>
33	#include <asm/io.h>	34	#include <asm/io.h>
34	#include <asm/uaccess.h>	35	#include <asm/uaccess.h>
35		36
Lines 205-217 static const unsigned char initseq[] = { Link Here
205	static int	206	static int
206	determine_norm (struct i2c_client *client)	207	determine_norm (struct i2c_client *client)
207	{	208	{
		209	DEFINE_WAIT(wait);
208	struct saa7110 *decoder = i2c_get_clientdata(client);	210	struct saa7110 *decoder = i2c_get_clientdata(client);
209	int status;	211	int status;
210		212
211	/* mode changed, start automatic detection */	213	/* mode changed, start automatic detection */
212	saa7110_write_block(client, initseq, sizeof(initseq));	214	saa7110_write_block(client, initseq, sizeof(initseq));
213	saa7110_selmux(client, decoder->input);	215	saa7110_selmux(client, decoder->input);
214	sleep_on_timeout(&decoder->wq, HZ / 4);	216	prepare_to_wait(&decoder->wq, &wait, TASK_UNINTERRUPTIBLE);
		217	schedule_timeout(HZ/4);
		218	finish_wait(&decoder->wq, &wait);
215	status = saa7110_read(client);	219	status = saa7110_read(client);
216	if (status & 0x40) {	220	if (status & 0x40) {
217	dprintk(1, KERN_INFO "%s: status=0x%02x (no signal)\n",	221	dprintk(1, KERN_INFO "%s: status=0x%02x (no signal)\n",
Lines 250-256 determine_norm (struct i2c_client *clien Link Here
250	saa7110_write(client, 0x11, 0x59);	254	saa7110_write(client, 0x11, 0x59);
251	//saa7110_write(client,0x2E,0x9A);	255	//saa7110_write(client,0x2E,0x9A);
252		256
253	sleep_on_timeout(&decoder->wq, HZ / 4);	257	prepare_to_wait(&decoder->wq, &wait, TASK_UNINTERRUPTIBLE);
		258	schedule_timeout(HZ/4);
		259	finish_wait(&decoder->wq, &wait);
254		260
255	status = saa7110_read(client);	261	status = saa7110_read(client);
256	if ((status & 0x03) == 0x01) {	262	if ((status & 0x03) == 0x01) {

Lines 8-10 obj-$(CONFIG_VIDEO_SAA7134_DVB) += saa71 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/Makefile (+1 lines)
8		8
9	EXTRA_CFLAGS += -I$(src)/..	9	EXTRA_CFLAGS += -I$(src)/..
10	EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core	10	EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core
		11	EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/frontends

Lines 11-19 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa6752hs.c (-89 / +225 lines)
11	#include <linux/types.h>	11	#include <linux/types.h>
12	#include <linux/videodev.h>	12	#include <linux/videodev.h>
13	#include <linux/init.h>	13	#include <linux/init.h>
		14	#include <linux/crc32.h>
14		15
15	#include <media/id.h>	16	#include <media/id.h>
16	#include <media/saa6752hs.h>	17
		18	#define MPEG_VIDEO_TARGET_BITRATE_MAX 27000
		19	#define MPEG_VIDEO_MAX_BITRATE_MAX 27000
		20	#define MPEG_TOTAL_TARGET_BITRATE_MAX 27000
		21	#define MPEG_PID_MAX ((1 << 14) - 1)
17		22
18	/* Addresses to scan */	23	/* Addresses to scan */
19	static unsigned short normal_i2c[] = {0x20, I2C_CLIENT_END};	24	static unsigned short normal_i2c[] = {0x20, I2C_CLIENT_END};
Lines 27-32 MODULE_LICENSE("GPL"); Link Here
27	static struct i2c_driver driver;	32	static struct i2c_driver driver;
28	static struct i2c_client client_template;	33	static struct i2c_client client_template;
29		34
		35	struct saa6752hs_state {
		36	struct i2c_client client;
		37	struct v4l2_mpeg_compression params;
		38	};
30		39
31	enum saa6752hs_command {	40	enum saa6752hs_command {
32	SAA6752HS_COMMAND_RESET = 0,	41	SAA6752HS_COMMAND_RESET = 0,
Lines 40-46 enum saa6752hs_command { Link Here
40	SAA6752HS_COMMAND_MAX	49	SAA6752HS_COMMAND_MAX
41	};	50	};
42		51
43
44	/* ---------------------------------------------------------------------- */	52	/* ---------------------------------------------------------------------- */
45		53
46	static u8 PAT[] = {	54	static u8 PAT[] = {
Lines 64-72 static u8 PAT[] = { Link Here
64		72
65	0x00, 0x01, // program_number(1)	73	0x00, 0x01, // program_number(1)
66		74
67	0xe0, 0x10, // PMT PID(0x10)	75	0xe0, 0x00, // PMT PID
68		76
69	0x76, 0xf1, 0x44, 0xd1 // CRC32	77	0x00, 0x00, 0x00, 0x00 // CRC32
70	};	78	};
71		79
72	static u8 PMT[] = {	80	static u8 PMT[] = {
Lines 74-80 static u8 PMT[] = { Link Here
74	0x01, // table number for encoder	82	0x01, // table number for encoder
75		83
76	0x47, // sync	84	0x47, // sync
77	0x40, 0x10, // transport_error_indicator(0), payload_unit_start(1), transport_priority(0), pid(0x10)	85	0x40, 0x00, // transport_error_indicator(0), payload_unit_start(1), transport_priority(0), pid
78	0x10, // transport_scrambling_control(00), adaptation_field_control(01), continuity_counter(0)	86	0x10, // transport_scrambling_control(00), adaptation_field_control(01), continuity_counter(0)
79		87
80	0x00, // PSI pointer to start of table	88	0x00, // PSI pointer to start of table
Lines 88-114 static u8 PMT[] = { Link Here
88		96
89	0x00, 0x00, // section_number(0), last_section_number(0)	97	0x00, 0x00, // section_number(0), last_section_number(0)
90		98
91	0xe1, 0x04, // PCR_PID (0x104)	99	0xe0, 0x00, // PCR_PID
92		100
93	0xf0, 0x00, // program_info_length(0)	101	0xf0, 0x00, // program_info_length(0)
94		102
95	0x02, 0xe1, 0x00, 0xf0, 0x00, // video stream type(2), pid(0x100)	103	0x02, 0xe0, 0x00, 0xf0, 0x00, // video stream type(2), pid
96	0x04, 0xe1, 0x03, 0xf0, 0x00, // audio stream type(4), pid(0x103)	104	0x04, 0xe0, 0x00, 0xf0, 0x00, // audio stream type(4), pid
97		105
98	0xa1, 0xca, 0x0f, 0x82 // CRC32	106	0x00, 0x00, 0x00, 0x00 // CRC32
99	};	107	};
100		108
101	static struct mpeg_params mpeg_params_template =	109	static struct v4l2_mpeg_compression param_defaults =
102	{	110	{
103	.bitrate_mode = MPEG_BITRATE_MODE_CBR,	111	.st_type = V4L2_MPEG_TS_2,
104	.video_target_bitrate = 5000,	112	.st_bitrate = {
105	.audio_bitrate = MPEG_AUDIO_BITRATE_256,	113	.mode = V4L2_BITRATE_CBR,
106	.total_bitrate = 6000,	114	.target = 7000,
107	};	115	},
108		116
		117	.ts_pid_pmt = 16,
		118	.ts_pid_video = 260,
		119	.ts_pid_audio = 256,
		120	.ts_pid_pcr = 259,
109		121
110	/* ---------------------------------------------------------------------- */	122	.vi_type = V4L2_MPEG_VI_2,
		123	.vi_aspect_ratio = V4L2_MPEG_ASPECT_4_3,
		124	.vi_bitrate = {
		125	.mode = V4L2_BITRATE_VBR,
		126	.target = 4000,
		127	.max = 6000,
		128	},
111		129
		130	.au_type = V4L2_MPEG_AU_2_II,
		131	.au_bitrate = {
		132	.mode = V4L2_BITRATE_CBR,
		133	.target = 256,
		134	},
		135
		136	#if 0
		137	/* FIXME: size? via S_FMT? */
		138	.video_format = MPEG_VIDEO_FORMAT_D1,
		139	#endif
		140	};
		141
		142	/* ---------------------------------------------------------------------- */
112		143
113	static int saa6752hs_chip_command(struct i2c_client* client,	144	static int saa6752hs_chip_command(struct i2c_client* client,
114	enum saa6752hs_command command)	145	enum saa6752hs_command command)
Lines 124-130 static int saa6752hs_chip_command(struct Link Here
124	break;	155	break;
125		156
126	case SAA6752HS_COMMAND_STOP:	157	case SAA6752HS_COMMAND_STOP:
127	buf[0] = 0x03;	158	buf[0] = 0x03;
128	break;	159	break;
129		160
130	case SAA6752HS_COMMAND_START:	161	case SAA6752HS_COMMAND_START:
Lines 180-253 static int saa6752hs_chip_command(struct Link Here
180		211
181		212
182	static int saa6752hs_set_bitrate(struct i2c_client* client,	213	static int saa6752hs_set_bitrate(struct i2c_client* client,
183	struct mpeg_params* params)	214	struct v4l2_mpeg_compression* params)
184	{	215	{
185	u8 buf[3];	216	u8 buf[3];
186		217
187	// set the bitrate mode	218	// set the bitrate mode
188	buf[0] = 0x71;	219	buf[0] = 0x71;
189	buf[1] = params->bitrate_mode;	220	buf[1] = (params->vi_bitrate.mode == V4L2_BITRATE_VBR) ? 0 : 1;
190	i2c_master_send(client, buf, 2);	221	i2c_master_send(client, buf, 2);
191		222
192	// set the video bitrate	223	// set the video bitrate
193	if (params->bitrate_mode == MPEG_BITRATE_MODE_VBR) {	224	if (params->vi_bitrate.mode == V4L2_BITRATE_VBR) {
194	// set the target bitrate	225	// set the target bitrate
195	buf[0] = 0x80;	226	buf[0] = 0x80;
196	buf[1] = params->video_target_bitrate >> 8;	227	buf[1] = params->vi_bitrate.target >> 8;
197	buf[2] = params->video_target_bitrate & 0xff;	228	buf[2] = params->vi_bitrate.target & 0xff;
198	i2c_master_send(client, buf, 3);	229	i2c_master_send(client, buf, 3);
199		230
200	// set the max bitrate	231	// set the max bitrate
201	buf[0] = 0x81;	232	buf[0] = 0x81;
202	buf[1] = params->video_max_bitrate >> 8;	233	buf[1] = params->vi_bitrate.max >> 8;
203	buf[2] = params->video_max_bitrate & 0xff;	234	buf[2] = params->vi_bitrate.max & 0xff;
204	i2c_master_send(client, buf, 3);	235	i2c_master_send(client, buf, 3);
205	} else {	236	} else {
206	// set the target bitrate (no max bitrate for CBR)	237	// set the target bitrate (no max bitrate for CBR)
207	buf[0] = 0x81;	238	buf[0] = 0x81;
208	buf[1] = params->video_target_bitrate >> 8;	239	buf[1] = params->vi_bitrate.target >> 8;
209	buf[2] = params->video_target_bitrate & 0xff;	240	buf[2] = params->vi_bitrate.target & 0xff;
210	i2c_master_send(client, buf, 3);	241	i2c_master_send(client, buf, 3);
211	}	242	}
212		243
213	// set the audio bitrate	244	// set the audio bitrate
214	buf[0] = 0x94;	245	buf[0] = 0x94;
215	buf[1] = params->audio_bitrate;	246	buf[1] = (256 == params->au_bitrate.target) ? 0 : 1;
216	i2c_master_send(client, buf, 2);	247	i2c_master_send(client, buf, 2);
217		248
218	// set the total bitrate	249	// set the total bitrate
219	buf[0] = 0xb1;	250	buf[0] = 0xb1;
220	buf[1] = params->total_bitrate >> 8;	251	buf[1] = params->st_bitrate.target >> 8;
221	buf[2] = params->total_bitrate & 0xff;	252	buf[2] = params->st_bitrate.target & 0xff;
222	i2c_master_send(client, buf, 3);	253	i2c_master_send(client, buf, 3);
223		254
		255	// return success
224	return 0;	256	return 0;
225	}	257	}
226		258
227		259
228	static int saa6752hs_init(struct i2c_client* client, struct mpeg_params* params)	260	static void saa6752hs_set_params(struct i2c_client* client,
		261	struct v4l2_mpeg_compression* params)
229	{	262	{
230	unsigned char buf[3];	263	struct saa6752hs_state *h = i2c_get_clientdata(client);
231	void *data;
232		264
233	// check the bitrate parameters first	265	/* check PIDs */
234	if (params != NULL) {	266	if (params->ts_pid_pmt <= MPEG_PID_MAX)
235	if (params->bitrate_mode >= MPEG_BITRATE_MODE_MAX)	267	h->params.ts_pid_pmt = params->ts_pid_pmt;
236	return -EINVAL;	268	if (params->ts_pid_pcr <= MPEG_PID_MAX)
237	if (params->video_target_bitrate >= MPEG_VIDEO_TARGET_BITRATE_MAX)	269	h->params.ts_pid_pcr = params->ts_pid_pcr;
238	return -EINVAL;	270	if (params->ts_pid_video <= MPEG_PID_MAX)
239	if (params->video_max_bitrate >= MPEG_VIDEO_MAX_BITRATE_MAX)	271	h->params.ts_pid_video = params->ts_pid_video;
240	return -EINVAL;	272	if (params->ts_pid_audio <= MPEG_PID_MAX)
241	if (params->audio_bitrate >= MPEG_AUDIO_BITRATE_MAX)	273	h->params.ts_pid_audio = params->ts_pid_audio;
242	return -EINVAL;
243	if (params->total_bitrate >= MPEG_TOTAL_BITRATE_MAX)
244	return -EINVAL;
245	if (params->bitrate_mode == MPEG_BITRATE_MODE_MAX &&
246	params->video_target_bitrate <= params->video_max_bitrate)
247	return -EINVAL;
248	}
249		274
250	// Set GOP structure {3, 13}	275	/* check bitrate parameters */
		276	if ((params->vi_bitrate.mode == V4L2_BITRATE_CBR) \|\|
		277	(params->vi_bitrate.mode == V4L2_BITRATE_VBR))
		278	h->params.vi_bitrate.mode = params->vi_bitrate.mode;
		279	if (params->vi_bitrate.mode != V4L2_BITRATE_NONE)
		280	h->params.st_bitrate.target = params->st_bitrate.target;
		281	if (params->vi_bitrate.mode != V4L2_BITRATE_NONE)
		282	h->params.vi_bitrate.target = params->vi_bitrate.target;
		283	if (params->vi_bitrate.mode == V4L2_BITRATE_VBR)
		284	h->params.vi_bitrate.max = params->vi_bitrate.max;
		285	if (params->au_bitrate.mode != V4L2_BITRATE_NONE)
		286	h->params.au_bitrate.target = params->au_bitrate.target;
		287
		288	/* aspect ratio */
		289	if (params->vi_aspect_ratio == V4L2_MPEG_ASPECT_4_3 \|\|
		290	params->vi_aspect_ratio == V4L2_MPEG_ASPECT_16_9)
		291	h->params.vi_aspect_ratio = params->vi_aspect_ratio;
		292
		293	/* range checks */
		294	if (h->params.st_bitrate.target > MPEG_TOTAL_TARGET_BITRATE_MAX)
		295	h->params.st_bitrate.target = MPEG_TOTAL_TARGET_BITRATE_MAX;
		296	if (h->params.vi_bitrate.target > MPEG_VIDEO_TARGET_BITRATE_MAX)
		297	h->params.vi_bitrate.target = MPEG_VIDEO_TARGET_BITRATE_MAX;
		298	if (h->params.vi_bitrate.max > MPEG_VIDEO_MAX_BITRATE_MAX)
		299	h->params.vi_bitrate.max = MPEG_VIDEO_MAX_BITRATE_MAX;
		300	if (h->params.au_bitrate.target <= 256)
		301	h->params.au_bitrate.target = 256;
		302	else
		303	h->params.au_bitrate.target = 384;
		304	}
		305
		306	static int saa6752hs_init(struct i2c_client* client)
		307	{
		308	unsigned char buf[9], buf2[4];
		309	struct saa6752hs_state *h;
		310	u32 crc;
		311	unsigned char localPAT[256];
		312	unsigned char localPMT[256];
		313
		314	h = i2c_get_clientdata(client);
		315
		316	// Set video format - must be done first as it resets other settings
		317	buf[0] = 0x41;
		318	buf[1] = 0 /* MPEG_VIDEO_FORMAT_D1 */;
		319	i2c_master_send(client, buf, 2);
		320
		321	// set bitrate
		322	saa6752hs_set_bitrate(client, &h->params);
		323
		324	// Set GOP structure {3, 13}
251	buf[0] = 0x72;	325	buf[0] = 0x72;
252	buf[1] = 0x03;	326	buf[1] = 0x03;
253	buf[2] = 0x0D;	327	buf[2] = 0x0D;
Lines 265-271 static int saa6752hs_init(struct i2c_cli Link Here
265		339
266	// Set Output Protocol	340	// Set Output Protocol
267	buf[0] = 0xD0;	341	buf[0] = 0xD0;
268	buf[1] = 0x01;	342	buf[1] = 0x81;
269	i2c_master_send(client,buf,2);	343	i2c_master_send(client,buf,2);
270		344
271	// Set video output stream format {TS}	345	// Set video output stream format {TS}
Lines 273-297 static int saa6752hs_init(struct i2c_cli Link Here
273	buf[1] = 0x05;	347	buf[1] = 0x05;
274	i2c_master_send(client,buf,2);	348	i2c_master_send(client,buf,2);
275		349
276	// Set Audio PID {0x103}	350	/* compute PAT */
		351	memcpy(localPAT, PAT, sizeof(PAT));
		352	localPAT[17] = 0xe0 \| ((h->params.ts_pid_pmt >> 8) & 0x0f);
		353	localPAT[18] = h->params.ts_pid_pmt & 0xff;
		354	crc = crc32_be(~0, &localPAT[7], sizeof(PAT) - 7 - 4);
		355	localPAT[sizeof(PAT) - 4] = (crc >> 24) & 0xFF;
		356	localPAT[sizeof(PAT) - 3] = (crc >> 16) & 0xFF;
		357	localPAT[sizeof(PAT) - 2] = (crc >> 8) & 0xFF;
		358	localPAT[sizeof(PAT) - 1] = crc & 0xFF;
		359
		360	/* compute PMT */
		361	memcpy(localPMT, PMT, sizeof(PMT));
		362	localPMT[3] = 0x40 \| ((h->params.ts_pid_pmt >> 8) & 0x0f);
		363	localPMT[4] = h->params.ts_pid_pmt & 0xff;
		364	localPMT[15] = 0xE0 \| ((h->params.ts_pid_pcr >> 8) & 0x0F);
		365	localPMT[16] = h->params.ts_pid_pcr & 0xFF;
		366	localPMT[20] = 0xE0 \| ((h->params.ts_pid_video >> 8) & 0x0F);
		367	localPMT[21] = h->params.ts_pid_video & 0xFF;
		368	localPMT[25] = 0xE0 \| ((h->params.ts_pid_audio >> 8) & 0x0F);
		369	localPMT[26] = h->params.ts_pid_audio & 0xFF;
		370	crc = crc32_be(~0, &localPMT[7], sizeof(PMT) - 7 - 4);
		371	localPMT[sizeof(PMT) - 4] = (crc >> 24) & 0xFF;
		372	localPMT[sizeof(PMT) - 3] = (crc >> 16) & 0xFF;
		373	localPMT[sizeof(PMT) - 2] = (crc >> 8) & 0xFF;
		374	localPMT[sizeof(PMT) - 1] = crc & 0xFF;
		375
		376	// Set Audio PID
277	buf[0] = 0xC1;	377	buf[0] = 0xC1;
278	buf[1] = 0x01;	378	buf[1] = (h->params.ts_pid_audio >> 8) & 0xFF;
279	buf[2] = 0x03;	379	buf[2] = h->params.ts_pid_audio & 0xFF;
280	i2c_master_send(client,buf,3);	380	i2c_master_send(client,buf,3);
281		381
282	// setup bitrate settings	382	// Set Video PID
283	data = i2c_get_clientdata(client);	383	buf[0] = 0xC0;
284	if (params) {	384	buf[1] = (h->params.ts_pid_video >> 8) & 0xFF;
285	saa6752hs_set_bitrate(client, params);	385	buf[2] = h->params.ts_pid_video & 0xFF;
286	memcpy(data, params, sizeof(struct mpeg_params));	386	i2c_master_send(client,buf,3);
287	} else {	387
288	// parameters were not supplied. use the previous set	388	// Set PCR PID
289	saa6752hs_set_bitrate(client, (struct mpeg_params*) data);	389	buf[0] = 0xC4;
290	}	390	buf[1] = (h->params.ts_pid_pcr >> 8) & 0xFF;
		391	buf[2] = h->params.ts_pid_pcr & 0xFF;
		392	i2c_master_send(client,buf,3);
291		393
292	// Send SI tables	394	// Send SI tables
293	i2c_master_send(client,PAT,sizeof(PAT));	395	i2c_master_send(client,localPAT,sizeof(PAT));
294	i2c_master_send(client,PMT,sizeof(PMT));	396	i2c_master_send(client,localPMT,sizeof(PMT));
295		397
296	// mute then unmute audio. This removes buzzing artefacts	398	// mute then unmute audio. This removes buzzing artefacts
297	buf[0] = 0xa4;	399	buf[0] = 0xa4;
Lines 303-333 static int saa6752hs_init(struct i2c_cli Link Here
303	// start it going	405	// start it going
304	saa6752hs_chip_command(client, SAA6752HS_COMMAND_START);	406	saa6752hs_chip_command(client, SAA6752HS_COMMAND_START);
305		407
		408	// readout current state
		409	buf[0] = 0xE1;
		410	buf[1] = 0xA7;
		411	buf[2] = 0xFE;
		412	buf[3] = 0x82;
		413	buf[4] = 0xB0;
		414	i2c_master_send(client, buf, 5);
		415	i2c_master_recv(client, buf2, 4);
		416
		417	// change aspect ratio
		418	buf[0] = 0xE0;
		419	buf[1] = 0xA7;
		420	buf[2] = 0xFE;
		421	buf[3] = 0x82;
		422	buf[4] = 0xB0;
		423	buf[5] = buf2[0];
		424	switch(h->params.vi_aspect_ratio) {
		425	case V4L2_MPEG_ASPECT_16_9:
		426	buf[6] = buf2[1] \| 0x40;
		427	break;
		428	case V4L2_MPEG_ASPECT_4_3:
		429	default:
		430	buf[6] = buf2[1] & 0xBF;
		431	break;
		432	break;
		433	}
		434	buf[7] = buf2[2];
		435	buf[8] = buf2[3];
		436	i2c_master_send(client, buf, 9);
		437
		438	// return success
306	return 0;	439	return 0;
307	}	440	}
308		441
309	static int saa6752hs_attach(struct i2c_adapter *adap, int addr, int kind)	442	static int saa6752hs_attach(struct i2c_adapter *adap, int addr, int kind)
310	{	443	{
311	struct i2c_client *client;	444	struct saa6752hs_state *h;
312	struct mpeg_params* params;
313
314	client_template.adapter = adap;
315	client_template.addr = addr;
316		445
317	printk("saa6752hs: chip found @ 0x%x\n", addr<<1);	446	printk("saa6752hs: chip found @ 0x%x\n", addr<<1);
318		447
319	if (NULL == (client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL)))	448	if (NULL == (h = kmalloc(sizeof(*h), GFP_KERNEL)))
320	return -ENOMEM;	449	return -ENOMEM;
321	memcpy(client,&client_template,sizeof(struct i2c_client));	450	memset(h,0,sizeof(*h));
322	strlcpy(client->name, "saa6752hs", sizeof(client->name));	451	h->client = client_template;
323		452	h->params = param_defaults;
324	if (NULL == (params = kmalloc(sizeof(struct mpeg_params), GFP_KERNEL)))	453	h->client.adapter = adap;
325	return -ENOMEM;	454	h->client.addr = addr;
326	memcpy(params,&mpeg_params_template,sizeof(struct mpeg_params));
327	i2c_set_clientdata(client, params);
328
329	i2c_attach_client(client);
330		455
		456	i2c_set_clientdata(&h->client, h);
		457	i2c_attach_client(&h->client);
331	return 0;	458	return 0;
332	}	459	}
333		460
Lines 340-369 static int saa6752hs_probe(struct i2c_ad Link Here
340		467
341	static int saa6752hs_detach(struct i2c_client *client)	468	static int saa6752hs_detach(struct i2c_client *client)
342	{	469	{
343	void *data;	470	struct saa6752hs_state *h;
344		471
345	data = i2c_get_clientdata(client);	472	h = i2c_get_clientdata(client);
346	i2c_detach_client(client);	473	i2c_detach_client(client);
347	kfree(data);	474	kfree(h);
348	kfree(client);
349	return 0;	475	return 0;
350	}	476	}
351		477
352	static int	478	static int
353	saa6752hs_command(struct i2c_client client, unsigned int cmd, void arg)	479	saa6752hs_command(struct i2c_client client, unsigned int cmd, void arg)
354	{	480	{
355	struct mpeg_params* init_arg = arg;	481	struct saa6752hs_state *h = i2c_get_clientdata(client);
		482	struct v4l2_mpeg_compression *params = arg;
		483	int err = 0;
356		484
357	switch (cmd) {	485	switch (cmd) {
358	case MPEG_SETPARAMS:	486	case VIDIOC_S_MPEGCOMP:
359	return saa6752hs_init(client, init_arg);	487	if (NULL == params) {
360		488	/* apply settings and start encoder */
		489	saa6752hs_init(client);
		490	break;
		491	}
		492	saa6752hs_set_params(client, params);
		493	/* fall through */
		494	case VIDIOC_G_MPEGCOMP:
		495	*params = h->params;
		496	break;
361	default:	497	default:
362	/* nothing */	498	/* nothing */
363	break;	499	break;
364	}	500	}
365		501
366	return 0;	502	return err;
367	}	503	}
368		504
369	/* ----------------------------------------------------------------------- */	505	/* ----------------------------------------------------------------------- */
Lines 380-386 static struct i2c_driver driver = { Link Here
380		516
381	static struct i2c_client client_template =	517	static struct i2c_client client_template =
382	{	518	{
383	I2C_DEVNAME("(saa6752hs unset)"),	519	I2C_DEVNAME("saa6752hs"),
384	.flags = I2C_CLIENT_ALLOW_USE,	520	.flags = I2C_CLIENT_ALLOW_USE,
385	.driver = &driver,	521	.driver = &driver,
386	};	522	};





/*
 * $Id: saa7134-cards.c,v 1.54 2005/03/07 12:01:51 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * card-specific stuff.

			.gpio = 0x8000,
		},
	},
	[SAA7134_BOARD_FLYTVPLATINUM_MINI] = {
		/* "Arnaud Quette" <aquette@free.fr> */
		.name           = "LifeView FlyTV Platinum Mini",
		.audio_clock    = 0x00200000,
		.tuner_type     = TUNER_PHILIPS_TDA8290,
		.inputs         = {{
			.name = name_tv,
			.vmux = 1,

			.amux = LINE2,
		}},
	},
	[SAA7134_BOARD_FLYTVPLATINUM_FM] = {
		/* LifeView FlyTV Platinum FM (LR214WF) */
		/* "Peter Missel <peter.missel@onlinehome.de> */
		.name           = "LifeView FlyTV Platinum FM",
		.audio_clock    = 0x00200000,
		.tuner_type     = TUNER_PHILIPS_TDA8290,
//		.gpiomask       = 0xe000,
		.inputs         = {{
			.name = name_tv,
			.vmux = 1,
			.amux = TV,
//			.gpio = 0x0000,
			.tv   = 1,
                },{
/*			.name = name_tv_mono,
			.vmux = 1,
			.amux = LINE2,
			.gpio = 0x0000,
			.tv   = 1,
		},{
*/			.name = name_comp1,	/* Composite signal on S-Video input */
			.vmux = 0,
			.amux = LINE2,
//			.gpio = 0x4000,
		},{
			.name = name_comp2,	/* Composite input */
			.vmux = 3,
			.amux = LINE2,
//			.gpio = 0x4000,
		},{
			.name = name_svideo,	/* S-Video signal on S-Video input */
			.vmux = 8,
			.amux = LINE2,
//			.gpio = 0x4000,
		}},
/*		.radio = {
			.name = name_radio,
			.amux = LINE2,
			.gpio = 0x2000,
		},
*/	},
	[SAA7134_BOARD_EMPRESS] = {
		/* "Gert Vervoort" <gert.vervoort@philips.com> */
		.name		= "EMPRESS",

		.audio_clock    = 0x00187de7,
		.tuner_type     = TUNER_PHILIPS_FM1216ME_MK3,
		.tda9887_conf   = TDA9887_PRESENT,
		.mpeg           = SAA7134_MPEG_DVB,
		.inputs = {{
			.name   = name_tv,
			.vmux   = 1,

		},{
			.name   = name_comp1,
			.vmux   = 0,
			.amux   = LINE1,
		},{
			.name   = name_svideo,
			.vmux   = 8,
			.amux   = LINE1,
		}},
		.radio = {
			.name   = name_radio,

                        .amux = LINE1,
                },
	},
	[SAA7135_BOARD_ASUSTeK_TVFM7135] = {
                .name           = "ASUS TV-FM 7135",
                .audio_clock    = 0x00187de7,
                .tuner_type     = TUNER_PHILIPS_TDA8290,
		.gpiomask       = 0x200000,
                .inputs         = {{
                        .name = name_tv,
                        .vmux = 1,
                        .amux = TV,
			.gpio = 0x0000,
                        .tv   = 1,
                },{
                        .name = name_comp1,
                        .vmux = 4,
                        .amux = LINE2,
			.gpio = 0x0000,
                },{
                        .name = name_svideo,
                        .vmux = 6,
                        .amux = LINE2,
			.gpio = 0x0000,
                }},
                .radio = {
                        .name = name_radio,
                        .amux = TV,
			.gpio = 0x200000,
                },
	},
	[SAA7134_BOARD_VA1000POWER] = {
                .name           = "AOPEN VA1000 POWER",
		.audio_clock    = 0x00187de7,

		},{
			.name = name_tv,
			.vmux = 3,
			.amux = TV,
			.tv   = 1,
		}},
		.mpeg      = SAA7134_MPEG_EMPRESS,

			.name = name_radio,
			.amux = LINE2,
		},
		.mute = {
			.name = name_mute,
                        .amux = LINE1,
		},
	},
	[SAA7134_BOARD_MANLI_MTV001] = {
		/* Ognjen Nastic <ognjen@logosoft.ba> UNTESTED */

		.inputs         = {{
			.name = name_comp1,
			.vmux = 3,
		},{
			.name = name_svideo,
			.vmux = 8,
		}},
	},
        [SAA7134_BOARD_NOVAC_PRIMETV7133] = {

                        .vmux = 8,
                }},
        },
	[SAA7134_BOARD_AVERMEDIA_STUDIO_305] = {
		.name           = "AverMedia AverTV Studio 305",
		.audio_clock    = 0x00187de7,
		.tuner_type     = TUNER_PHILIPS_FM1256_IH3,
		.tda9887_conf   = TDA9887_PRESENT,
		.gpiomask = 0x3,
		.inputs         = {{
			.name = name_tv,
			.vmux = 1,

                        .name = name_svideo,
                        .vmux = 8,
                        .amux = LINE1,
			.gpio = 0x00080,
                },{
                        .name = name_comp1,
                        .vmux = 3,
                        .amux = LINE1,
			.gpio = 0x00080,
                },{
                        .name = name_tv,
                        .vmux = 1,
                        .amux = LINE2_LEFT,
                        .tv   = 1,
			.gpio = 0x00080,
                }},
		.radio = {
			.name = name_radio,
			.amux = LINE2,
			.gpio = 0x80000,
		 },
		.mute = {
			.name = name_mute,

		},
        },
        [SAA7134_BOARD_SABRENT_SBTTVFM] = {
		/* Michael Rodriguez-Torrent <mrtorrent@asu.edu> */
                .name           = "Sabrent SBT-TVFM (saa7130)",
                .audio_clock    = 0x00187de7,
                .tuner_type     = TUNER_PHILIPS_NTSC_M,
  		.tda9887_conf   = TDA9887_PRESENT,
                .inputs         = {{
			.name = name_comp1,
			.vmux = 1,
			.amux = LINE2,
		},{
                        .name = name_tv,
                        .vmux = 3,
                        .amux = LINE2,
                        .tv   = 1,
                },{
                        .name = name_comp1,
                        .vmux = 1,
                        .amux = LINE2,
                },{
                        .name = name_svideo,
                        .vmux = 8,
                        .amux = LINE2,

		 }
	},
        [SAA7134_BOARD_AVERMEDIA_307] = {
		/*
		Nickolay V. Shmyrev <nshmyrev@yandex.ru>
		Lots of thanks to Andrey Zolotarev <zolotarev_andrey@mail.ru>
		*/
		.name           = "Avermedia AVerTV Studio 307",
		.audio_clock    = 0x00187de7,
		.tuner_type     = TUNER_PHILIPS_FM1256_IH3,
		.tda9887_conf   = TDA9887_PRESENT,
		.gpiomask       = 0x03,
		.inputs         = {{
			.name = name_tv,
			.vmux = 1,
			.amux = TV,
			.tv   = 1,
			.gpio = 0x00,
		},{
			.name = name_comp1,
			.vmux = 0,
			.amux = LINE2,
			.gpio = 0x00,
		},{
			.name = name_comp2,
			.vmux = 3,
			.amux = LINE2,
			.gpio = 0x00,
		},{
			.name = name_svideo,
			.vmux = 8,
			.amux = LINE2,
			.gpio = 0x00,
		}},
		.radio = {
			.name = name_radio,
			.amux = LINE1,
			.gpio = 0x01,
		},
        },
	[SAA7134_BOARD_AVERMEDIA_CARDBUS] = {

	[SAA7134_BOARD_CINERGY400_CARDBUS] = {
		.name           = "Terratec Cinergy 400 mobile",
		.audio_clock    = 0x187de7,
		.tuner_type     = TUNER_ALPS_TSBE5_PAL,
  		.tda9887_conf   = TDA9887_PRESENT,
		.inputs         = {{
       			.name = name_tv,
			.vmux = 1,
			.amux = TV,
			.tv   = 1,
               },{
			.name = name_tv_mono,
			.vmux = 1,
			.amux = LINE2,
			.tv   = 1,
                },{
                        .name = name_comp1,

                        .amux = LINE1,
                },{
                        .name = name_svideo,
                        .vmux = 8,
                        .amux = LINE1,
		}},
	},
	[SAA7134_BOARD_CINERGY600_MK3] = {
                .name           = "Terratec Cinergy 600 TV MK3",
                .audio_clock    = 0x00200000,
		.tuner_type	= TUNER_PHILIPS_FM1216ME_MK3,
  		.tda9887_conf   = TDA9887_PRESENT,
                .inputs         = {{
                        .name = name_tv,
                        .vmux = 1,
                        .amux = TV,
                        .tv   = 1,
                },{
                        .name = name_comp1,
                        .vmux = 4,
                        .amux = LINE1,
                },{
                        .name = name_svideo,
                        .vmux = 8,
                        .amux = LINE1,
                },{
                        .name = name_comp2, // CVideo over SVideo Connector
                        .vmux = 0,
                        .amux = LINE1,
                }},
		.radio = {
			.name = name_radio,
			.amux = LINE2,
               },
        },
 	[SAA7134_BOARD_VIDEOMATE_GOLD_PLUS] = {
 		/* Dylan Walkden <dylan_walkden@hotmail.com> */
 		.name		= "Compro VideoMate Gold+ Pal",
 		.audio_clock	= 0x00187de7,
 		.tuner_type	= TUNER_PHILIPS_PAL,
 		.gpiomask	= 0x1ce780,
 		.inputs		= {{
 			.name = name_svideo,
 			.vmux = 0,		// CVideo over SVideo Connector - ok?
 			.amux = LINE1,
 			.gpio = 0x008080,
 		},{
 			.name = name_comp1,
 			.vmux = 3,
 			.amux = LINE1,
 			.gpio = 0x008080,
 		},{
 			.name = name_tv,
 			.vmux = 1,
 			.amux = TV,
 			.tv   = 1,
 			.gpio = 0x008080,
 		}},
 		.radio = {
 			.name = name_radio,
 			.amux = LINE2,
 			.gpio = 0x80000,
 		},
 		.mute = {
 			.name = name_mute,
 			.amux = LINE2,
 			.gpio = 0x0c8000,
 		},
 	},
	[SAA7134_BOARD_PINNACLE_300I_DVBT_PAL] = {
                .name           = "Pinnacle PCTV 300i DVB-T + PAL",
                .audio_clock    = 0x00187de7,
                .tuner_type     = TUNER_MT2032,
                .tda9887_conf   = TDA9887_PRESENT | TDA9887_INTERCARRIER,
		.mpeg           = SAA7134_MPEG_DVB,
                .inputs         = {{
                        .name = name_tv,
                        .vmux = 3,
                        .amux = TV,
                        .tv   = 1,
                },{
                        .name = name_comp1,
                        .vmux = 0,
                        .amux = LINE2,
                },{
                        .name = name_comp2,
                        .vmux = 1,
                        .amux = LINE2,
                },{
                        .name = name_svideo,
                        .vmux = 8,
                        .amux = LINE2,
                }},
        },
	[SAA7134_BOARD_PROVIDEO_PV952] = {
		/* andreas.kretschmer@web.de */
		.name		= "ProVideo PV952",
		.audio_clock	= 0x00187de7,
		.tuner_type	= TUNER_PHILIPS_FM1216ME_MK3,
		.tda9887_conf   = TDA9887_PRESENT,
		.inputs         = {{
			.name = name_comp1,
			.vmux = 0,
			.amux = LINE1,
		},{
			.name = name_tv,
			.vmux = 1,
			.amux = TV,
			.tv   = 1,
		},{
			.name = name_tv_mono,
			.vmux = 1,
			.amux = LINE2,
			.tv   = 1,
		}},
		.radio = {
			.name = name_radio,
			.amux = LINE2,
		},
	},
	[SAA7134_BOARD_AVERMEDIA_305] = {
		/* much like the "studio" version but without radio
		 * and another tuner (sirspiritus@yandex.ru) */
		.name           = "AverMedia AverTV/305",
		.audio_clock    = 0x00187de7,
		.tuner_type     = TUNER_PHILIPS_FQ1216ME,
		.tda9887_conf   = TDA9887_PRESENT,
		.gpiomask = 0x3,
		.inputs         = {{
			.name = name_tv,
			.vmux = 1,
			.amux = LINE2,
			.tv   = 1,
		},{
			.name = name_comp1,
			.vmux = 0,
			.amux = LINE2,
		},{
			.name = name_comp2,
			.vmux = 3,
			.amux = LINE2,
		},{
			.name = name_svideo,
			.vmux = 8,
			.amux = LINE2,
		}},
		.mute = {
			 .name = name_mute,
			 .amux = LINE1,
		},
	},
	[SAA7134_BOARD_FLYDVBTDUO] = {
		/* LifeView FlyDVB-T DUO */
		/* "Nico Sabbi <nsabbi@tiscali.it> */
		.name           = "LifeView FlyDVB-T DUO",
		.audio_clock    = 0x00200000,
		.tuner_type     = TUNER_PHILIPS_TDA8290,
//		.gpiomask       = 0xe000,
		.inputs         = {{
			.name = name_tv,
			.vmux = 1,
			.amux = TV,
//			.gpio = 0x0000,
			.tv   = 1,
                },{
			.name = name_comp1,	/* Composite signal on S-Video input */
			.vmux = 0,
			.amux = LINE2,
//			.gpio = 0x4000,
		},{
			.name = name_comp2,	/* Composite input */
			.vmux = 3,
			.amux = LINE2,
//			.gpio = 0x4000,
		},{
			.name = name_svideo,	/* S-Video signal on S-Video input */
			.vmux = 8,
			.amux = LINE2,
//			.gpio = 0x4000,
		}},
	},
};

                .subdevice    = 0x1143,
                .driver_data  = SAA7134_BOARD_CINERGY600,
        },{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
                .subvendor    = 0x153B,
                .subdevice    = 0x1158,
                .driver_data  = SAA7134_BOARD_CINERGY600_MK3,
        },{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
		.subvendor    = 0x153b,

		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7135,
		.subvendor    = 0x5168,
		.subdevice    = 0x0212, /* minipci, LR212 */
		.driver_data  = SAA7134_BOARD_FLYTVPLATINUM_MINI,
        },{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
		.subvendor    = 0x5168,
		.subdevice    = 0x0214, /* Standard PCI, LR214WF */
		.driver_data  = SAA7134_BOARD_FLYTVPLATINUM_FM,
        },{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7134,

                .driver_data  = SAA7134_BOARD_ASUSTeK_TVFM7134,
	},{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
                .subvendor    = PCI_VENDOR_ID_ASUSTEK,
                .subdevice    = 0x4845,
                .driver_data  = SAA7135_BOARD_ASUSTeK_TVFM7135,
	},{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
                .subvendor    = PCI_VENDOR_ID_ASUSTEK,
                .subdevice    = 0x4830,

		.device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
                .subvendor    = 0x1461, /* Avermedia Technologies Inc */
                .subdevice    = 0x2115,
		.driver_data  = SAA7134_BOARD_AVERMEDIA_STUDIO_305,
	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
                .subvendor    = 0x1461, /* Avermedia Technologies Inc */
                .subdevice    = 0x2108,
		.driver_data  = SAA7134_BOARD_AVERMEDIA_305,
	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,

                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
                .subvendor    = 0x11bd,
                .subdevice    = 0x002d,
                .driver_data  = SAA7134_BOARD_PINNACLE_300I_DVBT_PAL,
        },{
                .vendor       = PCI_VENDOR_ID_PHILIPS,
                .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,

		.subvendor    = 0x153B,
		.subdevice    = 0x1152,
		.driver_data  = SAA7134_BOARD_CINERGY200,

 	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
                .subvendor    = 0x185b,
                .subdevice    = 0xc100,
		.driver_data  = SAA7134_BOARD_VIDEOMATE_TV_PVR,

 	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
                .subvendor    = 0x1131,
                .subdevice    = 0,
		.driver_data  = SAA7134_BOARD_SABRENT_SBTTVFM,
	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
		.subvendor    = 0x1461, /* Avermedia Technologies Inc */
		.subdevice    = 0x9715,
		.driver_data  = SAA7134_BOARD_AVERMEDIA_307,
	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
		.subvendor    = 0x185b,
		.subdevice    = 0xc200,
		.driver_data  = SAA7134_BOARD_VIDEOMATE_GOLD_PLUS,
        },{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
		.subvendor    = 0x1540,
		.subdevice    = 0x9524,
		.driver_data  = SAA7134_BOARD_PROVIDEO_PV952,

 	},{
		.vendor       = PCI_VENDOR_ID_PHILIPS,
		.device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
		.subvendor    = 0x5168,
		.subdevice    = 0x0306,
		.driver_data  = SAA7134_BOARD_FLYDVBTDUO,

 	},{
		/* --- boards without eeprom + subsystem ID --- */

	case SAA7134_BOARD_FLYVIDEO2000:
	case SAA7134_BOARD_FLYVIDEO3000:
		dev->has_remote = 1;
		/* fall throuth */
	case SAA7134_BOARD_FLYTVPLATINUM:
		board_flyvideo(dev);
		break;
	case SAA7134_BOARD_CINERGY400:
	case SAA7134_BOARD_CINERGY600:
	case SAA7134_BOARD_CINERGY600_MK3:
	case SAA7134_BOARD_ECS_TVP3XP:
	case SAA7134_BOARD_ECS_TVP3XP_4CB5:
	case SAA7134_BOARD_MD2819:
	case SAA7134_BOARD_AVERMEDIA_STUDIO_305:
	case SAA7134_BOARD_AVERMEDIA_305:
	case SAA7134_BOARD_AVERMEDIA_307:
//	case SAA7134_BOARD_SABRENT_SBTTVFM:  /* not finished yet */
	case SAA7134_BOARD_VIDEOMATE_TV_PVR:
		dev->has_remote = 1;
		break;
	case SAA7134_BOARD_AVACSSMARTTV:

		/* power-up tuner chip */
		saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x00040000, 0x00040000);
		saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00040000, 0x00000000);
		msleep(1);
		break;
	}
	if (dev->has_remote)
		dev->irq2_mask |= (SAA7134_IRQ2_INTE_GPIO18  |
				   SAA7134_IRQ2_INTE_GPIO18A |
				   SAA7134_IRQ2_INTE_GPIO16  );
	return 0;
}


			: SAA7134_BOARD_BMK_MPEX_TUNER;
		if (board == dev->board)
			break;
		dev->board = board;
		printk("%s: board type fixup: %s\n", dev->name,
		       saa7134_boards[dev->board].name);
		dev->tuner_type = saa7134_boards[dev->board].tuner_type;




/*
 * $Id: saa7134-core.c,v 1.28 2005/02/22 09:56:29 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * driver core

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/kmod.h>

static DECLARE_MUTEX(devlist_lock);
LIST_HEAD(saa7134_devlist);
static LIST_HEAD(mops_list);
static unsigned int saa7134_devcount;

#define dprintk(fmt, arg...)	if (core_debug) \
	printk(KERN_DEBUG "%s/core: " fmt, dev->name , ## arg)

			dump_statusregs(dev);
#endif

		if (report & SAA7134_IRQ_REPORT_RDCAP /* _INTL */)
			saa7134_irq_video_intl(dev);

		if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&

			       SAA7134_IRQ_REPORT_GPIO18)) &&
		    dev->remote)
			saa7134_input_irq(dev);
	}

	};
	if (10 == loop) {
		print_irqstatus(dev,loop,report,status);
		if (report & SAA7134_IRQ_REPORT_PE) {

			printk(KERN_WARNING "%s/irq: looping -- "
			       "clearing PE (parity error!) enable bit\n",dev->name);
			saa_clearl(SAA7134_IRQ2,SAA7134_IRQ2_INTE_PE);
		} else if (report & (SAA7134_IRQ_REPORT_GPIO16 |
				     SAA7134_IRQ_REPORT_GPIO18)) {
			/* disable gpio IRQs */
			printk(KERN_WARNING "%s/irq: looping -- "
			       "clearing GPIO enable bits\n",dev->name);
			saa_clearl(SAA7134_IRQ2, (SAA7134_IRQ2_INTE_GPIO16 |
						  SAA7134_IRQ2_INTE_GPIO18));
		} else {
			/* disable all irqs */
			printk(KERN_WARNING "%s/irq: looping -- "


	/* enable IRQ's */
	saa_writel(SAA7134_IRQ1, 0);
	saa_writel(SAA7134_IRQ2, dev->irq2_mask);
		   SAA7134_IRQ2_INTE_GPIO18  |
		   SAA7134_IRQ2_INTE_GPIO18A |
		   SAA7134_IRQ2_INTE_GPIO16  |
		   SAA7134_IRQ2_INTE_SC2     |
		   SAA7134_IRQ2_INTE_SC1     |
		   SAA7134_IRQ2_INTE_SC0     |
		   /* SAA7134_IRQ2_INTE_DEC5    |  FIXME: TRIG_ERR ??? */
		   SAA7134_IRQ2_INTE_DEC3    |
		   SAA7134_IRQ2_INTE_DEC2    |
		   /* SAA7134_IRQ2_INTE_DEC1    | */
		   SAA7134_IRQ2_INTE_DEC0    |
		   SAA7134_IRQ2_INTE_PE      |
		   SAA7134_IRQ2_INTE_AR);

	return 0;
}

	}

	/* initialize hardware #1 */
   	dev->irq2_mask =
		SAA7134_IRQ2_INTE_DEC3    |
		SAA7134_IRQ2_INTE_DEC2    |
		SAA7134_IRQ2_INTE_DEC1    |
		SAA7134_IRQ2_INTE_DEC0    |
		SAA7134_IRQ2_INTE_PE      |
		SAA7134_IRQ2_INTE_AR;
	saa7134_board_init1(dev);
	saa7134_hwinit1(dev);


	}
	list_add_tail(&dev->devlist,&saa7134_devlist);
	up(&devlist_lock);

	/* check for signal */
	saa7134_irq_video_intl(dev);
	return 0;

 fail5:


static void saa7134_fini(void)
{
	if (pending_registered)
		unregister_module_notifier(&pending_notifier);
	pci_unregister_driver(&saa7134_pci_driver);
}


Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-dvb.c (-8 / +183 lines)
1	/*	1	/*
2	* $Id: saa7134-dvb.c,v 1.4 2004/11/07 14:44:59 kraxel Exp $	2	* $Id: saa7134-dvb.c,v 1.12 2005/02/18 12:28:29 kraxel Exp $
3	*	3	*
4	* (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]	4	* (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
5	*	5	*
Lines 30-64 Link Here
30	#include "saa7134-reg.h"	30	#include "saa7134-reg.h"
31	#include "saa7134.h"	31	#include "saa7134.h"
32		32
		33	#include "dvb-pll.h"
		34	#include "mt352.h"
		35	#include "mt352_priv.h" /* FIXME */
		36	#include "tda1004x.h"
		37
33	MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");	38	MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
34	MODULE_LICENSE("GPL");	39	MODULE_LICENSE("GPL");
35		40
		41	static unsigned int antenna_pwr = 0;
		42	module_param(antenna_pwr, int, 0444);
		43	MODULE_PARM_DESC(antenna_pwr,"enable antenna power (Pinnacle 300i)");
		44
36	/* ------------------------------------------------------------------ */	45	/* ------------------------------------------------------------------ */
37		46
38	static int dvb_init(struct saa7134_dev *dev)	47	static int pinnacle_antenna_pwr(struct saa7134_dev *dev, int on)
39	{	48	{
40	printk("%s: %s\n",dev->name,__FUNCTION__);	49	u32 ok;
		50
		51	if (!on) {
		52	saa_setl(SAA7134_GPIO_GPMODE0 >> 2, (1 << 26));
		53	saa_clearl(SAA7134_GPIO_GPSTATUS0 >> 2, (1 << 26));
		54	return 0;
		55	}
		56
		57	saa_setl(SAA7134_GPIO_GPMODE0 >> 2, (1 << 26));
		58	saa_setl(SAA7134_GPIO_GPSTATUS0 >> 2, (1 << 26));
		59	udelay(10);
		60
		61	saa_setl(SAA7134_GPIO_GPMODE0 >> 2, (1 << 28));
		62	saa_clearl(SAA7134_GPIO_GPSTATUS0 >> 2, (1 << 28));
		63	udelay(10);
		64	saa_setl(SAA7134_GPIO_GPSTATUS0 >> 2, (1 << 28));
		65	udelay(10);
		66	ok = saa_readl(SAA7134_GPIO_GPSTATUS0) & (1 << 27);
		67	printk("%s: %s %s\n", dev->name, __FUNCTION__,
		68	ok ? "on" : "off");
		69
		70	if (!ok)
		71	saa_clearl(SAA7134_GPIO_GPSTATUS0 >> 2, (1 << 26));
		72	return ok;
		73	}
		74
		75	static int mt352_pinnacle_init(struct dvb_frontend* fe)
		76	{
		77	static u8 clock_config [] = { CLOCK_CTL, 0x3d, 0x28 };
		78	static u8 reset [] = { RESET, 0x80 };
		79	static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
		80	static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0xa0 };
		81	static u8 capt_range_cfg[] = { CAPT_RANGE, 0x31 };
		82	static u8 fsm_ctl_cfg[] = { 0x7b, 0x04 };
		83	static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x0f };
		84	static u8 scan_ctl_cfg [] = { SCAN_CTL, 0x0d };
		85	static u8 irq_cfg [] = { INTERRUPT_EN_0, 0x00, 0x00, 0x00, 0x00 };
		86	struct saa7134_dev *dev= fe->dvb->priv;
		87
		88	printk("%s: %s called\n",dev->name,__FUNCTION__);
		89
		90	mt352_write(fe, clock_config, sizeof(clock_config));
		91	udelay(200);
		92	mt352_write(fe, reset, sizeof(reset));
		93	mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
		94	mt352_write(fe, agc_cfg, sizeof(agc_cfg));
		95	mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
		96	mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
		97
		98	mt352_write(fe, fsm_ctl_cfg, sizeof(fsm_ctl_cfg));
		99	mt352_write(fe, scan_ctl_cfg, sizeof(scan_ctl_cfg));
		100	mt352_write(fe, irq_cfg, sizeof(irq_cfg));
		101	return 0;
		102	}
		103
		104	static int mt352_pinnacle_pll_set(struct dvb_frontend* fe,
		105	struct dvb_frontend_parameters* params,
		106	u8* pllbuf)
		107	{
		108	static int on = TDA9887_PRESENT \| TDA9887_PORT2_INACTIVE;
		109	static int off = TDA9887_PRESENT \| TDA9887_PORT2_ACTIVE;
		110	struct saa7134_dev *dev = fe->dvb->priv;
		111	struct v4l2_frequency f;
		112
		113	/* set frequency (mt2050) */
114	f.tuner = 0;
115	f.type = V4L2_TUNER_DIGITAL_TV;
116	f.frequency = params->frequency / 1000 * 16 / 1000;
117	saa7134_i2c_call_clients(dev,TDA9887_SET_CONFIG,&on);
118	saa7134_i2c_call_clients(dev,VIDIOC_S_FREQUENCY,&f);
119	saa7134_i2c_call_clients(dev,TDA9887_SET_CONFIG,&off);
120
121	pinnacle_antenna_pwr(dev, antenna_pwr);
41		122
		123	/* mt352 setup */
		124	mt352_pinnacle_init(fe);
		125	pllbuf[0] = 0xc2;
		126	pllbuf[1] = 0x00;
		127	pllbuf[2] = 0x00;
		128	pllbuf[3] = 0x80;
		129	pllbuf[4] = 0x00;
		130	return 0;
		131	}
		132
		133	static struct mt352_config pinnacle_300i = {
		134	.demod_address = 0x3c >> 1,
		135	.adc_clock = 20333,
		136	.if2 = 36150,
		137	.no_tuner = 1,
		138	.demod_init = mt352_pinnacle_init,
		139	.pll_set = mt352_pinnacle_pll_set,
		140	};
		141
		142	/* ------------------------------------------------------------------ */
		143
		144	static int medion_cardbus_init(struct dvb_frontend* fe)
		145	{
		146	/* anything to do here ??? */
		147	return 0;
		148	}
		149
		150	static int medion_cardbus_pll_set(struct dvb_frontend* fe,
		151	struct dvb_frontend_parameters* params)
		152	{
		153	struct saa7134_dev *dev = fe->dvb->priv;
		154	struct v4l2_frequency f;
		155
		156	/*
		157	* this instructs tuner.o to set the frequency, the call will
		158	* end up in tuner_command(), VIDIOC_S_FREQUENCY switch.
		159	* tda9887.o will see that as well.
		160	*/
		161	f.tuner = 0;
		162	f.type = V4L2_TUNER_DIGITAL_TV;
		163	f.frequency = params->frequency / 1000 * 16 / 1000;
		164	saa7134_i2c_call_clients(dev,VIDIOC_S_FREQUENCY,&f);
		165	return 0;
		166	}
		167
		168	static int fe_request_firmware(struct dvb_frontend* fe,
		169	const struct firmware *fw, char name)
		170	{
		171	struct saa7134_dev *dev = fe->dvb->priv;
		172	return request_firmware(fw, name, &dev->pci->dev);
		173	}
		174
		175	struct tda1004x_config medion_cardbus = {
		176	.demod_address = 0x08, /* not sure this is correct */
		177	.invert = 0,
		178	.invert_oclk = 0,
		179	.pll_init = medion_cardbus_init,
		180	.pll_set = medion_cardbus_pll_set,
		181	.request_firmware = fe_request_firmware,
		182	};
		183
		184	/* ------------------------------------------------------------------ */
		185
		186	static int dvb_init(struct saa7134_dev *dev)
187	{
42	/* init struct videobuf_dvb */	188	/* init struct videobuf_dvb */
		189	dev->ts.nr_bufs = 32;
		190	dev->ts.nr_packets = 32*4;
43	dev->dvb.name = dev->name;	191	dev->dvb.name = dev->name;
44	videobuf_queue_init(&dev->dvb.dvbq, &saa7134_ts_qops,	192	videobuf_queue_init(&dev->dvb.dvbq, &saa7134_ts_qops,
45	dev->pci, &dev->slock,	193	dev->pci, &dev->slock,
46	V4L2_BUF_TYPE_VIDEO_CAPTURE,	194	V4L2_BUF_TYPE_VIDEO_CAPTURE,
47	V4L2_FIELD_TOP,	195	V4L2_FIELD_ALTERNATE,
48	sizeof(struct saa7134_buf),	196	sizeof(struct saa7134_buf),
49	dev);	197	dev);
50		198
51	/* TODO: init frontend */	199	switch (dev->board) {
52	if (NULL == dev->dvb.frontend)	200	case SAA7134_BOARD_PINNACLE_300I_DVBT_PAL:
		201	printk("%s: pinnacle 300i dvb setup\n",dev->name);
		202	dev->dvb.frontend = mt352_attach(&pinnacle_300i,
		203	&dev->i2c_adap);
		204	break;
		205	case SAA7134_BOARD_MD7134:
		206	dev->dvb.frontend = tda10046_attach(&medion_cardbus,
		207	&dev->i2c_adap);
		208	if (NULL == dev->dvb.frontend)
		209	printk("%s: Hmm, looks like this is the old MD7134 "
		210	"version without DVB-T support\n",dev->name);
		211	break;
		212	default:
		213	printk("%s: Huh? unknown DVB card?\n",dev->name);
		214	break;
		215	}
		216
		217	if (NULL == dev->dvb.frontend) {
		218	printk("%s: frontend initialization failed\n",dev->name);
53	return -1;	219	return -1;
		220	}
54		221
55	/* register everything else */	222	/* register everything else */
56	return videobuf_dvb_register(&dev->dvb);	223	return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev);
57	}	224	}
58		225
59	static int dvb_fini(struct saa7134_dev *dev)	226	static int dvb_fini(struct saa7134_dev *dev)
60	{	227	{
		228	static int on = TDA9887_PRESENT \| TDA9887_PORT2_INACTIVE;
		229
61	printk("%s: %s\n",dev->name,__FUNCTION__);	230	printk("%s: %s\n",dev->name,__FUNCTION__);
		231
		232	switch (dev->board) {
		233	case SAA7134_BOARD_PINNACLE_300I_DVBT_PAL:
		234	/* otherwise we don't detect the tuner on next insmod */
		235	saa7134_i2c_call_clients(dev,TDA9887_SET_CONFIG,&on);
		236	break;
		237	};
62	videobuf_dvb_unregister(&dev->dvb);	238	videobuf_dvb_unregister(&dev->dvb);
63	return 0;	239	return 0;
64	}	240	}
Lines 86-91 module_exit(dvb_unregister); Link Here
86	/*	262	/*
87	* Local variables:	263	* Local variables:
88	* c-basic-offset: 8	264	* c-basic-offset: 8
89	* compile-command: "make DVB=1"
90	* End:	265	* End:
91	*/	266	*/

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-empress.c (-9 / +51 lines)
1	/*	1	/*
2	* $Id: saa7134-empress.c,v 1.3 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-empress.c,v 1.10 2005/02/03 10:24:33 kraxel Exp $
3	*	3	*
4	* (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]	4	* (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
5	*	5	*
Lines 21-26 Link Here
21	#include <linux/init.h>	21	#include <linux/init.h>
22	#include <linux/list.h>	22	#include <linux/list.h>
23	#include <linux/module.h>	23	#include <linux/module.h>
		24	#include <linux/moduleparam.h>
24	#include <linux/kernel.h>	25	#include <linux/kernel.h>
25	#include <linux/slab.h>	26	#include <linux/slab.h>
26	#include <linux/delay.h>	27	#include <linux/delay.h>
Lines 50-65 MODULE_PARM_DESC(debug,"enable debug mes Link Here
50		51
51	static void ts_reset_encoder(struct saa7134_dev* dev)	52	static void ts_reset_encoder(struct saa7134_dev* dev)
52	{	53	{
		54	if (!dev->empress_started)
		55	return;
		56
53	saa_writeb(SAA7134_SPECIAL_MODE, 0x00);	57	saa_writeb(SAA7134_SPECIAL_MODE, 0x00);
54	msleep(10);	58	msleep(10);
55	saa_writeb(SAA7134_SPECIAL_MODE, 0x01);	59	saa_writeb(SAA7134_SPECIAL_MODE, 0x01);
56	msleep(100);	60	msleep(100);
		61	dev->empress_started = 0;
57	}	62	}
58		63
59	static int ts_init_encoder(struct saa7134_dev* dev, void* arg)	64	static int ts_init_encoder(struct saa7134_dev* dev)
60	{	65	{
61	ts_reset_encoder(dev);	66	ts_reset_encoder(dev);
62	saa7134_i2c_call_clients(dev, MPEG_SETPARAMS, arg);	67	saa7134_i2c_call_clients(dev, VIDIOC_S_MPEGCOMP, NULL);
		68	dev->empress_started = 1;
63	return 0;	69	return 0;
64	}	70	}
65		71
Lines 81-98 static int ts_open(struct inode *inode, Link Here
81	return -ENODEV;	87	return -ENODEV;
82		88
83	dprintk("open minor=%d\n",minor);	89	dprintk("open minor=%d\n",minor);
84	down(&dev->empress_tsq.lock);
85	err = -EBUSY;	90	err = -EBUSY;
86	if (dev->empress_users)	91	if (down_trylock(&dev->empress_tsq.lock))
87	goto done;	92	goto done;
		93	if (dev->empress_users)
		94	goto done_up;
88		95
89	dev->empress_users++;	96	dev->empress_users++;
90	file->private_data = dev;	97	file->private_data = dev;
91	ts_init_encoder(dev, NULL);
92	err = 0;	98	err = 0;
93		99
94	done:	100	done_up:
95	up(&dev->empress_tsq.lock);	101	up(&dev->empress_tsq.lock);
		102	done:
96	return err;	103	return err;
97	}	104	}
98		105
Lines 105-110 static int ts_release(struct inode *inod Link Here
105	down(&dev->empress_tsq.lock);	112	down(&dev->empress_tsq.lock);
106	if (dev->empress_tsq.reading)	113	if (dev->empress_tsq.reading)
107	videobuf_read_stop(&dev->empress_tsq);	114	videobuf_read_stop(&dev->empress_tsq);
		115	videobuf_mmap_free(&dev->empress_tsq);
108	dev->empress_users--;	116	dev->empress_users--;
109		117
110	/* stop the encoder */	118	/* stop the encoder */
Lines 119-124 ts_read(struct file file, char __user Link Here
119	{	127	{
120	struct saa7134_dev *dev = file->private_data;	128	struct saa7134_dev *dev = file->private_data;
121		129
		130	if (!dev->empress_started)
		131	ts_init_encoder(dev);
		132
122	return videobuf_read_stream(&dev->empress_tsq,	133	return videobuf_read_stream(&dev->empress_tsq,
123	data, count, ppos, 0,	134	data, count, ppos, 0,
124	file->f_flags & O_NONBLOCK);	135	file->f_flags & O_NONBLOCK);
Lines 281-288 static int ts_do_ioctl(struct inode *ino Link Here
281	case VIDIOC_S_CTRL:	292	case VIDIOC_S_CTRL:
282	return saa7134_common_ioctl(dev, cmd, arg);	293	return saa7134_common_ioctl(dev, cmd, arg);
283		294
284	case MPEG_SETPARAMS:	295	case VIDIOC_S_MPEGCOMP:
285	return ts_init_encoder(dev, arg);	296	saa7134_i2c_call_clients(dev, VIDIOC_S_MPEGCOMP, arg);
		297	ts_init_encoder(dev);
		298	return 0;
		299	case VIDIOC_G_MPEGCOMP:
		300	saa7134_i2c_call_clients(dev, VIDIOC_G_MPEGCOMP, arg);
		301	return 0;
286		302
287	default:	303	default:
288	return -ENOIOCTLCMD;	304	return -ENOIOCTLCMD;
Lines 320-325 static struct video_device saa7134_empre Link Here
320	.minor = -1,	336	.minor = -1,
321	};	337	};
322		338
		339	static void empress_signal_update(void* data)
		340	{
		341	struct saa7134_dev* dev = (struct saa7134_dev*) data;
		342
		343	if (dev->nosignal) {
		344	dprintk("no video signal\n");
		345	ts_reset_encoder(dev);
		346	} else {
		347	dprintk("video signal acquired\n");
		348	if (dev->empress_users)
		349	ts_init_encoder(dev);
		350	}
		351	}
		352
		353	static void empress_signal_change(struct saa7134_dev *dev)
		354	{
		355	schedule_work(&dev->empress_workqueue);
		356	}
		357
		358
323	static int empress_init(struct saa7134_dev *dev)	359	static int empress_init(struct saa7134_dev *dev)
324	{	360	{
325	int err;	361	int err;
Lines 335-340 static int empress_init(struct saa7134_d Link Here
335	"%s empress (%s)", dev->name,	371	"%s empress (%s)", dev->name,
336	saa7134_boards[dev->board].name);	372	saa7134_boards[dev->board].name);
337		373
		374	INIT_WORK(&dev->empress_workqueue, empress_signal_update, (void*) dev);
		375
338	err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER,	376	err = video_register_device(dev->empress_dev,VFL_TYPE_GRABBER,
339	empress_nr[dev->nr]);	377	empress_nr[dev->nr]);
340	if (err < 0) {	378	if (err < 0) {
Lines 353-358 static int empress_init(struct saa7134_d Link Here
353	V4L2_FIELD_ALTERNATE,	391	V4L2_FIELD_ALTERNATE,
354	sizeof(struct saa7134_buf),	392	sizeof(struct saa7134_buf),
355	dev);	393	dev);
		394
		395	empress_signal_update(dev);
356	return 0;	396	return 0;
357	}	397	}
358		398
Lines 362-367 static int empress_fini(struct saa7134_d Link Here
362		402
363	if (NULL == dev->empress_dev)	403	if (NULL == dev->empress_dev)
364	return 0;	404	return 0;
		405	flush_scheduled_work();
365	video_unregister_device(dev->empress_dev);	406	video_unregister_device(dev->empress_dev);
366	dev->empress_dev = NULL;	407	dev->empress_dev = NULL;
367	return 0;	408	return 0;
Lines 371-376 static struct saa7134_mpeg_ops empress_o Link Here
371	.type = SAA7134_MPEG_EMPRESS,	412	.type = SAA7134_MPEG_EMPRESS,
372	.init = empress_init,	413	.init = empress_init,
373	.fini = empress_fini,	414	.fini = empress_fini,
		415	.signal_change = empress_signal_change,
374	};	416	};
375		417
376	static int __init empress_register(void)	418	static int __init empress_register(void)




/*
 * $Id: saa7134-i2c.c,v 1.10 2005/01/24 17:37:23 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * i2c interface support

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/delay.h>

	dword &= 0x0f;
	dword |= (attr << 6);
	dword |= ((__u32)data << 8);
	dword |= 0x00 << 16;  /* 100 kHz */
//	dword |= 0x40 << 16;  /* 400 kHz */
	dword |= 0xf0 << 24;
	saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword);
#endif

		if (!i2c_reset(dev))
			return -EIO;

	d2printk("start xfer\n");
	d1printk(KERN_DEBUG "%s: i2c xfer:",dev->name);
	for (i = 0; i < num; i++) {
		if (!(msgs[i].flags & I2C_M_NOSTART) || 0 == i) {
			/* send address */
			d2printk("send address\n");
			addr  = msgs[i].addr << 1;
			if (msgs[i].flags & I2C_M_RD)
				addr |= 1;
			if (i > 0 && msgs[i].flags & I2C_M_RD) {
				/* workaround for a saa7134 i2c bug
				 * needed to talk to the mt352 demux
				 * thanks to pinnacle for the hint */
				int quirk = 0xfd;
				d1printk(" [%02x quirk]",quirk);
				i2c_send_byte(dev,START,quirk);
				i2c_recv_byte(dev);
			}
			d1printk(" < %02x", addr);
			rc = i2c_send_byte(dev,START,addr);
			if (rc < 0)

		}
		if (msgs[i].flags & I2C_M_RD) {
			/* read bytes */
			d2printk("read bytes\n");
			for (byte = 0; byte < msgs[i].len; byte++) {
				d1printk(" =");
				rc = i2c_recv_byte(dev);

			}
		} else {
			/* write bytes */
			d2printk("write bytes\n");
			for (byte = 0; byte < msgs[i].len; byte++) {
				data = msgs[i].buf[byte];
				d1printk(" %02x", data);

			}
		}
	}
	d2printk("xfer done\n");
	d1printk(" >");
	i2c_set_attr(dev,STOP);
	rc = -EIO;

	return I2C_FUNC_SMBUS_EMUL;
}

#ifndef I2C_PEC
static void inc_use(struct i2c_adapter *adap)
{
	MOD_INC_USE_COUNT;
}

static void dec_use(struct i2c_adapter *adap)
{
	MOD_DEC_USE_COUNT;
}
#endif

static int attach_inform(struct i2c_client *client)
{
        struct saa7134_dev *dev = client->adapter->algo_data;

};

static struct i2c_adapter saa7134_adap_template = {
#ifdef I2C_PEC
	.owner         = THIS_MODULE,
#else
	.inc_use       = inc_use,
	.dec_use       = dec_use,
#endif
#ifdef I2C_CLASS_TV_ANALOG
	.class         = I2C_CLASS_TV_ANALOG,
#endif




/*
 * $Id: saa7134-input.c,v 1.16 2004/12/10 12:33:39 kraxel Exp $
 *
 * handle saa7134 IR remotes via linux kernel input layer.
 *

 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/sched.h>

	[ 17 ] = KEY_CHANNELDOWN,	// CHANNEL/PAGE-
	[ 49 ] = KEY_CHANNELUP		// CHANNEL/PAGE+
};

static IR_KEYTAB_TYPE videomate_tv_pvr_codes[IR_KEYTAB_SIZE] = {
	[ 20 ] = KEY_MUTE,
	[ 36 ] = KEY_ZOOM,

	[  1 ] = KEY_DVD,
	[ 35 ] = KEY_RADIO,
	[  0 ] = KEY_TV,

	[ 10 ] = KEY_REWIND,
	[  8 ] = KEY_PLAYPAUSE,
	[ 15 ] = KEY_FORWARD,

	[  2 ] = KEY_PREVIOUS,
	[  7 ] = KEY_STOP,
	[  6 ] = KEY_NEXT,

	[ 12 ] = KEY_UP,
	[ 14 ] = KEY_DOWN,
	[ 11 ] = KEY_LEFT,
	[ 13 ] = KEY_RIGHT,
	[ 17 ] = KEY_OK,

	[  3 ] = KEY_MENU,
	[  9 ] = KEY_SETUP,
	[  5 ] = KEY_VIDEO,
	[ 34 ] = KEY_CHANNEL,

	[ 18 ] = KEY_VOLUMEUP,
	[ 21 ] = KEY_VOLUMEDOWN,
	[ 16 ] = KEY_CHANNELUP,
	[ 19 ] = KEY_CHANNELDOWN,

	[  4 ] = KEY_RECORD,

	[ 22 ] = KEY_KP1,
	[ 23 ] = KEY_KP2,
	[ 24 ] = KEY_KP3,
	[ 25 ] = KEY_KP4,
	[ 26 ] = KEY_KP5,
	[ 27 ] = KEY_KP6,
	[ 28 ] = KEY_KP7,
	[ 29 ] = KEY_KP8,
	[ 30 ] = KEY_KP9,
	[ 31 ] = KEY_KP0,

	[ 32 ] = KEY_LANGUAGE,
	[ 33 ] = KEY_SLEEP,
};
/* ---------------------------------------------------------------------- */

static int build_key(struct saa7134_dev *dev)

		break;
	case SAA7134_BOARD_CINERGY400:
	case SAA7134_BOARD_CINERGY600:
	case SAA7134_BOARD_CINERGY600_MK3:
		ir_codes     = cinergy_codes;
		mask_keycode = 0x00003f;
		mask_keyup   = 0x040000;

		polling      = 50; // ms
		break;
	case SAA7134_BOARD_MD2819:
	case SAA7134_BOARD_AVERMEDIA_305:
	case SAA7134_BOARD_AVERMEDIA_307:
		ir_codes     = md2819_codes;
		mask_keycode = 0x0007C8;

		saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
		saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
		break;
	case SAA7134_BOARD_VIDEOMATE_TV_PVR:
		ir_codes     = videomate_tv_pvr_codes;
		mask_keycode = 0x00003F;
		mask_keyup   = 0x400000;
		polling      = 50; // ms
		break;
	}
	if (NULL == ir_codes) {
		printk("%s: Oops: IR config error [card=%d]\n",




/*
 * $Id: saa7134-oss.c,v 1.13 2004/12/10 12:33:39 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * oss dsp interface

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/soundcard.h>

		break;
	case LINE1:
	case LINE2:
	case LINE2_LEFT:
		analog_io = (LINE1 == dev->oss.input) ? 0x00 : 0x08;
		rate = (32000 == dev->oss.rate) ? 0x01 : 0x03;
		saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x08, analog_io);

		value = 0xbbbb32;  /* AUX1 */
		break;
	case LINE2:
	case LINE2_LEFT:
		value = 0xbbbb54;  /* AUX2 */
		break;
	}

				   (100 == level) ? 0x00 : 0x10);
			break;
		case LINE2:
		case LINE2_LEFT:
			saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x20,
				   (100 == level) ? 0x00 : 0x20);
			break;




/*
 * $Id: saa7134-ts.c,v 1.14 2005/02/03 10:24:33 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * video4linux video interface

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/delay.h>

	if (dev->ts_q.curr) {
		field = dev->ts_q.curr->vb.field;
		if (field == V4L2_FIELD_TOP) {
			if ((status & 0x100000) != 0x000000)
				goto done;
		} else {
			if ((status & 0x100000) != 0x100000)
				goto done;
		}
		saa7134_buffer_finish(dev,&dev->ts_q,STATE_DONE);




/*
 * $Id: saa7134-tvaudio.c,v 1.22 2005/01/07 13:11:19 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * tv audio decoder (fm stereo, nicam, ...)

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/delay.h>


	if (PCI_DEVICE_ID_PHILIPS_SAA7134 == dev->pci->device)
		/* 7134 mute */
		saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ? 0xbf : 0xbb);

	/* switch internal audio mux */
	switch (in->amux) {
	case TV:         ausel=0xc0; ics=0x00; ocs=0x02; break;
	case LINE1:      ausel=0x80; ics=0x00; ocs=0x00; break;
	case LINE2:      ausel=0x80; ics=0x08; ocs=0x01; break;
	case LINE2_LEFT: ausel=0x80; ics=0x08; ocs=0x05; break;
	}
	saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, ausel);
	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, ics);

		nicam = saa_readb(SAA7134_NICAM_STATUS);
		dprintk("getstereo: nicam=0x%x\n",nicam);
		switch (nicam & 0x0b) {
		case 0x08:
			retval = V4L2_TUNER_SUB_MONO;
			break;
		case 0x09:
			retval = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
			break;
		case 0x0a:
			retval = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
			break;
		case 0x08:
		default:
			retval = V4L2_TUNER_SUB_MONO;
			break;
		}
		break;
	}

	int mask;

	switch (dev->input->amux) {
	case TV:
		reg = 0x02;
		break;
	case LINE1:
		reg = 0x00;
		break;
	case LINE2:
	case LINE2_LEFT:
		reg = 0x01;
		break;
	}
	if (dev->ctl_mute)
		reg = 0x07;

/* ------------------------------------------------------------------ */
/* common stuff + external entry points                               */

static void saa7134_enable_i2s(struct saa7134_dev *dev)
{
	int i2s_format;

	if (!card_is_empress(dev))
		return;
	i2s_format = (dev->input->amux == TV) ? 0x00 : 0x01;

	/* enable I2S audio output for the mpeg encoder */
	saa_writeb(SAA7134_I2S_OUTPUT_SELECT,  0x80);
	saa_writeb(SAA7134_I2S_OUTPUT_FORMAT,  i2s_format);
	saa_writeb(SAA7134_I2S_OUTPUT_LEVEL,   0x0F);
	saa_writeb(SAA7134_I2S_AUDIO_OUTPUT,   0x01);
}

int saa7134_tvaudio_rx2mode(u32 rx)
{
	u32 mode;

		mute_input_7133(dev);
		break;
	}
	saa7134_enable_i2s(dev);
}

void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level)

	DECLARE_MUTEX_LOCKED(sem);
	int (*my_thread)(void *data) = NULL;

	/* enable I2S audio output */
	if (card_is_empress(dev)) {
		int i2sform = (48000 == dev->oss.rate)
			? 0x01 : 0x00;

		/* enable I2S output */
		saa_writeb(SAA7134_I2S_OUTPUT_SELECT,  0x80);
		saa_writeb(SAA7134_I2S_OUTPUT_FORMAT,  i2sform);
		saa_writeb(SAA7134_I2S_OUTPUT_LEVEL,   0x0F);
		saa_writeb(SAA7134_I2S_AUDIO_OUTPUT,   0x01);
	}

	switch (dev->pci->device) {
	case PCI_DEVICE_ID_PHILIPS_SAA7134:
		my_thread = tvaudio_thread;

		if (dev->thread.pid < 0)
			printk(KERN_WARNING "%s: kernel_thread() failed\n",
			       dev->name);
		saa7134_tvaudio_do_scan(dev);
	}

	saa7134_enable_i2s(dev);
	return 0;
}


Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-vbi.c (-1 / +2 lines)
1	/*	1	/*
2	* $Id: saa7134-vbi.c,v 1.5 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-vbi.c,v 1.6 2004/12/10 12:33:39 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* video4linux video interface	5	* video4linux video interface
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29		30




/*
 * $Id: saa7134-video.c,v 1.28 2005/02/15 15:59:35 kraxel Exp $
 *
 * device driver for philips saa7134 based TV cards
 * video4linux video interface

#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/slab.h>


		.chroma_ctrl2  = 0x06,
		.vgate_misc    = 0x1c,

	},{
		.name          = "PAL-60",
		.id            = V4L2_STD_PAL_60,

		.h_start       = 0,
		.h_stop        = 719,
		.video_v_start = 22,
		.video_v_stop  = 22+239,
		.vbi_v_start   = 10, /* FIXME */
		.vbi_v_stop    = 21, /* FIXME */
		.src_timing    = 1,
		
		.sync_control  = 0x18,
		.luma_control  = 0x40,
		.chroma_ctrl1  = 0x81,
		.chroma_gain   = 0x2a,
		.chroma_ctrl2  = 0x06,
		.vgate_misc    = 0x1c,
	}
};
#define TVNORMS ARRAY_SIZE(tvnorms)


static void set_tvnorm(struct saa7134_dev *dev, struct saa7134_tvnorm *norm)
{
	int luma_control,sync_control,mux;

	dprintk("set tv norm = %s\n",norm->name);
	dev->tvnorm = norm;
        nosignal = (0 == (saa_readb(SAA7134_STATUS_VIDEO1) & 0x03));

	mux = card_in(dev,dev->ctl_input).vmux;
	luma_control = norm->luma_control;


	if (mux > 5)
		luma_control |= 0x80; /* svideo */
	if (noninterlaced || dev->nosignal)
		sync_control |= 0x20;

	/* setup cropping */

		res_free(dev,fh,RESOURCE_VBI);
	}

	/* free stuff */
	videobuf_mmap_free(&fh->cap);
	videobuf_mmap_free(&fh->vbi);
	saa7134_pgtable_free(dev->pci,&fh->pt_cap);
	saa7134_pgtable_free(dev->pci,&fh->pt_vbi);


			f->fmt.pix.width = maxw;
		if (f->fmt.pix.height > maxh)
			f->fmt.pix.height = maxh;
		f->fmt.pix.width &= ~0x03;
		f->fmt.pix.bytesperline =
			(f->fmt.pix.width * fmt->depth) >> 3;
		f->fmt.pix.sizeimage =

	dev->ctl_hue        = ctrl_by_id(V4L2_CID_HUE)->default_value;
	dev->ctl_saturation = ctrl_by_id(V4L2_CID_SATURATION)->default_value;
	dev->ctl_volume     = ctrl_by_id(V4L2_CID_AUDIO_VOLUME)->default_value;
	dev->ctl_mute       = 1; // ctrl_by_id(V4L2_CID_AUDIO_MUTE)->default_value;
	dev->ctl_invert     = ctrl_by_id(V4L2_CID_PRIVATE_INVERT)->default_value;
	dev->ctl_automute   = ctrl_by_id(V4L2_CID_PRIVATE_AUTOMUTE)->default_value;


void saa7134_irq_video_intl(struct saa7134_dev *dev)
{
	static const char *st[] = {
		"(no signal)", "NTSC", "PAL", "SECAM" };
	u32 st1,st2;

	st1 = saa_readb(SAA7134_STATUS_VIDEO1);
	st2 = saa_readb(SAA7134_STATUS_VIDEO2);
	dprintk("DCSDT: pll: %s, sync: %s, norm: %s\n",
		(st1 & 0x40) ? "not locked" : "locked",
		(st2 & 0x40) ? "no"         : "yes",
		st[st1 & 0x03]);
	dev->nosignal = (st1 & 0x40) || (st2 & 0x40);

	if (dev->nosignal) {
		/* wake up tvaudio audio carrier scan thread */
		saa7134_tvaudio_do_scan(dev);
		if (!noninterlaced)
			saa_clearb(SAA7134_SYNC_CTRL, 0x20);
	} else {
		/* no video signal -> mute audio */
		if (dev->ctl_automute)
			dev->automute = 1;
		saa7134_tvaudio_setmute(dev);
		saa_setb(SAA7134_SYNC_CTRL, 0x20);
	} else {
		/* wake up tvaudio audio carrier scan thread */
		saa7134_tvaudio_do_scan(dev);
		if (!noninterlaced)
			saa_clearb(SAA7134_SYNC_CTRL, 0x20);
	}
	if (dev->mops && dev->mops->signal_change)
		dev->mops->signal_change(dev);
}

void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status)




/*
 * $Id: saa7134.h,v 1.38 2005/03/07 12:01:51 kraxel Exp $
 *
 * v4l2 device driver for philips saa7134 based TV cards
 *

	TV    = 1,
	LINE1 = 2,
	LINE2 = 3,
	LINE2_LEFT,
};

enum saa7134_video_out {

#define SAA7134_BOARD_AVACSSMARTTV     32
#define SAA7134_BOARD_AVERMEDIA_DVD_EZMAKER 33
#define SAA7134_BOARD_NOVAC_PRIMETV7133 34
#define SAA7134_BOARD_AVERMEDIA_STUDIO_305 35
#define SAA7133_BOARD_UPMOST_PURPLE_TV 36
#define SAA7134_BOARD_ITEMS_MTV005     37
#define SAA7134_BOARD_CINERGY200       38
#define SAA7134_BOARD_FLYTVPLATINUM_MINI 39
#define SAA7134_BOARD_VIDEOMATE_TV_PVR 40
#define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUS 41
#define SAA7134_BOARD_SABRENT_SBTTVFM  42

#define SAA7134_BOARD_AVERMEDIA_307    45
#define SAA7134_BOARD_AVERMEDIA_CARDBUS 46
#define SAA7134_BOARD_CINERGY400_CARDBUS 47
#define SAA7134_BOARD_CINERGY600_MK3   48
#define SAA7134_BOARD_VIDEOMATE_GOLD_PLUS 49
#define SAA7134_BOARD_PINNACLE_300I_DVBT_PAL 50
#define SAA7134_BOARD_PROVIDEO_PV952   51
#define SAA7134_BOARD_AVERMEDIA_305    52
#define SAA7135_BOARD_ASUSTeK_TVFM7135 53
#define SAA7134_BOARD_FLYTVPLATINUM_FM 54
#define SAA7134_BOARD_FLYDVBTDUO 55

#define SAA7134_MAXBOARDS 8
#define SAA7134_INPUT_MAX 8

	struct list_head           next;
	int                        (*init)(struct saa7134_dev *dev);
	int                        (*fini)(struct saa7134_dev *dev);
	void                       (*signal_change)(struct saa7134_dev *dev);
};

/* global device status */

	unsigned int               tuner_type;
	unsigned int               tda9887_conf;
	unsigned int               gpio_value;
	unsigned int               irq2_mask;

	/* i2c i/o */
	struct i2c_adapter         i2c_adap;

	struct saa7134_input       *hw_input;
	unsigned int               hw_mute;
	int                        last_carrier;
	int                        nosignal;

	/* SAA7134_MPEG_* */
	struct saa7134_ts          ts;

	struct video_device        *empress_dev;
	struct videobuf_queue      empress_tsq;
	unsigned int               empress_users;
	struct work_struct         empress_workqueue;
	int                        empress_started;

	/* SAA7134_MPEG_DVB only */
	struct videobuf_dvb        dvb;

/* saa7134-core.c                                              */

extern struct list_head  saa7134_devlist;
extern unsigned int      saa7134_devcount;

void saa7134_print_ioctl(char *name, unsigned int cmd);
void saa7134_track_gpio(struct saa7134_dev *dev, char *msg);




		/* unmap and free memory */
		saa->audhead = saa->audtail = saa->osdhead = 0;
		saa->vidhead = saa->vidtail = saa->osdtail = 0;
		vfree(saa->vidbuf);
		vfree(saa->audbuf);
		vfree(saa->osdbuf);
			vfree(saa->audbuf);
		if (saa->osdbuf)
			vfree(saa->osdbuf);
		if (saa->dmavid2)
			kfree((void *) saa->dmavid2);
		saa->audbuf = saa->vidbuf = saa->osdbuf = NULL;




/*
 * $Id: tda8290.c,v 1.7 2005/03/07 12:01:51 kraxel Exp $
 *
 * i2c tv tuner chip device driver
 * controls the philips tda8290+75 tuner chip combo.
 */
#include <linux/i2c.h>
#include <linux/videodev.h>
#include <linux/delay.h>
#include <media/tuner.h>

/* ---------------------------------------------------------------------- */

struct freq_entry {
	u16	freq;
	u8	value;
};

static struct freq_entry band_table[] = {
	{ 0x2DF4, 0x1C },
	{ 0x2574, 0x14 },
	{ 0x22B4, 0x0C },
	{ 0x20D4, 0x0B },
	{ 0x1E74, 0x3B },
	{ 0x1C34, 0x33 },
	{ 0x16F4, 0x5B },
	{ 0x1454, 0x53 },
	{ 0x12D4, 0x52 },
	{ 0x1034, 0x4A },
	{ 0x0EE4, 0x7A },
	{ 0x0D34, 0x72 },
	{ 0x0B54, 0x9A },
	{ 0x0914, 0x91 },
	{ 0x07F4, 0x89 },
	{ 0x0774, 0xB9 },
	{ 0x067B, 0xB1 },
	{ 0x0634, 0xD9 },
	{ 0x05A4, 0xD8 },	// FM radio
	{ 0x0494, 0xD0 },
	{ 0x03BC, 0xC8 },
	{ 0x0394, 0xF8 },	// 57250000 Hz
	{ 0x0000, 0xF0 },	// 0
};

static struct freq_entry div_table[] = {
	{ 0x1C34, 3 },
	{ 0x0D34, 2 },
	{ 0x067B, 1 },
        { 0x0000, 0 },
};

static struct freq_entry agc_table[] = {
	{ 0x22B4, 0x8F },
	{ 0x0B54, 0x9F },
	{ 0x09A4, 0x8F },
	{ 0x0554, 0x9F },
	{ 0x0000, 0xBF },
};

static __u8 get_freq_entry( struct freq_entry* table, __u16 freq)
{
	while(table->freq && table->freq > freq)
		table++;
	return table->value;
}

/* ---------------------------------------------------------------------- */

static unsigned char i2c_enable_bridge[2] = 	{ 0x21, 0xC0 };
static unsigned char i2c_disable_bridge[2] = 	{ 0x21, 0x80 };
static unsigned char i2c_init_tda8275[14] = 	{ 0x00, 0x00, 0x00, 0x00,
						  0x7C, 0x04, 0xA3, 0x3F,
						  0x2A, 0x04, 0xFF, 0x00,
						  0x00, 0x40 };
static unsigned char i2c_set_VS[2] = 		{ 0x30, 0x6F };
static unsigned char i2c_set_GP01_CF[2] = 	{ 0x20, 0x0B };
static unsigned char i2c_tda8290_reset[2] =	{ 0x00, 0x00 };
static unsigned char i2c_gainset_off[2] =	{ 0x28, 0x14 };
static unsigned char i2c_gainset_on[2] =	{ 0x28, 0x54 };
static unsigned char i2c_agc3_00[2] =		{ 0x80, 0x00 };
static unsigned char i2c_agc2_BF[2] =		{ 0x60, 0xBF };
static unsigned char i2c_cb1_D2[2] =		{ 0x30, 0xD2 };
static unsigned char i2c_cb1_56[2] =		{ 0x30, 0x56 };
static unsigned char i2c_cb1_52[2] =		{ 0x30, 0x52 };
static unsigned char i2c_cb1_50[2] =		{ 0x30, 0x50 };
static unsigned char i2c_agc2_7F[2] =		{ 0x60, 0x7F };
static unsigned char i2c_agc3_08[2] =		{ 0x80, 0x08 };

static struct i2c_msg i2c_msg_init[] = {
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_init_tda8275), i2c_init_tda8275 },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_disable_bridge), i2c_disable_bridge },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_set_VS), i2c_set_VS },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_set_GP01_CF), i2c_set_GP01_CF },
};

static struct i2c_msg i2c_msg_prolog[] = {
//	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_easy_mode), i2c_easy_mode },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_gainset_off), i2c_gainset_off },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_tda8290_reset), i2c_tda8290_reset },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_enable_bridge), i2c_enable_bridge },
};

static struct i2c_msg i2c_msg_config[] = {
//	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_set_freq), i2c_set_freq },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_agc3_00), i2c_agc3_00 },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_agc2_BF), i2c_agc2_BF },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_cb1_D2), i2c_cb1_D2 },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_cb1_56), i2c_cb1_56 },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_cb1_52), i2c_cb1_52 },
};

static struct i2c_msg i2c_msg_epilog[] = {
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_cb1_50), i2c_cb1_50 },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_agc2_7F), i2c_agc2_7F },
	{ I2C_ADDR_TDA8275, 0, ARRAY_SIZE(i2c_agc3_08), i2c_agc3_08 },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_disable_bridge), i2c_disable_bridge },
	{ I2C_ADDR_TDA8290, 0, ARRAY_SIZE(i2c_gainset_on), i2c_gainset_on },
};

static int tda8290_tune(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
	struct i2c_msg easy_mode =
		{ I2C_ADDR_TDA8290, 0, 2, t->i2c_easy_mode };
	struct i2c_msg set_freq =
		{ I2C_ADDR_TDA8275, 0, 8, t->i2c_set_freq  };

	i2c_transfer(c->adapter, &easy_mode,      1);
	i2c_transfer(c->adapter, i2c_msg_prolog, ARRAY_SIZE(i2c_msg_prolog));

	i2c_transfer(c->adapter, &set_freq,       1);
	i2c_transfer(c->adapter, i2c_msg_config, ARRAY_SIZE(i2c_msg_config));

	msleep(550);
	i2c_transfer(c->adapter, i2c_msg_epilog, ARRAY_SIZE(i2c_msg_epilog));
	return 0;
}

static void set_frequency(struct tuner *t, u16 ifc)
{
	u32 N = (((t->freq<<3)+ifc)&0x3fffc);

	N = N >> get_freq_entry(div_table, t->freq);
	t->i2c_set_freq[0] = 0;
	t->i2c_set_freq[1] = (unsigned char)(N>>8);
	t->i2c_set_freq[2] = (unsigned char) N;
	t->i2c_set_freq[3] = 0x40;
	t->i2c_set_freq[4] = 0x52;
	t->i2c_set_freq[5] = get_freq_entry(band_table, t->freq);
	t->i2c_set_freq[6] = get_freq_entry(agc_table,  t->freq);
	t->i2c_set_freq[7] = 0x8f;
}

#define V4L2_STD_MN	(V4L2_STD_PAL_M|V4L2_STD_PAL_N|V4L2_STD_PAL_Nc|V4L2_STD_NTSC)
#define V4L2_STD_B	(V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_SECAM_B)
#define V4L2_STD_GH	(V4L2_STD_PAL_G|V4L2_STD_PAL_H|V4L2_STD_SECAM_G|V4L2_STD_SECAM_H)
#define V4L2_STD_DK	(V4L2_STD_PAL_DK|V4L2_STD_SECAM_DK)

static void set_audio(struct tuner *t)
{
	t->i2c_easy_mode[0] = 0x01;

	if (t->std & V4L2_STD_MN)
		t->i2c_easy_mode[1] = 0x01;
	else if (t->std & V4L2_STD_B)
		t->i2c_easy_mode[1] = 0x02;
	else if (t->std & V4L2_STD_GH)
		t->i2c_easy_mode[1] = 0x04;
	else if (t->std & V4L2_STD_PAL_I)
		t->i2c_easy_mode[1] = 0x08;
	else if (t->std & V4L2_STD_DK)
		t->i2c_easy_mode[1] = 0x10;
	else if (t->std & V4L2_STD_SECAM_L)
		t->i2c_easy_mode[1] = 0x20;
}

static void set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	set_audio(t);
	set_frequency(t, 864);
	tda8290_tune(c);
}

static void set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	set_frequency(t, 704);
	tda8290_tune(c);
}

static int has_signal(struct i2c_client *c)
{
	unsigned char i2c_get_afc[1] = { 0x1B };
	unsigned char afc = 0;
	
	i2c_master_send(c, i2c_get_afc, ARRAY_SIZE(i2c_get_afc));
	i2c_master_recv(c, &afc, 1);
	return (afc & 0x80)? 65535:0;
}
	
int tda8290_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);

	strlcpy(c->name, "tda8290+75", sizeof(c->name));
	tuner_info("tuner: type set to %s\n", c->name);
	t->tv_freq    = set_tv_freq;
	t->radio_freq = set_radio_freq;
	t->has_signal = has_signal;

	i2c_master_send(c, i2c_enable_bridge, ARRAY_SIZE(i2c_enable_bridge));
	i2c_transfer(c->adapter, i2c_msg_init, ARRAY_SIZE(i2c_msg_init));
	return 0;
}

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Lines 557-563 static int tda9887_configure(struct tda9 Link Here

(-)linux-2.6.11.orig/drivers/media/video/tda9887.c (-1 / +1 lines)
557	#if 0	557	#if 0
558	/* This as-is breaks some cards, must be fixed in a	558	/* This as-is breaks some cards, must be fixed in a
559	* card-specific way, probably using TDA9887_SET_CONFIG to	559	* card-specific way, probably using TDA9887_SET_CONFIG to
560	* turn on/off port2 */	560	* turn on/off port2 */
561	if (t->std & V4L2_STD_SECAM_L) {	561	if (t->std & V4L2_STD_SECAM_L) {
562	/* secam fixup (FIXME: move this to tvnorms array?) */	562	/* secam fixup (FIXME: move this to tvnorms array?) */
563	buf[1] &= ~cOutputPort2Inactive;	563	buf[1] &= ~cOutputPort2Inactive;




/*
 * $Id: tuner-core.c,v 1.5 2005/02/15 15:59:35 kraxel Exp $
 *
 * i2c tv tuner chip device driver
 * core core, i.e. kernel interfaces, registering and so on
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/i2c.h>
#include <linux/types.h>
#include <linux/videodev.h>
#include <linux/init.h>

#include <media/tuner.h>
#include <media/audiochip.h>

#define UNSET (-1U)

/* standard i2c insmod options */
static unsigned short normal_i2c[] = {
	0x4b, /* tda8290 */
	I2C_CLIENT_END
};
static unsigned short normal_i2c_range[] = {
	0x60, 0x6f,
	I2C_CLIENT_END
};
I2C_CLIENT_INSMOD;

/* insmod options used at init time => read/only */
static unsigned int addr  =  0;
module_param(addr, int, 0444);

/* insmod options used at runtime => read/write */
unsigned int tuner_debug   = 0;
module_param(tuner_debug,       int, 0644);

static unsigned int tv_range[2]    = { 44, 958 };
static unsigned int radio_range[2] = { 65, 108 };

module_param_array(tv_range,    int, NULL, 0644);
module_param_array(radio_range, int, NULL, 0644);

MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
MODULE_LICENSE("GPL");

static int this_adap;

static struct i2c_driver driver;
static struct i2c_client client_template;

/* ---------------------------------------------------------------------- */

// Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz
static void set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type == UNSET) {
		tuner_info("tuner type not set\n");
		return;
	}
	if (NULL == t->tv_freq) {
		tuner_info("Huh? tv_set is NULL?\n");
		return;
	}
	if (freq < tv_range[0]*16 || freq > tv_range[1]*16) {
		/* FIXME: better do that chip-specific, but
		   right now we don't have that in the config
		   struct and this way is still better than no
		   check at all */
		tuner_info("TV freq (%d.%02d) out of range (%d-%d)\n",
			   freq/16,freq%16*100/16,tv_range[0],tv_range[1]);
		return;
	}
	t->tv_freq(c,freq);
}

static void set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type == UNSET) {
		tuner_info("tuner type not set\n");
		return;
	}
	if (NULL == t->radio_freq) {
		tuner_info("no radio tuning for this one, sorry.\n");
		return;
	}
	if (freq < radio_range[0]*16 || freq > radio_range[1]*16) {
		tuner_info("radio freq (%d.%02d) out of range (%d-%d)\n",
			   freq/16,freq%16*100/16,
			   radio_range[0],radio_range[1]);
		return;
	}
	t->radio_freq(c,freq);
}

static void set_freq(struct i2c_client *c, unsigned long freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	switch (t->mode) {
	case V4L2_TUNER_RADIO:
		tuner_dbg("radio freq set to %lu.%02lu\n",
			  freq/16,freq%16*100/16);
		set_radio_freq(c,freq);
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		tuner_dbg("tv freq set to %lu.%02lu\n",
			  freq/16,freq%16*100/16);
		set_tv_freq(c, freq);
		break;
	}
	t->freq = freq;
}

static void set_type(struct i2c_client *c, unsigned int type)
{
	struct tuner *t = i2c_get_clientdata(c);

	/* sanity check */
	if (type == UNSET  ||  type == TUNER_ABSENT)
		return;
	if (type >= tuner_count)
		return;

	if (NULL == t->i2c.dev.driver) {
		/* not registered yet */
		t->type = type;
		return;
	}
	if (t->initialized)
		/* run only once */
		return;

	t->initialized = 1;
	t->type = type;
	switch (t->type) {
	case TUNER_MT2032:
		microtune_init(c);
		break;
	case TUNER_PHILIPS_TDA8290:
		tda8290_init(c);
		break;
	default:
		default_tuner_init(c);
		break;
	}
}

static char pal[] = "-";
module_param_string(pal, pal, 0644, sizeof(pal));

static int tuner_fixup_std(struct tuner *t)
{
	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
		/* get more precise norm info from insmod option */
		switch (pal[0]) {
		case 'b':
		case 'B':
		case 'g':
		case 'G':
			tuner_dbg("insmod fixup: PAL => PAL-BG\n");
			t->std = V4L2_STD_PAL_BG;
			break;
		case 'i':
		case 'I':
			tuner_dbg("insmod fixup: PAL => PAL-I\n");
			t->std = V4L2_STD_PAL_I;
			break;
		case 'd':
		case 'D':
		case 'k':
		case 'K':
			tuner_dbg("insmod fixup: PAL => PAL-DK\n");
			t->std = V4L2_STD_PAL_DK;
			break;
		}
	}
	return 0;
}

/* ---------------------------------------------------------------------- */

static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
{
	struct tuner *t;

	if (this_adap > 0)
		return -1;
	this_adap++;

        client_template.adapter = adap;
        client_template.addr = addr;

        t = kmalloc(sizeof(struct tuner),GFP_KERNEL);
        if (NULL == t)
                return -ENOMEM;
        memset(t,0,sizeof(struct tuner));
        memcpy(&t->i2c,&client_template,sizeof(struct i2c_client));
	i2c_set_clientdata(&t->i2c, t);
	t->type       = UNSET;
	t->radio_if2  = 10700*1000; // 10.7MHz - FM radio

        i2c_attach_client(&t->i2c);
	tuner_info("chip found @ 0x%x (%s)\n",
		   addr << 1, adap->name);
	set_type(&t->i2c, t->type);
	return 0;
}

static int tuner_probe(struct i2c_adapter *adap)
{
	if (0 != addr) {
		normal_i2c[0]       = addr;
		normal_i2c_range[0] = addr;
		normal_i2c_range[1] = addr;
	}
	this_adap = 0;

	if (adap->class & I2C_CLASS_TV_ANALOG)
		return i2c_probe(adap, &addr_data, tuner_attach);
	return 0;
}

static int tuner_detach(struct i2c_client *client)
{
	struct tuner *t = i2c_get_clientdata(client);

	i2c_detach_client(&t->i2c);
	kfree(t);
	return 0;
}

#define SWITCH_V4L2	if (!t->using_v4l2 && tuner_debug) \
		          tuner_info("switching to v4l2\n"); \
	                  t->using_v4l2 = 1;
#define CHECK_V4L2	if (t->using_v4l2) { if (tuner_debug) \
			  tuner_info("ignore v4l1 call\n"); \
		          return 0; }

static int
tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
{
	struct tuner *t = i2c_get_clientdata(client);
        unsigned int *iarg = (int*)arg;

        switch (cmd) {

	/* --- configuration --- */
	case TUNER_SET_TYPE:
		set_type(client,*iarg);
		break;
	case AUDC_SET_RADIO:
		if (V4L2_TUNER_RADIO != t->mode) {
			set_tv_freq(client,400 * 16);
			t->mode = V4L2_TUNER_RADIO;
		}
		break;
	case AUDC_CONFIG_PINNACLE:
		switch (*iarg) {
		case 2:
			tuner_dbg("pinnacle pal\n");
			t->radio_if2 = 33300 * 1000;
			break;
		case 3:
			tuner_dbg("pinnacle ntsc\n");
			t->radio_if2 = 41300 * 1000;
			break;
		}
                break;

	/* --- v4l ioctls --- */
	/* take care: bttv does userspace copying, we'll get a
	   kernel pointer here... */
	case VIDIOCSCHAN:
	{
		static const v4l2_std_id map[] = {
			[ VIDEO_MODE_PAL   ] = V4L2_STD_PAL,
			[ VIDEO_MODE_NTSC  ] = V4L2_STD_NTSC_M,
			[ VIDEO_MODE_SECAM ] = V4L2_STD_SECAM,
			[ 4 /* bttv */     ] = V4L2_STD_PAL_M,
			[ 5 /* bttv */     ] = V4L2_STD_PAL_N,
			[ 6 /* bttv */     ] = V4L2_STD_NTSC_M_JP,
		};
		struct video_channel *vc = arg;

		CHECK_V4L2;
		t->mode = V4L2_TUNER_ANALOG_TV;
		if (vc->norm < ARRAY_SIZE(map))
			t->std = map[vc->norm];
		tuner_fixup_std(t);
		if (t->freq)
			set_tv_freq(client,t->freq);
		return 0;
	}
	case VIDIOCSFREQ:
	{
		unsigned long *v = arg;

		CHECK_V4L2;
		set_freq(client,*v);
		return 0;
	}
	case VIDIOCGTUNER:
	{
		struct video_tuner *vt = arg;

		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode  &&  t->has_signal)
			vt->signal = t->has_signal(client);
		return 0;
	}
	case VIDIOCGAUDIO:
	{
		struct video_audio *va = arg;

		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode  &&  t->is_stereo)
			va->mode = t->is_stereo(client)
				? VIDEO_SOUND_STEREO
				: VIDEO_SOUND_MONO;
		return 0;
	}

	case VIDIOC_S_STD:
	{
		v4l2_std_id *id = arg;

		SWITCH_V4L2;
		t->mode = V4L2_TUNER_ANALOG_TV;
		t->std = *id;
		tuner_fixup_std(t);
		if (t->freq)
			set_freq(client,t->freq);
		break;
	}
	case VIDIOC_S_FREQUENCY:
	{
		struct v4l2_frequency *f = arg;

		SWITCH_V4L2;
		if (V4L2_TUNER_RADIO == f->type &&
		    V4L2_TUNER_RADIO != t->mode)
			set_tv_freq(client,400*16);
		t->mode  = f->type;
		t->freq  = f->frequency;
		set_freq(client,t->freq);
		break;
	}
	case VIDIOC_G_TUNER:
	{
		struct v4l2_tuner *tuner = arg;

		SWITCH_V4L2;
		if (V4L2_TUNER_RADIO == t->mode  &&  t->has_signal)
			tuner->signal = t->has_signal(client);
		break;
	}
	default:
		/* nothing */
		break;
	}

	return 0;
}

static int tuner_suspend(struct device * dev, u32 state, u32 level)
{
	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	struct tuner *t = i2c_get_clientdata(c);

	tuner_dbg("suspend\n");
	/* FIXME: power down ??? */
	return 0;
}

static int tuner_resume(struct device * dev, u32 level)
{
	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	struct tuner *t = i2c_get_clientdata(c);

	tuner_dbg("resume\n");
	if (t->freq)
		set_freq(c,t->freq);
	return 0;
}

/* ----------------------------------------------------------------------- */

static struct i2c_driver driver = {
	.owner          = THIS_MODULE,
        .name           = "tuner",
        .id             = I2C_DRIVERID_TUNER,
        .flags          = I2C_DF_NOTIFY,
        .attach_adapter = tuner_probe,
        .detach_client  = tuner_detach,
        .command        = tuner_command,
	.driver = {
		.suspend = tuner_suspend,
		.resume  = tuner_resume,
	},
};
static struct i2c_client client_template =
{
	I2C_DEVNAME("(tuner unset)"),
	.flags      = I2C_CLIENT_ALLOW_USE,
        .driver     = &driver,
};

static int __init tuner_init_module(void)
{
	return i2c_add_driver(&driver);
}

static void __exit tuner_cleanup_module(void)
{
	i2c_del_driver(&driver);
}

module_init(tuner_init_module);
module_exit(tuner_cleanup_module);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */




/*
 * $Id: tuner-simple.c,v 1.10 2005/03/08 08:38:00 kraxel Exp $
 *
 * i2c tv tuner chip device driver
 * controls all those simple 4-control-bytes style tuners.
 */
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/videodev.h>
#include <media/tuner.h>

/* ---------------------------------------------------------------------- */

/* tv standard selection for Temic 4046 FM5
   this value takes the low bits of control byte 2
   from datasheet Rev.01, Feb.00
     standard     BG      I       L       L2      D
     picture IF   38.9    38.9    38.9    33.95   38.9
     sound 1      33.4    32.9    32.4    40.45   32.4
     sound 2      33.16
     NICAM        33.05   32.348  33.05           33.05
 */
#define TEMIC_SET_PAL_I         0x05
#define TEMIC_SET_PAL_DK        0x09
#define TEMIC_SET_PAL_L         0x0a // SECAM ?
#define TEMIC_SET_PAL_L2        0x0b // change IF !
#define TEMIC_SET_PAL_BG        0x0c

/* tv tuner system standard selection for Philips FQ1216ME
   this value takes the low bits of control byte 2
   from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
     standard 		BG	DK	I	L	L`
     picture carrier	38.90	38.90	38.90	38.90	33.95
     colour		34.47	34.47	34.47	34.47	38.38
     sound 1		33.40	32.40	32.90	32.40	40.45
     sound 2		33.16	-	-	-	-
     NICAM		33.05	33.05	32.35	33.05	39.80
 */
#define PHILIPS_SET_PAL_I	0x01 /* Bit 2 always zero !*/
#define PHILIPS_SET_PAL_BGDK	0x09
#define PHILIPS_SET_PAL_L2	0x0a
#define PHILIPS_SET_PAL_L	0x0b

/* system switching for Philips FI1216MF MK2
   from datasheet "1996 Jul 09",
    standard         BG     L      L'
    picture carrier  38.90  38.90  33.95
    colour	     34.47  34.37  38.38
    sound 1          33.40  32.40  40.45
    sound 2          33.16  -      -
    NICAM            33.05  33.05  39.80
 */
#define PHILIPS_MF_SET_BG	0x01 /* Bit 2 must be zero, Bit 3 is system output */
#define PHILIPS_MF_SET_PAL_L	0x03 // France
#define PHILIPS_MF_SET_PAL_L2	0x02 // L'


/* ---------------------------------------------------------------------- */

struct tunertype
{
	char *name;
	unsigned char Vendor;
	unsigned char Type;

	unsigned short thresh1;  /*  band switch VHF_LO <=> VHF_HI  */
	unsigned short thresh2;  /*  band switch VHF_HI <=> UHF     */
	unsigned char VHF_L;
	unsigned char VHF_H;
	unsigned char UHF;
	unsigned char config;
	unsigned short IFPCoff; /* 622.4=16*38.90 MHz PAL,
				   732  =16*45.75 NTSCi,
				   940  =16*58.75 NTSC-Japan
				   704  =16*44    ATSC */
};

/*
 *	The floats in the tuner struct are computed at compile time
 *	by gcc and cast back to integers. Thus we don't violate the
 *	"no float in kernel" rule.
 */
static struct tunertype tuners[] = {
        { "Temic PAL (4002 FH5)", TEMIC, PAL,
	  16*140.25,16*463.25,0x02,0x04,0x01,0x8e,623},
	{ "Philips PAL_I (FI1246 and compatibles)", Philips, PAL_I,
	  16*140.25,16*463.25,0xa0,0x90,0x30,0x8e,623},
	{ "Philips NTSC (FI1236,FM1236 and compatibles)", Philips, NTSC,
	  16*157.25,16*451.25,0xA0,0x90,0x30,0x8e,732},
	{ "Philips (SECAM+PAL_BG) (FI1216MF, FM1216MF, FR1216MF)", Philips, SECAM,
	  16*168.25,16*447.25,0xA7,0x97,0x37,0x8e,623},

	{ "NoTuner", NoTuner, NOTUNER,
	  0,0,0x00,0x00,0x00,0x00,0x00},
	{ "Philips PAL_BG (FI1216 and compatibles)", Philips, PAL,
	  16*168.25,16*447.25,0xA0,0x90,0x30,0x8e,623},
	{ "Temic NTSC (4032 FY5)", TEMIC, NTSC,
	  16*157.25,16*463.25,0x02,0x04,0x01,0x8e,732},
	{ "Temic PAL_I (4062 FY5)", TEMIC, PAL_I,
	  16*170.00,16*450.00,0x02,0x04,0x01,0x8e,623},

 	{ "Temic NTSC (4036 FY5)", TEMIC, NTSC,
	  16*157.25,16*463.25,0xa0,0x90,0x30,0x8e,732},
        { "Alps HSBH1", TEMIC, NTSC,
	  16*137.25,16*385.25,0x01,0x02,0x08,0x8e,732},
        { "Alps TSBE1",TEMIC,PAL,
	  16*137.25,16*385.25,0x01,0x02,0x08,0x8e,732},
        { "Alps TSBB5", Alps, PAL_I, /* tested (UK UHF) with Modulartech MM205 */
	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,632},

        { "Alps TSBE5", Alps, PAL, /* untested - data sheet guess. Only IF differs. */
	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,622},
        { "Alps TSBC5", Alps, PAL, /* untested - data sheet guess. Only IF differs. */
	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,608},
	{ "Temic PAL_BG (4006FH5)", TEMIC, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
  	{ "Alps TSCH6",Alps,NTSC,
  	  16*137.25,16*385.25,0x14,0x12,0x11,0x8e,732},

  	{ "Temic PAL_DK (4016 FY5)",TEMIC,PAL,
  	  16*168.25,16*456.25,0xa0,0x90,0x30,0x8e,623},
  	{ "Philips NTSC_M (MK2)",Philips,NTSC,
  	  16*160.00,16*454.00,0xa0,0x90,0x30,0x8e,732},
        { "Temic PAL_I (4066 FY5)", TEMIC, PAL_I,
          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
        { "Temic PAL* auto (4006 FN5)", TEMIC, PAL,
          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},

        { "Temic PAL_BG (4009 FR5) or PAL_I (4069 FR5)", TEMIC, PAL,
          16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
        { "Temic NTSC (4039 FR5)", TEMIC, NTSC,
          16*158.00, 16*453.00, 0xa0,0x90,0x30,0x8e,732},
        { "Temic PAL/SECAM multi (4046 FM5)", TEMIC, PAL,
          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
        { "Philips PAL_DK (FI1256 and compatibles)", Philips, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},

	{ "Philips PAL/SECAM multi (FQ1216ME)", Philips, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG PAL_I+FM (TAPC-I001D)", LGINNOTEK, PAL_I,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG PAL_I (TAPC-I701D)", LGINNOTEK, PAL_I,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG NTSC+FM (TPI8NSR01F)", LGINNOTEK, NTSC,
	  16*210.00,16*497.00,0xa0,0x90,0x30,0x8e,732},

	{ "LG PAL_BG+FM (TPI8PSB01D)", LGINNOTEK, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG PAL_BG (TPI8PSB11D)", LGINNOTEK, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "Temic PAL* auto + FM (4009 FN5)", TEMIC, PAL,
	  16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
	{ "SHARP NTSC_JP (2U5JF5540)", SHARP, NTSC, /* 940=16*58.75 NTSC@Japan */
	  16*137.25,16*317.25,0x01,0x02,0x08,0x8e,940 },

	{ "Samsung PAL TCPM9091PD27", Samsung, PAL,  /* from sourceforge v3tv */
          16*169,16*464,0xA0,0x90,0x30,0x8e,623},
	{ "MT20xx universal", Microtune,PAL|NTSC,
	  /* see mt20xx.c for details */ },
	{ "Temic PAL_BG (4106 FH5)", TEMIC, PAL,
          16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
	{ "Temic PAL_DK/SECAM_L (4012 FY5)", TEMIC, PAL,
          16*140.25, 16*463.25, 0x02,0x04,0x01,0x8e,623},

	{ "Temic NTSC (4136 FY5)", TEMIC, NTSC,
          16*158.00, 16*453.00, 0xa0,0x90,0x30,0x8e,732},
        { "LG PAL (newer TAPC series)", LGINNOTEK, PAL,
          16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,623},
	{ "Philips PAL/SECAM multi (FM1216ME MK3)", Philips, PAL,
	  16*160.00,16*442.00,0x01,0x02,0x04,0x8e,623 },
	{ "LG NTSC (newer TAPC series)", LGINNOTEK, NTSC,
          16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,732},

	{ "HITACHI V7-J180AT", HITACHI, NTSC,
	  16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,940 },
	{ "Philips PAL_MK (FI1216 MK)", Philips, PAL,
	  16*140.25,16*463.25,0x01,0xc2,0xcf,0x8e,623},
	{ "Philips 1236D ATSC/NTSC daul in",Philips,ATSC,
	  16*157.25,16*454.00,0xa0,0x90,0x30,0x8e,732},
        { "Philips NTSC MK3 (FM1236MK3 or FM1236/F)", Philips, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732},

        { "Philips 4 in 1 (ATI TV Wonder Pro/Conexant)", Philips, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732},
	{ "Microtune 4049 FM5",Microtune,PAL,
	  16*141.00,16*464.00,0xa0,0x90,0x30,0x8e,623},
	{ "Panasonic VP27s/ENGE4324D", Panasonic, NTSC,
	  16*160.00,16*454.00,0x01,0x02,0x08,0xce,940},
        { "LG NTSC (TAPE series)", LGINNOTEK, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732 },

        { "Tenna TNF 8831 BGFF)", Philips, PAL,
          16*161.25,16*463.25,0xa0,0x90,0x30,0x8e,623},
	{ "Microtune 4042 FI5 ATSC/NTSC dual in", Microtune, NTSC,
	  16*162.00,16*457.00,0xa2,0x94,0x31,0x8e,732},
        { "TCL 2002N", TCL, NTSC,
          16*172.00,16*448.00,0x01,0x02,0x08,0x8e,732},
	{ "Philips PAL/SECAM_D (FM 1256 I-H3)", Philips, PAL,
	  16*160.00,16*442.00,0x01,0x02,0x04,0x8e,623 },

	{ "Thomson DDT 7610 (ATSC/NTSC)", THOMSON, ATSC,
	  16*157.25,16*454.00,0x39,0x3a,0x3c,0x8e,732},
	{ "Philips FQ1286", Philips, NTSC,
	  16*160.00,16*454.00,0x41,0x42,0x04,0x8e,940}, // UHF band untested
	{ "tda8290+75", Philips,PAL|NTSC,
	  /* see tda8290.c for details */ },
	{ "LG PAL (TAPE series)", LGINNOTEK, PAL,
          16*170.00, 16*450.00, 0x01,0x02,0x08,0xce,623},

        { "Philips PAL/SECAM multi (FQ1216AME MK4)", Philips, PAL,
          16*160.00,16*442.00,0x01,0x02,0x04,0xce,623 },
        { "Philips FQ1236A MK4", Philips, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732 },

};
unsigned const int tuner_count = ARRAY_SIZE(tuners);

/* ---------------------------------------------------------------------- */

static int tuner_getstatus(struct i2c_client *c)
{
	unsigned char byte;

	if (1 != i2c_master_recv(c,&byte,1))
		return 0;
	return byte;
}

#define TUNER_POR       0x80
#define TUNER_FL        0x40
#define TUNER_MODE      0x38
#define TUNER_AFC       0x07

#define TUNER_STEREO    0x10 /* radio mode */
#define TUNER_SIGNAL    0x07 /* radio mode */

static int tuner_signal(struct i2c_client *c)
{
	return (tuner_getstatus(c) & TUNER_SIGNAL)<<13;
}

static int tuner_stereo(struct i2c_client *c)
{
	return (tuner_getstatus (c) & TUNER_STEREO);
}

#if 0 /* unused */
static int tuner_islocked (struct i2c_client *c)
{
        return (tuner_getstatus (c) & TUNER_FL);
}

static int tuner_afcstatus (struct i2c_client *c)
{
        return (tuner_getstatus (c) & TUNER_AFC) - 2;
}

static int tuner_mode (struct i2c_client *c)
{
        return (tuner_getstatus (c) & TUNER_MODE) >> 3;
}
#endif

/* ---------------------------------------------------------------------- */

static void default_set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	u8 config;
	u16 div;
	struct tunertype *tun;
        unsigned char buffer[4];
	int rc;

	tun = &tuners[t->type];
	if (freq < tun->thresh1) {
		config = tun->VHF_L;
		tuner_dbg("tv: VHF lowrange\n");
	} else if (freq < tun->thresh2) {
		config = tun->VHF_H;
		tuner_dbg("tv: VHF high range\n");
	} else {
		config = tun->UHF;
		tuner_dbg("tv: UHF range\n");
	}


	/* tv norm specific stuff for multi-norm tuners */
	switch (t->type) {
	case TUNER_PHILIPS_SECAM: // FI1216MF
		/* 0x01 -> ??? no change ??? */
		/* 0x02 -> PAL BDGHI / SECAM L */
		/* 0x04 -> ??? PAL others / SECAM others ??? */
		config &= ~0x02;
		if (t->std & V4L2_STD_SECAM)
			config |= 0x02;
		break;

	case TUNER_TEMIC_4046FM5:
		config &= ~0x0f;

		if (t->std & V4L2_STD_PAL_BG) {
			config |= TEMIC_SET_PAL_BG;

		} else if (t->std & V4L2_STD_PAL_I) {
			config |= TEMIC_SET_PAL_I;

		} else if (t->std & V4L2_STD_PAL_DK) {
			config |= TEMIC_SET_PAL_DK;

		} else if (t->std & V4L2_STD_SECAM_L) {
			config |= TEMIC_SET_PAL_L;

		}
		break;

	case TUNER_PHILIPS_FQ1216ME:
		config &= ~0x0f;

		if (t->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
			config |= PHILIPS_SET_PAL_BGDK;

		} else if (t->std & V4L2_STD_PAL_I) {
			config |= PHILIPS_SET_PAL_I;

		} else if (t->std & V4L2_STD_SECAM_L) {
			config |= PHILIPS_SET_PAL_L;

		}
		break;

	case TUNER_PHILIPS_ATSC:
		/* 0x00 -> ATSC antenna input 1 */
		/* 0x01 -> ATSC antenna input 2 */
		/* 0x02 -> NTSC antenna input 1 */
		/* 0x03 -> NTSC antenna input 2 */
		config &= ~0x03;
		if (!(t->std & V4L2_STD_ATSC))
			config |= 2;
		/* FIXME: input */
		break;

	case TUNER_MICROTUNE_4042FI5:
		/* Set the charge pump for fast tuning */
		tun->config |= 0x40;
		break;
	}

	/*
	 * Philips FI1216MK2 remark from specification :
	 * for channel selection involving band switching, and to ensure
	 * smooth tuning to the desired channel without causing
	 * unnecessary charge pump action, it is recommended to consider
	 * the difference between wanted channel frequency and the
	 * current channel frequency.  Unnecessary charge pump action
	 * will result in very low tuning voltage which may drive the
	 * oscillator to extreme conditions.
	 *
	 * Progfou: specification says to send config data before
	 * frequency in case (wanted frequency < current frequency).
	 */

	div=freq + tun->IFPCoff;
	if (t->type == TUNER_PHILIPS_SECAM && freq < t->freq) {
		buffer[0] = tun->config;
		buffer[1] = config;
		buffer[2] = (div>>8) & 0x7f;
		buffer[3] = div      & 0xff;
	} else {
		buffer[0] = (div>>8) & 0x7f;
		buffer[1] = div      & 0xff;
		buffer[2] = tun->config;
		buffer[3] = config;
	}
	tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
		  buffer[0],buffer[1],buffer[2],buffer[3]);

        if (4 != (rc = i2c_master_send(c,buffer,4)))
		tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);

	if (t->type == TUNER_MICROTUNE_4042FI5) {
		// FIXME - this may also work for other tuners
		unsigned long timeout = jiffies + msecs_to_jiffies(1);
		u8 status_byte = 0;

		/* Wait until the PLL locks */
		for (;;) {
			if (time_after(jiffies,timeout))
				return;
			if (1 != (rc = i2c_master_recv(c,&status_byte,1))) {
				tuner_warn("i2c i/o read error: rc == %d (should be 1)\n",rc);
				break;
			}
			/* bit 6 is PLL locked indicator */
			if (status_byte & 0x40)
				break;
			udelay(10);
		}

		/* Set the charge pump for optimized phase noise figure */
		tun->config &= ~0x40;
		buffer[0] = (div>>8) & 0x7f;
		buffer[1] = div      & 0xff;
		buffer[2] = tun->config;
		buffer[3] = config;
		tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
		       buffer[0],buffer[1],buffer[2],buffer[3]);

		if (4 != (rc = i2c_master_send(c,buffer,4)))
			tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
	}
}

static void default_set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tunertype *tun;
	struct tuner *t = i2c_get_clientdata(c);
        unsigned char buffer[4];
	unsigned div;
	int rc;

	tun=&tuners[t->type];
	div = freq + (int)(16*10.7);
	buffer[2] = tun->config;

	switch (t->type) {
	case TUNER_PHILIPS_FM1216ME_MK3:
	case TUNER_PHILIPS_FM1236_MK3:
		buffer[3] = 0x19;
		break;
	case TUNER_PHILIPS_FM1256_IH3:
		div = (20 * freq)/16 + 333 * 2;
	        buffer[2] = 0x80;
		buffer[3] = 0x19;
		break;
	case TUNER_LG_PAL_FM:
		buffer[3] = 0xa5;
		break;
	default:
		buffer[3] = 0xa4;
		break;
	}
        buffer[0] = (div>>8) & 0x7f;
        buffer[1] = div      & 0xff;

	tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
	       buffer[0],buffer[1],buffer[2],buffer[3]);

        if (4 != (rc = i2c_master_send(c,buffer,4)))
		tuner_warn("i2c i/o error: rc == %d (should be 4)\n",rc);
}

int default_tuner_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);

	tuner_info("type set to %d (%s)\n",
		   t->type, tuners[t->type].name);
	strlcpy(c->name, tuners[t->type].name, sizeof(c->name));

	t->tv_freq    = default_set_tv_freq;
	t->radio_freq = default_set_radio_freq;
	t->has_signal = tuner_signal;
	t->is_stereo  = tuner_stereo;
	return 0;
}

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */




/*
 * $Id: tuner.c,v 1.36 2005/01/14 13:29:40 kraxel Exp $
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/i2c.h>
#include <linux/types.h>
#include <linux/videodev.h>
#include <linux/init.h>

#include <media/tuner.h>
#include <media/audiochip.h>

#define UNSET (-1U)

/* standard i2c insmod options */
static unsigned short normal_i2c[] = {I2C_CLIENT_END};
static unsigned short normal_i2c_range[] = {0x60,0x6f,I2C_CLIENT_END};
I2C_CLIENT_INSMOD;

/* insmod options used at init time => read/only */
static unsigned int type  =  UNSET;
static unsigned int addr  =  0;
module_param(type, int, 0444);
module_param(addr, int, 0444);

/* insmod options used at runtime => read/write */
static unsigned int debug         = 0;
static unsigned int tv_antenna    = 1;
static unsigned int radio_antenna = 0;
static unsigned int optimize_vco  = 1;
module_param(debug,             int, 0644);
module_param(tv_antenna,        int, 0644);
module_param(radio_antenna,     int, 0644);
module_param(optimize_vco,      int, 0644);

static unsigned int tv_range[2]    = { 44, 958 };
static unsigned int radio_range[2] = { 65, 108 };

module_param_array(tv_range,    int, NULL, 0644);
module_param_array(radio_range, int, NULL, 0644);

MODULE_DESCRIPTION("device driver for various TV and TV+FM radio tuners");
MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
MODULE_LICENSE("GPL");

static int this_adap;
#define dprintk     if (debug) printk

struct tuner {
	unsigned int type;            /* chip type */
	unsigned int freq;            /* keep track of the current settings */
	v4l2_std_id  std;
	int          using_v4l2;

	enum v4l2_tuner_type mode;
	unsigned int input;

	// only for MT2032
	unsigned int xogc;
	unsigned int radio_if2;

	void (*tv_freq)(struct i2c_client *c, unsigned int freq);
	void (*radio_freq)(struct i2c_client *c, unsigned int freq);
};

static struct i2c_driver driver;
static struct i2c_client client_template;

/* ---------------------------------------------------------------------- */

/* tv standard selection for Temic 4046 FM5
   this value takes the low bits of control byte 2
   from datasheet Rev.01, Feb.00
     standard     BG      I       L       L2      D
     picture IF   38.9    38.9    38.9    33.95   38.9
     sound 1      33.4    32.9    32.4    40.45   32.4
     sound 2      33.16
     NICAM        33.05   32.348  33.05           33.05
 */
#define TEMIC_SET_PAL_I         0x05
#define TEMIC_SET_PAL_DK        0x09
#define TEMIC_SET_PAL_L         0x0a // SECAM ?
#define TEMIC_SET_PAL_L2        0x0b // change IF !
#define TEMIC_SET_PAL_BG        0x0c

/* tv tuner system standard selection for Philips FQ1216ME
   this value takes the low bits of control byte 2
   from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
     standard 		BG	DK	I	L	L`
     picture carrier	38.90	38.90	38.90	38.90	33.95
     colour		34.47	34.47	34.47	34.47	38.38
     sound 1		33.40	32.40	32.90	32.40	40.45
     sound 2		33.16	-	-	-	-
     NICAM		33.05	33.05	32.35	33.05	39.80
 */
#define PHILIPS_SET_PAL_I	0x01 /* Bit 2 always zero !*/
#define PHILIPS_SET_PAL_BGDK	0x09
#define PHILIPS_SET_PAL_L2	0x0a
#define PHILIPS_SET_PAL_L	0x0b

/* system switching for Philips FI1216MF MK2
   from datasheet "1996 Jul 09",
    standard         BG     L      L'
    picture carrier  38.90  38.90  33.95
    colour	     34.47  34.37  38.38
    sound 1          33.40  32.40  40.45
    sound 2          33.16  -      -
    NICAM            33.05  33.05  39.80
 */
#define PHILIPS_MF_SET_BG	0x01 /* Bit 2 must be zero, Bit 3 is system output */
#define PHILIPS_MF_SET_PAL_L	0x03 // France
#define PHILIPS_MF_SET_PAL_L2	0x02 // L'


/* ---------------------------------------------------------------------- */

struct tunertype
{
	char *name;
	unsigned char Vendor;
	unsigned char Type;

	unsigned short thresh1;  /*  band switch VHF_LO <=> VHF_HI  */
	unsigned short thresh2;  /*  band switch VHF_HI <=> UHF     */
	unsigned char VHF_L;
	unsigned char VHF_H;
	unsigned char UHF;
	unsigned char config;
	unsigned short IFPCoff; /* 622.4=16*38.90 MHz PAL,
				   732  =16*45.75 NTSCi,
				   940  =16*58.75 NTSC-Japan
				   704  =16*44    ATSC */
};

/*
 *	The floats in the tuner struct are computed at compile time
 *	by gcc and cast back to integers. Thus we don't violate the
 *	"no float in kernel" rule.
 */
static struct tunertype tuners[] = {
        { "Temic PAL (4002 FH5)", TEMIC, PAL,
	  16*140.25,16*463.25,0x02,0x04,0x01,0x8e,623},
	{ "Philips PAL_I (FI1246 and compatibles)", Philips, PAL_I,
	  16*140.25,16*463.25,0xa0,0x90,0x30,0x8e,623},
	{ "Philips NTSC (FI1236,FM1236 and compatibles)", Philips, NTSC,
	  16*157.25,16*451.25,0xA0,0x90,0x30,0x8e,732},
	{ "Philips (SECAM+PAL_BG) (FI1216MF, FM1216MF, FR1216MF)", Philips, SECAM,
	  16*168.25,16*447.25,0xA7,0x97,0x37,0x8e,623},

	{ "NoTuner", NoTuner, NOTUNER,
	  0,0,0x00,0x00,0x00,0x00,0x00},
	{ "Philips PAL_BG (FI1216 and compatibles)", Philips, PAL,
	  16*168.25,16*447.25,0xA0,0x90,0x30,0x8e,623},
	{ "Temic NTSC (4032 FY5)", TEMIC, NTSC,
	  16*157.25,16*463.25,0x02,0x04,0x01,0x8e,732},
	{ "Temic PAL_I (4062 FY5)", TEMIC, PAL_I,
	  16*170.00,16*450.00,0x02,0x04,0x01,0x8e,623},

 	{ "Temic NTSC (4036 FY5)", TEMIC, NTSC,
	  16*157.25,16*463.25,0xa0,0x90,0x30,0x8e,732},
        { "Alps HSBH1", TEMIC, NTSC,
	  16*137.25,16*385.25,0x01,0x02,0x08,0x8e,732},
        { "Alps TSBE1",TEMIC,PAL,
	  16*137.25,16*385.25,0x01,0x02,0x08,0x8e,732},
        { "Alps TSBB5", Alps, PAL_I, /* tested (UK UHF) with Modulartech MM205 */
	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,632},

        { "Alps TSBE5", Alps, PAL, /* untested - data sheet guess. Only IF differs. */
	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,622},
        { "Alps TSBC5", Alps, PAL, /* untested - data sheet guess. Only IF differs. */
	  16*133.25,16*351.25,0x01,0x02,0x08,0x8e,608},
	{ "Temic PAL_BG (4006FH5)", TEMIC, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
  	{ "Alps TSCH6",Alps,NTSC,
  	  16*137.25,16*385.25,0x14,0x12,0x11,0x8e,732},

  	{ "Temic PAL_DK (4016 FY5)",TEMIC,PAL,
  	  16*168.25,16*456.25,0xa0,0x90,0x30,0x8e,623},
  	{ "Philips NTSC_M (MK2)",Philips,NTSC,
  	  16*160.00,16*454.00,0xa0,0x90,0x30,0x8e,732},
        { "Temic PAL_I (4066 FY5)", TEMIC, PAL_I,
          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
        { "Temic PAL* auto (4006 FN5)", TEMIC, PAL,
          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},

        { "Temic PAL_BG (4009 FR5) or PAL_I (4069 FR5)", TEMIC, PAL,
          16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
        { "Temic NTSC (4039 FR5)", TEMIC, NTSC,
          16*158.00, 16*453.00, 0xa0,0x90,0x30,0x8e,732},
        { "Temic PAL/SECAM multi (4046 FM5)", TEMIC, PAL,
          16*169.00, 16*454.00, 0xa0,0x90,0x30,0x8e,623},
        { "Philips PAL_DK (FI1256 and compatibles)", Philips, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},

	{ "Philips PAL/SECAM multi (FQ1216ME)", Philips, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG PAL_I+FM (TAPC-I001D)", LGINNOTEK, PAL_I,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG PAL_I (TAPC-I701D)", LGINNOTEK, PAL_I,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG NTSC+FM (TPI8NSR01F)", LGINNOTEK, NTSC,
	  16*210.00,16*497.00,0xa0,0x90,0x30,0x8e,732},

	{ "LG PAL_BG+FM (TPI8PSB01D)", LGINNOTEK, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "LG PAL_BG (TPI8PSB11D)", LGINNOTEK, PAL,
	  16*170.00,16*450.00,0xa0,0x90,0x30,0x8e,623},
	{ "Temic PAL* auto + FM (4009 FN5)", TEMIC, PAL,
	  16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
	{ "SHARP NTSC_JP (2U5JF5540)", SHARP, NTSC, /* 940=16*58.75 NTSC@Japan */
	  16*137.25,16*317.25,0x01,0x02,0x08,0x8e,940 },

	{ "Samsung PAL TCPM9091PD27", Samsung, PAL,  /* from sourceforge v3tv */
          16*169,16*464,0xA0,0x90,0x30,0x8e,623},
	{ "MT20xx universal", Microtune,PAL|NTSC,
               0,0,0,0,0,0,0},
	{ "Temic PAL_BG (4106 FH5)", TEMIC, PAL,
          16*141.00, 16*464.00, 0xa0,0x90,0x30,0x8e,623},
	{ "Temic PAL_DK/SECAM_L (4012 FY5)", TEMIC, PAL,
          16*140.25, 16*463.25, 0x02,0x04,0x01,0x8e,623},

	{ "Temic NTSC (4136 FY5)", TEMIC, NTSC,
          16*158.00, 16*453.00, 0xa0,0x90,0x30,0x8e,732},
        { "LG PAL (newer TAPC series)", LGINNOTEK, PAL,
          16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,623},
	{ "Philips PAL/SECAM multi (FM1216ME MK3)", Philips, PAL,
	  16*160.00,16*442.00,0x01,0x02,0x04,0x8e,623 },
	{ "LG NTSC (newer TAPC series)", LGINNOTEK, NTSC,
          16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,732},

	{ "HITACHI V7-J180AT", HITACHI, NTSC,
	  16*170.00, 16*450.00, 0x01,0x02,0x08,0x8e,940 },
	{ "Philips PAL_MK (FI1216 MK)", Philips, PAL,
	  16*140.25,16*463.25,0x01,0xc2,0xcf,0x8e,623},
	{ "Philips 1236D ATSC/NTSC daul in",Philips,ATSC,
	  16*157.25,16*454.00,0xa0,0x90,0x30,0x8e,732},
        { "Philips NTSC MK3 (FM1236MK3 or FM1236/F)", Philips, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732},

        { "Philips 4 in 1 (ATI TV Wonder Pro/Conexant)", Philips, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732},
	{ "Microtune 4049 FM5",Microtune,PAL,
	  16*141.00,16*464.00,0xa0,0x90,0x30,0x8e,623},
	{ "Panasonic VP27s/ENGE4324D", Panasonic, NTSC,
	  16*160.00,16*454.00,0x01,0x02,0x08,0xce,940},
        { "LG NTSC (TAPE series)", LGINNOTEK, NTSC,
          16*160.00,16*442.00,0x01,0x02,0x04,0x8e,732 },

        { "Tenna TNF 8831 BGFF)", Philips, PAL,
          16*161.25,16*463.25,0xa0,0x90,0x30,0x8e,623},
	{ "Microtune 4042 FI5 ATSC/NTSC dual in", Microtune, NTSC,
	  16*162.00,16*457.00,0xa2,0x94,0x31,0x8e,732},
        { "TCL 2002N", TCL, NTSC,
          16*172.00,16*448.00,0x01,0x02,0x08,0x8e,732},
	{ "Philips PAL/SECAM_D (FM 1256 I-H3)", Philips, PAL,
	  16*160.00,16*442.00,0x01,0x02,0x04,0x8e,623 },

	{ "Thomson DDT 7610 ATSC/NTSC)", THOMSON, ATSC,
	  16*157.25,16*454.00,0x39,0x3a,0x3c,0x8e,732},
	{ "Philips FQ1286", Philips, NTSC,
	  16*160.00,16*454.00,0x41,0x42,0x04,0x8e,940}, // UHF band untested

};
#define TUNERS ARRAY_SIZE(tuners)

/* ---------------------------------------------------------------------- */

static int tuner_getstatus(struct i2c_client *c)
{
	unsigned char byte;

	struct tuner *t = i2c_get_clientdata(c);

        if (t->type == TUNER_MT2032)
		return 0;

	if (1 != i2c_master_recv(c,&byte,1))
		return 0;
	return byte;
}

#define TUNER_POR       0x80
#define TUNER_FL        0x40
#define TUNER_MODE      0x38
#define TUNER_AFC       0x07

#define TUNER_STEREO    0x10 /* radio mode */
#define TUNER_SIGNAL    0x07 /* radio mode */

static int tuner_signal(struct i2c_client *c)
{
	return (tuner_getstatus(c) & TUNER_SIGNAL)<<13;
}

static int tuner_stereo(struct i2c_client *c)
{
	return (tuner_getstatus (c) & TUNER_STEREO);
}

#if 0 /* unused */
static int tuner_islocked (struct i2c_client *c)
{
        return (tuner_getstatus (c) & TUNER_FL);
}

static int tuner_afcstatus (struct i2c_client *c)
{
        return (tuner_getstatus (c) & TUNER_AFC) - 2;
}

static int tuner_mode (struct i2c_client *c)
{
        return (tuner_getstatus (c) & TUNER_MODE) >> 3;
}
#endif

/* ---------------------------------------------------------------------- */

#define MT2032 0x04
#define MT2030 0x06
#define MT2040 0x07
#define MT2050 0x42

static char *microtune_part[] = {
	[ MT2030 ] = "MT2030",
	[ MT2032 ] = "MT2032",
	[ MT2040 ] = "MT2040",
	[ MT2050 ] = "MT2050",
};

// IsSpurInBand()?
static int mt2032_spurcheck(int f1, int f2, int spectrum_from,int spectrum_to)
{
	int n1=1,n2,f;

	f1=f1/1000; //scale to kHz to avoid 32bit overflows
	f2=f2/1000;
	spectrum_from/=1000;
	spectrum_to/=1000;

	dprintk("spurcheck f1=%d f2=%d  from=%d to=%d\n",f1,f2,spectrum_from,spectrum_to);

	do {
	    n2=-n1;
	    f=n1*(f1-f2);
	    do {
		n2--;
		f=f-f2;
		dprintk(" spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);

		if( (f>spectrum_from) && (f<spectrum_to))
			printk("mt2032 spurcheck triggered: %d\n",n1);
	    } while ( (f>(f2-spectrum_to)) || (n2>-5));
	    n1++;
	} while (n1<5);

	return 1;
}

static int mt2032_compute_freq(unsigned int rfin,
			       unsigned int if1, unsigned int if2,
			       unsigned int spectrum_from,
			       unsigned int spectrum_to,
			       unsigned char *buf,
			       int *ret_sel,
			       unsigned int xogc) //all in Hz
{
        unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
		desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;

        fref= 5250 *1000; //5.25MHz
	desired_lo1=rfin+if1;

	lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
        lo1n=lo1/8;
        lo1a=lo1-(lo1n*8);

        s=rfin/1000/1000+1090;

	if(optimize_vco) {
		if(s>1890) sel=0;
		else if(s>1720) sel=1;
		else if(s>1530) sel=2;
		else if(s>1370) sel=3;
		else sel=4; // >1090
	}
	else {
        	if(s>1790) sel=0; // <1958
        	else if(s>1617) sel=1;
        	else if(s>1449) sel=2;
        	else if(s>1291) sel=3;
        	else sel=4; // >1090
	}
	*ret_sel=sel;

        lo1freq=(lo1a+8*lo1n)*fref;

        dprintk("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
		rfin,lo1,lo1n,lo1a,sel,lo1freq);

        desired_lo2=lo1freq-rfin-if2;
        lo2=(desired_lo2)/fref;
        lo2n=lo2/8;
        lo2a=lo2-(lo2n*8);
        lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
        lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;

        dprintk("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
		rfin,lo2,lo2n,lo2a,lo2num,lo2freq);

        if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
                printk("mt2032: frequency parameters out of range: %d %d %d %d\n",
		       lo1a, lo1n, lo2a,lo2n);
                return(-1);
        }

	mt2032_spurcheck(lo1freq, desired_lo2,  spectrum_from, spectrum_to);
	// should recalculate lo1 (one step up/down)

	// set up MT2032 register map for transfer over i2c
	buf[0]=lo1n-1;
	buf[1]=lo1a | (sel<<4);
	buf[2]=0x86; // LOGC
	buf[3]=0x0f; //reserved
	buf[4]=0x1f;
	buf[5]=(lo2n-1) | (lo2a<<5);
 	if(rfin >400*1000*1000)
                buf[6]=0xe4;
        else
                buf[6]=0xf4; // set PKEN per rev 1.2
	buf[7]=8+xogc;
	buf[8]=0xc3; //reserved
	buf[9]=0x4e; //reserved
	buf[10]=0xec; //reserved
	buf[11]=(lo2num&0xff);
	buf[12]=(lo2num>>8) |0x80; // Lo2RST

	return 0;
}

static int mt2032_check_lo_lock(struct i2c_client *c)
{
	int try,lock=0;
	unsigned char buf[2];
	for(try=0;try<10;try++) {
		buf[0]=0x0e;
		i2c_master_send(c,buf,1);
		i2c_master_recv(c,buf,1);
		dprintk("mt2032 Reg.E=0x%02x\n",buf[0]);
		lock=buf[0] &0x06;

		if (lock==6)
			break;

		dprintk("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
		udelay(1000);
	}
        return lock;
}

static int mt2032_optimize_vco(struct i2c_client *c,int sel,int lock)
{
	unsigned char buf[2];
	int tad1;

	buf[0]=0x0f;
	i2c_master_send(c,buf,1);
	i2c_master_recv(c,buf,1);
	dprintk("mt2032 Reg.F=0x%02x\n",buf[0]);
	tad1=buf[0]&0x07;

	if(tad1 ==0) return lock;
	if(tad1 ==1) return lock;

	if(tad1==2) {
		if(sel==0)
			return lock;
		else sel--;
	}
	else {
		if(sel<4)
			sel++;
		else
			return lock;
	}

	dprintk("mt2032 optimize_vco: sel=%d\n",sel);

	buf[0]=0x0f;
	buf[1]=sel;
        i2c_master_send(c,buf,2);
	lock=mt2032_check_lo_lock(c);
	return lock;
}


static void mt2032_set_if_freq(struct i2c_client *c, unsigned int rfin,
			       unsigned int if1, unsigned int if2,
			       unsigned int from, unsigned int to)
{
	unsigned char buf[21];
	int lint_try,ret,sel,lock=0;
	struct tuner *t = i2c_get_clientdata(c);

	dprintk("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",rfin,if1,if2,from,to);

        buf[0]=0;
        ret=i2c_master_send(c,buf,1);
        i2c_master_recv(c,buf,21);

	buf[0]=0;
	ret=mt2032_compute_freq(rfin,if1,if2,from,to,&buf[1],&sel,t->xogc);
	if (ret<0)
		return;

        // send only the relevant registers per Rev. 1.2
        buf[0]=0;
        ret=i2c_master_send(c,buf,4);
        buf[5]=5;
        ret=i2c_master_send(c,buf+5,4);
        buf[11]=11;
        ret=i2c_master_send(c,buf+11,3);
        if(ret!=3)
                printk("mt2032_set_if_freq failed with %d\n",ret);

	// wait for PLLs to lock (per manual), retry LINT if not.
	for(lint_try=0; lint_try<2; lint_try++) {
		lock=mt2032_check_lo_lock(c);

		if(optimize_vco)
			lock=mt2032_optimize_vco(c,sel,lock);
		if(lock==6) break;

		printk("mt2032: re-init PLLs by LINT\n");
		buf[0]=7;
		buf[1]=0x80 +8+t->xogc; // set LINT to re-init PLLs
		i2c_master_send(c,buf,2);
		mdelay(10);
		buf[1]=8+t->xogc;
		i2c_master_send(c,buf,2);
        }

	if (lock!=6)
		printk("MT2032 Fatal Error: PLLs didn't lock.\n");

	buf[0]=2;
	buf[1]=0x20; // LOGC for optimal phase noise
	ret=i2c_master_send(c,buf,2);
	if (ret!=2)
		printk("mt2032_set_if_freq2 failed with %d\n",ret);
}


static void mt2032_set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	int if2,from,to;

	// signal bandwidth and picture carrier
	if (t->std & V4L2_STD_525_60) {
		// NTSC
		from = 40750*1000;
		to   = 46750*1000;
		if2  = 45750*1000;
	} else {
		// PAL
		from = 32900*1000;
		to   = 39900*1000;
		if2  = 38900*1000;
	}

        mt2032_set_if_freq(c, freq*62500 /* freq*1000*1000/16 */,
			   1090*1000*1000, if2, from, to);
}

static void mt2032_set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	int if2 = t->radio_if2;

	// per Manual for FM tuning: first if center freq. 1085 MHz
        mt2032_set_if_freq(c, freq*62500 /* freq*1000*1000/16 */,
			   1085*1000*1000,if2,if2,if2);
}

// Initalization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
static int mt2032_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
        unsigned char buf[21];
        int ret,xogc,xok=0;

	// Initialize Registers per spec.
        buf[1]=2; // Index to register 2
        buf[2]=0xff;
        buf[3]=0x0f;
        buf[4]=0x1f;
        ret=i2c_master_send(c,buf+1,4);

        buf[5]=6; // Index register 6
        buf[6]=0xe4;
        buf[7]=0x8f;
        buf[8]=0xc3;
        buf[9]=0x4e;
        buf[10]=0xec;
        ret=i2c_master_send(c,buf+5,6);

        buf[12]=13;  // Index register 13
        buf[13]=0x32;
        ret=i2c_master_send(c,buf+12,2);

        // Adjust XOGC (register 7), wait for XOK
        xogc=7;
        do {
		dprintk("mt2032: xogc = 0x%02x\n",xogc&0x07);
                mdelay(10);
                buf[0]=0x0e;
                i2c_master_send(c,buf,1);
                i2c_master_recv(c,buf,1);
                xok=buf[0]&0x01;
                dprintk("mt2032: xok = 0x%02x\n",xok);
                if (xok == 1) break;

                xogc--;
                dprintk("mt2032: xogc = 0x%02x\n",xogc&0x07);
                if (xogc == 3) {
                        xogc=4; // min. 4 per spec
                        break;
                }
                buf[0]=0x07;
                buf[1]=0x88 + xogc;
                ret=i2c_master_send(c,buf,2);
                if (ret!=2)
                        printk("mt2032_init failed with %d\n",ret);
        } while (xok != 1 );
	t->xogc=xogc;

	t->tv_freq    = mt2032_set_tv_freq;
	t->radio_freq = mt2032_set_radio_freq;
        return(1);
}

static void mt2050_set_antenna(struct i2c_client *c, unsigned char antenna)
{
       unsigned char buf[2];
       int ret;

       buf[0] = 6;
       buf[1] = antenna ? 0x11 : 0x10;
       ret=i2c_master_send(c,buf,2);
       dprintk("mt2050: enabled antenna connector %d\n", antenna);
}

static void mt2050_set_if_freq(struct i2c_client *c,unsigned int freq, unsigned int if2)
{
	unsigned int if1=1218*1000*1000;
	unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
	int ret;
	unsigned char buf[6];

	dprintk("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
		freq,if1,if2);

	f_lo1=freq+if1;
	f_lo1=(f_lo1/1000000)*1000000;

	f_lo2=f_lo1-freq-if2;
	f_lo2=(f_lo2/50000)*50000;

	lo1=f_lo1/4000000;
	lo2=f_lo2/4000000;

	f_lo1_modulo= f_lo1-(lo1*4000000);
	f_lo2_modulo= f_lo2-(lo2*4000000);

	num1=4*f_lo1_modulo/4000000;
	num2=4096*(f_lo2_modulo/1000)/4000;

	// todo spurchecks

	div1a=(lo1/12)-1;
	div1b=lo1-(div1a+1)*12;

	div2a=(lo2/8)-1;
	div2b=lo2-(div2a+1)*8;

	if (debug > 1) {
		printk("lo1 lo2 = %d %d\n", lo1, lo2);
		printk("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",num1,num2,div1a,div1b,div2a,div2b);
	}

	buf[0]=1;
	buf[1]= 4*div1b + num1;
	if(freq<275*1000*1000) buf[1] = buf[1]|0x80;

	buf[2]=div1a;
	buf[3]=32*div2b + num2/256;
	buf[4]=num2-(num2/256)*256;
	buf[5]=div2a;
	if(num2!=0) buf[5]=buf[5]|0x40;

	if (debug > 1) {
		int i;
		printk("bufs is: ");
		for(i=0;i<6;i++)
			printk("%x ",buf[i]);
		printk("\n");
	}

	ret=i2c_master_send(c,buf,6);
        if (ret!=6)
                printk("mt2050_set_if_freq failed with %d\n",ret);
}

static void mt2050_set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	unsigned int if2;

	if (t->std & V4L2_STD_525_60) {
		// NTSC
                if2 = 45750*1000;
        } else {
                // PAL
                if2 = 38900*1000;
        }
	if (V4L2_TUNER_DIGITAL_TV == t->mode) {
		// testing for DVB ...
		if2 = 36150*1000;
	}
	mt2050_set_if_freq(c, freq*62500, if2);
	mt2050_set_antenna(c, tv_antenna);
}

static void mt2050_set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	int if2 = t->radio_if2;

	mt2050_set_if_freq(c, freq*62500, if2);
	mt2050_set_antenna(c, radio_antenna);
}

static int mt2050_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
	unsigned char buf[2];
	int ret;

	buf[0]=6;
	buf[1]=0x10;
	ret=i2c_master_send(c,buf,2); //  power

	buf[0]=0x0f;
	buf[1]=0x0f;
	ret=i2c_master_send(c,buf,2); // m1lo

	buf[0]=0x0d;
	ret=i2c_master_send(c,buf,1);
	i2c_master_recv(c,buf,1);

	dprintk("mt2050: sro is %x\n",buf[0]);
	t->tv_freq    = mt2050_set_tv_freq;
	t->radio_freq = mt2050_set_radio_freq;
	return 0;
}

static int microtune_init(struct i2c_client *c)
{
	struct tuner *t = i2c_get_clientdata(c);
	char *name;
        unsigned char buf[21];
	int company_code;

	memset(buf,0,sizeof(buf));
	t->tv_freq    = NULL;
	t->radio_freq = NULL;
	name = "unknown";

        i2c_master_send(c,buf,1);
        i2c_master_recv(c,buf,21);
        if(debug) {
                int i;
                printk(KERN_DEBUG "tuner: MT2032 hexdump:\n");
                for(i=0;i<21;i++) {
                        printk(" %02x",buf[i]);
                        if(((i+1)%8)==0) printk(" ");
                        if(((i+1)%16)==0) printk("\n ");
                }
                printk("\n ");
        }
	company_code = buf[0x11] << 8 | buf[0x12];
        printk("tuner: microtune: companycode=%04x part=%02x rev=%02x\n",
	       company_code,buf[0x13],buf[0x14]);

#if 0
	/* seems to cause more problems than it solves ... */
	switch (company_code) {
	case 0x30bf:
	case 0x3cbf:
	case 0x3dbf:
	case 0x4d54:
	case 0x8e81:
	case 0x8e91:
		/* ok (?) */
		break;
	default:
		printk("tuner: microtune: unknown companycode\n");
		return 0;
	}
#endif

	if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
	    NULL != microtune_part[buf[0x13]])
		name = microtune_part[buf[0x13]];
	switch (buf[0x13]) {
	case MT2032:
		mt2032_init(c);
		break;
	case MT2050:
		mt2050_init(c);
		break;
	default:
		printk("tuner: microtune %s found, not (yet?) supported, sorry :-/\n",
		       name);
                return 0;
        }
	printk("tuner: microtune %s found, OK\n",name);
	return 0;
}

/* ---------------------------------------------------------------------- */

static void default_set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);
	u8 config;
	u16 div;
	struct tunertype *tun;
        unsigned char buffer[4];
	int rc;

	tun = &tuners[t->type];
	if (freq < tun->thresh1) {
		config = tun->VHF_L;
		dprintk("tv: VHF lowrange\n");
	} else if (freq < tun->thresh2) {
		config = tun->VHF_H;
		dprintk("tv: VHF high range\n");
	} else {
		config = tun->UHF;
		dprintk("tv: UHF range\n");
	}


	/* tv norm specific stuff for multi-norm tuners */
	switch (t->type) {
	case TUNER_PHILIPS_SECAM: // FI1216MF
		/* 0x01 -> ??? no change ??? */
		/* 0x02 -> PAL BDGHI / SECAM L */
		/* 0x04 -> ??? PAL others / SECAM others ??? */
		config &= ~0x02;
		if (t->std & V4L2_STD_SECAM)
			config |= 0x02;
		break;

	case TUNER_TEMIC_4046FM5:
		config &= ~0x0f;

		if (t->std & V4L2_STD_PAL_BG) {
			config |= TEMIC_SET_PAL_BG;

		} else if (t->std & V4L2_STD_PAL_I) {
			config |= TEMIC_SET_PAL_I;

		} else if (t->std & V4L2_STD_PAL_DK) {
			config |= TEMIC_SET_PAL_DK;

		} else if (t->std & V4L2_STD_SECAM_L) {
			config |= TEMIC_SET_PAL_L;

		}
		break;

	case TUNER_PHILIPS_FQ1216ME:
		config &= ~0x0f;

		if (t->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
			config |= PHILIPS_SET_PAL_BGDK;

		} else if (t->std & V4L2_STD_PAL_I) {
			config |= PHILIPS_SET_PAL_I;

		} else if (t->std & V4L2_STD_SECAM_L) {
			config |= PHILIPS_SET_PAL_L;

		}
		break;

	case TUNER_PHILIPS_ATSC:
		/* 0x00 -> ATSC antenna input 1 */
		/* 0x01 -> ATSC antenna input 2 */
		/* 0x02 -> NTSC antenna input 1 */
		/* 0x03 -> NTSC antenna input 2 */
		config &= ~0x03;
		if (!(t->std & V4L2_STD_ATSC))
			config |= 2;
		/* FIXME: input */
		break;

	case TUNER_MICROTUNE_4042FI5:
		/* Set the charge pump for fast tuning */
		tun->config |= 0x40;
		break;
	}

	/*
	 * Philips FI1216MK2 remark from specification :
	 * for channel selection involving band switching, and to ensure
	 * smooth tuning to the desired channel without causing
	 * unnecessary charge pump action, it is recommended to consider
	 * the difference between wanted channel frequency and the
	 * current channel frequency.  Unnecessary charge pump action
	 * will result in very low tuning voltage which may drive the
	 * oscillator to extreme conditions.
	 *
	 * Progfou: specification says to send config data before
	 * frequency in case (wanted frequency < current frequency).
	 */

	div=freq + tun->IFPCoff;
	if (t->type == TUNER_PHILIPS_SECAM && freq < t->freq) {
		buffer[0] = tun->config;
		buffer[1] = config;
		buffer[2] = (div>>8) & 0x7f;
		buffer[3] = div      & 0xff;
	} else {
		buffer[0] = (div>>8) & 0x7f;
		buffer[1] = div      & 0xff;
		buffer[2] = tun->config;
		buffer[3] = config;
	}
	dprintk("tuner: tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
		buffer[0],buffer[1],buffer[2],buffer[3]);

        if (4 != (rc = i2c_master_send(c,buffer,4)))
                printk("tuner: i2c i/o error: rc == %d (should be 4)\n",rc);

	if (t->type == TUNER_MICROTUNE_4042FI5) {
		// FIXME - this may also work for other tuners
		unsigned long timeout = jiffies + msecs_to_jiffies(1);
		u8 status_byte = 0;

		/* Wait until the PLL locks */
		for (;;) {
			if (time_after(jiffies,timeout))
				return;
			if (1 != (rc = i2c_master_recv(c,&status_byte,1))) {
				dprintk("tuner: i2c i/o read error: rc == %d (should be 1)\n",rc);
				break;
			}
			/* bit 6 is PLL locked indicator */
			if (status_byte & 0x40)
				break;
			udelay(10);
		}

		/* Set the charge pump for optimized phase noise figure */
		tun->config &= ~0x40;
		buffer[0] = (div>>8) & 0x7f;
		buffer[1] = div      & 0xff;
		buffer[2] = tun->config;
		buffer[3] = config;
		dprintk("tuner: tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
			buffer[0],buffer[1],buffer[2],buffer[3]);

		if (4 != (rc = i2c_master_send(c,buffer,4)))
			dprintk("tuner: i2c i/o error: rc == %d (should be 4)\n",rc);
	}
}

static void default_set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tunertype *tun;
	struct tuner *t = i2c_get_clientdata(c);
        unsigned char buffer[4];
	unsigned div;
	int rc;

	tun=&tuners[t->type];
	div = freq + (int)(16*10.7);
	buffer[2] = tun->config;

	switch (t->type) {
	case TUNER_PHILIPS_FM1216ME_MK3:
	case TUNER_PHILIPS_FM1236_MK3:
		buffer[3] = 0x19;
		break;
	case TUNER_PHILIPS_FM1256_IH3:
		div = (20 * freq)/16 + 333 * 2;
	        buffer[2] = 0x80;
		buffer[3] = 0x19;
		break;
	case TUNER_LG_PAL_FM:
		buffer[3] = 0xa5;
		break;
	default:
		buffer[3] = 0xa4;
		break;
	}
        buffer[0] = (div>>8) & 0x7f;
        buffer[1] = div      & 0xff;

	dprintk("tuner: radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
		buffer[0],buffer[1],buffer[2],buffer[3]);

        if (4 != (rc = i2c_master_send(c,buffer,4)))
                printk("tuner: i2c i/o error: rc == %d (should be 4)\n",rc);
}

/* ---------------------------------------------------------------------- */

// Set tuner frequency,  freq in Units of 62.5kHz = 1/16MHz
static void set_tv_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type == UNSET) {
		printk("tuner: tuner type not set\n");
		return;
	}
	if (NULL == t->tv_freq) {
		printk("tuner: Huh? tv_set is NULL?\n");
		return;
	}
	if (freq < tv_range[0]*16 || freq > tv_range[1]*16) {
		/* FIXME: better do that chip-specific, but
		   right now we don't have that in the config
		   struct and this way is still better than no
		   check at all */
		printk("tuner: TV freq (%d.%02d) out of range (%d-%d)\n",
		       freq/16,freq%16*100/16,tv_range[0],tv_range[1]);
		return;
	}
	t->tv_freq(c,freq);
}

static void set_radio_freq(struct i2c_client *c, unsigned int freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type == UNSET) {
		printk("tuner: tuner type not set\n");
		return;
	}
	if (NULL == t->radio_freq) {
		printk("tuner: no radio tuning for this one, sorry.\n");
		return;
	}
	if (freq < radio_range[0]*16 || freq > radio_range[1]*16) {
		printk("tuner: radio freq (%d.%02d) out of range (%d-%d)\n",
		       freq/16,freq%16*100/16,
		       radio_range[0],radio_range[1]);
		return;
	}
	t->radio_freq(c,freq);
}

static void set_freq(struct i2c_client *c, unsigned long freq)
{
	struct tuner *t = i2c_get_clientdata(c);

	switch (t->mode) {
	case V4L2_TUNER_RADIO:
		dprintk("tuner: radio freq set to %lu.%02lu\n",
			freq/16,freq%16*100/16);
		set_radio_freq(c,freq);
		break;
	case V4L2_TUNER_ANALOG_TV:
	case V4L2_TUNER_DIGITAL_TV:
		dprintk("tuner: tv freq set to %lu.%02lu\n",
			freq/16,freq%16*100/16);
		set_tv_freq(c, freq);
		break;
	}
	t->freq = freq;
}

static void set_type(struct i2c_client *c, unsigned int type, char *source)
{
	struct tuner *t = i2c_get_clientdata(c);

	if (t->type != UNSET && t->type != TUNER_ABSENT) {
		if (t->type != type)
			printk("tuner: type already set to %d, "
			       "ignoring request for %d\n", t->type, type);
		return;
	}
	if (type >= TUNERS)
		return;

	t->type = type;
	printk("tuner: type set to %d (%s) by %s\n",
	       t->type,tuners[t->type].name, source);
	strlcpy(c->name, tuners[t->type].name, sizeof(c->name));

	switch (t->type) {
	case TUNER_MT2032:
		microtune_init(c);
		break;
	default:
		t->tv_freq    = default_set_tv_freq;
		t->radio_freq = default_set_radio_freq;
		break;
	}
}

static char pal[] = "-";
module_param_string(pal, pal, 0644, sizeof(pal));

static int tuner_fixup_std(struct tuner *t)
{
	if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
		/* get more precise norm info from insmod option */
		switch (pal[0]) {
		case 'b':
		case 'B':
		case 'g':
		case 'G':
			dprintk("insmod fixup: PAL => PAL-BG\n");
			t->std = V4L2_STD_PAL_BG;
			break;
		case 'i':
		case 'I':
			dprintk("insmod fixup: PAL => PAL-I\n");
			t->std = V4L2_STD_PAL_I;
			break;
		case 'd':
		case 'D':
		case 'k':
		case 'K':
			dprintk("insmod fixup: PAL => PAL-DK\n");
			t->std = V4L2_STD_PAL_DK;
			break;
		}
	}
	return 0;
}

/* ---------------------------------------------------------------------- */

static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
{
	struct tuner *t;
	struct i2c_client *client;

	if (this_adap > 0)
		return -1;
	this_adap++;

        client_template.adapter = adap;
        client_template.addr = addr;

        printk("tuner: chip found at addr 0x%x i2c-bus %s\n",
	       addr<<1, adap->name);

        if (NULL == (client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL)))
                return -ENOMEM;
        memcpy(client,&client_template,sizeof(struct i2c_client));
        t = kmalloc(sizeof(struct tuner),GFP_KERNEL);
        if (NULL == t) {
                kfree(client);
                return -ENOMEM;
        }
        memset(t,0,sizeof(struct tuner));
	i2c_set_clientdata(client, t);
	t->type       = UNSET;
	t->radio_if2  = 10700*1000; // 10.7MHz - FM radio

        i2c_attach_client(client);
	if (type < TUNERS) {
		set_type(client, type, "insmod option");
		printk("tuner: The type=<n> insmod option will go away soon.\n");
		printk("tuner: Please use the tuner=<n> option provided by\n");
		printk("tuner: tv aard core driver (bttv, saa7134, ...) instead.\n");
	}
	return 0;
}

static int tuner_probe(struct i2c_adapter *adap)
{
	if (0 != addr) {
		normal_i2c_range[0] = addr;
		normal_i2c_range[1] = addr;
	}
	this_adap = 0;

#ifdef I2C_CLASS_TV_ANALOG
	if (adap->class & I2C_CLASS_TV_ANALOG)
		return i2c_probe(adap, &addr_data, tuner_attach);
#else
	switch (adap->id) {
	case I2C_ALGO_BIT | I2C_HW_SMBUS_VOODOO3:
	case I2C_ALGO_BIT | I2C_HW_B_BT848:
	case I2C_ALGO_BIT | I2C_HW_B_RIVA:
	case I2C_ALGO_SAA7134:
	case I2C_ALGO_SAA7146:
		return i2c_probe(adap, &addr_data, tuner_attach);
		break;
	}
#endif
	return 0;
}

static int tuner_detach(struct i2c_client *client)
{
	struct tuner *t = i2c_get_clientdata(client);

	i2c_detach_client(client);
	kfree(t);
	kfree(client);
	return 0;
}

#define SWITCH_V4L2	if (!t->using_v4l2 && debug) \
		          printk("tuner: switching to v4l2\n"); \
	                  t->using_v4l2 = 1;
#define CHECK_V4L2	if (t->using_v4l2) { if (debug) \
			  printk("tuner: ignore v4l1 call\n"); \
		          return 0; }

static int
tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
{
	struct tuner *t = i2c_get_clientdata(client);
        unsigned int *iarg = (int*)arg;

        switch (cmd) {

	/* --- configuration --- */
	case TUNER_SET_TYPE:
		set_type(client,*iarg,client->adapter->name);
		break;
	case AUDC_SET_RADIO:
		if (V4L2_TUNER_RADIO != t->mode) {
			set_tv_freq(client,400 * 16);
			t->mode = V4L2_TUNER_RADIO;
		}
		break;
	case AUDC_CONFIG_PINNACLE:
		switch (*iarg) {
		case 2:
			dprintk("tuner: pinnacle pal\n");
			t->radio_if2 = 33300 * 1000;
			break;
		case 3:
			dprintk("tuner: pinnacle ntsc\n");
			t->radio_if2 = 41300 * 1000;
			break;
		}
                break;

	/* --- v4l ioctls --- */
	/* take care: bttv does userspace copying, we'll get a
	   kernel pointer here... */
	case VIDIOCSCHAN:
	{
		static const v4l2_std_id map[] = {
			[ VIDEO_MODE_PAL   ] = V4L2_STD_PAL,
			[ VIDEO_MODE_NTSC  ] = V4L2_STD_NTSC_M,
			[ VIDEO_MODE_SECAM ] = V4L2_STD_SECAM,
			[ 4 /* bttv */     ] = V4L2_STD_PAL_M,
			[ 5 /* bttv */     ] = V4L2_STD_PAL_N,
			[ 6 /* bttv */     ] = V4L2_STD_NTSC_M_JP,
		};
		struct video_channel *vc = arg;

		CHECK_V4L2;
		t->mode = V4L2_TUNER_ANALOG_TV;
		if (vc->norm < ARRAY_SIZE(map))
			t->std = map[vc->norm];
		tuner_fixup_std(t);
		if (t->freq)
			set_tv_freq(client,t->freq);
		return 0;
	}
	case VIDIOCSFREQ:
	{
		unsigned long *v = arg;

		CHECK_V4L2;
		set_freq(client,*v);
		return 0;
	}
	case VIDIOCGTUNER:
	{
		struct video_tuner *vt = arg;

		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode)
			vt->signal = tuner_signal(client);
		return 0;
	}
	case VIDIOCGAUDIO:
	{
		struct video_audio *va = arg;

		CHECK_V4L2;
		if (V4L2_TUNER_RADIO == t->mode)
			va->mode = (tuner_stereo(client) ? VIDEO_SOUND_STEREO : VIDEO_SOUND_MONO);
		return 0;
	}

	case VIDIOC_S_STD:
	{
		v4l2_std_id *id = arg;

		SWITCH_V4L2;
		t->mode = V4L2_TUNER_ANALOG_TV;
		t->std = *id;
		tuner_fixup_std(t);
		if (t->freq)
			set_freq(client,t->freq);
		break;
	}
	case VIDIOC_S_FREQUENCY:
	{
		struct v4l2_frequency *f = arg;

		SWITCH_V4L2;
		if (V4L2_TUNER_RADIO == f->type &&
		    V4L2_TUNER_RADIO != t->mode)
			set_tv_freq(client,400*16);
		t->mode  = f->type;
		t->freq  = f->frequency;
		set_freq(client,t->freq);
		break;
	}
	case VIDIOC_G_TUNER:
	{
		struct v4l2_tuner *tuner = arg;

		SWITCH_V4L2;
		if (V4L2_TUNER_RADIO == t->mode)
			tuner->signal = tuner_signal(client);
		break;
	}
	default:
		/* nothing */
		break;
	}

	return 0;
}

static int tuner_suspend(struct device * dev, u32 state, u32 level)
{
	dprintk("tuner: suspend\n");
	/* FIXME: power down ??? */
	return 0;
}

static int tuner_resume(struct device * dev, u32 level)
{
	struct i2c_client *c = container_of(dev, struct i2c_client, dev);
	struct tuner *t = i2c_get_clientdata(c);

	dprintk("tuner: resume\n");
	if (t->freq)
		set_freq(c,t->freq);
	return 0;
}

/* ----------------------------------------------------------------------- */

static struct i2c_driver driver = {
	.owner          = THIS_MODULE,
        .name           = "i2c TV tuner driver",
        .id             = I2C_DRIVERID_TUNER,
        .flags          = I2C_DF_NOTIFY,
        .attach_adapter = tuner_probe,
        .detach_client  = tuner_detach,
        .command        = tuner_command,
	.driver = {
		.suspend = tuner_suspend,
		.resume  = tuner_resume,
	},
};
static struct i2c_client client_template =
{
	I2C_DEVNAME("(tuner unset)"),
	.flags      = I2C_CLIENT_ALLOW_USE,
        .driver     = &driver,
};

static int __init tuner_init_module(void)
{
	return i2c_add_driver(&driver);
}

static void __exit tuner_cleanup_module(void)
{
	i2c_del_driver(&driver);
}

module_init(tuner_init_module);
module_exit(tuner_cleanup_module);

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Lines 990-996 static int tda9874a_initialize(struct CH Link Here

(-)linux-2.6.11.orig/drivers/media/video/tvaudio.c (-1 / +1 lines)
990	{	990	{
991	if (tda9874a_SIF > 2)	991	if (tda9874a_SIF > 2)
992	tda9874a_SIF = 1;	992	tda9874a_SIF = 1;
993	if (tda9874a_STD >= 8)	993	if (tda9874a_STD > 8)
994	tda9874a_STD = 0;	994	tda9874a_STD = 0;
995	if(tda9874a_AMSEL > 1)	995	if(tda9874a_AMSEL > 1)
996	tda9874a_AMSEL = 0;	996	tda9874a_AMSEL = 0;






#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/videodev.h>
#include <linux/i2c.h>

#include <media/tuner.h>

	{ 0x00000007, "PAL(B/G)" },
	{ 0x00001000, "NTSC(M)" },
	{ 0x00000010, "PAL(I)" },
	{ 0x00400000, "SECAM(L/L´)" },
	{ 0x00000e00, "PAL(D/K)" },
	{ 0x03000000, "ATSC Digital" },
};

	{ TUNER_ABSENT,        "TCL MFPE05 2"},
	/* 90-99 */
	{ TUNER_ABSENT,        "LG TALN H202T"},
	{ TUNER_PHILIPS_FQ1216AME_MK4, "Philips FQ1216AME MK4"},
	{ TUNER_PHILIPS_FQ1236A_MK4, "Philips FQ1236A MK4"},
	{ TUNER_ABSENT,        "Philips FQ1286A MK4"},
	{ TUNER_ABSENT,        "Philips FQ1216ME MK5"},
	{ TUNER_ABSENT,        "Philips FQ1236 MK5"},
	{ TUNER_ABSENT,        "Unspecified"},
	{ TUNER_LG_PAL_TAPE,   "LG PAL (TAPE Series)"},
};

static char *sndtype[] = {

                case 61: //PNPEnv_TUNER_TAPE_M001D_MK3:
                case 78: //PNPEnv_TUNER_TDA8275C1_8290_FM:
                case 89: //PNPEnv_TUNER_TCL_MFPE05_2:
                case 92: //PNPEnv_TUNER_PHILIPS_FQ1236A_MK4:
                    return 1;
        }
        return 0;

	** if packet[0] & f8 == f8, then EOD and packet[1] == checksum
	**
	** In our (ivtv) case we're interested in the following:
	** tuner type: tag [00].05 or [0a].01 (index into hauppauge_tuner)
	** tuner fmts: tag [00].04 or [0a].00 (bitmask index into hauppauge_tuner_fmt)
	** radio:      tag [00].{last} or [0e].00  (bitmask.  bit2=FM)
	** audio proc: tag [02].01 or [05].00 (lower nibble indexes lut?)


	** # of inputs/outputs ???
	*/

	int i, j, len, done, beenhere, tag, tuner = 0, t_format = 0;
	char *t_name = NULL, *t_fmt_name = NULL;

	dprintk(1, "%s\n",__FUNCTION__);
	tvee->revision = done = len = beenhere = 0;
	for (i = 0; !done && i < 256; i += len) {
		dprintk(2, "processing pos = %02x (%02x, %02x)\n",
			i, eeprom_data[i], eeprom_data[i + 1]);

				(eeprom_data[i+7] << 16);
			break;
		case 0x0a:
			if(beenhere == 0) {
				tuner = eeprom_data[i+2];
				t_format = eeprom_data[i+1];
				beenhere = 1;
				break;
			} else {
				break;
			}
		case 0x0e:
			tvee->has_radio = eeprom_data[i+1];
			break;




/*
 * $Id: video-buf.c,v 1.18 2005/02/24 13:32:30 kraxel Exp $
 *
 * generic helper functions for video4linux capture buffers, to handle
 * memory management and PCI DMA.  Right now bttv + saa7134 use it.

		return -ENOMEM;
	}

	if (!dma->bus_addr) {
		dma->sglen = pci_map_sg(dev,dma->sglist,dma->nr_pages,
					dma->direction);
		if (0 == dma->sglen) {
			printk(KERN_WARNING
			       "%s: pci_map_sg failed\n",__FUNCTION__);
			kfree(dma->sglist);
			dma->sglist = NULL;
			dma->sglen = 0;
			return -EIO;
		}
	}
	return 0;
}


Lines 41-46 Link Here

(-)linux-2.6.11.orig/drivers/media/video/zoran_card.c (-1 / +5 lines)
41	#include <linux/spinlock.h>	41	#include <linux/spinlock.h>
42	#include <linux/sem.h>	42	#include <linux/sem.h>
43	#include <linux/kmod.h>	43	#include <linux/kmod.h>
		44	#include <linux/wait.h>
44		45
45	#include <linux/pci.h>	46	#include <linux/pci.h>
46	#include <linux/interrupt.h>	47	#include <linux/interrupt.h>
Lines 968-973 zoran_open_init_params (struct zoran *zr Link Here
968	static void __devinit	969	static void __devinit
969	test_interrupts (struct zoran *zr)	970	test_interrupts (struct zoran *zr)
970	{	971	{
		972	DEFINE_WAIT(wait);
971	int timeout, icr;	973	int timeout, icr;
972		974
973	clear_interrupt_counters(zr);	975	clear_interrupt_counters(zr);
Lines 975-981 test_interrupts (struct zoran *zr) Link Here
975	zr->testing = 1;	977	zr->testing = 1;
976	icr = btread(ZR36057_ICR);	978	icr = btread(ZR36057_ICR);
977	btwrite(0x78000000 \| ZR36057_ICR_IntPinEn, ZR36057_ICR);	979	btwrite(0x78000000 \| ZR36057_ICR_IntPinEn, ZR36057_ICR);
978	timeout = interruptible_sleep_on_timeout(&zr->test_q, 1 * HZ);	980	prepare_to_wait(&zr->test_q, &wait, TASK_INTERRUPTIBLE);
		981	timeout = schedule_timeout(HZ);
		982	finish_wait(&zr->test_q, &wait);
979	btwrite(0, ZR36057_ICR);	983	btwrite(0, ZR36057_ICR);
980	btwrite(0x78000000, ZR36057_ISR);	984	btwrite(0x78000000, ZR36057_ISR);
981	zr->testing = 0;	985	zr->testing = 0;




#include <linux/video_decoder.h>
#include <linux/video_encoder.h>
#include <linux/delay.h>
#include <linux/wait.h>

#include <asm/io.h>


	if (!zr->v4l_memgrab_active)
		return 0;

	wait_event_interruptible(zr->v4l_capq,
			(zr->v4l_pend_tail == zr->v4l_pend_head));
	if (signal_pending(current))
		return -ERESTARTSYS;
	}

	spin_lock_irqsave(&zr->spinlock, flags);
	zr36057_set_memgrab(zr, 0);




#include <linux/slab.h>
#include <linux/pci.h>
#include <linux/vmalloc.h>
#include <linux/wait.h>
#include <linux/byteorder/generic.h>

#include <linux/interrupt.h>

	}

	/* wait on this buffer to get ready */
	if (!wait_event_interruptible_timeout(zr->v4l_capq,
				(zr->v4l_buffers.buffer[frame].state != BUZ_STATE_PEND),
				10*HZ))
		return -ETIME;
	if (signal_pending(current))
		return -ERESTARTSYS;

	/* buffer should now be in BUZ_STATE_DONE */
	if (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_DONE)

	struct zoran_fh *fh = file->private_data;
	struct zoran *zr = fh->zr;
	unsigned long flags;
	int frame;

	if (fh->jpg_buffers.active == ZORAN_FREE) {
		dprintk(1,

			ZR_DEVNAME(zr));
		return -EINVAL;
	}
	if (!wait_event_interruptible_timeout(zr->jpg_capq,
			(zr->jpg_que_tail != zr->jpg_dma_tail ||
			 zr->jpg_dma_tail == zr->jpg_dma_head),
			10*HZ)) {
		int isr;
		    interruptible_sleep_on_timeout(&zr->jpg_capq, 10 * HZ);
		if (!timeout) {
			int isr;

		btand(~ZR36057_JMC_Go_en, ZR36057_JMC);
		udelay(1);
		zr->codec->control(zr->codec, CODEC_G_STATUS,
					   sizeof(isr), &isr);
		dprintk(1,
			KERN_ERR
			"%s: jpg_sync() - timeout: codec isr=0x%02x\n",
			ZR_DEVNAME(zr), isr);

		return -ETIME;

		} else if (signal_pending(current))
			return -ERESTARTSYS;
	}
	if (signal_pending(current))
		return -ERESTARTSYS;

	spin_lock_irqsave(&zr->spinlock, flags);





#include <linux/mm.h>
#include <linux/pci.h>
#include <linux/signal.h>
#include <linux/wait.h>
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/page.h>

		zoran_cap(ztv, 1);

		/* wait till this buffer gets grabbed */
		wait_event_interruptible(ztv->grabq,
				(unused->status != FBUFFER_BUSY));
		/* see if a signal did it */
		if (signal_pending(current))
			return -EINTR;
		}
		done = unused;
	}
	else

			return -EINVAL;
		 case FBUFFER_BUSY:
			/* wait till this buffer gets grabbed */
			wait_event_interruptible(ztv->grabq,
					(ztv->grabinfo[i].status != FBUFFER_BUSY));
			/* see if a signal did it */
			if (signal_pending(current))
				return -EINTR;
			}
			/* don't fall through; a DONE buffer is not UNUSED */
			break;
		 case FBUFFER_DONE:

		zoran_cap(ztv, 1);

		/* wait till this buffer gets grabbed */
		wait_event_interruptible(ztv->vbiq,
				(unused->status != FBUFFER_BUSY));
		/* see if a signal did it */
		if (signal_pending(current))
			return -EINTR;
		}
		done = unused;
	}
	else





	  If unsure, say N.

config CHR_DEV_SCH
	tristate "SCSI media changer support"
	depends on SCSI
	---help---
	  This is a driver for SCSI media changers.  Most common devices are
	  tape libraries and MOD/CDROM jukeboxes.  *Real* jukeboxes, you
	  don't need this for those tiny 6-slot cdrom changers.  Media
	  changers are listed as "Type: Medium Changer" in /proc/scsi/scsi.
	  If you have such hardware and want to use it with linux, say Y
	  here.  Check <file:Documentation/scsi-changer.txt> for details.
	
	  If you want to compile this as a module ( = code which can be
	  inserted in and removed from the running kernel whenever you want),
	  say M here and read <file:Documentation/modules.txt> and
	  <file:Documentation/scsi.txt>. The module will be called ch.o.
	  If unsure, say N.
	

comment "Some SCSI devices (e.g. CD jukebox) support multiple LUNs"
	depends on SCSI


Lines 141-146 obj-$(CONFIG_CHR_DEV_OSST) += osst.o Link Here

(-)linux-2.6.11.orig/drivers/scsi/Makefile (+1 lines)
141	obj-$(CONFIG_BLK_DEV_SD) += sd_mod.o	141	obj-$(CONFIG_BLK_DEV_SD) += sd_mod.o
142	obj-$(CONFIG_BLK_DEV_SR) += sr_mod.o	142	obj-$(CONFIG_BLK_DEV_SR) += sr_mod.o
143	obj-$(CONFIG_CHR_DEV_SG) += sg.o	143	obj-$(CONFIG_CHR_DEV_SG) += sg.o
		144	obj-$(CONFIG_CHR_DEV_SCH) += ch.o
144		145
145	scsi_mod-y += scsi.o hosts.o scsi_ioctl.o constants.o \	146	scsi_mod-y += scsi.o hosts.o scsi_ioctl.o constants.o \
146	scsicam.o scsi_error.o scsi_lib.o \	147	scsicam.o scsi_error.o scsi_lib.o \




/*
 * SCSI Media Changer device driver for Linux 2.6
 *
 *     (c) 1996-2003 Gerd Knorr <kraxel@bytesex.org>
 *
 */

#define VERSION "0.24"

#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/blkdev.h>
#include <linux/completion.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/ioctl32.h>
#include <linux/compat.h>
#include <linux/chio.h>			/* here are all the ioctls */

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_ioctl.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_request.h>
#include <scsi/scsi_dbg.h>

#define CH_DT_MAX       16
#define CH_TYPES        8

MODULE_DESCRIPTION("device driver for scsi media changer devices");
MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org>");
MODULE_LICENSE("GPL");

static int init = 1;
module_param(init, int, 0444);
MODULE_PARM_DESC(init, \
    "initialize element status on driver load (default: on)");

static int timeout_move = 300;
module_param(timeout_move, int, 0644);
MODULE_PARM_DESC(timeout_move,"timeout for move commands "
		 "(default: 300 seconds)");

static int timeout_init = 3600;
module_param(timeout_init, int, 0644);
MODULE_PARM_DESC(timeout_init,"timeout for INITIALIZE ELEMENT STATUS "
		 "(default: 3600 seconds)");

static int verbose = 1;
module_param(verbose, int, 0644);
MODULE_PARM_DESC(verbose,"be verbose (default: on)");

static int debug = 0;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug,"enable/disable debug messages, also prints more "
		 "detailed sense codes on scsi errors (default: off)");

static int dt_id[CH_DT_MAX] = { [ 0 ... (CH_DT_MAX-1) ] = -1 };
static int dt_lun[CH_DT_MAX];
module_param_array(dt_id,  int, NULL, 0444);
module_param_array(dt_lun, int, NULL, 0444);

/* tell the driver about vendor-specific slots */
static int vendor_firsts[CH_TYPES-4];
static int vendor_counts[CH_TYPES-4];
module_param_array(vendor_firsts, int, NULL, 0444);
module_param_array(vendor_counts, int, NULL, 0444);

static char *vendor_labels[CH_TYPES-4] = {
	"v0", "v1", "v2", "v3"
};
// module_param_string_array(vendor_labels, NULL, 0444);

#define dprintk(fmt, arg...)    if (debug) \
        printk(KERN_DEBUG "%s: " fmt, ch->name, ##arg)
#define vprintk(fmt, arg...)    if (verbose) \
        printk(KERN_INFO "%s: " fmt, ch->name, ##arg)

/* ------------------------------------------------------------------- */

#define MAX_RETRIES   1

static int  ch_probe(struct device *);
static int  ch_remove(struct device *);
static int  ch_open(struct inode * inode, struct file * filp);
static int  ch_release(struct inode * inode, struct file * filp);
static int  ch_ioctl(struct inode * inode, struct file * filp,
		     unsigned int cmd, unsigned long arg);
static long ch_ioctl_compat(struct file * filp,
			    unsigned int cmd, unsigned long arg);

typedef struct {
	struct list_head    list;
	int                 minor;
	char                name[8];
	struct scsi_device  *device;
	struct scsi_device  **dt;        /* ptrs to data transfer elements */
	u_int               firsts[CH_TYPES];
	u_int               counts[CH_TYPES];
	u_int               unit_attention;
	u_int		    voltags;
	struct semaphore    lock;
} scsi_changer;

static LIST_HEAD(ch_devlist);
static spinlock_t ch_devlist_lock = SPIN_LOCK_UNLOCKED;
static int ch_devcount;

struct scsi_driver ch_template =
{
	.owner     	= THIS_MODULE,
	.gendrv     	= {
		.name	= "ch",
		.probe  = ch_probe,
		.remove = ch_remove,
	},
};

static struct file_operations changer_fops =
{
	.owner        = THIS_MODULE,
	.open         = ch_open,
	.release      = ch_release,
	.ioctl        = ch_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = ch_ioctl_compat,
#endif
};

static struct {
	unsigned char  sense;
	unsigned char  asc;
	unsigned char  ascq;
	int	       errno;
} err[] = {
/* Just filled in what looks right. Hav'nt checked any standard paper for
   these errno assignments, so they may be wrong... */
	{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x21,
		.ascq   = 0x01,
		.errno  = EBADSLT, /* Invalid element address */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x28,
		.ascq   = 0x01,
		.errno  = EBADE,   /* Import or export element accessed */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x3B,
		.ascq   = 0x0D,
		.errno  = EXFULL,  /* Medium destination element full */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x3B,
		.ascq   = 0x0E,
		.errno  = EBADE,   /* Medium source element empty */
	},{
		.sense  = ILLEGAL_REQUEST,
		.asc    = 0x20,
		.ascq   = 0x00,
		.errno  = EBADRQC, /* Invalid command operation code */
	},{
	        /* end of list */
	}
};

/* ------------------------------------------------------------------- */

static int ch_find_errno(unsigned char *sense_buffer)
{
	int i,errno = 0;

	/* Check to see if additional sense information is available */
	if (sense_buffer[7]  > 5 &&
	    sense_buffer[12] != 0) {
		for (i = 0; err[i].errno != 0; i++) {
			if (err[i].sense == sense_buffer[ 2] &&
			    err[i].asc   == sense_buffer[12] &&
			    err[i].ascq  == sense_buffer[13]) {
				errno = -err[i].errno;
				break;
			}
		}
	}
	if (errno == 0)
		errno = -EIO;
	return errno;
}

static void
ch_request_done(struct scsi_cmnd *sc)
{
	sc->request->rq_status = RQ_SCSI_DONE; /* Busy, but indicate request done */
        if (sc->request->waiting != NULL)
		complete(sc->request->waiting);
}

static int
ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
	   void *buffer, unsigned buflength)
{
	int errno, retries = 0, timeout;
	DECLARE_COMPLETION(wait);
	struct scsi_request *sr;
	
	sr = scsi_allocate_request(ch->device, GFP_KERNEL);
	if (NULL == sr)
		return -ENOMEM;

 retry:
	errno = 0;
	if (debug) {
		dprintk("command: ");
		__scsi_print_command(cmd);
	}

	sr->sr_request->waiting = &wait;
	timeout = (cmd[0] == INITIALIZE_ELEMENT_STATUS)
		? timeout_init : timeout_move;
	scsi_do_req(sr, cmd, buffer, buflength, ch_request_done,
		    timeout * HZ, MAX_RETRIES);
	wait_for_completion(&wait);
	sr->sr_request->waiting = NULL;

	dprintk("result: 0x%x\n",sr->sr_result);
	if (driver_byte(sr->sr_result) != 0) {
		if (debug)
			scsi_print_req_sense(ch->name, sr);
		errno = ch_find_errno(sr->sr_sense_buffer);

		switch(sr->sr_sense_buffer[2] & 0xf) {
		case UNIT_ATTENTION:
			ch->unit_attention = 1;
			if (retries++ < 3)
				goto retry;
			break;
		}
	}
	scsi_release_request(sr);
	return errno;
}

/* ------------------------------------------------------------------------ */

static int
ch_elem_to_typecode(scsi_changer *ch, u_int elem)
{
	int i;
	
	for (i = 0; i < CH_TYPES; i++) {
		if (elem >= ch->firsts[i]  &&
		    elem <  ch->firsts[i] +
	            ch->counts[i])
			return i+1;
	}
	return 0;
}

static int
ch_read_element_status(scsi_changer *ch, u_int elem, char *data)
{
	u_char  cmd[12];
	u_char  *buffer;
	int     result;
	
	buffer = kmalloc(512, GFP_KERNEL);
	if(!buffer)
		return -ENOMEM;
	
 retry:
	memset(cmd,0,sizeof(cmd));
	cmd[0] = READ_ELEMENT_STATUS;
	cmd[1] = (ch->device->lun << 5) | 
		(ch->voltags ? 0x10 : 0) |
		ch_elem_to_typecode(ch,elem);
	cmd[2] = (elem >> 8) & 0xff;
	cmd[3] = elem        & 0xff;
	cmd[5] = 1;
	cmd[9] = 255;
	if (0 == (result = ch_do_scsi(ch, cmd, buffer, 256))) {
		if (((buffer[16] << 8) | buffer[17]) != elem) {
			dprintk("asked for element 0x%02x, got 0x%02x\n",
				elem,(buffer[16] << 8) | buffer[17]);
			kfree(buffer);
			return -EIO;
		}
		memcpy(data,buffer+16,16);
	} else {
		if (ch->voltags) {
			ch->voltags = 0;
			vprintk("device has no volume tag support%s\n","");
			goto retry;
		}
		dprintk("READ ELEMENT STATUS for element 0x%x failed\n",elem);
	}
	kfree(buffer);
	return result;
}

static int 
ch_init_elem(scsi_changer *ch)
{
	int err;
	u_char cmd[6];

	vprintk("INITIALIZE ELEMENT STATUS, may take some time ...%s\n","");
	memset(cmd,0,sizeof(cmd));
	cmd[0] = INITIALIZE_ELEMENT_STATUS;
	cmd[1] = ch->device->lun << 5;
	err = ch_do_scsi(ch, cmd, NULL, 0);
	vprintk("... finished%s\n","");
	return err;
}

static int
ch_readconfig(scsi_changer *ch)
{
	u_char  cmd[10], data[16];
	u_char  *buffer;
	int     result,id,lun,i;
	u_int   elem;
	
	buffer = kmalloc(512, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;
	memset(buffer,0,512);
	
	memset(cmd,0,sizeof(cmd));
	cmd[0] = MODE_SENSE;
	cmd[1] = ch->device->lun << 5;
	cmd[2] = 0x1d;
	cmd[4] = 255;
	result = ch_do_scsi(ch, cmd, buffer, 255);
	if (0 != result) {
		cmd[1] |= (1<<3);
		result  = ch_do_scsi(ch, cmd, buffer, 255);
	}
	if (0 == result) {
		ch->firsts[CHET_MT] =
			(buffer[buffer[3]+ 6] << 8) | buffer[buffer[3]+ 7];
		ch->counts[CHET_MT] =
			(buffer[buffer[3]+ 8] << 8) | buffer[buffer[3]+ 9];
		ch->firsts[CHET_ST] =
			(buffer[buffer[3]+10] << 8) | buffer[buffer[3]+11];
		ch->counts[CHET_ST] =
			(buffer[buffer[3]+12] << 8) | buffer[buffer[3]+13];
		ch->firsts[CHET_IE] =
			(buffer[buffer[3]+14] << 8) | buffer[buffer[3]+15];
		ch->counts[CHET_IE] =
			(buffer[buffer[3]+16] << 8) | buffer[buffer[3]+17];
		ch->firsts[CHET_DT] =
			(buffer[buffer[3]+18] << 8) | buffer[buffer[3]+19];
		ch->counts[CHET_DT] =
			(buffer[buffer[3]+20] << 8) | buffer[buffer[3]+21];
		vprintk("type #1 (mt): 0x%x+%d [medium transport]\n",
			ch->firsts[CHET_MT],
			ch->counts[CHET_MT]);
		vprintk("type #2 (st): 0x%x+%d [storage]\n",
			ch->firsts[CHET_ST],
			ch->counts[CHET_ST]);
		vprintk("type #3 (ie): 0x%x+%d [import/export]\n",
			ch->firsts[CHET_IE],
			ch->counts[CHET_IE]);
		vprintk("type #4 (dt): 0x%x+%d [data transfer]\n",
			ch->firsts[CHET_DT],
			ch->counts[CHET_DT]);
	} else {
		vprintk("reading element address assigment page failed!%s\n",
			"");
	}
	
	/* vendor specific element types */
	for (i = 0; i < 4; i++) {
		if (0 == vendor_counts[i])
			continue;
		if (NULL == vendor_labels[i])
			continue;
		ch->firsts[CHET_V1+i] = vendor_firsts[i];
		ch->counts[CHET_V1+i] = vendor_counts[i];
		vprintk("type #%d (v%d): 0x%x+%d [%s, vendor specific]\n",
			i+5,i+1,vendor_firsts[i],vendor_counts[i],
			vendor_labels[i]);
	}

	/* look up the devices of the data transfer elements */
	ch->dt = kmalloc(ch->counts[CHET_DT]*sizeof(struct scsi_device),
			 GFP_KERNEL);
	for (elem = 0; elem < ch->counts[CHET_DT]; elem++) {
		id  = -1;
		lun = 0;
		if (-1 != dt_id[elem]) {
			id  = dt_id[elem];
			lun = dt_lun[elem];
			vprintk("dt 0x%x: [insmod option] ",
				elem+ch->firsts[CHET_DT]);
		} else if (0 != ch_read_element_status
			   (ch,elem+ch->firsts[CHET_DT],data)) {
			vprintk("dt 0x%x: READ ELEMENT STATUS failed\n",
				elem+ch->firsts[CHET_DT]);
		} else {
			vprintk("dt 0x%x: ",elem+ch->firsts[CHET_DT]);
			if (data[6] & 0x80) {
				if (verbose)
					printk("not this SCSI bus\n");
				ch->dt[elem] = NULL;
			} else if (0 == (data[6] & 0x30)) {
				if (verbose)
					printk("ID/LUN unknown\n");
				ch->dt[elem] = NULL;
			} else {
				id  = ch->device->id;
				lun = 0;
				if (data[6] & 0x20) id  = data[7];
				if (data[6] & 0x10) lun = data[6] & 7;
			}
		}
		if (-1 != id) {
			if (verbose)
				printk("ID %i, LUN %i, ",id,lun);
			ch->dt[elem] =
				scsi_device_lookup(ch->device->host,
						   ch->device->channel,
						   id,lun);
			if (!ch->dt[elem]) {
				/* should not happen */
				if (verbose)
					printk("Huh? device not found!\n");
			} else {
				if (verbose)
					printk("name: %8.8s %16.16s %4.4s\n",
					       ch->dt[elem]->vendor,
					       ch->dt[elem]->model,
					       ch->dt[elem]->rev);
			}
		}
	}
	ch->voltags = 1;
	kfree(buffer);

	return 0;
}

/* ------------------------------------------------------------------------ */

static int
ch_position(scsi_changer *ch, u_int trans, u_int elem, int rotate)
{
	u_char  cmd[10];
	
	dprintk("position: 0x%x\n",elem);
	if (0 == trans)
		trans = ch->firsts[CHET_MT];
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = POSITION_TO_ELEMENT;
	cmd[1]  = ch->device->lun << 5;
	cmd[2]  = (trans >> 8) & 0xff;
	cmd[3]  =  trans       & 0xff;
	cmd[4]  = (elem  >> 8) & 0xff;
	cmd[5]  =  elem        & 0xff;
	cmd[8]  = rotate ? 1 : 0;
	return ch_do_scsi(ch, cmd, NULL,0);
}

static int
ch_move(scsi_changer *ch, u_int trans, u_int src, u_int dest, int rotate)
{
	u_char  cmd[12];
	
	dprintk("move: 0x%x => 0x%x\n",src,dest);
	if (0 == trans)
		trans = ch->firsts[CHET_MT];
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = MOVE_MEDIUM;
	cmd[1]  = ch->device->lun << 5;
	cmd[2]  = (trans >> 8) & 0xff;
	cmd[3]  =  trans       & 0xff;
	cmd[4]  = (src   >> 8) & 0xff;
	cmd[5]  =  src         & 0xff;
	cmd[6]  = (dest  >> 8) & 0xff;
	cmd[7]  =  dest        & 0xff;
	cmd[10] = rotate ? 1 : 0;
	return ch_do_scsi(ch, cmd, NULL,0);
}

static int
ch_exchange(scsi_changer *ch, u_int trans, u_int src,
	    u_int dest1, u_int dest2, int rotate1, int rotate2)
{
	u_char  cmd[12];
	
	dprintk("exchange: 0x%x => 0x%x => 0x%x\n",
		src,dest1,dest2);
	if (0 == trans)
		trans = ch->firsts[CHET_MT];
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = EXCHANGE_MEDIUM;
	cmd[1]  = ch->device->lun << 5;
	cmd[2]  = (trans >> 8) & 0xff;
	cmd[3]  =  trans       & 0xff;
	cmd[4]  = (src   >> 8) & 0xff;
	cmd[5]  =  src         & 0xff;
	cmd[6]  = (dest1 >> 8) & 0xff;
	cmd[7]  =  dest1       & 0xff;
	cmd[8]  = (dest2 >> 8) & 0xff;
	cmd[9]  =  dest2       & 0xff;
	cmd[10] = (rotate1 ? 1 : 0) | (rotate2 ? 2 : 0);
	
	return ch_do_scsi(ch, cmd, NULL,0);
}

static void
ch_check_voltag(char *tag)
{
	int i;

	for (i = 0; i < 32; i++) {
		/* restrict to ascii */
		if (tag[i] >= 0x7f || tag[i] < 0x20)
			tag[i] = ' ';
		/* don't allow search wildcards */
		if (tag[i] == '?' ||
		    tag[i] == '*')
			tag[i] = ' ';
	}
}

static int
ch_set_voltag(scsi_changer *ch, u_int elem,
	      int alternate, int clear, u_char *tag)
{
	u_char  cmd[12];
	u_char  *buffer;
	int result;

	buffer = kmalloc(512, GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;
	memset(buffer,0,512);

	dprintk("%s %s voltag: 0x%x => \"%s\"\n",
		clear     ? "clear"     : "set",
		alternate ? "alternate" : "primary",
		elem, tag);
	memset(cmd,0,sizeof(cmd));
	cmd[0]  = SEND_VOLUME_TAG;
	cmd[1] = (ch->device->lun << 5) | 
		ch_elem_to_typecode(ch,elem);
	cmd[2] = (elem >> 8) & 0xff;
	cmd[3] = elem        & 0xff;
	cmd[5] = clear
		? (alternate ? 0x0d : 0x0c)
		: (alternate ? 0x0b : 0x0a);
	
	cmd[9] = 255;

	memcpy(buffer,tag,32);
	ch_check_voltag(buffer);

	result = ch_do_scsi(ch, cmd, buffer, 256);
	kfree(buffer);
	return result;
}

static int ch_gstatus(scsi_changer *ch, int type, unsigned char *dest)
{
	int retval = 0;
	u_char data[16];
	unsigned int i;
	
	down(&ch->lock);
	for (i = 0; i < ch->counts[type]; i++) {
		if (0 != ch_read_element_status
		    (ch, ch->firsts[type]+i,data)) {
			retval = -EIO;
			break;
		}
		put_user(data[2], dest+i);
		if (data[2] & CESTATUS_EXCEPT)
			vprintk("element 0x%x: asc=0x%x, ascq=0x%x\n",
				ch->firsts[type]+i,
				(int)data[4],(int)data[5]);
		retval = ch_read_element_status
			(ch, ch->firsts[type]+i,data);
		if (0 != retval)
			break;
	}
	up(&ch->lock);
	return retval;
}

/* ------------------------------------------------------------------------ */

static int
ch_release(struct inode *inode, struct file *file)
{
	scsi_changer *ch = file->private_data;

	scsi_device_put(ch->device);
	file->private_data = NULL;
	return 0;
}

static int
ch_open(struct inode *inode, struct file *file)
{
	scsi_changer *tmp, *ch;
	int minor = iminor(inode);

	spin_lock(&ch_devlist_lock);
	ch = NULL;
	list_for_each_entry(tmp,&ch_devlist,list) {
		if (tmp->minor == minor)
			ch = tmp;
	}
	if (NULL == ch || scsi_device_get(ch->device)) {
		spin_unlock(&ch_devlist_lock);
		return -ENXIO;
	}
	spin_unlock(&ch_devlist_lock);

	file->private_data = ch;
	return 0;
}

static int
ch_checkrange(scsi_changer *ch, unsigned int type, unsigned int unit)
{
	if (type >= CH_TYPES  ||  unit >= ch->counts[type])
		return -1;
	return 0;
}

static int ch_ioctl(struct inode * inode, struct file * file,
		    unsigned int cmd, unsigned long arg)
{
	scsi_changer *ch = file->private_data;
	int retval;
	
	switch (cmd) {
	case CHIOGPARAMS:
	{
		struct changer_params params;
		
		params.cp_curpicker = 0;
		params.cp_npickers  = ch->counts[CHET_MT];
		params.cp_nslots    = ch->counts[CHET_ST];
		params.cp_nportals  = ch->counts[CHET_IE];
		params.cp_ndrives   = ch->counts[CHET_DT];
		
		if (copy_to_user((void *) arg, &params, sizeof(params)))
			return -EFAULT;
		return 0;
	}
	case CHIOGVPARAMS:
	{
		struct changer_vendor_params vparams;

		memset(&vparams,0,sizeof(vparams));
		if (ch->counts[CHET_V1]) {
			vparams.cvp_n1  = ch->counts[CHET_V1];
			strncpy(vparams.cvp_label1,vendor_labels[0],16);
		}
		if (ch->counts[CHET_V2]) {
			vparams.cvp_n2  = ch->counts[CHET_V2];
			strncpy(vparams.cvp_label2,vendor_labels[1],16);
		}
		if (ch->counts[CHET_V3]) {
			vparams.cvp_n3  = ch->counts[CHET_V3];
			strncpy(vparams.cvp_label3,vendor_labels[2],16);
		}
		if (ch->counts[CHET_V4]) {
			vparams.cvp_n4  = ch->counts[CHET_V4];
			strncpy(vparams.cvp_label4,vendor_labels[3],16);
		}
		if (copy_to_user((void *) arg, &vparams, sizeof(vparams)))
			return -EFAULT;
		return 0;
	}
	
	case CHIOPOSITION:
	{
		struct changer_position pos;
		
		if (copy_from_user(&pos, (void*)arg, sizeof (pos)))
			return -EFAULT;

		if (0 != ch_checkrange(ch, pos.cp_type, pos.cp_unit)) {
			dprintk("CHIOPOSITION: invalid parameter%s\n","");
			return -EBADSLT;
		}
		down(&ch->lock);
		retval = ch_position(ch,0,
				     ch->firsts[pos.cp_type] + pos.cp_unit,
				     pos.cp_flags & CP_INVERT);
		up(&ch->lock);
		return retval;
	}
	
	case CHIOMOVE:
	{
		struct changer_move mv;

		if (copy_from_user(&mv, (void*)arg, sizeof (mv)))
			return -EFAULT;

		if (0 != ch_checkrange(ch, mv.cm_fromtype, mv.cm_fromunit) ||
		    0 != ch_checkrange(ch, mv.cm_totype,   mv.cm_tounit  )) {
			dprintk("CHIOMOVE: invalid parameter%s\n","");
			return -EBADSLT;
		}
		
		down(&ch->lock);
		retval = ch_move(ch,0,
				 ch->firsts[mv.cm_fromtype] + mv.cm_fromunit,
				 ch->firsts[mv.cm_totype]   + mv.cm_tounit,
				 mv.cm_flags & CM_INVERT);
		up(&ch->lock);
		return retval;
	}

	case CHIOEXCHANGE:
	{
		struct changer_exchange mv;
		
		if (copy_from_user(&mv, (void*)arg, sizeof (mv)))
			return -EFAULT;

		if (0 != ch_checkrange(ch, mv.ce_srctype,  mv.ce_srcunit ) ||
		    0 != ch_checkrange(ch, mv.ce_fdsttype, mv.ce_fdstunit) ||
		    0 != ch_checkrange(ch, mv.ce_sdsttype, mv.ce_sdstunit)) {
			dprintk("CHIOEXCHANGE: invalid parameter%s\n","");
			return -EBADSLT;
		}
		
		down(&ch->lock);
		retval = ch_exchange
			(ch,0,
			 ch->firsts[mv.ce_srctype]  + mv.ce_srcunit,
			 ch->firsts[mv.ce_fdsttype] + mv.ce_fdstunit,
			 ch->firsts[mv.ce_sdsttype] + mv.ce_sdstunit,
			 mv.ce_flags & CE_INVERT1, mv.ce_flags & CE_INVERT2);
		up(&ch->lock);
		return retval;
	}

	case CHIOGSTATUS:
	{
		struct changer_element_status ces;
		
		if (copy_from_user(&ces, (void*)arg, sizeof (ces)))
			return -EFAULT;
		if (ces.ces_type < 0 || ces.ces_type >= CH_TYPES)
			return -EINVAL;

		return ch_gstatus(ch, ces.ces_type, ces.ces_data);
	}

	case CHIOGELEM:
	{
		struct changer_get_element cge;
		u_char  cmd[12];
		u_char  *buffer;
		unsigned int elem;
		int     result,i;
		
		if (copy_from_user(&cge, (void*)arg, sizeof (cge)))
			return -EFAULT;

		if (0 != ch_checkrange(ch, cge.cge_type, cge.cge_unit))
			return -EINVAL;
		elem = ch->firsts[cge.cge_type] + cge.cge_unit;
		
		buffer = kmalloc(512, GFP_KERNEL);
		if (!buffer)
			return -ENOMEM;
		down(&ch->lock);
		
	voltag_retry:
		memset(cmd,0,sizeof(cmd));
		cmd[0] = READ_ELEMENT_STATUS;
		cmd[1] = (ch->device->lun << 5) |
			(ch->voltags ? 0x10 : 0) |
			ch_elem_to_typecode(ch,elem);
		cmd[2] = (elem >> 8) & 0xff;
		cmd[3] = elem        & 0xff;
		cmd[5] = 1;
		cmd[9] = 255;
		
		if (0 == (result = ch_do_scsi(ch, cmd, buffer, 256))) {
			cge.cge_status = buffer[18];
			cge.cge_flags = 0;
			if (buffer[18] & CESTATUS_EXCEPT) {
				/* FIXME: fill cge_errno */
			}
			if (buffer[25] & 0x80) {
				cge.cge_flags |= CGE_SRC;
				if (buffer[25] & 0x40)
					cge.cge_flags |= CGE_INVERT;
				elem = (buffer[26]<<8) | buffer[27];
				for (i = 0; i < 4; i++) {
					if (elem >= ch->firsts[i] &&
					    elem <  ch->firsts[i] + ch->counts[i]) {
						cge.cge_srctype = i;
						cge.cge_srcunit = elem-ch->firsts[i];
					}
				}
			}
			if ((buffer[22] & 0x30) == 0x30) {
				cge.cge_flags |= CGE_IDLUN;
				cge.cge_id  = buffer[23];
				cge.cge_lun = buffer[22] & 7;
			}
			if (buffer[9] & 0x80) {
				cge.cge_flags |= CGE_PVOLTAG;
				memcpy(cge.cge_pvoltag,buffer+28,36);
			}
			if (buffer[9] & 0x40) {
				cge.cge_flags |= CGE_AVOLTAG;
				memcpy(cge.cge_avoltag,buffer+64,36);
			}
		} else if (ch->voltags) {
			ch->voltags = 0;
			vprintk("device has no volume tag support%s\n","");
			goto voltag_retry;
		}
		kfree(buffer);
		up(&ch->lock);
		
		if (copy_to_user((void*)arg, &cge, sizeof (cge)))
			return -EFAULT;
		return result;
	}

	case CHIOINITELEM:
	{
		down(&ch->lock);
		retval = ch_init_elem(ch);
		up(&ch->lock);
		return retval;
	}
		
	case CHIOSVOLTAG:
	{
		struct changer_set_voltag csv;
		int elem;

		if (copy_from_user(&csv, (void*)arg, sizeof(csv)))
			return -EFAULT;

		if (0 != ch_checkrange(ch, csv.csv_type, csv.csv_unit)) {
			dprintk("CHIOSVOLTAG: invalid parameter%s\n","");
			return -EBADSLT;
		}
		elem = ch->firsts[csv.csv_type] + csv.csv_unit;
		down(&ch->lock);
		retval = ch_set_voltag(ch, elem,
				       csv.csv_flags & CSV_AVOLTAG,
				       csv.csv_flags & CSV_CLEARTAG,
				       csv.csv_voltag);
		up(&ch->lock);
		return retval;
	}

	default:
		return scsi_ioctl(ch->device, cmd, (void*)arg);

	}
}

#ifdef CONFIG_COMPAT

struct changer_element_status32 {
	int		ces_type;
	compat_uptr_t	ces_data;
};
#define CHIOGSTATUS32  _IOW('c', 8,struct changer_element_status32)

static long ch_ioctl_compat(struct file * file,
			    unsigned int cmd, unsigned long arg)
{
	scsi_changer *ch = file->private_data;
	
	switch (cmd) {
	case CHIOGPARAMS:
	case CHIOGVPARAMS:
	case CHIOPOSITION:
	case CHIOMOVE:
	case CHIOEXCHANGE:
	case CHIOGELEM:
	case CHIOINITELEM:
	case CHIOSVOLTAG:
		/* compatible */
		return ch_ioctl(NULL /* inode, unused */,
				file, cmd, arg);
	case CHIOGSTATUS32:
	{
		struct changer_element_status32 ces32;
		unsigned char *data;
		
		if (copy_from_user(&ces32, (void*)arg, sizeof (ces32)))
			return -EFAULT;
		if (ces32.ces_type < 0 || ces32.ces_type >= CH_TYPES)
			return -EINVAL;

		data = compat_ptr(ces32.ces_data);
		return ch_gstatus(ch, ces32.ces_type, data);
	}
	default:
		// return scsi_ioctl_compat(ch->device, cmd, (void*)arg);
		return -ENOIOCTLCMD;

	}
}
#endif

/* ------------------------------------------------------------------------ */

static int ch_probe(struct device *dev)
{
	struct scsi_device *sd = to_scsi_device(dev);
	scsi_changer *ch;
	
	if (sd->type != TYPE_MEDIUM_CHANGER)
		return -ENODEV;
    
	ch = kmalloc(sizeof(*ch), GFP_KERNEL);
	if (NULL == ch)
		return -ENOMEM;

	memset(ch,0,sizeof(*ch));
	ch->minor = ch_devcount;
	sprintf(ch->name,"ch%d",ch->minor);
	init_MUTEX(&ch->lock);
	ch->device = sd;
	ch_readconfig(ch);
	if (init)
		ch_init_elem(ch);

	devfs_mk_cdev(MKDEV(SCSI_CHANGER_MAJOR,ch->minor),
		      S_IFCHR | S_IRUGO | S_IWUGO, ch->name);

	printk(KERN_INFO "Attached scsi changer %s "
	       "at scsi%d, channel %d, id %d, lun %d\n", 
	       ch->name, sd->host->host_no, sd->channel, sd->id, sd->lun);
	
	spin_lock(&ch_devlist_lock);
	list_add_tail(&ch->list,&ch_devlist);
	ch_devcount++;
	spin_unlock(&ch_devlist_lock);
	return 0;
}

static int ch_remove(struct device *dev)
{
	struct scsi_device *sd = to_scsi_device(dev);
	scsi_changer *tmp, *ch;

	spin_lock(&ch_devlist_lock);
	ch = NULL;
	list_for_each_entry(tmp,&ch_devlist,list) {
		if (tmp->device == sd)
			ch = tmp;
	}
	BUG_ON(NULL == ch);
	list_del(&ch->list);
	spin_unlock(&ch_devlist_lock);

	devfs_remove(ch->name);
	kfree(ch->dt);
	kfree(ch);
	ch_devcount--;
	return 0;
}

static int __init init_ch_module(void)
{
	int rc;
	
	printk(KERN_INFO "SCSI Media Changer driver v" VERSION " \n");
	rc = register_chrdev(SCSI_CHANGER_MAJOR,"ch",&changer_fops);
	if (rc < 0) {
		printk("Unable to get major %d for SCSI-Changer\n",
		       SCSI_CHANGER_MAJOR);
		return rc;
	}
	rc = scsi_register_driver(&ch_template.gendrv);
	if (rc < 0)
		goto fail1;
	return 0;

 fail1:
	unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
	return rc;
}

static void __exit exit_ch_module(void) 
{
	scsi_unregister_driver(&ch_template.gendrv);
	unregister_chrdev(SCSI_CHANGER_MAJOR, "ch");
}

module_init(init_ch_module);
module_exit(exit_ch_module);

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Lines 91-96 Link Here

(-)linux-2.6.11.orig/include/asm-alpha/ioctls.h (+1 lines)
91	#define TIOCGSID 0x5429 /* Return the session ID of FD */	91	#define TIOCGSID 0x5429 /* Return the session ID of FD */
92	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	92	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
93	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	93	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		94	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
94		95
95	#define TIOCSERCONFIG 0x5453	96	#define TIOCSERCONFIG 0x5453
96	#define TIOCSERGWILD 0x5454	97	#define TIOCSERGWILD 0x5454

Lines 48-53 Link Here

(-)linux-2.6.11.orig/include/asm-arm/ioctls.h (+1 lines)
48	#define TIOCGSID 0x5429 /* Return the session ID of FD */	48	#define TIOCGSID 0x5429 /* Return the session ID of FD */
49	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	49	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
50	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	50	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		51	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
51		52
52	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */	53	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
53	#define FIOCLEX 0x5451	54	#define FIOCLEX 0x5451

Lines 49-54 Link Here

(-)linux-2.6.11.orig/include/asm-i386/ioctls.h (+1 lines)
49	#define TIOCGSID 0x5429 /* Return the session ID of FD */	49	#define TIOCGSID 0x5429 /* Return the session ID of FD */
50	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	50	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
51	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	51	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		52	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
52		53
53	#define FIONCLEX 0x5450	54	#define FIONCLEX 0x5450
54	#define FIOCLEX 0x5451	55	#define FIOCLEX 0x5451

Lines 55-60 Link Here

(-)linux-2.6.11.orig/include/asm-ia64/ioctls.h (+1 lines)
55	#define TIOCGSID 0x5429 /* Return the session ID of FD */	55	#define TIOCGSID 0x5429 /* Return the session ID of FD */
56	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	56	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
57	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	57	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		58	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
58		59
59	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */	60	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
60	#define FIOCLEX 0x5451	61	#define FIOCLEX 0x5451

Lines 48-53 Link Here

(-)linux-2.6.11.orig/include/asm-m68k/ioctls.h (+1 lines)
48	#define TIOCGSID 0x5429 /* Return the session ID of FD */	48	#define TIOCGSID 0x5429 /* Return the session ID of FD */
49	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	49	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
50	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	50	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		51	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
51		52
52	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */	53	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
53	#define FIOCLEX 0x5451	54	#define FIOCLEX 0x5451

Lines 79-84 Link Here

(-)linux-2.6.11.orig/include/asm-mips/ioctls.h (+1 lines)
79	#define TIOCGSID 0x7416 /* Return the session ID of FD */	79	#define TIOCGSID 0x7416 /* Return the session ID of FD */
80	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	80	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
81	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	81	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		82	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
82		83
83	/* I hope the range from 0x5480 on is free ... */	84	/* I hope the range from 0x5480 on is free ... */
84	#define TIOCSCTTY 0x5480 /* become controlling tty */	85	#define TIOCSCTTY 0x5480 /* become controlling tty */

Lines 88-93 Link Here

(-)linux-2.6.11.orig/include/asm-ppc/ioctls.h (+1 lines)
88	#define TIOCGSID 0x5429 /* Return the session ID of FD */	88	#define TIOCGSID 0x5429 /* Return the session ID of FD */
89	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	89	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
90	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	90	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		91	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
91		92
92	#define TIOCSERCONFIG 0x5453	93	#define TIOCSERCONFIG 0x5453
93	#define TIOCSERGWILD 0x5454	94	#define TIOCSERGWILD 0x5454

Lines 95-100 Link Here

(-)linux-2.6.11.orig/include/asm-ppc64/ioctls.h (+1 lines)
95	#define TIOCGSID 0x5429 /* Return the session ID of FD */	95	#define TIOCGSID 0x5429 /* Return the session ID of FD */
96	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	96	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
97	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	97	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		98	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
98		99
99	#define TIOCSERCONFIG 0x5453	100	#define TIOCSERCONFIG 0x5453
100	#define TIOCSERGWILD 0x5454	101	#define TIOCSERGWILD 0x5454

Lines 56-61 Link Here

(-)linux-2.6.11.orig/include/asm-s390/ioctls.h (+1 lines)
56	#define TIOCGSID 0x5429 /* Return the session ID of FD */	56	#define TIOCGSID 0x5429 /* Return the session ID of FD */
57	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	57	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
58	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	58	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		59	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
59		60
60	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */	61	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
61	#define FIOCLEX 0x5451	62	#define FIOCLEX 0x5451

Lines 80-85 Link Here

(-)linux-2.6.11.orig/include/asm-sh/ioctls.h (+1 lines)
80	#define TIOCGSID _IOR('T', 41, pid_t) /* 0x5429 / / Return the session ID of FD */	80	#define TIOCGSID _IOR('T', 41, pid_t) /* 0x5429 / / Return the session ID of FD */
81	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	81	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
82	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	82	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		83	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
83		84
84	#define TIOCSERCONFIG _IO('T', 83) /* 0x5453 */	85	#define TIOCSERCONFIG _IO('T', 83) /* 0x5453 */
85	#define TIOCSERGWILD _IOR('T', 84, int) /* 0x5454 */	86	#define TIOCSERGWILD _IOR('T', 84, int) /* 0x5454 */

Lines 15-20 Link Here

(-)linux-2.6.11.orig/include/asm-sparc/ioctls.h (+1 lines)
15	#define TCSETS _IOW('T', 9, struct termios)	15	#define TCSETS _IOW('T', 9, struct termios)
16	#define TCSETSW _IOW('T', 10, struct termios)	16	#define TCSETSW _IOW('T', 10, struct termios)
17	#define TCSETSF _IOW('T', 11, struct termios)	17	#define TCSETSF _IOW('T', 11, struct termios)
		18	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
18		19
19	/* Note that all the ioctls that are not available in Linux have a	20	/* Note that all the ioctls that are not available in Linux have a
20	* double underscore on the front to: a) avoid some programs to	21	* double underscore on the front to: a) avoid some programs to

Lines 16-21 Link Here

(-)linux-2.6.11.orig/include/asm-sparc64/ioctls.h (+1 lines)
16	#define TCSETS _IOW('T', 9, struct termios)	16	#define TCSETS _IOW('T', 9, struct termios)
17	#define TCSETSW _IOW('T', 10, struct termios)	17	#define TCSETSW _IOW('T', 10, struct termios)
18	#define TCSETSF _IOW('T', 11, struct termios)	18	#define TCSETSF _IOW('T', 11, struct termios)
		19	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
19		20
20	/* Note that all the ioctls that are not available in Linux have a	21	/* Note that all the ioctls that are not available in Linux have a
21	* double underscore on the front to: a) avoid some programs to	22	* double underscore on the front to: a) avoid some programs to

Lines 48-53 Link Here

(-)linux-2.6.11.orig/include/asm-x86_64/ioctls.h (+1 lines)
48	#define TIOCGSID 0x5429 /* Return the session ID of FD */	48	#define TIOCGSID 0x5429 /* Return the session ID of FD */
49	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */	49	#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
50	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */	50	#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
		51	#define TIOCGDEV _IOR('T',0x32, unsigned int) /* Get real dev no below /dev/console */
51		52
52	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */	53	#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
53	#define FIOCLEX 0x5451	54	#define FIOCLEX 0x5451




/*
 * ioctl interface for the scsi media changer driver
 */

/* changer element types */
#define CHET_MT   0	/* media transport element (robot) */
#define CHET_ST   1	/* storage element (media slots) */
#define CHET_IE   2	/* import/export element */
#define CHET_DT   3	/* data transfer element (tape/cdrom/whatever) */
#define CHET_V1   4	/* vendor specific #1 */
#define CHET_V2   5	/* vendor specific #2 */
#define CHET_V3   6	/* vendor specific #3 */
#define CHET_V4   7	/* vendor specific #4 */


/*
 * CHIOGPARAMS
 *    query changer properties
 *
 * CHIOVGPARAMS
 *    query vendor-specific element types
 *
 *    accessing elements works by specifing type and unit of the element.
 *    for eample, storage elements are addressed with type = CHET_ST and
 *    unit = 0 .. cp_nslots-1
 *
 */
struct changer_params {
	int cp_curpicker;  /* current transport element */
	int cp_npickers;   /* number of transport elements      (CHET_MT) */
	int cp_nslots;     /* number of storage elements        (CHET_ST) */
	int cp_nportals;   /* number of import/export elements  (CHET_IE) */
	int cp_ndrives;    /* number of data transfer elements  (CHET_DT) */
};
struct changer_vendor_params {
	int  cvp_n1;       /* number of vendor specific elems   (CHET_V1) */
	char cvp_label1[16];
	int  cvp_n2;       /* number of vendor specific elems   (CHET_V2) */
	char cvp_label2[16];
	int  cvp_n3;       /* number of vendor specific elems   (CHET_V3) */
	char cvp_label3[16];
	int  cvp_n4;       /* number of vendor specific elems   (CHET_V4) */
	char cvp_label4[16];
	int  reserved[8];
};


/*
 * CHIOMOVE
 *    move a medium from one element to another
 */
struct changer_move {
	int cm_fromtype;	/* type/unit of source element */
	int cm_fromunit;	
	int cm_totype;	/* type/unit of destination element */
	int cm_tounit;
	int cm_flags;
};
#define CM_INVERT   1   /* flag: rotate media (for double-sided like MOD) */


/*
 * CHIOEXCHANGE
 *    move one medium from element #1 to element #2,
 *    and another one from element #2 to element #3.
 *    element #1 and #3 are allowed to be identical.
 */
struct changer_exchange {
	int ce_srctype;	    /* type/unit of element #1 */
	int ce_srcunit;
	int ce_fdsttype;    /* type/unit of element #2 */
	int ce_fdstunit;
	int ce_sdsttype;    /* type/unit of element #3 */
	int ce_sdstunit;
	int ce_flags;
};
#define CE_INVERT1   1
#define CE_INVERT2   2


/*
 * CHIOPOSITION
 *    move the transport element (robot arm) to a specific element.
 */
struct changer_position {
	int cp_type;
	int cp_unit;
	int cp_flags;
};
#define CP_INVERT   1


/*
 * CHIOGSTATUS
 *    get element status for all elements of a specific type
 */
struct changer_element_status {
	int             ces_type;
	unsigned char   *ces_data;
};
#define CESTATUS_FULL     0x01 /* full */
#define CESTATUS_IMPEXP   0x02	/* media was imported (inserted by sysop) */
#define CESTATUS_EXCEPT   0x04	/* error condition */
#define CESTATUS_ACCESS   0x08	/* access allowed */
#define CESTATUS_EXENAB   0x10	/* element can export media */
#define CESTATUS_INENAB   0x20	/* element can import media */


/*
 * CHIOGELEM
 *    get more detailed status informtion for a single element
 */
struct changer_get_element {
	int	cge_type;	 /* type/unit */
	int	cge_unit;
	int	cge_status;      /* status */
	int     cge_errno;       /* errno */
	int     cge_srctype;     /* source element of the last move/exchange */
	int     cge_srcunit;
	int     cge_id;          /* scsi id  (for data transfer elements) */
	int     cge_lun;         /* scsi lun (for data transfer elements) */
	char    cge_pvoltag[36]; /* primary volume tag */
	char    cge_avoltag[36]; /* alternate volume tag */
	int     cge_flags;
};
/* flags */
#define CGE_ERRNO     0x01       /* errno available       */
#define CGE_INVERT    0x02       /* media inverted        */
#define CGE_SRC       0x04       /* media src available   */
#define CGE_IDLUN     0x08       /* ID+LUN available      */
#define CGE_PVOLTAG   0x10       /* primary volume tag available */
#define CGE_AVOLTAG   0x20       /* alternate volume tag available */


/*
 * CHIOSVOLTAG
 *    set volume tag
 */
struct changer_set_voltag {
	int	csv_type;	 /* type/unit */
	int	csv_unit;
	char    csv_voltag[36];  /* volume tag */
	int     csv_flags;
};
#define CSV_PVOLTAG   0x01       /* primary volume tag */
#define CSV_AVOLTAG   0x02       /* alternate volume tag */
#define CSV_CLEARTAG  0x04       /* clear volume tag */

/* ioctls */
#define CHIOMOVE       _IOW('c', 1,struct changer_move)
#define CHIOEXCHANGE   _IOW('c', 2,struct changer_exchange)
#define CHIOPOSITION   _IOW('c', 3,struct changer_position)
#define CHIOGPICKER    _IOR('c', 4,int)                        /* not impl. */
#define CHIOSPICKER    _IOW('c', 5,int)                        /* not impl. */
#define CHIOGPARAMS    _IOR('c', 6,struct changer_params)
#define CHIOGSTATUS    _IOW('c', 8,struct changer_element_status)
#define CHIOGELEM      _IOW('c',16,struct changer_get_element)
#define CHIOINITELEM   _IO('c',17)
#define CHIOSVOLTAG    _IOW('c',18,struct changer_set_voltag)
#define CHIOGVPARAMS   _IOR('c',19,struct changer_vendor_params)

/* ---------------------------------------------------------------------- */

/*
 * Local variables:
 * c-basic-offset: 8
 * End:
 */

Lines 27-32 COMPATIBLE_IOCTL(TIOCSBRK) Link Here

(-)linux-2.6.11.orig/include/linux/compat_ioctl.h (+1 lines)
27	COMPATIBLE_IOCTL(TIOCCBRK)	27	COMPATIBLE_IOCTL(TIOCCBRK)
28	ULONG_IOCTL(TIOCMIWAIT)	28	ULONG_IOCTL(TIOCMIWAIT)
29	COMPATIBLE_IOCTL(TIOCGICOUNT)	29	COMPATIBLE_IOCTL(TIOCGICOUNT)
		30	COMPATIBLE_IOCTL(TIOCGDEV)
30	/* Little t */	31	/* Little t */
31	COMPATIBLE_IOCTL(TIOCGETD)	32	COMPATIBLE_IOCTL(TIOCGETD)
32	COMPATIBLE_IOCTL(TIOCSETD)	33	COMPATIBLE_IOCTL(TIOCSETD)

Lines 101-106 Link Here

(-)linux-2.6.11.orig/include/linux/major.h (+1 lines)
101	#define I2O_MAJOR 80 /* 80->87 */	101	#define I2O_MAJOR 80 /* 80->87 */
102		102
103	#define SHMIQ_MAJOR 85 /* Linux/mips, SGI /dev/shmiq */	103	#define SHMIQ_MAJOR 85 /* Linux/mips, SGI /dev/shmiq */
		104	#define SCSI_CHANGER_MAJOR 86
104		105
105	#define IDE6_MAJOR 88	106	#define IDE6_MAJOR 88
106	#define IDE7_MAJOR 89	107	#define IDE7_MAJOR 89




/* The above is based on SMPTE timecodes */


#if 1
/*
 *	M P E G   C O M P R E S S I O N   P A R A M E T E R S
 *
 *  ### WARNING: this is still work-in-progress right now, most likely
 *  ###          there will be some incompatible changes.
 *
 */
#if 0
/* ### generic compression settings don't work, there is too much
 * ### codec-specific stuff.  Maybe reuse that for MPEG codec settings
 * ### later ... */
struct v4l2_compression
{
	__u32	quality;
	__u32	keyframerate;
	__u32	pframerate;
	__u32	reserved[5];

/*  what we'll need for MPEG, extracted from some postings on
    the v4l list (Gert Vervoort, PlasmaJohn).

enum v4l2_bitrate_mode {
	V4L2_BITRATE_NONE = 0,	/* not specified */
	V4L2_BITRATE_CBR,	/* constant bitrate */
	V4L2_BITRATE_VBR,	/* variable bitrate */
};
struct v4l2_bitrate {
	/* rates are specified in kbit/sec */
	enum v4l2_bitrate_mode	mode;
	__u32			min;
	__u32			target;  /* use this one for CBR */
	__u32			max;
};

enum v4l2_mpeg_streamtype {
	V4L2_MPEG_SS_1,		/* MPEG-1 system stream */
	V4L2_MPEG_PS_2,		/* MPEG-2 program stream */
	V4L2_MPEG_TS_2,		/* MPEG-2 transport stream */
	V4L2_MPEG_PS_DVD,      	/* MPEG-2 program stream with DVD header fixups */
};
enum v4l2_mpeg_audiotype {
	V4L2_MPEG_AU_2_I,	/* MPEG-2 layer 1 */
	V4L2_MPEG_AU_2_II,	/* MPEG-2 layer 2 */
	V4L2_MPEG_AU_2_III,	/* MPEG-2 layer 3 */
	V4L2_MPEG_AC3,		/* AC3 */
	V4L2_MPEG_LPCM,		/* LPCM */
};
enum v4l2_mpeg_videotype {
	V4L2_MPEG_VI_1,		/* MPEG-1 */
	V4L2_MPEG_VI_2,		/* MPEG-2 */
};
enum v4l2_mpeg_aspectratio {
	V4L2_MPEG_ASPECT_SQUARE = 1,   /* square pixel */
	V4L2_MPEG_ASPECT_4_3    = 2,   /*  4 : 3       */
	V4L2_MPEG_ASPECT_16_9   = 3,   /* 16 : 9       */
	V4L2_MPEG_ASPECT_1_221  = 4,   /*  1 : 2,21    */
};

struct v4l2_mpeg_compression {
	/* general */
	enum v4l2_mpeg_streamtype	st_type;
	struct v4l2_bitrate		st_bitrate;
  - MPEG video version: MPEG-1, MPEG-2
  - GOP (Group Of Pictures) definition:
    - N: number of frames per GOP
    - M: distance between reference (I,P) frames
    - open/closed GOP
  - quantiser matrix: inter Q matrix (64 bytes) and intra Q matrix (64 bytes)
  - quantiser scale: linear or logarithmic
  - scanning: alternate or zigzag
  - bitrate mode: CBR (constant bitrate) or VBR (variable bitrate).
  - target video bitrate for CBR
  - target video bitrate for VBR
  - maximum video bitrate for VBR - min. quantiser value for VBR
  - max. quantiser value for VBR
  - adaptive quantisation value
  - return the number of bytes per GOP or bitrate for bitrate monitoring

	/* transport streams */
	__u16				ts_pid_pmt;
	__u16				ts_pid_audio;
	__u16				ts_pid_video;
	__u16				ts_pid_pcr;

	/* program stream */
	__u16				ps_size;
	__u16				reserved_1;    /* align */

	/* audio */
	enum v4l2_mpeg_audiotype	au_type;
	struct v4l2_bitrate		au_bitrate;
	__u32				au_sample_rate;
	__u8                            au_pesid;
	__u8                            reserved_2[3]; /* align */

	/* video */
	enum v4l2_mpeg_videotype	vi_type;
	enum v4l2_mpeg_aspectratio	vi_aspect_ratio;
	struct v4l2_bitrate		vi_bitrate;
	__u32				vi_frame_rate;
	__u16				vi_frames_per_gop;
	__u16				vi_bframes_count;
	__u8                            vi_pesid;
	__u8                            reserved_3[3]; /* align */

	/* misc flags */
	__u32                           closed_gops:1;
	__u32                           pulldown:1;
	__u32                           reserved_4:30; /* align */

	/* I don't expect the above being perfect yet ;) */
	__u32				reserved_5[8];
};
#endif


#define VIDIOC_ENUM_FMT         _IOWR ('V',  2, struct v4l2_fmtdesc)
#define VIDIOC_G_FMT		_IOWR ('V',  4, struct v4l2_format)
#define VIDIOC_S_FMT		_IOWR ('V',  5, struct v4l2_format)
#if 1 /* experimental */
#define VIDIOC_G_MPEGCOMP       _IOR  ('V',  6, struct v4l2_mpeg_compression)
#define VIDIOC_S_MPEGCOMP     	_IOW  ('V',  7, struct v4l2_mpeg_compression)
#endif
#define VIDIOC_REQBUFS		_IOWR ('V',  8, struct v4l2_requestbuffers)
#define VIDIOC_QUERYBUF		_IOWR ('V',  9, struct v4l2_buffer)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/include/media/ir-common.h (-1 / +5 lines)
1	/*	1	/*
2	* $Id: ir-common.h,v 1.6 2004/09/15 16:15:24 kraxel Exp $	2	* $Id: ir-common.h,v 1.8 2005/02/22 12:28:40 kraxel Exp $
3	*	3	*
4	* some common structs and functions to handle infrared remotes via	4	* some common structs and functions to handle infrared remotes via
5	* input layer ...	5	* input layer ...
Lines 47-53 struct ir_input_state { Link Here
47	};	47	};
48		48
49	extern IR_KEYTAB_TYPE ir_codes_rc5_tv[IR_KEYTAB_SIZE];	49	extern IR_KEYTAB_TYPE ir_codes_rc5_tv[IR_KEYTAB_SIZE];
		50	extern IR_KEYTAB_TYPE ir_codes_winfast[IR_KEYTAB_SIZE];
50	extern IR_KEYTAB_TYPE ir_codes_empty[IR_KEYTAB_SIZE];	51	extern IR_KEYTAB_TYPE ir_codes_empty[IR_KEYTAB_SIZE];
		52	extern IR_KEYTAB_TYPE ir_codes_hauppauge_new[IR_KEYTAB_SIZE];
51		53
52	void ir_input_init(struct input_dev dev, struct ir_input_state ir,	54	void ir_input_init(struct input_dev dev, struct ir_input_state ir,
53	int ir_type, IR_KEYTAB_TYPE *ir_codes);	55	int ir_type, IR_KEYTAB_TYPE *ir_codes);
Lines 55-60 void ir_input_nokey(struct input_dev *de Link Here
55	void ir_input_keydown(struct input_dev dev, struct ir_input_state ir,	57	void ir_input_keydown(struct input_dev dev, struct ir_input_state ir,
56	u32 ir_key, u32 ir_raw);	58	u32 ir_key, u32 ir_raw);
57	u32 ir_extract_bits(u32 data, u32 mask);	59	u32 ir_extract_bits(u32 data, u32 mask);
		60	int ir_dump_samples(u32 *samples, int count);
		61	int ir_decode_biphase(u32 *samples, int count, int low, int high);
58		62
59	/*	63	/*
60	* Local variables:	64	* Local variables:




    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#if 0 /* ndef _SAA6752HS_H */
#define _SAA6752HS_H

enum mpeg_video_bitrate_mode {
	MPEG_VIDEO_BITRATE_MODE_VBR = 0, /* Variable bitrate */
	MPEG_VIDEO_BITRATE_MODE_CBR = 1, /* Constant bitrate */

	MPEG_VIDEO_BITRATE_MODE_MAX
};

enum mpeg_audio_bitrate {

	MPEG_AUDIO_BITRATE_MAX
};

enum mpeg_video_format {
	MPEG_VIDEO_FORMAT_D1 = 0,
	MPEG_VIDEO_FORMAT_2_3_D1 = 1,
	MPEG_VIDEO_FORMAT_1_2_D1 = 2,
	MPEG_VIDEO_FORMAT_SIF = 3,

	MPEG_VIDEO_FORMAT_MAX
};

#define MPEG_VIDEO_TARGET_BITRATE_MAX 27000
#define MPEG_VIDEO_MAX_BITRATE_MAX 27000
#define MPEG_TOTAL_BITRATE_MAX 27000
#define MPEG_PID_MAX ((1 << 14) - 1)

struct mpeg_params {
	enum mpeg_video_bitrate_mode video_bitrate_mode;
	unsigned int video_target_bitrate;
	unsigned int video_max_bitrate; // only used for VBR
	enum mpeg_audio_bitrate audio_bitrate;
	unsigned int total_bitrate;

   	unsigned int pmt_pid;
	unsigned int video_pid;
	unsigned int audio_pid;
	unsigned int pcr_pid;

	enum mpeg_video_format video_format;
};

#define MPEG_SETPARAMS             _IOW('6',100,struct mpeg_params)




#define TUNER_PHILIPS_PAL_I 1
#define TUNER_PHILIPS_NTSC  2
#define TUNER_PHILIPS_SECAM 3		/* you must actively select B/G, L, L` */

#define TUNER_ABSENT        4
#define TUNER_PHILIPS_PAL   5
#define TUNER_TEMIC_NTSC    6        /* 4032 FY5 (3X 7004, 9498, 9789)  */
#define TUNER_TEMIC_PAL_I   7        /* 4062 FY5 (3X 8501, 9957)        */

#define TUNER_TEMIC_4036FY5_NTSC 8   /* 4036 FY5 (3X 1223, 1981, 7686)  */
#define TUNER_ALPS_TSBH1_NTSC 	 9
#define TUNER_ALPS_TSBE1_PAL 	10
#define TUNER_ALPS_TSBB5_PAL_I 	11

#define TUNER_ALPS_TSBE5_PAL 	12
#define TUNER_ALPS_TSBC5_PAL 	13
#define TUNER_TEMIC_4006FH5_PAL	14   /* 4006 FH5 (3X 9500, 9501, 7291)     */
#define TUNER_ALPS_TSHC6_NTSC 	15

#define TUNER_TEMIC_PAL_DK	16   /* 4016 FY5 (3X 1392, 1393)     */
#define TUNER_PHILIPS_NTSC_M	17
#define TUNER_TEMIC_4066FY5_PAL_I       18  /* 4066 FY5 (3X 7032, 7035) */
#define TUNER_TEMIC_4006FN5_MULTI_PAL   19  /* B/G, I and D/K autodetected (3X 7595, 7606, 7657)*/

#define TUNER_TEMIC_4009FR5_PAL         20  /* incl. FM radio (3X 7607, 7488, 7711)*/
#define TUNER_TEMIC_4039FR5_NTSC        21  /* incl. FM radio (3X 7246, 7578, 7732)*/
#define TUNER_TEMIC_4046FM5             22  /* you must actively select B/G, D/K, I, L, L` !  (3X 7804, 7806, 8103, 8104)*/
#define TUNER_PHILIPS_PAL_DK		23

#define TUNER_PHILIPS_FQ1216ME		24  /* you must actively select B/G/D/K, I, L, L` */
#define TUNER_LG_PAL_I_FM	25
#define TUNER_LG_PAL_I		26
#define TUNER_LG_NTSC_FM	27

#define TUNER_LG_PAL_FM		28
#define TUNER_LG_PAL		29
#define TUNER_TEMIC_4009FN5_MULTI_PAL_FM	30  /* B/G, I and D/K autodetected (3X 8155, 8160, 8163)*/
#define TUNER_SHARP_2U5JF5540_NTSC  31

#define TUNER_Samsung_PAL_TCPM9091PD27 32
#define TUNER_MT2032 33
#define TUNER_TEMIC_4106FH5 	34	/* 4106 FH5 (3X 7808, 7865)*/
#define TUNER_TEMIC_4012FY5	35	/* 4012 FY5 (3X 0971, 1099)*/

#define TUNER_TEMIC_4136FY5	36	/* 4136 FY5 (3X 7708, 7746)*/
#define TUNER_LG_PAL_NEW_TAPC   37
#define TUNER_PHILIPS_FM1216ME_MK3  38
#define TUNER_LG_NTSC_NEW_TAPC   39

#define TUNER_HITACHI_NTSC       40
#define TUNER_PHILIPS_PAL_MK     41
#define TUNER_PHILIPS_ATSC       42
#define TUNER_PHILIPS_FM1236_MK3 43

#define TUNER_PHILIPS_4IN1       44	/* ATI TV Wonder Pro - Conexant */
/* Microtune mergeged with Temic 12/31/1999 partially financed by Alps - these may be similar to Temic */
#define TUNER_MICROTUNE_4049FM5  45
#define TUNER_LG_NTSC_TAPE       47

#define TUNER_TNF_8831BGFF       48
#define TUNER_MICROTUNE_4042FI5  49	/* FusionHDTV 3 Gold - 4042 FI5 (3X 8147) */
#define TUNER_TCL_2002N          50
#define TUNER_PHILIPS_FM1256_IH3   51

#define TUNER_THOMSON_DTT7610    52
#define TUNER_PHILIPS_FQ1286     53
#define TUNER_PHILIPS_TDA8290    54
#define TUNER_LG_PAL_TAPE        55    /* Hauppauge PVR-150 PAL */

#define TUNER_PHILIPS_FQ1216AME_MK4 56 /* Hauppauge PVR-150 PAL */
#define TUNER_PHILIPS_FQ1236A_MK4 57   /* Hauppauge PVR-500MCE NTSC */

#define NOTUNER 0
#define PAL     1	/* PAL_BG */


#define TUNER_SET_TYPE               _IOW('t',1,int)    /* set tuner type */
#define TUNER_SET_TVFREQ             _IOW('t',2,int)    /* set tv freq */
#if 0 /* obsolete */
# define TUNER_SET_RADIOFREQ         _IOW('t',3,int)    /* set radio freq */
# define TUNER_SET_MODE              _IOW('t',4,int)    /* set tuner mode */
#endif

#define  TDA9887_SET_CONFIG          _IOW('t',5,int)
/* tv card specific */

# define TDA9887_DEEMPHASIS_75       (3<<16)
# define TDA9887_AUTOMUTE            (1<<18)

#ifdef __KERNEL__

#define I2C_ADDR_TDA8290        0x4b
#define I2C_ADDR_TDA8275        0x61

struct tuner {
	/* device */
	struct i2c_client i2c;

	/* state + config */
	unsigned int initialized;
	unsigned int type;            /* chip type */
	unsigned int freq;            /* keep track of the current settings */
	v4l2_std_id  std;
	int          using_v4l2;

	enum v4l2_tuner_type mode;
	unsigned int input;

	/* used by MT2032 */
	unsigned int xogc;
	unsigned int radio_if2;

	/* used by tda8290 */
	unsigned char i2c_easy_mode[2];
	unsigned char i2c_set_freq[8];

	/* function ptrs */
	void (*tv_freq)(struct i2c_client *c, unsigned int freq);
	void (*radio_freq)(struct i2c_client *c, unsigned int freq);
	int  (*has_signal)(struct i2c_client *c);
	int  (*is_stereo)(struct i2c_client *c);
};

extern unsigned int tuner_debug;
extern unsigned const int tuner_count;

extern int microtune_init(struct i2c_client *c);
extern int tda8290_init(struct i2c_client *c);
extern int default_tuner_init(struct i2c_client *c);

#define tuner_warn(fmt, arg...) \
	dev_printk(KERN_WARNING , &t->i2c.dev , fmt , ## arg)
#define tuner_info(fmt, arg...) \
	dev_printk(KERN_INFO , &t->i2c.dev , fmt , ## arg)
#define tuner_dbg(fmt, arg...) \
	if (tuner_debug) dev_printk(KERN_DEBUG , &t->i2c.dev , fmt , ## arg)

#endif /* __KERNEL__ */

#endif

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-basic-offset: 8
 * End:
 */




#define FORMAT_UNIT           0x04
#define READ_BLOCK_LIMITS     0x05
#define REASSIGN_BLOCKS       0x07
#define INITIALIZE_ELEMENT_STATUS 0x07
#define READ_6                0x08
#define WRITE_6               0x0a
#define SEEK_6                0x0b

#define READ_10               0x28
#define WRITE_10              0x2a
#define SEEK_10               0x2b
#define POSITION_TO_ELEMENT   0x2b
#define WRITE_VERIFY          0x2e
#define VERIFY                0x2f
#define SEARCH_HIGH           0x30

#define PERSISTENT_RESERVE_OUT 0x5f
#define REPORT_LUNS           0xa0
#define MOVE_MEDIUM           0xa5
#define EXCHANGE_MEDIUM       0xa6
#define READ_12               0xa8
#define WRITE_12              0xaa
#define WRITE_VERIFY_12       0xae

Added Link Here

(-)linux-2.6.11/localversion-kraxel (+1 lines)
1	-kraxel1

Return to bug 94814

Lines 2369-2374 int tty_ioctl(struct inode * inode, stru Link Here

(-)linux-2.6.11.orig/drivers/char/tty_io.c (+15 lines)
2369	case TIOCMBIC:	2369	case TIOCMBIC:
2370	case TIOCMBIS:	2370	case TIOCMBIS:
2371	return tty_tiocmset(tty, file, cmd, p);	2371	return tty_tiocmset(tty, file, cmd, p);
		2372	/*
		2373	* Without the real device to which /dev/console is connected,
		2374	* blogd can not work.
		2375	* blogd spawns a pty/tty pair,
		2376	* set /dev/console to the tty of that pair (ioctl TIOCCONS),
		2377	* then reads in all input from the current /dev/console,
		2378	* buffer or write the readed data to /var/log/boot.msg
		2379	* _and_ to the original real device.
		2380	*/
		2381	case TIOCGDEV:
		2382	{
		2383	unsigned int ret = new_encode_dev(tty_devnum(real_tty));
		2384	return put_user(ret, (unsigned int __user *)p);
		2385	}
		2386
2372	}	2387	}
2373	if (tty->driver->ioctl) {	2388	if (tty->driver->ioctl) {
2374	retval = (tty->driver->ioctl)(tty, file, cmd, arg);	2389	retval = (tty->driver->ioctl)(tty, file, cmd, arg);

Added Link Here

(-)linux-2.6.11/Documentation/scsi-changer.txt (+180 lines)
1
2	README for the SCSI media changer driver
3	========================================
4
5	This is a driver for SCSI Medium Changer devices, which are listed
6	with "Type: Medium Changer" in /proc/scsi/scsi.
7
8	This is for real Jukeboxes. It is not supported to work with
9	common small CD-ROM changers, neither one-lun-per-slot SCSI changers
10	nor IDE drives.
11
12	Userland tools available from here:
13	http://linux.bytesex.org/misc/changer.html
14
15
16	General Information
17	-------------------
18
19	First some words about how changers work: A changer has 2 (possibly
20	more) SCSI ID's. One for the changer device which controls the robot,
21	and one for the device which actually reads and writes the data. The
22	later may be anything, a MOD, a CD-ROM, a tape or whatever. For the
23	changer device this is a "don't care", he only shuffles around the
24	media, nothing else.
25
26
27	The SCSI changer model is complex, compared to - for example - IDE-CD
28	changers. But it allows to handle nearly all possible cases. It knows
29	4 different types of changer elements:
30
31	media transport - this one shuffles around the media, i.e. the
32	transport arm. Also known as "picker".
33	storage - a slot which can hold a media.
34	import/export - the same as above, but is accessable from outside,
35	i.e. there the operator (you !) can use this to
36	fill in and remove media from the changer.
37	Sometimes named "mailslot".
38	data transfer - this is the device which reads/writes, i.e. the
39	CD-ROM / Tape / whatever drive.
40
41	None of these is limited to one: A huge Jukebox could have slots for
42	123 CD-ROM's, 5 CD-ROM readers (and therefore 6 SCSI ID's: the changer
43	and each CD-ROM) and 2 transport arms. No problem to handle.
44
45
46	How it is implemented
47	---------------------
48
49	I implemented the driver as character device driver with a NetBSD-like
50	ioctl interface. Just grabbed NetBSD's header file and one of the
51	other linux SCSI device drivers as starting point. The interface
52	should be source code compatible with NetBSD. So if there is any
53	software (anybody knows ???) which supports a BSDish changer driver,
54	it should work with this driver too.
55
56	Over time a few more ioctls where added, volume tag support for example
57	wasn't covered by the NetBSD ioctl API.
58
59
60	Current State
61	-------------
62
63	Support for more than one transport arm is not implemented yet (and
64	nobody asked for it so far...).
65
66	I test and use the driver myself with a 35 slot cdrom jukebox from
67	Grundig. I got some reports telling it works ok with tape autoloaders
68	(Exabyte, HP and DEC). Some People use this driver with amanda. It
69	works fine with small (11 slots) and a huge (4 MOs, 88 slots)
70	magneto-optical Jukebox. Probably with lots of other changers too, most
71	(but not all :-) people mail me only if it does not work...
72
73	I don't have any device lists, neither black-list nor white-list. Thus
74	it is quite useless to ask me whenever a specific device is supported or
75	not. In theory every changer device which supports the SCSI-2 media
76	changer command set should work out-of-the-box with this driver. If it
77	doesn't, it is a bug. Either within the driver or within the firmware
78	of the changer device.
79
80
81	Using it
82	--------
83
84	This is a character device with major number is 86, so use
85	"mknod /dev/sch0 c 86 0" to create the special file for the driver.
86
87	If the module finds the changer, it prints some messages about the
88	device [ try "dmesg" if you don't see anything ] and should show up in
89	/proc/devices. If not.... some changers use ID ? / LUN 0 for the
90	device and ID ? / LUN 1 for the robot mechanism. But Linux does not
91	look for LUN's other than 0 as default, becauce there are to many
92	broken devices. So you can try:
93
94	1) echo "scsi add-single-device 0 0 ID 1" > /proc/scsi/scsi
95	(replace ID with the SCSI-ID of the device)
96	2) boot the kernel with "max_scsi_luns=1" on the command line
97	(append="max_scsi_luns=1" in lilo.conf should do the trick)
98
99
100	Trouble?
101	--------
102
103	If you insmod the driver with "insmod debug=1", it will be verbose and
104	prints a lot of stuff to the syslog. Compiling the kernel with
105	CONFIG_SCSI_CONSTANTS=y improves the quality of the error messages alot
106	because the kernel will translate the error codes into human-readable
107	strings then.
108
109	You can display these messages with the dmesg command (or check the
110	logfiles). If you email me some question becauce of a problem with the
111	driver, please include these messages.
112
113
114	Insmod options
115	--------------
116
117	debug=0/1
118	Enable debug messages (see above, default: 0).
119
120	verbose=0/1
121	Be verbose (default: 1).
122
123	init=0/1
124	Send INITIALIZE ELEMENT STATUS command to the changer
125	at insmod time (default: 1).
126
127	timeout_init=<seconds>
128	timeout for the INITIALIZE ELEMENT STATUS command
129	(default: 3600).
130
131	timeout_move=<seconds>
132	timeout for all other commands (default: 120).
133
134	dt_id=<id1>,<id2>,...
135	dt_lun=<lun1>,<lun2>,...
136	These two allow to specify the SCSI ID and LUN for the data
137	transfer elements. You likely don't need this as the jukebox
138	should provide this information. But some devices don't ...
139
140	vendor_firsts=
141	vendor_counts=
142	vendor_labels=
143	These insmod options can be used to tell the driver that there
144	are some vendor-specific element types. Grundig for example
145	does this. Some jukeboxes have a printer to label fresh burned
146	CDs, which is addressed as element 0xc000 (type 5). To tell the
147	driver about this vendor-specific element, use this:
148	$ insmod ch \
149	vendor_firsts=0xc000 \
150	vendor_counts=1 \
151	vendor_labels=printer
152	All three insmod options accept up to four comma-separated
153	values, this way you can configure the element types 5-8.
154	You likely need the SCSI specs for the device in question to
155	find the correct values as they are not covered by the SCSI-2
156	standard.
157
158
159	Credits
160	-------
161
162	I wrote this driver using the famous mailing-patches-around-the-world
163	method. With (more or less) help from:
164
165	Daniel Moehwald <moehwald@hdg.de>
166	Dane Jasper <dane@sonic.net>
167	R. Scott Bailey <sbailey@dsddi.eds.com>
168	Jonathan Corbet <corbet@lwn.net>
169
170	Special thanks go to
171	Martin Kuehne <martin.kuehne@bnbt.de>
172	for a old, second-hand (but full functional) cdrom jukebox which I use
173	to develop/test driver and tools now.
174
175	Have fun,
176
177	Gerd
178
179	--
180	Gerd Knorr <kraxel@bytesex.org>

Lines 6-34 Link Here

(-)linux-2.6.11.orig/Documentation/video4linux/CARDLIST.saa7134 (-20 / +21 lines)
6	5 -> SKNet Monster TV [1131:4e85]	6	5 -> SKNet Monster TV [1131:4e85]
7	6 -> Tevion MD 9717	7	6 -> Tevion MD 9717
8	7 -> KNC One TV-Station RDS / Typhoon TV Tuner RDS [1131:fe01,1894:fe01]	8	7 -> KNC One TV-Station RDS / Typhoon TV Tuner RDS [1131:fe01,1894:fe01]
9	8 -> KNC One TV-Station DVR [1894:a006]	9	8 -> Terratec Cinergy 400 TV [153B:1142]
10	9 -> Terratec Cinergy 400 TV [153B:1142]	10	9 -> Medion 5044
11	10 -> Medion 5044	11	10 -> Kworld/KuroutoShikou SAA7130-TVPCI
12	11 -> Kworld/KuroutoShikou SAA7130-TVPCI	12	11 -> Terratec Cinergy 600 TV [153B:1143]
13	12 -> Terratec Cinergy 600 TV [153B:1143]	13	12 -> Medion 7134 [16be:0003]
14	13 -> Medion 7134 [16be:0003]	14	13 -> Typhoon TV+Radio 90031
15	14 -> Typhoon TV+Radio 90031	15	14 -> ELSA EX-VISION 300TV [1048:226b]
16	15 -> ELSA EX-VISION 300TV [1048:226b]	16	15 -> ELSA EX-VISION 500TV [1048:226b]
17	16 -> ELSA EX-VISION 500TV [1048:226b]	17	16 -> ASUS TV-FM 7134 [1043:4842,1043:4830,1043:4840]
18	17 -> ASUS TV-FM 7134 [1043:4842,1043:4830,1043:4840]	18	17 -> AOPEN VA1000 POWER [1131:7133]
19	18 -> AOPEN VA1000 POWER [1131:7133]	19	18 -> BMK MPEX No Tuner
20	19 -> 10MOONS PCI TV CAPTURE CARD [1131:2001]	20	19 -> Compro VideoMate TV [185b:c100]
21	20 -> BMK MPEX No Tuner	21	20 -> Matrox CronosPlus [102B:48d0]
22	21 -> Compro VideoMate TV [185b:c100]	22	21 -> 10MOONS PCI TV CAPTURE CARD [1131:2001]
23	22 -> Matrox CronosPlus [102B:48d0]	23	22 -> Medion 2819/ AverMedia M156 [1461:a70b,1461:2115]
24	23 -> Medion 2819/ AverMedia M156 [1461:a70b,1461:2115]	24	23 -> BMK MPEX Tuner
25	24 -> BMK MPEX Tuner	25	24 -> KNC One TV-Station DVR [1894:a006]
26	25 -> ASUS TV-FM 7133 [1043:4843]	26	25 -> ASUS TV-FM 7133 [1043:4843]
27	26 -> Pinnacle PCTV Stereo (saa7134) [11bd:002b]	27	26 -> Pinnacle PCTV Stereo (saa7134) [11bd:002b]
28	27 -> Manli MuchTV M-TV002	28	27 -> Manli MuchTV M-TV002
29	28 -> Manli MuchTV M-TV001	29	28 -> Manli MuchTV M-TV001
30	29 -> Nagase Sangyo TransGear 3000TV [1461:050c]	30	29 -> Nagase Sangyo TransGear 3000TV [1461:050c]
31	30 -> Elitegroup ECS TVP3XP FM1216 Tuner Card(PAL-BG,FM) [1019:4cb4]	31	30 -> Elitegroup ECS TVP3XP FM1216 Tuner Card(PAL-BG,FM) [1019:4cb4]
32	31 -> Elitegroup ECS TVP3XP FM1236 Tuner Card (NTSC,FM) [1019:4cb5]	32	31 -> Elitegroup ECS TVP3XP FM1236 Tuner Card (NTSC,FM) [1019:4cb5]
33	32 -> AVACS SmartTV	33	32 -> AVACS SmartTV
34	33 -> AVerMedia DVD EZMaker [1461:10ff]	34	33 -> AVerMedia DVD EZMaker [1461:10ff]
		35	34 -> LifeView FlyTV Platinum33 mini [5168:0212]

Lines 18-42 Link Here

(-)linux-2.6.11.orig/arch/x86_64/ia32/ia32_ioctl.c (-20 lines)
18	#define CODE	18	#define CODE
19	#include "compat_ioctl.c"	19	#include "compat_ioctl.c"
20		20
21	#ifndef TIOCGDEV
22	#define TIOCGDEV _IOR('T',0x32, unsigned int)
23	#endif
24	static int tiocgdev(unsigned fd, unsigned cmd, unsigned int __user *ptr)
25	{
26
27	struct file *file = fget(fd);
28	struct tty_struct *real_tty;
29
30	if (!file)
31	return -EBADF;
32	if (file->f_op->ioctl != tty_ioctl)
33	return -EINVAL;
34	real_tty = (struct tty_struct *)file->private_data;
35	if (!real_tty)
36	return -EINVAL;
37	return put_user(new_encode_dev(tty_devnum(real_tty)), ptr);
38	}
39
40	#define RTC_IRQP_READ32 _IOR('p', 0x0b, unsigned int) /* Read IRQ rate */	21	#define RTC_IRQP_READ32 _IOR('p', 0x0b, unsigned int) /* Read IRQ rate */
41	#define RTC_IRQP_SET32 _IOW('p', 0x0c, unsigned int) /* Set IRQ rate */	22	#define RTC_IRQP_SET32 _IOW('p', 0x0c, unsigned int) /* Set IRQ rate */
42	#define RTC_EPOCH_READ32 _IOR('p', 0x0d, unsigned) /* Read epoch */	23	#define RTC_EPOCH_READ32 _IOR('p', 0x0d, unsigned) /* Read epoch */
Lines 176-182 COMPATIBLE_IOCTL(0x4B51) /* KDSHWCLK - Link Here
176	COMPATIBLE_IOCTL(FIOQSIZE)	157	COMPATIBLE_IOCTL(FIOQSIZE)
177		158
178	/* And these ioctls need translation */	159	/* And these ioctls need translation */
179	HANDLE_IOCTL(TIOCGDEV, tiocgdev)
180	/* realtime device */	160	/* realtime device */
181	HANDLE_IOCTL(RTC_IRQP_READ, rtc32_ioctl)	161	HANDLE_IOCTL(RTC_IRQP_READ, rtc32_ioctl)
182	HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl)	162	HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl)

Added Link Here

(-)linux-2.6.11/drivers/media/dvb/frontends/dvb-pll.c (+168 lines)
1	/*
2	* $Id: dvb-pll.c,v 1.7 2005/02/10 11:52:02 kraxel Exp $
3	*
4	* descriptions + helper functions for simple dvb plls.
5	*
6	* (c) 2004 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 <linux/module.h>
24	#include <linux/dvb/frontend.h>
25	#include <asm/types.h>
26
27	#include "dvb-pll.h"
28
29	/* ----------------------------------------------------------- */
30	/* descriptions */
31
32	struct dvb_pll_desc dvb_pll_thomson_dtt7579 = {
33	.name = "Thomson dtt7579",
34	.min = 177000000,
35	.max = 858000000,
36	.count = 5,
37	.entries = {
38	{ 0, 36166667, 166666, 0xb4, 0x03 }, /* go sleep */
39	{ 443250000, 36166667, 166666, 0xb4, 0x02 },
40	{ 542000000, 36166667, 166666, 0xb4, 0x08 },
41	{ 771000000, 36166667, 166666, 0xbc, 0x08 },
42	{ 999999999, 36166667, 166666, 0xf4, 0x08 },
43	},
44	};
45	EXPORT_SYMBOL(dvb_pll_thomson_dtt7579);
46
47	struct dvb_pll_desc dvb_pll_thomson_dtt7610 = {
48	.name = "Thomson dtt7610",
49	.min = 44000000,
50	.max = 958000000,
51	.count = 3,
52	.entries = {
53	{ 157250000, 44000000, 62500, 0x8e, 0x39 },
54	{ 454000000, 44000000, 62500, 0x8e, 0x3a },
55	{ 999999999, 44000000, 62500, 0x8e, 0x3c },
56	},
57	};
58	EXPORT_SYMBOL(dvb_pll_thomson_dtt7610);
59
60	static void thomson_dtt759x_bw(u8 *buf, int bandwidth)
61	{
62	if (BANDWIDTH_7_MHZ == bandwidth)
63	buf[3] \|= 0x10;
64	}
65
66	struct dvb_pll_desc dvb_pll_thomson_dtt759x = {
67	.name = "Thomson dtt759x",
68	.min = 177000000,
69	.max = 896000000,
70	.setbw = thomson_dtt759x_bw,
71	.count = 6,
72	.entries = {
73	{ 0, 36166667, 166666, 0x84, 0x03 },
74	{ 264000000, 36166667, 166666, 0xb4, 0x02 },
75	{ 470000000, 36166667, 166666, 0xbc, 0x02 },
76	{ 735000000, 36166667, 166666, 0xbc, 0x08 },
77	{ 835000000, 36166667, 166666, 0xf4, 0x08 },
78	{ 999999999, 36166667, 166666, 0xfc, 0x08 },
79	},
80	};
81	EXPORT_SYMBOL(dvb_pll_thomson_dtt759x);
82
83	struct dvb_pll_desc dvb_pll_lg_z201 = {
84	.name = "LG z201",
85	.min = 174000000,
86	.max = 862000000,
87	.count = 5,
88	.entries = {
89	{ 0, 36166667, 166666, 0xbc, 0x03 },
90	{ 443250000, 36166667, 166666, 0xbc, 0x01 },
91	{ 542000000, 36166667, 166666, 0xbc, 0x02 },
92	{ 830000000, 36166667, 166666, 0xf4, 0x02 },
93	{ 999999999, 36166667, 166666, 0xfc, 0x02 },
94	},
95	};
96	EXPORT_SYMBOL(dvb_pll_lg_z201);
97
98	struct dvb_pll_desc dvb_pll_unknown_1 = {
99	.name = "unknown 1", /* used by dntv live dvb-t */
100	.min = 174000000,
101	.max = 862000000,
102	.count = 9,
103	.entries = {
104	{ 150000000, 36166667, 166666, 0xb4, 0x01 },
105	{ 173000000, 36166667, 166666, 0xbc, 0x01 },
106	{ 250000000, 36166667, 166666, 0xb4, 0x02 },
107	{ 400000000, 36166667, 166666, 0xbc, 0x02 },
108	{ 420000000, 36166667, 166666, 0xf4, 0x02 },
109	{ 470000000, 36166667, 166666, 0xfc, 0x02 },
110	{ 600000000, 36166667, 166666, 0xbc, 0x08 },
111	{ 730000000, 36166667, 166666, 0xf4, 0x08 },
112	{ 999999999, 36166667, 166666, 0xfc, 0x08 },
113	},
114	};
115	EXPORT_SYMBOL(dvb_pll_unknown_1);
116
117	/* ----------------------------------------------------------- */
118	/* code */
119
120	static int debug = 0;
121	module_param(debug, int, 0644);
122	MODULE_PARM_DESC(debug, "enable verbose debug messages");
123
124	int dvb_pll_configure(struct dvb_pll_desc desc, u8 buf,
125	u32 freq, int bandwidth)
126	{
127	u32 div;
128	int i;
129
130	if (freq != 0 && (freq < desc->min \|\| freq > desc->max))
131	return -EINVAL;
132
133	for (i = 0; i < desc->count; i++) {
134	if (freq > desc->entries[i].limit)
135	continue;
136	break;
137	}
138	if (debug)
139	printk("pll: %s: freq=%d bw=%d \| i=%d/%d\n",
140	desc->name, freq, bandwidth, i, desc->count);
141	BUG_ON(i == desc->count);
142
143	div = (freq + desc->entries[i].offset) / desc->entries[i].stepsize;
144	buf[0] = div >> 8;
145	buf[1] = div & 0xff;
146	buf[2] = desc->entries[i].cb1;
147	buf[3] = desc->entries[i].cb2;
148
149	if (desc->setbw)
150	desc->setbw(buf, bandwidth);
151
152	if (debug)
153	printk("pll: %s: div=%d \| buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
154	desc->name, div, buf[0], buf[1], buf[2], buf[3]);
155
156	return 0;
157	}
158	EXPORT_SYMBOL(dvb_pll_configure);
159
160	MODULE_DESCRIPTION("dvb pll library");
161	MODULE_AUTHOR("Gerd Knorr");
162	MODULE_LICENSE("GPL");
163
164	/*
165	* Local variables:
166	* c-basic-offset: 8
167	* End:
168	*/

Added Link Here

(-)linux-2.6.11/drivers/media/dvb/frontends/dvb-pll.h (+34 lines)
1	/*
2	* $Id: dvb-pll.h,v 1.2 2005/02/10 11:43:41 kraxel Exp $
3	*/
4
5	struct dvb_pll_desc {
6	char *name;
7	u32 min;
8	u32 max;
9	void (setbw)(u8 buf, int bandwidth);
10	int count;
11	struct {
12	u32 limit;
13	u32 offset;
14	u32 stepsize;
15	u8 cb1;
16	u8 cb2;
17	} entries[];
18	};
19
20	extern struct dvb_pll_desc dvb_pll_thomson_dtt7579;
21	extern struct dvb_pll_desc dvb_pll_thomson_dtt759x;
22	extern struct dvb_pll_desc dvb_pll_thomson_dtt7610;
23	extern struct dvb_pll_desc dvb_pll_lg_z201;
24	extern struct dvb_pll_desc dvb_pll_unknown_1;
25
26	int dvb_pll_configure(struct dvb_pll_desc desc, u8 buf,
27	u32 freq, int bandwidth);
28
29	/*
30	* Local variables:
31	* c-basic-offset: 8
32	* compile-command: "make DVB=1"
33	* End:
34	*/

Added Link Here

(-)linux-2.6.11/drivers/media/dvb/frontends/or51132.c (+628 lines)
1	/*
2	* Support for OR51132 (pcHDTV HD-3000) - VSB/QAM
3	*
4	* Copyright (C) 2005 Kirk Lapray <kirk_lapray@bigfoot.com>
5	*
6	* Based on code from Jack Kelliher (kelliher@xmission.com)
7	* Copyright (C) 2002 & pcHDTV, inc.
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22	*
23	*/
24
25	/*
26	* This driver needs two external firmware files. Please copy
27	* "dvb-fe-or51132-vsb.fw" and "dvb-fe-or51132-qam.fw" to
28	* /usr/lib/hotplug/firmware/ or /lib/firmware/
29	* (depending on configuration of firmware hotplug).
30	*/
31	#define OR51132_VSB_FIRMWARE "dvb-fe-or51132-vsb.fw"
32	#define OR51132_QAM_FIRMWARE "dvb-fe-or51132-qam.fw"
33
34	#include <linux/kernel.h>
35	#include <linux/module.h>
36	#include <linux/moduleparam.h>
37	#include <linux/init.h>
38	#include <linux/delay.h>
39	#include <asm/byteorder.h>
40
41	#include "dvb_frontend.h"
42	#include "dvb-pll.h"
43	#include "or51132.h"
44
45	static int debug;
46	#define dprintk(args...) \
47	do { \
48	if (debug) printk(KERN_DEBUG "or51132: " args); \
49	} while (0)
50
51
52	struct or51132_state
53	{
54	struct i2c_adapter* i2c;
55	struct dvb_frontend_ops ops;
56
57	/* Configuration settings */
58	const struct or51132_config* config;
59
60	struct dvb_frontend frontend;
61
62	/* Demodulator private data */
63	fe_modulation_t current_modulation;
64
65	/* Tuner private data */
66	u32 current_frequency;
67	};
68
69	static int i2c_writebytes (struct or51132_state* state, u8 reg, u8 *buf, int len)
70	{
71	int err;
72	struct i2c_msg msg;
73	msg.addr = reg;
74	msg.flags = 0;
75	msg.len = len;
76	msg.buf = buf;
77
78	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
79	printk(KERN_WARNING "or51132: i2c_writebytes error (addr %02x, err == %i)\n", reg, err);
80	return -EREMOTEIO;
81	}
82
83	return 0;
84	}
85
86	static u8 i2c_readbytes (struct or51132_state* state, u8 reg, u8* buf, int len)
87	{
88	int err;
89	struct i2c_msg msg;
90	msg.addr = reg;
91	msg.flags = I2C_M_RD;
92	msg.len = len;
93	msg.buf = buf;
94
95	if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
96	printk(KERN_WARNING "or51132: i2c_readbytes error (addr %02x, err == %i)\n", reg, err);
97	return -EREMOTEIO;
98	}
99
100	return 0;
101	}
102
103	static int or51132_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
104	{
105	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
106	static u8 run_buf[] = {0x7F,0x01};
107	static u8 get_ver_buf[] = {0x04,0x00,0x30,0x00,0x00};
108	u8 rec_buf[14];
109	u8 cmd_buf[14];
110	u32 firmwareAsize, firmwareBsize;
111	int i,ret;
112
113	dprintk("Firmware is %ld bytes\n",fw->size);
114
115	/* Get size of firmware A and B */
116	firmwareAsize = le32_to_cpu(((u32)fw->data));
117	dprintk("FirmwareA is %i bytes\n",firmwareAsize);
118	firmwareBsize = le32_to_cpu(((u32)(fw->data+4)));
119	dprintk("FirmwareB is %i bytes\n",firmwareBsize);
120
121	/* Upload firmware */
122	if ((ret = i2c_writebytes(state,state->config->demod_address,
123	&fw->data[8],firmwareAsize))) {
124	printk(KERN_WARNING "or51132: load_firmware error 1\n");
125	return ret;
126	}
127	msleep(1); /* 1ms */
128	if ((ret = i2c_writebytes(state,state->config->demod_address,
129	&fw->data[8+firmwareAsize],firmwareBsize))) {
130	printk(KERN_WARNING "or51132: load_firmware error 2\n");
131	return ret;
132	}
133	msleep(1); /* 1ms */
134
135	if ((ret = i2c_writebytes(state,state->config->demod_address,
136	run_buf,2))) {
137	printk(KERN_WARNING "or51132: load_firmware error 3\n");
138	return ret;
139	}
140
141	/* Wait at least 5 msec */
142	msleep(20); /* 10ms */
143
144	if ((ret = i2c_writebytes(state,state->config->demod_address,
145	run_buf,2))) {
146	printk(KERN_WARNING "or51132: load_firmware error 4\n");
147	return ret;
148	}
149
150	/* 50ms for operation to begin */
151	msleep(50);
152
153	/* Read back ucode version to besure we loaded correctly and are really up and running */
154	/* Get uCode version */
155	cmd_buf[0] = 0x10;
156	cmd_buf[1] = 0x10;
157	cmd_buf[2] = 0x00;
158	cmd_buf[3] = 0x00;
159	msleep(20); /* 20ms */
160	if ((ret = i2c_writebytes(state,state->config->demod_address,
161	cmd_buf,3))) {
162	printk(KERN_WARNING "or51132: load_firmware error a\n");
163	return ret;
164	}
165
166	cmd_buf[0] = 0x04;
167	cmd_buf[1] = 0x17;
168	cmd_buf[2] = 0x00;
169	cmd_buf[3] = 0x00;
170	msleep(20); /* 20ms */
171	if ((ret = i2c_writebytes(state,state->config->demod_address,
172	cmd_buf,2))) {
173	printk(KERN_WARNING "or51132: load_firmware error b\n");
174	return ret;
175	}
176
177	cmd_buf[0] = 0x00;
178	cmd_buf[1] = 0x00;
179	cmd_buf[2] = 0x00;
180	cmd_buf[3] = 0x00;
181	msleep(20); /* 20ms */
182	if ((ret = i2c_writebytes(state,state->config->demod_address,
183	cmd_buf,2))) {
184	printk(KERN_WARNING "or51132: load_firmware error c\n");
185	return ret;
186	}
187
188	for(i=0;i<4;i++) {
189	msleep(20); /* 20ms */
190	get_ver_buf[4] = i+1;
191	if ((ret = i2c_readbytes(state,state->config->demod_address,
192	&rec_buf[i*2],2))) {
193	printk(KERN_WARNING
194	"or51132: load_firmware error d - %d\n",i);
195	return ret;
196	}
197	}
198
199	printk(KERN_WARNING
200	"or51132: Version: %02X%02X%02X%02X-%02X%02X%02X%02X (%02X%01X-%01X-%02X%01X-%01X)\n",
201	rec_buf[1],rec_buf[0],rec_buf[3],rec_buf[2],
202	rec_buf[5],rec_buf[4],rec_buf[7],rec_buf[6],
203	rec_buf[3],rec_buf[2]>>4,rec_buf[2]&0x0f,
204	rec_buf[5],rec_buf[4]>>4,rec_buf[4]&0x0f);
205
206	cmd_buf[0] = 0x10;
207	cmd_buf[1] = 0x00;
208	cmd_buf[2] = 0x00;
209	cmd_buf[3] = 0x00;
210	msleep(20); /* 20ms */
211	if ((ret = i2c_writebytes(state,state->config->demod_address,
212	cmd_buf,3))) {
213	printk(KERN_WARNING "or51132: load_firmware error e\n");
214	return ret;
215	}
216	return 0;
217	};
218
219	static int or51132_init(struct dvb_frontend* fe)
220	{
221	return 0;
222	}
223
224	static int or51132_read_ber(struct dvb_frontend* fe, u32* ber)
225	{
226	*ber = 0;
227	return 0;
228	}
229
230	static int or51132_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
231	{
232	*ucblocks = 0;
233	return 0;
234	}
235
236	static int or51132_sleep(struct dvb_frontend* fe)
237	{
238	return 0;
239	}
240
241	static int or51132_setmode(struct dvb_frontend* fe)
242	{
243	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
244	unsigned char cmd_buf[4];
245
246	dprintk("setmode %d\n",(int)state->current_modulation);
247	/* set operation mode in Receiver 1 register; */
248	cmd_buf[0] = 0x04;
249	cmd_buf[1] = 0x01;
250	switch (state->current_modulation) {
251	case QAM_256:
252	case QAM_64:
253	case QAM_AUTO:
254	/* Auto-deinterleave; MPEG ser, MPEG2tr, phase noise-high*/
255	cmd_buf[2] = 0x5F;
256	break;
257	case VSB_8:
258	/* Auto CH, Auto NTSC rej, MPEGser, MPEG2tr, phase noise-high*/
259	cmd_buf[2] = 0x50;
260	break;
261	default:
262	printk("setmode:Modulation set to unsupported value\n");
263	};
264	cmd_buf[3] = 0x00;
265	if (i2c_writebytes(state,state->config->demod_address,
266	cmd_buf,3)) {
267	printk(KERN_WARNING "or51132: set_mode error 1\n");
268	return -1;
269	}
270	dprintk("or51132: set #1 to %02x\n", cmd_buf[2]);
271
272	/* Set operation mode in Receiver 6 register */
273	cmd_buf[0] = 0x1C;
274	switch (state->current_modulation) {
275	case QAM_AUTO:
276	/* REC MODE Normal Carrier Lock */
277	cmd_buf[1] = 0x00;
278	/* Channel MODE Auto QAM64/256 */
279	cmd_buf[2] = 0x4f;
280	break;
281	case QAM_256:
282	/* REC MODE Normal Carrier Lock */
283	cmd_buf[1] = 0x00;
284	/* Channel MODE QAM256 */
285	cmd_buf[2] = 0x45;
286	break;
287	case QAM_64:
288	/* REC MODE Normal Carrier Lock */
289	cmd_buf[1] = 0x00;
290	/* Channel MODE QAM64 */
291	cmd_buf[2] = 0x43;
292	break;
293	case VSB_8:
294	/* REC MODE inv IF spectrum, Normal */
295	cmd_buf[1] = 0x03;
296	/* Channel MODE ATSC/VSB8 */
297	cmd_buf[2] = 0x06;
298	break;
299	default:
300	printk("setmode: Modulation set to unsupported value\n");
301	};
302	cmd_buf[3] = 0x00;
303	msleep(20); /* 20ms */
304	if (i2c_writebytes(state,state->config->demod_address,
305	cmd_buf,3)) {
306	printk(KERN_WARNING "or51132: set_mode error 2\n");
307	return -1;
308	}
309	dprintk("or51132: set #6 to 0x%02x%02x\n", cmd_buf[1], cmd_buf[2]);
310
311	return 0;
312	}
313
314	static int or51132_set_parameters(struct dvb_frontend* fe,
315	struct dvb_frontend_parameters *param)
316	{
317	int ret;
318	u8 buf[4];
319	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
320	const struct firmware *fw;
321
322	/* Change only if we are actually changing the modulation */
323	if (state->current_modulation != param->u.vsb.modulation) {
324	switch(param->u.vsb.modulation) {
325	case VSB_8:
326	dprintk("set_parameters VSB MODE\n");
327	printk("or51132: Waiting for firmware upload(%s)...\n",
328	OR51132_VSB_FIRMWARE);
329	ret = request_firmware(&fw, OR51132_VSB_FIRMWARE,
330	&state->i2c->dev);
331	if (ret){
332	printk(KERN_WARNING "or51132: No firmware up"
333	"loaded(timeout or file not found?)\n");
334	return ret;
335	}
336	/* Set non-punctured clock for VSB */
337	state->config->set_ts_params(fe, 0);
338	break;
339	case QAM_AUTO:
340	case QAM_64:
341	case QAM_256:
342	dprintk("set_parameters QAM MODE\n");
343	printk("or51132: Waiting for firmware upload(%s)...\n",
344	OR51132_QAM_FIRMWARE);
345	ret = request_firmware(&fw, OR51132_QAM_FIRMWARE,
346	&state->i2c->dev);
347	if (ret){
348	printk(KERN_WARNING "or51132: No firmware up"
349	"loaded(timeout or file not found?)\n");
350	return ret;
351	}
352	/* Set punctured clock for QAM */
353	state->config->set_ts_params(fe, 1);
354	break;
355	default:
356	printk("or51132:Modulation type(%d) UNSUPPORTED\n",
357	param->u.vsb.modulation);
358	return -1;
359	};
360	ret = or51132_load_firmware(fe, fw);
361	release_firmware(fw);
362	if (ret) {
363	printk(KERN_WARNING "or51132: Writing firmware to "
364	"device failed!\n");
365	return ret;
366	}
367	printk("or51132: Firmware upload complete.\n");
368
369	state->current_modulation = param->u.vsb.modulation;
370	or51132_setmode(fe);
371	}
372
373	/* Change only if we are actually changing the channel */
374	if (state->current_frequency != param->frequency) {
375	dvb_pll_configure(state->config->pll_desc, buf,
376	param->frequency, 0);
377	dprintk("set_parameters tuner bytes: 0x%02x 0x%02x "
378	"0x%02x 0x%02x\n",buf[0],buf[1],buf[2],buf[3]);
379	if (i2c_writebytes(state, state->config->pll_address ,buf, 4))
380	printk(KERN_WARNING "or51132: set_parameters error "
381	"writing to tuner\n");
382
383	/* Set to current mode */
384	or51132_setmode(fe);
385
386	/* Update current frequency */
387	state->current_frequency = param->frequency;
388	}
389	return 0;
390	}
391
392	static int or51132_read_status(struct dvb_frontend* fe, fe_status_t* status)
393	{
394	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
395	unsigned char rec_buf[2];
396	unsigned char snd_buf[2];
397	*status = 0;
398
399	/* Receiver Status */
400	snd_buf[0]=0x04;
401	snd_buf[1]=0x00;
402	msleep(30); /* 30ms */
403	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
404	printk(KERN_WARNING "or51132: read_status write error\n");
405	return -1;
406	}
407	msleep(30); /* 30ms */
408	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
409	printk(KERN_WARNING "or51132: read_status read error\n");
410	return -1;
411	}
412	dprintk("read_status %x %x\n",rec_buf[0],rec_buf[1]);
413
414	if (rec_buf[1] & 0x01) { /* Receiver Lock */
415	*status \|= FE_HAS_SIGNAL;
416	*status \|= FE_HAS_CARRIER;
417	*status \|= FE_HAS_VITERBI;
418	*status \|= FE_HAS_SYNC;
419	*status \|= FE_HAS_LOCK;
420	}
421	return 0;
422	}
423
424	/* log10-1 table at .5 increments from 1 to 100.5 */
425	unsigned int i100x20log10[] = {
426	0, 352, 602, 795, 954, 1088, 1204, 1306, 1397, 1480,
427	1556, 1625, 1690, 1750, 1806, 1858, 1908, 1955, 2000, 2042,
428	2082, 2121, 2158, 2193, 2227, 2260, 2292, 2322, 2352, 2380,
429	2408, 2434, 2460, 2486, 2510, 2534, 2557, 2580, 2602, 2623,
430	2644, 2664, 2684, 2704, 2723, 2742, 2760, 2778, 2795, 2813,
431	2829, 2846, 2862, 2878, 2894, 2909, 2924, 2939, 2954, 2968,
432	2982, 2996, 3010, 3023, 3037, 3050, 3062, 3075, 3088, 3100,
433	3112, 3124, 3136, 3148, 3159, 3170, 3182, 3193, 3204, 3214,
434	3225, 3236, 3246, 3256, 3266, 3276, 3286, 3296, 3306, 3316,
435	3325, 3334, 3344, 3353, 3362, 3371, 3380, 3389, 3397, 3406,
436	3415, 3423, 3432, 3440, 3448, 3456, 3464, 3472, 3480, 3488,
437	3496, 3504, 3511, 3519, 3526, 3534, 3541, 3549, 3556, 3563,
438	3570, 3577, 3584, 3591, 3598, 3605, 3612, 3619, 3625, 3632,
439	3639, 3645, 3652, 3658, 3665, 3671, 3677, 3683, 3690, 3696,
440	3702, 3708, 3714, 3720, 3726, 3732, 3738, 3744, 3750, 3755,
441	3761, 3767, 3772, 3778, 3784, 3789, 3795, 3800, 3806, 3811,
442	3816, 3822, 3827, 3832, 3838, 3843, 3848, 3853, 3858, 3863,
443	3868, 3874, 3879, 3884, 3888, 3893, 3898, 3903, 3908, 3913,
444	3918, 3922, 3927, 3932, 3936, 3941, 3946, 3950, 3955, 3960,
445	3964, 3969, 3973, 3978, 3982, 3986, 3991, 3995, 4000, 4004,
446	};
447
448	unsigned int denom[] = {1,1,100,1000,10000,100000,1000000,10000000,100000000};
449
450	unsigned int i20Log10(unsigned short val)
451	{
452	unsigned int rntval = 100;
453	unsigned int tmp = val;
454	unsigned int exp = 1;
455
456	while(tmp > 100) {tmp /= 100; exp++;}
457
458	val = (2 * val)/denom[exp];
459	if (exp > 1) rntval = 2000*exp;
460
461	rntval += i100x20log10[val];
462	return rntval;
463	}
464
465	static int or51132_read_signal_strength(struct dvb_frontend* fe, u16* strength)
466	{
467	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
468	unsigned char rec_buf[2];
469	unsigned char snd_buf[2];
470	u8 rcvr_stat;
471	u16 snr_equ;
472	int usK;
473
474	snd_buf[0]=0x04;
475	snd_buf[1]=0x02; /* SNR after Equalizer */
476	msleep(30); /* 30ms */
477	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
478	printk(KERN_WARNING "or51132: read_status write error\n");
479	return -1;
480	}
481	msleep(30); /* 30ms */
482	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
483	printk(KERN_WARNING "or51132: read_status read error\n");
484	return -1;
485	}
486	snr_equ = rec_buf[0] \| (rec_buf[1] << 8);
487	dprintk("read_signal_strength snr_equ %x %x (%i)\n",rec_buf[0],rec_buf[1],snr_equ);
488
489	/* Receiver Status */
490	snd_buf[0]=0x04;
491	snd_buf[1]=0x00;
492	msleep(30); /* 30ms */
493	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
494	printk(KERN_WARNING "or51132: read_signal_strength read_status write error\n");
495	return -1;
496	}
497	msleep(30); /* 30ms */
498	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
499	printk(KERN_WARNING "or51132: read_signal_strength read_status read error\n");
500	return -1;
501	}
502	dprintk("read_signal_strength read_status %x %x\n",rec_buf[0],rec_buf[1]);
503	rcvr_stat = rec_buf[1];
504	usK = (rcvr_stat & 0x10) ? 3 : 0;
505
506	/* The value reported back from the frontend will be FFFF=100% 0000=0% */
507	strength = (((8952 - i20Log10(snr_equ) - usK100)/3+5)*65535)/1000;
508	dprintk("read_signal_strength %i\n",*strength);
509
510	return 0;
511	}
512
513	static int or51132_read_snr(struct dvb_frontend* fe, u16* snr)
514	{
515	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
516	unsigned char rec_buf[2];
517	unsigned char snd_buf[2];
518	u16 snr_equ;
519
520	snd_buf[0]=0x04;
521	snd_buf[1]=0x02; /* SNR after Equalizer */
522	msleep(30); /* 30ms */
523	if (i2c_writebytes(state,state->config->demod_address,snd_buf,2)) {
524	printk(KERN_WARNING "or51132: read_snr write error\n");
525	return -1;
526	}
527	msleep(30); /* 30ms */
528	if (i2c_readbytes(state,state->config->demod_address,rec_buf,2)) {
529	printk(KERN_WARNING "or51132: read_snr dvr read error\n");
530	return -1;
531	}
532	snr_equ = rec_buf[0] \| (rec_buf[1] << 8);
533	dprintk("read_snr snr_equ %x %x (%i)\n",rec_buf[0],rec_buf[1],snr_equ);
534
535	*snr = 0xFFFF - snr_equ;
536	dprintk("read_snr %i\n",*snr);
537
538	return 0;
539	}
540
541	static int or51132_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
542	{
543	fe_tune_settings->min_delay_ms = 500;
544	fe_tune_settings->step_size = 0;
545	fe_tune_settings->max_drift = 0;
546
547	return 0;
548	}
549
550	static void or51132_release(struct dvb_frontend* fe)
551	{
552	struct or51132_state* state = (struct or51132_state*) fe->demodulator_priv;
553	kfree(state);
554	}
555
556	static struct dvb_frontend_ops or51132_ops;
557
558	struct dvb_frontend* or51132_attach(const struct or51132_config* config,
559	struct i2c_adapter* i2c)
560	{
561	struct or51132_state* state = NULL;
562
563	/* Allocate memory for the internal state */
564	state = kmalloc(sizeof(struct or51132_state), GFP_KERNEL);
565	if (state == NULL)
566	goto error;
567
568	/* Setup the state */
569	state->config = config;
570	state->i2c = i2c;
571	memcpy(&state->ops, &or51132_ops, sizeof(struct dvb_frontend_ops));
572	state->current_frequency = -1;
573	state->current_modulation = -1;
574
575	/* Create dvb_frontend */
576	state->frontend.ops = &state->ops;
577	state->frontend.demodulator_priv = state;
578	return &state->frontend;
579
580	error:
581	if (state)
582	kfree(state);
583	return NULL;
584	}
585
586	static struct dvb_frontend_ops or51132_ops = {
587
588	.info = {
589	.name = "Oren OR51132 VSB/QAM Frontend",
590	.type = FE_ATSC,
591	.frequency_min = 44000000,
592	.frequency_max = 958000000,
593	.frequency_stepsize = 166666,
594	.caps = FE_CAN_FEC_1_2 \| FE_CAN_FEC_2_3 \| FE_CAN_FEC_3_4 \|
595	FE_CAN_FEC_5_6 \| FE_CAN_FEC_7_8 \| FE_CAN_FEC_AUTO \|
596	FE_CAN_QAM_64 \| FE_CAN_QAM_256 \| FE_CAN_QAM_AUTO \|
597	FE_CAN_8VSB
598	},
599
600	.release = or51132_release,
601
602	.init = or51132_init,
603	.sleep = or51132_sleep,
604
605	.set_frontend = or51132_set_parameters,
606	.get_tune_settings = or51132_get_tune_settings,
607
608	.read_status = or51132_read_status,
609	.read_ber = or51132_read_ber,
610	.read_signal_strength = or51132_read_signal_strength,
611	.read_snr = or51132_read_snr,
612	.read_ucblocks = or51132_read_ucblocks,
613	};
614
615	module_param(debug, int, 0644);
616	MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
617
618	MODULE_DESCRIPTION("OR51132 ATSC [pcHDTV HD-3000] (8VSB & ITU J83 AnnexB FEC QAM64/256) Demodulator Driver");
619	MODULE_AUTHOR("Kirk Lapray");
620	MODULE_LICENSE("GPL");
621
622	EXPORT_SYMBOL(or51132_attach);
623
624	/*
625	* Local variables:
626	* c-basic-offset: 8
627	* End:
628	*/

Lines 75-83 static int pcm20_getflags(struct pcm20_d Link Here

(-)linux-2.6.11.orig/drivers/media/radio/miropcm20-radio.c (-9 / +3 lines)
75		75
76	if ((i=aci_rw_cmd(ACI_READ_TUNERSTATION, -1, -1))<0)	76	if ((i=aci_rw_cmd(ACI_READ_TUNERSTATION, -1, -1))<0)
77	return i;	77	return i;
78	#ifdef DEBUG	78	pr_debug("check_sig: 0x%x\n", i);
79	printk("check_sig: 0x%x\n", i);
80	#endif
81	if (i & 0x80) {	79	if (i & 0x80) {
82	/* no signal from tuner */	80	/* no signal from tuner */
83	*flags=0;	81	*flags=0;
Lines 107-115 static int pcm20_getflags(struct pcm20_d Link Here
107		105
108	if ((i=aci_rds_cmd(RDS_RXVALUE, &buf, 1))<0)	106	if ((i=aci_rds_cmd(RDS_RXVALUE, &buf, 1))<0)
109	return i;	107	return i;
110	#ifdef DEBUG	108	pr_debug("rds-signal: %d\n", buf);
111	printk("rds-signal: %d\n", buf);
112	#endif
113	if (buf > 15) {	109	if (buf > 15) {
114	printk("miropcm20-radio: RX strengths unexpected high...\n");	110	printk("miropcm20-radio: RX strengths unexpected high...\n");
115	buf=15;	111	buf=15;
Lines 172-180 static int pcm20_do_ioctl(struct inode * Link Here
172	unsigned long *freq = arg;	168	unsigned long *freq = arg;
173	pcm20->freq = *freq;	169	pcm20->freq = *freq;
174	i=pcm20_setfreq(pcm20, pcm20->freq);	170	i=pcm20_setfreq(pcm20, pcm20->freq);
175	#ifdef DEBUG	171	pr_debug("First view (setfreq): 0x%x\n", i);
176	printk("First view (setfreq): 0x%x\n", i);
177	#endif
178	return i;	172	return i;
179	}	173	}
180	case VIDIOCGAUDIO:	174	case VIDIOCGAUDIO:

Lines 29-35 Link Here

(-)linux-2.6.11.orig/drivers/media/radio/radio-zoltrix.c (-19 / +7 lines)
29	#include <linux/module.h> /* Modules */	29	#include <linux/module.h> /* Modules */
30	#include <linux/init.h> /* Initdata */	30	#include <linux/init.h> /* Initdata */
31	#include <linux/ioport.h> /* check_region, request_region */	31	#include <linux/ioport.h> /* check_region, request_region */
32	#include <linux/delay.h> /* udelay */	32	#include <linux/delay.h> /* udelay, msleep */
33	#include <asm/io.h> /* outb, outb_p */	33	#include <asm/io.h> /* outb, outb_p */
34	#include <asm/uaccess.h> /* copy to/from user */	34	#include <asm/uaccess.h> /* copy to/from user */
35	#include <linux/videodev.h> /* kernel radio structs */	35	#include <linux/videodev.h> /* kernel radio structs */
Lines 51-65 struct zol_device { Link Here
51	struct semaphore lock;	51	struct semaphore lock;
52	};	52	};
53		53
54
55	/* local things */
56
57	static void sleep_delay(void)
58	{
59	/* Sleep nicely for +/- 10 mS */
60	schedule();
61	}
62
63	static int zol_setvol(struct zol_device *dev, int vol)	54	static int zol_setvol(struct zol_device *dev, int vol)
64	{	55	{
65	dev->curvol = vol;	56	dev->curvol = vol;
Lines 76-82 static int zol_setvol(struct zol_device Link Here
76	}	67	}
77		68
78	outb(dev->curvol-1, io);	69	outb(dev->curvol-1, io);
79	sleep_delay();	70	msleep(10);
80	inb(io + 2);	71	inb(io + 2);
81	up(&dev->lock);	72	up(&dev->lock);
82	return 0;	73	return 0;
Lines 176-186 static int zol_getsigstr(struct zol_devi Link Here
176	down(&dev->lock);	167	down(&dev->lock);
177	outb(0x00, io); /* This stuff I found to do nothing */	168	outb(0x00, io); /* This stuff I found to do nothing */
178	outb(dev->curvol, io);	169	outb(dev->curvol, io);
179	sleep_delay();	170	msleep(20);
180	sleep_delay();
181		171
182	a = inb(io);	172	a = inb(io);
183	sleep_delay();	173	msleep(10);
184	b = inb(io);	174	b = inb(io);
185		175
186	up(&dev->lock);	176	up(&dev->lock);
Lines 202-212 static int zol_is_stereo (struct zol_dev Link Here
202		192
203	outb(0x00, io);	193	outb(0x00, io);
204	outb(dev->curvol, io);	194	outb(dev->curvol, io);
205	sleep_delay();	195	msleep(20);
206	sleep_delay();
207		196
208	x1 = inb(io);	197	x1 = inb(io);
209	sleep_delay();	198	msleep(10);
210	x2 = inb(io);	199	x2 = inb(io);
211		200
212	up(&dev->lock);	201	up(&dev->lock);
Lines 368-375 static int __init zoltrix_init(void) Link Here
368		357
369	outb(0, io);	358	outb(0, io);
370	outb(0, io);	359	outb(0, io);
371	sleep_delay();	360	msleep(20);
372	sleep_delay();
373	inb(io + 3);	361	inb(io + 3);
374		362
375	zoltrix_unit.curvol = 0;	363	zoltrix_unit.curvol = 0;

Lines 6-12 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bt832.c (-18 / +28 lines)
6	It outputs an 8-bit 4:2:2 YUV or YCrCb video signal which can be directly	6	It outputs an 8-bit 4:2:2 YUV or YCrCb video signal which can be directly
7	connected to bt848/bt878 GPIO pins on this purpose.	7	connected to bt848/bt878 GPIO pins on this purpose.
8	(see: VLSI Vision Ltd. www.vvl.co.uk for camera datasheets)	8	(see: VLSI Vision Ltd. www.vvl.co.uk for camera datasheets)
9		9
10	Supported Cards:	10	Supported Cards:
11	- Pixelview Rev.4E: 0x8a	11	- Pixelview Rev.4E: 0x8a
12	GPIO 0x400000 toggles Bt832 RESET, and the chip changes to i2c 0x88 !	12	GPIO 0x400000 toggles Bt832 RESET, and the chip changes to i2c 0x88 !
Lines 31-38 Link Here
31	#include <linux/errno.h>	31	#include <linux/errno.h>
32	#include <linux/slab.h>	32	#include <linux/slab.h>
33		33
34	#include "id.h"	34	#include <media/audiochip.h>
35	#include "audiochip.h"	35	#include <media/id.h>
36	#include "bttv.h"	36	#include "bttv.h"
37	#include "bt832.h"	37	#include "bt832.h"
38		38
Lines 95-101 int bt832_init(struct i2c_client *i2c_cl Link Here
95		95
96	buf=kmalloc(65,GFP_KERNEL);	96	buf=kmalloc(65,GFP_KERNEL);
97	bt832_hexdump(i2c_client_s,buf);	97	bt832_hexdump(i2c_client_s,buf);
98		98
99	if(buf[0x40] != 0x31) {	99	if(buf[0x40] != 0x31) {
100	printk("bt832: this i2c chip is no bt832 (id=%02x). Detaching.\n",buf[0x40]);	100	printk("bt832: this i2c chip is no bt832 (id=%02x). Detaching.\n",buf[0x40]);
101	kfree(buf);	101	kfree(buf);
Lines 135-141 int bt832_init(struct i2c_client *i2c_cl Link Here
135	buf[1]= 0x27 & (~0x01); // Default \| !skip	135	buf[1]= 0x27 & (~0x01); // Default \| !skip
136	if (2 != (rc = i2c_master_send(i2c_client_s,buf,2)))	136	if (2 != (rc = i2c_master_send(i2c_client_s,buf,2)))
137	printk("bt832: i2c i/o error EO: rc == %d (should be 2)\n",rc);	137	printk("bt832: i2c i/o error EO: rc == %d (should be 2)\n",rc);
138		138
139	bt832_hexdump(i2c_client_s,buf);	139	bt832_hexdump(i2c_client_s,buf);
140		140
141	#if 0	141	#if 0
Lines 168-175 int bt832_init(struct i2c_client *i2c_cl Link Here
168		168
169		169
170		170
171	static int bt832_attach(struct i2c_adapter *adap, int addr,	171	static int bt832_attach(struct i2c_adapter *adap, int addr, int kind)
172	unsigned short flags, int kind)
173	{	172	{
174	struct bt832 *t;	173	struct bt832 *t;
175		174
Lines 184-210 static int bt832_attach(struct i2c_adapt Link Here
184	return -ENOMEM;	183	return -ENOMEM;
185	memset(t,0,sizeof(*t));	184	memset(t,0,sizeof(*t));
186	t->client = client_template;	185	t->client = client_template;
187	t->client.data = t;	186	i2c_set_clientdata(&t->client, t);
188	i2c_attach_client(&t->client);	187	i2c_attach_client(&t->client);
189		188
190	if(! bt832_init(&t->client)) {	189	if(! bt832_init(&t->client)) {
191	bt832_detach(&t->client);	190	bt832_detach(&t->client);
192	return -1;	191	return -1;
193	}	192	}
194		193
195	return 0;	194	return 0;
196	}	195	}
197		196
198	static int bt832_probe(struct i2c_adapter *adap)	197	static int bt832_probe(struct i2c_adapter *adap)
199	{	198	{
		199	#ifdef I2C_CLASS_TV_ANALOG
200	if (adap->class & I2C_CLASS_TV_ANALOG)	200	if (adap->class & I2C_CLASS_TV_ANALOG)
201	return i2c_probe(adap, &addr_data, bt832_attach);	201	return i2c_probe(adap, &addr_data, bt832_attach);
		202	#else
		203	if (adap->id == (I2C_ALGO_BIT \| I2C_HW_B_BT848))
		204	return i2c_probe(adap, &addr_data, bt832_attach);
		205	#endif
202	return 0;	206	return 0;
203	}	207	}
204		208
205	static int bt832_detach(struct i2c_client *client)	209	static int bt832_detach(struct i2c_client *client)
206	{	210	{
207	struct bt832 t = (struct bt832)client->data;	211	struct bt832 *t = i2c_get_clientdata(client);
208		212
209	printk("bt832: detach.\n");	213	printk("bt832: detach.\n");
210	i2c_detach_client(client);	214	i2c_detach_client(client);
Lines 215-221 static int bt832_detach(struct i2c_clien Link Here
215	static int	219	static int
216	bt832_command(struct i2c_client client, unsigned int cmd, void arg)	220	bt832_command(struct i2c_client client, unsigned int cmd, void arg)
217	{	221	{
218	struct bt832 t = (struct bt832)client->data;	222	struct bt832 *t = i2c_get_clientdata(client);
219		223
220	printk("bt832: command %x\n",cmd);	224	printk("bt832: command %x\n",cmd);
221		225
Lines 249-267 static struct i2c_driver driver = { Link Here
249	};	253	};
250	static struct i2c_client client_template =	254	static struct i2c_client client_template =
251	{	255	{
252	.name = "bt832",	256	I2C_DEVNAME("bt832"),
253	.flags = I2C_CLIENT_ALLOW_USE,	257	.flags = I2C_CLIENT_ALLOW_USE,
254	.driver = &driver,	258	.driver = &driver,
255	};	259	};
256		260
257		261
258	int bt832_init_module(void)	262	static int __init bt832_init_module(void)
259	{	263	{
260	i2c_add_driver(&driver);	264	return i2c_add_driver(&driver);
261	return 0;
262	}	265	}
263		266
264	static void bt832_cleanup_module(void)	267	static void __exit bt832_cleanup_module(void)
265	{	268	{
266	i2c_del_driver(&driver);	269	i2c_del_driver(&driver);
267	}	270	}
Lines 269-271 static void bt832_cleanup_module(void) Link Here
269	module_init(bt832_init_module);	272	module_init(bt832_init_module);
270	module_exit(bt832_cleanup_module);	273	module_exit(bt832_cleanup_module);
271		274
		275	/*
		276	* Overrides for Emacs so that we follow Linus's tabbing style.
		277	* ---------------------------------------------------------------------------
		278	* Local variables:
		279	* c-basic-offset: 8
		280	* End:
		281	*/

Lines 1-6 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bt832.h (-18 / +18 lines)
1	/* Bt832 CMOS Camera Video Processor (VP)	1	/* Bt832 CMOS Camera Video Processor (VP)
2		2
3	The Bt832 CMOS Camera Video Processor chip connects a Quartsight CMOS	3	The Bt832 CMOS Camera Video Processor chip connects a Quartsight CMOS
4	color digital camera directly to video capture devices via an 8-bit,	4	color digital camera directly to video capture devices via an 8-bit,
5	4:2:2 YUV or YCrCb video interface.	5	4:2:2 YUV or YCrCb video interface.
6		6
Lines 85-91 Link Here
85	#define BT832_DEVICE_ID 63	85	#define BT832_DEVICE_ID 63
86	# define BT832_DEVICE_ID__31 0x31 // Bt832 has ID 0x31	86	# define BT832_DEVICE_ID__31 0x31 // Bt832 has ID 0x31
87		87
88	/* STMicroelectronivcs VV5404 camera module	88	/* STMicroelectronivcs VV5404 camera module
89	i2c: 0x20: sensor address	89	i2c: 0x20: sensor address
90	i2c: 0xa0: eeprom for ccd defect map	90	i2c: 0xa0: eeprom for ccd defect map
91	*/	91	*/
Lines 256-281 For the CCIR-601 standards, the sampling Link Here
256	//===========================================================================	256	//===========================================================================
257	// Timing generator SRAM table values for CCIR601 720x480 NTSC	257	// Timing generator SRAM table values for CCIR601 720x480 NTSC
258	//===========================================================================	258	//===========================================================================
259	// For NTSC CCIR656	259	// For NTSC CCIR656
260	BYTE BtCard::SRAMTable_NTSC[] =	260	BYTE BtCard::SRAMTable_NTSC[] =
261	{	261	{
262	// SRAM Timing Table for NTSC	262	// SRAM Timing Table for NTSC
263	0x0c, 0xc0, 0x00,	263	0x0c, 0xc0, 0x00,
264	0x00, 0x90, 0xc2,	264	0x00, 0x90, 0xc2,
265	0x03, 0x10, 0x03,	265	0x03, 0x10, 0x03,
266	0x06, 0x10, 0x34,	266	0x06, 0x10, 0x34,
267	0x12, 0x12, 0x65,	267	0x12, 0x12, 0x65,
268	0x02, 0x13, 0x24,	268	0x02, 0x13, 0x24,
269	0x19, 0x00, 0x24,	269	0x19, 0x00, 0x24,
270	0x39, 0x00, 0x96,	270	0x39, 0x00, 0x96,
271	0x59, 0x08, 0x93,	271	0x59, 0x08, 0x93,
272	0x83, 0x08, 0x97,	272	0x83, 0x08, 0x97,
273	0x03, 0x50, 0x30,	273	0x03, 0x50, 0x30,
274	0xc0, 0x40, 0x30,	274	0xc0, 0x40, 0x30,
275	0x86, 0x01, 0x01,	275	0x86, 0x01, 0x01,
276	0xa6, 0x0d, 0x62,	276	0xa6, 0x0d, 0x62,
277	0x03, 0x11, 0x61,	277	0x03, 0x11, 0x61,
278	0x05, 0x37, 0x30,	278	0x05, 0x37, 0x30,
279	0xac, 0x21, 0x50	279	0xac, 0x21, 0x50
280	};	280	};
281		281

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/btcx-risc.c (-5 / +7 lines)
1	/*	1	/*
2	$Id: btcx-risc.c,v 1.5 2004/12/10 12:33:39 kraxel Exp $	2	$Id: btcx-risc.c,v 1.6 2005/02/21 13:57:59 kraxel Exp $
3		3
4	btcx-risc.c	4	btcx-risc.c
5		5
Lines 52-63 void btcx_riscmem_free(struct pci_dev *p Link Here
52	{	52	{
53	if (NULL == risc->cpu)	53	if (NULL == risc->cpu)
54	return;	54	return;
55	pci_free_consistent(pci, risc->size, risc->cpu, risc->dma);
56	memset(risc,0,sizeof(*risc));
57	if (debug) {	55	if (debug) {
58	memcnt--;	56	memcnt--;
59	printk("btcx: riscmem free [%d]\n",memcnt);	57	printk("btcx: riscmem free [%d] dma=%lx\n",
		58	memcnt, (unsigned long)risc->dma);
60	}	59	}
		60	pci_free_consistent(pci, risc->size, risc->cpu, risc->dma);
		61	memset(risc,0,sizeof(*risc));
61	}	62	}
62		63
63	int btcx_riscmem_alloc(struct pci_dev *pci,	64	int btcx_riscmem_alloc(struct pci_dev *pci,
Lines 78-84 int btcx_riscmem_alloc(struct pci_dev *p Link Here
78	risc->size = size;	79	risc->size = size;
79	if (debug) {	80	if (debug) {
80	memcnt++;	81	memcnt++;
81	printk("btcx: riscmem alloc size=%d [%d]\n",size,memcnt);	82	printk("btcx: riscmem alloc [%d] dma=%lx cpu=%p size=%d\n",
		83	memcnt, (unsigned long)dma, cpu, size);
82	}	84	}
83	}	85	}
84	memset(risc->cpu,0,risc->size);	86	memset(risc->cpu,0,risc->size);

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bttv-driver.c (-17 / +78 lines)
1	/*	1	/*
2	$Id: bttv-driver.c,v 1.34 2005/01/07 13:11:19 kraxel Exp $	2	$Id: bttv-driver.c,v 1.37 2005/02/21 13:57:59 kraxel Exp $
3		3
4	bttv - Bt848 frame grabber driver	4	bttv - Bt848 frame grabber driver
5		5
Lines 3167-3172 static struct video_device radio_templat Link Here
3167	};	3167	};
3168		3168
3169	/* ----------------------------------------------------------------------- */	3169	/* ----------------------------------------------------------------------- */
		3170	/* some debug code */
		3171
		3172	int bttv_risc_decode(u32 risc)
		3173	{
		3174	static char *instr[16] = {
		3175	[ BT848_RISC_WRITE >> 28 ] = "write",
		3176	[ BT848_RISC_SKIP >> 28 ] = "skip",
		3177	[ BT848_RISC_WRITEC >> 28 ] = "writec",
		3178	[ BT848_RISC_JUMP >> 28 ] = "jump",
		3179	[ BT848_RISC_SYNC >> 28 ] = "sync",
		3180	[ BT848_RISC_WRITE123 >> 28 ] = "write123",
		3181	[ BT848_RISC_SKIP123 >> 28 ] = "skip123",
		3182	[ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
		3183	};
		3184	static int incr[16] = {
		3185	[ BT848_RISC_WRITE >> 28 ] = 2,
		3186	[ BT848_RISC_JUMP >> 28 ] = 2,
		3187	[ BT848_RISC_SYNC >> 28 ] = 2,
		3188	[ BT848_RISC_WRITE123 >> 28 ] = 5,
		3189	[ BT848_RISC_SKIP123 >> 28 ] = 2,
		3190	[ BT848_RISC_WRITE1S23 >> 28 ] = 3,
		3191	};
		3192	static char *bits[] = {
		3193	"be0", "be1", "be2", "be3/resync",
		3194	"set0", "set1", "set2", "set3",
		3195	"clr0", "clr1", "clr2", "clr3",
		3196	"irq", "res", "eol", "sol",
		3197	};
		3198	int i;
		3199
		3200	printk("0x%08x [ %s", risc,
		3201	instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
		3202	for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
		3203	if (risc & (1 << (i + 12)))
		3204	printk(" %s",bits[i]);
		3205	printk(" count=%d ]\n", risc & 0xfff);
		3206	return incr[risc >> 28] ? incr[risc >> 28] : 1;
		3207	}
		3208
		3209	void bttv_risc_disasm(struct bttv *btv,
		3210	struct btcx_riscmem *risc)
		3211	{
		3212	unsigned int i,j,n;
		3213
		3214	printk("%s: risc disasm: %p [dma=0x%08lx]\n",
		3215	btv->c.name, risc->cpu, (unsigned long)risc->dma);
		3216	for (i = 0; i < (risc->size >> 2); i += n) {
		3217	printk("%s: 0x%lx: ", btv->c.name,
		3218	(unsigned long)(risc->dma + (i<<2)));
		3219	n = bttv_risc_decode(risc->cpu[i]);
		3220	for (j = 1; j < n; j++)
		3221	printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
		3222	btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
		3223	risc->cpu[i+j], j);
		3224	if (0 == risc->cpu[i])
		3225	break;
		3226	}
		3227	}
		3228
		3229	static void bttv_print_riscaddr(struct bttv *btv)
		3230	{
		3231	printk(" main: %08Lx\n",
		3232	(unsigned long long)btv->main.dma);
		3233	printk(" vbi : o=%08Lx e=%08Lx\n",
3234	btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3235	btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3236	printk(" cap : o=%08Lx e=%08Lx\n",
3237	btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3238	btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3239	printk(" scr : o=%08Lx e=%08Lx\n",
3240	btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3241	btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3242	bttv_risc_disasm(btv, &btv->main);
3243	}
3244
3245	/* ----------------------------------------------------------------------- */
3170	/* irq handler */	3246	/* irq handler */
3171		3247
3172	static char *irq_name[] = {	3248	static char *irq_name[] = {
Lines 3204-3224 static void bttv_print_irqbits(u32 print Link Here
3204	}	3280	}
3205	}	3281	}
3206		3282
3207	static void bttv_print_riscaddr(struct bttv *btv)
3208	{
3209	printk(" main: %08Lx\n",
3210	(unsigned long long)btv->main.dma);
3211	printk(" vbi : o=%08Lx e=%08Lx\n",
3212	btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3213	btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3214	printk(" cap : o=%08Lx e=%08Lx\n",
3215	btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3216	btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3217	printk(" scr : o=%08Lx e=%08Lx\n",
3218	btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3219	btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3220	}
3221
3222	static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)	3283	static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3223	{	3284	{
3224	printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",	3285	printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
Lines 3921-3927 static void __devexit bttv_remove(struct Link Here
3921	return;	3982	return;
3922	}	3983	}
3923		3984
3924	static int bttv_suspend(struct pci_dev *pci_dev, u32 state)	3985	static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
3925	{	3986	{
3926	struct bttv *btv = pci_get_drvdata(pci_dev);	3987	struct bttv *btv = pci_get_drvdata(pci_dev);
3927	struct bttv_buffer_set idle;	3988	struct bttv_buffer_set idle;

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bttv-gpio.c (-15 / +2 lines)
1	/*	1	/*
2	$Id: bttv-gpio.c,v 1.6 2004/11/03 09:04:50 kraxel Exp $	2	$Id: bttv-gpio.c,v 1.7 2005/02/16 12:14:10 kraxel Exp $
3		3
4	bttv-gpio.c -- gpio sub drivers	4	bttv-gpio.c -- gpio sub drivers
5		5
Lines 94-99 int bttv_sub_del_devices(struct bttv_cor Link Here
94		94
95	list_for_each_safe(item,save,&core->subs) {	95	list_for_each_safe(item,save,&core->subs) {
96	sub = list_entry(item,struct bttv_sub_device,list);	96	sub = list_entry(item,struct bttv_sub_device,list);
		97	list_del(&sub->list);
97	device_unregister(&sub->dev);	98	device_unregister(&sub->dev);
98	}	99	}
99	return 0;	100	return 0;
Lines 113-132 void bttv_gpio_irq(struct bttv_core *cor Link Here
113	}	114	}
114	}	115	}
115		116
116	void bttv_i2c_info(struct bttv_core core, struct i2c_client client, int attach)
117	{
118	struct bttv_sub_driver *drv;
119	struct bttv_sub_device *dev;
120	struct list_head *item;
121
122	list_for_each(item,&core->subs) {
123	dev = list_entry(item,struct bttv_sub_device,list);
124	drv = to_bttv_sub_drv(dev->dev.driver);
125	if (drv && drv->i2c_info)
126	drv->i2c_info(dev,client,attach);
127	}
128	}
129
130	/* ----------------------------------------------------------------------- */	117	/* ----------------------------------------------------------------------- */
131	/* external: sub-driver register/unregister */	118	/* external: sub-driver register/unregister */
132		119

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bttv-i2c.c (-14 / +1 lines)
1	/*	1	/*
2	$Id: bttv-i2c.c,v 1.17 2004/12/14 15:33:30 kraxel Exp $	2	$Id: bttv-i2c.c,v 1.18 2005/02/16 12:14:10 kraxel Exp $
3		3
4	bttv-i2c.c -- all the i2c code is here	4	bttv-i2c.c -- all the i2c code is here
5		5
Lines 39-45 static struct i2c_adapter bttv_i2c_adap_ Link Here
39	static struct i2c_client bttv_i2c_client_template;	39	static struct i2c_client bttv_i2c_client_template;
40		40
41	static int attach_inform(struct i2c_client *client);	41	static int attach_inform(struct i2c_client *client);
42	static int detach_inform(struct i2c_client *client);
43		42
44	static int i2c_debug = 0;	43	static int i2c_debug = 0;
45	static int i2c_hw = 0;	44	static int i2c_hw = 0;
Lines 112-118 static struct i2c_adapter bttv_i2c_adap_ Link Here
112	I2C_DEVNAME("bt848"),	111	I2C_DEVNAME("bt848"),
113	.id = I2C_HW_B_BT848,	112	.id = I2C_HW_B_BT848,
114	.client_register = attach_inform,	113	.client_register = attach_inform,
115	.client_unregister = detach_inform,
116	};	114	};
117		115
118	/* ----------------------------------------------------------------------- */	116	/* ----------------------------------------------------------------------- */
Lines 290-296 static struct i2c_adapter bttv_i2c_adap_ Link Here
290	.id = I2C_ALGO_BIT \| I2C_HW_B_BT848 /* FIXME */,	288	.id = I2C_ALGO_BIT \| I2C_HW_B_BT848 /* FIXME */,
291	.algo = &bttv_algo,	289	.algo = &bttv_algo,
292	.client_register = attach_inform,	290	.client_register = attach_inform,
293	.client_unregister = detach_inform,
294	};	291	};
295		292
296	/* ----------------------------------------------------------------------- */	293	/* ----------------------------------------------------------------------- */
Lines 305-326 static int attach_inform(struct i2c_clie Link Here
305	if (btv->pinnacle_id != UNSET)	302	if (btv->pinnacle_id != UNSET)
306	bttv_call_i2c_clients(btv,AUDC_CONFIG_PINNACLE,	303	bttv_call_i2c_clients(btv,AUDC_CONFIG_PINNACLE,
307	&btv->pinnacle_id);	304	&btv->pinnacle_id);
308	bttv_i2c_info(&btv->c, client, 1);
309
310	if (bttv_debug)	305	if (bttv_debug)
311	printk("bttv%d: i2c attach [client=%s]\n",	306	printk("bttv%d: i2c attach [client=%s]\n",
312	btv->c.nr, i2c_clientname(client));	307	btv->c.nr, i2c_clientname(client));
313	return 0;	308	return 0;
314	}	309	}
315		310
316	static int detach_inform(struct i2c_client *client)
317	{
318	struct bttv *btv = i2c_get_adapdata(client->adapter);
319
320	bttv_i2c_info(&btv->c, client, 0);
321	return 0;
322	}
323
324	void bttv_call_i2c_clients(struct bttv btv, unsigned int cmd, void arg)	311	void bttv_call_i2c_clients(struct bttv btv, unsigned int cmd, void arg)
325	{	312	{
326	if (0 != btv->i2c_rc)	313	if (0 != btv->i2c_rc)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/bttv.h (-3 / +2 lines)
1	/*	1	/*
2	* $Id: bttv.h,v 1.14 2005/01/07 13:11:19 kraxel Exp $	2	* $Id: bttv.h,v 1.17 2005/02/22 14:06:32 kraxel Exp $
3	*	3	*
4	* bttv - Bt848 frame grabber driver	4	* bttv - Bt848 frame grabber driver
5	*	5	*
Lines 134-139 Link Here
134	#define BTTV_APAC_VIEWCOMP 0x7f	134	#define BTTV_APAC_VIEWCOMP 0x7f
135	#define BTTV_DVICO_DVBT_LITE 0x80	135	#define BTTV_DVICO_DVBT_LITE 0x80
136	#define BTTV_TIBET_CS16 0x83	136	#define BTTV_TIBET_CS16 0x83
		137	#define BTTV_KODICOM_4400R 0x84
137		138
138	/* i2c address list */	139	/* i2c address list */
139	#define I2C_TSA5522 0xc2	140	#define I2C_TSA5522 0xc2
Lines 302-309 struct bttv_sub_driver { Link Here
302	struct device_driver drv;	303	struct device_driver drv;
303	char wanted[BUS_ID_SIZE];	304	char wanted[BUS_ID_SIZE];
304	void (gpio_irq)(struct bttv_sub_device sub);	305	void (gpio_irq)(struct bttv_sub_device sub);
305	void (i2c_info)(struct bttv_sub_device sub,
306	struct i2c_client *client, int attach);
307	};	306	};
308	#define to_bttv_sub_drv(x) container_of((x), struct bttv_sub_driver, drv)	307	#define to_bttv_sub_drv(x) container_of((x), struct bttv_sub_driver, drv)
309		308

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-blackbird.c (-11 / +18 lines)
1	/*	1	/*
2	* $Id: cx88-blackbird.c,v 1.17 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: cx88-blackbird.c,v 1.26 2005/03/07 15:58:05 kraxel Exp $
3	*	3	*
4	* Support for a cx23416 mpeg encoder via cx2388x host port.	4	* Support for a cx23416 mpeg encoder via cx2388x host port.
5	* "blackbird" reference design.	5	* "blackbird" reference design.
Lines 25-30 Link Here
25	*/	25	*/
26		26
27	#include <linux/module.h>	27	#include <linux/module.h>
		28	#include <linux/moduleparam.h>
28	#include <linux/init.h>	29	#include <linux/init.h>
29	#include <linux/fs.h>	30	#include <linux/fs.h>
30	#include <linux/delay.h>	31	#include <linux/delay.h>
Lines 207-216 static int register_write(struct cx88_co Link Here
207	cx_read(P1_RADDR0);	208	cx_read(P1_RADDR0);
208		209
209	return wait_ready_gpio0_bit1(core,1);	210	return wait_ready_gpio0_bit1(core,1);
210	#if 0
211	udelay(1000); /* without this, things don't go right (subsequent memory_write()'s don't get through */
212	/* ? would this be safe here? set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(1); */
213	#endif
214	}	211	}
215		212
216		213
Lines 283-289 static int blackbird_api_cmd(struct cx88 Link Here
283	timeout = jiffies + msecs_to_jiffies(10);	280	timeout = jiffies + msecs_to_jiffies(10);
284	for (;;) {	281	for (;;) {
285	memory_read(dev->core, dev->mailbox, &flag);	282	memory_read(dev->core, dev->mailbox, &flag);
286	if (0 == (flag & 4))	283	if (0 != (flag & 4))
287	break;	284	break;
288	if (time_after(jiffies,timeout)) {	285	if (time_after(jiffies,timeout)) {
289	dprintk(0, "ERROR: API Mailbox timeout\n");	286	dprintk(0, "ERROR: API Mailbox timeout\n");
Lines 324-330 static int blackbird_find_mailbox(struct Link Here
324	signaturecnt = 0;	321	signaturecnt = 0;
325	if (4 == signaturecnt) {	322	if (4 == signaturecnt) {
326	dprintk(1, "Mailbox signature found\n");	323	dprintk(1, "Mailbox signature found\n");
327	return i;	324	return i+1;
328	}	325	}
329	}	326	}
330	dprintk(0, "Mailbox signature values not found!\n");	327	dprintk(0, "Mailbox signature values not found!\n");
Lines 427-433 static void blackbird_codec_settings(str Link Here
427	blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAMERATE, 1, 0, 0);	424	blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAMERATE, 1, 0, 0);
428		425
429	/* assign frame size */	426	/* assign frame size */
430	blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAME_SIZE, 2, 0, 480, 720);	427	blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAME_SIZE, 2, 0,
		428	dev->height, dev->width);
431		429
432	/* assign aspect ratio */	430	/* assign aspect ratio */
433	blackbird_api_cmd(dev, IVTV_API_ASSIGN_ASPECT_RATIO, 1, 0, 2);	431	blackbird_api_cmd(dev, IVTV_API_ASSIGN_ASPECT_RATIO, 1, 0, 2);
Lines 629-636 static int mpeg_do_ioctl(struct inode *i Link Here
629		627
630	memset(f,0,sizeof(*f));	628	memset(f,0,sizeof(*f));
631	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	629	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
632	f->fmt.pix.width = 720;	630	f->fmt.pix.width = dev->width;
633	f->fmt.pix.height = 576;	631	f->fmt.pix.height = dev->height;
634	f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;	632	f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
635	f->fmt.pix.sizeimage = 1024 * 512 /* FIXME: BUFFER_SIZE */;	633	f->fmt.pix.sizeimage = 1024 * 512 /* FIXME: BUFFER_SIZE */;
636	}	634	}
Lines 694-699 static int mpeg_open(struct inode *inode Link Here
694	file->private_data = fh;	692	file->private_data = fh;
695	fh->dev = dev;	693	fh->dev = dev;
696		694
		695	/* FIXME: locking against other video device */
		696	cx88_set_scale(dev->core, dev->width, dev->height,
		697	V4L2_FIELD_INTERLACED);
		698
697	videobuf_queue_init(&fh->mpegq, &blackbird_qops,	699	videobuf_queue_init(&fh->mpegq, &blackbird_qops,
698	dev->pci, &dev->slock,	700	dev->pci, &dev->slock,
699	V4L2_BUF_TYPE_VIDEO_CAPTURE,	701	V4L2_BUF_TYPE_VIDEO_CAPTURE,
Lines 715-720 static int mpeg_release(struct inode *in Link Here
715	if (fh->mpegq.reading)	717	if (fh->mpegq.reading)
716	videobuf_read_stop(&fh->mpegq);	718	videobuf_read_stop(&fh->mpegq);
717		719
		720	videobuf_mmap_free(&fh->mpegq);
718	file->private_data = NULL;	721	file->private_data = NULL;
719	kfree(fh);	722	kfree(fh);
720	return 0;	723	return 0;
Lines 821-826 static int __devinit blackbird_probe(str Link Here
821	memset(dev,0,sizeof(*dev));	824	memset(dev,0,sizeof(*dev));
822	dev->pci = pci_dev;	825	dev->pci = pci_dev;
823	dev->core = core;	826	dev->core = core;
		827	dev->width = 720;
		828	dev->height = 480;
824		829
825	err = cx8802_init_common(dev);	830	err = cx8802_init_common(dev);
826	if (0 != err)	831	if (0 != err)
Lines 852-857 static void __devexit blackbird_remove(s Link Here
852		857
853	/* common */	858	/* common */
854	cx8802_fini_common(dev);	859	cx8802_fini_common(dev);
		860	cx88_core_put(dev->core,dev->pci);
		861	kfree(dev);
855	}	862	}
856		863
857	static struct pci_device_id cx8802_pci_tbl[] = {	864	static struct pci_device_id cx8802_pci_tbl[] = {
Lines 885-891 static int blackbird_init(void) Link Here
885	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",	892	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
886	SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);	893	SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
887	#endif	894	#endif
888	return pci_module_init(&blackbird_pci_driver);	895	return pci_register_driver(&blackbird_pci_driver);
889	}	896	}
890		897
891	static void blackbird_fini(void)	898	static void blackbird_fini(void)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-cards.c (-167 / +226 lines)
1	/*	1	/*
2	* $Id: cx88-cards.c,v 1.47 2004/11/03 09:04:50 kraxel Exp $	2	* $Id: cx88-cards.c,v 1.66 2005/03/04 09:12:23 kraxel Exp $
3	*	3	*
4	* device driver for Conexant 2388x based TV cards	4	* device driver for Conexant 2388x based TV cards
5	* card-specific stuff.	5	* card-specific stuff.
Lines 26-39 Link Here
26	#include <linux/pci.h>	26	#include <linux/pci.h>
27	#include <linux/delay.h>	27	#include <linux/delay.h>
28		28
29	#if defined(CONFIG_VIDEO_CX88_DVB) \|\| defined(CONFIG_VIDEO_CX88_DVB_MODULE)
30	# define WITH_DVB 1
31	#endif
32
33	#include "cx88.h"	29	#include "cx88.h"
34	#ifdef WITH_DVB
35	#include "cx22702.h"
36	#endif
37		30
38	/* ------------------------------------------------------------------ */	31	/* ------------------------------------------------------------------ */
39	/* board config info */	32	/* board config info */
Lines 59-64 struct cx88_board cx88_boards[] = { Link Here
59	[CX88_BOARD_HAUPPAUGE] = {	52	[CX88_BOARD_HAUPPAUGE] = {
60	.name = "Hauppauge WinTV 34xxx models",	53	.name = "Hauppauge WinTV 34xxx models",
61	.tuner_type = UNSET,	54	.tuner_type = UNSET,
		55	.tda9887_conf = TDA9887_PRESENT,
62	.input = {{	56	.input = {{
63	.type = CX88_VMUX_TELEVISION,	57	.type = CX88_VMUX_TELEVISION,
64	.vmux = 0,	58	.vmux = 0,
Lines 91-97 struct cx88_board cx88_boards[] = { Link Here
91	},	85	},
92	[CX88_BOARD_PIXELVIEW] = {	86	[CX88_BOARD_PIXELVIEW] = {
93	.name = "PixelView",	87	.name = "PixelView",
94	.tuner_type = UNSET,	88	.tuner_type = 5,
95	.input = {{	89	.input = {{
96	.type = CX88_VMUX_TELEVISION,	90	.type = CX88_VMUX_TELEVISION,
97	.vmux = 0,	91	.vmux = 0,
Lines 126-132 struct cx88_board cx88_boards[] = { Link Here
126	.gpio0 = 0x03fe,	120	.gpio0 = 0x03fe,
127	}},	121	}},
128	},	122	},
129	[CX88_BOARD_WINFAST2000XP] = {	123	[CX88_BOARD_WINFAST2000XP_EXPERT] = {
130	.name = "Leadtek Winfast 2000XP Expert",	124	.name = "Leadtek Winfast 2000XP Expert",
131	.tuner_type = 44,	125	.tuner_type = 44,
132	.tda9887_conf = TDA9887_PRESENT,	126	.tda9887_conf = TDA9887_PRESENT,
Lines 217-242 struct cx88_board cx88_boards[] = { Link Here
217	.input = {{	211	.input = {{
218	.type = CX88_VMUX_TELEVISION,	212	.type = CX88_VMUX_TELEVISION,
219	.vmux = 0,	213	.vmux = 0,
220	}},	214	.gpio0 = 0x0035e700,
		215	.gpio1 = 0x00003004,
		216	.gpio2 = 0x0035e700,
		217	.gpio3 = 0x02000000,
		218	},{
		219
		220	.type = CX88_VMUX_COMPOSITE1,
		221	.vmux = 1,
		222	.gpio0 = 0x0035c700,
		223	.gpio1 = 0x00003004,
		224	.gpio2 = 0x0035c700,
		225	.gpio3 = 0x02000000,
		226	},{
		227	.type = CX88_VMUX_SVIDEO,
		228	.vmux = 2,
		229	.gpio0 = 0x0035c700,
		230	.gpio1 = 0x0035c700,
		231	.gpio2 = 0x02000000,
		232	.gpio3 = 0x02000000,
		233	}},
221	.radio = {	234	.radio = {
222	.type = CX88_RADIO,	235	.type = CX88_RADIO,
223	},	236	.gpio0 = 0x0035d700,
		237	.gpio1 = 0x00007004,
		238	.gpio2 = 0x0035d700,
		239	.gpio3 = 0x02000000,
		240	},
224	},	241	},
225	[CX88_BOARD_LEADTEK_PVR2000] = {	242	[CX88_BOARD_LEADTEK_PVR2000] = {
		243	// gpio values for PAL version from regspy by DScaler
226	.name = "Leadtek PVR 2000",	244	.name = "Leadtek PVR 2000",
227	.tuner_type = 38,	245	.tuner_type = 38,
		246	.tda9887_conf = TDA9887_PRESENT,
228	.input = {{	247	.input = {{
229	.type = CX88_VMUX_TELEVISION,	248	.type = CX88_VMUX_TELEVISION,
230	.vmux = 0,	249	.vmux = 0,
		250	.gpio0 = 0x0000bde6,
231	},{	251	},{
232	.type = CX88_VMUX_COMPOSITE1,	252	.type = CX88_VMUX_COMPOSITE1,
233	.vmux = 1,	253	.vmux = 1,
		254	.gpio0 = 0x0000bde6,
234	},{	255	},{
235	.type = CX88_VMUX_SVIDEO,	256	.type = CX88_VMUX_SVIDEO,
236	.vmux = 2,	257	.vmux = 2,
		258	.gpio0 = 0x0000bde6,
237	}},	259	}},
238	.radio = {	260	.radio = {
239	.type = CX88_RADIO,	261	.type = CX88_RADIO,
		262	.gpio0 = 0x0000bd62,
240	},	263	},
241	.blackbird = 1,	264	.blackbird = 1,
242	},	265	},
Lines 320-333 struct cx88_board cx88_boards[] = { Link Here
320	.name = "KWorld/VStream XPert DVB-T",	343	.name = "KWorld/VStream XPert DVB-T",
321	.tuner_type = TUNER_ABSENT,	344	.tuner_type = TUNER_ABSENT,
322	.input = {{	345	.input = {{
323	.type = CX88_VMUX_DVB,
324	.vmux = 0,
325	},{
326	.type = CX88_VMUX_COMPOSITE1,	346	.type = CX88_VMUX_COMPOSITE1,
327	.vmux = 1,	347	.vmux = 1,
		348	.gpio0 = 0x0700,
		349	.gpio2 = 0x0101,
328	},{	350	},{
329	.type = CX88_VMUX_SVIDEO,	351	.type = CX88_VMUX_SVIDEO,
330	.vmux = 2,	352	.vmux = 2,
		353	.gpio0 = 0x0700,
		354	.gpio2 = 0x0101,
331	}},	355	}},
332	.dvb = 1,	356	.dvb = 1,
333	},	357	},
Lines 452-457 struct cx88_board cx88_boards[] = { Link Here
452	}},	476	}},
453	.dvb = 1,	477	.dvb = 1,
454	},	478	},
		479	[CX88_BOARD_DNTV_LIVE_DVB_T] = {
		480	.name = "digitalnow DNTV Live! DVB-T",
		481	.tuner_type = TUNER_ABSENT,
		482	.input = {{
		483	.type = CX88_VMUX_COMPOSITE1,
		484	.vmux = 1,
		485	.gpio0 = 0x00000700,
		486	.gpio2 = 0x00000101,
		487	},{
		488	.type = CX88_VMUX_SVIDEO,
		489	.vmux = 2,
		490	.gpio0 = 0x00000700,
		491	.gpio2 = 0x00000101,
		492	}},
		493	.dvb = 1,
		494	},
		495	[CX88_BOARD_PCHDTV_HD3000] = {
		496	.name = "pcHDTV HD3000 HDTV",
		497	.tuner_type = TUNER_THOMSON_DTT7610,
		498	.input = {{
		499	.type = CX88_VMUX_TELEVISION,
		500	.vmux = 0,
		501	.gpio0 = 0x00008484,
		502	.gpio1 = 0x00000000,
		503	.gpio2 = 0x00000000,
		504	.gpio3 = 0x00000000,
		505	},{
		506	.type = CX88_VMUX_COMPOSITE1,
		507	.vmux = 1,
		508	.gpio0 = 0x00008400,
		509	.gpio1 = 0x00000000,
		510	.gpio2 = 0x00000000,
		511	.gpio3 = 0x00000000,
		512	},{
		513	.type = CX88_VMUX_SVIDEO,
		514	.vmux = 2,
		515	.gpio0 = 0x00008400,
		516	.gpio1 = 0x00000000,
		517	.gpio2 = 0x00000000,
		518	.gpio3 = 0x00000000,
		519	}},
		520	.radio = {
		521	.type = CX88_RADIO,
		522	.vmux = 2,
		523	.gpio0 = 0x00008400,
		524	.gpio1 = 0x00000000,
		525	.gpio2 = 0x00000000,
		526	.gpio3 = 0x00000000,
		527	},
		528	.dvb = 1,
		529	},
		530	[CX88_BOARD_HAUPPAUGE_ROSLYN] = {
		531	// entry added by Kaustubh D. Bhalerao <bhalerao.1@osu.edu>
		532	// GPIO values obtained from regspy, courtesy Sean Covel
		533	.name = "Hauppauge WinTV 28xxx (Roslyn) models",
		534	.tuner_type = UNSET,
		535	.input = {{
		536	.type = CX88_VMUX_TELEVISION,
		537	.vmux = 0,
		538	.gpio0 = 0xed12, // internal decoder
		539	.gpio2 = 0x00ff,
		540	},{
		541	.type = CX88_VMUX_DEBUG,
		542	.vmux = 0,
543	.gpio0 = 0xff01, // mono from tuner chip
544	},{
545	.type = CX88_VMUX_COMPOSITE1,
546	.vmux = 1,
547	.gpio0 = 0xff02,
548	},{
549	.type = CX88_VMUX_SVIDEO,
550	.vmux = 2,
551	.gpio0 = 0xed92,
552	.gpio2 = 0x00ff,
553	}},
554	.radio = {
555	.type = CX88_RADIO,
556	.gpio0 = 0xed96,
557	.gpio2 = 0x00ff,
558	},
559	.blackbird = 1,
560	},
561	[CX88_BOARD_DIGITALLOGIC_MEC] = {
562	/* params copied over from Leadtek PVR 2000 */
563	.name = "Digital-Logic MICROSPACE Entertainment Center (MEC)",
564	/* not sure yet about the tuner type */
565	.tuner_type = 38,
566	.tda9887_conf = TDA9887_PRESENT,
567	.input = {{
568	.type = CX88_VMUX_TELEVISION,
569	.vmux = 0,
570	.gpio0 = 0x0000bde6,
571	},{
572	.type = CX88_VMUX_COMPOSITE1,
573	.vmux = 1,
574	.gpio0 = 0x0000bde6,
575	},{
576	.type = CX88_VMUX_SVIDEO,
577	.vmux = 2,
578	.gpio0 = 0x0000bde6,
579	}},
580	.radio = {
581	.type = CX88_RADIO,
582	.gpio0 = 0x0000bd62,
583	},
584	.blackbird = 1,
585	},
586	[CX88_BOARD_IODATA_GVBCTV7E] = {
587	.name = "IODATA GV/BCTV7E",
588	.tuner_type = TUNER_PHILIPS_FQ1286,
589	.tda9887_conf = TDA9887_PRESENT,
590	.input = {{
591	.type = CX88_VMUX_TELEVISION,
592	.vmux = 1,
593	.gpio1 = 0x0000e03f,
594	},{
595	.type = CX88_VMUX_COMPOSITE1,
596	.vmux = 2,
597	.gpio1 = 0x0000e07f,
598	},{
599	.type = CX88_VMUX_SVIDEO,
600	.vmux = 3,
601	.gpio1 = 0x0000e07f,
602	}}
603	},
455	};	604	};
456	const unsigned int cx88_bcount = ARRAY_SIZE(cx88_boards);	605	const unsigned int cx88_bcount = ARRAY_SIZE(cx88_boards);
457		606
Lines 482-492 struct cx88_subid cx88_subids[] = { Link Here
482	},{	631	},{
483	.subvendor = 0x107d,	632	.subvendor = 0x107d,
484	.subdevice = 0x6611,	633	.subdevice = 0x6611,
485	.card = CX88_BOARD_WINFAST2000XP,	634	.card = CX88_BOARD_WINFAST2000XP_EXPERT,
486	},{	635	},{
487	.subvendor = 0x107d,	636	.subvendor = 0x107d,
488	.subdevice = 0x6613, /* NTSC */	637	.subdevice = 0x6613, /* NTSC */
489	.card = CX88_BOARD_WINFAST2000XP,	638	.card = CX88_BOARD_WINFAST2000XP_EXPERT,
490	},{	639	},{
491	.subvendor = 0x107d,	640	.subvendor = 0x107d,
492	.subdevice = 0x6620,	641	.subdevice = 0x6620,
Lines 543-548 struct cx88_subid cx88_subids[] = { Link Here
543	.subvendor = 0x18AC,	692	.subvendor = 0x18AC,
544	.subdevice = 0xDB10,	693	.subdevice = 0xDB10,
545	.card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS,	694	.card = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS,
		695	},{
		696	.subvendor = 0x1554,
		697	.subdevice = 0x4811,
		698	.card = CX88_BOARD_PIXELVIEW,
		699	},{
		700	.subvendor = 0x7063,
		701	.subdevice = 0x3000, /* HD-3000 card */
		702	.card = CX88_BOARD_PCHDTV_HD3000,
		703	},{
		704	.subvendor = 0x17DE,
		705	.subdevice = 0xA8A6,
		706	.card = CX88_BOARD_DNTV_LIVE_DVB_T,
		707	},{
		708	.subvendor = 0x0070,
		709	.subdevice = 0x2801,
		710	.card = CX88_BOARD_HAUPPAUGE_ROSLYN,
		711	},{
		712	.subvendor = 0x14F1,
		713	.subdevice = 0x0342,
		714	.card = CX88_BOARD_DIGITALLOGIC_MEC,
		715	},{
		716	.subvendor = 0x10fc,
		717	.subdevice = 0xd035,
		718	.card = CX88_BOARD_IODATA_GVBCTV7E,
546	}	719	}
547	};	720	};
548	const unsigned int cx88_idcount = ARRAY_SIZE(cx88_subids);	721	const unsigned int cx88_idcount = ARRAY_SIZE(cx88_subids);
Lines 552-558 const unsigned int cx88_idcount = ARRAY_ Link Here
552		725
553	static void __devinit leadtek_eeprom(struct cx88_core core, u8 eeprom_data)	726	static void __devinit leadtek_eeprom(struct cx88_core core, u8 eeprom_data)
554	{	727	{
555	/* This is just for the Winfast 2000 XP board ATM; I don't have data on	728	/* This is just for the "Winfast 2000XP Expert" board ATM; I don't have data on
556	* any others.	729	* any others.
557	*	730	*
558	* Byte 0 is 1 on the NTSC board.	731	* Byte 0 is 1 on the NTSC board.
Lines 569-676 static void __devinit leadtek_eeprom(str Link Here
569	core->has_radio = 1;	742	core->has_radio = 1;
570	core->tuner_type = (eeprom_data[6] == 0x13) ? 43 : 38;	743	core->tuner_type = (eeprom_data[6] == 0x13) ? 43 : 38;
571		744
572	printk(KERN_INFO "%s: Leadtek Winfast 2000 XP config: "	745	printk(KERN_INFO "%s: Leadtek Winfast 2000XP Expert config: "
573	"tuner=%d, eeprom[0]=0x%02x\n",	746	"tuner=%d, eeprom[0]=0x%02x\n",
574	core->name, core->tuner_type, eeprom_data[0]);	747	core->name, core->tuner_type, eeprom_data[0]);
575	}	748	}
576		749
577		750
578	/* ----------------------------------------------------------------------- */	751	/* ----------------------------------------------------------------------- */
579	/* some hauppauge specific stuff */
580
581	static struct {
582	int id;
583	char *name;
584	} hauppauge_tuner[] __devinitdata = {
585	{ TUNER_ABSENT, "" },
586	{ TUNER_ABSENT, "External" },
587	{ TUNER_ABSENT, "Unspecified" },
588	{ TUNER_PHILIPS_PAL, "Philips FI1216" },
589	{ TUNER_PHILIPS_SECAM, "Philips FI1216MF" },
590	{ TUNER_PHILIPS_NTSC, "Philips FI1236" },
591	{ TUNER_PHILIPS_PAL_I, "Philips FI1246" },
592	{ TUNER_PHILIPS_PAL_DK,"Philips FI1256" },
593	{ TUNER_PHILIPS_PAL, "Philips FI1216 MK2" },
594	{ TUNER_PHILIPS_SECAM, "Philips FI1216MF MK2" },
595	{ TUNER_PHILIPS_NTSC, "Philips FI1236 MK2" },
596	{ TUNER_PHILIPS_PAL_I, "Philips FI1246 MK2" },
597	{ TUNER_PHILIPS_PAL_DK,"Philips FI1256 MK2" },
598	{ TUNER_TEMIC_NTSC, "Temic 4032FY5" },
599	{ TUNER_TEMIC_PAL, "Temic 4002FH5" },
600	{ TUNER_TEMIC_PAL_I, "Temic 4062FY5" },
601	{ TUNER_PHILIPS_PAL, "Philips FR1216 MK2" },
602	{ TUNER_PHILIPS_SECAM, "Philips FR1216MF MK2" },
603	{ TUNER_PHILIPS_NTSC, "Philips FR1236 MK2" },
604	{ TUNER_PHILIPS_PAL_I, "Philips FR1246 MK2" },
605	{ TUNER_PHILIPS_PAL_DK,"Philips FR1256 MK2" },
606	{ TUNER_PHILIPS_PAL, "Philips FM1216" },
607	{ TUNER_PHILIPS_SECAM, "Philips FM1216MF" },
608	{ TUNER_PHILIPS_NTSC, "Philips FM1236" },
609	{ TUNER_PHILIPS_PAL_I, "Philips FM1246" },
610	{ TUNER_PHILIPS_PAL_DK,"Philips FM1256" },
611	{ TUNER_TEMIC_4036FY5_NTSC, "Temic 4036FY5" },
612	{ TUNER_ABSENT, "Samsung TCPN9082D" },
613	{ TUNER_ABSENT, "Samsung TCPM9092P" },
614	{ TUNER_TEMIC_4006FH5_PAL, "Temic 4006FH5" },
615	{ TUNER_ABSENT, "Samsung TCPN9085D" },
616	{ TUNER_ABSENT, "Samsung TCPB9085P" },
617	{ TUNER_ABSENT, "Samsung TCPL9091P" },
618	{ TUNER_TEMIC_4039FR5_NTSC, "Temic 4039FR5" },
619	{ TUNER_PHILIPS_FQ1216ME, "Philips FQ1216 ME" },
620	{ TUNER_TEMIC_4066FY5_PAL_I, "Temic 4066FY5" },
621	{ TUNER_PHILIPS_NTSC, "Philips TD1536" },
622	{ TUNER_PHILIPS_NTSC, "Philips TD1536D" },
623	{ TUNER_PHILIPS_NTSC, "Philips FMR1236" }, /* mono radio */
624	{ TUNER_ABSENT, "Philips FI1256MP" },
625	{ TUNER_ABSENT, "Samsung TCPQ9091P" },
626	{ TUNER_TEMIC_4006FN5_MULTI_PAL, "Temic 4006FN5" },
627	{ TUNER_TEMIC_4009FR5_PAL, "Temic 4009FR5" },
628	{ TUNER_TEMIC_4046FM5, "Temic 4046FM5" },
629	{ TUNER_TEMIC_4009FN5_MULTI_PAL_FM, "Temic 4009FN5" },
630	{ TUNER_ABSENT, "Philips TD1536D_FH_44"},
631	{ TUNER_LG_NTSC_FM, "LG TPI8NSR01F"},
632	{ TUNER_LG_PAL_FM, "LG TPI8PSB01D"},
633	{ TUNER_LG_PAL, "LG TPI8PSB11D"},
634	{ TUNER_LG_PAL_I_FM, "LG TAPC-I001D"},
635	{ TUNER_LG_PAL_I, "LG TAPC-I701D"}
636	};
637		752
638	static void hauppauge_eeprom(struct cx88_core core, u8 eeprom_data)	753	static void hauppauge_eeprom(struct cx88_core core, u8 eeprom_data)
639	{	754	{
640	unsigned int blk2,tuner,radio,model;	755	struct tveeprom tv;
641
642	if (eeprom_data[0] != 0x84 \|\| eeprom_data[2] != 0) {
643	printk(KERN_WARNING "%s: Hauppauge eeprom: invalid\n",
644	core->name);
645	return;
646	}
647
648	/* Block 2 starts after len+3 bytes header */
649	blk2 = eeprom_data[1] + 3;
650
651	/* decode + use some config infos */
652	model = eeprom_data[12] << 8 \| eeprom_data[11];
653	tuner = eeprom_data[9];
654	radio = eeprom_data[blk2-1] & 0x01;
655
656	if (tuner < ARRAY_SIZE(hauppauge_tuner))
657	core->tuner_type = hauppauge_tuner[tuner].id;
658	if (radio)
659	core->has_radio = 1;
660		756
661	printk(KERN_INFO "%s: hauppauge eeprom: model=%d, "	757	tveeprom_hauppauge_analog(&tv, eeprom_data);
662	"tuner=%s (%d), radio=%s\n",	758	core->tuner_type = tv.tuner_type;
663	core->name, model, (tuner < ARRAY_SIZE(hauppauge_tuner)	759	core->has_radio = tv.has_radio;
664	? hauppauge_tuner[tuner].name : "?"),
665	core->tuner_type, radio ? "yes" : "no");
666	}	760	}
667		761
668	#ifdef WITH_DVB
669	static int hauppauge_eeprom_dvb(struct cx88_core core, u8 ee)	762	static int hauppauge_eeprom_dvb(struct cx88_core core, u8 ee)
670	{	763	{
671	int model;	764	int model;
672	int tuner;	765	int tuner;
673	char *tname;
674		766
675	/* Make sure we support the board model */	767	/* Make sure we support the board model */
676	model = ee[0x1f] << 24 \| ee[0x1e] << 16 \| ee[0x1d] << 8 \| ee[0x1c];	768	model = ee[0x1f] << 24 \| ee[0x1e] << 16 \| ee[0x1d] << 8 \| ee[0x1c];
Lines 689-714 static int hauppauge_eeprom_dvb(struct c Link Here
689	/* Make sure we support the tuner */	781	/* Make sure we support the tuner */
690	tuner = ee[0x2d];	782	tuner = ee[0x2d];
691	switch(tuner) {	783	switch(tuner) {
692	case 0x4B:	784	case 0x4B: /* dtt 7595 */
693	tname = "Thomson DTT 7595";	785	case 0x4C: /* dtt 7592 */
694	core->pll_type = PLLTYPE_DTT7595;
695	break;
696	case 0x4C:
697	tname = "Thomson DTT 7592";
698	core->pll_type = PLLTYPE_DTT7592;
699	break;	786	break;
700	default:	787	default:
701	printk("%s: error: unknown hauppauge tuner 0x%02x\n",	788	printk("%s: error: unknown hauppauge tuner 0x%02x\n",
702	core->name, tuner);	789	core->name, tuner);
703	return -ENODEV;	790	return -ENODEV;
704	}	791	}
705	printk(KERN_INFO "%s: hauppauge eeprom: model=%d, tuner=%s (%d)\n",	792	printk(KERN_INFO "%s: hauppauge eeprom: model=%d, tuner=%d\n",
706	core->name, model, tname, tuner);	793	core->name, model, tuner);
707		794	return 0;
708	core->pll_addr = 0x61;
709	core->demod_addr = 0x43;
710	}	795	}
711	#endif
712		796
713	/* ----------------------------------------------------------------------- */	797	/* ----------------------------------------------------------------------- */
714	/* some GDI (was: Modular Technology) specific stuff */	798	/* some GDI (was: Modular Technology) specific stuff */
Lines 763-798 static void gdi_eeprom(struct cx88_core Link Here
763		847
764	/* ----------------------------------------------------------------------- */	848	/* ----------------------------------------------------------------------- */
765		849
766	static int
767	i2c_eeprom(struct i2c_client c, unsigned char eedata, int len)
768	{
769	unsigned char buf;
770	int err;
771
772	c->addr = 0xa0 >> 1;
773	buf = 0;
774	if (1 != (err = i2c_master_send(c,&buf,1))) {
775	printk(KERN_INFO "cx88: Huh, no eeprom present (err=%d)?\n",
776	err);
777	return -1;
778	}
779	if (len != (err = i2c_master_recv(c,eedata,len))) {
780	printk(KERN_WARNING "cx88: i2c eeprom read error (err=%d)\n",
781	err);
782	return -1;
783	}
784	#if 0
785	for (i = 0; i < len; i++) {
786	if (0 == (i % 16))
787	printk(KERN_INFO "cx88 ee: %02x:",i);
788	printk(" %02x",eedata[i]);
789	if (15 == (i % 16))
790	printk("\n");
791	}
792	#endif
793	return 0;
794	}
795
796	void cx88_card_list(struct cx88_core core, struct pci_dev pci)	850	void cx88_card_list(struct cx88_core core, struct pci_dev pci)
797	{	851	{
798	int i;	852	int i;
Lines 823-863 void cx88_card_setup(struct cx88_core *c Link Here
823	{	877	{
824	static u8 eeprom[128];	878	static u8 eeprom[128];
825		879
		880	if (0 == core->i2c_rc) {
		881	core->i2c_client.addr = 0xa0 >> 1;
		882	tveeprom_read(&core->i2c_client,eeprom,sizeof(eeprom));
		883	}
		884
826	switch (core->board) {	885	switch (core->board) {
827	case CX88_BOARD_HAUPPAUGE:	886	case CX88_BOARD_HAUPPAUGE:
		887	case CX88_BOARD_HAUPPAUGE_ROSLYN:
828	if (0 == core->i2c_rc)	888	if (0 == core->i2c_rc)
829	i2c_eeprom(&core->i2c_client,eeprom,sizeof(eeprom));	889	hauppauge_eeprom(core,eeprom+8);
830	hauppauge_eeprom(core,eeprom+8);
831	break;	890	break;
832	case CX88_BOARD_GDI:	891	case CX88_BOARD_GDI:
833	if (0 == core->i2c_rc)	892	if (0 == core->i2c_rc)
834	i2c_eeprom(&core->i2c_client,eeprom,sizeof(eeprom));	893	gdi_eeprom(core,eeprom);
835	gdi_eeprom(core,eeprom);
836	break;	894	break;
837	case CX88_BOARD_WINFAST2000XP:	895	case CX88_BOARD_WINFAST2000XP_EXPERT:
838	if (0 == core->i2c_rc)	896	if (0 == core->i2c_rc)
839	i2c_eeprom(&core->i2c_client,eeprom,sizeof(eeprom));	897	leadtek_eeprom(core,eeprom);
840	leadtek_eeprom(core,eeprom);	898	break;
		899	case CX88_BOARD_HAUPPAUGE_DVB_T1:
		900	if (0 == core->i2c_rc)
		901	hauppauge_eeprom_dvb(core,eeprom);
841	break;	902	break;
842	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:	903	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:
843	/* Tuner reset is hooked to the tuner out of reset */	904	case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:
		905	/* GPIO0:0 is hooked to mt352 reset pin */
844	cx_set(MO_GP0_IO, 0x00000101);	906	cx_set(MO_GP0_IO, 0x00000101);
845	cx_clear(MO_GP0_IO, 0x00000001);	907	cx_clear(MO_GP0_IO, 0x00000001);
846	msleep(1);	908	msleep(1);
847	cx_set(MO_GP0_IO, 0x00000101);	909	cx_set(MO_GP0_IO, 0x00000101);
848	break;	910	break;
849	#ifdef WITH_DVB	911	case CX88_BOARD_KWORLD_DVB_T:
850	case CX88_BOARD_HAUPPAUGE_DVB_T1:	912	case CX88_BOARD_DNTV_LIVE_DVB_T:
851	if (0 == core->i2c_rc)	913	cx_set(MO_GP0_IO, 0x00000707);
852	i2c_eeprom(&core->i2c_client,eeprom,sizeof(eeprom));	914	cx_set(MO_GP2_IO, 0x00000101);
853	hauppauge_eeprom_dvb(core,eeprom);	915	cx_clear(MO_GP2_IO, 0x00000001);
854	break;	916	msleep(1);
855	case CX88_BOARD_CONEXANT_DVB_T1:	917	cx_clear(MO_GP0_IO, 0x00000007);
856	core->pll_type = PLLTYPE_DTT7579;	918	cx_set(MO_GP2_IO, 0x00000101);
857	core->pll_addr = 0x60;
858	core->demod_addr = 0x43;
859	break;	919	break;
860	#endif
861	}	920	}
862	if (cx88_boards[core->board].radio.type == CX88_RADIO)	921	if (cx88_boards[core->board].radio.type == CX88_RADIO)
863	core->has_radio = 1;	922	core->has_radio = 1;

Added Link Here

(-)linux-2.6.11/drivers/media/video/cx88/cx88-input.c (+396 lines)
1	/*
2	* $Id: cx88-input.c,v 1.9 2005/03/04 09:12:23 kraxel Exp $
3	*
4	* Device driver for GPIO attached remote control interfaces
5	* on Conexant 2388x based TV/DVB cards.
6	*
7	* Copyright (c) 2003 Pavel Machek
8	* Copyright (c) 2004 Gerd Knorr
9	* Copyright (c) 2004 Chris Pascoe
10	*
11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.
15	*
16	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24	*/
25
26	#include <linux/init.h>
27	#include <linux/delay.h>
28	#include <linux/input.h>
29	#include <linux/pci.h>
30	#include <linux/module.h>
31	#include <linux/moduleparam.h>
32
33	#include <media/ir-common.h>
34
35	#include "cx88.h"
36
37	/* ---------------------------------------------------------------------- */
38
39	/* DigitalNow DNTV Live DVB-T Remote */
40	static IR_KEYTAB_TYPE ir_codes_dntv_live_dvb_t[IR_KEYTAB_SIZE] = {
41	[ 0x00 ] = KEY_ESC, // 'go up a level?'
42	[ 0x01 ] = KEY_KP1, // '1'
43	[ 0x02 ] = KEY_KP2, // '2'
44	[ 0x03 ] = KEY_KP3, // '3'
45	[ 0x04 ] = KEY_KP4, // '4'
46	[ 0x05 ] = KEY_KP5, // '5'
47	[ 0x06 ] = KEY_KP6, // '6'
48	[ 0x07 ] = KEY_KP7, // '7'
49	[ 0x08 ] = KEY_KP8, // '8'
50	[ 0x09 ] = KEY_KP9, // '9'
51	[ 0x0a ] = KEY_KP0, // '0'
52	[ 0x0b ] = KEY_TUNER, // 'tv/fm'
53	[ 0x0c ] = KEY_SEARCH, // 'scan'
54	[ 0x0d ] = KEY_STOP, // 'stop'
55	[ 0x0e ] = KEY_PAUSE, // 'pause'
56	[ 0x0f ] = KEY_LIST, // 'source'
57
58	[ 0x10 ] = KEY_MUTE, // 'mute'
59	[ 0x11 ] = KEY_REWIND, // 'backward <<'
60	[ 0x12 ] = KEY_POWER, // 'power'
61	[ 0x13 ] = KEY_S, // 'snap'
62	[ 0x14 ] = KEY_AUDIO, // 'stereo'
63	[ 0x15 ] = KEY_CLEAR, // 'reset'
64	[ 0x16 ] = KEY_PLAY, // 'play'
65	[ 0x17 ] = KEY_ENTER, // 'enter'
66	[ 0x18 ] = KEY_ZOOM, // 'full screen'
67	[ 0x19 ] = KEY_FASTFORWARD, // 'forward >>'
68	[ 0x1a ] = KEY_CHANNELUP, // 'channel +'
69	[ 0x1b ] = KEY_VOLUMEUP, // 'volume +'
70	[ 0x1c ] = KEY_INFO, // 'preview'
71	[ 0x1d ] = KEY_RECORD, // 'record'
72	[ 0x1e ] = KEY_CHANNELDOWN, // 'channel -'
73	[ 0x1f ] = KEY_VOLUMEDOWN, // 'volume -'
74	};
75
76	/* ---------------------------------------------------------------------- */
77
78	/* IO-DATA BCTV7E Remote */
79	static IR_KEYTAB_TYPE ir_codes_iodata_bctv7e[IR_KEYTAB_SIZE] = {
80	[ 0x40 ] = KEY_TV, // TV
81	[ 0x20 ] = KEY_RADIO, // FM
82	[ 0x60 ] = KEY_EPG, // EPG
83	[ 0x00 ] = KEY_POWER, // power
84
85	[ 0x50 ] = KEY_KP1, // 1
86	[ 0x30 ] = KEY_KP2, // 2
87	[ 0x70 ] = KEY_KP3, // 3
88	[ 0x10 ] = KEY_L, // Live
89
90	[ 0x48 ] = KEY_KP4, // 4
91	[ 0x28 ] = KEY_KP5, // 5
92	[ 0x68 ] = KEY_KP6, // 6
93	[ 0x08 ] = KEY_T, // Time Shift
94
95	[ 0x58 ] = KEY_KP7, // 7
96	[ 0x38 ] = KEY_KP8, // 8
97	[ 0x78 ] = KEY_KP9, // 9
98	[ 0x18 ] = KEY_PLAYPAUSE, // Play
99
100	[ 0x44 ] = KEY_KP0, // 10
101	[ 0x24 ] = KEY_ENTER, // 11
102	[ 0x64 ] = KEY_ESC, // 12
103	[ 0x04 ] = KEY_M, // Multi
104
105	[ 0x54 ] = KEY_VIDEO, // VIDEO
106	[ 0x34 ] = KEY_CHANNELUP, // channel +
107	[ 0x74 ] = KEY_VOLUMEUP, // volume +
108	[ 0x14 ] = KEY_MUTE, // Mute
109
110	[ 0x4c ] = KEY_S, // SVIDEO
111	[ 0x2c ] = KEY_CHANNELDOWN, // channel -
112	[ 0x6c ] = KEY_VOLUMEDOWN, // volume -
113	[ 0x0c ] = KEY_ZOOM, // Zoom
114
115	[ 0x5c ] = KEY_PAUSE, // pause
116	[ 0x3c ] = KEY_C, // \|\| (red)
117	[ 0x7c ] = KEY_RECORD, // recording
118	[ 0x1c ] = KEY_STOP, // stop
119
120	[ 0x41 ] = KEY_REWIND, // backward <<
121	[ 0x21 ] = KEY_PLAY, // play
122	[ 0x61 ] = KEY_FASTFORWARD, // forward >>
123	[ 0x01 ] = KEY_NEXT, // skip >\|
124	};
125
126	/* ---------------------------------------------------------------------- */
127
128	struct cx88_IR {
129	struct cx88_core *core;
130	struct input_dev input;
131	struct ir_input_state ir;
132	char name[32];
133	char phys[32];
134
135	/* sample from gpio pin 16 */
136	int sampling;
137	u32 samples[16];
138	int scount;
139	unsigned long release;
140
141	/* poll external decoder */
142	int polling;
143	struct work_struct work;
144	struct timer_list timer;
145	u32 gpio_addr;
146	u32 last_gpio;
147	u32 mask_keycode;
148	u32 mask_keydown;
149	u32 mask_keyup;
150	};
151
152	static int ir_debug = 0;
153	module_param(ir_debug, int, 0644); /* debug level [IR] */
154	MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
155
156	#define ir_dprintk(fmt, arg...) if (ir_debug) \
157	printk(KERN_DEBUG "%s IR: " fmt , ir->core->name, ## arg)
158
159	/* ---------------------------------------------------------------------- */
160
161	static void cx88_ir_handle_key(struct cx88_IR *ir)
162	{
163	struct cx88_core *core = ir->core;
164	u32 gpio, data;
165
166	/* read gpio value */
167	gpio = cx_read(ir->gpio_addr);
168	if (ir->polling) {
169	if (ir->last_gpio == gpio)
170	return;
171	ir->last_gpio = gpio;
172	}
173
174	/* extract data */
175	data = ir_extract_bits(gpio, ir->mask_keycode);
176	ir_dprintk("irq gpio=0x%x code=%d \| %s%s%s\n",
177	gpio, data,
178	ir->polling ? "poll" : "irq",
179	(gpio & ir->mask_keydown) ? " down" : "",
180	(gpio & ir->mask_keyup) ? " up" : "");
181
182	if (ir->mask_keydown) {
183	/* bit set on keydown */
184	if (gpio & ir->mask_keydown) {
185	ir_input_keydown(&ir->input,&ir->ir,data,data);
186	} else {
187	ir_input_nokey(&ir->input,&ir->ir);
188	}
189
190	} else if (ir->mask_keyup) {
191	/* bit cleared on keydown */
192	if (0 == (gpio & ir->mask_keyup)) {
193	ir_input_keydown(&ir->input,&ir->ir,data,data);
194	} else {
195	ir_input_nokey(&ir->input,&ir->ir);
196	}
197
198	} else {
199	/* can't distinguish keydown/up :-/ */
200	ir_input_keydown(&ir->input,&ir->ir,data,data);
201	ir_input_nokey(&ir->input,&ir->ir);
202	}
203	}
204
205	static void ir_timer(unsigned long data)
206	{
207	struct cx88_IR ir = (struct cx88_IR)data;
208
209	schedule_work(&ir->work);
210	}
211
212	static void cx88_ir_work(void *data)
213	{
214	struct cx88_IR *ir = data;
215	unsigned long timeout;
216
217	cx88_ir_handle_key(ir);
218	timeout = jiffies + (ir->polling * HZ / 1000);
219	mod_timer(&ir->timer, timeout);
220	}
221
222	/* ---------------------------------------------------------------------- */
223
224	int cx88_ir_init(struct cx88_core core, struct pci_dev pci)
225	{
226	struct cx88_IR *ir;
227	IR_KEYTAB_TYPE *ir_codes = NULL;
228	int ir_type = IR_TYPE_OTHER;
229
230	ir = kmalloc(sizeof(*ir),GFP_KERNEL);
231	if (NULL == ir)
232	return -ENOMEM;
233	memset(ir,0,sizeof(*ir));
234
235	/* detect & configure */
236	switch (core->board) {
237	case CX88_BOARD_DNTV_LIVE_DVB_T:
238	ir_codes = ir_codes_dntv_live_dvb_t;
239	ir->gpio_addr = MO_GP1_IO;
240	ir->mask_keycode = 0x1f;
241	ir->mask_keyup = 0x60;
242	ir->polling = 50; // ms
243	break;
244	case CX88_BOARD_HAUPPAUGE:
245	case CX88_BOARD_HAUPPAUGE_DVB_T1:
246	ir_codes = ir_codes_hauppauge_new;
247	ir_type = IR_TYPE_RC5;
248	ir->sampling = 1;
249	break;
250	case CX88_BOARD_WINFAST2000XP_EXPERT:
251	ir_codes = ir_codes_winfast;
252	ir->gpio_addr = MO_GP0_IO;
253	ir->mask_keycode = 0x8f8;
254	ir->mask_keyup = 0x100;
255	ir->polling = 1; // ms
256	break;
257	case CX88_BOARD_IODATA_GVBCTV7E:
258	ir_codes = ir_codes_iodata_bctv7e;
259	ir->gpio_addr = MO_GP0_IO;
260	ir->mask_keycode = 0xfd;
261	ir->mask_keydown = 0x02;
262	ir->polling = 5; // ms
263	break;
264	}
265	if (NULL == ir_codes) {
266	kfree(ir);
267	return -ENODEV;
268	}
269
270	/* init input device */
271	snprintf(ir->name, sizeof(ir->name), "cx88 IR (%s)",
272	cx88_boards[core->board].name);
273	snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
274	pci_name(pci));
275
276	ir_input_init(&ir->input, &ir->ir, ir_type, ir_codes);
277	ir->input.name = ir->name;
278	ir->input.phys = ir->phys;
279	ir->input.id.bustype = BUS_PCI;
280	ir->input.id.version = 1;
281	if (pci->subsystem_vendor) {
282	ir->input.id.vendor = pci->subsystem_vendor;
283	ir->input.id.product = pci->subsystem_device;
284	} else {
285	ir->input.id.vendor = pci->vendor;
286	ir->input.id.product = pci->device;
287	}
288
289	/* record handles to ourself */
290	ir->core = core;
291	core->ir = ir;
292
293	if (ir->polling) {
294	INIT_WORK(&ir->work, cx88_ir_work, ir);
295	init_timer(&ir->timer);
296	ir->timer.function = ir_timer;
297	ir->timer.data = (unsigned long)ir;
298	schedule_work(&ir->work);
299	}
300	if (ir->sampling) {
301	core->pci_irqmask \|= (1<<18); // IR_SMP_INT
302	cx_write(MO_DDS_IO, 0xa80a80); // 4 kHz sample rate
303	cx_write(MO_DDSCFG_IO, 0x5); // enable
304	}
305
306	/* all done */
307	input_register_device(&ir->input);
308	printk("%s: registered IR remote control\n", core->name);
309
310	return 0;
311	}
312
313	int cx88_ir_fini(struct cx88_core *core)
314	{
315	struct cx88_IR *ir = core->ir;
316
317	/* skip detach on non attached boards */
318	if (NULL == ir)
319	return 0;
320
321	if (ir->polling) {
322	del_timer(&ir->timer);
323	flush_scheduled_work();
324	}
325
326	input_unregister_device(&ir->input);
327	kfree(ir);
328
329	/* done */
330	core->ir = NULL;
331	return 0;
332	}
333
334	/* ---------------------------------------------------------------------- */
335
336	void cx88_ir_irq(struct cx88_core *core)
337	{
338	struct cx88_IR *ir = core->ir;
339	u32 samples,rc5;
340	int i;
341
342	if (NULL == ir)
343	return;
344	if (!ir->sampling)
345	return;
346
347	samples = cx_read(MO_SAMPLE_IO);
348	if (0 != samples && 0xffffffff != samples) {
349	/* record sample data */
350	if (ir->scount < ARRAY_SIZE(ir->samples))
351	ir->samples[ir->scount++] = samples;
352	return;
353	}
354	if (!ir->scount) {
355	/* nothing to sample */
356	if (ir->ir.keypressed && time_after(jiffies,ir->release))
357	ir_input_nokey(&ir->input,&ir->ir);
358	return;
359	}
360
361	/* have a complete sample */
362	if (ir->scount < ARRAY_SIZE(ir->samples))
363	ir->samples[ir->scount++] = samples;
364	for (i = 0; i < ir->scount; i++)
365	ir->samples[i] = ~ir->samples[i];
366	if (ir_debug)
367	ir_dump_samples(ir->samples,ir->scount);
368
369	/* decode it */
370	switch (core->board) {
371	case CX88_BOARD_HAUPPAUGE:
372	case CX88_BOARD_HAUPPAUGE_DVB_T1:
373	rc5 = ir_decode_biphase(ir->samples,ir->scount,5,7);
374	ir_dprintk("biphase decoded: %x\n",rc5);
375	if ((rc5 & 0xfffff000) != 0x3000)
376	break;
377	ir_input_keydown(&ir->input, &ir->ir, rc5 & 0x3f, rc5);
378	ir->release = jiffies + msecs_to_jiffies(120);
379	break;
380	}
381
382	ir->scount = 0;
383	return;
384	}
385
386	/* ---------------------------------------------------------------------- */
387
388	MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe");
389	MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls");
390	MODULE_LICENSE("GPL");
391
392	/*
393	* Local variables:
394	* c-basic-offset: 8
395	* End:
396	*/

Lines 1-8 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-vbi.c (-2 / +3 lines)
1	/*	1	/*
2	* $Id: cx88-vbi.c,v 1.14 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: cx88-vbi.c,v 1.16 2004/12/10 12:33:39 kraxel Exp $
3	*/	3	*/
4	#include <linux/kernel.h>	4	#include <linux/kernel.h>
5	#include <linux/module.h>	5	#include <linux/module.h>
		6	#include <linux/moduleparam.h>
6	#include <linux/init.h>	7	#include <linux/init.h>
7	#include <linux/slab.h>	8	#include <linux/slab.h>
8		9
Lines 64-70 int cx8800_start_vbi_dma(struct cx8800_d Link Here
64	q->count = 1;	65	q->count = 1;
65		66
66	/* enable irqs */	67	/* enable irqs */
67	cx_set(MO_PCI_INTMSK, 0x00fc01);	68	cx_set(MO_PCI_INTMSK, core->pci_irqmask \| 0x01);
68	cx_set(MO_VID_INTMSK, 0x0f0088);	69	cx_set(MO_VID_INTMSK, 0x0f0088);
69		70
70	/* enable capture */	71	/* enable capture */

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/cx88/cx88-video.c (-16 / +20 lines)
1	/*	1	/*
2	* $Id: cx88-video.c,v 1.46 2004/11/07 14:44:59 kraxel Exp $	2	* $Id: cx88-video.c,v 1.58 2005/03/07 15:58:05 kraxel Exp $
3	*	3	*
4	* device driver for Conexant 2388x based TV cards	4	* device driver for Conexant 2388x based TV cards
5	* video4linux video interface	5	* video4linux video interface
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kmod.h>	28	#include <linux/kmod.h>
28	#include <linux/kernel.h>	29	#include <linux/kernel.h>
29	#include <linux/slab.h>	30	#include <linux/slab.h>
Lines 428-434 static int start_video_dma(struct cx8800 Link Here
428	q->count = 1;	429	q->count = 1;
429		430
430	/* enable irqs */	431	/* enable irqs */
431	cx_set(MO_PCI_INTMSK, 0x00fc01);	432	cx_set(MO_PCI_INTMSK, core->pci_irqmask \| 0x01);
432	cx_set(MO_VID_INTMSK, 0x0f0011);	433	cx_set(MO_VID_INTMSK, 0x0f0011);
433		434
434	/* enable capture */	435	/* enable capture */
Lines 994-1000 static int video_open(struct inode *inod Link Here
994	cx_write(MO_GP3_IO, cx88_boards[board].radio.gpio3);	995	cx_write(MO_GP3_IO, cx88_boards[board].radio.gpio3);
995	dev->core->tvaudio = WW_FM;	996	dev->core->tvaudio = WW_FM;
996	cx88_set_tvaudio(core);	997	cx88_set_tvaudio(core);
997	cx88_set_stereo(core,V4L2_TUNER_MODE_STEREO);	998	cx88_set_stereo(core,V4L2_TUNER_MODE_STEREO,1);
998	cx88_call_i2c_clients(dev->core,AUDC_SET_RADIO,NULL);	999	cx88_call_i2c_clients(dev->core,AUDC_SET_RADIO,NULL);
999	}	1000	}
1000		1001
Lines 1002-1008 static int video_open(struct inode *inod Link Here
1002	}	1003	}
1003		1004
1004	static ssize_t	1005	static ssize_t
1005	video_read(struct file file, char __user data, size_t count, loff_t *ppos)	1006	video_read(struct file file, char data, size_t count, loff_t *ppos)
1006	{	1007	{
1007	struct cx8800_fh *fh = file->private_data;	1008	struct cx8800_fh *fh = file->private_data;
1008		1009
Lines 1083-1088 static int video_release(struct inode *i Link Here
1083	res_free(dev,fh,RESOURCE_VBI);	1084	res_free(dev,fh,RESOURCE_VBI);
1084	}	1085	}
1085		1086
		1087	videobuf_mmap_free(&fh->vidq);
		1088	videobuf_mmap_free(&fh->vbiq);
1086	file->private_data = NULL;	1089	file->private_data = NULL;
1087	kfree(fh);	1090	kfree(fh);
1088	return 0;	1091	return 0;
Lines 1338-1344 static int video_do_ioctl(struct inode * Link Here
1338	0;	1341	0;
1339	if (UNSET != core->tuner_type)	1342	if (UNSET != core->tuner_type)
1340	cap->capabilities \|= V4L2_CAP_TUNER;	1343	cap->capabilities \|= V4L2_CAP_TUNER;
1341
1342	return 0;	1344	return 0;
1343	}	1345	}
1344		1346
Lines 1429-1434 static int video_do_ioctl(struct inode * Link Here
1429	if (*i >= 4)	1431	if (*i >= 4)
1430	return -EINVAL;	1432	return -EINVAL;
1431	down(&dev->lock);	1433	down(&dev->lock);
		1434	cx88_newstation(core);
1432	video_mux(dev,*i);	1435	video_mux(dev,*i);
1433	up(&dev->lock);	1436	up(&dev->lock);
1434	return 0;	1437	return 0;
Lines 1560-1566 static int video_do_ioctl(struct inode * Link Here
1560	return -EINVAL;	1563	return -EINVAL;
1561	if (0 != t->index)	1564	if (0 != t->index)
1562	return -EINVAL;	1565	return -EINVAL;
1563	cx88_set_stereo(core, t->audmode);	1566	cx88_set_stereo(core, t->audmode, 1);
1564	return 0;	1567	return 0;
1565	}	1568	}
1566	case VIDIOC_G_FREQUENCY:	1569	case VIDIOC_G_FREQUENCY:
Lines 1590-1595 static int video_do_ioctl(struct inode * Link Here
1590	return -EINVAL;	1593	return -EINVAL;
1591	down(&dev->lock);	1594	down(&dev->lock);
1592	dev->freq = f->frequency;	1595	dev->freq = f->frequency;
		1596	cx88_newstation(core);
1593	#ifdef V4L2_I2C_CLIENTS	1597	#ifdef V4L2_I2C_CLIENTS
1594	cx88_call_i2c_clients(dev->core,VIDIOC_S_FREQUENCY,f);	1598	cx88_call_i2c_clients(dev->core,VIDIOC_S_FREQUENCY,f);
1595	#else	1599	#else
Lines 1880-1898 static irqreturn_t cx8800_irq(int irq, v Link Here
1880	{	1884	{
1881	struct cx8800_dev *dev = dev_id;	1885	struct cx8800_dev *dev = dev_id;
1882	struct cx88_core *core = dev->core;	1886	struct cx88_core *core = dev->core;
1883	u32 status, mask;	1887	u32 status;
1884	int loop, handled = 0;	1888	int loop, handled = 0;
1885		1889
1886	for (loop = 0; loop < 10; loop++) {	1890	for (loop = 0; loop < 10; loop++) {
1887	status = cx_read(MO_PCI_INTSTAT) & (~0x1f \| 0x01);	1891	status = cx_read(MO_PCI_INTSTAT) & (core->pci_irqmask \| 0x01);
1888	mask = cx_read(MO_PCI_INTMSK);	1892	if (0 == status)
1889	if (0 == (status & mask))
1890	goto out;	1893	goto out;
1891	cx_write(MO_PCI_INTSTAT, status);	1894	cx_write(MO_PCI_INTSTAT, status);
1892	handled = 1;	1895	handled = 1;
1893		1896
1894	if (status & mask & ~0x1f)	1897	if (status & core->pci_irqmask)
1895	cx88_irq(core,status,mask);	1898	cx88_core_irq(core,status);
1896	if (status & 0x01)	1899	if (status & 0x01)
1897	cx8800_vid_irq(dev);	1900	cx8800_vid_irq(dev);
1898	};	1901	};
Lines 2055-2060 static int __devinit cx8800_initdev(stru Link Here
2055	core->name,pci_dev->irq);	2058	core->name,pci_dev->irq);
2056	goto fail_core;	2059	goto fail_core;
2057	}	2060	}
		2061	cx_set(MO_PCI_INTMSK, core->pci_irqmask);
2058		2062
2059	/* load and configure helper modules */	2063	/* load and configure helper modules */
2060	if (TUNER_ABSENT != core->tuner_type)	2064	if (TUNER_ABSENT != core->tuner_type)
Lines 2156-2162 static void __devexit cx8800_finidev(str Link Here
2156	kfree(dev);	2160	kfree(dev);
2157	}	2161	}
2158		2162
2159	static int cx8800_suspend(struct pci_dev *pci_dev, u32 state)	2163	static int cx8800_suspend(struct pci_dev *pci_dev, pm_message_t state)
2160	{	2164	{
2161	struct cx8800_dev *dev = pci_get_drvdata(pci_dev);	2165	struct cx8800_dev *dev = pci_get_drvdata(pci_dev);
2162	struct cx88_core *core = dev->core;	2166	struct cx88_core *core = dev->core;
Lines 2181-2187 static int cx8800_suspend(struct pci_dev Link Here
2181	#endif	2185	#endif
2182		2186
2183	pci_save_state(pci_dev);	2187	pci_save_state(pci_dev);
2184	if (0 != pci_set_power_state(pci_dev, state)) {	2188	if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
2185	pci_disable_device(pci_dev);	2189	pci_disable_device(pci_dev);
2186	dev->state.disabled = 1;	2190	dev->state.disabled = 1;
2187	}	2191	}
Lines 2197-2203 static int cx8800_resume(struct pci_dev Link Here
2197	pci_enable_device(pci_dev);	2201	pci_enable_device(pci_dev);
2198	dev->state.disabled = 0;	2202	dev->state.disabled = 0;
2199	}	2203	}
2200	pci_set_power_state(pci_dev, 0);	2204	pci_set_power_state(pci_dev, PCI_D0);
2201	pci_restore_state(pci_dev);	2205	pci_restore_state(pci_dev);
2202		2206
2203	#if 1	2207	#if 1
Lines 2254-2260 static int cx8800_init(void) Link Here
2254	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",	2258	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
2255	SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);	2259	SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
2256	#endif	2260	#endif
2257	return pci_module_init(&cx8800_pci_driver);	2261	return pci_register_driver(&cx8800_pci_driver);
2258	}	2262	}
2259		2263
2260	static void cx8800_fini(void)	2264	static void cx8800_fini(void)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/ir-kbd-gpio.c (-48 / +3 lines)
1	/*	1	/*
2	* $Id: ir-kbd-gpio.c,v 1.11 2004/10/25 11:26:36 kraxel Exp $	2	* $Id: ir-kbd-gpio.c,v 1.12 2005/02/22 12:28:40 kraxel Exp $
3	*	3	*
4	* Copyright (c) 2003 Gerd Knorr	4	* Copyright (c) 2003 Gerd Knorr
5	* Copyright (c) 2003 Pavel Machek	5	* Copyright (c) 2003 Pavel Machek
Lines 114-164 static IR_KEYTAB_TYPE ir_codes_avermedia Link Here
114	[ 0x3e ] = KEY_VOLUMEUP, // 'volume +'	114	[ 0x3e ] = KEY_VOLUMEUP, // 'volume +'
115	};	115	};
116		116
117	static IR_KEYTAB_TYPE winfast_codes[IR_KEYTAB_SIZE] = {
118	[ 5 ] = KEY_KP1,
119	[ 6 ] = KEY_KP2,
120	[ 7 ] = KEY_KP3,
121	[ 9 ] = KEY_KP4,
122	[ 10 ] = KEY_KP5,
123	[ 11 ] = KEY_KP6,
124	[ 13 ] = KEY_KP7,
125	[ 14 ] = KEY_KP8,
126	[ 15 ] = KEY_KP9,
127	[ 18 ] = KEY_KP0,
128
129	[ 0 ] = KEY_POWER,
130	// [ 27 ] = MTS button
131	[ 2 ] = KEY_TUNER, // TV/FM
132	[ 30 ] = KEY_VIDEO,
133	// [ 22 ] = display button
134	[ 4 ] = KEY_VOLUMEUP,
135	[ 8 ] = KEY_VOLUMEDOWN,
136	[ 12 ] = KEY_CHANNELUP,
137	[ 16 ] = KEY_CHANNELDOWN,
138	[ 3 ] = KEY_ZOOM, // fullscreen
139	[ 31 ] = KEY_SUBTITLE, // closed caption/teletext
140	[ 32 ] = KEY_SLEEP,
141	// [ 41 ] = boss key
142	[ 20 ] = KEY_MUTE,
143	[ 43 ] = KEY_RED,
144	[ 44 ] = KEY_GREEN,
145	[ 45 ] = KEY_YELLOW,
146	[ 46 ] = KEY_BLUE,
147	[ 24 ] = KEY_KPPLUS, //fine tune +
148	[ 25 ] = KEY_KPMINUS, //fine tune -
149	// [ 42 ] = picture in picture
150	[ 33 ] = KEY_KPDOT,
151	[ 19 ] = KEY_KPENTER,
152	// [ 17 ] = recall
153	[ 34 ] = KEY_BACK,
154	[ 35 ] = KEY_PLAYPAUSE,
155	[ 36 ] = KEY_NEXT,
156	// [ 37 ] = time shifting
157	[ 38 ] = KEY_STOP,
158	[ 39 ] = KEY_RECORD
159	// [ 40 ] = snapshot
160	};
161
162	static IR_KEYTAB_TYPE ir_codes_pixelview[IR_KEYTAB_SIZE] = {	117	static IR_KEYTAB_TYPE ir_codes_pixelview[IR_KEYTAB_SIZE] = {
163	[ 2 ] = KEY_KP0,	118	[ 2 ] = KEY_KP0,
164	[ 1 ] = KEY_KP1,	119	[ 1 ] = KEY_KP1,
Lines 388-399 static int ir_probe(struct device *dev) Link Here
388	break;	343	break;
389		344
390	case BTTV_WINFAST2000:	345	case BTTV_WINFAST2000:
391	ir_codes = winfast_codes;	346	ir_codes = ir_codes_winfast;
392	ir->mask_keycode = 0x1f8;	347	ir->mask_keycode = 0x1f8;
393	break;	348	break;
394	case BTTV_MAGICTVIEW061:	349	case BTTV_MAGICTVIEW061:
395	case BTTV_MAGICTVIEW063:	350	case BTTV_MAGICTVIEW063:
396	ir_codes = winfast_codes;	351	ir_codes = ir_codes_winfast;
397	ir->mask_keycode = 0x0008e000;	352	ir->mask_keycode = 0x0008e000;
398	ir->mask_keydown = 0x00200000;	353	ir->mask_keydown = 0x00200000;
399	break;	354	break;

Added Link Here

(-)linux-2.6.11/drivers/media/video/mt20xx.c (+558 lines)
1	/*
2	* $Id: mt20xx.c,v 1.4 2005/03/04 09:24:56 kraxel Exp $
3	*
4	* i2c tv tuner chip device driver
5	* controls microtune tuners, mt2032 + mt2050 at the moment.
6	*/
7	#include <linux/delay.h>
8	#include <linux/i2c.h>
9	#include <linux/videodev.h>
10	#include <linux/moduleparam.h>
11	#include <media/tuner.h>
12
13	/* ---------------------------------------------------------------------- */
14
15	static unsigned int optimize_vco = 1;
16	module_param(optimize_vco, int, 0644);
17
18	static unsigned int tv_antenna = 1;
19	module_param(tv_antenna, int, 0644);
20
21	static unsigned int radio_antenna = 0;
22	module_param(radio_antenna, int, 0644);
23
24	/* ---------------------------------------------------------------------- */
25
26	#define MT2032 0x04
27	#define MT2030 0x06
28	#define MT2040 0x07
29	#define MT2050 0x42
30
31	static char *microtune_part[] = {
32	[ MT2030 ] = "MT2030",
33	[ MT2032 ] = "MT2032",
34	[ MT2040 ] = "MT2040",
35	[ MT2050 ] = "MT2050",
36	};
37
38	// IsSpurInBand()?
39	static int mt2032_spurcheck(struct i2c_client *c,
40	int f1, int f2, int spectrum_from,int spectrum_to)
41	{
42	struct tuner *t = i2c_get_clientdata(c);
43	int n1=1,n2,f;
44
45	f1=f1/1000; //scale to kHz to avoid 32bit overflows
46	f2=f2/1000;
47	spectrum_from/=1000;
48	spectrum_to/=1000;
49
50	tuner_dbg("spurcheck f1=%d f2=%d from=%d to=%d\n",
51	f1,f2,spectrum_from,spectrum_to);
52
53	do {
54	n2=-n1;
55	f=n1*(f1-f2);
56	do {
57	n2--;
58	f=f-f2;
59	tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);
60
61	if( (f>spectrum_from) && (f<spectrum_to))
62	tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
63	} while ( (f>(f2-spectrum_to)) \|\| (n2>-5));
64	n1++;
65	} while (n1<5);
66
67	return 1;
68	}
69
70	static int mt2032_compute_freq(struct i2c_client *c,
71	unsigned int rfin,
72	unsigned int if1, unsigned int if2,
73	unsigned int spectrum_from,
74	unsigned int spectrum_to,
75	unsigned char *buf,
76	int *ret_sel,
77	unsigned int xogc) //all in Hz
78	{
79	struct tuner *t = i2c_get_clientdata(c);
80	unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
81	desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;
82
83	fref= 5250 *1000; //5.25MHz
84	desired_lo1=rfin+if1;
85
86	lo1=(2(desired_lo1/1000)+(fref/1000)) / (2fref/1000);
87	lo1n=lo1/8;
88	lo1a=lo1-(lo1n*8);
89
90	s=rfin/1000/1000+1090;
91
92	if(optimize_vco) {
93	if(s>1890) sel=0;
94	else if(s>1720) sel=1;
95	else if(s>1530) sel=2;
96	else if(s>1370) sel=3;
97	else sel=4; // >1090
98	}
99	else {
100	if(s>1790) sel=0; // <1958
101	else if(s>1617) sel=1;
102	else if(s>1449) sel=2;
103	else if(s>1291) sel=3;
104	else sel=4; // >1090
105	}
106	*ret_sel=sel;
107
108	lo1freq=(lo1a+8lo1n)fref;
109
110	tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
111	rfin,lo1,lo1n,lo1a,sel,lo1freq);
112
113	desired_lo2=lo1freq-rfin-if2;
114	lo2=(desired_lo2)/fref;
115	lo2n=lo2/8;
116	lo2a=lo2-(lo2n*8);
117	lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
118	lo2freq=(lo2a+8lo2n)fref + lo2num(fref/1000)/37801000;
119
120	tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
121	rfin,lo2,lo2n,lo2a,lo2num,lo2freq);
122
123	if(lo1a<0 \|\| lo1a>7 \|\| lo1n<17 \|\|lo1n>48 \|\| lo2a<0 \|\|lo2a >7 \|\|lo2n<17 \|\| lo2n>30) {
124	tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
125	lo1a, lo1n, lo2a,lo2n);
126	return(-1);
127	}
128
129	mt2032_spurcheck(c, lo1freq, desired_lo2, spectrum_from, spectrum_to);
130	// should recalculate lo1 (one step up/down)
131
132	// set up MT2032 register map for transfer over i2c
133	buf[0]=lo1n-1;
134	buf[1]=lo1a \| (sel<<4);
135	buf[2]=0x86; // LOGC
136	buf[3]=0x0f; //reserved
137	buf[4]=0x1f;
138	buf[5]=(lo2n-1) \| (lo2a<<5);
139	if(rfin >40010001000)
140	buf[6]=0xe4;
141	else
142	buf[6]=0xf4; // set PKEN per rev 1.2
143	buf[7]=8+xogc;
144	buf[8]=0xc3; //reserved
145	buf[9]=0x4e; //reserved
146	buf[10]=0xec; //reserved
147	buf[11]=(lo2num&0xff);
148	buf[12]=(lo2num>>8) \|0x80; // Lo2RST
149
150	return 0;
151	}
152
153	static int mt2032_check_lo_lock(struct i2c_client *c)
154	{
155	struct tuner *t = i2c_get_clientdata(c);
156	int try,lock=0;
157	unsigned char buf[2];
158
159	for(try=0;try<10;try++) {
160	buf[0]=0x0e;
161	i2c_master_send(c,buf,1);
162	i2c_master_recv(c,buf,1);
163	tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
164	lock=buf[0] &0x06;
165
166	if (lock==6)
167	break;
168
169	tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
170	udelay(1000);
171	}
172	return lock;
173	}
174
175	static int mt2032_optimize_vco(struct i2c_client *c,int sel,int lock)
176	{
177	struct tuner *t = i2c_get_clientdata(c);
178	unsigned char buf[2];
179	int tad1;
180
181	buf[0]=0x0f;
182	i2c_master_send(c,buf,1);
183	i2c_master_recv(c,buf,1);
184	tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
185	tad1=buf[0]&0x07;
186
187	if(tad1 ==0) return lock;
188	if(tad1 ==1) return lock;
189
190	if(tad1==2) {
191	if(sel==0)
192	return lock;
193	else sel--;
194	}
195	else {
196	if(sel<4)
197	sel++;
198	else
199	return lock;
200	}
201
202	tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);
203
204	buf[0]=0x0f;
205	buf[1]=sel;
206	i2c_master_send(c,buf,2);
207	lock=mt2032_check_lo_lock(c);
208	return lock;
209	}
210
211
212	static void mt2032_set_if_freq(struct i2c_client *c, unsigned int rfin,
213	unsigned int if1, unsigned int if2,
214	unsigned int from, unsigned int to)
215	{
216	unsigned char buf[21];
217	int lint_try,ret,sel,lock=0;
218	struct tuner *t = i2c_get_clientdata(c);
219
220	tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
221	rfin,if1,if2,from,to);
222
223	buf[0]=0;
224	ret=i2c_master_send(c,buf,1);
225	i2c_master_recv(c,buf,21);
226
227	buf[0]=0;
228	ret=mt2032_compute_freq(c,rfin,if1,if2,from,to,&buf[1],&sel,t->xogc);
229	if (ret<0)
230	return;
231
232	// send only the relevant registers per Rev. 1.2
233	buf[0]=0;
234	ret=i2c_master_send(c,buf,4);
235	buf[5]=5;
236	ret=i2c_master_send(c,buf+5,4);
237	buf[11]=11;
238	ret=i2c_master_send(c,buf+11,3);
239	if(ret!=3)
240	tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);
241
242	// wait for PLLs to lock (per manual), retry LINT if not.
243	for(lint_try=0; lint_try<2; lint_try++) {
244	lock=mt2032_check_lo_lock(c);
245
246	if(optimize_vco)
247	lock=mt2032_optimize_vco(c,sel,lock);
248	if(lock==6) break;
249
250	tuner_dbg("mt2032: re-init PLLs by LINT\n");
251	buf[0]=7;
252	buf[1]=0x80 +8+t->xogc; // set LINT to re-init PLLs
253	i2c_master_send(c,buf,2);
254	mdelay(10);
255	buf[1]=8+t->xogc;
256	i2c_master_send(c,buf,2);
257	}
258
259	if (lock!=6)
260	tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");
261
262	buf[0]=2;
263	buf[1]=0x20; // LOGC for optimal phase noise
264	ret=i2c_master_send(c,buf,2);
265	if (ret!=2)
266	tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
267	}
268
269
270	static void mt2032_set_tv_freq(struct i2c_client *c, unsigned int freq)
271	{
272	struct tuner *t = i2c_get_clientdata(c);
273	int if2,from,to;
274
275	// signal bandwidth and picture carrier
276	if (t->std & V4L2_STD_525_60) {
277	// NTSC
278	from = 40750*1000;
279	to = 46750*1000;
280	if2 = 45750*1000;
281	} else {
282	// PAL
283	from = 32900*1000;
284	to = 39900*1000;
285	if2 = 38900*1000;
286	}
287
288	mt2032_set_if_freq(c, freq62500 / freq10001000/16 */,
289	109010001000, if2, from, to);
290	}
291
292	static void mt2032_set_radio_freq(struct i2c_client *c, unsigned int freq)
293	{
294	struct tuner *t = i2c_get_clientdata(c);
295	int if2 = t->radio_if2;
296
297	// per Manual for FM tuning: first if center freq. 1085 MHz
298	mt2032_set_if_freq(c, freq62500 / freq10001000/16 */,
299	108510001000,if2,if2,if2);
300	}
301
302	// Initalization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
303	static int mt2032_init(struct i2c_client *c)
304	{
305	struct tuner *t = i2c_get_clientdata(c);
306	unsigned char buf[21];
307	int ret,xogc,xok=0;
308
309	// Initialize Registers per spec.
310	buf[1]=2; // Index to register 2
311	buf[2]=0xff;
312	buf[3]=0x0f;
313	buf[4]=0x1f;
314	ret=i2c_master_send(c,buf+1,4);
315
316	buf[5]=6; // Index register 6
317	buf[6]=0xe4;
318	buf[7]=0x8f;
319	buf[8]=0xc3;
320	buf[9]=0x4e;
321	buf[10]=0xec;
322	ret=i2c_master_send(c,buf+5,6);
323
324	buf[12]=13; // Index register 13
325	buf[13]=0x32;
326	ret=i2c_master_send(c,buf+12,2);
327
328	// Adjust XOGC (register 7), wait for XOK
329	xogc=7;
330	do {
331	tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
332	mdelay(10);
333	buf[0]=0x0e;
334	i2c_master_send(c,buf,1);
335	i2c_master_recv(c,buf,1);
336	xok=buf[0]&0x01;
337	tuner_dbg("mt2032: xok = 0x%02x\n",xok);
338	if (xok == 1) break;
339
340	xogc--;
341	tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
342	if (xogc == 3) {
343	xogc=4; // min. 4 per spec
344	break;
345	}
346	buf[0]=0x07;
347	buf[1]=0x88 + xogc;
348	ret=i2c_master_send(c,buf,2);
349	if (ret!=2)
350	tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
351	} while (xok != 1 );
352	t->xogc=xogc;
353
354	t->tv_freq = mt2032_set_tv_freq;
355	t->radio_freq = mt2032_set_radio_freq;
356	return(1);
357	}
358
359	static void mt2050_set_antenna(struct i2c_client *c, unsigned char antenna)
360	{
361	struct tuner *t = i2c_get_clientdata(c);
362	unsigned char buf[2];
363	int ret;
364
365	buf[0] = 6;
366	buf[1] = antenna ? 0x11 : 0x10;
367	ret=i2c_master_send(c,buf,2);
368	tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
369	}
370
371	static void mt2050_set_if_freq(struct i2c_client *c,unsigned int freq, unsigned int if2)
372	{
373	struct tuner *t = i2c_get_clientdata(c);
374	unsigned int if1=121810001000;
375	unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
376	int ret;
377	unsigned char buf[6];
378
379	tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
380	freq,if1,if2);
381
382	f_lo1=freq+if1;
383	f_lo1=(f_lo1/1000000)*1000000;
384
385	f_lo2=f_lo1-freq-if2;
386	f_lo2=(f_lo2/50000)*50000;
387
388	lo1=f_lo1/4000000;
389	lo2=f_lo2/4000000;
390
391	f_lo1_modulo= f_lo1-(lo1*4000000);
392	f_lo2_modulo= f_lo2-(lo2*4000000);
393
394	num1=4*f_lo1_modulo/4000000;
395	num2=4096*(f_lo2_modulo/1000)/4000;
396
397	// todo spurchecks
398
399	div1a=(lo1/12)-1;
400	div1b=lo1-(div1a+1)*12;
401
402	div2a=(lo2/8)-1;
403	div2b=lo2-(div2a+1)*8;
404
405	if (tuner_debug > 1) {
406	tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
407	tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
408	num1,num2,div1a,div1b,div2a,div2b);
409	}
410
411	buf[0]=1;
412	buf[1]= 4*div1b + num1;
413	if(freq<27510001000) buf[1] = buf[1]\|0x80;
414
415	buf[2]=div1a;
416	buf[3]=32*div2b + num2/256;
417	buf[4]=num2-(num2/256)*256;
418	buf[5]=div2a;
419	if(num2!=0) buf[5]=buf[5]\|0x40;
420
421	if (tuner_debug > 1) {
422	int i;
423	tuner_dbg("bufs is: ");
424	for(i=0;i<6;i++)
425	printk("%x ",buf[i]);
426	printk("\n");
427	}
428
429	ret=i2c_master_send(c,buf,6);
430	if (ret!=6)
431	tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
432	}
433
434	static void mt2050_set_tv_freq(struct i2c_client *c, unsigned int freq)
435	{
436	struct tuner *t = i2c_get_clientdata(c);
437	unsigned int if2;
438
439	if (t->std & V4L2_STD_525_60) {
440	// NTSC
441	if2 = 45750*1000;
442	} else {
443	// PAL
444	if2 = 38900*1000;
445	}
446	if (V4L2_TUNER_DIGITAL_TV == t->mode) {
447	// DVB (pinnacle 300i)
448	if2 = 36150*1000;
449	}
450	mt2050_set_if_freq(c, freq*62500, if2);
451	mt2050_set_antenna(c, tv_antenna);
452	}
453
454	static void mt2050_set_radio_freq(struct i2c_client *c, unsigned int freq)
455	{
456	struct tuner *t = i2c_get_clientdata(c);
457	int if2 = t->radio_if2;
458
459	mt2050_set_if_freq(c, freq*62500, if2);
460	mt2050_set_antenna(c, radio_antenna);
461	}
462
463	static int mt2050_init(struct i2c_client *c)
464	{
465	struct tuner *t = i2c_get_clientdata(c);
466	unsigned char buf[2];
467	int ret;
468
469	buf[0]=6;
470	buf[1]=0x10;
471	ret=i2c_master_send(c,buf,2); // power
472
473	buf[0]=0x0f;
474	buf[1]=0x0f;
475	ret=i2c_master_send(c,buf,2); // m1lo
476
477	buf[0]=0x0d;
478	ret=i2c_master_send(c,buf,1);
479	i2c_master_recv(c,buf,1);
480
481	tuner_dbg("mt2050: sro is %x\n",buf[0]);
482	t->tv_freq = mt2050_set_tv_freq;
483	t->radio_freq = mt2050_set_radio_freq;
484	return 0;
485	}
486
487	int microtune_init(struct i2c_client *c)
488	{
489	struct tuner *t = i2c_get_clientdata(c);
490	char *name;
491	unsigned char buf[21];
492	int company_code;
493
494	memset(buf,0,sizeof(buf));
495	t->tv_freq = NULL;
496	t->radio_freq = NULL;
497	name = "unknown";
498
499	i2c_master_send(c,buf,1);
500	i2c_master_recv(c,buf,21);
501	if (tuner_debug) {
502	int i;
503	tuner_dbg("MT20xx hexdump:");
504	for(i=0;i<21;i++) {
505	printk(" %02x",buf[i]);
506	if(((i+1)%8)==0) printk(" ");
507	}
508	printk("\n");
509	}
510	company_code = buf[0x11] << 8 \| buf[0x12];
511	tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
512	company_code,buf[0x13],buf[0x14]);
513
514	#if 0
515	/* seems to cause more problems than it solves ... */
516	switch (company_code) {
517	case 0x30bf:
518	case 0x3cbf:
519	case 0x3dbf:
520	case 0x4d54:
521	case 0x8e81:
522	case 0x8e91:
523	/* ok (?) */
524	break;
525	default:
526	tuner_warn("tuner: microtune: unknown companycode\n");
527	return 0;
528	}
529	#endif
530
531	if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
532	NULL != microtune_part[buf[0x13]])
533	name = microtune_part[buf[0x13]];
534	switch (buf[0x13]) {
535	case MT2032:
536	mt2032_init(c);
537	break;
538	case MT2050:
539	mt2050_init(c);
540	break;
541	default:
542	tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
543	name);
544	return 0;
545	}
546
547	strlcpy(c->name, name, sizeof(c->name));
548	tuner_info("microtune %s found, OK\n",name);
549	return 0;
550	}
551
552	/*
553	* Overrides for Emacs so that we follow Linus's tabbing style.
554	* ---------------------------------------------------------------------------
555	* Local variables:
556	* c-basic-offset: 8
557	* End:
558	*/

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-core.c (-18 / +25 lines)
1	/*	1	/*
2	* $Id: saa7134-core.c,v 1.15 2004/11/07 14:44:59 kraxel Exp $	2	* $Id: saa7134-core.c,v 1.28 2005/02/22 09:56:29 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* driver core	5	* driver core
Lines 25-30 Link Here
25	#include <linux/init.h>	25	#include <linux/init.h>
26	#include <linux/list.h>	26	#include <linux/list.h>
27	#include <linux/module.h>	27	#include <linux/module.h>
		28	#include <linux/moduleparam.h>
28	#include <linux/kernel.h>	29	#include <linux/kernel.h>
29	#include <linux/slab.h>	30	#include <linux/slab.h>
30	#include <linux/kmod.h>	31	#include <linux/kmod.h>
Lines 88-94 MODULE_PARM_DESC(card, "card type"); Link Here
88	static DECLARE_MUTEX(devlist_lock);	89	static DECLARE_MUTEX(devlist_lock);
89	LIST_HEAD(saa7134_devlist);	90	LIST_HEAD(saa7134_devlist);
90	static LIST_HEAD(mops_list);	91	static LIST_HEAD(mops_list);
91	unsigned int saa7134_devcount;	92	static unsigned int saa7134_devcount;
92		93
93	#define dprintk(fmt, arg...) if (core_debug) \	94	#define dprintk(fmt, arg...) if (core_debug) \
94	printk(KERN_DEBUG "%s/core: " fmt, dev->name , ## arg)	95	printk(KERN_DEBUG "%s/core: " fmt, dev->name , ## arg)
Lines 620-626 static irqreturn_t saa7134_irq(int irq, Link Here
620	dump_statusregs(dev);	621	dump_statusregs(dev);
621	#endif	622	#endif
622		623
623	if (report & SAA7134_IRQ_REPORT_INTL)	624	if (report & SAA7134_IRQ_REPORT_RDCAP /* _INTL */)
624	saa7134_irq_video_intl(dev);	625	saa7134_irq_video_intl(dev);
625		626
626	if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&	627	if ((report & SAA7134_IRQ_REPORT_DONE_RA0) &&
Lines 642-649 static irqreturn_t saa7134_irq(int irq, Link Here
642	SAA7134_IRQ_REPORT_GPIO18)) &&	643	SAA7134_IRQ_REPORT_GPIO18)) &&
643	dev->remote)	644	dev->remote)
644	saa7134_input_irq(dev);	645	saa7134_input_irq(dev);
		646	}
645		647
646	};
647	if (10 == loop) {	648	if (10 == loop) {
648	print_irqstatus(dev,loop,report,status);	649	print_irqstatus(dev,loop,report,status);
649	if (report & SAA7134_IRQ_REPORT_PE) {	650	if (report & SAA7134_IRQ_REPORT_PE) {
Lines 651-656 static irqreturn_t saa7134_irq(int irq, Link Here
651	printk(KERN_WARNING "%s/irq: looping -- "	652	printk(KERN_WARNING "%s/irq: looping -- "
652	"clearing PE (parity error!) enable bit\n",dev->name);	653	"clearing PE (parity error!) enable bit\n",dev->name);
653	saa_clearl(SAA7134_IRQ2,SAA7134_IRQ2_INTE_PE);	654	saa_clearl(SAA7134_IRQ2,SAA7134_IRQ2_INTE_PE);
		655	} else if (report & (SAA7134_IRQ_REPORT_GPIO16 \|
		656	SAA7134_IRQ_REPORT_GPIO18)) {
		657	/* disable gpio IRQs */
		658	printk(KERN_WARNING "%s/irq: looping -- "
		659	"clearing GPIO enable bits\n",dev->name);
		660	saa_clearl(SAA7134_IRQ2, (SAA7134_IRQ2_INTE_GPIO16 \|
		661	SAA7134_IRQ2_INTE_GPIO18));
654	} else {	662	} else {
655	/* disable all irqs */	663	/* disable all irqs */
656	printk(KERN_WARNING "%s/irq: looping -- "	664	printk(KERN_WARNING "%s/irq: looping -- "
Lines 725-744 static int saa7134_hwinit2(struct saa713 Link Here
725		733
726	/* enable IRQ's */	734	/* enable IRQ's */
727	saa_writel(SAA7134_IRQ1, 0);	735	saa_writel(SAA7134_IRQ1, 0);
728	saa_writel(SAA7134_IRQ2,	736	saa_writel(SAA7134_IRQ2, dev->irq2_mask);
729	SAA7134_IRQ2_INTE_GPIO18 \|
730	SAA7134_IRQ2_INTE_GPIO18A \|
731	SAA7134_IRQ2_INTE_GPIO16 \|
732	SAA7134_IRQ2_INTE_SC2 \|
733	SAA7134_IRQ2_INTE_SC1 \|
734	SAA7134_IRQ2_INTE_SC0 \|
735	/* SAA7134_IRQ2_INTE_DEC5 \| FIXME: TRIG_ERR ??? */
736	SAA7134_IRQ2_INTE_DEC3 \|
737	SAA7134_IRQ2_INTE_DEC2 \|
738	/* SAA7134_IRQ2_INTE_DEC1 \| */
739	SAA7134_IRQ2_INTE_DEC0 \|
740	SAA7134_IRQ2_INTE_PE \|
741	SAA7134_IRQ2_INTE_AR);
742		737
743	return 0;	738	return 0;
744	}	739	}
Lines 959-964 static int __devinit saa7134_initdev(str Link Here
959	}	954	}
960		955
961	/* initialize hardware #1 */	956	/* initialize hardware #1 */
		957	dev->irq2_mask =
		958	SAA7134_IRQ2_INTE_DEC3 \|
		959	SAA7134_IRQ2_INTE_DEC2 \|
		960	SAA7134_IRQ2_INTE_DEC1 \|
		961	SAA7134_IRQ2_INTE_DEC0 \|
		962	SAA7134_IRQ2_INTE_PE \|
		963	SAA7134_IRQ2_INTE_AR;
962	saa7134_board_init1(dev);	964	saa7134_board_init1(dev);
963	saa7134_hwinit1(dev);	965	saa7134_hwinit1(dev);
964		966
Lines 1060-1065 static int __devinit saa7134_initdev(str Link Here
1060	}	1062	}
1061	list_add_tail(&dev->devlist,&saa7134_devlist);	1063	list_add_tail(&dev->devlist,&saa7134_devlist);
1062	up(&devlist_lock);	1064	up(&devlist_lock);
		1065
		1066	/* check for signal */
		1067	saa7134_irq_video_intl(dev);
1063	return 0;	1068	return 0;
1064		1069
1065	fail5:	1070	fail5:
Lines 1207-1212 static int saa7134_init(void) Link Here
1207		1212
1208	static void saa7134_fini(void)	1213	static void saa7134_fini(void)
1209	{	1214	{
		1215	if (pending_registered)
		1216	unregister_module_notifier(&pending_notifier);
1210	pci_unregister_driver(&saa7134_pci_driver);	1217	pci_unregister_driver(&saa7134_pci_driver);
1211	}	1218	}
1212		1219

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-i2c.c (-19 / +18 lines)
1	/*	1	/*
2	* $Id: saa7134-i2c.c,v 1.7 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-i2c.c,v 1.10 2005/01/24 17:37:23 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* i2c interface support	5	* i2c interface support
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29	#include <linux/delay.h>	30	#include <linux/delay.h>
Lines 205-211 static inline int i2c_send_byte(struct s Link Here
205	dword &= 0x0f;	206	dword &= 0x0f;
206	dword \|= (attr << 6);	207	dword \|= (attr << 6);
207	dword \|= ((__u32)data << 8);	208	dword \|= ((__u32)data << 8);
208	dword \|= 0x00 << 16;	209	dword \|= 0x00 << 16; /* 100 kHz */
		210	// dword \|= 0x40 << 16; /* 400 kHz */
209	dword \|= 0xf0 << 24;	211	dword \|= 0xf0 << 24;
210	saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword);	212	saa_writel(SAA7134_I2C_ATTR_STATUS >> 2, dword);
211	#endif	213	#endif
Lines 248-260 static int saa7134_i2c_xfer(struct i2c_a Link Here
248	if (!i2c_reset(dev))	250	if (!i2c_reset(dev))
249	return -EIO;	251	return -EIO;
250		252
		253	d2printk("start xfer\n");
251	d1printk(KERN_DEBUG "%s: i2c xfer:",dev->name);	254	d1printk(KERN_DEBUG "%s: i2c xfer:",dev->name);
252	for (i = 0; i < num; i++) {	255	for (i = 0; i < num; i++) {
253	if (!(msgs[i].flags & I2C_M_NOSTART) \|\| 0 == i) {	256	if (!(msgs[i].flags & I2C_M_NOSTART) \|\| 0 == i) {
254	/* send address */	257	/* send address */
		258	d2printk("send address\n");
255	addr = msgs[i].addr << 1;	259	addr = msgs[i].addr << 1;
256	if (msgs[i].flags & I2C_M_RD)	260	if (msgs[i].flags & I2C_M_RD)
257	addr \|= 1;	261	addr \|= 1;
		262	if (i > 0 && msgs[i].flags & I2C_M_RD) {
		263	/* workaround for a saa7134 i2c bug
		264	* needed to talk to the mt352 demux
		265	* thanks to pinnacle for the hint */
		266	int quirk = 0xfd;
		267	d1printk(" [%02x quirk]",quirk);
		268	i2c_send_byte(dev,START,quirk);
		269	i2c_recv_byte(dev);
		270	}
258	d1printk(" < %02x", addr);	271	d1printk(" < %02x", addr);
259	rc = i2c_send_byte(dev,START,addr);	272	rc = i2c_send_byte(dev,START,addr);
260	if (rc < 0)	273	if (rc < 0)
Lines 262-267 static int saa7134_i2c_xfer(struct i2c_a Link Here
262	}	275	}
263	if (msgs[i].flags & I2C_M_RD) {	276	if (msgs[i].flags & I2C_M_RD) {
264	/* read bytes */	277	/* read bytes */
		278	d2printk("read bytes\n");
265	for (byte = 0; byte < msgs[i].len; byte++) {	279	for (byte = 0; byte < msgs[i].len; byte++) {
266	d1printk(" =");	280	d1printk(" =");
267	rc = i2c_recv_byte(dev);	281	rc = i2c_recv_byte(dev);
Lines 272-277 static int saa7134_i2c_xfer(struct i2c_a Link Here
272	}	286	}
273	} else {	287	} else {
274	/* write bytes */	288	/* write bytes */
		289	d2printk("write bytes\n");
275	for (byte = 0; byte < msgs[i].len; byte++) {	290	for (byte = 0; byte < msgs[i].len; byte++) {
276	data = msgs[i].buf[byte];	291	data = msgs[i].buf[byte];
277	d1printk(" %02x", data);	292	d1printk(" %02x", data);
Lines 281-286 static int saa7134_i2c_xfer(struct i2c_a Link Here
281	}	296	}
282	}	297	}
283	}	298	}
		299	d2printk("xfer done\n");
284	d1printk(" >");	300	d1printk(" >");
285	i2c_set_attr(dev,STOP);	301	i2c_set_attr(dev,STOP);
286	rc = -EIO;	302	rc = -EIO;
Lines 313-330 static u32 functionality(struct i2c_adap Link Here
313	return I2C_FUNC_SMBUS_EMUL;	329	return I2C_FUNC_SMBUS_EMUL;
314	}	330	}
315		331
316	#ifndef I2C_PEC
317	static void inc_use(struct i2c_adapter *adap)
318	{
319	MOD_INC_USE_COUNT;
320	}
321
322	static void dec_use(struct i2c_adapter *adap)
323	{
324	MOD_DEC_USE_COUNT;
325	}
326	#endif
327
328	static int attach_inform(struct i2c_client *client)	332	static int attach_inform(struct i2c_client *client)
329	{	333	{
330	struct saa7134_dev *dev = client->adapter->algo_data;	334	struct saa7134_dev *dev = client->adapter->algo_data;
Lines 345-356 static struct i2c_algorithm saa7134_algo Link Here
345	};	349	};
346		350
347	static struct i2c_adapter saa7134_adap_template = {	351	static struct i2c_adapter saa7134_adap_template = {
348	#ifdef I2C_PEC
349	.owner = THIS_MODULE,	352	.owner = THIS_MODULE,
350	#else
351	.inc_use = inc_use,
352	.dec_use = dec_use,
353	#endif
354	#ifdef I2C_CLASS_TV_ANALOG	353	#ifdef I2C_CLASS_TV_ANALOG
355	.class = I2C_CLASS_TV_ANALOG,	354	.class = I2C_CLASS_TV_ANALOG,
356	#endif	355	#endif

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-input.c (-1 / +59 lines)
1	/*	1	/*
2	* $Id: saa7134-input.c,v 1.12 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-input.c,v 1.16 2004/12/10 12:33:39 kraxel Exp $
3	*	3	*
4	* handle saa7134 IR remotes via linux kernel input layer.	4	* handle saa7134 IR remotes via linux kernel input layer.
5	*	5	*
Lines 20-25 Link Here
20	*/	20	*/
21		21
22	#include <linux/module.h>	22	#include <linux/module.h>
		23	#include <linux/moduleparam.h>
23	#include <linux/init.h>	24	#include <linux/init.h>
24	#include <linux/delay.h>	25	#include <linux/delay.h>
25	#include <linux/sched.h>	26	#include <linux/sched.h>
Lines 258-263 static IR_KEYTAB_TYPE md2819_codes[IR_KE Link Here
258	[ 17 ] = KEY_CHANNELDOWN, // CHANNEL/PAGE-	259	[ 17 ] = KEY_CHANNELDOWN, // CHANNEL/PAGE-
259	[ 49 ] = KEY_CHANNELUP // CHANNEL/PAGE+	260	[ 49 ] = KEY_CHANNELUP // CHANNEL/PAGE+
260	};	261	};
		262
		263	static IR_KEYTAB_TYPE videomate_tv_pvr_codes[IR_KEYTAB_SIZE] = {
		264	[ 20 ] = KEY_MUTE,
		265	[ 36 ] = KEY_ZOOM,
		266
		267	[ 1 ] = KEY_DVD,
		268	[ 35 ] = KEY_RADIO,
		269	[ 0 ] = KEY_TV,
		270
		271	[ 10 ] = KEY_REWIND,
		272	[ 8 ] = KEY_PLAYPAUSE,
		273	[ 15 ] = KEY_FORWARD,
		274
		275	[ 2 ] = KEY_PREVIOUS,
		276	[ 7 ] = KEY_STOP,
		277	[ 6 ] = KEY_NEXT,
		278
		279	[ 12 ] = KEY_UP,
		280	[ 14 ] = KEY_DOWN,
		281	[ 11 ] = KEY_LEFT,
		282	[ 13 ] = KEY_RIGHT,
		283	[ 17 ] = KEY_OK,
		284
		285	[ 3 ] = KEY_MENU,
		286	[ 9 ] = KEY_SETUP,
		287	[ 5 ] = KEY_VIDEO,
		288	[ 34 ] = KEY_CHANNEL,
		289
		290	[ 18 ] = KEY_VOLUMEUP,
		291	[ 21 ] = KEY_VOLUMEDOWN,
		292	[ 16 ] = KEY_CHANNELUP,
		293	[ 19 ] = KEY_CHANNELDOWN,
		294
		295	[ 4 ] = KEY_RECORD,
		296
		297	[ 22 ] = KEY_KP1,
		298	[ 23 ] = KEY_KP2,
		299	[ 24 ] = KEY_KP3,
		300	[ 25 ] = KEY_KP4,
		301	[ 26 ] = KEY_KP5,
		302	[ 27 ] = KEY_KP6,
		303	[ 28 ] = KEY_KP7,
		304	[ 29 ] = KEY_KP8,
		305	[ 30 ] = KEY_KP9,
		306	[ 31 ] = KEY_KP0,
		307
		308	[ 32 ] = KEY_LANGUAGE,
		309	[ 33 ] = KEY_SLEEP,
		310	};
261	/* ---------------------------------------------------------------------- */	311	/* ---------------------------------------------------------------------- */
262		312
263	static int build_key(struct saa7134_dev *dev)	313	static int build_key(struct saa7134_dev *dev)
Lines 335-340 int saa7134_input_init1(struct saa7134_d Link Here
335	break;	385	break;
336	case SAA7134_BOARD_CINERGY400:	386	case SAA7134_BOARD_CINERGY400:
337	case SAA7134_BOARD_CINERGY600:	387	case SAA7134_BOARD_CINERGY600:
		388	case SAA7134_BOARD_CINERGY600_MK3:
338	ir_codes = cinergy_codes;	389	ir_codes = cinergy_codes;
339	mask_keycode = 0x00003f;	390	mask_keycode = 0x00003f;
340	mask_keyup = 0x040000;	391	mask_keyup = 0x040000;
Lines 353-358 int saa7134_input_init1(struct saa7134_d Link Here
353	polling = 50; // ms	404	polling = 50; // ms
354	break;	405	break;
355	case SAA7134_BOARD_MD2819:	406	case SAA7134_BOARD_MD2819:
		407	case SAA7134_BOARD_AVERMEDIA_305:
356	case SAA7134_BOARD_AVERMEDIA_307:	408	case SAA7134_BOARD_AVERMEDIA_307:
357	ir_codes = md2819_codes;	409	ir_codes = md2819_codes;
358	mask_keycode = 0x0007C8;	410	mask_keycode = 0x0007C8;
Lines 362-367 int saa7134_input_init1(struct saa7134_d Link Here
362	saa_setb(SAA7134_GPIO_GPMODE0, 0x4);	414	saa_setb(SAA7134_GPIO_GPMODE0, 0x4);
363	saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);	415	saa_setb(SAA7134_GPIO_GPSTATUS0, 0x4);
364	break;	416	break;
		417	case SAA7134_BOARD_VIDEOMATE_TV_PVR:
		418	ir_codes = videomate_tv_pvr_codes;
		419	mask_keycode = 0x00003F;
		420	mask_keyup = 0x400000;
		421	polling = 50; // ms
		422	break;
365	}	423	}
366	if (NULL == ir_codes) {	424	if (NULL == ir_codes) {
367	printk("%s: Oops: IR config error [card=%d]\n",	425	printk("%s: Oops: IR config error [card=%d]\n",

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-oss.c (-1 / +5 lines)
1	/*	1	/*
2	* $Id: saa7134-oss.c,v 1.11 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-oss.c,v 1.13 2004/12/10 12:33:39 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* oss dsp interface	5	* oss dsp interface
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29	#include <linux/soundcard.h>	30	#include <linux/soundcard.h>
Lines 543-548 mixer_recsrc_7134(struct saa7134_dev *de Link Here
543	break;	544	break;
544	case LINE1:	545	case LINE1:
545	case LINE2:	546	case LINE2:
		547	case LINE2_LEFT:
546	analog_io = (LINE1 == dev->oss.input) ? 0x00 : 0x08;	548	analog_io = (LINE1 == dev->oss.input) ? 0x00 : 0x08;
547	rate = (32000 == dev->oss.rate) ? 0x01 : 0x03;	549	rate = (32000 == dev->oss.rate) ? 0x01 : 0x03;
548	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, analog_io);	550	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, analog_io);
Lines 566-571 mixer_recsrc_7133(struct saa7134_dev *de Link Here
566	value = 0xbbbb32; /* AUX1 */	568	value = 0xbbbb32; /* AUX1 */
567	break;	569	break;
568	case LINE2:	570	case LINE2:
		571	case LINE2_LEFT:
569	value = 0xbbbb54; /* AUX2 */	572	value = 0xbbbb54; /* AUX2 */
570	break;	573	break;
571	}	574	}
Lines 608-613 mixer_level(struct saa7134_dev *dev, enu Link Here
608	(100 == level) ? 0x00 : 0x10);	611	(100 == level) ? 0x00 : 0x10);
609	break;	612	break;
610	case LINE2:	613	case LINE2:
		614	case LINE2_LEFT:
611	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x20,	615	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x20,
612	(100 == level) ? 0x00 : 0x20);	616	(100 == level) ? 0x00 : 0x20);
613	break;	617	break;

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-ts.c (-3 / +4 lines)
1	/*	1	/*
2	* $Id: saa7134-ts.c,v 1.12 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-ts.c,v 1.14 2005/02/03 10:24:33 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* video4linux video interface	5	* video4linux video interface
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29	#include <linux/delay.h>	30	#include <linux/delay.h>
Lines 220-229 void saa7134_irq_ts_done(struct saa7134_ Link Here
220	if (dev->ts_q.curr) {	221	if (dev->ts_q.curr) {
221	field = dev->ts_q.curr->vb.field;	222	field = dev->ts_q.curr->vb.field;
222	if (field == V4L2_FIELD_TOP) {	223	if (field == V4L2_FIELD_TOP) {
223	if ((status & 0x100000) != 0x100000)	224	if ((status & 0x100000) != 0x000000)
224	goto done;	225	goto done;
225	} else {	226	} else {
226	if ((status & 0x100000) != 0x000000)	227	if ((status & 0x100000) != 0x100000)
227	goto done;	228	goto done;
228	}	229	}
229	saa7134_buffer_finish(dev,&dev->ts_q,STATE_DONE);	230	saa7134_buffer_finish(dev,&dev->ts_q,STATE_DONE);

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-tvaudio.c (-24 / +39 lines)
1	/*	1	/*
2	* $Id: saa7134-tvaudio.c,v 1.17 2004/11/07 13:17:15 kraxel Exp $	2	* $Id: saa7134-tvaudio.c,v 1.22 2005/01/07 13:11:19 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* tv audio decoder (fm stereo, nicam, ...)	5	* tv audio decoder (fm stereo, nicam, ...)
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29	#include <linux/delay.h>	30	#include <linux/delay.h>
Lines 237-249 static void mute_input_7134(struct saa71 Link Here
237		238
238	if (PCI_DEVICE_ID_PHILIPS_SAA7134 == dev->pci->device)	239	if (PCI_DEVICE_ID_PHILIPS_SAA7134 == dev->pci->device)
239	/* 7134 mute */	240	/* 7134 mute */
240	saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ? 0xff : 0xbb);	241	saa_writeb(SAA7134_AUDIO_MUTE_CTRL, mute ? 0xbf : 0xbb);
241		242
242	/* switch internal audio mux */	243	/* switch internal audio mux */
243	switch (in->amux) {	244	switch (in->amux) {
244	case TV: ausel=0xc0; ics=0x00; ocs=0x02; break;	245	case TV: ausel=0xc0; ics=0x00; ocs=0x02; break;
245	case LINE1: ausel=0x80; ics=0x00; ocs=0x00; break;	246	case LINE1: ausel=0x80; ics=0x00; ocs=0x00; break;
246	case LINE2: ausel=0x80; ics=0x08; ocs=0x01; break;	247	case LINE2: ausel=0x80; ics=0x08; ocs=0x01; break;
		248	case LINE2_LEFT: ausel=0x80; ics=0x08; ocs=0x05; break;
247	}	249	}
248	saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, ausel);	250	saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, ausel);
249	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, ics);	251	saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, ics);
Lines 437-451 static int tvaudio_getstereo(struct saa7 Link Here
437	nicam = saa_readb(SAA7134_NICAM_STATUS);	439	nicam = saa_readb(SAA7134_NICAM_STATUS);
438	dprintk("getstereo: nicam=0x%x\n",nicam);	440	dprintk("getstereo: nicam=0x%x\n",nicam);
439	switch (nicam & 0x0b) {	441	switch (nicam & 0x0b) {
440	case 0x08:
441	retval = V4L2_TUNER_SUB_MONO;
442	break;
443	case 0x09:	442	case 0x09:
444	retval = V4L2_TUNER_SUB_LANG1 \| V4L2_TUNER_SUB_LANG2;	443	retval = V4L2_TUNER_SUB_LANG1 \| V4L2_TUNER_SUB_LANG2;
445	break;	444	break;
446	case 0x0a:	445	case 0x0a:
447	retval = V4L2_TUNER_SUB_MONO \| V4L2_TUNER_SUB_STEREO;	446	retval = V4L2_TUNER_SUB_MONO \| V4L2_TUNER_SUB_STEREO;
448	break;	447	break;
		448	case 0x08:
		449	default:
		450	retval = V4L2_TUNER_SUB_MONO;
		451	break;
449	}	452	}
450	break;	453	break;
451	}	454	}
Lines 748-756 static int mute_input_7133(struct saa713 Link Here
748	int mask;	751	int mask;
749		752
750	switch (dev->input->amux) {	753	switch (dev->input->amux) {
751	case TV: reg = 0x02; break;	754	case TV:
752	case LINE1: reg = 0x00; break;	755	reg = 0x02;
753	case LINE2: reg = 0x01; break;	756	break;
		757	case LINE1:
		758	reg = 0x00;
		759	break;
		760	case LINE2:
		761	case LINE2_LEFT:
		762	reg = 0x01;
		763	break;
754	}	764	}
755	if (dev->ctl_mute)	765	if (dev->ctl_mute)
756	reg = 0x07;	766	reg = 0x07;
Lines 869-874 static int tvaudio_thread_ddep(void *dat Link Here
869	/* ------------------------------------------------------------------ */	879	/* ------------------------------------------------------------------ */
870	/* common stuff + external entry points */	880	/* common stuff + external entry points */
871		881
		882	static void saa7134_enable_i2s(struct saa7134_dev *dev)
		883	{
		884	int i2s_format;
		885
		886	if (!card_is_empress(dev))
		887	return;
		888	i2s_format = (dev->input->amux == TV) ? 0x00 : 0x01;
		889
		890	/* enable I2S audio output for the mpeg encoder */
		891	saa_writeb(SAA7134_I2S_OUTPUT_SELECT, 0x80);
		892	saa_writeb(SAA7134_I2S_OUTPUT_FORMAT, i2s_format);
		893	saa_writeb(SAA7134_I2S_OUTPUT_LEVEL, 0x0F);
		894	saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x01);
		895	}
		896
872	int saa7134_tvaudio_rx2mode(u32 rx)	897	int saa7134_tvaudio_rx2mode(u32 rx)
873	{	898	{
874	u32 mode;	899	u32 mode;
Lines 911-916 void saa7134_tvaudio_setinput(struct saa Link Here
911	mute_input_7133(dev);	936	mute_input_7133(dev);
912	break;	937	break;
913	}	938	}
		939	saa7134_enable_i2s(dev);
914	}	940	}
915		941
916	void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level)	942	void saa7134_tvaudio_setvolume(struct saa7134_dev *dev, int level)
Lines 946-963 int saa7134_tvaudio_init2(struct saa7134 Link Here
946	DECLARE_MUTEX_LOCKED(sem);	972	DECLARE_MUTEX_LOCKED(sem);
947	int (my_thread)(void data) = NULL;	973	int (my_thread)(void data) = NULL;
948		974
949	/* enable I2S audio output */
950	if (card_is_empress(dev)) {
951	int i2sform = (48000 == dev->oss.rate)
952	? 0x01 : 0x00;
953
954	/* enable I2S output */
955	saa_writeb(SAA7134_I2S_OUTPUT_SELECT, 0x80);
956	saa_writeb(SAA7134_I2S_OUTPUT_FORMAT, i2sform);
957	saa_writeb(SAA7134_I2S_OUTPUT_LEVEL, 0x0F);
958	saa_writeb(SAA7134_I2S_AUDIO_OUTPUT, 0x01);
959	}
960
961	switch (dev->pci->device) {	975	switch (dev->pci->device) {
962	case PCI_DEVICE_ID_PHILIPS_SAA7134:	976	case PCI_DEVICE_ID_PHILIPS_SAA7134:
963	my_thread = tvaudio_thread;	977	my_thread = tvaudio_thread;
Lines 977-985 int saa7134_tvaudio_init2(struct saa7134 Link Here
977	if (dev->thread.pid < 0)	991	if (dev->thread.pid < 0)
978	printk(KERN_WARNING "%s: kernel_thread() failed\n",	992	printk(KERN_WARNING "%s: kernel_thread() failed\n",
979	dev->name);	993	dev->name);
980	wake_up_interruptible(&dev->thread.wq);	994	saa7134_tvaudio_do_scan(dev);
981	}	995	}
982		996
		997	saa7134_enable_i2s(dev);
983	return 0;	998	return 0;
984	}	999	}
985		1000

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134-video.c (-15 / +44 lines)
1	/*	1	/*
2	* $Id: saa7134-video.c,v 1.19 2004/11/07 14:44:59 kraxel Exp $	2	* $Id: saa7134-video.c,v 1.28 2005/02/15 15:59:35 kraxel Exp $
3	*	3	*
4	* device driver for philips saa7134 based TV cards	4	* device driver for philips saa7134 based TV cards
5	* video4linux video interface	5	* video4linux video interface
Lines 24-29 Link Here
24	#include <linux/init.h>	24	#include <linux/init.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/module.h>	26	#include <linux/module.h>
		27	#include <linux/moduleparam.h>
27	#include <linux/kernel.h>	28	#include <linux/kernel.h>
28	#include <linux/slab.h>	29	#include <linux/slab.h>
29		30
Lines 267-272 static struct saa7134_tvnorm tvnorms[] = Link Here
267	.chroma_ctrl2 = 0x06,	268	.chroma_ctrl2 = 0x06,
268	.vgate_misc = 0x1c,	269	.vgate_misc = 0x1c,
269		270
		271	},{
		272	.name = "PAL-60",
		273	.id = V4L2_STD_PAL_60,
		274
		275	.h_start = 0,
		276	.h_stop = 719,
		277	.video_v_start = 22,
		278	.video_v_stop = 22+239,
		279	.vbi_v_start = 10, /* FIXME */
		280	.vbi_v_stop = 21, /* FIXME */
		281	.src_timing = 1,
		282
		283	.sync_control = 0x18,
		284	.luma_control = 0x40,
		285	.chroma_ctrl1 = 0x81,
		286	.chroma_gain = 0x2a,
		287	.chroma_ctrl2 = 0x06,
		288	.vgate_misc = 0x1c,
270	}	289	}
271	};	290	};
272	#define TVNORMS ARRAY_SIZE(tvnorms)	291	#define TVNORMS ARRAY_SIZE(tvnorms)
Lines 443-453 void res_free(struct saa7134_dev *dev, s Link Here
443		462
444	static void set_tvnorm(struct saa7134_dev dev, struct saa7134_tvnorm norm)	463	static void set_tvnorm(struct saa7134_dev dev, struct saa7134_tvnorm norm)
445	{	464	{
446	int luma_control,sync_control,mux,nosignal;	465	int luma_control,sync_control,mux;
447		466
448	dprintk("set tv norm = %s\n",norm->name);	467	dprintk("set tv norm = %s\n",norm->name);
449	dev->tvnorm = norm;	468	dev->tvnorm = norm;
450	nosignal = (0 == (saa_readb(SAA7134_STATUS_VIDEO1) & 0x03));
451		469
452	mux = card_in(dev,dev->ctl_input).vmux;	470	mux = card_in(dev,dev->ctl_input).vmux;
453	luma_control = norm->luma_control;	471	luma_control = norm->luma_control;
Lines 455-461 static void set_tvnorm(struct saa7134_de Link Here
455		473
456	if (mux > 5)	474	if (mux > 5)
457	luma_control \|= 0x80; /* svideo */	475	luma_control \|= 0x80; /* svideo */
458	if (noninterlaced \|\| nosignal)	476	if (noninterlaced \|\| dev->nosignal)
459	sync_control \|= 0x20;	477	sync_control \|= 0x20;
460		478
461	/* setup cropping */	479	/* setup cropping */
Lines 1359-1364 static int video_release(struct inode *i Link Here
1359	res_free(dev,fh,RESOURCE_VBI);	1377	res_free(dev,fh,RESOURCE_VBI);
1360	}	1378	}
1361		1379
		1380	/* free stuff */
		1381	videobuf_mmap_free(&fh->cap);
		1382	videobuf_mmap_free(&fh->vbi);
1362	saa7134_pgtable_free(dev->pci,&fh->pt_cap);	1383	saa7134_pgtable_free(dev->pci,&fh->pt_cap);
1363	saa7134_pgtable_free(dev->pci,&fh->pt_vbi);	1384	saa7134_pgtable_free(dev->pci,&fh->pt_vbi);
1364		1385
Lines 1472-1477 static int saa7134_try_fmt(struct saa713 Link Here
1472	f->fmt.pix.width = maxw;	1493	f->fmt.pix.width = maxw;
1473	if (f->fmt.pix.height > maxh)	1494	if (f->fmt.pix.height > maxh)
1474	f->fmt.pix.height = maxh;	1495	f->fmt.pix.height = maxh;
		1496	f->fmt.pix.width &= ~0x03;
1475	f->fmt.pix.bytesperline =	1497	f->fmt.pix.bytesperline =
1476	(f->fmt.pix.width * fmt->depth) >> 3;	1498	(f->fmt.pix.width * fmt->depth) >> 3;
1477	f->fmt.pix.sizeimage =	1499	f->fmt.pix.sizeimage =
Lines 2267-2273 int saa7134_video_init1(struct saa7134_d Link Here
2267	dev->ctl_hue = ctrl_by_id(V4L2_CID_HUE)->default_value;	2289	dev->ctl_hue = ctrl_by_id(V4L2_CID_HUE)->default_value;
2268	dev->ctl_saturation = ctrl_by_id(V4L2_CID_SATURATION)->default_value;	2290	dev->ctl_saturation = ctrl_by_id(V4L2_CID_SATURATION)->default_value;
2269	dev->ctl_volume = ctrl_by_id(V4L2_CID_AUDIO_VOLUME)->default_value;	2291	dev->ctl_volume = ctrl_by_id(V4L2_CID_AUDIO_VOLUME)->default_value;
2270	dev->ctl_mute = ctrl_by_id(V4L2_CID_AUDIO_MUTE)->default_value;	2292	dev->ctl_mute = 1; // ctrl_by_id(V4L2_CID_AUDIO_MUTE)->default_value;
2271	dev->ctl_invert = ctrl_by_id(V4L2_CID_PRIVATE_INVERT)->default_value;	2293	dev->ctl_invert = ctrl_by_id(V4L2_CID_PRIVATE_INVERT)->default_value;
2272	dev->ctl_automute = ctrl_by_id(V4L2_CID_PRIVATE_AUTOMUTE)->default_value;	2294	dev->ctl_automute = ctrl_by_id(V4L2_CID_PRIVATE_AUTOMUTE)->default_value;
2273		2295
Lines 2317-2340 int saa7134_video_fini(struct saa7134_de Link Here
2317	void saa7134_irq_video_intl(struct saa7134_dev *dev)	2339	void saa7134_irq_video_intl(struct saa7134_dev *dev)
2318	{	2340	{
2319	static const char *st[] = {	2341	static const char *st[] = {
2320	"no signal", "found NTSC", "found PAL", "found SECAM" };	2342	"(no signal)", "NTSC", "PAL", "SECAM" };
2321	int norm;	2343	u32 st1,st2;
2322		2344
2323	norm = saa_readb(SAA7134_STATUS_VIDEO1) & 0x03;	2345	st1 = saa_readb(SAA7134_STATUS_VIDEO1);
2324	dprintk("DCSDT: %s\n",st[norm]);	2346	st2 = saa_readb(SAA7134_STATUS_VIDEO2);
		2347	dprintk("DCSDT: pll: %s, sync: %s, norm: %s\n",
		2348	(st1 & 0x40) ? "not locked" : "locked",
		2349	(st2 & 0x40) ? "no" : "yes",
		2350	st[st1 & 0x03]);
		2351	dev->nosignal = (st1 & 0x40) \|\| (st2 & 0x40);
2325		2352
2326	if (0 != norm) {	2353	if (dev->nosignal) {
2327	/* wake up tvaudio audio carrier scan thread */
2328	saa7134_tvaudio_do_scan(dev);
2329	if (!noninterlaced)
2330	saa_clearb(SAA7134_SYNC_CTRL, 0x20);
2331	} else {
2332	/* no video signal -> mute audio */	2354	/* no video signal -> mute audio */
2333	if (dev->ctl_automute)	2355	if (dev->ctl_automute)
2334	dev->automute = 1;	2356	dev->automute = 1;
2335	saa7134_tvaudio_setmute(dev);	2357	saa7134_tvaudio_setmute(dev);
2336	saa_setb(SAA7134_SYNC_CTRL, 0x20);	2358	saa_setb(SAA7134_SYNC_CTRL, 0x20);
		2359	} else {
		2360	/* wake up tvaudio audio carrier scan thread */
		2361	saa7134_tvaudio_do_scan(dev);
		2362	if (!noninterlaced)
		2363	saa_clearb(SAA7134_SYNC_CTRL, 0x20);
2337	}	2364	}
		2365	if (dev->mops && dev->mops->signal_change)
		2366	dev->mops->signal_change(dev);
2338	}	2367	}
2339		2368
2340	void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status)	2369	void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status)

Lines 1-5 Link Here

(-)linux-2.6.11.orig/drivers/media/video/saa7134/saa7134.h (-4 / +17 lines)
1	/*	1	/*
2	* $Id: saa7134.h,v 1.27 2004/11/04 11:03:52 kraxel Exp $	2	* $Id: saa7134.h,v 1.38 2005/03/07 12:01:51 kraxel Exp $
3	*	3	*
4	* v4l2 device driver for philips saa7134 based TV cards	4	* v4l2 device driver for philips saa7134 based TV cards
5	*	5	*
Lines 64-69 enum saa7134_audio_in { Link Here
64	TV = 1,	64	TV = 1,
65	LINE1 = 2,	65	LINE1 = 2,
66	LINE2 = 3,	66	LINE2 = 3,
		67	LINE2_LEFT,
67	};	68	};
68		69
69	enum saa7134_video_out {	70	enum saa7134_video_out {
Lines 156-166 struct saa7134_format { Link Here
156	#define SAA7134_BOARD_AVACSSMARTTV 32	157	#define SAA7134_BOARD_AVACSSMARTTV 32
157	#define SAA7134_BOARD_AVERMEDIA_DVD_EZMAKER 33	158	#define SAA7134_BOARD_AVERMEDIA_DVD_EZMAKER 33
158	#define SAA7134_BOARD_NOVAC_PRIMETV7133 34	159	#define SAA7134_BOARD_NOVAC_PRIMETV7133 34
159	#define SAA7134_BOARD_AVERMEDIA_305 35	160	#define SAA7134_BOARD_AVERMEDIA_STUDIO_305 35
160	#define SAA7133_BOARD_UPMOST_PURPLE_TV 36	161	#define SAA7133_BOARD_UPMOST_PURPLE_TV 36
161	#define SAA7134_BOARD_ITEMS_MTV005 37	162	#define SAA7134_BOARD_ITEMS_MTV005 37
162	#define SAA7134_BOARD_CINERGY200 38	163	#define SAA7134_BOARD_CINERGY200 38
163	#define SAA7134_BOARD_FLYTVPLATINUM 39	164	#define SAA7134_BOARD_FLYTVPLATINUM_MINI 39
164	#define SAA7134_BOARD_VIDEOMATE_TV_PVR 40	165	#define SAA7134_BOARD_VIDEOMATE_TV_PVR 40
165	#define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUS 41	166	#define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUS 41
166	#define SAA7134_BOARD_SABRENT_SBTTVFM 42	167	#define SAA7134_BOARD_SABRENT_SBTTVFM 42
Lines 169-174 struct saa7134_format { Link Here
169	#define SAA7134_BOARD_AVERMEDIA_307 45	170	#define SAA7134_BOARD_AVERMEDIA_307 45
170	#define SAA7134_BOARD_AVERMEDIA_CARDBUS 46	171	#define SAA7134_BOARD_AVERMEDIA_CARDBUS 46
171	#define SAA7134_BOARD_CINERGY400_CARDBUS 47	172	#define SAA7134_BOARD_CINERGY400_CARDBUS 47
		173	#define SAA7134_BOARD_CINERGY600_MK3 48
		174	#define SAA7134_BOARD_VIDEOMATE_GOLD_PLUS 49
		175	#define SAA7134_BOARD_PINNACLE_300I_DVBT_PAL 50
		176	#define SAA7134_BOARD_PROVIDEO_PV952 51
		177	#define SAA7134_BOARD_AVERMEDIA_305 52
		178	#define SAA7135_BOARD_ASUSTeK_TVFM7135 53
		179	#define SAA7134_BOARD_FLYTVPLATINUM_FM 54
		180	#define SAA7134_BOARD_FLYDVBTDUO 55
172		181
173	#define SAA7134_MAXBOARDS 8	182	#define SAA7134_MAXBOARDS 8
174	#define SAA7134_INPUT_MAX 8	183	#define SAA7134_INPUT_MAX 8
Lines 355-360 struct saa7134_mpeg_ops { Link Here
355	struct list_head next;	364	struct list_head next;
356	int (init)(struct saa7134_dev dev);	365	int (init)(struct saa7134_dev dev);
357	int (fini)(struct saa7134_dev dev);	366	int (fini)(struct saa7134_dev dev);
		367	void (signal_change)(struct saa7134_dev dev);
358	};	368	};
359		369
360	/* global device status */	370	/* global device status */
Lines 390-395 struct saa7134_dev { Link Here
390	unsigned int tuner_type;	400	unsigned int tuner_type;
391	unsigned int tda9887_conf;	401	unsigned int tda9887_conf;
392	unsigned int gpio_value;	402	unsigned int gpio_value;
		403	unsigned int irq2_mask;
393		404
394	/* i2c i/o */	405	/* i2c i/o */
395	struct i2c_adapter i2c_adap;	406	struct i2c_adapter i2c_adap;
Lines 437-442 struct saa7134_dev { Link Here
437	struct saa7134_input *hw_input;	448	struct saa7134_input *hw_input;
438	unsigned int hw_mute;	449	unsigned int hw_mute;
439	int last_carrier;	450	int last_carrier;
		451	int nosignal;
440		452
441	/* SAA7134_MPEG_* */	453	/* SAA7134_MPEG_* */
442	struct saa7134_ts ts;	454	struct saa7134_ts ts;
Lines 447-452 struct saa7134_dev { Link Here
447	struct video_device *empress_dev;	459	struct video_device *empress_dev;
448	struct videobuf_queue empress_tsq;	460	struct videobuf_queue empress_tsq;
449	unsigned int empress_users;	461	unsigned int empress_users;
		462	struct work_struct empress_workqueue;
		463	int empress_started;
450		464
451	/* SAA7134_MPEG_DVB only */	465	/* SAA7134_MPEG_DVB only */
452	struct videobuf_dvb dvb;	466	struct videobuf_dvb dvb;
Lines 476-482 struct saa7134_dev { Link Here
476	/* saa7134-core.c */	490	/* saa7134-core.c */
477		491
478	extern struct list_head saa7134_devlist;	492	extern struct list_head saa7134_devlist;
479	extern unsigned int saa7134_devcount;
480		493
481	void saa7134_print_ioctl(char *name, unsigned int cmd);	494	void saa7134_print_ioctl(char *name, unsigned int cmd);
482	void saa7134_track_gpio(struct saa7134_dev dev, char msg);	495	void saa7134_track_gpio(struct saa7134_dev dev, char msg);