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