CHDK_DE Vorschauversion  Trunk Rev. 5833
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
module_load.c-Dateireferenz
#include "camera_info.h"
#include "conf.h"
#include "console.h"
#include "clock.h"
#include "cache.h"
#include "lang.h"
#include "gui_mbox.h"
#include "gui_lang.h"
#include "time.h"
#include "ctype.h"
#include "simple_module.h"
#include "module_load.h"
#include "module_exportlist.h"
#include "module_hash.h"
+ Include-Abhängigkeitsdiagramm für module_load.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define BUFFER_FOR_READ_SIZE   4096
 
#define MODULES_PATH   "A/CHDK/MODULES/"
 
#define MAX_SIMPLE_MODULE   4
 

Funktionen

static unsigned int hash_module_name (char *str)
 
static unsigned int get_module_path (char *path, const char *name)
 
static int get_buffer (int size)
 
static int b_open (const char *name)
 
int b_read (int fd, char *buf, int len)
 
void b_close (int fd)
 
static int namecmp (const char *s1, const char *s2)
 
static int module_find (unsigned int hash)
 
static void moduleload_error (const char *name, const char *text)
 
static int module_do_relocations (flat_hdr *flat, void *relocbuf, uint32_t reloc_count)
 
static const void * module_find_symbol_address (uint32_t importid)
 
static int module_do_imports (flat_hdr *flat, void *relocbuf, uint32_t import_count)
 
static int module_do_action (int fd, flat_hdr *mod, uint32_t offset, uint32_t segment_size, int(*func)(flat_hdr *, void *, uint32_t))
 
static void module_writeline (char *buf)
 
static void module_log_hdr ()
 
void module_log_clear ()
 
static void module_log_load (const char *name, void *adr)
 
static void module_log_unload (char *name)
 
static int bind_module (module_handler_t *hMod, void *module_lib)
 
static void module_unload_idx (int idx)
 
void module_unload (const char *name)
 
static char * validate (ModuleInfo *mod_info, _version_t ver)
 
static char * load_module_file (int fd, const char *name, int size, int bss_size, flat_hdr **flat_buf)
 
static char * link_module (int fd, flat_hdr *flat_buf)
 
flat_hdrmodule_preload (const char *path, const char *name, _version_t ver)
 
static int _module_load (module_handler_t *hMod)
 
int module_load (module_handler_t *hMod)
 
static int default_run0 ()
 
static int default_run1 ()
 
static int default_run2 ()
 
static int default_run3 ()
 
static void module_run_error (int err, char *name)
 
static int default_run (int n)
 
int module_run (char *name)
 
void module_exit_alt ()
 
void module_tick_unloader ()
 
module_entrymodule_get_adr (unsigned int idx)
 
void get_module_info (const char *name, ModuleInfo *mi, char *modName, int modNameLen)
 

Variablen

sym_hash symbol_hash_table []
 
static module_entry modules [MAX_NUM_LOADED_MODULES]
 
static char * buf_load = 0
 
static int buf_size = 0
 
static libsimple_sym default_librun [MAX_SIMPLE_MODULE]
 
static libsimple_symlibrun [MAX_SIMPLE_MODULE] = { &default_librun[0], &default_librun[1], &default_librun[2], &default_librun[3] }
 
static char h_name [MAX_SIMPLE_MODULE][64]
 
static module_handler_t h_run [MAX_SIMPLE_MODULE]
 

Makro-Dokumentation

#define BUFFER_FOR_READ_SIZE   4096

Definiert in Zeile 38 der Datei module_load.c.

#define MAX_SIMPLE_MODULE   4

Definiert in Zeile 684 der Datei module_load.c.

#define MODULES_PATH   "A/CHDK/MODULES/"

Definiert in Zeile 39 der Datei module_load.c.

Dokumentation der Funktionen

static int _module_load ( module_handler_t hMod)
static

Definiert in Zeile 586 der Datei module_load.c.

