1 files changed, 65 insertions, 76 deletions
diff --git a/drivers/char/drm/mga_warp.c b/drivers/char/drm/mga_warp.c
index 0a3a0cc700dc..55ccc8a0ac29 100644
--- a/drivers/char/drm/mga_warp.c
+++ b/drivers/char/drm/mga_warp.c
@@ -48,65 +48,52 @@ do {									\
        vcbase += WARP_UCODE_SIZE( which );                             \
 } while (0)
+static const unsigned int mga_warp_g400_microcode_size =
-static unsigned int mga_warp_g400_microcode_size( drm_mga_private_t *dev_priv )
+               (WARP_UCODE_SIZE(warp_g400_tgz) +
-{
+                WARP_UCODE_SIZE(warp_g400_tgza) +
-        unsigned int size;
+                WARP_UCODE_SIZE(warp_g400_tgzaf) +
+                WARP_UCODE_SIZE(warp_g400_tgzf) +
-        size = ( WARP_UCODE_SIZE( warp_g400_tgz ) +
+                WARP_UCODE_SIZE(warp_g400_tgzs) +
-                 WARP_UCODE_SIZE( warp_g400_tgza ) +
+                WARP_UCODE_SIZE(warp_g400_tgzsa) +
-                 WARP_UCODE_SIZE( warp_g400_tgzaf ) +
+                WARP_UCODE_SIZE(warp_g400_tgzsaf) +
-                 WARP_UCODE_SIZE( warp_g400_tgzf ) +
+                WARP_UCODE_SIZE(warp_g400_tgzsf) +
-                 WARP_UCODE_SIZE( warp_g400_tgzs ) +
+                WARP_UCODE_SIZE(warp_g400_t2gz) +
-                 WARP_UCODE_SIZE( warp_g400_tgzsa ) +
+                WARP_UCODE_SIZE(warp_g400_t2gza) +
-                 WARP_UCODE_SIZE( warp_g400_tgzsaf ) +
+                WARP_UCODE_SIZE(warp_g400_t2gzaf) +
-                 WARP_UCODE_SIZE( warp_g400_tgzsf ) +
+                WARP_UCODE_SIZE(warp_g400_t2gzf) +
-                 WARP_UCODE_SIZE( warp_g400_t2gz ) +
+                WARP_UCODE_SIZE(warp_g400_t2gzs) +
-                 WARP_UCODE_SIZE( warp_g400_t2gza ) +
+                WARP_UCODE_SIZE(warp_g400_t2gzsa) +
-                 WARP_UCODE_SIZE( warp_g400_t2gzaf ) +
+                WARP_UCODE_SIZE(warp_g400_t2gzsaf) +
-                 WARP_UCODE_SIZE( warp_g400_t2gzf ) +
+                WARP_UCODE_SIZE(warp_g400_t2gzsf));
-                 WARP_UCODE_SIZE( warp_g400_t2gzs ) +
-                 WARP_UCODE_SIZE( warp_g400_t2gzsa ) +
+static const unsigned int mga_warp_g200_microcode_size =
-                 WARP_UCODE_SIZE( warp_g400_t2gzsaf ) +
+               (WARP_UCODE_SIZE(warp_g200_tgz) +
-                 WARP_UCODE_SIZE( warp_g400_t2gzsf ) );
+                WARP_UCODE_SIZE(warp_g200_tgza) +
+                WARP_UCODE_SIZE(warp_g200_tgzaf) +
-        size = PAGE_ALIGN( size );
+                WARP_UCODE_SIZE(warp_g200_tgzf) +
+                WARP_UCODE_SIZE(warp_g200_tgzs) +
-        DRM_DEBUG( "G400 ucode size = %d bytes\n", size );
+                WARP_UCODE_SIZE(warp_g200_tgzsa) +
-        return size;
+                WARP_UCODE_SIZE(warp_g200_tgzsaf) +
-}
+                WARP_UCODE_SIZE(warp_g200_tgzsf));
-static unsigned int mga_warp_g200_microcode_size( drm_mga_private_t *dev_priv )
+unsigned int mga_warp_microcode_size(const drm_mga_private_t * dev_priv)
 {
-        unsigned int size;
+        switch (dev_priv->chipset) {
+        case MGA_CARD_TYPE_G400:
-        size = ( WARP_UCODE_SIZE( warp_g200_tgz ) +
+        case MGA_CARD_TYPE_G550:
-                 WARP_UCODE_SIZE( warp_g200_tgza ) +
+                return PAGE_ALIGN(mga_warp_g400_microcode_size);
-                 WARP_UCODE_SIZE( warp_g200_tgzaf ) +
+        case MGA_CARD_TYPE_G200:
-                 WARP_UCODE_SIZE( warp_g200_tgzf ) +
+                return PAGE_ALIGN(mga_warp_g200_microcode_size);
-                 WARP_UCODE_SIZE( warp_g200_tgzs ) +
+        default:
-                 WARP_UCODE_SIZE( warp_g200_tgzsa ) +
+                return 0;
-                 WARP_UCODE_SIZE( warp_g200_tgzsaf ) +
+        }
-                 WARP_UCODE_SIZE( warp_g200_tgzsf ) );
-        size = PAGE_ALIGN( size );
-        DRM_DEBUG( "G200 ucode size = %d bytes\n", size );
-        return size;
 }
 static int mga_warp_install_g400_microcode( drm_mga_private_t *dev_priv )
 {
        unsigned char *vcbase = dev_priv->warp->handle;
        unsigned long pcbase = dev_priv->warp->offset;
-        unsigned int size;
-        size = mga_warp_g400_microcode_size( dev_priv );
-        if ( size > dev_priv->warp->size ) {
-                DRM_ERROR( "microcode too large! (%u > %lu)\n",
-                           size, dev_priv->warp->size );
-                return DRM_ERR(ENOMEM);
-        }
        memset( dev_priv->warp_pipe_phys, 0,
                sizeof(dev_priv->warp_pipe_phys) );
@@ -136,35 +123,36 @@ static int mga_warp_install_g200_microcode( drm_mga_private_t *dev_priv )
 {
        unsigned char *vcbase = dev_priv->warp->handle;
        unsigned long pcbase = dev_priv->warp->offset;
-        unsigned int size;
-        size = mga_warp_g200_microcode_size( dev_priv );
-        if ( size > dev_priv->warp->size ) {
-                DRM_ERROR( "microcode too large! (%u > %lu)\n",
-                           size, dev_priv->warp->size );
-                return DRM_ERR(ENOMEM);
-        }
-        memset( dev_priv->warp_pipe_phys, 0,
+        memset(dev_priv->warp_pipe_phys, 0, sizeof(dev_priv->warp_pipe_phys));
-                sizeof(dev_priv->warp_pipe_phys) );
-        WARP_UCODE_INSTALL( warp_g200_tgz,      MGA_WARP_TGZ );
+        WARP_UCODE_INSTALL(warp_g200_tgz, MGA_WARP_TGZ);
-        WARP_UCODE_INSTALL( warp_g200_tgzf,     MGA_WARP_TGZF );
+        WARP_UCODE_INSTALL(warp_g200_tgzf, MGA_WARP_TGZF);
-        WARP_UCODE_INSTALL( warp_g200_tgza,     MGA_WARP_TGZA );
+        WARP_UCODE_INSTALL(warp_g200_tgza, MGA_WARP_TGZA);
-        WARP_UCODE_INSTALL( warp_g200_tgzaf,    MGA_WARP_TGZAF );
+        WARP_UCODE_INSTALL(warp_g200_tgzaf, MGA_WARP_TGZAF);
-        WARP_UCODE_INSTALL( warp_g200_tgzs,     MGA_WARP_TGZS );
+        WARP_UCODE_INSTALL(warp_g200_tgzs, MGA_WARP_TGZS);
-        WARP_UCODE_INSTALL( warp_g200_tgzsf,    MGA_WARP_TGZSF );
+        WARP_UCODE_INSTALL(warp_g200_tgzsf, MGA_WARP_TGZSF);
-        WARP_UCODE_INSTALL( warp_g200_tgzsa,    MGA_WARP_TGZSA );
+        WARP_UCODE_INSTALL(warp_g200_tgzsa, MGA_WARP_TGZSA);
-        WARP_UCODE_INSTALL( warp_g200_tgzsaf,   MGA_WARP_TGZSAF );
+        WARP_UCODE_INSTALL(warp_g200_tgzsaf, MGA_WARP_TGZSAF);
        return 0;
 }
 int mga_warp_install_microcode( drm_mga_private_t *dev_priv )
 {
-        switch ( dev_priv->chipset ) {
+        const unsigned int size = mga_warp_microcode_size(dev_priv);
+        DRM_DEBUG("MGA ucode size = %d bytes\n", size);
+        if (size > dev_priv->warp->size) {
+                DRM_ERROR("microcode too large! (%u > %lu)\n",
+                          size, dev_priv->warp->size);
+                return DRM_ERR(ENOMEM);
+        }
+        switch (dev_priv->chipset) {
        case MGA_CARD_TYPE_G400:
-                return mga_warp_install_g400_microcode( dev_priv );
+        case MGA_CARD_TYPE_G550:
+                return mga_warp_install_g400_microcode(dev_priv);
        case MGA_CARD_TYPE_G200:
                return mga_warp_install_g200_microcode( dev_priv );
        default:
@@ -182,10 +170,11 @@ int mga_warp_init( drm_mga_private_t *dev_priv )
         */
        switch ( dev_priv->chipset ) {
        case MGA_CARD_TYPE_G400:
-                MGA_WRITE( MGA_WIADDR2, MGA_WMODE_SUSPEND );
+        case MGA_CARD_TYPE_G550:
-                MGA_WRITE( MGA_WGETMSB, 0x00000E00 );
+                MGA_WRITE(MGA_WIADDR2, MGA_WMODE_SUSPEND);
-                MGA_WRITE( MGA_WVRTXSZ, 0x00001807 );
+                MGA_WRITE(MGA_WGETMSB, 0x00000E00);
-                MGA_WRITE( MGA_WACCEPTSEQ, 0x18000000 );
+                MGA_WRITE(MGA_WVRTXSZ, 0x00001807);
+                MGA_WRITE(MGA_WACCEPTSEQ, 0x18000000);
                break;
        case MGA_CARD_TYPE_G200:
                MGA_WRITE( MGA_WIADDR, MGA_WMODE_SUSPEND );

diff --git a/drivers/char/drm/mga_warp.c b/drivers/char/drm/mga_warp.c index 0a3a0cc700dc..55ccc8a0ac29 100644 --- a/drivers/char/drm/mga_warp.c +++ b/drivers/char/drm/mga_warp.c
@@ -48,65 +48,52 @@ do { \
48	vcbase += WARP_UCODE_SIZE( which ); \	48	vcbase += WARP_UCODE_SIZE( which ); \
49	} while (0)	49	} while (0)
50		50
51		51	static const unsigned int mga_warp_g400_microcode_size =
52	static unsigned int mga_warp_g400_microcode_size( drm_mga_private_t *dev_priv )	52	(WARP_UCODE_SIZE(warp_g400_tgz) +
53	{	53	WARP_UCODE_SIZE(warp_g400_tgza) +
54	unsigned int size;	54	WARP_UCODE_SIZE(warp_g400_tgzaf) +
55		55	WARP_UCODE_SIZE(warp_g400_tgzf) +
56	size = ( WARP_UCODE_SIZE( warp_g400_tgz ) +	56	WARP_UCODE_SIZE(warp_g400_tgzs) +
57	WARP_UCODE_SIZE( warp_g400_tgza ) +	57	WARP_UCODE_SIZE(warp_g400_tgzsa) +
58	WARP_UCODE_SIZE( warp_g400_tgzaf ) +	58	WARP_UCODE_SIZE(warp_g400_tgzsaf) +
59	WARP_UCODE_SIZE( warp_g400_tgzf ) +	59	WARP_UCODE_SIZE(warp_g400_tgzsf) +
60	WARP_UCODE_SIZE( warp_g400_tgzs ) +	60	WARP_UCODE_SIZE(warp_g400_t2gz) +
61	WARP_UCODE_SIZE( warp_g400_tgzsa ) +	61	WARP_UCODE_SIZE(warp_g400_t2gza) +
62	WARP_UCODE_SIZE( warp_g400_tgzsaf ) +	62	WARP_UCODE_SIZE(warp_g400_t2gzaf) +
63	WARP_UCODE_SIZE( warp_g400_tgzsf ) +	63	WARP_UCODE_SIZE(warp_g400_t2gzf) +
64	WARP_UCODE_SIZE( warp_g400_t2gz ) +	64	WARP_UCODE_SIZE(warp_g400_t2gzs) +
65	WARP_UCODE_SIZE( warp_g400_t2gza ) +	65	WARP_UCODE_SIZE(warp_g400_t2gzsa) +
66	WARP_UCODE_SIZE( warp_g400_t2gzaf ) +	66	WARP_UCODE_SIZE(warp_g400_t2gzsaf) +
67	WARP_UCODE_SIZE( warp_g400_t2gzf ) +	67	WARP_UCODE_SIZE(warp_g400_t2gzsf));
68	WARP_UCODE_SIZE( warp_g400_t2gzs ) +	68
69	WARP_UCODE_SIZE( warp_g400_t2gzsa ) +	69	static const unsigned int mga_warp_g200_microcode_size =
70	WARP_UCODE_SIZE( warp_g400_t2gzsaf ) +	70	(WARP_UCODE_SIZE(warp_g200_tgz) +
71	WARP_UCODE_SIZE( warp_g400_t2gzsf ) );	71	WARP_UCODE_SIZE(warp_g200_tgza) +
72		72	WARP_UCODE_SIZE(warp_g200_tgzaf) +
73	size = PAGE_ALIGN( size );	73	WARP_UCODE_SIZE(warp_g200_tgzf) +
74		74	WARP_UCODE_SIZE(warp_g200_tgzs) +
75	DRM_DEBUG( "G400 ucode size = %d bytes\n", size );	75	WARP_UCODE_SIZE(warp_g200_tgzsa) +
76	return size;	76	WARP_UCODE_SIZE(warp_g200_tgzsaf) +
77	}	77	WARP_UCODE_SIZE(warp_g200_tgzsf));
78		78
79	static unsigned int mga_warp_g200_microcode_size( drm_mga_private_t *dev_priv )	79
		80	unsigned int mga_warp_microcode_size(const drm_mga_private_t * dev_priv)
80	{	81	{
81	unsigned int size;	82	switch (dev_priv->chipset) {
82		83	case MGA_CARD_TYPE_G400:
83	size = ( WARP_UCODE_SIZE( warp_g200_tgz ) +	84	case MGA_CARD_TYPE_G550:
84	WARP_UCODE_SIZE( warp_g200_tgza ) +	85	return PAGE_ALIGN(mga_warp_g400_microcode_size);
85	WARP_UCODE_SIZE( warp_g200_tgzaf ) +	86	case MGA_CARD_TYPE_G200:
86	WARP_UCODE_SIZE( warp_g200_tgzf ) +	87	return PAGE_ALIGN(mga_warp_g200_microcode_size);
87	WARP_UCODE_SIZE( warp_g200_tgzs ) +	88	default:
88	WARP_UCODE_SIZE( warp_g200_tgzsa ) +	89	return 0;
89	WARP_UCODE_SIZE( warp_g200_tgzsaf ) +	90	}
90	WARP_UCODE_SIZE( warp_g200_tgzsf ) );
91
92	size = PAGE_ALIGN( size );
93
94	DRM_DEBUG( "G200 ucode size = %d bytes\n", size );
95	return size;
96	}	91	}
97		92
98	static int mga_warp_install_g400_microcode( drm_mga_private_t *dev_priv )	93	static int mga_warp_install_g400_microcode( drm_mga_private_t *dev_priv )
99	{	94	{
100	unsigned char *vcbase = dev_priv->warp->handle;	95	unsigned char *vcbase = dev_priv->warp->handle;
101	unsigned long pcbase = dev_priv->warp->offset;	96	unsigned long pcbase = dev_priv->warp->offset;
102	unsigned int size;
103
104	size = mga_warp_g400_microcode_size( dev_priv );
105	if ( size > dev_priv->warp->size ) {
106	DRM_ERROR( "microcode too large! (%u > %lu)\n",
107	size, dev_priv->warp->size );
108	return DRM_ERR(ENOMEM);
109	}
110		97
111	memset( dev_priv->warp_pipe_phys, 0,	98	memset( dev_priv->warp_pipe_phys, 0,
112	sizeof(dev_priv->warp_pipe_phys) );	99	sizeof(dev_priv->warp_pipe_phys) );
@@ -136,35 +123,36 @@ static int mga_warp_install_g200_microcode( drm_mga_private_t *dev_priv )
136	{	123	{
137	unsigned char *vcbase = dev_priv->warp->handle;	124	unsigned char *vcbase = dev_priv->warp->handle;
138	unsigned long pcbase = dev_priv->warp->offset;	125	unsigned long pcbase = dev_priv->warp->offset;
139	unsigned int size;
140
141	size = mga_warp_g200_microcode_size( dev_priv );
142	if ( size > dev_priv->warp->size ) {
143	DRM_ERROR( "microcode too large! (%u > %lu)\n",
144	size, dev_priv->warp->size );
145	return DRM_ERR(ENOMEM);
146	}
147		126
148	memset( dev_priv->warp_pipe_phys, 0,	127	memset(dev_priv->warp_pipe_phys, 0, sizeof(dev_priv->warp_pipe_phys));
149	sizeof(dev_priv->warp_pipe_phys) );
150		128
151	WARP_UCODE_INSTALL( warp_g200_tgz, MGA_WARP_TGZ );	129	WARP_UCODE_INSTALL(warp_g200_tgz, MGA_WARP_TGZ);
152	WARP_UCODE_INSTALL( warp_g200_tgzf, MGA_WARP_TGZF );	130	WARP_UCODE_INSTALL(warp_g200_tgzf, MGA_WARP_TGZF);
153	WARP_UCODE_INSTALL( warp_g200_tgza, MGA_WARP_TGZA );	131	WARP_UCODE_INSTALL(warp_g200_tgza, MGA_WARP_TGZA);
154	WARP_UCODE_INSTALL( warp_g200_tgzaf, MGA_WARP_TGZAF );	132	WARP_UCODE_INSTALL(warp_g200_tgzaf, MGA_WARP_TGZAF);
155	WARP_UCODE_INSTALL( warp_g200_tgzs, MGA_WARP_TGZS );	133	WARP_UCODE_INSTALL(warp_g200_tgzs, MGA_WARP_TGZS);
156	WARP_UCODE_INSTALL( warp_g200_tgzsf, MGA_WARP_TGZSF );	134	WARP_UCODE_INSTALL(warp_g200_tgzsf, MGA_WARP_TGZSF);
157	WARP_UCODE_INSTALL( warp_g200_tgzsa, MGA_WARP_TGZSA );	135	WARP_UCODE_INSTALL(warp_g200_tgzsa, MGA_WARP_TGZSA);
158	WARP_UCODE_INSTALL( warp_g200_tgzsaf, MGA_WARP_TGZSAF );	136	WARP_UCODE_INSTALL(warp_g200_tgzsaf, MGA_WARP_TGZSAF);
159		137
160	return 0;	138	return 0;
161	}	139	}
162		140
163	int mga_warp_install_microcode( drm_mga_private_t *dev_priv )	141	int mga_warp_install_microcode( drm_mga_private_t *dev_priv )
164	{	142	{
165	switch ( dev_priv->chipset ) {	143	const unsigned int size = mga_warp_microcode_size(dev_priv);
		144
		145	DRM_DEBUG("MGA ucode size = %d bytes\n", size);
		146	if (size > dev_priv->warp->size) {
		147	DRM_ERROR("microcode too large! (%u > %lu)\n",
		148	size, dev_priv->warp->size);
		149	return DRM_ERR(ENOMEM);
		150	}
		151
		152	switch (dev_priv->chipset) {
166	case MGA_CARD_TYPE_G400:	153	case MGA_CARD_TYPE_G400:
167	return mga_warp_install_g400_microcode( dev_priv );	154	case MGA_CARD_TYPE_G550:
		155	return mga_warp_install_g400_microcode(dev_priv);
168	case MGA_CARD_TYPE_G200:	156	case MGA_CARD_TYPE_G200:
169	return mga_warp_install_g200_microcode( dev_priv );	157	return mga_warp_install_g200_microcode( dev_priv );
170	default:	158	default:
@@ -182,10 +170,11 @@ int mga_warp_init( drm_mga_private_t *dev_priv )
182	*/	170	*/
183	switch ( dev_priv->chipset ) {	171	switch ( dev_priv->chipset ) {
184	case MGA_CARD_TYPE_G400:	172	case MGA_CARD_TYPE_G400:
185	MGA_WRITE( MGA_WIADDR2, MGA_WMODE_SUSPEND );	173	case MGA_CARD_TYPE_G550:
186	MGA_WRITE( MGA_WGETMSB, 0x00000E00 );	174	MGA_WRITE(MGA_WIADDR2, MGA_WMODE_SUSPEND);
187	MGA_WRITE( MGA_WVRTXSZ, 0x00001807 );	175	MGA_WRITE(MGA_WGETMSB, 0x00000E00);
188	MGA_WRITE( MGA_WACCEPTSEQ, 0x18000000 );	176	MGA_WRITE(MGA_WVRTXSZ, 0x00001807);
		177	MGA_WRITE(MGA_WACCEPTSEQ, 0x18000000);
189	break;	178	break;
190	case MGA_CARD_TYPE_G200:	179	case MGA_CARD_TYPE_G200:
191	MGA_WRITE( MGA_WIADDR, MGA_WMODE_SUSPEND );	180	MGA_WRITE( MGA_WIADDR, MGA_WMODE_SUSPEND );