![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jlaefi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [XP on Mac] / xom / lib|
Return to jlaefi.c CVS log | Up to [XP on Mac] / xom / lib |
1.1 root 1: /*++
2:
3: Copyright (c) 2006 JLA
4:
5: Module Name:
6:
7: jlaefi.c
8:
9: Abstract:
10:
11: EFI helper routines
12:
13: Revision History
14:
15: --*/
16:
17: #include "efi.h"
18: #include "efilib.h"
19: #include "../lib/jlaefi.h"
20:
21: EFI_HANDLE imageHandle;
22: EFI_LOADED_IMAGE* pLoadedImage;
23: struct _EFI_CONSOLE_CONTROL_PROTOCOL* pConsoleControl;
24: SIMPLE_INPUT_INTERFACE* pKeyboard;
25: EFI_UGA_DRAW_PROTOCOL* pUgaDraw = 0;
26: EFI_DECOMPRESS_PROTOCOL* pDecompress;
27:
28: UINTN argc;
29: CHAR16** argv;
30: EFI_STATUS status;
31:
32: #define SHELL_INTERFACE_PROTOCOL \
33: { 0x47c7b223, 0xc42a, 0x11d2, 0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b }
34:
35: EFI_GUID ShellInterfaceProtocol = SHELL_INTERFACE_PROTOCOL;
36:
37: typedef struct _EFI_SHELL_INTERFACE {
38: // Handle back to original image handle & image info
39: EFI_HANDLE ImageHandle;
40: EFI_LOADED_IMAGE *Info;
41:
42: // Parsed arg list
43: CHAR16 **Argv;
44: UINTN Argc;
45:
46: // Storage for file redirection args after parsing
47: CHAR16 **RedirArgv;
48: UINTN RedirArgc;
49:
50: // A file style handle for console io
51: EFI_FILE_HANDLE StdIn;
52: EFI_FILE_HANDLE StdOut;
53: EFI_FILE_HANDLE StdErr;
54:
55: } EFI_SHELL_INTERFACE;
56:
57: EFI_GUID ConsoleControlProtocol = { 0xF42F7782, 0x012E, 0x4C12, 0x99, 0x56, 0x49, 0xf9, 0x43, 0x04, 0xf7, 0x21 };
58:
59: typedef enum {
60: EfiConsoleControlScreenText,
61: EfiConsoleControlScreenGraphics,
62: EfiConsoleControlScreenMax,
63: } EFI_CONSOLE_CONTROL_SCREEN_MODE;
64:
65: typedef struct _EFI_CONSOLE_CONTROL_PROTOCOL {
66: void (*GetMode)(struct _EFI_CONSOLE_CONTROL_PROTOCOL* pThis, EFI_CONSOLE_CONTROL_SCREEN_MODE* currentMode, UINT32 n0, UINT32 n1);
67: void (*SetMode)(struct _EFI_CONSOLE_CONTROL_PROTOCOL* pThis, EFI_CONSOLE_CONTROL_SCREEN_MODE currentMode);
68: } EFI_CONSOLE_CONTROL_PROTOCOL;
69:
70: void InitJLAEFI(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE* SystemTable) {
71: //
72: // Initialize the Library.
73: //
74: InitializeLib (ImageHandle, SystemTable);
75: pKeyboard = SystemTable->ConIn;
76: imageHandle = ImageHandle;
77:
78: // Get loaded image interface to implement exit() function
79: status = BS->HandleProtocol(imageHandle, &LoadedImageProtocol, &pLoadedImage);
80: if (EFI_ERROR(status)) {
81: Print(L"Unable to obtain LoadedImageProtocol interface: %r\n", status);
82: exit(EFI_SUCCESS);
83: }
84:
85: // Get console control interface to set text mode
86: status = LibLocateProtocol(&ConsoleControlProtocol, &pConsoleControl);
87: if (EFI_ERROR(status)) {
88: Print(L"Unable to obtain ConsoleControl interface: %r\n", status);
89: exit(EFI_SUCCESS);
90: }
91:
92: // Get arg list
93: {
94: EFI_SHELL_INTERFACE* pShell;
95: UINT32 handleCount, i;
96: EFI_HANDLE* handles;
97:
98: LibLocateHandle(ByProtocol, &ShellInterfaceProtocol, NULL, &handleCount, &handles);
99: for (i = 0; i < handleCount; ++i) {
100: BS->HandleProtocol(handles[i], &ShellInterfaceProtocol, &pShell);
101: if (pShell->Argc)
102: break;
103: }
104:
105: argc = pShell->Argc;
106: argv = pShell->Argv;
107: }
108:
109: // Locate UGA draw
110: // My iMac 17" reports that two handles implement UgaDraw
111: // But only one actually draws on the screen!!
112: // Both report the same resolution, both implement TextOut.
113: // And worse... Both TextOut->OutputString print to the screen!! (???)
114: // So... in order to draw to the screen, which one should I choose?
115: // What has worked so far is using the second one returned (HACK!)
116: {
117: UINTN NoHandles;
118: UINTN Index;
119: EFI_HANDLE* Handles;
120:
121: // Get list of UgaDraw implementors
122: LibLocateHandle(ByProtocol, &UgaDrawProtocol, NULL, &NoHandles, &Handles);
123:
124: // Enumerate all but keep only the last one (HACK!)
125: for (Index = 0; Index < NoHandles; Index++)
126: BS->HandleProtocol(Handles[Index], &UgaDrawProtocol, &pUgaDraw);
127:
128: // Sanity
129: if (!pUgaDraw)
130: Print(L"jlaefi: Unable to find UgaDraw interface\n");
131: }
132:
133: // Locate decompress algorithm
134: status = LibLocateProtocol(&DecompressProtocol, &pDecompress);
135: if (EFI_ERROR(status)) {
136: Print(L"Unable to obtain Decompress interface: %r\n", status);
137: exit(EFI_SUCCESS);
138: }
139: }
140:
141: void consoleControl(UINTN graphicsMode) {
142: if (pConsoleControl)
143: pConsoleControl->SetMode(pConsoleControl, graphicsMode ? EfiConsoleControlScreenGraphics : EfiConsoleControlScreenText);
144: }
145:
146: EFI_STATUS exec(EFI_HANDLE device, CHAR16* filename) {
147: EFI_DEVICE_PATH* filePath;
148: EFI_HANDLE handle;
149:
150: if (device == NULL)
151: device = pLoadedImage ? pLoadedImage->DeviceHandle : NULL;
152:
153: if (device == NULL) {
154: Print(L"exec(%s): Invalid device\n", filename);
155: return EFI_INVALID_PARAMETER;
156: }
157:
158: filePath = FileDevicePath(device, filename);
159: if (!filePath) {
160: Print(L"exec(%s): Unable to create device path\n", filename);
161: return EFI_OUT_OF_RESOURCES;
162: }
163:
164: status = BS->LoadImage(FALSE, imageHandle, filePath, NULL, 0, &handle);
165: if (EFI_ERROR(status)) {
166: Print(L"exec(%s): Unable to load image: %r\n", filename, status);
167: return EFI_NOT_FOUND;
168: }
169:
170: status = BS->StartImage(handle, NULL, NULL);
171: if (EFI_ERROR(status)) {
172: Print(L"exec(%s): Unable to start image: %r\n", filename, status);
173: return EFI_NOT_STARTED;
174: }
175: return EFI_SUCCESS;
176: }
177:
178: void exit(EFI_STATUS status) {
179: consoleControl(0);
180: BS->Exit(imageHandle, status, 0, NULL);
181: }
182:
183: CHAR16 inputChar(CHAR16* prompt, CHAR16 dflt) {
184: CHAR16 buffer[16];
185:
186: Print(L"%s [%c] : ", prompt, dflt);
187: Input(NULL, buffer, sizeof(buffer));
188: Print(L"\n");
189: if (buffer[0] == 'q')
190: exit(EFI_SUCCESS);
191: if (!buffer[0])
192: return dflt;
193: return buffer[0];
194: }
195:
196: UINT32 inputHex(CHAR16* prompt, UINT32 dflt) {
197: CHAR16 buffer[16];
198:
199: Print(L"%s [%04x] : ", prompt, dflt);
200: Input(NULL, buffer, sizeof(buffer));
201: Print(L"\n");
202: if (buffer[0] == 'q')
203: exit(EFI_SUCCESS);
204: if (!buffer[0])
205: return dflt;
206: return xtoi(buffer);
207: }
208:
209: UINT32 inputDec(CHAR16* prompt, UINT32 dflt) {
210: CHAR16 buffer[16];
211:
212: Print(L"%s [%4d] : ", prompt, dflt);
213: Input(NULL, buffer, sizeof(buffer));
214: Print(L"\n");
215: if (buffer[0] == 'q')
216: exit(EFI_SUCCESS);
217: if (!buffer[0])
218: return dflt;
219: return Atoi(buffer);
220: }
221:
222: void saveMemory(EFI_FILE* rootDir, UINT32 address, UINT32 length, UINTN copyFirst) {
223:
224: #define COPYBUFFERSIZE 0x100000
225:
226: EFI_STATUS status;
227: EFI_FILE* datFile;
228: CHAR16 filename[16];
229: UINT32 sz = length;
230: UINT8* copyBuffer;
231:
232: SPrint(filename, sizeof(filename), L"%05x.dat", address);
233: status = rootDir->Open(rootDir, &datFile, filename, EFI_FILE_MODE_READ, 0);
234: if (!EFI_ERROR(status)) {
235: datFile->Delete(datFile);
236: datFile->Close(datFile);
237: }
238:
239: status = rootDir->Open(rootDir, &datFile, filename, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
240: if (EFI_ERROR(status)) {
241: Print(L"Open(%s): %r\n", filename, status);
242: exit(status);
243: }
244:
245: if (copyFirst) {
246: copyBuffer = AllocatePool(COPYBUFFERSIZE);
247: if (!copyBuffer) {
248: Print(L"Unable to allocate %x byte copy buffer\n", COPYBUFFERSIZE);
249: exit(EFI_OUT_OF_RESOURCES);
250: }
251: }
252:
253: while (length) {
254: UINT8* srcPtr;
255: UINT32 sz;
256:
257: if (copyFirst) {
258: sz = length > COPYBUFFERSIZE ? COPYBUFFERSIZE : length;
259: __asm mov edi, copyBuffer
260: __asm mov esi, address
261: __asm mov ecx, sz
262: __asm shr ecx, 2
263: __asm rep movsd
264: address += sz;
265: srcPtr = copyBuffer;
266: length -= sz;
267: }
268: else {
269: sz = length;
270: srcPtr = (UINT8*)address;
271: length = 0;
272: }
273: Print(L"%X %X %X %X\n", srcPtr, sz, address, length);
274:
275: status = datFile->Write(datFile, &sz, srcPtr);
276: if (EFI_ERROR(status)) {
277: Print(L"Write(%s): %r\n", filename, status);
278: exit(status);
279: }
280: }
281:
282: if (copyFirst) {
283: FreePool(copyBuffer);
284: }
285:
286: Print(L"%s, %d bytes\n", filename, length);
287:
288: datFile->Close(datFile);
289:
290: }
291:
292: EFI_FILE* fileOpen(EFI_HANDLE device, CHAR16* filename, UINTN writeable) {
293: EFI_FILE* root;
294: EFI_FILE* file;
295:
296: if (device == NULL)
297: device = pLoadedImage ? pLoadedImage->DeviceHandle : NULL;
298:
299: if (device == NULL) {
300: Print(L"Invalid device\n");
301: return NULL;
302: }
303:
304: root = LibOpenRoot(device);
305: if (root == NULL)
306: return root;
307:
308: status = root->Open(root, &file, filename, EFI_FILE_MODE_READ, 0);
309: if (writeable) {
310: if (!EFI_ERROR(status)) {
311: file->Delete(file);
312: file->Close(file);
313: }
314:
315: status = root->Open(root, &file, filename, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
316: }
317:
318: if (EFI_ERROR(status))
319: Print(L"Open(%s): %r\n", filename, status);
320: root->Close(root);
321:
322: return file;
323: }
324:
325: EFI_FILE* getFileSystem() {
326: UINT32 i, j;
327: UINTN handleCount;
328: EFI_HANDLE* handles;
329: EFI_HANDLE fs[64];
330: EFI_FILE* fileSystem;
331:
332: // Display all potential storage devices
333: LibLocateHandle(ByProtocol, &FileSystemProtocol, NULL, &handleCount, &handles);
334:
335: for (i = 0, j = 0; i < handleCount && j < sizeof(fs) / sizeof(EFI_HANDLE); ++i) {
336: EFI_HANDLE handle = handles[i];
337: EFI_DEVICE_PATH* dpath = DevicePathFromHandle(handle);
338:
339: if (!dpath)
340: continue;
341:
342: Print(L"%x. %s\n", j + 1, DevicePathToStr(dpath));
343: fs[j++] = handle;
344: }
345: if (!j) {
346: Print(L"No filesystems available\n");
347: exit(EFI_UNSUPPORTED);
348: }
349:
350: // Get the user to choose the filesystem
351: do {
352: UINT32 i = inputHex(L"Please select the target filesystem ", 1);
353: } while (i < 1 || i >= j + 1);
354:
355: // Open file system
356: fileSystem = LibOpenRoot(fs[i - 1]);
357: if (!fileSystem) {
358: Print(L"Unable to open volume\n");
359: exit(EFI_DEVICE_ERROR);
360: }
361:
362: return fileSystem;
363: }
364:
365: EFI_HANDLE* handleList;
366: UINTN maxHandles;
367:
368: void initHandleList() {
369: if (!handleList) {
370: LibLocateHandle(AllHandles, NULL, NULL, &maxHandles, &handleList);
371: }
372: }
373:
374: EFI_HANDLE getHandleById(UINTN id) {
375: initHandleList();
376:
377: if (id <= 0 || id > maxHandles)
378: exit(EFI_INVALID_PARAMETER);
379:
380: return handleList[id - 1];
381: }
382:
383: VOID* getProtocolByHandleId(UINTN id, EFI_GUID* protocol) {
384: VOID* if0;
385: EFI_HANDLE handle = getHandleById(id);
386:
387: status = BS->HandleProtocol(handle, protocol, &if0);
388: if (EFI_ERROR(status))
389: exit(status);
390: return if0;
391: }
392:
393: UINTN getHandleId(EFI_HANDLE handle) {
394: UINTN i;
395:
396: initHandleList();
397:
398: for (i = 0; i < maxHandles; ++i) {
399: if (handleList[i] == handle)
400: return i + 1;
401: }
402: exit(EFI_INVALID_PARAMETER);
403: return 0;
404: }
405:
406: UINT32 getDefaultHexArg(CHAR16* id, UINTN arg, UINT32 dflt) {
407: if (arg >= argc) {
408: // TODO: Get variable named id and return it if present
409: return dflt;
410: }
411:
412: return xtoi(argv[arg]);
413: }
414:
415: CHAR16* getDeviceName(EFI_HANDLE handle) {
416: EFI_COMPONENT_NAME_PROTOCOL* pComponentName = NULL;
417: CHAR16* pName = NULL;
418: EFI_DEVICE_PATH* path;
419:
420: BS->HandleProtocol(handle, &ComponentNameProtocol, &pComponentName);
421: if (pComponentName)
422: pComponentName->GetControllerName(pComponentName, handle, NULL, "eng", &pName);
423: if (pName)
424: return pName;
425:
426: path = DevicePathFromHandle(handle);
427: return path ? DevicePathToStr(path) : L"Unknown";
428: }
429:
430: void dumpHandles(VOID* protocol) {
431: UINTN i, handleCount;
432: EFI_HANDLE* handles;
433:
434: LibLocateHandle(ByProtocol, protocol, NULL, &handleCount, &handles);
435: for (i = 0; i < handleCount; ++i) {
436: Print(L"%02x: %s\n", getHandleId(handles[i]), getDeviceName(handles[i]));
437: }
438: }
439:
440: void dumpHex(VOID* buffer, UINTN bufferOffset, UINTN size, UINTN displayOffset) {
441: UINTN lines = (size + 15) / 16;
442: UINT8* ptr = ((UINT8*)buffer) + bufferOffset;
443: while (lines--) {
444: UINTN i;
445:
446: Print(L"%X: ", displayOffset);
447: for (i = 0; i < 15; ++i) {
448: if (i < size)
449: Print(L"%02x", ptr[i]);
450: else
451: Print(L" ");
452: Print(L"%c", i == 7 ? '-' : ' ');
453: }
454:
455: Print(L" *");
456: for (i = 0; i < 15 && i < size; ++i) {
457: CHAR16 c = ptr[i];
458: Print(L"%c", c < 0x20 || c > 0x7f ? '.' : c);
459: }
460: Print(L"*\n");
461:
462: displayOffset += 16;
463: ptr += 16;
464: size -= 16;
465: }
466: }
467:
468: CHAR16 kbdGet() {
469: EFI_INPUT_KEY key;
470: EFI_STATUS status;
471:
472: status = pKeyboard->ReadKeyStroke(pKeyboard, &key);
473: if (status != EFI_SUCCESS)
474: return 0;
475: return key.UnicodeChar ? key.UnicodeChar : key.ScanCode | 0x8000;
476: }
477:
478: CHAR16 kbdGetKey() {
479: CHAR16 k;
480: while (!(k = kbdGet()));
481: return k;
482: }
483:
484: void* decompress(void* ptr, UINT32 size) {
485: UINT32 destSize, scratchSize;
486: VOID* destBuffer;
487: VOID* scratchBuffer;
488:
489: // Get buffer sizes
490: status = pDecompress->GetInfo(pDecompress, ptr, size, &destSize, &scratchSize);
491: if (EFI_ERROR(status)) {
492: Print(L"decompress: Error getting decompress info for %X: %r\n", ptr, status);
493: return 0;
494: }
495:
496: // Allocate buffers
497: destBuffer = AllocatePool(destSize);
498: if (!destBuffer) {
499: Print(L"decompress: Unable to allocate %,d bytes for target decompress buffer\n", destSize);
500: return 0;
501: }
502:
503: scratchBuffer = AllocatePool(scratchSize);
504: if (!scratchBuffer) {
505: Print(L"decompress: Unable to allocate %,d bytes for scratch decompress buffer\n", scratchBuffer);
506: FreePool(destBuffer);
507: return 0;
508: }
509:
510: // Decompress
511: status = pDecompress->Decompress(pDecompress, ptr, size, destBuffer, destSize, scratchBuffer, scratchSize);
512: if (EFI_ERROR(status)) {
513: Print(L"decompress: Error decompressing file at %X: %r\n", ptr, status);
514: FreePool(scratchBuffer);
515: FreePool(destBuffer);
516: return 0;
517: }
518:
519: // Release scratch buffer
520: FreePool(scratchBuffer);
521: return destBuffer;
522: }
523:
524: void tgaDraw(TGA* tga, UINTN x, UINTN y, TGA_ALIGNMENT alignment) {
525: UINTN horizAlign = alignment & tgaHorizontalMask;
526: UINTN vertAlign = alignment & tgaVerticalMask;
527:
528: // See if this is a valid TGA object
529: if (tga->colorMapType != 0 || tga->imageType != 2 || tga->bits != 32 || tga->identSize != 0) {
530: Print(L"Invalid TGA %X\n", tga);
531: return;
532: }
533: if ((tga->descriptor & 0x20) == 0) {
534: static EFI_UGA_PIXEL buffer[2048];
535: UINTN half = tga->height / 2;
536: UINTN slSize = tga->width * sizeof(EFI_UGA_PIXEL);
537: UINTN y;
538:
539: for (y = 0; y < half; ++y) {
540: void* sl1 = tga->data + y * tga->width;
541: void* sl2 = tga->data + (tga->height - y - 1) * tga->width;
542: CopyMem(buffer, sl1, slSize);
543: CopyMem(sl1 , sl2, slSize);
544: CopyMem(sl2, buffer, slSize);
545: }
546: tga->descriptor |= 0x20;
547: }
548: x = horizAlign == tgaLeft ? x :
549: horizAlign == tgaRight ? x - tga->width : x - tga->width / 2;
550: y = vertAlign == tgaTop ? y :
551: vertAlign == tgaBottom ? y - tga->height : y - tga->height / 2;
552:
553: if (pUgaDraw)
554: pUgaDraw->Blt(pUgaDraw, tga->data, EfiUgaBltBufferToVideo, 0, 0, x, y, tga->width, tga->height, 0);
555: }
556:
557: CHAR16* StrStr(CHAR16* str, CHAR16* str2) {
558: UINTN len, len2, i;
559:
560: len = StrLen(str);
561: len2 = StrLen(str2);
562: for (i = 0; i + len2 <= len; ++i) {
563: if (!StrnCmp(str + i, str2, len2))
564: return str + i;
565: }
566: return 0;
567: }
568:
569: int StrEndsWith(CHAR16* str, CHAR16* str2) {
570: UINTN len, len2;
571:
572: len = StrLen(str);
573: len2 = StrLen(str2);
574: if (len2 > len)
575: return 0;
576:
577: return !StrCmp(str + len - len2, str2);
578: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.