/* $NetBSD: midictl.c,v 1.10 2022/10/31 20:35:02 andvar Exp $ */

/*-
 * Copyright (c) 2006, 2008 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Chapman Flack, and by Andrew Doran.
 *
 * 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: midictl.c,v 1.10 2022/10/31 20:35:02 andvar Exp $");

/*
 * See midictl.h for an overview of the purpose and use of this module.
 */

#include <sys/systm.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/kmem.h>

#include "midictl.h"

/*
 * The upper part of this file is MIDI-aware, and deals with things like
 * decoding MIDI Control Change messages, dealing with the ones that require
 * special handling as mode messages or parameter updates, and so on.
 *
 * It relies on a "store" layer (implemented in the lower part of this file)
 * that only must be able to stash away 2-, 8-, or 16-bit quantities (which
 * it may pack into larger units as it sees fit) and find them again given
 * a class, channel, and key (controller/parameter number).
 *
 * The MIDI controllers can have 1-, 7-, or 14-bit values; the parameters are
 * also 14-bit. The 14-bit values have to be set in two MIDI messages, 7 bits
 * at a time. The MIDI layer uses store-managed 2- or 8-bit slots for the
 * smaller types, and uses the free high bit to indicate that it has explicitly
 * set the value. (Because the store is allowed to pack things, it may 'find'
 * a zero entry for a value we never set, because it shares a word with a
 * different value that has been set. We know it is not a real value because
 * the high bit is clear.)
 *
 * The 14-bit values are handled similarly: 16-bit store slots are used to hold
 * them, with the two free high bits indicating independently whether the MSB
 * and the LSB have been explicitly set--as two separate MIDI messages are
 * required. If such a control is queried when only one half has been explicitly
 * set, the result is as if it had been set to the specified default value
 * before the explicit set.
 */

typedef enum { CTL1, CTL7, CTL14, RPN, NRPN } class;

/*
 * assert(does_not_apply(KNFNamespaceArgumentAgainstNamesInPrototypes,
 *    PrototypesOfStaticFunctionsWithinNonIncludedFile));
 */
static void reset_all_controllers(midictl *mc, uint_fast8_t chan);
static void enter14(midictl *mc, uint_fast8_t chan, class c,
                    uint_fast16_t key, _Bool islsb, uint8_t val);
static uint_fast16_t read14(midictl *mc, uint_fast8_t chan, class c,
                            uint_fast16_t key, uint_fast16_t dflt);
static class classify(uint_fast16_t *key, _Bool *islsb);
static midictl_notify notify_no_one;

static _Bool store_locate(midictl_store *s, class c,
                            uint_fast8_t chan, uint_fast16_t key);
/*
 * store_extract and store_update operate on the bucket most recently found
 * by store_locate on this store. That works because reentrancy of midictl
 * functions is limited: they /can/ be reentered during midictl_notify
 * callbacks, but not at other arbitrary times. We never call notify /during/
 * a locate/extract/update transaction.
 */
static uint16_t store_extract(midictl_store *s, class c,
                              uint_fast8_t chan, uint_fast16_t key);
static void store_update(midictl_store *s, class c,
                         uint_fast8_t chan, uint_fast16_t key, uint16_t value);

#define PN_SET 0x8000  /* a parameter number has been explicitly set */
#define C14MSET 0x8000 /* MSB of a 14-bit val has been set */
#define C14LSET 0x4000 /* LSB of a 14-bit val has been set */
#define C7_SET 0x80    /* a 7-bit ctl has been set */
#define C1_SET 2       /* a 1-bit ctl has been set */

