Chameleon Applications

Chameleon Applications Svn Source Tree

Root/branches/iFabio/Chameleon/i386/libsaio/ati.c

Source at commit 307 created 12 years 11 months ago.
By ifabio, merge changes from trunk (929). Also merge the module changes from Azimutz branche (fix compile error) Also edited the info.plist into AHCIPortInjector.kext: http://forum.voodooprojects.org/index.php/topic,1170.0.html
1/*␊
2 * ATI Graphics Card Enabler, part of the Chameleon Boot Loader Project␊
3 *␊
4 * Copyright 2010 by Islam M. Ahmed Zaid. All rights reserved.␊
5 *␊
6 */␊
7␊
8␊
9#include "libsaio.h"␊
10#include "boot.h"␊
11#include "bootstruct.h"␊
12#include "pci.h"␊
13#include "platform.h"␊
14#include "device_inject.h"␊
15␊
16#include "ati_reg.h"␊
17␊
18#define␉OFFSET_TO_GET_ATOMBIOS_STRINGS_START␉␉0x6e␊
19␊
20#define Reg32(reg)␉␉␉␉␉(*(volatile uint32_t *)(card->mmio + reg))␊
21#define RegRead32(reg)␉␉␉␉(Reg32(reg))␊
22#define RegWrite32(reg, value)␉␉(Reg32(reg) = value)␊
23␊
24typedef enum {␊
25␉kNul,␊
26␉kStr,␊
27␉kPtr,␊
28␉kCst␊
29} type_t;␊
30␊
31typedef enum {␊
32␉CHIP_FAMILY_UNKNOW,␊
33␉CHIP_FAMILY_RS600,␊
34␉CHIP_FAMILY_RS690,␊
35␉CHIP_FAMILY_RS740,␊
36␉/* R600 */␊
37␉CHIP_FAMILY_R600,␊
38␉CHIP_FAMILY_RV610,␊
39␉CHIP_FAMILY_RV630,␊
40␉CHIP_FAMILY_RV670,␊
41␉CHIP_FAMILY_RV620,␊
42␉CHIP_FAMILY_RV635,␊
43␉CHIP_FAMILY_RS780,␊
44␉CHIP_FAMILY_RS880,␊
45␉/* R700 */␊
46␉CHIP_FAMILY_RV770,␊
47␉CHIP_FAMILY_RV730,␊
48␉CHIP_FAMILY_RV710,␊
49␉CHIP_FAMILY_RV740,␊
50␉/* Evergreen */␊
51␉CHIP_FAMILY_CEDAR,␊
52␉CHIP_FAMILY_REDWOOD,␊
53␉CHIP_FAMILY_JUNIPER,␊
54␉CHIP_FAMILY_CYPRESS,␊
55␉CHIP_FAMILY_HEMLOCK,␊
56␉/* Northern Islands */␊
57␉CHIP_FAMILY_BARTS,␊
58␉CHIP_FAMILY_CAICOS,␊
59␉CHIP_FAMILY_CAYMAN,␊
60␉CHIP_FAMILY_TURKS,␊
61␉CHIP_FAMILY_LAST␊
62} chip_family_t;␊
63␊
64static const char *chip_family_name[] = {␊
65␉"UNKNOW",␊
66␉"RS600",␊
67␉"RS690",␊
68␉"RS740",␊
69␉/* R600 */␊
70␉"R600",␊
71␉"RV610",␊
72␉"RV630",␊
73␉"RV670",␊
74␉"RV620",␊
75␉"RV635",␊
76␉"RS780",␊
77␉"RS880",␊
78␉/* R700 */␊
79␉"RV770",␊
80␉"RV730",␊
81␉"RV710",␊
82␉"RV740",␊
83␉/* Evergreen */␊
84␉"Cedar",␉// RV810␊
85␉"Redwood",␉// RV830␊
86␉"Juniper",␉// RV840␊
87␉"Cypress",␉// RV870␊
88␉"Hemlock",␊
89␉/* Northern Islands */␊
90␉"Barts",␊
91␉"Caicos",␊
92␉"Cayman",␊
93␉"Turks",␊
94␉""␊
95};␊
96␊
97typedef struct {␊
98␉const char␉␉*name;␊
99␉uint8_t␉␉␉ports;␊
100} card_config_t;␊
101␊
102static card_config_t card_configs[] = {␊
103␉{NULL,␉␉␉0},␊
104␉{"Alopias",␉␉2},␊
105␉{"Alouatta",␉4},␊
106␉{"Baboon",␉␉3},␊
107␉{"Cardinal",␉2},␊
108␉{"Caretta",␉␉1},␊
109␉{"Colobus",␉␉2},␊
110␉{"Douc",␉␉2},␊
111␉{"Eulemur",␉␉3},␊
112␉{"Flicker",␉␉3},␊
113␉{"Galago",␉␉2},␊
114␉{"Gliff",␉␉3},␊
115␉{"Hoolock",␉␉3},␊
116␉{"Hypoprion",␉2},␊
117␉{"Iago",␉␉2},␊
118␉{"Kakapo",␉␉3},␊
119␉{"Kipunji",␉␉4},␊
120␉{"Lamna",␉␉2},␊
121␉{"Langur",␉␉3},␊
122␉{"Megalodon",␉3},␊
123␉{"Motmot",␉␉2},␊
124␉{"Nomascus",␉5},␊
125␉{"Orangutan",␉2},␊
126␉{"Peregrine",␉2},␊
127␉{"Quail",␉␉3},␊
128␉{"Raven",␉␉3},␊
129␉{"Shrike",␉␉3},␊
130␉{"Sphyrna",␉␉1},␊
131␉{"Triakis",␉␉2},␊
132␉{"Uakari",␉␉4},␊
133␉{"Vervet",␉␉4},␊
134␉{"Zonalis",␉␉6},␊
135␉{"Pithecia",␉3},␊
136␉{"Bulrushes",␉6},␊
137␉{"Cattail",␉␉4},␊
138␉{"Hydrilla",␉5},␊
139␉{"Duckweed",␉4},␊
140␉{"Fanwort",␉␉4},␊
141␉{"Elodea",␉␉5},␊
142␉{"Kudzu",␉␉2},␊
143␉{"Gibba",␉␉5},␊
144␉{"Lotus",␉␉3},␊
145␉{"Ipomoea",␉␉3},␊
146␉{"Mangabey",␉2},␊
147␉{"Muskgrass",␉4},␊
148␉{"Juncus",␉␉4}␊
149};␊
150␊
151typedef enum {␊
152␉kNull,␊
153␉kAlopias,␊
154␉kAlouatta,␊
155␉kBaboon,␊
156␉kCardinal,␊
157␉kCaretta,␊
158␉kColobus,␊
159␉kDouc,␊
160␉kEulemur,␊
161␉kFlicker,␊
162␉kGalago,␊
163␉kGliff,␊
164␉kHoolock,␊
165␉kHypoprion,␊
166␉kIago,␊
167␉kKakapo,␊
168␉kKipunji,␊
169␉kLamna,␊
170␉kLangur,␊
171␉kMegalodon,␊
172␉kMotmot,␊
173␉kNomascus,␊
174␉kOrangutan,␊
175␉kPeregrine,␊
176␉kQuail,␊
177␉kRaven,␊
178␉kShrike,␊
179␉kSphyrna,␊
180␉kTriakis,␊
181␉kUakari,␊
182␉kVervet,␊
183␉kZonalis,␊
184␉kPithecia,␊
185␉kBulrushes,␊
186␉kCattail,␊
187␉kHydrilla,␊
188␉kDuckweed,␊
189␉kFanwort,␊
190␉kElodea,␊
191␉kKudzu,␊
192␉kGibba,␊
193␉kLotus,␊
194␉kIpomoea,␊
195␉kMangabey,␊
196␉kMuskgrass,␊
197␉kJuncus,␊
198␉kCfgEnd␊
199} config_name_t;␊
200␊
201typedef struct {␊
202␉uint16_t␉␉device_id;␊
203␉uint32_t␉␉subsys_id;␊
204␉chip_family_t␉chip_family;␊
205␉const char␉␉*model_name;␊
206␉config_name_t␉cfg_name;␊
207} radeon_card_info_t;␊
208␊
209static radeon_card_info_t radeon_cards[] = {␊
210␉/* Earlier cards are not supported */␊
211␉{ 0x9400,␉0x30001002,␉CHIP_FAMILY_R600,␉␉"ATI Radeon HD 2900 PRO",␉␉␉kNull␉␉},␊
212␉{ 0x9400,␉0x25521002,␉CHIP_FAMILY_R600,␉␉"ATI Radeon HD 2900 XT",␉␉␉kNull␉␉},␊
213␊
214␉{ 0x9440,␉0x24401682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4870",␉␉␉␉kMotmot␉␉},␊
215␉{ 0x9440,␉0x24411682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4870",␉␉␉␉kMotmot␉␉},␊
216␉{ 0x9440,␉0x24441682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4870",␉␉␉␉kMotmot␉␉},␊
217␉{ 0x9440,␉0x24451682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4870",␉␉␉␉kMotmot␉␉},␊
218␊
219␉{ 0x9441,␉0x24401682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4870 X2",␉␉␉kMotmot␉␉},␊
220␊
221␉{ 0x9442,␉0x24701682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4850",␉␉␉␉kMotmot␉␉},␊
222␉{ 0x9442,␉0x24711682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4850",␉␉␉␉kMotmot␉␉},␊
223␉{ 0x9442,␉0x080110B0,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4850",␉␉␉␉kMotmot␉␉},␊
224␉{ 0x9442,␉0xE104174B,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4850",␉␉␉␉kMotmot␉␉},␊
225␊
226␉{ 0x944A,␉0x30001682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
227␉{ 0x944A,␉0x30001043,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
228␉{ 0x944A,␉0x30001458,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
229␉{ 0x944A,␉0x30001462,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
230␉{ 0x944A,␉0x30001545,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
231␉{ 0x944A,␉0x30001787,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
232␉{ 0x944A,␉0x3000174B,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
233␉{ 0x944A,␉0x300017AF,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
234␊
235␉{ 0x944C,␉0x24801682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4830",␉␉␉␉kMotmot␉␉},␊
236␉{ 0x944C,␉0x24811682,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4830",␉␉␉␉kMotmot␉␉},␊
237␊
238␉{ 0x944E,␉0x3260174B,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4810 Series",␉␉kMotmot␉␉},␊
239␉{ 0x944E,␉0x3261174B,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4810 series",␉␉kMotmot␉␉},␊
240␉{ 0x944E,␉0x30001787,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4730 Series",␉␉kMotmot␉␉},␊
241␉{ 0x944E,␉0x30101787,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4810 Series",␉␉kMotmot␉␉},␊
242␉{ 0x944E,␉0x31001787,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4820",␉␉␉␉kMotmot␉␉},␊
243␊
244␉{ 0x9490,␉0x30501787,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4710",␉␉␉␉kNull␉␉},␊
245␉{ 0x9490,␉0x4710174B,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4710",␉␉␉␉kNull␉␉},␊
246␉{ 0x9490,␉0x300017AF,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4710",␉␉␉␉kNull␉␉},␊
247␊
248␉{ 0x9498,␉0x30501787,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4700",␉␉␉␉kNull␉␉},␊
249␉{ 0x9498,␉0x31001787,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4720",␉␉␉␉kNull␉␉},␊
250␉{ 0x9498,␉0x24511682,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4650",␉␉␉␉kNull␉␉},␊
251␉{ 0x9498,␉0x24521682,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4650",␉␉␉␉kNull␉␉},␊
252␉{ 0x9498,␉0x24541682,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4650",␉␉␉␉kNull␉␉},␊
253␉{ 0x9498,␉0x29331682,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4670",␉␉␉␉kNull␉␉},␊
254␉{ 0x9498,␉0x29341682,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4670",␉␉␉␉kNull␉␉},␊
255␉{ 0x9498,␉0x21CF1458,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4600 Series",␉␉kNull␉␉},␊
256␊
257␉{ 0x94B3,␉0x29001682,␉CHIP_FAMILY_RV740,␉␉"ATI Radeon HD 4770",␉␉␉␉kFlicker␉},␊
258␉{ 0x94B3,␉0x1170174B,␉CHIP_FAMILY_RV740,␉␉"ATI Radeon HD 4770",␉␉␉␉kFlicker␉},␊
259␉{ 0x94B3,␉0x10020D00,␉CHIP_FAMILY_RV740,␉␉"ATI Radeon HD 4770",␉␉␉␉kFlicker␉},␊
260␊
261␉{ 0x94C1,␉0x10021002,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 Pro",␉␉␉kNull␉␉},␊
262␉{ 0x94C1,␉0x0D021002,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
263␉{ 0x94C1,␉0x0D021028,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 Pro",␉␉␉kNull␉␉},␊
264␉{ 0x94C1,␉0x0D021028,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
265␉{ 0x94C1,␉0x21741458,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
266␉{ 0x94C1,␉0x10401462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
267␉{ 0x94C1,␉0x10331462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
268␉{ 0x94C1,␉0x10331462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
269␉{ 0x94C1,␉0x11101462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 XT",␉␉␉kNull␉␉},␊
270␊
271␉{ 0x94C3,␉0x37161642,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
272␉{ 0x94C3,␉0x30001642,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 3410",␉␉␉␉kNull␉␉},␊
273␉{ 0x94C3,␉0x03421002,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
274␉{ 0x94C3,␉0x30001025,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2350 Series",␉␉kNull␉␉},␊
275␉{ 0x94C3,␉0x04021028,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400",␉␉␉␉kNull␉␉},␊
276␉{ 0x94C3,␉0x03021028,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
277␉{ 0x94C3,␉0x04021028,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
278␉{ 0x94C3,␉0x216A1458,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
279␉{ 0x94C3,␉0x21721458,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
280␉{ 0x94C3,␉0x30001458,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 3410",␉␉␉␉kNull␉␉},␊
281␉{ 0x94C3,␉0x11041462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400",␉␉␉␉kNull␉␉},␊
282␉{ 0x94C3,␉0x10411462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400",␉␉␉␉kNull␉␉},␊
283␉{ 0x94C3,␉0x11051462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400",␉␉␉␉kNull␉␉},␊
284␉{ 0x94C3,␉0x10321462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
285␉{ 0x94C3,␉0x30001462,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 3410",␉␉␉␉kNull␉␉},␊
286␉{ 0x94C3,␉0x3000148C,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2350 Series",␉␉kNull␉␉},␊
287␉{ 0x94C3,␉0x2247148C,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 LE",␉␉␉kNull␉␉},␊
288␉{ 0x94C3,␉0x3000174B,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2350 Series",␉␉kNull␉␉},␊
289␉{ 0x94C3,␉0xE400174B,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
290␉{ 0x94C3,␉0xE370174B,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
291␉{ 0x94C3,␉0xE400174B,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
292␉{ 0x94C3,␉0xE370174B,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
293␉{ 0x94C3,␉0xE400174B,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 PRO",␉␉␉kNull␉␉},␊
294␉{ 0x94C3,␉0x203817AF,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400",␉␉␉␉kNull␉␉},␊
295␉{ 0x94C3,␉0x30001787,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2350 Series",␉␉kNull␉␉},␊
296␉{ 0x94C3,␉0x22471787,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 LE",␉␉␉kNull␉␉},␊
297␉{ 0x94C3,␉0x01011A93,␉CHIP_FAMILY_RV610,␉␉"Qimonda Radeon HD 2400 PRO",␉␉kNull␉␉},␊
298␊
299␊
300␉{ 0x9501,␉0x30001002,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3690",␉␉␉␉kNull␉␉},␊
301␉{ 0x9501,␉0x25421002,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3870",␉␉␉␉kNull␉␉},␊
302␉{ 0x9501,␉0x4750174B,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4750",␉␉␉␉kNull␉␉},␊
303␉{ 0x9501,␉0x3000174B,␉CHIP_FAMILY_RV670,␉␉"Sapphire Radeon HD 3690",␉␉␉kNull␉␉},␊
304␉{ 0x9501,␉0x30001787,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3690",␉␉␉␉kNull␉␉},␊
305␊
306␉{ 0x9505,␉0x30001002,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3690",␉␉␉␉kNull␉␉},␊
307␉{ 0x9505,␉0x25421002,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3850",␉␉␉␉kNull␉␉},␊
308␉{ 0x9505,␉0x30011043,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4730",␉␉␉␉kNull␉␉},␊
309␉{ 0x9505,␉0x3000148C,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3850",␉␉␉␉kNull␉␉},␊
310␉{ 0x9505,␉0x3002148C,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4730",␉␉␉␉kNull␉␉},␊
311␉{ 0x9505,␉0x3001148C,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4730",␉␉␉␉kNull␉␉},␊
312␉{ 0x9505,␉0x3003148C,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4750",␉␉␉␉kNull␉␉},␊
313␉{ 0x9505,␉0x3004148C,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4750",␉␉␉␉kNull␉␉},␊
314␉{ 0x9505,␉0x4730174B,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4730",␉␉␉␉kNull␉␉},␊
315␉{ 0x9505,␉0x3010174B,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4750",␉␉␉␉kNull␉␉},␊
316␉{ 0x9505,␉0x3001174B,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4750",␉␉␉␉kNull␉␉},␊
317␉{ 0x9505,␉0x3000174B,␉CHIP_FAMILY_RV670,␉␉"Sapphire Radeon HD 3690",␉␉␉kNull␉␉},␊
318␉{ 0x9505,␉0x30001787,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3690",␉␉␉␉kNull␉␉},␊
319␉{ 0x9505,␉0x301017AF,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 4750",␉␉␉␉kNull␉␉},␊
320␊
321␉{ 0x9540,␉0x4590174B,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4590",␉␉␉␉kNull␉␉},␊
322␉{ 0x9540,␉0x30501787,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4590",␉␉␉␉kNull␉␉},␊
323␊
324␉{ 0x954F,␉0x29201682,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4550",␉␉␉␉kNull␉␉},␊
325␉{ 0x954F,␉0x29211682,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4550",␉␉␉␉kNull␉␉},␊
326␉{ 0x954F,␉0x30901682,␉CHIP_FAMILY_RV710,␉␉"XFX Radeon HD 4570",␉␉␉␉kNull␉␉},␊
327␉{ 0x954F,␉0x4450174B,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4450",␉␉␉␉kNull␉␉},␊
328␉{ 0x954F,␉0x3000174B,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4520",␉␉␉␉kNull␉␉},␊
329␉{ 0x954F,␉0x30501787,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4450",␉␉␉␉kNull␉␉},␊
330␉{ 0x954F,␉0x31001787,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4520",␉␉␉␉kNull␉␉},␊
331␉{ 0x954F,␉0x4570174B,␉CHIP_FAMILY_RV710,␉␉"Sapphire Radeon HD4570",␉␉␉kNull␉␉},␊
332␉{ 0x954F,␉0x301017AF,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4450",␉␉␉␉kNull␉␉},␊
333␊
334␉{ 0x9552,␉0x3000148C,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4300/4500 Series",␉kNull␉␉},␊
335␉{ 0x9552,␉0x3000174B,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4300/4500 Series",␉kNull␉␉},␊
336␉{ 0x9552,␉0x30001787,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4300/4500 Series",␉kNull␉␉},␊
337␉{ 0x9552,␉0x300017AF,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4300/4500 Series",␉kNull␉␉},␊
338␊
339␉{ 0x9581,␉0x95811002,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3600 Series",␉␉kNull␉␉},␊
340␉{ 0x9581,␉0x3000148C,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3600 Series",␉␉kNull␉␉},␊
341␊
342␉{ 0x9583,␉0x3000148C,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3600 Series",␉␉kNull␉␉},␊
343␉{ 0x9588,␉0x01021A93,␉CHIP_FAMILY_RV630,␉␉"Qimonda Radeon HD 2600 XT",␉␉kNull␉␉},␊
344␊
345␉{ 0x9589,␉0x30001462,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3610",␉␉␉␉kNull␉␉},␊
346␉{ 0x9589,␉0x30001642,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3610",␉␉␉␉kNull␉␉},␊
347␉{ 0x9589,␉0x0E41174B,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3600 Series",␉␉kNull␉␉},␊
348␉{ 0x9589,␉0x30001787,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 3600 Series",␉␉kNull␉␉},␊
349␉{ 0x9589,␉0x01001A93,␉CHIP_FAMILY_RV630,␉␉"Qimonda Radeon HD 2600 PRO",␉␉kNull␉␉},␊
350␊
351␉{ 0x9591,␉0x2303148C,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 3600 Series",␉␉kNull␉␉},␊
352␊
353␉{ 0x9598,␉0xB3831002,␉CHIP_FAMILY_RV635,␉␉"ATI All-in-Wonder HD",␉␉␉␉kNull␉␉},␊
354␉{ 0x9598,␉0x30011043,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4570",␉␉␉␉kNull␉␉},␊
355␉{ 0x9598,␉0x30001043,␉CHIP_FAMILY_RV635,␉␉"HD3730",␉␉␉␉␉␉␉kNull␉␉},␊
356␉{ 0x9598,␉0x3000148C,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 3730",␉␉␉␉kNull␉␉},␊
357␉{ 0x9598,␉0x3031148C,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4570",␉␉␉␉kNull␉␉},␊
358␉{ 0x9598,␉0x3001148C,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4580",␉␉␉␉kNull␉␉},␊
359␉{ 0x9598,␉0x30011545,␉CHIP_FAMILY_RV635,␉␉"VisionTek Radeon HD 2600 Pro",␉␉kNull␉␉},␊
360␉{ 0x9598,␉0x30001545,␉CHIP_FAMILY_RV635,␉␉"VisionTek Radeon HD 2600 XT",␉␉kNull␉␉},␊
361␉{ 0x9598,␉0x4570174B,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4570",␉␉␉␉kNull␉␉},␊
362␉{ 0x9598,␉0x4580174B,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4580",␉␉␉␉kNull␉␉},␊
363␉{ 0x9598,␉0x4610174B,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4610",␉␉␉␉kNull␉␉},␊
364␉{ 0x9598,␉0x3000174B,␉CHIP_FAMILY_RV635,␉␉"Sapphire Radeon HD 3730",␉␉␉kNull␉␉},␊
365␉{ 0x9598,␉0x3001174B,␉CHIP_FAMILY_RV635,␉␉"Sapphire Radeon HD 3750",␉␉␉kNull␉␉},␊
366␉{ 0x9598,␉0x301017AF,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4570",␉␉␉␉kNull␉␉},␊
367␉{ 0x9598,␉0x301117AF,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4580",␉␉␉␉kNull␉␉},␊
368␉{ 0x9598,␉0x300117AF,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD3750",␉␉␉␉kNull␉␉},␊
369␉{ 0x9598,␉0x30501787,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 4610",␉␉␉␉kNull␉␉},␊
370␊
371␉{ 0x95C0,␉0x3000148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3550",␉␉␉␉kNull␉␉},␊
372␉{ 0x95C0,␉0xE3901745,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3550",␉␉␉␉kNull␉␉},␊
373␉{ 0x95C0,␉0x3002174B,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3570",␉␉␉␉kNull␉␉},␊
374␉{ 0x95C0,␉0x3020174B,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
375␉{ 0x95C0,␉0x3000174B,␉CHIP_FAMILY_RV620,␉␉"Sapphire Radeon HD 3550",␉␉␉kNull␉␉},␊
376␊
377␉{ 0x95C5,␉0x3000148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3450",␉␉␉␉kNull␉␉},␊
378␉{ 0x95C5,␉0x3001148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3550",␉␉␉␉kNull␉␉},␊
379␉{ 0x95C5,␉0x3002148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4230",␉␉␉␉kNull␉␉},␊
380␉{ 0x95C5,␉0x3033148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4230",␉␉␉␉kNull␉␉},␊
381␉{ 0x95C5,␉0x3003148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
382␉{ 0x95C5,␉0x3032148C,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
383␉{ 0x95C5,␉0x3010174B,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
384␉{ 0x95C5,␉0x4250174B,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
385␉{ 0x95C5,␉0x30501787,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
386␉{ 0x95C5,␉0x301017AF,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 4230",␉␉␉␉kNull␉␉},␊
387␉{ 0x95C5,␉0x01051A93,␉CHIP_FAMILY_RV620,␉␉"Qimonda Radeon HD 3450",␉␉␉kNull␉␉},␊
388␉{ 0x95C5,␉0x01041A93,␉CHIP_FAMILY_RV620,␉␉"Qimonda Radeon HD 3450",␉␉␉kNull␉␉},␊
389␊
390␉/* Evergreen */␊
391␉{ 0x6898,␉0x032E1043,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5870",␉␉␉␉kUakari␉␉},␊
392␉{ 0x6898,␉0xE140174B,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5870",␉␉␉␉kUakari␉␉},␊
393␉{ 0x6898,␉0x29611682,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5870",␉␉␉␉kUakari␉␉},␊
394␉{ 0x6898,␉0x0B001002,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5870",␉␉␉␉kZonalis␉},␊
395␉{ 0x6898,␉0x00D0106B,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5870",␉␉␉␉kLangur␉␉},␊
396␊
397␉{ 0x6899,␉0x21E41458,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5850",␉␉␉␉kUakari␉␉},␊
398␉{ 0x6899,␉0x200A1787,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5850",␉␉␉␉kUakari␉␉},␊
399␉{ 0x6899,␉0x22901787,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5850",␉␉␉␉kUakari␉␉},␊
400␉{ 0x6899,␉0xE140174B,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5850",␉␉␉␉kUakari␉␉},␊
401␊
402␉{ 0x689C,␉0x03521043,␉CHIP_FAMILY_HEMLOCK,␉"ASUS ARES",␉␉␉␉␉␉kUakari␉␉},␊
403␉{ 0x689C,␉0x039E1043,␉CHIP_FAMILY_HEMLOCK,␉"ASUS EAH5870 Series",␉␉␉␉kUakari␉␉},␊
404␉{ 0x689C,␉0x30201682,␉CHIP_FAMILY_HEMLOCK,␉"ATI Radeon HD 5970",␉␉␉␉kUakari␉␉},␊
405␊
406␉{ 0x68B8,␉0xE147174B,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
407␉{ 0x68B8,␉0x21D71458,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
408␉{ 0x68B8,␉0x1482174B,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
409␉{ 0x68B8,␉0x29901682,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
410␉{ 0x68B8,␉0x29911682,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
411␉{ 0x68B8,␉0x200B1787,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
412␉{ 0x68B8,␉0x22881787,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kVervet␉␉},␊
413␉{ 0x68B8,␉0x00CF106B,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5770",␉␉␉␉kHoolock␉},␊
414␊
415␉{ 0x68D8,␉0x301117AF,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5690",␉␉␉␉kNull␉␉},␊
416␉{ 0x68D8,␉0x301017AF,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5730",␉␉␉␉kNull␉␉},␊
417␉{ 0x68D8,␉0x30001787,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5730",␉␉␉␉kNull␉␉},␊
418␉{ 0x68D8,␉0x5690174B,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5690",␉␉␉␉kNull␉␉},␊
419␉{ 0x68D8,␉0x5730174B,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5730",␉␉␉␉kNull␉␉},␊
420␉{ 0x68D8,␉0x21D91458,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670",␉␉␉␉kBaboon␉␉},␊
421␉{ 0x68D8,␉0x03561043,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670",␉␉␉␉kBaboon␉␉},␊
422␉{ 0x68D8,␉0xE151174B,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5670",␉␉␉␉kBaboon␉␉},␊
423␉{ 0x68D9,␉0x301017AF,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5630",␉␉␉␉kNull␉␉},␊
424␉{ 0x68DA,␉0x301017AF,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5630",␉␉␉␉kNull␉␉},␊
425␉{ 0x68DA,␉0x30001787,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5630",␉␉␉␉kNull␉␉},␊
426␉{ 0x68DA,␉0x5630174B,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5630",␉␉␉␉kNull␉␉},␊
427␊
428␉{ 0x68E0,␉0x04561028,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5470M",␉␉␉␉kEulemur␉},␊
429␉{ 0x68E1,␉0x1426103C,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5430M",␉␉␉␉kEulemur␉},␊
430␉{ 0x68F9,␉0x301317AF,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5470",␉␉␉␉kNull␉␉},␊
431␉{ 0x68F9,␉0x301117AF,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5470",␉␉␉␉kNull␉␉},␊
432␉{ 0x68F9,␉0x301217AF,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5490",␉␉␉␉kNull␉␉},␊
433␉{ 0x68F9,␉0x30001787,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5470",␉␉␉␉kNull␉␉},␊
434␉{ 0x68F9,␉0x30021787,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5490",␉␉␉␉kNull␉␉},␊
435␉{ 0x68F9,␉0x30011787,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5530",␉␉␉␉kNull␉␉},␊
436␉{ 0x68F9,␉0x5470174B,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5470",␉␉␉␉kNull␉␉},␊
437␉{ 0x68F9,␉0x5490174B,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5490",␉␉␉␉kNull␉␉},␊
438␉{ 0x68F9,␉0x5530174B,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5530",␉␉␉␉kNull␉␉},␊
439␊
440␉/* Northen Islands */␊
441␉{ 0x6718,␉0x0B001002,␉CHIP_FAMILY_CAYMAN,␉␉"AMD Radeon HD 6970",␉␉␉␉kNull␉␉},␊
442␉{ 0x6718,␉0x31301682,␉CHIP_FAMILY_CAYMAN,␉␉"AMD Radeon HD 6970",␉␉␉␉kNull␉␉},␊
443␉{ 0x6718,␉0x67181002,␉CHIP_FAMILY_CAYMAN,␉␉"AMD Radeon HD 6970",␉␉␉␉kNull␉␉},␊
444␊
445␉{ 0x6738,␉0x67381002,␉CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6870",␉␉␉␉kDuckweed␉},␊
446␉{ 0x6739,␉0x67391002,␉CHIP_FAMILY_BARTS,␉␉"AMD Radeon HD 6850",␉␉␉␉kDuckweed␉},␊
447␊
448␉{ 0x6759,␉0xE193174B,␉CHIP_FAMILY_TURKS,␉␉"AMD Radeon HD 6570",␉␉␉␉kNull␉␉},␊
449␉␊
450␉/* standard/default models */␊
451␉{ 0x9400,␉0x00000000,␉CHIP_FAMILY_R600,␉␉"ATI Radeon HD 2900 XT",␉␉␉kNull␉␉},␊
452␉{ 0x9405,␉0x00000000,␉CHIP_FAMILY_R600,␉␉"ATI Radeon HD 2900 GT",␉␉␉kNull␉␉},␊
453␉{ 0x9440,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
454␉{ 0x9441,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4870 X2",␉␉␉kMotmot␉␉},␊
455␉{ 0x9442,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
456␉{ 0x9443,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4850 X2",␉␉␉kMotmot␉␉},␊
457␉{ 0x944C,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
458␉{ 0x944E,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4700 Series",␉␉kMotmot␉␉},␊
459␉{ 0x944E,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4700 Series",␉␉kMotmot␉␉},␊
460␉{ 0x9450,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"AMD FireStream 9270",␉␉␉␉kMotmot␉␉},␊
461␉{ 0x9452,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"AMD FireStream 9250",␉␉␉␉kMotmot␉␉},␊
462␉{ 0x9460,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
463␉{ 0x9462,␉0x00000000,␉CHIP_FAMILY_RV770,␉␉"ATI Radeon HD 4800 Series",␉␉kMotmot␉␉},␊
464␉{ 0x9490,␉0x00000000,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4600 Series",␉␉kFlicker␉},␊
465␉{ 0x9498,␉0x00000000,␉CHIP_FAMILY_RV730,␉␉"ATI Radeon HD 4600 Series",␉␉kFlicker␉},␊
466␉{ 0x94B3,␉0x00000000,␉CHIP_FAMILY_RV740,␉␉"ATI Radeon HD 4770",␉␉␉␉kFlicker␉},␊
467␉{ 0x94B4,␉0x00000000,␉CHIP_FAMILY_RV740,␉␉"ATI Radeon HD 4700 Series",␉␉kFlicker␉},␊
468␉{ 0x94B5,␉0x00000000,␉CHIP_FAMILY_RV740,␉␉"ATI Radeon HD 4770",␉␉␉␉kFlicker␉},␊
469␉{ 0x94C1,␉0x00000000,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 Series",␉␉kIago␉␉},␊
470␉{ 0x94C3,␉0x00000000,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 Series",␉␉kIago␉␉},␊
471␉{ 0x94C7,␉0x00000000,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2350",␉␉␉␉kIago␉␉},␊
472␉{ 0x94CC,␉0x00000000,␉CHIP_FAMILY_RV610,␉␉"ATI Radeon HD 2400 Series",␉␉kIago␉␉},␊
473␊
474␉{ 0x9501,␉0x00000000,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3800 Series",␉␉kMegalodon␉},␊
475␉{ 0x9505,␉0x00000000,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3800 Series",␉␉kMegalodon␉},␊
476␉{ 0x9507,␉0x00000000,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3830",␉␉␉␉kMegalodon␉},␊
477␉{ 0x950F,␉0x00000000,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3870 X2",␉␉␉kMegalodon␉},␊
478␉{ 0x9513,␉0x00000000,␉CHIP_FAMILY_RV670,␉␉"ATI Radeon HD 3850 X2",␉␉␉kMegalodon␉},␊
479␉{ 0x9519,␉0x00000000,␉CHIP_FAMILY_RV670,␉␉"AMD FireStream 9170",␉␉␉␉kMegalodon␉},␊
480␉{ 0x9540,␉0x00000000,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4550",␉␉␉␉kNull␉␉},␊
481␉{ 0x954F,␉0x00000000,␉CHIP_FAMILY_RV710,␉␉"ATI Radeon HD 4300/4500 Series",␉kNull␉␉},␊
482␉{ 0x9588,␉0x00000000,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 2600 XT",␉␉␉kLamna␉␉},␊
483␉{ 0x9589,␉0x00000000,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 2600 PRO",␉␉␉kLamna␉␉},␊
484␉{ 0x958A,␉0x00000000,␉CHIP_FAMILY_RV630,␉␉"ATI Radeon HD 2600 X2 Series",␉␉kLamna␉␉},␊
485␉{ 0x9598,␉0x00000000,␉CHIP_FAMILY_RV635,␉␉"ATI Radeon HD 3600 Series",␉␉kMegalodon␉},␊
486␉{ 0x95C0,␉0x00000000,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3400 Series",␉␉kIago␉␉},␊
487␉{ 0x95C5,␉0x00000000,␉CHIP_FAMILY_RV620,␉␉"ATI Radeon HD 3400 Series",␉␉kIago␉␉},␊
488␊
489␉{ 0x9610,␉0x00000000,␉CHIP_FAMILY_RS780,␉␉"ATI Radeon HD 3200 Graphics",␉␉kNull␉␉},␊
490␉{ 0x9611,␉0x00000000,␉CHIP_FAMILY_RS780,␉␉"ATI Radeon 3100 Graphics",␉␉␉kNull␉␉},␊
491␉{ 0x9614,␉0x00000000,␉CHIP_FAMILY_RS780,␉␉"ATI Radeon HD 3300 Graphics",␉␉kNull␉␉},␊
492␉{ 0x9616,␉0x00000000,␉CHIP_FAMILY_RS780,␉␉"AMD 760G",␉␉␉␉␉␉␉kNull␉␉},␊
493␊
494␉{ 0x9710,␉0x00000000,␉CHIP_FAMILY_RS880,␉␉"ATI Radeon HD 4200",␉␉␉␉kNull␉␉},␊
495␉{ 0x9715,␉0x00000000,␉CHIP_FAMILY_RS880,␉␉"ATI Radeon HD 4250",␉␉␉␉kNull␉␉},␊
496␉{ 0x9714,␉0x00000000,␉CHIP_FAMILY_RS880,␉␉"ATI Radeon HD 4290",␉␉␉␉kNull␉␉},␊
497␊
498␊
499␉/* Evergreen */␊
500␉{ 0x688D,␉0x00000000,␉CHIP_FAMILY_CYPRESS,␉"AMD FireStream 9350",␉␉␉␉kUakari␉␉},␊
501␊
502␉{ 0x6898,␉0x00000000,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5800 Series",␉␉kUakari␉␉},␊
503␉{ 0x6899,␉0x00000000,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5800 Series",␉␉kUakari␉␉},␊
504␉{ 0x689E,␉0x00000000,␉CHIP_FAMILY_CYPRESS,␉"ATI Radeon HD 5800 Series",␉␉kUakari␉␉},␊
505␉{ 0x689C,␉0x00000000,␉CHIP_FAMILY_HEMLOCK,␉"ATI Radeon HD 5900 Series",␉␉kUakari␉␉},␊
506␊
507␉{ 0x68B9,␉0x00000000,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5600 Series",␉␉kVervet␉␉},␊
508␉{ 0x68B8,␉0x00000000,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5700 Series",␉␉kVervet␉␉},␊
509␉{ 0x68BE,␉0x00000000,␉CHIP_FAMILY_JUNIPER,␉"ATI Radeon HD 5700 Series",␉␉kVervet␉␉},␊
510␊
511␉{ 0x68D8,␉0x00000000,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5600 Series",␉␉kBaboon␉␉},␊
512␉{ 0x68D9,␉0x00000000,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5500 Series",␉␉kBaboon␉␉},␊
513␉{ 0x68DA,␉0x00000000,␉CHIP_FAMILY_REDWOOD,␉"ATI Radeon HD 5500 Series",␉␉kBaboon␉␉},␊
514␊
515␉{ 0x68F9,␉0x00000000,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5400 Series",␉␉kNull␉␉},␊
516␊
517␉{ 0x6718,␉0x00000000,␉CHIP_FAMILY_CAYMAN,␉␉"AMD Radeon HD 6900 Series",␉␉kNull␉␉},␊
518␊
519␉/* Northen Islands */␊
520␉{ 0x6758,␉0x00000000,␉CHIP_FAMILY_TURKS,␉␉"AMD Radeon HD 6670",␉␉␉␉kNull␉␉},␊
521␉{ 0x6759,␉0x00000000,␉CHIP_FAMILY_TURKS,␉␉"AMD Radeon HD 6500 Series",␉␉kNull␉␉},␊
522␊
523␉{ 0x6770,␉0x00000000,␉CHIP_FAMILY_CAICOS,␉␉"AMD Radeon HD 6400 Series",␉␉kNull␉␉},␊
524␉{ 0x6779,␉0x00000000,␉CHIP_FAMILY_CAICOS,␉␉"AMD Radeon HD 6450 Series",␉␉kNull␉␉},␊
525␉␊
526␉{ 0x68F9,␉0x00000000,␉CHIP_FAMILY_CEDAR,␉␉"ATI Radeon HD 5400 Series",␉␉kNull␉␉},␊
527␊
528␉{ 0x0000,␉0x00000000,␉CHIP_FAMILY_UNKNOW,␉␉NULL,␉␉␉␉␉␉␉␉kNull␉␉}␊
529};␊
530␊
531␊
532typedef struct {␊
533␉struct DevPropDevice␉*device;␊
534␉radeon_card_info_t␉␉*info;␊
535␉pci_dt_t ␉␉␉␉*pci_dev;␊
536␉uint8_t␉␉␉␉␉*fb;␊
537␉uint8_t␉␉␉␉␉*mmio;␊
538␉uint8_t␉␉␉␉␉*io;␊
539␉uint8_t␉␉␉␉␉*rom;␊
540␉uint32_t␉␉␉␉rom_size;␊
541␉uint32_t␉␉␉␉vram_size;␊
542␉const char␉␉␉␉*cfg_name;␊
543␉uint8_t␉␉␉␉␉ports;␊
544␉uint32_t␉␉␉␉flags;␊
545␉bool␉␉␉␉␉posted;␊
546} card_t;␊
547card_t *card;␊
548␊
549/* Flags */␊
550#define MKFLAG(n)␉␉(1 << n)␊
551#define FLAGTRUE␉␉MKFLAG(0)␊
552#define EVERGREEN␉␉MKFLAG(1)␊
553␊
554static uint8_t atN = 0;␊
555␊
556typedef struct {␊
557␉type_t␉␉type;␊
558␉uint32_t␉size;␊
559␉uint8_t␉␉*data;␊
560} value_t;␊
561␊
562static value_t aty_name;␊
563static value_t aty_nameparent;␊
564//static value_t aty_model;␊
565␊
566#define DATVAL(x)␉␉{kPtr, sizeof(x), (uint8_t *)x}␊
567#define STRVAL(x)␉␉{kStr, sizeof(x), (uint8_t *)x}␊
568#define BYTVAL(x)␉␉{kCst, 1, (uint8_t *)x}␊
569#define WRDVAL(x)␉␉{kCst, 2, (uint8_t *)x}␊
570#define DWRVAL(x)␉␉{kCst, 4, (uint8_t *)x}␊
571#define QWRVAL(x)␉␉{kCst, 8, (uint8_t *)x}␊
572#define NULVAL␉␉␉{kNul, 0, (uint8_t *)NULL}␊
573␊
574bool get_bootdisplay_val(value_t *val);␊
575bool get_vrammemory_val(value_t *val);␊
576bool get_name_val(value_t *val);␊
577bool get_nameparent_val(value_t *val);␊
578bool get_model_val(value_t *val);␊
579bool get_conntype_val(value_t *val);␊
580bool get_vrammemsize_val(value_t *val);␊
581bool get_binimage_val(value_t *val);␊
582bool get_romrevision_val(value_t *val);␊
583bool get_deviceid_val(value_t *val);␊
584bool get_mclk_val(value_t *val);␊
585bool get_sclk_val(value_t *val);␊
586bool get_refclk_val(value_t *val);␊
587bool get_platforminfo_val(value_t *val);␊
588bool get_vramtotalsize_val(value_t *val);␊
589␊
590typedef struct {␊
591␉uint32_t␉flags;␊
592␉bool␉␉all_ports;␊
593␉char␉␉*name;␊
594␉bool␉␉(*get_value)(value_t *val);␊
595␉value_t␉␉default_val;␊
596} dev_prop_t;␊
597␊
598dev_prop_t ati_devprop_list[] = {␊
599␉{FLAGTRUE,␉false,␉"@0,AAPL,boot-display",␉␉get_bootdisplay_val,␉NULVAL␉␉␉␉␉␉␉},␊
600//␉{FLAGTRUE,␉false,␉"@0,ATY,EFIDisplay",␉␉NULL,␉␉␉␉␉STRVAL("TMDSA")␉␉␉␉␉},␊
601␊
602//␉{FLAGTRUE,␉true,␉"@0,AAPL,vram-memory",␉␉get_vrammemory_val,␉␉NULVAL␉␉␉␉␉␉␉},␊
603//␉{FLAGTRUE,␉true,␉"@0,compatible",␉␉␉get_name_val,␉␉␉NULVAL␉␉␉␉␉␉␉},␊
604//␉{FLAGTRUE,␉true,␉"@0,connector-type",␉␉get_conntype_val,␉␉NULVAL␉␉␉␉␉␉␉},␊
605//␉{FLAGTRUE,␉true,␉"@0,device_type",␉␉␉NULL,␉␉␉␉␉STRVAL("display")␉␉␉␉},␊
606//␉{FLAGTRUE,␉false,␉"@0,display-connect-flags",␉NULL,␉␉␉␉␉DWRVAL((uint32_t)0)␉␉␉␉},␊
607//␉{FLAGTRUE,␉true,␉"@0,display-type",␉␉␉NULL,␉␉␉␉␉STRVAL("NONE")␉␉␉␉␉},␊
608␉{FLAGTRUE,␉true,␉"@0,name",␉␉␉␉␉get_name_val,␉␉␉NULVAL␉␉␉␉␉␉␉},␊
609//␉{FLAGTRUE,␉true,␉"@0,VRAM,memsize",␉␉␉get_vrammemsize_val,␉NULVAL␉␉␉␉␉␉␉},␊
610␊
611//␉{FLAGTRUE,␉false,␉"AAPL,aux-power-connected",␉NULL,␉␉␉␉␉DWRVAL((uint32_t)1)␉␉␉␉},␊
612//␉{FLAGTRUE,␉false,␉"AAPL,backlight-control",␉NULL,␉␉␉␉␉DWRVAL((uint32_t)0)␉␉␉␉},␊
613␉{FLAGTRUE,␉false,␉"ATY,bin_image",␉␉␉get_binimage_val,␉␉NULVAL␉␉␉␉␉␉␉},␊
614␉{FLAGTRUE,␉false,␉"ATY,Copyright",␉␉␉NULL,␉STRVAL("Copyright AMD Inc. All Rights Reserved. 2005-2010")␉},␊
615␉{FLAGTRUE,␉false,␉"ATY,Card#",␉␉␉␉get_romrevision_val,␉NULVAL␉␉␉␉␉␉␉},␊
616␉{FLAGTRUE,␉false,␉"ATY,VendorID",␉␉␉␉NULL,␉␉␉␉␉WRDVAL((uint16_t)0x1002)␉␉},␊
617␉{FLAGTRUE,␉false,␉"ATY,DeviceID",␉␉␉␉get_deviceid_val,␉␉NULVAL␉␉␉␉␉␉␉},␊
618␊
619//␉{FLAGTRUE,␉false,␉"ATY,MCLK",␉␉␉␉␉get_mclk_val,␉␉␉NULVAL␉␉␉␉␉␉␉},␊
620//␉{FLAGTRUE,␉false,␉"ATY,SCLK",␉␉␉␉␉get_sclk_val,␉␉␉NULVAL␉␉␉␉␉␉␉},␊
621//␉{FLAGTRUE,␉false,␉"ATY,RefCLK",␉␉␉␉get_refclk_val,␉␉␉DWRVAL((uint32_t)0x0a8c)␉␉},␊
622␊
623//␉{FLAGTRUE,␉false,␉"ATY,PlatformInfo",␉␉␉get_platforminfo_val,␉NULVAL␉␉␉␉␉␉␉},␊
624␊
625␉{FLAGTRUE,␉false,␉"name",␉␉␉␉␉␉get_nameparent_val,␉␉NULVAL␉␉␉␉␉␉␉},␊
626␉{FLAGTRUE,␉false,␉"device_type",␉␉␉␉get_nameparent_val,␉␉NULVAL␉␉␉␉␉␉␉},␊
627␉{FLAGTRUE,␉false,␉"model",␉␉␉␉␉get_model_val,␉␉␉STRVAL("ATI Radeon")␉␉␉},␊
628//␉{FLAGTRUE,␉false,␉"VRAM,totalsize",␉␉␉get_vramtotalsize_val,␉NULVAL␉␉␉␉␉␉␉},␊
629␊
630␉{FLAGTRUE,␉false,␉NULL,␉␉␉␉␉␉NULL,␉␉␉␉␉NULVAL␉␉␉␉␉␉␉}␊
631};␊
632␊
633bool get_bootdisplay_val(value_t *val)␊
634{␊
635␉static uint32_t v = 0;␊
636␊
637␉if (v)␊
638␉␉return false;␊
639␊
640␉if (!card->posted)␊
641␉␉return false;␊
642␊
643␉v = 1;␊
644␉val->type = kCst;␊
645␉val->size = 4;␊
646␉val->data = (uint8_t *)&v;␊
647␊
648␉return true;␊
649}␊
650␊
651bool get_vrammemory_val(value_t *val)␊
652{␊
653␉return false;␊
654}␊
655␊
656bool get_name_val(value_t *val)␊
657{␊
658␉val->type = aty_name.type;␊
659␉val->size = aty_name.size;␊
660␉val->data = aty_name.data;␊
661␊
662␉return true;␊
663}␊
664␊
665bool get_nameparent_val(value_t *val)␊
666{␊
667␉val->type = aty_nameparent.type;␊
668␉val->size = aty_nameparent.size;␊
669␉val->data = aty_nameparent.data;␊
670␊
671␉return true;␊
672}␊
673␊
674bool get_model_val(value_t *val)␊
675{␊
676␉if (!card->info->model_name)␊
677␉␉return false;␊
678␊
679␉val->type = kStr;␊
680␉val->size = strlen(card->info->model_name) + 1;␊
681␉val->data = (uint8_t *)card->info->model_name;␊
682␊
683␉return true;␊
684}␊
685␊
686bool get_conntype_val(value_t *val)␊
687{␊
688/*␊
689Connector types:␊
6900x4 : DisplayPort␊
6910x400: DL DVI-I␊
6920x800: HDMI␊
693*/␊
694␉return false;␊
695}␊
696␊
697bool get_vrammemsize_val(value_t *val)␊
698{␊
699␉static int idx = -1;␊
700␉static uint64_t memsize;␊
701␊
702␉idx++;␊
703␉memsize = ((uint64_t)card->vram_size << 32);␊
704␉if (idx == 0)␊
705␉␉memsize = memsize | (uint64_t)card->vram_size;␊
706␊
707␉val->type = kCst;␊
708␉val->size = 8;␊
709␉val->data = (uint8_t *)&memsize;␊
710␊
711␉return true;␊
712}␊
713␊
714bool get_binimage_val(value_t *val)␊
715{␊
716␉if (!card->rom)␊
717␉␉return false;␊
718␊
719␉val->type = kPtr;␊
720␉val->size = card->rom_size;␊
721␉val->data = card->rom;␊
722␊
723␉return true;␊
724}␊
725␊
726bool get_romrevision_val(value_t *val)␊
727{␊
728␉uint8_t *rev;␊
729␉if (!card->rom)␊
730␉␉return false;␊
731␊
732␉rev = card->rom + *(uint8_t *)(card->rom + OFFSET_TO_GET_ATOMBIOS_STRINGS_START);␊
733␊
734␉val->type = kPtr;␊
735␉val->size = strlen((char *)rev);␊
736␉val->data = malloc(val->size);␊
737␊
738␉if (!val->data)␊
739␉␉return false;␊
740␊
741␉memcpy(val->data, rev, val->size);␊
742␊
743␉return true;␊
744}␊
745␊
746bool get_deviceid_val(value_t *val)␊
747{␊
748␉val->type = kCst;␊
749␉val->size = 2;␊
750␉val->data = (uint8_t *)&card->pci_dev->device_id;␊
751␊
752␉return true;␊
753}␊
754␊
755bool get_mclk_val(value_t *val)␊
756{␊
757␉return false;␊
758}␊
759␊
760bool get_sclk_val(value_t *val)␊
761{␊
762␉return false;␊
763}␊
764␊
765bool get_refclk_val(value_t *val)␊
766{␊
767␉return false;␊
768}␊
769␊
770bool get_platforminfo_val(value_t *val)␊
771{␊
772␉val->data = malloc(0x80);␊
773␉if (!val->data)␊
774␉␉return false;␊
775␊
776␉bzero(val->data, 0x80);␊
777␊
778␉val->type␉␉= kPtr;␊
779␉val->size␉␉= 0x80;␊
780␉val->data[0]␉= 1;␊
781␊
782␉return true;␊
783}␊
784␊
785bool get_vramtotalsize_val(value_t *val)␊
786{␊
787␉val->type = kCst;␊
788␉val->size = 4;␊
789␉val->data = (uint8_t *)&card->vram_size;␊
790␊
791␉return true;␊
792}␊
793␊
794void free_val(value_t *val)␊
795{␊
796␉if (val->type == kPtr)␊
797␉␉free(val->data);␊
798␉bzero(val, sizeof(value_t));␊
799}␊
800␊
801void devprop_add_list(dev_prop_t devprop_list[])␊
802{␊
803␉value_t *val = malloc(sizeof(value_t));␊
804␉int i, pnum;␊
805␉for (i = 0; devprop_list[i].name != NULL; i++)␊
806␉␉if ((devprop_list[i].flags == FLAGTRUE) || (devprop_list[i].flags | card->flags))␊
807␉␉␉if (devprop_list[i].get_value && devprop_list[i].get_value(val))␊
808␉␉␉{␊
809␉␉␉␉devprop_add_value(card->device, devprop_list[i].name, val->data, val->size);␊
810␉␉␉␉free_val(val);␊
811␉␉␉␉if (devprop_list[i].all_ports)␊
812␉␉␉␉{␊
813␉␉␉␉␉for (pnum = 1; pnum < card->ports; pnum++)␊
814␉␉␉␉␉{␊
815␉␉␉␉␉␉if (devprop_list[i].get_value(val))␊
816␉␉␉␉␉␉{␊
817␉␉␉␉␉␉␉devprop_list[i].name[1] = 0x30 + pnum; // convert to ascii␊
818␉␉␉␉␉␉␉devprop_add_value(card->device, devprop_list[i].name, val->data, val->size);␊
819␉␉␉␉␉␉␉free_val(val);␊
820␉␉␉␉␉␉}␊
821␉␉␉␉␉}␊
822␉␉␉␉␉devprop_list[i].name[1] = 0x30; // write back our "@0," for a next possible card␊
823␉␉␉␉}␊
824␉␉␉}␊
825␉␉␉else␊
826␉␉␉{␊
827␉␉␉␉if (devprop_list[i].default_val.type != kNul)␊
828␉␉␉␉␉devprop_add_value(card->device, devprop_list[i].name,␊
829␉␉␉␉␉␉devprop_list[i].default_val.type == kCst ?␊
830␉␉␉␉␉␉(uint8_t *)&(devprop_list[i].default_val.data) : devprop_list[i].default_val.data,␊
831␉␉␉␉␉␉devprop_list[i].default_val.size);␊
832␊
833␉␉␉␉if (devprop_list[i].all_ports)␊
834␉␉␉␉{␊
835␉␉␉␉␉for (pnum = 1; pnum < card->ports; pnum++)␊
836␉␉␉␉␉{␊
837␉␉␉␉␉␉if (devprop_list[i].default_val.type != kNul)␊
838␉␉␉␉␉␉{␊
839␉␉␉␉␉␉␉devprop_list[i].name[1] = 0x30 + pnum; // convert to ascii␊
840␉␉␉␉␉␉␉devprop_add_value(card->device, devprop_list[i].name,␊
841␉␉␉␉␉␉␉␉devprop_list[i].default_val.type == kCst ?␊
842␉␉␉␉␉␉␉␉(uint8_t *)&(devprop_list[i].default_val.data) : devprop_list[i].default_val.data,␊
843␉␉␉␉␉␉␉␉devprop_list[i].default_val.size);␊
844␉␉␉␉␉␉}␊
845␉␉␉␉␉}␊
846␉␉␉␉␉devprop_list[i].name[1] = 0x30; // write back our "@0," for a next possible card␊
847␉␉␉␉}␊
848␉␉␉}␊
849␊
850␉free(val);␊
851}␊
852␊
853␊
854bool validate_rom(option_rom_header_t *rom_header, pci_dt_t *pci_dev)␊
855{␊
856␉option_rom_pci_header_t *rom_pci_header;␊
857␊
858␉if (rom_header->signature != 0xaa55)␊
859␉␉return false;␊
860␊
861␉rom_pci_header = (option_rom_pci_header_t *)((uint8_t *)rom_header + rom_header->pci_header_offset);␊
862␊
863␉if (rom_pci_header->signature != 0x52494350)␊
864␉␉return false;␊
865␊
866␉if (rom_pci_header->vendor_id != pci_dev->vendor_id || rom_pci_header->device_id != pci_dev->device_id)␊
867␉␉return false;␊
868␊
869␉return true;␊
870}␊
871␊
872bool load_vbios_file(const char *key, uint16_t vendor_id, uint16_t device_id, uint32_t subsys_id)␊
873{␊
874␉int␉fd;␊
875␉char file_name[24];␊
876␉bool do_load = false;␊
877␊
878␉getBoolForKey(key, &do_load, &bootInfo->bootConfig);␊
879␉if (!do_load)␊
880␉␉return false;␊
881␊
882␉sprintf(file_name, "/Extra/%04x_%04x_%08x.rom", vendor_id, device_id, subsys_id);␊
883␉if ((fd = open_bvdev("bt(0,0)", file_name, 0)) < 0)␊
884␉␉return false;␊
885␊
886␉card->rom_size = file_size(fd);␊
887␉card->rom = malloc(card->rom_size);␊
888␉if (!card->rom)␊
889␉␉return false;␊
890␊
891␉read(fd, (char *)card->rom, card->rom_size);␊
892␊
893␉if (!validate_rom((option_rom_header_t *)card->rom, card->pci_dev))␊
894␉{␊
895␉␉card->rom_size = 0;␊
896␉␉card->rom = 0;␊
897␉␉return false;␊
898␉}␊
899␊
900␉card->rom_size = ((option_rom_header_t *)card->rom)->rom_size * 512;␊
901␊
902␉close(fd);␊
903␊
904␉return true;␊
905}␊
906␊
907void get_vram_size(void)␊
908{␊
909␉chip_family_t chip_family = card->info->chip_family;␊
910␊
911␉card->vram_size = 0;␊
912␊
913␉if (chip_family >= CHIP_FAMILY_CEDAR)␊
914␉␉/* size in MB on evergreen */␊
915␉␉/* XXX watch for overflow!!! */␊
916␉␉card->vram_size = RegRead32(R600_CONFIG_MEMSIZE) * 1024 * 1024;␊
917␉else␊
918␉␉if (chip_family >= CHIP_FAMILY_R600)␊
919␉␉␉card->vram_size = RegRead32(R600_CONFIG_MEMSIZE);␊
920}␊
921␊
922bool read_vbios(bool from_pci)␊
923{␊
924␉option_rom_header_t *rom_addr;␊
925␊
926␉if (from_pci)␊
927␉{␊
928␉␉rom_addr = (option_rom_header_t *)(pci_config_read32(card->pci_dev->dev.addr, PCI_ROM_ADDRESS) & ~0x7ff);␊
929␉␉verbose(" @0x%x", rom_addr);␊
930␉}␊
931␉else␊
932␉␉rom_addr = (option_rom_header_t *)0xc0000;␊
933␊
934␉if (!validate_rom(rom_addr, card->pci_dev))␊
935␉␉return false;␊
936␊
937␉card->rom_size = rom_addr->rom_size * 512;␊
938␉if (!card->rom_size)␊
939␉␉return false;␊
940␊
941␉card->rom = malloc(card->rom_size);␊
942␉if (!card->rom)␊
943␉␉return false;␊
944␊
945␉memcpy(card->rom, (void *)rom_addr, card->rom_size);␊
946␊
947␉return true;␊
948}␊
949␊
950bool read_disabled_vbios(void)␊
951{␊
952␉bool ret = false;␊
953␉chip_family_t chip_family = card->info->chip_family;␊
954␊
955␉if (chip_family >= CHIP_FAMILY_RV770)␊
956␉{␊
957␉␉uint32_t viph_control␉␉= RegRead32(RADEON_VIPH_CONTROL);␊
958␉␉uint32_t bus_cntl␉␉␉= RegRead32(RADEON_BUS_CNTL);␊
959␉␉uint32_t d1vga_control␉␉= RegRead32(AVIVO_D1VGA_CONTROL);␊
960␉␉uint32_t d2vga_control␉␉= RegRead32(AVIVO_D2VGA_CONTROL);␊
961␉␉uint32_t vga_render_control␉= RegRead32(AVIVO_VGA_RENDER_CONTROL);␊
962␉␉uint32_t rom_cntl␉␉␉= RegRead32(R600_ROM_CNTL);␊
963␉␉uint32_t cg_spll_func_cntl␉= 0;␊
964␉␉uint32_t cg_spll_status;␊
965␊
966␉␉/* disable VIP */␊
967␉␉RegWrite32(RADEON_VIPH_CONTROL, (viph_control & ~RADEON_VIPH_EN));␊
968␊
969␉␉/* enable the rom */␊
970␉␉RegWrite32(RADEON_BUS_CNTL, (bus_cntl & ~RADEON_BUS_BIOS_DIS_ROM));␊
971␊
972␉␉/* Disable VGA mode */␊
973␉␉RegWrite32(AVIVO_D1VGA_CONTROL, (d1vga_control & ~(AVIVO_DVGA_CONTROL_MODE_ENABLE | AVIVO_DVGA_CONTROL_TIMING_SELECT)));␊
974␉␉RegWrite32(AVIVO_D2VGA_CONTROL, (d2vga_control & ~(AVIVO_DVGA_CONTROL_MODE_ENABLE | AVIVO_DVGA_CONTROL_TIMING_SELECT)));␊
975␉␉RegWrite32(AVIVO_VGA_RENDER_CONTROL, (vga_render_control & ~AVIVO_VGA_VSTATUS_CNTL_MASK));␊
976␊
977␉␉if (chip_family == CHIP_FAMILY_RV730)␊
978␉␉{␊
979␉␉␉cg_spll_func_cntl = RegRead32(R600_CG_SPLL_FUNC_CNTL);␊
980␊
981␉␉␉/* enable bypass mode */␊
982␉␉␉RegWrite32(R600_CG_SPLL_FUNC_CNTL, (cg_spll_func_cntl | R600_SPLL_BYPASS_EN));␊
983␊
984␉␉␉/* wait for SPLL_CHG_STATUS to change to 1 */␊
985␉␉␉cg_spll_status = 0;␊
986␉␉␉while (!(cg_spll_status & R600_SPLL_CHG_STATUS))␊
987␉␉␉␉cg_spll_status = RegRead32(R600_CG_SPLL_STATUS);␊
988␊
989␉␉␉RegWrite32(R600_ROM_CNTL, (rom_cntl & ~R600_SCK_OVERWRITE));␊
990␉␉}␊
991␉␉else␊
992␉␉␉RegWrite32(R600_ROM_CNTL, (rom_cntl | R600_SCK_OVERWRITE));␊
993␊
994␉␉ret = read_vbios(true);␊
995␊
996␉␉/* restore regs */␊
997␉␉if (chip_family == CHIP_FAMILY_RV730)␊
998␉␉{␊
999␉␉␉RegWrite32(R600_CG_SPLL_FUNC_CNTL, cg_spll_func_cntl);␊
1000␊
1001␉␉␉/* wait for SPLL_CHG_STATUS to change to 1 */␊
1002␉␉␉cg_spll_status = 0;␊
1003␉␉␉while (!(cg_spll_status & R600_SPLL_CHG_STATUS))␊
1004␉␉␉cg_spll_status = RegRead32(R600_CG_SPLL_STATUS);␊
1005␉␉}␊
1006␉␉RegWrite32(RADEON_VIPH_CONTROL, viph_control);␊
1007␉␉RegWrite32(RADEON_BUS_CNTL, bus_cntl);␊
1008␉␉RegWrite32(AVIVO_D1VGA_CONTROL, d1vga_control);␊
1009␉␉RegWrite32(AVIVO_D2VGA_CONTROL, d2vga_control);␊
1010␉␉RegWrite32(AVIVO_VGA_RENDER_CONTROL, vga_render_control);␊
1011␉␉RegWrite32(R600_ROM_CNTL, rom_cntl);␊
1012␉}␊
1013␉else␊
1014␉␉if (chip_family >= CHIP_FAMILY_R600)␊
1015␉␉{␊
1016␉␉␉uint32_t viph_control␉␉␉␉= RegRead32(RADEON_VIPH_CONTROL);␊
1017␉␉␉uint32_t bus_cntl␉␉␉␉␉= RegRead32(RADEON_BUS_CNTL);␊
1018␉␉␉uint32_t d1vga_control␉␉␉␉= RegRead32(AVIVO_D1VGA_CONTROL);␊
1019␉␉␉uint32_t d2vga_control ␉␉␉␉= RegRead32(AVIVO_D2VGA_CONTROL);␊
1020␉␉␉uint32_t vga_render_control␉␉␉= RegRead32(AVIVO_VGA_RENDER_CONTROL);␊
1021␉␉␉uint32_t rom_cntl␉␉␉␉␉= RegRead32(R600_ROM_CNTL);␊
1022␉␉␉uint32_t general_pwrmgt␉␉␉␉= RegRead32(R600_GENERAL_PWRMGT);␊
1023␉␉␉uint32_t low_vid_lower_gpio_cntl␉= RegRead32(R600_LOW_VID_LOWER_GPIO_CNTL);␊
1024␉␉␉uint32_t medium_vid_lower_gpio_cntl␉= RegRead32(R600_MEDIUM_VID_LOWER_GPIO_CNTL);␊
1025␉␉␉uint32_t high_vid_lower_gpio_cntl␉= RegRead32(R600_HIGH_VID_LOWER_GPIO_CNTL);␊
1026␉␉␉uint32_t ctxsw_vid_lower_gpio_cntl␉= RegRead32(R600_CTXSW_VID_LOWER_GPIO_CNTL);␊
1027␉␉␉uint32_t lower_gpio_enable␉␉␉= RegRead32(R600_LOWER_GPIO_ENABLE);␊
1028␊
1029␉␉␉/* disable VIP */␊
1030␉␉␉RegWrite32(RADEON_VIPH_CONTROL, (viph_control & ~RADEON_VIPH_EN));␊
1031␊
1032␉␉␉/* enable the rom */␊
1033␉␉␉RegWrite32(RADEON_BUS_CNTL, (bus_cntl & ~RADEON_BUS_BIOS_DIS_ROM));␊
1034␊
1035␉␉␉/* Disable VGA mode */␊
1036␉␉␉RegWrite32(AVIVO_D1VGA_CONTROL, (d1vga_control & ~(AVIVO_DVGA_CONTROL_MODE_ENABLE | AVIVO_DVGA_CONTROL_TIMING_SELECT)));␊
1037␉␉␉RegWrite32(AVIVO_D2VGA_CONTROL, (d2vga_control & ~(AVIVO_DVGA_CONTROL_MODE_ENABLE | AVIVO_DVGA_CONTROL_TIMING_SELECT)));␊
1038␉␉␉RegWrite32(AVIVO_VGA_RENDER_CONTROL, (vga_render_control & ~AVIVO_VGA_VSTATUS_CNTL_MASK));␊
1039␉␉␉RegWrite32(R600_ROM_CNTL, ((rom_cntl & ~R600_SCK_PRESCALE_CRYSTAL_CLK_MASK) | (1 << R600_SCK_PRESCALE_CRYSTAL_CLK_SHIFT) | R600_SCK_OVERWRITE));␊
1040␉␉␉RegWrite32(R600_GENERAL_PWRMGT, (general_pwrmgt & ~R600_OPEN_DRAIN_PADS));␊
1041␉␉␉RegWrite32(R600_LOW_VID_LOWER_GPIO_CNTL, (low_vid_lower_gpio_cntl & ~0x400));␊
1042␉␉␉RegWrite32(R600_MEDIUM_VID_LOWER_GPIO_CNTL, (medium_vid_lower_gpio_cntl & ~0x400));␊
1043␉␉␉RegWrite32(R600_HIGH_VID_LOWER_GPIO_CNTL, (high_vid_lower_gpio_cntl & ~0x400));␊
1044␉␉␉RegWrite32(R600_CTXSW_VID_LOWER_GPIO_CNTL, (ctxsw_vid_lower_gpio_cntl & ~0x400));␊
1045␉␉␉RegWrite32(R600_LOWER_GPIO_ENABLE, (lower_gpio_enable | 0x400));␊
1046␊
1047␉␉␉ret = read_vbios(true);␊
1048␊
1049␉␉␉/* restore regs */␊
1050␉␉␉RegWrite32(RADEON_VIPH_CONTROL, viph_control);␊
1051␉␉␉RegWrite32(RADEON_BUS_CNTL, bus_cntl);␊
1052␉␉␉RegWrite32(AVIVO_D1VGA_CONTROL, d1vga_control);␊
1053␉␉␉RegWrite32(AVIVO_D2VGA_CONTROL, d2vga_control);␊
1054␉␉␉RegWrite32(AVIVO_VGA_RENDER_CONTROL, vga_render_control);␊
1055␉␉␉RegWrite32(R600_ROM_CNTL, rom_cntl);␊
1056␉␉␉RegWrite32(R600_GENERAL_PWRMGT, general_pwrmgt);␊
1057␉␉␉RegWrite32(R600_LOW_VID_LOWER_GPIO_CNTL, low_vid_lower_gpio_cntl);␊
1058␉␉␉RegWrite32(R600_MEDIUM_VID_LOWER_GPIO_CNTL, medium_vid_lower_gpio_cntl);␊
1059␉␉␉RegWrite32(R600_HIGH_VID_LOWER_GPIO_CNTL, high_vid_lower_gpio_cntl);␊
1060␉␉␉RegWrite32(R600_CTXSW_VID_LOWER_GPIO_CNTL, ctxsw_vid_lower_gpio_cntl);␊
1061␉␉␉RegWrite32(R600_LOWER_GPIO_ENABLE, lower_gpio_enable);␊
1062␊
1063␉␉}␊
1064␊
1065␉return ret;␊
1066}␊
1067␊
1068bool radeon_card_posted(void)␊
1069{␊
1070␉uint32_t reg;␊
1071␊
1072␉/* first check CRTCs */␊
1073␉reg = RegRead32(RADEON_CRTC_GEN_CNTL) | RegRead32(RADEON_CRTC2_GEN_CNTL);␊
1074␉if (reg & RADEON_CRTC_EN)␊
1075␉␉return true;␊
1076␊
1077␉/* then check MEM_SIZE, in case something turned the crtcs off */␊
1078␉reg = RegRead32(R600_CONFIG_MEMSIZE);␊
1079␉if (reg)␊
1080␉␉return true;␊
1081␊
1082␉return false;␊
1083}␊
1084#if 0␊
1085bool devprop_add_pci_config_space(void)␊
1086{␊
1087␉int offset;␊
1088␊
1089␉uint8_t *config_space = malloc(0x100);␊
1090␉if (!config_space)␊
1091␉␉return false;␊
1092␊
1093␉for (offset = 0; offset < 0x100; offset += 4)␊
1094␉␉config_space[offset / 4] = pci_config_read32(card->pci_dev->dev.addr, offset);␊
1095␊
1096␉devprop_add_value(card->device, "ATY,PCIConfigSpace", config_space, 0x100);␊
1097␉free(config_space);␊
1098␉return true;␊
1099}␊
1100#endif␊
1101␊
1102static bool init_card(pci_dt_t *pci_dev)␊
1103{␊
1104␉char name[24];␊
1105␉char name_parent[24];␊
1106␉int i;␊
1107␉bool add_vbios = true;␊
1108␊
1109␉card = malloc(sizeof(card_t));␊
1110␉if (!card)␊
1111␉␉return false;␊
1112␉bzero(card, sizeof(card_t));␊
1113␊
1114␉card->pci_dev = pci_dev;␊
1115␊
1116␉for (i = 0; radeon_cards[i].device_id ; i++)␊
1117␉␉if (radeon_cards[i].device_id == pci_dev->device_id)␊
1118␉␉{␊
1119␉␉␉card->info = &radeon_cards[i];␊
1120␉␉␉if ((radeon_cards[i].subsys_id == 0x00000000) || ␊
1121␉␉␉␉(radeon_cards[i].subsys_id == pci_dev->subsys_id.subsys_id))␊
1122␉␉␉␉break;␊
1123␉␉}␊
1124␊
1125␉if (!card->info->device_id || !card->info->cfg_name)␊
1126␉{␊
1127␉␉printf("Unsupported card!\n");␊
1128␉␉return false;␊
1129␉}␊
1130␊
1131␊
1132␉card->fb␉␉= (uint8_t *)(pci_config_read32(pci_dev->dev.addr, PCI_BASE_ADDRESS_0) & ~0x0f);␊
1133␉card->mmio␉␉= (uint8_t *)(pci_config_read32(pci_dev->dev.addr, PCI_BASE_ADDRESS_2) & ~0x0f);␊
1134␉card->io␉␉= (uint8_t *)(pci_config_read32(pci_dev->dev.addr, PCI_BASE_ADDRESS_4) & ~0x03);␊
1135␊
1136␉verbose("Framebuffer @0x%08X MMIO @0x%08X I/O Port @0x%08X ROM Addr @0x%08X\n",␊
1137␉␉card->fb, card->mmio, card->io, pci_config_read32(pci_dev->dev.addr, PCI_ROM_ADDRESS));␊
1138␊
1139␉card->posted␉= radeon_card_posted();␊
1140␉verbose("ATI card %s, ", card->posted ? "POSTed" : "non-POSTed");␊
1141␊
1142␉get_vram_size();␊
1143␊
1144␉getBoolForKey(kATYbinimage, &add_vbios, &bootInfo->bootConfig);␊
1145␊
1146␉if (add_vbios)␊
1147␉␉if (!load_vbios_file(kUseAtiROM, pci_dev->vendor_id, pci_dev->device_id, pci_dev->subsys_id.subsys_id))␊
1148␉␉{␊
1149␉␉␉verbose("reading VBIOS from %s", card->posted ? "legacy space" : "PCI ROM");␊
1150␉␉␉if (card->posted)␊
1151␉␉␉␉read_vbios(false);␊
1152␉␉␉else␊
1153␉␉␉␉read_disabled_vbios();␊
1154␉␉␉verbose("\n");␊
1155␉␉}␊
1156␊
1157␉card->ports = 2; // default␊
1158␊
1159␉if (card->info->chip_family >= CHIP_FAMILY_CEDAR)␊
1160␉{␊
1161␉␉card->flags |= EVERGREEN;␊
1162␉␉card->ports = 3;␊
1163␉}␊
1164␊
1165␉atN = 0;␊
1166␊
1167␉card->cfg_name = getStringForKey(kAtiConfig, &bootInfo->bootConfig);␊
1168␉if (!card->cfg_name)␊
1169␉{␊
1170␉␉card->cfg_name = card_configs[card->info->cfg_name].name;␊
1171␉␉card->ports = card_configs[card->info->cfg_name].ports;␊
1172␉}␊
1173␉else␊
1174␉{␊
1175␉␉for (i = 0; i < kCfgEnd; i++)␊
1176␉␉␉if (strcmp(card->cfg_name, card_configs[i].name) == 0)␊
1177␉␉␉␉card->ports = card_configs[i].ports;␊
1178␉}␊
1179␊
1180␉sprintf(name, "ATY,%s", card->cfg_name);␊
1181␉aty_name.type = kStr;␊
1182␉aty_name.size = strlen(name) + 1;␊
1183␉aty_name.data = (uint8_t *)name;␊
1184␊
1185␉sprintf(name_parent, "ATY,%sParent", card->cfg_name);␊
1186␉aty_nameparent.type = kStr;␊
1187␉aty_nameparent.size = strlen(name_parent) + 1;␊
1188␉aty_nameparent.data = (uint8_t *)name_parent;␊
1189␊
1190␉return true;␊
1191}␊
1192␊
1193bool setup_ati_devprop(pci_dt_t *ati_dev)␊
1194{␊
1195␉char *devicepath;␊
1196␊
1197␉if (!init_card(ati_dev))␊
1198␉␉return false;␊
1199␊
1200␉/* ------------------------------------------------- */␊
1201␉/* Find a better way to do this (in device_inject.c) */␊
1202␉if (!string)␊
1203␉␉string = devprop_create_string();␊
1204␊
1205␉devicepath = get_pci_dev_path(ati_dev);␊
1206␉card->device = devprop_add_device(string, devicepath);␊
1207␉if (!card->device)␊
1208␉␉return false;␊
1209␉/* ------------------------------------------------- */␊
1210␊
1211#if 0␊
1212␉uint64_t fb␉␉= (uint32_t)card->fb;␊
1213␉uint64_t mmio␉= (uint32_t)card->mmio;␊
1214␉uint64_t io␉␉= (uint32_t)card->io;␊
1215␉devprop_add_value(card->device, "ATY,FrameBufferOffset", &fb, 8);␊
1216␉devprop_add_value(card->device, "ATY,RegisterSpaceOffset", &mmio, 8);␊
1217␉devprop_add_value(card->device, "ATY,IOSpaceOffset", &io, 8);␊
1218#endif␊
1219␊
1220␉devprop_add_list(ati_devprop_list);␊
1221␊
1222␉/* ------------------------------------------------- */␊
1223␉/* Find a better way to do this (in device_inject.c) */␊
1224␉stringdata = malloc(string->length);␊
1225␉memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length);␊
1226␉stringlength = string->length;␊
1227␉/* ------------------------------------------------- */␊
1228␊
1229␉verbose("ATI %s %s %dMB (%s) [%04x:%04x] (subsys [%04x:%04x]):: %s\n", ␊
1230␉␉␉chip_family_name[card->info->chip_family], card->info->model_name, ␊
1231␉␉␉(uint32_t)(card->vram_size / (1024 * 1024)), card->cfg_name, ␊
1232␉␉␉ati_dev->vendor_id, ati_dev->device_id,␊
1233␉␉␉ati_dev->subsys_id.subsys.vendor_id, ati_dev->subsys_id.subsys.device_id,␊
1234␉␉␉devicepath);␊
1235␊
1236␉free(card);␊
1237␊
1238␉return true;␊
1239}␊
1240␊
1241

Archive Download this file

Revision: 307