1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Copyright (c) * Copyright (c) 2001 Tadpole Technology plc
28 * All rights reserved.
29 * From "@(#)pcicfg.c 1.31 99/06/18 SMI"
30 */
31
32 #pragma ident "%Z%%M% %I% %E% SMI"
33
34 /*
35 * Cardbus module
36 */
37
38 #include <sys/conf.h>
39 #include <sys/modctl.h>
40
41 #include <sys/pci.h>
42
43 #include <sys/ddi.h>
44 #include <sys/sunndi.h>
45 #include <sys/ddi_impldefs.h>
46
47 #include <sys/hotplug/hpcsvc.h>
48
49 #include <sys/pctypes.h>
50 #include <sys/pcmcia.h>
51 #include <sys/sservice.h>
52 #include <sys/note.h>
53
54 #include <sys/pci/pci_types.h>
55 #include <sys/pci/pci_sc.h>
56
57 #include <sys/pcic_reg.h>
58 #include <sys/pcic_var.h>
59 #include <sys/pcmcia.h>
60
61 #ifdef sparc
62 #include <sys/ddi_subrdefs.h>
63 #elif defined(__x86) || defined(__amd64)
64 #include <sys/pci_intr_lib.h>
65 #include <sys/mach_intr.h>
66 #endif
67
68 #include "cardbus.h"
69 #include "cardbus_parse.h"
70 #include "cardbus_hp.h"
71 #include "cardbus_cfg.h"
72
73 static int cardbus_command_default = PCI_COMM_SERR_ENABLE |
74 PCI_COMM_WAIT_CYC_ENAB |
75 PCI_COMM_PARITY_DETECT |
76 PCI_COMM_ME | PCI_COMM_MAE |
77 PCI_COMM_IO;
78
79 static int cardbus_next_instance = 0;
80 static int cardbus_count = 0;
81 int number_of_cardbus_cards = 0;
82
83 static int cardbus_bus_map(dev_info_t *dip, dev_info_t *rdip,
84 ddi_map_req_t *mp, off_t offset, off_t len, caddr_t *vaddrp);
85 static void pcirp2rp(const pci_regspec_t *pci_rp, struct regspec *rp);
86
87 static int cardbus_ctlops(dev_info_t *, dev_info_t *,
88 ddi_ctl_enum_t, void *arg, void *);
89 static void cardbus_init_child_regs(dev_info_t *child);
90 static int cardbus_initchild(dev_info_t *, dev_info_t *,
91 dev_info_t *, void *);
92 static int cardbus_name_child(dev_info_t *, char *, int);
93 static void cardbus_removechild(dev_info_t *dip);
94
95 static int cardbus_dma_allochdl(dev_info_t *dip, dev_info_t *rdip,
96 ddi_dma_attr_t *attr, int (*waitfp)(caddr_t), caddr_t arg,
97 ddi_dma_handle_t *handlep);
98 static int cardbus_dma_freehdl(dev_info_t *dip, dev_info_t *rdip,
99 ddi_dma_handle_t handle);
100 static int cardbus_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
101 ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
102 ddi_dma_cookie_t *cp, uint_t *ccountp);
103 static int cardbus_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
104 ddi_dma_handle_t handle);
105 static int cardbus_dma_flush(dev_info_t *dip, dev_info_t *rdip,
106 ddi_dma_handle_t handle, off_t off, size_t len,
107 uint_t cache_flags);
108 static int cardbus_dma_win(dev_info_t *dip, dev_info_t *rdip,
109 ddi_dma_handle_t handle, uint_t win, off_t *offp,
110 size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp);
111 static int cardbus_dma_map(dev_info_t *dip, dev_info_t *rdip,
112 struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep);
113
114 static int cardbus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
115 ddi_prop_op_t prop_op, int mod_flags,
116 char *name, caddr_t valuep, int *lengthp);
117
118 static int cardbus_get_eventcookie(dev_info_t *dip, dev_info_t *rdip,
119 char *eventname, ddi_eventcookie_t *cookiep);
120 static int cardbus_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
121 ddi_eventcookie_t cookie, void (*callback)(dev_info_t *dip,
122 ddi_eventcookie_t cookie, void *arg, void *bus_impldata),
123 void *arg, ddi_callback_id_t *cb_id);
124 static int cardbus_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id);
125 static int cardbus_post_event(dev_info_t *dip, dev_info_t *rdip,
126 ddi_eventcookie_t cookie, void *bus_impldata);
127
128 static int cardbus_intr_ops(dev_info_t *dip, dev_info_t *rdip,
129 ddi_intr_op_t intr_op,
130 ddi_intr_handle_impl_t *hdlp, void *result);
131
132 static int check_token(char *token, int *len);
133 static char *find_token(char **cp, int *l, char *endc);
134 static int parse_token(char *token);
135 static int token_to_hex(char *token, unsigned *val, int len);
136 static int token_to_dec(char *token, unsigned *val, int len);
137 static void cardbus_add_prop(struct cb_deviceset_props *cdsp, int type,
138 char *name, caddr_t vp, int len);
139 static void cardbus_add_stringprop(struct cb_deviceset_props *cdsp,
140 char *name, char *vp, int len);
141 static void cardbus_prop_free(ddi_prop_t *propp);
142 static void cardbus_devprops_free(struct cb_deviceset_props *cbdp);
143 static int cardbus_parse_devprop(cbus_t *cbp, char *cp);
144 static void cardbus_device_props(cbus_t *cbp);
145
146 static void cardbus_expand_busrange(dev_info_t *dip);
147
148 static int cardbus_convert_properties(dev_info_t *dip);
149 static void cardbus_revert_properties(dev_info_t *dip);
150
151 /*
152 * driver global data
153 */
154 kmutex_t cardbus_list_mutex; /* Protects the probe handle list */
155 void *cardbus_state;
156 int cardbus_latency_timer = 0x40;
157 int cardbus_debug = 0;
158
159 /*
160 * Module linkage information for the kernel.
161 */
162 extern struct mod_ops mod_miscops;
163 static struct modlmisc modlmisc = {
164 &mod_miscops,
165 "Cardbus Configurator support",
166 };
167
168 static struct modlinkage modlinkage = {
169 MODREV_1,
170 &modlmisc,
171 NULL
172 };
173
174 int
175 _init(void)
176 {
177 int error;
178
179 error = ddi_soft_state_init(&cardbus_state, sizeof (cbus_t), 0);
180 if (error != 0)
181 return (error);
182
183 mutex_init(&cardbus_list_mutex, NULL, MUTEX_DRIVER, NULL);
184 if ((error = mod_install(&modlinkage)) != 0) {
185 mutex_destroy(&cardbus_list_mutex);
186 }
187
188 return (error);
189 }
190
191 int
192 _fini(void)
193 {
194 int error;
195 if ((error = mod_remove(&modlinkage)) == 0) {
196 mutex_destroy(&cardbus_list_mutex);
197 ddi_soft_state_fini(&cardbus_state);
198 }
199 return (error);
200 }
201
202 int
203 _info(struct modinfo *modinfop)
204 {
205 return (mod_info(&modlinkage, modinfop));
206 }
207
208 static
209 struct bus_ops cardbusbus_ops = {
210 BUSO_REV,
211 cardbus_bus_map,
212 NULL,
213 NULL,
214 NULL,
215 i_ddi_map_fault,
216 cardbus_dma_map,
217 cardbus_dma_allochdl,
218 cardbus_dma_freehdl,
219 cardbus_dma_bindhdl,
220 cardbus_dma_unbindhdl,
221 cardbus_dma_flush,
222 cardbus_dma_win,
223 ddi_dma_mctl,
224 cardbus_ctlops, /* (*bus_ctl)(); */
225 cardbus_prop_op,
226 cardbus_get_eventcookie, /* (*bus_get_eventcookie)(); */
227 cardbus_add_eventcall, /* (*bus_add_eventcall)(); */
228 cardbus_remove_eventcall, /* (*bus_remove_eventcall)(); */
229 cardbus_post_event, /* (*bus_post_event)(); */
230 NULL, /* (*bus_intr_ctl)(); */
231 NULL, /* (*bus_config)(); */
232 NULL, /* (*bus_unconfig)(); */
233 NULL, /* (*bus_fm_init)(); */
234 NULL, /* (*bus_fm_fini)(); */
235 NULL, /* (*bus_enter)(); */
236 NULL, /* (*bus_exit)(); */
237 NULL, /* (*bus_power)(); */
238 cardbus_intr_ops /* (*bus_intr_op)(); */
239 };
240
241 #define CB_EVENT_TAG_INSERT 0
242 #define CB_EVENT_TAG_REMOVE 1
243
244 static ndi_event_definition_t cb_ndi_event_defs[] = {
245 { CB_EVENT_TAG_INSERT, DDI_DEVI_INSERT_EVENT, EPL_INTERRUPT, 0 },
246 { CB_EVENT_TAG_REMOVE, DDI_DEVI_REMOVE_EVENT, EPL_INTERRUPT, 0 }
247 };
248
249 #define CB_N_NDI_EVENTS \
250 (sizeof (cb_ndi_event_defs) / sizeof (cb_ndi_event_defs[0]))
251
252 #ifdef sparc
253 struct busnum_ctrl {
254 int rv;
255 dev_info_t *dip;
256 cardbus_bus_range_t *range;
257 };
258
259 static int
260 cardbus_claim_pci_busnum(dev_info_t *dip, void *arg)
261 {
262 cardbus_bus_range_t pci_bus_range;
263 struct busnum_ctrl *ctrl;
264 ndi_ra_request_t req;
265 char bus_type[16] = "(unknown)";
266 int len;
267 uint64_t base;
268 uint64_t retlen;
269
270 ctrl = (struct busnum_ctrl *)arg;
271
272 /* check if this is a PCI bus node */
273 len = sizeof (bus_type);
274 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
275 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
276 "device_type",
277 (caddr_t)&bus_type, &len) != DDI_SUCCESS)
278 return (0); /* (DDI_WALK_PRUNECHILD); */
279
280 if ((strcmp(bus_type, "pci") != 0) &&
281 (strcmp(bus_type, "pciex") != 0)) /* it is not a pci bus type */
282 return (0); /* (DDI_WALK_PRUNECHILD); */
283
284 /* look for the bus-range property */
285 len = sizeof (struct cardbus_bus_range);
286 if (ddi_getlongprop_buf(DDI_DEV_T_NONE, dip, DDI_PROP_DONTPASS,
287 "bus-range", (caddr_t)&pci_bus_range, &len) == DDI_SUCCESS) {
288 cardbus_err(dip, 1, "cardbus_claim_pci_busnum: %u -> %u \n",
289 pci_bus_range.lo, pci_bus_range.hi);
290 if ((pci_bus_range.lo >= ctrl->range->lo) &&
291 (pci_bus_range.hi <= ctrl->range->hi)) {
292 cardbus_err(dip, 1,
293 "cardbus_claim_pci_busnum: claim %u -> %u \n",
294 pci_bus_range.lo, pci_bus_range.hi);
295
296 /* claim the bus range from the bus resource map */
297 bzero((caddr_t)&req, sizeof (req));
298 req.ra_addr = (uint64_t)pci_bus_range.lo;
299 req.ra_flags |= NDI_RA_ALLOC_SPECIFIED;
300 req.ra_len = (uint64_t)pci_bus_range.hi -
301 (uint64_t)pci_bus_range.lo + 1;
302
303 if (ndi_ra_alloc(ctrl->dip, &req, &base, &retlen,
304 NDI_RA_TYPE_PCI_BUSNUM, 0) == NDI_SUCCESS)
305 return (0); /* (DDI_WALK_PRUNECHILD); */
306 }
307 }
308
309 /*
310 * never Error return.
311 */
312 ctrl->rv = DDI_SUCCESS;
313 return (DDI_WALK_TERMINATE);
314 }
315
316 static void
317 cardbus_walk_node_child(dev_info_t *parent,
318 int (*f)(dev_info_t *, void *), void *arg)
319 {
320 dev_info_t *dip;
321 int ret;
322
323 for (dip = ddi_get_child(parent); dip;
324 dip = ddi_get_next_sibling(dip)) {
325
326 ret = (*f) (dip, arg);
327 if (ret)
328 return;
329 }
330 }
331
332 static void cardbus_fix_hostbridge_busrange(dev_info_t *dip)
333 {
334 cardbus_bus_range_t bus_range;
335 struct busnum_ctrl ctrl;
336
337 uint64_t next_bus;
338 uint64_t blen;
339 ndi_ra_request_t req;
340 int len;
341
342 cardbus_err(dip, 1, "cardbus_fix_hostbridge_busrange\n");
343
344 bzero((caddr_t)&req, sizeof (ndi_ra_request_t));
345 req.ra_len = 1;
346 if (ndi_ra_alloc(dip, &req,
347 &next_bus, &blen, NDI_RA_TYPE_PCI_BUSNUM,
348 0) != NDI_SUCCESS) {
349 (void) ndi_ra_map_destroy(dip, NDI_RA_TYPE_PCI_BUSNUM);
350
351 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_BUSNUM)
352 == NDI_FAILURE) {
353 cardbus_err(dip, 1, "cardbus_fix_hostbridge_busrange "
354 "NDI_RA_TYPE_PCI_BUSNUM setup fail\n");
355 return;
356 }
357
358 bus_range.lo = 0;
359 (void) ddi_getlongprop_buf(DDI_DEV_T_NONE, dip,
360 DDI_PROP_DONTPASS, "bus-range", (caddr_t)&bus_range, &len);
361 bus_range.hi = 255;
362
363 (void) ndi_ra_free(dip,
364 (uint64_t)bus_range.lo + 1,
365 (uint64_t)bus_range.hi - (uint64_t)bus_range.lo,
366 NDI_RA_TYPE_PCI_BUSNUM, 0);
367
368 ctrl.rv = DDI_SUCCESS;
369 ctrl.dip = dip;
370 ctrl.range = &bus_range;
371
372 cardbus_walk_node_child(dip, cardbus_claim_pci_busnum,
373 (void*)&ctrl);
374
375 if (ctrl.rv != DDI_SUCCESS)
376 cardbus_err(dip, 1, "cardbus_fix_hostbridge_busrange "
377 "cardbus_walk_node_child fails\n");
378
379 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
380 "bus-range", (int *)&bus_range, 2);
381
382 } else {
383 cardbus_err(dip, 1, "cardbus_fix_hostbridge_busrange "
384 "already set up %x\n", (int)next_bus);
385 (void) ndi_ra_free(dip, next_bus, (uint64_t)1,
386 NDI_RA_TYPE_PCI_BUSNUM, 0);
387 }
388 }
389
390 static dev_info_t *
391 cardbus_find_hsbridge_dip(dev_info_t *dip)
392 {
393 dev_info_t *pdip;
394
395 pdip = ddi_get_parent(dip);
396 while (pdip) {
397 if (ddi_get_parent(pdip) == ddi_root_node())
398 break;
399 pdip = ddi_get_parent(pdip);
400 }
401
402 return (pdip);
403 }
404 #endif /* sparc */
405
406 /*
407 * Attach a device to the cardbus infrastructure.
408 */
409 int
410 cardbus_attach(dev_info_t *dip, cb_nexus_cb_t *nex_ops)
411 {
412 cbus_t *cbp;
413 int cb_instance;
414 anp_t *anp = (anp_t *)ddi_get_driver_private(dip);
415 struct dev_info *devi = DEVI(dip);
416
417 mutex_enter(&cardbus_list_mutex);
418
419 /*
420 * Make sure that it is not already initialized.
421 */
422 if (ddi_prop_exists(DDI_DEV_T_ANY, dip,
423 DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
424 "cbus-instance") == 1) {
425 cmn_err(CE_WARN,
426 "%s%d: cardbus instance already initialized!\n",
427 ddi_driver_name(dip), ddi_get_instance(dip));
428 mutex_exit(&cardbus_list_mutex);
429 return (DDI_FAILURE);
430 }
431
432 /*
433 * initialize soft state structure for the bus instance.
434 */
435 cb_instance = cardbus_next_instance++;
436
437 if (ddi_soft_state_zalloc(cardbus_state, cb_instance) != DDI_SUCCESS) {
438 cmn_err(CE_WARN, "%s%d: can't allocate cardbus soft state\n",
439 ddi_driver_name(dip), ddi_get_instance(dip));
440 mutex_exit(&cardbus_list_mutex);
441 return (DDI_FAILURE);
442 }
443
444 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
445 cbp->cb_instance = cb_instance;
446 cbp->cb_dip = dip;
447 mutex_init(&cbp->cb_mutex, NULL, MUTEX_DRIVER, NULL);
448
449 /*
450 * Save the instance number of the soft state structure for
451 * this bus as a devinfo property.
452 */
453 if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
454 "cbus-instance", (caddr_t)&cb_instance,
455 sizeof (cb_instance)) != DDI_SUCCESS) {
456 cmn_err(CE_WARN,
457 "%s%d: failed to add the property 'cbus-instance'",
458 ddi_driver_name(dip), ddi_get_instance(dip));
459 ddi_soft_state_free(cardbus_state, cb_instance);
460 mutex_exit(&cardbus_list_mutex);
461 return (DDI_FAILURE);
462 }
463
464 cbp->cb_nex_ops = nex_ops;
465 /*
466 * TODO - Should probably be some sort of locking on the devinfo here.
467 */
468 cbp->orig_dopsp = devi->devi_ops;
469 cbp->orig_bopsp = devi->devi_ops->devo_bus_ops;
470 cbp->cb_dops = *devi->devi_ops;
471 devi->devi_ops = &cbp->cb_dops;
472
473 if (ndi_event_alloc_hdl(dip, *anp->an_iblock, &cbp->cb_ndi_event_hdl,
474 NDI_SLEEP) == NDI_SUCCESS) {
475 cbp->cb_ndi_events.ndi_n_events = CB_N_NDI_EVENTS;
476 cbp->cb_ndi_events.ndi_events_version = NDI_EVENTS_REV1;
477 cbp->cb_ndi_events.ndi_event_defs = cb_ndi_event_defs;
478 if (ndi_event_bind_set(cbp->cb_ndi_event_hdl,
479 &cbp->cb_ndi_events,
480 NDI_SLEEP) != NDI_SUCCESS) {
481 cardbus_err(dip, 1,
482 "cardbus_attach: ndi_event_bind_set failed\n");
483 }
484 }
485
486 /*
487 * Check for device initialization property.
488 */
489 cardbus_device_props(cbp);
490
491 if (cardbus_init_hotplug(cbp) != DDI_SUCCESS) {
492 ddi_soft_state_free(cardbus_state, cb_instance);
493 mutex_exit(&cardbus_list_mutex);
494 return (DDI_FAILURE);
495 }
496
497 #ifdef sparc
498 /* a hack to fix the bus-range problem on pci root nodes */
499 {
500 dev_info_t *hs_dip;
501
502 hs_dip = cardbus_find_hsbridge_dip(dip);
503 cardbus_fix_hostbridge_busrange(hs_dip);
504 }
505 #endif
506
507 cardbus_expand_busrange(dip);
508 cardbus_count++;
509 mutex_exit(&cardbus_list_mutex);
510 return (DDI_SUCCESS);
511 }
512
513 #ifdef TODO
514 static int
515 cardbus_detach(dev_info_t *dip)
516 {
517 int cb_instance;
518 cbus_t *cbp;
519
520 mutex_enter(&cardbus_list_mutex);
521 /* get the instance number for the cardbus soft state data */
522 cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
523 DDI_PROP_DONTPASS, "cbus-instance", -1);
524 if (cb_instance < 0) {
525 mutex_exit(&cardbus_list_mutex);
526 return (DDI_FAILURE); /* no instance is setup for this bus */
527 }
528
529 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
530
531 if (cbp->cb_dsp) {
532 struct cb_deviceset_props *cbdp, *ncbdp;
533
534 cbdp = cbp->cb_dsp;
535 while (cbdp) {
536 ncbdp = cbdp->next;
537 cardbus_devprops_free(cbdp);
538 cbdp = ncbdp;
539 }
540 }
541 /*
542 * Unregister the bus with the HPS.
543 *
544 * (Note: It is assumed that the HPS framework uninstalls
545 * event handlers for all the hot plug slots on this bus.)
546 */
547 (void) hpc_nexus_unregister_bus(dip);
548
549 if (cbp->cb_ndi_event_hdl != NULL) {
550 (void) ndi_event_unbind_set(cbp->cb_ndi_event_hdl,
551 &cbp->cb_ndi_events, NDI_SLEEP);
552 ndi_event_free_hdl(cbp->cb_ndi_event_hdl);
553 }
554
555 mutex_destroy(&cbp->cb_mutex);
556 if (cbp->nexus_path)
557 kmem_free(cbp->nexus_path, strlen(cbp->nexus_path) + 1);
558 if (cbp->name)
559 kmem_free(cbp->name, strlen(cbp->name) + 1);
560
561 ddi_soft_state_free(cardbus_state, cb_instance);
562
563 /* remove the 'cbus-instance' property from the devinfo node */
564 (void) ddi_prop_remove(DDI_DEV_T_ANY, dip, "cbus-instance");
565
566 ASSERT(cardbus_count != 0);
567 --cardbus_count;
568
569 mutex_exit(&cardbus_list_mutex);
570 return (DDI_SUCCESS);
571 }
572 #endif
573
574 boolean_t
575 cardbus_load_cardbus(dev_info_t *dip, uint_t socket, uint32_t pc_base)
576 {
577 #ifndef HOTPLUG
578 struct cardbus_config_ctrl ctrl;
579 int circular_count;
580 #endif
581 int cb_instance;
582 cbus_t *cbp;
583 struct dev_info *devi = DEVI(dip);
584
585 _NOTE(ARGUNUSED(socket, pc_base))
586
587 #if defined(CARDBUS_DEBUG)
588 cardbus_err(dip, 6, "cardbus_load_cardbus\n");
589 #endif
590
591 cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
592 DDI_PROP_DONTPASS, "cbus-instance", -1);
593 ASSERT(cb_instance >= 0);
594 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
595
596 if (cbp->fatal_problem)
597 return (B_FALSE);
598
599 if (cardbus_convert_properties(dip) == DDI_FAILURE)
600 return (B_FALSE);
601
602 number_of_cardbus_cards++;
603 devi->devi_ops->devo_bus_ops = &cardbusbus_ops;
604
605 #ifdef HOTPLUG
606 mutex_enter(&cbp->cb_mutex);
607 cbp->card_present = B_TRUE;
608
609 (void) hpc_slot_event_notify(cbp->slot_handle,
610 HPC_EVENT_SLOT_INSERTION, 0);
611 (void) hpc_slot_event_notify(cbp->slot_handle,
612 HPC_EVENT_SLOT_POWER_ON, 0);
613 (void) hpc_slot_event_notify(cbp->slot_handle,
614 HPC_EVENT_SLOT_CONFIGURE, 0);
615
616 mutex_exit(&cbp->cb_mutex);
617 #else
618 if (cardbus_configure(cbp) != PCICFG_SUCCESS) {
619 #if defined(CARDBUS_DEBUG)
620 cardbus_err(dip, 6, "cardbus_configure failed\n");
621 #endif
622 return (B_FALSE);
623 }
624
625 ctrl.rv = NDI_SUCCESS;
626 ctrl.busno = cardbus_primary_busno(dip);
627 ctrl.op = PCICFG_OP_ONLINE;
628 ctrl.dip = NULL;
629 ctrl.flags = PCICFG_FLAGS_CONTINUE;
630
631 /*
632 * The child of the dip is the cardbus dip. The child of the
633 * cardbus dip is the device itself
634 */
635 #if defined(CARDBUS_DEBUG)
636 cardbus_err(dip, 8, "cardbus_load_cardbus: calling cbus_configure\n");
637 #endif
638 ndi_devi_enter(dip, &circular_count);
639 ddi_walk_devs(ddi_get_child(dip), cbus_configure, (void *)&ctrl);
640 ndi_devi_exit(dip, circular_count);
641
642 if (ctrl.rv != NDI_SUCCESS) {
643 cardbus_err(dip, 1,
644 "cardbus_load_cardbus (%s%d): failed to attach (%d)\n",
645 ctrl.dip ? ddi_driver_name(ctrl.dip) : "Unknown",
646 ctrl.dip ? ddi_get_instance(ctrl.dip) : 0,
647 ctrl.rv);
648
649 /*
650 * Returning error here will cause the pcic_load_cardbus() call
651 * to fail. This will invoke pcic_unload_cardbus() which calls
652 * cardbus_unload_cardbus() below.
653 */
654 return (B_FALSE);
655 }
656 #endif
657
658 #if defined(CARDBUS_DEBUG)
659 cardbus_err(dip, 7, "cardbus_load_cardbus: returning TRUE\n");
660 #endif
661
662 return (B_TRUE);
663 }
664
665 /*
666 * Unload the cardbus module
667 */
668 void
669 cardbus_unload_cardbus(dev_info_t *dip)
670 {
671 int cb_instance;
672 #ifndef HOTPLUG
673 int prim_bus = cardbus_primary_busno(dip);
674 int rval;
675 #endif
676 cbus_t *cbp;
677
678 cardbus_err(dip, 6, "cardbus_unload_cardbus\n");
679
680 cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
681 DDI_PROP_DONTPASS, "cbus-instance", -1);
682 ASSERT(cb_instance >= 0);
683 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
684
685 if (number_of_cardbus_cards == 0)
686 return;
687
688 #ifdef HOTPLUG
689 mutex_enter(&cbp->cb_mutex);
690 cbp->card_present = B_FALSE;
691
692 (void) hpc_slot_event_notify(cbp->slot_handle,
693 HPC_EVENT_SLOT_POWER_OFF, 0);
694 (void) hpc_slot_event_notify(cbp->slot_handle,
695 HPC_EVENT_SLOT_UNCONFIGURE, 0);
696 (void) hpc_slot_event_notify(cbp->slot_handle,
697 HPC_EVENT_SLOT_REMOVAL, 0);
698
699 mutex_exit(&cbp->cb_mutex);
700 #else
701
702 cardbus_err(dip, 8,
703 "cardbus_unload_cardbus: calling cardbus_unconfigure_node\n");
704
705 rval = cardbus_unconfigure_node(dip, prim_bus, B_TRUE);
706
707 if (rval != NDI_SUCCESS) {
708 cardbus_err(dip, 4,
709 "cardbus_unload_cardbus: "
710 "cardbus_unconfigure_node failed\n");
711 number_of_cardbus_cards--;
712 cbp->fatal_problem = B_TRUE;
713 cmn_err(CE_WARN,
714 "cardbus(%s%d): Failed to remove device tree: "
715 "Slot disabled",
716 ddi_get_name(dip), ddi_get_instance(dip));
717 return;
718 }
719
720 (void) cardbus_unconfigure(cbp);
721 #endif
722
723 /*
724 * Inform the lower drivers that the card has been removed
725 */
726 if (cbp->cb_ndi_event_hdl != NULL) {
727 ddi_eventcookie_t cookie;
728 if (ndi_event_retrieve_cookie(cbp->cb_ndi_event_hdl, dip,
729 DDI_DEVI_REMOVE_EVENT, &cookie, 0) == NDI_SUCCESS) {
730 (void) ndi_event_run_callbacks(cbp->cb_ndi_event_hdl,
731 dip, cookie, NULL);
732 }
733 }
734
735 cardbus_revert_properties(dip);
736 }
737
738 static boolean_t
739 is_32bit_pccard(dev_info_t *dip)
740 {
741 int len;
742 char bus_type[16];
743
744 len = sizeof (bus_type);
745 if (ddi_prop_op(DDI_DEV_T_ANY, ddi_get_parent(dip),
746 PROP_LEN_AND_VAL_BUF,
747 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
748 "device_type",
749 (caddr_t)&bus_type, &len) != DDI_SUCCESS)
750 return (B_FALSE);
751
752 if ((strcmp(bus_type, "pci") != 0) &&
753 (strcmp(bus_type, "pciex") != 0) &&
754 (strcmp(bus_type, "cardbus") != 0)) /* not of pci type */
755 return (B_FALSE);
756
757 return (B_TRUE);
758 }
759
760 void
761 cardbus_save_children(dev_info_t *dip)
762 {
763 for (; dip != NULL; dip = ddi_get_next_sibling(dip)) {
764 cardbus_save_children(ddi_get_child(dip));
765
766 if (strcmp("pcs", ddi_node_name(dip)) == 0)
767 continue;
768 if (!is_32bit_pccard(dip))
769 continue;
770 cardbus_err(dip, 1, "Saving device\n");
771 (void) pci_save_config_regs(dip);
772 }
773
774 }
775
776 void
777 cardbus_restore_children(dev_info_t *dip)
778 {
779 for (; dip != NULL; dip = ddi_get_next_sibling(dip)) {
780 cardbus_restore_children(ddi_get_child(dip));
781
782 if (strcmp("pcs", ddi_node_name(dip)) == 0)
783 continue;
784 if (!is_32bit_pccard(dip))
785 continue;
786 cardbus_err(dip, 1, "restoring device\n");
787 (void) pci_restore_config_regs(dip);
788 }
789
790 }
791
792 static int
793 cardbus_convert_properties(dev_info_t *dip)
794 {
795 struct pcm_regs *pcic_avail_p, *old_avail_p;
796 pci_regspec_t *cb_avail_p, *new_avail_p;
797 pcic_ranges_t *pcic_range_p, *old_range_p;
798 cardbus_range_t *cb_range_p, *new_range_p;
799 int range_len, range_entries, i;
800 int avail_len, avail_entries;
801
802 #if defined(CARDBUS_DEBUG)
803 cardbus_err(dip, 6, "cardbus_convert_properties\n");
804 #endif
805
806 if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
807 "#address-cells", 3) != DDI_SUCCESS) {
808 cardbus_err(dip, 1, "cardbus_convert_properties: "
809 "failed to update #address-cells property\n");
810 return (DDI_FAILURE);
811 }
812 if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
813 "#size-cells", 2) != DDI_SUCCESS) {
814 cardbus_err(dip, 1, "cardbus_convert_properties: "
815 "failed to update #size-cells property\n");
816 return (DDI_FAILURE);
817 }
818
819 if (ddi_getlongprop(DDI_DEV_T_NONE, dip, DDI_PROP_DONTPASS, "available",
820 (caddr_t)&pcic_avail_p, &avail_len) != DDI_PROP_SUCCESS) {
821 cardbus_err(dip, 1, "cardbus_convert_properties: "
822 "no available property for pcmcia\n");
823 } else {
824 avail_entries = avail_len / sizeof (struct pcm_regs);
825 cb_avail_p = kmem_alloc(sizeof (pci_regspec_t) * avail_entries,
826 KM_SLEEP);
827
828 old_avail_p = pcic_avail_p;
829 new_avail_p = cb_avail_p;
830 for (i = 0; i < avail_entries;
831 i++, old_avail_p++, new_avail_p++) {
832 new_avail_p->pci_phys_hi = old_avail_p->phys_hi;
833 new_avail_p->pci_phys_mid = 0;
834 new_avail_p->pci_phys_low = old_avail_p->phys_lo;
835 new_avail_p->pci_size_hi = 0;
836 new_avail_p->pci_size_low = old_avail_p->phys_len;
837 }
838
839 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
840 "available",
841 (int *)cb_avail_p,
842 (sizeof (pci_regspec_t) * avail_entries)/sizeof (int));
843
844 kmem_free(pcic_avail_p, avail_len);
845 kmem_free(cb_avail_p, sizeof (pci_regspec_t) * avail_entries);
846 }
847
848 if (ddi_getlongprop(DDI_DEV_T_NONE, dip, DDI_PROP_DONTPASS, "ranges",
849 (caddr_t)&pcic_range_p, &range_len) != DDI_PROP_SUCCESS) {
850 cardbus_err(dip, 1, "cardbus_convert_properties: "
851 "no ranges property for pcmcia\n");
852 } else {
853 range_entries = range_len / sizeof (pcic_ranges_t);
854 cb_range_p = kmem_alloc(
855 sizeof (cardbus_range_t) * range_entries, KM_SLEEP);
856
857 old_range_p = pcic_range_p;
858 new_range_p = cb_range_p;
859 for (i = 0; i < range_entries;
860 i++, old_range_p++, new_range_p++) {
861 new_range_p->child_hi =
862 old_range_p->pcic_range_caddrhi;
863 new_range_p->child_mid = 0;
864 new_range_p->child_lo =
865 old_range_p->pcic_range_caddrlo;
866 new_range_p->parent_hi =
867 old_range_p->pcic_range_paddrhi;
868 new_range_p->parent_mid =
869 old_range_p->pcic_range_paddrmid;
870 new_range_p->parent_lo =
871 old_range_p->pcic_range_paddrlo;
872 new_range_p->size_hi = 0;
873 new_range_p->size_lo = old_range_p->pcic_range_size;
874 }
875
876 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip, "ranges",
877 (int *)cb_range_p,
878 (sizeof (cardbus_range_t) * range_entries)/sizeof (int));
879
880 kmem_free(pcic_range_p, range_len);
881 kmem_free(cb_range_p, sizeof (cardbus_range_t) * range_entries);
882 }
883
884 return (DDI_SUCCESS);
885 }
886
887 static void
888 cardbus_revert_properties(dev_info_t *dip)
889 {
890 #if defined(CARDBUS_DEBUG)
891 cardbus_err(dip, 6, "cardbus_revert_properties\n");
892 #endif
893
894 (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "#address-cells");
895
896 (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "#size-cells");
897
898 (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "available");
899 }
900
901 static int
902 cardbus_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
903 ddi_prop_op_t prop_op, int mod_flags,
904 char *name, caddr_t valuep, int *lengthp)
905 {
906 #if defined(CARDBUS_DEBUG)
907 if ((ch_dip != dip) || (cardbus_debug >= 9))
908 cardbus_err(dip, 6,
909 "cardbus_prop_op(%s) (dip=0x%p, op=%d, name=%s)\n",
910 ddi_driver_name(ch_dip), (void *) dip, prop_op, name);
911 #endif
912 return (impl_ddi_bus_prop_op(dev, dip, ch_dip, prop_op,
913 mod_flags, name, valuep, lengthp));
914 }
915
916 static int
917 cardbus_ctlops(dev_info_t *dip, dev_info_t *rdip,
918 ddi_ctl_enum_t ctlop, void *arg, void *result)
919 {
920 pci_regspec_t *regs;
921 int totreg, reglen;
922 const char *dname = ddi_driver_name(dip);
923
924 ASSERT(number_of_cardbus_cards != 0);
925
926 cardbus_err(dip, 6,
927 "cardbus_ctlops(%p, %p, %d, %p, %p)\n",
928 (void *)dip, (void *)rdip, ctlop, (void *)arg, (void *)result);
929
930 switch (ctlop) {
931 case DDI_CTLOPS_UNINITCHILD:
932 cardbus_removechild((dev_info_t *)arg);
933 return (DDI_SUCCESS);
934 case DDI_CTLOPS_POWER:
935 return (DDI_SUCCESS);
936
937 default:
938 /*
939 * Do Nothing
940 */
941 cardbus_err(dip, 8,
942 "cardbus_ctlops: Unsupported DDI_CTLOP %d\n", ctlop);
943 return (ddi_ctlops(dip, rdip, ctlop, arg, result));
944
945 case DDI_CTLOPS_SIDDEV: /* see ddi_dev_is_sid(9F) */
946 return (DDI_SUCCESS);
947
948 case DDI_CTLOPS_SLAVEONLY: /* see ddi_slaveonly(9F) */
949 return (DDI_FAILURE); /* cardbus */
950
951 case DDI_CTLOPS_REGSIZE:
952 case DDI_CTLOPS_NREGS:
953 if (rdip == (dev_info_t *)NULL) {
954 *(int *)result = 0;
955 return (DDI_FAILURE);
956 }
957 break;
958
959 case DDI_CTLOPS_IOMIN:
960 /*
961 * If we are using the streaming cache, align at
962 * least on a cache line boundary. Otherwise use
963 * whatever alignment is passed in.
964 */
965
966 if (arg) {
967 int val = *((int *)result);
968
969 #ifdef PCI_SBUF_LINE_SIZE
970 val = maxbit(val, PCI_SBUF_LINE_SIZE);
971 #else
972 val = maxbit(val, 64);
973 #endif
974 *((int *)result) = val;
975 }
976 return (DDI_SUCCESS);
977
978 case DDI_CTLOPS_INITCHILD:
979 return (cardbus_initchild(rdip, dip, (dev_info_t *)arg,
980 result));
981
982 case DDI_CTLOPS_REPORTDEV:
983 if (rdip == (dev_info_t *)0)
984 return (DDI_FAILURE);
985
986 if (strcmp("pcs", ddi_node_name(rdip)) == 0)
987 cardbus_err(dip, 1,
988 "cardbus_ctlops: PCCard socket %d at %s@%s\n",
989 ddi_get_instance(rdip),
990 dname, ddi_get_name_addr(dip));
991 else {
992 pci_regspec_t *pci_rp;
993 dev_info_t *next;
994 int length;
995
996 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, rdip,
997 DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
998 (uint_t *)&length) != DDI_PROP_SUCCESS)
999 return (DDI_FAILURE);
1000
1001 if (pci_rp->pci_phys_hi == 0)
1002 cardbus_err(dip, 1, "%s%d at %s@%s\n",
1003 ddi_driver_name(rdip),
1004 ddi_get_instance(rdip),
1005 dname, ddi_get_name_addr(dip));
1006 else {
1007 uint8_t bus, device, function;
1008 int32_t val32;
1009 char *ptr, buf[128];
1010
1011 bus = PCI_REG_BUS_G(pci_rp->pci_phys_hi);
1012 device = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
1013 function = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);
1014
1015 ptr = buf;
1016 (void) sprintf(ptr, " "
1017 "Bus %3d Device %2d Function %2d",
1018 bus, device, function);
1019 ptr = &ptr[strlen(ptr)];
1020
1021 val32 = ddi_getprop(DDI_DEV_T_ANY, rdip,
1022 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
1023 "vendor-id", -1);
1024 if (val32 != -1) {
1025 (void) sprintf(ptr, " Vendor 0x%04x",
1026 val32);
1027 ptr = &ptr[strlen(ptr)];
1028 }
1029 val32 = ddi_getprop(DDI_DEV_T_ANY, rdip,
1030 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
1031 "device-id", -1);
1032 if (val32 != -1) {
1033 (void) sprintf(ptr, " Device 0x%04x",
1034 val32);
1035 ptr = &ptr[strlen(ptr)];
1036 }
1037 val32 = ddi_getprop(DDI_DEV_T_ANY, rdip,
1038 DDI_PROP_CANSLEEP | DDI_PROP_DONTPASS,
1039 "class-code", -1);
1040 if (val32 != -1) {
1041 const char *name;
1042
1043 if ((name = ddi_get_name(rdip)) !=
1044 NULL)
1045 (void) sprintf(ptr, " Name %s",
1046 name);
1047 else
1048 (void) sprintf(ptr,
1049 " Class 0x%x", val32 >> 8);
1050 ptr = &ptr[strlen(ptr)];
1051 }
1052
1053 *ptr++ = '\n';
1054 ASSERT(((caddr_t)ptr - (caddr_t)buf) <
1055 sizeof (buf));
1056 *ptr = '\0';
1057
1058 cardbus_err(dip, 1, buf);
1059 }
1060 ddi_prop_free(pci_rp);
1061
1062 for (next = ddi_get_child(rdip); next;
1063 next = ddi_get_next_sibling(next))
1064 (void) cardbus_ctlops(next, next,
1065 DDI_CTLOPS_REPORTDEV, arg, result);
1066 }
1067 return (DDI_SUCCESS);
1068 }
1069 *(int *)result = 0;
1070
1071 if (ddi_getlongprop(DDI_DEV_T_NONE, rdip,
1072 DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "reg",
1073 (caddr_t)®s, ®len) != DDI_SUCCESS)
1074 return (DDI_FAILURE);
1075
1076 totreg = reglen / sizeof (pci_regspec_t);
1077 if (ctlop == DDI_CTLOPS_NREGS) {
1078 cardbus_err(dip, 6,
1079 "cardbus_ctlops, returning NREGS = %d\n", totreg);
1080 *(int *)result = totreg;
1081 } else if (ctlop == DDI_CTLOPS_REGSIZE) {
1082 const int rn = *(int *)arg;
1083 if (rn > totreg)
1084 return (DDI_FAILURE);
1085 cardbus_err(dip, 6,
1086 "cardbus_ctlops, returning REGSIZE(%d) = %d\n",
1087 rn, regs[rn].pci_size_low);
1088 *(off_t *)result = regs[rn].pci_size_low;
1089 }
1090 kmem_free(regs, reglen);
1091 return (DDI_SUCCESS);
1092 }
1093
1094 static void
1095 cardbus_init_child_regs(dev_info_t *child)
1096 {
1097 ddi_acc_handle_t config_handle;
1098 uint16_t command_preserve, command;
1099 #if !defined(__i386) && !defined(__amd64)
1100 uint8_t bcr;
1101 #endif
1102 uint8_t header_type;
1103 uint8_t min_gnt, latency_timer;
1104 uint_t n;
1105
1106 /*
1107 * Map the child configuration space to for initialization.
1108 *
1109 * Set the latency-timer register to values appropriate
1110 * for the devices on the bus (based on other devices
1111 * MIN_GNT and MAX_LAT registers.
1112 *
1113 * Set the fast back-to-back enable bit in the command
1114 * register if it's supported and all devices on the bus
1115 * have the capability.
1116 *
1117 */
1118 if (pci_config_setup(child, &config_handle) != DDI_SUCCESS)
1119 return;
1120
1121 cardbus_err(child, 6, "cardbus_init_child_regs()\n");
1122
1123 /*
1124 * Determine the configuration header type.
1125 */
1126 header_type = pci_config_get8(config_handle, PCI_CONF_HEADER);
1127
1128 /*
1129 * Support for "command-preserve" property. Note that we
1130 * add PCI_COMM_BACK2BACK_ENAB to the bits to be preserved
1131 * since the obp will set this if the device supports and
1132 * all targets on the same bus support it. Since psycho
1133 * doesn't support PCI_COMM_BACK2BACK_ENAB, it will never
1134 * be set. This is just here in case future revs do support
1135 * PCI_COMM_BACK2BACK_ENAB.
1136 */
1137 command_preserve = ddi_prop_get_int(DDI_DEV_T_ANY, child,
1138 DDI_PROP_DONTPASS,
1139 "command-preserve", 0);
1140 command = pci_config_get16(config_handle, PCI_CONF_COMM);
1141 command &= (command_preserve | PCI_COMM_BACK2BACK_ENAB);
1142 command |= (cardbus_command_default & ~command_preserve);
1143 pci_config_put16(config_handle, PCI_CONF_COMM, command);
1144 command = pci_config_get16(config_handle, PCI_CONF_COMM);
1145
1146 #if !defined(__i386) && !defined(__amd64)
1147 /*
1148 * If the device has a bus control register then program it
1149 * based on the settings in the command register.
1150 */
1151 if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
1152 bcr = pci_config_get8(config_handle, PCI_BCNF_BCNTRL);
1153 if (cardbus_command_default & PCI_COMM_PARITY_DETECT)
1154 bcr |= PCI_BCNF_BCNTRL_PARITY_ENABLE;
1155 if (cardbus_command_default & PCI_COMM_SERR_ENABLE)
1156 bcr |= PCI_BCNF_BCNTRL_SERR_ENABLE;
1157 bcr |= PCI_BCNF_BCNTRL_MAST_AB_MODE;
1158 pci_config_put8(config_handle, PCI_BCNF_BCNTRL, bcr);
1159 }
1160 #endif
1161
1162 /*
1163 * Initialize cache-line-size configuration register if needed.
1164 */
1165 if (ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
1166 "cache-line-size", 0) == 0) {
1167
1168 pci_config_put8(config_handle, PCI_CONF_CACHE_LINESZ,
1169 PCI_CACHE_LINE_SIZE);
1170 n = pci_config_get8(config_handle, PCI_CONF_CACHE_LINESZ);
1171 if (n != 0)
1172 (void) ndi_prop_update_int(DDI_DEV_T_NONE, child,
1173 "cache-line-size", n);
1174 }
1175
1176 /*
1177 * Initialize latency timer registers if needed.
1178 */
1179 if (ddi_getprop(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
1180 "latency-timer", 0) == 0) {
1181
1182 if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
1183 latency_timer = cardbus_latency_timer;
1184 pci_config_put8(config_handle, PCI_BCNF_LATENCY_TIMER,
1185 latency_timer);
1186 } else {
1187 min_gnt = pci_config_get8(config_handle,
1188 PCI_CONF_MIN_G);
1189
1190 /*
1191 * Cardbus os only 33Mhz
1192 */
1193 if (min_gnt != 0) {
1194 latency_timer = min_gnt * 8;
1195 }
1196 }
1197 pci_config_put8(config_handle, PCI_CONF_LATENCY_TIMER,
1198 latency_timer);
1199 n = pci_config_get8(config_handle, PCI_CONF_LATENCY_TIMER);
1200 if (n != 0)
1201 (void) ndi_prop_update_int(DDI_DEV_T_NONE, child,
1202 "latency-timer", n);
1203 }
1204
1205 pci_config_teardown(&config_handle);
1206 }
1207
1208 static int
1209 cardbus_initchild(dev_info_t *rdip, dev_info_t *dip, dev_info_t *child,
1210 void *result)
1211 {
1212 char name[MAXNAMELEN];
1213 const char *dname = ddi_driver_name(dip);
1214 const struct cb_ops *cop;
1215
1216 _NOTE(ARGUNUSED(rdip, result))
1217
1218 cardbus_err(child, 6, "cardbus_initchild\n");
1219
1220 /*
1221 * Name the child
1222 */
1223 if (cardbus_name_child(child, name, MAXNAMELEN) != DDI_SUCCESS)
1224 return (DDI_FAILURE);
1225
1226 ddi_set_name_addr(child, name);
1227 ddi_set_parent_data(child, NULL);
1228
1229 if (ndi_dev_is_persistent_node(child) == 0) {
1230 /*
1231 * Try to merge the properties from this prototype
1232 * node into real h/w nodes.
1233 */
1234 if (ndi_merge_node(child, cardbus_name_child) == DDI_SUCCESS) {
1235 /*
1236 * Merged ok - return failure to remove the node.
1237 */
1238 cardbus_removechild(child);
1239 return (DDI_FAILURE);
1240 }
1241 /*
1242 * The child was not merged into a h/w node,
1243 * but there's not much we can do with it other
1244 * than return failure to cause the node to be removed.
1245 */
1246 cmn_err(CE_WARN, "!%s@%s: %s.conf properties not merged",
1247 ddi_driver_name(child), ddi_get_name_addr(child),
1248 ddi_driver_name(child));
1249 cardbus_removechild(child);
1250 return (DDI_NOT_WELL_FORMED);
1251 }
1252 cop = DEVI(dip)->devi_ops->devo_cb_ops;
1253
1254 if ((cop == NULL) || (!(cop->cb_flag & D_HOTPLUG))) {
1255 cmn_err(CE_WARN, "%s: driver doesn't support HOTPLUG\n", dname);
1256 return (DDI_FAILURE);
1257 }
1258
1259 cardbus_init_child_regs(child);
1260
1261 /*
1262 * Create ppd if needed.
1263 */
1264 if (ddi_get_parent_data(child) == NULL) {
1265 struct cardbus_parent_private_data *ppd;
1266
1267 #ifdef sparc
1268 ppd = (struct cardbus_parent_private_data *)
1269 kmem_zalloc(sizeof (struct cardbus_parent_private_data),
1270 KM_SLEEP);
1271
1272 #elif defined(__x86) || defined(__amd64)
1273 ppd = (struct cardbus_parent_private_data *)
1274 kmem_zalloc(sizeof (struct cardbus_parent_private_data)
1275 + sizeof (struct intrspec), KM_SLEEP);
1276
1277 ppd->ppd.par_intr = (struct intrspec *)(ppd + 1);
1278 (ppd->ppd.par_intr)->intrspec_pri = 0;
1279 (ppd->ppd.par_intr)->intrspec_vec = 0;
1280 (ppd->ppd.par_intr)->intrspec_func = (uint_t (*)()) 0;
1281 #endif
1282
1283 if (ddi_getprop(DDI_DEV_T_NONE, child, DDI_PROP_DONTPASS,
1284 "interrupts", -1) != -1)
1285 ppd->ppd.par_nintr = 1;
1286
1287 ppd->code = CB_PPD_CODE;
1288
1289 cardbus_err(child, 5,
1290 "cardbus_initchild: Creating empty ppd\n");
1291 ppd->ppd.par_nreg = 0;
1292 ppd->ppd.par_reg = NULL;
1293
1294 ddi_set_parent_data(child, (caddr_t)ppd);
1295 }
1296
1297 return (DDI_SUCCESS);
1298 }
1299
1300 static int
1301 cardbus_name_child(dev_info_t *child, char *name, int namelen)
1302 {
1303 pci_regspec_t *pci_rp;
1304 char **unit_addr;
1305 uint_t n;
1306 int bus, device, func;
1307
1308 /*
1309 * Pseudo nodes indicate a prototype node with per-instance
1310 * properties to be merged into the real h/w device node.
1311 * The interpretation of the unit-address is DD[,F]
1312 * where DD is the device id and F is the function.
1313 */
1314 if (ndi_dev_is_persistent_node(child) == 0) {
1315 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, child,
1316 DDI_PROP_DONTPASS,
1317 "unit-address", &unit_addr, &n) != DDI_PROP_SUCCESS) {
1318 cmn_err(CE_WARN, "cannot name node from %s.conf",
1319 ddi_driver_name(child));
1320 return (DDI_FAILURE);
1321 }
1322 if (n != 1 || *unit_addr == NULL || **unit_addr == 0) {
1323 cmn_err(CE_WARN, "unit-address property in %s.conf"
1324 " not well-formed", ddi_driver_name(child));
1325 ddi_prop_free(unit_addr);
1326 return (DDI_FAILURE);
1327 }
1328 (void) snprintf(name, namelen, "%s", *unit_addr);
1329 ddi_prop_free(unit_addr);
1330 return (DDI_SUCCESS);
1331 }
1332
1333 /*
1334 * Get the address portion of the node name based on
1335 * the function and device number.
1336 */
1337 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child, DDI_PROP_DONTPASS,
1338 "reg", (int **)&pci_rp, &n) != DDI_SUCCESS) {
1339 return (DDI_FAILURE);
1340 }
1341
1342 bus = PCI_REG_BUS_G(pci_rp->pci_phys_hi);
1343 device = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
1344 func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);
1345 ddi_prop_free(pci_rp);
1346
1347 if (func != 0)
1348 (void) snprintf(name, namelen, "%x,%x", device, func);
1349 else
1350 (void) snprintf(name, namelen, "%x", device);
1351
1352 cardbus_err(child, 8,
1353 "cardbus_name_child: system init done [%x][%x][%x]"
1354 " for %s [%s] nodeid: %x @%s\n",
1355 bus, device, func,
1356 ddi_get_name(child), ddi_get_name_addr(child),
1357 DEVI(child)->devi_nodeid, name);
1358
1359 return (DDI_SUCCESS);
1360 }
1361
1362 static void
1363 cardbus_removechild(dev_info_t *dip)
1364 {
1365 struct cardbus_parent_private_data *ppd;
1366
1367 ddi_set_name_addr(dip, NULL);
1368 impl_rem_dev_props(dip);
1369 ppd = (struct cardbus_parent_private_data *)ddi_get_parent_data(dip);
1370 if (ppd && (ppd->code == CB_PPD_CODE)) {
1371 if (ppd->ppd.par_reg && (ppd->ppd.par_nreg > 0))
1372 kmem_free((caddr_t)ppd->ppd.par_reg,
1373 ppd->ppd.par_nreg * sizeof (struct regspec));
1374 #ifdef sparc
1375 kmem_free(ppd, sizeof (struct cardbus_parent_private_data));
1376 #elif defined(__x86) || defined(__amd64)
1377 kmem_free(ppd, sizeof (struct cardbus_parent_private_data) +
1378 sizeof (struct intrspec));
1379 #endif
1380 cardbus_err(dip, 5,
1381 "cardbus_removechild: ddi_set_parent_data(NULL)\n");
1382 ddi_set_parent_data(dip, NULL);
1383 }
1384 }
1385
1386
1387 static char cb_bnamestr[] = "binding_name";
1388 static char cb_venidstr[] = "VendorID";
1389 static char cb_devidstr[] = "DeviceID";
1390 static char cb_nnamestr[] = "nodename";
1391
1392 static cb_props_parse_tree_t cb_props_parse_tree[] = {
1393 { cb_bnamestr, PT_STATE_STRING_VAR },
1394 { cb_venidstr, PT_STATE_HEX_VAR },
1395 { cb_devidstr, PT_STATE_HEX_VAR } };
1396
1397 static int
1398 check_token(char *token, int *len)
1399 {
1400 int state = PT_STATE_DEC_VAR;
1401 int sl = strlen(token), il = 1;
1402 char c;
1403
1404 if (token[0] == '0' && token[2] && (token[1] == 'x' || token[1] ==
1405 'X')) {
1406 state = PT_STATE_HEX_VAR;
1407 token += 2;
1408 }
1409
1410 while (c = *token++) {
1411 if (isdigit(c))
1412 continue;
1413 if (c == PARSE_COMMA) {
1414 il++;
1415 if (token[0] == '0' && token[2] && isx(token[1])) {
1416 state = PT_STATE_HEX_VAR;
1417 token += 2;
1418 }
1419 continue;
1420 }
1421 if (!isxdigit(c)) {
1422 *len = sl;
1423 return (PT_STATE_STRING_VAR);
1424 }
1425 state = PT_STATE_HEX_VAR;
1426 }
1427 *len = il;
1428 return (state);
1429 }
1430
1431
1432 static char *
1433 find_token(char **cp, int *l, char *endc)
1434 {
1435 char *cpp = *cp;
1436
1437 while ((**cp && (isalpha(**cp) || isxdigit(**cp) ||
1438 (**cp == PARSE_UNDERSCORE) ||
1439 (**cp == PARSE_COMMA) ||
1440 (**cp == PARSE_DASH)))) {
1441 (*cp)++;
1442 (*l)++;
1443 }
1444
1445 *endc = **cp;
1446 **cp = NULL;
1447
1448 return (cpp);
1449 }
1450
1451 static int
1452 parse_token(char *token)
1453 {
1454 cb_props_parse_tree_t *pt = cb_props_parse_tree;
1455 int k = sizeof (cb_props_parse_tree) /
1456 sizeof (cb_props_parse_tree_t);
1457
1458 while (k--) {
1459 if (strcmp((char *)token, pt->token) == 0)
1460 return (pt->state);
1461 pt++;
1462 }
1463
1464 return (PT_STATE_UNKNOWN);
1465 }
1466
1467 static int
1468 token_to_hex(char *token, unsigned *val, int len)
1469 {
1470 uchar_t c;
1471
1472 *val = 0;
1473 if (token[0] == '0' && (token[1] == 'x' || token[1] == 'X')) {
1474 token += 2;
1475 }
1476
1477 while (*token) {
1478 if (!isxdigit(*token)) {
1479 if (*token == PARSE_COMMA) {
1480 if (!(--len))
1481 return (1);
1482 val++;
1483 *val = 0;
1484 token++;
1485 if (token[0] == '0' && (token[1] == 'x' ||
1486 token[1] == 'X')) {
1487 token += 2;
1488 }
1489 continue;
1490 }
1491 return (0);
1492 }
1493 c = toupper(*token);
1494 if (c >= 'A')
1495 c = c - 'A' + 10 + '0';
1496 *val = ((*val * 16) + (c - '0'));
1497 token++;
1498 }
1499
1500 return (1);
1501 }
1502
1503 static int
1504 token_to_dec(char *token, unsigned *val, int len)
1505 {
1506 *val = 0;
1507
1508 while (*token) {
1509 if (!isdigit(*token)) {
1510 if (*token == PARSE_COMMA) {
1511 if (!(--len))
1512 return (1);
1513 val++;
1514 *val = 0;
1515 token++;
1516 continue;
1517 }
1518 return (0);
1519 }
1520 *val = ((*val * 10) + (*token - '0'));
1521 token++;
1522 }
1523
1524 return (1);
1525 }
1526
1527 static void
1528 cardbus_add_prop(struct cb_deviceset_props *cdsp, int type, char *name,
1529 caddr_t vp, int len)
1530 {
1531 ddi_prop_t *propp;
1532 int pnlen = strlen(name) + 1;
1533
1534 propp = (ddi_prop_t *)kmem_zalloc(sizeof (ddi_prop_t), KM_SLEEP);
1535 propp->prop_name = (char *)kmem_alloc(pnlen, KM_SLEEP);
1536 propp->prop_val = vp;
1537 bcopy(name, propp->prop_name, pnlen);
1538 propp->prop_len = len;
1539 propp->prop_flags = type;
1540 propp->prop_next = cdsp->prop_list;
1541 cdsp->prop_list = propp;
1542 }
1543
1544 static void
1545 cardbus_add_stringprop(struct cb_deviceset_props *cdsp, char *name,
1546 char *vp, int len)
1547 {
1548 char *nstr = kmem_zalloc(len + 1, KM_SLEEP);
1549
1550 bcopy(vp, nstr, len);
1551 cardbus_add_prop(cdsp, DDI_PROP_TYPE_STRING, name, (caddr_t)nstr,
1552 len + 1);
1553 }
1554
1555 static void
1556 cardbus_prop_free(ddi_prop_t *propp)
1557 {
1558 if (propp->prop_len) {
1559 switch (propp->prop_flags) {
1560 case DDI_PROP_TYPE_STRING:
1561 kmem_free(propp->prop_val, propp->prop_len);
1562 break;
1563 case DDI_PROP_TYPE_INT:
1564 kmem_free(propp->prop_val,
1565 propp->prop_len * sizeof (int));
1566 break;
1567 }
1568 }
1569 kmem_free(propp->prop_name, strlen(propp->prop_name) + 1);
1570 kmem_free(propp, sizeof (ddi_prop_t *));
1571 }
1572
1573 static void
1574 cardbus_devprops_free(struct cb_deviceset_props *cbdp)
1575 {
1576 ddi_prop_t *propp, *npropp;
1577
1578 propp = cbdp->prop_list;
1579 while (propp) {
1580 npropp = propp->prop_next;
1581 cardbus_prop_free(propp);
1582 propp = npropp;
1583 }
1584 if (cbdp->nodename)
1585 kmem_free(cbdp->nodename, strlen(cbdp->nodename) + 1);
1586 if (cbdp->binding_name)
1587 kmem_free(cbdp->binding_name, strlen(cbdp->binding_name) +
1588 1);
1589 kmem_free(cbdp, sizeof (*cbdp));
1590 }
1591
1592 /*
1593 * Format of "cb-device-init-props" property:
1594 * Anything before the semi-colon is an identifying equate, anything
1595 * after the semi-colon is a setting equate.
1596 *
1597 * "binding_name=xXxXxX VendorID=NNNN DeviceID=NNNN; nodename=NewName
1598 * Prop=PropVal"
1599 *
1600 */
1601 static int
1602 cardbus_parse_devprop(cbus_t *cbp, char *cp)
1603 {
1604 int state = PT_STATE_TOKEN, qm = 0, em = 0, smc = 0, l = 0;
1605 int length;
1606 char *token = "beginning of line";
1607 char *ptoken = NULL, *quote;
1608 char eq = NULL;
1609 struct cb_deviceset_props *cdsp;
1610
1611 cdsp = (struct cb_deviceset_props *)kmem_zalloc(sizeof (*cdsp),
1612 KM_SLEEP);
1613 length = strlen(cp);
1614
1615 while ((*cp) && (l < length)) {
1616 /*
1617 * Check for escaped characters
1618 */
1619 if (*cp == PARSE_ESCAPE) {
1620 char *cpp = cp, *cppp = cp + 1;
1621
1622 em = 1;
1623
1624 if (!qm) {
1625 cmn_err(CE_CONT, "cardbus_parse_devprop: "
1626 "escape not allowed outside "
1627 "of quotes at [%s]\n", token);
1628 return (DDI_FAILURE);
1629
1630 } /* if (!qm) */
1631
1632 while (*cppp)
1633 *cpp++ = *cppp++;
1634
1635 l++;
1636
1637 *cpp = NULL;
1638 } /* PARSE_ESCAPE */
1639
1640 /*
1641 * Check for quoted strings
1642 */
1643 if (!em && (*cp == PARSE_QUOTE)) {
1644 qm ^= 1;
1645 if (qm) {
1646 quote = cp + 1;
1647 } else {
1648 *cp = NULL;
1649 if (state == PT_STATE_CHECK) {
1650 if (strcmp(token, cb_nnamestr) == 0) {
1651 cdsp->nodename = kmem_alloc(
1652 strlen(quote) + 1,
1653 KM_SLEEP);
1654 (void) strcpy(cdsp->nodename,
1655 quote);
1656 } else
1657 cardbus_add_stringprop(cdsp,
1658 token, quote,
1659 strlen(quote));
1660 } else if (state != PT_STATE_STRING_VAR) {
1661 cmn_err(CE_CONT,
1662 "cardbus_parse_devprop: "
1663 "unexpected string [%s] after "
1664 "[%s]\n", quote, token);
1665 return (DDI_FAILURE);
1666 } else {
1667 if (strcmp(token, cb_bnamestr) == 0) {
1668 cdsp->binding_name = kmem_alloc(
1669 strlen(quote) + 1,
1670 KM_SLEEP);
1671 (void) strcpy(
1672 cdsp->binding_name, quote);
1673 }
1674 }
1675 state = PT_STATE_TOKEN;
1676 } /* if (qm) */
1677 } /* PARSE_QUOTE */
1678
1679 em = 0;
1680
1681 if (!qm && (*cp == PARSE_SEMICOLON)) {
1682 smc = 1;
1683 }
1684
1685 /*
1686 * Check for tokens
1687 */
1688 else if (!qm && (isalpha(*cp) || isxdigit(*cp))) {
1689 int tl;
1690 unsigned *intp;
1691 ptoken = token;
1692 token = find_token(&cp, &l, &eq);
1693
1694 switch (state) {
1695 case PT_STATE_TOKEN:
1696 if (smc) {
1697 if (eq == PARSE_EQUALS)
1698 state = PT_STATE_CHECK;
1699 else
1700 cardbus_add_prop(cdsp,
1701 DDI_PROP_TYPE_ANY,
1702 token,
1703 NULL, 0);
1704 } else if (eq == PARSE_EQUALS)
1705 switch (state = parse_token(token)) {
1706 case PT_STATE_UNKNOWN:
1707 cmn_err(CE_CONT,
1708 "cardbus_parse_devprop: "
1709 "unknown token [%s]\n",
1710 token);
1711 state = PT_STATE_TOKEN;
1712 } /* switch (parse_token) */
1713 else
1714 state = PT_STATE_TOKEN;
1715 break;
1716
1717 case PT_STATE_CHECK:
1718 switch (check_token(token, &tl)) {
1719 case PT_STATE_DEC_VAR:
1720 intp = (unsigned *)kmem_alloc(
1721 sizeof (int)*tl,
1722 KM_SLEEP);
1723 if (token_to_dec(token, intp, tl))
1724 cardbus_add_prop(cdsp,
1725 DDI_PROP_TYPE_INT, ptoken,
1726 (caddr_t)intp, tl);
1727 else
1728 kmem_free(intp,
1729 sizeof (int)*tl);
1730 break;
1731 case PT_STATE_HEX_VAR:
1732 intp = (unsigned *)kmem_alloc(
1733 sizeof (int)*tl,
1734 KM_SLEEP);
1735 if (token_to_hex(token, intp, tl))
1736 cardbus_add_prop(cdsp,
1737 DDI_PROP_TYPE_INT,
1738 ptoken,
1739 (caddr_t)intp, tl);
1740 else
1741 kmem_free(intp,
1742 sizeof (int)*tl);
1743 break;
1744 case PT_STATE_STRING_VAR:
1745 if (strcmp(ptoken, cb_nnamestr) == 0) {
1746 cdsp->nodename = kmem_alloc(
1747 tl + 1, KM_SLEEP);
1748 (void) strcpy(cdsp->nodename,
1749 token);
1750 } else
1751 cardbus_add_stringprop(cdsp,
1752 ptoken, token, tl);
1753 break;
1754 }
1755 state = PT_STATE_TOKEN;
1756 break;
1757
1758 case PT_STATE_HEX_VAR:
1759 if (strcmp(ptoken, cb_venidstr) == 0) {
1760 uint_t val;
1761 if (token_to_hex(token, &val, 1))
1762 cdsp->venid = val;
1763 } else if (strcmp(ptoken, cb_devidstr) == 0) {
1764 uint_t val;
1765 if (token_to_hex(token, &val, 1))
1766 cdsp->devid = val;
1767 }
1768 state = PT_STATE_TOKEN;
1769 break;
1770
1771 case PT_STATE_DEC_VAR:
1772 if (strcmp(ptoken, cb_venidstr) == 0) {
1773 uint_t val;
1774 if (token_to_dec(token, &val, 1))
1775 cdsp->venid = val;
1776 } else if (strcmp(ptoken, cb_devidstr) == 0) {
1777 uint_t val;
1778 if (token_to_dec(token, &val, 1))
1779 cdsp->devid = val;
1780 }
1781 state = PT_STATE_TOKEN;
1782 break;
1783
1784 case PT_STATE_STRING_VAR:
1785 if (strcmp(ptoken, cb_bnamestr) == 0) {
1786 cdsp->binding_name = kmem_alloc(
1787 strlen(token) + 1, KM_SLEEP);
1788 (void) strcpy(cdsp->binding_name,
1789 token);
1790 }
1791 state = PT_STATE_TOKEN;
1792 break;
1793
1794 default:
1795 cmn_err(CE_CONT, "cardbus_parse_devprop: "
1796 "unknown state machine state = %d\n",
1797 state);
1798
1799 cardbus_devprops_free(cdsp);
1800 return (DDI_FAILURE);
1801 } /* switch (state) */
1802 if (eq == PARSE_SEMICOLON)
1803 smc = 1;
1804 }
1805 cp++;
1806 l++;
1807 } /* while (*cp) */
1808
1809 if (qm) {
1810 cmn_err(CE_CONT, "cb_props_parse_line: unterminated "
1811 "string = [%s]\n", quote);
1812 cardbus_devprops_free(cdsp);
1813 return (DDI_FAILURE);
1814 }
1815
1816 if (state != PT_STATE_TOKEN) {
1817 cmn_err(CE_CONT, "cardbus_parse_devprop: token [%s] "
1818 "requires value\n", token);
1819 cardbus_devprops_free(cdsp);
1820 return (DDI_FAILURE);
1821 }
1822
1823 if (cdsp->venid == 0 || cdsp->devid == 0) {
1824 cmn_err(CE_CONT, "cardbus_parse_devprop: Entry "
1825 "requires VendorID and DeviceID\n");
1826 cardbus_devprops_free(cdsp);
1827 return (DDI_FAILURE);
1828 }
1829
1830 cdsp->next = cbp->cb_dsp;
1831 cbp->cb_dsp = cdsp;
1832 return (DDI_SUCCESS);
1833 }
1834
1835 static void
1836 cardbus_device_props(cbus_t *cbp)
1837 {
1838 char **prop_array;
1839 uint_t i, n;
1840
1841 if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, cbp->cb_dip,
1842 DDI_PROP_DONTPASS,
1843 "cb-device-init-props", &prop_array,
1844 &n) != DDI_PROP_SUCCESS)
1845 return;
1846
1847 for (i = 0; i < n; i++)
1848 (void) cardbus_parse_devprop(cbp, prop_array[i]);
1849
1850 ddi_prop_free(prop_array);
1851 }
1852
1853 static int
1854 cardbus_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
1855 off_t offset, off_t len, caddr_t *vaddrp)
1856 {
1857 register dev_info_t *pdip = (dev_info_t *)DEVI(dip)->devi_parent;
1858 int rc;
1859
1860 cardbus_err(dip, 9,
1861 "cardbus_bus_map(dip=0x%p, rdip=0x%p)\n",
1862 (void *) dip, (void *) rdip);
1863
1864 if (pdip == NULL)
1865 return (DDI_FAILURE);
1866
1867 /* A child has asked us to set something up */
1868 cardbus_err(dip, 9,
1869 "cardbus_bus_map(%s) calling %s - 0x%p, "
1870 "offset 0x%x, len 0x%x\n",
1871 ddi_driver_name(rdip),
1872 ddi_driver_name(pdip),
1873 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_map,
1874 (int)offset, (int)len);
1875
1876 rc = (DEVI(pdip)->devi_ops->devo_bus_ops->bus_map)
1877 (pdip, rdip, mp, offset, len, vaddrp);
1878 /* rc = ddi_map(dip, mp, offset, len, vaddrp); */
1879
1880 if (rc != DDI_SUCCESS) {
1881 cardbus_err(rdip, 8, "cardbus_bus_map failed, rc = %d\n", rc);
1882 return (DDI_FAILURE);
1883 } else {
1884 cardbus_err(rdip, 9, "cardbus_bus_map OK\n");
1885 return (DDI_SUCCESS);
1886 }
1887 }
1888
1889 static void
1890 pcirp2rp(const pci_regspec_t *pci_rp, struct regspec *rp)
1891 {
1892 /* bus = PCI_REG_BUS_G(pci_rp->pci_phys_hi); */
1893 if (PCI_REG_ADDR_G(pci_rp->pci_phys_hi) ==
1894 PCI_REG_ADDR_G(PCI_ADDR_IO)) {
1895 /* I/O */
1896 rp->regspec_bustype = 1;
1897 } else {
1898 /* memory */
1899 rp->regspec_bustype = 0;
1900 }
1901 rp->regspec_addr = pci_rp->pci_phys_low;
1902 rp->regspec_size = pci_rp->pci_size_low;
1903 }
1904
1905 static int
1906 cardbus_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
1907 int (*waitfp)(caddr_t), caddr_t arg,
1908 ddi_dma_handle_t *handlep)
1909 {
1910 dev_info_t *pdip = ddi_get_parent(dip);
1911
1912 cardbus_err(dip, 10,
1913 "cardbus_dma_allochdl(dip=0x%p, rdip=0x%p)\n",
1914 (void *) dip, (void *) rdip);
1915
1916 if (pdip == NULL)
1917 return (DDI_FAILURE);
1918
1919 cardbus_err(dip, 11,
1920 "cardbus_dma_allochdl calling %s - 0x%p\n",
1921 ddi_driver_name(pdip),
1922 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_allochdl);
1923
1924 return (ddi_dma_allochdl(dip, rdip, attr, waitfp, arg, handlep));
1925 }
1926
1927 static int
1928 cardbus_dma_freehdl(dev_info_t *dip, dev_info_t *rdip,
1929 ddi_dma_handle_t handle)
1930 {
1931 dev_info_t *pdip = ddi_get_parent(dip);
1932
1933 cardbus_err(dip, 10,
1934 "cardbus_dma_freehdl(dip=0x%p, rdip=0x%p)\n",
1935 (void *) dip, (void *) rdip);
1936
1937 if (pdip == NULL)
1938 return (DDI_FAILURE);
1939
1940 cardbus_err(dip, 11,
1941 "cardbus_dma_freehdl calling %s - 0x%p\n",
1942 ddi_driver_name(pdip),
1943 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_freehdl);
1944
1945 return (ddi_dma_freehdl(dip, rdip, handle));
1946 }
1947
1948 static int
1949 cardbus_dma_bindhdl(dev_info_t *dip, dev_info_t *rdip,
1950 ddi_dma_handle_t handle, struct ddi_dma_req *dmareq,
1951 ddi_dma_cookie_t *cp, uint_t *ccountp)
1952 {
1953 dev_info_t *pdip = ddi_get_parent(dip);
1954
1955 cardbus_err(dip, 10,
1956 "cardbus_dma_bindhdl(dip=0x%p, rdip=0x%p)\n",
1957 (void *) dip, (void *) rdip);
1958
1959 if (pdip == NULL)
1960 return (DDI_FAILURE);
1961
1962 cardbus_err(dip, 11,
1963 "cardbus_dma_bindhdl calling %s - 0x%p\n",
1964 ddi_driver_name(pdip),
1965 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_bindhdl);
1966
1967 return (DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_bindhdl(pdip,
1968 rdip, handle, dmareq, cp, ccountp));
1969 }
1970
1971 static int
1972 cardbus_dma_unbindhdl(dev_info_t *dip, dev_info_t *rdip,
1973 ddi_dma_handle_t handle)
1974 {
1975 dev_info_t *pdip = ddi_get_parent(dip);
1976
1977 cardbus_err(dip, 10,
1978 "cardbus_dma_unbindhdl(dip=0x%p, rdip=0x%p)\n",
1979 (void *) dip, (void *) rdip);
1980
1981 if (pdip == NULL)
1982 return (DDI_FAILURE);
1983
1984 cardbus_err(dip, 11,
1985 "cardbus_dma_unbindhdl calling %s - 0x%p\n",
1986 ddi_driver_name(pdip),
1987 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_unbindhdl);
1988
1989 return (DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_unbindhdl(pdip,
1990 rdip, handle));
1991 }
1992
1993 static int
1994 cardbus_dma_flush(dev_info_t *dip, dev_info_t *rdip,
1995 ddi_dma_handle_t handle, off_t off, size_t len,
1996 uint_t cache_flags)
1997 {
1998 dev_info_t *pdip = ddi_get_parent(dip);
1999
2000 cardbus_err(dip, 10,
2001 "cardbus_dma_flush(dip=0x%p, rdip=0x%p)\n",
2002 (void *) dip, (void *) rdip);
2003
2004 if (pdip == NULL)
2005 return (DDI_FAILURE);
2006
2007 cardbus_err(dip, 11,
2008 "cardbus_dma_flush calling %s - 0x%p\n",
2009 ddi_driver_name(pdip),
2010 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_flush);
2011
2012 return (DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_flush(pdip, rdip,
2013 handle, off, len, cache_flags));
2014 }
2015
2016 static int
2017 cardbus_dma_win(dev_info_t *dip, dev_info_t *rdip,
2018 ddi_dma_handle_t handle, uint_t win, off_t *offp,
2019 size_t *lenp, ddi_dma_cookie_t *cookiep, uint_t *ccountp)
2020 {
2021 dev_info_t *pdip = ddi_get_parent(dip);
2022 cardbus_err(dip, 6,
2023 "cardbus_dma_win(dip=0x%p, rdip=0x%p)\n",
2024 (void *) dip, (void *) rdip);
2025
2026 if (pdip == NULL)
2027 return (DDI_FAILURE);
2028
2029 cardbus_err(dip, 8,
2030 "cardbus_dma_win calling %s - 0x%p\n",
2031 ddi_driver_name(pdip),
2032 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_win);
2033
2034 return (DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_win(pdip, rdip,
2035 handle, win, offp, lenp, cookiep, ccountp));
2036 }
2037
2038 static int
2039 cardbus_dma_map(dev_info_t *dip, dev_info_t *rdip,
2040 struct ddi_dma_req *dmareqp, ddi_dma_handle_t *handlep)
2041 {
2042 dev_info_t *pdip = ddi_get_parent(dip);
2043
2044 cardbus_err(dip, 10,
2045 "cardbus_dma_map(dip=0x%p, rdip=0x%p)\n",
2046 (void *) dip, (void *) rdip);
2047
2048 if (pdip == NULL)
2049 return (DDI_FAILURE);
2050
2051 cardbus_err(dip, 11,
2052 "cardbus_dma_map calling %s - 0x%p\n",
2053 ddi_driver_name(pdip),
2054 (void *) DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_map);
2055
2056 return (DEVI(pdip)->devi_ops->devo_bus_ops->bus_dma_map(pdip, rdip,
2057 dmareqp, handlep));
2058 }
2059
2060 static int
2061 cardbus_get_eventcookie(dev_info_t *dip, dev_info_t *rdip,
2062 char *eventname, ddi_eventcookie_t *cookiep)
2063 {
2064 cbus_t *cbp;
2065 int cb_instance;
2066 int rc;
2067
2068 /*
2069 * get the soft state structure for the bus instance.
2070 */
2071 cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2072 DDI_PROP_DONTPASS, "cbus-instance", -1);
2073 ASSERT(cb_instance >= 0);
2074 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
2075
2076 cardbus_err(dip, 6, "cardbus_get_eventcookie %s\n", eventname);
2077
2078 ASSERT(number_of_cardbus_cards != 0);
2079
2080 if (cbp->cb_ndi_event_hdl == NULL) {
2081 /*
2082 * We can't handle up (probably called at the attachment
2083 * point) so pass it on up
2084 */
2085 dev_info_t *pdip = ddi_get_parent(dip);
2086 cardbus_err(dip, 8,
2087 "cardbus_get_eventcookie calling %s - 0x%p\n",
2088 ddi_driver_name(pdip),
2089 (void *)
2090 DEVI(pdip)->devi_ops->devo_bus_ops->bus_get_eventcookie);
2091 return (DEVI(pdip)->devi_ops->devo_bus_ops->
2092 bus_get_eventcookie(pdip, rdip, eventname, cookiep));
2093 }
2094
2095 cardbus_err(dip, 8,
2096 "cardbus_get_eventcookie calling ndi_event_retrieve_cookie\n");
2097
2098 rc = ndi_event_retrieve_cookie(cbp->cb_ndi_event_hdl, rdip, eventname,
2099 cookiep, NDI_EVENT_NOPASS);
2100
2101 cardbus_err(dip, 7,
2102 "cardbus_get_eventcookie rc %d cookie %p\n", rc, (void *)*cookiep);
2103 return (rc);
2104 }
2105
2106 static int
2107 cardbus_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
2108 ddi_eventcookie_t cookie, void (*callback)(dev_info_t *dip,
2109 ddi_eventcookie_t cookie, void *arg, void *bus_impldata),
2110 void *arg, ddi_callback_id_t *cb_id)
2111 {
2112 cbus_t *cbp;
2113 int cb_instance;
2114 int rc;
2115
2116 /*
2117 * get the soft state structure for the bus instance.
2118 */
2119 cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2120 DDI_PROP_DONTPASS, "cbus-instance", -1);
2121 ASSERT(cb_instance >= 0);
2122 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
2123
2124 cardbus_err(dip, 6, "cardbus_add_eventcall\n");
2125
2126 ASSERT(number_of_cardbus_cards != 0);
2127
2128 if (cbp->cb_ndi_event_hdl == NULL) {
2129 /*
2130 * We can't handle up (probably called at the attachment
2131 * point) so pass it on up
2132 */
2133 dev_info_t *pdip = ddi_get_parent(dip);
2134 cardbus_err(dip, 8,
2135 "cardbus_add_eventcall calling %s - 0x%p\n",
2136 ddi_driver_name(pdip),
2137 (void *)
2138 DEVI(pdip)->devi_ops->devo_bus_ops->bus_add_eventcall);
2139 return (DEVI(pdip)->devi_ops->devo_bus_ops->
2140 bus_add_eventcall(pdip, rdip, cookie, callback,
2141 arg, cb_id));
2142 }
2143
2144 cardbus_err(dip, 8,
2145 "cardbus_add_eventcall calling ndi_event_add_callback\n");
2146
2147 rc = ndi_event_add_callback(cbp->cb_ndi_event_hdl, rdip, cookie,
2148 callback, arg, NDI_EVENT_NOPASS, cb_id);
2149 cardbus_err(dip, 7,
2150 "cardbus_add_eventcall rc %d cookie %p\n", rc, (void *)cookie);
2151 return (rc);
2152 }
2153
2154 static int
2155 cardbus_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
2156 {
2157 cbus_t *cbp;
2158 int cb_instance;
2159
2160 /*
2161 * get the soft state structure for the bus instance.
2162 */
2163 cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2164 DDI_PROP_DONTPASS, "cbus-instance", -1);
2165 ASSERT(cb_instance >= 0);
2166 cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
2167
2168 cardbus_err(dip, 6, "cardbus_remove_eventcall\n");
2169
2170 ASSERT(number_of_cardbus_cards != 0);
2171
2172 if (cbp->cb_ndi_event_hdl == NULL) {
2173 /*
2174 * We can't handle up (probably called at the attachment
2175 * point) so pass it on up
2176 */
2177 dev_info_t *pdip = ddi_get_parent(dip);
2178 cardbus_err(dip, 8,
2179 "cardbus_remove_eventcall calling %s - 0x%p\n",
2180 ddi_driver_name(pdip),
2181 (void *)
2182 DEVI(pdip)->devi_ops->devo_bus_ops->bus_remove_eventcall);
2183 return (DEVI(pdip)->devi_ops->devo_bus_ops->
2184 bus_remove_eventcall(pdip, cb_id));
2185 }
2186
2187 return (ndi_event_remove_callback(cbp->cb_ndi_event_hdl, cb_id));
2188 }
2189
2190 static int
2191 cardbus_post_event(dev_info_t *dip, dev_info_t *rdip,
2192 ddi_eventcookie_t cookie, void *bus_impldata)
2193 {
2194 _NOTE(ARGUNUSED(rdip, cookie, bus_impldata))
2195 cardbus_err(dip, 1, "cardbus_post_event()\n");
2196 return (DDI_FAILURE);
2197 }
2198
2199 static int cardbus_remove_intr_impl(dev_info_t *dip, dev_info_t *rdip,
2200 ddi_intr_handle_impl_t *hdlp);
2201 static int cardbus_add_intr_impl(dev_info_t *dip, dev_info_t *rdip,
2202 ddi_intr_handle_impl_t *hdlp);
2203 static int cardbus_enable_intr_impl(dev_info_t *dip, dev_info_t *rdip,
2204 ddi_intr_handle_impl_t *hdlp);
2205 static int cardbus_disable_intr_impl(dev_info_t *dip, dev_info_t *rdip,
2206 ddi_intr_handle_impl_t *hdlp);
2207
2208 static int
2209 cardbus_get_pil(dev_info_t *dip)
2210 {
2211 return ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
2212 "interrupt-priorities", 6);
2213 }
2214
2215 static int
2216 cardbus_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
2217 ddi_intr_handle_impl_t *hdlp, void *result)
2218 {
2219 int ret = DDI_SUCCESS;
2220
2221 #if defined(CARDBUS_DEBUG)
2222 cardbus_err(dip, 8, "cardbus_intr_ops() intr_op=%d\n", (int)intr_op);
2223 #endif
2224
2225 switch (intr_op) {
2226 case DDI_INTROP_GETCAP:
2227 *(int *)result = DDI_INTR_FLAG_LEVEL;
2228 break;
2229 case DDI_INTROP_ALLOC:
2230 *(int *)result = hdlp->ih_scratch1;
2231 break;
2232 case DDI_INTROP_FREE:
2233 break;
2234 case DDI_INTROP_GETPRI:
2235 *(int *)result = hdlp->ih_pri ?
2236 hdlp->ih_pri : cardbus_get_pil(dip);
2237 break;
2238 case DDI_INTROP_SETPRI:
2239 break;
2240 case DDI_INTROP_ADDISR:
2241 case DDI_INTROP_REMISR:
2242 if (hdlp->ih_type != DDI_INTR_TYPE_FIXED) {
2243 cardbus_err(dip, 1, "Only fixed interrupts\n");
2244 return (DDI_FAILURE);
2245 }
2246 break;
2247 case DDI_INTROP_ENABLE:
2248 ret = cardbus_enable_intr_impl(dip, rdip, hdlp);
2249 break;
2250 case DDI_INTROP_DISABLE:
2251 ret = cardbus_disable_intr_impl(dip, rdip, hdlp);
2252 break;
2253 case DDI_INTROP_NINTRS:
2254 case DDI_INTROP_NAVAIL:
2255 #ifdef sparc
2256 *(int *)result = i_ddi_get_intx_nintrs(rdip);
2257 #else
2258 *(int *)result = 1;
2259 #endif
2260 break;
2261 case DDI_INTROP_SUPPORTED_TYPES:
2262 *(int *)result = DDI_INTR_TYPE_FIXED;
2263 break;
2264 default:
2265 ret = DDI_ENOTSUP;
2266 break;
2267 }
2268
2269 return (ret);
2270 }
2271
2272 static int
2273 cardbus_enable_intr_impl(dev_info_t *dip, dev_info_t *rdip,
2274 ddi_intr_handle_impl_t *hdlp)
2275 {
2276 anp_t *anp = (anp_t *)ddi_get_driver_private(dip);
2277 set_irq_handler_t sih;
2278 uint_t socket = 0; /* We only support devices */
2279 /* with one socket per function */
2280
2281 ASSERT(anp != NULL);
2282
2283 cardbus_err(dip, 9,
2284 "cardbus_enable_intr_impl, intr=0x%p, arg1=0x%p, arg2=0x%p"
2285 "rdip=0x%p(%s)\n",
2286 (void *) hdlp->ih_cb_func,
2287 hdlp->ih_cb_arg1, hdlp->ih_cb_arg2,
2288 (void *) rdip, ddi_driver_name(rdip));
2289
2290 if (hdlp->ih_type != DDI_INTR_TYPE_FIXED) {
2291 cardbus_err(dip, 1, "Only fixed interrupts\n");
2292 return (DDI_FAILURE);
2293 }
2294
2295 sih.socket = socket;
2296 sih.handler_id = (unsigned)(long)rdip;
2297 sih.handler = (f_tt *)hdlp->ih_cb_func;
2298 sih.arg1 = hdlp->ih_cb_arg1;
2299 sih.arg2 = hdlp->ih_cb_arg2;
2300 sih.irq = cardbus_get_pil(dip);
2301
2302 if ((*anp->an_if->pcif_set_interrupt)(dip, &sih) != SUCCESS)
2303 return (DDI_FAILURE);
2304
2305 return (DDI_SUCCESS);
2306 }
2307
2308 static int
2309 cardbus_disable_intr_impl(dev_info_t *dip, dev_info_t *rdip,
2310 ddi_intr_handle_impl_t *hdlp)
2311 {
2312 anp_t *anp = (anp_t *)ddi_get_driver_private(dip);
2313 clear_irq_handler_t cih;
2314 uint_t socket = 0; /* We only support devices with 1 socket per */
2315 /* function. */
2316
2317 ASSERT(anp != NULL);
2318
2319 cardbus_err(dip, 9,
2320 "cardbus_disable_intr_impl, intr=0x%p, arg1=0x%p, arg2=0x%p"
2321 "rdip=0x%p(%s%d)\n",
2322 (void *) hdlp->ih_cb_func,
2323 hdlp->ih_cb_arg1, hdlp->ih_cb_arg2,
2324 (void *) rdip, ddi_driver_name(rdip), ddi_get_instance(rdip));
2325
2326 if (hdlp->ih_type != DDI_INTR_TYPE_FIXED) {
2327 cardbus_err(dip, 1, "Only fixed interrupts\n");
2328 return (DDI_FAILURE);
2329 }
2330
2331 cih.socket = socket;
2332 cih.handler_id = (unsigned)(long)rdip;
2333 cih.handler = (f_tt *)hdlp->ih_cb_func;
2334
2335 if ((*anp->an_if->pcif_clr_interrupt)(dip, &cih) != SUCCESS)
2336 return (DDI_FAILURE);
2337
2338 return (DDI_SUCCESS);
2339 }
2340
2341 #if defined(CARDBUS_DEBUG)
2342 static int cardbus_do_pprintf = 0;
2343 #endif
2344
2345 /*PRINTFLIKE3*/
2346 void
2347 cardbus_err(dev_info_t *dip, int level, const char *fmt, ...)
2348 {
2349 if (cardbus_debug && (level <= cardbus_debug)) {
2350 va_list adx;
2351 int instance;
2352 char buf[256];
2353 const char *name;
2354 char *nl = "";
2355 #if !defined(CARDBUS_DEBUG)
2356 int ce;
2357 char qmark = 0;
2358
2359 if (level <= 3)
2360 ce = CE_WARN;
2361 else
2362 ce = CE_CONT;
2363 if (level == 4)
2364 qmark = 1;
2365 #endif
2366
2367 if (dip) {
2368 instance = ddi_get_instance(dip);
2369 /* name = ddi_binding_name(dip); */
2370 name = ddi_driver_name(dip);
2371 } else {
2372 instance = 0;
2373 name = "";
2374 }
2375
2376 va_start(adx, fmt);
2377 /* vcmn_err(ce, fmt, adx); */
2378 /* vprintf(fmt, adx); */
2379 /* prom_vprintf(fmt, adx); */
2380 (void) vsprintf(buf, fmt, adx);
2381 va_end(adx);
2382
2383 if (buf[strlen(buf) - 1] != '\n')
2384 nl = "\n";
2385
2386 #if defined(CARDBUS_DEBUG)
2387 if (cardbus_do_pprintf) {
2388 if (dip) {
2389 if (instance >= 0)
2390 prom_printf("%s(%d),0x%p: %s%s",
2391 name, instance, (void *)dip,
2392 buf, nl);
2393 else
2394 prom_printf("%s,0x%p: %s%s", name,
2395 (void *)dip, buf, nl);
2396 } else
2397 prom_printf("%s%s", buf, nl);
2398 } else {
2399 if (dip) {
2400 if (instance >= 0)
2401 cmn_err(CE_CONT, "%s(%d),0x%p: %s%s",
2402 name, instance, (void *)dip,
2403 buf, nl);
2404 else
2405 cmn_err(CE_CONT, "%s,0x%p: %s%s",
2406 name, (void *)dip, buf, nl);
2407 } else
2408 cmn_err(CE_CONT, "%s%s", buf, nl);
2409 }
2410 #else
2411 if (dip)
2412 cmn_err(ce, qmark ? "?%s%d: %s%s" : "%s%d: %s%s",
2413 name, instance, buf, nl);
2414 else
2415 cmn_err(ce, qmark ? "?%s%s" : "%s%s", buf, nl);
2416 #endif
2417 }
2418 }
2419
2420 static void cardbus_expand_busrange(dev_info_t *dip)
2421 {
2422 dev_info_t *pdip;
2423 cardbus_bus_range_t *bus_range;
2424 int len;
2425
2426 pdip = ddi_get_parent(dip);
2427
2428 if (ddi_getlongprop(DDI_DEV_T_ANY, pdip, DDI_PROP_DONTPASS, "bus-range",
2429 (caddr_t)&bus_range, &len) == DDI_PROP_SUCCESS) {
2430 ndi_ra_request_t req;
2431 uint64_t next_bus, blen;
2432 uint32_t ret;
2433 ddi_acc_handle_t handle;
2434
2435 if (bus_range->lo != bus_range->hi)
2436 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2437 "%u -> %u\n", bus_range->lo, bus_range->hi);
2438 else {
2439
2440 bzero((caddr_t)&req, sizeof (ndi_ra_request_t));
2441 req.ra_addr = bus_range->lo + 1;
2442 req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
2443 req.ra_len = 12;
2444
2445 while ((req.ra_len > 0) &&
2446 (ret = ndi_ra_alloc(ddi_get_parent(pdip), &req,
2447 &next_bus, &blen, NDI_RA_TYPE_PCI_BUSNUM,
2448 NDI_RA_PASS)) != NDI_SUCCESS)
2449 req.ra_len--;
2450
2451 if (ret != NDI_SUCCESS) {
2452 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2453 "fail to allocate bus number\n");
2454 goto exit;
2455 }
2456
2457 bus_range->hi = bus_range->lo + req.ra_len;
2458 if (ndi_prop_update_int_array(DDI_DEV_T_NONE, pdip,
2459 "bus-range", (int *)bus_range, 2) != DDI_SUCCESS) {
2460 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2461 "fail to update bus-range property\n");
2462 goto exit;
2463 }
2464
2465 if (pci_config_setup(pdip, &handle) != DDI_SUCCESS) {
2466 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2467 "fail to pci_config_setup\n");
2468 goto exit;
2469 }
2470
2471 pci_config_put8(handle, PCI_BCNF_SECBUS, bus_range->lo);
2472 pci_config_put8(handle, PCI_BCNF_SUBBUS, bus_range->hi);
2473
2474 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2475 "parent dip %u -> %u\n",
2476 pci_config_get8(handle, PCI_BCNF_SECBUS),
2477 pci_config_get8(handle, PCI_BCNF_SUBBUS));
2478 pci_config_teardown(&handle);
2479
2480 if (ndi_ra_map_setup(pdip, NDI_RA_TYPE_PCI_BUSNUM)
2481 != NDI_SUCCESS) {
2482 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2483 "fail to ndi_ra_map_setup of bus number\n");
2484 goto exit;
2485 }
2486
2487 (void) ndi_ra_free(pdip,
2488 (uint64_t)bus_range->lo + 1, req.ra_len,
2489 NDI_RA_TYPE_PCI_BUSNUM, 0);
2490 }
2491
2492 bzero((caddr_t)&req, sizeof (ndi_ra_request_t));
2493 req.ra_len = 2;
2494
2495 while ((req.ra_len > 0) &&
2496 (ret = ndi_ra_alloc(pdip, &req,
2497 &next_bus, &blen, NDI_RA_TYPE_PCI_BUSNUM,
2498 0)) != NDI_SUCCESS)
2499 req.ra_len--;
2500
2501 cardbus_err(dip, 1, "cardbus_expand_busrange: "
2502 "cardbus dip base %u length %d\n",
2503 (int)next_bus, (int)req.ra_len);
2504
2505 if (ret != NDI_SUCCESS) {
2506 cardbus_err(dip, 1, "cardbus_expand_busrange: "
2507 "fail to allocate bus number of length %d "
2508 "from parent\n",
2509 (int)req.ra_len);
2510 goto exit;
2511 }
2512
2513 if (ndi_ra_map_setup(dip, NDI_RA_TYPE_PCI_BUSNUM)
2514 != NDI_SUCCESS) {
2515 cardbus_err(dip, 1, "cardbus_expand_busrange: "
2516 "fail to ndi_ra_map_setup of bus numbers\n");
2517 goto exit;
2518 }
2519
2520 (void) ndi_ra_free(dip,
2521 (uint64_t)next_bus, req.ra_len,
2522 NDI_RA_TYPE_PCI_BUSNUM, 0);
2523 exit:
2524 kmem_free(bus_range, len);
2525
2526 } else
2527 cardbus_err(pdip, 1, "cardbus_expand_busrange: "
2528 "parent dip doesn't have busrange prop\n");
2529 }