Annotation of sys/dev/isa/aps.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: aps.c,v 1.15 2007/05/19 19:14:11 tedu Exp $ */
! 2: /*
! 3: * Copyright (c) 2005 Jonathan Gray <jsg@openbsd.org>
! 4: *
! 5: * Permission to use, copy, modify, and distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 16: */
! 17:
! 18: /*
! 19: * A driver for the ThinkPad Active Protection System based on notes from
! 20: * http://www.almaden.ibm.com/cs/people/marksmith/tpaps.html
! 21: */
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/systm.h>
! 25: #include <sys/device.h>
! 26: #include <sys/kernel.h>
! 27: #include <sys/sensors.h>
! 28: #include <sys/timeout.h>
! 29: #include <machine/bus.h>
! 30:
! 31: #include <dev/isa/isareg.h>
! 32: #include <dev/isa/isavar.h>
! 33:
! 34: #if defined(APSDEBUG)
! 35: #define DPRINTF(x) do { printf x; } while (0)
! 36: #else
! 37: #define DPRINTF(x)
! 38: #endif
! 39:
! 40: #define APS_ACCEL_STATE 0x04
! 41: #define APS_INIT 0x10
! 42: #define APS_STATE 0x11
! 43: #define APS_XACCEL 0x12
! 44: #define APS_YACCEL 0x14
! 45: #define APS_TEMP 0x16
! 46: #define APS_XVAR 0x17
! 47: #define APS_YVAR 0x19
! 48: #define APS_TEMP2 0x1b
! 49: #define APS_UNKNOWN 0x1c
! 50: #define APS_INPUT 0x1d
! 51: #define APS_CMD 0x1f
! 52:
! 53: #define APS_STATE_NEWDATA 0x50
! 54:
! 55: #define APS_CMD_START 0x01
! 56:
! 57: #define APS_INPUT_KB (1 << 5)
! 58: #define APS_INPUT_MS (1 << 6)
! 59: #define APS_INPUT_LIDOPEN (1 << 7)
! 60:
! 61: #define APS_ADDR_SIZE 0x1f
! 62:
! 63: struct sensor_rec {
! 64: u_int8_t state;
! 65: u_int16_t x_accel;
! 66: u_int16_t y_accel;
! 67: u_int8_t temp1;
! 68: u_int16_t x_var;
! 69: u_int16_t y_var;
! 70: u_int8_t temp2;
! 71: u_int8_t unk;
! 72: u_int8_t input;
! 73: };
! 74:
! 75: #define APS_NUM_SENSORS 9
! 76:
! 77: #define APS_SENSOR_XACCEL 0
! 78: #define APS_SENSOR_YACCEL 1
! 79: #define APS_SENSOR_XVAR 2
! 80: #define APS_SENSOR_YVAR 3
! 81: #define APS_SENSOR_TEMP1 4
! 82: #define APS_SENSOR_TEMP2 5
! 83: #define APS_SENSOR_KBACT 6
! 84: #define APS_SENSOR_MSACT 7
! 85: #define APS_SENSOR_LIDOPEN 8
! 86:
! 87: struct aps_softc {
! 88: struct device sc_dev;
! 89:
! 90: bus_space_tag_t aps_iot;
! 91: bus_space_handle_t aps_ioh;
! 92:
! 93: struct ksensor sensors[APS_NUM_SENSORS];
! 94: struct ksensordev sensordev;
! 95: void (*refresh_sensor_data)(struct aps_softc *);
! 96:
! 97: struct sensor_rec aps_data;
! 98: };
! 99:
! 100: int aps_match(struct device *, void *, void *);
! 101: void aps_attach(struct device *, struct device *, void *);
! 102:
! 103: int aps_init(bus_space_tag_t, bus_space_handle_t);
! 104: u_int8_t aps_mem_read_1(bus_space_tag_t, bus_space_handle_t, int, u_int8_t);
! 105: int aps_read_data(struct aps_softc *);
! 106: void aps_refresh_sensor_data(struct aps_softc *sc);
! 107: void aps_refresh(void *);
! 108: void aps_power(int, void *);
! 109:
! 110: struct cfattach aps_ca = {
! 111: sizeof(struct aps_softc),
! 112: aps_match,
! 113: aps_attach
! 114: };
! 115:
! 116: struct cfdriver aps_cd = {
! 117: NULL, "aps", DV_DULL
! 118: };
! 119:
! 120: struct timeout aps_timeout;
! 121:
! 122: int
! 123: aps_match(struct device *parent, void *match, void *aux)
! 124: {
! 125: bus_space_tag_t iot;
! 126: bus_space_handle_t ioh;
! 127: struct isa_attach_args *ia = aux;
! 128: int iobase, i;
! 129: u_int8_t cr;
! 130:
! 131: iot = ia->ia_iot;
! 132: iobase = ia->ipa_io[0].base;
! 133:
! 134: if (bus_space_map(iot, iobase, APS_ADDR_SIZE, 0, &ioh)) {
! 135: DPRINTF(("aps: can't map i/o space\n"));
! 136: return (0);
! 137: }
! 138:
! 139: /* See if this machine has APS */
! 140: bus_space_write_1(iot, ioh, APS_INIT, 0x13);
! 141: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 142:
! 143: /* ask again as the X40 is slightly deaf in one ear */
! 144: bus_space_read_1(iot, ioh, APS_CMD);
! 145: bus_space_write_1(iot, ioh, APS_INIT, 0x13);
! 146: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 147:
! 148: if (!aps_mem_read_1(iot, ioh, APS_CMD, 0x00)) {
! 149: bus_space_unmap(iot, ioh, APS_ADDR_SIZE);
! 150: return (0);
! 151: }
! 152:
! 153: /*
! 154: * Observed values from Linux driver:
! 155: * 0x01: T42
! 156: * 0x02: chip already initialised
! 157: * 0x03: T41
! 158: */
! 159: for (i = 0; i < 10; i++) {
! 160: cr = bus_space_read_1(iot, ioh, APS_STATE);
! 161: if (cr > 0 && cr < 6)
! 162: break;
! 163: delay(5 * 1000);
! 164: }
! 165:
! 166: bus_space_unmap(iot, ioh, APS_ADDR_SIZE);
! 167: DPRINTF(("aps: state register 0x%x\n", cr));
! 168: if (cr < 1 || cr > 5) {
! 169: DPRINTF(("aps0: unsupported state %d\n", cr));
! 170: return (0);
! 171: }
! 172:
! 173: ia->ipa_nio = 1;
! 174: ia->ipa_io[0].length = APS_ADDR_SIZE;
! 175: ia->ipa_nmem = 0;
! 176: ia->ipa_nirq = 0;
! 177: ia->ipa_ndrq = 0;
! 178:
! 179: return (1);
! 180: }
! 181:
! 182: void
! 183: aps_attach(struct device *parent, struct device *self, void *aux)
! 184: {
! 185: struct aps_softc *sc = (void *)self;
! 186: int iobase, i;
! 187: bus_space_tag_t iot;
! 188: bus_space_handle_t ioh;
! 189: struct isa_attach_args *ia = aux;
! 190:
! 191: iobase = ia->ipa_io[0].base;
! 192: iot = sc->aps_iot = ia->ia_iot;
! 193:
! 194: if (bus_space_map(iot, iobase, APS_ADDR_SIZE, 0, &sc->aps_ioh)) {
! 195: printf(": can't map i/o space\n");
! 196: return;
! 197: }
! 198:
! 199: ioh = sc->aps_ioh;
! 200:
! 201: printf("\n");
! 202:
! 203: if (!aps_init(iot, ioh))
! 204: goto out;
! 205:
! 206: sc->sensors[APS_SENSOR_XACCEL].type = SENSOR_INTEGER;
! 207: snprintf(sc->sensors[APS_SENSOR_XACCEL].desc,
! 208: sizeof(sc->sensors[APS_SENSOR_XACCEL].desc), "X_ACCEL");
! 209:
! 210: sc->sensors[APS_SENSOR_YACCEL].type = SENSOR_INTEGER;
! 211: snprintf(sc->sensors[APS_SENSOR_YACCEL].desc,
! 212: sizeof(sc->sensors[APS_SENSOR_YACCEL].desc), "Y_ACCEL");
! 213:
! 214: sc->sensors[APS_SENSOR_TEMP1].type = SENSOR_TEMP;
! 215: sc->sensors[APS_SENSOR_TEMP2].type = SENSOR_TEMP;
! 216:
! 217: sc->sensors[APS_SENSOR_XVAR].type = SENSOR_INTEGER;
! 218: snprintf(sc->sensors[APS_SENSOR_XVAR].desc,
! 219: sizeof(sc->sensors[APS_SENSOR_XVAR].desc), "X_VAR");
! 220:
! 221: sc->sensors[APS_SENSOR_YVAR].type = SENSOR_INTEGER;
! 222: snprintf(sc->sensors[APS_SENSOR_YVAR].desc,
! 223: sizeof(sc->sensors[APS_SENSOR_YVAR].desc), "Y_VAR");
! 224:
! 225: sc->sensors[APS_SENSOR_KBACT].type = SENSOR_INDICATOR;
! 226: snprintf(sc->sensors[APS_SENSOR_KBACT].desc,
! 227: sizeof(sc->sensors[APS_SENSOR_KBACT].desc), "Keyboard Active");
! 228:
! 229: sc->sensors[APS_SENSOR_MSACT].type = SENSOR_INDICATOR;
! 230: snprintf(sc->sensors[APS_SENSOR_MSACT].desc,
! 231: sizeof(sc->sensors[APS_SENSOR_MSACT].desc), "Mouse Active");
! 232:
! 233: sc->sensors[APS_SENSOR_LIDOPEN].type = SENSOR_INDICATOR;
! 234: snprintf(sc->sensors[APS_SENSOR_LIDOPEN].desc,
! 235: sizeof(sc->sensors[APS_SENSOR_LIDOPEN].desc), "Lid Open");
! 236:
! 237: /* stop hiding and report to the authorities */
! 238: strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname,
! 239: sizeof(sc->sensordev.xname));
! 240: for (i = 0; i < APS_NUM_SENSORS ; i++) {
! 241: sensor_attach(&sc->sensordev, &sc->sensors[i]);
! 242: }
! 243: sensordev_install(&sc->sensordev);
! 244:
! 245: powerhook_establish(aps_power, (void *)sc);
! 246:
! 247: /* Refresh sensor data every 0.5 seconds */
! 248: timeout_set(&aps_timeout, aps_refresh, sc);
! 249: timeout_add(&aps_timeout, (5 * hz) / 10);
! 250: return;
! 251: out:
! 252: printf("%s: failed to initialise\n", sc->sc_dev.dv_xname);
! 253: return;
! 254: }
! 255:
! 256: int
! 257: aps_init(bus_space_tag_t iot, bus_space_handle_t ioh)
! 258: {
! 259: bus_space_write_1(iot, ioh, APS_INIT, 0x17);
! 260: bus_space_write_1(iot, ioh, APS_STATE, 0x81);
! 261: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 262: if (!aps_mem_read_1(iot, ioh, APS_CMD, 0x00))
! 263: return (0);
! 264: if (!aps_mem_read_1(iot, ioh, APS_STATE, 0x00))
! 265: return (0);
! 266: if (!aps_mem_read_1(iot, ioh, APS_XACCEL, 0x60))
! 267: return (0);
! 268: if (!aps_mem_read_1(iot, ioh, APS_XACCEL + 1, 0x00))
! 269: return (0);
! 270: bus_space_write_1(iot, ioh, APS_INIT, 0x14);
! 271: bus_space_write_1(iot, ioh, APS_STATE, 0x01);
! 272: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 273: if (!aps_mem_read_1(iot, ioh, APS_CMD, 0x00))
! 274: return (0);
! 275: bus_space_write_1(iot, ioh, APS_INIT, 0x10);
! 276: bus_space_write_1(iot, ioh, APS_STATE, 0xc8);
! 277: bus_space_write_1(iot, ioh, APS_XACCEL, 0x00);
! 278: bus_space_write_1(iot, ioh, APS_XACCEL + 1, 0x02);
! 279: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 280: if (!aps_mem_read_1(iot, ioh, APS_CMD, 0x00))
! 281: return (0);
! 282: /* refresh data */
! 283: bus_space_write_1(iot, ioh, APS_INIT, 0x11);
! 284: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 285: if (!aps_mem_read_1(iot, ioh, APS_ACCEL_STATE, 0x50))
! 286: return (0);
! 287: if (!aps_mem_read_1(iot, ioh, APS_STATE, 0x00))
! 288: return (0);
! 289:
! 290: return (1);
! 291: }
! 292:
! 293: u_int8_t
! 294: aps_mem_read_1(bus_space_tag_t iot, bus_space_handle_t ioh, int reg,
! 295: u_int8_t val)
! 296: {
! 297: int i;
! 298: u_int8_t cr;
! 299: /* should take no longer than 50 microseconds */
! 300: for (i = 0; i < 10; i++) {
! 301: cr = bus_space_read_1(iot, ioh, reg);
! 302: if (cr == val)
! 303: return (1);
! 304: delay(5 * 1000);
! 305: }
! 306: DPRINTF(("aps: reg 0x%x not val 0x%x!\n", reg, val));
! 307: return (0);
! 308: }
! 309:
! 310: int
! 311: aps_read_data(struct aps_softc *sc)
! 312: {
! 313: bus_space_tag_t iot = sc->aps_iot;
! 314: bus_space_handle_t ioh = sc->aps_ioh;
! 315:
! 316: sc->aps_data.state = bus_space_read_1(iot, ioh, APS_STATE);
! 317: sc->aps_data.x_accel = bus_space_read_2(iot, ioh, APS_XACCEL);
! 318: sc->aps_data.y_accel = bus_space_read_2(iot, ioh, APS_YACCEL);
! 319: sc->aps_data.temp1 = bus_space_read_1(iot, ioh, APS_TEMP);
! 320: sc->aps_data.x_var = bus_space_read_2(iot, ioh, APS_XVAR);
! 321: sc->aps_data.y_var = bus_space_read_2(iot, ioh, APS_YVAR);
! 322: sc->aps_data.temp2 = bus_space_read_1(iot, ioh, APS_TEMP2);
! 323: sc->aps_data.input = bus_space_read_1(iot, ioh, APS_INPUT);
! 324:
! 325: return (1);
! 326: }
! 327:
! 328: void
! 329: aps_refresh_sensor_data(struct aps_softc *sc)
! 330: {
! 331: bus_space_tag_t iot = sc->aps_iot;
! 332: bus_space_handle_t ioh = sc->aps_ioh;
! 333: int64_t temp;
! 334: int i;
! 335:
! 336: /* ask for new data */
! 337: bus_space_write_1(iot, ioh, APS_INIT, 0x11);
! 338: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 339: if (!aps_mem_read_1(iot, ioh, APS_ACCEL_STATE, 0x50))
! 340: return;
! 341: aps_read_data(sc);
! 342: bus_space_write_1(iot, ioh, APS_INIT, 0x11);
! 343: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 344:
! 345: /* tell accelerometer we're done reading from it */
! 346: bus_space_read_1(iot, ioh, APS_CMD);
! 347: bus_space_read_1(iot, ioh, APS_ACCEL_STATE);
! 348:
! 349: for (i = 0; i < APS_NUM_SENSORS; i++) {
! 350: sc->sensors[i].flags &= ~SENSOR_FINVALID;
! 351: }
! 352:
! 353: sc->sensors[APS_SENSOR_XACCEL].value = sc->aps_data.x_accel;
! 354: sc->sensors[APS_SENSOR_YACCEL].value = sc->aps_data.y_accel;
! 355:
! 356: /* convert to micro (mu) degrees */
! 357: temp = sc->aps_data.temp1 * 1000000;
! 358: /* convert to kelvin */
! 359: temp += 273150000;
! 360: sc->sensors[APS_SENSOR_TEMP1].value = temp;
! 361:
! 362: /* convert to micro (mu) degrees */
! 363: temp = sc->aps_data.temp2 * 1000000;
! 364: /* convert to kelvin */
! 365: temp += 273150000;
! 366: sc->sensors[APS_SENSOR_TEMP2].value = temp;
! 367:
! 368: sc->sensors[APS_SENSOR_XVAR].value = sc->aps_data.x_var;
! 369: sc->sensors[APS_SENSOR_YVAR].value = sc->aps_data.y_var;
! 370: sc->sensors[APS_SENSOR_KBACT].value =
! 371: (sc->aps_data.input & APS_INPUT_KB) ? 1 : 0;
! 372: sc->sensors[APS_SENSOR_MSACT].value =
! 373: (sc->aps_data.input & APS_INPUT_MS) ? 1 : 0;
! 374: sc->sensors[APS_SENSOR_LIDOPEN].value =
! 375: (sc->aps_data.input & APS_INPUT_LIDOPEN) ? 1 : 0;
! 376: }
! 377:
! 378: void
! 379: aps_refresh(void *arg)
! 380: {
! 381: struct aps_softc *sc = (struct aps_softc *)arg;
! 382:
! 383: aps_refresh_sensor_data(sc);
! 384: timeout_add(&aps_timeout, (5 * hz) / 10);
! 385: }
! 386:
! 387: void
! 388: aps_power(int why, void *arg)
! 389: {
! 390: struct aps_softc *sc = (struct aps_softc *)arg;
! 391: bus_space_tag_t iot = sc->aps_iot;
! 392: bus_space_handle_t ioh = sc->aps_ioh;
! 393:
! 394: if (why != PWR_RESUME) {
! 395: if (timeout_pending(&aps_timeout))
! 396: timeout_del(&aps_timeout);
! 397: } else {
! 398: /*
! 399: * Redo the init sequence on resume, because APS is
! 400: * as forgetful as it is deaf.
! 401: */
! 402: bus_space_write_1(iot, ioh, APS_INIT, 0x13);
! 403: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 404: bus_space_read_1(iot, ioh, APS_CMD);
! 405: bus_space_write_1(iot, ioh, APS_INIT, 0x13);
! 406: bus_space_write_1(iot, ioh, APS_CMD, 0x01);
! 407:
! 408: if (aps_mem_read_1(iot, ioh, APS_CMD, 0x00) &&
! 409: aps_init(iot, ioh))
! 410: timeout_add(&aps_timeout, (5 * hz) / 10);
! 411: else
! 412: printf("aps: failed to wake up\n");
! 413: }
! 414: }
! 415:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to aps.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa