scheduled OSS driver removal (83bad1d7) · Commits · e / devices / android_kernel_teracube_2e

Documentation/feature-removal-schedule.txt

+0 −7

Original line number	Diff line number	Diff line
		@@ -208,13 +208,6 @@ Who: Randy Dunlap <randy.dunlap@oracle.com>

		---------------------------

		What: drivers depending on OSS_OBSOLETE
		When: options in 2.6.23, code in 2.6.25
		Why: obsolete OSS drivers
		Who: Adrian Bunk <bunk@stusta.de>

		---------------------------

		What: libata spindown skipping and warning
		When: Dec 2008
		Why: Some halt(8) implementations synchronize caches for and spin

arch/ppc/platforms/prep_setup.c

+0 −81

Original line number	Diff line number	Diff line
		@@ -91,20 +91,11 @@ extern void prep_tiger1_setup_pci(char irq_edge_mask_lo, char irq_edge_mask_hi
		#define cached_21 (((char *)(ppc_cached_irq_mask))[3])
		#define cached_A1 (((char *)(ppc_cached_irq_mask))[2])

		#ifdef CONFIG_SOUND_CS4232
		long ppc_cs4232_dma, ppc_cs4232_dma2;
		#endif

		extern PTE Hash, Hash_end;
		extern unsigned long Hash_size, Hash_mask;
		extern int probingmem;
		extern unsigned long loops_per_jiffy;

		#ifdef CONFIG_SOUND_CS4232
		EXPORT_SYMBOL(ppc_cs4232_dma);
		EXPORT_SYMBOL(ppc_cs4232_dma2);
		#endif

		/* useful ISA ports */
		#define PREP_SYSCTL 0x81c
		/* present in the IBM reference design; possibly identical in Mot boxes: */
		@@ -569,74 +560,6 @@ prep_show_percpuinfo(struct seq_file *m, int i)
		return 0;
		}

		#ifdef CONFIG_SOUND_CS4232
		static long __init masktoint(unsigned int i)
		{
		int t = -1;
		while (i >> ++t)
		;
		return (t-1);
		}

		/*
		* ppc_cs4232_dma and ppc_cs4232_dma2 are used in include/asm/dma.h
		* to distinguish sound dma-channels from others. This is because
		* blocksize on 16 bit dma-channels 5,6,7 is 128k, but
		* the cs4232.c uses 64k like on 8 bit dma-channels 0,1,2,3
		*/

		static void __init prep_init_sound(void)
		{
		PPC_DEVICE *audiodevice = NULL;

		/*
		* Get the needed resource information from residual data.
		*
		*/
		if (have_residual_data)
		audiodevice = residual_find_device(~0, NULL,
		MultimediaController, AudioController, -1, 0);

		if (audiodevice != NULL) {
		PnP_TAG_PACKET *pkt;

		pkt = PnP_find_packet((unsigned char *)&res->DevicePnPHeap[audiodevice->AllocatedOffset],
		S5_Packet, 0);
		if (pkt != NULL)
		ppc_cs4232_dma = masktoint(pkt->S5_Pack.DMAMask);
		pkt = PnP_find_packet((unsigned char*)&res->DevicePnPHeap[audiodevice->AllocatedOffset],
		S5_Packet, 1);
		if (pkt != NULL)
		ppc_cs4232_dma2 = masktoint(pkt->S5_Pack.DMAMask);
		}

		/*
		* These are the PReP specs' defaults for the cs4231. We use these
		* as fallback incase we don't have residual data.
		* At least the IBM Thinkpad 850 with IDE DMA Channels at 6 and 7
		* will use the other values.
		*/
		if (audiodevice == NULL) {
		switch (_prep_type) {
		case _PREP_IBM:
		ppc_cs4232_dma = 1;
		ppc_cs4232_dma2 = -1;
		break;
		default:
		ppc_cs4232_dma = 6;
		ppc_cs4232_dma2 = 7;
		}
		}

		/*
		* Find a way to push this information to the cs4232 driver
		* Give it out with printk, when not in cmd_line?
		* Append it to cmd_line and boot_command_line?
		* Format is cs4232=io,irq,dma,dma2
		*/
		}
		#endif /* CONFIG_SOUND_CS4232 */

		/*
		* Fill out screen_info according to the residual data. This allows us to use
		* at least vesafb.
		@@ -898,10 +821,6 @@ prep_setup_arch(void)
		}
		}

		#ifdef CONFIG_SOUND_CS4232
		prep_init_sound();
		#endif /* CONFIG_SOUND_CS4232 */

		prep_init_vesa();

		switch (_prep_type) {

drivers/media/video/Makefile

+0 −1

Original line number	Diff line number	Diff line
		@@ -22,7 +22,6 @@ obj-$(CONFIG_VIDEO_IR_I2C) += ir-kbd-i2c.o
		obj-$(CONFIG_VIDEO_TVAUDIO) += tvaudio.o
		obj-$(CONFIG_VIDEO_TDA7432) += tda7432.o
		obj-$(CONFIG_VIDEO_TDA9875) += tda9875.o
		obj-$(CONFIG_SOUND_TVMIXER) += tvmixer.o

		obj-$(CONFIG_VIDEO_SAA6588) += saa6588.o
		obj-$(CONFIG_VIDEO_SAA5246A) += saa5246a.o

drivers/media/video/tvmixer.c

deleted100644 → 0

+0 −336

Original line number	Diff line number	Diff line
		/*
		*/

		#include <linux/module.h>
		#include <linux/kernel.h>
		#include <linux/string.h>
		#include <linux/timer.h>
		#include <linux/delay.h>
		#include <linux/errno.h>
		#include <linux/slab.h>
		#include <linux/i2c.h>
		#include <linux/videodev.h>
		#include <linux/init.h>
		#include <linux/kdev_t.h>
		#include <linux/sound.h>
		#include <linux/soundcard.h>

		#include <asm/semaphore.h>
		#include <asm/uaccess.h>


		#define DEV_MAX 4

		static int devnr = -1;
		module_param(devnr, int, 0644);

		MODULE_AUTHOR("Gerd Knorr");
		MODULE_LICENSE("GPL");

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

		struct TVMIXER {
		struct i2c_client *dev;
		int minor;
		int count;
		};

		static struct TVMIXER devices[DEV_MAX];

		static int tvmixer_adapters(struct i2c_adapter *adap);
		static int tvmixer_clients(struct i2c_client *client);

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

		static int mix_to_v4l(int i)
		{
		int r;

		r = ((i & 0xff) * 65536 + 50) / 100;
		if (r > 65535) r = 65535;
		if (r < 0) r = 0;
		return r;
		}

		static int v4l_to_mix(int i)
		{
		int r;

		r = (i * 100 + 32768) / 65536;
		if (r > 100) r = 100;
		if (r < 0) r = 0;
		return r \| (r << 8);
		}

		static int v4l_to_mix2(int l, int r)
		{
		r = (r * 100 + 32768) / 65536;
		if (r > 100) r = 100;
		if (r < 0) r = 0;
		l = (l * 100 + 32768) / 65536;
		if (l > 100) l = 100;
		if (l < 0) l = 0;
		return (r << 8) \| l;
		}

		static int tvmixer_ioctl(struct inode inode, struct file file, unsigned int cmd, unsigned long arg)
		{
		struct video_audio va;
		int left,right,ret,val = 0;
		struct TVMIXER *mix = file->private_data;
		struct i2c_client *client = mix->dev;
		void __user argp = (void __user )arg;
		int __user *p = argp;

		if (NULL == client)
		return -ENODEV;

		if (cmd == SOUND_MIXER_INFO) {
		mixer_info info;
		strlcpy(info.id, "tv card", sizeof(info.id));
		strlcpy(info.name, client->name, sizeof(info.name));
		info.modify_counter = 42 /* FIXME */;
		if (copy_to_user(argp, &info, sizeof(info)))
		return -EFAULT;
		return 0;
		}
		if (cmd == SOUND_OLD_MIXER_INFO) {
		_old_mixer_info info;
		strlcpy(info.id, "tv card", sizeof(info.id));
		strlcpy(info.name, client->name, sizeof(info.name));
		if (copy_to_user(argp, &info, sizeof(info)))
		return -EFAULT;
		return 0;
		}
		if (cmd == OSS_GETVERSION)
		return put_user(SOUND_VERSION, p);

		if (_SIOC_DIR(cmd) & _SIOC_WRITE)
		if (get_user(val, p))
		return -EFAULT;

		/* read state */
		memset(&va,0,sizeof(va));
		client->driver->command(client,VIDIOCGAUDIO,&va);

		switch (cmd) {
		case MIXER_READ(SOUND_MIXER_RECMASK):
		case MIXER_READ(SOUND_MIXER_CAPS):
		case MIXER_READ(SOUND_MIXER_RECSRC):
		case MIXER_WRITE(SOUND_MIXER_RECSRC):
		ret = 0;
		break;

		case MIXER_READ(SOUND_MIXER_STEREODEVS):
		ret = SOUND_MASK_VOLUME;
		break;
		case MIXER_READ(SOUND_MIXER_DEVMASK):
		ret = SOUND_MASK_VOLUME;
		if (va.flags & VIDEO_AUDIO_BASS)
		ret \|= SOUND_MASK_BASS;
		if (va.flags & VIDEO_AUDIO_TREBLE)
		ret \|= SOUND_MASK_TREBLE;
		break;

		case MIXER_WRITE(SOUND_MIXER_VOLUME):
		left = mix_to_v4l(val);
		right = mix_to_v4l(val >> 8);
		va.volume = max(left,right);
		va.balance = (32768*min(left,right)) / (va.volume ? va.volume : 1);
		va.balance = (left<right) ? (65535-va.balance) : va.balance;
		if (va.volume)
		va.flags &= ~VIDEO_AUDIO_MUTE;
		client->driver->command(client,VIDIOCSAUDIO,&va);
		client->driver->command(client,VIDIOCGAUDIO,&va);
		/* fall throuth */
		case MIXER_READ(SOUND_MIXER_VOLUME):
		left = (min(65536 - va.balance,32768) *
		va.volume) / 32768;
		right = (min(va.balance,(u16)32768) *
		va.volume) / 32768;
		ret = v4l_to_mix2(left,right);
		break;

		case MIXER_WRITE(SOUND_MIXER_BASS):
		va.bass = mix_to_v4l(val);
		client->driver->command(client,VIDIOCSAUDIO,&va);
		client->driver->command(client,VIDIOCGAUDIO,&va);
		/* fall throuth */
		case MIXER_READ(SOUND_MIXER_BASS):
		ret = v4l_to_mix(va.bass);
		break;

		case MIXER_WRITE(SOUND_MIXER_TREBLE):
		va.treble = mix_to_v4l(val);
		client->driver->command(client,VIDIOCSAUDIO,&va);
		client->driver->command(client,VIDIOCGAUDIO,&va);
		/* fall throuth */
		case MIXER_READ(SOUND_MIXER_TREBLE):
		ret = v4l_to_mix(va.treble);
		break;

		default:
		return -EINVAL;
		}
		if (put_user(ret, p))
		return -EFAULT;
		return 0;
		}

		static int tvmixer_open(struct inode inode, struct file file)
		{
		int i, minor = iminor(inode);
		struct TVMIXER *mix = NULL;
		struct i2c_client *client = NULL;

		for (i = 0; i < DEV_MAX; i++) {
		if (devices[i].minor == minor) {
		mix = devices+i;
		client = mix->dev;
		break;
		}
		}

		if (NULL == client)
		return -ENODEV;

		/* lock bttv in memory while the mixer is in use */
		file->private_data = mix;
		if (client->adapter->owner)
		try_module_get(client->adapter->owner);
		return 0;
		}

		static int tvmixer_release(struct inode inode, struct file file)
		{
		struct TVMIXER *mix = file->private_data;
		struct i2c_client *client;

		client = mix->dev;
		if (NULL == client) {
		return -ENODEV;
		}

		module_put(client->adapter->owner);
		return 0;
		}

		static struct i2c_driver driver = {
		.driver = {
		.name = "tvmixer",
		},
		.id = I2C_DRIVERID_TVMIXER,
		.detach_adapter = tvmixer_adapters,
		.attach_adapter = tvmixer_adapters,
		.detach_client = tvmixer_clients,
		};

		static const struct file_operations tvmixer_fops = {
		.owner = THIS_MODULE,
		.llseek = no_llseek,
		.ioctl = tvmixer_ioctl,
		.open = tvmixer_open,
		.release = tvmixer_release,
		};

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

		static int tvmixer_adapters(struct i2c_adapter *adap)
		{
		struct i2c_client *client;

		list_for_each_entry(client, &adap->clients, list)
		tvmixer_clients(client);
		return 0;
		}

		static int tvmixer_clients(struct i2c_client *client)
		{
		struct video_audio va;
		int i,minor;

		if (!(client->adapter->class & I2C_CLASS_TV_ANALOG))
		return -1;

		/* unregister ?? */
		for (i = 0; i < DEV_MAX; i++) {
		if (devices[i].dev == client) {
		/* unregister */
		unregister_sound_mixer(devices[i].minor);
		devices[i].dev = NULL;
		devices[i].minor = -1;
		printk("tvmixer: %s unregistered (#1)\n",
		client->name);
		return 0;
		}
		}

		/* look for a free slot */
		for (i = 0; i < DEV_MAX; i++)
		if (NULL == devices[i].dev)
		break;
		if (i == DEV_MAX) {
		printk(KERN_WARNING "tvmixer: DEV_MAX too small\n");
		return -1;
		}

		/* audio chip with mixer ??? */
		if (NULL == client->driver->command)
		return -1;
		memset(&va,0,sizeof(va));
		if (0 != client->driver->command(client,VIDIOCGAUDIO,&va))
		return -1;
		if (0 == (va.flags & VIDEO_AUDIO_VOLUME))
		return -1;

		/* everything is fine, register */
		if ((minor = register_sound_mixer(&tvmixer_fops,devnr)) < 0) {
		printk(KERN_ERR "tvmixer: cannot allocate mixer device\n");
		return -1;
		}

		devices[i].minor = minor;
		devices[i].count = 0;
		devices[i].dev = client;
		printk("tvmixer: %s (%s) registered with minor %d\n",
		client->name,client->adapter->name,minor);

		return 0;
		}

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

		static int __init tvmixer_init_module(void)
		{
		int i;

		for (i = 0; i < DEV_MAX; i++)
		devices[i].minor = -1;

		return i2c_add_driver(&driver);
		}

		static void __exit tvmixer_cleanup_module(void)
		{
		int i;

		i2c_del_driver(&driver);
		for (i = 0; i < DEV_MAX; i++) {
		if (devices[i].minor != -1) {
		unregister_sound_mixer(devices[i].minor);
		printk("tvmixer: %s unregistered (#2)\n",
		devices[i].dev->name);
		}
		}
		}

		module_init(tvmixer_init_module);
		module_exit(tvmixer_cleanup_module);

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

include/asm-powerpc/dma.h

+4 −35

Original line number	Diff line number	Diff line
		@@ -93,16 +93,6 @@
		*
		*/

		/* see prep_setup_arch() for detailed informations */
		#if defined(CONFIG_SOUND_CS4232) && defined(CONFIG_PPC_PREP)
		extern long ppc_cs4232_dma, ppc_cs4232_dma2;
		#define SND_DMA1 ppc_cs4232_dma
		#define SND_DMA2 ppc_cs4232_dma2
		#else
		#define SND_DMA1 -1
		#define SND_DMA2 -1
		#endif

		/* 8237 DMA controllers */
		#define IO_DMA1_BASE 0x00 /* 8 bit slave DMA, channels 0..3 */
		#define IO_DMA2_BASE 0xC0 /* 16 bit master DMA, ch 4(=slave input)..7 */
		@@ -269,23 +259,14 @@ static __inline__ void set_dma_page(unsigned int dmanr, int pagenr)
		dma_outb(pagenr >> 8, DMA_HI_PAGE_3);
		break;
		case 5:
		if (SND_DMA1 == 5 \|\| SND_DMA2 == 5)
		dma_outb(pagenr, DMA_LO_PAGE_5);
		else
		dma_outb(pagenr & 0xfe, DMA_LO_PAGE_5);
		dma_outb(pagenr >> 8, DMA_HI_PAGE_5);
		break;
		case 6:
		if (SND_DMA1 == 6 \|\| SND_DMA2 == 6)
		dma_outb(pagenr, DMA_LO_PAGE_6);
		else
		dma_outb(pagenr & 0xfe, DMA_LO_PAGE_6);
		dma_outb(pagenr >> 8, DMA_HI_PAGE_6);
		break;
		case 7:
		if (SND_DMA1 == 7 \|\| SND_DMA2 == 7)
		dma_outb(pagenr, DMA_LO_PAGE_7);
		else
		dma_outb(pagenr & 0xfe, DMA_LO_PAGE_7);
		dma_outb(pagenr >> 8, DMA_HI_PAGE_7);
		break;
		@@ -302,12 +283,6 @@ static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int phys)
		((dmanr & 3) << 1) + IO_DMA1_BASE);
		dma_outb((phys >> 8) & 0xff,
		((dmanr & 3) << 1) + IO_DMA1_BASE);
		} else if (dmanr == SND_DMA1 \|\| dmanr == SND_DMA2) {
		dma_outb(phys & 0xff,
		((dmanr & 3) << 2) + IO_DMA2_BASE);
		dma_outb((phys >> 8) & 0xff,
		((dmanr & 3) << 2) + IO_DMA2_BASE);
		dma_outb((dmanr & 3), DMA2_EXT_REG);
		} else {
		dma_outb((phys >> 1) & 0xff,
		((dmanr & 3) << 2) + IO_DMA2_BASE);
		@@ -334,11 +309,6 @@ static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
		((dmanr & 3) << 1) + 1 + IO_DMA1_BASE);
		dma_outb((count >> 8) & 0xff,
		((dmanr & 3) << 1) + 1 + IO_DMA1_BASE);
		} else if (dmanr == SND_DMA1 \|\| dmanr == SND_DMA2) {
		dma_outb(count & 0xff,
		((dmanr & 3) << 2) + 2 + IO_DMA2_BASE);
		dma_outb((count >> 8) & 0xff,
		((dmanr & 3) << 2) + 2 + IO_DMA2_BASE);
		} else {
		dma_outb((count >> 1) & 0xff,
		((dmanr & 3) << 2) + 2 + IO_DMA2_BASE);
		@@ -368,8 +338,7 @@ static __inline__ int get_dma_residue(unsigned int dmanr)
		count = 1 + dma_inb(io_port);
		count += dma_inb(io_port) << 8;

		return (dmanr <= 3 \|\| dmanr == SND_DMA1 \|\| dmanr == SND_DMA2)
		? count : (count << 1);
		return (dmanr <= 3) ? count : (count << 1);
		}

		/* These are in kernel/dma.c: */