1 /* $NetBSD: rbus_ppb.c,v 1.10 2003/11/24 06:11:56 lukem Exp $ */
2
3 /*
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Michael Richardson <mcr@sandelman.ottawa.on.ca>
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39 /*
40 * CardBus front-end for the Intel/Digital DECchip 21152 PCI-PCI bridge
41 */
42
43 #include <sys/cdefs.h>
44 __KERNEL_RCSID(0, "$NetBSD: rbus_ppb.c,v 1.10 2003/11/24 06:11:56 lukem Exp $");
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/mbuf.h>
49 #include <sys/malloc.h>
50 #include <sys/kernel.h>
51 #include <sys/socket.h>
52 #include <sys/ioctl.h>
53 #include <sys/errno.h>
54 #include <sys/device.h>
55
56 #if NRND > 0
57 #include <sys/rnd.h>
58 #endif
59
60 #include <machine/endian.h>
61
62 #include <machine/bus.h>
63 #include <machine/intr.h>
64
65 #include <dev/pci/pcivar.h>
66 #include <dev/pci/pcireg.h>
67 #include <dev/pci/pcidevs.h>
68 #include <dev/pci/ppbreg.h>
69
70 #include <dev/ic/i82365reg.h>
71 #include <dev/ic/i82365var.h>
72
73 #include <dev/pci/pccbbreg.h>
74 #include <dev/pci/pccbbvar.h>
75
76 #include <dev/cardbus/cardbusvar.h>
77 #include <dev/cardbus/cardbusdevs.h>
78
79 #include <i386/pci/pci_addr_fixup.h>
80 #include <i386/pci/pci_bus_fixup.h>
81 #include <i386/pci/pci_intr_fixup.h>
82 #include <i386/pci/pcibios.h>
83
84 struct ppb_softc;
85
86 static int ppb_cardbus_match __P((struct device *, struct cfdata *, void *));
87 static void ppb_cardbus_attach __P((struct device *, struct device *, void *));
88 static int ppb_cardbus_detach __P((struct device * self, int flags));
89 /*static*/ void ppb_cardbus_setup __P((struct ppb_softc * sc));
90 /*static*/ int ppb_cardbus_enable __P((struct ppb_softc * sc));
91 /*static*/ void ppb_cardbus_disable __P((struct ppb_softc * sc));
92 static int ppb_activate __P((struct device *self, enum devact act));
93 int rppbprint __P((void *aux, const char *pnp));
94 int rbus_intr_fixup __P((pci_chipset_tag_t pc, int minbus,
95 int maxbus, int line));
96 void rbus_do_header_fixup __P((pci_chipset_tag_t pc, pcitag_t tag,
97 void *context));
98
99 static void rbus_pci_phys_allocate __P((pci_chipset_tag_t pc,
100 pcitag_t tag,
101 void *context));
102
103 static int rbus_do_phys_allocate __P((pci_chipset_tag_t pc,
104 pcitag_t tag,
105 int mapreg,
106 void *ctx,
107 int type,
108 bus_addr_t *addr,
109 bus_size_t size));
110
111 static void rbus_pci_phys_countspace __P((pci_chipset_tag_t pc,
112 pcitag_t tag,
113 void *context));
114
115 static int rbus_do_phys_countspace __P((pci_chipset_tag_t pc,
116 pcitag_t tag,
117 int mapreg,
118 void *ctx,
119 int type,
120 bus_addr_t *addr,
121 bus_size_t size));
122
123 unsigned int rbus_round_up __P((unsigned int size, unsigned int min));
124
125
126 struct ppb_cardbus_softc {
127 struct device sc_dev;
128 pcitag_t sc_tag;
129 int foo;
130 };
131
132 CFATTACH_DECL(rbus_ppb, sizeof(struct ppb_cardbus_softc),
133 ppb_cardbus_match, ppb_cardbus_attach, ppb_cardbus_detach, ppb_activate);
134
135 #ifdef CBB_DEBUG
136 int rbus_ppb_debug = 0; /* hack with kdb */
137 #define DPRINTF(X) if(rbus_ppb_debug) printf X
138 #else
139 #define DPRINTF(X)
140 #endif
141
142 static int
143 ppb_cardbus_match(parent, match, aux)
144 struct device *parent;
145 struct cfdata *match;
146 void *aux;
147 {
148 struct cardbus_attach_args *ca = aux;
149
150 if (CARDBUS_VENDOR(ca->ca_id) == PCI_VENDOR_DEC &&
151 CARDBUS_PRODUCT(ca->ca_id) == PCI_PRODUCT_DEC_21152)
152 return (1);
153
154 if(PCI_CLASS(ca->ca_class) == PCI_CLASS_BRIDGE &&
155 PCI_SUBCLASS(ca->ca_class) == PCI_SUBCLASS_BRIDGE_PCI) {
156 /* XXX */
157 printf("recognizing generic bridge chip\n");
158 }
159
160 return (0);
161 }
162
163
164 int
165 rppbprint(aux, pnp)
166 void *aux;
167 const char *pnp;
168 {
169 struct pcibus_attach_args *pba = aux;
170
171 /* only PCIs can attach to PPBs; easy. */
172 if (pnp)
173 aprint_normal("pci at %s", pnp);
174 aprint_normal(" bus %d (rbus)", pba->pba_bus);
175 return (UNCONF);
176 }
177
178 int
179 rbus_intr_fixup(pci_chipset_tag_t pc,
180 int minbus,
181 int maxbus,
182 int line)
183 {
184 pci_device_foreach_min(pc, minbus,
185 maxbus, rbus_do_header_fixup, (void *)&line);
186 return 0;
187 }
188
189 void
190 rbus_do_header_fixup(pc, tag, context)
191 pci_chipset_tag_t pc;
192 pcitag_t tag;
193 void *context;
194 {
195 int pin, irq;
196 int bus, device, function;
197 pcireg_t intr, id;
198 int *pline = (int *)context;
199 int line = *pline;
200
201 pci_decompose_tag(pc, tag, &bus, &device, &function);
202 id = pci_conf_read(pc, tag, PCI_ID_REG);
203
204 intr = pci_conf_read(pc, tag, PCI_INTERRUPT_REG);
205 pin = PCI_INTERRUPT_PIN(intr);
206 irq = PCI_INTERRUPT_LINE(intr);
207
208 #if 0
209 printf("do_header %02x:%02x:%02x pin=%d => line %d\n",
210 bus, device, function, pin, line);
211 #endif
212
213 intr &= ~(PCI_INTERRUPT_LINE_MASK << PCI_INTERRUPT_LINE_SHIFT);
214 intr |= (line << PCI_INTERRUPT_LINE_SHIFT);
215 pci_conf_write(pc, tag, PCI_INTERRUPT_REG, intr);
216
217 }
218
219 /*
220 * This function takes a range of PCI bus numbers and
221 * allocates space for all devices found in this space (the BARs) from
222 * the rbus space maps (I/O and memory).
223 *
224 * It assumes that "rbus" is defined. The whole concept does.
225 *
226 * It uses pci_device_foreach_min() to call rbus_pci_phys_allocate.
227 * This function is mostly stolen from
228 * pci_addr_fixup.c:pciaddr_resource_reserve.
229 *
230 */
231 struct rbus_pci_addr_fixup_context {
232 struct ppb_cardbus_softc *csc;
233 cardbus_chipset_tag_t ct;
234 struct cardbus_softc *sc;
235 struct cardbus_attach_args *caa;
236 int minbus;
237 int maxbus;
238 bus_size_t *bussize_ioreqs;
239 bus_size_t *bussize_memreqs;
240 rbus_tag_t *iobustags;
241 rbus_tag_t *membustags;
242 };
243
244 unsigned int
245 rbus_round_up(unsigned int size, unsigned int min)
246 {
247 unsigned int power2;
248
249 if(size == 0) {
250 return 0;
251 }
252
253 power2=min;
254
255 while(power2 < (1 << 31) &&
256 power2 < size) {
257 power2 = power2 << 1;
258 }
259
260 return power2;
261 }
262
263 static void
264 rbus_pci_addr_fixup(struct ppb_cardbus_softc *csc,
265 cardbus_chipset_tag_t ct,
266 struct cardbus_softc *sc,
267 pci_chipset_tag_t pc,
268 struct cardbus_attach_args *caa,
269 int minbus, int maxbus)
270 {
271 struct rbus_pci_addr_fixup_context rct;
272 int size, busnum;
273 bus_addr_t start;
274 bus_space_handle_t handle;
275 u_int32_t reg;
276
277 rct.csc=csc;
278 rct.ct=ct;
279 rct.sc=sc;
280 rct.caa=caa;
281 rct.minbus = minbus;
282 rct.maxbus = maxbus;
283 size = sizeof(bus_size_t)*(maxbus+1);
284 rct.bussize_ioreqs = alloca(size);
285 rct.bussize_memreqs = alloca(size);
286 rct.iobustags = alloca(maxbus * sizeof(rbus_tag_t));
287 rct.membustags = alloca(maxbus * sizeof(rbus_tag_t));
288
289 bzero(rct.bussize_ioreqs, size);
290 bzero(rct.bussize_memreqs, size);
291
292 printf("%s: sizing buses %d-%d\n",
293 rct.csc->sc_dev.dv_xname,
294 minbus, maxbus);
295
296 pci_device_foreach_min(pc, minbus, maxbus,
297 rbus_pci_phys_countspace, &rct);
298
299 /*
300 * we need to determine amount of address space for each
301 * bus. To do this, we have to roll up amounts and then
302 * we need to divide up the cardbus's extent to allocate
303 * some space to each bus.
304 */
305
306 for(busnum=maxbus; busnum > minbus; busnum--) {
307 if(pci_bus_parent[busnum] != 0) {
308 if(pci_bus_parent[busnum] < minbus ||
309 pci_bus_parent[busnum] >= maxbus) {
310 printf("%s: bus %d has illegal parent %d\n",
311 rct.csc->sc_dev.dv_xname,
312 busnum, pci_bus_parent[busnum]);
313 continue;
314 }
315
316 /* first round amount of space up */
317 rct.bussize_ioreqs[busnum] =
318 rbus_round_up(rct.bussize_ioreqs[busnum], PPB_IO_MIN);
319 rct.bussize_ioreqs[pci_bus_parent[busnum]] +=
320 rct.bussize_ioreqs[busnum];
321
322 rct.bussize_memreqs[busnum] =
323 rbus_round_up(rct.bussize_memreqs[busnum], PPB_MEM_MIN);
324 rct.bussize_memreqs[pci_bus_parent[busnum]] +=
325 rct.bussize_memreqs[busnum];
326
327 }
328 }
329
330 rct.bussize_ioreqs[minbus] =
331 rbus_round_up(rct.bussize_ioreqs[minbus], 4096);
332 rct.bussize_memreqs[minbus] =
333 rbus_round_up(rct.bussize_memreqs[minbus], 8);
334
335 printf("%s: total needs IO %08lx and MEM %08lx\n",
336 rct.csc->sc_dev.dv_xname,
337 rct.bussize_ioreqs[minbus], rct.bussize_memreqs[minbus]);
338
339 if(!caa->ca_rbus_iot) {
340 panic("no iot bus");
341 }
342
343 if(rct.bussize_ioreqs[minbus]) {
344 if(rbus_space_alloc(caa->ca_rbus_iot, 0,
345 rct.bussize_ioreqs[minbus],
346 rct.bussize_ioreqs[minbus]-1 /* mask */,
347 rct.bussize_ioreqs[minbus] /* align */,
348 /* flags */ 0,
349 &start,
350 &handle) != 0) {
351 panic("rbus_ppb: can not allocate %ld bytes in IO bus %d",
352 rct.bussize_ioreqs[minbus], minbus);
353 }
354 rct.iobustags[minbus]=rbus_new(caa->ca_rbus_iot,
355 start,
356 rct.bussize_ioreqs[minbus],
357 0 /* offset to add to physical address
358 to make processor address */,
359 RBUS_SPACE_DEDICATE);
360 }
361
362 if(rct.bussize_memreqs[minbus]) {
363 if(rbus_space_alloc(caa->ca_rbus_memt, 0,
364 rct.bussize_memreqs[minbus],
365 rct.bussize_memreqs[minbus]-1 /* mask */,
366 rct.bussize_memreqs[minbus] /* align */,
367 /* flags */ 0,
368 &start,
369 &handle) != 0) {
370 panic("%s: can not allocate %ld bytes in MEM bus %d",
371 rct.csc->sc_dev.dv_xname,
372 rct.bussize_memreqs[minbus], minbus);
373 }
374 rct.membustags[minbus]=rbus_new(caa->ca_rbus_memt,
375 start,
376 rct.bussize_memreqs[minbus],
377 0 /* offset to add to physical
378 address to make processor
379 address */,
380 RBUS_SPACE_DEDICATE);
381 }
382
383 for(busnum=minbus+1; busnum <= maxbus; busnum++) {
384 int busparent;
385
386 busparent = pci_bus_parent[busnum];
387
388 printf("%s: bus %d (parent=%d) needs IO %08lx and MEM %08lx\n",
389 rct.csc->sc_dev.dv_xname,
390 busnum,
391 busparent,
392 rct.bussize_ioreqs[busnum],
393 rct.bussize_memreqs[busnum]);
394
395 if(busparent > maxbus) {
396 panic("rbus_ppb: illegal parent");
397 }
398
399 if(rct.bussize_ioreqs[busnum]) {
400 if(rbus_space_alloc(rct.iobustags[busparent],
401 0,
402 rct.bussize_ioreqs[busnum],
403 rct.bussize_ioreqs[busnum]-1 /*mask */,
404 rct.bussize_ioreqs[busnum] /* align */,
405 /* flags */ 0,
406 &start,
407 &handle) != 0) {
408 panic("rbus_ppb: can not allocate %ld bytes in IO bus %d",
409 rct.bussize_ioreqs[busnum], busnum);
410 }
411 rct.iobustags[busnum]=rbus_new(rct.iobustags[busparent],
412 start,
413 rct.bussize_ioreqs[busnum],
414 0 /* offset to add to physical
415 address
416 to make processor address */,
417 RBUS_SPACE_DEDICATE);
418
419 /* program the bridge */
420
421 /* enable I/O space */
422 reg = pci_conf_read(pc, pci_bus_tag[busnum],
423 PCI_COMMAND_STATUS_REG);
424 reg |= PCI_COMMAND_IO_ENABLE | PCI_COMMAND_MASTER_ENABLE;
425 pci_conf_write(pc, pci_bus_tag[busnum],
426 PCI_COMMAND_STATUS_REG, reg);
427
428 /* now init the limit register for I/O */
429 pci_conf_write(pc, pci_bus_tag[busnum], PPB_REG_IOSTATUS,
430 (((start & 0xf000) >> 8) << PPB_IOBASE_SHIFT) |
431 ((((start +
432 rct.bussize_ioreqs[busnum] +
433 4095) & 0xf000) >> 8) << PPB_IOLIMIT_SHIFT));
434 }
435
436 if(rct.bussize_memreqs[busnum]) {
437 if(rbus_space_alloc(rct.membustags[busparent],
438 0,
439 rct.bussize_memreqs[busnum] /* size */,
440 rct.bussize_memreqs[busnum]-1 /*mask */,
441 rct.bussize_memreqs[busnum] /* align */,
442 /* flags */ 0,
443 &start,
444 &handle) != 0) {
445 panic("rbus_ppb: can not allocate %ld bytes in MEM bus %d",
446 rct.bussize_memreqs[busnum], busnum);
447 }
448 rct.membustags[busnum]=rbus_new(rct.membustags[busparent],
449 start,
450 rct.bussize_memreqs[busnum],
451 0 /* offset to add to physical
452 address to make processor
453 address */,
454 RBUS_SPACE_DEDICATE);
455
456 /* program the bridge */
457 /* enable memory space */
458 reg = pci_conf_read(pc, pci_bus_tag[busnum],
459 PCI_COMMAND_STATUS_REG);
460 reg |= PCI_COMMAND_MEM_ENABLE | PCI_COMMAND_MASTER_ENABLE;
461 pci_conf_write(pc, pci_bus_tag[busnum],
462 PCI_COMMAND_STATUS_REG, reg);
463
464 /* now init the limit register for memory */
465 pci_conf_write(pc, pci_bus_tag[busnum], PPB_REG_MEM,
466 ((start & PPB_MEM_MASK)
467 >> PPB_MEM_SHIFT) << PPB_MEMBASE_SHIFT |
468 (((start +
469 rct.bussize_memreqs[busnum] +
470 PPB_MEM_MIN-1) >> PPB_MEM_SHIFT)
471 << PPB_MEMLIMIT_SHIFT));
472
473 /* and set the prefetchable limits as well */
474 pci_conf_write(pc, pci_bus_tag[busnum], PPB_REG_PREFMEM,
475 ((start & PPB_MEM_MASK)
476 >> PPB_MEM_SHIFT) << PPB_MEMBASE_SHIFT |
477 (((start +
478 rct.bussize_memreqs[busnum] +
479 PPB_MEM_MIN-1) >> PPB_MEM_SHIFT)
480 << PPB_MEMLIMIT_SHIFT));
481
482 /* pci_conf_print(pc, pci_bus_tag[busnum], NULL); */
483 }
484 }
485
486 printf("%s: configuring buses %d-%d\n",
487 rct.csc->sc_dev.dv_xname,
488 minbus, maxbus);
489 pci_device_foreach_min(pc, minbus, maxbus,
490 rbus_pci_phys_allocate, &rct);
491 }
492
493 static void
494 rbus_pci_phys_countspace(pc, tag, context)
495 pci_chipset_tag_t pc;
496 pcitag_t tag;
497 void *context;
498 {
499 int bus, device, function;
500 struct rbus_pci_addr_fixup_context *rct =
501 (struct rbus_pci_addr_fixup_context *)context;
502
503 pci_decompose_tag(pc, tag, &bus, &device, &function);
504
505 printf("%s: configuring device %02x:%02x:%02x\n",
506 rct->csc->sc_dev.dv_xname,
507 bus, device, function);
508
509 pciaddr_resource_manage(pc, tag,
510 rbus_do_phys_countspace, context);
511 }
512
513
514 int
515 rbus_do_phys_countspace(pc, tag, mapreg, ctx, type, addr, size)
516 pci_chipset_tag_t pc;
517 pcitag_t tag;
518 void *ctx;
519 int mapreg, type;
520 bus_addr_t *addr;
521 bus_size_t size;
522 {
523 struct rbus_pci_addr_fixup_context *rct =
524 (struct rbus_pci_addr_fixup_context *)ctx;
525 int bus, device, function;
526
527 pci_decompose_tag(pc, tag, &bus, &device, &function);
528
529 if(size > (1<<24)) {
530 printf("%s: skipping huge space request of size=%08x\n",
531 rct->csc->sc_dev.dv_xname, (unsigned int)size);
532 return 0;
533 }
534
535 if(PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_IO) {
536 rct->bussize_ioreqs[bus] += size;
537 } else {
538 rct->bussize_memreqs[bus]+= size;
539 }
540
541 return 0;
542 }
543
544 static void
545 rbus_pci_phys_allocate(pc, tag, context)
546 pci_chipset_tag_t pc;
547 pcitag_t tag;
548 void *context;
549 {
550 int bus, device, function, command;
551 struct rbus_pci_addr_fixup_context *rct =
552 (struct rbus_pci_addr_fixup_context *)context;
553 //cardbus_chipset_tag_t ct = rct->ct;
554 // struct cardbus_softc *sc = rct->sc;
555
556 pci_decompose_tag(pc, tag, &bus, &device, &function);
557
558 printf("%s: configuring device %02x:%02x:%02x\n",
559 rct->csc->sc_dev.dv_xname,
560 bus, device, function);
561
562 pciaddr_resource_manage(pc, tag,
563 rbus_do_phys_allocate, context);
564
565 /* now turn the device's memory and I/O on */
566 command = pci_conf_read(pc, tag, PCI_COMMAND_STATUS_REG);
567 command |= PCI_COMMAND_IO_ENABLE|PCI_COMMAND_MEM_ENABLE;
568 pci_conf_write(pc, tag, PCI_COMMAND_STATUS_REG, command);
569 }
570
571 int
572 rbus_do_phys_allocate(pc, tag, mapreg, ctx, type, addr, size)
573 pci_chipset_tag_t pc;
574 pcitag_t tag;
575 void *ctx;
576 int mapreg, type;
577 bus_addr_t *addr;
578 bus_size_t size;
579 {
580 struct rbus_pci_addr_fixup_context *rct =
581 (struct rbus_pci_addr_fixup_context *)ctx;
582 cardbus_chipset_tag_t ct = rct->ct;
583 struct cardbus_softc *sc = rct->sc;
584 cardbus_function_t *cf = sc->sc_cf;
585 rbus_tag_t rbustag;
586 bus_space_tag_t bustag;
587 bus_addr_t mask = size -1;
588 bus_addr_t base = 0;
589 bus_space_handle_t handle;
590 int busflags = 0;
591 int flags = 0;
592 char *bustype;
593 int bus, device, function;
594
595 pci_decompose_tag(pc, tag, &bus, &device, &function);
596
597 /*
598 * some devices come up with garbage in them (Tulip?)
599 * we are in charge here, so give them address
600 * space anyway.
601 *
602 * XXX this may be due to no secondary PCI reset!!!
603 */
604 #if 0
605 if (*addr) {
606 printf("Already allocated space at %08x\n",
607 (unsigned int)*addr);
608 return (0);
609 }
610 #endif
611
612 if(size > (1<<24)) {
613 printf("%s: skipping huge space request of size=%08x\n",
614 rct->csc->sc_dev.dv_xname, (unsigned int)size);
615 return 0;
616 }
617
618 if(PCI_MAPREG_TYPE(type) == PCI_MAPREG_TYPE_IO) {
619 bustag = sc->sc_iot;
620 rbustag = rct->iobustags[bus];
621 bustype = "io";
622 } else {
623 bustag = sc->sc_memt;
624 rbustag = rct->membustags[bus];
625 bustype = "mem";
626 }
627
628 if((*cf->cardbus_space_alloc)(ct, rbustag, base, size,
629 mask, size, busflags|flags,
630 addr, &handle)) {
631 printf("%s: no available resources (size=%08x) for bar %2d. fixup failed\n",
632 rct->csc->sc_dev.dv_xname, (unsigned int)size, mapreg);
633
634 *addr = 0;
635 pci_conf_write(pc, tag, mapreg, *addr);
636 return (1);
637 }
638
639 printf("%s: alloc %s space of size %08x for %02d:%02d:%02d -> %08x\n",
640 rct->csc->sc_dev.dv_xname,
641 bustype,
642 (unsigned int)size,
643 bus, device, function, (unsigned int)*addr);
644
645 /* write new address to PCI device configuration header */
646 pci_conf_write(pc, tag, mapreg, *addr);
647
648 /* check */
649 {
650 DPRINTF(("%s: pci_addr_fixup: ",
651 rct->csc->sc_dev.dv_xname));
652 #ifdef CBB_DEBUG
653 if(rbus_ppb_debug) { pciaddr_print_devid(pc, tag); }
654 #endif
655 }
656
657 /* double check that the value got inserted correctly */
658 if (pciaddr_ioaddr(pci_conf_read(pc, tag, mapreg)) != *addr) {
659 pci_conf_write(pc, tag, mapreg, 0); /* clear */
660 printf("%s: fixup failed. (new address=%#x)\n",
661 rct->csc->sc_dev.dv_xname,
662 (unsigned)*addr);
663 return (1);
664 }
665
666 DPRINTF(("new address 0x%08x\n",
667 (unsigned)*addr));
668
669 return (0);
670 }
671
672 static void
673 ppb_cardbus_attach(parent, self, aux)
674 struct device *parent, *self;
675 void *aux;
676 {
677 struct ppb_cardbus_softc *csc = (struct ppb_cardbus_softc *) self;
678 struct cardbus_softc *parent_sc =
679 (struct cardbus_softc *) csc->sc_dev.dv_parent;
680 struct cardbus_attach_args *ca = aux;
681 cardbus_devfunc_t ct = ca->ca_ct;
682 cardbus_chipset_tag_t cc = ct->ct_cc;
683 cardbus_function_tag_t cf = ct->ct_cf;
684 struct pccbb_softc *psc = (struct pccbb_softc *)cc;
685 struct pcibus_attach_args pba;
686 char devinfo[256];
687 pcireg_t busdata;
688 int mybus, rv;
689 u_int16_t pciirq;
690 int minbus, maxbus;
691
692 mybus = ct->ct_bus;
693 pciirq = 0;
694 rv = 0;
695
696 /* shut up compiler */
697 csc->foo=parent_sc->sc_intrline;
698
699
700 pci_devinfo(ca->ca_id, ca->ca_class, 0, devinfo);
701 printf(": %s (rev. 0x%02x)\n", devinfo, PCI_REVISION(ca->ca_class));
702
703 csc->sc_tag = ca->ca_tag; /* XXX cardbustag_t == pcitag_t */
704
705 busdata = cardbus_conf_read(cc, cf, ca->ca_tag, PPB_REG_BUSINFO);
706 minbus = pcibios_max_bus;
707 maxbus = minbus; /* XXX; gcc */
708
709 if (PPB_BUSINFO_SECONDARY(busdata) == 0) {
710 printf("%s: not configured by system firmware calling pci_bus_fixup(%d)\n",
711 self->dv_xname, 0);
712
713 /*
714 * first, pull the reset wire on the secondary bridge
715 * to clear all devices
716 */
717 busdata = cardbus_conf_read(cc, cf, ca->ca_tag,
718 PPB_REG_BRIDGECONTROL);
719 cardbus_conf_write(cc, cf, ca->ca_tag, PPB_REG_BRIDGECONTROL,
720 busdata | PPB_BC_SECONDARY_RESET);
721 delay(1);
722 cardbus_conf_write(cc, cf, ca->ca_tag, PPB_REG_BRIDGECONTROL,
723 busdata);
724
725 /* then go initialize the bridge control registers */
726 maxbus = pci_bus_fixup(psc->sc_pc, 0);
727 }
728
729 busdata = cardbus_conf_read(cc, cf, ca->ca_tag, PPB_REG_BUSINFO);
730 if(PPB_BUSINFO_SECONDARY(busdata) == 0) {
731 printf("%s: still not configured, not fixable.\n",
732 self->dv_xname);
733 return;
734 }
735
736 #if 0
737 minbus = PPB_BUSINFO_SECONDARY(busdata);
738 maxbus = PPB_BUSINFO_SUBORDINATE(busdata);
739 #endif
740
741 /* now, go and assign addresses for the new devices */
742 rbus_pci_addr_fixup(csc, cc, parent_sc,
743 psc->sc_pc,
744 ca,
745 minbus, maxbus);
746
747 /*
748 * now configure all connected devices to the IRQ which
749 * was assigned to this slot, as they will all arrive from
750 * that IRQ.
751 */
752 rbus_intr_fixup(psc->sc_pc, minbus, maxbus, ca->ca_intrline);
753
754 /*
755 * enable direct routing of interrupts. We do this because
756 * we can not manage to get pccb_intr_establish() called until
757 * PCI subsystem is merged with rbus. The major thing that this
758 * routine does is avoid calling the driver's interrupt routine
759 * when the card has been removed.
760 *
761 * The rbus_ppb.c can not cope with card desertions until the merging
762 * anyway.
763 */
764 pccbb_intr_route(psc);
765
766 /*
767 * Attach the PCI bus than hangs off of it.
768 *
769 * XXX Don't pass-through Memory Read Multiple. Should we?
770 * XXX Consult the spec...
771 */
772 pba.pba_busname = "pci";
773 pba.pba_iot = ca->ca_iot;
774 pba.pba_memt = ca->ca_memt;
775 pba.pba_dmat = ca->ca_dmat;
776 pba.pba_pc = psc->sc_pc;
777 pba.pba_flags = PCI_FLAGS_IO_ENABLED|PCI_FLAGS_MEM_ENABLED;
778 pba.pba_bus = PPB_BUSINFO_SECONDARY(busdata);
779 pba.pba_bridgetag = &csc->sc_tag;
780 /*pba.pba_intrswiz = parent_sc->sc_intrswiz; */
781 pba.pba_intrtag = psc->sc_pa.pa_intrtag;
782
783 config_found(self, &pba, rppbprint);
784 }
785
786 void
787 ppb_cardbus_setup(struct ppb_softc * sc)
788 {
789 struct ppb_cardbus_softc *csc = (struct ppb_cardbus_softc *) sc;
790 #if 0
791 cardbus_chipset_tag_t cc = psc->sc_cc;
792 cardbus_function_tag_t cf = psc->sc_cf;
793 #endif
794
795 /* shut up compiler */
796 csc->foo=2;
797
798 printf("ppb_cardbus_setup called\n");
799 #if 0
800 /* not sure what to do here */
801 cardbustag_t tag = cardbus_make_tag(cc, cf, csc->ct->ct_bus,
802 csc->ct->ct_dev, csc->ct->ct_func);
803
804 command = Cardbus_conf_read(csc->ct, tag, CARDBUS_COMMAND_STATUS_REG);
805 if (csc->base0_reg) {
806 Cardbus_conf_write(csc->ct, tag,
807 CARDBUS_BASE0_REG, csc->base0_reg);
808 (cf->cardbus_ctrl) (cc, CARDBUS_MEM_ENABLE);
809 command |= CARDBUS_COMMAND_MEM_ENABLE |
810 CARDBUS_COMMAND_MASTER_ENABLE;
811 } else if (csc->base1_reg) {
812 Cardbus_conf_write(csc->ct, tag,
813 CARDBUS_BASE1_REG, csc->base1_reg);
814 (cf->cardbus_ctrl) (cc, CARDBUS_IO_ENABLE);
815 command |= (CARDBUS_COMMAND_IO_ENABLE |
816 CARDBUS_COMMAND_MASTER_ENABLE);
817 }
818
819 (cf->cardbus_ctrl) (cc, CARDBUS_BM_ENABLE);
820
821 /* enable the card */
822 Cardbus_conf_write(csc->ct, tag, CARDBUS_COMMAND_STATUS_REG, command);
823 #endif
824 }
825
826 int
827 ppb_cardbus_enable(struct ppb_softc * sc)
828 {
829 #if 0
830 struct ppb_cardbus_softc *csc = (struct fxp_cardbus_softc *) sc;
831 struct cardbus_softc *psc =
832 (struct cardbus_softc *) sc->sc_dev.dv_parent;
833 cardbus_chipset_tag_t cc = psc->sc_cc;
834 cardbus_function_tag_t cf = psc->sc_cf;
835
836 Cardbus_function_enable(csc->ct);
837
838 fxp_cardbus_setup(sc);
839
840 /* Map and establish the interrupt. */
841
842 sc->sc_ih = cardbus_intr_establish(cc, cf, psc->sc_intrline, IPL_NET,
843 fxp_intr, sc);
844 if (NULL == sc->sc_ih) {
845 printf("%s: couldn't establish interrupt\n",
846 sc->sc_dev.dv_xname);
847 return 1;
848 }
849
850 printf("%s: interrupting at %d\n", sc->sc_dev.dv_xname,
851 psc->sc_intrline);
852
853 #endif
854 return 0;
855 }
856
857 void
858 ppb_cardbus_disable(struct ppb_softc * sc)
859 {
860 #if 0
861 struct cardbus_softc *psc =
862 (struct cardbus_softc *) sc->sc_dev.dv_parent;
863 cardbus_chipset_tag_t cc = psc->sc_cc;
864 cardbus_function_tag_t cf = psc->sc_cf;
865
866 /* Remove interrupt handler. */
867 cardbus_intr_disestablish(cc, cf, sc->sc_ih);
868
869 Cardbus_function_disable(((struct fxp_cardbus_softc *) sc)->ct);
870 #endif
871 }
872
873 static int
874 ppb_cardbus_detach(self, flags)
875 struct device *self;
876 int flags;
877 {
878 /* struct ppb_softc *sc = (struct ppb_softc *) self;*/
879 struct ppb_cardbus_softc *csc = (struct ppb_cardbus_softc *) self;
880
881 #if 0
882 struct cardbus_devfunc *ct = csc->ct;
883 int rv, reg;
884
885 #ifdef DIAGNOSTIC
886 if (ct == NULL)
887 panic("%s: data structure lacks", sc->sc_dev.dv_xname);
888 #endif
889
890 rv = fxp_detach(sc);
891 if (rv == 0) {
892 /*
893 * Unhook the interrupt handler.
894 */
895 cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, sc->sc_ih);
896
897 /*
898 * release bus space and close window
899 */
900 if (csc->base0_reg)
901 reg = CARDBUS_BASE0_REG;
902 else
903 reg = CARDBUS_BASE1_REG;
904 Cardbus_mapreg_unmap(ct, reg, sc->sc_st, sc->sc_sh, csc->size);
905 }
906 return (rv);
907
908 #endif
909 csc->foo=1;
910 return 0;
911
912 }
913
914 int
915 ppb_activate(self, act)
916 struct device *self;
917 enum devact act;
918 {
919 printf("ppb_activate called\n");
920 return 0;
921 }
922
Cache object: 96d8f37b3779d8f46fa94061f1c315fd
|