Chameleon

Chameleon Svn Source Tree

Root/tags/2.0/i386/libsaio/ati.c

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

Archive Download this file

Revision: 1808