pci550x.c

linux下面

			ret = -EINVAL;
		 break;

		case PCI550X_IOCS_DIO_1: /* DIO Port 1 Output */
		 DIO_CTRL_R(reg);
		 if (reg & DIO_CTRL_DDC1) {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) DIO_1_W(reg);
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCG_DIO_0: /* DIO Port 0 Input */
		 DIO_CTRL_R(reg);
		 if (!(reg & DIO_CTRL_DDC0)) {
			DIO_0_R(reg);
			ret = put_user(reg, (u_int32_t *)arg);
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCG_DIO_1: /* DIO Port 1 Input */
		 DIO_CTRL_R(reg);
		 if (!(reg & DIO_CTRL_DDC1)) {
			DIO_1_R(reg);
			ret = put_user(reg, (u_int32_t *)arg);
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCS_DIO_16: /* DIO Port 0/1 Output */
		 DIO_CTRL_R(reg);
		 if ( (reg & DIO_CTRL_DDC0) &&
				(reg & DIO_CTRL_DDC1) ) {
			ret = get_user(reg, (u_int32_t *)arg);
			if (!ret) DIO_16_W(reg);
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCG_DIO_16: /* DIO Port 0/1 Input */
		 DIO_CTRL_R(reg);
		 if (! ( (reg & DIO_CTRL_DDC0) ||
				(reg & DIO_CTRL_DDC1) ) ) {
			DIO_16_R(reg);
			ret = put_user(reg, (u_int32_t *)arg);
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCS_AD_CTRL: /* write ADC Control Register */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_AD_CTRL: /* read ADC Control Register */
		 AD_CTRL_R(reg);
		 ret = put_user(reg, (u_int32_t *)arg);
		 break;

		case PCI550X_IOCT_ADC_CLOCK_SOURCE: /* ADC clock source  */
		 AD_CTRL_R(reg), treg = reg;
		 switch(arg) {
			case ADC_SW_CLK:
				reg &= (~AD_CTRL_S1S0);
				break;
			case ADC_IP_CLK:
				reg &= (~AD_CTRL_S1);
				reg |= (AD_CTRL_S0);
				break;
			case ADC_EXF_CLK:
				reg &= (~AD_CTRL_S0);
				reg |= (AD_CTRL_S1);
				break;
			case ADC_EXR_CLK:
				reg |= (AD_CTRL_S1S0);
				break;
			default:
				ret = -EINVAL;
				break;
		 }
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_TOEN: /* ADC External Trigger Output */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_TOEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_TOEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break; 

		case PCI550X_IOCT_ADC_COEN: /* ADC External Clock Output */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_COEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_COEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break; 

		case PCI550X_IOCT_ADC_ATEN: /* ADC About Trigger Mode */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_ATEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_ATEN);
		 else
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_BMDE: /* ADC Burst Mode */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_BMDE);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_BMDE);
		 else
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_PDM: /* ADC Packed Data Mode */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg &= (~AD_CTRL_PDM);
		 else if (arg == PCI550X_DISABLE)
			reg |= ( AD_CTRL_PDM);
		 else
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break; 

		case PCI550X_IOCT_ADC_DMAEN: /* ADC DMA Enable */
		 if (arg == PCI550X_ENABLE) {
			AD_CTRL_R(reg);
			if (reg & AD_CTRL_DMAEN)
				ret = -EBUSY;
			else {
				reg |= AD_CTRL_DMAEN;
				AD_CTRL_W(reg);
			}
		 } else if (arg == PCI550X_DISABLE) {
			AD_CTRL_R(reg);
			if (reg & AD_CTRL_DMAEN) {
				reg &= (~AD_CTRL_DMAEN);
			 	AD_CTRL_W(reg);
				for (i = 0; i < 500; i++) {
					AD_CTRL_R(reg);
					if (!(reg & AD_CTRL_DMAEN)) break;
					udelay(100);
				}
			if (reg & AD_CTRL_DMAEN)
				ret = -EIO;
			}
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCT_ADC_CVEN: /* ADC Convert Enable */
		 if (arg == PCI550X_ENABLE) {
		 	AD_CTRL_R(reg);
			if (reg & AD_CTRL_CVEN)
				ret = -EBUSY;
			else {
				reg |= AD_CTRL_CVEN;
		 		AD_CTRL_W(reg);
			}
		 } else if (arg == PCI550X_DISABLE) {
		 	AD_CTRL_R(reg);
			reg &= (~AD_CTRL_CVEN);
		 	AD_CTRL_W(reg);
			udelay(10);
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCT_ADC_TGPL: /* ADC ADTGIN input polarity */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_TGPL);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_TGPL);
		 else 
			ret = -EINVAL;
		 if (treg!= reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_TGSL: /* ADC ADTGIN input mode */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_TGSL);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_TGSL);
		 else
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_TGEN: /* ADC ADTGIN enable */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_TGEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_TGEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_CGSL: /* ADC pacer clock trig/gate */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_CGSL);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_CGSL);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_CGEN: /* ADC pacer clock enable */
		 AD_CTRL_R(reg), treg = reg;
		 if (reg & AD_CTRL_CGSL)
			ret = -EPERM;
		 else if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_CGEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_CGEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_EMXEN: /* ADC expansion inputs enable */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_EMXEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_EMXEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_ADC_FPCEN: /* ADC high resolution pacer */
		 AD_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( AD_CTRL_FPCEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~AD_CTRL_FPCEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) AD_CTRL_W(reg);
		 break;

		case PCI550X_IOCS_DA0_CTRL: /* write DAC0 Control Register */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_DA0_CTRL: /* read DAC0 Control Register */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg);
		 ret = put_user(reg, (u_int32_t *)arg);
		 break;

		case PCI550X_IOCT_DA0_CLOCK_SOURCE: /* DAC0 clock source  */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 switch(arg) {
			case DAC0_SW_CLK:
				reg &= (~DA0_CTRL_S1S0);
				break;
			case DAC0_IP_CLK:
				reg &= (~DA0_CTRL_S1);
				reg |= (DA0_CTRL_S0);
				break;
			case DAC0_EXF_CLK:
				reg &= (~DA0_CTRL_S0);
				reg |= (DA0_CTRL_S1);
				break;
			case DAC0_EXR_CLK:
				reg |= (DA0_CTRL_S1S0);
				break;
			default:
				ret = -EINVAL;
				break;
		 }
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_UB: /* enable/disable BIPOLAR output */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg &= (~DA0_CTRL_UB);
		 else if (arg == PCI550X_DISABLE)
			reg |= ( DA0_CTRL_UB);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break; 

		case PCI550X_IOCT_DA0_CVEN: /* DAC0 Convert Enable */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA0_CTRL_CVEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_CTRL_CVEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_PDM: /* DAC0 Packed Data Mode */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg &= (~DA0_CTRL_PDM);
		 else if (arg == PCI550X_DISABLE)
			reg |= ( DA0_CTRL_PDM);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break; 

		case PCI550X_IOCT_DA0_DMAEN: /* DAC0 DMA Enable */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 if (arg == PCI550X_ENABLE) {
			DA0_CTRL_R(reg);
			if (reg & DA0_CTRL_DMAEN)
				ret = -EBUSY;
			else {
				reg |= DA0_CTRL_DMAEN;
				DA0_CTRL_W(reg);
			}
		 } else if (arg == PCI550X_DISABLE) {
			DA0_CTRL_R(reg);
			if (reg & DA0_CTRL_DMAEN) {
				reg &= (~DA0_CTRL_DMAEN);
			 	DA0_CTRL_W(reg);
				for (i = 0; i < 500; i++) {
					DA0_CTRL_R(reg);
					if (!(reg & DA0_CTRL_DMAEN)) break;
					udelay(100);
				}
			}
			if (reg & DA0_CTRL_DMAEN)
				ret = -EIO;
		 } else
			ret = -EINVAL;
		 break;

		case PCI550X_IOCS_DAC0_PACER_CLOCK_RATE: /* DAC0 Pacer Clock */
		 ret = get_user(u1.pacer_clockf, (s32 *)arg);
		 if (!ret) {
			if (u1.pacer_clockf == 0) {
				ret = -EINVAL;
				break;
			} else if (u1.pacer_clockf == 0xffffffff)
				u1.pacer_clockf = 0;
			else if (u1.pacer_clockf <
					 PCI550X_FAST_DAC_RATE) {
				ret = -EINVAL;
				break;
			} else if ( (u1.pacer_clockf <
					PCI550X_NOMINAL_DAC_RATE) &&
				(dib->brd_type < pci5503hr) ) {
				ret = -EINVAL;
				break;
			} else
				u1.pacer_clockf = -u1.pacer_clockf;
			DA0_PACERL_WORK_W(u1.pacer_clockh[0]);
			DA0_PACERH_WORK_W(u1.pacer_clockh[1]);
			DA0_PACERL_W(u1.pacer_clockh[0]);
			DA0_PACERH_W(u1.pacer_clockh[1]);
		 }
		 break;

		case PCI550X_IOCS_DAC0_FAST_CLOCK_RATE: /* DAC0 FAST Clock */
		 ret = get_user(u1.pacer_clockf, (s32 *)arg);
		 if (!ret) {
			if (u1.pacer_clockf == 0) {
				ret = -EINVAL;
				break;
			} else if (u1.pacer_clockf <
					 (PCI550X_FAST_DAC_RATE << 2)) {
				ret = -EINVAL;
				break;
			} else if ( (u1.pacer_clockf <
					(PCI550X_NOMINAL_DAC_RATE << 2)) &&
				(dib->brd_type < pci5503hr)) {
				ret = -EINVAL;
				break;
			} else
				u1.pacer_clockf = (0x40 - u1.pacer_clockf);
			DA0_FASTCLK_W(u1.pacer_clockf);

		 }
		 break;

		case PCI550X_IOCT_DAC0_DMA_BYTES: /* Set DAC0 DMA Buf Size */
		 DA0_CTRL_R(reg);
		 if (reg & DA0_CTRL_DMAEN)
			ret = -EBUSY;
		 else if ( (arg <= 0) || (arg > (PCI550X_MAX_DMA_BYTES)) ||
			(arg % 4) )
			ret = -EINVAL;
		 else {
			dib->dac0_dma_bytes = arg;
			dma.bus_addressf = (u_int32_t)dib->dac0_dma_handle0;
			dma.bus_addressf += (dib->dac0_dma_bytes - 4);
			DA0_MPR0L_W(dma.bus_addressh[0]);
			DA0_MPR0H_W(dma.bus_addressh[1]);
			dma.bus_addressf = (u_int32_t)dib->dac0_dma_handle1;
			dma.bus_addressf += (dib->dac0_dma_bytes - 4);
			DA0_MPR1L_W(dma.bus_addressh[0]);
			DA0_MPR1H_W(dma.bus_addressh[1]);

			dib->dac0_dma_mcr = PCI550X_MAX_DMA_BYTES - (arg>>2);
			DA0_MCR0_WORK_W(dib->dac0_dma_mcr);
			DA0_MCR0_W(dib->dac0_dma_mcr);
			DA0_MCR1_WORK_W(dib->dac0_dma_mcr);
			DA0_MCR1_W(dib->dac0_dma_mcr);

			DA0_STATUS_R(reg);
			reg &= (~(DA0_STATUS_MPRF0 | DA0_STATUS_MPRF1));
			DA0_STATUS_W(reg);
			dib->dac0_status = reg;
		 }
		 break;

		case PCI550X_IOCT_DA0_TGPL: /* DAC0 DATGIN */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA0_CTRL_TGPL);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_CTRL_TGPL);
		 else {
			ret = -EINVAL;
			break;
		 }
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_TGSL: /* DAC0 DATGIN input mode */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA0_CTRL_TGSL);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_CTRL_TGSL);
		 else {
			ret = -EINVAL;
			break;
		 }
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_TGEN: /* DAC0 DATGIN enable */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA0_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA0_CTRL_TGEN);
		 else if (arg == PCI550X_DISABLE)