Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-01-01 07:42:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

staging: comedi: cb_pcidas64: remove DEBUG_PRINT

Browse Source 
The DEBUG_PRINT macro in this driver is used to output development
debug tracing messages. These messages are just added noise. Remove
them.

Signed-off-by: H Hartley Sweeten <hsweeten@visionengravers.com>
Reviewed-by: Ian Abbott <abbotti@mev.co.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
H Hartley Sweeten 2013-11-26 10:21:18 -07:00 committed by Greg Kroah-Hartman
parent 096669a830
commit 220edb9166
1 changed files with 3 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
drivers/staging/comedi/drivers/cb_pcidas64.c
View File

@ -94,15 +94,6 @@ TODO:
#include "plx9080.h" #include "plx9080.h"
#include "comedi_fc.h" #include "comedi_fc.h"
#undef PCIDAS64_DEBUG /* disable debugging code */
/* #define PCIDAS64_DEBUG enable debugging code */
#ifdef PCIDAS64_DEBUG
#define DEBUG_PRINT(format, args...) pr_debug(format, ## args)
#else
#define DEBUG_PRINT(format, args...) no_printk(format, ## args)
#endif
#define TIMER_BASE 25 /* 40MHz master clock */ #define TIMER_BASE 25 /* 40MHz master clock */
/* 100kHz 'prescaled' clock for slow acquisition, /* 100kHz 'prescaled' clock for slow acquisition,
* maybe I'll support this someday */ * maybe I'll support this someday */
@ -1252,8 +1243,6 @@ static void disable_ai_interrupts(struct comedi_device *dev)
writew(devpriv->intr_enable_bits, writew(devpriv->intr_enable_bits,
devpriv->main_iobase + INTR_ENABLE_REG); devpriv->main_iobase + INTR_ENABLE_REG);
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
DEBUG_PRINT("intr enable bits 0x%x\n", devpriv->intr_enable_bits);
} }
static void enable_ai_interrupts(struct comedi_device *dev, static void enable_ai_interrupts(struct comedi_device *dev,
@ -1277,7 +1266,6 @@ static void enable_ai_interrupts(struct comedi_device *dev,
devpriv->intr_enable_bits |= bits; devpriv->intr_enable_bits |= bits;
writew(devpriv->intr_enable_bits, writew(devpriv->intr_enable_bits,
devpriv->main_iobase + INTR_ENABLE_REG); devpriv->main_iobase + INTR_ENABLE_REG);
DEBUG_PRINT("intr enable bits 0x%x\n", devpriv->intr_enable_bits);
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
} }
@ -1292,38 +1280,6 @@ static void init_plx9080(struct comedi_device *dev)
devpriv->plx_control_bits = devpriv->plx_control_bits =
readl(devpriv->plx9080_iobase + PLX_CONTROL_REG); readl(devpriv->plx9080_iobase + PLX_CONTROL_REG);
/* plx9080 dump */
DEBUG_PRINT(" plx interrupt status 0x%x\n",
readl(plx_iobase + PLX_INTRCS_REG));
DEBUG_PRINT(" plx id bits 0x%x\n", readl(plx_iobase + PLX_ID_REG));
DEBUG_PRINT(" plx control reg 0x%x\n", devpriv->plx_control_bits);
DEBUG_PRINT(" plx mode/arbitration reg 0x%x\n",
readl(plx_iobase + PLX_MARB_REG));
DEBUG_PRINT(" plx region0 reg 0x%x\n",
readl(plx_iobase + PLX_REGION0_REG));
DEBUG_PRINT(" plx region1 reg 0x%x\n",
readl(plx_iobase + PLX_REGION1_REG));
DEBUG_PRINT(" plx revision 0x%x\n",
readl(plx_iobase + PLX_REVISION_REG));
DEBUG_PRINT(" plx dma channel 0 mode 0x%x\n",
readl(plx_iobase + PLX_DMA0_MODE_REG));
DEBUG_PRINT(" plx dma channel 1 mode 0x%x\n",
readl(plx_iobase + PLX_DMA1_MODE_REG));
DEBUG_PRINT(" plx dma channel 0 pci address 0x%x\n",
readl(plx_iobase + PLX_DMA0_PCI_ADDRESS_REG));
DEBUG_PRINT(" plx dma channel 0 local address 0x%x\n",
readl(plx_iobase + PLX_DMA0_LOCAL_ADDRESS_REG));
DEBUG_PRINT(" plx dma channel 0 transfer size 0x%x\n",
readl(plx_iobase + PLX_DMA0_TRANSFER_SIZE_REG));
DEBUG_PRINT(" plx dma channel 0 descriptor 0x%x\n",
readl(plx_iobase + PLX_DMA0_DESCRIPTOR_REG));
DEBUG_PRINT(" plx dma channel 0 command status 0x%x\n",
readb(plx_iobase + PLX_DMA0_CS_REG));
DEBUG_PRINT(" plx dma channel 0 threshold 0x%x\n",
readl(plx_iobase + PLX_DMA0_THRESHOLD_REG));
DEBUG_PRINT(" plx bigend 0x%x\n", readl(plx_iobase + PLX_BIGEND_REG));
#ifdef __BIG_ENDIAN #ifdef __BIG_ENDIAN
bits = BIGEND_DMA0 | BIGEND_DMA1; bits = BIGEND_DMA0 | BIGEND_DMA1;
#else #else
@ -1417,9 +1373,6 @@ static int set_ai_fifo_segment_length(struct comedi_device *dev,
devpriv->ai_fifo_segment_length = num_increments * increment_size; devpriv->ai_fifo_segment_length = num_increments * increment_size;
DEBUG_PRINT("set hardware fifo segment length to %i\n",
devpriv->ai_fifo_segment_length);
return devpriv->ai_fifo_segment_length; return devpriv->ai_fifo_segment_length;
} }
@ -1441,8 +1394,6 @@ static int set_ai_fifo_size(struct comedi_device *dev, unsigned int num_samples)
num_samples = retval * fifo->num_segments * fifo->sample_packing_ratio; num_samples = retval * fifo->num_segments * fifo->sample_packing_ratio;
DEBUG_PRINT("set hardware fifo size to %i\n", num_samples);
return num_samples; return num_samples;
} }
@ -1538,8 +1489,6 @@ static int alloc_and_init_dma_members(struct comedi_device *dev)
if (devpriv->ai_dma_desc == NULL) if (devpriv->ai_dma_desc == NULL)
return -ENOMEM; return -ENOMEM;
DEBUG_PRINT("ai dma descriptors start at bus addr 0x%llx\n",
(unsigned long long)devpriv->ai_dma_desc_bus_addr);
if (ao_cmd_is_supported(thisboard)) { if (ao_cmd_is_supported(thisboard)) {
devpriv->ao_dma_desc = devpriv->ao_dma_desc =
pci_alloc_consistent(pcidev, pci_alloc_consistent(pcidev,
@ -1548,9 +1497,6 @@ static int alloc_and_init_dma_members(struct comedi_device *dev)
&devpriv->ao_dma_desc_bus_addr); &devpriv->ao_dma_desc_bus_addr);
if (devpriv->ao_dma_desc == NULL) if (devpriv->ao_dma_desc == NULL)
return -ENOMEM; return -ENOMEM;
DEBUG_PRINT("ao dma descriptors start at bus addr 0x%llx\n",
(unsigned long long)devpriv->ao_dma_desc_bus_addr);
} }
/* initialize dma descriptors */ /* initialize dma descriptors */
for (i = 0; i < ai_dma_ring_count(thisboard); i++) { for (i = 0; i < ai_dma_ring_count(thisboard); i++) {
@ -1650,8 +1596,6 @@ static void i2c_write_byte(struct comedi_device *dev, uint8_t byte)
uint8_t bit; uint8_t bit;
unsigned int num_bits = 8; unsigned int num_bits = 8;
DEBUG_PRINT("writing to i2c byte 0x%x\n", byte);
for (bit = 1 << (num_bits - 1); bit; bit >>= 1) { for (bit = 1 << (num_bits - 1); bit; bit >>= 1) {
i2c_set_scl(dev, 0); i2c_set_scl(dev, 0);
if ((byte & bit)) if ((byte & bit))
@ -1738,7 +1682,6 @@ static int ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
unsigned long flags; unsigned long flags;
static const int timeout = 100; static const int timeout = 100;
DEBUG_PRINT("chanspec 0x%x\n", insn->chanspec);
channel = CR_CHAN(insn->chanspec); channel = CR_CHAN(insn->chanspec);
range = CR_RANGE(insn->chanspec); range = CR_RANGE(insn->chanspec);
aref = CR_AREF(insn->chanspec); aref = CR_AREF(insn->chanspec);
@ -1766,7 +1709,6 @@ static int ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
if (insn->chanspec & CR_ALT_SOURCE) { if (insn->chanspec & CR_ALT_SOURCE) {
unsigned int cal_en_bit; unsigned int cal_en_bit;
DEBUG_PRINT("reading calibration source\n");
if (thisboard->layout == LAYOUT_60XX) if (thisboard->layout == LAYOUT_60XX)
cal_en_bit = CAL_EN_60XX_BIT; cal_en_bit = CAL_EN_60XX_BIT;
else else
@ -1800,7 +1742,6 @@ static int ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
devpriv->i2c_cal_range_bits &= ~ADC_SRC_4020_MASK; devpriv->i2c_cal_range_bits &= ~ADC_SRC_4020_MASK;
if (insn->chanspec & CR_ALT_SOURCE) { if (insn->chanspec & CR_ALT_SOURCE) {
DEBUG_PRINT("reading calibration source\n");
devpriv->i2c_cal_range_bits |= devpriv->i2c_cal_range_bits |=
adc_src_4020_bits(devpriv->calibration_source); adc_src_4020_bits(devpriv->calibration_source);
} else { /* select BNC inputs */ } else { /* select BNC inputs */
@ -1839,7 +1780,6 @@ static int ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
/* wait for data */ /* wait for data */
for (i = 0; i < timeout; i++) { for (i = 0; i < timeout; i++) {
bits = readw(devpriv->main_iobase + HW_STATUS_REG); bits = readw(devpriv->main_iobase + HW_STATUS_REG);
DEBUG_PRINT(" pipe bits 0x%x\n", pipe_full_bits(bits));
if (thisboard->layout == LAYOUT_4020) { if (thisboard->layout == LAYOUT_4020) {
if (readw(devpriv->main_iobase + if (readw(devpriv->main_iobase +
ADC_WRITE_PNTR_REG)) ADC_WRITE_PNTR_REG))
@ -1850,7 +1790,6 @@ static int ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
} }
udelay(1); udelay(1);
} }
DEBUG_PRINT(" looped %i times waiting for data\n", i);
if (i == timeout) { if (i == timeout) {
comedi_error(dev, " analog input read insn timed out"); comedi_error(dev, " analog input read insn timed out");
dev_info(dev->class_dev, "status 0x%x\n", bits); dev_info(dev->class_dev, "status 0x%x\n", bits);
@ -1884,7 +1823,6 @@ static int ai_config_calibration_source(struct comedi_device *dev,
return -EINVAL; return -EINVAL;
} }
DEBUG_PRINT("setting calibration source to %i\n", source);
devpriv->calibration_source = source; devpriv->calibration_source = source;
return 2; return 2;
@ -2368,7 +2306,6 @@ static void set_ai_pacing(struct comedi_device *dev, struct comedi_cmd *cmd)
/* load lower 16 bits of convert interval */ /* load lower 16 bits of convert interval */
writew(convert_counter & 0xffff, writew(convert_counter & 0xffff,
devpriv->main_iobase + ADC_SAMPLE_INTERVAL_LOWER_REG); devpriv->main_iobase + ADC_SAMPLE_INTERVAL_LOWER_REG);
DEBUG_PRINT("convert counter 0x%x\n", convert_counter);
/* load upper 8 bits of convert interval */ /* load upper 8 bits of convert interval */
writew((convert_counter >> 16) & 0xff, writew((convert_counter >> 16) & 0xff,
devpriv->main_iobase + ADC_SAMPLE_INTERVAL_UPPER_REG); devpriv->main_iobase + ADC_SAMPLE_INTERVAL_UPPER_REG);
@ -2378,7 +2315,6 @@ static void set_ai_pacing(struct comedi_device *dev, struct comedi_cmd *cmd)
/* load upper 8 bits of scan delay */ /* load upper 8 bits of scan delay */
writew((scan_counter >> 16) & 0xff, writew((scan_counter >> 16) & 0xff,
devpriv->main_iobase + ADC_DELAY_INTERVAL_UPPER_REG); devpriv->main_iobase + ADC_DELAY_INTERVAL_UPPER_REG);
DEBUG_PRINT("scan counter 0x%x\n", scan_counter);
} }
static int use_internal_queue_6xxx(const struct comedi_cmd *cmd) static int use_internal_queue_6xxx(const struct comedi_cmd *cmd)
@ -2469,9 +2405,6 @@ static int setup_channel_queue(struct comedi_device *dev,
writew(bits, writew(bits,
devpriv->main_iobase + devpriv->main_iobase +
ADC_QUEUE_FIFO_REG); ADC_QUEUE_FIFO_REG);
DEBUG_PRINT(
"wrote 0x%x to external channel queue\n",
bits);
} }
/* doing a queue clear is not specified in board docs, /* doing a queue clear is not specified in board docs,
* but required for reliable operation */ * but required for reliable operation */
@ -2593,7 +2526,6 @@ static int ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
} }
writew(devpriv->adc_control1_bits, writew(devpriv->adc_control1_bits,
devpriv->main_iobase + ADC_CONTROL1_REG); devpriv->main_iobase + ADC_CONTROL1_REG);
DEBUG_PRINT("control1 bits 0x%x\n", devpriv->adc_control1_bits);
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
/* clear adc buffer */ /* clear adc buffer */
@ -2645,17 +2577,14 @@ static int ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
if (use_hw_sample_counter(cmd)) if (use_hw_sample_counter(cmd))
bits |= ADC_SAMPLE_COUNTER_EN_BIT; bits |= ADC_SAMPLE_COUNTER_EN_BIT;
writew(bits, devpriv->main_iobase + ADC_CONTROL0_REG); writew(bits, devpriv->main_iobase + ADC_CONTROL0_REG);
DEBUG_PRINT("control0 bits 0x%x\n", bits);
devpriv->ai_cmd_running = 1; devpriv->ai_cmd_running = 1;
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
/* start acquisition */ /* start acquisition */
if (cmd->start_src == TRIG_NOW) { if (cmd->start_src == TRIG_NOW)
writew(0, devpriv->main_iobase + ADC_START_REG); writew(0, devpriv->main_iobase + ADC_START_REG);
DEBUG_PRINT("soft trig\n");
}
return 0; return 0;
} }
@ -2690,10 +2619,6 @@ static void pio_drain_ai_fifo_16(struct comedi_device *dev)
read_segment = adc_upper_read_ptr_code(prepost_bits); read_segment = adc_upper_read_ptr_code(prepost_bits);
write_segment = adc_upper_write_ptr_code(prepost_bits); write_segment = adc_upper_write_ptr_code(prepost_bits);
DEBUG_PRINT(" rd seg %i, wrt seg %i, rd idx %i, wrt idx %i\n",
read_segment, write_segment, read_index,
write_index);
if (read_segment != write_segment) if (read_segment != write_segment)
num_samples = num_samples =
devpriv->ai_fifo_segment_length - read_index; devpriv->ai_fifo_segment_length - read_index;
@ -2715,8 +2640,6 @@ static void pio_drain_ai_fifo_16(struct comedi_device *dev)
break; break;
} }
DEBUG_PRINT(" read %i samples from fifo\n", num_samples);
for (i = 0; i < num_samples; i++) { for (i = 0; i < num_samples; i++) {
cfc_write_to_buffer(s, cfc_write_to_buffer(s,
readw(devpriv->main_iobase + readw(devpriv->main_iobase +
@ -2812,11 +2735,6 @@ static void drain_dma_buffers(struct comedi_device *dev, unsigned int channel)
num_samples * sizeof(uint16_t)); num_samples * sizeof(uint16_t));
devpriv->ai_dma_index = (devpriv->ai_dma_index + 1) % devpriv->ai_dma_index = (devpriv->ai_dma_index + 1) %
ai_dma_ring_count(thisboard); ai_dma_ring_count(thisboard);
DEBUG_PRINT("next buffer addr 0x%lx\n",
(unsigned long)devpriv->
ai_buffer_bus_addr[devpriv->ai_dma_index]);
DEBUG_PRINT("pci addr reg 0x%x\n", next_transfer_addr);
} }
/* XXX check for dma ring buffer overrun /* XXX check for dma ring buffer overrun
* (use end-of-chain bit to mark last unused buffer) */ * (use end-of-chain bit to mark last unused buffer) */
@ -2845,24 +2763,17 @@ static void handle_ai_interrupt(struct comedi_device *dev,
if (plx_status & ICS_DMA1_A) { /* dma chan 1 interrupt */ if (plx_status & ICS_DMA1_A) { /* dma chan 1 interrupt */
writeb((dma1_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT, writeb((dma1_status & PLX_DMA_EN_BIT) | PLX_CLEAR_DMA_INTR_BIT,
devpriv->plx9080_iobase + PLX_DMA1_CS_REG); devpriv->plx9080_iobase + PLX_DMA1_CS_REG);
DEBUG_PRINT("dma1 status 0x%x\n", dma1_status);
if (dma1_status & PLX_DMA_EN_BIT) if (dma1_status & PLX_DMA_EN_BIT)
drain_dma_buffers(dev, 1); drain_dma_buffers(dev, 1);
DEBUG_PRINT(" cleared dma ch1 interrupt\n");
} }
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
if (status & ADC_DONE_BIT)
DEBUG_PRINT("adc done interrupt\n");
/* drain fifo with pio */ /* drain fifo with pio */
if ((status & ADC_DONE_BIT) || if ((status & ADC_DONE_BIT) ||
((cmd->flags & TRIG_WAKE_EOS) && ((cmd->flags & TRIG_WAKE_EOS) &&
(status & ADC_INTR_PENDING_BIT) && (status & ADC_INTR_PENDING_BIT) &&
(thisboard->layout != LAYOUT_4020))) { (thisboard->layout != LAYOUT_4020))) {
DEBUG_PRINT("pio fifo drain\n");
spin_lock_irqsave(&dev->spinlock, flags); spin_lock_irqsave(&dev->spinlock, flags);
if (devpriv->ai_cmd_running) { if (devpriv->ai_cmd_running) {
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
@ -2947,7 +2858,6 @@ static void restart_ao_dma(struct comedi_device *dev)
dma_desc_bits = dma_desc_bits =
readl(devpriv->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG); readl(devpriv->plx9080_iobase + PLX_DMA0_DESCRIPTOR_REG);
dma_desc_bits &= ~PLX_END_OF_CHAIN_BIT; dma_desc_bits &= ~PLX_END_OF_CHAIN_BIT;
DEBUG_PRINT("restarting ao dma, descriptor reg 0x%x\n", dma_desc_bits);
load_first_dma_descriptor(dev, 0, dma_desc_bits); load_first_dma_descriptor(dev, 0, dma_desc_bits);
dma_start_sync(dev, 0); dma_start_sync(dev, 0);
@ -2963,10 +2873,6 @@ static unsigned int load_ao_dma_buffer(struct comedi_device *dev,
buffer_index = devpriv->ao_dma_index; buffer_index = devpriv->ao_dma_index;
prev_buffer_index = prev_ao_dma_index(dev); prev_buffer_index = prev_ao_dma_index(dev);
DEBUG_PRINT("attempting to load ao buffer %i (0x%llx)\n", buffer_index,
(unsigned long long)devpriv->ao_buffer_bus_addr[
buffer_index]);
num_bytes = comedi_buf_read_n_available(dev->write_subdev->async); num_bytes = comedi_buf_read_n_available(dev->write_subdev->async);
if (num_bytes > DMA_BUFFER_SIZE) if (num_bytes > DMA_BUFFER_SIZE)
num_bytes = DMA_BUFFER_SIZE; num_bytes = DMA_BUFFER_SIZE;
@ -2977,8 +2883,6 @@ static unsigned int load_ao_dma_buffer(struct comedi_device *dev,
if (num_bytes == 0) if (num_bytes == 0)
return 0; return 0;
DEBUG_PRINT("loading %i bytes\n", num_bytes);
num_bytes = cfc_read_array_from_buffer(dev->write_subdev, num_bytes = cfc_read_array_from_buffer(dev->write_subdev,
devpriv-> devpriv->
ao_buffer[buffer_index], ao_buffer[buffer_index],
@ -3052,14 +2956,12 @@ static void handle_ao_interrupt(struct comedi_device *dev,
writeb(PLX_CLEAR_DMA_INTR_BIT, writeb(PLX_CLEAR_DMA_INTR_BIT,
devpriv->plx9080_iobase + PLX_DMA0_CS_REG); devpriv->plx9080_iobase + PLX_DMA0_CS_REG);
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
DEBUG_PRINT("dma0 status 0x%x\n", dma0_status);
if (dma0_status & PLX_DMA_EN_BIT) { if (dma0_status & PLX_DMA_EN_BIT) {
load_ao_dma(dev, cmd); load_ao_dma(dev, cmd);
/* try to recover from dma end-of-chain event */ /* try to recover from dma end-of-chain event */
if (ao_dma_needs_restart(dev, dma0_status)) if (ao_dma_needs_restart(dev, dma0_status))
restart_ao_dma(dev); restart_ao_dma(dev);
} }
DEBUG_PRINT(" cleared dma ch0 interrupt\n");
} else { } else {
spin_unlock_irqrestore(&dev->spinlock, flags); spin_unlock_irqrestore(&dev->spinlock, flags);
} }
@ -3068,12 +2970,6 @@ static void handle_ao_interrupt(struct comedi_device *dev,
async->events |= COMEDI_CB_EOA; async->events |= COMEDI_CB_EOA;
if (ao_stopped_by_error(dev, cmd)) if (ao_stopped_by_error(dev, cmd))
async->events |= COMEDI_CB_ERROR; async->events |= COMEDI_CB_ERROR;
DEBUG_PRINT("plx dma0 desc reg 0x%x\n",
readl(devpriv->plx9080_iobase +
PLX_DMA0_DESCRIPTOR_REG));
DEBUG_PRINT("plx dma0 address reg 0x%x\n",
readl(devpriv->plx9080_iobase +
PLX_DMA0_PCI_ADDRESS_REG));
} }
cfc_handle_events(dev, s); cfc_handle_events(dev, s);
} }
@ -3089,15 +2985,12 @@ static irqreturn_t handle_interrupt(int irq, void *d)
plx_status = readl(devpriv->plx9080_iobase + PLX_INTRCS_REG); plx_status = readl(devpriv->plx9080_iobase + PLX_INTRCS_REG);
status = readw(devpriv->main_iobase + HW_STATUS_REG); status = readw(devpriv->main_iobase + HW_STATUS_REG);
DEBUG_PRINT("hw status 0x%x, plx status 0x%x\n", status, plx_status);
/* an interrupt before all the postconfig stuff gets done could /* an interrupt before all the postconfig stuff gets done could
* cause a NULL dereference if we continue through the * cause a NULL dereference if we continue through the
* interrupt handler */ * interrupt handler */
if (!dev->attached) { if (!dev->attached)
DEBUG_PRINT("premature interrupt, ignoring\n");
return IRQ_HANDLED; return IRQ_HANDLED;
}
handle_ai_interrupt(dev, status, plx_status); handle_ai_interrupt(dev, status, plx_status);
handle_ao_interrupt(dev, status, plx_status); handle_ao_interrupt(dev, status, plx_status);
@ -3105,11 +2998,8 @@ static irqreturn_t handle_interrupt(int irq, void *d)
if (plx_status & ICS_LDIA) { /* clear local doorbell interrupt */ if (plx_status & ICS_LDIA) { /* clear local doorbell interrupt */
plx_bits = readl(devpriv->plx9080_iobase + PLX_DBR_OUT_REG); plx_bits = readl(devpriv->plx9080_iobase + PLX_DBR_OUT_REG);
writel(plx_bits, devpriv->plx9080_iobase + PLX_DBR_OUT_REG); writel(plx_bits, devpriv->plx9080_iobase + PLX_DBR_OUT_REG);
DEBUG_PRINT(" cleared local doorbell bits 0x%x\n", plx_bits);
} }
DEBUG_PRINT("exiting handler\n");
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -3130,7 +3020,6 @@ static int ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
abort_dma(dev, 1); abort_dma(dev, 1);
DEBUG_PRINT("ai canceled\n");
return 0; return 0;
} }
@ -3458,7 +3347,6 @@ static int dio_callback(int dir, int port, int data, unsigned long arg)
void __iomem *iobase = (void __iomem *)arg; void __iomem *iobase = (void __iomem *)arg;
if (dir) { if (dir) {
writeb(data, iobase + port); writeb(data, iobase + port);
DEBUG_PRINT("wrote 0x%x to port %i\n", data, port);
return 0; return 0;
} else { } else {
return readb(iobase + port); return readb(iobase + port);
@ -4046,11 +3934,6 @@ static int auto_attach(struct comedi_device *dev,
return -ENOMEM; return -ENOMEM;
} }
DEBUG_PRINT(" plx9080 remapped to 0x%p\n", devpriv->plx9080_iobase);
DEBUG_PRINT(" main remapped to 0x%p\n", devpriv->main_iobase);
DEBUG_PRINT(" diocounter remapped to 0x%p\n",
devpriv->dio_counter_iobase);
/* figure out what local addresses are */ /* figure out what local addresses are */
local_range = readl(devpriv->plx9080_iobase + PLX_LAS0RNG_REG) & local_range = readl(devpriv->plx9080_iobase + PLX_LAS0RNG_REG) &
LRNG_MEM_MASK; LRNG_MEM_MASK;
@ -4065,9 +3948,6 @@ static int auto_attach(struct comedi_device *dev,
devpriv->local1_iobase = ((uint32_t)devpriv->dio_counter_phys_iobase & devpriv->local1_iobase = ((uint32_t)devpriv->dio_counter_phys_iobase &
~local_range) | local_decode; ~local_range) | local_decode;
DEBUG_PRINT(" local 0 io addr 0x%x\n", devpriv->local0_iobase);
DEBUG_PRINT(" local 1 io addr 0x%x\n", devpriv->local1_iobase);
retval = alloc_and_init_dma_members(dev); retval = alloc_and_init_dma_members(dev);
if (retval < 0) if (retval < 0)
return retval; return retval;