/*
* Remove inactive table from device. Routines which work's with inactive tables
* doesn't need to synchronise with dmstrategy. They can synchronise themselves with mutex?.
*
*/
int
dm_table_clear_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
dmv = NULL;
name = NULL;
uuid = NULL;
flags = 0;
minor = 0;
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
aprint_debug("Clearing inactive table from device: %s--%s\n",
name, uuid);
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
/* Select unused table */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
atomic_clear_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
dm_dev_unbusy(dmv);
return 0;
}
/*
* Set only flag to suggest that device is suspended. This call is
* not supported in NetBSD.
*
*/
int
dm_dev_suspend_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
name = NULL;
uuid = NULL;
flags = 0;
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
atomic_set_int(&dmv->flags, DM_SUSPEND_FLAG);
dm_dbg_print_flags(dmv->flags);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
dm_dev_unbusy(dmv);
/* Add flags to dictionary flag after dmv -> dict copy */
DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
return 0;
}
/*
* Get list of physical devices for active table.
* Get dev_t from pdev vnode and insert it into cmd_array.
*
* XXX. This function is called from lvm2tools to get information
* about physical devices, too e.g. during vgcreate.
*/
int
dm_table_deps_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
dm_table_t *tbl;
dm_table_entry_t *table_en;
prop_array_t cmd_array;
const char *name, *uuid;
uint32_t flags, minor;
int table_type;
name = NULL;
uuid = NULL;
dmv = NULL;
flags = 0;
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
/* create array for dev_t's */
cmd_array = prop_array_create();
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
aprint_debug("Getting table deps for device: %s\n", dmv->name);
/*
* if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
* INACTIVE TABLE
*/
if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
table_type = DM_TABLE_INACTIVE;
else
table_type = DM_TABLE_ACTIVE;
tbl = dm_table_get_entry(&dmv->table_head, table_type);
SLIST_FOREACH(table_en, tbl, next)
table_en->target->deps(table_en, cmd_array);
dm_table_release(&dmv->table_head, table_type);
dm_dev_unbusy(dmv);
prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
prop_object_release(cmd_array);
return 0;
}
/*
* Rename selected devices old name is in struct dm_ioctl.
* newname is taken from dictionary
*
* <key>cmd_data</key>
* <array>
* <string>...</string>
* </array>
*/
int
dm_dev_rename_ioctl(prop_dictionary_t dm_dict)
{
#if 0
prop_array_t cmd_array;
dm_dev_t *dmv;
const char *name, *uuid, *n_name;
uint32_t flags, minor;
name = NULL;
uuid = NULL;
minor = 0;
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
dm_dbg_print_flags(flags);
cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
if (strlen(n_name) + 1 > DM_NAME_LEN)
return EINVAL;
if ((dmv = dm_dev_rem(NULL, name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
/* change device name */
/*
* XXX How to deal with this change, name only used in
* dm_dev_routines, should I add dm_dev_change_name which will run
* under the dm_dev_list mutex ?
*/
strlcpy(dmv->name, n_name, DM_NAME_LEN);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
dm_dev_insert(dmv);
#endif
/*
* XXX: the rename is not yet implemented. The main complication
* here is devfs. We'd probably need a new function, rename_dev()
* that would trigger a node rename in devfs.
*/
kprintf("dm_dev_rename_ioctl called, but not implemented!\n");
return 0;
}
/*
* Return actual state of device to libdevmapper.
*/
int
dm_dev_status_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, j, minor;
name = NULL;
uuid = NULL;
flags = 0;
j = 0;
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
dm_dbg_print_flags(dmv->flags);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
if (dmv->flags & DM_SUSPEND_FLAG)
DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
/*
* Add status flags for tables I have to check both active and
* inactive tables.
*/
if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))) {
DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
} else
DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j);
if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
else
DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
dm_dev_unbusy(dmv);
return 0;
}
/*
* Rename selected devices old name is in struct dm_ioctl.
* newname is taken from dictionary
*
* <key>cmd_data</key>
* <array>
* <string>...</string>
* </array>
*/
int
dm_dev_rename_ioctl(prop_dictionary_t dm_dict)
{
prop_array_t cmd_array;
dm_dev_t *dmv;
const char *name, *uuid, *n_name;
uint32_t flags, minor;
name = NULL;
uuid = NULL;
minor = 0;
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
dm_dbg_print_flags(flags);
cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
if (strlen(n_name) + 1 > DM_NAME_LEN)
return EINVAL;
if ((dmv = dm_dev_rem(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
/* change device name */
/*
* XXX How to deal with this change, name only used in
* dm_dev_routines, should I add dm_dev_change_name which will run
* under the dm_dev_list mutex ?
*/
strlcpy(dmv->name, n_name, DM_NAME_LEN);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
dm_dev_insert(dmv);
return 0;
}
static nl_rule_t *
_npf_rule_iterate1(nl_config_t *ncf, prop_array_t rlist, unsigned *level)
{
prop_dictionary_t rldict;
uint32_t skipto = 0;
if (!ncf->ncf_rule_iter) {
/* Initialise the iterator. */
ncf->ncf_rule_iter = prop_array_iterator(rlist);
ncf->ncf_nlevel = 0;
ncf->ncf_reduce[0] = 0;
ncf->ncf_counter = 0;
}
rldict = prop_object_iterator_next(ncf->ncf_rule_iter);
if ((ncf->ncf_cur_rule.nrl_dict = rldict) == NULL) {
prop_object_iterator_release(ncf->ncf_rule_iter);
ncf->ncf_rule_iter = NULL;
return NULL;
}
*level = ncf->ncf_nlevel;
prop_dictionary_get_uint32(rldict, "skip-to", &skipto);
if (skipto) {
ncf->ncf_nlevel++;
ncf->ncf_reduce[ncf->ncf_nlevel] = skipto;
}
if (ncf->ncf_reduce[ncf->ncf_nlevel] == ++ncf->ncf_counter) {
assert(ncf->ncf_nlevel > 0);
ncf->ncf_nlevel--;
}
return &ncf->ncf_cur_rule;
}
/*
* Get the sector size from an _open_ device.
*/
static int _get_block_size(struct device *dev, unsigned int *size)
{
const char *name = dev_name(dev);
#ifdef __NetBSD__
struct disklabel lab;
prop_dictionary_t disk_dict, geom_dict;
uint32_t secsize;
#endif
if ((dev->block_size == -1)) {
#ifdef __NetBSD__
if (prop_dictionary_recv_ioctl(dev_fd(dev), DIOCGDISKINFO, &disk_dict)) {
if (ioctl(dev_fd(dev), DIOCGDINFO, &lab) < 0) {
dev->block_size = DEV_BSIZE;
} else
dev->block_size = lab.d_secsize;
} else {
geom_dict = prop_dictionary_get(disk_dict, "geometry");
prop_dictionary_get_uint32(geom_dict, "sector-size", &secsize);
dev->block_size = secsize;
}
#else
if (ioctl(dev_fd(dev), BLKBSZGET, &dev->block_size) < 0) {
log_sys_error("ioctl BLKBSZGET", name);
return 0;
}
#endif
log_debug("%s: block size is %u bytes", name, dev->block_size);
}
*size = (unsigned int) dev->block_size;
return 1;
}
static void
exynos_wdt_attach(device_t parent, device_t self, void *aux)
{
struct exynos_wdt_softc * const sc = device_private(self);
struct exyo_attach_args * const exyo = aux;
prop_dictionary_t dict = device_properties(self);
sc->sc_dev = self;
sc->sc_bst = exyo->exyo_core_bst;
if (bus_space_subregion(sc->sc_bst, exyo->exyo_core_bsh,
exyo->exyo_loc.loc_offset, exyo->exyo_loc.loc_size, &sc->sc_wdog_bsh)) {
aprint_error(": failed to map registers\n");
return;
}
/*
* This runs at the Exynos Pclk.
*/
prop_dictionary_get_uint32(dict, "frequency", &sc->sc_freq);
sc->sc_wdog_wtcon = exynos_wdt_wdog_read(sc, EXYNOS_WDT_WTCON);
sc->sc_wdog_armed = (sc->sc_wdog_wtcon & WTCON_ENABLE)
&& (sc->sc_wdog_wtcon & WTCON_RESET_ENABLE);
if (sc->sc_wdog_armed) {
sc->sc_wdog_prescaler =
__SHIFTOUT(sc->sc_wdog_wtcon, WTCON_PRESCALER) + 1;
sc->sc_wdog_clock_select =
__SHIFTOUT(sc->sc_wdog_wtcon, WTCON_CLOCK_SELECT);
sc->sc_freq /= sc->sc_wdog_prescaler;
sc->sc_freq >>= 4 + sc->sc_wdog_clock_select;
sc->sc_wdog_wtdat = exynos_wdt_wdog_read(sc, EXYNOS_WDT_WTDAT);
sc->sc_wdog_period = (sc->sc_wdog_wtdat + 1) / sc->sc_freq;
} else {
/*
* Simulate Linux behaviour better and switch tables here and not in
* dm_table_load_ioctl.
*/
int
dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
name = NULL;
uuid = NULL;
flags = 0;
/*
* char *xml; xml = prop_dictionary_externalize(dm_dict);
* printf("%s\n",xml);
*/
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
/* Remove device from global device list */
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
atomic_clear_int(&dmv->flags, (DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG));
atomic_set_int(&dmv->flags, DM_ACTIVE_PRESENT_FLAG);
dm_table_switch_tables(&dmv->table_head);
DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
dmsetdiskinfo(dmv->diskp, &dmv->table_head);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
dm_dev_unbusy(dmv);
/* Destroy inactive table after resume. */
dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
return 0;
}
u_int
npf_nat_getflags(nl_nat_t *nt)
{
prop_dictionary_t rldict = nt->nrl_dict;
unsigned flags = 0;
prop_dictionary_get_uint32(rldict, "flags", &flags);
return flags;
}
uint32_t
npf_rule_getattr(nl_rule_t *rl)
{
prop_dictionary_t rldict = rl->nrl_dict;
uint32_t attr = 0;
prop_dictionary_get_uint32(rldict, "attributes", &attr);
return attr;
}
unsigned
npf_table_getid(nl_table_t *tl)
{
prop_dictionary_t tldict = tl->ntl_dict;
unsigned id = (unsigned)-1;
prop_dictionary_get_uint32(tldict, "id", &id);
return id;
}
static int
npf_log_ctor(npf_rproc_t *rp, prop_dictionary_t params)
{
npf_ext_log_t *meta;
meta = kmem_zalloc(sizeof(npf_ext_log_t), KM_SLEEP);
prop_dictionary_get_uint32(params, "log-interface", &meta->if_idx);
npf_rproc_assign(rp, meta);
return 0;
}
static void
igphyattach(device_t parent, device_t self, void *aux)
{
struct mii_softc *sc = device_private(self);
struct mii_attach_args *ma = aux;
struct mii_data *mii = ma->mii_data;
const struct mii_phydesc *mpd;
struct igphy_softc *igsc = (struct igphy_softc *) sc;
prop_dictionary_t dict;
mpd = mii_phy_match(ma, igphys);
aprint_naive(": Media interface\n");
aprint_normal(": %s, rev. %d\n", mpd->mpd_name, MII_REV(ma->mii_id2));
dict = device_properties(parent);
if (!prop_dictionary_get_uint32(dict, "mactype", &igsc->sc_mactype))
aprint_error("WARNING! Failed to get mactype\n");
if (!prop_dictionary_get_uint32(dict, "macflags", &igsc->sc_macflags))
aprint_error("WARNING! Failed to get macflags\n");
sc->mii_dev = self;
sc->mii_inst = mii->mii_instance;
sc->mii_phy = ma->mii_phyno;
sc->mii_funcs = &igphy_funcs;
sc->mii_pdata = mii;
sc->mii_flags = ma->mii_flags;
sc->mii_anegticks = MII_ANEGTICKS_GIGE;
PHY_RESET(sc);
sc->mii_capabilities =
PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
if (sc->mii_capabilities & BMSR_EXTSTAT)
sc->mii_extcapabilities = PHY_READ(sc, MII_EXTSR);
aprint_normal_dev(self, "");
if ((sc->mii_capabilities & BMSR_MEDIAMASK) == 0 &&
(sc->mii_extcapabilities & EXTSR_MEDIAMASK) == 0)
aprint_error("no media present");
else
mii_phy_add_media(sc);
aprint_normal("\n");
}
static void
bcm_dmac_attach(device_t parent, device_t self, void *aux)
{
struct bcm_dmac_softc *sc = device_private(self);
const prop_dictionary_t cfg = device_properties(self);
struct bcm_dmac_channel *ch;
struct amba_attach_args *aaa = aux;
uint32_t val;
int index;
sc->sc_dev = self;
sc->sc_iot = aaa->aaa_iot;
if (bus_space_map(aaa->aaa_iot, aaa->aaa_addr, aaa->aaa_size, 0,
&sc->sc_ioh)) {
aprint_error(": unable to map device\n");
return;
}
prop_dictionary_get_uint32(cfg, "chanmask", &sc->sc_channelmask);
sc->sc_channelmask &= BCM_DMAC_CHANNELMASK;
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SCHED);
sc->sc_nchannels = 31 - __builtin_clz(sc->sc_channelmask);
sc->sc_channels = kmem_alloc(
sizeof(*sc->sc_channels) * sc->sc_nchannels, KM_SLEEP);
if (sc->sc_channels == NULL) {
aprint_error(": couldn't allocate channels\n");
return;
}
aprint_normal(":");
for (index = 0; index < sc->sc_nchannels; index++) {
ch = &sc->sc_channels[index];
ch->ch_sc = sc;
ch->ch_index = index;
ch->ch_callback = NULL;
ch->ch_callbackarg = NULL;
ch->ch_ih = NULL;
if ((__BIT(index) & sc->sc_channelmask) == 0)
continue;
aprint_normal(" DMA%d", index);
ch->ch_debug = DMAC_READ(sc, DMAC_DEBUG(index));
val = DMAC_READ(sc, DMAC_CS(index));
val |= DMAC_CS_RESET;
DMAC_WRITE(sc, DMAC_CS(index), val);
}
aprint_normal("\n");
aprint_naive("\n");
}
/*
* npf_normalise_ctor: a constructor for the normalisation rule procedure
* with the given parameters.
*/
static int
npf_normalise_ctor(npf_rproc_t *rp, prop_dictionary_t params)
{
npf_normalise_t *np;
/* Create a structure for normalisation parameters. */
np = kmem_zalloc(sizeof(npf_normalise_t), KM_SLEEP);
/* IP ID randomisation and IP_DF flag cleansing. */
prop_dictionary_get_bool(params, "random-id", &np->n_random_id);
prop_dictionary_get_bool(params, "no-df", &np->n_no_df);
/* Minimum IP TTL and maximum TCP MSS. */
prop_dictionary_get_uint32(params, "min-ttl", &np->n_minttl);
prop_dictionary_get_uint32(params, "max-mss", &np->n_maxmss);
/* Assign the parameters for this rule procedure. */
npf_rproc_assign(rp, np);
return 0;
}
static void
bcmpwm_attach(device_t parent, device_t self, void *aux)
{
struct bcm2835pwm_softc *sc = device_private(self);
struct amba_attach_args *aaa = aux;
const prop_dictionary_t cfg = device_properties(self);
aprint_naive("\n");
aprint_normal(": PWM\n");
sc->sc_dev = self;
sc->sc_iot = aaa->aaa_iot;
sc->sc_iob = aaa->aaa_addr;
if (bus_space_map(aaa->aaa_iot, aaa->aaa_addr, BCM2835_PWM_SIZE, 0,
&sc->sc_ioh)) {
aprint_error_dev(sc->sc_dev, "unable to map device\n");
goto fail0;
}
prop_dictionary_get_uint32(cfg, "pwmclockrate", &sc->sc_clockrate);
sc->sc_channels[0].sc = sc;
sc->sc_channels[0].ctlmask = PWM_CTL_MSEN1 | PWM_CTL_USEF1 |
PWM_CTL_POLA1 | PWM_CTL_SBIT1 |
PWM_CTL_RPTL1 | PWM_CTL_MODE1 |
PWM_CTL_PWEN1;
sc->sc_channels[0].stamask = PWM_STA_STA1;
sc->sc_channels[0].gapomask = PWM_STA_GAPO1;
sc->sc_channels[0].rng = PWM_RNG1;
sc->sc_channels[0].dat = PWM_DAT1;
sc->sc_channels[1].sc = sc;
sc->sc_channels[1].ctlmask = PWM_CTL_MSEN2 | PWM_CTL_USEF2 |
PWM_CTL_POLA2 | PWM_CTL_SBIT2 |
PWM_CTL_RPTL2 | PWM_CTL_MODE2 |
PWM_CTL_PWEN2;
sc->sc_channels[1].stamask = PWM_STA_STA2;
sc->sc_channels[1].gapomask = PWM_STA_GAPO2;
sc->sc_channels[1].rng = PWM_RNG2;
sc->sc_channels[1].dat = PWM_DAT2;
/* The PWM hardware can be used by vcaudio if the
* analog output is selected
*/
sc->sc_channels[0].inuse = false;
sc->sc_channels[1].inuse = false;
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
/* Success! */
fail0: return;
}
uint32_t
testcase_get_flags(prop_dictionary_t testcase)
{
uint32_t flags;
int r;
r = prop_dictionary_get_uint32(prop_dictionary_get(testcase, "opts"),
"flags", &flags);
if (r == 0)
err(1, "prop_dictionary operation failed");
return flags;
}
uid_t
testcase_get_runas_uid(prop_dictionary_t testcase)
{
uint32_t uid = 0;
int r;
r = prop_dictionary_get_uint32(
prop_dictionary_get(testcase, "opts"), "runas_uid", &uid);
if (r == 0)
err(1, "prop_dictionary operation failed");
return (uid_t)uid;
}
/*
* Try to remove all devices
*/
int
dm_dev_remove_all_ioctl(prop_dictionary_t dm_dict)
{
uint32_t flags = 0;
/* Get needed values from dictionary. */
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
dm_dbg_print_flags(flags);
/* Gently remove all devices, if possible */
return dm_dev_remove_all(1);
}
static int
hdaudioctl_list(int fd)
{
prop_dictionary_t request, response;
prop_dictionary_t dict;
prop_object_iterator_t iter;
prop_object_t obj;
prop_array_t array;
uint16_t nid, codecid;
uint16_t vendor, product;
uint32_t subsystem;
const char *device = NULL;
int error;
request = prop_dictionary_create();
if (request == NULL) {
fprintf(stderr, "out of memory\n");
return ENOMEM;
}
error = prop_dictionary_sendrecv_ioctl(request, fd,
HDAUDIO_FGRP_INFO, &response);
if (error != 0) {
perror("HDAUDIO_FGRP_INFO failed");
return error;
}
array = prop_dictionary_get(response, "function-group-info");
iter = prop_array_iterator(array);
prop_object_iterator_reset(iter);
while ((obj = prop_object_iterator_next(iter)) != NULL) {
dict = (prop_dictionary_t)obj;
prop_dictionary_get_uint16(dict, "codecid", &codecid);
prop_dictionary_get_uint16(dict, "nid", &nid);
prop_dictionary_get_uint16(dict, "vendor-id", &vendor);
prop_dictionary_get_uint16(dict, "product-id", &product);
prop_dictionary_get_uint32(dict, "subsystem-id", &subsystem);
prop_dictionary_get_cstring_nocopy(dict, "device", &device);
printf("codecid 0x%02X nid 0x%02X vendor 0x%04X "
"product 0x%04X subsystem 0x%08X device %s\n",
codecid, nid, vendor, product, subsystem,
device ? device : "<none>");
}
prop_object_release(array);
prop_object_release(response);
prop_object_release(request);
return 0;
}
/*
* Remove device from global list I have to remove active
* and inactive tables first.
*/
int
dm_dev_remove_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor;
device_t devt;
flags = 0;
name = NULL;
uuid = NULL;
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
dm_dbg_print_flags(flags);
/*
* This seems as hack to me, probably use routine dm_dev_get_devt to
* atomicaly get devt from device.
*/
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
devt = dmv->devt;
dm_dev_unbusy(dmv);
/*
* This will call dm_detach routine which will actually removes
* device.
*/
return config_detach(devt, DETACH_QUIET);
}
void
_npf_config_error(nl_config_t *ncf, nl_error_t *ne)
{
memset(ne, 0, sizeof(*ne));
prop_dictionary_get_int32(ncf->ncf_err, "id", &ne->ne_id);
prop_dictionary_get_cstring(ncf->ncf_err,
"source-file", &ne->ne_source_file);
prop_dictionary_get_uint32(ncf->ncf_err,
"source-line", &ne->ne_source_line);
prop_dictionary_get_int32(ncf->ncf_err,
"code-error", &ne->ne_ncode_error);
prop_dictionary_get_int32(ncf->ncf_err,
"code-errat", &ne->ne_ncode_errat);
}
/*
* Remove device
*/
int
dm_dev_remove_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
uint32_t flags, minor, is_open;
flags = 0;
name = NULL;
uuid = NULL;
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
dm_dbg_print_flags(flags);
if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
return ENOENT;
}
is_open = dmv->is_open;
dm_dev_unbusy(dmv);
if (is_open)
return EBUSY;
/*
* This will call dm_detach routine which will actually remove
* device.
*/
return dm_dev_remove(dmv);
}
/*
* Get list of all available targets from global
* target list and sent them back to libdevmapper.
*/
int
dm_list_versions_ioctl(prop_dictionary_t dm_dict)
{
prop_array_t target_list;
uint32_t flags;
flags = 0;
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
dm_dbg_print_flags(flags);
target_list = dm_target_prop_list();
prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list);
prop_object_release(target_list);
return 0;
}
static void
dwctwo_plb_attach(device_t parent, device_t self, void *aux)
{
struct dwc2_softc *sc = device_private(self);
struct plb_attach_args *paa = aux;
prop_dictionary_t dict = device_properties(self);
uint32_t srst0;
sc->sc_dev = self;
/* get core parameters */
if (!prop_dictionary_get_uint32(dict, "params",
(uint32_t *)&sc->sc_params)) {
aprint_error("struct dwc2_core_params not found\n");
return;
}
dwctwo_tag.pbs_base = paa->plb_addr;
dwctwo_tag.pbs_limit += paa->plb_addr;
if (bus_space_init(&dwctwo_tag, "dwctwotag", ex_storage,
sizeof(ex_storage)))
panic("dwctwo_attach: Failed to initialise opb_tag");
sc->sc_iot = &dwctwo_tag;
bus_space_map(sc->sc_iot, paa->plb_addr, DWCTWO_SIZE, 0, &sc->sc_ioh);
sc->sc_bus.dmatag = paa->plb_dmat;
intr_establish(paa->plb_irq, IST_LEVEL, IPL_SCHED, dwc2_intr, sc);
/* Enable the USB interface. */
mtsdr(DCR_SDR0_PFC1, mfsdr(DCR_SDR0_PFC1) | SDR0_PFC1_USBEN);
srst0 = mfsdr(DCR_SDR0_SRST0);
mtsdr(DCR_SDR0_SRST0, srst0 | SDR0_SRST0_UPRST | SDR0_SRST0_AHB);
delay(200 * 1000); /* XXXX */
mtsdr(DCR_SDR0_SRST0, srst0);
config_defer(self, dwctwo_plb_deferred);
}
/*
* Create in-kernel entry for device. Device attributes such as name, uuid are
* taken from proplib dictionary.
*
*/
int
dm_dev_create_ioctl(prop_dictionary_t dm_dict)
{
dm_dev_t *dmv;
const char *name, *uuid;
int r, flags;
r = 0;
flags = 0;
name = NULL;
uuid = NULL;
/* Get needed values from dictionary. */
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
dm_dbg_print_flags(flags);
/* Lookup name and uuid if device already exist quit. */
if ((dmv = dm_dev_lookup(name, uuid, -1)) != NULL) {
DM_ADD_FLAG(flags, DM_EXISTS_FLAG); /* Device already exists */
dm_dev_unbusy(dmv);
return EEXIST;
}
r = dm_dev_create(&dmv, name, uuid, flags);
if (r == 0) {
prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
}
return r;
}
/*
* npfctl_rule: add or remove dynamic rules in the specified ruleset.
*/
int
npfctl_rule(u_long cmd, void *data)
{
struct plistref *pref = data;
prop_dictionary_t npf_rule, retdict = NULL;
npf_ruleset_t *rlset;
npf_rule_t *rl = NULL;
const char *ruleset_name;
uint32_t rcmd = 0;
int error;
error = prop_dictionary_copyin_ioctl(pref, cmd, &npf_rule);
if (error) {
return error;
}
prop_dictionary_get_uint32(npf_rule, "command", &rcmd);
if (!prop_dictionary_get_cstring_nocopy(npf_rule,
"ruleset-name", &ruleset_name)) {
error = EINVAL;
goto out;
}
if (rcmd == NPF_CMD_RULE_ADD) {
retdict = prop_dictionary_create();
if (npf_mk_singlerule(npf_rule, NULL, &rl, retdict) != 0) {
error = EINVAL;
goto out;
}
}
npf_config_enter();
rlset = npf_config_ruleset();
switch (rcmd) {
case NPF_CMD_RULE_ADD: {
if ((error = npf_ruleset_add(rlset, ruleset_name, rl)) == 0) {
/* Success. */
uint64_t id = npf_rule_getid(rl);
prop_dictionary_set_uint64(retdict, "id", id);
rl = NULL;
}
break;
}
case NPF_CMD_RULE_REMOVE: {
uint64_t id;
if (!prop_dictionary_get_uint64(npf_rule, "id", &id)) {
error = EINVAL;
break;
}
error = npf_ruleset_remove(rlset, ruleset_name, id);
break;
}
case NPF_CMD_RULE_REMKEY: {
prop_object_t obj = prop_dictionary_get(npf_rule, "key");
const void *key = prop_data_data_nocopy(obj);
size_t len = prop_data_size(obj);
if (len == 0 || len > NPF_RULE_MAXKEYLEN) {
error = EINVAL;
break;
}
error = npf_ruleset_remkey(rlset, ruleset_name, key, len);
break;
}
case NPF_CMD_RULE_LIST: {
retdict = npf_ruleset_list(rlset, ruleset_name);
if (!retdict) {
error = ESRCH;
}
break;
}
case NPF_CMD_RULE_FLUSH: {
error = npf_ruleset_flush(rlset, ruleset_name);
break;
}
default:
error = EINVAL;
break;
}
/* Destroy any removed rules. */
if (!error && rcmd != NPF_CMD_RULE_ADD && rcmd != NPF_CMD_RULE_LIST) {
npf_config_sync();
npf_ruleset_gc(rlset);
}
npf_config_exit();
if (rl) {
KASSERT(error);
npf_rule_free(rl);
}
out:
if (retdict) {
prop_object_release(npf_rule);
prop_dictionary_copyout_ioctl(pref, cmd, retdict);
prop_object_release(retdict);
}
return error;
}
/*
* npfctl_load: store passed data i.e. update settings, create passed
* tables, rules and atomically activate all them.
*/
int
npfctl_load(u_long cmd, void *data)
{
struct plistref *pref = data;
prop_dictionary_t npf_dict, errdict;
prop_array_t alglist, natlist, tables, rprocs, rules, conlist;
npf_tableset_t *tblset = NULL;
npf_rprocset_t *rpset = NULL;
npf_ruleset_t *rlset = NULL;
npf_ruleset_t *nset = NULL;
npf_conndb_t *conndb = NULL;
uint32_t ver = 0;
size_t nitems;
bool flush;
int error;
/* Retrieve the dictionary. */
#ifndef _NPF_TESTING
error = prop_dictionary_copyin_ioctl(pref, cmd, &npf_dict);
if (error)
return error;
#else
npf_dict = (prop_dictionary_t)pref;
#endif
/* Dictionary for error reporting and version check. */
errdict = prop_dictionary_create();
prop_dictionary_get_uint32(npf_dict, "version", &ver);
if (ver != NPF_VERSION) {
error = EPROGMISMATCH;
goto fail;
}
/* ALGs. */
alglist = prop_dictionary_get(npf_dict, "algs");
error = npf_mk_algs(alglist, errdict);
if (error) {
goto fail;
}
/* NAT policies. */
natlist = prop_dictionary_get(npf_dict, "nat");
if ((nitems = prop_array_count(natlist)) > NPF_MAX_RULES) {
error = E2BIG;
goto fail;
}
nset = npf_ruleset_create(nitems);
error = npf_mk_natlist(nset, natlist, errdict);
if (error) {
goto fail;
}
/* Tables. */
tables = prop_dictionary_get(npf_dict, "tables");
if ((nitems = prop_array_count(tables)) > NPF_MAX_TABLES) {
error = E2BIG;
goto fail;
}
tblset = npf_tableset_create(nitems);
error = npf_mk_tables(tblset, tables, errdict);
if (error) {
goto fail;
}
/* Rule procedures. */
rprocs = prop_dictionary_get(npf_dict, "rprocs");
if ((nitems = prop_array_count(rprocs)) > NPF_MAX_RPROCS) {
error = E2BIG;
goto fail;
}
rpset = npf_rprocset_create();
error = npf_mk_rprocs(rpset, rprocs, errdict);
if (error) {
goto fail;
}
/* Rules. */
rules = prop_dictionary_get(npf_dict, "rules");
if ((nitems = prop_array_count(rules)) > NPF_MAX_RULES) {
error = E2BIG;
goto fail;
}
rlset = npf_ruleset_create(nitems);
error = npf_mk_rules(rlset, rules, rpset, errdict);
if (error) {
goto fail;
}
/* Connections (if loading any). */
if ((conlist = prop_dictionary_get(npf_dict, "conn-list")) != NULL) {
error = npf_mk_connlist(conlist, nset, &conndb, errdict);
if (error) {
goto fail;
}
}
flush = false;
prop_dictionary_get_bool(npf_dict, "flush", &flush);
/*
* Finally - perform the load.
*/
npf_config_load(rlset, tblset, nset, rpset, conndb, flush);
/* Done. Since data is consumed now, we shall not destroy it. */
tblset = NULL;
rpset = NULL;
rlset = NULL;
nset = NULL;
fail:
/*
* Note: destroy rulesets first, to drop references to the tableset.
*/
KASSERT(error == 0 || (nset || rpset || rlset || tblset));
if (nset) {
npf_ruleset_destroy(nset);
}
if (rlset) {
npf_ruleset_destroy(rlset);
}
if (rpset) {
npf_rprocset_destroy(rpset);
}
if (tblset) {
npf_tableset_destroy(tblset);
}
prop_object_release(npf_dict);
/* Error report. */
#ifndef _NPF_TESTING
prop_dictionary_set_int32(errdict, "errno", error);
prop_dictionary_copyout_ioctl(pref, cmd, errdict);
prop_object_release(errdict);
error = 0;
#endif
return error;
}
