drivers/media/usb/cx231xx/cx231xx-audio.c

   1 /*
   2  *  Conexant Cx231xx audio extension
   3  *
   4  *  Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
   5  *       Based on em28xx driver
   6  *
   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 as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include "cx231xx.h"
  24 #include <linux/kernel.h>
  25 #include <linux/init.h>
  26 #include <linux/sound.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/soundcard.h>
  29 #include <linux/slab.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/proc_fs.h>
  32 #include <linux/module.h>
  33 #include <sound/core.h>
  34 #include <sound/pcm.h>
  35 #include <sound/pcm_params.h>
  36 #include <sound/info.h>
  37 #include <sound/initval.h>
  38 #include <sound/control.h>
  39 #include <media/v4l2-common.h>
  40
  41 static int debug;
  42 module_param(debug, int, 0644);
  43 MODULE_PARM_DESC(debug, "activates debug info");
  44
  45 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  46
  47 static int cx231xx_isoc_audio_deinit(struct cx231xx *dev)
  48 {
  49         int i;
  50
  51         dev_dbg(dev->dev, "Stopping isoc\n");
  52
  53         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
  54                 if (dev->adev.urb[i]) {
  55                         if (!irqs_disabled())
  56                                 usb_kill_urb(dev->adev.urb[i]);
  57                         else
  58                                 usb_unlink_urb(dev->adev.urb[i]);
  59
  60                         usb_free_urb(dev->adev.urb[i]);
  61                         dev->adev.urb[i] = NULL;
  62
  63                         kfree(dev->adev.transfer_buffer[i]);
  64                         dev->adev.transfer_buffer[i] = NULL;
  65                 }
  66         }
  67
  68         return 0;
  69 }
  70
  71 static int cx231xx_bulk_audio_deinit(struct cx231xx *dev)
  72 {
  73         int i;
  74
  75         dev_dbg(dev->dev, "Stopping bulk\n");
  76
  77         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
  78                 if (dev->adev.urb[i]) {
  79                         if (!irqs_disabled())
  80                                 usb_kill_urb(dev->adev.urb[i]);
  81                         else
  82                                 usb_unlink_urb(dev->adev.urb[i]);
  83
  84                         usb_free_urb(dev->adev.urb[i]);
  85                         dev->adev.urb[i] = NULL;
  86
  87                         kfree(dev->adev.transfer_buffer[i]);
  88                         dev->adev.transfer_buffer[i] = NULL;
  89                 }
  90         }
  91
  92         return 0;
  93 }
  94
  95 static void cx231xx_audio_isocirq(struct urb *urb)
  96 {
  97         struct cx231xx *dev = urb->context;
  98         int i;
  99         unsigned int oldptr;
 100         int period_elapsed = 0;
 101         int status;
 102         unsigned char *cp;
 103         unsigned int stride;
 104         struct snd_pcm_substream *substream;
 105         struct snd_pcm_runtime *runtime;
 106
 107         if (dev->state & DEV_DISCONNECTED)
 108                 return;
 109
 110         switch (urb->status) {
 111         case 0:         /* success */
 112         case -ETIMEDOUT:        /* NAK */
 113                 break;
 114         case -ECONNRESET:       /* kill */
 115         case -ENOENT:
 116         case -ESHUTDOWN:
 117                 return;
 118         default:                /* error */
 119                 dev_dbg(dev->dev, "urb completition error %d.\n",
 120                         urb->status);
 121                 break;
 122         }
 123
 124         if (atomic_read(&dev->stream_started) == 0)
 125                 return;
 126
 127         if (dev->adev.capture_pcm_substream) {
 128                 substream = dev->adev.capture_pcm_substream;
 129                 runtime = substream->runtime;
 130                 stride = runtime->frame_bits >> 3;
 131
 132                 for (i = 0; i < urb->number_of_packets; i++) {
 133                         int length = urb->iso_frame_desc[i].actual_length /
 134                                      stride;
 135                         cp = (unsigned char *)urb->transfer_buffer +
 136                                               urb->iso_frame_desc[i].offset;
 137
 138                         if (!length)
 139                                 continue;
 140
 141                         oldptr = dev->adev.hwptr_done_capture;
 142                         if (oldptr + length >= runtime->buffer_size) {
 143                                 unsigned int cnt;
 144
 145                                 cnt = runtime->buffer_size - oldptr;
 146                                 memcpy(runtime->dma_area + oldptr * stride, cp,
 147                                        cnt * stride);
 148                                 memcpy(runtime->dma_area, cp + cnt * stride,
 149                                        length * stride - cnt * stride);
 150                         } else {
 151                                 memcpy(runtime->dma_area + oldptr * stride, cp,
 152                                        length * stride);
 153                         }
 154
 155                         snd_pcm_stream_lock(substream);
 156
 157                         dev->adev.hwptr_done_capture += length;
 158                         if (dev->adev.hwptr_done_capture >=
 159                                                 runtime->buffer_size)
 160                                 dev->adev.hwptr_done_capture -=
 161                                                 runtime->buffer_size;
 162
 163                         dev->adev.capture_transfer_done += length;
 164                         if (dev->adev.capture_transfer_done >=
 165                                 runtime->period_size) {
 166                                 dev->adev.capture_transfer_done -=
 167                                                 runtime->period_size;
 168                                 period_elapsed = 1;
 169                         }
 170                         snd_pcm_stream_unlock(substream);
 171                 }
 172                 if (period_elapsed)
 173                         snd_pcm_period_elapsed(substream);
 174         }
 175         urb->status = 0;
 176
 177         status = usb_submit_urb(urb, GFP_ATOMIC);
 178         if (status < 0) {
 179                 dev_err(dev->dev,
 180                         "resubmit of audio urb failed (error=%i)\n",
 181                         status);
 182         }
 183         return;
 184 }
 185
 186 static void cx231xx_audio_bulkirq(struct urb *urb)
 187 {
 188         struct cx231xx *dev = urb->context;
 189         unsigned int oldptr;
 190         int period_elapsed = 0;
 191         int status;
 192         unsigned char *cp;
 193         unsigned int stride;
 194         struct snd_pcm_substream *substream;
 195         struct snd_pcm_runtime *runtime;
 196
 197         if (dev->state & DEV_DISCONNECTED)
 198                 return;
 199
 200         switch (urb->status) {
 201         case 0:         /* success */
 202         case -ETIMEDOUT:        /* NAK */
 203                 break;
 204         case -ECONNRESET:       /* kill */
 205         case -ENOENT:
 206         case -ESHUTDOWN:
 207                 return;
 208         default:                /* error */
 209                 dev_dbg(dev->dev, "urb completition error %d.\n",
 210                         urb->status);
 211                 break;
 212         }
 213
 214         if (atomic_read(&dev->stream_started) == 0)
 215                 return;
 216
 217         if (dev->adev.capture_pcm_substream) {
 218                 substream = dev->adev.capture_pcm_substream;
 219                 runtime = substream->runtime;
 220                 stride = runtime->frame_bits >> 3;
 221
 222                 if (1) {
 223                         int length = urb->actual_length /
 224                                      stride;
 225                         cp = (unsigned char *)urb->transfer_buffer;
 226
 227                         oldptr = dev->adev.hwptr_done_capture;
 228                         if (oldptr + length >= runtime->buffer_size) {
 229                                 unsigned int cnt;
 230
 231                                 cnt = runtime->buffer_size - oldptr;
 232                                 memcpy(runtime->dma_area + oldptr * stride, cp,
 233                                        cnt * stride);
 234                                 memcpy(runtime->dma_area, cp + cnt * stride,
 235                                        length * stride - cnt * stride);
 236                         } else {
 237                                 memcpy(runtime->dma_area + oldptr * stride, cp,
 238                                        length * stride);
 239                         }
 240
 241                         snd_pcm_stream_lock(substream);
 242
 243                         dev->adev.hwptr_done_capture += length;
 244                         if (dev->adev.hwptr_done_capture >=
 245                                                 runtime->buffer_size)
 246                                 dev->adev.hwptr_done_capture -=
 247                                                 runtime->buffer_size;
 248
 249                         dev->adev.capture_transfer_done += length;
 250                         if (dev->adev.capture_transfer_done >=
 251                                 runtime->period_size) {
 252                                 dev->adev.capture_transfer_done -=
 253                                                 runtime->period_size;
 254                                 period_elapsed = 1;
 255                         }
 256                         snd_pcm_stream_unlock(substream);
 257                 }
 258                 if (period_elapsed)
 259                         snd_pcm_period_elapsed(substream);
 260         }
 261         urb->status = 0;
 262
 263         status = usb_submit_urb(urb, GFP_ATOMIC);
 264         if (status < 0) {
 265                 dev_err(dev->dev,
 266                         "resubmit of audio urb failed (error=%i)\n",
 267                         status);
 268         }
 269         return;
 270 }
 271
 272 static int cx231xx_init_audio_isoc(struct cx231xx *dev)
 273 {
 274         int i, errCode;
 275         int sb_size;
 276
 277         dev_dbg(dev->dev,
 278                 "%s: Starting ISO AUDIO transfers\n", __func__);
 279
 280         if (dev->state & DEV_DISCONNECTED)
 281                 return -ENODEV;
 282
 283         sb_size = CX231XX_ISO_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;
 284
 285         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
 286                 struct urb *urb;
 287                 int j, k;
 288
 289                 dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
 290                 if (!dev->adev.transfer_buffer[i])
 291                         return -ENOMEM;
 292
 293                 memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
 294                 urb = usb_alloc_urb(CX231XX_ISO_NUM_AUDIO_PACKETS, GFP_ATOMIC);
 295                 if (!urb) {
 296                         dev_err(dev->dev, "usb_alloc_urb failed!\n");
 297                         for (j = 0; j < i; j++) {
 298                                 usb_free_urb(dev->adev.urb[j]);
 299                                 kfree(dev->adev.transfer_buffer[j]);
 300                         }
 301                         return -ENOMEM;
 302                 }
 303
 304                 urb->dev = dev->udev;
 305                 urb->context = dev;
 306                 urb->pipe = usb_rcvisocpipe(dev->udev,
 307                                                 dev->adev.end_point_addr);
 308                 urb->transfer_flags = URB_ISO_ASAP;
 309                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
 310                 urb->interval = 1;
 311                 urb->complete = cx231xx_audio_isocirq;
 312                 urb->number_of_packets = CX231XX_ISO_NUM_AUDIO_PACKETS;
 313                 urb->transfer_buffer_length = sb_size;
 314
 315                 for (j = k = 0; j < CX231XX_ISO_NUM_AUDIO_PACKETS;
 316                         j++, k += dev->adev.max_pkt_size) {
 317                         urb->iso_frame_desc[j].offset = k;
 318                         urb->iso_frame_desc[j].length = dev->adev.max_pkt_size;
 319                 }
 320                 dev->adev.urb[i] = urb;
 321         }
 322
 323         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
 324                 errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
 325                 if (errCode < 0) {
 326                         cx231xx_isoc_audio_deinit(dev);
 327                         return errCode;
 328                 }
 329         }
 330
 331         return errCode;
 332 }
 333
 334 static int cx231xx_init_audio_bulk(struct cx231xx *dev)
 335 {
 336         int i, errCode;
 337         int sb_size;
 338
 339         dev_dbg(dev->dev,
 340                 "%s: Starting BULK AUDIO transfers\n", __func__);
 341
 342         if (dev->state & DEV_DISCONNECTED)
 343                 return -ENODEV;
 344
 345         sb_size = CX231XX_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;
 346
 347         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
 348                 struct urb *urb;
 349                 int j;
 350
 351                 dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
 352                 if (!dev->adev.transfer_buffer[i])
 353                         return -ENOMEM;
 354
 355                 memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
 356                 urb = usb_alloc_urb(CX231XX_NUM_AUDIO_PACKETS, GFP_ATOMIC);
 357                 if (!urb) {
 358                         dev_err(dev->dev, "usb_alloc_urb failed!\n");
 359                         for (j = 0; j < i; j++) {
 360                                 usb_free_urb(dev->adev.urb[j]);
 361                                 kfree(dev->adev.transfer_buffer[j]);
 362                         }
 363                         return -ENOMEM;
 364                 }
 365
 366                 urb->dev = dev->udev;
 367                 urb->context = dev;
 368                 urb->pipe = usb_rcvbulkpipe(dev->udev,
 369                                                 dev->adev.end_point_addr);
 370                 urb->transfer_flags = 0;
 371                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
 372                 urb->complete = cx231xx_audio_bulkirq;
 373                 urb->transfer_buffer_length = sb_size;
 374
 375                 dev->adev.urb[i] = urb;
 376
 377         }
 378
 379         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
 380                 errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
 381                 if (errCode < 0) {
 382                         cx231xx_bulk_audio_deinit(dev);
 383                         return errCode;
 384                 }
 385         }
 386
 387         return errCode;
 388 }
 389
 390 static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs,
 391                                         size_t size)
 392 {
 393         struct snd_pcm_runtime *runtime = subs->runtime;
 394         struct cx231xx *dev = snd_pcm_substream_chip(subs);
 395
 396         dev_dbg(dev->dev, "Allocating vbuffer\n");
 397         if (runtime->dma_area) {
 398                 if (runtime->dma_bytes > size)
 399                         return 0;
 400
 401                 vfree(runtime->dma_area);
 402         }
 403         runtime->dma_area = vmalloc(size);
 404         if (!runtime->dma_area)
 405                 return -ENOMEM;
 406
 407         runtime->dma_bytes = size;
 408
 409         return 0;
 410 }
 411
 412 static struct snd_pcm_hardware snd_cx231xx_hw_capture = {
 413         .info = SNDRV_PCM_INFO_BLOCK_TRANSFER   |
 414             SNDRV_PCM_INFO_MMAP                 |
 415             SNDRV_PCM_INFO_INTERLEAVED          |
 416             SNDRV_PCM_INFO_MMAP_VALID,
 417
 418         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 419
 420         .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
 421
 422         .rate_min = 48000,
 423         .rate_max = 48000,
 424         .channels_min = 2,
 425         .channels_max = 2,
 426         .buffer_bytes_max = 62720 * 8,  /* just about the value in usbaudio.c */
 427         .period_bytes_min = 64,         /* 12544/2, */
 428         .period_bytes_max = 12544,
 429         .periods_min = 2,
 430         .periods_max = 98,              /* 12544, */
 431 };
 432
 433 static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
 434 {
 435         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 436         struct snd_pcm_runtime *runtime = substream->runtime;
 437         int ret = 0;
 438
 439         dev_dbg(dev->dev,
 440                 "opening device and trying to acquire exclusive lock\n");
 441
 442         if (dev->state & DEV_DISCONNECTED) {
 443                 dev_err(dev->dev,
 444                         "Can't open. the device was removed.\n");
 445                 return -ENODEV;
 446         }
 447
 448         /* set alternate setting for audio interface */
 449         /* 1 - 48000 samples per sec */
 450         mutex_lock(&dev->lock);
 451         if (dev->USE_ISO)
 452                 ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 1);
 453         else
 454                 ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
 455         mutex_unlock(&dev->lock);
 456         if (ret < 0) {
 457                 dev_err(dev->dev,
 458                         "failed to set alternate setting !\n");
 459
 460                 return ret;
 461         }
 462
 463         runtime->hw = snd_cx231xx_hw_capture;
 464
 465         mutex_lock(&dev->lock);
 466         /* inform hardware to start streaming */
 467         ret = cx231xx_capture_start(dev, 1, Audio);
 468
 469         dev->adev.users++;
 470         mutex_unlock(&dev->lock);
 471
 472         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 473         dev->adev.capture_pcm_substream = substream;
 474         runtime->private_data = dev;
 475
 476         return 0;
 477 }
 478
 479 static int snd_cx231xx_pcm_close(struct snd_pcm_substream *substream)
 480 {
 481         int ret;
 482         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 483
 484         dev_dbg(dev->dev, "closing device\n");
 485
 486         /* inform hardware to stop streaming */
 487         mutex_lock(&dev->lock);
 488         ret = cx231xx_capture_start(dev, 0, Audio);
 489
 490         /* set alternate setting for audio interface */
 491         /* 1 - 48000 samples per sec */
 492         ret = cx231xx_set_alt_setting(dev, INDEX_AUDIO, 0);
 493         if (ret < 0) {
 494                 dev_err(dev->dev,
 495                         "failed to set alternate setting !\n");
 496
 497                 mutex_unlock(&dev->lock);
 498                 return ret;
 499         }
 500
 501         dev->adev.users--;
 502         mutex_unlock(&dev->lock);
 503
 504         if (dev->adev.users == 0 && dev->adev.shutdown == 1) {
 505                 dev_dbg(dev->dev, "audio users: %d\n", dev->adev.users);
 506                 dev_dbg(dev->dev, "disabling audio stream!\n");
 507                 dev->adev.shutdown = 0;
 508                 dev_dbg(dev->dev, "released lock\n");
 509                 if (atomic_read(&dev->stream_started) > 0) {
 510                         atomic_set(&dev->stream_started, 0);
 511                         schedule_work(&dev->wq_trigger);
 512                 }
 513         }
 514         return 0;
 515 }
 516
 517 static int snd_cx231xx_hw_capture_params(struct snd_pcm_substream *substream,
 518                                          struct snd_pcm_hw_params *hw_params)
 519 {
 520         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 521         int ret;
 522
 523         dev_dbg(dev->dev, "Setting capture parameters\n");
 524
 525         ret = snd_pcm_alloc_vmalloc_buffer(substream,
 526                                            params_buffer_bytes(hw_params));
 527 #if 0
 528         /* TODO: set up cx231xx audio chip to deliver the correct audio format,
 529            current default is 48000hz multiplexed => 96000hz mono
 530            which shouldn't matter since analogue TV only supports mono */
 531         unsigned int channels, rate, format;
 532
 533         format = params_format(hw_params);
 534         rate = params_rate(hw_params);
 535         channels = params_channels(hw_params);
 536 #endif
 537
 538         return ret;
 539 }
 540
 541 static int snd_cx231xx_hw_capture_free(struct snd_pcm_substream *substream)
 542 {
 543         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 544
 545         dev_dbg(dev->dev, "Stop capture, if needed\n");
 546
 547         if (atomic_read(&dev->stream_started) > 0) {
 548                 atomic_set(&dev->stream_started, 0);
 549                 schedule_work(&dev->wq_trigger);
 550         }
 551
 552         return 0;
 553 }
 554
 555 static int snd_cx231xx_prepare(struct snd_pcm_substream *substream)
 556 {
 557         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 558
 559         dev->adev.hwptr_done_capture = 0;
 560         dev->adev.capture_transfer_done = 0;
 561
 562         return 0;
 563 }
 564
 565 static void audio_trigger(struct work_struct *work)
 566 {
 567         struct cx231xx *dev = container_of(work, struct cx231xx, wq_trigger);
 568
 569         if (atomic_read(&dev->stream_started)) {
 570                 dev_dbg(dev->dev, "starting capture");
 571                 if (is_fw_load(dev) == 0)
 572                         cx25840_call(dev, core, load_fw);
 573                 if (dev->USE_ISO)
 574                         cx231xx_init_audio_isoc(dev);
 575                 else
 576                         cx231xx_init_audio_bulk(dev);
 577         } else {
 578                 dev_dbg(dev->dev, "stopping capture");
 579                 cx231xx_isoc_audio_deinit(dev);
 580         }
 581 }
 582
 583 static int snd_cx231xx_capture_trigger(struct snd_pcm_substream *substream,
 584                                        int cmd)
 585 {
 586         struct cx231xx *dev = snd_pcm_substream_chip(substream);
 587         int retval = 0;
 588
 589         if (dev->state & DEV_DISCONNECTED)
 590                 return -ENODEV;
 591
 592         spin_lock(&dev->adev.slock);
 593         switch (cmd) {
 594         case SNDRV_PCM_TRIGGER_START:
 595                 atomic_set(&dev->stream_started, 1);
 596                 break;
 597         case SNDRV_PCM_TRIGGER_STOP:
 598                 atomic_set(&dev->stream_started, 0);
 599                 break;
 600         default:
 601                 retval = -EINVAL;
 602                 break;
 603         }
 604         spin_unlock(&dev->adev.slock);
 605
 606         schedule_work(&dev->wq_trigger);
 607
 608         return retval;
 609 }
 610
 611 static snd_pcm_uframes_t snd_cx231xx_capture_pointer(struct snd_pcm_substream
 612                                                      *substream)
 613 {
 614         struct cx231xx *dev;
 615         unsigned long flags;
 616         snd_pcm_uframes_t hwptr_done;
 617
 618         dev = snd_pcm_substream_chip(substream);
 619
 620         spin_lock_irqsave(&dev->adev.slock, flags);
 621         hwptr_done = dev->adev.hwptr_done_capture;
 622         spin_unlock_irqrestore(&dev->adev.slock, flags);
 623
 624         return hwptr_done;
 625 }
 626
 627 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
 628                                              unsigned long offset)
 629 {
 630         void *pageptr = subs->runtime->dma_area + offset;
 631
 632         return vmalloc_to_page(pageptr);
 633 }
 634
 635 static struct snd_pcm_ops snd_cx231xx_pcm_capture = {
 636         .open = snd_cx231xx_capture_open,
 637         .close = snd_cx231xx_pcm_close,
 638         .ioctl = snd_pcm_lib_ioctl,
 639         .hw_params = snd_cx231xx_hw_capture_params,
 640         .hw_free = snd_cx231xx_hw_capture_free,
 641         .prepare = snd_cx231xx_prepare,
 642         .trigger = snd_cx231xx_capture_trigger,
 643         .pointer = snd_cx231xx_capture_pointer,
 644         .page = snd_pcm_get_vmalloc_page,
 645 };
 646
 647 static int cx231xx_audio_init(struct cx231xx *dev)
 648 {
 649         struct cx231xx_audio *adev = &dev->adev;
 650         struct snd_pcm *pcm;
 651         struct snd_card *card;
 652         static int devnr;
 653         int err;
 654         struct usb_interface *uif;
 655         int i, isoc_pipe = 0;
 656
 657         if (dev->has_alsa_audio != 1) {
 658                 /* This device does not support the extension (in this case
 659                    the device is expecting the snd-usb-audio module or
 660                    doesn't have analog audio support at all) */
 661                 return 0;
 662         }
 663
 664         dev_dbg(dev->dev,
 665                 "probing for cx231xx non standard usbaudio\n");
 666
 667         err = snd_card_new(dev->dev, index[devnr], "Cx231xx Audio",
 668                            THIS_MODULE, 0, &card);
 669         if (err < 0)
 670                 return err;
 671
 672         spin_lock_init(&adev->slock);
 673         err = snd_pcm_new(card, "Cx231xx Audio", 0, 0, 1, &pcm);
 674         if (err < 0) {
 675                 snd_card_free(card);
 676                 return err;
 677         }
 678
 679         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 680                         &snd_cx231xx_pcm_capture);
 681         pcm->info_flags = 0;
 682         pcm->private_data = dev;
 683         strcpy(pcm->name, "Conexant cx231xx Capture");
 684         strcpy(card->driver, "Cx231xx-Audio");
 685         strcpy(card->shortname, "Cx231xx Audio");
 686         strcpy(card->longname, "Conexant cx231xx Audio");
 687
 688         INIT_WORK(&dev->wq_trigger, audio_trigger);
 689
 690         err = snd_card_register(card);
 691         if (err < 0) {
 692                 snd_card_free(card);
 693                 return err;
 694         }
 695         adev->sndcard = card;
 696         adev->udev = dev->udev;
 697
 698         /* compute alternate max packet sizes for Audio */
 699         uif =
 700             dev->udev->actconfig->interface[dev->current_pcb_config.
 701                                             hs_config_info[0].interface_info.
 702                                             audio_index + 1];
 703
 704         adev->end_point_addr =
 705             uif->altsetting[0].endpoint[isoc_pipe].desc.
 706                         bEndpointAddress;
 707
 708         adev->num_alt = uif->num_altsetting;
 709         dev_info(dev->dev,
 710                 "audio EndPoint Addr 0x%x, Alternate settings: %i\n",
 711                 adev->end_point_addr, adev->num_alt);
 712         adev->alt_max_pkt_size = kmalloc(32 * adev->num_alt, GFP_KERNEL);
 713
 714         if (adev->alt_max_pkt_size == NULL)
 715                 return -ENOMEM;
 716
 717         for (i = 0; i < adev->num_alt; i++) {
 718                 u16 tmp =
 719                     le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.
 720                                 wMaxPacketSize);
 721                 adev->alt_max_pkt_size[i] =
 722                     (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
 723                 dev_dbg(dev->dev,
 724                         "audio alternate setting %i, max size= %i\n", i,
 725                         adev->alt_max_pkt_size[i]);
 726         }
 727
 728         return 0;
 729 }
 730
 731 static int cx231xx_audio_fini(struct cx231xx *dev)
 732 {
 733         if (dev == NULL)
 734                 return 0;
 735
 736         if (dev->has_alsa_audio != 1) {
 737                 /* This device does not support the extension (in this case
 738                    the device is expecting the snd-usb-audio module or
 739                    doesn't have analog audio support at all) */
 740                 return 0;
 741         }
 742
 743         if (dev->adev.sndcard) {
 744                 snd_card_free(dev->adev.sndcard);
 745                 kfree(dev->adev.alt_max_pkt_size);
 746                 dev->adev.sndcard = NULL;
 747         }
 748
 749         return 0;
 750 }
 751
 752 static struct cx231xx_ops audio_ops = {
 753         .id = CX231XX_AUDIO,
 754         .name = "Cx231xx Audio Extension",
 755         .init = cx231xx_audio_init,
 756         .fini = cx231xx_audio_fini,
 757 };
 758
 759 static int __init cx231xx_alsa_register(void)
 760 {
 761         return cx231xx_register_extension(&audio_ops);
 762 }
 763
 764 static void __exit cx231xx_alsa_unregister(void)
 765 {
 766         cx231xx_unregister_extension(&audio_ops);
 767 }
 768
 769 MODULE_LICENSE("GPL");
 770 MODULE_AUTHOR("Srinivasa Deevi <srinivasa.deevi@conexant.com>");
 771 MODULE_DESCRIPTION("Cx231xx Audio driver");
 772
 773 module_init(cx231xx_alsa_register);
 774 module_exit(cx231xx_alsa_unregister);