]> git.sur5r.net Git - u-boot/blob - drivers/ata/sata_sil.c
Merge git://git.denx.de/u-boot-tegra
[u-boot] / drivers / ata / sata_sil.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2011 Freescale Semiconductor, Inc.
4  * Author: Tang Yuantian <b29983@freescale.com>
5  */
6
7 #include <common.h>
8 #include <pci.h>
9 #include <command.h>
10 #include <asm/byteorder.h>
11 #include <malloc.h>
12 #include <asm/io.h>
13 #include <fis.h>
14 #include <sata.h>
15 #include <libata.h>
16 #include <sata.h>
17 #include "sata_sil.h"
18
19 /* Convert sectorsize to wordsize */
20 #define ATA_SECTOR_WORDS (ATA_SECT_SIZE/2)
21 #define virt_to_bus(devno, v)   pci_virt_to_mem(devno, (void *) (v))
22
23 static struct sata_info sata_info;
24
25 static struct pci_device_id supported[] = {
26         {PCI_VENDOR_ID_SILICONIMAGE, PCI_DEVICE_ID_SIL3131},
27         {PCI_VENDOR_ID_SILICONIMAGE, PCI_DEVICE_ID_SIL3132},
28         {PCI_VENDOR_ID_SILICONIMAGE, PCI_DEVICE_ID_SIL3124},
29         {}
30 };
31
32 static void sil_sata_dump_fis(struct sata_fis_d2h *s)
33 {
34         printf("Status FIS dump:\n");
35         printf("fis_type:               %02x\n", s->fis_type);
36         printf("pm_port_i:              %02x\n", s->pm_port_i);
37         printf("status:                 %02x\n", s->status);
38         printf("error:                  %02x\n", s->error);
39         printf("lba_low:                %02x\n", s->lba_low);
40         printf("lba_mid:                %02x\n", s->lba_mid);
41         printf("lba_high:               %02x\n", s->lba_high);
42         printf("device:                 %02x\n", s->device);
43         printf("lba_low_exp:            %02x\n", s->lba_low_exp);
44         printf("lba_mid_exp:            %02x\n", s->lba_mid_exp);
45         printf("lba_high_exp:           %02x\n", s->lba_high_exp);
46         printf("res1:                   %02x\n", s->res1);
47         printf("sector_count:           %02x\n", s->sector_count);
48         printf("sector_count_exp:       %02x\n", s->sector_count_exp);
49 }
50
51 static const char *sata_spd_string(unsigned int speed)
52 {
53         static const char * const spd_str[] = {
54                 "1.5 Gbps",
55                 "3.0 Gbps",
56                 "6.0 Gbps",
57         };
58
59         if ((speed - 1) > 2)
60                 return "<unknown>";
61
62         return spd_str[speed - 1];
63 }
64
65 static u32 ata_wait_register(void *reg, u32 mask,
66                          u32 val, int timeout_msec)
67 {
68         u32 tmp;
69
70         tmp = readl(reg);
71         while ((tmp & mask) == val && timeout_msec > 0) {
72                 mdelay(1);
73                 timeout_msec--;
74                 tmp = readl(reg);
75         }
76
77         return tmp;
78 }
79
80 static void sil_config_port(void *port)
81 {
82         /* configure IRQ WoC */
83         writel(PORT_CS_IRQ_WOC, port + PORT_CTRL_CLR);
84
85         /* zero error counters. */
86         writew(0x8000, port + PORT_DECODE_ERR_THRESH);
87         writew(0x8000, port + PORT_CRC_ERR_THRESH);
88         writew(0x8000, port + PORT_HSHK_ERR_THRESH);
89         writew(0x0000, port + PORT_DECODE_ERR_CNT);
90         writew(0x0000, port + PORT_CRC_ERR_CNT);
91         writew(0x0000, port + PORT_HSHK_ERR_CNT);
92
93         /* always use 64bit activation */
94         writel(PORT_CS_32BIT_ACTV, port + PORT_CTRL_CLR);
95
96         /* clear port multiplier enable and resume bits */
97         writel(PORT_CS_PMP_EN | PORT_CS_PMP_RESUME, port + PORT_CTRL_CLR);
98 }
99
100 static int sil_init_port(void *port)
101 {
102         u32 tmp;
103
104         writel(PORT_CS_INIT, port + PORT_CTRL_STAT);
105         ata_wait_register(port + PORT_CTRL_STAT,
106                           PORT_CS_INIT, PORT_CS_INIT, 100);
107         tmp = ata_wait_register(port + PORT_CTRL_STAT,
108                                 PORT_CS_RDY, 0, 100);
109
110         if ((tmp & (PORT_CS_INIT | PORT_CS_RDY)) != PORT_CS_RDY)
111                 return 1;
112
113         return 0;
114 }
115
116 static void sil_read_fis(int dev, int tag, struct sata_fis_d2h *fis)
117 {
118         struct sil_sata *sata = sata_dev_desc[dev].priv;
119         void *port = sata->port;
120         struct sil_prb *prb;
121         int i;
122         u32 *src, *dst;
123
124         prb = port + PORT_LRAM + tag * PORT_LRAM_SLOT_SZ;
125         src = (u32 *)&prb->fis;
126         dst = (u32 *)fis;
127         for (i = 0; i < sizeof(struct sata_fis_h2d); i += 4)
128                 *dst++ = readl(src++);
129 }
130
131 static int sil_exec_cmd(int dev, struct sil_cmd_block *pcmd, int tag)
132 {
133         struct sil_sata *sata = sata_dev_desc[dev].priv;
134         void *port = sata->port;
135         u64 paddr = virt_to_bus(sata->devno, pcmd);
136         u32 irq_mask, irq_stat;
137         int rc;
138
139         writel(PORT_IRQ_COMPLETE | PORT_IRQ_ERROR, port + PORT_IRQ_ENABLE_CLR);
140
141         /* better to add momery barrior here */
142         writel((u32)paddr, port + PORT_CMD_ACTIVATE + tag * 8);
143         writel((u64)paddr >> 32, port + PORT_CMD_ACTIVATE + tag * 8 + 4);
144
145         irq_mask = (PORT_IRQ_COMPLETE | PORT_IRQ_ERROR) << PORT_IRQ_RAW_SHIFT;
146         irq_stat = ata_wait_register(port + PORT_IRQ_STAT, irq_mask,
147                         0, 10000);
148
149         /* clear IRQs */
150         writel(irq_mask, port + PORT_IRQ_STAT);
151         irq_stat >>= PORT_IRQ_RAW_SHIFT;
152
153         if (irq_stat & PORT_IRQ_COMPLETE)
154                 rc = 0;
155         else {
156                 /* force port into known state */
157                 sil_init_port(port);
158                 if (irq_stat & PORT_IRQ_ERROR)
159                         rc = 1; /* error */
160                 else
161                         rc = 2; /* busy */
162         }
163
164         return rc;
165 }
166
167 static int sil_cmd_set_feature(int dev)
168 {
169         struct sil_sata *sata = sata_dev_desc[dev].priv;
170         struct sil_cmd_block cmdb, *pcmd = &cmdb;
171         struct sata_fis_d2h fis;
172         u8 udma_cap;
173         int ret;
174
175         memset((void *)&cmdb, 0, sizeof(struct sil_cmd_block));
176         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
177         pcmd->prb.fis.pm_port_c = (1 << 7);
178         pcmd->prb.fis.command = ATA_CMD_SET_FEATURES;
179         pcmd->prb.fis.features = SETFEATURES_XFER;
180
181         /* First check the device capablity */
182         udma_cap = (u8)(sata->udma & 0xff);
183         debug("udma_cap %02x\n", udma_cap);
184
185         if (udma_cap == ATA_UDMA6)
186                 pcmd->prb.fis.sector_count = XFER_UDMA_6;
187         if (udma_cap == ATA_UDMA5)
188                 pcmd->prb.fis.sector_count = XFER_UDMA_5;
189         if (udma_cap == ATA_UDMA4)
190                 pcmd->prb.fis.sector_count = XFER_UDMA_4;
191         if (udma_cap == ATA_UDMA3)
192                 pcmd->prb.fis.sector_count = XFER_UDMA_3;
193
194         ret = sil_exec_cmd(dev, pcmd, 0);
195         if (ret) {
196                 sil_read_fis(dev, 0, &fis);
197                 printf("Err: exe cmd(0x%x).\n",
198                                 readl(sata->port + PORT_SERROR));
199                 sil_sata_dump_fis(&fis);
200                 return 1;
201         }
202
203         return 0;
204 }
205
206 static int sil_cmd_identify_device(int dev, u16 *id)
207 {
208         struct sil_sata *sata = sata_dev_desc[dev].priv;
209         struct sil_cmd_block cmdb, *pcmd = &cmdb;
210         struct sata_fis_d2h fis;
211         int ret;
212
213         memset((void *)&cmdb, 0, sizeof(struct sil_cmd_block));
214         pcmd->prb.ctrl = cpu_to_le16(PRB_CTRL_PROTOCOL);
215         pcmd->prb.prot = cpu_to_le16(PRB_PROT_READ);
216         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
217         pcmd->prb.fis.pm_port_c = (1 << 7);
218         pcmd->prb.fis.command = ATA_CMD_ID_ATA;
219         pcmd->sge.addr = cpu_to_le64(virt_to_bus(sata->devno, id));
220         pcmd->sge.cnt = cpu_to_le32(sizeof(id[0]) * ATA_ID_WORDS);
221         pcmd->sge.flags = cpu_to_le32(SGE_TRM);
222
223         ret = sil_exec_cmd(dev, pcmd, 0);
224         if (ret) {
225                 sil_read_fis(dev, 0, &fis);
226                 printf("Err: id cmd(0x%x).\n", readl(sata->port + PORT_SERROR));
227                 sil_sata_dump_fis(&fis);
228                 return 1;
229         }
230         ata_swap_buf_le16(id, ATA_ID_WORDS);
231
232         return 0;
233 }
234
235 static int sil_cmd_soft_reset(int dev)
236 {
237         struct sil_cmd_block cmdb, *pcmd = &cmdb;
238         struct sil_sata *sata = sata_dev_desc[dev].priv;
239         struct sata_fis_d2h fis;
240         void *port = sata->port;
241         int ret;
242
243         /* put the port into known state */
244         if (sil_init_port(port)) {
245                 printf("SRST: port %d not ready\n", dev);
246                 return 1;
247         }
248
249         memset((void *)&cmdb, 0, sizeof(struct sil_cmd_block));
250
251         pcmd->prb.ctrl = cpu_to_le16(PRB_CTRL_SRST);
252         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
253         pcmd->prb.fis.pm_port_c = 0xf;
254
255         ret = sil_exec_cmd(dev, &cmdb, 0);
256         if (ret) {
257                 sil_read_fis(dev, 0, &fis);
258                 printf("SRST cmd error.\n");
259                 sil_sata_dump_fis(&fis);
260                 return 1;
261         }
262
263         return 0;
264 }
265
266 static ulong sil_sata_rw_cmd(int dev, ulong start, ulong blkcnt,
267                 u8 *buffer, int is_write)
268 {
269         struct sil_sata *sata = sata_dev_desc[dev].priv;
270         struct sil_cmd_block cmdb, *pcmd = &cmdb;
271         struct sata_fis_d2h fis;
272         u64 block;
273         int ret;
274
275         block = (u64)start;
276         memset(pcmd, 0, sizeof(struct sil_cmd_block));
277         pcmd->prb.ctrl = cpu_to_le16(PRB_CTRL_PROTOCOL);
278         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
279         pcmd->prb.fis.pm_port_c = (1 << 7);
280         if (is_write) {
281                 pcmd->prb.fis.command = ATA_CMD_WRITE;
282                 pcmd->prb.prot = cpu_to_le16(PRB_PROT_WRITE);
283         } else {
284                 pcmd->prb.fis.command = ATA_CMD_READ;
285                 pcmd->prb.prot = cpu_to_le16(PRB_PROT_READ);
286         }
287
288         pcmd->prb.fis.device = ATA_LBA;
289         pcmd->prb.fis.device |= (block >> 24) & 0xf;
290         pcmd->prb.fis.lba_high = (block >> 16) & 0xff;
291         pcmd->prb.fis.lba_mid = (block >> 8) & 0xff;
292         pcmd->prb.fis.lba_low = block & 0xff;
293         pcmd->prb.fis.sector_count = (u8)blkcnt & 0xff;
294
295         pcmd->sge.addr = cpu_to_le64(virt_to_bus(sata->devno, buffer));
296         pcmd->sge.cnt = cpu_to_le32(blkcnt * ATA_SECT_SIZE);
297         pcmd->sge.flags = cpu_to_le32(SGE_TRM);
298
299         ret = sil_exec_cmd(dev, pcmd, 0);
300         if (ret) {
301                 sil_read_fis(dev, 0, &fis);
302                 printf("Err: rw cmd(0x%08x).\n",
303                                 readl(sata->port + PORT_SERROR));
304                 sil_sata_dump_fis(&fis);
305                 return 1;
306         }
307
308         return blkcnt;
309 }
310
311 static ulong sil_sata_rw_cmd_ext(int dev, ulong start, ulong blkcnt,
312                 u8 *buffer, int is_write)
313 {
314         struct sil_sata *sata = sata_dev_desc[dev].priv;
315         struct sil_cmd_block cmdb, *pcmd = &cmdb;
316         struct sata_fis_d2h fis;
317         u64 block;
318         int ret;
319
320         block = (u64)start;
321         memset(pcmd, 0, sizeof(struct sil_cmd_block));
322         pcmd->prb.ctrl = cpu_to_le16(PRB_CTRL_PROTOCOL);
323         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
324         pcmd->prb.fis.pm_port_c = (1 << 7);
325         if (is_write) {
326                 pcmd->prb.fis.command = ATA_CMD_WRITE_EXT;
327                 pcmd->prb.prot = cpu_to_le16(PRB_PROT_WRITE);
328         } else {
329                 pcmd->prb.fis.command = ATA_CMD_READ_EXT;
330                 pcmd->prb.prot = cpu_to_le16(PRB_PROT_READ);
331         }
332
333         pcmd->prb.fis.lba_high_exp = (block >> 40) & 0xff;
334         pcmd->prb.fis.lba_mid_exp = (block >> 32) & 0xff;
335         pcmd->prb.fis.lba_low_exp = (block >> 24) & 0xff;
336         pcmd->prb.fis.lba_high = (block >> 16) & 0xff;
337         pcmd->prb.fis.lba_mid = (block >> 8) & 0xff;
338         pcmd->prb.fis.lba_low = block & 0xff;
339         pcmd->prb.fis.device = ATA_LBA;
340         pcmd->prb.fis.sector_count_exp = (blkcnt >> 8) & 0xff;
341         pcmd->prb.fis.sector_count = blkcnt & 0xff;
342
343         pcmd->sge.addr = cpu_to_le64(virt_to_bus(sata->devno, buffer));
344         pcmd->sge.cnt = cpu_to_le32(blkcnt * ATA_SECT_SIZE);
345         pcmd->sge.flags = cpu_to_le32(SGE_TRM);
346
347         ret = sil_exec_cmd(dev, pcmd, 0);
348         if (ret) {
349                 sil_read_fis(dev, 0, &fis);
350                 printf("Err: rw ext cmd(0x%08x).\n",
351                                 readl(sata->port + PORT_SERROR));
352                 sil_sata_dump_fis(&fis);
353                 return 1;
354         }
355
356         return blkcnt;
357 }
358
359 static ulong sil_sata_rw_lba28(int dev, ulong blknr, lbaint_t blkcnt,
360                                const void *buffer, int is_write)
361 {
362         ulong start, blks, max_blks;
363         u8 *addr;
364
365         start = blknr;
366         blks = blkcnt;
367         addr = (u8 *)buffer;
368
369         max_blks = ATA_MAX_SECTORS;
370         do {
371                 if (blks > max_blks) {
372                         sil_sata_rw_cmd(dev, start, max_blks, addr, is_write);
373                         start += max_blks;
374                         blks -= max_blks;
375                         addr += ATA_SECT_SIZE * max_blks;
376                 } else {
377                         sil_sata_rw_cmd(dev, start, blks, addr, is_write);
378                         start += blks;
379                         blks = 0;
380                         addr += ATA_SECT_SIZE * blks;
381                 }
382         } while (blks != 0);
383
384         return blkcnt;
385 }
386
387 static ulong sil_sata_rw_lba48(int dev, ulong blknr, lbaint_t blkcnt,
388                                const void *buffer, int is_write)
389 {
390         ulong start, blks, max_blks;
391         u8 *addr;
392
393         start = blknr;
394         blks = blkcnt;
395         addr = (u8 *)buffer;
396
397         max_blks = ATA_MAX_SECTORS_LBA48;
398         do {
399                 if (blks > max_blks) {
400                         sil_sata_rw_cmd_ext(dev, start, max_blks,
401                                         addr, is_write);
402                         start += max_blks;
403                         blks -= max_blks;
404                         addr += ATA_SECT_SIZE * max_blks;
405                 } else {
406                         sil_sata_rw_cmd_ext(dev, start, blks,
407                                         addr, is_write);
408                         start += blks;
409                         blks = 0;
410                         addr += ATA_SECT_SIZE * blks;
411                 }
412         } while (blks != 0);
413
414         return blkcnt;
415 }
416
417 static void sil_sata_cmd_flush_cache(int dev)
418 {
419         struct sil_cmd_block cmdb, *pcmd = &cmdb;
420
421         memset((void *)pcmd, 0, sizeof(struct sil_cmd_block));
422         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
423         pcmd->prb.fis.pm_port_c = (1 << 7);
424         pcmd->prb.fis.command = ATA_CMD_FLUSH;
425
426         sil_exec_cmd(dev, pcmd, 0);
427 }
428
429 static void sil_sata_cmd_flush_cache_ext(int dev)
430 {
431         struct sil_cmd_block cmdb, *pcmd = &cmdb;
432
433         memset((void *)pcmd, 0, sizeof(struct sil_cmd_block));
434         pcmd->prb.fis.fis_type = SATA_FIS_TYPE_REGISTER_H2D;
435         pcmd->prb.fis.pm_port_c = (1 << 7);
436         pcmd->prb.fis.command = ATA_CMD_FLUSH_EXT;
437
438         sil_exec_cmd(dev, pcmd, 0);
439 }
440
441 static void sil_sata_init_wcache(int dev, u16 *id)
442 {
443         struct sil_sata *sata = sata_dev_desc[dev].priv;
444
445         if (ata_id_has_wcache(id) && ata_id_wcache_enabled(id))
446                 sata->wcache = 1;
447         if (ata_id_has_flush(id))
448                 sata->flush = 1;
449         if (ata_id_has_flush_ext(id))
450                 sata->flush_ext = 1;
451 }
452
453 static int sil_sata_get_wcache(int dev)
454 {
455         struct sil_sata *sata = sata_dev_desc[dev].priv;
456
457         return sata->wcache;
458 }
459
460 static int sil_sata_get_flush(int dev)
461 {
462         struct sil_sata *sata = sata_dev_desc[dev].priv;
463
464         return sata->flush;
465 }
466
467 static int sil_sata_get_flush_ext(int dev)
468 {
469         struct sil_sata *sata = sata_dev_desc[dev].priv;
470
471         return sata->flush_ext;
472 }
473
474 /*
475  * SATA interface between low level driver and command layer
476  */
477 ulong sata_read(int dev, ulong blknr, lbaint_t blkcnt, void *buffer)
478 {
479         struct sil_sata *sata = sata_dev_desc[dev].priv;
480         ulong rc;
481
482         if (sata->lba48)
483                 rc = sil_sata_rw_lba48(dev, blknr, blkcnt, buffer, READ_CMD);
484         else
485                 rc = sil_sata_rw_lba28(dev, blknr, blkcnt, buffer, READ_CMD);
486
487         return rc;
488 }
489
490 /*
491  * SATA interface between low level driver and command layer
492  */
493 ulong sata_write(int dev, ulong blknr, lbaint_t blkcnt, const void *buffer)
494 {
495         struct sil_sata *sata = sata_dev_desc[dev].priv;
496         ulong rc;
497
498         if (sata->lba48) {
499                 rc = sil_sata_rw_lba48(dev, blknr, blkcnt, buffer, WRITE_CMD);
500                 if (sil_sata_get_wcache(dev) && sil_sata_get_flush_ext(dev))
501                         sil_sata_cmd_flush_cache_ext(dev);
502         } else {
503                 rc = sil_sata_rw_lba28(dev, blknr, blkcnt, buffer, WRITE_CMD);
504                 if (sil_sata_get_wcache(dev) && sil_sata_get_flush(dev))
505                         sil_sata_cmd_flush_cache(dev);
506         }
507
508         return rc;
509 }
510
511 /*
512  * SATA interface between low level driver and command layer
513  */
514 int init_sata(int dev)
515 {
516         static int init_done, idx;
517         pci_dev_t devno;
518         u16 word;
519
520         if (init_done == 1 && dev < sata_info.maxport)
521                 return 0;
522
523         init_done = 1;
524
525         /* Find PCI device(s) */
526         devno = pci_find_devices(supported, idx++);
527         if (devno == -1)
528                 return 1;
529
530         pci_read_config_word(devno, PCI_DEVICE_ID, &word);
531
532         /* get the port count */
533         word &= 0xf;
534
535         sata_info.portbase = sata_info.maxport;
536         sata_info.maxport = sata_info.portbase + word;
537         sata_info.devno = devno;
538
539         /* Read out all BARs */
540         sata_info.iobase[0] = (ulong)pci_map_bar(devno,
541                         PCI_BASE_ADDRESS_0, PCI_REGION_MEM);
542         sata_info.iobase[1] = (ulong)pci_map_bar(devno,
543                         PCI_BASE_ADDRESS_2, PCI_REGION_MEM);
544         sata_info.iobase[2] = (ulong)pci_map_bar(devno,
545                         PCI_BASE_ADDRESS_4, PCI_REGION_MEM);
546
547         /* mask out the unused bits */
548         sata_info.iobase[0] &= 0xffffff80;
549         sata_info.iobase[1] &= 0xfffffc00;
550         sata_info.iobase[2] &= 0xffffff80;
551
552         /* Enable Bus Mastering and memory region */
553         pci_write_config_word(devno, PCI_COMMAND,
554                         PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
555
556         /* Check if mem accesses and Bus Mastering are enabled. */
557         pci_read_config_word(devno, PCI_COMMAND, &word);
558         if (!(word & PCI_COMMAND_MEMORY) ||
559                         (!(word & PCI_COMMAND_MASTER))) {
560                 printf("Error: Can not enable MEM access or Bus Mastering.\n");
561                 debug("PCI command: %04x\n", word);
562                 return 1;
563         }
564
565         /* GPIO off */
566         writel(0, (void *)(sata_info.iobase[0] + HOST_FLASH_CMD));
567         /* clear global reset & mask interrupts during initialization */
568         writel(0, (void *)(sata_info.iobase[0] + HOST_CTRL));
569
570         return 0;
571 }
572
573 int reset_sata(int dev)
574 {
575         return 0;
576 }
577
578 /*
579  * SATA interface between low level driver and command layer
580  */
581 int scan_sata(int dev)
582 {
583         unsigned char serial[ATA_ID_SERNO_LEN + 1];
584         unsigned char firmware[ATA_ID_FW_REV_LEN + 1];
585         unsigned char product[ATA_ID_PROD_LEN + 1];
586         struct sil_sata *sata;
587         void *port;
588         int cnt;
589         u16 *id;
590         u32 tmp;
591
592         if (dev >= sata_info.maxport) {
593                 printf("SATA#%d is not present\n", dev);
594                 return 1;
595         }
596
597         printf("SATA#%d\n", dev);
598         port = (void *)sata_info.iobase[1] +
599                 PORT_REGS_SIZE * (dev - sata_info.portbase);
600
601         /* Initial PHY setting */
602         writel(0x20c, port + PORT_PHY_CFG);
603
604         /* clear port RST */
605         tmp = readl(port + PORT_CTRL_STAT);
606         if (tmp & PORT_CS_PORT_RST) {
607                 writel(PORT_CS_PORT_RST, port + PORT_CTRL_CLR);
608                 tmp = ata_wait_register(port + PORT_CTRL_STAT,
609                                 PORT_CS_PORT_RST, PORT_CS_PORT_RST, 100);
610                 if (tmp & PORT_CS_PORT_RST)
611                         printf("Err: Failed to clear port RST\n");
612         }
613
614         /* Check if device is present */
615         for (cnt = 0; cnt < 100; cnt++) {
616                 tmp = readl(port + PORT_SSTATUS);
617                 if ((tmp & 0xF) == 0x3)
618                         break;
619                 mdelay(1);
620         }
621
622         tmp = readl(port + PORT_SSTATUS);
623         if ((tmp & 0xf) != 0x3) {
624                 printf("        (No RDY)\n");
625                 return 1;
626         }
627
628         /* Wait for port ready */
629         tmp = ata_wait_register(port + PORT_CTRL_STAT,
630                                 PORT_CS_RDY, PORT_CS_RDY, 100);
631         if ((tmp & PORT_CS_RDY) != PORT_CS_RDY) {
632                 printf("%d port not ready.\n", dev);
633                 return 1;
634         }
635
636         /* configure port */
637         sil_config_port(port);
638
639         /* Reset port */
640         writel(PORT_CS_DEV_RST, port + PORT_CTRL_STAT);
641         readl(port + PORT_CTRL_STAT);
642         tmp = ata_wait_register(port + PORT_CTRL_STAT, PORT_CS_DEV_RST,
643                                 PORT_CS_DEV_RST, 100);
644         if (tmp & PORT_CS_DEV_RST) {
645                 printf("%d port reset failed.\n", dev);
646                 return 1;
647         }
648
649         sata = (struct sil_sata *)malloc(sizeof(struct sil_sata));
650         if (!sata) {
651                 printf("%d no memory.\n", dev);
652                 return 1;
653         }
654         memset((void *)sata, 0, sizeof(struct sil_sata));
655
656         /* turn on port interrupt */
657         tmp = readl((void *)(sata_info.iobase[0] + HOST_CTRL));
658         tmp |= (1 << (dev - sata_info.portbase));
659         writel(tmp, (void *)(sata_info.iobase[0] + HOST_CTRL));
660
661         /* Save the private struct to block device struct */
662         sata_dev_desc[dev].priv = (void *)sata;
663         sata->port = port;
664         sata->devno = sata_info.devno;
665         sprintf(sata->name, "SATA#%d", dev);
666         sil_cmd_soft_reset(dev);
667         tmp = readl(port + PORT_SSTATUS);
668         tmp = (tmp >> 4) & 0xf;
669         printf("        (%s)\n", sata_spd_string(tmp));
670
671         id = (u16 *)malloc(ATA_ID_WORDS * 2);
672         if (!id) {
673                 printf("Id malloc failed\n");
674                 free((void *)sata);
675                 return 1;
676         }
677         sil_cmd_identify_device(dev, id);
678
679 #ifdef CONFIG_LBA48
680         /* Check if support LBA48 */
681         if (ata_id_has_lba48(id)) {
682                 sata_dev_desc[dev].lba48 = 1;
683                 sata->lba48 = 1;
684                 debug("Device supports LBA48\n");
685         } else
686                 debug("Device supports LBA28\n");
687 #endif
688
689         /* Serial number */
690         ata_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
691         memcpy(sata_dev_desc[dev].product, serial, sizeof(serial));
692
693         /* Firmware version */
694         ata_id_c_string(id, firmware, ATA_ID_FW_REV, sizeof(firmware));
695         memcpy(sata_dev_desc[dev].revision, firmware, sizeof(firmware));
696
697         /* Product model */
698         ata_id_c_string(id, product, ATA_ID_PROD, sizeof(product));
699         memcpy(sata_dev_desc[dev].vendor, product, sizeof(product));
700
701         /* Totoal sectors */
702         sata_dev_desc[dev].lba = ata_id_n_sectors(id);
703
704         sil_sata_init_wcache(dev, id);
705         sil_cmd_set_feature(dev);
706
707 #ifdef DEBUG
708         sil_cmd_identify_device(dev, id);
709         ata_dump_id(id);
710 #endif
711         free((void *)id);
712
713         return 0;
714 }