2 * Sony CDU-31A CDROM interface device driver.
4 * Corey Minyard (minyard@wf-rch.cirr.com)
8 * See Documentation/cdrom/cdu31a for additional details about this driver.
10 * The Sony interface device driver handles Sony interface CDROM
11 * drives and provides a complete block-level interface as well as an
12 * ioctl() interface compatible with the Sun (as specified in
13 * include/linux/cdrom.h). With this interface, CDROMs can be
14 * accessed and standard audio CDs can be played back normally.
16 * WARNING - All autoprobes have been removed from the driver.
17 * You MUST configure the CDU31A via a LILO config
18 * at boot time or in lilo.conf. I have the
19 * following in my lilo.conf:
21 * append="cdu31a=0x1f88,0,PAS"
23 * The first number is the I/O base address of the
24 * card. The second is the interrupt (0 means none).
25 * The third should be "PAS" if on a Pro-Audio
26 * spectrum, or nothing if on something else.
28 * This interface is (unfortunately) a polled interface. This is
29 * because most Sony interfaces are set up with DMA and interrupts
30 * disables. Some (like mine) do not even have the capability to
31 * handle interrupts or DMA. For this reason you will see a lot of
34 * retry_count = jiffies+ SONY_JIFFIES_TIMEOUT;
35 * while (time_before(jiffies, retry_count) && (! <some condition to wait for))
37 * while (handle_sony_cd_attention())
42 * if (the condition not met)
47 * This ugly hack waits for something to happen, sleeping a little
48 * between every try. it also handles attentions, which are
49 * asynchronous events from the drive informing the driver that a disk
50 * has been inserted, removed, etc.
52 * NEWS FLASH - The driver now supports interrupts but they are
53 * turned off by default. Use of interrupts is highly encouraged, it
54 * cuts CPU usage down to a reasonable level. I had DMA in for a while
55 * but PC DMA is just too slow. Better to just insb() it.
57 * One thing about these drives: They talk in MSF (Minute Second Frame) format.
58 * There are 75 frames a second, 60 seconds a minute, and up to 75 minutes on a
59 * disk. The funny thing is that these are sent to the drive in BCD, but the
60 * interface wants to see them in decimal. A lot of conversion goes on.
62 * DRIVER SPECIAL FEATURES
63 * -----------------------
65 * This section describes features beyond the normal audio and CD-ROM
66 * functions of the drive.
68 * 2048 byte buffer mode
70 * If a disk is mounted with -o block=2048, data is copied straight
71 * from the drive data port to the buffer. Otherwise, the readahead
72 * buffer must be involved to hold the other 1K of data when a 1K
73 * block operation is done. Note that with 2048 byte blocks you
74 * cannot execute files from the CD.
78 * The driver should support XA disks for both the CDU31A and CDU33A.
79 * It does this transparently, the using program doesn't need to set it.
83 * A multi-session disk looks just like a normal disk to the user.
84 * Just mount one normally, and all the data should be there.
85 * A special thanks to Koen for help with this!
89 * Using the CDROMREADAUDIO it is possible to read raw audio and data
90 * tracks. Both operations return 2352 bytes per sector. On the data
91 * tracks, the first 12 bytes is not returned by the drive and the value
92 * of that data is indeterminate.
95 * Copyright (C) 1993 Corey Minyard
97 * This program is free software; you can redistribute it and/or modify
98 * it under the terms of the GNU General Public License as published by
99 * the Free Software Foundation; either version 2 of the License, or
100 * (at your option) any later version.
102 * This program is distributed in the hope that it will be useful,
103 * but WITHOUT ANY WARRANTY; without even the implied warranty of
104 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
105 * GNU General Public License for more details.
107 * You should have received a copy of the GNU General Public License
108 * along with this program; if not, write to the Free Software
109 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
112 * CDs with form1 and form2 sectors cause problems
113 * with current read-ahead strategy.
116 * Heiko Eissfeldt <heiko@colossus.escape.de>
117 * For finding abug in the return of the track numbers.
118 * TOC processing redone for proper multisession support.
121 * It probably a little late to be adding a history, but I guess I
124 * 10/24/95 - Added support for disabling the eject button when the
125 * drive is open. Note that there is a small problem
126 * still here, if the eject button is pushed while the
127 * drive light is flashing, the drive will return a bad
128 * status and be reset. It recovers, though.
130 * 03/07/97 - Fixed a problem with timers.
133 * 18 Spetember 1997 -- Ported to Uniform CD-ROM driver by
134 * Heiko Eissfeldt <heiko@colossus.escape.de> with additional
135 * changes by Erik Andersen <andersee@debian.org>
137 * 24 January 1998 -- Removed the scd_disc_status() function, which was now
138 * just dead code left over from the port.
139 * Erik Andersen <andersee@debian.org>
141 * 16 July 1998 -- Drive donated to Erik Andersen by John Kodis
142 * <kodis@jagunet.com>. Work begun on fixing driver to
143 * work under 2.1.X. Added temporary extra printks
144 * which seem to slow it down enough to work.
146 * 9 November 1999 -- Make kernel-parameter implementation work with 2.3.x
147 * Removed init_module & cleanup_module in favor of
148 * module_init & module_exit.
149 * Torben Mathiasen <tmm@image.dk>
152 #include <linux/major.h>
154 #include <linux/module.h>
156 #include <linux/errno.h>
157 #include <linux/signal.h>
158 #include <linux/sched.h>
159 #include <linux/timer.h>
160 #include <linux/fs.h>
161 #include <linux/kernel.h>
162 #include <linux/hdreg.h>
163 #include <linux/genhd.h>
164 #include <linux/ioport.h>
165 #include <linux/devfs_fs_kernel.h>
166 #include <linux/string.h>
167 #include <linux/slab.h>
168 #include <linux/init.h>
169 #include <linux/interrupt.h>
171 #include <asm/system.h>
173 #include <asm/uaccess.h>
176 #include <linux/cdrom.h>
179 #define MAJOR_NR CDU31A_CDROM_MAJOR
180 #include <linux/blkdev.h>
182 #define CDU31A_READAHEAD 4 /* 128 sector, 64kB, 32 reads read-ahead */
183 #define CDU31A_MAX_CONSECUTIVE_ATTENTIONS 10
187 /* Define the following if you have data corruption problems. */
188 #undef SONY_POLL_EACH_BYTE
191 ** Edit the following data to change interrupts, DMA channels, etc.
192 ** Default is polled and no DMA. DMA is not recommended for double-speed
196 unsigned short base; /* I/O Base Address */
197 short int_num; /* Interrupt Number (-1 means scan for it,
198 0 means don't use) */
199 } cdu31a_addresses[] __initdata = {
203 static int handle_sony_cd_attention(void);
204 static int read_subcode(void);
205 static void sony_get_toc(void);
206 static int scd_spinup(void);
207 /*static int scd_open(struct inode *inode, struct file *filp);*/
208 static int scd_open(struct cdrom_device_info *, int);
209 static void do_sony_cd_cmd(unsigned char cmd,
210 unsigned char *params,
211 unsigned int num_params,
212 unsigned char *result_buffer,
213 unsigned int *result_size);
214 static void size_to_buf(unsigned int size, unsigned char *buf);
216 /* Parameters for the read-ahead. */
217 static unsigned int sony_next_block; /* Next 512 byte block offset */
218 static unsigned int sony_blocks_left = 0; /* Number of 512 byte blocks left
219 in the current read command. */
222 /* The base I/O address of the Sony Interface. This is a variable (not a
223 #define) so it can be easily changed via some future ioctl() */
224 static unsigned int cdu31a_port = 0;
225 MODULE_PARM(cdu31a_port, "i");
228 * The following are I/O addresses of the various registers for the drive. The
229 * comment for the base address also applies here.
231 static volatile unsigned short sony_cd_cmd_reg;
232 static volatile unsigned short sony_cd_param_reg;
233 static volatile unsigned short sony_cd_write_reg;
234 static volatile unsigned short sony_cd_control_reg;
235 static volatile unsigned short sony_cd_status_reg;
236 static volatile unsigned short sony_cd_result_reg;
237 static volatile unsigned short sony_cd_read_reg;
238 static volatile unsigned short sony_cd_fifost_reg;
240 static struct request_queue *cdu31a_queue;
241 static spinlock_t cdu31a_lock = SPIN_LOCK_UNLOCKED; /* queue lock */
243 static int sony_spun_up = 0; /* Has the drive been spun up? */
245 static int sony_speed = 0; /* Last wanted speed */
247 static int sony_xa_mode = 0; /* Is an XA disk in the drive
248 and the drive a CDU31A? */
250 static int sony_raw_data_mode = 1; /* 1 if data tracks, 0 if audio.
251 For raw data reads. */
253 static unsigned int sony_usage = 0; /* How many processes have the
256 static int sony_pas_init = 0; /* Initialize the Pro-Audio
259 static struct s_sony_session_toc single_toc; /* Holds the
263 static struct s_all_sessions_toc sony_toc; /* entries gathered from all
266 static int sony_toc_read = 0; /* Has the TOC been read for
269 static struct s_sony_subcode last_sony_subcode; /* Points to the last
270 subcode address read */
272 static volatile int sony_inuse = 0; /* Is the drive in use? Only one operation
275 static DECLARE_WAIT_QUEUE_HEAD(sony_wait); /* Things waiting for the drive */
277 static struct task_struct *has_cd_task = NULL; /* The task that is currently
278 using the CDROM drive, or
281 static int is_double_speed = 0; /* does the drive support double speed ? */
282 static int is_a_cdu31a = 1; /* Is the drive a CDU31A? */
284 static int is_auto_eject = 1; /* Door has been locked? 1=No/0=Yes */
287 * The audio status uses the values from read subchannel data as specified
288 * in include/linux/cdrom.h.
290 static volatile int sony_audio_status = CDROM_AUDIO_NO_STATUS;
293 * The following are a hack for pausing and resuming audio play. The drive
294 * does not work as I would expect it, if you stop it then start it again,
295 * the drive seeks back to the beginning and starts over. This holds the
296 * position during a pause so a resume can restart it. It uses the
297 * audio status variable above to tell if it is paused.
299 static unsigned volatile char cur_pos_msf[3] = { 0, 0, 0 };
300 static unsigned volatile char final_pos_msf[3] = { 0, 0, 0 };
302 /* What IRQ is the drive using? 0 if none. */
303 static int cdu31a_irq = 0;
304 MODULE_PARM(cdu31a_irq, "i");
306 /* The interrupt handler will wake this queue up when it gets an
308 DECLARE_WAIT_QUEUE_HEAD(cdu31a_irq_wait);
310 static int curr_control_reg = 0; /* Current value of the control register */
312 /* A disk changed variable. When a disk change is detected, it will
313 all be set to TRUE. As the upper layers ask for disk_changed status
314 it will be cleared. */
315 static char disk_changed;
317 /* Variable for using the readahead buffer. The readahead buffer
318 is used for raw sector reads and for blocksizes that are smaller
320 static char readahead_buffer[CD_FRAMESIZE_RAW];
321 static int readahead_dataleft = 0;
322 static int readahead_bad = 0;
324 /* Used to time a short period to abort an operation after the
325 drive has been idle for a while. This keeps the light on
326 the drive from flashing for very long. */
327 static struct timer_list cdu31a_abort_timer;
329 /* Marks if the timeout has started an abort read. This is used
330 on entry to the drive to tell the code to read out the status
331 from the abort read. */
332 static int abort_read_started = 0;
335 * Uniform cdrom interface function
336 * report back, if disc has changed from time of last request.
338 static int scd_media_changed(struct cdrom_device_info *cdi, int disc_nr)
342 retval = disk_changed;
349 * Uniform cdrom interface function
350 * report back, if drive is ready
352 static int scd_drive_status(struct cdrom_device_info *cdi, int slot_nr)
354 if (CDSL_CURRENT != slot_nr) {
355 /* we have no changer support */
358 if (scd_spinup() == 0) {
361 return sony_spun_up ? CDS_DISC_OK : CDS_DRIVE_NOT_READY;
364 static inline void enable_interrupts(void)
366 curr_control_reg |= (SONY_ATTN_INT_EN_BIT
367 | SONY_RES_RDY_INT_EN_BIT
368 | SONY_DATA_RDY_INT_EN_BIT);
369 outb(curr_control_reg, sony_cd_control_reg);
372 static inline void disable_interrupts(void)
374 curr_control_reg &= ~(SONY_ATTN_INT_EN_BIT
375 | SONY_RES_RDY_INT_EN_BIT
376 | SONY_DATA_RDY_INT_EN_BIT);
377 outb(curr_control_reg, sony_cd_control_reg);
381 * Wait a little while (used for polling the drive). If in initialization,
382 * setting a timeout doesn't work, so just loop for a while.
384 static inline void sony_sleep(void)
388 if (cdu31a_irq <= 0) {
390 } else { /* Interrupt driven */
395 interruptible_sleep_on(&cdu31a_irq_wait);
396 restore_flags(flags);
402 * The following are convenience routine to read various status and set
403 * various conditions in the drive.
405 static inline int is_attention(void)
407 return ((inb(sony_cd_status_reg) & SONY_ATTN_BIT) != 0);
410 static inline int is_busy(void)
412 return ((inb(sony_cd_status_reg) & SONY_BUSY_BIT) != 0);
415 static inline int is_data_ready(void)
417 return ((inb(sony_cd_status_reg) & SONY_DATA_RDY_BIT) != 0);
420 static inline int is_data_requested(void)
422 return ((inb(sony_cd_status_reg) & SONY_DATA_REQUEST_BIT) != 0);
425 static inline int is_result_ready(void)
427 return ((inb(sony_cd_status_reg) & SONY_RES_RDY_BIT) != 0);
430 static inline int is_param_write_rdy(void)
432 return ((inb(sony_cd_fifost_reg) & SONY_PARAM_WRITE_RDY_BIT) != 0);
435 static inline int is_result_reg_not_empty(void)
437 return ((inb(sony_cd_fifost_reg) & SONY_RES_REG_NOT_EMP_BIT) != 0);
440 static inline void reset_drive(void)
442 curr_control_reg = 0;
443 readahead_dataleft = 0;
445 outb(SONY_DRIVE_RESET_BIT, sony_cd_control_reg);
449 * Uniform cdrom interface function
450 * reset drive and return when it is ready
452 static int scd_reset(struct cdrom_device_info *cdi)
454 unsigned long retry_count;
458 retry_count = jiffies + SONY_RESET_TIMEOUT;
459 while (time_before(jiffies, retry_count) && (!is_attention())) {
466 static inline void clear_attention(void)
468 outb(curr_control_reg | SONY_ATTN_CLR_BIT, sony_cd_control_reg);
471 static inline void clear_result_ready(void)
473 outb(curr_control_reg | SONY_RES_RDY_CLR_BIT, sony_cd_control_reg);
476 static inline void clear_data_ready(void)
478 outb(curr_control_reg | SONY_DATA_RDY_CLR_BIT,
479 sony_cd_control_reg);
482 static inline void clear_param_reg(void)
484 outb(curr_control_reg | SONY_PARAM_CLR_BIT, sony_cd_control_reg);
487 static inline unsigned char read_status_register(void)
489 return (inb(sony_cd_status_reg));
492 static inline unsigned char read_result_register(void)
494 return (inb(sony_cd_result_reg));
497 static inline unsigned char read_data_register(void)
499 return (inb(sony_cd_read_reg));
502 static inline void write_param(unsigned char param)
504 outb(param, sony_cd_param_reg);
507 static inline void write_cmd(unsigned char cmd)
509 outb(curr_control_reg | SONY_RES_RDY_INT_EN_BIT,
510 sony_cd_control_reg);
511 outb(cmd, sony_cd_cmd_reg);
514 static irqreturn_t cdu31a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
518 if (abort_read_started) {
519 /* We might be waiting for an abort to finish. Don't
520 disable interrupts yet, though, because we handle
522 /* Clear out the result registers. */
523 while (is_result_reg_not_empty()) {
524 val = read_result_register();
527 clear_result_ready();
529 /* Clear out the data */
530 while (is_data_requested()) {
531 val = read_data_register();
533 abort_read_started = 0;
535 /* If something was waiting, wake it up now. */
536 if (waitqueue_active(&cdu31a_irq_wait)) {
537 disable_interrupts();
538 wake_up(&cdu31a_irq_wait);
540 } else if (waitqueue_active(&cdu31a_irq_wait)) {
541 disable_interrupts();
542 wake_up(&cdu31a_irq_wait);
544 disable_interrupts();
546 ("CDU31A: Got an interrupt but nothing was waiting\n");
552 * give more verbose error messages
554 static unsigned char *translate_error(unsigned char err_code)
556 static unsigned char errbuf[80];
560 return "illegal command ";
562 return "illegal parameter ";
565 return "not loaded ";
569 return "not spinning ";
573 return "spindle servo ";
575 return "focus servo ";
577 return "eject mechanism ";
579 return "audio playing ";
581 return "emergency eject ";
586 return "frame sync ";
588 return "subcode address ";
590 return "block sync ";
592 return "header address ";
595 return "illegal track read ";
597 return "mode 0 read ";
599 return "illegal mode read ";
601 return "illegal block size read ";
607 return "leadout read ";
609 return "buffer overrun ";
612 return "unrecoverable CIRC ";
614 return "unrecoverable LECC ";
619 return "invalid subcode data ";
621 return "focus on TOC read ";
623 return "frame sync on TOC read ";
628 return "hardware failure ";
634 return "data track ";
636 sprintf(errbuf, "unknown 0x%02x ", err_code);
641 * Set the drive parameters so the drive will auto-spin-up when a
644 static void set_drive_params(int want_doublespeed)
646 unsigned char res_reg[12];
647 unsigned int res_size;
648 unsigned char params[3];
651 params[0] = SONY_SD_AUTO_SPIN_DOWN_TIME;
652 params[1] = 0x00; /* Never spin down the drive. */
653 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
654 params, 2, res_reg, &res_size);
655 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20)) {
656 printk(" Unable to set spin-down time: 0x%2.2x\n",
660 params[0] = SONY_SD_MECH_CONTROL;
661 params[1] = SONY_AUTO_SPIN_UP_BIT; /* Set auto spin up */
664 params[1] |= SONY_AUTO_EJECT_BIT;
666 if (is_double_speed && want_doublespeed) {
667 params[1] |= SONY_DOUBLE_SPEED_BIT; /* Set the drive to double speed if
670 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
671 params, 2, res_reg, &res_size);
672 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20)) {
673 printk(" Unable to set mechanical parameters: 0x%2.2x\n",
679 * Uniform cdrom interface function
680 * select reading speed for data access
682 static int scd_select_speed(struct cdrom_device_info *cdi, int speed)
687 sony_speed = speed - 1;
689 set_drive_params(sony_speed);
694 * Uniform cdrom interface function
695 * lock or unlock eject button
697 static int scd_lock_door(struct cdrom_device_info *cdi, int lock)
699 if (lock == 0 && sony_usage == 1) {
700 /* Unlock the door, only if nobody is using the drive */
705 set_drive_params(sony_speed);
710 * This code will reset the drive and attempt to restore sane parameters.
712 static void restart_on_error(void)
714 unsigned char res_reg[12];
715 unsigned int res_size;
716 unsigned long retry_count;
719 printk("cdu31a: Resetting drive on error\n");
721 retry_count = jiffies + SONY_RESET_TIMEOUT;
722 while (time_before(jiffies, retry_count) && (!is_attention())) {
725 set_drive_params(sony_speed);
726 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
727 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20)) {
728 printk("cdu31a: Unable to spin up drive: 0x%2.2x\n",
732 current->state = TASK_INTERRUPTIBLE;
733 schedule_timeout(2 * HZ);
739 * This routine writes data to the parameter register. Since this should
740 * happen fairly fast, it is polled with no OS waits between.
742 static int write_params(unsigned char *params, int num_params)
744 unsigned int retry_count;
747 retry_count = SONY_READY_RETRIES;
748 while ((retry_count > 0) && (!is_param_write_rdy())) {
751 if (!is_param_write_rdy()) {
755 while (num_params > 0) {
756 write_param(*params);
766 * The following reads data from the command result register. It is a
767 * fairly complex routine, all status info flows back through this
768 * interface. The algorithm is stolen directly from the flowcharts in
772 get_result(unsigned char *result_buffer, unsigned int *result_size)
776 unsigned long retry_count;
779 while (handle_sony_cd_attention());
780 /* Wait for the result data to be ready */
781 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
782 while (time_before(jiffies, retry_count)
783 && (is_busy() || (!(is_result_ready())))) {
786 while (handle_sony_cd_attention());
788 if (is_busy() || (!(is_result_ready()))) {
790 printk("CDU31A timeout out %d\n", __LINE__);
792 result_buffer[0] = 0x20;
793 result_buffer[1] = SONY_TIMEOUT_OP_ERR;
799 * Get the first two bytes. This determines what else needs
802 clear_result_ready();
803 a = read_result_register();
807 /* Check for block error status result. */
808 if ((a & 0xf0) == 0x50) {
813 b = read_result_register();
819 * 0x20 means an error occurred. Byte 2 will have the error code.
820 * Otherwise, the command succeeded, byte 2 will have the count of
821 * how many more status bytes are coming.
823 * The result register can be read 10 bytes at a time, a wait for
824 * result ready to be asserted must be done between every 10 bytes.
826 if ((a & 0xf0) != 0x20) {
828 for (i = 0; i < 8; i++) {
829 *result_buffer = read_result_register();
836 retry_count = SONY_READY_RETRIES;
837 while ((retry_count > 0)
838 && (!is_result_ready())) {
841 if (!is_result_ready()) {
843 printk("CDU31A timeout out %d\n",
846 result_buffer[0] = 0x20;
853 clear_result_ready();
855 for (i = 0; i < 10; i++) {
857 read_result_register();
865 retry_count = SONY_READY_RETRIES;
866 while ((retry_count > 0)
867 && (!is_result_ready())) {
870 if (!is_result_ready()) {
872 printk("CDU31A timeout out %d\n",
875 result_buffer[0] = 0x20;
885 *result_buffer = read_result_register();
894 * Do a command that does not involve data transfer. This routine must
895 * be re-entrant from the same task to support being called from the
896 * data operation code when an error occurs.
899 do_sony_cd_cmd(unsigned char cmd,
900 unsigned char *params,
901 unsigned int num_params,
902 unsigned char *result_buffer, unsigned int *result_size)
904 unsigned long retry_count;
912 if (current != has_cd_task) { /* Allow recursive calls to this routine */
914 interruptible_sleep_on(&sony_wait);
915 if (signal_pending(current)) {
916 result_buffer[0] = 0x20;
917 result_buffer[1] = SONY_SIGNAL_OP_ERR;
919 restore_flags(flags);
924 has_cd_task = current;
933 while (handle_sony_cd_attention());
937 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
938 while (time_before(jiffies, retry_count) && (is_busy())) {
941 while (handle_sony_cd_attention());
945 printk("CDU31A timeout out %d\n", __LINE__);
947 result_buffer[0] = 0x20;
948 result_buffer[1] = SONY_TIMEOUT_OP_ERR;
951 clear_result_ready();
954 write_params(params, num_params);
957 get_result(result_buffer, result_size);
960 if (((result_buffer[0] & 0xf0) == 0x20)
961 && (num_retries < MAX_CDU31A_RETRIES)) {
963 current->state = TASK_INTERRUPTIBLE;
964 schedule_timeout(HZ / 10); /* Wait .1 seconds on retries */
965 goto retry_cd_operation;
968 if (!recursive_call) {
971 wake_up_interruptible(&sony_wait);
974 restore_flags(flags);
979 * Handle an attention from the drive. This will return 1 if it found one
980 * or 0 if not (if one is found, the caller might want to call again).
982 * This routine counts the number of consecutive times it is called
983 * (since this is always called from a while loop until it returns
984 * a 0), and returns a 0 if it happens too many times. This will help
987 static int handle_sony_cd_attention(void)
989 unsigned char atten_code;
990 static int num_consecutive_attentions = 0;
995 printk("Entering handle_sony_cd_attention\n");
997 if (is_attention()) {
998 if (num_consecutive_attentions >
999 CDU31A_MAX_CONSECUTIVE_ATTENTIONS) {
1001 ("cdu31a: Too many consecutive attentions: %d\n",
1002 num_consecutive_attentions);
1003 num_consecutive_attentions = 0;
1005 printk("Leaving handle_sony_cd_attention at %d\n",
1012 atten_code = read_result_register();
1014 switch (atten_code) {
1015 /* Someone changed the CD. Mark it as changed */
1016 case SONY_MECH_LOADED_ATTN:
1019 sony_audio_status = CDROM_AUDIO_NO_STATUS;
1020 sony_blocks_left = 0;
1023 case SONY_SPIN_DOWN_COMPLETE_ATTN:
1024 /* Mark the disk as spun down. */
1028 case SONY_AUDIO_PLAY_DONE_ATTN:
1029 sony_audio_status = CDROM_AUDIO_COMPLETED;
1033 case SONY_EJECT_PUSHED_ATTN:
1034 if (is_auto_eject) {
1035 sony_audio_status = CDROM_AUDIO_INVALID;
1039 case SONY_LEAD_IN_ERR_ATTN:
1040 case SONY_LEAD_OUT_ERR_ATTN:
1041 case SONY_DATA_TRACK_ERR_ATTN:
1042 case SONY_AUDIO_PLAYBACK_ERR_ATTN:
1043 sony_audio_status = CDROM_AUDIO_ERROR;
1047 num_consecutive_attentions++;
1049 printk("Leaving handle_sony_cd_attention at %d\n",
1053 } else if (abort_read_started) {
1054 while (is_result_reg_not_empty()) {
1055 val = read_result_register();
1058 clear_result_ready();
1059 /* Clear out the data */
1060 while (is_data_requested()) {
1061 val = read_data_register();
1063 abort_read_started = 0;
1065 printk("Leaving handle_sony_cd_attention at %d\n",
1071 num_consecutive_attentions = 0;
1073 printk("Leaving handle_sony_cd_attention at %d\n", __LINE__);
1079 /* Convert from an integer 0-99 to BCD */
1080 static inline unsigned int int_to_bcd(unsigned int val)
1085 retval = (val / 10) << 4;
1086 retval = retval | val % 10;
1091 /* Convert from BCD to an integer from 0-99 */
1092 static unsigned int bcd_to_int(unsigned int bcd)
1094 return ((((bcd >> 4) & 0x0f) * 10) + (bcd & 0x0f));
1099 * Convert a logical sector value (like the OS would want to use for
1100 * a block device) to an MSF format.
1102 static void log_to_msf(unsigned int log, unsigned char *msf)
1104 log = log + LOG_START_OFFSET;
1105 msf[0] = int_to_bcd(log / 4500);
1107 msf[1] = int_to_bcd(log / 75);
1108 msf[2] = int_to_bcd(log % 75);
1113 * Convert an MSF format to a logical sector.
1115 static unsigned int msf_to_log(unsigned char *msf)
1122 log += msf[0] * 4500;
1123 log = log - LOG_START_OFFSET;
1130 * Take in integer size value and put it into a buffer like
1131 * the drive would want to see a number-of-sector value.
1133 static void size_to_buf(unsigned int size, unsigned char *buf)
1135 buf[0] = size / 65536;
1136 size = size % 65536;
1137 buf[1] = size / 256;
1138 buf[2] = size % 256;
1141 /* Starts a read operation. Returns 0 on success and 1 on failure.
1142 The read operation used here allows multiple sequential sectors
1143 to be read and status returned for each sector. The driver will
1144 read the output one at a time as the requests come and abort the
1145 operation if the requested sector is not the next one from the
1148 start_request(unsigned int sector, unsigned int nsect, int read_nsect_only)
1150 unsigned char params[6];
1151 unsigned int read_size;
1152 unsigned long retry_count;
1156 printk("Entering start_request\n");
1158 log_to_msf(sector, params);
1159 /* If requested, read exactly what was asked. */
1160 if (read_nsect_only) {
1164 * If the full read-ahead would go beyond the end of the media, trim
1165 * it back to read just till the end of the media.
1167 else if ((sector + nsect) >= sony_toc.lead_out_start_lba) {
1168 read_size = sony_toc.lead_out_start_lba - sector;
1170 /* Read the full readahead amount. */
1172 read_size = CDU31A_READAHEAD / 4;
1174 size_to_buf(read_size, ¶ms[3]);
1177 * Clear any outstanding attentions and wait for the drive to
1178 * complete any pending operations.
1180 while (handle_sony_cd_attention());
1182 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1183 while (time_before(jiffies, retry_count) && (is_busy())) {
1186 while (handle_sony_cd_attention());
1190 printk("CDU31A: Timeout while waiting to issue command\n");
1192 printk("Leaving start_request at %d\n", __LINE__);
1196 /* Issue the command */
1197 clear_result_ready();
1200 write_params(params, 6);
1201 write_cmd(SONY_READ_BLKERR_STAT_CMD);
1203 sony_blocks_left = read_size * 4;
1204 sony_next_block = sector * 4;
1205 readahead_dataleft = 0;
1208 printk("Leaving start_request at %d\n", __LINE__);
1213 printk("Leaving start_request at %d\n", __LINE__);
1217 /* Abort a pending read operation. Clear all the drive status and
1218 readahead variables. */
1219 static void abort_read(void)
1221 unsigned char result_reg[2];
1226 do_sony_cd_cmd(SONY_ABORT_CMD, NULL, 0, result_reg, &result_size);
1227 if ((result_reg[0] & 0xf0) == 0x20) {
1228 printk("CDU31A: Error aborting read, %s error\n",
1229 translate_error(result_reg[1]));
1232 while (is_result_reg_not_empty()) {
1233 val = read_result_register();
1236 clear_result_ready();
1237 /* Clear out the data */
1238 while (is_data_requested()) {
1239 val = read_data_register();
1242 sony_blocks_left = 0;
1243 readahead_dataleft = 0;
1247 /* Called when the timer times out. This will abort the
1248 pending read operation. */
1249 static void handle_abort_timeout(unsigned long data)
1251 unsigned long flags;
1254 printk("Entering handle_abort_timeout\n");
1258 /* If it is in use, ignore it. */
1260 /* We can't use abort_read(), because it will sleep
1261 or schedule in the timer interrupt. Just start
1262 the operation, finish it on the next access to
1264 clear_result_ready();
1266 write_cmd(SONY_ABORT_CMD);
1268 sony_blocks_left = 0;
1269 readahead_dataleft = 0;
1271 abort_read_started = 1;
1273 restore_flags(flags);
1275 printk("Leaving handle_abort_timeout\n");
1279 /* Actually get data and status from the drive. */
1281 input_data(char *buffer,
1282 unsigned int bytesleft,
1283 unsigned int nblocks, unsigned int offset, unsigned int skip)
1286 volatile unsigned char val;
1290 printk("Entering input_data\n");
1292 /* If an XA disk on a CDU31A, skip the first 12 bytes of data from
1293 the disk. The real data is after that. */
1295 for (i = 0; i < CD_XA_HEAD; i++) {
1296 val = read_data_register();
1302 if (bytesleft == 2048) { /* 2048 byte direct buffer transfer */
1303 insb(sony_cd_read_reg, buffer, 2048);
1304 readahead_dataleft = 0;
1306 /* If the input read did not align with the beginning of the block,
1307 skip the necessary bytes. */
1309 insb(sony_cd_read_reg, readahead_buffer, skip);
1312 /* Get the data into the buffer. */
1313 insb(sony_cd_read_reg, &buffer[offset], bytesleft);
1315 /* Get the rest of the data into the readahead buffer at the
1317 readahead_dataleft = (2048 - skip) - bytesleft;
1318 insb(sony_cd_read_reg,
1319 readahead_buffer + bytesleft, readahead_dataleft);
1321 sony_blocks_left -= nblocks;
1322 sony_next_block += nblocks;
1324 /* If an XA disk, we have to clear out the rest of the unused
1325 error correction data. */
1327 for (i = 0; i < CD_XA_TAIL; i++) {
1328 val = read_data_register();
1332 printk("Leaving input_data at %d\n", __LINE__);
1336 /* read data from the drive. Note the nsect must be <= 4. */
1338 read_data_block(char *buffer,
1340 unsigned int nblocks,
1341 unsigned char res_reg[], int *res_size)
1343 unsigned long retry_count;
1344 unsigned int bytesleft;
1345 unsigned int offset;
1350 printk("Entering read_data_block\n");
1356 bytesleft = nblocks * 512;
1359 /* If the data in the read-ahead does not match the block offset,
1360 then fix things up. */
1361 if (((block % 4) * 512) != ((2048 - readahead_dataleft) % 2048)) {
1362 sony_next_block += block % 4;
1363 sony_blocks_left -= block % 4;
1364 skip = (block % 4) * 512;
1369 /* We have readahead data in the buffer, get that first before we
1370 decide if a read is necessary. */
1371 if (readahead_dataleft != 0) {
1372 if (bytesleft > readahead_dataleft) {
1373 /* The readahead will not fill the requested buffer, but
1374 get the data out of the readahead into the buffer. */
1376 readahead_buffer + (2048 -
1377 readahead_dataleft),
1378 readahead_dataleft);
1379 bytesleft -= readahead_dataleft;
1380 offset += readahead_dataleft;
1381 readahead_dataleft = 0;
1383 /* The readahead will fill the whole buffer, get the data
1386 readahead_buffer + (2048 -
1387 readahead_dataleft),
1389 readahead_dataleft -= bytesleft;
1391 sony_blocks_left -= nblocks;
1392 sony_next_block += nblocks;
1394 /* If the data in the readahead is bad, return an error so the
1395 driver will abort the buffer. */
1396 if (readahead_bad) {
1398 res_reg[1] = SONY_BAD_DATA_ERR;
1402 if (readahead_dataleft == 0) {
1406 /* Final transfer is done for read command, get final result. */
1407 if (sony_blocks_left == 0) {
1408 get_result(res_reg, res_size);
1411 printk("Leaving read_data_block at %d\n",
1418 /* Wait for the drive to tell us we have something */
1419 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1420 while (time_before(jiffies, retry_count) && !(is_data_ready())) {
1421 while (handle_sony_cd_attention());
1425 if (!(is_data_ready())) {
1426 if (is_result_ready()) {
1427 get_result(res_reg, res_size);
1428 if ((res_reg[0] & 0xf0) != 0x20) {
1430 ("CDU31A: Got result that should have been error: %d\n",
1433 res_reg[1] = SONY_BAD_DATA_ERR;
1439 printk("CDU31A timeout out %d\n", __LINE__);
1442 res_reg[1] = SONY_TIMEOUT_OP_ERR;
1447 input_data(buffer, bytesleft, nblocks, offset, skip);
1449 /* Wait for the status from the drive. */
1450 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1451 while (time_before(jiffies, retry_count)
1452 && !(is_result_ready())) {
1453 while (handle_sony_cd_attention());
1458 if (!is_result_ready()) {
1460 printk("CDU31A timeout out %d\n", __LINE__);
1463 res_reg[1] = SONY_TIMEOUT_OP_ERR;
1467 get_result(res_reg, res_size);
1469 /* If we got a buffer status, handle that. */
1470 if ((res_reg[0] & 0xf0) == 0x50) {
1473 SONY_NO_CIRC_ERR_BLK_STAT)
1475 SONY_NO_LECC_ERR_BLK_STAT)
1477 SONY_RECOV_LECC_ERR_BLK_STAT)) {
1478 /* The data was successful, but if data was read from
1479 the readahead and it was bad, set the whole
1481 if (readahead_bad) {
1490 ("CDU31A: Data block error: 0x%x\n",
1493 res_reg[1] = SONY_BAD_DATA_ERR;
1496 /* Data is in the readahead buffer but an error was returned.
1497 Make sure future requests don't use the data. */
1498 if (bytesleft != 2048) {
1503 /* Final transfer is done for read command, get final result. */
1504 if (sony_blocks_left == 0) {
1505 get_result(res_reg, res_size);
1507 } else if ((res_reg[0] & 0xf0) != 0x20) {
1508 /* The drive gave me bad status, I don't know what to do.
1509 Reset the driver and return an error. */
1511 ("CDU31A: Invalid block status: 0x%x\n",
1515 res_reg[1] = SONY_BAD_DATA_ERR;
1521 printk("Leaving read_data_block at %d\n", __LINE__);
1527 * The OS calls this to perform a read or write operation to the drive.
1528 * Write obviously fail. Reads to a read ahead of sony_buffer_size
1529 * bytes to help speed operations. This especially helps since the OS
1530 * uses 1024 byte blocks and the drive uses 2048 byte blocks. Since most
1531 * data access on a CD is done sequentially, this saves a lot of operations.
1533 static void do_cdu31a_request(request_queue_t * q)
1535 struct request *req;
1538 unsigned char res_reg[12];
1539 unsigned int res_size;
1541 unsigned long flags;
1545 printk("Entering do_cdu31a_request\n");
1549 * Make sure no one else is using the driver; wait for them
1550 * to finish if it is so.
1554 while (sony_inuse) {
1555 interruptible_sleep_on(&sony_wait);
1556 if (signal_pending(current)) {
1557 restore_flags(flags);
1559 printk("Leaving do_cdu31a_request at %d\n",
1566 has_cd_task = current;
1568 /* Get drive status before doing anything. */
1569 while (handle_sony_cd_attention());
1571 /* Make sure we have a valid TOC. */
1575 * jens: driver has lots of races
1577 spin_unlock_irq(q->queue_lock);
1579 /* Make sure the timer is cancelled. */
1580 del_timer(&cdu31a_abort_timer);
1584 * The beginning here is stolen from the hard disk driver. I hope
1587 req = elv_next_request(q);
1589 goto end_do_cdu31a_request;
1594 block = req->sector;
1595 nblock = req->nr_sectors;
1597 if (!sony_toc_read) {
1598 printk("CDU31A: TOC not read\n");
1599 end_request(req, 0);
1604 if (!(req->flags & REQ_CMD))
1606 if (rq_data_dir(req) == WRITE) {
1607 end_request(req, 0);
1610 if (rq_data_dir(req) != READ)
1611 panic("CDU31A: Unknown cmd");
1613 * If the block address is invalid or the request goes beyond the end of
1614 * the media, return an error.
1616 if ((block / 4) >= sony_toc.lead_out_start_lba) {
1617 printk("CDU31A: Request past end of media\n");
1618 end_request(req, 0);
1621 if (((block + nblock) / 4) >= sony_toc.lead_out_start_lba) {
1622 printk("CDU31A: Request past end of media\n");
1623 end_request(req, 0);
1630 while (handle_sony_cd_attention());
1632 if (!sony_toc_read) {
1633 printk("CDU31A: TOC not read\n");
1634 end_request(req, 0);
1638 /* If no data is left to be read from the drive, start the
1640 if (sony_blocks_left == 0) {
1641 if (start_request(block / 4, CDU31A_READAHEAD / 4, 0)) {
1642 end_request(req, 0);
1646 /* If the requested block is not the next one waiting in
1647 the driver, abort the current operation and start a
1649 else if (block != sony_next_block) {
1651 printk("CDU31A Warning: Read for block %d, expected %d\n",
1652 block, sony_next_block);
1655 if (!sony_toc_read) {
1656 printk("CDU31A: TOC not read\n");
1657 end_request(req, 0);
1660 if (start_request(block / 4, CDU31A_READAHEAD / 4, 0)) {
1661 printk("CDU31a: start request failed\n");
1662 end_request(req, 0);
1667 read_data_block(req->buffer, block, nblock, res_reg, &res_size);
1669 if (res_reg[0] != 0x20) {
1670 end_request(req, 1);
1674 if (num_retries > MAX_CDU31A_RETRIES) {
1675 end_request(req, 0);
1680 if (res_reg[1] == SONY_NOT_SPIN_ERR) {
1681 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg,
1684 printk("CDU31A: %s error for block %d, nblock %d\n",
1685 translate_error(res_reg[1]), block, nblock);
1687 goto try_read_again;
1689 end_do_cdu31a_request:
1690 spin_lock_irq(q->queue_lock);
1692 /* After finished, cancel any pending operations. */
1695 /* Start a timer to time out after a while to disable
1697 cdu31a_abort_timer.expires = jiffies + 2 * HZ; /* Wait 2 seconds */
1698 add_timer(&cdu31a_abort_timer);
1703 wake_up_interruptible(&sony_wait);
1704 restore_flags(flags);
1706 printk("Leaving do_cdu31a_request at %d\n", __LINE__);
1712 * Read the table of contents from the drive and set up TOC if
1715 static void sony_get_toc(void)
1717 unsigned char res_reg[2];
1718 unsigned int res_size;
1719 unsigned char parms[1];
1722 int totaltracks = 0;
1727 printk("Entering sony_get_toc\n");
1731 if (!sony_toc_read) {
1733 /* Ignore the result, since it might error if spinning already. */
1734 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg,
1737 do_sony_cd_cmd(SONY_READ_TOC_CMD, NULL, 0, res_reg,
1740 /* The drive sometimes returns error 0. I don't know why, but ignore
1741 it. It seems to mean the drive has already done the operation. */
1743 || ((res_reg[0] != 0) && (res_reg[1] != 0))) {
1744 /* If the drive is already playing, it's ok. */
1745 if ((res_reg[1] == SONY_AUDIO_PLAYING_ERR)
1746 || (res_reg[1] == 0)) {
1747 goto gettoc_drive_spinning;
1750 /* If the drive says it is not spun up (even though we just did it!)
1751 then retry the operation at least a few times. */
1752 if ((res_reg[1] == SONY_NOT_SPIN_ERR)
1753 && (num_spin_ups < MAX_CDU31A_RETRIES)) {
1755 goto respinup_on_gettoc;
1758 printk("cdu31a: Error reading TOC: %x %s\n",
1759 res_reg[0], translate_error(res_reg[1]));
1763 gettoc_drive_spinning:
1765 /* The idea here is we keep asking for sessions until the command
1766 fails. Then we know what the last valid session on the disk is.
1767 No need to check session 0, since session 0 is the same as session
1768 1; the command returns different information if you give it 0.
1771 memset(&sony_toc, 0x0e, sizeof(sony_toc));
1772 memset(&single_toc, 0x0f, sizeof(single_toc));
1776 /* This seems to slow things down enough to make it work. This
1777 * appears to be a problem in do_sony_cd_cmd. This printk seems
1778 * to address the symptoms... -Erik */
1780 printk("cdu31a: Trying session %d\n", session);
1783 do_sony_cd_cmd(SONY_READ_TOC_SPEC_CMD,
1784 parms, 1, res_reg, &res_size);
1787 printk("%2.2x %2.2x\n", res_reg[0], res_reg[1]);
1791 || ((res_reg[0] & 0xf0) == 0x20)) {
1792 /* An error reading the TOC, this must be past the last session. */
1795 ("Yikes! Couldn't read any sessions!");
1799 printk("Reading session %d\n", session);
1803 do_sony_cd_cmd(SONY_REQ_TOC_DATA_SPEC_CMD,
1806 (unsigned char *) &single_toc,
1809 || ((single_toc.exec_status[0] & 0xf0) ==
1812 ("cdu31a: Error reading session %d: %x %s\n",
1813 session, single_toc.exec_status[0],
1814 translate_error(single_toc.
1816 /* An error reading the TOC. Return without sony_toc_read
1822 ("add0 %01x, con0 %01x, poi0 %02x, 1st trk %d, dsktyp %x, dum0 %x\n",
1823 single_toc.address0, single_toc.control0,
1825 bcd_to_int(single_toc.first_track_num),
1826 single_toc.disk_type, single_toc.dummy0);
1828 ("add1 %01x, con1 %01x, poi1 %02x, lst trk %d, dummy1 %x, dum2 %x\n",
1829 single_toc.address1, single_toc.control1,
1831 bcd_to_int(single_toc.last_track_num),
1832 single_toc.dummy1, single_toc.dummy2);
1834 ("add2 %01x, con2 %01x, poi2 %02x leadout start min %d, sec %d, frame %d\n",
1835 single_toc.address2, single_toc.control2,
1837 bcd_to_int(single_toc.lead_out_start_msf[0]),
1838 bcd_to_int(single_toc.lead_out_start_msf[1]),
1839 bcd_to_int(single_toc.lead_out_start_msf[2]));
1840 if (res_size > 18 && single_toc.pointb0 > 0xaf)
1842 ("addb0 %01x, conb0 %01x, poib0 %02x, nextsession min %d, sec %d, frame %d\n"
1843 "#mode5_ptrs %02d, max_start_outer_leadout_msf min %d, sec %d, frame %d\n",
1844 single_toc.addressb0,
1845 single_toc.controlb0,
1847 bcd_to_int(single_toc.
1848 next_poss_prog_area_msf
1850 bcd_to_int(single_toc.
1851 next_poss_prog_area_msf
1853 bcd_to_int(single_toc.
1854 next_poss_prog_area_msf
1856 single_toc.num_mode_5_pointers,
1857 bcd_to_int(single_toc.
1858 max_start_outer_leadout_msf
1860 bcd_to_int(single_toc.
1861 max_start_outer_leadout_msf
1863 bcd_to_int(single_toc.
1864 max_start_outer_leadout_msf
1866 if (res_size > 27 && single_toc.pointb1 > 0xaf)
1868 ("addb1 %01x, conb1 %01x, poib1 %02x, %x %x %x %x #skipint_ptrs %d, #skiptrkassign %d %x\n",
1869 single_toc.addressb1,
1870 single_toc.controlb1,
1872 single_toc.dummyb0_1[0],
1873 single_toc.dummyb0_1[1],
1874 single_toc.dummyb0_1[2],
1875 single_toc.dummyb0_1[3],
1876 single_toc.num_skip_interval_pointers,
1877 single_toc.num_skip_track_assignments,
1878 single_toc.dummyb0_2);
1879 if (res_size > 36 && single_toc.pointb2 > 0xaf)
1881 ("addb2 %01x, conb2 %01x, poib2 %02x, %02x %02x %02x %02x %02x %02x %02x\n",
1882 single_toc.addressb2,
1883 single_toc.controlb2,
1885 single_toc.tracksb2[0],
1886 single_toc.tracksb2[1],
1887 single_toc.tracksb2[2],
1888 single_toc.tracksb2[3],
1889 single_toc.tracksb2[4],
1890 single_toc.tracksb2[5],
1891 single_toc.tracksb2[6]);
1892 if (res_size > 45 && single_toc.pointb3 > 0xaf)
1894 ("addb3 %01x, conb3 %01x, poib3 %02x, %02x %02x %02x %02x %02x %02x %02x\n",
1895 single_toc.addressb3,
1896 single_toc.controlb3,
1898 single_toc.tracksb3[0],
1899 single_toc.tracksb3[1],
1900 single_toc.tracksb3[2],
1901 single_toc.tracksb3[3],
1902 single_toc.tracksb3[4],
1903 single_toc.tracksb3[5],
1904 single_toc.tracksb3[6]);
1905 if (res_size > 54 && single_toc.pointb4 > 0xaf)
1907 ("addb4 %01x, conb4 %01x, poib4 %02x, %02x %02x %02x %02x %02x %02x %02x\n",
1908 single_toc.addressb4,
1909 single_toc.controlb4,
1911 single_toc.tracksb4[0],
1912 single_toc.tracksb4[1],
1913 single_toc.tracksb4[2],
1914 single_toc.tracksb4[3],
1915 single_toc.tracksb4[4],
1916 single_toc.tracksb4[5],
1917 single_toc.tracksb4[6]);
1918 if (res_size > 63 && single_toc.pointc0 > 0xaf)
1920 ("addc0 %01x, conc0 %01x, poic0 %02x, %02x %02x %02x %02x %02x %02x %02x\n",
1921 single_toc.addressc0,
1922 single_toc.controlc0,
1924 single_toc.dummyc0[0],
1925 single_toc.dummyc0[1],
1926 single_toc.dummyc0[2],
1927 single_toc.dummyc0[3],
1928 single_toc.dummyc0[4],
1929 single_toc.dummyc0[5],
1930 single_toc.dummyc0[6]);
1935 sony_toc.lead_out_start_msf[0] =
1936 bcd_to_int(single_toc.lead_out_start_msf[0]);
1937 sony_toc.lead_out_start_msf[1] =
1938 bcd_to_int(single_toc.lead_out_start_msf[1]);
1939 sony_toc.lead_out_start_msf[2] =
1940 bcd_to_int(single_toc.lead_out_start_msf[2]);
1941 sony_toc.lead_out_start_lba =
1942 single_toc.lead_out_start_lba =
1943 msf_to_log(sony_toc.lead_out_start_msf);
1945 /* For points that do not exist, move the data over them
1946 to the right location. */
1947 if (single_toc.pointb0 != 0xb0) {
1948 memmove(((char *) &single_toc) + 27,
1949 ((char *) &single_toc) + 18,
1952 } else if (res_size > 18) {
1953 sony_toc.lead_out_start_msf[0] =
1954 bcd_to_int(single_toc.
1955 max_start_outer_leadout_msf
1957 sony_toc.lead_out_start_msf[1] =
1958 bcd_to_int(single_toc.
1959 max_start_outer_leadout_msf
1961 sony_toc.lead_out_start_msf[2] =
1962 bcd_to_int(single_toc.
1963 max_start_outer_leadout_msf
1965 sony_toc.lead_out_start_lba =
1966 msf_to_log(sony_toc.
1967 lead_out_start_msf);
1969 if (single_toc.pointb1 != 0xb1) {
1970 memmove(((char *) &single_toc) + 36,
1971 ((char *) &single_toc) + 27,
1975 if (single_toc.pointb2 != 0xb2) {
1976 memmove(((char *) &single_toc) + 45,
1977 ((char *) &single_toc) + 36,
1981 if (single_toc.pointb3 != 0xb3) {
1982 memmove(((char *) &single_toc) + 54,
1983 ((char *) &single_toc) + 45,
1987 if (single_toc.pointb4 != 0xb4) {
1988 memmove(((char *) &single_toc) + 63,
1989 ((char *) &single_toc) + 54,
1993 if (single_toc.pointc0 != 0xc0) {
1994 memmove(((char *) &single_toc) + 72,
1995 ((char *) &single_toc) + 63,
2001 ("start track lba %u, leadout start lba %u\n",
2002 single_toc.start_track_lba,
2003 single_toc.lead_out_start_lba);
2009 bcd_to_int(single_toc.last_track_num)
2011 bcd_to_int(single_toc.
2012 first_track_num); i++) {
2014 ("trk %02d: add 0x%01x, con 0x%01x, track %02d, start min %02d, sec %02d, frame %02d\n",
2016 single_toc.tracks[i].address,
2017 single_toc.tracks[i].control,
2018 bcd_to_int(single_toc.
2020 bcd_to_int(single_toc.
2024 bcd_to_int(single_toc.
2028 bcd_to_int(single_toc.
2033 bcd_to_int(single_toc.
2036 bcd_to_int(single_toc.
2040 bcd_to_int(single_toc.
2043 bcd_to_int(single_toc.
2048 ("min track number %d, max track number %d\n",
2053 /* prepare a special table of contents for a CD-I disc. They don't have one. */
2054 if (single_toc.disk_type == 0x10 &&
2055 single_toc.first_track_num == 2 &&
2056 single_toc.last_track_num == 2 /* CD-I */ ) {
2057 sony_toc.tracks[totaltracks].address = 1;
2058 sony_toc.tracks[totaltracks].control = 4; /* force data tracks */
2059 sony_toc.tracks[totaltracks].track = 1;
2060 sony_toc.tracks[totaltracks].
2061 track_start_msf[0] = 0;
2062 sony_toc.tracks[totaltracks].
2063 track_start_msf[1] = 2;
2064 sony_toc.tracks[totaltracks].
2065 track_start_msf[2] = 0;
2069 /* gather track entries from this session */
2075 bcd_to_int(single_toc.last_track_num)
2077 bcd_to_int(single_toc.
2079 i++, totaltracks++) {
2080 sony_toc.tracks[totaltracks].
2082 single_toc.tracks[i].address;
2083 sony_toc.tracks[totaltracks].
2085 single_toc.tracks[i].control;
2086 sony_toc.tracks[totaltracks].
2088 bcd_to_int(single_toc.
2090 sony_toc.tracks[totaltracks].
2091 track_start_msf[0] =
2092 bcd_to_int(single_toc.
2094 track_start_msf[0]);
2095 sony_toc.tracks[totaltracks].
2096 track_start_msf[1] =
2097 bcd_to_int(single_toc.
2099 track_start_msf[1]);
2100 sony_toc.tracks[totaltracks].
2101 track_start_msf[2] =
2102 bcd_to_int(single_toc.
2104 track_start_msf[2]);
2108 msf_to_log(sony_toc.
2113 sony_toc.tracks[totaltracks].
2117 tracks[totaltracks].
2120 sony_toc.tracks[totaltracks].
2124 tracks[totaltracks].
2128 sony_toc.first_track_num = mint;
2129 sony_toc.last_track_num = maxt;
2130 /* Disk type of last session wins. For example:
2131 CD-Extra has disk type 0 for the first session, so
2132 a dumb HiFi CD player thinks it is a plain audio CD.
2133 We are interested in the disk type of the last session,
2134 which is 0x20 (XA) for CD-Extra, so we can access the
2136 sony_toc.disk_type = single_toc.disk_type;
2137 sony_toc.sessions = session;
2139 /* don't believe everything :-) */
2141 single_toc.start_track_lba = 0;
2142 sony_toc.start_track_lba =
2143 single_toc.start_track_lba;
2145 if (session > 1 && single_toc.pointb0 == 0xb0 &&
2146 sony_toc.lead_out_start_lba ==
2147 single_toc.lead_out_start_lba) {
2151 /* Let's not get carried away... */
2153 printk("cdu31a: too many sessions: %d\n",
2159 sony_toc.track_entries = totaltracks;
2160 /* add one entry for the LAST track with track number CDROM_LEADOUT */
2161 sony_toc.tracks[totaltracks].address = single_toc.address2;
2162 sony_toc.tracks[totaltracks].control = single_toc.control2;
2163 sony_toc.tracks[totaltracks].track = CDROM_LEADOUT;
2164 sony_toc.tracks[totaltracks].track_start_msf[0] =
2165 sony_toc.lead_out_start_msf[0];
2166 sony_toc.tracks[totaltracks].track_start_msf[1] =
2167 sony_toc.lead_out_start_msf[1];
2168 sony_toc.tracks[totaltracks].track_start_msf[2] =
2169 sony_toc.lead_out_start_msf[2];
2175 ("Disk session %d, start track: %d, stop track: %d\n",
2176 session, single_toc.start_track_lba,
2177 single_toc.lead_out_start_lba);
2181 printk("Leaving sony_get_toc\n");
2187 * Uniform cdrom interface function
2188 * return multisession offset and sector information
2190 static int scd_get_last_session(struct cdrom_device_info *cdi,
2191 struct cdrom_multisession *ms_info)
2193 if (ms_info == NULL)
2199 ms_info->addr_format = CDROM_LBA;
2200 ms_info->addr.lba = sony_toc.start_track_lba;
2201 ms_info->xa_flag = sony_toc.disk_type == SONY_XA_DISK_TYPE ||
2202 sony_toc.disk_type == 0x10 /* CDI */ ;
2208 * Search for a specific track in the table of contents.
2210 static int find_track(int track)
2214 for (i = 0; i <= sony_toc.track_entries; i++) {
2215 if (sony_toc.tracks[i].track == track) {
2225 * Read the subcode and put it in last_sony_subcode for future use.
2227 static int read_subcode(void)
2229 unsigned int res_size;
2232 do_sony_cd_cmd(SONY_REQ_SUBCODE_ADDRESS_CMD,
2234 0, (unsigned char *) &last_sony_subcode, &res_size);
2236 || ((last_sony_subcode.exec_status[0] & 0xf0) == 0x20)) {
2237 printk("Sony CDROM error %s (read_subcode)\n",
2238 translate_error(last_sony_subcode.exec_status[1]));
2242 last_sony_subcode.track_num =
2243 bcd_to_int(last_sony_subcode.track_num);
2244 last_sony_subcode.index_num =
2245 bcd_to_int(last_sony_subcode.index_num);
2246 last_sony_subcode.abs_msf[0] =
2247 bcd_to_int(last_sony_subcode.abs_msf[0]);
2248 last_sony_subcode.abs_msf[1] =
2249 bcd_to_int(last_sony_subcode.abs_msf[1]);
2250 last_sony_subcode.abs_msf[2] =
2251 bcd_to_int(last_sony_subcode.abs_msf[2]);
2253 last_sony_subcode.rel_msf[0] =
2254 bcd_to_int(last_sony_subcode.rel_msf[0]);
2255 last_sony_subcode.rel_msf[1] =
2256 bcd_to_int(last_sony_subcode.rel_msf[1]);
2257 last_sony_subcode.rel_msf[2] =
2258 bcd_to_int(last_sony_subcode.rel_msf[2]);
2263 * Uniform cdrom interface function
2264 * return the media catalog number found on some older audio cds
2267 scd_get_mcn(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
2269 unsigned char resbuffer[2 + 14];
2270 unsigned char *mcnp = mcn->medium_catalog_number;
2271 unsigned char *resp = resbuffer + 3;
2272 unsigned int res_size;
2274 memset(mcn->medium_catalog_number, 0, 14);
2275 do_sony_cd_cmd(SONY_REQ_UPC_EAN_CMD,
2276 NULL, 0, resbuffer, &res_size);
2277 if ((res_size < 2) || ((resbuffer[0] & 0xf0) == 0x20));
2279 /* packed bcd to single ASCII digits */
2280 *mcnp++ = (*resp >> 4) + '0';
2281 *mcnp++ = (*resp++ & 0x0f) + '0';
2282 *mcnp++ = (*resp >> 4) + '0';
2283 *mcnp++ = (*resp++ & 0x0f) + '0';
2284 *mcnp++ = (*resp >> 4) + '0';
2285 *mcnp++ = (*resp++ & 0x0f) + '0';
2286 *mcnp++ = (*resp >> 4) + '0';
2287 *mcnp++ = (*resp++ & 0x0f) + '0';
2288 *mcnp++ = (*resp >> 4) + '0';
2289 *mcnp++ = (*resp++ & 0x0f) + '0';
2290 *mcnp++ = (*resp >> 4) + '0';
2291 *mcnp++ = (*resp++ & 0x0f) + '0';
2292 *mcnp++ = (*resp >> 4) + '0';
2300 * Get the subchannel info like the CDROMSUBCHNL command wants to see it. If
2301 * the drive is playing, the subchannel needs to be read (since it would be
2302 * changing). If the drive is paused or completed, the subcode information has
2303 * already been stored, just use that. The ioctl call wants things in decimal
2304 * (not BCD), so all the conversions are done.
2306 static int sony_get_subchnl_info(struct cdrom_subchnl *schi)
2308 /* Get attention stuff */
2309 while (handle_sony_cd_attention());
2312 if (!sony_toc_read) {
2316 switch (sony_audio_status) {
2317 case CDROM_AUDIO_NO_STATUS:
2318 case CDROM_AUDIO_PLAY:
2319 if (read_subcode() < 0) {
2324 case CDROM_AUDIO_PAUSED:
2325 case CDROM_AUDIO_COMPLETED:
2329 case CDROM_AUDIO_NO_STATUS:
2330 schi->cdsc_audiostatus = sony_audio_status;
2334 case CDROM_AUDIO_INVALID:
2335 case CDROM_AUDIO_ERROR:
2340 schi->cdsc_audiostatus = sony_audio_status;
2341 schi->cdsc_adr = last_sony_subcode.address;
2342 schi->cdsc_ctrl = last_sony_subcode.control;
2343 schi->cdsc_trk = last_sony_subcode.track_num;
2344 schi->cdsc_ind = last_sony_subcode.index_num;
2345 if (schi->cdsc_format == CDROM_MSF) {
2346 schi->cdsc_absaddr.msf.minute =
2347 last_sony_subcode.abs_msf[0];
2348 schi->cdsc_absaddr.msf.second =
2349 last_sony_subcode.abs_msf[1];
2350 schi->cdsc_absaddr.msf.frame =
2351 last_sony_subcode.abs_msf[2];
2353 schi->cdsc_reladdr.msf.minute =
2354 last_sony_subcode.rel_msf[0];
2355 schi->cdsc_reladdr.msf.second =
2356 last_sony_subcode.rel_msf[1];
2357 schi->cdsc_reladdr.msf.frame =
2358 last_sony_subcode.rel_msf[2];
2359 } else if (schi->cdsc_format == CDROM_LBA) {
2360 schi->cdsc_absaddr.lba =
2361 msf_to_log(last_sony_subcode.abs_msf);
2362 schi->cdsc_reladdr.lba =
2363 msf_to_log(last_sony_subcode.rel_msf);
2369 /* Get audio data from the drive. This is fairly complex because I
2370 am looking for status and data at the same time, but if I get status
2371 then I just look for data. I need to get the status immediately so
2372 the switch from audio to data tracks will happen quickly. */
2374 read_audio_data(char *buffer, unsigned char res_reg[], int *res_size)
2376 unsigned long retry_count;
2385 /* Wait for the drive to tell us we have something */
2386 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
2387 continue_read_audio_wait:
2388 while (time_before(jiffies, retry_count) && !(is_data_ready())
2389 && !(is_result_ready() || result_read)) {
2390 while (handle_sony_cd_attention());
2394 if (!(is_data_ready())) {
2395 if (is_result_ready() && !result_read) {
2396 get_result(res_reg, res_size);
2398 /* Read block status and continue waiting for data. */
2399 if ((res_reg[0] & 0xf0) == 0x50) {
2401 goto continue_read_audio_wait;
2403 /* Invalid data from the drive. Shut down the operation. */
2404 else if ((res_reg[0] & 0xf0) != 0x20) {
2406 ("CDU31A: Got result that should have been error: %d\n",
2409 res_reg[1] = SONY_BAD_DATA_ERR;
2415 printk("CDU31A timeout out %d\n", __LINE__);
2418 res_reg[1] = SONY_TIMEOUT_OP_ERR;
2425 /* If data block, then get 2340 bytes offset by 12. */
2426 if (sony_raw_data_mode) {
2427 insb(sony_cd_read_reg, buffer + CD_XA_HEAD,
2430 /* Audio gets the whole 2352 bytes. */
2431 insb(sony_cd_read_reg, buffer, CD_FRAMESIZE_RAW);
2434 /* If I haven't already gotten the result, get it now. */
2436 /* Wait for the drive to tell us we have something */
2437 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
2438 while (time_before(jiffies, retry_count)
2439 && !(is_result_ready())) {
2440 while (handle_sony_cd_attention());
2445 if (!is_result_ready()) {
2447 printk("CDU31A timeout out %d\n",
2451 res_reg[1] = SONY_TIMEOUT_OP_ERR;
2456 get_result(res_reg, res_size);
2460 if ((res_reg[0] & 0xf0) == 0x50) {
2461 if ((res_reg[0] == SONY_NO_CIRC_ERR_BLK_STAT)
2462 || (res_reg[0] == SONY_NO_LECC_ERR_BLK_STAT)
2463 || (res_reg[0] == SONY_RECOV_LECC_ERR_BLK_STAT)
2464 || (res_reg[0] == SONY_NO_ERR_DETECTION_STAT)) {
2465 /* Ok, nothing to do. */
2467 printk("CDU31A: Data block error: 0x%x\n",
2470 res_reg[1] = SONY_BAD_DATA_ERR;
2473 } else if ((res_reg[0] & 0xf0) != 0x20) {
2474 /* The drive gave me bad status, I don't know what to do.
2475 Reset the driver and return an error. */
2476 printk("CDU31A: Invalid block status: 0x%x\n",
2480 res_reg[1] = SONY_BAD_DATA_ERR;
2486 /* Perform a raw data read. This will automatically detect the
2487 track type and read the proper data (audio or data). */
2488 static int read_audio(struct cdrom_read_audio *ra)
2491 unsigned char params[2];
2492 unsigned char res_reg[12];
2493 unsigned int res_size;
2494 unsigned int cframe;
2495 unsigned long flags;
2498 * Make sure no one else is using the driver; wait for them
2499 * to finish if it is so.
2503 while (sony_inuse) {
2504 interruptible_sleep_on(&sony_wait);
2505 if (signal_pending(current)) {
2506 restore_flags(flags);
2511 has_cd_task = current;
2512 restore_flags(flags);
2514 if (!sony_spun_up) {
2518 /* Set the drive to do raw operations. */
2519 params[0] = SONY_SD_DECODE_PARAM;
2520 params[1] = 0x06 | sony_raw_data_mode;
2521 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2522 params, 2, res_reg, &res_size);
2523 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20)) {
2524 printk("CDU31A: Unable to set decode params: 0x%2.2x\n",
2529 /* From here down, we have to goto exit_read_audio instead of returning
2530 because the drive parameters have to be set back to data before
2534 /* start_request clears out any readahead data, so it should be safe. */
2535 if (start_request(ra->addr.lba, ra->nframes, 1)) {
2537 goto exit_read_audio;
2540 /* For every requested frame. */
2542 while (cframe < ra->nframes) {
2543 read_audio_data(readahead_buffer, res_reg, &res_size);
2544 if ((res_reg[0] & 0xf0) == 0x20) {
2545 if (res_reg[1] == SONY_BAD_DATA_ERR) {
2547 ("CDU31A: Data error on audio sector %d\n",
2548 ra->addr.lba + cframe);
2549 } else if (res_reg[1] == SONY_ILL_TRACK_R_ERR) {
2550 /* Illegal track type, change track types and start over. */
2551 sony_raw_data_mode =
2552 (sony_raw_data_mode) ? 0 : 1;
2554 /* Set the drive mode. */
2555 params[0] = SONY_SD_DECODE_PARAM;
2556 params[1] = 0x06 | sony_raw_data_mode;
2557 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2559 2, res_reg, &res_size);
2561 || ((res_reg[0] & 0xf0) == 0x20)) {
2563 ("CDU31A: Unable to set decode params: 0x%2.2x\n",
2566 goto exit_read_audio;
2569 /* Restart the request on the current frame. */
2571 (ra->addr.lba + cframe,
2572 ra->nframes - cframe, 1)) {
2574 goto exit_read_audio;
2577 /* Don't go back to the top because don't want to get into
2578 and infinite loop. A lot of code gets duplicated, but
2579 that's no big deal, I don't guess. */
2580 read_audio_data(readahead_buffer, res_reg,
2582 if ((res_reg[0] & 0xf0) == 0x20) {
2584 SONY_BAD_DATA_ERR) {
2586 ("CDU31A: Data error on audio sector %d\n",
2591 ("CDU31A: Error reading audio data on sector %d: %s\n",
2592 ra->addr.lba + cframe,
2596 goto exit_read_audio;
2598 } else if (copy_to_user((char *)(ra->buf +
2603 CD_FRAMESIZE_RAW)) {
2605 goto exit_read_audio;
2609 ("CDU31A: Error reading audio data on sector %d: %s\n",
2610 ra->addr.lba + cframe,
2611 translate_error(res_reg[1]));
2613 goto exit_read_audio;
2615 } else if (copy_to_user((char *)(ra->buf + (CD_FRAMESIZE_RAW *
2617 (char *)readahead_buffer,
2618 CD_FRAMESIZE_RAW)) {
2620 goto exit_read_audio;
2626 get_result(res_reg, &res_size);
2627 if ((res_reg[0] & 0xf0) == 0x20) {
2628 printk("CDU31A: Error return from audio read: %s\n",
2629 translate_error(res_reg[1]));
2631 goto exit_read_audio;
2636 /* Set the drive mode back to the proper one for the disk. */
2637 params[0] = SONY_SD_DECODE_PARAM;
2638 if (!sony_xa_mode) {
2643 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2644 params, 2, res_reg, &res_size);
2645 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20)) {
2646 printk("CDU31A: Unable to reset decode params: 0x%2.2x\n",
2653 wake_up_interruptible(&sony_wait);
2659 do_sony_cd_cmd_chk(const char *name,
2661 unsigned char *params,
2662 unsigned int num_params,
2663 unsigned char *result_buffer, unsigned int *result_size)
2665 do_sony_cd_cmd(cmd, params, num_params, result_buffer,
2667 if ((*result_size < 2) || ((result_buffer[0] & 0xf0) == 0x20)) {
2668 printk("Sony CDROM error %s (CDROM%s)\n",
2669 translate_error(result_buffer[1]), name);
2676 * Uniform cdrom interface function
2679 static int scd_tray_move(struct cdrom_device_info *cdi, int position)
2681 if (position == 1 /* open tray */ ) {
2682 unsigned char res_reg[12];
2683 unsigned int res_size;
2685 do_sony_cd_cmd(SONY_AUDIO_STOP_CMD, NULL, 0, res_reg,
2687 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg,
2690 sony_audio_status = CDROM_AUDIO_INVALID;
2691 return do_sony_cd_cmd_chk("EJECT", SONY_EJECT_CMD, NULL, 0,
2692 res_reg, &res_size);
2694 if (0 == scd_spinup())
2701 * The big ugly ioctl handler.
2703 static int scd_audio_ioctl(struct cdrom_device_info *cdi,
2704 unsigned int cmd, void *arg)
2706 unsigned char res_reg[12];
2707 unsigned int res_size;
2708 unsigned char params[7];
2713 case CDROMSTART: /* Spin up the drive */
2714 return do_sony_cd_cmd_chk("START", SONY_SPIN_UP_CMD, NULL,
2715 0, res_reg, &res_size);
2718 case CDROMSTOP: /* Spin down the drive */
2719 do_sony_cd_cmd(SONY_AUDIO_STOP_CMD, NULL, 0, res_reg,
2723 * Spin the drive down, ignoring the error if the disk was
2724 * already not spinning.
2726 sony_audio_status = CDROM_AUDIO_NO_STATUS;
2727 return do_sony_cd_cmd_chk("STOP", SONY_SPIN_DOWN_CMD, NULL,
2728 0, res_reg, &res_size);
2730 case CDROMPAUSE: /* Pause the drive */
2731 if (do_sony_cd_cmd_chk
2732 ("PAUSE", SONY_AUDIO_STOP_CMD, NULL, 0, res_reg,
2735 /* Get the current position and save it for resuming */
2736 if (read_subcode() < 0) {
2739 cur_pos_msf[0] = last_sony_subcode.abs_msf[0];
2740 cur_pos_msf[1] = last_sony_subcode.abs_msf[1];
2741 cur_pos_msf[2] = last_sony_subcode.abs_msf[2];
2742 sony_audio_status = CDROM_AUDIO_PAUSED;
2746 case CDROMRESUME: /* Start the drive after being paused */
2747 if (sony_audio_status != CDROM_AUDIO_PAUSED) {
2751 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg,
2754 /* Start the drive at the saved position. */
2755 params[1] = int_to_bcd(cur_pos_msf[0]);
2756 params[2] = int_to_bcd(cur_pos_msf[1]);
2757 params[3] = int_to_bcd(cur_pos_msf[2]);
2758 params[4] = int_to_bcd(final_pos_msf[0]);
2759 params[5] = int_to_bcd(final_pos_msf[1]);
2760 params[6] = int_to_bcd(final_pos_msf[2]);
2762 if (do_sony_cd_cmd_chk
2763 ("RESUME", SONY_AUDIO_PLAYBACK_CMD, params, 7, res_reg,
2766 sony_audio_status = CDROM_AUDIO_PLAY;
2769 case CDROMPLAYMSF: /* Play starting at the given MSF address. */
2770 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg,
2773 /* The parameters are given in int, must be converted */
2774 for (i = 1; i < 7; i++) {
2776 int_to_bcd(((unsigned char *) arg)[i - 1]);
2779 if (do_sony_cd_cmd_chk
2780 ("PLAYMSF", SONY_AUDIO_PLAYBACK_CMD, params, 7,
2781 res_reg, &res_size) < 0)
2784 /* Save the final position for pauses and resumes */
2785 final_pos_msf[0] = bcd_to_int(params[4]);
2786 final_pos_msf[1] = bcd_to_int(params[5]);
2787 final_pos_msf[2] = bcd_to_int(params[6]);
2788 sony_audio_status = CDROM_AUDIO_PLAY;
2791 case CDROMREADTOCHDR: /* Read the table of contents header */
2793 struct cdrom_tochdr *hdr;
2796 if (!sony_toc_read) {
2800 hdr = (struct cdrom_tochdr *) arg;
2801 hdr->cdth_trk0 = sony_toc.first_track_num;
2802 hdr->cdth_trk1 = sony_toc.last_track_num;
2806 case CDROMREADTOCENTRY: /* Read a given table of contents entry */
2808 struct cdrom_tocentry *entry;
2810 unsigned char *msf_val = NULL;
2813 if (!sony_toc_read) {
2817 entry = (struct cdrom_tocentry *) arg;
2819 track_idx = find_track(entry->cdte_track);
2820 if (track_idx < 0) {
2825 sony_toc.tracks[track_idx].address;
2827 sony_toc.tracks[track_idx].control;
2829 sony_toc.tracks[track_idx].track_start_msf;
2831 /* Logical buffer address or MSF format requested? */
2832 if (entry->cdte_format == CDROM_LBA) {
2833 entry->cdte_addr.lba = msf_to_log(msf_val);
2834 } else if (entry->cdte_format == CDROM_MSF) {
2835 entry->cdte_addr.msf.minute = *msf_val;
2836 entry->cdte_addr.msf.second =
2838 entry->cdte_addr.msf.frame =
2845 case CDROMPLAYTRKIND: /* Play a track. This currently ignores index. */
2847 struct cdrom_ti *ti = (struct cdrom_ti *) arg;
2851 if (!sony_toc_read) {
2855 if ((ti->cdti_trk0 < sony_toc.first_track_num)
2856 || (ti->cdti_trk0 > sony_toc.last_track_num)
2857 || (ti->cdti_trk1 < ti->cdti_trk0)) {
2861 track_idx = find_track(ti->cdti_trk0);
2862 if (track_idx < 0) {
2866 int_to_bcd(sony_toc.tracks[track_idx].
2867 track_start_msf[0]);
2869 int_to_bcd(sony_toc.tracks[track_idx].
2870 track_start_msf[1]);
2872 int_to_bcd(sony_toc.tracks[track_idx].
2873 track_start_msf[2]);
2876 * If we want to stop after the last track, use the lead-out
2879 if (ti->cdti_trk1 >= sony_toc.last_track_num) {
2880 track_idx = find_track(CDROM_LEADOUT);
2882 track_idx = find_track(ti->cdti_trk1 + 1);
2884 if (track_idx < 0) {
2888 int_to_bcd(sony_toc.tracks[track_idx].
2889 track_start_msf[0]);
2891 int_to_bcd(sony_toc.tracks[track_idx].
2892 track_start_msf[1]);
2894 int_to_bcd(sony_toc.tracks[track_idx].
2895 track_start_msf[2]);
2898 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg,
2901 do_sony_cd_cmd(SONY_AUDIO_PLAYBACK_CMD, params, 7,
2902 res_reg, &res_size);
2905 || ((res_reg[0] & 0xf0) == 0x20)) {
2906 printk("Params: %x %x %x %x %x %x %x\n",
2907 params[0], params[1], params[2],
2908 params[3], params[4], params[5],
2911 ("Sony CDROM error %s (CDROMPLAYTRKIND)\n",
2912 translate_error(res_reg[1]));
2916 /* Save the final position for pauses and resumes */
2917 final_pos_msf[0] = bcd_to_int(params[4]);
2918 final_pos_msf[1] = bcd_to_int(params[5]);
2919 final_pos_msf[2] = bcd_to_int(params[6]);
2920 sony_audio_status = CDROM_AUDIO_PLAY;
2924 case CDROMVOLCTRL: /* Volume control. What volume does this change, anyway? */
2926 struct cdrom_volctrl *volctrl =
2927 (struct cdrom_volctrl *) arg;
2929 params[0] = SONY_SD_AUDIO_VOLUME;
2930 params[1] = volctrl->channel0;
2931 params[2] = volctrl->channel1;
2932 return do_sony_cd_cmd_chk("VOLCTRL",
2933 SONY_SET_DRIVE_PARAM_CMD,
2937 case CDROMSUBCHNL: /* Get subchannel info */
2938 return sony_get_subchnl_info((struct cdrom_subchnl *) arg);
2945 static int scd_dev_ioctl(struct cdrom_device_info *cdi,
2946 unsigned int cmd, unsigned long arg)
2951 case CDROMREADAUDIO: /* Read 2352 byte audio tracks and 2340 byte
2954 struct cdrom_read_audio ra;
2958 if (!sony_toc_read) {
2962 if (copy_from_user(&ra, (char *) arg, sizeof(ra)))
2965 if (ra.nframes == 0) {
2969 i = verify_area(VERIFY_WRITE, ra.buf,
2970 CD_FRAMESIZE_RAW * ra.nframes);
2974 if (ra.addr_format == CDROM_LBA) {
2976 sony_toc.lead_out_start_lba)
2977 || (ra.addr.lba + ra.nframes >=
2978 sony_toc.lead_out_start_lba)) {
2981 } else if (ra.addr_format == CDROM_MSF) {
2982 if ((ra.addr.msf.minute >= 75)
2983 || (ra.addr.msf.second >= 60)
2984 || (ra.addr.msf.frame >= 75)) {
2988 ra.addr.lba = ((ra.addr.msf.minute * 4500)
2989 + (ra.addr.msf.second * 75)
2990 + ra.addr.msf.frame);
2992 sony_toc.lead_out_start_lba)
2993 || (ra.addr.lba + ra.nframes >=
2994 sony_toc.lead_out_start_lba)) {
2998 /* I know, this can go negative on an unsigned. However,
2999 the first thing done to the data is to add this value,
3000 so this should compensate and allow direct msf access. */
3001 ra.addr.lba -= LOG_START_OFFSET;
3006 return (read_audio(&ra));
3016 static int scd_spinup(void)
3018 unsigned char res_reg[12];
3019 unsigned int res_size;
3025 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
3027 /* The drive sometimes returns error 0. I don't know why, but ignore
3028 it. It seems to mean the drive has already done the operation. */
3029 if ((res_size < 2) || ((res_reg[0] != 0) && (res_reg[1] != 0))) {
3030 printk("Sony CDROM %s error (scd_open, spin up)\n",
3031 translate_error(res_reg[1]));
3035 do_sony_cd_cmd(SONY_READ_TOC_CMD, NULL, 0, res_reg, &res_size);
3037 /* The drive sometimes returns error 0. I don't know why, but ignore
3038 it. It seems to mean the drive has already done the operation. */
3039 if ((res_size < 2) || ((res_reg[0] != 0) && (res_reg[1] != 0))) {
3040 /* If the drive is already playing, it's ok. */
3041 if ((res_reg[1] == SONY_AUDIO_PLAYING_ERR)
3042 || (res_reg[1] == 0)) {
3046 /* If the drive says it is not spun up (even though we just did it!)
3047 then retry the operation at least a few times. */
3048 if ((res_reg[1] == SONY_NOT_SPIN_ERR)
3049 && (num_spin_ups < MAX_CDU31A_RETRIES)) {
3051 goto respinup_on_open;
3054 printk("Sony CDROM error %s (scd_open, read toc)\n",
3055 translate_error(res_reg[1]));
3056 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg,
3064 * Open the drive for operations. Spin the drive up and read the table of
3065 * contents if these have not already been done.
3067 static int scd_open(struct cdrom_device_info *cdi, int openmode)
3069 unsigned char res_reg[12];
3070 unsigned int res_size;
3071 unsigned char params[2];
3073 if (sony_usage == 0) {
3074 if (scd_spinup() != 0)
3077 if (!sony_toc_read) {
3078 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0,
3079 res_reg, &res_size);
3083 /* For XA on the CDU31A only, we have to do special reads.
3084 The CDU33A handles XA automagically. */
3085 /* if ( (sony_toc.disk_type == SONY_XA_DISK_TYPE) */
3086 if ((sony_toc.disk_type != 0x00)
3087 && (!is_double_speed)) {
3088 params[0] = SONY_SD_DECODE_PARAM;
3090 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
3091 params, 2, res_reg, &res_size);
3093 || ((res_reg[0] & 0xf0) == 0x20)) {
3095 ("CDU31A: Unable to set XA params: 0x%2.2x\n",
3100 /* A non-XA disk. Set the parms back if necessary. */
3101 else if (sony_xa_mode) {
3102 params[0] = SONY_SD_DECODE_PARAM;
3104 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
3105 params, 2, res_reg, &res_size);
3107 || ((res_reg[0] & 0xf0) == 0x20)) {
3109 ("CDU31A: Unable to reset XA params: 0x%2.2x\n",
3125 * Close the drive. Spin it down if no task is using it. The spin
3126 * down will fail if playing audio, so audio play is OK.
3128 static void scd_release(struct cdrom_device_info *cdi)
3130 if (sony_usage == 1) {
3131 unsigned char res_reg[12];
3132 unsigned int res_size;
3134 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg,
3142 static struct cdrom_device_ops scd_dops = {
3144 .release = scd_release,
3145 .drive_status = scd_drive_status,
3146 .media_changed = scd_media_changed,
3147 .tray_move = scd_tray_move,
3148 .lock_door = scd_lock_door,
3149 .select_speed = scd_select_speed,
3150 .get_last_session = scd_get_last_session,
3151 .get_mcn = scd_get_mcn,
3153 .audio_ioctl = scd_audio_ioctl,
3154 .dev_ioctl = scd_dev_ioctl,
3155 .capability = CDC_OPEN_TRAY | CDC_CLOSE_TRAY | CDC_LOCK |
3156 CDC_SELECT_SPEED | CDC_MULTI_SESSION |
3157 CDC_MULTI_SESSION | CDC_MCN |
3158 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO |
3159 CDC_RESET | CDC_IOCTLS | CDC_DRIVE_STATUS,
3163 static struct cdrom_device_info scd_info = {
3170 static int scd_block_open(struct inode *inode, struct file *file)
3172 return cdrom_open(&scd_info, inode, file);
3175 static int scd_block_release(struct inode *inode, struct file *file)
3177 return cdrom_release(&scd_info, file);
3180 static int scd_block_ioctl(struct inode *inode, struct file *file,
3181 unsigned cmd, unsigned long arg)
3183 return cdrom_ioctl(&scd_info, inode, cmd, arg);
3186 static int scd_block_media_changed(struct gendisk *disk)
3188 return cdrom_media_changed(&scd_info);
3191 struct block_device_operations scd_bdops =
3193 .owner = THIS_MODULE,
3194 .open = scd_block_open,
3195 .release = scd_block_release,
3196 .ioctl = scd_block_ioctl,
3197 .media_changed = scd_block_media_changed,
3200 static struct gendisk *scd_gendisk;
3202 /* The different types of disc loading mechanisms supported */
3203 static char *load_mech[] __initdata =
3204 { "caddy", "tray", "pop-up", "unknown" };
3207 get_drive_configuration(unsigned short base_io,
3208 unsigned char res_reg[], unsigned int *res_size)
3210 unsigned long retry_count;
3213 if (!request_region(base_io, 4, "cdu31a"))
3216 /* Set the base address */
3217 cdu31a_port = base_io;
3219 /* Set up all the register locations */
3220 sony_cd_cmd_reg = cdu31a_port + SONY_CMD_REG_OFFSET;
3221 sony_cd_param_reg = cdu31a_port + SONY_PARAM_REG_OFFSET;
3222 sony_cd_write_reg = cdu31a_port + SONY_WRITE_REG_OFFSET;
3223 sony_cd_control_reg = cdu31a_port + SONY_CONTROL_REG_OFFSET;
3224 sony_cd_status_reg = cdu31a_port + SONY_STATUS_REG_OFFSET;
3225 sony_cd_result_reg = cdu31a_port + SONY_RESULT_REG_OFFSET;
3226 sony_cd_read_reg = cdu31a_port + SONY_READ_REG_OFFSET;
3227 sony_cd_fifost_reg = cdu31a_port + SONY_FIFOST_REG_OFFSET;
3230 * Check to see if anything exists at the status register location.
3231 * I don't know if this is a good way to check, but it seems to work
3234 if (read_status_register() != 0xff) {
3236 * Reset the drive and wait for attention from it (to say it's reset).
3237 * If you don't wait, the next operation will probably fail.
3240 retry_count = jiffies + SONY_RESET_TIMEOUT;
3241 while (time_before(jiffies, retry_count)
3242 && (!is_attention())) {
3247 /* If attention is never seen probably not a CDU31a present */
3248 if (!is_attention()) {
3255 * Get the drive configuration.
3257 do_sony_cd_cmd(SONY_REQ_DRIVE_CONFIG_CMD,
3259 0, (unsigned char *) res_reg, res_size);
3260 if (*res_size <= 2 || (res_reg[0] & 0xf0) != 0)
3265 /* Return an error */
3268 release_region(cdu31a_port, 4);
3275 * Set up base I/O and interrupts, called from main.c.
3279 static int __init cdu31a_setup(char *strings)
3283 (void) get_options(strings, ARRAY_SIZE(ints), ints);
3286 cdu31a_port = ints[1];
3289 cdu31a_irq = ints[2];
3291 if ((strings != NULL) && (*strings != '\0')) {
3292 if (strcmp(strings, "PAS") == 0) {
3295 printk("CDU31A: Unknown interface type: %s\n",
3303 __setup("cdu31a=", cdu31a_setup);
3308 * Initialize the driver.
3310 int __init cdu31a_init(void)
3312 struct s_sony_drive_config drive_config;
3313 struct gendisk *disk;
3315 unsigned int res_size;
3322 * According to Alex Freed (freed@europa.orion.adobe.com), this is
3323 * required for the Fusion CD-16 package. If the sound driver is
3324 * loaded, it should work fine, but just in case...
3326 * The following turn on the CD-ROM interface for a Fusion CD-16.
3328 if (sony_pas_init) {
3333 /* Setting the base I/O address to 0xffff will disable it. */
3334 if (cdu31a_port == 0xffff)
3337 if (cdu31a_port != 0) {
3338 /* Need IRQ 0 because we can't sleep here. */
3339 tmp_irq = cdu31a_irq;
3341 if (!get_drive_configuration(cdu31a_port,
3342 drive_config.exec_status,
3345 cdu31a_irq = tmp_irq;
3348 for (i = 0; cdu31a_addresses[i].base; i++) {
3349 if (get_drive_configuration(cdu31a_addresses[i].base,
3350 drive_config.exec_status,
3352 cdu31a_irq = cdu31a_addresses[i].int_num;
3360 if (register_blkdev(MAJOR_NR, "cdu31a"))
3363 disk = alloc_disk(1);
3366 disk->major = MAJOR_NR;
3367 disk->first_minor = 0;
3368 sprintf(disk->disk_name, "cdu31a");
3369 disk->fops = &scd_bdops;
3370 disk->flags = GENHD_FL_CD;
3372 if (SONY_HWC_DOUBLE_SPEED(drive_config))
3373 is_double_speed = 1;
3375 tmp_irq = cdu31a_irq; /* Need IRQ 0 because we can't sleep here. */
3378 set_drive_params(sony_speed);
3380 cdu31a_irq = tmp_irq;
3382 if (cdu31a_irq > 0) {
3384 (cdu31a_irq, cdu31a_interrupt, SA_INTERRUPT,
3387 ("Unable to grab IRQ%d for the CDU31A driver\n",
3393 sprintf(msg, "Sony I/F CDROM : %8.8s %16.16s %8.8s\n",
3394 drive_config.vendor_id,
3395 drive_config.product_id,
3396 drive_config.product_rev_level);
3397 sprintf(buf, " Capabilities: %s",
3398 load_mech[SONY_HWC_GET_LOAD_MECH(drive_config)]);
3400 if (SONY_HWC_AUDIO_PLAYBACK(drive_config))
3401 strcat(msg, ", audio");
3403 deficiency |= CDC_PLAY_AUDIO;
3404 if (SONY_HWC_EJECT(drive_config))
3405 strcat(msg, ", eject");
3407 deficiency |= CDC_OPEN_TRAY;
3408 if (SONY_HWC_LED_SUPPORT(drive_config))
3409 strcat(msg, ", LED");
3410 if (SONY_HWC_ELECTRIC_VOLUME(drive_config))
3411 strcat(msg, ", elec. Vol");
3412 if (SONY_HWC_ELECTRIC_VOLUME_CTL(drive_config))
3413 strcat(msg, ", sep. Vol");
3414 if (is_double_speed)
3415 strcat(msg, ", double speed");
3417 deficiency |= CDC_SELECT_SPEED;
3418 if (cdu31a_irq > 0) {
3419 sprintf(buf, ", irq %d", cdu31a_irq);
3425 strcmp("CD-ROM CDU31A", drive_config.product_id) == 0;
3427 cdu31a_queue = blk_init_queue(do_cdu31a_request, &cdu31a_lock);
3431 init_timer(&cdu31a_abort_timer);
3432 cdu31a_abort_timer.function = handle_abort_timeout;
3434 scd_info.mask = deficiency;
3436 if (register_cdrom(&scd_info))
3438 disk->queue = cdu31a_queue;
3445 blk_cleanup_queue(cdu31a_queue);
3448 free_irq(cdu31a_irq, NULL);
3449 printk("Unable to register CDU-31a with Uniform cdrom driver\n");
3452 if (unregister_blkdev(MAJOR_NR, "cdu31a")) {
3453 printk("Can't unregister block device for cdu31a\n");
3456 release_region(cdu31a_port, 4);
3462 void __exit cdu31a_exit(void)
3464 del_gendisk(scd_gendisk);
3465 put_disk(scd_gendisk);
3466 if (unregister_cdrom(&scd_info)) {
3468 ("Can't unregister cdu31a from Uniform cdrom driver\n");
3471 if ((unregister_blkdev(MAJOR_NR, "cdu31a") == -EINVAL)) {
3472 printk("Can't unregister cdu31a\n");
3476 blk_cleanup_queue(cdu31a_queue);
3479 free_irq(cdu31a_irq, NULL);
3481 release_region(cdu31a_port, 4);
3482 printk(KERN_INFO "cdu31a module released.\n");
3486 module_init(cdu31a_init);
3488 module_exit(cdu31a_exit);
3490 MODULE_LICENSE("GPL");
3491 MODULE_ALIAS_BLOCKDEV_MAJOR(CDU31A_CDROM_MAJOR);