workbench/hidds/hidd.nouveau/drm/drm-aros/drmP.h

   1 /*
   2     Copyright 2009-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /*-
   7  * This file incorporates work covered by the following copyright and
   8  * permission notice:
   9  *
  10  *  Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  11  *  Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  12  *  All rights reserved.
  13  *
  14  *  Permission is hereby granted, free of charge, to any person obtaining a
  15  *  copy of this software and associated documentation files (the "Software"),
  16  *  to deal in the Software without restriction, including without limitation
  17  *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
  18  *  and/or sell copies of the Software, and to permit persons to whom the
  19  *  Software is furnished to do so, subject to the following conditions:
  20  *
  21  *  The above copyright notice and this permission notice (including the next
  22  *  paragraph) shall be included in all copies or substantial portions of the
  23  *  Software.
  24  *
  25  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  28  *  VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  29  *  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  30  *  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  31  *  OTHER DEALINGS IN THE SOFTWARE.
  32  *
  33  */
  34
  35 #if !defined(DRMP_H)
  36 #define DRMP_H
  37
  38 #define DEBUG 0
  39 #include <aros/debug.h>
  40
  41 #include "drm.h"
  42 #include <hidd/irq.h>
  43 #include "drm_aros_config.h"
  44 #include "drm_compat_funcs.h"
  45 #include "drm_redefines.h"
  46
  47 #include <errno.h>
  48 #include <stdio.h>
  49 #include <string.h>
  50
  51 #include "drm_mm.h"
  52
  53 #define DRM_ERROR(fmt, ...) bug("[" DRM_NAME "(ERROR):%s] " fmt, __func__ , ##__VA_ARGS__)
  54 #define DRM_DEBUG(fmt, ...) D(bug("[" DRM_NAME "(DEBUG):%s] " fmt, __func__ , ##__VA_ARGS__))
  55 #define DRM_DEBUG_KMS(fmt, ...) D(bug("[" DRM_NAME "(DEBUG):%s] " fmt, __func__ , ##__VA_ARGS__))
  56 #define DRM_IMPL(fmt, ...)  bug("------IMPLEMENT(%s): " fmt, __func__ , ##__VA_ARGS__)
  57 #define DRM_INFO(fmt, ...)  bug("[" DRM_NAME "(INFO)] " fmt, ##__VA_ARGS__)
  58 #define DRM_DEBUG_DRIVER    DRM_DEBUG
  59
  60
  61 /*
  62  * DRM_READMEMORYBARRIER() prevents reordering of reads.
  63  * DRM_WRITEMEMORYBARRIER() prevents reordering of writes.
  64  * DRM_MEMORYBARRIER() prevents reordering of reads and writes.
  65  */
  66
  67 #if defined(__i386__)
  68 #define DRM_READMEMORYBARRIER()     __asm __volatile("lock; addl $0,0(%%esp)" : : : "memory");
  69 #define DRM_WRITEMEMORYBARRIER()    __asm __volatile("" : : : "memory");
  70 #define DRM_MEMORYBARRIER()         __asm __volatile("lock; addl $0,0(%%esp)" : : : "memory");
  71 #else
  72 #error IMPLEMENT momory bariers for non-x86
  73 #endif
  74
  75
  76 #define DRM_COPY_FROM_USER(to, from, size)   copy_from_user(to, from, size)
  77 #define DRM_COPY_TO_USER(to , from, size)    copy_to_user(to, from, size)
  78 #define DRM_ARRAY_SIZE(x)   ARRAY_SIZE(x)
  79 #define DRM_UDELAY(d)       udelay(d)
  80 #define DRM_CURRENTPID      1
  81 #define DRM_IRQ_ARGS        void *arg
  82 #define DRM_SUSER(p)        capable(CAP_SYS_ADMIN)
  83 typedef int                 irqreturn_t;
  84 #define IRQ_NONE            1
  85 #define IRQ_HANDLED         0
  86
  87 struct drm_file;
  88 struct drm_device;
  89 struct file;
  90 struct drm_gem_object;
  91
  92 typedef int drm_ioctl_t(struct drm_device *dev, void *data,
  93             struct drm_file *file_priv);
  94
  95 #define DRM_AUTH            0x1
  96 #define DRM_MASTER          0x2
  97 #define DRM_ROOT_ONLY       0x4
  98 #define DRM_CONTROL_ALLOW   0x8
  99 #define DRM_UNLOCKED        0x10
 100
 101 struct drm_ioctl_desc
 102 {
 103     unsigned int cmd;
 104     int flags;
 105     drm_ioctl_t *func;
 106     unsigned int cmd_drv;
 107 };
 108
 109 /*
 110  * Creates a driver or general drm_ioctl_desc array entry for the given
 111  * ioctl, for use by drm_ioctl().
 112  */
 113 #define DRM_IOCTL_NR(n)     ((n) & 0xff)
 114 #define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags)                 \
 115         [DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl}
 116
 117
 118 /* Memory management */
 119 struct drm_local_map
 120 {
 121     resource_size_t offset;         /* Requested physical address (0 for SAREA)*/
 122     unsigned long size;             /* Requested physical size (bytes) */
 123     enum drm_map_type type;         /* Type of memory to map */
 124     enum drm_map_flags flags;       /* Flags */
 125     void *handle;                   /* Memory address */
 126     int mtrr;                       /* MTRR slot used */
 127 };
 128
 129 typedef struct drm_local_map drm_local_map_t;
 130
 131 struct drm_map_list
 132 {
 133     struct list_head head;                  /* list head */
 134 /* FIXME: Commented out fields */
 135 //    struct drm_hash_item hash;
 136     struct drm_local_map *map;              /* mapping */
 137     uint64_t user_token;
 138     struct drm_master *master;
 139     struct drm_mm_node *file_offset_node;   /* fake offset */
 140 };
 141
 142 struct drm_sg_mem {
 143     unsigned long handle;
 144     void *virtual;
 145     int pages;
 146 #if !defined(__AROS__)
 147     struct page **pagelist;
 148 #else
 149     void * buffer;
 150 #endif
 151     dma_addr_t *busaddr;
 152 };
 153
 154 #define DRM_AGP_KERN struct agp_kern_info
 155 #define DRM_AGP_MEM struct agp_memory
 156 struct drm_agp_mem {
 157     DRM_AGP_MEM *memory;
 158     unsigned long bound;
 159     int pages;
 160     struct list_head head;
 161 };
 162
 163 struct drm_agp_head {
 164     DRM_AGP_KERN agp_info;          /* AGP device information */
 165     struct list_head memory;
 166     unsigned long mode;             /* AGP mode */
 167     struct agp_bridge_data *bridge;
 168     int enabled;                    /* whether the AGP bus as been enabled */
 169     int acquired;                   /* whether the AGP device has been acquired */
 170     unsigned long base;
 171     int agp_mtrr;
 172     int cant_use_aperture;
 173     unsigned long page_mask;
 174 };
 175
 176 struct drm_pciid
 177 {
 178     UWORD VendorID;
 179     UWORD ProductID;
 180 };
 181
 182 #include "drm_crtc.h"
 183
 184 /* Contains a collection of functions common to each drm driver */
 185
 186 #define DRIVER_USE_AGP     0x1
 187 #define DRIVER_REQUIRE_AGP 0x2
 188 #define DRIVER_GEM         0x1000
 189 #define DRIVER_MODESET     0x2000
 190
 191 /* Size of ringbuffer for vblank timestamps. Just double-buffer
 192  * in initial implementation.
 193  */
 194 #define DRM_VBLANKTIME_RBSIZE 2
 195
 196 /* Flags and return codes for get_vblank_timestamp() driver function. */
 197 #define DRM_CALLED_FROM_VBLIRQ 1
 198 #define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
 199 #define DRM_VBLANKTIME_INVBL             (1 << 1)
 200
 201 /* get_scanout_position() return flags */
 202 #define DRM_SCANOUTPOS_VALID        (1 << 0)
 203 #define DRM_SCANOUTPOS_INVBL        (1 << 1)
 204 #define DRM_SCANOUTPOS_ACCURATE     (1 << 2)
 205
 206 struct drm_driver
 207 {
 208     /* PCI */
 209     UWORD               VendorID;
 210     UWORD               ProductID;
 211     UWORD               SubSystemVendorID;
 212     UWORD               SubSystemProductID;
 213     struct drm_pciid    *PciIDs;
 214     OOP_Object          *pciDevice;
 215     BOOL                IsAGP;
 216     BOOL                IsPCIE;
 217
 218     /* DRM device */
 219     struct drm_device   *dev;
 220
 221     int         (*load)(struct drm_device *, unsigned long);
 222     int         (*firstopen)(struct drm_device *);
 223     int         (*open) (struct drm_device *, struct drm_file *);
 224     void        (*preclose)(struct drm_device *dev, struct drm_file *);
 225     void        (*postclose) (struct drm_device *, struct drm_file *);
 226     void        (*lastclose)(struct drm_device *);
 227     int         (*unload)(struct drm_device *);
 228
 229     /* IRQ */
 230     irqreturn_t (*irq_handler)(DRM_IRQ_ARGS);
 231     void        (*irq_preinstall)(struct drm_device *);
 232     int         (*irq_postinstall)(struct drm_device *);
 233     void        (*irq_uninstall)(struct drm_device *);
 234
 235     /* GEM */
 236     int         (*gem_init_object) (struct drm_gem_object *obj);
 237     void        (*gem_free_object) (struct drm_gem_object *obj);
 238     void        (*gem_free_object_unlocked) (struct drm_gem_object *obj);
 239
 240     int                     version_patchlevel;
 241     unsigned int            driver_features;
 242     struct drm_ioctl_desc   *ioctls;
 243 };
 244
 245 struct drm_device
 246 {
 247     struct list_head maplist;       /* Linked list of regions */
 248
 249     int irq_enabled;                /* True if irq handler is enabled */
 250     int pci_vendor;                 /* PCI vendor id */
 251     int pci_device;                 /* PCI device id */
 252
 253     struct drm_agp_head *agp;       /* AGP data */
 254
 255     struct drm_driver *driver;      /* Driver functions */
 256     void *dev_private;              /* Device private data */
 257     struct mutex  struct_mutex;
 258
 259     struct address_space *dev_mapping;
 260     struct drm_mode_config mode_config;
 261
 262     /* GEM information */
 263     spinlock_t object_name_lock;
 264     struct idr object_name_idr;
 265     uint32_t invalidate_domains;    /* domains pending invalidation */
 266     uint32_t flush_domains;         /* domains pending flush */
 267
 268     /* AROS specific fields */
 269     OOP_Object              *pdev;
 270     HIDDT_IRQ_Handler       *IntHandler;
 271 };
 272
 273 static __inline__ int drm_core_check_feature(struct drm_device *dev,
 274                          int feature)
 275 {
 276     return ((dev->driver->driver_features & feature) ? 1 : 0);
 277 }
 278
 279 typedef struct drm_dma_handle {
 280         dma_addr_t busaddr;
 281         void *vaddr;
 282         size_t size;
 283 } drm_dma_handle_t;
 284
 285 struct drm_file
 286 {
 287     struct idr object_idr;
 288     spinlock_t table_lock;
 289     void *driver_priv;
 290     struct list_head fbs;
 291 };
 292
 293 struct drm_gem_object {
 294     /** Reference count of this object */
 295     struct kref refcount;
 296
 297     /** Handle count of this object. Each handle also holds a reference */
 298     atomic_t handle_count; /* number of handles on this object */
 299
 300     /** Related drm device */
 301     struct drm_device *dev;
 302
 303     /** File representing the shmem storage */
 304     struct file *filp;
 305
 306     /* Mapping info for this object */
 307     struct drm_map_list map_list;
 308
 309     /**
 310      * Size of the object, in bytes.  Immutable over the object's
 311      * lifetime.
 312      */
 313     size_t size;
 314
 315     /**
 316      * Global name for this object, starts at 1. 0 means unnamed.
 317      * Access is covered by the object_name_lock in the related drm_device
 318      */
 319     int name;
 320
 321     /**
 322      * Memory domains. These monitor which caches contain read/write data
 323      * related to the object. When transitioning from one set of domains
 324      * to another, the driver is called to ensure that caches are suitably
 325      * flushed and invalidated
 326      */
 327     uint32_t read_domains;
 328     uint32_t write_domain;
 329
 330     /**
 331      * While validating an exec operation, the
 332      * new read/write domain values are computed here.
 333      * They will be transferred to the above values
 334      * at the point that any cache flushing occurs
 335      */
 336     uint32_t pending_read_domains;
 337     uint32_t pending_write_domain;
 338
 339     void *driver_private;
 340 };
 341
 342 static inline int drm_core_has_AGP(struct drm_device *dev)
 343 {
 344         return drm_core_check_feature(dev, DRIVER_USE_AGP);
 345 }
 346
 347 static __inline__ int drm_device_is_agp(struct drm_device *dev)
 348 {
 349     return dev->driver->IsAGP;
 350 }
 351
 352 static __inline__ int drm_device_is_pcie(struct drm_device *dev)
 353 {
 354     return dev->driver->IsPCIE;
 355 }
 356
 357 static __inline__ void *drm_calloc_large(size_t nmemb, size_t size)
 358 {
 359     return AllocVec(nmemb * size, MEMF_ANY | MEMF_CLEAR);
 360 }
 361
 362 static __inline__ void drm_free_large(void *ptr)
 363 {
 364     FreeVec(ptr);
 365 }
 366
 367 /* drm_bufs.c */
 368 int drm_order(unsigned long size);
 369 resource_size_t drm_get_resource_len(struct drm_device *dev,
 370                         unsigned int resource);
 371 resource_size_t drm_get_resource_start(struct drm_device *dev,
 372                         unsigned int resource);
 373
 374
 375 /* drm_drv.c */
 376 void drm_exit(struct drm_driver *driver);
 377 int drm_init(struct drm_driver *driver);
 378
 379 /* drm_irq.c */
 380 int drm_irq_install(struct drm_device *dev);
 381 int drm_irq_uninstall(struct drm_device *dev);
 382
 383 int drm_vblank_init(struct drm_device *dev, int num_crtcs);
 384 void drm_vblank_cleanup(struct drm_device *dev);
 385 void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
 386 void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
 387 int drm_vblank_get(struct drm_device *dev, int crtc);
 388 void drm_vblank_put(struct drm_device *dev, int crtc);
 389 void drm_handle_vblank(struct drm_device *dev, int crtc);
 390 u32 drm_vblank_count(struct drm_device *dev, int crtc);
 391
 392 /* drm_pci.c */
 393 drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
 394                                        size_t align, dma_addr_t maxaddr);
 395 void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah);
 396
 397 /* drm_memory.c */
 398 void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
 399 void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
 400 void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
 401 int drm_unbind_agp(DRM_AGP_MEM * handle);
 402 void drm_free_agp(DRM_AGP_MEM * handle, int pages);
 403
 404 /* drm_agpsupport.c */
 405 struct drm_agp_head *drm_agp_init(struct drm_device *dev);
 406 int drm_agp_acquire(struct drm_device *dev);
 407 int drm_agp_release(struct drm_device *dev);
 408 int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
 409 int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info);
 410 int drm_agp_free_memory(DRM_AGP_MEM * handle);
 411 int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
 412 void drm_agp_chipset_flush(struct drm_device *dev);
 413 DRM_AGP_MEM * drm_agp_bind_pages(struct drm_device *dev, struct page **pages,
 414                    unsigned long num_pages, uint32_t gtt_offset, u32 type);
 415
 416 /* drm_cache.c */
 417 void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
 418
 419 /* GEM */
 420 int drm_gem_init(struct drm_device *dev);
 421 void drm_gem_object_release(struct drm_gem_object *obj);
 422 void drm_gem_object_free(struct kref *kref);
 423 void drm_gem_object_free_unlocked(struct kref *kref);
 424 void drm_gem_object_handle_free(struct drm_gem_object *obj);
 425 struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
 426                         size_t size);
 427 int drm_gem_handle_create(struct drm_file *file_priv,
 428               struct drm_gem_object *obj,
 429               u32 *handlep);
 430
 431 struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
 432                          struct drm_file *filp,
 433                          u32 handle);
 434
 435
 436 static inline void
 437 drm_gem_object_reference(struct drm_gem_object *obj)
 438 {
 439     kref_get(&obj->refcount);
 440 }
 441
 442 static inline void
 443 drm_gem_object_unreference(struct drm_gem_object *obj)
 444 {
 445     if (obj == NULL)
 446         return;
 447
 448     kref_put(&obj->refcount, drm_gem_object_free);
 449 }
 450
 451 static inline void
 452 drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
 453 {
 454     if (obj != NULL) {
 455         struct drm_device *dev = obj->dev;
 456         mutex_lock(&dev->struct_mutex);
 457         kref_put(&obj->refcount, drm_gem_object_free);
 458         mutex_unlock(&dev->struct_mutex);
 459     }
 460 }
 461
 462 int drm_gem_handle_create(struct drm_file *file_priv,
 463               struct drm_gem_object *obj,
 464               u32 *handlep);
 465
 466 static inline void
 467 drm_gem_object_handle_reference(struct drm_gem_object *obj)
 468 {
 469     drm_gem_object_reference(obj);
 470     atomic_inc(&obj->handle_count);
 471 }
 472
 473 static inline void
 474 drm_gem_object_handle_unreference(struct drm_gem_object *obj)
 475 {
 476     if (obj == NULL)
 477         return;
 478
 479     if (atomic_read(&obj->handle_count) == 0)
 480         return;
 481     /*
 482     * Must bump handle count first as this may be the last
 483     * ref, in which case the object would disappear before we
 484     * checked for a name
 485     */
 486     if (atomic_dec_and_test(&obj->handle_count))
 487         drm_gem_object_handle_free(obj);
 488     drm_gem_object_unreference(obj);
 489 }
 490
 491 static inline void
 492 drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
 493 {
 494     if (obj == NULL)
 495         return;
 496
 497     if (atomic_read(&obj->handle_count) == 0)
 498         return;
 499
 500     /*
 501     * Must bump handle count first as this may be the last
 502     * ref, in which case the object would disappear before we
 503     * checked for a name
 504     */
 505
 506     if (atomic_dec_and_test(&obj->handle_count))
 507         drm_gem_object_handle_free(obj);
 508     drm_gem_object_unreference_unlocked(obj);
 509 }
 510
 511 /* GEM IOCTL */
 512 int drm_gem_open_ioctl(struct drm_device *dev, void *data,
 513                struct drm_file *file_priv);
 514 int drm_gem_close_ioctl(struct drm_device *dev, void *data,
 515             struct drm_file *file_priv);
 516 int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
 517             struct drm_file *file_priv);
 518
 519 /* MTRR */
 520 #define DRM_MTRR_WC     0
 521 static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
 522                    unsigned int flags)
 523 {
 524     return -ENODEV;
 525 }
 526 static inline int drm_mtrr_del(int handle, unsigned long offset,
 527                    unsigned long size, unsigned int flags)
 528 {
 529     return -ENODEV;
 530 }
 531
 532 #define MTRR_TYPE_WRCOMB     1
 533
 534 static inline int mtrr_add(unsigned long base, unsigned long size,
 535                     unsigned int type, char increment)
 536 {
 537     return -ENODEV;
 538 }
 539
 540 #endif