LXR linux/drivers/staging/meilhaus/me1400

   1/**
   2 * @file me1400_device.c
   3 *
   4 * @brief ME-1400 device instance.
   5 * @note Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
   6 * @author Guenter Gebhardt
   7 * @author Krzysztof Gantzke    (k.gantzke@meilhaus.de)
   8 */
   9
  10/*
  11 * Copyright (C) 2007 Meilhaus Electronic GmbH (support@meilhaus.de)
  12 *
  13 * This file is free software; you can redistribute it and/or modify
  14 * it under the terms of the GNU General Public License as published by
  15 * the Free Software Foundation; either version 2 of the License, or
  16 * (at your option) any later version.
  17 *
  18 * This program is distributed in the hope that it will be useful,
  19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 * GNU General Public License for more details.
  22 *
  23 * You should have received a copy of the GNU General Public License
  24 * along with this program; if not, write to the Free Software
  25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26 */
  27
  28/*
  29 * User application could also include the kernel header files. But the
  30 * real kernel functions are protected by #ifdef __KERNEL__.
  31 */
  32#ifndef __KERNEL__
  33#  define __KERNEL__
  34#endif
  35
  36/*
  37 * This must be defined before module.h is included. Not needed, when
  38 * it is a built in driver.
  39 */
  40#ifndef MODULE
  41#  define MODULE
  42#endif
  43
  44#include <linux/module.h>
  45
  46#include <linux/pci.h>
  47#include <linux/slab.h>
  48#include <linux/sched.h>
  49#include <linux/interrupt.h>
  50#include <linux/version.h>
  51
  52#include "meids.h"
  53#include "meerror.h"
  54#include "mecommon.h"
  55#include "meinternal.h"
  56
  57#include "medebug.h"
  58
  59#include "me1400_device.h"
  60#include "me8254.h"
  61#include "me8254_reg.h"
  62#include "me8255.h"
  63#include "me1400_ext_irq.h"
  64
  65me_device_t *me1400_pci_constructor(struct pci_dev *pci_device)
  66{
  67        int err;
  68        me1400_device_t *me1400_device;
  69        me_subdevice_t *subdevice;
  70        unsigned int version_idx;
  71        unsigned int me8255_idx;
  72        unsigned int dio_idx;
  73        unsigned int me8254_idx;
  74        unsigned int ctr_idx;
  75        unsigned int ext_irq_idx;
  76
  77        PDEBUG("executed.\n");
  78
  79        // Allocate structure for device instance.
  80        me1400_device = kmalloc(sizeof(me1400_device_t), GFP_KERNEL);
  81
  82        if (!me1400_device) {
  83                PERROR("Cannot get memory for 1400ate device instance.\n");
  84                return NULL;
  85        }
  86
  87        memset(me1400_device, 0, sizeof(me1400_device_t));
  88
  89        // Initialize base class structure.
  90        err = me_device_pci_init((me_device_t *) me1400_device, pci_device);
  91
  92        if (err) {
  93                kfree(me1400_device);
  94                PERROR("Cannot initialize device base class.\n");
  95                return NULL;
  96        }
  97
  98        /* Check for ME1400 extension device. If detected we fake a ME-1400 D device id. */
  99        if (me1400_device->base.info.pci.device_id ==
 100            PCI_DEVICE_ID_MEILHAUS_ME140C) {
 101                uint8_t ctrl;
 102                ctrl =
 103                    inb(me1400_device->base.info.pci.reg_bases[2] +
 104                        ME1400D_CLK_SRC_2_REG);
 105                PDEBUG_REG("xxx_reg inb(0x%X+0x%X)=0x%x\n",
 106                           me1400_device->base.info.pci.reg_bases[2],
 107                           ME1400D_CLK_SRC_2_REG, ctrl);
 108                outb(ctrl | 0xF0,
 109                     me1400_device->base.info.pci.reg_bases[2] +
 110                     ME1400D_CLK_SRC_2_REG);
 111                PDEBUG_REG("xxx_reg outb(0x%X+0x%X)=0x%x\n",
 112                           me1400_device->base.info.pci.reg_bases[2],
 113                           ME1400D_CLK_SRC_2_REG, ctrl | 0xF0);
 114                ctrl =
 115                    inb(me1400_device->base.info.pci.reg_bases[2] +
 116                        ME1400D_CLK_SRC_2_REG);
 117                PDEBUG_REG("xxx_reg inb(0x%X+0x%X)=0x%x\n",
 118                           me1400_device->base.info.pci.reg_bases[2],
 119                           ME1400D_CLK_SRC_2_REG, ctrl);
 120
 121                if ((ctrl & 0xF0) == 0xF0) {
 122                        PINFO("ME1400 D detected.\n");
 123                        me1400_device->base.info.pci.device_id =
 124                            PCI_DEVICE_ID_MEILHAUS_ME140D;
 125                }
 126        }
 127
 128        /* Initialize global stuff of digital i/o subdevices. */
 129        for (me8255_idx = 0; me8255_idx < ME1400_MAX_8255; me8255_idx++) {
 130                me1400_device->dio_current_mode[me8255_idx] = 0;
 131                spin_lock_init(&me1400_device->dio_ctrl_reg_lock[me8255_idx]);
 132        }
 133
 134        /* Initialize global stuff of counter subdevices. */
 135        spin_lock_init(&me1400_device->clk_src_reg_lock);
 136
 137        for (me8254_idx = 0; me8254_idx < ME1400_MAX_8254; me8254_idx++)
 138                spin_lock_init(&me1400_device->ctr_ctrl_reg_lock[me8254_idx]);
 139
 140        /* Get the index in the device version information table. */
 141        version_idx =
 142            me1400_versions_get_device_index(me1400_device->base.info.pci.
 143                                             device_id);
 144
 145        /* Generate DIO subdevice instances. */
 146        for (me8255_idx = 0;
 147             me8255_idx < me1400_versions[version_idx].dio_chips;
 148             me8255_idx++) {
 149                for (dio_idx = 0; dio_idx < 3; dio_idx++) {
 150                        subdevice =
 151                            (me_subdevice_t *)
 152                            me8255_constructor(me1400_versions[version_idx].
 153                                               device_id,
 154                                               me1400_device->base.info.pci.
 155                                               reg_bases[2], me8255_idx,
 156                                               dio_idx,
 157                                               &me1400_device->
 158                                               dio_current_mode[me8255_idx],
 159                                               &me1400_device->
 160                                               dio_ctrl_reg_lock[me8255_idx]);
 161
 162                        if (!subdevice) {
 163                                me_device_deinit((me_device_t *) me1400_device);
 164                                kfree(me1400_device);
 165                                PERROR("Cannot get memory for subdevice.\n");
 166                                return NULL;
 167                        }
 168
 169                        me_slist_add_subdevice_tail(&me1400_device->base.slist,
 170                                                    subdevice);
 171                }
 172        }
 173
 174        /* Generate counter subdevice instances. */
 175        for (me8254_idx = 0;
 176             me8254_idx < me1400_versions[version_idx].ctr_chips;
 177             me8254_idx++) {
 178                for (ctr_idx = 0; ctr_idx < 3; ctr_idx++) {
 179                        subdevice =
 180                            (me_subdevice_t *)
 181                            me8254_constructor(me1400_device->base.info.pci.
 182                                               device_id,
 183                                               me1400_device->base.info.pci.
 184                                               reg_bases[2], me8254_idx,
 185                                               ctr_idx,
 186                                               &me1400_device->
 187                                               ctr_ctrl_reg_lock[me8254_idx],
 188                                               &me1400_device->
 189                                               clk_src_reg_lock);
 190
 191                        if (!subdevice) {
 192                                me_device_deinit((me_device_t *) me1400_device);
 193                                kfree(me1400_device);
 194                                PERROR("Cannot get memory for subdevice.\n");
 195                                return NULL;
 196                        }
 197
 198                        me_slist_add_subdevice_tail(&me1400_device->base.slist,
 199                                                    subdevice);
 200                }
 201        }
 202
 203        /* Generate external interrupt subdevice instances. */
 204        for (ext_irq_idx = 0;
 205             ext_irq_idx < me1400_versions[version_idx].ext_irq_subdevices;
 206             ext_irq_idx++) {
 207                subdevice =
 208                    (me_subdevice_t *)
 209                    me1400_ext_irq_constructor(me1400_device->base.info.pci.
 210                                               device_id,
 211                                               me1400_device->base.info.pci.
 212                                               reg_bases[1],
 213                                               me1400_device->base.info.pci.
 214                                               reg_bases[2],
 215                                               &me1400_device->clk_src_reg_lock,
 216                                               me1400_device->base.irq);
 217
 218                if (!subdevice) {
 219                        me_device_deinit((me_device_t *) me1400_device);
 220                        kfree(me1400_device);
 221                        PERROR("Cannot get memory for subdevice.\n");
 222                        return NULL;
 223                }
 224
 225                me_slist_add_subdevice_tail(&me1400_device->base.slist,
 226                                            subdevice);
 227        }
 228
 229        return (me_device_t *) me1400_device;
 230}
 231
 232// Init and exit of module.
 233
 234static int __init me1400_init(void)
 235{
 236        PDEBUG("executed.\n");
 237        return 0;
 238}
 239
 240static void __exit me1400_exit(void)
 241{
 242        PDEBUG("executed.\n");
 243}
 244
 245module_init(me1400_init);
 246module_exit(me1400_exit);
 247
 248// Administrative stuff for modinfo.
 249MODULE_AUTHOR
 250    ("Guenter Gebhardt <g.gebhardt@meilhaus.de> & Krzysztof Gantzke <k.gantzke@meilhaus.de>");
 251MODULE_DESCRIPTION("Device Driver Module for Meilhaus ME-14xx devices");
 252MODULE_SUPPORTED_DEVICE("Meilhaus ME-14xx MIO devices");
 253MODULE_LICENSE("GPL");
 254
 255// Export the constructor.
 256EXPORT_SYMBOL(me1400_pci_constructor);
 257