]> git.sur5r.net Git - u-boot/blob - common/cmd_sata.c
ARM: dts: exnyos: enable dw-mmc controller
[u-boot] / common / cmd_sata.c
1 /*
2  * Copyright (C) 2000-2005, DENX Software Engineering
3  *              Wolfgang Denk <wd@denx.de>
4  * Copyright (C) Procsys. All rights reserved.
5  *              Mushtaq Khan <mushtaq_k@procsys.com>
6  *                      <mushtaqk_921@yahoo.co.in>
7  * Copyright (C) 2008 Freescale Semiconductor, Inc.
8  *              Dave Liu <daveliu@freescale.com>
9  *
10  * SPDX-License-Identifier:     GPL-2.0+
11  */
12
13 #include <common.h>
14 #include <command.h>
15 #include <part.h>
16 #include <sata.h>
17
18 static int sata_curr_device = -1;
19 block_dev_desc_t sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE];
20
21 int __sata_initialize(void)
22 {
23         int rc;
24         int i;
25
26         for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; i++) {
27                 memset(&sata_dev_desc[i], 0, sizeof(struct block_dev_desc));
28                 sata_dev_desc[i].if_type = IF_TYPE_SATA;
29                 sata_dev_desc[i].dev = i;
30                 sata_dev_desc[i].part_type = PART_TYPE_UNKNOWN;
31                 sata_dev_desc[i].type = DEV_TYPE_HARDDISK;
32                 sata_dev_desc[i].lba = 0;
33                 sata_dev_desc[i].blksz = 512;
34                 sata_dev_desc[i].log2blksz = LOG2(sata_dev_desc[i].blksz);
35                 sata_dev_desc[i].block_read = sata_read;
36                 sata_dev_desc[i].block_write = sata_write;
37
38                 rc = init_sata(i);
39                 if (!rc) {
40                         rc = scan_sata(i);
41                         if (!rc && (sata_dev_desc[i].lba > 0) &&
42                                 (sata_dev_desc[i].blksz > 0))
43                                 init_part(&sata_dev_desc[i]);
44                 }
45         }
46         sata_curr_device = 0;
47         return rc;
48 }
49 int sata_initialize(void) __attribute__((weak,alias("__sata_initialize")));
50
51 #ifdef CONFIG_PARTITIONS
52 block_dev_desc_t *sata_get_dev(int dev)
53 {
54         return (dev < CONFIG_SYS_SATA_MAX_DEVICE) ? &sata_dev_desc[dev] : NULL;
55 }
56 #endif
57
58 static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
59 {
60         int rc = 0;
61
62         if (argc == 2 && strcmp(argv[1], "init") == 0)
63                 return sata_initialize();
64
65         /* If the user has not yet run `sata init`, do it now */
66         if (sata_curr_device == -1)
67                 if (sata_initialize())
68                         return 1;
69
70         switch (argc) {
71         case 0:
72         case 1:
73                 return CMD_RET_USAGE;
74         case 2:
75                 if (strncmp(argv[1],"inf", 3) == 0) {
76                         int i;
77                         putc('\n');
78                         for (i = 0; i < CONFIG_SYS_SATA_MAX_DEVICE; ++i) {
79                                 if (sata_dev_desc[i].type == DEV_TYPE_UNKNOWN)
80                                         continue;
81                                 printf ("SATA device %d: ", i);
82                                 dev_print(&sata_dev_desc[i]);
83                         }
84                         return 0;
85                 } else if (strncmp(argv[1],"dev", 3) == 0) {
86                         if ((sata_curr_device < 0) || (sata_curr_device >= CONFIG_SYS_SATA_MAX_DEVICE)) {
87                                 puts("\nno SATA devices available\n");
88                                 return 1;
89                         }
90                         printf("\nSATA device %d: ", sata_curr_device);
91                         dev_print(&sata_dev_desc[sata_curr_device]);
92                         return 0;
93                 } else if (strncmp(argv[1],"part",4) == 0) {
94                         int dev, ok;
95
96                         for (ok = 0, dev = 0; dev < CONFIG_SYS_SATA_MAX_DEVICE; ++dev) {
97                                 if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) {
98                                         ++ok;
99                                         if (dev)
100                                                 putc ('\n');
101                                         print_part(&sata_dev_desc[dev]);
102                                 }
103                         }
104                         if (!ok) {
105                                 puts("\nno SATA devices available\n");
106                                 rc ++;
107                         }
108                         return rc;
109                 }
110                 return CMD_RET_USAGE;
111         case 3:
112                 if (strncmp(argv[1], "dev", 3) == 0) {
113                         int dev = (int)simple_strtoul(argv[2], NULL, 10);
114
115                         printf("\nSATA device %d: ", dev);
116                         if (dev >= CONFIG_SYS_SATA_MAX_DEVICE) {
117                                 puts ("unknown device\n");
118                                 return 1;
119                         }
120                         dev_print(&sata_dev_desc[dev]);
121
122                         if (sata_dev_desc[dev].type == DEV_TYPE_UNKNOWN)
123                                 return 1;
124
125                         sata_curr_device = dev;
126
127                         puts("... is now current device\n");
128
129                         return 0;
130                 } else if (strncmp(argv[1], "part", 4) == 0) {
131                         int dev = (int)simple_strtoul(argv[2], NULL, 10);
132
133                         if (sata_dev_desc[dev].part_type != PART_TYPE_UNKNOWN) {
134                                 print_part(&sata_dev_desc[dev]);
135                         } else {
136                                 printf("\nSATA device %d not available\n", dev);
137                                 rc = 1;
138                         }
139                         return rc;
140                 }
141                 return CMD_RET_USAGE;
142
143         default: /* at least 4 args */
144                 if (strcmp(argv[1], "read") == 0) {
145                         ulong addr = simple_strtoul(argv[2], NULL, 16);
146                         ulong cnt = simple_strtoul(argv[4], NULL, 16);
147                         ulong n;
148                         lbaint_t blk = simple_strtoul(argv[3], NULL, 16);
149
150                         printf("\nSATA read: device %d block # %ld, count %ld ... ",
151                                 sata_curr_device, blk, cnt);
152
153                         n = sata_read(sata_curr_device, blk, cnt, (u32 *)addr);
154
155                         /* flush cache after read */
156                         flush_cache(addr, cnt * sata_dev_desc[sata_curr_device].blksz);
157
158                         printf("%ld blocks read: %s\n",
159                                 n, (n==cnt) ? "OK" : "ERROR");
160                         return (n == cnt) ? 0 : 1;
161                 } else if (strcmp(argv[1], "write") == 0) {
162                         ulong addr = simple_strtoul(argv[2], NULL, 16);
163                         ulong cnt = simple_strtoul(argv[4], NULL, 16);
164                         ulong n;
165
166                         lbaint_t blk = simple_strtoul(argv[3], NULL, 16);
167
168                         printf("\nSATA write: device %d block # %ld, count %ld ... ",
169                                 sata_curr_device, blk, cnt);
170
171                         n = sata_write(sata_curr_device, blk, cnt, (u32 *)addr);
172
173                         printf("%ld blocks written: %s\n",
174                                 n, (n == cnt) ? "OK" : "ERROR");
175                         return (n == cnt) ? 0 : 1;
176                 } else {
177                         return CMD_RET_USAGE;
178                 }
179
180                 return rc;
181         }
182 }
183
184 U_BOOT_CMD(
185         sata, 5, 1, do_sata,
186         "SATA sub system",
187         "init - init SATA sub system\n"
188         "sata info - show available SATA devices\n"
189         "sata device [dev] - show or set current device\n"
190         "sata part [dev] - print partition table\n"
191         "sata read addr blk# cnt\n"
192         "sata write addr blk# cnt"
193 );