1 /* 2 * Copyright (c) 2005 Jesse Off. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 * 25 * 26 * The matrix keypad is a primitive type of keying device 27 * commonly used in systems as a small, cheap, easy-to-build and rugged 28 * way to get user input in a variety of embedded environments. This 29 * driver can work for any size of keypad. A one key keypad (aka 30 * button) can also be used. The theory of operation is described 31 * thusly: 32 * 33 * 1) The keypad is connected to the NetBSD embedded system 34 * with digital I/O (DIO) pins connected to each column of 35 * the keypad and also to each row of the keypad. 36 * 37 * 2) When a button is pressed, a short is made between a 38 * column line and the intersecting row line. 39 * 40 * 3) Software is responsible to poll each row/column individually 41 * and also to debounce any key presses. 42 * 43 * To correctly wire up such a thing requires the input DIO 44 * lines to have pull-up resistors, otherwise an input may be read as a random 45 * value if not currently being shorted by a button press. 46 */ 47 48 #include <sys/cdefs.h> 49 __KERNEL_RCSID(0, "$NetBSD: matrixkp_subr.c,v 1.7 2007/10/19 11:59:55 ad Exp $"); 50 51 #include <sys/param.h> 52 #include <sys/systm.h> 53 #include <sys/proc.h> 54 #include <sys/callout.h> 55 #include <sys/conf.h> 56 #include <sys/kernel.h> 57 #include <sys/types.h> 58 59 #include <machine/autoconf.h> 60 #include <sys/intr.h> 61 #include <sys/bus.h> 62 63 #include <dev/wscons/wsconsio.h> 64 #include <dev/wscons/wskbdvar.h> 65 #include <dev/wscons/wsksymdef.h> 66 #include <dev/wscons/wsksymvar.h> 67 68 #include <dev/ic/matrixkpvar.h> 69 70 #define TV_ELAPSED_US(x, y) (((x).tv_sec - (y).tv_sec) * 1000000 + \ 71 ((x).tv_usec - (y).tv_usec)) 72 73 const struct wskbd_accessops mxkp_accessops = { 74 mxkp_enable, 75 mxkp_set_leds, 76 mxkp_ioctl, 77 }; 78 79 void 80 mxkp_attach(struct matrixkp_softc *sc) 81 { 82 u_int32_t i; 83 84 callout_init(&sc->sc_callout, 0); 85 callout_setfunc(&sc->sc_callout, mxkp_poll, sc); 86 if (sc->poll_freq > hz || sc->poll_freq == 0) 87 sc->poll_freq = hz; 88 sc->sc_enabled = 0; 89 if (sc->debounce_stable_ms == 0) 90 sc->sc_flags |= MXKP_NODEBOUNCE; 91 if (sc->mxkp_event == NULL) 92 sc->mxkp_event = mxkp_wskbd_event; 93 FOR_KEYS(i, sc->mxkp_pressed[i] = 0); 94 } 95 96 void 97 mxkp_poll(void *arg) 98 { 99 struct matrixkp_softc *sc = (struct matrixkp_softc *)arg; 100 u_int32_t i, anychanged; 101 u_int32_t scanned[(MAXNKEYS + 31) / 32]; 102 u_int32_t changed[(MAXNKEYS + 31) / 32]; 103 u_int32_t set[(MAXNKEYS + 31) / 32]; 104 u_int32_t cleared[(MAXNKEYS + 31) / 32]; 105 106 rescan: 107 anychanged = 0; 108 FOR_KEYS(i, scanned[i] = 0); 109 sc->mxkp_scankeys(sc, scanned); 110 FOR_KEYS(i, changed[i] = sc->mxkp_pressed[i] ^ scanned[i]); 111 FOR_KEYS(i, anychanged |= changed[i]); 112 113 if (!(sc->sc_flags & MXKP_NODEBOUNCE) && anychanged) { 114 mxkp_debounce(sc, changed, scanned); 115 anychanged = 0; 116 FOR_KEYS(i, changed[i] &= sc->mxkp_pressed[i] ^ scanned[i]); 117 FOR_KEYS(i, anychanged |= changed[i]); 118 } 119 if (anychanged) { 120 FOR_KEYS(i, set[i] = changed[i] & scanned[i]); 121 FOR_KEYS(i, cleared[i] = changed[i] & sc->mxkp_pressed[i]); 122 sc->mxkp_event(sc, set, cleared); 123 FOR_KEYS(i, sc->mxkp_pressed[i] &= ~cleared[i]); 124 FOR_KEYS(i, sc->mxkp_pressed[i] |= set[i]); 125 goto rescan; 126 } 127 if (sc->sc_enabled) 128 callout_schedule(&sc->sc_callout, hz / sc->poll_freq); 129 } 130 131 /* 132 * debounce will return when masked keys have been stable 133 * for sc->debounce_stable_ms 134 */ 135 void 136 mxkp_debounce(struct matrixkp_softc *sc, u_int32_t *mask, u_int32_t *scan) { 137 struct timeval verystart, start, now; 138 u_int32_t last_val[(MAXNKEYS + 31) / 32]; 139 u_int32_t anyset, i; 140 141 FOR_KEYS(i, last_val[i] = scan[i]); 142 microtime(&verystart); 143 start = verystart; 144 do { 145 FOR_KEYS(i, scan[i] = 0); 146 sc->mxkp_scankeys(sc, scan); 147 microtime(&now); 148 anyset = 0; 149 FOR_KEYS(i, anyset |= (scan[i] ^ last_val[i]) & mask[i]); 150 if (anyset) /* bounce detected */ 151 start = now; 152 FOR_KEYS(i, last_val[i] = scan[i]); 153 } while (TV_ELAPSED_US(now, start) <= (sc->debounce_stable_ms * 1000)); 154 } 155 156 void 157 mxkp_wskbd_event(struct matrixkp_softc *sc, u_int32_t *on, u_int32_t *off) 158 { 159 unsigned int i; 160 161 for(i = 0; i < sc->mxkp_nkeys; i++) { 162 if (off[i / 32] & (1 << (i % 32))) { 163 wskbd_input(sc->sc_wskbddev, WSCONS_EVENT_KEY_UP, i); 164 } 165 } 166 for(i = 0; i < sc->mxkp_nkeys; i++) { 167 if (on[i / 32] & (1 << (i % 32))) { 168 wskbd_input(sc->sc_wskbddev, WSCONS_EVENT_KEY_DOWN, i); 169 } 170 } 171 } 172 173 int 174 mxkp_enable(void *v, int on) 175 { 176 struct matrixkp_softc *sc = v; 177 178 if (on) { 179 if (sc->sc_enabled) 180 return EBUSY; 181 182 sc->sc_enabled = 1; 183 callout_schedule(&sc->sc_callout, hz / sc->poll_freq); 184 } else { 185 sc->sc_enabled = 0; 186 } 187 188 return 0; 189 } 190 191 void 192 mxkp_set_leds(void *v, int leds) 193 { 194 } 195 196 int 197 mxkp_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l) 198 { 199 switch (cmd) { 200 case WSKBDIO_GTYPE: 201 *(int *)data = WSKBD_TYPE_MATRIXKP; 202 return 0; 203 case WSKBDIO_SETLEDS: 204 return 0; 205 case WSKBDIO_GETLEDS: 206 *(int *)data = 0; 207 return 0; 208 case WSKBDIO_COMPLEXBELL: 209 return 0; 210 } 211 return EPASSTHROUGH; 212 } 213
Indexes created Sat Sep 20 22:09:52 GMT 2025