typedef struct{
int data;
struct pci_dev *pci_dev; /* for a PCI device */
- int pci_setup; /* non-zero in PCI set up okay */
lsampl_t ao_readback[2]; /* Used for AO readback */
}pci6208_private;
retval = pci6208_pci_setup(devpriv->pci_dev, &io_base, dev->minor);
if (retval < 0) return retval;
- // Allow resources to be freed and PCI device to be disabled.
- devpriv->pci_setup = 1;
-
dev->iobase=io_base;
dev->board_name = thisboard->name;
printk("comedi%d: pci6208: remove\n",dev->minor);
if(devpriv && devpriv->pci_dev){
- if (devpriv->pci_setup) {
+ if(dev->iobase) {
pci_release_regions(devpriv->pci_dev);
pci_disable_device(devpriv->pci_dev);
}
typedef struct{
int data;
struct pci_dev *pci_dev;
- int pci_setup;
} adl_pci7432_private;
#define devpriv ((adl_pci7432_private *)dev->private)
printk("comedi%d: I/O port conflict\n", dev->minor);
return -EIO;
}
- devpriv->pci_setup = 1; /* Allow resources to be freed on detach */
dev->iobase = pci_resource_start ( pcidev, 2 );
printk ( "comedi: base addr %4lx\n", dev->iobase );
printk("comedi%d: pci7432: remove\n",dev->minor);
if (devpriv && devpriv->pci_dev) {
- if (devpriv->pci_setup) {
+ if (dev->iobase) {
pci_release_regions(devpriv->pci_dev);
pci_disable_device(devpriv->pci_dev);
}
typedef struct{
int data;
struct pci_dev *pci_dev;
- int pci_setup;
} adl_pci8164_private;
#define devpriv ((adl_pci8164_private *)dev->private)
printk("comedi%d: I/O port conflict\n", dev->minor);
return -EIO;
}
- devpriv->pci_setup = 1; /* Allow resources to be freed on detach */
dev->iobase = pci_resource_start ( pcidev, 2 );
printk ( "comedi: base addr %4lx\n", dev->iobase );
printk("comedi%d: pci8164: remove\n",dev->minor);
if (devpriv && devpriv->pci_dev) {
- if (devpriv->pci_setup) {
+ if (dev->iobase) {
pci_release_regions(devpriv->pci_dev);
pci_disable_device(devpriv->pci_dev);
}
int error,i;
pci9111_board_struct* board;
+ if(alloc_private(dev, sizeof(pci9111_private_data_struct)) < 0)
+ {
+ return -ENOMEM;
+ }
//
// Probe the device to determine what device in the series it is.
//
dev->board_ptr = pci9111_boards + i;
board = (pci9111_board_struct *) dev->board_ptr;
+ dev_private->pci_device = pci_device;
goto found;
}
}
if(pci_enable_device (pci_device) < 0)
{
printk("comedi%d: Failed to enable PCI device\n", dev->minor);
- pci_dev_put(pci_device);
return -EIO;
}
if(pci_request_regions(pci_device, PCI9111_DRIVER_NAME))
{
printk("comedi%d: I/O port conflict\n",dev->minor);
- pci_dev_put(pci_device);
return -EIO;
}
dev->iobase=io_base;
dev->board_name = board->name;
-
- if(alloc_private(dev,sizeof(pci9111_private_data_struct))<0)
- {
- pci_release_regions(pci_device);
- pci_disable_device(pci_device);
- pci_dev_put(pci_device);
- return -ENOMEM;
- }
-
- dev_private->pci_device = pci_device;
dev_private->io_range = io_range;
dev_private->is_valid=0;
dev_private->lcr_io_base=lcr_io_base;
static int pci9111_detach(comedi_device *dev)
{
- // Reset device
-
- if (dev->private!=0)
- {
- if (dev_private->is_valid) pci9111_reset(dev);
-
- }
-
- // Release previously allocated irq
-
- if (dev->irq!=0)
- {
- comedi_free_irq(dev->irq,dev);
- }
-
- if (dev_private!=0 && dev_private->pci_device!=0)
- {
- pci_release_regions(dev_private->pci_device);
- pci_disable_device(dev_private->pci_device);
- pci_dev_put(dev_private->pci_device);
- }
-
- return 0;
+ // Reset device
+
+ if (dev->private!=0)
+ {
+ if (dev_private->is_valid) pci9111_reset(dev);
+
+ }
+
+ // Release previously allocated irq
+
+ if (dev->irq!=0)
+ {
+ comedi_free_irq(dev->irq,dev);
+ }
+
+ if (dev_private!=0 && dev_private->pci_device!=0)
+ {
+ if(dev->iobase)
+ {
+ pci_release_regions(dev_private->pci_device);
+ pci_disable_device(dev_private->pci_device);
+ }
+ pci_dev_put(dev_private->pci_device);
+ }
+
+ return 0;
}
pci_dio_private *next; // next private struct
struct pci_dev *pcidev; // pointer to board's pci_dev
char valid; // card is usable
- char enabled; // PCI card is enabled
char GlobalIrqEnabled;// 1= any IRQ source is enabled
// PCI-1760 specific data
unsigned char IDICntEnable; // counter's counting enable status
if (pci_request_regions(pcidev, driver_pci_dio.driver_name)) {
rt_printk(", Error: Can't allocate PCI device!\n");
return -EIO;
- }
- devpriv->enabled=1;
-
+ }
iobase=pci_resource_start(pcidev, this_board->main_pci_region);
rt_printk(", b:s:f=%d:%d:%d, io=0x%4x",
pcidev->bus->number, PCI_SLOT(pcidev->devfn), PCI_FUNC(pcidev->devfn),
s->private=NULL;
}
- if (devpriv->enabled) {
- pci_release_regions(devpriv->pcidev);
- pci_disable_device(devpriv->pcidev);
+ if (devpriv->pcidev) {
+ if (dev->iobase) {
+ pci_release_regions(devpriv->pcidev);
+ pci_disable_device(devpriv->pcidev);
+ }
+ pci_dev_put(devpriv->pcidev);
}
if (devpriv->prev) {
if (devpriv->next) {
devpriv->next->prev=devpriv->prev;
}
-
- if (devpriv->pcidev) {
- pci_dev_put(devpriv->pcidev);
- }
- }
+ }
return 0;
}
printk(KERN_DEBUG "comedi%d: %s: attach\n", dev->minor,
DIO200_DRIVER_NAME);
+ if ((ret=alloc_private(dev,sizeof(dio200_private))) < 0) {
+ printk(KERN_ERR "comedi%d: error! out of memory!\n", dev->minor);
+ return ret;
+ }
+
/* Process options. */
switch (thisboard->bustype) {
case isa_bustype:
if ((ret=dio200_find_pci(dev, bus, slot, &pci_dev)) < 0)
return ret;
+ devpriv->pci_dev = pci_dev;
break;
default:
printk(KERN_ERR "comedi%d: %s: BUG! cannot determine board type!\n",
break;
}
- if ((ret=alloc_private(dev,sizeof(dio200_private))) < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n", dev->minor);
- if (pci_dev) {
- pci_dev_put(pci_dev);
- }
- return ret;
- }
-
devpriv->intr_sd = -1;
/* Enable device and reserve I/O spaces. */
if (ret < 0) {
printk(KERN_ERR "comedi%d: error! cannot enable PCI device!\n",
dev->minor);
- pci_dev_put(pci_dev);
return ret;
}
iobase = pci_resource_start(pci_dev, 2);
if (ret < 0) {
printk(KERN_ERR "comedi%d: I/O port conflict (PCI)!\n",
dev->minor);
- pci_dev_put(pci_dev);
return ret;
}
- devpriv->pci_dev = pci_dev;
} else {
ret = dio200_request_region(dev->minor, iobase, DIO200_IO_SIZE);
if (ret < 0) {
}
if (devpriv) {
if (devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
} else if (dev->iobase) {
release_region(dev->iobase, DIO200_IO_SIZE);
int ret;
printk("comedi%d: %s: ",dev->minor, PC236_DRIVER_NAME);
-
+/*
+ * Allocate the private structure area. alloc_private() is a
+ * convenient macro defined in comedidev.h.
+ */
+ if ((ret=alloc_private(dev,sizeof(pc236_private))) < 0) {
+ printk("out of memory!\n");
+ return ret;
+ }
/* Process options. */
switch (thisboard->bustype) {
case isa_bustype:
if (((pci_dev->class ^ pci_id->class) & pci_id->class_mask) != 0)
continue;
/* Found a match. */
+ devpriv->pci_dev = pci_dev;
break;
}
if (!pci_dev) {
dev->board_name = thisboard->name;
printk("%s ", dev->board_name);
-/*
- * Allocate the private structure area. alloc_private() is a
- * convenient macro defined in comedidev.h.
- */
- if ((ret=alloc_private(dev,sizeof(pc236_private))) < 0) {
- printk("out of memory!\n");
- if (pci_dev)
- pci_dev_put(pci_dev);
- return ret;
- }
-
/* Enable device and reserve I/O spaces. */
if (pci_dev) {
if ((ret=pci_enable_device(pci_dev)) < 0) {
printk("error enabling PCI device!\n");
- pci_dev_put(pci_dev);
return ret;
}
if ((ret=pci_request_regions(pci_dev, PC236_DRIVER_NAME)) < 0) {
printk("I/O port conflict (PCI)!\n");
- pci_dev_put(pci_dev);
return ret;
}
- devpriv->pci_dev = pci_dev;
devpriv->lcr_iobase = pci_resource_start(pci_dev, 1);
iobase = pci_resource_start(pci_dev, 2);
irq = pci_dev->irq;
}
if (devpriv) {
if (devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
} else if (dev->iobase) {
release_region(dev->iobase, PC236_IO_SIZE);
}
}
-
return 0;
}
int ret;
printk("comedi%d: %s: ",dev->minor, PC263_DRIVER_NAME);
-
+/*
+ * Allocate the private structure area. alloc_private() is a
+ * convenient macro defined in comedidev.h.
+ */
+ if ((ret=alloc_private(dev,sizeof(pc263_private))) < 0) {
+ printk("out of memory!\n");
+ return ret;
+ }
/* Process options. */
switch (thisboard->bustype) {
case isa_bustype:
if (((pci_dev->class ^ pci_id->class) & pci_id->class_mask) != 0)
continue;
/* Found a match. */
+ devpriv->pci_dev = pci_dev;
break;
}
if (!pci_dev) {
dev->board_name = thisboard->name;
printk("%s ", dev->board_name);
-/*
- * Allocate the private structure area. alloc_private() is a
- * convenient macro defined in comedidev.h.
- */
- if ((ret=alloc_private(dev,sizeof(pc263_private))) < 0) {
- printk("out of memory!\n");
- if (pci_dev)
- pci_dev_put(pci_dev);
- return ret;
- }
-
/* Enable device and reserve I/O spaces. */
if (pci_dev) {
if ((ret=pci_enable_device(pci_dev)) < 0) {
printk("error enabling PCI device!\n");
- pci_dev_put(pci_dev);
return ret;
}
if ((ret=pci_request_regions(pci_dev, PC263_DRIVER_NAME)) < 0) {
printk("I/O port conflict (PCI)!\n");
- pci_dev_put(pci_dev);
return ret;
}
- devpriv->pci_dev = pci_dev;
iobase = pci_resource_start(pci_dev, 2);
} else {
if ((ret=pc263_request_region(iobase, PC263_IO_SIZE)) < 0) {
if (devpriv) {
if (devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
} else if (dev->iobase) {
release_region(dev->iobase, PC263_IO_SIZE);
bus = it->options[0];
slot = it->options[1];
-
+ if ((ret=alloc_private(dev,sizeof(pci224_private))) < 0) {
+ printk(KERN_ERR "comedi%d: error! out of memory!\n",
+ dev->minor);
+ return ret;
+ }
if ((ret=pci224_find_pci(dev, bus, slot, &pci_dev)) < 0)
return ret;
+ devpriv->pci_dev = pci_dev;
if ((ret=pci_enable_device(pci_dev)) < 0) {
printk(KERN_ERR "comedi%d: error! cannot enable PCI device!\n",
dev->minor);
- pci_dev_put(pci_dev);
return ret;
}
if (pci_request_regions(pci_dev, DRIVER_NAME)) {
printk(KERN_ERR "comedi%d: error! cannot allocate PCI regions!\n",
dev->minor);
- pci_dev_put(pci_dev);
return -EIO;
}
-
- if ((ret=alloc_private(dev,sizeof(pci224_private))) < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
- pci_release_regions(pci_dev);
- pci_disable_device(pci_dev);
- pci_dev_put(pci_dev);
- return ret;
- }
-
- devpriv->pci_dev = pci_dev;
spin_lock_init(&devpriv->ao_spinlock);
devpriv->iobase1 = pci_resource_start(pci_dev, 2);
PCI224_DACCON_FIFOENAB | PCI224_DACCON_FIFOINTR_EMPTY);
outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
dev->iobase + PCI224_DACCON);
-
+
/* Allocate subdevices. There is only one! */
if ((ret=alloc_subdevices(dev, 1)) < 0) {
printk(KERN_ERR "comedi%d: error! out of memory!\n",
dev->minor);
return ret;
}
-
+
s = dev->subdevices + 0;
/* Analog output subdevice. */
s->type = COMEDI_SUBD_AO;
kfree(devpriv->ao_scan_order);
}
if (devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
}
}
printk("comedi%d: amplc_pci230\n",dev->minor);
+ /* Allocate the private structure area using alloc_private().
+ * Macro defined in comedidev.h - memsets struct fields to 0. */
+ if((alloc_private(dev,sizeof(struct pci230_private)))<0){
+ return -ENOMEM;
+ }
/* Find card */
for(pci_dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); pci_dev != NULL ;
pci_dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pci_dev)) {
printk("comedi%d: amplc_pci230: No PCI230 found\n",dev->minor);
return -EIO;
}
+ devpriv->pci_dev = pci_dev;
dev->board_ptr = pci230_boards+i;
/* Read base addressses of the PCI230's two I/O regions from PCI configuration register. */
if(pci_enable_device(pci_dev)<0){
- pci_dev_put(pci_dev);
return -EIO;
}
/* Reserve I/O spaces. */
if(pci_request_regions(pci_dev,"PCI230")<0){
printk("comedi%d: amplc_pci230: I/O space conflict\n",dev->minor);
- pci_dev_put(pci_dev);
return -EIO;
}
printk("comedi%d: amplc_pci230: I/O region 1 0x%04x I/O region 2 0x%04x\n",dev->minor, pci_iobase, iobase);
- /* Allocate the private structure area using alloc_private().
- * Macro defined in comedidev.h - memsets struct fields to 0. */
- if((alloc_private(dev,sizeof(struct pci230_private)))<0){
- pci_release_regions(pci_dev);
- pci_disable_device(pci_dev);
- pci_dev_put(pci_dev);
- return -ENOMEM;
- }
- devpriv->pci_dev = pci_dev;
devpriv->pci_iobase = pci_iobase;
dev->iobase = iobase;
if(devpriv){
if(devpriv->pci_dev){
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
}
}
continue;
}
}
+ devpriv->pci_dev = pcidev;
dev->board_ptr = cb_pcidas_boards + index;
goto found;
}
if(pci_enable_device(pcidev))
{
printk(" Failed to enable PCI device\n");
- pci_dev_put(pcidev);
return -EIO;
}
if(pci_request_regions(pcidev, "cb_pcidas"))
{
printk(" I/O port conflict\n");
- pci_dev_put(pcidev);
return -EIO;
}
- devpriv->pci_dev = pcidev;
-
/*
* Initialize devpriv->control_status and devpriv->adc_fifo to point to
* their base address.
subdev_8255_cleanup(dev,dev->subdevices + 2);
if(devpriv && devpriv->pci_dev)
{
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(devpriv->s5933_config)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
}
continue;
}
}
+ priv(dev)->hw_dev = pcidev;
dev->board_ptr = pcidas64_boards + index;
break;
}
if( pci_enable_device( pcidev ) )
{
printk(KERN_WARNING " failed to enable PCI device\n");
- pci_dev_put( pcidev );
return -EIO;
}
if( pci_request_regions( pcidev, driver_cb_pcidas.driver_name ) )
{
/* Couldn't allocate io space */
printk(KERN_WARNING " failed to allocate io memory\n");
- pci_dev_put( pcidev );
return -EIO;
}
pci_set_master( pcidev );
- priv(dev)->hw_dev = pcidev;
-
//Initialize dev->board_name
dev->board_name = board(dev)->name;
if(priv(dev)->ao_dma_desc)
pci_free_consistent(priv(dev)->hw_dev, sizeof(struct plx_dma_desc) * AO_DMA_RING_COUNT,
priv(dev)->ao_dma_desc, priv(dev)->ao_dma_desc_bus_addr );
- pci_release_regions(priv(dev)->hw_dev);
- pci_disable_device(priv(dev)->hw_dev);
+ if(priv(dev)->main_phys_iobase)
+ {
+ pci_release_regions(priv(dev)->hw_dev);
+ pci_disable_device(priv(dev)->hw_dev);
+ }
pci_dev_put(priv(dev)->hw_dev);
}
}
pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
if(pcidev->vendor==PCI_VENDOR_ID_CB){
if(it->options[0] || it->options[1]){
- if(pcidev->bus->number==it->options[0] &&
- PCI_SLOT(pcidev->devfn)==it->options[1]){
- break;
+ if(pcidev->bus->number != it->options[0] ||
+ PCI_SLOT(pcidev->devfn) != it->options[1]){
+ continue;
+ }
+ }
+ for(index=0;index<N_BOARDS;index++){
+ if(cb_pcidda_boards[index].device_id == pcidev->device){
+ goto found;
}
- }else{
- break;
}
}
}
-
if(!pcidev){
printk("Not a ComputerBoards/MeasurementComputing card on requested position\n");
return -EIO;
}
-
- for(index=0;index<N_BOARDS;index++){
- if(cb_pcidda_boards[index].device_id == pcidev->device){
- goto found;
- }
- }
- printk("Not a supported ComputerBoards/MeasurementComputing card on "
- "requested position\n");
- pci_dev_put(pcidev);
- return -EIO;
-
found:
+ devpriv->pci_dev = pcidev;
dev->board_ptr = cb_pcidda_boards+index;
// "thisboard" macro can be used from here.
printk("Found %s at requested position\n",thisboard->name);
if(pci_enable_device(pcidev))
{
printk("cb_pcidda: failed to enable PCI device\n");
- pci_dev_put(pcidev);
return -EIO;
}
if (pci_request_regions(pcidev, thisboard->name))
{
printk("cb_pcidda: I/O port conflict\n");
- pci_dev_put(pcidev);
return -EIO;
}
- devpriv->pci_dev = pcidev;
devpriv->digitalio = pci_resource_start(devpriv->pci_dev, DIGITALIO_BADRINDEX);
devpriv->dac = pci_resource_start(devpriv->pci_dev, DAC_BADRINDEX);
{
if(devpriv->pci_dev)
{
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(devpriv->dac)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
}
}
continue;
}
}
+ devpriv->pci_dev = pcidev;
dev->board_ptr = cb_pcimdas_boards + index;
goto found;
}
if(pci_enable_device(pcidev))
{
printk(" Failed to enable PCI device\n");
- pci_dev_put(pcidev);
return -EIO;
}
if(pci_request_regions(pcidev, "cb_pcimdas"))
{
printk(" I/O port conflict\n");
- pci_dev_put(pcidev);
return -EIO;
}
- devpriv->pci_dev = pcidev;
devpriv->BADR0 = pci_resource_start(devpriv->pci_dev, 0);
devpriv->BADR1 = pci_resource_start(devpriv->pci_dev, 1);
{
if(devpriv->pci_dev)
{
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(devpriv->BADR0)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
}
}
*/
static int detach(comedi_device *dev)
{
- if (devpriv) {
+ if (devpriv) {
- if (devpriv->registers && thisboard) {
- devpriv->registers = 0;
- }
+ if (dev->subdevices && devpriv->attached_to_8255) {
+ /* de-register us from the 8255 driver */
+ subdev_8255_cleanup(dev,dev->subdevices + 2);
+ devpriv->attached_to_8255 = 0;
+ }
- if (dev->subdevices && devpriv->attached_to_8255) {
- /* de-register us from the 8255 driver */
- subdev_8255_cleanup(dev,dev->subdevices + 2);
- devpriv->attached_to_8255 = 0;
- }
+ if (devpriv->pci_dev) {
+ if(devpriv->registers)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
+ pci_dev_put(devpriv->pci_dev);
+ }
- if (devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- }
+ if (devpriv->attached_successfully && thisboard)
+ printk("comedi%d: %s: detached\n", dev->minor, thisboard->name);
- if (devpriv->attached_successfully && thisboard)
- printk("comedi%d: %s: detached\n", dev->minor, thisboard->name);
+ }
- }
-
return 0;
}
}
/* found ! */
+ devpriv->pci_dev = pcidev;
dev->board_ptr = boards + index;
if (pci_enable_device(pcidev))
{
printk("cb_pcimdda: Failed to enable PCI device\n");
- pci_dev_put(pcidev);
return -EIO;
}
if (pci_request_regions(pcidev, thisboard->name))
{
printk("cb_pcimdda: I/O port conflict\n");
- pci_dev_put(pcidev);
return -EIO;
}
- devpriv->pci_dev = pcidev;
registers = pci_resource_start(devpriv->pci_dev, REGS_BADRINDEX);
devpriv->registers = registers;
devpriv->dio_registers
if ( pcidev->vendor == PCI_VENDOR_ID_CONTEC &&
pcidev->device == PCI_DEVICE_ID_PIO1616L ) {
+ devpriv->pci_dev = pcidev;
if (pci_enable_device(pcidev)) {
printk("error enabling PCI device!\n");
return -EIO;
printk("I/O port conflict!\n");
return -EIO;
}
- devpriv->pci_dev = pcidev;
dev->iobase = pci_resource_start ( pcidev, 0 );
printk ( " base addr %lx ", dev->iobase );
printk("comedi%d: contec: remove\n",dev->minor);
if (devpriv && devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
pci_dev_put(devpriv->pci_dev);
}
static int daqboard2000_attach(comedi_device *dev, comedi_devconfig *it)
{
- int result = 0;
- comedi_subdevice *s;
- struct pci_dev *card = NULL;
- void *aux_data;
- unsigned int aux_len;
-
- printk("comedi%d: daqboard2000:", dev->minor);
-
- /* FIXME: we should handle multiple cards, have to make David decide
- how, so we will be consistent among all PCI card drivers... */
- card = pci_get_device(0x1616, 0x0409, NULL);
-
- if (!card) {
- printk(" no daqboard2000 found\n");
- result = -EIO;
- goto out;
- }else{
- u32 id;
- int i;
- id = ((u32)card->subsystem_device << 16) | card->subsystem_vendor;
- for(i=0;i<n_boardtypes;i++){
- if(boardtypes[i].id==id){
- printk(" %s",boardtypes[i].name);
- dev->board_ptr=boardtypes+i;
- }
- }
- if(!dev->board_ptr){
- printk(" unknown subsystem id %08x (pretend it is an ids2)",id);
- dev->board_ptr=boardtypes;
- }
- }
-
- if((result = pci_enable_device(card))<0){
- pci_dev_put(card);
- goto out;
- }
-
- if((result = pci_request_regions(card, "daqboard2000")) < 0) {
- pci_dev_put(card);
- goto out;
- }
+ int result = 0;
+ comedi_subdevice *s;
+ struct pci_dev *card = NULL;
+ void *aux_data;
+ unsigned int aux_len;
+
+ printk("comedi%d: daqboard2000:", dev->minor);
+
+ result = alloc_private(dev,sizeof(daqboard2000_private));
+ if(result < 0){
+ return -ENOMEM;
+ }
+ /* FIXME: we should handle multiple cards, have to make David decide
+ how, so we will be consistent among all PCI card drivers... */
+ card = pci_get_device(0x1616, 0x0409, NULL);
+ if (!card) {
+ printk(" no daqboard2000 found\n");
+ return -EIO;
+ }else{
+ u32 id;
+ int i;
+ devpriv->pci_dev = card;
+ id = ((u32)card->subsystem_device << 16) | card->subsystem_vendor;
+ for(i=0;i<n_boardtypes;i++){
+ if(boardtypes[i].id==id){
+ printk(" %s",boardtypes[i].name);
+ dev->board_ptr=boardtypes+i;
+ }
+ }
+ if(!dev->board_ptr){
+ printk(" unknown subsystem id %08x (pretend it is an ids2)",id);
+ dev->board_ptr=boardtypes;
+ }
+ }
- result = alloc_private(dev,sizeof(daqboard2000_private));
- if(result<0){
- pci_release_regions(card);
- pci_disable_device(card);
- pci_dev_put(card);
- goto out;
- }
- devpriv->pci_dev = card;
+ if((result = pci_enable_device(card))<0){
+ return -EIO;
+ }
+ if((result = pci_request_regions(card, "daqboard2000")) < 0) {
+ return -EIO;
+ }
+ devpriv->plx = ioremap(pci_resource_start(card,0), DAQBOARD2000_PLX_SIZE);
+ devpriv->daq = ioremap(pci_resource_start(card,2), DAQBOARD2000_DAQ_SIZE);
- result = alloc_subdevices(dev, 3);
- if(result<0)goto out;
-
- devpriv->plx = ioremap(pci_resource_start(card,0), DAQBOARD2000_PLX_SIZE);
- devpriv->daq = ioremap(pci_resource_start(card,2), DAQBOARD2000_DAQ_SIZE);
- readl(devpriv->plx + 0x6c);
+ result = alloc_subdevices(dev, 3);
+ if(result<0)goto out;
+
+ readl(devpriv->plx + 0x6c);
/*
u8 interrupt;
static int daqboard2000_detach(comedi_device * dev)
{
- printk("comedi%d: daqboard2000: remove\n", dev->minor);
-
- if(dev->subdevices)
- subdev_8255_cleanup(dev,dev->subdevices+2);
-
- if (devpriv && devpriv->daq) {
- iounmap(devpriv->daq);
- }
- if (devpriv && devpriv->plx) {
- iounmap(devpriv->plx);
- }
- if (dev->irq) {
- free_irq(dev->irq, dev);
- }
- if (devpriv && devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- }
- return 0;
+ printk("comedi%d: daqboard2000: remove\n", dev->minor);
+
+ if(dev->subdevices)
+ subdev_8255_cleanup(dev,dev->subdevices+2);
+
+ if (dev->irq) {
+ free_irq(dev->irq, dev);
+ }
+ if(devpriv)
+ {
+ if(devpriv->daq)
+ iounmap(devpriv->daq);
+ if(devpriv->plx)
+ iounmap(devpriv->plx);
+ if(devpriv->pci_dev)
+ {
+ if(devpriv->daq)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
+ pci_dev_put(devpriv->pci_dev);
+ }
+ }
+ return 0;
}
COMEDI_INITCLEANUP(driver_daqboard2000);
printk("No pci das08 cards found\n");
return -EIO;
}
+ devpriv->pdev = pdev;
// enable PCI device
if(pci_enable_device(pdev)){
printk(" Error enabling PCI device\n");
- pci_dev_put(pdev);
return -EIO;
}
// reserve I/O spaces
if(pci_request_regions(pdev, "das08")){
printk(" I/O port conflict\n");
- pci_dev_put(pdev);
return -EIO;
}
- devpriv->pdev = pdev;
// read base addresses
pci_iobase = pci_resource_start(pdev, 1);
iobase = pci_resource_start(pdev, 2);
if(devpriv){
if(devpriv->pdev){
- pci_release_regions(devpriv->pdev);
- pci_disable_device(devpriv->pdev);
+ if(devpriv->pci_iobase)
+ {
+ pci_release_regions(devpriv->pdev);
+ pci_disable_device(devpriv->pdev);
+ }
pci_dev_put(devpriv->pdev);
}
}
typedef struct{
struct pci_dev *pci_dev;
- int pci_enabled;
unsigned long phys_addr;
void *io_addr;
unsigned int lock;
{
if(devpriv->pci_dev)
{
- if (devpriv->pci_enabled)
+ if(devpriv->phys_addr)
{
pci_release_regions(devpriv->pci_dev);
pci_disable_device(devpriv->pci_dev);
ret = pci_request_regions(devpriv->pci_dev, "dt3000");
if(ret<0)return ret;
- devpriv->pci_enabled = 1;
-
addr=pci_resource_start(devpriv->pci_dev,0);
devpriv->phys_addr=addr;
offset = devpriv->phys_addr & ~PAGE_MASK;
}
if( pcidev )
{
+ priv(dev)->hw_dev = pcidev;
dev->board_ptr = hpdi_boards + i;
break;
}
if( pci_enable_device( pcidev ) )
{
printk(KERN_WARNING " failed enable PCI device\n");
- pci_dev_put( pcidev );
return -EIO;
}
if( pci_request_regions( pcidev, driver_hpdi.driver_name ) )
{
/* Couldn't allocate io space */
printk(KERN_WARNING " failed to allocate io memory\n");
- pci_dev_put( pcidev );
return -EIO;
}
pci_set_master( pcidev );
- priv(dev)->hw_dev = pcidev;
-
//Initialize dev->board_name
dev->board_name = board(dev)->name;
if( priv(dev)->dma_desc )
pci_free_consistent( priv(dev)->hw_dev, sizeof( struct plx_dma_desc ) *
NUM_DMA_DESCRIPTORS, priv(dev)->dma_desc, priv(dev)->dma_desc_phys_addr );
- pci_release_regions( priv(dev)->hw_dev );
- pci_disable_device( priv(dev)->hw_dev );
+ if(priv(dev)->hpdi_phys_iobase)
+ {
+ pci_release_regions( priv(dev)->hw_dev );
+ pci_disable_device( priv(dev)->hw_dev );
+ }
pci_dev_put(priv(dev)->hw_dev);
}
}
int io_base;
int error, i;
+ /* allocate device private structure */
+ if((error = alloc_private(dev, sizeof(cnt_device_private))) < 0)
+ {
+ return error;
+ }
+
/* Probe the device to determine what device in the series it is. */
for(pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); pci_device != NULL ;
pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pci_device))
found:
printk("comedi%d: found %s at PCI bus %d, slot %d\n",dev->minor,
board->name, pci_device->bus->number, PCI_SLOT(pci_device->devfn));
+ devpriv->pcidev = pci_device;
dev->board_name = board->name;
/* enable PCI device */
if((error = pci_enable_device(pci_device)) < 0)
{
- pci_dev_put(pci_device);
return error;
}
/* request PCI regions */
if((error = pci_request_regions(pci_device, CNT_DRIVER_NAME)) < 0)
{
- pci_dev_put(pci_device);
return error;
}
io_base = pci_resource_start(pci_device, 0);
dev->iobase = io_base & PCI_BASE_ADDRESS_IO_MASK;
- /* allocate device private structure */
- if((error = alloc_private(dev, sizeof(cnt_device_private))) < 0)
- {
- pci_dev_put(pci_device);
- return error;
- }
-
- devpriv->pcidev = pci_device;
-
/* allocate the subdevice structures */
if((error = alloc_subdevices(dev, 1)) < 0)
{
static int cnt_detach(comedi_device *dev)
{
- if (devpriv && devpriv->pcidev)
- {
- pci_release_regions(devpriv->pcidev);
- pci_disable_device(devpriv->pcidev);
- pci_dev_put(devpriv->pcidev);
- }
-
- printk("comedi%d: " CNT_DRIVER_NAME " remove\n",dev->minor);
- return 0;
+ if (devpriv && devpriv->pcidev)
+ {
+ if(dev->iobase)
+ {
+ pci_release_regions(devpriv->pcidev);
+ pci_disable_device(devpriv->pcidev);
+ }
+ pci_dev_put(devpriv->pcidev);
+ }
+ printk("comedi%d: " CNT_DRIVER_NAME " remove\n",dev->minor);
+ return 0;
}
CALL_PDEBUG("In me4000_probe()\n");
+ /* Allocate private memory */
+ if(alloc_private(dev, sizeof(me4000_info_t)) < 0){
+ return -ENOMEM;
+ }
/*
* Probe the device to determine what device in the series it is.
*/
for(pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); pci_device != NULL ;
pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pci_device)) {
- if(pci_device->vendor == PCI_VENDOR_ID_MEILHAUS){
- for(i = 0; i < ME4000_BOARD_VERSIONS; i++){
- if(me4000_boards[i].device_id == pci_device->device){
- /* Was a particular bus/slot requested? */
- if((it->options[0] != 0) || (it->options[1] != 0)){
- /* Are we on the wrong bus/slot? */
- if(pci_device->bus->number != it->options[0] ||
- PCI_SLOT(pci_device->devfn) != it->options[1]){
- continue;
+ if(pci_device->vendor == PCI_VENDOR_ID_MEILHAUS){
+ for(i = 0; i < ME4000_BOARD_VERSIONS; i++){
+ if(me4000_boards[i].device_id == pci_device->device){
+ /* Was a particular bus/slot requested? */
+ if((it->options[0] != 0) || (it->options[1] != 0)){
+ /* Are we on the wrong bus/slot? */
+ if(pci_device->bus->number != it->options[0] ||
+ PCI_SLOT(pci_device->devfn) != it->options[1]){
+ continue;
+ }
+ }
+ dev->board_ptr = me4000_boards + i;
+ board = (me4000_board_t *) dev->board_ptr;
+ info->pci_dev_p = pci_device;
+ goto found;
+ }
}
- }
-
- dev->board_ptr = me4000_boards + i;
- board = (me4000_board_t *) dev->board_ptr;
- goto found;
}
- }
- }
}
printk(KERN_ERR"comedi%d: me4000: me4000_probe(): No supported board found (req. bus/slot : %d/%d)\n",
dev->minor, me4000_boards[i].name,
pci_device->bus->number, PCI_SLOT(pci_device->devfn));
- /* Allocate private memory */
- if(alloc_private(dev, sizeof(me4000_info_t)) < 0){
- pci_dev_put(pci_device);
- return -ENOMEM;
- }
-
/* Set data in device structure */
dev->board_name = board->name;
/* Enable PCI device */
result = pci_enable_device(pci_device);
if(result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot enable PCI device\n", dev->minor);
- pci_dev_put(pci_device);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot enable PCI device\n", dev->minor);
+ return result;
}
/* Request the PCI register regions */
result = pci_request_regions(pci_device, dev->board_name);
if (result < 0){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot request I/O regions\n", dev->minor);
- pci_dev_put(pci_device);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot request I/O regions\n", dev->minor);
+ return result;
}
-
/* Get the PCI base registers */
result = get_registers(dev, pci_device);
if(result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot get registers\n", dev->minor);
- pci_release_regions(pci_device);
- pci_disable_device(pci_device);
- pci_dev_put(pci_device);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot get registers\n", dev->minor);
+ return result;
}
- /* Initialize board info (sets info->pci_dev_p) */
+ /* Initialize board info */
result = init_board_info(dev, pci_device);
if (result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init baord info\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init baord info\n", dev->minor);
+ return result;
}
/* Init analog output context */
result = init_ao_context(dev);
if (result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init ao context\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init ao context\n", dev->minor);
+ return result;
}
/* Init analog input context */
result = init_ai_context(dev);
if (result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init ai context\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init ai context\n", dev->minor);
+ return result;
}
/* Init digital I/O context */
result = init_dio_context(dev);
if (result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init dio context\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init dio context\n", dev->minor);
+ return result;
}
/* Init counter context */
result = init_cnt_context(dev);
if (result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init cnt context\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Cannot init cnt context\n", dev->minor);
+ return result;
}
/* Download the xilinx firmware */
result = xilinx_download(dev);
if(result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Can't download firmware\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Can't download firmware\n", dev->minor);
+ return result;
}
/* Make a hardware reset */
result = reset_board(dev);
if(result){
- printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Can't reset board\n", dev->minor);
- return result;
+ printk(KERN_ERR"comedi%d: me4000: me4000_probe(): Can't reset board\n", dev->minor);
+ return result;
}
return 0;
static int init_board_info(comedi_device *dev, struct pci_dev *pci_dev_p){
int result;
- info->pci_dev_p = pci_dev_p;
CALL_PDEBUG("In init_board_info()\n");
static int me4000_detach(comedi_device *dev){
- CALL_PDEBUG("In me4000_detach()\n");
-
- if(info){
- if(info->pci_dev_p) {
- reset_board(dev);
- pci_release_regions(info->pci_dev_p);
- pci_dev_put(info->pci_dev_p);
+ CALL_PDEBUG("In me4000_detach()\n");
+
+ if(info){
+ if(info->pci_dev_p) {
+ reset_board(dev);
+ if(info->plx_regbase)
+ {
+ pci_release_regions(info->pci_dev_p);
+ pci_disable_device(info->pci_dev_p);
+ }
+ pci_dev_put(info->pci_dev_p);
+ }
}
- }
- return 0;
+ return 0;
}
unsigned int regbase_tmp;
int result, error, i;
+ // Allocate private memory
+ if(alloc_private(dev,sizeof(me_private_data_struct)) < 0)
+ {
+ return -ENOMEM;
+ }
+
//
// Probe the device to determine what device in the series it is.
//
dev->board_ptr = me_boards + i;
board = (me_board_struct *) dev->board_ptr;
+ dev_private->pci_device = pci_device;
goto found;
}
}
dev->minor, me_boards[i].name,
pci_device->bus->number, PCI_SLOT(pci_device->devfn));
- // Allocate private memory
-
- if(alloc_private(dev,sizeof(me_private_data_struct)) < 0)
- {
- pci_dev_put(pci_device);
- return -ENOMEM;
- }
-
// Enable PCI device
if(pci_enable_device(pci_device) < 0)
{
printk("comedi%d: Failed to enable PCI device\n", dev->minor);
- pci_dev_put(pci_device);
return -EIO;
}
if(pci_request_regions(pci_device, ME_DRIVER_NAME) < 0)
{
printk("comedi%d: I/O memory conflict\n", dev->minor);
- pci_dev_put(pci_device);
return -EIO;
}
// Set data in device structure
dev->board_name = board->name;
- dev_private->pci_device = pci_device;
// Read PLX register base address [PCI_BASE_ADDRESS #0].
plx_regbase_tmp = pci_resource_start(pci_device, 0);
plx_regbase_size_tmp = pci_resource_end(pci_device, 0) - plx_regbase_tmp + 1;
-
- if(plx_regbase_tmp & PCI_BASE_ADDRESS_SPACE)
- {
- printk("comedi%d: PLX space is not MEM\n", dev->minor);
- return -EIO;
- }
+ dev_private->plx_regbase = ioremap(plx_regbase_tmp, plx_regbase_size_tmp);
+ dev_private->plx_regbase_size = plx_regbase_size_tmp;
// Read Swap base address [PCI_BASE_ADDRESS #5].
}
/*----------------------------------------------------- Workaround end -----*/
- plx_regbase_tmp &= PCI_BASE_ADDRESS_MEM_MASK;
- dev_private->plx_regbase_size = plx_regbase_size_tmp;
- dev_private->plx_regbase = ioremap(plx_regbase_tmp, plx_regbase_size_tmp);
// Read Meilhaus register base address [PCI_BASE_ADDRESS #2].
me_regbase_tmp = pci_resource_start(pci_device, 2);
me_regbase_size_tmp = pci_resource_end(pci_device, 2) - me_regbase_tmp + 1;
-
- if(me_regbase_tmp & PCI_BASE_ADDRESS_SPACE)
- {
- printk("comedi%d: Meilhaus space is not MEM\n", dev->minor);
- return -EIO;
- }
-
- me_regbase_tmp &= PCI_BASE_ADDRESS_MEM_MASK;
dev_private->me_regbase_size = me_regbase_size_tmp;
dev_private->me_regbase = ioremap(me_regbase_tmp, me_regbase_size_tmp);
static int me_detach(comedi_device *dev)
{
- if(dev_private)
- {
- if (dev_private->me_regbase)
- {
- me_reset(dev);
- }
-
- if(dev_private->pci_device)
- {
- pci_release_regions(dev_private->pci_device);
- pci_disable_device(dev_private->pci_device);
- pci_dev_put(dev_private->pci_device);
- }
- }
-
- return 0;
+ if(dev_private)
+ {
+ if (dev_private->me_regbase)
+ {
+ me_reset(dev);
+ }
+ if(dev_private->pci_device)
+ {
+ if(dev_private->plx_regbase)
+ {
+ pci_release_regions(dev_private->pci_device);
+ pci_disable_device(dev_private->pci_device);
+ }
+ pci_dev_put(dev_private->pci_device);
+ }
+ }
+ return 0;
}
/*
* Probe the device to determine what device in the series it is.
*/
- for(pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); pcidev != NULL ;
+ for(pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL); pcidev != NULL ;
pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
- if (pcidev->vendor == PCI_VENDOR_ID_RTD) {
- if (it->options[0] || it->options[1]) {
- if (pcidev->bus->number == it->options[0]
- && PCI_SLOT(pcidev->devfn) == it->options[1]) {
- DPRINTK("rtd520: found bus=%d slot=%d\n",
- it->options[0], it->options[1]);
- break; /* found it */
+ if (pcidev->vendor == PCI_VENDOR_ID_RTD) {
+ if (it->options[0] || it->options[1]) {
+ if (pcidev->bus->number != it->options[0]
+ || PCI_SLOT(pcidev->devfn) != it->options[1]) {
+ continue;
+ }
+ }
+ break; /* found one */
}
- } else { /* specific board/slot not specified */
- break; /* found one */
- }
}
- }
-
if (!pcidev) {
- if (it->options[0] && it->options[1]) {
- printk ("No RTD card at bus=%d slot=%d.\n",
- it->options[0], it->options[1]);
- } else {
- printk ("No RTD card found.\n");
+ if (it->options[0] && it->options[1]) {
+ printk ("No RTD card at bus=%d slot=%d.\n",
+ it->options[0], it->options[1]);
+ } else {
+ printk ("No RTD card found.\n");
+ }
+ return -EIO;
+ }
+ devpriv->pci_dev = pcidev;
+ if (pcidev->device != thisboard->device_id) {
+ printk ("Found an RTD card, but not the supported type (%x).\n",
+ pcidev->device);
+ return -EIO;
}
- return -EIO;
- }
-
- if (pcidev->device != thisboard->device_id) {
- printk ("Found an RTD card, but not the supported type (%x).\n",
- pcidev->device);
- pci_dev_put(pcidev);
- return -EIO;
- }
dev->board_name = thisboard->name;
- if((ret=pci_enable_device(pcidev))<0){
- pci_dev_put(pcidev);
- return ret;
- }
- if((ret=pci_request_regions(pcidev, "rtd520"))<0){
- pci_dev_put(pcidev);
- return ret;
- }
-
- devpriv->pci_dev = pcidev;
+ if((ret=pci_enable_device(pcidev))<0){
+ return ret;
+ }
+ if((ret=pci_request_regions(pcidev, "rtd520"))<0){
+ return ret;
+ }
/*
* Initialize base addresses
s->n_chan=3;
s->maxdata=0xffff;
- /* check if our interrupt is available and get it */
- dev->irq = devpriv->pci_dev->irq;
- if (dev->irq > 0) {
- if((ret=comedi_request_irq (dev->irq, rtd_interrupt,
- SA_SHIRQ, "rtd520", dev)) < 0) {
- printk("Could not get interrupt! (%d)\n", dev->irq);
- dev->irq = 0;
- return ret;
+ /* check if our interrupt is available and get it */
+ if((ret=comedi_request_irq (devpriv->pci_dev->irq, rtd_interrupt,
+ SA_SHIRQ, "rtd520", dev)) < 0) {
+ printk("Could not get interrupt! (%d)\n", devpriv->pci_dev->irq);
+ return ret;
}
+ dev->irq = devpriv->pci_dev->irq;
printk("( irq=%d )", dev->irq);
- } else {
- printk("( NO IRQ )");
- }
#ifdef USE_DMA
if (dev->irq > 0) {
iounmap (devpriv->lcfg);
}
if (devpriv->pci_dev) {
- pci_release_regions(devpriv->pci_dev);
- pci_disable_device(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
+ if(devpriv->las0)
+ {
+ pci_release_regions(devpriv->pci_dev);
+ pci_disable_device(devpriv->pci_dev);
+ }
+ pci_dev_put(devpriv->pci_dev);
}
}
return -ENOMEM;
pdev=pci_get_device(PCI_VENDOR_ID_S626, PCI_DEVICE_ID_S626, NULL);
+ devpriv->pdev = pdev;
if(pdev==NULL) {
printk("s626_attach: Board not present!!!");
if((result = pci_enable_device(pdev))<0){
printk("s626_attach: pci_enable_device fails\n");
- pci_dev_put(pdev);
return -ENODEV;
}
if((result = pci_request_regions(pdev, "s626"))<0){
printk("s626_attach: pci_request_regions fails\n");
- pci_dev_put(pdev);
return -ENODEV;
}
- devpriv->pdev = pdev;
-
resourceStart=(uint64_t)pci_resource_start(devpriv->pdev,0);
devpriv->base_addr=ioremap(resourceStart, SIZEOF_ADDRESS_SPACE);
static int s626_detach(comedi_device *dev)
{
-
- if(devpriv){
- //stop ai_command
- devpriv->ai_cmd_running=0;
-
- if(devpriv->base_addr){
- //interrupt mask
- WR7146( P_IER, 0 ); // Disable master interrupt.
- WR7146( P_ISR, IRQ_GPIO3 | IRQ_RPS1 ); // Clear board's IRQ status
- // flag.
-
- // Disable the watchdog timer and battery charger.
- WriteMISC2(dev,0);
-
- // Close all interfaces on 7146 device.
- WR7146( P_MC1, MC1_SHUTDOWN );
- WR7146( P_ACON1, ACON1_BASE );
-
- CloseDMAB(dev,&devpriv->RPSBuf,DMABUF_SIZE);
- CloseDMAB(dev,&devpriv->ANABuf,DMABUF_SIZE);
- }
-
- if(dev->irq){
- comedi_free_irq(dev->irq,dev);
- }
-
- if(devpriv->base_addr){
- iounmap(devpriv->base_addr);
- }
-
- if(devpriv->pdev){
- pci_release_regions(devpriv->pdev);
- pci_disable_device(devpriv->pdev);
- pci_dev_put(devpriv->pdev);
- }
- }
-
- DEBUG("s626_detach: S626 detached!\n");
-
- return 0;
+ if(devpriv){
+ //stop ai_command
+ devpriv->ai_cmd_running=0;
+
+ if(devpriv->base_addr){
+ //interrupt mask
+ WR7146( P_IER, 0 ); // Disable master interrupt.
+ WR7146( P_ISR, IRQ_GPIO3 | IRQ_RPS1 ); // Clear board's IRQ status flag.
+
+ // Disable the watchdog timer and battery charger.
+ WriteMISC2(dev,0);
+
+ // Close all interfaces on 7146 device.
+ WR7146( P_MC1, MC1_SHUTDOWN );
+ WR7146( P_ACON1, ACON1_BASE );
+
+ CloseDMAB(dev,&devpriv->RPSBuf,DMABUF_SIZE);
+ CloseDMAB(dev,&devpriv->ANABuf,DMABUF_SIZE);
+ }
+
+ if(dev->irq){
+ comedi_free_irq(dev->irq,dev);
+ }
+
+ if(devpriv->base_addr){
+ iounmap(devpriv->base_addr);
+ }
+
+ if(devpriv->pdev){
+ if(devpriv->base_addr)
+ {
+ pci_release_regions(devpriv->pdev);
+ pci_disable_device(devpriv->pdev);
+ }
+ pci_dev_put(devpriv->pdev);
+ }
+ }
+
+ DEBUG("s626_detach: S626 detached!\n");
+
+ return 0;
}
/*
projects / comedi.git / commitdiff