587 {
588  int idx;
589 
590  // Get full path to module file, and hash of path
591  char path[60];
592  unsigned int hash = get_module_path(path, hMod->name);
593 
594  // Check if module already loaded
595  idx = module_find(hash);
596  if (idx >= 0)
597  return idx;
598 
599  // Reset lib (should not be needed, loader should only be called from 'default' lib)
600  *hMod->lib = hMod->default_lib;
601 
602  // Simple lock to prevent multiple attempts to load modules simultaneously (in different tasks)
603  // Not perfect; but should be sufficient
604  static int isLoading = 0;
605  while (isLoading != 0) msleep(10);
606  isLoading = 1;
607 
608  // Find empty slot
609  for (idx=0; idx<MAX_NUM_LOADED_MODULES && modules[idx].hdr; idx++) ;
610 
611  // If no slot found return error
612  if (idx == MAX_NUM_LOADED_MODULES)
613  {
614  moduleload_error(hMod->name, "too many modules loaded");
615  idx = -1;
616  }
617  else
618  {
619  // Load and relocate module (returns 0 if error)
620  flat_hdr* mod = module_preload(path, hMod->name, hMod->version);
621 
622  if (mod != 0)
623  {
624  // Module is valid. Finalize binding
625  modules[idx].hdr = mod;
626  modules[idx].hName = hash;
627  modules[idx].hMod = hMod;
628 
629  int bind_err = bind_module(hMod, mod->_module_info->lib);
630 
631  // Call module loader if required
632  if (!bind_err && mod->_module_info->lib->loader)
633  {
634  bind_err = mod->_module_info->lib->loader();
635  }
636 
637  // If any errors, unload module and display error message
638  if (bind_err)
639  {
640  module_unload_idx(idx);
641  moduleload_error(hMod->name, "loader error");
642  idx = -1;
643  }
644  }
645  else
646  {
647  // module did not load, return invalid index
648  idx = -1;
649  }
650  }
651 
652  // Release lock
653  isLoading = 0;
654 
655  return idx;
656 }
void b_close ( int  fd)

Definiert in Zeile 138 der Datei module_load.c.

139 {
140  if (fd >= 0)
141  close(fd);
142 }
static int b_open ( const char *  name)
static

Definiert in Zeile 106 der Datei module_load.c.

107 {
109  {
110  return -1;
111  }
112 
113  return open(name, O_RDONLY, 0777);
114 }
int b_read ( int  fd,
char *  buf,
int  len 
)

Definiert in Zeile 119 der Datei module_load.c.

120 {
121  int loaded = 0, now = 1;
122 
123  while (now && loaded<len)
124  {
125  now = len - loaded;
126  if (now > buf_size)
127  now = buf_size;
128 
129  now = read(fd, buf_load, now);
130  memcpy(buf+loaded, buf_load, now);
131  loaded += now;
132  }
133 
134  return loaded;
135 }
static int bind_module ( module_handler_t hMod,
void *  module_lib 
)
static

Definiert in Zeile 376 der Datei module_load.c.

377 {
378  // If unloading module, reset library to unloaded default
379  if (module_lib == 0)
380  *hMod->lib = hMod->default_lib;
381  else
382  *hMod->lib = module_lib;
383 
384  return 0;
385 }
static int default_run ( int  n)
static

Definiert in Zeile 726 der Datei module_load.c.

727 {
728  if (module_load(&h_run[n]))
729  {
730  if ((*h_run[n].lib)->run)
731  {
732  return (*h_run[n].lib)->run();
733  }
734  else
735  {
736  // Error - module does not support 'simple' mode
738  // Assumption - module will unload automatically via module_tick_unloader()
739  }
740  }
741 
742  return -1;
743 }
static int default_run0 ( )
static

Definiert in Zeile 746 der Datei module_load.c.

746 { return default_run(0); }
static int default_run1 ( )
static

