diff options
Diffstat (limited to 'utils/imxtools/scsitools/scsitool.c')
-rw-r--r-- | utils/imxtools/scsitools/scsitool.c | 523 |
1 files changed, 225 insertions, 298 deletions
diff --git a/utils/imxtools/scsitools/scsitool.c b/utils/imxtools/scsitools/scsitool.c index 2e364dcb17..86956d0910 100644 --- a/utils/imxtools/scsitools/scsitool.c +++ b/utils/imxtools/scsitools/scsitool.c | |||
@@ -31,50 +31,21 @@ | |||
31 | #include <sys/stat.h> | 31 | #include <sys/stat.h> |
32 | #include <fcntl.h> | 32 | #include <fcntl.h> |
33 | #include <unistd.h> | 33 | #include <unistd.h> |
34 | #ifndef _WIN32 | 34 | #include "rbscsi.h" |
35 | #include <scsi/scsi.h> | ||
36 | #endif | ||
37 | #include <scsi/sg_lib.h> | ||
38 | #include <scsi/sg_pt.h> | ||
39 | #include "misc.h" | 35 | #include "misc.h" |
40 | #include "stmp_scsi.h" | 36 | #include "stmp_scsi.h" |
41 | 37 | ||
42 | /* the windows port doesn't have scsi.h and GOOD */ | ||
43 | #ifndef GOOD | ||
44 | #define GOOD 0x00 | ||
45 | #endif | ||
46 | |||
47 | bool g_debug = false; | 38 | bool g_debug = false; |
48 | bool g_force = false; | 39 | bool g_force = false; |
49 | int g_dev_fd = 0; | 40 | stmp_device_t g_dev_fd; |
50 | |||
51 | #define let_the_force_flow(x) do { if(!g_force) return x; } while(0) | ||
52 | #define continue_the_force(x) if(x) let_the_force_flow(x) | ||
53 | |||
54 | #define check_field(v_exp, v_have, str_ok, str_bad) \ | ||
55 | if((v_exp) != (v_have)) \ | ||
56 | { cprintf(RED, str_bad); let_the_force_flow(__LINE__); } \ | ||
57 | else { cprintf(RED, str_ok); } | ||
58 | 41 | ||
59 | #define errorf(...) do { cprintf(GREY, __VA_ARGS__); return __LINE__; } while(0) | 42 | struct stmp_device_t |
60 | |||
61 | #if 0 | ||
62 | void *buffer_alloc(int sz) | ||
63 | { | ||
64 | #ifdef SG_LIB_MINGW | ||
65 | unsigned psz = getpagesize(); | ||
66 | #else | ||
67 | unsigned psz = sysconf(_SC_PAGESIZE); /* was getpagesize() */ | ||
68 | #endif | ||
69 | void *buffer = malloc(sz + psz); | ||
70 | return (void *)(((ptrdiff_t)(buffer + psz - 1)) & ~(psz - 1)); | ||
71 | } | ||
72 | #else | ||
73 | void *buffer_alloc(int sz) | ||
74 | { | 43 | { |
75 | return malloc(sz); | 44 | rb_scsi_device_t dev; |
76 | } | 45 | unsigned flags; |
77 | #endif | 46 | void *user; |
47 | stmp_printf_t printf; | ||
48 | }; | ||
78 | 49 | ||
79 | static uint16_t fix_endian16be(uint16_t w) | 50 | static uint16_t fix_endian16be(uint16_t w) |
80 | { | 51 | { |
@@ -115,77 +86,99 @@ static void print_hex(void *_buffer, int buffer_size) | |||
115 | } | 86 | } |
116 | } | 87 | } |
117 | 88 | ||
118 | /* Do read */ | 89 | static void misc_std_printf(void *user, const char *fmt, ...) |
119 | #define DO_READ (1 << 1) | 90 | { |
120 | /* Do write */ | 91 | (void) user; |
121 | #define DO_WRITE (1 << 2) | 92 | va_list args; |
93 | va_start(args, fmt); | ||
94 | vprintf(fmt, args); | ||
95 | va_end(args); | ||
96 | } | ||
122 | 97 | ||
123 | /* returns <0 on error and status otherwise */ | 98 | #define stmp_printf(dev, ...) \ |
124 | int do_scsi(uint8_t *cdb, int cdb_size, unsigned flags, void *sense, int *sense_size, void *buffer, int *buf_size) | 99 | dev->printf(dev->user, __VA_ARGS__) |
100 | |||
101 | #define stmp_debugf(dev, ...) \ | ||
102 | do{ if(dev->flags & STMP_DEBUG) stmp_printf(dev, __VA_ARGS__); }while(0) | ||
103 | |||
104 | stmp_device_t stmp_open(rb_scsi_device_t rdev, unsigned flags, void *user, stmp_printf_t printf) | ||
125 | { | 105 | { |
126 | char error[256]; | 106 | if(printf == NULL) |
127 | struct sg_pt_base *obj = construct_scsi_pt_obj(); | 107 | printf = misc_std_printf; |
128 | if(obj == NULL) | 108 | stmp_device_t sdev = malloc(sizeof(struct stmp_device_t)); |
129 | { | 109 | memset(sdev, 0, sizeof(struct stmp_device_t)); |
130 | cprintf(GREY, "construct_scsi_pt_obj failed\n"); | 110 | sdev->dev = rdev; |
131 | return 1; | 111 | sdev->flags = flags; |
132 | } | 112 | sdev->user = user; |
133 | set_scsi_pt_cdb(obj, cdb, cdb_size); | 113 | sdev->printf = printf; |
134 | if(sense) | 114 | return sdev; |
135 | set_scsi_pt_sense(obj, sense, *sense_size); | 115 | } |
136 | if(flags & DO_READ) | ||
137 | set_scsi_pt_data_in(obj, buffer, *buf_size); | ||
138 | if(flags & DO_WRITE) | ||
139 | set_scsi_pt_data_out(obj, buffer, *buf_size); | ||
140 | int ret = do_scsi_pt(obj, g_dev_fd, 10, 0); | ||
141 | switch(get_scsi_pt_result_category(obj)) | ||
142 | { | ||
143 | case SCSI_PT_RESULT_SENSE: | ||
144 | case SCSI_PT_RESULT_GOOD: | ||
145 | ret = get_scsi_pt_status_response(obj); | ||
146 | break; | ||
147 | case SCSI_PT_RESULT_STATUS: | ||
148 | cprintf(GREY, "Status error: %d (", get_scsi_pt_status_response(obj)); | ||
149 | sg_print_scsi_status(get_scsi_pt_status_response(obj)); | ||
150 | printf(")\n"); | ||
151 | break; | ||
152 | case SCSI_PT_RESULT_TRANSPORT_ERR: | ||
153 | cprintf(GREY, "Transport error: %s\n", get_scsi_pt_transport_err_str(obj, 256, error)); | ||
154 | ret = -2; | ||
155 | break; | ||
156 | case SCSI_PT_RESULT_OS_ERR: | ||
157 | cprintf(GREY, "OS error: %s\n", get_scsi_pt_os_err_str(obj, 256, error)); | ||
158 | ret = -3; | ||
159 | break; | ||
160 | default: | ||
161 | cprintf(GREY, "Unknown error\n"); | ||
162 | break; | ||
163 | } | ||
164 | 116 | ||
165 | if(sense) | 117 | void stmp_close(stmp_device_t dev) |
166 | *sense_size = get_scsi_pt_sense_len(obj); | 118 | { |
167 | if(flags & (DO_WRITE | DO_READ)) | 119 | free(dev); |
168 | *buf_size -= get_scsi_pt_resid(obj); | 120 | } |
169 | 121 | ||
170 | destruct_scsi_pt_obj(obj); | 122 | /* returns <0 on error and status otherwise */ |
171 | return ret; | 123 | int stmp_scsi(stmp_device_t dev, uint8_t *cdb, int cdb_size, unsigned flags, |
124 | void *sense, int *sense_size, void *buffer, int *buf_size) | ||
125 | { | ||
126 | struct rb_scsi_raw_cmd_t cmd; | ||
127 | memset(&cmd, 0, sizeof(cmd)); | ||
128 | cmd.dir = RB_SCSI_NONE; | ||
129 | if(flags & STMP_READ) | ||
130 | cmd.dir = RB_SCSI_READ; | ||
131 | if(flags & STMP_WRITE) | ||
132 | cmd.dir = RB_SCSI_WRITE; | ||
133 | cmd.cdb = cdb; | ||
134 | cmd.cdb_len = cdb_size; | ||
135 | cmd.sense = sense; | ||
136 | cmd.sense_len = *sense_size; | ||
137 | cmd.buf = buffer; | ||
138 | cmd.buf_len = *buf_size; | ||
139 | cmd.tmo = 1; | ||
140 | int ret = rb_scsi_raw_xfer(dev->dev, &cmd); | ||
141 | *sense_size = cmd.sense_len; | ||
142 | *buf_size = cmd.buf_len; | ||
143 | return ret == RB_SCSI_OK || ret == RB_SCSI_SENSE ? cmd.status : -ret; | ||
172 | } | 144 | } |
173 | 145 | ||
174 | int do_sense_analysis(int status, uint8_t *sense, int sense_size) | 146 | int stmp_sense_analysis(stmp_device_t dev, int status, uint8_t *sense, int sense_size) |
175 | { | 147 | { |
176 | if(status != GOOD && g_debug) | 148 | if(status != 0 && (dev->flags & STMP_DEBUG)) |
177 | { | 149 | { |
178 | cprintf_field("Status:", " "); fflush(stdout); | 150 | stmp_printf(dev, "Status: %d\n", status); |
179 | sg_print_scsi_status(status); | 151 | stmp_printf(dev, "Sense:"); |
180 | cprintf_field("\nSense:", " "); fflush(stdout); | 152 | for(int i = 0; i < sense_size; i++) |
181 | sg_print_sense(NULL, sense, sense_size, 0); | 153 | stmp_printf(dev, " %02x", sense[i]); |
154 | stmp_printf(dev, "\n"); | ||
182 | } | 155 | } |
183 | if(status == GOOD) | ||
184 | return 0; | ||
185 | return status; | 156 | return status; |
186 | } | 157 | } |
187 | 158 | ||
188 | int stmp_inquiry(uint8_t *dev_type, char vendor[9], char product[17]) | 159 | static int stmp_scsi_read_cmd(stmp_device_t dev, uint8_t cmd, uint8_t subcmd, |
160 | uint8_t subsubcmd, void *buf, int *len) | ||
161 | { | ||
162 | uint8_t cdb[16]; | ||
163 | memset(cdb, 0, sizeof(cdb)); | ||
164 | cdb[0] = SCSI_STMP_READ; | ||
165 | cdb[1] = cmd; | ||
166 | cdb[2] = subcmd; | ||
167 | cdb[3] = subsubcmd; | ||
168 | |||
169 | uint8_t sense[32]; | ||
170 | int sense_size = sizeof(sense); | ||
171 | |||
172 | int ret = stmp_scsi(dev, cdb, sizeof(cdb), STMP_READ, sense, &sense_size, buf, len); | ||
173 | if(ret < 0) | ||
174 | return ret; | ||
175 | ret = stmp_sense_analysis(dev, ret, sense, sense_size); | ||
176 | if(ret) | ||
177 | return ret; | ||
178 | return 0; | ||
179 | } | ||
180 | |||
181 | int stmp_scsi_inquiry(stmp_device_t dev, uint8_t *dev_type, char vendor[9], char product[17]) | ||
189 | { | 182 | { |
190 | unsigned char buffer[36]; | 183 | unsigned char buffer[36]; |
191 | uint8_t cdb[10]; | 184 | uint8_t cdb[10]; |
@@ -197,10 +190,10 @@ int stmp_inquiry(uint8_t *dev_type, char vendor[9], char product[17]) | |||
197 | int sense_size = sizeof(sense); | 190 | int sense_size = sizeof(sense); |
198 | 191 | ||
199 | int buf_sz = sizeof(buffer); | 192 | int buf_sz = sizeof(buffer); |
200 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, buffer, &buf_sz); | 193 | int ret = stmp_scsi(dev, cdb, sizeof(cdb), STMP_READ, sense, &sense_size, buffer, &buf_sz); |
201 | if(ret < 0) | 194 | if(ret < 0) |
202 | return ret; | 195 | return ret; |
203 | ret = do_sense_analysis(ret, sense, sense_size); | 196 | ret = stmp_sense_analysis(dev, ret, sense, sense_size); |
204 | if(ret) | 197 | if(ret) |
205 | return ret; | 198 | return ret; |
206 | if(buf_sz != sizeof(buffer)) | 199 | if(buf_sz != sizeof(buffer)) |
@@ -213,109 +206,66 @@ int stmp_inquiry(uint8_t *dev_type, char vendor[9], char product[17]) | |||
213 | return 0; | 206 | return 0; |
214 | } | 207 | } |
215 | 208 | ||
216 | static int stmp_get_protocol_version(struct scsi_stmp_protocol_version_t *ver) | 209 | int stmp_scsi_get_protocol_version(stmp_device_t dev, void *buf, int *len) |
217 | { | 210 | { |
218 | uint8_t cdb[16]; | 211 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_PROTOCOL_VERSION, 0, 0, buf, len); |
219 | memset(cdb, 0, sizeof(cdb)); | 212 | } |
220 | cdb[0] = SCSI_STMP_READ; | ||
221 | cdb[1] = SCSI_STMP_CMD_GET_PROTOCOL_VERSION; | ||
222 | |||
223 | uint8_t sense[32]; | ||
224 | int sense_size = sizeof(sense); | ||
225 | 213 | ||
226 | int buf_sz = sizeof(struct scsi_stmp_protocol_version_t); | 214 | int stmp_get_protocol_version(stmp_device_t dev, struct scsi_stmp_protocol_version_t *ver) |
227 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, ver, &buf_sz); | 215 | { |
228 | if(ret < 0) | 216 | int len = sizeof(*ver); |
229 | return ret; | 217 | int ret = stmp_scsi_get_protocol_version(dev, ver, &len); |
230 | ret = do_sense_analysis(ret, sense, sense_size); | 218 | if(ret || len != sizeof(*ver)) |
231 | if(ret) | ||
232 | return ret; | ||
233 | if(buf_sz != sizeof(struct scsi_stmp_protocol_version_t)) | ||
234 | return -1; | 219 | return -1; |
235 | return 0; | 220 | return 0; |
236 | } | 221 | } |
237 | 222 | ||
238 | static int stmp_get_chip_major_rev_id(struct scsi_stmp_chip_major_rev_id_t *ver) | 223 | int stmp_scsi_get_chip_major_rev_id(stmp_device_t dev, void *buf, int *len) |
239 | { | 224 | { |
240 | uint8_t cdb[16]; | 225 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_CHIP_MAJOR_REV_ID, 0, 0, buf, len); |
241 | memset(cdb, 0, sizeof(cdb)); | 226 | } |
242 | cdb[0] = SCSI_STMP_READ; | ||
243 | cdb[1] = SCSI_STMP_CMD_GET_CHIP_MAJOR_REV_ID; | ||
244 | |||
245 | uint8_t sense[32]; | ||
246 | int sense_size = sizeof(sense); | ||
247 | 227 | ||
248 | int buf_sz = sizeof(struct scsi_stmp_chip_major_rev_id_t); | 228 | int stmp_get_chip_major_rev_id(stmp_device_t dev, uint16_t *ver) |
249 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, ver, &buf_sz); | 229 | { |
250 | if(ret < 0) | 230 | int len = sizeof(*ver); |
251 | return ret; | 231 | int ret = stmp_scsi_get_chip_major_rev_id(dev, ver, &len); |
252 | ret = do_sense_analysis(ret, sense, sense_size); | 232 | if(ret || len != sizeof(*ver)) |
253 | if(ret) | ||
254 | return ret; | ||
255 | if(buf_sz != sizeof(struct scsi_stmp_chip_major_rev_id_t)) | ||
256 | return -1; | 233 | return -1; |
257 | ver->rev = fix_endian16be(ver->rev); | 234 | *ver = fix_endian16be(*ver); |
258 | return 0; | 235 | return 0; |
259 | } | 236 | } |
260 | 237 | ||
261 | static int stmp_get_rom_rev_id(struct scsi_stmp_rom_rev_id_t *ver) | 238 | int stmp_scsi_get_rom_rev_id(stmp_device_t dev, void *buf, int *len) |
262 | { | 239 | { |
263 | uint8_t cdb[16]; | 240 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_ROM_REV_ID, 0, 0, buf, len); |
264 | memset(cdb, 0, sizeof(cdb)); | 241 | } |
265 | cdb[0] = SCSI_STMP_READ; | ||
266 | cdb[1] = SCSI_STMP_CMD_GET_ROM_REV_ID; | ||
267 | |||
268 | uint8_t sense[32]; | ||
269 | int sense_size = sizeof(sense); | ||
270 | 242 | ||
271 | int buf_sz = sizeof(struct scsi_stmp_rom_rev_id_t); | 243 | int stmp_get_rom_rev_id(stmp_device_t dev, uint16_t *ver) |
272 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, ver, &buf_sz); | 244 | { |
273 | if(ret < 0) | 245 | int len = sizeof(*ver); |
274 | return ret; | 246 | int ret = stmp_scsi_get_rom_rev_id(dev, ver, &len); |
275 | ret = do_sense_analysis(ret, sense, sense_size); | 247 | if(ret || len != sizeof(*ver)) |
276 | if(ret) | ||
277 | return ret; | ||
278 | if(buf_sz != sizeof(struct scsi_stmp_rom_rev_id_t)) | ||
279 | return -1; | 248 | return -1; |
280 | ver->rev = fix_endian16be(ver->rev); | 249 | *ver = fix_endian16be(*ver); |
281 | return 0; | 250 | return 0; |
282 | } | 251 | } |
283 | 252 | ||
284 | static int stmp_get_logical_media_info(uint8_t info, void *data, int *len) | 253 | int stmp_scsi_get_logical_media_info(stmp_device_t dev, uint8_t info, void *data, int *len) |
285 | { | 254 | { |
286 | uint8_t cdb[16]; | 255 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_LOGICAL_MEDIA_INFO, info, 0, data, len); |
287 | memset(cdb, 0, sizeof(cdb)); | ||
288 | cdb[0] = SCSI_STMP_READ; | ||
289 | cdb[1] = SCSI_STMP_CMD_GET_LOGICAL_MEDIA_INFO; | ||
290 | cdb[2] = info; | ||
291 | |||
292 | uint8_t sense[32]; | ||
293 | int sense_size = sizeof(sense); | ||
294 | |||
295 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, data, len); | ||
296 | if(ret < 0) | ||
297 | return ret; | ||
298 | return do_sense_analysis(ret, sense, sense_size); | ||
299 | } | 256 | } |
300 | 257 | ||
301 | static int stmp_get_logical_table(struct scsi_stmp_logical_table_t *table, int entry_count) | 258 | int stmp_scsi_get_logical_table(stmp_device_t dev, int entry_count, void *buf, int *len) |
302 | { | 259 | { |
303 | uint8_t cdb[16]; | 260 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_LOGICAL_TABLE, entry_count, 0, buf, len); |
304 | memset(cdb, 0, sizeof(cdb)); | 261 | } |
305 | cdb[0] = SCSI_STMP_READ; | ||
306 | cdb[1] = SCSI_STMP_CMD_GET_LOGICAL_TABLE; | ||
307 | cdb[2] = entry_count; | ||
308 | |||
309 | uint8_t sense[32]; | ||
310 | int sense_size = sizeof(sense); | ||
311 | 262 | ||
312 | int buf_sz = sizeof(struct scsi_stmp_logical_table_t) + | 263 | int stmp_get_logical_table(stmp_device_t dev, struct scsi_stmp_logical_table_t *table, int entry_count) |
264 | { | ||
265 | int buf_sz = sizeof(struct scsi_stmp_logical_table_t) + | ||
313 | entry_count * sizeof(struct scsi_stmp_logical_table_entry_t); | 266 | entry_count * sizeof(struct scsi_stmp_logical_table_entry_t); |
314 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, table, &buf_sz); | 267 | int ret = stmp_scsi_get_logical_table(dev, entry_count, table, &buf_sz); |
315 | if(ret < 0) | 268 | if(ret != 0) |
316 | return ret; | ||
317 | ret = do_sense_analysis(ret, sense, sense_size); | ||
318 | if(ret) | ||
319 | return ret; | 269 | return ret; |
320 | if((buf_sz - sizeof(struct scsi_stmp_logical_table_t)) % sizeof(struct scsi_stmp_logical_table_entry_t)) | 270 | if((buf_sz - sizeof(struct scsi_stmp_logical_table_t)) % sizeof(struct scsi_stmp_logical_table_entry_t)) |
321 | return -1; | 271 | return -1; |
@@ -326,59 +276,22 @@ static int stmp_get_logical_table(struct scsi_stmp_logical_table_t *table, int e | |||
326 | return 0; | 276 | return 0; |
327 | } | 277 | } |
328 | 278 | ||
329 | static int stmp_get_logical_drive_info(uint8_t drive, uint8_t info, void *data, int *len) | 279 | int stmp_scsi_get_logical_drive_info(stmp_device_t dev, uint8_t drive, uint8_t info, void *data, int *len) |
330 | { | 280 | { |
331 | uint8_t cdb[16]; | 281 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_LOGICAL_DRIVE_INFO, drive, info, data, len); |
332 | memset(cdb, 0, sizeof(cdb)); | ||
333 | cdb[0] = SCSI_STMP_READ; | ||
334 | cdb[1] = SCSI_STMP_CMD_GET_LOGICAL_DRIVE_INFO; | ||
335 | cdb[2] = drive; | ||
336 | cdb[3] = info; | ||
337 | |||
338 | uint8_t sense[32]; | ||
339 | int sense_size = sizeof(sense); | ||
340 | |||
341 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, data, len); | ||
342 | if(ret < 0) | ||
343 | return ret; | ||
344 | return do_sense_analysis(ret, sense, sense_size); | ||
345 | } | 282 | } |
346 | 283 | ||
347 | static int stmp_get_device_info(uint8_t info, void *data, int *len) | 284 | int stmp_scsi_get_device_info(stmp_device_t dev, uint8_t info, void *data, int *len) |
348 | { | 285 | { |
349 | uint8_t cdb[16]; | 286 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_DEVICE_INFO, info, 0, data, len); |
350 | memset(cdb, 0, sizeof(cdb)); | ||
351 | cdb[0] = SCSI_STMP_READ; | ||
352 | cdb[1] = SCSI_STMP_CMD_GET_DEVICE_INFO; | ||
353 | cdb[2] = info; | ||
354 | |||
355 | uint8_t sense[32]; | ||
356 | int sense_size = sizeof(sense); | ||
357 | |||
358 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, data, len); | ||
359 | if(ret < 0) | ||
360 | return ret; | ||
361 | return do_sense_analysis(ret, sense, sense_size); | ||
362 | } | 287 | } |
363 | 288 | ||
364 | static int stmp_get_serial_number(uint8_t info, void *data, int *len) | 289 | int stmp_scsi_get_serial_number(stmp_device_t dev, uint8_t info, void *data, int *len) |
365 | { | 290 | { |
366 | uint8_t cdb[16]; | 291 | return stmp_scsi_read_cmd(dev, SCSI_STMP_CMD_GET_CHIP_SERIAL_NUMBER, info, 0, data, len); |
367 | memset(cdb, 0, sizeof(cdb)); | ||
368 | cdb[0] = SCSI_STMP_READ; | ||
369 | cdb[1] = SCSI_STMP_CMD_GET_CHIP_SERIAL_NUMBER; | ||
370 | cdb[2] = info; | ||
371 | |||
372 | uint8_t sense[32]; | ||
373 | int sense_size = sizeof(sense); | ||
374 | |||
375 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, data, len); | ||
376 | if(ret < 0) | ||
377 | return ret; | ||
378 | return do_sense_analysis(ret, sense, sense_size); | ||
379 | } | 292 | } |
380 | 293 | ||
381 | static int stmp_read_logical_drive_sectors(uint8_t drive, uint64_t address, | 294 | int stmp_scsi_read_logical_drive_sectors(stmp_device_t dev, uint8_t drive, uint64_t address, |
382 | uint32_t count, void *buffer, int *buffer_size) | 295 | uint32_t count, void *buffer, int *buffer_size) |
383 | { | 296 | { |
384 | uint8_t cdb[16]; | 297 | uint8_t cdb[16]; |
@@ -394,13 +307,13 @@ static int stmp_read_logical_drive_sectors(uint8_t drive, uint64_t address, | |||
394 | uint8_t sense[32]; | 307 | uint8_t sense[32]; |
395 | int sense_size = sizeof(sense); | 308 | int sense_size = sizeof(sense); |
396 | 309 | ||
397 | int ret = do_scsi(cdb, sizeof(cdb), DO_READ, sense, &sense_size, buffer, buffer_size); | 310 | int ret = stmp_scsi(dev, cdb, sizeof(cdb), STMP_READ, sense, &sense_size, buffer, buffer_size); |
398 | if(ret < 0) | 311 | if(ret < 0) |
399 | return ret; | 312 | return ret; |
400 | return do_sense_analysis(ret, sense, sense_size); | 313 | return stmp_sense_analysis(dev, ret, sense, sense_size); |
401 | } | 314 | } |
402 | 315 | ||
403 | static int stmp_write_logical_drive_sectors(uint8_t drive, uint64_t address, | 316 | int stmp_scsi_write_logical_drive_sectors(stmp_device_t dev, uint8_t drive, uint64_t address, |
404 | uint32_t count, void *buffer, int *buffer_size) | 317 | uint32_t count, void *buffer, int *buffer_size) |
405 | { | 318 | { |
406 | uint8_t cdb[16]; | 319 | uint8_t cdb[16]; |
@@ -416,10 +329,10 @@ static int stmp_write_logical_drive_sectors(uint8_t drive, uint64_t address, | |||
416 | uint8_t sense[32]; | 329 | uint8_t sense[32]; |
417 | int sense_size = sizeof(sense); | 330 | int sense_size = sizeof(sense); |
418 | 331 | ||
419 | int ret = do_scsi(cdb, sizeof(cdb), DO_WRITE, sense, &sense_size, buffer, buffer_size); | 332 | int ret = stmp_scsi(dev, cdb, sizeof(cdb), STMP_WRITE, sense, &sense_size, buffer, buffer_size); |
420 | if(ret < 0) | 333 | if(ret < 0) |
421 | return ret; | 334 | return ret; |
422 | return do_sense_analysis(ret, sense, sense_size); | 335 | return stmp_sense_analysis(dev, ret, sense, sense_size); |
423 | } | 336 | } |
424 | 337 | ||
425 | static const char *stmp_get_logical_media_type_string(uint32_t type) | 338 | static const char *stmp_get_logical_media_type_string(uint32_t type) |
@@ -435,7 +348,7 @@ static const char *stmp_get_logical_media_type_string(uint32_t type) | |||
435 | } | 348 | } |
436 | } | 349 | } |
437 | 350 | ||
438 | static const char *stmp_get_logical_media_vendor_string(uint32_t type) | 351 | const char *stmp_get_logical_media_vendor_string(uint32_t type) |
439 | { | 352 | { |
440 | switch(type) | 353 | switch(type) |
441 | { | 354 | { |
@@ -451,7 +364,7 @@ static const char *stmp_get_logical_media_vendor_string(uint32_t type) | |||
451 | } | 364 | } |
452 | } | 365 | } |
453 | 366 | ||
454 | static const char *stmp_get_logical_drive_type_string(uint32_t type) | 367 | const char *stmp_get_logical_drive_type_string(uint32_t type) |
455 | { | 368 | { |
456 | switch(type) | 369 | switch(type) |
457 | { | 370 | { |
@@ -463,7 +376,7 @@ static const char *stmp_get_logical_drive_type_string(uint32_t type) | |||
463 | } | 376 | } |
464 | } | 377 | } |
465 | 378 | ||
466 | static const char *stmp_get_logical_drive_tag_string(uint8_t type) | 379 | const char *stmp_get_logical_drive_tag_string(uint32_t type) |
467 | { | 380 | { |
468 | switch(type) | 381 | switch(type) |
469 | { | 382 | { |
@@ -482,7 +395,7 @@ static const char *stmp_get_logical_drive_tag_string(uint8_t type) | |||
482 | } | 395 | } |
483 | } | 396 | } |
484 | 397 | ||
485 | static const char *stmp_get_logical_media_state_string(uint8_t state) | 398 | const char *stmp_get_logical_media_state_string(uint8_t state) |
486 | { | 399 | { |
487 | switch(state) | 400 | switch(state) |
488 | { | 401 | { |
@@ -520,22 +433,16 @@ static int do_info(void) | |||
520 | uint8_t dev_type; | 433 | uint8_t dev_type; |
521 | char vendor[9]; | 434 | char vendor[9]; |
522 | char product[17]; | 435 | char product[17]; |
523 | int ret = stmp_inquiry(&dev_type, vendor, product); | 436 | int ret = stmp_scsi_inquiry(g_dev_fd, &dev_type, vendor, product); |
524 | if(ret) | 437 | if(ret == 0) |
525 | { | ||
526 | cprintf(GREY, "Cannot get inquiry data: %d\n", ret); | ||
527 | } | ||
528 | else | ||
529 | { | 438 | { |
530 | cprintf_field(" Vendor: ", "%s\n", vendor); | 439 | cprintf_field(" Vendor: ", "%s\n", vendor); |
531 | cprintf_field(" Product: ", "%s\n", product); | 440 | cprintf_field(" Product: ", "%s\n", product); |
532 | } | 441 | } |
533 | 442 | ||
534 | struct scsi_stmp_protocol_version_t ver; | 443 | struct scsi_stmp_protocol_version_t ver; |
535 | ret = stmp_get_protocol_version(&ver); | 444 | ret = stmp_get_protocol_version(g_dev_fd, &ver); |
536 | if(ret) | 445 | if(ret == 0) |
537 | cprintf(GREY, "Cannot get protocol version: %d\n", ret); | ||
538 | else | ||
539 | cprintf_field(" Protocol: ", "%x.%x\n", ver.major, ver.minor); | 446 | cprintf_field(" Protocol: ", "%x.%x\n", ver.major, ver.minor); |
540 | 447 | ||
541 | do | 448 | do |
@@ -551,7 +458,7 @@ static int do_info(void) | |||
551 | 458 | ||
552 | cprintf(GREEN, " Device\n"); | 459 | cprintf(GREEN, " Device\n"); |
553 | int len = 4; | 460 | int len = 4; |
554 | ret = stmp_get_device_info(0, &u.u32, &len); | 461 | ret = stmp_scsi_get_device_info(g_dev_fd, 0, &u.u32, &len); |
555 | if(!ret && len == 4) | 462 | if(!ret && len == 4) |
556 | { | 463 | { |
557 | u.u32 = fix_endian32be(u.u32); | 464 | u.u32 = fix_endian32be(u.u32); |
@@ -559,7 +466,7 @@ static int do_info(void) | |||
559 | } | 466 | } |
560 | 467 | ||
561 | len = 4; | 468 | len = 4; |
562 | ret = stmp_get_device_info(1, &u.u32, &len); | 469 | ret = stmp_scsi_get_device_info(g_dev_fd, 1, &u.u32, &len); |
563 | if(!ret && len == 4) | 470 | if(!ret && len == 4) |
564 | { | 471 | { |
565 | u.u32 = fix_endian32be(u.u32); | 472 | u.u32 = fix_endian32be(u.u32); |
@@ -567,19 +474,19 @@ static int do_info(void) | |||
567 | } | 474 | } |
568 | 475 | ||
569 | len = 2; | 476 | len = 2; |
570 | ret = stmp_get_serial_number(0, &u.u16, &len); | 477 | ret = stmp_scsi_get_serial_number(g_dev_fd, 0, &u.u16, &len); |
571 | if(!ret && len == 2) | 478 | if(!ret && len == 2) |
572 | { | 479 | { |
573 | u.u16 = fix_endian16be(u.u16); | 480 | u.u16 = fix_endian16be(u.u16); |
574 | len = MIN(u.u16, sizeof(u.buf)); | 481 | len = MIN(u.u16, sizeof(u.buf)); |
575 | ret = stmp_get_serial_number(1, u.buf, &len); | 482 | ret = stmp_scsi_get_serial_number(g_dev_fd, 1, u.buf, &len); |
576 | cprintf_field(" Serial Number:", " "); | 483 | cprintf_field(" Serial Number:", " "); |
577 | print_hex(u.buf, len); | 484 | print_hex(u.buf, len); |
578 | cprintf(OFF, "\n"); | 485 | cprintf(OFF, "\n"); |
579 | } | 486 | } |
580 | 487 | ||
581 | len = 2; | 488 | len = 2; |
582 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_NR_DRIVES, &u.u16, &len); | 489 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_NR_DRIVES, &u.u16, &len); |
583 | if(!ret && len == 2) | 490 | if(!ret && len == 2) |
584 | { | 491 | { |
585 | u.u16 = fix_endian16be(u.u16); | 492 | u.u16 = fix_endian16be(u.u16); |
@@ -587,7 +494,7 @@ static int do_info(void) | |||
587 | } | 494 | } |
588 | 495 | ||
589 | len = 4; | 496 | len = 4; |
590 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_TYPE, &u.u32, &len); | 497 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_TYPE, &u.u32, &len); |
591 | if(!ret && len == 4) | 498 | if(!ret && len == 4) |
592 | { | 499 | { |
593 | u.u32 = fix_endian32be(u.u32); | 500 | u.u32 = fix_endian32be(u.u32); |
@@ -596,22 +503,22 @@ static int do_info(void) | |||
596 | } | 503 | } |
597 | 504 | ||
598 | len = 1; | 505 | len = 1; |
599 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_IS_INITIALISED, &u.u8, &len); | 506 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_IS_INITIALISED, &u.u8, &len); |
600 | if(!ret && len == 1) | 507 | if(!ret && len == 1) |
601 | cprintf_field(" Is Initialised: ", "%d\n", u.u8); | 508 | cprintf_field(" Is Initialised: ", "%d\n", u.u8); |
602 | 509 | ||
603 | len = 1; | 510 | len = 1; |
604 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_STATE, &u.u8, &len); | 511 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_STATE, &u.u8, &len); |
605 | if(!ret && len == 1) | 512 | if(!ret && len == 1) |
606 | cprintf_field(" State: ", "%s\n", stmp_get_logical_media_state_string(u.u8)); | 513 | cprintf_field(" State: ", "%s\n", stmp_get_logical_media_state_string(u.u8)); |
607 | 514 | ||
608 | len = 1; | 515 | len = 1; |
609 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_IS_WRITE_PROTECTED, &u.u8, &len); | 516 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_IS_WRITE_PROTECTED, &u.u8, &len); |
610 | if(!ret && len == 1) | 517 | if(!ret && len == 1) |
611 | cprintf_field(" Is Write Protected: ", "%#x\n", u.u8); | 518 | cprintf_field(" Is Write Protected: ", "%#x\n", u.u8); |
612 | 519 | ||
613 | len = 8; | 520 | len = 8; |
614 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_SIZE, &u.u64, &len); | 521 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_SIZE, &u.u64, &len); |
615 | if(!ret && len == 8) | 522 | if(!ret && len == 8) |
616 | { | 523 | { |
617 | u.u64 = fix_endian64be(u.u64); | 524 | u.u64 = fix_endian64be(u.u64); |
@@ -621,7 +528,7 @@ static int do_info(void) | |||
621 | 528 | ||
622 | int serial_number_size = 0; | 529 | int serial_number_size = 0; |
623 | len = 4; | 530 | len = 4; |
624 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_SERIAL_NUMBER_SIZE, &u.u32, &len); | 531 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_SERIAL_NUMBER_SIZE, &u.u32, &len); |
625 | if(!ret && len == 4) | 532 | if(!ret && len == 4) |
626 | { | 533 | { |
627 | u.u32 = fix_endian32be(u.u32); | 534 | u.u32 = fix_endian32be(u.u32); |
@@ -630,7 +537,7 @@ static int do_info(void) | |||
630 | } | 537 | } |
631 | 538 | ||
632 | len = serial_number_size; | 539 | len = serial_number_size; |
633 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_SERIAL_NUMBER, &u.buf, &len); | 540 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_SERIAL_NUMBER, &u.buf, &len); |
634 | if(!ret && len != 0) | 541 | if(!ret && len != 0) |
635 | { | 542 | { |
636 | cprintf(GREEN, " Serial Number:"); | 543 | cprintf(GREEN, " Serial Number:"); |
@@ -638,17 +545,17 @@ static int do_info(void) | |||
638 | } | 545 | } |
639 | 546 | ||
640 | len = 1; | 547 | len = 1; |
641 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_IS_SYSTEM_MEDIA, &u.u8, &len); | 548 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_IS_SYSTEM_MEDIA, &u.u8, &len); |
642 | if(!ret && len == 1) | 549 | if(!ret && len == 1) |
643 | cprintf_field(" Is System Media: ", "%d\n", u.u8); | 550 | cprintf_field(" Is System Media: ", "%d\n", u.u8); |
644 | 551 | ||
645 | len = 1; | 552 | len = 1; |
646 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_IS_MEDIA_PRESENT, &u.u8, &len); | 553 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_IS_MEDIA_PRESENT, &u.u8, &len); |
647 | if(!ret && len == 1) | 554 | if(!ret && len == 1) |
648 | cprintf_field(" Is Media Present: ", "%d\n", u.u8); | 555 | cprintf_field(" Is Media Present: ", "%d\n", u.u8); |
649 | 556 | ||
650 | len = 4; | 557 | len = 4; |
651 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_VENDOR, &u.u32, &len); | 558 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_VENDOR, &u.u32, &len); |
652 | if(!ret && len == 4) | 559 | if(!ret && len == 4) |
653 | { | 560 | { |
654 | u.u32 = fix_endian32be(u.u32); | 561 | u.u32 = fix_endian32be(u.u32); |
@@ -657,7 +564,7 @@ static int do_info(void) | |||
657 | } | 564 | } |
658 | 565 | ||
659 | len = 8; | 566 | len = 8; |
660 | ret = stmp_get_logical_media_info(13, &u.u64, &len); | 567 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, 13, &u.u64, &len); |
661 | if(!ret && len == 8) | 568 | if(!ret && len == 8) |
662 | { | 569 | { |
663 | u.u64 = fix_endian64be(u.u64); | 570 | u.u64 = fix_endian64be(u.u64); |
@@ -665,7 +572,7 @@ static int do_info(void) | |||
665 | } | 572 | } |
666 | 573 | ||
667 | len = 4; | 574 | len = 4; |
668 | ret = stmp_get_logical_media_info(11, &u.u32, &len); | 575 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, 11, &u.u32, &len); |
669 | if(!ret && len == 4) | 576 | if(!ret && len == 4) |
670 | { | 577 | { |
671 | u.u32 = fix_endian32be(u.u32); | 578 | u.u32 = fix_endian32be(u.u32); |
@@ -673,7 +580,7 @@ static int do_info(void) | |||
673 | } | 580 | } |
674 | 581 | ||
675 | len = 4; | 582 | len = 4; |
676 | ret = stmp_get_logical_media_info(14, &u.u32, &len); | 583 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, 14, &u.u32, &len); |
677 | if(!ret && len == 4) | 584 | if(!ret && len == 4) |
678 | { | 585 | { |
679 | u.u32 = fix_endian32be(u.u32); | 586 | u.u32 = fix_endian32be(u.u32); |
@@ -681,27 +588,27 @@ static int do_info(void) | |||
681 | } | 588 | } |
682 | 589 | ||
683 | len = 4; | 590 | len = 4; |
684 | ret = stmp_get_logical_media_info(SCSI_STMP_MEDIA_INFO_ALLOC_UNIT_SIZE, &u.u32, &len); | 591 | ret = stmp_scsi_get_logical_media_info(g_dev_fd, SCSI_STMP_MEDIA_INFO_ALLOC_UNIT_SIZE, &u.u32, &len); |
685 | if(!ret && len == 4) | 592 | if(!ret && len == 4) |
686 | { | 593 | { |
687 | u.u32 = fix_endian32be(u.u32); | 594 | u.u32 = fix_endian32be(u.u32); |
688 | cprintf_field(" Allocation Unit Size: ", "%d B\n", u.u32); | 595 | cprintf_field(" Allocation Unit Size: ", "%d B\n", u.u32); |
689 | } | 596 | } |
690 | }while(0); | 597 | }while(0); |
691 | 598 | ||
692 | struct scsi_stmp_chip_major_rev_id_t chip_rev; | 599 | uint16_t chip_rev; |
693 | ret = stmp_get_chip_major_rev_id(&chip_rev); | 600 | ret = stmp_get_chip_major_rev_id(g_dev_fd, &chip_rev); |
694 | if(ret) | 601 | if(ret) |
695 | cprintf(GREY, "Cannot get chip major revision id: %d\n", ret); | 602 | cprintf(GREY, "Cannot get chip major revision id: %d\n", ret); |
696 | else | 603 | else |
697 | cprintf_field(" Chip Major Rev ID: ", "%x\n", chip_rev.rev); | 604 | cprintf_field(" Chip Major Rev ID: ", "%x\n", chip_rev); |
698 | 605 | ||
699 | struct scsi_stmp_rom_rev_id_t rom_rev; | 606 | uint16_t rom_rev; |
700 | ret = stmp_get_rom_rev_id(&rom_rev); | 607 | ret = stmp_get_rom_rev_id(g_dev_fd, &rom_rev); |
701 | if(ret) | 608 | if(ret) |
702 | cprintf(GREY, "Cannot get rom revision id: %d\n", ret); | 609 | cprintf(GREY, "Cannot get rom revision id: %d\n", ret); |
703 | else | 610 | else |
704 | cprintf_field(" ROM Rev ID: ", "%x\n", rom_rev.rev); | 611 | cprintf_field(" ROM Rev ID: ", "%x\n", rom_rev); |
705 | 612 | ||
706 | struct | 613 | struct |
707 | { | 614 | { |
@@ -709,7 +616,7 @@ static int do_info(void) | |||
709 | struct scsi_stmp_logical_table_entry_t entry[20]; | 616 | struct scsi_stmp_logical_table_entry_t entry[20]; |
710 | }__attribute__((packed)) table; | 617 | }__attribute__((packed)) table; |
711 | 618 | ||
712 | ret = stmp_get_logical_table(&table.header, sizeof(table.entry) / sizeof(table.entry[0])); | 619 | ret = stmp_get_logical_table(g_dev_fd, &table.header, sizeof(table.entry) / sizeof(table.entry[0])); |
713 | if(ret) | 620 | if(ret) |
714 | cprintf(GREY, "Cannot get logical table: %d\n", ret); | 621 | cprintf(GREY, "Cannot get logical table: %d\n", ret); |
715 | else | 622 | else |
@@ -747,9 +654,9 @@ static int do_info(void) | |||
747 | }u; | 654 | }u; |
748 | uint8_t drive = table.entry[i].drive_no; | 655 | uint8_t drive = table.entry[i].drive_no; |
749 | cprintf_field(" Drive ", "%02x\n", drive); | 656 | cprintf_field(" Drive ", "%02x\n", drive); |
750 | 657 | ||
751 | int len = 4; | 658 | int len = 4; |
752 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SECTOR_SIZE, &u.u32, &len); | 659 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SECTOR_SIZE, &u.u32, &len); |
753 | if(!ret && len == 4) | 660 | if(!ret && len == 4) |
754 | { | 661 | { |
755 | u.u32 = fix_endian32be(u.u32); | 662 | u.u32 = fix_endian32be(u.u32); |
@@ -758,7 +665,7 @@ static int do_info(void) | |||
758 | } | 665 | } |
759 | 666 | ||
760 | len = 4; | 667 | len = 4; |
761 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVe_INFO_ERASE_SIZE, &u.u32, &len); | 668 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVe_INFO_ERASE_SIZE, &u.u32, &len); |
762 | if(!ret && len == 4) | 669 | if(!ret && len == 4) |
763 | { | 670 | { |
764 | u.u32 = fix_endian32be(u.u32); | 671 | u.u32 = fix_endian32be(u.u32); |
@@ -767,7 +674,7 @@ static int do_info(void) | |||
767 | } | 674 | } |
768 | 675 | ||
769 | len = 8; | 676 | len = 8; |
770 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SIZE, &u.u64, &len); | 677 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SIZE, &u.u64, &len); |
771 | if(!ret && len == 8) | 678 | if(!ret && len == 8) |
772 | { | 679 | { |
773 | u.u64 = fix_endian64be(u.u64); | 680 | u.u64 = fix_endian64be(u.u64); |
@@ -777,7 +684,7 @@ static int do_info(void) | |||
777 | } | 684 | } |
778 | 685 | ||
779 | len = 4; | 686 | len = 4; |
780 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SIZE_MEGA, &u.u32, &len); | 687 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SIZE_MEGA, &u.u32, &len); |
781 | if(!ret && len == 4) | 688 | if(!ret && len == 4) |
782 | { | 689 | { |
783 | u.u32 = fix_endian32be(u.u32); | 690 | u.u32 = fix_endian32be(u.u32); |
@@ -785,7 +692,7 @@ static int do_info(void) | |||
785 | } | 692 | } |
786 | 693 | ||
787 | len = 8; | 694 | len = 8; |
788 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SECTOR_COUNT, &u.u64, &len); | 695 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SECTOR_COUNT, &u.u64, &len); |
789 | if(!ret && len == 8) | 696 | if(!ret && len == 8) |
790 | { | 697 | { |
791 | u.u64 = fix_endian64be(u.u64); | 698 | u.u64 = fix_endian64be(u.u64); |
@@ -793,7 +700,7 @@ static int do_info(void) | |||
793 | } | 700 | } |
794 | 701 | ||
795 | len = 4; | 702 | len = 4; |
796 | ret = stmp_get_logical_drive_info(drive,SCSI_STMP_DRIVE_INFO_TYPE, &u.u32, &len); | 703 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive,SCSI_STMP_DRIVE_INFO_TYPE, &u.u32, &len); |
797 | if(!ret && len == 4) | 704 | if(!ret && len == 4) |
798 | { | 705 | { |
799 | u.u32 = fix_endian32be(u.u32); | 706 | u.u32 = fix_endian32be(u.u32); |
@@ -802,7 +709,7 @@ static int do_info(void) | |||
802 | } | 709 | } |
803 | 710 | ||
804 | len = 1; | 711 | len = 1; |
805 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_TAG, &u.u8, &len); | 712 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_TAG, &u.u8, &len); |
806 | if(!ret && len == 1) | 713 | if(!ret && len == 1) |
807 | { | 714 | { |
808 | cprintf_field(" Tag: ", "%#x", u.u8); | 715 | cprintf_field(" Tag: ", "%#x", u.u8); |
@@ -810,7 +717,7 @@ static int do_info(void) | |||
810 | } | 717 | } |
811 | 718 | ||
812 | len = 52; | 719 | len = 52; |
813 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_COMPONENT_VERSION, &u.buf, &len); | 720 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_COMPONENT_VERSION, &u.buf, &len); |
814 | if(!ret && len != 0) | 721 | if(!ret && len != 0) |
815 | { | 722 | { |
816 | cprintf(GREEN, " Component Version:"); | 723 | cprintf(GREEN, " Component Version:"); |
@@ -818,7 +725,7 @@ static int do_info(void) | |||
818 | } | 725 | } |
819 | 726 | ||
820 | len = 52; | 727 | len = 52; |
821 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_PROJECT_VERSION, &u.buf, &len); | 728 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_PROJECT_VERSION, &u.buf, &len); |
822 | if(!ret && len != 0) | 729 | if(!ret && len != 0) |
823 | { | 730 | { |
824 | cprintf(GREEN, " Project Version:"); | 731 | cprintf(GREEN, " Project Version:"); |
@@ -826,7 +733,7 @@ static int do_info(void) | |||
826 | } | 733 | } |
827 | 734 | ||
828 | len = 1; | 735 | len = 1; |
829 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_IS_WRITE_PROTETED, &u.u8, &len); | 736 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_IS_WRITE_PROTETED, &u.u8, &len); |
830 | if(!ret && len == 1) | 737 | if(!ret && len == 1) |
831 | { | 738 | { |
832 | cprintf_field(" Is Writed Protected: ", "%d\n", u.u8); | 739 | cprintf_field(" Is Writed Protected: ", "%d\n", u.u8); |
@@ -834,7 +741,7 @@ static int do_info(void) | |||
834 | 741 | ||
835 | len = 2; | 742 | len = 2; |
836 | int serial_number_size = 0; | 743 | int serial_number_size = 0; |
837 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SERIAL_NUMBER_SIZE, &u.u16, &len); | 744 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SERIAL_NUMBER_SIZE, &u.u16, &len); |
838 | if(!ret && len == 2) | 745 | if(!ret && len == 2) |
839 | { | 746 | { |
840 | u.u16 = fix_endian16be(u.u16); | 747 | u.u16 = fix_endian16be(u.u16); |
@@ -843,7 +750,7 @@ static int do_info(void) | |||
843 | } | 750 | } |
844 | 751 | ||
845 | len = serial_number_size; | 752 | len = serial_number_size; |
846 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SERIAL_NUMBER, &u.buf, &len); | 753 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SERIAL_NUMBER, &u.buf, &len); |
847 | if(!ret && len != 0) | 754 | if(!ret && len != 0) |
848 | { | 755 | { |
849 | cprintf(GREEN, " Serial Number:"); | 756 | cprintf(GREEN, " Serial Number:"); |
@@ -851,21 +758,21 @@ static int do_info(void) | |||
851 | } | 758 | } |
852 | 759 | ||
853 | len = 1; | 760 | len = 1; |
854 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_MEDIA_PRESENT, &u.u8, &len); | 761 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_MEDIA_PRESENT, &u.u8, &len); |
855 | if(!ret && len == 1) | 762 | if(!ret && len == 1) |
856 | { | 763 | { |
857 | cprintf_field(" Is Media Present: ", "%d\n", u.u8); | 764 | cprintf_field(" Is Media Present: ", "%d\n", u.u8); |
858 | } | 765 | } |
859 | 766 | ||
860 | len = 1; | 767 | len = 1; |
861 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_MEDIA_CHANGE, &u.u8, &len); | 768 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_MEDIA_CHANGE, &u.u8, &len); |
862 | if(!ret && len == 1) | 769 | if(!ret && len == 1) |
863 | { | 770 | { |
864 | cprintf_field(" Media Change: ", "%d\n", u.u8); | 771 | cprintf_field(" Media Change: ", "%d\n", u.u8); |
865 | } | 772 | } |
866 | 773 | ||
867 | len = 4; | 774 | len = 4; |
868 | ret = stmp_get_logical_drive_info(drive, SCSI_STMP_DRIVE_INFO_SECTOR_ALLOCATION, &u.u32, &len); | 775 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive, SCSI_STMP_DRIVE_INFO_SECTOR_ALLOCATION, &u.u32, &len); |
869 | if(!ret && len == 4) | 776 | if(!ret && len == 4) |
870 | { | 777 | { |
871 | u.u32 = fix_endian32be(u.u32); | 778 | u.u32 = fix_endian32be(u.u32); |
@@ -888,7 +795,7 @@ void do_extract(const char *file) | |||
888 | struct scsi_stmp_logical_table_entry_t entry[20]; | 795 | struct scsi_stmp_logical_table_entry_t entry[20]; |
889 | }__attribute__((packed)) table; | 796 | }__attribute__((packed)) table; |
890 | 797 | ||
891 | int ret = stmp_get_logical_table(&table.header, sizeof(table.entry) / sizeof(table.entry[0])); | 798 | int ret = stmp_get_logical_table(g_dev_fd, &table.header, sizeof(table.entry) / sizeof(table.entry[0])); |
892 | if(ret) | 799 | if(ret) |
893 | { | 800 | { |
894 | cprintf(GREY, "Cannot get logical table: %d\n", ret); | 801 | cprintf(GREY, "Cannot get logical table: %d\n", ret); |
@@ -917,7 +824,7 @@ void do_extract(const char *file) | |||
917 | } | 824 | } |
918 | int len = 4; | 825 | int len = 4; |
919 | uint32_t sector_size; | 826 | uint32_t sector_size; |
920 | ret = stmp_get_logical_drive_info(drive_no, SCSI_STMP_DRIVE_INFO_SECTOR_SIZE, §or_size, &len); | 827 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive_no, SCSI_STMP_DRIVE_INFO_SECTOR_SIZE, §or_size, &len); |
921 | if(ret || len != 4) | 828 | if(ret || len != 4) |
922 | { | 829 | { |
923 | cprintf(GREY, "Cannot get sector size\n"); | 830 | cprintf(GREY, "Cannot get sector size\n"); |
@@ -931,7 +838,7 @@ void do_extract(const char *file) | |||
931 | } | 838 | } |
932 | uint8_t *sector = malloc(sector_size); | 839 | uint8_t *sector = malloc(sector_size); |
933 | len = sector_size; | 840 | len = sector_size; |
934 | ret = stmp_read_logical_drive_sectors(drive_no, 0, 1, sector, &len); | 841 | ret = stmp_scsi_read_logical_drive_sectors(g_dev_fd, drive_no, 0, 1, sector, &len); |
935 | if(ret || len != (int)sector_size) | 842 | if(ret || len != (int)sector_size) |
936 | { | 843 | { |
937 | cprintf(GREY, "Cannot read first sector\n"); | 844 | cprintf(GREY, "Cannot read first sector\n"); |
@@ -953,7 +860,7 @@ void do_extract(const char *file) | |||
953 | 860 | ||
954 | for(int sec = 0; sec * sector_size < fw_size; sec++) | 861 | for(int sec = 0; sec * sector_size < fw_size; sec++) |
955 | { | 862 | { |
956 | ret = stmp_read_logical_drive_sectors(drive_no, sec, 1, sector, &len); | 863 | ret = stmp_scsi_read_logical_drive_sectors(g_dev_fd, drive_no, sec, 1, sector, &len); |
957 | if(ret || len != (int)sector_size) | 864 | if(ret || len != (int)sector_size) |
958 | { | 865 | { |
959 | cprintf(GREY, "Cannot read sector %d\n", sec); | 866 | cprintf(GREY, "Cannot read sector %d\n", sec); |
@@ -989,7 +896,8 @@ void do_write(const char *file, int want_a_brick) | |||
989 | struct scsi_stmp_logical_table_entry_t entry[20]; | 896 | struct scsi_stmp_logical_table_entry_t entry[20]; |
990 | }__attribute__((packed)) table; | 897 | }__attribute__((packed)) table; |
991 | 898 | ||
992 | int ret = stmp_get_logical_table(&table.header, sizeof(table.entry) / sizeof(table.entry[0])); | 899 | int len = sizeof(table); |
900 | int ret = stmp_scsi_get_logical_table(g_dev_fd, sizeof(table.entry) / sizeof(table.entry[0]), &table.header, &len); | ||
993 | if(ret) | 901 | if(ret) |
994 | { | 902 | { |
995 | cprintf(GREY, "Cannot get logical table: %d\n", ret); | 903 | cprintf(GREY, "Cannot get logical table: %d\n", ret); |
@@ -1016,9 +924,9 @@ void do_write(const char *file, int want_a_brick) | |||
1016 | cprintf(RED, "* "); | 924 | cprintf(RED, "* "); |
1017 | cprintf_field("Size: ", "%#llx\n", (unsigned long long)drive_sz); | 925 | cprintf_field("Size: ", "%#llx\n", (unsigned long long)drive_sz); |
1018 | } | 926 | } |
1019 | int len = 4; | 927 | len = 4; |
1020 | uint32_t sector_size; | 928 | uint32_t sector_size; |
1021 | ret = stmp_get_logical_drive_info(drive_no, SCSI_STMP_DRIVE_INFO_SECTOR_SIZE, §or_size, &len); | 929 | ret = stmp_scsi_get_logical_drive_info(g_dev_fd, drive_no, SCSI_STMP_DRIVE_INFO_SECTOR_SIZE, §or_size, &len); |
1022 | if(ret || len != 4) | 930 | if(ret || len != 4) |
1023 | { | 931 | { |
1024 | cprintf(GREY, "Cannot get sector size\n"); | 932 | cprintf(GREY, "Cannot get sector size\n"); |
@@ -1034,7 +942,7 @@ void do_write(const char *file, int want_a_brick) | |||
1034 | 942 | ||
1035 | /* sanity check by reading first sector */ | 943 | /* sanity check by reading first sector */ |
1036 | len = sector_size; | 944 | len = sector_size; |
1037 | ret = stmp_read_logical_drive_sectors(drive_no, 0, 1, sector, &len); | 945 | ret = stmp_scsi_read_logical_drive_sectors(g_dev_fd, drive_no, 0, 1, sector, &len); |
1038 | if(ret || len != (int)sector_size) | 946 | if(ret || len != (int)sector_size) |
1039 | { | 947 | { |
1040 | cprintf(GREY, "Cannot read first sector\n"); | 948 | cprintf(GREY, "Cannot read first sector\n"); |
@@ -1091,7 +999,7 @@ void do_write(const char *file, int want_a_brick) | |||
1091 | if(xfer_len < (int)sector_size) | 999 | if(xfer_len < (int)sector_size) |
1092 | memset(sector + xfer_len, 0, sector_size - xfer_len); | 1000 | memset(sector + xfer_len, 0, sector_size - xfer_len); |
1093 | len = sector_size; | 1001 | len = sector_size; |
1094 | ret = stmp_write_logical_drive_sectors(drive_no, sec, 1, sector, &len); | 1002 | ret = stmp_scsi_write_logical_drive_sectors(g_dev_fd, drive_no, sec, 1, sector, &len); |
1095 | if(ret || len != (int)sector_size) | 1003 | if(ret || len != (int)sector_size) |
1096 | { | 1004 | { |
1097 | cprintf(GREY, "Cannot write sector %d\n", sec); | 1005 | cprintf(GREY, "Cannot write sector %d\n", sec); |
@@ -1121,6 +1029,18 @@ static void usage(void) | |||
1121 | 1029 | ||
1122 | static int g_yes_i_want_a_brick = 0; | 1030 | static int g_yes_i_want_a_brick = 0; |
1123 | 1031 | ||
1032 | static void scsi_printf(void *user, const char *fmt, ...) | ||
1033 | { | ||
1034 | (void)user; | ||
1035 | if(!g_debug) | ||
1036 | return; | ||
1037 | va_list args; | ||
1038 | va_start(args, fmt); | ||
1039 | color(GREY); | ||
1040 | vprintf(fmt, args); | ||
1041 | va_end(args); | ||
1042 | } | ||
1043 | |||
1124 | int main(int argc, char **argv) | 1044 | int main(int argc, char **argv) |
1125 | { | 1045 | { |
1126 | if(argc == 1) | 1046 | if(argc == 1) |
@@ -1185,13 +1105,20 @@ int main(int argc, char **argv) | |||
1185 | } | 1105 | } |
1186 | 1106 | ||
1187 | int ret = 0; | 1107 | int ret = 0; |
1188 | g_dev_fd = scsi_pt_open_device(argv[optind], false, true); | 1108 | rb_scsi_device_t scsi_dev = rb_scsi_open(argv[optind], g_debug ? RB_SCSI_DEBUG : 0, NULL, scsi_printf); |
1189 | if(g_dev_fd < 0) | 1109 | if(scsi_dev == 0) |
1190 | { | 1110 | { |
1191 | cprintf(GREY, "Cannot open device: %m\n"); | 1111 | cprintf(GREY, "Cannot open device: %m\n"); |
1192 | ret = 1; | 1112 | ret = 1; |
1193 | goto Lend; | 1113 | goto Lend; |
1194 | } | 1114 | } |
1115 | g_dev_fd = stmp_open(scsi_dev, g_debug ? STMP_DEBUG : 0, NULL, scsi_printf); | ||
1116 | if(g_dev_fd == 0) | ||
1117 | { | ||
1118 | cprintf(GREY, "Cannot open stmp device: %m\n"); | ||
1119 | ret = 2; | ||
1120 | goto Lend; | ||
1121 | } | ||
1195 | 1122 | ||
1196 | if(extract_fw) | 1123 | if(extract_fw) |
1197 | do_extract(extract_fw); | 1124 | do_extract(extract_fw); |
@@ -1200,10 +1127,10 @@ int main(int argc, char **argv) | |||
1200 | if(write_fw) | 1127 | if(write_fw) |
1201 | do_write(write_fw, g_yes_i_want_a_brick); | 1128 | do_write(write_fw, g_yes_i_want_a_brick); |
1202 | 1129 | ||
1203 | scsi_pt_close_device(g_dev_fd); | 1130 | stmp_close(g_dev_fd); |
1131 | rb_scsi_close(scsi_dev); | ||
1204 | Lend: | 1132 | Lend: |
1205 | color(OFF); | 1133 | color(OFF); |
1206 | 1134 | ||
1207 | return ret; | 1135 | return ret; |
1208 | } | 1136 | } |
1209 | |||