1 /* $NetBSD: cardbus.c,v 1.47.4.1 2004/07/23 22:15:16 he Exp $ */
2
3 /*
4 * Copyright (c) 1997, 1998, 1999 and 2000
5 * HAYAKAWA Koichi. 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:
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 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by HAYAKAWA Koichi.
18 * 4. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
26 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
28 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
30 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 __KERNEL_RCSID(0, "$NetBSD: cardbus.c,v 1.47.4.1 2004/07/23 22:15:16 he Exp $");
37
38 #include "opt_cardbus.h"
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/device.h>
43 #include <sys/malloc.h>
44 #include <sys/kernel.h>
45 #include <sys/syslog.h>
46 #include <sys/proc.h>
47 #include <sys/reboot.h> /* for AB_* needed by bootverbose */
48
49 #include <machine/bus.h>
50
51 #include <dev/cardbus/cardbusvar.h>
52 #include <dev/cardbus/cardbusdevs.h>
53
54 #include <dev/cardbus/cardbus_exrom.h>
55
56 #include <dev/pci/pcivar.h> /* XXX */
57 #include <dev/pci/pcireg.h> /* XXX */
58
59 #include <dev/pcmcia/pcmciareg.h>
60
61 #if defined CARDBUS_DEBUG
62 #define STATIC
63 #define DPRINTF(a) printf a
64 #else
65 #define STATIC static
66 #define DPRINTF(a)
67 #endif
68
69
70 STATIC void cardbusattach(struct device *, struct device *, void *);
71 int cardbus_attach_card(struct cardbus_softc *);
72
73 STATIC int cardbusmatch(struct device *, struct cfdata *, void *);
74 static int cardbussubmatch(struct device *, struct cfdata *, void *);
75 static int cardbusprint(void *, const char *);
76
77 typedef void (*tuple_decode_func)(u_int8_t*, int, void*);
78
79 static int decode_tuples(u_int8_t *, int, tuple_decode_func, void*);
80 #ifdef CARDBUS_DEBUG
81 static void print_tuple(u_int8_t*, int, void*);
82 #endif
83
84 static int cardbus_read_tuples(struct cardbus_attach_args *,
85 cardbusreg_t, u_int8_t *, size_t);
86
87 static void enable_function(struct cardbus_softc *, int, int);
88 static void disable_function(struct cardbus_softc *, int);
89
90 CFATTACH_DECL(cardbus, sizeof(struct cardbus_softc),
91 cardbusmatch, cardbusattach, NULL, NULL);
92
93 #ifndef __NetBSD_Version__
94 struct cfdriver cardbus_cd = {
95 NULL, "cardbus", DV_DULL
96 };
97 #endif
98
99
100 STATIC int
101 cardbusmatch(struct device *parent, struct cfdata *cf, void *aux)
102 {
103 struct cbslot_attach_args *cba = aux;
104
105 if (strcmp(cba->cba_busname, cf->cf_name)) {
106 DPRINTF(("cardbusmatch: busname differs %s <=> %s\n",
107 cba->cba_busname, cf->cf_name));
108 return (0);
109 }
110
111 return (1);
112 }
113
114 STATIC void
115 cardbusattach(struct device *parent, struct device *self, void *aux)
116 {
117 struct cardbus_softc *sc = (void *)self;
118 struct cbslot_attach_args *cba = aux;
119
120 sc->sc_bus = cba->cba_bus;
121 sc->sc_device = 0;
122 sc->sc_intrline = cba->cba_intrline;
123 sc->sc_cacheline = cba->cba_cacheline;
124 sc->sc_lattimer = cba->cba_lattimer;
125
126 printf(": bus %d device %d", sc->sc_bus, sc->sc_device);
127 if (bootverbose)
128 printf(" cacheline 0x%x, lattimer 0x%x", sc->sc_cacheline,
129 sc->sc_lattimer);
130 printf("\n");
131
132 sc->sc_iot = cba->cba_iot; /* CardBus I/O space tag */
133 sc->sc_memt = cba->cba_memt; /* CardBus MEM space tag */
134 sc->sc_dmat = cba->cba_dmat; /* DMA tag */
135 sc->sc_cc = cba->cba_cc;
136 sc->sc_cf = cba->cba_cf;
137
138 #if rbus
139 sc->sc_rbus_iot = cba->cba_rbus_iot;
140 sc->sc_rbus_memt = cba->cba_rbus_memt;
141 #endif
142
143 sc->sc_funcs = NULL;
144 }
145
146 static int
147 cardbus_read_tuples(struct cardbus_attach_args *ca, cardbusreg_t cis_ptr,
148 u_int8_t *tuples, size_t len)
149 {
150 struct cardbus_softc *sc = ca->ca_ct->ct_sc;
151 cardbus_chipset_tag_t cc = ca->ca_ct->ct_cc;
152 cardbus_function_tag_t cf = ca->ca_ct->ct_cf;
153 cardbustag_t tag = ca->ca_tag;
154 cardbusreg_t command;
155 bus_space_tag_t bar_tag;
156 bus_space_handle_t bar_memh;
157 bus_size_t bar_size;
158 bus_addr_t bar_addr;
159 cardbusreg_t reg;
160 int found = 0;
161 int cardbus_space = cis_ptr & CARDBUS_CIS_ASIMASK;
162 int i, j;
163
164 memset(tuples, 0, len);
165
166 cis_ptr = cis_ptr & CARDBUS_CIS_ADDRMASK;
167
168 switch (cardbus_space) {
169 case CARDBUS_CIS_ASI_TUPLE:
170 DPRINTF(("%s: reading CIS data from configuration space\n",
171 sc->sc_dev.dv_xname));
172 for (i = cis_ptr, j = 0; i < 0xff; i += 4) {
173 u_int32_t e = (*cf->cardbus_conf_read)(cc, tag, i);
174 tuples[j] = 0xff & e;
175 e >>= 8;
176 tuples[j + 1] = 0xff & e;
177 e >>= 8;
178 tuples[j + 2] = 0xff & e;
179 e >>= 8;
180 tuples[j + 3] = 0xff & e;
181 j += 4;
182 }
183 found++;
184 break;
185
186 case CARDBUS_CIS_ASI_BAR0:
187 case CARDBUS_CIS_ASI_BAR1:
188 case CARDBUS_CIS_ASI_BAR2:
189 case CARDBUS_CIS_ASI_BAR3:
190 case CARDBUS_CIS_ASI_BAR4:
191 case CARDBUS_CIS_ASI_BAR5:
192 case CARDBUS_CIS_ASI_ROM:
193 if (cardbus_space == CARDBUS_CIS_ASI_ROM) {
194 reg = CARDBUS_ROM_REG;
195 DPRINTF(("%s: reading CIS data from ROM\n",
196 sc->sc_dev.dv_xname));
197 } else {
198 reg = CARDBUS_BASE0_REG + (cardbus_space - 1) * 4;
199 DPRINTF(("%s: reading CIS data from BAR%d\n",
200 sc->sc_dev.dv_xname, cardbus_space - 1));
201 }
202
203 /*
204 * XXX zero register so mapreg_map doesn't get confused by old
205 * contents.
206 */
207 cardbus_conf_write(cc, cf, tag, reg, 0);
208 if (Cardbus_mapreg_map(ca->ca_ct, reg,
209 CARDBUS_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT,
210 0, &bar_tag, &bar_memh, &bar_addr, &bar_size)) {
211 printf("%s: failed to map memory\n",
212 sc->sc_dev.dv_xname);
213 return (1);
214 }
215
216 if (cardbus_space == CARDBUS_CIS_ASI_ROM) {
217 cardbusreg_t exrom;
218 int save;
219 struct cardbus_rom_image_head rom_image;
220 struct cardbus_rom_image *p;
221
222 save = splhigh();
223 /* enable rom address decoder */
224 exrom = cardbus_conf_read(cc, cf, tag, reg);
225 cardbus_conf_write(cc, cf, tag, reg, exrom | 1);
226
227 command = cardbus_conf_read(cc, cf, tag,
228 CARDBUS_COMMAND_STATUS_REG);
229 cardbus_conf_write(cc, cf, tag,
230 CARDBUS_COMMAND_STATUS_REG,
231 command | CARDBUS_COMMAND_MEM_ENABLE);
232
233 if (cardbus_read_exrom(ca->ca_memt, bar_memh,
234 &rom_image))
235 goto out;
236
237 SIMPLEQ_FOREACH(p, &rom_image, next) {
238 if (p->rom_image ==
239 CARDBUS_CIS_ASI_ROM_IMAGE(cis_ptr)) {
240 bus_space_read_region_1(p->romt,
241 p->romh, CARDBUS_CIS_ADDR(cis_ptr),
242 tuples, 256);
243 found++;
244 }
245 break;
246 }
247 while ((p = SIMPLEQ_FIRST(&rom_image)) != NULL) {
248 SIMPLEQ_REMOVE_HEAD(&rom_image, next);
249 free(p, M_DEVBUF);
250 }
251 out:
252 exrom = cardbus_conf_read(cc, cf, tag, reg);
253 cardbus_conf_write(cc, cf, tag, reg, exrom & ~1);
254 splx(save);
255 } else {
256 command = cardbus_conf_read(cc, cf, tag,
257 CARDBUS_COMMAND_STATUS_REG);
258 cardbus_conf_write(cc, cf, tag,
259 CARDBUS_COMMAND_STATUS_REG,
260 command | CARDBUS_COMMAND_MEM_ENABLE);
261 /* XXX byte order? */
262 bus_space_read_region_1(ca->ca_memt, bar_memh,
263 cis_ptr, tuples, 256);
264 found++;
265 }
266 command = cardbus_conf_read(cc, cf, tag,
267 CARDBUS_COMMAND_STATUS_REG);
268 cardbus_conf_write(cc, cf, tag, CARDBUS_COMMAND_STATUS_REG,
269 command & ~CARDBUS_COMMAND_MEM_ENABLE);
270 cardbus_conf_write(cc, cf, tag, reg, 0);
271
272 Cardbus_mapreg_unmap(ca->ca_ct, reg, bar_tag, bar_memh,
273 bar_size);
274 break;
275
276 #ifdef DIAGNOSTIC
277 default:
278 panic("%s: bad CIS space (%d)", sc->sc_dev.dv_xname,
279 cardbus_space);
280 #endif
281 }
282 return (!found);
283 }
284
285 static void
286 parse_tuple(u_int8_t *tuple, int len, void *data)
287 {
288 struct cardbus_cis_info *cis = data;
289 char *p;
290 int i, bar_index;
291
292 switch (tuple[0]) {
293 case PCMCIA_CISTPL_MANFID:
294 if (tuple[1] != 5) {
295 DPRINTF(("%s: wrong length manufacturer id (%d)\n",
296 __func__, tuple[1]));
297 break;
298 }
299 cis->manufacturer = tuple[2] | (tuple[3] << 8);
300 cis->product = tuple[4] | (tuple[5] << 8);
301 break;
302
303 case PCMCIA_CISTPL_VERS_1:
304 memcpy(cis->cis1_info_buf, tuple + 2, tuple[1]);
305 i = 0;
306 p = cis->cis1_info_buf + 2;
307 while (i <
308 sizeof(cis->cis1_info) / sizeof(cis->cis1_info[0])) {
309 cis->cis1_info[i++] = p;
310 while (*p != '\0' && *p != '\xff')
311 p++;
312 if (*p == '\xff')
313 break;
314 p++;
315 }
316 break;
317
318 case PCMCIA_CISTPL_BAR:
319 if (tuple[1] != 6) {
320 DPRINTF(("%s: BAR with short length (%d)\n",
321 __func__, tuple[1]));
322 break;
323 }
324 bar_index = tuple[2] & 7;
325 if (bar_index == 0) {
326 DPRINTF(("%s: invalid ASI in BAR tuple\n", __func__));
327 break;
328 }
329 bar_index--;
330 cis->bar[bar_index].flags = tuple[2];
331 cis->bar[bar_index].size =
332 (tuple[4] << 0) |
333 (tuple[5] << 8) |
334 (tuple[6] << 16) |
335 (tuple[7] << 24);
336 break;
337
338 case PCMCIA_CISTPL_FUNCID:
339 cis->funcid = tuple[2];
340 break;
341
342 case PCMCIA_CISTPL_FUNCE:
343 switch (cis->funcid) {
344 case PCMCIA_FUNCTION_SERIAL:
345 if (tuple[1] >= 2 &&
346 /* XXX PCMCIA_TPLFE_TYPE_SERIAL_??? */
347 tuple[2] == 0) {
348 cis->funce.serial.uart_type = tuple[3] & 0x1f;
349 cis->funce.serial.uart_present = 1;
350 }
351 break;
352
353 case PCMCIA_FUNCTION_NETWORK:
354 if (tuple[1] >= 8 &&
355 tuple[2] == PCMCIA_TPLFE_TYPE_LAN_NID) {
356 if (tuple[3] >
357 sizeof(cis->funce.network.netid)) {
358 DPRINTF(("%s: unknown network id type "
359 "(len = %d)\n",
360 __func__, tuple[3]));
361 } else {
362 cis->funce.network.netid_present = 1;
363 memcpy(cis->funce.network.netid,
364 tuple + 4, tuple[3]);
365 }
366 }
367 break;
368 }
369 break;
370 }
371 }
372
373 /*
374 * int cardbus_attach_card(struct cardbus_softc *sc)
375 *
376 * This function attaches the card on the slot: turns on power,
377 * reads and analyses tuple, sets configuration index.
378 *
379 * This function returns the number of recognised device functions.
380 * If no functions are recognised, return 0.
381 */
382 int
383 cardbus_attach_card(struct cardbus_softc *sc)
384 {
385 cardbus_chipset_tag_t cc;
386 cardbus_function_tag_t cf;
387 cardbustag_t tag;
388 cardbusreg_t id, class, cis_ptr;
389 cardbusreg_t bhlc;
390 u_int8_t tuple[2048];
391 int cdstatus;
392 int function, nfunction;
393 struct cardbus_devfunc **previous_next = &(sc->sc_funcs);
394 struct device *csc;
395 int no_work_funcs = 0;
396 cardbus_devfunc_t ct;
397
398 cc = sc->sc_cc;
399 cf = sc->sc_cf;
400
401 DPRINTF(("cardbus_attach_card: cb%d start\n", sc->sc_dev.dv_unit));
402
403 /* inspect initial voltage */
404 if ((cdstatus = (*cf->cardbus_ctrl)(cc, CARDBUS_CD)) == 0) {
405 DPRINTF(("cardbusattach: no CardBus card on cb%d\n",
406 sc->sc_dev.dv_unit));
407 return (0);
408 }
409
410 /*
411 * XXX use fake function 8 to keep power on during whole
412 * configuration.
413 */
414 enable_function(sc, cdstatus, 8);
415 function = 0;
416
417 tag = cardbus_make_tag(cc, cf, sc->sc_bus, sc->sc_device, function);
418
419 /*
420 * Wait until power comes up. Maxmum 500 ms.
421 */
422 {
423 int i;
424
425 for (i = 0; i < 5; ++i) {
426 id = cardbus_conf_read(cc, cf, tag, CARDBUS_ID_REG);
427 if (id != 0xffffffff && id != 0) {
428 break;
429 }
430 if (cold) { /* before kernel thread invoked */
431 delay(100 * 1000);
432 } else { /* thread context */
433 if (tsleep((void *)sc, PCATCH, "cardbus",
434 hz / 10) != EWOULDBLOCK) {
435 break;
436 }
437 }
438 }
439 if (i == 5) {
440 return (0);
441 }
442 }
443
444 bhlc = cardbus_conf_read(cc, cf, tag, CARDBUS_BHLC_REG);
445 DPRINTF(("%s bhlc 0x%08x -> ", sc->sc_dev.dv_xname, bhlc));
446 nfunction = CARDBUS_HDRTYPE_MULTIFN(bhlc) ? 8 : 1;
447
448 for (function = 0; function < nfunction; function++) {
449 struct cardbus_attach_args ca;
450
451 tag = cardbus_make_tag(cc, cf, sc->sc_bus, sc->sc_device,
452 function);
453
454 id = cardbus_conf_read(cc, cf, tag, CARDBUS_ID_REG);
455 class = cardbus_conf_read(cc, cf, tag, CARDBUS_CLASS_REG);
456 cis_ptr = cardbus_conf_read(cc, cf, tag, CARDBUS_CIS_REG);
457
458 /* Invalid vendor ID value? */
459 if (CARDBUS_VENDOR(id) == CARDBUS_VENDOR_INVALID) {
460 continue;
461 }
462
463 DPRINTF(("cardbus_attach_card: "
464 "Vendor 0x%x, Product 0x%x, CIS 0x%x\n",
465 CARDBUS_VENDOR(id), CARDBUS_PRODUCT(id), cis_ptr));
466
467 enable_function(sc, cdstatus, function);
468
469 /* clean up every BAR */
470 cardbus_conf_write(cc, cf, tag, CARDBUS_BASE0_REG, 0);
471 cardbus_conf_write(cc, cf, tag, CARDBUS_BASE1_REG, 0);
472 cardbus_conf_write(cc, cf, tag, CARDBUS_BASE2_REG, 0);
473 cardbus_conf_write(cc, cf, tag, CARDBUS_BASE3_REG, 0);
474 cardbus_conf_write(cc, cf, tag, CARDBUS_BASE4_REG, 0);
475 cardbus_conf_write(cc, cf, tag, CARDBUS_BASE5_REG, 0);
476 cardbus_conf_write(cc, cf, tag, CARDBUS_ROM_REG, 0);
477
478 /* set initial latency and cacheline size */
479 bhlc = cardbus_conf_read(cc, cf, tag, CARDBUS_BHLC_REG);
480 DPRINTF(("%s func%d bhlc 0x%08x -> ", sc->sc_dev.dv_xname,
481 function, bhlc));
482 bhlc &= ~((CARDBUS_LATTIMER_MASK << CARDBUS_LATTIMER_SHIFT) |
483 (CARDBUS_CACHELINE_MASK << CARDBUS_CACHELINE_SHIFT));
484 bhlc |= ((sc->sc_cacheline & CARDBUS_CACHELINE_MASK) << CARDBUS_CACHELINE_SHIFT);
485 bhlc |= ((sc->sc_lattimer & CARDBUS_LATTIMER_MASK) << CARDBUS_LATTIMER_SHIFT);
486
487 cardbus_conf_write(cc, cf, tag, CARDBUS_BHLC_REG, bhlc);
488 bhlc = cardbus_conf_read(cc, cf, tag, CARDBUS_BHLC_REG);
489 DPRINTF(("0x%08x\n", bhlc));
490
491 if (CARDBUS_LATTIMER(bhlc) < 0x10) {
492 bhlc &= ~(CARDBUS_LATTIMER_MASK << CARDBUS_LATTIMER_SHIFT);
493 bhlc |= (0x10 << CARDBUS_LATTIMER_SHIFT);
494 cardbus_conf_write(cc, cf, tag, CARDBUS_BHLC_REG, bhlc);
495 }
496
497 /*
498 * We need to allocate the ct here, since we might
499 * need it when reading the CIS
500 */
501 if ((ct = malloc(sizeof(struct cardbus_devfunc),
502 M_DEVBUF, M_NOWAIT)) == NULL) {
503 panic("no room for cardbus_tag");
504 }
505
506 ct->ct_cc = sc->sc_cc;
507 ct->ct_cf = sc->sc_cf;
508 ct->ct_bus = sc->sc_bus;
509 ct->ct_dev = sc->sc_device;
510 ct->ct_func = function;
511 ct->ct_sc = sc;
512 ct->ct_next = NULL;
513 *previous_next = ct;
514
515 memset(&ca, 0, sizeof(ca));
516
517 ca.ca_unit = sc->sc_dev.dv_unit;
518 ca.ca_ct = ct;
519
520 ca.ca_iot = sc->sc_iot;
521 ca.ca_memt = sc->sc_memt;
522 ca.ca_dmat = sc->sc_dmat;
523
524 #if rbus
525 ca.ca_rbus_iot = sc->sc_rbus_iot;
526 ca.ca_rbus_memt= sc->sc_rbus_memt;
527 #endif
528
529 ca.ca_tag = tag;
530 ca.ca_bus = sc->sc_bus;
531 ca.ca_device = sc->sc_device;
532 ca.ca_function = function;
533 ca.ca_id = id;
534 ca.ca_class = class;
535
536 ca.ca_intrline = sc->sc_intrline;
537
538 if (cis_ptr != 0) {
539 if (cardbus_read_tuples(&ca, cis_ptr, tuple, sizeof(tuple))) {
540 printf("cardbus_attach_card: failed to read CIS\n");
541 } else {
542 #ifdef CARDBUS_DEBUG
543 decode_tuples(tuple, 2048, print_tuple, NULL);
544 #endif
545 decode_tuples(tuple, 2048, parse_tuple, &ca.ca_cis);
546 }
547 }
548
549 if ((csc = config_found_sm((void *)sc, &ca, cardbusprint,
550 cardbussubmatch)) == NULL) {
551 /* do not match */
552 disable_function(sc, function);
553 free(ct, M_DEVBUF);
554 *previous_next = NULL;
555 } else {
556 /* found */
557 previous_next = &(ct->ct_next);
558 ct->ct_device = csc;
559 ++no_work_funcs;
560 }
561 }
562 /*
563 * XXX power down pseudo function 8 (this will power down the card
564 * if no functions were attached).
565 */
566 disable_function(sc, 8);
567
568 return (no_work_funcs);
569 }
570
571 static int
572 cardbussubmatch(struct device *parent, struct cfdata *cf, void *aux)
573 {
574 struct cardbus_attach_args *ca = aux;
575
576 if (cf->cardbuscf_dev != CARDBUS_UNK_DEV &&
577 cf->cardbuscf_dev != ca->ca_unit) {
578 return (0);
579 }
580 if (cf->cardbuscf_function != CARDBUS_UNK_FUNCTION &&
581 cf->cardbuscf_function != ca->ca_function) {
582 return (0);
583 }
584
585 return (config_match(parent, cf, aux));
586 }
587
588 static int
589 cardbusprint(void *aux, const char *pnp)
590 {
591 struct cardbus_attach_args *ca = aux;
592 char devinfo[256];
593 int i;
594
595 if (pnp) {
596 pci_devinfo(ca->ca_id, ca->ca_class, 1, devinfo);
597 for (i = 0; i < 4; i++) {
598 if (ca->ca_cis.cis1_info[i] == NULL)
599 break;
600 if (i)
601 aprint_normal(", ");
602 aprint_normal("%s", ca->ca_cis.cis1_info[i]);
603 }
604 aprint_verbose("%s(manufacturer 0x%x, product 0x%x)",
605 i ? " " : "",
606 ca->ca_cis.manufacturer, ca->ca_cis.product);
607 aprint_normal(" %s at %s", devinfo, pnp);
608 }
609 aprint_normal(" dev %d function %d", ca->ca_device, ca->ca_function);
610
611 return (UNCONF);
612 }
613
614 /*
615 * void cardbus_detach_card(struct cardbus_softc *sc)
616 *
617 * This function detaches the card on the slot: detach device data
618 * structure and turns off the power.
619 *
620 * This function must not be called under interrupt context.
621 */
622 void
623 cardbus_detach_card(struct cardbus_softc *sc)
624 {
625 struct cardbus_devfunc *ct, *ct_next, **prev_next;
626
627 prev_next = &(sc->sc_funcs->ct_next);
628
629 for (ct = sc->sc_funcs; ct != NULL; ct = ct_next) {
630 struct device *fndev = ct->ct_device;
631 ct_next = ct->ct_next;
632
633 DPRINTF(("%s: detaching %s\n", sc->sc_dev.dv_xname,
634 fndev->dv_xname));
635 /* call device detach function */
636
637 if (0 != config_detach(fndev, 0)) {
638 printf("%s: cannot detach dev %s, function %d\n",
639 sc->sc_dev.dv_xname, fndev->dv_xname, ct->ct_func);
640 prev_next = &(ct->ct_next);
641 } else {
642 sc->sc_poweron_func &= ~(1 << ct->ct_func);
643 *prev_next = ct->ct_next;
644 free(ct, M_DEVBUF);
645 }
646 }
647
648 sc->sc_poweron_func = 0;
649 (*sc->sc_cf->cardbus_power)(sc->sc_cc,
650 CARDBUS_VCC_0V | CARDBUS_VPP_0V);
651 }
652
653 /*
654 * void *cardbus_intr_establish(cc, cf, irq, level, func, arg)
655 * Interrupt handler of pccard.
656 * args:
657 * cardbus_chipset_tag_t *cc
658 * int irq:
659 */
660 void *
661 cardbus_intr_establish(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf,
662 cardbus_intr_handle_t irq, int level, int (*func)(void *), void *arg)
663 {
664
665 DPRINTF(("- cardbus_intr_establish: irq %d\n", irq));
666 return ((*cf->cardbus_intr_establish)(cc, irq, level, func, arg));
667 }
668
669 /*
670 * void cardbus_intr_disestablish(cc, cf, handler)
671 * Interrupt handler of pccard.
672 * args:
673 * cardbus_chipset_tag_t *cc
674 */
675 void
676 cardbus_intr_disestablish(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf,
677 void *handler)
678 {
679
680 DPRINTF(("- pccard_intr_disestablish\n"));
681 (*cf->cardbus_intr_disestablish)(cc, handler);
682 }
683
684 /*
685 * XXX this should be merged with cardbus_function_{enable,disable},
686 * but we don't have a ct when these functions are called.
687 */
688 static void
689 enable_function(struct cardbus_softc *sc, int cdstatus, int function)
690 {
691
692 if (sc->sc_poweron_func == 0) {
693 /* switch to 3V and/or wait for power to stabilize */
694 if (cdstatus & CARDBUS_3V_CARD) {
695 /*
696 * sc_poweron_func must be substituted before
697 * entering sleep, in order to avoid turn on
698 * power twice.
699 */
700 sc->sc_poweron_func |= (1 << function);
701 (*sc->sc_cf->cardbus_power)(sc->sc_cc, CARDBUS_VCC_3V);
702 } else {
703 /* No cards other than 3.3V cards. */
704 return;
705 }
706 (*sc->sc_cf->cardbus_ctrl)(sc->sc_cc, CARDBUS_RESET);
707 }
708 sc->sc_poweron_func |= (1 << function);
709 }
710
711 static void
712 disable_function(struct cardbus_softc *sc, int function)
713 {
714
715 sc->sc_poweron_func &= ~(1 << function);
716 if (sc->sc_poweron_func == 0) {
717 /* power-off because no functions are enabled */
718 (*sc->sc_cf->cardbus_power)(sc->sc_cc, CARDBUS_VCC_0V);
719 }
720 }
721
722 /*
723 * int cardbus_function_enable(struct cardbus_softc *sc, int func)
724 *
725 * This function enables a function on a card. When no power is
726 * applied on the card, power will be applied on it.
727 */
728 int
729 cardbus_function_enable(struct cardbus_softc *sc, int func)
730 {
731 cardbus_chipset_tag_t cc = sc->sc_cc;
732 cardbus_function_tag_t cf = sc->sc_cf;
733 cardbusreg_t command;
734 cardbustag_t tag;
735
736 DPRINTF(("entering cardbus_function_enable... "));
737
738 /* entering critical area */
739
740 /* XXX: sc_vold should be used */
741 enable_function(sc, CARDBUS_3V_CARD, func);
742
743 /* exiting critical area */
744
745 tag = cardbus_make_tag(cc, cf, sc->sc_bus, sc->sc_device, func);
746
747 command = cardbus_conf_read(cc, cf, tag, CARDBUS_COMMAND_STATUS_REG);
748 command |= (CARDBUS_COMMAND_MEM_ENABLE | CARDBUS_COMMAND_IO_ENABLE |
749 CARDBUS_COMMAND_MASTER_ENABLE); /* XXX: good guess needed */
750
751 cardbus_conf_write(cc, cf, tag, CARDBUS_COMMAND_STATUS_REG, command);
752
753 cardbus_free_tag(cc, cf, tag);
754
755 DPRINTF(("%x\n", sc->sc_poweron_func));
756
757 return (0);
758 }
759
760 /*
761 * int cardbus_function_disable(struct cardbus_softc *, int func)
762 *
763 * This function disable a function on a card. When no functions are
764 * enabled, it turns off the power.
765 */
766 int
767 cardbus_function_disable(struct cardbus_softc *sc, int func)
768 {
769
770 DPRINTF(("entering cardbus_function_disable... "));
771
772 disable_function(sc, func);
773
774 return (0);
775 }
776
777 /*
778 * int cardbus_get_capability(cardbus_chipset_tag_t cc,
779 * cardbus_function_tag_t cf, cardbustag_t tag, int capid, int *offset,
780 * cardbusreg_t *value)
781 *
782 * Find the specified PCI capability.
783 */
784 int
785 cardbus_get_capability(cardbus_chipset_tag_t cc, cardbus_function_tag_t cf,
786 cardbustag_t tag, int capid, int *offset, cardbusreg_t *value)
787 {
788 cardbusreg_t reg;
789 unsigned int ofs;
790
791 reg = cardbus_conf_read(cc, cf, tag, PCI_COMMAND_STATUS_REG);
792 if (!(reg & PCI_STATUS_CAPLIST_SUPPORT))
793 return (0);
794
795 ofs = PCI_CAPLIST_PTR(cardbus_conf_read(cc, cf, tag,
796 PCI_CAPLISTPTR_REG));
797 while (ofs != 0) {
798 #ifdef DIAGNOSTIC
799 if ((ofs & 3) || (ofs < 0x40))
800 panic("cardbus_get_capability");
801 #endif
802 reg = cardbus_conf_read(cc, cf, tag, ofs);
803 if (PCI_CAPLIST_CAP(reg) == capid) {
804 if (offset)
805 *offset = ofs;
806 if (value)
807 *value = reg;
808 return (1);
809 }
810 ofs = PCI_CAPLIST_NEXT(reg);
811 }
812
813 return (0);
814 }
815
816 /*
817 * below this line, there are some functions for decoding tuples.
818 * They should go out from this file.
819 */
820
821 static u_int8_t *
822 decode_tuple(u_int8_t *tuple, tuple_decode_func func, void *data);
823
824 static int
825 decode_tuples(u_int8_t *tuple, int buflen, tuple_decode_func func, void *data)
826 {
827 u_int8_t *tp = tuple;
828
829 if (PCMCIA_CISTPL_LINKTARGET != *tuple) {
830 DPRINTF(("WRONG TUPLE: 0x%x\n", *tuple));
831 return (0);
832 }
833
834 while (NULL != (tp = decode_tuple(tp, func, data))) {
835 if (tuple + buflen < tp) {
836 break;
837 }
838 }
839
840 return (1);
841 }
842
843 static u_int8_t *
844 decode_tuple(u_int8_t *tuple, tuple_decode_func func, void *data)
845 {
846 u_int8_t type;
847 u_int8_t len;
848
849 type = tuple[0];
850 len = tuple[1] + 2;
851
852 (*func)(tuple, len, data);
853
854 if (type == PCMCIA_CISTPL_END) {
855 return (NULL);
856 }
857
858 return (tuple + len);
859 }
860
861 #ifdef CARDBUS_DEBUG
862 static const char *tuple_name(int);
863 static const char *tuple_names[] = {
864 "TPL_NULL", "TPL_DEVICE", "Reserved", "Reserved", /* 0-3 */
865 "CONFIG_CB", "CFTABLE_ENTRY_CB", "Reserved", "BAR", /* 4-7 */
866 "Reserved", "Reserved", "Reserved", "Reserved", /* 8-B */
867 "Reserved", "Reserved", "Reserved", "Reserved", /* C-F */
868 "CHECKSUM", "LONGLINK_A", "LONGLINK_C", "LINKTARGET", /* 10-13 */
869 "NO_LINK", "VERS_1", "ALTSTR", "DEVICE_A",
870 "JEDEC_C", "JEDEC_A", "CONFIG", "CFTABLE_ENTRY",
871 "DEVICE_OC", "DEVICE_OA", "DEVICE_GEO", "DEVICE_GEO_A",
872 "MANFID", "FUNCID", "FUNCE", "SWIL", /* 20-23 */
873 "Reserved", "Reserved", "Reserved", "Reserved", /* 24-27 */
874 "Reserved", "Reserved", "Reserved", "Reserved", /* 28-2B */
875 "Reserved", "Reserved", "Reserved", "Reserved", /* 2C-2F */
876 "Reserved", "Reserved", "Reserved", "Reserved", /* 30-33 */
877 "Reserved", "Reserved", "Reserved", "Reserved", /* 34-37 */
878 "Reserved", "Reserved", "Reserved", "Reserved", /* 38-3B */
879 "Reserved", "Reserved", "Reserved", "Reserved", /* 3C-3F */
880 "VERS_2", "FORMAT", "GEOMETRY", "BYTEORDER",
881 "DATE", "BATTERY", "ORG"
882 };
883 #define NAME_LEN(x) (sizeof x / sizeof(x[0]))
884
885 static const char *
886 tuple_name(int type)
887 {
888
889 if (0 <= type && type < NAME_LEN(tuple_names)) {
890 return (tuple_names[type]);
891 } else if (type == 0xff) {
892 return ("END");
893 } else {
894 return ("Reserved");
895 }
896 }
897
898 static void
899 print_tuple(u_int8_t *tuple, int len, void *data)
900 {
901 int i;
902
903 printf("tuple: %s len %d\n", tuple_name(tuple[0]), len);
904
905 for (i = 0; i < len; ++i) {
906 if (i % 16 == 0) {
907 printf(" 0x%2x:", i);
908 }
909 printf(" %x", tuple[i]);
910 if (i % 16 == 15) {
911 printf("\n");
912 }
913 }
914 if (i % 16 != 0) {
915 printf("\n");
916 }
917 }
918 #endif
Cache object: 98f2fc5d3283613c911079bc634ae911
|