Definiert in Zeile 747 der Datei module_load.c.

747 { return default_run(1); }
static int default_run2 ( )
static

Definiert in Zeile 748 der Datei module_load.c.

748 { return default_run(2); }
static int default_run3 ( )
static

Definiert in Zeile 749 der Datei module_load.c.

749 { return default_run(3); }
static int get_buffer ( int  size)
static

Definiert in Zeile 85 der Datei module_load.c.

86 {
87  size = (size + 3) & 0xFFFFFFFC; // round up to 4 byte boundary
88  if (size > buf_size)
89  {
90  if (buf_load)
91  {
92  ufree(buf_load);
93  buf_load = 0;
94  buf_size = 0;
95  }
96  buf_load = umalloc(size);
97  if (buf_load)
98  buf_size = size;
99  }
100 
101  return buf_size;
102 }
void get_module_info ( const char *  name,
ModuleInfo mi,
char *  modName,
int  modNameLen 
)

Definiert in Zeile 838 der Datei module_load.c.

839 {
840  memset(mi, 0, sizeof(ModuleInfo));
841  if (modName)
842  modName[0] = 0; // Only used if module name stored in file (not a LANG string)
843 
844  // Get full path to module file, and hash of path
845  char path[60];
846  get_module_path(path, name);
847 
848  // open file
849  int fd = open(path, O_RDONLY, 0777);
850  if (fd < 0)
851  return;
852 
853  // Read module header only to get size info
854  flat_hdr flat;
855  read(fd, (char*)&flat, sizeof(flat_hdr));
856 
857  // Check version and magic number - make sure it is a CHDK module file
858  if ((flat.rev == FLAT_VERSION) && (flat.magic == FLAT_MAGIC_NUMBER))
859  {
861  read(fd, mi, sizeof(ModuleInfo));
862 
863  if ((mi->moduleName >= 0) && modName)
864  {
865  // Load module name string
866  lseek(fd, mi->moduleName, SEEK_SET);
867  read(fd, modName, modNameLen-1);
868  modName[modNameLen-1] = 0;
869  }
870  }
871 
872  close(fd);
873 }
static unsigned int get_module_path ( char *  path,
const char *  name 
)
static

Definiert in Zeile 60 der Datei module_load.c.

61 {
62  // Check if full path supplied?
63  if ((tolower(name[0]) != 'a') || (name[1] != '/'))
64  strcpy(path, MODULES_PATH);
65  else
66  path[0] = 0;
67  // Add supplied name to path
68  strcat(path, name);
69 
70  return hash_module_name(path);
71 }
static unsigned int hash_module_name ( char *  str)
static

Definiert in Zeile 44 der Datei module_load.c.

45 {
46  unsigned int hash = 5381;
47  int c;
48 
49  // djb2 hash algorithm (Dan Bernstein - http://cr.yp.to/djb.html)
50  while ((c = *str++) != 0)
51  hash = ((hash << 5) + hash) ^ toupper(c); /* hash * 33 xor c */
52 
53  return hash;
54 }
static char* link_module ( int  fd,
flat_hdr flat_buf 
)
static

Definiert in Zeile 494 der Datei module_load.c.

495 {
496  // Make relocations
497  int reloc_size = flat_buf->import_start - flat_buf->reloc_start;
498  int import_size = flat_buf->import_size;
499 
500  // Get larger buffer size if needed
501  int sz = (reloc_size > import_size) ? reloc_size : import_size;
502 
503  if (!get_buffer(sz)) // Re-allocate if needed
504  return "malloc";
505 
506  if (!module_do_action(fd, flat_buf, flat_buf->reloc_start, reloc_size, module_do_relocations))
507  return "reloc error";
508 
509  if (!module_do_action(fd, flat_buf, flat_buf->import_start, import_size, module_do_imports))
510  return "link error";
511 
512  return 0;
513 }
static char* load_module_file ( int  fd,
const char *  name,
int  size,
int  bss_size,
flat_hdr **  flat_buf 
)
static

