Remove misleading typedef on struct scan_command.
 static void armjtagew_state_move(void);
 static void armjtagew_path_move(int num_states, tap_state_t *path);
 static void armjtagew_runtest(int num_cycles);
-static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command);
+static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
 static void armjtagew_reset(int trst, int srst);
 //static void armjtagew_simple_command(uint8_t command);
 static int armjtagew_get_status(void);
 static int armjtagew_tap_execute(void);
 static void armjtagew_tap_ensure_space(int scans, int bits);
 static void armjtagew_tap_append_step(int tms, int tdi);
-static void armjtagew_tap_append_scan(int length, uint8_t *buffer, scan_command_t *command);
+static void armjtagew_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command);
 
 /* ARM-JTAG-EW lowlevel functions */
 struct armjtagew {
        }
 }
 
-static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command)
+static void armjtagew_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
        tap_state_t saved_end_state;
 
 struct pending_scan_result {
        int first;      /* First bit position in tdo_buffer to read */
        int length; /* Number of bits to read */
-       scan_command_t *command; /* Corresponding scan command */
+       struct scan_command *command; /* Corresponding scan command */
        uint8_t *buffer;
 };
 
        }
 }
 
-void armjtagew_tap_append_scan(int length, uint8_t *buffer, scan_command_t *command)
+void armjtagew_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command)
 {
        struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
        int i;
                                uint8_t *buffer = pending_scan_result->buffer;
                                int length = pending_scan_result->length;
                                int first = pending_scan_result->first;
-                               scan_command_t *command = pending_scan_result->command;
+                               struct scan_command *command = pending_scan_result->command;
 
                                /* Copy to buffer */
                                buf_set_buf(tdo_buffer, first, buffer, 0, length);
 
 }
 
 
-void bitq_scan(scan_command_t* cmd)
+void bitq_scan(struct scan_command* cmd)
 {
        int i;
 
 
        next_command_pointer = &jtag_command_queue;
 }
 
-enum scan_type jtag_scan_type(const scan_command_t *cmd)
+enum scan_type jtag_scan_type(const struct scan_command *cmd)
 {
        int i;
        int type = 0;
        return type;
 }
 
-int jtag_scan_size(const scan_command_t *cmd)
+int jtag_scan_size(const struct scan_command *cmd)
 {
        int bit_count = 0;
        int i;
        return bit_count;
 }
 
-int jtag_build_buffer(const scan_command_t *cmd, uint8_t **buffer)
+int jtag_build_buffer(const struct scan_command *cmd, uint8_t **buffer)
 {
        int bit_count = 0;
        int i;
        return bit_count;
 }
 
-int jtag_read_buffer(uint8_t *buffer, const scan_command_t *cmd)
+int jtag_read_buffer(uint8_t *buffer, const struct scan_command *cmd)
 {
        int i;
        int bit_count = 0;
 
  * The scan_command provide a means of encapsulating a set of scan_field_s
  * structures that should be scanned in/out to the device.
  */
-typedef struct scan_command_s
-{
+struct scan_command {
        /// instruction/not data scan
        bool ir_scan;
        /// number of fields in *fields array
        struct scan_field* fields;
        /// state in which JTAG commands should finish
        tap_state_t end_state;
-} scan_command_t;
+};
 
 typedef struct statemove_command_s
 {
  */
 typedef union jtag_command_container_u
 {
-       scan_command_t*         scan;
+       struct scan_command*         scan;
        statemove_command_t*    statemove;
        pathmove_command_t*     pathmove;
        runtest_command_t*      runtest;
 void jtag_queue_command(jtag_command_t *cmd);
 void jtag_command_queue_reset(void);
 
-enum scan_type jtag_scan_type(const scan_command_t* cmd);
-int jtag_scan_size(const scan_command_t* cmd);
-int jtag_read_buffer(uint8_t* buffer, const scan_command_t* cmd);
-int jtag_build_buffer(const scan_command_t* cmd, uint8_t** buffer);
+enum scan_type jtag_scan_type(const struct scan_command* cmd);
+int jtag_scan_size(const struct scan_command* cmd);
+int jtag_read_buffer(uint8_t* buffer, const struct scan_command* cmd);
+int jtag_build_buffer(const struct scan_command* cmd, uint8_t** buffer);
 
 #endif // JTAG_COMMANDS_H
 
        size_t num_taps = jtag_tap_count_enabled();
 
        jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
-       scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
+       struct scan_command * scan              = cmd_queue_alloc(sizeof(struct scan_command));
        struct scan_field * out_fields  = cmd_queue_alloc(num_taps  * sizeof(struct scan_field));
 
        jtag_queue_command(cmd);
 {
 
        jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
-       scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
+       struct scan_command * scan              = cmd_queue_alloc(sizeof(struct scan_command));
        struct scan_field * out_fields  = cmd_queue_alloc(in_num_fields * sizeof(struct scan_field));
 
        jtag_queue_command(cmd);
        }
 
        jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
-       scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
+       struct scan_command * scan              = cmd_queue_alloc(sizeof(struct scan_command));
        struct scan_field * out_fields  = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(struct scan_field));
 
        jtag_queue_command(cmd);
 
 
        jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
-       scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
+       struct scan_command * scan              = cmd_queue_alloc(sizeof(struct scan_command));
        struct scan_field * out_fields  = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(struct scan_field));
 
        jtag_queue_command(cmd);
 int interface_jtag_add_plain_dr_scan(int in_num_fields, const struct scan_field *in_fields, tap_state_t state)
 {
        jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
-       scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
+       struct scan_command * scan              = cmd_queue_alloc(sizeof(struct scan_command));
        struct scan_field * out_fields  = cmd_queue_alloc(in_num_fields * sizeof(struct scan_field));
 
        jtag_queue_command(cmd);
 
        }
 }
 
