1 /* $NetBSD: nbppcon.c,v 1.5 2021/08/07 16:18:53 thorpej Exp $ */
2 /*
3 * Copyright (c) 2011 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 #include <sys/cdefs.h>
28 __KERNEL_RCSID(0, "$NetBSD: nbppcon.c,v 1.5 2021/08/07 16:18:53 thorpej Exp $");
29
30 #include <sys/param.h>
31 #include <sys/device.h>
32 #include <sys/errno.h>
33
34 #include <machine/platid.h>
35 #include <machine/platid_mask.h>
36
37 #include <arm/xscale/pxa2x0_i2c.h>
38
39 #include <hpcarm/dev/nbppconvar.h>
40
41 #include <dev/i2c/i2cvar.h>
42 #include <dev/i2c/at24cxxvar.h>
43
44 #include "locators.h"
45
46 #define NBPPCON_ADDR 0x13
47
48
49 struct nbppcon_softc {
50 device_t sc_dev;
51 i2c_tag_t sc_tag;
52 int sc_address;
53
54 struct callback {
55 int cb_tag;
56 int (*cb_func)(void *, int, char *);
57 void *cb_arg;
58 } sc_cbs[2];
59 };
60
61 static int nbppcon_match(device_t, cfdata_t, void *);
62 static void nbppcon_attach(device_t, device_t, void *);
63
64 static int nbppcon_search(device_t, cfdata_t, const int *, void *);
65 static int nbppcon_print(void *aux, const char *pnp);
66
67 CFATTACH_DECL_NEW(nbppcon, sizeof(struct nbppcon_softc),
68 nbppcon_match, nbppcon_attach, NULL, NULL);
69
70
71 /* ARGSUSED */
72 static int
nbppcon_match(device_t parent,cfdata_t match,void * aux)73 nbppcon_match(device_t parent, cfdata_t match, void *aux)
74 {
75 struct i2c_attach_args *ia = aux;
76
77 if (ia->ia_addr != NBPPCON_ADDR ||
78 !platid_match(&platid, &platid_mask_MACH_PSIONTEKLOGIX_NETBOOK_PRO))
79 return 0;
80
81 return I2C_MATCH_ADDRESS_AND_PROBE;
82 }
83
84 /* ARGSUSED */
85 static void
nbppcon_attach(device_t parent,device_t self,void * aux)86 nbppcon_attach(device_t parent, device_t self, void *aux)
87 {
88 struct nbppcon_softc *sc = device_private(self);
89 struct i2c_attach_args *ia = aux;
90 int rv;
91 char buf[128];
92
93 sc->sc_dev = self;
94 sc->sc_tag = ia->ia_tag;
95 sc->sc_address = ia->ia_addr;
96
97 aprint_naive("\n");
98 aprint_normal(": NETBOOK PRO PCon\n");
99
100 #define NVRAM_ADDR 0x53
101 #define NVRAM_DATA_REV 0x14
102 rv = seeprom_bootstrap_read(sc->sc_tag, NVRAM_ADDR, 0x00, 128,
103 buf, sizeof(buf));
104 if (rv == 0)
105 aprint_normal_dev(self, "NETBOOK PRO Rev.%c\n",
106 buf[NVRAM_DATA_REV] - '0' + '@');
107 else
108 aprint_error_dev(self, "NVRAM read failed\n");
109
110 config_search(self, NULL,
111 CFARGS(.search = nbppcon_search));
112 }
113
114 /* ARGSUSED */
115 static int
nbppcon_search(device_t self,cfdata_t cf,const int * ldesc,void * aux)116 nbppcon_search(device_t self, cfdata_t cf, const int *ldesc, void *aux)
117 {
118 struct nbppcon_attach_args pcon;
119
120 pcon.aa_name = cf->cf_name;
121 pcon.aa_tag = cf->cf_loc[NBPPCONCF_TAG];
122
123 if (config_probe(self, cf, &pcon))
124 config_attach(self, cf, &pcon, nbppcon_print, CFARGS_NONE);
125
126 return 0;
127 }
128
129 /* ARGSUSED */
130 static int
nbppcon_print(void * aux,const char * pnp)131 nbppcon_print(void *aux, const char *pnp)
132 {
133
134 if (pnp != NULL)
135 aprint_normal("%s", pnp);
136 return UNCONF;
137 }
138
139
140 void *
nbppcon_regist_callback(device_t self,int tag,int (* func)(void *,int,char *),void * arg)141 nbppcon_regist_callback(device_t self,
142 int tag, int (*func)(void *, int, char *), void *arg)
143 {
144 struct nbppcon_softc *sc = device_private(self);
145 int i;
146
147 for (i = 0; i < __arraycount(sc->sc_cbs); i++)
148 if (sc->sc_cbs[i].cb_func == NULL) {
149 sc->sc_cbs[i].cb_tag = tag;
150 sc->sc_cbs[i].cb_func = func;
151 sc->sc_cbs[i].cb_arg = arg;
152 return func;
153 }
154
155 return NULL;
156 }
157
158 int
nbppcon_intr(device_t self,int buflen,char * buf)159 nbppcon_intr(device_t self, int buflen, char *buf)
160 {
161 struct nbppcon_softc *sc = device_private(self);
162 struct callback *cb;
163 int i;
164
165 for (i = 0; i < __arraycount(sc->sc_cbs); i++) {
166 cb = &sc->sc_cbs[i];
167 if (cb->cb_func != NULL &&
168 cb->cb_tag == buf[0])
169 return cb->cb_func(cb->cb_arg, buflen, buf);
170 }
171 aprint_error_dev(sc->sc_dev, "unknown tag received: 0x%02x\n", buf[0]);
172 return 0;
173 }
174
175 int
nbppcon_poll(device_t self,int tag,int buflen,char * buf)176 nbppcon_poll(device_t self, int tag, int buflen, char *buf)
177 {
178 struct nbppcon_softc *sc = device_private(self);
179 int rv;
180
181 if (iic_acquire_bus(sc->sc_tag, I2C_F_POLL)) {
182 aprint_error_dev(sc->sc_dev,
183 "%s: acquire bus failed\n", __func__);
184 return -1;
185 }
186
187 do {
188 extern int nbpiic_poll(void *, int, char *);
189
190 rv = nbpiic_poll(sc->sc_tag->ic_cookie, buflen, buf);
191 if (rv > 0 && buf[0] == tag)
192 break;
193 } while (rv == 0 || buf[0] != tag);
194
195 iic_release_bus(sc->sc_tag, I2C_F_POLL);
196
197 return rv;
198 }
199
200 int
nbppcon_kbd_ready(device_t self)201 nbppcon_kbd_ready(device_t self)
202 {
203 struct nbppcon_softc *sc = device_private(self);
204 int rv;
205 char cmd[1], data[1];
206
207 if (iic_acquire_bus(sc->sc_tag, I2C_F_POLL)) {
208 aprint_error_dev(sc->sc_dev,
209 "%s: acquire bus failed\n", __func__);
210 return -1;
211 }
212
213 cmd[0] = 0x00; /* Keyboard */
214 data[0] = 0x00; /* 0x00:Ready, 0x01:Busy? */
215 rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_address,
216 cmd, sizeof(cmd), data, sizeof(data), I2C_F_POLL);
217
218 cpu_dcache_wbinv_all(); /* XXXX: Why? */
219
220 iic_release_bus(sc->sc_tag, I2C_F_POLL);
221
222 return rv;
223 }
224
225 int
nbppcon_pwr_hwreset(device_t self)226 nbppcon_pwr_hwreset(device_t self)
227 {
228 struct nbppcon_softc *sc = device_private(self);
229 int rv;
230 char cmd[1], data[1];
231
232 if (iic_acquire_bus(sc->sc_tag, I2C_F_POLL)) {
233 aprint_error_dev(sc->sc_dev,
234 "%s: acquire bus failed\n", __func__);
235 return -1;
236 }
237
238 cmd[0] = 0x05; /* POWER */
239 data[0] = 0x00; /* HWReset */
240 #if 0
241 rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_address,
242 cmd, sizeof(cmd), data, sizeof(data), I2C_F_POLL);
243 #else /* XXXX: Oops, ensure HWReset, ignore cmd and data. */
244 rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_address + 1,
245 cmd, sizeof(cmd), data, sizeof(data), I2C_F_POLL);
246 #endif
247
248 iic_release_bus(sc->sc_tag, I2C_F_POLL);
249
250 return rv;
251 }
252