Logo Search packages:      
Sourcecode: cdrkit version File versions  Download package

scsi-amigaos.c

/*
 * This file has been modified for the cdrkit suite.
 *
 * The behaviour and appearence of the program code below can differ to a major
 * extent from the version distributed by the original author(s).
 *
 * For details, see Changelog file distributed with the cdrkit package. If you
 * received this file from another source then ask the distributing person for
 * a log of modifications.
 *
 */

/* @(#)scsi-amigaos.c   1.6 04/01/14 Copyright 1997,2000-2003 J. Schilling */
/*
 *    Interface for the AmigaOS generic SCSI implementation.
 *
 *    Warning: you may change this source, but if you do that
 *    you need to change the _usal_version and _usal_auth* string below.
 *    You may not return "schily" for an SCG_AUTHOR request anymore.
 *    Choose your name instead of "schily" and make clear that the version
 *    string is related to a modified source.
 *
 *    Copyright (c) 1997, 2000-2003 J. Schilling
 *    AmigaOS support code written by T. Langer
 */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; see the file COPYING.  If not, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#define     BOOL  int

#include <strdefs.h>
#include <exec/ports.h>
#include <exec/io.h>
#include <exec/errors.h>
#include <devices/scsidisk.h>
#include <devices/timer.h>
#include <exec/semaphores.h>
#include <exec/memory.h>
#include <exec/execbase.h>
#include <clib/exec_protos.h>
#include <clib/alib_protos.h>

/*
 *    Warning: you may change this source, but if you do that
 *    you need to change the _usal_version and _usal_auth* string below.
 *    You may not return "schily" for an SCG_AUTHOR request anymore.
 *    Choose your name instead of "schily" and make clear that the version
 *    string is related to a modified source.
 */
static      char  _usal_trans_version[] = "scsi-amigaos.c-1.6";   /* The version for this transport */
static      char  _usal_auth[] = "T. Langer";

#define     MAX_SCG           8     /* Max # of SCSI controllers */
#define     MAX_TGT           8
#define     MAX_LUN           8
#define     MAX_DEV           MAX_SCG*MAX_TGT*MAX_LUN

struct usal_local{
      int   usalfiles[MAX_SCG][MAX_TGT][MAX_LUN];
};

#define     usallocal(p)      ((struct usal_local*)((p)->local))

#define     MAX_DMA_AMIGAOS (64*1024)

static struct IOReq {
      struct IOStdReq *ioReq;
      int         ref_count;
} request[MAX_DEV];

static      char                          *devs[MAX_SCG];
static      struct MsgPort          *ioMsgPort = NULL;
static      struct timerequest      *timer_io = NULL;
static      struct MsgPort          *timerMsgPort = NULL;
static      int               initialized = 0;
static      int               last_bus = -1;
/* my private var: for debug purpose only */
static      int               ami_debug = 0;

extern      struct ExecBase         *SysBase;
#define     IOERR_TIMEOUT           (-8)
#define     CHECK_CONDITION         0x02
#define     DUNIT(b, t, l)          (100 * b) + (10 * (l < 0 ? 0:l)) + t

static      void  amiga_init(void);
static      int   amiga_open_scsi(int bus, int tgt, int lun, SCSI *usalp);
static      void  amiga_close_scsi(int fd);
static      void  amiga_close_scsi_all(void);
static      void  amiga_scan_devices(void);
static      int   amiga_find_device(char *device);
static      int   amiga_open_timer(void);
static      void  amiga_close_timer(void);
static      int   amiga_get_scsi_bus(char *device);

/*
 * Return version information for the low level SCSI transport code.
 * This has been introduced to make it easier to trace down problems
 * in applications.
 */
static char *
usalo_version(SCSI *usalp, int what)
{
      if (usalp != (SCSI *)0) {
            switch (what) {

            case SCG_VERSION:
                  return (_usal_trans_version);
            /*
             * If you changed this source, you are not allowed to
             * return "schily" for the SCG_AUTHOR request.
             */
            case SCG_AUTHOR:
/*                return (_usal_auth_cdrkit);*/
                  return (_usal_auth);
            case SCG_SCCS_ID:
                  return (__sccsid);
            }
      }
      return ((char *)0);
}

static int
usalo_help(SCSI *usalp, FILE *f)
{
      __usal_help(f, "Amiga SCSI", "Generic SCSI",
            "", "bus,target,lun or xxx.device:b,t,l", "1,2,0 or scsi.device:1,2,0", TRUE, FALSE);
      return (0);
}