-static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, uint8_t* buffer, int scan_size)
+static int ft2232_large_scan(struct scan_command* cmd, enum scan_type type, uint8_t* buffer, int scan_size)
 {
        int num_bytes = (scan_size + 7) / 8;
        int bits_left = scan_size;
 
 static void jlink_state_move(void);
 static void jlink_path_move(int num_states, tap_state_t *path);
 static void jlink_runtest(int num_cycles);
-static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command);
+static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
 static void jlink_reset(int trst, int srst);
 static void jlink_simple_command(uint8_t command);
 static int jlink_get_status(void);
 static int jlink_tap_execute(void);
 static void jlink_tap_ensure_space(int scans, int bits);
 static void jlink_tap_append_step(int tms, int tdi);
-static void jlink_tap_append_scan(int length, uint8_t *buffer, scan_command_t *command);
+static void jlink_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command);
 
 /* Jlink lowlevel functions */
 struct jlink {
        }
 }
 
-static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command)
+static void jlink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
        tap_state_t saved_end_state;
 
 struct pending_scan_result {
        int first;      /* First bit position in tdo_buffer to read */
        int length; /* Number of bits to read */
-       scan_command_t *command; /* Corresponding scan command */
+       struct scan_command *command; /* Corresponding scan command */
        uint8_t *buffer;
 };
 
        tap_length++;
 }
 
-static void jlink_tap_append_scan(int length, uint8_t *buffer, scan_command_t *command)
+static void jlink_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command)
 {
        struct pending_scan_result *pending_scan_result =
                &pending_scan_results_buffer[pending_scan_results_length];
                uint8_t *buffer = pending_scan_result->buffer;
                int length = pending_scan_result->length;
                int first = pending_scan_result->first;
-               scan_command_t *command = pending_scan_result->command;
+               struct scan_command *command = pending_scan_result->command;
 
                /* Copy to buffer */
                buf_set_buf(tdo_buffer, first, buffer, 0, length);
 
 struct pending_scan_result {
        int offset;
        int length; /* Number of bits to read */
-       scan_command_t *command; /* Corresponding scan command */
+       struct scan_command *command; /* Corresponding scan command */
        uint8_t *buffer;
 };
 
 static void vsllink_stableclocks_dma(int num_cycles, int tms);
 static void vsllink_stableclocks_normal(int num_cycles, int tms);
 static void (*vsllink_stableclocks)(int num_cycles, int tms);
-static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command);
-static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command);
-static void (*vsllink_scan)(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command);
+static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
+static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
+static void (*vsllink_scan)(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
 static void vsllink_reset(int trst, int srst);
 static void vsllink_simple_command(uint8_t command);
 static int vsllink_connect(void);
 static void vsllink_tap_ensure_space_dma(int scans, int length);
 static void vsllink_tap_ensure_space_normal(int scans, int length);
 static void (*vsllink_tap_ensure_space)(int scans, int length);
-static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_command_t *command);
-static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_command_t *command, int offset);
+static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, struct scan_command *command);
+static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, struct scan_command *command, int offset);
 
 /* VSLLink lowlevel functions */
 struct vsllink {
        }
 }
 
-static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command)
+static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
        tap_state_t saved_end_state;
        uint8_t bits_left, tms_tmp, tdi_len;
 
        tap_set_state(tap_get_end_state());
 }
-static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command)
+static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
        tap_state_t saved_end_state;
 
        }
 }
 
-static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_command_t *command, int offset)
+static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, struct scan_command *command, int offset)
 {
        struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
        int i;
 
        pending_scan_results_length++;
 }
-static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_command_t *command)
+static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, struct scan_command *command)
 {
        struct pending_scan_result *pending_scan_result;
        int len_tmp, len_all, i;
                                uint8_t *buffer = pending_scan_result->buffer;
                                int length = pending_scan_result->length;
                                int offset = pending_scan_result->offset;
-                               scan_command_t *command = pending_scan_result->command;
+                               struct scan_command *command = pending_scan_result->command;
 
                                if (buffer != NULL)
                                {
                                int length = pending_scan_result->length;
                                int first = pending_scan_result->offset;
 
-                               scan_command_t *command = pending_scan_result->command;
+                               struct scan_command *command = pending_scan_result->command;
                                buf_set_buf(vsllink_usb_in_buffer, first, buffer, 0, length);
 
                                DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):", length, first);