/*
 *   I M P L E M E N T A T I O N     O F     T H E     S T O R E :
 *
 * MIDI defines a metric plethora of possible controllers, registered
 * parameters, and nonregistered parameters: a bit more than 32k possible words
 * to store. The saving grace is that only a handful are likely to appear in
 * typical MIDI data, and only a handful are likely implemented by or
 * interesting to a typical client. So the store implementation needs to be
 * suited to a largish but quite sparse data set.
 *
 * A double-hashed, open address table is used here. Each slot is a uint64
 * that contains the match key (control class|channel|ctl-or-PN-number) as
 * well as the values for two or more channels. CTL14s, RPNs, and NRPNs can
 * be packed two channels to the slot; CTL7s, six channels; and CTL1s get all
 * 16 channels into one slot. The channel value used in the key is the lowest
 * channel stored in the slot. Open addressing is appropriate here because the
 * link fields in a chained approach would be at least 100% overhead, and also,
 * we don't delete (MIDICTL_RESET is the only event that logically deletes
 * things, and at the moment it does not remove anything from the table, but
 * zeroes the stored value). If wanted, the deletion algorithm for open
 * addressing could be used, with shrinking/rehashing when the load factor
 * drops below 3/8 (1/2 is the current threshold for expansion), and the
 * rehashing would relieve the fills-with-DELETED problem in most cases. But
 * for now the table never shrinks while the device is open.
 */

struct midictl_store {
        uint64_t *table;
        uint64_t key;
        uint32_t idx;
        uint32_t lgcapacity;
        uint32_t used;
        kcondvar_t cv;
        kmutex_t *lock;
        bool destroy;
};

#define INITIALLGCAPACITY 6 /* initial capacity 1<<6 */
#define IS_USED 1<<15
#define IS_CTL7 1<<14

#define CTL1SHIFT(chan) (23+((chan)<<1))
#define CTL7SHIFT(chan) (16+((chan)<<3))
#define CTLESHIFT(chan) (23+((chan)<<4))

#define NEED_REHASH(s)  ((s)->used * 2 >= 1 << (s)->lgcapacity)

static uint_fast8_t const packing[] = {
        [CTL1 ] = 16, /* 16 * 2 bits ==> 32 bits, all chns in one bucket */
        [CTL7 ] =  6, /*  6 * 8 bits ==> 48 bits, 6 chns in one bucket */
        [CTL14] =  2, /*  2 *16 bits ==> 32 bits, 2 chns in one bucket */
        [RPN  ] =  2,
        [NRPN ] =  2
};

static uint32_t store_idx(uint32_t lgcapacity,
                          uint64_t *table,
                          uint64_t key, uint64_t mask);
static void store_rehash(midictl_store *s);
static void store_thread(void *);

int
midictl_open(midictl *mc)
{
        midictl_store *s;
        int error;

        if (mc->lock == NULL)
                panic("midictl_open: no lock");
        if (NULL == mc->notify)
                mc->notify = notify_no_one;
        s = kmem_zalloc(sizeof(*s), KM_SLEEP);
        s->lgcapacity = INITIALLGCAPACITY;
        s->table = kmem_zalloc(sizeof(*s->table)<<s->lgcapacity, KM_SLEEP);
        s->lock = mc->lock;
        cv_init(&s->cv, "midictlv");
        error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, store_thread, 
            s, NULL, "midictlt");
        if (error != 0) {
                printf("midictl: cannot create kthread, error = %d\n", error);
                cv_destroy(&s->cv);
                kmem_free(s->table, sizeof(*s->table)<<s->lgcapacity);
                kmem_free(s, sizeof(*s));
                return error;
        }
        mc->store = s;
        return 0;
}

void
midictl_close(midictl *mc)
{
        midictl_store *s;
        kmutex_t *lock;

        s = mc->store;
        lock = s->lock;

        mutex_enter(lock);
        s->destroy = true;
        cv_broadcast(&s->cv);
        mutex_exit(lock);
}

