Commit | Line | Data |
---|---|---|
70c0f263 BS |
1 | /* |
2 | * Copyright 2012 Red Hat Inc. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice shall be included in | |
12 | * all copies or substantial portions of the Software. | |
13 | * | |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
20 | * OTHER DEALINGS IN THE SOFTWARE. | |
21 | * | |
22 | * Authors: Ben Skeggs | |
23 | */ | |
24 | ||
25 | #include <core/object.h> | |
26 | #include <core/device.h> | |
27 | #include <core/subdev.h> | |
28 | #include <core/option.h> | |
29 | ||
30 | #include <subdev/bios.h> | |
31 | #include <subdev/bios/bmp.h> | |
32 | #include <subdev/bios/bit.h> | |
33 | ||
34 | u8 | |
35 | nvbios_checksum(const u8 *data, int size) | |
36 | { | |
37 | u8 sum = 0; | |
38 | while (size--) | |
39 | sum += *data++; | |
40 | return sum; | |
41 | } | |
42 | ||
43 | u16 | |
44 | nvbios_findstr(const u8 *data, int size, const char *str, int len) | |
45 | { | |
46 | int i, j; | |
47 | ||
48 | for (i = 0; i <= (size - len); i++) { | |
49 | for (j = 0; j < len; j++) | |
50 | if ((char)data[i + j] != str[j]) | |
51 | break; | |
52 | if (j == len) | |
53 | return i; | |
54 | } | |
55 | ||
56 | return 0; | |
57 | } | |
58 | ||
77145f1c BS |
59 | #if defined(__powerpc__) |
60 | static void | |
61 | nouveau_bios_shadow_of(struct nouveau_bios *bios) | |
62 | { | |
63 | struct pci_dev *pdev = nv_device(bios)->pdev; | |
64 | struct device_node *dn; | |
65 | const u32 *data; | |
fced4b22 | 66 | int size; |
77145f1c BS |
67 | |
68 | dn = pci_device_to_OF_node(pdev); | |
69 | if (!dn) { | |
70 | nv_info(bios, "Unable to get the OF node\n"); | |
71 | return; | |
72 | } | |
73 | ||
74 | data = of_get_property(dn, "NVDA,BMP", &size); | |
00e4845b | 75 | if (data && size) { |
77145f1c BS |
76 | bios->size = size; |
77 | bios->data = kmalloc(bios->size, GFP_KERNEL); | |
78 | if (bios->data) | |
79 | memcpy(bios->data, data, size); | |
80 | } | |
81 | } | |
82 | #endif | |
83 | ||
70c0f263 BS |
84 | static void |
85 | nouveau_bios_shadow_pramin(struct nouveau_bios *bios) | |
86 | { | |
87 | struct nouveau_device *device = nv_device(bios); | |
791dc143 | 88 | u64 addr = 0; |
70c0f263 BS |
89 | u32 bar0 = 0; |
90 | int i; | |
91 | ||
92 | if (device->card_type >= NV_50) { | |
791dc143 ML |
93 | if ( device->card_type < NV_C0 || |
94 | !(nv_rd32(bios, 0x022500) & 0x00000001)) | |
95 | addr = (u64)(nv_rd32(bios, 0x619f04) & 0xffffff00) << 8; | |
96 | ||
70c0f263 BS |
97 | if (!addr) { |
98 | addr = (u64)nv_rd32(bios, 0x001700) << 16; | |
99 | addr += 0xf0000; | |
100 | } | |
101 | ||
102 | bar0 = nv_mask(bios, 0x001700, 0xffffffff, addr >> 16); | |
103 | } | |
104 | ||
105 | /* bail if no rom signature */ | |
106 | if (nv_rd08(bios, 0x700000) != 0x55 || | |
107 | nv_rd08(bios, 0x700001) != 0xaa) | |
108 | goto out; | |
109 | ||
110 | bios->size = nv_rd08(bios, 0x700002) * 512; | |
00e4845b MS |
111 | if (!bios->size) |
112 | goto out; | |
113 | ||
70c0f263 BS |
114 | bios->data = kmalloc(bios->size, GFP_KERNEL); |
115 | if (bios->data) { | |
116 | for (i = 0; i < bios->size; i++) | |
117 | nv_wo08(bios, i, nv_rd08(bios, 0x700000 + i)); | |
118 | } | |
119 | ||
120 | out: | |
121 | if (device->card_type >= NV_50) | |
122 | nv_wr32(bios, 0x001700, bar0); | |
123 | } | |
124 | ||
125 | static void | |
126 | nouveau_bios_shadow_prom(struct nouveau_bios *bios) | |
127 | { | |
128 | struct nouveau_device *device = nv_device(bios); | |
129 | u32 pcireg, access; | |
130 | u16 pcir; | |
131 | int i; | |
132 | ||
133 | /* enable access to rom */ | |
134 | if (device->card_type >= NV_50) | |
135 | pcireg = 0x088050; | |
136 | else | |
137 | pcireg = 0x001850; | |
138 | access = nv_mask(bios, pcireg, 0x00000001, 0x00000000); | |
139 | ||
140 | /* bail if no rom signature, with a workaround for a PROM reading | |
141 | * issue on some chipsets. the first read after a period of | |
142 | * inactivity returns the wrong result, so retry the first header | |
143 | * byte a few times before giving up as a workaround | |
144 | */ | |
145 | i = 16; | |
146 | do { | |
147 | if (nv_rd08(bios, 0x300000) == 0x55) | |
148 | break; | |
149 | } while (i--); | |
150 | ||
151 | if (!i || nv_rd08(bios, 0x300001) != 0xaa) | |
152 | goto out; | |
153 | ||
154 | /* additional check (see note below) - read PCI record header */ | |
155 | pcir = nv_rd08(bios, 0x300018) | | |
156 | nv_rd08(bios, 0x300019) << 8; | |
157 | if (nv_rd08(bios, 0x300000 + pcir) != 'P' || | |
158 | nv_rd08(bios, 0x300001 + pcir) != 'C' || | |
159 | nv_rd08(bios, 0x300002 + pcir) != 'I' || | |
160 | nv_rd08(bios, 0x300003 + pcir) != 'R') | |
161 | goto out; | |
162 | ||
163 | /* read entire bios image to system memory */ | |
164 | bios->size = nv_rd08(bios, 0x300002) * 512; | |
00e4845b MS |
165 | if (!bios->size) |
166 | goto out; | |
167 | ||
70c0f263 BS |
168 | bios->data = kmalloc(bios->size, GFP_KERNEL); |
169 | if (bios->data) { | |
170 | for (i = 0; i < bios->size; i++) | |
171 | nv_wo08(bios, i, nv_rd08(bios, 0x300000 + i)); | |
172 | } | |
173 | ||
174 | out: | |
175 | /* disable access to rom */ | |
176 | nv_wr32(bios, pcireg, access); | |
177 | } | |
178 | ||
a91ed42d | 179 | #if defined(CONFIG_ACPI) && defined(CONFIG_X86) |
70c0f263 BS |
180 | int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len); |
181 | bool nouveau_acpi_rom_supported(struct pci_dev *pdev); | |
182 | #else | |
183 | static inline bool | |
184 | nouveau_acpi_rom_supported(struct pci_dev *pdev) { | |
185 | return false; | |
186 | } | |
187 | ||
188 | static inline int | |
189 | nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len) { | |
190 | return -EINVAL; | |
191 | } | |
192 | #endif | |
193 | ||
194 | static void | |
195 | nouveau_bios_shadow_acpi(struct nouveau_bios *bios) | |
196 | { | |
197 | struct pci_dev *pdev = nv_device(bios)->pdev; | |
9a334cd0 | 198 | int ret, cnt, i; |
70c0f263 | 199 | |
90e2889c MP |
200 | if (!nouveau_acpi_rom_supported(pdev)) { |
201 | bios->data = NULL; | |
70c0f263 | 202 | return; |
90e2889c | 203 | } |
70c0f263 | 204 | |
70c0f263 | 205 | bios->size = 0; |
d1626a96 BS |
206 | bios->data = kmalloc(4096, GFP_KERNEL); |
207 | if (bios->data) { | |
208 | if (nouveau_acpi_get_bios_chunk(bios->data, 0, 4096) == 4096) | |
209 | bios->size = bios->data[2] * 512; | |
210 | kfree(bios->data); | |
211 | } | |
212 | ||
00e4845b MS |
213 | if (!bios->size) |
214 | return; | |
70c0f263 | 215 | |
9a334cd0 | 216 | bios->data = kmalloc(bios->size, GFP_KERNEL); |
de2b8b8b BS |
217 | if (bios->data) { |
218 | /* disobey the acpi spec - much faster on at least w530 ... */ | |
219 | ret = nouveau_acpi_get_bios_chunk(bios->data, 0, bios->size); | |
220 | if (ret != bios->size || | |
221 | nvbios_checksum(bios->data, bios->size)) { | |
222 | /* ... that didn't work, ok, i'll be good now */ | |
223 | for (i = 0; i < bios->size; i += cnt) { | |
224 | cnt = min((bios->size - i), (u32)4096); | |
225 | ret = nouveau_acpi_get_bios_chunk(bios->data, i, cnt); | |
226 | if (ret != cnt) | |
227 | break; | |
228 | } | |
229 | } | |
70c0f263 BS |
230 | } |
231 | } | |
232 | ||
233 | static void | |
234 | nouveau_bios_shadow_pci(struct nouveau_bios *bios) | |
235 | { | |
236 | struct pci_dev *pdev = nv_device(bios)->pdev; | |
237 | size_t size; | |
238 | ||
239 | if (!pci_enable_rom(pdev)) { | |
240 | void __iomem *rom = pci_map_rom(pdev, &size); | |
241 | if (rom && size) { | |
242 | bios->data = kmalloc(size, GFP_KERNEL); | |
243 | if (bios->data) { | |
244 | memcpy_fromio(bios->data, rom, size); | |
245 | bios->size = size; | |
246 | } | |
247 | } | |
248 | if (rom) | |
249 | pci_unmap_rom(pdev, rom); | |
250 | ||
251 | pci_disable_rom(pdev); | |
252 | } | |
253 | } | |
254 | ||
121cdf08 MG |
255 | static void |
256 | nouveau_bios_shadow_platform(struct nouveau_bios *bios) | |
257 | { | |
258 | struct pci_dev *pdev = nv_device(bios)->pdev; | |
259 | size_t size; | |
260 | ||
261 | void __iomem *rom = pci_platform_rom(pdev, &size); | |
262 | if (rom && size) { | |
263 | bios->data = kmalloc(size, GFP_KERNEL); | |
264 | if (bios->data) { | |
265 | memcpy_fromio(bios->data, rom, size); | |
266 | bios->size = size; | |
267 | } | |
268 | } | |
269 | } | |
270 | ||
70c0f263 BS |
271 | static int |
272 | nouveau_bios_score(struct nouveau_bios *bios, const bool writeable) | |
273 | { | |
00e4845b MS |
274 | if (bios->size < 3 || !bios->data || bios->data[0] != 0x55 || |
275 | bios->data[1] != 0xAA) { | |
70c0f263 BS |
276 | nv_info(bios, "... signature not found\n"); |
277 | return 0; | |
278 | } | |
279 | ||
00e4845b MS |
280 | if (nvbios_checksum(bios->data, |
281 | min_t(u32, bios->data[2] * 512, bios->size))) { | |
70c0f263 BS |
282 | nv_info(bios, "... checksum invalid\n"); |
283 | /* if a ro image is somewhat bad, it's probably all rubbish */ | |
284 | return writeable ? 2 : 1; | |
285 | } | |
286 | ||
287 | nv_info(bios, "... appears to be valid\n"); | |
288 | return 3; | |
289 | } | |
290 | ||
291 | struct methods { | |
77145f1c | 292 | const char desc[16]; |
70c0f263 BS |
293 | void (*shadow)(struct nouveau_bios *); |
294 | const bool rw; | |
295 | int score; | |
296 | u32 size; | |
297 | u8 *data; | |
298 | }; | |
299 | ||
300 | static int | |
301 | nouveau_bios_shadow(struct nouveau_bios *bios) | |
302 | { | |
303 | struct methods shadow_methods[] = { | |
77145f1c BS |
304 | #if defined(__powerpc__) |
305 | { "OpenFirmware", nouveau_bios_shadow_of, true, 0, 0, NULL }, | |
306 | #endif | |
70c0f263 BS |
307 | { "PRAMIN", nouveau_bios_shadow_pramin, true, 0, 0, NULL }, |
308 | { "PROM", nouveau_bios_shadow_prom, false, 0, 0, NULL }, | |
309 | { "ACPI", nouveau_bios_shadow_acpi, true, 0, 0, NULL }, | |
310 | { "PCIROM", nouveau_bios_shadow_pci, true, 0, 0, NULL }, | |
121cdf08 | 311 | { "PLATFORM", nouveau_bios_shadow_platform, true, 0, 0, NULL }, |
70c0f263 BS |
312 | {} |
313 | }; | |
314 | struct methods *mthd, *best; | |
315 | const struct firmware *fw; | |
316 | const char *optarg; | |
317 | int optlen, ret; | |
318 | char *source; | |
319 | ||
320 | optarg = nouveau_stropt(nv_device(bios)->cfgopt, "NvBios", &optlen); | |
321 | source = optarg ? kstrndup(optarg, optlen, GFP_KERNEL) : NULL; | |
322 | if (source) { | |
323 | /* try to match one of the built-in methods */ | |
324 | mthd = shadow_methods; | |
325 | do { | |
326 | if (strcasecmp(source, mthd->desc)) | |
327 | continue; | |
328 | nv_info(bios, "source: %s\n", mthd->desc); | |
329 | ||
330 | mthd->shadow(bios); | |
331 | mthd->score = nouveau_bios_score(bios, mthd->rw); | |
332 | if (mthd->score) { | |
333 | kfree(source); | |
334 | return 0; | |
335 | } | |
336 | } while ((++mthd)->shadow); | |
337 | ||
338 | /* attempt to load firmware image */ | |
339 | ret = request_firmware(&fw, source, &nv_device(bios)->pdev->dev); | |
340 | if (ret == 0) { | |
341 | bios->size = fw->size; | |
342 | bios->data = kmemdup(fw->data, fw->size, GFP_KERNEL); | |
343 | release_firmware(fw); | |
344 | ||
345 | nv_info(bios, "image: %s\n", source); | |
346 | if (nouveau_bios_score(bios, 1)) { | |
347 | kfree(source); | |
348 | return 0; | |
349 | } | |
350 | ||
351 | kfree(bios->data); | |
352 | bios->data = NULL; | |
353 | } | |
354 | ||
355 | nv_error(bios, "source \'%s\' invalid\n", source); | |
356 | kfree(source); | |
357 | } | |
358 | ||
359 | mthd = shadow_methods; | |
360 | do { | |
361 | nv_info(bios, "checking %s for image...\n", mthd->desc); | |
362 | mthd->shadow(bios); | |
363 | mthd->score = nouveau_bios_score(bios, mthd->rw); | |
364 | mthd->size = bios->size; | |
365 | mthd->data = bios->data; | |
366 | bios->data = NULL; | |
367 | } while (mthd->score != 3 && (++mthd)->shadow); | |
368 | ||
369 | mthd = shadow_methods; | |
370 | best = mthd; | |
371 | do { | |
372 | if (mthd->score > best->score) { | |
373 | kfree(best->data); | |
374 | best = mthd; | |
375 | } | |
376 | } while ((++mthd)->shadow); | |
377 | ||
378 | if (best->score) { | |
379 | nv_info(bios, "using image from %s\n", best->desc); | |
380 | bios->size = best->size; | |
381 | bios->data = best->data; | |
382 | return 0; | |
383 | } | |
384 | ||
385 | nv_error(bios, "unable to locate usable image\n"); | |
386 | return -EINVAL; | |
387 | } | |
388 | ||
389 | static u8 | |
0a32241d | 390 | nouveau_bios_rd08(struct nouveau_object *object, u64 addr) |
70c0f263 BS |
391 | { |
392 | struct nouveau_bios *bios = (void *)object; | |
393 | return bios->data[addr]; | |
394 | } | |
395 | ||
396 | static u16 | |
0a32241d | 397 | nouveau_bios_rd16(struct nouveau_object *object, u64 addr) |
70c0f263 BS |
398 | { |
399 | struct nouveau_bios *bios = (void *)object; | |
400 | return get_unaligned_le16(&bios->data[addr]); | |
401 | } | |
402 | ||
403 | static u32 | |
0a32241d | 404 | nouveau_bios_rd32(struct nouveau_object *object, u64 addr) |
70c0f263 BS |
405 | { |
406 | struct nouveau_bios *bios = (void *)object; | |
407 | return get_unaligned_le32(&bios->data[addr]); | |
408 | } | |
409 | ||
410 | static void | |
0a32241d | 411 | nouveau_bios_wr08(struct nouveau_object *object, u64 addr, u8 data) |
70c0f263 BS |
412 | { |
413 | struct nouveau_bios *bios = (void *)object; | |
414 | bios->data[addr] = data; | |
415 | } | |
416 | ||
417 | static void | |
0a32241d | 418 | nouveau_bios_wr16(struct nouveau_object *object, u64 addr, u16 data) |
70c0f263 BS |
419 | { |
420 | struct nouveau_bios *bios = (void *)object; | |
421 | put_unaligned_le16(data, &bios->data[addr]); | |
422 | } | |
423 | ||
424 | static void | |
0a32241d | 425 | nouveau_bios_wr32(struct nouveau_object *object, u64 addr, u32 data) |
70c0f263 BS |
426 | { |
427 | struct nouveau_bios *bios = (void *)object; | |
428 | put_unaligned_le32(data, &bios->data[addr]); | |
429 | } | |
430 | ||
431 | static int | |
432 | nouveau_bios_ctor(struct nouveau_object *parent, | |
433 | struct nouveau_object *engine, | |
434 | struct nouveau_oclass *oclass, void *data, u32 size, | |
435 | struct nouveau_object **pobject) | |
436 | { | |
437 | struct nouveau_bios *bios; | |
438 | struct bit_entry bit_i; | |
439 | int ret; | |
440 | ||
441 | ret = nouveau_subdev_create(parent, engine, oclass, 0, | |
442 | "VBIOS", "bios", &bios); | |
443 | *pobject = nv_object(bios); | |
444 | if (ret) | |
445 | return ret; | |
446 | ||
447 | ret = nouveau_bios_shadow(bios); | |
448 | if (ret) | |
449 | return ret; | |
450 | ||
451 | /* detect type of vbios we're dealing with */ | |
452 | bios->bmp_offset = nvbios_findstr(bios->data, bios->size, | |
453 | "\xff\x7f""NV\0", 5); | |
454 | if (bios->bmp_offset) { | |
455 | nv_info(bios, "BMP version %x.%x\n", | |
456 | bmp_version(bios) >> 8, | |
457 | bmp_version(bios) & 0xff); | |
458 | } | |
459 | ||
460 | bios->bit_offset = nvbios_findstr(bios->data, bios->size, | |
461 | "\xff\xb8""BIT", 5); | |
462 | if (bios->bit_offset) | |
463 | nv_info(bios, "BIT signature found\n"); | |
464 | ||
465 | /* determine the vbios version number */ | |
466 | if (!bit_entry(bios, 'i', &bit_i) && bit_i.length >= 4) { | |
467 | bios->version.major = nv_ro08(bios, bit_i.offset + 3); | |
468 | bios->version.chip = nv_ro08(bios, bit_i.offset + 2); | |
469 | bios->version.minor = nv_ro08(bios, bit_i.offset + 1); | |
470 | bios->version.micro = nv_ro08(bios, bit_i.offset + 0); | |
0dd660d4 | 471 | bios->version.patch = nv_ro08(bios, bit_i.offset + 4); |
70c0f263 BS |
472 | } else |
473 | if (bmp_version(bios)) { | |
474 | bios->version.major = nv_ro08(bios, bios->bmp_offset + 13); | |
475 | bios->version.chip = nv_ro08(bios, bios->bmp_offset + 12); | |
476 | bios->version.minor = nv_ro08(bios, bios->bmp_offset + 11); | |
477 | bios->version.micro = nv_ro08(bios, bios->bmp_offset + 10); | |
478 | } | |
479 | ||
0dd660d4 | 480 | nv_info(bios, "version %02x.%02x.%02x.%02x.%02x\n", |
70c0f263 | 481 | bios->version.major, bios->version.chip, |
0dd660d4 | 482 | bios->version.minor, bios->version.micro, bios->version.patch); |
70c0f263 BS |
483 | |
484 | return 0; | |
485 | } | |
486 | ||
487 | static void | |
488 | nouveau_bios_dtor(struct nouveau_object *object) | |
489 | { | |
490 | struct nouveau_bios *bios = (void *)object; | |
491 | kfree(bios->data); | |
492 | nouveau_subdev_destroy(&bios->base); | |
493 | } | |
494 | ||
495 | static int | |
496 | nouveau_bios_init(struct nouveau_object *object) | |
497 | { | |
498 | struct nouveau_bios *bios = (void *)object; | |
499 | return nouveau_subdev_init(&bios->base); | |
500 | } | |
501 | ||
502 | static int | |
503 | nouveau_bios_fini(struct nouveau_object *object, bool suspend) | |
504 | { | |
505 | struct nouveau_bios *bios = (void *)object; | |
506 | return nouveau_subdev_fini(&bios->base, suspend); | |
507 | } | |
508 | ||
509 | struct nouveau_oclass | |
510 | nouveau_bios_oclass = { | |
511 | .handle = NV_SUBDEV(VBIOS, 0x00), | |
512 | .ofuncs = &(struct nouveau_ofuncs) { | |
513 | .ctor = nouveau_bios_ctor, | |
514 | .dtor = nouveau_bios_dtor, | |
515 | .init = nouveau_bios_init, | |
516 | .fini = nouveau_bios_fini, | |
517 | .rd08 = nouveau_bios_rd08, | |
518 | .rd16 = nouveau_bios_rd16, | |
519 | .rd32 = nouveau_bios_rd32, | |
520 | .wr08 = nouveau_bios_wr08, | |
521 | .wr16 = nouveau_bios_wr16, | |
522 | .wr32 = nouveau_bios_wr32, | |
523 | }, | |
524 | }; |