Annotation of sys/arch/aviion/dev/vme.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: vme.c,v 1.3 2006/05/21 12:22:02 miod Exp $ */
2: /*
3: * Copyright (c) 2006, Miodrag Vallat.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: *
14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
18: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
22: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
23: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
24: * POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27: /*
28: * XXX TODO: Finish /dev/vme{a16,a24,a32}{d8,d16,d32} interface.
29: */
30:
31: #include <sys/param.h>
32: #include <sys/systm.h>
33: #include <sys/kernel.h>
34: #include <sys/device.h>
35: #include <sys/extent.h>
36: #include <sys/malloc.h>
37: #include <sys/proc.h>
38: #include <sys/uio.h>
39:
40: #include <machine/bus.h>
41: #include <machine/conf.h>
42:
43: #include <uvm/uvm_extern.h>
44:
45: #include <aviion/dev/vmevar.h>
46:
47: #include <machine/avcommon.h>
48: #include <machine/av400.h>
49: #include <aviion/dev/sysconreg.h>
50:
51: struct vmesoftc {
52: struct device sc_dev;
53:
54: struct extent *sc_ext_a16;
55: struct extent *sc_ext_a24;
56: struct extent *sc_ext_a32;
57: };
58:
59: int vmematch(struct device *, void *, void *);
60: void vmeattach(struct device *, struct device *, void *);
61:
62: struct cfattach vme_ca = {
63: sizeof(struct vmesoftc), vmematch, vmeattach
64: };
65:
66: struct cfdriver vme_cd = {
67: NULL, "vme", DV_DULL
68: };
69:
70: int vme16_map(bus_addr_t, bus_size_t, int, bus_space_handle_t *);
71: void vme16_unmap(bus_space_handle_t, bus_size_t);
72: int vme24_map(bus_addr_t, bus_size_t, int, bus_space_handle_t *);
73: void vme24_unmap(bus_space_handle_t, bus_size_t);
74: int vme32_map(bus_addr_t, bus_size_t, int, bus_space_handle_t *);
75: void vme32_unmap(bus_space_handle_t, bus_size_t);
76: int vme_subregion(bus_space_handle_t, bus_size_t, bus_size_t,
77: bus_space_handle_t *);
78: void * vme_vaddr(bus_space_handle_t);
79:
80: int vme_map(struct extent *, paddr_t, bus_addr_t, bus_size_t, int,
81: bus_space_handle_t *);
82: void vme_unmap(struct extent *, vme_addr_t, vaddr_t, bus_size_t);
83: int vmeprint(void *, const char *);
84: int vmescan(struct device *, void *, void *);
85:
86: u_int vmevecbase;
87:
88: int
89: vmematch(struct device *parent, void *vcf, void *aux)
90: {
91: /* XXX no VME on AV100/AV200/AV300, though */
92: return (1);
93: }
94:
95: void
96: vmeattach(struct device *parent, struct device *self, void *aux)
97: {
98: struct vmesoftc *sc = (struct vmesoftc *)self;
99: u_int32_t ucsr;
100:
101: printf("\n");
102:
103: /*
104: * Initialize extents
105: */
106: sc->sc_ext_a16 = extent_create("vme a16", 0, 1 << (16 - PAGE_SHIFT),
107: M_DEVBUF, NULL, 0, EX_NOWAIT);
108: sc->sc_ext_a24 = extent_create("vme a24", 0, 1 << (24 - PAGE_SHIFT),
109: M_DEVBUF, NULL, 0, EX_NOWAIT);
110: sc->sc_ext_a32 = extent_create("vme a32", 0, 1 << (32 - PAGE_SHIFT),
111: M_DEVBUF, NULL, 0, EX_NOWAIT);
112:
113: vmevecbase = 0x80; /* Hard coded */
114:
115: /*
116: * Force a reasonable timeout for VME data transfers.
117: * We can not disable this, this would cause autoconf to hang
118: * on the first missing device we'll probe.
119: */
120: ucsr = *(volatile u_int32_t*)AV_UCSR;
121: ucsr = (ucsr & ~VTOSELBITS) | VTO128US;
122: *(volatile u_int32_t *)AV_UCSR = ucsr;
123:
124: /*
125: * Clear EXTAD to allow VME A24 devices to access the first 16MB
126: * of memory.
127: */
128: *(volatile u_int32_t *)AV_EXTAD = 0x00000000;
129:
130: /*
131: * Use supervisor data address modifiers for VME accesses.
132: */
133: *(volatile u_int32_t *)AV_EXTAM = 0x0d;
134:
135: /*
136: * Display VME ranges.
137: */
138: printf("%s: A32 %08x-%08x\n", self->dv_xname,
139: AV400_VME32_START1, AV400_VME32_END1);
140: printf("%s: A32 %08x-%08x\n", self->dv_xname,
141: AV400_VME32_START2, AV400_VME32_END2);
142: printf("%s: A24 %08x-%08x\n", self->dv_xname,
143: AV400_VME24_START, AV400_VME24_END);
144: printf("%s: A16 %08x-%08x\n", self->dv_xname,
145: AV400_VME16_START, AV400_VME16_END);
146:
147: /* scan for child devices */
148: config_search(vmescan, self, aux);
149: }
150:
151: int
152: vmescan(struct device *parent, void *vcf, void *aux)
153: {
154: struct cfdata *cf = vcf;
155: struct vme_attach_args vaa;
156:
157: bzero(&vaa, sizeof vaa);
158: vaa.vaa_addr_a16 = (vme_addr_t)cf->cf_loc[0];
159: vaa.vaa_addr_a24 = (vme_addr_t)cf->cf_loc[1];
160: vaa.vaa_addr_a32 = (vme_addr_t)cf->cf_loc[2];
161: vaa.vaa_ipl = (u_int)cf->cf_loc[3];
162:
163: if ((*cf->cf_attach->ca_match)(parent, cf, &vaa) == 0)
164: return (0);
165:
166: config_attach(parent, cf, &vaa, vmeprint);
167: return (1);
168: }
169:
170: int
171: vmeprint(void *aux, const char *pnp)
172: {
173: struct vme_attach_args *vaa = aux;
174:
175: if (vaa->vaa_addr_a16 != (vme_addr_t)-1)
176: printf(" a16 0x%04x", vaa->vaa_addr_a16);
177: if (vaa->vaa_addr_a24 != (vme_addr_t)-1)
178: printf(" a24 0x%06x", vaa->vaa_addr_a24);
179: if (vaa->vaa_addr_a32 != (vme_addr_t)-1)
180: printf(" a32 0x%08x", vaa->vaa_addr_a32);
181: if (vaa->vaa_ipl != (u_int)-1)
182: printf(" ipl %u", vaa->vaa_ipl);
183:
184: return (UNCONF);
185: }
186:
187: /*
188: * Interrupt related code
189: */
190:
191: /* allocate interrupt vectors */
192: int
193: vmeintr_allocate(u_int count, int flags, u_int *array)
194: {
195: u_int vec, v;
196:
197: if ((flags & VMEINTR_CONTIGUOUS) == 0) {
198: for (vec = vmevecbase; vec <= NVMEINTR - count; vec++) {
199: if (SLIST_EMPTY(&intr_handlers[vec])) {
200: *array++ = vec;
201: if (--count == 0)
202: return (0);
203: }
204: }
205: } else {
206: for (vec = vmevecbase; vec <= NVMEINTR - count; vec++) {
207: /* do we have count contiguous unassigned vectors? */
208: for (v = count; v != 0; v--)
209: if (!SLIST_EMPTY(&intr_handlers[vec + v - 1]))
210: break;
211:
212: if (v == 0) {
213: *array = vec;
214: return (0);
215: }
216: }
217: }
218:
219: return (EPERM);
220: }
221:
222: /* enable and establish interrupt */
223: int
224: vmeintr_establish(u_int vec, struct intrhand *ih, const char *name)
225: {
226: /*
227: * No need to enable the VME interrupt source in the interrupt
228: * controller, as they are enabled by default.
229: */
230: return intr_establish(vec, ih, name);
231: }
232:
233: /*
234: * bus_space specific functions
235: */
236:
237: int
238: vme16_map(bus_addr_t addr, bus_size_t size, int flags, bus_space_handle_t *ret)
239: {
240: struct vmesoftc *sc = (void *)vme_cd.cd_devs[0];
241:
242: if (AV400_ISVMEA16(addr) && AV400_ISVMEA16(addr + size - 1))
243: return (vme_map(sc->sc_ext_a16, addr + AV400_VME16_BASE, addr,
244: size, flags, ret));
245: else
246: return (EINVAL);
247: }
248:
249: int
250: vme24_map(bus_addr_t addr, bus_size_t size, int flags, bus_space_handle_t *ret)
251: {
252: struct vmesoftc *sc = (void *)vme_cd.cd_devs[0];
253:
254: if (AV400_ISVMEA24(addr) && AV400_ISVMEA24(addr + size - 1))
255: return (vme_map(sc->sc_ext_a24, addr + AV400_VME24_BASE, addr,
256: size, flags, ret));
257: else
258: return (EINVAL);
259: }
260:
261: int
262: vme32_map(bus_addr_t addr, bus_size_t size, int flags, bus_space_handle_t *ret)
263: {
264: struct vmesoftc *sc = (void *)vme_cd.cd_devs[0];
265:
266: if (AV400_ISVMEA32(addr) && AV400_ISVMEA32(addr + size - 1))
267: return (vme_map(sc->sc_ext_a32, addr + AV400_VME32_BASE, addr,
268: size, flags, ret));
269: else
270: return (EINVAL);
271: }
272:
273: int
274: vme_map(struct extent *ext, paddr_t paddr, bus_addr_t addr, bus_size_t size,
275: int flags, bus_space_handle_t *ret)
276: {
277: int rc;
278: paddr_t pa;
279: psize_t len;
280: vaddr_t ova, va;
281: u_int pg;
282: extern vaddr_t pmap_map(vaddr_t, paddr_t, paddr_t, vm_prot_t, u_int);
283:
284: pa = trunc_page(paddr);
285: len = round_page(paddr + size) - pa;
286:
287: if (ext != NULL) {
288: rc = extent_alloc_region(ext, atop(addr), atop(len),
289: EX_NOWAIT | EX_MALLOCOK);
290: if (rc != 0)
291: return (rc);
292: }
293:
294: ova = va = uvm_km_valloc(kernel_map, len);
295: if (va == NULL) {
296: rc = ENOMEM;
297: goto fail;
298: }
299:
300: *ret = (bus_space_handle_t)va;
301:
302: for (pg = atop(len); pg !=0; pg--) {
303: pmap_kenter_pa(va, pa, UVM_PROT_RW);
304: va += PAGE_SIZE;
305: pa += PAGE_SIZE;
306: }
307: if (flags & BUS_SPACE_MAP_CACHEABLE)
308: pmap_cache_ctrl(pmap_kernel(), ova, ova + len, CACHE_GLOBAL);
309: pmap_update(pmap_kernel());
310:
311: return (0);
312:
313: fail:
314: if (ext != NULL)
315: extent_free(ext, atop(addr), atop(len), EX_NOWAIT | EX_MALLOCOK);
316: return (rc);
317: }
318:
319: void
320: vme16_unmap(bus_space_handle_t handle, bus_size_t size)
321: {
322: struct vmesoftc *sc = (void *)vme_cd.cd_devs[0];
323: paddr_t pa;
324:
325: if (pmap_extract(pmap_kernel(), (vaddr_t)handle, &pa) == FALSE)
326: return;
327:
328: pa -= AV400_VME16_BASE;
329: return (vme_unmap(sc->sc_ext_a16, pa, (vaddr_t)handle, size));
330: }
331:
332: void
333: vme24_unmap(bus_space_handle_t handle, bus_size_t size)
334: {
335: struct vmesoftc *sc = (void *)vme_cd.cd_devs[0];
336: paddr_t pa;
337:
338: if (pmap_extract(pmap_kernel(), (vaddr_t)handle, &pa) == FALSE)
339: return;
340:
341: pa -= AV400_VME24_BASE;
342: return (vme_unmap(sc->sc_ext_a24, pa, (vaddr_t)handle, size));
343: }
344:
345: void
346: vme32_unmap(bus_space_handle_t handle, bus_size_t size)
347: {
348: struct vmesoftc *sc = (void *)vme_cd.cd_devs[0];
349: paddr_t pa;
350:
351: if (pmap_extract(pmap_kernel(), (vaddr_t)handle, &pa) == FALSE)
352: return;
353:
354: pa -= AV400_VME32_BASE;
355: return (vme_unmap(sc->sc_ext_a32, pa, (vaddr_t)handle, size));
356: }
357:
358: void
359: vme_unmap(struct extent *ext, vme_addr_t addr, vaddr_t vaddr, bus_size_t size)
360: {
361: vaddr_t va;
362: vsize_t len;
363:
364: va = trunc_page(vaddr);
365: len = round_page(vaddr + size) - va;
366:
367: pmap_kremove(va, len);
368: pmap_update(pmap_kernel());
369: uvm_km_free(kernel_map, va, len);
370:
371: if (ext != NULL)
372: extent_free(ext, atop(addr), atop(len),
373: EX_NOWAIT | EX_MALLOCOK);
374: }
375:
376: int
377: vme_subregion(bus_space_handle_t handle, bus_addr_t offset, bus_size_t size,
378: bus_space_handle_t *ret)
379: {
380: /* since vme_map produces linear mappings, this is safe */
381: *ret = handle + offset;
382: return (0);
383: }
384:
385: void *
386: vme_vaddr(bus_space_handle_t handle)
387: {
388: return ((void *)handle);
389: }
390:
391: /*
392: * Get a bus_space_tag for the requested address and data access modes.
393: *
394: * On aviion, we do not honour the dspace yet.
395: */
396: int
397: vmebus_get_bst(struct device *vsc, u_int aspace, u_int dspace,
398: bus_space_tag_t *bst)
399: {
400: struct aviion_bus_space_tag *tag;
401:
402: switch (dspace) {
403: case VME_D32:
404: case VME_D16:
405: case VME_D8:
406: break;
407: default:
408: return (EINVAL);
409: }
410:
411: switch (aspace) {
412: case VME_A32:
413: case VME_A24:
414: case VME_A16:
415: break;
416: default:
417: return (EINVAL);
418: }
419:
420: tag = (struct aviion_bus_space_tag *)malloc(sizeof *tag, M_DEVBUF,
421: M_NOWAIT);
422: if (tag == NULL)
423: return (ENOMEM);
424:
425: switch (aspace) {
426: default:
427: case VME_A32:
428: tag->bs_map = vme32_map;
429: tag->bs_unmap = vme32_unmap;
430: tag->bs_subregion = vme_subregion;
431: tag->bs_vaddr = vme_vaddr;
432: break;
433: case VME_A24:
434: tag->bs_map = vme24_map;
435: tag->bs_unmap = vme24_unmap;
436: tag->bs_subregion = vme_subregion;
437: tag->bs_vaddr = vme_vaddr;
438: break;
439: case VME_A16:
440: tag->bs_map = vme16_map;
441: tag->bs_unmap = vme16_unmap;
442: tag->bs_subregion = vme_subregion;
443: tag->bs_vaddr = vme_vaddr;
444: break;
445: }
446:
447: *bst = tag;
448: return (0);
449: }
450:
451: void
452: vmebus_release_bst(struct device *vsc, bus_space_tag_t b)
453: {
454: free((void *)b, M_DEVBUF);
455: }
456:
457: /*
458: * /dev/vme* access routines
459: */
460:
461: /* minor device number encoding */
462: #define AWIDTH_FIELD(minor) (minor & 0x0f)
463: #define AWIDTH(w) ((w) << 3)
464: #define DWIDTH_FIELD(minor) ((minor & 0xf0) >> 4)
465: #define DWIDTH(w) ((w) << 3)
466:
467: int
468: vmeopen(dev_t dev, int flags, int type, struct proc *p)
469: {
470: if (vme_cd.cd_ndevs == 0 || vme_cd.cd_devs[0] == NULL)
471: return (ENODEV);
472:
473: switch (AWIDTH_FIELD(minor(dev))) {
474: case VME_A32:
475: case VME_A24:
476: case VME_A16:
477: break;
478: default:
479: return (ENODEV);
480: }
481:
482: switch (DWIDTH_FIELD(minor(dev))) {
483: case VME_D32:
484: case VME_D16:
485: case VME_D8:
486: break;
487: default:
488: return (ENODEV);
489: }
490:
491: return (0);
492: }
493:
494: int
495: vmeclose(dev_t dev, int flags, int type, struct proc *p)
496: {
497: return (0);
498: }
499:
500: int
501: vmeread(dev_t dev, struct uio *uio, int flags)
502: {
503: return (EIO);
504: }
505:
506: int
507: vmewrite(dev_t dev, struct uio *uio, int flags)
508: {
509: return (EIO);
510: }
511:
512: int
513: vmeioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
514: {
515: switch (cmd) {
516: default:
517: return (ENOTTY);
518: }
519: }
520:
521: paddr_t
522: vmemmap(dev_t dev, off_t off, int prot)
523: {
524: int awidth;
525: paddr_t pa;
526:
527: if ((off & PAGE_MASK) != 0)
528: return (-1);
529:
530: awidth = AWIDTH_FIELD(minor(dev));
531:
532: /* check offset range */
533: if (off < 0 || off >= (1ULL << AWIDTH(awidth)))
534: return (-1);
535:
536: pa = (paddr_t)off;
537:
538: switch (awidth) {
539: case VME_A32:
540: if (!AV400_ISVMEA32(pa))
541: return (-1);
542: pa += AV400_VME32_BASE;
543: break;
544: case VME_A24:
545: if (!AV400_ISVMEA24(pa))
546: return (-1);
547: pa += AV400_VME24_BASE;
548: break;
549: case VME_A16:
550: if (!AV400_ISVMEA16(pa))
551: return (-1);
552: pa += AV400_VME16_BASE;
553: break;
554: }
555:
556: return (atop(pa));
557: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to vme.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / aviion / dev