1 /*
2 * Copyright (c) 2003, 2004, 2005
3 * John Wehle <john@feith.com>. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by John Wehle.
16 * 4. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
23 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * I2c routines for the Conexant MPEG-2 Codec driver.
34 */
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/malloc.h>
39 #include <sys/conf.h>
40 #include <sys/uio.h>
41 #include <sys/kernel.h>
42 #include <sys/module.h>
43 #include <sys/poll.h>
44 #include <sys/select.h>
45 #include <sys/resource.h>
46 #include <sys/bus.h>
47 #include <sys/rman.h>
48
49 #include <machine/clock.h>
50
51 #include <bus/pci/pcireg.h>
52 #include <bus/pci/pcivar.h>
53
54 #include <dev/video/cxm/cxm.h>
55
56 #include <bus/iicbus/iiconf.h>
57
58 #include "iicbb_if.h"
59
60
61 static int cxm_iic_probe(device_t dev);
62 static int cxm_iic_attach(device_t dev);
63 static int cxm_iic_detach(device_t dev);
64 static void cxm_iic_child_detached(device_t dev, device_t child);
65
66 static int cxm_iic_callback(device_t, int, caddr_t *);
67 static int cxm_iic_reset(device_t, u_char, u_char, u_char *);
68 static int cxm_iic_getscl(device_t);
69 static int cxm_iic_getsda(device_t);
70 static void cxm_iic_setscl(device_t, int);
71 static void cxm_iic_setsda(device_t, int);
72
73 static device_method_t cxm_iic_methods[] = {
74 /* Device interface */
75 DEVMETHOD(device_probe, cxm_iic_probe),
76 DEVMETHOD(device_attach, cxm_iic_attach),
77 DEVMETHOD(device_detach, cxm_iic_detach),
78
79 /* bus interface */
80 DEVMETHOD(bus_child_detached, cxm_iic_child_detached),
81 DEVMETHOD(bus_print_child, bus_generic_print_child),
82 DEVMETHOD(bus_driver_added, bus_generic_driver_added),
83
84 /* iicbb interface */
85 DEVMETHOD(iicbb_callback, cxm_iic_callback),
86 DEVMETHOD(iicbb_reset, cxm_iic_reset),
87 DEVMETHOD(iicbb_getscl, cxm_iic_getscl),
88 DEVMETHOD(iicbb_getsda, cxm_iic_getsda),
89 DEVMETHOD(iicbb_setscl, cxm_iic_setscl),
90 DEVMETHOD(iicbb_setsda, cxm_iic_setsda),
91
92 DEVMETHOD_END
93 };
94
95 static driver_t cxm_iic_driver = {
96 "cxm_iic",
97 cxm_iic_methods,
98 sizeof(struct cxm_iic_softc),
99 };
100
101 static devclass_t cxm_iic_devclass;
102
103 DRIVER_MODULE(cxm_iic, cxm, cxm_iic_driver, cxm_iic_devclass, NULL, NULL);
104 MODULE_VERSION(cxm_iic, 1);
105 MODULE_DEPEND(cxm_iic, iicbb, IICBB_MINVER, IICBB_PREFVER, IICBB_MAXVER);
106
107
108 /*
109 * the boot time probe routine.
110 *
111 * The cxm_iic device is only probed after it has
112 * been established that the cxm device is present
113 * which means that the cxm_iic device * must *
114 * be present since it's built into the cxm hardware.
115 */
116 static int
cxm_iic_probe(device_t dev)117 cxm_iic_probe(device_t dev)
118 {
119 device_set_desc(dev, "Conexant iTVC15 / iTVC16 I2C controller");
120
121 return 0;
122 }
123
124
125 /*
126 * the attach routine.
127 */
128 static int
cxm_iic_attach(device_t dev)129 cxm_iic_attach(device_t dev)
130 {
131 device_t *kids;
132 device_t iicbus;
133 int error;
134 int numkids;
135 int i;
136 bus_space_handle_t *bhandlep;
137 bus_space_tag_t *btagp;
138 struct cxm_iic_softc *sc;
139 device_t child;
140
141 /* Get the device data */
142 sc = device_get_softc(dev);
143
144 /* retrieve the cxm btag and bhandle */
145 if (BUS_READ_IVAR(device_get_parent(dev), dev,
146 CXM_IVAR_BTAG, (uintptr_t *)&btagp)
147 || BUS_READ_IVAR(device_get_parent(dev), dev,
148 CXM_IVAR_BHANDLE, (uintptr_t *)&bhandlep)) {
149 device_printf(dev,
150 "could not retrieve bus space information\n");
151 return ENXIO;
152 }
153
154 sc->btag = *btagp;
155 sc->bhandle = *bhandlep;
156
157 /* add bit-banging generic code onto cxm_iic interface */
158 sc->iicbb = device_add_child(dev, "iicbb", -1);
159
160 if (!sc->iicbb) {
161 device_printf(dev, "could not add iicbb\n");
162 return ENXIO;
163 }
164
165 /* probed and attached the bit-banging code */
166 error = device_probe_and_attach(sc->iicbb);
167
168 if (error) {
169 device_printf(dev, "could not attach iicbb\n");
170 goto fail;
171 }
172
173 /* locate iicbus which was attached by the bit-banging code */
174 iicbus = NULL;
175 device_get_children(sc->iicbb, &kids, &numkids);
176 for (i = 0; i < numkids; i++)
177 if (strcmp(device_get_name(kids[i]), "iicbus") == 0) {
178 iicbus = kids[i];
179 break;
180 }
181 kfree(kids, M_TEMP);
182
183 if (!iicbus) {
184 device_printf(dev, "could not find iicbus\n");
185 error = ENXIO;
186 goto fail;
187 }
188
189 if (BUS_WRITE_IVAR(device_get_parent(dev), dev,
190 CXM_IVAR_IICBUS, (uintptr_t)&iicbus)) {
191 device_printf(dev, "could not store iicbus information\n");
192 error = ENXIO;
193 goto fail;
194 }
195
196 return 0;
197
198 fail:
199 /*
200 * Detach the children before recursively deleting
201 * in case a child has a pointer to a grandchild
202 * which is used by the child's detach routine.
203 *
204 * Remember the child before detaching so we can
205 * delete it (bus_generic_detach indirectly zeroes
206 * sc->child_dev).
207 */
208 child = sc->iicbb;
209 bus_generic_detach(dev);
210 if (child)
211 device_delete_child(dev, child);
212
213 return error;
214 }
215
216
217 /*
218 * the detach routine.
219 */
220 static int
cxm_iic_detach(device_t dev)221 cxm_iic_detach(device_t dev)
222 {
223 struct cxm_iic_softc *sc;
224 device_t child;
225
226 /* Get the device data */
227 sc = device_get_softc(dev);
228
229 BUS_WRITE_IVAR(device_get_parent(dev), dev, CXM_IVAR_IICBUS, 0);
230
231 /*
232 * Detach the children before recursively deleting
233 * in case a child has a pointer to a grandchild
234 * which is used by the child's detach routine.
235 *
236 * Remember the child before detaching so we can
237 * delete it (bus_generic_detach indirectly zeroes
238 * sc->child_dev).
239 */
240 child = sc->iicbb;
241 bus_generic_detach(dev);
242 if (child)
243 device_delete_child(dev, child);
244
245 return 0;
246 }
247
248
249 /*
250 * the child detached routine.
251 */
252 static void
cxm_iic_child_detached(device_t dev,device_t child)253 cxm_iic_child_detached(device_t dev, device_t child)
254 {
255 struct cxm_iic_softc *sc;
256
257 /* Get the device data */
258 sc = device_get_softc(dev);
259
260 if (child == sc->iicbb)
261 sc->iicbb = NULL;
262 }
263
264
265 static int
cxm_iic_callback(device_t dev,int index,caddr_t * data)266 cxm_iic_callback(device_t dev, int index, caddr_t *data)
267 {
268 return 0;
269 }
270
271
272 static int
cxm_iic_reset(device_t dev,u_char speed,u_char addr,u_char * oldaddr)273 cxm_iic_reset(device_t dev, u_char speed, u_char addr, u_char * oldaddr)
274 {
275 struct cxm_iic_softc *sc;
276
277 /* Get the device data */
278 sc = (struct cxm_iic_softc *)device_get_softc(dev);
279
280 /* Set scl to 1 */
281 CSR_WRITE_4(sc, CXM_REG_I2C_SETSCL, ~(int)1);
282
283 /* Set sda to 1 */
284 CSR_WRITE_4(sc, CXM_REG_I2C_SETSDA, ~(int)1);
285
286 /*
287 * PCI writes may be buffered so force the
288 * write to complete by reading the last
289 * location written.
290 */
291
292 CSR_READ_4(sc, CXM_REG_I2C_SETSDA);
293
294 /* Wait for 10 usec */
295 DELAY(10);
296
297 return IIC_ENOADDR;
298 }
299
300
301 static int
cxm_iic_getscl(device_t dev)302 cxm_iic_getscl(device_t dev)
303 {
304 struct cxm_iic_softc *sc;
305
306 /* Get the device data */
307 sc = (struct cxm_iic_softc *)device_get_softc(dev);
308
309 /* Get sda */
310 return CSR_READ_1(sc, CXM_REG_I2C_GETSCL);
311 }
312
313
314 static int
cxm_iic_getsda(device_t dev)315 cxm_iic_getsda(device_t dev)
316 {
317 struct cxm_iic_softc *sc;
318
319 /* Get the device data */
320 sc = (struct cxm_iic_softc *)device_get_softc(dev);
321
322 /* Get sda */
323 return CSR_READ_1(sc, CXM_REG_I2C_GETSDA);
324 }
325
326
327 static void
cxm_iic_setscl(device_t dev,int val)328 cxm_iic_setscl(device_t dev, int val)
329 {
330 struct cxm_iic_softc *sc;
331
332 /* Get the device data */
333 sc = (struct cxm_iic_softc *)device_get_softc(dev);
334
335 /* Set scl to the requested value */
336 CSR_WRITE_4(sc, CXM_REG_I2C_SETSCL, ~(int)(val ? 1 : 0));
337
338 /*
339 * PCI writes may be buffered so force the
340 * write to complete by reading the last
341 * location written.
342 */
343
344 CSR_READ_4(sc, CXM_REG_I2C_SETSCL);
345 }
346
347
348 static void
cxm_iic_setsda(device_t dev,int val)349 cxm_iic_setsda(device_t dev, int val)
350 {
351 struct cxm_iic_softc *sc;
352
353 /* Get the device data */
354 sc = (struct cxm_iic_softc *)device_get_softc(dev);
355
356 /* Set sda to the requested value */
357 CSR_WRITE_4(sc, CXM_REG_I2C_SETSDA, ~(int)(val ? 1 : 0));
358
359 /*
360 * PCI writes may be buffered so force the
361 * write to complete by reading the last
362 * location written.
363 */
364
365 CSR_READ_4(sc, CXM_REG_I2C_SETSDA);
366 }
367