pci550x.c

linux下面

			reg &= (~DA0_CTRL_TGEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_CGSL: /* DAC0 trigger gate source */
		 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_CGSL);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_CTRL_CGSL);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_CGEN: /* DAC0 software gate */
		 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_CGEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_CTRL_CGEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA0_FPCEN: /* DAC0 fast pacer clock */
		 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_FPCEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA0_CTRL_FPCEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA0_CTRL_W(reg);
		 break;

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

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

		case PCI550X_IOCT_DA1_CLOCK_SOURCE: /* DAC1 clock source  */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA1_CTRL_R(reg), treg = reg;
		 switch(arg) {
			case DAC1_SW_CLK:
				reg &= (~DA1_CTRL_S1S0);
				break;
			case DAC1_IP_CLK:
				reg &= (~DA1_CTRL_S1);
				reg |= (DA1_CTRL_S0);
				break;
			case DAC1_DA0_CLK:
				reg &= (~DA1_CTRL_S0);
				reg |= (DA1_CTRL_S1);
				break;
			default:
				ret = -EINVAL;
				break;
		 }
		 if (treg != reg) DA1_CTRL_W(reg);
		 break;

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

		case PCI550X_IOCT_DA1_CVEN: /* DAC1 Convert Enable */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA1_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= ( DA1_CTRL_CVEN);
		 else if (arg == PCI550X_DISABLE)
			reg &= (~DA1_CTRL_CVEN);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA1_CTRL_W(reg);
		 break;

		case PCI550X_IOCT_DA1_PDM: /* DAC1 Packed Data Mode */
		 if (dib->pdev->subsystem_device != PCI_SUBSYSTEM_ID_B) {
			ret = -ENODEV;
			break;
		 }
		 DA1_CTRL_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg &= (~DA1_CTRL_PDM);
		 else if (arg == PCI550X_DISABLE)
			reg |= ( DA1_CTRL_PDM);
		 else 
			ret = -EINVAL;
		 if (treg != reg) DA1_CTRL_W(reg);
		 break; 

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

		case PCI550X_IOCT_DAC1_DMA_BYTES: /* Set DMA Buffer Size */
		 DA1_CTRL_R(reg);
		 if (reg & DA1_CTRL_DMAEN)
			ret = -EBUSY;
		 else if ( (arg <= 0) || (arg > (PCI550X_MAX_DMA_BYTES)) ||
			(arg % 4) )
			ret = -EINVAL;
		 else {
			dib->dac1_dma_bytes = arg;
			dma.bus_addressf = (u_int32_t)dib->dac1_dma_handle0;
			dma.bus_addressf += (dib->dac1_dma_bytes - 4);
			DA1_MPR0L_W(dma.bus_addressh[0]);
			DA1_MPR0H_W(dma.bus_addressh[1]);
			dma.bus_addressf = (u_int32_t)dib->dac1_dma_handle1;
			dma.bus_addressf += (dib->dac1_dma_bytes - 4);
			DA1_MPR1L_W(dma.bus_addressh[0]);
			DA1_MPR1H_W(dma.bus_addressh[1]);

			dib->dac1_dma_mcr = PCI550X_MAX_DMA_BYTES - (arg>>2);
			DA1_MCR0_WORK_W(dib->dac1_dma_mcr);
			DA1_MCR0_W(dib->dac1_dma_mcr);
			DA1_MCR1_WORK_W(dib->dac1_dma_mcr);
			DA1_MCR1_W(dib->dac1_dma_mcr);

			DA1_STATUS_R(reg);
			reg &= (~(DA1_STATUS_MPRF0 | DA1_STATUS_MPRF1));
			DA1_STATUS_W(reg);
			dib->dac1_status = reg;
		 }
		 break;

		case PCI550X_IOCS_DAC1_PACER_CLOCK_RATE: /* DAC1 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;
			DA1_PACERL_WORK_W(u1.pacer_clockh[0]);
			DA1_PACERH_WORK_W(u1.pacer_clockh[1]);
			DA1_PACERL_W(u1.pacer_clockh[0]);
			DA1_PACERH_W(u1.pacer_clockh[1]);
		 }
		 break;

		case PCI550X_IOCS_AD_BLENGTH_WORK:
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_BLENGTH_WORK_W(reg);
		 break;

		case PCI550X_IOCS_AD_BLENGTH:
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_BLENGTH_W(reg);
		 break;

		case PCI550X_IOCS_AD_BRATE_WORK:
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_BRATE_WORK_W(reg);
		 break;

		case PCI550X_IOCS_AD_BRATE:
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_BRATE_W(reg);
		 break;

		case PCI550X_IOCS_AD_CCOUNT_WORK:
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_CCOUNT_WORK_W(reg);
		 break;

		case PCI550X_IOCS_AD_CCOUNT:
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) AD_BRATE_W(reg);
		 break;

		case PCI550X_IOCS_ADC_PACER_CLOCK_RATE: /* ADC 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_ADC_RATE) {
				ret = -EINVAL;
				break;
			} else if ( (u1.pacer_clockf <
					PCI550X_NOMINAL_ADC_RATE) &&
				(dib->brd_type < pci5503hr) ) {
				ret = -EINVAL;
				break;
			} else
				u1.pacer_clockf = -u1.pacer_clockf;
			AD_PACERL_WORK_W(u1.pacer_clockh[0]);
			AD_PACERH_WORK_W(u1.pacer_clockh[1]);
			AD_PACERL_W(u1.pacer_clockh[0]);
			AD_PACERH_W(u1.pacer_clockh[1]);
		 }
		 break;

		case PCI550X_IOCS_ADC_FAST_CLOCK_RATE: /* ADC 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_ADC_RATE << 2)) {
				ret = -EINVAL;
				break;
			} else if ( (u1.pacer_clockf <
					(PCI550X_NOMINAL_ADC_RATE << 2)) &&
				(dib->brd_type < pci5503hr)) {
				ret = -EINVAL;
				break;
			} else
				u1.pacer_clockf = (0x40 - u1.pacer_clockf);
			AD_FASTCLK_W(u1.pacer_clockf);

		 }
		 break;

		case PCI550X_IOCT_ADC_DMA_BYTES: /* Set DMA Buffer Size */
		 AD_CTRL_R(reg);
		 if (reg & AD_CTRL_DMAEN)
			ret = -EBUSY;
		 else if ( (arg <= 0) ||
			(arg > (PCI550X_MAX_DMA_BYTES)) || (arg % 4) )
			ret = -EINVAL;
		 else {
			dib->adc_dma_bytes = arg;
			dma.bus_addressf = (u_int32_t)dib->adc_dma_handle0;
			dma.bus_addressf += (dib->adc_dma_bytes - 4);
			AD_MPR0L_W(dma.bus_addressh[0]);
			AD_MPR0H_W(dma.bus_addressh[1]);
			dma.bus_addressf = (u_int32_t)dib->adc_dma_handle1;
			dma.bus_addressf += (dib->adc_dma_bytes - 4);
			AD_MPR1L_W(dma.bus_addressh[0]);
			AD_MPR1H_W(dma.bus_addressh[1]);

			dib->adc_dma_mcr = PCI550X_MAX_DMA_BYTES - (arg>>2);
			AD_MCR0_WORK_W(dib->adc_dma_mcr);
			AD_MCR0_W(dib->adc_dma_mcr);
			AD_MCR1_WORK_W(dib->adc_dma_mcr);
			AD_MCR1_W(dib->adc_dma_mcr);

			AD_STATUS_R(reg);
			reg |= (AD_STATUS_MPRF0 | AD_STATUS_MPRF1);
			AD_STATUS_W(reg);
			dib->adc_status = reg;
		 }
		 break;

		case PCI550X_IOCS_ADC_BURST_LENGTH: /* ADC Burst Length */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) {
			if ( (reg == 0) || (reg > 65536) ) {
				ret = -EINVAL;
				break;
			}
			AD_BLENGTH_WORK_W(-(reg % 65536));
			AD_BLENGTH_W(-(reg % 65536));
		 }
		 break;

		case PCI550X_IOCS_ADC_BURST_RATE: /* ADC Burst Rate */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) {
			if ( (reg == 0) || (reg > 65536) ) {
				ret = -EINVAL;
				break;
			}
			AD_BRATE_WORK_W(-(reg % 65536));
			AD_BRATE_W(-(reg % 65536));
		 }
		 break;

		case PCI550X_IOCS_ADC_CCOUNT: /* ADC Post Trigger Count */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) {
			if ( (reg == 0) || (reg > 65536) ) {
				ret = -EINVAL;
				break;
			}
			AD_CCOUNT_WORK_W((65536 - reg));
			AD_CCOUNT_W((65536 - reg));
		 }
		 break;

		/*********************************************************/
		/*************** CONTROL AND STATUS REGISTERS ************/
		/*********************************************************/

		case PCI550X_IOCS_TEST_REG: /* write Test Register */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) TEST_REG_W(reg);
		 break;

		case PCI550X_IOCG_TEST_REG: /* read Test Register */
		 TEST_REG_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

		case PCI550X_IOCT_TEST_REG_RST23: /* RST23 */
		 if (dib->brd_type != pci5500mf) {
			TEST_REG_R(reg), treg = reg;
			if (arg == PCI550X_SET)
				reg |= TEST_REG_RST23;
			else if (arg == PCI550X_RESET)
				reg &= (~(TEST_REG_RST23));
			else 
				ret = -EINVAL;
			if (treg != reg) TEST_REG_W(reg);
		  } else
			ret = -ENODEV;
		 break;

		case PCI550X_IOCT_TEST_REG_TCTR1: /* TCTR1 */
		 TEST_REG_R(reg), treg = reg;
		 if (arg == PCI550X_SET)
			reg |= TEST_REG_TCTR1;
		 else if (arg == PCI550X_RESET)
			reg &= (~(TEST_REG_TCTR1));
		 else 
			ret = -EINVAL;
		 if (treg != reg) TEST_REG_W(reg);
		 break;

		case PCI550X_IOCT_TEST_REG_TCTR0: /* TCTR0 */
		 TEST_REG_R(reg), treg = reg;
		 if (arg == PCI550X_SET)
			reg |= TEST_REG_TCTR0;
		 else if (arg == PCI550X_RESET)
			reg &= (~(TEST_REG_TCTR0));
		 else 
			ret = -EINVAL;
		 if (treg != reg) TEST_REG_W(reg);
		 break;

		case PCI550X_IOCT_TEST_REG_OVEN: /* OVEN */
		 TEST_REG_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= TEST_REG_OVEN;
		 else if (arg == PCI550X_DISABLE)
			reg &= (~(TEST_REG_OVEN));
		 else 
			ret = -EINVAL;
		 if (treg != reg) TEST_REG_W(reg);
		 break;

		case PCI550X_IOCT_TEST_REG_NEQ: /* NEQ */
		 if (dib->brd_type != pci5500mf) {
			TEST_REG_R(reg), treg = reg;
			if (arg == PCI550X_SET)
				reg |= TEST_REG_NEQ;
			else if (arg == PCI550X_RESET)
				reg &= (~(TEST_REG_NEQ));
			else 
				ret = -EINVAL;
			if (treg != reg) TEST_REG_W(reg);
		  } else
			ret = -ENODEV;
		 break;

		case PCI550X_IOCT_TEST_REG_TMDE: /* TMDE */
		 TEST_REG_R(reg), treg = reg;
		 if (arg == PCI550X_ENABLE)
			reg |= TEST_REG_TMDE;
		 else if (arg == PCI550X_DISABLE)
			reg &= (~(TEST_REG_TMDE));
		 else 
			ret = -EINVAL;
		 if (treg != reg) TEST_REG_W(reg);
		 break;

		case PCI550X_IOCT_TEST_REG_TSEL: /* TSEL */
		 TEST_REG_R(reg), treg = reg;
		 switch (arg) {
			case TEST_REG_TSEL_B00:
				reg &= (~(TEST_REG_TSEL_B1B0));
				break;
			case TEST_REG_TSEL_B01:
				reg |= (TEST_REG_TSEL_B0);
				reg &= (~(TEST_REG_TSEL_B1));
				break;
			case TEST_REG_TSEL_B10:
				reg &= (~(TEST_REG_TSEL_B0));
				reg |= (TEST_REG_TSEL_B1);
				break;
			case TEST_REG_TSEL_B11:
				reg |= (TEST_REG_TSEL_B0);
				reg |= (TEST_REG_TSEL_B1);
			default:
				ret = -EINVAL;
				break;
			}
		 if (treg != reg) TEST_REG_W(reg);
		 break;

		case PCI550X_IOCS_DIO_CTRL: /* write DIO Control Register */
		 ret = get_user(reg, (u_int32_t *)arg);
		 if (!ret) DIO_CTRL_W(reg);
		 break;

		case PCI550X_IOCG_DIO_CTRL: /* read DIO Control Register */
		 DIO_CTRL_R(reg);
		 ret = put_user(reg, (unsigned int *)arg);
		 break;

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