drivers/staging/meilhaus/me8200_device.c

   1 /**
   2  * @file me8200_device.c
   3  *
   4  * @brief ME-8200 device class implementation.
   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 #ifndef __KERNEL__
  29 #  define __KERNEL__
  30 #endif
  31
  32 #ifndef MODULE
  33 #  define MODULE
  34 #endif
  35
  36 #include <linux/module.h>
  37
  38 #include <linux/pci.h>
  39 #include <linux/slab.h>
  40
  41 #include "meids.h"
  42 #include "meerror.h"
  43 #include "mecommon.h"
  44 #include "meinternal.h"
  45
  46 #include "medebug.h"
  47 #include "meplx_reg.h"
  48 #include "medevice.h"
  49 #include "me8200_device.h"
  50 #include "mesubdevice.h"
  51 #include "me8200_di.h"
  52 #include "me8200_do.h"
  53 #include "me8200_dio.h"
  54
  55 me_device_t *me8200_pci_constructor(struct pci_dev *pci_device)
  56 {
  57         me8200_device_t *me8200_device;
  58         me_subdevice_t *subdevice;
  59         unsigned int version_idx;
  60         int err;
  61         int i;
  62
  63         PDEBUG("executed.\n");
  64
  65         // Allocate structure for device instance.
  66         me8200_device = kmalloc(sizeof(me8200_device_t), GFP_KERNEL);
  67
  68         if (!me8200_device) {
  69                 PERROR("Cannot get memory for device instance.\n");
  70                 return NULL;
  71         }
  72
  73         memset(me8200_device, 0, sizeof(me8200_device_t));
  74
  75         // Initialize base class structure.
  76         err = me_device_pci_init((me_device_t *) me8200_device, pci_device);
  77
  78         if (err) {
  79                 kfree(me8200_device);
  80                 PERROR("Cannot initialize device base class.\n");
  81                 return NULL;
  82         }
  83
  84         /* Get the index in the device version information table. */
  85         version_idx =
  86             me8200_versions_get_device_index(me8200_device->base.info.pci.
  87                                              device_id);
  88
  89         // Initialize spin lock .
  90         spin_lock_init(&me8200_device->irq_ctrl_lock);
  91         spin_lock_init(&me8200_device->irq_mode_lock);
  92         spin_lock_init(&me8200_device->dio_ctrl_lock);
  93
  94         /* Setup the PLX interrupt configuration */
  95         outl(PLX_INTCSR_LOCAL_INT1_EN |
  96              PLX_INTCSR_LOCAL_INT1_POL |
  97              PLX_INTCSR_LOCAL_INT2_EN |
  98              PLX_INTCSR_LOCAL_INT2_POL |
  99              PLX_INTCSR_PCI_INT_EN,
 100              me8200_device->base.info.pci.reg_bases[1] + PLX_INTCSR);
 101
 102         // Create subdevice instances.
 103
 104         for (i = 0; i < me8200_versions[version_idx].di_subdevices; i++) {
 105                 subdevice =
 106                     (me_subdevice_t *) me8200_di_constructor(me8200_device->
 107                                                              base.info.pci.
 108                                                              reg_bases[2], i,
 109                                                              me8200_device->
 110                                                              base.irq,
 111                                                              &me8200_device->
 112                                                              irq_ctrl_lock,
 113                                                              &me8200_device->
 114                                                              irq_mode_lock);
 115
 116                 if (!subdevice) {
 117                         me_device_deinit((me_device_t *) me8200_device);
 118                         kfree(me8200_device);
 119                         PERROR("Cannot get memory for subdevice.\n");
 120                         return NULL;
 121                 }
 122
 123                 me_slist_add_subdevice_tail(&me8200_device->base.slist,
 124                                             subdevice);
 125         }
 126
 127         for (i = 0; i < me8200_versions[version_idx].do_subdevices; i++) {
 128                 subdevice =
 129                     (me_subdevice_t *) me8200_do_constructor(me8200_device->
 130                                                              base.info.pci.
 131                                                              reg_bases[2], i,
 132                                                              me8200_device->
 133                                                              base.irq,
 134                                                              &me8200_device->
 135                                                              irq_mode_lock);
 136
 137                 if (!subdevice) {
 138                         me_device_deinit((me_device_t *) me8200_device);
 139                         kfree(me8200_device);
 140                         PERROR("Cannot get memory for subdevice.\n");
 141                         return NULL;
 142                 }
 143
 144                 me_slist_add_subdevice_tail(&me8200_device->base.slist,
 145                                             subdevice);
 146         }
 147
 148         for (i = 0; i < me8200_versions[version_idx].dio_subdevices; i++) {
 149                 subdevice =
 150                     (me_subdevice_t *) me8200_dio_constructor(me8200_device->
 151                                                               base.info.pci.
 152                                                               reg_bases[2], i,
 153                                                               &me8200_device->
 154                                                               dio_ctrl_lock);
 155
 156                 if (!subdevice) {
 157                         me_device_deinit((me_device_t *) me8200_device);
 158                         kfree(me8200_device);
 159                         PERROR("Cannot get memory for subdevice.\n");
 160                         return NULL;
 161                 }
 162
 163                 me_slist_add_subdevice_tail(&me8200_device->base.slist,
 164                                             subdevice);
 165         }
 166
 167         return (me_device_t *) me8200_device;
 168 }
 169 EXPORT_SYMBOL(me8200_pci_constructor);
 170
 171 // Init and exit of module.
 172
 173 static int __init me8200_init(void)
 174 {
 175         PDEBUG("executed.\n.");
 176         return 0;
 177 }
 178
 179 static void __exit me8200_exit(void)
 180 {
 181         PDEBUG("executed.\n.");
 182 }
 183
 184 module_init(me8200_init);
 185
 186 module_exit(me8200_exit);
 187
 188 // Administrative stuff for modinfo.
 189 MODULE_AUTHOR("Guenter Gebhardt <g.gebhardt@meilhaus.de>");
 190 MODULE_DESCRIPTION("Device Driver Module for Template Device");
 191 MODULE_SUPPORTED_DEVICE("Meilhaus Template Devices");
 192 MODULE_LICENSE("GPL");