drv_philips.c
上传用户:xiejiait
上传日期:2007-01-06
资源大小:881k
文件大小:30k
源码类别:

SCSI/ASPI

开发平台:

MultiPlatform

  1. /* @(#)drv_philips.c 1.34 00/01/28 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static char sccsid[] =
  4. "@(#)drv_philips.c 1.34 00/01/28 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  * CDR device implementation for
  8.  * Philips/Yamaha/Ricoh/Plasmon
  9.  *
  10.  * Copyright (c) 1997 J. Schilling
  11.  */
  12. /*
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2, or (at your option)
  16.  * any later version.
  17.  *
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; see the file COPYING.  If not, write to
  25.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  26.  */
  27. #include <mconfig.h>
  28. #include <stdio.h>
  29. #include <standard.h>
  30. #include <intcvt.h>
  31. #include <scg/scsireg.h>
  32. #include <scg/scsitransp.h>
  33. #include <scg/scgcmd.h>
  34. #include <scg/scsidefs.h> /* XXX Only for DEV_RICOH_RO_1060C */
  35. #include "cdrecord.h"
  36. extern int debug;
  37. extern int lverbose;
  38. LOCAL int load_unload_philips __PR((SCSI *scgp, int));
  39. LOCAL int philips_load __PR((SCSI *scgp));
  40. LOCAL int philips_unload __PR((SCSI *scgp));
  41. LOCAL int philips_dumbload __PR((SCSI *scgp));
  42. LOCAL int philips_dumbunload __PR((SCSI *scgp));
  43. LOCAL int recover_philips __PR((SCSI *scgp, int));
  44. LOCAL int speed_select_yamaha __PR((SCSI *scgp, int *speedp, int dummy));
  45. LOCAL int speed_select_philips __PR((SCSI *scgp, int *speedp, int dummy));
  46. LOCAL int speed_select_oldphilips __PR((SCSI *scgp, int *speedp, int dummy));
  47. LOCAL int speed_select_dumbphilips __PR((SCSI *scgp, int *speedp, int dummy));
  48. LOCAL int speed_select_pioneer __PR((SCSI *scgp, int *speedp, int dummy));
  49. LOCAL int philips_getdisktype __PR((SCSI *scgp, cdr_t *dp, dstat_t *dsp));
  50. LOCAL BOOL capacity_philips __PR((SCSI *scgp, long *lp));
  51. LOCAL int first_writable_addr_philips __PR((SCSI *scgp, long *, int, int, int, int));
  52. LOCAL int next_wr_addr_philips __PR((SCSI *scgp, int track, track_t *trackp, long *ap));
  53. LOCAL int reserve_track_philips __PR((SCSI *scgp, unsigned long));
  54. LOCAL int scsi_cdr_write_philips __PR((SCSI *scgp, caddr_t bp, long sectaddr, long size, int blocks, BOOL islast));
  55. LOCAL int write_track_info_philips __PR((SCSI *scgp, int));
  56. LOCAL int write_track_philips __PR((SCSI *scgp, long, int));
  57. LOCAL int open_track_philips __PR((SCSI *scgp, cdr_t *dp, int track, track_t *track_info));
  58. LOCAL int open_track_oldphilips __PR((SCSI *scgp, cdr_t *dp, int track, track_t *track_info));
  59. LOCAL int open_track_yamaha __PR((SCSI *scgp, cdr_t *dp, int track, track_t *track_info));
  60. LOCAL int close_track_philips __PR((SCSI *scgp, int track, track_t *trackp));
  61. LOCAL int fixation_philips __PR((SCSI *scgp, int, int, int, int tracks, track_t *trackp));
  62. LOCAL int philips_attach __PR((SCSI *scgp, cdr_t *));
  63. LOCAL int plasmon_attach __PR((SCSI *scgp, cdr_t *));
  64. LOCAL int ricoh_attach __PR((SCSI *scgp, cdr_t *));
  65. LOCAL int philips_getlilo __PR((SCSI *scgp, long *lilenp, long *lolenp));
  66. struct cdd_52x_mode_page_21 { /* write track information */
  67. MP_P_CODE; /* parsave & pagecode */
  68. Uchar p_len; /* 0x0E = 14 Bytes */
  69. Uchar res_2;
  70. Uchar sectype;
  71. Uchar track;
  72. Uchar ISRC[9];
  73. Uchar res[2];
  74. };
  75. struct cdd_52x_mode_page_23 { /* speed selection */
  76. MP_P_CODE; /* parsave & pagecode */
  77. Uchar p_len; /* 0x06 = 6 Bytes */
  78. Uchar speed;
  79. Uchar dummy;
  80. Uchar res[4];
  81. };
  82. #if defined(_BIT_FIELDS_LTOH) /* Intel byteorder */
  83. struct yamaha_mode_page_31 { /* drive configuration */
  84. MP_P_CODE; /* parsave & pagecode */
  85. Uchar p_len; /* 0x02 = 2 Bytes */
  86. Uchar res;
  87. Ucbit dummy : 4;
  88. Ucbit speed : 4;
  89. };
  90. #else /* Motorola byteorder */
  91. struct yamaha_mode_page_31 { /* drive configuration */
  92. MP_P_CODE; /* parsave & pagecode */
  93. Uchar p_len; /* 0x02 = 2 Bytes */
  94. Uchar res;
  95. Ucbit speed : 4;
  96. Ucbit dummy : 4;
  97. };
  98. #endif
  99. struct cdd_52x_mode_data {
  100. struct scsi_mode_header header;
  101. union cdd_pagex {
  102. struct cdd_52x_mode_page_21 page21;
  103. struct cdd_52x_mode_page_23 page23;
  104. struct yamaha_mode_page_31 page31;
  105. } pagex;
  106. };
  107. cdr_t cdr_philips_cdd521O = {
  108. 0,
  109. CDR_TAO|CDR_TRAYLOAD,
  110. "philips_cdd521_old",
  111. "driver for Philips old CDD-521",
  112. 0,
  113. drive_identify,
  114. philips_attach,
  115. philips_getdisktype,
  116. philips_load,
  117. philips_unload,
  118. buf_dummy,
  119. recovery_needed,
  120. recover_philips,
  121. speed_select_oldphilips,
  122. select_secsize,
  123. next_wr_addr_philips,
  124. reserve_track_philips,
  125. scsi_cdr_write_philips,
  126. no_sendcue,
  127. open_track_oldphilips,
  128. close_track_philips,
  129. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  130. cmd_dummy,
  131. read_session_offset_philips,
  132. fixation_philips,
  133. blank_dummy,
  134. };
  135. cdr_t cdr_philips_dumb = {
  136. 0,
  137. CDR_TAO|CDR_TRAYLOAD,
  138. "philips_dumb",
  139. "driver for Philips CDD-521 with pessimistic assumptions",
  140. 0,
  141. drive_identify,
  142. philips_attach,
  143. philips_getdisktype,
  144. philips_dumbload,
  145. philips_dumbunload,
  146. buf_dummy,
  147. recovery_needed,
  148. recover_philips,
  149. speed_select_dumbphilips,
  150. select_secsize,
  151. next_wr_addr_philips,
  152. reserve_track_philips,
  153. scsi_cdr_write_philips,
  154. no_sendcue,
  155. open_track_oldphilips,
  156. close_track_philips,
  157. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  158. cmd_dummy,
  159. read_session_offset_philips,
  160. fixation_philips,
  161. blank_dummy,
  162. };
  163. cdr_t cdr_philips_cdd521 = {
  164. 0,
  165. CDR_TAO|CDR_TRAYLOAD,
  166. "philips_cdd521",
  167. "driver for Philips CDD-521",
  168. 0,
  169. drive_identify,
  170. philips_attach,
  171. philips_getdisktype,
  172. philips_load,
  173. philips_unload,
  174. buf_dummy,
  175. recovery_needed,
  176. recover_philips,
  177. speed_select_philips,
  178. select_secsize,
  179. next_wr_addr_philips,
  180. reserve_track_philips,
  181. scsi_cdr_write_philips,
  182. no_sendcue,
  183. open_track_philips,
  184. close_track_philips,
  185. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  186. cmd_dummy,
  187. read_session_offset_philips,
  188. fixation_philips,
  189. blank_dummy,
  190. };
  191. cdr_t cdr_philips_cdd522 = {
  192. 0,
  193. CDR_TAO|CDR_DAO|CDR_TRAYLOAD,
  194. "philips_cdd522",
  195. "driver for Philips CDD-522",
  196. 0,
  197. drive_identify,
  198. philips_attach,
  199. philips_getdisktype,
  200. philips_load,
  201. philips_unload,
  202. buf_dummy,
  203. recovery_needed,
  204. recover_philips,
  205. speed_select_philips,
  206. select_secsize,
  207. next_wr_addr_philips,
  208. reserve_track_philips,
  209. scsi_cdr_write_philips,
  210. no_sendcue,
  211. open_track_philips,
  212. close_track_philips,
  213. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  214. cmd_dummy,
  215. read_session_offset_philips,
  216. fixation_philips,
  217. blank_dummy,
  218. };
  219. cdr_t cdr_kodak_pcd600 = {
  220. 0,
  221. CDR_TAO|CDR_TRAYLOAD,
  222. "kodak_pcd_600",
  223. "driver for Kodak PCD-600",
  224. 0,
  225. drive_identify,
  226. philips_attach,
  227. philips_getdisktype,
  228. philips_load,
  229. philips_unload,
  230. buf_dummy,
  231. recovery_needed,
  232. recover_philips,
  233. speed_select_philips,
  234. select_secsize,
  235. next_wr_addr_philips,
  236. reserve_track_philips,
  237. scsi_cdr_write_philips,
  238. no_sendcue,
  239. open_track_oldphilips,
  240. close_track_philips,
  241. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  242. cmd_dummy,
  243. read_session_offset_philips,
  244. fixation_philips,
  245. blank_dummy,
  246. };
  247. cdr_t cdr_plasmon_rf4100 = {
  248. 0,
  249. CDR_TAO|CDR_TRAYLOAD,
  250. "plasmon_rf4100",
  251. "driver for Plasmon RF 4100",
  252. 0,
  253. drive_identify,
  254. plasmon_attach,
  255. philips_getdisktype,
  256. philips_load,
  257. philips_unload,
  258. buf_dummy,
  259. recovery_needed,
  260. recover_philips,
  261. speed_select_philips,
  262. select_secsize,
  263. next_wr_addr_philips,
  264. reserve_track_philips,
  265. scsi_cdr_write_philips,
  266. no_sendcue,
  267. open_track_philips,
  268. close_track_philips,
  269. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  270. cmd_dummy,
  271. read_session_offset_philips,
  272. fixation_philips,
  273. blank_dummy,
  274. };
  275. cdr_t cdr_pioneer_dw_s114x = {
  276. 0,
  277. CDR_TAO|CDR_TRAYLOAD|CDR_SWABAUDIO,
  278. "pioneer_dws114x",
  279. "driver for Pioneer DW-S114X",
  280. 0,
  281. drive_identify,
  282. philips_attach,
  283. philips_getdisktype,
  284. scsi_load,
  285. scsi_unload,
  286. buf_dummy,
  287. recovery_needed,
  288. recover_philips,
  289. speed_select_pioneer,
  290. select_secsize,
  291. next_wr_addr_philips,
  292. reserve_track_philips,
  293. scsi_cdr_write_philips,
  294. no_sendcue,
  295. /* open_track_yamaha,*/
  296. /*???*/ open_track_oldphilips,
  297. close_track_philips,
  298. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  299. cmd_dummy,
  300. read_session_offset_philips,
  301. fixation_philips,
  302. blank_dummy,
  303. };
  304. cdr_t cdr_yamaha_cdr100 = {
  305. 0,
  306. CDR_TAO|CDR_DAO|CDR_CADDYLOAD|CDR_SWABAUDIO,
  307. "yamaha_cdr100",
  308. "driver for Yamaha CDR-100 / CDR-102",
  309. 0,
  310. drive_identify,
  311. philips_attach,
  312. drive_getdisktype,
  313. (int(*)__PR((SCSI *)))cmd_dummy,
  314. philips_unload,
  315. buf_dummy,
  316. recovery_needed,
  317. recover_philips,
  318. speed_select_yamaha,
  319. select_secsize,
  320. next_wr_addr_philips,
  321. reserve_track_philips,
  322. scsi_cdr_write_philips,
  323. no_sendcue,
  324. open_track_yamaha,
  325. close_track_philips,
  326. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  327. cmd_dummy,
  328. read_session_offset_philips,
  329. fixation_philips,
  330. blank_dummy,
  331. };
  332. cdr_t cdr_ricoh_ro1060 = {
  333. 0,
  334. CDR_TAO|CDR_DAO|CDR_CADDYLOAD,
  335. "ricoh_ro1060c",
  336. "driver for Ricoh RO-1060C",
  337. 0,
  338. drive_identify,
  339. ricoh_attach,
  340. philips_getdisktype,
  341. scsi_load,
  342. scsi_unload,
  343. buf_dummy,
  344. recovery_needed,
  345. recover_philips,
  346. speed_select_yamaha,
  347. select_secsize,
  348. next_wr_addr_philips,
  349. reserve_track_philips,
  350. scsi_cdr_write_philips,
  351. no_sendcue,
  352. open_track_philips,
  353. close_track_philips,
  354. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  355. cmd_dummy,
  356. read_session_offset_philips,
  357. fixation_philips,
  358. blank_dummy,
  359. };
  360. cdr_t cdr_ricoh_ro1420 = {
  361. 0,
  362. CDR_TAO|CDR_DAO|CDR_CADDYLOAD,
  363. "ricoh_ro1420c",
  364. "driver for Ricoh RO-1420C",
  365. 0,
  366. drive_identify,
  367. ricoh_attach,
  368. philips_getdisktype,
  369. scsi_load,
  370. scsi_unload,
  371. buf_dummy,
  372. recovery_needed,
  373. recover_philips,
  374. speed_select_yamaha,
  375. select_secsize,
  376. next_wr_addr_philips,
  377. reserve_track_philips,
  378. scsi_cdr_write_philips,
  379. no_sendcue,
  380. open_track_philips,
  381. close_track_philips,
  382. (int(*)__PR((SCSI *, int, track_t *, int, int)))cmd_dummy,
  383. cmd_dummy,
  384. read_session_offset_philips,
  385. fixation_philips,
  386. blank_dummy,
  387. };
  388. LOCAL int
  389. load_unload_philips(scgp, load)
  390. SCSI *scgp;
  391. int load;
  392. {
  393. register struct scg_cmd *scmd = scgp->scmd;
  394. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  395. scmd->flags = SCG_DISRE_ENA;
  396. scmd->cdb_len = SC_G1_CDBLEN;
  397. scmd->sense_len = CCS_SENSE_LEN;
  398. scmd->target = scgp->target;
  399. scmd->cdb.g1_cdb.cmd = 0xE7;
  400. scmd->cdb.g1_cdb.lun = scgp->lun;
  401. scmd->cdb.g1_cdb.count[1] = !load;
  402. scgp->cmdname = "philips medium load/unload";
  403. if (scsicmd(scgp) < 0)
  404. return (-1);
  405. return (0);
  406. }
  407. LOCAL int
  408. philips_load(scgp)
  409. SCSI *scgp;
  410. {
  411. return (load_unload_philips(scgp, 1));
  412. }
  413. LOCAL int
  414. philips_unload(scgp)
  415. SCSI *scgp;
  416. {
  417. return (load_unload_philips(scgp, 0));
  418. }
  419. LOCAL int
  420. philips_dumbload(scgp)
  421. SCSI *scgp;
  422. {
  423. int ret;
  424. scgp->silent++;
  425. ret = load_unload_philips(scgp, 1);
  426. scgp->silent--;
  427. if (ret < 0)
  428. return (scsi_load(scgp));
  429. return (0);
  430. }
  431. LOCAL int
  432. philips_dumbunload(scgp)
  433. SCSI *scgp;
  434. {
  435. int ret;
  436. scgp->silent++;
  437. ret = load_unload_philips(scgp, 0);
  438. scgp->silent--;
  439. if (ret < 0)
  440. return (scsi_unload(scgp));
  441. return (0);
  442. }
  443. LOCAL int
  444. recover_philips(scgp, track)
  445. SCSI *scgp;
  446. int track;
  447. {
  448. register struct scg_cmd *scmd = scgp->scmd;
  449. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  450. scmd->flags = SCG_DISRE_ENA;
  451. scmd->cdb_len = SC_G1_CDBLEN;
  452. scmd->sense_len = CCS_SENSE_LEN;
  453. scmd->target = scgp->target;
  454. scmd->cdb.g1_cdb.cmd = 0xEC;
  455. scmd->cdb.g1_cdb.lun = scgp->lun;
  456. scgp->cmdname = "philips recover";
  457. if (scsicmd(scgp) < 0)
  458. return (-1);
  459. return (0);
  460. }
  461. LOCAL int
  462. speed_select_yamaha(scgp, speedp, dummy)
  463. SCSI *scgp;
  464. int *speedp;
  465. int dummy;
  466. {
  467. struct scsi_mode_page_header *mp;
  468. char mode[256];
  469. int len = 16;
  470. int page = 0x31;
  471. struct yamaha_mode_page_31 *xp;
  472. struct cdd_52x_mode_data md;
  473. int count;
  474. int speed = 1;
  475. if (speedp) {
  476. speed = *speedp;
  477. } else {
  478. fillbytes((caddr_t)mode, sizeof(mode), '');
  479. if (!get_mode_params(scgp, page, "Speed/Dummy information",
  480. (u_char *)mode, (u_char *)0, (u_char *)0, (u_char *)0, &len)) {
  481. return (-1);
  482. }
  483. if (len == 0)
  484. return (-1);
  485. mp = (struct scsi_mode_page_header *)
  486. (mode + sizeof(struct scsi_mode_header) +
  487. ((struct scsi_mode_header *)mode)->blockdesc_len);
  488. xp = (struct yamaha_mode_page_31 *)mp;
  489. speed = xp->speed;
  490. }
  491. fillbytes((caddr_t)&md, sizeof(md), '');
  492. count  = sizeof(struct scsi_mode_header) +
  493. sizeof(struct yamaha_mode_page_31);
  494. speed >>= 1;
  495. md.pagex.page31.p_code = 0x31;
  496. md.pagex.page31.p_len =  0x02;
  497. md.pagex.page31.speed = speed;
  498. md.pagex.page31.dummy = dummy?1:0;
  499. return (mode_select(scgp, (Uchar *)&md, count, 0, scgp->inq->data_format >= 2));
  500. }
  501. LOCAL int
  502. speed_select_philips(scgp, speedp, dummy)
  503. SCSI *scgp;
  504. int *speedp;
  505. int dummy;
  506. {
  507. struct scsi_mode_page_header *mp;
  508. char mode[256];
  509. int len = 20;
  510. int page = 0x23;
  511. struct cdd_52x_mode_page_23 *xp;
  512. struct cdd_52x_mode_data md;
  513. int count;
  514. int speed = 1;
  515. if (speedp) {
  516. speed = *speedp;
  517. } else {
  518. fillbytes((caddr_t)mode, sizeof(mode), '');
  519. if (!get_mode_params(scgp, page, "Speed/Dummy information",
  520. (u_char *)mode, (u_char *)0, (u_char *)0, (u_char *)0, &len)) {
  521. return (-1);
  522. }
  523. if (len == 0)
  524. return (-1);
  525. mp = (struct scsi_mode_page_header *)
  526. (mode + sizeof(struct scsi_mode_header) +
  527. ((struct scsi_mode_header *)mode)->blockdesc_len);
  528. xp = (struct cdd_52x_mode_page_23 *)mp;
  529. speed = xp->speed;
  530. }
  531. fillbytes((caddr_t)&md, sizeof(md), '');
  532. count  = sizeof(struct scsi_mode_header) +
  533. sizeof(struct cdd_52x_mode_page_23);
  534. md.pagex.page23.p_code = 0x23;
  535. md.pagex.page23.p_len =  0x06;
  536. md.pagex.page23.speed = speed;
  537. md.pagex.page23.dummy = dummy?1:0;
  538. return (mode_select(scgp, (Uchar *)&md, count, 0, scgp->inq->data_format >= 2));
  539. }
  540. LOCAL int
  541. speed_select_pioneer(scgp, speedp, dummy)
  542. SCSI *scgp;
  543. int *speedp;
  544. int dummy;
  545. {
  546. if (speedp != 0 && *speedp < 2) {
  547. *speedp = 2;
  548. if (lverbose)
  549. printf("WARNING: setting to minimum speed (2).n");
  550. }
  551. return (speed_select_philips(scgp, speedp, dummy));
  552. }
  553. LOCAL int
  554. speed_select_oldphilips(scgp, speedp, dummy)
  555. SCSI *scgp;
  556. int *speedp;
  557. int dummy;
  558. {
  559. if (lverbose)
  560. printf("WARNING: ignoring selected speed.n");
  561. if (dummy) {
  562. errmsgno(EX_BAD, "Cannot set dummy writing for this device.n");
  563. return (-1);
  564. }
  565. return (0);
  566. }
  567. LOCAL int
  568. speed_select_dumbphilips(scgp, speedp, dummy)
  569. SCSI *scgp;
  570. int *speedp;
  571. int dummy;
  572. {
  573. if (speed_select_philips(scgp, speedp, dummy) < 0)
  574. return (speed_select_oldphilips(scgp, speedp, dummy));
  575. return (0);
  576. }
  577. #define IS(what,flag) printf("  Is %s%sn", flag?"":"not ",what);
  578. LOCAL int
  579. philips_getdisktype(scgp, dp, dsp)
  580. SCSI *scgp;
  581. cdr_t *dp;
  582. dstat_t *dsp;
  583. {
  584. char sbuf[16];
  585. long dummy;
  586. long lilen;
  587. long lolen;
  588. msf_t msf;
  589. int audio = -1;
  590. scgp->silent++;
  591. dummy = (*dp->cdr_next_wr_address)(scgp, 0, (track_t *)0, &lilen);
  592. scgp->silent--;
  593. /*
  594.  * Check for "Command sequence error" first.
  595.  */
  596. if ((dsp->ds_cdrflags & RF_WRITE) != 0 &&
  597.     dummy < 0 &&
  598.     (scsi_sense_key(scgp) != SC_ILLEGAL_REQUEST ||
  599. scsi_sense_code(scgp) != 0x2C)) {
  600. errmsgno(EX_BAD, "Drive needs to reload the media to return to proper status.n");
  601. unload_media(scgp, dp, F_EJECT);
  602. load_media(scgp, dp, TRUE);
  603. }
  604. scgp->silent++;
  605. if (read_subchannel(scgp, sbuf, 0, 12, 0, 1, 0xf0) >= 0) {
  606. if (sbuf[2] ==0 && sbuf[3] == 8)
  607. audio = (sbuf[7] & 0x40) != 0;
  608. }
  609. scgp->silent--;
  610. if (lverbose && dummy >= 0 && lilen == 0) {
  611. scgp->silent++;
  612. dummy = philips_getlilo(scgp, &lilen, &lolen);
  613. scgp->silent--;
  614. if (dummy >= 0) {
  615. /* printf("lead-in len: %d lead-out len: %dn", lilen, lolen);*/
  616. lba_to_msf(-150 - lilen, &msf);
  617. printf("ATIP info from disk:n");
  618. if (audio >= 0)
  619. IS("unrestricted", audio);
  620. if (audio == 1 || (audio == 0 && (sbuf[7] & 0x3F) != 0x3F))
  621. printf("  Disk application code: %dn", sbuf[7] & 0x3F);
  622. printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)n",
  623. -150 - lilen, msf.msf_min, msf.msf_sec, msf.msf_frame);
  624. if (capacity_philips(scgp, &lolen)) {
  625. lba_to_msf(lolen, &msf);
  626. printf(
  627. "  ATIP start of lead out: %ld (%02d:%02d/%02d)n",
  628. lolen, msf.msf_min, msf.msf_sec, msf.msf_frame);
  629. }
  630. lba_to_msf(-150 - lilen, &msf);
  631. pr_manufacturer(&msf,
  632. FALSE, /* Always not erasable */
  633. audio>0); /* Audio from read subcode */
  634. }
  635. }
  636. if (capacity_philips(scgp, &lolen)) {
  637. dsp->ds_maxblocks = lolen;
  638. dsp->ds_maxrblocks = disk_rcap(&msf, dsp->ds_maxblocks,
  639. FALSE, /* Always not erasable */
  640. audio>0); /* Audio from read subcode */
  641. }
  642. scgp->silent++;
  643. /*read_subchannel(scgp, bp, track, cnt, msf, subq, fmt); */
  644. if (read_subchannel(scgp, sbuf, 0, 14, 0, 0, 0xf1) >= 0)
  645. scsiprbytes("Disk bar code:", (Uchar *)sbuf, 14 - scsigetresid(scgp));
  646. scgp->silent--;
  647. return (drive_getdisktype(scgp, dp, dsp));
  648. }
  649. LOCAL BOOL
  650. capacity_philips(scgp, lp)
  651. SCSI *scgp;
  652. long *lp;
  653. {
  654. long l = 0L;
  655. BOOL succeed = TRUE;
  656. scgp->silent++;
  657. if (read_B0(scgp, FALSE, NULL, &l) >= 0) {
  658. if (debug)
  659. printf("lead out B0: %ldn", l);
  660. *lp = l;
  661. } else if (read_trackinfo(scgp, 0xAA, &l, NULL, NULL, NULL, NULL) >= 0) {
  662. if (debug)
  663. printf("lead out AA: %ldn", l);
  664. *lp = l;
  665. } if (read_capacity(scgp) >= 0) {
  666. l = scgp->cap->c_baddr + 1;
  667. if (debug)
  668. printf("lead out capacity: %ldn", l);
  669. } else {
  670. succeed = FALSE;
  671. }
  672. *lp = l;
  673. scgp->silent--;
  674. return (succeed);
  675. }
  676. struct fwa {
  677. char len;
  678. char addr[4];
  679. char res;
  680. };
  681. LOCAL int
  682. first_writable_addr_philips(scgp, ap, track, isaudio, preemp, npa)
  683. SCSI *scgp;
  684. long *ap;
  685. int track;
  686. int isaudio;
  687. int preemp;
  688. int npa;
  689. {
  690.  struct fwa fwa;
  691. register struct scg_cmd *scmd = scgp->scmd;
  692. fillbytes((caddr_t)&fwa, sizeof(fwa), '');
  693. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  694. scmd->addr = (caddr_t)&fwa;
  695. scmd->size = sizeof(fwa);
  696. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  697. scmd->cdb_len = SC_G1_CDBLEN;
  698. scmd->sense_len = CCS_SENSE_LEN;
  699. scmd->target = scgp->target;
  700. scmd->cdb.g1_cdb.cmd = 0xE2;
  701. scmd->cdb.g1_cdb.lun = scgp->lun;
  702. scmd->cdb.g1_cdb.addr[0] = track;
  703. scmd->cdb.g1_cdb.addr[1] = isaudio ? (preemp ? 5 : 4) : 1;
  704. scmd->cdb.g1_cdb.count[0] = npa?1:0;
  705. scmd->cdb.g1_cdb.count[1] = sizeof(fwa);
  706. scgp->cmdname = "first writeable address philips";
  707. if (scsicmd(scgp) < 0)
  708. return (-1);
  709. if (ap)
  710. *ap = a_to_4_byte(fwa.addr);
  711. return (0);
  712. }
  713. LOCAL int
  714. next_wr_addr_philips(scgp, track, trackp, ap)
  715. SCSI *scgp;
  716. int track;
  717. track_t *trackp;
  718. long *ap;
  719. {
  720. /* if (first_writable_addr_philips(scgp, ap, 0, 0, 0, 1) < 0)*/
  721. if (first_writable_addr_philips(scgp, ap, 0, 0, 0, 0) < 0)
  722. return (-1);
  723. return (0);
  724. }
  725. LOCAL int
  726. reserve_track_philips(scgp, len)
  727. SCSI *scgp;
  728. unsigned long len;
  729. {
  730. register struct scg_cmd *scmd = scgp->scmd;
  731. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  732. scmd->flags = SCG_DISRE_ENA;
  733. scmd->cdb_len = SC_G1_CDBLEN;
  734. scmd->sense_len = CCS_SENSE_LEN;
  735. scmd->target = scgp->target;
  736. scmd->cdb.g1_cdb.cmd = 0xE4;
  737. scmd->cdb.g1_cdb.lun = scgp->lun;
  738. i_to_4_byte(&scmd->cdb.g1_cdb.addr[3], len);
  739. scgp->cmdname = "philips reserve_track";
  740. if (scsicmd(scgp) < 0)
  741. return (-1);
  742. return (0);
  743. }
  744. LOCAL int
  745. scsi_cdr_write_philips(scgp, bp, sectaddr, size, blocks, islast)
  746. SCSI *scgp;
  747. caddr_t bp; /* address of buffer */
  748. long sectaddr; /* disk address (sector) to put */
  749. long size; /* number of bytes to transfer */
  750. int blocks; /* sector count */
  751. BOOL islast; /* last write for track */
  752. {
  753. return (write_xg0(scgp, bp, 0, size, blocks));
  754. }
  755. LOCAL int
  756. write_track_info_philips(scgp, sectype)
  757. SCSI *scgp;
  758. int sectype;
  759. {
  760. struct cdd_52x_mode_data md;
  761. int count = sizeof(struct scsi_mode_header) +
  762. sizeof(struct cdd_52x_mode_page_21);
  763. fillbytes((caddr_t)&md, sizeof(md), '');
  764. md.pagex.page21.p_code = 0x21;
  765. md.pagex.page21.p_len =  0x0E;
  766. /* is sectype ok ??? */
  767. md.pagex.page21.sectype = sectype;
  768. md.pagex.page21.track = 0; /* 0 : create new track */
  769. return (mode_select(scgp, (Uchar *)&md, count, 0, scgp->inq->data_format >= 2));
  770. }
  771. LOCAL int
  772. write_track_philips(scgp, track, sectype)
  773. SCSI *scgp;
  774. long track; /* track number 0 == new track */
  775. int sectype;
  776. {
  777. register struct scg_cmd *scmd = scgp->scmd;
  778. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  779. scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
  780. /* scmd->flags = SCG_DISRE_ENA;*/
  781. scmd->cdb_len = SC_G1_CDBLEN;
  782. scmd->sense_len = CCS_SENSE_LEN;
  783. scmd->target = scgp->target;
  784. scmd->cdb.g1_cdb.cmd = 0xE6;
  785. scmd->cdb.g1_cdb.lun = scgp->lun;
  786. g1_cdbaddr(&scmd->cdb.g1_cdb, track);
  787. scmd->cdb.g1_cdb.res6 = sectype;
  788. scgp->cmdname = "philips write_track";
  789. if (scsicmd(scgp) < 0)
  790. return (-1);
  791. return (0);
  792. }
  793. LOCAL int
  794. open_track_philips(scgp, dp, track, track_info)
  795. SCSI *scgp;
  796. cdr_t *dp;
  797. int track;
  798. track_t *track_info;
  799. {
  800. if (select_secsize(scgp, track_info->secsize) < 0)
  801. return (-1);
  802. if (write_track_info_philips(scgp, track_info->sectype) < 0)
  803. return (-1);
  804. if (write_track_philips(scgp, 0, track_info->sectype) < 0)
  805. return (-1);
  806. return (0);
  807. }
  808. LOCAL int
  809. open_track_oldphilips(scgp, dp, track, track_info)
  810. SCSI *scgp;
  811. cdr_t *dp;
  812.   int track;
  813. track_t *track_info;
  814. {
  815. if (write_track_philips(scgp, 0, track_info->sectype) < 0)
  816. return (-1);
  817. return (0);
  818. }
  819. LOCAL int
  820. open_track_yamaha(scgp, dp, track, track_info)
  821. SCSI *scgp;
  822. cdr_t *dp;
  823.   int track;
  824. track_t *track_info;
  825. {
  826. if (select_secsize(scgp, track_info->secsize) < 0)
  827. return (-1);
  828. if (write_track_philips(scgp, 0, track_info->sectype) < 0)
  829. return (-1);
  830. return (0);
  831. }
  832. LOCAL int
  833. close_track_philips(scgp, track, trackp)
  834. SCSI *scgp;
  835. int track;
  836. track_t *trackp;
  837. {
  838. return (scsi_flush_cache(scgp));
  839. }
  840. LOCAL int
  841. fixation_philips(scgp, onp, dummy, type, tracks, trackp)
  842. SCSI *scgp;
  843. int onp; /* open next program area */
  844. int dummy;
  845. int type; /* TOC type 0: CD-DA, 1: CD-ROM, 2: CD-ROM/XA1, 3: CD-ROM/XA2, 4: CDI */
  846. int tracks;
  847. track_t *trackp;
  848. {
  849. register struct scg_cmd *scmd = scgp->scmd;
  850. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  851. scmd->flags = SCG_DISRE_ENA;
  852. scmd->cdb_len = SC_G1_CDBLEN;
  853. scmd->sense_len = CCS_SENSE_LEN;
  854. scmd->target = scgp->target;
  855. scmd->timeout = 8 * 60; /* Needs up to 4 minutes */
  856. scmd->cdb.g1_cdb.cmd = 0xE9;
  857. scmd->cdb.g1_cdb.lun = scgp->lun;
  858. scmd->cdb.g1_cdb.count[1] = (onp ? 8 : 0) | type;
  859. scgp->cmdname = "philips fixation";
  860. if (scsicmd(scgp) < 0)
  861. return (-1);
  862. return (0);
  863. }
  864. static const char *sd_cdd_521_error_str[] = {
  865. "0300tray out", /* 0x03 */
  866. "6200write data error with CU", /* 0x32 */ /* Yamaha */
  867. "6300monitor atip error", /* 0x33 */
  868. "6400absorbtion control error", /* 0x34 */
  869. #ifdef YAMAHA_CDR_100
  870. /* Is this the same ??? */
  871. "12000write operation in progress", /* 0x50 */
  872. #endif
  873. "12700unable to read TOC/PMA/Subcode/ATIP", /* 0x57 */
  874. "13200operator medium removal request", /* 0x5a */
  875. "14500verify failed", /* 0x65 */
  876. "20100illegal track number", /* 0x81 */
  877. "20200command now not valid", /* 0x82 */
  878. "20300medium removal is prevented", /* 0x83 */
  879. "20400tray out", /* 0x84 */
  880. "20500track at one not in PMA", /* 0x85 */
  881. "24000stopped on non data block", /* 0xa0 */
  882. "24100invalid start adress", /* 0xa1 */
  883. "24200attampt to cross track-boundary", /* 0xa2 */
  884. "24300illegal medium", /* 0xa3 */
  885. "24400disk write protected", /* 0xa4 */
  886. "24500application code conflict", /* 0xa5 */
  887. "24600illegal blocksize for command", /* 0xa6 */
  888. "24700blocksize conflict", /* 0xa7 */
  889. "25000illegal transfer length", /* 0xa8 */
  890. "25100request for fixation failed", /* 0xa9 */
  891. "25200end of medium reached", /* 0xaa */
  892. #ifdef REAL_CDD_521
  893. "25300non reserved reserved track", /* 0xab */
  894. #else
  895. "25300illegal track number", /* 0xab */
  896. #endif
  897. "25400data track length error", /* 0xac */
  898. "25500buffer under run", /* 0xad */
  899. "25600illegal track mode", /* 0xae */
  900. "25700optical power calibration error", /* 0xaf */
  901. "26000calibration area almost full", /* 0xb0 */
  902. "26100current program area empty", /* 0xb1 */
  903. "26200no efm at search address", /* 0xb2 */
  904. "26300link area encountered", /* 0xb3 */
  905. "26400calibration area full", /* 0xb4 */
  906. "26500dummy data blocks added", /* 0xb5 */
  907. "26600block size format conflict", /* 0xb6 */
  908. "26700current command aborted", /* 0xb7 */
  909. "27000program area not empty", /* 0xb8 */
  910. #ifdef YAMAHA_CDR_100
  911. /* Used while writing lead in in DAO */
  912. "27000write leadin in progress", /* 0xb8 */
  913. #endif
  914. "27100parameter list too large", /* 0xb9 */
  915. "27700buffer overflow", /* 0xbf */ /* Yamaha */
  916. "30000no barcode available", /* 0xc0 */
  917. "30100barcode reading error", /* 0xc1 */
  918. "32000recovery needed", /* 0xd0 */
  919. "32100cannot recover track", /* 0xd1 */
  920. "32200cannot recover pma", /* 0xd2 */
  921. "32300cannot recover leadin", /* 0xd3 */
  922. "32400cannot recover leadout", /* 0xd4 */
  923. "32500cannot recover opc", /* 0xd5 */
  924. "32600eeprom failure", /* 0xd6 */
  925. "34000laser current over", /* 0xe0 */ /* Yamaha */
  926. "34100servo adjustment over", /* 0xe0 */ /* Yamaha */
  927. NULL
  928. };
  929. static const char *sd_ro1420_error_str[] = {
  930. "0400logical unit is in process of becoming ready", /* 04 00 */
  931. "11200radial skating error", /* 09 80 */
  932. "11201sledge servo failure", /* 09 81 */
  933. "11202pll no lock", /* 09 82 */
  934. "11203servo off track", /* 09 83 */
  935. "11204atip sync error", /* 09 84 */
  936. "11205atip/subcode jumped error", /* 09 85 */
  937. "127300subcode not found", /* 57 C0 */
  938. "127301atip not found", /* 57 C1 */
  939. "127302no atip or subcode", /* 57 C2 */
  940. "127303pma error", /* 57 C3 */
  941. "127304toc read error", /* 57 C4 */
  942. "127305disk informatoion error", /* 57 C5 */
  943. "144200read in leadin", /* 64 80 */
  944. "144201read in leadout", /* 64 81 */
  945. "20100illegal track", /* 81 00 */
  946. "20200command not now valid", /* 82 00 */
  947. "22000reserve track check error", /* 90 00 */
  948. "22001verify blank error", /* 90 01 */
  949. "22101mode of last track error", /* 91 01 */
  950. "22200header search error", /* 92 00 */
  951. "23001header monitor error", /* 98 01 */
  952. "23002edc error", /* 98 02 */
  953. "23003read link, run-in run-out", /* 98 03 */
  954. "23004last one block error", /* 98 04 */
  955. "23005illegal blocksize", /* 98 05 */
  956. "23006not all data transferred", /* 98 06 */
  957. "23007cdbd over run error", /* 98 07 */
  958. "24000stopped on non_data block", /* A0 00 */
  959. "24100invalid start address", /* A1 00 */
  960. "24300illegal medium", /* A3 00 */
  961. "24600illegal blocksize for command", /* A6 00 */
  962. "25100request for fixation failed", /* A9 00 */
  963. "25200end of medium reached", /* AA 00 */
  964. "25300illegal track number", /* AB 00 */
  965. "25500buffer underrun", /* AD 00 */
  966. "25600illegal track mode", /* AE 00 */
  967. "257200power range error", /* AF 80 */
  968. "257201moderation error", /* AF 81 */
  969. "257202beta upper range error", /* AF 82 */
  970. "257203beta lower range error", /* AF 83 */
  971. "257204alpha upper range error", /* AF 84 */
  972. "257205alpha lower range error", /* AF 85 */
  973. "257206alpha and power range error", /* AF 86 */
  974. "26000calibration area almost full", /* B0 00 */
  975. "26100current program area empty", /* B1 00 */
  976. "26200no efm at search address", /* B2 00 */
  977. "26400calibration area full", /* B4 00 */
  978. "26500dummy blocks added", /* B5 00 */
  979. "27200write audio on reserved track", /* BA 00 */
  980. "302200syscon rom error", /* C2 80 */
  981. "302201syscon ram error", /* C2 81 */
  982. "302220efm encoder error", /* C2 90 */
  983. "302221efm decoder error", /* C2 91 */
  984. "302222servo ic error", /* C2 92 */
  985. "302223motor controller error", /* C2 93 */
  986. "302224dac error", /* C2 94 */
  987. "302225syscon eeprom error", /* C2 95 */
  988. "302240block decoder communication error", /* C2 A0 */
  989. "302241block encoder communication error", /* C2 A1 */
  990. "302242block encoder/decoder path error", /* C2 A2 */
  991. "30300CD-R engine selftest error", /* C3 xx */
  992. "30400buffer parity error", /* C4 00 */
  993. "30500data transfer error", /* C5 00 */
  994. "3400012V failure", /* E0 00 */
  995. "34100undefined syscon error", /* E1 00 */
  996. "34101syscon communication error", /* E1 01 */
  997. "34102unknown syscon error", /* E1 02 */
  998. "34200syscon not ready", /* E2 00 */
  999. "34300command rejected", /* E3 00 */
  1000. "34400command not accepted", /* E4 00 */
  1001. "34500verify error at beginning of track", /* E5 00 */
  1002. "34501verify error at ending of track", /* E5 01 */
  1003. "34502verify error at beginning of lead-in", /* E5 02 */
  1004. "34503verify error at ending of lead-in", /* E5 03 */
  1005. "34504verify error at beginning of lead-out", /* E5 04 */
  1006. "34505verify error at ending of lead-out", /* E5 05 */
  1007. "37700command phase timeout error", /* FF 00 */
  1008. "37701data in phase timeout error", /* FF 01 */
  1009. "37702data out phase timeout error", /* FF 02 */
  1010. "37703status phase timeout error", /* FF 03 */
  1011. "37704message in phase timeout error", /* FF 04 */
  1012. "37705message out phase timeout error", /* FF 05 */
  1013. NULL
  1014. };
  1015. LOCAL int
  1016. philips_attach(scgp, dp)
  1017. SCSI *scgp;
  1018. cdr_t *dp;
  1019. {
  1020. scsi_setnonstderrs(scgp, sd_cdd_521_error_str);
  1021. return (0);
  1022. }
  1023. LOCAL int
  1024. plasmon_attach(scgp, dp)
  1025. SCSI *scgp;
  1026. cdr_t *dp;
  1027. {
  1028. scgp->inq->data_format = 1; /* Correct the ly */
  1029. scsi_setnonstderrs(scgp, sd_cdd_521_error_str);
  1030. return (0);
  1031. }
  1032. LOCAL int
  1033. ricoh_attach(scgp, dp)
  1034. SCSI *scgp;
  1035. cdr_t *dp;
  1036. {
  1037. if (dp == &cdr_ricoh_ro1060) {
  1038. errmsgno(EX_BAD, "No support for Ricoh RO-1060Cn");
  1039. return (-1);
  1040. }
  1041. scsi_setnonstderrs(scgp, sd_ro1420_error_str);
  1042. return (0);
  1043. }
  1044. LOCAL int
  1045. philips_getlilo(scgp, lilenp, lolenp)
  1046. SCSI *scgp;
  1047. long *lilenp;
  1048. long *lolenp;
  1049. {
  1050.  char buf[4];
  1051.  long li, lo;
  1052. register struct scg_cmd *scmd = scgp->scmd;
  1053. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1054. scmd->addr = buf;
  1055. scmd->size = sizeof(buf);;
  1056. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  1057. scmd->cdb_len = SC_G1_CDBLEN;
  1058. scmd->sense_len = CCS_SENSE_LEN;
  1059. scmd->target = scgp->target;
  1060. scmd->cdb.g1_cdb.cmd = 0xEE; /* Read session info */
  1061. scmd->cdb.g1_cdb.lun = scgp->lun;
  1062. g1_cdblen(&scmd->cdb.g1_cdb, sizeof(buf));
  1063. scgp->cmdname = "philips read session info";
  1064. if (scsicmd(scgp) < 0)
  1065. return (-1);
  1066. if (scgp->verbose)
  1067. scsiprbytes("Session info data: ", (u_char *)buf, sizeof(buf) - scsigetresid(scgp));
  1068. li = a_to_u_2_byte(buf);
  1069. lo = a_to_u_2_byte(&buf[2]);
  1070. if (lilenp)
  1071. *lilenp = li;
  1072. if (lolenp)
  1073. *lolenp = lo;
  1074. return (0);
  1075. }