/*      $NetBSD: mmemcard.c,v 1.26 2015/04/26 15:15:19 mlelstv Exp $    */

/*-
 * Copyright (c) 2002 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by ITOH Yasufumi.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: mmemcard.c,v 1.26 2015/04/26 15:15:19 mlelstv Exp $");

#include <sys/param.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/device.h>
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/stat.h>
#include <sys/systm.h>
#include <sys/vnode.h>
#include <sys/conf.h>

#include <dreamcast/dev/maple/maple.h>
#include <dreamcast/dev/maple/mapleconf.h>

#include "ioconf.h"

#define MMEM_MAXACCSIZE 1012    /* (255*4) - 8  =  253*32 / 8 */

struct mmem_funcdef {   /* XXX assuming little-endian structure packing */
        unsigned unused : 8,
                 ra     : 4,    /* number of access / read */
                 wa     : 4,    /* number of access / write */
                 bb     : 8,    /* block size / 32 - 1 */
                 pt     : 8;    /* number of partition - 1 */
};

struct mmem_request_read_data {
        uint32_t        func_code;
        uint8_t         pt;
        uint8_t         phase;
        uint16_t        block;
};

struct mmem_response_read_data {
        uint32_t        func_code;      /* function code (big endian) */
        uint32_t        blkno;          /* 512byte block number (big endian) */
        uint8_t         data[MMEM_MAXACCSIZE];
};

struct mmem_request_write_data {
        uint32_t        func_code;
        uint8_t         pt;
        uint8_t         phase;          /* 0, 1, 2, 3: for each 128 byte */
        uint16_t        block;
        uint8_t         data[MMEM_MAXACCSIZE];
};
#define MMEM_SIZE_REQW(sc)      ((sc)->sc_waccsz + 8)

struct mmem_request_get_media_info {
        uint32_t        func_code;
        uint32_t        pt;             /* pt (1 byte) and unused 3 bytes */
};

struct mmem_media_info {
        uint16_t        maxblk, minblk;
        uint16_t        infpos;
        uint16_t        fatpos, fatsz;
        uint16_t        dirpos, dirsz;
        uint16_t        icon;
        uint16_t        datasz;
        uint16_t        rsvd[3];
};

struct mmem_response_media_info {
        uint32_t        func_code;      /* function code (big endian) */
        struct mmem_media_info info;
};

struct mmem_softc {
        device_t sc_dev;

        device_t sc_parent;
        struct maple_unit *sc_unit;
        struct maple_devinfo *sc_devinfo;

        enum mmem_stat {
                MMEM_INIT,      /* during initialization */
                MMEM_INIT2,     /* during initialization */
                MMEM_IDLE,      /* init done, not in I/O */
                MMEM_READ,      /* in read operation */
                MMEM_WRITE1,    /* in write operation (read and compare) */
                MMEM_WRITE2,    /* in write operation (write) */
                MMEM_DETACH     /* detaching */
        } sc_stat;

        int             sc_npt;         /* number of partitions */
        int             sc_bsize;       /* block size */
        int             sc_wacc;        /* number of write access per block */
        int             sc_waccsz;      /* size of a write access */
        int             sc_racc;        /* number of read access per block */
        int             sc_raccsz;      /* size of a read access */

        struct mmem_pt {
                int             pt_flags;
#define MMEM_PT_OK      1       /* partition is alive */
                struct disk     pt_dk;          /* disk(9) */
                struct mmem_media_info pt_info; /* geometry per part */

                char            pt_name[16 /* see device.h */ + 4 /* ".255" */];
        } *sc_pt;

        /* write request buffer (only one is used at a time) */
        union {
                struct mmem_request_read_data req_read;
                struct mmem_request_write_data req_write;
                struct mmem_request_get_media_info req_minfo;
        } sc_req;
#define sc_reqr sc_req.req_read
#define sc_reqw sc_req.req_write
#define sc_reqm sc_req.req_minfo

        /* pending buffers */
        struct bufq_state *sc_q;

