linux/drivers/media/usb/tm6000/tm6000-alsa.c
<<
>>
Prefs
   1/*
   2 *
   3 *  Support for audio capture for tm5600/6000/6010
   4 *    (c) 2007-2008 Mauro Carvalho Chehab <mchehab@redhat.com>
   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
  43static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  44
  45static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
  46
  47module_param_array(enable, bool, NULL, 0444);
  48MODULE_PARM_DESC(enable, "Enable tm6000x soundcard. default enabled.");
  49
  50module_param_array(index, int, NULL, 0444);
  51MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s).");
  52
  53
  54/****************************************************************************
  55                                Module macros
  56 ****************************************************************************/
  57
  58MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
  59MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
  60MODULE_LICENSE("GPL");
  61MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},"
  62                        "{{Trident,tm6000},"
  63                        "{{Trident,tm6010}");
  64static unsigned int debug;
  65module_param(debug, int, 0644);
  66MODULE_PARM_DESC(debug, "enable debug messages");
  67
  68/****************************************************************************
  69                        Module specific funtions
  70 ****************************************************************************/
  71
  72/*
  73 * BOARD Specific: Sets audio DMA
  74 */
  75
  76static 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 */
  93static 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
 105static 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
 116static 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
 148static 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 */
 171static 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 */
 196static 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
 209static 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 */
 282static 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 */
 299static 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 */
 316static 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 */
 330static 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
 345static 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 */
 373static 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
 380static 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 */
 391static 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 */
 416static 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_create(index[devnr], "tm6000", THIS_MODULE, 0, &card);
 435        if (rc < 0) {
 436                snd_printk(KERN_ERR "cannot create card instance %d\n", devnr);
 437                return rc;
 438        }
 439        strcpy(card->driver, "tm6000-alsa");
 440        strcpy(card->shortname, "TM5600/60x0");
 441        sprintf(card->longname, "TM5600/60x0 Audio at bus %d device %d",
 442                dev->udev->bus->busnum, dev->udev->devnum);
 443
 444        sprintf(component, "USB%04x:%04x",
 445                le16_to_cpu(dev->udev->descriptor.idVendor),
 446                le16_to_cpu(dev->udev->descriptor.idProduct));
 447        snd_component_add(card, component);
 448        snd_card_set_dev(card, &dev->udev->dev);
 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
 480error_chip:
 481        kfree(chip);
 482        dev->adev = NULL;
 483error:
 484        snd_card_free(card);
 485        return rc;
 486}
 487
 488static 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
 510static 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
 518static int __init tm6000_alsa_register(void)
 519{
 520        return tm6000_register_extension(&audio_ops);
 521}
 522
 523static void __exit tm6000_alsa_unregister(void)
 524{
 525        tm6000_unregister_extension(&audio_ops);
 526}
 527
 528module_init(tm6000_alsa_register);
 529module_exit(tm6000_alsa_unregister);
 530