![[BACK]](/icons/back.gif){kind=icon}
Return to mainbus.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa64 / hppa64|
Return to mainbus.c CVS log | Up to [local] / sys / arch / hppa64 / hppa64 |
1.1 nbrk 1: /* $OpenBSD: mainbus.c,v 1.4 2007/05/29 21:00:50 jason Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Michael Shalayeff
5: * All rights reserved.
6: *
7: * Permission to use, copy, modify, and distribute this software for any
8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
10: *
11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
16: * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
17: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18: */
19:
20: #include "power.h"
21:
22: #undef BTLBDEBUG
23:
24: #include <sys/param.h>
25: #include <sys/systm.h>
26: #include <sys/device.h>
27: #include <sys/reboot.h>
28: #include <sys/extent.h>
29: #include <sys/mbuf.h>
30:
31: #include <uvm/uvm.h>
32: #include <uvm/uvm_page.h>
33:
34: #include <machine/pdc.h>
35: #include <machine/iomod.h>
36: #include <machine/autoconf.h>
37:
38: struct mainbus_softc {
39: struct device sc_dv;
40:
41: hppa_hpa_t sc_hpa;
42: };
43:
44: int mbmatch(struct device *, void *, void *);
45: void mbattach(struct device *, struct device *, void *);
46:
47: struct cfattach mainbus_ca = {
48: sizeof(struct mainbus_softc), mbmatch, mbattach
49: };
50:
51: struct cfdriver mainbus_cd = {
52: NULL, "mainbus", DV_DULL
53: };
54:
55: struct pdc_hpa pdc_hpa PDC_ALIGNMENT;
56: struct pdc_power_info pdc_power_info PDC_ALIGNMENT;
57:
58: /* from machdep.c */
59: extern struct extent *hppa_ex;
60:
61: int
62: mbus_add_mapping(bus_addr_t bpa, bus_size_t size, int flags,
63: bus_space_handle_t *bshp)
64: {
65: paddr_t spa, epa;
66: int bank, off;
67:
68: if ((bank = vm_physseg_find(atop(bpa), &off)) >= 0)
69: panic("mbus_add_mapping: mapping real memory @0x%lx", bpa);
70:
71: for (spa = trunc_page(bpa), epa = bpa + size;
72: spa < epa; spa += PAGE_SIZE)
73: pmap_kenter_pa(spa, spa, UVM_PROT_RW);
74:
75: *bshp = bpa;
76: return (0);
77: }
78:
79: int
80: mbus_map(void *v, bus_addr_t bpa, bus_size_t size,
81: int flags, bus_space_handle_t *bshp)
82: {
83: int error;
84:
85: bpa &= HPPA_PHYSMAP;
86: if ((error = extent_alloc_region(hppa_ex, bpa, size, EX_NOWAIT)))
87: return (error);
88:
89: if ((error = mbus_add_mapping(bpa, size, flags, bshp))) {
90: if (extent_free(hppa_ex, bpa, size, EX_NOWAIT)) {
91: printf("bus_space_map: pa 0x%lx, size 0x%lx\n",
92: bpa, size);
93: printf("bus_space_map: can't free region\n");
94: }
95: }
96:
97: return error;
98: }
99:
100: void
101: mbus_unmap(void *v, bus_space_handle_t bsh, bus_size_t size)
102: {
103: u_long sva, eva;
104:
105: sva = trunc_page(bsh);
106: eva = round_page(bsh + size);
107:
108: #ifdef DIAGNOSTIC
109: if (eva <= sva)
110: panic("bus_space_unmap: overflow");
111: #endif
112:
113: pmap_kremove(sva, eva - sva);
114:
115: if (extent_free(hppa_ex, bsh, size, EX_NOWAIT)) {
116: printf("bus_space_unmap: ps 0x%lx, size 0x%lx\n",
117: bsh, size);
118: printf("bus_space_unmap: can't free region\n");
119: }
120: }
121:
122: int
123: mbus_alloc(void *v, bus_addr_t rstart, bus_addr_t rend, bus_size_t size,
124: bus_size_t align, bus_size_t boundary, int flags,
125: bus_addr_t *addrp, bus_space_handle_t *bshp)
126: {
127: bus_addr_t bpa;
128: int error;
129:
130: rstart &= HPPA_PHYSMAP;
131: rend &= HPPA_PHYSMAP;
132: if (rstart < hppa_ex->ex_start || rend > hppa_ex->ex_end)
133: panic("bus_space_alloc: bad region start/end");
134:
135: if ((error = extent_alloc_subregion(hppa_ex, rstart, rend, size,
136: align, 0, boundary, EX_NOWAIT, &bpa)))
137: return (error);
138:
139: if ((error = mbus_add_mapping(bpa, size, flags, bshp))) {
140: if (extent_free(hppa_ex, bpa, size, EX_NOWAIT)) {
141: printf("bus_space_alloc: pa 0x%lx, size 0x%lx\n",
142: bpa, size);
143: printf("bus_space_alloc: can't free region\n");
144: }
145: }
146:
147: *addrp = bpa | ~HPPA_PHYSMAP;
148: return (error);
149: }
150:
151: void
152: mbus_free(void *v, bus_space_handle_t h, bus_size_t size)
153: {
154: /* bus_space_unmap() does all that we need to do. */
155: mbus_unmap(v, h, size);
156: }
157:
158: int
159: mbus_subregion(void *v, bus_space_handle_t bsh, bus_size_t offset,
160: bus_size_t size, bus_space_handle_t *nbshp)
161: {
162: *nbshp = bsh + offset;
163: return (0);
164: }
165:
166: void
167: mbus_barrier(void *v, bus_space_handle_t h, bus_size_t o, bus_size_t l, int op)
168: {
169: sync_caches();
170: }
171:
172: struct hppa64_bus_space_tag hppa_bustag = {
173: NULL,
174:
175: mbus_map, mbus_unmap, mbus_subregion, mbus_alloc, mbus_free,
176: mbus_barrier,
177: };
178:
179: int
180: mbus_dmamap_create(void *v, bus_size_t size, int nsegments,
181: bus_size_t maxsegsz, bus_size_t boundary, int flags,
182: bus_dmamap_t *dmamp)
183: {
184: struct hppa64_bus_dmamap *map;
185: size_t mapsize;
186:
187: mapsize = sizeof(*map) + (sizeof(bus_dma_segment_t) * (nsegments - 1));
188: map = malloc(mapsize, M_DEVBUF,
189: (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK);
190: if (!map)
191: return (ENOMEM);
192:
193: bzero(map, mapsize);
194: map->_dm_size = size;
195: map->_dm_segcnt = nsegments;
196: map->_dm_maxsegsz = maxsegsz;
197: map->_dm_boundary = boundary;
198: map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT);
199: map->dm_mapsize = 0;
200: map->dm_nsegs = 0;
201:
202: *dmamp = map;
203: return (0);
204: }
205:
206: void
207: mbus_dmamap_unload(void *v, bus_dmamap_t map)
208: {
209: map->dm_mapsize = 0;
210: map->dm_nsegs = 0;
211: }
212:
213: void
214: mbus_dmamap_destroy(void *v, bus_dmamap_t map)
215: {
216: if (map->dm_mapsize != 0)
217: mbus_dmamap_unload(v, map);
218:
219: free(map, M_DEVBUF);
220: }
221:
222: /*
223: * Utility function to load a linear buffer. lastaddrp holds state
224: * between invocations (for multiple-buffer loads). segp contains
225: * the starting segment on entrance, and the ending segment on exit.
226: * first indicates if this is the first invocation of this function.
227: */
228: int
229: _bus_dmamap_load_buffer(bus_dma_tag_t t, bus_dmamap_t map, void *buf,
230: bus_size_t buflen, struct proc *p, int flags, paddr_t *lastaddrp,
231: int *segp, int first)
232: {
233: bus_size_t sgsize;
234: bus_addr_t curaddr, lastaddr, baddr, bmask;
235: vaddr_t vaddr = (vaddr_t)buf;
236: int seg;
237: pmap_t pmap;
238:
239: pmap = p? p->p_vmspace->vm_map.pmap : pmap_kernel();
240: lastaddr = *lastaddrp;
241: bmask = ~(map->_dm_boundary - 1);
242:
243: for (seg = *segp; buflen > 0 ; ) {
244: /*
245: * Get the physical address for this segment.
246: */
247: pmap_extract(pmap, vaddr, (paddr_t *)&curaddr);
248:
249: /*
250: * Compute the segment size, and adjust counts.
251: */
252: sgsize = PAGE_SIZE - ((u_long)vaddr & PAGE_MASK);
253: if (buflen < sgsize)
254: sgsize = buflen;
255:
256: /*
257: * Make sure we don't cross any boundaries.
258: */
259: if (map->_dm_boundary > 0) {
260: baddr = (curaddr + map->_dm_boundary) & bmask;
261: if (sgsize > (baddr - curaddr))
262: sgsize = (baddr - curaddr);
263: }
264:
265: /*
266: * Insert chunk into a segment, coalescing with
267: * previous segment if possible.
268: */
269: if (first) {
270: map->dm_segs[seg].ds_addr = curaddr;
271: map->dm_segs[seg].ds_len = sgsize;
272: map->dm_segs[seg]._ds_va = vaddr;
273: first = 0;
274: } else {
275: if (curaddr == lastaddr &&
276: (map->dm_segs[seg].ds_len + sgsize) <=
277: map->_dm_maxsegsz &&
278: (map->_dm_boundary == 0 ||
279: (map->dm_segs[seg].ds_addr & bmask) ==
280: (curaddr & bmask)))
281: map->dm_segs[seg].ds_len += sgsize;
282: else {
283: if (++seg >= map->_dm_segcnt)
284: break;
285: map->dm_segs[seg].ds_addr = curaddr;
286: map->dm_segs[seg].ds_len = sgsize;
287: map->dm_segs[seg]._ds_va = vaddr;
288: }
289: }
290:
291: lastaddr = curaddr + sgsize;
292: vaddr += sgsize;
293: buflen -= sgsize;
294: }
295:
296: *segp = seg;
297: *lastaddrp = lastaddr;
298:
299: /*
300: * Did we fit?
301: */
302: if (buflen != 0)
303: return (EFBIG); /* XXX better return value here? */
304: return (0);
305: }
306:
307: int
308: mbus_dmamap_load(void *v, bus_dmamap_t map, void *addr, bus_size_t size,
309: struct proc *p, int flags)
310: {
311: paddr_t lastaddr;
312: int seg, error;
313:
314: /*
315: * Make sure that on error condition we return "no valid mappings".
316: */
317: map->dm_nsegs = 0;
318: map->dm_mapsize = 0;
319:
320: if (size > map->_dm_size)
321: return (EINVAL);
322:
323: seg = 0;
324: lastaddr = 0;
325: error = _bus_dmamap_load_buffer(NULL, map, addr, size, p, flags,
326: &lastaddr, &seg, 1);
327: if (error == 0) {
328: map->dm_mapsize = size;
329: map->dm_nsegs = seg + 1;
330: }
331:
332: return (0);
333: }
334:
335: int
336: mbus_dmamap_load_mbuf(void *v, bus_dmamap_t map, struct mbuf *m0, int flags)
337: {
338: paddr_t lastaddr;
339: int seg, error, first;
340: struct mbuf *m;
341:
342: map->dm_mapsize = 0;
343: map->dm_nsegs = 0;
344:
345: #ifdef DIAGNOSTIC
346: if ((m0->m_flags & M_PKTHDR) == 0)
347: panic("_bus_dmamap_load_mbuf: no packet header");
348: #endif
349:
350: if (m0->m_pkthdr.len > map->_dm_size)
351: return (EINVAL);
352:
353: first = 1;
354: seg = 0;
355: error = 0;
356: lastaddr = 0;
357: for (m = m0; m != NULL && error == 0; m = m->m_next) {
358: error = _bus_dmamap_load_buffer(NULL, map, m->m_data, m->m_len,
359: NULL, flags, &lastaddr, &seg, first);
360: first = 0;
361: }
362: if (error == 0) {
363: map->dm_mapsize = m0->m_pkthdr.len;
364: map->dm_nsegs = seg + 1;
365: }
366:
367: return (error);
368: }
369:
370: int
371: mbus_dmamap_load_uio(void *v, bus_dmamap_t map, struct uio *uio, int flags)
372: {
373: paddr_t lastaddr;
374: int seg, i, error, first;
375: bus_size_t minlen, resid;
376: struct proc *p = NULL;
377: struct iovec *iov;
378: caddr_t addr;
379:
380: /*
381: * Make sure that on error condition we return "no valid mappings".
382: */
383: map->dm_mapsize = 0;
384: map->dm_nsegs = 0;
385:
386: resid = uio->uio_resid;
387: iov = uio->uio_iov;
388:
389: if (resid > map->_dm_size)
390: return (EINVAL);
391:
392: if (uio->uio_segflg == UIO_USERSPACE) {
393: p = uio->uio_procp;
394: #ifdef DIAGNOSTIC
395: if (p == NULL)
396: panic("_bus_dmamap_load_uio: USERSPACE but no proc");
397: #endif
398: }
399:
400: first = 1;
401: seg = 0;
402: error = 0;
403: lastaddr = 0;
404: for (i = 0; i < uio->uio_iovcnt && resid != 0 && error == 0; i++) {
405: /*
406: * Now at the first iovec to load. Load each iovec
407: * until we have exhausted the residual count.
408: */
409: minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len;
410: addr = (caddr_t)iov[i].iov_base;
411:
412: error = _bus_dmamap_load_buffer(NULL, map, addr, minlen,
413: p, flags, &lastaddr, &seg, first);
414: first = 0;
415:
416: resid -= minlen;
417: }
418: if (error == 0) {
419: map->dm_mapsize = uio->uio_resid;
420: map->dm_nsegs = seg + 1;
421: }
422: return (error);
423: }
424:
425: int
426: mbus_dmamap_load_raw(void *v, bus_dmamap_t map, bus_dma_segment_t *segs,
427: int nsegs, bus_size_t size, int flags)
428: {
429: if (nsegs > map->_dm_segcnt || size > map->_dm_size)
430: return (EINVAL);
431:
432: /*
433: * Make sure we don't cross any boundaries.
434: */
435: if (map->_dm_boundary) {
436: bus_addr_t bmask = ~(map->_dm_boundary - 1);
437: int i;
438:
439: for (i = 0; i < nsegs; i++) {
440: if (segs[i].ds_len > map->_dm_maxsegsz)
441: return (EINVAL);
442: if ((segs[i].ds_addr & bmask) !=
443: ((segs[i].ds_addr + segs[i].ds_len - 1) & bmask))
444: return (EINVAL);
445: }
446: }
447:
448: bcopy(segs, map->dm_segs, nsegs * sizeof(*segs));
449: map->dm_nsegs = nsegs;
450: map->dm_mapsize = size;
451: return (0);
452: }
453:
454: void
455: mbus_dmamap_sync(void *v, bus_dmamap_t map, bus_addr_t off, bus_size_t len,
456: int ops)
457: {
458: bus_dma_segment_t *ps = map->dm_segs,
459: *es = &map->dm_segs[map->dm_nsegs];
460:
461: if (off >= map->_dm_size)
462: return;
463:
464: if ((off + len) > map->_dm_size)
465: len = map->_dm_size - off;
466:
467: for (; len && ps < es; ps++)
468: if (off > ps->ds_len)
469: off -= ps->ds_len;
470: else {
471: bus_size_t l = ps->ds_len - off;
472: if (l > len)
473: l = len;
474: fdcache(HPPA_SID_KERNEL, ps->_ds_va + off, l);
475: len -= l;
476: off = 0;
477: }
478:
479: /* for either operation sync the shit away */
480: sync_caches();
481: }
482:
483: int
484: mbus_dmamem_alloc(void *v, bus_size_t size, bus_size_t alignment,
485: bus_size_t boundary, bus_dma_segment_t *segs, int nsegs,
486: int *rsegs, int flags)
487: {
488: extern paddr_t avail_end;
489: struct pglist pglist;
490: struct vm_page *pg;
491:
492: size = round_page(size);
493:
494: TAILQ_INIT(&pglist);
495: if (uvm_pglistalloc(size, 0, avail_end, alignment, boundary,
496: &pglist, 1, flags & BUS_DMA_NOWAIT))
497: return (ENOMEM);
498:
499: pg = TAILQ_FIRST(&pglist);
500: segs[0]._ds_va = segs[0].ds_addr = VM_PAGE_TO_PHYS(pg);
501: segs[0].ds_len = size;
502: *rsegs = 1;
503:
504: for(; pg; pg = TAILQ_NEXT(pg, pageq))
505: /* XXX for now */
506: pmap_changebit(pg, PTE_UNCACHABLE, 0);
507: pmap_update(pmap_kernel());
508:
509: return (0);
510: }
511:
512: void
513: mbus_dmamem_free(void *v, bus_dma_segment_t *segs, int nsegs)
514: {
515: struct pglist pglist;
516: paddr_t pa, epa;
517:
518: TAILQ_INIT(&pglist);
519: for(; nsegs--; segs++)
520: for (pa = segs->ds_addr, epa = pa + segs->ds_len;
521: pa < epa; pa += PAGE_SIZE) {
522: struct vm_page *pg = PHYS_TO_VM_PAGE(pa);
523: if (!pg)
524: panic("mbus_dmamem_free: no page for pa");
525: TAILQ_INSERT_TAIL(&pglist, pg, pageq);
526: }
527: uvm_pglistfree(&pglist);
528: }
529:
530: int
531: mbus_dmamem_map(void *v, bus_dma_segment_t *segs, int nsegs, size_t size,
532: caddr_t *kvap, int flags)
533: {
534: *kvap = (caddr_t)segs[0].ds_addr;
535: return 0;
536: }
537:
538: void
539: mbus_dmamem_unmap(void *v, caddr_t kva, size_t size)
540: {
541: }
542:
543: paddr_t
544: mbus_dmamem_mmap(void *v, bus_dma_segment_t *segs, int nsegs, off_t off,
545: int prot, int flags)
546: {
547: panic("_dmamem_mmap: not implemented");
548: }
549:
550: const struct hppa64_bus_dma_tag hppa_dmatag = {
551: NULL,
552: mbus_dmamap_create, mbus_dmamap_destroy,
553: mbus_dmamap_load, mbus_dmamap_load_mbuf,
554: mbus_dmamap_load_uio, mbus_dmamap_load_raw,
555: mbus_dmamap_unload, mbus_dmamap_sync,
556:
557: mbus_dmamem_alloc, mbus_dmamem_free, mbus_dmamem_map,
558: mbus_dmamem_unmap, mbus_dmamem_mmap
559: };
560:
561: int
562: mbmatch(parent, cfdata, aux)
563: struct device *parent;
564: void *cfdata;
565: void *aux;
566: {
567: struct cfdata *cf = cfdata;
568:
569: /* there will be only one */
570: if (cf->cf_unit)
571: return 0;
572:
573: return 1;
574: }
575:
576: void
577: mbattach(parent, self, aux)
578: struct device *parent;
579: struct device *self;
580: void *aux;
581: {
582: struct mainbus_softc *sc = (struct mainbus_softc *)self;
583: struct confargs nca;
584: bus_space_handle_t ioh;
585: bus_addr_t hpa;
586:
587: /* fetch the "default" cpu hpa */
588: if (pdc_call((iodcio_t)pdc, 0, PDC_HPA, PDC_HPA_DFLT, &pdc_hpa) < 0)
589: panic("mbattach: PDC_HPA failed");
590: hpa = pdc_hpa.hpa | 0xffffffff00000000UL;
591:
592: printf(" [flex %lx]\n", hpa & HPPA_FLEX_MASK);
593:
594: /* map all the way till the end of the memory */
595: if (bus_space_map(&hppa_bustag, hpa, HPPA_PHYSEND - hpa + 1, 0, &ioh))
596: panic("mbattach: cannot map mainbus IO space");
597:
598: /*
599: * Local-Broadcast the HPA to all modules on this bus
600: */
601: ((struct iomod *)(HPPA_LBCAST & HPPA_PHYSMAP))->io_flex =
602: (hpa & HPPA_FLEX_MASK) | DMA_ENABLE;
603:
604: sc->sc_hpa = hpa;
605:
606: /* PDC first */
607: bzero (&nca, sizeof(nca));
608: nca.ca_name = "pdc";
609: nca.ca_iot = &hppa_bustag;
610: nca.ca_dmatag = &hppa_dmatag;
611: config_found(self, &nca, mbprint);
612:
613: #if NPOWER > 0
614: /* get some power */
615: bzero (&nca, sizeof(nca));
616: nca.ca_name = "power";
617: nca.ca_irq = -1;
618: if (!pdc_call((iodcio_t)pdc, 0, PDC_SOFT_POWER,
619: PDC_SOFT_POWER_INFO, &pdc_power_info, 0)) {
620: nca.ca_iot = &hppa_bustag;
621: nca.ca_hpa = pdc_power_info.addr;
622: nca.ca_hpamask = HPPA_IOBEGIN;
623: }
624: config_found(self, &nca, mbprint);
625: #endif
626:
627: bzero (&nca, sizeof(nca));
628: nca.ca_iot = &hppa_bustag;
629: nca.ca_dmatag = &hppa_dmatag;
630: nca.ca_mod = -1;
631: pdc_scan(self, &nca);
632: }
633:
634: /*
635: * retrive CPU #N HPA value
636: */
637: hppa_hpa_t
638: cpu_gethpa(n)
639: int n;
640: {
641: struct mainbus_softc *sc;
642:
643: sc = mainbus_cd.cd_devs[0];
644:
645: return sc->sc_hpa;
646: }
647:
648: int
649: mbprint(aux, pnp)
650: void *aux;
651: const char *pnp;
652: {
653: struct confargs *ca = aux;
654:
655: if (pnp)
656: printf("\"%s\" at %s", ca->ca_name, pnp);
657:
658: if (ca->ca_hpa)
659: printf(" hpa %lx", ca->ca_hpa);
660:
661: return (UNCONF);
662: }