8e0fb4ab7260a6de2c0b3eb416e0c6a08f52efa8
[mirror_edk2.git] / Tools / Source / FrameworkTasks / org / tianocore / framework / tasks / GenFfsFileTask.java
1 /** @file
2 GenFfsFileTask class.
3
4 GenFfsFileTaks is to generate ffs file.
5
6 Copyright (c) 2006, Intel Corporation
7 All rights reserved. This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16 package org.tianocore.framework.tasks;
17
18 import java.io.DataInputStream;
19 import java.io.DataOutputStream;
20 import java.io.File;
21 import java.io.FileInputStream;
22 import java.io.FileOutputStream;
23 import java.util.ArrayList;
24 import java.util.Iterator;
25 import java.util.List;
26
27 import org.apache.tools.ant.BuildException;
28 import org.apache.tools.ant.Project;
29 import org.apache.tools.ant.Task;
30
31 /**
32 GenFfsFileTask
33
34 GenFfsFileTaks is to generate ffs file.
35
36 **/
37 public class GenFfsFileTask extends Task implements EfiDefine, FfsTypes {
38 /**
39 * GenFfsFile Task Class
40 * class member
41 * -baseName : module baseName
42 * -ffsFileGuid : module Guid.
43 * -ffsFileType : Ffs file type.
44 * -ffsAttributeRecovery : The file is required for recovery.
45 * -ffsAligment : The file data alignment (0 if none required). See FFS
46 * specification for supported alignments (0-7 are only possible
47 * values). *
48 * -ffsAttributeCheckSum : The file data is checksummed. If this is FALSE a
49 * value of 0x5A will be inserted in the file
50 * checksum field of the file header. *
51 * -sectFileDir : specifies the full path to the component build directory.
52 * Required.
53 * -ffsAttrib : Data recorde attribute added result.
54 * -sectionList : List recorded all section elemet in task.
55 */
56 ///
57 /// module baseName
58 ///
59 String baseName = "";
60 ///
61 ///
62 ///
63 String moduleType;
64 ///
65 /// module Guid
66 ///
67 String ffsFileGuid = "";
68 ///
69 /// Ffs file type
70 ///
71 String ffsFileType = "";
72 ///
73 /// ffsAttribHeaderExtension value is used to set the corresponding bit in
74 /// the output FFS file header
75 ///
76 boolean ffsAttribHeaderExtension = false;
77 ///
78 /// ffsAttribTailPresent value is used to set the corresponding bit in the
79 /// output FFS file header
80 ///
81 boolean ffsAttribTailPresent = false;
82 ///
83 /// ffsAttribRecovery value is used to set the corresponding bit in the
84 /// output FFS file header
85 ///
86 boolean ffsAttribRecovery = false;
87 ///
88 /// ffsAttribDataAlignment value is used to set the corresponding bit in the output
89 /// FFS file header.The specified FFS alignment must be a value between 0
90 /// and 7 inclusive
91 ///
92 int ffsAttribDataAlignment = 0;
93 ///
94 /// ffsAttribChecksum value is used to set the corresponding bit in the
95 /// output FFS file header
96 ///
97 boolean FfsAttribChecksum = false;
98 ///
99 /// Attribute is used to record the sum of all bit in the output FFS file.
100 ///
101 byte attributes = 0;
102 ///
103 /// The output directory of ffs file.
104 ///
105 String outputDir = "";
106 ///
107 /// List of section.
108 ///
109 List<Object> sectionList = new ArrayList<Object>();
110
111 ///
112 /// The path of Framewor_Tools_Paht.
113 ///
114 static String path = "";
115
116 /**
117 execute
118
119 GenFfsFileTask execute is to generate ffs file according to input section
120 dscriptive information.
121 **/
122 public void execute() throws BuildException {
123 Section sect;
124 int fileSize;
125 int orgFileSize;
126 int fileDataSize;
127 int orgFileDataSize;
128 File ffsFile;
129 File ffsOrgFile;
130 FfsHeader ffsHeader = new FfsHeader();
131 FfsHeader orgFfsHeader = new FfsHeader();
132 String ffsSuffix = "";
133 String outputPath = "";
134
135 //
136 // Get Fraemwork_Tools_Path
137 //
138 Project pj = this.getOwningTarget().getProject();
139 path = pj.getProperty("env.FRAMEWORK_TOOLS_PATH");
140
141 //
142 // Check does the BaseName, Guid, FileType set value.
143 //
144 if (this.baseName.equals("")) {
145 throw new BuildException ("Must set BaseName!\n");
146 }
147
148 if (this.ffsFileGuid.equals("")) {
149 throw new BuildException ("Must set ffsFileGuid!\n");
150 }
151
152 if (this.ffsFileType.equals("")) {
153 throw new BuildException ("Must set ffsFileType!\n");
154 }
155
156 //
157 // Create ffs file. File name = FfsFileGuid + BaseName + ffsSuffix.
158 // If outputDir's value was set, file will output to the outputDir.
159 //
160 ffsSuffix = TypeToSuffix (this.moduleType);
161 if (!this.outputDir.equals("")) {
162 String temp;
163 outputPath = this.outputDir;
164 temp = outputPath.replace('\\', File.separatorChar);
165 outputPath = temp.replace('/', File.separatorChar);
166 if (outputPath.charAt(outputPath.length()-1) != File.separatorChar) {
167 outputPath = outputPath + File.separator;
168 }
169
170 }
171
172 String ffsFilePath = outputPath + this.ffsFileGuid + '-' + this.baseName + ffsSuffix;
173 ffsFile = new File (ffsFilePath);
174 //
175 // Create ffs ORG file. fileName = FfsFileGuid + BaseName + ffsSuffix +
176 // ".org".
177 //
178 ffsOrgFile = new File(ffsFilePath + ".org");
179
180 log(ffsFile.getName());
181 log(ffsOrgFile.getName());
182 try {
183 //
184 // Create file output stream -- dataBuffer.
185 //
186 FileOutputStream dataFs = new FileOutputStream (ffsFile.getAbsolutePath());
187 DataOutputStream dataBuffer = new DataOutputStream (dataFs);
188
189 //
190 // Create org file output stream -- orgDataBuffer
191 //
192 FileOutputStream orgDataFs = new FileOutputStream (ffsOrgFile.getAbsolutePath());
193 DataOutputStream orgDataBuffer = new DataOutputStream (orgDataFs);
194
195 //
196 // Search SectionList find earch section and call it's
197 // ToBuffer function.
198 //
199 Iterator sectionIter = this.sectionList.iterator();
200 while (sectionIter.hasNext()) {
201 sect = (Section)sectionIter.next();
202
203 try {
204 //
205 // The last section don't need 4 byte ffsAligment.
206 //
207 sect.toBuffer((DataOutputStream)dataBuffer, (DataOutputStream) orgDataBuffer);
208 } catch (Exception e) {
209 throw new BuildException (e.getMessage());
210 }
211 }
212 dataBuffer.close();
213 orgDataBuffer.close();
214 } catch (Exception e) {
215 throw new BuildException (e.getMessage());
216 }
217
218 //
219 // Creat Ffs file header
220 //
221 try {
222
223 //
224 // create input stream to read file data
225 //
226 byte[] fileBuffer = new byte[(int)ffsFile.length()];
227 FileInputStream fi = new FileInputStream (ffsFile.getAbsolutePath());
228 DataInputStream di = new DataInputStream (fi);
229 di.read(fileBuffer);
230 di.close();
231
232 //
233 // create input org stream to read file data
234 //
235 byte[] orgFileBuffer = new byte[(int)ffsOrgFile.length()];
236 FileInputStream ofi = new FileInputStream (ffsOrgFile.getAbsolutePath());
237 DataInputStream odi = new DataInputStream (ofi);
238 odi.read(orgFileBuffer);
239 odi.close();
240
241 //
242 // Add GUID to header struct
243 //
244 if (this.ffsFileGuid != null) {
245 stringToGuid (this.ffsFileGuid, ffsHeader.name);
246 //
247 // Add Guid to org header struct
248 //
249 stringToGuid (this.ffsFileGuid, orgFfsHeader.name);
250 }
251
252 ffsHeader.ffsAttributes = this.attributes;
253 if ((ffsHeader.fileType = stringToType(this.ffsFileType))== -1) {
254 throw new BuildException ("FFS_FILE_TYPE unknow!\n");
255 }
256
257 //
258 // Copy ffsHeader.ffsAttribute and fileType to orgFfsHeader.ffsAttribute
259 // and fileType
260 //
261 orgFfsHeader.ffsAttributes = ffsHeader.ffsAttributes;
262 orgFfsHeader.fileType = ffsHeader.fileType;
263
264 //
265 // Adjust file size. The function is used to tripe the last
266 // section padding of 4 binary boundary.
267 //
268 //
269 if (ffsHeader.fileType != EFI_FV_FILETYPE_RAW) {
270
271 fileDataSize = adjustFileSize (fileBuffer);
272 orgFileDataSize = adjustFileSize (orgFileBuffer);
273
274 } else {
275 fileDataSize = fileBuffer.length;
276 orgFileDataSize = orgFileBuffer.length;
277 }
278
279 //
280 // 1. add header size to file size
281 //
282 fileSize = fileDataSize + ffsHeader.getSize();
283 //
284 // add header size to org file size
285 //
286 orgFileSize = orgFileDataSize + ffsHeader.getSize();
287
288 if ((ffsHeader.ffsAttributes & FFS_ATTRIB_TAIL_PRESENT) != 0) {
289 if (ffsHeader.fileType == EFI_FV_FILETYPE_FFS_PAD) {
290
291 throw new BuildException (
292 "FFS_ATTRIB_TAIL_PRESENT=TRUE is " +
293 "invalid for PAD files"
294 );
295 }
296 if (fileSize == ffsHeader.getSize()) {
297 throw new BuildException (
298 "FFS_ATTRIB_TAIL_PRESENT=TRUE is " +
299 "invalid for 0-length files"
300 );
301 }
302 fileSize = fileSize + 2;
303 orgFileSize = orgFileSize + 2;
304 }
305
306 //
307 // 2. set file size to header struct
308 //
309 ffsHeader.ffsFileSize[0] = (byte)(fileSize & 0x00FF);
310 ffsHeader.ffsFileSize[1] = (byte)((fileSize & 0x00FF00)>>8);
311 ffsHeader.ffsFileSize[2] = (byte)(((int)fileSize & 0xFF0000)>>16);
312
313 //
314 // set file size to org header struct
315 //
316 orgFfsHeader.ffsFileSize[0] = (byte)(orgFileSize & 0x00FF);
317 orgFfsHeader.ffsFileSize[1] = (byte)((orgFileSize & 0x00FF00)>>8);
318 orgFfsHeader.ffsFileSize[2] = (byte)(((int)orgFileSize & 0xFF0000)>>16);
319
320 //
321 // Fill in checksums and state, these must be zero for checksumming
322 //
323 ffsHeader.integrityCheck.header = calculateChecksum8 (
324 ffsHeader.structToBuffer(),
325 ffsHeader.getSize()
326 );
327 //
328 // Fill in org file's header check sum and state
329 //
330 orgFfsHeader.integrityCheck.header = calculateChecksum8 (
331 orgFfsHeader.structToBuffer(),
332 orgFfsHeader.getSize()
333 );
334
335 if ((this.attributes & FFS_ATTRIB_CHECKSUM) != 0) {
336 if ((this.attributes & FFS_ATTRIB_TAIL_PRESENT) != 0) {
337 ffsHeader.integrityCheck.file = calculateChecksum8 (
338 fileBuffer,
339 fileDataSize
340 );
341 //
342 // Add org file header
343 //
344 orgFfsHeader.integrityCheck.file = calculateChecksum8 (
345 orgFileBuffer,
346 orgFileDataSize
347 );
348 } else {
349 ffsHeader.integrityCheck.file = calculateChecksum8 (
350 fileBuffer,
351 fileDataSize
352 );
353 //
354 // Add org file header
355 //
356 orgFfsHeader.integrityCheck.file = calculateChecksum8 (
357 orgFileBuffer,
358 orgFileDataSize
359 );
360 }
361 } else {
362 ffsHeader.integrityCheck.file = FFS_FIXED_CHECKSUM;
363 orgFfsHeader.integrityCheck.file = FFS_FIXED_CHECKSUM;
364 }
365
366 //
367 // Set the state now. Spec says the checksum assumes the state is 0.
368 //
369 ffsHeader.ffsState = EFI_FILE_HEADER_CONSTRUCTION |
370 EFI_FILE_HEADER_VALID |
371 EFI_FILE_DATA_VALID;
372 orgFfsHeader.ffsState = ffsHeader.ffsState;
373
374 //
375 // create output stream to first write header data in file, then write sect data in file.
376 //
377 FileOutputStream headerFfs = new FileOutputStream (ffsFile.getAbsolutePath());
378 DataOutputStream ffsBuffer = new DataOutputStream (headerFfs);
379
380 FileOutputStream orgHeaderFfs = new FileOutputStream (ffsOrgFile.getAbsolutePath());
381 DataOutputStream orgFfsBuffer = new DataOutputStream (orgHeaderFfs);
382
383 //
384 // Add header struct and file data to FFS file
385 //
386 ffsBuffer.write(ffsHeader.structToBuffer());
387 orgFfsBuffer.write(orgFfsHeader.structToBuffer());
388
389 for (int i = 0; i< fileDataSize; i++) {
390 ffsBuffer.write(fileBuffer[i]);
391 }
392
393 for (int i = 0; i < orgFileDataSize; i++){
394 orgFfsBuffer.write(orgFileBuffer[i]);
395 }
396
397 //
398 // If there is a tail, then set it
399 //
400 if ((this.attributes & FFS_ATTRIB_TAIL_PRESENT) != 0) {
401 short tailValue ;
402 byte [] tailByte = new byte[2];
403
404 //
405 // reverse tailvalue , integritycheck.file as hight byte, and
406 // integritycheck.header as low byte.
407 //
408 tailValue = (short)(ffsHeader.integrityCheck.header & 0xff);
409 tailValue = (short)((tailValue) | ((ffsHeader.integrityCheck.file << 8) & 0xff00));
410 tailValue = (short)~tailValue;
411
412 //
413 // Change short to byte[2]
414 //
415 tailByte[0] = (byte)(tailValue & 0xff);
416 tailByte[1] = (byte)((tailValue & 0xff00)>>8);
417 ffsBuffer.write(tailByte[0]);
418 ffsBuffer.write(tailByte[1]);
419
420 orgFfsBuffer.write(tailByte[0]);
421 orgFfsBuffer.write(tailByte[1]);
422 }
423
424 //
425 // close output stream. Note if don't close output stream
426 // the buffer can't be rewritten to file.
427 //
428 ffsBuffer.close();
429 orgFfsBuffer.close();
430 } catch (Exception e) {
431 log("genffsfile failed!");
432 throw new BuildException (e.getMessage());
433 }
434 }
435
436 /**
437 addCompress
438
439 This function is to add compress section to section list.
440 @param compress Section of compress
441 **/
442 public void addCompress(CompressSection compress) {
443 this.sectionList.add(compress);
444 }
445
446 /**
447 addTool
448
449 This function is to add tool section to section list.
450 @param tool Section of tool
451 **/
452 public void addTool(Tool tool) {
453 this.sectionList.add(tool);
454 }
455
456 /**
457 addSectionFile
458
459 This function is to add sectFile section to section list.
460 @param sectFile Section of sectFile.
461 **/
462 public void addSectFile (SectFile sectFile) {
463 this.sectionList.add(sectFile);
464 }
465
466 /**
467 getBaseName
468
469 This function is to get basename
470
471 @return String of base name
472 **/
473 public String getBaseName() {
474 return this.baseName;
475 }
476
477 /**
478 setBaseName
479
480 This function is to set base name.
481 @param baseName
482 **/
483 public void setBaseName(String baseName) {
484 this.baseName = baseName.trim();
485 }
486
487 /**
488 getFfsAligment
489
490 This function is to get the ffsAligment
491 @return The value of ffsAligment.
492 **/
493 public int getFfsAttribDataAlignment() {
494 return this.ffsAttribDataAlignment;
495 }
496
497 /**
498 setFfsAligment
499
500 This function is to set ffsAligment
501 @param ffsAligment The value of ffsAligment.
502 **/
503 public void setFfsAttribDataAlignment(int ffsAligment) {
504 this.ffsAttribDataAlignment = ffsAligment;
505 if (this.ffsAttribDataAlignment > 7) {
506 throw new BuildException ("FFS_ALIGMENT Scope is 0-7");
507 } else {
508 attributes |= (((byte)this.ffsAttribDataAlignment) << 3);
509 }
510 }
511
512 /**
513 getFfsAttribCheckSum
514
515 This function is to get ffsAttribCheckSum
516
517 @return Value of ffsAttribChecksum
518 **/
519 public boolean getFfsAttribChecksum() {
520 return this.FfsAttribChecksum;
521 }
522
523 /**
524 setFfsAttribChecksum
525
526 This function is to set ffsAttribChecksum
527 @param ffsAttributeCheckSum Value of ffsAttribCheckSum
528 **/
529 public void setFfsAttribChecksum(boolean ffsAttributeCheckSum) {
530 this.FfsAttribChecksum = ffsAttributeCheckSum;
531 if (ffsAttributeCheckSum) {
532 attributes |= FFS_ATTRIB_CHECKSUM;
533 }
534 }
535
536 /**
537 getFfsAttribRecovery
538
539 This function is to get ffsAttribRecovery
540 @return Value of ffsAttribRecovery
541 **/
542 public boolean getFfsAttribRecovery() {
543 return this.ffsAttribRecovery;
544 }
545
546 /**
547 setRecovery
548
549 This function is to set ffsAttributeRecovery
550
551 @param ffsAttributeRecovery Value of ffsAttributeRecovery
552 **/
553 public void setRecovery(boolean ffsAttributeRecovery) {
554 this.ffsAttribRecovery = ffsAttributeRecovery;
555 if (ffsAttributeRecovery) {
556 attributes |= FFS_ATTRIB_RECOVERY;
557 }
558 }
559
560 /**
561 getFileGuid
562
563 This function is to get fileGuid
564 @return Guid
565 **/
566 public String getFileGuid() {
567 return this.ffsFileGuid;
568 }
569
570 /**
571 setFileGuid
572
573 This function is to set fileGuid
574 @param ffsFileGuid String of GUID
575 **/
576 public void setFileGuid(String ffsFileGuid) {
577 this.ffsFileGuid = ffsFileGuid.trim();
578 }
579
580 /**
581 getFfsFileType
582
583 This function is to get ffsFileType.
584
585 @return value of ffsFileType
586 **/
587 public String getFfsFileType() {
588 return this.ffsFileType;
589 }
590
591 /**
592 setFfsFileType
593
594 This function is to set ffsFileType.
595
596 @param ffsFileType
597 **/
598 public void setFfsFileType(String ffsFileType) {
599 this.ffsFileType = ffsFileType.trim();
600 }
601
602 /**
603 ffsAttribHeaderExtension
604
605 This function is to get ffsAttribHeaderExtension
606
607 @return Value of ffsAttribHeaderExtension
608 **/
609 public boolean isFfsAttribHeaderExtension() {
610 return this.ffsAttribHeaderExtension;
611 }
612
613 /**
614 setHeaderExension
615
616 This function is to set headerExtension
617 @param headerExtension Value of headerExension
618 **/
619 public void setHeaderExtension(boolean headerExtension) {
620 this.ffsAttribHeaderExtension = headerExtension;
621 if (headerExtension) {
622 attributes |= FFS_ATTRIB_HEADER_EXTENSION;
623 }
624 }
625
626 /**
627 isFfsAttribTailPresent
628
629 This function is to get ffsAttribTailPresent value.
630 @return Value of ffsAttribTailPresent.
631 **/
632 public boolean isFfsAttribTailPresent() {
633 return this.ffsAttribTailPresent;
634 }
635
636 /**
637 setFfsAttribTailPresent
638
639 This function is to set ffsAttribTailPresent.
640 @param tailPresent Value of ffsAttribTailPresent.
641 **/
642 public void setFfsAttribTailPresent(boolean tailPresent) {
643 this.ffsAttribTailPresent = tailPresent;
644 if (tailPresent) {
645 attributes |= FFS_ATTRIB_TAIL_PRESENT;
646 }
647 }
648
649
650 /**
651 stringToGuid
652
653 This function is to convert string to GUID.
654 * @param GuidStr String of GUID.
655 * @param Guid GUID form.
656 */
657 private void stringToGuid (String GuidStr, FfsHeader.FfsGuid Guid){
658
659 int i = 0;
660 int j = 0;
661 int k = 0;
662 char [] charArry;
663 String [] SplitStr;
664
665 byte[] buffer = new byte[16];
666 if (GuidStr.length()!=36) {
667 throw new BuildException ("Guid length is not correct!");
668 }
669
670
671 SplitStr = GuidStr.split("-");
672 if (SplitStr.length != 5) {
673 throw new BuildException ("Guid type is not correct!");
674 }
675
676
677
678 for (i= 0; i < SplitStr.length; i++) {
679 String str = SplitStr[i];
680 charArry = str.toCharArray();
681
682 for (j =0; j < (str.toCharArray().length)/2; j++) {
683
684 buffer[k] = hexCharToByte (charArry[j*2]);
685 buffer[k] = (byte)( buffer[k]& 0x0f);
686 buffer[k] = (byte)((buffer[k]<< 4));
687 buffer[k] = (byte)( buffer[k]& 0xf0);
688 buffer[k] = (byte)( buffer[k]|hexCharToByte(charArry[j*2+1]));
689 k++;
690 }
691 }
692 Guid.bufferToStruct(buffer);
693 }
694
695 /**
696 typeToSuffix
697
698 This function is to get suffix of ffs file according to ffsFileType.
699
700 @param ffsFileType ffsFileType
701 @return The suffix of ffs file
702 **/
703 private String TypeToSuffix (String ffsFileType){
704 String[][] suffix = { { "BASE", ".FFS"},
705 { "SEC", ".SEC" }, { "PEI_CORE", ".PEI" },
706 { "PEIM", ".PEI" }, { "DXE_CORE", ".DXE" },
707 { "DXE_DRIVER", ".DXE" }, { "DXE_RUNTIME_DRIVER", ".DXE" },
708 { "DXE_SAL_DRIVER", ".DXE" }, { "DXE_SMM_DRIVER", ".DXE" },
709 { "TOOL", ".FFS" }, { "UEFI_DRIVER", ".DXE" },
710 { "UEFI_APPLICATION", ".APP" }, { "USER_DEFINED", ".FFS" } };
711
712 for (int i = 0; i < suffix.length; i++) {
713 if (suffix[i][0].equalsIgnoreCase(moduleType)) {
714 return suffix[i][1];
715 }
716 }
717
718 return ".FFS";
719 }
720
721
722 /**
723 stringToType
724
725 This function is to get ffsFileType integer value according to ffsFileType.
726 @param ffsFileType String value of ffsFileType
727 @return Integer value of ffsFileType.
728 **/
729 private byte stringToType (String ffsFileType){
730
731 if (ffsFileType.equals("EFI_FV_FILETYPE_ALL")) {
732 return(byte)EFI_FV_FILETYPE_ALL;
733 }
734
735 if (ffsFileType.equals("EFI_FV_FILETYPE_RAW")) {
736 return(byte)EFI_FV_FILETYPE_RAW;
737 }
738
739 if (ffsFileType.equals("EFI_FV_FILETYPE_FREEFORM")) {
740 return(byte)EFI_FV_FILETYPE_FREEFORM;
741 }
742
743 if (ffsFileType.equals("EFI_FV_FILETYPE_SECURITY_CORE")) {
744 return(byte)EFI_FV_FILETYPE_SECURITY_CORE;
745 }
746
747 if (ffsFileType.equals("EFI_FV_FILETYPE_PEI_CORE")) {
748 return(byte) EFI_FV_FILETYPE_PEI_CORE;
749 }
750
751 if (ffsFileType.equals("EFI_FV_FILETYPE_DXE_CORE")) {
752 return(byte)EFI_FV_FILETYPE_DXE_CORE;
753 }
754
755 if (ffsFileType.equals("EFI_FV_FILETYPE_PEIM")) {
756 return(byte)EFI_FV_FILETYPE_PEIM;
757 }
758
759 if (ffsFileType.equals("EFI_FV_FILETYPE_DRIVER")) {
760 return(byte) EFI_FV_FILETYPE_DRIVER;
761 }
762
763 if (ffsFileType.equals("EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER")) {
764 return(byte)EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER;
765 }
766
767 if (ffsFileType.equals("EFI_FV_FILETYPE_APPLICATION")) {
768 return(byte)EFI_FV_FILETYPE_APPLICATION;
769 }
770
771 if (ffsFileType.equals("EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE")) {
772 return(byte)EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE;
773 }
774 if (ffsFileType.equals("EFI_FV_FILETYPE_FFS_PAD")) {
775 return(byte) EFI_FV_FILETYPE_FFS_PAD;
776 }
777
778 return -1;
779 }
780
781
782
783 /**
784 calculateCheckSum8
785
786 This function is to calculate the value needed for a valid UINT8 checksum
787 @param buffer Byte buffer containing byte data of component.
788 @param size Size of the buffer.
789 @return The 8 bit checksum value needed.
790 **/
791 private byte calculateChecksum8 (byte[] buffer, int size){
792 return(byte) (0x100 - calculateSum8 (buffer, size));
793 }
794
795
796 /**
797 calculateSum8
798
799 This function is to calculate the UINT8 sum for the requested region.
800 @param buffer Byte buffer containing byte data of component
801 @param size Size of the buffer.
802 @return The 8 bit checksum value needed.
803 **/
804 private short calculateSum8 (byte[] buffer, int size){
805 int Index;
806 byte Sum;
807 Sum = 0;
808
809 //
810 // Perform the word sum for buffer
811 //
812 for (Index = 0; Index < size; Index++) {
813 Sum = (byte) (Sum + buffer[Index]);
814 }
815
816 return(byte) Sum;
817 }
818
819 /**
820 hexCharToByte
821
822 This function is to convert hex character to byte
823
824 @param hexChar hex character
825 @return Byte which corresponding to the character.
826 **/
827 private byte hexCharToByte (char hexChar){
828 switch (hexChar) {
829 case '0':
830 return(byte)0x00;
831 case '1':
832 return(byte)0x01;
833 case '2':
834 return(byte)0x02;
835 case '3':
836 return(byte)0x03;
837 case '4':
838 return(byte)0x04;
839 case '5':
840 return(byte)0x05;
841 case '6':
842 return(byte)0x06;
843 case '7':
844 return(byte)0x07;
845 case '8':
846 return(byte)0x08;
847 case '9':
848 return(byte)0x09;
849 case 'a':
850 case 'A':
851 return(byte)0x0a;
852 case 'b':
853 case 'B':
854 return(byte)0x0b;
855 case 'c':
856 case 'C':
857 return(byte)0x0c;
858
859 case 'd':
860 case 'D':
861 return(byte)0x0d;
862
863 case 'e':
864 case 'E':
865 return(byte)0x0e;
866 case 'f':
867 case 'F':
868 return(byte)0x0f;
869
870 default:
871 return(byte)0xff;
872 }
873 }
874
875 /**
876 adjustFileSize
877
878 This function is used to adjusts file size to insure sectioned file is exactly the right length such
879 that it ends on exactly the last byte of the last section. ProcessScript()
880 may have padded beyond the end of the last section out to a 4 byte boundary.
881 This padding is stripped.
882
883 @param buffer Byte buffer contains a section stream
884 @return Corrected size of file.
885 **/
886 private int adjustFileSize (byte[] buffer){
887
888 int orignalLen = buffer.length;
889 int adjustLen = 0;
890 int sectionPoint = 0;
891 int nextSectionPoint = 0;
892 int sectionLen = 0;
893 int totalLen = 0;
894 int firstSectionHeader = 0;
895
896
897 firstSectionHeader = buffer[0]& 0xff;
898 firstSectionHeader = ((buffer[1]&0xff)<<8) | firstSectionHeader;
899 firstSectionHeader = ((buffer[2]&0xff)<<16)| firstSectionHeader;
900
901
902 while (sectionPoint < buffer.length) {
903 sectionLen = buffer[0 + sectionPoint]& 0xff;
904 sectionLen = ((buffer[1 + sectionPoint]&0xff)<<8)| sectionLen;
905 sectionLen = ((buffer[2 + sectionPoint]&0xff)<<16)| sectionLen;
906 totalLen = totalLen + sectionLen;
907
908 if (totalLen == orignalLen) {
909 return totalLen;
910 }
911
912 sectionPoint = sectionPoint + sectionLen;
913 adjustLen = sectionPoint;
914
915 nextSectionPoint = (sectionPoint + 0x03) & (~0x03);
916 totalLen = totalLen + nextSectionPoint - sectionLen;
917 sectionPoint = nextSectionPoint;
918 }
919 return adjustLen;
920 }
921
922 /**
923 getOutputDir
924
925 This function is to get output directory.
926
927 @return Path of output directory.
928 **/
929 public String getOutputDir() {
930 return outputDir;
931 }
932
933 /**
934 setOutputDir
935
936 This function is to set output directory.
937
938 @param outputDir The output direcotry.
939 **/
940 public void setOutputDir(String outputDir) {
941 this.outputDir = outputDir;
942 }
943
944 public String getModuleType() {
945 return this.moduleType;
946 }
947
948 public void setModuleType(String moduleType) {
949 this.moduleType = moduleType;
950 }
951 }