Annotation of sys/dev/pci/puc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: puc.c,v 1.12 2007/04/26 01:31:05 gwk Exp $ */
2: /* $NetBSD: puc.c,v 1.3 1999/02/06 06:29:54 cgd Exp $ */
3:
4: /*
5: * Copyright (c) 1996, 1998, 1999
6: * Christopher G. Demetriou. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Christopher G. Demetriou
19: * for the NetBSD Project.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: /*
36: * PCI "universal" communication card device driver, glues com, lpt,
37: * and similar ports to PCI via bridge chip often much larger than
38: * the devices being glued.
39: *
40: * Author: Christopher G. Demetriou, May 14, 1998 (derived from NetBSD
41: * sys/dev/pci/pciide.c, revision 1.6).
42: *
43: * These devices could be (and some times are) described as
44: * communications/{serial,parallel}, etc. devices with known
45: * programming interfaces, but those programming interfaces (in
46: * particular the BAR assignments for devices, etc.) in fact are not
47: * particularly well defined.
48: *
49: * After I/we have seen more of these devices, it may be possible
50: * to generalize some of these bits. In particular, devices which
51: * describe themselves as communications/serial/16[45]50, and
52: * communications/parallel/??? might be attached via direct
53: * 'com' and 'lpt' attachments to pci.
54: */
55:
56: #include <sys/param.h>
57: #include <sys/systm.h>
58: #include <sys/device.h>
59:
60: #include <dev/pci/pcireg.h>
61: #include <dev/pci/pcivar.h>
62: #include <dev/pci/pucvar.h>
63:
64: #include <dev/pci/pcidevs.h>
65:
66: struct puc_pci_softc {
67: struct puc_softc sc_psc;
68:
69: pci_chipset_tag_t pc;
70: pci_intr_handle_t ih;
71: };
72:
73: int puc_pci_match(struct device *, void *, void *);
74: void puc_pci_attach(struct device *, struct device *, void *);
75: const char *puc_pci_intr_string(struct puc_attach_args *);
76: void *puc_pci_intr_establish(struct puc_attach_args *, int,
77: int (*)(void *), void *, char *);
78:
79: struct cfattach puc_pci_ca = {
80: sizeof(struct puc_pci_softc), puc_pci_match, puc_pci_attach
81: };
82:
83: struct cfdriver puc_cd = {
84: NULL, "puc", DV_DULL
85: };
86:
87: const char *puc_port_type_name(int);
88:
89: int
90: puc_pci_match(struct device *parent, void *match, void *aux)
91: {
92: struct pci_attach_args *pa = aux;
93: const struct puc_device_description *desc;
94: pcireg_t bhlc, subsys;
95:
96: bhlc = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_BHLC_REG);
97: if (PCI_HDRTYPE_TYPE(bhlc) != 0)
98: return (0);
99:
100: subsys = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
101:
102: desc = puc_find_description(PCI_VENDOR(pa->pa_id),
103: PCI_PRODUCT(pa->pa_id), PCI_VENDOR(subsys), PCI_PRODUCT(subsys));
104: if (desc != NULL)
105: return (10);
106:
107: /*
108: * Match class/subclass, so we can tell people to compile kernel
109: * with options that cause this driver to spew.
110: */
111: if (PCI_CLASS(pa->pa_class) == PCI_CLASS_COMMUNICATIONS &&
112: PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_BRIDGE_PCI)
113: return (1);
114:
115: return (0);
116: }
117:
118: const char *
119: puc_pci_intr_string(struct puc_attach_args *paa)
120: {
121: struct puc_pci_softc *sc = paa->puc;
122:
123: return (pci_intr_string(sc->pc, sc->ih));
124: }
125:
126: void *
127: puc_pci_intr_establish(struct puc_attach_args *paa, int type,
128: int (*func)(void *), void *arg, char *name)
129: {
130: struct puc_pci_softc *sc = paa->puc;
131:
132: return (pci_intr_establish(sc->pc, sc->ih, type, func, arg, name));
133: }
134:
135: void
136: puc_pci_attach(struct device *parent, struct device *self, void *aux)
137: {
138: struct puc_pci_softc *psc = (struct puc_pci_softc *)self;
139: struct puc_softc *sc = &psc->sc_psc;
140: struct pci_attach_args *pa = aux;
141: struct puc_attach_args paa;
142: pcireg_t subsys;
143: int i;
144:
145: subsys = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
146: sc->sc_desc = puc_find_description(PCI_VENDOR(pa->pa_id),
147: PCI_PRODUCT(pa->pa_id), PCI_VENDOR(subsys), PCI_PRODUCT(subsys));
148: if (sc->sc_desc == NULL) {
149: /*
150: * This was a class/subclass match, so tell people to compile
151: * kernel with options that cause this driver to spew.
152: */
153: #ifdef PUC_PRINT_REGS
154: printf(":\n");
155: pci_conf_print(pa->pa_pc, pa->pa_tag, NULL);
156: #else
157: printf(": unknown PCI communications device\n");
158: printf("%s: compile kernel with PUC_PRINT_REGS and larger\n",
159: sc->sc_dev.dv_xname);
160: printf("%s: message buffer (via 'options MSGBUFSIZE=...'),\n",
161: sc->sc_dev.dv_xname);
162: printf("%s: and report the result with sendbug(1)\n",
163: sc->sc_dev.dv_xname);
164: #endif
165: return;
166: }
167:
168: puc_print_ports(sc->sc_desc);
169:
170: /*
171: * XXX This driver assumes that 'com' ports attached to it
172: * XXX can not be console. That isn't unreasonable, because PCI
173: * XXX devices are supposed to be dynamically mapped, and com
174: * XXX console ports want fixed addresses. When/if baseboard
175: * XXX 'com' ports are identified as PCI/communications/serial
176: * XXX devices and are known to be mapped at the standard
177: * XXX addresses, if they can be the system console then we have
178: * XXX to cope with doing the mapping right. Then this will get
179: * XXX really ugly. Of course, by then we might know the real
180: * XXX definition of PCI/communications/serial, and attach 'com'
181: * XXX directly on PCI.
182: */
183: for (i = 0; i < PUC_NBARS; i++) {
184: pcireg_t type;
185: int bar;
186:
187: sc->sc_bar_mappings[i].mapped = 0;
188: bar = PCI_MAPREG_START + 4 * i;
189: if (!pci_mapreg_probe(pa->pa_pc, pa->pa_tag, bar, &type))
190: continue;
191:
192: sc->sc_bar_mappings[i].mapped = (pci_mapreg_map(pa, bar, type,
193: 0, &sc->sc_bar_mappings[i].t, &sc->sc_bar_mappings[i].h,
194: &sc->sc_bar_mappings[i].a, &sc->sc_bar_mappings[i].s, 0)
195: == 0);
196: sc->sc_bar_mappings[i].type = type;
197: if (sc->sc_bar_mappings[i].mapped)
198: continue;
199:
200: printf("%s: couldn't map BAR at offset 0x%lx\n",
201: sc->sc_dev.dv_xname, (long)bar);
202: }
203:
204: /* Map interrupt. */
205: psc->pc = pa->pa_pc;
206: if (pci_intr_map(pa, &psc->ih)) {
207: printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname);
208: return;
209: }
210:
211: paa.puc = sc;
212: paa.hwtype = 0; /* autodetect */
213: paa.intr_string = &puc_pci_intr_string;
214: paa.intr_establish = &puc_pci_intr_establish;
215:
216: /*
217: * If this is a serial card with a known specific chip, provide
218: * the UART type.
219: */
220: if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_PLX &&
221: PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_PLX_CRONYX_OMEGA)
222: paa.hwtype = 0x08; /* XXX COM_UART_ST16C654 */
223:
224: puc_common_attach(sc, &paa);
225: }
226:
227: void
228: puc_common_attach(struct puc_softc *sc, struct puc_attach_args *paa)
229: {
230: int i, bar;
231:
232: /*
233: * XXX the sub-devices establish the interrupts, for the
234: * XXX following reasons:
235: * XXX
236: * XXX * we can't really know what IPLs they'd want
237: * XXX
238: * XXX * the MD dispatching code can ("should") dispatch
239: * XXX chained interrupts better than we can.
240: * XXX
241: * XXX It would be nice if we could indicate to the MD interrupt
242: * XXX handling code that the interrupt line used by the device
243: * XXX was a PCI (level triggered) interrupt.
244: * XXX
245: * XXX It's not pretty, but hey, what is?
246: */
247:
248: /* Configure each port. */
249: for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) {
250: /* Skip unknown ports */
251: if (sc->sc_desc->ports[i].type != PUC_PORT_TYPE_COM &&
252: sc->sc_desc->ports[i].type != PUC_PORT_TYPE_LPT)
253: continue;
254: /* make sure the base address register is mapped */
255: bar = PUC_PORT_BAR_INDEX(sc->sc_desc->ports[i].bar);
256: if (!sc->sc_bar_mappings[bar].mapped) {
257: printf("%s: %s port uses unmapped BAR (0x%x)\n",
258: sc->sc_dev.dv_xname,
259: puc_port_type_name(sc->sc_desc->ports[i].type),
260: sc->sc_desc->ports[i].bar);
261: continue;
262: }
263:
264: /* set up to configure the child device */
265: paa->port = i;
266: paa->type = sc->sc_desc->ports[i].type;
267: paa->flags = sc->sc_desc->ports[i].flags;
268: paa->a = sc->sc_bar_mappings[bar].a;
269: paa->t = sc->sc_bar_mappings[bar].t;
270:
271: if (bus_space_subregion(sc->sc_bar_mappings[bar].t,
272: sc->sc_bar_mappings[bar].h, sc->sc_desc->ports[i].offset,
273: sc->sc_bar_mappings[bar].s - sc->sc_desc->ports[i].offset,
274: &paa->h)) {
275: printf("%s: couldn't get subregion for port %d\n",
276: sc->sc_dev.dv_xname, i);
277: continue;
278: }
279:
280: #if 0
281: if (autoconf_verbose)
282: printf("%s: port %d: %s @ (index %d) 0x%x "
283: "(0x%lx, 0x%lx)\n", sc->sc_dev.dv_xname, paa->port,
284: puc_port_type_name(paa->type), bar, (int)paa->a,
285: (long)paa->t, (long)paa->h);
286: #endif
287:
288: /* and configure it */
289: sc->sc_ports[i].dev = config_found_sm(&sc->sc_dev, paa,
290: puc_print, puc_submatch);
291: }
292: }
293:
294: int
295: puc_print(void *aux, const char *pnp)
296: {
297: struct puc_attach_args *paa = aux;
298:
299: if (pnp)
300: printf("%s at %s", puc_port_type_name(paa->type), pnp);
301: printf(" port %d", paa->port);
302: return (UNCONF);
303: }
304:
305: int
306: puc_submatch(struct device *parent, void *vcf, void *aux)
307: {
308: struct cfdata *cf = (struct cfdata *)vcf;
309: struct puc_attach_args *aa = aux;
310:
311: if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != aa->port)
312: return 0;
313: return ((*cf->cf_attach->ca_match)(parent, cf, aux));
314: }
315:
316: const struct puc_device_description *
317: puc_find_description(u_long vend, u_long prod, u_long svend, u_long sprod)
318: {
319: int i;
320:
321: #define checkreg(val, index) \
322: (((val) & puc_devices[i].rmask[(index)]) == puc_devices[i].rval[(index)])
323: #define pucdevdone(idx) \
324: (puc_devices[idx].rval[0] == 0 && puc_devices[idx].rval[1] == 0 \
325: && puc_devices[idx].rval[2] == 0 && puc_devices[idx].rval[3] == 0)
326:
327: for (i = 0; !pucdevdone(i); i++) {
328: if (checkreg(vend, PUC_REG_VEND) &&
329: checkreg(prod, PUC_REG_PROD) &&
330: checkreg(svend, PUC_REG_SVEND) &&
331: checkreg(sprod, PUC_REG_SPROD))
332: return (&puc_devices[i]);
333: }
334:
335: #undef devdone
336: #undef checkreg
337:
338: return (NULL);
339: }
340:
341: const char *
342: puc_port_type_name(int type)
343: {
344:
345: switch (type) {
346: case PUC_PORT_TYPE_COM:
347: return "com";
348: case PUC_PORT_TYPE_LPT:
349: return "lpt";
350: default:
351: return "unknown";
352: }
353: }
354:
355: void
356: puc_print_ports(const struct puc_device_description *desc)
357: {
358: int i, ncom, nlpt;
359:
360: printf(": ports: ");
361: for (i = ncom = nlpt = 0; PUC_PORT_VALID(desc, i); i++) {
362: switch (desc->ports[i].type) {
363: case PUC_PORT_TYPE_COM:
364: ncom++;
365: break;
366: case PUC_PORT_TYPE_LPT:
367: nlpt++;
368: break;
369: default:
370: printf("port %d unknown type %d ", i,
371: desc->ports[i].type);
372: }
373: }
374: if (ncom)
375: printf("%d com", ncom);
376: if (nlpt) {
377: if (ncom)
378: printf(", ");
379: printf("%d lpt", nlpt);
380: }
381: printf("\n");
382: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to puc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci