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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
YamahaCDR10x.cc
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：25k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

YamahaCDR10x.cc：源码内容
  1. /*  cdrdao - write audio CD-Rs in disc-at-once mode
  2.  *
  3.  *  Copyright (C) 1999  Cameron G. MacKinnon <C_MacKinnon@yahoo.com>
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  20. /*
  21.  * $Log: YamahaCDR10x.cc,v $
  22.  * Revision 1.3  1999/04/05 11:04:10  mueller
  23.  * Added driver option flags.
  24.  *
  25.  * Revision 1.2  1999/03/27 14:35:17  mueller
  26.  * Added data track support.
  27.  *
  28.  * Revision 1.1  1999/02/28 10:27:49  mueller
  29.  * Initial revision
  30.  */
  32. /* Cameron's log:
  33.  *
  34.  * Revision 0.4  1999/01/08 21:00:00  cmackin
  35.  * Fixed BCD fields in Cue Sheet
  36.  * Todo: BCD issues for ISRC and Catalog
  37.  *       core dump when RO CD inserted for burn functions
  38.  *
  39.  * Revision 0.3  1999/01/08 12:00:00  cmackin
  40.  * Added {g,s}etModePage6(...): Yamaha doesn't support the (10) cmds
  41.  *
  42.  * Revision 0.2  1999/01/08 09:00:00  cmackin
  43.  * Added READ CD-ROM CAPACITY to diskInfo()
  44.  *
  45.  * Revision 0.1  1999/01/07 20:44:58  cmackin
  46.  * Initial revision, based on GenericMMC
  47.  *
  48.  */
  50. /* Driver for Yamaha CDR10X drives. 
  51.  * Written by Cameron G. MacKinnon <C_MacKinnon@yahoo.com>.
  52.  */
  54. static char rcsid[] = "$Id: YamahaCDR10x.cc,v 1.3 1999/04/05 11:04:10 mueller Exp mueller $";
  56. #include <config.h>
  58. #include <unistd.h>
  59. #include <string.h>
  60. #include <assert.h>
  62. #include "YamahaCDR10x.h"
  64. #include "Toc.h"
  65. #include "PQSubChannel16.h"
  66. #include "util.h"
  67. #include "port.h"
  70. YamahaCDR10x::YamahaCDR10x(ScsiIf *scsiIf, unsigned long options)
  71.   : CdrDriver(scsiIf, options)
  72. {
  73.   int i;
  75.   driverName_ = "Yamaha CDR10x - Version 0.5 (data)";
  77.   encodingMode_ = 1; 
  78.   
  79.   speed_ = 0;
  80.   simulate_ = 1;
  82.   scsiTimeout_ = 0;
  84.   for (i = 0; i < maxScannedSubChannels_; i++)
  85.     scannedSubChannels_[i] = new PQSubChannel16;
  87.   // reads little endian samples
  88.   audioDataByteOrder_ = 0;
  89. }
  91. // static constructor
  92. CdrDriver *YamahaCDR10x::instance(ScsiIf *scsiIf, unsigned long options)
  93. {
  94.   return new YamahaCDR10x(scsiIf, options);
  95. }
  97. YamahaCDR10x::~YamahaCDR10x()
  98. {
  99.   int i;
  101.   for (i = 0; i < maxScannedSubChannels_; i++) {
  102.     delete scannedSubChannels_[i];
  103.     scannedSubChannels_[i] = NULL;
  104.   }
  105. }
  107. int YamahaCDR10x::multiSession(int m)
  108. {
  109.   if (m != 0) {
  110.     return 1; // multi session mode is not supported
  111.   }
  113.   return 0;
  114. }
  116. // sets speed
  117. // return: 0: OK
  118. //         1: illegal speed
  119. int YamahaCDR10x::speed(int s)
  120. {
  121.   if (s == 0 || s == 1 || s == 2 || s == 4)
  122.     speed_ = s;
  123.   else if (s == 3)
  124.     speed_ = 2;
  125.   else if (s > 4)
  126.     speed_ = 4;
  127.   else
  128.     return 1;
  130.   if (selectSpeed() != 0)
  131.     return 1;
  132.   
  133.   return 0;
  134. }
  136. int YamahaCDR10x::speed()
  137. {
  138.   DriveInfo di;
  140.   if (driveInfo(&di, 1) != 0) {
  141.     return 0;
  142.   }
  144.   return speed2Mult(di.currentWriteSpeed);
  146. }
  148. // loads ('unload' == 0) or ejects ('unload' == 1) tray
  149. // return: 0: OK
  150. //         1: scsi command failed
  151. int YamahaCDR10x::loadUnload(int unload) const
  152. {
  153.   unsigned char cmd[6];
  155.   memset(cmd, 0, 6);
  157.   cmd[0] = 0x1b; // START/STOP UNIT
  158.   if (unload) {
  159.     cmd[4] = 0x02; // LoUnlo=1, Start=0
  160.   }
  161.   else {
  162.     cmd[4] = 0x01; // LoUnlo=0, Start=1: This is a caddy, and load is reserved
  163.   }
  164.   
  165.   if (sendCmd(cmd, 6, NULL, 0, NULL, 0) != 0) {
  166.     message(-2, "Cannot %s medium.", (unload ? "stop & unload" : "start"));
  167.     return 1;
  168.   }
  170.   return 0;
  171. }
  173. // sets read/write speed
  174. // return: 0: OK
  175. //         1: scsi command failed
  176. int YamahaCDR10x::selectSpeed()
  177. {
  178.   unsigned char mp[4];
  180.   if (getModePage6(0x31/*drive configuration mode page*/, mp, 4,
  181.    NULL, NULL, 1) != 0) {
  182.     message(-2, "Cannot retrieve drive configuration mode page (0x31).");
  183.     return 1;
  184.   }
  186.   mp[3] &= 0x0f;
  187.   if(speed_ == 0 || speed_ == 4) {
  188. mp[3] |= 0x20;  // read at 4x, write at 2x (CDR102) or 4x (CDR100)
  189.   } else if(speed_ == 2) {
  190. mp[3] |= 0x10;  // read at 2x, write at 2x
  191.   } else if(speed_ == 1) {
  192. ;   // read at 1x, write at 1x
  193.   } else {
  194. message(-2, "Invalid write speed argument %d. 0, 1, 2 or 4 expected.",
  195. speed_);
  196. return 1;
  197.   }
  199.   if (setModePage6(mp, NULL, NULL, 1) != 0) {
  200.     message(-2, "Cannot set drive configuration mode page for cd speed.");
  201.     return 1;
  202.   }
  204.   return 0;
  205. }
  207. // Sets write parameters via mode pages 0x31 and 0x32.
  208. // return: 0: OK
  209. //         1: scsi command failed
  210. int YamahaCDR10x::setWriteParameters()
  211. {
  212.   unsigned char mp[8]; // the larger of 4 and 8, gets used twice
  214.   if (getModePage6(0x31/*drive configuration mode page*/, mp, 4,
  215.    NULL, NULL, 1) != 0) {
  216.     message(-2, "Cannot retrieve drive configuration mode page (0x31).");
  217.     return 1;
  218.   }
  220.   mp[3] &= 0xf0; // save speed settings in high nibble
  221.   mp[3] |= (simulate_ ? 1 : 0);
  223.   if (setModePage6(mp, NULL, NULL, 1) != 0) {
  224.     message(-2, "Cannot set drive configuration mode page (0x31).");
  225.     return 1;
  226.   }
  228.   memset(mp, 0, 8);
  230.   if (getModePage6(0x32/*write format mode page*/, mp, 8,
  231.    NULL, NULL, 1) != 0) {
  232.     message(-2, "Cannot retrieve write format mode page (0x32).");
  233.     return 1;
  234.   }
  236.   mp[2] &= 0xf0; // RW subcode internally zero supplied
  237.   mp[3] &= 0xf0;
  238.   mp[3] |= 0x04; // disc at once (single session)
  240.   if (setModePage6(mp, NULL, NULL, 1) != 0) {
  241.     message(-2, "Cannot set write format mode page (0x32).");
  242.     return 1;
  243.   }
  245.   return 0;
  246. }
  248. void YamahaCDR10x::cueSheetDataType(TrackData::Mode mode,
  249.     unsigned char *dataType,
  250.     unsigned char *dataForm)
  251. {
  252.   switch (mode) {
  253.   case TrackData::AUDIO:
  254.     *dataType = 0;
  255.     *dataForm = 0;
  256.     break;
  257.     
  258.   case TrackData::MODE1:
  259.   case TrackData::MODE1_RAW:
  260.     *dataType = 2;
  261.     *dataForm = 3;
  262.     break;
  264.   case TrackData::MODE2:
  265.     *dataType = 3;
  266.     *dataForm = 3;
  267.     break;
  269.   case TrackData::MODE2_RAW:
  270.   case TrackData::MODE2_FORM1:
  271.   case TrackData::MODE2_FORM2:
  272.   case TrackData::MODE2_FORM_MIX:
  273.     if (toc_->tocType() == Toc::CD_I)
  274.       *dataType = 4;
  275.     else
  276.       *dataType = 5;
  277.     *dataForm = 3;
  278.     break;
  280.   case TrackData::MODE0:
  281.     message(-3, "Illegal mode in 'YamahaCDR10x::cueSheetDataType()'.");
  282.     *dataType = 0;
  283.     *dataForm = 0;
  284.     break;
  285.   }
  286. }
  288. // Creates cue sheet for current toc.
  289. // cueSheetLen: filled with length of cue sheet in bytes
  290. // return: newly allocated cue sheet buffer or 'NULL' on error
  291. // CHECKS OUT WITH DOS-DAO AND MANUAL
  292. unsigned char *YamahaCDR10x::createCueSheet(long *cueSheetLen)
  293. {
  294.   const Track *t;
  295.   int trackNr;
  296.   Msf start, end, index;
  297.   unsigned char *cueSheet;
  298.   long len = 2; // entries for lead-in, lead-out
  299.   long n; // index into cue sheet
  300.   unsigned char ctl; // control nibbles of cue sheet entry CTL/ADR
  301.   long i;
  302.   unsigned char dataForm;
  303.   unsigned char dataType;
  305.   TrackIterator itr(toc_);
  307.   if (itr.first(start, end) == NULL) {
  308.     return NULL;
  309.   }
  311.   if (toc_->catalogValid()) {
  312.     len += 2;
  313.   }
  315.   for (t = itr.first(start, end), trackNr = 1;
  316.        t != NULL; t = itr.next(start, end), trackNr++) {
  317.     len += 2; // entry for track and mandatory pre-gap
  318.     if (t->type() == TrackData::AUDIO && t->isrcValid()) {
  319.       len += 2; // entries for ISRC code
  320.     }
  321.     len += t->nofIndices(); // entry for each index increment
  322.   }
  324.   cueSheet = new (unsigned char)[len * 8];
  325.   n = 0;
  327.   if (toc_->leadInMode() == TrackData::AUDIO)
  328.     ctl = 0;
  329.   else
  330.     ctl = 0x40;
  332.   if (toc_->catalogValid()) {
  333.     // fill catalog number entry
  334.     cueSheet[n*8] = 0x02 | ctl;
  335.     cueSheet[(n+1)*8] = 0x02 | ctl;
  336.     for (i = 1; i <= 13; i++) {
  337.       if (i < 8) {
  338. cueSheet[n*8 + i] = toc_->catalog(i-1) + '0';
  339.       }
  340.       else {
  341. cueSheet[(n+1)*8 + i - 7] = toc_->catalog(i-1) + '0';
  342.       }
  343.     }
  344.     cueSheet[(n+1)*8+7] = 0;
  345.     n += 2;
  346.   }
  348.   cueSheetDataType(toc_->leadInMode(), &dataType, &dataForm);
  350.   // entry for lead-in
  351.   cueSheet[n*8] = 0x01 | ctl; // CTL/ADR
  352.   cueSheet[n*8+1] = 0;        // Track number
  353.   cueSheet[n*8+2] = 0;        // Index
  354.   cueSheet[n*8+3] = dataType; // Data Type
  355.   cueSheet[n*8+4] = 0;        // Data Form: always 0 for lead-in
  356.   cueSheet[n*8+5] = 0;        // MIN
  357.   cueSheet[n*8+6] = 0;        // SEC
  358.   cueSheet[n*8+7] = 0;        // FRAME
  359.   n++;
  360.   
  361.   for (t = itr.first(start, end), trackNr = 1;
  362.        t != NULL;
  363.        t = itr.next(start, end), trackNr++) {
  365.     cueSheetDataType(t->type(), &dataType, &dataForm);
  367.     ctl = trackCtl(t);
  369.     if (t->type() == TrackData::AUDIO) {
  370.       // set ISRC code for audio track
  371.       if (t->isrcValid()) {
  372. cueSheet[n*8] = ctl | 0x03;
  373. cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  374. cueSheet[n*8+2] = t->isrcCountry(0);
  375. cueSheet[n*8+3] = t->isrcCountry(1);
  376. cueSheet[n*8+4] = t->isrcOwner(0);  
  377. cueSheet[n*8+5] = t->isrcOwner(1);   
  378. cueSheet[n*8+6] = t->isrcOwner(2);  
  379. cueSheet[n*8+7] = t->isrcYear(0) + '0';
  380. n++;
  382. cueSheet[n*8] = ctl | 0x03;
  383. cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  384. cueSheet[n*8+2] = t->isrcYear(1) + '0';
  385. cueSheet[n*8+3] = t->isrcSerial(0) + '0';
  386. cueSheet[n*8+4] = t->isrcSerial(1) + '0';
  387. cueSheet[n*8+5] = t->isrcSerial(2) + '0';
  388. cueSheet[n*8+6] = t->isrcSerial(3) + '0';
  389. cueSheet[n*8+7] = t->isrcSerial(4) + '0';
  390. n++;
  391.       }
  392.     }
  394.     Msf tstart(start.lba() + 150); // start of index 1
  396.     // start of pre-gap, atime equals index 1 if no pre-gap is defined
  397.     Msf pstart(trackNr == 1 ? 0 : tstart.lba() - t->start().lba());
  399.     // entry for pre-gap
  400.     cueSheet[n*8]   = ctl | 0x01;
  401.     cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  402.     cueSheet[n*8+2] = 0;        // Index 0 indicates pre-gap
  403.     cueSheet[n*8+3] = dataType; // Data Type
  404.     cueSheet[n*8+4] = dataForm; // Data Form
  405.     cueSheet[n*8+5] = SubChannel::bcd(pstart.min());
  406.     cueSheet[n*8+6] = SubChannel::bcd(pstart.sec());
  407.     cueSheet[n*8+7] = SubChannel::bcd(pstart.frac());
  408.     n++;
  410.     cueSheet[n*8]   = ctl | 0x01;
  411.     cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  412.     cueSheet[n*8+2] = 1;        // Index 1
  413.     cueSheet[n*8+3] = dataType; // Data Type
  414.     cueSheet[n*8+4] = dataForm; // Data Form
  415.     cueSheet[n*8+5] = SubChannel::bcd(tstart.min());
  416.     cueSheet[n*8+6] = SubChannel::bcd(tstart.sec());
  417.     cueSheet[n*8+7] = SubChannel::bcd(tstart.frac());
  418.     n++;
  420.     for (i = 0; i < t->nofIndices(); i++) {
  421.       index = tstart + t->getIndex(i);
  422.       cueSheet[n*8]   = ctl | 0x01;
  423.       cueSheet[n*8+1] = SubChannel::bcd(trackNr);
  424.       cueSheet[n*8+2] = SubChannel::bcd(i+2); // Index
  425.       cueSheet[n*8+3] = dataType;    // DataType
  426.       cueSheet[n*8+4] = dataForm;    // Data Form
  427.       cueSheet[n*8+5] = SubChannel::bcd(index.min());
  428.       cueSheet[n*8+6] = SubChannel::bcd(index.sec());
  429.       cueSheet[n*8+7] = SubChannel::bcd(index.frac());
  430.       n++;
  431.     }
  432.   }
  434.   assert(n == len - 1);
  436.   // entry for lead out
  437.   Msf lostart(toc_->length().lba() + 150);
  438.   cueSheetDataType(toc_->leadOutMode(), &dataType, &dataForm);
  439.   ctl = toc_->leadOutMode() == TrackData::AUDIO ? 0 : 0x40;
  440.     
  441.   cueSheet[n*8]   = ctl | 0x01;
  442.   cueSheet[n*8+1] = 0xaa; // This IS BCD
  443.   cueSheet[n*8+2] = 1; // Index 1
  444.   cueSheet[n*8+3] = dataType; // Data for lead-out
  445.   cueSheet[n*8+4] = 0;        // Data Form, always 0 for lead-out
  446.   cueSheet[n*8+5] = SubChannel::bcd(lostart.min());
  447.   cueSheet[n*8+6] = SubChannel::bcd(lostart.sec());
  448.   cueSheet[n*8+7] = SubChannel::bcd(lostart.frac());
  450.   message(3, "nCue Sheet:");
  451.   message(3, "CTL/  TNO  INDEX  DATA  DATA  MIN  SEC  FRAME");
  452.   message(3, "ADR   BCD  BCD    TYPE  Form  BCD  BCD  BCD <- Note");
  453.   for (n = 0; n < len; n++) {
  454.     message(3, "%02x    %02x    %02x     %02x    %02x   %02x   %02x   %02x",
  455.    cueSheet[n*8],
  456.    cueSheet[n*8+1], cueSheet[n*8+2], cueSheet[n*8+3], cueSheet[n*8+4],
  457.    cueSheet[n*8+5], cueSheet[n*8+6], cueSheet[n*8+7]);
  458.   }
  460.   *cueSheetLen = len * 8;
  461.   return cueSheet;
  462. }
  464. // LOOKS GOOD
  465. int YamahaCDR10x::sendCueSheet()
  466. {
  467.   unsigned char cmd[10];
  468.   long cueSheetLen;
  469.   unsigned char *cueSheet = createCueSheet(&cueSheetLen);
  471.   if (cueSheet == NULL) {
  472.     return 1;
  473.   }
  475.   if(cueSheetLen > 32768) {  // Limit imposed by drive.
  476.     message(-2, "Cue sheet too long for this device: Limit is 32k bytes.");
  477.     delete[] cueSheet;
  478.     return 1;
  479.   }
  481.   memset(cmd, 0, 10);
  483.   cmd[0] = 0xea; // Yamaha Vendor Specific WRITE TOC
  485.   cmd[7] = cueSheetLen >> 8;
  486.   cmd[8] = cueSheetLen;
  488.   if (sendCmd(cmd, 10, cueSheet, cueSheetLen, NULL, 0) != 0) {
  489.     message(-2, "Cannot send cue sheet.");
  490.     delete[] cueSheet;
  491.     return 1;
  492.   }
  494.   delete[] cueSheet;
  495.   return 0;
  496. }
  498. // DOES NOT TALK TO DRIVE: JUST HOUSEKEEPING
  499. int YamahaCDR10x::initDao(const Toc *toc)
  500. {
  501.   long n;
  503.   toc_ = toc;
  505.   blockLength_ = AUDIO_BLOCK_LEN;
  506.   blocksPerWrite_ = scsiIf_->maxDataLen() / blockLength_;
  508.   assert(blocksPerWrite_ > 0);
  510.   if (selectSpeed() != 0) {
  511.     return 1;
  512.   }
  514.   // allocate buffer for writing zeros
  515.   n = blocksPerWrite_ * blockLength_;
  516.   delete[] zeroBuffer_;
  517.   zeroBuffer_ = new char[n];
  518.   memset(zeroBuffer_, 0, n);
  520.   return 0;
  521. }
  523. // LOOKS OK - dodgy WRITE TRACK parameters, but apparently how DAO16 does it
  524. int YamahaCDR10x::startDao()
  525. {
  526.   unsigned char cmd[10];
  528.   scsiTimeout_ = scsiIf_->timeout(3 * 60);
  530.   if (setWriteParameters() != 0 ||
  531.       sendCueSheet() != 0) {
  532.     return 1;
  533.   }
  535.   memset(cmd, 0, 10);
  536.   cmd[0] = 0xe6;  // Yamaha WRITE TRACK(10)
  537.   cmd[5] = 0; // Track Number
  538.   cmd[6] &= 0xdf; // R Parity = 0;
  539.   cmd[6] &= 0xef; // Byte Swap = 0 = little endian
  540.   cmd[6] &= 0xf7; // Copy = 0
  541.   cmd[6] &= 0xfb; // Audio = 0 (false)
  542.   cmd[6] &= 0xfc; // Mode=0 NB This combination of mode/audio is reserved
  543.   // so we end up sending a bare e6 command with nine bytes of nulls
  545.   if (sendCmd(cmd, 10, NULL, 0, NULL, 0) != 0) {
  546. message(-2, "Could not send command 0xE6: WRITE TRACK(10)");
  547. return 1;
  548.   }
  550.   //message(1, "Writing lead-in and gap...");
  552.   long lba = -150;
  554.   if (writeZeros(toc_->leadInMode(), lba, 0, 150) != 0) {
  555.     return 1;
  556.   }
  557.   
  558.   return 0;
  559. }
  561. int YamahaCDR10x::finishDao()
  562. {
  563.   unsigned char cmd[6];
  564.   const unsigned char *sense;
  565.   int senseLen;
  567.   message(1, "Flushing cache...");
  568.   
  569.   if (flushCache() != 0) {
  570.     return 1;
  571.   }
  573.   memset(cmd, 0, 6);
  575.   // wait until lead-out is written
  576.   while(sendCmd(cmd, 6, NULL, 0, NULL, 0, 0) == 2
  577. && (sense = scsiIf_->getSense(senseLen)) && senseLen 
  578. && sense[2] == 0x0b  && sense[0xc] == 0x50) {
  579.     sleep(1);
  580.   }
  582.   scsiIf_->timeout(scsiTimeout_);
  584.   delete[] zeroBuffer_, zeroBuffer_ = NULL;
  586.   return 0;
  587. }
  589. void YamahaCDR10x::abortDao()
  590. {
  591.   flushCache();
  592. }
  594. ///////////////////////// FIXME THE TOP BAR //////////////////////////////
  596. // NEEDS WORK
  597. DiskInfo *YamahaCDR10x::diskInfo()
  598. {
  599.   unsigned char cmd[10];
  600.   unsigned long dataLen = 8;
  601.   unsigned char data[8];
  602.   static DiskInfo di;
  603.   //char spd;
  605.   memset(&di, 0, sizeof(DiskInfo));
  607.   di.valid.cdrw = 0; // by definition, for this device
  609.   memset(cmd, 0, 10);
  610.   memset(data, 0, dataLen);
  612.   // This looks like CdrDevice::readCapacity, but with a difference: we
  613.   // get data for a ROM, and we need to check that our disc is writable
  615.   cmd[0] = 0x25; // READ CD-ROM CAPACITY
  616.  
  617.   if (sendCmd(cmd, 10, NULL, 0, data, dataLen) != 0) {
  618.     message(-1, "Cannot read CD-ROM capacity.");
  619.     return &di;
  620.   }
  622.   if(data[4] | data[5] | data[6] | data[7]) { // block length field, 0=writable
  623. di.capacity = 0;
  624.   } else { // disk is writable
  625. di.capacity = data[0]<<24 | data[1]<<16 | data[2]<<8 | data[3];
  626.   }
  627.   di.valid.capacity = 1;
  629.   // FIXME: need to come up with empty, manufacturerID, recSpeed
  631.   // maybe use READ DISC INFO (0x43) here? se p. 62
  632. /////////////////////////////////////////
  633.   
  634.   return &di;
  635. }
  638. // tries to read catalog number from disk and adds it to 'toc'
  639. // return: 1 if valid catalog number was found, else 0
  640. int YamahaCDR10x::readCatalog(Toc *toc, long startLba, long endLba)
  641. {
  642.   unsigned char cmd[10];
  643.   unsigned char data[24];
  644.   char catalog[14];
  645.   int i;
  647.   memset(cmd, 0, 10);
  648.   memset(data, 0, 24);
  650.   cmd[0] = 0x42; // READ SUB-CHANNEL
  651.   cmd[2] = 1 << 6;
  652.   cmd[3] = 0x02; // get media catalog number
  653.   cmd[8] = 24;   // transfer length
  655.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  656.     message(-2, "Cannot get catalog number.");
  657.     return 0;
  658.   }
  660.   if (data[8] & 0x80) {
  661.     for (i = 0; i < 13; i++) {
  662.       catalog[i] = data[0x09 + i];
  663.     }
  664.     catalog[13] = 0;
  666.     if (toc->catalog(catalog) == 0) {
  667.       return 1;
  668.     }
  669.   }
  671.   return 0;
  672. }
  674. int YamahaCDR10x::readIsrc(int trackNr, char *buf)
  675. {
  676.   unsigned char cmd[10];
  677.   unsigned char data[24];
  678.   int i;
  680.   buf[0] = 0;
  682.   memset(cmd, 0, 10);
  683.   memset(data, 0, 24);
  685.   cmd[0] = 0x42; // READ SUB-CHANNEL
  686.   cmd[2] = 1 << 6;
  687.   cmd[3] = 0x03; // get ISRC
  688.   cmd[6] = trackNr;
  689.   cmd[8] = 24;   // transfer length
  691.   if (sendCmd(cmd, 10, NULL, 0, data, 24) != 0) {
  692.     message(-2, "Cannot get ISRC code.");
  693.     return 0;
  694.   }
  696.   // FIXME this looks right, but the offsets could be wrong
  697.   if (data[8] & 0x80) {
  698.     for (i = 0; i < 12; i++) {
  699.       buf[i] = data[0x09 + i];
  700.     }
  701.     buf[12] = 0;
  702.   }
  704.   return 0;
  705. }
  707. int YamahaCDR10x::analyzeTrack(TrackData::Mode mode, int trackNr,
  708.        long startLba,
  709.        long endLba, Msf *indexIncrements,
  710.        int *indexIncrementCnt, long *pregap,
  711.        char *isrcCode, unsigned char *ctl)
  712. {
  713.   int ret = analyzeTrackScan(mode, trackNr, startLba, endLba,
  714.      indexIncrements, indexIncrementCnt, pregap,
  715.      isrcCode, ctl);
  717.   if (mode == TrackData::AUDIO)
  718.     readIsrc(trackNr, isrcCode);
  719.   else
  720.     *isrcCode = 0;
  722.   return ret;
  723. }
  725. int YamahaCDR10x::readSubChannels(long lba, long len, SubChannel ***chans,
  726.   Sample *audioData)
  727. {
  728.   int retries = 5;
  729.   int i;
  730.   unsigned char cmd[12];
  731.   
  732.   cmd[0] = 0xd8;  // Yamaha READ CD-DA
  733.   cmd[1] = 0;
  734.   cmd[2] = lba >> 24;
  735.   cmd[3] = lba >> 16;
  736.   cmd[4] = lba >> 8;
  737.   cmd[5] = lba;
  738.   cmd[6] = len >> 24;
  739.   cmd[7] = len >> 16;
  740.   cmd[8] = len >> 8;
  741.   cmd[9] = len;
  742.   cmd[10] = 0x01;  // 2352 + 10 Q (no CRC) + 6 NULL
  743.   cmd[11] = 0;
  745.   while (1) {
  746.     if (sendCmd(cmd, 12, NULL, 0,
  747. transferBuffer_, len * (AUDIO_BLOCK_LEN + 16),
  748. retries == 0 ? 1 : 0) != 0) {
  749.       if (retries == 0)
  750. return 1;
  751.     }
  752.     else {
  753.       break;
  754.     }
  756.     retries--;
  757.   }
  759.   for (i = 0; i < len; i++) {
  760.     PQSubChannel16 *chan = (PQSubChannel16*)scannedSubChannels_[i];
  761.     unsigned char *p =
  762.       transferBuffer_  + i * (AUDIO_BLOCK_LEN + 16) + AUDIO_BLOCK_LEN;
  764.     // slightly reorder the sub-channel so it is suitable for 'PQSubChannel16'
  765.     p[0] <<= 4;   // ctl/adr
  766.     p[0] |= p[1];
  767.     p[1] = p[2];  // track nr
  768.     p[2] = p[3];  // index nr
  769.     p[3] = p[4];  // min
  770.     p[4] = p[5];  // sec
  771.     p[5] = p[6];  // frame
  772.     p[6] = 0;     // zero
  773.     // p[7] is amin
  774.     // p[8] is asec
  775.     // p[9] is aframe
  777.     chan->init(p);
  778.     
  779.     if (chan->checkConsistency())
  780.       chan->calcCrc();
  781.   }
  783.   if (audioData != NULL) {
  784.     unsigned char *p = transferBuffer_;
  786.     for (i = 0; i < len; i++) {
  787.       memcpy(audioData, p, AUDIO_BLOCK_LEN);
  789.       p += AUDIO_BLOCK_LEN + 16;
  790.       audioData += SAMPLES_PER_BLOCK;
  791.     }
  792.   }
  793.   
  794.   *chans = scannedSubChannels_;
  795.   return 0;
  796. }
  798. // LOOKSGOOD, except for accurate audio stream bit
  799. int YamahaCDR10x::driveInfo(DriveInfo *info, int showErrorMsg)
  800. {
  801.   unsigned char mp[4];
  803.   if (getModePage6(0x31, mp, 4, NULL, NULL, showErrorMsg) != 0) {
  804.     if (showErrorMsg) {
  805.       message(-2, "Cannot retrieve drive configuration mode page (0x31).");
  806.     }
  807.     return 1;
  808.   }
  810.   // FIXME
  811.   // info->accurateAudioStream = mp[5] & 0x02 ? 1 : 0;
  812.   info->accurateAudioStream = 0;
  814.   info->maxReadSpeed = mult2Speed(4);
  816.   if(!strncmp(scsiIf_->product(), "CDR100", 6)) {
  817. info->maxWriteSpeed = mult2Speed(4);
  818. info->currentWriteSpeed = info->currentReadSpeed = 
  819. mult2Speed(1 << (mp[3] >> 4));
  820.   } else { // CDR102, crippled to 2x write
  821. info->maxWriteSpeed = mult2Speed(2);
  822. info->currentReadSpeed = mult2Speed(1 << (mp[3] >> 4));
  823. info->currentWriteSpeed = mult2Speed((mp[3] >> 4) ? 2 : 1);
  824.   }
  826.   return 0;
  827. }
  829. // writeData is overridden here because the CDR10x, while writing the disc
  830. // lead-in with the buffer full, will return CHECK CONDITION with sense
  831. // DRIVE BUSY and additional sense 0xb8 = WRITE LEAD-IN IN PROGRESS.
  832. // This is normal operation and the write should be retried until successful.
  834. // Writes data to target, the block length depends on the actual writing mode
  835. // 'len' is number of blocks to write.
  836. // 'lba' specifies the next logical block address for writing and is updated
  837. // by this function.
  838. // return: 0: OK
  839. //         1: scsi command failed
  840. int YamahaCDR10x::writeData(TrackData::Mode mode, long &lba, const char *buf,
  841.     long len)
  842. {
  843.   assert(blocksPerWrite_ > 0);
  844.   int writeLen = 0;
  845.   unsigned char cmd[10];
  846.   int retry;
  847.   int retval;
  848.   long blockLength = blockSize(mode);
  850. #if 0
  851.   long sum, i;
  853.   sum = 0;
  855.   for (i = 0; i < len * blockLength; i++) {
  856.     sum += buf[i];
  857.   }
  859.   message(0, "W: %ld: %ld, %ld, %ld", lba, blockLength, len, sum);
  860. #endif
  862.   memset(cmd, 0, 10);
  863.   cmd[0] = 0x2a; // WRITE1
  864.   
  865.   while (len > 0) {
  866.     writeLen = (len > blocksPerWrite_ ? blocksPerWrite_ : len);
  868.     cmd[2] = lba >> 24;
  869.     cmd[3] = lba >> 16;
  870.     cmd[4] = lba >> 8;
  871.     cmd[5] = lba;
  873.     cmd[7] = writeLen >> 8;
  874.     cmd[8] = writeLen & 0xff;
  876.     do {
  877.       retry = 0;
  878.       retval = sendCmd(cmd, 10, (unsigned char *)buf, writeLen * blockLength,
  879.        NULL, 0, 0);
  880.       if(retval == 2) {
  881.         const unsigned char *sense;
  882.         int senseLen;
  884.         sense = scsiIf_->getSense(senseLen);
  886. // we spin on the write here, waiting a reasonable time in between
  887. // we should really use READ BLOCK LIMIT (0x05)
  888. if(senseLen && sense[2] == 9 && sense[0xc] == 0xb8) {
  889.   mSleep(40);
  890.           retry = 1;
  891.         }
  892. else {
  893.   scsiIf_->printError();
  894. }
  895.       }
  896.     } while(retry == 1);
  898.     if(retval) {
  899.       message(-2, "Write data failed.");
  900.       return 1;
  901.     }
  903.     buf += writeLen * blockLength;
  905.     lba += writeLen;
  906.     len -= writeLen;
  907.   }
  908.       
  909.   return 0;
  910. }
  912. CdRawToc *YamahaCDR10x::getRawToc(int sessionNr, int *len)
  913. {
  914.   // not supported by drive
  915.   return NULL;
  916. }
  919. long YamahaCDR10x::readTrackData(TrackData::Mode mode, long lba, long len,
  920.  unsigned char *buf)
  921. {
  922.   unsigned char cmd[10];
  923.   long blockLen = 2340;
  924.   long i;
  925.   TrackData::Mode actMode;
  926.   int ok = 0;
  927.   int softError;
  928.   const unsigned char *sense;
  929.   int senseLen;
  931.   if (setBlockSize(blockLen) != 0)
  932.     return 0;
  934.   memset(cmd, 0, 10);
  936.   cmd[0] = 0x28; // READ10
  937.   cmd[2] = lba >> 24;
  938.   cmd[3] = lba >> 16;
  939.   cmd[4] = lba >> 8;
  940.   cmd[5] = lba;
  942.   while (len > 0 && !ok) {
  943.     cmd[7] = len >> 8;
  944.     cmd[8] = len;
  946.     memset(transferBuffer_, 0, len * blockLen);
  947.     switch (sendCmd(cmd, 10, NULL, 0, transferBuffer_, len * blockLen, 0)) {
  948.     case 0:
  949.       ok = 1;
  950.       break;
  952.     case 2:
  953.       softError = 0;
  954.       sense = scsiIf_->getSense(senseLen);
  956.       if (senseLen > 0x0c) {
  957. if ((sense[2] &0x0f) == 5) {
  958.   switch (sense[12]) {
  959.   case 0x63: // end of user area encountered on this track
  960.   case 0x64: // Illegal mode for this track
  961.     softError = 1;
  962.     break;
  963.   }
  964. }
  965. else if ((sense[2] & 0x0f) == 3) { // Medium error
  966.   switch (sense[12]) {
  967.   case 0x02: // No seek complete, sector not found
  968.   case 0x11: // L-EC error
  969.     return -2;
  970.     break;
  971.   }
  972. }
  973.       }
  975.       if (!softError) {
  976. scsiIf_->printError();
  977. return -1;
  978.       }
  979.       break;
  981.     default:
  982.       message(-2, "Read error at LBA %ld, len %ld", lba, len);
  983.       return -1;
  984.       break;
  985.     }
  987.     if (!ok) {
  988.       len--;
  989.     }
  990.   }
  992.   unsigned char *sector = transferBuffer_;
  993.   for (i = 0; i < len; i++) {
  994.     actMode = determineSectorMode(sector);
  996.     if (!(actMode == mode ||
  997.   (mode == TrackData::MODE2_FORM_MIX &&
  998.    (actMode == TrackData::MODE2_FORM1 ||
  999.     actMode == TrackData::MODE2_FORM2)) ||
  1001.   (mode == TrackData::MODE1_RAW && actMode == TrackData::MODE1) ||
  1003.   (mode == TrackData::MODE2_RAW &&
  1004.    (actMode == TrackData::MODE2 ||
  1005.     actMode == TrackData::MODE2_FORM1 ||
  1006.     actMode == TrackData::MODE2_FORM2)))) {
  1007.       return i;
  1008.     }
  1010.     if (buf != NULL) {
  1011.       switch (mode) {
  1012.       case TrackData::MODE1:
  1013. memcpy(buf, sector + 4, MODE1_BLOCK_LEN);
  1014. buf += MODE1_BLOCK_LEN;
  1015. break;
  1016.       case TrackData::MODE2:
  1017.       case TrackData::MODE2_FORM_MIX:
  1018. memcpy(buf, sector + 4, MODE2_BLOCK_LEN);
  1019. buf += MODE2_BLOCK_LEN;
  1020. break;
  1021.       case TrackData::MODE2_FORM1:
  1022. memcpy(buf, sector + 12, MODE2_FORM1_DATA_LEN);
  1023. buf += MODE2_FORM1_DATA_LEN;
  1024. break;
  1025.       case TrackData::MODE2_FORM2:
  1026. memcpy(buf, sector + 12, MODE2_FORM2_DATA_LEN);
  1027. buf += MODE2_FORM2_DATA_LEN;
  1028. break;
  1029.       case TrackData::MODE1_RAW:
  1030.       case TrackData::MODE2_RAW:
  1031. memcpy(buf, syncPattern, 12);
  1032. memcpy(buf + 12, sector, 2340);
  1033. buf += AUDIO_BLOCK_LEN;
  1034. break;
  1035.       case TrackData::MODE0:
  1036.       case TrackData::AUDIO:
  1037. message(-3, "YamahaCDR10x::readTrackData: Illegal mode.");
  1038. return 0;
  1039. break;
  1040.       }
  1041.     }
  1043.     sector += blockLen;
  1044.   }  
  1046.   return len;
  1047. }
  1049. Toc *YamahaCDR10x::readDiskToc(int session, const char *audioFilename)
  1050. {
  1051.   Toc *toc = CdrDriver::readDiskToc(session, audioFilename);
  1053.   setBlockSize(MODE1_BLOCK_LEN);
  1054.   
  1055.   return toc;
  1056. }
  1058. Toc *YamahaCDR10x::readDisk(int session, const char *fname)
  1059. {
  1060.   Toc *toc = CdrDriver::readDisk(session, fname);
  1062.   setBlockSize(MODE1_BLOCK_LEN);
  1064.   return toc;
  1065. }
  1067. int YamahaCDR10x::readAudioRange(int fd, long start, long end,
  1068.  int startTrack, int endTrack, TrackInfo *info)
  1069. {
  1070.   if (!onTheFly_) {
  1071.     int t;
  1073.     message(1, "Analyzing...");
  1074.     
  1075.     for (t = startTrack; t <= endTrack; t++) {
  1076.       message(1, "Track %d...", t + 1);
  1077.       info[t].isrcCode[0] = 0;
  1078.       readIsrc(t + 1, info[t].isrcCode);
  1079.       if (info[t].isrcCode[0] != 0)
  1080. message(1, "Found ISRC code.");
  1081.     }
  1083.     message(1, "Reading...");
  1084.   }
  1086.   return CdrDriver::readAudioRangeParanoia(fd, start, end, startTrack,
  1087.    endTrack, info);
  1088. }