void
midictl_change(midictl *mc, uint_fast8_t chan, uint8_t *ctlval)
{
        class c;
        uint_fast16_t key, val;
        _Bool islsb, present;

        KASSERT(mutex_owned(mc->lock));
        KASSERT(!mc->store->destroy);
                
        switch ( ctlval[0] ) {
        /*
         * Channel mode messages:
         */
        case MIDI_CTRL_OMNI_OFF:
        case MIDI_CTRL_OMNI_ON:
        case MIDI_CTRL_POLY_OFF:
        case MIDI_CTRL_POLY_ON:
                if ( chan != mc->base_channel )
                        return; /* ignored - not on base channel */
                else
                        return; /* XXX ignored anyway - not implemented yet */
        case MIDI_CTRL_NOTES_OFF:
                mc->notify(mc->cookie, MIDICTL_NOTES_OFF, chan, 0);
                return;
        case MIDI_CTRL_LOCAL:
                mc->notify(mc->cookie, MIDICTL_LOCAL, chan, ctlval[1]);
                return;
        case MIDI_CTRL_SOUND_OFF:
                mc->notify(mc->cookie, MIDICTL_SOUND_OFF, chan, 0);
                return;
        case MIDI_CTRL_RESET:
                reset_all_controllers(mc, chan);
                return;
        /*
         * Control changes to be handled specially:
         */
        case MIDI_CTRL_RPN_LSB:
                mc-> rpn &= ~0x7f;
                mc-> rpn |=  PN_SET | (0x7f & ctlval[1]);
                mc->nrpn &= ~PN_SET;
                return;
        case MIDI_CTRL_RPN_MSB:
                mc-> rpn &= ~0x7fU<<7;
                mc-> rpn |=  PN_SET | (0x7f & ctlval[1])<<7;
                mc->nrpn &= ~PN_SET;
                return;
        case MIDI_CTRL_NRPN_LSB:
                mc->nrpn &= ~0x7f;
                mc->nrpn |=  PN_SET | (0x7f & ctlval[1]);
                mc-> rpn &= ~PN_SET;
                return;
        case MIDI_CTRL_NRPN_MSB:
                mc->nrpn &= ~0x7fU<<7;
                mc->nrpn |=  PN_SET | (0x7f & ctlval[1])<<7;
                mc-> rpn &= ~PN_SET;
                return;
        case MIDI_CTRL_DATA_ENTRY_LSB:
                islsb = 1;
                goto whichparm;
        case MIDI_CTRL_DATA_ENTRY_MSB:
                islsb = 0;
        whichparm:
                if ( 0 == ( (mc->rpn ^ mc->nrpn) & PN_SET ) )
                        return; /* exactly one must be current */
                if ( mc->rpn & PN_SET ) {
                        key = mc->rpn;
                        c = RPN;
                } else {
                        key = mc->nrpn;
                        c = NRPN;
                }
                key &= 0x3fff;
                if ( 0x3fff == key ) /* 'null' parm# to lock out changes */
                        return;
                enter14(mc, chan, c, key, islsb, ctlval[1]);
                return;
        case MIDI_CTRL_RPN_INCREMENT: /* XXX for later - these are a PITA to */
        case MIDI_CTRL_RPN_DECREMENT: /* get right - 'right' varies by param */
                        /* see http://www.midi.org/about-midi/rp18.shtml */
                return;
        }
        
        /*
         * Channel mode, RPN, and NRPN operations have been ruled out.
         * This is an ordinary control change.
         */
        
        key = ctlval[0];
        c = classify(&key, &islsb);
        
        switch ( c ) {
        case CTL14:
                enter14(mc, chan, c, key, islsb, ctlval[1]);
                return;
        case CTL7:
                present = store_locate(mc->store, c, chan, key);
                if ( !mc->accept_any_ctl_rpn ) {
                        if ( !present )
                                break;
                        val = store_extract(mc->store, c, chan, key);
                        if ( !(val&C7_SET) )
                                break;
                }
                store_update(mc->store, c, chan, key,
                    C7_SET | (0x7f & ctlval[1]));
                mc->notify(mc->cookie, MIDICTL_CTLR, chan, key);
                return;
        case CTL1:
                present = store_locate(mc->store, c, chan, key);
                if ( !mc->accept_any_ctl_rpn ) {
                        if ( !present )
                                break;
                        val = store_extract(mc->store, c, chan, key);
                        if ( !(val&C1_SET) )
                                break;
                }
                store_update(mc->store, c, chan, key,
                    C1_SET | (ctlval[1]>63));
                mc->notify(mc->cookie, MIDICTL_CTLR, chan, key);
                return;
        case RPN:
        case NRPN:
                return; /* won't see these - sop for gcc */
        }
}

