drivers/media/usb/tm6000/tm6000-alsa.c

   1 /*
   2  *
   3  *  Support for audio capture for tm5600/6000/6010
   4  *    (c) 2007-2008 Mauro Carvalho Chehab
   5  *
   6  *  Based on cx88-alsa.c
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/device.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/usb.h>
  18 #include <linux/slab.h>
  19 #include <linux/vmalloc.h>
  20
  21 #include <linux/delay.h>
  22 #include <sound/core.h>
  23 #include <sound/pcm.h>
  24 #include <sound/pcm_params.h>
  25 #include <sound/control.h>
  26 #include <sound/initval.h>
  27
  28
  29 #include "tm6000.h"
  30 #include "tm6000-regs.h"
  31
  32 #undef dprintk
  33
  34 #define dprintk(level, fmt, arg...) do {                                   \
  35         if (debug >= level)                                                \
  36                 printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg); \
  37         } while (0)
  38
  39 /****************************************************************************
  40                         Module global static vars
  41  ****************************************************************************/
  42
  43 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  44
  45 static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
  46
  47 module_param_array(enable, bool, NULL, 0444);
  48 MODULE_PARM_DESC(enable, "Enable tm6000x soundcard. default enabled.");
  49
  50 module_param_array(index, int, NULL, 0444);
  51 MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s).");
  52
  53
  54 /****************************************************************************
  55                                 Module macros
  56  ****************************************************************************/
  57
  58 MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
  59 MODULE_AUTHOR("Mauro Carvalho Chehab");
  60 MODULE_LICENSE("GPL");
  61 MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},"
  62                         "{{Trident,tm6000},"
  63                         "{{Trident,tm6010}");
  64 static unsigned int debug;
  65 module_param(debug, int, 0644);
  66 MODULE_PARM_DESC(debug, "enable debug messages");
  67
  68 /****************************************************************************
  69                         Module specific funtions
  70  ****************************************************************************/
  71
  72 /*
  73  * BOARD Specific: Sets audio DMA
  74  */
  75
  76 static int _tm6000_start_audio_dma(struct snd_tm6000_card *chip)
  77 {
  78         struct tm6000_core *core = chip->core;
  79
  80         dprintk(1, "Starting audio DMA\n");
  81
  82         /* Enables audio */
  83         tm6000_set_reg_mask(core, TM6010_REQ07_RCC_ACTIVE_IF, 0x40, 0x40);
  84
  85         tm6000_set_audio_bitrate(core, 48000);
  86
  87         return 0;
  88 }
  89
  90 /*
  91  * BOARD Specific: Resets audio DMA
  92  */
  93 static int _tm6000_stop_audio_dma(struct snd_tm6000_card *chip)
  94 {
  95         struct tm6000_core *core = chip->core;
  96
  97         dprintk(1, "Stopping audio DMA\n");
  98
  99         /* Disables audio */
 100         tm6000_set_reg_mask(core, TM6010_REQ07_RCC_ACTIVE_IF, 0x00, 0x40);
 101
 102         return 0;
 103 }
 104
 105 static void dsp_buffer_free(struct snd_pcm_substream *substream)
 106 {
 107         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 108
 109         dprintk(2, "Freeing buffer\n");
 110
 111         vfree(substream->runtime->dma_area);
 112         substream->runtime->dma_area = NULL;
 113         substream->runtime->dma_bytes = 0;
 114 }
 115
 116 static int dsp_buffer_alloc(struct snd_pcm_substream *substream, int size)
 117 {
 118         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 119
 120         dprintk(2, "Allocating buffer\n");
 121
 122         if (substream->runtime->dma_area) {
 123                 if (substream->runtime->dma_bytes > size)
 124                         return 0;
 125
 126                 dsp_buffer_free(substream);
 127         }
 128
 129         substream->runtime->dma_area = vmalloc(size);
 130         if (!substream->runtime->dma_area)
 131                 return -ENOMEM;
 132
 133         substream->runtime->dma_bytes = size;
 134
 135         return 0;
 136 }
 137
 138
 139 /****************************************************************************
 140                                 ALSA PCM Interface
 141  ****************************************************************************/
 142
 143 /*
 144  * Digital hardware definition
 145  */
 146 #define DEFAULT_FIFO_SIZE       4096
 147
 148 static struct snd_pcm_hardware snd_tm6000_digital_hw = {
 149         .info = SNDRV_PCM_INFO_BATCH |
 150                 SNDRV_PCM_INFO_MMAP |
 151                 SNDRV_PCM_INFO_INTERLEAVED |
 152                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
 153                 SNDRV_PCM_INFO_MMAP_VALID,
 154         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 155
 156         .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
 157         .rate_min = 48000,
 158         .rate_max = 48000,
 159         .channels_min = 2,
 160         .channels_max = 2,
 161         .period_bytes_min = 64,
 162         .period_bytes_max = 12544,
 163         .periods_min = 2,
 164         .periods_max = 98,
 165         .buffer_bytes_max = 62720 * 8,
 166 };
 167
 168 /*
 169  * audio pcm capture open callback
 170  */
 171 static int snd_tm6000_pcm_open(struct snd_pcm_substream *substream)
 172 {
 173         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 174         struct snd_pcm_runtime *runtime = substream->runtime;
 175         int err;
 176
 177         err = snd_pcm_hw_constraint_pow2(runtime, 0,
 178                                          SNDRV_PCM_HW_PARAM_PERIODS);
 179         if (err < 0)
 180                 goto _error;
 181
 182         chip->substream = substream;
 183
 184         runtime->hw = snd_tm6000_digital_hw;
 185         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 186
 187         return 0;
 188 _error:
 189         dprintk(1, "Error opening PCM!\n");
 190         return err;
 191 }
 192
 193 /*
 194  * audio close callback
 195  */
 196 static int snd_tm6000_close(struct snd_pcm_substream *substream)
 197 {
 198         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 199         struct tm6000_core *core = chip->core;
 200
 201         if (atomic_read(&core->stream_started) > 0) {
 202                 atomic_set(&core->stream_started, 0);
 203                 schedule_work(&core->wq_trigger);
 204         }
 205
 206         return 0;
 207 }
 208
 209 static int tm6000_fillbuf(struct tm6000_core *core, char *buf, int size)
 210 {
 211         struct snd_tm6000_card *chip = core->adev;
 212         struct snd_pcm_substream *substream = chip->substream;
 213         struct snd_pcm_runtime *runtime;
 214         int period_elapsed = 0;
 215         unsigned int stride, buf_pos;
 216         int length;
 217
 218         if (atomic_read(&core->stream_started) == 0)
 219                 return 0;
 220
 221         if (!size || !substream) {
 222                 dprintk(1, "substream was NULL\n");
 223                 return -EINVAL;
 224         }
 225
 226         runtime = substream->runtime;
 227         if (!runtime || !runtime->dma_area) {
 228                 dprintk(1, "runtime was NULL\n");
 229                 return -EINVAL;
 230         }
 231
 232         buf_pos = chip->buf_pos;
 233         stride = runtime->frame_bits >> 3;
 234
 235         if (stride == 0) {
 236                 dprintk(1, "stride is zero\n");
 237                 return -EINVAL;
 238         }
 239
 240         length = size / stride;
 241         if (length == 0) {
 242                 dprintk(1, "%s: length was zero\n", __func__);
 243                 return -EINVAL;
 244         }
 245
 246         dprintk(1, "Copying %d bytes at %p[%d] - buf size=%d x %d\n", size,
 247                 runtime->dma_area, buf_pos,
 248                 (unsigned int)runtime->buffer_size, stride);
 249
 250         if (buf_pos + length >= runtime->buffer_size) {
 251                 unsigned int cnt = runtime->buffer_size - buf_pos;
 252                 memcpy(runtime->dma_area + buf_pos * stride, buf, cnt * stride);
 253                 memcpy(runtime->dma_area, buf + cnt * stride,
 254                         length * stride - cnt * stride);
 255         } else
 256                 memcpy(runtime->dma_area + buf_pos * stride, buf,
 257                         length * stride);
 258
 259         snd_pcm_stream_lock(substream);
 260
 261         chip->buf_pos += length;
 262         if (chip->buf_pos >= runtime->buffer_size)
 263                 chip->buf_pos -= runtime->buffer_size;
 264
 265         chip->period_pos += length;
 266         if (chip->period_pos >= runtime->period_size) {
 267                 chip->period_pos -= runtime->period_size;
 268                 period_elapsed = 1;
 269         }
 270
 271         snd_pcm_stream_unlock(substream);
 272
 273         if (period_elapsed)
 274                 snd_pcm_period_elapsed(substream);
 275
 276         return 0;
 277 }
 278
 279 /*
 280  * hw_params callback
 281  */
 282 static int snd_tm6000_hw_params(struct snd_pcm_substream *substream,
 283                               struct snd_pcm_hw_params *hw_params)
 284 {
 285         int size, rc;
 286
 287         size = params_period_bytes(hw_params) * params_periods(hw_params);
 288
 289         rc = dsp_buffer_alloc(substream, size);
 290         if (rc < 0)
 291                 return rc;
 292
 293         return 0;
 294 }
 295
 296 /*
 297  * hw free callback
 298  */
 299 static int snd_tm6000_hw_free(struct snd_pcm_substream *substream)
 300 {
 301         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 302         struct tm6000_core *core = chip->core;
 303
 304         if (atomic_read(&core->stream_started) > 0) {
 305                 atomic_set(&core->stream_started, 0);
 306                 schedule_work(&core->wq_trigger);
 307         }
 308
 309         dsp_buffer_free(substream);
 310         return 0;
 311 }
 312
 313 /*
 314  * prepare callback
 315  */
 316 static int snd_tm6000_prepare(struct snd_pcm_substream *substream)
 317 {
 318         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 319
 320         chip->buf_pos = 0;
 321         chip->period_pos = 0;
 322
 323         return 0;
 324 }
 325
 326
 327 /*
 328  * trigger callback
 329  */
 330 static void audio_trigger(struct work_struct *work)
 331 {
 332         struct tm6000_core *core = container_of(work, struct tm6000_core,
 333                                                 wq_trigger);
 334         struct snd_tm6000_card *chip = core->adev;
 335
 336         if (atomic_read(&core->stream_started)) {
 337                 dprintk(1, "starting capture");
 338                 _tm6000_start_audio_dma(chip);
 339         } else {
 340                 dprintk(1, "stopping capture");
 341                 _tm6000_stop_audio_dma(chip);
 342         }
 343 }
 344
 345 static int snd_tm6000_card_trigger(struct snd_pcm_substream *substream, int cmd)
 346 {
 347         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 348         struct tm6000_core *core = chip->core;
 349         int err = 0;
 350
 351         switch (cmd) {
 352         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
 353         case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
 354         case SNDRV_PCM_TRIGGER_START:
 355                 atomic_set(&core->stream_started, 1);
 356                 break;
 357         case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
 358         case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
 359         case SNDRV_PCM_TRIGGER_STOP:
 360                 atomic_set(&core->stream_started, 0);
 361                 break;
 362         default:
 363                 err = -EINVAL;
 364                 break;
 365         }
 366         schedule_work(&core->wq_trigger);
 367
 368         return err;
 369 }
 370 /*
 371  * pointer callback
 372  */
 373 static snd_pcm_uframes_t snd_tm6000_pointer(struct snd_pcm_substream *substream)
 374 {
 375         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
 376
 377         return chip->buf_pos;
 378 }
 379
 380 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
 381                                              unsigned long offset)
 382 {
 383         void *pageptr = subs->runtime->dma_area + offset;
 384
 385         return vmalloc_to_page(pageptr);
 386 }
 387
 388 /*
 389  * operators
 390  */
 391 static struct snd_pcm_ops snd_tm6000_pcm_ops = {
 392         .open = snd_tm6000_pcm_open,
 393         .close = snd_tm6000_close,
 394         .ioctl = snd_pcm_lib_ioctl,
 395         .hw_params = snd_tm6000_hw_params,
 396         .hw_free = snd_tm6000_hw_free,
 397         .prepare = snd_tm6000_prepare,
 398         .trigger = snd_tm6000_card_trigger,
 399         .pointer = snd_tm6000_pointer,
 400         .page = snd_pcm_get_vmalloc_page,
 401 };
 402
 403 /*
 404  * create a PCM device
 405  */
 406
 407 /* FIXME: Control interface - How to control volume/mute? */
 408
 409 /****************************************************************************
 410                         Basic Flow for Sound Devices
 411  ****************************************************************************/
 412
 413 /*
 414  * Alsa Constructor - Component probe
 415  */
 416 static int tm6000_audio_init(struct tm6000_core *dev)
 417 {
 418         struct snd_card         *card;
 419         struct snd_tm6000_card  *chip;
 420         int                     rc;
 421         static int              devnr;
 422         char                    component[14];
 423         struct snd_pcm          *pcm;
 424
 425         if (!dev)
 426                 return 0;
 427
 428         if (devnr >= SNDRV_CARDS)
 429                 return -ENODEV;
 430
 431         if (!enable[devnr])
 432                 return -ENOENT;
 433
 434         rc = snd_card_new(&dev->udev->dev, index[devnr], "tm6000",
 435                           THIS_MODULE, 0, &card);
 436         if (rc < 0) {
 437                 snd_printk(KERN_ERR "cannot create card instance %d\n", devnr);
 438                 return rc;
 439         }
 440         strcpy(card->driver, "tm6000-alsa");
 441         strcpy(card->shortname, "TM5600/60x0");
 442         sprintf(card->longname, "TM5600/60x0 Audio at bus %d device %d",
 443                 dev->udev->bus->busnum, dev->udev->devnum);
 444
 445         sprintf(component, "USB%04x:%04x",
 446                 le16_to_cpu(dev->udev->descriptor.idVendor),
 447                 le16_to_cpu(dev->udev->descriptor.idProduct));
 448         snd_component_add(card, component);
 449
 450         chip = kzalloc(sizeof(struct snd_tm6000_card), GFP_KERNEL);
 451         if (!chip) {
 452                 rc = -ENOMEM;
 453                 goto error;
 454         }
 455
 456         chip->core = dev;
 457         chip->card = card;
 458         dev->adev = chip;
 459         spin_lock_init(&chip->reg_lock);
 460
 461         rc = snd_pcm_new(card, "TM6000 Audio", 0, 0, 1, &pcm);
 462         if (rc < 0)
 463                 goto error_chip;
 464
 465         pcm->info_flags = 0;
 466         pcm->private_data = chip;
 467         strcpy(pcm->name, "Trident TM5600/60x0");
 468
 469         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_tm6000_pcm_ops);
 470
 471         INIT_WORK(&dev->wq_trigger, audio_trigger);
 472         rc = snd_card_register(card);
 473         if (rc < 0)
 474                 goto error_chip;
 475
 476         dprintk(1, "Registered audio driver for %s\n", card->longname);
 477
 478         return 0;
 479
 480 error_chip:
 481         kfree(chip);
 482         dev->adev = NULL;
 483 error:
 484         snd_card_free(card);
 485         return rc;
 486 }
 487
 488 static int tm6000_audio_fini(struct tm6000_core *dev)
 489 {
 490         struct snd_tm6000_card *chip;
 491
 492         if (!dev)
 493                 return 0;
 494         chip = dev->adev;
 495
 496         if (!chip)
 497                 return 0;
 498
 499         if (!chip->card)
 500                 return 0;
 501
 502         snd_card_free(chip->card);
 503         chip->card = NULL;
 504         kfree(chip);
 505         dev->adev = NULL;
 506
 507         return 0;
 508 }
 509
 510 static struct tm6000_ops audio_ops = {
 511         .type   = TM6000_AUDIO,
 512         .name   = "TM6000 Audio Extension",
 513         .init   = tm6000_audio_init,
 514         .fini   = tm6000_audio_fini,
 515         .fillbuf = tm6000_fillbuf,
 516 };
 517
 518 static int __init tm6000_alsa_register(void)
 519 {
 520         return tm6000_register_extension(&audio_ops);
 521 }
 522
 523 static void __exit tm6000_alsa_unregister(void)
 524 {
 525         tm6000_unregister_extension(&audio_ops);
 526 }
 527
 528 module_init(tm6000_alsa_register);
 529 module_exit(tm6000_alsa_unregister);