]> git.sur5r.net Git - u-boot/blob - common/cmd_sata.c
net: make ARP timeout configurable
[u-boot] / common / cmd_sata.c
1 /*
2  * Copyright (C) Procsys. All rights reserved.
3  * Author: Mushtaq Khan <mushtaq_k@procsys.com>
4  *                      <mushtaqk_921@yahoo.co.in>
5  *
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2 of
10  * the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20  * MA 02111-1307 USA
21  *
22  * with the reference to libata in kernel 2.4.32
23  *
24  */
25
26 /*
27  * File contains SATA read-write and other utility functions.
28  */
29 #include <common.h>
30 #include <asm/io.h>
31 #include <pci.h>
32 #include <command.h>
33 #include <config.h>
34 #include <ide.h>
35 #include <ata.h>
36
37 #ifdef CFG_SATA_SUPPORTED
38 /*For debug prints set macro DEBUG_SATA to 1 */
39 #define DEBUG_SATA 0
40 /*Macro for SATA library specific declarations */
41 #define SATA_DECL
42 #include <sata.h>
43 #undef SATA_DECL
44
45 static u8 __inline__
46 sata_inb (unsigned long ioaddr)
47 {
48         return inb (ioaddr);
49 }
50
51 static void __inline__
52 sata_outb (unsigned char val, unsigned long ioaddr)
53 {
54         outb (val, ioaddr);
55 }
56
57 static void
58 output_data (struct sata_ioports *ioaddr, ulong * sect_buf, int words)
59 {
60         outsw (ioaddr->data_addr, sect_buf, words << 1);
61 }
62
63 static int
64 input_data (struct sata_ioports *ioaddr, ulong * sect_buf, int words)
65 {
66         insw (ioaddr->data_addr, sect_buf, words << 1);
67         return 0;
68 }
69
70 static void
71 sata_cpy (unsigned char *dst, unsigned char *src, unsigned int len)
72 {
73         unsigned char *end, *last;
74
75         last = dst;
76         end = src + len - 1;
77
78         /* reserve space for '\0' */
79         if (len < 2)
80                 goto OUT;
81
82         /* skip leading white space */
83         while ((*src) && (src < end) && (*src == ' '))
84                 ++src;
85
86         /* copy string, omitting trailing white space */
87         while ((*src) && (src < end)) {
88                 *dst++ = *src;
89                 if (*src++ != ' ')
90                         last = dst;
91         }
92       OUT:
93         *last = '\0';
94 }
95
96 int
97 sata_bus_softreset (int num)
98 {
99         u8 dev = 0, status = 0, i;
100
101         port[num].dev_mask = 0;
102
103         for (i = 0; i < CFG_SATA_DEVS_PER_BUS; i++) {
104                 if (!(sata_devchk (&port[num].ioaddr, i))) {
105                         PRINTF ("dev_chk failed for dev#%d\n", i);
106                 } else {
107                         port[num].dev_mask |= (1 << i);
108                         PRINTF ("dev_chk passed for dev#%d\n", i);
109                 }
110         }
111
112         if (!(port[num].dev_mask)) {
113                 printf ("no devices on port%d\n", num);
114                 return 1;
115         }
116
117         dev_select (&port[num].ioaddr, dev);
118
119         port[num].ctl_reg = 0x08;       /*Default value of control reg */
120         sata_outb (port[num].ctl_reg, port[num].ioaddr.ctl_addr);
121         udelay (10);
122         sata_outb (port[num].ctl_reg | ATA_SRST, port[num].ioaddr.ctl_addr);
123         udelay (10);
124         sata_outb (port[num].ctl_reg, port[num].ioaddr.ctl_addr);
125
126         /* spec mandates ">= 2ms" before checking status.
127          * We wait 150ms, because that was the magic delay used for
128          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
129          * between when the ATA command register is written, and then
130          * status is checked.  Because waiting for "a while" before
131          * checking status is fine, post SRST, we perform this magic
132          * delay here as well.
133          */
134         msleep (150);
135         status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 300);
136         while ((status & ATA_BUSY)) {
137                 msleep (100);
138                 status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 3);
139         }
140
141         if (status & ATA_BUSY)
142                 printf ("ata%u is slow to respond,plz be patient\n", port);
143
144         while ((status & ATA_BUSY)) {
145                 msleep (100);
146                 status = sata_chk_status (&port[num].ioaddr);
147         }
148
149         if (status & ATA_BUSY) {
150                 printf ("ata%u failed to respond : ", port);
151                 printf ("bus reset failed\n");
152                 return 1;
153         }
154         return 0;
155 }
156
157 void
158 sata_identify (int num, int dev)
159 {
160         u8 cmd = 0, status = 0, devno = num * CFG_SATA_DEVS_PER_BUS + dev;
161         u16 iobuf[ATA_SECT_SIZE];
162         u64 n_sectors = 0;
163         u8 mask = 0;
164
165         memset (iobuf, 0, sizeof (iobuf));
166         hd_driveid_t *iop = (hd_driveid_t *) iobuf;
167
168         if (dev == 0)
169                 mask = 0x01;
170         else
171                 mask = 0x02;
172
173         if (!(port[num].dev_mask & mask)) {
174                 printf ("dev%d is not present on port#%d\n", dev, num);
175                 return;
176         }
177
178         printf ("port=%d dev=%d\n", num, dev);
179
180         dev_select (&port[num].ioaddr, dev);
181
182         status = 0;
183         cmd = ATA_CMD_IDENT;    /*Device Identify Command */
184         sata_outb (cmd, port[num].ioaddr.command_addr);
185         sata_inb (port[num].ioaddr.altstatus_addr);
186         udelay (10);
187
188         status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 1000);
189         if (status & ATA_ERR) {
190                 printf ("\ndevice not responding\n");
191                 port[num].dev_mask &= ~mask;
192                 return;
193         }
194
195         input_data (&port[num].ioaddr, (ulong *) iobuf, ATA_SECTORWORDS);
196
197         PRINTF ("\nata%u: dev %u cfg 49:%04x 82:%04x 83:%04x 84:%04x85:%04x"
198                 "86:%04x" "87:%04x 88:%04x\n", num, dev, iobuf[49],
199                 iobuf[82], iobuf[83], iobuf[84], iobuf[85], iobuf[86],
200                 iobuf[87], iobuf[88]);
201
202         /* we require LBA and DMA support (bits 8 & 9 of word 49) */
203         if (!ata_id_has_dma (iobuf) || !ata_id_has_lba (iobuf)) {
204                 PRINTF ("ata%u: no dma/lba\n", num);
205         }
206         ata_dump_id (iobuf);
207
208         if (ata_id_has_lba48 (iobuf)) {
209                 n_sectors = ata_id_u64 (iobuf, 100);
210         } else {
211                 n_sectors = ata_id_u32 (iobuf, 60);
212         }
213         PRINTF ("no. of sectors %u\n", ata_id_u64 (iobuf, 100));
214         PRINTF ("no. of sectors %u\n", ata_id_u32 (iobuf, 60));
215
216         if (n_sectors == 0) {
217                 port[num].dev_mask &= ~mask;
218                 return;
219         }
220
221         sata_cpy (sata_dev_desc[devno].revision, iop->fw_rev,
222                   sizeof (sata_dev_desc[devno].revision));
223         sata_cpy (sata_dev_desc[devno].vendor, iop->model,
224                   sizeof (sata_dev_desc[devno].vendor));
225         sata_cpy (sata_dev_desc[devno].product, iop->serial_no,
226                   sizeof (sata_dev_desc[devno].product));
227         strswab (sata_dev_desc[devno].revision);
228         strswab (sata_dev_desc[devno].vendor);
229
230         if ((iop->config & 0x0080) == 0x0080) {
231                 sata_dev_desc[devno].removable = 1;
232         } else {
233                 sata_dev_desc[devno].removable = 0;
234         }
235
236         sata_dev_desc[devno].lba = iop->lba_capacity;
237         PRINTF ("lba=0x%x", sata_dev_desc[devno].lba);
238
239 #ifdef CONFIG_LBA48
240         if (iop->command_set_2 & 0x0400) {
241                 sata_dev_desc[devno].lba48 = 1;
242                 lba = (unsigned long long) iop->lba48_capacity[0] |
243                     ((unsigned long long) iop->lba48_capacity[1] << 16) |
244                     ((unsigned long long) iop->lba48_capacity[2] << 32) |
245                     ((unsigned long long) iop->lba48_capacity[3] << 48);
246         } else {
247                 sata_dev_desc[devno].lba48 = 0;
248         }
249 #endif
250
251         /* assuming HD */
252         sata_dev_desc[devno].type = DEV_TYPE_HARDDISK;
253         sata_dev_desc[devno].blksz = ATA_BLOCKSIZE;
254         sata_dev_desc[devno].lun = 0;   /* just to fill something in... */
255 }
256
257 void
258 set_Feature_cmd (int num, int dev)
259 {
260         u8 mask = 0x00, status = 0;
261
262         if (dev == 0)
263                 mask = 0x01;
264         else
265                 mask = 0x02;
266
267         if (!(port[num].dev_mask & mask)) {
268                 PRINTF ("dev%d is not present on port#%d\n", dev, num);
269                 return;
270         }
271
272         dev_select (&port[num].ioaddr, dev);
273
274         sata_outb (SETFEATURES_XFER, port[num].ioaddr.feature_addr);
275         sata_outb (XFER_PIO_4, port[num].ioaddr.nsect_addr);
276         sata_outb (0, port[num].ioaddr.lbal_addr);
277         sata_outb (0, port[num].ioaddr.lbam_addr);
278         sata_outb (0, port[num].ioaddr.lbah_addr);
279
280         sata_outb (ATA_DEVICE_OBS, port[num].ioaddr.device_addr);
281         sata_outb (ATA_CMD_SETF, port[num].ioaddr.command_addr);
282
283         udelay (50);
284         msleep (150);
285
286         status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 5000);
287         if ((status & (ATA_STAT_BUSY | ATA_STAT_ERR))) {
288                 printf ("Error  : status 0x%02x\n", status);
289                 port[num].dev_mask &= ~mask;
290         }
291 }
292
293 void
294 sata_port (struct sata_ioports *ioport)
295 {
296         ioport->data_addr = ioport->cmd_addr + ATA_REG_DATA;
297         ioport->error_addr = ioport->cmd_addr + ATA_REG_ERR;
298         ioport->feature_addr = ioport->cmd_addr + ATA_REG_FEATURE;
299         ioport->nsect_addr = ioport->cmd_addr + ATA_REG_NSECT;
300         ioport->lbal_addr = ioport->cmd_addr + ATA_REG_LBAL;
301         ioport->lbam_addr = ioport->cmd_addr + ATA_REG_LBAM;
302         ioport->lbah_addr = ioport->cmd_addr + ATA_REG_LBAH;
303         ioport->device_addr = ioport->cmd_addr + ATA_REG_DEVICE;
304         ioport->status_addr = ioport->cmd_addr + ATA_REG_STATUS;
305         ioport->command_addr = ioport->cmd_addr + ATA_REG_CMD;
306 }
307
308 int
309 sata_devchk (struct sata_ioports *ioaddr, int dev)
310 {
311         u8 nsect, lbal;
312
313         dev_select (ioaddr, dev);
314
315         sata_outb (0x55, ioaddr->nsect_addr);
316         sata_outb (0xaa, ioaddr->lbal_addr);
317
318         sata_outb (0xaa, ioaddr->nsect_addr);
319         sata_outb (0x55, ioaddr->lbal_addr);
320
321         sata_outb (0x55, ioaddr->nsect_addr);
322         sata_outb (0xaa, ioaddr->lbal_addr);
323
324         nsect = sata_inb (ioaddr->nsect_addr);
325         lbal = sata_inb (ioaddr->lbal_addr);
326
327         if ((nsect == 0x55) && (lbal == 0xaa))
328                 return 1;       /* we found a device */
329         else
330                 return 0;       /* nothing found */
331 }
332
333 void
334 dev_select (struct sata_ioports *ioaddr, int dev)
335 {
336         u8 tmp = 0;
337
338         if (dev == 0)
339                 tmp = ATA_DEVICE_OBS;
340         else
341                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
342
343         sata_outb (tmp, ioaddr->device_addr);
344         sata_inb (ioaddr->altstatus_addr);
345         udelay (5);
346 }
347
348 u8
349 sata_busy_wait (struct sata_ioports *ioaddr, int bits, unsigned int max)
350 {
351         u8 status;
352
353         do {
354                 udelay (1000);
355                 status = sata_chk_status (ioaddr);
356                 max--;
357         } while ((status & bits) && (max > 0));
358
359         return status;
360 }
361
362 u8
363 sata_chk_status (struct sata_ioports * ioaddr)
364 {
365         return sata_inb (ioaddr->status_addr);
366 }
367
368 void
369 msleep (int count)
370 {
371         int i;
372
373         for (i = 0; i < count; i++)
374                 udelay (1000);
375 }
376
377 ulong
378 sata_read (int device, ulong blknr,lbaint_t blkcnt, void * buff)
379 {
380         ulong n = 0, *buffer = (ulong *)buff;
381         u8 dev = 0, num = 0, mask = 0, status = 0;
382
383 #ifdef CONFIG_LBA48
384         unsigned char lba48 = 0;
385
386         if (blknr & 0x0000fffff0000000) {
387                 if (!sata_dev_desc[devno].lba48) {
388                         printf ("Drive doesn't support 48-bit addressing\n");
389                         return 0;
390                 }
391                 /* more than 28 bits used, use 48bit mode */
392                 lba48 = 1;
393         }
394 #endif
395         /*Port Number */
396         num = device / CFG_SATA_DEVS_PER_BUS;
397         /*dev on the port */
398         if (device >= CFG_SATA_DEVS_PER_BUS)
399                 dev = device - CFG_SATA_DEVS_PER_BUS;
400         else
401                 dev = device;
402
403         if (dev == 0)
404                 mask = 0x01;
405         else
406                 mask = 0x02;
407
408         if (!(port[num].dev_mask & mask)) {
409                 printf ("dev%d is not present on port#%d\n", dev, num);
410                 return 0;
411         }
412
413         /* Select device */
414         dev_select (&port[num].ioaddr, dev);
415
416         status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
417         if (status & ATA_BUSY) {
418                 printf ("ata%u failed to respond\n", port[num].port_no);
419                 return n;
420         }
421         while (blkcnt-- > 0) {
422                 status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
423                 if (status & ATA_BUSY) {
424                         printf ("ata%u failed to respond\n", 0);
425                         return n;
426                 }
427 #ifdef CONFIG_LBA48
428                 if (lba48) {
429                         /* write high bits */
430                         sata_outb (0, port[num].ioaddr.nsect_addr);
431                         sata_outb ((blknr >> 24) & 0xFF,
432                                    port[num].ioaddr.lbal_addr);
433                         sata_outb ((blknr >> 32) & 0xFF,
434                                    port[num].ioaddr.lbam_addr);
435                         sata_outb ((blknr >> 40) & 0xFF,
436                                    port[num].ioaddr.lbah_addr);
437                 }
438 #endif
439                 sata_outb (1, port[num].ioaddr.nsect_addr);
440                 sata_outb (((blknr) >> 0) & 0xFF,
441                            port[num].ioaddr.lbal_addr);
442                 sata_outb ((blknr >> 8) & 0xFF, port[num].ioaddr.lbam_addr);
443                 sata_outb ((blknr >> 16) & 0xFF, port[num].ioaddr.lbah_addr);
444
445 #ifdef CONFIG_LBA48
446                 if (lba48) {
447                         sata_outb (ATA_LBA, port[num].ioaddr.device_addr);
448                         sata_outb (ATA_CMD_READ_EXT,
449                                    port[num].ioaddr.command_addr);
450                 } else
451 #endif
452                 {
453                         sata_outb (ATA_LBA | ((blknr >> 24) & 0xF),
454                                    port[num].ioaddr.device_addr);
455                         sata_outb (ATA_CMD_READ,
456                                    port[num].ioaddr.command_addr);
457                 }
458
459                 msleep (50);
460                 /*may take up to 4 sec */
461                 status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 4000);
462
463                 if ((status & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR))
464                     != ATA_STAT_DRQ) {
465                         u8 err = 0;
466
467                         printf ("Error no DRQ dev %d blk %ld: sts 0x%02x\n",
468                                 device, (ulong) blknr, status);
469                         err = sata_inb (port[num].ioaddr.error_addr);
470                         printf ("Error reg = 0x%x\n", err);
471                         return (n);
472                 }
473                 input_data (&port[num].ioaddr, buffer, ATA_SECTORWORDS);
474                 sata_inb (port[num].ioaddr.altstatus_addr);
475                 udelay (50);
476
477                 ++n;
478                 ++blknr;
479                 buffer += ATA_SECTORWORDS;
480         }
481         return n;
482 }
483
484 ulong
485 sata_write (int device, ulong blknr,lbaint_t blkcnt, void * buff)
486 {
487         ulong n = 0, *buffer = (ulong *)buff;
488         unsigned char status = 0, num = 0, dev = 0, mask = 0;
489
490 #ifdef CONFIG_LBA48
491         unsigned char lba48 = 0;
492
493         if (blknr & 0x0000fffff0000000) {
494                 if (!sata_dev_desc[devno].lba48) {
495                         printf ("Drive doesn't support 48-bit addressing\n");
496                         return 0;
497                 }
498                 /* more than 28 bits used, use 48bit mode */
499                 lba48 = 1;
500         }
501 #endif
502         /*Port Number */
503         num = device / CFG_SATA_DEVS_PER_BUS;
504         /*dev on the Port */
505         if (device >= CFG_SATA_DEVS_PER_BUS)
506                 dev = device - CFG_SATA_DEVS_PER_BUS;
507         else
508                 dev = device;
509
510         if (dev == 0)
511                 mask = 0x01;
512         else
513                 mask = 0x02;
514
515         /* Select device */
516         dev_select (&port[num].ioaddr, dev);
517
518         status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
519         if (status & ATA_BUSY) {
520                 printf ("ata%u failed to respond\n", port[num].port_no);
521                 return n;
522         }
523
524         while (blkcnt-- > 0) {
525                 status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 500);
526                 if (status & ATA_BUSY) {
527                         printf ("ata%u failed to respond\n",
528                                 port[num].port_no);
529                         return n;
530                 }
531 #ifdef CONFIG_LBA48
532                 if (lba48) {
533                         /* write high bits */
534                         sata_outb (0, port[num].ioaddr.nsect_addr);
535                         sata_outb ((blknr >> 24) & 0xFF,
536                                    port[num].ioaddr.lbal_addr);
537                         sata_outb ((blknr >> 32) & 0xFF,
538                                    port[num].ioaddr.lbam_addr);
539                         sata_outb ((blknr >> 40) & 0xFF,
540                                    port[num].ioaddr.lbah_addr);
541                 }
542 #endif
543                 sata_outb (1, port[num].ioaddr.nsect_addr);
544                 sata_outb ((blknr >> 0) & 0xFF, port[num].ioaddr.lbal_addr);
545                 sata_outb ((blknr >> 8) & 0xFF, port[num].ioaddr.lbam_addr);
546                 sata_outb ((blknr >> 16) & 0xFF, port[num].ioaddr.lbah_addr);
547 #ifdef CONFIG_LBA48
548                 if (lba48) {
549                         sata_outb (ATA_LBA, port[num].ioaddr.device_addr);
550                         sata_outb (ATA_CMD_WRITE_EXT,
551                                    port[num].ioaddr.command_addr);
552                 } else
553 #endif
554                 {
555                         sata_outb (ATA_LBA | ((blknr >> 24) & 0xF),
556                                    port[num].ioaddr.device_addr);
557                         sata_outb (ATA_CMD_WRITE,
558                                    port[num].ioaddr.command_addr);
559                 }
560
561                 msleep (50);
562                 /*may take up to 4 sec */
563                 status = sata_busy_wait (&port[num].ioaddr, ATA_BUSY, 4000);
564                 if ((status & (ATA_STAT_DRQ | ATA_STAT_BUSY | ATA_STAT_ERR))
565                     != ATA_STAT_DRQ) {
566                         printf ("Error no DRQ dev %d blk %ld: sts 0x%02x\n",
567                                 device, (ulong) blknr, status);
568                         return (n);
569                 }
570
571                 output_data (&port[num].ioaddr, buffer, ATA_SECTORWORDS);
572                 sata_inb (port[num].ioaddr.altstatus_addr);
573                 udelay (50);
574
575                 ++n;
576                 ++blknr;
577                 buffer += ATA_SECTORWORDS;
578         }
579         return n;
580 }
581
582 block_dev_desc_t *sata_get_dev (int dev);
583
584 block_dev_desc_t *
585 sata_get_dev (int dev)
586 {
587         return ((block_dev_desc_t *) & sata_dev_desc[dev]);
588 }
589
590 int
591 do_sata (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
592 {
593
594         switch (argc) {
595         case 0:
596         case 1:
597                 printf ("Usage:\n%s\n", cmdtp->usage);
598                 return 1;
599         case 2:
600                 if (strncmp (argv[1], "init", 4) == 0) {
601                         int rcode = 0;
602
603                         rcode = init_sata ();
604                         if (rcode)
605                                 printf ("Sata initialization Failed\n");
606                         return rcode;
607                 } else if (strncmp (argv[1], "inf", 3) == 0) {
608                         int i;
609
610                         putc ('\n');
611                         for (i = 0; i < CFG_SATA_MAXDEVICES; ++i) {
612                                 /*List only known devices */
613                                 if (sata_dev_desc[i].type ==
614                                     DEV_TYPE_UNKNOWN)
615                                         continue;
616                                 printf ("sata dev %d: ", i);
617                                 dev_print (&sata_dev_desc[i]);
618                         }
619                         return 0;
620                 }
621                 printf ("Usage:\n%s\n", cmdtp->usage);
622                 return 1;
623         case 3:
624                 if (strcmp (argv[1], "dev") == 0) {
625                         int dev = (int) simple_strtoul (argv[2], NULL, 10);
626
627                         if (dev >= CFG_SATA_MAXDEVICES) {
628                                 printf ("\nSata dev %d not available\n",
629                                         dev);
630                                 return 1;
631                         }
632                         printf ("\nSATA dev %d: ", dev);
633                         dev_print (&sata_dev_desc[dev]);
634                         if (sata_dev_desc[dev].type == DEV_TYPE_UNKNOWN)
635                                 return 1;
636                         curr_dev = dev;
637                         return 0;
638                 } else if (strcmp (argv[1], "part") == 0) {
639                         int dev = (int) simple_strtoul (argv[2], NULL, 10);
640
641                         if (dev >= CFG_SATA_MAXDEVICES) {
642                                 printf ("\nSata dev %d not available\n",
643                                         dev);
644                                 return 1;
645                         }
646                         PRINTF ("\nSATA dev %d: ", dev);
647                         if (sata_dev_desc[dev].part_type !=
648                             PART_TYPE_UNKNOWN) {
649                                 print_part (&sata_dev_desc[dev]);
650                         } else {
651                                 printf ("\nSata dev %d partition type "
652                                         "unknown\n", dev);
653                                 return 1;
654                         }
655                         return 0;
656                 }
657                 printf ("Usage:\n%s\n", cmdtp->usage);
658                 return 1;
659         default:
660                 if (argc < 5) {
661                         printf ("Usage:\n%s\n", cmdtp->usage);
662                         return 1;
663                 }
664                 if (strcmp (argv[1], "read") == 0) {
665                         ulong addr = simple_strtoul (argv[2], NULL, 16);
666                         ulong cnt = simple_strtoul (argv[4], NULL, 16);
667                         ulong n;
668                         lbaint_t blk = simple_strtoul (argv[3], NULL, 16);
669
670                         memset ((int *) addr, 0, cnt * 512);
671                         printf ("\nSATA read: dev %d blk # %ld,"
672                                 "count %ld ... ", curr_dev, blk, cnt);
673                         n = sata_read (curr_dev, blk, cnt, (ulong *) addr);
674                         /* flush cache after read */
675                         flush_cache (addr, cnt * 512);
676                         printf ("%ld blocks read: %s\n", n,
677                                 (n == cnt) ? "OK" : "ERR");
678                         if (n == cnt)
679                                 return 1;
680                         else
681                                 return 0;
682                 } else if (strcmp (argv[1], "write") == 0) {
683                         ulong addr = simple_strtoul (argv[2], NULL, 16);
684                         ulong cnt = simple_strtoul (argv[4], NULL, 16);
685                         ulong n;
686                         lbaint_t blk = simple_strtoul (argv[3], NULL, 16);
687
688                         printf ("\nSata write: dev %d blk # %ld,"
689                                 "count %ld ... ", curr_dev, blk, cnt);
690                         n = sata_write (curr_dev, blk, cnt, (ulong *) addr);
691                         printf ("%ld blocks written: %s\n", n,
692                                 (n == cnt) ? "OK" : "ERR");
693                         if (n == cnt)
694                                 return 1;
695                         else
696                                 return 0;
697                 } else {
698                         printf ("Usage:\n%s\n", cmdtp->usage);
699                         return 1;
700                 }
701         }                       /*End OF SWITCH */
702 }
703
704 U_BOOT_CMD (sata, 5, 1, do_sata,
705             "sata init\n"
706             "sata info\n"
707             "sata part device\n"
708             "sata dev device\n"
709             "sata read  addr blk# cnt\n"
710             "sata write  addr blk# cnt\n", "cmd for init,rw and dev-info\n");
711
712 #endif