source: trunk/hal/x86_64/drivers/ioc_ata.c @ 268

Last change on this file since 268 was 268, checked in by max@…, 4 years ago

Mmh, the wait must be done for each block, not for each operation.

File size: 5.6 KB
Line 
1/*
2 * ioc_ata.c - ATA driver implementation
3 *
4 * Copyright (c) 2017 Maxime Villard
5 *
6 * This file is part of ALMOS-MKH.
7 *
8 * ALMOS-MKH is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2.0 of the License.
11 *
12 * ALMOS-MKH is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include <chdev.h>
23#include <dev_ioc.h>
24#include <hal_drivers.h>
25#include <hal_kentry.h>
26#include <thread.h>
27#include <spinlock.h>
28
29#include <hal_internal.h>
30
31#define PIO_ATA_CBR_BASE        0x1F0
32#       define ATA_DATA         0x000
33#       define ATA_ERRFEAT      0x001 /* two regs */
34#       define ATA_SCR          0x002
35#       define ATA_SNR          0x003 /* lba0 */
36#       define ATA_CLR          0x004 /* lba1 */
37#       define ATA_CHR          0x005 /* lba2 */
38#       define ATA_DHR          0x006 /* drive | lba3 */
39#       define ATA_SR           0x007
40#               define ATA_SR_ERR       0x01
41#               define ATA_SR_IDX       0x02
42#               define ATA_SR_CORR      0x04
43#               define ATA_SR_DRQ       0x08
44#               define ATA_SR_DSC       0x10
45#               define ATA_SR_DF        0x20
46#               define ATA_SR_DRDY      0x40
47#               define ATA_SR_BSY       0x80
48#       define ATA_CR           0x007 /* two regs */
49
50#define ATA_CMD_READ_SECTORS_RETRY      0x20
51#define ATA_CMD_READ_SECTORS_NORETRY    0x21
52#define ATA_CMD_WRITE_SECTORS_RETRY     0x30
53#define ATA_CMD_WRITE_SECTORS_NORETRY   0x31
54#define ATA_CMD_IDENTIFY                0xEC
55
56static inline uint16_t ata_data_read()
57{
58        return in16(PIO_ATA_CBR_BASE + ATA_DATA);
59}
60
61static inline void ata_data_write(uint16_t val)
62{
63        out16(PIO_ATA_CBR_BASE + ATA_DATA, val);
64}
65
66static inline uint8_t ata_cbr_read(uint32_t reg)
67{
68        return in8(PIO_ATA_CBR_BASE + reg);
69}
70
71static inline void ata_cbr_write(uint32_t reg, uint8_t val)
72{
73        out8(PIO_ATA_CBR_BASE + reg, val);
74}
75
76static inline int ata_wait()
77{
78        uint8_t status;
79
80        while (1) {
81                status = ata_cbr_read(ATA_SR);
82                if (status & ATA_SR_DRQ)
83                        break;
84        }
85
86        return ((status & ATA_SR_ERR) ? -1 : 0);
87}
88
89static void ata_prepare(uint8_t slave, uint32_t lba, uint8_t count)
90{
91        ata_cbr_write(ATA_ERRFEAT, 0x00); /* NULL byte to port 0x1F1 */
92        ata_cbr_write(ATA_SCR, count); /* sector count */
93
94        /* set the lba */
95        ata_cbr_write(ATA_SNR, (lba >> 0) & 0xFF);
96        ata_cbr_write(ATA_CLR, (lba >> 8) & 0xFF);
97        ata_cbr_write(ATA_CHR, (lba >> 16)& 0xFF);
98
99        /* set the drive and lba3 */
100        ata_cbr_write(ATA_DHR, 0xE0 | (slave << 4) | ((lba >> 24) & 0x0F));
101}
102
103static int ata_read(uint8_t count, char *buf)
104{
105        uint16_t tmpword;
106        int idx;
107
108        for (idx = 0; idx < 256 * count; idx++) {
109                /* wait for the drive to signal that it's ready */
110                if (ata_wait() == -1)
111                        x86_panic("ata_wait");
112
113                /* read */
114                tmpword = ata_data_read();
115                buf[idx * 2] = (uint8_t)(tmpword & 0xFF);
116                buf[idx * 2 + 1] = (uint8_t)(tmpword >> 8);
117        }
118
119        return 0;
120}
121
122static int ata_write(uint8_t count, char *buf)
123{
124        uint16_t tmpword;
125        int idx;
126
127        /* wait for the drive to signal that it's ready */
128        if (ata_wait() == -1)
129                x86_panic("ata_wait");
130
131        for (idx = 0; idx < 256 * count; idx++) {
132                tmpword = (buf[idx * 2 + 1] << 8) | buf[idx * 2];
133                ata_data_write(tmpword);
134        }
135
136        return 0;
137}
138
139static uint16_t bswap16(uint16_t x)
140{
141        return ((x << 8) & 0xFF00) | ((x >> 8) & 0x00FF);
142}
143
144static void ata_init()
145{
146        uint8_t id[512];
147        uint16_t tmpw, *p;
148        size_t idx;
149        char *model;
150        uint8_t ncyl;
151        int ret;
152
153        ata_prepare(0, 0, 0);
154        ata_cbr_write(ATA_CR, ATA_CMD_IDENTIFY);
155
156        /* wait for the drive to signal that it's ready */
157        ret = ata_wait();
158        if (ret == -1)
159                x86_panic("-> unable to identify ATA\n");
160
161        for (idx = 0; idx < 256; idx++) {
162                tmpw = ata_data_read();
163                id[idx * 2]     = (uint8_t)((tmpw >> 0) & 0xFF);
164                id[idx * 2 + 1] = (uint8_t)((tmpw >> 8) & 0xFF);
165        }
166
167        ncyl = id[0] & 0x1;
168        x86_printf("-> cyl: %z\n", (uint64_t)ncyl);
169
170        for (idx = 27*2; idx < 46*2; idx += 2) {
171                p = (uint16_t *)(&id[idx]);
172                *p = bswap16(*p);
173        }
174
175        model = &id[27*2];
176        id[46*2] = '\0';
177        x86_printf("-> ATA model: '%s'\n", model);
178}
179
180/* -------------------------------------------------------------------------- */
181
182static void ioc_ata_cmd(xptr_t th_xp);
183extern void x86_ioapic_ata0();
184
185void ioc_ata_init(chdev_t *chdev)
186{
187        chdev->cmd = &ioc_ata_cmd;
188        chdev->isr = &x86_ioapic_ata0;
189        ata_init();
190}
191
192static void ioc_ata_cmd(xptr_t th_xp)
193{
194        uint32_t   cmd_type;     // IOC_READ / IOC_WRITE / IOC_SYNC_READ
195        uint32_t   lba;          // command argument
196        uint32_t   count;        // command argument
197        xptr_t     buf_xp;       // command argument
198
199        // get client thread cluster and local pointer
200        cxy_t      th_cxy = GET_CXY( th_xp );
201        thread_t * th_ptr = (thread_t *)GET_PTR( th_xp );
202
203        // get command arguments and extended pointer on IOC device
204        cmd_type =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.type   ) );
205        lba      =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.lba    ) );
206        count    =         hal_remote_lw ( XPTR( th_cxy , &th_ptr->command.ioc.count  ) );
207        buf_xp   = (xptr_t)hal_remote_lwd( XPTR( th_cxy , &th_ptr->command.ioc.buf_xp ) );
208
209        /* execute operation */
210        ata_prepare(0, lba, count);
211        if (cmd_type == IOC_WRITE) {
212                ata_cbr_write(ATA_CR, ATA_CMD_WRITE_SECTORS_RETRY);
213        } else {
214                ata_cbr_write(ATA_CR, ATA_CMD_READ_SECTORS_RETRY);
215        }
216
217        /* waiting policy depends on the command type */
218        if (cmd_type == IOC_SYNC_READ) {
219                ata_read(count, (char *)buf_xp);
220        } else {
221                x86_panic("!IOC_SYNC_READ not supported");
222        }
223}
224
225void ioc_ata_isr(hal_cpu_context_t *ctx)
226{
227        x86_printf("rip = %Z\n", ctx->tf_rip);
228
229        x86_panic((char *)__func__);
230}
231
Note: See TracBrowser for help on using the repository browser.