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