Subversion Repositories HelenOS

Rev

Rev 4557 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4507 svoboda 1
/*
2
 * Copyright (c) 2009 Jiri Svoboda
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup bd
30
 * @{
31
 */
32
 
33
/**
34
 * @file
35
 * @brief ATA disk driver
36
 *
37
 * This driver currently works only with CHS addressing and uses PIO.
38
 * Currently based on the (now obsolete) ANSI X3.221-1994 (ATA-1) standard.
39
 * At this point only reading is possible, not writing.
4557 svoboda 40
 *
41
 * The driver services a single controller which can have up to two disks
42
 * attached.
4507 svoboda 43
 */
44
 
45
#include <stdio.h>
46
#include <libarch/ddi.h>
47
#include <ddi.h>
48
#include <ipc/ipc.h>
49
#include <ipc/bd.h>
50
#include <async.h>
51
#include <as.h>
4557 svoboda 52
#include <fibril_sync.h>
4507 svoboda 53
#include <devmap.h>
54
#include <sys/types.h>
55
#include <errno.h>
4529 svoboda 56
#include <bool.h>
4621 svoboda 57
#include <task.h>
4507 svoboda 58
 
4530 svoboda 59
#include "ata_bd.h"
60
 
4507 svoboda 61
#define NAME "ata_bd"
62
 
63
static const size_t block_size = 512;
64
static size_t comm_size;
65
 
66
static uintptr_t cmd_physical = 0x1f0;
67
static uintptr_t ctl_physical = 0x170;
68
static ata_cmd_t *cmd;
69
static ata_ctl_t *ctl;
70
 
4557 svoboda 71
/** Per-disk state. */
4531 svoboda 72
static disk_t disk[MAX_DISKS];
4507 svoboda 73
 
74
static int ata_bd_init(void);
75
static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
4545 svoboda 76
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
4507 svoboda 77
    void *buf);
78
static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
79
    void *buf);
4532 svoboda 80
static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
81
    const void *buf);
4529 svoboda 82
static int drive_identify(int drive_id, disk_t *d);
4507 svoboda 83
 
84
int main(int argc, char **argv)
85
{
86
    uint8_t status;
4529 svoboda 87
    char name[16];
88
    int i, rc;
89
    int n_disks;
4507 svoboda 90
 
91
    printf(NAME ": ATA disk driver\n");
92
 
4557 svoboda 93
    printf("I/O address 0x%x\n", cmd_physical);
4507 svoboda 94
 
95
    if (ata_bd_init() != EOK)
96
        return -1;
97
 
98
    /* Put drives to reset, disable interrupts. */
99
    printf("Reset drives...\n");
100
    pio_write_8(&ctl->device_control, DCR_SRST);
4531 svoboda 101
    /* FIXME: Find out how to do this properly. */
4507 svoboda 102
    async_usleep(100);
103
    pio_write_8(&ctl->device_control, 0);
104
 
105
    do {
106
        status = pio_read_8(&cmd->status);
107
    } while ((status & SR_BSY) != 0);
108
    printf("Done\n");
109
 
110
    printf("Status = 0x%x\n", pio_read_8(&cmd->status));
111
 
4529 svoboda 112
    (void) drive_identify(0, &disk[0]);
113
    (void) drive_identify(1, &disk[1]);
114
 
115
    n_disks = 0;
116
 
117
    for (i = 0; i < MAX_DISKS; i++) {
118
        /* Skip unattached drives. */
119
        if (disk[i].present == false)
120
            continue;
121
 
122
        snprintf(name, 16, "disk%d", i);
4557 svoboda 123
        rc = devmap_device_register(name, &disk[i].dev_handle);
4529 svoboda 124
        if (rc != EOK) {
125
            devmap_hangup_phone(DEVMAP_DRIVER);
126
            printf(NAME ": Unable to register device %s.\n",
127
                name);
128
            return rc;
129
        }
130
        ++n_disks;
131
    }
132
 
133
    if (n_disks == 0) {
134
        printf("No disks detected.\n");
135
        return -1;
136
    }
137
 
138
    printf(NAME ": Accepting connections\n");
4621 svoboda 139
    task_retval(0);
4529 svoboda 140
    async_manager();
141
 
142
    /* Not reached */
143
    return 0;
144
}
145
 
