[BACK]Return to xen_bus_dma.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / arch / xen / x86

Annotation of src/sys/arch/xen/x86/xen_bus_dma.c, Revision 1.1

1.1     ! bouyer      1: /*     $NetBSD: bus_dma.c,v 1.21 2005/04/16 07:53:35 yamt Exp $        */
        !             2: /*     NetBSD bus_dma.c,v 1.21 2005/04/16 07:53:35 yamt Exp */
        !             3:
        !             4: /*-
        !             5:  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
        !             6:  * All rights reserved.
        !             7:  *
        !             8:  * This code is derived from software contributed to The NetBSD Foundation
        !             9:  * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
        !            10:  * Simulation Facility, NASA Ames Research Center.
        !            11:  *
        !            12:  * Redistribution and use in source and binary forms, with or without
        !            13:  * modification, are permitted provided that the following conditions
        !            14:  * are met:
        !            15:  * 1. Redistributions of source code must retain the above copyright
        !            16:  *    notice, this list of conditions and the following disclaimer.
        !            17:  * 2. Redistributions in binary form must reproduce the above copyright
        !            18:  *    notice, this list of conditions and the following disclaimer in the
        !            19:  *    documentation and/or other materials provided with the distribution.
        !            20:  * 3. All advertising materials mentioning features or use of this software
        !            21:  *    must display the following acknowledgement:
        !            22:  *     This product includes software developed by the NetBSD
        !            23:  *     Foundation, Inc. and its contributors.
        !            24:  * 4. Neither the name of The NetBSD Foundation nor the names of its
        !            25:  *    contributors may be used to endorse or promote products derived
        !            26:  *    from this software without specific prior written permission.
        !            27:  *
        !            28:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
        !            29:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
        !            30:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
        !            31:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
        !            32:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
        !            33:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
        !            34:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
        !            35:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
        !            36:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
        !            37:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
        !            38:  * POSSIBILITY OF SUCH DAMAGE.
        !            39:  */
        !            40:
        !            41: #include <sys/cdefs.h>
        !            42: __KERNEL_RCSID(0, "$NetBSD: bus_dma.c,v 1.21 2005/04/16 07:53:35 yamt Exp $");
        !            43:
        !            44: #include <sys/param.h>
        !            45: #include <sys/systm.h>
        !            46: #include <sys/kernel.h>
        !            47: #include <sys/malloc.h>
        !            48: #include <sys/mbuf.h>
        !            49: #include <sys/proc.h>
        !            50:
        !            51: #include <machine/bus.h>
        !            52: #include <machine/bus_private.h>
        !            53:
        !            54: #include <uvm/uvm_extern.h>
        !            55:
        !            56: extern paddr_t avail_end;
        !            57:
        !            58: /* Pure 2^n version of get_order */
        !            59: static __inline__ int get_order(unsigned long size)
        !            60: {
        !            61:        int order = -1;
        !            62:        size = (size - 1) >> (PAGE_SHIFT - 1);
        !            63:        do {
        !            64:                size >>= 1;
        !            65:                order++;
        !            66:        } while (size);
        !            67:        return order;
        !            68: }
        !            69:
        !            70: static int
        !            71: _xen_alloc_contig(bus_size_t size, bus_size_t alignment, bus_size_t boundary,
        !            72:     struct pglist *mlistp, int flags)
        !            73: {
        !            74:        int order, i;
        !            75:        unsigned long npagesreq, npages, mfn;
        !            76:        bus_addr_t pa;
        !            77:        struct vm_page *pg, *pgnext;
        !            78:        struct pglist freelist;
        !            79:        int s, error;
        !            80:
        !            81:        TAILQ_INIT(&freelist);
        !            82:
        !            83:        /*
        !            84:         * When requesting a contigous memory region, the hypervisor will
        !            85:         * return a memory range aligned on size. This will automagically
        !            86:         * handle "boundary", but the only way to enforce alignment
        !            87:         * is to request a memory region of size max(alignment, size).
        !            88:         */
        !            89:        order = max(get_order(size), get_order(alignment));
        !            90:        npages = (1 << order);
        !            91:        npagesreq = (size >> PAGE_SHIFT);
        !            92:        KASSERT(npages >= npagesreq);
        !            93:
        !            94:        /* get npages from UWM, and give them back to the hypervisor */
        !            95:        error = uvm_pglistalloc(npages << PAGE_SHIFT, 0, avail_end, 0, 0,
        !            96:            mlistp, npages, (flags & BUS_DMA_NOWAIT) == 0);
        !            97:        if (error)
        !            98:                return (error);
        !            99:
        !           100:        for (pg = mlistp->tqh_first; pg != NULL; pg = pg->pageq.tqe_next) {
        !           101:                pa = VM_PAGE_TO_PHYS(pg);
        !           102:                mfn = xpmap_ptom(pa) >> PAGE_SHIFT;
        !           103:                xpmap_phys_to_machine_mapping[
        !           104:                    (pa - XPMAP_OFFSET) >> PAGE_SHIFT] = INVALID_P2M_ENTRY;
        !           105:                if (HYPERVISOR_dom_mem_op(MEMOP_decrease_reservation,
        !           106:                    &mfn, 1, 0) != 1) {
        !           107:                        printf("xen_alloc_contig: MEMOP_decrease_reservation "
        !           108:                            "failed!\n");
        !           109:                        return ENOMEM;
        !           110:                }
        !           111:        }
        !           112:        /* Get the new contiguous memory extent */
        !           113:        if (HYPERVISOR_dom_mem_op(MEMOP_increase_reservation,
        !           114:            &mfn, 1, order) != 1) {
        !           115:                printf("xen_alloc_contig: MEMOP_increase_reservation "
        !           116:                    "failed!\n");
        !           117:                return ENOMEM;
        !           118:        }
        !           119:        s = splvm();
        !           120:        /* Map the new extent in place of the old pages */
        !           121:        for (pg = mlistp->tqh_first, i = 0; pg != NULL; pg = pgnext, i++) {
        !           122:                pgnext = pg->pageq.tqe_next;
        !           123:                pa = VM_PAGE_TO_PHYS(pg);
        !           124:                xpmap_phys_to_machine_mapping[
        !           125:                    (pa - XPMAP_OFFSET) >> PAGE_SHIFT] = mfn+i;
        !           126:                xpq_queue_machphys_update((mfn+i) << PAGE_SHIFT, pa);
        !           127:                /* while here, give extra pages back to UVM */
        !           128:                if (i >= npagesreq) {
        !           129:                        TAILQ_REMOVE(mlistp, pg, pageq);
        !           130:                        uvm_pagefree(pg);
        !           131:                }
        !           132:
        !           133:        }
        !           134:        /* Flush updates through and flush the TLB */
        !           135:        xpq_queue_tlb_flush();
        !           136:        xpq_flush_queue();
        !           137:        splx(s);
        !           138:        return 0;
        !           139: }
        !           140:
        !           141:
        !           142: /*
        !           143:  * Allocate physical memory from the given physical address range.
        !           144:  * Called by DMA-safe memory allocation methods.
        !           145:  * We need our own version to deal with physical vs machine addresses.
        !           146:  */
        !           147: int
        !           148: _xen_bus_dmamem_alloc_range(bus_dma_tag_t t, bus_size_t size,
        !           149:     bus_size_t alignment, bus_size_t boundary, bus_dma_segment_t *segs,
        !           150:     int nsegs, int *rsegs, int flags, bus_addr_t low, bus_addr_t high)
        !           151: {
        !           152:        paddr_t curaddr, lastaddr;
        !           153:        bus_addr_t bus_curaddr, bus_lastaddr;
        !           154:        struct vm_page *m;
        !           155:        struct pglist mlist;
        !           156:        int curseg, error;
        !           157:        int doingrealloc = 0;
        !           158:
        !           159:        /* Always round the size. */
        !           160:        size = round_page(size);
        !           161:
        !           162:        /*
        !           163:         * Allocate pages from the VM system.
        !           164:         */
        !           165:        error = uvm_pglistalloc(size, 0, avail_end, alignment, boundary,
        !           166:            &mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0);
        !           167:        if (error)
        !           168:                return (error);
        !           169: again:
        !           170:
        !           171:        /*
        !           172:         * Compute the location, size, and number of segments actually
        !           173:         * returned by the VM code.
        !           174:         */
        !           175:        m = mlist.tqh_first;
        !           176:        curseg = 0;
        !           177:        lastaddr = segs[curseg].ds_addr = VM_PAGE_TO_PHYS(m);
        !           178:        segs[curseg].ds_len = PAGE_SIZE;
        !           179:        m = m->pageq.tqe_next;
        !           180:
        !           181:        for (; m != NULL; m = m->pageq.tqe_next) {
        !           182:                curaddr = VM_PAGE_TO_PHYS(m);
        !           183:                bus_curaddr = _BUS_PHYS_TO_BUS(curaddr);
        !           184:                bus_lastaddr = _BUS_PHYS_TO_BUS(lastaddr);
        !           185:                if ((bus_lastaddr < low || bus_lastaddr >= high) ||
        !           186:                    (bus_curaddr < low || bus_curaddr >= high)) {
        !           187:                        /*
        !           188:                         * If machine addresses are outside the allowed
        !           189:                         * range we have to bail. Xen2 doesn't offer an
        !           190:                         * interface to get memory in a specific address
        !           191:                         * range.
        !           192:                         */
        !           193:                        printf("_xen_bus_dmamem_alloc_range: no way to "
        !           194:                            "enforce address range\n");
        !           195:                        return EINVAL;
        !           196:                }
        !           197:                if (bus_curaddr == (bus_lastaddr + PAGE_SIZE))
        !           198:                        segs[curseg].ds_len += PAGE_SIZE;
        !           199:                else {
        !           200:                        curseg++;
        !           201:                        if (curseg >= nsegs) {
        !           202:                                if (doingrealloc == 1)
        !           203:                                        panic("_xen_bus_dmamem_alloc_range: "
        !           204:                                           "xen_alloc_contig returned "
        !           205:                                           "too much segments");
        !           206:                                doingrealloc = 1;
        !           207:                                /*
        !           208:                                 * Too much segments. Free this memory and
        !           209:                                 * get a contigous segment from the hypervisor.
        !           210:                                 */
        !           211:                                uvm_pglistfree(&mlist);
        !           212:                                for (curseg = 0; curseg < nsegs; curseg++) {
        !           213:                                        segs[curseg].ds_addr = 0;
        !           214:                                        segs[curseg].ds_len = 0;
        !           215:                                }
        !           216:                                error = _xen_alloc_contig(size, alignment,
        !           217:                                    boundary, &mlist, flags);
        !           218:                                if (error)
        !           219:                                        return error;
        !           220:                                goto again;
        !           221:                        }
        !           222:                        segs[curseg].ds_addr = curaddr;
        !           223:                        segs[curseg].ds_len = PAGE_SIZE;
        !           224:                }
        !           225:                lastaddr = curaddr;
        !           226:        }
        !           227:
        !           228:        *rsegs = curseg + 1;
        !           229:
        !           230:        return (0);
        !           231: }

CVSweb <webmaster@jp.NetBSD.org>