1/* $NetBSD: puc.c,v 1.7 2000/07/29 17:43:38 jlam Exp $ */ 2
| |
3/*-
| 1/*-
|
4 * Copyright (c) 2002 JF Hay. All rights reserved. 5 * Copyright (c) 2000 M. Warner Losh. All rights reserved.
| 2 * Copyright (c) 2006 Marcel Moolenaar 3 * All rights reserved.
|
6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met:
| 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:
|
10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution.
| |
15 *
| 8 *
|
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29/*- 30 * Copyright (c) 1996, 1998, 1999 31 * Christopher G. Demetriou. All rights reserved. 32 * 33 * Redistribution and use in source and binary forms, with or without 34 * modification, are permitted provided that the following conditions 35 * are met:
| |
36 * 1. Redistributions of source code must retain the above copyright 37 * notice, this list of conditions and the following disclaimer. 38 * 2. Redistributions in binary form must reproduce the above copyright 39 * notice, this list of conditions and the following disclaimer in the 40 * documentation and/or other materials provided with the distribution.
| 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.
|
41 * 3. All advertising materials mentioning features or use of this software 42 * must display the following acknowledgement: 43 * This product includes software developed by Christopher G. Demetriou 44 * for the NetBSD Project. 45 * 4. The name of the author may not be used to endorse or promote products 46 * derived from this software without specific prior written permission
| |
47 * 48 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 49 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 50 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 51 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 52 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 53 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 54 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 55 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 56 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 57 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 58 */ 59 60#include <sys/cdefs.h>
| 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 WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h>
|
61__FBSDID("$FreeBSD: head/sys/dev/puc/puc.c 155917 2006-02-22 17:19:10Z jhb $");
| 28__FBSDID("$FreeBSD: head/sys/dev/puc/puc.c 158124 2006-04-28 21:21:53Z marcel $");
|
62
| 29
|
63/* 64 * PCI "universal" communication card device driver, glues com, lpt, 65 * and similar ports to PCI via bridge chip often much larger than 66 * the devices being glued. 67 * 68 * Author: Christopher G. Demetriou, May 14, 1998 (derived from NetBSD 69 * sys/dev/pci/pciide.c, revision 1.6). 70 * 71 * These devices could be (and some times are) described as 72 * communications/{serial,parallel}, etc. devices with known 73 * programming interfaces, but those programming interfaces (in 74 * particular the BAR assignments for devices, etc.) in fact are not 75 * particularly well defined. 76 * 77 * After I/we have seen more of these devices, it may be possible 78 * to generalize some of these bits. In particular, devices which 79 * describe themselves as communications/serial/16[45]50, and 80 * communications/parallel/??? might be attached via direct 81 * 'com' and 'lpt' attachments to pci. 82 */ 83 84#include "opt_puc.h" 85
| |
86#include <sys/param.h> 87#include <sys/systm.h> 88#include <sys/kernel.h> 89#include <sys/bus.h> 90#include <sys/conf.h> 91#include <sys/malloc.h>
| 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/kernel.h> 33#include <sys/bus.h> 34#include <sys/conf.h> 35#include <sys/malloc.h>
|
| 36#include <sys/mutex.h>
|
92 93#include <machine/bus.h> 94#include <machine/resource.h> 95#include <sys/rman.h> 96 97#include <dev/pci/pcireg.h> 98#include <dev/pci/pcivar.h> 99
| 37 38#include <machine/bus.h> 39#include <machine/resource.h> 40#include <sys/rman.h> 41 42#include <dev/pci/pcireg.h> 43#include <dev/pci/pcivar.h> 44
|
100#define PUC_ENTRAILS 1 101#include <dev/puc/pucvar.h>
| 45#include <dev/puc/puc_bfe.h> 46#include <dev/puc/puc_bus.h> 47#include <dev/puc/puc_cfg.h>
|
102
| 48
|
103struct puc_device { 104 struct resource_list resources; 105 int port; 106 int regshft; 107 u_int serialfreq; 108 u_int subtype; 109};
| 49#define PUC_ISRCCNT 5
|
110
| 50
|
111static void puc_intr(void *arg);
| 51struct puc_port { 52 struct puc_bar *p_bar; 53 struct resource *p_rres; 54 struct resource *p_ires; 55 device_t p_dev; 56 int p_nr; 57 int p_type; 58 int p_rclk;
|
112
| 59
|
113static int puc_find_free_unit(char *); 114#ifdef PUC_DEBUG 115static void puc_print_resource_list(struct resource_list *); 116#endif
| 60 int p_hasintr:1;
|
117
| 61
|
| 62 driver_intr_t *p_ih; 63 serdev_intr_t *p_ihsrc[PUC_ISRCCNT]; 64 void *p_iharg; 65 66 int p_ipend; 67}; 68
|
118devclass_t puc_devclass;
| 69devclass_t puc_devclass;
|
| 70const char puc_driver_name[] = "puc";
|
119
| 71
|
120static int 121puc_port_bar_index(struct puc_softc *sc, int bar)
| 72MALLOC_DEFINE(M_PUC, "PUC", "PUC driver"); 73 74struct puc_bar * 75puc_get_bar(struct puc_softc *sc, int rid)
|
122{
| 76{
|
123 int i;
| 77 struct puc_bar *bar; 78 struct rman *rm; 79 u_long end, start; 80 int error, i;
|
124
| 81
|
125 for (i = 0; i < PUC_MAX_BAR; i += 1) { 126 if (!sc->sc_bar_mappings[i].used) 127 break; 128 if (sc->sc_bar_mappings[i].bar == bar) 129 return (i);
| 82 /* Find the BAR entry with the given RID. */ 83 i = 0; 84 while (i < PUC_PCI_BARS && sc->sc_bar[i].b_rid != rid) 85 i++; 86 if (i < PUC_PCI_BARS) 87 return (&sc->sc_bar[i]); 88 89 /* Not found. If we're looking for an unused entry, return NULL. */ 90 if (rid == -1) 91 return (NULL); 92 93 /* Get an unused entry for us to fill. */ 94 bar = puc_get_bar(sc, -1); 95 if (bar == NULL) 96 return (NULL); 97 bar->b_rid = rid; 98 bar->b_type = SYS_RES_IOPORT; 99 bar->b_res = bus_alloc_resource_any(sc->sc_dev, bar->b_type, 100 &bar->b_rid, RF_ACTIVE); 101 if (bar->b_res == NULL) { 102 bar->b_rid = rid; 103 bar->b_type = SYS_RES_MEMORY; 104 bar->b_res = bus_alloc_resource_any(sc->sc_dev, bar->b_type, 105 &bar->b_rid, RF_ACTIVE); 106 if (bar->b_res == NULL) { 107 bar->b_rid = -1; 108 return (NULL); 109 }
|
130 }
| 110 }
|
131 if (i == PUC_MAX_BAR) { 132 printf("%s: out of bars!\n", __func__); 133 return (-1);
| 111 112 /* Update our managed space. */ 113 rm = (bar->b_type == SYS_RES_IOPORT) ? &sc->sc_ioport : &sc->sc_iomem; 114 start = rman_get_start(bar->b_res); 115 end = rman_get_end(bar->b_res); 116 error = rman_manage_region(rm, start, end); 117 if (error) { 118 bus_release_resource(sc->sc_dev, bar->b_type, bar->b_rid, 119 bar->b_res); 120 bar->b_res = NULL; 121 bar->b_rid = -1; 122 bar = NULL;
|
134 }
| 123 }
|
135 sc->sc_bar_mappings[i].bar = bar; 136 sc->sc_bar_mappings[i].used = 1; 137 return (i);
| 124 125 return (bar);
|
138} 139
| 126} 127
|
140static int 141puc_probe_ilr(struct puc_softc *sc, struct resource *res)
| 128static void 129puc_intr(void *arg)
|
142{
| 130{
|
143 u_char t1, t2; 144 int i;
| 131 struct puc_port *port; 132 struct puc_softc *sc = arg; 133 u_long dev, devs; 134 int i, idx, ipend, isrc; 135 uint8_t ilr;
|
145
| 136
|
146 switch (sc->sc_desc.ilr_type) { 147 case PUC_ILR_TYPE_DIGI: 148 sc->ilr_st = rman_get_bustag(res); 149 sc->ilr_sh = rman_get_bushandle(res); 150 for (i = 0; i < 2 && sc->sc_desc.ilr_offset[i] != 0; i++) { 151 t1 = bus_space_read_1(sc->ilr_st, sc->ilr_sh, 152 sc->sc_desc.ilr_offset[i]); 153 t1 = ~t1; 154 bus_space_write_1(sc->ilr_st, sc->ilr_sh, 155 sc->sc_desc.ilr_offset[i], t1); 156 t2 = bus_space_read_1(sc->ilr_st, sc->ilr_sh, 157 sc->sc_desc.ilr_offset[i]); 158 if (t2 == t1) 159 return (0);
| 137 devs = sc->sc_serdevs; 138 if (sc->sc_ilr == PUC_ILR_DIGI) { 139 idx = 0; 140 while (devs & (0xfful << idx)) { 141 ilr = ~bus_read_1(sc->sc_port[idx].p_rres, 7); 142 devs &= ~0ul ^ ((u_long)ilr << idx); 143 idx += 8;
|
160 }
| 144 }
|
161 return (1);
| 145 } else if (sc->sc_ilr == PUC_ILR_QUATECH) { 146 /* 147 * Don't trust the value if it's the same as the option 148 * register. It may mean that the ILR is not active and 149 * we're reading the option register instead. This may 150 * lead to false positives on 8-port boards. 151 */ 152 ilr = bus_read_1(sc->sc_port[0].p_rres, 7); 153 if (ilr != (sc->sc_cfg_data & 0xff)) 154 devs &= (u_long)ilr; 155 }
|
162
| 156
|
163 default: 164 break;
| 157 ipend = 0; 158 idx = 0, dev = 1UL; 159 while (devs != 0UL) { 160 while ((devs & dev) == 0UL) 161 idx++, dev <<= 1; 162 devs &= ~dev; 163 port = &sc->sc_port[idx]; 164 port->p_ipend = SERDEV_IPEND(port->p_dev); 165 ipend |= port->p_ipend;
|
165 }
| 166 }
|
166 return (0);
| 167 168 i = 0, isrc = SER_INT_OVERRUN; 169 while (ipend) { 170 while (i < PUC_ISRCCNT && !(ipend & isrc)) 171 i++, isrc <<= 1; 172 KASSERT(i < PUC_ISRCCNT, ("%s", __func__)); 173 ipend &= ~isrc; 174 idx = 0, dev = 1UL; 175 devs = sc->sc_serdevs; 176 while (devs != 0UL) { 177 while ((devs & dev) == 0UL) 178 idx++, dev <<= 1; 179 devs &= ~dev; 180 port = &sc->sc_port[idx]; 181 if (!(port->p_ipend & isrc)) 182 continue; 183 if (port->p_ihsrc[i] != NULL) 184 (*port->p_ihsrc[i])(port->p_iharg); 185 } 186 }
|
167} 168 169int
| 187} 188 189int
|
170puc_attach(device_t dev, const struct puc_device_description *desc)
| 190puc_bfe_attach(device_t dev)
|
171{
| 191{
|
172 char *typestr; 173 int bidx, childunit, i, irq_setup, ressz, rid, type;
| 192 char buffer[64]; 193 struct puc_bar *bar; 194 struct puc_port *port;
|
174 struct puc_softc *sc;
| 195 struct puc_softc *sc;
|
175 struct puc_device *pdev; 176 struct resource *res; 177 struct resource_list_entry *rle; 178 bus_space_handle_t bh;
| 196 struct rman *rm; 197 intptr_t res; 198 bus_addr_t ofs, start; 199 bus_size_t size; 200 bus_space_handle_t bsh; 201 bus_space_tag_t bst; 202 int error, idx;
|
179
| 203
|
180 if (desc == NULL) 181 return (ENXIO);
| 204 sc = device_get_softc(dev);
|
182
| 205
|
183 sc = (struct puc_softc *)device_get_softc(dev); 184 bzero(sc, sizeof(*sc)); 185 sc->sc_desc = *desc;
| 206 for (idx = 0; idx < PUC_PCI_BARS; idx++) 207 sc->sc_bar[idx].b_rid = -1;
|
186
| 208
|
187#ifdef PUC_DEBUG 188 bootverbose = 1;
| 209 do { 210 sc->sc_ioport.rm_type = RMAN_ARRAY; 211 error = rman_init(&sc->sc_ioport); 212 if (!error) { 213 sc->sc_iomem.rm_type = RMAN_ARRAY; 214 error = rman_init(&sc->sc_iomem); 215 if (!error) { 216 sc->sc_irq.rm_type = RMAN_ARRAY; 217 error = rman_init(&sc->sc_irq); 218 if (!error) 219 break; 220 rman_fini(&sc->sc_iomem); 221 } 222 rman_fini(&sc->sc_ioport); 223 } 224 return (error); 225 } while (0);
|
189
| 226
|
190 printf("puc: name: %s\n", sc->sc_desc.name); 191#endif 192 rid = 0; 193 res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 194 RF_ACTIVE | RF_SHAREABLE); 195 if (!res) 196 return (ENXIO);
| 227 snprintf(buffer, sizeof(buffer), "%s I/O port mapping", 228 device_get_nameunit(dev)); 229 sc->sc_ioport.rm_descr = strdup(buffer, M_PUC); 230 snprintf(buffer, sizeof(buffer), "%s I/O memory mapping", 231 device_get_nameunit(dev)); 232 sc->sc_iomem.rm_descr = strdup(buffer, M_PUC); 233 snprintf(buffer, sizeof(buffer), "%s port numbers", 234 device_get_nameunit(dev)); 235 sc->sc_irq.rm_descr = strdup(buffer, M_PUC);
|
197
| 236
|
198 sc->irqres = res; 199 sc->irqrid = rid; 200#ifdef PUC_FASTINTR 201 irq_setup = bus_setup_intr(dev, res, 202 INTR_TYPE_TTY | INTR_FAST, puc_intr, sc, &sc->intr_cookie); 203 if (irq_setup == 0) 204 sc->fastintr = INTR_FAST; 205 else 206#else 207 irq_setup = bus_setup_intr(dev, res, 208 INTR_TYPE_TTY, puc_intr, sc, &sc->intr_cookie); 209#endif 210 if (irq_setup != 0) 211 return (ENXIO);
| 237 error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res); 238 KASSERT(error == 0, ("%s %d", __func__, __LINE__)); 239 sc->sc_nports = (int)res; 240 sc->sc_port = malloc(sc->sc_nports * sizeof(struct puc_port), 241 M_PUC, M_WAITOK|M_ZERO);
|
212
| 242
|
213 rid = 0; 214 for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) { 215 if (i > 0 && rid == sc->sc_desc.ports[i].bar) 216 sc->barmuxed = 1; 217 rid = sc->sc_desc.ports[i].bar; 218 bidx = puc_port_bar_index(sc, rid);
| 243 error = rman_manage_region(&sc->sc_irq, 1, sc->sc_nports); 244 if (error) 245 goto fail;
|
219
| 246
|
220 if (bidx < 0 || sc->sc_bar_mappings[bidx].res != NULL) 221 continue;
| 247 error = puc_config(sc, PUC_CFG_SETUP, 0, &res); 248 if (error) 249 goto fail;
|
222
| 250
|
223 type = (sc->sc_desc.ports[i].flags & PUC_FLAGS_MEMORY) 224 ? SYS_RES_MEMORY : SYS_RES_IOPORT; 225 226 res = bus_alloc_resource_any(dev, type, &rid, 227 RF_ACTIVE); 228 if (res == NULL && 229 sc->sc_desc.ports[i].flags & PUC_FLAGS_ALTRES) { 230 type = (type == SYS_RES_IOPORT) 231 ? SYS_RES_MEMORY : SYS_RES_IOPORT; 232 res = bus_alloc_resource_any(dev, type, &rid, 233 RF_ACTIVE);
| 251 for (idx = 0; idx < sc->sc_nports; idx++) { 252 port = &sc->sc_port[idx]; 253 port->p_nr = idx + 1; 254 error = puc_config(sc, PUC_CFG_GET_TYPE, idx, &res); 255 if (error) 256 goto fail; 257 port->p_type = res; 258 error = puc_config(sc, PUC_CFG_GET_RID, idx, &res); 259 if (error) 260 goto fail; 261 bar = puc_get_bar(sc, res); 262 if (bar == NULL) { 263 error = ENXIO; 264 goto fail;
|
234 }
| 265 }
|
235 if (res == NULL) { 236 device_printf(dev, "could not get resource\n"); 237 continue;
| 266 port->p_bar = bar; 267 start = rman_get_start(bar->b_res); 268 error = puc_config(sc, PUC_CFG_GET_OFS, idx, &res); 269 if (error) 270 goto fail; 271 ofs = res; 272 error = puc_config(sc, PUC_CFG_GET_LEN, idx, &res); 273 if (error) 274 goto fail; 275 size = res; 276 rm = (bar->b_type == SYS_RES_IOPORT) 277 ? &sc->sc_ioport: &sc->sc_iomem; 278 port->p_rres = rman_reserve_resource(rm, start + ofs, 279 start + ofs + size - 1, size, 0, NULL); 280 if (port->p_rres != NULL) { 281 bsh = rman_get_bushandle(bar->b_res); 282 bst = rman_get_bustag(bar->b_res); 283 bus_space_subregion(bst, bsh, ofs, size, &bsh); 284 rman_set_bushandle(port->p_rres, bsh); 285 rman_set_bustag(port->p_rres, bst);
|
238 }
| 286 }
|
239 sc->sc_bar_mappings[bidx].type = type; 240 sc->sc_bar_mappings[bidx].res = res; 241 242 if (sc->sc_desc.ilr_type != PUC_ILR_TYPE_NONE) { 243 sc->ilr_enabled = puc_probe_ilr(sc, res); 244 if (sc->ilr_enabled) 245 device_printf(dev, "ILR enabled\n"); 246 else 247 device_printf(dev, "ILR disabled\n");
| 287 port->p_ires = rman_reserve_resource(&sc->sc_irq, port->p_nr, 288 port->p_nr, 1, 0, NULL); 289 if (port->p_ires == NULL) { 290 error = ENXIO; 291 goto fail;
|
248 }
| 292 }
|
249#ifdef PUC_DEBUG 250 printf("%s rid %d bst %lx, start %lx, end %lx\n", 251 (type == SYS_RES_MEMORY) ? "memory" : "port", rid, 252 (u_long)rman_get_bustag(res), (u_long)rman_get_start(res), 253 (u_long)rman_get_end(res)); 254#endif 255 }
| 293 error = puc_config(sc, PUC_CFG_GET_CLOCK, idx, &res); 294 if (error) 295 goto fail; 296 port->p_rclk = res;
|
256
| 297
|
257 if (desc->init != NULL) { 258 i = desc->init(sc); 259 if (i != 0) 260 return (i);
| 298 port->p_dev = device_add_child(dev, NULL, -1); 299 if (port->p_dev != NULL) 300 device_set_ivars(port->p_dev, (void *)port);
|
261 } 262
| 301 } 302
|
263 for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) { 264 rid = sc->sc_desc.ports[i].bar; 265 bidx = puc_port_bar_index(sc, rid); 266 if (bidx < 0 || sc->sc_bar_mappings[bidx].res == NULL) 267 continue;
| 303 error = puc_config(sc, PUC_CFG_GET_ILR, 0, &res); 304 if (error) 305 goto fail; 306 sc->sc_ilr = res; 307 if (bootverbose && sc->sc_ilr != 0) 308 device_printf(dev, "using interrupt latch register\n");
|
268
| 309
|
269 switch (sc->sc_desc.ports[i].type & ~PUC_PORT_SUBTYPE_MASK) { 270 case PUC_PORT_TYPE_COM: 271 typestr = "sio"; 272 break; 273 case PUC_PORT_TYPE_LPT: 274 typestr = "ppc"; 275 break; 276 case PUC_PORT_TYPE_UART: 277 typestr = "uart"; 278 break; 279 default: 280 continue; 281 } 282 switch (sc->sc_desc.ports[i].type & PUC_PORT_SUBTYPE_MASK) { 283 case PUC_PORT_UART_SAB82532: 284 ressz = 64; 285 break; 286 case PUC_PORT_UART_Z8530: 287 ressz = 2; 288 break; 289 default: 290 ressz = 8; 291 break; 292 } 293 pdev = malloc(sizeof(struct puc_device), M_DEVBUF, 294 M_NOWAIT | M_ZERO); 295 if (!pdev) 296 continue; 297 resource_list_init(&pdev->resources);
| 310 sc->sc_irid = 0; 311 sc->sc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->sc_irid, 312 RF_ACTIVE|RF_SHAREABLE); 313 if (sc->sc_ires != NULL) { 314 error = bus_setup_intr(dev, sc->sc_ires, 315 INTR_TYPE_TTY | INTR_FAST, puc_intr, sc, &sc->sc_icookie); 316 if (error) 317 error = bus_setup_intr(dev, sc->sc_ires, 318 INTR_TYPE_TTY | INTR_MPSAFE, puc_intr, sc, 319 &sc->sc_icookie); 320 else 321 sc->sc_fastintr = 1;
|
298
| 322
|
299 /* First fake up an IRQ resource. */ 300 resource_list_add(&pdev->resources, SYS_RES_IRQ, 0, 301 rman_get_start(sc->irqres), rman_get_end(sc->irqres), 302 rman_get_end(sc->irqres) - rman_get_start(sc->irqres) + 1); 303 rle = resource_list_find(&pdev->resources, SYS_RES_IRQ, 0); 304 rle->res = sc->irqres; 305 306 /* Now fake an IOPORT or MEMORY resource */ 307 res = sc->sc_bar_mappings[bidx].res; 308 type = sc->sc_bar_mappings[bidx].type; 309 resource_list_add(&pdev->resources, type, 0, 310 rman_get_start(res) + sc->sc_desc.ports[i].offset, 311 rman_get_start(res) + sc->sc_desc.ports[i].offset 312 + ressz - 1, ressz); 313 rle = resource_list_find(&pdev->resources, type, 0); 314 315 if (sc->barmuxed == 0) { 316 rle->res = sc->sc_bar_mappings[bidx].res; 317 } else { 318 rle->res = rman_secret_puc_alloc_resource(M_WAITOK); 319 if (rle->res == NULL) { 320 free(pdev, M_DEVBUF); 321 return (ENOMEM); 322 } 323 324 rman_set_start(rle->res, rman_get_start(res) + 325 sc->sc_desc.ports[i].offset); 326 rman_set_end(rle->res, rman_get_start(rle->res) + 327 ressz - 1); 328 rman_set_bustag(rle->res, rman_get_bustag(res)); 329 bus_space_subregion(rman_get_bustag(rle->res), 330 rman_get_bushandle(res), 331 sc->sc_desc.ports[i].offset, ressz, 332 &bh); 333 rman_set_bushandle(rle->res, bh);
| 323 if (error) { 324 device_printf(dev, "could not activate interrupt\n"); 325 bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, 326 sc->sc_ires); 327 sc->sc_ires = NULL;
|
334 }
| 328 }
|
| 329 } 330 if (sc->sc_ires == NULL) { 331 /* XXX no interrupt resource. Force polled mode. */ 332 sc->sc_polled = 1; 333 }
|
335
| 334
|
336 pdev->port = i + 1; 337 pdev->serialfreq = sc->sc_desc.ports[i].serialfreq; 338 pdev->subtype = sc->sc_desc.ports[i].type & 339 PUC_PORT_SUBTYPE_MASK; 340 pdev->regshft = sc->sc_desc.ports[i].regshft; 341 342 childunit = puc_find_free_unit(typestr); 343 if (childunit < 0 && strcmp(typestr, "uart") != 0) { 344 typestr = "uart"; 345 childunit = puc_find_free_unit(typestr); 346 } 347 sc->sc_ports[i].dev = device_add_child(dev, typestr, 348 childunit); 349 if (sc->sc_ports[i].dev == NULL) { 350 if (sc->barmuxed) { 351 bus_space_unmap(rman_get_bustag(rle->res), 352 rman_get_bushandle(rle->res), ressz); 353 rman_secret_puc_free_resource(rle->res); 354 free(pdev, M_DEVBUF); 355 }
| 335 /* Probe and attach our children. */ 336 for (idx = 0; idx < sc->sc_nports; idx++) { 337 port = &sc->sc_port[idx]; 338 if (port->p_dev == NULL)
|
356 continue;
| 339 continue;
|
| 340 error = device_probe_and_attach(port->p_dev); 341 if (error) { 342 device_delete_child(dev, port->p_dev); 343 port->p_dev = NULL;
|
357 }
| 344 }
|
358 device_set_ivars(sc->sc_ports[i].dev, pdev); 359 device_set_desc(sc->sc_ports[i].dev, sc->sc_desc.name); 360#ifdef PUC_DEBUG 361 printf("puc: type %d, bar %x, offset %x\n", 362 sc->sc_desc.ports[i].type, 363 sc->sc_desc.ports[i].bar, 364 sc->sc_desc.ports[i].offset); 365 puc_print_resource_list(&pdev->resources); 366#endif 367 device_set_flags(sc->sc_ports[i].dev, 368 sc->sc_desc.ports[i].flags); 369 if (device_probe_and_attach(sc->sc_ports[i].dev) != 0) { 370 if (sc->barmuxed) { 371 bus_space_unmap(rman_get_bustag(rle->res), 372 rman_get_bushandle(rle->res), ressz); 373 rman_secret_puc_free_resource(rle->res); 374 free(pdev, M_DEVBUF); 375 } 376 }
| |
377 } 378
| 345 } 346
|
379#ifdef PUC_DEBUG 380 bootverbose = 0; 381#endif
| 347 /* 348 * If there are no serdev devices, then our interrupt handler 349 * will do nothing. Tear it down. 350 */ 351 if (sc->sc_serdevs == 0UL) 352 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie); 353
|
382 return (0);
| 354 return (0);
|
383}
| |
384
| 355
|
385static u_int32_t 386puc_ilr_read(struct puc_softc *sc) 387{ 388 u_int32_t mask; 389 int i; 390 391 mask = 0; 392 switch (sc->sc_desc.ilr_type) { 393 case PUC_ILR_TYPE_DIGI: 394 for (i = 1; i >= 0 && sc->sc_desc.ilr_offset[i] != 0; i--) { 395 mask = (mask << 8) | (bus_space_read_1(sc->ilr_st, 396 sc->ilr_sh, sc->sc_desc.ilr_offset[i]) & 0xff); 397 } 398 break; 399 400 default: 401 mask = 0xffffffff; 402 break;
| 356fail: 357 for (idx = 0; idx < sc->sc_nports; idx++) { 358 port = &sc->sc_port[idx]; 359 if (port->p_dev != NULL) 360 device_delete_child(dev, port->p_dev); 361 if (port->p_rres != NULL) 362 rman_release_resource(port->p_rres); 363 if (port->p_ires != NULL) 364 rman_release_resource(port->p_ires);
|
403 }
| 365 }
|
404 return (mask);
| 366 for (idx = 0; idx < PUC_PCI_BARS; idx++) { 367 bar = &sc->sc_bar[idx]; 368 if (bar->b_res != NULL) 369 bus_release_resource(sc->sc_dev, bar->b_type, 370 bar->b_rid, bar->b_res); 371 } 372 rman_fini(&sc->sc_irq); 373 free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC); 374 rman_fini(&sc->sc_iomem); 375 free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC); 376 rman_fini(&sc->sc_ioport); 377 free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC); 378 free(sc->sc_port, M_PUC); 379 return (error);
|
405} 406
| 380} 381
|
407/* 408 * This is an interrupt handler. For boards that can't tell us which 409 * device generated the interrupt it just calls all the registered 410 * handlers sequencially, but for boards that can tell us which 411 * device(s) generated the interrupt it calls only handlers for devices 412 * that actually generated the interrupt. 413 */ 414static void 415puc_intr(void *arg)
| 382int 383puc_bfe_detach(device_t dev)
|
416{
| 384{
|
417 int i; 418 u_int32_t ilr_mask;
| 385 struct puc_bar *bar; 386 struct puc_port *port;
|
419 struct puc_softc *sc;
| 387 struct puc_softc *sc;
|
| 388 int error, idx;
|
420
| 389
|
421 sc = (struct puc_softc *)arg; 422 ilr_mask = sc->ilr_enabled ? puc_ilr_read(sc) : 0xffffffff; 423 for (i = 0; i < PUC_MAX_PORTS; i++) 424 if (sc->sc_ports[i].ihand != NULL && 425 ((ilr_mask >> i) & 0x00000001)) 426 (sc->sc_ports[i].ihand)(sc->sc_ports[i].ihandarg); 427}
| 390 sc = device_get_softc(dev);
|
428
| 391
|
429static int 430puc_find_free_unit(char *name) 431{ 432 devclass_t dc; 433 int start; 434 int unit;
| 392 /* Detach our children. */ 393 error = 0; 394 for (idx = 0; idx < sc->sc_nports; idx++) { 395 port = &sc->sc_port[idx]; 396 if (port->p_dev == NULL) 397 continue; 398 if (device_detach(port->p_dev) == 0) { 399 device_delete_child(dev, port->p_dev); 400 if (port->p_rres != NULL) 401 rman_release_resource(port->p_rres); 402 if (port->p_ires != NULL) 403 rman_release_resource(port->p_ires); 404 } else 405 error = ENXIO; 406 } 407 if (error) 408 return (error);
|
435
| 409
|
436 unit = 0; 437 start = 0; 438 while (resource_int_value(name, unit, "port", &start) == 0 && 439 start > 0) 440 unit++; 441 dc = devclass_find(name); 442 if (dc == NULL) 443 return (-1); 444 while (devclass_get_device(dc, unit)) 445 unit++; 446#ifdef PUC_DEBUG 447 printf("puc: Using %s%d\n", name, unit); 448#endif 449 return (unit);
| 410 if (sc->sc_serdevs != 0UL) 411 bus_teardown_intr(dev, sc->sc_ires, sc->sc_icookie); 412 bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irid, sc->sc_ires); 413 414 for (idx = 0; idx < PUC_PCI_BARS; idx++) { 415 bar = &sc->sc_bar[idx]; 416 if (bar->b_res != NULL) 417 bus_release_resource(sc->sc_dev, bar->b_type, 418 bar->b_rid, bar->b_res); 419 } 420 421 rman_fini(&sc->sc_irq); 422 free(__DECONST(void *, sc->sc_irq.rm_descr), M_PUC); 423 rman_fini(&sc->sc_iomem); 424 free(__DECONST(void *, sc->sc_iomem.rm_descr), M_PUC); 425 rman_fini(&sc->sc_ioport); 426 free(__DECONST(void *, sc->sc_ioport.rm_descr), M_PUC); 427 free(sc->sc_port, M_PUC); 428 return (0);
|
450} 451
| 429} 430
|
452#ifdef PUC_DEBUG 453static void 454puc_print_resource_list(struct resource_list *rl)
| 431int 432puc_bfe_probe(device_t dev, const struct puc_cfg *cfg)
|
455{
| 433{
|
456#if 0 457 struct resource_list_entry *rle;
| 434 struct puc_softc *sc; 435 intptr_t res; 436 int error;
|
458
| 437
|
459 printf("print_resource_list: rl %p\n", rl); 460 SLIST_FOREACH(rle, rl, link) 461 printf(" type %x, rid %x start %lx end %lx count %lx\n", 462 rle->type, rle->rid, rle->start, rle->end, rle->count); 463 printf("print_resource_list: end.\n"); 464#endif
| 438 sc = device_get_softc(dev); 439 sc->sc_dev = dev; 440 sc->sc_cfg = cfg; 441 442 /* We don't attach to single-port serial cards. */ 443 if (cfg->ports == PUC_PORT_1S || cfg->ports == PUC_PORT_1P) 444 return (EDOOFUS); 445 error = puc_config(sc, PUC_CFG_GET_NPORTS, 0, &res); 446 if (error) 447 return (error); 448 error = puc_config(sc, PUC_CFG_GET_DESC, 0, &res); 449 if (error) 450 return (error); 451 if (res != 0) 452 device_set_desc(dev, (const char *)res); 453 return (BUS_PROBE_DEFAULT);
|
465}
| 454}
|
466#endif
| |
467 468struct resource *
| 455 456struct resource *
|
469puc_alloc_resource(device_t dev, device_t child, int type, int *rid,
| 457puc_bus_alloc_resource(device_t dev, device_t child, int type, int *rid,
|
470 u_long start, u_long end, u_long count, u_int flags) 471{
| 458 u_long start, u_long end, u_long count, u_int flags) 459{
|
472 struct puc_device *pdev; 473 struct resource *retval; 474 struct resource_list *rl; 475 struct resource_list_entry *rle; 476 device_t my_child;
| 460 struct puc_port *port; 461 struct resource *res; 462 device_t assigned, originator; 463 int error;
|
477
| 464
|
478 /* 479 * in the case of a child of child we need to find our immediate child 480 */ 481 for (my_child = child; device_get_parent(my_child) != dev; 482 my_child = device_get_parent(my_child));
| 465 /* Get our immediate child. */ 466 originator = child; 467 while (child != NULL && device_get_parent(child) != dev) 468 child = device_get_parent(child); 469 if (child == NULL) 470 return (NULL);
|
483
| 471
|
484 pdev = device_get_ivars(my_child); 485 rl = &pdev->resources;
| 472 port = device_get_ivars(child); 473 KASSERT(port != NULL, ("%s %d", __func__, __LINE__));
|
486
| 474
|
487#ifdef PUC_DEBUG 488 printf("puc_alloc_resource: pdev %p, looking for t %x, r %x\n", 489 pdev, type, *rid); 490 puc_print_resource_list(rl); 491#endif 492 retval = NULL; 493 rle = resource_list_find(rl, type, *rid); 494 if (rle) { 495#ifdef PUC_DEBUG 496 printf("found rle, %lx, %lx, %lx\n", rle->start, rle->end, 497 rle->count); 498#endif 499 retval = rle->res; 500 } 501#ifdef PUC_DEBUG
| 475 if (rid == NULL || *rid != 0) 476 return (NULL); 477 478 /* We only support default allocations. */ 479 if (start != 0UL || end != ~0UL) 480 return (NULL); 481 482 if (type == port->p_bar->b_type) 483 res = port->p_rres; 484 else if (type == SYS_RES_IRQ) 485 res = port->p_ires;
|
502 else
| 486 else
|
503 printf("oops rle is gone\n"); 504#endif
| 487 return (NULL);
|
505
| 488
|
506 return (retval);
| 489 if (res == NULL) 490 return (NULL); 491 492 assigned = rman_get_device(res); 493 if (assigned == NULL) /* Not allocated */ 494 rman_set_device(res, originator); 495 else if (assigned != originator) 496 return (NULL); 497 498 if (flags & RF_ACTIVE) { 499 error = rman_activate_resource(res); 500 if (error) { 501 if (assigned == NULL) 502 rman_set_device(res, NULL); 503 return (NULL); 504 } 505 } 506 507 return (res);
|
507} 508 509int
| 508} 509 510int
|
510puc_release_resource(device_t dev, device_t child, int type, int rid,
| 511puc_bus_release_resource(device_t dev, device_t child, int type, int rid,
|
511 struct resource *res) 512{
| 512 struct resource *res) 513{
|
| 514 struct puc_port *port; 515 device_t originator; 516 517 /* Get our immediate child. */ 518 originator = child; 519 while (child != NULL && device_get_parent(child) != dev) 520 child = device_get_parent(child); 521 if (child == NULL) 522 return (EINVAL); 523 524 port = device_get_ivars(child); 525 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 526 527 if (rid != 0 || res == NULL) 528 return (EINVAL); 529 530 if (type == port->p_bar->b_type) { 531 if (res != port->p_rres) 532 return (EINVAL); 533 } else if (type == SYS_RES_IRQ) { 534 if (res != port->p_ires) 535 return (EINVAL); 536 if (port->p_hasintr) 537 return (EBUSY); 538 } else 539 return (EINVAL); 540 541 if (rman_get_device(res) != originator) 542 return (ENXIO); 543 if (rman_get_flags(res) & RF_ACTIVE) 544 rman_deactivate_resource(res); 545 rman_set_device(res, NULL);
|
513 return (0); 514} 515 516int
| 546 return (0); 547} 548 549int
|
517puc_get_resource(device_t dev, device_t child, int type, int rid,
| 550puc_bus_get_resource(device_t dev, device_t child, int type, int rid,
|
518 u_long *startp, u_long *countp) 519{
| 551 u_long *startp, u_long *countp) 552{
|
520 struct puc_device *pdev; 521 struct resource_list *rl; 522 struct resource_list_entry *rle;
| 553 struct puc_port *port; 554 struct resource *res; 555 u_long start;
|
523
| 556
|
524 pdev = device_get_ivars(child); 525 rl = &pdev->resources;
| 557 /* Get our immediate child. */ 558 while (child != NULL && device_get_parent(child) != dev) 559 child = device_get_parent(child); 560 if (child == NULL) 561 return (EINVAL);
|
526
| 562
|
527#ifdef PUC_DEBUG 528 printf("puc_get_resource: pdev %p, looking for t %x, r %x\n", pdev, 529 type, rid); 530 puc_print_resource_list(rl); 531#endif 532 rle = resource_list_find(rl, type, rid); 533 if (rle) { 534#ifdef PUC_DEBUG 535 printf("found rle %p,", rle); 536#endif 537 if (startp != NULL) 538 *startp = rle->start; 539 if (countp != NULL) 540 *countp = rle->count; 541#ifdef PUC_DEBUG 542 printf(" %lx, %lx\n", rle->start, rle->count); 543#endif 544 return (0); 545 } else 546 printf("oops rle is gone\n"); 547 return (ENXIO);
| 563 port = device_get_ivars(child); 564 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 565 566 if (type == port->p_bar->b_type) 567 res = port->p_rres; 568 else if (type == SYS_RES_IRQ) 569 res = port->p_ires; 570 else 571 return (ENXIO); 572 573 if (rid != 0 || res == NULL) 574 return (ENXIO); 575 576 start = rman_get_start(res); 577 if (startp != NULL) 578 *startp = start; 579 if (countp != NULL) 580 *countp = rman_get_end(res) - start + 1; 581 return (0);
|
548} 549 550int
| 582} 583 584int
|
551puc_setup_intr(device_t dev, device_t child, struct resource *r, int flags, 552 void (*ihand)(void *), void *arg, void **cookiep)
| 585puc_bus_setup_intr(device_t dev, device_t child, struct resource *res, 586 int flags, void (*ihand)(void *), void *arg, void **cookiep)
|
553{
| 587{
|
554 int i;
| 588 struct puc_port *port;
|
555 struct puc_softc *sc;
| 589 struct puc_softc *sc;
|
| 590 device_t originator; 591 int i, isrc, serdev;
|
556
| 592
|
557 sc = (struct puc_softc *)device_get_softc(dev); 558 if ((flags & INTR_FAST) != sc->fastintr)
| 593 sc = device_get_softc(dev); 594 595 /* Get our immediate child. */ 596 originator = child; 597 while (child != NULL && device_get_parent(child) != dev) 598 child = device_get_parent(child); 599 if (child == NULL) 600 return (EINVAL); 601 602 port = device_get_ivars(child); 603 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 604 605 if (ihand == NULL || cookiep == NULL || res != port->p_ires) 606 return (EINVAL); 607 if (rman_get_device(port->p_ires) != originator)
|
559 return (ENXIO);
| 608 return (ENXIO);
|
560 for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) { 561 if (sc->sc_ports[i].dev == child) { 562 if (sc->sc_ports[i].ihand != 0) 563 return (ENXIO); 564 sc->sc_ports[i].ihand = ihand; 565 sc->sc_ports[i].ihandarg = arg; 566 *cookiep = arg; 567 return (0);
| 609 610 /* 611 * Have non-serdev ports handled by the bus implementation. It 612 * supports multiple handlers for a single interrupt as it is, 613 * so we wouldn't add value if we did it ourselves. 614 */ 615 serdev = 0; 616 if (port->p_type == PUC_TYPE_SERIAL) { 617 i = 0, isrc = SER_INT_OVERRUN; 618 while (i < PUC_ISRCCNT) { 619 port->p_ihsrc[i] = SERDEV_IHAND(originator, isrc); 620 if (port->p_ihsrc[i] != NULL) 621 serdev = 1; 622 i++, isrc <<= 1;
|
568 } 569 }
| 623 } 624 }
|
570 return (ENXIO);
| 625 if (!serdev) 626 return (BUS_SETUP_INTR(device_get_parent(dev), originator, 627 sc->sc_ires, flags, ihand, arg, cookiep)); 628 629 /* We demand that serdev devices use fast interrupts. */ 630 if (!(flags & INTR_FAST)) 631 return (ENXIO); 632 633 sc->sc_serdevs |= 1UL << (port->p_nr - 1); 634 635 port->p_hasintr = 1; 636 port->p_ih = ihand; 637 port->p_iharg = arg; 638 639 *cookiep = port; 640 return (0);
|
571} 572 573int
| 641} 642 643int
|
574puc_teardown_intr(device_t dev, device_t child, struct resource *r, 575 void *cookie)
| 644puc_bus_teardown_intr(device_t dev, device_t child, struct resource *res, 645 void *cookie)
|
576{
| 646{
|
577 int i;
| 647 struct puc_port *port;
|
578 struct puc_softc *sc;
| 648 struct puc_softc *sc;
|
| 649 device_t originator; 650 int i;
|
579
| 651
|
580 sc = (struct puc_softc *)device_get_softc(dev); 581 for (i = 0; PUC_PORT_VALID(sc->sc_desc, i); i++) { 582 if (sc->sc_ports[i].dev == child) { 583 sc->sc_ports[i].ihand = NULL; 584 sc->sc_ports[i].ihandarg = NULL; 585 return (0); 586 } 587 } 588 return (ENXIO);
| 652 sc = device_get_softc(dev); 653 654 /* Get our immediate child. */ 655 originator = child; 656 while (child != NULL && device_get_parent(child) != dev) 657 child = device_get_parent(child); 658 if (child == NULL) 659 return (EINVAL); 660 661 port = device_get_ivars(child); 662 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 663 664 if (res != port->p_ires) 665 return (EINVAL); 666 if (rman_get_device(port->p_ires) != originator) 667 return (ENXIO); 668 669 if (!port->p_hasintr) 670 return (BUS_TEARDOWN_INTR(device_get_parent(dev), originator, 671 sc->sc_ires, cookie)); 672 673 if (cookie != port) 674 return (EINVAL); 675 676 port->p_hasintr = 0; 677 port->p_ih = NULL; 678 port->p_iharg = NULL; 679 680 for (i = 0; i < PUC_ISRCCNT; i++) 681 port->p_ihsrc[i] = NULL; 682 683 return (0);
|
589} 590 591int
| 684} 685 686int
|
592puc_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
| 687puc_bus_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
|
593{
| 688{
|
594 struct puc_device *pdev;
| 689 struct puc_port *port;
|
595
| 690
|
596 pdev = device_get_ivars(child); 597 if (pdev == NULL) 598 return (ENOENT);
| 691 /* Get our immediate child. */ 692 while (child != NULL && device_get_parent(child) != dev) 693 child = device_get_parent(child); 694 if (child == NULL) 695 return (EINVAL);
|
599
| 696
|
| 697 port = device_get_ivars(child); 698 KASSERT(port != NULL, ("%s %d", __func__, __LINE__)); 699 700 if (result == NULL) 701 return (EINVAL); 702
|
600 switch(index) {
| 703 switch(index) {
|
601 case PUC_IVAR_FREQ: 602 *result = pdev->serialfreq;
| 704 case PUC_IVAR_CLOCK: 705 *result = port->p_rclk;
|
603 break;
| 706 break;
|
604 case PUC_IVAR_PORT: 605 *result = pdev->port;
| 707 case PUC_IVAR_TYPE: 708 *result = port->p_type;
|
606 break;
| 709 break;
|
607 case PUC_IVAR_REGSHFT: 608 *result = pdev->regshft; 609 break; 610 case PUC_IVAR_SUBTYPE: 611 *result = pdev->subtype; 612 break;
| |
613 default: 614 return (ENOENT); 615 } 616 return (0); 617}
| 710 default: 711 return (ENOENT); 712 } 713 return (0); 714}
|