Definiert in Zeile 468 der Datei module_load.c.

469 {
470  *flat_buf = (flat_hdr*)malloc(size+bss_size);
471  if (!*flat_buf)
472  return "malloc";
473 
474  module_log_load(name, *flat_buf);
475 
476  if (lseek(fd, 0, SEEK_SET) == 0)
477  {
478  if (b_read(fd, (char*)*flat_buf, size) == size)
479  {
480  memset((unsigned char*)(*flat_buf)+size, 0, bss_size);
481  return 0;
482  }
483  }
484 
485  // Load failed, free memory
486  free(*flat_buf);
487  *flat_buf = 0;
488 
489  return "read";
490 }
static int module_do_action ( int  fd,
flat_hdr mod,
uint32_t  offset,
uint32_t  segment_size,
int(*)(flat_hdr *, void *, uint32_t func 
)
static

Definiert in Zeile 277 der Datei module_load.c.

278 {
279  if (segment_size > 0)
280  {
281  if (lseek(fd, offset, SEEK_SET) == (int)offset)
282  {
283  if (read(fd, buf_load, segment_size) == (int)segment_size)
284  {
285  // relocate or link module
286  return func(mod, (uint32_t*)buf_load, segment_size >> 2);
287  }
288  }
289  return 0;
290  }
291  return 1;
292 }
static int module_do_imports ( flat_hdr flat,
void *  relocbuf,
uint32_t  import_count 
)
static

Definiert in Zeile 248 der Datei module_load.c.

249 {
250  uint32_t i;
251  unsigned char* buf = (unsigned char*)flat; // base address of module in memory
252  uint32_t* rbuf = (uint32_t*)relocbuf; // link array
253 
254  for (i=0; i < import_count;)
255  {
256  // Find CHDK address of symbol via hash value, if not found return error
257  int importaddress = (int)module_find_symbol_address(rbuf[i++]);
258  if (importaddress == 0) return 0;
259 
260  // Get number of locations in module to link
261  int cnt = rbuf[i] >> 24;
262 
263  for (; cnt>0; cnt--)
264  {
265  // Get offset into module (exclude count value)
266  uint32_t offs = rbuf[i++] & 0x00FFFFFF;
267  // Add initial value at location to symbol address
268  *(uint32_t*)(buf+offs) += importaddress;
269  }
270  }
271  return 1;
272 }
static int module_do_relocations ( flat_hdr flat,
void *  relocbuf,
uint32_t  reloc_count 
)
static

Definiert in Zeile 205 der Datei module_load.c.

206 {
207  uint32_t i;
208  unsigned char* buf = (unsigned char*)flat; // base address of module in memory
209  uint32_t* rbuf = (uint32_t*)relocbuf; // relocation array
210 
211  for (i=0; i < reloc_count; i++)
212  {
213  // Add initial value at relocated address to the base module address
214  *(uint32_t*)(buf+rbuf[i]) += (uint32_t)buf;
215  }
216 
217  return 1;
218 }
void module_exit_alt ( )

Definiert in Zeile 792 der Datei module_load.c.

793 {
794  int idx;
795 
796  for (idx=MAX_NUM_LOADED_MODULES-1; idx>=0; idx--)
797  {
798  if (modules[idx].hdr && modules[idx].hdr->_module_info->lib->exit_alt)
799  {
800  // Tell module we are leaving <ALT>
801  modules[idx].hdr->_module_info->lib->exit_alt();
802  }
803  }
804 }
static int module_find ( unsigned int  hash)
static

Definiert in Zeile 167 der Datei module_load.c.

168 {
169  int i;
170 
171  for (i=0; i<MAX_NUM_LOADED_MODULES; i++)
172  {
173  if (modules[i].hdr && (modules[i].hName == hash))
174  {
175  return i;
176  }
177  }
178  return -1;
179 }
static const void* module_find_symbol_address ( uint32_t  importid)
static

Definiert in Zeile 223 der Datei module_load.c.

224 {
225  int min = 0, max = EXPORTLIST_COUNT-1;
226  do
227  {
228  int mid = (min + max) >> 1;
229  if (importid == symbol_hash_table[mid].hash)
230  return symbol_hash_table[mid].address;
231  else if (importid > symbol_hash_table[mid].hash)
232  min = mid + 1;
233  else
234  max = mid - 1;
235  } while (min <= max);
236  return 0;
237 }
module_entry* module_get_adr ( unsigned int  idx)

Definiert in Zeile 828 der Datei module_load.c.

829 {
830  if (idx < MAX_NUM_LOADED_MODULES)
831  if (modules[idx].hdr)
832  return &modules[idx];
833  return 0;
834 }
int module_load ( module_handler_t hMod)

Definiert in Zeile 660 der Datei module_load.c.

661 {
662  // Attempt to load module
663  _module_load(hMod);
664 
665  // If load succeeded return success
666  if (*hMod->lib && (*hMod->lib != hMod->default_lib))
667  {
668  return 1;
669  }
670 
671  // If load failed reset library to unloaded default (should not be needed!)
672  if (*hMod->lib == 0)
673  *hMod->lib = hMod->default_lib;
674 
675  // Failure
676  return 0;
677 }
void module_log_clear ( )

Definiert in Zeile 343 der Datei module_load.c.

344 {
345  remove("A/MODULES.LOG");
346 }
static void module_log_hdr ( )
static

Definiert in Zeile 318 der Datei module_load.c.

319 {
320  static int hdr_logged = 0;
321 
322  if (conf.module_logging)
323  {
324  if (hdr_logged == 0)
325  {
326  hdr_logged = 1;
327 
328  time_t datetime;
329  struct tm *ttm;
330  char buf[100];
331 
332  datetime = time(NULL);
333  ttm = localtime(&datetime);
334 
335  sprintf(buf, "Tick ,Op,Address ,Name (%04d:%02d:%02d %02d:%02d:%02d)\n", ttm->tm_year+1900, ttm->tm_mon+1, ttm->tm_mday, ttm->tm_hour, ttm->tm_min, ttm->tm_sec);
336 
337  module_writeline(buf);
338  }
339  }
340 }
static void module_log_load ( const char *  name,
void *  adr 
)
static

Definiert in Zeile 349 der Datei module_load.c.

350 {
351  if (conf.module_logging)
352  {
353  char buf[100];
354  sprintf(buf,"%8d,LD,%08x,%s\n",get_tick_count(),adr,name);
355 
356  module_log_hdr();
357  module_writeline(buf);
358  }
359 }
static void module_log_unload ( char *  name)
static

Definiert in Zeile 362 der Datei module_load.c.

363 {
364  if (conf.module_logging)
365  {
366  char buf[100];
367  sprintf(buf,"%8d,UN, ,%s\n",get_tick_count(),name);
368 
369  module_log_hdr();
370  module_writeline(buf);
371  }
372 }
flat_hdr* module_preload ( const char *  path,
const char *  name,
_version_t  ver 
)

Definiert in Zeile 518 der Datei module_load.c.

519 {
520  // Allocate buffer and open file
521  int module_fd = b_open(path);
522  if (module_fd <= 0)
523  {
524  moduleload_error(name, "open error");
525  return 0;
526  }
527 
528  // Read module header only to get size info
529  flat_hdr flat;
530  b_read(module_fd, (char*)&flat, sizeof(flat)); // TODO - compare loaded with requested size
531 
532  // Error message
533  char *msg = 0;
534 
535  // Pointer to memory allocated to load module
536  flat_hdr* flat_buf = 0;
537 
538  // Check version and magic number - make sure it is a CHDK module file
539  if ((flat.rev == FLAT_VERSION) && (flat.magic == FLAT_MAGIC_NUMBER))
540  {
541  // Allocate module memory, and load module code
542  msg = load_module_file(module_fd, name, flat.reloc_start, flat.bss_size, &flat_buf);
543  if (msg == 0)
544  {
545  // Module info checks
546  ModuleInfo *mod_info = flat_buf->_module_info = (ModuleInfo*)((unsigned int)flat_buf+flat_buf->_module_info_offset);
547 
548  // Validate version requirements
549  msg = validate(mod_info, ver);
550  if (msg == 0)
551  {
552  // Make relocations
553  msg = link_module(module_fd, flat_buf);
554  }
555  }
556  }
557  else
558  msg = "bad magicnum";
559 
560  // Close file
561  b_close(module_fd);
562 
563  // If any error found, free module memory and display error
564  if (msg)
565  {
566  if (flat_buf)
567  free(flat_buf);
568  moduleload_error(name, msg);
569  return 0;
570  }
571 
572  // TODO these could be changed to operate on affected address ranges only
573  // after relocating but before attempting to execute loaded code
574  // clean data cache to ensure code is in main memory
576  // then flush instruction cache to ensure no addresses containing new code are cached
578 
579  // Return module memory address
580  return flat_buf;
581 }
int module_run ( char *  name)

Definiert in Zeile 755 der Datei module_load.c.

756 {
757  int i;
758  for (i=0; i<MAX_SIMPLE_MODULE; i++)
759  {
760  // Check if module loaded (otherwise name not valid)
761  if (*h_run[i].lib != h_run[i].default_lib)
762  {
763  if (namecmp(name, h_run[i].name))
764  {
765  // Already loaded
766  return (*h_run[i].lib)->run();
767  }
768  }
769  }
770  for (i=0; i<MAX_SIMPLE_MODULE; i++)
771  {
772  // Look for empty slot
773  if (*h_run[i].lib == h_run[i].default_lib)
774  {
775  // Found space - run module
776  strcpy(h_run[i].name, name);
777  return (*h_run[i].lib)->run();
778  }
779  }
780 
781  // Error - no space
783 
784  return -1;
785 }
static void module_run_error ( int  err,
char *  name 
)
static

Definiert in Zeile 716 der Datei module_load.c.

717 {
718  char buf[100];
719  sprintf(buf, lang_str(err), name);
721 }
void module_tick_unloader ( )

Definiert in Zeile 809 der Datei module_load.c.

810 {
811  int idx;
812 
813  for (idx=MAX_NUM_LOADED_MODULES-1; idx>=0; idx--)
814  {
815  if (modules[idx].hdr && modules[idx].hdr->_module_info->lib->can_unload)
816  {
817  // Ask module if it is safe to unload
818  if (modules[idx].hdr->_module_info->lib->can_unload())
819  module_unload_idx(idx);
820  }
821  }
822 }
void module_unload ( const char *  name)

Definiert in Zeile 410 der Datei module_load.c.

411 {
412  // Get full path to module file, and hash of path
413  char path[60];
414  unsigned int hash = get_module_path(path, name);
415 
416  // Find loaded module, and unload it
418 }
static void module_unload_idx ( int  idx)
static

Definiert in Zeile 389 der Datei module_load.c.

390 {
391  if ((idx >= 0) && (modules[idx].hdr != 0))
392  {
393  // Log unload
394  module_log_unload(modules[idx].hMod->name);
395 
396  // Call module unload function
397  if (modules[idx].hdr->_module_info->lib->unloader)
398  modules[idx].hdr->_module_info->lib->unloader();
399 
400  // Unbind pointers to module (chdk core callback)
401  bind_module(modules[idx].hMod, 0);
402 
403  // Free module memory, and mark module as inactive
404  free(modules[idx].hdr);
405  modules[idx].hdr = 0;
406  }
407 }
static void module_writeline ( char *  buf)
static

Definiert in Zeile 302 der Datei module_load.c.

303 {
304  if (conf.module_logging)
305  {
306  int fd = open("A/MODULES.LOG", O_WRONLY|O_CREAT|O_APPEND, 0777);
307  if (fd >= 0)
308  {
309  lseek(fd, 0, SEEK_END);
310  write(fd, buf, strlen(buf));
311  close(fd);
312  }
313  }
314 }
static void moduleload_error ( const char *  name,
const char *  text 
)
static

Definiert in Zeile 183 der Datei module_load.c.

184 {
185  extern volatile int chdk_started_flag;
186  if (chdk_started_flag)
187  {
188  char buf[100];
189  sprintf(buf, "Fail to load %s: %s", name, text);
190 
191  console_clear();
192  console_add_line(buf);
193  msleep(1000);
194  }
195 }
static int namecmp ( const char *  s1,
const char *  s2 
)
static

Definiert in Zeile 150 der Datei module_load.c.

151 {
152  if ((s1 == 0) && (s2 == 0)) return 1; // Both null --> equal
153  if ((s1 == 0) || (s2 == 0)) return 0; // One null (but not both) --> not equal
154  while (*s1 && *s2)
155  {
156  if (tolower(*s1) != tolower(*s2)) return 0;
157  s1++;
158  s2++;
159  }
160  return ((*s1 == 0) && (*s2 == 0));
161 }
static char* validate ( ModuleInfo mod_info,
_version_t  ver 
)
static

Definiert in Zeile 423 der Datei module_load.c.

424 {
425  static char msg[50];
426 
427  if ((mod_info->magicnum != MODULEINFO_V1_MAGICNUM) || (mod_info->sizeof_struct != sizeof(ModuleInfo)))
428  return "Malformed module info";
429 
430  if (mod_info->chdk_required_branch && (mod_info->chdk_required_branch != CURRENT_CHDK_BRANCH))
431  return "require different CHDK branch";
432 
433  if (mod_info->chdk_required_architecture != OPT_ARCHITECTURE)
434  return "wrong CHDK architecture";
435 
436  if (mod_info->chdk_required_ver > CHDK_BUILD_NUM)
437  {
438  sprintf(msg, "require CHDK%05d", mod_info->chdk_required_ver);
439  return msg;
440  }
441 
442  if (mod_info->chdk_required_platfid && (mod_info->chdk_required_platfid != (uint32_t)conf.platformid))
443  {
444  sprintf(msg, "require platfid %d", mod_info->chdk_required_platfid);
445  return msg;
446  }
447 
448  if (!chk_api_version(mod_info->module_version, ver))
449  return "incorrect module version";
450 
452  return "incorrect CONF version";
453 
455  return "incorrect CAM SCREEN version";
456 
458  return "incorrect CAM SENSOR version";
459 
461  return "incorrect CAM INFO version";
462 
463  return 0;
464 }

Variablen-Dokumentation

char* buf_load = 0
static

Definiert in Zeile 79 der Datei module_load.c.

int buf_size = 0
static

Definiert in Zeile 80 der Datei module_load.c.

libsimple_sym default_librun[MAX_SIMPLE_MODULE]
static
Initialisierung:
=
{
{ { 0, 0, 0, 0, default_run0 } },
{ { 0, 0, 0, 0, default_run1 } },
{ { 0, 0, 0, 0, default_run2 } },
{ { 0, 0, 0, 0, default_run3 } }
}

Definiert in Zeile 693 der Datei module_load.c.

char h_name[MAX_SIMPLE_MODULE][64]
static

Definiert in Zeile 704 der Datei module_load.c.

Initialisierung:

Definiert in Zeile 707 der Datei module_load.c.

Definiert in Zeile 700 der Datei module_load.c.

Definiert in Zeile 34 der Datei module_load.c.

sym_hash symbol_hash_table[]