pci550x.c

linux下面

		case PCI550X_IOCT_DIO_DDC2: /* DIO Port 2 Direction Control */
		 if (dib->brd_type == pci5500mf) {
			ret = -ENODEV;
			break;
		 }
		 DIO_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_DIO_OUTPUT)
			reg |= DIO_CTRL_DDC2;
		 else if (arg == PCI550X_DIO_INPUT)
			reg &= (~DIO_CTRL_DDC2);
		 else
			ret = -EINVAL;
		 if (treg != reg) DIO_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DIO_DDC1: /* DIO Port 1 Direction Control */
		 DIO_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_DIO_OUTPUT)
			reg |= DIO_CTRL_DDC1;
		 else if (arg == PCI550X_DIO_INPUT)
			reg &= (~DIO_CTRL_DDC1);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DIO_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DIO_DDC0: /* DIO Port 0 Direction Control */
		 DIO_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_DIO_OUTPUT)
			reg |= DIO_CTRL_DDC0;
		 else if (arg == PCI550X_DIO_INPUT)
			reg &= (~DIO_CTRL_DDC0);
		 else 
			break;
		 if (treg != reg) DIO_CTRL_W(reg);
		 break;

		case PCI550X_IOCS_CNTR0_CTRL: /* write CNTR0 Control Reg */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) CNTR0_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_CNTR0_CTRL: /* read CNTR0 Control Reg */
		 CNTR0_CTRL_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_CNTR0_ENA: /* CNTR0 Enable */
		 CNTR0_CTRL_R(reg), treg = reg;
	 	 if (arg == PCI550X_ENABLE)
			if (reg & CNTR0_CTRL_ENA) {
				ret = -EBUSY;
				break;
			} else
				reg = ( CNTR0_CTRL_ENA |
					 CNTR0_CTRL_OVF | CNTR0_CTRL_ERR);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~CNTR0_CTRL_ENA);
	       	 else 
			ret = -EINVAL;
		 if (treg != reg) CNTR0_CTRL_W(reg);
		 break;

		case PCI550X_IOCS_CNTR1_CTRL: /* write CNTR1 Control Reg */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) CNTR1_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_CNTR1_CTRL: /* read CNTR1 Control Reg */
		 CNTR1_CTRL_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_CNTR1_ENA: /* CNTR1 Enable */
		 CNTR1_CTRL_R(reg), treg = reg;
	 	 if (arg == PCI550X_ENABLE)
			if (reg & CNTR1_CTRL_ENA) {
				ret = -EBUSY;
				break;
			} else
				reg = ( CNTR1_CTRL_ENA |
					 CNTR1_CTRL_OVF | CNTR1_CTRL_ERR);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~CNTR1_CTRL_ENA);
	       	 else 
			ret = -EINVAL;
		 if (treg != reg) CNTR1_CTRL_W(reg);
		 break;

		case PCI550X_IOCS_TMR0_CTRL: /* write TMR0 Control Reg */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) TMR0_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_TMR0_CTRL: /* read TMR0 Control Reg */
		 CNTR0_CTRL_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_TMR0_ENA: /* TIMER0  Enable */
		 AD_CTRL_R(reg);
		 if (reg & AD_CTRL_TOEN)
			ret = -EPERM;
	 	 else if (arg == PCI550X_ENABLE) {
			TMR0_CTRL_R(reg);
			if (reg & TMR0_CTRL_ENA)
				ret = -EBUSY;
			else
				reg = TMR0_CTRL_ENA;
		 		TMR0_CTRL_W(reg);
	 	 } else if (arg == PCI550X_DISABLE) {
			TMR0_CTRL_R(reg);
			reg &= (~TMR0_CTRL_ENA);
		 	TMR0_CTRL_W(reg);
	       	 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCS_TMR1_CTRL: /* write TIMER1 Control Reg */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) TMR1_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_TMR1_CTRL: /* read TIMER1 Control Reg */
		 CNTR1_CTRL_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_TMR1_ENA: /* TIMER1 Enable */
		 AD_CTRL_R(reg);
		 if (reg & AD_CTRL_TOEN)
			ret = -EPERM;
	 	 else if (arg == PCI550X_ENABLE) {
			TMR1_CTRL_R(reg);
			if (reg & TMR1_CTRL_ENA)
				ret = -EBUSY;
			else
				reg = TMR1_CTRL_ENA;
		 		TMR1_CTRL_W(reg);
	 	 } else if (arg == PCI550X_DISABLE) {
			TMR1_CTRL_R(reg);
			reg &= (~TMR1_CTRL_ENA);
		 	TMR1_CTRL_W(reg);
	       	 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCS_AD_STATUS: /* write ADC Status Register */
		 ret = get_user(reg, (unsigned int *)arg);
		 if (!ret) AD_STATUS_W(reg);
		 break;

		case PCI550X_IOCG_AD_STATUS: /* read ADC Status Register */
		 AD_STATUS_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_AD_STATUS_FFEN: /* ADC FIFO Enable */
		 AD_STATUS_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_STATUS_FFEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_STATUS_FFEN);
		 else {
			ret = -EINVAL;
			break;
		 }
		 if (treg != reg) AD_STATUS_W(reg);
		 break; 

		case PCI550X_IOC_AD_STATUS_CONV: /* start an A/D conversion */
		 AD_CTRL_R(reg);
		 if (!(reg & AD_CTRL_CVEN))
			ret = -EPERM;
		 else {
			 AD_STATUS_R(reg);
			 if (!(reg & AD_STATUS_READY))
				ret = -EBUSY;
			 else if (!(reg & AD_STATUS_GATE))
				ret = -EAGAIN;
		 	else 
				AD_STATUS_W(reg);
		 }
		 break;

		case PCI550X_IOCS_DA0_STATUS: /* write DAC0 Status Register */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 ret = get_user(reg, (unsigned int *)arg);
		 if (!ret) DA0_STATUS_W(reg);
		 break;

		case PCI550X_IOCG_DA0_STATUS: /* read DAC0 Status Register */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_STATUS_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_DA0_STATUS_FFEN: /* DAC0 FIFO Enable */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_STATUS_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA0_STATUS_FFEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_STATUS_FFEN);
		 else
			ret = -EINVAL;
		 if (treg != reg) DA0_STATUS_W(reg);
		 break; 

		case PCI550X_IOC_DA0_STATUS_CONV: /* start DAC0 conversion */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg);
	 	 if (!(reg & DA0_CTRL_CVEN))
			ret = -EPERM;
		 else {
			DA0_STATUS_R(reg);
			if (!(reg & DA0_STATUS_READY))
				ret = -EBUSY;
			else if (!(reg & DA0_STATUS_GATE))
				ret = -EAGAIN;
			else 
				DA0_STATUS_W(reg);
	 	 }
		 break;

		case PCI550X_IOCS_DA1_STATUS: /* write DAC1 Status Register */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 ret = get_user(reg, (unsigned int *)arg);
		 if (!ret) DA1_STATUS_W(reg);
		 break;

		case PCI550X_IOCG_DA1_STATUS: /* read DAC1 Status Register */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA1_STATUS_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_DA1_STATUS_FFEN: /* DAC1 FIFO Enable */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA1_STATUS_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA1_STATUS_FFEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA1_STATUS_FFEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA1_STATUS_W(reg);
		 break; 

		case PCI550X_IOC_DA1_STATUS_CONV: /* start DAC1 conversion */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA1_CTRL_R(reg);
	 	 if (!(reg & DA1_CTRL_CVEN))
			ret = -EPERM;
		 else {
			DA1_STATUS_R(reg);
			if (!(reg & DA1_STATUS_READY))
				ret = -EBUSY;
			else 
				DA1_STATUS_W(reg);
	 	 }
		 break;

		/*********************************************************/
		/******** TIME DEPENDENT TIMER/COUNTER REGISTERS *********/
		/*********************************************************/
		case PCI550X_IOCS_CNTR0_WORK: /* write CNTR0_WORK */
		 CNTR0_CTRL_R(reg);
		 if (reg & CNTR0_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) CNTR0_WORK_W(reg);
		 }
		 break;

		case PCI550X_IOCG_CNTR0_WORK: /* read CNTR0_WORK */
		 CNTR0_WORK_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_CNTR0: /* write CNTR0 */
		 CNTR0_CTRL_R(reg);
		 if (reg & CNTR0_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) CNTR0_W(reg);
		 }
		 break;

		case PCI550X_IOCG_CNTR0: /* read CNTR0 */
		 CNTR0_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_CNTR1_WORK: /* write CNTR1_WORK */
		 CNTR1_CTRL_R(reg);
		 if (reg & CNTR1_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) CNTR1_WORK_W(reg);
		 }
		 break;

		case PCI550X_IOCG_CNTR1_WORK: /* read CNTR1_WORK */
		 CNTR1_WORK_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_CNTR1: /* write CNTR1 */
		 CNTR1_CTRL_R(reg);
		 if (reg & CNTR1_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) CNTR1_W(reg);
		 }
		 break;

		case PCI550X_IOCG_CNTR1: /* read CNTR1 */
		 CNTR1_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_TMR0_WORK: /* write TMR0_WORK */
		 TMR0_CTRL_R(reg);
		 if (reg & TMR0_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) TMR0_WORK_W(reg);
		 }
		 break;

		case PCI550X_IOCG_TMR0_WORK: /* read TMR0_WORK */
		 TMR0_WORK_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_TMR0: /* write TMR0 */
		 TMR0_CTRL_R(reg);
		 if (reg & TMR0_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) TMR0_W(reg);
		 }
		 break;

		case PCI550X_IOCG_TMR0: /* read TMR0 */
		 TMR0_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_TMR1_WORK: /* write TMR1_WORK */
		 TMR1_CTRL_R(reg);
		 if (reg & TMR1_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) TMR1_WORK_W(reg);
		 }
		 break;

		case PCI550X_IOCG_TMR1_WORK: /* read TMR1_WORK */
		 TMR1_WORK_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_TMR1: /* write TMR1 */
		 TMR1_CTRL_R(reg);
		 if (reg & TMR1_CTRL_ENA)
			ret = -EBUSY;
		 else {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) TMR1_W(reg);
		 }
		 break;

		case PCI550X_IOCG_TMR1: /* read TMR1 */
		 TMR1_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_OVEN_WORK: /* write OVEN WORK */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) OVEN_WORK_W(reg);
		 break;

		case PCI550X_IOCG_OVEN_WORK: /* read OVEN WORK */
		 OVEN_WORK_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCS_OVEN_TMR: /* write OVEN TMR */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) OVEN_TMR_W(reg);
		 break;

		case PCI550X_IOCG_OVEN_TMR: /* read OVEN TMR */
		 OVEN_TMR_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		default: /* redundant, as cmd was checked against MAXNR */

		 ret = (-ENOTTY);
	}

	spin_unlock(&dib->reg_lock);
	return(ret);
}

