git.oblomov.eu Git - linux-2.6/blob - 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  */