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