2012-04-17 08:01:25 -06:00
|
|
|
/*
|
|
|
|
* Copyright 2010 Matt Turner.
|
|
|
|
* Copyright 2012 Red Hat
|
|
|
|
*
|
|
|
|
* This file is subject to the terms and conditions of the GNU General
|
|
|
|
* Public License version 2. See the file COPYING in the main
|
|
|
|
* directory of this archive for more details.
|
|
|
|
*
|
|
|
|
* Authors: Matthew Garrett
|
|
|
|
* Matt Turner
|
|
|
|
* Dave Airlie
|
|
|
|
*/
|
|
|
|
#ifndef __MGAG200_DRV_H__
|
|
|
|
#define __MGAG200_DRV_H__
|
|
|
|
|
|
|
|
#include <video/vga.h>
|
|
|
|
|
2012-10-02 11:01:07 -06:00
|
|
|
#include <drm/drm_fb_helper.h>
|
|
|
|
#include <drm/ttm/ttm_bo_api.h>
|
|
|
|
#include <drm/ttm/ttm_bo_driver.h>
|
|
|
|
#include <drm/ttm/ttm_placement.h>
|
|
|
|
#include <drm/ttm/ttm_memory.h>
|
|
|
|
#include <drm/ttm/ttm_module.h>
|
2012-04-17 08:01:25 -06:00
|
|
|
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/i2c-algo-bit.h>
|
|
|
|
|
|
|
|
#include "mgag200_reg.h"
|
|
|
|
|
|
|
|
#define DRIVER_AUTHOR "Matthew Garrett"
|
|
|
|
|
|
|
|
#define DRIVER_NAME "mgag200"
|
|
|
|
#define DRIVER_DESC "MGA G200 SE"
|
|
|
|
#define DRIVER_DATE "20110418"
|
|
|
|
|
|
|
|
#define DRIVER_MAJOR 1
|
|
|
|
#define DRIVER_MINOR 0
|
|
|
|
#define DRIVER_PATCHLEVEL 0
|
|
|
|
|
|
|
|
#define MGAG200FB_CONN_LIMIT 1
|
|
|
|
|
|
|
|
#define RREG8(reg) ioread8(((void __iomem *)mdev->rmmio) + (reg))
|
|
|
|
#define WREG8(reg, v) iowrite8(v, ((void __iomem *)mdev->rmmio) + (reg))
|
|
|
|
#define RREG32(reg) ioread32(((void __iomem *)mdev->rmmio) + (reg))
|
|
|
|
#define WREG32(reg, v) iowrite32(v, ((void __iomem *)mdev->rmmio) + (reg))
|
|
|
|
|
|
|
|
#define ATTR_INDEX 0x1fc0
|
|
|
|
#define ATTR_DATA 0x1fc1
|
|
|
|
|
|
|
|
#define WREG_ATTR(reg, v) \
|
|
|
|
do { \
|
|
|
|
RREG8(0x1fda); \
|
|
|
|
WREG8(ATTR_INDEX, reg); \
|
|
|
|
WREG8(ATTR_DATA, v); \
|
|
|
|
} while (0) \
|
|
|
|
|
|
|
|
#define WREG_SEQ(reg, v) \
|
|
|
|
do { \
|
|
|
|
WREG8(MGAREG_SEQ_INDEX, reg); \
|
|
|
|
WREG8(MGAREG_SEQ_DATA, v); \
|
|
|
|
} while (0) \
|
|
|
|
|
|
|
|
#define WREG_CRT(reg, v) \
|
|
|
|
do { \
|
|
|
|
WREG8(MGAREG_CRTC_INDEX, reg); \
|
|
|
|
WREG8(MGAREG_CRTC_DATA, v); \
|
|
|
|
} while (0) \
|
|
|
|
|
|
|
|
|
|
|
|
#define WREG_ECRT(reg, v) \
|
|
|
|
do { \
|
|
|
|
WREG8(MGAREG_CRTCEXT_INDEX, reg); \
|
|
|
|
WREG8(MGAREG_CRTCEXT_DATA, v); \
|
|
|
|
} while (0) \
|
|
|
|
|
|
|
|
#define GFX_INDEX 0x1fce
|
|
|
|
#define GFX_DATA 0x1fcf
|
|
|
|
|
|
|
|
#define WREG_GFX(reg, v) \
|
|
|
|
do { \
|
|
|
|
WREG8(GFX_INDEX, reg); \
|
|
|
|
WREG8(GFX_DATA, v); \
|
|
|
|
} while (0) \
|
|
|
|
|
|
|
|
#define DAC_INDEX 0x3c00
|
|
|
|
#define DAC_DATA 0x3c0a
|
|
|
|
|
|
|
|
#define WREG_DAC(reg, v) \
|
|
|
|
do { \
|
|
|
|
WREG8(DAC_INDEX, reg); \
|
|
|
|
WREG8(DAC_DATA, v); \
|
|
|
|
} while (0) \
|
|
|
|
|
|
|
|
#define MGA_MISC_OUT 0x1fc2
|
|
|
|
#define MGA_MISC_IN 0x1fcc
|
|
|
|
|
|
|
|
#define MGAG200_MAX_FB_HEIGHT 4096
|
|
|
|
#define MGAG200_MAX_FB_WIDTH 4096
|
|
|
|
|
|
|
|
#define MATROX_DPMS_CLEARED (-1)
|
|
|
|
|
|
|
|
#define to_mga_crtc(x) container_of(x, struct mga_crtc, base)
|
|
|
|
#define to_mga_encoder(x) container_of(x, struct mga_encoder, base)
|
|
|
|
#define to_mga_connector(x) container_of(x, struct mga_connector, base)
|
|
|
|
#define to_mga_framebuffer(x) container_of(x, struct mga_framebuffer, base)
|
|
|
|
|
|
|
|
struct mga_framebuffer {
|
|
|
|
struct drm_framebuffer base;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mga_fbdev {
|
|
|
|
struct drm_fb_helper helper;
|
|
|
|
struct mga_framebuffer mfb;
|
|
|
|
void *sysram;
|
|
|
|
int size;
|
|
|
|
struct ttm_bo_kmap_obj mapping;
|
2013-05-01 22:52:01 -06:00
|
|
|
int x1, y1, x2, y2; /* dirty rect */
|
|
|
|
spinlock_t dirty_lock;
|
2012-04-17 08:01:25 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct mga_crtc {
|
|
|
|
struct drm_crtc base;
|
|
|
|
u8 lut_r[256], lut_g[256], lut_b[256];
|
|
|
|
int last_dpms;
|
|
|
|
bool enabled;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mga_mode_info {
|
|
|
|
bool mode_config_initialized;
|
|
|
|
struct mga_crtc *crtc;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mga_encoder {
|
|
|
|
struct drm_encoder base;
|
|
|
|
int last_dpms;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct mga_i2c_chan {
|
|
|
|
struct i2c_adapter adapter;
|
|
|
|
struct drm_device *dev;
|
|
|
|
struct i2c_algo_bit_data bit;
|
|
|
|
int data, clock;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct mga_connector {
|
|
|
|
struct drm_connector base;
|
|
|
|
struct mga_i2c_chan *i2c;
|
|
|
|
};
|
|
|
|
|
drm/mgag200: Hardware cursor support
G200 cards support, at best, 16 colour palleted images for the cursor
so we do a conversion in the cursor_set function, and reject cursors
with more than 16 colours, or cursors with partial transparency. Xorg
falls back gracefully to software cursors in this case.
We can't disable/enable the cursor hardware without causing momentary
corruption around the cursor. Instead, once the cursor is on we leave
it on, and simulate turning the cursor off by moving it
offscreen. This works well.
Since we can't disable -> update -> enable the cursors, we double
buffer cursor icons, then just move the base address that points to
the old cursor, to the new. This also works well, but uses an extra
page of memory.
The cursor buffers are lazily-allocated on first cursor_set. This is
to make sure they don't take priority over any framebuffers in case of
limited memory.
Here is a representation of how the bitmap for the cursor is mapped in G200 memory :
Each line of color cursor use 6 Slices of 8 bytes. Slices 0 to 3
are used for the 4bpp bitmap, slice 4 for XOR mask and slice 5 for
AND mask. Each line has the following format:
// Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7
//
// S0: P00-01 P02-03 P04-05 P06-07 P08-09 P10-11 P12-13 P14-15
// S1: P16-17 P18-19 P20-21 P22-23 P24-25 P26-27 P28-29 P30-31
// S2: P32-33 P34-35 P36-37 P38-39 P40-41 P42-43 P44-45 P46-47
// S3: P48-49 P50-51 P52-53 P54-55 P56-57 P58-59 P60-61 P62-63
// S4: X63-56 X55-48 X47-40 X39-32 X31-24 X23-16 X15-08 X07-00
// S5: A63-56 A55-48 A47-40 A39-32 A31-24 A23-16 A15-08 A07-00
//
// S0 to S5 = Slices 0 to 5
// P00 to P63 = Bitmap - pixels 0 to 63
// X00 to X63 = always 0 - pixels 0 to 63
// A00 to A63 = transparent markers - pixels 0 to 63
// 1 means colour, 0 means transparent
Signed-off-by: Christopher Harvey <charvey@matrox.com>
Signed-off-by: Mathieu Larouche <mathieu.larouche@matrox.com>
Acked-by: Julia Lemire <jlemire@matrox.com>
Tested-by: Julia Lemire <jlemire@matrox.com>
Signed-off-by: Dave Airlie <airlied@gmail.com>
2013-06-05 13:24:26 -06:00
|
|
|
struct mga_cursor {
|
|
|
|
/*
|
|
|
|
We have to have 2 buffers for the cursor to avoid occasional
|
|
|
|
corruption while switching cursor icons.
|
|
|
|
If either of these is NULL, then don't do hardware cursors, and
|
|
|
|
fall back to software.
|
|
|
|
*/
|
|
|
|
struct mgag200_bo *pixels_1;
|
|
|
|
struct mgag200_bo *pixels_2;
|
|
|
|
u64 pixels_1_gpu_addr, pixels_2_gpu_addr;
|
|
|
|
/* The currently displayed icon, this points to one of pixels_1, or pixels_2 */
|
|
|
|
struct mgag200_bo *pixels_current;
|
|
|
|
/* The previously displayed icon */
|
|
|
|
struct mgag200_bo *pixels_prev;
|
|
|
|
};
|
2012-04-17 08:01:25 -06:00
|
|
|
|
|
|
|
struct mga_mc {
|
|
|
|
resource_size_t vram_size;
|
|
|
|
resource_size_t vram_base;
|
|
|
|
resource_size_t vram_window;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum mga_type {
|
|
|
|
G200_SE_A,
|
|
|
|
G200_SE_B,
|
|
|
|
G200_WB,
|
|
|
|
G200_EV,
|
|
|
|
G200_EH,
|
|
|
|
G200_ER,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define IS_G200_SE(mdev) (mdev->type == G200_SE_A || mdev->type == G200_SE_B)
|
|
|
|
|
|
|
|
struct mga_device {
|
|
|
|
struct drm_device *dev;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
resource_size_t rmmio_base;
|
|
|
|
resource_size_t rmmio_size;
|
|
|
|
void __iomem *rmmio;
|
|
|
|
|
|
|
|
struct mga_mc mc;
|
|
|
|
struct mga_mode_info mode_info;
|
|
|
|
|
|
|
|
struct mga_fbdev *mfbdev;
|
drm/mgag200: Hardware cursor support
G200 cards support, at best, 16 colour palleted images for the cursor
so we do a conversion in the cursor_set function, and reject cursors
with more than 16 colours, or cursors with partial transparency. Xorg
falls back gracefully to software cursors in this case.
We can't disable/enable the cursor hardware without causing momentary
corruption around the cursor. Instead, once the cursor is on we leave
it on, and simulate turning the cursor off by moving it
offscreen. This works well.
Since we can't disable -> update -> enable the cursors, we double
buffer cursor icons, then just move the base address that points to
the old cursor, to the new. This also works well, but uses an extra
page of memory.
The cursor buffers are lazily-allocated on first cursor_set. This is
to make sure they don't take priority over any framebuffers in case of
limited memory.
Here is a representation of how the bitmap for the cursor is mapped in G200 memory :
Each line of color cursor use 6 Slices of 8 bytes. Slices 0 to 3
are used for the 4bpp bitmap, slice 4 for XOR mask and slice 5 for
AND mask. Each line has the following format:
// Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7
//
// S0: P00-01 P02-03 P04-05 P06-07 P08-09 P10-11 P12-13 P14-15
// S1: P16-17 P18-19 P20-21 P22-23 P24-25 P26-27 P28-29 P30-31
// S2: P32-33 P34-35 P36-37 P38-39 P40-41 P42-43 P44-45 P46-47
// S3: P48-49 P50-51 P52-53 P54-55 P56-57 P58-59 P60-61 P62-63
// S4: X63-56 X55-48 X47-40 X39-32 X31-24 X23-16 X15-08 X07-00
// S5: A63-56 A55-48 A47-40 A39-32 A31-24 A23-16 A15-08 A07-00
//
// S0 to S5 = Slices 0 to 5
// P00 to P63 = Bitmap - pixels 0 to 63
// X00 to X63 = always 0 - pixels 0 to 63
// A00 to A63 = transparent markers - pixels 0 to 63
// 1 means colour, 0 means transparent
Signed-off-by: Christopher Harvey <charvey@matrox.com>
Signed-off-by: Mathieu Larouche <mathieu.larouche@matrox.com>
Acked-by: Julia Lemire <jlemire@matrox.com>
Tested-by: Julia Lemire <jlemire@matrox.com>
Signed-off-by: Dave Airlie <airlied@gmail.com>
2013-06-05 13:24:26 -06:00
|
|
|
struct mga_cursor cursor;
|
2012-04-17 08:01:25 -06:00
|
|
|
|
|
|
|
bool suspended;
|
|
|
|
int num_crtc;
|
|
|
|
enum mga_type type;
|
|
|
|
int has_sdram;
|
|
|
|
struct drm_display_mode mode;
|
|
|
|
|
|
|
|
int bpp_shifts[4];
|
|
|
|
|
|
|
|
int fb_mtrr;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
struct drm_global_reference mem_global_ref;
|
|
|
|
struct ttm_bo_global_ref bo_global_ref;
|
|
|
|
struct ttm_bo_device bdev;
|
|
|
|
} ttm;
|
|
|
|
|
2013-06-27 11:38:59 -06:00
|
|
|
/* SE model number stored in reg 0x1e24 */
|
|
|
|
u32 unique_rev_id;
|
2012-04-17 08:01:25 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct mgag200_bo {
|
|
|
|
struct ttm_buffer_object bo;
|
|
|
|
struct ttm_placement placement;
|
|
|
|
struct ttm_bo_kmap_obj kmap;
|
|
|
|
struct drm_gem_object gem;
|
2014-08-27 05:16:04 -06:00
|
|
|
struct ttm_place placements[3];
|
2012-04-17 08:01:25 -06:00
|
|
|
int pin_count;
|
|
|
|
};
|
|
|
|
#define gem_to_mga_bo(gobj) container_of((gobj), struct mgag200_bo, gem)
|
|
|
|
|
|
|
|
static inline struct mgag200_bo *
|
|
|
|
mgag200_bo(struct ttm_buffer_object *bo)
|
|
|
|
{
|
|
|
|
return container_of(bo, struct mgag200_bo, bo);
|
|
|
|
}
|
2013-04-05 09:28:32 -06:00
|
|
|
/* mgag200_crtc.c */
|
2012-04-17 08:01:25 -06:00
|
|
|
void mga_crtc_fb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
|
|
|
|
u16 blue, int regno);
|
|
|
|
void mga_crtc_fb_gamma_get(struct drm_crtc *crtc, u16 *red, u16 *green,
|
|
|
|
u16 *blue, int regno);
|
|
|
|
|
|
|
|
/* mgag200_mode.c */
|
|
|
|
int mgag200_modeset_init(struct mga_device *mdev);
|
|
|
|
void mgag200_modeset_fini(struct mga_device *mdev);
|
|
|
|
|
2013-04-05 09:28:32 -06:00
|
|
|
/* mgag200_fb.c */
|
2012-04-17 08:01:25 -06:00
|
|
|
int mgag200_fbdev_init(struct mga_device *mdev);
|
|
|
|
void mgag200_fbdev_fini(struct mga_device *mdev);
|
|
|
|
|
|
|
|
/* mgag200_main.c */
|
|
|
|
int mgag200_framebuffer_init(struct drm_device *dev,
|
|
|
|
struct mga_framebuffer *mfb,
|
|
|
|
struct drm_mode_fb_cmd2 *mode_cmd,
|
|
|
|
struct drm_gem_object *obj);
|
|
|
|
|
|
|
|
|
|
|
|
int mgag200_driver_load(struct drm_device *dev, unsigned long flags);
|
|
|
|
int mgag200_driver_unload(struct drm_device *dev);
|
|
|
|
int mgag200_gem_create(struct drm_device *dev,
|
|
|
|
u32 size, bool iskernel,
|
|
|
|
struct drm_gem_object **obj);
|
|
|
|
int mgag200_dumb_create(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args);
|
|
|
|
void mgag200_gem_free_object(struct drm_gem_object *obj);
|
|
|
|
int
|
|
|
|
mgag200_dumb_mmap_offset(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle,
|
|
|
|
uint64_t *offset);
|
2013-04-05 09:28:32 -06:00
|
|
|
/* mgag200_i2c.c */
|
2012-04-17 08:01:25 -06:00
|
|
|
struct mga_i2c_chan *mgag200_i2c_create(struct drm_device *dev);
|
|
|
|
void mgag200_i2c_destroy(struct mga_i2c_chan *i2c);
|
|
|
|
|
|
|
|
#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT)
|
|
|
|
void mgag200_ttm_placement(struct mgag200_bo *bo, int domain);
|
|
|
|
|
2013-06-27 05:48:22 -06:00
|
|
|
static inline int mgag200_bo_reserve(struct mgag200_bo *bo, bool no_wait)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2014-07-21 05:15:51 -06:00
|
|
|
ret = ttm_bo_reserve(&bo->bo, true, no_wait, false, NULL);
|
2013-06-27 05:48:22 -06:00
|
|
|
if (ret) {
|
|
|
|
if (ret != -ERESTARTSYS && ret != -EBUSY)
|
|
|
|
DRM_ERROR("reserve failed %p\n", bo);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void mgag200_bo_unreserve(struct mgag200_bo *bo)
|
|
|
|
{
|
|
|
|
ttm_bo_unreserve(&bo->bo);
|
|
|
|
}
|
|
|
|
|
2012-04-17 08:01:25 -06:00
|
|
|
int mgag200_bo_create(struct drm_device *dev, int size, int align,
|
|
|
|
uint32_t flags, struct mgag200_bo **pastbo);
|
|
|
|
int mgag200_mm_init(struct mga_device *mdev);
|
|
|
|
void mgag200_mm_fini(struct mga_device *mdev);
|
|
|
|
int mgag200_mmap(struct file *filp, struct vm_area_struct *vma);
|
|
|
|
int mgag200_bo_pin(struct mgag200_bo *bo, u32 pl_flag, u64 *gpu_addr);
|
|
|
|
int mgag200_bo_unpin(struct mgag200_bo *bo);
|
|
|
|
int mgag200_bo_push_sysram(struct mgag200_bo *bo);
|
drm/mgag200: Hardware cursor support
G200 cards support, at best, 16 colour palleted images for the cursor
so we do a conversion in the cursor_set function, and reject cursors
with more than 16 colours, or cursors with partial transparency. Xorg
falls back gracefully to software cursors in this case.
We can't disable/enable the cursor hardware without causing momentary
corruption around the cursor. Instead, once the cursor is on we leave
it on, and simulate turning the cursor off by moving it
offscreen. This works well.
Since we can't disable -> update -> enable the cursors, we double
buffer cursor icons, then just move the base address that points to
the old cursor, to the new. This also works well, but uses an extra
page of memory.
The cursor buffers are lazily-allocated on first cursor_set. This is
to make sure they don't take priority over any framebuffers in case of
limited memory.
Here is a representation of how the bitmap for the cursor is mapped in G200 memory :
Each line of color cursor use 6 Slices of 8 bytes. Slices 0 to 3
are used for the 4bpp bitmap, slice 4 for XOR mask and slice 5 for
AND mask. Each line has the following format:
// Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7
//
// S0: P00-01 P02-03 P04-05 P06-07 P08-09 P10-11 P12-13 P14-15
// S1: P16-17 P18-19 P20-21 P22-23 P24-25 P26-27 P28-29 P30-31
// S2: P32-33 P34-35 P36-37 P38-39 P40-41 P42-43 P44-45 P46-47
// S3: P48-49 P50-51 P52-53 P54-55 P56-57 P58-59 P60-61 P62-63
// S4: X63-56 X55-48 X47-40 X39-32 X31-24 X23-16 X15-08 X07-00
// S5: A63-56 A55-48 A47-40 A39-32 A31-24 A23-16 A15-08 A07-00
//
// S0 to S5 = Slices 0 to 5
// P00 to P63 = Bitmap - pixels 0 to 63
// X00 to X63 = always 0 - pixels 0 to 63
// A00 to A63 = transparent markers - pixels 0 to 63
// 1 means colour, 0 means transparent
Signed-off-by: Christopher Harvey <charvey@matrox.com>
Signed-off-by: Mathieu Larouche <mathieu.larouche@matrox.com>
Acked-by: Julia Lemire <jlemire@matrox.com>
Tested-by: Julia Lemire <jlemire@matrox.com>
Signed-off-by: Dave Airlie <airlied@gmail.com>
2013-06-05 13:24:26 -06:00
|
|
|
/* mgag200_cursor.c */
|
|
|
|
int mga_crtc_cursor_set(struct drm_crtc *crtc, struct drm_file *file_priv,
|
|
|
|
uint32_t handle, uint32_t width, uint32_t height);
|
|
|
|
int mga_crtc_cursor_move(struct drm_crtc *crtc, int x, int y);
|
|
|
|
|
2012-04-17 08:01:25 -06:00
|
|
|
#endif /* __MGAG200_DRV_H__ */
|