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