]>
Commit | Line | Data |
---|---|---|
e887afc9 WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Denis Peter, MPL AG Switzerland | |
4 | * | |
1a459660 | 5 | * SPDX-License-Identifier: GPL-2.0+ |
e887afc9 WD |
6 | */ |
7 | ||
8 | /* | |
9 | * SCSI support. | |
10 | */ | |
e887afc9 WD |
11 | #include <common.h> |
12 | #include <command.h> | |
f3609473 | 13 | #include <inttypes.h> |
e887afc9 WD |
14 | #include <asm/processor.h> |
15 | #include <scsi.h> | |
16 | #include <image.h> | |
e887afc9 WD |
17 | #include <pci.h> |
18 | ||
4ae5eb7c VB |
19 | #ifdef CONFIG_SCSI_DEV_LIST |
20 | #define SCSI_DEV_LIST CONFIG_SCSI_DEV_LIST | |
21 | #else | |
e887afc9 WD |
22 | #ifdef CONFIG_SCSI_SYM53C8XX |
23 | #define SCSI_VEND_ID 0x1000 | |
24 | #ifndef CONFIG_SCSI_DEV_ID | |
25 | #define SCSI_DEV_ID 0x0001 | |
26 | #else | |
27 | #define SCSI_DEV_ID CONFIG_SCSI_DEV_ID | |
28 | #endif | |
4782ac80 JZ |
29 | #elif defined CONFIG_SATA_ULI5288 |
30 | ||
31 | #define SCSI_VEND_ID 0x10b9 | |
32 | #define SCSI_DEV_ID 0x5288 | |
33 | ||
942e3143 | 34 | #elif !defined(CONFIG_SCSI_AHCI_PLAT) |
4782ac80 | 35 | #error no scsi device defined |
e887afc9 | 36 | #endif |
4ae5eb7c VB |
37 | #define SCSI_DEV_LIST {SCSI_VEND_ID, SCSI_DEV_ID} |
38 | #endif | |
e887afc9 | 39 | |
1a1cf6ee | 40 | #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) |
4ae5eb7c VB |
41 | const struct pci_device_id scsi_device_list[] = { SCSI_DEV_LIST }; |
42 | #endif | |
e887afc9 WD |
43 | static ccb tempccb; /* temporary scsi command buffer */ |
44 | ||
45 | static unsigned char tempbuff[512]; /* temporary data buffer */ | |
46 | ||
47 | static int scsi_max_devs; /* number of highest available scsi device */ | |
48 | ||
49 | static int scsi_curr_dev; /* current device */ | |
50 | ||
4101f687 | 51 | static struct blk_desc scsi_dev_desc[CONFIG_SYS_SCSI_MAX_DEVICE]; |
e887afc9 WD |
52 | |
53 | /******************************************************************************** | |
54 | * forward declerations of some Setup Routines | |
55 | */ | |
56 | void scsi_setup_test_unit_ready(ccb * pccb); | |
35df8931 ML |
57 | void scsi_setup_read6(ccb * pccb, lbaint_t start, unsigned short blocks); |
58 | void scsi_setup_read_ext(ccb * pccb, lbaint_t start, unsigned short blocks); | |
2b42c931 ML |
59 | void scsi_setup_read16(ccb * pccb, lbaint_t start, unsigned long blocks); |
60 | ||
35df8931 ML |
61 | static void scsi_setup_write_ext(ccb *pccb, lbaint_t start, |
62 | unsigned short blocks); | |
e887afc9 WD |
63 | void scsi_setup_inquiry(ccb * pccb); |
64 | void scsi_ident_cpy (unsigned char *dest, unsigned char *src, unsigned int len); | |
65 | ||
66 | ||
b4c5bbce GB |
67 | static int scsi_read_capacity(ccb *pccb, lbaint_t *capacity, |
68 | unsigned long *blksz); | |
4101f687 | 69 | static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr, |
7c4213f6 | 70 | lbaint_t blkcnt, void *buffer); |
4101f687 | 71 | static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr, |
758c9e69 | 72 | lbaint_t blkcnt, const void *buffer); |
e887afc9 WD |
73 | |
74 | ||
75 | /********************************************************************************* | |
76 | * (re)-scan the scsi bus and reports scsi device info | |
77 | * to the user if mode = 1 | |
78 | */ | |
79 | void scsi_scan(int mode) | |
80 | { | |
81 | unsigned char i,perq,modi,lun; | |
b4c5bbce GB |
82 | lbaint_t capacity; |
83 | unsigned long blksz; | |
e887afc9 WD |
84 | ccb* pccb=(ccb *)&tempccb; |
85 | ||
86 | if(mode==1) { | |
87 | printf("scanning bus for devices...\n"); | |
88 | } | |
6d0f6bcf | 89 | for(i=0;i<CONFIG_SYS_SCSI_MAX_DEVICE;i++) { |
e887afc9 WD |
90 | scsi_dev_desc[i].target=0xff; |
91 | scsi_dev_desc[i].lun=0xff; | |
92 | scsi_dev_desc[i].lba=0; | |
93 | scsi_dev_desc[i].blksz=0; | |
0472fbfd EE |
94 | scsi_dev_desc[i].log2blksz = |
95 | LOG2_INVALID(typeof(scsi_dev_desc[i].log2blksz)); | |
e887afc9 WD |
96 | scsi_dev_desc[i].type=DEV_TYPE_UNKNOWN; |
97 | scsi_dev_desc[i].vendor[0]=0; | |
98 | scsi_dev_desc[i].product[0]=0; | |
99 | scsi_dev_desc[i].revision[0]=0; | |
472d5460 | 100 | scsi_dev_desc[i].removable = false; |
e887afc9 WD |
101 | scsi_dev_desc[i].if_type=IF_TYPE_SCSI; |
102 | scsi_dev_desc[i].dev=i; | |
103 | scsi_dev_desc[i].part_type=PART_TYPE_UNKNOWN; | |
104 | scsi_dev_desc[i].block_read=scsi_read; | |
758c9e69 | 105 | scsi_dev_desc[i].block_write = scsi_write; |
e887afc9 WD |
106 | } |
107 | scsi_max_devs=0; | |
6d0f6bcf | 108 | for(i=0;i<CONFIG_SYS_SCSI_MAX_SCSI_ID;i++) { |
e887afc9 | 109 | pccb->target=i; |
6d0f6bcf | 110 | for(lun=0;lun<CONFIG_SYS_SCSI_MAX_LUN;lun++) { |
e887afc9 WD |
111 | pccb->lun=lun; |
112 | pccb->pdata=(unsigned char *)&tempbuff; | |
113 | pccb->datalen=512; | |
114 | scsi_setup_inquiry(pccb); | |
472d5460 | 115 | if (scsi_exec(pccb) != true) { |
e887afc9 | 116 | if(pccb->contr_stat==SCSI_SEL_TIME_OUT) { |
1a344f29 | 117 | debug ("Selection timeout ID %d\n",pccb->target); |
e887afc9 WD |
118 | continue; /* selection timeout => assuming no device present */ |
119 | } | |
120 | scsi_print_error(pccb); | |
121 | continue; | |
122 | } | |
123 | perq=tempbuff[0]; | |
124 | modi=tempbuff[1]; | |
125 | if((perq & 0x1f)==0x1f) { | |
126 | continue; /* skip unknown devices */ | |
127 | } | |
128 | if((modi&0x80)==0x80) /* drive is removable */ | |
472d5460 | 129 | scsi_dev_desc[scsi_max_devs].removable=true; |
e887afc9 | 130 | /* get info for this device */ |
2309c130 SR |
131 | scsi_ident_cpy((unsigned char *)&scsi_dev_desc[scsi_max_devs].vendor[0], |
132 | &tempbuff[8], 8); | |
133 | scsi_ident_cpy((unsigned char *)&scsi_dev_desc[scsi_max_devs].product[0], | |
134 | &tempbuff[16], 16); | |
135 | scsi_ident_cpy((unsigned char *)&scsi_dev_desc[scsi_max_devs].revision[0], | |
136 | &tempbuff[32], 4); | |
e887afc9 WD |
137 | scsi_dev_desc[scsi_max_devs].target=pccb->target; |
138 | scsi_dev_desc[scsi_max_devs].lun=pccb->lun; | |
139 | ||
140 | pccb->datalen=0; | |
141 | scsi_setup_test_unit_ready(pccb); | |
472d5460 YS |
142 | if (scsi_exec(pccb) != true) { |
143 | if (scsi_dev_desc[scsi_max_devs].removable == true) { | |
e887afc9 WD |
144 | scsi_dev_desc[scsi_max_devs].type=perq; |
145 | goto removable; | |
146 | } | |
147 | scsi_print_error(pccb); | |
148 | continue; | |
149 | } | |
b4c5bbce | 150 | if (scsi_read_capacity(pccb, &capacity, &blksz)) { |
e887afc9 WD |
151 | scsi_print_error(pccb); |
152 | continue; | |
153 | } | |
e887afc9 WD |
154 | scsi_dev_desc[scsi_max_devs].lba=capacity; |
155 | scsi_dev_desc[scsi_max_devs].blksz=blksz; | |
0472fbfd EE |
156 | scsi_dev_desc[scsi_max_devs].log2blksz = |
157 | LOG2(scsi_dev_desc[scsi_max_devs].blksz); | |
e887afc9 WD |
158 | scsi_dev_desc[scsi_max_devs].type=perq; |
159 | init_part(&scsi_dev_desc[scsi_max_devs]); | |
160 | removable: | |
161 | if(mode==1) { | |
162 | printf (" Device %d: ", scsi_max_devs); | |
163 | dev_print(&scsi_dev_desc[scsi_max_devs]); | |
164 | } /* if mode */ | |
165 | scsi_max_devs++; | |
166 | } /* next LUN */ | |
167 | } | |
168 | if(scsi_max_devs>0) | |
169 | scsi_curr_dev=0; | |
170 | else | |
d0ff51ba | 171 | scsi_curr_dev = -1; |
447c031b SR |
172 | |
173 | printf("Found %d device(s).\n", scsi_max_devs); | |
fff40a7e | 174 | #ifndef CONFIG_SPL_BUILD |
447c031b | 175 | setenv_ulong("scsidevs", scsi_max_devs); |
fff40a7e | 176 | #endif |
447c031b SR |
177 | } |
178 | ||
179 | int scsi_get_disk_count(void) | |
180 | { | |
181 | return scsi_max_devs; | |
e887afc9 WD |
182 | } |
183 | ||
1a1cf6ee | 184 | #if defined(CONFIG_PCI) && !defined(CONFIG_SCSI_AHCI_PLAT) |
e887afc9 WD |
185 | void scsi_init(void) |
186 | { | |
9fbdb946 | 187 | int busdevfunc = -1; |
4ae5eb7c VB |
188 | int i; |
189 | /* | |
190 | * Find a device from the list, this driver will support a single | |
191 | * controller. | |
192 | */ | |
193 | for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { | |
194 | /* get PCI Device ID */ | |
9fbdb946 SG |
195 | #ifdef CONFIG_DM_PCI |
196 | struct udevice *dev; | |
197 | int ret; | |
198 | ||
199 | ret = dm_pci_find_device(scsi_device_list[i].vendor, | |
200 | scsi_device_list[i].device, 0, &dev); | |
201 | if (!ret) { | |
202 | busdevfunc = dm_pci_get_bdf(dev); | |
203 | break; | |
204 | } | |
205 | #else | |
4ae5eb7c VB |
206 | busdevfunc = pci_find_device(scsi_device_list[i].vendor, |
207 | scsi_device_list[i].device, | |
208 | 0); | |
9fbdb946 | 209 | #endif |
4ae5eb7c VB |
210 | if (busdevfunc != -1) |
211 | break; | |
212 | } | |
e887afc9 | 213 | |
4ae5eb7c VB |
214 | if (busdevfunc == -1) { |
215 | printf("Error: SCSI Controller(s) "); | |
216 | for (i = 0; i < ARRAY_SIZE(scsi_device_list); i++) { | |
217 | printf("%04X:%04X ", | |
218 | scsi_device_list[i].vendor, | |
219 | scsi_device_list[i].device); | |
220 | } | |
221 | printf("not found\n"); | |
e887afc9 WD |
222 | return; |
223 | } | |
224 | #ifdef DEBUG | |
225 | else { | |
4ae5eb7c VB |
226 | printf("SCSI Controller (%04X,%04X) found (%d:%d:%d)\n", |
227 | scsi_device_list[i].vendor, | |
228 | scsi_device_list[i].device, | |
229 | (busdevfunc >> 16) & 0xFF, | |
230 | (busdevfunc >> 11) & 0x1F, | |
231 | (busdevfunc >> 8) & 0x7); | |
e887afc9 WD |
232 | } |
233 | #endif | |
abbdb262 | 234 | bootstage_start(BOOTSTAGE_ID_ACCUM_SCSI, "ahci"); |
e887afc9 WD |
235 | scsi_low_level_init(busdevfunc); |
236 | scsi_scan(1); | |
abbdb262 | 237 | bootstage_accum(BOOTSTAGE_ID_ACCUM_SCSI); |
e887afc9 | 238 | } |
942e3143 | 239 | #endif |
e887afc9 | 240 | |
df3fc526 | 241 | #ifdef CONFIG_PARTITIONS |
4101f687 | 242 | struct blk_desc *scsi_get_dev(int dev) |
e887afc9 | 243 | { |
6d0f6bcf | 244 | return (dev < CONFIG_SYS_SCSI_MAX_DEVICE) ? &scsi_dev_desc[dev] : NULL; |
e887afc9 | 245 | } |
df3fc526 | 246 | #endif |
e887afc9 | 247 | |
e887afc9 WD |
248 | /****************************************************************************** |
249 | * scsi boot command intepreter. Derived from diskboot | |
250 | */ | |
54841ab5 | 251 | int do_scsiboot (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 | 252 | { |
7405a133 | 253 | return common_diskboot(cmdtp, "scsi", argc, argv); |
e887afc9 WD |
254 | } |
255 | ||
256 | /********************************************************************************* | |
257 | * scsi command intepreter | |
258 | */ | |
54841ab5 | 259 | int do_scsi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 WD |
260 | { |
261 | switch (argc) { | |
4c12eeb8 SG |
262 | case 0: |
263 | case 1: | |
264 | return CMD_RET_USAGE; | |
47e26b1b | 265 | |
4c12eeb8 | 266 | case 2: |
e887afc9 WD |
267 | if (strncmp(argv[1],"res",3) == 0) { |
268 | printf("\nReset SCSI\n"); | |
269 | scsi_bus_reset(); | |
270 | scsi_scan(1); | |
271 | return 0; | |
272 | } | |
273 | if (strncmp(argv[1],"inf",3) == 0) { | |
274 | int i; | |
6d0f6bcf | 275 | for (i=0; i<CONFIG_SYS_SCSI_MAX_DEVICE; ++i) { |
e887afc9 WD |
276 | if(scsi_dev_desc[i].type==DEV_TYPE_UNKNOWN) |
277 | continue; /* list only known devices */ | |
278 | printf ("SCSI dev. %d: ", i); | |
279 | dev_print(&scsi_dev_desc[i]); | |
280 | } | |
281 | return 0; | |
282 | } | |
283 | if (strncmp(argv[1],"dev",3) == 0) { | |
6d0f6bcf | 284 | if ((scsi_curr_dev < 0) || (scsi_curr_dev >= CONFIG_SYS_SCSI_MAX_DEVICE)) { |
e887afc9 WD |
285 | printf("\nno SCSI devices available\n"); |
286 | return 1; | |
287 | } | |
288 | printf ("\n Device %d: ", scsi_curr_dev); | |
289 | dev_print(&scsi_dev_desc[scsi_curr_dev]); | |
290 | return 0; | |
291 | } | |
292 | if (strncmp(argv[1],"scan",4) == 0) { | |
293 | scsi_scan(1); | |
294 | return 0; | |
295 | } | |
296 | if (strncmp(argv[1],"part",4) == 0) { | |
297 | int dev, ok; | |
6d0f6bcf | 298 | for (ok=0, dev=0; dev<CONFIG_SYS_SCSI_MAX_DEVICE; ++dev) { |
e887afc9 WD |
299 | if (scsi_dev_desc[dev].type!=DEV_TYPE_UNKNOWN) { |
300 | ok++; | |
301 | if (dev) | |
302 | printf("\n"); | |
1a344f29 | 303 | debug ("print_part of %x\n",dev); |
e887afc9 WD |
304 | print_part(&scsi_dev_desc[dev]); |
305 | } | |
306 | } | |
307 | if (!ok) | |
308 | printf("\nno SCSI devices available\n"); | |
309 | return 1; | |
310 | } | |
4c12eeb8 | 311 | return CMD_RET_USAGE; |
53677ef1 | 312 | case 3: |
e887afc9 WD |
313 | if (strncmp(argv[1],"dev",3) == 0) { |
314 | int dev = (int)simple_strtoul(argv[2], NULL, 10); | |
315 | printf ("\nSCSI device %d: ", dev); | |
6d0f6bcf | 316 | if (dev >= CONFIG_SYS_SCSI_MAX_DEVICE) { |
e887afc9 WD |
317 | printf("unknown device\n"); |
318 | return 1; | |
319 | } | |
320 | printf ("\n Device %d: ", dev); | |
321 | dev_print(&scsi_dev_desc[dev]); | |
322 | if(scsi_dev_desc[dev].type == DEV_TYPE_UNKNOWN) { | |
323 | return 1; | |
324 | } | |
325 | scsi_curr_dev = dev; | |
326 | printf("... is now current device\n"); | |
327 | return 0; | |
328 | } | |
329 | if (strncmp(argv[1],"part",4) == 0) { | |
330 | int dev = (int)simple_strtoul(argv[2], NULL, 10); | |
331 | if(scsi_dev_desc[dev].type != DEV_TYPE_UNKNOWN) { | |
332 | print_part(&scsi_dev_desc[dev]); | |
333 | } | |
334 | else { | |
335 | printf ("\nSCSI device %d not available\n", dev); | |
336 | } | |
337 | return 1; | |
338 | } | |
4c12eeb8 | 339 | return CMD_RET_USAGE; |
e887afc9 WD |
340 | default: |
341 | /* at least 4 args */ | |
342 | if (strcmp(argv[1],"read") == 0) { | |
343 | ulong addr = simple_strtoul(argv[2], NULL, 16); | |
344 | ulong blk = simple_strtoul(argv[3], NULL, 16); | |
345 | ulong cnt = simple_strtoul(argv[4], NULL, 16); | |
346 | ulong n; | |
347 | printf ("\nSCSI read: device %d block # %ld, count %ld ... ", | |
348 | scsi_curr_dev, blk, cnt); | |
7c4213f6 SW |
349 | n = scsi_read(&scsi_dev_desc[scsi_curr_dev], |
350 | blk, cnt, (ulong *)addr); | |
e887afc9 WD |
351 | printf ("%ld blocks read: %s\n",n,(n==cnt) ? "OK" : "ERROR"); |
352 | return 0; | |
758c9e69 HTL |
353 | } else if (strcmp(argv[1], "write") == 0) { |
354 | ulong addr = simple_strtoul(argv[2], NULL, 16); | |
355 | ulong blk = simple_strtoul(argv[3], NULL, 16); | |
356 | ulong cnt = simple_strtoul(argv[4], NULL, 16); | |
357 | ulong n; | |
358 | printf("\nSCSI write: device %d block # %ld, " | |
359 | "count %ld ... ", | |
360 | scsi_curr_dev, blk, cnt); | |
7c4213f6 SW |
361 | n = scsi_write(&scsi_dev_desc[scsi_curr_dev], |
362 | blk, cnt, (ulong *)addr); | |
758c9e69 HTL |
363 | printf("%ld blocks written: %s\n", n, |
364 | (n == cnt) ? "OK" : "ERROR"); | |
365 | return 0; | |
e887afc9 WD |
366 | } |
367 | } /* switch */ | |
4c12eeb8 | 368 | return CMD_RET_USAGE; |
e887afc9 WD |
369 | } |
370 | ||
371 | /**************************************************************************************** | |
372 | * scsi_read | |
373 | */ | |
374 | ||
2b42c931 ML |
375 | /* almost the maximum amount of the scsi_ext command.. */ |
376 | #define SCSI_MAX_READ_BLK 0xFFFF | |
377 | #define SCSI_LBA48_READ 0xFFFFFFF | |
e887afc9 | 378 | |
4101f687 | 379 | static ulong scsi_read(struct blk_desc *block_dev, lbaint_t blknr, |
7c4213f6 | 380 | lbaint_t blkcnt, void *buffer) |
e887afc9 | 381 | { |
7c4213f6 | 382 | int device = block_dev->dev; |
758c9e69 HTL |
383 | lbaint_t start, blks; |
384 | uintptr_t buf_addr; | |
c7d0fd79 | 385 | unsigned short smallblks = 0; |
e887afc9 WD |
386 | ccb* pccb=(ccb *)&tempccb; |
387 | device&=0xff; | |
388 | /* Setup device | |
389 | */ | |
390 | pccb->target=scsi_dev_desc[device].target; | |
391 | pccb->lun=scsi_dev_desc[device].lun; | |
392 | buf_addr=(unsigned long)buffer; | |
393 | start=blknr; | |
394 | blks=blkcnt; | |
758c9e69 HTL |
395 | debug("\nscsi_read: dev %d startblk " LBAF |
396 | ", blccnt " LBAF " buffer %lx\n", | |
397 | device, start, blks, (unsigned long)buffer); | |
e887afc9 WD |
398 | do { |
399 | pccb->pdata=(unsigned char *)buf_addr; | |
2b42c931 ML |
400 | #ifdef CONFIG_SYS_64BIT_LBA |
401 | if (start > SCSI_LBA48_READ) { | |
402 | unsigned long blocks; | |
403 | blocks = min_t(lbaint_t, blks, SCSI_MAX_READ_BLK); | |
404 | pccb->datalen = scsi_dev_desc[device].blksz * blocks; | |
405 | scsi_setup_read16(pccb, start, blocks); | |
406 | start += blocks; | |
407 | blks -= blocks; | |
c7d0fd79 | 408 | } else |
2b42c931 ML |
409 | #endif |
410 | if (blks > SCSI_MAX_READ_BLK) { | |
e887afc9 WD |
411 | pccb->datalen=scsi_dev_desc[device].blksz * SCSI_MAX_READ_BLK; |
412 | smallblks=SCSI_MAX_READ_BLK; | |
413 | scsi_setup_read_ext(pccb,start,smallblks); | |
414 | start+=SCSI_MAX_READ_BLK; | |
415 | blks-=SCSI_MAX_READ_BLK; | |
416 | } | |
417 | else { | |
418 | pccb->datalen=scsi_dev_desc[device].blksz * blks; | |
419 | smallblks=(unsigned short) blks; | |
420 | scsi_setup_read_ext(pccb,start,smallblks); | |
421 | start+=blks; | |
422 | blks=0; | |
423 | } | |
758c9e69 | 424 | debug("scsi_read_ext: startblk " LBAF |
f3609473 | 425 | ", blccnt %x buffer %" PRIXPTR "\n", |
758c9e69 | 426 | start, smallblks, buf_addr); |
472d5460 | 427 | if (scsi_exec(pccb) != true) { |
e887afc9 WD |
428 | scsi_print_error(pccb); |
429 | blkcnt-=blks; | |
430 | break; | |
431 | } | |
432 | buf_addr+=pccb->datalen; | |
433 | } while(blks!=0); | |
758c9e69 | 434 | debug("scsi_read_ext: end startblk " LBAF |
f3609473 | 435 | ", blccnt %x buffer %" PRIXPTR "\n", start, smallblks, buf_addr); |
e887afc9 WD |
436 | return(blkcnt); |
437 | } | |
438 | ||
758c9e69 HTL |
439 | /******************************************************************************* |
440 | * scsi_write | |
441 | */ | |
442 | ||
443 | /* Almost the maximum amount of the scsi_ext command.. */ | |
444 | #define SCSI_MAX_WRITE_BLK 0xFFFF | |
445 | ||
4101f687 | 446 | static ulong scsi_write(struct blk_desc *block_dev, lbaint_t blknr, |
758c9e69 HTL |
447 | lbaint_t blkcnt, const void *buffer) |
448 | { | |
7c4213f6 | 449 | int device = block_dev->dev; |
758c9e69 HTL |
450 | lbaint_t start, blks; |
451 | uintptr_t buf_addr; | |
452 | unsigned short smallblks; | |
453 | ccb* pccb = (ccb *)&tempccb; | |
454 | device &= 0xff; | |
455 | /* Setup device | |
456 | */ | |
457 | pccb->target = scsi_dev_desc[device].target; | |
458 | pccb->lun = scsi_dev_desc[device].lun; | |
459 | buf_addr = (unsigned long)buffer; | |
460 | start = blknr; | |
461 | blks = blkcnt; | |
462 | debug("\n%s: dev %d startblk " LBAF ", blccnt " LBAF " buffer %lx\n", | |
463 | __func__, device, start, blks, (unsigned long)buffer); | |
464 | do { | |
465 | pccb->pdata = (unsigned char *)buf_addr; | |
466 | if (blks > SCSI_MAX_WRITE_BLK) { | |
467 | pccb->datalen = (scsi_dev_desc[device].blksz * | |
468 | SCSI_MAX_WRITE_BLK); | |
469 | smallblks = SCSI_MAX_WRITE_BLK; | |
470 | scsi_setup_write_ext(pccb, start, smallblks); | |
471 | start += SCSI_MAX_WRITE_BLK; | |
472 | blks -= SCSI_MAX_WRITE_BLK; | |
473 | } else { | |
474 | pccb->datalen = scsi_dev_desc[device].blksz * blks; | |
475 | smallblks = (unsigned short)blks; | |
476 | scsi_setup_write_ext(pccb, start, smallblks); | |
477 | start += blks; | |
478 | blks = 0; | |
479 | } | |
f3609473 | 480 | debug("%s: startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n", |
758c9e69 | 481 | __func__, start, smallblks, buf_addr); |
472d5460 | 482 | if (scsi_exec(pccb) != true) { |
758c9e69 HTL |
483 | scsi_print_error(pccb); |
484 | blkcnt -= blks; | |
485 | break; | |
486 | } | |
487 | buf_addr += pccb->datalen; | |
488 | } while (blks != 0); | |
f3609473 | 489 | debug("%s: end startblk " LBAF ", blccnt %x buffer %" PRIXPTR "\n", |
758c9e69 HTL |
490 | __func__, start, smallblks, buf_addr); |
491 | return blkcnt; | |
492 | } | |
493 | ||
e887afc9 WD |
494 | /* copy src to dest, skipping leading and trailing blanks |
495 | * and null terminate the string | |
496 | */ | |
497 | void scsi_ident_cpy (unsigned char *dest, unsigned char *src, unsigned int len) | |
498 | { | |
499 | int start,end; | |
500 | ||
501 | start=0; | |
502 | while(start<len) { | |
503 | if(src[start]!=' ') | |
504 | break; | |
505 | start++; | |
506 | } | |
507 | end=len-1; | |
508 | while(end>start) { | |
509 | if(src[end]!=' ') | |
510 | break; | |
511 | end--; | |
512 | } | |
513 | for( ; start<=end; start++) { | |
514 | *dest++=src[start]; | |
515 | } | |
516 | *dest='\0'; | |
517 | } | |
518 | ||
519 | ||
e887afc9 WD |
520 | /* Trim trailing blanks, and NUL-terminate string |
521 | */ | |
522 | void scsi_trim_trail (unsigned char *str, unsigned int len) | |
523 | { | |
524 | unsigned char *p = str + len - 1; | |
525 | ||
526 | while (len-- > 0) { | |
527 | *p-- = '\0'; | |
528 | if (*p != ' ') { | |
529 | return; | |
530 | } | |
531 | } | |
532 | } | |
533 | ||
b4c5bbce GB |
534 | int scsi_read_capacity(ccb *pccb, lbaint_t *capacity, unsigned long *blksz) |
535 | { | |
536 | *capacity = 0; | |
537 | ||
538 | memset(pccb->cmd, 0, sizeof(pccb->cmd)); | |
539 | pccb->cmd[0] = SCSI_RD_CAPAC10; | |
540 | pccb->cmd[1] = pccb->lun << 5; | |
541 | pccb->cmdlen = 10; | |
542 | pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ | |
543 | ||
544 | pccb->datalen = 8; | |
472d5460 | 545 | if (scsi_exec(pccb) != true) |
b4c5bbce GB |
546 | return 1; |
547 | ||
548 | *capacity = ((lbaint_t)pccb->pdata[0] << 24) | | |
549 | ((lbaint_t)pccb->pdata[1] << 16) | | |
550 | ((lbaint_t)pccb->pdata[2] << 8) | | |
551 | ((lbaint_t)pccb->pdata[3]); | |
552 | ||
553 | if (*capacity != 0xffffffff) { | |
554 | /* Read capacity (10) was sufficient for this drive. */ | |
555 | *blksz = ((unsigned long)pccb->pdata[4] << 24) | | |
556 | ((unsigned long)pccb->pdata[5] << 16) | | |
557 | ((unsigned long)pccb->pdata[6] << 8) | | |
558 | ((unsigned long)pccb->pdata[7]); | |
559 | return 0; | |
560 | } | |
561 | ||
562 | /* Read capacity (10) was insufficient. Use read capacity (16). */ | |
563 | ||
564 | memset(pccb->cmd, 0, sizeof(pccb->cmd)); | |
565 | pccb->cmd[0] = SCSI_RD_CAPAC16; | |
566 | pccb->cmd[1] = 0x10; | |
567 | pccb->cmdlen = 16; | |
568 | pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ | |
569 | ||
570 | pccb->datalen = 16; | |
472d5460 | 571 | if (scsi_exec(pccb) != true) |
b4c5bbce GB |
572 | return 1; |
573 | ||
574 | *capacity = ((uint64_t)pccb->pdata[0] << 56) | | |
575 | ((uint64_t)pccb->pdata[1] << 48) | | |
576 | ((uint64_t)pccb->pdata[2] << 40) | | |
577 | ((uint64_t)pccb->pdata[3] << 32) | | |
578 | ((uint64_t)pccb->pdata[4] << 24) | | |
579 | ((uint64_t)pccb->pdata[5] << 16) | | |
580 | ((uint64_t)pccb->pdata[6] << 8) | | |
581 | ((uint64_t)pccb->pdata[7]); | |
582 | ||
583 | *blksz = ((uint64_t)pccb->pdata[8] << 56) | | |
584 | ((uint64_t)pccb->pdata[9] << 48) | | |
585 | ((uint64_t)pccb->pdata[10] << 40) | | |
586 | ((uint64_t)pccb->pdata[11] << 32) | | |
587 | ((uint64_t)pccb->pdata[12] << 24) | | |
588 | ((uint64_t)pccb->pdata[13] << 16) | | |
589 | ((uint64_t)pccb->pdata[14] << 8) | | |
590 | ((uint64_t)pccb->pdata[15]); | |
591 | ||
592 | return 0; | |
593 | } | |
594 | ||
e887afc9 WD |
595 | |
596 | /************************************************************************************ | |
597 | * Some setup (fill-in) routines | |
598 | */ | |
599 | void scsi_setup_test_unit_ready(ccb * pccb) | |
600 | { | |
601 | pccb->cmd[0]=SCSI_TST_U_RDY; | |
602 | pccb->cmd[1]=pccb->lun<<5; | |
603 | pccb->cmd[2]=0; | |
604 | pccb->cmd[3]=0; | |
605 | pccb->cmd[4]=0; | |
606 | pccb->cmd[5]=0; | |
607 | pccb->cmdlen=6; | |
608 | pccb->msgout[0]=SCSI_IDENTIFY; /* NOT USED */ | |
609 | } | |
610 | ||
2b42c931 ML |
611 | #ifdef CONFIG_SYS_64BIT_LBA |
612 | void scsi_setup_read16(ccb * pccb, lbaint_t start, unsigned long blocks) | |
613 | { | |
614 | pccb->cmd[0] = SCSI_READ16; | |
615 | pccb->cmd[1] = pccb->lun<<5; | |
616 | pccb->cmd[2] = ((unsigned char) (start >> 56)) & 0xff; | |
617 | pccb->cmd[3] = ((unsigned char) (start >> 48)) & 0xff; | |
618 | pccb->cmd[4] = ((unsigned char) (start >> 40)) & 0xff; | |
619 | pccb->cmd[5] = ((unsigned char) (start >> 32)) & 0xff; | |
620 | pccb->cmd[6] = ((unsigned char) (start >> 24)) & 0xff; | |
621 | pccb->cmd[7] = ((unsigned char) (start >> 16)) & 0xff; | |
622 | pccb->cmd[8] = ((unsigned char) (start >> 8)) & 0xff; | |
623 | pccb->cmd[9] = ((unsigned char) (start)) & 0xff; | |
624 | pccb->cmd[10] = 0; | |
625 | pccb->cmd[11] = ((unsigned char) (blocks >> 24)) & 0xff; | |
626 | pccb->cmd[12] = ((unsigned char) (blocks >> 16)) & 0xff; | |
627 | pccb->cmd[13] = ((unsigned char) (blocks >> 8)) & 0xff; | |
628 | pccb->cmd[14] = (unsigned char) blocks & 0xff; | |
629 | pccb->cmd[15] = 0; | |
630 | pccb->cmdlen = 16; | |
631 | pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ | |
632 | debug ("scsi_setup_read16: cmd: %02X %02X " | |
633 | "startblk %02X%02X%02X%02X%02X%02X%02X%02X " | |
634 | "blccnt %02X%02X%02X%02X\n", | |
635 | pccb->cmd[0], pccb->cmd[1], | |
636 | pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5], | |
637 | pccb->cmd[6], pccb->cmd[7], pccb->cmd[8], pccb->cmd[9], | |
638 | pccb->cmd[11], pccb->cmd[12], pccb->cmd[13], pccb->cmd[14]); | |
639 | } | |
640 | #endif | |
641 | ||
35df8931 | 642 | void scsi_setup_read_ext(ccb * pccb, lbaint_t start, unsigned short blocks) |
e887afc9 WD |
643 | { |
644 | pccb->cmd[0]=SCSI_READ10; | |
645 | pccb->cmd[1]=pccb->lun<<5; | |
646 | pccb->cmd[2]=((unsigned char) (start>>24))&0xff; | |
647 | pccb->cmd[3]=((unsigned char) (start>>16))&0xff; | |
648 | pccb->cmd[4]=((unsigned char) (start>>8))&0xff; | |
649 | pccb->cmd[5]=((unsigned char) (start))&0xff; | |
650 | pccb->cmd[6]=0; | |
651 | pccb->cmd[7]=((unsigned char) (blocks>>8))&0xff; | |
652 | pccb->cmd[8]=(unsigned char) blocks & 0xff; | |
653 | pccb->cmd[6]=0; | |
654 | pccb->cmdlen=10; | |
655 | pccb->msgout[0]=SCSI_IDENTIFY; /* NOT USED */ | |
1a344f29 | 656 | debug ("scsi_setup_read_ext: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n", |
e887afc9 WD |
657 | pccb->cmd[0],pccb->cmd[1], |
658 | pccb->cmd[2],pccb->cmd[3],pccb->cmd[4],pccb->cmd[5], | |
659 | pccb->cmd[7],pccb->cmd[8]); | |
660 | } | |
661 | ||
35df8931 | 662 | void scsi_setup_write_ext(ccb *pccb, lbaint_t start, unsigned short blocks) |
758c9e69 HTL |
663 | { |
664 | pccb->cmd[0] = SCSI_WRITE10; | |
665 | pccb->cmd[1] = pccb->lun << 5; | |
666 | pccb->cmd[2] = ((unsigned char) (start>>24)) & 0xff; | |
667 | pccb->cmd[3] = ((unsigned char) (start>>16)) & 0xff; | |
668 | pccb->cmd[4] = ((unsigned char) (start>>8)) & 0xff; | |
669 | pccb->cmd[5] = ((unsigned char) (start)) & 0xff; | |
670 | pccb->cmd[6] = 0; | |
671 | pccb->cmd[7] = ((unsigned char) (blocks>>8)) & 0xff; | |
672 | pccb->cmd[8] = (unsigned char)blocks & 0xff; | |
673 | pccb->cmd[9] = 0; | |
674 | pccb->cmdlen = 10; | |
675 | pccb->msgout[0] = SCSI_IDENTIFY; /* NOT USED */ | |
676 | debug("%s: cmd: %02X %02X startblk %02X%02X%02X%02X blccnt %02X%02X\n", | |
677 | __func__, | |
678 | pccb->cmd[0], pccb->cmd[1], | |
679 | pccb->cmd[2], pccb->cmd[3], pccb->cmd[4], pccb->cmd[5], | |
680 | pccb->cmd[7], pccb->cmd[8]); | |
681 | } | |
682 | ||
35df8931 | 683 | void scsi_setup_read6(ccb * pccb, lbaint_t start, unsigned short blocks) |
e887afc9 WD |
684 | { |
685 | pccb->cmd[0]=SCSI_READ6; | |
686 | pccb->cmd[1]=pccb->lun<<5 | (((unsigned char)(start>>16))&0x1f); | |
687 | pccb->cmd[2]=((unsigned char) (start>>8))&0xff; | |
688 | pccb->cmd[3]=((unsigned char) (start))&0xff; | |
689 | pccb->cmd[4]=(unsigned char) blocks & 0xff; | |
690 | pccb->cmd[5]=0; | |
691 | pccb->cmdlen=6; | |
692 | pccb->msgout[0]=SCSI_IDENTIFY; /* NOT USED */ | |
1a344f29 | 693 | debug ("scsi_setup_read6: cmd: %02X %02X startblk %02X%02X blccnt %02X\n", |
e887afc9 WD |
694 | pccb->cmd[0],pccb->cmd[1], |
695 | pccb->cmd[2],pccb->cmd[3],pccb->cmd[4]); | |
696 | } | |
697 | ||
698 | ||
699 | void scsi_setup_inquiry(ccb * pccb) | |
700 | { | |
701 | pccb->cmd[0]=SCSI_INQUIRY; | |
702 | pccb->cmd[1]=pccb->lun<<5; | |
703 | pccb->cmd[2]=0; | |
704 | pccb->cmd[3]=0; | |
705 | if(pccb->datalen>255) | |
706 | pccb->cmd[4]=255; | |
707 | else | |
708 | pccb->cmd[4]=(unsigned char)pccb->datalen; | |
709 | pccb->cmd[5]=0; | |
710 | pccb->cmdlen=6; | |
711 | pccb->msgout[0]=SCSI_IDENTIFY; /* NOT USED */ | |
712 | } | |
713 | ||
460c322f WD |
714 | |
715 | U_BOOT_CMD( | |
716 | scsi, 5, 1, do_scsi, | |
2fb2604d | 717 | "SCSI sub-system", |
460c322f WD |
718 | "reset - reset SCSI controller\n" |
719 | "scsi info - show available SCSI devices\n" | |
720 | "scsi scan - (re-)scan SCSI bus\n" | |
721 | "scsi device [dev] - show or set current device\n" | |
722 | "scsi part [dev] - print partition table of one or all SCSI devices\n" | |
723 | "scsi read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n" | |
758c9e69 HTL |
724 | " to memory address `addr'\n" |
725 | "scsi write addr blk# cnt - write `cnt' blocks starting at block\n" | |
726 | " `blk#' from memory address `addr'" | |
460c322f WD |
727 | ); |
728 | ||
729 | U_BOOT_CMD( | |
730 | scsiboot, 3, 1, do_scsiboot, | |
2fb2604d | 731 | "boot from SCSI device", |
a89c33db | 732 | "loadAddr dev:part" |
460c322f | 733 | ); |