summaryrefslogtreecommitdiff
path: root/libusal/scsi-amigaos.c
diff options
context:
space:
mode:
Diffstat (limited to 'libusal/scsi-amigaos.c')
-rw-r--r--libusal/scsi-amigaos.c771
1 files changed, 771 insertions, 0 deletions
diff --git a/libusal/scsi-amigaos.c b/libusal/scsi-amigaos.c
new file mode 100644
index 0000000..991a4ab
--- /dev/null
+++ b/libusal/scsi-amigaos.c
@@ -0,0 +1,771 @@
+/*
+ * 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 cgit v1.2.3 (git 2.39.1) at 2024-12-03 18:13:15 +0000