2 linux/kernel/blk_drv/mcd.c - Mitsumi CDROM driver
4 Copyright (C) 1992 Martin Harriss
5 Portions Copyright (C) 2001 Red Hat
7 martin@bdsi.com (no longer valid - where are you now, Martin?)
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 0.1 First attempt - internal use only
26 0.2 Cleaned up delays and use of timer - alpha release
27 0.3 Audio support added
28 0.3.1 Changes for mitsumi CRMC LU005S march version
29 (stud11@cc4.kuleuven.ac.be)
30 0.3.2 bug fixes to the ioctls and merged with ALPHA0.99-pl12
31 (Jon Tombs <jon@robots.ox.ac.uk>)
32 0.3.3 Added more #defines and mcd_setup()
33 (Jon Tombs <jon@gtex02.us.es>)
35 October 1993 Bernd Huebner and Ruediger Helsch, Unifix Software GmbH,
36 Braunschweig, Germany: rework to speed up data read operation.
37 Also enabled definition of irq and address from bootstrap, using the
39 November 93 added code for FX001 S,D (single & double speed).
40 February 94 added code for broken M 5/6 series of 16-bit single speed.
44 Added support for loadable MODULEs, so mcd can now also be loaded by
45 insmod and removed by rmmod during runtime.
46 Werner Zimmermann (zimmerma@rz.fht-esslingen.de), Mar. 26, 95
49 I added code for FX001 D to drop from double speed to single speed
50 when encountering errors... this helps with some "problematic" CD's
51 that are supposedly "OUT OF TOLERANCE" (but are really shitty presses!)
52 severely scratched, or possibly slightly warped! I have noticed that
53 the Mitsumi 2x/4x drives are just less tolerant and the firmware is
54 not smart enough to drop speed, so let's just kludge it with software!
55 ****** THE 4X SPEED MITSUMI DRIVES HAVE THE SAME PROBLEM!!!!!! ******
56 Anyone want to "DONATE" one to me?! ;) I hear sometimes they are
58 ** HINT... HINT... TAKE NOTES MITSUMI This could save some hassles with
59 certain "large" CD's that have data on the outside edge in your
60 DOS DRIVERS .... Accuracy counts... speed is secondary ;)
61 17 June 95 Modifications By Andrew J. Kroll <ag784@freenet.buffalo.edu>
62 07 July 1995 Modifications by Andrew J. Kroll
64 Bjorn Ekwall <bj0rn@blox.se> added unregister_blkdev to mcd_init()
66 Michael K. Johnson <johnsonm@redhat.com> added retries on open
67 for slow drives which take a while to recognize that they contain
70 November 1997 -- ported to the Uniform CD-ROM driver by Erik Andersen.
71 March 1999 -- made io base and irq CONFIG_ options (Tigran Aivazian).
73 November 1999 -- Make kernel-parameter implementation work with 2.3.x
74 Removed init_module & cleanup_module in favor of
75 module_init & module_exit.
76 Torben Mathiasen <tmm@image.dk>
78 September 2001 - Reformatted and cleaned up the code
79 Alan Cox <alan@redhat.com>
82 #include <linux/module.h>
84 #include <linux/errno.h>
85 #include <linux/interrupt.h>
86 #include <linux/signal.h>
88 #include <linux/timer.h>
90 #include <linux/kernel.h>
91 #include <linux/devfs_fs_kernel.h>
92 #include <linux/cdrom.h>
93 #include <linux/ioport.h>
94 #include <linux/string.h>
95 #include <linux/delay.h>
96 #include <linux/init.h>
97 #include <linux/config.h>
99 /* #define REALLY_SLOW_IO */
100 #include <asm/system.h>
102 #include <asm/current.h>
103 #include <asm/uaccess.h>
104 #include <linux/blkdev.h>
106 #define mcd_port mcd /* for compatible parameter passing with "insmod" */
109 /* I added A flag to drop to 1x speed if too many errors 0 = 1X ; 1 = 2X */
110 static int mcdDouble;
112 /* How many sectors to hold at 1x speed counter */
113 static int mcd1xhold;
115 /* Is the drive connected properly and responding?? */
116 static int mcdPresent;
117 static struct request_queue *mcd_queue;
119 #define MAJOR_NR MITSUMI_CDROM_MAJOR
120 #define QUEUE (mcd_queue)
121 #define CURRENT elv_next_request(mcd_queue)
123 #define QUICK_LOOP_DELAY udelay(45) /* use udelay */
124 #define QUICK_LOOP_COUNT 20
126 static int current_valid(void)
129 CURRENT->cmd == READ &&
130 CURRENT->sector != -1;
133 #define MFL_STATUSorDATA (MFL_STATUS | MFL_DATA)
134 #define MCD_BUF_SIZ 16
135 static volatile int mcd_transfer_is_active;
136 static char mcd_buf[2048 * MCD_BUF_SIZ]; /* buffer for block size conversion */
137 static volatile int mcd_buf_bn[MCD_BUF_SIZ], mcd_next_bn;
138 static volatile int mcd_buf_in, mcd_buf_out = -1;
139 static volatile int mcd_error;
140 static int mcd_open_count;
148 MCD_S_STOPPING /* 6 */
150 static volatile enum mcd_state_e mcd_state = MCD_S_IDLE;
151 static int mcd_mode = -1;
152 static int MCMD_DATA_READ = MCMD_PLAY_READ;
154 #define READ_TIMEOUT 3000
156 int mitsumi_bug_93_wait;
158 static short mcd_port = CONFIG_MCD_BASE; /* used as "mcd" by "insmod" */
159 static int mcd_irq = CONFIG_MCD_IRQ; /* must directly follow mcd_port */
160 MODULE_PARM(mcd, "1-2i");
162 static int McdTimeout, McdTries;
163 static DECLARE_WAIT_QUEUE_HEAD(mcd_waitq);
165 static struct mcd_DiskInfo DiskInfo;
166 static struct mcd_Toc Toc[MAX_TRACKS];
167 static struct mcd_Play_msf mcd_Play;
169 static int audioStatus;
170 static char mcdDiskChanged;
171 static char tocUpToDate;
172 static char mcdVersion;
174 static void mcd_transfer(void);
175 static void mcd_poll(unsigned long dummy);
176 static void mcd_invalidate_buffers(void);
177 static void hsg2msf(long hsg, struct msf *msf);
178 static void bin2bcd(unsigned char *p);
179 static int bcd2bin(unsigned char bcd);
180 static int mcdStatus(void);
181 static void sendMcdCmd(int cmd, struct mcd_Play_msf *params);
182 static int getMcdStatus(int timeout);
183 static int GetQChannelInfo(struct mcd_Toc *qp);
184 static int updateToc(void);
185 static int GetDiskInfo(void);
186 static int GetToc(void);
187 static int getValue(unsigned char *result);
188 static int mcd_open(struct cdrom_device_info *cdi, int purpose);
189 static void mcd_release(struct cdrom_device_info *cdi);
190 static int mcd_media_changed(struct cdrom_device_info *cdi, int disc_nr);
191 static int mcd_tray_move(struct cdrom_device_info *cdi, int position);
192 static spinlock_t mcd_spinlock = SPIN_LOCK_UNLOCKED;
193 static int mcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
195 static int mcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
197 static struct timer_list mcd_timer = TIMER_INITIALIZER(NULL, 0, 0);
199 static struct cdrom_device_ops mcd_dops = {
201 .release = mcd_release,
202 .drive_status = mcd_drive_status,
203 .media_changed = mcd_media_changed,
204 .tray_move = mcd_tray_move,
205 .audio_ioctl = mcd_audio_ioctl,
206 .capability = CDC_OPEN_TRAY | CDC_MEDIA_CHANGED |
207 CDC_PLAY_AUDIO | CDC_DRIVE_STATUS,
210 static struct cdrom_device_info mcd_info = {
217 static int mcd_block_open(struct inode *inode, struct file *file)
219 return cdrom_open(&mcd_info, inode, file);
222 static int mcd_block_release(struct inode *inode, struct file *file)
224 return cdrom_release(&mcd_info, file);
227 static int mcd_block_ioctl(struct inode *inode, struct file *file,
228 unsigned cmd, unsigned long arg)
230 return cdrom_ioctl(&mcd_info, inode, cmd, arg);
233 static int mcd_block_media_changed(struct gendisk *disk)
235 return cdrom_media_changed(&mcd_info);
238 static struct block_device_operations mcd_bdops =
240 .owner = THIS_MODULE,
241 .open = mcd_block_open,
242 .release = mcd_block_release,
243 .ioctl = mcd_block_ioctl,
244 .media_changed = mcd_block_media_changed,
247 static struct gendisk *mcd_gendisk;
250 static int __init mcd_setup(char *str)
254 (void) get_options(str, ARRAY_SIZE(ints), ints);
261 mitsumi_bug_93_wait = ints[3];
266 __setup("mcd=", mcd_setup);
270 static int mcd_media_changed(struct cdrom_device_info *cdi, int disc_nr)
277 * Do a 'get status' command and get the result. Only use from the top half
278 * because it calls 'getMcdStatus' which sleeps.
281 static int statusCmd(void)
285 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
286 /* send get-status cmd */
287 outb(MCMD_GET_STATUS, MCDPORT(0));
289 st = getMcdStatus(MCD_STATUS_DELAY);
299 * Send a 'Play' command and get the status. Use only from the top half.
302 static int mcdPlay(struct mcd_Play_msf *arg)
306 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
307 sendMcdCmd(MCMD_PLAY_READ, arg);
308 st = getMcdStatus(2 * MCD_STATUS_DELAY);
317 static int mcd_tray_move(struct cdrom_device_info *cdi, int position)
322 /* all drives can at least stop! */
323 if (audioStatus == CDROM_AUDIO_PLAY) {
324 outb(MCMD_STOP, MCDPORT(0));
325 i = getMcdStatus(MCD_STATUS_DELAY);
328 audioStatus = CDROM_AUDIO_NO_STATUS;
330 outb(MCMD_EJECT, MCDPORT(0));
332 * the status (i) shows failure on all but the FX drives.
333 * But nothing we can do about that in software!
334 * So just read the status and forget it. - Jon.
336 i = getMcdStatus(MCD_STATUS_DELAY);
342 long msf2hsg(struct msf *mp)
344 return bcd2bin(mp->frame) + bcd2bin(mp->sec) * 75 + bcd2bin(mp->min) * 4500 - 150;
348 int mcd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
352 struct mcd_Toc qInfo;
354 struct cdrom_tochdr *tocHdr;
355 struct cdrom_msf *msf;
356 struct cdrom_subchnl *subchnl;
357 struct cdrom_tocentry *entry;
358 struct mcd_Toc *tocPtr;
359 struct cdrom_volctrl *volctrl;
368 return i; /* error reading TOC */
372 case CDROMSTART: /* Spin up the drive */
373 /* Don't think we can do this. Even if we could,
374 * I think the drive times out and stops after a while
375 * anyway. For now, ignore it.
380 case CDROMSTOP: /* Spin down the drive */
381 outb(MCMD_STOP, MCDPORT(0));
382 i = getMcdStatus(MCD_STATUS_DELAY);
384 /* should we do anything if it fails? */
386 audioStatus = CDROM_AUDIO_NO_STATUS;
389 case CDROMPAUSE: /* Pause the drive */
390 if (audioStatus != CDROM_AUDIO_PLAY)
393 outb(MCMD_STOP, MCDPORT(0));
394 i = getMcdStatus(MCD_STATUS_DELAY);
396 if (GetQChannelInfo(&qInfo) < 0) {
397 /* didn't get q channel info */
399 audioStatus = CDROM_AUDIO_NO_STATUS;
403 mcd_Play.start = qInfo.diskTime; /* remember restart point */
405 audioStatus = CDROM_AUDIO_PAUSED;
408 case CDROMRESUME: /* Play it again, Sam */
409 if (audioStatus != CDROM_AUDIO_PAUSED)
412 /* restart the drive at the saved position. */
414 i = mcdPlay(&mcd_Play);
416 audioStatus = CDROM_AUDIO_ERROR;
420 audioStatus = CDROM_AUDIO_PLAY;
423 case CDROMPLAYTRKIND: /* Play a track. This currently ignores index. */
425 ti = (struct cdrom_ti *) arg;
427 if (ti->cdti_trk0 < DiskInfo.first
428 || ti->cdti_trk0 > DiskInfo.last
429 || ti->cdti_trk1 < ti->cdti_trk0) {
433 if (ti->cdti_trk1 > DiskInfo.last)
434 ti->cdti_trk1 = DiskInfo.last;
436 mcd_Play.start = Toc[ti->cdti_trk0].diskTime;
437 mcd_Play.end = Toc[ti->cdti_trk1 + 1].diskTime;
440 printk("play: %02x:%02x.%02x to %02x:%02x.%02x\n",
441 mcd_Play.start.min, mcd_Play.start.sec,
442 mcd_Play.start.frame, mcd_Play.end.min,
443 mcd_Play.end.sec, mcd_Play.end.frame);
446 i = mcdPlay(&mcd_Play);
448 audioStatus = CDROM_AUDIO_ERROR;
452 audioStatus = CDROM_AUDIO_PLAY;
455 case CDROMPLAYMSF: /* Play starting at the given MSF address. */
457 if (audioStatus == CDROM_AUDIO_PLAY) {
458 outb(MCMD_STOP, MCDPORT(0));
459 i = getMcdStatus(MCD_STATUS_DELAY);
460 audioStatus = CDROM_AUDIO_NO_STATUS;
463 msf = (struct cdrom_msf *) arg;
467 bin2bcd(&msf->cdmsf_min0);
468 bin2bcd(&msf->cdmsf_sec0);
469 bin2bcd(&msf->cdmsf_frame0);
470 bin2bcd(&msf->cdmsf_min1);
471 bin2bcd(&msf->cdmsf_sec1);
472 bin2bcd(&msf->cdmsf_frame1);
474 mcd_Play.start.min = msf->cdmsf_min0;
475 mcd_Play.start.sec = msf->cdmsf_sec0;
476 mcd_Play.start.frame = msf->cdmsf_frame0;
477 mcd_Play.end.min = msf->cdmsf_min1;
478 mcd_Play.end.sec = msf->cdmsf_sec1;
479 mcd_Play.end.frame = msf->cdmsf_frame1;
482 printk("play: %02x:%02x.%02x to %02x:%02x.%02x\n",
483 mcd_Play.start.min, mcd_Play.start.sec,
484 mcd_Play.start.frame, mcd_Play.end.min,
485 mcd_Play.end.sec, mcd_Play.end.frame);
488 i = mcdPlay(&mcd_Play);
490 audioStatus = CDROM_AUDIO_ERROR;
494 audioStatus = CDROM_AUDIO_PLAY;
497 case CDROMREADTOCHDR: /* Read the table of contents header */
498 tocHdr = (struct cdrom_tochdr *) arg;
499 tocHdr->cdth_trk0 = DiskInfo.first;
500 tocHdr->cdth_trk1 = DiskInfo.last;
503 case CDROMREADTOCENTRY: /* Read an entry in the table of contents */
504 entry = (struct cdrom_tocentry *) arg;
505 if (entry->cdte_track == CDROM_LEADOUT)
506 tocPtr = &Toc[DiskInfo.last - DiskInfo.first + 1];
508 else if (entry->cdte_track > DiskInfo.last
509 || entry->cdte_track < DiskInfo.first)
513 tocPtr = &Toc[entry->cdte_track];
515 entry->cdte_adr = tocPtr->ctrl_addr;
516 entry->cdte_ctrl = tocPtr->ctrl_addr >> 4;
518 if (entry->cdte_format == CDROM_LBA)
519 entry->cdte_addr.lba = msf2hsg(&tocPtr->diskTime);
521 else if (entry->cdte_format == CDROM_MSF) {
522 entry->cdte_addr.msf.minute =
523 bcd2bin(tocPtr->diskTime.min);
524 entry->cdte_addr.msf.second =
525 bcd2bin(tocPtr->diskTime.sec);
526 entry->cdte_addr.msf.frame =
527 bcd2bin(tocPtr->diskTime.frame);
535 case CDROMSUBCHNL: /* Get subchannel info */
537 subchnl = (struct cdrom_subchnl *) arg;
538 if (GetQChannelInfo(&qInfo) < 0)
541 subchnl->cdsc_audiostatus = audioStatus;
542 subchnl->cdsc_adr = qInfo.ctrl_addr;
543 subchnl->cdsc_ctrl = qInfo.ctrl_addr >> 4;
544 subchnl->cdsc_trk = bcd2bin(qInfo.track);
545 subchnl->cdsc_ind = bcd2bin(qInfo.pointIndex);
546 subchnl->cdsc_absaddr.msf.minute = bcd2bin(qInfo.diskTime.min);
547 subchnl->cdsc_absaddr.msf.second = bcd2bin(qInfo.diskTime.sec);
548 subchnl->cdsc_absaddr.msf.frame = bcd2bin(qInfo.diskTime.frame);
549 subchnl->cdsc_reladdr.msf.minute = bcd2bin(qInfo.trackTime.min);
550 subchnl->cdsc_reladdr.msf.second = bcd2bin(qInfo.trackTime.sec);
551 subchnl->cdsc_reladdr.msf.frame = bcd2bin(qInfo.trackTime.frame);
554 case CDROMVOLCTRL: /* Volume control */
555 volctrl = (struct cdrom_volctrl *) arg;
556 outb(MCMD_SET_VOLUME, MCDPORT(0));
557 outb(volctrl->channel0, MCDPORT(0));
558 outb(255, MCDPORT(0));
559 outb(volctrl->channel1, MCDPORT(0));
560 outb(255, MCDPORT(0));
562 i = getMcdStatus(MCD_STATUS_DELAY);
583 * Take care of the different block sizes between cdrom and Linux.
584 * When Linux gets variable block sizes this will probably go away.
587 static void mcd_transfer(void)
589 if (!current_valid())
592 while (CURRENT->nr_sectors) {
593 int bn = CURRENT->sector / 4;
595 for (i = 0; i < MCD_BUF_SIZ && mcd_buf_bn[i] != bn; ++i)
597 if (i < MCD_BUF_SIZ) {
598 int offs =(i * 4 + (CURRENT->sector & 3)) * 512;
599 int nr_sectors = 4 - (CURRENT->sector & 3);
600 if (mcd_buf_out != i) {
602 if (mcd_buf_bn[i] != bn) {
607 if (nr_sectors > CURRENT->nr_sectors)
608 nr_sectors = CURRENT->nr_sectors;
609 memcpy(CURRENT->buffer, mcd_buf + offs, nr_sectors * 512);
610 CURRENT->nr_sectors -= nr_sectors;
611 CURRENT->sector += nr_sectors;
612 CURRENT->buffer += nr_sectors * 512;
622 * We only seem to get interrupts after an error.
623 * Just take the interrupt and clear out the status reg.
626 static irqreturn_t mcd_interrupt(int irq, void *dev_id, struct pt_regs *regs)
630 st = inb(MCDPORT(1)) & 0xFF;
631 test1(printk("<int1-%02X>", st));
632 if (!(st & MFL_STATUS)) {
633 st = inb(MCDPORT(0)) & 0xFF;
634 test1(printk("<int0-%02X>", st));
635 if ((st & 0xFF) != 0xFF)
636 mcd_error = st ? st & 0xFF : -1;
642 static void do_mcd_request(request_queue_t * q)
644 test2(printk(" do_mcd_request(%ld+%ld)\n", CURRENT->sector,
645 CURRENT->nr_sectors));
647 mcd_transfer_is_active = 1;
648 while (current_valid()) {
650 if (CURRENT->nr_sectors == 0) {
651 end_request(CURRENT, 1);
653 mcd_buf_out = -1; /* Want to read a block not in buffer */
654 if (mcd_state == MCD_S_IDLE) {
656 if (updateToc() < 0) {
657 while (current_valid())
658 end_request(CURRENT, 0);
662 mcd_state = MCD_S_START;
664 mcd_timer.function = mcd_poll;
665 mod_timer(&mcd_timer, jiffies + 1);
670 mcd_transfer_is_active = 0;
671 test2(printk(" do_mcd_request ends\n"));
676 static void mcd_poll(unsigned long dummy)
682 if (mcd_error & 0xA5) {
683 printk(KERN_ERR "mcd: I/O error 0x%02x", mcd_error);
684 if (mcd_error & 0x80)
685 printk(" (Door open)");
686 if (mcd_error & 0x20)
687 printk(" (Disk changed)");
688 if (mcd_error & 0x04) {
689 printk(" (Read error)"); /* Bitch about the problem. */
691 /* Time to get fancy! If at 2x speed and 1 error, drop to 1x speed! */
692 /* Interesting how it STAYS at MCD_RETRY_ATTEMPTS on first error! */
693 /* But I find that rather HANDY!!! */
694 /* Neat! it REALLY WORKS on those LOW QUALITY CD's!!! Smile! :) */
697 /* Slap the CD down to single speed! */
699 && McdTries == MCD_RETRY_ATTEMPTS
700 && MCMD_DATA_READ == MCMD_2X_READ) {
701 MCMD_DATA_READ = MCMD_PLAY_READ; /* Uhhh, Ummmm, muhuh-huh! */
702 mcd1xhold = SINGLE_HOLD_SECTORS; /* Hey Beavis! */
703 printk(" Speed now 1x"); /* Pull my finger! */
707 mcd_invalidate_buffers();
708 #ifdef WARN_IF_READ_FAILURE
709 if (McdTries == MCD_RETRY_ATTEMPTS)
710 printk(KERN_ERR "mcd: read of block %d failed\n",
714 /* Nuts! This cd is ready for recycling! */
715 /* When WAS the last time YOU cleaned it CORRECTLY?! */
716 printk(KERN_ERR "mcd: read of block %d failed, giving up\n",
718 if (mcd_transfer_is_active) {
723 end_request(CURRENT, 0);
724 McdTries = MCD_RETRY_ATTEMPTS;
728 mcd_state = MCD_S_STOP;
730 /* Switch back to Double speed if enough GOOD sectors were read! */
732 /* Are we a double speed with a crappy CD?! */
733 if (mcdDouble == 1 && McdTries == MCD_RETRY_ATTEMPTS
734 && MCMD_DATA_READ == MCMD_PLAY_READ) {
735 /* We ARE a double speed and we ARE bitching! */
736 if (mcd1xhold == 0) { /* Okay, Like are we STILL at single speed? *//* We need to switch back to double speed now... */
737 MCMD_DATA_READ = MCMD_2X_READ; /* Uhhh... BACK You GO! */
738 printk(KERN_INFO "mcd: Switching back to 2X speed!\n"); /* Tell 'em! */
740 mcd1xhold--; /* No?! Count down the good reads some more... */
741 /* and try, try again! */
747 test3(printk("MCD_S_IDLE\n"));
751 test3(printk("MCD_S_START\n"));
752 outb(MCMD_GET_STATUS, MCDPORT(0));
753 mcd_state = mcd_mode == 1 ? MCD_S_READ : MCD_S_MODE;
758 test3(printk("MCD_S_MODE\n"));
759 if ((st = mcdStatus()) != -1) {
760 if (st & MST_DSK_CHG) {
763 mcd_invalidate_buffers();
766 set_mode_immediately:
767 if ((st & MST_DOOR_OPEN) || !(st & MST_READY)) {
770 if (mcd_transfer_is_active) {
771 mcd_state = MCD_S_START;
775 printk((st & MST_DOOR_OPEN) ?
777 "mcd: disk removed\n");
778 mcd_state = MCD_S_IDLE;
779 while (current_valid())
780 end_request(CURRENT, 0);
783 outb(MCMD_SET_MODE, MCDPORT(0));
786 mcd_state = MCD_S_READ;
792 test3(printk("MCD_S_READ\n"));
793 if ((st = mcdStatus()) != -1) {
794 if (st & MST_DSK_CHG) {
797 mcd_invalidate_buffers();
801 if ((st & MST_DOOR_OPEN) || !(st & MST_READY)) {
804 if (mcd_transfer_is_active) {
805 mcd_state = MCD_S_START;
809 printk((st & MST_DOOR_OPEN) ?
811 "mcd: disk removed\n");
812 mcd_state = MCD_S_IDLE;
813 while (current_valid())
814 end_request(CURRENT, 0);
818 if (current_valid()) {
819 struct mcd_Play_msf msf;
820 mcd_next_bn = CURRENT->sector / 4;
821 hsg2msf(mcd_next_bn, &msf.start);
825 sendMcdCmd(MCMD_DATA_READ, &msf);
826 mcd_state = MCD_S_DATA;
827 McdTimeout = READ_TIMEOUT;
829 mcd_state = MCD_S_STOP;
837 test3(printk("MCD_S_DATA\n"));
838 st = inb(MCDPORT(1)) & (MFL_STATUSorDATA);
840 test5(printk("Status %02x\n", st))
843 #ifdef WARN_IF_READ_FAILURE
845 printk(KERN_WARNING "mcd: read of block %d failed\n",
849 printk(KERN_ERR "mcd: read of block %d failed, giving up\n", mcd_next_bn);
850 if (mcd_transfer_is_active) {
855 end_request(CURRENT, 0);
858 mcd_state = MCD_S_START;
859 McdTimeout = READ_TIMEOUT;
862 case MFL_STATUSorDATA:
867 if (!current_valid() && mcd_buf_in == mcd_buf_out) {
868 mcd_state = MCD_S_STOP;
871 mcd_buf_bn[mcd_buf_in] = -1;
872 insb(MCDPORT(0), mcd_buf + 2048 * mcd_buf_in,
874 mcd_buf_bn[mcd_buf_in] = mcd_next_bn++;
875 if (mcd_buf_out == -1)
876 mcd_buf_out = mcd_buf_in;
877 mcd_buf_in = mcd_buf_in + 1 == MCD_BUF_SIZ ? 0 : mcd_buf_in + 1;
878 if (!mcd_transfer_is_active) {
879 while (current_valid()) {
881 if (CURRENT->nr_sectors == 0)
882 end_request(CURRENT, 1);
889 && (CURRENT->sector / 4 < mcd_next_bn ||
890 CURRENT->sector / 4 > mcd_next_bn + 16)) {
891 mcd_state = MCD_S_STOP;
894 McdTimeout = READ_TIMEOUT;
896 int count = QUICK_LOOP_COUNT;
899 if ((st = (inb(MCDPORT(1))) & (MFL_STATUSorDATA)) != (MFL_STATUSorDATA)) {
900 test4(printk(" %d ", QUICK_LOOP_COUNT - count));
901 goto data_immediately;
904 test4(printk("ended "));
911 test3(printk("MCD_S_STOP\n"));
912 if (!mitsumi_bug_93_wait)
913 goto do_not_work_around_mitsumi_bug_93_1;
915 McdTimeout = mitsumi_bug_93_wait;
916 mcd_state = 9 + 3 + 1;
923 do_not_work_around_mitsumi_bug_93_1:
924 outb(MCMD_STOP, MCDPORT(0));
925 if ((inb(MCDPORT(1)) & MFL_STATUSorDATA) == MFL_STATUS) {
929 } while ((inb(MCDPORT(1)) & MFL_STATUSorDATA) == MFL_STATUS && --i);
930 outb(MCMD_STOP, MCDPORT(0));
931 if ((inb(MCDPORT(1)) & MFL_STATUSorDATA) == MFL_STATUS) {
935 } while ((inb(MCDPORT(1)) & MFL_STATUSorDATA) == MFL_STATUS && --i);
936 outb(MCMD_STOP, MCDPORT(0));
940 mcd_state = MCD_S_STOPPING;
945 test3(printk("MCD_S_STOPPING\n"));
946 if ((st = mcdStatus()) == -1 && McdTimeout)
949 if ((st != -1) && (st & MST_DSK_CHG)) {
952 mcd_invalidate_buffers();
954 if (!mitsumi_bug_93_wait)
955 goto do_not_work_around_mitsumi_bug_93_2;
957 McdTimeout = mitsumi_bug_93_wait;
958 mcd_state = 9 + 3 + 2;
966 do_not_work_around_mitsumi_bug_93_2:
967 test3(printk("CURRENT_VALID %d mcd_mode %d\n", current_valid(),
969 if (current_valid()) {
972 goto read_immediately;
974 goto set_mode_immediately;
976 mcd_state = MCD_S_START;
980 mcd_state = MCD_S_IDLE;
985 printk(KERN_ERR "mcd: invalid state %d\n", mcd_state);
990 printk(KERN_WARNING "mcd: timeout in state %d\n", mcd_state);
991 mcd_state = MCD_S_STOP;
993 mcd_timer.function = mcd_poll;
994 mod_timer(&mcd_timer, jiffies + 1);
999 static void mcd_invalidate_buffers(void)
1002 for (i = 0; i < MCD_BUF_SIZ; ++i)
1008 * Open the device special file. Check that a disk is in.
1010 static int mcd_open(struct cdrom_device_info *cdi, int purpose)
1013 if (mcdPresent == 0)
1014 return -ENXIO; /* no hardware */
1016 if (mcd_open_count || mcd_state != MCD_S_IDLE)
1019 mcd_invalidate_buffers();
1021 st = statusCmd(); /* check drive status */
1023 goto err_out; /* drive doesn't respond */
1024 if ((st & MST_READY) == 0) { /* no disk? wait a sec... */
1025 current->state = TASK_INTERRUPTIBLE;
1026 schedule_timeout(HZ);
1028 } while (((st & MST_READY) == 0) && count++ < MCD_RETRY_ATTEMPTS);
1030 if (updateToc() < 0)
1043 * On close, we flush all mcd blocks from the buffer cache.
1045 static void mcd_release(struct cdrom_device_info *cdi)
1047 if (!--mcd_open_count) {
1048 mcd_invalidate_buffers();
1053 * Test for presence of drive and initialize it. Called at boot time.
1056 int __init mcd_init(void)
1058 struct gendisk *disk = alloc_disk(1);
1060 unsigned char result[3];
1064 printk(KERN_INFO "mcd: can't allocated disk.\n");
1067 if (mcd_port <= 0 || mcd_irq <= 0) {
1068 printk(KERN_INFO "mcd: not probing.\n");
1072 if (register_blkdev(MAJOR_NR, "mcd")) {
1076 if (!request_region(mcd_port, 4, "mcd")) {
1077 printk(KERN_ERR "mcd: Initialization failed, I/O port (%X) already in use\n", mcd_port);
1081 mcd_queue = blk_init_queue(do_mcd_request, &mcd_spinlock);
1085 /* check for card */
1087 outb(0, MCDPORT(1)); /* send reset */
1088 for (count = 0; count < 2000000; count++)
1089 (void) inb(MCDPORT(1)); /* delay a bit */
1091 outb(0x40, MCDPORT(0)); /* send get-stat cmd */
1092 for (count = 0; count < 2000000; count++)
1093 if (!(inb(MCDPORT(1)) & MFL_STATUS))
1096 if (count >= 2000000) {
1097 printk(KERN_INFO "mcd: initialisation failed - No mcd device at 0x%x irq %d\n",
1101 count = inb(MCDPORT(0)); /* pick up the status */
1103 outb(MCMD_GET_VERSION, MCDPORT(0));
1104 for (count = 0; count < 3; count++)
1105 if (getValue(result + count)) {
1106 printk(KERN_ERR "mcd: mitsumi get version failed at 0x%x\n",
1111 if (result[0] == result[1] && result[1] == result[2])
1114 mcdVersion = result[2];
1116 if (mcdVersion >= 4)
1117 outb(4, MCDPORT(2)); /* magic happens */
1119 /* don't get the IRQ until we know for sure the drive is there */
1121 if (request_irq(mcd_irq, mcd_interrupt, SA_INTERRUPT, "Mitsumi CD", NULL)) {
1122 printk(KERN_ERR "mcd: Unable to get IRQ%d for Mitsumi CD-ROM\n", mcd_irq);
1126 if (result[1] == 'D') {
1127 MCMD_DATA_READ = MCMD_2X_READ;
1128 /* Added flag to drop to 1x speed if too many errors */
1132 sprintf(msg, " mcd: Mitsumi %s Speed CD-ROM at port=0x%x,"
1133 " irq=%d\n", mcd_info.speed == 1 ? "Single" : "Double",
1136 outb(MCMD_CONFIG_DRIVE, MCDPORT(0));
1137 outb(0x02, MCDPORT(0));
1138 outb(0x00, MCDPORT(0));
1141 outb(MCMD_CONFIG_DRIVE, MCDPORT(0));
1142 outb(0x10, MCDPORT(0));
1143 outb(0x04, MCDPORT(0));
1146 mcd_invalidate_buffers();
1149 disk->major = MAJOR_NR;
1150 disk->first_minor = 0;
1151 sprintf(disk->disk_name, "mcd");
1152 disk->fops = &mcd_bdops;
1153 disk->flags = GENHD_FL_CD;
1156 if (register_cdrom(&mcd_info) != 0) {
1157 printk(KERN_ERR "mcd: Unable to register Mitsumi CD-ROM.\n");
1160 disk->queue = mcd_queue;
1166 free_irq(mcd_irq, NULL);
1168 release_region(mcd_port, 4);
1170 blk_cleanup_queue(mcd_queue);
1172 unregister_blkdev(MAJOR_NR, "mcd");
1178 static void hsg2msf(long hsg, struct msf *msf)
1181 msf->min = hsg / 4500;
1183 msf->sec = hsg / 75;
1184 msf->frame = hsg % 75;
1186 bin2bcd(&msf->min); /* convert to BCD */
1188 bin2bcd(&msf->frame);
1192 static void bin2bcd(unsigned char *p)
1201 static int bcd2bin(unsigned char bcd)
1203 return (bcd >> 4) * 10 + (bcd & 0xF);
1208 * See if a status is ready from the drive and return it
1212 static int mcdStatus(void)
1217 st = inb(MCDPORT(1)) & MFL_STATUS;
1219 i = inb(MCDPORT(0)) & 0xFF;
1227 * Send a play or read command to the drive
1230 static void sendMcdCmd(int cmd, struct mcd_Play_msf *params)
1232 outb(cmd, MCDPORT(0));
1233 outb(params->start.min, MCDPORT(0));
1234 outb(params->start.sec, MCDPORT(0));
1235 outb(params->start.frame, MCDPORT(0));
1236 outb(params->end.min, MCDPORT(0));
1237 outb(params->end.sec, MCDPORT(0));
1238 outb(params->end.frame, MCDPORT(0));
1243 * Timer interrupt routine to test for status ready from the drive.
1244 * (see the next routine)
1247 static void mcdStatTimer(unsigned long dummy)
1249 if (!(inb(MCDPORT(1)) & MFL_STATUS)) {
1250 wake_up(&mcd_waitq);
1255 if (McdTimeout <= 0) {
1256 wake_up(&mcd_waitq);
1259 mcd_timer.function = mcdStatTimer;
1260 mod_timer(&mcd_timer, jiffies + 1);
1265 * Wait for a status to be returned from the drive. The actual test
1266 * (see routine above) is done by the timer interrupt to avoid
1267 * excessive rescheduling.
1270 static int getMcdStatus(int timeout)
1274 McdTimeout = timeout;
1275 mcd_timer.function = mcdStatTimer;
1276 mod_timer(&mcd_timer, jiffies + 1);
1277 sleep_on(&mcd_waitq);
1278 if (McdTimeout <= 0)
1281 st = inb(MCDPORT(0)) & 0xFF;
1285 if ((st & MST_BUSY) == 0 && audioStatus == CDROM_AUDIO_PLAY)
1286 /* XXX might be an error? look at q-channel? */
1287 audioStatus = CDROM_AUDIO_COMPLETED;
1289 if (st & MST_DSK_CHG) {
1292 audioStatus = CDROM_AUDIO_NO_STATUS;
1299 /* gives current state of the drive This function is quite unreliable,
1300 and should probably be rewritten by someone, eventually... */
1302 int mcd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
1306 st = statusCmd(); /* check drive status */
1308 return -EIO; /* drive doesn't respond */
1309 if ((st & MST_READY))
1311 if ((st & MST_DOOR_OPEN))
1312 return CDS_TRAY_OPEN;
1313 if ((st & MST_DSK_CHG))
1315 if ((st & MST_BUSY))
1316 return CDS_DRIVE_NOT_READY;
1322 * Read a value from the drive.
1325 static int getValue(unsigned char *result)
1330 for (count = 0; count < 2000; count++)
1331 if (!(inb(MCDPORT(1)) & MFL_STATUS))
1334 if (count >= 2000) {
1335 printk("mcd: getValue timeout\n");
1339 s = inb(MCDPORT(0)) & 0xFF;
1340 *result = (unsigned char) s;
1345 * Read the current Q-channel info. Also used for reading the
1346 * table of contents.
1349 int GetQChannelInfo(struct mcd_Toc *qp)
1351 unsigned char notUsed;
1354 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
1355 outb(MCMD_GET_Q_CHANNEL, MCDPORT(0));
1356 if (getMcdStatus(MCD_STATUS_DELAY) != -1)
1360 if (retry >= MCD_RETRY_ATTEMPTS)
1363 if (getValue(&qp->ctrl_addr) < 0)
1365 if (getValue(&qp->track) < 0)
1367 if (getValue(&qp->pointIndex) < 0)
1369 if (getValue(&qp->trackTime.min) < 0)
1371 if (getValue(&qp->trackTime.sec) < 0)
1373 if (getValue(&qp->trackTime.frame) < 0)
1375 if (getValue(¬Used) < 0)
1377 if (getValue(&qp->diskTime.min) < 0)
1379 if (getValue(&qp->diskTime.sec) < 0)
1381 if (getValue(&qp->diskTime.frame) < 0)
1388 * Read the table of contents (TOC) and TOC header if necessary
1391 static int updateToc(void)
1396 if (GetDiskInfo() < 0)
1407 * Read the table of contents header
1410 static int GetDiskInfo(void)
1414 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
1415 outb(MCMD_GET_DISK_INFO, MCDPORT(0));
1416 if (getMcdStatus(MCD_STATUS_DELAY) != -1)
1420 if (retry >= MCD_RETRY_ATTEMPTS)
1423 if (getValue(&DiskInfo.first) < 0)
1425 if (getValue(&DiskInfo.last) < 0)
1428 DiskInfo.first = bcd2bin(DiskInfo.first);
1429 DiskInfo.last = bcd2bin(DiskInfo.last);
1433 ("Disk Info: first %d last %d length %02x:%02x.%02x first %02x:%02x.%02x\n",
1434 DiskInfo.first, DiskInfo.last, DiskInfo.diskLength.min,
1435 DiskInfo.diskLength.sec, DiskInfo.diskLength.frame,
1436 DiskInfo.firstTrack.min, DiskInfo.firstTrack.sec,
1437 DiskInfo.firstTrack.frame);
1440 if (getValue(&DiskInfo.diskLength.min) < 0)
1442 if (getValue(&DiskInfo.diskLength.sec) < 0)
1444 if (getValue(&DiskInfo.diskLength.frame) < 0)
1446 if (getValue(&DiskInfo.firstTrack.min) < 0)
1448 if (getValue(&DiskInfo.firstTrack.sec) < 0)
1450 if (getValue(&DiskInfo.firstTrack.frame) < 0)
1457 * Read the table of contents (TOC)
1460 static int GetToc(void)
1465 struct mcd_Toc qInfo;
1467 for (i = 0; i < MAX_TRACKS; i++)
1468 Toc[i].pointIndex = 0;
1470 i = DiskInfo.last + 3;
1472 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
1473 outb(MCMD_STOP, MCDPORT(0));
1474 if (getMcdStatus(MCD_STATUS_DELAY) != -1)
1478 if (retry >= MCD_RETRY_ATTEMPTS)
1481 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
1482 outb(MCMD_SET_MODE, MCDPORT(0));
1483 outb(0x05, MCDPORT(0)); /* mode: toc */
1485 if (getMcdStatus(MCD_STATUS_DELAY) != -1)
1489 if (retry >= MCD_RETRY_ATTEMPTS)
1492 for (limit = 300; limit > 0; limit--) {
1493 if (GetQChannelInfo(&qInfo) < 0)
1496 px = bcd2bin(qInfo.pointIndex);
1497 if (px > 0 && px < MAX_TRACKS && qInfo.track == 0)
1498 if (Toc[px].pointIndex == 0) {
1507 Toc[DiskInfo.last + 1].diskTime = DiskInfo.diskLength;
1509 for (retry = 0; retry < MCD_RETRY_ATTEMPTS; retry++) {
1510 outb(MCMD_SET_MODE, MCDPORT(0));
1511 outb(0x01, MCDPORT(0));
1513 if (getMcdStatus(MCD_STATUS_DELAY) != -1)
1518 for (i = 1; i <= DiskInfo.last; i++)
1520 ("i = %2d ctl-adr = %02X track %2d px %02X %02X:%02X.%02X %02X:%02X.%02X\n",
1521 i, Toc[i].ctrl_addr, Toc[i].track, Toc[i].pointIndex,
1522 Toc[i].trackTime.min, Toc[i].trackTime.sec,
1523 Toc[i].trackTime.frame, Toc[i].diskTime.min,
1524 Toc[i].diskTime.sec, Toc[i].diskTime.frame);
1525 for (i = 100; i < 103; i++)
1527 ("i = %2d ctl-adr = %02X track %2d px %02X %02X:%02X.%02X %02X:%02X.%02X\n",
1528 i, Toc[i].ctrl_addr, Toc[i].track, Toc[i].pointIndex,
1529 Toc[i].trackTime.min, Toc[i].trackTime.sec,
1530 Toc[i].trackTime.frame, Toc[i].diskTime.min,
1531 Toc[i].diskTime.sec, Toc[i].diskTime.frame);
1534 return limit > 0 ? 0 : -1;
1537 void __exit mcd_exit(void)
1539 del_gendisk(mcd_gendisk);
1540 put_disk(mcd_gendisk);
1541 if (unregister_cdrom(&mcd_info)) {
1542 printk(KERN_WARNING "Can't unregister cdrom mcd\n");
1545 free_irq(mcd_irq, NULL);
1546 release_region(mcd_port, 4);
1547 if (unregister_blkdev(MAJOR_NR, "mcd")) {
1548 printk(KERN_WARNING "Can't unregister major mcd\n");
1551 blk_cleanup_queue(mcd_queue);
1552 del_timer_sync(&mcd_timer);
1556 module_init(mcd_init);
1558 module_exit(mcd_exit);
1560 MODULE_AUTHOR("Martin Harriss");
1561 MODULE_LICENSE("GPL");
1562 MODULE_ALIAS_BLOCKDEV_MAJOR(MITSUMI_CDROM_MAJOR);