Home | History | Annotate | Line # | Download | only in dev
pfckbd.c revision 1.25 
      1 /*	$NetBSD: pfckbd.c,v 1.25 2008/04/28 20:23:22 martin Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2001, 2002 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by UCHIYAMA Yasushi.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * Matrix scan keyboard connected to SH7709, SH7709A PFC module.
     34  * currently, HP Jornada 680/690, HITACHI PERSONA HPW-50PAD only.
     35  */
     36 #include <sys/cdefs.h>
     37 __KERNEL_RCSID(0, "$NetBSD: pfckbd.c,v 1.25 2008/04/28 20:23:22 martin Exp $");
     38 
     39 #include "debug_hpcsh.h"
     40 
     41 #include <sys/param.h>
     42 #include <sys/systm.h>
     43 #include <sys/device.h>
     44 #include <sys/callout.h>
     45 
     46 #include <machine/bus.h>
     47 #include <machine/platid.h>
     48 #include <machine/platid_mask.h>
     49 
     50 #include <dev/hpc/hpckbdvar.h>
     51 
     52 #include <sh3/pfcreg.h>
     53 
     54 #include <hpcsh/dev/pfckbdvar.h>
     55 
     56 #ifdef	PFCKBD_DEBUG
     57 #define DPRINTF_ENABLE
     58 #define DPRINTF_DEBUG	pfckbd_debug
     59 #endif
     60 #include <machine/debug.h>
     61 
     62 static struct pfckbd_core {
     63 	int pc_attached;
     64 	int pc_enabled;
     65 	struct callout pc_soft_ch;
     66 	struct hpckbd_ic_if pc_if;
     67 	struct hpckbd_if *pc_hpckbd;
     68 	uint16_t pc_column[8];
     69 	void (*pc_callout)(void *);
     70 } pfckbd_core;
     71 
     72 static int pfckbd_match(device_t, cfdata_t, void *);
     73 static void pfckbd_attach(device_t, device_t, void *);
     74 
     75 CFATTACH_DECL_NEW(pfckbd, 0,
     76     pfckbd_match, pfckbd_attach, NULL, NULL);
     77 
     78 static void pfckbd_ifsetup(struct pfckbd_core *);
     79 
     80 /* callbacks for hpckbd */
     81 static int pfckbd_input_establish(void *, struct hpckbd_if *);
     82 static int pfckbd_poll(void *);
     83 
     84 static void pfckbd_input(struct pfckbd_core *, int, uint16_t);
     85 
     86 static void (*pfckbd_callout_lookup(void))(void *);
     87 static void pfckbd_callout_unknown(void *);
     88 static void pfckbd_callout_hp(void *);
     89 static void pfckbd_callout_hitachi(void *);
     90 void pfckbd_poll_hitachi_power(void);
     91 
     92 
     93 /* callout function table. this function is platfrom specific. */
     94 static const struct {
     95 	platid_mask_t *platform;
     96 	void (*func)(void *);
     97 } pfckbd_calloutfunc_table[] = {
     98 	{ &platid_mask_MACH_HP		, pfckbd_callout_hp },
     99 	{ &platid_mask_MACH_HITACHI	, pfckbd_callout_hitachi }
    100 };
    101 
    102 
    103 void
    104 pfckbd_cnattach()
    105 {
    106 	struct pfckbd_core *pc = &pfckbd_core;
    107 
    108 	if ((cpu_product != CPU_PRODUCT_7709)
    109 	    && (cpu_product != CPU_PRODUCT_7709A))
    110 		return;
    111 
    112 	/* initialize interface */
    113 	pfckbd_ifsetup(pc);
    114 
    115 	/* attach descendants */
    116 	hpckbd_cnattach(&pc->pc_if);
    117 }
    118 
    119 static int
    120 pfckbd_match(device_t parent, cfdata_t cf, void *aux)
    121 {
    122 
    123 	if ((cpu_product != CPU_PRODUCT_7709)
    124 	    && (cpu_product != CPU_PRODUCT_7709A))
    125 		return 0;
    126 
    127 	return !pfckbd_core.pc_attached; /* attach only once */
    128 }
    129 
    130 static void
    131 pfckbd_attach(device_t parent, device_t self, void *aux)
    132 {
    133 	struct hpckbd_attach_args haa;
    134 
    135 	aprint_naive("\n");
    136 	aprint_normal("\n");
    137 
    138 	pfckbd_core.pc_attached = 1;
    139 
    140 	pfckbd_ifsetup(&pfckbd_core);
    141 
    142 	/* attach hpckbd */
    143 	haa.haa_ic = &pfckbd_core.pc_if; /* tell hpckbd our interface */
    144 	config_found(self, &haa, hpckbd_print);
    145 
    146 	/* install callout handler */
    147 	callout_init(&pfckbd_core.pc_soft_ch, 0);
    148 	callout_reset(&pfckbd_core.pc_soft_ch, 1,
    149 		      pfckbd_core.pc_callout, &pfckbd_core);
    150 }
    151 
    152 static void
    153 pfckbd_ifsetup(struct pfckbd_core *pc)
    154 {
    155 	int i;
    156 
    157 	pc->pc_if.hii_ctx = pc;
    158 	pc->pc_if.hii_establish	= pfckbd_input_establish;
    159 	pc->pc_if.hii_poll = pfckbd_poll;
    160 
    161 	for (i = 0; i < 8; i++)
    162 		pc->pc_column[i] = 0xdfff;
    163 
    164 	/* select PFC access method */
    165 	pc->pc_callout = pfckbd_callout_lookup();
    166 }
    167 
    168 
    169 /*
    170  * Callback for hpckbd_initif
    171  */
    172 static int
    173 pfckbd_input_establish(void *ic, struct hpckbd_if *kbdif)
    174 {
    175 	struct pfckbd_core *pc = ic;
    176 
    177 	pc->pc_hpckbd = kbdif;	/* save hpckbd interface */
    178 	pc->pc_enabled = 1;	/* ok to talk to hpckbd */
    179 
    180 	return 0;
    181 }
    182 
    183 /*
    184  * Callback for hpckbd_cngetc
    185  */
    186 static int
    187 pfckbd_poll(void *ic)
    188 {
    189 	struct pfckbd_core *pc = ic;
    190 
    191 	if (pc->pc_enabled)
    192 		(*pc->pc_callout)(pc);
    193 
    194 	return 0;
    195 }
    196 
    197 /*
    198  * Called by platform specific scan routines to report key events to hpckbd
    199  */
    200 static void
    201 pfckbd_input(struct pfckbd_core *pc, int column, uint16_t data)
    202 {
    203 	int row, type, val;
    204 	unsigned int edge, mask;
    205 
    206 	edge = data ^ pc->pc_column[column];
    207 	if (edge == 0)
    208 		return;		/* no changes in this column */
    209 
    210 	pc->pc_column[column] = data;
    211 
    212 	for (row = 0, mask = 1; row < 16; ++row, mask <<= 1) {
    213 		if (mask & edge) {
    214 			type = mask & data ? /* up */ 0 : /* down */ 1;
    215 			DPRINTF("(%2d, %2d) %d \n", row, column, type);
    216 
    217 			val = row * 8 + column;
    218 			hpckbd_input(pc->pc_hpckbd, type, val);
    219 		}
    220 	}
    221 }
    222 
    223 
    224 /*
    225  * Platform dependent scan routines.
    226  */
    227 
    228 /* Look up appropriate callback handler */
    229 static void
    230 (*pfckbd_callout_lookup())(void *)
    231 {
    232 	int i, n;
    233 
    234 	n = sizeof(pfckbd_calloutfunc_table)
    235 		/ sizeof(pfckbd_calloutfunc_table[0]);
    236 
    237 	for (i = 0; i < n; i++)
    238 		if (platid_match(&platid,
    239 				 pfckbd_calloutfunc_table[i].platform))
    240 			return pfckbd_calloutfunc_table[i].func;
    241 
    242 	return pfckbd_callout_unknown;
    243 }
    244 
    245 /* Placeholder for unknown platform */
    246 static void
    247 pfckbd_callout_unknown(void *arg)
    248 {
    249 
    250 	printf("%s: unknown keyboard switch\n", __func__);
    251 }
    252 
    253 /*
    254  * HP Jornada680/690, HP620LX
    255  */
    256 static void
    257 pfckbd_callout_hp(void *arg)
    258 {
    259 #define PFCKBD_HP_PDCR_MASK 0xcc0c
    260 #define PFCKBD_HP_PECR_MASK 0xf0cf
    261 
    262 	/*
    263 	 * Disable output on all lines but the n'th line in D.
    264 	 * Pull the n'th scan line in D low.
    265 	 */
    266 #define PD(n)								\
    267 	{ (uint16_t)(PFCKBD_HP_PDCR_MASK & (~(1 << (2*(n)+1)))),	\
    268 	  (uint16_t)(PFCKBD_HP_PECR_MASK & 0xffff),			\
    269 	  (uint8_t)~(1 << (n)),						\
    270 	  0xff }
    271 
    272 	/* Ditto for E */
    273 #define PE(n)								\
    274 	{ (uint16_t)(PFCKBD_HP_PDCR_MASK & 0xffff),			\
    275 	  (uint16_t)(PFCKBD_HP_PECR_MASK & (~(1 << (2*(n)+1)))),	\
    276 	  0xff,								\
    277 	  (uint8_t)~(1 << (n)) }
    278 
    279 	static const struct {
    280 		uint16_t dc, ec; uint8_t d, e;
    281 	} scan[] = {
    282 		PD(1), PD(5), PE(1), PE(6), PE(7), PE(3), PE(0), PD(7)
    283 	};
    284 
    285 #undef PD
    286 #undef PE
    287 
    288 	struct pfckbd_core *pc = arg;
    289 	uint16_t dc, ec;
    290 	int column;
    291 	uint16_t data;
    292 
    293 	if (!pc->pc_enabled)
    294 		goto reinstall;
    295 
    296 	/* bits in D/E control regs we do not touch (XXX: can they change?) */
    297 	dc = _reg_read_2(SH7709_PDCR) & ~PFCKBD_HP_PDCR_MASK;
    298 	ec = _reg_read_2(SH7709_PECR) & ~PFCKBD_HP_PECR_MASK;
    299 
    300 	for (column = 0; column < 8; column++) {
    301 		/* disable output to all lines except the one we scan */
    302 		_reg_write_2(SH7709_PDCR, dc | scan[column].dc);
    303 		_reg_write_2(SH7709_PECR, ec | scan[column].ec);
    304 		delay(5);
    305 
    306 		/* pull the scan line low */
    307 		_reg_write_1(SH7709_PDDR, scan[column].d);
    308 		_reg_write_1(SH7709_PEDR, scan[column].e);
    309 		delay(50);
    310 
    311 		/* read sense */
    312 		data = _reg_read_1(SH7709_PFDR)
    313 			| (_reg_read_1(SH7709_PCDR) << 8);
    314 
    315 		pfckbd_input(pc, column, data);
    316 	}
    317 
    318 	/* scan no lines */
    319 	_reg_write_1(SH7709_PDDR, 0xff);
    320 	_reg_write_1(SH7709_PEDR, 0xff);
    321 
    322 	/* enable all scan lines */
    323 	_reg_write_2(SH7709_PDCR, dc | (0x5555 & PFCKBD_HP_PDCR_MASK));
    324 	_reg_write_2(SH7709_PECR, ec | (0x5555 & PFCKBD_HP_PECR_MASK));
    325 
    326 #if 0
    327 	/* (ignore) extra keys/events (recorder buttons, lid, cable &c) */
    328 	data = _reg_read_1(SH7709_PGDR) | (_reg_read_1(SH7709_PHDR) << 8);
    329 #endif
    330 
    331  reinstall:
    332 	callout_schedule(&pc->pc_soft_ch, 1);
    333 }
    334 
    335 /*
    336  * HITACH PERSONA (HPW-50PAD)
    337  */
    338 static void
    339 pfckbd_callout_hitachi(void *arg)
    340 {
    341 #define PFCKBD_HITACHI_PCCR_MASK 0xfff3
    342 #define PFCKBD_HITACHI_PDCR_MASK 0x000c
    343 #define PFCKBD_HITACHI_PECR_MASK 0x30cf
    344 
    345 #define PFCKBD_HITACHI_PCDR_SCN_MASK 0xfd
    346 #define PFCKBD_HITACHI_PDDR_SCN_MASK 0x02
    347 #define PFCKBD_HITACHI_PEDR_SCN_MASK 0x4b
    348 
    349 #define PFCKBD_HITACHI_PCDR_SNS_MASK 0x01
    350 #define PFCKBD_HITACHI_PFDR_SNS_MASK 0xfe
    351 
    352 	/*
    353 	 * Disable output on all lines but the n'th line in C.
    354 	 * Pull the n'th scan line in C low.
    355 	 */
    356 #define PC(n)								\
    357 	{ (uint16_t)(PFCKBD_HITACHI_PCCR_MASK & (~(1 << (2*(n)+1)))),	\
    358 	  (uint16_t)(PFCKBD_HITACHI_PDCR_MASK & 0xffff),		\
    359 	  (uint16_t)(PFCKBD_HITACHI_PECR_MASK & 0xffff),		\
    360 	  (uint8_t)(PFCKBD_HITACHI_PCDR_SCN_MASK & ~(1 << (n))),	\
    361 	  PFCKBD_HITACHI_PDDR_SCN_MASK,					\
    362 	  PFCKBD_HITACHI_PEDR_SCN_MASK }
    363 
    364 	/* Ditto for D */
    365 #define PD(n)								\
    366 	{ (uint16_t)(PFCKBD_HITACHI_PCCR_MASK & 0xffff),		\
    367 	  (uint16_t)(PFCKBD_HITACHI_PDCR_MASK & (~(1 << (2*(n)+1)))),	\
    368 	  (uint16_t)(PFCKBD_HITACHI_PECR_MASK & 0xffff),		\
    369 	  PFCKBD_HITACHI_PCDR_SCN_MASK,					\
    370 	  (uint8_t)(PFCKBD_HITACHI_PDDR_SCN_MASK & ~(1 << (n))),	\
    371 	  PFCKBD_HITACHI_PEDR_SCN_MASK }
    372 
    373 	/* Ditto for E */
    374 #define PE(n)								\
    375 	{ (uint16_t)(PFCKBD_HITACHI_PCCR_MASK & 0xffff),		\
    376 	  (uint16_t)(PFCKBD_HITACHI_PDCR_MASK & 0xffff),		\
    377 	  (uint16_t)(PFCKBD_HITACHI_PECR_MASK & (~(1 << (2*(n)+1)))),	\
    378 	  PFCKBD_HITACHI_PCDR_SCN_MASK,					\
    379 	  PFCKBD_HITACHI_PDDR_SCN_MASK,					\
    380 	  (uint8_t)(PFCKBD_HITACHI_PEDR_SCN_MASK & ~(1 << (n))) }
    381 
    382 	static const struct {
    383 		uint16_t cc, dc, ec; uint8_t c, d, e;
    384 	} scan[] = {
    385 		PE(6), PE(3), PE(1), PE(0), PC(7), PC(6), PC(5), PC(4),
    386 		PC(3), PC(2), PD(1), PC(0)
    387 	};
    388 
    389 	struct pfckbd_core *pc = arg;
    390 	uint16_t cc, dc, ec;
    391 	uint8_t data[2], cd, dd, ed;
    392 	int i;
    393 
    394 	if (!pc->pc_enabled)
    395 		goto reinstall;
    396 
    397 	/* bits in C/D/E control regs we do not touch (XXX: can they change?) */
    398 	cc = _reg_read_2(SH7709_PCCR) & ~PFCKBD_HITACHI_PCCR_MASK;
    399 	dc = _reg_read_2(SH7709_PDCR) & ~PFCKBD_HITACHI_PDCR_MASK;
    400 	ec = _reg_read_2(SH7709_PECR) & ~PFCKBD_HITACHI_PECR_MASK;
    401 
    402 	for (i = 0; i < 12; i++) {
    403 		/* disable output to all lines except the one we scan */
    404 		_reg_write_2(SH7709_PCCR, cc | scan[i].cc);
    405 		_reg_write_2(SH7709_PDCR, dc | scan[i].dc);
    406 		_reg_write_2(SH7709_PECR, ec | scan[i].ec);
    407 		delay(5);
    408 
    409 		cd = _reg_read_1(SH7709_PCDR) & ~PFCKBD_HITACHI_PCDR_SCN_MASK;
    410 		dd = _reg_read_1(SH7709_PDDR) & ~PFCKBD_HITACHI_PDDR_SCN_MASK;
    411 		ed = _reg_read_1(SH7709_PEDR) & ~PFCKBD_HITACHI_PEDR_SCN_MASK;
    412 
    413 		/* pull the scan line low */
    414 		_reg_write_1(SH7709_PCDR, cd | scan[i].c);
    415 		_reg_write_1(SH7709_PDDR, dd | scan[i].d);
    416 		_reg_write_1(SH7709_PEDR, ed | scan[i].e);
    417 		delay(50);
    418 
    419 		/* read sense */
    420 		data[i & 0x1] =
    421 		    (_reg_read_1(SH7709_PCDR) & PFCKBD_HITACHI_PCDR_SNS_MASK)
    422 		  | (_reg_read_1(SH7709_PFDR) & PFCKBD_HITACHI_PFDR_SNS_MASK);
    423 
    424 		if (i & 0x1)
    425 			pfckbd_input(pc, (i >> 1), (data[0] | (data[1] << 8)));
    426 	}
    427 
    428 	/* enable all scan lines */
    429 	_reg_write_2(SH7709_PCCR, cc | (0x5555 & PFCKBD_HITACHI_PCCR_MASK));
    430 	_reg_write_2(SH7709_PDCR, dc | (0x5555 & PFCKBD_HITACHI_PDCR_MASK));
    431 	_reg_write_2(SH7709_PECR, ec | (0x5555 & PFCKBD_HITACHI_PECR_MASK));
    432 
    433  reinstall:
    434 	callout_schedule(&pc->pc_soft_ch, 1);
    435 }
    436 
    437 void
    438 pfckbd_poll_hitachi_power()
    439 {
    440 	static const struct {
    441 		uint16_t cc, dc, ec; uint8_t c, d, e;
    442 	} poll = PD(1);
    443 
    444 #undef PC
    445 #undef PD
    446 #undef PE
    447 
    448 	uint16_t cc, dc, ec;
    449 	uint8_t cd, dd, ed;
    450 
    451 	/* bits in C/D/E control regs we do not touch (XXX: can they change?) */
    452 	cc = _reg_read_2(SH7709_PCCR) & ~PFCKBD_HITACHI_PCCR_MASK;
    453 	dc = _reg_read_2(SH7709_PDCR) & ~PFCKBD_HITACHI_PDCR_MASK;
    454 	ec = _reg_read_2(SH7709_PECR) & ~PFCKBD_HITACHI_PECR_MASK;
    455 
    456 	/* disable output to all lines except the one we scan */
    457 	_reg_write_2(SH7709_PCCR, cc | poll.cc);
    458 	_reg_write_2(SH7709_PDCR, dc | poll.dc);
    459 	_reg_write_2(SH7709_PECR, ec | poll.ec);
    460 	delay(5);
    461 
    462 	cd = _reg_read_1(SH7709_PCDR) & ~PFCKBD_HITACHI_PCDR_SCN_MASK;
    463 	dd = _reg_read_1(SH7709_PDDR) & ~PFCKBD_HITACHI_PDDR_SCN_MASK;
    464 	ed = _reg_read_1(SH7709_PEDR) & ~PFCKBD_HITACHI_PEDR_SCN_MASK;
    465 
    466 	/* pull the scan line low */
    467 	_reg_write_1(SH7709_PCDR, cd | poll.c);
    468 	_reg_write_1(SH7709_PDDR, dd | poll.d);
    469 	_reg_write_1(SH7709_PEDR, ed | poll.e);
    470 	delay(50);
    471 
    472 	/* poll POWER On */
    473 	while (_reg_read_1(SH7709_PCDR) & PFCKBD_HITACHI_PCDR_SNS_MASK & 0x01);
    474 
    475 	/* enable all scan lines */
    476 	_reg_write_2(SH7709_PCCR, cc | (0x5555 & PFCKBD_HITACHI_PCCR_MASK));
    477 	_reg_write_2(SH7709_PDCR, dc | (0x5555 & PFCKBD_HITACHI_PDCR_MASK));
    478 	_reg_write_2(SH7709_PECR, ec | (0x5555 & PFCKBD_HITACHI_PECR_MASK));
    479 }
    480