?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / cdrom / mcdx.c
blob01b4e9a5602e455a1e8522894be3f76905a42595
1 /*
2 * The Mitsumi CDROM interface
3 * Copyright (C) 1995 1996 Heiko Schlittermann <heiko@lotte.sax.de>
4 * VERSION: 2.14(hs)
5 *
6 * ... anyway, I'm back again, thanks to Marcin, he adopted
7 * large portions of my code (at least the parts containing
8 * my main thoughts ...)
9 *
10 ****************** H E L P *********************************
11 * If you ever plan to update your CD ROM drive and perhaps
12 * want to sell or simply give away your Mitsumi FX-001[DS]
13 * -- Please --
14 * mail me (heiko@lotte.sax.de). When my last drive goes
15 * ballistic no more driver support will be available from me!
16 *************************************************************
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2, or (at your option)
21 * any later version.
22 *
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
27 *
28 * You should have received a copy of the GNU General Public License
29 * along with this program; see the file COPYING. If not, write to
30 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
31 *
32 * Thanks to
33 * The Linux Community at all and ...
34 * Martin Harriss (he wrote the first Mitsumi Driver)
35 * Eberhard Moenkeberg (he gave me much support and the initial kick)
36 * Bernd Huebner, Ruediger Helsch (Unifix-Software GmbH, they
37 * improved the original driver)
38 * Jon Tombs, Bjorn Ekwall (module support)
39 * Daniel v. Mosnenck (he sent me the Technical and Programming Reference)
40 * Gerd Knorr (he lent me his PhotoCD)
41 * Nils Faerber and Roger E. Wolff (extensively tested the LU portion)
42 * Andreas Kies (testing the mysterious hang-ups)
43 * Heiko Eissfeldt (VERIFY_READ/WRITE)
44 * Marcin Dalecki (improved performance, shortened code)
45 * ... somebody forgotten?
46 *
47 * 9 November 1999 -- Make kernel-parameter implementation work with 2.3.x
48 * Removed init_module & cleanup_module in favor of
49 * module_init & module_exit.
50 * Torben Mathiasen <tmm@image.dk>
51 */
52
53
54 #if RCS
55 static const char *mcdx_c_version
56 = "$Id: mcdx.c,v 1.21 1997/01/26 07:12:59 davem Exp $";
57 #endif
58
59 #include <linux/version.h>
60 #include <linux/module.h>
61
62 #include <linux/errno.h>
63 #include <linux/interrupt.h>
64 #include <linux/fs.h>
65 #include <linux/kernel.h>
66 #include <linux/cdrom.h>
67 #include <linux/ioport.h>
68 #include <linux/mm.h>
69 #include <linux/slab.h>
70 #include <linux/init.h>
71 #include <asm/io.h>
72 #include <asm/current.h>
73 #include <asm/uaccess.h>
74
75 #include <linux/major.h>
76 #define MAJOR_NR MITSUMI_X_CDROM_MAJOR
77 #include <linux/blkdev.h>
78 #include <linux/devfs_fs_kernel.h>
79
80 /* for compatible parameter passing with "insmod" */
81 #define mcdx_drive_map mcdx
82 #include "mcdx.h"
83
84 #ifndef HZ
85 #error HZ not defined
86 #endif
87
88 #define xwarn(fmt, args...) printk(KERN_WARNING MCDX " " fmt, ## args)
89
90 #if !MCDX_QUIET
91 #define xinfo(fmt, args...) printk(KERN_INFO MCDX " " fmt, ## args)
92 #else
93 #define xinfo(fmt, args...) { ; }
94 #endif
95
96 #if MCDX_DEBUG
97 #define xtrace(lvl, fmt, args...) \
98 { if (lvl > 0) \
99 { printk(KERN_DEBUG MCDX ":: " fmt, ## args); } }
100 #define xdebug(fmt, args...) printk(KERN_DEBUG MCDX ":: " fmt, ## args)
101 #else
102 #define xtrace(lvl, fmt, args...) { ; }
103 #define xdebug(fmt, args...) { ; }
104 #endif
105
106 /* CONSTANTS *******************************************************/
107
108 /* Following are the number of sectors we _request_ from the drive
109 every time an access outside the already requested range is done.
110 The _direct_ size is the number of sectors we're allowed to skip
111 directly (performing a read instead of requesting the new sector
112 needed */
113 const int REQUEST_SIZE = 800; /* should be less then 255 * 4 */
114 const int DIRECT_SIZE = 400; /* should be less then REQUEST_SIZE */
115
116 enum drivemodes { TOC, DATA, RAW, COOKED };
117 enum datamodes { MODE0, MODE1, MODE2 };
118 enum resetmodes { SOFT, HARD };
119
120 const int SINGLE = 0x01; /* single speed drive (FX001S, LU) */
121 const int DOUBLE = 0x02; /* double speed drive (FX001D, ..? */
122 const int DOOR = 0x04; /* door locking capability */
123 const int MULTI = 0x08; /* multi session capability */
124
125 const unsigned char READ1X = 0xc0;
126 const unsigned char READ2X = 0xc1;
127
128
129 /* DECLARATIONS ****************************************************/
130 struct s_subqcode {
131 unsigned char control;
132 unsigned char tno;
133 unsigned char index;
134 struct cdrom_msf0 tt;
135 struct cdrom_msf0 dt;
136 };
137
138 struct s_diskinfo {
139 unsigned int n_first;
140 unsigned int n_last;
141 struct cdrom_msf0 msf_leadout;
142 struct cdrom_msf0 msf_first;
143 };
144
145 struct s_multi {
146 unsigned char multi;
147 struct cdrom_msf0 msf_last;
148 };
149
150 struct s_version {
151 unsigned char code;
152 unsigned char ver;
153 };
154
155 /* Per drive/controller stuff **************************************/
156
157 struct s_drive_stuff {
158 /* waitqueues */
159 wait_queue_head_t busyq;
160 wait_queue_head_t lockq;
161 wait_queue_head_t sleepq;
162
163 /* flags */
164 volatile int introk; /* status of last irq operation */
165 volatile int busy; /* drive performs an operation */
166 volatile int lock; /* exclusive usage */
167
168 /* cd infos */
169 struct s_diskinfo di;
170 struct s_multi multi;
171 struct s_subqcode *toc; /* first entry of the toc array */
172 struct s_subqcode start;
173 struct s_subqcode stop;
174 int xa; /* 1 if xa disk */
175 int audio; /* 1 if audio disk */
176 int audiostatus;
177
178 /* `buffer' control */
179 volatile int valid; /* pending, ..., values are valid */
180 volatile int pending; /* next sector to be read */
181 volatile int low_border; /* first sector not to be skipped direct */
182 volatile int high_border; /* first sector `out of area' */
183 #ifdef AK2
184 volatile int int_err;
185 #endif /* AK2 */
186
187 /* adds and odds */
188 unsigned wreg_data; /* w data */
189 unsigned wreg_reset; /* w hardware reset */
190 unsigned wreg_hcon; /* w hardware conf */
191 unsigned wreg_chn; /* w channel */
192 unsigned rreg_data; /* r data */
193 unsigned rreg_status; /* r status */
194
195 int irq; /* irq used by this drive */
196 int present; /* drive present and its capabilities */
197 unsigned char readcmd; /* read cmd depends on single/double speed */
198 unsigned char playcmd; /* play should always be single speed */
199 unsigned int xxx; /* set if changed, reset while open */
200 unsigned int yyy; /* set if changed, reset by media_changed */
201 int users; /* keeps track of open/close */
202 int lastsector; /* last block accessible */
203 int status; /* last operation's error / status */
204 int readerrs; /* # of blocks read w/o error */
205 struct cdrom_device_info info;
206 struct gendisk *disk;
207 };
208
209
210 /* Prototypes ******************************************************/
211
212 /* The following prototypes are already declared elsewhere. They are
213 repeated here to show what's going on. And to sense, if they're
214 changed elsewhere. */
215
216 /* declared in blk.h */
217 int mcdx_init(void);
218 void do_mcdx_request(request_queue_t * q);
219
220 static int mcdx_block_open(struct inode *inode, struct file *file)
221 {
222 struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
223 return cdrom_open(&p->info, inode, file);
224 }
225
226 static int mcdx_block_release(struct inode *inode, struct file *file)
227 {
228 struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
229 return cdrom_release(&p->info, file);
230 }
231
232 static int mcdx_block_ioctl(struct inode *inode, struct file *file,
233 unsigned cmd, unsigned long arg)
234 {
235 struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
236 return cdrom_ioctl(file, &p->info, inode, cmd, arg);
237 }
238
239 static int mcdx_block_media_changed(struct gendisk *disk)
240 {
241 struct s_drive_stuff *p = disk->private_data;
242 return cdrom_media_changed(&p->info);
243 }
244
245 static struct block_device_operations mcdx_bdops =
246 {
247 .owner = THIS_MODULE,
248 .open = mcdx_block_open,
249 .release = mcdx_block_release,
250 .ioctl = mcdx_block_ioctl,
251 .media_changed = mcdx_block_media_changed,
252 };
253
254
255 /* Indirect exported functions. These functions are exported by their
256 addresses, such as mcdx_open and mcdx_close in the
257 structure mcdx_dops. */
258
259 /* exported by file_ops */
260 static int mcdx_open(struct cdrom_device_info *cdi, int purpose);
261 static void mcdx_close(struct cdrom_device_info *cdi);
262 static int mcdx_media_changed(struct cdrom_device_info *cdi, int disc_nr);
263 static int mcdx_tray_move(struct cdrom_device_info *cdi, int position);
264 static int mcdx_lockdoor(struct cdrom_device_info *cdi, int lock);
265 static int mcdx_audio_ioctl(struct cdrom_device_info *cdi,
266 unsigned int cmd, void *arg);
267
268 /* misc internal support functions */
269 static void log2msf(unsigned int, struct cdrom_msf0 *);
270 static unsigned int msf2log(const struct cdrom_msf0 *);
271 static unsigned int uint2bcd(unsigned int);
272 static unsigned int bcd2uint(unsigned char);
273 static unsigned port(int *);
274 static int irq(int *);
275 static void mcdx_delay(struct s_drive_stuff *, long jifs);
276 static int mcdx_transfer(struct s_drive_stuff *, char *buf, int sector,
277 int nr_sectors);
278 static int mcdx_xfer(struct s_drive_stuff *, char *buf, int sector,
279 int nr_sectors);
280
281 static int mcdx_config(struct s_drive_stuff *, int);
282 static int mcdx_requestversion(struct s_drive_stuff *, struct s_version *,
283 int);
284 static int mcdx_stop(struct s_drive_stuff *, int);
285 static int mcdx_hold(struct s_drive_stuff *, int);
286 static int mcdx_reset(struct s_drive_stuff *, enum resetmodes, int);
287 static int mcdx_setdrivemode(struct s_drive_stuff *, enum drivemodes, int);
288 static int mcdx_setdatamode(struct s_drive_stuff *, enum datamodes, int);
289 static int mcdx_requestsubqcode(struct s_drive_stuff *,
290 struct s_subqcode *, int);
291 static int mcdx_requestmultidiskinfo(struct s_drive_stuff *,
292 struct s_multi *, int);
293 static int mcdx_requesttocdata(struct s_drive_stuff *, struct s_diskinfo *,
294 int);
295 static int mcdx_getstatus(struct s_drive_stuff *, int);
296 static int mcdx_getval(struct s_drive_stuff *, int to, int delay, char *);
297 static int mcdx_talk(struct s_drive_stuff *,
298 const unsigned char *cmd, size_t,
299 void *buffer, size_t size, unsigned int timeout, int);
300 static int mcdx_readtoc(struct s_drive_stuff *);
301 static int mcdx_playtrk(struct s_drive_stuff *, const struct cdrom_ti *);
302 static int mcdx_playmsf(struct s_drive_stuff *, const struct cdrom_msf *);
303 static int mcdx_setattentuator(struct s_drive_stuff *,
304 struct cdrom_volctrl *, int);
305
306 /* static variables ************************************************/
307
308 static int mcdx_drive_map[][2] = MCDX_DRIVEMAP;
309 static struct s_drive_stuff *mcdx_stuffp[MCDX_NDRIVES];
310 static spinlock_t mcdx_lock = SPIN_LOCK_UNLOCKED;
311 static struct request_queue *mcdx_queue;
312 MODULE_PARM(mcdx, "1-4i");
313
314 static struct cdrom_device_ops mcdx_dops = {
315 .open = mcdx_open,
316 .release = mcdx_close,
317 .media_changed = mcdx_media_changed,
318 .tray_move = mcdx_tray_move,
319 .lock_door = mcdx_lockdoor,
320 .audio_ioctl = mcdx_audio_ioctl,
321 .capability = CDC_OPEN_TRAY | CDC_LOCK | CDC_MEDIA_CHANGED |
322 CDC_PLAY_AUDIO | CDC_DRIVE_STATUS,
323 };
324
325 /* KERNEL INTERFACE FUNCTIONS **************************************/
326
327
328 static int mcdx_audio_ioctl(struct cdrom_device_info *cdi,
329 unsigned int cmd, void *arg)
330 {
331 struct s_drive_stuff *stuffp = cdi->handle;
332
333 if (!stuffp->present)
334 return -ENXIO;
335
336 if (stuffp->xxx) {
337 if (-1 == mcdx_requesttocdata(stuffp, &stuffp->di, 1)) {
338 stuffp->lastsector = -1;
339 } else {
340 stuffp->lastsector = (CD_FRAMESIZE / 512)
341 * msf2log(&stuffp->di.msf_leadout) - 1;
342 }
343
344 if (stuffp->toc) {
345 kfree(stuffp->toc);
346 stuffp->toc = NULL;
347 if (-1 == mcdx_readtoc(stuffp))
348 return -1;
349 }
350
351 stuffp->xxx = 0;
352 }
353
354 switch (cmd) {
355 case CDROMSTART:{
356 xtrace(IOCTL, "ioctl() START\n");
357 /* Spin up the drive. Don't think we can do this.
358 * For now, ignore it.
359 */
360 return 0;
361 }
362
363 case CDROMSTOP:{
364 xtrace(IOCTL, "ioctl() STOP\n");
365 stuffp->audiostatus = CDROM_AUDIO_INVALID;
366 if (-1 == mcdx_stop(stuffp, 1))
367 return -EIO;
368 return 0;
369 }
370
371 case CDROMPLAYTRKIND:{
372 struct cdrom_ti *ti = (struct cdrom_ti *) arg;
373
374 xtrace(IOCTL, "ioctl() PLAYTRKIND\n");
375 if ((ti->cdti_trk0 < stuffp->di.n_first)
376 || (ti->cdti_trk0 > stuffp->di.n_last)
377 || (ti->cdti_trk1 < stuffp->di.n_first))
378 return -EINVAL;
379 if (ti->cdti_trk1 > stuffp->di.n_last)
380 ti->cdti_trk1 = stuffp->di.n_last;
381 xtrace(PLAYTRK, "ioctl() track %d to %d\n",
382 ti->cdti_trk0, ti->cdti_trk1);
383 return mcdx_playtrk(stuffp, ti);
384 }
385
386 case CDROMPLAYMSF:{
387 struct cdrom_msf *msf = (struct cdrom_msf *) arg;
388
389 xtrace(IOCTL, "ioctl() PLAYMSF\n");
390
391 if ((stuffp->audiostatus == CDROM_AUDIO_PLAY)
392 && (-1 == mcdx_hold(stuffp, 1)))
393 return -EIO;
394
395 msf->cdmsf_min0 = uint2bcd(msf->cdmsf_min0);
396 msf->cdmsf_sec0 = uint2bcd(msf->cdmsf_sec0);
397 msf->cdmsf_frame0 = uint2bcd(msf->cdmsf_frame0);
398
399 msf->cdmsf_min1 = uint2bcd(msf->cdmsf_min1);
400 msf->cdmsf_sec1 = uint2bcd(msf->cdmsf_sec1);
401 msf->cdmsf_frame1 = uint2bcd(msf->cdmsf_frame1);
402
403 stuffp->stop.dt.minute = msf->cdmsf_min1;
404 stuffp->stop.dt.second = msf->cdmsf_sec1;
405 stuffp->stop.dt.frame = msf->cdmsf_frame1;
406
407 return mcdx_playmsf(stuffp, msf);
408 }
409
410 case CDROMRESUME:{
411 xtrace(IOCTL, "ioctl() RESUME\n");
412 return mcdx_playtrk(stuffp, NULL);
413 }
414
415 case CDROMREADTOCENTRY:{
416 struct cdrom_tocentry *entry =
417 (struct cdrom_tocentry *) arg;
418 struct s_subqcode *tp = NULL;
419 xtrace(IOCTL, "ioctl() READTOCENTRY\n");
420
421 if (-1 == mcdx_readtoc(stuffp))
422 return -1;
423 if (entry->cdte_track == CDROM_LEADOUT)
424 tp = &stuffp->toc[stuffp->di.n_last -
425 stuffp->di.n_first + 1];
426 else if (entry->cdte_track > stuffp->di.n_last
427 || entry->cdte_track < stuffp->di.n_first)
428 return -EINVAL;
429 else
430 tp = &stuffp->toc[entry->cdte_track -
431 stuffp->di.n_first];
432
433 if (NULL == tp)
434 return -EIO;
435 entry->cdte_adr = tp->control;
436 entry->cdte_ctrl = tp->control >> 4;
437 /* Always return stuff in MSF, and let the Uniform cdrom driver
438 worry about what the user actually wants */
439 entry->cdte_addr.msf.minute =
440 bcd2uint(tp->dt.minute);
441 entry->cdte_addr.msf.second =
442 bcd2uint(tp->dt.second);
443 entry->cdte_addr.msf.frame =
444 bcd2uint(tp->dt.frame);
445 return 0;
446 }
447
448 case CDROMSUBCHNL:{
449 struct cdrom_subchnl *sub =
450 (struct cdrom_subchnl *) arg;
451 struct s_subqcode q;
452
453 xtrace(IOCTL, "ioctl() SUBCHNL\n");
454
455 if (-1 == mcdx_requestsubqcode(stuffp, &q, 2))
456 return -EIO;
457
458 xtrace(SUBCHNL, "audiostatus: %x\n",
459 stuffp->audiostatus);
460 sub->cdsc_audiostatus = stuffp->audiostatus;
461 sub->cdsc_adr = q.control;
462 sub->cdsc_ctrl = q.control >> 4;
463 sub->cdsc_trk = bcd2uint(q.tno);
464 sub->cdsc_ind = bcd2uint(q.index);
465
466 xtrace(SUBCHNL, "trk %d, ind %d\n",
467 sub->cdsc_trk, sub->cdsc_ind);
468 /* Always return stuff in MSF, and let the Uniform cdrom driver
469 worry about what the user actually wants */
470 sub->cdsc_absaddr.msf.minute =
471 bcd2uint(q.dt.minute);
472 sub->cdsc_absaddr.msf.second =
473 bcd2uint(q.dt.second);
474 sub->cdsc_absaddr.msf.frame = bcd2uint(q.dt.frame);
475 sub->cdsc_reladdr.msf.minute =
476 bcd2uint(q.tt.minute);
477 sub->cdsc_reladdr.msf.second =
478 bcd2uint(q.tt.second);
479 sub->cdsc_reladdr.msf.frame = bcd2uint(q.tt.frame);
480 xtrace(SUBCHNL,
481 "msf: abs %02d:%02d:%02d, rel %02d:%02d:%02d\n",
482 sub->cdsc_absaddr.msf.minute,
483 sub->cdsc_absaddr.msf.second,
484 sub->cdsc_absaddr.msf.frame,
485 sub->cdsc_reladdr.msf.minute,
486 sub->cdsc_reladdr.msf.second,
487 sub->cdsc_reladdr.msf.frame);
488
489 return 0;
490 }
491
492 case CDROMREADTOCHDR:{
493 struct cdrom_tochdr *toc =
494 (struct cdrom_tochdr *) arg;
495
496 xtrace(IOCTL, "ioctl() READTOCHDR\n");
497 toc->cdth_trk0 = stuffp->di.n_first;
498 toc->cdth_trk1 = stuffp->di.n_last;
499 xtrace(TOCHDR,
500 "ioctl() track0 = %d, track1 = %d\n",
501 stuffp->di.n_first, stuffp->di.n_last);
502 return 0;
503 }
504
505 case CDROMPAUSE:{
506 xtrace(IOCTL, "ioctl() PAUSE\n");
507 if (stuffp->audiostatus != CDROM_AUDIO_PLAY)
508 return -EINVAL;
509 if (-1 == mcdx_stop(stuffp, 1))
510 return -EIO;
511 stuffp->audiostatus = CDROM_AUDIO_PAUSED;
512 if (-1 ==
513 mcdx_requestsubqcode(stuffp, &stuffp->start,
514 1))
515 return -EIO;
516 return 0;
517 }
518
519 case CDROMMULTISESSION:{
520 struct cdrom_multisession *ms =
521 (struct cdrom_multisession *) arg;
522 xtrace(IOCTL, "ioctl() MULTISESSION\n");
523 /* Always return stuff in LBA, and let the Uniform cdrom driver
524 worry about what the user actually wants */
525 ms->addr.lba = msf2log(&stuffp->multi.msf_last);
526 ms->xa_flag = !!stuffp->multi.multi;
527 xtrace(MS,
528 "ioctl() (%d, 0x%08x [%02x:%02x.%02x])\n",
529 ms->xa_flag, ms->addr.lba,
530 stuffp->multi.msf_last.minute,
531 stuffp->multi.msf_last.second,
532 stuffp->multi.msf_last.frame);
533
534 return 0;
535 }
536
537 case CDROMEJECT:{
538 xtrace(IOCTL, "ioctl() EJECT\n");
539 if (stuffp->users > 1)
540 return -EBUSY;
541 return (mcdx_tray_move(cdi, 1));
542 }
543
544 case CDROMCLOSETRAY:{
545 xtrace(IOCTL, "ioctl() CDROMCLOSETRAY\n");
546 return (mcdx_tray_move(cdi, 0));
547 }
548
549 case CDROMVOLCTRL:{
550 struct cdrom_volctrl *volctrl =
551 (struct cdrom_volctrl *) arg;
552 xtrace(IOCTL, "ioctl() VOLCTRL\n");
553
554 #if 0 /* not tested! */
555 /* adjust for the weirdness of workman (md) */
556 /* can't test it (hs) */
557 volctrl.channel2 = volctrl.channel1;
558 volctrl.channel1 = volctrl.channel3 = 0x00;
559 #endif
560 return mcdx_setattentuator(stuffp, volctrl, 2);
561 }
562
563 default:
564 return -EINVAL;
565 }
566 }
567
568 void do_mcdx_request(request_queue_t * q)
569 {
570 struct s_drive_stuff *stuffp;
571 struct request *req;
572
573 again:
574
575 req = elv_next_request(q);
576 if (!req)
577 return;
578
579 stuffp = req->rq_disk->private_data;
580
581 if (!stuffp->present) {
582 xwarn("do_request(): bad device: %s\n",req->rq_disk->disk_name);
583 xtrace(REQUEST, "end_request(0): bad device\n");
584 end_request(req, 0);
585 return;
586 }
587
588 if (stuffp->audio) {
589 xwarn("do_request() attempt to read from audio cd\n");
590 xtrace(REQUEST, "end_request(0): read from audio\n");
591 end_request(req, 0);
592 return;
593 }
594
595 xtrace(REQUEST, "do_request() (%lu + %lu)\n",
596 req->sector, req->nr_sectors);
597
598 if (req->cmd != READ) {
599 xwarn("do_request(): non-read command to cd!!\n");
600 xtrace(REQUEST, "end_request(0): write\n");
601 end_request(req, 0);
602 return;
603 }
604 else {
605 stuffp->status = 0;
606 while (req->nr_sectors) {
607 int i;
608
609 i = mcdx_transfer(stuffp,
610 req->buffer,
611 req->sector,
612 req->nr_sectors);
613
614 if (i == -1) {
615 end_request(req, 0);
616 goto again;
617 }
618 req->sector += i;
619 req->nr_sectors -= i;
620 req->buffer += (i * 512);
621 }
622 end_request(req, 1);
623 goto again;
624
625 xtrace(REQUEST, "end_request(1)\n");
626 end_request(req, 1);
627 }
628
629 goto again;
630 }
631
632 static int mcdx_open(struct cdrom_device_info *cdi, int purpose)
633 {
634 struct s_drive_stuff *stuffp;
635 xtrace(OPENCLOSE, "open()\n");
636 stuffp = cdi->handle;
637 if (!stuffp->present)
638 return -ENXIO;
639
640 /* Make the modules looking used ... (thanx bjorn).
641 * But we shouldn't forget to decrement the module counter
642 * on error return */
643
644 /* this is only done to test if the drive talks with us */
645 if (-1 == mcdx_getstatus(stuffp, 1))
646 return -EIO;
647
648 if (stuffp->xxx) {
649
650 xtrace(OPENCLOSE, "open() media changed\n");
651 stuffp->audiostatus = CDROM_AUDIO_INVALID;
652 stuffp->readcmd = 0;
653 xtrace(OPENCLOSE, "open() Request multisession info\n");
654 if (-1 ==
655 mcdx_requestmultidiskinfo(stuffp, &stuffp->multi, 6))
656 xinfo("No multidiskinfo\n");
657 } else {
658 /* multisession ? */
659 if (!stuffp->multi.multi)
660 stuffp->multi.msf_last.second = 2;
661
662 xtrace(OPENCLOSE, "open() MS: %d, last @ %02x:%02x.%02x\n",
663 stuffp->multi.multi,
664 stuffp->multi.msf_last.minute,
665 stuffp->multi.msf_last.second,
666 stuffp->multi.msf_last.frame);
667
668 {;
669 } /* got multisession information */
670 /* request the disks table of contents (aka diskinfo) */
671 if (-1 == mcdx_requesttocdata(stuffp, &stuffp->di, 1)) {
672
673 stuffp->lastsector = -1;
674
675 } else {
676
677 stuffp->lastsector = (CD_FRAMESIZE / 512)
678 * msf2log(&stuffp->di.msf_leadout) - 1;
679
680 xtrace(OPENCLOSE,
681 "open() start %d (%02x:%02x.%02x) %d\n",
682 stuffp->di.n_first,
683 stuffp->di.msf_first.minute,
684 stuffp->di.msf_first.second,
685 stuffp->di.msf_first.frame,
686 msf2log(&stuffp->di.msf_first));
687 xtrace(OPENCLOSE,
688 "open() last %d (%02x:%02x.%02x) %d\n",
689 stuffp->di.n_last,
690 stuffp->di.msf_leadout.minute,
691 stuffp->di.msf_leadout.second,
692 stuffp->di.msf_leadout.frame,
693 msf2log(&stuffp->di.msf_leadout));
694 }
695
696 if (stuffp->toc) {
697 xtrace(MALLOC, "open() free old toc @ %p\n",
698 stuffp->toc);
699 kfree(stuffp->toc);
700
701 stuffp->toc = NULL;
702 }
703
704 xtrace(OPENCLOSE, "open() init irq generation\n");
705 if (-1 == mcdx_config(stuffp, 1))
706 return -EIO;
707 #if FALLBACK
708 /* Set the read speed */
709 xwarn("AAA %x AAA\n", stuffp->readcmd);
710 if (stuffp->readerrs)
711 stuffp->readcmd = READ1X;
712 else
713 stuffp->readcmd =
714 stuffp->present | SINGLE ? READ1X : READ2X;
715 xwarn("XXX %x XXX\n", stuffp->readcmd);
716 #else
717 stuffp->readcmd =
718 stuffp->present | SINGLE ? READ1X : READ2X;
719 #endif
720
721 /* try to get the first sector, iff any ... */
722 if (stuffp->lastsector >= 0) {
723 char buf[512];
724 int ans;
725 int tries;
726
727 stuffp->xa = 0;
728 stuffp->audio = 0;
729
730 for (tries = 6; tries; tries--) {
731
732 stuffp->introk = 1;
733
734 xtrace(OPENCLOSE, "open() try as %s\n",
735 stuffp->xa ? "XA" : "normal");
736 /* set data mode */
737 if (-1 == (ans = mcdx_setdatamode(stuffp,
738 stuffp->
739 xa ?
740 MODE2 :
741 MODE1,
742 1))) {
743 /* return -EIO; */
744 stuffp->xa = 0;
745 break;
746 }
747
748 if ((stuffp->audio = e_audio(ans)))
749 break;
750
751 while (0 ==
752 (ans =
753 mcdx_transfer(stuffp, buf, 0, 1)));
754
755 if (ans == 1)
756 break;
757 stuffp->xa = !stuffp->xa;
758 }
759 }
760 /* xa disks will be read in raw mode, others not */
761 if (-1 == mcdx_setdrivemode(stuffp,
762 stuffp->xa ? RAW : COOKED,
763 1))
764 return -EIO;
765 if (stuffp->audio) {
766 xinfo("open() audio disk found\n");
767 } else if (stuffp->lastsector >= 0) {
768 xinfo("open() %s%s disk found\n",
769 stuffp->xa ? "XA / " : "",
770 stuffp->multi.
771 multi ? "Multi Session" : "Single Session");
772 }
773 }
774 stuffp->xxx = 0;
775 stuffp->users++;
776 return 0;
777 }
778
779 static void mcdx_close(struct cdrom_device_info *cdi)
780 {
781 struct s_drive_stuff *stuffp;
782
783 xtrace(OPENCLOSE, "close()\n");
784
785 stuffp = cdi->handle;
786
787 --stuffp->users;
788 }
789
790 static int mcdx_media_changed(struct cdrom_device_info *cdi, int disc_nr)
791 /* Return: 1 if media changed since last call to this function
792 0 otherwise */
793 {
794 struct s_drive_stuff *stuffp;
795
796 xinfo("mcdx_media_changed called for device %s\n", cdi->name);
797
798 stuffp = cdi->handle;
799 mcdx_getstatus(stuffp, 1);
800
801 if (stuffp->yyy == 0)
802 return 0;
803
804 stuffp->yyy = 0;
805 return 1;
806 }
807
808 #ifndef MODULE
809 static int __init mcdx_setup(char *str)
810 {
811 int pi[4];
812 (void) get_options(str, ARRAY_SIZE(pi), pi);
813
814 if (pi[0] > 0)
815 mcdx_drive_map[0][0] = pi[1];
816 if (pi[0] > 1)
817 mcdx_drive_map[0][1] = pi[2];
818 return 1;
819 }
820
821 __setup("mcdx=", mcdx_setup);
822
823 #endif
824
825 /* DIRTY PART ******************************************************/
826
827 static void mcdx_delay(struct s_drive_stuff *stuff, long jifs)
828 /* This routine is used for sleeping.
829 * A jifs value <0 means NO sleeping,
830 * =0 means minimal sleeping (let the kernel
831 * run for other processes)
832 * >0 means at least sleep for that amount.
833 * May be we could use a simple count loop w/ jumps to itself, but
834 * I wanna make this independent of cpu speed. [1 jiffy is 1/HZ] sec */
835 {
836 if (jifs < 0)
837 return;
838
839 xtrace(SLEEP, "*** delay: sleepq\n");
840 interruptible_sleep_on_timeout(&stuff->sleepq, jifs);
841 xtrace(SLEEP, "delay awoken\n");
842 if (signal_pending(current)) {
843 xtrace(SLEEP, "got signal\n");
844 }
845 }
846
847 static irqreturn_t mcdx_intr(int irq, void *dev_id, struct pt_regs *regs)
848 {
849 struct s_drive_stuff *stuffp = dev_id;
850 unsigned char b;
851
852 if (stuffp == NULL) {
853 xwarn("mcdx: no device for intr %d\n", irq);
854 return IRQ_NONE;
855 }
856 #ifdef AK2
857 if (!stuffp->busy && stuffp->pending)
858 stuffp->int_err = 1;
859
860 #endif /* AK2 */
861 /* get the interrupt status */
862 b = inb(stuffp->rreg_status);
863 stuffp->introk = ~b & MCDX_RBIT_DTEN;
864
865 /* NOTE: We only should get interrupts if the data we
866 * requested are ready to transfer.
867 * But the drive seems to generate ``asynchronous'' interrupts
868 * on several error conditions too. (Despite the err int enable
869 * setting during initialisation) */
870
871 /* if not ok, read the next byte as the drives status */
872 if (!stuffp->introk) {
873 xtrace(IRQ, "intr() irq %d hw status 0x%02x\n", irq, b);
874 if (~b & MCDX_RBIT_STEN) {
875 xinfo("intr() irq %d status 0x%02x\n",
876 irq, inb(stuffp->rreg_data));
877 } else {
878 xinfo("intr() irq %d ambiguous hw status\n", irq);
879 }
880 } else {
881 xtrace(IRQ, "irq() irq %d ok, status %02x\n", irq, b);
882 }
883
884 stuffp->busy = 0;
885 wake_up_interruptible(&stuffp->busyq);
886 return IRQ_HANDLED;
887 }
888
889
890 static int mcdx_talk(struct s_drive_stuff *stuffp,
891 const unsigned char *cmd, size_t cmdlen,
892 void *buffer, size_t size, unsigned int timeout, int tries)
893 /* Send a command to the drive, wait for the result.
894 * returns -1 on timeout, drive status otherwise
895 * If buffer is not zero, the result (length size) is stored there.
896 * If buffer is zero the size should be the number of bytes to read
897 * from the drive. These bytes are discarded.
898 */
899 {
900 int st;
901 char c;
902 int discard;
903
904 /* Somebody wants the data read? */
905 if ((discard = (buffer == NULL)))
906 buffer = &c;
907
908 while (stuffp->lock) {
909 xtrace(SLEEP, "*** talk: lockq\n");
910 interruptible_sleep_on(&stuffp->lockq);
911 xtrace(SLEEP, "talk: awoken\n");
912 }
913
914 stuffp->lock = 1;
915
916 /* An operation other then reading data destroys the
917 * data already requested and remembered in stuffp->request, ... */
918 stuffp->valid = 0;
919
920 #if MCDX_DEBUG & TALK
921 {
922 unsigned char i;
923 xtrace(TALK,
924 "talk() %d / %d tries, res.size %d, command 0x%02x",
925 tries, timeout, size, (unsigned char) cmd[0]);
926 for (i = 1; i < cmdlen; i++)
927 xtrace(TALK, " 0x%02x", cmd[i]);
928 xtrace(TALK, "\n");
929 }
930 #endif
931
932 /* give up if all tries are done (bad) or if the status
933 * st != -1 (good) */
934 for (st = -1; st == -1 && tries; tries--) {
935
936 char *bp = (char *) buffer;
937 size_t sz = size;
938
939 outsb(stuffp->wreg_data, cmd, cmdlen);
940 xtrace(TALK, "talk() command sent\n");
941
942 /* get the status byte */
943 if (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
944 xinfo("talk() %02x timed out (status), %d tr%s left\n",
945 cmd[0], tries - 1, tries == 2 ? "y" : "ies");
946 continue;
947 }
948 st = *bp;
949 sz--;
950 if (!discard)
951 bp++;
952
953 xtrace(TALK, "talk() got status 0x%02x\n", st);
954
955 /* command error? */
956 if (e_cmderr(st)) {
957 xwarn("command error cmd = %02x %s \n",
958 cmd[0], cmdlen > 1 ? "..." : "");
959 st = -1;
960 continue;
961 }
962
963 /* audio status? */
964 if (stuffp->audiostatus == CDROM_AUDIO_INVALID)
965 stuffp->audiostatus =
966 e_audiobusy(st) ? CDROM_AUDIO_PLAY :
967 CDROM_AUDIO_NO_STATUS;
968 else if (stuffp->audiostatus == CDROM_AUDIO_PLAY
969 && e_audiobusy(st) == 0)
970 stuffp->audiostatus = CDROM_AUDIO_COMPLETED;
971
972 /* media change? */
973 if (e_changed(st)) {
974 xinfo("talk() media changed\n");
975 stuffp->xxx = stuffp->yyy = 1;
976 }
977
978 /* now actually get the data */
979 while (sz--) {
980 if (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
981 xinfo("talk() %02x timed out (data), %d tr%s left\n",
982 cmd[0], tries - 1,
983 tries == 2 ? "y" : "ies");
984 st = -1;
985 break;
986 }
987 if (!discard)
988 bp++;
989 xtrace(TALK, "talk() got 0x%02x\n", *(bp - 1));
990 }
991 }
992
993 #if !MCDX_QUIET
994 if (!tries && st == -1)
995 xinfo("talk() giving up\n");
996 #endif
997
998 stuffp->lock = 0;
999 wake_up_interruptible(&stuffp->lockq);
1000
1001 xtrace(TALK, "talk() done with 0x%02x\n", st);
1002 return st;
1003 }
1004
1005 /* MODULE STUFF ***********************************************************/
1006
1007 int __mcdx_init(void)
1008 {
1009 int i;
1010 int drives = 0;
1011
1012 mcdx_init();
1013 for (i = 0; i < MCDX_NDRIVES; i++) {
1014 if (mcdx_stuffp[i]) {
1015 xtrace(INIT, "init_module() drive %d stuff @ %p\n",
1016 i, mcdx_stuffp[i]);
1017 drives++;
1018 }
1019 }
1020
1021 if (!drives)
1022 return -EIO;
1023
1024 return 0;
1025 }
1026
1027 void __exit mcdx_exit(void)
1028 {
1029 int i;
1030
1031 xinfo("cleanup_module called\n");
1032
1033 for (i = 0; i < MCDX_NDRIVES; i++) {
1034 struct s_drive_stuff *stuffp = mcdx_stuffp[i];
1035 if (!stuffp)
1036 continue;
1037 del_gendisk(stuffp->disk);
1038 if (unregister_cdrom(&stuffp->info)) {
1039 printk(KERN_WARNING "Can't unregister cdrom mcdx\n");
1040 continue;
1041 }
1042 put_disk(stuffp->disk);
1043 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1044 free_irq(stuffp->irq, NULL);
1045 if (stuffp->toc) {
1046 xtrace(MALLOC, "cleanup_module() free toc @ %p\n",
1047 stuffp->toc);
1048 kfree(stuffp->toc);
1049 }
1050 xtrace(MALLOC, "cleanup_module() free stuffp @ %p\n",
1051 stuffp);
1052 mcdx_stuffp[i] = NULL;
1053 kfree(stuffp);
1054 }
1055
1056 if (unregister_blkdev(MAJOR_NR, "mcdx") != 0) {
1057 xwarn("cleanup() unregister_blkdev() failed\n");
1058 }
1059 blk_cleanup_queue(mcdx_queue);
1060 #if !MCDX_QUIET
1061 else
1062 xinfo("cleanup() succeeded\n");
1063 #endif
1064 }
1065
1066 #ifdef MODULE
1067 module_init(__mcdx_init);
1068 #endif
1069 module_exit(mcdx_exit);
1070
1071
1072 /* Support functions ************************************************/
1073
1074 int __init mcdx_init_drive(int drive)
1075 {
1076 struct s_version version;
1077 struct gendisk *disk;
1078 struct s_drive_stuff *stuffp;
1079 int size = sizeof(*stuffp);
1080 char msg[80];
1081
1082 xtrace(INIT, "init() try drive %d\n", drive);
1083
1084 xtrace(INIT, "kmalloc space for stuffpt's\n");
1085 xtrace(MALLOC, "init() malloc %d bytes\n", size);
1086 if (!(stuffp = kmalloc(size, GFP_KERNEL))) {
1087 xwarn("init() malloc failed\n");
1088 return 1;
1089 }
1090
1091 disk = alloc_disk(1);
1092 if (!disk) {
1093 xwarn("init() malloc failed\n");
1094 kfree(stuffp);
1095 return 1;
1096 }
1097
1098 xtrace(INIT, "init() got %d bytes for drive stuff @ %p\n",
1099 sizeof(*stuffp), stuffp);
1100
1101 /* set default values */
1102 memset(stuffp, 0, sizeof(*stuffp));
1103
1104 stuffp->present = 0; /* this should be 0 already */
1105 stuffp->toc = NULL; /* this should be NULL already */
1106
1107 /* setup our irq and i/o addresses */
1108 stuffp->irq = irq(mcdx_drive_map[drive]);
1109 stuffp->wreg_data = stuffp->rreg_data = port(mcdx_drive_map[drive]);
1110 stuffp->wreg_reset = stuffp->rreg_status = stuffp->wreg_data + 1;
1111 stuffp->wreg_hcon = stuffp->wreg_reset + 1;
1112 stuffp->wreg_chn = stuffp->wreg_hcon + 1;
1113
1114 init_waitqueue_head(&stuffp->busyq);
1115 init_waitqueue_head(&stuffp->lockq);
1116 init_waitqueue_head(&stuffp->sleepq);
1117
1118 /* check if i/o addresses are available */
1119 if (!request_region(stuffp->wreg_data, MCDX_IO_SIZE, "mcdx")) {
1120 xwarn("0x%03x,%d: Init failed. "
1121 "I/O ports (0x%03x..0x%03x) already in use.\n",
1122 stuffp->wreg_data, stuffp->irq,
1123 stuffp->wreg_data,
1124 stuffp->wreg_data + MCDX_IO_SIZE - 1);
1125 xtrace(MALLOC, "init() free stuffp @ %p\n", stuffp);
1126 kfree(stuffp);
1127 put_disk(disk);
1128 xtrace(INIT, "init() continue at next drive\n");
1129 return 0; /* next drive */
1130 }
1131
1132 xtrace(INIT, "init() i/o port is available at 0x%03x\n"
1133 stuffp->wreg_data);
1134 xtrace(INIT, "init() hardware reset\n");
1135 mcdx_reset(stuffp, HARD, 1);
1136
1137 xtrace(INIT, "init() get version\n");
1138 if (-1 == mcdx_requestversion(stuffp, &version, 4)) {
1139 /* failed, next drive */
1140 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1141 xwarn("%s=0x%03x,%d: Init failed. Can't get version.\n",
1142 MCDX, stuffp->wreg_data, stuffp->irq);
1143 xtrace(MALLOC, "init() free stuffp @ %p\n", stuffp);
1144 kfree(stuffp);
1145 put_disk(disk);
1146 xtrace(INIT, "init() continue at next drive\n");
1147 return 0;
1148 }
1149
1150 switch (version.code) {
1151 case 'D':
1152 stuffp->readcmd = READ2X;
1153 stuffp->present = DOUBLE | DOOR | MULTI;
1154 break;
1155 case 'F':
1156 stuffp->readcmd = READ1X;
1157 stuffp->present = SINGLE | DOOR | MULTI;
1158 break;
1159 case 'M':
1160 stuffp->readcmd = READ1X;
1161 stuffp->present = SINGLE;
1162 break;
1163 default:
1164 stuffp->present = 0;
1165 break;
1166 }
1167
1168 stuffp->playcmd = READ1X;
1169
1170 if (!stuffp->present) {
1171 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1172 xwarn("%s=0x%03x,%d: Init failed. No Mitsumi CD-ROM?.\n",
1173 MCDX, stuffp->wreg_data, stuffp->irq);
1174 kfree(stuffp);
1175 put_disk(disk);
1176 return 0; /* next drive */
1177 }
1178
1179 xtrace(INIT, "init() register blkdev\n");
1180 if (register_blkdev(MAJOR_NR, "mcdx")) {
1181 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1182 kfree(stuffp);
1183 put_disk(disk);
1184 return 1;
1185 }
1186
1187 mcdx_queue = blk_init_queue(do_mcdx_request, &mcdx_lock);
1188 if (!mcdx_queue) {
1189 unregister_blkdev(MAJOR_NR, "mcdx");
1190 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1191 kfree(stuffp);
1192 put_disk(disk);
1193 return 1;
1194 }
1195
1196 xtrace(INIT, "init() subscribe irq and i/o\n");
1197 if (request_irq(stuffp->irq, mcdx_intr, SA_INTERRUPT, "mcdx", stuffp)) {
1198 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1199 xwarn("%s=0x%03x,%d: Init failed. Can't get irq (%d).\n",
1200 MCDX, stuffp->wreg_data, stuffp->irq, stuffp->irq);
1201 stuffp->irq = 0;
1202 blk_cleanup_queue(mcdx_queue);
1203 kfree(stuffp);
1204 put_disk(disk);
1205 return 0;
1206 }
1207
1208 xtrace(INIT, "init() get garbage\n");
1209 {
1210 int i;
1211 mcdx_delay(stuffp, HZ / 2);
1212 for (i = 100; i; i--)
1213 (void) inb(stuffp->rreg_status);
1214 }
1215
1216
1217 #if WE_KNOW_WHY
1218 /* irq 11 -> channel register */
1219 outb(0x50, stuffp->wreg_chn);
1220 #endif
1221
1222 xtrace(INIT, "init() set non dma but irq mode\n");
1223 mcdx_config(stuffp, 1);
1224
1225 stuffp->info.ops = &mcdx_dops;
1226 stuffp->info.speed = 2;
1227 stuffp->info.capacity = 1;
1228 stuffp->info.handle = stuffp;
1229 sprintf(stuffp->info.name, "mcdx%d", drive);
1230 disk->major = MAJOR_NR;
1231 disk->first_minor = drive;
1232 strcpy(disk->disk_name, stuffp->info.name);
1233 disk->fops = &mcdx_bdops;
1234 disk->flags = GENHD_FL_CD;
1235 stuffp->disk = disk;
1236
1237 sprintf(msg, " mcdx: Mitsumi CD-ROM installed at 0x%03x, irq %d."
1238 " (Firmware version %c %x)\n",
1239 stuffp->wreg_data, stuffp->irq, version.code, version.ver);
1240 mcdx_stuffp[drive] = stuffp;
1241 xtrace(INIT, "init() mcdx_stuffp[%d] = %p\n", drive, stuffp);
1242 if (register_cdrom(&stuffp->info) != 0) {
1243 printk("Cannot register Mitsumi CD-ROM!\n");
1244 free_irq(stuffp->irq, NULL);
1245 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1246 kfree(stuffp);
1247 put_disk(disk);
1248 if (unregister_blkdev(MAJOR_NR, "mcdx") != 0)
1249 xwarn("cleanup() unregister_blkdev() failed\n");
1250 blk_cleanup_queue(mcdx_queue);
1251 return 2;
1252 }
1253 disk->private_data = stuffp;
1254 disk->queue = mcdx_queue;
1255 add_disk(disk);
1256 printk(msg);
1257 return 0;
1258 }
1259
1260 int __init mcdx_init(void)
1261 {
1262 int drive;
1263 #ifdef MODULE
1264 xwarn("Version 2.14(hs) for " UTS_RELEASE "\n");
1265 #else
1266 xwarn("Version 2.14(hs) \n");
1267 #endif
1268
1269 xwarn("$Id: mcdx.c,v 1.21 1997/01/26 07:12:59 davem Exp $\n");
1270
1271 /* zero the pointer array */
1272 for (drive = 0; drive < MCDX_NDRIVES; drive++)
1273 mcdx_stuffp[drive] = NULL;
1274
1275 /* do the initialisation */
1276 for (drive = 0; drive < MCDX_NDRIVES; drive++) {
1277 switch (mcdx_init_drive(drive)) {
1278 case 2:
1279 return -EIO;
1280 case 1:
1281 break;
1282 }
1283 }
1284 return 0;
1285 }
1286
1287 static int mcdx_transfer(struct s_drive_stuff *stuffp,
1288 char *p, int sector, int nr_sectors)
1289 /* This seems to do the actually transfer. But it does more. It
1290 keeps track of errors occurred and will (if possible) fall back
1291 to single speed on error.
1292 Return: -1 on timeout or other error
1293 else status byte (as in stuff->st) */
1294 {
1295 int ans;
1296
1297 ans = mcdx_xfer(stuffp, p, sector, nr_sectors);
1298 return ans;
1299 #if FALLBACK
1300 if (-1 == ans)
1301 stuffp->readerrs++;
1302 else
1303 return ans;
1304
1305 if (stuffp->readerrs && stuffp->readcmd == READ1X) {
1306 xwarn("XXX Already reading 1x -- no chance\n");
1307 return -1;
1308 }
1309
1310 xwarn("XXX Fallback to 1x\n");
1311
1312 stuffp->readcmd = READ1X;
1313 return mcdx_transfer(stuffp, p, sector, nr_sectors);
1314 #endif
1315
1316 }
1317
1318
1319 static int mcdx_xfer(struct s_drive_stuff *stuffp,
1320 char *p, int sector, int nr_sectors)
1321 /* This does actually the transfer from the drive.
1322 Return: -1 on timeout or other error
1323 else status byte (as in stuff->st) */
1324 {
1325 int border;
1326 int done = 0;
1327 long timeout;
1328
1329 if (stuffp->audio) {
1330 xwarn("Attempt to read from audio CD.\n");
1331 return -1;
1332 }
1333
1334 if (!stuffp->readcmd) {
1335 xinfo("Can't transfer from missing disk.\n");
1336 return -1;
1337 }
1338
1339 while (stuffp->lock) {
1340 interruptible_sleep_on(&stuffp->lockq);
1341 }
1342
1343 if (stuffp->valid && (sector >= stuffp->pending)
1344 && (sector < stuffp->low_border)) {
1345
1346 /* All (or at least a part of the sectors requested) seems
1347 * to be already requested, so we don't need to bother the
1348 * drive with new requests ...
1349 * Wait for the drive become idle, but first
1350 * check for possible occurred errors --- the drive
1351 * seems to report them asynchronously */
1352
1353
1354 border = stuffp->high_border < (border =
1355 sector + nr_sectors)
1356 ? stuffp->high_border : border;
1357
1358 stuffp->lock = current->pid;
1359
1360 do {
1361
1362 while (stuffp->busy) {
1363
1364 timeout =
1365 interruptible_sleep_on_timeout
1366 (&stuffp->busyq, 5 * HZ);
1367
1368 if (!stuffp->introk) {
1369 xtrace(XFER,
1370 "error via interrupt\n");
1371 } else if (!timeout) {
1372 xtrace(XFER, "timeout\n");
1373 } else if (signal_pending(current)) {
1374 xtrace(XFER, "signal\n");
1375 } else
1376 continue;
1377
1378 stuffp->lock = 0;
1379 stuffp->busy = 0;
1380 stuffp->valid = 0;
1381
1382 wake_up_interruptible(&stuffp->lockq);
1383 xtrace(XFER, "transfer() done (-1)\n");
1384 return -1;
1385 }
1386
1387 /* check if we need to set the busy flag (as we
1388 * expect an interrupt */
1389 stuffp->busy = (3 == (stuffp->pending & 3));
1390
1391 /* Test if it's the first sector of a block,
1392 * there we have to skip some bytes as we read raw data */
1393 if (stuffp->xa && (0 == (stuffp->pending & 3))) {
1394 const int HEAD =
1395 CD_FRAMESIZE_RAW - CD_XA_TAIL -
1396 CD_FRAMESIZE;
1397 insb(stuffp->rreg_data, p, HEAD);
1398 }
1399
1400 /* now actually read the data */
1401 insb(stuffp->rreg_data, p, 512);
1402
1403 /* test if it's the last sector of a block,
1404 * if so, we have to handle XA special */
1405 if ((3 == (stuffp->pending & 3)) && stuffp->xa) {
1406 char dummy[CD_XA_TAIL];
1407 insb(stuffp->rreg_data, &dummy[0], CD_XA_TAIL);
1408 }
1409
1410 if (stuffp->pending == sector) {
1411 p += 512;
1412 done++;
1413 sector++;
1414 }
1415 } while (++(stuffp->pending) < border);
1416
1417 stuffp->lock = 0;
1418 wake_up_interruptible(&stuffp->lockq);
1419
1420 } else {
1421
1422 /* The requested sector(s) is/are out of the
1423 * already requested range, so we have to bother the drive
1424 * with a new request. */
1425
1426 static unsigned char cmd[] = {
1427 0,
1428 0, 0, 0,
1429 0, 0, 0
1430 };
1431
1432 cmd[0] = stuffp->readcmd;
1433
1434 /* The numbers held in ->pending, ..., should be valid */
1435 stuffp->valid = 1;
1436 stuffp->pending = sector & ~3;
1437
1438 /* do some sanity checks */
1439 if (stuffp->pending > stuffp->lastsector) {
1440 xwarn
1441 ("transfer() sector %d from nirvana requested.\n",
1442 stuffp->pending);
1443 stuffp->status = MCDX_ST_EOM;
1444 stuffp->valid = 0;
1445 xtrace(XFER, "transfer() done (-1)\n");
1446 return -1;
1447 }
1448
1449 if ((stuffp->low_border = stuffp->pending + DIRECT_SIZE)
1450 > stuffp->lastsector + 1) {
1451 xtrace(XFER, "cut low_border\n");
1452 stuffp->low_border = stuffp->lastsector + 1;
1453 }
1454 if ((stuffp->high_border = stuffp->pending + REQUEST_SIZE)
1455 > stuffp->lastsector + 1) {
1456 xtrace(XFER, "cut high_border\n");
1457 stuffp->high_border = stuffp->lastsector + 1;
1458 }
1459
1460 { /* Convert the sector to be requested to MSF format */
1461 struct cdrom_msf0 pending;
1462 log2msf(stuffp->pending / 4, &pending);
1463 cmd[1] = pending.minute;
1464 cmd[2] = pending.second;
1465 cmd[3] = pending.frame;
1466 }
1467
1468 cmd[6] =
1469 (unsigned
1470 char) ((stuffp->high_border - stuffp->pending) / 4);
1471 xtrace(XFER, "[%2d]\n", cmd[6]);
1472
1473 stuffp->busy = 1;
1474 /* Now really issue the request command */
1475 outsb(stuffp->wreg_data, cmd, sizeof cmd);
1476
1477 }
1478 #ifdef AK2
1479 if (stuffp->int_err) {
1480 stuffp->valid = 0;
1481 stuffp->int_err = 0;
1482 return -1;
1483 }
1484 #endif /* AK2 */
1485
1486 stuffp->low_border = (stuffp->low_border +=
1487 done) <
1488 stuffp->high_border ? stuffp->low_border : stuffp->high_border;
1489
1490 return done;
1491 }
1492
1493
1494 /* Access to elements of the mcdx_drive_map members */
1495
1496 static unsigned port(int *ip)
1497 {
1498 return ip[0];
1499 }
1500 static int irq(int *ip)
1501 {
1502 return ip[1];
1503 }
1504
1505 /* Misc number converters */
1506
1507 static unsigned int bcd2uint(unsigned char c)
1508 {
1509 return (c >> 4) * 10 + (c & 0x0f);
1510 }
1511
1512 static unsigned int uint2bcd(unsigned int ival)
1513 {
1514 return ((ival / 10) << 4) | (ival % 10);
1515 }
1516
1517 static void log2msf(unsigned int l, struct cdrom_msf0 *pmsf)
1518 {
1519 l += CD_MSF_OFFSET;
1520 pmsf->minute = uint2bcd(l / 4500), l %= 4500;
1521 pmsf->second = uint2bcd(l / 75);
1522 pmsf->frame = uint2bcd(l % 75);
1523 }
1524
1525 static unsigned int msf2log(const struct cdrom_msf0 *pmsf)
1526 {
1527 return bcd2uint(pmsf->frame)
1528 + bcd2uint(pmsf->second) * 75
1529 + bcd2uint(pmsf->minute) * 4500 - CD_MSF_OFFSET;
1530 }
1531
1532 int mcdx_readtoc(struct s_drive_stuff *stuffp)
1533 /* Read the toc entries from the CD,
1534 * Return: -1 on failure, else 0 */
1535 {
1536
1537 if (stuffp->toc) {
1538 xtrace(READTOC, "ioctl() toc already read\n");
1539 return 0;
1540 }
1541
1542 xtrace(READTOC, "ioctl() readtoc for %d tracks\n",
1543 stuffp->di.n_last - stuffp->di.n_first + 1);
1544
1545 if (-1 == mcdx_hold(stuffp, 1))
1546 return -1;
1547
1548 xtrace(READTOC, "ioctl() tocmode\n");
1549 if (-1 == mcdx_setdrivemode(stuffp, TOC, 1))
1550 return -EIO;
1551
1552 /* all seems to be ok so far ... malloc */
1553 {
1554 int size;
1555 size =
1556 sizeof(struct s_subqcode) * (stuffp->di.n_last -
1557 stuffp->di.n_first + 2);
1558
1559 xtrace(MALLOC, "ioctl() malloc %d bytes\n", size);
1560 stuffp->toc = kmalloc(size, GFP_KERNEL);
1561 if (!stuffp->toc) {
1562 xwarn("Cannot malloc %d bytes for toc\n", size);
1563 mcdx_setdrivemode(stuffp, DATA, 1);
1564 return -EIO;
1565 }
1566 }
1567
1568 /* now read actually the index */
1569 {
1570 int trk;
1571 int retries;
1572
1573 for (trk = 0;
1574 trk < (stuffp->di.n_last - stuffp->di.n_first + 1);
1575 trk++)
1576 stuffp->toc[trk].index = 0;
1577
1578 for (retries = 300; retries; retries--) { /* why 300? */
1579 struct s_subqcode q;
1580 unsigned int idx;
1581
1582 if (-1 == mcdx_requestsubqcode(stuffp, &q, 1)) {
1583 mcdx_setdrivemode(stuffp, DATA, 1);
1584 return -EIO;
1585 }
1586
1587 idx = bcd2uint(q.index);
1588
1589 if ((idx > 0)
1590 && (idx <= stuffp->di.n_last)
1591 && (q.tno == 0)
1592 && (stuffp->toc[idx - stuffp->di.n_first].
1593 index == 0)) {
1594 stuffp->toc[idx - stuffp->di.n_first] = q;
1595 xtrace(READTOC,
1596 "ioctl() toc idx %d (trk %d)\n",
1597 idx, trk);
1598 trk--;
1599 }
1600 if (trk == 0)
1601 break;
1602 }
1603 memset(&stuffp->
1604 toc[stuffp->di.n_last - stuffp->di.n_first + 1], 0,
1605 sizeof(stuffp->toc[0]));
1606 stuffp->toc[stuffp->di.n_last - stuffp->di.n_first +
1607 1].dt = stuffp->di.msf_leadout;
1608 }
1609
1610 /* unset toc mode */
1611 xtrace(READTOC, "ioctl() undo toc mode\n");
1612 if (-1 == mcdx_setdrivemode(stuffp, DATA, 2))
1613 return -EIO;
1614
1615 #if MCDX_DEBUG && READTOC
1616 {
1617 int trk;
1618 for (trk = 0;
1619 trk < (stuffp->di.n_last - stuffp->di.n_first + 2);
1620 trk++)
1621 xtrace(READTOC, "ioctl() %d readtoc %02x %02x %02x"
1622 " %02x:%02x.%02x %02x:%02x.%02x\n",
1623 trk + stuffp->di.n_first,
1624 stuffp->toc[trk].control,
1625 stuffp->toc[trk].tno,
1626 stuffp->toc[trk].index,
1627 stuffp->toc[trk].tt.minute,
1628 stuffp->toc[trk].tt.second,
1629 stuffp->toc[trk].tt.frame,
1630 stuffp->toc[trk].dt.minute,
1631 stuffp->toc[trk].dt.second,
1632 stuffp->toc[trk].dt.frame);
1633 }
1634 #endif
1635
1636 return 0;
1637 }
1638
1639 static int
1640 mcdx_playmsf(struct s_drive_stuff *stuffp, const struct cdrom_msf *msf)
1641 {
1642 unsigned char cmd[7] = {
1643 0, 0, 0, 0, 0, 0, 0
1644 };
1645
1646 if (!stuffp->readcmd) {
1647 xinfo("Can't play from missing disk.\n");
1648 return -1;
1649 }
1650
1651 cmd[0] = stuffp->playcmd;
1652
1653 cmd[1] = msf->cdmsf_min0;
1654 cmd[2] = msf->cdmsf_sec0;
1655 cmd[3] = msf->cdmsf_frame0;
1656 cmd[4] = msf->cdmsf_min1;
1657 cmd[5] = msf->cdmsf_sec1;
1658 cmd[6] = msf->cdmsf_frame1;
1659
1660 xtrace(PLAYMSF, "ioctl(): play %x "
1661 "%02x:%02x:%02x -- %02x:%02x:%02x\n",
1662 cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]);
1663
1664 outsb(stuffp->wreg_data, cmd, sizeof cmd);
1665
1666 if (-1 == mcdx_getval(stuffp, 3 * HZ, 0, NULL)) {
1667 xwarn("playmsf() timeout\n");
1668 return -1;
1669 }
1670
1671 stuffp->audiostatus = CDROM_AUDIO_PLAY;
1672 return 0;
1673 }
1674
1675 static int
1676 mcdx_playtrk(struct s_drive_stuff *stuffp, const struct cdrom_ti *ti)
1677 {
1678 struct s_subqcode *p;
1679 struct cdrom_msf msf;
1680
1681 if (-1 == mcdx_readtoc(stuffp))
1682 return -1;
1683
1684 if (ti)
1685 p = &stuffp->toc[ti->cdti_trk0 - stuffp->di.n_first];
1686 else
1687 p = &stuffp->start;
1688
1689 msf.cdmsf_min0 = p->dt.minute;
1690 msf.cdmsf_sec0 = p->dt.second;
1691 msf.cdmsf_frame0 = p->dt.frame;
1692
1693 if (ti) {
1694 p = &stuffp->toc[ti->cdti_trk1 - stuffp->di.n_first + 1];
1695 stuffp->stop = *p;
1696 } else
1697 p = &stuffp->stop;
1698
1699 msf.cdmsf_min1 = p->dt.minute;
1700 msf.cdmsf_sec1 = p->dt.second;
1701 msf.cdmsf_frame1 = p->dt.frame;
1702
1703 return mcdx_playmsf(stuffp, &msf);
1704 }
1705
1706
1707 /* Drive functions ************************************************/
1708
1709 static int mcdx_tray_move(struct cdrom_device_info *cdi, int position)
1710 {
1711 struct s_drive_stuff *stuffp = cdi->handle;
1712
1713 if (!stuffp->present)
1714 return -ENXIO;
1715 if (!(stuffp->present & DOOR))
1716 return -ENOSYS;
1717
1718 if (position) /* 1: eject */
1719 return mcdx_talk(stuffp, "\xf6", 1, NULL, 1, 5 * HZ, 3);
1720 else /* 0: close */
1721 return mcdx_talk(stuffp, "\xf8", 1, NULL, 1, 5 * HZ, 3);
1722 return 1;
1723 }
1724
1725 static int mcdx_stop(struct s_drive_stuff *stuffp, int tries)
1726 {
1727 return mcdx_talk(stuffp, "\xf0", 1, NULL, 1, 2 * HZ, tries);
1728 }
1729
1730 static int mcdx_hold(struct s_drive_stuff *stuffp, int tries)
1731 {
1732 return mcdx_talk(stuffp, "\x70", 1, NULL, 1, 2 * HZ, tries);
1733 }
1734
1735 static int mcdx_requestsubqcode(struct s_drive_stuff *stuffp,
1736 struct s_subqcode *sub, int tries)
1737 {
1738 char buf[11];
1739 int ans;
1740
1741 if (-1 == (ans = mcdx_talk(stuffp, "\x20", 1, buf, sizeof(buf),
1742 2 * HZ, tries)))
1743 return -1;
1744 sub->control = buf[1];
1745 sub->tno = buf[2];
1746 sub->index = buf[3];
1747 sub->tt.minute = buf[4];
1748 sub->tt.second = buf[5];
1749 sub->tt.frame = buf[6];
1750 sub->dt.minute = buf[8];
1751 sub->dt.second = buf[9];
1752 sub->dt.frame = buf[10];
1753
1754 return ans;
1755 }
1756
1757 static int mcdx_requestmultidiskinfo(struct s_drive_stuff *stuffp,
1758 struct s_multi *multi, int tries)
1759 {
1760 char buf[5];
1761 int ans;
1762
1763 if (stuffp->present & MULTI) {
1764 ans =
1765 mcdx_talk(stuffp, "\x11", 1, buf, sizeof(buf), 2 * HZ,
1766 tries);
1767 multi->multi = buf[1];
1768 multi->msf_last.minute = buf[2];
1769 multi->msf_last.second = buf[3];
1770 multi->msf_last.frame = buf[4];
1771 return ans;
1772 } else {
1773 multi->multi = 0;
1774 return 0;
1775 }
1776 }
1777
1778 static int mcdx_requesttocdata(struct s_drive_stuff *stuffp, struct s_diskinfo *info,
1779 int tries)
1780 {
1781 char buf[9];
1782 int ans;
1783 ans =
1784 mcdx_talk(stuffp, "\x10", 1, buf, sizeof(buf), 2 * HZ, tries);
1785 if (ans == -1) {
1786 info->n_first = 0;
1787 info->n_last = 0;
1788 } else {
1789 info->n_first = bcd2uint(buf[1]);
1790 info->n_last = bcd2uint(buf[2]);
1791 info->msf_leadout.minute = buf[3];
1792 info->msf_leadout.second = buf[4];
1793 info->msf_leadout.frame = buf[5];
1794 info->msf_first.minute = buf[6];
1795 info->msf_first.second = buf[7];
1796 info->msf_first.frame = buf[8];
1797 }
1798 return ans;
1799 }
1800
1801 static int mcdx_setdrivemode(struct s_drive_stuff *stuffp, enum drivemodes mode,
1802 int tries)
1803 {
1804 char cmd[2];
1805 int ans;
1806
1807 xtrace(HW, "setdrivemode() %d\n", mode);
1808
1809 if (-1 == (ans = mcdx_talk(stuffp, "\xc2", 1, cmd, sizeof(cmd), 5 * HZ, tries)))
1810 return -1;
1811
1812 switch (mode) {
1813 case TOC:
1814 cmd[1] |= 0x04;
1815 break;
1816 case DATA:
1817 cmd[1] &= ~0x04;
1818 break;
1819 case RAW:
1820 cmd[1] |= 0x40;
1821 break;
1822 case COOKED:
1823 cmd[1] &= ~0x40;
1824 break;
1825 default:
1826 break;
1827 }
1828 cmd[0] = 0x50;
1829 return mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
1830 }
1831
1832 static int mcdx_setdatamode(struct s_drive_stuff *stuffp, enum datamodes mode,
1833 int tries)
1834 {
1835 unsigned char cmd[2] = { 0xa0 };
1836 xtrace(HW, "setdatamode() %d\n", mode);
1837 switch (mode) {
1838 case MODE0:
1839 cmd[1] = 0x00;
1840 break;
1841 case MODE1:
1842 cmd[1] = 0x01;
1843 break;
1844 case MODE2:
1845 cmd[1] = 0x02;
1846 break;
1847 default:
1848 return -EINVAL;
1849 }
1850 return mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
1851 }
1852
1853 static int mcdx_config(struct s_drive_stuff *stuffp, int tries)
1854 {
1855 char cmd[4];
1856
1857 xtrace(HW, "config()\n");
1858
1859 cmd[0] = 0x90;
1860
1861 cmd[1] = 0x10; /* irq enable */
1862 cmd[2] = 0x05; /* pre, err irq enable */
1863
1864 if (-1 == mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries))
1865 return -1;
1866
1867 cmd[1] = 0x02; /* dma select */
1868 cmd[2] = 0x00; /* no dma */
1869
1870 return mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries);
1871 }
1872
1873 static int mcdx_requestversion(struct s_drive_stuff *stuffp, struct s_version *ver,
1874 int tries)
1875 {
1876 char buf[3];
1877 int ans;
1878
1879 if (-1 == (ans = mcdx_talk(stuffp, "\xdc",
1880 1, buf, sizeof(buf), 2 * HZ, tries)))
1881 return ans;
1882
1883 ver->code = buf[1];
1884 ver->ver = buf[2];
1885
1886 return ans;
1887 }
1888
1889 static int mcdx_reset(struct s_drive_stuff *stuffp, enum resetmodes mode, int tries)
1890 {
1891 if (mode == HARD) {
1892 outb(0, stuffp->wreg_chn); /* no dma, no irq -> hardware */
1893 outb(0, stuffp->wreg_reset); /* hw reset */
1894 return 0;
1895 } else
1896 return mcdx_talk(stuffp, "\x60", 1, NULL, 1, 5 * HZ, tries);
1897 }
1898
1899 static int mcdx_lockdoor(struct cdrom_device_info *cdi, int lock)
1900 {
1901 struct s_drive_stuff *stuffp = cdi->handle;
1902 char cmd[2] = { 0xfe };
1903
1904 if (!(stuffp->present & DOOR))
1905 return -ENOSYS;
1906 if (stuffp->present & DOOR) {
1907 cmd[1] = lock ? 0x01 : 0x00;
1908 return mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 1, 5 * HZ, 3);
1909 } else
1910 return 0;
1911 }
1912
1913 static int mcdx_getstatus(struct s_drive_stuff *stuffp, int tries)
1914 {
1915 return mcdx_talk(stuffp, "\x40", 1, NULL, 1, 5 * HZ, tries);
1916 }
1917
1918 static int
1919 mcdx_getval(struct s_drive_stuff *stuffp, int to, int delay, char *buf)
1920 {
1921 unsigned long timeout = to + jiffies;
1922 char c;
1923
1924 if (!buf)
1925 buf = &c;
1926
1927 while (inb(stuffp->rreg_status) & MCDX_RBIT_STEN) {
1928 if (time_after(jiffies, timeout))
1929 return -1;
1930 mcdx_delay(stuffp, delay);
1931 }
1932
1933 *buf = (unsigned char) inb(stuffp->rreg_data) & 0xff;
1934
1935 return 0;
1936 }
1937
1938 static int mcdx_setattentuator(struct s_drive_stuff *stuffp,
1939 struct cdrom_volctrl *vol, int tries)
1940 {
1941 char cmd[5];
1942 cmd[0] = 0xae;
1943 cmd[1] = vol->channel0;
1944 cmd[2] = 0;
1945 cmd[3] = vol->channel1;
1946 cmd[4] = 0;
1947
1948 return mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 5, 200, tries);
1949 }
1950
1951 MODULE_LICENSE("GPL");
1952 MODULE_ALIAS_BLOCKDEV_MAJOR(MITSUMI_X_CDROM_MAJOR);
MOXA 2.6.9 from sdlinux-moxaart.tgz