2 * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
3 * Terry Lv <r65388@freescale.com>
5 * SPDX-License-Identifier: GPL-2.0+
11 #include <dwc_ahsata.h>
18 #include <asm/arch/clock.h>
19 #include <asm/arch/sys_proto.h>
20 #include <linux/bitops.h>
21 #include <linux/ctype.h>
22 #include <linux/errno.h>
23 #include "dwc_ahsata_priv.h"
25 struct sata_port_regs
{
49 struct sata_host_regs
{
78 #define MAX_DATA_BYTES_PER_SG (4 * 1024 * 1024)
79 #define MAX_BYTES_PER_TRANS (AHCI_MAX_SG * MAX_DATA_BYTES_PER_SG)
81 #define writel_with_flush(a, b) do { writel(a, b); readl(b); } while (0)
83 static inline void __iomem
*ahci_port_base(void __iomem
*base
, u32 port
)
85 return base
+ 0x100 + (port
* 0x80);
88 static int waiting_for_cmd_completed(u8
*offset
,
96 ((status
= readl(offset
)) & sign
) && i
< timeout_msec
;
100 return (i
< timeout_msec
) ? 0 : -1;
103 static int ahci_setup_oobr(struct ahci_uc_priv
*uc_priv
, int clk
)
105 struct sata_host_regs
*host_mmio
= uc_priv
->mmio_base
;
107 writel(SATA_HOST_OOBR_WE
, &host_mmio
->oobr
);
108 writel(0x02060b14, &host_mmio
->oobr
);
113 static int ahci_host_init(struct ahci_uc_priv
*uc_priv
)
115 u32 tmp
, cap_save
, num_ports
;
116 int i
, j
, timeout
= 1000;
117 struct sata_port_regs
*port_mmio
= NULL
;
118 struct sata_host_regs
*host_mmio
= uc_priv
->mmio_base
;
119 int clk
= mxc_get_clock(MXC_SATA_CLK
);
121 cap_save
= readl(&host_mmio
->cap
);
122 cap_save
|= SATA_HOST_CAP_SSS
;
124 /* global controller reset */
125 tmp
= readl(&host_mmio
->ghc
);
126 if ((tmp
& SATA_HOST_GHC_HR
) == 0)
127 writel_with_flush(tmp
| SATA_HOST_GHC_HR
, &host_mmio
->ghc
);
129 while ((readl(&host_mmio
->ghc
) & SATA_HOST_GHC_HR
) && --timeout
)
133 debug("controller reset failed (0x%x)\n", tmp
);
138 writel(clk
/ 1000, &host_mmio
->timer1ms
);
140 ahci_setup_oobr(uc_priv
, 0);
142 writel_with_flush(SATA_HOST_GHC_AE
, &host_mmio
->ghc
);
143 writel(cap_save
, &host_mmio
->cap
);
144 num_ports
= (cap_save
& SATA_HOST_CAP_NP_MASK
) + 1;
145 writel_with_flush((1 << num_ports
) - 1, &host_mmio
->pi
);
148 * Determine which Ports are implemented by the DWC_ahsata,
149 * by reading the PI register. This bit map value aids the
150 * software to determine how many Ports are available and
151 * which Port registers need to be initialized.
153 uc_priv
->cap
= readl(&host_mmio
->cap
);
154 uc_priv
->port_map
= readl(&host_mmio
->pi
);
156 /* Determine how many command slots the HBA supports */
157 uc_priv
->n_ports
= (uc_priv
->cap
& SATA_HOST_CAP_NP_MASK
) + 1;
159 debug("cap 0x%x port_map 0x%x n_ports %d\n",
160 uc_priv
->cap
, uc_priv
->port_map
, uc_priv
->n_ports
);
162 for (i
= 0; i
< uc_priv
->n_ports
; i
++) {
163 uc_priv
->port
[i
].port_mmio
= ahci_port_base(host_mmio
, i
);
164 port_mmio
= uc_priv
->port
[i
].port_mmio
;
166 /* Ensure that the DWC_ahsata is in idle state */
167 tmp
= readl(&port_mmio
->cmd
);
170 * When P#CMD.ST, P#CMD.CR, P#CMD.FRE and P#CMD.FR
171 * are all cleared, the Port is in an idle state.
173 if (tmp
& (SATA_PORT_CMD_CR
| SATA_PORT_CMD_FR
|
174 SATA_PORT_CMD_FRE
| SATA_PORT_CMD_ST
)) {
177 * System software places a Port into the idle state by
178 * clearing P#CMD.ST and waiting for P#CMD.CR to return
181 tmp
&= ~SATA_PORT_CMD_ST
;
182 writel_with_flush(tmp
, &port_mmio
->cmd
);
185 * spec says 500 msecs for each bit, so
186 * this is slightly incorrect.
191 while ((readl(&port_mmio
->cmd
) & SATA_PORT_CMD_CR
)
196 debug("port reset failed (0x%x)\n", tmp
);
202 tmp
= readl(&port_mmio
->cmd
);
203 writel((tmp
| SATA_PORT_CMD_SUD
), &port_mmio
->cmd
);
205 /* Wait for spin-up to finish */
207 while (!(readl(&port_mmio
->cmd
) | SATA_PORT_CMD_SUD
)
211 debug("Spin-Up can't finish!\n");
215 for (j
= 0; j
< 100; ++j
) {
217 tmp
= readl(&port_mmio
->ssts
);
218 if (((tmp
& SATA_PORT_SSTS_DET_MASK
) == 0x3) ||
219 ((tmp
& SATA_PORT_SSTS_DET_MASK
) == 0x1))
223 /* Wait for COMINIT bit 26 (DIAG_X) in SERR */
225 while (!(readl(&port_mmio
->serr
) | SATA_PORT_SERR_DIAG_X
)
229 debug("Can't find DIAG_X set!\n");
234 * For each implemented Port, clear the P#SERR
235 * register, by writing ones to each implemented\
238 tmp
= readl(&port_mmio
->serr
);
239 debug("P#SERR 0x%x\n",
241 writel(tmp
, &port_mmio
->serr
);
243 /* Ack any pending irq events for this port */
244 tmp
= readl(&host_mmio
->is
);
245 debug("IS 0x%x\n", tmp
);
247 writel(tmp
, &host_mmio
->is
);
249 writel(1 << i
, &host_mmio
->is
);
251 /* set irq mask (enables interrupts) */
252 writel(DEF_PORT_IRQ
, &port_mmio
->ie
);
254 /* register linkup ports */
255 tmp
= readl(&port_mmio
->ssts
);
256 debug("Port %d status: 0x%x\n", i
, tmp
);
257 if ((tmp
& SATA_PORT_SSTS_DET_MASK
) == 0x03)
258 uc_priv
->link_port_map
|= (0x01 << i
);
261 tmp
= readl(&host_mmio
->ghc
);
262 debug("GHC 0x%x\n", tmp
);
263 writel(tmp
| SATA_HOST_GHC_IE
, &host_mmio
->ghc
);
264 tmp
= readl(&host_mmio
->ghc
);
265 debug("GHC 0x%x\n", tmp
);
270 static void ahci_print_info(struct ahci_uc_priv
*uc_priv
)
272 struct sata_host_regs
*host_mmio
= uc_priv
->mmio_base
;
273 u32 vers
, cap
, impl
, speed
;
277 vers
= readl(&host_mmio
->vs
);
279 impl
= uc_priv
->port_map
;
281 speed
= (cap
& SATA_HOST_CAP_ISS_MASK
)
282 >> SATA_HOST_CAP_ISS_OFFSET
;
292 printf("AHCI %02x%02x.%02x%02x "
293 "%u slots %u ports %s Gbps 0x%x impl %s mode\n",
298 ((cap
>> 8) & 0x1f) + 1,
307 cap
& (1 << 31) ? "64bit " : "",
308 cap
& (1 << 30) ? "ncq " : "",
309 cap
& (1 << 28) ? "ilck " : "",
310 cap
& (1 << 27) ? "stag " : "",
311 cap
& (1 << 26) ? "pm " : "",
312 cap
& (1 << 25) ? "led " : "",
313 cap
& (1 << 24) ? "clo " : "",
314 cap
& (1 << 19) ? "nz " : "",
315 cap
& (1 << 18) ? "only " : "",
316 cap
& (1 << 17) ? "pmp " : "",
317 cap
& (1 << 15) ? "pio " : "",
318 cap
& (1 << 14) ? "slum " : "",
319 cap
& (1 << 13) ? "part " : "");
322 static int ahci_fill_sg(struct ahci_uc_priv
*uc_priv
, u8 port
,
323 unsigned char *buf
, int buf_len
)
325 struct ahci_ioports
*pp
= &uc_priv
->port
[port
];
326 struct ahci_sg
*ahci_sg
= pp
->cmd_tbl_sg
;
327 u32 sg_count
, max_bytes
;
330 max_bytes
= MAX_DATA_BYTES_PER_SG
;
331 sg_count
= ((buf_len
- 1) / max_bytes
) + 1;
332 if (sg_count
> AHCI_MAX_SG
) {
333 printf("Error:Too much sg!\n");
337 for (i
= 0; i
< sg_count
; i
++) {
339 cpu_to_le32((u32
)buf
+ i
* max_bytes
);
340 ahci_sg
->addr_hi
= 0;
341 ahci_sg
->flags_size
= cpu_to_le32(0x3fffff &
346 buf_len
-= max_bytes
;
352 static void ahci_fill_cmd_slot(struct ahci_ioports
*pp
, u32 cmd_slot
, u32 opts
)
354 struct ahci_cmd_hdr
*cmd_hdr
= (struct ahci_cmd_hdr
*)(pp
->cmd_slot
+
355 AHCI_CMD_SLOT_SZ
* cmd_slot
);
357 memset(cmd_hdr
, 0, AHCI_CMD_SLOT_SZ
);
358 cmd_hdr
->opts
= cpu_to_le32(opts
);
360 pp
->cmd_slot
->tbl_addr
= cpu_to_le32((u32
)pp
->cmd_tbl
& 0xffffffff);
361 #ifdef CONFIG_PHYS_64BIT
362 pp
->cmd_slot
->tbl_addr_hi
=
363 cpu_to_le32((u32
)(((pp
->cmd_tbl
) >> 16) >> 16));
367 #define AHCI_GET_CMD_SLOT(c) ((c) ? ffs(c) : 0)
369 static int ahci_exec_ata_cmd(struct ahci_uc_priv
*uc_priv
, u8 port
,
370 struct sata_fis_h2d
*cfis
, u8
*buf
, u32 buf_len
,
373 struct ahci_ioports
*pp
= &uc_priv
->port
[port
];
374 struct sata_port_regs
*port_mmio
= pp
->port_mmio
;
376 int sg_count
= 0, cmd_slot
= 0;
378 cmd_slot
= AHCI_GET_CMD_SLOT(readl(&port_mmio
->ci
));
379 if (32 == cmd_slot
) {
380 printf("Can't find empty command slot!\n");
384 /* Check xfer length */
385 if (buf_len
> MAX_BYTES_PER_TRANS
) {
386 printf("Max transfer length is %dB\n\r",
387 MAX_BYTES_PER_TRANS
);
391 memcpy((u8
*)(pp
->cmd_tbl
), cfis
, sizeof(struct sata_fis_h2d
));
393 sg_count
= ahci_fill_sg(uc_priv
, port
, buf
, buf_len
);
394 opts
= (sizeof(struct sata_fis_h2d
) >> 2) | (sg_count
<< 16);
397 flush_cache((ulong
)buf
, buf_len
);
399 ahci_fill_cmd_slot(pp
, cmd_slot
, opts
);
401 flush_cache((int)(pp
->cmd_slot
), AHCI_PORT_PRIV_DMA_SZ
);
402 writel_with_flush(1 << cmd_slot
, &port_mmio
->ci
);
404 if (waiting_for_cmd_completed((u8
*)&port_mmio
->ci
, 10000,
406 printf("timeout exit!\n");
409 invalidate_dcache_range((int)(pp
->cmd_slot
),
410 (int)(pp
->cmd_slot
)+AHCI_PORT_PRIV_DMA_SZ
);
411 debug("ahci_exec_ata_cmd: %d byte transferred.\n",
412 pp
->cmd_slot
->status
);
414 invalidate_dcache_range((ulong
)buf
, (ulong
)buf
+buf_len
);
419 static void ahci_set_feature(struct ahci_uc_priv
*uc_priv
, u8 port
)
421 struct sata_fis_h2d h2d
__aligned(ARCH_DMA_MINALIGN
);
422 struct sata_fis_h2d
*cfis
= &h2d
;
424 memset(cfis
, 0, sizeof(struct sata_fis_h2d
));
425 cfis
->fis_type
= SATA_FIS_TYPE_REGISTER_H2D
;
426 cfis
->pm_port_c
= 1 << 7;
427 cfis
->command
= ATA_CMD_SET_FEATURES
;
428 cfis
->features
= SETFEATURES_XFER
;
429 cfis
->sector_count
= ffs(uc_priv
->udma_mask
+ 1) + 0x3e;
431 ahci_exec_ata_cmd(uc_priv
, port
, cfis
, NULL
, 0, READ_CMD
);
434 static int ahci_port_start(struct ahci_uc_priv
*uc_priv
, u8 port
)
436 struct ahci_ioports
*pp
= &uc_priv
->port
[port
];
437 struct sata_port_regs
*port_mmio
= pp
->port_mmio
;
440 int timeout
= 10000000;
442 debug("Enter start port: %d\n", port
);
443 port_status
= readl(&port_mmio
->ssts
);
444 debug("Port %d status: %x\n", port
, port_status
);
445 if ((port_status
& 0xf) != 0x03) {
446 printf("No Link on this port!\n");
450 mem
= (u32
)malloc(AHCI_PORT_PRIV_DMA_SZ
+ 1024);
453 printf("No mem for table!\n");
457 mem
= (mem
+ 0x400) & (~0x3ff); /* Aligned to 1024-bytes */
458 memset((u8
*)mem
, 0, AHCI_PORT_PRIV_DMA_SZ
);
461 * First item in chunk of DMA memory: 32-slot command table,
462 * 32 bytes each in size
464 pp
->cmd_slot
= (struct ahci_cmd_hdr
*)mem
;
465 debug("cmd_slot = 0x%x\n", (unsigned int) pp
->cmd_slot
);
466 mem
+= (AHCI_CMD_SLOT_SZ
* DWC_AHSATA_MAX_CMD_SLOTS
);
469 * Second item: Received-FIS area, 256-Byte aligned
472 mem
+= AHCI_RX_FIS_SZ
;
475 * Third item: data area for storing a single command
476 * and its scatter-gather table
479 debug("cmd_tbl_dma = 0x%lx\n", pp
->cmd_tbl
);
481 mem
+= AHCI_CMD_TBL_HDR
;
483 writel_with_flush(0x00004444, &port_mmio
->dmacr
);
484 pp
->cmd_tbl_sg
= (struct ahci_sg
*)mem
;
485 writel_with_flush((u32
)pp
->cmd_slot
, &port_mmio
->clb
);
486 writel_with_flush(pp
->rx_fis
, &port_mmio
->fb
);
489 writel_with_flush((SATA_PORT_CMD_FRE
| readl(&port_mmio
->cmd
)),
492 /* Wait device ready */
493 while ((readl(&port_mmio
->tfd
) & (SATA_PORT_TFD_STS_ERR
|
494 SATA_PORT_TFD_STS_DRQ
| SATA_PORT_TFD_STS_BSY
))
498 debug("Device not ready for BSY, DRQ and"
503 writel_with_flush(PORT_CMD_ICC_ACTIVE
| PORT_CMD_FIS_RX
|
504 PORT_CMD_POWER_ON
| PORT_CMD_SPIN_UP
|
505 PORT_CMD_START
, &port_mmio
->cmd
);
507 debug("Exit start port %d\n", port
);
512 static void dwc_ahsata_print_info(struct blk_desc
*pdev
)
514 printf("SATA Device Info:\n\r");
515 #ifdef CONFIG_SYS_64BIT_LBA
516 printf("S/N: %s\n\rProduct model number: %s\n\r"
517 "Firmware version: %s\n\rCapacity: %lld sectors\n\r",
518 pdev
->product
, pdev
->vendor
, pdev
->revision
, pdev
->lba
);
520 printf("S/N: %s\n\rProduct model number: %s\n\r"
521 "Firmware version: %s\n\rCapacity: %ld sectors\n\r",
522 pdev
->product
, pdev
->vendor
, pdev
->revision
, pdev
->lba
);
526 static void dwc_ahsata_identify(struct ahci_uc_priv
*uc_priv
, u16
*id
)
528 struct sata_fis_h2d h2d
__aligned(ARCH_DMA_MINALIGN
);
529 struct sata_fis_h2d
*cfis
= &h2d
;
530 u8 port
= uc_priv
->hard_port_no
;
532 memset(cfis
, 0, sizeof(struct sata_fis_h2d
));
534 cfis
->fis_type
= SATA_FIS_TYPE_REGISTER_H2D
;
535 cfis
->pm_port_c
= 0x80; /* is command */
536 cfis
->command
= ATA_CMD_ID_ATA
;
538 ahci_exec_ata_cmd(uc_priv
, port
, cfis
, (u8
*)id
, ATA_ID_WORDS
* 2,
540 ata_swap_buf_le16(id
, ATA_ID_WORDS
);
543 static void dwc_ahsata_xfer_mode(struct ahci_uc_priv
*uc_priv
, u16
*id
)
545 uc_priv
->pio_mask
= id
[ATA_ID_PIO_MODES
];
546 uc_priv
->udma_mask
= id
[ATA_ID_UDMA_MODES
];
547 debug("pio %04x, udma %04x\n\r", uc_priv
->pio_mask
, uc_priv
->udma_mask
);
550 static u32
dwc_ahsata_rw_cmd(struct ahci_uc_priv
*uc_priv
, u32 start
,
551 u32 blkcnt
, u8
*buffer
, int is_write
)
553 struct sata_fis_h2d h2d
__aligned(ARCH_DMA_MINALIGN
);
554 struct sata_fis_h2d
*cfis
= &h2d
;
555 u8 port
= uc_priv
->hard_port_no
;
560 memset(cfis
, 0, sizeof(struct sata_fis_h2d
));
562 cfis
->fis_type
= SATA_FIS_TYPE_REGISTER_H2D
;
563 cfis
->pm_port_c
= 0x80; /* is command */
564 cfis
->command
= (is_write
) ? ATA_CMD_WRITE
: ATA_CMD_READ
;
565 cfis
->device
= ATA_LBA
;
567 cfis
->device
|= (block
>> 24) & 0xf;
568 cfis
->lba_high
= (block
>> 16) & 0xff;
569 cfis
->lba_mid
= (block
>> 8) & 0xff;
570 cfis
->lba_low
= block
& 0xff;
571 cfis
->sector_count
= (u8
)(blkcnt
& 0xff);
573 if (ahci_exec_ata_cmd(uc_priv
, port
, cfis
, buffer
,
574 ATA_SECT_SIZE
* blkcnt
, is_write
) > 0)
580 static void dwc_ahsata_flush_cache(struct ahci_uc_priv
*uc_priv
)
582 struct sata_fis_h2d h2d
__aligned(ARCH_DMA_MINALIGN
);
583 struct sata_fis_h2d
*cfis
= &h2d
;
584 u8 port
= uc_priv
->hard_port_no
;
586 memset(cfis
, 0, sizeof(struct sata_fis_h2d
));
588 cfis
->fis_type
= SATA_FIS_TYPE_REGISTER_H2D
;
589 cfis
->pm_port_c
= 0x80; /* is command */
590 cfis
->command
= ATA_CMD_FLUSH
;
592 ahci_exec_ata_cmd(uc_priv
, port
, cfis
, NULL
, 0, 0);
595 static u32
dwc_ahsata_rw_cmd_ext(struct ahci_uc_priv
*uc_priv
, u32 start
,
596 lbaint_t blkcnt
, u8
*buffer
, int is_write
)
598 struct sata_fis_h2d h2d
__aligned(ARCH_DMA_MINALIGN
);
599 struct sata_fis_h2d
*cfis
= &h2d
;
600 u8 port
= uc_priv
->hard_port_no
;
605 memset(cfis
, 0, sizeof(struct sata_fis_h2d
));
607 cfis
->fis_type
= SATA_FIS_TYPE_REGISTER_H2D
;
608 cfis
->pm_port_c
= 0x80; /* is command */
610 cfis
->command
= (is_write
) ? ATA_CMD_WRITE_EXT
613 cfis
->lba_high_exp
= (block
>> 40) & 0xff;
614 cfis
->lba_mid_exp
= (block
>> 32) & 0xff;
615 cfis
->lba_low_exp
= (block
>> 24) & 0xff;
616 cfis
->lba_high
= (block
>> 16) & 0xff;
617 cfis
->lba_mid
= (block
>> 8) & 0xff;
618 cfis
->lba_low
= block
& 0xff;
619 cfis
->device
= ATA_LBA
;
620 cfis
->sector_count_exp
= (blkcnt
>> 8) & 0xff;
621 cfis
->sector_count
= blkcnt
& 0xff;
623 if (ahci_exec_ata_cmd(uc_priv
, port
, cfis
, buffer
,
624 ATA_SECT_SIZE
* blkcnt
, is_write
) > 0)
630 static void dwc_ahsata_flush_cache_ext(struct ahci_uc_priv
*uc_priv
)
632 struct sata_fis_h2d h2d
__aligned(ARCH_DMA_MINALIGN
);
633 struct sata_fis_h2d
*cfis
= &h2d
;
634 u8 port
= uc_priv
->hard_port_no
;
636 memset(cfis
, 0, sizeof(struct sata_fis_h2d
));
638 cfis
->fis_type
= SATA_FIS_TYPE_REGISTER_H2D
;
639 cfis
->pm_port_c
= 0x80; /* is command */
640 cfis
->command
= ATA_CMD_FLUSH_EXT
;
642 ahci_exec_ata_cmd(uc_priv
, port
, cfis
, NULL
, 0, 0);
645 static void dwc_ahsata_init_wcache(struct ahci_uc_priv
*uc_priv
, u16
*id
)
647 if (ata_id_has_wcache(id
) && ata_id_wcache_enabled(id
))
648 uc_priv
->flags
|= SATA_FLAG_WCACHE
;
649 if (ata_id_has_flush(id
))
650 uc_priv
->flags
|= SATA_FLAG_FLUSH
;
651 if (ata_id_has_flush_ext(id
))
652 uc_priv
->flags
|= SATA_FLAG_FLUSH_EXT
;
655 static u32
ata_low_level_rw_lba48(struct ahci_uc_priv
*uc_priv
, u32 blknr
,
656 lbaint_t blkcnt
, const void *buffer
,
667 max_blks
= ATA_MAX_SECTORS_LBA48
;
670 if (blks
> max_blks
) {
671 if (max_blks
!= dwc_ahsata_rw_cmd_ext(uc_priv
, start
,
677 addr
+= ATA_SECT_SIZE
* max_blks
;
679 if (blks
!= dwc_ahsata_rw_cmd_ext(uc_priv
, start
, blks
,
684 addr
+= ATA_SECT_SIZE
* blks
;
691 static u32
ata_low_level_rw_lba28(struct ahci_uc_priv
*uc_priv
, u32 blknr
,
692 lbaint_t blkcnt
, const void *buffer
,
703 max_blks
= ATA_MAX_SECTORS
;
705 if (blks
> max_blks
) {
706 if (max_blks
!= dwc_ahsata_rw_cmd(uc_priv
, start
,
712 addr
+= ATA_SECT_SIZE
* max_blks
;
714 if (blks
!= dwc_ahsata_rw_cmd(uc_priv
, start
, blks
,
719 addr
+= ATA_SECT_SIZE
* blks
;
726 static int dwc_ahci_start_ports(struct ahci_uc_priv
*uc_priv
)
731 linkmap
= uc_priv
->link_port_map
;
734 printf("No port device detected!\n");
738 for (i
= 0; i
< uc_priv
->n_ports
; i
++) {
739 if ((linkmap
>> i
) && ((linkmap
>> i
) & 0x01)) {
740 if (ahci_port_start(uc_priv
, (u8
)i
)) {
741 printf("Can not start port %d\n", i
);
744 uc_priv
->hard_port_no
= i
;
752 static int dwc_ahsata_scan_common(struct ahci_uc_priv
*uc_priv
,
753 struct blk_desc
*pdev
)
755 u8 serial
[ATA_ID_SERNO_LEN
+ 1] = { 0 };
756 u8 firmware
[ATA_ID_FW_REV_LEN
+ 1] = { 0 };
757 u8 product
[ATA_ID_PROD_LEN
+ 1] = { 0 };
759 u8 port
= uc_priv
->hard_port_no
;
760 ALLOC_CACHE_ALIGN_BUFFER(u16
, id
, ATA_ID_WORDS
);
762 /* Identify device to get information */
763 dwc_ahsata_identify(uc_priv
, id
);
766 ata_id_c_string(id
, serial
, ATA_ID_SERNO
, sizeof(serial
));
767 memcpy(pdev
->product
, serial
, sizeof(serial
));
769 /* Firmware version */
770 ata_id_c_string(id
, firmware
, ATA_ID_FW_REV
, sizeof(firmware
));
771 memcpy(pdev
->revision
, firmware
, sizeof(firmware
));
774 ata_id_c_string(id
, product
, ATA_ID_PROD
, sizeof(product
));
775 memcpy(pdev
->vendor
, product
, sizeof(product
));
778 n_sectors
= ata_id_n_sectors(id
);
779 pdev
->lba
= (u32
)n_sectors
;
781 pdev
->type
= DEV_TYPE_HARDDISK
;
782 pdev
->blksz
= ATA_SECT_SIZE
;
785 /* Check if support LBA48 */
786 if (ata_id_has_lba48(id
)) {
788 debug("Device support LBA48\n\r");
791 /* Get the NCQ queue depth from device */
792 uc_priv
->flags
&= (~SATA_FLAG_Q_DEP_MASK
);
793 uc_priv
->flags
|= ata_id_queue_depth(id
);
795 /* Get the xfer mode from device */
796 dwc_ahsata_xfer_mode(uc_priv
, id
);
798 /* Get the write cache status from device */
799 dwc_ahsata_init_wcache(uc_priv
, id
);
801 /* Set the xfer mode to highest speed */
802 ahci_set_feature(uc_priv
, port
);
804 dwc_ahsata_print_info(pdev
);
810 * SATA interface between low level driver and command layer
812 static ulong
sata_read_common(struct ahci_uc_priv
*uc_priv
,
813 struct blk_desc
*desc
, ulong blknr
,
814 lbaint_t blkcnt
, void *buffer
)
819 rc
= ata_low_level_rw_lba48(uc_priv
, blknr
, blkcnt
, buffer
,
822 rc
= ata_low_level_rw_lba28(uc_priv
, blknr
, blkcnt
, buffer
,
828 static ulong
sata_write_common(struct ahci_uc_priv
*uc_priv
,
829 struct blk_desc
*desc
, ulong blknr
,
830 lbaint_t blkcnt
, const void *buffer
)
833 u32 flags
= uc_priv
->flags
;
836 rc
= ata_low_level_rw_lba48(uc_priv
, blknr
, blkcnt
, buffer
,
838 if ((flags
& SATA_FLAG_WCACHE
) && (flags
& SATA_FLAG_FLUSH_EXT
))
839 dwc_ahsata_flush_cache_ext(uc_priv
);
841 rc
= ata_low_level_rw_lba28(uc_priv
, blknr
, blkcnt
, buffer
,
843 if ((flags
& SATA_FLAG_WCACHE
) && (flags
& SATA_FLAG_FLUSH
))
844 dwc_ahsata_flush_cache(uc_priv
);
850 #if !CONFIG_IS_ENABLED(AHCI)
851 static int ahci_init_one(int pdev
)
854 struct ahci_uc_priv
*uc_priv
= NULL
;
856 uc_priv
= malloc(sizeof(struct ahci_uc_priv
));
857 memset(uc_priv
, 0, sizeof(struct ahci_uc_priv
));
860 uc_priv
->host_flags
= ATA_FLAG_SATA
866 uc_priv
->mmio_base
= (void __iomem
*)CONFIG_DWC_AHSATA_BASE_ADDR
;
868 /* initialize adapter */
869 rc
= ahci_host_init(uc_priv
);
873 ahci_print_info(uc_priv
);
875 /* Save the uc_private struct to block device struct */
876 sata_dev_desc
[pdev
].priv
= uc_priv
;
884 int init_sata(int dev
)
886 struct ahci_uc_priv
*uc_priv
= NULL
;
888 #if defined(CONFIG_MX6)
889 if (!is_mx6dq() && !is_mx6dqp())
892 if (dev
< 0 || dev
> (CONFIG_SYS_SATA_MAX_DEVICE
- 1)) {
893 printf("The sata index %d is out of ranges\n\r", dev
);
899 uc_priv
= sata_dev_desc
[dev
].priv
;
901 return dwc_ahci_start_ports(uc_priv
) ? 1 : 0;
904 int reset_sata(int dev
)
906 struct ahci_uc_priv
*uc_priv
;
907 struct sata_host_regs
*host_mmio
;
909 if (dev
< 0 || dev
> (CONFIG_SYS_SATA_MAX_DEVICE
- 1)) {
910 printf("The sata index %d is out of ranges\n\r", dev
);
914 uc_priv
= sata_dev_desc
[dev
].priv
;
916 /* not initialized, so nothing to reset */
919 host_mmio
= uc_priv
->mmio_base
;
920 setbits_le32(&host_mmio
->ghc
, SATA_HOST_GHC_HR
);
921 while (readl(&host_mmio
->ghc
) & SATA_HOST_GHC_HR
)
927 int sata_port_status(int dev
, int port
)
929 struct sata_port_regs
*port_mmio
;
930 struct ahci_uc_priv
*uc_priv
= NULL
;
932 if (dev
< 0 || dev
> (CONFIG_SYS_SATA_MAX_DEVICE
- 1))
935 if (sata_dev_desc
[dev
].priv
== NULL
)
938 uc_priv
= sata_dev_desc
[dev
].priv
;
939 port_mmio
= uc_priv
->port
[port
].port_mmio
;
941 return readl(&port_mmio
->ssts
) & SATA_PORT_SSTS_DET_MASK
;
945 * SATA interface between low level driver and command layer
947 ulong
sata_read(int dev
, ulong blknr
, lbaint_t blkcnt
, void *buffer
)
949 struct ahci_uc_priv
*uc_priv
= sata_dev_desc
[dev
].priv
;
951 return sata_read_common(uc_priv
, &sata_dev_desc
[dev
], blknr
, blkcnt
,
955 ulong
sata_write(int dev
, ulong blknr
, lbaint_t blkcnt
, const void *buffer
)
957 struct ahci_uc_priv
*uc_priv
= sata_dev_desc
[dev
].priv
;
959 return sata_write_common(uc_priv
, &sata_dev_desc
[dev
], blknr
, blkcnt
,
963 int scan_sata(int dev
)
965 struct ahci_uc_priv
*uc_priv
= sata_dev_desc
[dev
].priv
;
966 struct blk_desc
*pdev
= &sata_dev_desc
[dev
];
968 return dwc_ahsata_scan_common(uc_priv
, pdev
);
970 #endif /* CONFIG_IS_ENABLED(AHCI) */
972 #if CONFIG_IS_ENABLED(AHCI)
974 int dwc_ahsata_port_status(struct udevice
*dev
, int port
)
976 struct ahci_uc_priv
*uc_priv
= dev_get_uclass_priv(dev
);
977 struct sata_port_regs
*port_mmio
;
979 port_mmio
= uc_priv
->port
[port
].port_mmio
;
980 return readl(&port_mmio
->ssts
) & SATA_PORT_SSTS_DET_MASK
? 0 : -ENXIO
;
983 int dwc_ahsata_bus_reset(struct udevice
*dev
)
985 struct ahci_uc_priv
*uc_priv
= dev_get_uclass_priv(dev
);
986 struct sata_host_regs
*host_mmio
= uc_priv
->mmio_base
;
988 setbits_le32(&host_mmio
->ghc
, SATA_HOST_GHC_HR
);
989 while (readl(&host_mmio
->ghc
) & SATA_HOST_GHC_HR
)
995 int dwc_ahsata_scan(struct udevice
*dev
)
997 struct ahci_uc_priv
*uc_priv
= dev_get_uclass_priv(dev
);
998 struct blk_desc
*desc
;
1003 * Create only one block device and do detection
1004 * to make sure that there won't be a lot of
1005 * block devices created
1007 device_find_first_child(dev
, &blk
);
1009 ret
= blk_create_devicef(dev
, "dwc_ahsata_blk", "blk",
1010 IF_TYPE_SATA
, -1, 512, 0, &blk
);
1012 debug("Can't create device\n");
1017 desc
= dev_get_uclass_platdata(blk
);
1018 ret
= dwc_ahsata_scan_common(uc_priv
, desc
);
1020 debug("%s: Failed to scan bus\n", __func__
);
1027 int dwc_ahsata_probe(struct udevice
*dev
)
1029 struct ahci_uc_priv
*uc_priv
= dev_get_uclass_priv(dev
);
1032 uc_priv
->host_flags
= ATA_FLAG_SATA
| ATA_FLAG_NO_LEGACY
|
1033 ATA_FLAG_MMIO
| ATA_FLAG_PIO_DMA
| ATA_FLAG_NO_ATAPI
;
1034 uc_priv
->mmio_base
= (void __iomem
*)dev_read_addr(dev
);
1036 /* initialize adapter */
1037 ret
= ahci_host_init(uc_priv
);
1041 ahci_print_info(uc_priv
);
1043 return dwc_ahci_start_ports(uc_priv
);
1046 static ulong
dwc_ahsata_read(struct udevice
*blk
, lbaint_t blknr
,
1047 lbaint_t blkcnt
, void *buffer
)
1049 struct blk_desc
*desc
= dev_get_uclass_platdata(blk
);
1050 struct udevice
*dev
= dev_get_parent(blk
);
1051 struct ahci_uc_priv
*uc_priv
;
1053 uc_priv
= dev_get_uclass_priv(dev
);
1054 return sata_read_common(uc_priv
, desc
, blknr
, blkcnt
, buffer
);
1057 static ulong
dwc_ahsata_write(struct udevice
*blk
, lbaint_t blknr
,
1058 lbaint_t blkcnt
, const void *buffer
)
1060 struct blk_desc
*desc
= dev_get_uclass_platdata(blk
);
1061 struct udevice
*dev
= dev_get_parent(blk
);
1062 struct ahci_uc_priv
*uc_priv
;
1064 uc_priv
= dev_get_uclass_priv(dev
);
1065 return sata_write_common(uc_priv
, desc
, blknr
, blkcnt
, buffer
);
1068 static const struct blk_ops dwc_ahsata_blk_ops
= {
1069 .read
= dwc_ahsata_read
,
1070 .write
= dwc_ahsata_write
,
1073 U_BOOT_DRIVER(dwc_ahsata_blk
) = {
1074 .name
= "dwc_ahsata_blk",
1076 .ops
= &dwc_ahsata_blk_ops
,