int
show_pkg_info_from_metadir(struct xbps_handle *xhp,
const char *pkgname,
const char *option)
{
prop_dictionary_t d, pkgdb_d;
const char *instdate, *pname;
bool autoinst;
d = xbps_dictionary_from_metadata_plist(xhp, pkgname, XBPS_PKGPROPS);
if (d == NULL)
return EINVAL;
prop_dictionary_get_cstring_nocopy(d, "pkgname", &pname);
pkgdb_d = xbps_pkgdb_get_pkgd(xhp, pname, false);
if (pkgdb_d == NULL) {
prop_object_release(d);
return EINVAL;
}
if (prop_dictionary_get_cstring_nocopy(pkgdb_d,
"install-date", &instdate))
prop_dictionary_set_cstring_nocopy(d, "install-date",
instdate);
if (prop_dictionary_get_bool(pkgdb_d, "automatic-install", &autoinst))
prop_dictionary_set_bool(d, "automatic-install", autoinst);
if (option == NULL)
show_pkg_info(d);
else
show_pkg_info_one(d, option);
prop_object_release(d);
return 0;
}
int
npf_config_submit(nl_config_t *ncf, int fd)
{
const char *plist = ncf->ncf_plist;
prop_dictionary_t npf_dict;
prop_array_t rlset;
int error = 0;
npf_dict = prop_dictionary_create();
if (npf_dict == NULL) {
return ENOMEM;
}
prop_dictionary_set_uint32(npf_dict, "version", NPF_VERSION);
rlset = _npf_ruleset_transform(ncf->ncf_rules_list);
if (rlset == NULL) {
prop_object_release(npf_dict);
return ENOMEM;
}
prop_object_release(ncf->ncf_rules_list);
ncf->ncf_rules_list = rlset;
prop_dictionary_set(npf_dict, "rules", ncf->ncf_rules_list);
prop_dictionary_set(npf_dict, "algs", ncf->ncf_alg_list);
prop_dictionary_set(npf_dict, "rprocs", ncf->ncf_rproc_list);
prop_dictionary_set(npf_dict, "tables", ncf->ncf_table_list);
prop_dictionary_set(npf_dict, "translation", ncf->ncf_nat_list);
prop_dictionary_set_bool(npf_dict, "flush", ncf->ncf_flush);
if (ncf->ncf_debug) {
prop_dictionary_set(npf_dict, "debug", ncf->ncf_debug);
}
if (plist) {
if (!prop_dictionary_externalize_to_file(npf_dict, plist)) {
error = errno;
}
prop_object_release(npf_dict);
return error;
}
if (fd) {
error = prop_dictionary_sendrecv_ioctl(npf_dict, fd,
IOC_NPF_RELOAD, &ncf->ncf_err);
if (error) {
prop_object_release(npf_dict);
assert(ncf->ncf_err == NULL);
return error;
}
prop_dictionary_get_int32(ncf->ncf_err, "errno", &error);
}
prop_object_release(npf_dict);
return error;
}
static void
add_model_specifics(prop_dictionary_t dict)
{
const char *bl_rev_models[] = {
"PowerBook4,3", "PowerBook6,3", "PowerBook6,5", NULL};
int node;
node = OF_finddevice("/");
if (of_compatible(node, bl_rev_models) != -1) {
prop_dictionary_set_bool(dict, "backlight_level_reverted", 1);
}
}
static void
tegra_genfb_attach(device_t parent, device_t self, void *aux)
{
struct tegra_genfb_softc * const sc = device_private(self);
struct tegrafb_attach_args * const tfb = aux;
prop_dictionary_t prop = device_properties(self);
const bool is_console = tfb->tfb_console;
struct genfb_ops ops;
sc->sc_gen.sc_dev = self;
sc->sc_dmat = tfb->tfb_dmat;
sc->sc_dmamap = tfb->tfb_dmamap;
prop_dictionary_set_bool(prop, "is_console", is_console);
prop_dictionary_set_uint32(prop, "width", tfb->tfb_width);
prop_dictionary_set_uint32(prop, "height", tfb->tfb_height);
prop_dictionary_set_uint8(prop, "depth", tfb->tfb_depth);
prop_dictionary_set_uint32(prop, "linebytes", tfb->tfb_stride);
prop_dictionary_set_uint64(prop, "address", 0);
prop_dictionary_set_uint64(prop, "virtual_address",
(uintptr_t)tfb->tfb_dmap);
genfb_init(&sc->sc_gen);
if (sc->sc_gen.sc_width == 0 || sc->sc_gen.sc_fbsize == 0) {
aprint_error(": disabled\n");
return;
}
pmf_device_register1(self, NULL, NULL, tegra_genfb_shutdown);
aprint_naive("\n");
if (is_console) {
aprint_normal(": switching to framebuffer console\n");
} else {
aprint_normal("\n");
}
memset(&ops, 0, sizeof(ops));
ops.genfb_ioctl = tegra_genfb_ioctl;
ops.genfb_mmap = tegra_genfb_mmap;
genfb_attach(&sc->sc_gen, &ops);
#if defined(DDB)
if (is_console) {
tegra_genfb_consoledev = self;
db_trap_callback = tegra_genfb_ddb_trap_callback;
}
#endif
}
int
npfctl_getconf(u_long cmd, void *data)
{
struct plistref *pref = data;
prop_dictionary_t npf_dict;
int error;
npf_core_enter();
npf_dict = npf_core_dict();
prop_dictionary_set_bool(npf_dict, "active", npf_pfil_registered_p());
error = prop_dictionary_copyout_ioctl(pref, cmd, npf_dict);
npf_core_exit();
return error;
}
device_t
device_isa_register(device_t dev, void *aux)
{
/*
* Handle network interfaces here, the attachment information is
* not available driver-independently later.
*
* For disks, there is nothing useful available at attach time.
*/
if (device_class(dev) == DV_IFNET) {
struct btinfo_netif *bin = lookup_bootinfo(BTINFO_NETIF);
if (bin == NULL)
return NULL;
/*
* We don't check the driver name against the device name
* passed by the boot ROM. The ROM should stay usable if
* the driver becomes obsolete. The physical attachment
* information (checked below) must be sufficient to
* identify the device.
*/
if (bin->bus == BI_BUS_ISA &&
device_is_a(device_parent(dev), "isa")) {
struct isa_attach_args *iaa = aux;
/* Compare IO base address */
/* XXXJRT What about multiple IO addrs? */
if (iaa->ia_nio > 0 &&
bin->addr.iobase == iaa->ia_io[0].ir_addr)
return dev;
}
}
#if NACPICA > 0
#if notyet
if (device_is_a(dev, "isa") && acpi_active) {
if (!(AcpiGbl_FADT.BootFlags & ACPI_FADT_LEGACY_DEVICES))
prop_dictionary_set_bool(device_properties(dev),
"no-legacy-devices", true);
}
#endif
#endif /* NACPICA > 0 */
return NULL;
}
void
copy_disp_props(struct device *dev, int node, prop_dictionary_t dict)
{
uint32_t temp;
char typestr[32];
memset(typestr, 0, sizeof(typestr));
OF_getprop(console_node, "device_type", typestr, sizeof(typestr));
if (strcmp(typestr, "serial") != 0) {
/* this is our console, when we don't have a serial console */
prop_dictionary_set_bool(dict, "is_console", 1);
}
if (!of_to_uint32_prop(dict, node, "width", "width")) {
OF_interpret("screen-width", 0, 1, &temp);
prop_dictionary_set_uint32(dict, "width", temp);
}
if (!of_to_uint32_prop(dict, node, "height", "height")) {
OF_interpret("screen-height", 0, 1, &temp);
prop_dictionary_set_uint32(dict, "height", temp);
}
of_to_uint32_prop(dict, node, "linebytes", "linebytes");
if (!of_to_uint32_prop(dict, node, "depth", "depth")) {
/*
* XXX we should check linebytes vs. width but those
* FBs that don't have a depth property ( /chaos/control... )
* won't have linebytes either
*/
prop_dictionary_set_uint32(dict, "depth", 8);
}
if (!of_to_uint32_prop(dict, node, "address", "address")) {
uint32_t fbaddr = 0;
OF_interpret("frame-buffer-adr", 0, 1, &fbaddr);
if (fbaddr != 0)
prop_dictionary_set_uint32(dict, "address", fbaddr);
}
}
void
device_register(struct device *dev, void *aux)
{
struct device *pdev;
if ((pdev = device_parent(dev)) != NULL &&
device_is_a(pdev, "pci")) {
/*
* cats builtin aceride is on 0:16:0
*/
struct pci_attach_args *pa = aux;
if (((pa)->pa_bus == 0
&& (pa)->pa_device == 16
&& (pa)->pa_function == 0)) {
if (prop_dictionary_set_bool(device_properties(dev),
"ali1543-ide-force-compat-mode",
true) == false) {
printf("WARNING: unable to set "
"ali1543-ide-force-compat-mode "
"property for %s\n", dev->dv_xname);
}
}
}
}
void
cubie_device_register(device_t self, void *aux)
{
prop_dictionary_t dict = device_properties(self);
if (device_is_a(self, "armperiph")
&& device_is_a(device_parent(self), "mainbus")) {
/*
* XXX KLUDGE ALERT XXX
* The iot mainbus supplies is completely wrong since it scales
* addresses by 2. The simpliest remedy is to replace with our
* bus space used for the armcore regisers (which armperiph uses).
*/
struct mainbus_attach_args * const mb = aux;
mb->mb_iot = &awin_bs_tag;
return;
}
#if defined(CPU_CORTEXA7) || defined(CPU_CORTEXA15)
if (device_is_a(self, "armgtmr")) {
/*
* The frequency of the generic timer is the reference
* frequency.
*/
prop_dictionary_set_uint32(dict, "frequency", AWIN_REF_FREQ);
return;
}
#endif
if (device_is_a(self, "awinio")) {
prop_dictionary_set_bool(dict, "no-awge", true);
return;
}
if (device_is_a(self, "awingpio")) {
/*
* These are GPIOs being used for various functions.
*/
prop_dictionary_set_cstring(dict, "satapwren", ">PB8");
prop_dictionary_set_cstring(dict, "usb0drv", ">PB9");
prop_dictionary_set_cstring(dict, "usb2drv", ">PH3");
prop_dictionary_set_cstring(dict, "usb0iddet", "<PH4");
prop_dictionary_set_cstring(dict, "usb0vbusdet", "<PH5");
prop_dictionary_set_cstring(dict, "usb1drv", ">PH6");
prop_dictionary_set_cstring(dict, "hdd5ven", ">PH17");
prop_dictionary_set_cstring(dict, "emacpwren", ">PH19");
prop_dictionary_set_cstring(dict, "status-led1", ">PH21");
prop_dictionary_set_cstring(dict, "status-led2", ">PH20");
/*
* These pins have no connections.
*/
prop_dictionary_set_uint32(dict, "nc-b", 0x0003d0e8);
prop_dictionary_set_uint32(dict, "nc-c", 0x00ff0000);
prop_dictionary_set_uint32(dict, "nc-h", 0x03c53f04);
prop_dictionary_set_uint32(dict, "nc-i", 0x003fc03f);
return;
}
if (device_is_a(self, "ehci")) {
return;
}
if (device_is_a(self, "ahcisata")) {
/* PIO PB<8> output */
prop_dictionary_set_cstring(dict, "power-gpio", "satapwren");
return;
}
if (device_is_a(self, "sdhc")) {
#if 0
prop_dictionary_set_uint32(dict, "clkmask", 0);
prop_dictionary_set_bool(dict, "8bit", true);
#endif
return;
}
if (device_is_a(self, "com")) {
#if NAWIN_FB > 0
if (use_fb_console)
prop_dictionary_set_bool(dict, "is_console", false);
#endif
return;
}
}
static void
copyprops(struct device *busdev, int node, prop_dictionary_t dict)
{
struct device *cntrlr;
prop_dictionary_t psycho;
paddr_t fbpa, mem_base = 0;
uint32_t temp, fboffset;
uint32_t fbaddr = 0;
int options;
char output_device[256];
char *pos;
cntrlr = device_parent(busdev);
if (cntrlr != NULL) {
psycho = device_properties(cntrlr);
prop_dictionary_get_uint64(psycho, "mem_base", &mem_base);
}
prop_dictionary_set_bool(dict, "is_console", 1);
if (!of_to_uint32_prop(dict, node, "width", "width")) {
OF_interpret("screen-width", 0, 1, &temp);
prop_dictionary_set_uint32(dict, "width", temp);
}
if (!of_to_uint32_prop(dict, console_node, "height", "height")) {
OF_interpret("screen-height", 0, 1, &temp);
prop_dictionary_set_uint32(dict, "height", temp);
}
of_to_uint32_prop(dict, console_node, "linebytes", "linebytes");
if (!of_to_uint32_prop(dict, console_node, "depth", "depth") &&
/* Some cards have an extra space in the property name */
!of_to_uint32_prop(dict, console_node, "depth ", "depth")) {
/*
* XXX we should check linebytes vs. width but those
* FBs that don't have a depth property ( /chaos/control... )
* won't have linebytes either
*/
prop_dictionary_set_uint32(dict, "depth", 8);
}
OF_getprop(console_node, "address", &fbaddr, sizeof(fbaddr));
if (fbaddr == 0)
OF_interpret("frame-buffer-adr", 0, 1, &fbaddr);
if (fbaddr != 0) {
pmap_extract(pmap_kernel(), fbaddr, &fbpa);
#ifdef DEBUG
printf("membase: %lx fbpa: %lx\n", (unsigned long)mem_base,
(unsigned long)fbpa);
#endif
if (mem_base == 0) {
/* XXX this is guesswork */
fboffset = (uint32_t)(fbpa & 0xffffffff);
}
fboffset = (uint32_t)(fbpa - mem_base);
prop_dictionary_set_uint32(dict, "address", fboffset);
}
of_to_dataprop(dict, console_node, "EDID", "EDID");
temp = 0;
if (OF_getprop(console_node, "ATY,RefCLK", &temp, sizeof(temp)) != 4) {
OF_getprop(OF_parent(console_node), "ATY,RefCLK", &temp,
sizeof(temp));
}
if (temp != 0)
prop_dictionary_set_uint32(dict, "refclk", temp / 10);
/*
* finally, let's see if there's a video mode specified in
* output-device and pass it on so drivers like radeonfb
* can do their thing
*/
options = OF_finddevice("/options");
if ((options == 0) || (options == -1))
return;
if (OF_getprop(options, "output-device", output_device, 256) == 0)
return;
printf("output-device: %s\n", output_device);
/* find the mode string if there is one */
pos = strstr(output_device, ":r");
if (pos == NULL)
return;
prop_dictionary_set_cstring(dict, "videomode", pos + 2);
}
void
copy_disp_props(struct device *dev, int node, prop_dictionary_t dict)
{
uint32_t temp;
uint64_t cmap_cb;
if (node != console_node) {
/*
* see if any child matches since OF attaches nodes for
* each head and /chosen/stdout points to the head
* rather than the device itself in this case
*/
int sub;
sub = OF_child(node);
while ((sub != 0) && (sub != console_node)) {
sub = OF_peer(sub);
}
if (sub != console_node)
return;
node = sub;
}
prop_dictionary_set_bool(dict, "is_console", 1);
if (!of_to_uint32_prop(dict, node, "width", "width")) {
OF_interpret("screen-width", 0, 1, &temp);
prop_dictionary_set_uint32(dict, "width", temp);
}
if (!of_to_uint32_prop(dict, node, "height", "height")) {
OF_interpret("screen-height", 0, 1, &temp);
prop_dictionary_set_uint32(dict, "height", temp);
}
of_to_uint32_prop(dict, node, "linebytes", "linebytes");
if (!of_to_uint32_prop(dict, node, "depth", "depth")) {
/*
* XXX we should check linebytes vs. width but those
* FBs that don't have a depth property ( /chaos/control... )
* won't have linebytes either
*/
prop_dictionary_set_uint32(dict, "depth", 8);
}
if (!of_to_uint32_prop(dict, node, "address", "address")) {
uint32_t fbaddr = 0;
OF_interpret("frame-buffer-adr", 0, 1, &fbaddr);
if (fbaddr != 0)
prop_dictionary_set_uint32(dict, "address", fbaddr);
}
of_to_dataprop(dict, node, "EDID", "EDID");
add_model_specifics(dict);
temp = 0;
if (OF_getprop(node, "ATY,RefCLK", &temp, sizeof(temp)) != 4) {
OF_getprop(OF_parent(node), "ATY,RefCLK", &temp,
sizeof(temp));
}
if (temp != 0)
prop_dictionary_set_uint32(dict, "refclk", temp / 10);
gfb_cb.gcc_cookie = (void *)console_instance;
gfb_cb.gcc_set_mapreg = of_set_palette;
cmap_cb = (uint64_t)&gfb_cb;
prop_dictionary_set_uint64(dict, "cmap_callback", cmap_cb);
}
void
device_register(device_t dev, void *aux)
{
static int found, initted, scsiboot, netboot;
device_t parent = device_parent(dev);
if (mach_type == MACH_SGI_IP32 &&
parent != NULL && device_is_a(parent, "pci")) {
struct pci_attach_args *pa = aux;
if (BUILTIN_AHC_P(pa)) {
if (prop_dictionary_set_bool(device_properties(dev),
"aic7xxx-use-target-defaults", true) == false) {
printf("WARNING: unable to set "
"aic7xxx-use-target-defaults property "
"for %s\n", device_xname(dev));
}
if (prop_dictionary_set_bool(device_properties(dev),
"aic7xxx-override-ultra", true) == false) {
printf("WARNING: unable to set "
"aic7xxx-override-ultra property for %s\n",
device_xname(dev));
}
}
}
/*
* The Set Engineering GIO Fast Ethernet controller has restrictions
* on DMA boundaries.
*/
if (device_is_a(dev, "tl")) {
device_t grandparent;
prop_number_t gfe_boundary;
grandparent = device_parent(parent);
if (grandparent != NULL && device_is_a(grandparent, "giopci")) {
gfe_boundary = prop_number_create_integer(PAGE_SIZE);
KASSERT(gfe_boundary != NULL);
if (prop_dictionary_set(device_properties(dev),
"tl-dma-page-boundary", gfe_boundary) == false) {
printf("WARNING: unable to set "
"tl-dma-page-boundary property "
"for %s\n", device_xname(dev));
}
prop_object_release(gfe_boundary);
return;
}
}
if (found)
return;
if (!initted && booted_protocol) {
scsiboot = strcmp(booted_protocol, "SCSI") == 0;
netboot = (strcmp(booted_protocol, "BOOTP") == 0);
initted = 1;
}
/*
* Handle SCSI boot device definitions
* wdsc -- IP12/22/24
* ahc -- IP32
*/
if ( (scsiboot && device_is_a(dev, "wdsc")) ||
(scsiboot && device_is_a(dev, "ahc")) ) {
/* XXX device_unit() abuse */
if (device_unit(dev) == booted_slot)
booted_controller = dev;
return;
}
/*
* If we found the boot controller, if check disk/tape/cdrom device
* on that controller matches.
*/
if (booted_controller &&
(device_is_a(dev, "sd") ||
device_is_a(dev, "st") ||
device_is_a(dev, "cd"))) {
struct scsipibus_attach_args *sa = aux;
if (device_parent(parent) != booted_controller)
return;
if (booted_unit != sa->sa_periph->periph_target)
return;
booted_device = dev;
found = 1;
return;
}
/*
* Check if netboot device.
*/
if (netboot &&
(device_is_a(dev, "sq") ||
device_is_a(dev, "mec"))) {
/* XXX Check unit number? (Which we don't parse yet) */
booted_device = dev;
found = 1;
return;
}
}
void
device_register(device_t dev, void *aux)
{
#if NPCI > 0
static bool found_console = false;
struct pci_attach_args *paa = aux;
#endif
/*
* Handle network interfaces here, the attachment information is
* not available driver-independently later.
*
* For disks, there is nothing useful available at attach time.
*/
if (device_class(dev) == DV_IFNET) {
struct btinfo_netif *bin = lookup_bootinfo(BTINFO_NETIF);
if (bin == NULL)
return;
/*
* We don't check the driver name against the device name
* passed by the boot ROM. The ROM should stay usable if
* the driver becomes obsolete. The physical attachment
* information (checked below) must be sufficient to
* idenfity the device.
*/
if (bin->bus == BI_BUS_ISA &&
device_is_a(device_parent(dev), "isa")) {
struct isa_attach_args *iaa = aux;
/* Compare IO base address */
/* XXXJRT What about multiple IO addrs? */
if (iaa->ia_nio > 0 &&
bin->addr.iobase == iaa->ia_io[0].ir_addr)
goto found;
}
#if NPCI > 0
if (bin->bus == BI_BUS_PCI &&
device_is_a(device_parent(dev), "pci")) {
int b, d, f;
/*
* Calculate BIOS representation of:
*
* <bus,device,function>
*
* and compare.
*/
pci_decompose_tag(paa->pa_pc, paa->pa_tag, &b, &d, &f);
if (bin->addr.tag == ((b << 8) | (d << 3) | f))
goto found;
}
#endif /* NPCI > 0 */
}
#if NISA > 0 && NACPICA > 0
#if notyet
if (device_is_a(dev, "isa") && acpi_active) {
if (!(AcpiGbl_FADT.BootFlags & ACPI_FADT_LEGACY_DEVICES))
prop_dictionary_set_bool(device_properties(dev),
"no-legacy-devices", true);
}
#endif
#endif /* NISA > 0 && NACPICA > 0 */
#if NPCI > 0
if (device_parent(dev) && device_is_a(device_parent(dev), "pci") &&
found_console == false) {
struct btinfo_framebuffer *fbinfo;
struct pci_attach_args *pa = aux;
prop_dictionary_t dict;
#if NACPICA > 0
struct genfb_parameter_callback *gpc;
int b, d, f;
#endif
if (PCI_CLASS(pa->pa_class) == PCI_CLASS_DISPLAY) {
#if NWSDISPLAY > 0 && NGENFB > 0
extern struct vcons_screen x86_genfb_console_screen;
struct rasops_info *ri;
ri = &x86_genfb_console_screen.scr_ri;
#endif
fbinfo = lookup_bootinfo(BTINFO_FRAMEBUFFER);
dict = device_properties(dev);
/*
* framebuffer drivers other than genfb can work
* without the address property
*/
if (fbinfo != NULL) {
if (fbinfo->physaddr != 0) {
prop_dictionary_set_uint32(dict, "width",
fbinfo->width);
prop_dictionary_set_uint32(dict, "height",
fbinfo->height);
prop_dictionary_set_uint8(dict, "depth",
fbinfo->depth);
prop_dictionary_set_uint16(dict, "linebytes",
fbinfo->stride);
prop_dictionary_set_uint64(dict, "address",
fbinfo->physaddr);
#if NWSDISPLAY > 0 && NGENFB > 0
if (ri->ri_bits != NULL) {
prop_dictionary_set_uint64(dict,
"virtual_address",
(vaddr_t)ri->ri_bits);
}
#endif
}
#if notyet
prop_dictionary_set_bool(dict, "splash",
fbinfo->flags & BI_FB_SPLASH ?
true : false);
#endif
if (fbinfo->depth == 8) {
gfb_cb.gcc_cookie = NULL;
gfb_cb.gcc_set_mapreg =
x86_genfb_set_mapreg;
prop_dictionary_set_uint64(dict,
"cmap_callback",
(uint64_t)(uintptr_t)&gfb_cb);
}
if (fbinfo->physaddr != 0) {
mode_cb.gmc_setmode = x86_genfb_setmode;
prop_dictionary_set_uint64(dict,
"mode_callback",
(uint64_t)(uintptr_t)&mode_cb);
}
#if NWSDISPLAY > 0 && NGENFB > 0
if (device_is_a(dev, "genfb")) {
x86_genfb_set_console_dev(dev);
#ifdef DDB
db_trap_callback =
x86_genfb_ddb_trap_callback;
#endif
}
#endif
}
prop_dictionary_set_bool(dict, "is_console", true);
prop_dictionary_set_bool(dict, "clear-screen", false);
#if NWSDISPLAY > 0 && NGENFB > 0
prop_dictionary_set_uint16(dict, "cursor-row",
x86_genfb_console_screen.scr_ri.ri_crow);
#endif
#if notyet
prop_dictionary_set_bool(dict, "splash",
fbinfo->flags & BI_FB_SPLASH ? true : false);
#endif
pmf_cb.gpc_suspend = x86_genfb_suspend;
pmf_cb.gpc_resume = x86_genfb_resume;
prop_dictionary_set_uint64(dict,
"pmf_callback", (uint64_t)(uintptr_t)&pmf_cb);
#if NACPICA > 0
pci_decompose_tag(paa->pa_pc, paa->pa_tag, &b, &d, &f);
gpc = acpidisp_md_out_find(b, d, f);
if (gpc != NULL)
prop_dictionary_set_uint64(dict,
"brightness_callback", (uint64_t)(vaddr_t)gpc);
#endif
#ifdef VGA_POST
vga_posth = vga_post_init(pa->pa_bus, pa->pa_device,
pa->pa_function);
#endif
found_console = true;
return;
}
}
#endif
return;
found:
if (booted_device) {
/* XXX should be a panic() */
printf("WARNING: double match for boot device (%s, %s)\n",
device_xname(booted_device), device_xname(dev));
return;
}
booted_device = dev;
}
int
drmfb_attach(struct drmfb_softc *sc, const struct drmfb_attach_args *da)
{
const struct drm_fb_helper_surface_size *const sizes = da->da_fb_sizes;
const prop_dictionary_t dict = device_properties(da->da_dev);
#if NVGA > 0
struct drm_device *const dev = da->da_fb_helper->dev;
#endif
static const struct genfb_ops zero_genfb_ops;
struct genfb_ops genfb_ops = zero_genfb_ops;
enum { CONS_VGA, CONS_GENFB, CONS_NONE } what_was_cons;
int error;
/* genfb requires this. */
KASSERTMSG((void *)&sc->sc_genfb == device_private(da->da_dev),
"drmfb_softc must be first member of device softc");
sc->sc_da = *da;
prop_dictionary_set_uint32(dict, "width", sizes->surface_width);
prop_dictionary_set_uint32(dict, "height", sizes->surface_height);
prop_dictionary_set_uint8(dict, "depth", sizes->surface_bpp);
prop_dictionary_set_uint16(dict, "linebytes",
roundup2((sizes->surface_width * howmany(sizes->surface_bpp, 8)),
64));
prop_dictionary_set_uint32(dict, "address", 0); /* XXX >32-bit */
CTASSERT(sizeof(uintptr_t) <= sizeof(uint64_t));
prop_dictionary_set_uint64(dict, "virtual_address",
(uint64_t)(uintptr_t)da->da_fb_vaddr);
prop_dictionary_set_uint64(dict, "mode_callback",
(uint64_t)(uintptr_t)&drmfb_genfb_mode_callback);
/* XXX Whattakludge! */
#if NVGA > 0
if ((da->da_params->dp_is_vga_console != NULL) &&
(*da->da_params->dp_is_vga_console)(dev)) {
what_was_cons = CONS_VGA;
prop_dictionary_set_bool(dict, "is_console", true);
vga_cndetach();
if (da->da_params->dp_disable_vga)
(*da->da_params->dp_disable_vga)(dev);
} else
#endif
if (genfb_is_console() && genfb_is_enabled()) {
what_was_cons = CONS_GENFB;
prop_dictionary_set_bool(dict, "is_console", true);
} else {
what_was_cons = CONS_NONE;
prop_dictionary_set_bool(dict, "is_console", false);
}
sc->sc_genfb.sc_dev = sc->sc_da.da_dev;
genfb_init(&sc->sc_genfb);
genfb_ops.genfb_ioctl = drmfb_genfb_ioctl;
genfb_ops.genfb_mmap = drmfb_genfb_mmap;
genfb_ops.genfb_enable_polling = drmfb_genfb_enable_polling;
genfb_ops.genfb_disable_polling = drmfb_genfb_disable_polling;
error = genfb_attach(&sc->sc_genfb, &genfb_ops);
if (error) {
aprint_error_dev(sc->sc_da.da_dev,
"failed to attach genfb: %d\n", error);
goto fail0;
}
/* Success! */
return 0;
fail0: KASSERT(error);
/* XXX Restore console... */
switch (what_was_cons) {
case CONS_VGA:
break;
case CONS_GENFB:
break;
case CONS_NONE:
break;
default:
break;
}
return error;
}
/*
* Attach a display. We need to notice if it is the console, too.
*/
static void
genfb_attach_sbus(device_t parent, device_t self, void *args)
{
struct genfb_sbus_softc *sc = device_private(self);
struct sbus_attach_args *sa = args;
static const struct genfb_ops zero_ops;
struct genfb_ops ops = zero_ops;
prop_dictionary_t dict;
bus_space_handle_t bh;
paddr_t fbpa;
vaddr_t fbva;
int node = sa->sa_node;
int isconsole;
aprint_normal("\n");
sc->sc_gen.sc_dev = self;
/* Remember cookies for genfb_mmap_sbus() */
sc->sc_tag = sa->sa_bustag;
sc->sc_paddr = sbus_bus_addr(sa->sa_bustag, sa->sa_slot, sa->sa_offset);
/* read geometry information from the device tree */
sc->sc_gen.sc_width = prom_getpropint(sa->sa_node, "width", 1152);
sc->sc_gen.sc_height = prom_getpropint(sa->sa_node, "height", 900);
sc->sc_gen.sc_depth = prom_getpropint(sa->sa_node, "depth", 8);
sc->sc_gen.sc_stride = prom_getpropint(sa->sa_node, "linebytes",
(sc->sc_gen.sc_width * sc->sc_gen.sc_depth + 7) >> 3 );
sc->sc_gen.sc_fbsize = sc->sc_gen.sc_height * sc->sc_gen.sc_stride;
fbva = (uint32_t)prom_getpropint(sa->sa_node, "address", 0);
if (fbva == 0)
panic("this fb has no address property\n");
aprint_normal_dev(self, "%d x %d at %d bit\n",
sc->sc_gen.sc_width, sc->sc_gen.sc_height, sc->sc_gen.sc_depth);
pmap_extract(pmap_kernel(), fbva, &fbpa);
sc->sc_gen.sc_fboffset = (fbpa & 0x01ffffff) -
(sc->sc_paddr & 0x01ffffff);
aprint_normal_dev(self, "framebuffer at offset 0x%x\n",
(uint32_t)sc->sc_gen.sc_fboffset);
#if notyet
if (sc->sc_gen.sc_depth <= 8) {
/* setup some ANSIish colour map */
char boo[256];
snprintf(boo, 256, "\" pal!\" %x %x %x %x %x call",
sa->sa_node, 0, 0xa0, 0xa0, 0);
prom_interpret(boo);
}
#endif
isconsole = fb_is_console(node);
dict = device_properties(self);
prop_dictionary_set_bool(dict, "is_console", isconsole);
if (sbus_bus_map(sa->sa_bustag,
sa->sa_slot,
sa->sa_offset + sc->sc_gen.sc_fboffset,
sc->sc_gen.sc_fbsize,
BUS_SPACE_MAP_LINEAR, &bh) != 0) {
aprint_error_dev(self, "cannot map framebuffer\n");
return;
}
sc->sc_gen.sc_fbaddr = (void *)bus_space_vaddr(sa->sa_bustag, bh);
ops.genfb_ioctl = genfb_ioctl_sbus;
ops.genfb_mmap = genfb_mmap_sbus;
genfb_attach(&sc->sc_gen, &ops);
}
/*
* Called back during autoconfiguration for each device found
*/
void
device_register(device_t dev, void *aux)
{
device_t busdev = device_parent(dev);
int ofnode = 0;
/*
* We don't know the type of 'aux' - it depends on the
* bus this device attaches to. We are only interested in
* certain bus types, this only is used to find the boot
* device.
*/
if (busdev == NULL) {
/*
* Ignore mainbus0 itself, it certainly is not a boot
* device.
*/
} else if (device_is_a(busdev, "mainbus")) {
struct mainbus_attach_args *ma = aux;
ofnode = ma->ma_node;
} else if (device_is_a(busdev, "pci")) {
struct pci_attach_args *pa = aux;
ofnode = PCITAG_NODE(pa->pa_tag);
} else if (device_is_a(busdev, "sbus") || device_is_a(busdev, "dma")
|| device_is_a(busdev, "ledma")) {
struct sbus_attach_args *sa = aux;
ofnode = sa->sa_node;
} else if (device_is_a(busdev, "ebus")) {
struct ebus_attach_args *ea = aux;
ofnode = ea->ea_node;
} else if (device_is_a(busdev, "iic")) {
struct i2c_attach_args *ia = aux;
if (ia->ia_name == NULL) /* indirect config */
return;
ofnode = (int)ia->ia_cookie;
} else if (device_is_a(dev, "sd") || device_is_a(dev, "cd")) {
struct scsipibus_attach_args *sa = aux;
struct scsipi_periph *periph = sa->sa_periph;
int off = 0;
/*
* There are two "cd" attachments:
* atapibus -> atabus -> controller
* scsibus -> controller
* We want the node of the controller.
*/
if (device_is_a(busdev, "atapibus")) {
busdev = device_parent(busdev);
/*
* if the atapibus is connected to the secondary
* channel of the atabus, we need an offset of 2
* to match OF's idea of the target number.
* (i.e. on U5/U10 "cdrom" and "disk2" have the
* same target encoding, though different names)
*/
if (periph->periph_channel->chan_channel == 1)
off = 2;
}
ofnode = device_ofnode(device_parent(busdev));
dev_path_drive_match(dev, ofnode, periph->periph_target + off,
0, periph->periph_lun);
return;
} else if (device_is_a(dev, "wd")) {
struct ata_device *adev = aux;
ofnode = device_ofnode(device_parent(busdev));
dev_path_drive_match(dev, ofnode, adev->adev_channel*2+
adev->adev_drv_data->drive, 0, 0);
return;
}
if (busdev == NULL)
return;
if (ofnode != 0) {
uint8_t eaddr[ETHER_ADDR_LEN];
char tmpstr[32];
char tmpstr2[32];
int node;
uint32_t id = 0;
uint64_t nwwn = 0, pwwn = 0;
prop_dictionary_t dict;
prop_data_t blob;
prop_number_t pwwnd = NULL, nwwnd = NULL;
prop_number_t idd = NULL;
device_setofnode(dev, ofnode);
dev_path_exact_match(dev, ofnode);
if (OF_getprop(ofnode, "name", tmpstr, sizeof(tmpstr)) <= 0)
tmpstr[0] = 0;
if (OF_getprop(ofnode, "device_type", tmpstr2, sizeof(tmpstr2)) <= 0)
tmpstr2[0] = 0;
/*
* If this is a network interface, note the
* mac address.
*/
if (strcmp(tmpstr, "network") == 0
|| strcmp(tmpstr, "ethernet") == 0
|| strcmp(tmpstr2, "network") == 0
|| strcmp(tmpstr2, "ethernet") == 0
|| OF_getprop(ofnode, "mac-address", &eaddr, sizeof(eaddr))
>= ETHER_ADDR_LEN
|| OF_getprop(ofnode, "local-mac-address", &eaddr, sizeof(eaddr))
>= ETHER_ADDR_LEN) {
dict = device_properties(dev);
/*
* Is it a network interface with FCode?
*/
if (strcmp(tmpstr, "network") == 0 ||
strcmp(tmpstr2, "network") == 0) {
prop_dictionary_set_bool(dict,
"without-seeprom", true);
prom_getether(ofnode, eaddr);
} else {
if (!prom_get_node_ether(ofnode, eaddr))
goto noether;
}
blob = prop_data_create_data(eaddr, ETHER_ADDR_LEN);
prop_dictionary_set(dict, "mac-address", blob);
prop_object_release(blob);
of_to_dataprop(dict, ofnode, "shared-pins",
"shared-pins");
}
noether:
/* is this a FC node? */
if (strcmp(tmpstr, "scsi-fcp") == 0) {
dict = device_properties(dev);
if (OF_getprop(ofnode, "port-wwn", &pwwn, sizeof(pwwn))
== sizeof(pwwn)) {
pwwnd =
prop_number_create_unsigned_integer(pwwn);
prop_dictionary_set(dict, "port-wwn", pwwnd);
prop_object_release(pwwnd);
}
if (OF_getprop(ofnode, "node-wwn", &nwwn, sizeof(nwwn))
== sizeof(nwwn)) {
nwwnd =
prop_number_create_unsigned_integer(nwwn);
prop_dictionary_set(dict, "node-wwn", nwwnd);
prop_object_release(nwwnd);
}
}
/* is this an spi device? look for scsi-initiator-id */
if (strcmp(tmpstr2, "scsi") == 0 ||
strcmp(tmpstr2, "scsi-2") == 0) {
dict = device_properties(dev);
for (node = ofnode; node != 0; node = OF_parent(node)) {
if (OF_getprop(node, "scsi-initiator-id", &id,
sizeof(id)) <= 0)
continue;
idd = prop_number_create_unsigned_integer(id);
prop_dictionary_set(dict,
"scsi-initiator-id", idd);
prop_object_release(idd);
break;
}
}
}
/*
* Check for I2C busses and add data for their direct configuration.
*/
if (device_is_a(dev, "iic")) {
int busnode = device_ofnode(busdev);
if (busnode) {
prop_dictionary_t props = device_properties(busdev);
prop_object_t cfg = prop_dictionary_get(props,
"i2c-child-devices");
if (!cfg) {
int node;
const char *name;
/*
* pmu's i2c devices are under the "i2c" node,
* so find it out.
*/
name = prom_getpropstring(busnode, "name");
if (strcmp(name, "pmu") == 0) {
for (node = OF_child(busnode);
node != 0; node = OF_peer(node)) {
name = prom_getpropstring(node,
"name");
if (strcmp(name, "i2c") == 0) {
busnode = node;
break;
}
}
}
of_enter_i2c_devs(props, busnode,
sizeof(cell_t));
}
}
/*
* Add SPARCle spdmem devices (0x50 and 0x51) that the
* firmware does not know about.
*/
if (!strcmp(machine_model, "TAD,SPARCLE")) {
prop_dictionary_t props = device_properties(busdev);
prop_array_t cfg = prop_array_create();
int i;
DPRINTF(ACDB_PROBE, ("\nAdding spdmem for SPARCle "));
for (i = 0x50; i <= 0x51; i++) {
prop_dictionary_t spd =
prop_dictionary_create();
prop_dictionary_set_cstring(spd, "name",
"dimm-spd");
prop_dictionary_set_uint32(spd, "addr", i);
prop_dictionary_set_uint64(spd, "cookie", 0);
prop_array_add(cfg, spd);
prop_object_release(spd);
}
prop_dictionary_set(props, "i2c-child-devices", cfg);
prop_object_release(cfg);
}
}
/* set properties for PCI framebuffers */
if (device_is_a(busdev, "pci")) {
/* see if this is going to be console */
struct pci_attach_args *pa = aux;
prop_dictionary_t dict;
int sub;
int console = 0;
dict = device_properties(dev);
/* we only care about display devices from here on */
if (PCI_CLASS(pa->pa_class) != PCI_CLASS_DISPLAY)
return;
console = (ofnode == console_node);
if (!console) {
/*
* see if any child matches since OF attaches
* nodes for each head and /chosen/stdout
* points to the head rather than the device
* itself in this case
*/
sub = OF_child(ofnode);
while ((sub != 0) && (sub != console_node)) {
sub = OF_peer(sub);
}
if (sub == console_node) {
console = true;
}
}
copyprops(busdev, ofnode, dict, console);
if (console) {
uint64_t cmap_cb;
prop_dictionary_set_uint32(dict,
"instance_handle", console_instance);
gfb_cb.gcc_cookie =
(void *)(intptr_t)console_instance;
gfb_cb.gcc_set_mapreg = of_set_palette;
cmap_cb = (uint64_t)(uintptr_t)&gfb_cb;
prop_dictionary_set_uint64(dict,
"cmap_callback", cmap_cb);
}
#ifdef notyet
else {
int width;
/*
* the idea is to 'open' display devices with no useful
* properties, in the hope that the firmware will
* properly initialize them and we can run things like
* genfb on them
*/
if (OF_getprop(node, "width", &width, sizeof(width))
!= 4) {
instance = OF_open(name);
#endif
}
}
/*
* Called back after autoconfiguration of a device is done
*/
void
device_register_post_config(device_t dev, void *aux)
{
if (booted_device == NULL && device_is_a(dev, "sd")) {
struct scsipibus_attach_args *sa = aux;
struct scsipi_periph *periph = sa->sa_periph;
uint64_t wwn = 0;
int ofnode;
/*
* If this is a FC-AL drive it will have
* aquired its WWN device property by now,
* so we can properly match it.
*/
if (prop_dictionary_get_uint64(device_properties(dev),
"port-wwn", &wwn)) {
/*
* Different to what we do in device_register,
* we do not pass the "controller" ofnode,
* because FC-AL devices attach below a "fp" node,
* E.g.: /pci/SUNW,qlc@4/fp@0,0/disk
* and we need the parent of "disk" here.
*/
ofnode = device_ofnode(
device_parent(device_parent(dev)));
for (ofnode = OF_child(ofnode);
ofnode != 0 && booted_device == NULL;
ofnode = OF_peer(ofnode)) {
dev_path_drive_match(dev, ofnode,
periph->periph_target,
wwn, periph->periph_lun);
}
}
}
}
static void
copyprops(device_t busdev, int node, prop_dictionary_t dict, int is_console)
{
device_t cntrlr;
prop_dictionary_t psycho;
paddr_t fbpa, mem_base = 0;
uint32_t temp, fboffset;
uint32_t fbaddr = 0;
int options;
char output_device[256];
char *pos;
cntrlr = device_parent(busdev);
if (cntrlr != NULL) {
psycho = device_properties(cntrlr);
prop_dictionary_get_uint64(psycho, "mem_base", &mem_base);
}
if (is_console)
prop_dictionary_set_bool(dict, "is_console", 1);
of_to_uint32_prop(dict, node, "width", "width");
of_to_uint32_prop(dict, node, "height", "height");
of_to_uint32_prop(dict, node, "linebytes", "linebytes");
if (!of_to_uint32_prop(dict, node, "depth", "depth") &&
/* Some cards have an extra space in the property name */
!of_to_uint32_prop(dict, node, "depth ", "depth")) {
/*
* XXX we should check linebytes vs. width but those
* FBs that don't have a depth property ( /chaos/control... )
* won't have linebytes either
*/
prop_dictionary_set_uint32(dict, "depth", 8);
}
OF_getprop(node, "address", &fbaddr, sizeof(fbaddr));
if (fbaddr != 0) {
pmap_extract(pmap_kernel(), fbaddr, &fbpa);
#ifdef DEBUG
printf("membase: %lx fbpa: %lx\n", (unsigned long)mem_base,
(unsigned long)fbpa);
#endif
if (mem_base == 0) {
/* XXX this is guesswork */
fboffset = (uint32_t)(fbpa & 0xffffffff);
}
fboffset = (uint32_t)(fbpa - mem_base);
prop_dictionary_set_uint32(dict, "address", fboffset);
}
if (!of_to_dataprop(dict, node, "EDID", "EDID"))
of_to_dataprop(dict, node, "edid", "EDID");
temp = 0;
if (OF_getprop(node, "ATY,RefCLK", &temp, sizeof(temp)) != 4) {
OF_getprop(OF_parent(node), "ATY,RefCLK", &temp,
sizeof(temp));
}
if (temp != 0)
prop_dictionary_set_uint32(dict, "refclk", temp / 10);
/*
* finally, let's see if there's a video mode specified in
* output-device and pass it on so drivers like radeonfb
* can do their thing
*/
if (!is_console)
return;
options = OF_finddevice("/options");
if ((options == 0) || (options == -1))
return;
if (OF_getprop(options, "output-device", output_device, 256) == 0)
return;
/* find the mode string if there is one */
pos = strstr(output_device, ":r");
if (pos == NULL)
return;
prop_dictionary_set_cstring(dict, "videomode", pos + 2);
}
static void
of_set_palette(void *cookie, int index, int r, int g, int b)
{
int ih = (int)((intptr_t)cookie);
OF_call_method_1("color!", ih, 4, r, g, b, index);
}
void
npf_ext_param_bool(nl_ext_t *ext, const char *key, bool val)
{
prop_dictionary_t extdict = ext->nxt_dict;
prop_dictionary_set_bool(extdict, key, val);
}
/*
* npfctl_save: export the config dictionary as it was submitted,
* including the current snapshot of the connections. Additionally,
* indicate whether the ruleset is currently active.
*/
int
npfctl_save(u_long cmd, void *data)
{
struct plistref *pref = data;
prop_array_t rulelist, natlist, tables, rprocs, conlist;
prop_dictionary_t npf_dict = NULL;
int error;
rulelist = prop_array_create();
natlist = prop_array_create();
tables = prop_array_create();
rprocs = prop_array_create();
conlist = prop_array_create();
/*
* Serialise the connections and NAT policies.
*/
npf_config_enter();
error = npf_conndb_export(conlist);
if (error) {
goto out;
}
error = npf_ruleset_export(npf_config_ruleset(), rulelist);
if (error) {
goto out;
}
error = npf_ruleset_export(npf_config_natset(), natlist);
if (error) {
goto out;
}
error = npf_tableset_export(npf_config_tableset(), tables);
if (error) {
goto out;
}
error = npf_rprocset_export(npf_config_rprocs(), rprocs);
if (error) {
goto out;
}
prop_array_t alglist = npf_alg_export();
npf_dict = prop_dictionary_create();
prop_dictionary_set_uint32(npf_dict, "version", NPF_VERSION);
prop_dictionary_set_and_rel(npf_dict, "algs", alglist);
prop_dictionary_set_and_rel(npf_dict, "rules", rulelist);
prop_dictionary_set_and_rel(npf_dict, "nat", natlist);
prop_dictionary_set_and_rel(npf_dict, "tables", tables);
prop_dictionary_set_and_rel(npf_dict, "rprocs", rprocs);
prop_dictionary_set_and_rel(npf_dict, "conn-list", conlist);
prop_dictionary_set_bool(npf_dict, "active", npf_pfil_registered_p());
error = prop_dictionary_copyout_ioctl(pref, cmd, npf_dict);
out:
npf_config_exit();
if (!npf_dict) {
prop_object_release(rulelist);
prop_object_release(natlist);
prop_object_release(tables);
prop_object_release(rprocs);
prop_object_release(conlist);
} else {
prop_object_release(npf_dict);
}
return error;
}
void
gdium_device_register(device_t dev, void *aux)
{
prop_dictionary_t dict;
static int gkey_chain_pos = 0;
static device_t lastparent = NULL;
if (device_is_a(dev, "genfb") || device_is_a(dev, "voyagerfb")) {
dict = device_properties(dev);
/*
* this is a hack
* is_console needs to be checked against reality
*/
prop_dictionary_set_bool(dict, "is_console", 1);
prop_dictionary_set_uint32(dict, "width", 1024);
prop_dictionary_set_uint32(dict, "height", 600);
prop_dictionary_set_uint32(dict, "depth", 16);
prop_dictionary_set_uint32(dict, "linebytes", 2048);
if (fb_addr != 0)
prop_dictionary_set_uint32(dict, "address", fb_addr);
}
if (device_parent(dev) != lastparent && gkey_chain_pos != 0)
return;
switch (gkey_chain_pos) {
case 0: /* bonito at mainbus */
if (device_is_a(dev, "bonito"))
goto advance;
break;
case 1: /* pci at bonito */
if (device_is_a(dev, "pci"))
goto advance;
break;
case 2: /* ehci at pci dev 15 */
if (device_is_a(dev, "ehci")) {
struct pci_attach_args *paa = aux;
if (paa->pa_device == 15)
goto advance;
}
break;
case 3: /* usb at ehci */
if (device_is_a(dev, "usb"))
goto advance;
break;
case 4: /* uhub at usb */
if (device_is_a(dev, "uhub"))
goto advance;
break;
case 5: /* umass at uhub port 3 */
if (device_is_a(dev, "umass")) {
struct usb_attach_arg *uaa = aux;
if (uaa->uaa_port == 3)
goto advance;
}
break;
case 6: /* scsibus at umass */
if (device_is_a(dev, "scsibus"))
goto advance;
break;
case 7: /* sd at scsibus */
if (booted_device == NULL)
booted_device = dev;
break;
}
return;
advance:
gkey_chain_pos++;
lastparent = dev;
}