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

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

SCSI/ASPI

开发平台：

MultiPlatform

scsi_cdr.c：源码内容
  1. /*
  2. XXX
  3. SIZEOF testen !!!
  4. */
  5. /* @(#)scsi_cdr.c 1.84 00/01/28 Copyright 1995 J. Schilling */
  6. #ifndef lint
  7. static char sccsid[] =
  8. "@(#)scsi_cdr.c 1.84 00/01/28 Copyright 1995 J. Schilling";
  9. #endif
  10. /*
  11.  * SCSI command functions for cdrecord
  12.  *
  13.  * Copyright (c) 1995 J. Schilling
  14.  */
  15. /*
  16.  * This program is free software; you can redistribute it and/or modify
  17.  * it under the terms of the GNU General Public License as published by
  18.  * the Free Software Foundation; either version 2, or (at your option)
  19.  * any later version.
  20.  *
  21.  * This program is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  * GNU General Public License for more details.
  25.  *
  26.  * You should have received a copy of the GNU General Public License
  27.  * along with this program; see the file COPYING.  If not, write to
  28.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  29.  */
  31. /*
  32.  * NOTICE: The Philips CDD 521 has several firmware bugs.
  33.  * One of them is not to respond to a SCSI selection
  34.  * within 200ms if the general load on the
  35.  * SCSI bus is high. To deal with this problem
  36.  * most of the SCSI commands are send with the
  37.  * SCG_CMD_RETRY flag enabled.
  38.  */
  39. #include <mconfig.h>
  41. #include <stdio.h>
  42. #include <standard.h>
  43. #include <stdxlib.h>
  44. #include <unixstd.h>
  45. #include <fctldefs.h>
  46. #include <errno.h>
  47. #include <strdefs.h>
  49. #include <utypes.h>
  50. #include <btorder.h>
  51. #include <intcvt.h>
  52. #include <scg/scgcmd.h>
  53. #include <scg/scsidefs.h>
  54. #include <scg/scsireg.h>
  55. #include <scg/scsitransp.h>
  57. #include "cdrecord.h"
  59. #define strbeg(s1,s2) (strstr((s2), (s1)) == (s2))
  61. EXPORT BOOL unit_ready __PR((SCSI *scgp));
  62. EXPORT BOOL wait_unit_ready __PR((SCSI *scgp, int secs));
  63. EXPORT int test_unit_ready __PR((SCSI *scgp));
  64. EXPORT int rezero_unit __PR((SCSI *scgp));
  65. EXPORT int request_sense __PR((SCSI *scgp));
  66. EXPORT int inquiry __PR((SCSI *scgp, caddr_t, int));
  67. EXPORT int read_capacity __PR((SCSI *scgp));
  68. EXPORT int scsi_load_unload __PR((SCSI *scgp, int));
  69. EXPORT int scsi_prevent_removal __PR((SCSI *scgp, int));
  70. EXPORT int scsi_start_stop_unit __PR((SCSI *scgp, int, int));
  71. EXPORT int scsi_set_speed __PR((SCSI *scgp, int readspeed, int writespeed));
  72. EXPORT int scsi_get_speed __PR((SCSI *scgp, int *readspeedp, int *writespeedp));
  73. EXPORT int qic02 __PR((SCSI *scgp, int));
  74. EXPORT int write_xg0 __PR((SCSI *scgp, caddr_t, long, long, int));
  75. EXPORT int write_xg1 __PR((SCSI *scgp, caddr_t, long, long, int));
  76. EXPORT int write_xg5 __PR((SCSI *scgp, caddr_t, long, long, int));
  77. EXPORT int scsi_flush_cache __PR((SCSI *scgp));
  78. EXPORT int read_buffer __PR((SCSI *scgp, caddr_t bp, int cnt, int mode));
  79. EXPORT int read_subchannel __PR((SCSI *scgp, caddr_t bp, int track,
  80. int cnt,int msf, int subq, int fmt));
  81. EXPORT int read_toc __PR((SCSI *scgp, caddr_t, int, int, int, int));
  82. EXPORT int read_toc_philips __PR((SCSI *scgp, caddr_t, int, int, int, int));
  83. EXPORT int read_header __PR((SCSI *scgp, caddr_t, long, int, int));
  84. EXPORT int read_disk_info __PR((SCSI *scgp, caddr_t, int));
  85. EXPORT int read_track_info __PR((SCSI *scgp, caddr_t, int, int));
  86. EXPORT int read_track_info_philips __PR((SCSI *scgp, caddr_t, int, int));
  87. EXPORT int scsi_close_tr_session __PR((SCSI *scgp, int type, int track));
  88. EXPORT int read_master_cue __PR((SCSI *scgp, caddr_t bp, int sheet, int cnt));
  89. EXPORT int send_cue_sheet __PR((SCSI *scgp, caddr_t bp, long size));
  90. EXPORT int read_buff_cap __PR((SCSI *scgp, long *, long *));
  91. EXPORT int scsi_blank __PR((SCSI *scgp, long addr, int blanktype));
  92. EXPORT BOOL allow_atapi __PR((SCSI *scgp, BOOL new));
  93. EXPORT int mode_select __PR((SCSI *scgp, Uchar *, int, int, int));
  94. EXPORT int mode_sense __PR((SCSI *scgp, Uchar *dp, int cnt, int page, int pcf));
  95. EXPORT int mode_select_sg0 __PR((SCSI *scgp, Uchar *, int, int, int));
  96. EXPORT int mode_sense_sg0 __PR((SCSI *scgp, Uchar *dp, int cnt, int page, int pcf));
  97. EXPORT int mode_select_g0 __PR((SCSI *scgp, Uchar *, int, int, int));
  98. EXPORT int mode_select_g1 __PR((SCSI *scgp, Uchar *, int, int, int));
  99. EXPORT int mode_sense_g0 __PR((SCSI *scgp, Uchar *dp, int cnt, int page, int pcf));
  100. EXPORT int mode_sense_g1 __PR((SCSI *scgp, Uchar *dp, int cnt, int page, int pcf));
  101. EXPORT int read_tochdr __PR((SCSI *scgp, cdr_t *, int *, int *));
  102. EXPORT int read_cdtext __PR((SCSI *scgp));
  103. EXPORT int read_trackinfo __PR((SCSI *scgp, int, long *, struct msf *, int *, int *, int *));
  104. EXPORT int read_B0 __PR((SCSI *scgp, BOOL isbcd, long *b0p, long *lop));
  105. EXPORT int read_session_offset __PR((SCSI *scgp, long *));
  106. EXPORT int read_session_offset_philips __PR((SCSI *scgp, long *));
  107. EXPORT int sense_secsize __PR((SCSI *scgp, int current));
  108. EXPORT int select_secsize __PR((SCSI *scgp, int));
  109. EXPORT BOOL is_cddrive __PR((SCSI *scgp));
  110. EXPORT BOOL is_unknown_dev __PR((SCSI *scgp));
  111. EXPORT int read_scsi __PR((SCSI *scgp, caddr_t, long, int));
  112. EXPORT int read_g0 __PR((SCSI *scgp, caddr_t, long, int));
  113. EXPORT int read_g1 __PR((SCSI *scgp, caddr_t, long, int));
  114. EXPORT BOOL getdev __PR((SCSI *scgp, BOOL));
  115. EXPORT void printdev __PR((SCSI *scgp));
  116. EXPORT BOOL do_inquiry __PR((SCSI *scgp, BOOL));
  117. EXPORT BOOL recovery_needed __PR((SCSI *scgp));
  118. EXPORT int scsi_load __PR((SCSI *scgp));
  119. EXPORT int scsi_unload __PR((SCSI *scgp));
  120. EXPORT int scsi_cdr_write __PR((SCSI *scgp, caddr_t bp, long sectaddr, long size, int blocks, BOOL islast));
  121. EXPORT struct cd_mode_page_2A * mmc_cap __PR((SCSI *scgp, Uchar *modep));
  122. EXPORT void mmc_getval __PR((struct cd_mode_page_2A *mp,
  123. BOOL *cdrrp, BOOL *cdwrp,
  124. BOOL *cdrrwp, BOOL *cdwrwp,
  125. BOOL *dvdp));
  126. EXPORT BOOL is_mmc __PR((SCSI *scgp, BOOL *dvdp));
  127. EXPORT BOOL mmc_check __PR((SCSI *scgp, BOOL *cdrrp, BOOL *cdwrp,
  128. BOOL *cdrrwp, BOOL *cdwrwp,
  129. BOOL *dvdp));
  130. EXPORT void print_capabilities __PR((SCSI *scgp));
  132. EXPORT BOOL
  133. unit_ready(scgp)
  134. SCSI *scgp;
  135. {
  136. register struct scg_cmd *scmd = scgp->scmd;
  138. if (test_unit_ready(scgp) >= 0) /* alles OK */
  139. return (TRUE);
  140. else if (scmd->error >= SCG_FATAL) /* nicht selektierbar */
  141. return (FALSE);
  143. if (scmd->sense.code < 0x70) { /* non extended Sense */
  144. if (scmd->sense.code == 0x04) /* NOT_READY */
  145. return (FALSE);
  146. return (TRUE);
  147. }
  148. if (((struct scsi_ext_sense *)&scmd->sense)->key == SC_UNIT_ATTENTION) {
  149. if (test_unit_ready(scgp) >= 0) /* alles OK */
  150. return (TRUE);
  151. }
  152. /* FALSE wenn NOT_READY */
  153. return (((struct scsi_ext_sense *)&scmd->sense)->key != SC_NOT_READY);
  154. }
  156. EXPORT BOOL
  157. wait_unit_ready(scgp, secs)
  158. SCSI *scgp;
  159. int secs;
  160. {
  161. int i;
  162. int c;
  163. int k;
  164. int ret;
  166. scgp->silent++;
  167. ret = test_unit_ready(scgp); /* eat up unit attention */
  168. if (ret < 0)
  169. ret = test_unit_ready(scgp); /* got power on condition? */
  170. scgp->silent--;
  172. if (ret >= 0) /* success that's enough */
  173. return (TRUE);
  175. scgp->silent++;
  176. for (i=0; i < secs && (ret = test_unit_ready(scgp)) < 0; i++) {
  177. if (scgp->scmd->scb.busy != 0) {
  178. sleep(1);
  179. continue;
  180. }
  181. c = scsi_sense_code(scgp);
  182. k = scsi_sense_key(scgp);
  183. if (k == SC_NOT_READY && (c == 0x3A || c == 0x30)) {
  184. if (scgp->silent <= 1)
  185. scsiprinterr(scgp);
  186. scgp->silent--;
  187. return (FALSE);
  188. }
  189. sleep(1);
  190. }
  191. scgp->silent--;
  192. if (ret < 0)
  193. return (FALSE);
  194. return (TRUE);
  195. }
  197. EXPORT int
  198. test_unit_ready(scgp)
  199. SCSI *scgp;
  200. {
  201. register struct scg_cmd *scmd = scgp->scmd;
  203. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  204. scmd->addr = (caddr_t)0;
  205. scmd->size = 0;
  206. scmd->flags = SCG_DISRE_ENA | (scgp->silent ? SCG_SILENT:0);
  207. scmd->cdb_len = SC_G0_CDBLEN;
  208. scmd->sense_len = CCS_SENSE_LEN;
  209. scmd->target = scgp->target;
  210. scmd->cdb.g0_cdb.cmd = SC_TEST_UNIT_READY;
  211. scmd->cdb.g0_cdb.lun = scgp->lun;
  213. scgp->cmdname = "test unit ready";
  215. return (scsicmd(scgp));
  216. }
  218. EXPORT int
  219. rezero_unit(scgp)
  220. SCSI *scgp;
  221. {
  222. register struct scg_cmd *scmd = scgp->scmd;
  224. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  225. scmd->addr = (caddr_t)0;
  226. scmd->size = 0;
  227. scmd->flags = SCG_DISRE_ENA;
  228. scmd->cdb_len = SC_G0_CDBLEN;
  229. scmd->sense_len = CCS_SENSE_LEN;
  230. scmd->target = scgp->target;
  231. scmd->cdb.g0_cdb.cmd = SC_REZERO_UNIT;
  232. scmd->cdb.g0_cdb.lun = scgp->lun;
  234. scgp->cmdname = "rezero unit";
  236. return (scsicmd(scgp));
  237. }
  239. EXPORT int
  240. request_sense(scgp)
  241. SCSI *scgp;
  242. {
  243.  char sensebuf[CCS_SENSE_LEN];
  244. register struct scg_cmd *scmd = scgp->scmd;
  247. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  248. scmd->addr = sensebuf;
  249. scmd->size = sizeof(sensebuf);;
  250. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  251. scmd->cdb_len = SC_G0_CDBLEN;
  252. scmd->sense_len = CCS_SENSE_LEN;
  253. scmd->target = scgp->target;
  254. scmd->cdb.g0_cdb.cmd = SC_REQUEST_SENSE;
  255. scmd->cdb.g0_cdb.lun = scgp->lun;
  256. scmd->cdb.g0_cdb.count = CCS_SENSE_LEN;
  258. scgp->cmdname = "request_sense";
  260. if (scsicmd(scgp) < 0)
  261. return (-1);
  262. scsiprsense((Uchar *)sensebuf, CCS_SENSE_LEN - scsigetresid(scgp));
  263. return (0);
  264. }
  266. EXPORT int
  267. inquiry(scgp, bp, cnt)
  268. SCSI *scgp;
  269. caddr_t bp;
  270. int cnt;
  271. {
  272. register struct scg_cmd *scmd = scgp->scmd;
  274. fillbytes(bp, cnt, '');
  275. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  276. scmd->addr = bp;
  277. scmd->size = cnt;
  278. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  279. scmd->cdb_len = SC_G0_CDBLEN;
  280. scmd->sense_len = CCS_SENSE_LEN;
  281. scmd->target = scgp->target;
  282. scmd->cdb.g0_cdb.cmd = SC_INQUIRY;
  283. scmd->cdb.g0_cdb.lun = scgp->lun;
  284. scmd->cdb.g0_cdb.count = cnt;
  286. scgp->cmdname = "inquiry";
  288. if (scsicmd(scgp) < 0)
  289. return (-1);
  290. if (scgp->verbose)
  291. scsiprbytes("Inquiry Data   :", (Uchar *)bp, cnt - scsigetresid(scgp));
  292. return (0);
  293. }
  295. EXPORT int
  296. read_capacity(scgp)
  297. SCSI *scgp;
  298. {
  299. register struct scg_cmd *scmd = scgp->scmd;
  301. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  302. scmd->addr = (caddr_t)scgp->cap;
  303. scmd->size = sizeof(struct scsi_capacity);
  304. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  305. scmd->cdb_len = SC_G1_CDBLEN;
  306. scmd->sense_len = CCS_SENSE_LEN;
  307. scmd->target = scgp->target;
  308. scmd->cdb.g1_cdb.cmd = 0x25; /* Read Capacity */
  309. scmd->cdb.g1_cdb.lun = scgp->lun;
  310. g1_cdblen(&scmd->cdb.g1_cdb, 0); /* Full Media */
  312. scgp->cmdname = "read capacity";
  314. if (scsicmd(scgp) < 0) {
  315. return (-1);
  316. } else {
  317. long kb;
  318. long mb;
  319. long prmb;
  320. double dkb;
  321. long cbsize;
  322. long cbaddr;
  324. /*
  325.  * c_bsize & c_baddr are signed Int32_t
  326.  * so we use signed int conversion here.
  327.  */
  328. cbsize = a_to_4_byte(&scgp->cap->c_bsize);
  329. cbaddr = a_to_4_byte(&scgp->cap->c_baddr);
  330. scgp->cap->c_bsize = cbsize;
  331. scgp->cap->c_baddr = cbaddr;
  333. if (scgp->silent)
  334. return (0);
  336. dkb =  (scgp->cap->c_baddr+1.0) * (scgp->cap->c_bsize/1024.0);
  337. kb = dkb;
  338. mb = dkb / 1024.0;
  339. prmb = dkb / 1000.0 * 1.024;
  340. printf("Capacity: %ld Blocks = %ld kBytes = %ld MBytes = %ld prMBn",
  341. (long)scgp->cap->c_baddr+1, kb, mb, prmb);
  342. printf("Sectorsize: %ld Bytesn", (long)scgp->cap->c_bsize);
  343. }
  344. return (0);
  345. }
  347. EXPORT int
  348. scsi_load_unload(scgp, load)
  349. SCSI *scgp;
  350. int load;
  351. {
  352. register struct scg_cmd *scmd = scgp->scmd;
  354. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  355. scmd->flags = SCG_DISRE_ENA;
  356. scmd->cdb_len = SC_G5_CDBLEN;
  357. scmd->sense_len = CCS_SENSE_LEN;
  358. scmd->target = scgp->target;
  359. scmd->cdb.g5_cdb.cmd = 0xA6;
  360. scmd->cdb.g5_cdb.lun = scgp->lun;
  361. scmd->cdb.g5_cdb.addr[1] = load?3:2;
  362. scmd->cdb.g5_cdb.count[2] = 0; /* slot # */
  364. scgp->cmdname = "medium load/unload";
  366. if (scsicmd(scgp) < 0)
  367. return (-1);
  368. return (0);
  369. }
  371. EXPORT int
  372. scsi_prevent_removal(scgp, prevent)
  373. SCSI *scgp;
  374. int prevent;
  375. {
  376. register struct scg_cmd *scmd = scgp->scmd;
  378. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  379. scmd->flags = SCG_DISRE_ENA;
  380. scmd->cdb_len = SC_G0_CDBLEN;
  381. scmd->sense_len = CCS_SENSE_LEN;
  382. scmd->target = scgp->target;
  383. scmd->cdb.g0_cdb.cmd = 0x1E;
  384. scmd->cdb.g0_cdb.lun = scgp->lun;
  385. scmd->cdb.g0_cdb.count = prevent & 1;
  387. scgp->cmdname = "prevent/allow medium removal";
  389. if (scsicmd(scgp) < 0)
  390. return (-1);
  391. return (0);
  392. }
  395. EXPORT int
  396. scsi_start_stop_unit(scgp, flg, loej)
  397. SCSI *scgp;
  398. int flg;
  399. int loej;
  400. {
  401. register struct scg_cmd *scmd = scgp->scmd;
  403. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  404. scmd->flags = SCG_DISRE_ENA;
  405. scmd->cdb_len = SC_G0_CDBLEN;
  406. scmd->sense_len = CCS_SENSE_LEN;
  407. scmd->target = scgp->target;
  408. scmd->cdb.g0_cdb.cmd = 0x1B; /* Start Stop Unit */
  409. scmd->cdb.g0_cdb.lun = scgp->lun;
  410. scmd->cdb.g0_cdb.count = (flg ? 1:0) | (loej ? 2:0);
  412. scgp->cmdname = "start/stop unit";
  414. return (scsicmd(scgp));
  415. }
  417. EXPORT int
  418. scsi_set_speed(scgp, readspeed, writespeed)
  419. SCSI *scgp;
  420. int readspeed;
  421. int writespeed;
  422. {
  423. register struct scg_cmd *scmd = scgp->scmd;
  425. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  426. scmd->flags = SCG_DISRE_ENA;
  427. scmd->cdb_len = SC_G5_CDBLEN;
  428. scmd->sense_len = CCS_SENSE_LEN;
  429. scmd->target = scgp->target;
  430. scmd->cdb.g5_cdb.cmd = 0xBB;
  431. scmd->cdb.g5_cdb.lun = scgp->lun;
  432. i_to_2_byte(&scmd->cdb.g5_cdb.addr[0], readspeed);
  433. i_to_2_byte(&scmd->cdb.g5_cdb.addr[2], writespeed);
  435. scgp->cmdname = "set cd speed";
  437. if (scsicmd(scgp) < 0)
  438. return (-1);
  439. return (0);
  440. }
  442. EXPORT int
  443. scsi_get_speed(scgp, readspeedp, writespeedp)
  444. SCSI *scgp;
  445. int *readspeedp;
  446. int *writespeedp;
  447. {
  448. struct cd_mode_page_2A *mp;
  449. Uchar m[256];
  450. int val;
  452. scgp->silent++;
  453. mp = mmc_cap(scgp, m);/* Get MMC capabilities in allocated mp */
  454. scgp->silent--;
  455. if (mp == NULL)
  456. return (-1); /* Pre SCSI-3/mmc drive   */
  458. val = a_to_u_2_byte(mp->cur_read_speed);
  459. if (readspeedp)
  460. *writespeedp = val;
  462. val = a_to_u_2_byte(mp->cur_write_speed);
  463. if (writespeedp)
  464. *writespeedp = val;
  466. return (0);
  467. }
  470. EXPORT int
  471. qic02(scgp, cmd)
  472. SCSI *scgp;
  473. int cmd;
  474. {
  475. register struct scg_cmd *scmd = scgp->scmd;
  477. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  478. scmd->addr = (caddr_t)0;
  479. scmd->size = 0;
  480. scmd->flags = SCG_DISRE_ENA;
  481. scmd->cdb_len = SC_G0_CDBLEN;
  482. scmd->sense_len = DEF_SENSE_LEN;
  483. scmd->target = scgp->target;
  484. scmd->cdb.g0_cdb.cmd = 0x0D; /* qic02 Sysgen SC4000 */
  485. scmd->cdb.g0_cdb.lun = scgp->lun;
  486. scmd->cdb.g0_cdb.mid_addr = cmd;
  488. scgp->cmdname = "qic 02";
  489. return (scsicmd(scgp));
  490. }
  492. EXPORT int
  493. write_xg0(scgp, bp, addr, size, cnt)
  494. SCSI *scgp;
  495. caddr_t bp; /* address of buffer */
  496. long addr; /* disk address (sector) to put */
  497. long size; /* number of bytes to transfer */
  498. int cnt; /* sectorcount */
  499. {
  500. register struct scg_cmd *scmd = scgp->scmd;
  502. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  503. scmd->addr = bp;
  504. scmd->size = size;
  505. scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
  506. /* scmd->flags = SCG_DISRE_ENA;*/
  507. scmd->cdb_len = SC_G0_CDBLEN;
  508. scmd->sense_len = CCS_SENSE_LEN;
  509. scmd->target = scgp->target;
  510. scmd->cdb.g0_cdb.cmd = SC_WRITE;
  511. scmd->cdb.g0_cdb.lun = scgp->lun;
  512. g0_cdbaddr(&scmd->cdb.g0_cdb, addr);
  513. scmd->cdb.g0_cdb.count = cnt;
  515. scgp->cmdname = "write_g0";
  517. if (scsicmd(scgp) < 0)
  518. return (-1);
  519. return (size - scsigetresid(scgp));
  520. }
  522. EXPORT int
  523. write_xg1(scgp, bp, addr, size, cnt)
  524. SCSI *scgp;
  525. caddr_t bp; /* address of buffer */
  526. long addr; /* disk address (sector) to put */
  527. long size; /* number of bytes to transfer */
  528. int cnt; /* sectorcount */
  529. {
  530. register struct scg_cmd *scmd = scgp->scmd;
  532. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  533. scmd->addr = bp;
  534. scmd->size = size;
  535. scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
  536. /* scmd->flags = SCG_DISRE_ENA;*/
  537. scmd->cdb_len = SC_G1_CDBLEN;
  538. scmd->sense_len = CCS_SENSE_LEN;
  539. scmd->target = scgp->target;
  540. scmd->cdb.g1_cdb.cmd = SC_EWRITE;
  541. scmd->cdb.g1_cdb.lun = scgp->lun;
  542. g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
  543. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  545. scgp->cmdname = "write_g1";
  547. if (scsicmd(scgp) < 0)
  548. return (-1);
  549. return (size - scsigetresid(scgp));
  550. }
  552. EXPORT int
  553. write_xg5(scgp, bp, addr, size, cnt)
  554. SCSI *scgp;
  555. caddr_t bp; /* address of buffer */
  556. long addr; /* disk address (sector) to put */
  557. long size; /* number of bytes to transfer */
  558. int cnt; /* sectorcount */
  559. {
  560. register struct scg_cmd *scmd = scgp->scmd;
  562. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  563. scmd->addr = bp;
  564. scmd->size = size;
  565. scmd->flags = SCG_DISRE_ENA|SCG_CMD_RETRY;
  566. /* scmd->flags = SCG_DISRE_ENA;*/
  567. scmd->cdb_len = SC_G5_CDBLEN;
  568. scmd->sense_len = CCS_SENSE_LEN;
  569. scmd->target = scgp->target;
  570. scmd->cdb.g5_cdb.cmd = 0xAA;
  571. scmd->cdb.g5_cdb.lun = scgp->lun;
  572. g5_cdbaddr(&scmd->cdb.g5_cdb, addr);
  573. g5_cdblen(&scmd->cdb.g5_cdb, cnt);
  575. scgp->cmdname = "write_g5";
  577. if (scsicmd(scgp) < 0)
  578. return (-1);
  579. return (size - scsigetresid(scgp));
  580. }
  582. EXPORT int
  583. scsi_flush_cache(scgp)
  584. SCSI *scgp;
  585. {
  586. register struct scg_cmd *scmd = scgp->scmd;
  588. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  589. scmd->flags = SCG_DISRE_ENA;
  590. scmd->cdb_len = SC_G1_CDBLEN;
  591. scmd->sense_len = CCS_SENSE_LEN;
  592. scmd->target = scgp->target;
  593. scmd->timeout = 2 * 60; /* Max: sizeof(CDR-cache)/150KB/s */
  594. scmd->cdb.g1_cdb.cmd = 0x35;
  595. scmd->cdb.g1_cdb.lun = scgp->lun;
  597. scgp->cmdname = "flush cache";
  599. if (scsicmd(scgp) < 0)
  600. return (-1);
  601. return (0);
  602. }
  604. EXPORT int
  605. read_buffer(scgp, bp, cnt, mode)
  606. SCSI *scgp;
  607. caddr_t bp;
  608. int cnt;
  609. int mode;
  610. {
  611. register struct scg_cmd *scmd = scgp->scmd;
  613. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  614. scmd->addr = bp;
  615. scmd->size = cnt;
  616. scmd->dma_read = 1;
  617. scmd->cdb_len = SC_G1_CDBLEN;
  618. scmd->sense_len = CCS_SENSE_LEN;
  619. scmd->target = scgp->target;
  620. scmd->cdb.g1_cdb.cmd = 0x3C; /* Read Buffer */
  621. scmd->cdb.g1_cdb.lun = scgp->lun;
  622. scmd->cdb.cmd_cdb[1] |= (mode & 7);
  623. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  625. scgp->cmdname = "read buffer";
  627. return (scsicmd(scgp));
  628. }
  630. EXPORT int
  631. read_subchannel(scgp, bp, track, cnt, msf, subq, fmt)
  632. SCSI *scgp;
  633. caddr_t bp;
  634. int track;
  635. int cnt;
  636. int msf;
  637. int subq;
  638. int fmt;
  640. {
  641. register struct scg_cmd *scmd = scgp->scmd;
  643. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  644. scmd->addr = bp;
  645. scmd->size = cnt;
  646. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  647. scmd->cdb_len = SC_G1_CDBLEN;
  648. scmd->sense_len = CCS_SENSE_LEN;
  649. scmd->target = scgp->target;
  650. scmd->cdb.g1_cdb.cmd = 0x42;
  651. scmd->cdb.g1_cdb.lun = scgp->lun;
  652. if (msf)
  653. scmd->cdb.g1_cdb.res = 1;
  654. if (subq)
  655. scmd->cdb.g1_cdb.addr[0] = 0x40;
  656. scmd->cdb.g1_cdb.addr[1] = fmt;
  657. scmd->cdb.g1_cdb.res6 = track;
  658. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  660. scgp->cmdname = "read subchannel";
  662. if (scsicmd(scgp) < 0)
  663. return (-1);
  664. return (0);
  665. }
  667. EXPORT int
  668. read_toc(scgp, bp, track, cnt, msf, fmt)
  669. SCSI *scgp;
  670. caddr_t bp;
  671. int track;
  672. int cnt;
  673. int msf;
  674. int fmt;
  676. {
  677. register struct scg_cmd *scmd = scgp->scmd;
  679. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  680. scmd->addr = bp;
  681. scmd->size = cnt;
  682. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  683. scmd->cdb_len = SC_G1_CDBLEN;
  684. scmd->sense_len = CCS_SENSE_LEN;
  685. scmd->target = scgp->target;
  686. scmd->cdb.g1_cdb.cmd = 0x43;
  687. scmd->cdb.g1_cdb.lun = scgp->lun;
  688. if (msf)
  689. scmd->cdb.g1_cdb.res = 1;
  690. scmd->cdb.g1_cdb.addr[0] = fmt & 0x0F;
  691. scmd->cdb.g1_cdb.res6 = track;
  692. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  694. scgp->cmdname = "read toc";
  696. if (scsicmd(scgp) < 0)
  697. return (-1);
  698. return (0);
  699. }
  701. EXPORT int
  702. read_toc_philips(scgp, bp, track, cnt, msf, fmt)
  703. SCSI *scgp;
  704. caddr_t bp;
  705. int track;
  706. int cnt;
  707. int msf;
  708. int fmt;
  710. {
  711. register struct scg_cmd *scmd = scgp->scmd;
  713. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  714. scmd->addr = bp;
  715. scmd->size = cnt;
  716. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  717. scmd->cdb_len = SC_G1_CDBLEN;
  718. scmd->sense_len = CCS_SENSE_LEN;
  719. scmd->target = scgp->target;
  720. scmd->timeout = 4 * 60; /* May last  174s on a TEAC CD-R55S */
  721. scmd->cdb.g1_cdb.cmd = 0x43;
  722. scmd->cdb.g1_cdb.lun = scgp->lun;
  723. if (msf)
  724. scmd->cdb.g1_cdb.res = 1;
  725. scmd->cdb.g1_cdb.res6 = track;
  726. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  728. if (fmt & 1)
  729. scmd->cdb.g1_cdb.vu_96 = 1;
  730. if (fmt & 2)
  731. scmd->cdb.g1_cdb.vu_97 = 1;
  733. scgp->cmdname = "read toc";
  735. if (scsicmd(scgp) < 0)
  736. return (-1);
  737. return (0);
  738. }
  740. EXPORT int
  741. read_header(scgp, bp, addr, cnt, msf)
  742. SCSI *scgp;
  743. caddr_t bp;
  744. long addr;
  745. int cnt;
  746. int msf;
  747. {
  748. register struct scg_cmd *scmd = scgp->scmd;
  750. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  751. scmd->addr = bp;
  752. scmd->size = cnt;
  753. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  754. scmd->cdb_len = SC_G1_CDBLEN;
  755. scmd->sense_len = CCS_SENSE_LEN;
  756. scmd->target = scgp->target;
  757. scmd->cdb.g1_cdb.cmd = 0x44;
  758. scmd->cdb.g1_cdb.lun = scgp->lun;
  759. if (msf)
  760. scmd->cdb.g1_cdb.res = 1;
  761. g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
  762. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  764. scgp->cmdname = "read header";
  766. if (scsicmd(scgp) < 0)
  767. return (-1);
  768. return (0);
  769. }
  771. EXPORT int
  772. read_disk_info(scgp, bp, cnt)
  773. SCSI *scgp;
  774. caddr_t bp;
  775. int cnt;
  777. {
  778. register struct scg_cmd *scmd = scgp->scmd;
  780. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  781. scmd->addr = bp;
  782. scmd->size = cnt;
  783. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  784. scmd->cdb_len = SC_G1_CDBLEN;
  785. scmd->sense_len = CCS_SENSE_LEN;
  786. scmd->target = scgp->target;
  787. scmd->timeout = 4 * 60; /* Needs up to 2 minutes */
  788. scmd->cdb.g1_cdb.cmd = 0x51;
  789. scmd->cdb.g1_cdb.lun = scgp->lun;
  790. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  792. scgp->cmdname = "read disk info";
  794. if (scsicmd(scgp) < 0)
  795. return (-1);
  796. return (0);
  797. }
  799. EXPORT int
  800. read_track_info(scgp, bp, track, cnt)
  801. SCSI *scgp;
  802. caddr_t bp;
  803. int track;
  804. int cnt;
  806. {
  807. register struct scg_cmd *scmd = scgp->scmd;
  809. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  810. scmd->addr = bp;
  811. scmd->size = cnt;
  812. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  813. scmd->cdb_len = SC_G1_CDBLEN;
  814. scmd->sense_len = CCS_SENSE_LEN;
  815. scmd->target = scgp->target;
  816. scmd->timeout = 4 * 60; /* Needs up to 2 minutes */
  817. scmd->cdb.g1_cdb.cmd = 0x52;
  818. scmd->cdb.g1_cdb.lun = scgp->lun;
  819. scmd->cdb.g1_cdb.reladr = 1; /* Track */
  820. g1_cdbaddr(&scmd->cdb.g1_cdb, track);
  821. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  823. scgp->cmdname = "read track info";
  825. if (scsicmd(scgp) < 0)
  826. return (-1);
  827. return (0);
  828. }
  830. EXPORT int
  831. read_track_info_philips(scgp, bp, track, cnt)
  832. SCSI *scgp;
  833. caddr_t bp;
  834. int track;
  835. int cnt;
  837. {
  838. register struct scg_cmd *scmd = scgp->scmd;
  840. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  841. scmd->addr = bp;
  842. scmd->size = cnt;
  843. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  844. scmd->cdb_len = SC_G1_CDBLEN;
  845. scmd->sense_len = CCS_SENSE_LEN;
  846. scmd->target = scgp->target;
  847. scmd->cdb.g1_cdb.cmd = 0xE5;
  848. scmd->cdb.g1_cdb.lun = scgp->lun;
  849. g1_cdbaddr(&scmd->cdb.g1_cdb, track);
  850. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  852. scgp->cmdname = "read track info";
  854. if (scsicmd(scgp) < 0)
  855. return (-1);
  856. return (0);
  857. }
  859. EXPORT int
  860. scsi_close_tr_session(scgp, type, track)
  861. SCSI *scgp;
  862. int type;
  863. int track;
  864. {
  865. register struct scg_cmd *scmd = scgp->scmd;
  867. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  868. scmd->flags = SCG_DISRE_ENA;
  869. scmd->cdb_len = SC_G1_CDBLEN;
  870. scmd->sense_len = CCS_SENSE_LEN;
  871. scmd->target = scgp->target;
  872. scmd->timeout = 8 * 60; /* Needs up to 4 minutes */
  873. scmd->cdb.g1_cdb.cmd = 0x5B;
  874. scmd->cdb.g1_cdb.lun = scgp->lun;
  875. scmd->cdb.g1_cdb.addr[0] = type;
  876. scmd->cdb.g1_cdb.addr[3] = track;
  878. #ifdef nono
  879. scmd->cdb.g1_cdb.reladr = 1; /* IMM hack to test Mitsumi behaviour*/
  880. #endif
  882. scgp->cmdname = "close track/session";
  884. if (scsicmd(scgp) < 0)
  885. return (-1);
  886. return (0);
  887. }
  889. EXPORT int
  890. read_master_cue(scgp, bp, sheet, cnt)
  891. SCSI *scgp;
  892. caddr_t bp; /* address of master cue sheet */
  893. int sheet; /* Sheet number */
  894. int cnt; /* Transfer count */
  895. {
  896. register struct scg_cmd *scmd = scgp->scmd;
  898. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  899. scmd->addr = bp;
  900. scmd->size = cnt;
  901. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  902. scmd->cdb_len = SC_G1_CDBLEN;
  903. scmd->sense_len = CCS_SENSE_LEN;
  904. scmd->target = scgp->target;
  905. scmd->cdb.g1_cdb.cmd = 0x59; /* Read master cue */
  906. scmd->cdb.g1_cdb.lun = scgp->lun;
  907. scmd->cdb.g1_cdb.addr[2] = sheet;
  908. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  910. scgp->cmdname = "read master cue";
  912. if (scsicmd(scgp) < 0)
  913. return (-1);
  914. return (0);
  915. }
  917. EXPORT int
  918. send_cue_sheet(scgp, bp, size)
  919. SCSI *scgp;
  920. caddr_t bp; /* address of cue sheet buffer */
  921. long size; /* number of bytes to transfer */
  922. {
  923. register struct scg_cmd *scmd = scgp->scmd;
  925. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  926. scmd->addr = bp;
  927. scmd->size = size;
  928. scmd->flags = SCG_DISRE_ENA;
  929. scmd->cdb_len = SC_G1_CDBLEN;
  930. scmd->sense_len = CCS_SENSE_LEN;
  931. scmd->target = scgp->target;
  932. scmd->cdb.g1_cdb.cmd = 0x5D; /* Send CUE sheet */
  933. scmd->cdb.g1_cdb.lun = scgp->lun;
  934. g1_cdblen(&scmd->cdb.g1_cdb, size); 
  936. scgp->cmdname = "send_cue_sheet";
  938. if (scsicmd(scgp) < 0)
  939. return (-1);
  940. return (size - scmd->resid);
  941. }
  943. EXPORT int
  944. read_buff_cap(scgp, sp, fp)
  945. SCSI *scgp;
  946. long *sp; /* Size pointer */
  947. long *fp; /* Free pointer */
  948. {
  949. char resp[12];
  950. Ulong freespace;
  951. Ulong bufsize;
  952. int per;
  953. register struct scg_cmd *scmd = scgp->scmd;
  955. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  956. scmd->addr = (caddr_t)resp;
  957. scmd->size = sizeof(resp);
  958. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  959. scmd->cdb_len = SC_G1_CDBLEN;
  960. scmd->sense_len = CCS_SENSE_LEN;
  961. scmd->target = scgp->target;
  962. scmd->cdb.g1_cdb.cmd = 0x5C; /* Read buffer cap */
  963. scmd->cdb.g1_cdb.lun = scgp->lun;
  964. g1_cdblen(&scmd->cdb.g1_cdb, sizeof(resp));
  966. scgp->cmdname = "read buffer cap";
  968. if (scsicmd(scgp) < 0)
  969. return (-1);
  971. bufsize   = a_to_u_4_byte(&resp[4]);
  972. freespace = a_to_u_4_byte(&resp[8]);
  973. if (sp)
  974. *sp = bufsize;
  975. if (fp)
  976. *fp = freespace;
  978. if (scgp->verbose || (sp == 0 && fp == 0))
  979. printf("BFree: %ld K BSize: %ld Kn", freespace >> 10, bufsize >> 10);
  981. if (bufsize == 0)
  982. return (0);
  983. per = (100 * (bufsize - freespace)) / bufsize;
  984. if (per < 0)
  985. return (0);
  986. if (per > 100)
  987. return (100);
  988. return (per);
  989. }
  991. EXPORT int
  992. scsi_blank(scgp, addr, blanktype)
  993. SCSI *scgp;
  994. long addr;
  995. int blanktype;
  996. {
  997. register struct scg_cmd *scmd = scgp->scmd;
  999. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1000. scmd->flags = SCG_DISRE_ENA;
  1001. scmd->cdb_len = SC_G5_CDBLEN;
  1002. scmd->sense_len = CCS_SENSE_LEN;
  1003. scmd->target = scgp->target;
  1004. scmd->timeout = 160 * 60; /* full blank at 1x could take 80 minutes */
  1005. scmd->cdb.g5_cdb.cmd = 0xA1; /* Blank */
  1006. scmd->cdb.g0_cdb.high_addr = blanktype;
  1007. g1_cdbaddr(&scmd->cdb.g5_cdb, addr);
  1009. scgp->cmdname = "blank unit";
  1011. return (scsicmd(scgp));
  1012. }
  1014. /*
  1015.  * XXX First try to handle ATAPI:
  1016.  * XXX ATAPI cannot handle SCSI 6 byte commands.
  1017.  * XXX We try to simulate 6 byte mode sense/select.
  1018.  */
  1019. LOCAL BOOL is_atapi;
  1021. EXPORT BOOL
  1022. allow_atapi(scgp, new)
  1023. SCSI *scgp;
  1024. BOOL new;
  1025. {
  1026. BOOL old = is_atapi;
  1027. Uchar mode[256];
  1029. if (new == old)
  1030. return (old);
  1032. scgp->silent++;
  1033. if (new &&
  1034.     mode_sense_g1(scgp, mode, 8, 0x3F, 0) < 0) { /* All pages current */
  1035. new = FALSE;
  1036. }
  1037. scgp->silent--;
  1039. is_atapi = new;
  1040. return (old);
  1041. }
  1043. EXPORT int
  1044. mode_select(scgp, dp, cnt, smp, pf)
  1045. SCSI *scgp;
  1046. Uchar *dp;
  1047. int cnt;
  1048. int smp;
  1049. int pf;
  1050. {
  1051. if (is_atapi)
  1052. return (mode_select_sg0(scgp, dp, cnt, smp, pf));
  1053. return (mode_select_g0(scgp, dp, cnt, smp, pf));
  1054. }
  1056. EXPORT int
  1057. mode_sense(scgp, dp, cnt, page, pcf)
  1058. SCSI *scgp;
  1059. Uchar *dp;
  1060. int cnt;
  1061. int page;
  1062. int pcf;
  1063. {
  1064. if (is_atapi)
  1065. return (mode_sense_sg0(scgp, dp, cnt, page, pcf));
  1066. return (mode_sense_g0(scgp, dp, cnt, page, pcf));
  1067. }
  1069. /*
  1070.  * Simulate mode select g0 with mode select g1.
  1071.  */
  1072. EXPORT int
  1073. mode_select_sg0(scgp, dp, cnt, smp, pf)
  1074. SCSI *scgp;
  1075. Uchar *dp;
  1076. int cnt;
  1077. int smp;
  1078. int pf;
  1079. {
  1080. Uchar xmode[256+4];
  1081. int amt = cnt;
  1083. if (amt < 1 || amt > 255) {
  1084. /* XXX clear SCSI error codes ??? */
  1085. return (-1);
  1086. }
  1088. if (amt < 4) { /* Data length. medium type & VU */
  1089. amt += 1;
  1090. } else {
  1091. amt += 4;
  1092. movebytes(&dp[4], &xmode[8], cnt-4);
  1093. }
  1094. xmode[0] = 0;
  1095. xmode[1] = 0;
  1096. xmode[2] = dp[1];
  1097. xmode[3] = dp[2];
  1098. xmode[4] = 0;
  1099. xmode[5] = 0;
  1100. i_to_2_byte(&xmode[6], (unsigned int)dp[3]);
  1102. if (scgp->verbose) scsiprbytes("Mode Parameters (un-converted)", dp, cnt);
  1104. return (mode_select_g1(scgp, xmode, amt, smp, pf));
  1105. }
  1107. /*
  1108.  * Simulate mode sense g0 with mode sense g1.
  1109.  */
  1110. EXPORT int
  1111. mode_sense_sg0(scgp, dp, cnt, page, pcf)
  1112. SCSI *scgp;
  1113. Uchar *dp;
  1114. int cnt;
  1115. int page;
  1116. int pcf;
  1117. {
  1118. Uchar xmode[256+4];
  1119. int amt = cnt;
  1120. int len;
  1122. if (amt < 1 || amt > 255) {
  1123. /* XXX clear SCSI error codes ??? */
  1124. return (-1);
  1125. }
  1127. fillbytes((caddr_t)xmode, sizeof(xmode), '');
  1128. if (amt < 4) { /* Data length. medium type & VU */
  1129. amt += 1;
  1130. } else {
  1131. amt += 4;
  1132. }
  1133. if (mode_sense_g1(scgp, xmode, amt, page, pcf) < 0)
  1134. return (-1);
  1136. amt = cnt - scsigetresid(scgp);
  1137. if (amt > 4)
  1138. movebytes(&xmode[8], &dp[4], amt-4);
  1139. len = a_to_u_2_byte(xmode);
  1140. if (len == 0) {
  1141. dp[0] = 0;
  1142. } else if (len < 6) {
  1143. if (len > 2)
  1144. len = 2;
  1145. dp[0] = len;
  1146. } else {
  1147. dp[0] = len - 3;
  1148. }
  1149. dp[1] = xmode[2];
  1150. dp[2] = xmode[3];
  1151. len = a_to_u_2_byte(&xmode[6]);
  1152. dp[3] = len;
  1154. if (scgp->verbose) scsiprbytes("Mode Sense Data (converted)", dp, amt);
  1155. return (0);
  1156. }
  1158. EXPORT int
  1159. mode_select_g0(scgp, dp, cnt, smp, pf)
  1160. SCSI *scgp;
  1161. Uchar *dp;
  1162. int cnt;
  1163. int smp;
  1164. int pf;
  1165. {
  1166. register struct scg_cmd *scmd = scgp->scmd;
  1168. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1169. scmd->addr = (caddr_t)dp;
  1170. scmd->size = cnt;
  1171. scmd->flags = SCG_DISRE_ENA;
  1172. scmd->cdb_len = SC_G0_CDBLEN;
  1173. scmd->sense_len = CCS_SENSE_LEN;
  1174. scmd->target = scgp->target;
  1175. scmd->cdb.g0_cdb.cmd = SC_MODE_SELECT;
  1176. scmd->cdb.g0_cdb.lun = scgp->lun;
  1177. scmd->cdb.g0_cdb.high_addr = smp ? 1 : 0 | pf ? 0x10 : 0;
  1178. scmd->cdb.g0_cdb.count = cnt;
  1180. if (scgp->verbose) {
  1181. printf("%s ", smp?"Save":"Set ");
  1182. scsiprbytes("Mode Parameters", dp, cnt);
  1183. }
  1185. scgp->cmdname = "mode select g0";
  1187. return (scsicmd(scgp));
  1188. }
  1190. EXPORT int
  1191. mode_select_g1(scgp, dp, cnt, smp, pf)
  1192. SCSI *scgp;
  1193. Uchar *dp;
  1194. int cnt;
  1195. int smp;
  1196. int pf;
  1197. {
  1198. register struct scg_cmd *scmd = scgp->scmd;
  1200. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1201. scmd->addr = (caddr_t)dp;
  1202. scmd->size = cnt;
  1203. scmd->flags = SCG_DISRE_ENA;
  1204. scmd->cdb_len = SC_G1_CDBLEN;
  1205. scmd->sense_len = CCS_SENSE_LEN;
  1206. scmd->target = scgp->target;
  1207. scmd->cdb.g1_cdb.cmd = 0x55;
  1208. scmd->cdb.g1_cdb.lun = scgp->lun;
  1209. scmd->cdb.g0_cdb.high_addr = smp ? 1 : 0 | pf ? 0x10 : 0;
  1210. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  1212. if (scgp->verbose) {
  1213. printf("%s ", smp?"Save":"Set ");
  1214. scsiprbytes("Mode Parameters", dp, cnt);
  1215. }
  1217. scgp->cmdname = "mode select g1";
  1219. return (scsicmd(scgp));
  1220. }
  1222. EXPORT int
  1223. mode_sense_g0(scgp, dp, cnt, page, pcf)
  1224. SCSI *scgp;
  1225. Uchar *dp;
  1226. int cnt;
  1227. int page;
  1228. int pcf;
  1229. {
  1230. register struct scg_cmd *scmd = scgp->scmd;
  1232. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1233. scmd->addr = (caddr_t)dp;
  1234. scmd->size = 0xFF;
  1235. scmd->size = cnt;
  1236. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  1237. scmd->cdb_len = SC_G0_CDBLEN;
  1238. scmd->sense_len = CCS_SENSE_LEN;
  1239. scmd->target = scgp->target;
  1240. scmd->cdb.g0_cdb.cmd = SC_MODE_SENSE;
  1241. scmd->cdb.g0_cdb.lun = scgp->lun;
  1242. #ifdef nonono
  1243. scmd->cdb.g0_cdb.high_addr = 1<<4; /* DBD Disable Block desc. */
  1244. #endif
  1245. scmd->cdb.g0_cdb.mid_addr = (page&0x3F) | ((pcf<<6)&0xC0);
  1246. scmd->cdb.g0_cdb.count = page ? 0xFF : 24;
  1247. scmd->cdb.g0_cdb.count = cnt;
  1249. scgp->cmdname = "mode sense g0";
  1251. if (scsicmd(scgp) < 0)
  1252. return (-1);
  1253. if (scgp->verbose) scsiprbytes("Mode Sense Data", dp, cnt - scsigetresid(scgp));
  1254. return (0);
  1255. }
  1257. EXPORT int
  1258. mode_sense_g1(scgp, dp, cnt, page, pcf)
  1259. SCSI *scgp;
  1260. Uchar *dp;
  1261. int cnt;
  1262. int page;
  1263. int pcf;
  1264. {
  1265. register struct scg_cmd *scmd = scgp->scmd;
  1267. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1268. scmd->addr = (caddr_t)dp;
  1269. scmd->size = cnt;
  1270. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  1271. scmd->cdb_len = SC_G1_CDBLEN;
  1272. scmd->sense_len = CCS_SENSE_LEN;
  1273. scmd->target = scgp->target;
  1274. scmd->cdb.g1_cdb.cmd = 0x5A;
  1275. scmd->cdb.g1_cdb.lun = scgp->lun;
  1276. #ifdef nonono
  1277. scmd->cdb.g0_cdb.high_addr = 1<<4; /* DBD Disable Block desc. */
  1278. #endif
  1279. scmd->cdb.g1_cdb.addr[0] = (page&0x3F) | ((pcf<<6)&0xC0);
  1280. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  1282. scgp->cmdname = "mode sense g1";
  1284. if (scsicmd(scgp) < 0)
  1285. return (-1);
  1286. if (scgp->verbose) scsiprbytes("Mode Sense Data", dp, cnt - scsigetresid(scgp));
  1287. return (0);
  1288. }
  1290. struct tocheader {
  1291. Uchar len[2];
  1292. Uchar first;
  1293. Uchar last;
  1294. };
  1296. struct trackdesc {
  1297. Uchar res0;
  1299. #if defined(_BIT_FIELDS_LTOH) /* Intel byteorder */
  1300. Ucbit control : 4;
  1301. Ucbit adr : 4;
  1302. #else /* Motorola byteorder */
  1303. Ucbit adr : 4;
  1304. Ucbit control : 4;
  1305. #endif
  1307. Uchar track;
  1308. Uchar res3;
  1309. Uchar addr[4];
  1310. };
  1312. struct diskinfo {
  1313. struct tocheader hd;
  1314. struct trackdesc desc[1];
  1315. };
  1317. struct siheader {
  1318. Uchar len[2];
  1319. Uchar finished;
  1320. Uchar unfinished;
  1321. };
  1323. struct sidesc {
  1324. Uchar sess_number;
  1325. Uchar res1;
  1326. Uchar track;
  1327. Uchar res3;
  1328. Uchar addr[4];
  1329. };
  1331. struct sinfo {
  1332. struct siheader hd;
  1333. struct sidesc desc[1];
  1334. };
  1336. struct trackheader {
  1337. Uchar mode;
  1338. Uchar res[3];
  1339. Uchar addr[4];
  1340. };
  1341. #define TRM_ZERO 0
  1342. #define TRM_USER_ECC 1 /* 2048 bytes user data + 288 Bytes ECC/EDC */
  1343. #define TRM_USER 2 /* All user data (2336 bytes) */
  1345. struct ftrackdesc {
  1346. Uchar sess_number;
  1348. #if defined(_BIT_FIELDS_LTOH) /* Intel byteorder */
  1349. Ucbit control : 4;
  1350. Ucbit adr : 4;
  1351. #else /* Motorola byteorder */
  1352. Ucbit adr : 4;
  1353. Ucbit control : 4;
  1354. #endif
  1356. Uchar track;
  1357. Uchar point;
  1358. Uchar amin;
  1359. Uchar asec;
  1360. Uchar aframe;
  1361. Uchar res7;
  1362. Uchar pmin;
  1363. Uchar psec;
  1364. Uchar pframe;
  1365. };
  1367. struct fdiskinfo {
  1368. struct tocheader hd;
  1369. struct ftrackdesc desc[1];
  1370. };
  1373. EXPORT int
  1374. read_tochdr(scgp, dp, fp, lp)
  1375. SCSI *scgp;
  1376. cdr_t *dp;
  1377. int *fp;
  1378. int *lp;
  1379. {
  1380. struct tocheader *tp;
  1381. char xb[256];
  1382. int len;
  1384. tp = (struct tocheader *)xb;
  1386. fillbytes((caddr_t)xb, sizeof(xb), '');
  1387. if (read_toc(scgp, xb, 0, sizeof(struct tocheader), 0, FMT_TOC) < 0) {
  1388. if (scgp->silent == 0)
  1389. errmsgno(EX_BAD, "Cannot read TOC headern");
  1390. return (-1);
  1391. }
  1392. len = a_to_u_2_byte(tp->len) + sizeof(struct tocheader)-2;
  1393. if (len >= 4) {
  1394. if (fp)
  1395. *fp = tp->first;
  1396. if (lp)
  1397. *lp = tp->last;
  1398. return (0);
  1399. }
  1400. return (-1);
  1401. }
  1403. EXPORT int
  1404. read_cdtext(scgp)
  1405. SCSI *scgp;
  1406. {
  1407. struct tocheader *tp;
  1408. char xb[256];
  1409. int len;
  1410. char xxb[10000];
  1412. tp = (struct tocheader *)xb;
  1414. fillbytes((caddr_t)xb, sizeof(xb), '');
  1415. if (read_toc(scgp, xb, 0, sizeof(struct tocheader), 0, FMT_CDTEXT) < 0) {
  1416. if (scgp->silent == 0 || scgp->verbose > 0)
  1417. errmsgno(EX_BAD, "Cannot read CD-Text headern");
  1418. return (-1);
  1419. }
  1420. len = a_to_u_2_byte(tp->len) + sizeof(struct tocheader)-2;
  1421. printf("CD-Text len: %dn", len);
  1423. if (read_toc(scgp, xxb, 0, len, 0, FMT_CDTEXT) < 0) {
  1424. if (scgp->silent == 0)
  1425. errmsgno(EX_BAD, "Cannot read CD-Textn");
  1426. return (-1);
  1427. }
  1428. {
  1429. FILE *f = fileopen("cdtext.dat", "wct");
  1430. filewrite(f, xxb, len);
  1431. }
  1432. return (0);
  1433. }
  1435. EXPORT int
  1436. read_trackinfo(scgp, track, offp, msfp, adrp, controlp, modep)
  1437. SCSI *scgp;
  1438. int track;
  1439. long *offp;
  1440. struct msf *msfp;
  1441. int *adrp;
  1442. int *controlp;
  1443. int *modep;
  1444. {
  1445. struct diskinfo *dp;
  1446. char xb[256];
  1447. int len;
  1449. dp = (struct diskinfo *)xb;
  1451. fillbytes((caddr_t)xb, sizeof(xb), '');
  1452. if (read_toc(scgp, xb, track, sizeof(struct diskinfo), 0, FMT_TOC) < 0) {
  1453. if (scgp->silent <= 0)
  1454. errmsgno(EX_BAD, "Cannot read TOCn");
  1455. return (-1);
  1456. }
  1457. len = a_to_u_2_byte(dp->hd.len) + sizeof(struct tocheader)-2;
  1458. if (len <  (int)sizeof(struct diskinfo))
  1459. return (-1);
  1461. if (offp)
  1462. *offp = a_to_4_byte(dp->desc[0].addr);
  1463. if (adrp)
  1464. *adrp = dp->desc[0].adr;
  1465. if (controlp)
  1466. *controlp = dp->desc[0].control;
  1468. if (msfp) {
  1469. scgp->silent++;
  1470. if (read_toc(scgp, xb, track, sizeof(struct diskinfo), 1, FMT_TOC)
  1471. >= 0) {
  1472. msfp->msf_min = dp->desc[0].addr[1];
  1473. msfp->msf_sec = dp->desc[0].addr[2];
  1474. msfp->msf_frame = dp->desc[0].addr[3];
  1475. } else if (read_toc(scgp, xb, track, sizeof(struct diskinfo), 0, FMT_TOC)
  1476. >= 0) {
  1477. /*
  1478.  * Some drives (e.g. the Philips CDD-522) don't support
  1479.  * to read the TOC in MSF mode.
  1480.  */
  1481. long off = a_to_4_byte(dp->desc[0].addr);
  1483. lba_to_msf(off, msfp);
  1484. } else {
  1485. msfp->msf_min = 0;
  1486. msfp->msf_sec = 0;
  1487. msfp->msf_frame = 0;
  1488. }
  1489. scgp->silent--;
  1490. }
  1492. if (modep == NULL)
  1493. return (0);
  1495. if (track == 0xAA) {
  1496. *modep = -1;
  1497. return (0);
  1498. }
  1500. fillbytes((caddr_t)xb, sizeof(xb), '');
  1502. scgp->silent++;
  1503. if (read_header(scgp, xb, *offp, 8, 0) >= 0) {
  1504. *modep = xb[0];
  1505. } else if (read_track_info_philips(scgp, xb, track, 14) >= 0) {
  1506. *modep = xb[0xb] & 0xF;
  1507. } else {
  1508. *modep = -1;
  1509. }
  1510. scgp->silent--;
  1511. return (0);
  1512. }
  1514. EXPORT int
  1515. read_B0(scgp, isbcd, b0p, lop)
  1516. SCSI *scgp;
  1517. BOOL isbcd;
  1518. long *b0p;
  1519. long *lop;
  1520. {
  1521. struct fdiskinfo *dp;
  1522. struct ftrackdesc *tp;
  1523. char xb[8192];
  1524. char *pe;
  1525. int len;
  1526. long l;
  1528. dp = (struct fdiskinfo *)xb;
  1530. fillbytes((caddr_t)xb, sizeof(xb), '');
  1531. if (read_toc_philips(scgp, xb, 1, sizeof(struct tocheader), 0, FMT_FULLTOC) < 0) {
  1532. return (-1);
  1533. }
  1534. len = a_to_u_2_byte(dp->hd.len) + sizeof(struct tocheader)-2;
  1535. if (len <  (int)sizeof(struct fdiskinfo))
  1536. return (-1);
  1537. if (read_toc_philips(scgp, xb, 1, len, 0, FMT_FULLTOC) < 0) {
  1538. return (-1);
  1539. }
  1540. if (scgp->verbose) {
  1541. scsiprbytes("TOC data: ", (Uchar *)xb,
  1542. len > (int)sizeof(xb) - scsigetresid(scgp) ?
  1543. sizeof(xb) - scsigetresid(scgp) : len);
  1545. tp = &dp->desc[0];
  1546. pe = &xb[len];
  1548. while ((char *)tp < pe) {
  1549. scsiprbytes("ENT: ", (Uchar *)tp, 11);
  1550. tp++;
  1551. }
  1552. }
  1553. tp = &dp->desc[0];
  1554. pe = &xb[len];
  1556. for (; (char *)tp < pe; tp++) {
  1557. if (tp->sess_number != dp->hd.last)
  1558. continue;
  1559. if (tp->point != 0xB0)
  1560. continue;
  1561. if (scgp->verbose)
  1562. scsiprbytes("B0: ", (Uchar *)tp, 11);
  1563. if (isbcd) {
  1564. l = msf_to_lba(from_bcd(tp->amin),
  1565. from_bcd(tp->asec),
  1566. from_bcd(tp->aframe));
  1567. } else {
  1568. l = msf_to_lba(tp->amin,
  1569. tp->asec,
  1570. tp->aframe);
  1571. }
  1572. if (b0p)
  1573. *b0p = l;
  1575. if (scgp->verbose)
  1576. printf("B0 start: %ldn", l);
  1578. if (isbcd) {
  1579. l = msf_to_lba(from_bcd(tp->pmin),
  1580. from_bcd(tp->psec),
  1581. from_bcd(tp->pframe));
  1582. } else {
  1583. l = msf_to_lba(tp->pmin,
  1584. tp->psec,
  1585. tp->pframe);
  1586. }
  1588. if (scgp->verbose)
  1589. printf("B0 lout: %ldn", l);
  1590. if (lop)
  1591. *lop = l;
  1592. return (0);
  1593. }
  1594. return (-1);
  1595. }
  1598. /*
  1599.  * Return address of first track in last session (SCSI-3/mmc version).
  1600.  */
  1601. EXPORT int
  1602. read_session_offset(scgp, offp)
  1603. SCSI *scgp;
  1604. long *offp;
  1605. {
  1606. struct diskinfo *dp;
  1607. char xb[256];
  1608. int len;
  1610. dp = (struct diskinfo *)xb;
  1612. fillbytes((caddr_t)xb, sizeof(xb), '');
  1613. if (read_toc(scgp, (caddr_t)xb, 0, sizeof(struct tocheader), 0, FMT_SINFO) < 0)
  1614. return (-1);
  1616. if (scgp->verbose)
  1617. scsiprbytes("tocheader: ",
  1618. (Uchar *)xb, sizeof(struct tocheader) - scsigetresid(scgp));
  1620. len = a_to_u_2_byte(dp->hd.len) + sizeof(struct tocheader)-2;
  1621. if (len > (int)sizeof(xb)) {
  1622. errmsgno(EX_BAD, "Session info too big.n");
  1623. return (-1);
  1624. }
  1625. if (read_toc(scgp, (caddr_t)xb, 0, len, 0, FMT_SINFO) < 0)
  1626. return (-1);
  1628. if (scgp->verbose)
  1629. scsiprbytes("tocheader: ",
  1630. (Uchar *)xb, len - scsigetresid(scgp));
  1632. dp = (struct diskinfo *)xb;
  1633. if (offp)
  1634. *offp = a_to_u_4_byte(dp->desc[0].addr);
  1635. return (0);
  1636. }
  1638. /*
  1639.  * Return address of first track in last session (pre SCSI-3 version).
  1640.  */
  1641. EXPORT int
  1642. read_session_offset_philips(scgp, offp)
  1643. SCSI *scgp;
  1644. long *offp;
  1645. {
  1646. struct sinfo *sp;
  1647. char xb[256];
  1648. int len;
  1650. sp = (struct sinfo *)xb;
  1652. fillbytes((caddr_t)xb, sizeof(xb), '');
  1653. if (read_toc_philips(scgp, (caddr_t)xb, 0, sizeof(struct siheader), 0, FMT_SINFO) < 0)
  1654. return (-1);
  1655. len = a_to_u_2_byte(sp->hd.len) + sizeof(struct siheader)-2;
  1656. if (len > (int)sizeof(xb)) {
  1657. errmsgno(EX_BAD, "Session info too big.n");
  1658. return (-1);
  1659. }
  1660. if (read_toc_philips(scgp, (caddr_t)xb, 0, len, 0, FMT_SINFO) < 0)
  1661. return (-1);
  1662. /*
  1663.  * Old drives return the number of finished sessions in first/finished
  1664.  * a descriptor is returned for each session. 
  1665.  * New drives return the number of the first and last session
  1666.  * one descriptor for the last finished session is returned
  1667.  * as in SCSI-3
  1668.  * In all cases the lowest session number is set to 1.
  1669.  */
  1670. sp = (struct sinfo *)xb;
  1671. if (offp)
  1672. *offp = a_to_u_4_byte(sp->desc[sp->hd.finished-1].addr);
  1673. return (0);
  1674. }
  1676. EXPORT int
  1677. sense_secsize(scgp, current)
  1678. SCSI *scgp;
  1679. int current;
  1680. {
  1681. Uchar mode[0x100];
  1682. Uchar *p;
  1683. Uchar *ep;
  1684. int secsize = -1;
  1686. scgp->silent++;
  1687. (void)unit_ready(scgp);
  1688. scgp->silent--;
  1690. /* XXX Quick and dirty, musz verallgemeinert werden !!! */
  1692. fillbytes(mode, sizeof(mode), '');
  1693. scgp->silent++;
  1694. if (mode_sense(scgp, mode, 0xFF, 0x3F, current?0:2) < 0) { /* All Pages */
  1695. fillbytes(mode, sizeof(mode), '');
  1696. if (mode_sense(scgp, mode, 0xFF, 0, current?0:2) < 0) {/* VU (block desc) */
  1697. scgp->silent--;
  1698. return (-1);
  1699. }
  1700. }
  1701. scgp->silent--;
  1703. ep = mode+mode[0]; /* Points to last byte of data */
  1704. p = &mode[4];
  1705. p += mode[3];
  1706. if (scgp->debug) {
  1707. printf("Pages: ");
  1708. while (p < ep) {
  1709. printf("0x%x ", *p&0x3F);
  1710. p += p[1]+2;
  1711. }
  1712. printf("n");
  1713. }
  1715. if (mode[3] == 8) {
  1716. if (scgp->debug) {
  1717. printf("Density: 0x%xn", mode[4]);
  1718. printf("Blocks:  %ldn", a_to_u_3_byte(&mode[5]));
  1719. printf("Blocklen:%ldn", a_to_u_3_byte(&mode[9]));
  1720. }
  1721. secsize = a_to_u_3_byte(&mode[9]);
  1722. }
  1723. return (secsize);
  1724. }
  1726. EXPORT int
  1727. select_secsize(scgp, secsize)
  1728. SCSI *scgp;
  1729. int secsize;
  1730. {
  1731. struct scsi_mode_data md;
  1732. int count = sizeof(struct scsi_mode_header) +
  1733. sizeof(struct scsi_mode_blockdesc);
  1735. (void)test_unit_ready(scgp); /* clear any error situation */
  1737. fillbytes((caddr_t)&md, sizeof(md), '');
  1738. md.header.blockdesc_len = 8;
  1739. i_to_3_byte(md.blockdesc.lblen, secsize);
  1741. return (mode_select(scgp, (Uchar *)&md, count, 0, scgp->inq->data_format >= 2));
  1742. }
  1744. EXPORT BOOL
  1745. is_cddrive(scgp)
  1746. SCSI *scgp;
  1747. {
  1748. return (scgp->inq->type == INQ_ROMD || scgp->inq->type == INQ_WORM);
  1749. }
  1751. EXPORT BOOL
  1752. is_unknown_dev(scgp)
  1753. SCSI *scgp;
  1754. {
  1755. return (scgp->dev == DEV_UNKNOWN);
  1756. }
  1758. #define DEBUG
  1759. #ifdef DEBUG
  1760. #define G0_MAXADDR 0x1FFFFFL
  1762. EXPORT int
  1763. read_scsi(scgp, bp, addr, cnt)
  1764. SCSI *scgp;
  1765. caddr_t bp;
  1766. long addr;
  1767. int cnt;
  1768. {
  1769. if(addr <= G0_MAXADDR && cnt < 256 && !is_atapi)
  1770. return (read_g0(scgp, bp, addr, cnt));
  1771. else
  1772. return (read_g1(scgp, bp, addr, cnt));
  1773. }
  1775. EXPORT int
  1776. read_g0(scgp, bp, addr, cnt)
  1777. SCSI *scgp;
  1778. caddr_t bp;
  1779. long addr;
  1780. int cnt;
  1781. {
  1782. register struct scg_cmd *scmd = scgp->scmd;
  1784. if (scgp->cap->c_bsize <= 0)
  1785. raisecond("capacity_not_set", 0L);
  1787. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1788. scmd->addr = bp;
  1789. scmd->size = cnt*scgp->cap->c_bsize;
  1790. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  1791. scmd->cdb_len = SC_G0_CDBLEN;
  1792. scmd->sense_len = CCS_SENSE_LEN;
  1793. scmd->target = scgp->target;
  1794. scmd->cdb.g0_cdb.cmd = SC_READ;
  1795. scmd->cdb.g0_cdb.lun = scgp->lun;
  1796. g0_cdbaddr(&scmd->cdb.g0_cdb, addr);
  1797. scmd->cdb.g0_cdb.count = cnt;
  1798. /* scmd->cdb.g0_cdb.vu_56 = 1;*/
  1800. scgp->cmdname = "read_g0";
  1802. return (scsicmd(scgp));
  1803. }
  1805. EXPORT int
  1806. read_g1(scgp, bp, addr, cnt)
  1807. SCSI *scgp;
  1808. caddr_t bp;
  1809. long addr;
  1810. int cnt;
  1811. {
  1812. register struct scg_cmd *scmd = scgp->scmd;
  1814. if (scgp->cap->c_bsize <= 0)
  1815. raisecond("capacity_not_set", 0L);
  1817. fillbytes((caddr_t)scmd, sizeof(*scmd), '');
  1818. scmd->addr = bp;
  1819. scmd->size = cnt*scgp->cap->c_bsize;
  1820. scmd->flags = SCG_RECV_DATA|SCG_DISRE_ENA;
  1821. scmd->cdb_len = SC_G1_CDBLEN;
  1822. scmd->sense_len = CCS_SENSE_LEN;
  1823. scmd->target = scgp->target;
  1824. scmd->cdb.g1_cdb.cmd = SC_EREAD;
  1825. scmd->cdb.g1_cdb.lun = scgp->lun;
  1826. g1_cdbaddr(&scmd->cdb.g1_cdb, addr);
  1827. g1_cdblen(&scmd->cdb.g1_cdb, cnt);
  1829. scgp->cmdname = "read_g1";
  1831. return (scsicmd(scgp));
  1832. }
  1833. #endif /* DEBUG */
  1835. EXPORT BOOL
  1836. getdev(scgp, print)
  1837. SCSI *scgp;
  1838. BOOL print;
  1839. {
  1840.  BOOL got_inquiry = TRUE;
  1841.  char vendor_info[8+1];
  1842.  char prod_ident[16+1];
  1843.  char prod_revision[4+1];
  1844.  int inq_len = 0;
  1845. register struct scg_cmd *scmd = scgp->scmd;
  1846. register struct scsi_inquiry *inq = scgp->inq;
  1849. fillbytes((caddr_t)inq, sizeof(*inq), '');
  1850. scgp->dev = DEV_UNKNOWN;
  1851. scgp->silent++;
  1852. (void)unit_ready(scgp);
  1853. if (scmd->error >= SCG_FATAL &&
  1854. !(scmd->scb.chk && scmd->sense_count > 0)) {
  1855. scgp->silent--;
  1856. return (FALSE);
  1857. }
  1860. /* if (scmd->error < SCG_FATAL || scmd->scb.chk && scmd->sense_count > 0){*/
  1862. if (inquiry(scgp, (caddr_t)inq, sizeof(*inq)) < 0) {
  1863. got_inquiry = FALSE;
  1864. } else {
  1865. inq_len = sizeof(*inq) - scsigetresid(scgp);
  1866. }
  1867. if (!got_inquiry) {
  1868. if (scgp->verbose) {
  1869. printf(
  1870. "error: %d scb.chk: %d sense_count: %d sense.code: 0x%xn",
  1871. scmd->error, scmd->scb.chk,
  1872. scmd->sense_count, scmd->sense.code);
  1873. }
  1874. /*
  1875.  * Folgende Kontroller kennen das Kommando
  1876.  * INQUIRY nicht:
  1877.  *
  1878.  * ADAPTEC ACB-4000, ACB-4010, ACB 4070
  1879.  * SYSGEN SC4000
  1880.  *
  1881.  * Leider reagieren ACB40X0 und ACB5500 identisch
  1882.  * wenn drive not ready (code == not ready),
  1883.  * sie sind dann nicht zu unterscheiden.
  1884.  */
  1886. if (scmd->scb.chk && scmd->sense_count == 4) {
  1887. /* Test auf SYSGEN  */
  1888. (void)qic02(scgp, 0x12); /* soft lock on  */
  1889. if (qic02(scgp, 1) < 0) { /* soft lock off */
  1890. scgp->dev = DEV_ACB40X0;
  1891. /* scgp->dev = acbdev();*/
  1892. } else {
  1893. scgp->dev = DEV_SC4000;
  1894. inq->type = INQ_SEQD;
  1895. inq->removable = 1;
  1896. }
  1897. }
  1898. } else if (scgp->verbose) {
  1899. int i;
  1900. int len = inq->add_len + 5;
  1901. Uchar ibuf[256+5];
  1902. Uchar *ip = (Uchar *)inq;
  1903. Uchar c;
  1905. if (len > (int)sizeof (*inq) &&
  1906. inquiry(scgp, (caddr_t)ibuf, inq->add_len+5) >= 0) {
  1907. len = inq->add_len+5 - scsigetresid(scgp);
  1908. ip = ibuf;
  1909. } else {
  1910. len = sizeof (*inq);
  1911. }
  1912. printf("Inquiry Data   : ");
  1913. for (i = 0; i < len; i++) {
  1914. c = ip[i];
  1915. if (c >= ' ' && c < 0177)
  1916. printf("%c", c);
  1917. else
  1918. printf(".");
  1919. }
  1920. printf("n");
  1921. }
  1923. strncpy(vendor_info, inq->vendor_info, sizeof(inq->vendor_info));
  1924. strncpy(prod_ident, inq->prod_ident, sizeof(inq->prod_ident));
  1925. strncpy(prod_revision, inq->prod_revision, sizeof(inq->prod_revision));
  1927. vendor_info[sizeof(inq->vendor_info)] = '';
  1928. prod_ident[sizeof(inq->prod_ident)] = '';
  1929. prod_revision[sizeof(inq->prod_revision)] = '';
  1931. switch (inq->type) {
  1933. case INQ_DASD:
  1934. if (inq->add_len == 0 && inq->vendor_info[0] != '') {
  1935. Uchar *p;
  1936. /*
  1937.  * NT-4.0 creates fake inquiry data for IDE disks.
  1938.  * Unfortunately, it does not set add_len wo we
  1939.  * check if vendor_info, prod_ident and prod_revision
  1940.  * contains valid chars for a CCS inquiry.
  1941.  */
  1942. if (inq_len >= 36)
  1943. inq->add_len = 31;
  1945. for (p = (Uchar *)&inq->vendor_info[0];
  1946. p < (Uchar *)&inq->prod_revision[4];
  1947. p++) {
  1948. if (*p < 0x20 || *p > 0x7E) {
  1949. inq->add_len = 0;
  1950. break;
  1951. }
  1952. }
  1953. }
  1954. if (inq->add_len == 0) {
  1955. if (scgp->dev == DEV_UNKNOWN && got_inquiry) {
  1956. scgp->dev = DEV_ACB5500;
  1957. strcpy(inq->vendor_info,
  1958. "ADAPTEC ACB-5500        FAKE");
  1960. } else switch (scgp->dev) {
  1962. case DEV_ACB40X0:
  1963. strcpy(inq->vendor_info,
  1964. "ADAPTEC ACB-40X0        FAKE");
  1965. break;
  1966. case DEV_ACB4000:
  1967. strcpy(inq->vendor_info,
  1968. "ADAPTEC ACB-4000        FAKE");
  1969. break;
  1970. case DEV_ACB4010:
  1971. strcpy(inq->vendor_info,
  1972. "ADAPTEC ACB-4010        FAKE");
  1973. break;
  1974. case DEV_ACB4070:
  1975. strcpy(inq->vendor_info,
  1976. "ADAPTEC ACB-4070        FAKE");
  1977. break;
  1978. }
  1979. } else if (inq->add_len < 31) {
  1980. scgp->dev = DEV_NON_CCS_DSK;
  1982. } else if (strbeg("EMULEX", vendor_info)) {
  1983. if (strbeg("MD21", prod_ident))
  1984. scgp->dev = DEV_MD21;
  1985. if (strbeg("MD23", prod_ident))
  1986. scgp->dev = DEV_MD23;
  1987. else
  1988. scgp->dev = DEV_CCS_GENDISK;
  1989. } else if (strbeg("ADAPTEC", vendor_info)) {
  1990. if (strbeg("ACB-4520", prod_ident))
  1991. scgp->dev = DEV_ACB4520A;
  1992. if (strbeg("ACB-4525", prod_ident))
  1993. scgp->dev = DEV_ACB4525;
  1994. else
  1995. scgp->dev = DEV_CCS_GENDISK;
  1996. } else if (strbeg("SONY", vendor_info) &&
  1997. strbeg("SMO-C501", prod_ident)) {
  1998. scgp->dev = DEV_SONY_SMO;
  1999. } else {
  2000. scgp->dev = DEV_CCS_GENDISK;
  2001. }
  2002. break;
  2004. case INQ_SEQD:
  2005. if (scgp->dev == DEV_SC4000) {
  2006. strcpy(inq->vendor_info,
  2007. "SYSGEN  SC4000          FAKE");
  2008. } else if (inq->add_len == 0 &&
  2009. inq->removable &&
  2010. inq->ansi_version == 1) {
  2011. scgp->dev = DEV_MT02;
  2012. strcpy(inq->vendor_info,
  2013. "EMULEX  MT02            FAKE");
  2014. }
  2015. break;
  2017. /* case INQ_OPTD:*/
  2018. case INQ_ROMD:
  2019. case INQ_WORM:
  2020. if (strbeg("RXT-800S", prod_ident))
  2021. scgp->dev = DEV_RXT800S;
  2023. /*
  2024.  * Start of CD-Recorders:
  2025.  */
  2026. if (strbeg("ACER", vendor_info)) { 
  2027. if (strbeg("CR-4020C", prod_ident)) 
  2028.                                 scgp->dev = DEV_RICOH_RO_1420C;
  2030. } else if (strbeg("CREATIVE", vendor_info)) { 
  2031. if (strbeg("CDR2000", prod_ident))
  2032. scgp->dev = DEV_RICOH_RO_1060C;
  2034. } else if (strbeg("GRUNDIG", vendor_info)) { 
  2035. if (strbeg("CDR100IPW", prod_ident))
  2036. scgp->dev = DEV_CDD_2000;
  2038. } else if (strbeg("JVC", vendor_info)) {
  2039. if (strbeg("XR-W2001", prod_ident))
  2040. scgp->dev = DEV_TEAC_CD_R50S;
  2041. else if (strbeg("XR-W2010", prod_ident))
  2042. scgp->dev = DEV_TEAC_CD_R50S;
  2043. else if (strbeg("R2626", prod_ident))
  2044. scgp->dev = DEV_TEAC_CD_R50S;
  2046. } else if (strbeg("MITSBISH", vendor_info)) {
  2048. #ifdef XXXX_REALLY
  2049. /* It's MMC compliant */
  2050. if (strbeg("CDRW226", prod_ident))
  2051. scgp->dev = DEV_MMC_CDRW;
  2052. #endif
  2054. } else if (strbeg("MITSUMI", vendor_info)) {
  2055. /* Don't know any product string */
  2056. scgp->dev = DEV_CDD_522;
  2058. } else if (strbeg("OPTIMA", vendor_info)) {
  2059. if (strbeg("CD-R 650", prod_ident))
  2060. scgp->dev = DEV_SONY_CDU_924;
  2062. } else if (strbeg("PHILIPS", vendor_info) ||
  2063. strbeg("IMS", vendor_info) ||
  2064. strbeg("KODAK", vendor_info) ||
  2065. strbeg("HP", vendor_info)) {
  2067. if (strbeg("CDD521/00", prod_ident))
  2068. scgp->dev = DEV_CDD_521_OLD;
  2069. else if (strbeg("CDD521/02", prod_ident))
  2070. scgp->dev = DEV_CDD_521_OLD; /* PCD 200R? */
  2071. else if (strbeg("CDD521", prod_ident))
  2072. scgp->dev = DEV_CDD_521;
  2074. if (strbeg("CDD522", prod_ident))
  2075. scgp->dev = DEV_CDD_522;
  2076. if (strbeg("PCD225", prod_ident))
  2077. scgp->dev = DEV_CDD_522;
  2078. if (strbeg("KHSW/OB", prod_ident)) /* PCD600 */
  2079. scgp->dev = DEV_PCD_600;
  2080. if (strbeg("CDR-240", prod_ident))
  2081. scgp->dev = DEV_CDD_2000;
  2083. if (strbeg("CDD20", prod_ident))
  2084. scgp->dev = DEV_CDD_2000;
  2085. if (strbeg("CDD26", prod_ident))
  2086. scgp->dev = DEV_CDD_2600;
  2088. if (strbeg("C4324/C4325", prod_ident))
  2089. scgp->dev = DEV_CDD_2000;
  2090. if (strbeg("CD-Writer 6020", prod_ident))
  2091. scgp->dev = DEV_CDD_2600;
  2093. } else if (strbeg("PINNACLE", vendor_info)) {
  2094. if (strbeg("RCD-1000", prod_ident))
  2095. scgp->dev = DEV_TEAC_CD_R50S;
  2096. if (strbeg("RCD5020", prod_ident))
  2097. scgp->dev = DEV_TEAC_CD_R50S;
  2098. if (strbeg("RCD5040", prod_ident))
  2099. scgp->dev = DEV_TEAC_CD_R50S;
  2100. if (strbeg("RCD 4X4", prod_ident))
  2101. scgp->dev = DEV_TEAC_CD_R50S;
  2103. } else if (strbeg("PIONEER", vendor_info)) {
  2104. if (strbeg("CD-WO DW-S114X", prod_ident))
  2105. scgp->dev = DEV_PIONEER_DW_S114X;
  2106. else if (strbeg("DVD-R DVR-S101", prod_ident))
  2107. scgp->dev = DEV_PIONEER_DVDR_S101;
  2109. } else if (strbeg("PLASMON", vendor_info)) {
  2110. if (strbeg("RF4100", prod_ident))
  2111. scgp->dev = DEV_PLASMON_RF_4100;
  2112. else if (strbeg("CDR4220", prod_ident))
  2113. scgp->dev = DEV_CDD_2000;
  2115. } else if (strbeg("PLEXTOR", vendor_info)) {
  2116. if (strbeg("CD-R   PX-R24CS", prod_ident))
  2117. scgp->dev = DEV_RICOH_RO_1420C;
  2119. } else if (strbeg("RICOH", vendor_info)) {
  2120. if (strbeg("RO-1420C", prod_ident))
  2121. scgp->dev = DEV_RICOH_RO_1420C;
  2122. if (strbeg("RO1060C", prod_ident))
  2123. scgp->dev = DEV_RICOH_RO_1060C;
  2125. } else if (strbeg("SAF", vendor_info)) { /* Smart & Friendly */
  2126. if (strbeg("CD-R2004", prod_ident) ||
  2127.     strbeg("CD-R2006 ", prod_ident))
  2128. scgp->dev = DEV_SONY_CDU_924;
  2129. else if (strbeg("CD-R2006PLUS", prod_ident))
  2130. scgp->dev = DEV_TEAC_CD_R50S;
  2131. else if (strbeg("CD-RW226", prod_ident))
  2132. scgp->dev = DEV_TEAC_CD_R50S;
  2133. else if (strbeg("CD-R4012", prod_ident))
  2134. scgp->dev = DEV_TEAC_CD_R50S;
  2136. } else if (strbeg("SONY", vendor_info)) {
  2137. if (strbeg("CD-R   CDU92", prod_ident) ||
  2138.     strbeg("CD-R   CDU94", prod_ident))
  2139. scgp->dev = DEV_SONY_CDU_924;
  2141. } else if (strbeg("TEAC", vendor_info)) {
  2142. if (strbeg("CD-R50S", prod_ident) ||
  2143.     strbeg("CD-R55S", prod_ident))
  2144. scgp->dev = DEV_TEAC_CD_R50S;
  2146. } else if (strbeg("TRAXDATA", vendor_info) ||
  2147. strbeg("Traxdata", vendor_info)) {
  2148. if (strbeg("CDR4120", prod_ident))
  2149. scgp->dev = DEV_TEAC_CD_R50S;
  2151. } else if (strbeg("T.YUDEN", vendor_info)) {
  2152. if (strbeg("CD-WO EW-50", prod_ident))
  2153. scgp->dev = DEV_CDD_521;
  2155. } else if (strbeg("WPI", vendor_info)) { /* Wearnes */
  2156. if (strbeg("CDR-632P", prod_ident))
  2157. scgp->dev = DEV_CDD_2600;
  2159. } else if (strbeg("YAMAHA", vendor_info)) {
  2160. if (strbeg("CDR10", prod_ident))
  2161. scgp->dev = DEV_YAMAHA_CDR_100;
  2162. if (strbeg("CDR200", prod_ident))
  2163. scgp->dev = DEV_YAMAHA_CDR_400;
  2164. if (strbeg("CDR400", prod_ident))
  2165. scgp->dev = DEV_YAMAHA_CDR_400;
  2167. } else if (strbeg("MATSHITA", vendor_info)) {
  2168. if (strbeg("CD-R   CW-7501", prod_ident))
  2169. scgp->dev = DEV_MATSUSHITA_7501;
  2170. if (strbeg("CD-R   CW-7502", prod_ident))
  2171. scgp->dev = DEV_MATSUSHITA_7502;
  2172. }
  2173. if (scgp->dev == DEV_UNKNOWN) {
  2174. /*
  2175.  * We do not have Manufacturer strings for
  2176.  * the following drives.
  2177.  */
  2178. if (strbeg("CDS615E", prod_ident)) /* Olympus */
  2179. scgp->dev = DEV_SONY_CDU_924;
  2180. }
  2181. if (scgp->dev == DEV_UNKNOWN && inq->type == INQ_ROMD) {
  2182. BOOL cdrr  = FALSE;
  2183. BOOL cdwr  = FALSE;
  2184. BOOL cdrrw  = FALSE;
  2185. BOOL cdwrw  = FALSE;
  2186. BOOL dvd  = FALSE;
  2188. scgp->dev = DEV_CDROM;
  2190. if (mmc_check(scgp, &cdrr, &cdwr, &cdrrw, &cdwrw, &dvd))
  2191. scgp->dev = DEV_MMC_CDROM;
  2192. if (cdwr)
  2193. scgp->dev = DEV_MMC_CDR;
  2194. if (cdwrw)
  2195. scgp->dev = DEV_MMC_CDRW;
  2196. if (dvd)
  2197. scgp->dev = DEV_MMC_DVD;
  2198. }
  2200. case INQ_PROCD:
  2201. if (strbeg("BERTHOLD", vendor_info)) {
  2202. if (strbeg("", prod_ident))
  2203. scgp->dev = DEV_HRSCAN;
  2204. }
  2205. break;
  2207. case INQ_SCAN:
  2208. scgp->dev = DEV_MS300A;
  2209. break;
  2210. }
  2211. scgp->silent--;
  2212. if (!print)
  2213. return (TRUE);
  2215. if (scgp->dev == DEV_UNKNOWN && !got_inquiry) {
  2216. #ifdef PRINT_INQ_ERR
  2217. scsiprinterr(scgp);
  2218. #endif
  2219. return (FALSE);
  2220. }
  2222. printf("Device type    : ");
  2223. scsiprintdev(inq);
  2224. printf("Version        : %dn", inq->ansi_version);
  2225. printf("Response Format: %dn", inq->data_format);
  2226. if (inq->data_format >= 2) {
  2227. printf("Capabilities   : ");
  2228. if (inq->aenc) printf("AENC ");
  2229. if (inq->termiop) printf("TERMIOP ");
  2230. if (inq->reladr) printf("RELADR ");
  2231. if (inq->wbus32) printf("WBUS32 ");
  2232. if (inq->wbus16) printf("WBUS16 ");
  2233. if (inq->sync) printf("SYNC ");
  2234. if (inq->linked) printf("LINKED ");
  2235. if (inq->cmdque) printf("CMDQUE ");
  2236. if (inq->softreset) printf("SOFTRESET ");
  2237. printf("n");
  2238. }
  2239. if (inq->add_len >= 31 ||
  2240. inq->info[0] || inq->ident[0] || inq->revision[0]) {
  2241. printf("Vendor_info    : '%.8s'n", inq->info);
  2242. printf("Identifikation : '%.16s'n", inq->ident);
  2243. printf("Revision       : '%.4s'n", inq->revision);
  2244. }
  2245. return (TRUE);
  2246. }
  2248. EXPORT void
  2249. printdev(scgp)
  2250. SCSI *scgp;
  2251. {
  2252. printf("Device seems to be: ");
  2254. switch (scgp->dev) {
  2256. case DEV_UNKNOWN: printf("unknown"); break;
  2257. case DEV_ACB40X0: printf("Adaptec 4000/4010/4070");break;
  2258. case DEV_ACB4000: printf("Adaptec 4000"); break;
  2259. case DEV_ACB4010: printf("Adaptec 4010"); break;
  2260. case DEV_ACB4070: printf("Adaptec 4070"); break;
  2261. case DEV_ACB5500: printf("Adaptec 5500"); break;
  2262. case DEV_ACB4520A: printf("Adaptec 4520A"); break;
  2263. case DEV_ACB4525: printf("Adaptec 4525"); break;
  2264. case DEV_MD21: printf("Emulex MD21"); break;
  2265. case DEV_MD23: printf("Emulex MD23"); break;
  2266. case DEV_NON_CCS_DSK: printf("Generic NON CCS Disk"); break;
  2267. case DEV_CCS_GENDISK: printf("Generic CCS Disk"); break;
  2268. case DEV_SONY_SMO: printf("Sony SMO-C501"); break;
  2269. case DEV_MT02: printf("Emulex MT02"); break;
  2270. case DEV_SC4000: printf("Sysgen SC4000"); break;
  2271. case DEV_RXT800S: printf("Maxtor RXT800S"); break;
  2272. case DEV_HRSCAN: printf("Berthold HR-Scanner"); break;
  2273. case DEV_MS300A: printf("Microtek MS300A"); break;
  2275. case DEV_CDROM: printf("Generic CD-ROM"); break;
  2276. case DEV_MMC_CDROM: printf("Generic mmc CD-ROM"); break;
  2277. case DEV_MMC_CDR: printf("Generic mmc CD-R"); break;
  2278. case DEV_MMC_CDRW: printf("Generic mmc CD-RW"); break;
  2279. case DEV_MMC_DVD: printf("Generic mmc2 DVD"); break;
  2280. case DEV_CDD_521_OLD: printf("Philips old CDD-521"); break;
  2281. case DEV_CDD_521: printf("Philips CDD-521"); break;
  2282. case DEV_CDD_522: printf("Philips CDD-522"); break;
  2283. case DEV_PCD_600: printf("Kodak PCD-600"); break;
  2284. case DEV_CDD_2000: printf("Philips CDD-2000"); break;
  2285. case DEV_CDD_2600: printf("Philips CDD-2600"); break;
  2286. case DEV_YAMAHA_CDR_100:printf("Yamaha CDR-100"); break;
  2287. case DEV_YAMAHA_CDR_400:printf("Yamaha CDR-400"); break;
  2288. case DEV_PLASMON_RF_4100:printf("Plasmon RF-4100"); break;
  2289. case DEV_SONY_CDU_924: printf("Sony CDU-924S"); break;
  2290. case DEV_RICOH_RO_1060C:printf("Ricoh RO-1060C"); break;
  2291. case DEV_RICOH_RO_1420C:printf("Ricoh RO-1420C"); break;
  2292. case DEV_TEAC_CD_R50S: printf("Teac CD-R50S"); break;
  2293. case DEV_MATSUSHITA_7501:printf("Matsushita CW-7501"); break;
  2294. case DEV_MATSUSHITA_7502:printf("Matsushita CW-7502"); break;
  2296. case DEV_PIONEER_DW_S114X: printf("Pioneer DW-S114X"); break;
  2297. case DEV_PIONEER_DVDR_S101:printf("Pioneer DVD-R S101");break;
  2299. default: printf("Missing Entry for dev %d",
  2300. scgp->dev); break;
  2302. }
  2303. printf(".n");
  2305. }
  2307. EXPORT BOOL
  2308. do_inquiry(scgp, print)
  2309. SCSI *scgp;
  2310. int print;
  2311. {
  2312. if (getdev(scgp, print)) {
  2313. if (print)
  2314. printdev(scgp);
  2315. return (TRUE);
  2316. } else {
  2317. return (FALSE);
  2318. }
  2319. }
  2321. EXPORT BOOL
  2322. recovery_needed(scgp)
  2323. SCSI *scgp;
  2324. {
  2325.  int err;
  2326. register struct scg_cmd *scmd = scgp->scmd;
  2328. scgp->silent++;
  2329. err = test_unit_ready(scgp);
  2330. scgp->silent--;
  2332. if (err >= 0)
  2333. return (FALSE);
  2334. else if (scmd->error >= SCG_FATAL) /* nicht selektierbar */
  2335. return (FALSE);
  2337. if (scmd->sense.code < 0x70) /* non extended Sense */
  2338. return (FALSE);
  2340. /* XXX Old Philips code */
  2341. return (((struct scsi_ext_sense *)&scmd->sense)->sense_code == 0xD0);
  2342. }
  2344. EXPORT int
  2345. scsi_load(scgp)
  2346. SCSI *scgp;
  2347. {
  2348. return (scsi_start_stop_unit(scgp, 1, 1));
  2349. }
  2351. EXPORT int
  2352. scsi_unload(scgp)
  2353. SCSI *scgp;
  2354. {
  2355. return (scsi_start_stop_unit(scgp, 0, 1));
  2356. }
  2358. EXPORT int
  2359. scsi_cdr_write(scgp, bp, sectaddr, size, blocks, islast)
  2360. SCSI *scgp;
  2361. caddr_t bp; /* address of buffer */
  2362. long sectaddr; /* disk address (sector) to put */
  2363. long size; /* number of bytes to transfer */
  2364. int blocks; /* sector count */
  2365. BOOL islast; /* last write for track */
  2366. {
  2367. return (write_xg1(scgp, bp, sectaddr, size, blocks));
  2368. }
  2370. EXPORT struct cd_mode_page_2A *
  2371. mmc_cap(scgp, modep)
  2372. SCSI *scgp;
  2373. Uchar *modep;
  2374. {
  2375. int len;
  2376. int val;
  2377. Uchar mode[0x100];
  2378. struct cd_mode_page_2A *mp;
  2379. struct cd_mode_page_2A *mp2;
  2382. retry:
  2383. fillbytes((caddr_t)mode, sizeof(mode), '');
  2385. if (!get_mode_params(scgp, 0x2A, "CD capabilities",
  2386. mode, (Uchar *)0, (Uchar *)0, (Uchar *)0, &len)) {
  2388. if (scsi_sense_key(scgp) == SC_NOT_READY) {
  2389. if (wait_unit_ready(scgp, 60))
  2390. goto retry;
  2391. }
  2392. return (NULL); /* Pre SCSI-3/mmc drive   */
  2393. }
  2395. if (len == 0) /* Pre SCSI-3/mmc drive   */
  2396. return (NULL);
  2398. mp = (struct cd_mode_page_2A *)
  2399. (mode + sizeof(struct scsi_mode_header) +
  2400. ((struct scsi_mode_header *)mode)->blockdesc_len);
  2402. /*
  2403.  * Do some heuristics against pre SCSI-3/mmc VU page 2A
  2404.  * We should test for a minimum p_len of 0x14, but some
  2405.  * buggy CD-ROM readers ommit the write speed values.
  2406.  */
  2407. if (mp->p_len < 0x10)
  2408. return (NULL);
  2410. val = a_to_u_2_byte(mp->max_read_speed);
  2411. if (val != 0 && val < 176)
  2412. return (NULL);
  2414. val = a_to_u_2_byte(mp->cur_read_speed);
  2415. if (val != 0 && val < 176)
  2416. return (NULL);
  2418. len -= sizeof(struct scsi_mode_header) +
  2419. ((struct scsi_mode_header *)mode)->blockdesc_len;
  2420. if (modep)
  2421. mp2 = (struct cd_mode_page_2A *)modep;
  2422. else
  2423. mp2 = (struct cd_mode_page_2A *)malloc(len);
  2424. if (mp2)
  2425. movebytes(mp, mp2, len);
  2427. return (mp2);
  2428. }
  2430. EXPORT void
  2431. mmc_getval(mp, cdrrp, cdwrp, cdrrwp, cdwrwp, dvdp)
  2432. struct cd_mode_page_2A *mp;
  2433. BOOL *cdrrp;
  2434. BOOL *cdwrp;
  2435. BOOL *cdrrwp;
  2436. BOOL *cdwrwp;
  2437. BOOL *dvdp;
  2438. {
  2439. if (cdrrp)
  2440. *cdrrp = (mp->cd_r_read != 0); /* SCSI-3/mmc CD */
  2441. if (cdwrp)
  2442. *cdwrp = (mp->cd_r_write != 0); /* SCSI-3/mmc CD-R */
  2444. if (cdrrwp)
  2445. *cdrrwp = (mp->cd_rw_read != 0);/* SCSI-3/mmc CD */
  2446. if (cdwrwp)
  2447. *cdwrwp = (mp->cd_rw_write != 0);/* SCSI-3/mmc CD-RW */
  2448. if (dvdp) {
  2449. *dvdp =  /* SCSI-3/mmc2 DVD  */
  2450. (mp->dvd_ram_read + mp->dvd_r_read  + mp->dvd_rom_read +
  2451.  mp->dvd_ram_write + mp->dvd_r_write) != 0;
  2452. }
  2453. }
  2455. EXPORT BOOL
  2456. is_mmc(scgp, dvdp)
  2457. SCSI *scgp;
  2458. BOOL *dvdp;
  2459. {
  2460. return (mmc_check(scgp, NULL, NULL, NULL, NULL, dvdp));
  2461. }
  2463. EXPORT BOOL
  2464. mmc_check(scgp, cdrrp, cdwrp, cdrrwp, cdwrwp, dvdp)
  2465. SCSI *scgp;
  2466. BOOL *cdrrp;
  2467. BOOL *cdwrp;
  2468. BOOL *cdrrwp;
  2469. BOOL *cdwrwp;
  2470. BOOL *dvdp;
  2471. {
  2472. Uchar mode[0x100];
  2473. BOOL was_atapi;
  2474. struct cd_mode_page_2A *mp;
  2476. if (scgp->inq->type != INQ_ROMD)
  2477. return (FALSE);
  2479. fillbytes((caddr_t)mode, sizeof(mode), '');
  2481. was_atapi = allow_atapi(scgp, TRUE);
  2482. scgp->silent++;
  2483. mp = mmc_cap(scgp, mode);
  2484. scgp->silent--;
  2485. allow_atapi(scgp, was_atapi);
  2486. if (mp == NULL)
  2487. return (FALSE);
  2489. mmc_getval(mp, cdrrp, cdwrp, cdrrwp, cdwrwp, dvdp);
  2491. return (TRUE); /* Generic SCSI-3/mmc CD */
  2492. }
  2494. #define DOES(what,flag) printf("  Does %s%sn", flag?"":"not ",what);
  2495. #define IS(what,flag) printf("  Is %s%sn", flag?"":"not ",what);
  2496. #define VAL(what,val) printf("  %s: %dn", what, val[0]*256 + val[1]);
  2497. #define SVAL(what,val) printf("  %s: %sn", what, val);
  2499. EXPORT void
  2500. print_capabilities(scgp)
  2501. SCSI *scgp;
  2502. {
  2503. BOOL was_atapi;
  2504. Uchar mode[0x100];
  2505. struct cd_mode_page_2A *mp;
  2506. static const char *bclk[4] = {"32", "16", "24", "24 (I2S)"};
  2507. static const char *load[8] = {"caddy", "tray", "pop-up", "reserved(3)",
  2508. "disc changer", "cartridge changer",
  2509. "reserved(6)", "reserved(7)" };
  2512. if (scgp->inq->type != INQ_ROMD)
  2513. return;
  2515. fillbytes((caddr_t)mode, sizeof(mode), '');
  2517. was_atapi = allow_atapi(scgp, TRUE); /* Try to switch to 10 byte mode cmds */
  2518. scgp->silent++;
  2519. mp = mmc_cap(scgp, mode);
  2520. scgp->silent--;
  2521. allow_atapi(scgp, was_atapi);
  2522. if (mp == NULL)
  2523. return;
  2525. printf ("nDrive capabilities, per page 2A:nn");
  2527. DOES("read CD-R media", mp->cd_r_read);
  2528. DOES("write CD-R media", mp->cd_r_write);
  2529. DOES("read CD-RW media", mp->cd_rw_read);
  2530. DOES("write CD-RW media", mp->cd_rw_write);
  2531. DOES("read DVD-ROM media", mp->dvd_rom_read);
  2532. DOES("read DVD-R media", mp->dvd_r_read);
  2533. DOES("write DVD-R media", mp->dvd_r_write);
  2534. DOES("read DVD-RAM media", mp->dvd_ram_read);
  2535. DOES("write DVD-RAM media", mp->dvd_ram_write);
  2536. DOES("support test writing", mp->test_write);
  2537. printf("n");
  2538. DOES("read Mode 2 Form 1 blocks", mp->mode_2_form_1);
  2539. DOES("read Mode 2 Form 2 blocks", mp->mode_2_form_2);
  2540. DOES("read digital audio blocks", mp->cd_da_supported);
  2541. if (mp->cd_da_supported) 
  2542. DOES("restart non-streamed digital audio reads accurately", mp->cd_da_accurate);
  2543. DOES("read multi-session CDs", mp->multi_session);
  2544. DOES("read fixed-packet CD media using Method 2", mp->method2);
  2545. DOES("read CD bar code", mp->read_bar_code);
  2546. DOES("read R-W subcode information", mp->rw_supported);
  2547. if (mp->rw_supported) 
  2548. DOES("return R-W subcode de-interleaved and error-corrected", mp->rw_deint_corr);
  2549. DOES("return CD media catalog number", mp->UPC);
  2550. DOES("return CD ISRC information", mp->ISRC);
  2551. DOES("support C2 error pointers", mp->c2_pointers);
  2552. DOES("deliver composite A/V data", mp->composite);
  2553. printf("n");
  2554. DOES("play audio CDs", mp->audio_play);
  2555. if (mp->audio_play) {
  2556. VAL("Number of volume control levels", mp->num_vol_levels);
  2557. DOES("support individual volume control setting for each channel", mp->sep_chan_vol);
  2558. DOES("support independent mute setting for each channel", mp->sep_chan_mute);
  2559. DOES("support digital output on port 1", mp->digital_port_1);
  2560. DOES("support digital output on port 2", mp->digital_port_2);
  2561. if (mp->digital_port_1 || mp->digital_port_2) {
  2562. DOES("send digital data LSB-first", mp->LSBF);
  2563. DOES("set LRCK high for left-channel data", mp->RCK);
  2564. DOES("have valid data on falling edge of clock", mp->BCK);
  2565. SVAL("Length of data in BCLKs", bclk[mp->length]);
  2566. }
  2567. }
  2568. printf("n");
  2569. SVAL("Loading mechanism type", load[mp->loading_type]);
  2570. DOES("support ejection of CD via START/STOP command", mp->eject);
  2571. DOES("lock media on power up via prevent jumper", mp->prevent_jumper);
  2572. DOES("allow media to be locked in the drive via PREVENT/ALLOW command", mp->lock);
  2573. IS("currently in a media-locked state", mp->lock_state);
  2574. DOES("have load-empty-slot-in-changer feature", mp->sw_slot_sel);
  2575. DOES("support Individual Disk Present feature", mp->disk_present_rep);
  2576. printf("n");
  2577. VAL("Maximum read  speed in kB/s", mp->max_read_speed);
  2578. VAL("Current read  speed in kB/s", mp->cur_read_speed);
  2579. VAL("Maximum write speed in kB/s", mp->max_write_speed);
  2580. VAL("Current write speed in kB/s", mp->cur_write_speed);
  2581. VAL("Buffer size in KB", mp->buffer_size);
  2583. return; /* Generic SCSI-3/mmc CD */
  2584. }