struct mpu401 *
mpu401_init(kobj_class_t cls, void *cookie, driver_intr_t softintr,
mpu401_intr_t ** cb)
{
struct mpu401 *m;
*cb = NULL;
m = malloc(sizeof(*m), M_MIDI, M_NOWAIT | M_ZERO);
if (!m)
return NULL;
kobj_init((kobj_t)m, cls);
callout_init(&m->timer, CALLOUT_MPSAFE);
m->si = softintr;
m->cookie = cookie;
m->flags = 0;
m->mid = midi_init(&mpu401_class, 0, 0, m);
if (!m->mid)
goto err;
*cb = mpu401_intr;
return m;
err:
printf("mpu401_init error\n");
free(m, M_MIDI);
return NULL;
}
int
scc_bfe_probe(device_t dev, u_int regshft, u_int rclk, u_int rid)
{
struct scc_softc *sc;
struct scc_class *cl;
u_long size, sz;
int error;
/*
* Initialize the instance. Note that the instance (=softc) does
* not necessarily match the hardware specific softc. We can't do
* anything about it now, because we may not attach to the device.
* Hardware drivers cannot use any of the class specific fields
* while probing.
*/
sc = device_get_softc(dev);
cl = sc->sc_class;
kobj_init((kobj_t)sc, (kobj_class_t)cl);
sc->sc_dev = dev;
if (device_get_desc(dev) == NULL)
device_set_desc(dev, cl->name);
size = abs(cl->cl_range) << regshft;
/*
* Allocate the register resource. We assume that all SCCs have a
* single register window in either I/O port space or memory mapped
* I/O space. Any SCC that needs multiple windows will consequently
* not be supported by this driver as-is.
*/
sc->sc_rrid = rid;
sc->sc_rtype = SYS_RES_MEMORY;
sc->sc_rres = bus_alloc_resource(dev, sc->sc_rtype, &sc->sc_rrid,
0, ~0, cl->cl_channels * size, RF_ACTIVE);
if (sc->sc_rres == NULL) {
sc->sc_rrid = rid;
sc->sc_rtype = SYS_RES_IOPORT;
sc->sc_rres = bus_alloc_resource(dev, sc->sc_rtype,
&sc->sc_rrid, 0, ~0, cl->cl_channels * size, RF_ACTIVE);
if (sc->sc_rres == NULL)
return (ENXIO);
}
/*
* Fill in the bus access structure and call the hardware specific
* probe method.
*/
sz = (size != 0) ? size : rman_get_size(sc->sc_rres);
sc->sc_bas.bsh = rman_get_bushandle(sc->sc_rres);
sc->sc_bas.bst = rman_get_bustag(sc->sc_rres);
sc->sc_bas.range = sz;
sc->sc_bas.rclk = rclk;
sc->sc_bas.regshft = regshft;
error = SCC_PROBE(sc);
bus_release_resource(dev, sc->sc_rtype, sc->sc_rrid, sc->sc_rres);
return ((error == 0) ? BUS_PROBE_DEFAULT : error);
}
void
platform_probe_and_attach()
{
platform_def_t **platpp, *platp;
int prio, best_prio;
plat_obj = &plat_kernel_obj;
best_prio = 0;
/*
* Try to locate the best platform kobj
*/
SET_FOREACH(platpp, platform_set) {
platp = *platpp;
/*
* Take care of compiling the selected class, and
* then statically initialise the MMU object
*/
kobj_class_compile_static(platp, &plat_kernel_kops);
kobj_init((kobj_t)plat_obj, platp);
prio = PLATFORM_PROBE(plat_obj);
/* Check for errors */
if (prio > 0)
continue;
/*
* Check if this module was specifically requested through
* the loader tunable we provide.
*/
if (strcmp(platp->name,plat_name) == 0) {
plat_def_impl = platp;
break;
}
/* Otherwise, see if it is better than our current best */
if (plat_def_impl == NULL || prio > best_prio) {
best_prio = prio;
plat_def_impl = platp;
}
/*
* We can't free the KOBJ, since it is static. Reset the ops
* member of this class so that we can come back later.
*/
platp->ops = NULL;
}
void fb_mm_initbuf(struct fb_conf * fb)
{
struct buf * bp = &fb->mem;
/* Just to make sure we don't have anything fancy there. */
memset(bp, 0, sizeof(struct buf));
mtx_init(&bp->lock, MTX_TYPE_TICKET, 0);
/* TODO We must implement a generic initializer for this */
kobj_init(&bp->b_obj, fb_mm_free_callback);
fb->mem.b_flags = B_BUSY | B_NOSYNC | B_NOTSHARED | B_NOCORE;
bp->vm_ops = &fb_mm_bufops;
bp->b_mmu.vaddr = 0; /* Will be set when mapped. */
bp->b_mmu.pt = NULL; /* Will be set when mapped. */
}
kobj_t
kobj_create(kobj_class_t cls,
struct malloc_type *mtype,
int mflags)
{
kobj_t obj;
/*
* Allocate and initialise the new object.
*/
obj = malloc(cls->size, mtype, mflags | M_ZERO);
if (!obj)
return 0;
kobj_init(obj, cls);
return obj;
}
/*ARGSUSED3*/
void
_kobj_boot(
struct boot_syscalls *syscallp,
void *dvec,
struct bootops *bootops,
Boot *ebp)
{
val_t bootaux[BA_NUM];
int i;
for (i = 0; i < BA_NUM; i++)
bootaux[i].ba_val = NULL;
bootaux[BA_ENTRY].ba_ptr = (void *)_locore_start;
bootaux[BA_PAGESZ].ba_val = MMU_PAGESIZE;
bootaux[BA_LPAGESZ].ba_val = kbm_nucleus_size;
/*
* Initialize krtld.
*/
kobj_init(syscallp, dvec, bootops, bootaux);
}
