SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/meilhaus/medevice.c

   1 /**
   2  * @file medevice.c
   3  *
   4  * @brief Meilhaus device base class.
   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 #include "mecommon.h"
  29 #include "meinternal.h"
  30 #include "medefines.h"
  31 #include "meerror.h"
  32
  33 #include "medebug.h"
  34 #include "medevice.h"
  35
  36 #ifndef __KERNEL__
  37 #  define __KERNEL__
  38 #endif
  39
  40 static int me_device_io_irq_start(struct me_device *device,
  41                                   struct file *filep,
  42                                   int subdevice,
  43                                   int channel,
  44                                   int irq_source,
  45                                   int irq_edge, int irq_arg, int flags)
  46 {
  47         int err = ME_ERRNO_SUCCESS;
  48         me_subdevice_t *s;
  49
  50         PDEBUG("executed.\n");
  51
  52         // Check subdevice index.
  53         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
  54                 PERROR("Invalid subdevice.\n");
  55                 return ME_ERRNO_INVALID_SUBDEVICE;
  56         }
  57         // Enter device.
  58         err = me_dlock_enter(&device->dlock, filep);
  59
  60         if (err) {
  61                 PERROR("Cannot enter device.\n");
  62                 return err;
  63         }
  64         // Get subdevice instance.
  65         s = me_slist_get_subdevice(&device->slist, subdevice);
  66
  67         if (s) {
  68                 // Call subdevice method.
  69                 err = s->me_subdevice_io_irq_start(s,
  70                                                    filep,
  71                                                    channel,
  72                                                    irq_source,
  73                                                    irq_edge, irq_arg, flags);
  74         } else {
  75                 // Something really bad happened.
  76                 PERROR("Cannot get subdevice instance.\n");
  77                 err = ME_ERRNO_INTERNAL;
  78         }
  79
  80         // Exit device.
  81         me_dlock_exit(&device->dlock, filep);
  82
  83         return err;
  84 }
  85
  86 static int me_device_io_irq_wait(struct me_device *device,
  87                                  struct file *filep,
  88                                  int subdevice,
  89                                  int channel,
  90                                  int *irq_count,
  91                                  int *value, int time_out, int flags)
  92 {
  93         int err = ME_ERRNO_SUCCESS;
  94         me_subdevice_t *s;
  95
  96         PDEBUG("executed.\n");
  97
  98         // Check subdevice index.
  99         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 100                 PERROR("Invalid subdevice.\n");
 101                 return ME_ERRNO_INVALID_SUBDEVICE;
 102         }
 103         // Enter device.
 104         err = me_dlock_enter(&device->dlock, filep);
 105
 106         if (err) {
 107                 PERROR("Cannot enter device.\n");
 108                 return err;
 109         }
 110         // Get subdevice instance.
 111         s = me_slist_get_subdevice(&device->slist, subdevice);
 112
 113         if (s) {
 114                 // Call subdevice method.
 115                 err = s->me_subdevice_io_irq_wait(s,
 116                                                   filep,
 117                                                   channel,
 118                                                   irq_count,
 119                                                   value, time_out, flags);
 120         } else {
 121                 // Something really bad happened.
 122                 PERROR("Cannot get subdevice instance.\n");
 123                 err = ME_ERRNO_INTERNAL;
 124         }
 125
 126         // Exit device.
 127         me_dlock_exit(&device->dlock, filep);
 128
 129         return err;
 130 }
 131
 132 static int me_device_io_irq_stop(struct me_device *device,
 133                                  struct file *filep,
 134                                  int subdevice, int channel, int flags)
 135 {
 136         int err = ME_ERRNO_SUCCESS;
 137         me_subdevice_t *s;
 138
 139         PDEBUG("executed.\n");
 140
 141         // Check subdevice index.
 142         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 143                 PERROR("Invalid subdevice.\n");
 144                 return ME_ERRNO_INVALID_SUBDEVICE;
 145         }
 146         // Enter device.
 147         err = me_dlock_enter(&device->dlock, filep);
 148
 149         if (err) {
 150                 PERROR("Cannot enter device.\n");
 151                 return err;
 152         }
 153         // Get subdevice instance.
 154         s = me_slist_get_subdevice(&device->slist, subdevice);
 155
 156         if (s) {
 157                 // Call subdevice method.
 158                 err = s->me_subdevice_io_irq_stop(s, filep, channel, flags);
 159         } else {
 160                 // Something really bad happened.
 161                 PERROR("Cannot get subdevice instance.\n");
 162                 err = ME_ERRNO_INTERNAL;
 163         }
 164
 165         // Exit device.
 166         me_dlock_exit(&device->dlock, filep);
 167
 168         return err;
 169 }
 170
 171 static int me_device_io_reset_device(struct me_device *device,
 172                                      struct file *filep, int flags)
 173 {
 174         int err = ME_ERRNO_SUCCESS;
 175         me_subdevice_t *s;
 176         int i, n;
 177
 178         PDEBUG("executed.\n");
 179
 180         /* Get the number of subdevices. */
 181         n = me_slist_get_number_subdevices(&device->slist);
 182
 183         // Enter device.
 184         err = me_dlock_enter(&device->dlock, filep);
 185
 186         if (err) {
 187                 PERROR("Cannot enter device.\n");
 188                 return err;
 189         }
 190
 191         /* Reset every subdevice in list. */
 192         for (i = 0; i < n; i++) {
 193                 s = me_slist_get_subdevice(&device->slist, i);
 194                 err = s->me_subdevice_io_reset_subdevice(s, filep, flags);
 195
 196                 if (err) {
 197                         PERROR("Cannot reset subdevice.\n");
 198                         break;
 199                 }
 200         }
 201
 202         // Exit device.
 203         me_dlock_exit(&device->dlock, filep);
 204
 205         return err;
 206 }
 207
 208 static int me_device_io_reset_subdevice(struct me_device *device,
 209                                         struct file *filep,
 210                                         int subdevice, int flags)
 211 {
 212         int err = ME_ERRNO_SUCCESS;
 213         me_subdevice_t *s;
 214
 215         PDEBUG("executed.\n");
 216
 217         // Check subdevice index.
 218
 219         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 220                 PERROR("Invalid subdevice.\n");
 221                 return ME_ERRNO_INVALID_SUBDEVICE;
 222         }
 223         // Enter device.
 224         err = me_dlock_enter(&device->dlock, filep);
 225
 226         if (err) {
 227                 PERROR("Cannot enter device.\n");
 228                 return err;
 229         }
 230         // Get subdevice instance.
 231         s = me_slist_get_subdevice(&device->slist, subdevice);
 232
 233         if (s) {
 234                 // Call subdevice method.
 235                 err = s->me_subdevice_io_reset_subdevice(s, filep, flags);
 236         } else {
 237                 // Something really bad happened.
 238                 PERROR("Cannot get subdevice instance.\n");
 239                 err = ME_ERRNO_INTERNAL;
 240         }
 241
 242         // Exit device.
 243         me_dlock_exit(&device->dlock, filep);
 244
 245         return err;
 246 }
 247
 248 static int me_device_io_single_config(struct me_device *device,
 249                                       struct file *filep,
 250                                       int subdevice,
 251                                       int channel,
 252                                       int single_config,
 253                                       int ref,
 254                                       int trig_chan,
 255                                       int trig_type, int trig_edge, int flags)
 256 {
 257         int err = ME_ERRNO_SUCCESS;
 258         me_subdevice_t *s;
 259
 260         PDEBUG("executed.\n");
 261
 262         // Check subdevice index.
 263
 264         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 265                 PERROR("Invalid subdevice.\n");
 266                 return ME_ERRNO_INVALID_SUBDEVICE;
 267         }
 268         // Enter device.
 269         err = me_dlock_enter(&device->dlock, filep);
 270
 271         if (err) {
 272                 PERROR("Cannot enter device.\n");
 273                 return err;
 274         }
 275         // Get subdevice instance.
 276         s = me_slist_get_subdevice(&device->slist, subdevice);
 277
 278         if (s) {
 279                 // Call subdevice method.
 280                 err = s->me_subdevice_io_single_config(s,
 281                                                        filep,
 282                                                        channel,
 283                                                        single_config,
 284                                                        ref,
 285                                                        trig_chan,
 286                                                        trig_type,
 287                                                        trig_edge, flags);
 288         } else {
 289                 // Something really bad happened.
 290                 PERROR("Cannot get subdevice instance.\n");
 291                 err = ME_ERRNO_INTERNAL;
 292         }
 293
 294         // Exit device.
 295         me_dlock_exit(&device->dlock, filep);
 296
 297         return err;
 298 }
 299
 300 static int me_device_io_single_read(struct me_device *device,
 301                                     struct file *filep,
 302                                     int subdevice,
 303                                     int channel,
 304                                     int *value, int time_out, int flags)
 305 {
 306         int err = ME_ERRNO_SUCCESS;
 307         me_subdevice_t *s;
 308
 309         PDEBUG("executed.\n");
 310
 311         // Check subdevice index.
 312
 313         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 314                 PERROR("Invalid subdevice.\n");
 315                 return ME_ERRNO_INVALID_SUBDEVICE;
 316         }
 317         // Enter device.
 318         err = me_dlock_enter(&device->dlock, filep);
 319
 320         if (err) {
 321                 PERROR("Cannot enter device.\n");
 322                 return err;
 323         }
 324         // Get subdevice instance.
 325         s = me_slist_get_subdevice(&device->slist, subdevice);
 326
 327         if (s) {
 328                 // Call subdevice method.
 329                 err = s->me_subdevice_io_single_read(s,
 330                                                      filep,
 331                                                      channel,
 332                                                      value, time_out, flags);
 333         } else {
 334                 // Something really bad happened.
 335                 PERROR("Cannot get subdevice instance.\n");
 336                 err = ME_ERRNO_INTERNAL;
 337         }
 338
 339         // Exit device.
 340         me_dlock_exit(&device->dlock, filep);
 341
 342         return err;
 343 }
 344
 345 static int me_device_io_single_write(struct me_device *device,
 346                                      struct file *filep,
 347                                      int subdevice,
 348                                      int channel,
 349                                      int value, int time_out, int flags)
 350 {
 351         int err = ME_ERRNO_SUCCESS;
 352         me_subdevice_t *s;
 353
 354         PDEBUG("executed.\n");
 355
 356         // Check subdevice index.
 357
 358         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 359                 PERROR("Invalid subdevice.\n");
 360                 return ME_ERRNO_INVALID_SUBDEVICE;
 361         }
 362         // Enter device.
 363         err = me_dlock_enter(&device->dlock, filep);
 364
 365         if (err) {
 366                 PERROR("Cannot enter device.\n");
 367                 return err;
 368         }
 369         // Get subdevice instance.
 370         s = me_slist_get_subdevice(&device->slist, subdevice);
 371
 372         if (s) {
 373                 // Call subdevice method.
 374                 err = s->me_subdevice_io_single_write(s,
 375                                                       filep,
 376                                                       channel,
 377                                                       value, time_out, flags);
 378         } else {
 379                 // Something really bad happened.
 380                 PERROR("Cannot get subdevice instance.\n");
 381                 err = ME_ERRNO_INTERNAL;
 382         }
 383
 384         // Exit device.
 385         me_dlock_exit(&device->dlock, filep);
 386
 387         return err;
 388 }
 389
 390 static int me_device_io_stream_config(struct me_device *device,
 391                                       struct file *filep,
 392                                       int subdevice,
 393                                       meIOStreamConfig_t * config_list,
 394                                       int count,
 395                                       meIOStreamTrigger_t * trigger,
 396                                       int fifo_irq_threshold, int flags)
 397 {
 398         int err = ME_ERRNO_SUCCESS;
 399         me_subdevice_t *s;
 400
 401         PDEBUG("executed.\n");
 402
 403         // Check subdevice index.
 404
 405         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 406                 PERROR("Invalid subdevice.\n");
 407                 return ME_ERRNO_INVALID_SUBDEVICE;
 408         }
 409         // Enter device.
 410         err = me_dlock_enter(&device->dlock, filep);
 411
 412         if (err) {
 413                 PERROR("Cannot enter device.\n");
 414                 return err;
 415         }
 416         // Get subdevice instance.
 417         s = me_slist_get_subdevice(&device->slist, subdevice);
 418
 419         if (s) {
 420                 // Call subdevice method.
 421                 err = s->me_subdevice_io_stream_config(s,
 422                                                        filep,
 423                                                        config_list,
 424                                                        count,
 425                                                        trigger,
 426                                                        fifo_irq_threshold,
 427                                                        flags);
 428         } else {
 429                 // Something really bad happened.
 430                 PERROR("Cannot get subdevice instance.\n");
 431                 err = ME_ERRNO_INTERNAL;
 432         }
 433
 434         // Exit device.
 435         me_dlock_exit(&device->dlock, filep);
 436
 437         return err;
 438 }
 439
 440 static int me_device_io_stream_new_values(struct me_device *device,
 441                                           struct file *filep,
 442                                           int subdevice,
 443                                           int time_out, int *count, int flags)
 444 {
 445         int err = ME_ERRNO_SUCCESS;
 446         me_subdevice_t *s;
 447
 448         PDEBUG("executed.\n");
 449
 450         // Check subdevice index.
 451
 452         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 453                 PERROR("Invalid subdevice.\n");
 454                 return ME_ERRNO_INVALID_SUBDEVICE;
 455         }
 456         // Enter device.
 457         err = me_dlock_enter(&device->dlock, filep);
 458
 459         if (err) {
 460                 PERROR("Cannot enter device.\n");
 461                 return err;
 462         }
 463         // Get subdevice instance.
 464         s = me_slist_get_subdevice(&device->slist, subdevice);
 465
 466         if (s) {
 467                 // Call subdevice method.
 468                 err = s->me_subdevice_io_stream_new_values(s,
 469                                                            filep,
 470                                                            time_out,
 471                                                            count, flags);
 472         } else {
 473                 // Something really bad happened.
 474                 PERROR("Cannot get subdevice instance.\n");
 475                 err = ME_ERRNO_INTERNAL;
 476         }
 477
 478         // Exit device.
 479         me_dlock_exit(&device->dlock, filep);
 480
 481         return err;
 482 }
 483
 484 static int me_device_io_stream_read(struct me_device *device,
 485                                     struct file *filep,
 486                                     int subdevice,
 487                                     int read_mode,
 488                                     int *values, int *count, int flags)
 489 {
 490         int err = ME_ERRNO_SUCCESS;
 491         me_subdevice_t *s;
 492
 493         PDEBUG("executed.\n");
 494
 495         // Check subdevice index.
 496
 497         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 498                 PERROR("Invalid subdevice.\n");
 499                 return ME_ERRNO_INVALID_SUBDEVICE;
 500         }
 501         // Enter device.
 502         err = me_dlock_enter(&device->dlock, filep);
 503
 504         if (err) {
 505                 PERROR("Cannot enter device.\n");
 506                 return err;
 507         }
 508         // Get subdevice instance.
 509         s = me_slist_get_subdevice(&device->slist, subdevice);
 510
 511         if (s) {
 512                 // Call subdevice method.
 513                 err = s->me_subdevice_io_stream_read(s,
 514                                                      filep,
 515                                                      read_mode,
 516                                                      values, count, flags);
 517         } else {
 518                 // Something really bad happened.
 519                 PERROR("Cannot get subdevice instance.\n");
 520                 err = ME_ERRNO_INTERNAL;
 521         }
 522
 523         // Exit device.
 524         me_dlock_exit(&device->dlock, filep);
 525
 526         return err;
 527 }
 528
 529 static int me_device_io_stream_start(struct me_device *device,
 530                                      struct file *filep,
 531                                      int subdevice,
 532                                      int start_mode, int time_out, int flags)
 533 {
 534         int err = ME_ERRNO_SUCCESS;
 535         me_subdevice_t *s;
 536
 537         PDEBUG("executed.\n");
 538
 539         // Check subdevice index.
 540
 541         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 542                 PERROR("Invalid subdevice.\n");
 543                 return ME_ERRNO_INVALID_SUBDEVICE;
 544         }
 545         // Enter device.
 546         err = me_dlock_enter(&device->dlock, filep);
 547
 548         if (err) {
 549                 PERROR("Cannot enter device.\n");
 550                 return err;
 551         }
 552         // Get subdevice instance.
 553         s = me_slist_get_subdevice(&device->slist, subdevice);
 554
 555         if (s) {
 556                 // Call subdevice method.
 557                 err = s->me_subdevice_io_stream_start(s,
 558                                                       filep,
 559                                                       start_mode,
 560                                                       time_out, flags);
 561         } else {
 562                 // Something really bad happened.
 563                 PERROR("Cannot get subdevice instance.\n");
 564                 err = ME_ERRNO_INTERNAL;
 565         }
 566
 567         // Exit device.
 568         me_dlock_exit(&device->dlock, filep);
 569
 570         return err;
 571 }
 572
 573 static int me_device_io_stream_status(struct me_device *device,
 574                                       struct file *filep,
 575                                       int subdevice,
 576                                       int wait,
 577                                       int *status, int *count, int flags)
 578 {
 579         int err = ME_ERRNO_SUCCESS;
 580         me_subdevice_t *s;
 581
 582         PDEBUG("executed.\n");
 583
 584         // Check subdevice index.
 585
 586         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 587                 PERROR("Invalid subdevice.\n");
 588                 return ME_ERRNO_INVALID_SUBDEVICE;
 589         }
 590         // Enter device.
 591         err = me_dlock_enter(&device->dlock, filep);
 592
 593         if (err) {
 594                 PERROR("Cannot enter device.\n");
 595                 return err;
 596         }
 597         // Get subdevice instance.
 598         s = me_slist_get_subdevice(&device->slist, subdevice);
 599
 600         if (s) {
 601                 // Call subdevice method.
 602                 err = s->me_subdevice_io_stream_status(s,
 603                                                        filep,
 604                                                        wait,
 605                                                        status, count, flags);
 606         } else {
 607                 // Something really bad happened.
 608                 PERROR("Cannot get subdevice instance.\n");
 609                 err = ME_ERRNO_INTERNAL;
 610         }
 611
 612         // Exit device.
 613         me_dlock_exit(&device->dlock, filep);
 614
 615         return err;
 616 }
 617
 618 static int me_device_io_stream_stop(struct me_device *device,
 619                                     struct file *filep,
 620                                     int subdevice, int stop_mode, int flags)
 621 {
 622         int err = ME_ERRNO_SUCCESS;
 623         me_subdevice_t *s;
 624
 625         PDEBUG("executed.\n");
 626
 627         // Check subdevice index.
 628
 629         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 630                 PERROR("Invalid subdevice.\n");
 631                 return ME_ERRNO_INVALID_SUBDEVICE;
 632         }
 633         // Enter device.
 634         err = me_dlock_enter(&device->dlock, filep);
 635
 636         if (err) {
 637                 PERROR("Cannot enter device.\n");
 638                 return err;
 639         }
 640         // Get subdevice instance.
 641         s = me_slist_get_subdevice(&device->slist, subdevice);
 642
 643         if (s) {
 644                 // Call subdevice method.
 645                 err = s->me_subdevice_io_stream_stop(s,
 646                                                      filep, stop_mode, flags);
 647         } else {
 648                 // Something really bad happened.
 649                 PERROR("Cannot get subdevice instance.\n");
 650                 err = ME_ERRNO_INTERNAL;
 651         }
 652
 653         // Exit device.
 654         me_dlock_exit(&device->dlock, filep);
 655
 656         return err;
 657 }
 658
 659 static int me_device_io_stream_write(struct me_device *device,
 660                                      struct file *filep,
 661                                      int subdevice,
 662                                      int write_mode,
 663                                      int *values, int *count, int flags)
 664 {
 665         int err = ME_ERRNO_SUCCESS;
 666         me_subdevice_t *s;
 667
 668         PDEBUG("executed.\n");
 669
 670         // Check subdevice index.
 671
 672         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 673                 PERROR("Invalid subdevice.\n");
 674                 return ME_ERRNO_INVALID_SUBDEVICE;
 675         }
 676         // Enter device.
 677         err = me_dlock_enter(&device->dlock, filep);
 678
 679         if (err) {
 680                 PERROR("Cannot enter device.\n");
 681                 return err;
 682         }
 683         // Get subdevice instance.
 684         s = me_slist_get_subdevice(&device->slist, subdevice);
 685
 686         if (s) {
 687                 // Call subdevice method.
 688                 err = s->me_subdevice_io_stream_write(s,
 689                                                       filep,
 690                                                       write_mode,
 691                                                       values, count, flags);
 692         } else {
 693                 // Something really bad happened.
 694                 PERROR("Cannot get subdevice instance.\n");
 695                 err = ME_ERRNO_INTERNAL;
 696         }
 697
 698         // Exit device.
 699         me_dlock_exit(&device->dlock, filep);
 700
 701         return err;
 702 }
 703
 704 static int me_device_lock_device(struct me_device *device,
 705                                  struct file *filep, int lock, int flags)
 706 {
 707         PDEBUG("executed.\n");
 708
 709         return me_dlock_lock(&device->dlock,
 710                              filep, lock, flags, &device->slist);
 711 }
 712
 713 static int me_device_lock_subdevice(struct me_device *device,
 714                                     struct file *filep,
 715                                     int subdevice, int lock, int flags)
 716 {
 717         int err = ME_ERRNO_SUCCESS;
 718         me_subdevice_t *s;
 719
 720         PDEBUG("executed.\n");
 721
 722         // Check subdevice index.
 723
 724         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 725                 PERROR("Invalid subdevice.\n");
 726                 return ME_ERRNO_INVALID_SUBDEVICE;
 727         }
 728         // Enter device.
 729         err = me_dlock_enter(&device->dlock, filep);
 730
 731         if (err) {
 732                 PERROR("Cannot enter device.\n");
 733                 return err;
 734         }
 735         // Get subdevice instance.
 736         s = me_slist_get_subdevice(&device->slist, subdevice);
 737
 738         if (s) {
 739                 // Call subdevice method.
 740                 err = s->me_subdevice_lock_subdevice(s, filep, lock, flags);
 741         } else {
 742                 // Something really bad happened.
 743                 PERROR("Cannot get subdevice instance.\n");
 744                 err = ME_ERRNO_INTERNAL;
 745         }
 746
 747         // Exit device.
 748         me_dlock_exit(&device->dlock, filep);
 749
 750         return err;
 751 }
 752
 753 static int me_device_query_description_device(struct me_device *device,
 754                                               char **description)
 755 {
 756         PDEBUG("executed.\n");
 757         *description = device->device_description;
 758         return ME_ERRNO_SUCCESS;
 759 }
 760
 761 static int me_device_query_info_device(struct me_device *device,
 762                                        int *vendor_id,
 763                                        int *device_id,
 764                                        int *serial_no,
 765                                        int *bus_type,
 766                                        int *bus_no,
 767                                        int *dev_no, int *func_no, int *plugged)
 768 {
 769         PDEBUG("executed.\n");
 770
 771         if (device->bus_type == ME_BUS_TYPE_PCI) {
 772                 *vendor_id = device->info.pci.vendor_id;
 773                 *device_id = device->info.pci.device_id;
 774                 *serial_no = device->info.pci.serial_no;
 775                 *bus_type = ME_BUS_TYPE_PCI;
 776                 *bus_no = device->info.pci.pci_bus_no;
 777                 *dev_no = device->info.pci.pci_dev_no;
 778                 *func_no = device->info.pci.pci_func_no;
 779                 *plugged = ME_PLUGGED_IN;
 780         } else {
 781                 *plugged = ME_PLUGGED_OUT;
 782         }
 783         return ME_ERRNO_SUCCESS;
 784 }
 785
 786 static int me_device_query_name_device(struct me_device *device, char **name)
 787 {
 788         PDEBUG("executed.\n");
 789         *name = device->device_name;
 790         return ME_ERRNO_SUCCESS;
 791 }
 792
 793 static int me_device_query_name_device_driver(struct me_device *device,
 794                                               char **name)
 795 {
 796         PDEBUG("executed.\n");
 797         *name = device->driver_name;
 798         return ME_ERRNO_SUCCESS;
 799 }
 800
 801 static int me_device_query_number_subdevices(struct me_device *device,
 802                                              int *number)
 803 {
 804         PDEBUG("executed.\n");
 805         return me_slist_query_number_subdevices(&device->slist, number);
 806 }
 807
 808 static int me_device_query_number_channels(struct me_device *device,
 809                                            int subdevice, int *number)
 810 {
 811         int err = ME_ERRNO_SUCCESS;
 812         me_subdevice_t *s;
 813
 814         PDEBUG("executed.\n");
 815
 816         // Check subdevice index.
 817
 818         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 819                 PERROR("Invalid subdevice.\n");
 820                 return ME_ERRNO_INVALID_SUBDEVICE;
 821         }
 822         // Get subdevice instance.
 823         s = me_slist_get_subdevice(&device->slist, subdevice);
 824
 825         if (s) {
 826                 // Call subdevice method.
 827                 err = s->me_subdevice_query_number_channels(s, number);
 828         } else {
 829                 // Something really bad happened.
 830                 PERROR("Cannot get subdevice instance.\n");
 831                 err = ME_ERRNO_INTERNAL;
 832         }
 833
 834         return err;
 835 }
 836
 837 static int me_device_query_number_ranges(struct me_device *device,
 838                                          int subdevice, int unit, int *count)
 839 {
 840         int err = ME_ERRNO_SUCCESS;
 841         me_subdevice_t *s;
 842
 843         PDEBUG("executed.\n");
 844
 845         // Check subdevice index.
 846
 847         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 848                 PERROR("Invalid subdevice.\n");
 849                 return ME_ERRNO_INVALID_SUBDEVICE;
 850         }
 851         // Get subdevice instance.
 852         s = me_slist_get_subdevice(&device->slist, subdevice);
 853
 854         if (s) {
 855                 // Call subdevice method.
 856                 err = s->me_subdevice_query_number_ranges(s, unit, count);
 857         } else {
 858                 // Something really bad happened.
 859                 PERROR("Cannot get subdevice instance.\n");
 860                 err = ME_ERRNO_INTERNAL;
 861         }
 862
 863         return err;
 864 }
 865
 866 static int me_device_query_range_by_min_max(struct me_device *device,
 867                                             int subdevice,
 868                                             int unit,
 869                                             int *min,
 870                                             int *max, int *maxdata, int *range)
 871 {
 872         int err = ME_ERRNO_SUCCESS;
 873         me_subdevice_t *s;
 874
 875         PDEBUG("executed.\n");
 876
 877         // Check subdevice index.
 878
 879         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 880                 PERROR("Invalid subdevice.\n");
 881                 return ME_ERRNO_INVALID_SUBDEVICE;
 882         }
 883         // Get subdevice instance.
 884         s = me_slist_get_subdevice(&device->slist, subdevice);
 885
 886         if (s) {
 887                 // Call subdevice method.
 888                 err = s->me_subdevice_query_range_by_min_max(s,
 889                                                              unit,
 890                                                              min,
 891                                                              max,
 892                                                              maxdata, range);
 893         } else {
 894                 // Something really bad happened.
 895                 PERROR("Cannot get subdevice instance.\n");
 896                 err = ME_ERRNO_INTERNAL;
 897         }
 898
 899         return err;
 900 }
 901
 902 static int me_device_query_range_info(struct me_device *device,
 903                                       int subdevice,
 904                                       int range,
 905                                       int *unit,
 906                                       int *min, int *max, int *maxdata)
 907 {
 908         int err = ME_ERRNO_SUCCESS;
 909         me_subdevice_t *s;
 910
 911         PDEBUG("executed.\n");
 912
 913         // Check subdevice index.
 914
 915         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 916                 PERROR("Invalid subdevice.\n");
 917                 return ME_ERRNO_INVALID_SUBDEVICE;
 918         }
 919         // Get subdevice instance.
 920         s = me_slist_get_subdevice(&device->slist, subdevice);
 921
 922         if (s) {
 923                 // Call subdevice method.
 924                 err = s->me_subdevice_query_range_info(s,
 925                                                        range,
 926                                                        unit, min, max, maxdata);
 927         } else {
 928                 // Something really bad happened.
 929                 PERROR("Cannot get subdevice instance.\n");
 930                 err = ME_ERRNO_INTERNAL;
 931         }
 932
 933         return err;
 934 }
 935
 936 static int me_device_query_subdevice_by_type(struct me_device *device,
 937                                              int start_subdevice,
 938                                              int type,
 939                                              int subtype, int *subdevice)
 940 {
 941         PDEBUG("executed.\n");
 942
 943         return me_slist_get_subdevice_by_type(&device->slist,
 944                                               start_subdevice,
 945                                               type, subtype, subdevice);
 946 }
 947
 948 static int me_device_query_subdevice_type(struct me_device *device,
 949                                           int subdevice,
 950                                           int *type, int *subtype)
 951 {
 952         int err = ME_ERRNO_SUCCESS;
 953         me_subdevice_t *s;
 954
 955         PDEBUG("executed.\n");
 956
 957         // Check subdevice index.
 958
 959         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 960                 PERROR("Invalid subdevice.\n");
 961                 return ME_ERRNO_INVALID_SUBDEVICE;
 962         }
 963         // Get subdevice instance.
 964         s = me_slist_get_subdevice(&device->slist, subdevice);
 965
 966         if (s) {
 967                 // Call subdevice method.
 968                 err = s->me_subdevice_query_subdevice_type(s, type, subtype);
 969         } else {
 970                 // Something really bad happened.
 971                 PERROR("Cannot get subdevice instance.\n");
 972                 err = ME_ERRNO_INTERNAL;
 973         }
 974
 975         return err;
 976 }
 977
 978 static int me_device_query_subdevice_caps(struct me_device *device,
 979                                           int subdevice, int *caps)
 980 {
 981         int err = ME_ERRNO_SUCCESS;
 982         me_subdevice_t *s;
 983
 984         PDEBUG("executed.\n");
 985
 986         // Check subdevice index.
 987
 988         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
 989                 PERROR("Invalid subdevice.\n");
 990                 return ME_ERRNO_INVALID_SUBDEVICE;
 991         }
 992         // Get subdevice instance.
 993         s = me_slist_get_subdevice(&device->slist, subdevice);
 994
 995         if (s) {
 996                 // Call subdevice method.
 997                 err = s->me_subdevice_query_subdevice_caps(s, caps);
 998         } else {
 999                 // Something really bad happened.
1000                 PERROR("Cannot get subdevice instance.\n");
1001                 err = ME_ERRNO_INTERNAL;
1002         }
1003
1004         return err;
1005 }
1006
1007 static int me_device_query_subdevice_caps_args(struct me_device *device,
1008                                                int subdevice,
1009                                                int cap, int *args, int count)
1010 {
1011         int err = ME_ERRNO_SUCCESS;
1012         me_subdevice_t *s;
1013
1014         PDEBUG("executed.\n");
1015
1016         // Check subdevice index.
1017
1018         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
1019                 PERROR("Invalid subdevice.\n");
1020                 return ME_ERRNO_INVALID_SUBDEVICE;
1021         }
1022         // Get subdevice instance.
1023         s = me_slist_get_subdevice(&device->slist, subdevice);
1024
1025         if (s) {
1026                 // Call subdevice method.
1027                 err = s->me_subdevice_query_subdevice_caps_args(s,
1028                                                                 cap,
1029                                                                 args, count);
1030         } else {
1031                 // Something really bad happened.
1032                 PERROR("Cannot get subdevice instance.\n");
1033                 err = ME_ERRNO_INTERNAL;
1034         }
1035
1036         return err;
1037 }
1038
1039 static int me_device_query_timer(struct me_device *device,
1040                                  int subdevice,
1041                                  int timer,
1042                                  int *base_frequency,
1043                                  uint64_t * min_ticks, uint64_t * max_ticks)
1044 {
1045         int err = ME_ERRNO_SUCCESS;
1046         me_subdevice_t *s;
1047
1048         PDEBUG("executed.\n");
1049
1050         // Check subdevice index.
1051
1052         if (subdevice >= me_slist_get_number_subdevices(&device->slist)) {
1053                 PERROR("Invalid subdevice.\n");
1054                 return ME_ERRNO_INVALID_SUBDEVICE;
1055         }
1056         // Get subdevice instance.
1057         s = me_slist_get_subdevice(&device->slist, subdevice);
1058
1059         if (s) {
1060                 // Call subdevice method.
1061                 err = s->me_subdevice_query_timer(s,
1062                                                   timer,
1063                                                   base_frequency,
1064                                                   min_ticks, max_ticks);
1065         } else {
1066                 // Something really bad happened.
1067                 PERROR("Cannot get subdevice instance.\n");
1068                 err = ME_ERRNO_INTERNAL;
1069         }
1070
1071         return err;
1072 }
1073
1074 static int me_device_query_version_device_driver(struct me_device *device,
1075                                                  int *version)
1076 /** @todo Versions shold be read from driver. I must overwrite this function in each module. Here should be returned an error!
1077 */
1078 {
1079         PDEBUG("executed.\n");
1080         *version = ME_VERSION_DRIVER;
1081         return ME_ERRNO_SUCCESS;
1082 }
1083
1084 static int me_device_config_load(struct me_device *device, struct file *filep,
1085                                  me_cfg_device_entry_t * config)
1086 {
1087         PDEBUG("executed.\n");
1088         return ME_ERRNO_SUCCESS;        //If no need for config return success.
1089 //      return ME_ERRNO_NOT_SUPPORTED;
1090 }
1091
1092 static void me_device_destructor(me_device_t * me_device)
1093 {
1094         PDEBUG("executed.\n");
1095         me_device_deinit(me_device);
1096         kfree(me_device);
1097 }
1098
1099 /* //me_device_usb_init
1100 int me_device_usb_init(me_device_t *me_device, struct usb_interface *interface)
1101 {
1102         PDEBUG("executed.\n");
1103         return -1;
1104 }
1105 */
1106
1107 static int get_device_descriptions(uint16_t device_id,
1108                                    char **device_name,
1109                                    char **device_description,
1110                                    char **driver_name)
1111 /** @todo This is wrong concept! Static table has too strong limitations!
1112 * 'device_name' and 'driver_name' should be calculated from 'device_id'
1113 * 'device_description' should be read from device or moved to user space and handled by library!
1114 */
1115 {
1116         PDEBUG("executed.\n");
1117
1118         switch (device_id) {
1119         case PCI_DEVICE_ID_MEILHAUS_ME1000:
1120         case PCI_DEVICE_ID_MEILHAUS_ME1000_A:
1121         case PCI_DEVICE_ID_MEILHAUS_ME1000_B:
1122                 *device_name = ME1000_NAME_DEVICE_ME1000;
1123                 *device_description = ME1000_DESCRIPTION_DEVICE_ME1000;
1124                 *driver_name = ME1000_NAME_DRIVER;
1125                 break;
1126
1127         case PCI_DEVICE_ID_MEILHAUS_ME1400:
1128                 *device_name = ME1400_NAME_DEVICE_ME1400;
1129                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400;
1130                 *driver_name = ME1400_NAME_DRIVER;
1131                 break;
1132
1133         case PCI_DEVICE_ID_MEILHAUS_ME140A:
1134                 *device_name = ME1400_NAME_DEVICE_ME1400A;
1135                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400A;
1136                 *driver_name = ME1400_NAME_DRIVER;
1137                 break;
1138
1139         case PCI_DEVICE_ID_MEILHAUS_ME140B:
1140                 *device_name = ME1400_NAME_DEVICE_ME1400B;
1141                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400B;
1142                 *driver_name = ME1400_NAME_DRIVER;
1143                 break;
1144
1145         case PCI_DEVICE_ID_MEILHAUS_ME14E0:
1146                 *device_name = ME1400_NAME_DEVICE_ME1400E;
1147                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400E;
1148                 *driver_name = ME1400_NAME_DRIVER;
1149                 break;
1150
1151         case PCI_DEVICE_ID_MEILHAUS_ME14EA:
1152                 *device_name = ME1400_NAME_DEVICE_ME1400EA;
1153                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400EA;
1154                 *driver_name = ME1400_NAME_DRIVER;
1155                 break;
1156
1157         case PCI_DEVICE_ID_MEILHAUS_ME14EB:
1158                 *device_name = ME1400_NAME_DEVICE_ME1400EB;
1159                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400EB;
1160                 *driver_name = ME1400_NAME_DRIVER;
1161                 break;
1162
1163         case PCI_DEVICE_ID_MEILHAUS_ME140C:
1164                 *device_name = ME1400_NAME_DEVICE_ME1400C;
1165                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400C;
1166                 *driver_name = ME1400_NAME_DRIVER;
1167                 break;
1168
1169         case PCI_DEVICE_ID_MEILHAUS_ME140D:
1170                 *device_name = ME1400_NAME_DEVICE_ME1400D;
1171                 *device_description = ME1400_DESCRIPTION_DEVICE_ME1400D;
1172                 *driver_name = ME1400_NAME_DRIVER;
1173                 break;
1174
1175         case PCI_DEVICE_ID_MEILHAUS_ME1600_4U:
1176                 *device_name = ME1600_NAME_DEVICE_ME16004U;
1177                 *device_description = ME1600_DESCRIPTION_DEVICE_ME16004U;
1178                 *driver_name = ME1600_NAME_DRIVER;
1179                 break;
1180
1181         case PCI_DEVICE_ID_MEILHAUS_ME1600_8U:
1182                 *device_name = ME1600_NAME_DEVICE_ME16008U;
1183                 *device_description = ME1600_DESCRIPTION_DEVICE_ME16008U;
1184                 *driver_name = ME1600_NAME_DRIVER;
1185                 break;
1186
1187         case PCI_DEVICE_ID_MEILHAUS_ME1600_12U:
1188                 *device_name = ME1600_NAME_DEVICE_ME160012U;
1189                 *device_description = ME1600_DESCRIPTION_DEVICE_ME160012U;
1190                 *driver_name = ME1600_NAME_DRIVER;
1191                 break;
1192
1193         case PCI_DEVICE_ID_MEILHAUS_ME1600_16U:
1194                 *device_name = ME1600_NAME_DEVICE_ME160016U;
1195                 *device_description = ME1600_DESCRIPTION_DEVICE_ME160016U;
1196                 *driver_name = ME1600_NAME_DRIVER;
1197                 break;
1198
1199         case PCI_DEVICE_ID_MEILHAUS_ME1600_16U_8I:
1200                 *device_name = ME1600_NAME_DEVICE_ME160016U8I;
1201                 *device_description = ME1600_DESCRIPTION_DEVICE_ME160016U8I;
1202                 *driver_name = ME1600_NAME_DRIVER;
1203                 break;
1204
1205         case PCI_DEVICE_ID_MEILHAUS_ME4610:
1206                 *device_name = ME4600_NAME_DEVICE_ME4610;
1207                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4610;
1208                 *driver_name = ME4600_NAME_DRIVER;
1209                 break;
1210
1211         case PCI_DEVICE_ID_MEILHAUS_ME4650:
1212                 *device_name = ME4600_NAME_DEVICE_ME4650;
1213                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4650;
1214                 *driver_name = ME4600_NAME_DRIVER;
1215                 break;
1216
1217         case PCI_DEVICE_ID_MEILHAUS_ME4660:
1218                 *device_name = ME4600_NAME_DEVICE_ME4660;
1219                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4660;
1220                 *driver_name = ME4600_NAME_DRIVER;
1221                 break;
1222
1223         case PCI_DEVICE_ID_MEILHAUS_ME4660I:
1224                 *device_name = ME4600_NAME_DEVICE_ME4660I;
1225                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4660I;
1226                 *driver_name = ME4600_NAME_DRIVER;
1227                 break;
1228
1229         case PCI_DEVICE_ID_MEILHAUS_ME4660S:
1230                 *device_name = ME4600_NAME_DEVICE_ME4660S;
1231                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4660S;
1232                 *driver_name = ME4600_NAME_DRIVER;
1233                 break;
1234
1235         case PCI_DEVICE_ID_MEILHAUS_ME4660IS:
1236                 *device_name = ME4600_NAME_DEVICE_ME4660IS;
1237                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4660IS;
1238                 *driver_name = ME4600_NAME_DRIVER;
1239                 break;
1240
1241         case PCI_DEVICE_ID_MEILHAUS_ME4670:
1242                 *device_name = ME4600_NAME_DEVICE_ME4670;
1243                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4670;
1244                 *driver_name = ME4600_NAME_DRIVER;
1245                 break;
1246
1247         case PCI_DEVICE_ID_MEILHAUS_ME4670I:
1248                 *device_name = ME4600_NAME_DEVICE_ME4670I;
1249                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4670I;
1250                 *driver_name = ME4600_NAME_DRIVER;
1251                 break;
1252
1253         case PCI_DEVICE_ID_MEILHAUS_ME4670S:
1254                 *device_name = ME4600_NAME_DEVICE_ME4670S;
1255                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4670S;
1256                 *driver_name = ME4600_NAME_DRIVER;
1257                 break;
1258
1259         case PCI_DEVICE_ID_MEILHAUS_ME4670IS:
1260                 *device_name = ME4600_NAME_DEVICE_ME4670IS;
1261                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4670IS;
1262                 *driver_name = ME4600_NAME_DRIVER;
1263                 break;
1264
1265         case PCI_DEVICE_ID_MEILHAUS_ME4680:
1266                 *device_name = ME4600_NAME_DEVICE_ME4680;
1267                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4680;
1268                 *driver_name = ME4600_NAME_DRIVER;
1269                 break;
1270
1271         case PCI_DEVICE_ID_MEILHAUS_ME4680I:
1272                 *device_name = ME4600_NAME_DEVICE_ME4680I;
1273                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4680I;
1274                 *driver_name = ME4600_NAME_DRIVER;
1275                 break;
1276
1277         case PCI_DEVICE_ID_MEILHAUS_ME4680S:
1278                 *device_name = ME4600_NAME_DEVICE_ME4680S;
1279                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4680S;
1280                 *driver_name = ME4600_NAME_DRIVER;
1281                 break;
1282
1283         case PCI_DEVICE_ID_MEILHAUS_ME4680IS:
1284                 *device_name = ME4600_NAME_DEVICE_ME4680IS;
1285                 *device_description = ME4600_DESCRIPTION_DEVICE_ME4680IS;
1286                 *driver_name = ME4600_NAME_DRIVER;
1287                 break;
1288
1289         case PCI_DEVICE_ID_MEILHAUS_ME6004:
1290                 *device_name = ME6000_NAME_DEVICE_ME60004;
1291                 *device_description = ME6000_DESCRIPTION_DEVICE_ME60004;
1292                 *driver_name = ME6000_NAME_DRIVER;
1293                 break;
1294
1295         case PCI_DEVICE_ID_MEILHAUS_ME6008:
1296                 *device_name = ME6000_NAME_DEVICE_ME60008;
1297                 *device_description = ME6000_DESCRIPTION_DEVICE_ME60008;
1298                 *driver_name = ME6000_NAME_DRIVER;
1299                 break;
1300
1301         case PCI_DEVICE_ID_MEILHAUS_ME600F:
1302                 *device_name = ME6000_NAME_DEVICE_ME600016;
1303                 *device_description = ME6000_DESCRIPTION_DEVICE_ME600016;
1304                 *driver_name = ME6000_NAME_DRIVER;
1305                 break;
1306
1307         case PCI_DEVICE_ID_MEILHAUS_ME6014:
1308                 *device_name = ME6000_NAME_DEVICE_ME6000I4;
1309                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000I4;
1310                 *driver_name = ME6000_NAME_DRIVER;
1311                 break;
1312
1313         case PCI_DEVICE_ID_MEILHAUS_ME6018:
1314                 *device_name = ME6000_NAME_DEVICE_ME6000I8;
1315                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000I8;
1316                 *driver_name = ME6000_NAME_DRIVER;
1317                 break;
1318
1319         case PCI_DEVICE_ID_MEILHAUS_ME601F:
1320                 *device_name = ME6000_NAME_DEVICE_ME6000I16;
1321                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000I16;
1322                 *driver_name = ME6000_NAME_DRIVER;
1323                 break;
1324
1325         case PCI_DEVICE_ID_MEILHAUS_ME6034:
1326                 *device_name = ME6000_NAME_DEVICE_ME6000ISLE4;
1327                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE4;
1328                 *driver_name = ME6000_NAME_DRIVER;
1329                 break;
1330
1331         case PCI_DEVICE_ID_MEILHAUS_ME6038:
1332                 *device_name = ME6000_NAME_DEVICE_ME6000ISLE8;
1333                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE8;
1334                 *driver_name = ME6000_NAME_DRIVER;
1335                 break;
1336
1337         case PCI_DEVICE_ID_MEILHAUS_ME603F:
1338                 *device_name = ME6000_NAME_DEVICE_ME6000ISLE16;
1339                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE16;
1340                 *driver_name = ME6000_NAME_DRIVER;
1341                 break;
1342
1343         case PCI_DEVICE_ID_MEILHAUS_ME6104:
1344                 *device_name = ME6000_NAME_DEVICE_ME61004;
1345                 *device_description = ME6000_DESCRIPTION_DEVICE_ME61004;
1346                 *driver_name = ME6000_NAME_DRIVER;
1347                 break;
1348
1349         case PCI_DEVICE_ID_MEILHAUS_ME6108:
1350                 *device_name = ME6000_NAME_DEVICE_ME61008;
1351                 *device_description = ME6000_DESCRIPTION_DEVICE_ME61008;
1352                 *driver_name = ME6000_NAME_DRIVER;
1353                 break;
1354
1355         case PCI_DEVICE_ID_MEILHAUS_ME610F:
1356                 *device_name = ME6000_NAME_DEVICE_ME610016;
1357                 *device_description = ME6000_DESCRIPTION_DEVICE_ME610016;
1358                 *driver_name = ME6000_NAME_DRIVER;
1359                 break;
1360
1361         case PCI_DEVICE_ID_MEILHAUS_ME6114:
1362                 *device_name = ME6000_NAME_DEVICE_ME6100I4;
1363                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100I4;
1364                 *driver_name = ME6000_NAME_DRIVER;
1365                 break;
1366
1367         case PCI_DEVICE_ID_MEILHAUS_ME6118:
1368                 *device_name = ME6000_NAME_DEVICE_ME6100I8;
1369                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100I8;
1370                 *driver_name = ME6000_NAME_DRIVER;
1371                 break;
1372
1373         case PCI_DEVICE_ID_MEILHAUS_ME611F:
1374                 *device_name = ME6000_NAME_DEVICE_ME6100I16;
1375                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100I16;
1376                 *driver_name = ME6000_NAME_DRIVER;
1377                 break;
1378
1379         case PCI_DEVICE_ID_MEILHAUS_ME6134:
1380                 *device_name = ME6000_NAME_DEVICE_ME6100ISLE4;
1381                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE4;
1382                 *driver_name = ME6000_NAME_DRIVER;
1383                 break;
1384
1385         case PCI_DEVICE_ID_MEILHAUS_ME6138:
1386                 *device_name = ME6000_NAME_DEVICE_ME6100ISLE8;
1387                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE8;
1388                 *driver_name = ME6000_NAME_DRIVER;
1389                 break;
1390
1391         case PCI_DEVICE_ID_MEILHAUS_ME613F:
1392                 *device_name = ME6000_NAME_DEVICE_ME6100ISLE16;
1393                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE16;
1394                 *driver_name = ME6000_NAME_DRIVER;
1395                 break;
1396
1397         case PCI_DEVICE_ID_MEILHAUS_ME6044:
1398                 *device_name = ME6000_NAME_DEVICE_ME60004DIO;
1399                 *device_description = ME6000_DESCRIPTION_DEVICE_ME60004DIO;
1400                 *driver_name = ME6000_NAME_DRIVER;
1401                 break;
1402
1403         case PCI_DEVICE_ID_MEILHAUS_ME6048:
1404                 *device_name = ME6000_NAME_DEVICE_ME60008DIO;
1405                 *device_description = ME6000_DESCRIPTION_DEVICE_ME60008DIO;
1406                 *driver_name = ME6000_NAME_DRIVER;
1407                 break;
1408
1409         case PCI_DEVICE_ID_MEILHAUS_ME604F:
1410                 *device_name = ME6000_NAME_DEVICE_ME600016DIO;
1411                 *device_description = ME6000_DESCRIPTION_DEVICE_ME600016DIO;
1412                 *driver_name = ME6000_NAME_DRIVER;
1413                 break;
1414
1415         case PCI_DEVICE_ID_MEILHAUS_ME6054:
1416                 *device_name = ME6000_NAME_DEVICE_ME6000I4DIO;
1417                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000I4DIO;
1418                 *driver_name = ME6000_NAME_DRIVER;
1419                 break;
1420
1421         case PCI_DEVICE_ID_MEILHAUS_ME6058:
1422                 *device_name = ME6000_NAME_DEVICE_ME6000I8DIO;
1423                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000I8DIO;
1424                 *driver_name = ME6000_NAME_DRIVER;
1425                 break;
1426
1427         case PCI_DEVICE_ID_MEILHAUS_ME605F:
1428                 *device_name = ME6000_NAME_DEVICE_ME6000I16DIO;
1429                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000I16DIO;
1430                 *driver_name = ME6000_NAME_DRIVER;
1431                 break;
1432
1433         case PCI_DEVICE_ID_MEILHAUS_ME6074:
1434                 *device_name = ME6000_NAME_DEVICE_ME6000ISLE4DIO;
1435                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE4DIO;
1436                 *driver_name = ME6000_NAME_DRIVER;
1437                 break;
1438
1439         case PCI_DEVICE_ID_MEILHAUS_ME6078:
1440                 *device_name = ME6000_NAME_DEVICE_ME6000ISLE8DIO;
1441                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE8DIO;
1442                 *driver_name = ME6000_NAME_DRIVER;
1443                 break;
1444
1445         case PCI_DEVICE_ID_MEILHAUS_ME607F:
1446                 *device_name = ME6000_NAME_DEVICE_ME6000ISLE16DIO;
1447                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6000ISLE16DIO;
1448                 *driver_name = ME6000_NAME_DRIVER;
1449                 break;
1450
1451         case PCI_DEVICE_ID_MEILHAUS_ME6144:
1452                 *device_name = ME6000_NAME_DEVICE_ME61004DIO;
1453                 *device_description = ME6000_DESCRIPTION_DEVICE_ME61004DIO;
1454                 *driver_name = ME6000_NAME_DRIVER;
1455                 break;
1456
1457         case PCI_DEVICE_ID_MEILHAUS_ME6148:
1458                 *device_name = ME6000_NAME_DEVICE_ME61008DIO;
1459                 *device_description = ME6000_DESCRIPTION_DEVICE_ME61008DIO;
1460                 *driver_name = ME6000_NAME_DRIVER;
1461                 break;
1462
1463         case PCI_DEVICE_ID_MEILHAUS_ME614F:
1464                 *device_name = ME6000_NAME_DEVICE_ME610016DIO;
1465                 *device_description = ME6000_DESCRIPTION_DEVICE_ME610016DIO;
1466                 *driver_name = ME6000_NAME_DRIVER;
1467                 break;
1468
1469         case PCI_DEVICE_ID_MEILHAUS_ME6154:
1470                 *device_name = ME6000_NAME_DEVICE_ME6100I4DIO;
1471                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100I4DIO;
1472                 *driver_name = ME6000_NAME_DRIVER;
1473                 break;
1474
1475         case PCI_DEVICE_ID_MEILHAUS_ME6158:
1476                 *device_name = ME6000_NAME_DEVICE_ME6100I8DIO;
1477                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100I8DIO;
1478                 *driver_name = ME6000_NAME_DRIVER;
1479                 break;
1480
1481         case PCI_DEVICE_ID_MEILHAUS_ME615F:
1482                 *device_name = ME6000_NAME_DEVICE_ME6100I16DIO;
1483                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100I16DIO;
1484                 *driver_name = ME6000_NAME_DRIVER;
1485                 break;
1486
1487         case PCI_DEVICE_ID_MEILHAUS_ME6174:
1488                 *device_name = ME6000_NAME_DEVICE_ME6100ISLE4DIO;
1489                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE4DIO;
1490                 *driver_name = ME6000_NAME_DRIVER;
1491                 break;
1492
1493         case PCI_DEVICE_ID_MEILHAUS_ME6178:
1494                 *device_name = ME6000_NAME_DEVICE_ME6100ISLE8DIO;
1495                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE8DIO;
1496                 *driver_name = ME6000_NAME_DRIVER;
1497                 break;
1498
1499         case PCI_DEVICE_ID_MEILHAUS_ME617F:
1500                 *device_name = ME6000_NAME_DEVICE_ME6100ISLE16DIO;
1501                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6100ISLE16DIO;
1502                 *driver_name = ME6000_NAME_DRIVER;
1503                 break;
1504
1505         case PCI_DEVICE_ID_MEILHAUS_ME6259:
1506                 *device_name = ME6000_NAME_DEVICE_ME6200I9DIO;
1507                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6200I9DIO;
1508                 *driver_name = ME6000_NAME_DRIVER;
1509                 break;
1510
1511         case PCI_DEVICE_ID_MEILHAUS_ME6359:
1512                 *device_name = ME6000_NAME_DEVICE_ME6300I9DIO;
1513                 *device_description = ME6000_DESCRIPTION_DEVICE_ME6300I9DIO;
1514                 *driver_name = ME6000_NAME_DRIVER;
1515                 break;
1516
1517         case PCI_DEVICE_ID_MEILHAUS_ME0630:
1518                 *device_name = ME0600_NAME_DEVICE_ME0630;
1519                 *device_description = ME0600_DESCRIPTION_DEVICE_ME0630;
1520                 *driver_name = ME0600_NAME_DRIVER;
1521                 break;
1522
1523         case PCI_DEVICE_ID_MEILHAUS_ME8100_A:
1524                 *device_name = ME8100_NAME_DEVICE_ME8100A;
1525                 *device_description = ME8100_DESCRIPTION_DEVICE_ME8100A;
1526                 *driver_name = ME8100_NAME_DRIVER;
1527                 break;
1528
1529         case PCI_DEVICE_ID_MEILHAUS_ME8100_B:
1530                 *device_name = ME8100_NAME_DEVICE_ME8100B;
1531                 *device_description = ME8100_DESCRIPTION_DEVICE_ME8100B;
1532                 *driver_name = ME8100_NAME_DRIVER;
1533                 break;
1534
1535         case PCI_DEVICE_ID_MEILHAUS_ME8200_A:
1536                 *device_name = ME8200_NAME_DEVICE_ME8200A;
1537                 *device_description = ME8200_DESCRIPTION_DEVICE_ME8200A;
1538                 *driver_name = ME8200_NAME_DRIVER;
1539                 break;
1540
1541         case PCI_DEVICE_ID_MEILHAUS_ME8200_B:
1542                 *device_name = ME8200_NAME_DEVICE_ME8200B;
1543                 *device_description = ME8200_DESCRIPTION_DEVICE_ME8200B;
1544                 *driver_name = ME8200_NAME_DRIVER;
1545                 break;
1546
1547         case PCI_DEVICE_ID_MEILHAUS_ME0940:
1548                 *device_name = ME0900_NAME_DEVICE_ME0940;
1549                 *device_description = ME0900_DESCRIPTION_DEVICE_ME0940;
1550                 *driver_name = ME0900_NAME_DRIVER;
1551                 break;
1552
1553         case PCI_DEVICE_ID_MEILHAUS_ME0950:
1554                 *device_name = ME0900_NAME_DEVICE_ME0950;
1555                 *device_description = ME0900_DESCRIPTION_DEVICE_ME0950;
1556                 *driver_name = ME0900_NAME_DRIVER;
1557                 break;
1558
1559         case PCI_DEVICE_ID_MEILHAUS_ME0960:
1560                 *device_name = ME0900_NAME_DEVICE_ME0960;
1561                 *device_description = ME0900_DESCRIPTION_DEVICE_ME0960;
1562                 *driver_name = ME0900_NAME_DRIVER;
1563                 break;
1564 /*
1565                 case USB_DEVICE_ID_MEPHISTO_S1:
1566                         *device_name = MEPHISTO_S1_NAME_DEVICE;
1567                         *device_description = MEPHISTO_S1_DESCRIPTION_DEVICE;
1568                         *driver_name = MEPHISTO_S1_NAME_DRIVER;
1569                         break;
1570 */
1571         default:
1572                 *device_name = EMPTY_NAME_DEVICE;
1573                 *device_description = EMPTY_DESCRIPTION_DEVICE;
1574                 *driver_name = EMPTY_NAME_DRIVER;
1575
1576                 PERROR("Invalid device id.\n");
1577
1578                 return 1;
1579         }
1580
1581         return 0;
1582 }
1583
1584 int me_device_pci_init(me_device_t * me_device, struct pci_dev *pci_device)
1585 {
1586         int err;
1587         int i;
1588
1589         PDEBUG("executed.\n");
1590
1591         // Initialize device list head.
1592         INIT_LIST_HEAD(&me_device->list);
1593
1594         // Initialize device description strings.
1595         err = get_device_descriptions(pci_device->device,
1596                                       &me_device->device_name,
1597                                       &me_device->device_description,
1598                                       &me_device->driver_name);
1599
1600         if (err) {
1601                 PERROR("Cannot initialize device description strings.\n");
1602                 return 1;
1603         }
1604         // Enable the pci device.
1605         err = pci_enable_device(pci_device);
1606
1607         if (err < 0) {
1608                 PERROR("Cannot enable PCI device.\n");
1609                 return 1;
1610         }
1611         // Request the PCI register regions.
1612         err = pci_request_regions(pci_device, me_device->device_name);
1613
1614         if (err < 0) {
1615                 PERROR("Cannot request PCI regions.\n");
1616                 goto ERROR_0;
1617         }
1618         // The bus carrying the device is a PCI bus.
1619         me_device->bus_type = ME_BUS_TYPE_PCI;
1620
1621         // Store the PCI information for later usage.
1622         me_device->info.pci.pci_device = pci_device;
1623
1624         // Get PCI register bases and sizes.
1625         for (i = 0; i < 6; i++) {
1626                 me_device->info.pci.reg_bases[i] =
1627                     pci_resource_start(pci_device, i);
1628                 me_device->info.pci.reg_sizes[i] =
1629                     pci_resource_len(pci_device, i);
1630         }
1631
1632         // Get the PCI location.
1633         me_device->info.pci.pci_bus_no = pci_device->bus->number;
1634         me_device->info.pci.pci_dev_no = PCI_SLOT(pci_device->devfn);
1635         me_device->info.pci.pci_func_no = PCI_FUNC(pci_device->devfn);
1636
1637         // Get Meilhaus specific device information.
1638         me_device->info.pci.vendor_id = pci_device->vendor;
1639         me_device->info.pci.device_id = pci_device->device;
1640         pci_read_config_byte(pci_device, 0x08,
1641                              &me_device->info.pci.hw_revision);
1642         pci_read_config_dword(pci_device, 0x2C, &me_device->info.pci.serial_no);
1643
1644         // Get the interrupt request number.
1645         me_device->irq = pci_device->irq;
1646
1647         // Initialize device lock instance.
1648         err = me_dlock_init(&me_device->dlock);
1649
1650         if (err) {
1651                 PERROR("Cannot initialize device lock instance.\n");
1652                 goto ERROR_1;
1653         }
1654         // Initialize subdevice list instance.
1655         me_slist_init(&me_device->slist);
1656
1657         if (err) {
1658                 PERROR("Cannot initialize subdevice list instance.\n");
1659                 goto ERROR_2;
1660         }
1661         // Initialize method pointers.
1662         me_device->me_device_io_irq_start = me_device_io_irq_start;
1663         me_device->me_device_io_irq_wait = me_device_io_irq_wait;
1664         me_device->me_device_io_irq_stop = me_device_io_irq_stop;
1665         me_device->me_device_io_reset_device = me_device_io_reset_device;
1666         me_device->me_device_io_reset_subdevice = me_device_io_reset_subdevice;
1667         me_device->me_device_io_single_config = me_device_io_single_config;
1668         me_device->me_device_io_single_read = me_device_io_single_read;
1669         me_device->me_device_io_single_write = me_device_io_single_write;
1670         me_device->me_device_io_stream_config = me_device_io_stream_config;
1671         me_device->me_device_io_stream_new_values =
1672             me_device_io_stream_new_values;
1673         me_device->me_device_io_stream_read = me_device_io_stream_read;
1674         me_device->me_device_io_stream_start = me_device_io_stream_start;
1675         me_device->me_device_io_stream_status = me_device_io_stream_status;
1676         me_device->me_device_io_stream_stop = me_device_io_stream_stop;
1677         me_device->me_device_io_stream_write = me_device_io_stream_write;
1678         me_device->me_device_lock_device = me_device_lock_device;
1679         me_device->me_device_lock_subdevice = me_device_lock_subdevice;
1680         me_device->me_device_query_description_device =
1681             me_device_query_description_device;
1682         me_device->me_device_query_info_device = me_device_query_info_device;
1683         me_device->me_device_query_name_device = me_device_query_name_device;
1684         me_device->me_device_query_name_device_driver =
1685             me_device_query_name_device_driver;
1686         me_device->me_device_query_number_subdevices =
1687             me_device_query_number_subdevices;
1688         me_device->me_device_query_number_channels =
1689             me_device_query_number_channels;
1690         me_device->me_device_query_number_ranges =
1691             me_device_query_number_ranges;
1692         me_device->me_device_query_range_by_min_max =
1693             me_device_query_range_by_min_max;
1694         me_device->me_device_query_range_info = me_device_query_range_info;
1695         me_device->me_device_query_subdevice_by_type =
1696             me_device_query_subdevice_by_type;
1697         me_device->me_device_query_subdevice_type =
1698             me_device_query_subdevice_type;
1699         me_device->me_device_query_subdevice_caps =
1700             me_device_query_subdevice_caps;
1701         me_device->me_device_query_subdevice_caps_args =
1702             me_device_query_subdevice_caps_args;
1703         me_device->me_device_query_timer = me_device_query_timer;
1704         me_device->me_device_query_version_device_driver =
1705             me_device_query_version_device_driver;
1706         me_device->me_device_config_load = me_device_config_load;
1707         me_device->me_device_destructor = me_device_destructor;
1708
1709         return 0;
1710
1711       ERROR_0:
1712         me_dlock_deinit(&me_device->dlock);
1713
1714       ERROR_1:
1715         pci_release_regions(pci_device);
1716
1717       ERROR_2:
1718         pci_disable_device(pci_device);
1719
1720         return 1;
1721 }
1722
1723 void me_device_deinit(me_device_t * me_device)
1724 {
1725         PDEBUG("executed.\n");
1726
1727         me_slist_deinit(&me_device->slist);
1728         me_dlock_deinit(&me_device->dlock);
1729
1730         if (me_device->bus_type == ME_BUS_TYPE_PCI) {
1731                 pci_release_regions(me_device->info.pci.pci_device);
1732                 pci_disable_device(me_device->info.pci.pci_device);
1733         }
1734 /*
1735         else
1736         {
1737                 // Must be an USB device.
1738         }
1739 */
1740 }