CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
module_load.c-Dateireferenz
#include "camera_info.h"
#include "stdlib.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 "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 37 der Datei module_load.c.

#define MAX_SIMPLE_MODULE   4

Definiert in Zeile 683 der Datei module_load.c.

#define MODULES_PATH   "A/CHDK/MODULES/"

Definiert in Zeile 38 der Datei module_load.c.

Dokumentation der Funktionen

static int _module_load ( module_handler_t hMod)
static

Definiert in Zeile 585 der Datei module_load.c.

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

Definiert in Zeile 137 der Datei module_load.c.

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

Definiert in Zeile 105 der Datei module_load.c.

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

Definiert in Zeile 118 der Datei module_load.c.

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

Definiert in Zeile 375 der Datei module_load.c.

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

Definiert in Zeile 725 der Datei module_load.c.

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

Definiert in Zeile 745 der Datei module_load.c.

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

Definiert in Zeile 746 der Datei module_load.c.

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

Definiert in Zeile 747 der Datei module_load.c.

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

Definiert in Zeile 748 der Datei module_load.c.

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

Definiert in Zeile 84 der Datei module_load.c.

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

Definiert in Zeile 837 der Datei module_load.c.

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

Definiert in Zeile 59 der Datei module_load.c.

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

Definiert in Zeile 43 der Datei module_load.c.

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

Definiert in Zeile 493 der Datei module_load.c.

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

Definiert in Zeile 467 der Datei module_load.c.

468 {
469  *flat_buf = (flat_hdr*)malloc(size+bss_size);
470  if (!*flat_buf)
471  return "malloc";
472 
473  module_log_load(name, *flat_buf);
474 
475  if (lseek(fd, 0, SEEK_SET) == 0)
476  {
477  if (b_read(fd, (char*)*flat_buf, size) == size)
478  {
479  memset((unsigned char*)(*flat_buf)+size, 0, bss_size);
480  return 0;
481  }
482  }
483 
484  // Load failed, free memory
485  free(*flat_buf);
486  *flat_buf = 0;
487 
488  return "read";
489 }
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 276 der Datei module_load.c.

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

Definiert in Zeile 247 der Datei module_load.c.

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

Definiert in Zeile 204 der Datei module_load.c.

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

Definiert in Zeile 791 der Datei module_load.c.

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

Definiert in Zeile 166 der Datei module_load.c.

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

Definiert in Zeile 222 der Datei module_load.c.

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

Definiert in Zeile 827 der Datei module_load.c.

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

Definiert in Zeile 659 der Datei module_load.c.

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

Definiert in Zeile 342 der Datei module_load.c.

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

Definiert in Zeile 317 der Datei module_load.c.

318 {
319  static int hdr_logged = 0;
320 
321  if (conf.module_logging)
322  {
323  if (hdr_logged == 0)
324  {
325  hdr_logged = 1;
326 
327  time_t datetime;
328  struct tm *ttm;
329  char buf[100];
330 
331  datetime = time(NULL);
332  ttm = localtime(&datetime);
333 
334  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);
335 
336  module_writeline(buf);
337  }
338  }
339 }
static void module_log_load ( const char *  name,
void *  adr 
)
static

Definiert in Zeile 348 der Datei module_load.c.

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

Definiert in Zeile 361 der Datei module_load.c.

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

Definiert in Zeile 517 der Datei module_load.c.

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

Definiert in Zeile 754 der Datei module_load.c.

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

Definiert in Zeile 715 der Datei module_load.c.

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

Definiert in Zeile 808 der Datei module_load.c.

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

Definiert in Zeile 409 der Datei module_load.c.

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

Definiert in Zeile 388 der Datei module_load.c.

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

Definiert in Zeile 301 der Datei module_load.c.

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

Definiert in Zeile 182 der Datei module_load.c.

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

Definiert in Zeile 149 der Datei module_load.c.

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

Definiert in Zeile 422 der Datei module_load.c.

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

Variablen-Dokumentation

char* buf_load = 0
static

Definiert in Zeile 78 der Datei module_load.c.

int buf_size = 0
static

Definiert in Zeile 79 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 692 der Datei module_load.c.

char h_name[MAX_SIMPLE_MODULE][64]
static

Definiert in Zeile 703 der Datei module_load.c.

Initialisierung:

Definiert in Zeile 706 der Datei module_load.c.

Definiert in Zeile 699 der Datei module_load.c.

Definiert in Zeile 33 der Datei module_load.c.

sym_hash symbol_hash_table[]