static int
usalo_open(SCSI *usalp, char *device)
{
            int   busno = usal_scsibus(usalp);
            int   tgt   = usal_target(usalp);
            int   tlun  = usal_lun(usalp);
      register int      f;
      register int      b;
      register int      t;
      register int      l;
      register int      nopen = 0;

      if (initialized == 0) {
            amiga_init();
            initialized = 1;
      }

      if (busno >= MAX_SCG || tgt >= MAX_TGT || tlun >= MAX_LUN) {
            errno = EINVAL;
            if (usalp->errstr) {
                  snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                        "Illegal value for busno, target or lun '%d,%d,%d'",
                        busno, tgt, tlun);
            }
            return (-1);
      }
      if (usalp->local == NULL) {
            usalp->local = malloc(sizeof (struct usal_local));
            if (usalp->local == NULL)
                  return (0);

            for (b = 0; b < MAX_SCG; b++) {
                  for (t = 0; t < MAX_TGT; t++) {
                        for (l = 0; l < MAX_LUN; l++) {
                              usallocal(usalp)->usalfiles[b][t][l] = -1;
                        }
                  }
            }
      }

      if (device == NULL || *device == '\0') {

            if (last_bus == -1) {
                  snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                        "No scsi device found");
                  return (-1);
            }
            if (busno < 0 && tgt < 0 && tlun < 0) {
                  /* cdrecord -scanbus */
                  for (b = 0; b <= last_bus; b++) {
                        for (t = 0; t < MAX_TGT; t++) {
                              for (l = 0; l < MAX_LUN; l++) {
                                    f = amiga_open_scsi(b, t, l, usalp);
                                    if (f != -1) {
                                          usallocal(usalp)->usalfiles[b][t][l] = f;
                                          nopen++;
                                    }
                              }
                        }
                  }
            } else {
                  /* cdrecord [-scanbus] dev=b,t,l */
                  f = amiga_open_scsi(busno, tgt, tlun, usalp);
                  if (f != -1) {
                        usallocal(usalp)->usalfiles[busno][tgt][tlun] = f;
                        nopen++;
                  }
            }
      } else {
            if (busno < 0 && tgt < 0 && tlun < 0) {
                  /* cdrecord -scanbus dev=xxx.device */
                  b = amiga_get_scsi_bus(device);
                  if (b != -1) {
                        for (t = 0; t < MAX_TGT; t++) {
                              for (l = 0; l < MAX_LUN; l++) {
                                    f = amiga_open_scsi(b, t, l, usalp);
                                    if (f != -1) {
                                          usallocal(usalp)->usalfiles[b][t][l] = f;
                                          nopen++;
                                    }
                              }
                        }
                  } else {
                        snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                              "Scsi device %s not found", device);
                  }
            } else {
                  /* cdrecord [-scanbus] dev=xxx.device:b,t,l */
                  /*
                   * this is a special case, in which the scsi device is accessed just by
                   * name, bus parameter from the command is ignored.
                   */
                  b = amiga_get_scsi_bus(device);
                  if (b != -1) {
                        f = amiga_open_scsi(b, tgt, tlun, usalp);
                        if (f != -1) {
                              usallocal(usalp)->usalfiles[busno][tgt][tlun] = f;
                              nopen++;
                        }
                  } else {
                        snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                              "Scsi device %s not found", device);
                  }
            }
      }

      return (nopen);
}

static int
usalo_close(SCSI *usalp)
{
      register int    b;
      register int    t;
      register int    l;

      if (usalp->local == NULL)
            return (-1);

      for (b = 0; b < MAX_SCG; b++) {
            for (t = 0; t < MAX_TGT; t++) {
                  for (l = 0; l < MAX_LUN; l++) {
                        if (usallocal(usalp)->usalfiles[b][t][l] >= 0)
                              amiga_close_scsi(usallocal(usalp)->usalfiles[b][t][l]);
                        usallocal(usalp)->usalfiles[b][t][l] = -1;
                  }
            }
      }
      return (0);
}

static long
usalo_maxdma(SCSI *usalp, long amt)
{
      return (MAX_DMA_AMIGAOS);
}

static void *
usalo_getbuf(SCSI *usalp, long amt)
{
      if (usalp->debug > 0) {
            fprintf((FILE *)usalp->errfile,
                  "usalo_getbuf: %ld bytes\n", amt);
      }
      usalp->bufbase = valloc((size_t)(amt));
      return (usalp->bufbase);
}

static void
usalo_freebuf(SCSI *usalp)
{
      if (usalp->bufbase)
            free(usalp->bufbase);
      usalp->bufbase = NULL;
}

