sys/arch/mipsco/stand/common/saio.c

   1 /*      $NetBSD: saio.c,v 1.11 2009/03/14 15:36:10 dsl Exp $    */
   2
   3 /*
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Van Jacobson of Lawrence Berkeley Laboratory and Ralph Campbell.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)rz.c        8.1 (Berkeley) 6/10/93
  35  */
  36
  37 #include <lib/libsa/stand.h>
  38 #include <lib/libkern/libkern.h>
  39 #include <machine/prom.h>
  40 #include <machine/stdarg.h>
  41
  42 #include <sys/param.h>
  43 #include <sys/disklabel.h>
  44
  45 #include "common.h"
  46 #include "saio.h"
  47
  48 struct  saio_softc {
  49         int     sc_fd;                  /* PROM file id */
  50         int     sc_ctlr;                /* controller number */
  51         int     sc_unit;                /* disk unit number */
  52         int     sc_part;                /* disk partition number */
  53         struct  disklabel sc_label;     /* disk label for this disk */
  54 };
  55
  56 struct io_arg {
  57         int retval;
  58         unsigned long sectst;
  59         unsigned long memaddr;
  60         unsigned long datasz;
  61 };
  62
  63 #define IOB_BUFSZ       512
  64 #define IOB_INODESZ     316
  65
  66 struct device_table {
  67         char *dt_string;        /* device name */
  68         int (*dt_init) (int);   /* device init routine */
  69         int (*dt_open)(int);    /* device open routine */
  70         int (*dt_strategy)(int);        /* device strategy routine, returns cnt */
  71         int (*dt_close)(int);   /* device close routine */
  72         int (*dt_ioctl)(int);   /* device ioctl routine */
  73         int dt_type;            /* device "type" */
  74         int dt_fs;              /* file system type */
  75         char *dt_desc;          /* device description */
  76 };
  77
  78 struct sa_iob {
  79         char    i_buf[IOB_BUFSZ];       /* file system or tape header */
  80         char    i_ino_dir[IOB_INODESZ]; /* inode or disk/tape directory */
  81
  82         int     i_flgs;         /* see F_ below */
  83         int     i_ctlr;         /* controller board */
  84         int     i_unit;         /* pseudo device unit */
  85         int     i_part;         /* disk partition */
  86         char    *i_ma;          /* memory address of i/o buffer */
  87         int     i_cc;           /* character count of transfer */
  88         int32_t i_offset;       /* seek offset in file */
  89         /* XXX ondisk32 */
  90         int32_t i_bn;           /* 1st block # of next read */
  91         int     i_fstype;       /* file system type */
  92         int     i_errno;        /* error # return */
  93         unsigned int    i_devaddr;      /* csr address */
  94         struct device_table *i_dp;      /* pointer into device_table */
  95         char    *i_bufp;                        /* i/o buffer for blk devs */
  96 }__attribute__((__packed__));
  97
  98 extern struct sa_iob *saiob[];
  99
 100 int
 101 saiostrategy(void *devdata, int rw, daddr_t bn, size_t reqcnt, void *addr, size_t *cnt)
 102         /* cnt:  out: number of bytes transfered */
 103 {
 104         struct saio_softc *sc = (struct saio_softc *)devdata;
 105         int part = sc->sc_part;
 106         struct partition *pp = &sc->sc_label.d_partitions[part];
 107         int s;
 108         long offset;
 109         struct sa_iob *iob;
 110         char *adr;
 111
 112         offset = bn * DEV_BSIZE;
 113         *cnt = 0;
 114
 115         /*
 116          * Partial-block transfers not handled.
 117          */
 118         if (reqcnt & (DEV_BSIZE - 1)) {
 119                 return (EINVAL);
 120         }
 121         offset += pp->p_offset * DEV_BSIZE;
 122
 123         iob = saiob[sc->sc_fd];
 124         iob->i_offset = offset;
 125
 126 #if notyet
 127         if (prom_lseek(sc->sc_fd, offset, 0) < 0)
 128                 return (EIO);
 129 #endif
 130
 131         adr = (char *)addr;
 132         while (*cnt < reqcnt) {
 133                 s = prom_read(sc->sc_fd, iob->i_buf, 512);
 134                 if (s < 0) {
 135                         return (EIO);
 136                 }
 137                 memcpy(adr, iob->i_buf, s);
 138                 *cnt += s;
 139                 adr += s;
 140         }
 141         return (0);
 142 }
 143
 144 int
 145 saioopen(struct open_file *f, ...)
 146 {
 147         int ctlr, unit, part;
 148
 149         struct saio_softc *sc;
 150         struct disklabel *lp;
 151         int i;
 152         char *msg;
 153         char buf[DEV_BSIZE];
 154         int cnt;
 155         static char device[] = "dksd(0,0,10)";
 156
 157         va_list ap;
 158
 159         va_start(ap, f);
 160
 161         ctlr = va_arg(ap, int);
 162         unit = va_arg(ap, int);
 163         part = va_arg(ap, int);
 164
 165         va_end(ap);
 166
 167         device[5] = '0' + ctlr;
 168         device[7] = '0' + unit;
 169
 170         i = prom_open(device, 0);
 171         if (i < 0) {
 172                 printf("open failed\n");
 173                 return (ENXIO);
 174         }
 175
 176         sc = alloc(sizeof(struct saio_softc));
 177         memset(sc, 0, sizeof(struct saio_softc));
 178         f->f_devdata = (void *)sc;
 179
 180         sc->sc_fd = i;
 181         sc->sc_ctlr = ctlr;
 182         sc->sc_unit = unit;
 183         sc->sc_part = part;
 184
 185         /* try to read disk label and partition table information */
 186         lp = &sc->sc_label;
 187         lp->d_secsize = DEV_BSIZE;
 188         lp->d_secpercyl = 1;
 189         lp->d_npartitions = MAXPARTITIONS;
 190         lp->d_partitions[part].p_offset = 0;
 191         lp->d_partitions[part].p_size = 0x7fffffff;
 192
 193         i = saiostrategy(sc, F_READ, (daddr_t)LABELSECTOR, DEV_BSIZE, buf, &cnt);
 194         if (i || cnt != DEV_BSIZE) {
 195                 printf("%s: error reading disk label\n", device);
 196                 goto bad;
 197         }
 198
 199         msg = getdisklabel(buf, lp);
 200         if (msg) {
 201 #ifdef LIBSA_NO_DISKLABEL_MSGS
 202                 printf("%s: no disklabel\n", device);
 203 #else
 204                 printf("getlabel: %s\n", msg);
 205 #endif
 206                 return (0);
 207         }
 208         if (part >= lp->d_npartitions || lp->d_partitions[part].p_size == 0) {
 209         bad:
 210                 dealloc(sc, sizeof(struct saio_softc));
 211                 return (ENXIO);
 212         }
 213         return (0);
 214 }
 215
 216 #ifndef LIBSA_NO_DEV_CLOSE
 217 int
 218 saioclose(struct open_file *f)
 219 {
 220
 221         prom_close(((struct saio_softc *)f->f_devdata)->sc_fd);
 222         dealloc(f->f_devdata, sizeof(struct saio_softc));
 223         f->f_devdata = (void *)0;
 224         return (0);
 225 }
 226 #endif