me_device_t *me1000_pci_constructor(struct pci_dev * pci_device)
{
me1000_device_t *me1000_device;
me_subdevice_t *subdevice;
int err;
int i;
PDEBUG("executed.\n");
// Allocate structure for device instance.
me1000_device = kmalloc(sizeof(me1000_device_t), GFP_KERNEL);
if (!me1000_device) {
PERROR("Cannot get memory for ME-1000 device instance.\n");
return NULL;
}
memset(me1000_device, 0, sizeof(me1000_device_t));
// Initialize base class structure.
err = me_device_pci_init((me_device_t *) me1000_device, pci_device);
if (err) {
kfree(me1000_device);
PERROR("Cannot initialize device base class.\n");
return NULL;
}
// Initialize spin lock .
spin_lock_init(&me1000_device->ctrl_lock);
for (i = 0; i < 4; i++) {
subdevice =
(me_subdevice_t *) me1000_dio_constructor(me1000_device->
base.info.pci.
reg_bases[2], i,
&me1000_device->
ctrl_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me1000_device);
kfree(me1000_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me1000_device->base.slist,
subdevice);
}
// Overwrite base class methods.
me1000_device->base.me_device_config_load = me1000_config_load;
return (me_device_t *) me1000_device;
}
me_device_t *me8200_pci_constructor(struct pci_dev *pci_device)
{
me8200_device_t *me8200_device;
me_subdevice_t *subdevice;
unsigned int version_idx;
int err;
int i;
PDEBUG("executed.\n");
// Allocate structure for device instance.
me8200_device = kmalloc(sizeof(me8200_device_t), GFP_KERNEL);
if (!me8200_device) {
PERROR("Cannot get memory for device instance.\n");
return NULL;
}
memset(me8200_device, 0, sizeof(me8200_device_t));
// Initialize base class structure.
err = me_device_pci_init((me_device_t *) me8200_device, pci_device);
if (err) {
kfree(me8200_device);
PERROR("Cannot initialize device base class.\n");
return NULL;
}
/* Get the index in the device version information table. */
version_idx =
me8200_versions_get_device_index(me8200_device->base.info.pci.
device_id);
// Initialize spin lock .
spin_lock_init(&me8200_device->irq_ctrl_lock);
spin_lock_init(&me8200_device->irq_mode_lock);
spin_lock_init(&me8200_device->dio_ctrl_lock);
/* Setup the PLX interrupt configuration */
outl(PLX_INTCSR_LOCAL_INT1_EN |
PLX_INTCSR_LOCAL_INT1_POL |
PLX_INTCSR_LOCAL_INT2_EN |
PLX_INTCSR_LOCAL_INT2_POL |
PLX_INTCSR_PCI_INT_EN,
me8200_device->base.info.pci.reg_bases[1] + PLX_INTCSR);
// Create subdevice instances.
for (i = 0; i < me8200_versions[version_idx].di_subdevices; i++) {
subdevice =
(me_subdevice_t *) me8200_di_constructor(me8200_device->
base.info.pci.
reg_bases[2], i,
me8200_device->
base.irq,
&me8200_device->
irq_ctrl_lock,
&me8200_device->
irq_mode_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me8200_device);
kfree(me8200_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me8200_device->base.slist,
subdevice);
}
for (i = 0; i < me8200_versions[version_idx].do_subdevices; i++) {
subdevice =
(me_subdevice_t *) me8200_do_constructor(me8200_device->
base.info.pci.
reg_bases[2], i,
me8200_device->
base.irq,
&me8200_device->
irq_mode_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me8200_device);
kfree(me8200_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me8200_device->base.slist,
subdevice);
}
for (i = 0; i < me8200_versions[version_idx].dio_subdevices; i++) {
subdevice =
(me_subdevice_t *) me8200_dio_constructor(me8200_device->
base.info.pci.
reg_bases[2], i,
&me8200_device->
dio_ctrl_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me8200_device);
kfree(me8200_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me8200_device->base.slist,
subdevice);
}
return (me_device_t *) me8200_device;
}
me_device_t *me0900_pci_constructor(struct pci_dev *pci_device)
{
me0900_device_t *me0900_device;
me_subdevice_t *subdevice;
unsigned int version_idx;
int err;
int i;
int port_shift;
PDEBUG("executed.\n");
// Allocate structure for device instance.
me0900_device = kmalloc(sizeof(me0900_device_t), GFP_KERNEL);
if (!me0900_device) {
PERROR("Cannot get memory for device instance.\n");
return NULL;
}
memset(me0900_device, 0, sizeof(me0900_device_t));
// Initialize base class structure.
err = me_device_pci_init((me_device_t *) me0900_device, pci_device);
if (err) {
kfree(me0900_device);
PERROR("Cannot initialize device base class.\n");
return NULL;
}
/* Get the index in the device version information table. */
version_idx =
me0900_versions_get_device_index(me0900_device->base.info.pci.
device_id);
/* Initialize 8255 chip to desired mode */
if (me0900_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME0940) {
outb(0x9B,
me0900_device->base.info.pci.reg_bases[2] +
ME0900_CTRL_REG);
} else if (me0900_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME0950) {
outb(0x89,
me0900_device->base.info.pci.reg_bases[2] +
ME0900_CTRL_REG);
outb(0x00,
me0900_device->base.info.pci.reg_bases[2] +
ME0900_WRITE_ENABLE_REG);
} else if (me0900_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME0960) {
outb(0x8B,
me0900_device->base.info.pci.reg_bases[2] +
ME0900_CTRL_REG);
outb(0x00,
me0900_device->base.info.pci.reg_bases[2] +
ME0900_WRITE_ENABLE_REG);
}
port_shift =
(me0900_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME0960) ? 1 : 0;
// Create subdevice instances.
for (i = 0; i < me0900_versions[version_idx].di_subdevices; i++) {
subdevice =
(me_subdevice_t *) me0900_di_constructor(me0900_device->
base.info.pci.
reg_bases[2],
i + port_shift);
if (!subdevice) {
me_device_deinit((me_device_t *) me0900_device);
kfree(me0900_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me0900_device->base.slist,
subdevice);
}
for (i = 0; i < me0900_versions[version_idx].do_subdevices; i++) {
subdevice =
(me_subdevice_t *) me0900_do_constructor(me0900_device->
base.info.pci.
reg_bases[2], i);
if (!subdevice) {
me_device_deinit((me_device_t *) me0900_device);
kfree(me0900_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me0900_device->base.slist,
subdevice);
}
return (me_device_t *) me0900_device;
}
me_device_t *me6000_pci_constructor(struct pci_dev *pci_device)
{
me6000_device_t *me6000_device;
me_subdevice_t *subdevice;
unsigned int version_idx;
int err;
int i;
int high_range = 0;
int fifo;
PDEBUG("executed.\n");
// Allocate structure for device instance.
me6000_device = kmalloc(sizeof(me6000_device_t), GFP_KERNEL);
if (!me6000_device) {
PERROR("Cannot get memory for device instance.\n");
return NULL;
}
memset(me6000_device, 0, sizeof(me6000_device_t));
// Initialize base class structure.
err = me_device_pci_init((me_device_t *) me6000_device, pci_device);
if (err) {
kfree(me6000_device);
PERROR("Cannot initialize device base class.\n");
return NULL;
}
/* Download the xilinx firmware */
err = me_xilinx_download(me6000_device->base.info.pci.reg_bases[1],
me6000_device->base.info.pci.reg_bases[2],
&pci_device->dev, "me6000.bin");
if (err) {
me_device_deinit((me_device_t *) me6000_device);
kfree(me6000_device);
PERROR("Can't download firmware.\n");
return NULL;
}
/* Get the index in the device version information table. */
version_idx =
me6000_versions_get_device_index(me6000_device->base.info.pci.
device_id);
// Initialize spin lock .
spin_lock_init(&me6000_device->preload_reg_lock);
spin_lock_init(&me6000_device->dio_ctrl_reg_lock);
/* Create digital input/output instances. */
for (i = 0; i < me6000_versions[version_idx].dio_subdevices; i++) {
subdevice =
(me_subdevice_t *) me6000_dio_constructor(me6000_device->
base.info.pci.
reg_bases[3], i,
&me6000_device->
dio_ctrl_reg_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me6000_device);
kfree(me6000_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me6000_device->base.slist,
subdevice);
}
/* Create analog output instances. */
for (i = 0; i < me6000_versions[version_idx].ao_subdevices; i++) {
high_range = ((i == 8)
&&
((me6000_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME6359)
|| (me6000_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME6259)
)
)? 1 : 0;
fifo =
(i <
me6000_versions[version_idx].
ao_fifo) ? ME6000_AO_HAS_FIFO : 0x0;
fifo |= (i < 4) ? ME6000_AO_EXTRA_HARDWARE : 0x0;
subdevice =
(me_subdevice_t *) me6000_ao_constructor(me6000_device->
base.info.pci.
reg_bases[2],
&me6000_device->
preload_reg_lock,
&me6000_device->
preload_flags,
&me6000_device->
triggering_flags,
i, fifo,
me6000_device->
base.irq,
high_range,
me6000_workqueue);
if (!subdevice) {
me_device_deinit((me_device_t *) me6000_device);
kfree(me6000_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me6000_device->base.slist,
subdevice);
}
return (me_device_t *) me6000_device;
}
me_device_t *me1400_pci_constructor(struct pci_dev *pci_device)
{
int err;
me1400_device_t *me1400_device;
me_subdevice_t *subdevice;
unsigned int version_idx;
unsigned int me8255_idx;
unsigned int dio_idx;
unsigned int me8254_idx;
unsigned int ctr_idx;
unsigned int ext_irq_idx;
PDEBUG("executed.\n");
// Allocate structure for device instance.
me1400_device = kmalloc(sizeof(me1400_device_t), GFP_KERNEL);
if (!me1400_device) {
PERROR("Cannot get memory for 1400ate device instance.\n");
return NULL;
}
memset(me1400_device, 0, sizeof(me1400_device_t));
// Initialize base class structure.
err = me_device_pci_init((me_device_t *) me1400_device, pci_device);
if (err) {
kfree(me1400_device);
PERROR("Cannot initialize device base class.\n");
return NULL;
}
/* Check for ME1400 extension device. If detected we fake a ME-1400 D device id. */
if (me1400_device->base.info.pci.device_id ==
PCI_DEVICE_ID_MEILHAUS_ME140C) {
uint8_t ctrl;
ctrl =
inb(me1400_device->base.info.pci.reg_bases[2] +
ME1400D_CLK_SRC_2_REG);
PDEBUG_REG("xxx_reg inb(0x%X+0x%X)=0x%x\n",
me1400_device->base.info.pci.reg_bases[2],
ME1400D_CLK_SRC_2_REG, ctrl);
outb(ctrl | 0xF0,
me1400_device->base.info.pci.reg_bases[2] +
ME1400D_CLK_SRC_2_REG);
PDEBUG_REG("xxx_reg outb(0x%X+0x%X)=0x%x\n",
me1400_device->base.info.pci.reg_bases[2],
ME1400D_CLK_SRC_2_REG, ctrl | 0xF0);
ctrl =
inb(me1400_device->base.info.pci.reg_bases[2] +
ME1400D_CLK_SRC_2_REG);
PDEBUG_REG("xxx_reg inb(0x%X+0x%X)=0x%x\n",
me1400_device->base.info.pci.reg_bases[2],
ME1400D_CLK_SRC_2_REG, ctrl);
if ((ctrl & 0xF0) == 0xF0) {
PINFO("ME1400 D detected.\n");
me1400_device->base.info.pci.device_id =
PCI_DEVICE_ID_MEILHAUS_ME140D;
}
}
/* Initialize global stuff of digital i/o subdevices. */
for (me8255_idx = 0; me8255_idx < ME1400_MAX_8255; me8255_idx++) {
me1400_device->dio_current_mode[me8255_idx] = 0;
spin_lock_init(&me1400_device->dio_ctrl_reg_lock[me8255_idx]);
}
/* Initialize global stuff of counter subdevices. */
spin_lock_init(&me1400_device->clk_src_reg_lock);
for (me8254_idx = 0; me8254_idx < ME1400_MAX_8254; me8254_idx++)
spin_lock_init(&me1400_device->ctr_ctrl_reg_lock[me8254_idx]);
/* Get the index in the device version information table. */
version_idx =
me1400_versions_get_device_index(me1400_device->base.info.pci.
device_id);
/* Generate DIO subdevice instances. */
for (me8255_idx = 0;
me8255_idx < me1400_versions[version_idx].dio_chips;
me8255_idx++) {
for (dio_idx = 0; dio_idx < 3; dio_idx++) {
subdevice =
(me_subdevice_t *)
me8255_constructor(me1400_versions[version_idx].
device_id,
me1400_device->base.info.pci.
reg_bases[2], me8255_idx,
dio_idx,
&me1400_device->
dio_current_mode[me8255_idx],
&me1400_device->
dio_ctrl_reg_lock[me8255_idx]);
if (!subdevice) {
me_device_deinit((me_device_t *) me1400_device);
kfree(me1400_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me1400_device->base.slist,
subdevice);
}
}
/* Generate counter subdevice instances. */
for (me8254_idx = 0;
me8254_idx < me1400_versions[version_idx].ctr_chips;
me8254_idx++) {
for (ctr_idx = 0; ctr_idx < 3; ctr_idx++) {
subdevice =
(me_subdevice_t *)
me8254_constructor(me1400_device->base.info.pci.
device_id,
me1400_device->base.info.pci.
reg_bases[2], me8254_idx,
ctr_idx,
&me1400_device->
ctr_ctrl_reg_lock[me8254_idx],
&me1400_device->
clk_src_reg_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me1400_device);
kfree(me1400_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me1400_device->base.slist,
subdevice);
}
}
/* Generate external interrupt subdevice instances. */
for (ext_irq_idx = 0;
ext_irq_idx < me1400_versions[version_idx].ext_irq_subdevices;
ext_irq_idx++) {
subdevice =
(me_subdevice_t *)
me1400_ext_irq_constructor(me1400_device->base.info.pci.
device_id,
me1400_device->base.info.pci.
reg_bases[1],
me1400_device->base.info.pci.
reg_bases[2],
&me1400_device->clk_src_reg_lock,
me1400_device->base.irq);
if (!subdevice) {
me_device_deinit((me_device_t *) me1400_device);
kfree(me1400_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me1400_device->base.slist,
subdevice);
}
return (me_device_t *) me1400_device;
}
me_device_t *me4600_pci_constructor(struct pci_dev *pci_device)
#endif //BOSCH
{
me4600_device_t *me4600_device;
me_subdevice_t *subdevice;
unsigned int version_idx;
int err;
int i;
PDEBUG("executed.\n");
// Allocate structure for device instance.
me4600_device = kmalloc(sizeof(me4600_device_t), GFP_KERNEL);
if (!me4600_device) {
PERROR("Cannot get memory for ME-4600 device instance.\n");
return NULL;
}
memset(me4600_device, 0, sizeof(me4600_device_t));
// Initialize base class structure.
err = me_device_pci_init((me_device_t *) me4600_device, pci_device);
if (err) {
kfree(me4600_device);
PERROR("Cannot initialize device base class.\n");
return NULL;
}
// Download the xilinx firmware.
if (me4600_device->base.info.pci.device_id == PCI_DEVICE_ID_MEILHAUS_ME4610) { //Jekyll <=> me4610
err =
me_xilinx_download(me4600_device->base.info.pci.
reg_bases[1],
me4600_device->base.info.pci.
reg_bases[5], &pci_device->dev,
"me4610.bin");
} else { // General me4600 firmware
#ifdef BOSCH
err =
me_xilinx_download(me4600_device->base.info.pci.
reg_bases[1],
me4600_device->base.info.pci.
reg_bases[5], &pci_device->dev,
(me_bosch_fw) ? "me4600_bosch.bin" :
"me4600.bin");
#else //~BOSCH
err =
me_xilinx_download(me4600_device->base.info.pci.
reg_bases[1],
me4600_device->base.info.pci.
reg_bases[5], &pci_device->dev,
"me4600.bin");
#endif
}
if (err) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot download firmware.\n");
return NULL;
}
// Get the index in the device version information table.
version_idx =
me4600_versions_get_device_index(me4600_device->base.info.pci.
device_id);
// Initialize spin locks.
spin_lock_init(&me4600_device->preload_reg_lock);
me4600_device->preload_flags = 0;
spin_lock_init(&me4600_device->dio_lock);
spin_lock_init(&me4600_device->ai_ctrl_lock);
spin_lock_init(&me4600_device->ctr_ctrl_reg_lock);
spin_lock_init(&me4600_device->ctr_clk_src_reg_lock);
// Create digital input instances.
for (i = 0; i < me4600_versions[version_idx].di_subdevices; i++) {
subdevice =
(me_subdevice_t *) me4600_di_constructor(me4600_device->
base.info.pci.
reg_bases[2],
&me4600_device->
dio_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
// Create digital output instances.
for (i = 0; i < me4600_versions[version_idx].do_subdevices; i++) {
subdevice =
(me_subdevice_t *) me4600_do_constructor(me4600_device->
base.info.pci.
reg_bases[2],
&me4600_device->
dio_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
// Create digital input/output instances.
for (i = 0; i < me4600_versions[version_idx].dio_subdevices; i++) {
subdevice =
(me_subdevice_t *) me4600_dio_constructor(me4600_device->
base.info.pci.
reg_bases[2],
me4600_versions
[version_idx].
do_subdevices +
me4600_versions
[version_idx].
di_subdevices + i,
&me4600_device->
dio_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
// Create analog input instances.
for (i = 0; i < me4600_versions[version_idx].ai_subdevices; i++) {
subdevice =
(me_subdevice_t *) me4600_ai_constructor(me4600_device->
base.info.pci.
reg_bases[2],
me4600_versions
[version_idx].
ai_channels,
me4600_versions
[version_idx].
ai_ranges,
me4600_versions
[version_idx].
ai_isolated,
me4600_versions
[version_idx].
ai_sh,
me4600_device->
base.irq,
&me4600_device->
ai_ctrl_lock,
me4600_workqueue);
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
// Create analog output instances.
for (i = 0; i < me4600_versions[version_idx].ao_subdevices; i++) {
#ifdef BOSCH
subdevice =
(me_subdevice_t *) me4600_ao_constructor(me4600_device->
base.info.pci.
reg_bases[2],
&me4600_device->
preload_reg_lock,
&me4600_device->
preload_flags, i,
me4600_versions
[version_idx].
ao_fifo,
me4600_device->
base.irq);
#else //~BOSCH
subdevice =
(me_subdevice_t *) me4600_ao_constructor(me4600_device->
base.info.pci.
reg_bases[2],
&me4600_device->
preload_reg_lock,
&me4600_device->
preload_flags, i,
me4600_versions
[version_idx].
ao_fifo,
me4600_device->
base.irq,
me4600_workqueue);
#endif
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
// Create counter instances.
for (i = 0; i < me4600_versions[version_idx].ctr_subdevices; i++) {
subdevice =
(me_subdevice_t *) me8254_constructor(me4600_device->base.
info.pci.device_id,
me4600_device->base.
info.pci.reg_bases[3],
0, i,
&me4600_device->
ctr_ctrl_reg_lock,
&me4600_device->
ctr_clk_src_reg_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
// Create external interrupt instances.
for (i = 0; i < me4600_versions[version_idx].ext_irq_subdevices; i++) {
subdevice =
(me_subdevice_t *)
me4600_ext_irq_constructor(me4600_device->base.info.pci.
reg_bases[2],
me4600_device->base.irq,
&me4600_device->ai_ctrl_lock);
if (!subdevice) {
me_device_deinit((me_device_t *) me4600_device);
kfree(me4600_device);
PERROR("Cannot get memory for subdevice.\n");
return NULL;
}
me_slist_add_subdevice_tail(&me4600_device->base.slist,
subdevice);
}
return (me_device_t *) me4600_device;
}