451084d2e0
Cc: David Kiliani <mail@davidkiliani.de> Signed-off-by: Alexander Beregalov <a.beregalov@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
1265 lines
27 KiB
C
1265 lines
27 KiB
C
/* 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 <linux/module.h>
|
|
#include <linux/slab.h>
|
|
|
|
#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;
|
|
}
|
|
EXPORT_SYMBOL(medummy_constructor);
|
|
|
|
// 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 <g.gebhardt@meilhaus.de>");
|
|
MODULE_DESCRIPTION("Device Driver Module for Meilhaus ME-DUMMY Devices");
|
|
MODULE_SUPPORTED_DEVICE("Meilhaus ME-DUMMY Devices");
|
|
MODULE_LICENSE("GPL");
|