drivers/cdrom/gscd.c

   1 #define GSCD_VERSION "0.4a Oliver Raupach <raupach@nwfs1.rz.fh-hannover.de>"
   2
   3 /*
   4         linux/drivers/block/gscd.c - GoldStar R420 CDROM driver
   5
   6         Copyright (C) 1995  Oliver Raupach <raupach@nwfs1.rz.fh-hannover.de>
   7         based upon pre-works by   Eberhard Moenkeberg <emoenke@gwdg.de>
   8
   9
  10         For all kind of other information about the GoldStar CDROM
  11         and this Linux device driver I installed a WWW-URL:
  12         http://linux.rz.fh-hannover.de/~raupach
  13
  14
  15              If you are the editor of a Linux CD, you should
  16              enable gscd.c within your boot floppy kernel and
  17              send me one of your CDs for free.
  18
  19
  20         --------------------------------------------------------------------
  21         This program is free software; you can redistribute it and/or modify
  22         it under the terms of the GNU General Public License as published by
  23         the Free Software Foundation; either version 2, or (at your option)
  24         any later version.
  25
  26         This program is distributed in the hope that it will be useful,
  27         but WITHOUT ANY WARRANTY; without even the implied warranty of
  28         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29         GNU General Public License for more details.
  30
  31         You should have received a copy of the GNU General Public License
  32         along with this program; if not, write to the Free Software
  33         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  34
  35 */
  36
  37 /* These settings are for various debug-level. Leave they untouched ... */
  38 #define  NO_GSCD_DEBUG
  39 #define  NO_IOCTL_DEBUG
  40 #define  NO_MODULE_DEBUG
  41 #define  NO_FUTURE_WORK
  42 /*------------------------*/
  43
  44 #include <linux/module.h>
  45
  46 #include <linux/malloc.h>
  47 #include <linux/errno.h>
  48 #include <linux/signal.h>
  49 #include <linux/sched.h>
  50 #include <linux/timer.h>
  51 #include <linux/fs.h>
  52 #include <linux/mm.h>
  53 #include <linux/kernel.h>
  54 #include <linux/cdrom.h>
  55 #include <linux/ioport.h>
  56 #include <linux/major.h>
  57 #include <linux/string.h>
  58 #include <linux/init.h>
  59
  60 #include <asm/system.h>
  61 #include <asm/io.h>
  62 #include <asm/uaccess.h>
  63
  64 #define MAJOR_NR GOLDSTAR_CDROM_MAJOR
  65 #include <linux/blk.h>
  66 #define gscd_port gscd /* for compatible parameter passing with "insmod" */
  67 #include "gscd.h"
  68
  69
  70 static int gscdPresent            = 0;
  71
  72 static unsigned char gscd_buf[2048];    /* buffer for block size conversion */
  73 static int   gscd_bn              = -1;
  74 static short gscd_port            = GSCD_BASE_ADDR;
  75 MODULE_PARM(gscd, "h");
  76
  77 /* Kommt spaeter vielleicht noch mal dran ...
  78  *    static struct wait_queue *gscd_waitq = NULL;
  79  */
  80
  81 static void gscd_transfer         (void);
  82 static void gscd_read_cmd         (void);
  83 static void gscd_hsg2msf          (long hsg, struct msf *msf);
  84 static void gscd_bin2bcd          (unsigned char *p);
  85
  86 /* Schnittstellen zum Kern/FS */
  87
  88 static void do_gscd_request       (void);
  89 static int  gscd_ioctl            (struct inode *, struct file *, unsigned int, unsigned long);
  90 static int  gscd_open             (struct inode *, struct file *);
  91 static int  gscd_release          (struct inode *, struct file *);
  92 static int  check_gscd_med_chg    (kdev_t);
  93
  94 /*      GoldStar Funktionen    */
  95
  96 static void cc_Reset             (void);
  97 static int  wait_drv_ready       (void);
  98 static int  find_drives          (void);
  99 static void cmd_out              (int, char *, char *, int);
 100 static void cmd_status           (void);
 101 static void cc_Ident             (char *);
 102 static void cc_SetSpeed          (void);
 103 static void init_cd_drive        (int);
 104
 105 static int  get_status           (void);
 106 static void clear_Audio          (void);
 107 static void cc_invalidate        (void);
 108
 109 /* some things for the next version */
 110 #ifdef FUTURE_WORK
 111 static void update_state          (void);
 112 static long gscd_msf2hsg          (struct msf *mp);
 113 static int  gscd_bcd2bin          (unsigned char bcd);
 114 #endif
 115
 116 /*    common GoldStar Initialization    */
 117
 118 static int my_gscd_init (void);
 119
 120
 121 /*      lo-level cmd-Funktionen    */
 122
 123 static void cmd_info_in          ( char *, int );
 124 static void cmd_end              ( void );
 125 static void cmd_read_b           ( char *, int, int );
 126 static void cmd_read_w           ( char *, int, int );
 127 static int  cmd_unit_alive       ( void );
 128 static void cmd_write_cmd        ( char * );
 129
 130
 131 /*      GoldStar Variablen     */
 132
 133 static int  curr_drv_state;
 134 static int  drv_states[]       = {0,0,0,0,0,0,0,0};
 135 static int  drv_mode;
 136 static int  disk_state;
 137 static int  speed;
 138 static int  ndrives;
 139
 140 static unsigned char drv_num_read;
 141 static unsigned char f_dsk_valid;
 142 static unsigned char current_drive;
 143 static unsigned char f_drv_ok;
 144
 145
 146 static char f_AudioPlay;
 147 static char f_AudioPause;
 148 static int  AudioStart_m;
 149 static int  AudioStart_f;
 150 static int  AudioEnd_m;
 151 static int  AudioEnd_f;
 152
 153
 154 static struct file_operations gscd_fops = {
 155         NULL,                   /* lseek - default */
 156         block_read,             /* read - general block-dev read */
 157         block_write,            /* write - general block-dev write */
 158         NULL,                   /* readdir - bad */
 159         NULL,                   /* poll */
 160         gscd_ioctl,             /* ioctl */
 161         NULL,                   /* mmap */
 162         gscd_open,              /* open */
 163         NULL,                   /* flush */
 164         gscd_release,           /* release */
 165         NULL,                   /* fsync */
 166         NULL,                   /* fasync*/
 167         check_gscd_med_chg,     /* media change */
 168         NULL                    /* revalidate */
 169 };
 170
 171 /*
 172  * Checking if the media has been changed
 173  * (not yet implemented)
 174  */
 175 static int check_gscd_med_chg (kdev_t full_dev)
 176 {
 177    int target;
 178
 179
 180    target = MINOR(full_dev);
 181
 182    if (target > 0)
 183    {
 184       printk("GSCD: GoldStar CD-ROM request error: invalid device.\n");
 185       return 0;
 186    }
 187
 188    #ifdef GSCD_DEBUG
 189    printk ("gscd: check_med_change\n");
 190    #endif
 191
 192   return 0;
 193 }
 194
 195
 196 __initfunc(void gscd_setup (char *str, int *ints))
 197 {
 198   if (ints[0] > 0)
 199   {
 200      gscd_port = ints[1];
 201   }
 202 }
 203
 204
 205 static int gscd_ioctl (struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
 206 {
 207 unsigned char to_do[10];
 208 unsigned char dummy;
 209
 210
 211     switch (cmd)
 212     {
 213        case CDROMSTART:     /* Spin up the drive */
 214                 /* Don't think we can do this.  Even if we could,
 215                  * I think the drive times out and stops after a while
 216                  * anyway.  For now, ignore it.
 217                  */
 218             return 0;
 219
 220        case CDROMRESUME:   /* keine Ahnung was das ist */
 221             return 0;
 222
 223
 224        case CDROMEJECT:
 225             cmd_status ();
 226             to_do[0] = CMD_TRAY_CTL;
 227             cmd_out (TYPE_INFO, (char *)&to_do, (char *)&dummy, 0);
 228
 229             return 0;
 230
 231        default:
 232             return -EINVAL;
 233     }
 234
 235 }
 236
 237
 238 /*
 239  * Take care of the different block sizes between cdrom and Linux.
 240  * When Linux gets variable block sizes this will probably go away.
 241  */
 242
 243 static void gscd_transfer (void)
 244 {
 245 long offs;
 246
 247         while (CURRENT -> nr_sectors > 0 && gscd_bn == CURRENT -> sector / 4)
 248         {
 249                 offs = (CURRENT -> sector & 3) * 512;
 250                 memcpy(CURRENT -> buffer, gscd_buf + offs, 512);
 251                 CURRENT -> nr_sectors--;
 252                 CURRENT -> sector++;
 253                 CURRENT -> buffer += 512;
 254         }
 255 }
 256
 257
 258 /*
 259  * I/O request routine called from Linux kernel.
 260  */
 261
 262 static void do_gscd_request (void)
 263 {
 264 unsigned int block,dev;
 265 unsigned int nsect;
 266
 267 repeat:
 268         if (!(CURRENT) || CURRENT->rq_status == RQ_INACTIVE) return;
 269         INIT_REQUEST;
 270         dev = MINOR(CURRENT->rq_dev);
 271         block = CURRENT->sector;
 272         nsect = CURRENT->nr_sectors;
 273
 274         if (CURRENT == NULL || CURRENT -> sector == -1)
 275                 return;
 276
 277         if (CURRENT -> cmd != READ)
 278         {
 279                 printk("GSCD: bad cmd %d\n", CURRENT -> cmd);
 280                 end_request(0);
 281                 goto repeat;
 282         }
 283
 284         if (MINOR(CURRENT -> rq_dev) != 0)
 285         {
 286                 printk("GSCD: this version supports only one device\n");
 287                 end_request(0);
 288                 goto repeat;
 289         }
 290
 291         gscd_transfer();
 292
 293         /* if we satisfied the request from the buffer, we're done. */
 294
 295         if (CURRENT -> nr_sectors == 0)
 296         {
 297                 end_request(1);
 298                 goto repeat;
 299         }
 300
 301 #ifdef GSCD_DEBUG
 302         printk ("GSCD: dev %d, block %d, nsect %d\n", dev, block, nsect );
 303 #endif
 304
 305         gscd_read_cmd ();
 306 }
 307
 308
 309
 310 /*
 311  * Check the result of the set-mode command.  On success, send the
 312  * read-data command.
 313  */
 314
 315 static void
 316 gscd_read_cmd (void)
 317 {
 318 long   block;
 319 struct gscd_Play_msf gscdcmd;
 320 char   cmd[] = { CMD_READ, 0x80, 0,0,0, 0,1 }; /* cmd mode M-S-F secth sectl */
 321
 322
 323
 324         cmd_status ();
 325         if ( disk_state & (ST_NO_DISK | ST_DOOR_OPEN) )
 326         {
 327            printk ( "GSCD: no disk or door open\n" );
 328            end_request (0);
 329         }
 330         else
 331         {
 332            if ( disk_state & ST_INVALID )
 333            {
 334               printk ( "GSCD: disk invalid\n" );
 335               end_request (0);
 336            }
 337            else
 338            {
 339               gscd_bn = -1;             /* purge our buffer */
 340               block = CURRENT -> sector / 4;
 341               gscd_hsg2msf(block, &gscdcmd.start);      /* cvt to msf format */
 342
 343               cmd[2] = gscdcmd.start.min;
 344               cmd[3] = gscdcmd.start.sec;
 345               cmd[4] = gscdcmd.start.frame;
 346
 347 #ifdef GSCD_DEBUG
 348               printk ("GSCD: read msf %d:%d:%d\n", cmd[2], cmd[3], cmd[4] );
 349 #endif
 350               cmd_out ( TYPE_DATA, (char *)&cmd, (char *)&gscd_buf[0], 1 );
 351
 352               gscd_bn = CURRENT -> sector / 4;
 353               gscd_transfer();
 354               end_request(1);
 355            }
 356         }
 357         SET_TIMER(do_gscd_request, 1);
 358 }
 359
 360
 361 /*
 362  * Open the device special file.  Check that a disk is in.
 363  */
 364
 365 static int gscd_open (struct inode *ip, struct file *fp)
 366 {
 367 int   st;
 368
 369 #ifdef GSCD_DEBUG
 370 printk ( "GSCD: open\n" );
 371 #endif
 372
 373         if (gscdPresent == 0)
 374                 return -ENXIO;                  /* no hardware */
 375
 376         MOD_INC_USE_COUNT;
 377
 378         get_status ();
 379         st = disk_state & (ST_NO_DISK | ST_DOOR_OPEN);
 380         if ( st )
 381         {
 382            printk ( "GSCD: no disk or door open\n" );
 383            MOD_DEC_USE_COUNT;
 384            return -ENXIO;
 385         }
 386
 387 /*      if (updateToc() < 0)
 388                 return -EIO;
 389 */
 390
 391         return 0;
 392 }
 393
 394
 395 /*
 396  * On close, we flush all gscd blocks from the buffer cache.
 397  */
 398
 399 static int gscd_release (struct inode * inode, struct file * file)
 400 {
 401
 402 #ifdef GSCD_DEBUG
 403 printk ( "GSCD: release\n" );
 404 #endif
 405
 406         gscd_bn = -1;
 407         sync_dev(inode->i_rdev);
 408         invalidate_buffers(inode -> i_rdev);
 409
 410         MOD_DEC_USE_COUNT;
 411         return 0;
 412 }
 413
 414
 415 int get_status (void)
 416 {
 417 int  status;
 418
 419     cmd_status ();
 420     status = disk_state & (ST_x08 | ST_x04 | ST_INVALID | ST_x01);
 421
 422     if ( status == (ST_x08 | ST_x04 | ST_INVALID | ST_x01) )
 423     {
 424        cc_invalidate ();
 425        return 1;
 426     }
 427     else
 428     {
 429        return 0;
 430     }
 431 }
 432
 433
 434 void cc_invalidate (void)
 435 {
 436    drv_num_read  = 0xFF;
 437    f_dsk_valid   = 0xFF;
 438    current_drive = 0xFF;
 439    f_drv_ok      = 0xFF;
 440
 441    clear_Audio ();
 442
 443 }
 444
 445 void clear_Audio (void)
 446 {
 447
 448    f_AudioPlay = 0;
 449    f_AudioPause = 0;
 450    AudioStart_m = 0;
 451    AudioStart_f = 0;
 452    AudioEnd_m   = 0;
 453    AudioEnd_f   = 0;
 454
 455 }
 456
 457 /*
 458  *   waiting ?
 459  */
 460
 461 int wait_drv_ready (void)
 462 {
 463 int found, read;
 464
 465    do
 466    {
 467        found = inb ( GSCDPORT(0) );
 468        found &= 0x0f;
 469        read  = inb ( GSCDPORT(0) );
 470        read  &= 0x0f;
 471    } while ( read != found );
 472
 473 #ifdef GSCD_DEBUG
 474 printk ( "Wait for: %d\n", read );
 475 #endif
 476
 477    return read;
 478 }
 479
 480 void cc_Ident (char * respons)
 481 {
 482 char to_do [] = {CMD_IDENT, 0, 0};
 483
 484     cmd_out (TYPE_INFO, (char *)&to_do, (char *)respons, (int)0x1E );
 485
 486 }
 487
 488 void cc_SetSpeed (void)
 489 {
 490 char to_do [] = {CMD_SETSPEED, 0, 0};
 491 char dummy;
 492
 493     if ( speed > 0 )
 494     {
 495        to_do[1] = speed & 0x0F;
 496        cmd_out (TYPE_INFO, (char *)&to_do, (char *)&dummy, 0);
 497     }
 498 }
 499
 500
 501 void cc_Reset (void)
 502 {
 503 char to_do [] = {CMD_RESET, 0};
 504 char dummy;
 505
 506    cmd_out (TYPE_INFO, (char *)&to_do, (char *)&dummy, 0);
 507 }
 508
 509
 510
 511 void cmd_status (void)
 512 {
 513 char to_do [] = {CMD_STATUS, 0};
 514 char dummy;
 515
 516    cmd_out (TYPE_INFO, (char *)&to_do, (char *)&dummy, 0);
 517
 518 #ifdef GSCD_DEBUG
 519 printk ("GSCD: Status: %d\n", disk_state );
 520 #endif
 521
 522 }
 523
 524 void cmd_out ( int cmd_type, char * cmd, char * respo_buf, int respo_count )
 525 {
 526 int        result;
 527
 528
 529        result = wait_drv_ready ();
 530        if ( result != drv_mode )
 531        {
 532        unsigned long test_loops = 0xFFFF;
 533        int           i,dummy;
 534
 535           outb ( curr_drv_state, GSCDPORT(0));
 536
 537           /* LOCLOOP_170 */
 538           do
 539           {
 540              result = wait_drv_ready ();
 541              test_loops--;
 542           } while ( (result != drv_mode) && (test_loops > 0) );
 543
 544           if ( result != drv_mode )
 545           {
 546              disk_state = ST_x08 | ST_x04 | ST_INVALID;
 547              return;
 548           }
 549
 550           /* ...and waiting */
 551           for ( i=1,dummy=1 ; i<0xFFFF ; i++ )
 552           {
 553              dummy *= i;
 554           }
 555        }
 556
 557        /* LOC_172 */
 558        /* check the unit */
 559        /* and wake it up */
 560        if ( cmd_unit_alive () != 0x08 )
 561        {
 562           /* LOC_174 */
 563           /* game over for this unit */
 564           disk_state = ST_x08 | ST_x04 | ST_INVALID;
 565           return;
 566        }
 567
 568        /* LOC_176 */
 569        #ifdef GSCD_DEBUG
 570         printk ("LOC_176 ");
 571        #endif
 572        if ( drv_mode == 0x09 )
 573        {
 574           /* magic... */
 575           printk ("GSCD: magic ...\n");
 576           outb ( result, GSCDPORT(2));
 577        }
 578
 579        /* write the command to the drive */
 580        cmd_write_cmd (cmd);
 581
 582        /* LOC_178 */
 583        for (;;)
 584        {
 585           result = wait_drv_ready ();
 586           if ( result != drv_mode )
 587           {
 588              /* LOC_179 */
 589              if ( result == 0x04 )                  /* Mode 4 */
 590              {
 591                 /* LOC_205 */
 592                 #ifdef GSCD_DEBUG
 593                 printk ("LOC_205 ");
 594                 #endif
 595                 disk_state = inb ( GSCDPORT (2));
 596
 597                 do
 598                 {
 599                    result = wait_drv_ready ();
 600                 } while ( result != drv_mode );
 601                 return;
 602
 603              }
 604              else
 605              {
 606                 if ( result == 0x06 )               /* Mode 6 */
 607                 {
 608                    /* LOC_181 */
 609                    #ifdef GSCD_DEBUG
 610                     printk ("LOC_181 ");
 611                    #endif
 612
 613                    if (cmd_type == TYPE_DATA)
 614                    {
 615                       /* read data */
 616                       /* LOC_184 */
 617                       if ( drv_mode == 9 )
 618                       {
 619                          /* read the data to the buffer (word) */
 620
 621                          /* (*(cmd+1))?(CD_FRAMESIZE/2):(CD_FRAMESIZE_RAW/2) */
 622                          cmd_read_w ( respo_buf, respo_count, CD_FRAMESIZE/2 );
 623                          return;
 624                       }
 625                       else
 626                       {
 627                          /* read the data to the buffer (byte) */
 628
 629                          /* (*(cmd+1))?(CD_FRAMESIZE):(CD_FRAMESIZE_RAW)    */
 630                          cmd_read_b ( respo_buf, respo_count, CD_FRAMESIZE );
 631                          return;
 632                       }
 633                    }
 634                    else
 635                    {
 636                       /* read the info to the buffer */
 637                       cmd_info_in ( respo_buf, respo_count );
 638                       return;
 639                    }
 640
 641                    return;
 642                 }
 643              }
 644
 645           }
 646           else
 647           {
 648              disk_state = ST_x08 | ST_x04 | ST_INVALID;
 649              return;
 650           }
 651        } /* for (;;) */
 652
 653
 654 #ifdef GSCD_DEBUG
 655 printk ("\n");
 656 #endif
 657 }
 658
 659
 660 static void cmd_write_cmd ( char *pstr )
 661 {
 662 int  i,j;
 663
 664     /* LOC_177 */
 665     #ifdef GSCD_DEBUG
 666      printk ("LOC_177 ");
 667     #endif
 668
 669     /* calculate the number of parameter */
 670     j = *pstr & 0x0F;
 671
 672     /* shift it out */
 673     for ( i=0 ; i<j ; i++ )
 674     {
 675        outb ( *pstr, GSCDPORT(2) );
 676        pstr++;
 677     }
 678 }
 679
 680
 681 static int cmd_unit_alive ( void )
 682 {
 683 int            result;
 684 unsigned long  max_test_loops;
 685
 686
 687     /* LOC_172 */
 688     #ifdef GSCD_DEBUG
 689      printk ("LOC_172 ");
 690     #endif
 691
 692     outb ( curr_drv_state, GSCDPORT(0));
 693     max_test_loops = 0xFFFF;
 694
 695     do
 696     {
 697        result = wait_drv_ready ();
 698        max_test_loops--;
 699     } while ( (result != 0x08) && (max_test_loops > 0) );
 700
 701     return result;
 702 }
 703
 704
 705 static void cmd_info_in ( char *pb, int count )
 706 {
 707 int   result;
 708 char  read;
 709
 710
 711         /* read info */
 712         /* LOC_182 */
 713         #ifdef GSCD_DEBUG
 714          printk ("LOC_182 ");
 715         #endif
 716
 717         do
 718         {
 719            read = inb (GSCDPORT(2));
 720            if ( count > 0 )
 721            {
 722               *pb = read;
 723               pb++;
 724               count--;
 725            }
 726
 727            /* LOC_183 */
 728            do
 729            {
 730               result = wait_drv_ready ();
 731            } while ( result == 0x0E );
 732         } while ( result == 6 );
 733
 734         cmd_end ();
 735         return;
 736 }
 737
 738
 739 static void cmd_read_b ( char *pb, int count, int size )
 740 {
 741 int  result;
 742 int  i;
 743
 744
 745        /* LOC_188 */
 746        /* LOC_189 */
 747        #ifdef GSCD_DEBUG
 748         printk ("LOC_189 ");
 749        #endif
 750
 751        do
 752        {
 753           do
 754           {
 755              result = wait_drv_ready ();
 756           } while ( result != 6 || result == 0x0E );
 757
 758           if ( result != 6 )
 759           {
 760              cmd_end ();
 761              return;
 762           }
 763
 764           #ifdef GSCD_DEBUG
 765            printk ("LOC_191 ");
 766           #endif
 767
 768           for ( i=0 ; i< size ; i++ )
 769           {
 770              *pb = inb (GSCDPORT(2));
 771              pb++;
 772           }
 773           count--;
 774        } while ( count > 0 );
 775
 776        cmd_end ();
 777        return;
 778 }
 779
 780
 781 static void cmd_end (void)
 782 {
 783 int   result;
 784
 785
 786       /* LOC_204 */
 787       #ifdef GSCD_DEBUG
 788        printk ("LOC_204 ");
 789       #endif
 790
 791       do
 792       {
 793          result = wait_drv_ready ();
 794          if ( result == drv_mode )
 795          {
 796             return;
 797          }
 798       } while ( result != 4 );
 799
 800       /* LOC_205 */
 801       #ifdef GSCD_DEBUG
 802        printk ("LOC_205 ");
 803       #endif
 804
 805       disk_state = inb ( GSCDPORT (2));
 806
 807       do
 808       {
 809          result = wait_drv_ready ();
 810       } while ( result != drv_mode );
 811       return;
 812
 813 }
 814
 815
 816 static void cmd_read_w ( char *pb, int count, int size )
 817 {
 818 int  result;
 819 int  i;
 820
 821
 822     #ifdef GSCD_DEBUG
 823      printk ("LOC_185 ");
 824     #endif
 825
 826     do
 827     {
 828        /* LOC_185 */
 829        do
 830        {
 831           result = wait_drv_ready ();
 832        } while ( result != 6 || result == 0x0E );
 833
 834        if ( result != 6 )
 835        {
 836           cmd_end ();
 837           return;
 838        }
 839
 840        for ( i=0 ; i<size ; i++ )
 841        {
 842            /* na, hier muss ich noch mal drueber nachdenken */
 843            *pb = inw(GSCDPORT(2));
 844            pb++;
 845         }
 846         count--;
 847      } while ( count > 0 );
 848
 849      cmd_end ();
 850      return;
 851 }
 852
 853 __initfunc(int find_drives (void))
 854 {
 855 int *pdrv;
 856 int drvnum;
 857 int subdrv;
 858 int i;
 859
 860     speed           = 0;
 861     pdrv            = (int *)&drv_states;
 862     curr_drv_state  = 0xFE;
 863     subdrv          = 0;
 864     drvnum          = 0;
 865
 866     for ( i=0 ; i<8 ; i++ )
 867     {
 868        subdrv++;
 869        cmd_status ();
 870        disk_state &= ST_x08 | ST_x04 | ST_INVALID | ST_x01;
 871        if ( disk_state != (ST_x08 | ST_x04 | ST_INVALID) )
 872        {
 873           /* LOC_240 */
 874           *pdrv = curr_drv_state;
 875           init_cd_drive (drvnum);
 876           pdrv++;
 877           drvnum++;
 878        }
 879        else
 880        {
 881           if ( subdrv < 2 )
 882           {
 883              continue;
 884           }
 885           else
 886           {
 887              subdrv = 0;
 888           }
 889        }
 890
 891 /*       curr_drv_state<<1;         <-- das geht irgendwie nicht */
 892 /* muss heissen:    curr_drv_state <<= 1; (ist ja Wert-Zuweisung) */
 893          curr_drv_state *= 2;
 894          curr_drv_state |= 1;
 895 #ifdef GSCD_DEBUG
 896          printk ("DriveState: %d\n", curr_drv_state );
 897 #endif
 898     }
 899
 900     ndrives = drvnum;
 901     return drvnum;
 902 }
 903
 904 __initfunc(void init_cd_drive ( int num ))
 905 {
 906 char resp [50];
 907 int  i;
 908
 909    printk ("GSCD: init unit %d\n", num );
 910    cc_Ident ((char *)&resp);
 911
 912    printk ("GSCD: identification: ");
 913    for ( i=0 ; i<0x1E; i++ )
 914    {
 915       printk ( "%c", resp[i] );
 916    }
 917    printk ("\n");
 918
 919    cc_SetSpeed ();
 920
 921 }
 922
 923 #ifdef FUTURE_WORK
 924 /* return_done */
 925 static void update_state ( void )
 926 {
 927 unsigned int AX;
 928
 929
 930     if ( (disk_state & (ST_x08 | ST_x04 | ST_INVALID | ST_x01)) == 0 )
 931     {
 932        if ( disk_state == (ST_x08 | ST_x04 | ST_INVALID))
 933        {
 934           AX = ST_INVALID;
 935        }
 936
 937        if ( (disk_state & (ST_x08 | ST_x04 | ST_INVALID | ST_x01)) == 0 )
 938        {
 939           invalidate ();
 940           f_drv_ok = 0;
 941        }
 942
 943        AX |= 0x8000;
 944     }
 945
 946     if ( disk_state & ST_PLAYING )
 947     {
 948        AX |= 0x200;
 949     }
 950
 951     AX |= 0x100;
 952     /* pkt_esbx = AX; */
 953
 954     disk_state = 0;
 955
 956 }
 957 #endif
 958
 959 #ifdef MODULE
 960 /* Init for the Module-Version */
 961 int init_module (void)
 962 {
 963 long err;
 964
 965
 966      /* call the GoldStar-init */
 967      err = my_gscd_init ( );
 968
 969      if ( err < 0 )
 970      {
 971          return err;
 972      }
 973      else
 974      {
 975         printk (KERN_INFO "Happy GoldStar !\n" );
 976         return 0;
 977      }
 978 }
 979
 980 void cleanup_module (void)
 981 {
 982
 983    if ((unregister_blkdev(MAJOR_NR, "gscd" ) == -EINVAL))
 984    {
 985       printk("What's that: can't unregister GoldStar-module\n" );
 986       return;
 987    }
 988
 989    release_region (gscd_port,4);
 990    printk(KERN_INFO "GoldStar-module released.\n" );
 991 }
 992 #endif
 993
 994
 995 /* Test for presence of drive and initialize it.  Called only at boot time. */
 996 __initfunc(int gscd_init (void))
 997 {
 998    return my_gscd_init ();
 999 }
1000
1001
1002 /* This is the common initialisation for the GoldStar drive. */
1003 /* It is called at boot time AND for module init.           */
1004 __initfunc(int my_gscd_init (void))
1005 {
1006 int i;
1007 int result;
1008
1009         printk (KERN_INFO "GSCD: version %s\n", GSCD_VERSION);
1010         printk (KERN_INFO "GSCD: Trying to detect a Goldstar R420 CD-ROM drive at 0x%X.\n", gscd_port);
1011
1012         if (check_region(gscd_port, 4))
1013         {
1014           printk("GSCD: Init failed, I/O port (%X) already in use.\n", gscd_port);
1015           return -EIO;
1016         }
1017
1018
1019         /* check for card */
1020         result = wait_drv_ready ();
1021         if ( result == 0x09 )
1022         {
1023            printk ("GSCD: DMA kann ich noch nicht!\n" );
1024            return -EIO;
1025         }
1026
1027         if ( result == 0x0b )
1028         {
1029            drv_mode = result;
1030            i = find_drives ();
1031            if ( i == 0 )
1032            {
1033               printk ( "GSCD: GoldStar CD-ROM Drive is not found.\n" );
1034               return -EIO;
1035            }
1036         }
1037
1038         if ( (result != 0x0b) && (result != 0x09) )
1039         {
1040               printk ("GSCD: GoldStar Interface Adapter does not exist or H/W error\n" );
1041               return -EIO;
1042         }
1043
1044         /* reset all drives */
1045         i = 0;
1046         while ( drv_states[i] != 0 )
1047         {
1048            curr_drv_state = drv_states[i];
1049            printk (KERN_INFO "GSCD: Reset unit %d ... ",i );
1050            cc_Reset ();
1051            printk ( "done\n" );
1052            i++;
1053         }
1054
1055         if (register_blkdev(MAJOR_NR, "gscd", &gscd_fops) != 0)
1056         {
1057                 printk("GSCD: Unable to get major %d for GoldStar CD-ROM\n",
1058                        MAJOR_NR);
1059                 return -EIO;
1060         }
1061
1062         blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
1063         read_ahead[MAJOR_NR] = 4;
1064
1065         disk_state = 0;
1066         gscdPresent = 1;
1067
1068         request_region(gscd_port, 4, "gscd");
1069
1070         printk (KERN_INFO "GSCD: GoldStar CD-ROM Drive found.\n" );
1071         return 0;
1072 }
1073
1074 static void gscd_hsg2msf (long hsg, struct msf *msf)
1075 {
1076         hsg += CD_MSF_OFFSET;
1077         msf -> min = hsg / (CD_FRAMES*CD_SECS);
1078         hsg %= CD_FRAMES*CD_SECS;
1079         msf -> sec = hsg / CD_FRAMES;
1080         msf -> frame = hsg % CD_FRAMES;
1081
1082         gscd_bin2bcd(&msf -> min);              /* convert to BCD */
1083         gscd_bin2bcd(&msf -> sec);
1084         gscd_bin2bcd(&msf -> frame);
1085 }
1086
1087
1088 static void gscd_bin2bcd (unsigned char *p)
1089 {
1090 int u, t;
1091
1092         u = *p % 10;
1093         t = *p / 10;
1094         *p = u | (t << 4);
1095 }
1096
1097
1098 #ifdef FUTURE_WORK
1099 static long gscd_msf2hsg (struct msf *mp)
1100 {
1101         return gscd_bcd2bin(mp -> frame)
1102                 + gscd_bcd2bin(mp -> sec) * CD_FRAMES
1103                 + gscd_bcd2bin(mp -> min) * CD_FRAMES * CD_SECS
1104                 - CD_MSF_OFFSET;
1105 }
1106
1107 static int gscd_bcd2bin (unsigned char bcd)
1108 {
1109         return (bcd >> 4) * 10 + (bcd & 0xF);
1110 }
1111 #endif
1112
1113