public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-09-18 22:14:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

drm/mgag200: Store HW_BUG_NO_STARTADD flag in device info

Browse source 
Flag devices with broken handling of the startadd field in
struct mgag200_device_info, instead of PCI driver data. This
reduces the driver data to a simple type constant.

Signed-off-by: Thomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: Jocelyn Falempe <jfalempe@redhat.com>
Tested-by: Jocelyn Falempe <jfalempe@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20220601112522.5774-8-tzimmermann@suse.de
This commit is contained in:
Thomas Zimmermann 2022-06-01 13:25:19 +02:00
parent b9a577a407
commit 21e74bf995
11 changed files with 69 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
drivers/gpu/drm/mgag200/mgag200_drv.c
View file

@ -162,14 +162,13 @@ int mgag200_device_preinit(struct mga_device *mdev)
return 0; return 0;
} }
int mgag200_device_init(struct mga_device *mdev, enum mga_type type, unsigned long flags, int mgag200_device_init(struct mga_device *mdev, enum mga_type type,
const struct mgag200_device_info *info) const struct mgag200_device_info *info)
{ {
struct drm_device *dev = &mdev->base; struct drm_device *dev = &mdev->base;
u8 crtcext3, misc; u8 crtcext3, misc;
int ret; int ret;
mdev->flags = flags;
mdev->info = info; mdev->info = info;
mdev->type = type; mdev->type = type;
@ -202,8 +201,7 @@ int mgag200_device_init(struct mga_device *mdev, enum mga_type type, unsigned lo
static const struct pci_device_id mgag200_pciidlist[] = { static const struct pci_device_id mgag200_pciidlist[] = {
{ PCI_VENDOR_ID_MATROX, 0x520, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_PCI }, { PCI_VENDOR_ID_MATROX, 0x520, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_PCI },
{ PCI_VENDOR_ID_MATROX, 0x521, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_AGP }, { PCI_VENDOR_ID_MATROX, 0x521, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_AGP },
{ PCI_VENDOR_ID_MATROX, 0x522, PCI_ANY_ID, PCI_ANY_ID, 0, 0, { PCI_VENDOR_ID_MATROX, 0x522, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_SE_A },
G200_SE_A | MGAG200_FLAG_HW_BUG_NO_STARTADD},
{ PCI_VENDOR_ID_MATROX, 0x524, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_SE_B }, { PCI_VENDOR_ID_MATROX, 0x524, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_SE_B },
{ PCI_VENDOR_ID_MATROX, 0x530, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_EV }, { PCI_VENDOR_ID_MATROX, 0x530, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_EV },
{ PCI_VENDOR_ID_MATROX, 0x532, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_WB }, { PCI_VENDOR_ID_MATROX, 0x532, PCI_ANY_ID, PCI_ANY_ID, 0, 0, G200_WB },
@ -216,22 +214,10 @@ static const struct pci_device_id mgag200_pciidlist[] = {
MODULE_DEVICE_TABLE(pci, mgag200_pciidlist); MODULE_DEVICE_TABLE(pci, mgag200_pciidlist);
static enum mga_type mgag200_type_from_driver_data(kernel_ulong_t driver_data)
{
return (enum mga_type)(driver_data & MGAG200_TYPE_MASK);
}
static unsigned long mgag200_flags_from_driver_data(kernel_ulong_t driver_data)
{
return driver_data & MGAG200_FLAG_MASK;
}
static int static int
mgag200_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) mgag200_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{ {
kernel_ulong_t driver_data = ent->driver_data; enum mga_type type = (enum mga_type)ent->driver_data;
enum mga_type type = mgag200_type_from_driver_data(driver_data);
unsigned long flags = mgag200_flags_from_driver_data(driver_data);
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
int ret; int ret;
@ -247,29 +233,29 @@ mgag200_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
switch (type) { switch (type) {
case G200_PCI: case G200_PCI:
case G200_AGP: case G200_AGP:
mdev = mgag200_g200_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_SE_A: case G200_SE_A:
case G200_SE_B: case G200_SE_B:
mdev = mgag200_g200se_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200se_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_WB: case G200_WB:
mdev = mgag200_g200wb_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200wb_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_EV: case G200_EV:
mdev = mgag200_g200ev_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200ev_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_EH: case G200_EH:
mdev = mgag200_g200eh_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200eh_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_EH3: case G200_EH3:
mdev = mgag200_g200eh3_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200eh3_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_ER: case G200_ER:
mdev = mgag200_g200er_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200er_device_create(pdev, &mgag200_driver, type);
break; break;
case G200_EW3: case G200_EW3:
mdev = mgag200_g200ew3_device_create(pdev, &mgag200_driver, type, flags); mdev = mgag200_g200ew3_device_create(pdev, &mgag200_driver, type);
break; break;
default: default:
dev_err(&pdev->dev, "Device type %d is unsupported\n", type); dev_err(&pdev->dev, "Device type %d is unsupported\n", type);

33
drivers/gpu/drm/mgag200/mgag200_drv.h
View file

@ -188,24 +188,23 @@ enum mga_type {
G200_EW3, G200_EW3,
}; };
/* HW does not handle 'startadd' field correct. */
#define MGAG200_FLAG_HW_BUG_NO_STARTADD (1ul << 8)
#define MGAG200_TYPE_MASK (0x000000ff)
#define MGAG200_FLAG_MASK (0x00ffff00)
#define IS_G200_SE(mdev) (mdev->type == G200_SE_A || mdev->type == G200_SE_B) #define IS_G200_SE(mdev) (mdev->type == G200_SE_A || mdev->type == G200_SE_B)
struct mgag200_device_info { struct mgag200_device_info {
/*
* HW does not handle 'startadd' register correctly. Always set
* it's value to 0.
*/
bool bug_no_startadd:1;
}; };
#define MGAG200_DEVICE_INFO_INIT() \ #define MGAG200_DEVICE_INFO_INIT(_bug_no_startadd) \
{ \ { \
.bug_no_startadd = (_bug_no_startadd), \
} }
struct mga_device { struct mga_device {
struct drm_device base; struct drm_device base;
unsigned long flags;
const struct mgag200_device_info *info; const struct mgag200_device_info *info;
@ -261,26 +260,26 @@ int mgag200_init_pci_options(struct pci_dev *pdev, u32 option, u32 option2);
resource_size_t mgag200_probe_vram(void __iomem *mem, resource_size_t size); resource_size_t mgag200_probe_vram(void __iomem *mem, resource_size_t size);
resource_size_t mgag200_device_probe_vram(struct mga_device *mdev); resource_size_t mgag200_device_probe_vram(struct mga_device *mdev);
int mgag200_device_preinit(struct mga_device *mdev); int mgag200_device_preinit(struct mga_device *mdev);
int mgag200_device_init(struct mga_device *mdev, enum mga_type type, unsigned long flags, int mgag200_device_init(struct mga_device *mdev, enum mga_type type,
const struct mgag200_device_info *info); const struct mgag200_device_info *info);
/* mgag200_<device type>.c */ /* mgag200_<device type>.c */
struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200er_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200er_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
struct mga_device *mgag200_g200ew3_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200ew3_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags); enum mga_type type);
/* mgag200_mode.c */ /* mgag200_mode.c */
resource_size_t mgag200_device_probe_vram(struct mga_device *mdev); resource_size_t mgag200_device_probe_vram(struct mga_device *mdev);

6
drivers/gpu/drm/mgag200/mgag200_g200.c
View file

@ -34,7 +34,7 @@ static int mgag200_g200_init_pci_options(struct pci_dev *pdev)
*/ */
static const struct mgag200_device_info mgag200_g200_device_info = static const struct mgag200_device_info mgag200_g200_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
static void mgag200_g200_interpret_bios(struct mgag200_g200_device *g200, static void mgag200_g200_interpret_bios(struct mgag200_g200_device *g200,
const unsigned char *bios, size_t size) const unsigned char *bios, size_t size)
@ -160,7 +160,7 @@ out:
} }
struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mgag200_g200_device *g200; struct mgag200_g200_device *g200;
struct mga_device *mdev; struct mga_device *mdev;
@ -186,7 +186,7 @@ struct mga_device *mgag200_g200_device_create(struct pci_dev *pdev, const struct
mgag200_g200_init_refclk(g200); mgag200_g200_init_refclk(g200);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

6
drivers/gpu/drm/mgag200/mgag200_g200eh.c
View file

@ -11,10 +11,10 @@
*/ */
static const struct mgag200_device_info mgag200_g200eh_device_info = static const struct mgag200_device_info mgag200_g200eh_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
@ -36,7 +36,7 @@ struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev, const stru
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200eh_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200eh_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

6
drivers/gpu/drm/mgag200/mgag200_g200eh3.c
View file

@ -11,11 +11,11 @@
*/ */
static const struct mgag200_device_info mgag200_g200eh3_device_info = static const struct mgag200_device_info mgag200_g200eh3_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev, struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev,
const struct drm_driver *drv, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
@ -37,7 +37,7 @@ struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev,
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200eh3_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200eh3_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

6
drivers/gpu/drm/mgag200/mgag200_g200er.c
View file

@ -11,10 +11,10 @@
*/ */
static const struct mgag200_device_info mgag200_g200er_device_info = static const struct mgag200_device_info mgag200_g200er_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
struct mga_device *mgag200_g200er_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200er_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
@ -32,7 +32,7 @@ struct mga_device *mgag200_g200er_device_create(struct pci_dev *pdev, const stru
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200er_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200er_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

6
drivers/gpu/drm/mgag200/mgag200_g200ev.c
View file

@ -11,10 +11,10 @@
*/ */
static const struct mgag200_device_info mgag200_g200ev_device_info = static const struct mgag200_device_info mgag200_g200ev_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
@ -36,7 +36,7 @@ struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const stru
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200ev_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200ev_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

6
drivers/gpu/drm/mgag200/mgag200_g200ew3.c
View file

@ -11,7 +11,7 @@
*/ */
static const struct mgag200_device_info mgag200_g200ew3_device_info = static const struct mgag200_device_info mgag200_g200ew3_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
static resource_size_t mgag200_g200ew3_device_probe_vram(struct mga_device *mdev) static resource_size_t mgag200_g200ew3_device_probe_vram(struct mga_device *mdev)
{ {
@ -24,7 +24,7 @@ static resource_size_t mgag200_g200ew3_device_probe_vram(struct mga_device *mdev
struct mga_device *mgag200_g200ew3_device_create(struct pci_dev *pdev, struct mga_device *mgag200_g200ew3_device_create(struct pci_dev *pdev,
const struct drm_driver *drv, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
@ -46,7 +46,7 @@ struct mga_device *mgag200_g200ew3_device_create(struct pci_dev *pdev,
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200ew3_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200ew3_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

23
drivers/gpu/drm/mgag200/mgag200_g200se.c
View file

@ -32,8 +32,11 @@ static int mgag200_g200se_init_pci_options(struct pci_dev *pdev)
* DRM device * DRM device
*/ */
static const struct mgag200_device_info mgag200_g200se_device_info = static const struct mgag200_device_info mgag200_g200se_a_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(true);
static const struct mgag200_device_info mgag200_g200se_b_device_info =
MGAG200_DEVICE_INFO_INIT(false);
static void mgag200_g200se_init_unique_id(struct mgag200_g200se_device *g200se) static void mgag200_g200se_init_unique_id(struct mgag200_g200se_device *g200se)
{ {
@ -47,9 +50,10 @@ static void mgag200_g200se_init_unique_id(struct mgag200_g200se_device *g200se)
} }
struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mgag200_g200se_device *g200se; struct mgag200_g200se_device *g200se;
const struct mgag200_device_info *info;
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
resource_size_t vram_available; resource_size_t vram_available;
@ -73,7 +77,18 @@ struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const stru
mgag200_g200se_init_unique_id(g200se); mgag200_g200se_init_unique_id(g200se);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200se_device_info); switch (type) {
case G200_SE_A:
info = &mgag200_g200se_a_device_info;
break;
case G200_SE_B:
info = &mgag200_g200se_b_device_info;
break;
default:
return ERR_PTR(-EINVAL);
}
ret = mgag200_device_init(mdev, type, info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

6
drivers/gpu/drm/mgag200/mgag200_g200wb.c
View file

@ -11,10 +11,10 @@
*/ */
static const struct mgag200_device_info mgag200_g200wb_device_info = static const struct mgag200_device_info mgag200_g200wb_device_info =
MGAG200_DEVICE_INFO_INIT(); MGAG200_DEVICE_INFO_INIT(false);
struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const struct drm_driver *drv, struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type, unsigned long flags) enum mga_type type)
{ {
struct mga_device *mdev; struct mga_device *mdev;
struct drm_device *dev; struct drm_device *dev;
@ -36,7 +36,7 @@ struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const stru
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);
ret = mgag200_device_init(mdev, type, flags, &mgag200_g200wb_device_info); ret = mgag200_device_init(mdev, type, &mgag200_g200wb_device_info);
if (ret) if (ret)
return ERR_PTR(ret); return ERR_PTR(ret);

2
drivers/gpu/drm/mgag200/mgag200_mode.c
View file

@ -245,7 +245,7 @@ static void mgag200_set_startadd(struct mga_device *mdev,
startadd = offset / 8; startadd = offset / 8;
if (startadd > 0) if (startadd > 0)
drm_WARN_ON_ONCE(dev, mdev->flags & MGAG200_FLAG_HW_BUG_NO_STARTADD); drm_WARN_ON_ONCE(dev, mdev->info->bug_no_startadd);
/* /*
* Can't store addresses any higher than that, but we also * Can't store addresses any higher than that, but we also