From a76d924dffcb040b44a2bb5be026f0c974590c30 Mon Sep 17 00:00:00 2001 From: Daniel Jacobowitz Date: Thu, 21 Sep 2006 14:00:53 +0000 Subject: * Makefile.in (SFILES): Add target-memory.c. (COMMON_OBS): Add target-memory.o. * memattr.c (lookup_mem_region): Adjust handling for the top of memory. Improve comments. * remote.c (packet_check_result): New function, split out from packet_ok. Recognize "E." as an error prefix. (packet_ok): Use it. (remote_write_bytes_aux): New function, renamed from remote_write_bytes. Take packet header, packet format, and length flag as arguments. (remote_write_bytes): Rewrite to use remote_write_bytes_aux. (remote_send_printf, restore_remote_timeout) (remote_flash_timeout, remote_flash_erase, remote_flash_write) (remote_flash_done): New. (remote_xfer_partial): Handle flash writes. (init_remote_ops, init_remote_async_ops): Set to_flash_erase and to_flash_done. * symfile.c (struct load_section_data): Include a pointer to the cumulative stats and a request queue. Move most members to other types. (struct load_progress_data, struct load_progress_section_data): New types. (load_progress): Handle a NULL baton and zero bytes. Update for type changes. (load_section_callback): Create memory write requests instead of writing to memory. Don't print the progress message here. (clear_memory_write_data): New function. (generic_load): Use target_write_memory_blocks. * target-memory.c: New file. * target.c (update_current_target): Mention new uninherited methods. (memory_xfer_partial): Issue an error for flash writes. (target_flash_erase, target_flash_done): New functions. (target_write_with_progress): Call the progress callback at the start also. * target.h (enum target_object): Add TARGET_OBJECT_FLASH. (target_write_with_progress): Update comment. (struct target_ops): Add to_flash_erase and to_flash_done. (target_flash_erase, target_flash_done, struct memory_write_request) (memory_write_request_s, enum flash_preserve_mode) (target_write_memory_blocks): New, including a vector type for memory_write_request_s. --- gdb/target.h | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 76 insertions(+), 5 deletions(-) (limited to 'gdb/target.h') diff --git a/gdb/target.h b/gdb/target.h index 6769216..ffbaddc 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -202,6 +202,11 @@ enum target_object TARGET_OBJECT_WCOOKIE, /* Target memory map in XML format. */ TARGET_OBJECT_MEMORY_MAP, + /* Flash memory. This object can be used to write contents to + a previously erased flash memory. Using it without erasing + flash can have unexpected results. Addresses are physical + address on target, and not relative to flash start. */ + TARGET_OBJECT_FLASH /* Possible future objects: TARGET_OBJECT_FILE, TARGET_OBJECT_PROC, ... */ }; @@ -227,11 +232,13 @@ extern LONGEST target_write (struct target_ops *ops, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len); -/* Similar to target_write, except that it also calls PROGRESS - with the number of bytes written and the opaque BATON after - every partial write. This is useful for progress reporting - and user interaction while writing data. To abort the transfer, - the progress callback can throw an exception. */ +/* Similar to target_write, except that it also calls PROGRESS with + the number of bytes written and the opaque BATON after every + successful partial write (and before the first write). This is + useful for progress reporting and user interaction while writing + data. To abort the transfer, the progress callback can throw an + exception. */ + LONGEST target_write_with_progress (struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, @@ -471,6 +478,20 @@ struct target_ops layers will re-fetch it. */ VEC(mem_region_s) *(*to_memory_map) (struct target_ops *); + /* Erases the region of flash memory starting at ADDRESS, of + length LENGTH. + + Precondition: both ADDRESS and ADDRESS+LENGTH should be aligned + on flash block boundaries, as reported by 'to_memory_map'. */ + void (*to_flash_erase) (struct target_ops *, + ULONGEST address, LONGEST length); + + /* Finishes a flash memory write sequence. After this operation + all flash memory should be available for writing and the result + of reading from areas written by 'to_flash_write' should be + equal to what was written. */ + void (*to_flash_done) (struct target_ops *); + int to_magic; /* Need sub-structure for target machine related rather than comm related? */ @@ -599,6 +620,56 @@ extern int child_xfer_memory (CORE_ADDR, gdb_byte *, int, int, is returned. */ VEC(mem_region_s) *target_memory_map (void); +/* Erase the specified flash region. */ +void target_flash_erase (ULONGEST address, LONGEST length); + +/* Finish a sequence of flash operations. */ +void target_flash_done (void); + +/* Describes a request for a memory write operation. */ +struct memory_write_request + { + /* Begining address that must be written. */ + ULONGEST begin; + /* Past-the-end address. */ + ULONGEST end; + /* The data to write. */ + gdb_byte *data; + /* A callback baton for progress reporting for this request. */ + void *baton; + }; +typedef struct memory_write_request memory_write_request_s; +DEF_VEC_O(memory_write_request_s); + +/* Enumeration specifying different flash preservation behaviour. */ +enum flash_preserve_mode + { + flash_preserve, + flash_discard + }; + +/* Write several memory blocks at once. This version can be more + efficient than making several calls to target_write_memory, in + particular because it can optimize accesses to flash memory. + + Moreover, this is currently the only memory access function in gdb + that supports writing to flash memory, and it should be used for + all cases where access to flash memory is desirable. + + REQUESTS is the vector (see vec.h) of memory_write_request. + PRESERVE_FLASH_P indicates what to do with blocks which must be + erased, but not completely rewritten. + PROGRESS_CB is a function that will be periodically called to provide + feedback to user. It will be called with the baton corresponding + to the request currently being written. It may also be called + with a NULL baton, when preserved flash sectors are being rewritten. + + The function returns 0 on success, and error otherwise. */ +int target_write_memory_blocks (VEC(memory_write_request_s) *requests, + enum flash_preserve_mode preserve_flash_p, + void (*progress_cb) (ULONGEST, void *)); + + extern char *child_pid_to_exec_file (int); extern char *child_core_file_to_sym_file (char *); -- cgit v1.1