1/* $NetBSD: pcmcom.c,v 1.40 2012/10/27 17:18:37 chs Exp $ */
2
3/*-
4 * Copyright (c) 1998, 2000, 2004 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by RedBack Networks, Inc.
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 * Device driver for multi-port PCMCIA serial cards, written by
34 * Jason R. Thorpe for RedBack Networks, Inc.
35 *
36 * Most of these cards are simply multiple UARTs sharing a single interrupt
37 * line, and rely on the fact that PCMCIA level-triggered interrupts can
38 * be shared. There are no special interrupt registers on them, as there
39 * are on most ISA multi-port serial cards.
40 *
41 * If there are other cards that have interrupt registers, they should not
42 * be glued into this driver. Rather, separate drivers should be written
43 * for those devices, as we have in the ISA multi-port serial card case.
44 */
45
46#include <sys/cdefs.h>
47__KERNEL_RCSID(0, "$NetBSD: pcmcom.c,v 1.40 2012/10/27 17:18:37 chs Exp $");
48
49#include <sys/param.h>
50#include <sys/systm.h>
51#include <sys/device.h>
52#include <sys/termios.h>
53#include <sys/malloc.h>
54
55#include <sys/bus.h>
56#include <sys/intr.h>
57
58#include <dev/ic/comreg.h>
59#include <dev/ic/comvar.h>
60
61#include <dev/pcmcia/pcmciavar.h>
62#include <dev/pcmcia/pcmciareg.h>
63#include <dev/pcmcia/pcmciadevs.h>
64
65#include "com.h"
66#include "pcmcom.h"
67
68#include "locators.h"
69
70struct pcmcom_softc {
71 device_t sc_dev; /* generic device glue */
72
73 struct pcmcia_function *sc_pf; /* our PCMCIA function */
74 void *sc_ih; /* interrupt handle */
75 int sc_enabled_count; /* enabled count */
76
77#define NSLAVES 8
78 device_t sc_slaves[NSLAVES]; /* slave info */
79 int sc_nslaves; /* slave count */
80
81 int sc_state;
82#define PCMCOM_ATTACHED 3
83};
84
85struct pcmcom_attach_args {
86 bus_space_tag_t pca_iot; /* I/O tag */
87 bus_space_handle_t pca_ioh; /* I/O handle */
88 int pca_slave; /* slave # */
89};
90
91int pcmcom_match(device_t, cfdata_t, void *);
92int pcmcom_validate_config(struct pcmcia_config_entry *);
93void pcmcom_attach(device_t, device_t, void *);
94int pcmcom_detach(device_t, int);
95void pcmcom_childdet(device_t, device_t);
96
97CFATTACH_DECL_NEW(pcmcom, sizeof(struct pcmcom_softc),
98 pcmcom_match, pcmcom_attach, pcmcom_detach, NULL);
99
100const struct pcmcia_product pcmcom_products[] = {
101 { PCMCIA_VENDOR_SOCKET, PCMCIA_PRODUCT_SOCKET_DUAL_RS232,
102 PCMCIA_CIS_INVALID },
103#if 0 /* does not work */
104 { PCMCIA_VENDOR_SOCKET, PCMCIA_PRODUCT_SOCKET_DUAL_RS232_A,
105 PCMCIA_CIS_INVALID },
106#endif
107};
108const size_t pcmcom_nproducts = __arraycount(pcmcom_products);
109
110int pcmcom_print(void *, const char *);
111
112int pcmcom_enable(struct pcmcom_softc *);
113void pcmcom_disable(struct pcmcom_softc *);
114
115int pcmcom_intr(void *);
116
117int
118pcmcom_match(device_t parent, cfdata_t cf, void *aux)
119{
120 struct pcmcia_attach_args *pa = aux;
121
122 if (pcmcia_product_lookup(pa, pcmcom_products, pcmcom_nproducts,
123 sizeof(pcmcom_products[0]), NULL))
124 return (2); /* beat com_pcmcia */
125 return (0);
126}
127
128int
129pcmcom_validate_config(struct pcmcia_config_entry *cfe)
130{
131 if (cfe->iftype != PCMCIA_IFTYPE_IO ||
132 cfe->num_iospace < 1 || cfe->num_iospace > NSLAVES)
133 return (EINVAL);
134 return (0);
135}
136
137void
138pcmcom_attach(device_t parent, device_t self, void *aux)
139{
140 struct pcmcom_softc *sc = device_private(self);
141 struct pcmcia_attach_args *pa = aux;
142 struct pcmcia_config_entry *cfe;
143 int slave;
144 int error;
145 int locs[PCMCOMCF_NLOCS];
146
147 sc->sc_dev = self;
148
149 sc->sc_pf = pa->pf;
150
151 error = pcmcia_function_configure(pa->pf, pcmcom_validate_config);
152 if (error) {
153 aprint_error_dev(self, "configure failed, error=%d\n", error);
154 return;
155 }
156
157 cfe = pa->pf->cfe;
158 sc->sc_nslaves = cfe->num_iospace;
159
160 error = pcmcom_enable(sc);
161 if (error)
162 goto fail;
163
164 /* Attach the children. */
165 for (slave = 0; slave < sc->sc_nslaves; slave++) {
166 struct pcmcom_attach_args pca;
167
168 printf("%s: slave %d\n", device_xname(self), slave);
169
170 pca.pca_iot = cfe->iospace[slave].handle.iot;
171 pca.pca_ioh = cfe->iospace[slave].handle.ioh;
172 pca.pca_slave = slave;
173
174 locs[PCMCOMCF_SLAVE] = slave;
175
176 sc->sc_slaves[slave] = config_found_sm_loc(sc->sc_dev,
177 "pcmcom", locs,
178 &pca, pcmcom_print, config_stdsubmatch);
179 }
180
181 pcmcom_disable(sc);
182 sc->sc_state = PCMCOM_ATTACHED;
183 return;
184
185fail:
186 pcmcia_function_unconfigure(pa->pf);
187}
188
189void
190pcmcom_childdet(device_t self, device_t child)
191{
192 struct pcmcom_softc *sc = device_private(self);
193 int slave;
194
195 for (slave = sc->sc_nslaves - 1; slave >= 0; slave--) {
196 if (sc->sc_slaves[slave] == child)
197 sc->sc_slaves[slave] = NULL;
198 }
199}
200
201int
202pcmcom_detach(device_t self, int flags)
203{
204 struct pcmcom_softc *sc = device_private(self);
205 int slave, error;
206
207 if (sc->sc_state != PCMCOM_ATTACHED)
208 return (0);
209
210 for (slave = sc->sc_nslaves - 1; slave >= 0; slave--) {
211 if (sc->sc_slaves[slave]) {
212 /* Detach the child. */
213 error = config_detach(sc->sc_slaves[slave], flags);
214 if (error)
215 return (error);
216 }
217 }
218
219 pcmcia_function_unconfigure(sc->sc_pf);
220
221 return (0);
222}
223
224int
225pcmcom_print(void *aux, const char *pnp)
226{
227 struct pcmcom_attach_args *pca = aux;
228
229 /* only com's can attach to pcmcom's; easy... */
230 if (pnp)
231 aprint_normal("com at %s", pnp);
232
233 aprint_normal(" slave %d", pca->pca_slave);
234
235 return (UNCONF);
236}
237
238int
239pcmcom_intr(void *arg)
240{
241#if NCOM > 0
242 struct pcmcom_softc *sc = arg;
243 int i, rval = 0;
244
245 if (sc->sc_enabled_count == 0)
246 return (0);
247
248 for (i = 0; i < sc->sc_nslaves; i++) {
249 if (sc->sc_slaves[i])
250 rval |= comintr(sc->sc_slaves[i]);
251 }
252
253 return (rval);
254#else
255 return (0);
256#endif /* NCOM > 0 */
257}
258
259int
260pcmcom_enable(struct pcmcom_softc *sc)
261{
262 int error;
263
264 if (sc->sc_enabled_count++ != 0)
265 return (0);
266
267 /* Establish the interrupt. */
268 sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_SERIAL,
269 pcmcom_intr, sc);
270 if (!sc->sc_ih)
271 return (EIO);
272
273 error = pcmcia_function_enable(sc->sc_pf);
274 if (error) {
275 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
276 sc->sc_ih = 0;
277 }
278
279 return (error);
280}
281
282void
283pcmcom_disable(struct pcmcom_softc *sc)
284{
285
286 if (--sc->sc_enabled_count != 0)
287 return;
288
289 pcmcia_function_disable(sc->sc_pf);
290 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
291 sc->sc_ih = 0;
292}
293
294/****** Here begins the com attachment code. ******/
295
296#if NCOM_PCMCOM > 0
297int com_pcmcom_match(device_t, cfdata_t , void *);
298void com_pcmcom_attach(device_t, device_t, void *);
299
300/* No pcmcom-specific goo in the softc; it's all in the parent. */
301CFATTACH_DECL_NEW(com_pcmcom, sizeof(struct com_softc),
302 com_pcmcom_match, com_pcmcom_attach, com_detach, NULL);
303
304int com_pcmcom_enable(struct com_softc *);
305void com_pcmcom_disable(struct com_softc *);
306
307int
308com_pcmcom_match(device_t parent, cfdata_t cf, void *aux)
309{
310
311 /* Device is always present. */
312 return (1);
313}
314
315void
316com_pcmcom_attach(device_t parent, device_t self, void *aux)
317{
318 struct com_softc *sc = device_private(self);
319 struct pcmcom_attach_args *pca = aux;
320
321 sc->sc_dev = self;
322 COM_INIT_REGS(sc->sc_regs, pca->pca_iot, pca->pca_ioh, -1);
323 sc->enabled = 1;
324
325 sc->sc_frequency = COM_FREQ;
326
327 sc->enable = com_pcmcom_enable;
328 sc->disable = com_pcmcom_disable;
329
330 com_attach_subr(sc);
331
332 sc->enabled = 0;
333}
334
335int
336com_pcmcom_enable(struct com_softc *sc)
337{
338 return pcmcom_enable(device_private(device_parent(sc->sc_dev)));
339}
340
341void
342com_pcmcom_disable(struct com_softc *sc)
343{
344
345 pcmcom_disable(device_private(device_parent(sc->sc_dev)));
346}
347#endif /* NCOM_PCMCOM > 0 */
348