1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 * Copyright 2012 Milan Jurik. All rights reserved.
25 */
26
27 #include <sys/types.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <stdio.h>
31 #include <sys/dkio.h>
32 #include <unistd.h>
33 #include <errno.h>
34 #include <libintl.h>
35 #include <sys/time.h>
36
37 #include "mmc.h"
38 #include "util.h"
39 #include "misc_scsi.h"
40 #include "transport.h"
41 #include "main.h"
42 #include "toshiba.h"
43 #include "msgs.h"
44 #include "device.h"
45
46 static int check_track_size(cd_device *dev, int trk_num,
47 struct track_info *tip);
48 static int rtoc_get_trk_sess_num(uchar_t *rtoc, size_t rtoc_len, int trk_num,
49 int *sess_nump);
50 static int rtoc_get_sess_last_trk_num(uchar_t *rtoc, size_t rtoc_len,
51 int sess_num, int *last_trk_nump);
52 static int rtoc_get_sess_leadout_lba(uchar_t *rtoc, size_t rtoc_len,
53 int sess_num, uint32_t *leadout_lba);
54 static rtoc_td_t *get_rtoc_td(rtoc_td_t *begin_tdp, rtoc_td_t *end_tdp,
55 uchar_t adr, uchar_t point);
56
57 uint32_t
read_scsi32(void * addr)58 read_scsi32(void *addr)
59 {
60 uchar_t *ad = (uchar_t *)addr;
61 uint32_t ret;
62
63 ret = ((((uint32_t)ad[0]) << 24) | (((uint32_t)ad[1]) << 16) |
64 (((uint32_t)ad[2]) << 8) | ad[3]);
65 return (ret);
66 }
67
68 uint16_t
read_scsi16(void * addr)69 read_scsi16(void *addr)
70 {
71 uchar_t *ad = (uchar_t *)addr;
72 uint16_t ret;
73
74 ret = ((((uint16_t)ad[0]) << 8) | ad[1]);
75 return (ret);
76 }
77
78 void
load_scsi32(void * addr,uint32_t v)79 load_scsi32(void *addr, uint32_t v)
80 {
81 uchar_t *ad = (uchar_t *)addr;
82
83 ad[0] = (uchar_t)(v >> 24);
84 ad[1] = (uchar_t)(v >> 16);
85 ad[2] = (uchar_t)(v >> 8);
86 ad[3] = (uchar_t)v;
87 }
88
89 void
load_scsi16(void * addr,uint16_t v)90 load_scsi16(void *addr, uint16_t v)
91 {
92 uchar_t *ad = (uchar_t *)addr;
93 ad[0] = (uchar_t)(v >> 8);
94 ad[1] = (uchar_t)v;
95 }
96 /*
97 * will get the mode page only i.e. will strip off the header.
98 */
99 int
get_mode_page(int fd,int page_no,int pc,int buf_len,uchar_t * buffer)100 get_mode_page(int fd, int page_no, int pc, int buf_len, uchar_t *buffer)
101 {
102 int ret;
103 uchar_t byte2, *buf;
104 uint_t header_len, page_len, copy_cnt;
105
106 byte2 = (uchar_t)(((pc << 6) & 0xC0) | (page_no & 0x3f));
107 buf = (uchar_t *)my_zalloc(256);
108
109 /* Ask 254 bytes only to make our IDE driver happy */
110 ret = mode_sense(fd, byte2, 1, 254, buf);
111 if (ret == 0) {
112 free(buf);
113 return (0);
114 }
115
116 header_len = 8 + read_scsi16(&buf[6]);
117 page_len = buf[header_len + 1] + 2;
118
119 copy_cnt = (page_len > buf_len) ? buf_len : page_len;
120 (void) memcpy(buffer, &buf[header_len], copy_cnt);
121 free(buf);
122
123 return (1);
124 }
125
126 /*
127 * will take care of adding mode header and any extra bytes at the end.
128 */
129 int
set_mode_page(int fd,uchar_t * buffer)130 set_mode_page(int fd, uchar_t *buffer)
131 {
132 int ret;
133 uchar_t *buf;
134 uint_t total, p_len;
135
136 p_len = buffer[1] + 2;
137 total = p_len + 8;
138 buf = (uchar_t *)my_zalloc(total);
139
140 (void) memcpy(&buf[8], buffer, p_len);
141 if (debug) {
142 int i;
143
144 (void) printf("MODE: [");
145 for (i = 0; i < p_len; i++) {
146 (void) printf("0x%02x ", (uchar_t)buffer[i]);
147 }
148
149 (void) printf("]\n");
150 }
151 ret = mode_select(fd, total, buf);
152 free(buf);
153
154 return (ret);
155 }
156
157 /*
158 * Builds track information database for track trackno. If trackno is
159 * -1, builds the database for next blank track.
160 */
161 int
build_track_info(cd_device * dev,int trackno,struct track_info * t_info)162 build_track_info(cd_device *dev, int trackno, struct track_info *t_info)
163 {
164 uchar_t *ti;
165 uchar_t toc[20]; /* 2 entries + 4 byte header */
166 int ret;
167
168 (void) memset(t_info, 0, sizeof (*t_info));
169 /* 1st try READ TRACK INFORMATION */
170 ti = (uchar_t *)my_zalloc(TRACK_INFO_SIZE);
171 t_info->ti_track_no = trackno;
172
173 /* Gererate faked information for writing to DVD */
174 if (device_type != CD_RW) {
175 uint_t bsize;
176
177 t_info->ti_flags = 0x3000;
178 t_info->ti_track_no = 1;
179 t_info->ti_session_no = 1;
180 t_info->ti_track_mode = 0x4;
181 t_info->ti_data_mode = 1;
182 t_info->ti_start_address = 0;
183
184 /* only 1 track on DVD make it max size */
185 t_info->ti_track_size = read_format_capacity(target->d_fd,
186 &bsize);
187 if (t_info->ti_track_size < MAX_CD_BLKS) {
188 t_info->ti_track_size = MAX_DVD_BLKS;
189 }
190
191 t_info->ti_nwa = 0;
192 t_info->ti_lra = 0;
193 t_info->ti_packet_size = 0x10;
194 t_info->ti_free_blocks = 0;
195 }
196
197 if (read_track_info(dev->d_fd, trackno, ti)) {
198
199 if (debug)
200 (void) printf("using read_track_info for TOC \n");
201
202 t_info->ti_track_no = ti[2];
203 t_info->ti_session_no = ti[3];
204 t_info->ti_flags = (ti[6] >> 4) & 0xf;
205 t_info->ti_flags |= (uint32_t)(ti[5] & 0xf0);
206 t_info->ti_flags |= (uint32_t)(ti[7]) << 8;
207 t_info->ti_flags |= TI_SESSION_NO_VALID | TI_FREE_BLOCKS_VALID;
208 t_info->ti_track_mode = ti[5] & 0xf;
209 if ((ti[6] & 0xf) == 0xf)
210 t_info->ti_data_mode = 0xff;
211 else
212 t_info->ti_data_mode = ti[6] & 0xf;
213 t_info->ti_start_address = read_scsi32(&ti[8]);
214 t_info->ti_nwa = read_scsi32(&ti[12]);
215 t_info->ti_free_blocks = read_scsi32(&ti[16]);
216 t_info->ti_packet_size = read_scsi32(&ti[20]);
217 t_info->ti_track_size = read_scsi32(&ti[24]);
218 t_info->ti_lra = read_scsi32(&ti[28]);
219 free(ti);
220 return (1);
221 }
222 /* READ TRACK INFORMATION not supported, try other options */
223 free(ti);
224 /*
225 * We can get info for next blank track if READ TRACK INFO is not
226 * supported.
227 */
228 if (trackno == -1)
229 return (0);
230
231 if (debug)
232 (void) printf("using READ_TOC for TOC\n");
233
234 /* Try Read TOC */
235 if (!read_toc(dev->d_fd, 0, trackno, 20, toc)) {
236 return (0);
237 }
238 t_info->ti_start_address = read_scsi32(&toc[8]);
239 t_info->ti_track_mode = toc[5] & 0xf;
240 t_info->ti_track_size = read_scsi32(&toc[16]) - read_scsi32(&toc[8]);
241 t_info->ti_data_mode = get_data_mode(dev->d_fd, read_scsi32(&toc[8]));
242
243 /* Numbers for audio tracks are always in 2K chunks */
244 if ((dev->d_blksize == 512) && ((t_info->ti_track_mode & 4) == 0)) {
245 t_info->ti_start_address /= 4;
246 t_info->ti_track_size /= 4;
247 }
248
249 /* Now find out the session thing */
250 ret = read_toc(dev->d_fd, 1, trackno, 12, toc);
251
252 /*
253 * Make sure that the call succeeds and returns the requested
254 * TOC size correctly.
255 */
256
257 if ((ret == 0) || (toc[1] != 0x0a)) {
258
259 /* For ATAPI drives or old Toshiba drives */
260 ret = read_toc_as_per_8020(dev->d_fd, 1, trackno, 12, toc);
261 }
262 /* If this goes through well TOC length will always be 0x0a */
263 if (ret && (toc[1] == 0x0a)) {
264 if (trackno >= toc[6]) {
265 t_info->ti_session_no = toc[3];
266 t_info->ti_flags |= TI_SESSION_NO_VALID;
267 }
268 /*
269 * This might be the last track of this session. If so,
270 * exclude the leadout and next lead in.
271 */
272 if (trackno == (toc[6] - 1)) {
273 /*
274 * 1.5 Min leadout + 1 min. leadin + 2 sec. pre-gap.
275 * For 2nd+ leadout it will be 0.5 min. But currently
276 * there is no direct way. And it will not happen
277 * for any normal case.
278 *
279 * 75 frames/sec, 60 sec/min, so leadin gap is
280 * ((1.5 +1)*60 + 2)*75 = 11400 frames (blocks)
281 */
282 t_info->ti_track_size -= 11400;
283 }
284 } else {
285 if (check_track_size(dev, trackno, t_info) != 1)
286 return (0);
287 }
288
289 return (1);
290 }
291
292 /*
293 * The size of the last track in one of the first N - 1 sessions of an
294 * N-session (N > 1) disc is reported incorrectly by some drives and calculated
295 * incorrectly for others, because a pre-gap/lead-out/lead-in section that ends
296 * a session is erroneously considered part of that track. This function checks
297 * for this corner case, and adjusts the track size if necessary.
298 */
299 static int
check_track_size(cd_device * dev,int trk_num,struct track_info * tip)300 check_track_size(cd_device *dev, int trk_num, struct track_info *tip)
301 {
302 size_t raw_toc_len;
303 uchar_t *raw_toc;
304 rtoc_hdr_t hdr;
305 uint32_t sess_leadout_lba;
306 int sess_last_trk_num;
307 int trk_sess_num;
308 uint32_t trk_size;
309
310 /* Request Raw TOC Header for session count. */
311 if (read_toc(dev->d_fd, FORMAT_RAW_TOC, 1,
312 sizeof (rtoc_hdr_t), (uchar_t *)&hdr) != 1)
313 return (0);
314
315 /* Is this a multi-session medium? */
316 if (hdr.rh_last_sess_num > hdr.rh_first_sess_num) {
317 /* Yes; request entire Raw TOC. */
318 raw_toc_len = read_scsi16(&hdr.rh_data_len1) + RTOC_DATA_LEN_SZ;
319 raw_toc = (uchar_t *)my_zalloc(raw_toc_len);
320
321 if (read_toc(dev->d_fd, FORMAT_RAW_TOC, 1, raw_toc_len, raw_toc)
322 != 1)
323 goto fail;
324
325 if (rtoc_get_trk_sess_num(raw_toc, raw_toc_len, trk_num,
326 &trk_sess_num) != 1)
327 goto fail;
328
329 tip->ti_session_no = trk_sess_num;
330 tip->ti_flags |= TI_SESSION_NO_VALID;
331
332 /* Is the track in one of the first N - 1 sessions? */
333 if (trk_sess_num < hdr.rh_last_sess_num) {
334 if (rtoc_get_sess_last_trk_num(raw_toc, raw_toc_len,
335 trk_sess_num, &sess_last_trk_num) != 1)
336 goto fail;
337
338 /* Is the track the last track in the session? */
339 if (trk_num == sess_last_trk_num) {
340 if (rtoc_get_sess_leadout_lba(raw_toc,
341 raw_toc_len, trk_sess_num,
342 &sess_leadout_lba) != 1)
343 goto fail;
344
345 trk_size = sess_leadout_lba -
346 tip->ti_start_address;
347
348 /* Fix track size if it was too big. */
349 if (tip->ti_track_size > trk_size)
350 tip->ti_track_size = trk_size;
351 }
352 }
353 free(raw_toc);
354 }
355 return (1);
356
357 fail:
358 free(raw_toc);
359 return (0);
360 }
361
362 /*
363 * Determine what session number a track is in by parsing the Raw TOC format of
364 * the the READ TOC/PMA/ATIP command response data.
365 */
366 static int
rtoc_get_trk_sess_num(uchar_t * rtoc,size_t rtoc_len,int trk_num,int * sess_nump)367 rtoc_get_trk_sess_num(uchar_t *rtoc, size_t rtoc_len, int trk_num,
368 int *sess_nump)
369 {
370 rtoc_td_t *tdp = (rtoc_td_t *)(rtoc + sizeof (rtoc_hdr_t));
371 rtoc_td_t *last_tdp = (rtoc_td_t *)(rtoc + rtoc_len -
372 sizeof (rtoc_td_t));
373
374 if ((tdp = get_rtoc_td(tdp, last_tdp, Q_MODE_1, (uchar_t)trk_num)) !=
375 NULL) {
376 *sess_nump = tdp->rt_session_num;
377 return (1);
378 } else
379 return (0);
380 }
381
382 /*
383 * Determine the last track number in a specified session number by parsing the
384 * Raw TOC format of the READ TOC/PMA/ATIP command response data.
385 */
386 static int
rtoc_get_sess_last_trk_num(uchar_t * rtoc,size_t rtoc_len,int sess_num,int * last_trk_nump)387 rtoc_get_sess_last_trk_num(uchar_t *rtoc, size_t rtoc_len, int sess_num,
388 int *last_trk_nump)
389 {
390 rtoc_td_t *tdp = (rtoc_td_t *)(rtoc + sizeof (rtoc_hdr_t));
391 rtoc_td_t *last_tdp = (rtoc_td_t *)(rtoc + rtoc_len -
392 sizeof (rtoc_td_t));
393
394 while ((tdp = get_rtoc_td(tdp, last_tdp, Q_MODE_1,
395 POINT_SESS_LAST_TRK)) != NULL) {
396 if (tdp->rt_session_num == sess_num) {
397 *last_trk_nump = tdp->rt_pmin;
398 return (1);
399 } else {
400 ++tdp;
401 }
402 }
403
404 return (0);
405 }
406
407 /*
408 * Determine the starting LBA of the the session leadout by parsing the Raw TOC
409 * format of the READ TOC/PMA/ATIP command response data.
410 */
411 static int
rtoc_get_sess_leadout_lba(uchar_t * rtoc,size_t rtoc_len,int sess_num,uint32_t * leadout_lba)412 rtoc_get_sess_leadout_lba(uchar_t *rtoc, size_t rtoc_len, int sess_num,
413 uint32_t *leadout_lba)
414 {
415 rtoc_td_t *tdp = (rtoc_td_t *)(rtoc + sizeof (rtoc_hdr_t));
416 rtoc_td_t *last_tdp = (rtoc_td_t *)(rtoc + rtoc_len -
417 sizeof (rtoc_td_t));
418
419 while ((tdp = get_rtoc_td(tdp, last_tdp, Q_MODE_1,
420 POINT_LEADOUT_ADDR)) != NULL) {
421 if (tdp->rt_session_num == sess_num) {
422 *leadout_lba = MSF2LBA(tdp->rt_pmin, tdp->rt_psec,
423 tdp->rt_pframe);
424 return (1);
425 } else {
426 ++tdp;
427 }
428 }
429
430 return (0);
431 }
432
433 /*
434 * Search a set of Raw TOC Track Descriptors using <'adr', 'point'> as the
435 * search key. Return a pointer to the first Track Descriptor that matches.
436 */
437 static rtoc_td_t *
get_rtoc_td(rtoc_td_t * begin_tdp,rtoc_td_t * end_tdp,uchar_t adr,uchar_t point)438 get_rtoc_td(rtoc_td_t *begin_tdp, rtoc_td_t *end_tdp, uchar_t adr,
439 uchar_t point)
440 {
441 rtoc_td_t *cur_tdp = begin_tdp;
442
443 while (cur_tdp <= end_tdp) {
444 if ((cur_tdp->rt_adr == adr) && (cur_tdp->rt_point == point))
445 return (cur_tdp);
446 else
447 cur_tdp++;
448 }
449
450 return (NULL);
451 }
452
453 uchar_t
get_data_mode(int fd,uint32_t lba)454 get_data_mode(int fd, uint32_t lba)
455 {
456 int ret;
457 uchar_t *buf;
458 uchar_t mode;
459
460 buf = (uchar_t *)my_zalloc(8);
461 ret = read_header(fd, lba, buf);
462 if (ret == 0)
463 mode = 0xff;
464 else
465 mode = buf[0];
466 free(buf);
467 return (mode);
468 }
469
470 /*
471 * Set page code 5 for TAO mode.
472 */
473 int
prepare_for_write(cd_device * dev,int track_mode,int test_write,int keep_disc_open)474 prepare_for_write(cd_device *dev, int track_mode, int test_write,
475 int keep_disc_open)
476 {
477 uchar_t *buf;
478 int no_err;
479 int reset_device;
480
481 if ((write_mode == DAO_MODE) && keep_disc_open) {
482 (void) printf(gettext(
483 "Multi-session is not supported on DVD media\n"));
484 exit(1);
485 }
486
487 if ((write_mode == DAO_MODE) && debug) {
488 (void) printf("Preparing to write in DAO\n");
489 }
490
491 (void) start_stop(dev->d_fd, 1);
492 /* Some drives do not support this command but still do it */
493 (void) rezero_unit(dev->d_fd);
494
495 buf = (uchar_t *)my_zalloc(64);
496
497 no_err = get_mode_page(dev->d_fd, 5, 0, 64, buf);
498 if (no_err)
499 no_err = ((buf[1] + 2) > 64) ? 0 : 1;
500 /*
501 * If the device is already in simulation mode and again a
502 * simulation is requested, then set the device in non-simulation
503 * 1st and then take it to simulation mode. This will flush any
504 * previous fake state in the drive.
505 */
506 if (no_err && test_write && (buf[2] & 0x10)) {
507 reset_device = 1;
508 } else {
509 reset_device = 0;
510 }
511 if (no_err != 0) {
512 buf[0] &= 0x3f;
513
514 /* set TAO or DAO writing mode */
515 buf[2] = (write_mode == TAO_MODE)?1:2;
516
517 /* set simulation flag */
518 if (test_write && (!reset_device)) {
519 buf[2] |= 0x10;
520 } else {
521 buf[2] &= ~0x10;
522 }
523
524 /* Turn on HW buffer underrun protection (BUFE) */
525 if (!test_write) {
526 buf[2] |= 0x40;
527 }
528
529 /* set track mode type */
530 if (device_type == CD_RW) {
531 buf[3] = track_mode & 0x0f; /* ctrl nibble */
532 }
533
534 if (keep_disc_open) {
535 buf[3] |= 0xc0; /* Allow more sessions */
536 }
537
538 /* Select track type (audio or data) */
539 if (track_mode == TRACK_MODE_DATA) {
540 buf[4] = 8; /* 2048 byte sector */
541 } else {
542 buf[4] = 0; /* 2352 byte sector */
543 }
544 buf[7] = buf[8] = 0;
545
546 /* Need to clear these fields for setting into DAO */
547 if (write_mode == DAO_MODE)
548 buf[5] = buf[15] = 0;
549
550 /* print out mode for detailed log */
551 if (debug && verbose) {
552 int i;
553
554 (void) printf("setting = [ ");
555 for (i = 0; i < 15; i++)
556 (void) printf("0x%x ", buf[i]);
557 (void) printf("]\n");
558 }
559
560 no_err = set_mode_page(dev->d_fd, buf);
561
562 if (no_err && reset_device) {
563 /* Turn the test write bit back on */
564 buf[2] |= 0x10;
565 no_err = set_mode_page(dev->d_fd, buf);
566 }
567
568 /*
569 * Since BUFE is the only optional flag we are
570 * setting we will try to turn it off if the command
571 * fails.
572 */
573 if (!no_err) {
574 /*
575 * Some old drives may not support HW
576 * buffer underrun protection, try again
577 * after turning it off.
578 */
579 if (debug)
580 (void) printf("Turning off BUFE\n");
581 buf[2] &= ~0x40;
582 no_err = set_mode_page(dev->d_fd, buf);
583 }
584 }
585
586 free(buf);
587 return (no_err);
588 }
589
590 /*
591 * Close session. This will write TOC.
592 */
593 int
finalize(cd_device * dev)594 finalize(cd_device *dev)
595 {
596 uchar_t *di;
597 int count, ret, err;
598 int immediate;
599 int finalize_max;
600
601 /*
602 * For ATAPI devices we will use the immediate mode and will
603 * poll the command for completion so that this command may
604 * not hog the channel. But for SCSI, we will use the treditional
605 * way of issuing the command with a large enough timeout. This
606 * is done because immediate mode was designed for ATAPI and some
607 * SCSI RW drives might not be even tested with it.
608 */
609 if ((dev->d_inq[2] & 7) != 0) {
610 /* SCSI device */
611 immediate = 0;
612 } else {
613 /* non-SCSI (e.g ATAPI) device */
614 immediate = 1;
615 }
616
617 /* We need to close track before close session */
618 if (device_type == DVD_PLUS) {
619 if (!close_track(dev->d_fd, 0, 0, immediate))
620 return (0);
621 }
622
623 if (!close_track(dev->d_fd, 0, 1, immediate)) {
624 /*
625 * For DAO mode which we use for DVD-RW, the latest MMC
626 * specification does not mention close_track. Some
627 * newer drives will return an ILLEGAL INSTRUCTION
628 * which we will ignore. We have also found a Panasonic
629 * drive which will return a MEDIA ERROR. It is safe
630 * to ignore both errors as this is not needed for
631 * these drives.
632 * This is kept for older drives which had needed
633 * us to issue close_track to flush the cache fully.
634 * once we are certain these drives have cleared the
635 * market, this can be removed.
636 */
637 if (device_type == DVD_MINUS) {
638 return (0);
639 }
640 } else {
641 if (!immediate)
642 return (1);
643 }
644 if (immediate) {
645 (void) sleep(10);
646
647 di = (uchar_t *)my_zalloc(DISC_INFO_BLOCK_SIZE);
648 err = 0;
649
650 if (device_type == CD_RW) {
651 /* Finalization should not take more than 6 minutes */
652 finalize_max = FINALIZE_TIMEOUT;
653 } else {
654 /* some DVD-RW drives take longer than 6 minutes */
655 finalize_max = FINALIZE_TIMEOUT*2;
656 }
657
658 for (count = 0; count < finalize_max; count++) {
659 ret = read_disc_info(dev->d_fd, di);
660 if (ret != 0)
661 break;
662 if (uscsi_status != 2)
663 err = 1;
664 if (SENSE_KEY(rqbuf) == 2) {
665 /* not ready but not becoming ready */
666 if (ASC(rqbuf) != 4)
667 err = 1;
668 } else if (SENSE_KEY(rqbuf) == 5) {
669 /* illegal mode for this track */
670 if (ASC(rqbuf) != 0x64)
671 err = 1;
672 } else {
673 err = 1;
674 }
675 if (err == 1) {
676 if (debug) {
677 (void) printf("Finalization failed\n");
678 (void) printf("%x %x %x %x\n",
679 uscsi_status, SENSE_KEY(rqbuf),
680 ASC(rqbuf), ASCQ(rqbuf));
681 }
682 free(di);
683 return (0);
684 }
685 if (uscsi_status == 2) {
686 int i;
687 /* illegal field in command packet */
688 if (ASC(rqbuf) == 0x24) {
689 /* print it out! */
690 (void) printf("\n");
691 for (i = 0; i < 18; i++)
692 (void) printf("%x ",
693 (unsigned)(rqbuf[i]));
694 (void) printf("\n");
695 }
696 }
697 (void) sleep(5);
698 }
699 free(di);
700 }
701 return (ret);
702 }
703
704 /*
705 * Find out media capacity.
706 */
707 uint32_t
get_last_possible_lba(cd_device * dev)708 get_last_possible_lba(cd_device *dev)
709 {
710 uchar_t *di;
711 uint32_t cap;
712
713 di = (uchar_t *)my_zalloc(DISC_INFO_BLOCK_SIZE);
714 if (!read_disc_info(dev->d_fd, di)) {
715 free(di);
716 return (0);
717 }
718
719 /*
720 * If we have a DVD+R this field is an LBA. If the media is
721 * a CD-R/W the field is MSF formatted. Otherwise this field
722 * is not valid and will be zero.
723 */
724 if (device_type == DVD_PLUS) {
725 if (read_scsi32(&di[20]) != 0xffffffff) {
726 cap = read_scsi32(&di[20]);
727 } else {
728 cap = 0;
729 }
730 } else {
731 if ((di[21] != 0) && (di[21] != 0xff)) {
732 cap = MSF2LBA(di[21], di[22], di[23]);
733 } else {
734 cap = 0;
735 }
736 }
737
738 free(di);
739 return (cap);
740 }
741
742 int
read_audio_through_read_cd(cd_device * dev,uint_t start_lba,uint_t nblks,uchar_t * buf)743 read_audio_through_read_cd(cd_device *dev, uint_t start_lba, uint_t nblks,
744 uchar_t *buf)
745 {
746 int retry;
747 int ret;
748
749 for (retry = 0; retry < 3; retry++) {
750 ret = read_cd(dev->d_fd, (uint32_t)start_lba, (uint16_t)nblks,
751 1, buf, (uint32_t)(nblks * 2352));
752 if (ret)
753 break;
754 }
755 return (ret);
756 }
757
758 int
eject_media(cd_device * dev)759 eject_media(cd_device *dev)
760 {
761 if (vol_running) {
762 /* If there is a media, try using DKIOCEJECT 1st */
763 if (check_device(dev, CHECK_NO_MEDIA) == 0) {
764 /*
765 * The check_device() call will issue
766 * a TEST UNIT READY (TUR) and retry many
767 * times when a DVD-R is present. The DKIOCEJECT
768 * ioctl will subsequently fail causing us to
769 * issue the LOAD/UNLOAD SCSI command to the device
770 * with out ejecting the media. Insted of letting
771 * this happen, issue a reset to the device before
772 * issuing the DKIOCEJCET ioctl.
773 */
774 if (device_type == DVD_MINUS)
775 reset_dev(dev->d_fd);
776
777 if (ioctl(dev->d_fd, DKIOCEJECT, 0) == 0) {
778 return (1);
779 }
780 }
781 }
782 if (load_unload(dev->d_fd, 0) == 0) {
783 /* if eject fails */
784 if ((uscsi_status == 2) && (ASC(rqbuf) == 0x53)) {
785 /*
786 * check that eject is not blocked on the device
787 */
788 if (!prevent_allow_mr(dev->d_fd, 1))
789 return (0);
790 return (load_unload(dev->d_fd, 0));
791 }
792 return (0);
793 }
794 return (1);
795 }
796
797 /*
798 * Get current Read or Write Speed from Mode Page 0x2a.
799 *
800 * Use the size of the Page to determine which Multimedia Command
801 * set (MMC) is present. Based on the MMC version, get the
802 * specified Read/Write Speed.
803 *
804 * Note that some MMC versions do not necessarily support a
805 * (current) Read or Write Speed. As a result, this function
806 * _can_ return a value of zero.
807 *
808 * The newer standards (reserve and) mark the field(s) as Obsolete,
809 * yet many vendors populate the Obsolete fields with valid values
810 * (assumedly for backward compatibility). This is important, as
811 * a command like GET PERFORMANCE cannot return _the_ speed; it can
812 * only return a Logical-Block-Address-dependent (LBA) speed. Such
813 * values can vary widely between the innermost and outermost Track.
814 * Mode Page 0x2a is the best solution identifying "the current
815 * (nominal) speed".
816 */
817 static uint16_t
cd_speed_get(cd_device * dev,int cmd)818 cd_speed_get(cd_device *dev, int cmd)
819 {
820 uchar_t *mp2a;
821 uint16_t rate = 0;
822 int offset;
823 uint_t buflen = 254;
824
825 /*
826 * Allocate a buffer acceptably larger than any nominal
827 * Page for Page Code 0x2A.
828 */
829 mp2a = (uchar_t *)my_zalloc(buflen);
830 if (get_mode_page(dev->d_fd, 0x2A, 0, buflen, mp2a) == 0)
831 goto end;
832
833 /* Determine MMC version based on 'Page Length' field */
834 switch (mp2a[1]) {
835 case 0x14: /* MMC-1 */
836 if (debug)
837 (void) printf("Mode Page 2A: MMC-1\n");
838
839 offset = (cmd == GET_READ_SPEED) ? 14 : 20;
840 rate = read_scsi16(&mp2a[offset]);
841 break;
842
843
844 case 0x18: /* MMC-2 */
845 if (debug)
846 (void) printf("Mode Page 2A: MMC-2;"
847 " Read and Write Speeds are "
848 "obsolete\n");
849
850 /* see if "Obsolete" values are valid: */
851 offset = (cmd == GET_READ_SPEED) ? 14 : 20;
852 rate = read_scsi16(&mp2a[offset]);
853 break;
854
855 default: /* MMC-3 or newer */
856 if (debug)
857 (void) printf("Mode Page 2A: MMC-3 or"
858 " newer; Read Speed is obsolete.\n");
859
860 if (cmd == GET_READ_SPEED) {
861 /* this is Obsolete, but try it */
862 offset = 14;
863 rate = read_scsi16(&mp2a[offset]);
864 } else {
865 /* Write Speed is not obsolete */
866 offset = 28;
867 rate = read_scsi16(&mp2a[offset]);
868
869 if (rate == 0) {
870 /*
871 * then try an Obsolete field
872 * (but this shouldn't happen!)
873 */
874 offset = 20;
875 rate = read_scsi16(&mp2a[offset]);
876 }
877 }
878 break;
879 }
880 end:
881 free(mp2a);
882
883 if (debug)
884 (void) printf("cd_speed_get: %s Speed is "
885 "%uX\n", (cmd == GET_READ_SPEED) ?
886 "Read" : "Write", cdrw_bandwidth_to_x(rate));
887 return (rate);
888 }
889
890 /*
891 * CD speed related functions (ioctl style) for drives which do not support
892 * real time streaming.
893 *
894 * For the SET operations, the SET CD SPEED command needs
895 * both the Read Speed and the Write Speed. Eg, if
896 * we're trying to set the Write Speed (SET_WRITE_SPEED),
897 * then we first need to obtain the current Read Speed.
898 * That speed is specified along with the chosen_speed (the
899 * Write Speed in this case) in the SET CD SPEED command.
900 */
901 int
cd_speed_ctrl(cd_device * dev,int cmd,int speed)902 cd_speed_ctrl(cd_device *dev, int cmd, int speed)
903 {
904 uint16_t rate;
905
906 switch (cmd) {
907 case GET_READ_SPEED:
908 rate = cd_speed_get(dev, GET_READ_SPEED);
909 return (cdrw_bandwidth_to_x(rate));
910
911 case GET_WRITE_SPEED:
912 rate = cd_speed_get(dev, GET_WRITE_SPEED);
913 return (cdrw_bandwidth_to_x(rate));
914
915 case SET_READ_SPEED:
916 rate = cd_speed_get(dev, GET_WRITE_SPEED);
917 return (set_cd_speed(dev->d_fd,
918 cdrw_x_to_bandwidth(speed), rate));
919
920 case SET_WRITE_SPEED:
921 rate = cd_speed_get(dev, GET_READ_SPEED);
922 return (set_cd_speed(dev->d_fd, rate,
923 cdrw_x_to_bandwidth(speed)));
924
925 default:
926 return (0);
927 }
928 }
929
930 /*
931 * Manage sending of SET STREAMING command using the specified
932 * read_speed and write_speed.
933 *
934 * This function allocates and initializes a Performance
935 * Descriptor, which is sent as part of the SET STREAMING
936 * command. The descriptor is deallocated before function
937 * exit.
938 */
939 static int
do_set_streaming(cd_device * dev,uint_t read_speed,uint_t write_speed)940 do_set_streaming(cd_device *dev, uint_t read_speed,
941 uint_t write_speed)
942 {
943 int ret;
944 uchar_t *str;
945
946 /* Allocate and initialize the Performance Descriptor */
947 str = (uchar_t *)my_zalloc(SET_STREAM_DATA_LEN);
948
949 /* Read Time (in milliseconds) */
950 load_scsi32(&str[16], 1000);
951 /* Write Time (in milliseconds) */
952 load_scsi32(&str[24], 1000);
953
954 /* Read Speed */
955 load_scsi32(&str[12], (uint32_t)read_speed);
956 /* Write Speed */
957 load_scsi32(&str[20], (uint32_t)write_speed);
958
959 /* issue SET STREAMING command */
960 ret = set_streaming(dev->d_fd, str);
961 free(str);
962
963 return (ret);
964 }
965
966 /*
967 * cd speed related functions for drives which support
968 * Real-Time Streaming Feature.
969 *
970 * For the SET operations, the SET STREAMING command needs
971 * both the Read Speed and the Write Speed. Eg, if
972 * we're trying to set the Write Speed (SET_WRITE_SPEED),
973 * then we first need to obtain the current Read Speed.
974 * That speed is specified along with the chosen_speed (the
975 * Write Speed in this case) in the SET STREAMING command.
976 */
977 int
rt_streaming_ctrl(cd_device * dev,int cmd,int speed)978 rt_streaming_ctrl(cd_device *dev, int cmd, int speed)
979 {
980 int ret = 0;
981 uint_t rate;
982
983 switch (cmd) {
984 case GET_WRITE_SPEED:
985 rate = cd_speed_get(dev, GET_WRITE_SPEED);
986 ret = (int)cdrw_bandwidth_to_x(rate);
987 break;
988
989 case GET_READ_SPEED:
990 rate = cd_speed_get(dev, GET_READ_SPEED);
991 ret = (int)cdrw_bandwidth_to_x(rate);
992 break;
993
994 case SET_READ_SPEED: {
995 uint_t write_speed = cd_speed_get(dev, GET_WRITE_SPEED);
996
997 /* set Read Speed using SET STREAMING */
998 ret = do_set_streaming(dev,
999 cdrw_x_to_bandwidth(speed), write_speed);
1000
1001 /* If rt_speed_ctrl fails for any reason use cd_speed_ctrl */
1002 if (ret == 0) {
1003 if (debug)
1004 (void) printf(" real time speed control"
1005 " failed, using CD speed control\n");
1006
1007 dev->d_speed_ctrl = cd_speed_ctrl;
1008 ret = dev->d_speed_ctrl(dev, cmd, speed);
1009 }
1010 break;
1011 }
1012
1013 case SET_WRITE_SPEED: {
1014 uint_t read_speed = cd_speed_get(dev, GET_READ_SPEED);
1015
1016 /* set Write Speed using SET STREAMING */
1017 ret = do_set_streaming(dev, read_speed,
1018 cdrw_x_to_bandwidth(speed));
1019
1020 /* If rt_speed_ctrl fails for any reason use cd_speed_ctrl */
1021 if (ret == 0) {
1022 if (debug)
1023 (void) printf(" real time speed control"
1024 " failed, using CD speed control\n");
1025
1026 dev->d_speed_ctrl = cd_speed_ctrl;
1027 ret = dev->d_speed_ctrl(dev, cmd, speed);
1028 }
1029 break;
1030 }
1031
1032 default:
1033 break;
1034 }
1035
1036 return (ret);
1037 }
1038
1039 /*
1040 * Initialize device for track-at-once mode of writing. All of the data will
1041 * need to be written to the track without interruption.
1042 * This initialized TAO by setting page code 5 and speed.
1043 */
1044 void
write_init(int mode)1045 write_init(int mode)
1046 {
1047 (void) printf(gettext("Initializing device"));
1048 if (simulation)
1049 (void) printf(gettext("(Simulation mode)"));
1050 print_n_flush("...");
1051
1052 get_media_type(target->d_fd);
1053
1054 /* DVD- requires DAO mode */
1055 if (device_type == DVD_MINUS) {
1056 write_mode = DAO_MODE;
1057 }
1058
1059 /* DVD+ and DVD- have no support for AUDIO, bail out */
1060 if ((mode == TRACK_MODE_AUDIO) && (device_type != CD_RW)) {
1061 err_msg(gettext("Audio mode is only supported for CD media\n"));
1062 exit(1);
1063 }
1064 if (simulation &&
1065 check_device(target, CHECK_MEDIA_IS_NOT_BLANK) &&
1066 !check_device(target, CHECK_MEDIA_IS_NOT_ERASABLE) &&
1067 device_type != DVD_PLUS_W) {
1068 /*
1069 * If we were in simulation mode, and media wasn't blank,
1070 * but medium was erasable, then cdrw goes to erase the
1071 * contents of the media after the simulation writing in order
1072 * to cleanup the ghost TOC (see write_fini() calls blank()).
1073 * This is bad because it removes existing data if media was
1074 * multi-session. Therefore, we no longer allow simulation
1075 * writing if such condition is met. we don't blank the DVD+RW
1076 * media, so DVD+RWs are fine.
1077 */
1078 err_msg(gettext(
1079 "Cannot perform simulation for non-blank media\n"));
1080 exit(1);
1081 }
1082
1083 if (!prepare_for_write(target, mode, simulation, keep_disc_open)) {
1084 /* l10n_NOTE : 'failed' as in Initializing device...failed */
1085 (void) printf(gettext("failed.\n"));
1086 err_msg(gettext("Cannot initialize device for write\n"));
1087 exit(1);
1088 }
1089 /* l10n_NOTE : 'done' as in "Initializing device...done" */
1090 (void) printf(gettext("done.\n"));
1091
1092 /* if speed change option was used (-p) then try to set the speed */
1093 if (requested_speed != 0) {
1094 if (verbose)
1095 (void) printf(gettext("Trying to set speed to %dX.\n"),
1096 requested_speed);
1097 if (target->d_speed_ctrl(target, SET_WRITE_SPEED,
1098 requested_speed) == 0) {
1099 err_msg(gettext("Unable to set speed.\n"));
1100 exit(1);
1101 }
1102 if (verbose) {
1103 int speed;
1104 speed = target->d_speed_ctrl(target,
1105 GET_WRITE_SPEED, 0);
1106 if (speed == requested_speed) {
1107 (void) printf(gettext("Speed set to %dX.\n"),
1108 speed);
1109 } else if (speed == 0) {
1110 (void) printf(gettext("Could not obtain "
1111 "current Write Speed.\n"));
1112 } else {
1113 (void) printf(
1114 gettext("Speed set to closest approximation "
1115 "of %dX allowed by device (%dX).\n"),
1116 requested_speed, speed);
1117 }
1118 }
1119 }
1120 }
1121
1122 void
write_fini(void)1123 write_fini(void)
1124 {
1125 print_n_flush(gettext("Finalizing (Can take several minutes)..."));
1126 /* Some drives don't like this while in test write mode */
1127 if (!simulation) {
1128 if (!finalize(target)) {
1129 /*
1130 * It is possible that the drive is busy writing the
1131 * buffered portion. So do not get upset yet.
1132 */
1133 (void) sleep(10);
1134 if (!finalize(target)) {
1135 if (debug) {
1136 (void) printf("status %x, %x/%x/%x\n",
1137 uscsi_status, SENSE_KEY(rqbuf),
1138 ASC(rqbuf), ASCQ(rqbuf));
1139 }
1140
1141 /*
1142 * Different vendor drives return different
1143 * sense error info for CLOSE SESSION command.
1144 * The Panasonic drive that we are using is
1145 * one such drive.
1146 */
1147 if (device_type == DVD_MINUS) {
1148 if (verbose) {
1149 (void) printf(
1150 "skipping finalizing\n");
1151 }
1152 } else {
1153
1154 /* l10n_NOTE : 'failed' as in finishing up...failed */
1155 (void) printf(gettext("failed.\n"));
1156
1157 err_msg(gettext(
1158 "Could not finalize the disc.\n"));
1159 exit(1);
1160 }
1161
1162
1163 }
1164 }
1165 if (vol_running) {
1166 (void) eject_media(target);
1167 }
1168 } else if (check_device(target, CHECK_MEDIA_IS_NOT_BLANK)) {
1169 /*
1170 * Some drives such as the pioneer A04 will retain a
1171 * ghost TOC after a simulation write is done. The
1172 * media will actually be blank, but the drive will
1173 * report a TOC. There is currently no other way to
1174 * re-initialize the media other than ejecting or
1175 * to ask the drive to clear the leadout. The laser
1176 * is currently off so nothing is written to the
1177 * media (on a good behaving drive).
1178 * NOTE that a device reset does not work to make
1179 * the drive re-initialize the media.
1180 */
1181
1182 blanking_type = "clear_ghost";
1183 blank();
1184
1185 }
1186 /* l10n_NOTE : 'done' as in "Finishing up...done" */
1187 (void) printf(gettext("done.\n"));
1188 }
1189