src/add-ons/kernel/drivers/audio/ac97/es1370/util.c

   1 /*
   2  * BeOS Driver for Intel ICH AC'97 Link interface
   3  *
   4  * Copyright (c) 2002, Marcus Overhagen <marcus@overhagen.de>
   5  *
   6  * All rights reserved.
   7  * Redistribution and use in source and binary forms, with or without modification,
   8  * are permitted provided that the following conditions are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright notice,
  11  *   this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright notice,
  13  *   this list of conditions and the following disclaimer in the documentation
  14  *   and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  24  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  25  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  */
  28 #include <Errors.h>
  29 #include <KernelExport.h>
  30 #include <OS.h>
  31 #include <string.h>
  32
  33 //#define DEBUG 2
  34
  35 #include "debug.h"
  36 #include "util.h"
  37
  38 spinlock slock = B_SPINLOCK_INITIALIZER;
  39
  40 uint32 round_to_pagesize(uint32 size);
  41
  42
  43 cpu_status
  44 lock(void)
  45 {
  46         cpu_status status = disable_interrupts();
  47         acquire_spinlock(&slock);
  48         return status;
  49 }
  50
  51
  52 void
  53 unlock(cpu_status status)
  54 {
  55         release_spinlock(&slock);
  56         restore_interrupts(status);
  57 }
  58
  59
  60 uint32
  61 round_to_pagesize(uint32 size)
  62 {
  63         return (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
  64 }
  65
  66
  67 area_id
  68 alloc_mem(void **phy, void **log, size_t size, const char *name)
  69 {
  70 // TODO: phy should be phys_addr_t*!
  71         physical_entry pe;
  72         void * logadr;
  73         area_id areaid;
  74         status_t rv;
  75
  76         LOG(("allocating %d bytes for %s\n",size,name));
  77
  78         size = round_to_pagesize(size);
  79         areaid = create_area(name, &logadr, B_ANY_KERNEL_ADDRESS, size,
  80                 B_32_BIT_CONTIGUOUS, B_READ_AREA | B_WRITE_AREA);
  81                 // TODO: The rest of the code doesn't deal correctly with physical
  82                 // addresses > 4 GB, so we have to force 32 bit addresses here.
  83         if (areaid < B_OK) {
  84                 PRINT(("couldn't allocate area %s\n",name));
  85                 return B_ERROR;
  86         }
  87         rv = get_memory_map(logadr, size, &pe, 1);
  88         if (rv < B_OK) {
  89                 delete_area(areaid);
  90                 PRINT(("couldn't map %s\n", name));
  91                 return B_ERROR;
  92         }
  93         memset(logadr, 0, size);
  94         if (log)
  95                 *log = logadr;
  96         if (phy)
  97                 *phy = (void*)(addr_t)pe.address;
  98         LOG(("area = %d, size = %d, log = %#08X, phy = %#08X\n", areaid, size,
  99                 logadr, pe.address));
 100         return areaid;
 101 }
 102
 103
 104 /* This is not the most advanced method to map physical memory for io access.
 105  * Perhaps using B_ANY_KERNEL_ADDRESS instead of B_ANY_KERNEL_BLOCK_ADDRESS
 106  * makes the whole offset calculation and relocation obsolete. But the code
 107  * below does work, and I can't test if using B_ANY_KERNEL_ADDRESS also works.
 108  */
 109 area_id
 110 map_mem(void **log, void *phy, size_t size, const char *name)
 111 {
 112         uint32 offset;
 113         void *phyadr;
 114         void *mapadr;
 115         area_id area;
 116
 117         LOG(("mapping physical address %p with %#x bytes for %s\n",phy,size,name));
 118
 119         offset = (uint32)phy & (B_PAGE_SIZE - 1);
 120         phyadr = phy - offset;
 121         size = round_to_pagesize(size + offset);
 122         area = map_physical_memory(name, (addr_t)phyadr, size,
 123                 B_ANY_KERNEL_BLOCK_ADDRESS, B_READ_AREA | B_WRITE_AREA, &mapadr);
 124         *log = mapadr + offset;
 125
 126         LOG(("physical = %p, logical = %p, offset = %#x, phyadr = %p, mapadr = %p, size = %#x, area = %#x\n",
 127                 phy, *log, offset, phyadr, mapadr, size, area));
 128
 129         return area;
 130 }