uint_fast16_t
midictl_read(midictl *mc, uint_fast8_t chan, uint_fast8_t ctlr,
             uint_fast16_t dflt)
{
        uint_fast16_t key, val;
        class c;
        _Bool islsb, present;

        KASSERT(mutex_owned(mc->lock));
        KASSERT(!mc->store->destroy);
        
        key = ctlr;
        c = classify(&key, &islsb);
        switch ( c ) {
        case CTL1:
                present = store_locate(mc->store, c, chan, key);
                if ( !present ||
                    !(C1_SET&(val = store_extract(mc->store, c, chan, key))) ) {
                        val = C1_SET | (dflt > 63); /* convert to boolean */
                        store_update(mc->store, c, chan, key, val);
                }
                return (val & 1) ? 127 : 0;
        case CTL7:
                present = store_locate(mc->store, c, chan, key);
                if ( !present ||
                    !(C7_SET&(val = store_extract(mc->store, c, chan, key))) ) {
                        val = C7_SET | (dflt & 0x7f);
                        store_update(mc->store, c, chan, key, val);
                }
                return val & 0x7f;
        case CTL14:
                KASSERT(!islsb);
                return read14(mc, chan, c, key, dflt);
        case RPN:
        case NRPN:
                break; /* sop for gcc */
        }
        return 0; /* sop for gcc */
}

uint_fast16_t
midictl_rpn_read(midictl *mc, uint_fast8_t chan, uint_fast16_t ctlr,
                 uint_fast16_t dflt)
{

        KASSERT(mutex_owned(mc->lock));
        KASSERT(!mc->store->destroy);

        return read14(mc, chan, RPN, ctlr, dflt);
}

uint_fast16_t
midictl_nrpn_read(midictl *mc, uint_fast8_t chan, uint_fast16_t ctlr,
                  uint_fast16_t dflt)
{

        KASSERT(mutex_owned(mc->lock));
        KASSERT(!mc->store->destroy);

        return read14(mc, chan, NRPN, ctlr, dflt);
}

static void
reset_all_controllers(midictl *mc, uint_fast8_t chan)
{
        uint_fast16_t ctlr, key;
        class c;
        _Bool islsb, present;

        KASSERT(mutex_owned(mc->lock));
        
        for ( ctlr = 0 ; ; ++ ctlr ) {
                switch ( ctlr ) {
                /*
                 * exempt by http://www.midi.org/about-midi/rp15.shtml:
                 */
                case MIDI_CTRL_BANK_SELECT_MSB:         /* 0 */
                case MIDI_CTRL_CHANNEL_VOLUME_MSB:      /* 7 */
                case MIDI_CTRL_PAN_MSB:                 /* 10 */
                        continue;
                case MIDI_CTRL_BANK_SELECT_LSB:         /* 32 */
                        ctlr += 31; /* skip all these LSBs anyway */
                        continue;
                case MIDI_CTRL_SOUND_VARIATION:         /* 70 */
                        ctlr += 9; /* skip all Sound Controllers */
                        continue;
                case MIDI_CTRL_EFFECT_DEPTH_1:          /* 91 */
                        goto loop_exit; /* nothing more gets reset */
                /*
                 * exempt for our own personal reasons:
                 */
                case MIDI_CTRL_DATA_ENTRY_MSB:          /* 6 */
                        continue; /* doesn't go to the store */
                }
                
                key = ctlr;
                c = classify(&key, &islsb);
                
                present = store_locate(mc->store, c, chan, key);
                if ( !present )
                        continue;
                store_update(mc->store, c, chan, key, 0); /* no C*SET */
        }
loop_exit:
        mc->notify(mc->cookie, MIDICTL_RESET, chan, 0);
}

static void
enter14(midictl *mc, uint_fast8_t chan, class c, uint_fast16_t key,
        _Bool islsb, uint8_t val)
{
        uint16_t stval;
        _Bool present;
        
        KASSERT(mutex_owned(mc->lock));

        present = store_locate(mc->store, c, chan, key);
        stval = (present) ? store_extract(mc->store, c, chan, key) : 0;
        if ( !( stval & (C14MSET|C14LSET) ) ) {
                if ( !((NRPN==c)? mc->accept_any_nrpn: mc->accept_any_ctl_rpn) )
                        return;
        }
        if ( islsb )
                stval = C14LSET | val | ( stval & ~0x7f );
        else
                stval = C14MSET | ( val << 7 ) | ( stval & ~0x3f80 );
        store_update(mc->store, c, chan, key, stval);
        mc->notify(mc->cookie, CTL14 == c ? MIDICTL_CTLR
                             : RPN   == c ? MIDICTL_RPN
                             : MIDICTL_NRPN, chan, key);
}

