Home | History | Annotate | Line # | Download | only in i2c
tcakp.c revision 1.7 
      1 /* $NetBSD: tcakp.c,v 1.7 2018/06/16 21:22:13 thorpej Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2017 Jared McNeill <jmcneill (at) invisible.ca>
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     26  * POSSIBILITY OF SUCH DAMAGE.
     27  */
     28 
     29 #include "opt_fdt.h"
     30 
     31 #include <sys/cdefs.h>
     32 __KERNEL_RCSID(0, "$NetBSD: tcakp.c,v 1.7 2018/06/16 21:22:13 thorpej Exp $");
     33 
     34 #include <sys/param.h>
     35 #include <sys/systm.h>
     36 #include <sys/kernel.h>
     37 #include <sys/device.h>
     38 #include <sys/conf.h>
     39 #include <sys/bus.h>
     40 #include <sys/kmem.h>
     41 #include <sys/bitops.h>
     42 
     43 #include <dev/i2c/i2cvar.h>
     44 
     45 #include <dev/wscons/wsconsio.h>
     46 #include <dev/wscons/wskbdvar.h>
     47 #include <dev/wscons/wsksymdef.h>
     48 #include <dev/wscons/wsksymvar.h>
     49 #include <dev/wscons/linux_keymap.h>
     50 
     51 #ifdef FDT
     52 #include <dev/fdt/fdtvar.h>
     53 #endif
     54 
     55 #define	TCA_MAX_ROWS		8
     56 #define	TCA_MAX_COLS		10
     57 
     58 #define	TCA_CFG			0x01
     59 #define	 CFG_AI			__BIT(7)
     60 #define	 CFG_GPI_E_CFG		__BIT(6)
     61 #define	 CFG_OVR_FLOW_M		__BIT(5)
     62 #define	 CFG_INT_CFG		__BIT(4)
     63 #define	 CFG_OVR_FLOW_IEN	__BIT(3)
     64 #define	 CFG_K_LCK_IEN		__BIT(2)
     65 #define	 CFG_GPI_IEN		__BIT(1)
     66 #define	 CFG_KE_IEN		__BIT(0)
     67 #define	TCA_INT_STAT		0x02
     68 #define	 INT_STAT_CAD_INT	__BIT(4)
     69 #define	 INT_STAT_OVR_FLOW_INT	__BIT(3)
     70 #define	 INT_STAT_K_LCD_INT	__BIT(2)
     71 #define	 INT_STAT_GPI_INT	__BIT(1)
     72 #define	 INT_STAT_K_INT		__BIT(0)
     73 #define	TCA_KEY_LCK_EC		0x03
     74 #define	 KEY_LCK_EC_K_LCK_EN	__BIT(6)
     75 #define	 KEY_LCK_EC_LCK2	__BIT(5)
     76 #define	 KEY_LCK_EC_LCK1	__BIT(4)
     77 #define	 KEY_LCK_EC_KEC		__BITS(3,0)
     78 #define	TCA_EVENT(c)		(0x04 + (c) - 'A')
     79 #define	 TCA_EVENT_STATE	__BIT(7)
     80 #define	 TCA_EVENT_CODE		__BITS(6,0)
     81 #define	TCA_KP_GPIO1		0x1d
     82 #define	TCA_KP_GPIO2		0x1e
     83 #define	TCA_KP_GPIO3		0x1f
     84 #define	TCA_DEBOUNCE_DIS1	0x29
     85 #define	TCA_DEBOUNCE_DIS2	0x2a
     86 #define	TCA_DEBOUNCE_DIS3	0x2b
     87 
     88 struct tcakp_softc {
     89 	device_t	sc_dev;
     90 	i2c_tag_t	sc_i2c;
     91 	i2c_addr_t	sc_addr;
     92 	int		sc_phandle;
     93 
     94 	u_int		sc_rows;
     95 	u_int		sc_cols;
     96 	bool		sc_autorepeat;
     97 	u_int		sc_row_shift;
     98 
     99 	uint16_t	sc_keymap[128];
    100 
    101 	void		*sc_ih;
    102 
    103 	int		sc_enabled;
    104 	device_t	sc_wskbddev;
    105 };
    106 
    107 static int	tcakp_match(device_t, cfdata_t, void *);
    108 static void	tcakp_attach(device_t, device_t, void *);
    109 
    110 static int	tcakp_read(struct tcakp_softc *, uint8_t, uint8_t *);
    111 static int	tcakp_write(struct tcakp_softc *, uint8_t, uint8_t);
    112 
    113 CFATTACH_DECL_NEW(tcakp, sizeof(struct tcakp_softc),
    114     tcakp_match, tcakp_attach, NULL, NULL);
    115 
    116 static const char * tcakp_compats[] = {
    117 	"ti,tca8418",
    118 	NULL
    119 };
    120 
    121 static u_int
    122 tcakp_decode(struct tcakp_softc *sc, uint8_t code)
    123 {
    124 	u_int row = code / TCA_MAX_COLS;
    125 	u_int col = code % TCA_MAX_COLS;
    126 	if (col == 0) {
    127 		row = row - 1;
    128 		col = TCA_MAX_COLS - 1;
    129 	} else {
    130 		col = col - 1;
    131 	}
    132 
    133 	return (row << sc->sc_row_shift) + col;
    134 }
    135 
    136 static int
    137 tcakp_intr(void *priv)
    138 {
    139 	struct tcakp_softc * const sc = priv;
    140 	uint8_t stat, ev;
    141 	int ret = 0;
    142 
    143 	tcakp_read(sc, TCA_INT_STAT, &stat);
    144 	if (stat & INT_STAT_K_INT) {
    145 		tcakp_read(sc, TCA_EVENT('A'), &ev);
    146 		while (ev != 0) {
    147 			const bool pressed = __SHIFTOUT(ev, TCA_EVENT_STATE);
    148 			const uint8_t code = __SHIFTOUT(ev, TCA_EVENT_CODE);
    149 
    150 			/* Translate raw code to keymap index */
    151 			const u_int index = tcakp_decode(sc, code);
    152 
    153 			u_int type = pressed ? WSCONS_EVENT_KEY_DOWN :
    154 					       WSCONS_EVENT_KEY_UP;
    155 			int key = linux_key_to_usb(sc->sc_keymap[index]);
    156 
    157 			if (sc->sc_wskbddev)
    158 				wskbd_input(sc->sc_wskbddev, type, key);
    159 
    160 			tcakp_read(sc, TCA_EVENT('A'), &ev);
    161 		}
    162 		ret = 1;
    163 	}
    164 	tcakp_write(sc, TCA_INT_STAT, stat);
    165 
    166 	return ret;
    167 }
    168 
    169 static int
    170 tcakp_init(struct tcakp_softc *sc)
    171 {
    172 	uint32_t mask;
    173 	uint8_t val;
    174 
    175 	if (sc->sc_rows == 0 || sc->sc_cols == 0) {
    176 		aprint_error_dev(sc->sc_dev, "not configured\n");
    177 		return ENXIO;
    178 	}
    179 
    180 	mask = __BITS(sc->sc_rows - 1, 0);
    181 	mask += __BITS(sc->sc_cols - 1, 0) << 8;
    182 
    183 	/* Lock the keyboard */
    184 	tcakp_write(sc, TCA_KEY_LCK_EC, KEY_LCK_EC_K_LCK_EN);
    185 	/* Select keyboard mode */
    186 	tcakp_write(sc, TCA_KP_GPIO1, (mask >> 0) & 0xff);
    187 	tcakp_write(sc, TCA_KP_GPIO2, (mask >> 8) & 0xff);
    188 	tcakp_write(sc, TCA_KP_GPIO3, (mask >> 16) & 0xff);
    189 	/* Disable debounce */
    190 	tcakp_write(sc, TCA_DEBOUNCE_DIS1, (mask >> 0) & 0xff);
    191 	tcakp_write(sc, TCA_DEBOUNCE_DIS2, (mask >> 8) & 0xff);
    192 	tcakp_write(sc, TCA_DEBOUNCE_DIS3, (mask >> 16) & 0xff);
    193 	/* Enable key event interrupts */
    194 	tcakp_write(sc, TCA_CFG, CFG_INT_CFG | CFG_KE_IEN);
    195 	/* Clear interrupts */
    196 	tcakp_read(sc, TCA_INT_STAT, &val);
    197 	tcakp_write(sc, TCA_INT_STAT, val);
    198 
    199 	return 0;
    200 }
    201 
    202 static void
    203 tcakp_configure_fdt(struct tcakp_softc *sc)
    204 {
    205 	const uint32_t *keymap;
    206 	int len;
    207 
    208 	of_getprop_uint32(sc->sc_phandle, "keypad,num-rows", &sc->sc_rows);
    209 	of_getprop_uint32(sc->sc_phandle, "keypad,num-columns", &sc->sc_cols);
    210 	sc->sc_autorepeat = of_getprop_bool(sc->sc_phandle, "keypad,autorepeat");
    211 
    212 	keymap = fdtbus_get_prop(sc->sc_phandle, "linux,keymap", &len);
    213 	if (keymap == NULL || len <= 0)
    214 		return;
    215 
    216 	sc->sc_row_shift = fls32(sc->sc_cols) - 1;
    217 	if (sc->sc_row_shift & (sc->sc_cols - 1))
    218 		sc->sc_row_shift++;
    219 
    220 	while (len >= 4) {
    221 		const uint32_t e = be32toh(*keymap);
    222 		const u_int row = (e >> 24) & 0xff;
    223 		const u_int col = (e >> 16) & 0xff;
    224 		const u_int index = (row << sc->sc_row_shift) + col;
    225 
    226 		sc->sc_keymap[index] = e & 0xffff;
    227 
    228 		len -= 4;
    229 		keymap++;
    230 	}
    231 }
    232 
    233 static int
    234 tcakp_enable(void *v, int on)
    235 {
    236 	struct tcakp_softc * const sc = v;
    237 
    238 	if (on) {
    239 		/* Disable key lock */
    240 		tcakp_write(sc, TCA_KEY_LCK_EC, 0);
    241 	} else {
    242 		/* Enable key lock */
    243 		tcakp_write(sc, TCA_KEY_LCK_EC, KEY_LCK_EC_K_LCK_EN);
    244 	}
    245 
    246 	return 0;
    247 }
    248 
    249 static void
    250 tcakp_set_leds(void *v, int leds)
    251 {
    252 }
    253 
    254 static int
    255 tcakp_ioctl(void *v, u_long cmd, void *data, int flag, lwp_t *l)
    256 {
    257 	switch (cmd) {
    258 	case WSKBDIO_GTYPE:
    259 		*(int *)data = WSKBD_TYPE_USB;
    260 		return 0;
    261 	}
    262 
    263 	return EPASSTHROUGH;
    264 }
    265 
    266 static const struct wskbd_accessops tcakp_accessops = {
    267 	tcakp_enable,
    268 	tcakp_set_leds,
    269 	tcakp_ioctl,
    270 };
    271 
    272 #if notyet
    273 static void
    274 tcakp_cngetc(void *v, u_int *type, int *data)
    275 {
    276 	struct tcakp_softc * const sc = v;
    277 	uint8_t ev = 0;
    278 
    279 	do {
    280 		tcakp_read(sc, TCA_EVENT('A'), &ev);
    281 	} while (ev == 0);
    282 
    283 	const bool pressed = __SHIFTOUT(ev, TCA_EVENT_STATE);
    284 	const uint8_t code = __SHIFTOUT(ev, TCA_EVENT_CODE);
    285 	const u_int index = tcakp_decode(sc, code);
    286 
    287 	*type = pressed ? WSCONS_EVENT_KEY_DOWN :
    288 			  WSCONS_EVENT_KEY_UP;
    289 	*data = sc->sc_keymap[index];
    290 }
    291 
    292 static void
    293 tcakp_cnpollc(void *v, int on)
    294 {
    295 }
    296 
    297 static void
    298 tcakp_cnbell(void *v, u_int pitch, u_int period, u_int volume)
    299 {
    300 }
    301 
    302 static const struct wskbd_consops tcakp_consops = {
    303 	tcakp_cngetc,
    304 	tcakp_cnpollc,
    305 	tcakp_cnbell,
    306 };
    307 #endif
    308 
    309 extern const struct wscons_keydesc hidkbd_keydesctab[];
    310 static const struct wskbd_mapdata tcakp_keymapdata = {
    311 	hidkbd_keydesctab,
    312 	KB_US,
    313 };
    314 
    315 static int
    316 tcakp_match(device_t parent, cfdata_t match, void *aux)
    317 {
    318 	struct i2c_attach_args *ia = aux;
    319 	int match_result;
    320 
    321 	if (iic_use_direct_match(ia, match, tcakp_compats, &match_result))
    322 		return match_result;
    323 
    324 	if (ia->ia_addr == 0x34)
    325 		return I2C_MATCH_ADDRESS_ONLY;
    326 
    327 	return 0;
    328 }
    329 
    330 static void
    331 tcakp_attach(device_t parent, device_t self, void *aux)
    332 {
    333 	struct tcakp_softc * const sc = device_private(self);
    334 	struct i2c_attach_args *ia = aux;
    335 	struct wskbddev_attach_args a;
    336 
    337 	sc->sc_dev = self;
    338 	sc->sc_i2c = ia->ia_tag;
    339 	sc->sc_addr = ia->ia_addr;
    340 	sc->sc_phandle = ia->ia_cookie;
    341 
    342 	aprint_naive("\n");
    343 	aprint_normal(": TCA8418\n");
    344 
    345 #ifdef FDT
    346 	sc->sc_ih = fdtbus_intr_establish(sc->sc_phandle, 0, IPL_VM, 0,
    347 	    tcakp_intr, sc);
    348 
    349 	tcakp_configure_fdt(sc);
    350 #endif
    351 
    352 	if (tcakp_init(sc) != 0)
    353 		return;
    354 
    355 	memset(&a, 0, sizeof(a));
    356 	a.console = false;	/* XXX */
    357 	a.keymap = &tcakp_keymapdata;
    358 	a.accessops = &tcakp_accessops;
    359 	a.accesscookie = sc;
    360 
    361 	sc->sc_wskbddev = config_found_ia(self, "wskbddev", &a, wskbddevprint);
    362 }
    363 
    364 static int
    365 tcakp_read(struct tcakp_softc *sc, uint8_t reg, uint8_t *val)
    366 {
    367 	return iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, sc->sc_addr,
    368 	    &reg, 1, val, 1, I2C_F_POLL);
    369 }
    370 
    371 static int
    372 tcakp_write(struct tcakp_softc *sc, uint8_t reg, uint8_t val)
    373 {
    374 	uint8_t buf[2] = { reg, val };
    375 	return iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, sc->sc_addr,
    376 	    NULL, 0, buf, 2, I2C_F_POLL);
    377 }
    378