git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/cx18/cx18-irq.c

   1 /*
   2  *  cx18 interrupt handling
   3  *
   4  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19  *  02111-1307  USA
  20  */
  21
  22 #include "cx18-driver.h"
  23 #include "cx18-io.h"
  24 #include "cx18-firmware.h"
  25 #include "cx18-fileops.h"
  26 #include "cx18-queue.h"
  27 #include "cx18-irq.h"
  28 #include "cx18-ioctl.h"
  29 #include "cx18-mailbox.h"
  30 #include "cx18-vbi.h"
  31 #include "cx18-scb.h"
  32 #include "cx18-dvb.h"
  33
  34 void cx18_work_handler(struct work_struct *work)
  35 {
  36         struct cx18 *cx = container_of(work, struct cx18, work);
  37         if (test_and_clear_bit(CX18_F_I_WORK_INITED, &cx->i_flags)) {
  38                 struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
  39                 /* This thread must use the FIFO scheduler as it
  40                  * is realtime sensitive. */
  41                 sched_setscheduler(current, SCHED_FIFO, &param);
  42         }
  43         if (test_and_clear_bit(CX18_F_I_WORK_HANDLER_DVB, &cx->i_flags))
  44                 cx18_dvb_work_handler(cx);
  45 }
  46
  47 static void epu_dma_done(struct cx18 *cx, struct cx18_mailbox *mb)
  48 {
  49         u32 handle = mb->args[0];
  50         struct cx18_stream *s = NULL;
  51         struct cx18_buffer *buf;
  52         u32 off;
  53         int i;
  54         int id;
  55
  56         for (i = 0; i < CX18_MAX_STREAMS; i++) {
  57                 s = &cx->streams[i];
  58                 if ((handle == s->handle) && (s->dvb.enabled))
  59                         break;
  60                 if (s->v4l2dev && handle == s->handle)
  61                         break;
  62         }
  63         if (i == CX18_MAX_STREAMS) {
  64                 CX18_WARN("Got DMA done notification for unknown/inactive"
  65                           " handle %d\n", handle);
  66                 mb->error = CXERR_NOT_OPEN;
  67                 mb->cmd = 0;
  68                 cx18_mb_ack(cx, mb);
  69                 return;
  70         }
  71
  72         off = mb->args[1];
  73         if (mb->args[2] != 1)
  74                 CX18_WARN("Ack struct = %d for %s\n",
  75                         mb->args[2], s->name);
  76         id = cx18_read_enc(cx, off);
  77         buf = cx18_queue_get_buf_irq(s, id, cx18_read_enc(cx, off + 4));
  78         CX18_DEBUG_HI_DMA("DMA DONE for %s (buffer %d)\n", s->name, id);
  79         if (buf) {
  80                 cx18_buf_sync_for_cpu(s, buf);
  81                 if (s->type == CX18_ENC_STREAM_TYPE_TS && s->dvb.enabled) {
  82                         CX18_DEBUG_HI_DMA("TS recv bytesused = %d\n",
  83                                         buf->bytesused);
  84
  85                         set_bit(CX18_F_I_WORK_HANDLER_DVB, &cx->i_flags);
  86                         set_bit(CX18_F_I_HAVE_WORK, &cx->i_flags);
  87                 } else
  88                         set_bit(CX18_F_B_NEED_BUF_SWAP, &buf->b_flags);
  89         } else {
  90                 CX18_WARN("Could not find buf %d for stream %s\n",
  91                                 cx18_read_enc(cx, off), s->name);
  92         }
  93         mb->error = 0;
  94         mb->cmd = 0;
  95         cx18_mb_ack(cx, mb);
  96         wake_up(&cx->dma_waitq);
  97         if (s->id != -1)
  98                 wake_up(&s->waitq);
  99 }
 100
 101 static void epu_debug(struct cx18 *cx, struct cx18_mailbox *mb)
 102 {
 103         char str[256] = { 0 };
 104         char *p;
 105
 106         if (mb->args[1]) {
 107                 cx18_setup_page(cx, mb->args[1]);
 108                 cx18_memcpy_fromio(cx, str, cx->enc_mem + mb->args[1], 252);
 109                 str[252] = 0;
 110         }
 111         cx18_mb_ack(cx, mb);
 112         CX18_DEBUG_INFO("%x %s\n", mb->args[0], str);
 113         p = strchr(str, '.');
 114         if (!test_bit(CX18_F_I_LOADED_FW, &cx->i_flags) && p && p > str)
 115                 CX18_INFO("FW version: %s\n", p - 1);
 116 }
 117
 118 static void epu_cmd(struct cx18 *cx, u32 sw1)
 119 {
 120         struct cx18_mailbox mb;
 121
 122         if (sw1 & IRQ_CPU_TO_EPU) {
 123                 cx18_memcpy_fromio(cx, &mb, &cx->scb->cpu2epu_mb, sizeof(mb));
 124                 mb.error = 0;
 125
 126                 switch (mb.cmd) {
 127                 case CX18_EPU_DMA_DONE:
 128                         epu_dma_done(cx, &mb);
 129                         break;
 130                 case CX18_EPU_DEBUG:
 131                         epu_debug(cx, &mb);
 132                         break;
 133                 default:
 134                         CX18_WARN("Unknown CPU_TO_EPU mailbox command %#08x\n",
 135                                   mb.cmd);
 136                         break;
 137                 }
 138         }
 139
 140         if (sw1 & IRQ_APU_TO_EPU) {
 141                 cx18_memcpy_fromio(cx, &mb, &cx->scb->apu2epu_mb, sizeof(mb));
 142                 CX18_WARN("Unknown APU_TO_EPU mailbox command %#08x\n", mb.cmd);
 143         }
 144
 145         if (sw1 & IRQ_HPU_TO_EPU) {
 146                 cx18_memcpy_fromio(cx, &mb, &cx->scb->hpu2epu_mb, sizeof(mb));
 147                 CX18_WARN("Unknown HPU_TO_EPU mailbox command %#08x\n", mb.cmd);
 148         }
 149 }
 150
 151 static void xpu_ack(struct cx18 *cx, u32 sw2)
 152 {
 153         if (sw2 & IRQ_CPU_TO_EPU_ACK)
 154                 wake_up(&cx->mb_cpu_waitq);
 155         if (sw2 & IRQ_APU_TO_EPU_ACK)
 156                 wake_up(&cx->mb_apu_waitq);
 157         if (sw2 & IRQ_HPU_TO_EPU_ACK)
 158                 wake_up(&cx->mb_hpu_waitq);
 159 }
 160
 161 irqreturn_t cx18_irq_handler(int irq, void *dev_id)
 162 {
 163         struct cx18 *cx = (struct cx18 *)dev_id;
 164         u32 sw1, sw1_mask;
 165         u32 sw2, sw2_mask;
 166         u32 hw2, hw2_mask;
 167
 168         sw1_mask = cx18_read_reg(cx, SW1_INT_ENABLE_PCI);
 169         sw1 = cx18_read_reg(cx, SW1_INT_STATUS) & sw1_mask;
 170         sw2_mask = cx18_read_reg(cx, SW2_INT_ENABLE_PCI);
 171         sw2 = cx18_read_reg(cx, SW2_INT_STATUS) & sw2_mask;
 172         hw2_mask = cx18_read_reg(cx, HW2_INT_MASK5_PCI);
 173         hw2 = cx18_read_reg(cx, HW2_INT_CLR_STATUS) & hw2_mask;
 174
 175         if (sw1)
 176                 cx18_write_reg_expect(cx, sw1, SW1_INT_STATUS, ~sw1, sw1);
 177         if (sw2)
 178                 cx18_write_reg_expect(cx, sw2, SW2_INT_STATUS, ~sw2, sw2);
 179         if (hw2)
 180                 cx18_write_reg_expect(cx, hw2, HW2_INT_CLR_STATUS, ~hw2, hw2);
 181
 182         if (sw1 || sw2 || hw2)
 183                 CX18_DEBUG_HI_IRQ("SW1: %x  SW2: %x  HW2: %x\n", sw1, sw2, hw2);
 184
 185         /* To do: interrupt-based I2C handling
 186         if (hw2 & (HW2_I2C1_INT|HW2_I2C2_INT)) {
 187         }
 188         */
 189
 190         if (sw2)
 191                 xpu_ack(cx, sw2);
 192
 193         if (sw1)
 194                 epu_cmd(cx, sw1);
 195
 196         if (test_and_clear_bit(CX18_F_I_HAVE_WORK, &cx->i_flags))
 197                 queue_work(cx->work_queue, &cx->work);
 198
 199         return (sw1 || sw2 || hw2) ? IRQ_HANDLED : IRQ_NONE;
 200 }