        /* current I/O access */
        struct buf      *sc_bp;
        int             sc_cnt;
        char            *sc_iobuf;
        int             sc_retry;
#define MMEM_MAXRETRY   12
};

/*
 * minor number layout (mmemdetach() depends on this layout):
 *
 * 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
 * |---------------------| |---------------------| |---------|
 *          unit                    part           disklabel partition
 */
#define MMEM_PART(diskunit)     ((diskunit) & 0xff)
#define MMEM_UNIT(diskunit)     ((diskunit) >> 8)
#define MMEM_DISKMINOR(unit, part, disklabel_partition) \
        DISKMINOR(((unit) << 8) | (part), (disklabel_partition))

static int      mmemmatch(device_t, cfdata_t, void *);
static void     mmemattach(device_t, device_t, void *);
static void     mmem_defaultlabel(struct mmem_softc *, struct mmem_pt *,
                    struct disklabel *);
static int      mmemdetach(device_t, int);
static void     mmem_intr(void *, struct maple_response *, int, int);
static void     mmem_printerror(const char *, int, int, uint32_t);
static void     mmemstart(struct mmem_softc *);
static void     mmemstart_bp(struct mmem_softc *);
static void     mmemstart_write2(struct mmem_softc *);
static void     mmemdone(struct mmem_softc *, struct mmem_pt *, int);

dev_type_open(mmemopen);
dev_type_close(mmemclose);
dev_type_read(mmemread);
dev_type_write(mmemwrite);
dev_type_ioctl(mmemioctl);
dev_type_strategy(mmemstrategy);

const struct bdevsw mmem_bdevsw = {
        .d_open = mmemopen,
        .d_close = mmemclose,
        .d_strategy = mmemstrategy,
        .d_ioctl = mmemioctl,
        .d_dump = nodump,
        .d_psize = nosize,
        .d_discard = nodiscard,
        .d_flag = D_DISK
};

const struct cdevsw mmem_cdevsw = {
        .d_open = mmemopen,
        .d_close = mmemclose,
        .d_read = mmemread,
        .d_write = mmemwrite,
        .d_ioctl = mmemioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = nopoll,
        .d_mmap = nommap,
        .d_kqfilter = nokqfilter,
        .d_discard = nodiscard,
        .d_flag = D_DISK
};

CFATTACH_DECL_NEW(mmem, sizeof(struct mmem_softc),
    mmemmatch, mmemattach, mmemdetach, NULL);

struct dkdriver mmemdkdriver = {
        .d_strategy = mmemstrategy
};

static int
mmemmatch(device_t parent, cfdata_t cf, void *aux)
{
        struct maple_attach_args *ma = aux;

        return ma->ma_function == MAPLE_FN_MEMCARD ? MAPLE_MATCH_FUNC : 0;
}

