src/add-ons/kernel/drivers/network/dp83815/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 <OS.h>
  30 #include <string.h>
  31
  32 #include "util.h"
  33
  34 spinlock slock = 0;
  35
  36 uint32 round_to_pagesize(uint32 size);
  37
  38
  39 cpu_status
  40 lock(void)
  41 {
  42         cpu_status status = disable_interrupts();
  43         acquire_spinlock(&slock);
  44         return status;
  45 }
  46
  47
  48 void
  49 unlock(cpu_status status)
  50 {
  51         release_spinlock(&slock);
  52         restore_interrupts(status);
  53 }
  54
  55
  56 uint32
  57 round_to_pagesize(uint32 size)
  58 {
  59         return (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
  60 }
  61
  62
  63 area_id
  64 alloc_mem(void **log, void **phy, size_t size, const char *name)
  65 {
  66 // TODO: phy should be phys_addr_t*!
  67         physical_entry pe;
  68         void * logadr;
  69         area_id areaid;
  70         status_t rv;
  71
  72         dprintf("dp83815: allocating %ld bytes for %s\n",size,name);
  73
  74         size = round_to_pagesize(size);
  75         areaid = create_area(name, &logadr, B_ANY_KERNEL_ADDRESS, size,
  76                 B_32_BIT_CONTIGUOUS, B_READ_AREA | B_WRITE_AREA);
  77                 // TODO: The rest of the code doesn't deal correctly with physical
  78                 // addresses > 4 GB, so we have to force 32 bit addresses here.
  79         if (areaid < B_OK) {
  80                 dprintf("couldn't allocate area %s\n",name);
  81                 return B_ERROR;
  82         }
  83         rv = get_memory_map(logadr,size,&pe,1);
  84         if (rv < B_OK) {
  85                 delete_area(areaid);
  86                 dprintf("couldn't map %s\n",name);
  87                 return B_ERROR;
  88         }
  89         memset(logadr,0,size);
  90         if (log)
  91                 *log = logadr;
  92         if (phy)
  93                 *phy = (void*)(addr_t)pe.address;
  94         dprintf("area = %ld, size = %ld, log = %p, phy = %p\n",areaid,size,logadr,pe.address);
  95         return areaid;
  96 }
  97
  98
  99 /* This is not the most advanced method to map physical memory for io access.
 100  * Perhaps using B_ANY_KERNEL_ADDRESS instead of B_ANY_KERNEL_BLOCK_ADDRESS
 101  * makes the whole offset calculation and relocation obsolete. But the code
 102  * below does work, and I can't test if using B_ANY_KERNEL_ADDRESS also works.
 103  */
 104 area_id
 105 map_mem(void **log, void *phy, size_t size, const char *name)
 106 {
 107         uint32 offset;
 108         void *phyadr;
 109         void *mapadr;
 110         area_id area;
 111
 112         dprintf("mapping physical address %p with %#lx bytes for %s\n",phy,size,name);
 113
 114         offset = (uint32)phy & (B_PAGE_SIZE - 1);
 115         phyadr = (void *) ( (uint32)phy - offset );
 116         size = round_to_pagesize(size + offset);
 117         area = map_physical_memory(name, (addr_t)phyadr, size,
 118                 B_ANY_KERNEL_BLOCK_ADDRESS, B_READ_AREA | B_WRITE_AREA, &mapadr);
 119         *log = (void *) ( (uint32)mapadr + offset );
 120
 121         dprintf("physical = %p, logical = %p, offset = %#lx, phyadr = %p, mapadr = %p, size = %#lx, area = %#lx\n",
 122                 phy, *log, offset, phyadr, mapadr, size, area);
 123
 124         return area;
 125 }