开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
drv_mmc.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：32k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

drv_mmc.c：源码内容
  1. /* @(#)drv_mmc.c 1.47 00/01/28 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char sccsid[] =
  4. "@(#)drv_mmc.c 1.47 00/01/28 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * CDR device implementation for
  8.  * SCSI-3/mmc conforming drives
  9.  * e.g. Yamaha CDR-400, Ricoh MP6200
  10.  *
  11.  * Copyright (c) 1997 J. Schilling
  12.  */
  13. /*
  14.  * This program is free software; you can redistribute it and/or modify
  15.  * it under the terms of the GNU General Public License as published by
  16.  * the Free Software Foundation; either version 2, or (at your option)
  17.  * any later version.
  18.  *
  19.  * This program is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  * GNU General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; see the file COPYING.  If not, write to
  26.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  */
  29. /*#define DEBUG*/
  30. #define PRINT_ATIP
  31. #include <mconfig.h>
  33. #include <stdio.h>
  34. #include <standard.h>
  35. #include <fctldefs.h>
  36. #include <errno.h>
  37. #include <strdefs.h>
  38. #include <unixstd.h>
  39. #include <timedefs.h>
  41. #include <utypes.h>
  42. #include <btorder.h>
  43. #include <intcvt.h>
  44. #include <scg/scgcmd.h>
  45. #include <scg/scsidefs.h>
  46. #include <scg/scsireg.h>
  47. #include <scg/scsitransp.h>
  49. #include <scsimmc.h>
  50. #include "cdrecord.h"
  52. extern BOOL isgui;
  54. extern int debug;
  55. extern int lverbose;
  57. LOCAL int curspeed = 1;
  59. LOCAL int mmc_load __PR((SCSI *scgp));
  60. LOCAL int mmc_unload __PR((SCSI *scgp));
  61. LOCAL cdr_t *identify_mmc __PR((SCSI *scgp, cdr_t *, struct scsi_inquiry *));
  62. LOCAL int attach_mmc __PR((SCSI *scgp, cdr_t *));
  63. LOCAL int get_diskinfo __PR((SCSI *scgp, struct disk_info *dip));
  64. LOCAL void di_to_dstat __PR((struct disk_info *dip, dstat_t *dsp));
  65. #ifdef PRINT_ATIP
  66. LOCAL int get_pma __PR((SCSI *scgp));
  67. #endif
  68. LOCAL int getdisktype_mmc __PR((SCSI *scgp, cdr_t *dp, dstat_t *dsp));
  69. LOCAL int speed_select_mmc __PR((SCSI *scgp, int *speedp, int dummy));
  70. LOCAL int next_wr_addr_mmc __PR((SCSI *scgp, int track, track_t *trackp, long *ap));
  71. LOCAL int open_track_mmc __PR((SCSI *scgp, cdr_t *dp, int track, track_t *trackp));
  72. LOCAL int close_track_mmc __PR((SCSI *scgp, int track, track_t *trackp));
  73. LOCAL int open_session_mmc __PR((SCSI *scgp, int tracks, track_t *trackp, int toctype, int multi));
  74. LOCAL int waitfix_mmc __PR((SCSI *scgp, int secs));
  75. LOCAL int fixate_mmc __PR((SCSI *scgp, int onp, int dummy, int toctype, int tracks, track_t *trackp));
  76. LOCAL int blank_mmc __PR((SCSI *scgp, long addr, int blanktype));
  77. LOCAL int scsi_sony_write __PR((SCSI *scgp, caddr_t bp, long sectaddr, long size, int blocks, BOOL islast));
  79. LOCAL int
  80. mmc_load(scgp)
  81. SCSI *scgp;
  82. {
  83. return (scsi_load_unload(scgp, 1));
  84. }
  86. LOCAL int
  87. mmc_unload(scgp)
  88. SCSI *scgp;
  89. {
  90. return (scsi_load_unload(scgp, 0));
  91. }
  93. cdr_t cdr_mmc = {
  94. 0,
  95. CDR_TAO|CDR_DAO|CDR_PACKET|CDR_SWABAUDIO,
  96. "mmc_cdr",
  97. "generic SCSI-3/mmc CD-R driver",
  98. 0,
  99. identify_mmc,
  100. attach_mmc,
  101. getdisktype_mmc,
  102. scsi_load,
  103. /* mmc_load,*/
  104. scsi_unload,
  105. read_buff_cap,
  106. (int(*)__PR((SCSI *)))cmd_dummy, /* recovery_needed */
  107. (int(*)__PR((SCSI *, int)))cmd_dummy, /* recover */
  108. speed_select_mmc,
  109. select_secsize,
  110. next_wr_addr_mmc,
  111. (int(*)__PR((SCSI *, Ulong)))cmd_ill, /* reserve_track */
  112. scsi_cdr_write,
  113. send_cue,
  114. open_track_mmc,
  115. close_track_mmc,
  116. open_session_mmc,
  117. cmd_dummy,
  118. read_session_offset,
  119. fixate_mmc,
  120. blank_mmc,
  121. };
  123. cdr_t cdr_mmc_sony = {
  124. 0,
  125. CDR_TAO|CDR_DAO|CDR_PACKET|CDR_SWABAUDIO,
  126. "mmc_cdr_sony",
  127. "generic SCSI-3/mmc CD-R driver (Sony 928 variant)",
  128. 0,
  129. identify_mmc,
  130. attach_mmc,
  131. getdisktype_mmc,
  132. scsi_load,
  133. /* mmc_load,*/
  134. scsi_unload,
  135. read_buff_cap,
  136. (int(*)__PR((SCSI *)))cmd_dummy, /* recovery_needed */
  137. (int(*)__PR((SCSI *, int)))cmd_dummy, /* recover */
  138. speed_select_mmc,
  139. select_secsize,
  140. next_wr_addr_mmc,
  141. (int(*)__PR((SCSI *, Ulong)))cmd_ill, /* reserve_track */
  142. scsi_sony_write,
  143. send_cue,
  144. open_track_mmc,
  145. close_track_mmc,
  146. open_session_mmc,
  147. cmd_dummy,
  148. read_session_offset,
  149. fixate_mmc,
  150. blank_mmc,
  151. };
  153. /*
  154.  * SCSI-3/mmc conformant CD drive
  155.  */
  156. cdr_t cdr_cd = {
  157. 0,
  158. CDR_ISREADER|CDR_SWABAUDIO,
  159. "mmc_cd",
  160. "generic SCSI-3/mmc CD driver",
  161. 0,
  162. identify_mmc,
  163. attach_mmc,
  164. drive_getdisktype,
  165. scsi_load,
  166. scsi_unload,
  167. read_buff_cap,
  168. (int(*)__PR((SCSI *)))cmd_dummy, /* recovery_needed */
  169. (int(*)__PR((SCSI *, int)))cmd_dummy, /* recover */
  170. speed_select_mmc,
  171. select_secsize,
  172. (int(*)__PR((SCSI *scgp, int, track_t *, long *)))cmd_ill, /* next_wr_addr */
  173. (int(*)__PR((SCSI *, Ulong)))cmd_ill, /* reserve_track */
  174. scsi_cdr_write,
  175. no_sendcue,
  176. open_track_mmc,
  177. close_track_mmc,
  178. (int(*)__PR((SCSI *scgp, int, track_t *, int, int)))cmd_dummy,
  179. cmd_dummy,
  180. read_session_offset,
  181. (int(*)__PR((SCSI *scgp, int, int, int, int, track_t *)))cmd_dummy, /* fixation */
  182. blank_dummy,
  183. };
  185. /*
  186.  * Old pre SCSI-3/mmc CD drive
  187.  */
  188. cdr_t cdr_oldcd = {
  189. 0,
  190. CDR_ISREADER,
  191. "scsi2_cd",
  192. "generic SCSI-2 CD driver",
  193. 0,
  194. identify_mmc,
  195. drive_attach,
  196. drive_getdisktype,
  197. scsi_load,
  198. scsi_unload,
  199. buf_dummy,
  200. (int(*)__PR((SCSI *)))cmd_dummy, /* recovery_needed */
  201. (int(*)__PR((SCSI *, int)))cmd_dummy, /* recover */
  202. speed_select_mmc,
  203. select_secsize,
  204. (int(*)__PR((SCSI *scg, int, track_t *, long *)))cmd_ill, /* next_wr_addr */
  205. (int(*)__PR((SCSI *, Ulong)))cmd_ill, /* reserve_track */
  206. scsi_cdr_write,
  207. no_sendcue,
  208. open_track_mmc,
  209. close_track_mmc,
  210. (int(*)__PR((SCSI *scgp, int, track_t *, int, int)))cmd_dummy,
  211. cmd_dummy,
  212. read_session_offset_philips,
  213. (int(*)__PR((SCSI *scgp, int, int, int, int, track_t *)))cmd_dummy, /* fixation */
  214. blank_dummy,
  215. };
  217. LOCAL cdr_t *
  218. identify_mmc(scgp, dp, ip)
  219. SCSI *scgp;
  220. cdr_t *dp;
  221. struct scsi_inquiry *ip;
  222. {
  223. BOOL cdrr  = FALSE; /* Read CD-R */
  224. BOOL cdwr  = FALSE; /* Write CD-R */
  225. BOOL cdrrw  = FALSE; /* Read CD-RW */
  226. BOOL cdwrw  = FALSE; /* Write CD-RW */
  227. Uchar mode[0x100];
  228. struct cd_mode_page_2A *mp;
  230. if (ip->type != INQ_WORM && ip->type != INQ_ROMD)
  231. return ((cdr_t *)0);
  233. allow_atapi(scgp, TRUE);/* Try to switch to 10 byte mode cmds */
  235. scgp->silent++;
  236. mp = mmc_cap(scgp, mode); /* Get MMC capabilities */
  237. scgp->silent--;
  238. if (mp == NULL)
  239. return (&cdr_oldcd); /* Pre SCSI-3/mmc drive   */
  241. mmc_getval(mp, &cdrr, &cdwr, &cdrrw, &cdwrw, NULL);
  243. /*
  244.  * At this point we know that we have a SCSI-3/mmc compliant drive.
  245.  * Unfortunately ATAPI drives violate the SCSI spec in returning
  246.  * a response data format of '1' which from the SCSI spec would
  247.  * tell us not to use the "PF" bit in mode select. As ATAPI drives
  248.  * require the "PF" bit to be set, we 'correct' the inquiry data.
  249.  *
  250.  * XXX xxx_identify() should not have any side_effects ??
  251.  */
  252. if (ip->data_format < 2)
  253. ip->data_format = 2;
  255. if (strncmp(ip->vendor_info, "SONY", 4) == 0 &&
  256.     strncmp(ip->prod_ident, "CD-R   CDU928E", 14) == 0) {
  257. dp = &cdr_mmc_sony;
  258. }
  259. if (!cdwr) /* SCSI-3/mmc CD drive */
  260. dp = &cdr_cd;
  262. return (dp);
  263. }
  265. LOCAL int
  266. attach_mmc(scgp, dp)
  267. SCSI *scgp;
  268. cdr_t *dp;
  269. {
  270. struct cd_mode_page_2A *mp;
  273. allow_atapi(scgp, TRUE);/* Try to switch to 10 byte mode cmds */
  275. scgp->silent++;
  276. mp = mmc_cap(scgp, NULL);/* Get MMC capabilities in allocated mp */
  277. scgp->silent--;
  278. if (mp == NULL)
  279. return (-1); /* Pre SCSI-3/mmc drive   */
  281. dp->cdr_cdcap = mp; /* Store MMC cap pointer */
  283. if (mp->loading_type == LT_TRAY)
  284. dp->cdr_flags |= CDR_TRAYLOAD;
  285. else if (mp->loading_type == LT_CADDY)
  286. dp->cdr_flags |= CDR_CADDYLOAD;
  288. return (0);
  289. }
  291. #ifdef PRINT_ATIP
  292. LOCAL int get_atip __PR((SCSI *scgp, struct atipinfo *atp));
  293. void print_di __PR((struct disk_info *dip));
  294. void print_atip __PR((SCSI *scgp, struct atipinfo *atp));
  295. #endif /* PRINT_ATIP */
  297. LOCAL int
  298. get_diskinfo(scgp, dip)
  299. SCSI *scgp;
  300. struct disk_info *dip;
  301. {
  302. int len;
  303. int ret;
  305. fillbytes((caddr_t)dip, sizeof(*dip), '');
  307. if (read_disk_info(scgp, (caddr_t)dip, 2) < 0)
  308. return (-1);
  309. len = a_to_u_2_byte(dip->data_len);
  310. len += 2;
  311. ret = read_disk_info(scgp, (caddr_t)dip, len);
  313. #ifdef DEBUG
  314. scsiprbytes("Disk info:", (u_char *)dip,
  315. len-scsigetresid(scgp));
  316. #endif
  317. return (ret);
  318. }
  320. LOCAL void
  321. di_to_dstat(dip, dsp)
  322. struct disk_info *dip;
  323. dstat_t *dsp;
  324. {
  325. dsp->ds_diskid = a_to_u_4_byte(dip->disk_id);
  326. if (dip->did_v)
  327. dsp->ds_flags |= DSF_DID_V;
  328. dsp->ds_diskstat = dip->disk_status;
  329. dsp->ds_sessstat = dip->sess_status;
  331. dsp->ds_maxblocks = msf_to_lba(dip->last_lead_out[1],
  332. dip->last_lead_out[2],
  333. dip->last_lead_out[3]);
  334. /*
  335.  * Check for 0xFF:0xFF/0xFF which is an indicator for a complete disk
  336.  */
  337. if (dsp->ds_maxblocks == 716730)
  338. dsp->ds_maxblocks = -1L;
  340. if (dsp->ds_first_leadin == 0) {
  341. dsp->ds_first_leadin = msf_to_lba(dip->last_lead_in[1],
  342. dip->last_lead_in[2],
  343. dip->last_lead_in[3]);
  344. if (dsp->ds_first_leadin > 0)
  345. dsp->ds_first_leadin = 0;
  346. }
  348. if (dsp->ds_last_leadout == 0 && dsp->ds_maxblocks >= 0)
  349. dsp->ds_last_leadout = dsp->ds_maxblocks;
  350. }
  352. #ifdef PRINT_ATIP
  354. LOCAL int
  355. get_atip(scgp, atp)
  356. SCSI *scgp;
  357. struct atipinfo *atp;
  358. {
  359. int len;
  360. int ret;
  362. fillbytes((caddr_t)atp, sizeof(*atp), '');
  364. if (read_toc(scgp, (caddr_t)atp, 0, 2, 0, FMT_ATIP) < 0)
  365. return (-1);
  366. len = a_to_u_2_byte(atp->hd.len);
  367. len += 2;
  368. ret = read_toc(scgp, (caddr_t)atp, 0, len, 0, FMT_ATIP);
  370. #ifdef DEBUG
  371. scsiprbytes("ATIP info:", (u_char *)atp,
  372. len-scsigetresid(scgp));
  373. #endif
  374. /*
  375.  * Yamaha sometimes returns zeroed ATIP info for disks without ATIP
  376.  */
  377. if (atp->desc.lead_in[1] == 0 &&
  378. atp->desc.lead_in[2] == 0 &&
  379. atp->desc.lead_in[3] == 0 &&
  380. atp->desc.lead_out[1] == 0 &&
  381. atp->desc.lead_out[2] == 0 &&
  382. atp->desc.lead_out[3] == 0)
  383. return (-1);
  385. if (atp->desc.lead_in[1] >= 0x90 && debug) {
  386. /*
  387.  * Only makes sense with buggy Ricoh firmware.
  388.  */
  389. errmsgno(EX_BAD, "Converting ATIP from BCDn");
  390. atp->desc.lead_in[1] = from_bcd(atp->desc.lead_in[1]);
  391. atp->desc.lead_in[2] = from_bcd(atp->desc.lead_in[2]);
  392. atp->desc.lead_in[3] = from_bcd(atp->desc.lead_in[3]);
  394. atp->desc.lead_out[1] = from_bcd(atp->desc.lead_out[1]);
  395. atp->desc.lead_out[2] = from_bcd(atp->desc.lead_out[2]);
  396. atp->desc.lead_out[3] = from_bcd(atp->desc.lead_out[3]);
  397. }
  399. return (ret);
  400. }
  402. LOCAL int
  403. /*get_pma(atp)*/
  404. get_pma(scgp)
  405. SCSI *scgp;
  406. /* struct atipinfo *atp;*/
  407. {
  408. int len;
  409. int ret;
  410. char atp[1024];
  412. fillbytes((caddr_t)atp, sizeof(*atp), '');
  414. /* if (read_toc(scgp, (caddr_t)atp, 0, 2, 1, FMT_PMA) < 0)*/
  415. if (read_toc(scgp, (caddr_t)atp, 0, 2, 0, FMT_PMA) < 0)
  416. return (-1);
  417. /* len = a_to_u_2_byte(atp->hd.len);*/
  418. len = a_to_u_2_byte(atp);
  419. len += 2;
  420. /* ret = read_toc(scgp, (caddr_t)atp, 0, len, 1, FMT_PMA);*/
  421. ret = read_toc(scgp, (caddr_t)atp, 0, len, 0, FMT_PMA);
  423. #ifdef DEBUG
  424. scsiprbytes("PMA:", (u_char *)atp,
  425. len-scsigetresid(scgp));
  426. #endif
  427. ret = read_toc(scgp, (caddr_t)atp, 0, len, 1, FMT_PMA);
  429. #ifdef DEBUG
  430. scsiprbytes("PMA:", (u_char *)atp,
  431. len-scsigetresid(scgp));
  432. #endif
  433. return (ret);
  434. }
  436. #endif /* PRINT_ATIP */
  438. LOCAL int
  439. getdisktype_mmc(scgp, dp, dsp)
  440. SCSI *scgp;
  441. cdr_t *dp;
  442. dstat_t *dsp;
  443. {
  444. extern char *buf;
  445. struct disk_info *dip;
  446. u_char mode[0x100];
  447. char ans[2];
  448. msf_t msf;
  449. BOOL did_atip = FALSE;
  450. BOOL did_dummy = FALSE;
  452. msf.msf_min = msf.msf_sec = msf.msf_frame = 0;
  453. #ifdef PRINT_ATIP
  454. /*
  455.  * It seems that there are drives that do not support to
  456.  * read ATIP (e.g. HP 7100)
  457.  * Also if a NON CD-R media is inserted, this will never work.
  458.  * For this reason, make a failure non-fatal.
  459.  */
  460. scgp->silent++;
  461. if (get_atip(scgp, (struct atipinfo *)mode) >= 0) {
  462. msf.msf_min = mode[8];
  463. msf.msf_sec = mode[9];
  464. msf.msf_frame = mode[10];
  465. did_atip = TRUE;
  466. if (lverbose) {
  467. print_atip(scgp, (struct atipinfo *)mode);
  468. pr_manufacturer(&msf,
  469. ((struct atipinfo *)mode)->desc.erasable,
  470. ((struct atipinfo *)mode)->desc.uru);
  471. }
  472. }
  473. scgp->silent--;
  474. #endif
  475. again:
  476. dip = (struct disk_info *)buf;
  477. if (get_diskinfo(scgp, dip) < 0)
  478. return (-1);
  480. /*
  481.  * Check for non writable disk first.
  482.  */
  483. if (dip->disk_status == DS_COMPLETE && dsp->ds_cdrflags & RF_WRITE) {
  484. if (!did_dummy) {
  485. int xspeed = 0xFFFF;
  487. /*
  488.  * Try to clear the dummy bit to reset the virtual
  489.  * drive status. Not all drives support it even though
  490.  * it is mentioned in the MMC standard.
  491.  */
  492. if (lverbose)
  493. printf("Trying to clear drive status.n");
  494. speed_select_mmc(scgp, &xspeed, FALSE);
  495. did_dummy = TRUE;
  496. goto again;
  497. }
  498. errmsgno(EX_BAD, "Drive needs to reload the media to return to proper status.n");
  499. unload_media(scgp, dp, F_EJECT);
  501. if ((dp->cdr_flags & CDR_TRAYLOAD) != 0) {
  502. scgp->silent++;
  503. load_media(scgp, dp, FALSE);
  504. scgp->silent--;
  505. }
  506. scgp->silent++;
  507. if (((dp->cdr_flags & CDR_TRAYLOAD) == 0) ||
  508. !wait_unit_ready(scgp, 5)) {
  509. scgp->silent--;
  511. printf("Re-load disk and hit <CR>");
  512. if (isgui)
  513. printf("n");
  514. flush();
  515. getline(ans, 1);
  516. } else {
  517. scgp->silent--;
  518. }
  519. load_media(scgp, dp, TRUE);
  520. }
  521. if (get_diskinfo(scgp, dip) < 0)
  522. return (-1);
  523. di_to_dstat(dip, dsp);
  524. if (!did_atip && dsp->ds_first_leadin < 0)
  525. lba_to_msf(dsp->ds_first_leadin, &msf);
  527. if (lverbose && !did_atip) {
  528. print_min_atip(dsp->ds_first_leadin, dsp->ds_last_leadout);
  529. if (dsp->ds_first_leadin < 0)
  530.                 pr_manufacturer(&msf,
  531. dip->erasable,
  532. dip->uru);
  533. }
  534. dsp->ds_maxrblocks = disk_rcap(&msf, dsp->ds_maxblocks,
  535. dip->erasable,
  536. dip->uru);
  539. #ifdef PRINT_ATIP
  540. #ifdef DEBUG
  541. if (get_atip(scgp, (struct atipinfo *)mode) < 0)
  542. return (-1);
  543. /*
  544.  * Get pma gibt 膔ger mit CW-7502
  545.  * Wenn Die Disk leer ist, dann stuerzt alles ab.
  546.  * Firmware 4.02 kann nicht get_pma
  547.  */
  548. if (dip->disk_status != DS_EMPTY) {
  549. /* get_pma();*/
  550. }
  551. printf("ATIP lead in:  %ld (%02d:%02d/%02d)n",
  552. msf_to_lba(mode[8], mode[9], mode[10]),
  553. mode[8], mode[9], mode[10]);
  554. printf("ATIP lead out: %ld (%02d:%02d/%02d)n",
  555. msf_to_lba(mode[12], mode[13], mode[14]),
  556. mode[12], mode[13], mode[14]);
  557. print_di(dip);
  558. print_atip(scgp, (struct atipinfo *)mode);
  559. #endif
  560. #endif /* PRINT_ATIP */
  561. return (drive_getdisktype(scgp, dp, dsp));
  562. }
  564. #ifdef PRINT_ATIP
  566. #define DOES(what,flag) printf("  Does %s%sn", flag?"":"not ",what);
  567. #define IS(what,flag) printf("  Is %s%sn", flag?"":"not ",what);
  568. #define VAL(what,val) printf("  %s: %dn", what, val[0]*256 + val[1]);
  569. #define SVAL(what,val) printf("  %s: %sn", what, val);
  571. void
  572. print_di(dip)
  573. struct disk_info *dip;
  574. {
  575. static char *ds_name[] = { "empty", "incomplete/appendable", "complete", "illegal" };
  576. static char *ss_name[] = { "empty", "incomplete/appendable", "illegal", "complete", };
  578. IS("erasable", dip->erasable);
  579. printf("disk status: %sn", ds_name[dip->disk_status]);
  580. printf("session status: %sn", ss_name[dip->sess_status]);
  581. printf("first track: %d number of sessions: %d first track in last sess: %d last track in last sess: %dn",
  582. dip->first_track,
  583. dip->numsess,
  584. dip->first_track_ls,
  585. dip->last_track_ls);
  586. IS("unrestricted", dip->uru);
  587. printf("Disk type: ");
  588. switch (dip->disk_type) {
  590. case SES_DA_ROM: printf("CD-DA or CD-ROM"); break;
  591. case SES_CDI: printf("CDI"); break;
  592. case SES_XA: printf("CD-ROM XA"); break;
  593. case SES_UNDEF: printf("undefined"); break;
  594. default: printf("reserved"); break;
  595. }
  596. printf("n");
  597. if (dip->did_v)
  598. printf("Disk id: 0x%lXn", a_to_u_4_byte(dip->disk_id));
  600. printf("last start of lead in: %ldn",
  601. msf_to_lba(dip->last_lead_in[1],
  602. dip->last_lead_in[2],
  603. dip->last_lead_in[3]));
  604. printf("last start of lead out: %ldn",
  605. msf_to_lba(dip->last_lead_out[1],
  606. dip->last_lead_out[2],
  607. dip->last_lead_out[3]));
  609. if (dip->dbc_v)
  610. printf("Disk bar code: 0x%lX%lXn",
  611. a_to_u_4_byte(dip->disk_barcode),
  612. a_to_u_4_byte(&dip->disk_barcode[4]));
  614. if (dip->num_opc_entries > 0) {
  615. printf("OPC table:n");
  616. }
  617. }
  619. LOCAL char clv_to_speed[8] = {
  620. 0, 2, 4, 6, 8, 0, 0, 0
  621. };
  623. void
  624. print_atip(scgp, atp)
  625. SCSI *scgp;
  626. struct atipinfo *atp;
  627. {
  628. if (scgp->verbose)
  629. scsiprbytes("ATIP info: ", (Uchar *)atp, sizeof (*atp));
  631. printf("ATIP info from disk:n");
  632. printf("  Indicated writing power: %dn", atp->desc.ind_wr_power);
  633. if (atp->desc.erasable || atp->desc.ref_speed)
  634. printf("  Reference speed: %dn", clv_to_speed[atp->desc.ref_speed]);
  635. IS("unrestricted", atp->desc.uru);
  636. /* printf("  Disk application code: %dn", atp->desc.res5_05);*/
  637. IS("erasable", atp->desc.erasable);
  638. if (atp->desc.sub_type)
  639. printf("  Disk sub type: %dn", atp->desc.sub_type);
  640. printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)n",
  641. msf_to_lba(atp->desc.lead_in[1],
  642. atp->desc.lead_in[2],
  643. atp->desc.lead_in[3]),
  644. atp->desc.lead_in[1],
  645. atp->desc.lead_in[2],
  646. atp->desc.lead_in[3]);
  647. printf("  ATIP start of lead out: %ld (%02d:%02d/%02d)n",
  648. msf_to_lba(atp->desc.lead_out[1],
  649. atp->desc.lead_out[2],
  650. atp->desc.lead_out[3]),
  651. atp->desc.lead_out[1],
  652. atp->desc.lead_out[2],
  653. atp->desc.lead_out[3]);
  654. if (atp->desc.a1_v) {
  655. if (atp->desc.clv_low != 0 || atp->desc.clv_high != 0)
  656. printf("  speed low: %d speed high: %dn",
  657. clv_to_speed[atp->desc.clv_low],
  658. clv_to_speed[atp->desc.clv_high]);
  659. printf("  power mult factor: %d %dn", atp->desc.power_mult, atp->desc.tgt_y_pow);
  660. if (atp->desc.erasable)
  661. printf("  recommended erase/write power: %dn", atp->desc.rerase_pwr_ratio);
  662. }
  663. if (atp->desc.a2_v) {
  664. printf("  A2 values: %02X %02X %02Xn",
  665. atp->desc.a2[0],
  666. atp->desc.a2[1],
  667. atp->desc.a2[2]);
  668. }
  669. if (atp->desc.a3_v) {
  670. printf("  A3 values: %02X %02X %02Xn",
  671. atp->desc.a3[0],
  672. atp->desc.a3[1],
  673. atp->desc.a3[2]);
  674. }
  675. }
  676. #endif /* PRINT_ATIP */
  678. LOCAL int
  679. speed_select_mmc(scgp, speedp, dummy)
  680. SCSI *scgp;
  681. int *speedp;
  682. int dummy;
  683. {
  684. u_char mode[0x100];
  685. int len;
  686. struct cd_mode_page_05 *mp;
  687. int val;
  689. if (speedp)
  690. curspeed = *speedp;
  692. fillbytes((caddr_t)mode, sizeof(mode), '');
  694. if (!get_mode_params(scgp, 0x05, "CD write parameter",
  695. mode, (u_char *)0, (u_char *)0, (u_char *)0, &len))
  696. return (-1);
  697. if (len == 0)
  698. return (-1);
  700. mp = (struct cd_mode_page_05 *)
  701. (mode + sizeof(struct scsi_mode_header) +
  702. ((struct scsi_mode_header *)mode)->blockdesc_len);
  703. #ifdef DEBUG
  704. scsiprbytes("CD write parameter:", (u_char *)mode, len);
  705. #endif
  708. mp->test_write = dummy != 0;
  709. /*
  710.  * Set default values:
  711.  * Write type = 01 (track at once)
  712.  * Track mode = 04 (CD-ROM)
  713.  * Data block type = 08 (CD-ROM)
  714.  * Session format = 00 (CD-ROM)
  715.  */
  716. mp->write_type = WT_TAO;
  717. mp->track_mode = TM_DATA; 
  718. mp->dbtype = DB_ROM_MODE1;
  719. mp->session_format = SES_DA_ROM;/* Matsushita has illegal def. value */
  722. #ifdef DEBUG
  723. scsiprbytes("CD write parameter:", (u_char *)mode, len);
  724. #endif
  725. if (!set_mode_params(scgp, "CD write parameter", mode, len, 0, -1))
  726. return (-1);
  728. if (speedp == 0)
  729. return (0);
  731. /* if (scsi_set_speed(-1, curspeed*176) < 0)*/
  733. /*
  734.  * 44100 * 2 * 2 =  176400 bytes/s
  735.  *
  736.  * The right formula would be:
  737.  * tmp = (((long)curspeed) * 1764) / 10;
  738.  *
  739.  * But the standard is rounding the wrong way.
  740.  * Furtunately rounding down is guaranteed.
  741.  */
  742. if (scsi_set_speed(scgp, -1, curspeed*177) < 0)
  743. return (-1);
  745. if (scsi_get_speed(scgp, 0, &val) >= 0) {
  746. curspeed = val / 176;
  747. *speedp = curspeed;
  748. }
  749. return (0);
  750. }
  752. LOCAL int
  753. next_wr_addr_mmc(scgp, track, trackp, ap)
  754. SCSI *scgp;
  755. int track;
  756. track_t *trackp;
  757. long *ap;
  758. {
  759. struct track_info track_info;
  760. long next_addr;
  761. int result = -1;
  764. /*
  765.  * Reading info for current track may require doing the read_track_info
  766.  * with either the track number (if the track is currently being written)
  767.  * or with 0xFF (if the track hasn't been started yet and is invisible
  768.  */
  770. if (track > 0 && is_packet(trackp)) {
  771. scgp->silent++;
  772. result = read_track_info(scgp, (caddr_t)&track_info, track,
  773. sizeof(track_info));
  774. scgp->silent--;
  775. }
  777. if (result < 0) {
  778. if (read_track_info(scgp, (caddr_t)&track_info, 0xFF,
  779. sizeof(track_info)) < 0)
  780. return (-1);
  781. }
  782. if (scgp->verbose)
  783. scsiprbytes("track info:", (u_char *)&track_info,
  784. sizeof(track_info)-scsigetresid(scgp));
  785. next_addr = a_to_4_byte(track_info.next_writable_addr);
  786. if (ap)
  787. *ap = next_addr;
  788. return (0);
  789. }
  791. int st2mode[] = {
  792. 0, /* 0 */
  793. TM_DATA, /* 1 ST_ROM_MODE1 */
  794. TM_DATA, /* 2 ST_ROM_MODE2 */
  795. 0, /* 3 */
  796. 0, /* 4 ST_AUDIO_NOPRE */
  797. TM_PREEM, /* 5 ST_AUDIO_PRE */
  798. 0, /* 6 */
  799. 0, /* 7 */
  800. };
  802. LOCAL int
  803. open_track_mmc(scgp, dp, track, trackp)
  804. SCSI *scgp;
  805. cdr_t *dp;
  806. int track;
  807. track_t *trackp;
  808. {
  809. u_char mode[0x100];
  810. int len;
  811. struct cd_mode_page_05 *mp;
  813. if (!is_tao(trackp)) {
  814. if (trackp->pregapsize > 0 && (trackp->flags & TI_PREGAP) == 0) {
  815. if (lverbose) {
  816. printf("Writing pregap for track %d at %ldn",
  817. track,
  818. trackp->trackstart-trackp->pregapsize);
  819. }
  820. pad_track(scgp, dp, track, trackp,
  821. trackp->trackstart-trackp->pregapsize,
  822. trackp->pregapsize*trackp->secsize,
  823. FALSE, 0);
  824. }
  825. return (0);
  826. }
  828. fillbytes((caddr_t)mode, sizeof(mode), '');
  830. if (!get_mode_params(scgp, 0x05, "CD write parameter",
  831. mode, (u_char *)0, (u_char *)0, (u_char *)0, &len))
  832. return (-1);
  833. if (len == 0)
  834. return (-1);
  836. mp = (struct cd_mode_page_05 *)
  837. (mode + sizeof(struct scsi_mode_header) +
  838. ((struct scsi_mode_header *)mode)->blockdesc_len);
  841. /* mp->track_mode = ???;*/
  842. mp->track_mode = st2mode[trackp->sectype & ST_MASK];
  843. /* mp->copy = ???;*/
  844. mp->dbtype = trackp->dbtype;
  846. /*i_to_short(mp->audio_pause_len, 300);*/
  847. /*i_to_short(mp->audio_pause_len, 150);*/
  848. /*i_to_short(mp->audio_pause_len, 0);*/
  850. if (is_packet(trackp)) {
  851. mp->write_type = WT_PACKET;
  852. mp->track_mode |= TM_INCREMENTAL;
  853. mp->fp = (trackp->pktsize > 0) ? 1 : 0;
  854. i_to_4_byte(mp->packet_size, trackp->pktsize);
  855. } else {
  856. mp->write_type = WT_TAO;
  857. mp->fp = 0;
  858. i_to_4_byte(mp->packet_size, 0);
  859. }
  860. if (trackp->isrc) {
  861. mp->ISRC[0] = 0x80; /* Set ISRC valid */
  862. strncpy((char *)&mp->ISRC[1], trackp->isrc, 12);
  864. } else {
  865. fillbytes(&mp->ISRC[0], sizeof(mp->ISRC), '');
  866. }
  867.  
  868. #ifdef DEBUG
  869. scsiprbytes("CD write parameter:", (u_char *)mode, len);
  870. #endif
  871. if (!set_mode_params(scgp, "CD write parameter", mode, len, 0, trackp->secsize))
  872. return (-1);
  874. return (0);
  875. }
  877. LOCAL int
  878. close_track_mmc(scgp, track, trackp)
  879. SCSI *scgp;
  880. int track;
  881. track_t *trackp;
  882. {
  883. int ret;
  885. if (!is_tao(trackp))
  886. return (0);
  888. if (scsi_flush_cache(scgp) < 0) {
  889. printf("Trouble flushing the cachen");
  890. return -1;
  891. }
  892. wait_unit_ready(scgp, 300); /* XXX Wait for ATAPI */
  893. if (is_packet(trackp) && !is_noclose(trackp)) {
  894. /* close the incomplete track */
  895. ret = scsi_close_tr_session(scgp, 1, 0xFF);
  896. wait_unit_ready(scgp, 300); /* XXX Wait for ATAPI */
  897. return (ret);
  898. }
  899. return (0);
  900. }
  902. int toc2sess[] = {
  903. SES_DA_ROM, /* CD-DA  */
  904. SES_DA_ROM, /* CD-ROM  */
  905. SES_XA, /* CD-ROM XA mode 1  */
  906. SES_XA, /* CD-ROM XA MODE 2  */
  907. SES_CDI, /* CDI  */
  908. SES_DA_ROM, /* Invalid - use default */
  909. SES_DA_ROM, /* Invalid - use default */
  910. };
  912. LOCAL int
  913. open_session_mmc(scgp, tracks, trackp, toctype, multi)
  914. SCSI *scgp;
  915. int tracks;
  916. track_t *trackp;
  917. int toctype;
  918. int multi;
  919. {
  920. u_char mode[0x100];
  921. int len;
  922. struct cd_mode_page_05 *mp;
  924. fillbytes((caddr_t)mode, sizeof(mode), '');
  926. if (!get_mode_params(scgp, 0x05, "CD write parameter",
  927. mode, (u_char *)0, (u_char *)0, (u_char *)0, &len))
  928. return (-1);
  929. if (len == 0)
  930. return (-1);
  932. mp = (struct cd_mode_page_05 *)
  933. (mode + sizeof(struct scsi_mode_header) +
  934. ((struct scsi_mode_header *)mode)->blockdesc_len);
  936. mp->write_type = WT_TAO; /* fix to allow DAO later */
  937. if (!is_tao(trackp)) {
  938. mp->write_type = WT_SAO;
  939. mp->track_mode = 0;
  940. mp->dbtype = DB_RAW;
  941. }
  943. mp->multi_session = (multi != 0) ? MS_MULTI : MS_NONE;
  944. mp->session_format = toc2sess[toctype & TOC_MASK];
  946. if (trackp->isrc) {
  947. mp->media_cat_number[0] = 0x80; /* Set MCN valid */
  948. strncpy((char *)&mp->media_cat_number[1], trackp->isrc, 13);
  950. } else {
  951. fillbytes(&mp->media_cat_number[0], sizeof(mp->media_cat_number), '');
  952. }
  953. #ifdef DEBUG
  954. scsiprbytes("CD write parameter:", (u_char *)mode, len);
  955. #endif
  956. if (!set_mode_params(scgp, "CD write parameter", mode, len, 0, -1))
  957. return (-1);
  959. return (0);
  960. }
  962. LOCAL int
  963. waitfix_mmc(scgp, secs)
  964. SCSI *scgp;
  965. int secs;
  966. {
  967. char dibuf[16];
  968. int i;
  969. int key;
  970. #define W_SLEEP 2
  972. scgp->silent++;
  973. for (i = 0; i < secs/W_SLEEP; i++) {
  974. if (read_disk_info(scgp, dibuf, sizeof(dibuf)) >= 0) {
  975. scgp->silent--;
  976. return (0);
  977. }
  978. key = scsi_sense_key(scgp);
  979. if (key != SC_UNIT_ATTENTION && key != SC_NOT_READY)
  980. break;
  981. sleep(W_SLEEP);
  982. }
  983. scgp->silent--;
  984. return (-1);
  985. #undef W_SLEEP
  986. }
  988. LOCAL int
  989. fixate_mmc(scgp, onp, dummy, toctype, tracks, trackp)
  990. SCSI *scgp;
  991. int onp;
  992. int dummy;
  993. int toctype;
  994. int tracks;
  995. track_t *trackp;
  996. {
  997. int ret = 0;
  998. int key = 0;
  999. int code = 0;
  1000. struct timeval starttime;
  1001. struct timeval stoptime;
  1003. starttime.tv_sec = 0;
  1004. starttime.tv_usec = 0;
  1005. stoptime = starttime;
  1006. gettimeofday(&starttime, (struct timezone *)0);
  1008. if (dummy && lverbose)
  1009. printf("WARNING: Some drives don't like fixation in dummy mode.n");
  1010. if (is_tao(trackp)) {
  1011. scgp->silent++;
  1012. ret = scsi_close_tr_session(scgp, 2, 0);
  1013. scgp->silent--;
  1014. key = scsi_sense_key(scgp);
  1015. code = scsi_sense_code(scgp);
  1016. } else {
  1017. if (scsi_flush_cache(scgp) < 0)
  1018. printf("Trouble flushing the cachen");
  1019. }
  1020. if (ret >= 0) {
  1021. wait_unit_ready(scgp, 420/curspeed); /* XXX Wait for ATAPI */
  1022. waitfix_mmc(scgp, 420/curspeed); /* XXX Wait for ATAPI */
  1023. return (ret);
  1024. }
  1026. if ((dummy != 0 && (key != SC_ILLEGAL_REQUEST)) ||
  1027. /*
  1028.  * Try to suppress messages from drives that don't like fixation
  1029.  * in -dummy mode.
  1030.  */
  1031.     ((dummy == 0) &&
  1032.      ( ((key != SC_UNIT_ATTENTION) && (key != SC_NOT_READY)) ||
  1033. ((code != 0x2E) && (code != 0x04)) ||
  1034. (strncmp(scgp->inq->vendor_info, "MITSUMI", 7) != 0)))) {
  1035. /*
  1036.  * UNIT ATTENTION/2E seems to be a magic for old Mitsumi ATAPI drives
  1037.  * NOT READY/ code 4 qual 7 (logical unit not ready, operation in progress)
  1038.  * seems to be a magic for newer Mitsumi ATAPI drives
  1039.  * when returning early from fixating.
  1040.  * Try to supress the error message in this case to make
  1041.  * simple minded users less confused.
  1042.  */
  1043. scsiprinterr(scgp);
  1044. scsiprintresult(scgp); /* XXX restore key/code in future */
  1045. }
  1047. wait_unit_ready(scgp, 420); /* XXX Wait for ATAPI */
  1048. waitfix_mmc(scgp, 420/curspeed);/* XXX Wait for ATAPI */
  1050. if (!dummy &&
  1051. (ret >= 0 || (key == SC_UNIT_ATTENTION && code == 0x2E))) {
  1052. /*
  1053.  * Some ATAPI drives (e.g. Mitsumi) imply the
  1054.  * IMMED bit in the SCSI cdb. As there seems to be no
  1055.  * way to properly check for the real end of the
  1056.  * fixating process we wait for the expected time.
  1057.  */
  1058. gettimeofday(&stoptime, (struct timezone *)0);
  1059. timevaldiff(&starttime, &stoptime);
  1060. if (stoptime.tv_sec < (220 / curspeed)) {
  1061. unsigned secs;
  1063. if (lverbose) {
  1064. printf("Actual fixating time: %ld secondsn",
  1065. (long)stoptime.tv_sec);
  1066. }
  1067. secs = (280 / curspeed) - stoptime.tv_sec;
  1068. if (lverbose) {
  1069. printf("ATAPI early return: sleeping %d seconds.n",
  1070. secs);
  1071. }
  1072. sleep(secs);
  1073. }
  1074. }
  1075. return (ret);
  1076. }
  1078. char *blank_types[] = {
  1079. "entire disk",
  1080. "PMA, TOC, pregap",
  1081. "incomplete track",
  1082. "reserved track",
  1083. "tail of track",
  1084. "closing of last session",
  1085. "last session",
  1086. "reserved blanking type",
  1087. };
  1089. LOCAL int
  1090. blank_mmc(scgp, addr, blanktype)
  1091. SCSI *scgp;
  1092. long addr;
  1093. int blanktype;
  1094. {
  1095. BOOL cdrr  = FALSE; /* Read CD-R */
  1096. BOOL cdwr  = FALSE; /* Write CD-R */
  1097. BOOL cdrrw  = FALSE; /* Read CD-RW */
  1098. BOOL cdwrw  = FALSE; /* Write CD-RW */
  1100. mmc_check(scgp, &cdrr, &cdwr, &cdrrw, &cdwrw, NULL);
  1101. if (!cdwrw)
  1102. return (blank_dummy(scgp, addr, blanktype));
  1104. if (lverbose) {
  1105. printf("Blanking %sn", blank_types[blanktype & 0x07]);
  1106. flush();
  1107. }
  1109. return (scsi_blank(scgp, addr, blanktype));
  1110. }
  1112. LOCAL int
  1113. scsi_sony_write(scgp, bp, sectaddr, size, blocks, islast)
  1114. SCSI *scgp;
  1115. caddr_t bp; /* address of buffer */
  1116. long sectaddr; /* disk address (sector) to put */
  1117. long size; /* number of bytes to transfer */
  1118. int blocks; /* sector count */
  1119. BOOL islast; /* last write for track */
  1120. {
  1121. return (write_xg5(scgp, bp, sectaddr, size, blocks));
  1122. }
  1124. Uchar db2df[] = {
  1125. 0x00, /*  0 2352 bytes of raw data */
  1126. 0xFF, /*  1 2368 bytes (raw data + P/Q Subchannel) */
  1127. 0xFF, /*  2 2448 bytes (raw data + P-W Subchannel) */
  1128. 0xFF, /*  3 2448 bytes (raw data + P-W raw Subchannel)*/
  1129. 0xFF, /*  4 -    Reserved */
  1130. 0xFF, /*  5 -    Reserved */
  1131. 0xFF, /*  6 -    Reserved */
  1132. 0xFF, /*  7 -    Vendor specific */
  1133. 0x10, /*  8 2048 bytes Mode 1 (ISO/IEC 10149) */
  1134. 0xFF, /*  9 2336 bytes Mode 2 (ISO/IEC 10149) */
  1135. 0xFF, /* 10 2048 bytes Mode 2! (CD-ROM XA form 1) */
  1136. 0xFF, /* 11 2056 bytes Mode 2 (CD-ROM XA form 1) */
  1137. 0xFF, /* 12 2324 bytes Mode 2 (CD-ROM XA form 2) */
  1138. 0xFF, /* 13 2332 bytes Mode 2 (CD-ROM XA 1/2+subhdr) */
  1139. 0xFF, /* 14 -    Reserved */
  1140. 0xFF, /* 15 -    Vendor specific */
  1141. };
  1143. #include <stdxlib.h>
  1145. LOCAL void fillcue __PR((struct mmc_cue *cp, int ca, int tno, int idx, int dataform, int scms, msf_t *mp));
  1146. EXPORT int do_cue __PR((int tracks, track_t *trackp, struct mmc_cue **cuep));
  1147. EXPORT int send_cue __PR((SCSI *scgp, int tracks, track_t *trackp));
  1149. EXPORT int
  1150. do_cue(tracks, trackp, cuep)
  1151. int tracks;
  1152. track_t *trackp;
  1153. struct mmc_cue **cuep;
  1154. {
  1155. int i;
  1156. struct mmc_cue *cue;
  1157. struct mmc_cue *cp;
  1158. int ncue = 0;
  1159. int icue = 0;
  1160. int pgsize;
  1161. msf_t m;
  1162. int ctl;
  1163. int df;
  1164. int scms;
  1166. cue = (struct mmc_cue *)malloc(1);
  1168. for (i = 0; i <= tracks; i++) {
  1169. ctl = (st2mode[trackp[i].sectype & ST_MASK]) << 4;
  1170. if (is_copy(&trackp[i]))
  1171. ctl |= TM_ALLOW_COPY << 4;
  1172. df = db2df[trackp[i].dbtype & 0x0F];
  1174. if (trackp[i].isrc) { /* MCN or ISRC */
  1175. ncue += 2;
  1176. cue = (struct mmc_cue *)realloc(cue, ncue * sizeof(*cue));
  1177. cp = &cue[icue++];
  1178. if (i == 0) {
  1179. cp->cs_ctladr = 0x02;
  1180. movebytes(&trackp[i].isrc[0], &cp->cs_tno, 7);
  1181. cp = &cue[icue++];
  1182. cp->cs_ctladr = 0x02;
  1183. movebytes(&trackp[i].isrc[7], &cp->cs_tno, 7);
  1184. } else {
  1185. cp->cs_ctladr = 0x03;
  1186. cp->cs_tno = i;
  1187. movebytes(&trackp[i].isrc[0], &cp->cs_index, 6);
  1188. cp = &cue[icue++];
  1189. cp->cs_ctladr = 0x03;
  1190. cp->cs_tno = i;
  1191. movebytes(&trackp[i].isrc[6], &cp->cs_index, 6);
  1192. }
  1193. }
  1194. if (i == 0) { /* Lead in */
  1195. if (df < 0x10)
  1196. df |= 1;
  1197. else
  1198. df |= 4;
  1199. lba_to_msf(-150, &m);
  1200. cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1201. cp = &cue[icue++];
  1202. fillcue(cp, ctl|0x01, i, 0, df, 0, &m);
  1203. } else {
  1204. scms = 0;
  1206. if (is_scms(&trackp[i]))
  1207. scms = 0x80;
  1208. pgsize = trackp[i].pregapsize;
  1209. /* if (pgsize == 0)*/
  1210. /* pgsize = 150;*/
  1211. lba_to_msf(trackp[i].trackstart-pgsize, &m);
  1212. cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1213. cp = &cue[icue++];
  1214. fillcue(cp, ctl|0x01, i, 0, df, scms, &m);
  1216. if (trackp[i].nindex == 1) {
  1217. lba_to_msf(trackp[i].trackstart, &m);
  1218. cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1219. cp = &cue[icue++];
  1220. fillcue(cp, ctl|0x01, i, 1, df, scms, &m);
  1221. } else {
  1222. int idx;
  1223. long *idxlist;
  1225. ncue += trackp[i].nindex;
  1226. idxlist = trackp[i].tindex;
  1227. cue = (struct mmc_cue *)realloc(cue, ncue * sizeof(*cue));
  1229. for(idx = 1; idx <=trackp[i].nindex; idx++) {
  1230. lba_to_msf(trackp[i].trackstart + idxlist[idx], &m);
  1231. cp = &cue[icue++];
  1232. fillcue(cp, ctl|0x01, i, idx, df, scms, &m);
  1233. }
  1234. }
  1235. }
  1236. }
  1237. /* Lead out */
  1238. ctl = (st2mode[trackp[tracks+1].sectype & ST_MASK]) << 4;
  1239. df = db2df[trackp[tracks+1].dbtype & 0x0F];
  1240. if (df < 0x10)
  1241. df |= 1;
  1242. else
  1243. df |= 4;
  1244. lba_to_msf(trackp[tracks+1].trackstart, &m);
  1245. cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1246. cp = &cue[icue++];
  1247. fillcue(cp, ctl|0x01, 0xAA, 1, df, 0, &m);
  1249. if (lverbose > 1) for (i = 0; i < ncue; i++) {
  1250. scsiprbytes("", (Uchar *)&cue[i], 8);
  1251. }
  1252. if (cuep)
  1253. *cuep = cue;
  1254. return (ncue);
  1255. }
  1257. LOCAL void
  1258. fillcue(cp, ca, tno, idx, dataform, scms, mp)
  1259. struct mmc_cue *cp; /* The target cue entry */
  1260. int ca; /* Control/adr for this entry */
  1261. int tno; /* Track number for this entry */
  1262. int idx; /* Index for this entry */
  1263. int dataform; /* Data format for this entry */
  1264. int scms; /* Serial copy management */
  1265. msf_t *mp; /* MSF value for this entry */
  1266. {
  1267. cp->cs_ctladr = ca; /* XXX wie lead in */
  1268. cp->cs_tno = tno;
  1269. cp->cs_index = idx;
  1270. cp->cs_dataform = dataform;/* XXX wie lead in */
  1271. cp->cs_scms = scms;
  1272. cp->cs_min = mp->msf_min;
  1273. cp->cs_sec = mp->msf_sec;
  1274. cp->cs_frame = mp->msf_frame;
  1275. }
  1277. EXPORT int
  1278. send_cue(scgp, tracks, trackp)
  1279. SCSI *scgp;
  1280. int tracks;
  1281. track_t *trackp;
  1282. {
  1283. struct mmc_cue *cp;
  1284. int ncue;
  1285. int ret;
  1286. int i;
  1288. ncue = do_cue(tracks, trackp, &cp);
  1289. for (i = 1; i <= tracks; i++) {
  1290. if (trackp[i].tracksize < 0) {
  1291. errmsgno(EX_BAD, "Track %d has unknown length.n", i);
  1292. return (-1);
  1293. }
  1294. }
  1295. ret = send_cue_sheet(scgp, (caddr_t)cp, ncue*8);
  1296. free(cp);
  1297. return (ret);
  1298. }