static void
mmemattach(device_t parent, device_t self, void *aux)
{
        struct mmem_softc *sc = device_private(self);
        struct maple_attach_args *ma = aux;
        int i;
        union {
                uint32_t v;
                struct mmem_funcdef s;
        } funcdef;

        sc->sc_dev = self;
        sc->sc_parent = parent;
        sc->sc_unit = ma->ma_unit;
        sc->sc_devinfo = ma->ma_devinfo;

        funcdef.v = maple_get_function_data(ma->ma_devinfo, MAPLE_FN_MEMCARD);
        printf(": Memory card\n");
        printf("%s: %d part, %d bytes/block, ",
            device_xname(self),
            sc->sc_npt = funcdef.s.pt + 1,
            sc->sc_bsize = (funcdef.s.bb + 1)  << 5);
        if ((sc->sc_wacc = funcdef.s.wa) == 0)
                printf("no write, ");
        else
                printf("%d acc/write, ", sc->sc_wacc);
        if ((sc->sc_racc = funcdef.s.ra) == 0)
                printf("no read\n");
        else
                printf("%d acc/read\n", sc->sc_racc);

        /*
         * start init sequence
         */
        sc->sc_stat = MMEM_INIT;
        bufq_alloc(&sc->sc_q, "disksort", BUFQ_SORT_RAWBLOCK);

        /* check consistency */
        if (sc->sc_wacc != 0) {
                sc->sc_waccsz = sc->sc_bsize / sc->sc_wacc;
                if (sc->sc_bsize != sc->sc_waccsz * sc->sc_wacc) {
                        printf("%s: write access isn't equally divided\n",
                            device_xname(self));
                        sc->sc_wacc = 0;        /* no write */
                } else if (sc->sc_waccsz > MMEM_MAXACCSIZE) {
                        printf("%s: write access size is too large\n",
                            device_xname(self));
                        sc->sc_wacc = 0;        /* no write */
                }
        }
        if (sc->sc_racc != 0) {
                sc->sc_raccsz = sc->sc_bsize / sc->sc_racc;
                if (sc->sc_bsize != sc->sc_raccsz * sc->sc_racc) {
                        printf("%s: read access isn't equally divided\n",
                            device_xname(self));
                        sc->sc_racc = 0;        /* no read */
                } else if (sc->sc_raccsz > MMEM_MAXACCSIZE) {
                        printf("%s: read access size is too large\n",
                            device_xname(self));
                        sc->sc_racc = 0;        /* no read */
                }
        }
        if (sc->sc_wacc == 0 && sc->sc_racc == 0) {
                printf("%s: device doesn't support read nor write\n",
                    device_xname(self));
                return;
        }

        /* per-part structure */
        sc->sc_pt = malloc(sizeof(struct mmem_pt) * sc->sc_npt, M_DEVBUF,
            M_WAITOK|M_ZERO);

        for (i = 0; i < sc->sc_npt; i++) {
                snprintf(sc->sc_pt[i].pt_name, sizeof(sc->sc_pt[i].pt_name),
                    "%s.%d", device_xname(self), i);
        }

        maple_set_callback(parent, sc->sc_unit, MAPLE_FN_MEMCARD,
            mmem_intr, sc);

        /*
         * get capacity (start from partition 0)
         */
        sc->sc_reqm.func_code = htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
        sc->sc_reqm.pt = 0;
        maple_command(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD,
            MAPLE_COMMAND_GETMINFO, sizeof sc->sc_reqm / 4, &sc->sc_reqm, 0);
}

static int
mmemdetach(device_t self, int flags)
{
        struct mmem_softc *sc = device_private(self);
        struct buf *bp;
        int i;
        int minor_l, minor_h;

        sc->sc_stat = MMEM_DETACH;      /* just in case */

        /*
         * kill pending I/O
         */
        if ((bp = sc->sc_bp) != NULL) {
                bp->b_error = EIO;
                bp->b_resid = bp->b_bcount;
                biodone(bp);
        }
        while ((bp = bufq_get(sc->sc_q)) != NULL) {
                bp->b_error = EIO;
                bp->b_resid = bp->b_bcount;
                biodone(bp);
        }
        bufq_free(sc->sc_q);

        /*
         * revoke vnodes
         */
#ifdef __HAVE_OLD_DISKLABEL
 #error This code assumes DISKUNIT() is contiguous in minor number.
#endif
        minor_l = MMEM_DISKMINOR(device_unit(self), 0, 0);
        minor_h = MMEM_DISKMINOR(device_unit(self), sc->sc_npt - 1,
            MAXPARTITIONS - 1);
        vdevgone(bdevsw_lookup_major(&mmem_bdevsw), minor_l, minor_h, VBLK);
        vdevgone(cdevsw_lookup_major(&mmem_cdevsw), minor_l, minor_h, VCHR);

        /*
         * free per-partition structure
         */
        if (sc->sc_pt) {
                /*
                 * detach disks
                 */
                for (i = 0; i < sc->sc_npt; i++) {
                        if (sc->sc_pt[i].pt_flags & MMEM_PT_OK) {
                                disk_detach(&sc->sc_pt[i].pt_dk);
                                disk_destroy(&sc->sc_pt[i].pt_dk);
                        }
                }
                free(sc->sc_pt, M_DEVBUF);
        }

        return 0;
}

