87f6c6625d
most devsw referenced functions are now static, as they are in the same file as their devsw structure. I've also added DEVFS support for nearly every device in the system, however many of the devices have 'incorrect' names under DEVFS because I couldn't quickly work out the correct naming conventions. (but devfs won't be coming on line for a month or so anyhow so that doesn't matter) If you "OWN" a device which would normally have an entry in /dev then search for the devfs_add_devsw() entries and munge to make them right.. check out similar devices to see what I might have done in them in you can't see what's going on.. for a laugh compare conf.c conf.h defore and after... :) I have not doen DEVFS entries for any DISKSLICE devices yet as that will be a much more complicated job.. (pass 5 :) pass 4 will be to make the devsw tables of type (cdevsw * ) rather than (cdevsw) seems to work here.. complaints to the usual places.. :)
395 lines
10 KiB
C
395 lines
10 KiB
C
/*
|
|
* worm: Write Once device driver
|
|
*
|
|
* Copyright (C) 1995, HD Associates, Inc.
|
|
* PO Box 276
|
|
* Pepperell, MA 01463
|
|
* 508 433 5266
|
|
* dufault@hda.com
|
|
*
|
|
* This code is contributed to the University of California at Berkeley:
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $Id: worm.c,v 1.13 1995/12/05 07:14:27 julian Exp $
|
|
*/
|
|
|
|
/* XXX This is PRELIMINARY.
|
|
*
|
|
* We need the "kern devconf" stuff, but I'm not
|
|
* going to add it until it is done in a simple way that provides
|
|
* base behavior in scsi_driver.c
|
|
*
|
|
* Until Bruce finishes the slice stuff there will be no partitions.
|
|
* When it is finished I hope to hoist the partition code up into
|
|
* "scsi_driver" and use common code for all devices.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/kernel.h>
|
|
#ifdef DEVFS
|
|
#include <sys/devfsext.h>
|
|
#endif /*DEVFS*/
|
|
#include <scsi/scsi_all.h>
|
|
#include <scsi/scsiconf.h>
|
|
#include <scsi/scsi_disk.h>
|
|
|
|
|
|
struct scsi_data {
|
|
struct buf_queue_head buf_queue;
|
|
u_int32 n_blks; /* Number of blocks (0 for bogus) */
|
|
u_int32 blk_size; /* Size of each blocks */
|
|
#ifdef DEVFS
|
|
void *devfs_token; /* more elaborate later */
|
|
#endif
|
|
};
|
|
|
|
static void wormstart(u_int32 unit, u_int32 flags);
|
|
|
|
static errval worm_open(dev_t dev, int flags, int fmt, struct proc *p,
|
|
struct scsi_link *sc_link);
|
|
static errval worm_ioctl(dev_t dev, int cmd, caddr_t addr, int flag,
|
|
struct proc *p, struct scsi_link *sc_link);
|
|
static errval worm_close(dev_t dev, int flag, int fmt, struct proc *p,
|
|
struct scsi_link *sc_link);
|
|
static void worm_strategy(struct buf *bp, struct scsi_link *sc_link);
|
|
|
|
static d_open_t wormopen;
|
|
static d_close_t wormclose;
|
|
static d_ioctl_t wormioctl;
|
|
d_strategy_t wormstrategy;
|
|
|
|
#define CDEV_MAJOR 62
|
|
struct cdevsw worm_cdevsw =
|
|
{ wormopen, wormclose, rawread, rawwrite, /*62*/
|
|
wormioctl, nostop, nullreset, nodevtotty,/* worm */
|
|
seltrue, nommap, wormstrategy };
|
|
|
|
|
|
SCSI_DEVICE_ENTRIES(worm)
|
|
|
|
static struct scsi_device worm_switch =
|
|
{
|
|
NULL,
|
|
wormstart, /* we have a queue, and this is how we service it */
|
|
NULL,
|
|
NULL,
|
|
"worm",
|
|
0,
|
|
{0, 0},
|
|
SDEV_ONCE_ONLY, /* Only one open allowed */
|
|
wormattach,
|
|
"Write-Once",
|
|
wormopen,
|
|
sizeof(struct scsi_data),
|
|
T_WORM,
|
|
0,
|
|
0,
|
|
worm_open,
|
|
0,
|
|
worm_close,
|
|
worm_strategy,
|
|
};
|
|
|
|
static int worm_size(struct scsi_link *sc_link, int flags)
|
|
{
|
|
int ret;
|
|
struct scsi_data *worm = sc_link->sd;
|
|
|
|
worm->n_blks = scsi_read_capacity(sc_link, &worm->blk_size,
|
|
flags);
|
|
|
|
if(worm->blk_size == 0)
|
|
/* XXX */
|
|
worm->blk_size = 2048;
|
|
if (worm->n_blks)
|
|
{
|
|
sc_link->flags |= SDEV_MEDIA_LOADED;
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
sc_link->flags &= ~SDEV_MEDIA_LOADED;
|
|
ret = 0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static errval
|
|
wormattach(struct scsi_link *sc_link)
|
|
{
|
|
struct scsi_data *worm = sc_link->sd;
|
|
|
|
TAILQ_INIT(&worm->buf_queue);
|
|
|
|
printf("- UNTESTED ");
|
|
|
|
if (worm_size(sc_link, SCSI_NOSLEEP | SCSI_NOMASK) == 0)
|
|
printf("- can't get capacity.");
|
|
else
|
|
printf("with %ld %ld byte blocks.",
|
|
worm->n_blks, worm->blk_size);
|
|
#ifdef DEVFS
|
|
|
|
worm->devfs_token = devfs_add_devsw( "/", "rworm", &worm_cdevsw, 0,
|
|
DV_CHR, 0, 0, 0600);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* wormstart looks to see if there is a buf waiting for the device
|
|
* and that the device is not already busy. If both are true,
|
|
* It dequeues the buf and creates a scsi command to perform the
|
|
* transfer required. The transfer request will call scsi_done
|
|
* on completion, which will in turn call this routine again
|
|
* so that the next queued transfer is performed.
|
|
* The bufs are queued by the strategy routine (wormstrategy)
|
|
*
|
|
* This routine is also called after other non-queued requests
|
|
* have been made of the scsi driver, to ensure that the queue
|
|
* continues to be drained.
|
|
* wormstart() is called at splbio
|
|
*
|
|
* XXX It looks like we need a "scsistart" to hoist common code up
|
|
* into. In particular, the removable media checking should be
|
|
* handled in one place.
|
|
*/
|
|
static void
|
|
wormstart(unit, flags)
|
|
u_int32 unit;
|
|
u_int32 flags;
|
|
{
|
|
struct scsi_link *sc_link = SCSI_LINK(&worm_switch, unit);
|
|
struct scsi_data *worm = sc_link->sd;
|
|
register struct buf *bp = 0;
|
|
struct scsi_rw_big cmd;
|
|
|
|
u_int32 lba; /* Logical block address */
|
|
u_int32 tl; /* Transfer length */
|
|
|
|
SC_DEBUG(sc_link, SDEV_DB2, ("wormstart "));
|
|
|
|
/*
|
|
* We should reject all queued entries if SDEV_MEDIA_LOADED is not true.
|
|
*/
|
|
if (!(sc_link->flags & SDEV_MEDIA_LOADED)) {
|
|
goto badnews; /* no I/O.. media changed or something */
|
|
}
|
|
|
|
/*
|
|
* See if there is a buf to do and we are not already
|
|
* doing one
|
|
*/
|
|
while (sc_link->opennings != 0) {
|
|
|
|
/* if a special awaits, let it proceed first */
|
|
if (sc_link->flags & SDEV_WAITING) {
|
|
sc_link->flags &= ~SDEV_WAITING;
|
|
wakeup(sc_link);
|
|
return;
|
|
}
|
|
|
|
bp = worm->buf_queue.tqh_first;
|
|
if (bp == NULL) { /* yes, an assign */
|
|
return;
|
|
}
|
|
TAILQ_REMOVE( &worm->buf_queue, bp, b_act);
|
|
|
|
/*
|
|
* Fill out the scsi command
|
|
*/
|
|
bzero(&cmd, sizeof(cmd));
|
|
if ((bp->b_flags & B_READ) == B_WRITE) {
|
|
cmd.op_code = WRITE_BIG;
|
|
flags |= SCSI_DATA_OUT;
|
|
} else {
|
|
cmd.op_code = READ_BIG;
|
|
flags |= SCSI_DATA_IN;
|
|
}
|
|
|
|
|
|
lba = bp->b_blkno / (worm->blk_size / DEV_BSIZE);
|
|
tl = bp->b_bcount / worm->blk_size;
|
|
|
|
scsi_uto4b(lba, &cmd.addr_3);
|
|
scsi_uto2b(tl, &cmd.length2);
|
|
|
|
/*
|
|
* go ask the adapter to do all this for us
|
|
*/
|
|
if (scsi_scsi_cmd(sc_link,
|
|
(struct scsi_generic *) &cmd,
|
|
sizeof(cmd),
|
|
(u_char *) bp->b_un.b_addr,
|
|
bp->b_bcount,
|
|
0, /* can't retry a read on a tape really */
|
|
100000,
|
|
bp,
|
|
flags | SCSI_NOSLEEP) == SUCCESSFULLY_QUEUED) {
|
|
} else {
|
|
printf("worm%ld: oops not queued\n", unit);
|
|
if (bp) {
|
|
bp->b_flags |= B_ERROR;
|
|
bp->b_error = EIO;
|
|
biodone(bp);
|
|
}
|
|
}
|
|
} /* go back and see if we can cram more work in.. */
|
|
badnews:
|
|
}
|
|
|
|
static void
|
|
worm_strategy(struct buf *bp, struct scsi_link *sc_link)
|
|
{
|
|
struct buf **dp;
|
|
unsigned char unit;
|
|
u_int32 opri;
|
|
struct scsi_data *worm;
|
|
|
|
unit = minor((bp->b_dev));
|
|
worm = sc_link->sd;
|
|
|
|
/* XXX: Can't we move this check up to "scsi_strategy"?
|
|
*/
|
|
if (!(sc_link->flags & SDEV_MEDIA_LOADED) ||
|
|
bp->b_blkno > worm->n_blks ||
|
|
bp->b_bcount & (worm->blk_size - 1)) {
|
|
bp->b_error = EIO;
|
|
bp->b_flags |= B_ERROR;
|
|
biodone(bp);
|
|
return;
|
|
}
|
|
|
|
opri = splbio();
|
|
|
|
/*
|
|
* Use a bounce buffer if necessary
|
|
* XXX: How can we move this up?
|
|
*/
|
|
#ifdef BOUNCE_BUFFERS
|
|
if (sc_link->flags & SDEV_BOUNCE)
|
|
vm_bounce_alloc(bp);
|
|
#endif
|
|
|
|
/*
|
|
* Place it in the queue of activities for this device
|
|
* at the end.
|
|
*/
|
|
TAILQ_INSERT_TAIL(&worm->buf_queue, bp, b_act);
|
|
|
|
wormstart(unit, 0);
|
|
|
|
splx(opri);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Open the device. XXX: I'm completely guessing at this sequence.
|
|
*/
|
|
static int
|
|
worm_open(dev_t dev, int flags, int fmt, struct proc *p,
|
|
struct scsi_link *sc_link)
|
|
{
|
|
if (sc_link->flags & SDEV_OPEN)
|
|
return EBUSY;
|
|
|
|
/*
|
|
* Check that it is still responding and ok.
|
|
* if the media has been changed this will result in a
|
|
* "unit attention" error which the error code will
|
|
* disregard because the SDEV_OPEN flag is not yet set
|
|
*
|
|
* XXX This should REALLY be hoisted up. As soon as Bruce
|
|
* finishes that slice stuff. (Add a different flag,
|
|
* and then do a "scsi_test_unit_ready" with the "ignore
|
|
* unit attention" thing set. Then all this replicated
|
|
* test unit ready code can be pulled up.
|
|
*/
|
|
scsi_test_unit_ready(sc_link, SCSI_SILENT);
|
|
|
|
/*
|
|
* Next time actually take notice of error returns
|
|
*/
|
|
sc_link->flags |= SDEV_OPEN; /* unit attn errors are now errors */
|
|
|
|
if (scsi_test_unit_ready(sc_link, SCSI_SILENT) != 0) {
|
|
SC_DEBUG(sc_link, SDEV_DB3, ("not ready\n"));
|
|
sc_link->flags &= ~SDEV_OPEN;
|
|
return ENXIO;
|
|
}
|
|
|
|
scsi_start_unit(sc_link, SCSI_SILENT);
|
|
|
|
scsi_prevent(sc_link, PR_PREVENT, SCSI_SILENT);
|
|
|
|
if (worm_size(sc_link, 0) == 0) {
|
|
scsi_stop_unit(sc_link, 0, SCSI_SILENT);
|
|
scsi_prevent(sc_link, PR_ALLOW, SCSI_SILENT);
|
|
sc_link->flags &= ~SDEV_OPEN;
|
|
return ENXIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
worm_close(dev_t dev, int flag, int fmt, struct proc *p,
|
|
struct scsi_link *sc_link)
|
|
{
|
|
scsi_stop_unit(sc_link, 0, SCSI_SILENT);
|
|
scsi_prevent(sc_link, PR_ALLOW, SCSI_SILENT);
|
|
sc_link->flags &= ~SDEV_OPEN;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static worm_devsw_installed = 0;
|
|
|
|
static void
|
|
worm_drvinit(void *unused)
|
|
{
|
|
dev_t dev;
|
|
|
|
if( ! worm_devsw_installed ) {
|
|
dev = makedev(CDEV_MAJOR,0);
|
|
cdevsw_add(&dev,&worm_cdevsw,NULL);
|
|
worm_devsw_installed = 1;
|
|
}
|
|
}
|
|
|
|
SYSINIT(wormdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,worm_drvinit,NULL)
|
|
|
|
|