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