void print_recursive(char **files, char *flags, char *folder, int i)
{
char **path;
struct stat *file_stat;
int boolean;
if (!files || !files[0] || !ft_strlen(files[0]))
return ;
boolean = 0;
if (!(path = malloc(sizeof(char*) * ALL_RECURSIVE_POSSIBILITY)))
return ;
path = ft_set_null(path);
print_total(files, flags, folder);
while (files[i])
{
if (!(file_stat = get_file_stat(files[i], file_stat, folder)))
return ;
print_by_flags(file_stat, flags, files, i);
if (S_ISDIR(file_stat->st_mode) && files[i][0] != '.' && (boolean += 1))
path = new_dir(path, files[i]);
free(file_stat);
i++;
}
ft_putstr("\n");
free_files(files);
(boolean) ? recursive_if(path, folder, flags) : free_files(path);
}
void ft_ls_dir2(t_flag flag, t_item *list, int multidir, char *tmp)
{
DIR *dir;
t_item *files;
int start;
start = 0;
files = NULL;
while (list)
{
dir = opendir(list->name);
while (ft_get_item(&files, readdir(dir),
ft_strjoin(list->path, "/"), flag) != 0)
;
closedir(dir);
if (files)
{
start == 1 ? ft_putchar('\n') : NULL;
tmp = ft_strjoin(list->name, ":");
multidir ? ft_putendl(tmp) : NULL;
ft_strdel(&tmp);
start = 1;
ft_displayfile(flag, files, 1);
}
free_files(&files);
list = list->next;
}
}
void recursive_if(char **path, char *folder, char *flags)
{
int i;
char *rl;
struct stat *file_stat;
i = 0;
rl = ft_strnew(DEFAULT_BUFFER);
while (path[i])
{
ft_bzero(rl, DEFAULT_BUFFER);
rl = realpath(folder, rl);
rl = ft_strcat(rl, "/");
rl = ft_strcat(rl, path[i]);
rl = ft_strcat(rl, "/");
if (!(file_stat = get_file_stat(path[i], file_stat, folder)))
return ;
ft_putstr(rl);
ft_putstr(":\n");
print_recursive(get_specified_dir(rl, flags), flags, rl, 0);
free(file_stat);
i++;
}
free(rl);
free_files(path);
}
/** If @a loaded_in_frame is set, this was called just to indicate a move inside
* a frameset, and we basically just reset the appropriate frame's view_state in
* that case. When clicking on a link inside a frame, the frame URI is somehow
* updated and added to the files-to-load queue, then ses_forward() is called
* with @a loaded_in_frame unset, duplicating the whole frameset's location,
* then later the file-to-load callback calls it for the particular frame with
* @a loaded_in_frame set. */
struct view_state *
ses_forward(struct session *ses, int loaded_in_frame)
{
struct location *loc = NULL;
struct view_state *vs;
if (!loaded_in_frame) {
free_files(ses);
mem_free_set(&ses->search_word, NULL);
}
x:
if (!loaded_in_frame) {
loc = mem_calloc(1, sizeof(*loc));
if (!loc) return NULL;
copy_struct(&loc->download, &ses->loading);
}
if (ses->task.target.frame && *ses->task.target.frame) {
struct frame *frame;
assertm(have_location(ses), "no location yet");
if_assert_failed return NULL;
if (!loaded_in_frame) {
copy_location(loc, cur_loc(ses));
add_to_history(&ses->history, loc);
}
frame = ses_find_frame(ses, ses->task.target.frame);
if (!frame) {
if (!loaded_in_frame) {
del_from_history(&ses->history, loc);
destroy_location(loc);
}
mem_free_set(&ses->task.target.frame, NULL);
goto x;
}
vs = &frame->vs;
if (!loaded_in_frame) {
destroy_vs(vs, 1);
init_vs(vs, ses->loading_uri, vs->plain);
} else {
done_uri(vs->uri);
vs->uri = get_uri_reference(ses->loading_uri);
if (vs->doc_view) {
/* vs->doc_view itself will get detached in
* render_document_frames(), but that's too
* late for us. */
vs->doc_view->vs = NULL;
vs->doc_view = NULL;
}
#ifdef CONFIG_ECMASCRIPT
vs->ecmascript_fragile = 1;
#endif
}
} else {
static int
list_dir(FILE *out, const char *directory, int flags)
{
DIR *d = opendir(directory);
struct dirent *ent;
char **files = NULL;
int n_files = 0;
int ret;
if(d == NULL) {
syslog(LOG_ERR, "%s: %m", directory);
return -1;
}
while((ent = readdir(d)) != NULL) {
void *tmp;
if(hide_file(ent->d_name, flags))
continue;
tmp = realloc(files, (n_files + 1) * sizeof(*files));
if (tmp == NULL) {
syslog(LOG_ERR, "%s: out of memory", directory);
free_files (files, n_files);
closedir (d);
return -1;
}
files = tmp;
ret = asprintf(&files[n_files], "%s/%s", directory, ent->d_name);
if (ret == -1) {
syslog(LOG_ERR, "%s: out of memory", directory);
free_files (files, n_files);
closedir (d);
return -1;
}
++n_files;
}
closedir(d);
return list_files(out, (const char**)files, n_files, flags | LS_DIR_FLAG);
}
void reload_button_clicked( GtkWidget *widget, gpointer data) {
pthread_mutex_lock(&loading_mutex);
if( !loading ) {
loading = TRUE;
pthread_mutex_unlock(&loading_mutex);
free_folders();
free_files();
read_config(auto_clear_tags);
/* load the folders, and clear the tags database */
load_folders_threaded(TRUE);
} else
pthread_mutex_unlock(&loading_mutex);
}
/*
* Deinit camera
*/
int
spca50x_flash_close (CameraPrivateLibrary *pl, GPContext *context)
{
if (pl->fw_rev == 1) {
CHECK (gp_port_usb_msg_write (pl->gpdev, 0x00, 0x01, 0x2306,
NULL, 0x00));
CHECK (gp_port_usb_msg_write (pl->gpdev, 0x00, 0x00, 0x0d04,
NULL, 0x00));
} else {
/* Anything we need to do? */
}
if (!pl->dirty_flash && pl->bridge == BRIDGE_SPCA500) {
/* check if we need to free the file info buffers */
free_files(pl);
}
pl->dirty_flash = 1;
return GP_OK;
}
int main( int argc, char *argv[] )
{
extern char *optarg;
extern int optind;
int c;
int usage = 0;
int memory_dump = 0;
int dos_newlines = 0;
char *pc;
int cmd_processor = 0;
char *processor_name = NULL;
state.i_memory = i_memory_create();
state.pass = 0;
state.quiet = 0;
#ifdef PARSE_DEBUG
{
extern int yydebug;
yydebug = 1; /* enable parse debug */
}
#endif
#ifdef USE_GPASM_HEADER_PATH
/* add the header path to the include paths list */
#ifndef __MSDOS__
include_paths[n_include_paths++] = GPASM_HEADER_PATH;
#else
include_paths[n_include_paths++] = "c:\\gputils\\header";
#endif
#endif
while ((c = GETOPT_FUNC) != EOF) {
switch (c) {
case '?':
case 'h':
usage = 1;
break;
case 'a':
select_hexformat(optarg);
state.cmd_line.hex_format = 1;
break;
case 'c':
state.case_insensitive = 1;
if (state.stDefines != NULL) {
printf("Warning: The -c option must be called before the -d option.\n");
}
break;
case 'D':
case 'd':
if ((optarg != NULL) && (strlen(optarg) > 0)) {
struct symbol *sym;
char *lhs, *rhs;
/* the Defines symbol table is not yet defined*/
if (state.stDefines == NULL) {
state.stDefines = push_symbol_table(NULL, state.case_insensitive);
}
lhs = strdup(optarg);
rhs = strchr(lhs, '=');
if (rhs != NULL) {
*rhs = '\0'; /* Terminate the left-hand side */
rhs++; /* right-hand side begins after the '=' */
}
sym = get_symbol(state.stDefines, lhs);
if (sym == NULL)
sym = add_symbol(state.stDefines, lhs);
if (rhs)
annotate_symbol(sym, rhs);
}
break;
case 'e':
select_expand(optarg);
state.cmd_line.macro_expand = 1;
break;
case 'I':
if(n_include_paths < MAX_INCLUDE_PATHS) {
include_paths[n_include_paths++] = optarg;
} else {
fprintf(stderr, "too many -I paths\n");
exit(1);
}
break;
case 'l':
dump_processor_list();
exit(0);
break;
case 'm':
memory_dump = 1;
break;
case 'n':
#ifndef __MSDOS__
dos_newlines = 1;
#endif
break;
case 'o':
strcpy(state.hexfilename, optarg);
strcpy(state.basefilename, optarg);
pc = strrchr(state.basefilename, '.');
if (pc)
*pc = 0;
break;
case 'p':
cmd_processor = 1;
processor_name = optarg;
break;
case 'q':
state.quiet = 1;
break;
case 'r':
select_radix(optarg);
state.cmd_line.radix = 1;
break;
case 'w':
select_errorlevel(atoi(optarg));
state.cmd_line.error_level = 1;
break;
case 'v':
fprintf(stderr, "%s\n", GPASM_VERSION_STRING);
exit(0);
}
if (usage)
break;
}
if (optind < argc)
state.srcfilename = argv[optind];
else
usage = 1;
if (usage) {
show_usage();
}
if(state.basefilename[0] == '\0') {
strcpy(state.basefilename, state.srcfilename);
pc = strrchr(state.basefilename, '.');
if (pc)
*pc = 0;
}
/* the Defines symbol table is not yet defined*/
if (state.stDefines == NULL) {
state.stDefines = push_symbol_table(NULL, state.case_insensitive);
}
/* Builtins are always case insensitive */
state.stBuiltin = push_symbol_table(NULL, 1);
state.stDirective = state.stBuiltin;
state.stMacros = push_symbol_table(NULL, state.case_insensitive);
state.stTop =
state.stGlobal = push_symbol_table(NULL, state.case_insensitive);
opcode_init(0);
/* the tables are built, select the processor if -p was used */
if (cmd_processor) {
select_processor(processor_name);
state.cmd_line.processor = 1;
}
state.maxram = (MAX_RAM - 1);
open_src(state.srcfilename, 0);
state.pass = 1;
yyparse();
open_src(state.srcfilename, 0);
state.pass++;
state.org = 0;
state.cblock = 0;
if (state.cmd_line.radix != 1)
state.radix = 16;
cod_init();
lst_init();
yyparse();
assert(state.pass == 2);
pop_symbol_table(state.stBuiltin);
if (check_writehex(state.i_memory, state.hex_format)) {
gperror(GPE_IHEX,NULL);
} else {
int byte_words;
if (state.device.core_size > 0xff) {
byte_words = 0;
} else {
byte_words = 1;
if (state.hex_format != inhx8m) {
gpwarning(GPW_UNKNOWN,"Must use inhx8m format for EEPROM8");
state.hex_format = inhx8m;
}
}
if (writehex(state.basefilename, state.i_memory,
state.hex_format, state.num.errors,
byte_words, dos_newlines)) {
gperror(GPE_UNKNOWN,"Error generating hex file");
}
}
if(memory_dump)
print_i_memory(state.i_memory);
/* Maybe produce a symbol table */
if (state.lst.symboltable) {
lst_throw(); /* Start symbol table on a fresh page */
lst_symbol_table(state.stGlobal);
lst_defines_table(state.stDefines);
}
/* Maybe produce a memory map */
if (state.lst.memorymap) {
lst_memory_map(state.i_memory);
}
/* Finish off the listing and symbol files*/
lst_close();
if (state.processor_info)
cod_close_file();
free_files();
if (state.num.errors > 0)
return 1;
else
return 0;
}
void main_loop()
{
while(PAD_ButtonsHeld(0) & PAD_BUTTON_A) { VIDEO_WaitVSync (); }
// We don't care if a subsequent device is "default"
if(needsDeviceChange) {
free_files();
if(deviceHandler_deinit) {
deviceHandler_deinit(deviceHandler_initial);
}
if (forceSlot) {
deviceHandler_FAT_deinit(&initial_SD1);
}
curDevice = -1;
needsDeviceChange = 0;
deviceHandler_initial = NULL;
needsRefresh = 1;
curMenuLocation = ON_FILLIST;
select_device(0);
if (curDevice == WKF) {
trySlotB();
}
curMenuLocation = ON_OPTIONS;
}
if(deviceHandler_initial) {
// If the user selected a device, make sure it's ready before we browse the filesystem
deviceHandler_deinit( deviceHandler_initial );
sdgecko_setSpeed(EXI_SPEED32MHZ);
if(!deviceHandler_init( deviceHandler_initial )) {
if(((deviceHandler_initial->name[0] == 's')&&(deviceHandler_initial->name[1] == 'd'))||(deviceHandler_initial->name[0] == 'i')) {
print_gecko("SD/IDE-EXI Device Failed to initialize @ 32MHz!\r\nTrying again once @ 16MHz...\r\n");
sdgecko_setSpeed(EXI_SPEED16MHZ);
if(!deviceHandler_init(deviceHandler_initial)) {
// Try the alternate slot for SDGecko or IDE-EXI
if(deviceHandler_initial->name[0] == 's')
deviceHandler_initial = (deviceHandler_initial == &initial_SD0) ?
&initial_SD1:&initial_SD0;
else
deviceHandler_initial = (deviceHandler_initial == &initial_IDE0) ?
&initial_IDE1:&initial_IDE0;
memcpy(&curFile, deviceHandler_initial, sizeof(file_handle));
}
print_gecko("Trying alternate slot @ 32MHz...\r\n");
sdgecko_setSpeed(EXI_SPEED32MHZ);
if(!deviceHandler_init( deviceHandler_initial )) {
print_gecko("Alternate slot failed once @ 16MHz... \r\n");
sdgecko_setSpeed(EXI_SPEED16MHZ);
if(!deviceHandler_init( deviceHandler_initial )) {
print_gecko("Both slots failed twice\r\n");
needsDeviceChange = 1;
return;
}
}
}
}
if(curDevice==SD_CARD || curDevice==WKF || curDevice==IDEEXI) {
load_config(forceSlot);
}
}
else {
curMenuLocation=ON_OPTIONS;
}
// If a previously undetected device has been successfully init'd, mark it as available from now on
if(!deviceHandler_getDeviceAvailable(curDevice)) {
deviceHandler_setDeviceAvailable(curDevice, 1);
}
while(1) {
if(deviceHandler_initial && needsRefresh) {
curMenuLocation=ON_OPTIONS;
free_files();
curSelection=0; files=0; curMenuSelection=0;
// Read the directory/device TOC
if(allFiles){ free(allFiles); allFiles = NULL; }
print_gecko("Reading directory: %s\r\n",curFile.name);
files = deviceHandler_readDir(&curFile, &allFiles, -1);
memcpy(&curDir, &curFile, sizeof(file_handle));
sortFiles(allFiles, files);
print_gecko("Found %i entries\r\n",files);
if(files<1) { deviceHandler_deinit(deviceHandler_initial); needsDeviceChange=1; break;}
needsRefresh = 0;
curMenuLocation=ON_FILLIST;
}
while(PAD_ButtonsHeld(0) & PAD_BUTTON_A) { VIDEO_WaitVSync (); }
drawFiles(&allFiles, files);
u16 btns = PAD_ButtonsHeld(0);
if(curMenuLocation==ON_OPTIONS) {
if(btns & PAD_BUTTON_LEFT){ curMenuSelection = (--curMenuSelection < 0) ? (MENU_MAX-1) : curMenuSelection;}
else if(btns & PAD_BUTTON_RIGHT){curMenuSelection = (curMenuSelection + 1) % MENU_MAX; }
}
if(deviceHandler_initial && ((btns & PAD_BUTTON_B)||(curMenuLocation==ON_FILLIST))) {
while(PAD_ButtonsHeld(0) & PAD_BUTTON_B){ VIDEO_WaitVSync (); }
curMenuLocation=ON_FILLIST;
renderFileBrowser(&allFiles, files);
}
else if(btns & PAD_BUTTON_A) {
//handle menu event
switch(curMenuSelection) {
case 0: // Device change
needsDeviceChange = 1; //Change from SD->DVD or vice versa
break;
case 1: // Settings
show_settings(NULL, NULL);
break;
case 2: // Credits
show_info();
break;
case 3:
if(deviceHandler_initial) {
memcpy(&curFile, deviceHandler_initial, sizeof(file_handle));
if(curDevice == WKF) {
wkfReinit(); deviceHandler_deinit(deviceHandler_initial);
}
}
needsRefresh=1;
break;
case 4:
__libogc_exit(0);
break;
}
}
while (!(!(PAD_ButtonsHeld(0) & PAD_BUTTON_B) && !(PAD_ButtonsHeld(0) & PAD_BUTTON_A) && !(PAD_ButtonsHeld(0) & PAD_BUTTON_RIGHT) && !(PAD_ButtonsHeld(0) & PAD_BUTTON_LEFT))) {
VIDEO_WaitVSync();
}
if(needsDeviceChange) {
break;
}
}
}
static int
stormfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
int result;
struct file *dir;
GList *files = NULL, *head = NULL, *next = NULL;
DEBUG("readdir: %s\n", path);
if((result = valid_path(path)) != 0)
return result;
filler(buf, ".", 0, 0);
filler(buf, "..", 0, 0);
dir = cache_get(path);
if(cache_valid(dir) && dir->dir != NULL) {
pthread_mutex_lock(&dir->lock);
head = g_list_first(dir->dir);
while(head != NULL) {
next = head->next;
struct file *f = head->data;
filler(buf, (char *) f->name, f->st, 0);
head = next;
}
pthread_mutex_unlock(&dir->lock);
return 0;
}
if((result = proxy_readdir(path, &files)) != 0)
return result;
result = proxy_getattr_multi(path, files);
pthread_mutex_lock(&dir->lock);
head = g_list_first(files);
while(head != NULL) {
next = head->next;
// FIXME: list_bucket is using the same structure (file) as
// the cache which makes the code below confusing.
struct file *file = head->data;
char *fullpath = get_path(path, file->name);
struct file *f = cache_get(fullpath);
free(fullpath);
pthread_mutex_lock(&f->lock);
if(f->st == NULL)
f->st = g_new0(struct stat, 1);
memcpy(f->st, file->st, sizeof(struct stat));
f->st->st_nlink = 1;
cache_touch(f);
pthread_mutex_unlock(&f->lock);
filler(buf, (char *) f->name, f->st, 0);
dir->dir = g_list_append(dir->dir, f);
head = next;
}
pthread_mutex_unlock(&dir->lock);
free_files(files);
return result;
}
int
assemble(void)
{
char *pc;
struct symbol_table *cmd_defines;
/* store the command line defines to restore on second pass */
cmd_defines = state.stDefines;
state.c_memory = state.i_memory = i_memory_create();
if(state.basefilename[0] == '\0') {
strcpy(state.basefilename, state.srcfilename);
pc = strrchr(state.basefilename, '.');
if (pc)
*pc = 0;
}
/* Builtins are always case insensitive */
state.stBuiltin = push_symbol_table(NULL, 1);
state.stDirective = state.stBuiltin;
state.stMacros = push_symbol_table(NULL, state.case_insensitive);
state.stTop =
state.stGlobal = push_symbol_table(NULL, state.case_insensitive);
state.stTopDefines =
state.stDefines = push_symbol_table(cmd_defines, state.case_insensitive);
opcode_init(0);
/* the tables are built, select the processor if -p was used */
if (cmd_processor) {
select_processor(processor_name);
state.cmd_line.processor = 1;
}
state.pass = 1;
open_src(state.srcfilename, 0);
yyparse();
state.pass++;
state.org = 0;
state.cblock = 0;
/* clean out defines for second pass */
state.stTopDefines =
state.stDefines = push_symbol_table(cmd_defines, state.case_insensitive);
if (state.cmd_line.radix != 1)
state.radix = 16;
state.obj.symbol_num = 0;
state.obj.section_num = 0;
state.obj.org_num = 0;
state.found_config = 0;
state.found_devid = 0;
state.found_idlocs = 0;
coff_init();
cod_init();
lst_init();
open_src(state.srcfilename, 0);
yyparse();
assert(state.pass == 2);
pop_symbol_table(state.stBuiltin);
hex_init();
if(state.memory_dump)
print_i_memory(state.i_memory,
state.device.class == PROC_CLASS_PIC16E ? 1 : 0);
/* Maybe produce a symbol table */
if (state.lst.symboltable) {
lst_throw(); /* Start symbol table on a fresh page */
lst_symbol_table(state.stGlobal);
lst_defines_table(state.stDefines);
}
/* Maybe produce a memory map */
if ((state.mode == absolute) && (state.lst.memorymap)) {
lst_memory_map(state.i_memory);
}
/* Finish off the object, listing, and symbol files*/
coff_close_file();
lst_close();
if (state.processor_info)
cod_close_file();
free_files();
if ((state.num.errors > 0) ||
(gp_num_errors > 0))
return EXIT_FAILURE;
else
return EXIT_SUCCESS;
}
int tardiffmerge(int argc, char *argv[], char *flags)
{
int n, num_diffs;
struct File *files, *file;
bool input_ok, output_ok, order_files;
num_diffs = argc - 1;
input_ok = output_ok = false;
order_files = (strchr(flags, 'f') == NULL);
/* Verify arguments are all diff files: */
input_ok = identify_files((const char**)argv, num_diffs, NULL, &files);
for (file = files; file != NULL; file = file->next)
{
if (file->type == FILE_INVALID)
{
fprintf(stderr, "%s: %s\n", file->path, file->invalid.error);
}
else
if (file->type != FILE_DIFF)
{
fprintf(stderr, "%s: not a differences file\n", file->path);
input_ok = false;
}
else /* file->type == FILE_DIFF */
{
static uint8_t zero_digest[DS];
if (order_files &&
memcmp(file->diff.digest1, zero_digest, DS) == 0)
{
fprintf(stderr, "Input contains version 1.0 difference files; "
"merge order cannot be determined.\n");
input_ok = false;
}
}
}
if (input_ok && order_files)
{
mark_usable(files);
if (!order_input(&files))
{
fprintf(stderr, "Input files could not be ordered!\n");
input_ok = false;
}
}
if (input_ok)
{
/* Redirect output (if necessary) */
if (strcmp(argv[argc - 1], "-") != 0) redirect_stdout(argv[argc - 1]);
n = 0;
for (file = files; file != NULL; file = file->next)
{
InputStream *is;
char magic[MAGIC_LEN];
/* Try to open again */
is = OpenFileInputStream(file->path);
if (is == NULL)
{
fprintf(stderr, "%s: could not be opened.\n", file->path);
break;
}
/* Save pointer here, so we can close it later. */
is_diff[n++] = is;
/* Verify magic again */
read_data(is, magic, MAGIC_LEN);
if (memcmp(magic, MAGIC_STR, MAGIC_LEN) != 0)
{
fprintf(stderr, "%s: not a differences file\n", file->path);
break;
}
/* Process entire file */
process_input(is);
}
if (file == NULL)
{
output_ok = generate_output();
}
/* Close open streams: */
while (n-- > 0) is_diff[n]->close(is_diff[n]);
munmap(last_blocks, last_num_blocks*sizeof(BlockRef));
}
free_files(files);
return (input_ok && output_ok) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
spca50x_flash_get_TOC(CameraPrivateLibrary *pl, int *filecount)
{
uint16_t n_toc_entries;
int toc_size = 0;
if (pl->dirty_flash == 0){
/* TOC has been read already, and stored in the pl,
so let's not read it again unless "dirty" gets set,
e.g. by a reset, delete or capture action... */
*filecount = pl->num_files_on_flash;
return GP_OK;
}
pl->num_files_on_flash = 0;
if (pl->bridge == BRIDGE_SPCA500) { /* for dsc350 type cams */
/* command mode */
CHECK (gp_port_usb_msg_write (pl->gpdev,
0x00, 0x0080, 0x0100,
NULL, 0x00));
/* trigger TOC upload */
CHECK (gp_port_usb_msg_write (pl->gpdev,
0x05, 0x0000, 0x000d,
NULL, 0x00));
toc_size = 0x100; /* always 256 for the dsc-350 cams */
} else {
if (pl->fw_rev == 1) {
CHECK (gp_port_usb_msg_read (pl->gpdev,
0x0b, 0x0000, 0x0000,
(char*)&n_toc_entries, 0x02));
/* Each file gets two toc entries, one for the image,
one for the thumbnail */
LE16TOH (n_toc_entries);
*filecount = n_toc_entries/2;
} else {
CHECK (gp_port_usb_msg_read (pl->gpdev,
0x54, 0x0000, 0x0000,
(char*)&n_toc_entries, 0x02));
LE16TOH (n_toc_entries);
*filecount = n_toc_entries;
}
/* If empty, return now */
if (n_toc_entries == 0)
return GP_OK;
/* Request the TOC */
if (pl->fw_rev == 1) {
CHECK (gp_port_usb_msg_read (pl->gpdev, 0x0a,
n_toc_entries, 0x000c,
NULL, 0x00));
} else {
CHECK (gp_port_usb_msg_read (pl->gpdev, 0x54,
n_toc_entries, 0x0001,
NULL, 0x00));
}
/* slurp it in. Supposedly there's 32 bytes in each entry. */
toc_size = n_toc_entries * 32;
/* align */
if (toc_size % 512 != 0)
toc_size = ((toc_size / 512) + 1) * 512;
}
if (pl->flash_toc)
free (pl->flash_toc);
pl->flash_toc = malloc(toc_size);
if (!pl->flash_toc)
return GP_ERROR_NO_MEMORY;
CHECK (spca50x_flash_wait_for_ready(pl));
if (pl->bridge == BRIDGE_SPCA500) { /* For dsc350 type cams */
/* read the TOC from the cam */
CHECK (gp_port_read (pl->gpdev, (char *)pl->flash_toc, toc_size));
/* reset to idle */
CHECK (gp_port_usb_msg_write(pl->gpdev, 0x00, 0x0000, 0x0100, NULL, 0x0));
*filecount = (int)pl->flash_toc[10];
/* Now, create the files info buffer */
free_files(pl);
/* NOTE: using calloc to ensure new block is "empty" */
pl->files = calloc (1, *filecount * sizeof (struct SPCA50xFile));
if (!pl->files)
return GP_ERROR_NO_MEMORY;
} else { /* all other cams with flash... */
/* read the TOC from the cam */
CHECK (gp_port_read (pl->gpdev, (char *)pl->flash_toc, toc_size));
}
/* record that TOC has been updated - clear the "dirty" flag */
pl->num_files_on_flash = *filecount;
pl->dirty_flash = 0;
return GP_OK;
}
