drm_memory.c revision 1.10
1/*- 2 *Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. 3 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the next 14 * paragraph) shall be included in all copies or substantial portions of the 15 * Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 * 25 * Authors: 26 * Rickard E. (Rik) Faith <faith@valinux.com> 27 * Gareth Hughes <gareth@valinux.com> 28 * 29 */ 30 31/** @file drm_memory.c 32 * Wrappers for kernel memory allocation routines, and MTRR management support. 33 * 34 * This file previously implemented a memory consumption tracking system using 35 * the "area" argument for various different types of allocations, but that 36 * has been stripped out for now. 37 */ 38 39#include "drmP.h" 40 41void 42drm_mem_init(void) 43{ 44} 45 46void 47drm_mem_uninit(void) 48{ 49} 50 51void* 52drm_alloc(size_t size, int area) 53{ 54 return malloc(size, M_DRM, M_NOWAIT); 55} 56 57void * 58drm_calloc(size_t nmemb, size_t size, int area) 59{ 60 if (nmemb == 0 || SIZE_MAX / nmemb < size) 61 return (NULL); 62 else 63 return malloc(size * nmemb, M_DRM, M_NOWAIT | M_ZERO); 64} 65 66void * 67drm_realloc(void *oldpt, size_t oldsize, size_t size, int area) 68{ 69 void *pt; 70 71 pt = malloc(size, M_DRM, M_NOWAIT); 72 if (pt == NULL) 73 return NULL; 74 if (oldpt && oldsize) { 75 memcpy(pt, oldpt, oldsize); 76 free(oldpt, M_DRM); 77 } 78 return pt; 79} 80 81void 82drm_free(void *pt, size_t size, int area) 83{ 84 if (pt != NULL) 85 free(pt, M_DRM); 86} 87 88void * 89drm_ioremap(struct drm_device *dev, drm_local_map_t *map) 90{ 91 struct vga_pci_bar *bar = NULL; 92 int i; 93 94 DRM_DEBUG("offset: 0x%x size: 0x%x type: %d\n", map->offset, map->size, 95 map->type); 96 97 if (map->type == _DRM_AGP || map->type == _DRM_FRAME_BUFFER) { 98 /* 99 * there can be multiple agp maps in the same BAR, agp also 100 * quite possibly isn't the same as the vga device, just try 101 * to map it. 102 */ 103 DRM_DEBUG("AGP map\n"); 104 map->bst = dev->pa.pa_memt; 105 if (bus_space_map(map->bst, map->offset, 106 map->size, BUS_SPACE_MAP_LINEAR, &map->bsh)) { 107 DRM_ERROR("ioremap fail\n"); 108 return (NULL); 109 } 110 goto done; 111 } else { 112 for (i = 0; i < DRM_MAX_PCI_RESOURCE; ++i) { 113 bar = vga_pci_bar_info(dev->vga_softc, i); 114 if (bar == NULL) 115 continue; 116 117 if (bar->base == map->offset) { 118 DRM_DEBUG("REGISTERS map\n"); 119 map->bsr = vga_pci_bar_map(dev->vga_softc, 120 bar->addr, map->size, BUS_SPACE_MAP_LINEAR); 121 if (map->bsr == NULL) { 122 DRM_ERROR("ioremap fail\n"); 123 return (NULL); 124 } 125 map->bst = map->bsr->bst; 126 map->bsh = map->bsr->bsh; 127 goto done; 128 } 129 } 130 } 131done: 132 /* handles are still supposed to be kernel virtual addresses */ 133 return bus_space_vaddr(map->bst, map->bsh); 134} 135 136void 137drm_ioremapfree(drm_local_map_t *map) 138{ 139 if (map != NULL && map->bsr != NULL) 140 vga_pci_bar_unmap(map->bsr); 141 else 142 bus_space_unmap(map->bst, map->bsh, map->size); 143} 144 145int 146drm_mtrr_add(unsigned long offset, size_t size, int flags) 147{ 148#ifndef DRM_NO_MTRR 149 int act; 150 struct mem_range_desc mrdesc; 151 152 mrdesc.mr_base = offset; 153 mrdesc.mr_len = size; 154 mrdesc.mr_flags = flags; 155 act = MEMRANGE_SET_UPDATE; 156 strlcpy(mrdesc.mr_owner, "drm", sizeof(mrdesc.mr_owner)); 157 return mem_range_attr_set(&mrdesc, &act); 158#else 159 return 0; 160#endif 161} 162 163int 164drm_mtrr_del(int __unused handle, unsigned long offset, size_t size, int flags) 165{ 166#ifndef DRM_NO_MTRR 167 int act; 168 struct mem_range_desc mrdesc; 169 170 mrdesc.mr_base = offset; 171 mrdesc.mr_len = size; 172 mrdesc.mr_flags = flags; 173 act = MEMRANGE_SET_REMOVE; 174 strlcpy(mrdesc.mr_owner, "drm", sizeof(mrdesc.mr_owner)); 175 return mem_range_attr_set(&mrdesc, &act); 176#else 177 return 0; 178#endif 179} 180 181u_int8_t 182drm_read8(drm_local_map_t *map, unsigned long offset) 183{ 184 u_int8_t *ptr; 185 186 switch (map->type) { 187 case _DRM_SCATTER_GATHER: 188 ptr = map->handle + offset; 189 return (*ptr); 190 191 default: 192 return (bus_space_read_1(map->bst, map->bsh, offset)); 193 } 194} 195 196u_int16_t 197drm_read16(drm_local_map_t *map, unsigned long offset) 198{ 199 u_int16_t *ptr; 200 switch (map->type) { 201 case _DRM_SCATTER_GATHER: 202 ptr = map->handle + offset; 203 return (*ptr); 204 default: 205 return (bus_space_read_2(map->bst, map->bsh, offset)); 206 } 207} 208 209u_int32_t 210drm_read32(drm_local_map_t *map, unsigned long offset) 211{ 212 u_int32_t *ptr; 213 switch (map->type) { 214 case _DRM_SCATTER_GATHER: 215 ptr = map->handle + offset; 216 return (*ptr); 217 default: 218 return (bus_space_read_4(map->bst, map->bsh, offset)); 219 } 220} 221 222void 223drm_write8(drm_local_map_t *map, unsigned long offset, u_int8_t val) 224{ 225 u_int8_t *ptr; 226 switch (map->type) { 227 case _DRM_SCATTER_GATHER: 228 ptr = map->handle + offset; 229 *ptr = val; 230 break; 231 default: 232 bus_space_write_1(map->bst, map->bsh, offset, val); 233 } 234} 235 236void 237drm_write16(drm_local_map_t *map, unsigned long offset, u_int16_t val) 238{ 239 u_int16_t *ptr; 240 switch (map->type) { 241 case _DRM_SCATTER_GATHER: 242 ptr = map->handle + offset; 243 *ptr = val; 244 break; 245 default: 246 bus_space_write_2(map->bst, map->bsh, offset, val); 247 } 248} 249 250void 251drm_write32(drm_local_map_t *map, unsigned long offset, u_int32_t val) 252{ 253 u_int32_t *ptr; 254 switch (map->type) { 255 case _DRM_SCATTER_GATHER: 256 ptr = map->handle + offset; 257 *ptr = val; 258 break; 259 default: 260 bus_space_write_4(map->bst, map->bsh, offset, val); 261 } 262} 263