Pull bugzilla-7570 into release branch
[linux-2.6] / drivers / media / video / tvmixer.c
1 /*
2  */
3
4 #include <linux/module.h>
5 #include <linux/moduleparam.h>
6 #include <linux/kernel.h>
7 #include <linux/string.h>
8 #include <linux/timer.h>
9 #include <linux/delay.h>
10 #include <linux/errno.h>
11 #include <linux/slab.h>
12 #include <linux/i2c.h>
13 #include <linux/videodev.h>
14 #include <linux/init.h>
15 #include <linux/kdev_t.h>
16 #include <linux/sound.h>
17 #include <linux/soundcard.h>
18
19 #include <asm/semaphore.h>
20 #include <asm/uaccess.h>
21
22
23 #define DEV_MAX  4
24
25 static int devnr = -1;
26 module_param(devnr, int, 0644);
27
28 MODULE_AUTHOR("Gerd Knorr");
29 MODULE_LICENSE("GPL");
30
31 /* ----------------------------------------------------------------------- */
32
33 struct TVMIXER {
34         struct i2c_client *dev;
35         int minor;
36         int count;
37 };
38
39 static struct TVMIXER devices[DEV_MAX];
40
41 static int tvmixer_adapters(struct i2c_adapter *adap);
42 static int tvmixer_clients(struct i2c_client *client);
43
44 /* ----------------------------------------------------------------------- */
45
46 static int mix_to_v4l(int i)
47 {
48         int r;
49
50         r = ((i & 0xff) * 65536 + 50) / 100;
51         if (r > 65535) r = 65535;
52         if (r <     0) r =     0;
53         return r;
54 }
55
56 static int v4l_to_mix(int i)
57 {
58         int r;
59
60         r = (i * 100 + 32768) / 65536;
61         if (r > 100) r = 100;
62         if (r <   0) r =   0;
63         return r | (r << 8);
64 }
65
66 static int v4l_to_mix2(int l, int r)
67 {
68         r = (r * 100 + 32768) / 65536;
69         if (r > 100) r = 100;
70         if (r <   0) r =   0;
71         l = (l * 100 + 32768) / 65536;
72         if (l > 100) l = 100;
73         if (l <   0) l =   0;
74         return (r << 8) | l;
75 }
76
77 static int tvmixer_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
78 {
79         struct video_audio va;
80         int left,right,ret,val = 0;
81         struct TVMIXER *mix = file->private_data;
82         struct i2c_client *client = mix->dev;
83         void __user *argp = (void __user *)arg;
84         int __user *p = argp;
85
86         if (NULL == client)
87                 return -ENODEV;
88
89         if (cmd == SOUND_MIXER_INFO) {
90                 mixer_info info;
91                 strlcpy(info.id, "tv card", sizeof(info.id));
92                 strlcpy(info.name, client->name, sizeof(info.name));
93                 info.modify_counter = 42 /* FIXME */;
94                 if (copy_to_user(argp, &info, sizeof(info)))
95                         return -EFAULT;
96                 return 0;
97         }
98         if (cmd == SOUND_OLD_MIXER_INFO) {
99                 _old_mixer_info info;
100                 strlcpy(info.id, "tv card", sizeof(info.id));
101                 strlcpy(info.name, client->name, sizeof(info.name));
102                 if (copy_to_user(argp, &info, sizeof(info)))
103                         return -EFAULT;
104                 return 0;
105         }
106         if (cmd == OSS_GETVERSION)
107                 return put_user(SOUND_VERSION, p);
108
109         if (_SIOC_DIR(cmd) & _SIOC_WRITE)
110                 if (get_user(val, p))
111                         return -EFAULT;
112
113         /* read state */
114         memset(&va,0,sizeof(va));
115         client->driver->command(client,VIDIOCGAUDIO,&va);
116
117         switch (cmd) {
118         case MIXER_READ(SOUND_MIXER_RECMASK):
119         case MIXER_READ(SOUND_MIXER_CAPS):
120         case MIXER_READ(SOUND_MIXER_RECSRC):
121         case MIXER_WRITE(SOUND_MIXER_RECSRC):
122                 ret = 0;
123                 break;
124
125         case MIXER_READ(SOUND_MIXER_STEREODEVS):
126                 ret = SOUND_MASK_VOLUME;
127                 break;
128         case MIXER_READ(SOUND_MIXER_DEVMASK):
129                 ret = SOUND_MASK_VOLUME;
130                 if (va.flags & VIDEO_AUDIO_BASS)
131                         ret |= SOUND_MASK_BASS;
132                 if (va.flags & VIDEO_AUDIO_TREBLE)
133                         ret |= SOUND_MASK_TREBLE;
134                 break;
135
136         case MIXER_WRITE(SOUND_MIXER_VOLUME):
137                 left  = mix_to_v4l(val);
138                 right = mix_to_v4l(val >> 8);
139                 va.volume  = max(left,right);
140                 va.balance = (32768*min(left,right)) / (va.volume ? va.volume : 1);
141                 va.balance = (left<right) ? (65535-va.balance) : va.balance;
142                 if (va.volume)
143                         va.flags &= ~VIDEO_AUDIO_MUTE;
144                 client->driver->command(client,VIDIOCSAUDIO,&va);
145                 client->driver->command(client,VIDIOCGAUDIO,&va);
146                 /* fall throuth */
147         case MIXER_READ(SOUND_MIXER_VOLUME):
148                 left  = (min(65536 - va.balance,32768) *
149                          va.volume) / 32768;
150                 right = (min(va.balance,(u16)32768) *
151                          va.volume) / 32768;
152                 ret = v4l_to_mix2(left,right);
153                 break;
154
155         case MIXER_WRITE(SOUND_MIXER_BASS):
156                 va.bass = mix_to_v4l(val);
157                 client->driver->command(client,VIDIOCSAUDIO,&va);
158                 client->driver->command(client,VIDIOCGAUDIO,&va);
159                 /* fall throuth  */
160         case MIXER_READ(SOUND_MIXER_BASS):
161                 ret = v4l_to_mix(va.bass);
162                 break;
163
164         case MIXER_WRITE(SOUND_MIXER_TREBLE):
165                 va.treble = mix_to_v4l(val);
166                 client->driver->command(client,VIDIOCSAUDIO,&va);
167                 client->driver->command(client,VIDIOCGAUDIO,&va);
168                 /* fall throuth */
169         case MIXER_READ(SOUND_MIXER_TREBLE):
170                 ret = v4l_to_mix(va.treble);
171                 break;
172
173         default:
174                 return -EINVAL;
175         }
176         if (put_user(ret, p))
177                 return -EFAULT;
178         return 0;
179 }
180
181 static int tvmixer_open(struct inode *inode, struct file *file)
182 {
183         int i, minor = iminor(inode);
184         struct TVMIXER *mix = NULL;
185         struct i2c_client *client = NULL;
186
187         for (i = 0; i < DEV_MAX; i++) {
188                 if (devices[i].minor == minor) {
189                         mix = devices+i;
190                         client = mix->dev;
191                         break;
192                 }
193         }
194
195         if (NULL == client)
196                 return -ENODEV;
197
198         /* lock bttv in memory while the mixer is in use  */
199         file->private_data = mix;
200         if (client->adapter->owner)
201                 try_module_get(client->adapter->owner);
202         return 0;
203 }
204
205 static int tvmixer_release(struct inode *inode, struct file *file)
206 {
207         struct TVMIXER *mix = file->private_data;
208         struct i2c_client *client;
209
210         client = mix->dev;
211         if (NULL == client) {
212                 return -ENODEV;
213         }
214
215         module_put(client->adapter->owner);
216         return 0;
217 }
218
219 static struct i2c_driver driver = {
220         .driver = {
221                 .name    = "tvmixer",
222         },
223         .id              = I2C_DRIVERID_TVMIXER,
224         .detach_adapter  = tvmixer_adapters,
225         .attach_adapter  = tvmixer_adapters,
226         .detach_client   = tvmixer_clients,
227 };
228
229 static const struct file_operations tvmixer_fops = {
230         .owner          = THIS_MODULE,
231         .llseek         = no_llseek,
232         .ioctl          = tvmixer_ioctl,
233         .open           = tvmixer_open,
234         .release        = tvmixer_release,
235 };
236
237 /* ----------------------------------------------------------------------- */
238
239 static int tvmixer_adapters(struct i2c_adapter *adap)
240 {
241         struct list_head  *item;
242         struct i2c_client *client;
243
244         list_for_each(item,&adap->clients) {
245                 client = list_entry(item, struct i2c_client, list);
246                 tvmixer_clients(client);
247         }
248         return 0;
249 }
250
251 static int tvmixer_clients(struct i2c_client *client)
252 {
253         struct video_audio va;
254         int i,minor;
255
256         if (!(client->adapter->class & I2C_CLASS_TV_ANALOG))
257                 return -1;
258
259         /* unregister ?? */
260         for (i = 0; i < DEV_MAX; i++) {
261                 if (devices[i].dev == client) {
262                         /* unregister */
263                         unregister_sound_mixer(devices[i].minor);
264                         devices[i].dev = NULL;
265                         devices[i].minor = -1;
266                         printk("tvmixer: %s unregistered (#1)\n",
267                                client->name);
268                         return 0;
269                 }
270         }
271
272         /* look for a free slot */
273         for (i = 0; i < DEV_MAX; i++)
274                 if (NULL == devices[i].dev)
275                         break;
276         if (i == DEV_MAX) {
277                 printk(KERN_WARNING "tvmixer: DEV_MAX too small\n");
278                 return -1;
279         }
280
281         /* audio chip with mixer ??? */
282         if (NULL == client->driver->command)
283                 return -1;
284         memset(&va,0,sizeof(va));
285         if (0 != client->driver->command(client,VIDIOCGAUDIO,&va))
286                 return -1;
287         if (0 == (va.flags & VIDEO_AUDIO_VOLUME))
288                 return -1;
289
290         /* everything is fine, register */
291         if ((minor = register_sound_mixer(&tvmixer_fops,devnr)) < 0) {
292                 printk(KERN_ERR "tvmixer: cannot allocate mixer device\n");
293                 return -1;
294         }
295
296         devices[i].minor = minor;
297         devices[i].count = 0;
298         devices[i].dev   = client;
299         printk("tvmixer: %s (%s) registered with minor %d\n",
300                client->name,client->adapter->name,minor);
301
302         return 0;
303 }
304
305 /* ----------------------------------------------------------------------- */
306
307 static int __init tvmixer_init_module(void)
308 {
309         int i;
310
311         for (i = 0; i < DEV_MAX; i++)
312                 devices[i].minor = -1;
313
314         return i2c_add_driver(&driver);
315 }
316
317 static void __exit tvmixer_cleanup_module(void)
318 {
319         int i;
320
321         i2c_del_driver(&driver);
322         for (i = 0; i < DEV_MAX; i++) {
323                 if (devices[i].minor != -1) {
324                         unregister_sound_mixer(devices[i].minor);
325                         printk("tvmixer: %s unregistered (#2)\n",
326                                devices[i].dev->name);
327                 }
328         }
329 }
330
331 module_init(tvmixer_init_module);
332 module_exit(tvmixer_cleanup_module);
333
334 /*
335  * Overrides for Emacs so that we follow Linus's tabbing style.
336  * ---------------------------------------------------------------------------
337  * Local variables:
338  * c-basic-offset: 8
339  * End:
340  */