git.oblomov.eu Git - linux-2.6/blob - drivers/staging/meilhaus/memain.c

   1 /**
   2  * @file memain.c
   3  *
   4  * @brief Main Meilhaus device driver.
   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 #include <linux/pci.h>
  38 //#include <linux/usb.h>
  39 #include <linux/errno.h>
  40 #include <asm/uaccess.h>
  41 #include <linux/cdev.h>
  42 #include <linux/rwsem.h>
  43
  44 #include "medefines.h"
  45 #include "metypes.h"
  46 #include "meerror.h"
  47
  48 #include "medebug.h"
  49 #include "memain.h"
  50 #include "medevice.h"
  51 #include "meioctl.h"
  52 #include "mecommon.h"
  53
  54 /* Module parameters
  55 */
  56
  57 #ifdef BOSCH
  58 static unsigned int me_bosch_fw = 0;
  59
  60 # ifdef module_param
  61 module_param(me_bosch_fw, int, S_IRUGO);
  62 # else
  63 MODULE_PARM(me_bosch_fw, "i");
  64 # endif
  65
  66 MODULE_PARM_DESC(me_bosch_fw,
  67                  "Flags which signals the ME-4600 driver to load the bosch firmware (default = 0).");
  68 #endif //BOSCH
  69
  70 static unsigned int major = 0;
  71 #ifdef module_param
  72 module_param(major, int, S_IRUGO);
  73 #else
  74 MODULE_PARM(major, "i");
  75 #endif
  76
  77 /* Global Driver Lock
  78 */
  79
  80 static struct file *me_filep = NULL;
  81 static int me_count = 0;
  82 static spinlock_t me_lock = SPIN_LOCK_UNLOCKED;
  83 static DECLARE_RWSEM(me_rwsem);
  84
  85 /* Board instances are kept in a global list */
  86 LIST_HEAD(me_device_list);
  87
  88 /* Prototypes
  89 */
  90
  91 static int me_probe_pci(struct pci_dev *dev, const struct pci_device_id *id);
  92 static void me_remove_pci(struct pci_dev *dev);
  93 static int insert_to_device_list(me_device_t * n_device);
  94 static int replace_with_dummy(int vendor_id, int device_id, int serial_no);
  95 static void clear_device_list(void);
  96 static int me_open(struct inode *inode_ptr, struct file *filep);
  97 static int me_release(struct inode *, struct file *);
  98 static int me_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
  99 //static int me_probe_usb(struct usb_interface *interface, const struct usb_device_id *id);
 100 //static void me_disconnect_usb(struct usb_interface *interface);
 101
 102 /* Character device structure
 103 */
 104
 105 static struct cdev *cdevp;
 106
 107 /* File operations provided by the module
 108 */
 109
 110 static struct file_operations me_file_operations = {
 111         .owner = THIS_MODULE,
 112         .ioctl = me_ioctl,
 113         .open = me_open,
 114         .release = me_release,
 115 };
 116
 117 struct pci_driver me_pci_driver = {
 118         .name = MEMAIN_NAME,
 119         .id_table = me_pci_table,
 120         .probe = me_probe_pci,
 121         .remove = me_remove_pci
 122 };
 123
 124 /* //me_usb_driver
 125 static struct usb_driver me_usb_driver =
 126 {
 127         .name = MEMAIN_NAME,
 128         .id_table = me_usb_table,
 129         .probe = me_probe_usb,
 130         .disconnect = me_disconnect_usb
 131 };
 132 */
 133
 134 #ifdef ME_LOCK_MULTIPLEX_TEMPLATE
 135 ME_LOCK_MULTIPLEX_TEMPLATE("me_lock_device",
 136                            me_lock_device_t,
 137                            me_lock_device,
 138                            me_device_lock_device,
 139                            (device, filep, karg.lock, karg.flags))
 140
 141     ME_LOCK_MULTIPLEX_TEMPLATE("me_lock_subdevice",
 142                            me_lock_subdevice_t,
 143                            me_lock_subdevice,
 144                            me_device_lock_subdevice,
 145                            (device, filep, karg.subdevice, karg.lock,
 146                         karg.flags))
 147 #else
 148 #error macro ME_LOCK_MULTIPLEX_TEMPLATE not defined
 149 #endif
 150
 151 #ifdef ME_IO_MULTIPLEX_TEMPLATE
 152 ME_IO_MULTIPLEX_TEMPLATE("me_io_irq_start",
 153                          me_io_irq_start_t,
 154                          me_io_irq_start,
 155                          me_device_io_irq_start,
 156                          (device,
 157                           filep,
 158                           karg.subdevice,
 159                           karg.channel,
 160                           karg.irq_source,
 161                           karg.irq_edge, karg.irq_arg, karg.flags))
 162
 163     ME_IO_MULTIPLEX_TEMPLATE("me_io_irq_wait",
 164                          me_io_irq_wait_t,
 165                          me_io_irq_wait,
 166                          me_device_io_irq_wait,
 167                          (device,
 168                       filep,
 169                       karg.subdevice,
 170                       karg.channel,
 171                       &karg.irq_count, &karg.value, karg.time_out, karg.flags))
 172
 173     ME_IO_MULTIPLEX_TEMPLATE("me_io_irq_stop",
 174                          me_io_irq_stop_t,
 175                          me_io_irq_stop,
 176                          me_device_io_irq_stop,
 177                          (device,
 178                       filep, karg.subdevice, karg.channel, karg.flags))
 179
 180     ME_IO_MULTIPLEX_TEMPLATE("me_io_reset_device",
 181                          me_io_reset_device_t,
 182                          me_io_reset_device,
 183                          me_device_io_reset_device, (device, filep, karg.flags))
 184
 185     ME_IO_MULTIPLEX_TEMPLATE("me_io_reset_subdevice",
 186                          me_io_reset_subdevice_t,
 187                          me_io_reset_subdevice,
 188                          me_device_io_reset_subdevice,
 189                          (device, filep, karg.subdevice, karg.flags))
 190
 191     ME_IO_MULTIPLEX_TEMPLATE("me_io_single_config",
 192                          me_io_single_config_t,
 193                          me_io_single_config,
 194                          me_device_io_single_config,
 195                          (device,
 196                       filep,
 197                       karg.subdevice,
 198                       karg.channel,
 199                       karg.single_config,
 200                       karg.ref,
 201                       karg.trig_chan,
 202                       karg.trig_type, karg.trig_edge, karg.flags))
 203
 204     ME_IO_MULTIPLEX_TEMPLATE("me_io_stream_new_values",
 205                          me_io_stream_new_values_t,
 206                          me_io_stream_new_values,
 207                          me_device_io_stream_new_values,
 208                          (device,
 209                       filep,
 210                       karg.subdevice, karg.time_out, &karg.count, karg.flags))
 211
 212     ME_IO_MULTIPLEX_TEMPLATE("me_io_stream_read",
 213                          me_io_stream_read_t,
 214                          me_io_stream_read,
 215                          me_device_io_stream_read,
 216                          (device,
 217                       filep,
 218                       karg.subdevice,
 219                       karg.read_mode, karg.values, &karg.count, karg.flags))
 220
 221     ME_IO_MULTIPLEX_TEMPLATE("me_io_stream_status",
 222                          me_io_stream_status_t,
 223                          me_io_stream_status,
 224                          me_device_io_stream_status,
 225                          (device,
 226                       filep,
 227                       karg.subdevice,
 228                       karg.wait, &karg.status, &karg.count, karg.flags))
 229
 230     ME_IO_MULTIPLEX_TEMPLATE("me_io_stream_write",
 231                          me_io_stream_write_t,
 232                          me_io_stream_write,
 233                          me_device_io_stream_write,
 234                          (device,
 235                       filep,
 236                       karg.subdevice,
 237                       karg.write_mode, karg.values, &karg.count, karg.flags))
 238 #else
 239 #error macro ME_IO_MULTIPLEX_TEMPLATE not defined
 240 #endif
 241
 242 #ifdef ME_QUERY_MULTIPLEX_STR_TEMPLATE
 243 ME_QUERY_MULTIPLEX_STR_TEMPLATE("me_query_name_device",
 244                                 me_query_name_device_t,
 245                                 me_query_name_device,
 246                                 me_device_query_name_device, (device, &msg))
 247
 248     ME_QUERY_MULTIPLEX_STR_TEMPLATE("me_query_name_device_driver",
 249                                 me_query_name_device_driver_t,
 250                                 me_query_name_device_driver,
 251                                 me_device_query_name_device_driver,
 252                                 (device, &msg))
 253
 254     ME_QUERY_MULTIPLEX_STR_TEMPLATE("me_query_description_device",
 255                                 me_query_description_device_t,
 256                                 me_query_description_device,
 257                                 me_device_query_description_device,
 258                                 (device, &msg))
 259 #else
 260 #error macro ME_QUERY_MULTIPLEX_STR_TEMPLATE not defined
 261 #endif
 262
 263 #ifdef ME_QUERY_MULTIPLEX_TEMPLATE
 264 ME_QUERY_MULTIPLEX_TEMPLATE("me_query_info_device",
 265                             me_query_info_device_t,
 266                             me_query_info_device,
 267                             me_device_query_info_device,
 268                             (device,
 269                              &karg.vendor_id,
 270                              &karg.device_id,
 271                              &karg.serial_no,
 272                              &karg.bus_type,
 273                              &karg.bus_no,
 274                              &karg.dev_no, &karg.func_no, &karg.plugged))
 275
 276     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_number_subdevices",
 277                             me_query_number_subdevices_t,
 278                             me_query_number_subdevices,
 279                             me_device_query_number_subdevices,
 280                             (device, &karg.number))
 281
 282     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_number_channels",
 283                             me_query_number_channels_t,
 284                             me_query_number_channels,
 285                             me_device_query_number_channels,
 286                             (device, karg.subdevice, &karg.number))
 287
 288     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_subdevice_by_type",
 289                             me_query_subdevice_by_type_t,
 290                             me_query_subdevice_by_type,
 291                             me_device_query_subdevice_by_type,
 292                             (device,
 293                          karg.start_subdevice,
 294                          karg.type, karg.subtype, &karg.subdevice))
 295
 296     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_subdevice_type",
 297                             me_query_subdevice_type_t,
 298                             me_query_subdevice_type,
 299                             me_device_query_subdevice_type,
 300                             (device, karg.subdevice, &karg.type, &karg.subtype))
 301
 302     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_subdevice_caps",
 303                             me_query_subdevice_caps_t,
 304                             me_query_subdevice_caps,
 305                             me_device_query_subdevice_caps,
 306                             (device, karg.subdevice, &karg.caps))
 307
 308     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_subdevice_caps_args",
 309                             me_query_subdevice_caps_args_t,
 310                             me_query_subdevice_caps_args,
 311                             me_device_query_subdevice_caps_args,
 312                             (device, karg.subdevice, karg.cap, karg.args,
 313                          karg.count))
 314
 315     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_number_ranges",
 316                             me_query_number_ranges_t,
 317                             me_query_number_ranges,
 318                             me_device_query_number_ranges,
 319                             (device, karg.subdevice, karg.unit, &karg.number))
 320
 321     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_range_by_min_max",
 322                             me_query_range_by_min_max_t,
 323                             me_query_range_by_min_max,
 324                             me_device_query_range_by_min_max,
 325                             (device,
 326                          karg.subdevice,
 327                          karg.unit,
 328                          &karg.min, &karg.max, &karg.max_data, &karg.range))
 329
 330     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_range_info",
 331                             me_query_range_info_t,
 332                             me_query_range_info,
 333                             me_device_query_range_info,
 334                             (device,
 335                          karg.subdevice,
 336                          karg.range,
 337                          &karg.unit, &karg.min, &karg.max, &karg.max_data))
 338
 339     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_timer",
 340                             me_query_timer_t,
 341                             me_query_timer,
 342                             me_device_query_timer,
 343                             (device,
 344                          karg.subdevice,
 345                          karg.timer,
 346                          &karg.base_frequency,
 347                          &karg.min_ticks, &karg.max_ticks))
 348
 349     ME_QUERY_MULTIPLEX_TEMPLATE("me_query_version_device_driver",
 350                             me_query_version_device_driver_t,
 351                             me_query_version_device_driver,
 352                             me_device_query_version_device_driver,
 353                             (device, &karg.version))
 354 #else
 355 #error macro ME_QUERY_MULTIPLEX_TEMPLATE not defined
 356 #endif
 357
 358 /** ******************************************************************************** **/
 359
 360 static me_device_t *get_dummy_instance(unsigned short vendor_id,
 361                                        unsigned short device_id,
 362                                        unsigned int serial_no,
 363                                        int bus_type,
 364                                        int bus_no, int dev_no, int func_no)
 365 {
 366         int err;
 367         me_dummy_constructor_t constructor = NULL;
 368         me_device_t *instance;
 369
 370         PDEBUG("executed.\n");
 371
 372         if ((constructor = symbol_get(medummy_constructor)) == NULL) {
 373                 err = request_module(MEDUMMY_NAME);
 374
 375                 if (err) {
 376                         PERROR("Error while request for module %s.\n",
 377                                MEDUMMY_NAME);
 378                         return NULL;
 379                 }
 380
 381                 if ((constructor = symbol_get(medummy_constructor)) == NULL) {
 382                         PERROR("Can't get %s driver module constructor.\n",
 383                                MEDUMMY_NAME);
 384                         return NULL;
 385                 }
 386         }
 387
 388         if ((instance = (*constructor) (vendor_id,
 389                                         device_id,
 390                                         serial_no,
 391                                         bus_type,
 392                                         bus_no, dev_no, func_no)) == NULL)
 393                 symbol_put(medummy_constructor);
 394
 395         return instance;
 396 }
 397
 398 static int me_probe_pci(struct pci_dev *dev, const struct pci_device_id *id)
 399 {
 400         int err;
 401         me_pci_constructor_t constructor = NULL;
 402 #ifdef BOSCH
 403         me_bosch_constructor_t constructor_bosch = NULL;
 404 #endif
 405         me_device_t *n_device = NULL;
 406         uint32_t device;
 407
 408         char constructor_name[24] = "me0000_pci_constructor";
 409         char module_name[7] = "me0000";
 410
 411         PDEBUG("executed.\n");
 412         device = dev->device;
 413         if ((device & 0xF000) == 0x6000) {      // Exceptions: me61xx, me62xx, me63xx are handled by one driver.
 414                 device &= 0xF0FF;
 415         }
 416
 417         constructor_name[2] += (char)((device >> 12) & 0x000F);
 418         constructor_name[3] += (char)((device >> 8) & 0x000F);
 419         PDEBUG("constructor_name: %s\n", constructor_name);
 420         module_name[2] += (char)((device >> 12) & 0x000F);
 421         module_name[3] += (char)((device >> 8) & 0x000F);
 422         PDEBUG("module_name: %s\n", module_name);
 423
 424         if ((constructor =
 425              (me_pci_constructor_t) symbol_get(constructor_name)) == NULL) {
 426                 if (request_module(module_name)) {
 427                         PERROR("Error while request for module %s.\n",
 428                                module_name);
 429                         return -ENODEV;
 430                 }
 431
 432                 if ((constructor =
 433                      (me_pci_constructor_t) symbol_get(constructor_name)) ==
 434                     NULL) {
 435                         PERROR("Can't get %s driver module constructor.\n",
 436                                module_name);
 437                         return -ENODEV;
 438                 }
 439         }
 440 #ifdef BOSCH
 441         if ((device & 0xF000) == 0x4000) {      // Bosch build has differnt constructor for me4600.
 442                 if ((n_device =
 443                      (*constructor_bosch) (dev, me_bosch_fw)) == NULL) {
 444                         symbol_put(constructor_name);
 445                         PERROR
 446                             ("Can't get device instance of %s driver module.\n",
 447                              module_name);
 448                         return -ENODEV;
 449                 }
 450         } else {
 451 #endif
 452                 if ((n_device = (*constructor) (dev)) == NULL) {
 453                         symbol_put(constructor_name);
 454                         PERROR
 455                             ("Can't get device instance of %s driver module.\n",
 456                              module_name);
 457                         return -ENODEV;
 458                 }
 459 #ifdef BOSCH
 460         }
 461 #endif
 462
 463         insert_to_device_list(n_device);
 464         err =
 465             n_device->me_device_io_reset_device(n_device, NULL,
 466                                                 ME_IO_RESET_DEVICE_NO_FLAGS);
 467         if (err) {
 468                 PERROR("Error while reseting device.\n");
 469         } else {
 470                 PDEBUG("Reseting device was sucessful.\n");
 471         }
 472         return ME_ERRNO_SUCCESS;
 473 }
 474
 475 static void release_instance(me_device_t * device)
 476 {
 477         int vendor_id;
 478         int device_id;
 479         int serial_no;
 480         int bus_type;
 481         int bus_no;
 482         int dev_no;
 483         int func_no;
 484         int plugged;
 485
 486         uint32_t dev_id;
 487
 488         char constructor_name[24] = "me0000_pci_constructor";
 489
 490         PDEBUG("executed.\n");
 491
 492         device->me_device_query_info_device(device,
 493                                             &vendor_id,
 494                                             &device_id,
 495                                             &serial_no,
 496                                             &bus_type,
 497                                             &bus_no,
 498                                             &dev_no, &func_no, &plugged);
 499
 500         dev_id = device_id;
 501         device->me_device_destructor(device);
 502
 503         if (plugged != ME_PLUGGED_IN) {
 504                 PDEBUG("release: medummy_constructor\n");
 505
 506                 symbol_put("medummy_constructor");
 507         } else {
 508                 if ((dev_id & 0xF000) == 0x6000) {      // Exceptions: me61xx, me62xx, me63xx are handled by one driver.
 509                         dev_id &= 0xF0FF;
 510                 }
 511
 512                 constructor_name[2] += (char)((dev_id >> 12) & 0x000F);
 513                 constructor_name[3] += (char)((dev_id >> 8) & 0x000F);
 514                 PDEBUG("release: %s\n", constructor_name);
 515
 516                 symbol_put(constructor_name);
 517         }
 518 }
 519
 520 static int insert_to_device_list(me_device_t * n_device)
 521 {
 522         me_device_t *o_device = NULL;
 523
 524         struct list_head *pos;
 525         int n_vendor_id;
 526         int n_device_id;
 527         int n_serial_no;
 528         int n_bus_type;
 529         int n_bus_no;
 530         int n_dev_no;
 531         int n_func_no;
 532         int n_plugged;
 533         int o_vendor_id;
 534         int o_device_id;
 535         int o_serial_no;
 536         int o_bus_type;
 537         int o_bus_no;
 538         int o_dev_no;
 539         int o_func_no;
 540         int o_plugged;
 541
 542         PDEBUG("executed.\n");
 543
 544         n_device->me_device_query_info_device(n_device,
 545                                               &n_vendor_id,
 546                                               &n_device_id,
 547                                               &n_serial_no,
 548                                               &n_bus_type,
 549                                               &n_bus_no,
 550                                               &n_dev_no,
 551                                               &n_func_no, &n_plugged);
 552
 553         down_write(&me_rwsem);
 554
 555         list_for_each(pos, &me_device_list) {
 556                 o_device = list_entry(pos, me_device_t, list);
 557                 o_device->me_device_query_info_device(o_device,
 558                                                       &o_vendor_id,
 559                                                       &o_device_id,
 560                                                       &o_serial_no,
 561                                                       &o_bus_type,
 562                                                       &o_bus_no,
 563                                                       &o_dev_no,
 564                                                       &o_func_no, &o_plugged);
 565
 566                 if (o_plugged == ME_PLUGGED_OUT) {
 567                         if (((o_vendor_id == n_vendor_id) &&
 568                              (o_device_id == n_device_id) &&
 569                              (o_serial_no == n_serial_no) &&
 570                              (o_bus_type == n_bus_type)) ||
 571                             ((o_vendor_id == n_vendor_id) &&
 572                              (o_device_id == n_device_id) &&
 573                              (o_bus_type == n_bus_type) &&
 574                              (o_bus_no == n_bus_no) &&
 575                              (o_dev_no == n_dev_no) &&
 576                              (o_func_no == n_func_no))) {
 577                                 n_device->list.prev = pos->prev;
 578                                 n_device->list.next = pos->next;
 579                                 pos->prev->next = &n_device->list;
 580                                 pos->next->prev = &n_device->list;
 581                                 release_instance(o_device);
 582                                 break;
 583                         }
 584                 }
 585         }
 586
 587         if (pos == &me_device_list) {
 588                 list_add_tail(&n_device->list, &me_device_list);
 589         }
 590
 591         up_write(&me_rwsem);
 592
 593         return 0;
 594 }
 595
 596 static void me_remove_pci(struct pci_dev *dev)
 597 {
 598         int vendor_id = dev->vendor;
 599         int device_id = dev->device;
 600         int subsystem_vendor = dev->subsystem_vendor;
 601         int subsystem_device = dev->subsystem_device;
 602         int serial_no = (subsystem_device << 16) | subsystem_vendor;
 603
 604         PDEBUG("executed.\n");
 605
 606         PINFO("Vendor id = 0x%08X\n", vendor_id);
 607         PINFO("Device id = 0x%08X\n", device_id);
 608         PINFO("Serial Number = 0x%08X\n", serial_no);
 609
 610         replace_with_dummy(vendor_id, device_id, serial_no);
 611 }
 612
 613 static int replace_with_dummy(int vendor_id, int device_id, int serial_no)
 614 {
 615
 616         struct list_head *pos;
 617         me_device_t *n_device = NULL;
 618         me_device_t *o_device = NULL;
 619         int o_vendor_id;
 620         int o_device_id;
 621         int o_serial_no;
 622         int o_bus_type;
 623         int o_bus_no;
 624         int o_dev_no;
 625         int o_func_no;
 626         int o_plugged;
 627
 628         PDEBUG("executed.\n");
 629
 630         down_write(&me_rwsem);
 631
 632         list_for_each(pos, &me_device_list) {
 633                 o_device = list_entry(pos, me_device_t, list);
 634                 o_device->me_device_query_info_device(o_device,
 635                                                       &o_vendor_id,
 636                                                       &o_device_id,
 637                                                       &o_serial_no,
 638                                                       &o_bus_type,
 639                                                       &o_bus_no,
 640                                                       &o_dev_no,
 641                                                       &o_func_no, &o_plugged);
 642
 643                 if (o_plugged == ME_PLUGGED_IN) {
 644                         if (((o_vendor_id == vendor_id) &&
 645                              (o_device_id == device_id) &&
 646                              (o_serial_no == serial_no))) {
 647                                 n_device = get_dummy_instance(o_vendor_id,
 648                                                               o_device_id,
 649                                                               o_serial_no,
 650                                                               o_bus_type,
 651                                                               o_bus_no,
 652                                                               o_dev_no,
 653                                                               o_func_no);
 654
 655                                 if (!n_device) {
 656                                         up_write(&me_rwsem);
 657                                         PERROR("Cannot get dummy instance.\n");
 658                                         return 1;
 659                                 }
 660
 661                                 n_device->list.prev = pos->prev;
 662
 663                                 n_device->list.next = pos->next;
 664                                 pos->prev->next = &n_device->list;
 665                                 pos->next->prev = &n_device->list;
 666                                 release_instance(o_device);
 667                                 break;
 668                         }
 669                 }
 670         }
 671
 672         up_write(&me_rwsem);
 673
 674         return 0;
 675 }
 676
 677 static void clear_device_list(void)
 678 {
 679
 680         struct list_head *entry;
 681         me_device_t *device;
 682
 683         // Clear the device info list .
 684         down_write(&me_rwsem);
 685
 686         while (!list_empty(&me_device_list)) {
 687                 entry = me_device_list.next;
 688                 device = list_entry(entry, me_device_t, list);
 689                 list_del(entry);
 690                 release_instance(device);
 691         }
 692
 693         up_write(&me_rwsem);
 694 }
 695
 696 static int lock_driver(struct file *filep, int lock, int flags)
 697 {
 698         int err = ME_ERRNO_SUCCESS;
 699         me_device_t *device;
 700
 701         PDEBUG("executed.\n");
 702
 703         down_read(&me_rwsem);
 704
 705         spin_lock(&me_lock);
 706
 707         switch (lock) {
 708
 709         case ME_LOCK_SET:
 710                 if (me_count) {
 711                         PERROR
 712                             ("Driver System is currently used by another process.\n");
 713                         err = ME_ERRNO_USED;
 714                 } else if ((me_filep != NULL) && (me_filep != filep)) {
 715                         PERROR
 716                             ("Driver System is already logged by another process.\n");
 717                         err = ME_ERRNO_LOCKED;
 718                 } else {
 719                         list_for_each_entry(device, &me_device_list, list) {
 720                                 err =
 721                                     device->me_device_lock_device(device, filep,
 722                                                                   ME_LOCK_CHECK,
 723                                                                   flags);
 724
 725                                 if (err)
 726                                         break;
 727                         }
 728
 729                         if (!err)
 730                                 me_filep = filep;
 731                 }
 732
 733                 break;
 734
 735         case ME_LOCK_RELEASE:
 736                 if ((me_filep != NULL) && (me_filep != filep)) {
 737                         err = ME_ERRNO_SUCCESS;
 738                 } else {
 739                         list_for_each_entry(device, &me_device_list, list) {
 740                                 device->me_device_lock_device(device, filep,
 741                                                               ME_LOCK_RELEASE,
 742                                                               flags);
 743                         }
 744
 745                         me_filep = NULL;
 746                 }
 747
 748                 break;
 749
 750         default:
 751                 PERROR("Invalid lock specified.\n");
 752
 753                 err = ME_ERRNO_INVALID_LOCK;
 754
 755                 break;
 756         }
 757
 758         spin_unlock(&me_lock);
 759
 760         up_read(&me_rwsem);
 761
 762         return err;
 763 }
 764
 765 static int me_lock_driver(struct file *filep, me_lock_driver_t * arg)
 766 {
 767         int err = 0;
 768
 769         me_lock_driver_t lock;
 770
 771         PDEBUG("executed.\n");
 772
 773         err = copy_from_user(&lock, arg, sizeof(me_lock_driver_t));
 774
 775         if (err) {
 776                 PERROR("Can't copy arguments to kernel space.\n");
 777                 return -EFAULT;
 778         }
 779
 780         lock.errno = lock_driver(filep, lock.lock, lock.flags);
 781
 782         err = copy_to_user(arg, &lock, sizeof(me_lock_driver_t));
 783
 784         if (err) {
 785                 PERROR("Can't copy query back to user space.\n");
 786                 return -EFAULT;
 787         }
 788
 789         return ME_ERRNO_SUCCESS;
 790 }
 791
 792 static int me_open(struct inode *inode_ptr, struct file *filep)
 793 {
 794
 795         PDEBUG("executed.\n");
 796         // Nothing to do here.
 797         return 0;
 798 }
 799
 800 static int me_release(struct inode *inode_ptr, struct file *filep)
 801 {
 802
 803         PDEBUG("executed.\n");
 804         lock_driver(filep, ME_LOCK_RELEASE, ME_LOCK_DRIVER_NO_FLAGS);
 805
 806         return 0;
 807 }
 808
 809 static int me_query_version_main_driver(struct file *filep,
 810                                         me_query_version_main_driver_t * arg)
 811 {
 812         int err;
 813         me_query_version_main_driver_t karg;
 814
 815         PDEBUG("executed.\n");
 816
 817         karg.version = ME_VERSION_DRIVER;
 818         karg.errno = ME_ERRNO_SUCCESS;
 819
 820         err = copy_to_user(arg, &karg, sizeof(me_query_version_main_driver_t));
 821
 822         if (err) {
 823                 PERROR("Can't copy query back to user space.\n");
 824                 return -EFAULT;
 825         }
 826
 827         return 0;
 828 }
 829
 830 static int me_config_load_device(struct file *filep,
 831                                  me_cfg_device_entry_t * karg, int device_no)
 832 {
 833
 834         int err = ME_ERRNO_SUCCESS;
 835         int k = 0;
 836
 837         struct list_head *pos = NULL;
 838         me_device_t *device = NULL;
 839
 840         PDEBUG("executed.\n");
 841
 842         list_for_each(pos, &me_device_list) {
 843                 if (k == device_no) {
 844                         device = list_entry(pos, me_device_t, list);
 845                         break;
 846                 }
 847
 848                 k++;
 849         }
 850
 851         if (pos == &me_device_list) {
 852                 PERROR("Invalid device number specified.\n");
 853                 return ME_ERRNO_INVALID_DEVICE;
 854         } else {
 855                 spin_lock(&me_lock);
 856
 857                 if ((me_filep != NULL) && (me_filep != filep)) {
 858                         spin_unlock(&me_lock);
 859                         PERROR("Resource is locked by another process.\n");
 860                         return ME_ERRNO_LOCKED;
 861                 } else {
 862                         me_count++;
 863                         spin_unlock(&me_lock);
 864
 865                         err =
 866                             device->me_device_config_load(device, filep, karg);
 867
 868                         spin_lock(&me_lock);
 869                         me_count--;
 870                         spin_unlock(&me_lock);
 871                 }
 872         }
 873
 874         return err;
 875 }
 876
 877 static int me_config_load(struct file *filep, me_config_load_t * arg)
 878 {
 879         int err;
 880         int i;
 881         me_config_load_t cfg_setup;
 882         me_config_load_t karg_cfg_setup;
 883
 884         struct list_head *pos = NULL;
 885
 886         struct list_head new_list;
 887         me_device_t *o_device;
 888         me_device_t *n_device;
 889         int o_vendor_id;
 890         int o_device_id;
 891         int o_serial_no;
 892         int o_bus_type;
 893         int o_bus_no;
 894         int o_dev_no;
 895         int o_func_no;
 896         int o_plugged;
 897
 898         PDEBUG("executed.\n");
 899
 900         // Copy argument to kernel space.
 901         err = copy_from_user(&karg_cfg_setup, arg, sizeof(me_config_load_t));
 902
 903         if (err) {
 904                 PERROR("Can't copy arguments to kernel space.\n");
 905                 return -EFAULT;
 906         }
 907         // Allocate kernel buffer for device list.
 908         cfg_setup.device_list =
 909             kmalloc(sizeof(me_cfg_device_entry_t) * karg_cfg_setup.count,
 910                     GFP_KERNEL);
 911
 912         if (!cfg_setup.device_list) {
 913                 PERROR("Can't get buffer %li for device list.\n",
 914                        sizeof(me_cfg_device_entry_t) * karg_cfg_setup.count);
 915                 return -ENOMEM;
 916         }
 917         // Copy device list to kernel space.
 918         err =
 919             copy_from_user(cfg_setup.device_list, karg_cfg_setup.device_list,
 920                            sizeof(me_cfg_device_entry_t) *
 921                            karg_cfg_setup.count);
 922
 923         if (err) {
 924                 PERROR("Can't copy device list to kernel space.\n");
 925                 kfree(cfg_setup.device_list);
 926                 return -EFAULT;
 927         }
 928
 929         cfg_setup.count = karg_cfg_setup.count;
 930
 931         INIT_LIST_HEAD(&new_list);
 932
 933         down_write(&me_rwsem);
 934
 935         spin_lock(&me_lock);
 936
 937         if ((me_filep != NULL) && (me_filep != filep)) {
 938                 spin_unlock(&me_lock);
 939                 PERROR("Driver System is logged by another process.\n");
 940                 karg_cfg_setup.errno = ME_ERRNO_LOCKED;
 941         } else {
 942                 me_count++;
 943                 spin_unlock(&me_lock);
 944
 945                 for (i = 0; i < karg_cfg_setup.count; i++) {
 946                         PDEBUG("me_config_load() device=%d.\n", i);
 947                         if (cfg_setup.device_list[i].tcpip.access_type ==
 948                             ME_ACCESS_TYPE_LOCAL) {
 949                                 list_for_each(pos, &me_device_list) {
 950                                         o_device =
 951                                             list_entry(pos, me_device_t, list);
 952                                         o_device->
 953                                             me_device_query_info_device
 954                                             (o_device, &o_vendor_id,
 955                                              &o_device_id, &o_serial_no,
 956                                              &o_bus_type, &o_bus_no, &o_dev_no,
 957                                              &o_func_no, &o_plugged);
 958
 959                                         if (cfg_setup.device_list[i].info.
 960                                             hw_location.bus_type ==
 961                                             ME_BUS_TYPE_PCI) {
 962                                                 if (((o_vendor_id ==
 963                                                       cfg_setup.device_list[i].
 964                                                       info.vendor_id)
 965                                                      && (o_device_id ==
 966                                                          cfg_setup.
 967                                                          device_list[i].info.
 968                                                          device_id)
 969                                                      && (o_serial_no ==
 970                                                          cfg_setup.
 971                                                          device_list[i].info.
 972                                                          serial_no)
 973                                                      && (o_bus_type ==
 974                                                          cfg_setup.
 975                                                          device_list[i].info.
 976                                                          hw_location.bus_type))
 977                                                     ||
 978                                                     ((o_vendor_id ==
 979                                                       cfg_setup.device_list[i].
 980                                                       info.vendor_id)
 981                                                      && (o_device_id ==
 982                                                          cfg_setup.
 983                                                          device_list[i].info.
 984                                                          device_id)
 985                                                      && (o_bus_type ==
 986                                                          cfg_setup.
 987                                                          device_list[i].info.
 988                                                          hw_location.bus_type)
 989                                                      && (o_bus_no ==
 990                                                          cfg_setup.
 991                                                          device_list[i].info.
 992                                                          hw_location.pci.bus_no)
 993                                                      && (o_dev_no ==
 994                                                          cfg_setup.
 995                                                          device_list[i].info.
 996                                                          hw_location.pci.
 997                                                          device_no)
 998                                                      && (o_func_no ==
 999                                                          cfg_setup.
1000                                                          device_list[i].info.
1001                                                          hw_location.pci.
1002                                                          function_no))) {
1003                                                         list_move_tail(pos,
1004                                                                        &new_list);
1005                                                         break;
1006                                                 }
1007                                         }
1008 /*
1009                                         else if (cfg_setup.device_list[i].info.hw_location.bus_type == ME_BUS_TYPE_USB)
1010                                         {
1011                                                 if (((o_vendor_id == cfg_setup.device_list[i].info.vendor_id) &&
1012                                                         (o_device_id == cfg_setup.device_list[i].info.device_id) &&
1013                                                         (o_serial_no == cfg_setup.device_list[i].info.serial_no) &&
1014                                                         (o_bus_type == cfg_setup.device_list[i].info.hw_location.bus_type)) ||
1015                                                         ((o_vendor_id == cfg_setup.device_list[i].info.vendor_id) &&
1016                                                          (o_device_id == cfg_setup.device_list[i].info.device_id) &&
1017                                                          (o_bus_type == cfg_setup.device_list[i].info.hw_location.bus_type) &&
1018                                                          (o_bus_no == cfg_setup.device_list[i].info.hw_location.usb.root_hub_no)))
1019                                                 {
1020                                                         list_move_tail(pos, &new_list);
1021                                                         break;
1022                                                 }
1023                                         }
1024 */
1025                                         else {
1026                                                 PERROR("Wrong bus type: %d.\n",
1027                                                        cfg_setup.device_list[i].
1028                                                        info.hw_location.
1029                                                        bus_type);
1030                                         }
1031                                 }
1032
1033                                 if (pos == &me_device_list) {   // Device is not already in the list
1034                                         if (cfg_setup.device_list[i].info.
1035                                             hw_location.bus_type ==
1036                                             ME_BUS_TYPE_PCI) {
1037                                                 n_device =
1038                                                     get_dummy_instance
1039                                                     (cfg_setup.device_list[i].
1040                                                      info.vendor_id,
1041                                                      cfg_setup.device_list[i].
1042                                                      info.device_id,
1043                                                      cfg_setup.device_list[i].
1044                                                      info.serial_no,
1045                                                      cfg_setup.device_list[i].
1046                                                      info.hw_location.bus_type,
1047                                                      cfg_setup.device_list[i].
1048                                                      info.hw_location.pci.
1049                                                      bus_no,
1050                                                      cfg_setup.device_list[i].
1051                                                      info.hw_location.pci.
1052                                                      device_no,
1053                                                      cfg_setup.device_list[i].
1054                                                      info.hw_location.pci.
1055                                                      function_no);
1056
1057                                                 if (!n_device) {
1058                                                         PERROR
1059                                                             ("Can't get dummy instance.\n");
1060                                                         kfree(cfg_setup.
1061                                                               device_list);
1062                                                         spin_lock(&me_lock);
1063                                                         me_count--;
1064                                                         spin_unlock(&me_lock);
1065                                                         up_write(&me_rwsem);
1066                                                         return -EFAULT;
1067                                                 }
1068
1069                                                 list_add_tail(&n_device->list,
1070                                                               &new_list);
1071                                         }
1072 /*
1073                                         else if (cfg_setup.device_list[i].info.hw_location.bus_type == ME_BUS_TYPE_USB)
1074                                         {
1075                                                 n_device = get_dummy_instance(
1076                                                                cfg_setup.device_list[i].info.vendor_id,
1077                                                                cfg_setup.device_list[i].info.device_id,
1078                                                                cfg_setup.device_list[i].info.serial_no,
1079                                                                cfg_setup.device_list[i].info.hw_location.bus_type,
1080                                                                cfg_setup.device_list[i].info.hw_location.usb.root_hub_no,
1081                                                                0,
1082                                                                0);
1083
1084                                                 if (!n_device)
1085                                                 {
1086                                                         PERROR("Can't get dummy instance.\n");
1087                                                         kfree(cfg_setup.device_list);
1088                                                         spin_lock(&me_lock);
1089                                                         me_count--;
1090                                                         spin_unlock(&me_lock);
1091                                                         up_write(&me_rwsem);
1092                                                         return -EFAULT;
1093                                                 }
1094
1095                                                 list_add_tail(&n_device->list, &new_list);
1096                                         }
1097 */
1098                                 }
1099                         } else {
1100                                 n_device = get_dummy_instance(0,
1101                                                               0, 0, 0, 0, 0, 0);
1102
1103                                 if (!n_device) {
1104                                         PERROR("Can't get dummy instance.\n");
1105                                         kfree(cfg_setup.device_list);
1106                                         spin_lock(&me_lock);
1107                                         me_count--;
1108                                         spin_unlock(&me_lock);
1109                                         up_write(&me_rwsem);
1110                                         return -EFAULT;
1111                                 }
1112
1113                                 list_add_tail(&n_device->list, &new_list);
1114                         }
1115                 }
1116
1117                 while (!list_empty(&me_device_list)) {
1118                         o_device =
1119                             list_entry(me_device_list.next, me_device_t, list);
1120                         o_device->me_device_query_info_device(o_device,
1121                                                               &o_vendor_id,
1122                                                               &o_device_id,
1123                                                               &o_serial_no,
1124                                                               &o_bus_type,
1125                                                               &o_bus_no,
1126                                                               &o_dev_no,
1127                                                               &o_func_no,
1128                                                               &o_plugged);
1129
1130                         if (o_plugged == ME_PLUGGED_IN) {
1131                                 list_move_tail(me_device_list.next, &new_list);
1132                         } else {
1133                                 list_del(me_device_list.next);
1134                                 release_instance(o_device);
1135                         }
1136                 }
1137
1138                 // Move temporary new list to global driver list.
1139                 list_splice(&new_list, &me_device_list);
1140
1141                 karg_cfg_setup.errno = ME_ERRNO_SUCCESS;
1142         }
1143
1144         for (i = 0; i < cfg_setup.count; i++) {
1145
1146                 karg_cfg_setup.errno =
1147                     me_config_load_device(filep, &cfg_setup.device_list[i], i);
1148                 if (karg_cfg_setup.errno) {
1149                         PERROR("me_config_load_device(%d)=%d\n", i,
1150                                karg_cfg_setup.errno);
1151                         break;
1152                 }
1153         }
1154
1155         spin_lock(&me_lock);
1156
1157         me_count--;
1158         spin_unlock(&me_lock);
1159         up_write(&me_rwsem);
1160
1161         err = copy_to_user(arg, &karg_cfg_setup, sizeof(me_config_load_t));
1162
1163         if (err) {
1164                 PERROR("Can't copy config list to user space.\n");
1165                 kfree(cfg_setup.device_list);
1166                 return -EFAULT;
1167         }
1168
1169         kfree(cfg_setup.device_list);
1170         return 0;
1171 }
1172
1173 static int me_io_stream_start(struct file *filep, me_io_stream_start_t * arg)
1174 {
1175         int err;
1176         int i, k;
1177
1178         struct list_head *pos;
1179         me_device_t *device;
1180         me_io_stream_start_t karg;
1181         meIOStreamStart_t *list;
1182
1183         PDEBUG("executed.\n");
1184
1185         err = copy_from_user(&karg, arg, sizeof(me_io_stream_start_t));
1186
1187         if (err) {
1188                 PERROR("Can't copy arguments to kernel space.\n");
1189                 return -EFAULT;
1190         }
1191
1192         karg.errno = ME_ERRNO_SUCCESS;
1193
1194         list = kmalloc(sizeof(meIOStreamStart_t) * karg.count, GFP_KERNEL);
1195
1196         if (!list) {
1197                 PERROR("Can't get buffer for start list.\n");
1198                 return -ENOMEM;
1199         }
1200
1201         err =
1202             copy_from_user(list, karg.start_list,
1203                            sizeof(meIOStreamStart_t) * karg.count);
1204
1205         if (err) {
1206                 PERROR("Can't copy start list to kernel space.\n");
1207                 kfree(list);
1208                 return -EFAULT;
1209         }
1210
1211         spin_lock(&me_lock);
1212
1213         if ((me_filep != NULL) && (me_filep != filep)) {
1214                 spin_unlock(&me_lock);
1215                 PERROR("Driver System is logged by another process.\n");
1216
1217                 for (i = 0; i < karg.count; i++) {
1218                         list[i].iErrno = ME_ERRNO_LOCKED;
1219                 }
1220         } else {
1221                 me_count++;
1222                 spin_unlock(&me_lock);
1223
1224                 for (i = 0; i < karg.count; i++) {
1225                         down_read(&me_rwsem);
1226                         k = 0;
1227                         list_for_each(pos, &me_device_list) {
1228                                 if (k == list[i].iDevice) {
1229                                         device =
1230                                             list_entry(pos, me_device_t, list);
1231                                         break;
1232                                 }
1233
1234                                 k++;
1235                         }
1236
1237                         if (pos == &me_device_list) {
1238                                 up_read(&me_rwsem);
1239                                 PERROR("Invalid device number specified.\n");
1240                                 list[i].iErrno = ME_ERRNO_INVALID_DEVICE;
1241                                 karg.errno = ME_ERRNO_INVALID_DEVICE;
1242                                 break;
1243                         } else {
1244                                 list[i].iErrno =
1245                                     device->me_device_io_stream_start(device,
1246                                                                       filep,
1247                                                                       list[i].
1248                                                                       iSubdevice,
1249                                                                       list[i].
1250                                                                       iStartMode,
1251                                                                       list[i].
1252                                                                       iTimeOut,
1253                                                                       list[i].
1254                                                                       iFlags);
1255
1256                                 if (list[i].iErrno) {
1257                                         up_read(&me_rwsem);
1258                                         karg.errno = list[i].iErrno;
1259                                         break;
1260                                 }
1261                         }
1262
1263                         up_read(&me_rwsem);
1264                 }
1265
1266                 spin_lock(&me_lock);
1267
1268                 me_count--;
1269                 spin_unlock(&me_lock);
1270         }
1271
1272         err = copy_to_user(arg, &karg, sizeof(me_io_stream_start_t));
1273
1274         if (err) {
1275                 PERROR("Can't copy arguments to user space.\n");
1276                 kfree(list);
1277                 return -EFAULT;
1278         }
1279
1280         err =
1281             copy_to_user(karg.start_list, list,
1282                          sizeof(meIOStreamStart_t) * karg.count);
1283
1284         if (err) {
1285                 PERROR("Can't copy start list to user space.\n");
1286                 kfree(list);
1287                 return -EFAULT;
1288         }
1289
1290         kfree(list);
1291
1292         return err;
1293 }
1294
1295 static int me_io_single(struct file *filep, me_io_single_t * arg)
1296 {
1297         int err;
1298         int i, k;
1299
1300         struct list_head *pos;
1301         me_device_t *device;
1302         me_io_single_t karg;
1303         meIOSingle_t *list;
1304
1305         PDEBUG("executed.\n");
1306
1307         err = copy_from_user(&karg, arg, sizeof(me_io_single_t));
1308
1309         if (err) {
1310                 PERROR("Can't copy arguments to kernel space.\n");
1311                 return -EFAULT;
1312         }
1313
1314         karg.errno = ME_ERRNO_SUCCESS;
1315
1316         list = kmalloc(sizeof(meIOSingle_t) * karg.count, GFP_KERNEL);
1317
1318         if (!list) {
1319                 PERROR("Can't get buffer for single list.\n");
1320                 return -ENOMEM;
1321         }
1322
1323         err =
1324             copy_from_user(list, karg.single_list,
1325                            sizeof(meIOSingle_t) * karg.count);
1326
1327         if (err) {
1328                 PERROR("Can't copy single list to kernel space.\n");
1329                 kfree(list);
1330                 return -EFAULT;
1331         }
1332
1333         spin_lock(&me_lock);
1334
1335         if ((me_filep != NULL) && (me_filep != filep)) {
1336                 spin_unlock(&me_lock);
1337                 PERROR("Driver System is logged by another process.\n");
1338
1339                 for (i = 0; i < karg.count; i++) {
1340                         list[i].iErrno = ME_ERRNO_LOCKED;
1341                 }
1342         } else {
1343                 me_count++;
1344                 spin_unlock(&me_lock);
1345
1346                 for (i = 0; i < karg.count; i++) {
1347                         k = 0;
1348
1349                         down_read(&me_rwsem);
1350
1351                         list_for_each(pos, &me_device_list) {
1352                                 if (k == list[i].iDevice) {
1353                                         device =
1354                                             list_entry(pos, me_device_t, list);
1355                                         break;
1356                                 }
1357
1358                                 k++;
1359                         }
1360
1361                         if (pos == &me_device_list) {
1362                                 up_read(&me_rwsem);
1363                                 PERROR("Invalid device number specified.\n");
1364                                 list[i].iErrno = ME_ERRNO_INVALID_DEVICE;
1365                                 karg.errno = ME_ERRNO_INVALID_DEVICE;
1366                                 break;
1367                         } else {
1368                                 if (list[i].iDir == ME_DIR_OUTPUT) {
1369                                         list[i].iErrno =
1370                                             device->
1371                                             me_device_io_single_write(device,
1372                                                                       filep,
1373                                                                       list[i].
1374                                                                       iSubdevice,
1375                                                                       list[i].
1376                                                                       iChannel,
1377                                                                       list[i].
1378                                                                       iValue,
1379                                                                       list[i].
1380                                                                       iTimeOut,
1381                                                                       list[i].
1382                                                                       iFlags);
1383
1384                                         if (list[i].iErrno) {
1385                                                 up_read(&me_rwsem);
1386                                                 karg.errno = list[i].iErrno;
1387                                                 break;
1388                                         }
1389                                 } else if (list[i].iDir == ME_DIR_INPUT) {
1390                                         list[i].iErrno =
1391                                             device->
1392                                             me_device_io_single_read(device,
1393                                                                      filep,
1394                                                                      list[i].
1395                                                                      iSubdevice,
1396                                                                      list[i].
1397                                                                      iChannel,
1398                                                                      &list[i].
1399                                                                      iValue,
1400                                                                      list[i].
1401                                                                      iTimeOut,
1402                                                                      list[i].
1403                                                                      iFlags);
1404
1405                                         if (list[i].iErrno) {
1406                                                 up_read(&me_rwsem);
1407                                                 karg.errno = list[i].iErrno;
1408                                                 break;
1409                                         }
1410                                 } else {
1411                                         up_read(&me_rwsem);
1412                                         PERROR
1413                                             ("Invalid single direction specified.\n");
1414                                         list[i].iErrno = ME_ERRNO_INVALID_DIR;
1415                                         karg.errno = ME_ERRNO_INVALID_DIR;
1416                                         break;
1417                                 }
1418                         }
1419
1420                         up_read(&me_rwsem);
1421                 }
1422
1423                 spin_lock(&me_lock);
1424
1425                 me_count--;
1426                 spin_unlock(&me_lock);
1427         }
1428
1429         err = copy_to_user(arg, &karg, sizeof(me_io_single_t));
1430
1431         if (err) {
1432                 PERROR("Can't copy arguments to user space.\n");
1433                 return -EFAULT;
1434         }
1435
1436         err =
1437             copy_to_user(karg.single_list, list,
1438                          sizeof(meIOSingle_t) * karg.count);
1439
1440         if (err) {
1441                 PERROR("Can't copy single list to user space.\n");
1442                 kfree(list);
1443                 return -EFAULT;
1444         }
1445
1446         kfree(list);
1447
1448         return err;
1449 }
1450
1451 static int me_io_stream_config(struct file *filep, me_io_stream_config_t * arg)
1452 {
1453         int err;
1454         int k = 0;
1455
1456         struct list_head *pos;
1457         me_device_t *device;
1458         me_io_stream_config_t karg;
1459         meIOStreamConfig_t *list;
1460
1461         PDEBUG("executed.\n");
1462
1463         err = copy_from_user(&karg, arg, sizeof(me_io_stream_config_t));
1464
1465         if (err) {
1466                 PERROR("Can't copy arguments to kernel space.\n");
1467                 return -EFAULT;
1468         }
1469
1470         list = kmalloc(sizeof(meIOStreamConfig_t) * karg.count, GFP_KERNEL);
1471
1472         if (!list) {
1473                 PERROR("Can't get buffer for config list.\n");
1474                 return -ENOMEM;
1475         }
1476
1477         err =
1478             copy_from_user(list, karg.config_list,
1479                            sizeof(meIOStreamConfig_t) * karg.count);
1480
1481         if (err) {
1482                 PERROR("Can't copy config list to kernel space.\n");
1483                 kfree(list);
1484                 return -EFAULT;
1485         }
1486
1487         spin_lock(&me_lock);
1488
1489         if ((me_filep != NULL) && (me_filep != filep)) {
1490                 spin_unlock(&me_lock);
1491                 PERROR("Driver System is logged by another process.\n");
1492                 karg.errno = ME_ERRNO_LOCKED;
1493         } else {
1494                 me_count++;
1495                 spin_unlock(&me_lock);
1496
1497                 down_read(&me_rwsem);
1498
1499                 list_for_each(pos, &me_device_list) {
1500                         if (k == karg.device) {
1501                                 device = list_entry(pos, me_device_t, list);
1502                                 break;
1503                         }
1504
1505                         k++;
1506                 }
1507
1508                 if (pos == &me_device_list) {
1509                         PERROR("Invalid device number specified.\n");
1510                         karg.errno = ME_ERRNO_INVALID_DEVICE;
1511                 } else {
1512                         karg.errno =
1513                             device->me_device_io_stream_config(device, filep,
1514                                                                karg.subdevice,
1515                                                                list, karg.count,
1516                                                                &karg.trigger,
1517                                                                karg.
1518                                                                fifo_irq_threshold,
1519                                                                karg.flags);
1520                 }
1521
1522                 up_read(&me_rwsem);
1523
1524                 spin_lock(&me_lock);
1525                 me_count--;
1526                 spin_unlock(&me_lock);
1527         }
1528
1529         err = copy_to_user(arg, &karg, sizeof(me_io_stream_config_t));
1530
1531         if (err) {
1532                 PERROR("Can't copy back to user space.\n");
1533                 kfree(list);
1534                 return -EFAULT;
1535         }
1536
1537         kfree(list);
1538
1539         return err;
1540 }
1541
1542 static int me_query_number_devices(struct file *filep,
1543                                    me_query_number_devices_t * arg)
1544 {
1545         int err;
1546         me_query_number_devices_t karg;
1547
1548         struct list_head *pos;
1549
1550         PDEBUG("executed.\n");
1551
1552         karg.number = 0;
1553         down_read(&me_rwsem);
1554         list_for_each(pos, &me_device_list) {
1555                 karg.number++;
1556         }
1557
1558         up_read(&me_rwsem);
1559
1560         karg.errno = ME_ERRNO_SUCCESS;
1561
1562         err = copy_to_user(arg, &karg, sizeof(me_query_number_devices_t));
1563
1564         if (err) {
1565                 PERROR("Can't copy query back to user space.\n");
1566                 return -EFAULT;
1567         }
1568
1569         return 0;
1570 }
1571
1572 static int me_io_stream_stop(struct file *filep, me_io_stream_stop_t * arg)
1573 {
1574         int err;
1575         int i, k;
1576
1577         struct list_head *pos;
1578         me_device_t *device;
1579         me_io_stream_stop_t karg;
1580         meIOStreamStop_t *list;
1581
1582         PDEBUG("executed.\n");
1583
1584         err = copy_from_user(&karg, arg, sizeof(me_io_stream_stop_t));
1585
1586         if (err) {
1587                 PERROR("Can't copy arguments to kernel space.\n");
1588                 return -EFAULT;
1589         }
1590
1591         karg.errno = ME_ERRNO_SUCCESS;
1592
1593         list = kmalloc(sizeof(meIOStreamStop_t) * karg.count, GFP_KERNEL);
1594
1595         if (!list) {
1596                 PERROR("Can't get buffer for stop list.\n");
1597                 return -ENOMEM;
1598         }
1599
1600         err =
1601             copy_from_user(list, karg.stop_list,
1602                            sizeof(meIOStreamStop_t) * karg.count);
1603
1604         if (err) {
1605                 PERROR("Can't copy stop list to kernel space.\n");
1606                 kfree(list);
1607                 return -EFAULT;
1608         }
1609
1610         spin_lock(&me_lock);
1611
1612         if ((me_filep != NULL) && (me_filep != filep)) {
1613                 spin_unlock(&me_lock);
1614                 PERROR("Driver System is logged by another process.\n");
1615
1616                 for (i = 0; i < karg.count; i++) {
1617                         list[i].iErrno = ME_ERRNO_LOCKED;
1618                 }
1619         } else {
1620                 me_count++;
1621                 spin_unlock(&me_lock);
1622
1623                 for (i = 0; i < karg.count; i++) {
1624                         k = 0;
1625                         down_read(&me_rwsem);
1626                         list_for_each(pos, &me_device_list) {
1627                                 if (k == list[i].iDevice) {
1628                                         device =
1629                                             list_entry(pos, me_device_t, list);
1630                                         break;
1631                                 }
1632
1633                                 k++;
1634                         }
1635
1636                         if (pos == &me_device_list) {
1637                                 up_read(&me_rwsem);
1638                                 PERROR("Invalid device number specified.\n");
1639                                 list[i].iErrno = ME_ERRNO_INVALID_DEVICE;
1640                                 karg.errno = ME_ERRNO_INVALID_DEVICE;
1641                                 break;
1642                         } else {
1643                                 list[i].iErrno =
1644                                     device->me_device_io_stream_stop(device,
1645                                                                      filep,
1646                                                                      list[i].
1647                                                                      iSubdevice,
1648                                                                      list[i].
1649                                                                      iStopMode,
1650                                                                      list[i].
1651                                                                      iFlags);
1652
1653                                 if (list[i].iErrno) {
1654                                         up_read(&me_rwsem);
1655                                         karg.errno = list[i].iErrno;
1656                                         break;
1657                                 }
1658                         }
1659
1660                         up_read(&me_rwsem);
1661                 }
1662
1663                 spin_lock(&me_lock);
1664
1665                 me_count--;
1666                 spin_unlock(&me_lock);
1667         }
1668
1669         err = copy_to_user(arg, &karg, sizeof(me_io_stream_stop_t));
1670
1671         if (err) {
1672                 PERROR("Can't copy arguments to user space.\n");
1673                 return -EFAULT;
1674         }
1675
1676         err =
1677             copy_to_user(karg.stop_list, list,
1678                          sizeof(meIOStreamStop_t) * karg.count);
1679
1680         if (err) {
1681                 PERROR("Can't copy stop list to user space.\n");
1682                 kfree(list);
1683                 return -EFAULT;
1684         }
1685
1686         kfree(list);
1687
1688         return err;
1689 }
1690
1691 /*  //me_probe_usb
1692 static int me_probe_usb(struct usb_interface *interface, const struct usb_device_id *id)
1693 {
1694         //int err;
1695         //me_usb_constructor_t *constructor = NULL;
1696         me_device_t *n_device = NULL;
1697
1698         PDEBUG("executed.\n");
1699
1700         switch (id->idProduct)
1701         {
1702                         case USB_DEVICE_ID_MEPHISTO_S1:
1703                                 if((constructor = symbol_get(mephisto_s1_constructor)) == NULL){
1704                                         err = request_module(MEPHISTO_S1_NAME);
1705                                         if(err){
1706                                                 PERROR("Error while request for module %s.\n", MEPHISTO_S1_NAME);
1707                                                 return -ENODEV;
1708                                         }
1709                                         if((constructor = symbol_get(mephisto_s1_constructor)) == NULL){
1710                                                 PERROR("Can't get %s driver module constructor.\n", MEPHISTO_S1_NAME);
1711                                                 return -ENODEV;
1712                                         }
1713                                 }
1714
1715                                 if((n_device = (*constructor)(interface)) == NULL){
1716                                         symbol_put(mephisto_s1_constructor);
1717                                         PERROR("Can't get device instance of %s driver module.\n", MEPHISTO_S1_NAME);
1718                                         return -ENODEV;
1719                                 }
1720
1721                                 break;
1722
1723                 default:
1724                         PERROR("Invalid product id.\n");
1725
1726                         return -EINVAL;
1727         }
1728
1729         return insert_to_device_list(n_device);
1730 }
1731 */
1732
1733 /*  //me_disconnect_usb
1734 static void me_disconnect_usb(struct usb_interface *interface)
1735 {
1736
1737         struct usb_device *device = interface_to_usbdev(interface);
1738         int vendor_id = device->descriptor.idVendor;
1739         int device_id = device->descriptor.idProduct;
1740         int serial_no;
1741
1742         sscanf(&device->serial[2], "%x", &serial_no);
1743
1744         PDEBUG("executed.\n");
1745
1746         PINFO("Vendor id = 0x%08X\n", vendor_id);
1747         PINFO("Device id = 0x%08X\n", device_id);
1748         PINFO("Serial Number = 0x%08X\n", serial_no);
1749
1750         replace_with_dummy(vendor_id, device_id, serial_no);
1751 }
1752 */
1753
1754 static int me_ioctl(struct inode *inodep,
1755                     struct file *filep, unsigned int service, unsigned long arg)
1756 {
1757
1758         PDEBUG("executed.\n");
1759
1760         if (_IOC_TYPE(service) != MEMAIN_MAGIC) {
1761                 PERROR("Invalid magic number.\n");
1762                 return -ENOTTY;
1763         }
1764
1765         PDEBUG("service number: 0x%x.\n", service);
1766
1767         switch (service) {
1768         case ME_IO_IRQ_ENABLE:
1769                 return me_io_irq_start(filep, (me_io_irq_start_t *) arg);
1770
1771         case ME_IO_IRQ_WAIT:
1772                 return me_io_irq_wait(filep, (me_io_irq_wait_t *) arg);
1773
1774         case ME_IO_IRQ_DISABLE:
1775                 return me_io_irq_stop(filep, (me_io_irq_stop_t *) arg);
1776
1777         case ME_IO_RESET_DEVICE:
1778                 return me_io_reset_device(filep, (me_io_reset_device_t *) arg);
1779
1780         case ME_IO_RESET_SUBDEVICE:
1781                 return me_io_reset_subdevice(filep,
1782                                              (me_io_reset_subdevice_t *) arg);
1783
1784         case ME_IO_SINGLE_CONFIG:
1785                 return me_io_single_config(filep,
1786                                            (me_io_single_config_t *) arg);
1787
1788         case ME_IO_SINGLE:
1789                 return me_io_single(filep, (me_io_single_t *) arg);
1790
1791         case ME_IO_STREAM_CONFIG:
1792                 return me_io_stream_config(filep,
1793                                            (me_io_stream_config_t *) arg);
1794
1795         case ME_IO_STREAM_NEW_VALUES:
1796                 return me_io_stream_new_values(filep,
1797                                                (me_io_stream_new_values_t *)
1798                                                arg);
1799
1800         case ME_IO_STREAM_READ:
1801                 return me_io_stream_read(filep, (me_io_stream_read_t *) arg);
1802
1803         case ME_IO_STREAM_START:
1804                 return me_io_stream_start(filep, (me_io_stream_start_t *) arg);
1805
1806         case ME_IO_STREAM_STATUS:
1807                 return me_io_stream_status(filep,
1808                                            (me_io_stream_status_t *) arg);
1809
1810         case ME_IO_STREAM_STOP:
1811                 return me_io_stream_stop(filep, (me_io_stream_stop_t *) arg);
1812
1813         case ME_IO_STREAM_WRITE:
1814                 return me_io_stream_write(filep, (me_io_stream_write_t *) arg);
1815
1816         case ME_LOCK_DRIVER:
1817                 return me_lock_driver(filep, (me_lock_driver_t *) arg);
1818
1819         case ME_LOCK_DEVICE:
1820                 return me_lock_device(filep, (me_lock_device_t *) arg);
1821
1822         case ME_LOCK_SUBDEVICE:
1823                 return me_lock_subdevice(filep, (me_lock_subdevice_t *) arg);
1824
1825         case ME_QUERY_INFO_DEVICE:
1826                 return me_query_info_device(filep,
1827                                             (me_query_info_device_t *) arg);
1828
1829         case ME_QUERY_DESCRIPTION_DEVICE:
1830                 return me_query_description_device(filep,
1831                                                    (me_query_description_device_t
1832                                                     *) arg);
1833
1834         case ME_QUERY_NAME_DEVICE:
1835                 return me_query_name_device(filep,
1836                                             (me_query_name_device_t *) arg);
1837
1838         case ME_QUERY_NAME_DEVICE_DRIVER:
1839                 return me_query_name_device_driver(filep,
1840                                                    (me_query_name_device_driver_t
1841                                                     *) arg);
1842
1843         case ME_QUERY_NUMBER_DEVICES:
1844                 return me_query_number_devices(filep,
1845                                                (me_query_number_devices_t *)
1846                                                arg);
1847
1848         case ME_QUERY_NUMBER_SUBDEVICES:
1849                 return me_query_number_subdevices(filep,
1850                                                   (me_query_number_subdevices_t
1851                                                    *) arg);
1852
1853         case ME_QUERY_NUMBER_CHANNELS:
1854                 return me_query_number_channels(filep,
1855                                                 (me_query_number_channels_t *)
1856                                                 arg);
1857
1858         case ME_QUERY_NUMBER_RANGES:
1859                 return me_query_number_ranges(filep,
1860                                               (me_query_number_ranges_t *) arg);
1861
1862         case ME_QUERY_RANGE_BY_MIN_MAX:
1863                 return me_query_range_by_min_max(filep,
1864                                                  (me_query_range_by_min_max_t *)
1865                                                  arg);
1866
1867         case ME_QUERY_RANGE_INFO:
1868                 return me_query_range_info(filep,
1869                                            (me_query_range_info_t *) arg);
1870
1871         case ME_QUERY_SUBDEVICE_BY_TYPE:
1872                 return me_query_subdevice_by_type(filep,
1873                                                   (me_query_subdevice_by_type_t
1874                                                    *) arg);
1875
1876         case ME_QUERY_SUBDEVICE_TYPE:
1877                 return me_query_subdevice_type(filep,
1878                                                (me_query_subdevice_type_t *)
1879                                                arg);
1880
1881         case ME_QUERY_SUBDEVICE_CAPS:
1882                 return me_query_subdevice_caps(filep,
1883                                                (me_query_subdevice_caps_t *)
1884                                                arg);
1885
1886         case ME_QUERY_SUBDEVICE_CAPS_ARGS:
1887                 return me_query_subdevice_caps_args(filep,
1888                                                     (me_query_subdevice_caps_args_t
1889                                                      *) arg);
1890
1891         case ME_QUERY_TIMER:
1892                 return me_query_timer(filep, (me_query_timer_t *) arg);
1893
1894         case ME_QUERY_VERSION_MAIN_DRIVER:
1895                 return me_query_version_main_driver(filep,
1896                                                     (me_query_version_main_driver_t
1897                                                      *) arg);
1898
1899         case ME_QUERY_VERSION_DEVICE_DRIVER:
1900                 return me_query_version_device_driver(filep,
1901                                                       (me_query_version_device_driver_t
1902                                                        *) arg);
1903
1904         case ME_CONFIG_LOAD:
1905                 return me_config_load(filep, (me_config_load_t *) arg);
1906         }
1907
1908         PERROR("Invalid ioctl number.\n");
1909         return -ENOTTY;
1910 }
1911
1912 // Init and exit of module.
1913 static int memain_init(void)
1914 {
1915         int result = 0;
1916         dev_t dev = MKDEV(major, 0);
1917
1918         PDEBUG("executed.\n");
1919
1920         // Register pci driver. This will return 0 if the PCI subsystem is not available.
1921         result = pci_register_driver(&me_pci_driver);
1922
1923         if (result < 0) {
1924                 PERROR("Can't register pci driver.\n");
1925                 goto INIT_ERROR_1;
1926         }
1927
1928 /*
1929         // Register usb driver. This will return -ENODEV if no USB subsystem is available.
1930         result = usb_register(&me_usb_driver);
1931
1932         if (result)
1933         {
1934                 if (result == -ENODEV)
1935                 {
1936                         PERROR("No USB subsystem available.\n");
1937                 }
1938                 else
1939                 {
1940                         PERROR("Can't register usb driver.\n");
1941                         goto INIT_ERROR_2;
1942                 }
1943         }
1944 */
1945         // Register the character device.
1946         if (major) {
1947                 result = register_chrdev_region(dev, 1, MEMAIN_NAME);
1948         } else {
1949                 result = alloc_chrdev_region(&dev, 0, 1, MEMAIN_NAME);
1950                 major = MAJOR(dev);
1951         }
1952
1953         if (result < 0) {
1954                 PERROR("Can't get major driver no.\n");
1955                 goto INIT_ERROR_3;
1956         }
1957
1958         cdevp = cdev_alloc();
1959
1960         if (!cdevp) {
1961                 PERROR("Can't get character device structure.\n");
1962                 result = -ENOMEM;
1963                 goto INIT_ERROR_4;
1964         }
1965
1966         cdevp->ops = &me_file_operations;
1967
1968         cdevp->owner = THIS_MODULE;
1969
1970         result = cdev_add(cdevp, dev, 1);
1971
1972         if (result < 0) {
1973                 PERROR("Cannot add character device structure.\n");
1974                 goto INIT_ERROR_5;
1975         }
1976
1977         return 0;
1978
1979       INIT_ERROR_5:
1980         cdev_del(cdevp);
1981
1982       INIT_ERROR_4:
1983         unregister_chrdev_region(dev, 1);
1984
1985       INIT_ERROR_3:
1986 //      usb_deregister(&me_usb_driver);
1987
1988 //INIT_ERROR_2:
1989         pci_unregister_driver(&me_pci_driver);
1990         clear_device_list();
1991
1992       INIT_ERROR_1:
1993         return result;
1994 }
1995
1996 static void __exit memain_exit(void)
1997 {
1998         dev_t dev = MKDEV(major, 0);
1999
2000         PDEBUG("executed.\n");
2001
2002         cdev_del(cdevp);
2003         unregister_chrdev_region(dev, 1);
2004         pci_unregister_driver(&me_pci_driver);
2005 //      usb_deregister(&me_usb_driver);
2006         clear_device_list();
2007 }
2008
2009 module_init(memain_init);
2010 module_exit(memain_exit);
2011
2012 // Administrative stuff for modinfo.
2013 MODULE_AUTHOR
2014     ("Guenter Gebhardt <g.gebhardt@meilhaus.de> & Krzysztof Gantzke <k.gantzke@meilhaus.de>");
2015 MODULE_DESCRIPTION("Central module for Meilhaus Driver System.");
2016 MODULE_SUPPORTED_DEVICE("Meilhaus PCI/cPCI boards.");
2017 MODULE_LICENSE("GPL");
2018
2019 #ifdef BOSCH
2020 // Export the flag for the BOSCH firmware.
2021 EXPORT_SYMBOL(me_bosch_fw);
2022 #endif // BOSCH