drivers/staging/meilhaus/medummy.c

   1 /* Device driver for Meilhaus ME-DUMMY devices.
   2  * ===========================================
   3  *
   4  *    Copyright (C) 2005 Meilhaus Electronic GmbH (support@meilhaus.de)
   5  *
   6  *    This file is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License
  17  *    along with this program; if not, write to the Free Software
  18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 /*
  22  * User application could also include the kernel header files. But the
  23  * real kernel functions are protected by #ifdef __KERNEL__.
  24  */
  25 #ifndef __KERNEL__
  26 #  define __KERNEL__
  27 #endif
  28
  29 /*
  30  * This must be defined before module.h is included. Not needed, when
  31  * it is a built in driver.
  32  */
  33 #ifndef MODULE
  34 #  define MODULE
  35 #endif
  36
  37 #include <linux/module.h>
  38 #include <linux/slab.h>
  39
  40 #include "meerror.h"
  41 #include "meinternal.h"
  42
  43 #include "meids.h"
  44 #include "mecommon.h"
  45 #include "medevice.h"
  46 #include "medebug.h"
  47
  48 #include "medummy.h"
  49
  50 static int medummy_io_irq_start(me_device_t *device,
  51                                 struct file *filep,
  52                                 int subdevice,
  53                                 int channel,
  54                                 int irq_source,
  55                                 int irq_edge, int irq_arg, int flags)
  56 {
  57         PDEBUG("executed.\n");
  58         return ME_ERRNO_DEVICE_UNPLUGGED;
  59 }
  60
  61 static int medummy_io_irq_wait(me_device_t *device,
  62                                struct file *filep,
  63                                int subdevice,
  64                                int channel,
  65                                int *irq_count,
  66                                int *value, int timeout, int flags)
  67 {
  68         PDEBUG("executed.\n");
  69         return ME_ERRNO_DEVICE_UNPLUGGED;
  70 }
  71
  72 static int medummy_io_irq_stop(me_device_t *device,
  73                                struct file *filep,
  74                                int subdevice, int channel, int flags)
  75 {
  76         PDEBUG("executed.\n");
  77         return ME_ERRNO_DEVICE_UNPLUGGED;
  78 }
  79
  80 static int medummy_io_reset_device(me_device_t *device,
  81                                    struct file *filep, int flags)
  82 {
  83         PDEBUG("executed.\n");
  84         return ME_ERRNO_DEVICE_UNPLUGGED;
  85 }
  86
  87 static int medummy_io_reset_subdevice(me_device_t *device,
  88                                       struct file *filep,
  89                                       int subdevice, int flags)
  90 {
  91         PDEBUG("executed.\n");
  92         return ME_ERRNO_DEVICE_UNPLUGGED;
  93 }
  94
  95 static int medummy_io_single_config(me_device_t *device,
  96                                     struct file *filep,
  97                                     int subdevice,
  98                                     int channel,
  99                                     int single_config,
 100                                     int ref,
 101                                     int trig_chan,
 102                                     int trig_type, int trig_edge, int flags)
 103 {
 104         PDEBUG("executed.\n");
 105         return ME_ERRNO_DEVICE_UNPLUGGED;
 106 }
 107
 108 static int medummy_io_single_read(me_device_t *device,
 109                                   struct file *filep,
 110                                   int subdevice,
 111                                   int channel,
 112                                   int *value, int time_out, int flags)
 113 {
 114         PDEBUG("executed.\n");
 115         return ME_ERRNO_DEVICE_UNPLUGGED;
 116 }
 117
 118 static int medummy_io_single_write(me_device_t *device,
 119                                    struct file *filep,
 120                                    int subdevice,
 121                                    int channel,
 122                                    int value, int time_out, int flags)
 123 {
 124         PDEBUG("executed.\n");
 125         return ME_ERRNO_DEVICE_UNPLUGGED;
 126 }
 127
 128 static int medummy_io_stream_config(me_device_t *device,
 129                                     struct file *filep,
 130                                     int subdevice,
 131                                     meIOStreamConfig_t *config_list,
 132                                     int count,
 133                                     meIOStreamTrigger_t *trigger,
 134                                     int fifo_irq_threshold, int flags)
 135 {
 136         PDEBUG("executed.\n");
 137         return ME_ERRNO_DEVICE_UNPLUGGED;
 138 }
 139
 140 static int medummy_io_stream_new_values(me_device_t *device,
 141                                         struct file *filep,
 142                                         int subdevice,
 143                                         int timeout, int *count, int flags)
 144 {
 145         PDEBUG("executed.\n");
 146         return ME_ERRNO_DEVICE_UNPLUGGED;
 147 }
 148
 149 static int medummy_io_stream_read(me_device_t *device,
 150                                   struct file *filep,
 151                                   int subdevice,
 152                                   int read_mode,
 153                                   int *values, int *count, int flags)
 154 {
 155         PDEBUG("executed.\n");
 156         return ME_ERRNO_DEVICE_UNPLUGGED;
 157 }
 158
 159 static int medummy_io_stream_start(me_device_t *device,
 160                                    struct file *filep,
 161                                    int subdevice,
 162                                    int start_mode, int time_out, int flags)
 163 {
 164         PDEBUG("executed.\n");
 165         return ME_ERRNO_DEVICE_UNPLUGGED;
 166 }
 167
 168 static int medummy_io_stream_status(me_device_t *device,
 169                                     struct file *filep,
 170                                     int subdevice,
 171                                     int wait,
 172                                     int *status, int *values, int flags)
 173 {
 174         PDEBUG("executed.\n");
 175         return ME_ERRNO_DEVICE_UNPLUGGED;
 176 }
 177
 178 static int medummy_io_stream_stop(me_device_t *device,
 179                                   struct file *filep,
 180                                   int subdevice, int stop_mode, int flags)
 181 {
 182         PDEBUG("executed.\n");
 183         return ME_ERRNO_DEVICE_UNPLUGGED;
 184 }
 185
 186 static int medummy_io_stream_write(me_device_t *device,
 187                                    struct file *filep,
 188                                    int subdevice,
 189                                    int write_mode,
 190                                    int *values, int *count, int flags)
 191 {
 192         PDEBUG("executed.\n");
 193         return ME_ERRNO_DEVICE_UNPLUGGED;
 194 }
 195
 196 static int medummy_lock_device(me_device_t *device,
 197                                struct file *filep, int lock, int flags)
 198 {
 199         PDEBUG("executed.\n");
 200         return ME_ERRNO_DEVICE_UNPLUGGED;
 201 }
 202
 203 static int medummy_lock_subdevice(me_device_t *device,
 204                                   struct file *filep,
 205                                   int subdevice, int lock, int flags)
 206 {
 207         PDEBUG("executed.\n");
 208         return ME_ERRNO_DEVICE_UNPLUGGED;
 209 }
 210
 211 static int medummy_query_description_device(me_device_t *device,
 212                                             char **description)
 213 {
 214         medummy_device_t *instance = (medummy_device_t *) device;
 215
 216         PDEBUG("executed.\n");
 217
 218 //      if (instance->magic != MEDUMMY_MAGIC_NUMBER)
 219 //      {
 220 //              PERROR("Wrong magic number.\n");
 221 //              return ME_ERRNO_INTERNAL;
 222 //      }
 223
 224         switch (instance->device_id) {
 225
 226         case PCI_DEVICE_ID_MEILHAUS_ME1000:
 227
 228         case PCI_DEVICE_ID_MEILHAUS_ME1000_A:
 229
 230         case PCI_DEVICE_ID_MEILHAUS_ME1000_B:
 231                 *description = ME1000_DESCRIPTION_DEVICE_ME1000;
 232
 233                 break;
 234
 235         case PCI_DEVICE_ID_MEILHAUS_ME1400:
 236                 *description = ME1400_DESCRIPTION_DEVICE_ME1400;
 237
 238                 break;
 239
 240         case PCI_DEVICE_ID_MEILHAUS_ME140A:
 241                 *description = ME1400_DESCRIPTION_DEVICE_ME1400A;
 242
 243                 break;
 244
 245         case PCI_DEVICE_ID_MEILHAUS_ME140B:
 246                 *description = ME1400_DESCRIPTION_DEVICE_ME1400B;
 247
 248                 break;
 249
 250         case PCI_DEVICE_ID_MEILHAUS_ME14E0:
 251                 *description = ME1400_DESCRIPTION_DEVICE_ME1400E;
 252
 253                 break;
 254
 255         case PCI_DEVICE_ID_MEILHAUS_ME14EA:
 256                 *description = ME1400_DESCRIPTION_DEVICE_ME1400EA;
 257
 258                 break;
 259
 260         case PCI_DEVICE_ID_MEILHAUS_ME14EB:
 261                 *description = ME1400_DESCRIPTION_DEVICE_ME1400EB;
 262
 263                 break;
 264
 265         case PCI_DEVICE_ID_MEILHAUS_ME140C:
 266                 *description = ME1400_DESCRIPTION_DEVICE_ME1400C;
 267
 268                 break;
 269
 270         case PCI_DEVICE_ID_MEILHAUS_ME140D:
 271                 *description = ME1400_DESCRIPTION_DEVICE_ME1400D;
 272
 273                 break;
 274
 275         case PCI_DEVICE_ID_MEILHAUS_ME1600_4U:
 276                 *description = ME1600_DESCRIPTION_DEVICE_ME16004U;
 277
 278                 break;
 279
 280         case PCI_DEVICE_ID_MEILHAUS_ME1600_8U:
 281                 *description = ME1600_DESCRIPTION_DEVICE_ME16008U;
 282
 283                 break;
 284
 285         case PCI_DEVICE_ID_MEILHAUS_ME1600_12U:
 286                 *description = ME1600_DESCRIPTION_DEVICE_ME160012U;
 287
 288                 break;
 289
 290         case PCI_DEVICE_ID_MEILHAUS_ME1600_16U:
 291                 *description = ME1600_DESCRIPTION_DEVICE_ME160016U;
 292
 293                 break;
 294
 295         case PCI_DEVICE_ID_MEILHAUS_ME1600_16U_8I:
 296                 *description = ME1600_DESCRIPTION_DEVICE_ME160016U8I;
 297
 298                 break;
 299
 300         case PCI_DEVICE_ID_MEILHAUS_ME4610:
 301                 *description = ME4600_DESCRIPTION_DEVICE_ME4610;
 302
 303                 break;
 304
 305         case PCI_DEVICE_ID_MEILHAUS_ME4650:
 306                 *description = ME4600_DESCRIPTION_DEVICE_ME4650;
 307
 308                 break;
 309
 310         case PCI_DEVICE_ID_MEILHAUS_ME4660:
 311                 *description = ME4600_DESCRIPTION_DEVICE_ME4660;
 312
 313                 break;
 314
 315         case PCI_DEVICE_ID_MEILHAUS_ME4660I:
 316                 *description = ME4600_DESCRIPTION_DEVICE_ME4660I;
 317
 318                 break;
 319
 320         case PCI_DEVICE_ID_MEILHAUS_ME4660S:
 321                 *description = ME4600_DESCRIPTION_DEVICE_ME4660S;
 322
 323                 break;
 324
 325         case PCI_DEVICE_ID_MEILHAUS_ME4660IS:
 326                 *description = ME4600_DESCRIPTION_DEVICE_ME4660IS;
 327
 328                 break;
 329
 330         case PCI_DEVICE_ID_MEILHAUS_ME4670:
 331                 *description = ME4600_DESCRIPTION_DEVICE_ME4670;
 332
 333                 break;
 334
 335         case PCI_DEVICE_ID_MEILHAUS_ME4670I:
 336                 *description = ME4600_DESCRIPTION_DEVICE_ME4670I;
 337
 338                 break;
 339
 340         case PCI_DEVICE_ID_MEILHAUS_ME4670S:
 341                 *description = ME4600_DESCRIPTION_DEVICE_ME4670S;
 342
 343                 break;
 344
 345         case PCI_DEVICE_ID_MEILHAUS_ME4670IS:
 346                 *description = ME4600_DESCRIPTION_DEVICE_ME4670IS;
 347
 348                 break;
 349
 350         case PCI_DEVICE_ID_MEILHAUS_ME4680:
 351                 *description = ME4600_DESCRIPTION_DEVICE_ME4680;
 352
 353                 break;
 354
 355         case PCI_DEVICE_ID_MEILHAUS_ME4680I:
 356                 *description = ME4600_DESCRIPTION_DEVICE_ME4680I;
 357
 358                 break;
 359
 360         case PCI_DEVICE_ID_MEILHAUS_ME4680S:
 361                 *description = ME4600_DESCRIPTION_DEVICE_ME4680S;
 362
 363                 break;
 364
 365         case PCI_DEVICE_ID_MEILHAUS_ME4680IS:
 366                 *description = ME4600_DESCRIPTION_DEVICE_ME4680IS;
 367
 368                 break;
 369
 370         case PCI_DEVICE_ID_MEILHAUS_ME6004:
 371                 *description = ME6000_DESCRIPTION_DEVICE_ME60004;
 372
 373                 break;
 374
 375         case PCI_DEVICE_ID_MEILHAUS_ME6008:
 376                 *description = ME6000_DESCRIPTION_DEVICE_ME60008;
 377
 378                 break;
 379
 380         case PCI_DEVICE_ID_MEILHAUS_ME600F:
 381                 *description = ME6000_DESCRIPTION_DEVICE_ME600016;
 382
 383                 break;
 384
 385         case PCI_DEVICE_ID_MEILHAUS_ME6014:
 386                 *description = ME6000_DESCRIPTION_DEVICE_ME6000I4;
 387
 388                 break;
 389
 390         case PCI_DEVICE_ID_MEILHAUS_ME6018:
 391                 *description = ME6000_DESCRIPTION_DEVICE_ME6000I8;
 392
 393                 break;
 394
 395         case PCI_DEVICE_ID_MEILHAUS_ME601F:
 396                 *description = ME6000_DESCRIPTION_DEVICE_ME6000I16;
 397
 398                 break;
 399
 400         case PCI_DEVICE_ID_MEILHAUS_ME6034:
 401                 *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE4;
 402
 403                 break;
 404
 405         case PCI_DEVICE_ID_MEILHAUS_ME6038:
 406                 *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE8;
 407
 408                 break;
 409
 410         case PCI_DEVICE_ID_MEILHAUS_ME603F:
 411                 *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE16;
 412
 413                 break;
 414
 415         case PCI_DEVICE_ID_MEILHAUS_ME6104:
 416                 *description = ME6000_DESCRIPTION_DEVICE_ME61004;
 417
 418                 break;
 419
 420         case PCI_DEVICE_ID_MEILHAUS_ME6108:
 421                 *description = ME6000_DESCRIPTION_DEVICE_ME61008;
 422
 423                 break;
 424
 425         case PCI_DEVICE_ID_MEILHAUS_ME610F:
 426                 *description = ME6000_DESCRIPTION_DEVICE_ME610016;
 427
 428                 break;
 429
 430         case PCI_DEVICE_ID_MEILHAUS_ME6114:
 431                 *description = ME6000_DESCRIPTION_DEVICE_ME6100I4;
 432
 433                 break;
 434
 435         case PCI_DEVICE_ID_MEILHAUS_ME6118:
 436                 *description = ME6000_DESCRIPTION_DEVICE_ME6100I8;
 437
 438                 break;
 439
 440         case PCI_DEVICE_ID_MEILHAUS_ME611F:
 441                 *description = ME6000_DESCRIPTION_DEVICE_ME6100I16;
 442
 443                 break;
 444
 445         case PCI_DEVICE_ID_MEILHAUS_ME6134:
 446                 *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE4;
 447
 448                 break;
 449
 450         case PCI_DEVICE_ID_MEILHAUS_ME6138:
 451                 *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE8;
 452
 453                 break;
 454
 455         case PCI_DEVICE_ID_MEILHAUS_ME613F:
 456                 *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE16;
 457
 458                 break;
 459
 460         case PCI_DEVICE_ID_MEILHAUS_ME6044:
 461                 *description = ME6000_DESCRIPTION_DEVICE_ME60004DIO;
 462
 463                 break;
 464
 465         case PCI_DEVICE_ID_MEILHAUS_ME6048:
 466                 *description = ME6000_DESCRIPTION_DEVICE_ME60008DIO;
 467
 468                 break;
 469
 470         case PCI_DEVICE_ID_MEILHAUS_ME604F:
 471                 *description = ME6000_DESCRIPTION_DEVICE_ME600016DIO;
 472
 473                 break;
 474
 475         case PCI_DEVICE_ID_MEILHAUS_ME6054:
 476                 *description = ME6000_DESCRIPTION_DEVICE_ME6000I4DIO;
 477
 478                 break;
 479
 480         case PCI_DEVICE_ID_MEILHAUS_ME6058:
 481                 *description = ME6000_DESCRIPTION_DEVICE_ME6000I8DIO;
 482
 483                 break;
 484
 485         case PCI_DEVICE_ID_MEILHAUS_ME605F:
 486                 *description = ME6000_DESCRIPTION_DEVICE_ME6000I16DIO;
 487
 488                 break;
 489
 490         case PCI_DEVICE_ID_MEILHAUS_ME6074:
 491                 *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE4DIO;
 492
 493                 break;
 494
 495         case PCI_DEVICE_ID_MEILHAUS_ME6078:
 496                 *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE8DIO;
 497
 498                 break;
 499
 500         case PCI_DEVICE_ID_MEILHAUS_ME607F:
 501                 *description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE16DIO;
 502
 503                 break;
 504
 505         case PCI_DEVICE_ID_MEILHAUS_ME6144:
 506                 *description = ME6000_DESCRIPTION_DEVICE_ME61004DIO;
 507
 508                 break;
 509
 510         case PCI_DEVICE_ID_MEILHAUS_ME6148:
 511                 *description = ME6000_DESCRIPTION_DEVICE_ME61008DIO;
 512
 513                 break;
 514
 515         case PCI_DEVICE_ID_MEILHAUS_ME614F:
 516                 *description = ME6000_DESCRIPTION_DEVICE_ME610016DIO;
 517
 518                 break;
 519
 520         case PCI_DEVICE_ID_MEILHAUS_ME6154:
 521                 *description = ME6000_DESCRIPTION_DEVICE_ME6100I4DIO;
 522
 523                 break;
 524
 525         case PCI_DEVICE_ID_MEILHAUS_ME6158:
 526                 *description = ME6000_DESCRIPTION_DEVICE_ME6100I8DIO;
 527
 528                 break;
 529
 530         case PCI_DEVICE_ID_MEILHAUS_ME615F:
 531                 *description = ME6000_DESCRIPTION_DEVICE_ME6100I16DIO;
 532
 533                 break;
 534
 535         case PCI_DEVICE_ID_MEILHAUS_ME6174:
 536                 *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE4DIO;
 537
 538                 break;
 539
 540         case PCI_DEVICE_ID_MEILHAUS_ME6178:
 541                 *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE8DIO;
 542
 543                 break;
 544
 545         case PCI_DEVICE_ID_MEILHAUS_ME617F:
 546                 *description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE16DIO;
 547
 548                 break;
 549
 550         case PCI_DEVICE_ID_MEILHAUS_ME6259:
 551                 *description = ME6000_DESCRIPTION_DEVICE_ME6200I9DIO;
 552
 553                 break;
 554
 555         case PCI_DEVICE_ID_MEILHAUS_ME6359:
 556                 *description = ME6000_DESCRIPTION_DEVICE_ME6300I9DIO;
 557
 558                 break;
 559
 560         case PCI_DEVICE_ID_MEILHAUS_ME0630:
 561                 *description = ME0600_DESCRIPTION_DEVICE_ME0630;
 562
 563                 break;
 564
 565         case PCI_DEVICE_ID_MEILHAUS_ME8100_A:
 566                 *description = ME8100_DESCRIPTION_DEVICE_ME8100A;
 567
 568                 break;
 569
 570         case PCI_DEVICE_ID_MEILHAUS_ME8100_B:
 571                 *description = ME8100_DESCRIPTION_DEVICE_ME8100B;
 572
 573                 break;
 574
 575         case PCI_DEVICE_ID_MEILHAUS_ME0940:
 576                 *description = ME0900_DESCRIPTION_DEVICE_ME0940;
 577
 578                 break;
 579
 580         case PCI_DEVICE_ID_MEILHAUS_ME0950:
 581                 *description = ME0900_DESCRIPTION_DEVICE_ME0950;
 582
 583                 break;
 584
 585         case PCI_DEVICE_ID_MEILHAUS_ME0960:
 586                 *description = ME0900_DESCRIPTION_DEVICE_ME0960;
 587
 588                 break;
 589 /*
 590                 case USB_DEVICE_ID_MEPHISTO_S1:
 591                         *description = MEPHISTO_S1_DESCRIPTION_DEVICE;
 592
 593                         break;
 594 */
 595         default:
 596                 *description = EMPTY_DESCRIPTION_DEVICE;
 597                 PERROR("Invalid device id in device info.\n");
 598
 599                 return ME_ERRNO_INTERNAL;
 600         }
 601
 602         return ME_ERRNO_DEVICE_UNPLUGGED;
 603 }
 604
 605 static int medummy_query_info_device(me_device_t *device,
 606                                      int *vendor_id,
 607                                      int *device_id,
 608                                      int *serial_no,
 609                                      int *bus_type,
 610                                      int *bus_no,
 611                                      int *dev_no, int *func_no, int *plugged)
 612 {
 613         medummy_device_t *instance = (medummy_device_t *) device;
 614
 615         PDEBUG("executed.\n");
 616
 617 //      if (instance->magic != MEDUMMY_MAGIC_NUMBER)
 618 //      {
 619 //              PERROR("Wrong magic number.\n");
 620 //              return ME_ERRNO_INTERNAL;
 621 //      }
 622
 623         *vendor_id = instance->vendor_id;
 624         *device_id = instance->device_id;
 625         *serial_no = instance->serial_no;
 626         *bus_type = instance->bus_type;
 627         *bus_no = instance->bus_no;
 628         *dev_no = instance->dev_no;
 629         *func_no = instance->func_no;
 630         *plugged = ME_PLUGGED_OUT;
 631
 632         return ME_ERRNO_SUCCESS;
 633 }
 634
 635 static int medummy_query_name_device_driver(me_device_t *device, char **name)
 636 {
 637         PDEBUG("executed.\n");
 638         *name = MEDUMMY_NAME_DRIVER;
 639         return ME_ERRNO_SUCCESS;
 640 }
 641
 642 static int medummy_query_name_device(me_device_t *device, char **name)
 643 {
 644         medummy_device_t *instance = (medummy_device_t *) device;
 645
 646         PDEBUG("executed.\n");
 647
 648 // // //        if (instance->magic != MEDUMMY_MAGIC_NUMBER)
 649 // // //        {
 650 // // //                PERROR("Wrong magic number.\n");
 651 // // //                return ME_ERRNO_INTERNAL;
 652 // // //        }
 653
 654         switch (instance->device_id) {
 655
 656         case PCI_DEVICE_ID_MEILHAUS_ME1000:
 657
 658         case PCI_DEVICE_ID_MEILHAUS_ME1000_A:
 659
 660         case PCI_DEVICE_ID_MEILHAUS_ME1000_B:
 661                 *name = ME1000_NAME_DEVICE_ME1000;
 662
 663                 break;
 664
 665         case PCI_DEVICE_ID_MEILHAUS_ME1400:
 666                 *name = ME1400_NAME_DEVICE_ME1400;
 667
 668                 break;
 669
 670         case PCI_DEVICE_ID_MEILHAUS_ME140A:
 671                 *name = ME1400_NAME_DEVICE_ME1400A;
 672
 673                 break;
 674
 675         case PCI_DEVICE_ID_MEILHAUS_ME140B:
 676                 *name = ME1400_NAME_DEVICE_ME1400B;
 677
 678                 break;
 679
 680         case PCI_DEVICE_ID_MEILHAUS_ME14E0:
 681                 *name = ME1400_NAME_DEVICE_ME1400E;
 682
 683                 break;
 684
 685         case PCI_DEVICE_ID_MEILHAUS_ME14EA:
 686                 *name = ME1400_NAME_DEVICE_ME1400EA;
 687
 688                 break;
 689
 690         case PCI_DEVICE_ID_MEILHAUS_ME14EB:
 691                 *name = ME1400_NAME_DEVICE_ME1400EB;
 692
 693                 break;
 694
 695         case PCI_DEVICE_ID_MEILHAUS_ME140C:
 696                 *name = ME1400_NAME_DEVICE_ME1400C;
 697
 698                 break;
 699
 700         case PCI_DEVICE_ID_MEILHAUS_ME140D:
 701                 *name = ME1400_NAME_DEVICE_ME1400D;
 702
 703                 break;
 704
 705         case PCI_DEVICE_ID_MEILHAUS_ME1600_4U:
 706                 *name = ME1600_NAME_DEVICE_ME16004U;
 707
 708                 break;
 709
 710         case PCI_DEVICE_ID_MEILHAUS_ME1600_8U:
 711                 *name = ME1600_NAME_DEVICE_ME16008U;
 712
 713                 break;
 714
 715         case PCI_DEVICE_ID_MEILHAUS_ME1600_12U:
 716                 *name = ME1600_NAME_DEVICE_ME160012U;
 717
 718                 break;
 719
 720         case PCI_DEVICE_ID_MEILHAUS_ME1600_16U:
 721                 *name = ME1600_NAME_DEVICE_ME160016U;
 722
 723                 break;
 724
 725         case PCI_DEVICE_ID_MEILHAUS_ME1600_16U_8I:
 726                 *name = ME1600_NAME_DEVICE_ME160016U8I;
 727
 728                 break;
 729
 730         case PCI_DEVICE_ID_MEILHAUS_ME4610:
 731                 *name = ME4600_NAME_DEVICE_ME4610;
 732
 733                 break;
 734
 735         case PCI_DEVICE_ID_MEILHAUS_ME4650:
 736                 *name = ME4600_NAME_DEVICE_ME4650;
 737
 738                 break;
 739
 740         case PCI_DEVICE_ID_MEILHAUS_ME4660:
 741                 *name = ME4600_NAME_DEVICE_ME4660;
 742
 743                 break;
 744
 745         case PCI_DEVICE_ID_MEILHAUS_ME4660I:
 746                 *name = ME4600_NAME_DEVICE_ME4660I;
 747
 748                 break;
 749
 750         case PCI_DEVICE_ID_MEILHAUS_ME4670:
 751                 *name = ME4600_NAME_DEVICE_ME4670;
 752
 753                 break;
 754
 755         case PCI_DEVICE_ID_MEILHAUS_ME4670I:
 756                 *name = ME4600_NAME_DEVICE_ME4670I;
 757
 758                 break;
 759
 760         case PCI_DEVICE_ID_MEILHAUS_ME4670S:
 761                 *name = ME4600_NAME_DEVICE_ME4670S;
 762
 763                 break;
 764
 765         case PCI_DEVICE_ID_MEILHAUS_ME4670IS:
 766                 *name = ME4600_NAME_DEVICE_ME4670IS;
 767
 768                 break;
 769
 770         case PCI_DEVICE_ID_MEILHAUS_ME4680:
 771                 *name = ME4600_NAME_DEVICE_ME4680;
 772
 773                 break;
 774
 775         case PCI_DEVICE_ID_MEILHAUS_ME4680I:
 776                 *name = ME4600_NAME_DEVICE_ME4680I;
 777
 778                 break;
 779
 780         case PCI_DEVICE_ID_MEILHAUS_ME4680S:
 781                 *name = ME4600_NAME_DEVICE_ME4680S;
 782
 783                 break;
 784
 785         case PCI_DEVICE_ID_MEILHAUS_ME4680IS:
 786                 *name = ME4600_NAME_DEVICE_ME4680IS;
 787
 788                 break;
 789
 790         case PCI_DEVICE_ID_MEILHAUS_ME6004:
 791                 *name = ME6000_NAME_DEVICE_ME60004;
 792
 793                 break;
 794
 795         case PCI_DEVICE_ID_MEILHAUS_ME6008:
 796                 *name = ME6000_NAME_DEVICE_ME60008;
 797
 798                 break;
 799
 800         case PCI_DEVICE_ID_MEILHAUS_ME600F:
 801                 *name = ME6000_NAME_DEVICE_ME600016;
 802
 803                 break;
 804
 805         case PCI_DEVICE_ID_MEILHAUS_ME6014:
 806                 *name = ME6000_NAME_DEVICE_ME6000I4;
 807
 808                 break;
 809
 810         case PCI_DEVICE_ID_MEILHAUS_ME6018:
 811                 *name = ME6000_NAME_DEVICE_ME6000I8;
 812
 813                 break;
 814
 815         case PCI_DEVICE_ID_MEILHAUS_ME601F:
 816                 *name = ME6000_NAME_DEVICE_ME6000I16;
 817
 818                 break;
 819
 820         case PCI_DEVICE_ID_MEILHAUS_ME6034:
 821                 *name = ME6000_NAME_DEVICE_ME6000ISLE4;
 822
 823                 break;
 824
 825         case PCI_DEVICE_ID_MEILHAUS_ME6038:
 826                 *name = ME6000_NAME_DEVICE_ME6000ISLE8;
 827
 828                 break;
 829
 830         case PCI_DEVICE_ID_MEILHAUS_ME603F:
 831                 *name = ME6000_NAME_DEVICE_ME6000ISLE16;
 832
 833                 break;
 834
 835         case PCI_DEVICE_ID_MEILHAUS_ME6104:
 836                 *name = ME6000_NAME_DEVICE_ME61004;
 837
 838                 break;
 839
 840         case PCI_DEVICE_ID_MEILHAUS_ME6108:
 841                 *name = ME6000_NAME_DEVICE_ME61008;
 842
 843                 break;
 844
 845         case PCI_DEVICE_ID_MEILHAUS_ME610F:
 846                 *name = ME6000_NAME_DEVICE_ME610016;
 847
 848                 break;
 849
 850         case PCI_DEVICE_ID_MEILHAUS_ME6114:
 851                 *name = ME6000_NAME_DEVICE_ME6100I4;
 852
 853                 break;
 854
 855         case PCI_DEVICE_ID_MEILHAUS_ME6118:
 856                 *name = ME6000_NAME_DEVICE_ME6100I8;
 857
 858                 break;
 859
 860         case PCI_DEVICE_ID_MEILHAUS_ME611F:
 861                 *name = ME6000_NAME_DEVICE_ME6100I16;
 862
 863                 break;
 864
 865         case PCI_DEVICE_ID_MEILHAUS_ME6134:
 866                 *name = ME6000_NAME_DEVICE_ME6100ISLE4;
 867
 868                 break;
 869
 870         case PCI_DEVICE_ID_MEILHAUS_ME6138:
 871                 *name = ME6000_NAME_DEVICE_ME6100ISLE8;
 872
 873                 break;
 874
 875         case PCI_DEVICE_ID_MEILHAUS_ME613F:
 876                 *name = ME6000_NAME_DEVICE_ME6100ISLE16;
 877
 878                 break;
 879
 880         case PCI_DEVICE_ID_MEILHAUS_ME6044:
 881                 *name = ME6000_NAME_DEVICE_ME60004DIO;
 882
 883                 break;
 884
 885         case PCI_DEVICE_ID_MEILHAUS_ME6048:
 886                 *name = ME6000_NAME_DEVICE_ME60008DIO;
 887
 888                 break;
 889
 890         case PCI_DEVICE_ID_MEILHAUS_ME604F:
 891                 *name = ME6000_NAME_DEVICE_ME600016DIO;
 892
 893                 break;
 894
 895         case PCI_DEVICE_ID_MEILHAUS_ME6054:
 896                 *name = ME6000_NAME_DEVICE_ME6000I4DIO;
 897
 898                 break;
 899
 900         case PCI_DEVICE_ID_MEILHAUS_ME6058:
 901                 *name = ME6000_NAME_DEVICE_ME6000I8DIO;
 902
 903                 break;
 904
 905         case PCI_DEVICE_ID_MEILHAUS_ME605F:
 906                 *name = ME6000_NAME_DEVICE_ME6000I16DIO;
 907
 908                 break;
 909
 910         case PCI_DEVICE_ID_MEILHAUS_ME6074:
 911                 *name = ME6000_NAME_DEVICE_ME6000ISLE4DIO;
 912
 913                 break;
 914
 915         case PCI_DEVICE_ID_MEILHAUS_ME6078:
 916                 *name = ME6000_NAME_DEVICE_ME6000ISLE8DIO;
 917
 918                 break;
 919
 920         case PCI_DEVICE_ID_MEILHAUS_ME607F:
 921                 *name = ME6000_NAME_DEVICE_ME6000ISLE16DIO;
 922
 923                 break;
 924
 925         case PCI_DEVICE_ID_MEILHAUS_ME6144:
 926                 *name = ME6000_NAME_DEVICE_ME61004DIO;
 927
 928                 break;
 929
 930         case PCI_DEVICE_ID_MEILHAUS_ME6148:
 931                 *name = ME6000_NAME_DEVICE_ME61008DIO;
 932
 933                 break;
 934
 935         case PCI_DEVICE_ID_MEILHAUS_ME614F:
 936                 *name = ME6000_NAME_DEVICE_ME610016DIO;
 937
 938                 break;
 939
 940         case PCI_DEVICE_ID_MEILHAUS_ME6154:
 941                 *name = ME6000_NAME_DEVICE_ME6100I4DIO;
 942
 943                 break;
 944
 945         case PCI_DEVICE_ID_MEILHAUS_ME6158:
 946                 *name = ME6000_NAME_DEVICE_ME6100I8DIO;
 947
 948                 break;
 949
 950         case PCI_DEVICE_ID_MEILHAUS_ME615F:
 951                 *name = ME6000_NAME_DEVICE_ME6100I16DIO;
 952
 953                 break;
 954
 955         case PCI_DEVICE_ID_MEILHAUS_ME6174:
 956                 *name = ME6000_NAME_DEVICE_ME6100ISLE4DIO;
 957
 958                 break;
 959
 960         case PCI_DEVICE_ID_MEILHAUS_ME6178:
 961                 *name = ME6000_NAME_DEVICE_ME6100ISLE8DIO;
 962
 963                 break;
 964
 965         case PCI_DEVICE_ID_MEILHAUS_ME617F:
 966                 *name = ME6000_NAME_DEVICE_ME6100ISLE16DIO;
 967
 968                 break;
 969
 970         case PCI_DEVICE_ID_MEILHAUS_ME0630:
 971                 *name = ME0600_NAME_DEVICE_ME0630;
 972
 973                 break;
 974
 975         case PCI_DEVICE_ID_MEILHAUS_ME8100_A:
 976                 *name = ME8100_NAME_DEVICE_ME8100A;
 977
 978                 break;
 979
 980         case PCI_DEVICE_ID_MEILHAUS_ME8100_B:
 981                 *name = ME8100_NAME_DEVICE_ME8100B;
 982
 983                 break;
 984
 985         case PCI_DEVICE_ID_MEILHAUS_ME0940:
 986                 *name = ME0900_NAME_DEVICE_ME0940;
 987
 988                 break;
 989
 990         case PCI_DEVICE_ID_MEILHAUS_ME0950:
 991                 *name = ME0900_NAME_DEVICE_ME0950;
 992
 993                 break;
 994
 995         case PCI_DEVICE_ID_MEILHAUS_ME0960:
 996                 *name = ME0900_NAME_DEVICE_ME0960;
 997
 998                 break;
 999 /*
1000                 case USB_DEVICE_ID_MEPHISTO_S1:
1001                         *name = MEPHISTO_S1_NAME_DEVICE;
1002
1003                         break;
1004 */
1005         default:
1006                 *name = EMPTY_NAME_DEVICE;
1007                 PERROR("Invalid PCI device id.\n");
1008
1009                 return ME_ERRNO_INTERNAL;
1010         }
1011
1012         return ME_ERRNO_SUCCESS;
1013 }
1014
1015 static int medummy_query_number_subdevices(me_device_t *device, int *number)
1016 {
1017         PDEBUG("executed.\n");
1018         return ME_ERRNO_DEVICE_UNPLUGGED;
1019 }
1020
1021 static int medummy_query_number_channels(me_device_t *device,
1022                                          int subdevice, int *number)
1023 {
1024         PDEBUG("executed.\n");
1025         return ME_ERRNO_DEVICE_UNPLUGGED;
1026 }
1027
1028 static int medummy_query_number_ranges(me_device_t *device,
1029                                        int subdevice, int unit, int *count)
1030 {
1031         PDEBUG("executed.\n");
1032         return ME_ERRNO_DEVICE_UNPLUGGED;
1033 }
1034
1035 static int medummy_query_subdevice_type(me_device_t *device,
1036                                         int subdevice, int *type, int *subtype)
1037 {
1038         PDEBUG("executed.\n");
1039         return ME_ERRNO_DEVICE_UNPLUGGED;
1040 }
1041
1042 static int medummy_query_subdevice_caps(me_device_t *device,
1043                                         int subdevice, int *caps)
1044 {
1045         PDEBUG("executed.\n");
1046         return ME_ERRNO_DEVICE_UNPLUGGED;
1047 }
1048
1049 static int medummy_query_subdevice_caps_args(me_device_t *device,
1050                                              int subdevice,
1051                                              int cap, int *args, int count)
1052 {
1053         PDEBUG("executed.\n");
1054         return ME_ERRNO_NOT_SUPPORTED;
1055 }
1056
1057 static int medummy_query_subdevice_by_type(me_device_t *device,
1058                                            int start_subdevice,
1059                                            int type,
1060                                            int subtype, int *subdevice)
1061 {
1062         PDEBUG("executed.\n");
1063         return ME_ERRNO_DEVICE_UNPLUGGED;
1064 }
1065
1066 static int medummy_query_range_by_min_max(me_device_t *device,
1067                                           int subdevice,
1068                                           int unit,
1069                                           int *min,
1070                                           int *max, int *maxdata, int *range)
1071 {
1072         PDEBUG("executed.\n");
1073         return ME_ERRNO_DEVICE_UNPLUGGED;
1074 }
1075
1076 static int medummy_query_range_info(me_device_t *device,
1077                                     int subdevice,
1078                                     int range,
1079                                     int *unit, int *min, int *max, int *maxdata)
1080 {
1081         PDEBUG("executed.\n");
1082         return ME_ERRNO_DEVICE_UNPLUGGED;
1083 }
1084
1085 int medummy_query_timer(me_device_t *device,
1086                         int subdevice,
1087                         int timer,
1088                         int *base_frequency,
1089                         uint64_t *min_ticks, uint64_t *max_ticks)
1090 {
1091         PDEBUG("executed.\n");
1092         return ME_ERRNO_DEVICE_UNPLUGGED;
1093 }
1094
1095 static int medummy_query_version_device_driver(me_device_t *device,
1096                                                int *version)
1097 {
1098         PDEBUG("executed.\n");
1099
1100         *version = ME_VERSION_DRIVER;
1101         return ME_ERRNO_SUCCESS;
1102 }
1103
1104 static void medummy_destructor(me_device_t *device)
1105 {
1106         PDEBUG("executed.\n");
1107         kfree(device);
1108 }
1109
1110 static int init_device_info(unsigned short vendor_id,
1111                             unsigned short device_id,
1112                             unsigned int serial_no,
1113                             int bus_type,
1114                             int bus_no,
1115                             int dev_no,
1116                             int func_no, medummy_device_t *instance)
1117 {
1118         PDEBUG("executed.\n");
1119
1120 //      instance->magic = MEDUMMY_MAGIC_NUMBER;
1121         instance->vendor_id = vendor_id;
1122         instance->device_id = device_id;
1123         instance->serial_no = serial_no;
1124         instance->bus_type = bus_type;
1125         instance->bus_no = bus_no;
1126         instance->dev_no = dev_no;
1127         instance->func_no = func_no;
1128
1129         return 0;
1130 }
1131
1132 static int medummy_config_load(me_device_t *device, struct file *filep,
1133                                me_cfg_device_entry_t *config)
1134 {
1135         PDEBUG("executed.\n");
1136         return ME_ERRNO_SUCCESS;
1137 }
1138
1139 static int init_device_instance(me_device_t *device)
1140 {
1141         PDEBUG("executed.\n");
1142
1143         INIT_LIST_HEAD(&device->list);
1144
1145         device->me_device_io_irq_start = medummy_io_irq_start;
1146         device->me_device_io_irq_wait = medummy_io_irq_wait;
1147         device->me_device_io_irq_stop = medummy_io_irq_stop;
1148         device->me_device_io_reset_device = medummy_io_reset_device;
1149         device->me_device_io_reset_subdevice = medummy_io_reset_subdevice;
1150         device->me_device_io_single_config = medummy_io_single_config;
1151         device->me_device_io_single_read = medummy_io_single_read;
1152         device->me_device_io_single_write = medummy_io_single_write;
1153         device->me_device_io_stream_config = medummy_io_stream_config;
1154         device->me_device_io_stream_new_values = medummy_io_stream_new_values;
1155         device->me_device_io_stream_read = medummy_io_stream_read;
1156         device->me_device_io_stream_start = medummy_io_stream_start;
1157         device->me_device_io_stream_status = medummy_io_stream_status;
1158         device->me_device_io_stream_stop = medummy_io_stream_stop;
1159         device->me_device_io_stream_write = medummy_io_stream_write;
1160
1161         device->me_device_lock_device = medummy_lock_device;
1162         device->me_device_lock_subdevice = medummy_lock_subdevice;
1163
1164         device->me_device_query_description_device =
1165             medummy_query_description_device;
1166         device->me_device_query_info_device = medummy_query_info_device;
1167         device->me_device_query_name_device_driver =
1168             medummy_query_name_device_driver;
1169         device->me_device_query_name_device = medummy_query_name_device;
1170
1171         device->me_device_query_number_subdevices =
1172             medummy_query_number_subdevices;
1173         device->me_device_query_number_channels = medummy_query_number_channels;
1174         device->me_device_query_number_ranges = medummy_query_number_ranges;
1175
1176         device->me_device_query_range_by_min_max =
1177             medummy_query_range_by_min_max;
1178         device->me_device_query_range_info = medummy_query_range_info;
1179
1180         device->me_device_query_subdevice_type = medummy_query_subdevice_type;
1181         device->me_device_query_subdevice_by_type =
1182             medummy_query_subdevice_by_type;
1183         device->me_device_query_subdevice_caps = medummy_query_subdevice_caps;
1184         device->me_device_query_subdevice_caps_args =
1185             medummy_query_subdevice_caps_args;
1186
1187         device->me_device_query_timer = medummy_query_timer;
1188
1189         device->me_device_query_version_device_driver =
1190             medummy_query_version_device_driver;
1191
1192         device->me_device_destructor = medummy_destructor;
1193         device->me_device_config_load = medummy_config_load;
1194         return 0;
1195 }
1196
1197 me_device_t *medummy_constructor(unsigned short vendor_id,
1198                                  unsigned short device_id,
1199                                  unsigned int serial_no,
1200                                  int bus_type,
1201                                  int bus_no, int dev_no, int func_no)
1202 {
1203         int result = 0;
1204         medummy_device_t *instance;
1205
1206         PDEBUG("executed.\n");
1207
1208         /* Allocate structure for device attributes */
1209         instance = kmalloc(sizeof(medummy_device_t), GFP_KERNEL);
1210
1211         if (!instance) {
1212                 PERROR("Can't get memory for device instance.\n");
1213                 return NULL;
1214         }
1215
1216         memset(instance, 0, sizeof(medummy_device_t));
1217
1218         /* Initialize device info */
1219         result = init_device_info(vendor_id,
1220                                   device_id,
1221                                   serial_no,
1222                                   bus_type, bus_no, dev_no, func_no, instance);
1223
1224         if (result) {
1225                 PERROR("Cannot init baord info.\n");
1226                 kfree(instance);
1227                 return NULL;
1228         }
1229
1230         /* Initialize device instance */
1231         result = init_device_instance((me_device_t *) instance);
1232
1233         if (result) {
1234                 PERROR("Cannot init baord info.\n");
1235                 kfree(instance);
1236                 return NULL;
1237         }
1238
1239         return (me_device_t *) instance;
1240 }
1241 EXPORT_SYMBOL(medummy_constructor);
1242
1243 // Init and exit of module.
1244
1245 static int __init dummy_init(void)
1246 {
1247         PDEBUG("executed.\n");
1248         return 0;
1249 }
1250
1251 static void __exit dummy_exit(void)
1252 {
1253         PDEBUG("executed.\n");
1254 }
1255
1256 module_init(dummy_init);
1257
1258 module_exit(dummy_exit);
1259
1260 // Administrative stuff for modinfo.
1261 MODULE_AUTHOR("Guenter Gebhardt <g.gebhardt@meilhaus.de>");
1262 MODULE_DESCRIPTION("Device Driver Module for Meilhaus ME-DUMMY Devices");
1263 MODULE_SUPPORTED_DEVICE("Meilhaus ME-DUMMY Devices");
1264 MODULE_LICENSE("GPL");