iodev/cdrom_amigaos.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: cdrom_amigaos.cc,v 1.14 2008/01/26 22:24:00 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2000  MandrakeSoft S.A.
   6 //
   7 //    MandrakeSoft S.A.
   8 //    43, rue d'Aboukir
   9 //    75002 Paris - France
  10 //    http://www.linux-mandrake.com/
  11 //    http://www.mandrakesoft.com/
  12 //
  13 //  This library is free software; you can redistribute it and/or
  14 //  modify it under the terms of the GNU Lesser General Public
  15 //  License as published by the Free Software Foundation; either
  16 //  version 2 of the License, or (at your option) any later version.
  17 //
  18 //  This library is distributed in the hope that it will be useful,
  19 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 //  Lesser General Public License for more details.
  22 //
  23 //  You should have received a copy of the GNU Lesser General Public
  24 //  License along with this library; if not, write to the Free Software
  25 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26
  27
  28 // These are the low-level CDROM functions which are called
  29 // from 'harddrv.cc'.  They effect the OS specific functionality
  30 // needed by the CDROM emulation in 'harddrv.cc'.  Mostly, just
  31 // ioctl() calls and such.  Should be fairly easy to add support
  32 // for your OS if it is not supported yet.
  33
  34
  35 #include "bochs.h"
  36 #include "scsi_commands.h"
  37 #include "cdrom.h"
  38
  39 #include <exec/types.h>
  40 #include <exec/memory.h>
  41 #include <devices/trackdisk.h>
  42 #include <devices/scsidisk.h>
  43 #include <dos/dos.h>
  44 #include <proto/dos.h>
  45 #include <proto/exec.h>
  46 #include <clib/alib_protos.h>
  47 #include <stdio.h>
  48
  49 #define LOG_THIS /* no SMF tricks here, not needed */
  50
  51 #define BX_CD_FRAMESIZE 2048
  52 #define CD_FRAMESIZE    2048
  53 #define SENSELEN 32
  54 #define MAX_DATA_LEN 252
  55
  56 int amiga_cd_unit;
  57 char amiga_cd_device[256];
  58
  59 struct MsgPort *CDMP; /* Pointer for message port */
  60 struct IOExtTD *CDIO; /* Pointer for IORequest */
  61 int cd_error;
  62
  63 typedef struct {
  64         UBYTE pad0;
  65         UBYTE trackType;
  66         UBYTE trackNum;
  67         UBYTE pad1;
  68         ULONG startFrame;
  69 } TOCENTRY;
  70
  71 typedef struct {
  72         UWORD    length;
  73         UBYTE    firstTrack;
  74         UBYTE    lastTrack;
  75         TOCENTRY tocs[100];
  76 } TOC;
  77
  78 typedef struct {
  79         ULONG sectors;
  80         ULONG blocksize;
  81 } CAPACITY;
  82
  83 unsigned char sensebuf[SENSELEN];
  84
  85 int DoSCSI (UBYTE * data, int datasize, UBYTE * cmd, int cmdsize, UBYTE flags);
  86
  87 cdrom_interface::cdrom_interface(char *dev)
  88 {
  89   char buf[256];
  90
  91   sscanf(dev, "%s%s", amiga_cd_device, buf);
  92   amiga_cd_unit = atoi(buf);
  93
  94   CDMP = CreateMsgPort();
  95   if (CDMP != NULL) {
  96     CDIO = (struct IOExtTD *)CreateIORequest(CDMP, sizeof(struct IOExtTD));
  97     if (CDIO != NULL) {
  98       cd_error = OpenDevice(amiga_cd_device, amiga_cd_unit, (struct IORequest *)CDIO, 0);
  99       if (cd_error != 0)
 100         BX_PANIC(("CD_Open: could not open device %s unit %d\n", amiga_cd_device, amiga_cd_unit));
 101     }
 102   }
 103 }
 104
 105 cdrom_interface::~cdrom_interface(void)
 106 {
 107   if (cd_error == 0) {
 108     CloseDevice((struct IORequest *)CDIO);
 109   }
 110   if (CDIO != NULL) {
 111     DeleteIORequest((struct IORequest *)CDIO);
 112   }
 113   if (CDMP != NULL) {
 114     DeleteMsgPort(CDMP);
 115   }
 116 }
 117
 118   bx_bool
 119 cdrom_interface::insert_cdrom(char *dev)
 120 {
 121   Bit8u cdb[6];
 122   Bit8u buf[2*BX_CD_FRAMESIZE];
 123   Bit8u i = 0;
 124
 125   memset(cdb,0,sizeof(cdb));
 126
 127   cdb[0] = SCSI_DA_START_STOP_UNIT;
 128   cdb[4] = 1 | 2;
 129
 130   DoSCSI(0, 0,cdb,sizeof(cdb),SCSIF_READ);
 131
 132   /*Check if there's a valid media present in the drive*/
 133   CDIO->iotd_Req.io_Data    = buf;
 134   CDIO->iotd_Req.io_Command = CMD_READ;
 135   CDIO->iotd_Req.io_Length  = BX_CD_FRAMESIZE;
 136   CDIO->iotd_Req.io_Offset  = BX_CD_FRAMESIZE;
 137
 138   for(i = 0; i < 200; i++) /*it takes a while for the cdrom to validate*/
 139   {
 140         DoIO((struct IORequest *)CDIO);
 141     if (CDIO->iotd_Req.io_Error == 0)
 142         break;
 143     Delay (10);
 144   }
 145
 146   if (CDIO->iotd_Req.io_Error != 0)
 147     return false;
 148   else
 149     return true;
 150 }
 151
 152
 153   void
 154 cdrom_interface::eject_cdrom()
 155 {
 156   Bit8u cdb[6];
 157
 158   memset(cdb,0,sizeof(cdb));
 159
 160   cdb[0] = SCSI_DA_START_STOP_UNIT;
 161   cdb[4] = 0 | 2;
 162
 163   DoSCSI(0, 0,cdb,sizeof(cdb),SCSIF_READ);
 164 }
 165
 166
 167   bx_bool
 168 cdrom_interface::read_toc(Bit8u* buf, int* length, bx_bool msf, int start_track, int format)
 169 {
 170   Bit8u cdb[10];
 171   TOC *toc;
 172   toc = (TOC*) buf;
 173
 174   if (format != 0)
 175     return false;
 176
 177   memset(cdb,0,sizeof(cdb));
 178
 179   cdb[0] = SCSI_CD_READ_TOC;
 180
 181   if (msf)
 182     cdb[1] = 2;
 183   else
 184     cdb[1] = 0;
 185
 186   cdb[6] = start_track;
 187   cdb[7] = sizeof(TOC)>>8;
 188   cdb[8] = sizeof(TOC)&0xFF;
 189
 190   DoSCSI((UBYTE *)buf, sizeof(TOC), cdb, sizeof(cdb), SCSIF_READ);
 191
 192   *length = toc->length + 4;
 193
 194   return true;
 195 }
 196
 197
 198   Bit32u
 199 cdrom_interface::capacity()
 200 {
 201   CAPACITY cap;
 202   Bit8u cdb[10];
 203
 204   memset(cdb,0,sizeof(cdb));
 205   cdb[0] = SCSI_DA_READ_CAPACITY;
 206
 207   int err;
 208
 209   if ((err = DoSCSI((UBYTE *)&cap, sizeof(cap),
 210                     cdb, sizeof (cdb),
 211                     (SCSIF_READ | SCSIF_AUTOSENSE))) == 0)
 212     return(cap.sectors);
 213   else
 214     BX_PANIC (("Couldn't get media capacity"));
 215 }
 216
 217   bx_bool
 218 cdrom_interface::read_block(Bit8u* buf, int lba, int blocksize)
 219 {
 220   CDIO->iotd_Req.io_Data    = buf;
 221   CDIO->iotd_Req.io_Command = CMD_READ;
 222   CDIO->iotd_Req.io_Length  = BX_CD_FRAMESIZE;
 223   CDIO->iotd_Req.io_Offset  = lba * BX_CD_FRAMESIZE;
 224   DoIO((struct IORequest *)CDIO);
 225
 226   if (CDIO->iotd_Req.io_Error != 0) {
 227     BX_PANIC(("Error %d reading CD data sector: %ld", CDIO->iotd_Req.io_Error, lba));
 228     return 0;
 229   }
 230   return 1;
 231 }
 232
 233   bx_bool
 234 cdrom_interface::start_cdrom()
 235 {
 236   // Spin up the cdrom drive.
 237
 238   if (fd >= 0) {
 239     BX_INFO(("start_cdrom: your OS is not supported yet."));
 240     return 0; // OS not supported yet, return 0 always.
 241   }
 242   return 0;
 243 }
 244
 245
 246 int DoSCSI(UBYTE *data, int datasize, Bit8u *cmd,int cmdsize, UBYTE direction)
 247 {
 248   struct SCSICmd scmd;
 249
 250   CDIO->iotd_Req.io_Command = HD_SCSICMD;
 251   CDIO->iotd_Req.io_Data    = &scmd;
 252   CDIO->iotd_Req.io_Length  = sizeof(scmd);
 253
 254   scmd.scsi_Data        = (UWORD *)data;
 255   scmd.scsi_Length      = datasize;
 256   scmd.scsi_SenseActual = 0;
 257   scmd.scsi_SenseData   = sensebuf;
 258   scmd.scsi_SenseLength = SENSELEN;
 259   scmd.scsi_Command     = cmd;
 260   scmd.scsi_CmdLength   = cmdsize;
 261   scmd.scsi_Flags       = SCSIF_AUTOSENSE | direction;
 262
 263   DoIO((struct IORequest *)CDIO);
 264
 265   if (CDIO->iotd_Req.io_Error != 0) {
 266     BX_PANIC(("DoSCSI: error %d", CDIO->iotd_Req.io_Error));
 267   }
 268
 269   return CDIO->iotd_Req.io_Error;
 270 }
 271
 272 void cdrom_interface::seek(int lba)
 273 {
 274   unsigned char buffer[BX_CD_FRAMESIZE];
 275
 276   read_block(buffer, lba, BX_CD_FRAMESIZE);
 277 }