146
static int drive_identify(int disk_id, disk_t *d)
147
{
148
    uint16_t data;
149
    uint8_t status;
4545 svoboda 150
    size_t i;
4529 svoboda 151
 
152
    printf("Identify drive %d\n", disk_id);
153
    pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
4507 svoboda 154
    async_usleep(100);
4531 svoboda 155
    pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
4507 svoboda 156
 
4529 svoboda 157
    status = pio_read_8(&cmd->status);
158
    printf("Status = 0x%x\n", status);
4507 svoboda 159
 
4529 svoboda 160
    d->present = false;
161
 
162
    /*
163
     * Detect if drive is present. This is Qemu only! Need to
164
     * do the right thing to work with real drives.
165
     */
166
    if ((status & SR_DRDY) == 0) {
167
        printf("None attached.\n");
168
        return ENOENT;
169
    }
170
 
4531 svoboda 171
    for (i = 0; i < block_size / 2; i++) {
4507 svoboda 172
        do {
173
            status = pio_read_8(&cmd->status);
174
        } while ((status & SR_DRDY) == 0);
175
 
176
        data = pio_read_16(&cmd->data_port);
177
 
178
        switch (i) {
4529 svoboda 179
        case 1: d->cylinders = data; break;
180
        case 3: d->heads = data; break;
181
        case 6: d->sectors = data; break;
4507 svoboda 182
        }
183
    }
184
 
4529 svoboda 185
    d->blocks = d->cylinders * d->heads * d->sectors;
186
 
4507 svoboda 187
    printf("Geometry: %u cylinders, %u heads, %u sectors\n",
4529 svoboda 188
        d->cylinders, d->heads, d->sectors);
4507 svoboda 189
 
4529 svoboda 190
    d->present = true;
4557 svoboda 191
    fibril_mutex_initialize(&d->lock);
4507 svoboda 192
 
4529 svoboda 193
    return EOK;
4507 svoboda 194
}
195
 
196
static int ata_bd_init(void)
197
{
198
    void *vaddr;
4529 svoboda 199
    int rc;
4507 svoboda 200
 
201
    rc = devmap_driver_register(NAME, ata_bd_connection);
202
    if (rc < 0) {
203
        printf(NAME ": Unable to register driver.\n");
204
        return rc;
205
    }
206
 
207
    rc = pio_enable((void *) cmd_physical, sizeof(ata_cmd_t), &vaddr);
208
    if (rc != EOK) {
209
        printf(NAME ": Could not initialize device I/O space.\n");
210
        return rc;
211
    }
212
 
213
    cmd = vaddr;
214
 
215
    rc = pio_enable((void *) ctl_physical, sizeof(ata_ctl_t), &vaddr);
216
    if (rc != EOK) {
217
        printf(NAME ": Could not initialize device I/O space.\n");
218
        return rc;
219
    }
220
 
221
    ctl = vaddr;
222
 
223
 
224
    return EOK;
225
}
226
 
227
static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
228
{
229
    void *fs_va = NULL;
230
    ipc_callid_t callid;
231
    ipc_call_t call;
232
    ipcarg_t method;
233
    dev_handle_t dh;
234
    int flags;
235
    int retval;
236
    off_t idx;
4545 svoboda 237
    size_t size;
4507 svoboda 238
    int disk_id, i;
239
 
240
    /* Get the device handle. */
241
    dh = IPC_GET_ARG1(*icall);
242
 
243
    /* Determine which disk device is the client connecting to. */
244
    disk_id = -1;
245
    for (i = 0; i < MAX_DISKS; i++)
4557 svoboda 246
        if (disk[i].dev_handle == dh)
4507 svoboda 247
            disk_id = i;
248
 
4529 svoboda 249
    if (disk_id < 0 || disk[disk_id].present == false) {
4507 svoboda 250
        ipc_answer_0(iid, EINVAL);
251
        return;
252
    }
253
 
254
    /* Answer the IPC_M_CONNECT_ME_TO call. */
255
    ipc_answer_0(iid, EOK);
256
 
257
    if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
258
        ipc_answer_0(callid, EHANGUP);
259
        return;
260
    }
261
 
262
    fs_va = as_get_mappable_page(comm_size);
263
    if (fs_va == NULL) {
264
        ipc_answer_0(callid, EHANGUP);
265
        return;
266
    }
267
 
268
    (void) ipc_share_out_finalize(callid, fs_va);
269
 
270
    while (1) {
271
        callid = async_get_call(&call);
272
        method = IPC_GET_METHOD(call);
273
        switch (method) {
274
        case IPC_M_PHONE_HUNGUP:
275
            /* The other side has hung up. */
276
            ipc_answer_0(callid, EOK);
277
            return;
278
        case BD_READ_BLOCK:
279
        case BD_WRITE_BLOCK:
280
            idx = IPC_GET_ARG1(call);
281
            size = IPC_GET_ARG2(call);
282
            if (size > comm_size) {
283
                retval = EINVAL;
284
                break;
285
            }
286
            retval = ata_bd_rdwr(disk_id, method, idx,
287
                size, fs_va);
288
            break;
289
        default:
290
            retval = EINVAL;
291
            break;
292
        }
293
        ipc_answer_0(callid, retval);
294
    }
295
}
296
 
4545 svoboda 297
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
4507 svoboda 298
    void *buf)
