drivers/media/video/tvmixer.c

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