static uint_fast16_t
read14(midictl *mc, uint_fast8_t chan, class c, uint_fast16_t key,
       uint_fast16_t dflt)
{
        uint16_t val;
        _Bool present;

        KASSERT(mutex_owned(mc->lock));

        present = store_locate(mc->store, c, chan, key);
        if ( !present )
                goto neitherset;

        val = store_extract(mc->store, c, chan, key);
        switch ( val & (C14MSET|C14LSET) ) {
        case C14MSET|C14LSET:
                return val & 0x3fff;
        case C14MSET:
                val = C14LSET | (val & ~0x7f) | (dflt & 0x7f);
                break;
        case C14LSET:
                val = C14MSET | (val & ~0x3f8) | (dflt & 0x3f8);
                break;
neitherset:
        case 0:
                val = C14MSET|C14LSET | (dflt & 0x3fff);
        }
        store_update(mc->store, c, chan, key, val);
        return val & 0x3fff;
}

/*
 * Determine the controller class; ranges based on
 * http://www.midi.org/about-midi/table3.shtml dated 1995/1999/2002
 * and viewed 2 June 2006.
 */
static class
classify(uint_fast16_t *key, _Bool *islsb) {
        if ( *key < 32 ) {
                *islsb = 0;
                return CTL14;
        } else if ( *key < 64 ) {
                *islsb = 1;
                *key -= 32;
                return CTL14;
        } else if ( *key < 70 ) {
                return CTL1;
        }               /* 70-84 defined, 85-90 undef'd, 91-95 def'd */
        return CTL7;    /* 96-101,120- handled above, 102-119 all undef'd */
                        /* treat them all as CTL7 */
}

static void
notify_no_one(void *cookie, midictl_evt evt,
    uint_fast8_t chan, uint_fast16_t k)
{
}

#undef PN_SET
#undef C14MSET
#undef C14LSET
#undef C7_SET
#undef C1_SET

static void
store_thread(void *arg)
{
        midictl_store *s;

        s = arg;

        mutex_enter(s->lock);
        for (;;) {
                if (s->destroy) {
                        mutex_exit(s->lock);
                        cv_destroy(&s->cv);
                        kmem_free(s->table, sizeof(*s->table)<<s->lgcapacity);
                        kmem_free(s, sizeof(*s));
                        kthread_exit(0);
                } else if (NEED_REHASH(s)) {
                        store_rehash(s);
                } else {
                        cv_wait(&s->cv, s->lock);
                }
        }
}

static _Bool
store_locate(midictl_store *s, class c, uint_fast8_t chan, uint_fast16_t key)
{
        uint64_t mask;

        KASSERT(mutex_owned(s->lock));
        
        if ( s->used >= 1 << s->lgcapacity )
                panic("%s: repeated attempts to expand table failed", __func__);

        chan = packing[c] * (chan/packing[c]);

        if ( CTL7 == c ) {      /* only 16 bits here (key's only 7) */
                s->key = IS_USED | IS_CTL7 | (chan << 7) | key;
                mask = 0xffff;
        } else {                /* use 23 bits (key could be 14) */
                s->key = (c << 20) | (chan << 16) | IS_USED | key;
                mask = 0x7fffff;
        }
        
        s->idx = store_idx(s->lgcapacity, s->table, s->key, mask);
        
        if ( !(s->table[s->idx] & IS_USED) )
                return 0;

        return 1;
}

