drivers/gpu/drm/mgag200/mgag200_drv.h

   1 /*
   2  * Copyright 2010 Matt Turner.
   3  * Copyright 2012 Red Hat
   4  *
   5  * This file is subject to the terms and conditions of the GNU General
   6  * Public License version 2. See the file COPYING in the main
   7  * directory of this archive for more details.
   8  *
   9  * Authors: Matthew Garrett
  10  *          Matt Turner
  11  *          Dave Airlie
  12  */
  13 #ifndef __MGAG200_DRV_H__
  14 #define __MGAG200_DRV_H__
  15
  16 #include <video/vga.h>
  17
  18 #include <drm/drm_fb_helper.h>
  19 #include <drm/ttm/ttm_bo_api.h>
  20 #include <drm/ttm/ttm_bo_driver.h>
  21 #include <drm/ttm/ttm_placement.h>
  22 #include <drm/ttm/ttm_memory.h>
  23 #include <drm/ttm/ttm_module.h>
  24
  25 #include <linux/i2c.h>
  26 #include <linux/i2c-algo-bit.h>
  27
  28 #include "mgag200_reg.h"
  29
  30 #define DRIVER_AUTHOR           "Matthew Garrett"
  31
  32 #define DRIVER_NAME             "mgag200"
  33 #define DRIVER_DESC             "MGA G200 SE"
  34 #define DRIVER_DATE             "20110418"
  35
  36 #define DRIVER_MAJOR            1
  37 #define DRIVER_MINOR            0
  38 #define DRIVER_PATCHLEVEL       0
  39
  40 #define MGAG200FB_CONN_LIMIT 1
  41
  42 #define RREG8(reg) ioread8(((void __iomem *)mdev->rmmio) + (reg))
  43 #define WREG8(reg, v) iowrite8(v, ((void __iomem *)mdev->rmmio) + (reg))
  44 #define RREG32(reg) ioread32(((void __iomem *)mdev->rmmio) + (reg))
  45 #define WREG32(reg, v) iowrite32(v, ((void __iomem *)mdev->rmmio) + (reg))
  46
  47 #define ATTR_INDEX 0x1fc0
  48 #define ATTR_DATA 0x1fc1
  49
  50 #define WREG_ATTR(reg, v)                                       \
  51         do {                                                    \
  52                 RREG8(0x1fda);                                  \
  53                 WREG8(ATTR_INDEX, reg);                         \
  54                 WREG8(ATTR_DATA, v);                            \
  55         } while (0)                                             \
  56
  57 #define WREG_SEQ(reg, v)                                        \
  58         do {                                                    \
  59                 WREG8(MGAREG_SEQ_INDEX, reg);                   \
  60                 WREG8(MGAREG_SEQ_DATA, v);                      \
  61         } while (0)                                             \
  62
  63 #define WREG_CRT(reg, v)                                        \
  64         do {                                                    \
  65                 WREG8(MGAREG_CRTC_INDEX, reg);                  \
  66                 WREG8(MGAREG_CRTC_DATA, v);                     \
  67         } while (0)                                             \
  68
  69
  70 #define WREG_ECRT(reg, v)                                       \
  71         do {                                                    \
  72                 WREG8(MGAREG_CRTCEXT_INDEX, reg);                               \
  73                 WREG8(MGAREG_CRTCEXT_DATA, v);                          \
  74         } while (0)                                             \
  75
  76 #define GFX_INDEX 0x1fce
  77 #define GFX_DATA 0x1fcf
  78
  79 #define WREG_GFX(reg, v)                                        \
  80         do {                                                    \
  81                 WREG8(GFX_INDEX, reg);                          \
  82                 WREG8(GFX_DATA, v);                             \
  83         } while (0)                                             \
  84
  85 #define DAC_INDEX 0x3c00
  86 #define DAC_DATA 0x3c0a
  87
  88 #define WREG_DAC(reg, v)                                        \
  89         do {                                                    \
  90                 WREG8(DAC_INDEX, reg);                          \
  91                 WREG8(DAC_DATA, v);                             \
  92         } while (0)                                             \
  93
  94 #define MGA_MISC_OUT 0x1fc2
  95 #define MGA_MISC_IN 0x1fcc
  96
  97 #define MGAG200_MAX_FB_HEIGHT 4096
  98 #define MGAG200_MAX_FB_WIDTH 4096
  99
 100 #define MATROX_DPMS_CLEARED (-1)
 101
 102 #define to_mga_crtc(x) container_of(x, struct mga_crtc, base)
 103 #define to_mga_encoder(x) container_of(x, struct mga_encoder, base)
 104 #define to_mga_connector(x) container_of(x, struct mga_connector, base)
 105 #define to_mga_framebuffer(x) container_of(x, struct mga_framebuffer, base)
 106
 107 struct mga_framebuffer {
 108         struct drm_framebuffer base;
 109         struct drm_gem_object *obj;
 110 };
 111
 112 struct mga_fbdev {
 113         struct drm_fb_helper helper;
 114         struct mga_framebuffer mfb;
 115         void *sysram;
 116         int size;
 117         struct ttm_bo_kmap_obj mapping;
 118         int x1, y1, x2, y2; /* dirty rect */
 119         spinlock_t dirty_lock;
 120 };
 121
 122 struct mga_crtc {
 123         struct drm_crtc base;
 124         u8 lut_r[256], lut_g[256], lut_b[256];
 125         int last_dpms;
 126         bool enabled;
 127 };
 128
 129 struct mga_mode_info {
 130         bool mode_config_initialized;
 131         struct mga_crtc *crtc;
 132 };
 133
 134 struct mga_encoder {
 135         struct drm_encoder base;
 136         int last_dpms;
 137 };
 138
 139
 140 struct mga_i2c_chan {
 141         struct i2c_adapter adapter;
 142         struct drm_device *dev;
 143         struct i2c_algo_bit_data bit;
 144         int data, clock;
 145 };
 146
 147 struct mga_connector {
 148         struct drm_connector base;
 149         struct mga_i2c_chan *i2c;
 150 };
 151
 152
 153 struct mga_mc {
 154         resource_size_t                 vram_size;
 155         resource_size_t                 vram_base;
 156         resource_size_t                 vram_window;
 157 };
 158
 159 enum mga_type {
 160         G200_SE_A,
 161         G200_SE_B,
 162         G200_WB,
 163         G200_EV,
 164         G200_EH,
 165         G200_ER,
 166 };
 167
 168 #define IS_G200_SE(mdev) (mdev->type == G200_SE_A || mdev->type == G200_SE_B)
 169
 170 struct mga_device {
 171         struct drm_device               *dev;
 172         unsigned long                   flags;
 173
 174         resource_size_t                 rmmio_base;
 175         resource_size_t                 rmmio_size;
 176         void __iomem                    *rmmio;
 177
 178         drm_local_map_t                 *framebuffer;
 179
 180         struct mga_mc                   mc;
 181         struct mga_mode_info            mode_info;
 182
 183         struct mga_fbdev *mfbdev;
 184
 185         bool                            suspended;
 186         int                             num_crtc;
 187         enum mga_type                   type;
 188         int                             has_sdram;
 189         struct drm_display_mode         mode;
 190
 191         int bpp_shifts[4];
 192
 193         int fb_mtrr;
 194
 195         struct {
 196                 struct drm_global_reference mem_global_ref;
 197                 struct ttm_bo_global_ref bo_global_ref;
 198                 struct ttm_bo_device bdev;
 199         } ttm;
 200
 201         /* SE model number stored in reg 0x1e24 */
 202         u32 unique_rev_id;
 203 };
 204
 205
 206 struct mgag200_bo {
 207         struct ttm_buffer_object bo;
 208         struct ttm_placement placement;
 209         struct ttm_bo_kmap_obj kmap;
 210         struct drm_gem_object gem;
 211         u32 placements[3];
 212         int pin_count;
 213 };
 214 #define gem_to_mga_bo(gobj) container_of((gobj), struct mgag200_bo, gem)
 215
 216 static inline struct mgag200_bo *
 217 mgag200_bo(struct ttm_buffer_object *bo)
 218 {
 219         return container_of(bo, struct mgag200_bo, bo);
 220 }
 221                                 /* mgag200_crtc.c */
 222 void mga_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
 223                              u16 blue, int regno);
 224 void mga_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
 225                              u16 *blue, int regno);
 226
 227                                 /* mgag200_mode.c */
 228 int mgag200_modeset_init(struct mga_device *mdev);
 229 void mgag200_modeset_fini(struct mga_device *mdev);
 230
 231                                 /* mgag200_fb.c */
 232 int mgag200_fbdev_init(struct mga_device *mdev);
 233 void mgag200_fbdev_fini(struct mga_device *mdev);
 234
 235                                 /* mgag200_main.c */
 236 int mgag200_framebuffer_init(struct drm_device *dev,
 237                              struct mga_framebuffer *mfb,
 238                              struct drm_mode_fb_cmd2 *mode_cmd,
 239                              struct drm_gem_object *obj);
 240
 241
 242 int mgag200_driver_load(struct drm_device *dev, unsigned long flags);
 243 int mgag200_driver_unload(struct drm_device *dev);
 244 int mgag200_gem_create(struct drm_device *dev,
 245                    u32 size, bool iskernel,
 246                        struct drm_gem_object **obj);
 247 int mgag200_gem_init_object(struct drm_gem_object *obj);
 248 int mgag200_dumb_create(struct drm_file *file,
 249                         struct drm_device *dev,
 250                         struct drm_mode_create_dumb *args);
 251 int mgag200_dumb_destroy(struct drm_file *file,
 252                          struct drm_device *dev,
 253                          uint32_t handle);
 254 void mgag200_gem_free_object(struct drm_gem_object *obj);
 255 int
 256 mgag200_dumb_mmap_offset(struct drm_file *file,
 257                          struct drm_device *dev,
 258                          uint32_t handle,
 259                          uint64_t *offset);
 260                                 /* mgag200_i2c.c */
 261 struct mga_i2c_chan *mgag200_i2c_create(struct drm_device *dev);
 262 void mgag200_i2c_destroy(struct mga_i2c_chan *i2c);
 263
 264 #define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT)
 265 void mgag200_ttm_placement(struct mgag200_bo *bo, int domain);
 266
 267 int mgag200_bo_reserve(struct mgag200_bo *bo, bool no_wait);
 268 void mgag200_bo_unreserve(struct mgag200_bo *bo);
 269 int mgag200_bo_create(struct drm_device *dev, int size, int align,
 270                       uint32_t flags, struct mgag200_bo **pastbo);
 271 int mgag200_mm_init(struct mga_device *mdev);
 272 void mgag200_mm_fini(struct mga_device *mdev);
 273 int mgag200_mmap(struct file *filp, struct vm_area_struct *vma);
 274 int mgag200_bo_pin(struct mgag200_bo *bo, u32 pl_flag, u64 *gpu_addr);
 275 int mgag200_bo_unpin(struct mgag200_bo *bo);
 276 int mgag200_bo_push_sysram(struct mgag200_bo *bo);
 277 #endif                          /* __MGAG200_DRV_H__ */