]> git.sur5r.net Git - openocd/blob - src/target/avrt.c
flash: fix lpc2000 driver typo
[openocd] / src / target / avrt.c
1 /***************************************************************************
2  *   Copyright (C) 2009 by Simon Qian                                      *
3  *   SimonQian@SimonQian.com                                               *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) any later version.                                   *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19  ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "avrt.h"
25 #include "target.h"
26 #include "target_type.h"
27
28
29 #define AVR_JTAG_INS_LEN        4
30
31 /* forward declarations */
32 static int avr_target_create(struct target *target, Jim_Interp *interp);
33 static int avr_init_target(struct command_context *cmd_ctx, struct target *target);
34
35 static int avr_arch_state(struct target *target);
36 static int avr_poll(struct target *target);
37 static int avr_halt(struct target *target);
38 static int avr_resume(struct target *target, int current, uint32_t address, int handle_breakpoints, int debug_execution);
39 static int avr_step(struct target *target, int current, uint32_t address, int handle_breakpoints);
40
41 static int avr_assert_reset(struct target *target);
42 static int avr_deassert_reset(struct target *target);
43 static int avr_soft_reset_halt(struct target *target);
44
45 /* IR and DR functions */
46 static int mcu_write_ir(struct jtag_tap *tap, uint8_t *ir_in, uint8_t *ir_out, int ir_len, int rti);
47 static int mcu_write_dr(struct jtag_tap *tap, uint8_t *dr_in, uint8_t *dr_out, int dr_len, int rti);
48 static int mcu_write_ir_u8(struct jtag_tap *tap, uint8_t *ir_in, uint8_t ir_out, int ir_len, int rti);
49 static int mcu_write_dr_u32(struct jtag_tap *tap, uint32_t *ir_in, uint32_t ir_out, int dr_len, int rti);
50
51 struct target_type avr_target =
52 {
53         .name = "avr",
54
55         .poll = avr_poll,
56         .arch_state = avr_arch_state,
57
58         .target_request_data = NULL,
59
60         .halt = avr_halt,
61         .resume = avr_resume,
62         .step = avr_step,
63
64         .assert_reset = avr_assert_reset,
65         .deassert_reset = avr_deassert_reset,
66         .soft_reset_halt = avr_soft_reset_halt,
67 /*
68         .get_gdb_reg_list = avr_get_gdb_reg_list,
69
70         .read_memory = avr_read_memory,
71         .write_memory = avr_write_memory,
72         .bulk_write_memory = avr_bulk_write_memory,
73         .checksum_memory = avr_checksum_memory,
74         .blank_check_memory = avr_blank_check_memory,
75
76         .run_algorithm = avr_run_algorithm,
77
78         .add_breakpoint = avr_add_breakpoint,
79         .remove_breakpoint = avr_remove_breakpoint,
80         .add_watchpoint = avr_add_watchpoint,
81         .remove_watchpoint = avr_remove_watchpoint,
82 */
83         .target_create = avr_target_create,
84         .init_target = avr_init_target,
85 };
86
87 static int avr_target_create(struct target *target, Jim_Interp *interp)
88 {
89         struct avr_common *avr = calloc(1, sizeof(struct avr_common));
90
91         avr->jtag_info.tap = target->tap;
92         target->arch_info = avr;
93
94         return ERROR_OK;
95 }
96
97 static int avr_init_target(struct command_context *cmd_ctx, struct target *target)
98 {
99         LOG_DEBUG("%s", __FUNCTION__);
100         return ERROR_OK;
101 }
102
103 static int avr_arch_state(struct target *target)
104 {
105         LOG_DEBUG("%s", __FUNCTION__);
106         return ERROR_OK;
107 }
108
109 static int avr_poll(struct target *target)
110 {
111         if ((target->state == TARGET_RUNNING) || (target->state == TARGET_DEBUG_RUNNING))
112         {
113                 target->state = TARGET_HALTED;
114         }
115
116         LOG_DEBUG("%s", __FUNCTION__);
117         return ERROR_OK;
118 }
119
120 static int avr_halt(struct target *target)
121 {
122         LOG_DEBUG("%s", __FUNCTION__);
123         return ERROR_OK;
124 }
125
126 static int avr_resume(struct target *target, int current, uint32_t address,
127                 int handle_breakpoints, int debug_execution)
128 {
129         LOG_DEBUG("%s", __FUNCTION__);
130         return ERROR_OK;
131 }
132
133 static int avr_step(struct target *target, int current, uint32_t address, int handle_breakpoints)
134 {
135         LOG_DEBUG("%s", __FUNCTION__);
136         return ERROR_OK;
137 }
138
139 static int avr_assert_reset(struct target *target)
140 {
141         target->state = TARGET_RESET;
142
143         LOG_DEBUG("%s", __FUNCTION__);
144         return ERROR_OK;
145 }
146
147 static int avr_deassert_reset(struct target *target)
148 {
149         target->state = TARGET_RUNNING;
150
151         LOG_DEBUG("%s", __FUNCTION__);
152         return ERROR_OK;
153 }
154
155 static int avr_soft_reset_halt(struct target *target)
156 {
157         LOG_DEBUG("%s", __FUNCTION__);
158         return ERROR_OK;
159 }
160
161 int avr_jtag_senddat(struct jtag_tap *tap, uint32_t* dr_in, uint32_t dr_out,
162                 int len)
163 {
164         return mcu_write_dr_u32(tap, dr_in, dr_out, len, 1);
165 }
166
167 int avr_jtag_sendinstr(struct jtag_tap *tap, uint8_t *ir_in, uint8_t ir_out)
168 {
169         return mcu_write_ir_u8(tap, ir_in, ir_out, AVR_JTAG_INS_LEN, 1);
170 }
171
172 /* IR and DR functions */
173 static int mcu_write_ir(struct jtag_tap *tap, uint8_t *ir_in, uint8_t *ir_out,
174                 int ir_len, int rti)
175 {
176         if (NULL == tap)
177         {
178                 LOG_ERROR("invalid tap");
179                 return ERROR_FAIL;
180         }
181         if (ir_len != tap->ir_length)
182         {
183                 LOG_ERROR("invalid ir_len");
184                 return ERROR_FAIL;
185         }
186
187         {
188                 jtag_add_plain_ir_scan(tap->ir_length, ir_out, ir_in, TAP_IDLE);
189         }
190
191         return ERROR_OK;
192 }
193
194 static int mcu_write_dr(struct jtag_tap *tap, uint8_t *dr_in, uint8_t *dr_out,
195                 int dr_len, int rti)
196 {
197         if (NULL == tap)
198         {
199                 LOG_ERROR("invalid tap");
200                 return ERROR_FAIL;
201         }
202
203         {
204                 jtag_add_plain_dr_scan(dr_len, dr_out, dr_in, TAP_IDLE);
205         }
206
207         return ERROR_OK;
208 }
209
210 static int mcu_write_ir_u8(struct jtag_tap *tap, uint8_t *ir_in,
211                 uint8_t ir_out, int ir_len, int rti)
212 {
213         if (ir_len > 8)
214         {
215                 LOG_ERROR("ir_len overflow, maxium is 8");
216                 return ERROR_FAIL;
217         }
218
219         mcu_write_ir(tap, ir_in, &ir_out, ir_len, rti);
220
221         return ERROR_OK;
222 }
223
224 static int mcu_write_dr_u32(struct jtag_tap *tap, uint32_t *dr_in,
225                 uint32_t dr_out, int dr_len, int rti)
226 {
227         if (dr_len > 32)
228         {
229                 LOG_ERROR("dr_len overflow, maxium is 32");
230                 return ERROR_FAIL;
231         }
232
233         mcu_write_dr(tap, (uint8_t*)dr_in, (uint8_t*)&dr_out, dr_len, rti);
234
235         return ERROR_OK;
236 }
237
238 int mcu_execute_queue(void)
239 {
240         return jtag_execute_queue();
241 }