/* fake disklabel */
static void
mmem_defaultlabel(struct mmem_softc *sc, struct mmem_pt *pt,
    struct disklabel *d)
{

        memset(d, 0, sizeof *d);

#if 0
        d->d_type = DKTYPE_FLOPPY;              /* XXX? */
#endif
        strncpy(d->d_typename, sc->sc_devinfo->di_product_name,
            sizeof d->d_typename);
        strcpy(d->d_packname, "fictitious");
        d->d_secsize = sc->sc_bsize;
        d->d_ntracks = 1;                       /* XXX */
        d->d_nsectors = d->d_secpercyl = 8;     /* XXX */
        d->d_secperunit = pt->pt_info.maxblk - pt->pt_info.minblk + 1;
        d->d_ncylinders = d->d_secperunit / d->d_secpercyl;
        d->d_rpm = 1;                           /* when 4 acc/write */

        d->d_npartitions = RAW_PART + 1;
        d->d_partitions[RAW_PART].p_size = d->d_secperunit;

        d->d_magic = d->d_magic2 = DISKMAGIC;
        d->d_checksum = dkcksum(d);
}

/*
 * called back from maple bus driver
 */
static void
mmem_intr(void *arg, struct maple_response *response, int sz, int flags)
{
        struct mmem_softc *sc = arg;
        struct mmem_response_read_data *r = (void *) response->data;
        struct mmem_response_media_info *rm = (void *) response->data;
        struct buf *bp;
        int part;
        struct mmem_pt *pt;
        char pbuf[9];
        int off;

        switch (sc->sc_stat) {
        case MMEM_INIT:
                /* checking part geometry */
                part = sc->sc_reqm.pt;
                pt = &sc->sc_pt[part];
                switch ((maple_response_t) response->response_code) {
                case MAPLE_RESPONSE_DATATRF:
                        pt->pt_info = rm->info;
                        format_bytes(pbuf, sizeof(pbuf),
                            (uint64_t)
                                ((pt->pt_info.maxblk - pt->pt_info.minblk + 1)
                                 * sc->sc_bsize));
                        printf("%s: %s, blk %d %d, inf %d, fat %d %d, dir %d %d, icon %d, data %d\n",
                            pt->pt_name,
                            pbuf,
                            pt->pt_info.maxblk, pt->pt_info.minblk,
                            pt->pt_info.infpos,
                            pt->pt_info.fatpos, pt->pt_info.fatsz,
                            pt->pt_info.dirpos, pt->pt_info.dirsz,
                            pt->pt_info.icon,
                            pt->pt_info.datasz);

                        disk_init(&pt->pt_dk, pt->pt_name, &mmemdkdriver);
                        disk_attach(&pt->pt_dk);

                        mmem_defaultlabel(sc, pt, pt->pt_dk.dk_label);

                        /* this partition is active */
                        pt->pt_flags = MMEM_PT_OK;

                        break;
                default:
                        printf("%s: init: unexpected response %#x, sz %d\n",
                            pt->pt_name, be32toh(response->response_code), sz);
                        break;
                }
                if (++part == sc->sc_npt) {
#if 1
                        /*
                         * XXX Read a block and discard the contents (only to
                         * turn off the access indicator on Visual Memory).
                         */
                        pt = &sc->sc_pt[0];
                        sc->sc_reqr.func_code =
                            htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
                        sc->sc_reqr.pt = 0;
                        sc->sc_reqr.block = htobe16(pt->pt_info.minblk);
                        sc->sc_reqr.phase = 0;
                        maple_command(sc->sc_parent, sc->sc_unit,
                            MAPLE_FN_MEMCARD, MAPLE_COMMAND_BREAD,
                            sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
                        sc->sc_stat = MMEM_INIT2;
#else
                        sc->sc_stat = MMEM_IDLE;        /* init done */
#endif
                } else {
                        sc->sc_reqm.pt = part;
                        maple_command(sc->sc_parent, sc->sc_unit,
                            MAPLE_FN_MEMCARD, MAPLE_COMMAND_GETMINFO,
                            sizeof sc->sc_reqm / 4, &sc->sc_reqm, 0);
                }
                break;

        case MMEM_INIT2:
                /* XXX just discard */
                sc->sc_stat = MMEM_IDLE;        /* init done */
                break;

        case MMEM_READ:
                bp = sc->sc_bp;

                switch ((maple_response_t) response->response_code) {
                case MAPLE_RESPONSE_DATATRF:            /* read done */
                        off = sc->sc_raccsz * sc->sc_reqr.phase;
                        memcpy(sc->sc_iobuf + off, r->data + off,
                            sc->sc_raccsz);

                        if (++sc->sc_reqr.phase == sc->sc_racc) {
                                /* all phase done */
                                pt = &sc->sc_pt[sc->sc_reqr.pt];
                                mmemdone(sc, pt, 0);
                        } else {
                                /* go next phase */
                                maple_command(sc->sc_parent, sc->sc_unit,
                                    MAPLE_FN_MEMCARD, MAPLE_COMMAND_BREAD,
                                    sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
                        }
                        break;
                case MAPLE_RESPONSE_FILEERR:
                        mmem_printerror(sc->sc_pt[sc->sc_reqr.pt].pt_name,
                            1, bp->b_rawblkno,
                            r->func_code /* XXX */);
                        mmemstart_bp(sc);               /* retry */
                        break;
                default:
                        printf("%s: read: unexpected response %#x %#x, sz %d\n",
                            sc->sc_pt[sc->sc_reqr.pt].pt_name,
                            be32toh(response->response_code),
                            be32toh(r->func_code), sz);
                        mmemstart_bp(sc);               /* retry */
                        break;
                }
                break;

        case MMEM_WRITE1:       /* read before write / verify after write */
                bp = sc->sc_bp;

                switch ((maple_response_t) response->response_code) {
                case MAPLE_RESPONSE_DATATRF:            /* read done */
                        off = sc->sc_raccsz * sc->sc_reqr.phase;
                        if (memcmp(r->data + off, sc->sc_iobuf + off,
                            sc->sc_raccsz)) {
                                /*
                                 * data differ, start writing
                                 */
                                mmemstart_write2(sc);
                        } else if (++sc->sc_reqr.phase == sc->sc_racc) {
                                /*
                                 * all phase done and compared equal
                                 */
                                pt = &sc->sc_pt[sc->sc_reqr.pt];
                                mmemdone(sc, pt, 0);
                        } else {
                                /* go next phase */
                                maple_command(sc->sc_parent, sc->sc_unit,
                                    MAPLE_FN_MEMCARD, MAPLE_COMMAND_BREAD,
                                    sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
                        }
                        break;
                case MAPLE_RESPONSE_FILEERR:
                        mmem_printerror(sc->sc_pt[sc->sc_reqr.pt].pt_name,
                            1, bp->b_rawblkno,
                            r->func_code /* XXX */);
                        mmemstart_write2(sc);   /* start writing */
                        break;
                default:
                        printf("%s: verify: unexpected response %#x %#x, sz %d\n",
                            sc->sc_pt[sc->sc_reqr.pt].pt_name,
                            be32toh(response->response_code),
                            be32toh(r->func_code), sz);
                        mmemstart_write2(sc);   /* start writing */
                        break;
                }
                break;

        case MMEM_WRITE2:       /* write */
                bp = sc->sc_bp;

                switch ((maple_response_t) response->response_code) {
                case MAPLE_RESPONSE_OK:                 /* write done */
                        if (sc->sc_reqw.phase == sc->sc_wacc) {
                                /* all phase done */
                                mmemstart_bp(sc);       /* start verify */
                        } else if (++sc->sc_reqw.phase == sc->sc_wacc) {
                                /* check error */
                                maple_command(sc->sc_parent, sc->sc_unit,
                                    MAPLE_FN_MEMCARD, MAPLE_COMMAND_GETLASTERR,
                                    2 /* no data */ , &sc->sc_reqw,
                                    MAPLE_FLAG_CMD_PERIODIC_TIMING);
                        } else {
                                /* go next phase */
                                memcpy(sc->sc_reqw.data, sc->sc_iobuf +
                                    sc->sc_waccsz * sc->sc_reqw.phase,
                                    sc->sc_waccsz);
                                maple_command(sc->sc_parent, sc->sc_unit,
                                    MAPLE_FN_MEMCARD, MAPLE_COMMAND_BWRITE,
                                    MMEM_SIZE_REQW(sc) / 4, &sc->sc_reqw,
                                    MAPLE_FLAG_CMD_PERIODIC_TIMING);
                        }
                        break;
                case MAPLE_RESPONSE_FILEERR:
                        mmem_printerror(sc->sc_pt[sc->sc_reqw.pt].pt_name,
                            0, bp->b_rawblkno,
                            r->func_code /* XXX */);
                        mmemstart_write2(sc);   /* retry writing */
                        break;
                default:
                        printf("%s: write: unexpected response %#x, %#x, sz %d\n",
                            sc->sc_pt[sc->sc_reqw.pt].pt_name,
                            be32toh(response->response_code),
                            be32toh(r->func_code), sz);
                        mmemstart_write2(sc);   /* retry writing */
                        break;
                }
                break;

        default:
                break;
        }
}

static void
mmem_printerror(const char *head, int rd, int blk, uint32_t code)
{

        printf("%s: error %sing blk %d:", head, rd? "read" : "writ", blk);
        NTOHL(code);
        if (code & 1)
                printf(" PT error");
        if (code & 2)
                printf(" Phase error");
        if (code & 4)
                printf(" Block error");
        if (code & 010)
                printf(" Write error");
        if (code & 020)
                printf(" Length error");
        if (code & 040)
                printf(" CRC error");
        if (code & ~077)
                printf(" Unknown error %#x", code & ~077);
        printf("\n");
}

int
mmemopen(dev_t dev, int flags, int devtype, struct lwp *l)
{
        int diskunit, unit, part, labelpart;
        struct mmem_softc *sc;
        struct mmem_pt *pt;

        diskunit = DISKUNIT(dev);
        unit = MMEM_UNIT(diskunit);
        part = MMEM_PART(diskunit);
        labelpart = DISKPART(dev);
        if ((sc = device_lookup_private(&mmem_cd, unit)) == NULL
            || sc->sc_stat == MMEM_INIT
            || sc->sc_stat == MMEM_INIT2
            || part >= sc->sc_npt || (pt = &sc->sc_pt[part])->pt_flags == 0)
                return ENXIO;

        switch (devtype) {
        case S_IFCHR:
                pt->pt_dk.dk_copenmask |= (1 << labelpart);
                break;
        case S_IFBLK:
                pt->pt_dk.dk_bopenmask |= (1 << labelpart);
                break;
        }

        return 0;
}

int
mmemclose(dev_t dev, int flags, int devtype, struct lwp *l)
{
        int diskunit, unit, part, labelpart;
        struct mmem_softc *sc;
        struct mmem_pt *pt;

        diskunit = DISKUNIT(dev);
        unit = MMEM_UNIT(diskunit);
        part = MMEM_PART(diskunit);
        sc = device_lookup_private(&mmem_cd, unit);
        pt = &sc->sc_pt[part];
        labelpart = DISKPART(dev);

        switch (devtype) {
        case S_IFCHR:
                pt->pt_dk.dk_copenmask &= ~(1 << labelpart);
                break;
        case S_IFBLK:
                pt->pt_dk.dk_bopenmask &= ~(1 << labelpart);
                break;
        }

        return 0;
}

void
mmemstrategy(struct buf *bp)
{
        int diskunit, unit, part, labelpart;
        struct mmem_softc *sc;
        struct mmem_pt *pt;
        daddr_t off, nblk, cnt;

        diskunit = DISKUNIT(bp->b_dev);
        unit = MMEM_UNIT(diskunit);
        part = MMEM_PART(diskunit);
        if ((sc = device_lookup_private(&mmem_cd, unit)) == NULL
            || sc->sc_stat == MMEM_INIT
            || sc->sc_stat == MMEM_INIT2
            || part >= sc->sc_npt || (pt = &sc->sc_pt[part])->pt_flags == 0)
                goto inval;

#if 0
        printf("%s: mmemstrategy: blkno %d, count %ld\n",
            pt->pt_name, bp->b_blkno, bp->b_bcount);
#endif

        if (bp->b_flags & B_READ) {
                if (sc->sc_racc == 0)
                        goto inval;             /* no read */
        } else if (sc->sc_wacc == 0) {
                bp->b_error = EROFS;            /* no write */
                goto done;
        }

        if (bp->b_blkno & ~(~(daddr_t)0 >> (DEV_BSHIFT + 1 /* sign bit */))
            || (bp->b_bcount % sc->sc_bsize) != 0)
                goto inval;

        cnt = howmany(bp->b_bcount, sc->sc_bsize);
        if (cnt == 0)
                goto done;      /* no work */

        off = bp->b_blkno * DEV_BSIZE / sc->sc_bsize;

        /* offset to disklabel partition */
        labelpart = DISKPART(bp->b_dev);
        if (labelpart == RAW_PART) {
                nblk = pt->pt_info.maxblk - pt->pt_info.minblk + 1;
        } else {
                off +=
                    nblk = pt->pt_dk.dk_label->d_partitions[labelpart].p_offset;
                nblk += pt->pt_dk.dk_label->d_partitions[labelpart].p_size;
        }

        /* deal with the EOF condition */
        if (off + cnt > nblk) {
                if (off >= nblk) {
                        if (off == nblk)
                                goto done;
                        goto inval;
                }
                cnt = nblk - off;
                bp->b_resid = bp->b_bcount - (cnt * sc->sc_bsize);
        }

        bp->b_rawblkno = off;

        /* queue this transfer */
        bufq_put(sc->sc_q, bp);

        if (sc->sc_stat == MMEM_IDLE)
                mmemstart(sc);

        return;

inval:  bp->b_error = EINVAL;
done:   bp->b_resid = bp->b_bcount;
        biodone(bp);
}

/*
 * start I/O operations
 */
static void
mmemstart(struct mmem_softc *sc)
{
        struct buf *bp;
        struct mmem_pt *pt;
        int s;

        if ((bp = bufq_get(sc->sc_q)) == NULL) {
                sc->sc_stat = MMEM_IDLE;
                maple_enable_unit_ping(sc->sc_parent, sc->sc_unit,
                    MAPLE_FN_MEMCARD, 1);
                return;
        }

        sc->sc_bp = bp;
        sc->sc_cnt = howmany(bp->b_bcount - bp->b_resid, sc->sc_bsize);
        KASSERT(sc->sc_cnt);
        sc->sc_iobuf = bp->b_data;
        sc->sc_retry = 0;

        pt = &sc->sc_pt[MMEM_PART(DISKUNIT(bp->b_dev))];
        s = splbio();
        disk_busy(&pt->pt_dk);
        splx(s);

        /*
         * I/O access will fail if the removal detection (by maple driver)
         * occurs before finishing the I/O, so disable it.
         * We are sending commands, and the removal detection is still alive.
         */
        maple_enable_unit_ping(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD, 0);

        mmemstart_bp(sc);
}

/*
 * start/retry a specified I/O operation
 */
static void
mmemstart_bp(struct mmem_softc *sc)
{
        struct buf *bp;
        int diskunit, part;
        struct mmem_pt *pt;

        bp = sc->sc_bp;
        diskunit = DISKUNIT(bp->b_dev);
        part = MMEM_PART(diskunit);
        pt = &sc->sc_pt[part];

        /* handle retry */
        if (sc->sc_retry++ > MMEM_MAXRETRY) {
                /* retry count exceeded */
                mmemdone(sc, pt, EIO);
                return;
        }

        /*
         * Start the first phase (phase# = 0).
         */
        /* start read */
        sc->sc_stat = (bp->b_flags & B_READ) ? MMEM_READ : MMEM_WRITE1;
        sc->sc_reqr.func_code = htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
        sc->sc_reqr.pt = part;
        sc->sc_reqr.block = htobe16(bp->b_rawblkno);
        sc->sc_reqr.phase = 0;          /* first phase */
        maple_command(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD,
            MAPLE_COMMAND_BREAD, sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
}

static void
mmemstart_write2(struct mmem_softc *sc)
{
        struct buf *bp;
        int diskunit, part;
        struct mmem_pt *pt;

        bp = sc->sc_bp;
        diskunit = DISKUNIT(bp->b_dev);
        part = MMEM_PART(diskunit);
        pt = &sc->sc_pt[part];

        /* handle retry */
        if (sc->sc_retry++ > MMEM_MAXRETRY - 2 /* spare for verify read */) {
                /* retry count exceeded */
                mmemdone(sc, pt, EIO);
                return;
        }

        /*
         * Start the first phase (phase# = 0).
         */
        /* start write */
        sc->sc_stat = MMEM_WRITE2;
        sc->sc_reqw.func_code = htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
        sc->sc_reqw.pt = part;
        sc->sc_reqw.block = htobe16(bp->b_rawblkno);
        sc->sc_reqw.phase = 0;          /* first phase */
        memcpy(sc->sc_reqw.data, sc->sc_iobuf /* + sc->sc_waccsz * phase */,
            sc->sc_waccsz);
        maple_command(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD,
            MAPLE_COMMAND_BWRITE, MMEM_SIZE_REQW(sc) / 4, &sc->sc_reqw,
            MAPLE_FLAG_CMD_PERIODIC_TIMING);
}

static void
mmemdone(struct mmem_softc *sc, struct mmem_pt *pt, int err)
{
        struct buf *bp = sc->sc_bp;
        int s;
        int bcnt;

        KASSERT(bp);

        if (err) {
                bcnt = (char *)sc->sc_iobuf - (char *)bp->b_data;
                bp->b_resid = bp->b_bcount - bcnt;

                /* raise error if no block is read */
                if (bcnt == 0) {
                        bp->b_error = err;
                }
                goto term_xfer;
        }

        sc->sc_iobuf += sc->sc_bsize;
        if (--sc->sc_cnt == 0) {
        term_xfer:
                /* terminate current transfer */
                sc->sc_bp = NULL;
                s = splbio();
                disk_unbusy(&pt->pt_dk,
                    (char *)sc->sc_iobuf - (char *)bp->b_data,
                    sc->sc_stat == MMEM_READ);
                biodone(bp);
                splx(s);

                /* go next transfer */
                mmemstart(sc);
        } else {
                /* go next block */
                bp->b_rawblkno++;
                sc->sc_retry = 0;
                mmemstart_bp(sc);
        }
}

int
mmemread(dev_t dev, struct uio *uio, int flags)
{

        return physio(mmemstrategy, NULL, dev, B_READ, minphys, uio);
}

int
mmemwrite(dev_t dev, struct uio *uio, int flags)
{

        return physio(mmemstrategy, NULL, dev, B_WRITE, minphys, uio);
}

int
mmemioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        int diskunit, unit, part;
        struct mmem_softc *sc;
        struct mmem_pt *pt;

        diskunit = DISKUNIT(dev);
        unit = MMEM_UNIT(diskunit);
        part = MMEM_PART(diskunit);
        sc = device_lookup_private(&mmem_cd, unit);
        pt = &sc->sc_pt[part];

        switch (cmd) {
        case DIOCGDINFO:
                *(struct disklabel *)data = *pt->pt_dk.dk_label; /* XXX */
                break;

        default:
                /* generic maple ioctl */
                return maple_unit_ioctl(sc->sc_parent, sc->sc_unit, cmd, data,
                    flag, l);
        }

        return 0;
}