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