开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
gscd.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：20k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

gscd.c：源码内容
  1. #define GSCD_VERSION "0.4a Oliver Raupach <raupach@nwfs1.rz.fh-hannover.de>"
  3. /*
  4. linux/drivers/block/gscd.c - GoldStar R420 CDROM driver
  6.         Copyright (C) 1995  Oliver Raupach <raupach@nwfs1.rz.fh-hannover.de>
  7.         based upon pre-works by   Eberhard Moenkeberg <emoenke@gwdg.de>
  8.         
  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        
  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.
  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.
  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.
  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.
  35. --------------------------------------------------------------------
  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>
  42. */
  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. /*------------------------*/
  51. #include <linux/module.h>
  53. #include <linux/slab.h>
  54. #include <linux/errno.h>
  55. #include <linux/signal.h>
  56. #include <linux/sched.h>
  57. #include <linux/timer.h>
  58. #include <linux/fs.h>
  59. #include <linux/mm.h>
  60. #include <linux/kernel.h>
  61. #include <linux/cdrom.h>
  62. #include <linux/ioport.h>
  63. #include <linux/major.h>
  64. #include <linux/string.h>
  65. #include <linux/init.h>
  66. #include <linux/devfs_fs_kernel.h>
  68. #include <asm/system.h>
  69. #include <asm/io.h>
  70. #include <asm/uaccess.h>
  72. #define MAJOR_NR GOLDSTAR_CDROM_MAJOR
  73. #include <linux/blk.h>
  74. #define gscd_port gscd /* for compatible parameter passing with "insmod" */
  75. #include "gscd.h"
  77. static int gscd_blocksizes[1] = { 512 };
  79. static int gscdPresent = 0;
  81. static unsigned char gscd_buf[2048]; /* buffer for block size conversion */
  82. static int gscd_bn = -1;
  83. static short gscd_port = GSCD_BASE_ADDR;
  84. MODULE_PARM(gscd, "h");
  86. /* Kommt spaeter vielleicht noch mal dran ...
  87.  *    static DECLARE_WAIT_QUEUE_HEAD(gscd_waitq);
  88.  */
  90. static void gscd_transfer(void);
  91. static void gscd_read_cmd(void);
  92. static void gscd_hsg2msf(long hsg, struct msf *msf);
  93. static void gscd_bin2bcd(unsigned char *p);
  95. /* Schnittstellen zum Kern/FS */
  97. static void do_gscd_request(request_queue_t *);
  98. static void __do_gscd_request(unsigned long dummy);
  99. static int gscd_ioctl(struct inode *, struct file *, unsigned int,
  100.       unsigned long);
  101. static int gscd_open(struct inode *, struct file *);
  102. static int gscd_release(struct inode *, struct file *);
  103. static int check_gscd_med_chg(kdev_t);
  105. /*      GoldStar Funktionen    */
  107. static void cc_Reset(void);
  108. static int wait_drv_ready(void);
  109. static int find_drives(void);
  110. static void cmd_out(int, char *, char *, int);
  111. static void cmd_status(void);
  112. static void cc_Ident(char *);
  113. static void cc_SetSpeed(void);
  114. static void init_cd_drive(int);
  116. static int get_status(void);
  117. static void clear_Audio(void);
  118. static void cc_invalidate(void);
  120. /* some things for the next version */
  121. #ifdef FUTURE_WORK
  122. static void update_state(void);
  123. static long gscd_msf2hsg(struct msf *mp);
  124. static int gscd_bcd2bin(unsigned char bcd);
  125. #endif
  127. /*    common GoldStar Initialization    */
  129. static int my_gscd_init(void);
  132. /*      lo-level cmd-Funktionen    */
  134. static void cmd_info_in(char *, int);
  135. static void cmd_end(void);
  136. static void cmd_read_b(char *, int, int);
  137. static void cmd_read_w(char *, int, int);
  138. static int cmd_unit_alive(void);
  139. static void cmd_write_cmd(char *);
  142. /*      GoldStar Variablen     */
  144. static int curr_drv_state;
  145. static int drv_states[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
  146. static int drv_mode;
  147. static int disk_state;
  148. static int speed;
  149. static int ndrives;
  151. static unsigned char drv_num_read;
  152. static unsigned char f_dsk_valid;
  153. static unsigned char current_drive;
  154. static unsigned char f_drv_ok;
  157. static char f_AudioPlay;
  158. static char f_AudioPause;
  159. static int AudioStart_m;
  160. static int AudioStart_f;
  161. static int AudioEnd_m;
  162. static int AudioEnd_f;
  164. static struct timer_list gscd_timer;
  166. static struct block_device_operations gscd_fops = {
  167. owner:THIS_MODULE,
  168. open:gscd_open,
  169. release:gscd_release,
  170. ioctl:gscd_ioctl,
  171. check_media_change:check_gscd_med_chg,
  172. };
  174. /* 
  175.  * Checking if the media has been changed
  176.  * (not yet implemented)
  177.  */
  178. static int check_gscd_med_chg(kdev_t full_dev)
  179. {
  180. int target;
  183. target = MINOR(full_dev);
  185. if (target > 0) {
  186. printk
  187.     ("GSCD: GoldStar CD-ROM request error: invalid device.n");
  188. return 0;
  189. }
  190. #ifdef GSCD_DEBUG
  191. printk("gscd: check_med_changen");
  192. #endif
  194. return 0;
  195. }
  198. #ifndef MODULE
  199. /* Using new interface for kernel-parameters */
  201. static int __init gscd_setup(char *str)
  202. {
  203. int ints[2];
  204. (void) get_options(str, ARRAY_SIZE(ints), ints);
  206. if (ints[0] > 0) {
  207. gscd_port = ints[1];
  208. }
  209. return 1;
  210. }
  212. __setup("gscd=", gscd_setup);
  214. #endif
  216. static int gscd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
  217.       unsigned long arg)
  218. {
  219. unsigned char to_do[10];
  220. unsigned char dummy;
  223. switch (cmd) {
  224. case CDROMSTART: /* Spin up the drive */
  225. /* Don't think we can do this.  Even if we could,
  226.  * I think the drive times out and stops after a while
  227.  * anyway.  For now, ignore it.
  228.  */
  229. return 0;
  231. case CDROMRESUME: /* keine Ahnung was das ist */
  232. return 0;
  235. case CDROMEJECT:
  236. cmd_status();
  237. to_do[0] = CMD_TRAY_CTL;
  238. cmd_out(TYPE_INFO, (char *) &to_do, (char *) &dummy, 0);
  240. return 0;
  242. default:
  243. return -EINVAL;
  244. }
  246. }
  249. /*
  250.  * Take care of the different block sizes between cdrom and Linux.
  251.  * When Linux gets variable block sizes this will probably go away.
  252.  */
  254. static void gscd_transfer(void)
  255. {
  256. long offs;
  258. while (CURRENT->nr_sectors > 0 && gscd_bn == CURRENT->sector / 4) {
  259. offs = (CURRENT->sector & 3) * 512;
  260. memcpy(CURRENT->buffer, gscd_buf + offs, 512);
  261. CURRENT->nr_sectors--;
  262. CURRENT->sector++;
  263. CURRENT->buffer += 512;
  264. }
  265. }
  268. /*
  269.  * I/O request routine called from Linux kernel.
  270.  */
  272. static void do_gscd_request(request_queue_t * q)
  273. {
  274. __do_gscd_request(0);
  275. }
  277. static void __do_gscd_request(unsigned long dummy)
  278. {
  279. unsigned int block, dev;
  280. unsigned int nsect;
  282.       repeat:
  283. if (QUEUE_EMPTY || CURRENT->rq_status == RQ_INACTIVE)
  284. goto out;
  285. INIT_REQUEST;
  286. dev = MINOR(CURRENT->rq_dev);
  287. block = CURRENT->sector;
  288. nsect = CURRENT->nr_sectors;
  290. if (QUEUE_EMPTY || CURRENT->sector == -1)
  291. goto out;
  293. if (CURRENT->cmd != READ) {
  294. printk("GSCD: bad cmd %dn", CURRENT->cmd);
  295. end_request(0);
  296. goto repeat;
  297. }
  299. if (MINOR(CURRENT->rq_dev) != 0) {
  300. printk("GSCD: this version supports only one devicen");
  301. end_request(0);
  302. goto repeat;
  303. }
  305. gscd_transfer();
  307. /* if we satisfied the request from the buffer, we're done. */
  309. if (CURRENT->nr_sectors == 0) {
  310. end_request(1);
  311. goto repeat;
  312. }
  313. #ifdef GSCD_DEBUG
  314. printk("GSCD: dev %d, block %d, nsect %dn", dev, block, nsect);
  315. #endif
  317. gscd_read_cmd();
  318.       out:
  319. return;
  320. }
  324. /*
  325.  * Check the result of the set-mode command.  On success, send the
  326.  * read-data command.
  327.  */
  329. static void gscd_read_cmd(void)
  330. {
  331. long block;
  332. struct gscd_Play_msf gscdcmd;
  333. char cmd[] = { CMD_READ, 0x80, 0, 0, 0, 0, 1 }; /* cmd mode M-S-F secth sectl */
  337. cmd_status();
  338. if (disk_state & (ST_NO_DISK | ST_DOOR_OPEN)) {
  339. printk("GSCD: no disk or door openn");
  340. end_request(0);
  341. } else {
  342. if (disk_state & ST_INVALID) {
  343. printk("GSCD: disk invalidn");
  344. end_request(0);
  345. } else {
  346. gscd_bn = -1; /* purge our buffer */
  347. block = CURRENT->sector / 4;
  348. gscd_hsg2msf(block, &gscdcmd.start); /* cvt to msf format */
  350. cmd[2] = gscdcmd.start.min;
  351. cmd[3] = gscdcmd.start.sec;
  352. cmd[4] = gscdcmd.start.frame;
  354. #ifdef GSCD_DEBUG
  355. printk("GSCD: read msf %d:%d:%dn", cmd[2], cmd[3],
  356.        cmd[4]);
  357. #endif
  358. cmd_out(TYPE_DATA, (char *) &cmd,
  359. (char *) &gscd_buf[0], 1);
  361. gscd_bn = CURRENT->sector / 4;
  362. gscd_transfer();
  363. end_request(1);
  364. }
  365. }
  366. SET_TIMER(__do_gscd_request, 1);
  367. }
  370. /*
  371.  * Open the device special file.  Check that a disk is in.
  372.  */
  374. static int gscd_open(struct inode *ip, struct file *fp)
  375. {
  376. int st;
  378. #ifdef GSCD_DEBUG
  379. printk("GSCD: openn");
  380. #endif
  382. if (gscdPresent == 0)
  383. return -ENXIO; /* no hardware */
  385. get_status();
  386. st = disk_state & (ST_NO_DISK | ST_DOOR_OPEN);
  387. if (st) {
  388. printk("GSCD: no disk or door openn");
  389. return -ENXIO;
  390. }
  392. /* if (updateToc() < 0)
  393. return -EIO;
  394. */
  396. return 0;
  397. }
  400. /*
  401.  * On close, we flush all gscd blocks from the buffer cache.
  402.  */
  404. static int gscd_release(struct inode *inode, struct file *file)
  405. {
  407. #ifdef GSCD_DEBUG
  408. printk("GSCD: releasen");
  409. #endif
  411. gscd_bn = -1;
  413. return 0;
  414. }
  417. int get_status(void)
  418. {
  419. int status;
  421. cmd_status();
  422. status = disk_state & (ST_x08 | ST_x04 | ST_INVALID | ST_x01);
  424. if (status == (ST_x08 | ST_x04 | ST_INVALID | ST_x01)) {
  425. cc_invalidate();
  426. return 1;
  427. } else {
  428. return 0;
  429. }
  430. }
  433. void cc_invalidate(void)
  434. {
  435. drv_num_read = 0xFF;
  436. f_dsk_valid = 0xFF;
  437. current_drive = 0xFF;
  438. f_drv_ok = 0xFF;
  440. clear_Audio();
  442. }
  444. void clear_Audio(void)
  445. {
  447. f_AudioPlay = 0;
  448. f_AudioPause = 0;
  449. AudioStart_m = 0;
  450. AudioStart_f = 0;
  451. AudioEnd_m = 0;
  452. AudioEnd_f = 0;
  454. }
  456. /*
  457.  *   waiting ?  
  458.  */
  460. int wait_drv_ready(void)
  461. {
  462. int found, read;
  464. do {
  465. found = inb(GSCDPORT(0));
  466. found &= 0x0f;
  467. read = inb(GSCDPORT(0));
  468. read &= 0x0f;
  469. } while (read != found);
  471. #ifdef GSCD_DEBUG
  472. printk("Wait for: %dn", read);
  473. #endif
  475. return read;
  476. }
  478. void cc_Ident(char *respons)
  479. {
  480. char to_do[] = { CMD_IDENT, 0, 0 };
  482. cmd_out(TYPE_INFO, (char *) &to_do, (char *) respons, (int) 0x1E);
  484. }
  486. void cc_SetSpeed(void)
  487. {
  488. char to_do[] = { CMD_SETSPEED, 0, 0 };
  489. char dummy;
  491. if (speed > 0) {
  492. to_do[1] = speed & 0x0F;
  493. cmd_out(TYPE_INFO, (char *) &to_do, (char *) &dummy, 0);
  494. }
  495. }
  498. void cc_Reset(void)
  499. {
  500. char to_do[] = { CMD_RESET, 0 };
  501. char dummy;
  503. cmd_out(TYPE_INFO, (char *) &to_do, (char *) &dummy, 0);
  504. }
  508. void cmd_status(void)
  509. {
  510. char to_do[] = { CMD_STATUS, 0 };
  511. char dummy;
  513. cmd_out(TYPE_INFO, (char *) &to_do, (char *) &dummy, 0);
  515. #ifdef GSCD_DEBUG
  516. printk("GSCD: Status: %dn", disk_state);
  517. #endif
  519. }
  521. void cmd_out(int cmd_type, char *cmd, char *respo_buf, int respo_count)
  522. {
  523. int result;
  526. result = wait_drv_ready();
  527. if (result != drv_mode) {
  528. unsigned long test_loops = 0xFFFF;
  529. int i, dummy;
  531. outb(curr_drv_state, GSCDPORT(0));
  533. /* LOCLOOP_170 */
  534. do {
  535. result = wait_drv_ready();
  536. test_loops--;
  537. } while ((result != drv_mode) && (test_loops > 0));
  539. if (result != drv_mode) {
  540. disk_state = ST_x08 | ST_x04 | ST_INVALID;
  541. return;
  542. }
  544. /* ...and waiting */
  545. for (i = 1, dummy = 1; i < 0xFFFF; i++) {
  546. dummy *= i;
  547. }
  548. }
  550. /* LOC_172 */
  551. /* check the unit */
  552. /* and wake it up */
  553. if (cmd_unit_alive() != 0x08) {
  554. /* LOC_174 */
  555. /* game over for this unit */
  556. disk_state = ST_x08 | ST_x04 | ST_INVALID;
  557. return;
  558. }
  560. /* LOC_176 */
  561. #ifdef GSCD_DEBUG
  562. printk("LOC_176 ");
  563. #endif
  564. if (drv_mode == 0x09) {
  565. /* magic... */
  566. printk("GSCD: magic ...n");
  567. outb(result, GSCDPORT(2));
  568. }
  570. /* write the command to the drive */
  571. cmd_write_cmd(cmd);
  573. /* LOC_178 */
  574. for (;;) {
  575. result = wait_drv_ready();
  576. if (result != drv_mode) {
  577. /* LOC_179 */
  578. if (result == 0x04) { /* Mode 4 */
  579. /* LOC_205 */
  580. #ifdef GSCD_DEBUG
  581. printk("LOC_205 ");
  582. #endif
  583. disk_state = inb(GSCDPORT(2));
  585. do {
  586. result = wait_drv_ready();
  587. } while (result != drv_mode);
  588. return;
  590. } else {
  591. if (result == 0x06) { /* Mode 6 */
  592. /* LOC_181 */
  593. #ifdef GSCD_DEBUG
  594. printk("LOC_181 ");
  595. #endif
  597. if (cmd_type == TYPE_DATA) {
  598. /* read data */
  599. /* LOC_184 */
  600. if (drv_mode == 9) {
  601. /* read the data to the buffer (word) */
  603. /* (*(cmd+1))?(CD_FRAMESIZE/2):(CD_FRAMESIZE_RAW/2) */
  604. cmd_read_w
  605.     (respo_buf,
  606.      respo_count,
  607.      CD_FRAMESIZE /
  608.      2);
  609. return;
  610. } else {
  611. /* read the data to the buffer (byte) */
  613. /* (*(cmd+1))?(CD_FRAMESIZE):(CD_FRAMESIZE_RAW)    */
  614. cmd_read_b
  615.     (respo_buf,
  616.      respo_count,
  617.      CD_FRAMESIZE);
  618. return;
  619. }
  620. } else {
  621. /* read the info to the buffer */
  622. cmd_info_in(respo_buf,
  623.     respo_count);
  624. return;
  625. }
  627. return;
  628. }
  629. }
  631. } else {
  632. disk_state = ST_x08 | ST_x04 | ST_INVALID;
  633. return;
  634. }
  635. } /* for (;;) */
  638. #ifdef GSCD_DEBUG
  639. printk("n");
  640. #endif
  641. }
  644. static void cmd_write_cmd(char *pstr)
  645. {
  646. int i, j;
  648. /* LOC_177 */
  649. #ifdef GSCD_DEBUG
  650. printk("LOC_177 ");
  651. #endif
  653. /* calculate the number of parameter */
  654. j = *pstr & 0x0F;
  656. /* shift it out */
  657. for (i = 0; i < j; i++) {
  658. outb(*pstr, GSCDPORT(2));
  659. pstr++;
  660. }
  661. }
  664. static int cmd_unit_alive(void)
  665. {
  666. int result;
  667. unsigned long max_test_loops;
  670. /* LOC_172 */
  671. #ifdef GSCD_DEBUG
  672. printk("LOC_172 ");
  673. #endif
  675. outb(curr_drv_state, GSCDPORT(0));
  676. max_test_loops = 0xFFFF;
  678. do {
  679. result = wait_drv_ready();
  680. max_test_loops--;
  681. } while ((result != 0x08) && (max_test_loops > 0));
  683. return result;
  684. }
  687. static void cmd_info_in(char *pb, int count)
  688. {
  689. int result;
  690. char read;
  693. /* read info */
  694. /* LOC_182 */
  695. #ifdef GSCD_DEBUG
  696. printk("LOC_182 ");
  697. #endif
  699. do {
  700. read = inb(GSCDPORT(2));
  701. if (count > 0) {
  702. *pb = read;
  703. pb++;
  704. count--;
  705. }
  707. /* LOC_183 */
  708. do {
  709. result = wait_drv_ready();
  710. } while (result == 0x0E);
  711. } while (result == 6);
  713. cmd_end();
  714. return;
  715. }
  718. static void cmd_read_b(char *pb, int count, int size)
  719. {
  720. int result;
  721. int i;
  724. /* LOC_188 */
  725. /* LOC_189 */
  726. #ifdef GSCD_DEBUG
  727. printk("LOC_189 ");
  728. #endif
  730. do {
  731. do {
  732. result = wait_drv_ready();
  733. } while (result != 6 || result == 0x0E);
  735. if (result != 6) {
  736. cmd_end();
  737. return;
  738. }
  739. #ifdef GSCD_DEBUG
  740. printk("LOC_191 ");
  741. #endif
  743. for (i = 0; i < size; i++) {
  744. *pb = inb(GSCDPORT(2));
  745. pb++;
  746. }
  747. count--;
  748. } while (count > 0);
  750. cmd_end();
  751. return;
  752. }
  755. static void cmd_end(void)
  756. {
  757. int result;
  760. /* LOC_204 */
  761. #ifdef GSCD_DEBUG
  762. printk("LOC_204 ");
  763. #endif
  765. do {
  766. result = wait_drv_ready();
  767. if (result == drv_mode) {
  768. return;
  769. }
  770. } while (result != 4);
  772. /* LOC_205 */
  773. #ifdef GSCD_DEBUG
  774. printk("LOC_205 ");
  775. #endif
  777. disk_state = inb(GSCDPORT(2));
  779. do {
  780. result = wait_drv_ready();
  781. } while (result != drv_mode);
  782. return;
  784. }
  787. static void cmd_read_w(char *pb, int count, int size)
  788. {
  789. int result;
  790. int i;
  793. #ifdef GSCD_DEBUG
  794. printk("LOC_185 ");
  795. #endif
  797. do {
  798. /* LOC_185 */
  799. do {
  800. result = wait_drv_ready();
  801. } while (result != 6 || result == 0x0E);
  803. if (result != 6) {
  804. cmd_end();
  805. return;
  806. }
  808. for (i = 0; i < size; i++) {
  809. /* na, hier muss ich noch mal drueber nachdenken */
  810. *pb = inw(GSCDPORT(2));
  811. pb++;
  812. }
  813. count--;
  814. } while (count > 0);
  816. cmd_end();
  817. return;
  818. }
  820. int __init find_drives(void)
  821. {
  822. int *pdrv;
  823. int drvnum;
  824. int subdrv;
  825. int i;
  827. speed = 0;
  828. pdrv = (int *) &drv_states;
  829. curr_drv_state = 0xFE;
  830. subdrv = 0;
  831. drvnum = 0;
  833. for (i = 0; i < 8; i++) {
  834. subdrv++;
  835. cmd_status();
  836. disk_state &= ST_x08 | ST_x04 | ST_INVALID | ST_x01;
  837. if (disk_state != (ST_x08 | ST_x04 | ST_INVALID)) {
  838. /* LOC_240 */
  839. *pdrv = curr_drv_state;
  840. init_cd_drive(drvnum);
  841. pdrv++;
  842. drvnum++;
  843. } else {
  844. if (subdrv < 2) {
  845. continue;
  846. } else {
  847. subdrv = 0;
  848. }
  849. }
  851. /*       curr_drv_state<<1;         <-- das geht irgendwie nicht */
  852. /* muss heissen:    curr_drv_state <<= 1; (ist ja Wert-Zuweisung) */
  853. curr_drv_state *= 2;
  854. curr_drv_state |= 1;
  855. #ifdef GSCD_DEBUG
  856. printk("DriveState: %dn", curr_drv_state);
  857. #endif
  858. }
  860. ndrives = drvnum;
  861. return drvnum;
  862. }
  864. void __init init_cd_drive(int num)
  865. {
  866. char resp[50];
  867. int i;
  869. printk("GSCD: init unit %dn", num);
  870. cc_Ident((char *) &resp);
  872. printk("GSCD: identification: ");
  873. for (i = 0; i < 0x1E; i++) {
  874. printk("%c", resp[i]);
  875. }
  876. printk("n");
  878. cc_SetSpeed();
  880. }
  882. #ifdef FUTURE_WORK
  883. /* return_done */
  884. static void update_state(void)
  885. {
  886. unsigned int AX;
  889. if ((disk_state & (ST_x08 | ST_x04 | ST_INVALID | ST_x01)) == 0) {
  890. if (disk_state == (ST_x08 | ST_x04 | ST_INVALID)) {
  891. AX = ST_INVALID;
  892. }
  894. if ((disk_state & (ST_x08 | ST_x04 | ST_INVALID | ST_x01))
  895.     == 0) {
  896. invalidate();
  897. f_drv_ok = 0;
  898. }
  900. AX |= 0x8000;
  901. }
  903. if (disk_state & ST_PLAYING) {
  904. AX |= 0x200;
  905. }
  907. AX |= 0x100;
  908. /* pkt_esbx = AX; */
  910. disk_state = 0;
  912. }
  913. #endif
  915. /* Init for the Module-Version */
  916. int init_gscd(void)
  917. {
  918. long err;
  921. /* call the GoldStar-init */
  922. err = my_gscd_init();
  924. if (err < 0) {
  925. return err;
  926. } else {
  927. printk(KERN_INFO "Happy GoldStar !n");
  928. return 0;
  929. }
  930. }
  932. void __exit exit_gscd(void)
  933. {
  934. CLEAR_TIMER;
  936. devfs_unregister(devfs_find_handle
  937.  (NULL, "gscd", 0, 0, DEVFS_SPECIAL_BLK, 0));
  938. if ((devfs_unregister_blkdev(MAJOR_NR, "gscd") == -EINVAL)) {
  939. printk("What's that: can't unregister GoldStar-modulen");
  940. return;
  941. }
  942. blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
  943. release_region(gscd_port, 4);
  944. printk(KERN_INFO "GoldStar-module released.n");
  945. }
  947. #ifdef MODULE
  948. module_init(init_gscd);
  949. #endif
  950. module_exit(exit_gscd);
  953. /* Test for presence of drive and initialize it.  Called only at boot time. */
  954. int __init gscd_init(void)
  955. {
  956. return my_gscd_init();
  957. }
  960. /* This is the common initialisation for the GoldStar drive. */
  961. /* It is called at boot time AND for module init.           */
  962. int __init my_gscd_init(void)
  963. {
  964. int i;
  965. int result;
  967. printk(KERN_INFO "GSCD: version %sn", GSCD_VERSION);
  968. printk(KERN_INFO
  969.        "GSCD: Trying to detect a Goldstar R420 CD-ROM drive at 0x%X.n",
  970.        gscd_port);
  972. if (check_region(gscd_port, 4)) {
  973. printk
  974.     ("GSCD: Init failed, I/O port (%X) already in use.n",
  975.      gscd_port);
  976. return -EIO;
  977. }
  980. /* check for card */
  981. result = wait_drv_ready();
  982. if (result == 0x09) {
  983. printk("GSCD: DMA kann ich noch nicht!n");
  984. return -EIO;
  985. }
  987. if (result == 0x0b) {
  988. drv_mode = result;
  989. i = find_drives();
  990. if (i == 0) {
  991. printk
  992.     ("GSCD: GoldStar CD-ROM Drive is not found.n");
  993. return -EIO;
  994. }
  995. }
  997. if ((result != 0x0b) && (result != 0x09)) {
  998. printk
  999.     ("GSCD: GoldStar Interface Adapter does not exist or H/W errorn");
  1000. return -EIO;
  1001. }
  1003. /* reset all drives */
  1004. i = 0;
  1005. while (drv_states[i] != 0) {
  1006. curr_drv_state = drv_states[i];
  1007. printk(KERN_INFO "GSCD: Reset unit %d ... ", i);
  1008. cc_Reset();
  1009. printk("donen");
  1010. i++;
  1011. }
  1013. if (devfs_register_blkdev(MAJOR_NR, "gscd", &gscd_fops) != 0) {
  1014. printk
  1015.     ("GSCD: Unable to get major %d for GoldStar CD-ROMn",
  1016.      MAJOR_NR);
  1017. return -EIO;
  1018. }
  1019. devfs_register(NULL, "gscd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
  1020.        S_IFBLK | S_IRUGO | S_IWUGO, &gscd_fops, NULL);
  1022. blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
  1023. blksize_size[MAJOR_NR] = gscd_blocksizes;
  1024. read_ahead[MAJOR_NR] = 4;
  1026. disk_state = 0;
  1027. gscdPresent = 1;
  1029. request_region(gscd_port, 4, "gscd");
  1030. register_disk(NULL, MKDEV(MAJOR_NR, 0), 1, &gscd_fops, 0);
  1032. printk(KERN_INFO "GSCD: GoldStar CD-ROM Drive found.n");
  1033. return 0;
  1034. }
  1036. static void gscd_hsg2msf(long hsg, struct msf *msf)
  1037. {
  1038. hsg += CD_MSF_OFFSET;
  1039. msf->min = hsg / (CD_FRAMES * CD_SECS);
  1040. hsg %= CD_FRAMES * CD_SECS;
  1041. msf->sec = hsg / CD_FRAMES;
  1042. msf->frame = hsg % CD_FRAMES;
  1044. gscd_bin2bcd(&msf->min); /* convert to BCD */
  1045. gscd_bin2bcd(&msf->sec);
  1046. gscd_bin2bcd(&msf->frame);
  1047. }
  1050. static void gscd_bin2bcd(unsigned char *p)
  1051. {
  1052. int u, t;
  1054. u = *p % 10;
  1055. t = *p / 10;
  1056. *p = u | (t << 4);
  1057. }
  1060. #ifdef FUTURE_WORK
  1061. static long gscd_msf2hsg(struct msf *mp)
  1062. {
  1063. return gscd_bcd2bin(mp->frame)
  1064.     + gscd_bcd2bin(mp->sec) * CD_FRAMES
  1065.     + gscd_bcd2bin(mp->min) * CD_FRAMES * CD_SECS - CD_MSF_OFFSET;
  1066. }
  1068. static int gscd_bcd2bin(unsigned char bcd)
  1069. {
  1070. return (bcd >> 4) * 10 + (bcd & 0xF);
  1071. }
  1072. #endif
  1074. MODULE_AUTHOR("Oliver Raupach <raupach@nwfs1.rz.fh-hannover.de>");
  1075. MODULE_LICENSE("GPL");
  1076. EXPORT_NO_SYMBOLS;