开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
drm_vm.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

drm_vm.h：源码内容
  1. /* drm_vm.h -- Memory mapping for DRM -*- linux-c -*-
  2.  * Created: Mon Jan  4 08:58:31 1999 by faith@valinux.com
  3.  *
  4.  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  5.  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  6.  * All Rights Reserved.
  7.  *
  8.  * Permission is hereby granted, free of charge, to any person obtaining a
  9.  * copy of this software and associated documentation files (the "Software"),
  10.  * to deal in the Software without restriction, including without limitation
  11.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12.  * and/or sell copies of the Software, and to permit persons to whom the
  13.  * Software is furnished to do so, subject to the following conditions:
  14.  *
  15.  * The above copyright notice and this permission notice (including the next
  16.  * paragraph) shall be included in all copies or substantial portions of the
  17.  * Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25.  * OTHER DEALINGS IN THE SOFTWARE.
  26.  *
  27.  * Authors:
  28.  *    Rickard E. (Rik) Faith <faith@valinux.com>
  29.  *    Gareth Hughes <gareth@valinux.com>
  30.  */
  32. #define __NO_VERSION__
  33. #include "drmP.h"
  35. struct vm_operations_struct   DRM(vm_ops) = {
  36. nopage:  DRM(vm_nopage),
  37. open:  DRM(vm_open),
  38. close:  DRM(vm_close),
  39. };
  41. struct vm_operations_struct   DRM(vm_shm_ops) = {
  42. nopage:  DRM(vm_shm_nopage),
  43. open:  DRM(vm_open),
  44. close:  DRM(vm_shm_close),
  45. };
  47. struct vm_operations_struct   DRM(vm_dma_ops) = {
  48. nopage:  DRM(vm_dma_nopage),
  49. open:  DRM(vm_open),
  50. close:  DRM(vm_close),
  51. };
  53. struct vm_operations_struct   DRM(vm_sg_ops) = {
  54. nopage:  DRM(vm_sg_nopage),
  55. open:    DRM(vm_open),
  56. close:   DRM(vm_close),
  57. };
  59. #if LINUX_VERSION_CODE < 0x020317
  60. unsigned long DRM(vm_nopage)(struct vm_area_struct *vma,
  61.      unsigned long address,
  62.      int unused)
  63. #else
  64. /* Return type changed in 2.3.23 */
  65. struct page *DRM(vm_nopage)(struct vm_area_struct *vma,
  66.     unsigned long address,
  67.     int unused)
  68. #endif
  69. {
  70. #if __REALLY_HAVE_AGP
  71. drm_file_t *priv  = vma->vm_file->private_data;
  72. drm_device_t *dev = priv->dev;
  73. drm_map_t *map    = NULL;
  74. drm_map_list_t  *r_list;
  75. struct list_head *list;
  77. /*
  78.          * Find the right map
  79.          */
  81. if(!dev->agp->cant_use_aperture) goto vm_nopage_error;
  83. list_for_each(list, &dev->maplist->head) {
  84. r_list = (drm_map_list_t *)list;
  85. map = r_list->map;
  86. if (!map) continue;
  87. if (map->offset == VM_OFFSET(vma)) break;
  88. }
  90. if (map && map->type == _DRM_AGP) {
  91. unsigned long offset = address - vma->vm_start;
  92. unsigned long baddr = VM_OFFSET(vma) + offset;
  93. struct drm_agp_mem *agpmem;
  94. struct page *page;
  96. #if __alpha__
  97. /*
  98.                  * Adjust to a bus-relative address
  99.                  */
  100. baddr -= dev->hose->mem_space->start;
  101. #endif
  103. /*
  104.                  * It's AGP memory - find the real physical page to map
  105.                  */
  106. for(agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next) {
  107. if (agpmem->bound <= baddr &&
  108.     agpmem->bound + agpmem->pages * PAGE_SIZE > baddr) 
  109. break;
  110. }
  112. if (!agpmem) goto vm_nopage_error;
  114. /*
  115.                  * Get the page, inc the use count, and return it
  116.                  */
  117. offset = (baddr - agpmem->bound) >> PAGE_SHIFT;
  118. agpmem->memory->memory[offset] &= dev->agp->page_mask;
  119. page = virt_to_page(__va(agpmem->memory->memory[offset]));
  120. get_page(page);
  122. DRM_DEBUG("baddr = 0x%lx page = 0x%p, offset = 0x%lxn",
  123.   baddr, __va(agpmem->memory->memory[offset]), offset);
  125. #if LINUX_VERSION_CODE < 0x020317
  126. return page_address(page);
  127. #else
  128. return page;
  129. #endif
  130.         }
  131. vm_nopage_error:
  132. #endif /* __REALLY_HAVE_AGP */
  134. return NOPAGE_SIGBUS; /* Disallow mremap */
  135. }
  137. #if LINUX_VERSION_CODE < 0x020317
  138. unsigned long DRM(vm_shm_nopage)(struct vm_area_struct *vma,
  139.  unsigned long address,
  140.  int unused)
  141. #else
  142. /* Return type changed in 2.3.23 */
  143. struct page *DRM(vm_shm_nopage)(struct vm_area_struct *vma,
  144. unsigned long address,
  145. int unused)
  146. #endif
  147. {
  148. #if LINUX_VERSION_CODE >= 0x020300
  149. drm_map_t  *map  = (drm_map_t *)vma->vm_private_data;
  150. #else
  151. drm_map_t  *map  = (drm_map_t *)vma->vm_pte;
  152. #endif
  153. unsigned long  offset;
  154. unsigned long  i;
  155. pgd_t  *pgd;
  156. pmd_t  *pmd;
  157. pte_t  *pte;
  158. struct page  *page;
  160. if (address > vma->vm_end) return NOPAGE_SIGBUS; /* Disallow mremap */
  161. if (!map)        return NOPAGE_OOM;  /* Nothing allocated */
  163. offset  = address - vma->vm_start;
  164. i = (unsigned long)map->handle + offset;
  165. /* We have to walk page tables here because we need large SAREA's, and
  166.  * they need to be virtually contiguous in kernel space.
  167.  */
  168. pgd = pgd_offset_k( i );
  169. if( !pgd_present( *pgd ) ) return NOPAGE_OOM;
  170. pmd = pmd_offset( pgd, i );
  171. if( !pmd_present( *pmd ) ) return NOPAGE_OOM;
  172. pte = pte_offset( pmd, i );
  173. if( !pte_present( *pte ) ) return NOPAGE_OOM;
  175. page = pte_page(*pte);
  176. get_page(page);
  178. DRM_DEBUG("shm_nopage 0x%lxn", address);
  179. #if LINUX_VERSION_CODE < 0x020317
  180. return page_address(page);
  181. #else
  182. return page;
  183. #endif
  184. }
  186. /* Special close routine which deletes map information if we are the last
  187.  * person to close a mapping and its not in the global maplist.
  188.  */
  190. void DRM(vm_shm_close)(struct vm_area_struct *vma)
  191. {
  192. drm_file_t *priv = vma->vm_file->private_data;
  193. drm_device_t *dev = priv->dev;
  194. drm_vma_entry_t *pt, *prev, *next;
  195. drm_map_t *map;
  196. drm_map_list_t *r_list;
  197. struct list_head *list;
  198. int found_maps = 0;
  200. DRM_DEBUG("0x%08lx,0x%08lxn",
  201.   vma->vm_start, vma->vm_end - vma->vm_start);
  202. #if LINUX_VERSION_CODE < 0x020333
  203. MOD_DEC_USE_COUNT; /* Needed before Linux 2.3.51 */
  204. #endif
  205. atomic_dec(&dev->vma_count);
  207. #if LINUX_VERSION_CODE >= 0x020300
  208. map = vma->vm_private_data;
  209. #else
  210. map = vma->vm_pte;
  211. #endif
  213. down(&dev->struct_sem);
  214. for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
  215. next = pt->next;
  216. #if LINUX_VERSION_CODE >= 0x020300
  217. if (pt->vma->vm_private_data == map) found_maps++;
  218. #else
  219. if (pt->vma->vm_pte == map) found_maps++;
  220. #endif
  221. if (pt->vma == vma) {
  222. if (prev) {
  223. prev->next = pt->next;
  224. } else {
  225. dev->vmalist = pt->next;
  226. }
  227. DRM(free)(pt, sizeof(*pt), DRM_MEM_VMAS);
  228. } else {
  229. prev = pt;
  230. }
  231. }
  232. /* We were the only map that was found */
  233. if(found_maps == 1 &&
  234.    map->flags & _DRM_REMOVABLE) {
  235. /* Check to see if we are in the maplist, if we are not, then
  236.  * we delete this mappings information.
  237.  */
  238. found_maps = 0;
  239. list = &dev->maplist->head;
  240. list_for_each(list, &dev->maplist->head) {
  241. r_list = (drm_map_list_t *) list;
  242. if (r_list->map == map) found_maps++;
  243. }
  245. if(!found_maps) {
  246. switch (map->type) {
  247. case _DRM_REGISTERS:
  248. case _DRM_FRAME_BUFFER:
  249. #if __REALLY_HAVE_MTRR
  250. if (map->mtrr >= 0) {
  251. int retcode;
  252. retcode = mtrr_del(map->mtrr,
  253.    map->offset,
  254.    map->size);
  255. DRM_DEBUG("mtrr_del = %dn", retcode);
  256. }
  257. #endif
  258. DRM(ioremapfree)(map->handle, map->size);
  259. break;
  260. case _DRM_SHM:
  261. vfree(map->handle);
  262. break;
  263. case _DRM_AGP:
  264. case _DRM_SCATTER_GATHER:
  265. break;
  266. }
  267. DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
  268. }
  269. }
  270. up(&dev->struct_sem);
  271. }
  273. #if LINUX_VERSION_CODE < 0x020317
  274. unsigned long DRM(vm_dma_nopage)(struct vm_area_struct *vma,
  275.  unsigned long address,
  276.  int unused)
  277. #else
  278. /* Return type changed in 2.3.23 */
  279. struct page *DRM(vm_dma_nopage)(struct vm_area_struct *vma,
  280. unsigned long address,
  281. int unused)
  282. #endif
  283. {
  284. drm_file_t  *priv  = vma->vm_file->private_data;
  285. drm_device_t  *dev  = priv->dev;
  286. drm_device_dma_t *dma  = dev->dma;
  287. unsigned long  offset;
  288. unsigned long  page_nr;
  289. struct page  *page;
  291. if (!dma)    return NOPAGE_SIGBUS; /* Error */
  292. if (address > vma->vm_end) return NOPAGE_SIGBUS; /* Disallow mremap */
  293. if (!dma->pagelist)    return NOPAGE_OOM ; /* Nothing allocated */
  295. offset  = address - vma->vm_start; /* vm_[pg]off[set] should be 0 */
  296. page_nr  = offset >> PAGE_SHIFT;
  297. page = virt_to_page((dma->pagelist[page_nr] + 
  298.      (offset & (~PAGE_MASK))));
  300. get_page(page);
  302. DRM_DEBUG("dma_nopage 0x%lx (page %lu)n", address, page_nr); 
  303. #if LINUX_VERSION_CODE < 0x020317
  304. return page_address(page);
  305. #else
  306. return page;
  307. #endif
  308. }
  310. #if LINUX_VERSION_CODE < 0x020317
  311. unsigned long DRM(vm_sg_nopage)(struct vm_area_struct *vma,
  312. unsigned long address,
  313. int unused)
  314. #else
  315. /* Return type changed in 2.3.23 */
  316. struct page *DRM(vm_sg_nopage)(struct vm_area_struct *vma,
  317.        unsigned long address,
  318.        int unused)
  319. #endif
  320. {
  321. #if LINUX_VERSION_CODE >= 0x020300
  322. drm_map_t        *map    = (drm_map_t *)vma->vm_private_data;
  323. #else
  324. drm_map_t        *map    = (drm_map_t *)vma->vm_pte;
  325. #endif
  326. drm_file_t *priv = vma->vm_file->private_data;
  327. drm_device_t *dev = priv->dev;
  328. drm_sg_mem_t *entry = dev->sg;
  329. unsigned long offset;
  330. unsigned long map_offset;
  331. unsigned long page_offset;
  332. struct page *page;
  334. if (!entry)                return NOPAGE_SIGBUS; /* Error */
  335. if (address > vma->vm_end) return NOPAGE_SIGBUS; /* Disallow mremap */
  336. if (!entry->pagelist)      return NOPAGE_OOM ;  /* Nothing allocated */
  339. offset = address - vma->vm_start;
  340. map_offset = map->offset - dev->sg->handle;
  341. page_offset = (offset >> PAGE_SHIFT) + (map_offset >> PAGE_SHIFT);
  342. page = entry->pagelist[page_offset];
  343. get_page(page);
  345. #if LINUX_VERSION_CODE < 0x020317
  346. return page_address(page);
  347. #else
  348. return page;
  349. #endif
  350. }
  352. void DRM(vm_open)(struct vm_area_struct *vma)
  353. {
  354. drm_file_t *priv = vma->vm_file->private_data;
  355. drm_device_t *dev = priv->dev;
  356. drm_vma_entry_t *vma_entry;
  358. DRM_DEBUG("0x%08lx,0x%08lxn",
  359.   vma->vm_start, vma->vm_end - vma->vm_start);
  360. atomic_inc(&dev->vma_count);
  361. #if LINUX_VERSION_CODE < 0x020333
  362. /* The map can exist after the fd is closed. */
  363. MOD_INC_USE_COUNT; /* Needed before Linux 2.3.51 */
  364. #endif
  366. vma_entry = DRM(alloc)(sizeof(*vma_entry), DRM_MEM_VMAS);
  367. if (vma_entry) {
  368. down(&dev->struct_sem);
  369. vma_entry->vma = vma;
  370. vma_entry->next = dev->vmalist;
  371. vma_entry->pid = current->pid;
  372. dev->vmalist = vma_entry;
  373. up(&dev->struct_sem);
  374. }
  375. }
  377. void DRM(vm_close)(struct vm_area_struct *vma)
  378. {
  379. drm_file_t *priv = vma->vm_file->private_data;
  380. drm_device_t *dev = priv->dev;
  381. drm_vma_entry_t *pt, *prev;
  383. DRM_DEBUG("0x%08lx,0x%08lxn",
  384.   vma->vm_start, vma->vm_end - vma->vm_start);
  385. #if LINUX_VERSION_CODE < 0x020333
  386. MOD_DEC_USE_COUNT; /* Needed before Linux 2.3.51 */
  387. #endif
  388. atomic_dec(&dev->vma_count);
  390. down(&dev->struct_sem);
  391. for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
  392. if (pt->vma == vma) {
  393. if (prev) {
  394. prev->next = pt->next;
  395. } else {
  396. dev->vmalist = pt->next;
  397. }
  398. DRM(free)(pt, sizeof(*pt), DRM_MEM_VMAS);
  399. break;
  400. }
  401. }
  402. up(&dev->struct_sem);
  403. }
  405. int DRM(mmap_dma)(struct file *filp, struct vm_area_struct *vma)
  406. {
  407. drm_file_t  *priv  = filp->private_data;
  408. drm_device_t  *dev;
  409. drm_device_dma_t *dma;
  410. unsigned long  length  = vma->vm_end - vma->vm_start;
  412. lock_kernel();
  413. dev  = priv->dev;
  414. dma  = dev->dma;
  415. DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lxn",
  416.   vma->vm_start, vma->vm_end, VM_OFFSET(vma));
  418. /* Length must match exact page count */
  419. if (!dma || (length >> PAGE_SHIFT) != dma->page_count) {
  420. unlock_kernel();
  421. return -EINVAL;
  422. }
  423. unlock_kernel();
  425. vma->vm_ops   = &DRM(vm_dma_ops);
  426. vma->vm_flags |= VM_RESERVED; /* Don't swap */
  428. #if LINUX_VERSION_CODE < 0x020203 /* KERNEL_VERSION(2,2,3) */
  429. /* In Linux 2.2.3 and above, this is
  430.    handled in do_mmap() in mm/mmap.c. */
  431. ++filp->f_count;
  432. #endif
  433. vma->vm_file  =  filp; /* Needed for drm_vm_open() */
  434. DRM(vm_open)(vma);
  435. return 0;
  436. }
  438. #ifndef DRIVER_GET_MAP_OFS
  439. #define DRIVER_GET_MAP_OFS() (map->offset)
  440. #endif
  442. #ifndef DRIVER_GET_REG_OFS
  443. #ifdef __alpha__
  444. #define DRIVER_GET_REG_OFS() (dev->hose->dense_mem_base -
  445.  dev->hose->mem_space->start)
  446. #else
  447. #define DRIVER_GET_REG_OFS() 0
  448. #endif
  449. #endif
  451. int DRM(mmap)(struct file *filp, struct vm_area_struct *vma)
  452. {
  453. drm_file_t *priv = filp->private_data;
  454. drm_device_t *dev = priv->dev;
  455. drm_map_t *map = NULL;
  456. drm_map_list_t  *r_list;
  457. unsigned long   offset  = 0;
  458. struct list_head *list;
  460. DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lxn",
  461.   vma->vm_start, vma->vm_end, VM_OFFSET(vma));
  463. if ( !priv->authenticated ) return -EACCES;
  465. if (!VM_OFFSET(vma)) return DRM(mmap_dma)(filp, vma);
  467. /* A sequential search of a linked list is
  468.    fine here because: 1) there will only be
  469.    about 5-10 entries in the list and, 2) a
  470.    DRI client only has to do this mapping
  471.    once, so it doesn't have to be optimized
  472.    for performance, even if the list was a
  473.    bit longer. */
  474. list_for_each(list, &dev->maplist->head) {
  475. unsigned long off;
  477. r_list = (drm_map_list_t *)list;
  478. map = r_list->map;
  479. if (!map) continue;
  480. off = DRIVER_GET_MAP_OFS();
  481. if (off == VM_OFFSET(vma)) break;
  482. }
  484. if (!map || ((map->flags&_DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
  485. return -EPERM;
  487. /* Check for valid size. */
  488. if (map->size != vma->vm_end - vma->vm_start) return -EINVAL;
  490. if (!capable(CAP_SYS_ADMIN) && (map->flags & _DRM_READ_ONLY)) {
  491. vma->vm_flags &= VM_MAYWRITE;
  492. #if defined(__i386__)
  493. pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
  494. #else
  495. /* Ye gads this is ugly.  With more thought
  496.                                    we could move this up higher and use
  497.                                    `protection_map' instead.  */
  498. vma->vm_page_prot = __pgprot(pte_val(pte_wrprotect(
  499. __pte(pgprot_val(vma->vm_page_prot)))));
  500. #endif
  501. }
  503. switch (map->type) {
  504.         case _DRM_AGP:
  505. #if defined(__alpha__)
  506.                 /*
  507.                  * On Alpha we can't talk to bus dma address from the
  508.                  * CPU, so for memory of type DRM_AGP, we'll deal with
  509.                  * sorting out the real physical pages and mappings
  510.                  * in nopage()
  511.                  */
  512.                 vma->vm_ops = &DRM(vm_ops);
  513.                 break;
  514. #endif
  515.                 /* fall through to _DRM_FRAME_BUFFER... */        
  516. case _DRM_FRAME_BUFFER:
  517. case _DRM_REGISTERS:
  518. if (VM_OFFSET(vma) >= __pa(high_memory)) {
  519. #if defined(__i386__)
  520. if (boot_cpu_data.x86 > 3 && map->type != _DRM_AGP) {
  521. pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
  522. pgprot_val(vma->vm_page_prot) &= ~_PAGE_PWT;
  523. }
  524. #elif defined(__ia64__)
  525. if (map->type != _DRM_AGP)
  526. vma->vm_page_prot =
  527. pgprot_writecombine(vma->vm_page_prot);
  528. #elif defined(__powerpc__)
  529. pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE | _PAGE_GUARDED;
  530. #endif
  531. vma->vm_flags |= VM_IO; /* not in core dump */
  532. }
  533. offset = DRIVER_GET_REG_OFS();
  534. #ifdef __sparc__
  535. if (io_remap_page_range(vma->vm_start,
  536. VM_OFFSET(vma) + offset,
  537. vma->vm_end - vma->vm_start,
  538. vma->vm_page_prot, 0))
  539. #else
  540. if (remap_page_range(vma->vm_start,
  541.      VM_OFFSET(vma) + offset,
  542.      vma->vm_end - vma->vm_start,
  543.      vma->vm_page_prot))
  544. #endif
  545. return -EAGAIN;
  546. DRM_DEBUG("   Type = %d; start = 0x%lx, end = 0x%lx,"
  547.   " offset = 0x%lxn",
  548.   map->type,
  549.   vma->vm_start, vma->vm_end, VM_OFFSET(vma) + offset);
  550. vma->vm_ops = &DRM(vm_ops);
  551. break;
  552. case _DRM_SHM:
  553. vma->vm_ops = &DRM(vm_shm_ops);
  554. #if LINUX_VERSION_CODE >= 0x020300
  555. vma->vm_private_data = (void *)map;
  556. #else
  557. vma->vm_pte = (unsigned long)map;
  558. #endif
  559. /* Don't let this area swap.  Change when
  560.    DRM_KERNEL advisory is supported. */
  561. vma->vm_flags |= VM_RESERVED;
  562. break;
  563. case _DRM_SCATTER_GATHER:
  564. vma->vm_ops = &DRM(vm_sg_ops);
  565. #if LINUX_VERSION_CODE >= 0x020300
  566. vma->vm_private_data = (void *)map;
  567. #else
  568. vma->vm_pte = (unsigned long)map;
  569. #endif
  570.                 vma->vm_flags |= VM_RESERVED;
  571.                 break;
  572. default:
  573. return -EINVAL; /* This should never happen. */
  574. }
  575. vma->vm_flags |= VM_RESERVED; /* Don't swap */
  577. #if LINUX_VERSION_CODE < 0x020203 /* KERNEL_VERSION(2,2,3) */
  578. /* In Linux 2.2.3 and above, this is
  579.    handled in do_mmap() in mm/mmap.c. */
  580. ++filp->f_count;
  581. #endif
  582. vma->vm_file  =  filp; /* Needed for drm_vm_open() */
  583. DRM(vm_open)(vma);
  584. return 0;
  585. }