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