/*
* console routines
*/
void
zskbd_cnattach(int zsunit, int zschan)
{
wskbd_cnattach(&zskbd_wskbd_consops, zs_get_chan_addr(zsunit, zschan),
&sgikbd_wskbd_keymapdata);
zskbd_is_console = 1;
}
void
kbd_enable(struct device *dev)
{
struct kbd_softc *k = device_private(dev);
struct wskbddev_attach_args a;
if (k->k_isconsole)
wskbd_cnattach(&sunkbd_wskbd_consops, k,
&sunkbd_wskbd_keymapdata);
a.console = k->k_isconsole;
a.keymap = &sunkbd_wskbd_keymapdata;
a.accessops = &sunkbd_wskbd_accessops;
a.accesscookie = k;
/* XXX why? */
k->k_wsenabled = 0;
/* Attach the wskbd */
k->k_wskbd = config_found(k->k_dev, &a, wskbddevprint);
callout_init(&k->k_wsbell, 0);
wssunkbd_enable(k,1);
wssunkbd_set_leds(k, WSKBD_LED_SCROLL | WSKBD_LED_NUM | WSKBD_LED_CAPS);
delay(100000);
wssunkbd_set_leds(k, 0);
}
int
pckbd_cnattach(pckbport_tag_t kbctag, int kbcslot)
{
int res;
u_char cmd[1];
res = pckbd_init(&pckbd_consdata, kbctag, kbcslot, 1);
#if 0 /* we allow the console to be attached if no keyboard is present */
if (res)
return res;
#endif
/* Just to be sure. */
cmd[0] = KBC_ENABLE;
res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 1, 0, 0, 0);
#if 0
if (res)
return res;
#endif
wskbd_cnattach(&pckbd_consops, &pckbd_consdata, &pckbd_keymapdata);
return 0;
}
void
dnkbd_attach_subdevices(struct dnkbd_softc *sc)
{
struct wskbddev_attach_args ka;
#if NWSMOUSE > 0
struct wsmousedev_attach_args ma;
#endif
#if NHILKBD > 0
extern int hil_is_console;
#endif
extern struct consdev wsdisplay_cons;
/*
* If both hilkbd and dnkbd are configured, prefer the Domain
* keyboard as console (if we are here, we know the keyboard is
* plugged), unless the console keyboard has been claimed already
* (i.e. late hotplug with hil keyboard plugged first).
*/
if (cn_tab == &wsdisplay_cons) {
#if NHILKBD > 0
if (hil_is_console == -1) {
ka.console = 1;
hil_is_console = 0;
} else
ka.console = 0;
#else
ka.console = 1;
#endif
} else
ka.console = 0;
ka.keymap = &dnkbd_keymapdata;
ka.accessops = &dnkbd_accessops;
ka.accesscookie = sc;
#ifndef DKKBD_LAYOUT
dnkbd_keymapdata.layout = sc->sc_layout;
#endif
if (ka.console) {
sc->sc_flags = SF_PLUGGED | SF_CONSOLE | SF_ENABLED;
wskbd_cnattach(&dnkbd_consops, sc, &dnkbd_keymapdata);
} else {
sc->sc_flags = SF_PLUGGED;
}
sc->sc_wskbddev = config_found_sm(&sc->sc_dev, &ka, wskbddevprint,
dnsubmatch_kbd);
#if NWSMOUSE > 0
ma.accessops = &dnmouse_accessops;
ma.accesscookie = sc;
sc->sc_wsmousedev = config_found_sm(&sc->sc_dev, &ma, wsmousedevprint,
dnsubmatch_mouse);
#endif
SET(sc->sc_flags, SF_ATTACHED);
}
void
arckbd_cnattach(device_t self)
{
#if NWSKBD > 0
struct arckbd_softc *sc = device_private(self);
wskbd_cnattach(&arckbd_consops, sc, &arckbd_mapdata_default);
#endif
}
/* EXPORT */ void
ws_cnattach(void)
{
static int voidfill;
/* XXX need CH.B initialization XXX */
wskbd_cnattach(&ws_consops, &voidfill, &omkbd_keymapdata);
}
int
dzkbd_cnattach(struct dz_linestate *ls)
{
dzkbd_console_internal.dzi_ks.attmt.sendchar = dzkbd_sendchar;
dzkbd_console_internal.dzi_ks.attmt.cookie = ls;
lk201_init(&dzkbd_console_internal.dzi_ks);
dzkbd_console_internal.dzi_ls = ls;
wskbd_cnattach(&dzkbd_consops, &dzkbd_console_internal,
&dzkbd_keymapdata);
return 0;
}
int
qsckbd_cnattach(u_int line)
{
qsckbd_console_internal.dzi_ks.attmt.sendchar = qsckbd_sendchar;
qsckbd_console_internal.dzi_ks.attmt.cookie = (void *)line;
lk201_init(&qsckbd_console_internal.dzi_ks);
qsckbd_console_internal.dzi_line = line;
wskbd_cnattach(&qsckbd_consops, &qsckbd_console_internal,
&qsckbd_keymapdata);
return 0;
}
/*
* console routines
*/
void
ewskbd_zsc_cnattach(uint32_t csr, uint32_t data, int pclk)
{
struct zs_chanstate *cs;
cs = &conschan;
cs->cs_reg_csr = (void *)csr;
cs->cs_reg_data = (void *)data;
cs->cs_brg_clk = pclk / 16;
cs->cs_defspeed = EWSKBD_BAUD;
ewskbd_zsc_init(cs);
zs_putc(cs, EWSKBD_SETLEDS);
wskbd_cnattach(&ewskbd_wskbd_consops, cs, &ews4800kbd_wskbd_keymapdata);
ewskbd_is_console = 1;
}
int
dzkbd_cnattach()
{
/*
* Early operation (especially keyboard initialization)
* requires the help of the serial console routines, which
* need to be initialized to work with the keyboard line.
*/
dzcninit_internal(0, 1);
dzkbd_console_internal.dzi_ks.attmt.sendchar = dzkbd_sendchar;
dzkbd_console_internal.dzi_ks.attmt.cookie = NULL;
lk201_init(&dzkbd_console_internal.dzi_ks);
dzkbd_console_internal.dzi_ls = NULL;
wskbd_cnattach(&dzkbd_consops, &dzkbd_console_internal,
&dzkbd_keymapdata);
return 0;
}
void
ukbd_attach(struct device *parent, struct device *self, void *aux)
{
struct ukbd_softc *sc = (struct ukbd_softc *)self;
struct usb_attach_arg *uaa = aux;
struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
usb_hid_descriptor_t *hid;
u_int32_t qflags;
const char *parseerr;
kbd_t layout = (kbd_t)-1;
struct wskbddev_attach_args a;
sc->sc_hdev.sc_intr = ukbd_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
parseerr = ukbd_parse_desc(sc);
if (parseerr != NULL) {
printf("\n%s: attach failed, %s\n",
sc->sc_hdev.sc_dev.dv_xname, parseerr);
return;
}
hid = usbd_get_hid_descriptor(uha->uaa->iface);
#ifdef DIAGNOSTIC
printf(": %d modifier keys, %d key codes",
sc->sc_nmod, sc->sc_nkeycode);
#endif
qflags = usbd_get_quirks(uha->parent->sc_udev)->uq_flags;
sc->sc_debounce = (qflags & UQ_SPUR_BUT_UP) != 0;
/*
* Remember if we're the console keyboard.
*
* XXX This always picks the first keyboard on the
* first USB bus, but what else can we really do?
*/
if ((sc->sc_console_keyboard = ukbd_is_console) != 0) {
/* Don't let any other keyboard have it. */
ukbd_is_console = 0;
}
if (uha->uaa->vendor == USB_VENDOR_TOPRE &&
uha->uaa->product == USB_PRODUCT_TOPRE_HHKB) {
/* ignore country code on purpose */
} else {
if (hid->bCountryCode <= HCC_MAX)
layout = ukbd_countrylayout[hid->bCountryCode];
#ifdef DIAGNOSTIC
if (hid->bCountryCode != 0)
printf(", country code %d", hid->bCountryCode);
#endif
}
if (layout == (kbd_t)-1) {
#ifdef UKBD_LAYOUT
layout = UKBD_LAYOUT;
#else
layout = KB_US;
#endif
}
ukbd_keymapdata.layout = layout;
printf("\n");
if (sc->sc_console_keyboard) {
DPRINTF(("ukbd_attach: console keyboard sc=%p\n", sc));
wskbd_cnattach(&ukbd_consops, sc, &ukbd_keymapdata);
ukbd_enable(sc, 1);
}
a.console = sc->sc_console_keyboard;
a.keymap = &ukbd_keymapdata;
a.accessops = &ukbd_accessops;
a.accesscookie = sc;
#ifdef WSDISPLAY_COMPAT_RAWKBD
timeout_set(&sc->sc_rawrepeat_ch, ukbd_rawrepeat, sc);
#endif
timeout_set(&sc->sc_delay, ukbd_delayed_decode, sc);
/* Flash the leds; no real purpose, just shows we're alive. */
ukbd_set_leds(sc, WSKBD_LED_SCROLL | WSKBD_LED_NUM | WSKBD_LED_CAPS);
usbd_delay_ms(uha->parent->sc_udev, 400);
ukbd_set_leds(sc, 0);
sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
}
int
akbd_cnattach(void)
{
wskbd_cnattach(&akbd_consops, NULL, &akbd_keymapdata);
return 0;
}
static void
zkbd_attach(device_t parent, device_t self, void *aux)
{
struct zkbd_softc *sc = device_private(self);
struct wskbddev_attach_args a;
int pin, i;
sc->sc_dev = self;
zkbd_sc = sc;
aprint_normal("\n");
aprint_naive("\n");
sc->sc_polling = 0;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_rawkbd = 0;
#endif
callout_init(&sc->sc_roll_to, 0);
callout_setfunc(&sc->sc_roll_to, zkbd_poll, sc);
#ifdef WSDISPLAY_COMPAT_RAWKBD
callout_init(&sc->sc_rawrepeat_ch, 0);
callout_setfunc(&sc->sc_rawrepeat_ch, zkbd_rawrepeat, sc);
#endif
if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
sc->sc_sense_array = gpio_sense_pins_c3000;
sc->sc_strobe_array = gpio_strobe_pins_c3000;
sc->sc_nsense = __arraycount(gpio_sense_pins_c3000);
sc->sc_nstrobe = __arraycount(gpio_strobe_pins_c3000);
sc->sc_stuck_keys = stuck_keys_c3000;
sc->sc_nstuck = __arraycount(stuck_keys_c3000);
sc->sc_maxkbdcol = 10;
sc->sc_onkey_pin = 95;
sc->sc_sync_pin = 16;
sc->sc_swa_pin = 97;
sc->sc_swb_pin = 96;
sc->sc_keymapdata = &zkbd_keymapdata;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_xt_keymap = xt_keymap;
#endif
} else if (ZAURUS_ISC860) {
sc->sc_sense_array = gpio_sense_pins_c860;
sc->sc_strobe_array = gpio_strobe_pins_c860;
sc->sc_nsense = __arraycount(gpio_sense_pins_c860);
sc->sc_nstrobe = __arraycount(gpio_strobe_pins_c860);
sc->sc_stuck_keys = stuck_keys_c860;
sc->sc_nstuck = __arraycount(stuck_keys_c860);
sc->sc_maxkbdcol = 0;
sc->sc_onkey_pin = -1;
sc->sc_sync_pin = -1;
sc->sc_swa_pin = -1;
sc->sc_swb_pin = -1;
sc->sc_keymapdata = &zkbd_keymapdata_c860;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_xt_keymap = xt_keymap_c860;
#endif
} else {
/* XXX */
return;
}
if (!pmf_device_register(sc->sc_dev, NULL, zkbd_resume))
aprint_error_dev(sc->sc_dev,
"couldn't establish power handler\n");
sc->sc_okeystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
M_DEVBUF, M_NOWAIT);
memset(sc->sc_okeystate, 0, sc->sc_nsense * sc->sc_nstrobe);
sc->sc_keystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
M_DEVBUF, M_NOWAIT);
memset(sc->sc_keystate, 0, sc->sc_nsense * sc->sc_nstrobe);
/* set all the strobe bits */
for (i = 0; i < sc->sc_nstrobe; i++) {
pin = sc->sc_strobe_array[i];
if (pin == -1)
continue;
pxa2x0_gpio_set_function(pin, GPIO_SET|GPIO_OUT);
}
/* set all the sense bits */
for (i = 0; i < sc->sc_nsense; i++) {
pin = sc->sc_sense_array[i];
if (pin == -1)
continue;
pxa2x0_gpio_set_function(pin, GPIO_IN);
if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
pxa2x0_gpio_intr_establish(pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_irq_c3000, sc);
} else if (ZAURUS_ISC860) {
pxa2x0_gpio_intr_establish(pin, IST_EDGE_RISING,
IPL_TTY, zkbd_irq_c860, sc);
}
}
if (sc->sc_onkey_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_onkey_pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_on, sc);
if (sc->sc_sync_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_sync_pin, IST_EDGE_RISING,
IPL_TTY, zkbd_sync, sc);
if (sc->sc_swa_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_swa_pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_hinge, sc);
if (sc->sc_swb_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_swb_pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_hinge, sc);
if (glass_console) {
wskbd_cnattach(&zkbd_consops, sc, sc->sc_keymapdata);
a.console = 1;
} else {
a.console = 0;
}
a.keymap = sc->sc_keymapdata;
a.accessops = &zkbd_accessops;
a.accesscookie = sc;
zkbd_hinge(sc); /* to initialize sc_hinge */
sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
}
void
ukbd_attach(device_t parent, device_t self, void *aux)
{
struct ukbd_softc *sc = device_private(self);
struct uhidev_attach_arg *uha = aux;
u_int32_t qflags;
const char *parseerr;
#if defined(__NetBSD__)
struct wskbddev_attach_args a;
#else
int i;
#endif
sc->sc_hdev.sc_dev = self;
sc->sc_hdev.sc_intr = ukbd_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
if (!pmf_device_register(self, NULL, NULL)) {
aprint_normal("\n");
aprint_error_dev(self, "couldn't establish power handler\n");
}
parseerr = ukbd_parse_desc(sc);
if (parseerr != NULL) {
aprint_normal("\n");
aprint_error_dev(self, "attach failed, %s\n", parseerr);
USB_ATTACH_ERROR_RETURN;
}
#ifdef DIAGNOSTIC
aprint_normal(": %d modifier keys, %d key codes", sc->sc_nmod,
sc->sc_nkeycode);
#endif
aprint_normal("\n");
qflags = usbd_get_quirks(uha->parent->sc_udev)->uq_flags;
sc->sc_debounce = (qflags & UQ_SPUR_BUT_UP) != 0;
/*
* Remember if we're the console keyboard.
*
* XXX This always picks the first keyboard on the
* first USB bus, but what else can we really do?
*/
if ((sc->sc_console_keyboard = ukbd_is_console) != 0) {
/* Don't let any other keyboard have it. */
ukbd_is_console = 0;
}
if (sc->sc_console_keyboard) {
DPRINTF(("ukbd_attach: console keyboard sc=%p\n", sc));
wskbd_cnattach(&ukbd_consops, sc, &ukbd_keymapdata);
ukbd_enable(sc, 1);
}
a.console = sc->sc_console_keyboard;
a.keymap = &ukbd_keymapdata;
a.accessops = &ukbd_accessops;
a.accesscookie = sc;
#ifdef UKBD_REPEAT
usb_callout_init(sc->sc_rawrepeat_ch);
#endif
usb_callout_init(sc->sc_delay);
/* Flash the leds; no real purpose, just shows we're alive. */
ukbd_set_leds(sc, WSKBD_LED_SCROLL | WSKBD_LED_NUM | WSKBD_LED_CAPS);
usbd_delay_ms(uha->parent->sc_udev, 400);
ukbd_set_leds(sc, 0);
sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
USB_ATTACH_SUCCESS_RETURN;
}
void
j720sspattach(struct device *parent, struct device *self, void *aux)
{
struct j720ssp_softc *sc = (void *)self;
struct sa11x0_softc *psc = (void *)parent;
struct sa11x0_attach_args *sa = aux;
struct wskbddev_attach_args a;
printf("\n");
sc->sc_iot = psc->sc_iot;
sc->sc_gpioh = psc->sc_gpioh;
if (bus_space_map(sc->sc_iot, sa->sa_addr, sa->sa_size, 0,
&sc->sc_ssph)) {
printf("%s: unable to map SSP registers\n",
sc->sc_dev.dv_xname);
return;
}
sc->sc_si = softintr_establish(IPL_SOFTCLOCK, j720kbdsoft, sc);
sc->sc_enabled = 0;
a.console = 0;
a.keymap = &j720kbd_keymapdata;
a.accessops = &j720kbd_accessops;
a.accesscookie = sc;
/* Do console initialization */
if (! (bootinfo->bi_cnuse & BI_CNUSE_SERIAL)) {
j720kbdcons_sc = *sc;
a.console = 1;
wskbd_cnattach(&j720kbd_consops, NULL, &j720kbd_keymapdata);
j720kbdcons_initstate = 1;
}
/*
* Attach the wskbd, saving a handle to it.
* XXX XXX XXX
*/
sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
#ifdef DEBUG
/* Zero the stat counters */
j720sspwaitcnt = 0;
j720sspwaittime = 0;
#endif
if (j720kbdcons_initstate == 1)
j720kbd_enable(sc, 1);
/* LCD control is on the same bus */
config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS,
CONFIG_HOOK_SHARE, j720lcdparam, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS,
CONFIG_HOOK_SHARE, j720lcdparam, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS_MAX,
CONFIG_HOOK_SHARE, j720lcdparam, sc);
config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_CONTRAST,
CONFIG_HOOK_SHARE, j720lcdparam, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST,
CONFIG_HOOK_SHARE, j720lcdparam, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST_MAX,
CONFIG_HOOK_SHARE, j720lcdparam, sc);
}
static void
adbkbd_attach(device_t parent, device_t self, void *aux)
{
struct adbkbd_softc *sc = device_private(self);
struct adb_attach_args *aaa = aux;
short cmd;
struct wskbddev_attach_args a;
#if NWSMOUSE > 0
struct wsmousedev_attach_args am;
#endif
uint8_t buffer[2];
sc->sc_dev = self;
sc->sc_ops = aaa->ops;
sc->sc_adbdev = aaa->dev;
sc->sc_adbdev->cookie = sc;
sc->sc_adbdev->handler = adbkbd_handler;
sc->sc_us = ADBTALK(sc->sc_adbdev->current_addr, 0);
sc->sc_leds = 0; /* initially off */
sc->sc_have_led_control = 0;
/*
* If this is != 0 then pushing the power button will not immadiately
* send a shutdown event to sysmon but instead require another key
* press within 5 seconds with a gap of at least two seconds. The
* reason to do this is the fact that some PowerBook keyboards,
* like the 2400, 3400 and original G3 have their power buttons
* right next to the backspace key and it's extremely easy to hit
* it by accident.
* On most other keyboards the power button is sufficiently far out
* of the way so we don't need this.
*/
sc->sc_power_button_delay = 0;
sc->sc_msg_len = 0;
sc->sc_poll = 0;
sc->sc_capslock = 0;
sc->sc_trans[1] = 103; /* F11 */
sc->sc_trans[2] = 111; /* F12 */
/*
* Most ADB keyboards send 0x7f 0x7f when the power button is pressed.
* Some older PowerBooks, like the 3400c, will send a single scancode
* 0x7e instead. Unfortunately Fn-Command on some more recent *Books
* sends the same scancode, so by default sc_power is set to a value
* that can't occur as a scancode and only set to 0x7e on hardware that
* needs it
*/
sc->sc_power = 0xffff;
sc->sc_timestamp = 0;
sc->sc_emul_usb = FALSE;
aprint_normal(" addr %d: ", sc->sc_adbdev->current_addr);
switch (sc->sc_adbdev->handler_id) {
case ADB_STDKBD:
aprint_normal("standard keyboard\n");
break;
case ADB_ISOKBD:
aprint_normal("standard keyboard (ISO layout)\n");
break;
case ADB_EXTKBD:
cmd = ADBTALK(sc->sc_adbdev->current_addr, 1);
sc->sc_msg_len = 0;
sc->sc_ops->send(sc->sc_ops->cookie, sc->sc_poll, cmd, 0, NULL);
adbkbd_wait(sc, 10);
/* Ignore Logitech MouseMan/Trackman pseudo keyboard */
/* XXX needs testing */
if (sc->sc_buffer[2] == 0x9a && sc->sc_buffer[3] == 0x20) {
aprint_normal("Mouseman (non-EMP) pseudo keyboard\n");
return;
} else if (sc->sc_buffer[2] == 0x9a &&
sc->sc_buffer[3] == 0x21) {
aprint_normal("Trackman (non-EMP) pseudo keyboard\n");
return;
} else {
aprint_normal("extended keyboard\n");
adbkbd_initleds(sc);
}
break;
case ADB_EXTISOKBD:
aprint_normal("extended keyboard (ISO layout)\n");
adbkbd_initleds(sc);
break;
case ADB_KBDII:
aprint_normal("keyboard II\n");
break;
case ADB_ISOKBDII:
aprint_normal("keyboard II (ISO layout)\n");
break;
case ADB_PBKBD:
aprint_normal("PowerBook keyboard\n");
sc->sc_power = 0x7e;
sc->sc_power_button_delay = 1;
break;
case ADB_PBISOKBD:
aprint_normal("PowerBook keyboard (ISO layout)\n");
sc->sc_power = 0x7e;
sc->sc_power_button_delay = 1;
break;
case ADB_ADJKPD:
aprint_normal("adjustable keypad\n");
break;
case ADB_ADJKBD:
aprint_normal("adjustable keyboard\n");
break;
case ADB_ADJISOKBD:
aprint_normal("adjustable keyboard (ISO layout)\n");
break;
case ADB_ADJJAPKBD:
aprint_normal("adjustable keyboard (Japanese layout)\n");
break;
case ADB_PBEXTISOKBD:
aprint_normal("PowerBook extended keyboard (ISO layout)\n");
sc->sc_power_button_delay = 1;
sc->sc_power = 0x7e;
break;
case ADB_PBEXTJAPKBD:
aprint_normal("PowerBook extended keyboard (Japanese layout)\n");
sc->sc_power_button_delay = 1;
sc->sc_power = 0x7e;
break;
case ADB_JPKBDII:
aprint_normal("keyboard II (Japanese layout)\n");
break;
case ADB_PBEXTKBD:
aprint_normal("PowerBook extended keyboard\n");
sc->sc_power_button_delay = 1;
sc->sc_power = 0x7e;
break;
case ADB_DESIGNKBD:
aprint_normal("extended keyboard\n");
adbkbd_initleds(sc);
break;
case ADB_PBJPKBD:
aprint_normal("PowerBook keyboard (Japanese layout)\n");
sc->sc_power_button_delay = 1;
sc->sc_power = 0x7e;
break;
case ADB_PBG3KBD:
aprint_normal("PowerBook G3 keyboard\n");
break;
case ADB_PBG3JPKBD:
aprint_normal("PowerBook G3 keyboard (Japanese layout)\n");
break;
case ADB_IBOOKKBD:
aprint_normal("iBook keyboard\n");
break;
default:
aprint_normal("mapped device (%d)\n", sc->sc_adbdev->handler_id);
break;
}
/*
* try to switch to extended protocol
* as in, tell the keyboard to distinguish between left and right
* Shift, Control and Alt keys
*/
cmd = ADBLISTEN(sc->sc_adbdev->current_addr, 3);
buffer[0] = sc->sc_adbdev->current_addr;
buffer[1] = 3;
sc->sc_msg_len = 0;
sc->sc_ops->send(sc->sc_ops->cookie, sc->sc_poll, cmd, 2, buffer);
adbkbd_wait(sc, 10);
cmd = ADBTALK(sc->sc_adbdev->current_addr, 3);
sc->sc_msg_len = 0;
sc->sc_ops->send(sc->sc_ops->cookie, sc->sc_poll, cmd, 0, NULL);
adbkbd_wait(sc, 10);
if ((sc->sc_msg_len == 4) && (sc->sc_buffer[3] == 3)) {
aprint_verbose_dev(sc->sc_dev, "extended protocol enabled\n");
}
if (adbkbd_is_console && (adbkbd_console_attached == 0)) {
wskbd_cnattach(&adbkbd_consops, sc, &adbkbd_keymapdata);
adbkbd_console_attached = 1;
a.console = 1;
} else {
a.console = 0;
}
a.keymap = &adbkbd_keymapdata;
a.accessops = &adbkbd_accessops;
a.accesscookie = sc;
sc->sc_wskbddev = config_found_ia(self, "wskbddev", &a, wskbddevprint);
#ifdef ADBKBD_EMUL_USB
sc->sc_emul_usb = TRUE;
wskbd_set_evtrans(sc->sc_wskbddev, adb_to_usb, 128);
#endif /* ADBKBD_EMUL_USB */
#if NWSMOUSE > 0
/* attach the mouse device */
am.accessops = &adbkms_accessops;
am.accesscookie = sc;
sc->sc_wsmousedev = config_found_ia(self, "wsmousedev", &am,
wsmousedevprint);
#endif
adbkbd_setup_sysctl(sc);
/* finally register the power button */
sysmon_task_queue_init();
memset(&sc->sc_sm_pbutton, 0, sizeof(struct sysmon_pswitch));
sc->sc_sm_pbutton.smpsw_name = device_xname(sc->sc_dev);
sc->sc_sm_pbutton.smpsw_type = PSWITCH_TYPE_POWER;
if (sysmon_pswitch_register(&sc->sc_sm_pbutton) != 0)
aprint_error_dev(sc->sc_dev,
"unable to register power button with sysmon\n");
}
void
ukbd_attach(struct device *parent, struct device *self, void *aux)
{
struct ukbd_softc *sc = (struct ukbd_softc *)self;
struct hidkbd *kbd = &sc->sc_kbd;
struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)aux;
struct usb_hid_descriptor *hid;
u_int32_t qflags;
int dlen, repid;
void *desc;
kbd_t layout = (kbd_t)-1;
sc->sc_hdev.sc_intr = ukbd_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_udev = uha->uaa->device;
sc->sc_hdev.sc_report_id = uha->reportid;
uhidev_get_report_desc(uha->parent, &desc, &dlen);
repid = uha->reportid;
sc->sc_hdev.sc_isize = hid_report_size(desc, dlen, hid_input, repid);
sc->sc_hdev.sc_osize = hid_report_size(desc, dlen, hid_output, repid);
sc->sc_hdev.sc_fsize = hid_report_size(desc, dlen, hid_feature, repid);
qflags = usbd_get_quirks(sc->sc_hdev.sc_udev)->uq_flags;
if (hidkbd_attach(self, kbd, 1, qflags, repid, desc, dlen) != 0)
return;
if (uha->uaa->vendor == USB_VENDOR_APPLE) {
int iso = 0;
if ((uha->uaa->product == USB_PRODUCT_APPLE_FOUNTAIN_ISO) ||
(uha->uaa->product == USB_PRODUCT_APPLE_GEYSER_ISO))
iso = 1;
if (hid_locate(desc, dlen, HID_USAGE2(HUP_APPLE, HUG_FN_KEY),
uha->reportid, hid_input, &sc->sc_apple_fn, &qflags)) {
if (qflags & HIO_VARIABLE) {
if (iso)
sc->sc_munge = ukbd_apple_iso_munge;
else
sc->sc_munge = ukbd_apple_munge;
}
}
}
if (uha->uaa->vendor == USB_VENDOR_TOPRE &&
uha->uaa->product == USB_PRODUCT_TOPRE_HHKB) {
/* ignore country code on purpose */
} else {
hid = usbd_get_hid_descriptor(uha->uaa->iface);
if (hid->bCountryCode <= HCC_MAX)
layout = ukbd_countrylayout[hid->bCountryCode];
#ifdef DIAGNOSTIC
if (hid->bCountryCode != 0)
printf(", country code %d", hid->bCountryCode);
#endif
}
if (layout == (kbd_t)-1) {
#ifdef UKBD_LAYOUT
layout = UKBD_LAYOUT;
#else
layout = KB_US | KB_DEFAULT;
#endif
}
printf("\n");
#ifdef __loongson__
if (uha->uaa->vendor == USB_VENDOR_CYPRESS &&
uha->uaa->product == USB_PRODUCT_CYPRESS_LPRDK)
sc->sc_munge = ukbd_gdium_munge;
#endif
if (kbd->sc_console_keyboard) {
extern struct wskbd_mapdata ukbd_keymapdata;
DPRINTF(("ukbd_attach: console keyboard sc=%p\n", sc));
ukbd_keymapdata.layout = layout;
wskbd_cnattach(&ukbd_consops, sc, &ukbd_keymapdata);
ukbd_enable(sc, 1);
}
/* Flash the leds; no real purpose, just shows we're alive. */
ukbd_set_leds(sc, WSKBD_LED_SCROLL | WSKBD_LED_NUM |
WSKBD_LED_CAPS | WSKBD_LED_COMPOSE);
usbd_delay_ms(sc->sc_hdev.sc_udev, 400);
ukbd_set_leds(sc, 0);
hidkbd_attach_wskbd(kbd, layout, &ukbd_accessops);
}