drivers/media/pci/cx25821/cx25821-audio-upstream.c

   1 /*
   2  *  Driver for the Conexant CX25821 PCIe bridge
   3  *
   4  *  Copyright (C) 2009 Conexant Systems Inc.
   5  *  Authors  <hiep.huynh@conexant.com>, <shu.lin@conexant.com>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *
  16  *  GNU General Public License for more details.
  17  */
  18
  19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20
  21 #include "cx25821-video.h"
  22 #include "cx25821-audio-upstream.h"
  23
  24 #include <linux/fs.h>
  25 #include <linux/errno.h>
  26 #include <linux/kernel.h>
  27 #include <linux/init.h>
  28 #include <linux/module.h>
  29 #include <linux/syscalls.h>
  30 #include <linux/file.h>
  31 #include <linux/fcntl.h>
  32 #include <linux/delay.h>
  33 #include <linux/slab.h>
  34 #include <linux/uaccess.h>
  35
  36 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
  37 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
  38 MODULE_LICENSE("GPL");
  39
  40 static int _intr_msk = FLD_AUD_SRC_RISCI1 | FLD_AUD_SRC_OF |
  41                         FLD_AUD_SRC_SYNC | FLD_AUD_SRC_OPC_ERR;
  42
  43 static int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
  44                                               const struct sram_channel *ch,
  45                                               unsigned int bpl, u32 risc)
  46 {
  47         unsigned int i, lines;
  48         u32 cdt;
  49
  50         if (ch->cmds_start == 0) {
  51                 cx_write(ch->ptr1_reg, 0);
  52                 cx_write(ch->ptr2_reg, 0);
  53                 cx_write(ch->cnt2_reg, 0);
  54                 cx_write(ch->cnt1_reg, 0);
  55                 return 0;
  56         }
  57
  58         bpl = (bpl + 7) & ~7;   /* alignment */
  59         cdt = ch->cdt;
  60         lines = ch->fifo_size / bpl;
  61
  62         if (lines > 3)
  63                 lines = 3;
  64
  65         BUG_ON(lines < 2);
  66
  67         /* write CDT */
  68         for (i = 0; i < lines; i++) {
  69                 cx_write(cdt + 16 * i, ch->fifo_start + bpl * i);
  70                 cx_write(cdt + 16 * i + 4, 0);
  71                 cx_write(cdt + 16 * i + 8, 0);
  72                 cx_write(cdt + 16 * i + 12, 0);
  73         }
  74
  75         /* write CMDS */
  76         cx_write(ch->cmds_start + 0, risc);
  77
  78         cx_write(ch->cmds_start + 4, 0);
  79         cx_write(ch->cmds_start + 8, cdt);
  80         cx_write(ch->cmds_start + 12, AUDIO_CDT_SIZE_QW);
  81         cx_write(ch->cmds_start + 16, ch->ctrl_start);
  82
  83         /* IQ size */
  84         cx_write(ch->cmds_start + 20, AUDIO_IQ_SIZE_DW);
  85
  86         for (i = 24; i < 80; i += 4)
  87                 cx_write(ch->cmds_start + i, 0);
  88
  89         /* fill registers */
  90         cx_write(ch->ptr1_reg, ch->fifo_start);
  91         cx_write(ch->ptr2_reg, cdt);
  92         cx_write(ch->cnt2_reg, AUDIO_CDT_SIZE_QW);
  93         cx_write(ch->cnt1_reg, AUDIO_CLUSTER_SIZE_QW - 1);
  94
  95         return 0;
  96 }
  97
  98 static __le32 *cx25821_risc_field_upstream_audio(struct cx25821_dev *dev,
  99                                                  __le32 *rp,
 100                                                  dma_addr_t databuf_phys_addr,
 101                                                  unsigned int bpl,
 102                                                  int fifo_enable)
 103 {
 104         unsigned int line;
 105         const struct sram_channel *sram_ch =
 106                 dev->channels[dev->_audio_upstream_channel].sram_channels;
 107         int offset = 0;
 108
 109         /* scan lines */
 110         for (line = 0; line < LINES_PER_AUDIO_BUFFER; line++) {
 111                 *(rp++) = cpu_to_le32(RISC_READ | RISC_SOL | RISC_EOL | bpl);
 112                 *(rp++) = cpu_to_le32(databuf_phys_addr + offset);
 113                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
 114
 115                 /* Check if we need to enable the FIFO
 116                  * after the first 3 lines.
 117                  * For the upstream audio channel,
 118                  * the risc engine will enable the FIFO */
 119                 if (fifo_enable && line == 2) {
 120                         *(rp++) = RISC_WRITECR;
 121                         *(rp++) = sram_ch->dma_ctl;
 122                         *(rp++) = sram_ch->fld_aud_fifo_en;
 123                         *(rp++) = 0x00000020;
 124                 }
 125
 126                 offset += AUDIO_LINE_SIZE;
 127         }
 128
 129         return rp;
 130 }
 131
 132 static int cx25821_risc_buffer_upstream_audio(struct cx25821_dev *dev,
 133                                        struct pci_dev *pci,
 134                                        unsigned int bpl, unsigned int lines)
 135 {
 136         __le32 *rp;
 137         int fifo_enable = 0;
 138         int frame = 0, i = 0;
 139         int frame_size = AUDIO_DATA_BUF_SZ;
 140         int databuf_offset = 0;
 141         int risc_flag = RISC_CNT_INC;
 142         dma_addr_t risc_phys_jump_addr;
 143
 144         /* Virtual address of Risc buffer program */
 145         rp = dev->_risc_virt_addr;
 146
 147         /* sync instruction */
 148         *(rp++) = cpu_to_le32(RISC_RESYNC | AUDIO_SYNC_LINE);
 149
 150         for (frame = 0; frame < NUM_AUDIO_FRAMES; frame++) {
 151                 databuf_offset = frame_size * frame;
 152
 153                 if (frame == 0) {
 154                         fifo_enable = 1;
 155                         risc_flag = RISC_CNT_RESET;
 156                 } else {
 157                         fifo_enable = 0;
 158                         risc_flag = RISC_CNT_INC;
 159                 }
 160
 161                 /* Calculate physical jump address */
 162                 if ((frame + 1) == NUM_AUDIO_FRAMES) {
 163                         risc_phys_jump_addr =
 164                             dev->_risc_phys_start_addr +
 165                             RISC_SYNC_INSTRUCTION_SIZE;
 166                 } else {
 167                         risc_phys_jump_addr =
 168                             dev->_risc_phys_start_addr +
 169                             RISC_SYNC_INSTRUCTION_SIZE +
 170                             AUDIO_RISC_DMA_BUF_SIZE * (frame + 1);
 171                 }
 172
 173                 rp = cx25821_risc_field_upstream_audio(dev, rp,
 174                                 dev->_audiodata_buf_phys_addr + databuf_offset,
 175                                 bpl, fifo_enable);
 176
 177                 if (USE_RISC_NOOP_AUDIO) {
 178                         for (i = 0; i < NUM_NO_OPS; i++)
 179                                 *(rp++) = cpu_to_le32(RISC_NOOP);
 180                 }
 181
 182                 /* Loop to (Nth)FrameRISC or to Start of Risc program &
 183                  * generate IRQ */
 184                 *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | risc_flag);
 185                 *(rp++) = cpu_to_le32(risc_phys_jump_addr);
 186                 *(rp++) = cpu_to_le32(0);
 187
 188                 /* Recalculate virtual address based on frame index */
 189                 rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE / 4 +
 190                         (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4);
 191         }
 192
 193         return 0;
 194 }
 195
 196 static void cx25821_free_memory_audio(struct cx25821_dev *dev)
 197 {
 198         if (dev->_risc_virt_addr) {
 199                 pci_free_consistent(dev->pci, dev->_audiorisc_size,
 200                                     dev->_risc_virt_addr, dev->_risc_phys_addr);
 201                 dev->_risc_virt_addr = NULL;
 202         }
 203
 204         if (dev->_audiodata_buf_virt_addr) {
 205                 pci_free_consistent(dev->pci, dev->_audiodata_buf_size,
 206                                     dev->_audiodata_buf_virt_addr,
 207                                     dev->_audiodata_buf_phys_addr);
 208                 dev->_audiodata_buf_virt_addr = NULL;
 209         }
 210 }
 211
 212 void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
 213 {
 214         const struct sram_channel *sram_ch =
 215                 dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels;
 216         u32 tmp = 0;
 217
 218         if (!dev->_audio_is_running) {
 219                 printk(KERN_DEBUG
 220                        pr_fmt("No audio file is currently running so return!\n"));
 221                 return;
 222         }
 223         /* Disable RISC interrupts */
 224         cx_write(sram_ch->int_msk, 0);
 225
 226         /* Turn OFF risc and fifo enable in AUD_DMA_CNTRL */
 227         tmp = cx_read(sram_ch->dma_ctl);
 228         cx_write(sram_ch->dma_ctl,
 229                  tmp & ~(sram_ch->fld_aud_fifo_en | sram_ch->fld_aud_risc_en));
 230
 231         /* Clear data buffer memory */
 232         if (dev->_audiodata_buf_virt_addr)
 233                 memset(dev->_audiodata_buf_virt_addr, 0,
 234                        dev->_audiodata_buf_size);
 235
 236         dev->_audio_is_running = 0;
 237         dev->_is_first_audio_frame = 0;
 238         dev->_audioframe_count = 0;
 239         dev->_audiofile_status = END_OF_FILE;
 240
 241         flush_work(&dev->_audio_work_entry);
 242
 243         kfree(dev->_audiofilename);
 244 }
 245
 246 void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev)
 247 {
 248         if (dev->_audio_is_running)
 249                 cx25821_stop_upstream_audio(dev);
 250
 251         cx25821_free_memory_audio(dev);
 252 }
 253
 254 static int cx25821_get_audio_data(struct cx25821_dev *dev,
 255                            const struct sram_channel *sram_ch)
 256 {
 257         struct file *file;
 258         int frame_index_temp = dev->_audioframe_index;
 259         int i = 0;
 260         int frame_size = AUDIO_DATA_BUF_SZ;
 261         int frame_offset = frame_size * frame_index_temp;
 262         char mybuf[AUDIO_LINE_SIZE];
 263         loff_t file_offset = dev->_audioframe_count * frame_size;
 264         char *p = NULL;
 265
 266         if (dev->_audiofile_status == END_OF_FILE)
 267                 return 0;
 268
 269         file = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0);
 270         if (IS_ERR(file)) {
 271                 pr_err("%s(): ERROR opening file(%s) with errno = %ld!\n",
 272                        __func__, dev->_audiofilename, -PTR_ERR(file));
 273                 return PTR_ERR(file);
 274         }
 275
 276         if (dev->_audiodata_buf_virt_addr)
 277                 p = (char *)dev->_audiodata_buf_virt_addr + frame_offset;
 278
 279         for (i = 0; i < dev->_audio_lines_count; i++) {
 280                 int n = kernel_read(file, mybuf, AUDIO_LINE_SIZE, &file_offset);
 281                 if (n < AUDIO_LINE_SIZE) {
 282                         pr_info("Done: exit %s() since no more bytes to read from Audio file\n",
 283                                 __func__);
 284                         dev->_audiofile_status = END_OF_FILE;
 285                         fput(file);
 286                         return 0;
 287                 }
 288                 dev->_audiofile_status = IN_PROGRESS;
 289                 if (p) {
 290                         memcpy(p, mybuf, n);
 291                         p += n;
 292                 }
 293         }
 294         dev->_audioframe_count++;
 295         fput(file);
 296
 297         return 0;
 298 }
 299
 300 static void cx25821_audioups_handler(struct work_struct *work)
 301 {
 302         struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
 303                         _audio_work_entry);
 304
 305         if (!dev) {
 306                 pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
 307                         __func__);
 308                 return;
 309         }
 310
 311         cx25821_get_audio_data(dev, dev->channels[dev->_audio_upstream_channel].
 312                         sram_channels);
 313 }
 314
 315 static int cx25821_openfile_audio(struct cx25821_dev *dev,
 316                            const struct sram_channel *sram_ch)
 317 {
 318         char *p = (void *)dev->_audiodata_buf_virt_addr;
 319         struct file *file;
 320         loff_t file_offset = 0;
 321         int i, j;
 322
 323         file = filp_open(dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0);
 324         if (IS_ERR(file)) {
 325                 pr_err("%s(): ERROR opening file(%s) with errno = %ld!\n",
 326                         __func__, dev->_audiofilename, PTR_ERR(file));
 327                 return PTR_ERR(file);
 328         }
 329
 330         for (j = 0; j < NUM_AUDIO_FRAMES; j++) {
 331                 for (i = 0; i < dev->_audio_lines_count; i++) {
 332                         char buf[AUDIO_LINE_SIZE];
 333                         loff_t offset = file_offset;
 334                         int n = kernel_read(file, buf, AUDIO_LINE_SIZE, &file_offset);
 335
 336                         if (n < AUDIO_LINE_SIZE) {
 337                                 pr_info("Done: exit %s() since no more bytes to read from Audio file\n",
 338                                         __func__);
 339                                 dev->_audiofile_status = END_OF_FILE;
 340                                 fput(file);
 341                                 return 0;
 342                         }
 343
 344                         if (p)
 345                                 memcpy(p + offset, buf, n);
 346                 }
 347                 dev->_audioframe_count++;
 348         }
 349         dev->_audiofile_status = IN_PROGRESS;
 350         fput(file);
 351         return 0;
 352 }
 353
 354 static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
 355                                                  const struct sram_channel *sram_ch,
 356                                                  int bpl)
 357 {
 358         int ret = 0;
 359         dma_addr_t dma_addr;
 360         dma_addr_t data_dma_addr;
 361
 362         cx25821_free_memory_audio(dev);
 363
 364         dev->_risc_virt_addr = pci_alloc_consistent(dev->pci,
 365                         dev->audio_upstream_riscbuf_size, &dma_addr);
 366         dev->_risc_virt_start_addr = dev->_risc_virt_addr;
 367         dev->_risc_phys_start_addr = dma_addr;
 368         dev->_risc_phys_addr = dma_addr;
 369         dev->_audiorisc_size = dev->audio_upstream_riscbuf_size;
 370
 371         if (!dev->_risc_virt_addr) {
 372                 printk(KERN_DEBUG
 373                         pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n"));
 374                 return -ENOMEM;
 375         }
 376         /* Clear out memory at address */
 377         memset(dev->_risc_virt_addr, 0, dev->_audiorisc_size);
 378
 379         /* For Audio Data buffer allocation */
 380         dev->_audiodata_buf_virt_addr = pci_alloc_consistent(dev->pci,
 381                         dev->audio_upstream_databuf_size, &data_dma_addr);
 382         dev->_audiodata_buf_phys_addr = data_dma_addr;
 383         dev->_audiodata_buf_size = dev->audio_upstream_databuf_size;
 384
 385         if (!dev->_audiodata_buf_virt_addr) {
 386                 printk(KERN_DEBUG
 387                         pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n"));
 388                 return -ENOMEM;
 389         }
 390         /* Clear out memory at address */
 391         memset(dev->_audiodata_buf_virt_addr, 0, dev->_audiodata_buf_size);
 392
 393         ret = cx25821_openfile_audio(dev, sram_ch);
 394         if (ret < 0)
 395                 return ret;
 396
 397         /* Creating RISC programs */
 398         ret = cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl,
 399                                                 dev->_audio_lines_count);
 400         if (ret < 0) {
 401                 printk(KERN_DEBUG
 402                         pr_fmt("ERROR creating audio upstream RISC programs!\n"));
 403                 goto error;
 404         }
 405
 406         return 0;
 407
 408 error:
 409         return ret;
 410 }
 411
 412 static int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num,
 413                                u32 status)
 414 {
 415         int i = 0;
 416         u32 int_msk_tmp;
 417         const struct sram_channel *channel = dev->channels[chan_num].sram_channels;
 418         dma_addr_t risc_phys_jump_addr;
 419         __le32 *rp;
 420
 421         if (status & FLD_AUD_SRC_RISCI1) {
 422                 /* Get interrupt_index of the program that interrupted */
 423                 u32 prog_cnt = cx_read(channel->gpcnt);
 424
 425                 /* Since we've identified our IRQ, clear our bits from the
 426                  * interrupt mask and interrupt status registers */
 427                 cx_write(channel->int_msk, 0);
 428                 cx_write(channel->int_stat, cx_read(channel->int_stat));
 429
 430                 spin_lock(&dev->slock);
 431
 432                 while (prog_cnt != dev->_last_index_irq) {
 433                         /* Update _last_index_irq */
 434                         if (dev->_last_index_irq < (NUMBER_OF_PROGRAMS - 1))
 435                                 dev->_last_index_irq++;
 436                         else
 437                                 dev->_last_index_irq = 0;
 438
 439                         dev->_audioframe_index = dev->_last_index_irq;
 440
 441                         schedule_work(&dev->_audio_work_entry);
 442                 }
 443
 444                 if (dev->_is_first_audio_frame) {
 445                         dev->_is_first_audio_frame = 0;
 446
 447                         if (dev->_risc_virt_start_addr != NULL) {
 448                                 risc_phys_jump_addr =
 449                                         dev->_risc_phys_start_addr +
 450                                         RISC_SYNC_INSTRUCTION_SIZE +
 451                                         AUDIO_RISC_DMA_BUF_SIZE;
 452
 453                                 rp = cx25821_risc_field_upstream_audio(dev,
 454                                                 dev->_risc_virt_start_addr + 1,
 455                                                 dev->_audiodata_buf_phys_addr,
 456                                                 AUDIO_LINE_SIZE, FIFO_DISABLE);
 457
 458                                 if (USE_RISC_NOOP_AUDIO) {
 459                                         for (i = 0; i < NUM_NO_OPS; i++) {
 460                                                 *(rp++) =
 461                                                     cpu_to_le32(RISC_NOOP);
 462                                         }
 463                                 }
 464                                 /* Jump to 2nd Audio Frame */
 465                                 *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 |
 466                                                 RISC_CNT_RESET);
 467                                 *(rp++) = cpu_to_le32(risc_phys_jump_addr);
 468                                 *(rp++) = cpu_to_le32(0);
 469                         }
 470                 }
 471
 472                 spin_unlock(&dev->slock);
 473         } else {
 474                 if (status & FLD_AUD_SRC_OF)
 475                         pr_warn("%s(): Audio Received Overflow Error Interrupt!\n",
 476                                 __func__);
 477
 478                 if (status & FLD_AUD_SRC_SYNC)
 479                         pr_warn("%s(): Audio Received Sync Error Interrupt!\n",
 480                                 __func__);
 481
 482                 if (status & FLD_AUD_SRC_OPC_ERR)
 483                         pr_warn("%s(): Audio Received OpCode Error Interrupt!\n",
 484                                 __func__);
 485
 486                 /* Read and write back the interrupt status register to clear
 487                  * our bits */
 488                 cx_write(channel->int_stat, cx_read(channel->int_stat));
 489         }
 490
 491         if (dev->_audiofile_status == END_OF_FILE) {
 492                 pr_warn("EOF Channel Audio Framecount = %d\n",
 493                         dev->_audioframe_count);
 494                 return -1;
 495         }
 496         /* ElSE, set the interrupt mask register, re-enable irq. */
 497         int_msk_tmp = cx_read(channel->int_msk);
 498         cx_write(channel->int_msk, int_msk_tmp |= _intr_msk);
 499
 500         return 0;
 501 }
 502
 503 static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
 504 {
 505         struct cx25821_dev *dev = dev_id;
 506         u32 audio_status;
 507         int handled = 0;
 508         const struct sram_channel *sram_ch;
 509
 510         if (!dev)
 511                 return -1;
 512
 513         sram_ch = dev->channels[dev->_audio_upstream_channel].sram_channels;
 514
 515         audio_status = cx_read(sram_ch->int_stat);
 516
 517         /* Only deal with our interrupt */
 518         if (audio_status) {
 519                 handled = cx25821_audio_upstream_irq(dev,
 520                                 dev->_audio_upstream_channel, audio_status);
 521         }
 522
 523         if (handled < 0)
 524                 cx25821_stop_upstream_audio(dev);
 525         else
 526                 handled += handled;
 527
 528         return IRQ_RETVAL(handled);
 529 }
 530
 531 static void cx25821_wait_fifo_enable(struct cx25821_dev *dev,
 532                                      const struct sram_channel *sram_ch)
 533 {
 534         int count = 0;
 535         u32 tmp;
 536
 537         do {
 538                 /* Wait 10 microsecond before checking to see if the FIFO is
 539                  * turned ON. */
 540                 udelay(10);
 541
 542                 tmp = cx_read(sram_ch->dma_ctl);
 543
 544                 /* 10 millisecond timeout */
 545                 if (count++ > 1000) {
 546                         pr_err("ERROR: %s() fifo is NOT turned on. Timeout!\n",
 547                                 __func__);
 548                         return;
 549                 }
 550
 551         } while (!(tmp & sram_ch->fld_aud_fifo_en));
 552
 553 }
 554
 555 static int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
 556                                             const struct sram_channel *sram_ch)
 557 {
 558         u32 tmp = 0;
 559         int err = 0;
 560
 561         /* Set the physical start address of the RISC program in the initial
 562          * program counter(IPC) member of the CMDS. */
 563         cx_write(sram_ch->cmds_start + 0, dev->_risc_phys_addr);
 564         /* Risc IPC High 64 bits 63-32 */
 565         cx_write(sram_ch->cmds_start + 4, 0);
 566
 567         /* reset counter */
 568         cx_write(sram_ch->gpcnt_ctl, 3);
 569
 570         /* Set the line length       (It looks like we do not need to set the
 571          * line length) */
 572         cx_write(sram_ch->aud_length, AUDIO_LINE_SIZE & FLD_AUD_DST_LN_LNGTH);
 573
 574         /* Set the input mode to 16-bit */
 575         tmp = cx_read(sram_ch->aud_cfg);
 576         tmp |= FLD_AUD_SRC_ENABLE | FLD_AUD_DST_PK_MODE | FLD_AUD_CLK_ENABLE |
 577                 FLD_AUD_MASTER_MODE | FLD_AUD_CLK_SELECT_PLL_D |
 578                 FLD_AUD_SONY_MODE;
 579         cx_write(sram_ch->aud_cfg, tmp);
 580
 581         /* Read and write back the interrupt status register to clear it */
 582         tmp = cx_read(sram_ch->int_stat);
 583         cx_write(sram_ch->int_stat, tmp);
 584
 585         /* Clear our bits from the interrupt status register. */
 586         cx_write(sram_ch->int_stat, _intr_msk);
 587
 588         /* Set the interrupt mask register, enable irq. */
 589         cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | (1 << sram_ch->irq_bit));
 590         tmp = cx_read(sram_ch->int_msk);
 591         cx_write(sram_ch->int_msk, tmp |= _intr_msk);
 592
 593         err = request_irq(dev->pci->irq, cx25821_upstream_irq_audio,
 594                         IRQF_SHARED, dev->name, dev);
 595         if (err < 0) {
 596                 pr_err("%s: can't get upstream IRQ %d\n", dev->name,
 597                                 dev->pci->irq);
 598                 goto fail_irq;
 599         }
 600
 601         /* Start the DMA  engine */
 602         tmp = cx_read(sram_ch->dma_ctl);
 603         cx_set(sram_ch->dma_ctl, tmp | sram_ch->fld_aud_risc_en);
 604
 605         dev->_audio_is_running = 1;
 606         dev->_is_first_audio_frame = 1;
 607
 608         /* The fifo_en bit turns on by the first Risc program */
 609         cx25821_wait_fifo_enable(dev, sram_ch);
 610
 611         return 0;
 612
 613 fail_irq:
 614         cx25821_dev_unregister(dev);
 615         return err;
 616 }
 617
 618 int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
 619 {
 620         const struct sram_channel *sram_ch;
 621         int err = 0;
 622
 623         if (dev->_audio_is_running) {
 624                 pr_warn("Audio Channel is still running so return!\n");
 625                 return 0;
 626         }
 627
 628         dev->_audio_upstream_channel = channel_select;
 629         sram_ch = dev->channels[channel_select].sram_channels;
 630
 631         /* Work queue */
 632         INIT_WORK(&dev->_audio_work_entry, cx25821_audioups_handler);
 633
 634         dev->_last_index_irq = 0;
 635         dev->_audio_is_running = 0;
 636         dev->_audioframe_count = 0;
 637         dev->_audiofile_status = RESET_STATUS;
 638         dev->_audio_lines_count = LINES_PER_AUDIO_BUFFER;
 639         _line_size = AUDIO_LINE_SIZE;
 640
 641         if ((dev->input_audiofilename) &&
 642             (strcmp(dev->input_audiofilename, "") != 0))
 643                 dev->_audiofilename = kstrdup(dev->input_audiofilename,
 644                                               GFP_KERNEL);
 645         else
 646                 dev->_audiofilename = kstrdup(_defaultAudioName,
 647                                               GFP_KERNEL);
 648
 649         if (!dev->_audiofilename) {
 650                 err = -ENOMEM;
 651                 goto error;
 652         }
 653
 654         cx25821_sram_channel_setup_upstream_audio(dev, sram_ch,
 655                                                   _line_size, 0);
 656
 657         dev->audio_upstream_riscbuf_size =
 658                 AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS +
 659                 RISC_SYNC_INSTRUCTION_SIZE;
 660         dev->audio_upstream_databuf_size = AUDIO_DATA_BUF_SZ * NUM_AUDIO_PROGS;
 661
 662         /* Allocating buffers and prepare RISC program */
 663         err = cx25821_audio_upstream_buffer_prepare(dev, sram_ch,
 664                                                         _line_size);
 665         if (err < 0) {
 666                 pr_err("%s: Failed to set up Audio upstream buffers!\n",
 667                         dev->name);
 668                 goto error;
 669         }
 670         /* Start RISC engine */
 671         cx25821_start_audio_dma_upstream(dev, sram_ch);
 672
 673         return 0;
 674
 675 error:
 676         cx25821_dev_unregister(dev);
 677
 678         return err;
 679 }