linux-core/savage_drv.c

   1 /*
   2  * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
   3  * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <linux/config.h>
  26 #include "savage.h"
  27 #include "drmP.h"
  28 #include "savage_drm.h"
  29 #include "savage_drv.h"
  30
  31 #define DRIVER_AUTHOR           "John Zhao, S3 Graphics Inc."
  32
  33 #define DRIVER_NAME             "savage"
  34 #define DRIVER_DESC             "Savage4 Family"
  35 #define DRIVER_DATE             "20011023"
  36
  37 #define DRIVER_MAJOR            1
  38 #define DRIVER_MINOR            0
  39 #define DRIVER_PATCHLEVEL       0
  40
  41 /* Currently Savage4 not implement DMA */
  42 /* mark off by Jiayo Hsu, Oct. 23, 2001*/
  43
  44
  45 #if SAVAGE_CMD_DMA /* Check the 3D driver, and we need to fix this anyway */
  46
  47 #define DRIVER_IOCTLS \
  48         [DRM_IOCTL_NR(DRM_IOCTL_SAVAGE_ALLOC_CONTINUOUS_MEM)] \
  49         = {savage_alloc_continuous_mem,1,0},\
  50         [DRM_IOCTL_NR( DRM_IOCTL_SAVAGE_GET_PHYSICS_ADDRESS)] \
  51         = {savage_get_physics_address,1,0},\
  52         [DRM_IOCTL_NR(DRM_IOCTL_SAVAGE_FREE_CONTINUOUS_MEM)]  \
  53         = {savage_free_cont_mem,1,0}
  54
  55 int savage_alloc_continuous_mem(struct inode *inode, struct file *filp,
  56                 unsigned int cmd, unsigned long arg)
  57 {
  58   drm_savage_alloc_cont_mem_t cont_mem;
  59   unsigned long size,addr;
  60   void * ret;
  61   int i;
  62   mem_map_t *p;
  63   pgprot_t flags;
  64
  65   /* add to list */
  66   drm_file_t *priv = filp->private_data;
  67   drm_device_t *dev = priv->dev;
  68   drm_map_t *map;
  69   drm_map_list_t *list;
  70
  71   if (copy_from_user(&cont_mem,(drm_savage_alloc_cont_mem_t *)arg,sizeof(cont_mem)))
  72     return -EFAULT;
  73
  74   map = DRM(alloc)( sizeof(*map), DRM_MEM_MAPS );
  75   if ( !map )
  76     return -ENOMEM;
  77
  78   /*check the parameters*/
  79   if (cont_mem.size <= 0 )
  80     return -EINVAL;
  81
  82   size = cont_mem.type * cont_mem.size;
  83   printk("[drm]JTLIsize = %lu\n",size);
  84
  85   ret = (void *)__get_free_pages(GFP_KERNEL, get_order(size));
  86   if (ret == NULL)
  87     {
  88       printk("Kalloc error\n");
  89       return 0;
  90     }
  91
  92   /*set the reserverd flag so that the remap_page_range can map these page*/
  93   for(i=0,p=virt_to_page(ret);i< size /PAGE_SIZE; i++,p++)
  94     SetPageReserved(p);
  95
  96   cont_mem.phyaddress = virt_to_bus(ret);
  97   cont_mem.location = DRM_SAVAGE_MEM_LOCATION_PCI; /* pci only at present*/
  98
  99
 100   /*Map the memory to user space*/
 101   down_write(&current->mm->mmap_sem);
 102   addr=do_mmap(NULL,0,size,PROT_READ|PROT_WRITE,MAP_PRIVATE,cont_mem.phyaddress);
 103   if (addr<=0)
 104     return -EFAULT;
 105   pgprot_val(flags)=_PAGE_PRESENT | _PAGE_RW |_PAGE_USER ;
 106   if (remap_page_range(addr,cont_mem.phyaddress,size,flags))
 107     return -EFAULT;
 108   up_write(&current->mm->mmap_sem);
 109
 110   for(i=0,p=virt_to_page(ret);i< size /PAGE_SIZE; i++,p++)
 111     ClearPageReserved(p);
 112
 113   cont_mem.linear = addr;
 114
 115   /*map list*/
 116   map->handle =  ret; /* to distinguish with other*/
 117   map->offset = cont_mem.phyaddress;
 118   map->size = size;
 119   map->mtrr=-1;
 120   /*map-flags,type??*/
 121
 122   list = DRM(alloc)(sizeof(*list), DRM_MEM_MAPS);
 123   if(!list) {
 124     DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
 125     return -EINVAL;
 126   }
 127   memset(list, 0, sizeof(*list));
 128   list->map = map;
 129
 130   down(&dev->struct_sem);
 131   list_add(&list->head, &dev->maplist->head);
 132   up(&dev->struct_sem);
 133
 134   if (copy_to_user((drm_savage_alloc_cont_mem_t *)arg,&cont_mem,sizeof(cont_mem)))
 135     return -EFAULT;
 136
 137   for(i=0,p=virt_to_page(ret);i< size /PAGE_SIZE; i++,p++)
 138     atomic_set(&p->count,1);
 139
 140   return 1;/*success*/
 141 }
 142
 143 int savage_get_physics_address(struct inode *inode, struct file *filp,
 144                                unsigned int cmd, unsigned long arg)
 145 {
 146
 147   drm_savage_get_physcis_address_t req;
 148   unsigned long buf;
 149   pgd_t *pgd;
 150   pmd_t *pmd;
 151   pte_t *pte;
 152   struct mm_struct *mm;
 153
 154   if (copy_from_user(&req,(drm_savage_get_physcis_address_t *)arg,sizeof(req)))
 155     return -EFAULT;
 156   buf = req.v_address;
 157
 158   /*What kind of virtual address ?*/
 159   if (buf >= (unsigned long)high_memory)
 160     mm = &init_mm;
 161   else
 162     mm = current->mm;
 163
 164 #ifdef LINUX_24
 165   spin_lock(&mm->page_table_lock);
 166 #endif
 167
 168   pgd=pgd_offset(mm,buf);
 169   pmd=pmd_offset(pgd,buf);
 170   pte=pte_offset_map(pmd,buf);
 171
 172   if (!pte_present(*pte))
 173     return -EFAULT;
 174
 175   req.p_address = ((pte_val(*pte) &PAGE_MASK) |( buf&(PAGE_SIZE-1)));
 176
 177   if (copy_to_user((drm_savage_get_physcis_address_t  *)arg,&req,sizeof(req)))
 178     return -EFAULT;
 179   return 1;
 180 }
 181
 182 /*free the continuous memory*/
 183 int savage_free_cont_mem(struct inode *inode, struct file *filp,
 184                                unsigned int cmd, unsigned long arg)
 185 {
 186   drm_savage_alloc_cont_mem_t cont_mem;
 187   unsigned long size;
 188
 189   /*map  list */
 190   drm_file_t *priv = filp->private_data;
 191   drm_device_t *dev = priv->dev;
 192   drm_map_t *map;
 193   struct list_head *list;
 194   drm_map_list_t *r_list = NULL;
 195
 196   if (copy_from_user(&cont_mem,(drm_savage_alloc_cont_mem_t *)arg,sizeof(cont_mem)))
 197     return -EFAULT;
 198   size = cont_mem.type * cont_mem.size;
 199   if (size <= 0)
 200     return -EINVAL;
 201
 202   /* find the map in the list */
 203   list_for_each(list,&dev->maplist->head)
 204     {
 205       r_list = (drm_map_list_t *) list;
 206
 207       if(r_list->map &&
 208          r_list->map->offset == cont_mem.phyaddress )
 209          break;
 210     }
 211   /*find none*/
 212   if(list == (&dev->maplist->head)) {
 213     up(&dev->struct_sem);
 214     return -EINVAL;
 215   }
 216   map = r_list->map;
 217   list_del(list);
 218   DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);
 219
 220   /*unmap the user space */
 221 #ifdef DO_MUNMAP_4_ARGS
 222   if ( do_munmap(current->mm,cont_mem.linear,size,1)!=0)
 223 #else
 224   if ( do_munmap(current->mm,cont_mem.linear,size)!=0)
 225 #endif
 226     return -EFAULT;
 227   /*free the page*/
 228   free_pages((unsigned long)map->handle, get_order(size));
 229
 230   return 1;
 231 }
 232 #else /* SAVAGE_CMD_DMA */
 233 #define DRIVER_IOCTLS
 234 #endif /* SAVAGE_CMD_DMA */
 235
 236 #if 0
 237
 238 #define DRIVER_IOCTLS                                                      \
 239         [DRM_IOCTL_NR(DRM_IOCTL_DMA)]         = { mga_dma_buffers, 1, 0 }, \
 240         [DRM_IOCTL_NR(DRM_IOCTL_MGA_INIT)]    = { mga_dma_init,    1, 1 }, \
 241         [DRM_IOCTL_NR(DRM_IOCTL_MGA_FLUSH)]   = { mga_dma_flush,   1, 0 }, \
 242         [DRM_IOCTL_NR(DRM_IOCTL_MGA_RESET)]   = { mga_dma_reset,   1, 0 }, \
 243         [DRM_IOCTL_NR(DRM_IOCTL_MGA_SWAP)]    = { mga_dma_swap,    1, 0 }, \
 244         [DRM_IOCTL_NR(DRM_IOCTL_MGA_CLEAR)]   = { mga_dma_clear,   1, 0 }, \
 245         [DRM_IOCTL_NR(DRM_IOCTL_MGA_VERTEX)]  = { mga_dma_vertex,  1, 0 }, \
 246         [DRM_IOCTL_NR(DRM_IOCTL_MGA_INDICES)] = { mga_dma_indices, 1, 0 }, \
 247         [DRM_IOCTL_NR(DRM_IOCTL_MGA_ILOAD)]   = { mga_dma_iload,   1, 0 }, \
 248         [DRM_IOCTL_NR(DRM_IOCTL_MGA_BLIT)]    = { mga_dma_blit,    1, 0 },
 249
 250
 251 #define __HAVE_COUNTERS         3
 252 #define __HAVE_COUNTER6         _DRM_STAT_IRQ
 253 #define __HAVE_COUNTER7         _DRM_STAT_PRIMARY
 254 #define __HAVE_COUNTER8         _DRM_STAT_SECONDARY
 255
 256 #endif /* end #if 0 */
 257
 258 #include "drm_agpsupport.h"
 259 #include "drm_auth.h"
 260 #include "drm_bufs.h"
 261 #include "drm_context.h"
 262 #include "drm_dma.h"
 263 #include "drm_drawable.h"
 264 #include "drm_drv.h"
 265 #include "drm_fops.h"
 266 #include "drm_init.h"
 267 #include "drm_ioctl.h"
 268 #include "drm_irq.h"
 269 #include "drm_lock.h"
 270 #include "drm_memory.h"
 271 #include "drm_proc.h"
 272 #include "drm_vm.h"
 273 #include "drm_stub.h"
 274 #include "drm_scatter.h"
 275
 276
 277