static uint16_t
store_extract(midictl_store *s, class c, uint_fast8_t chan,
    uint_fast16_t key)
{

        KASSERT(mutex_owned(s->lock));

        chan %= packing[c];
        switch ( c ) {
        case CTL1:
                return 3 & (s->table[s->idx]>>CTL1SHIFT(chan));
        case CTL7:
                return 0xff & (s->table[s->idx]>>CTL7SHIFT(chan));
        case CTL14:
        case RPN:
        case NRPN:
                break;
        }
        return 0xffff & (s->table[s->idx]>>CTLESHIFT(chan));
}

static void
store_update(midictl_store *s, class c, uint_fast8_t chan,
    uint_fast16_t key, uint16_t value)
{
        uint64_t orig;

        KASSERT(mutex_owned(s->lock));
        
        orig = s->table[s->idx];
        if ( !(orig & IS_USED) ) {
                orig = s->key;
                ++ s->used;
        }
                
        chan %= packing[c];
        
        switch ( c ) {
        case CTL1:
                orig &= ~(((uint64_t)3)<<CTL1SHIFT(chan));
                orig |= ((uint64_t)(3 & value)) << CTL1SHIFT(chan);
                break;
        case CTL7:
                orig &= ~(((uint64_t)0xff)<<CTL7SHIFT(chan));
                orig |= ((uint64_t)(0xff & value)) << CTL7SHIFT(chan);
                break;
        case CTL14:
        case RPN:
        case NRPN:
                orig &= ~(((uint64_t)0xffff)<<CTLESHIFT(chan));
                orig |= ((uint64_t)value) << CTLESHIFT(chan);
                break;
        }
        
        s->table[s->idx] = orig;
        if (NEED_REHASH(s))
                cv_broadcast(&s->cv);
}

static uint32_t
store_idx(uint32_t lgcapacity, uint64_t *table,
          uint64_t key, uint64_t mask)
{
        uint32_t val;
        uint32_t k, h1, h2;
        int32_t idx;
        
        k = key;
        
        h1 = ((k * 0x61c88646) >> (32-lgcapacity)) & ((1<<lgcapacity) - 1);
        h2 = ((k * 0x9e3779b9) >> (32-lgcapacity)) & ((1<<lgcapacity) - 1);     
        h2 |= 1;

        for ( idx = h1 ;; idx -= h2 ) {
                if ( idx < 0 )
                        idx += 1<<lgcapacity;
                val = (uint32_t)(table[idx] & mask);
                if ( val == k )
                        break;
                if ( !(val & IS_USED) )
                        break; 
        }
        
        return idx;
}

static void
store_rehash(midictl_store *s)
{
        uint64_t *newtbl, *oldtbl, mask;
        uint32_t oldlgcap, newlgcap, oidx, nidx;

        KASSERT(mutex_owned(s->lock));

        oldlgcap = s->lgcapacity;
        newlgcap = oldlgcap + s->lgcapacity;

        mutex_exit(s->lock);
        newtbl = kmem_zalloc(sizeof(*newtbl) << newlgcap, KM_SLEEP);
        mutex_enter(s->lock);

        /*
         * If s->lgcapacity is changed from what we saved int oldlgcap
         * then someone else has already done this for us.
         * XXXMRG but only function changes s->lgcapacity from its
         * initial value, and it is called single threaded from the
         * main store_thread(), so this code seems dead to me.
         */
        if (oldlgcap != s->lgcapacity) {
                KASSERT(FALSE);
                mutex_exit(s->lock);
                kmem_free(newtbl, sizeof(*newtbl) << newlgcap);
                mutex_enter(s->lock);
                return;
        }
                        
        for (oidx = 1 << s->lgcapacity ; oidx-- > 0 ; ) {
                if (!(s->table[oidx] & IS_USED))
                        continue;
                if (s->table[oidx] & IS_CTL7)
                        mask = 0xffff;
                else
                        mask = 0x3fffff;
                nidx = store_idx(newlgcap, newtbl,
                    s->table[oidx] & mask, mask);
                newtbl[nidx] = s->table[oidx];
        }
        oldtbl = s->table;
        s->table = newtbl;
        s->lgcapacity = newlgcap;
        
        mutex_exit(s->lock);
        kmem_free(oldtbl, sizeof(*oldtbl) << oldlgcap);
        mutex_enter(s->lock);
}