299
{
300
    int rc;
4545 svoboda 301
    size_t now;
4507 svoboda 302
 
303
    while (size > 0) {
4545 svoboda 304
        now = size < block_size ? size : block_size;
4507 svoboda 305
        if (now != block_size)
306
            return EINVAL;
307
 
308
        if (method == BD_READ_BLOCK)
309
            rc = ata_bd_read_block(disk_id, blk_idx, 1, buf);
310
        else
4532 svoboda 311
            rc = ata_bd_write_block(disk_id, blk_idx, 1, buf);
4507 svoboda 312
 
313
        if (rc != EOK)
314
            return rc;
315
 
316
        buf += block_size;
317
        blk_idx++;
318
 
319
        if (size > block_size)
320
            size -= block_size;
321
        else
322
            size = 0;
323
    }
324
 
325
    return EOK;
326
}
327
 
328
 
329
static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
330
    void *buf)
331
{
332
    size_t i;
333
    uint16_t data;
334
    uint8_t status;
335
    uint64_t c, h, s;
336
    uint64_t idx;
337
    uint8_t drv_head;
4529 svoboda 338
    disk_t *d;
4507 svoboda 339
 
4529 svoboda 340
    d = &disk[disk_id];
341
 
4507 svoboda 342
    /* Check device bounds. */
4529 svoboda 343
    if (blk_idx >= d->blocks)
4507 svoboda 344
        return EINVAL;
345
 
346
    /* Compute CHS. */
4529 svoboda 347
    c = blk_idx / (d->heads * d->sectors);
348
    idx = blk_idx % (d->heads * d->sectors);
4507 svoboda 349
 
4529 svoboda 350
    h = idx / d->sectors;
351
    s = 1 + (idx % d->sectors);
4507 svoboda 352
 
353
    /* New value for Drive/Head register */
354
    drv_head =
355
        ((disk_id != 0) ? DHR_DRV : 0) |
356
        (h & 0x0f);
357
 
4557 svoboda 358
    fibril_mutex_lock(&d->lock);
4507 svoboda 359
 
360
    /* Program a Read Sectors operation. */
361
 
362
    pio_write_8(&cmd->drive_head, drv_head);
363
    pio_write_8(&cmd->sector_count, 1);
364
    pio_write_8(&cmd->sector_number, s);
365
    pio_write_8(&cmd->cylinder_low, c & 0xff);
366
    pio_write_8(&cmd->cylinder_high, c >> 16);
4531 svoboda 367
    pio_write_8(&cmd->command, CMD_READ_SECTORS);
4507 svoboda 368
 
369
    /* Read data from the disk buffer. */
370
 
4531 svoboda 371
    for (i = 0; i < block_size / 2; i++) {
4507 svoboda 372
        do {
373
            status = pio_read_8(&cmd->status);
374
        } while ((status & SR_DRDY) == 0);
375
 
376
        data = pio_read_16(&cmd->data_port);
377
        ((uint16_t *) buf)[i] = data;
378
    }
379
 
4557 svoboda 380
    fibril_mutex_unlock(&d->lock);
4507 svoboda 381
    return EOK;
382
}
383
 
4532 svoboda 384
static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
385
    const void *buf)
386
{
387
    size_t i;
388
    uint8_t status;
389
    uint64_t c, h, s;
390
    uint64_t idx;
391
    uint8_t drv_head;
392
    disk_t *d;
4507 svoboda 393
 
4532 svoboda 394
    d = &disk[disk_id];
395
 
396
    /* Check device bounds. */
397
    if (blk_idx >= d->blocks)
398
        return EINVAL;
399
 
400
    /* Compute CHS. */
401
    c = blk_idx / (d->heads * d->sectors);
402
    idx = blk_idx % (d->heads * d->sectors);
403
 
404
    h = idx / d->sectors;
405
    s = 1 + (idx % d->sectors);
406
 
407
    /* New value for Drive/Head register */
408
    drv_head =
409
        ((disk_id != 0) ? DHR_DRV : 0) |
410
        (h & 0x0f);
411
 
4557 svoboda 412
    fibril_mutex_lock(&d->lock);
4532 svoboda 413
 
414
    /* Program a Read Sectors operation. */
415
 
416
    pio_write_8(&cmd->drive_head, drv_head);
417
    pio_write_8(&cmd->sector_count, 1);
418
    pio_write_8(&cmd->sector_number, s);
419
    pio_write_8(&cmd->cylinder_low, c & 0xff);
420
    pio_write_8(&cmd->cylinder_high, c >> 16);
421
    pio_write_8(&cmd->command, CMD_WRITE_SECTORS);
422
 
423
    /* Write data to the disk buffer. */
424
 
425
    for (i = 0; i < block_size / 2; i++) {
426
        do {
427
            status = pio_read_8(&cmd->status);
428
        } while ((status & SR_DRDY) == 0);
429
 
430
        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
431
    }
432
 
4557 svoboda 433
    fibril_mutex_unlock(&d->lock);
4532 svoboda 434
    return EOK;
435
}
436
 
437
 
4507 svoboda 438
/**
439
 * @}
440
 */