drivers/media/video/tvmixer.c

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