ahci: move link bring-up handling to separate function
[platform/kernel/u-boot.git] / drivers / block / ahci.c
1 /*
2  * Copyright (C) Freescale Semiconductor, Inc. 2006.
3  * Author: Jason Jin<Jason.jin@freescale.com>
4  *         Zhang Wei<wei.zhang@freescale.com>
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  *
8  * with the reference on libata and ahci drvier in kernel
9  */
10 #include <common.h>
11
12 #include <command.h>
13 #include <pci.h>
14 #include <asm/processor.h>
15 #include <asm/errno.h>
16 #include <asm/io.h>
17 #include <malloc.h>
18 #include <scsi.h>
19 #include <ata.h>
20 #include <linux/ctype.h>
21 #include <ahci.h>
22
23 static int ata_io_flush(u8 port);
24
25 struct ahci_probe_ent *probe_ent = NULL;
26 hd_driveid_t *ataid[AHCI_MAX_PORTS];
27
28 #define writel_with_flush(a,b)  do { writel(a,b); readl(b); } while (0)
29
30 /*
31  * Some controllers limit number of blocks they can read/write at once.
32  * Contemporary SSD devices work much faster if the read/write size is aligned
33  * to a power of 2.  Let's set default to 128 and allowing to be overwritten if
34  * needed.
35  */
36 #ifndef MAX_SATA_BLOCKS_READ_WRITE
37 #define MAX_SATA_BLOCKS_READ_WRITE      0x80
38 #endif
39
40 /* Maximum timeouts for each event */
41 #define WAIT_MS_SPINUP  10000
42 #define WAIT_MS_DATAIO  5000
43 #define WAIT_MS_FLUSH   5000
44 #define WAIT_MS_LINKUP  4
45
46 static inline u32 ahci_port_base(u32 base, u32 port)
47 {
48         return base + 0x100 + (port * 0x80);
49 }
50
51
52 static void ahci_setup_port(struct ahci_ioports *port, unsigned long base,
53                             unsigned int port_idx)
54 {
55         base = ahci_port_base(base, port_idx);
56
57         port->cmd_addr = base;
58         port->scr_addr = base + PORT_SCR;
59 }
60
61
62 #define msleep(a) udelay(a * 1000)
63
64 static void ahci_dcache_flush_range(unsigned begin, unsigned len)
65 {
66         const unsigned long start = begin;
67         const unsigned long end = start + len;
68
69         debug("%s: flush dcache: [%#lx, %#lx)\n", __func__, start, end);
70         flush_dcache_range(start, end);
71 }
72
73 /*
74  * SATA controller DMAs to physical RAM.  Ensure data from the
75  * controller is invalidated from dcache; next access comes from
76  * physical RAM.
77  */
78 static void ahci_dcache_invalidate_range(unsigned begin, unsigned len)
79 {
80         const unsigned long start = begin;
81         const unsigned long end = start + len;
82
83         debug("%s: invalidate dcache: [%#lx, %#lx)\n", __func__, start, end);
84         invalidate_dcache_range(start, end);
85 }
86
87 /*
88  * Ensure data for SATA controller is flushed out of dcache and
89  * written to physical memory.
90  */
91 static void ahci_dcache_flush_sata_cmd(struct ahci_ioports *pp)
92 {
93         ahci_dcache_flush_range((unsigned long)pp->cmd_slot,
94                                 AHCI_PORT_PRIV_DMA_SZ);
95 }
96
97 static int waiting_for_cmd_completed(volatile u8 *offset,
98                                      int timeout_msec,
99                                      u32 sign)
100 {
101         int i;
102         u32 status;
103
104         for (i = 0; ((status = readl(offset)) & sign) && i < timeout_msec; i++)
105                 msleep(1);
106
107         return (i < timeout_msec) ? 0 : -1;
108 }
109
110 int __weak ahci_link_up(struct ahci_probe_ent *probe_ent, u8 port)
111 {
112         u32 tmp;
113         int j = 0;
114         u8 *port_mmio = (u8 *)probe_ent->port[port].port_mmio;
115
116         /* 
117          * Bring up SATA link.
118          * SATA link bringup time is usually less than 1 ms; only very
119          * rarely has it taken between 1-2 ms. Never seen it above 2 ms.
120          */
121         while (j < WAIT_MS_LINKUP) {
122                 tmp = readl(port_mmio + PORT_SCR_STAT);
123                 tmp &= PORT_SCR_STAT_DET_MASK;
124                 if (tmp == PORT_SCR_STAT_DET_PHYRDY)
125                         return 0;
126                 udelay(1000);
127                 j++;
128         }
129         return 1;
130 }
131
132 static int ahci_host_init(struct ahci_probe_ent *probe_ent)
133 {
134 #ifndef CONFIG_SCSI_AHCI_PLAT
135         pci_dev_t pdev = probe_ent->dev;
136         u16 tmp16;
137         unsigned short vendor;
138 #endif
139         volatile u8 *mmio = (volatile u8 *)probe_ent->mmio_base;
140         u32 tmp, cap_save, cmd;
141         int i, j, ret;
142         volatile u8 *port_mmio;
143         u32 port_map;
144
145         debug("ahci_host_init: start\n");
146
147         cap_save = readl(mmio + HOST_CAP);
148         cap_save &= ((1 << 28) | (1 << 17));
149         cap_save |= (1 << 27);  /* Staggered Spin-up. Not needed. */
150
151         /* global controller reset */
152         tmp = readl(mmio + HOST_CTL);
153         if ((tmp & HOST_RESET) == 0)
154                 writel_with_flush(tmp | HOST_RESET, mmio + HOST_CTL);
155
156         /* reset must complete within 1 second, or
157          * the hardware should be considered fried.
158          */
159         i = 1000;
160         do {
161                 udelay(1000);
162                 tmp = readl(mmio + HOST_CTL);
163                 if (!i--) {
164                         debug("controller reset failed (0x%x)\n", tmp);
165                         return -1;
166                 }
167         } while (tmp & HOST_RESET);
168
169         writel_with_flush(HOST_AHCI_EN, mmio + HOST_CTL);
170         writel(cap_save, mmio + HOST_CAP);
171         writel_with_flush(0xf, mmio + HOST_PORTS_IMPL);
172
173 #ifndef CONFIG_SCSI_AHCI_PLAT
174         pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor);
175
176         if (vendor == PCI_VENDOR_ID_INTEL) {
177                 u16 tmp16;
178                 pci_read_config_word(pdev, 0x92, &tmp16);
179                 tmp16 |= 0xf;
180                 pci_write_config_word(pdev, 0x92, tmp16);
181         }
182 #endif
183         probe_ent->cap = readl(mmio + HOST_CAP);
184         probe_ent->port_map = readl(mmio + HOST_PORTS_IMPL);
185         port_map = probe_ent->port_map;
186         probe_ent->n_ports = (probe_ent->cap & 0x1f) + 1;
187
188         debug("cap 0x%x  port_map 0x%x  n_ports %d\n",
189               probe_ent->cap, probe_ent->port_map, probe_ent->n_ports);
190
191         if (probe_ent->n_ports > CONFIG_SYS_SCSI_MAX_SCSI_ID)
192                 probe_ent->n_ports = CONFIG_SYS_SCSI_MAX_SCSI_ID;
193
194         for (i = 0; i < probe_ent->n_ports; i++) {
195                 if (!(port_map & (1 << i)))
196                         continue;
197                 probe_ent->port[i].port_mmio = ahci_port_base((u32) mmio, i);
198                 port_mmio = (u8 *) probe_ent->port[i].port_mmio;
199                 ahci_setup_port(&probe_ent->port[i], (unsigned long)mmio, i);
200
201                 /* make sure port is not active */
202                 tmp = readl(port_mmio + PORT_CMD);
203                 if (tmp & (PORT_CMD_LIST_ON | PORT_CMD_FIS_ON |
204                            PORT_CMD_FIS_RX | PORT_CMD_START)) {
205                         debug("Port %d is active. Deactivating.\n", i);
206                         tmp &= ~(PORT_CMD_LIST_ON | PORT_CMD_FIS_ON |
207                                  PORT_CMD_FIS_RX | PORT_CMD_START);
208                         writel_with_flush(tmp, port_mmio + PORT_CMD);
209
210                         /* spec says 500 msecs for each bit, so
211                          * this is slightly incorrect.
212                          */
213                         msleep(500);
214                 }
215
216                 /* Add the spinup command to whatever mode bits may
217                  * already be on in the command register.
218                  */
219                 cmd = readl(port_mmio + PORT_CMD);
220                 cmd |= PORT_CMD_FIS_RX;
221                 cmd |= PORT_CMD_SPIN_UP;
222                 writel_with_flush(cmd, port_mmio + PORT_CMD);
223
224                 /* Bring up SATA link. */
225                 ret = ahci_link_up(probe_ent, i);
226                 if (ret) {
227                         printf("SATA link %d timeout.\n", i);
228                         continue;
229                 } else {
230                         debug("SATA link ok.\n");
231                 }
232
233                 /* Clear error status */
234                 tmp = readl(port_mmio + PORT_SCR_ERR);
235                 if (tmp)
236                         writel(tmp, port_mmio + PORT_SCR_ERR);
237
238                 debug("Spinning up device on SATA port %d... ", i);
239
240                 j = 0;
241                 while (j < WAIT_MS_SPINUP) {
242                         tmp = readl(port_mmio + PORT_TFDATA);
243                         if (!(tmp & (ATA_STAT_BUSY | ATA_STAT_DRQ)))
244                                 break;
245                         udelay(1000);
246                         j++;
247                 }
248                 printf("Target spinup took %d ms.\n", j);
249                 if (j == WAIT_MS_SPINUP)
250                         debug("timeout.\n");
251                 else
252                         debug("ok.\n");
253
254                 tmp = readl(port_mmio + PORT_SCR_ERR);
255                 debug("PORT_SCR_ERR 0x%x\n", tmp);
256                 writel(tmp, port_mmio + PORT_SCR_ERR);
257
258                 /* ack any pending irq events for this port */
259                 tmp = readl(port_mmio + PORT_IRQ_STAT);
260                 debug("PORT_IRQ_STAT 0x%x\n", tmp);
261                 if (tmp)
262                         writel(tmp, port_mmio + PORT_IRQ_STAT);
263
264                 writel(1 << i, mmio + HOST_IRQ_STAT);
265
266                 /* set irq mask (enables interrupts) */
267                 writel(DEF_PORT_IRQ, port_mmio + PORT_IRQ_MASK);
268
269                 /* register linkup ports */
270                 tmp = readl(port_mmio + PORT_SCR_STAT);
271                 debug("SATA port %d status: 0x%x\n", i, tmp);
272                 if ((tmp & PORT_SCR_STAT_DET_MASK) == PORT_SCR_STAT_DET_PHYRDY)
273                         probe_ent->link_port_map |= (0x01 << i);
274         }
275
276         tmp = readl(mmio + HOST_CTL);
277         debug("HOST_CTL 0x%x\n", tmp);
278         writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL);
279         tmp = readl(mmio + HOST_CTL);
280         debug("HOST_CTL 0x%x\n", tmp);
281 #ifndef CONFIG_SCSI_AHCI_PLAT
282         pci_read_config_word(pdev, PCI_COMMAND, &tmp16);
283         tmp |= PCI_COMMAND_MASTER;
284         pci_write_config_word(pdev, PCI_COMMAND, tmp16);
285 #endif
286         return 0;
287 }
288
289
290 static void ahci_print_info(struct ahci_probe_ent *probe_ent)
291 {
292 #ifndef CONFIG_SCSI_AHCI_PLAT
293         pci_dev_t pdev = probe_ent->dev;
294         u16 cc;
295 #endif
296         volatile u8 *mmio = (volatile u8 *)probe_ent->mmio_base;
297         u32 vers, cap, cap2, impl, speed;
298         const char *speed_s;
299         const char *scc_s;
300
301         vers = readl(mmio + HOST_VERSION);
302         cap = probe_ent->cap;
303         cap2 = readl(mmio + HOST_CAP2);
304         impl = probe_ent->port_map;
305
306         speed = (cap >> 20) & 0xf;
307         if (speed == 1)
308                 speed_s = "1.5";
309         else if (speed == 2)
310                 speed_s = "3";
311         else if (speed == 3)
312                 speed_s = "6";
313         else
314                 speed_s = "?";
315
316 #ifdef CONFIG_SCSI_AHCI_PLAT
317         scc_s = "SATA";
318 #else
319         pci_read_config_word(pdev, 0x0a, &cc);
320         if (cc == 0x0101)
321                 scc_s = "IDE";
322         else if (cc == 0x0106)
323                 scc_s = "SATA";
324         else if (cc == 0x0104)
325                 scc_s = "RAID";
326         else
327                 scc_s = "unknown";
328 #endif
329         printf("AHCI %02x%02x.%02x%02x "
330                "%u slots %u ports %s Gbps 0x%x impl %s mode\n",
331                (vers >> 24) & 0xff,
332                (vers >> 16) & 0xff,
333                (vers >> 8) & 0xff,
334                vers & 0xff,
335                ((cap >> 8) & 0x1f) + 1, (cap & 0x1f) + 1, speed_s, impl, scc_s);
336
337         printf("flags: "
338                "%s%s%s%s%s%s%s"
339                "%s%s%s%s%s%s%s"
340                "%s%s%s%s%s%s\n",
341                cap & (1 << 31) ? "64bit " : "",
342                cap & (1 << 30) ? "ncq " : "",
343                cap & (1 << 28) ? "ilck " : "",
344                cap & (1 << 27) ? "stag " : "",
345                cap & (1 << 26) ? "pm " : "",
346                cap & (1 << 25) ? "led " : "",
347                cap & (1 << 24) ? "clo " : "",
348                cap & (1 << 19) ? "nz " : "",
349                cap & (1 << 18) ? "only " : "",
350                cap & (1 << 17) ? "pmp " : "",
351                cap & (1 << 16) ? "fbss " : "",
352                cap & (1 << 15) ? "pio " : "",
353                cap & (1 << 14) ? "slum " : "",
354                cap & (1 << 13) ? "part " : "",
355                cap & (1 << 7) ? "ccc " : "",
356                cap & (1 << 6) ? "ems " : "",
357                cap & (1 << 5) ? "sxs " : "",
358                cap2 & (1 << 2) ? "apst " : "",
359                cap2 & (1 << 1) ? "nvmp " : "",
360                cap2 & (1 << 0) ? "boh " : "");
361 }
362
363 #ifndef CONFIG_SCSI_AHCI_PLAT
364 static int ahci_init_one(pci_dev_t pdev)
365 {
366         u16 vendor;
367         int rc;
368
369         memset((void *)ataid, 0, sizeof(hd_driveid_t *) * AHCI_MAX_PORTS);
370
371         probe_ent = malloc(sizeof(struct ahci_probe_ent));
372         memset(probe_ent, 0, sizeof(struct ahci_probe_ent));
373         probe_ent->dev = pdev;
374
375         probe_ent->host_flags = ATA_FLAG_SATA
376                                 | ATA_FLAG_NO_LEGACY
377                                 | ATA_FLAG_MMIO
378                                 | ATA_FLAG_PIO_DMA
379                                 | ATA_FLAG_NO_ATAPI;
380         probe_ent->pio_mask = 0x1f;
381         probe_ent->udma_mask = 0x7f;    /*Fixme,assume to support UDMA6 */
382
383         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_5, &probe_ent->mmio_base);
384         debug("ahci mmio_base=0x%08x\n", probe_ent->mmio_base);
385
386         /* Take from kernel:
387          * JMicron-specific fixup:
388          * make sure we're in AHCI mode
389          */
390         pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor);
391         if (vendor == 0x197b)
392                 pci_write_config_byte(pdev, 0x41, 0xa1);
393
394         /* initialize adapter */
395         rc = ahci_host_init(probe_ent);
396         if (rc)
397                 goto err_out;
398
399         ahci_print_info(probe_ent);
400
401         return 0;
402
403       err_out:
404         return rc;
405 }
406 #endif
407
408 #define MAX_DATA_BYTE_COUNT  (4*1024*1024)
409
410 static int ahci_fill_sg(u8 port, unsigned char *buf, int buf_len)
411 {
412         struct ahci_ioports *pp = &(probe_ent->port[port]);
413         struct ahci_sg *ahci_sg = pp->cmd_tbl_sg;
414         u32 sg_count;
415         int i;
416
417         sg_count = ((buf_len - 1) / MAX_DATA_BYTE_COUNT) + 1;
418         if (sg_count > AHCI_MAX_SG) {
419                 printf("Error:Too much sg!\n");
420                 return -1;
421         }
422
423         for (i = 0; i < sg_count; i++) {
424                 ahci_sg->addr =
425                     cpu_to_le32((u32) buf + i * MAX_DATA_BYTE_COUNT);
426                 ahci_sg->addr_hi = 0;
427                 ahci_sg->flags_size = cpu_to_le32(0x3fffff &
428                                           (buf_len < MAX_DATA_BYTE_COUNT
429                                            ? (buf_len - 1)
430                                            : (MAX_DATA_BYTE_COUNT - 1)));
431                 ahci_sg++;
432                 buf_len -= MAX_DATA_BYTE_COUNT;
433         }
434
435         return sg_count;
436 }
437
438
439 static void ahci_fill_cmd_slot(struct ahci_ioports *pp, u32 opts)
440 {
441         pp->cmd_slot->opts = cpu_to_le32(opts);
442         pp->cmd_slot->status = 0;
443         pp->cmd_slot->tbl_addr = cpu_to_le32(pp->cmd_tbl & 0xffffffff);
444         pp->cmd_slot->tbl_addr_hi = 0;
445 }
446
447
448 #ifdef CONFIG_AHCI_SETFEATURES_XFER
449 static void ahci_set_feature(u8 port)
450 {
451         struct ahci_ioports *pp = &(probe_ent->port[port]);
452         volatile u8 *port_mmio = (volatile u8 *)pp->port_mmio;
453         u32 cmd_fis_len = 5;    /* five dwords */
454         u8 fis[20];
455
456         /* set feature */
457         memset(fis, 0, sizeof(fis));
458         fis[0] = 0x27;
459         fis[1] = 1 << 7;
460         fis[2] = ATA_CMD_SETF;
461         fis[3] = SETFEATURES_XFER;
462         fis[12] = __ilog2(probe_ent->udma_mask + 1) + 0x40 - 0x01;
463
464         memcpy((unsigned char *)pp->cmd_tbl, fis, sizeof(fis));
465         ahci_fill_cmd_slot(pp, cmd_fis_len);
466         ahci_dcache_flush_sata_cmd(pp);
467         writel(1, port_mmio + PORT_CMD_ISSUE);
468         readl(port_mmio + PORT_CMD_ISSUE);
469
470         if (waiting_for_cmd_completed(port_mmio + PORT_CMD_ISSUE,
471                                 WAIT_MS_DATAIO, 0x1)) {
472                 printf("set feature error on port %d!\n", port);
473         }
474 }
475 #endif
476
477
478 static int ahci_port_start(u8 port)
479 {
480         struct ahci_ioports *pp = &(probe_ent->port[port]);
481         volatile u8 *port_mmio = (volatile u8 *)pp->port_mmio;
482         u32 port_status;
483         u32 mem;
484
485         debug("Enter start port: %d\n", port);
486         port_status = readl(port_mmio + PORT_SCR_STAT);
487         debug("Port %d status: %x\n", port, port_status);
488         if ((port_status & 0xf) != 0x03) {
489                 printf("No Link on this port!\n");
490                 return -1;
491         }
492
493         mem = (u32) malloc(AHCI_PORT_PRIV_DMA_SZ + 2048);
494         if (!mem) {
495                 free(pp);
496                 printf("No mem for table!\n");
497                 return -ENOMEM;
498         }
499
500         mem = (mem + 0x800) & (~0x7ff); /* Aligned to 2048-bytes */
501         memset((u8 *) mem, 0, AHCI_PORT_PRIV_DMA_SZ);
502
503         /*
504          * First item in chunk of DMA memory: 32-slot command table,
505          * 32 bytes each in size
506          */
507         pp->cmd_slot =
508                 (struct ahci_cmd_hdr *)(uintptr_t)virt_to_phys((void *)mem);
509         debug("cmd_slot = 0x%x\n", (unsigned)pp->cmd_slot);
510         mem += (AHCI_CMD_SLOT_SZ + 224);
511
512         /*
513          * Second item: Received-FIS area
514          */
515         pp->rx_fis = virt_to_phys((void *)mem);
516         mem += AHCI_RX_FIS_SZ;
517
518         /*
519          * Third item: data area for storing a single command
520          * and its scatter-gather table
521          */
522         pp->cmd_tbl = virt_to_phys((void *)mem);
523         debug("cmd_tbl_dma = 0x%x\n", pp->cmd_tbl);
524
525         mem += AHCI_CMD_TBL_HDR;
526         pp->cmd_tbl_sg =
527                         (struct ahci_sg *)(uintptr_t)virt_to_phys((void *)mem);
528
529         writel_with_flush((u32) pp->cmd_slot, port_mmio + PORT_LST_ADDR);
530
531         writel_with_flush(pp->rx_fis, port_mmio + PORT_FIS_ADDR);
532
533         writel_with_flush(PORT_CMD_ICC_ACTIVE | PORT_CMD_FIS_RX |
534                           PORT_CMD_POWER_ON | PORT_CMD_SPIN_UP |
535                           PORT_CMD_START, port_mmio + PORT_CMD);
536
537         debug("Exit start port %d\n", port);
538
539         return 0;
540 }
541
542
543 static int ahci_device_data_io(u8 port, u8 *fis, int fis_len, u8 *buf,
544                                 int buf_len, u8 is_write)
545 {
546
547         struct ahci_ioports *pp = &(probe_ent->port[port]);
548         volatile u8 *port_mmio = (volatile u8 *)pp->port_mmio;
549         u32 opts;
550         u32 port_status;
551         int sg_count;
552
553         debug("Enter %s: for port %d\n", __func__, port);
554
555         if (port > probe_ent->n_ports) {
556                 printf("Invalid port number %d\n", port);
557                 return -1;
558         }
559
560         port_status = readl(port_mmio + PORT_SCR_STAT);
561         if ((port_status & 0xf) != 0x03) {
562                 debug("No Link on port %d!\n", port);
563                 return -1;
564         }
565
566         memcpy((unsigned char *)pp->cmd_tbl, fis, fis_len);
567
568         sg_count = ahci_fill_sg(port, buf, buf_len);
569         opts = (fis_len >> 2) | (sg_count << 16) | (is_write << 6);
570         ahci_fill_cmd_slot(pp, opts);
571
572         ahci_dcache_flush_sata_cmd(pp);
573         ahci_dcache_flush_range((unsigned)buf, (unsigned)buf_len);
574
575         writel_with_flush(1, port_mmio + PORT_CMD_ISSUE);
576
577         if (waiting_for_cmd_completed(port_mmio + PORT_CMD_ISSUE,
578                                 WAIT_MS_DATAIO, 0x1)) {
579                 printf("timeout exit!\n");
580                 return -1;
581         }
582
583         ahci_dcache_invalidate_range((unsigned)buf, (unsigned)buf_len);
584         debug("%s: %d byte transferred.\n", __func__, pp->cmd_slot->status);
585
586         return 0;
587 }
588
589
590 static char *ata_id_strcpy(u16 *target, u16 *src, int len)
591 {
592         int i;
593         for (i = 0; i < len / 2; i++)
594                 target[i] = swab16(src[i]);
595         return (char *)target;
596 }
597
598
599 static void dump_ataid(hd_driveid_t *ataid)
600 {
601         debug("(49)ataid->capability = 0x%x\n", ataid->capability);
602         debug("(53)ataid->field_valid =0x%x\n", ataid->field_valid);
603         debug("(63)ataid->dma_mword = 0x%x\n", ataid->dma_mword);
604         debug("(64)ataid->eide_pio_modes = 0x%x\n", ataid->eide_pio_modes);
605         debug("(75)ataid->queue_depth = 0x%x\n", ataid->queue_depth);
606         debug("(80)ataid->major_rev_num = 0x%x\n", ataid->major_rev_num);
607         debug("(81)ataid->minor_rev_num = 0x%x\n", ataid->minor_rev_num);
608         debug("(82)ataid->command_set_1 = 0x%x\n", ataid->command_set_1);
609         debug("(83)ataid->command_set_2 = 0x%x\n", ataid->command_set_2);
610         debug("(84)ataid->cfsse = 0x%x\n", ataid->cfsse);
611         debug("(85)ataid->cfs_enable_1 = 0x%x\n", ataid->cfs_enable_1);
612         debug("(86)ataid->cfs_enable_2 = 0x%x\n", ataid->cfs_enable_2);
613         debug("(87)ataid->csf_default = 0x%x\n", ataid->csf_default);
614         debug("(88)ataid->dma_ultra = 0x%x\n", ataid->dma_ultra);
615         debug("(93)ataid->hw_config = 0x%x\n", ataid->hw_config);
616 }
617
618
619 /*
620  * SCSI INQUIRY command operation.
621  */
622 static int ata_scsiop_inquiry(ccb *pccb)
623 {
624         static const u8 hdr[] = {
625                 0,
626                 0,
627                 0x5,            /* claim SPC-3 version compatibility */
628                 2,
629                 95 - 4,
630         };
631         u8 fis[20];
632         u8 *tmpid;
633         u8 port;
634
635         /* Clean ccb data buffer */
636         memset(pccb->pdata, 0, pccb->datalen);
637
638         memcpy(pccb->pdata, hdr, sizeof(hdr));
639
640         if (pccb->datalen <= 35)
641                 return 0;
642
643         memset(fis, 0, sizeof(fis));
644         /* Construct the FIS */
645         fis[0] = 0x27;          /* Host to device FIS. */
646         fis[1] = 1 << 7;        /* Command FIS. */
647         fis[2] = ATA_CMD_IDENT; /* Command byte. */
648
649         /* Read id from sata */
650         port = pccb->target;
651         if (!(tmpid = malloc(sizeof(hd_driveid_t))))
652                 return -ENOMEM;
653
654         if (ahci_device_data_io(port, (u8 *) &fis, sizeof(fis), tmpid,
655                                 sizeof(hd_driveid_t), 0)) {
656                 debug("scsi_ahci: SCSI inquiry command failure.\n");
657                 free(tmpid);
658                 return -EIO;
659         }
660
661         if (ataid[port])
662                 free(ataid[port]);
663         ataid[port] = (hd_driveid_t *) tmpid;
664
665         memcpy(&pccb->pdata[8], "ATA     ", 8);
666         ata_id_strcpy((u16 *) &pccb->pdata[16], (u16 *)ataid[port]->model, 16);
667         ata_id_strcpy((u16 *) &pccb->pdata[32], (u16 *)ataid[port]->fw_rev, 4);
668
669         dump_ataid(ataid[port]);
670         return 0;
671 }
672
673
674 /*
675  * SCSI READ10/WRITE10 command operation.
676  */
677 static int ata_scsiop_read_write(ccb *pccb, u8 is_write)
678 {
679         u32 lba = 0;
680         u16 blocks = 0;
681         u8 fis[20];
682         u8 *user_buffer = pccb->pdata;
683         u32 user_buffer_size = pccb->datalen;
684
685         /* Retrieve the base LBA number from the ccb structure. */
686         memcpy(&lba, pccb->cmd + 2, sizeof(lba));
687         lba = be32_to_cpu(lba);
688
689         /*
690          * And the number of blocks.
691          *
692          * For 10-byte and 16-byte SCSI R/W commands, transfer
693          * length 0 means transfer 0 block of data.
694          * However, for ATA R/W commands, sector count 0 means
695          * 256 or 65536 sectors, not 0 sectors as in SCSI.
696          *
697          * WARNING: one or two older ATA drives treat 0 as 0...
698          */
699         blocks = (((u16)pccb->cmd[7]) << 8) | ((u16) pccb->cmd[8]);
700
701         debug("scsi_ahci: %s %d blocks starting from lba 0x%x\n",
702               is_write ?  "write" : "read", (unsigned)lba, blocks);
703
704         /* Preset the FIS */
705         memset(fis, 0, sizeof(fis));
706         fis[0] = 0x27;           /* Host to device FIS. */
707         fis[1] = 1 << 7;         /* Command FIS. */
708         /* Command byte (read/write). */
709         fis[2] = is_write ? ATA_CMD_WRITE_EXT : ATA_CMD_READ_EXT;
710
711         while (blocks) {
712                 u16 now_blocks; /* number of blocks per iteration */
713                 u32 transfer_size; /* number of bytes per iteration */
714
715                 now_blocks = min(MAX_SATA_BLOCKS_READ_WRITE, blocks);
716
717                 transfer_size = ATA_BLOCKSIZE * now_blocks;
718                 if (transfer_size > user_buffer_size) {
719                         printf("scsi_ahci: Error: buffer too small.\n");
720                         return -EIO;
721                 }
722
723                 /* LBA48 SATA command but only use 32bit address range within
724                  * that. The next smaller command range (28bit) is too small.
725                  */
726                 fis[4] = (lba >> 0) & 0xff;
727                 fis[5] = (lba >> 8) & 0xff;
728                 fis[6] = (lba >> 16) & 0xff;
729                 fis[7] = 1 << 6; /* device reg: set LBA mode */
730                 fis[8] = ((lba >> 24) & 0xff);
731                 fis[3] = 0xe0; /* features */
732
733                 /* Block (sector) count */
734                 fis[12] = (now_blocks >> 0) & 0xff;
735                 fis[13] = (now_blocks >> 8) & 0xff;
736
737                 /* Read/Write from ahci */
738                 if (ahci_device_data_io(pccb->target, (u8 *) &fis, sizeof(fis),
739                                         user_buffer, user_buffer_size,
740                                         is_write)) {
741                         debug("scsi_ahci: SCSI %s10 command failure.\n",
742                               is_write ? "WRITE" : "READ");
743                         return -EIO;
744                 }
745
746                 /* If this transaction is a write, do a following flush.
747                  * Writes in u-boot are so rare, and the logic to know when is
748                  * the last write and do a flush only there is sufficiently
749                  * difficult. Just do a flush after every write. This incurs,
750                  * usually, one extra flush when the rare writes do happen.
751                  */
752                 if (is_write) {
753                         if (-EIO == ata_io_flush(pccb->target))
754                                 return -EIO;
755                 }
756                 user_buffer += transfer_size;
757                 user_buffer_size -= transfer_size;
758                 blocks -= now_blocks;
759                 lba += now_blocks;
760         }
761
762         return 0;
763 }
764
765
766 /*
767  * SCSI READ CAPACITY10 command operation.
768  */
769 static int ata_scsiop_read_capacity10(ccb *pccb)
770 {
771         u32 cap;
772         u32 block_size;
773
774         if (!ataid[pccb->target]) {
775                 printf("scsi_ahci: SCSI READ CAPACITY10 command failure. "
776                        "\tNo ATA info!\n"
777                        "\tPlease run SCSI commmand INQUIRY firstly!\n");
778                 return -EPERM;
779         }
780
781         cap = le32_to_cpu(ataid[pccb->target]->lba_capacity);
782         if (cap == 0xfffffff) {
783                 unsigned short *cap48 = ataid[pccb->target]->lba48_capacity;
784                 if (cap48[2] || cap48[3]) {
785                         cap = 0xffffffff;
786                 } else {
787                         cap = (le16_to_cpu(cap48[1]) << 16) |
788                               (le16_to_cpu(cap48[0]));
789                 }
790         }
791
792         cap = cpu_to_be32(cap);
793         memcpy(pccb->pdata, &cap, sizeof(cap));
794
795         block_size = cpu_to_be32((u32)512);
796         memcpy(&pccb->pdata[4], &block_size, 4);
797
798         return 0;
799 }
800
801
802 /*
803  * SCSI READ CAPACITY16 command operation.
804  */
805 static int ata_scsiop_read_capacity16(ccb *pccb)
806 {
807         u64 cap;
808         u64 block_size;
809
810         if (!ataid[pccb->target]) {
811                 printf("scsi_ahci: SCSI READ CAPACITY16 command failure. "
812                        "\tNo ATA info!\n"
813                        "\tPlease run SCSI commmand INQUIRY firstly!\n");
814                 return -EPERM;
815         }
816
817         cap = le32_to_cpu(ataid[pccb->target]->lba_capacity);
818         if (cap == 0xfffffff) {
819                 memcpy(&cap, ataid[pccb->target]->lba48_capacity, sizeof(cap));
820                 cap = le64_to_cpu(cap);
821         }
822
823         cap = cpu_to_be64(cap);
824         memcpy(pccb->pdata, &cap, sizeof(cap));
825
826         block_size = cpu_to_be64((u64)512);
827         memcpy(&pccb->pdata[8], &block_size, 8);
828
829         return 0;
830 }
831
832
833 /*
834  * SCSI TEST UNIT READY command operation.
835  */
836 static int ata_scsiop_test_unit_ready(ccb *pccb)
837 {
838         return (ataid[pccb->target]) ? 0 : -EPERM;
839 }
840
841
842 int scsi_exec(ccb *pccb)
843 {
844         int ret;
845
846         switch (pccb->cmd[0]) {
847         case SCSI_READ10:
848                 ret = ata_scsiop_read_write(pccb, 0);
849                 break;
850         case SCSI_WRITE10:
851                 ret = ata_scsiop_read_write(pccb, 1);
852                 break;
853         case SCSI_RD_CAPAC10:
854                 ret = ata_scsiop_read_capacity10(pccb);
855                 break;
856         case SCSI_RD_CAPAC16:
857                 ret = ata_scsiop_read_capacity16(pccb);
858                 break;
859         case SCSI_TST_U_RDY:
860                 ret = ata_scsiop_test_unit_ready(pccb);
861                 break;
862         case SCSI_INQUIRY:
863                 ret = ata_scsiop_inquiry(pccb);
864                 break;
865         default:
866                 printf("Unsupport SCSI command 0x%02x\n", pccb->cmd[0]);
867                 return false;
868         }
869
870         if (ret) {
871                 debug("SCSI command 0x%02x ret errno %d\n", pccb->cmd[0], ret);
872                 return false;
873         }
874         return true;
875
876 }
877
878
879 void scsi_low_level_init(int busdevfunc)
880 {
881         int i;
882         u32 linkmap;
883
884 #ifndef CONFIG_SCSI_AHCI_PLAT
885         ahci_init_one(busdevfunc);
886 #endif
887
888         linkmap = probe_ent->link_port_map;
889
890         for (i = 0; i < CONFIG_SYS_SCSI_MAX_SCSI_ID; i++) {
891                 if (((linkmap >> i) & 0x01)) {
892                         if (ahci_port_start((u8) i)) {
893                                 printf("Can not start port %d\n", i);
894                                 continue;
895                         }
896 #ifdef CONFIG_AHCI_SETFEATURES_XFER
897                         ahci_set_feature((u8) i);
898 #endif
899                 }
900         }
901 }
902
903 #ifdef CONFIG_SCSI_AHCI_PLAT
904 int ahci_init(u32 base)
905 {
906         int i, rc = 0;
907         u32 linkmap;
908
909         memset(ataid, 0, sizeof(ataid));
910
911         probe_ent = malloc(sizeof(struct ahci_probe_ent));
912         memset(probe_ent, 0, sizeof(struct ahci_probe_ent));
913
914         probe_ent->host_flags = ATA_FLAG_SATA
915                                 | ATA_FLAG_NO_LEGACY
916                                 | ATA_FLAG_MMIO
917                                 | ATA_FLAG_PIO_DMA
918                                 | ATA_FLAG_NO_ATAPI;
919         probe_ent->pio_mask = 0x1f;
920         probe_ent->udma_mask = 0x7f;    /*Fixme,assume to support UDMA6 */
921
922         probe_ent->mmio_base = base;
923
924         /* initialize adapter */
925         rc = ahci_host_init(probe_ent);
926         if (rc)
927                 goto err_out;
928
929         ahci_print_info(probe_ent);
930
931         linkmap = probe_ent->link_port_map;
932
933         for (i = 0; i < CONFIG_SYS_SCSI_MAX_SCSI_ID; i++) {
934                 if (((linkmap >> i) & 0x01)) {
935                         if (ahci_port_start((u8) i)) {
936                                 printf("Can not start port %d\n", i);
937                                 continue;
938                         }
939 #ifdef CONFIG_AHCI_SETFEATURES_XFER
940                         ahci_set_feature((u8) i);
941 #endif
942                 }
943         }
944 err_out:
945         return rc;
946 }
947 #endif
948
949 /*
950  * In the general case of generic rotating media it makes sense to have a
951  * flush capability. It probably even makes sense in the case of SSDs because
952  * one cannot always know for sure what kind of internal cache/flush mechanism
953  * is embodied therein. At first it was planned to invoke this after the last
954  * write to disk and before rebooting. In practice, knowing, a priori, which
955  * is the last write is difficult. Because writing to the disk in u-boot is
956  * very rare, this flush command will be invoked after every block write.
957  */
958 static int ata_io_flush(u8 port)
959 {
960         u8 fis[20];
961         struct ahci_ioports *pp = &(probe_ent->port[port]);
962         volatile u8 *port_mmio = (volatile u8 *)pp->port_mmio;
963         u32 cmd_fis_len = 5;    /* five dwords */
964
965         /* Preset the FIS */
966         memset(fis, 0, 20);
967         fis[0] = 0x27;           /* Host to device FIS. */
968         fis[1] = 1 << 7;         /* Command FIS. */
969         fis[2] = ATA_CMD_FLUSH_EXT;
970
971         memcpy((unsigned char *)pp->cmd_tbl, fis, 20);
972         ahci_fill_cmd_slot(pp, cmd_fis_len);
973         writel_with_flush(1, port_mmio + PORT_CMD_ISSUE);
974
975         if (waiting_for_cmd_completed(port_mmio + PORT_CMD_ISSUE,
976                         WAIT_MS_FLUSH, 0x1)) {
977                 debug("scsi_ahci: flush command timeout on port %d.\n", port);
978                 return -EIO;
979         }
980
981         return 0;
982 }
983
984
985 void scsi_bus_reset(void)
986 {
987         /*Not implement*/
988 }
989
990
991 void scsi_print_error(ccb * pccb)
992 {
993         /*The ahci error info can be read in the ahci driver*/
994 }