xref: /netbsd-src/sys/arch/hpcsh/dev/psh3tp.c (revision 7433666e375b3ac4cc764df5a6726be98bc1cdd5)
1 /*	$NetBSD: psh3tp.c,v 1.18 2023/12/20 14:50:02 thorpej Exp $	*/
2 /*
3  * Copyright (c) 2005 KIYOHARA Takashi
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
19  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
23  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
24  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25  * POSSIBILITY OF SUCH DAMAGE.
26  *
27  */
28 
29 #include <sys/cdefs.h>
30 
31 #include <sys/types.h>
32 #include <sys/param.h>
33 #include <sys/device.h>
34 #include <sys/errno.h>
35 #include <sys/kernel.h>
36 #include <sys/systm.h>
37 #include <sys/callout.h>
38 
39 #include "opt_psh3tp.h"
40 
41 #include <dev/wscons/wsconsio.h>
42 #include <dev/wscons/wsmousevar.h>
43 #include <dev/hpc/hpctpanelvar.h>
44 
45 #include <machine/platid.h>
46 #include <machine/platid_mask.h>
47 
48 #include <machine/intr.h>
49 
50 #include <sh3/exception.h>
51 #include <sh3/intcreg.h>
52 #include <sh3/pfcreg.h>
53 #include <sh3/adcreg.h>
54 
55 #include <sh3/dev/adcvar.h>
56 
57 
58 #ifdef PSH3TP_DEBUG
59 volatile int psh3tp_debug = 4;
60 #define DPRINTF_PRINTF		printf_nolog
61 #define DPRINTF(arg)		if (psh3tp_debug) DPRINTF_PRINTF arg
62 #define DPRINTFN(n, arg)	if (psh3tp_debug > (n)) DPRINTF_PRINTF arg
63 #else
64 #define DPRINTF(arg)		((void)0)
65 #define DPRINTFN(n, arg)	((void)0)
66 #endif
67 
68 
69 /*
70  * PFC bits pertinent to PERSONA HPW-50PA touch-panel
71  */
72 #define PHDR_TP_PEN_UP		0x40
73 #define SCPDR_TP_SCAN_ENABLE	0x20
74 #define SCPDR_TP_SCAN_DISABLE	0x01
75 #define SCPDR_TP_SCAN_X		0x06
76 #define SCPDR_TP_SCAN_Y		0x09
77 
78 /*
79  * A/D converter channels to get x/y from
80  */
81 #define ADC_CHANNEL_TP_X	1
82 #define ADC_CHANNEL_TP_Y	0
83 
84 /*
85  * Default (read: my device) raw X/Y values for framebuffer edges.
86  */
87 #define PSH3TP_FB_RIGHT		 56
88 #define PSH3TP_FB_LEFT		969
89 #define PSH3TP_FB_TOP		848
90 #define PSH3TP_FB_BOTTOM	121
91 
92 
93 struct psh3tp_softc {
94 	device_t sc_dev;
95 
96 #define PSH3TP_WSMOUSE_ENABLED	0x01
97 	int sc_enabled;
98 	struct callout sc_touch_ch;
99 	device_t sc_wsmousedev;
100 	struct tpcalib_softc sc_tpcalib; /* calibration info for wsmouse */
101 };
102 
103 
104 /* config machinery */
105 static int psh3tp_match(device_t, struct cfdata *, void *);
106 static void psh3tp_attach(device_t, device_t, void *);
107 
108 /* wsmouse accessops */
109 static int psh3tp_wsmouse_enable(void *);
110 static int psh3tp_wsmouse_ioctl(void *, u_long, void *, int, struct lwp *);
111 static void psh3tp_wsmouse_disable(void *);
112 
113 /* internal driver routines */
114 static void psh3tp_enable(struct psh3tp_softc *);
115 static void psh3tp_disable(struct psh3tp_softc *);
116 static int psh3tp_set_enable(struct psh3tp_softc *, int, int);
117 static int psh3tp_intr(void *);
118 static void psh3tp_start_polling(void *);
119 static void psh3tp_stop_polling(struct psh3tp_softc *);
120 static void psh3tp_callout_wsmouse(void *);
121 static void psh3tp_wsmouse_input(struct psh3tp_softc *, int, int);
122 static void psh3tp_get_raw_xy(int *, int *);
123 
124 
125 const struct wsmouse_accessops psh3tp_accessops = {
126 	psh3tp_wsmouse_enable,
127 	psh3tp_wsmouse_ioctl,
128 	psh3tp_wsmouse_disable
129 };
130 
131 static const struct wsmouse_calibcoords psh3tp_default_calib = {
132 	0, 0, 639, 239,
133 	4,
134 	{{ PSH3TP_FB_LEFT,  PSH3TP_FB_TOP,      0,   0 },
135 	 { PSH3TP_FB_RIGHT, PSH3TP_FB_TOP,    639,   0 },
136 	 { PSH3TP_FB_LEFT,  PSH3TP_FB_BOTTOM,   0, 239 },
137 	 { PSH3TP_FB_RIGHT, PSH3TP_FB_BOTTOM, 639, 239 }}
138 };
139 
140 
141 CFATTACH_DECL_NEW(psh3tp, sizeof(struct psh3tp_softc),
142     psh3tp_match, psh3tp_attach, NULL, NULL);
143 
144 
145 /* ARGSUSED */
146 static int
psh3tp_match(device_t parent __unused,struct cfdata * cf,void * aux __unused)147 psh3tp_match(device_t parent __unused, struct cfdata *cf, void *aux __unused)
148 {
149 
150 	if (!platid_match(&platid, &platid_mask_MACH_HITACHI_PERSONA))
151 		return 0;
152 
153 	if (strcmp(cf->cf_name, "psh3tp") != 0)
154 		return 0;
155 
156 	return 1;
157 }
158 
159 
160 /*
161  * Attach the touch panel driver and its wsmouse child.
162  *
163  * Note that we have to use submatch to distinguish between child because
164  * wsmouse_match matches unconditionally.
165  */
166 /* ARGSUSED */
167 static void
psh3tp_attach(device_t parent __unused,device_t self,void * aux __unused)168 psh3tp_attach(device_t parent __unused, device_t self, void *aux __unused)
169 {
170 	struct psh3tp_softc *sc = device_private(self);
171 	struct wsmousedev_attach_args wsma;
172 
173 	aprint_naive("\n");
174 	aprint_normal("\n");
175 
176 	sc->sc_dev = self;
177 	sc->sc_enabled = 0;
178 
179 	/* touch-panel as a pointing device */
180 	wsma.accessops = &psh3tp_accessops;
181 	wsma.accesscookie = sc;
182 
183 	sc->sc_wsmousedev = config_found(
184 	    self, &wsma, wsmousedevprint, CFARGS_NONE);
185 	if (sc->sc_wsmousedev == NULL)
186 		return;
187 
188 	/* init calibration, set default parameters */
189 	tpcalib_init(&sc->sc_tpcalib);
190 	tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS,
191 	    (void *)__UNCONST(&psh3tp_default_calib), 0, 0);
192 
193 	/* used when in polling mode */
194 	callout_init(&sc->sc_touch_ch, 0);
195 
196 	/* establish interrupt handler, but disable until opened */
197 	intc_intr_establish(SH7709_INTEVT2_IRQ2,
198 	    IST_EDGE, IPL_TTY, psh3tp_intr, sc);
199 	intc_intr_disable(SH7709_INTEVT2_IRQ2);
200 
201  	if (!pmf_device_register(self, NULL, NULL))
202  		aprint_error_dev(self, "unable to establish power handler\n");
203 }
204 
205 
206 /*
207  * Enable touch panel:  we start in interrupt mode.
208  * Must be called at spltty().
209  */
210 /* ARGSUSED */
211 static void
psh3tp_enable(struct psh3tp_softc * sc __unused)212 psh3tp_enable(struct psh3tp_softc *sc __unused)
213 {
214 
215 	DPRINTFN(2, ("%s: enable\n", device_xname(sc->sc_dev)));
216 	intc_intr_enable(SH7709_INTEVT2_IRQ2);
217 }
218 
219 
220 /*
221  * Disable touch panel: disable interrupt, cancel pending callout.
222  * Must be called at spltty().
223  */
224 static void
psh3tp_disable(struct psh3tp_softc * sc)225 psh3tp_disable(struct psh3tp_softc *sc)
226 {
227 
228 	DPRINTFN(2, ("%s: disable\n", device_xname(sc->sc_dev)));
229 	intc_intr_disable(SH7709_INTEVT2_IRQ2);
230 	callout_stop(&sc->sc_touch_ch);
231 }
232 
233 
234 static int
psh3tp_set_enable(struct psh3tp_softc * sc,int on,int child)235 psh3tp_set_enable(struct psh3tp_softc *sc, int on, int child)
236 {
237 	int s = spltty();
238 
239 	if (on) {
240 		if (!sc->sc_enabled)
241 			psh3tp_enable(sc);
242 		sc->sc_enabled |= child;
243 	} else {
244 		sc->sc_enabled &= ~child;
245 		if (!sc->sc_enabled)
246 			psh3tp_disable(sc);
247 	}
248 
249 	splx(s);
250 	return 0;
251 }
252 
253 
254 static int
psh3tp_wsmouse_enable(void * cookie)255 psh3tp_wsmouse_enable(void *cookie)
256 {
257 	struct psh3tp_softc *sc = (struct psh3tp_softc *)cookie;
258 
259 	DPRINTFN(1, ("%s: wsmouse enable\n", device_xname(sc->sc_dev)));
260 	return psh3tp_set_enable(sc, 1, PSH3TP_WSMOUSE_ENABLED);
261 }
262 
263 
264 static void
psh3tp_wsmouse_disable(void * cookie)265 psh3tp_wsmouse_disable(void *cookie)
266 {
267 	struct psh3tp_softc *sc = (struct psh3tp_softc *)cookie;
268 
269 	DPRINTFN(1, ("%s: wsmouse disable\n", device_xname(sc->sc_dev)));
270 	psh3tp_set_enable(sc, 0, PSH3TP_WSMOUSE_ENABLED);
271 }
272 
273 
274 static int
psh3tp_intr(void * arg)275 psh3tp_intr(void *arg)
276 {
277 	struct psh3tp_softc *sc = (struct psh3tp_softc *)arg;
278 
279 	uint8_t irr0;
280 	uint8_t phdr, touched;
281 	unsigned int steady, tremor_timeout;
282 
283 	irr0 = _reg_read_1(SH7709_IRR0);
284 	if ((irr0 & IRR0_IRQ2) == 0) {
285 #ifdef DIAGNOSTIC
286 		printf("%s: irr0 %02x?\n", device_xname(sc->sc_dev), irr0);
287 #endif
288 		return 0;
289 	}
290 
291 	if (!sc->sc_enabled) {
292 		DPRINTFN(1, ("%s: intr: !sc_enabled\n", device_xname(sc->sc_dev)));
293 		intc_intr_disable(SH7709_INTEVT2_IRQ2);
294 		goto served;
295 	}
296 
297 	/*
298 	 * Number of times the "touched" bit should be read
299 	 * consecutively.
300 	 */
301 #define TREMOR_THRESHOLD 0x300
302 	steady = 0;
303 	tremor_timeout = TREMOR_THRESHOLD * 16;	/* XXX: arbitrary */
304 	touched = true;		/* we start with "touched" state */
305 
306 	do {
307 		uint8_t state;
308 
309 		phdr = _reg_read_1(SH7709_PHDR);
310 		state = ((phdr & PHDR_TP_PEN_UP) != PHDR_TP_PEN_UP);
311 
312 		if (state == touched)
313 			++steady;
314 		else {
315 			steady = 0;
316 			touched = state;
317 		}
318 
319 		if (--tremor_timeout == 0) {
320 			DPRINTF(("%s: tremor timeout!\n",
321 			    device_xname(sc->sc_dev)));
322 			goto served;
323 		}
324 	} while (steady < TREMOR_THRESHOLD);
325 
326 	if (touched) {
327 		intc_intr_disable(SH7709_INTEVT2_IRQ2);
328 
329 		/*
330 		 * ADC readings are not stable yet, so schedule
331 		 * callout instead of accessing ADC from the interrupt
332 		 * handler only to immediately delay().
333 		 */
334 		callout_reset(&sc->sc_touch_ch,
335 		    hz/32, psh3tp_start_polling, sc);
336 	} else
337 		DPRINTFN(1, ("%s: tremor\n", device_xname(sc->sc_dev)));
338 served:
339 	/* clear the interrupt */
340 	_reg_write_1(SH7709_IRR0, irr0 & ~IRR0_IRQ2);
341 
342 	return 1;
343 }
344 
345 
346 /*
347  * Called from the interrupt handler at spltty() upon first touch.
348  * Decide if we are going to report this touch as a mouse click/drag.
349  */
350 static void
psh3tp_start_polling(void * arg)351 psh3tp_start_polling(void *arg)
352 {
353 	struct psh3tp_softc *sc = (struct psh3tp_softc *)arg;
354 	uint8_t phdr;
355 	int rawx, rawy;
356 
357 	phdr = _reg_read_1(SH7709_PHDR);
358 	if ((phdr & PHDR_TP_PEN_UP) == PHDR_TP_PEN_UP) {
359 		DPRINTFN(2, ("%s: start: pen is not down\n",
360 		    device_xname(sc->sc_dev)));
361 		psh3tp_stop_polling(sc);
362 		return;
363 	}
364 
365 	psh3tp_get_raw_xy(&rawx, &rawy);
366 	DPRINTFN(2, ("%s: start: %4d %4d -> ",
367 	    device_xname(sc->sc_dev), rawx, rawy));
368 
369 	if (sc->sc_enabled & PSH3TP_WSMOUSE_ENABLED) {
370 		DPRINTFN(2, ("mouse\n"));
371 		psh3tp_wsmouse_input(sc, rawx, rawy);
372 		callout_reset(&sc->sc_touch_ch,
373 		    hz/32, psh3tp_callout_wsmouse, sc);
374 	} else {
375 		DPRINTFN(2, ("ignore\n"));
376 		psh3tp_stop_polling(sc);
377 	}
378 }
379 
380 
381 /*
382  * Re-enable touch panel interrupt.
383  * Called at spltty() when polling code detects pen-up.
384  */
385 /* ARGSUSED */
386 static void
psh3tp_stop_polling(struct psh3tp_softc * sc __unused)387 psh3tp_stop_polling(struct psh3tp_softc *sc __unused)
388 {
389 	uint8_t irr0;
390 
391 	DPRINTFN(2, ("%s: stop\n", device_xname(sc->sc_dev)));
392 
393 	/* clear pending interrupt signal before re-enabling the interrupt */
394 	irr0 = _reg_read_1(SH7709_IRR0);
395 	if ((irr0 & IRR0_IRQ2) != 0)
396 		_reg_write_1(SH7709_IRR0, irr0 & ~IRR0_IRQ2);
397 
398 	intc_intr_enable(SH7709_INTEVT2_IRQ2);
399 }
400 
401 
402 /*
403  * We are reporting this touch as a mouse click/drag.
404  */
405 static void
psh3tp_callout_wsmouse(void * arg)406 psh3tp_callout_wsmouse(void *arg)
407 {
408 	struct psh3tp_softc *sc = (struct psh3tp_softc *)arg;
409 	uint8_t phdr;
410 	int rawx, rawy;
411 	int s;
412 
413 	s = spltty();
414 
415 	if (!sc->sc_enabled) {
416 		DPRINTFN(1, ("%s: wsmouse callout: !sc_enabled\n",
417 		    device_xname(sc->sc_dev)));
418 		splx(s);
419 		return;
420 	}
421 
422 	phdr = _reg_read_1(SH7709_PHDR);
423 	if ((phdr & PHDR_TP_PEN_UP) != PHDR_TP_PEN_UP) {
424 		psh3tp_get_raw_xy(&rawx, &rawy);
425 		psh3tp_wsmouse_input(sc, rawx, rawy); /* mouse dragged */
426 		callout_schedule(&sc->sc_touch_ch, hz/32);
427 	} else {
428 		wsmouse_input( /* button up */
429 		    sc->sc_wsmousedev, 0, 0, 0, 0, 0, WSMOUSE_INPUT_DELTA);
430 		psh3tp_stop_polling(sc);
431 	}
432 	splx(s);
433 }
434 
435 
436 /*
437  * Report mouse click/drag.
438  */
439 static void
psh3tp_wsmouse_input(struct psh3tp_softc * sc,int rawx,int rawy)440 psh3tp_wsmouse_input(struct psh3tp_softc *sc, int rawx, int rawy)
441 {
442 	int x, y;
443 
444 	tpcalib_trans(&sc->sc_tpcalib, rawx, rawy, &x, &y);
445 
446 	DPRINTFN(3, ("%s: %4d %4d -> %3d %3d\n",
447 	     device_xname(sc->sc_dev), rawx, rawy, x, y));
448 
449 	wsmouse_input(sc->sc_wsmousedev,
450 	    1,	/* button */
451 	    x, y, 0, 0,
452 	    WSMOUSE_INPUT_ABSOLUTE_X | WSMOUSE_INPUT_ABSOLUTE_Y);
453 }
454 
455 
456 /*
457  * Read raw X/Y coordinates from the ADC.
458  */
459 static void
psh3tp_get_raw_xy(int * rawxp,int * rawyp)460 psh3tp_get_raw_xy(int *rawxp, int *rawyp)
461 {
462 	uint8_t scpdr;
463 
464 	/* X axis */
465 	scpdr = _reg_read_1(SH7709_SCPDR);
466 	scpdr &= ~SCPDR_TP_SCAN_DISABLE;
467 	scpdr |= (SCPDR_TP_SCAN_ENABLE | SCPDR_TP_SCAN_X);
468 	_reg_write_1(SH7709_SCPDR, scpdr);
469 	delay(40);
470 
471 	*rawxp = adc_sample_channel(ADC_CHANNEL_TP_X);
472 
473 	/* Y axis */
474 	scpdr = _reg_read_1(SH7709_SCPDR);
475 	scpdr &=  ~SCPDR_TP_SCAN_X;
476 	scpdr |= (SCPDR_TP_SCAN_ENABLE | SCPDR_TP_SCAN_Y);
477 	_reg_write_1(SH7709_SCPDR, scpdr);
478 	delay(40);
479 
480 	*rawyp = adc_sample_channel(ADC_CHANNEL_TP_Y);
481 
482 	/* restore SCPDR */
483 	scpdr = _reg_read_1(SH7709_SCPDR);
484 	scpdr &= ~(SCPDR_TP_SCAN_ENABLE | SCPDR_TP_SCAN_Y);
485 	scpdr |= SCPDR_TP_SCAN_DISABLE;
486 	_reg_write_1(SH7709_SCPDR, scpdr);
487 }
488 
489 
490 static int
psh3tp_wsmouse_ioctl(void * cookie,u_long cmd,void * data,int flag,struct lwp * l)491 psh3tp_wsmouse_ioctl(void *cookie, u_long cmd, void *data, int flag,
492 		     struct lwp *l)
493 {
494 	struct psh3tp_softc *sc = (struct psh3tp_softc *)cookie;
495 
496 	return hpc_tpanel_ioctl(&sc->sc_tpcalib, cmd, data, flag, l);
497 }
498