blob: 75101b5d798dd8c9a2a03a5f2576a652f65c54cf [file] [log] [blame]
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09001/*
2 * sata_dwc.c
3 *
4 * Synopsys DesignWare Cores (DWC) SATA host driver
5 *
6 * Author: Mark Miesfeld <mmiesfeld@amcc.com>
7 *
8 * Ported from 2.6.19.2 to 2.6.25/26 by Stefan Roese <sr@denx.de>
9 * Copyright 2008 DENX Software Engineering
10 *
11 * Based on versions provided by AMCC and Synopsys which are:
12 * Copyright 2006 Applied Micro Circuits Corporation
13 * COPYRIGHT (C) 2005 SYNOPSYS, INC. ALL RIGHTS RESERVED
14 *
15 * This program is free software; you can redistribute
16 * it and/or modify it under the terms of the GNU
17 * General Public License as published by the
18 * Free Software Foundation; either version 2 of the License,
19 * or (at your option) any later version.
20 *
21 */
22/*
23 * SATA support based on the chip canyonlands.
24 *
25 * 04-17-2009
26 * The local version of this driver for the canyonlands board
27 * does not use interrupts but polls the chip instead.
28 */
29
30#include <common.h>
31#include <command.h>
32#include <pci.h>
33#include <asm/processor.h>
34#include <asm/errno.h>
35#include <asm/io.h>
36#include <malloc.h>
37#include <ata.h>
38#include <linux/ctype.h>
39
40#include "sata_dwc.h"
41
42#define DMA_NUM_CHANS 1
43#define DMA_NUM_CHAN_REGS 8
44
45#define AHB_DMA_BRST_DFLT 16
46
47struct dmareg {
48 u32 low;
49 u32 high;
50};
51
52struct dma_chan_regs {
53 struct dmareg sar;
54 struct dmareg dar;
55 struct dmareg llp;
56 struct dmareg ctl;
57 struct dmareg sstat;
58 struct dmareg dstat;
59 struct dmareg sstatar;
60 struct dmareg dstatar;
61 struct dmareg cfg;
62 struct dmareg sgr;
63 struct dmareg dsr;
64};
65
66struct dma_interrupt_regs {
67 struct dmareg tfr;
68 struct dmareg block;
69 struct dmareg srctran;
70 struct dmareg dsttran;
71 struct dmareg error;
72};
73
74struct ahb_dma_regs {
75 struct dma_chan_regs chan_regs[DMA_NUM_CHAN_REGS];
76 struct dma_interrupt_regs interrupt_raw;
77 struct dma_interrupt_regs interrupt_status;
78 struct dma_interrupt_regs interrupt_mask;
79 struct dma_interrupt_regs interrupt_clear;
80 struct dmareg statusInt;
81 struct dmareg rq_srcreg;
82 struct dmareg rq_dstreg;
83 struct dmareg rq_sgl_srcreg;
84 struct dmareg rq_sgl_dstreg;
85 struct dmareg rq_lst_srcreg;
86 struct dmareg rq_lst_dstreg;
87 struct dmareg dma_cfg;
88 struct dmareg dma_chan_en;
89 struct dmareg dma_id;
90 struct dmareg dma_test;
91 struct dmareg res1;
92 struct dmareg res2;
93 /* DMA Comp Params
94 * Param 6 = dma_param[0], Param 5 = dma_param[1],
95 * Param 4 = dma_param[2] ...
96 */
97 struct dmareg dma_params[6];
98};
99
100#define DMA_EN 0x00000001
101#define DMA_DI 0x00000000
102#define DMA_CHANNEL(ch) (0x00000001 << (ch))
103#define DMA_ENABLE_CHAN(ch) ((0x00000001 << (ch)) | \
104 ((0x000000001 << (ch)) << 8))
105#define DMA_DISABLE_CHAN(ch) (0x00000000 | \
106 ((0x000000001 << (ch)) << 8))
107
108#define SATA_DWC_MAX_PORTS 1
109#define SATA_DWC_SCR_OFFSET 0x24
110#define SATA_DWC_REG_OFFSET 0x64
111
112struct sata_dwc_regs {
113 u32 fptagr;
114 u32 fpbor;
115 u32 fptcr;
116 u32 dmacr;
117 u32 dbtsr;
118 u32 intpr;
119 u32 intmr;
120 u32 errmr;
121 u32 llcr;
122 u32 phycr;
123 u32 physr;
124 u32 rxbistpd;
125 u32 rxbistpd1;
126 u32 rxbistpd2;
127 u32 txbistpd;
128 u32 txbistpd1;
129 u32 txbistpd2;
130 u32 bistcr;
131 u32 bistfctr;
132 u32 bistsr;
133 u32 bistdecr;
134 u32 res[15];
135 u32 testr;
136 u32 versionr;
137 u32 idr;
138 u32 unimpl[192];
139 u32 dmadr[256];
140};
141
142#define SATA_DWC_TXFIFO_DEPTH 0x01FF
143#define SATA_DWC_RXFIFO_DEPTH 0x01FF
144
145#define SATA_DWC_DBTSR_MWR(size) ((size / 4) & SATA_DWC_TXFIFO_DEPTH)
146#define SATA_DWC_DBTSR_MRD(size) (((size / 4) & \
147 SATA_DWC_RXFIFO_DEPTH) << 16)
148#define SATA_DWC_INTPR_DMAT 0x00000001
149#define SATA_DWC_INTPR_NEWFP 0x00000002
150#define SATA_DWC_INTPR_PMABRT 0x00000004
151#define SATA_DWC_INTPR_ERR 0x00000008
152#define SATA_DWC_INTPR_NEWBIST 0x00000010
153#define SATA_DWC_INTPR_IPF 0x10000000
154#define SATA_DWC_INTMR_DMATM 0x00000001
155#define SATA_DWC_INTMR_NEWFPM 0x00000002
156#define SATA_DWC_INTMR_PMABRTM 0x00000004
157#define SATA_DWC_INTMR_ERRM 0x00000008
158#define SATA_DWC_INTMR_NEWBISTM 0x00000010
159
160#define SATA_DWC_DMACR_TMOD_TXCHEN 0x00000004
161#define SATA_DWC_DMACR_TXRXCH_CLEAR SATA_DWC_DMACR_TMOD_TXCHEN
162
163#define SATA_DWC_QCMD_MAX 32
164
165#define SATA_DWC_SERROR_ERR_BITS 0x0FFF0F03
166
167#define HSDEVP_FROM_AP(ap) (struct sata_dwc_device_port*) \
168 (ap)->private_data
169
170struct sata_dwc_device {
171 struct device *dev;
172 struct ata_probe_ent *pe;
173 struct ata_host *host;
174 u8 *reg_base;
175 struct sata_dwc_regs *sata_dwc_regs;
176 int irq_dma;
177};
178
179struct sata_dwc_device_port {
180 struct sata_dwc_device *hsdev;
181 int cmd_issued[SATA_DWC_QCMD_MAX];
182 u32 dma_chan[SATA_DWC_QCMD_MAX];
183 int dma_pending[SATA_DWC_QCMD_MAX];
184};
185
186enum {
187 SATA_DWC_CMD_ISSUED_NOT = 0,
188 SATA_DWC_CMD_ISSUED_PEND = 1,
189 SATA_DWC_CMD_ISSUED_EXEC = 2,
190 SATA_DWC_CMD_ISSUED_NODATA = 3,
191
192 SATA_DWC_DMA_PENDING_NONE = 0,
193 SATA_DWC_DMA_PENDING_TX = 1,
194 SATA_DWC_DMA_PENDING_RX = 2,
195};
196
197#define msleep(a) udelay(a * 1000)
198#define ssleep(a) msleep(a * 1000)
199
200static int ata_probe_timeout = (ATA_TMOUT_INTERNAL / 100);
201
202enum sata_dev_state {
203 SATA_INIT = 0,
204 SATA_READY = 1,
205 SATA_NODEVICE = 2,
206 SATA_ERROR = 3,
207};
208enum sata_dev_state dev_state = SATA_INIT;
209
210static struct ahb_dma_regs *sata_dma_regs = 0;
211static struct ata_host *phost;
212static struct ata_port ap;
213static struct ata_port *pap = &ap;
214static struct ata_device ata_device;
215static struct sata_dwc_device_port dwc_devp;
216
217static void *scr_addr_sstatus;
218static u32 temp_n_block = 0;
219
220static unsigned ata_exec_internal(struct ata_device *dev,
221 struct ata_taskfile *tf, const u8 *cdb,
222 int dma_dir, unsigned int buflen,
223 unsigned long timeout);
224static unsigned int ata_dev_set_feature(struct ata_device *dev,
225 u8 enable,u8 feature);
226static unsigned int ata_dev_init_params(struct ata_device *dev,
227 u16 heads, u16 sectors);
228static u8 ata_irq_on(struct ata_port *ap);
229static struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
230 unsigned int tag);
231static int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
232 u8 status, int in_wq);
233static void ata_tf_to_host(struct ata_port *ap,
234 const struct ata_taskfile *tf);
235static void ata_exec_command(struct ata_port *ap,
236 const struct ata_taskfile *tf);
237static unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
238static u8 ata_check_altstatus(struct ata_port *ap);
239static u8 ata_check_status(struct ata_port *ap);
240static void ata_dev_select(struct ata_port *ap, unsigned int device,
241 unsigned int wait, unsigned int can_sleep);
242static void ata_qc_issue(struct ata_queued_cmd *qc);
243static void ata_tf_load(struct ata_port *ap,
244 const struct ata_taskfile *tf);
245static int ata_dev_read_sectors(unsigned char* pdata,
246 unsigned long datalen, u32 block, u32 n_block);
247static int ata_dev_write_sectors(unsigned char* pdata,
248 unsigned long datalen , u32 block, u32 n_block);
249static void ata_std_dev_select(struct ata_port *ap, unsigned int device);
250static void ata_qc_complete(struct ata_queued_cmd *qc);
251static void __ata_qc_complete(struct ata_queued_cmd *qc);
252static void fill_result_tf(struct ata_queued_cmd *qc);
253static void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
254static void ata_mmio_data_xfer(struct ata_device *dev,
255 unsigned char *buf,
256 unsigned int buflen,int do_write);
257static void ata_pio_task(struct ata_port *arg_ap);
258static void __ata_port_freeze(struct ata_port *ap);
259static int ata_port_freeze(struct ata_port *ap);
260static void ata_qc_free(struct ata_queued_cmd *qc);
261static void ata_pio_sectors(struct ata_queued_cmd *qc);
262static void ata_pio_sector(struct ata_queued_cmd *qc);
263static void ata_pio_queue_task(struct ata_port *ap,
264 void *data,unsigned long delay);
265static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq);
266static int sata_dwc_softreset(struct ata_port *ap);
267static int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
268 unsigned int flags, u16 *id);
269static int check_sata_dev_state(void);
270
271extern block_dev_desc_t sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE];
272
273static const struct ata_port_info sata_dwc_port_info[] = {
274 {
275 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
276 ATA_FLAG_MMIO | ATA_FLAG_PIO_POLLING |
277 ATA_FLAG_SRST | ATA_FLAG_NCQ,
278 .pio_mask = 0x1f,
279 .mwdma_mask = 0x07,
280 .udma_mask = 0x7f,
281 },
282};
283
284int init_sata(int dev)
285{
286 struct sata_dwc_device hsdev;
287 struct ata_host host;
288 struct ata_port_info pi = sata_dwc_port_info[0];
289 struct ata_link *link;
290 struct sata_dwc_device_port hsdevp = dwc_devp;
291 u8 *base = 0;
292 u8 *sata_dma_regs_addr = 0;
293 u8 status;
294 unsigned long base_addr = 0;
295 int chan = 0;
296 int rc;
297 int i;
298
299 phost = &host;
300
301 base = (u8*)SATA_BASE_ADDR;
302
303 hsdev.sata_dwc_regs = (void *__iomem)(base + SATA_DWC_REG_OFFSET);
304
305 host.n_ports = SATA_DWC_MAX_PORTS;
306
307 for (i = 0; i < SATA_DWC_MAX_PORTS; i++) {
308 ap.pflags |= ATA_PFLAG_INITIALIZING;
309 ap.flags = ATA_FLAG_DISABLED;
310 ap.print_id = -1;
311 ap.ctl = ATA_DEVCTL_OBS;
312 ap.host = &host;
313 ap.last_ctl = 0xFF;
314
315 link = &ap.link;
316 link->ap = &ap;
317 link->pmp = 0;
318 link->active_tag = ATA_TAG_POISON;
319 link->hw_sata_spd_limit = 0;
320
321 ap.port_no = i;
322 host.ports[i] = &ap;
323 }
324
325 ap.pio_mask = pi.pio_mask;
326 ap.mwdma_mask = pi.mwdma_mask;
327 ap.udma_mask = pi.udma_mask;
328 ap.flags |= pi.flags;
329 ap.link.flags |= pi.link_flags;
330
331 host.ports[0]->ioaddr.cmd_addr = base;
332 host.ports[0]->ioaddr.scr_addr = base + SATA_DWC_SCR_OFFSET;
333 scr_addr_sstatus = base + SATA_DWC_SCR_OFFSET;
334
335 base_addr = (unsigned long)base;
336
337 host.ports[0]->ioaddr.cmd_addr = (void *)base_addr + 0x00;
338 host.ports[0]->ioaddr.data_addr = (void *)base_addr + 0x00;
339
340 host.ports[0]->ioaddr.error_addr = (void *)base_addr + 0x04;
341 host.ports[0]->ioaddr.feature_addr = (void *)base_addr + 0x04;
342
343 host.ports[0]->ioaddr.nsect_addr = (void *)base_addr + 0x08;
344
345 host.ports[0]->ioaddr.lbal_addr = (void *)base_addr + 0x0c;
346 host.ports[0]->ioaddr.lbam_addr = (void *)base_addr + 0x10;
347 host.ports[0]->ioaddr.lbah_addr = (void *)base_addr + 0x14;
348
349 host.ports[0]->ioaddr.device_addr = (void *)base_addr + 0x18;
350 host.ports[0]->ioaddr.command_addr = (void *)base_addr + 0x1c;
351 host.ports[0]->ioaddr.status_addr = (void *)base_addr + 0x1c;
352
353 host.ports[0]->ioaddr.altstatus_addr = (void *)base_addr + 0x20;
354 host.ports[0]->ioaddr.ctl_addr = (void *)base_addr + 0x20;
355
356 sata_dma_regs_addr = (u8*)SATA_DMA_REG_ADDR;
357 sata_dma_regs = (void *__iomem)sata_dma_regs_addr;
358
359 status = ata_check_altstatus(&ap);
360
361 if (status == 0x7f) {
362 printf("Hard Disk not found.\n");
363 dev_state = SATA_NODEVICE;
364 rc = FALSE;
365 return rc;
366 }
367
368 printf("Waiting for device...");
369 i = 0;
370 while (1) {
371 udelay(10000);
372
373 status = ata_check_altstatus(&ap);
374
375 if ((status & ATA_BUSY) == 0) {
376 printf("\n");
377 break;
378 }
379
380 i++;
381 if (i > (ATA_RESET_TIME * 100)) {
382 printf("** TimeOUT **\n");
383
384 dev_state = SATA_NODEVICE;
385 rc = FALSE;
386 return rc;
387 }
388 if ((i >= 100) && ((i % 100) == 0))
389 printf(".");
390 }
391
392 rc = sata_dwc_softreset(&ap);
393
394 if (rc) {
395 printf("sata_dwc : error. soft reset failed\n");
396 return rc;
397 }
398
399 for (chan = 0; chan < DMA_NUM_CHANS; chan++) {
400 out_le32(&(sata_dma_regs->interrupt_mask.error.low),
401 DMA_DISABLE_CHAN(chan));
402
403 out_le32(&(sata_dma_regs->interrupt_mask.tfr.low),
404 DMA_DISABLE_CHAN(chan));
405 }
406
407 out_le32(&(sata_dma_regs->dma_cfg.low), DMA_DI);
408
409 out_le32(&hsdev.sata_dwc_regs->intmr,
410 SATA_DWC_INTMR_ERRM |
411 SATA_DWC_INTMR_PMABRTM);
412
413 /* Unmask the error bits that should trigger
414 * an error interrupt by setting the error mask register.
415 */
416 out_le32(&hsdev.sata_dwc_regs->errmr, SATA_DWC_SERROR_ERR_BITS);
417
418 hsdev.host = ap.host;
419 memset(&hsdevp, 0, sizeof(hsdevp));
420 hsdevp.hsdev = &hsdev;
421
422 for (i = 0; i < SATA_DWC_QCMD_MAX; i++)
423 hsdevp.cmd_issued[i] = SATA_DWC_CMD_ISSUED_NOT;
424
425 out_le32((void __iomem *)scr_addr_sstatus + 4,
426 in_le32((void __iomem *)scr_addr_sstatus + 4));
427
428 rc = 0;
429 return rc;
430}
431
432static u8 ata_check_altstatus(struct ata_port *ap)
433{
434 u8 val = 0;
435 val = readb(ap->ioaddr.altstatus_addr);
436 return val;
437}
438
439static int sata_dwc_softreset(struct ata_port *ap)
440{
441 u8 nsect,lbal = 0;
442 u8 tmp = 0;
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900443 struct ata_ioports *ioaddr = &ap->ioaddr;
444
Stefan Roese13a8c8d2011-11-15 08:02:49 +0000445 in_le32((void *)ap->ioaddr.scr_addr + (SCR_ERROR * 4));
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900446
447 writeb(0x55, ioaddr->nsect_addr);
448 writeb(0xaa, ioaddr->lbal_addr);
449 writeb(0xaa, ioaddr->nsect_addr);
450 writeb(0x55, ioaddr->lbal_addr);
451 writeb(0x55, ioaddr->nsect_addr);
452 writeb(0xaa, ioaddr->lbal_addr);
453
454 nsect = readb(ioaddr->nsect_addr);
455 lbal = readb(ioaddr->lbal_addr);
456
457 if ((nsect == 0x55) && (lbal == 0xaa)) {
458 printf("Device found\n");
459 } else {
460 printf("No device found\n");
461 dev_state = SATA_NODEVICE;
462 return FALSE;
463 }
464
465 tmp = ATA_DEVICE_OBS;
466 writeb(tmp, ioaddr->device_addr);
467 writeb(ap->ctl, ioaddr->ctl_addr);
468
469 udelay(200);
470
471 writeb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
472
473 udelay(200);
474 writeb(ap->ctl, ioaddr->ctl_addr);
475
476 msleep(150);
Stefan Roese13a8c8d2011-11-15 08:02:49 +0000477 ata_check_status(ap);
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900478
479 msleep(50);
480 ata_check_status(ap);
481
482 while (1) {
483 u8 status = ata_check_status(ap);
484
485 if (!(status & ATA_BUSY))
486 break;
487
488 printf("Hard Disk status is BUSY.\n");
489 msleep(50);
490 }
491
492 tmp = ATA_DEVICE_OBS;
493 writeb(tmp, ioaddr->device_addr);
494
495 nsect = readb(ioaddr->nsect_addr);
496 lbal = readb(ioaddr->lbal_addr);
497
498 return 0;
499}
500
501static u8 ata_check_status(struct ata_port *ap)
502{
503 u8 val = 0;
504 val = readb(ap->ioaddr.status_addr);
505 return val;
506}
507
508static int ata_id_has_hipm(const u16 *id)
509{
510 u16 val = id[76];
511
512 if (val == 0 || val == 0xffff)
513 return -1;
514
515 return val & (1 << 9);
516}
517
518static int ata_id_has_dipm(const u16 *id)
519{
520 u16 val = id[78];
521
522 if (val == 0 || val == 0xffff)
523 return -1;
524
525 return val & (1 << 3);
526}
527
528int scan_sata(int dev)
529{
530 int i;
531 int rc;
532 u8 status;
533 const u16 *id;
534 struct ata_device *ata_dev = &ata_device;
Wolfgang Denk24ec52d2011-11-29 22:17:46 +0000535 unsigned long pio_mask, mwdma_mask;
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900536 char revbuf[7];
537 u16 iobuf[ATA_SECTOR_WORDS];
538
539 memset(iobuf, 0, sizeof(iobuf));
540
541 if (dev_state == SATA_NODEVICE)
542 return 1;
543
544 printf("Waiting for device...");
545 i = 0;
546 while (1) {
547 udelay(10000);
548
549 status = ata_check_altstatus(&ap);
550
551 if ((status & ATA_BUSY) == 0) {
552 printf("\n");
553 break;
554 }
555
556 i++;
557 if (i > (ATA_RESET_TIME * 100)) {
558 printf("** TimeOUT **\n");
559
560 dev_state = SATA_NODEVICE;
561 return 1;
562 }
563 if ((i >= 100) && ((i % 100) == 0))
564 printf(".");
565 }
566
567 udelay(1000);
568
569 rc = ata_dev_read_id(ata_dev, &ata_dev->class,
570 ATA_READID_POSTRESET,ata_dev->id);
571 if (rc) {
572 printf("sata_dwc : error. failed sata scan\n");
573 return 1;
574 }
575
576 /* SATA drives indicate we have a bridge. We don't know which
577 * end of the link the bridge is which is a problem
578 */
579 if (ata_id_is_sata(ata_dev->id))
580 ap.cbl = ATA_CBL_SATA;
581
582 id = ata_dev->id;
583
584 ata_dev->flags &= ~ATA_DFLAG_CFG_MASK;
585 ata_dev->max_sectors = 0;
586 ata_dev->cdb_len = 0;
587 ata_dev->n_sectors = 0;
588 ata_dev->cylinders = 0;
589 ata_dev->heads = 0;
590 ata_dev->sectors = 0;
591
592 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
593 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
594 pio_mask <<= 3;
595 pio_mask |= 0x7;
596 } else {
597 /* If word 64 isn't valid then Word 51 high byte holds
598 * the PIO timing number for the maximum. Turn it into
599 * a mask.
600 */
601 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
602 if (mode < 5) {
603 pio_mask = (2 << mode) - 1;
604 } else {
605 pio_mask = 1;
606 }
607 }
608
609 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
610
611 if (ata_id_is_cfa(id)) {
612 int pio = id[163] & 0x7;
613 int dma = (id[163] >> 3) & 7;
614
615 if (pio)
616 pio_mask |= (1 << 5);
617 if (pio > 1)
618 pio_mask |= (1 << 6);
619 if (dma)
620 mwdma_mask |= (1 << 3);
621 if (dma > 1)
622 mwdma_mask |= (1 << 4);
623 }
624
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900625 if (ata_dev->class == ATA_DEV_ATA) {
626 if (ata_id_is_cfa(id)) {
627 if (id[162] & 1)
628 printf("supports DRM functions and may "
629 "not be fully accessable.\n");
630 sprintf(revbuf, "%s", "CFA");
631 } else {
632 if (ata_id_has_tpm(id))
633 printf("supports DRM functions and may "
634 "not be fully accessable.\n");
635 }
636
637 ata_dev->n_sectors = ata_id_n_sectors((u16*)id);
638
639 if (ata_dev->id[59] & 0x100)
640 ata_dev->multi_count = ata_dev->id[59] & 0xff;
641
642 if (ata_id_has_lba(id)) {
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900643 char ncq_desc[20];
644
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900645 ata_dev->flags |= ATA_DFLAG_LBA;
646 if (ata_id_has_lba48(id)) {
647 ata_dev->flags |= ATA_DFLAG_LBA48;
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900648
649 if (ata_dev->n_sectors >= (1UL << 28) &&
650 ata_id_has_flush_ext(id))
651 ata_dev->flags |= ATA_DFLAG_FLUSH_EXT;
652 }
653 if (!ata_id_has_ncq(ata_dev->id))
654 ncq_desc[0] = '\0';
655
656 if (ata_dev->horkage & ATA_HORKAGE_NONCQ)
657 sprintf(ncq_desc, "%s", "NCQ (not used)");
658
659 if (ap.flags & ATA_FLAG_NCQ)
660 ata_dev->flags |= ATA_DFLAG_NCQ;
661 }
662 ata_dev->cdb_len = 16;
663 }
664 ata_dev->max_sectors = ATA_MAX_SECTORS;
665 if (ata_dev->flags & ATA_DFLAG_LBA48)
666 ata_dev->max_sectors = ATA_MAX_SECTORS_LBA48;
667
668 if (!(ata_dev->horkage & ATA_HORKAGE_IPM)) {
669 if (ata_id_has_hipm(ata_dev->id))
670 ata_dev->flags |= ATA_DFLAG_HIPM;
671 if (ata_id_has_dipm(ata_dev->id))
672 ata_dev->flags |= ATA_DFLAG_DIPM;
673 }
674
675 if ((ap.cbl == ATA_CBL_SATA) && (!ata_id_is_sata(ata_dev->id))) {
676 ata_dev->udma_mask &= ATA_UDMA5;
677 ata_dev->max_sectors = ATA_MAX_SECTORS;
678 }
679
680 if (ata_dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
681 printf("Drive reports diagnostics failure."
682 "This may indicate a drive\n");
683 printf("fault or invalid emulation."
684 "Contact drive vendor for information.\n");
685 }
686
687 rc = check_sata_dev_state();
688
689 ata_id_c_string(ata_dev->id,
690 (unsigned char *)sata_dev_desc[dev].revision,
691 ATA_ID_FW_REV, sizeof(sata_dev_desc[dev].revision));
692 ata_id_c_string(ata_dev->id,
693 (unsigned char *)sata_dev_desc[dev].vendor,
694 ATA_ID_PROD, sizeof(sata_dev_desc[dev].vendor));
695 ata_id_c_string(ata_dev->id,
696 (unsigned char *)sata_dev_desc[dev].product,
697 ATA_ID_SERNO, sizeof(sata_dev_desc[dev].product));
698
699 sata_dev_desc[dev].lba = (u32) ata_dev->n_sectors;
700
701#ifdef CONFIG_LBA48
702 if (ata_dev->id[83] & (1 << 10)) {
703 sata_dev_desc[dev].lba48 = 1;
704 } else {
705 sata_dev_desc[dev].lba48 = 0;
706 }
707#endif
708
709 return 0;
710}
711
712static u8 ata_busy_wait(struct ata_port *ap,
713 unsigned int bits,unsigned int max)
714{
715 u8 status;
716
717 do {
718 udelay(10);
719 status = ata_check_status(ap);
720 max--;
721 } while (status != 0xff && (status & bits) && (max > 0));
722
723 return status;
724}
725
726static int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
727 unsigned int flags, u16 *id)
728{
729 struct ata_port *ap = pap;
730 unsigned int class = *p_class;
731 struct ata_taskfile tf;
732 unsigned int err_mask = 0;
733 const char *reason;
734 int may_fallback = 1, tried_spinup = 0;
735 u8 status;
736 int rc;
737
738 status = ata_busy_wait(ap, ATA_BUSY, 30000);
739 if (status & ATA_BUSY) {
740 printf("BSY = 0 check. timeout.\n");
741 rc = FALSE;
742 return rc;
743 }
744
745 ata_dev_select(ap, dev->devno, 1, 1);
746
747retry:
748 memset(&tf, 0, sizeof(tf));
749 ap->print_id = 1;
750 ap->flags &= ~ATA_FLAG_DISABLED;
751 tf.ctl = ap->ctl;
752 tf.device = ATA_DEVICE_OBS;
753 tf.command = ATA_CMD_ID_ATA;
754 tf.protocol = ATA_PROT_PIO;
755
756 /* Some devices choke if TF registers contain garbage. Make
757 * sure those are properly initialized.
758 */
759 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
760
761 /* Device presence detection is unreliable on some
762 * controllers. Always poll IDENTIFY if available.
763 */
764 tf.flags |= ATA_TFLAG_POLLING;
765
766 temp_n_block = 1;
767
768 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
769 sizeof(id[0]) * ATA_ID_WORDS, 0);
770
771 if (err_mask) {
772 if (err_mask & AC_ERR_NODEV_HINT) {
773 printf("NODEV after polling detection\n");
774 return -ENOENT;
775 }
776
777 if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
778 /* Device or controller might have reported
779 * the wrong device class. Give a shot at the
780 * other IDENTIFY if the current one is
781 * aborted by the device.
782 */
783 if (may_fallback) {
784 may_fallback = 0;
785
786 if (class == ATA_DEV_ATA) {
787 class = ATA_DEV_ATAPI;
788 } else {
789 class = ATA_DEV_ATA;
790 }
791 goto retry;
792 }
793 /* Control reaches here iff the device aborted
794 * both flavors of IDENTIFYs which happens
795 * sometimes with phantom devices.
796 */
797 printf("both IDENTIFYs aborted, assuming NODEV\n");
798 return -ENOENT;
799 }
800 rc = -EIO;
801 reason = "I/O error";
802 goto err_out;
803 }
804
805 /* Falling back doesn't make sense if ID data was read
806 * successfully at least once.
807 */
808 may_fallback = 0;
809
810 unsigned int id_cnt;
811
812 for (id_cnt = 0; id_cnt < ATA_ID_WORDS; id_cnt++)
813 id[id_cnt] = le16_to_cpu(id[id_cnt]);
814
815
816 rc = -EINVAL;
817 reason = "device reports invalid type";
818
819 if (class == ATA_DEV_ATA) {
820 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
821 goto err_out;
822 } else {
823 if (ata_id_is_ata(id))
824 goto err_out;
825 }
826 if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
827 tried_spinup = 1;
828 /*
829 * Drive powered-up in standby mode, and requires a specific
830 * SET_FEATURES spin-up subcommand before it will accept
831 * anything other than the original IDENTIFY command.
832 */
833 err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
834 if (err_mask && id[2] != 0x738c) {
835 rc = -EIO;
836 reason = "SPINUP failed";
837 goto err_out;
838 }
839 /*
840 * If the drive initially returned incomplete IDENTIFY info,
841 * we now must reissue the IDENTIFY command.
842 */
843 if (id[2] == 0x37c8)
844 goto retry;
845 }
846
847 if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) {
848 /*
849 * The exact sequence expected by certain pre-ATA4 drives is:
850 * SRST RESET
851 * IDENTIFY (optional in early ATA)
852 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
853 * anything else..
854 * Some drives were very specific about that exact sequence.
855 *
856 * Note that ATA4 says lba is mandatory so the second check
857 * shoud never trigger.
858 */
859 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
860 err_mask = ata_dev_init_params(dev, id[3], id[6]);
861 if (err_mask) {
862 rc = -EIO;
863 reason = "INIT_DEV_PARAMS failed";
864 goto err_out;
865 }
866
867 /* current CHS translation info (id[53-58]) might be
868 * changed. reread the identify device info.
869 */
870 flags &= ~ATA_READID_POSTRESET;
871 goto retry;
872 }
873 }
874
875 *p_class = class;
876 return 0;
877
878err_out:
Stefan Roese13a8c8d2011-11-15 08:02:49 +0000879 printf("failed to READ ID (%s, err_mask=0x%x)\n", reason, err_mask);
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +0900880 return rc;
881}
882
883static u8 ata_wait_idle(struct ata_port *ap)
884{
885 u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
886 return status;
887}
888
889static void ata_dev_select(struct ata_port *ap, unsigned int device,
890 unsigned int wait, unsigned int can_sleep)
891{
892 if (wait)
893 ata_wait_idle(ap);
894
895 ata_std_dev_select(ap, device);
896
897 if (wait)
898 ata_wait_idle(ap);
899}
900
901static void ata_std_dev_select(struct ata_port *ap, unsigned int device)
902{
903 u8 tmp;
904
905 if (device == 0) {
906 tmp = ATA_DEVICE_OBS;
907 } else {
908 tmp = ATA_DEVICE_OBS | ATA_DEV1;
909 }
910
911 writeb(tmp, ap->ioaddr.device_addr);
912
913 readb(ap->ioaddr.altstatus_addr);
914
915 udelay(1);
916}
917
918static int waiting_for_reg_state(volatile u8 *offset,
919 int timeout_msec,
920 u32 sign)
921{
922 int i;
923 u32 status;
924
925 for (i = 0; i < timeout_msec; i++) {
926 status = readl(offset);
927 if ((status & sign) != 0)
928 break;
929 msleep(1);
930 }
931
932 return (i < timeout_msec) ? 0 : -1;
933}
934
935static void ata_qc_reinit(struct ata_queued_cmd *qc)
936{
937 qc->dma_dir = DMA_NONE;
938 qc->flags = 0;
939 qc->nbytes = qc->extrabytes = qc->curbytes = 0;
940 qc->n_elem = 0;
941 qc->err_mask = 0;
942 qc->sect_size = ATA_SECT_SIZE;
943 qc->nbytes = ATA_SECT_SIZE * temp_n_block;
944
945 memset(&qc->tf, 0, sizeof(qc->tf));
946 qc->tf.ctl = 0;
947 qc->tf.device = ATA_DEVICE_OBS;
948
949 qc->result_tf.command = ATA_DRDY;
950 qc->result_tf.feature = 0;
951}
952
953struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
954 unsigned int tag)
955{
956 if (tag < ATA_MAX_QUEUE)
957 return &ap->qcmd[tag];
958 return NULL;
959}
960
961static void __ata_port_freeze(struct ata_port *ap)
962{
963 printf("set port freeze.\n");
964 ap->pflags |= ATA_PFLAG_FROZEN;
965}
966
967static int ata_port_freeze(struct ata_port *ap)
968{
969 __ata_port_freeze(ap);
970 return 0;
971}
972
973unsigned ata_exec_internal(struct ata_device *dev,
974 struct ata_taskfile *tf, const u8 *cdb,
975 int dma_dir, unsigned int buflen,
976 unsigned long timeout)
977{
978 struct ata_link *link = dev->link;
979 struct ata_port *ap = pap;
980 struct ata_queued_cmd *qc;
981 unsigned int tag, preempted_tag;
982 u32 preempted_sactive, preempted_qc_active;
983 int preempted_nr_active_links;
984 unsigned int err_mask;
985 int rc = 0;
986 u8 status;
987
988 status = ata_busy_wait(ap, ATA_BUSY, 300000);
989 if (status & ATA_BUSY) {
990 printf("BSY = 0 check. timeout.\n");
991 rc = FALSE;
992 return rc;
993 }
994
995 if (ap->pflags & ATA_PFLAG_FROZEN)
996 return AC_ERR_SYSTEM;
997
998 tag = ATA_TAG_INTERNAL;
999
1000 if (test_and_set_bit(tag, &ap->qc_allocated)) {
1001 rc = FALSE;
1002 return rc;
1003 }
1004
1005 qc = __ata_qc_from_tag(ap, tag);
1006 qc->tag = tag;
1007 qc->ap = ap;
1008 qc->dev = dev;
1009
1010 ata_qc_reinit(qc);
1011
1012 preempted_tag = link->active_tag;
1013 preempted_sactive = link->sactive;
1014 preempted_qc_active = ap->qc_active;
1015 preempted_nr_active_links = ap->nr_active_links;
1016 link->active_tag = ATA_TAG_POISON;
1017 link->sactive = 0;
1018 ap->qc_active = 0;
1019 ap->nr_active_links = 0;
1020
1021 qc->tf = *tf;
1022 if (cdb)
1023 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1024 qc->flags |= ATA_QCFLAG_RESULT_TF;
1025 qc->dma_dir = dma_dir;
1026 qc->private_data = 0;
1027
1028 ata_qc_issue(qc);
1029
1030 if (!timeout)
1031 timeout = ata_probe_timeout * 1000 / HZ;
1032
1033 status = ata_busy_wait(ap, ATA_BUSY, 30000);
1034 if (status & ATA_BUSY) {
1035 printf("BSY = 0 check. timeout.\n");
1036 printf("altstatus = 0x%x.\n", status);
1037 qc->err_mask |= AC_ERR_OTHER;
1038 return qc->err_mask;
1039 }
1040
1041 if (waiting_for_reg_state(ap->ioaddr.altstatus_addr, 1000, 0x8)) {
1042 u8 status = 0;
1043 u8 errorStatus = 0;
1044
1045 status = readb(ap->ioaddr.altstatus_addr);
1046 if ((status & 0x01) != 0) {
1047 errorStatus = readb(ap->ioaddr.feature_addr);
1048 if (errorStatus == 0x04 &&
1049 qc->tf.command == ATA_CMD_PIO_READ_EXT){
1050 printf("Hard Disk doesn't support LBA48\n");
1051 dev_state = SATA_ERROR;
1052 qc->err_mask |= AC_ERR_OTHER;
1053 return qc->err_mask;
1054 }
1055 }
1056 qc->err_mask |= AC_ERR_OTHER;
1057 return qc->err_mask;
1058 }
1059
1060 status = ata_busy_wait(ap, ATA_BUSY, 10);
1061 if (status & ATA_BUSY) {
1062 printf("BSY = 0 check. timeout.\n");
1063 qc->err_mask |= AC_ERR_OTHER;
1064 return qc->err_mask;
1065 }
1066
1067 ata_pio_task(ap);
1068
1069 if (!rc) {
1070 if (qc->flags & ATA_QCFLAG_ACTIVE) {
1071 qc->err_mask |= AC_ERR_TIMEOUT;
1072 ata_port_freeze(ap);
1073 }
1074 }
1075
1076 if (qc->flags & ATA_QCFLAG_FAILED) {
1077 if (qc->result_tf.command & (ATA_ERR | ATA_DF))
1078 qc->err_mask |= AC_ERR_DEV;
1079
1080 if (!qc->err_mask)
1081 qc->err_mask |= AC_ERR_OTHER;
1082
1083 if (qc->err_mask & ~AC_ERR_OTHER)
1084 qc->err_mask &= ~AC_ERR_OTHER;
1085 }
1086
1087 *tf = qc->result_tf;
1088 err_mask = qc->err_mask;
1089 ata_qc_free(qc);
1090 link->active_tag = preempted_tag;
1091 link->sactive = preempted_sactive;
1092 ap->qc_active = preempted_qc_active;
1093 ap->nr_active_links = preempted_nr_active_links;
1094
1095 if (ap->flags & ATA_FLAG_DISABLED) {
1096 err_mask |= AC_ERR_SYSTEM;
1097 ap->flags &= ~ATA_FLAG_DISABLED;
1098 }
1099
1100 return err_mask;
1101}
1102
1103static void ata_qc_issue(struct ata_queued_cmd *qc)
1104{
1105 struct ata_port *ap = qc->ap;
1106 struct ata_link *link = qc->dev->link;
1107 u8 prot = qc->tf.protocol;
1108
1109 if (ata_is_ncq(prot)) {
1110 if (!link->sactive)
1111 ap->nr_active_links++;
1112 link->sactive |= 1 << qc->tag;
1113 } else {
1114 ap->nr_active_links++;
1115 link->active_tag = qc->tag;
1116 }
1117
1118 qc->flags |= ATA_QCFLAG_ACTIVE;
1119 ap->qc_active |= 1 << qc->tag;
1120
1121 if (qc->dev->flags & ATA_DFLAG_SLEEPING) {
1122 msleep(1);
1123 return;
1124 }
1125
1126 qc->err_mask |= ata_qc_issue_prot(qc);
1127 if (qc->err_mask)
1128 goto err;
1129
1130 return;
1131err:
1132 ata_qc_complete(qc);
1133}
1134
1135static unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
1136{
1137 struct ata_port *ap = qc->ap;
1138
1139 if (ap->flags & ATA_FLAG_PIO_POLLING) {
1140 switch (qc->tf.protocol) {
1141 case ATA_PROT_PIO:
1142 case ATA_PROT_NODATA:
1143 case ATAPI_PROT_PIO:
1144 case ATAPI_PROT_NODATA:
1145 qc->tf.flags |= ATA_TFLAG_POLLING;
1146 break;
1147 default:
1148 break;
1149 }
1150 }
1151
1152 ata_dev_select(ap, qc->dev->devno, 1, 0);
1153
1154 switch (qc->tf.protocol) {
1155 case ATA_PROT_PIO:
1156 if (qc->tf.flags & ATA_TFLAG_POLLING)
1157 qc->tf.ctl |= ATA_NIEN;
1158
1159 ata_tf_to_host(ap, &qc->tf);
1160
1161 ap->hsm_task_state = HSM_ST;
1162
1163 if (qc->tf.flags & ATA_TFLAG_POLLING)
1164 ata_pio_queue_task(ap, qc, 0);
1165
1166 break;
1167
1168 default:
1169 return AC_ERR_SYSTEM;
1170 }
1171
1172 return 0;
1173}
1174
1175static void ata_tf_to_host(struct ata_port *ap,
1176 const struct ata_taskfile *tf)
1177{
1178 ata_tf_load(ap, tf);
1179 ata_exec_command(ap, tf);
1180}
1181
1182static void ata_tf_load(struct ata_port *ap,
1183 const struct ata_taskfile *tf)
1184{
1185 struct ata_ioports *ioaddr = &ap->ioaddr;
1186 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
1187
1188 if (tf->ctl != ap->last_ctl) {
1189 if (ioaddr->ctl_addr)
1190 writeb(tf->ctl, ioaddr->ctl_addr);
1191 ap->last_ctl = tf->ctl;
1192 ata_wait_idle(ap);
1193 }
1194
1195 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
1196 writeb(tf->hob_feature, ioaddr->feature_addr);
1197 writeb(tf->hob_nsect, ioaddr->nsect_addr);
1198 writeb(tf->hob_lbal, ioaddr->lbal_addr);
1199 writeb(tf->hob_lbam, ioaddr->lbam_addr);
1200 writeb(tf->hob_lbah, ioaddr->lbah_addr);
1201 }
1202
1203 if (is_addr) {
1204 writeb(tf->feature, ioaddr->feature_addr);
1205 writeb(tf->nsect, ioaddr->nsect_addr);
1206 writeb(tf->lbal, ioaddr->lbal_addr);
1207 writeb(tf->lbam, ioaddr->lbam_addr);
1208 writeb(tf->lbah, ioaddr->lbah_addr);
1209 }
1210
1211 if (tf->flags & ATA_TFLAG_DEVICE)
1212 writeb(tf->device, ioaddr->device_addr);
1213
1214 ata_wait_idle(ap);
1215}
1216
1217static void ata_exec_command(struct ata_port *ap,
1218 const struct ata_taskfile *tf)
1219{
1220 writeb(tf->command, ap->ioaddr.command_addr);
1221
1222 readb(ap->ioaddr.altstatus_addr);
1223
1224 udelay(1);
1225}
1226
1227static void ata_pio_queue_task(struct ata_port *ap,
1228 void *data,unsigned long delay)
1229{
1230 ap->port_task_data = data;
1231}
1232
1233static unsigned int ac_err_mask(u8 status)
1234{
1235 if (status & (ATA_BUSY | ATA_DRQ))
1236 return AC_ERR_HSM;
1237 if (status & (ATA_ERR | ATA_DF))
1238 return AC_ERR_DEV;
1239 return 0;
1240}
1241
1242static unsigned int __ac_err_mask(u8 status)
1243{
1244 unsigned int mask = ac_err_mask(status);
1245 if (mask == 0)
1246 return AC_ERR_OTHER;
1247 return mask;
1248}
1249
1250static void ata_pio_task(struct ata_port *arg_ap)
1251{
1252 struct ata_port *ap = arg_ap;
1253 struct ata_queued_cmd *qc = ap->port_task_data;
1254 u8 status;
1255 int poll_next;
1256
1257fsm_start:
1258 /*
1259 * This is purely heuristic. This is a fast path.
1260 * Sometimes when we enter, BSY will be cleared in
1261 * a chk-status or two. If not, the drive is probably seeking
1262 * or something. Snooze for a couple msecs, then
1263 * chk-status again. If still busy, queue delayed work.
1264 */
1265 status = ata_busy_wait(ap, ATA_BUSY, 5);
1266 if (status & ATA_BUSY) {
1267 msleep(2);
1268 status = ata_busy_wait(ap, ATA_BUSY, 10);
1269 if (status & ATA_BUSY) {
1270 ata_pio_queue_task(ap, qc, ATA_SHORT_PAUSE);
1271 return;
1272 }
1273 }
1274
1275 poll_next = ata_hsm_move(ap, qc, status, 1);
1276
1277 /* another command or interrupt handler
1278 * may be running at this point.
1279 */
1280 if (poll_next)
1281 goto fsm_start;
1282}
1283
1284static int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
1285 u8 status, int in_wq)
1286{
1287 int poll_next;
1288
1289fsm_start:
1290 switch (ap->hsm_task_state) {
1291 case HSM_ST_FIRST:
1292 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
1293
1294 if ((status & ATA_DRQ) == 0) {
1295 if (status & (ATA_ERR | ATA_DF)) {
1296 qc->err_mask |= AC_ERR_DEV;
1297 } else {
1298 qc->err_mask |= AC_ERR_HSM;
1299 }
1300 ap->hsm_task_state = HSM_ST_ERR;
1301 goto fsm_start;
1302 }
1303
1304 /* Device should not ask for data transfer (DRQ=1)
1305 * when it finds something wrong.
1306 * We ignore DRQ here and stop the HSM by
1307 * changing hsm_task_state to HSM_ST_ERR and
1308 * let the EH abort the command or reset the device.
1309 */
1310 if (status & (ATA_ERR | ATA_DF)) {
1311 if (!(qc->dev->horkage & ATA_HORKAGE_STUCK_ERR)) {
1312 printf("DRQ=1 with device error, "
1313 "dev_stat 0x%X\n", status);
1314 qc->err_mask |= AC_ERR_HSM;
1315 ap->hsm_task_state = HSM_ST_ERR;
1316 goto fsm_start;
1317 }
1318 }
1319
1320 if (qc->tf.protocol == ATA_PROT_PIO) {
1321 /* PIO data out protocol.
1322 * send first data block.
1323 */
1324 /* ata_pio_sectors() might change the state
1325 * to HSM_ST_LAST. so, the state is changed here
1326 * before ata_pio_sectors().
1327 */
1328 ap->hsm_task_state = HSM_ST;
1329 ata_pio_sectors(qc);
1330 } else {
1331 printf("protocol is not ATA_PROT_PIO \n");
1332 }
1333 break;
1334
1335 case HSM_ST:
1336 if ((status & ATA_DRQ) == 0) {
1337 if (status & (ATA_ERR | ATA_DF)) {
1338 qc->err_mask |= AC_ERR_DEV;
1339 } else {
1340 /* HSM violation. Let EH handle this.
1341 * Phantom devices also trigger this
1342 * condition. Mark hint.
1343 */
1344 qc->err_mask |= AC_ERR_HSM | AC_ERR_NODEV_HINT;
1345 }
1346
1347 ap->hsm_task_state = HSM_ST_ERR;
1348 goto fsm_start;
1349 }
1350 /* For PIO reads, some devices may ask for
1351 * data transfer (DRQ=1) alone with ERR=1.
1352 * We respect DRQ here and transfer one
1353 * block of junk data before changing the
1354 * hsm_task_state to HSM_ST_ERR.
1355 *
1356 * For PIO writes, ERR=1 DRQ=1 doesn't make
1357 * sense since the data block has been
1358 * transferred to the device.
1359 */
1360 if (status & (ATA_ERR | ATA_DF)) {
1361 qc->err_mask |= AC_ERR_DEV;
1362
1363 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
1364 ata_pio_sectors(qc);
1365 status = ata_wait_idle(ap);
1366 }
1367
1368 if (status & (ATA_BUSY | ATA_DRQ))
1369 qc->err_mask |= AC_ERR_HSM;
1370
1371 /* ata_pio_sectors() might change the
1372 * state to HSM_ST_LAST. so, the state
1373 * is changed after ata_pio_sectors().
1374 */
1375 ap->hsm_task_state = HSM_ST_ERR;
1376 goto fsm_start;
1377 }
1378
1379 ata_pio_sectors(qc);
1380 if (ap->hsm_task_state == HSM_ST_LAST &&
1381 (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
1382 status = ata_wait_idle(ap);
1383 goto fsm_start;
1384 }
1385
1386 poll_next = 1;
1387 break;
1388
1389 case HSM_ST_LAST:
1390 if (!ata_ok(status)) {
1391 qc->err_mask |= __ac_err_mask(status);
1392 ap->hsm_task_state = HSM_ST_ERR;
1393 goto fsm_start;
1394 }
1395
1396 ap->hsm_task_state = HSM_ST_IDLE;
1397
1398 ata_hsm_qc_complete(qc, in_wq);
1399
1400 poll_next = 0;
1401 break;
1402
1403 case HSM_ST_ERR:
1404 /* make sure qc->err_mask is available to
1405 * know what's wrong and recover
1406 */
1407 ap->hsm_task_state = HSM_ST_IDLE;
1408
1409 ata_hsm_qc_complete(qc, in_wq);
1410
1411 poll_next = 0;
1412 break;
1413 default:
1414 poll_next = 0;
1415 }
1416
1417 return poll_next;
1418}
1419
1420static void ata_pio_sectors(struct ata_queued_cmd *qc)
1421{
1422 struct ata_port *ap;
1423 ap = pap;
1424 qc->pdata = ap->pdata;
1425
1426 ata_pio_sector(qc);
1427
1428 readb(qc->ap->ioaddr.altstatus_addr);
1429 udelay(1);
1430}
1431
1432static void ata_pio_sector(struct ata_queued_cmd *qc)
1433{
1434 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
1435 struct ata_port *ap = qc->ap;
1436 unsigned int offset;
1437 unsigned char *buf;
1438 char temp_data_buf[512];
1439
1440 if (qc->curbytes == qc->nbytes - qc->sect_size)
1441 ap->hsm_task_state = HSM_ST_LAST;
1442
1443 offset = qc->curbytes;
1444
1445 switch (qc->tf.command) {
1446 case ATA_CMD_ID_ATA:
1447 buf = (unsigned char *)&ata_device.id[0];
1448 break;
1449 case ATA_CMD_PIO_READ_EXT:
1450 case ATA_CMD_PIO_READ:
1451 case ATA_CMD_PIO_WRITE_EXT:
1452 case ATA_CMD_PIO_WRITE:
1453 buf = qc->pdata + offset;
1454 break;
1455 default:
1456 buf = (unsigned char *)&temp_data_buf[0];
1457 }
1458
1459 ata_mmio_data_xfer(qc->dev, buf, qc->sect_size, do_write);
1460
1461 qc->curbytes += qc->sect_size;
1462
1463}
1464
1465static void ata_mmio_data_xfer(struct ata_device *dev, unsigned char *buf,
1466 unsigned int buflen, int do_write)
1467{
1468 struct ata_port *ap = pap;
1469 void __iomem *data_addr = ap->ioaddr.data_addr;
1470 unsigned int words = buflen >> 1;
1471 u16 *buf16 = (u16 *)buf;
1472 unsigned int i = 0;
1473
1474 udelay(100);
1475 if (do_write) {
1476 for (i = 0; i < words; i++)
1477 writew(le16_to_cpu(buf16[i]), data_addr);
1478 } else {
1479 for (i = 0; i < words; i++)
1480 buf16[i] = cpu_to_le16(readw(data_addr));
1481 }
1482
1483 if (buflen & 0x01) {
1484 __le16 align_buf[1] = { 0 };
1485 unsigned char *trailing_buf = buf + buflen - 1;
1486
1487 if (do_write) {
1488 memcpy(align_buf, trailing_buf, 1);
1489 writew(le16_to_cpu(align_buf[0]), data_addr);
1490 } else {
1491 align_buf[0] = cpu_to_le16(readw(data_addr));
1492 memcpy(trailing_buf, align_buf, 1);
1493 }
1494 }
1495}
1496
1497static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
1498{
1499 struct ata_port *ap = qc->ap;
1500
1501 if (in_wq) {
1502 /* EH might have kicked in while host lock is
1503 * released.
1504 */
1505 qc = &ap->qcmd[qc->tag];
1506 if (qc) {
1507 if (!(qc->err_mask & AC_ERR_HSM)) {
1508 ata_irq_on(ap);
1509 ata_qc_complete(qc);
1510 } else {
1511 ata_port_freeze(ap);
1512 }
1513 }
1514 } else {
1515 if (!(qc->err_mask & AC_ERR_HSM)) {
1516 ata_qc_complete(qc);
1517 } else {
1518 ata_port_freeze(ap);
1519 }
1520 }
1521}
1522
1523static u8 ata_irq_on(struct ata_port *ap)
1524{
1525 struct ata_ioports *ioaddr = &ap->ioaddr;
1526 u8 tmp;
1527
1528 ap->ctl &= ~ATA_NIEN;
1529 ap->last_ctl = ap->ctl;
1530
1531 if (ioaddr->ctl_addr)
1532 writeb(ap->ctl, ioaddr->ctl_addr);
1533
1534 tmp = ata_wait_idle(ap);
1535
1536 return tmp;
1537}
1538
1539static unsigned int ata_tag_internal(unsigned int tag)
1540{
1541 return tag == ATA_MAX_QUEUE - 1;
1542}
1543
1544static void ata_qc_complete(struct ata_queued_cmd *qc)
1545{
1546 struct ata_device *dev = qc->dev;
1547 if (qc->err_mask)
1548 qc->flags |= ATA_QCFLAG_FAILED;
1549
1550 if (qc->flags & ATA_QCFLAG_FAILED) {
1551 if (!ata_tag_internal(qc->tag)) {
1552 fill_result_tf(qc);
1553 return;
1554 }
1555 }
1556 if (qc->flags & ATA_QCFLAG_RESULT_TF)
1557 fill_result_tf(qc);
1558
1559 /* Some commands need post-processing after successful
1560 * completion.
1561 */
1562 switch (qc->tf.command) {
1563 case ATA_CMD_SET_FEATURES:
1564 if (qc->tf.feature != SETFEATURES_WC_ON &&
1565 qc->tf.feature != SETFEATURES_WC_OFF)
1566 break;
1567 case ATA_CMD_INIT_DEV_PARAMS:
1568 case ATA_CMD_SET_MULTI:
1569 break;
1570
1571 case ATA_CMD_SLEEP:
1572 dev->flags |= ATA_DFLAG_SLEEPING;
1573 break;
1574 }
1575
1576 __ata_qc_complete(qc);
1577}
1578
1579static void fill_result_tf(struct ata_queued_cmd *qc)
1580{
1581 struct ata_port *ap = qc->ap;
1582
1583 qc->result_tf.flags = qc->tf.flags;
1584 ata_tf_read(ap, &qc->result_tf);
1585}
1586
1587static void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
1588{
1589 struct ata_ioports *ioaddr = &ap->ioaddr;
1590
1591 tf->command = ata_check_status(ap);
1592 tf->feature = readb(ioaddr->error_addr);
1593 tf->nsect = readb(ioaddr->nsect_addr);
1594 tf->lbal = readb(ioaddr->lbal_addr);
1595 tf->lbam = readb(ioaddr->lbam_addr);
1596 tf->lbah = readb(ioaddr->lbah_addr);
1597 tf->device = readb(ioaddr->device_addr);
1598
1599 if (tf->flags & ATA_TFLAG_LBA48) {
1600 if (ioaddr->ctl_addr) {
1601 writeb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
1602
1603 tf->hob_feature = readb(ioaddr->error_addr);
1604 tf->hob_nsect = readb(ioaddr->nsect_addr);
1605 tf->hob_lbal = readb(ioaddr->lbal_addr);
1606 tf->hob_lbam = readb(ioaddr->lbam_addr);
1607 tf->hob_lbah = readb(ioaddr->lbah_addr);
1608
1609 writeb(tf->ctl, ioaddr->ctl_addr);
1610 ap->last_ctl = tf->ctl;
1611 } else {
1612 printf("sata_dwc warnning register read.\n");
1613 }
1614 }
1615}
1616
1617static void __ata_qc_complete(struct ata_queued_cmd *qc)
1618{
1619 struct ata_port *ap = qc->ap;
1620 struct ata_link *link = qc->dev->link;
1621
1622 link->active_tag = ATA_TAG_POISON;
1623 ap->nr_active_links--;
1624
1625 if (qc->flags & ATA_QCFLAG_CLEAR_EXCL && ap->excl_link == link)
1626 ap->excl_link = NULL;
1627
1628 qc->flags &= ~ATA_QCFLAG_ACTIVE;
1629 ap->qc_active &= ~(1 << qc->tag);
1630}
1631
1632static void ata_qc_free(struct ata_queued_cmd *qc)
1633{
1634 struct ata_port *ap = qc->ap;
1635 unsigned int tag;
1636 qc->flags = 0;
1637 tag = qc->tag;
1638 if (tag < ATA_MAX_QUEUE) {
1639 qc->tag = ATA_TAG_POISON;
1640 clear_bit(tag, &ap->qc_allocated);
1641 }
1642}
1643
1644static int check_sata_dev_state(void)
1645{
1646 unsigned long datalen;
1647 unsigned char *pdata;
1648 int ret = 0;
1649 int i = 0;
1650 char temp_data_buf[512];
1651
1652 while (1) {
1653 udelay(10000);
1654
1655 pdata = (unsigned char*)&temp_data_buf[0];
1656 datalen = 512;
1657
1658 ret = ata_dev_read_sectors(pdata, datalen, 0, 1);
1659
1660 if (ret == TRUE)
1661 break;
1662
1663 i++;
1664 if (i > (ATA_RESET_TIME * 100)) {
1665 printf("** TimeOUT **\n");
1666 dev_state = SATA_NODEVICE;
1667 return FALSE;
1668 }
1669
1670 if ((i >= 100) && ((i % 100) == 0))
1671 printf(".");
1672 }
1673
1674 dev_state = SATA_READY;
1675
1676 return TRUE;
1677}
1678
1679static unsigned int ata_dev_set_feature(struct ata_device *dev,
1680 u8 enable, u8 feature)
1681{
1682 struct ata_taskfile tf;
1683 struct ata_port *ap;
1684 ap = pap;
1685 unsigned int err_mask;
1686
1687 memset(&tf, 0, sizeof(tf));
1688 tf.ctl = ap->ctl;
1689
1690 tf.device = ATA_DEVICE_OBS;
1691 tf.command = ATA_CMD_SET_FEATURES;
1692 tf.feature = enable;
1693 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1694 tf.protocol = ATA_PROT_NODATA;
1695 tf.nsect = feature;
1696
1697 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, 0, 0);
1698
1699 return err_mask;
1700}
1701
1702static unsigned int ata_dev_init_params(struct ata_device *dev,
1703 u16 heads, u16 sectors)
1704{
1705 struct ata_taskfile tf;
1706 struct ata_port *ap;
1707 ap = pap;
1708 unsigned int err_mask;
1709
1710 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
1711 return AC_ERR_INVALID;
1712
1713 memset(&tf, 0, sizeof(tf));
1714 tf.ctl = ap->ctl;
1715 tf.device = ATA_DEVICE_OBS;
1716 tf.command = ATA_CMD_INIT_DEV_PARAMS;
1717 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1718 tf.protocol = ATA_PROT_NODATA;
1719 tf.nsect = sectors;
1720 tf.device |= (heads - 1) & 0x0f;
1721
1722 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, 0, 0);
1723
1724 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
1725 err_mask = 0;
1726
1727 return err_mask;
1728}
1729
1730#if defined(CONFIG_SATA_DWC) && !defined(CONFIG_LBA48)
1731#define SATA_MAX_READ_BLK 0xFF
1732#else
1733#define SATA_MAX_READ_BLK 0xFFFF
1734#endif
1735
1736ulong sata_read(int device, ulong blknr, lbaint_t blkcnt, void *buffer)
1737{
1738 ulong start,blks, buf_addr;
1739 unsigned short smallblks;
1740 unsigned long datalen;
1741 unsigned char *pdata;
1742 device &= 0xff;
1743
1744 u32 block = 0;
1745 u32 n_block = 0;
1746
1747 if (dev_state != SATA_READY)
1748 return 0;
1749
1750 buf_addr = (unsigned long)buffer;
1751 start = blknr;
1752 blks = blkcnt;
1753 do {
1754 pdata = (unsigned char *)buf_addr;
1755 if (blks > SATA_MAX_READ_BLK) {
1756 datalen = sata_dev_desc[device].blksz * SATA_MAX_READ_BLK;
1757 smallblks = SATA_MAX_READ_BLK;
1758
1759 block = (u32)start;
1760 n_block = (u32)smallblks;
1761
1762 start += SATA_MAX_READ_BLK;
1763 blks -= SATA_MAX_READ_BLK;
1764 } else {
1765 datalen = sata_dev_desc[device].blksz * SATA_MAX_READ_BLK;
1766 datalen = sata_dev_desc[device].blksz * blks;
1767 smallblks = (unsigned short)blks;
1768
1769 block = (u32)start;
1770 n_block = (u32)smallblks;
1771
1772 start += blks;
1773 blks = 0;
1774 }
1775
1776 if (ata_dev_read_sectors(pdata, datalen, block, n_block) != TRUE) {
1777 printf("sata_dwc : Hard disk read error.\n");
1778 blkcnt -= blks;
1779 break;
1780 }
1781 buf_addr += datalen;
1782 } while (blks != 0);
1783
1784 return (blkcnt);
1785}
1786
1787static int ata_dev_read_sectors(unsigned char *pdata, unsigned long datalen,
1788 u32 block, u32 n_block)
1789{
1790 struct ata_port *ap = pap;
1791 struct ata_device *dev = &ata_device;
1792 struct ata_taskfile tf;
1793 unsigned int class = ATA_DEV_ATA;
1794 unsigned int err_mask = 0;
1795 const char *reason;
1796 int may_fallback = 1;
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09001797
1798 if (dev_state == SATA_ERROR)
1799 return FALSE;
1800
1801 ata_dev_select(ap, dev->devno, 1, 1);
1802
1803retry:
1804 memset(&tf, 0, sizeof(tf));
1805 tf.ctl = ap->ctl;
1806 ap->print_id = 1;
1807 ap->flags &= ~ATA_FLAG_DISABLED;
1808
1809 ap->pdata = pdata;
1810
1811 tf.device = ATA_DEVICE_OBS;
1812
1813 temp_n_block = n_block;
1814
1815#ifdef CONFIG_LBA48
1816 tf.command = ATA_CMD_PIO_READ_EXT;
1817 tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1818
1819 tf.hob_feature = 31;
1820 tf.feature = 31;
1821 tf.hob_nsect = (n_block >> 8) & 0xff;
1822 tf.nsect = n_block & 0xff;
1823
1824 tf.hob_lbah = 0x0;
1825 tf.hob_lbam = 0x0;
1826 tf.hob_lbal = (block >> 24) & 0xff;
1827 tf.lbah = (block >> 16) & 0xff;
1828 tf.lbam = (block >> 8) & 0xff;
1829 tf.lbal = block & 0xff;
1830
1831 tf.device = 1 << 6;
1832 if (tf.flags & ATA_TFLAG_FUA)
1833 tf.device |= 1 << 7;
1834#else
1835 tf.command = ATA_CMD_PIO_READ;
1836 tf.flags |= ATA_TFLAG_LBA ;
1837
1838 tf.feature = 31;
1839 tf.nsect = n_block & 0xff;
1840
1841 tf.lbah = (block >> 16) & 0xff;
1842 tf.lbam = (block >> 8) & 0xff;
1843 tf.lbal = block & 0xff;
1844
1845 tf.device = (block >> 24) & 0xf;
1846
1847 tf.device |= 1 << 6;
1848 if (tf.flags & ATA_TFLAG_FUA)
1849 tf.device |= 1 << 7;
1850
1851#endif
1852
1853 tf.protocol = ATA_PROT_PIO;
1854
1855 /* Some devices choke if TF registers contain garbage. Make
1856 * sure those are properly initialized.
1857 */
1858 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1859 tf.flags |= ATA_TFLAG_POLLING;
1860
1861 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 0, 0);
1862
1863 if (err_mask) {
1864 if (err_mask & AC_ERR_NODEV_HINT) {
1865 printf("READ_SECTORS NODEV after polling detection\n");
1866 return -ENOENT;
1867 }
1868
1869 if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
1870 /* Device or controller might have reported
1871 * the wrong device class. Give a shot at the
1872 * other IDENTIFY if the current one is
1873 * aborted by the device.
1874 */
1875 if (may_fallback) {
1876 may_fallback = 0;
1877
1878 if (class == ATA_DEV_ATA) {
1879 class = ATA_DEV_ATAPI;
1880 } else {
1881 class = ATA_DEV_ATA;
1882 }
1883 goto retry;
1884 }
1885 /* Control reaches here iff the device aborted
1886 * both flavors of IDENTIFYs which happens
1887 * sometimes with phantom devices.
1888 */
1889 printf("both IDENTIFYs aborted, assuming NODEV\n");
1890 return -ENOENT;
1891 }
1892
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09001893 reason = "I/O error";
1894 goto err_out;
1895 }
1896
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09001897 return TRUE;
1898
1899err_out:
1900 printf("failed to READ SECTORS (%s, err_mask=0x%x)\n", reason, err_mask);
1901 return FALSE;
1902}
1903
1904#if defined(CONFIG_SATA_DWC) && !defined(CONFIG_LBA48)
1905#define SATA_MAX_WRITE_BLK 0xFF
1906#else
1907#define SATA_MAX_WRITE_BLK 0xFFFF
1908#endif
1909
1910ulong sata_write(int device, ulong blknr, lbaint_t blkcnt, void *buffer)
1911{
1912 ulong start,blks, buf_addr;
1913 unsigned short smallblks;
1914 unsigned long datalen;
1915 unsigned char *pdata;
1916 device &= 0xff;
1917
1918
1919 u32 block = 0;
1920 u32 n_block = 0;
1921
1922 if (dev_state != SATA_READY)
1923 return 0;
1924
1925 buf_addr = (unsigned long)buffer;
1926 start = blknr;
1927 blks = blkcnt;
1928 do {
1929 pdata = (unsigned char *)buf_addr;
1930 if (blks > SATA_MAX_WRITE_BLK) {
1931 datalen = sata_dev_desc[device].blksz * SATA_MAX_WRITE_BLK;
1932 smallblks = SATA_MAX_WRITE_BLK;
1933
1934 block = (u32)start;
1935 n_block = (u32)smallblks;
1936
1937 start += SATA_MAX_WRITE_BLK;
1938 blks -= SATA_MAX_WRITE_BLK;
1939 } else {
1940 datalen = sata_dev_desc[device].blksz * blks;
1941 smallblks = (unsigned short)blks;
1942
1943 block = (u32)start;
1944 n_block = (u32)smallblks;
1945
1946 start += blks;
1947 blks = 0;
1948 }
1949
1950 if (ata_dev_write_sectors(pdata, datalen, block, n_block) != TRUE) {
1951 printf("sata_dwc : Hard disk read error.\n");
1952 blkcnt -= blks;
1953 break;
1954 }
1955 buf_addr += datalen;
1956 } while (blks != 0);
1957
1958 return (blkcnt);
1959}
1960
1961static int ata_dev_write_sectors(unsigned char* pdata, unsigned long datalen,
1962 u32 block, u32 n_block)
1963{
1964 struct ata_port *ap = pap;
1965 struct ata_device *dev = &ata_device;
1966 struct ata_taskfile tf;
1967 unsigned int class = ATA_DEV_ATA;
1968 unsigned int err_mask = 0;
1969 const char *reason;
1970 int may_fallback = 1;
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09001971
1972 if (dev_state == SATA_ERROR)
1973 return FALSE;
1974
1975 ata_dev_select(ap, dev->devno, 1, 1);
1976
1977retry:
1978 memset(&tf, 0, sizeof(tf));
1979 tf.ctl = ap->ctl;
1980 ap->print_id = 1;
1981 ap->flags &= ~ATA_FLAG_DISABLED;
1982
1983 ap->pdata = pdata;
1984
1985 tf.device = ATA_DEVICE_OBS;
1986
1987 temp_n_block = n_block;
1988
1989
1990#ifdef CONFIG_LBA48
1991 tf.command = ATA_CMD_PIO_WRITE_EXT;
1992 tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48 | ATA_TFLAG_WRITE;
1993
1994 tf.hob_feature = 31;
1995 tf.feature = 31;
1996 tf.hob_nsect = (n_block >> 8) & 0xff;
1997 tf.nsect = n_block & 0xff;
1998
1999 tf.hob_lbah = 0x0;
2000 tf.hob_lbam = 0x0;
2001 tf.hob_lbal = (block >> 24) & 0xff;
2002 tf.lbah = (block >> 16) & 0xff;
2003 tf.lbam = (block >> 8) & 0xff;
2004 tf.lbal = block & 0xff;
2005
2006 tf.device = 1 << 6;
2007 if (tf.flags & ATA_TFLAG_FUA)
2008 tf.device |= 1 << 7;
2009#else
2010 tf.command = ATA_CMD_PIO_WRITE;
2011 tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_WRITE;
2012
2013 tf.feature = 31;
2014 tf.nsect = n_block & 0xff;
2015
2016 tf.lbah = (block >> 16) & 0xff;
2017 tf.lbam = (block >> 8) & 0xff;
2018 tf.lbal = block & 0xff;
2019
2020 tf.device = (block >> 24) & 0xf;
2021
2022 tf.device |= 1 << 6;
2023 if (tf.flags & ATA_TFLAG_FUA)
2024 tf.device |= 1 << 7;
2025
2026#endif
2027
2028 tf.protocol = ATA_PROT_PIO;
2029
2030 /* Some devices choke if TF registers contain garbage. Make
2031 * sure those are properly initialized.
2032 */
2033 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2034 tf.flags |= ATA_TFLAG_POLLING;
2035
2036 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE, 0, 0);
2037
2038 if (err_mask) {
2039 if (err_mask & AC_ERR_NODEV_HINT) {
2040 printf("READ_SECTORS NODEV after polling detection\n");
2041 return -ENOENT;
2042 }
2043
2044 if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
2045 /* Device or controller might have reported
2046 * the wrong device class. Give a shot at the
2047 * other IDENTIFY if the current one is
2048 * aborted by the device.
2049 */
2050 if (may_fallback) {
2051 may_fallback = 0;
2052
2053 if (class == ATA_DEV_ATA) {
2054 class = ATA_DEV_ATAPI;
2055 } else {
2056 class = ATA_DEV_ATA;
2057 }
2058 goto retry;
2059 }
2060 /* Control reaches here iff the device aborted
2061 * both flavors of IDENTIFYs which happens
2062 * sometimes with phantom devices.
2063 */
2064 printf("both IDENTIFYs aborted, assuming NODEV\n");
2065 return -ENOENT;
2066 }
2067
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09002068 reason = "I/O error";
2069 goto err_out;
2070 }
2071
Kazuaki Ichinohee405afa2009-06-12 18:10:12 +09002072 return TRUE;
2073
2074err_out:
2075 printf("failed to WRITE SECTORS (%s, err_mask=0x%x)\n", reason, err_mask);
2076 return FALSE;
2077}