/*
 * pci550x_init_one - init each board as we find them
 */
static int __init pci550x_init_one(struct pci_dev *pdev,
                                   const struct pci_device_id *ent)
{
	pci550x_dib *dib; /* dib pointer */
        unsigned long addr;                                                     
	size_t len;
	void *membase;
	int rc;

	/* enable the device */
	if (pci_enable_device(pdev))
		return(-EIO);

	/* set bus master enable */
	pci_set_master(pdev);

        addr = pci_resource_start(pdev, 0);
        if (!addr) {
		printk(KERN_ERR PCI550X_PFX "In function pci550x_init_one:\n"
		"pci_resource_start() failure - PCI Region 0 unavailable\n");
		return(-ENODEV);
        }

	len = pci_resource_len(pdev, 0);
	if (!len) {
		printk(KERN_ERR PCI550X_PFX "In function pci550x_init_one:\n"
		"pci_resource_len() reports PCI Region 0 of size 0 bytes\n");
		return(-ENODEV);
	}

        if (!request_mem_region (addr, len, driver_name)) {
		printk(KERN_ERR PCI550X_PFX "In function pci550x_init_one:\n"
		"pci_resource_len() reports PCI Region 0 unavailable\n");
                return(-ENODEV);
        }

	membase = ioremap(addr,len);
	if (!membase) {
		printk(KERN_ERR PCI550X_PFX "In function pci550x_init_one:\n"
		"ioremap() failed to map PCI Region 0\n");
		release_mem_region(addr, len);
		return(-ENODEV);
	}

	/* allocate the device information block (dib) */
	dib = (pci550x_dib*)kmalloc(sizeof(pci550x_dib), GFP_KERNEL);
	if (dib == NULL) {
		printk(KERN_ERR PCI550X_PFX "In function pci550x_init_one:\n"
		"kmalloc() failure - unable to allocate memory\n");
		iounmap(membase);
		release_mem_region(addr, len);
		return(-ENOMEM);
	}

	/* fill in the dib */
	memset((void *)dib, 0, sizeof(pci550x_dib));
	dib->brd_name = brd_names[ent->driver_data];
	pci_read_config_byte(pdev, PCI_REVISION_ID, &dib->brd_rev);
	d