mmc.c 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538
  1. /*
  2. * multi-media commands
  3. *
  4. * as of mmc-6, mode page 0x2a (capabilities & mechanical status) is legacy
  5. * and read-only, last defined in mmc-3. mode page 5 (write parameters)
  6. * applies only to cd-r(w) and dvd-r(w); *-rom, dvd+* and bd-* are right out.
  7. */
  8. #include <u.h>
  9. #include <libc.h>
  10. #include <disk.h>
  11. #include "../scuzz/scsireq.h"
  12. #include "dat.h"
  13. #include "fns.h"
  14. enum
  15. {
  16. Pagesz = 255,
  17. Pagwrparams = 5, /* (cd|dvd)-r(w) device write parameters */
  18. Pagcache = 8,
  19. Pagcapmechsts = 0x2a,
  20. Invistrack = 0xff, /* the invisible & incomplete track */
  21. };
  22. static Dev mmcdev;
  23. typedef struct Mmcaux Mmcaux;
  24. struct Mmcaux {
  25. /* drive characteristics */
  26. uchar page05[Pagesz]; /* write parameters */
  27. int page05ok;
  28. int pagecmdsz;
  29. /* disc characteristics */
  30. ulong mmcnwa;
  31. int nropen;
  32. int nwopen;
  33. vlong ntotby;
  34. long ntotbk;
  35. };
  36. /* these will be printed as user ids, so no spaces please */
  37. static char *dvdtype[] = {
  38. "dvd-rom",
  39. "dvd-ram",
  40. "dvd-r",
  41. "dvd-rw",
  42. "hd-dvd-rom",
  43. "hd-dvd-ram",
  44. "hd-dvd-r",
  45. "type-7-unknown",
  46. "type-8-unknown",
  47. "dvd+rw",
  48. "dvd+r",
  49. "type-11-unknown",
  50. "type-12-unknown",
  51. "dvd+rw-dl",
  52. "dvd+r-dl",
  53. "type-15-unknown",
  54. };
  55. static ulong
  56. bige(void *p)
  57. {
  58. uchar *a;
  59. a = p;
  60. return (a[0]<<24)|(a[1]<<16)|(a[2]<<8)|(a[3]<<0);
  61. }
  62. static ushort
  63. biges(void *p)
  64. {
  65. uchar *a;
  66. a = p;
  67. return (a[0]<<8) | a[1];
  68. }
  69. ulong
  70. getnwa(Drive *drive)
  71. {
  72. Mmcaux *aux;
  73. aux = drive->aux;
  74. return aux->mmcnwa;
  75. }
  76. static void
  77. hexdump(void *v, int n)
  78. {
  79. int i;
  80. uchar *p;
  81. p = v;
  82. for(i=0; i<n; i++){
  83. print("%.2ux ", p[i]);
  84. if((i%8) == 7)
  85. print("\n");
  86. }
  87. if(i%8)
  88. print("\n");
  89. }
  90. static void
  91. initcdb(uchar *cdb, int len, int cmd)
  92. {
  93. memset(cdb, 0, len);
  94. cdb[0] = cmd;
  95. }
  96. //static uchar *
  97. //newcdb(int len, int cmd)
  98. //{
  99. // uchar *cdb;
  100. //
  101. // cdb = emalloc(len);
  102. // cdb[0] = cmd;
  103. // return cdb;
  104. //}
  105. /*
  106. * SCSI CDBs (cmd arrays) are 6, 10, 12, 16 or 32 bytes long.
  107. * The mode sense/select commands implicitly refer to
  108. * a mode parameter list, which consists of an 8-byte
  109. * mode parameter header, followed by zero or more block
  110. * descriptors and zero or more mode pages (MMC-2 §5.5.2).
  111. * We'll ignore mode sub-pages.
  112. * Integers are stored big-endian.
  113. *
  114. * The format of the mode parameter (10) header is:
  115. * ushort mode_data_length; // of following bytes
  116. * uchar medium_type;
  117. * uchar device_specific;
  118. * uchar reserved[2];
  119. * ushort block_descriptor_length; // zero
  120. *
  121. * The format of the mode parameter (6) header is:
  122. * uchar mode_data_length; // of following bytes
  123. * uchar medium_type;
  124. * uchar device_specific;
  125. * uchar block_descriptor_length; // zero
  126. *
  127. * The format of the mode pages is:
  128. * uchar page_code_and_PS;
  129. * uchar page_len; // of following bytes
  130. * uchar parameter[page_len];
  131. *
  132. * see SPC-3 §4.3.4.6 for allocation length and §7.4 for mode parameter lists.
  133. */
  134. enum {
  135. Mode10parmhdrlen= 8,
  136. Mode6parmhdrlen = 4,
  137. Modepaghdrlen = 2,
  138. };
  139. static int
  140. mmcgetpage10(Drive *drive, int page, void *v)
  141. {
  142. uchar cmd[10], resp[512];
  143. int n, r;
  144. memset(cmd, 0, sizeof(cmd));
  145. cmd[0] = ScmdMsense10;
  146. cmd[2] = page;
  147. cmd[8] = 255; /* allocation length: buffer size */
  148. // print("get: sending cmd\n");
  149. // hexdump(cmd, 10);
  150. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  151. if(n < Mode10parmhdrlen)
  152. return -1;
  153. r = (resp[6]<<8) | resp[7]; /* block descriptor length */
  154. n -= Mode10parmhdrlen + r;
  155. if(n < 0)
  156. return -1;
  157. if(n > Pagesz)
  158. n = Pagesz;
  159. memmove(v, &resp[Mode10parmhdrlen + r], n);
  160. // print("get: got cmd\n");
  161. // hexdump(cmd, 10);
  162. // print("page\n");
  163. // hexdump(v, n);
  164. return n;
  165. }
  166. static int
  167. mmcgetpage6(Drive *drive, int page, void *v)
  168. {
  169. uchar cmd[6], resp[512];
  170. int n;
  171. memset(cmd, 0, sizeof(cmd));
  172. cmd[0] = ScmdMsense6;
  173. cmd[2] = page;
  174. cmd[4] = 255; /* allocation length */
  175. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  176. if(n < Mode6parmhdrlen)
  177. return -1;
  178. n -= Mode6parmhdrlen + resp[3];
  179. if(n < 0)
  180. return -1;
  181. if(n > Pagesz)
  182. n = Pagesz;
  183. memmove(v, &resp[Mode6parmhdrlen + resp[3]], n);
  184. return n;
  185. }
  186. static int
  187. mmcsetpage10(Drive *drive, int page, void *v)
  188. {
  189. uchar cmd[10], *p, *pagedata;
  190. int len, n;
  191. /* allocate parameter list, copy in mode page, fill in header */
  192. pagedata = v;
  193. assert(pagedata[0] == page);
  194. len = Mode10parmhdrlen + Modepaghdrlen + pagedata[1];
  195. p = emalloc(len);
  196. memmove(p + Mode10parmhdrlen, pagedata, pagedata[1]);
  197. /* parameter list header */
  198. p[0] = 0;
  199. p[1] = len - 2;
  200. /* set up CDB */
  201. memset(cmd, 0, sizeof(cmd));
  202. cmd[0] = ScmdMselect10;
  203. cmd[1] = 0x10; /* format not vendor-specific */
  204. cmd[8] = len;
  205. // print("set: sending cmd\n");
  206. // hexdump(cmd, 10);
  207. // print("parameter list header\n");
  208. // hexdump(p, Mode10parmhdrlen);
  209. // print("page\n");
  210. // hexdump(p + Mode10parmhdrlen, len - Mode10parmhdrlen);
  211. n = scsi(drive, cmd, sizeof(cmd), p, len, Swrite);
  212. // print("set: got cmd\n");
  213. // hexdump(cmd, 10);
  214. free(p);
  215. if(n < len)
  216. return -1;
  217. return 0;
  218. }
  219. static int
  220. mmcsetpage6(Drive *drive, int page, void *v)
  221. {
  222. uchar cmd[6], *p, *pagedata;
  223. int len, n;
  224. if (vflag)
  225. print("mmcsetpage6 called!\n");
  226. pagedata = v;
  227. assert(pagedata[0] == page);
  228. len = Mode6parmhdrlen + Modepaghdrlen + pagedata[1];
  229. p = emalloc(len);
  230. memmove(p + Mode6parmhdrlen, pagedata, pagedata[1]);
  231. memset(cmd, 0, sizeof(cmd));
  232. cmd[0] = ScmdMselect6;
  233. cmd[1] = 0x10; /* format not vendor-specific */
  234. cmd[4] = len;
  235. n = scsi(drive, cmd, sizeof(cmd), p, len, Swrite);
  236. free(p);
  237. if(n < len)
  238. return -1;
  239. return 0;
  240. }
  241. static int
  242. mmcgetpage(Drive *drive, int page, void *v)
  243. {
  244. Mmcaux *aux;
  245. aux = drive->aux;
  246. switch(aux->pagecmdsz) {
  247. case 10:
  248. return mmcgetpage10(drive, page, v);
  249. case 6:
  250. return mmcgetpage6(drive, page, v);
  251. default:
  252. assert(0);
  253. }
  254. return -1;
  255. }
  256. static int
  257. mmcsetpage(Drive *drive, int page, void *v)
  258. {
  259. Mmcaux *aux;
  260. aux = drive->aux;
  261. switch(aux->pagecmdsz) {
  262. case 10:
  263. return mmcsetpage10(drive, page, v);
  264. case 6:
  265. return mmcsetpage6(drive, page, v);
  266. default:
  267. assert(0);
  268. }
  269. return -1;
  270. }
  271. int
  272. mmcstatus(Drive *drive)
  273. {
  274. uchar cmd[12];
  275. initcdb(cmd, sizeof cmd, ScmdCDstatus); /* mechanism status */
  276. return scsi(drive, cmd, sizeof(cmd), nil, 0, Sread);
  277. }
  278. void
  279. mmcgetspeed(Drive *drive)
  280. {
  281. int n, maxread, curread, maxwrite, curwrite;
  282. uchar buf[Pagesz];
  283. memset(buf, 0, 22);
  284. n = mmcgetpage(drive, Pagcapmechsts, buf); /* legacy page */
  285. if (n < 22) {
  286. if (vflag)
  287. fprint(2, "no Pagcapmechsts mode page!\n");
  288. return;
  289. }
  290. maxread = (buf[8]<<8)|buf[9];
  291. curread = (buf[14]<<8)|buf[15];
  292. maxwrite = (buf[18]<<8)|buf[19];
  293. curwrite = (buf[20]<<8)|buf[21];
  294. if(maxread && maxread < 170 || curread && curread < 170)
  295. return; /* bogus data */
  296. drive->readspeed = curread;
  297. drive->writespeed = curwrite;
  298. drive->maxreadspeed = maxread;
  299. drive->maxwritespeed = maxwrite;
  300. }
  301. static int
  302. getdevtype(Drive *drive)
  303. {
  304. int n;
  305. uchar cmd[6], resp[Pagesz];
  306. initcdb(cmd, sizeof cmd, ScmdInq);
  307. cmd[3] = sizeof resp >> 8;
  308. cmd[4] = sizeof resp;
  309. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread);
  310. if (n < 8)
  311. return -1;
  312. return resp[0] & 037;
  313. }
  314. static int
  315. start(Drive *drive, int code)
  316. {
  317. uchar cmd[6];
  318. initcdb(cmd, sizeof cmd, ScmdStart);
  319. cmd[4] = code;
  320. return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
  321. }
  322. Drive*
  323. mmcprobe(Scsi *scsi)
  324. {
  325. Mmcaux *aux;
  326. Drive *drive;
  327. uchar buf[Pagesz];
  328. int cap, n;
  329. if (vflag)
  330. print("mmcprobe: inquiry: %s\n", scsi->inquire);
  331. drive = emalloc(sizeof(Drive));
  332. drive->Scsi = *scsi;
  333. drive->Dev = mmcdev;
  334. aux = emalloc(sizeof(Mmcaux));
  335. drive->aux = aux;
  336. scsiready(drive);
  337. drive->type = getdevtype(drive);
  338. if (drive->type != TypeCD) {
  339. werrstr("not an mmc device");
  340. free(aux);
  341. free(drive);
  342. return nil;
  343. }
  344. /*
  345. * drive is an mmc device; learn what we can about it
  346. * (as opposed to the disc in it).
  347. */
  348. start(drive, 1);
  349. /* attempt to read CD capabilities page, but it's now legacy */
  350. if(mmcgetpage10(drive, Pagcapmechsts, buf) >= 0)
  351. aux->pagecmdsz = 10;
  352. else if(mmcgetpage6(drive, Pagcapmechsts, buf) >= 0)
  353. aux->pagecmdsz = 6;
  354. else {
  355. if (vflag)
  356. fprint(2, "no Pagcapmechsts mode page!\n");
  357. werrstr("can't read mode page %d!", Pagcapmechsts);
  358. free(aux);
  359. free(drive);
  360. return nil;
  361. }
  362. cap = 0;
  363. if(buf[Capwrite] & (Capcdr|Capcdrw|Capdvdr|Capdvdram) ||
  364. buf[Capmisc] & Caprw)
  365. cap |= Cwrite;
  366. if(buf[Capmisc] & Capcdda) /* CD-DA commands supported? */
  367. cap |= Ccdda; /* not used anywhere else */
  368. // print("read %d max %d\n", biges(buf+14), biges(buf+8));
  369. // print("write %d max %d\n", biges(buf+20), biges(buf+18));
  370. /* cache optional page 05 (write parameter page) */
  371. if(/* (cap & Cwrite) && */
  372. mmcgetpage(drive, Pagwrparams, aux->page05) >= 0) {
  373. aux->page05ok = 1;
  374. cap |= Cwrite;
  375. if (vflag)
  376. fprint(2, "mmcprobe: got page 5, assuming drive can write\n");
  377. } else {
  378. if (vflag)
  379. fprint(2, "no Pagwrparams mode page!\n");
  380. cap &= ~Cwrite;
  381. }
  382. drive->cap = cap;
  383. mmcgetspeed(drive);
  384. /*
  385. * we can't actually control caching much.
  386. * see SBC-2 §6.3.3 but also MMC-6 §7.6.
  387. */
  388. n = mmcgetpage(drive, Pagcache, buf);
  389. if (n >= 3) {
  390. /* n == 255; buf[1] == 10 (10 bytes after buf[1]) */
  391. buf[0] &= 077; /* clear reserved bits, MMC-6 §7.2.3 */
  392. assert(buf[0] == Pagcache);
  393. assert(buf[1] >= 10);
  394. buf[2] = Ccwce;
  395. if (mmcsetpage(drive, Pagcache, buf) < 0)
  396. if (vflag)
  397. print("mmcprobe: cache control NOT set\n");
  398. }
  399. return drive;
  400. }
  401. static char *tracktype[] = { /* indices are track modes (Tm*) */
  402. "audio cdda",
  403. "2 audio channels",
  404. "2",
  405. "3",
  406. "data, recorded uninterrupted",
  407. "data, recorded interrupted",
  408. };
  409. /* t is a track number on disc, i is an index into drive->track[] for result */
  410. static int
  411. mmctrackinfo(Drive *drive, int t, int i)
  412. {
  413. int n, type, bs;
  414. ulong beg, size;
  415. uchar tmode;
  416. uchar cmd[10], resp[255];
  417. Mmcaux *aux;
  418. aux = drive->aux;
  419. memset(cmd, 0, sizeof(cmd));
  420. cmd[0] = ScmdRtrackinfo;
  421. cmd[1] = 1; /* address below is logical track # */
  422. cmd[2] = t>>24;
  423. cmd[3] = t>>16;
  424. cmd[4] = t>>8;
  425. cmd[5] = t;
  426. cmd[7] = sizeof(resp)>>8;
  427. cmd[8] = sizeof(resp);
  428. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  429. if(n < 28) {
  430. if(vflag)
  431. print("trackinfo %d fails n=%d: %r\n", t, n);
  432. return -1;
  433. }
  434. beg = bige(&resp[8]);
  435. size = bige(&resp[24]);
  436. tmode = resp[5] & 0x0D;
  437. // dmode = resp[6] & 0x0F;
  438. if(vflag)
  439. print("track %d type %d (%s)", t, tmode,
  440. (tmode < nelem(tracktype)? tracktype[tmode]: "**GOK**"));
  441. type = TypeNone;
  442. bs = BScdda;
  443. switch(tmode){
  444. case Tmcdda:
  445. type = TypeAudio;
  446. bs = BScdda;
  447. break;
  448. case Tm2audio: /* 2 audio channels, with pre-emphasis 50/15 μs */
  449. if(vflag)
  450. print("audio channels with preemphasis on track %d "
  451. "(u%.3d)\n", t, i);
  452. type = TypeNone;
  453. break;
  454. case Tmunintr: /* data track, recorded uninterrupted */
  455. case Tmintr: /* data track, recorded interrupted */
  456. /* treat Tmintr (5) as cdrom; it's probably dvd or bd */
  457. type = TypeData;
  458. bs = BScdrom;
  459. break;
  460. default:
  461. if(vflag)
  462. print("unknown track type %d\n", tmode);
  463. break;
  464. }
  465. drive->track[i].mtime = drive->changetime;
  466. drive->track[i].beg = beg;
  467. drive->track[i].end = beg+size;
  468. drive->track[i].type = type;
  469. drive->track[i].bs = bs;
  470. drive->track[i].size = (vlong)(size-2) * bs; /* -2: skip lead out */
  471. if(resp[6] & (1<<6)) { /* blank? */
  472. drive->track[i].type = TypeBlank;
  473. drive->writeok = 1;
  474. }
  475. if(vflag)
  476. print(" start %lud end %lud", beg, beg + size - 1);
  477. /* resp[6] & (1<<7) of zero: invisible track */
  478. /* t == getinvistrack(): invisible track */
  479. if(t == Invistrack || resp[7] & 1) { /* invis or nwa valid? */
  480. aux->mmcnwa = bige(&resp[12]);
  481. if ((long)aux->mmcnwa < 0) /* implausible? */
  482. aux->mmcnwa = 0;
  483. if (vflag)
  484. print(" nwa %lud", aux->mmcnwa);
  485. }
  486. if (vflag)
  487. print("\n");
  488. return 0;
  489. }
  490. /* this may fail for blank media */
  491. static int
  492. mmcreadtoc(Drive *drive, int type, int track, void *data, int nbytes)
  493. {
  494. uchar cmd[10];
  495. memset(cmd, 0, sizeof(cmd));
  496. cmd[0] = ScmdRTOC;
  497. cmd[1] = type; /* msf bit & reserved */
  498. cmd[2] = Tocfmttoc;
  499. cmd[6] = track; /* track/session */
  500. cmd[7] = nbytes>>8;
  501. cmd[8] = nbytes;
  502. return scsi(drive, cmd, sizeof(cmd), data, nbytes, Sread);
  503. }
  504. static int
  505. mmcreaddiscinfo(Drive *drive, void *data, int nbytes)
  506. {
  507. uchar cmd[10];
  508. int n;
  509. memset(cmd, 0, sizeof(cmd));
  510. cmd[0] = ScmdRdiscinfo;
  511. cmd[7] = nbytes>>8;
  512. cmd[8] = nbytes;
  513. n = scsi(drive, cmd, sizeof(cmd), data, nbytes, Sread);
  514. if(n < 24) {
  515. if(n >= 0)
  516. werrstr("rdiscinfo returns %d", n);
  517. return -1;
  518. }
  519. return n;
  520. }
  521. static Msf
  522. rdmsf(uchar *p)
  523. {
  524. Msf msf;
  525. msf.m = p[0];
  526. msf.s = p[1];
  527. msf.f = p[2];
  528. return msf;
  529. }
  530. static int
  531. getdiscinfo(Drive *drive, uchar resp[], int resplen)
  532. {
  533. int n;
  534. n = mmcreaddiscinfo(drive, resp, resplen);
  535. if(n < 3) {
  536. if (vflag)
  537. fprint(2, "read disc info failed\n");
  538. return n;
  539. }
  540. if (vflag)
  541. fprint(2, "read disc info succeeded\n");
  542. assert((resp[2] & 0340) == 0); /* data type 0 */
  543. drive->erasable = ((resp[2] & 0x10) != 0); /* -RW? */
  544. drive->erasableset = 1;
  545. return n;
  546. }
  547. static int
  548. getdvdstruct(Drive *drive)
  549. {
  550. int n, cat;
  551. uchar cmd[12], resp[Pagesz];
  552. initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */
  553. cmd[1] = 0; /* media type: dvd */
  554. cmd[7] = 0; /* format code: physical format */
  555. cmd[8] = sizeof resp >> 8; /* allocation length */
  556. cmd[9] = sizeof resp;
  557. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread);
  558. if (n < 7)
  559. return -1;
  560. // print("dvd structure:\n");
  561. // hexdump(resp, n);
  562. /* resp[0..1] is resp length */
  563. cat = (resp[4] & 0xf0) >> 4; /* disk category, MMC-6 §6.22.3.2.1 */
  564. if (vflag)
  565. fprint(2, "dvd type is %s\n", dvdtype[cat]);
  566. drive->dvdtype = dvdtype[cat];
  567. /* write parameters mode page may suffice to compute writeok for dvd */
  568. drive->erasable = drive->recordable = 0;
  569. /*
  570. * the layer-type field is a *bit array*,
  571. * though an enumeration of types would make more sense,
  572. * since the types are exclusive, not orthogonal.
  573. */
  574. if (resp[6] & (1<<2)) /* rewritable? */
  575. drive->erasable = 1;
  576. else if (resp[6] & (1<<1)) /* recordable once? */
  577. drive->recordable = 1;
  578. else { /* factory-pressed disk */
  579. drive->blank = 0;
  580. drive->blankset = 1;
  581. }
  582. drive->erasableset = drive->recordableset = 1;
  583. drive->mmctype = (cat >= 8? Mmcdvdplus: Mmcdvdminus);
  584. return 0;
  585. }
  586. static int
  587. getbdstruct(Drive *drive)
  588. {
  589. int n;
  590. uchar cmd[12], resp[4100];
  591. initcdb(cmd, sizeof cmd, ScmdReadDVD); /* actually, read disc structure */
  592. cmd[1] = 1; /* media type: bd */
  593. cmd[7] = 0; /* format code: disc info */
  594. cmd[8] = sizeof resp >> 8; /* allocation length */
  595. cmd[9] = sizeof resp;
  596. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof resp, Sread);
  597. /*
  598. * resp[0..1] is resp length.
  599. * resp[4+8..4+8+2] is bd type (disc type identifier):
  600. * BDO|BDW|BDR, MMC-6 §6.22.3.3.1. The above command should
  601. * fail on DVD drives, but some seem to ignore media type
  602. * and return successfully, so verify that it's a BD drive.
  603. */
  604. if (n < 4+8+3 || resp[4+8] != 'B' || resp[4+8+1] != 'D')
  605. return -1;
  606. if (vflag)
  607. fprint(2, "read disc structure (bd) succeeded\n");
  608. drive->erasable = drive->recordable = 0;
  609. switch (resp[4+8+2]) {
  610. case 'O':
  611. drive->blank = 0;
  612. drive->blankset = 1;
  613. break;
  614. case 'R': /* Recordable */
  615. drive->recordable = 1;
  616. break;
  617. case 'W': /* reWritable */
  618. drive->erasable = 1;
  619. break;
  620. default:
  621. fprint(2, "%s: unknown bd type BD%c\n", argv0, resp[4+8+2]);
  622. return -1;
  623. }
  624. drive->erasableset = drive->recordableset = 1;
  625. drive->mmctype = Mmcbd;
  626. return 0;
  627. }
  628. /*
  629. * infer endings from the beginnings of other tracks.
  630. */
  631. static void
  632. mmcinfertracks(Drive *drive, int first, int last)
  633. {
  634. int i;
  635. uchar resp[1024];
  636. ulong tot;
  637. Track *t;
  638. if (vflag)
  639. fprint(2, "inferring tracks\n");
  640. for(i = first; i <= last; i++) {
  641. memset(resp, 0, sizeof(resp));
  642. if(mmcreadtoc(drive, 0, i, resp, sizeof(resp)) < 0)
  643. break;
  644. t = &drive->track[i-first];
  645. t->mtime = drive->changetime;
  646. t->type = TypeData;
  647. t->bs = BScdrom;
  648. t->beg = bige(resp+8);
  649. if(!(resp[5] & 4)) {
  650. t->type = TypeAudio;
  651. t->bs = BScdda;
  652. }
  653. }
  654. if((long)drive->track[0].beg < 0) /* i've seen negative track 0's */
  655. drive->track[0].beg = 0;
  656. tot = 0;
  657. memset(resp, 0, sizeof(resp));
  658. /* 0xAA is lead-out */
  659. if(mmcreadtoc(drive, 0, 0xAA, resp, sizeof(resp)) < 0)
  660. print("bad\n");
  661. if(resp[6])
  662. tot = bige(resp+8);
  663. for(i=last; i>=first; i--) {
  664. t = &drive->track[i-first];
  665. t->end = tot;
  666. tot = t->beg;
  667. if(t->end <= t->beg)
  668. t->beg = t->end = 0;
  669. /* -2: skip lead out */
  670. t->size = (t->end - t->beg - 2) * (vlong)t->bs;
  671. }
  672. }
  673. /* this gets called a lot from main.c's 9P routines */
  674. static int
  675. mmcgettoc(Drive *drive)
  676. {
  677. int i, n, first, last;
  678. uchar resp[1024];
  679. Mmcaux *aux;
  680. /*
  681. * if someone has swapped the cd,
  682. * mmcreadtoc will get ``medium changed'' and the
  683. * scsi routines will set nchange and changetime in the
  684. * scsi device.
  685. */
  686. mmcreadtoc(drive, 0, 0, resp, sizeof(resp));
  687. if(drive->Scsi.changetime == 0) { /* no media present */
  688. drive->mmctype = Mmcnone;
  689. drive->ntrack = 0;
  690. return 0;
  691. }
  692. /*
  693. * if the disc doesn't appear to be have been changed, and there
  694. * is a disc in this drive, there's nothing to do (the common case).
  695. */
  696. if(drive->nchange == drive->Scsi.nchange && drive->changetime != 0)
  697. return 0;
  698. /*
  699. * the disc in the drive may have just been changed,
  700. * so rescan it and relearn all about it.
  701. */
  702. drive->ntrack = 0;
  703. drive->nameok = 0;
  704. drive->nchange = drive->Scsi.nchange;
  705. drive->changetime = drive->Scsi.changetime;
  706. drive->writeok = drive->erasable = drive->recordable = drive->blank = 0;
  707. drive->erasableset = drive->recordableset = drive->blankset = 0;
  708. aux = drive->aux;
  709. aux->mmcnwa = 0;
  710. aux->nropen = aux->nwopen = 0;
  711. aux->ntotby = aux->ntotbk = 0;
  712. for(i=0; i<nelem(drive->track); i++){
  713. memset(&drive->track[i].mbeg, 0, sizeof(Msf));
  714. memset(&drive->track[i].mend, 0, sizeof(Msf));
  715. }
  716. /*
  717. * TODO: set read ahead, MMC-6 §6.37, seems to control caching.
  718. */
  719. /*
  720. * find number of tracks
  721. */
  722. if((n = mmcreadtoc(drive, Msfbit, 0, resp, sizeof(resp))) < 4) {
  723. /*
  724. * on a blank disc in a cd-rw, use readdiscinfo
  725. * to find the track info.
  726. */
  727. if(getdiscinfo(drive, resp, sizeof(resp)) < 7)
  728. return -1;
  729. assert((resp[2] & 0340) == 0); /* data type 0 */
  730. if(resp[4] != 1)
  731. print("multi-session disc %d\n", resp[4]);
  732. first = resp[3];
  733. last = resp[6];
  734. if(vflag)
  735. print("blank disc %d %d\n", first, last);
  736. /* the assumption of blankness may be unwarranted */
  737. drive->writeok = drive->blank = drive->blankset = 1;
  738. } else {
  739. first = resp[2];
  740. last = resp[3];
  741. if(n >= 4+8*(last-first+2)) {
  742. /* resp[4 + i*8 + 2] is track # */
  743. /* <=: track[last-first+1] = end */
  744. for(i=0; i<=last-first+1; i++)
  745. drive->track[i].mbeg = rdmsf(resp+4+i*8+5);
  746. for(i=0; i<last-first+1; i++)
  747. drive->track[i].mend = drive->track[i+1].mbeg;
  748. }
  749. }
  750. drive->mmctype = Mmcnone;
  751. drive->dvdtype = nil;
  752. getdvdstruct(drive);
  753. getbdstruct(drive);
  754. if (drive->mmctype == Mmcnone)
  755. drive->mmctype = Mmccd; /* by default */
  756. if (drive->recordable || drive->erasable)
  757. drive->writeok = 1;
  758. if (vflag) {
  759. fprint(2, "writeok %d", drive->writeok);
  760. /* drive->blank is never used and hard to figure out */
  761. // if (drive->blankset)
  762. // fprint(2, " blank %d", drive->blank);
  763. if (drive->recordableset)
  764. fprint(2, " recordable %d", drive->recordable);
  765. if (drive->erasableset)
  766. fprint(2, " erasable %d", drive->erasable);
  767. fprint(2, "\n");
  768. print("first %d last %d\n", first, last);
  769. }
  770. if(first == 0 && last == 0)
  771. first = 1;
  772. if(first <= 0 || first >= Maxtrack) {
  773. werrstr("first table %d not in range", first);
  774. return -1;
  775. }
  776. if(last <= 0 || last >= Maxtrack) {
  777. werrstr("last table %d not in range", last);
  778. return -1;
  779. }
  780. if(drive->cap & Cwrite) /* CDR drives are easy */
  781. for(i = first; i <= last; i++)
  782. mmctrackinfo(drive, i, i - first);
  783. else
  784. /*
  785. * otherwise we need to infer endings from the
  786. * beginnings of other tracks.
  787. */
  788. mmcinfertracks(drive, first, last);
  789. drive->firsttrack = first;
  790. drive->ntrack = last+1-first;
  791. return 0;
  792. }
  793. static void
  794. settrkmode(uchar *p, int mode)
  795. {
  796. p[Wptrkmode] &= ~0xf;
  797. p[Wptrkmode] |= mode;
  798. }
  799. /*
  800. * this uses page 5, which is optional.
  801. */
  802. static int
  803. mmcsetbs(Drive *drive, int bs)
  804. {
  805. uchar *p;
  806. Mmcaux *aux;
  807. aux = drive->aux;
  808. if (!aux->page05ok)
  809. return 0; /* harmless; assume 2k */
  810. p = aux->page05;
  811. /*
  812. * establish defaults.
  813. */
  814. p[0] &= 077; /* clear reserved bits, MMC-6 §7.2.3 */
  815. p[Wpwrtype] = Bufe | Wttrackonce;
  816. // if(testonlyflag)
  817. // p[Wpwrtype] |= 0x10; /* test-write */
  818. /* assume dvd values as defaults */
  819. settrkmode(p, Tmintr);
  820. p[Wptrkmode] |= Msnext;
  821. p[Wpdatblktype] = Db2kdata;
  822. p[Wpsessfmt] = Sfdata;
  823. switch(drive->mmctype) {
  824. case Mmcdvdplus:
  825. case Mmcbd:
  826. break;
  827. case Mmcdvdminus:
  828. /* dvd-r can only do disc-at-once or incremental */
  829. p[Wpwrtype] = Bufe | Wtsessonce;
  830. break;
  831. case Mmccd:
  832. settrkmode(p, Tmunintr); /* data track, uninterrupted */
  833. switch(bs){
  834. case BScdda:
  835. /* 2 audio channels without pre-emphasis */
  836. settrkmode(p, Tmcdda); /* TODO: should be Tm2audio? */
  837. p[Wpdatblktype] = Dbraw;
  838. break;
  839. case BScdrom:
  840. break;
  841. case BScdxa:
  842. p[Wpdatblktype] = Db2336;
  843. p[Wpsessfmt] = Sfcdxa;
  844. break;
  845. default:
  846. fprint(2, "%s: unknown CD type; bs %d\n", argv0, bs);
  847. assert(0);
  848. }
  849. break;
  850. default:
  851. fprint(2, "%s: unknown disc sub-type %d\n",
  852. argv0, drive->mmctype);
  853. break;
  854. }
  855. if(mmcsetpage(drive, Pagwrparams, p) < 0) {
  856. if (vflag)
  857. fprint(2, "mmcsetbs: could NOT set write parameters page\n");
  858. return -1;
  859. }
  860. return 0;
  861. }
  862. /* off is a block number */
  863. static long
  864. mmcread(Buf *buf, void *v, long nblock, ulong off)
  865. {
  866. int bs;
  867. long n, nn;
  868. uchar cmd[12];
  869. Drive *drive;
  870. Otrack *o;
  871. o = buf->otrack;
  872. drive = o->drive;
  873. bs = o->track->bs;
  874. off += o->track->beg;
  875. if(nblock >= (1<<10)) {
  876. werrstr("mmcread too big");
  877. if(vflag)
  878. fprint(2, "mmcread too big\n");
  879. return -1;
  880. }
  881. /* truncate nblock modulo size of track */
  882. if(off > o->track->end - 2) {
  883. werrstr("read past end of track");
  884. if(vflag)
  885. fprint(2, "end of track (%ld->%ld off %ld)",
  886. o->track->beg, o->track->end - 2, off);
  887. return -1;
  888. }
  889. if(off == o->track->end - 2)
  890. return 0;
  891. if(off+nblock > o->track->end - 2)
  892. nblock = o->track->end - 2 - off;
  893. /*
  894. * `read cd' only works for CDs; for everybody else,
  895. * we'll try plain `read (12)'. only use read cd if it's
  896. * a cd drive with a cd in it and we're not reading data
  897. * (e.g., reading audio).
  898. */
  899. memset(cmd, 0, sizeof(cmd));
  900. if (drive->type == TypeCD && drive->mmctype == Mmccd && bs != BScdrom) {
  901. cmd[0] = ScmdReadcd;
  902. cmd[2] = off>>24;
  903. cmd[3] = off>>16;
  904. cmd[4] = off>>8;
  905. cmd[5] = off>>0;
  906. cmd[6] = nblock>>16;
  907. cmd[7] = nblock>>8;
  908. cmd[8] = nblock>>0;
  909. cmd[9] = 0x10;
  910. switch(bs){
  911. case BScdda:
  912. cmd[1] = 0x04;
  913. break;
  914. case BScdrom:
  915. cmd[1] = 0x08;
  916. break;
  917. case BScdxa:
  918. cmd[1] = 0x0C;
  919. break;
  920. default:
  921. werrstr("unknown bs %d", bs);
  922. return -1;
  923. }
  924. } else { /* e.g., TypeDA */
  925. cmd[0] = ScmdRead12;
  926. cmd[2] = off>>24;
  927. cmd[3] = off>>16;
  928. cmd[4] = off>>8;
  929. cmd[5] = off>>0;
  930. cmd[6] = nblock>>24;
  931. cmd[7] = nblock>>16;
  932. cmd[8] = nblock>>8;
  933. cmd[9] = nblock;
  934. // cmd[10] = 0x80; /* streaming */
  935. }
  936. n = nblock*bs;
  937. nn = scsi(drive, cmd, sizeof(cmd), v, n, Sread);
  938. if(nn != n) {
  939. if(nn != -1)
  940. werrstr("short read %ld/%ld", nn, n);
  941. if(vflag)
  942. print("read off %lud nblock %ld bs %d failed\n",
  943. off, nblock, bs);
  944. return -1;
  945. }
  946. return nblock;
  947. }
  948. static Otrack*
  949. mmcopenrd(Drive *drive, int trackno)
  950. {
  951. Otrack *o;
  952. Mmcaux *aux;
  953. if(trackno < 0 || trackno >= drive->ntrack) {
  954. werrstr("track number out of range");
  955. return nil;
  956. }
  957. aux = drive->aux;
  958. if(aux->nwopen) {
  959. werrstr("disk in use for writing");
  960. return nil;
  961. }
  962. o = emalloc(sizeof(Otrack));
  963. o->drive = drive;
  964. o->track = &drive->track[trackno];
  965. o->nchange = drive->nchange;
  966. o->omode = OREAD;
  967. o->buf = bopen(mmcread, OREAD, o->track->bs, BDNblock);
  968. o->buf->otrack = o;
  969. aux->nropen++;
  970. return o;
  971. }
  972. static int
  973. format(Drive *drive)
  974. {
  975. ulong nblks, blksize;
  976. uchar *fmtdesc;
  977. uchar cmd[6], parms[4+8];
  978. if (drive->recordable && drive->mmctype != Mmcbd) {
  979. werrstr("don't format write-once cd or dvd media");
  980. return -1;
  981. }
  982. initcdb(cmd, sizeof cmd, ScmdFormat); /* format unit */
  983. cmd[1] = 0x10 | 1; /* format data, mmc format code */
  984. memset(parms, 0, sizeof parms);
  985. /* format list header */
  986. parms[1] = 2; /* immediate return; don't wait */
  987. parms[3] = 8; /* format descriptor length */
  988. fmtdesc = parms + 4;
  989. fmtdesc[4] = 0; /* full format */
  990. nblks = 0;
  991. blksize = BScdrom;
  992. switch (drive->mmctype) {
  993. case Mmccd:
  994. nblks = 0;
  995. break;
  996. case Mmcdvdplus:
  997. /* format type 0 is optional but equiv to format type 0x26 */
  998. fmtdesc[4] = 0x26 << 2;
  999. nblks = ~0ul;
  1000. blksize = 0;
  1001. break;
  1002. }
  1003. PUTBELONG(fmtdesc, nblks);
  1004. PUTBE24(fmtdesc + 5, blksize);
  1005. // print("format parameters:\n");
  1006. // hexdump(parms, sizeof parms);
  1007. if(vflag)
  1008. print("%lld ns: format\n", nsec());
  1009. return scsi(drive, cmd, sizeof(cmd), parms, sizeof parms, Swrite);
  1010. }
  1011. static long
  1012. mmcxwrite(Otrack *o, void *v, long nblk)
  1013. {
  1014. uchar cmd[10];
  1015. Mmcaux *aux;
  1016. assert(o->omode == OWRITE);
  1017. aux = o->drive->aux;
  1018. if (aux->mmcnwa == 0 && scsiready(o->drive) < 0) {
  1019. werrstr("device not ready to write");
  1020. return -1;
  1021. }
  1022. aux->ntotby += nblk*o->track->bs;
  1023. aux->ntotbk += nblk;
  1024. memset(cmd, 0, sizeof(cmd));
  1025. cmd[0] = ScmdExtwrite; /* write (10) */
  1026. cmd[2] = aux->mmcnwa>>24;
  1027. cmd[3] = aux->mmcnwa>>16;
  1028. cmd[4] = aux->mmcnwa>>8;
  1029. cmd[5] = aux->mmcnwa;
  1030. cmd[7] = nblk>>8;
  1031. cmd[8] = nblk>>0;
  1032. if(vflag)
  1033. print("%lld ns: write %ld at 0x%lux\n",
  1034. nsec(), nblk, aux->mmcnwa);
  1035. aux->mmcnwa += nblk;
  1036. return scsi(o->drive, cmd, sizeof(cmd), v, nblk*o->track->bs, Swrite);
  1037. }
  1038. static long
  1039. mmcwrite(Buf *buf, void *v, long nblk, ulong)
  1040. {
  1041. return mmcxwrite(buf->otrack, v, nblk);
  1042. }
  1043. enum {
  1044. Eccblk = 128, /* sectors per ecc block */
  1045. Rsvslop = 0,
  1046. };
  1047. static int
  1048. reserve(Drive *drive, int track)
  1049. {
  1050. ulong sz;
  1051. uchar cmd[10];
  1052. initcdb(cmd, sizeof cmd, ScmdReserve);
  1053. track -= drive->firsttrack; /* switch to zero-origin */
  1054. if (track >= 0 && track < drive->ntrack)
  1055. /* .end is next sector past sz */
  1056. sz = drive->track[track].end - drive->track[track].beg - Rsvslop;
  1057. else {
  1058. sz = Eccblk;
  1059. fprint(2, "%s: reserve: track #%d out of range 0-%d\n",
  1060. argv0, track, drive->ntrack);
  1061. }
  1062. sz -= sz % Eccblk; /* round down to ecc-block multiple */
  1063. if ((long)sz < 0) {
  1064. fprint(2, "%s: reserve: bogus size %lud\n", argv0, sz);
  1065. return -1;
  1066. }
  1067. cmd[1] = 0; /* no ASRV: allocate by size not lba */
  1068. PUTBELONG(cmd + 2 + 3, sz);
  1069. if (vflag)
  1070. fprint(2, "reserving %ld sectors\n", sz);
  1071. return scsi(drive, cmd, sizeof cmd, cmd, 0, Snone);
  1072. }
  1073. static int
  1074. getinvistrack(Drive *drive)
  1075. {
  1076. int n;
  1077. uchar cmd[10], resp[Pagesz];
  1078. initcdb(cmd, sizeof(cmd), ScmdRtrackinfo);
  1079. cmd[1] = 1<<2 | 1; /* open; address below is logical track # */
  1080. PUTBELONG(cmd + 2, 1); /* find first open track */
  1081. cmd[7] = sizeof(resp)>>8;
  1082. cmd[8] = sizeof(resp);
  1083. n = scsi(drive, cmd, sizeof(cmd), resp, sizeof(resp), Sread);
  1084. if(n < 4) {
  1085. if(vflag)
  1086. print("trackinfo for invis track fails n=%d: %r\n", n);
  1087. return -1;
  1088. }
  1089. if(vflag)
  1090. print("getinvistrack: track #%d session #%d\n",
  1091. resp[2], resp[3]);
  1092. return resp[2];
  1093. }
  1094. static Otrack*
  1095. mmccreate(Drive *drive, int type)
  1096. {
  1097. int bs, invis;
  1098. Mmcaux *aux;
  1099. Track *t;
  1100. Otrack *o;
  1101. aux = drive->aux;
  1102. if(aux->nropen || aux->nwopen) {
  1103. werrstr("drive in use");
  1104. return nil;
  1105. }
  1106. switch(type){
  1107. case TypeAudio:
  1108. bs = BScdda;
  1109. break;
  1110. case TypeData:
  1111. bs = BScdrom;
  1112. break;
  1113. default:
  1114. werrstr("bad type %d", type);
  1115. return nil;
  1116. }
  1117. invis = getinvistrack(drive);
  1118. if (invis < 0)
  1119. invis = Invistrack;
  1120. /* comment out the returns for now; it should be no big deal - geoff */
  1121. if(mmctrackinfo(drive, invis, Maxtrack)) {
  1122. if (vflag)
  1123. fprint(2, "mmccreate: mmctrackinfo for invis track %d"
  1124. " failed: %r\n", invis);
  1125. werrstr("disc not writable");
  1126. // return nil;
  1127. }
  1128. if(mmcsetbs(drive, bs) < 0) {
  1129. werrstr("cannot set bs mode");
  1130. // return nil;
  1131. }
  1132. if(mmctrackinfo(drive, invis, Maxtrack)) {
  1133. if (vflag)
  1134. fprint(2, "mmccreate: mmctrackinfo for invis track %d"
  1135. " (2) failed: %r\n", invis);
  1136. werrstr("disc not writable 2");
  1137. // return nil;
  1138. }
  1139. /* special hack for dvd-r: reserve the invisible track */
  1140. if (drive->mmctype == Mmcdvdminus && drive->writeok &&
  1141. drive->recordable && reserve(drive, invis) < 0) {
  1142. if (vflag)
  1143. fprint(2, "mmcreate: reserving track %d for dvd-r "
  1144. "failed: %r\n", invis);
  1145. return nil;
  1146. }
  1147. aux->ntotby = 0;
  1148. aux->ntotbk = 0;
  1149. t = &drive->track[drive->ntrack++];
  1150. t->size = 0;
  1151. t->bs = bs;
  1152. t->beg = aux->mmcnwa;
  1153. t->end = 0;
  1154. t->type = type;
  1155. drive->nameok = 0;
  1156. o = emalloc(sizeof(Otrack));
  1157. o->drive = drive;
  1158. o->nchange = drive->nchange;
  1159. o->omode = OWRITE;
  1160. o->track = t;
  1161. o->buf = bopen(mmcwrite, OWRITE, bs, BDNblock);
  1162. o->buf->otrack = o;
  1163. aux->nwopen++;
  1164. if(vflag)
  1165. print("mmcinit: nwa = 0x%luX\n", aux->mmcnwa);
  1166. return o;
  1167. }
  1168. /*
  1169. * issue some form of close track, close session or finalize disc command.
  1170. * see The Matrix, table 252 in MMC-6 §6.3.2.3.
  1171. */
  1172. static int
  1173. mmcxclose(Drive *drive, int clf, int trackno)
  1174. {
  1175. uchar cmd[10];
  1176. memset(cmd, 0, sizeof(cmd));
  1177. cmd[0] = ScmdClosetracksess;
  1178. /* cmd[1] & 1 is the immediate bit */
  1179. cmd[2] = clf; /* close function */
  1180. if(clf == Closetrack)
  1181. cmd[5] = trackno;
  1182. return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
  1183. }
  1184. /* flush drive cache, close current track */
  1185. void
  1186. mmcsynccache(Drive *drive)
  1187. {
  1188. int invis;
  1189. uchar cmd[10];
  1190. Mmcaux *aux;
  1191. initcdb(cmd, sizeof cmd, ScmdSynccache);
  1192. /*
  1193. * this will take a long time to burn the remainder of a dvd-r
  1194. * with a reserved track covering the whole disc.
  1195. */
  1196. if (vflag) {
  1197. fprint(2, "syncing cache");
  1198. if (drive->mmctype == Mmcdvdminus && drive->writeok &&
  1199. drive->recordable)
  1200. fprint(2, "; dvd-r burning rest of track reservation, "
  1201. "will be slow");
  1202. fprint(2, "\n");
  1203. }
  1204. scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
  1205. if(vflag) {
  1206. aux = drive->aux;
  1207. print("mmcsynccache: bytes = %lld blocks = %ld, mmcnwa 0x%luX\n",
  1208. aux->ntotby, aux->ntotbk, aux->mmcnwa);
  1209. }
  1210. invis = getinvistrack(drive);
  1211. if (invis < 0)
  1212. invis = Invistrack;
  1213. /*
  1214. * rsc: seems not to work on some drives.
  1215. * so ignore return code & don't issue on dvd+rw.
  1216. */
  1217. if(drive->mmctype != Mmcdvdplus || !drive->erasable) {
  1218. if (vflag)
  1219. fprint(2, "closing invisible track %d (not dvd+rw)...\n",
  1220. invis);
  1221. mmcxclose(drive, Closetrack, invis);
  1222. if (vflag)
  1223. fprint(2, "... done.\n");
  1224. }
  1225. }
  1226. /*
  1227. * close the open track `o'.
  1228. */
  1229. static void
  1230. mmcclose(Otrack *o)
  1231. {
  1232. Mmcaux *aux;
  1233. static uchar zero[2*BSmax];
  1234. aux = o->drive->aux;
  1235. if(o->omode == OREAD)
  1236. aux->nropen--;
  1237. else if(o->omode == OWRITE) {
  1238. aux->nwopen--;
  1239. mmcxwrite(o, zero, 2); /* write lead out */
  1240. mmcsynccache(o->drive);
  1241. o->drive->nchange = -1; /* force reread toc */
  1242. }
  1243. free(o);
  1244. }
  1245. static int
  1246. setonesess(Drive *drive)
  1247. {
  1248. uchar *p;
  1249. Mmcaux *aux;
  1250. /* page 5 is legacy and now read-only; see MMC-6 §7.5.4.1 */
  1251. aux = drive->aux;
  1252. p = aux->page05;
  1253. p[Wptrkmode] &= ~Msbits;
  1254. p[Wptrkmode] |= Msnonext;
  1255. return mmcsetpage(drive, Pagwrparams, p);
  1256. }
  1257. /*
  1258. * close the current session, then finalize the disc.
  1259. */
  1260. static int
  1261. mmcfixate(Drive *drive)
  1262. {
  1263. int r;
  1264. if((drive->cap & Cwrite) == 0) {
  1265. werrstr("not a writer");
  1266. return -1;
  1267. }
  1268. drive->nchange = -1; /* force reread toc */
  1269. setonesess(drive);
  1270. /* skip explicit close session on bd-r */
  1271. if (drive->mmctype != Mmcbd || drive->erasable) {
  1272. if (vflag)
  1273. fprint(2, "closing session and maybe finalizing...\n");
  1274. r = mmcxclose(drive, Closesessfinal, 0);
  1275. if (vflag)
  1276. fprint(2, "... done.\n");
  1277. if (r < 0)
  1278. return r;
  1279. }
  1280. /*
  1281. * Closesessfinal only closes & doesn't finalize on dvd+r and bd-r.
  1282. * Closedvdrbdfinal closes & finalizes dvd+r and bd-r.
  1283. */
  1284. if ((drive->mmctype == Mmcdvdplus || drive->mmctype == Mmcbd) &&
  1285. !drive->erasable) {
  1286. if (vflag)
  1287. fprint(2, "finalizing dvd+r or bd-r... "
  1288. "(won't print `done').\n");
  1289. return mmcxclose(drive, Closedvdrbdfinal, 0);
  1290. }
  1291. return 0;
  1292. }
  1293. static int
  1294. mmcblank(Drive *drive, int quick)
  1295. {
  1296. uchar cmd[12];
  1297. drive->nchange = -1; /* force reread toc */
  1298. memset(cmd, 0, sizeof(cmd));
  1299. cmd[0] = ScmdBlank; /* blank cd-rw media */
  1300. /* immediate bit is 0x10 */
  1301. /* cmd[1] = 0 means blank the whole disc; = 1 just the header */
  1302. cmd[1] = quick ? 0x01 : 0x00;
  1303. return scsi(drive, cmd, sizeof(cmd), cmd, 0, Snone);
  1304. }
  1305. static char*
  1306. e(int status)
  1307. {
  1308. if(status < 0)
  1309. return geterrstr();
  1310. return nil;
  1311. }
  1312. static char*
  1313. mmcctl(Drive *drive, int argc, char **argv)
  1314. {
  1315. char *cmd;
  1316. if(argc < 1)
  1317. return nil;
  1318. cmd = argv[0];
  1319. if(strcmp(cmd, "format") == 0)
  1320. return e(format(drive));
  1321. if(strcmp(cmd, "blank") == 0)
  1322. return e(mmcblank(drive, 0));
  1323. if(strcmp(cmd, "quickblank") == 0)
  1324. return e(mmcblank(drive, 1));
  1325. if(strcmp(cmd, "eject") == 0)
  1326. return e(start(drive, 2));
  1327. if(strcmp(cmd, "ingest") == 0)
  1328. return e(start(drive, 3));
  1329. return "bad arg";
  1330. }
  1331. static char*
  1332. mmcsetspeed(Drive *drive, int r, int w)
  1333. {
  1334. char *rv;
  1335. uchar cmd[12];
  1336. memset(cmd, 0, sizeof(cmd));
  1337. cmd[0] = ScmdSetcdspeed;
  1338. cmd[2] = r>>8;
  1339. cmd[3] = r;
  1340. cmd[4] = w>>8;
  1341. cmd[5] = w;
  1342. rv = e(scsi(drive, cmd, sizeof(cmd), nil, 0, Snone));
  1343. mmcgetspeed(drive);
  1344. return rv;
  1345. }
  1346. static Dev mmcdev = {
  1347. mmcopenrd,
  1348. mmccreate,
  1349. bufread,
  1350. bufwrite,
  1351. mmcclose,
  1352. mmcgettoc,
  1353. mmcfixate,
  1354. mmcctl,
  1355. mmcsetspeed,
  1356. };