static BOOL
usalo_havebus(SCSI *usalp, int busno)
{
      register int      t;
      register int      l;

      if (busno < 0 || busno >= MAX_SCG)
            return (FALSE);

      if (usalp->local == NULL)
            return (FALSE);

      for (t = 0; t < MAX_TGT; t++) {
            for (l = 0; l < MAX_LUN; l++)
                  if (usallocal(usalp)->usalfiles[busno][t][l] != -1)
                        return (TRUE);
      }
      return (FALSE);
}

static int
usalo_fileno(SCSI *usalp, int busno, int tgt, int tlun)
{
      if (busno < 0 || busno >= MAX_SCG ||
          tgt < 0 || tgt >= MAX_TGT ||
          tlun < 0 || tlun >= MAX_LUN)
            return (-1);

      if (usalp->local == NULL)
            return (-1);

      return ((int)usallocal(usalp)->usalfiles[busno][tgt][tlun]);
}

static int
usalo_initiator_id(SCSI *usalp)
{
      return (-1);
}

static int
usalo_isatapi(SCSI *usalp)
{
      return (FALSE);
}

static int
usalo_reset(SCSI *usalp, int what)
{
      /* XXX Is there really no reset function on AmigaOS? */
      errno = EINVAL;
      return (-1);
}

static int
usalo_send(SCSI *usalp)
{
      register struct IOStdReq *ioreq = NULL;
      struct SCSICmd    Cmd;
      int         ret = 0;
      struct usal_cmd   *sp = usalp->scmd;

      sp->error = SCG_NO_ERROR;
      sp->sense_count = 0;
      sp->u_scb.cmd_scb[0] = 0;
      sp->resid = 0;

      if (usalp->fd < 0) {
            sp->error = SCG_FATAL;
            return (0);
      }
      ioreq = request[usalp->fd].ioReq;
      if (ioreq == NULL) {
            sp->error = SCG_FATAL;
            return (0);
      }
      ioreq->io_Length = sizeof (struct SCSICmd);
      ioreq->io_Data = &Cmd;
      ioreq->io_Command = HD_SCSICMD;

      Cmd.scsi_Flags = SCSIF_AUTOSENSE;   /* We set the SCSI cmd len */
      if (sp->flags & SCG_RECV_DATA)
            Cmd.scsi_Flags |= SCSIF_READ;
      else if (sp->size > 0)
            Cmd.scsi_Flags |= SCSIF_WRITE;

      Cmd.scsi_Command = sp->cdb.cmd_cdb;
      Cmd.scsi_CmdLength = sp->cdb_len;
      Cmd.scsi_Data = (UWORD *) sp->addr;
      Cmd.scsi_Length = sp->size;
      Cmd.scsi_Actual = 0;

      Cmd.scsi_SenseData = sp->u_sense.cmd_sense;
      Cmd.scsi_SenseLength = sp->sense_len;
      Cmd.scsi_SenseActual = 0;
      Cmd.scsi_Status = 0;

      do_scsi_cmd(ioreq, sp->timeout);

      fillbytes(&sp->scb, sizeof (sp->scb), '\0');
      sp->resid = Cmd.scsi_Length - Cmd.scsi_Actual;

      if (sp->resid < 0)
            sp->resid = 0;
      sp->sense_count = Cmd.scsi_SenseActual;
      if (sp->sense_count < 0)
            sp->sense_count;

      if (sp->sense_count > SCG_MAX_SENSE)
            sp->sense_count = SCG_MAX_SENSE;
      sp->u_scb.cmd_scb[0] = Cmd.scsi_Status;

      if (ioreq->io_Error)
            sp->ux_errno = EIO;

      if (ami_debug)
            printf("ioreq->io_Error: %ld; status %ld\n", ioreq->io_Error, Cmd.scsi_Status);

      switch (ioreq->io_Error) {
            case 0:
                  sp->error = SCG_NO_ERROR;
                  break;
            case IOERR_TIMEOUT:
                  sp->error = SCG_TIMEOUT;
                  break;
            case HFERR_DMA:
            case IOERR_UNITBUSY:
            case HFERR_Phase:
            case HFERR_Parity:
            case HFERR_BadStatus:
                  if (Cmd.scsi_Status == CHECK_CONDITION) {
                        sp->error = SCG_NO_ERROR;
                  } else {
                        sp->error = SCG_RETRYABLE;
                  }
                  break;
            default:
                  /* XXX was kann sonst noch passieren? */
                  sp->error = SCG_FATAL;
                  break;
      }

      return (ret);
}

