mmc.c 47 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067
  1. /*
  2. * This file is part of the UCB release of Plan 9. It is subject to the license
  3. * terms in the LICENSE file found in the top-level directory of this
  4. * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
  5. * part of the UCB release of Plan 9, including this file, may be copied,
  6. * modified, propagated, or distributed except according to the terms contained
  7. * in the LICENSE file.
  8. */
  9. /*
  10. * multi-media commands
  11. *
  12. * as of mmc-6, mode page 0x2a (capabilities & mechanical status) is legacy
  13. * and read-only, last defined in mmc-3. mode page 5 (write parameters)
  14. * applies only to cd-r(w) and dvd-r(w); *-rom, dvd+* and bd-* are right out.
  15. */
  16. #include <u.h>
  17. #include <libc.h>
  18. #include <disk.h>
  19. #include "../scuzz/scsireq.h"
  20. #include "dat.h"
  21. #include "fns.h"
  22. enum
  23. {
  24. Desperate = 0, /* non-zero grubs around in inquiry string */
  25. Pagesz = 255,
  26. Pagerrrecov = 1, /* error recovery */
  27. Pagwrparams = 5, /* (cd|dvd)-r(w) device write parameters */
  28. Pagcache = 8,
  29. Pagcapmechsts = 0x2a,
  30. Invistrack = 0xff, /* the invisible & incomplete track */
  31. Maxresptracks = 120, /* (1024-slop) / 8 */
  32. /* Pagerrrecov error control bits (buf[2]) */
  33. Erawre = 1<<7, /* recover from write errors */
  34. Erarre = 1<<6, /* recover from read errors */
  35. Ertb = 1<<5, /* transfer bad block to host */
  36. Errc = 1<<4, /* read continuous; no error recovery */
  37. Erper = 1<<2, /* post error: report recovered errors */
  38. Erdte = 1<<1, /* disable transfer on error */
  39. Erdcr = 1<<0, /* disable correction */
  40. Kilo = 1000LL,
  41. GB = Kilo * Kilo * Kilo,
  42. };
  43. typedef struct Intfeat Intfeat;
  44. typedef struct Mmcaux Mmcaux;
  45. static Dev mmcdev;
  46. struct Mmcaux {
  47. /* drive characteristics */
  48. uint8_t page05[Pagesz]; /* write parameters */
  49. int page05ok;
  50. int pagecmdsz;
  51. /* disc characteristics */
  52. int32_t mmcnwa; /* next writable address (block #) */
  53. int nropen;
  54. int nwopen;
  55. int64_t ntotby;
  56. int32_t ntotbk;
  57. };
  58. struct Intfeat {
  59. int numb;
  60. char *name;
  61. };
  62. enum {
  63. Featrandwrite = 0x20,
  64. Featdfctmgmt = 0x24,
  65. Featwriteonce = 0x25,
  66. Featedfctrpt = 0x29,
  67. Featdvdrw = 0x2a,
  68. };
  69. Intfeat intfeats[] = {
  70. Featrandwrite, "random writable", /* for write-and-verify */
  71. // 0x21, "incr. streaming writable",
  72. Featdfctmgmt, "hw defect mgmt.",
  73. Featwriteonce, "write once", /* for write-and-verify */
  74. Featedfctrpt, "enhanced defect reporting",
  75. Featdvdrw, "dvd+rw", /* for dvd write-and-verify */
  76. 0x38, "pseudo-overwrite",
  77. // 0x40, "bd read",
  78. // 0x41, "bd write",
  79. };
  80. /* these will be printed as user ids, so no spaces please */
  81. static char *dvdtype[] = {
  82. "dvd-rom",
  83. "dvd-ram",
  84. "dvd-r",
  85. "dvd-rw",
  86. "hd-dvd-rom",
  87. "hd-dvd-ram",
  88. "hd-dvd-r",
  89. "type-7-unknown",
  90. "type-8-unknown",
  91. "dvd+rw",
  92. "dvd+r",
  93. "type-11-unknown",
  94. "type-12-unknown",
  95. "dvd+rw-dl",
  96. "dvd+r-dl",
  97. "type-15-unknown",
  98. };
  99. static int format(Drive *drive);
  100. static int getinvistrack(Drive *drive);
  101. static uint32_t
  102. bige(void *p)
  103. {
  104. uint8_t *a;
  105. a = p;
  106. return (a[0]<<24)|(a[1]<<16)|(a[2]<<8)|(a[3]<<0);
  107. }
  108. uint32_t
  109. getnwa(Drive *drive)
  110. {
  111. Mmcaux *aux;
  112. aux = drive->aux;
  113. return aux->mmcnwa;
  114. }
  115. static void
  116. initcdb(uint8_t *cdb, int len, int cmd)
  117. {
  118. memset(cdb, 0, len);
  119. cdb[0] = cmd;
  120. }
  121. /*
  122. * SCSI CDBs (cmd arrays) are 6, 10, 12, 16 or 32 bytes long.
  123. * The mode sense/select commands implicitly refer to
  124. * a mode parameter list, which consists of an 8-byte
  125. * mode parameter header, followed by zero or more block
  126. * descriptors and zero or more mode pages (MMC-2 §5.5.2).
  127. * We'll ignore mode sub-pages.
  128. * Integers are stored big-endian.
  129. *
  130. * The format of the mode parameter (10) header is:
  131. * ushort mode_data_length; // of following bytes
  132. * unsigned char medium_type;
  133. * unsigned char device_specific;
  134. * unsigned char reserved[2];
  135. * ushort block_descriptor_length; // zero
  136. *
  137. * The format of the mode parameter (6) header is:
  138. * unsigned char mode_data_length; // of following bytes
  139. * unsigned char medium_type;
  140. * unsigned char device_specific;
  141. * unsigned char block_descriptor_length; // zero
  142. *
  143. * The format of the mode pages is:
  144. * unsigned char page_code_and_PS;
  145. * unsigned char page_len; // of following bytes
  146. * unsigned char parameter[page_len];
  147. *
  148. * see SPC-3 §4.3.4.6 for allocation length and §7.4 for mode parameter lists.
  149. */
  150. enum {
  151. Mode10parmhdrlen= 8,
  152. Mode6parmhdrlen = 4,
  153. Modepaghdrlen = 2,
  154. };
  155. static int
  156. mmcgetpage10(Drive *drive, int page, void *v)
  157. {
  158. uint8_t cmd[10], resp[512];
  159. int n, r;
  160. initcdb(cmd, sizeof cmd, ScmdMsense10);
  161. cmd[2] = page;
  162. cmd[8] = 255; /* allocation length: buffer size */
  163. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  164. if(n < Mode10parmhdrlen)
  165. return -1;
  166. r = (resp[6]<<8) | resp[7]; /* block descriptor length */
  167. n -= Mode10parmhdrlen + r;
  168. if(n < 0)
  169. return -1;
  170. if(n > Pagesz)
  171. n = Pagesz;
  172. memmove(v, &resp[Mode10parmhdrlen + r], n);
  173. return n;
  174. }
  175. static int
  176. mmcgetpage6(Drive *drive, int page, void *v)
  177. {
  178. uint8_t cmd[6], resp[512];
  179. int n;
  180. initcdb(cmd, sizeof cmd, ScmdMsense6);
  181. cmd[2] = page;
  182. cmd[4] = 255; /* allocation length */
  183. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  184. if(n < Mode6parmhdrlen)
  185. return -1;
  186. n -= Mode6parmhdrlen + resp[3];
  187. if(n < 0)
  188. return -1;
  189. if(n > Pagesz)
  190. n = Pagesz;
  191. memmove(v, &resp[Mode6parmhdrlen + resp[3]], n);
  192. return n;
  193. }
  194. static int
  195. mmcsetpage10(Drive *drive, int page, void *v)
  196. {
  197. uint8_t cmd[10], *p, *pagedata;
  198. int len, n;
  199. /* allocate parameter list, copy in mode page, fill in header */
  200. pagedata = v;
  201. assert(pagedata[0] == page);
  202. len = Mode10parmhdrlen + Modepaghdrlen + pagedata[1];
  203. p = emalloc(len);
  204. memmove(p + Mode10parmhdrlen, pagedata, pagedata[1]);
  205. /* parameter list header */
  206. p[0] = 0;
  207. p[1] = len - 2;
  208. /* set up CDB */
  209. initcdb(cmd, sizeof cmd, ScmdMselect10);
  210. cmd[1] = 0x10; /* format not vendor-specific */
  211. cmd[8] = len;
  212. n = scsi(&drive->scsi, cmd, sizeof(cmd), p, len, Swrite);
  213. free(p);
  214. if(n < len)
  215. return -1;
  216. return 0;
  217. }
  218. static int
  219. mmcsetpage6(Drive *drive, int page, void *v)
  220. {
  221. uint8_t cmd[6], *p, *pagedata;
  222. int len, n;
  223. if (vflag)
  224. print("mmcsetpage6 called!\n");
  225. pagedata = v;
  226. assert(pagedata[0] == page);
  227. len = Mode6parmhdrlen + Modepaghdrlen + pagedata[1];
  228. p = emalloc(len);
  229. memmove(p + Mode6parmhdrlen, pagedata, pagedata[1]);
  230. initcdb(cmd, sizeof cmd, ScmdMselect6);
  231. cmd[1] = 0x10; /* format not vendor-specific */
  232. cmd[4] = len;
  233. n = scsi(&drive->scsi, cmd, sizeof(cmd), p, len, Swrite);
  234. free(p);
  235. if(n < len)
  236. return -1;
  237. return 0;
  238. }
  239. static int
  240. mmcgetpage(Drive *drive, int page, void *v)
  241. {
  242. Mmcaux *aux;
  243. aux = drive->aux;
  244. switch(aux->pagecmdsz) {
  245. case 10:
  246. return mmcgetpage10(drive, page, v);
  247. case 6:
  248. return mmcgetpage6(drive, page, v);
  249. default:
  250. assert(0);
  251. }
  252. return -1;
  253. }
  254. static int
  255. mmcsetpage(Drive *drive, int page, void *v)
  256. {
  257. Mmcaux *aux;
  258. aux = drive->aux;
  259. switch(aux->pagecmdsz) {
  260. case 10:
  261. return mmcsetpage10(drive, page, v);
  262. case 6:
  263. return mmcsetpage6(drive, page, v);
  264. default:
  265. assert(0);
  266. }
  267. return -1;
  268. }
  269. int
  270. mmcstatus(Drive *drive)
  271. {
  272. uint8_t cmd[12];
  273. initcdb(cmd, sizeof cmd, ScmdCDstatus); /* mechanism status */
  274. return scsi(&drive->scsi, cmd, sizeof(cmd), nil, 0, Sread);
  275. }
  276. void
  277. mmcgetspeed(Drive *drive)
  278. {
  279. int n, maxread, curread, maxwrite, curwrite;
  280. uint8_t buf[Pagesz];
  281. memset(buf, 0, 22);
  282. n = mmcgetpage(drive, Pagcapmechsts, buf); /* legacy page */
  283. if (n < 22) {
  284. if (vflag)
  285. fprint(2, "no Pagcapmechsts mode page!\n");
  286. return;
  287. }
  288. maxread = (buf[8]<<8)|buf[9];
  289. curread = (buf[14]<<8)|buf[15];
  290. maxwrite = (buf[18]<<8)|buf[19];
  291. curwrite = (buf[20]<<8)|buf[21];
  292. if(maxread && maxread < 170 || curread && curread < 170)
  293. return; /* bogus data */
  294. drive->readspeed = curread;
  295. drive->writespeed = curwrite;
  296. drive->maxreadspeed = maxread;
  297. drive->maxwritespeed = maxwrite;
  298. }
  299. static int
  300. getdevtype(Drive *drive)
  301. {
  302. int n;
  303. uint8_t cmd[6], resp[Pagesz];
  304. initcdb(cmd, sizeof cmd, ScmdInq);
  305. cmd[3] = sizeof resp >> 8;
  306. cmd[4] = sizeof resp;
  307. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof resp, Sread);
  308. if (n < 8)
  309. return -1;
  310. return resp[0] & 037;
  311. }
  312. static int
  313. start(Drive *drive, int code)
  314. {
  315. uint8_t cmd[6];
  316. initcdb(cmd, sizeof cmd, ScmdStart);
  317. cmd[4] = code;
  318. return scsi(&drive->scsi, cmd, sizeof(cmd), cmd, 0, Snone);
  319. }
  320. static int
  321. setcaching(Drive *drive)
  322. {
  323. int n;
  324. uint8_t buf[Pagesz];
  325. /*
  326. * we can't actually control caching much.
  327. * see SBC-2 §6.3.3 but also MMC-6 §7.6.
  328. *
  329. * should set read ahead, MMC-6 §6.37; seems to control caching.
  330. */
  331. n = mmcgetpage(drive, Pagcache, buf);
  332. if (n < 3)
  333. return -1;
  334. /* n == 255; buf[1] == 10 (10 bytes after buf[1]) */
  335. buf[0] &= 077; /* clear reserved bits, MMC-6 §7.2.3 */
  336. assert(buf[0] == Pagcache);
  337. assert(buf[1] >= 10);
  338. buf[2] = Ccwce;
  339. if (mmcsetpage(drive, Pagcache, buf) < 0) {
  340. if (vflag)
  341. print("mmcprobe: cache control NOT set\n");
  342. return -1;
  343. }
  344. return 0;
  345. }
  346. Drive*
  347. mmcprobe(Scsi *scsi)
  348. {
  349. Mmcaux *aux;
  350. Drive *drive;
  351. uint8_t buf[Pagesz];
  352. int cap;
  353. if (vflag)
  354. print("mmcprobe: inquiry: %s\n", scsi->inquire);
  355. drive = emalloc(sizeof(Drive));
  356. drive->scsi = *scsi;
  357. drive->Dev = mmcdev;
  358. drive->invistrack = -1;
  359. getinvistrack(drive);
  360. aux = emalloc(sizeof(Mmcaux));
  361. drive->aux = aux;
  362. scsiready(&drive->scsi);
  363. drive->type = getdevtype(drive);
  364. if (drive->type != TypeCD) {
  365. werrstr("not an mmc device");
  366. free(aux);
  367. free(drive);
  368. return nil;
  369. }
  370. /*
  371. * drive is an mmc device; learn what we can about it
  372. * (as opposed to the disc in it).
  373. */
  374. start(drive, 1);
  375. /* attempt to read CD capabilities page, but it's now legacy */
  376. if(mmcgetpage10(drive, Pagcapmechsts, buf) >= 0)
  377. aux->pagecmdsz = 10;
  378. else if(mmcgetpage6(drive, Pagcapmechsts, buf) >= 0)
  379. aux->pagecmdsz = 6;
  380. else {
  381. if (vflag)
  382. fprint(2, "no Pagcapmechsts mode page!\n");
  383. werrstr("can't read mode page %d!", Pagcapmechsts);
  384. free(aux);
  385. free(drive);
  386. return nil;
  387. }
  388. cap = 0;
  389. if(buf[Capwrite] & (Capcdr|Capcdrw|Capdvdr|Capdvdram) ||
  390. buf[Capmisc] & Caprw)
  391. cap |= Cwrite;
  392. if(buf[Capmisc] & Capcdda) /* CD-DA commands supported? */
  393. cap |= Ccdda; /* not used anywhere else */
  394. /* cache optional page 05 (write parameter page) */
  395. if(/* (cap & Cwrite) && */
  396. mmcgetpage(drive, Pagwrparams, aux->page05) >= 0) {
  397. aux->page05ok = 1;
  398. cap |= Cwrite;
  399. if (vflag)
  400. fprint(2, "mmcprobe: got page 5, assuming drive can write\n");
  401. } else {
  402. if (vflag)
  403. fprint(2, "no Pagwrparams mode page!\n");
  404. cap &= ~Cwrite;
  405. }
  406. drive->cap = cap;
  407. mmcgetspeed(drive);
  408. setcaching(drive);
  409. return drive;
  410. }
  411. static char *tracktype[] = { /* indices are track modes (Tm*) */
  412. "audio cdda",
  413. "2 audio channels",
  414. "2",
  415. "3",
  416. "data, recorded uninterrupted",
  417. "data, recorded interrupted",
  418. };
  419. /*
  420. * figure out the first writable block, if we can, into drive->aux->mmcnwa.
  421. * resp must be from ScmdRtrackinfo.
  422. */
  423. static int32_t
  424. gettracknwa(Drive *drive, int t, uint32_t beg, uint8_t *resp)
  425. {
  426. int32_t newnwa;
  427. Mmcaux *aux;
  428. aux = drive->aux;
  429. if(resp[7] & 1) { /* nwa valid? */
  430. newnwa = bige(&resp[12]);
  431. if (newnwa >= 0)
  432. if (aux->mmcnwa < 0)
  433. aux->mmcnwa = newnwa;
  434. else if (aux->mmcnwa != newnwa)
  435. fprint(2, "nwa is %ld but invis track starts blk %ld\n",
  436. newnwa, aux->mmcnwa);
  437. }
  438. /* resp[6] & (1<<7) of zero: invisible track */
  439. if(t == Invistrack || t == drive->invistrack)
  440. if (aux->mmcnwa < 0)
  441. aux->mmcnwa = beg;
  442. else if (aux->mmcnwa != beg)
  443. fprint(2, "invis track starts blk %ld but nwa is %ld\n",
  444. beg, aux->mmcnwa);
  445. if (vflag && aux->mmcnwa >= 0)
  446. print(" nwa %lud", aux->mmcnwa);
  447. return 0;
  448. }
  449. /*
  450. * map tmode to type & bs.
  451. */
  452. static void
  453. gettypebs(uint8_t tmode, int t, int i, int *typep, int *bsp)
  454. {
  455. int type, bs;
  456. if(vflag)
  457. print("track %d type %d (%s)", t, tmode,
  458. (tmode < nelem(tracktype)? tracktype[tmode]: "**GOK**"));
  459. type = TypeNone;
  460. bs = BScdda;
  461. switch(tmode){
  462. case Tmcdda:
  463. type = TypeAudio;
  464. bs = BScdda;
  465. break;
  466. case Tm2audio: /* 2 audio channels, with pre-emphasis 50/15 μs */
  467. if(vflag)
  468. print("audio channels with preemphasis on track %d "
  469. "(u%.3d)\n", t, i);
  470. type = TypeNone;
  471. break;
  472. case Tmunintr: /* data track, recorded uninterrupted */
  473. case Tmintr: /* data track, recorded interrupted */
  474. /* treat Tmintr (5) as cdrom; it's probably dvd or bd */
  475. type = TypeData;
  476. bs = BScdrom;
  477. break;
  478. default:
  479. if(vflag)
  480. print("unknown track type %d\n", tmode);
  481. break;
  482. }
  483. *bsp = bs;
  484. *typep = type;
  485. }
  486. /* t is a track number on disc, i is an index into drive->track[] for result */
  487. static int
  488. mmctrackinfo(Drive *drive, int t, int i)
  489. {
  490. int n, type, bs;
  491. uint32_t beg, size;
  492. uint8_t tmode;
  493. uint8_t cmd[10], resp[255];
  494. Track *track;
  495. initcdb(cmd, sizeof cmd, ScmdRtrackinfo);
  496. cmd[1] = 1; /* address below is logical track # */
  497. cmd[2] = t>>24;
  498. cmd[3] = t>>16;
  499. cmd[4] = t>>8;
  500. cmd[5] = t;
  501. cmd[7] = sizeof(resp)>>8;
  502. cmd[8] = sizeof(resp);
  503. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  504. if(n < 28) {
  505. if(vflag)
  506. print("trackinfo %d fails n=%d: %r\n", t, n);
  507. return -1;
  508. }
  509. tmode = resp[5] & 0x0D;
  510. // dmode = resp[6] & 0x0F;
  511. gettypebs(tmode, t, i, &type, &bs);
  512. beg = bige(&resp[8]);
  513. size = bige(&resp[24]);
  514. track = &drive->track[i];
  515. track->mtime = drive->changetime;
  516. track->beg = beg;
  517. track->end = beg + size;
  518. track->type = type;
  519. track->bs = bs;
  520. track->size = (int64_t)(size-2) * bs; /* -2: skip lead out */
  521. if(resp[6] & (1<<6)) { /* blank? */
  522. track->type = TypeBlank;
  523. drive->writeok = Yes;
  524. }
  525. if(vflag)
  526. print(" start %lud end %lud", beg, beg + size - 1);
  527. gettracknwa(drive, t, beg, resp);
  528. if (vflag)
  529. print("\n");
  530. return 0;
  531. }
  532. /* this may fail for blank media */
  533. static int
  534. mmcreadtoc(Drive *drive, int type, int track, void *data, int nbytes)
  535. {
  536. uint8_t cmd[10];
  537. initcdb(cmd, sizeof cmd, ScmdRTOC);
  538. cmd[1] = type; /* msf bit & reserved */
  539. cmd[2] = Tocfmttoc;
  540. cmd[6] = track; /* track/session */
  541. cmd[7] = nbytes>>8;
  542. cmd[8] = nbytes;
  543. /*
  544. * printing iounit(drive->scsi.rawfd) here yields
  545. * iounit(3) = 0; # for local access
  546. * iounit(3) = 65512; # for remote access via /mnt/term
  547. */
  548. return scsi(&drive->scsi, cmd, sizeof(cmd), data, nbytes, Sread);
  549. }
  550. static Msf
  551. rdmsf(uint8_t *p)
  552. {
  553. Msf msf;
  554. msf.m = p[0];
  555. msf.s = p[1];
  556. msf.f = p[2];
  557. return msf;
  558. }
  559. static int
  560. getdiscinfo(Drive *drive, uint8_t resp[], int resplen)
  561. {
  562. int n;
  563. uint8_t cmd[10];
  564. initcdb(cmd, sizeof cmd, ScmdRdiscinfo);
  565. cmd[7] = resplen>>8;
  566. cmd[8] = resplen;
  567. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, resplen, Sread);
  568. if(n < 24) {
  569. if(n >= 0)
  570. werrstr("rdiscinfo returns %d", n);
  571. else if (vflag)
  572. fprint(2, "read disc info failed\n");
  573. return -1;
  574. }
  575. if (vflag)
  576. fprint(2, "read disc info succeeded\n");
  577. assert((resp[2] & 0340) == 0); /* data type 0 */
  578. drive->erasable = ((resp[2] & 0x10) != 0); /* -RW? */
  579. return n;
  580. }
  581. int
  582. isbitset(uint bit, uint8_t *map)
  583. {
  584. return map[bit/8] & (1 << (bit%8));
  585. }
  586. /*
  587. * set read-write error recovery mode page 1 (10 bytes), mmc-6 §7.3.
  588. *
  589. * requires defect management feature (0x24) mmc-6 §5.3.13 (mandatory on bd,
  590. * but has to be enabled by allocating spares with FORMAT UNIT command)
  591. * or enhanced defect reporting feature (0x29) mmc-6 §5.3.17,
  592. * and they are mutually exclusive.
  593. */
  594. static int
  595. seterrrecov(Drive *drive)
  596. {
  597. int n;
  598. uint8_t buf[Pagesz];
  599. if (!isbitset(Featdfctmgmt, drive->features) &&
  600. !isbitset(Featedfctrpt, drive->features)) {
  601. fprint(2, "defect mgmt. and enhanced defect reporting disabled!\n");
  602. return -1;
  603. }
  604. n = mmcgetpage(drive, Pagerrrecov, buf);
  605. if (n < 3)
  606. return -1;
  607. /* n == 255; buf[1] == 10 (10 bytes after buf[1]) */
  608. /*
  609. * error recovery page as read:
  610. * 0: 01 (page: error recovery)
  611. * 1: 0a (length: 10)
  612. * 2: c0 (error control bits: 0300 == Erawre|Erarre)
  613. * 3: 20 (read retry count: 32)
  614. * 4: 00
  615. * 5: 00
  616. * 6: 00
  617. * 7: 00
  618. * 8: 01 (write retry count: 1)
  619. * 9: 00 00 00 (error reporting window size)
  620. */
  621. buf[0] &= ~(1<<6); /* clear reserved bit */
  622. assert((buf[0] & 077) == Pagerrrecov);
  623. assert(buf[1] >= 10);
  624. buf[2] = Erawre | Erarre; /* default: Erawre; can't set Ertb */
  625. if (isbitset(Featedfctrpt, drive->features))
  626. buf[7] = 1; /* emcdr: 1==recover, don't tell us; default 0 */
  627. // buf[3] = 32; /* rd retry count; default 32; arbitrary */
  628. // buf[8] = 1; /* wr retry count; default 1; arbitrary */
  629. // memset(buf+9, 0, 3); /* err reporting win siz: 0 == no tsr; default 0 */
  630. if (mmcsetpage(drive, Pagerrrecov, buf) < 0) {
  631. if (vflag)
  632. fprint(2, "error recovery NOT set\n");
  633. return -1;
  634. }
  635. if (vflag)
  636. fprint(2, "error recovery set\n");
  637. return 0;
  638. }
  639. char *
  640. featname(int feat)
  641. {
  642. Intfeat *ifp;
  643. for (ifp = intfeats; ifp < intfeats + nelem(intfeats); ifp++)
  644. if (feat == ifp->numb)
  645. return ifp->name;
  646. return nil;
  647. }
  648. static int
  649. prof2mmctype(Drive *drive, uint16_t prof)
  650. {
  651. if(prof == 0 || prof == 0xffff) /* none or whacko? */
  652. return -1;
  653. if(drive->mmctype != Mmcnone)
  654. return -1;
  655. switch (prof >> 4) {
  656. case 0:
  657. drive->mmctype = Mmccd;
  658. break;
  659. case 1:
  660. if (prof == 0x1a || prof == 0x1b)
  661. drive->mmctype = Mmcdvdplus;
  662. else
  663. drive->mmctype = Mmcdvdminus;
  664. break;
  665. case 2:
  666. drive->mmctype = Mmcdvdplus; /* dual layer */
  667. break;
  668. case 4:
  669. drive->mmctype = Mmcbd;
  670. if (vflag)
  671. fprint(2, "getconf profile for bd = %#x\n", prof);
  672. /*
  673. * further decode prof to set writability flags.
  674. * mostly for Pioneer BDR-206M.
  675. */
  676. drive->erasable = drive->recordable = No;
  677. switch (prof) {
  678. case 0x40:
  679. break;
  680. case 0x41:
  681. case 0x42:
  682. drive->recordable = Yes;
  683. break;
  684. case 0x43:
  685. drive->erasable = Yes;
  686. break;
  687. }
  688. break;
  689. case 5:
  690. drive->mmctype = Mmcdvdminus; /* hd dvd, obs. */
  691. break;
  692. }
  693. return 0;
  694. }
  695. static void
  696. notefeats(Drive *drive, uint8_t *p, uint32_t datalen)
  697. {
  698. int left, len;
  699. uint feat;
  700. char *ftnm;
  701. if (vflag)
  702. fprint(2, "features: ");
  703. for (left = datalen; left > 0; left -= len, p += len) {
  704. feat = p[0]<<8 | p[1];
  705. len = 4 + p[3];
  706. ftnm = featname(feat);
  707. if (vflag && ftnm)
  708. fprint(2, "%#ux (%s) curr %d\n", feat, ftnm, p[2] & 1);
  709. if (feat >= Maxfeatures) { /* could be vendor-specific */
  710. if (vflag)
  711. fprint(2, "feature %d too big for bit map\n",
  712. feat);
  713. } else if (p[2] & 1)
  714. drive->features[feat/8] |= 1 << (feat%8);
  715. }
  716. }
  717. static int
  718. getconfcmd(Drive *drive, uint8_t *resp, int respsz)
  719. {
  720. int n;
  721. uint32_t datalen;
  722. uint8_t cmd[10];
  723. initcdb(cmd, sizeof cmd, Scmdgetconf);
  724. cmd[3] = 0; /* start with profile list feature */
  725. cmd[7] = respsz >> 8;
  726. cmd[8] = respsz;
  727. n = scsi(&drive->scsi, cmd, sizeof cmd, resp, respsz, Sread);
  728. if (n < 0) {
  729. if(vflag)
  730. fprint(2, "get config cmd failed\n");
  731. return -1;
  732. }
  733. if (n < 4)
  734. return -1;
  735. datalen = GETBELONG(resp+0);
  736. if (datalen < 8)
  737. return -1;
  738. return datalen;
  739. }
  740. static int
  741. getconf(Drive *drive)
  742. {
  743. uint16_t prof;
  744. int32_t datalen;
  745. uint8_t resp[64*1024 - 8]; /* 64k-8 max, 450 typical */
  746. memset(drive->features, 0, sizeof drive->features);
  747. datalen = getconfcmd(drive, resp, sizeof resp);
  748. if(datalen < 0)
  749. return -1;
  750. /*
  751. * features start with an 8-byte header:
  752. * ulong datalen, ushort reserved, ushort current profile.
  753. * profile codes (table 92) are: 0 reserved, 1-7 legacy, 8-0xf cd,
  754. * 0x10-0x1f 0x2a-0x2b dvd*, 0x40-0x4f bd, 0x50-0x5f hd dvd,
  755. * 0xffff whacko.
  756. *
  757. * this is followed by multiple feature descriptors:
  758. * ushort code, unsigned char bits, unsigned char addnl_len, addnl_len bytes.
  759. */
  760. prof = resp[6]<<8 | resp[7];
  761. if (prof2mmctype(drive, prof) < 0)
  762. return datalen;
  763. /*
  764. * for bd-r, establish non-default recording mode before first write,
  765. * with FORMAT UNIT command to allocate spares (BD MMC set
  766. * description, v1.1, §4.4.4).
  767. */
  768. if (drive->mmctype == Mmcbd && drive->recordable == Yes &&
  769. drive->erasable == No) {
  770. format(drive); /* no-op with error if already been done */
  771. /* read config again, now that bd-r has spares */
  772. datalen = getconfcmd(drive, resp, sizeof resp);
  773. if(datalen < 0)
  774. return -1;
  775. }
  776. /* skip header to find feature list */
  777. notefeats(drive, resp + 8, datalen - 8);
  778. if (drive->mmctype == Mmcbd)
  779. seterrrecov(drive);
  780. return datalen;
  781. }
  782. static int
  783. getdvdstruct(Drive *drive)
  784. {
  785. int n, cat;
  786. uint8_t cmd[12], resp[Pagesz];
  787. initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */
  788. cmd[1] = 0; /* media type: dvd */
  789. cmd[7] = 0; /* format code: physical format */
  790. cmd[8] = sizeof resp >> 8; /* allocation length */
  791. cmd[9] = sizeof resp;
  792. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof resp, Sread);
  793. if (n < 7) {
  794. if(vflag)
  795. fprint(2, "read disc structure (dvd) cmd failed\n");
  796. return -1;
  797. }
  798. /* resp[0..1] is resp length */
  799. cat = (resp[4] & 0xf0) >> 4; /* disk category, MMC-6 §6.22.3.2.1 */
  800. if (vflag)
  801. fprint(2, "dvd type is %s\n", dvdtype[cat]);
  802. drive->dvdtype = dvdtype[cat];
  803. /* write parameters mode page may suffice to compute writeok for dvd */
  804. drive->erasable = drive->recordable = No;
  805. /*
  806. * the layer-type field is a *bit array*,
  807. * though an enumeration of types would make more sense,
  808. * since the types are exclusive, not orthogonal.
  809. */
  810. if (resp[6] & (1<<2)) /* rewritable? */
  811. drive->erasable = Yes;
  812. else if (resp[6] & (1<<1)) /* recordable once? */
  813. drive->recordable = Yes;
  814. /* else it's a factory-pressed disk */
  815. drive->mmctype = (cat >= 8? Mmcdvdplus: Mmcdvdminus);
  816. return 0;
  817. }
  818. /*
  819. * ugly hack to divine device type from inquiry string as last resort.
  820. * mostly for Pioneer BDR-206M.
  821. */
  822. static int
  823. bdguess(Drive *drive)
  824. {
  825. if (drive->mmctype == Mmcnone) {
  826. if (strstr(drive->scsi.inquire, "BD") == nil)
  827. return -1;
  828. if (vflag)
  829. fprint(2, "drive probably a BD (from inquiry string)\n");
  830. drive->mmctype = Mmcbd;
  831. } else if (drive->mmctype == Mmcbd) {
  832. if (drive->erasable != Unset && drive->recordable != Unset)
  833. return 0;
  834. } else
  835. return -1;
  836. drive->recordable = drive->writeok = No;
  837. if (strstr(drive->scsi.inquire, "RW") != nil) {
  838. if (vflag)
  839. fprint(2, "drive probably a burner (from inquiry string)\n");
  840. drive->recordable = drive->writeok = Yes;
  841. if (drive->erasable == Unset) { /* set by getdiscinfo perhaps */
  842. drive->erasable = No; /* no way to tell, alas */
  843. if (vflag)
  844. fprint(2, "\tassuming -r not -re\n");
  845. }
  846. } else {
  847. if (drive->erasable == Unset)
  848. drive->erasable = No;
  849. }
  850. if (drive->erasable == Yes)
  851. drive->recordable = No; /* mutually exclusive */
  852. return 0;
  853. }
  854. static int
  855. getbdstruct(Drive *drive)
  856. {
  857. int n;
  858. uint8_t cmd[12], resp[4+4096];
  859. uint8_t *di, *body;
  860. initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */
  861. cmd[1] = 1; /* media type: bd */
  862. /* cmd[6] is layer #, 0 is first */
  863. cmd[7] = 0; /* format code: disc info */
  864. cmd[8] = sizeof resp >> 8; /* allocation length */
  865. cmd[9] = (int8_t)sizeof resp;
  866. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof resp, Sread);
  867. if(n < 0) {
  868. if(vflag)
  869. fprint(2, "read disc structure (bd) cmd failed\n");
  870. return -1;
  871. }
  872. /*
  873. * resp[0..1] is resp length (4100); 2 & 3 are reserved.
  874. * there may be multiple disc info structs of 112 bytes each.
  875. * disc info (di) starts at 4. di[0..7] are header, followed by body.
  876. * body[0..2] is bd type (disc type identifier):
  877. * BDO|BDW|BDR, MMC-6 §6.22.3.3.1. The above scsi command should
  878. * fail on DVD drives, but some seem to ignore media type
  879. * and return successfully, so verify that it's a BD drive.
  880. */
  881. di = resp + 4;
  882. body = di + 8;
  883. n -= 4 + 8;
  884. if (n < 3 || di[0] != 'D' || di[1] != 'I' ||
  885. body[0] != 'B' || body[1] != 'D') {
  886. if(vflag)
  887. fprint(2, "it's not a bd\n");
  888. return -1;
  889. }
  890. if (vflag)
  891. fprint(2, "read disc structure (bd) succeeded; di format %d\n",
  892. di[2]);
  893. drive->erasable = drive->recordable = No;
  894. switch (body[2]) {
  895. case 'O': /* read-Only */
  896. break;
  897. case 'R': /* Recordable */
  898. drive->recordable = Yes;
  899. break;
  900. case 'W': /* reWritable */
  901. drive->erasable = Yes;
  902. break;
  903. default:
  904. fprint(2, "%s: unknown bd type BD%c\n", argv0, body[2]);
  905. return -1;
  906. }
  907. /* printed getbdstruct: di bytes 98 di units/layers 32 */
  908. // fprint(2, "getbdstruct: di bytes %d di units/layers %d\n", di[6], di[3]);
  909. drive->mmctype = Mmcbd;
  910. return 0;
  911. }
  912. /*
  913. * infer endings from the beginnings of other tracks.
  914. */
  915. static int
  916. mmcinfertracks(Drive *drive, int first, int last)
  917. {
  918. int i;
  919. uint8_t resp[1024];
  920. uint32_t tot;
  921. Track *t;
  922. if (vflag)
  923. fprint(2, "inferring tracks from toc\n");
  924. for(i = first; i <= last; i++) {
  925. memset(resp, 0, sizeof(resp));
  926. if(mmcreadtoc(drive, 0, i, resp, sizeof(resp)) < 0) {
  927. last = i - 1;
  928. if (last < 1)
  929. last = 1;
  930. break;
  931. }
  932. t = &drive->track[i-first];
  933. t->mtime = drive->changetime;
  934. t->type = TypeData;
  935. t->bs = BScdrom;
  936. t->beg = bige(resp+8);
  937. if(!(resp[5] & 4)) {
  938. t->type = TypeAudio;
  939. t->bs = BScdda;
  940. }
  941. }
  942. if((int32_t)drive->track[0].beg < 0) /* i've seen negative track 0's */
  943. drive->track[0].beg = 0;
  944. tot = 0;
  945. memset(resp, 0, sizeof(resp));
  946. /* 0xAA is lead-out */
  947. if(mmcreadtoc(drive, 0, 0xAA, resp, sizeof(resp)) < 0)
  948. print("bad mmcreadtoc\n");
  949. if(resp[6])
  950. tot = bige(resp+8);
  951. t = nil;
  952. for(i=last; i>=first; i--) {
  953. t = &drive->track[i-first];
  954. t->end = tot;
  955. tot = t->beg;
  956. if(t->end <= t->beg)
  957. t->beg = t->end = 0;
  958. /* -2: skip lead out */
  959. t->size = (t->end - t->beg - 2) * (int64_t)t->bs;
  960. }
  961. fprint(2, "infertracks: nwa should be %,lld; tot = %,ld\n", t->size, tot);
  962. return last;
  963. }
  964. static void
  965. initdrive(Drive *drive)
  966. {
  967. int i;
  968. Mmcaux *aux;
  969. drive->ntrack = 0;
  970. drive->nameok = 0;
  971. drive->nchange = drive->scsi.nchange;
  972. drive->changetime = drive->scsi.changetime;
  973. drive->writeok = No;
  974. drive->erasable = drive->recordable = Unset;
  975. drive->laysfx = nil;
  976. getinvistrack(drive);
  977. aux = drive->aux;
  978. aux->mmcnwa = -1;
  979. aux->nropen = aux->nwopen = 0;
  980. aux->ntotby = aux->ntotbk = 0;
  981. for(i=0; i<nelem(drive->track); i++){
  982. memset(&drive->track[i].mbeg, 0, sizeof(Msf));
  983. memset(&drive->track[i].mend, 0, sizeof(Msf));
  984. }
  985. }
  986. static int32_t
  987. computenwa(Drive *drive, int first, int last)
  988. {
  989. int i;
  990. uint32_t nwa;
  991. Track *t;
  992. /*
  993. * work through the tracks in reverse order (last to first).
  994. * assume last is the to-be-written invisible track.
  995. */
  996. nwa = 0;
  997. for(i=last-1; i>=first; i--) {
  998. t = &drive->track[i-first];
  999. nwa += t->end - t->beg;
  1000. }
  1001. return nwa;
  1002. }
  1003. static int
  1004. findntracks(Drive *drive, int *firstp, int *lastp)
  1005. {
  1006. int i, n, first, last;
  1007. uint8_t resp[1024];
  1008. if((n = mmcreadtoc(drive, Msfbit, 0, resp, sizeof(resp))) < 4) {
  1009. /*
  1010. * it could be a blank disc. in case it's a blank disc in a
  1011. * cd-rw drive, use readdiscinfo to try to find the track info.
  1012. */
  1013. if(getdiscinfo(drive, resp, sizeof(resp)) < 7)
  1014. return -1;
  1015. assert((resp[2] & 0340) == 0); /* data type 0 */
  1016. if(resp[4] != 1)
  1017. print("multi-session disc %d\n", resp[4]);
  1018. drive->writeok = Yes;
  1019. /*
  1020. * some drives (e.g., LG's BDs) report only 1 track on an
  1021. * unfinalized disc, so probe every track. the nwa reported
  1022. * by such drives may be wrong (e.g., 0), so compute that too.
  1023. */
  1024. first = resp[3];
  1025. last = resp[6];
  1026. if(vflag)
  1027. print("rdiscinfo tracks %d-%d (last==1 means TBD)\n",
  1028. first, last);
  1029. if(last == 1)
  1030. last = Maxresptracks; /* probe the tracks */
  1031. } else {
  1032. first = resp[2];
  1033. last = resp[3];
  1034. if(vflag)
  1035. print("toc tracks %d-%d (last==1 means TBD)\n",
  1036. first, last);
  1037. if(last == 1)
  1038. last = Maxresptracks; /* probe the tracks */
  1039. if(n >= 4+8*(last-first+2)) {
  1040. /* resp[4 + i*8 + 2] is track # */
  1041. /* <=: track[last-first+1] = end */
  1042. for(i=0; i<=last-first+1; i++)
  1043. drive->track[i].mbeg = rdmsf(resp+4+i*8+5);
  1044. for(i=0; i<last-first+1; i++)
  1045. drive->track[i].mend = drive->track[i+1].mbeg;
  1046. }
  1047. }
  1048. *firstp = first;
  1049. *lastp = last;
  1050. return 0;
  1051. }
  1052. /* needs drive->mmctype to be already set */
  1053. static int
  1054. alltrackinfo(Drive *drive, int first, int last)
  1055. {
  1056. int i;
  1057. int32_t nwa;
  1058. int64_t cap;
  1059. char *osfx;
  1060. Mmcaux *aux;
  1061. Track *track;
  1062. for(i = first; i <= last; i++)
  1063. if (mmctrackinfo(drive, i, i - first) < 0) {
  1064. last = i - 1;
  1065. if (last < 1)
  1066. last = 1;
  1067. break;
  1068. }
  1069. track = &drive->track[last - first];
  1070. drive->end = track->end;
  1071. if (drive->mmctype == Mmcbd) {
  1072. /* allow for lower apparent capacity due to reserved spares */
  1073. cap = (int64_t)track->end * track->bs;
  1074. osfx = drive->laysfx;
  1075. if (cap >= (int64_t)101*GB)
  1076. drive->laysfx = "-ql"; /* 128GB nominal */
  1077. else if (cap >= (int64_t)51*GB)
  1078. drive->laysfx = "-tl"; /* 100GB nominal */
  1079. else if (cap >= (int64_t)26*GB)
  1080. drive->laysfx = "-dl"; /* 50GB nominal */
  1081. else
  1082. drive->laysfx = ""; /* 25GB nominal */
  1083. if (vflag)
  1084. fprint(2, "capacity %,lud sectors (%,lld bytes); bd%s\n",
  1085. track->end, cap, drive->laysfx);
  1086. if (osfx == nil || strcmp(osfx, drive->laysfx) != 0)
  1087. drive->relearn = 1;
  1088. }
  1089. if (drive->mmctype == Mmcnone)
  1090. return last; /* no disc */
  1091. nwa = computenwa(drive, first, last);
  1092. aux = drive->aux;
  1093. if (vflag)
  1094. fprint(2, "nwa from drive %,ld; computed nwa %,ld\n",
  1095. aux->mmcnwa, nwa);
  1096. if (aux->mmcnwa == -1 && nwa == 0)
  1097. return last; /* probably a blank disc */
  1098. if (aux->mmcnwa == -1)
  1099. fprint(2, "%s: disc is full\n", argv0);
  1100. /* reconcile differing nwas */
  1101. if (aux->mmcnwa != nwa) {
  1102. fprint(2, "%s: nwa from drive %,ld != computed nwa %,ld\n",
  1103. argv0, aux->mmcnwa, nwa);
  1104. fprint(2, "\tbe careful! assuming computed nwa\n");
  1105. /* the invisible track may still start at the old nwa. */
  1106. // aux->mmcnwa = nwa;
  1107. }
  1108. return last;
  1109. }
  1110. static int
  1111. findtracks(Drive *drive, int first, int last)
  1112. {
  1113. if(first == 0 && last == 0)
  1114. first = 1;
  1115. if(first <= 0 || first >= Maxtrack) {
  1116. werrstr("first table %d not in range", first);
  1117. return -1;
  1118. }
  1119. if(last <= 0 || last >= Maxtrack) {
  1120. werrstr("last table %d not in range", last);
  1121. return -1;
  1122. }
  1123. if(!(drive->cap & Cwrite))
  1124. last = mmcinfertracks(drive, first, last);
  1125. else
  1126. last = alltrackinfo(drive, first, last);
  1127. drive->firsttrack = first;
  1128. drive->ntrack = last+1-first;
  1129. if (vflag)
  1130. fprint(2, "this time for sure: first %d last %d\n", first, last);
  1131. return 0;
  1132. }
  1133. static void
  1134. finddisctype(Drive *drive, int first, int last)
  1135. {
  1136. char *ty;
  1137. /* deduce disc type */
  1138. drive->mmctype = Mmcnone;
  1139. drive->dvdtype = nil;
  1140. getdvdstruct(drive);
  1141. getconf(drive);
  1142. getbdstruct(drive);
  1143. if (Desperate)
  1144. bdguess(drive);
  1145. if (drive->mmctype == Mmcnone)
  1146. drive->mmctype = Mmccd; /* by default */
  1147. if (drive->recordable == Yes || drive->erasable == Yes)
  1148. drive->writeok = Yes;
  1149. if (vflag) {
  1150. fprint(2, "writeok %d", drive->writeok);
  1151. if (drive->recordable != Unset)
  1152. fprint(2, " recordable %d", drive->recordable);
  1153. if (drive->erasable != Unset)
  1154. fprint(2, " erasable %d", drive->erasable);
  1155. fprint(2, "\n");
  1156. fprint(2, "first %d last ", first);
  1157. if (last == Maxresptracks)
  1158. print("TBD\n");
  1159. else
  1160. print("%d\n", last);
  1161. ty = disctype(drive);
  1162. fprint(2, "it's a %s disc.", ty);
  1163. free(ty);
  1164. if (drive->mmctype == Mmcbd && drive->laysfx == nil)
  1165. fprint(2, " (number of layers isn't known yet.)");
  1166. fprint(2, "\n\n");
  1167. }
  1168. }
  1169. /* this gets called a lot from main.c's 9P routines */
  1170. static int
  1171. mmcgettoc(Drive *drive)
  1172. {
  1173. int first, last;
  1174. uint8_t resp[1024];
  1175. /*
  1176. * if someone has swapped the cd,
  1177. * mmcreadtoc will get ``medium changed'' and the scsi routines
  1178. * will set nchange and changetime in the scsi device.
  1179. */
  1180. mmcreadtoc(drive, 0, 0, resp, sizeof(resp));
  1181. if(drive->scsi.changetime == 0) { /* no media present */
  1182. drive->mmctype = Mmcnone;
  1183. drive->ntrack = 0;
  1184. return 0;
  1185. }
  1186. /*
  1187. * if the disc doesn't appear to be have been changed, and there
  1188. * is a disc in this drive, there's nothing to do (the common case).
  1189. */
  1190. if(drive->nchange == drive->scsi.nchange && drive->changetime != 0 &&
  1191. !drive->relearn)
  1192. return 0;
  1193. drive->relearn = 0;
  1194. /*
  1195. * the disc in the drive may have just been changed,
  1196. * so rescan it and relearn all about it.
  1197. */
  1198. if (vflag &&
  1199. (drive->nchange != drive->scsi.nchange || drive->changetime == 0))
  1200. fprint(2, "\nnew disc in drive\n");
  1201. initdrive(drive);
  1202. if (findntracks(drive, &first, &last) < 0)
  1203. return -1;
  1204. /*
  1205. * we would like to call findtracks before finddisctype so that
  1206. * we can format bd-rs at the right capacity with explicit spares
  1207. * ratio given, but findtracks needs the disc type to be already set.
  1208. * format is called from getconf from finddisctype before getbdstruct.
  1209. * luckily, FORMAT UNIT (thus format()) doesn't seem to care when we
  1210. * don't provide an explicit spares ratio.
  1211. */
  1212. /* calls getdvdstruct, getconf and getbdstruct, in that order */
  1213. finddisctype(drive, first, last); /* formats bds at first use */
  1214. return findtracks(drive, first, last);
  1215. }
  1216. static void
  1217. settrkmode(uint8_t *p, int mode)
  1218. {
  1219. p[Wptrkmode] &= ~0xf;
  1220. p[Wptrkmode] |= mode;
  1221. }
  1222. /*
  1223. * this uses page 5, which is optional.
  1224. */
  1225. static int
  1226. mmcsetbs(Drive *drive, int bs)
  1227. {
  1228. uint8_t *p;
  1229. Mmcaux *aux;
  1230. aux = drive->aux;
  1231. if (!aux->page05ok)
  1232. return 0; /* harmless; assume 2k */
  1233. p = aux->page05;
  1234. /*
  1235. * establish defaults.
  1236. */
  1237. p[0] &= 077; /* clear reserved bits, MMC-6 §7.2.3 */
  1238. p[Wpwrtype] = Bufe | Wttrackonce;
  1239. // if(testonlyflag)
  1240. // p[Wpwrtype] |= 0x10; /* test-write */
  1241. /* assume dvd values as defaults */
  1242. settrkmode(p, Tmintr);
  1243. p[Wptrkmode] |= Msnext;
  1244. p[Wpdatblktype] = Db2kdata;
  1245. p[Wpsessfmt] = Sfdata;
  1246. switch(drive->mmctype) {
  1247. case Mmcdvdplus:
  1248. case Mmcbd:
  1249. break;
  1250. case Mmcdvdminus:
  1251. /* dvd-r can only do disc-at-once or incremental */
  1252. p[Wpwrtype] = Bufe | Wtsessonce;
  1253. break;
  1254. case Mmccd:
  1255. settrkmode(p, Tmunintr); /* data track, uninterrupted */
  1256. switch(bs){
  1257. case BScdda:
  1258. /* 2 audio channels without pre-emphasis */
  1259. settrkmode(p, Tmcdda); /* should be Tm2audio? */
  1260. p[Wpdatblktype] = Dbraw;
  1261. break;
  1262. case BScdrom:
  1263. break;
  1264. case BScdxa:
  1265. p[Wpdatblktype] = Db2336;
  1266. p[Wpsessfmt] = Sfcdxa;
  1267. break;
  1268. default:
  1269. fprint(2, "%s: unknown CD type; bs %d\n", argv0, bs);
  1270. assert(0);
  1271. }
  1272. break;
  1273. default:
  1274. fprint(2, "%s: unknown disc sub-type %d\n",
  1275. argv0, drive->mmctype);
  1276. break;
  1277. }
  1278. if(mmcsetpage(drive, Pagwrparams, p) < 0) {
  1279. if (vflag)
  1280. fprint(2, "mmcsetbs: could NOT set write parameters page\n");
  1281. return -1;
  1282. }
  1283. return 0;
  1284. }
  1285. /*
  1286. * `read cd' only works for CDs; for everybody else,
  1287. * we'll try plain `read (12)'. only use read cd if it's
  1288. * a cd drive with a cd in it and we're not reading data
  1289. * (e.g., reading audio).
  1290. */
  1291. static int
  1292. fillread12cdb(Drive *drive, uint8_t *cmd, int32_t nblock, uint32_t off,
  1293. int bs)
  1294. {
  1295. if (drive->type == TypeCD && drive->mmctype == Mmccd && bs != BScdrom) {
  1296. initcdb(cmd, 12, ScmdReadcd);
  1297. cmd[6] = nblock>>16;
  1298. cmd[7] = nblock>>8;
  1299. cmd[8] = nblock>>0;
  1300. cmd[9] = 0x10;
  1301. switch(bs){
  1302. case BScdda:
  1303. cmd[1] = 0x04;
  1304. break;
  1305. case BScdrom:
  1306. cmd[1] = 0x08;
  1307. break;
  1308. case BScdxa:
  1309. cmd[1] = 0x0C;
  1310. break;
  1311. default:
  1312. werrstr("unknown bs %d", bs);
  1313. return -1;
  1314. }
  1315. } else { /* e.g., TypeDA */
  1316. initcdb(cmd, 12, ScmdRead12);
  1317. cmd[6] = nblock>>24;
  1318. cmd[7] = nblock>>16;
  1319. cmd[8] = nblock>>8;
  1320. cmd[9] = nblock;
  1321. // cmd[10] = 0x80; /* streaming */
  1322. }
  1323. cmd[2] = off>>24;
  1324. cmd[3] = off>>16;
  1325. cmd[4] = off>>8;
  1326. cmd[5] = off>>0;
  1327. return 0;
  1328. }
  1329. /* off is a block number */
  1330. static int32_t
  1331. mmcread(Buf *buf, void *v, int32_t nblock, uint32_t off)
  1332. {
  1333. int bs;
  1334. int32_t n, nn;
  1335. uint8_t cmd[12];
  1336. Drive *drive;
  1337. Otrack *o;
  1338. o = buf->otrack;
  1339. drive = o->drive;
  1340. bs = o->track->bs;
  1341. off += o->track->beg;
  1342. if(nblock >= (1<<10)) {
  1343. werrstr("mmcread too big");
  1344. if(vflag)
  1345. fprint(2, "mmcread too big\n");
  1346. return -1;
  1347. }
  1348. /* truncate nblock modulo size of track */
  1349. if(off > o->track->end - 2) {
  1350. werrstr("read past end of track");
  1351. if(vflag)
  1352. fprint(2, "end of track (%ld->%ld off %ld)",
  1353. o->track->beg, o->track->end - 2, off);
  1354. return -1;
  1355. }
  1356. if(off == o->track->end - 2)
  1357. return 0;
  1358. if(off+nblock > o->track->end - 2)
  1359. nblock = o->track->end - 2 - off;
  1360. if (fillread12cdb(drive, cmd, nblock, off, bs) < 0)
  1361. return -1;
  1362. n = nblock*bs;
  1363. nn = scsi(&drive->scsi, cmd, sizeof(cmd), v, n, Sread);
  1364. if(nn != n) {
  1365. if(nn != -1)
  1366. werrstr("short read %ld/%ld", nn, n);
  1367. if(vflag)
  1368. print("read off %lud nblock %ld bs %d failed\n",
  1369. off, nblock, bs);
  1370. return -1;
  1371. }
  1372. return nblock;
  1373. }
  1374. static Otrack*
  1375. mmcopenrd(Drive *drive, int trackno)
  1376. {
  1377. Otrack *o;
  1378. Mmcaux *aux;
  1379. if(trackno < 0 || trackno >= drive->ntrack) {
  1380. werrstr("track number out of range");
  1381. return nil;
  1382. }
  1383. aux = drive->aux;
  1384. if(aux->nwopen) {
  1385. werrstr("disk in use for writing");
  1386. return nil;
  1387. }
  1388. o = emalloc(sizeof(Otrack));
  1389. o->drive = drive;
  1390. o->track = &drive->track[trackno];
  1391. o->nchange = drive->nchange;
  1392. o->omode = OREAD;
  1393. o->buf = bopen(mmcread, OREAD, o->track->bs, Readblock);
  1394. o->buf->otrack = o;
  1395. aux->nropen++;
  1396. return o;
  1397. }
  1398. enum {
  1399. Flhlen = 4, /* format list header length */
  1400. Fdlen = 8, /* format descriptor length */
  1401. /* format unit cdb[1] */
  1402. Formatdata = 0x10,
  1403. /* format list header [1] */
  1404. Immed = 1<<1, /* immediate return, don't wait */
  1405. /* format descriptor [4] */
  1406. Fmtfull = 0,
  1407. Fullbdrsrm = 0, /* sequential */
  1408. Fullbdrsrmspares= 1, /* + spares for defect mgmt. */
  1409. Fullbdrrrm = 2, /* random */
  1410. Fmtbdrspares = 0x32 << 2,
  1411. Bdrsparessrmplus= 0, /* srm+pow */
  1412. Bdrsparessrmminus=1, /* srm-pow */
  1413. Bdrsparesrrm = 2, /* random */
  1414. };
  1415. static int
  1416. format(Drive *drive)
  1417. {
  1418. int setblksz;
  1419. uint32_t nblks, blksize;
  1420. uint8_t *fmtdesc;
  1421. uint8_t cmd[6], parms[Flhlen+Fdlen];
  1422. if (drive->recordable == Yes && drive->mmctype != Mmcbd) {
  1423. werrstr("don't format write-once cd or dvd media");
  1424. return -1;
  1425. }
  1426. initcdb(cmd, sizeof cmd, ScmdFormat); /* format unit */
  1427. cmd[1] = Formatdata | 1; /* mmc format code 1 */
  1428. /* parms is format list header & format descriptor */
  1429. memset(parms, 0, sizeof parms);
  1430. /* format list header */
  1431. parms[1] = Immed;
  1432. parms[3] = Fdlen;
  1433. fmtdesc = parms + Flhlen;
  1434. fmtdesc[4] = Fmtfull;
  1435. /* 0-3 are big-endian # of blocks, 5-7 format-dependent data */
  1436. nblks = 0;
  1437. blksize = BScdrom;
  1438. setblksz = 1;
  1439. switch (drive->mmctype) {
  1440. case Mmccd:
  1441. nblks = 0;
  1442. break;
  1443. case Mmcdvdplus:
  1444. /* format type 0 is optional but equiv to format type 0x26 */
  1445. fmtdesc[4] = 0x26 << 2;
  1446. nblks = (int64_t)~0ul;
  1447. blksize = 0;
  1448. break;
  1449. case Mmcbd:
  1450. /* enable BD-R defect mgmt. */
  1451. if (drive->recordable == Yes && drive->erasable == No) {
  1452. parms[1] &= ~Immed;
  1453. fmtdesc[4] |= Fullbdrsrmspares;
  1454. setblksz = 0;
  1455. }
  1456. break;
  1457. }
  1458. PUTBELONG(fmtdesc, nblks);
  1459. if (setblksz)
  1460. PUTBE24(fmtdesc + 5, blksize);
  1461. // print("format parameters:\n");
  1462. // hexdump(parms, sizeof parms);
  1463. if(vflag)
  1464. print("%lld ns: format\n", nsec());
  1465. return scsi(&drive->scsi, cmd, sizeof(cmd), parms, sizeof parms, Swrite);
  1466. }
  1467. static int
  1468. dvdcanverify(Drive *drive)
  1469. {
  1470. return (drive->mmctype == Mmcdvdplus ||
  1471. drive->mmctype == Mmcdvdminus) &&
  1472. isbitset(Featrandwrite, drive->features) &&
  1473. isbitset(Featwriteonce, drive->features) &&
  1474. isbitset(Featdvdrw, drive->features);
  1475. }
  1476. static int32_t
  1477. mmcxwrite(Otrack *o, void *v, int32_t nblk)
  1478. {
  1479. int r;
  1480. int32_t bs;
  1481. uint8_t cmd[10];
  1482. Drive *drive;
  1483. Mmcaux *aux;
  1484. assert(o->omode == OWRITE);
  1485. bs = o->track->bs;
  1486. drive = o->drive;
  1487. aux = drive->aux;
  1488. if (aux->mmcnwa == -1 && scsiready(&drive->scsi) < 0) {
  1489. werrstr("device not ready to write");
  1490. return -1;
  1491. }
  1492. if (aux->mmcnwa == -1 ||
  1493. drive->end != 0 && aux->mmcnwa + nblk > drive->end) {
  1494. werrstr("writing past last block");
  1495. return -1;
  1496. }
  1497. if (nblk <= 0)
  1498. fprint(2, "mmcxwrite: nblk %ld <= 0\n", nblk);
  1499. aux->ntotby += nblk * bs;
  1500. aux->ntotbk += nblk;
  1501. /*
  1502. * "write and verify" (ScmdExtwritever) only works on write-once media
  1503. * and not on CDs (mmc-6 §6.48.1).
  1504. */
  1505. if ((drive->mmctype == Mmcbd || dvdcanverify(drive)) &&
  1506. drive->recordable == Yes && drive->erasable == No)
  1507. initcdb(cmd, sizeof cmd, ScmdExtwritever);
  1508. else
  1509. initcdb(cmd, sizeof cmd, ScmdExtwrite); /* write (10) */
  1510. cmd[2] = aux->mmcnwa>>24;
  1511. cmd[3] = aux->mmcnwa>>16;
  1512. cmd[4] = aux->mmcnwa>>8;
  1513. cmd[5] = aux->mmcnwa;
  1514. cmd[7] = nblk>>8;
  1515. cmd[8] = nblk>>0;
  1516. if(vflag > 1)
  1517. print("%lld ns: write+verify %ld at %#lux\n",
  1518. nsec(), nblk, aux->mmcnwa);
  1519. /*
  1520. * we are using a private copy of scsi.c that doesn't retry writes
  1521. * to ensure that the write-verify command is issued exactly once.
  1522. * the drive may perform internal defect management on write errors,
  1523. * but explicit attempts to rewrite a given sector on write-once
  1524. * media are guaranteed to fail.
  1525. */
  1526. r = scsi(&drive->scsi, cmd, sizeof(cmd), v, nblk * bs, Swrite);
  1527. if (r < 0)
  1528. fprint(2, "%s: write+verify error at blk offset %,ld = "
  1529. "offset %,lld / bs %ld: %r\n",
  1530. argv0, aux->mmcnwa, (int64_t)aux->mmcnwa * bs, bs);
  1531. else
  1532. aux->mmcnwa += nblk;
  1533. return r;
  1534. }
  1535. static int32_t
  1536. mmcwrite(Buf *buf, void *v, int32_t nblk, uint32_t i)
  1537. {
  1538. return mmcxwrite(buf->otrack, v, nblk);
  1539. }
  1540. enum {
  1541. Eccblk = 128, /* sectors per ecc block */
  1542. Rsvslop = 0,
  1543. };
  1544. static int
  1545. reserve(Drive *drive, int track)
  1546. {
  1547. uint32_t sz;
  1548. uint8_t cmd[10];
  1549. initcdb(cmd, sizeof cmd, ScmdReserve);
  1550. track -= drive->firsttrack; /* switch to zero-origin */
  1551. if (track >= 0 && track < drive->ntrack)
  1552. /* .end is next sector past sz */
  1553. sz = drive->track[track].end - drive->track[track].beg - Rsvslop;
  1554. else {
  1555. sz = Eccblk;
  1556. fprint(2, "%s: reserve: track #%d out of range 0-%d\n",
  1557. argv0, track, drive->ntrack);
  1558. }
  1559. sz -= sz % Eccblk; /* round down to ecc-block multiple */
  1560. if ((int32_t)sz < 0) {
  1561. fprint(2, "%s: reserve: bogus size %lud\n", argv0, sz);
  1562. return -1;
  1563. }
  1564. cmd[1] = 0; /* no ASRV: allocate by size not lba */
  1565. PUTBELONG(cmd + 2 + 3, sz);
  1566. if (vflag)
  1567. fprint(2, "reserving %ld sectors\n", sz);
  1568. return scsi(&drive->scsi, cmd, sizeof cmd, cmd, 0, Snone);
  1569. }
  1570. static int
  1571. getinvistrack(Drive *drive)
  1572. {
  1573. int n;
  1574. uint8_t cmd[10], resp[Pagesz];
  1575. initcdb(cmd, sizeof(cmd), ScmdRtrackinfo);
  1576. cmd[1] = 1<<2 | 1; /* open; address below is logical track # */
  1577. PUTBELONG(cmd + 2, 1); /* find first open track */
  1578. cmd[7] = sizeof(resp)>>8;
  1579. cmd[8] = sizeof(resp);
  1580. n = scsi(&drive->scsi, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  1581. if(n < 4) {
  1582. if(vflag)
  1583. print("trackinfo for invis track fails n=%d: %r\n", n);
  1584. return -1;
  1585. }
  1586. if(vflag)
  1587. print("getinvistrack: track #%d session #%d\n",
  1588. resp[2], resp[3]);
  1589. drive->invistrack = resp[2];
  1590. return resp[2];
  1591. }
  1592. static Otrack*
  1593. mmccreate(Drive *drive, int type)
  1594. {
  1595. int bs;
  1596. Mmcaux *aux;
  1597. Track *t;
  1598. Otrack *o;
  1599. aux = drive->aux;
  1600. if(aux->nropen || aux->nwopen) {
  1601. werrstr("drive in use");
  1602. return nil;
  1603. }
  1604. switch(type){
  1605. case TypeAudio:
  1606. bs = BScdda;
  1607. break;
  1608. case TypeData:
  1609. bs = BScdrom;
  1610. break;
  1611. default:
  1612. werrstr("bad type %d", type);
  1613. return nil;
  1614. }
  1615. /* comment out the returns for now; it should be no big deal - geoff */
  1616. if(mmctrackinfo(drive, drive->invistrack, Maxtrack)) {
  1617. if (vflag)
  1618. fprint(2, "mmccreate: mmctrackinfo for invis track %d"
  1619. " failed: %r\n", drive->invistrack);
  1620. werrstr("disc not writable");
  1621. // return nil;
  1622. }
  1623. if(mmcsetbs(drive, bs) < 0) {
  1624. werrstr("cannot set bs mode");
  1625. // return nil;
  1626. }
  1627. if(mmctrackinfo(drive, drive->invistrack, Maxtrack)) {
  1628. if (vflag)
  1629. fprint(2, "mmccreate: mmctrackinfo for invis track %d"
  1630. " (2) failed: %r\n", drive->invistrack);
  1631. werrstr("disc not writable 2");
  1632. // return nil;
  1633. }
  1634. /* special hack for dvd-r: reserve the invisible track */
  1635. if (drive->mmctype == Mmcdvdminus && drive->writeok &&
  1636. drive->recordable == Yes && reserve(drive, drive->invistrack) < 0) {
  1637. if (vflag)
  1638. fprint(2, "mmcreate: reserving track %d for dvd-r "
  1639. "failed: %r\n", drive->invistrack);
  1640. return nil;
  1641. }
  1642. aux->ntotby = 0;
  1643. aux->ntotbk = 0;
  1644. t = &drive->track[drive->ntrack++];
  1645. t->size = 0;
  1646. t->bs = bs;
  1647. t->beg = aux->mmcnwa;
  1648. t->end = 0;
  1649. t->type = type;
  1650. drive->nameok = 0;
  1651. o = emalloc(sizeof(Otrack));
  1652. o->drive = drive;
  1653. o->nchange = drive->nchange;
  1654. o->omode = OWRITE;
  1655. o->track = t;
  1656. o->buf = bopen(mmcwrite, OWRITE, bs, Readblock);
  1657. o->buf->otrack = o;
  1658. aux->nwopen++;
  1659. if(vflag)
  1660. print("mmcinit: nwa = %#luX\n", aux->mmcnwa);
  1661. return o;
  1662. }
  1663. /*
  1664. * issue some form of close track, close session or finalize disc command.
  1665. * see The Matrix, table 252 in MMC-6 §6.3.2.3.
  1666. */
  1667. static int
  1668. mmcxclose(Drive *drive, int clf, int trackno)
  1669. {
  1670. uint8_t cmd[10];
  1671. initcdb(cmd, sizeof cmd, ScmdClosetracksess);
  1672. /* cmd[1] & 1 is the immediate bit */
  1673. cmd[2] = clf; /* close function */
  1674. if(clf == Closetrack)
  1675. cmd[5] = trackno;
  1676. return scsi(&drive->scsi, cmd, sizeof(cmd), cmd, 0, Snone);
  1677. }
  1678. /* flush drive cache, close current track */
  1679. void
  1680. mmcsynccache(Drive *drive)
  1681. {
  1682. uint8_t cmd[10];
  1683. Mmcaux *aux;
  1684. initcdb(cmd, sizeof cmd, ScmdSynccache);
  1685. /*
  1686. * this will take a long time to burn the remainder of a dvd-r
  1687. * with a reserved track covering the whole disc.
  1688. */
  1689. if (vflag) {
  1690. fprint(2, "syncing cache");
  1691. if (drive->mmctype == Mmcdvdminus && drive->writeok &&
  1692. drive->recordable == Yes)
  1693. fprint(2, "; dvd-r burning rest of track reservation, "
  1694. "will be slow");
  1695. fprint(2, "\n");
  1696. }
  1697. scsi(&drive->scsi, cmd, sizeof(cmd), cmd, 0, Snone);
  1698. if(vflag) {
  1699. aux = drive->aux;
  1700. print("mmcsynccache: bytes = %lld blocks = %ld, mmcnwa %#luX\n",
  1701. aux->ntotby, aux->ntotbk, aux->mmcnwa);
  1702. }
  1703. /*
  1704. * rsc: seems not to work on some drives.
  1705. * so ignore return code & don't issue on dvd+rw.
  1706. */
  1707. if(drive->mmctype != Mmcdvdplus || drive->erasable == No) {
  1708. if (vflag)
  1709. fprint(2, "closing invisible track %d (not dvd+rw)...\n",
  1710. drive->invistrack);
  1711. mmcxclose(drive, Closetrack, drive->invistrack);
  1712. if (vflag)
  1713. fprint(2, "... done.\n");
  1714. }
  1715. getinvistrack(drive); /* track # has probably changed */
  1716. }
  1717. /*
  1718. * close the open track `o'.
  1719. */
  1720. static void
  1721. mmcclose(Otrack *o)
  1722. {
  1723. Mmcaux *aux;
  1724. static uint8_t zero[2*BSmax];
  1725. aux = o->drive->aux;
  1726. if(o->omode == OREAD)
  1727. aux->nropen--;
  1728. else if(o->omode == OWRITE) {
  1729. aux->nwopen--;
  1730. mmcxwrite(o, zero, 2); /* write lead out */
  1731. mmcsynccache(o->drive);
  1732. o->drive->nchange = -1; /* force reread toc */
  1733. }
  1734. free(o);
  1735. }
  1736. static int
  1737. setonesess(Drive *drive)
  1738. {
  1739. uint8_t *p;
  1740. Mmcaux *aux;
  1741. /* page 5 is legacy and now read-only; see MMC-6 §7.5.4.1 */
  1742. aux = drive->aux;
  1743. if (!aux->page05ok)
  1744. return -1;
  1745. p = aux->page05;
  1746. p[Wptrkmode] &= ~Msbits;
  1747. p[Wptrkmode] |= Msnonext;
  1748. return mmcsetpage(drive, Pagwrparams, p);
  1749. }
  1750. /*
  1751. * close the current session, then finalize the disc.
  1752. */
  1753. static int
  1754. mmcfixate(Drive *drive)
  1755. {
  1756. int r;
  1757. if((drive->cap & Cwrite) == 0) {
  1758. werrstr("not a writer");
  1759. return -1;
  1760. }
  1761. drive->nchange = -1; /* force reread toc */
  1762. setonesess(drive);
  1763. /* skip explicit close session on bd-r */
  1764. if (drive->mmctype != Mmcbd || drive->erasable == Yes) {
  1765. if (vflag)
  1766. fprint(2, "closing session and maybe finalizing...\n");
  1767. r = mmcxclose(drive, Closesessfinal, 0);
  1768. if (vflag)
  1769. fprint(2, "... done.\n");
  1770. if (r < 0)
  1771. return r;
  1772. }
  1773. /*
  1774. * Closesessfinal only closes & doesn't finalize on dvd+r and bd-r.
  1775. * Closedvdrbdfinal closes & finalizes dvd+r and bd-r.
  1776. */
  1777. if ((drive->mmctype == Mmcdvdplus || drive->mmctype == Mmcbd) &&
  1778. drive->erasable == No) {
  1779. if (vflag)
  1780. fprint(2, "finalizing dvd+r or bd-r... "
  1781. "(won't print `done').\n");
  1782. return mmcxclose(drive, Closedvdrbdfinal, 0);
  1783. }
  1784. return 0;
  1785. }
  1786. static int
  1787. mmcblank(Drive *drive, int quick)
  1788. {
  1789. uint8_t cmd[12];
  1790. drive->nchange = -1; /* force reread toc */
  1791. initcdb(cmd, sizeof cmd, ScmdBlank); /* blank cd-rw media */
  1792. /* immediate bit is 0x10 */
  1793. /* cmd[1] = 0 means blank the whole disc; = 1 just the header */
  1794. cmd[1] = quick ? 0x01 : 0x00;
  1795. return scsi(&drive->scsi, cmd, sizeof(cmd), cmd, 0, Snone);
  1796. }
  1797. static char*
  1798. e(int status)
  1799. {
  1800. if(status < 0)
  1801. return geterrstr();
  1802. return nil;
  1803. }
  1804. static char*
  1805. mmcctl(Drive *drive, int argc, char **argv)
  1806. {
  1807. char *cmd;
  1808. if(argc < 1)
  1809. return nil;
  1810. cmd = argv[0];
  1811. if(strcmp(cmd, "format") == 0)
  1812. return e(format(drive));
  1813. if(strcmp(cmd, "blank") == 0)
  1814. return e(mmcblank(drive, 0));
  1815. if(strcmp(cmd, "quickblank") == 0)
  1816. return e(mmcblank(drive, 1));
  1817. if(strcmp(cmd, "eject") == 0)
  1818. return e(start(drive, 2));
  1819. if(strcmp(cmd, "ingest") == 0)
  1820. return e(start(drive, 3));
  1821. return "bad arg";
  1822. }
  1823. static char*
  1824. mmcsetspeed(Drive *drive, int r, int w)
  1825. {
  1826. char *rv;
  1827. uint8_t cmd[12];
  1828. initcdb(cmd, sizeof cmd, ScmdSetcdspeed);
  1829. cmd[2] = r>>8;
  1830. cmd[3] = r;
  1831. cmd[4] = w>>8;
  1832. cmd[5] = w;
  1833. rv = e(scsi(&drive->scsi, cmd, sizeof(cmd), nil, 0, Snone));
  1834. mmcgetspeed(drive);
  1835. return rv;
  1836. }
  1837. static Dev mmcdev = {
  1838. mmcopenrd,
  1839. mmccreate,
  1840. bufread,
  1841. bufwrite,
  1842. mmcclose,
  1843. mmcgettoc,
  1844. mmcfixate,
  1845. mmcctl,
  1846. mmcsetspeed,
  1847. };