Annotation of sys/arch/macppc/dev/tpms.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: tpms.c,v 1.12 2007/06/14 10:11:16 mbalmer Exp $ */
2:
3: /*
4: * Copyright (c) 2005, Johan Wallén
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 are
9: * met:
10: *
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: *
14: * 2. Redistributions in binary form must reproduce the above
15: * copyright notice, this list of conditions and the following
16: * disclaimer in the documentation and/or other materials provided
17: * with the distribution.
18: *
19: * 3. The name of the copyright holder may not be used to endorse or
20: * promote products derived from this software without specific
21: * prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
24: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE
27: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: /*
37: * The tpms driver provides support for the trackpad on new (post
38: * February 2005) Apple PowerBooks (and iBooks?) that are not standard
39: * USB HID mice.
40: */
41:
42: /*
43: * The protocol (that is, the interpretation of the data generated by
44: * the trackpad) is taken from the Linux appletouch driver version
45: * 0.08 by Johannes Berg, Stelian Pop and Frank Arnold. The method
46: * used to detect fingers on the trackpad is also taken from that
47: * driver.
48: */
49:
50: /*
51: * PROTOCOL:
52: *
53: * The driver transfers continuously 81 byte events. The last byte is
54: * 1 if the button is pressed, and is 0 otherwise. Of the remaining
55: * bytes, 26 + 16 = 42 are sensors detecting pressure in the X or
56: * horizontal, and Y or vertical directions, respectively. On 12 and
57: * 15 inch PowerBooks, only the 16 first sensors in the X-direction
58: * are used. In the X-direction, the sensors correspond to byte
59: * positions
60: *
61: * 2, 7, 12, 17, 22, 27, 32, 37, 4, 9, 14, 19, 24, 29, 34, 39, 42,
62: * 47, 52, 57, 62, 67, 72, 77, 44 and 49;
63: *
64: * in the Y direction, the sensors correspond to byte positions
65: *
66: * 1, 6, 11, 16, 21, 26, 31, 36, 3, 8, 13, 18, 23, 28, 33 and 38.
67: *
68: * The change in the sensor values over time is more interesting than
69: * their absolute values: if the pressure increases, we know that the
70: * finger has just moved there.
71: *
72: * We keep track of the previous sample (of sensor values in the X and
73: * Y directions) and the accumulated change for each sensor. When we
74: * receive a new sample, we add the difference of the new sensor value
75: * and the old value to the accumulated change. If the accumulator
76: * becomes negative, we set it to zero. The effect is that the
77: * accumulator is large for sensors whose pressure has recently
78: * increased. If there is little change in pressure (or if the
79: * pressure decreases), the accumulator drifts back to zero.
80: *
81: * Since there is some fluctuations, we ignore accumulator values
82: * below a threshold. The raw finger position is computed as a
83: * weighted average of the other sensors (the weights are the
84: * accumulated changes).
85: *
86: * For smoothing, we keep track of the previous raw finger position,
87: * and the virtual position reported to wsmouse. The new raw position
88: * is computed as a weighted average of the old raw position and the
89: * computed raw position. Since this still generates some noise, we
90: * compute a new virtual position as a weighted average of the previous
91: * virtual position and the new raw position. The weights are
92: * controlled by the raw change and a noise parameter. The position
93: * is reported as a relative position.
94: */
95:
96: /*
97: * TODO:
98: *
99: * Add support for other drivers of the same type.
100: *
101: * Add support for tapping and two-finger scrolling? The
102: * implementation already detects two fingers, so this should be
103: * relatively easy.
104: *
105: * Implement some of the mouse ioctls?
106: *
107: * Take care of the XXXs.
108: *
109: */
110:
111: #include <sys/param.h>
112: #include <sys/device.h>
113: #include <sys/errno.h>
114:
115: #include <sys/ioctl.h>
116: #include <sys/systm.h>
117: #include <sys/tty.h>
118:
119: #include <dev/usb/usb.h>
120: #include <dev/usb/usbdi.h>
121: #include <dev/usb/usbdevs.h>
122: #include <dev/usb/uhidev.h>
123:
124: #include <dev/wscons/wsconsio.h>
125: #include <dev/wscons/wsmousevar.h>
126:
127: /*
128: * Debugging output.
129: */
130:
131: /* XXX Should be redone, and its use should be added back. */
132:
133: #ifdef TPMS_DEBUG
134:
135: /*
136: * Print the error message (preceded by the driver and function)
137: * specified by the string literal fmt (followed by newline) if
138: * tpmsdebug is greater than n. The macro may only be used in the
139: * scope of sc, which must be castable to struct device *. There must
140: * be at least one vararg. Do not define TPMS_DEBUG on non-C99
141: * compilers.
142: */
143:
144: #define DPRINTFN(n, fmt, ...) \
145: do { \
146: if (tpmsdebug > (n)) \
147: logprintf("%s: %s: " fmt "\n", \
148: ((struct device *) sc)->dv_xname, \
149: __func__, __VA_ARGS__); \
150: } while ( /* CONSTCOND */ 0)
151:
152: int tpmsdebug = 0;
153:
154: #endif /* TPMS_DEBUG */
155:
156: /*
157: * Magic numbers.
158: */
159:
160: /* The amount of data transfered by the USB device. */
161: #define TPMS_DATA_LEN 81
162:
163: /* The maximum number of sensors. */
164: #define TPMS_X_SENSORS 26
165: #define TPMS_Y_SENSORS 16
166: #define TPMS_SENSORS (TPMS_X_SENSORS + TPMS_Y_SENSORS)
167:
168: /*
169: * Parameters for supported devices. For generality, these parameters
170: * can be different for each device. The meanings of the parameters
171: * are as follows.
172: *
173: * desc: A printable description used for dmesg output.
174: *
175: * noise: Amount of noise in the computed position. This controls
176: * how large a change must be to get reported, and how
177: * large enough changes are smoothed. A good value can
178: * probably only be found experimentally, but something around
179: * 16 seems suitable.
180: *
181: * product: The product ID of the trackpad.
182: *
183: *
184: * threshold: Accumulated changes less than this are ignored. A good
185: * value could be determined experimentally, but 5 is a
186: * reasonable guess.
187: *
188: * vendor: The vendor ID. Currently USB_VENDOR_APPLE for all devices.
189: *
190: * x_factor: Factor used in computations with X-coordinates. If the
191: * x-resolution of the display is x, this should be
192: * (x + 1) / (x_sensors - 1). Other values work fine, but
193: * then the aspect ratio is not necessarily kept.
194: *
195: * x_sensors: The number of sensors in the X-direction.
196: *
197: * y_factor: As x_factors, but for Y-coordinates.
198: *
199: * y_sensors: The number of sensors in the Y-direction.
200: */
201:
202: struct tpms_dev {
203: const char *descr; /* Description of the driver (for dmesg). */
204: int noise; /* Amount of noise in the computed position. */
205: int threshold; /* Changes less than this are ignored. */
206: int x_factor; /* Factor used in computation with X-coordinates. */
207: int x_sensors; /* The number of X-sensors. */
208: int y_factor; /* Factor used in computation with Y-coordinates. */
209: int y_sensors; /* The number of Y-sensors. */
210: uint16_t product; /* Product ID. */
211: uint16_t vendor; /* The vendor ID. */
212: };
213:
214: /* Devices supported by this driver. */
215: static struct tpms_dev tpms_devices[] =
216: {
217: #define POWERBOOK_TOUCHPAD(inches, prod, x_fact, x_sens, y_fact) \
218: { \
219: .descr = #inches " inch PowerBook Trackpad", \
220: .vendor = USB_VENDOR_APPLE, \
221: .product = (prod), \
222: .noise = 16, \
223: .threshold = 5, \
224: .x_factor = (x_fact), \
225: .x_sensors = (x_sens), \
226: .y_factor = (y_fact), \
227: .y_sensors = 16 \
228: }
229: /* 12 inch PowerBooks */
230: POWERBOOK_TOUCHPAD(12, 0x030a, 69, 16, 52), /* XXX Not tested. */
231: /* 14 inch iBook G4 */
232: POWERBOOK_TOUCHPAD(14, 0x030b, 69, 16, 52),
233: /* 15 inch PowerBooks */
234: POWERBOOK_TOUCHPAD(15, 0x020e, 85, 16, 57), /* XXX Not tested. */
235: POWERBOOK_TOUCHPAD(15, 0x020f, 85, 16, 57),
236: /* 17 inch PowerBooks */
237: POWERBOOK_TOUCHPAD(17, 0x020d, 71, 26, 68) /* XXX Not tested. */
238: #undef POWERBOOK_TOUCHPAD
239: };
240:
241: /* The number of supported devices. */
242: #define TPMS_NUM_DEVICES (sizeof(tpms_devices) / sizeof(tpms_devices[0]))
243:
244: /*
245: * Types and prototypes.
246: */
247:
248: /* Device data. */
249: struct tpms_softc {
250: struct uhidev sc_hdev; /* USB parent (got the struct device). */
251: int sc_acc[TPMS_SENSORS]; /* Accumulated sensor values. */
252: signed char sc_prev[TPMS_SENSORS]; /* Previous sample. */
253: signed char sc_sample[TPMS_SENSORS]; /* Current sample. */
254: struct device *sc_wsmousedev; /* WSMouse device. */
255: int sc_noise; /* Amount of noise. */
256: int sc_threshold; /* Threshold value. */
257: int sc_x; /* Virtual position in horizontal
258: * direction (wsmouse position). */
259: int sc_x_factor; /* X-coordinate factor. */
260: int sc_x_raw; /* X-position of finger on trackpad. */
261: int sc_x_sensors; /* Number of X-sensors. */
262: int sc_y; /* Virtual position in vertical direction
263: * (wsmouse position). */
264: int sc_y_factor; /* Y-coordinate factor. */
265: int sc_y_raw; /* Y-position of finger on trackpad. */
266: int sc_y_sensors; /* Number of Y-sensors. */
267: uint32_t sc_buttons; /* Button state. */
268: uint32_t sc_status; /* Status flags. */
269: #define TPMS_ENABLED 1 /* Is the device enabled? */
270: #define TPMS_DYING 2 /* Is the device dying? */
271: #define TPMS_VALID 4 /* Is the previous sample valid? */
272: };
273:
274: void tpms_intr(struct uhidev *, void *, unsigned int);
275: int tpms_enable(void *);
276: void tpms_disable(void *);
277: int tpms_ioctl(void *, unsigned long, caddr_t, int, struct proc *);
278: void reorder_sample(signed char *, signed char *);
279: int compute_delta(struct tpms_softc *, int *, int *, int *, uint32_t *);
280: int detect_pos(int *, int, int, int, int *, int *);
281: int smooth_pos(int, int, int);
282:
283: /* Access methods for wsmouse. */
284: const struct wsmouse_accessops tpms_accessops = {
285: tpms_enable,
286: tpms_ioctl,
287: tpms_disable,
288: };
289:
290: /* This take cares also of the basic device registration. */
291: int tpms_match(struct device *, void *, void *);
292: void tpms_attach(struct device *, struct device *, void *);
293: int tpms_detach(struct device *, int);
294: int tpms_activate(struct device *, enum devact);
295:
296: struct cfdriver tpms_cd = {
297: NULL, "tpms", DV_DULL
298: };
299:
300: const struct cfattach tpms_ca = {
301: sizeof(struct tpms_softc),
302: tpms_match,
303: tpms_attach,
304: tpms_detach,
305: tpms_activate,
306: };
307:
308: /*
309: * Basic driver.
310: */
311:
312: /* Try to match the device at some uhidev. */
313:
314: int
315: tpms_match(struct device *parent, void *match, void *aux)
316: {
317: struct usb_attach_arg *uaa = aux;
318: struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
319: usb_device_descriptor_t *udd;
320: int i;
321: uint16_t vendor, product;
322:
323: /*
324: * We just check if the vendor and product IDs have the magic numbers
325: * we expect.
326: */
327: if ((udd = usbd_get_device_descriptor(uha->parent->sc_udev)) != NULL) {
328: vendor = UGETW(udd->idVendor);
329: product = UGETW(udd->idProduct);
330: for (i = 0; i < TPMS_NUM_DEVICES; i++) {
331: if (vendor == tpms_devices[i].vendor &&
332: product == tpms_devices[i].product)
333: return (UMATCH_IFACECLASS);
334: }
335: }
336:
337: return (UMATCH_NONE);
338: }
339:
340:
341: /* Attach the device. */
342:
343: void
344: tpms_attach(struct device *parent, struct device *self, void *aux)
345: {
346: struct tpms_softc *sc = (struct tpms_softc *)self;
347: struct usb_attach_arg *uaa = aux;
348: struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
349: struct wsmousedev_attach_args a;
350: struct tpms_dev *pd;
351: usb_device_descriptor_t *udd;
352: int i;
353: uint16_t vendor, product;
354:
355: /* Fill in device-specific parameters. */
356: if ((udd = usbd_get_device_descriptor(uha->parent->sc_udev)) != NULL) {
357: product = UGETW(udd->idProduct);
358: vendor = UGETW(udd->idVendor);
359: for (i = 0; i < TPMS_NUM_DEVICES; i++) {
360: pd = &tpms_devices[i];
361: if (product == pd->product && vendor == pd->vendor) {
362: printf(": %s\n", pd->descr);
363: sc->sc_noise = pd->noise;
364: sc->sc_threshold = pd->threshold;
365: sc->sc_x_factor = pd->x_factor;
366: sc->sc_x_sensors = pd->x_sensors;
367: sc->sc_y_factor = pd->y_factor;
368: sc->sc_y_sensors = pd->y_sensors;
369: break;
370: }
371: }
372: }
373: if (sc->sc_x_sensors <= 0 || sc->sc_x_sensors > TPMS_X_SENSORS ||
374: sc->sc_y_sensors <= 0 || sc->sc_y_sensors > TPMS_Y_SENSORS) {
375: printf(": unexpected sensors configuration (%d:%d)\n",
376: sc->sc_x_sensors, sc->sc_y_sensors);
377: return;
378: }
379:
380: sc->sc_hdev.sc_intr = tpms_intr;
381: sc->sc_hdev.sc_parent = uha->parent;
382: sc->sc_hdev.sc_report_id = uha->reportid;
383:
384: sc->sc_status = 0;
385:
386: a.accessops = &tpms_accessops;
387: a.accesscookie = sc;
388: sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint);
389: }
390:
391: /* Detach the device. */
392:
393: int
394: tpms_detach(struct device *self, int flags)
395: {
396: struct tpms_softc *sc = (struct tpms_softc *)self;
397: int ret;
398:
399: /* The wsmouse driver does all the work. */
400: ret = 0;
401: if (sc->sc_wsmousedev != NULL)
402: ret = config_detach(sc->sc_wsmousedev, flags);
403:
404: return (ret);
405: }
406:
407: /* Activate the device. */
408:
409: int
410: tpms_activate(struct device *self, enum devact act)
411: {
412: struct tpms_softc *sc = (struct tpms_softc *)self;
413: int ret;
414:
415: if (act == DVACT_DEACTIVATE) {
416: ret = 0;
417: if (sc->sc_wsmousedev != NULL)
418: ret = config_deactivate(sc->sc_wsmousedev);
419: sc->sc_status |= TPMS_DYING;
420: return (ret);
421: }
422: return (EOPNOTSUPP);
423: }
424:
425:
426: /* Enable the device. */
427:
428: int
429: tpms_enable(void *v)
430: {
431: struct tpms_softc *sc = v;
432:
433: /* Check that we are not detaching or already enabled. */
434: if (sc->sc_status & TPMS_DYING)
435: return (EIO);
436: if (sc->sc_status & TPMS_ENABLED)
437: return (EBUSY);
438:
439: sc->sc_status |= TPMS_ENABLED;
440: sc->sc_status &= ~TPMS_VALID;
441: sc->sc_buttons = 0;
442: memset(sc->sc_sample, 0, sizeof(sc->sc_sample));
443:
444: return (uhidev_open(&sc->sc_hdev));
445: }
446:
447: /* Disable the device. */
448:
449: void
450: tpms_disable(void *v)
451: {
452: struct tpms_softc *sc = v;
453:
454: if (!(sc->sc_status & TPMS_ENABLED))
455: return;
456:
457: sc->sc_status &= ~TPMS_ENABLED;
458: uhidev_close(&sc->sc_hdev);
459: }
460:
461: int
462: tpms_ioctl(void *v, unsigned long cmd, caddr_t data, int flag, struct proc *p)
463: {
464: switch (cmd) {
465: case WSMOUSEIO_GTYPE:
466: *(u_int *)data = WSMOUSE_TYPE_TPANEL;
467: return (0);
468: }
469:
470: return (-1);
471: }
472:
473: /*
474: * Interrupts & pointer movement.
475: */
476:
477: /* Handle interrupts. */
478:
479: void
480: tpms_intr(struct uhidev *addr, void *ibuf, unsigned int len)
481: {
482: struct tpms_softc *sc = (struct tpms_softc *)addr;
483: signed char *data;
484: int dx, dy, dz, i, s;
485: uint32_t buttons;
486:
487: /* Ignore incomplete data packets. */
488: if (len != TPMS_DATA_LEN)
489: return;
490: data = ibuf;
491:
492: /* The last byte is 1 if the button is pressed and 0 otherwise. */
493: buttons = !!data[TPMS_DATA_LEN - 1];
494:
495: /* Everything below assumes that the sample is reordered. */
496: reorder_sample(sc->sc_sample, data);
497:
498: /* Is this the first sample? */
499: if (!(sc->sc_status & TPMS_VALID)) {
500: sc->sc_status |= TPMS_VALID;
501: sc->sc_x = sc->sc_y = -1;
502: sc->sc_x_raw = sc->sc_y_raw = -1;
503: memcpy(sc->sc_prev, sc->sc_sample, sizeof(sc->sc_prev));
504: memset(sc->sc_acc, 0, sizeof(sc->sc_acc));
505: return;
506: }
507: /* Accumulate the sensor change while keeping it nonnegative. */
508: for (i = 0; i < TPMS_SENSORS; i++) {
509: sc->sc_acc[i] += sc->sc_sample[i] - sc->sc_prev[i];
510: if (sc->sc_acc[i] < 0)
511: sc->sc_acc[i] = 0;
512: }
513: memcpy(sc->sc_prev, sc->sc_sample, sizeof(sc->sc_prev));
514:
515: /* Compute change. */
516: dx = dy = dz = 0;
517: if (!compute_delta(sc, &dx, &dy, &dz, &buttons))
518: return;
519:
520: /* Report to wsmouse. */
521: if ((dx != 0 || dy != 0 || dz != 0 || buttons != sc->sc_buttons) &&
522: sc->sc_wsmousedev != NULL) {
523: s = spltty();
524: wsmouse_input(sc->sc_wsmousedev, buttons, dx, -dy, dz, 0,
525: WSMOUSE_INPUT_DELTA);
526: splx(s);
527: }
528: sc->sc_buttons = buttons;
529: }
530:
531: /*
532: * Reorder the sensor values so that all the X-sensors are before the
533: * Y-sensors in the natural order. Note that this might have to be
534: * rewritten if TPMS_X_SENSORS or TPMS_Y_SENSORS change.
535: */
536:
537: void
538: reorder_sample(signed char *to, signed char *from)
539: {
540: int i;
541:
542: for (i = 0; i < 8; i++) {
543: /* X-sensors. */
544: to[i] = from[5 * i + 2];
545: to[i + 8] = from[5 * i + 4];
546: to[i + 16] = from[5 * i + 42];
547: #if 0
548: /*
549: * XXX This seems to introduce random vertical jumps, so
550: * we ignore these sensors until we figure out their meaning.
551: */
552: if (i < 2)
553: to[i + 24] = from[5 * i + 44];
554: #endif /* 0 */
555: /* Y-sensors. */
556: to[i + 26] = from[5 * i + 1];
557: to[i + 34] = from[5 * i + 3];
558: }
559: }
560:
561: /*
562: * Compute the change in x, y and z direction, update the button state
563: * (to simulate more than one button, scrolling etc.), and update the
564: * history. Note that dx, dy, dz and buttons are modified only if
565: * corresponding pressure is detected and should thus be initialised
566: * before the call. Return 0 on error.
567: */
568:
569: /* XXX Could we report something useful in dz? */
570:
571: int
572: compute_delta(struct tpms_softc *sc, int *dx, int *dy, int *dz,
573: uint32_t * buttons)
574: {
575: int x_det, y_det, x_raw, y_raw, x_fingers, y_fingers, fingers, x, y;
576:
577: x_det = detect_pos(sc->sc_acc, sc->sc_x_sensors, sc->sc_threshold,
578: sc->sc_x_factor, &x_raw, &x_fingers);
579: y_det = detect_pos(sc->sc_acc + TPMS_X_SENSORS, sc->sc_y_sensors,
580: sc->sc_threshold, sc->sc_y_factor,
581: &y_raw, &y_fingers);
582: fingers = max(x_fingers, y_fingers);
583:
584: /* Check the number of fingers and if we have detected a position. */
585: if (fingers > 1) {
586: /* More than one finger detected, resetting. */
587: memset(sc->sc_acc, 0, sizeof(sc->sc_acc));
588: sc->sc_x_raw = sc->sc_y_raw = sc->sc_x = sc->sc_y = -1;
589: return 0;
590: } else if (x_det == 0 && y_det == 0) {
591: /* No position detected, resetting. */
592: memset(sc->sc_acc, 0, sizeof(sc->sc_acc));
593: sc->sc_x_raw = sc->sc_y_raw = sc->sc_x = sc->sc_y = -1;
594: } else if (x_det > 0 && y_det > 0) {
595: /* Smooth position. */
596: if (sc->sc_x_raw >= 0) {
597: sc->sc_x_raw = (3 * sc->sc_x_raw + x_raw) / 4;
598: sc->sc_y_raw = (3 * sc->sc_y_raw + y_raw) / 4;
599: /*
600: * Compute virtual position and change if we already
601: * have a decent position.
602: */
603: if (sc->sc_x >= 0) {
604: x = smooth_pos(sc->sc_x, sc->sc_x_raw,
605: sc->sc_noise);
606: y = smooth_pos(sc->sc_y, sc->sc_y_raw,
607: sc->sc_noise);
608: *dx = x - sc->sc_x;
609: *dy = y - sc->sc_y;
610: sc->sc_x = x;
611: sc->sc_y = y;
612: } else {
613: /* Initialise virtual position. */
614: sc->sc_x = sc->sc_x_raw;
615: sc->sc_y = sc->sc_y_raw;
616: }
617: } else {
618: /* Initialise raw position. */
619: sc->sc_x_raw = x_raw;
620: sc->sc_y_raw = y_raw;
621: }
622: }
623: return (1);
624: }
625:
626: /*
627: * Compute the new smoothed position from the previous smoothed position
628: * and the raw position.
629: */
630:
631: int
632: smooth_pos(int pos_old, int pos_raw, int noise)
633: {
634: int ad, delta;
635:
636: delta = pos_raw - pos_old;
637: ad = abs(delta);
638:
639: /* Too small changes are ignored. */
640: if (ad < noise / 2)
641: delta = 0;
642: /* A bit larger changes are smoothed. */
643: else if (ad < noise)
644: delta /= 4;
645: else if (ad < 2 * noise)
646: delta /= 2;
647:
648: return (pos_old + delta);
649: }
650:
651: /*
652: * Detect the position of the finger. Returns the total pressure.
653: * The position is returned in pos_ret and the number of fingers
654: * is returned in fingers_ret. The position returned in pos_ret
655: * is in [0, (n_sensors - 1) * factor - 1].
656: */
657:
658: int
659: detect_pos(int *sensors, int n_sensors, int threshold, int fact,
660: int *pos_ret, int *fingers_ret)
661: {
662: int i, w, s;
663:
664: /*
665: * Compute the number of fingers, total pressure, and weighted
666: * position of the fingers.
667: */
668: *fingers_ret = 0;
669: w = s = 0;
670: for (i = 0; i < n_sensors; i++) {
671: if (sensors[i] >= threshold) {
672: if (i == 0 || sensors[i - 1] < threshold)
673: *fingers_ret += 1;
674: s += sensors[i];
675: w += sensors[i] * i;
676: }
677: }
678:
679: if (s > 0)
680: *pos_ret = w * fact / s;
681:
682: return (s);
683: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to tpms.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / dev