static int
do_scsi_cmd(struct IOStdReq *scsi_io, int timeout)
{
      ULONG scsi_flag = 0;
      ULONG timer_flag = 0;
      ULONG wait_sigs = 0;
      ULONG wait_ret = 0;
      int         ret = 0;

      scsi_flag = 1L<<scsi_io->io_Message.mn_ReplyPort->mp_SigBit;
      wait_sigs = scsi_flag;

      SetSignal(0L, scsi_flag);
      SendIO((struct IORequest *)scsi_io);
      if (timer_io) {
            timer_flag = 1L<<timerMsgPort->mp_SigBit;
            wait_sigs |= timer_flag;
            timer_io->tr_time.tv_secs = timeout;
            SetSignal(0L, timer_flag);
            SendIO((struct IORequest *)timer_io);
      }

      wait_ret = Wait(wait_sigs);

      if (wait_ret & scsi_flag) {
            WaitIO((struct IORequest *)scsi_io);
            if (timer_io) {
                  if (!CheckIO((struct IORequest *) timer_io)) {
                        AbortIO((struct IORequest *)timer_io);
                        WaitIO((struct IORequest *)timer_io);
                  }
            }
      } else if (wait_ret & timer_flag) {
            WaitIO((struct IORequest *)timer_io);
            if (!CheckIO((struct IORequest *) scsi_io)) {
                  AbortIO((struct IORequest *)scsi_io);
                  if (scsi_io->io_Error == IOERR_ABORTED) {
                        WaitIO((struct IORequest *)scsi_io);
                  }
            }
            scsi_io->io_Error = IOERR_TIMEOUT;
      }

      return (scsi_io->io_Error);
}

/*--------------------------------------------------------------------------*/

/* strlwr: seems not to be implemented in ixemul */
static char *
strlwr(char *s)
{
      unsigned char *s1;

      s1 = (unsigned char *)s;
      while (*s1) {
            if ((*s1 > ('A'-1)) && (*s1 < ('Z'+1)))
                  *s1 += 'a'-'A';
            s1++;
      }
      return (s);
}

/*
 * amiga specific functions
 */
static void
amiga_init()
{
      memset(request, 0, sizeof (request));
      amiga_scan_devices();
      if (ami_debug)
            printf("scanning bus. %ld device(s) found\n", last_bus + 1);

      atexit(amiga_close_scsi_all);
}

static void
amiga_scan_devices()
{
      /*
       * searching all known scsi devices
       * for first there is only a (full) support for scsi.device and amithlon.device.
       * This are devices i tested.
       * All the other devices have to be specified by name (i.e. cdrecord dev=blabla.device:0,0,0)
       * but didn't appear in the scanbus list. Later they should/may be also added to the
       * main_dev_list (after testing).
       */
      const char  *main_dev_list[] = { "scsi.device", "amithlon.device", NULL };

      int   i;
      char  **main_dev;

      main_dev = (char **)main_dev_list;
      while (*main_dev) {
            if (last_bus == MAX_SCG - 1)
                  break;
            if (amiga_find_device(*main_dev)) {
                  last_bus++;
                  devs[last_bus] = strdup(*main_dev);
                  for (i = 2; i < MAX_SCG; i++) {
                        char tmp[256];
                        if (last_bus == MAX_SCG - 1)
                              break;
                        if (i == 2) {
                              sprintf(tmp, "2nd.%s", *main_dev);
                        } else if (i == 3) {
                              sprintf(tmp, "3rd.%s", *main_dev);
                        } else {
                              sprintf(tmp, "%ldth.%s", i, *main_dev);
                        }
                        if (amiga_find_device(tmp)) {
                              last_bus++;
                              devs[last_bus] = strdup(tmp);
                        } else {
                              break;
                        }
                  }
            }
            main_dev++;
      }
}

static void
amiga_close_scsi(int fd)
{
      if (request[fd].ref_count > 0) {
            request[fd].ref_count--;
            if (request[fd].ref_count == 0) {
                  CloseDevice((struct IORequest *) request[fd].ioReq);
                  DeleteStdIO(request[fd].ioReq);
                  request[fd].ioReq = NULL;
                  if (ami_debug) {
                        printf("closing device fd %ld\n", fd);
                  }
            }
      }
}

static void
amiga_close_scsi_all()
{
      int   i;

      for (i = 0; i < MAX_DEV; i++) {
            if (request[i].ioReq != NULL) {
                  if (ami_debug) {
                        printf("closing device fd %ld\n", i);
                  }
                  CloseDevice((struct IORequest *) request[i].ioReq);
                  DeleteStdIO(request[i].ioReq);
                  request[i].ioReq = NULL;
            }
      }

      if (ioMsgPort) {
            DeletePort(ioMsgPort);
            ioMsgPort = NULL;
      }
      amiga_close_timer();

      for (i = 0; i < MAX_SCG; i++) {
            free(devs[i]);
      }
}

