/* Device driver for Meilhaus ME-DUMMY devices. * =========================================== * * Copyright (C) 2005 Meilhaus Electronic GmbH (support@meilhaus.de) * * This file is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * User application could also include the kernel header files. But the * real kernel functions are protected by #ifdef __KERNEL__. */ #ifndef __KERNEL__ # define __KERNEL__ #endif /* * This must be defined before module.h is included. Not needed, when * it is a built in driver. */ #ifndef MODULE # define MODULE #endif #include #include #include "meerror.h" #include "meinternal.h" #include "meids.h" #include "mecommon.h" #include "medevice.h" #include "medebug.h" #include "medummy.h" static int medummy_io_irq_start(me_device_t * device, struct file *filep, int subdevice, int channel, int irq_source, int irq_edge, int irq_arg, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_irq_wait(me_device_t * device, struct file *filep, int subdevice, int channel, int *irq_count, int *value, int timeout, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_irq_stop(me_device_t * device, struct file *filep, int subdevice, int channel, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_reset_device(me_device_t * device, struct file *filep, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_reset_subdevice(me_device_t * device, struct file *filep, int subdevice, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_single_config(me_device_t * device, struct file *filep, int subdevice, int channel, int single_config, int ref, int trig_chan, int trig_type, int trig_edge, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_single_read(me_device_t * device, struct file *filep, int subdevice, int channel, int *value, int time_out, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_single_write(me_device_t * device, struct file *filep, int subdevice, int channel, int value, int time_out, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_config(me_device_t * device, struct file *filep, int subdevice, meIOStreamConfig_t * config_list, int count, meIOStreamTrigger_t * trigger, int fifo_irq_threshold, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_new_values(me_device_t * device, struct file *filep, int subdevice, int timeout, int *count, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_read(me_device_t * device, struct file *filep, int subdevice, int read_mode, int *values, int *count, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_start(me_device_t * device, struct file *filep, int subdevice, int start_mode, int time_out, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_status(me_device_t * device, struct file *filep, int subdevice, int wait, int *status, int *values, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_stop(me_device_t * device, struct file *filep, int subdevice, int stop_mode, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_io_stream_write(me_device_t * device, struct file *filep, int subdevice, int write_mode, int *values, int *count, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_lock_device(me_device_t * device, struct file *filep, int lock, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_lock_subdevice(me_device_t * device, struct file *filep, int subdevice, int lock, int flags) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_description_device(me_device_t * device, char **description) { medummy_device_t *instance = (medummy_device_t *) device; PDEBUG("executed.\n"); // if (instance->magic != MEDUMMY_MAGIC_NUMBER) // { // PERROR("Wrong magic number.\n"); // return ME_ERRNO_INTERNAL; // } switch (instance->device_id) { case PCI_DEVICE_ID_MEILHAUS_ME1000: case PCI_DEVICE_ID_MEILHAUS_ME1000_A: case PCI_DEVICE_ID_MEILHAUS_ME1000_B: *description = ME1000_DESCRIPTION_DEVICE_ME1000; break; case PCI_DEVICE_ID_MEILHAUS_ME1400: *description = ME1400_DESCRIPTION_DEVICE_ME1400; break; case PCI_DEVICE_ID_MEILHAUS_ME140A: *description = ME1400_DESCRIPTION_DEVICE_ME1400A; break; case PCI_DEVICE_ID_MEILHAUS_ME140B: *description = ME1400_DESCRIPTION_DEVICE_ME1400B; break; case PCI_DEVICE_ID_MEILHAUS_ME14E0: *description = ME1400_DESCRIPTION_DEVICE_ME1400E; break; case PCI_DEVICE_ID_MEILHAUS_ME14EA: *description = ME1400_DESCRIPTION_DEVICE_ME1400EA; break; case PCI_DEVICE_ID_MEILHAUS_ME14EB: *description = ME1400_DESCRIPTION_DEVICE_ME1400EB; break; case PCI_DEVICE_ID_MEILHAUS_ME140C: *description = ME1400_DESCRIPTION_DEVICE_ME1400C; break; case PCI_DEVICE_ID_MEILHAUS_ME140D: *description = ME1400_DESCRIPTION_DEVICE_ME1400D; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_4U: *description = ME1600_DESCRIPTION_DEVICE_ME16004U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_8U: *description = ME1600_DESCRIPTION_DEVICE_ME16008U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_12U: *description = ME1600_DESCRIPTION_DEVICE_ME160012U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_16U: *description = ME1600_DESCRIPTION_DEVICE_ME160016U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_16U_8I: *description = ME1600_DESCRIPTION_DEVICE_ME160016U8I; break; case PCI_DEVICE_ID_MEILHAUS_ME4610: *description = ME4600_DESCRIPTION_DEVICE_ME4610; break; case PCI_DEVICE_ID_MEILHAUS_ME4650: *description = ME4600_DESCRIPTION_DEVICE_ME4650; break; case PCI_DEVICE_ID_MEILHAUS_ME4660: *description = ME4600_DESCRIPTION_DEVICE_ME4660; break; case PCI_DEVICE_ID_MEILHAUS_ME4660I: *description = ME4600_DESCRIPTION_DEVICE_ME4660I; break; case PCI_DEVICE_ID_MEILHAUS_ME4660S: *description = ME4600_DESCRIPTION_DEVICE_ME4660S; break; case PCI_DEVICE_ID_MEILHAUS_ME4660IS: *description = ME4600_DESCRIPTION_DEVICE_ME4660IS; break; case PCI_DEVICE_ID_MEILHAUS_ME4670: *description = ME4600_DESCRIPTION_DEVICE_ME4670; break; case PCI_DEVICE_ID_MEILHAUS_ME4670I: *description = ME4600_DESCRIPTION_DEVICE_ME4670I; break; case PCI_DEVICE_ID_MEILHAUS_ME4670S: *description = ME4600_DESCRIPTION_DEVICE_ME4670S; break; case PCI_DEVICE_ID_MEILHAUS_ME4670IS: *description = ME4600_DESCRIPTION_DEVICE_ME4670IS; break; case PCI_DEVICE_ID_MEILHAUS_ME4680: *description = ME4600_DESCRIPTION_DEVICE_ME4680; break; case PCI_DEVICE_ID_MEILHAUS_ME4680I: *description = ME4600_DESCRIPTION_DEVICE_ME4680I; break; case PCI_DEVICE_ID_MEILHAUS_ME4680S: *description = ME4600_DESCRIPTION_DEVICE_ME4680S; break; case PCI_DEVICE_ID_MEILHAUS_ME4680IS: *description = ME4600_DESCRIPTION_DEVICE_ME4680IS; break; case PCI_DEVICE_ID_MEILHAUS_ME6004: *description = ME6000_DESCRIPTION_DEVICE_ME60004; break; case PCI_DEVICE_ID_MEILHAUS_ME6008: *description = ME6000_DESCRIPTION_DEVICE_ME60008; break; case PCI_DEVICE_ID_MEILHAUS_ME600F: *description = ME6000_DESCRIPTION_DEVICE_ME600016; break; case PCI_DEVICE_ID_MEILHAUS_ME6014: *description = ME6000_DESCRIPTION_DEVICE_ME6000I4; break; case PCI_DEVICE_ID_MEILHAUS_ME6018: *description = ME6000_DESCRIPTION_DEVICE_ME6000I8; break; case PCI_DEVICE_ID_MEILHAUS_ME601F: *description = ME6000_DESCRIPTION_DEVICE_ME6000I16; break; case PCI_DEVICE_ID_MEILHAUS_ME6034: *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE4; break; case PCI_DEVICE_ID_MEILHAUS_ME6038: *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE8; break; case PCI_DEVICE_ID_MEILHAUS_ME603F: *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE16; break; case PCI_DEVICE_ID_MEILHAUS_ME6104: *description = ME6000_DESCRIPTION_DEVICE_ME61004; break; case PCI_DEVICE_ID_MEILHAUS_ME6108: *description = ME6000_DESCRIPTION_DEVICE_ME61008; break; case PCI_DEVICE_ID_MEILHAUS_ME610F: *description = ME6000_DESCRIPTION_DEVICE_ME610016; break; case PCI_DEVICE_ID_MEILHAUS_ME6114: *description = ME6000_DESCRIPTION_DEVICE_ME6100I4; break; case PCI_DEVICE_ID_MEILHAUS_ME6118: *description = ME6000_DESCRIPTION_DEVICE_ME6100I8; break; case PCI_DEVICE_ID_MEILHAUS_ME611F: *description = ME6000_DESCRIPTION_DEVICE_ME6100I16; break; case PCI_DEVICE_ID_MEILHAUS_ME6134: *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE4; break; case PCI_DEVICE_ID_MEILHAUS_ME6138: *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE8; break; case PCI_DEVICE_ID_MEILHAUS_ME613F: *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE16; break; case PCI_DEVICE_ID_MEILHAUS_ME6044: *description = ME6000_DESCRIPTION_DEVICE_ME60004DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6048: *description = ME6000_DESCRIPTION_DEVICE_ME60008DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME604F: *description = ME6000_DESCRIPTION_DEVICE_ME600016DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6054: *description = ME6000_DESCRIPTION_DEVICE_ME6000I4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6058: *description = ME6000_DESCRIPTION_DEVICE_ME6000I8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME605F: *description = ME6000_DESCRIPTION_DEVICE_ME6000I16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6074: *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6078: *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME607F: *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6144: *description = ME6000_DESCRIPTION_DEVICE_ME61004DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6148: *description = ME6000_DESCRIPTION_DEVICE_ME61008DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME614F: *description = ME6000_DESCRIPTION_DEVICE_ME610016DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6154: *description = ME6000_DESCRIPTION_DEVICE_ME6100I4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6158: *description = ME6000_DESCRIPTION_DEVICE_ME6100I8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME615F: *description = ME6000_DESCRIPTION_DEVICE_ME6100I16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6174: *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6178: *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME617F: *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6259: *description = ME6000_DESCRIPTION_DEVICE_ME6200I9DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6359: *description = ME6000_DESCRIPTION_DEVICE_ME6300I9DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME0630: *description = ME0600_DESCRIPTION_DEVICE_ME0630; break; case PCI_DEVICE_ID_MEILHAUS_ME8100_A: *description = ME8100_DESCRIPTION_DEVICE_ME8100A; break; case PCI_DEVICE_ID_MEILHAUS_ME8100_B: *description = ME8100_DESCRIPTION_DEVICE_ME8100B; break; case PCI_DEVICE_ID_MEILHAUS_ME0940: *description = ME0900_DESCRIPTION_DEVICE_ME0940; break; case PCI_DEVICE_ID_MEILHAUS_ME0950: *description = ME0900_DESCRIPTION_DEVICE_ME0950; break; case PCI_DEVICE_ID_MEILHAUS_ME0960: *description = ME0900_DESCRIPTION_DEVICE_ME0960; break; /* case USB_DEVICE_ID_MEPHISTO_S1: *description = MEPHISTO_S1_DESCRIPTION_DEVICE; break; */ default: *description = EMPTY_DESCRIPTION_DEVICE; PERROR("Invalid device id in device info.\n"); return ME_ERRNO_INTERNAL; } return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_info_device(me_device_t * device, int *vendor_id, int *device_id, int *serial_no, int *bus_type, int *bus_no, int *dev_no, int *func_no, int *plugged) { medummy_device_t *instance = (medummy_device_t *) device; PDEBUG("executed.\n"); // if (instance->magic != MEDUMMY_MAGIC_NUMBER) // { // PERROR("Wrong magic number.\n"); // return ME_ERRNO_INTERNAL; // } *vendor_id = instance->vendor_id; *device_id = instance->device_id; *serial_no = instance->serial_no; *bus_type = instance->bus_type; *bus_no = instance->bus_no; *dev_no = instance->dev_no; *func_no = instance->func_no; *plugged = ME_PLUGGED_OUT; return ME_ERRNO_SUCCESS; } static int medummy_query_name_device_driver(me_device_t * device, char **name) { PDEBUG("executed.\n"); *name = MEDUMMY_NAME_DRIVER; return ME_ERRNO_SUCCESS; } static int medummy_query_name_device(me_device_t * device, char **name) { medummy_device_t *instance = (medummy_device_t *) device; PDEBUG("executed.\n"); // // // if (instance->magic != MEDUMMY_MAGIC_NUMBER) // // // { // // // PERROR("Wrong magic number.\n"); // // // return ME_ERRNO_INTERNAL; // // // } switch (instance->device_id) { case PCI_DEVICE_ID_MEILHAUS_ME1000: case PCI_DEVICE_ID_MEILHAUS_ME1000_A: case PCI_DEVICE_ID_MEILHAUS_ME1000_B: *name = ME1000_NAME_DEVICE_ME1000; break; case PCI_DEVICE_ID_MEILHAUS_ME1400: *name = ME1400_NAME_DEVICE_ME1400; break; case PCI_DEVICE_ID_MEILHAUS_ME140A: *name = ME1400_NAME_DEVICE_ME1400A; break; case PCI_DEVICE_ID_MEILHAUS_ME140B: *name = ME1400_NAME_DEVICE_ME1400B; break; case PCI_DEVICE_ID_MEILHAUS_ME14E0: *name = ME1400_NAME_DEVICE_ME1400E; break; case PCI_DEVICE_ID_MEILHAUS_ME14EA: *name = ME1400_NAME_DEVICE_ME1400EA; break; case PCI_DEVICE_ID_MEILHAUS_ME14EB: *name = ME1400_NAME_DEVICE_ME1400EB; break; case PCI_DEVICE_ID_MEILHAUS_ME140C: *name = ME1400_NAME_DEVICE_ME1400C; break; case PCI_DEVICE_ID_MEILHAUS_ME140D: *name = ME1400_NAME_DEVICE_ME1400D; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_4U: *name = ME1600_NAME_DEVICE_ME16004U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_8U: *name = ME1600_NAME_DEVICE_ME16008U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_12U: *name = ME1600_NAME_DEVICE_ME160012U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_16U: *name = ME1600_NAME_DEVICE_ME160016U; break; case PCI_DEVICE_ID_MEILHAUS_ME1600_16U_8I: *name = ME1600_NAME_DEVICE_ME160016U8I; break; case PCI_DEVICE_ID_MEILHAUS_ME4610: *name = ME4600_NAME_DEVICE_ME4610; break; case PCI_DEVICE_ID_MEILHAUS_ME4650: *name = ME4600_NAME_DEVICE_ME4650; break; case PCI_DEVICE_ID_MEILHAUS_ME4660: *name = ME4600_NAME_DEVICE_ME4660; break; case PCI_DEVICE_ID_MEILHAUS_ME4660I: *name = ME4600_NAME_DEVICE_ME4660I; break; case PCI_DEVICE_ID_MEILHAUS_ME4670: *name = ME4600_NAME_DEVICE_ME4670; break; case PCI_DEVICE_ID_MEILHAUS_ME4670I: *name = ME4600_NAME_DEVICE_ME4670I; break; case PCI_DEVICE_ID_MEILHAUS_ME4670S: *name = ME4600_NAME_DEVICE_ME4670S; break; case PCI_DEVICE_ID_MEILHAUS_ME4670IS: *name = ME4600_NAME_DEVICE_ME4670IS; break; case PCI_DEVICE_ID_MEILHAUS_ME4680: *name = ME4600_NAME_DEVICE_ME4680; break; case PCI_DEVICE_ID_MEILHAUS_ME4680I: *name = ME4600_NAME_DEVICE_ME4680I; break; case PCI_DEVICE_ID_MEILHAUS_ME4680S: *name = ME4600_NAME_DEVICE_ME4680S; break; case PCI_DEVICE_ID_MEILHAUS_ME4680IS: *name = ME4600_NAME_DEVICE_ME4680IS; break; case PCI_DEVICE_ID_MEILHAUS_ME6004: *name = ME6000_NAME_DEVICE_ME60004; break; case PCI_DEVICE_ID_MEILHAUS_ME6008: *name = ME6000_NAME_DEVICE_ME60008; break; case PCI_DEVICE_ID_MEILHAUS_ME600F: *name = ME6000_NAME_DEVICE_ME600016; break; case PCI_DEVICE_ID_MEILHAUS_ME6014: *name = ME6000_NAME_DEVICE_ME6000I4; break; case PCI_DEVICE_ID_MEILHAUS_ME6018: *name = ME6000_NAME_DEVICE_ME6000I8; break; case PCI_DEVICE_ID_MEILHAUS_ME601F: *name = ME6000_NAME_DEVICE_ME6000I16; break; case PCI_DEVICE_ID_MEILHAUS_ME6034: *name = ME6000_NAME_DEVICE_ME6000ISLE4; break; case PCI_DEVICE_ID_MEILHAUS_ME6038: *name = ME6000_NAME_DEVICE_ME6000ISLE8; break; case PCI_DEVICE_ID_MEILHAUS_ME603F: *name = ME6000_NAME_DEVICE_ME6000ISLE16; break; case PCI_DEVICE_ID_MEILHAUS_ME6104: *name = ME6000_NAME_DEVICE_ME61004; break; case PCI_DEVICE_ID_MEILHAUS_ME6108: *name = ME6000_NAME_DEVICE_ME61008; break; case PCI_DEVICE_ID_MEILHAUS_ME610F: *name = ME6000_NAME_DEVICE_ME610016; break; case PCI_DEVICE_ID_MEILHAUS_ME6114: *name = ME6000_NAME_DEVICE_ME6100I4; break; case PCI_DEVICE_ID_MEILHAUS_ME6118: *name = ME6000_NAME_DEVICE_ME6100I8; break; case PCI_DEVICE_ID_MEILHAUS_ME611F: *name = ME6000_NAME_DEVICE_ME6100I16; break; case PCI_DEVICE_ID_MEILHAUS_ME6134: *name = ME6000_NAME_DEVICE_ME6100ISLE4; break; case PCI_DEVICE_ID_MEILHAUS_ME6138: *name = ME6000_NAME_DEVICE_ME6100ISLE8; break; case PCI_DEVICE_ID_MEILHAUS_ME613F: *name = ME6000_NAME_DEVICE_ME6100ISLE16; break; case PCI_DEVICE_ID_MEILHAUS_ME6044: *name = ME6000_NAME_DEVICE_ME60004DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6048: *name = ME6000_NAME_DEVICE_ME60008DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME604F: *name = ME6000_NAME_DEVICE_ME600016DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6054: *name = ME6000_NAME_DEVICE_ME6000I4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6058: *name = ME6000_NAME_DEVICE_ME6000I8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME605F: *name = ME6000_NAME_DEVICE_ME6000I16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6074: *name = ME6000_NAME_DEVICE_ME6000ISLE4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6078: *name = ME6000_NAME_DEVICE_ME6000ISLE8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME607F: *name = ME6000_NAME_DEVICE_ME6000ISLE16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6144: *name = ME6000_NAME_DEVICE_ME61004DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6148: *name = ME6000_NAME_DEVICE_ME61008DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME614F: *name = ME6000_NAME_DEVICE_ME610016DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6154: *name = ME6000_NAME_DEVICE_ME6100I4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6158: *name = ME6000_NAME_DEVICE_ME6100I8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME615F: *name = ME6000_NAME_DEVICE_ME6100I16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6174: *name = ME6000_NAME_DEVICE_ME6100ISLE4DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME6178: *name = ME6000_NAME_DEVICE_ME6100ISLE8DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME617F: *name = ME6000_NAME_DEVICE_ME6100ISLE16DIO; break; case PCI_DEVICE_ID_MEILHAUS_ME0630: *name = ME0600_NAME_DEVICE_ME0630; break; case PCI_DEVICE_ID_MEILHAUS_ME8100_A: *name = ME8100_NAME_DEVICE_ME8100A; break; case PCI_DEVICE_ID_MEILHAUS_ME8100_B: *name = ME8100_NAME_DEVICE_ME8100B; break; case PCI_DEVICE_ID_MEILHAUS_ME0940: *name = ME0900_NAME_DEVICE_ME0940; break; case PCI_DEVICE_ID_MEILHAUS_ME0950: *name = ME0900_NAME_DEVICE_ME0950; break; case PCI_DEVICE_ID_MEILHAUS_ME0960: *name = ME0900_NAME_DEVICE_ME0960; break; /* case USB_DEVICE_ID_MEPHISTO_S1: *name = MEPHISTO_S1_NAME_DEVICE; break; */ default: *name = EMPTY_NAME_DEVICE; PERROR("Invalid PCI device id.\n"); return ME_ERRNO_INTERNAL; } return ME_ERRNO_SUCCESS; } static int medummy_query_number_subdevices(me_device_t * device, int *number) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_number_channels(me_device_t * device, int subdevice, int *number) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_number_ranges(me_device_t * device, int subdevice, int unit, int *count) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_subdevice_type(me_device_t * device, int subdevice, int *type, int *subtype) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_subdevice_caps(me_device_t * device, int subdevice, int *caps) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_subdevice_caps_args(me_device_t * device, int subdevice, int cap, int *args, int count) { PDEBUG("executed.\n"); return ME_ERRNO_NOT_SUPPORTED; } static int medummy_query_subdevice_by_type(me_device_t * device, int start_subdevice, int type, int subtype, int *subdevice) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_range_by_min_max(me_device_t * device, int subdevice, int unit, int *min, int *max, int *maxdata, int *range) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_range_info(me_device_t * device, int subdevice, int range, int *unit, int *min, int *max, int *maxdata) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } int medummy_query_timer(me_device_t * device, int subdevice, int timer, int *base_frequency, uint64_t * min_ticks, uint64_t * max_ticks) { PDEBUG("executed.\n"); return ME_ERRNO_DEVICE_UNPLUGGED; } static int medummy_query_version_device_driver(me_device_t * device, int *version) { PDEBUG("executed.\n"); *version = ME_VERSION_DRIVER; return ME_ERRNO_SUCCESS; } static void medummy_destructor(me_device_t * device) { PDEBUG("executed.\n"); kfree(device); } static int init_device_info(unsigned short vendor_id, unsigned short device_id, unsigned int serial_no, int bus_type, int bus_no, int dev_no, int func_no, medummy_device_t * instance) { PDEBUG("executed.\n"); // instance->magic = MEDUMMY_MAGIC_NUMBER; instance->vendor_id = vendor_id; instance->device_id = device_id; instance->serial_no = serial_no; instance->bus_type = bus_type; instance->bus_no = bus_no; instance->dev_no = dev_no; instance->func_no = func_no; return 0; } static int medummy_config_load(me_device_t * device, struct file *filep, me_cfg_device_entry_t * config) { PDEBUG("executed.\n"); return ME_ERRNO_SUCCESS; } static int init_device_instance(me_device_t * device) { PDEBUG("executed.\n"); INIT_LIST_HEAD(&device->list); device->me_device_io_irq_start = medummy_io_irq_start; device->me_device_io_irq_wait = medummy_io_irq_wait; device->me_device_io_irq_stop = medummy_io_irq_stop; device->me_device_io_reset_device = medummy_io_reset_device; device->me_device_io_reset_subdevice = medummy_io_reset_subdevice; device->me_device_io_single_config = medummy_io_single_config; device->me_device_io_single_read = medummy_io_single_read; device->me_device_io_single_write = medummy_io_single_write; device->me_device_io_stream_config = medummy_io_stream_config; device->me_device_io_stream_new_values = medummy_io_stream_new_values; device->me_device_io_stream_read = medummy_io_stream_read; device->me_device_io_stream_start = medummy_io_stream_start; device->me_device_io_stream_status = medummy_io_stream_status; device->me_device_io_stream_stop = medummy_io_stream_stop; device->me_device_io_stream_write = medummy_io_stream_write; device->me_device_lock_device = medummy_lock_device; device->me_device_lock_subdevice = medummy_lock_subdevice; device->me_device_query_description_device = medummy_query_description_device; device->me_device_query_info_device = medummy_query_info_device; device->me_device_query_name_device_driver = medummy_query_name_device_driver; device->me_device_query_name_device = medummy_query_name_device; device->me_device_query_number_subdevices = medummy_query_number_subdevices; device->me_device_query_number_channels = medummy_query_number_channels; device->me_device_query_number_ranges = medummy_query_number_ranges; device->me_device_query_range_by_min_max = medummy_query_range_by_min_max; device->me_device_query_range_info = medummy_query_range_info; device->me_device_query_subdevice_type = medummy_query_subdevice_type; device->me_device_query_subdevice_by_type = medummy_query_subdevice_by_type; device->me_device_query_subdevice_caps = medummy_query_subdevice_caps; device->me_device_query_subdevice_caps_args = medummy_query_subdevice_caps_args; device->me_device_query_timer = medummy_query_timer; device->me_device_query_version_device_driver = medummy_query_version_device_driver; device->me_device_destructor = medummy_destructor; device->me_device_config_load = medummy_config_load; return 0; } me_device_t *medummy_constructor(unsigned short vendor_id, unsigned short device_id, unsigned int serial_no, int bus_type, int bus_no, int dev_no, int func_no) { int result = 0; medummy_device_t *instance; PDEBUG("executed.\n"); /* Allocate structure for device attributes */ instance = kmalloc(sizeof(medummy_device_t), GFP_KERNEL); if (!instance) { PERROR("Can't get memory for device instance.\n"); return NULL; } memset(instance, 0, sizeof(medummy_device_t)); /* Initialize device info */ result = init_device_info(vendor_id, device_id, serial_no, bus_type, bus_no, dev_no, func_no, instance); if (result) { PERROR("Cannot init baord info.\n"); kfree(instance); return NULL; } /* Initialize device instance */ result = init_device_instance((me_device_t *) instance); if (result) { PERROR("Cannot init baord info.\n"); kfree(instance); return NULL; } return (me_device_t *) instance; } // Init and exit of module. static int __init dummy_init(void) { PDEBUG("executed.\n"); return 0; } static void __exit dummy_exit(void) { PDEBUG("executed.\n"); } module_init(dummy_init); module_exit(dummy_exit); // Administrative stuff for modinfo. MODULE_AUTHOR("Guenter Gebhardt "); MODULE_DESCRIPTION("Device Driver Module for Meilhaus ME-DUMMY Devices"); MODULE_SUPPORTED_DEVICE("Meilhaus ME-DUMMY Devices"); MODULE_LICENSE("GPL"); // Export the constructor. EXPORT_SYMBOL(medummy_constructor);