2 * @file me1400_ext_irq.c
4 * @brief ME-1400 external interrupt subdevice instance.
5 * @note Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
6 * @author Guenter Gebhardt
7 * @author Krzysztof Gantzke (k.gantzke@meilhaus.de)
11 * Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
13 * This file is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 #include <linux/module.h>
37 #include <linux/slab.h>
38 #include <linux/spinlock.h>
40 #include <linux/types.h>
41 #include <linux/interrupt.h>
43 #include "medefines.h"
44 #include "meinternal.h"
49 #include "me1400_ext_irq.h"
50 #include "me1400_ext_irq_reg.h"
55 #define ME1400_EXT_IRQ_MAGIC_NUMBER 0x1401 /**< The magic number of the class structure. */
56 #define ME1400_EXT_IRQ_NUMBER_CHANNELS 1 /**< One channel per counter. */
62 static int me1400_ext_irq_io_irq_start(struct me_subdevice *subdevice,
66 int irq_edge, int irq_arg, int flags)
68 me1400_ext_irq_subdevice_t *instance;
69 unsigned long cpu_flags;
72 PDEBUG("executed.\n");
74 instance = (me1400_ext_irq_subdevice_t *) subdevice;
76 if (flags & ~ME_IO_IRQ_START_DIO_BIT) {
77 PERROR("Invalid flag specified.\n");
78 return ME_ERRNO_INVALID_FLAGS;
82 PERROR("Invalid channel.\n");
83 return ME_ERRNO_INVALID_CHANNEL;
86 if (irq_source != ME_IRQ_SOURCE_DIO_LINE) {
87 PERROR("Invalid irq source.\n");
88 return ME_ERRNO_INVALID_IRQ_SOURCE;
91 if (irq_edge != ME_IRQ_EDGE_RISING) {
92 PERROR("Invalid irq edge.\n");
93 return ME_ERRNO_INVALID_IRQ_EDGE;
98 spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
100 spin_lock(instance->clk_src_reg_lock);
101 // // Enable IRQ on PLX
102 // tmp = inb(instance->plx_intcs_reg) | (PLX_LOCAL_INT1_EN | PLX_LOCAL_INT1_POL | PLX_PCI_INT_EN);
103 // outb(tmp, instance->plx_intcs_reg);
104 // PDEBUG_REG("ctrl_reg outb(PLX:0x%lX)=0x%x\n", instance->plx_intcs_reg, tmp);
107 switch (instance->device_id) {
108 case PCI_DEVICE_ID_MEILHAUS_ME140C:
109 case PCI_DEVICE_ID_MEILHAUS_ME140D:
110 tmp = inb(instance->ctrl_reg);
111 tmp |= ME1400CD_EXT_IRQ_CLK_EN;
112 outb(tmp, instance->ctrl_reg);
113 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
115 instance->ctrl_reg - instance->reg_base, tmp);
119 outb(ME1400AB_EXT_IRQ_IRQ_EN, instance->ctrl_reg);
120 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
122 instance->ctrl_reg - instance->reg_base,
123 ME1400AB_EXT_IRQ_IRQ_EN);
126 spin_unlock(instance->clk_src_reg_lock);
128 spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
132 return ME_ERRNO_SUCCESS;
135 static int me1400_ext_irq_io_irq_wait(struct me_subdevice *subdevice,
139 int *value, int time_out, int flags)
141 me1400_ext_irq_subdevice_t *instance;
142 unsigned long cpu_flags;
144 int err = ME_ERRNO_SUCCESS;
146 PDEBUG("executed.\n");
148 instance = (me1400_ext_irq_subdevice_t *) subdevice;
151 PERROR("Invalid flag specified.\n");
152 return ME_ERRNO_INVALID_FLAGS;
156 PERROR("Invalid channel.\n");
157 return ME_ERRNO_INVALID_CHANNEL;
161 PERROR("Invalid time out.\n");
162 return ME_ERRNO_INVALID_TIMEOUT;
166 /* Convert to ticks */
167 t = (time_out * HZ) / 1000;
175 if (instance->rised <= 0) {
178 t = wait_event_interruptible_timeout(instance->
184 PERROR("Wait on interrupt timed out.\n");
185 err = ME_ERRNO_TIMEOUT;
188 wait_event_interruptible(instance->wait_queue,
189 (instance->rised != 0));
192 if (instance->rised < 0) {
193 PERROR("Wait on interrupt aborted by user.\n");
194 err = ME_ERRNO_CANCELLED;
198 if (signal_pending(current)) {
199 PERROR("Wait on interrupt aborted by signal.\n");
200 err = ME_ERRNO_SIGNAL;
203 spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
205 *irq_count = instance->n;
207 spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
214 static int me1400_ext_irq_io_irq_stop(struct me_subdevice *subdevice,
216 int channel, int flags)
218 me1400_ext_irq_subdevice_t *instance;
219 unsigned long cpu_flags;
221 int err = ME_ERRNO_SUCCESS;
223 PDEBUG("executed.\n");
225 instance = (me1400_ext_irq_subdevice_t *) subdevice;
228 PERROR("Invalid flag specified.\n");
229 return ME_ERRNO_INVALID_FLAGS;
233 PERROR("Invalid channel.\n");
234 return ME_ERRNO_INVALID_CHANNEL;
239 spin_lock_irqsave(&instance->subdevice_lock, cpu_flags);
240 spin_lock(instance->clk_src_reg_lock);
241 // // Disable IRQ on PLX
242 // tmp = inb(instance->plx_intcs_reg) & ( ~(PLX_LOCAL_INT1_EN | PLX_LOCAL_INT1_POL | PLX_PCI_INT_EN));
243 // outb(tmp, instance->plx_intcs_reg);
244 // PDEBUG_REG("ctrl_reg outb(PLX:0x%lX)=0x%x\n", instance->plx_intcs_reg, tmp);
246 switch (instance->device_id) {
247 case PCI_DEVICE_ID_MEILHAUS_ME140C:
248 case PCI_DEVICE_ID_MEILHAUS_ME140D:
249 tmp = inb(instance->ctrl_reg);
250 tmp &= ~ME1400CD_EXT_IRQ_CLK_EN;
251 outb(tmp, instance->ctrl_reg);
252 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
254 instance->ctrl_reg - instance->reg_base, tmp);
259 outb(0x00, instance->ctrl_reg);
260 PDEBUG_REG("ctrl_reg outl(0x%lX+0x%lX)=0x%x\n",
262 instance->ctrl_reg - instance->reg_base, 0x00);
265 spin_unlock(instance->clk_src_reg_lock);
266 instance->rised = -1;
267 spin_unlock_irqrestore(&instance->subdevice_lock, cpu_flags);
268 wake_up_interruptible_all(&instance->wait_queue);
275 static int me1400_ext_irq_io_reset_subdevice(struct me_subdevice *subdevice,
276 struct file *filep, int flags)
278 me1400_ext_irq_subdevice_t *instance =
279 (me1400_ext_irq_subdevice_t *) subdevice;
281 PDEBUG("executed.\n");
284 PERROR("Invalid flag specified.\n");
285 return ME_ERRNO_INVALID_FLAGS;
289 return me1400_ext_irq_io_irq_stop(subdevice, filep, 0, flags);
292 static int me1400_ext_irq_query_number_channels(struct me_subdevice *subdevice,
295 PDEBUG("executed.\n");
296 *number = ME1400_EXT_IRQ_NUMBER_CHANNELS;
297 return ME_ERRNO_SUCCESS;
300 static int me1400_ext_irq_query_subdevice_type(struct me_subdevice *subdevice,
301 int *type, int *subtype)
303 PDEBUG("executed.\n");
304 *type = ME_TYPE_EXT_IRQ;
305 *subtype = ME_SUBTYPE_SINGLE;
306 return ME_ERRNO_SUCCESS;
309 static int me1400_ext_irq_query_subdevice_caps(struct me_subdevice *subdevice,
312 PDEBUG("executed.\n");
313 *caps = ME_CAPS_EXT_IRQ_EDGE_RISING;
314 return ME_ERRNO_SUCCESS;
317 static int me1400_ext_irq_query_subdevice_caps_args(struct me_subdevice
319 int *args, int count)
321 PDEBUG("executed.\n");
322 return ME_ERRNO_NOT_SUPPORTED;
325 static irqreturn_t me1400_ext_irq_isr(int irq, void *dev_id)
327 me1400_ext_irq_subdevice_t *instance;
331 instance = (me1400_ext_irq_subdevice_t *) dev_id;
333 if (irq != instance->irq) {
334 PERROR("Incorrect interrupt num: %d.\n", irq);
338 spin_lock(&instance->subdevice_lock);
339 status = inl(instance->plx_intcs_reg);
340 // if (!((status & PLX_LOCAL_INT1_STATE) && (status & PLX_LOCAL_INT1_EN) && (status & PLX_PCI_INT_EN)))
342 (PLX_LOCAL_INT1_STATE | PLX_LOCAL_INT1_EN | PLX_PCI_INT_EN)) !=
343 (PLX_LOCAL_INT1_STATE | PLX_LOCAL_INT1_EN | PLX_PCI_INT_EN)) {
344 spin_unlock(&instance->subdevice_lock);
345 PINFO("%ld Shared interrupt. %s(): irq_status_reg=0x%04X\n",
346 jiffies, __func__, status);
350 inl(instance->ctrl_reg);
352 PDEBUG("executed.\n");
357 switch (instance->device_id) {
359 case PCI_DEVICE_ID_MEILHAUS_ME140C:
360 case PCI_DEVICE_ID_MEILHAUS_ME140D:
361 spin_lock(instance->clk_src_reg_lock);
362 tmp = inb(instance->ctrl_reg);
363 tmp &= ~ME1400CD_EXT_IRQ_CLK_EN;
364 outb(tmp, instance->ctrl_reg);
365 PDEBUG_REG("ctrl_reg outb(0x%lX+0x%lX)=0x%x\n",
367 instance->ctrl_reg - instance->reg_base, tmp);
368 tmp |= ME1400CD_EXT_IRQ_CLK_EN;
369 outb(tmp, instance->ctrl_reg);
370 PDEBUG_REG("ctrl_reg outb(0x%lX+0x%lX)=0x%x\n",
372 instance->ctrl_reg - instance->reg_base, tmp);
373 spin_unlock(instance->clk_src_reg_lock);
378 outb(0, instance->ctrl_reg);
379 PDEBUG_REG("ctrl_reg outb(0x%lX+0x%lX)=0x%x\n",
381 instance->ctrl_reg - instance->reg_base, 0);
382 outb(ME1400AB_EXT_IRQ_IRQ_EN, instance->ctrl_reg);
383 PDEBUG_REG("ctrl_reg outb(0x%lX+0x%lX)=0x%x\n",
385 instance->ctrl_reg - instance->reg_base,
386 ME1400AB_EXT_IRQ_IRQ_EN);
390 spin_unlock(&instance->subdevice_lock);
391 wake_up_interruptible_all(&instance->wait_queue);
396 static void me1400_ext_irq_destructor(struct me_subdevice *subdevice)
398 me1400_ext_irq_subdevice_t *instance;
401 PDEBUG("executed.\n");
403 instance = (me1400_ext_irq_subdevice_t *) subdevice;
405 // Disable IRQ on PLX
408 plx_intcs_reg) & (~(PLX_LOCAL_INT1_EN | PLX_LOCAL_INT1_POL |
410 outb(tmp, instance->plx_intcs_reg);
411 PDEBUG_REG("ctrl_reg outb(plx:0x%lX)=0x%x\n", instance->plx_intcs_reg,
414 free_irq(instance->irq, (void *)instance);
415 me_subdevice_deinit(&instance->base);
419 me1400_ext_irq_subdevice_t *me1400_ext_irq_constructor(uint32_t device_id,
420 uint32_t plx_reg_base,
421 uint32_t me1400_reg_base,
426 me1400_ext_irq_subdevice_t *subdevice;
430 PDEBUG("executed.\n");
432 /* Allocate memory for subdevice instance */
433 subdevice = kmalloc(sizeof(me1400_ext_irq_subdevice_t), GFP_KERNEL);
436 PERROR("Cannot get memory for 1400_ext_irq instance.\n");
440 memset(subdevice, 0, sizeof(me1400_ext_irq_subdevice_t));
442 /* Initialize subdevice base class */
443 err = me_subdevice_init(&subdevice->base);
446 PERROR("Cannot initialize subdevice base class instance.\n");
450 // Initialize spin locks.
451 spin_lock_init(&subdevice->subdevice_lock);
452 subdevice->clk_src_reg_lock = clk_src_reg_lock;
454 /* Initialize wait queue */
455 init_waitqueue_head(&subdevice->wait_queue);
457 subdevice->irq = irq;
459 err = request_irq(irq, me1400_ext_irq_isr,
460 IRQF_DISABLED | IRQF_SHARED,
461 ME1400_NAME, (void *)subdevice);
464 PERROR("Can't get irq.\n");
465 me_subdevice_deinit(&subdevice->base);
469 PINFO("Registered irq=%d.\n", subdevice->irq);
471 /* Initialize registers */
472 subdevice->plx_intcs_reg = plx_reg_base + PLX_INTCSR_REG;
473 subdevice->ctrl_reg = me1400_reg_base + ME1400AB_EXT_IRQ_CTRL_REG;
474 #ifdef MEDEBUG_DEBUG_REG
475 subdevice->reg_base = me1400_reg_base;
481 plx_intcs_reg) | (PLX_LOCAL_INT1_EN | PLX_LOCAL_INT1_POL |
483 outb(tmp, subdevice->plx_intcs_reg);
484 PDEBUG_REG("ctrl_reg outb(Pplx:0x%lX)=0x%x\n", subdevice->plx_intcs_reg,
487 /* Initialize the subdevice methods */
488 subdevice->base.me_subdevice_io_irq_start = me1400_ext_irq_io_irq_start;
489 subdevice->base.me_subdevice_io_irq_wait = me1400_ext_irq_io_irq_wait;
490 subdevice->base.me_subdevice_io_irq_stop = me1400_ext_irq_io_irq_stop;
491 subdevice->base.me_subdevice_io_reset_subdevice =
492 me1400_ext_irq_io_reset_subdevice;
493 subdevice->base.me_subdevice_query_number_channels =
494 me1400_ext_irq_query_number_channels;
495 subdevice->base.me_subdevice_query_subdevice_type =
496 me1400_ext_irq_query_subdevice_type;
497 subdevice->base.me_subdevice_query_subdevice_caps =
498 me1400_ext_irq_query_subdevice_caps;
499 subdevice->base.me_subdevice_query_subdevice_caps_args =
500 me1400_ext_irq_query_subdevice_caps_args;
501 subdevice->base.me_subdevice_destructor = me1400_ext_irq_destructor;
503 subdevice->rised = 0;