void
platform_probe_and_attach(void)
{
platform_def_t **platpp, *platp;
int prio, best_prio;
plat_obj = &plat_kernel_obj;
best_prio = 0;
/*
* We are unable to use TUNABLE_STR as the read will happen
* well after this function has returned.
*/
TUNABLE_STR_FETCH("hw.platform", plat_name, sizeof(plat_name));
/*
* 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((kobj_class_t)platp,
&plat_kernel_kops);
kobj_init_static((kobj_t)plat_obj, (kobj_class_t)platp);
plat_obj->cls = 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;
}
/*
* Routines used in machine-dependent code
*/
void
pmap_bootstrap(vm_offset_t start, vm_offset_t end)
{
mmu_obj = &mmu_kernel_obj;
/*
* Take care of compiling the selected class, and
* then statically initialise the MMU object
*/
kobj_class_compile_static(mmu_def_impl, &mmu_kernel_kops);
kobj_init_static((kobj_t)mmu_obj, mmu_def_impl);
MMU_BOOTSTRAP(mmu_obj, start, end);
}
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. Luckily,
* this has no ill effects since it gets reset every time.
*/
}
/**
* Probe and attach a bhnd_erom parser instance for the bhnd bus.
*
* @param[out] erom_cls The probed EROM class.
* @param[out] erom_ops The storage to be used when compiling
* @p erom_cls.
* @param[out] erom The storage to be used when initializing the
* static instance of @p erom_cls.
* @param esize The total available number of bytes allocated
* for @p erom. If this is less than is required
* by @p erom_cls ENOMEM will be returned.
* @param eio EROM I/O callbacks to be used.
* @param[out] cid On success, the probed chip identification.
*/
static int
bcm_erom_probe_and_attach(bhnd_erom_class_t **erom_cls, kobj_ops_t erom_ops,
bhnd_erom_t *erom, size_t esize, struct bhnd_erom_io *eio,
struct bhnd_chipid *cid)
{
bhnd_erom_class_t **clsp;
bus_addr_t bus_addr;
int error, prio, result;
*erom_cls = NULL;
prio = 0;
/* Map our first bus core for the erom probe */
bus_addr = bcm_get_bus_addr();
if ((error = bhnd_erom_io_map(eio, bus_addr, BHND_DEFAULT_CORE_SIZE))) {
BCM_ERR("failed to map first core at %#jx+%#jx: %d\n",
(uintmax_t)bus_addr, (uintmax_t)BHND_DEFAULT_CORE_SIZE,
error);
return (error);
}
SET_FOREACH(clsp, bhnd_erom_class_set) {
struct bhnd_chipid pcid;
bhnd_erom_class_t *cls;
struct kobj_ops kops;
cls = *clsp;
/* Compile the class' ops table */
kobj_class_compile_static(cls, &kops);
/* Probe the bus address */
result = bhnd_erom_probe(cls, eio, NULL, &pcid);
/* Drop pointer to stack allocated ops table */
cls->ops = NULL;
/* The parser did not match if an error was returned */
if (result > 0)
continue;
/* Check for a new highest priority match */
if (*erom_cls == NULL || result > prio) {
prio = result;
*cid = pcid;
*erom_cls = cls;
}
/* Terminate immediately on BUS_PROBE_SPECIFIC */
if (result == BUS_PROBE_SPECIFIC)
break;
}
/* Valid EROM class probed? */
if (*erom_cls == NULL) {
BCM_ERR("no erom parser found for root bus at %#jx\n",
(uintmax_t)bus_addr);
return (ENOENT);
}
/* Using the provided storage, recompile the erom class ... */
kobj_class_compile_static(*erom_cls, erom_ops);
/* ... and initialize the erom parser instance */
error = bhnd_erom_init_static(*erom_cls, erom, esize, cid, eio);
return (error);
}