release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/video/omap2/vram.c

   1 /*
   2  * VRAM manager for OMAP
   3  *
   4  * Copyright (C) 2009 Nokia Corporation
   5  * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  */
  20
  21 /*#define DEBUG*/
  22
  23 #include <linux/kernel.h>
  24 #include <linux/mm.h>
  25 #include <linux/list.h>
  26 #include <linux/slab.h>
  27 #include <linux/seq_file.h>
  28 #include <linux/memblock.h>
  29 #include <linux/completion.h>
  30 #include <linux/debugfs.h>
  31 #include <linux/jiffies.h>
  32 #include <linux/module.h>
  33
  34 #include <asm/setup.h>
  35
  36 #include <plat/sram.h>
  37 #include <plat/vram.h>
  38 #include <plat/dma.h>
  39
  40 #ifdef DEBUG
  41 #define DBG(format, ...) pr_debug("VRAM: " format, ## __VA_ARGS__)
  42 #else
  43 #define DBG(format, ...)
  44 #endif
  45
  46 #define OMAP2_SRAM_START                0x40200000
  47 /* Maximum size, in reality this is smaller if SRAM is partially locked. */
  48 #define OMAP2_SRAM_SIZE                 0xa0000         /* 640k */
  49
  50 /* postponed regions are used to temporarily store region information at boot
  51  * time when we cannot yet allocate the region list */
  52 #define MAX_POSTPONED_REGIONS 10
  53
  54 static bool vram_initialized;
  55 static int postponed_cnt;
  56 static struct {
  57         unsigned long paddr;
  58         size_t size;
  59 } postponed_regions[MAX_POSTPONED_REGIONS];
  60
  61 struct vram_alloc {
  62         struct list_head list;
  63         unsigned long paddr;
  64         unsigned pages;
  65 };
  66
  67 struct vram_region {
  68         struct list_head list;
  69         struct list_head alloc_list;
  70         unsigned long paddr;
  71         unsigned pages;
  72 };
  73
  74 static DEFINE_MUTEX(region_mutex);
  75 static LIST_HEAD(region_list);
  76
  77 static inline int region_mem_type(unsigned long paddr)
  78 {
  79         if (paddr >= OMAP2_SRAM_START &&
  80             paddr < OMAP2_SRAM_START + OMAP2_SRAM_SIZE)
  81                 return OMAP_VRAM_MEMTYPE_SRAM;
  82         else
  83                 return OMAP_VRAM_MEMTYPE_SDRAM;
  84 }
  85
  86 static struct vram_region *omap_vram_create_region(unsigned long paddr,
  87                 unsigned pages)
  88 {
  89         struct vram_region *rm;
  90
  91         rm = kzalloc(sizeof(*rm), GFP_KERNEL);
  92
  93         if (rm) {
  94                 INIT_LIST_HEAD(&rm->alloc_list);
  95                 rm->paddr = paddr;
  96                 rm->pages = pages;
  97         }
  98
  99         return rm;
 100 }
 101
 102
 103 static struct vram_alloc *omap_vram_create_allocation(struct vram_region *vr,
 104                 unsigned long paddr, unsigned pages)
 105 {
 106         struct vram_alloc *va;
 107         struct vram_alloc *new;
 108
 109         new = kzalloc(sizeof(*va), GFP_KERNEL);
 110
 111         if (!new)
 112                 return NULL;
 113
 114         new->paddr = paddr;
 115         new->pages = pages;
 116
 117         list_for_each_entry(va, &vr->alloc_list, list) {
 118                 if (va->paddr > new->paddr)
 119                         break;
 120         }
 121
 122         list_add_tail(&new->list, &va->list);
 123
 124         return new;
 125 }
 126
 127 static void omap_vram_free_allocation(struct vram_alloc *va)
 128 {
 129         list_del(&va->list);
 130         kfree(va);
 131 }
 132
 133 int omap_vram_add_region(unsigned long paddr, size_t size)
 134 {
 135         struct vram_region *rm;
 136         unsigned pages;
 137
 138         if (vram_initialized) {
 139                 DBG("adding region paddr %08lx size %d\n",
 140                                 paddr, size);
 141
 142                 size &= PAGE_MASK;
 143                 pages = size >> PAGE_SHIFT;
 144
 145                 rm = omap_vram_create_region(paddr, pages);
 146                 if (rm == NULL)
 147                         return -ENOMEM;
 148
 149                 list_add(&rm->list, &region_list);
 150         } else {
 151                 if (postponed_cnt == MAX_POSTPONED_REGIONS)
 152                         return -ENOMEM;
 153
 154                 postponed_regions[postponed_cnt].paddr = paddr;
 155                 postponed_regions[postponed_cnt].size = size;
 156
 157                 ++postponed_cnt;
 158         }
 159         return 0;
 160 }
 161
 162 int omap_vram_free(unsigned long paddr, size_t size)
 163 {
 164         struct vram_region *rm;
 165         struct vram_alloc *alloc;
 166         unsigned start, end;
 167
 168         DBG("free mem paddr %08lx size %d\n", paddr, size);
 169
 170         size = PAGE_ALIGN(size);
 171
 172         mutex_lock(&region_mutex);
 173
 174         list_for_each_entry(rm, &region_list, list) {
 175                 list_for_each_entry(alloc, &rm->alloc_list, list) {
 176                         start = alloc->paddr;
 177                         end = alloc->paddr + (alloc->pages >> PAGE_SHIFT);
 178
 179                         if (start >= paddr && end < paddr + size)
 180                                 goto found;
 181                 }
 182         }
 183
 184         mutex_unlock(&region_mutex);
 185         return -EINVAL;
 186
 187 found:
 188         omap_vram_free_allocation(alloc);
 189
 190         mutex_unlock(&region_mutex);
 191         return 0;
 192 }
 193 EXPORT_SYMBOL(omap_vram_free);
 194
 195 static int _omap_vram_reserve(unsigned long paddr, unsigned pages)
 196 {
 197         struct vram_region *rm;
 198         struct vram_alloc *alloc;
 199         size_t size;
 200
 201         size = pages << PAGE_SHIFT;
 202
 203         list_for_each_entry(rm, &region_list, list) {
 204                 unsigned long start, end;
 205
 206                 DBG("checking region %lx %d\n", rm->paddr, rm->pages);
 207
 208                 if (region_mem_type(rm->paddr) != region_mem_type(paddr))
 209                         continue;
 210
 211                 start = rm->paddr;
 212                 end = start + (rm->pages << PAGE_SHIFT) - 1;
 213                 if (start > paddr || end < paddr + size - 1)
 214                         continue;
 215
 216                 DBG("block ok, checking allocs\n");
 217
 218                 list_for_each_entry(alloc, &rm->alloc_list, list) {
 219                         end = alloc->paddr - 1;
 220
 221                         if (start <= paddr && end >= paddr + size - 1)
 222                                 goto found;
 223
 224                         start = alloc->paddr + (alloc->pages << PAGE_SHIFT);
 225                 }
 226
 227                 end = rm->paddr + (rm->pages << PAGE_SHIFT) - 1;
 228
 229                 if (!(start <= paddr && end >= paddr + size - 1))
 230                         continue;
 231 found:
 232                 DBG("found area start %lx, end %lx\n", start, end);
 233
 234                 if (omap_vram_create_allocation(rm, paddr, pages) == NULL)
 235                         return -ENOMEM;
 236
 237                 return 0;
 238         }
 239
 240         return -ENOMEM;
 241 }
 242
 243 int omap_vram_reserve(unsigned long paddr, size_t size)
 244 {
 245         unsigned pages;
 246         int r;
 247
 248         DBG("reserve mem paddr %08lx size %d\n", paddr, size);
 249
 250         size = PAGE_ALIGN(size);
 251         pages = size >> PAGE_SHIFT;
 252
 253         mutex_lock(&region_mutex);
 254
 255         r = _omap_vram_reserve(paddr, pages);
 256
 257         mutex_unlock(&region_mutex);
 258
 259         return r;
 260 }
 261 EXPORT_SYMBOL(omap_vram_reserve);
 262
 263 static void _omap_vram_dma_cb(int lch, u16 ch_status, void *data)
 264 {
 265         struct completion *compl = data;
 266         complete(compl);
 267 }
 268
 269 static int _omap_vram_clear(u32 paddr, unsigned pages)
 270 {
 271         struct completion compl;
 272         unsigned elem_count;
 273         unsigned frame_count;
 274         int r;
 275         int lch;
 276
 277         init_completion(&compl);
 278
 279         r = omap_request_dma(OMAP_DMA_NO_DEVICE, "VRAM DMA",
 280                         _omap_vram_dma_cb,
 281                         &compl, &lch);
 282         if (r) {
 283                 pr_err("VRAM: request_dma failed for memory clear\n");
 284                 return -EBUSY;
 285         }
 286
 287         elem_count = pages * PAGE_SIZE / 4;
 288         frame_count = 1;
 289
 290         omap_set_dma_transfer_params(lch, OMAP_DMA_DATA_TYPE_S32,
 291                         elem_count, frame_count,
 292                         OMAP_DMA_SYNC_ELEMENT,
 293                         0, 0);
 294
 295         omap_set_dma_dest_params(lch, 0, OMAP_DMA_AMODE_POST_INC,
 296                         paddr, 0, 0);
 297
 298         omap_set_dma_color_mode(lch, OMAP_DMA_CONSTANT_FILL, 0x000000);
 299
 300         omap_start_dma(lch);
 301
 302         if (wait_for_completion_timeout(&compl, msecs_to_jiffies(1000)) == 0) {
 303                 omap_stop_dma(lch);
 304                 pr_err("VRAM: dma timeout while clearing memory\n");
 305                 r = -EIO;
 306                 goto err;
 307         }
 308
 309         r = 0;
 310 err:
 311         omap_free_dma(lch);
 312
 313         return r;
 314 }
 315
 316 static int _omap_vram_alloc(int mtype, unsigned pages, unsigned long *paddr)
 317 {
 318         struct vram_region *rm;
 319         struct vram_alloc *alloc;
 320
 321         list_for_each_entry(rm, &region_list, list) {
 322                 unsigned long start, end;
 323
 324                 DBG("checking region %lx %d\n", rm->paddr, rm->pages);
 325
 326                 if (region_mem_type(rm->paddr) != mtype)
 327                         continue;
 328
 329                 start = rm->paddr;
 330
 331                 list_for_each_entry(alloc, &rm->alloc_list, list) {
 332                         end = alloc->paddr;
 333
 334                         if (end - start >= pages << PAGE_SHIFT)
 335                                 goto found;
 336
 337                         start = alloc->paddr + (alloc->pages << PAGE_SHIFT);
 338                 }
 339
 340                 end = rm->paddr + (rm->pages << PAGE_SHIFT);
 341 found:
 342                 if (end - start < pages << PAGE_SHIFT)
 343                         continue;
 344
 345                 DBG("found %lx, end %lx\n", start, end);
 346
 347                 alloc = omap_vram_create_allocation(rm, start, pages);
 348                 if (alloc == NULL)
 349                         return -ENOMEM;
 350
 351                 *paddr = start;
 352
 353                 _omap_vram_clear(start, pages);
 354
 355                 return 0;
 356         }
 357
 358         return -ENOMEM;
 359 }
 360
 361 int omap_vram_alloc(int mtype, size_t size, unsigned long *paddr)
 362 {
 363         unsigned pages;
 364         int r;
 365
 366         BUG_ON(mtype > OMAP_VRAM_MEMTYPE_MAX || !size);
 367
 368         DBG("alloc mem type %d size %d\n", mtype, size);
 369
 370         size = PAGE_ALIGN(size);
 371         pages = size >> PAGE_SHIFT;
 372
 373         mutex_lock(&region_mutex);
 374
 375         r = _omap_vram_alloc(mtype, pages, paddr);
 376
 377         mutex_unlock(&region_mutex);
 378
 379         return r;
 380 }
 381 EXPORT_SYMBOL(omap_vram_alloc);
 382
 383 void omap_vram_get_info(unsigned long *vram,
 384                 unsigned long *free_vram,
 385                 unsigned long *largest_free_block)
 386 {
 387         struct vram_region *vr;
 388         struct vram_alloc *va;
 389
 390         *vram = 0;
 391         *free_vram = 0;
 392         *largest_free_block = 0;
 393
 394         mutex_lock(&region_mutex);
 395
 396         list_for_each_entry(vr, &region_list, list) {
 397                 unsigned free;
 398                 unsigned long pa;
 399
 400                 pa = vr->paddr;
 401                 *vram += vr->pages << PAGE_SHIFT;
 402
 403                 list_for_each_entry(va, &vr->alloc_list, list) {
 404                         free = va->paddr - pa;
 405                         *free_vram += free;
 406                         if (free > *largest_free_block)
 407                                 *largest_free_block = free;
 408                         pa = va->paddr + (va->pages << PAGE_SHIFT);
 409                 }
 410
 411                 free = vr->paddr + (vr->pages << PAGE_SHIFT) - pa;
 412                 *free_vram += free;
 413                 if (free > *largest_free_block)
 414                         *largest_free_block = free;
 415         }
 416
 417         mutex_unlock(&region_mutex);
 418 }
 419 EXPORT_SYMBOL(omap_vram_get_info);
 420
 421 #if defined(CONFIG_DEBUG_FS)
 422 static int vram_debug_show(struct seq_file *s, void *unused)
 423 {
 424         struct vram_region *vr;
 425         struct vram_alloc *va;
 426         unsigned size;
 427
 428         mutex_lock(&region_mutex);
 429
 430         list_for_each_entry(vr, &region_list, list) {
 431                 size = vr->pages << PAGE_SHIFT;
 432                 seq_printf(s, "%08lx-%08lx (%d bytes)\n",
 433                                 vr->paddr, vr->paddr + size - 1,
 434                                 size);
 435
 436                 list_for_each_entry(va, &vr->alloc_list, list) {
 437                         size = va->pages << PAGE_SHIFT;
 438                         seq_printf(s, "    %08lx-%08lx (%d bytes)\n",
 439                                         va->paddr, va->paddr + size - 1,
 440                                         size);
 441                 }
 442         }
 443
 444         mutex_unlock(&region_mutex);
 445
 446         return 0;
 447 }
 448
 449 static int vram_debug_open(struct inode *inode, struct file *file)
 450 {
 451         return single_open(file, vram_debug_show, inode->i_private);
 452 }
 453
 454 static const struct file_operations vram_debug_fops = {
 455         .open           = vram_debug_open,
 456         .read           = seq_read,
 457         .llseek         = seq_lseek,
 458         .release        = single_release,
 459 };
 460
 461 static int __init omap_vram_create_debugfs(void)
 462 {
 463         struct dentry *d;
 464
 465         d = debugfs_create_file("vram", S_IRUGO, NULL,
 466                         NULL, &vram_debug_fops);
 467         if (IS_ERR(d))
 468                 return PTR_ERR(d);
 469
 470         return 0;
 471 }
 472 #endif
 473
 474 static __init int omap_vram_init(void)
 475 {
 476         int i;
 477
 478         vram_initialized = 1;
 479
 480         for (i = 0; i < postponed_cnt; i++)
 481                 omap_vram_add_region(postponed_regions[i].paddr,
 482                                 postponed_regions[i].size);
 483
 484 #ifdef CONFIG_DEBUG_FS
 485         if (omap_vram_create_debugfs())
 486                 pr_err("VRAM: Failed to create debugfs file\n");
 487 #endif
 488
 489         return 0;
 490 }
 491
 492 arch_initcall(omap_vram_init);
 493
 494 /* boottime vram alloc stuff */
 495
 496 /* set from board file */
 497 static u32 omap_vram_sram_start __initdata;
 498 static u32 omap_vram_sram_size __initdata;
 499
 500 /* set from board file */
 501 static u32 omap_vram_sdram_start __initdata;
 502 static u32 omap_vram_sdram_size __initdata;
 503
 504 /* set from kernel cmdline */
 505 static u32 omap_vram_def_sdram_size __initdata;
 506 static u32 omap_vram_def_sdram_start __initdata;
 507
 508 static int __init omap_vram_early_vram(char *p)
 509 {
 510         omap_vram_def_sdram_size = memparse(p, &p);
 511         if (*p == ',')
 512                 omap_vram_def_sdram_start = simple_strtoul(p + 1, &p, 16);
 513         return 0;
 514 }
 515 early_param("vram", omap_vram_early_vram);
 516
 517 /*
 518  * Called from map_io. We need to call to this early enough so that we
 519  * can reserve the fixed SDRAM regions before VM could get hold of them.
 520  */
 521 void __init omap_vram_reserve_sdram_memblock(void)
 522 {
 523         u32 paddr;
 524         u32 size = 0;
 525
 526         /* cmdline arg overrides the board file definition */
 527         if (omap_vram_def_sdram_size) {
 528                 size = omap_vram_def_sdram_size;
 529                 paddr = omap_vram_def_sdram_start;
 530         }
 531
 532         if (!size) {
 533                 size = omap_vram_sdram_size;
 534                 paddr = omap_vram_sdram_start;
 535         }
 536
 537 #ifdef CONFIG_OMAP2_VRAM_SIZE
 538         if (!size) {
 539                 size = CONFIG_OMAP2_VRAM_SIZE * 1024 * 1024;
 540                 paddr = 0;
 541         }
 542 #endif
 543
 544         if (!size)
 545                 return;
 546
 547         size = PAGE_ALIGN(size);
 548
 549         if (paddr) {
 550                 struct memblock_property res;
 551
 552                 res.base = paddr;
 553                 res.size = size;
 554                 if ((paddr & ~PAGE_MASK) || memblock_find(&res) ||
 555                     res.base != paddr || res.size != size) {
 556                         pr_err("Illegal SDRAM region for VRAM\n");
 557                         return;
 558                 }
 559
 560                 if (memblock_is_region_reserved(paddr, size)) {
 561                         pr_err("FB: failed to reserve VRAM - busy\n");
 562                         return;
 563                 }
 564
 565                 if (memblock_reserve(paddr, size) < 0) {
 566                         pr_err("FB: failed to reserve VRAM - no memory\n");
 567                         return;
 568                 }
 569         } else {
 570                 paddr = memblock_alloc_base(size, PAGE_SIZE, MEMBLOCK_REAL_LIMIT);
 571         }
 572
 573         omap_vram_add_region(paddr, size);
 574
 575         pr_info("Reserving %u bytes SDRAM for VRAM\n", size);
 576 }
 577
 578 /*
 579  * Called at sram init time, before anything is pushed to the SRAM stack.
 580  * Because of the stack scheme, we will allocate everything from the
 581  * start of the lowest address region to the end of SRAM. This will also
 582  * include padding for page alignment and possible holes between regions.
 583  *
 584  * As opposed to the SDRAM case, we'll also do any dynamic allocations at
 585  * this point, since the driver built as a module would have problem with
 586  * freeing / reallocating the regions.
 587  */
 588 unsigned long __init omap_vram_reserve_sram(unsigned long sram_pstart,
 589                                   unsigned long sram_vstart,
 590                                   unsigned long sram_size,
 591                                   unsigned long pstart_avail,
 592                                   unsigned long size_avail)
 593 {
 594         unsigned long                   pend_avail;
 595         unsigned long                   reserved;
 596         u32 paddr;
 597         u32 size;
 598
 599         paddr = omap_vram_sram_start;
 600         size = omap_vram_sram_size;
 601
 602         if (!size)
 603                 return 0;
 604
 605         reserved = 0;
 606         pend_avail = pstart_avail + size_avail;
 607
 608         if (!paddr) {
 609                 /* Dynamic allocation */
 610                 if ((size_avail & PAGE_MASK) < size) {
 611                         pr_err("Not enough SRAM for VRAM\n");
 612                         return 0;
 613                 }
 614                 size_avail = (size_avail - size) & PAGE_MASK;
 615                 paddr = pstart_avail + size_avail;
 616         }
 617
 618         if (paddr < sram_pstart ||
 619                         paddr + size > sram_pstart + sram_size) {
 620                 pr_err("Illegal SRAM region for VRAM\n");
 621                 return 0;
 622         }
 623
 624         /* Reserve everything above the start of the region. */
 625         if (pend_avail - paddr > reserved)
 626                 reserved = pend_avail - paddr;
 627         size_avail = pend_avail - reserved - pstart_avail;
 628
 629         omap_vram_add_region(paddr, size);
 630
 631         if (reserved)
 632                 pr_info("Reserving %lu bytes SRAM for VRAM\n", reserved);
 633
 634         return reserved;
 635 }
 636
 637 void __init omap_vram_set_sdram_vram(u32 size, u32 start)
 638 {
 639         omap_vram_sdram_start = start;
 640         omap_vram_sdram_size = size;
 641 }
 642
 643 void __init omap_vram_set_sram_vram(u32 size, u32 start)
 644 {
 645         omap_vram_sram_start = start;
 646         omap_vram_sram_size = size;
 647 }