static int
amiga_open_scsi(int bus, int tgt, int lun, SCSI *usalp)
{
      int   fd = bus * MAX_TGT * MAX_LUN + tgt * MAX_LUN + lun;
      int   unit = DUNIT(bus, tgt, lun);
      char  *dev = devs[bus];

      if (dev == NULL) {
            if (usalp->errstr) {
                  snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                        "No scsi device found at bus %ld\n", bus);
            }
            return (-1);
      }

      if (ioMsgPort == NULL) {
            ioMsgPort = CreatePort(NULL, 0);
      }

      if (ioMsgPort != NULL) {
            if (request[fd].ioReq == NULL) {
                  request[fd].ioReq = CreateStdIO(ioMsgPort);
            }

            if (request[fd].ioReq != NULL) {
                  if (ami_debug)
                        printf("trying %s, unit %ld\n", dev, unit);
                  if (OpenDevice(dev, unit, (struct IORequest *)request[fd].ioReq, 0L)) {
                        if (usalp->errstr) {
                              snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                                    "Cannot open %s\n",     dev);
                        }
                        if (request[fd].ref_count == 0) {
                              DeleteStdIO(request[fd].ioReq);
                              request[fd].ioReq = NULL;
                        }
                        fd = -1;
                  } else {
                        request[fd].ref_count++;
                        if (ami_debug)
                              printf("opening %s, unit %ld as fd %ld count %ld\n", dev, unit, fd, request[fd].ref_count);
                  }
            } else {
                  if (usalp->errstr) {
                        snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                              "Cannot create IOReq");
                  }
            }
      } else {
            if (usalp->errstr) {
                  snprintf(usalp->errstr, SCSI_ERRSTR_SIZE,
                        "Cannot open Message Port");
            }
      }

      return (fd);
}

static int
amiga_open_timer()
{
      int   ret = 0;

      /* we need the timer to catch scsi timeouts */
      if (timer_io == NULL) {
            if (ami_debug)
                  printf("opening timer\n");

            timerMsgPort = CreatePort(NULL, 0);
            if (timerMsgPort) {
                  timer_io = (struct timerequest *)CreateExtIO(timerMsgPort, sizeof (struct timerequest));
                  if (timer_io) {
                        if (OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *)timer_io, 0)) {
                              printf("Warning: can't open timer device\n");
                              DeleteExtIO((struct IORequest *) timer_io);
                              DeletePort(timerMsgPort);
                              timer_io = NULL;
                              timerMsgPort = NULL;
                              ret = 1;
                        } else {
                              timer_io->tr_node.io_Command = TR_ADDREQUEST;
                              timer_io->tr_time.tv_micro = 0;
                        }
                  } else {
                        printf("Warning: can't create timer request\n");
                        DeletePort(timerMsgPort);
                        timerMsgPort = NULL;
                        ret = 1;
                  }
            } else {
                  printf("Warning: can't create timer port\n");
                  ret = 1;
            }
      }
      return (ret);
}

static void
amiga_close_timer()
{
      if (timer_io) {
            if (ami_debug)
                  printf("closing timer\n");

            AbortIO((struct IORequest *) timer_io);
            WaitIO((struct IORequest *) timer_io);
            CloseDevice((struct IORequest *)timer_io);
            DeleteExtIO((struct IORequest *) timer_io);
            DeletePort(timerMsgPort);
            timer_io = NULL;
            timerMsgPort = NULL;
      }
}

static int
amiga_get_scsi_bus(char *device)
{
      int   i;
      char  *tmp = strdup(device);

      strlwr(tmp);
      for (i = 0; i <= last_bus; i++) {
            if (strcmp(devs[i], tmp) == 0) {
                  return (i);
            }
      }

      if (amiga_find_device(tmp)) {
            devs[i] = tmp;
            last_bus = i;
            return (i);
      }

      return (-1);
}

static int
amiga_find_device(char *device)
{
      char        tmp[256];
      struct Node *DeviceLibNode = SysBase->DeviceList.lh_Head;

      if (ami_debug)
            printf("looking for %s ", device);

      Forbid();
      while (DeviceLibNode->ln_Succ) {
            DeviceLibNode = DeviceLibNode->ln_Succ;
            strcpy(tmp, DeviceLibNode->ln_Name);
            strlwr(tmp);
            if (strcmp(tmp, device) == 0) {
                  if (ami_debug)
                        printf(" ... found\n");
                  return (1);
            }
      }
      Permit();

      if (ami_debug)
            printf(" ... not found\n");

      return (0);
}

Generated by  Doxygen 1.6.0   Back to index