int
pmsprobe(device_t parent, cfdata_t match, void *aux)
{
struct pckbport_attach_args *pa = aux;
u_char cmd[1], resp[2];
int res;
if (pa->pa_slot != PCKBPORT_AUX_SLOT)
return 0;
/* Flush any garbage. */
pckbport_flush(pa->pa_tag, pa->pa_slot);
/* reset the device */
cmd[0] = PMS_RESET;
res = pckbport_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 2, resp, 1);
if (res) {
aprint_debug("pmsprobe: reset error %d\n", res);
return 0;
}
if (resp[0] != PMS_RSTDONE) {
printf("pmsprobe: reset response 0x%x\n", resp[0]);
return 0;
}
/* get type number (0 = mouse) */
if (resp[1] != 0) {
aprint_debug("pmsprobe: type 0x%x\n", resp[1]);
return 0;
}
return 10;
}
int
pckbd_set_xtscancode(pckbport_tag_t kbctag, pckbport_slot_t kbcslot,
struct pckbd_internal *id)
{
int xt, res = 0;
u_char cmd[2];
/*
* Some keyboard/8042 combinations do not seem to work if the keyboard
* is set to table 1; in fact, it would appear that some keyboards just
* ignore the command altogether. So by default, we use the AT scan
* codes and have the 8042 translate them. Unfortunately, this is
* known to not work on some PS/2 machines. We try desperately to deal
* with this by checking the (lack of a) translate bit in the 8042 and
* attempting to set the keyboard to XT mode. If this all fails, well,
* tough luck. If the PCKBC_CANT_TRANSLATE pckbc flag was set, we
* enable software translation.
*
* XXX It would perhaps be a better choice to just use AT scan codes
* and not bother with this.
*/
xt = pckbport_xt_translation(kbctag, kbcslot, 1);
if (xt == 1) {
/* The 8042 is translating for us; use AT codes. */
cmd[0] = KBC_SETTABLE;
cmd[1] = 2;
res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0);
if (res) {
u_char cmdb[1];
aprint_debug("pckbd: error setting scanset 2\n");
/*
* XXX at least one keyboard is reported to lock up
* if a "set table" is attempted, thus the "reset".
* XXX ignore errors, scanset 2 should be
* default anyway.
*/
cmdb[0] = KBC_RESET;
(void)pckbport_poll_cmd(kbctag, kbcslot, cmdb, 1, 1, 0, 1);
pckbport_flush(kbctag, kbcslot);
res = 0;
}
if (id != NULL)
id->t_translating = 1;
} else if (xt == -1) {
/* Software translation required */
if (id != NULL)
id->t_translating = 0;
} else {
/* Stupid 8042; set keyboard to XT codes. */
cmd[0] = KBC_SETTABLE;
cmd[1] = 1;
res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0);
if (res)
aprint_debug("pckbd: error setting scanset 1\n");
if (id != NULL)
id->t_translating = 1;
}
return res;
}
static int
pci_io_find(pci_chipset_tag_t pc, pcitag_t tag, int reg, pcireg_t type,
bus_addr_t *basep, bus_size_t *sizep, int *flagsp)
{
pcireg_t address, mask;
int s;
if (reg < PCI_MAPREG_START ||
#if 0
/*
* Can't do this check; some devices have mapping registers
* way out in left field.
*/
reg >= PCI_MAPREG_END ||
#endif
(reg & 3))
panic("pci_io_find: bad request");
/*
* Section 6.2.5.1, `Address Maps', tells us that:
*
* 1) The builtin software should have already mapped the device in a
* reasonable way.
*
* 2) A device which wants 2^n bytes of memory will hardwire the bottom
* n bits of the address to 0. As recommended, we write all 1s and see
* what we get back.
*/
s = splhigh();
address = pci_conf_read(pc, tag, reg);
pci_conf_write(pc, tag, reg, 0xffffffff);
mask = pci_conf_read(pc, tag, reg);
pci_conf_write(pc, tag, reg, address);
splx(s);
if (PCI_MAPREG_TYPE(address) != PCI_MAPREG_TYPE_IO) {
aprint_debug("pci_io_find: expected type i/o, found mem\n");
return (1);
}
if (PCI_MAPREG_IO_SIZE(mask) == 0) {
aprint_debug("pci_io_find: void region\n");
return (1);
}
if (basep != 0)
*basep = PCI_MAPREG_IO_ADDR(address);
if (sizep != 0)
*sizep = PCI_MAPREG_IO_SIZE(mask);
if (flagsp != 0)
*flagsp = 0;
return (0);
}
static int
pciaddr_do_resource_allocate(pci_chipset_tag_t pc, pcitag_t tag,
int mapreg, void *ctx, int type, bus_addr_t *addr, bus_size_t size)
{
struct pciaddr *pciaddrmap = (struct pciaddr *)ctx;
bus_addr_t start;
int error;
struct extent *ex;
if (*addr != 0) /* no need to allocate */
return 0;
ex = (type == PCI_MAPREG_TYPE_MEM ?
pciaddrmap->extent_mem : pciaddrmap->extent_port);
/* XXX Don't allocate if device is AGP device to avoid conflict. */
if (device_is_agp(pc, tag))
return 0;
start = (type == PCI_MAPREG_TYPE_MEM ?
pciaddrmap->mem_alloc_start : pciaddrmap->port_alloc_start);
if (start < ex->ex_start || start + size - 1 >= ex->ex_end) {
aprint_debug("No available resources. fixup failed\n");
return 1;
}
error = extent_alloc_subregion(ex, start, ex->ex_end, size,
size, 0,
EX_FAST|EX_NOWAIT|EX_MALLOCOK,
(u_long *)addr);
if (error) {
aprint_debug("No available resources. fixup failed\n");
return 1;
}
/* write new address to PCI device configuration header */
pci_conf_write(pc, tag, mapreg, *addr);
/* check */
aprint_debug("pci_addr_fixup: ");
pciaddr_print_devid(pc, tag);
if (pciaddr_ioaddr(pci_conf_read(pc, tag, mapreg)) != *addr) {
pci_conf_write(pc, tag, mapreg, 0); /* clear */
aprint_error("fixup failed. (new address=%#x)\n", (unsigned)*addr);
return 1;
}
aprint_debug("new address 0x%08x\n", (unsigned)*addr);
return 0;
}
/*
* Close SCI
*/
static ACPI_STATUS
sci_close(struct valz_acpi_softc *sc)
{
ACPI_STATUS rv;
uint32_t result;
rv = valz_acpi_hci_set(sc, SCI_CLOSE, 0, 0, &result);
if (ACPI_FAILURE(rv)) {
aprint_error("SCI: ACPI set error\n");
} else {
switch (result) {
case SCI_OPENCLOSE_OK:
aprint_debug("Closing SCI\n");
break;
case SCI_NOT_OPEN:
aprint_error("SCI is not opened\n");
break;
case SCI_NOT_SUPPORTED:
aprint_error("SCI is not supported\n");
break;
case SCI_NOT_PRESENT:
aprint_error("SCI is not present\n");
break;
default:
aprint_error("SCI: undefined behavior\n");
break;
}
}
return rv;
}
/*
* valz_acpi_event:
*
* Check hotkey event and do it, if event occur.
*/
static void
valz_acpi_event(void *arg)
{
struct valz_acpi_softc *sc = arg;
ACPI_STATUS rv;
uint32_t value, result;
for (;;) {
rv = valz_acpi_hci_get(sc, HCI_GET, HCI_SYSTEM_EVENT_FIFO,
&value, &result);
if (ACPI_SUCCESS(rv) && result == 0) {
switch (value) {
case FN_F9_PRESS:
valz_acpi_touchpad_toggle(sc);
break;
case FN_TAB_PRESS:
valz_acpi_lcd_backlight_toggle(sc);
break;
default:
/* Many unused buttons */
aprint_debug("Pressed: 0x%x\n", value);
break;
}
}
if (ACPI_FAILURE(rv) || result == HCI_NOT_SUPPORTED ||
result == HCI_FIFO_EMPTY)
break;
}
}
/*
* 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;
}
static bool
pckbd_resume(device_t dv, const pmf_qual_t *qual)
{
struct pckbd_softc *sc = device_private(dv);
u_char cmd[1], resp[1];
int res;
/* XXX jmcneill reset the keyboard */
pckbport_flush(sc->id->t_kbctag, sc->id->t_kbcslot);
cmd[0] = KBC_RESET;
res = pckbport_poll_cmd(sc->id->t_kbctag,
sc->id->t_kbcslot, cmd, 1, 1, resp, 1);
if (res)
aprint_debug("pckbdprobe: reset error %d\n", res);
if (resp[0] != KBR_RSTDONE)
printf("pckbdprobe: reset response 0x%x\n",
resp[0]);
pckbport_flush(sc->id->t_kbctag, sc->id->t_kbcslot);
pckbd_enable(sc, 1);
return true;
}
/*
* Destroy all table data. This function can run when there are no
* readers on table lists.
*/
int
dm_table_destroy(dm_table_head_t * head, uint8_t table_id)
{
dm_table_t *tbl;
dm_table_entry_t *table_en;
uint8_t id;
lockmgr(&head->table_mtx, LK_EXCLUSIVE);
aprint_debug("dm_Table_destroy called with %d--%d\n", table_id, head->io_cnt);
if (table_id == DM_TABLE_ACTIVE)
id = head->cur_active_table;
else
id = 1 - head->cur_active_table;
tbl = &head->tables[id];
while (!SLIST_EMPTY(tbl)) { /* List Deletion. */
table_en = SLIST_FIRST(tbl);
/*
* Remove target specific config data. After successfull
* call table_en->target_config must be set to NULL.
*/
table_en->target->destroy(table_en);
SLIST_REMOVE_HEAD(tbl, next);
kfree(table_en, M_DM);
}
lockmgr(&head->table_mtx, LK_RELEASE);
return 0;
}
int
bi_print(void *aux, const char *name)
{
struct bi_attach_args *ba = aux;
const struct bi_list *bl;
u_int16_t nr;
nr = bus_space_read_2(ba->ba_iot, ba->ba_ioh, 0);
for (bl = &bi_list[0]; bl->bl_nr; bl++)
if (bl->bl_nr == nr)
break;
if (name) {
if (bl->bl_nr == 0)
aprint_normal("unknown device 0x%x", nr);
else
aprint_normal(bl->bl_name);
aprint_normal(" at %s", name);
}
aprint_normal(" node %d", ba->ba_nodenr);
if (bl->bl_havedriver & DT_VEC)
aprint_normal(" vec %o", ba->ba_ivec & 511);
#ifdef DEBUG
if (bus_space_read_4(ba->ba_iot, ba->ba_ioh, BIREG_SADR) &&
bus_space_read_4(ba->ba_iot, ba->ba_ioh, BIREG_EADR))
aprint_debug(" [sadr %x eadr %x]",
bus_space_read_4(ba->ba_iot, ba->ba_ioh, BIREG_SADR),
bus_space_read_4(ba->ba_iot, ba->ba_ioh, BIREG_EADR));
#endif
if (bl->bl_havedriver & DT_QUIET)
aprint_normal("\n");
return bl->bl_havedriver & DT_QUIET ? QUIET :
bl->bl_havedriver & DT_HAVDRV ? UNCONF : UNSUPP;
}
/*
* Translate command sent from libdevmapper to func.
*/
static int
dm_cmd_to_fun(prop_dictionary_t dm_dict) {
int i, r;
prop_string_t command;
r = 0;
if ((command = prop_dictionary_get(dm_dict, DM_IOCTL_COMMAND)) == NULL)
return EINVAL;
for(i = 0; cmd_fn[i].cmd != NULL; i++)
if (prop_string_equals_cstring(command, cmd_fn[i].cmd))
break;
if (!cmd_fn[i].allowed &&
(r = kauth_authorize_system(kauth_cred_get(),
KAUTH_SYSTEM_DEVMAPPER, 0, NULL, NULL, NULL)) != 0)
return r;
if (cmd_fn[i].cmd == NULL)
return EINVAL;
aprint_debug("ioctl %s called\n", cmd_fn[i].cmd);
r = cmd_fn[i].fn(dm_dict);
return r;
}
static int
dmclose(dev_t dev, int flags, int mode, struct lwp *l)
{
aprint_debug("dm close routine called %" PRIu32 "\n", minor(dev));
return 0;
}
/* Call apropriate ioctl handler function. */
static int
dm_ioctl_switch(u_long cmd)
{
switch(cmd) {
case NETBSD_DM_IOCTL:
aprint_debug("dm NetBSD_DM_IOCTL called\n");
break;
default:
aprint_debug("dm unknown ioctl called\n");
return ENOTTY;
break; /* NOT REACHED */
}
return 0;
}
void
pchbattach(struct device *parent, struct device *self, void *aux)
{
struct pci_attach_args *pa = aux;
char devinfo[256];
#if NAGP > 0
struct agpbus_attach_args apa;
#endif
volatile unsigned char *python;
uint32_t v;
aprint_normal("\n");
/*
* All we do is print out a description. Eventually, we
* might want to add code that does something that's
* possibly chipset-specific.
*/
pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo, sizeof(devinfo));
aprint_normal("%s: %s (rev. 0x%02x)\n", self->dv_xname, devinfo,
PCI_REVISION(pa->pa_class));
switch (PCI_VENDOR(pa->pa_id)) {
case PCI_VENDOR_IBM:
switch (PCI_PRODUCT(pa->pa_id)) {
case PCI_PRODUCT_IBM_82660:
ibm82660_print(pa, self);
break;
case PCI_PRODUCT_IBM_PYTHON:
python = mapiodev(0xfeff6000, 0x60);
v = 0x88b78e01; /* taken from linux */
out32rb(python+0x30, v);
v = in32rb(python+0x30);
aprint_debug("Reset python reg 30 to 0x%x\n", v);
break;
}
break;
case PCI_VENDOR_MOT:
switch (PCI_PRODUCT(pa->pa_id)) {
case PCI_PRODUCT_MOT_MPC105:
mpc105_print(pa, self);
break;
case PCI_PRODUCT_MOT_MPC106:
mpc106_print(pa, self);
break;
}
break;
}
#if NAGP > 0
if (pci_get_capability(pa->pa_pc, pa->pa_tag, PCI_CAP_AGP,
NULL, NULL) != 0) {
apa.apa_pci_args = *pa;
config_found_ia(self, "agpbus", &apa, agpbusprint);
}
#endif /* NAGP */
}
/*
* 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;
}
static int
systm_aprint_debug(lua_State *L)
{
const char *s;
s = lua_tostring(L, -1);
if (s)
aprint_debug("%s", s);
return 0;
}
void
pciaddr_print_devid(pci_chipset_tag_t pc, pcitag_t tag)
{
int bus, device, function;
pcireg_t id;
id = pci_conf_read(pc, tag, PCI_ID_REG);
pci_decompose_tag(pc, tag, &bus, &device, &function);
aprint_debug("%03d:%02d:%d 0x%04x 0x%04x ", bus, device, function,
PCI_VENDOR(id), PCI_PRODUCT(id));
}
void
ssp_init(void)
{
int s;
aprint_debug("Initializing SSP: ");
/*
* We initialize ssp here carefully:
* 1. after we got some entropy
* 2. without calling a function
*/
size_t i;
long guard[__arraycount(__stack_chk_guard)];
cprng_fast(guard, sizeof(guard));
s = splhigh();
for (i = 0; i < __arraycount(guard); i++)
__stack_chk_guard[i] = guard[i];
splx(s);
for (i = 0; i < __arraycount(guard); i++)
aprint_debug("%lx ", guard[i]);
aprint_debug("\n");
}
/*
* these are both bad jokes
*/
int
pckbdprobe(device_t parent, cfdata_t cf, void *aux)
{
struct pckbport_attach_args *pa = aux;
int res;
u_char cmd[1], resp[1];
/*
* XXX There are rumours that a keyboard can be connected
* to the aux port as well. For me, this didn't work.
* For further experiments, allow it if explicitly
* wired in the config file.
*/
if ((pa->pa_slot != PCKBPORT_KBD_SLOT) &&
(cf->cf_loc[PCKBPORTCF_SLOT] == PCKBPORTCF_SLOT_DEFAULT))
return 0;
/* Flush any garbage. */
pckbport_flush(pa->pa_tag, pa->pa_slot);
/* Reset the keyboard. */
cmd[0] = KBC_RESET;
res = pckbport_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 1, resp, 1);
if (res) {
aprint_debug("pckbdprobe: reset error %d\n", res);
/*
* There is probably no keyboard connected.
* Let the probe succeed if the keyboard is used
* as console input - it can be connected later.
*/
return pckbd_is_console(pa->pa_tag, pa->pa_slot) ? 1 : 0;
}
if (resp[0] != KBR_RSTDONE) {
printf("pckbdprobe: reset response 0x%x\n", resp[0]);
return 0;
}
/*
* Some keyboards seem to leave a second ack byte after the reset.
* This is kind of stupid, but we account for them anyway by just
* flushing the buffer.
*/
pckbport_flush(pa->pa_tag, pa->pa_slot);
if (pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot, NULL))
return 0;
return 2;
}
/*
* Dynamically set the start address for rbus. This must be called
* before rbus is initialized. The start address should be determined
* by the amount of installed memory. Generally 1 GB has been found
* to be a good value, but it fails on some Thinkpads (e.g. 2645-4AU),
* for which 0.5 GB is a good value. It also fails on (at least)
* Thinkpads with 2GB of RAM, for which 2 GB is a good value.
*
* Thus, a general strategy of setting rbus_min_start to the amount of
* memory seems in order. However, the actually amount of memory is
* generally slightly more than the amount found, e.g. 1014MB vs 1024,
* or 2046 vs 2048.
*/
void
rbus_min_start_hint(psize_t ram)
{
#ifdef RBUS_MIN_START_FORCED
aprint_debug("rbus: rbus_min_start from config at %#0" PRIxPADDR "\n",
rbus_min_start);
#else
if (ram <= 192*1024*1024UL) {
/*
* <= 192 MB, so try 0.5 GB. This will work on
* Thinkpad 600E (2645-4AU), which fails at 1GB, and
* on some other older machines that may have trouble
* with addresses needing more than 20 bits.
*/
rbus_min_start = 512 * 1024 * 1024UL;
}
if (ram >= 1024*1024*1024UL) {
/*
* > 1GB, so try 2 GB.
*/
rbus_min_start = 2 * 1024 * 1024 * 1024UL;
}
/* XXX Not tested in > 2 GB case. */
if (ram > 2 * 1024*1024*1024UL) {
/*
* > 2 GB, so try 3 GB.
*/
rbus_min_start = 3 * 1024 * 1024 * 1024UL;
}
aprint_debug("rbus: rbus_min_start set to %#0" PRIxPADDR "\n",
rbus_min_start);
#endif
}
int
pckbd_enable(void *v, int on)
{
struct pckbd_softc *sc = v;
int res;
u_char cmd[1];
if (on) {
if (sc->sc_enabled) {
aprint_debug("pckbd_enable: bad enable\n");
return EBUSY;
}
pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 1);
cmd[0] = KBC_ENABLE;
res = pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
cmd, 1, 0, NULL, 0);
if (res) {
printf("pckbd_enable: command error\n");
return (res);
}
res = pckbd_set_xtscancode(sc->id->t_kbctag,
sc->id->t_kbcslot, sc->id);
if (res)
return res;
sc->sc_enabled = 1;
} else {
if (sc->id->t_isconsole)
return EBUSY;
cmd[0] = KBC_DISABLE;
res = pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
cmd, 1, 0, 1, 0);
if (res) {
printf("pckbd_disable: command error\n");
return res;
}
pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 0);
sc->sc_enabled = 0;
}
return 0;
}
/*
* Allocate target specific config data, and link them to table.
* This function is called only when, flags is not READONLY and
* therefore we can add things to pdev list. This should not a
* problem because this routine is called only from dm_table_load_ioctl.
* @argv[0] is name,
* @argv[1] is physical data offset.
*/
static int
dm_target_linear_init(dm_dev_t * dmv, void **target_config, char *params)
{
dm_target_linear_config_t *tlc;
dm_pdev_t *dmp;
char **ap, *argv[3];
if (params == NULL)
return EINVAL;
/*
* Parse a string, containing tokens delimited by white space,
* into an argument vector
*/
for (ap = argv; ap < &argv[2] &&
(*ap = strsep(¶ms, " \t")) != NULL;) {
if (**ap != '\0')
ap++;
}
aprint_debug("Linear target init function called %s--%s!!\n",
argv[0], argv[1]);
/* XXX: temp hack */
if (argv[0] == NULL)
return EINVAL;
/* Insert dmp to global pdev list */
if ((dmp = dm_pdev_insert(argv[0])) == NULL)
return ENOENT;
if ((tlc = kmalloc(sizeof(dm_target_linear_config_t), M_DMLINEAR, M_WAITOK))
== NULL)
return ENOMEM;
tlc->pdev = dmp;
tlc->offset = 0; /* default settings */
/* Check user input if it is not leave offset as 0. */
tlc->offset = atoi64(argv[1]);
*target_config = tlc;
dmv->dev_type = DM_LINEAR_DEV;
return 0;
}
void
child_return(void *arg)
{
lwp_t *l = arg;
register_t rval[2];
struct pcb *pcb = lwp_getpcb(l);
ucontext_t *ucp = &pcb->pcb_userret_ucp;
/* return value zero */
rval[0] = 0;
rval[1] = 0;
md_syscall_set_returnargs(l, ucp, 0, rval);
aprint_debug("child return! lwp %p\n", l);
userret(l);
ktrsysret(SYS_fork, 0, 0);
}
static int
dmioctl(struct dev_ioctl_args *ap)
{
cdev_t dev = ap->a_head.a_dev;
u_long cmd = ap->a_cmd;
void *data = ap->a_data;
int r, err;
prop_dictionary_t dm_dict_in;
err = r = 0;
aprint_debug("dmioctl called\n");
KKASSERT(data != NULL);
if (( r = disk_ioctl_switch(dev, cmd, data)) == ENOTTY) {
struct plistref *pref = (struct plistref *) data;
/* Check if we were called with NETBSD_DM_IOCTL ioctl
otherwise quit. */
if ((r = dm_ioctl_switch(cmd)) != 0)
return r;
if((r = prop_dictionary_copyin_ioctl(pref, cmd, &dm_dict_in)) != 0)
return r;
if ((r = dm_check_version(dm_dict_in)) != 0)
goto cleanup_exit;
/* run ioctl routine */
if ((err = dm_cmd_to_fun(dm_dict_in)) != 0)
goto cleanup_exit;
cleanup_exit:
r = prop_dictionary_copyout_ioctl(pref, cmd, dm_dict_in);
prop_object_release(dm_dict_in);
}
/*
* Return the error of the actual command if one one has
* happened. Otherwise return 'r' which indicates errors
* that occurred during helper operations.
*/
return (err != 0)?err:r;
}
int
wbsio_probe(device_t parent, cfdata_t match, void *aux)
{
struct isa_attach_args *ia = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
uint8_t reg;
/* Must supply an address */
if (ia->ia_nio < 1)
return 0;
if (ISA_DIRECT_CONFIG(ia))
return 0;
if (ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT)
return 0;
/* Match by device ID */
iot = ia->ia_iot;
if (bus_space_map(iot, ia->ia_io[0].ir_addr, WBSIO_IOSIZE, 0, &ioh))
return 0;
wbsio_conf_enable(iot, ioh);
reg = wbsio_conf_read(iot, ioh, WBSIO_ID);
aprint_debug("wbsio_probe: id 0x%02x\n", reg);
wbsio_conf_disable(iot, ioh);
bus_space_unmap(iot, ioh, WBSIO_IOSIZE);
switch (reg) {
case WBSIO_ID_W83627HF:
case WBSIO_ID_W83627THF:
case WBSIO_ID_W83627EHF:
case WBSIO_ID_W83627DHG:
case WBSIO_ID_W83637HF:
case WBSIO_ID_W83697HF:
case WBSIO_ID_NCT6776F:
ia->ia_nio = 1;
ia->ia_io[0].ir_size = WBSIO_IOSIZE;
ia->ia_niomem = 0;
ia->ia_nirq = 0;
ia->ia_ndrq = 0;
return 1;
}
return 0;
}
/*
* Status routine is called to get params string, which is target
* specific. When dm_table_status_ioctl is called with flag
* DM_STATUS_TABLE_FLAG I have to sent params string back.
*/
static char *
dm_target_linear_status(void *target_config)
{
dm_target_linear_config_t *tlc;
char *params;
tlc = target_config;
aprint_debug("Linear target status function called\n");
/* target expects use of M_DM */
params = kmalloc(DM_MAX_PARAMS_SIZE, M_DM, M_WAITOK);
aprint_normal("%s %" PRIu64, tlc->pdev->name, tlc->offset);
ksnprintf(params, DM_MAX_PARAMS_SIZE, "%s %" PRIu64,
tlc->pdev->name, tlc->offset);
return params;
}
int
gpioiic_match(device_t parent, cfdata_t cf, void *aux)
{
struct gpio_attach_args *ga = aux;
if (strcmp(ga->ga_dvname, cf->cf_name))
return 0;
if (ga->ga_offset == -1)
return 0;
/* Check that we have enough pins */
if (gpio_npins(ga->ga_mask) != GPIOIIC_NPINS) {
aprint_debug("%s: invalid pin mask 0x%02x\n", cf->cf_name,
ga->ga_mask);
return 0;
}
return 1;
}
static int
dmclose(struct dev_close_args *ap)
{
cdev_t dev = ap->a_head.a_dev;
dm_dev_t *dmv;
/* Shortcut for the control device */
if (minor(dev) == 0)
return 0;
if ((dmv = dm_dev_lookup(NULL, NULL, minor(dev))) == NULL)
return ENXIO;
dmv->is_open = 0;
dm_dev_unbusy(dmv);
aprint_debug("dm close routine called %" PRIu32 "\n",
minor(ap->a_head.a_dev));
return 0;
}
int
gpiopwm_match(device_t parent, cfdata_t cf,
void *aux)
{
struct gpio_attach_args *ga = aux;
if (strcmp(ga->ga_dvname, cf->cf_name))
return 0;
if (ga->ga_offset == -1)
return 0;
/* Check number of pins, must be 1 */
if (gpio_npins(ga->ga_mask) != GPIOPWM_NPINS) {
aprint_debug("%s: invalid pin mask 0x%02x\n", cf->cf_name,
ga->ga_mask);
return 0;
}
return 1;
}
void
ath_cardbus_setup(struct ath_cardbus_softc *csc)
{
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
int rc;
pcireg_t reg;
if ((rc = cardbus_set_powerstate(ct, csc->sc_tag, PCI_PWR_D0)) != 0)
aprint_debug("%s: cardbus_set_powerstate %d\n", __func__, rc);
/* Program the BAR. */
cardbus_conf_write(cc, cf, csc->sc_tag, ATH_PCI_MMBA, csc->sc_bar_val);
/* Enable the appropriate bits in the PCI CSR. */
reg = cardbus_conf_read(cc, cf, csc->sc_tag,
PCI_COMMAND_STATUS_REG);
reg |= PCI_COMMAND_MASTER_ENABLE | PCI_COMMAND_MEM_ENABLE;
cardbus_conf_write(cc, cf, csc->sc_tag, PCI_COMMAND_STATUS_REG, reg);
}
