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>
4507 svoboda 57
 
4530 svoboda 58
#include "ata_bd.h"
59
 
4507 svoboda 60
#define NAME "ata_bd"
61
 
62
static const size_t block_size = 512;
63
static size_t comm_size;
64
 
65
static uintptr_t cmd_physical = 0x1f0;
66
static uintptr_t ctl_physical = 0x170;
67
static ata_cmd_t *cmd;
68
static ata_ctl_t *ctl;
69
 
4557 svoboda 70
/** Per-disk state. */
4531 svoboda 71
static disk_t disk[MAX_DISKS];
4507 svoboda 72
 
73
static int ata_bd_init(void);
74
static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
4545 svoboda 75
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
4507 svoboda 76
    void *buf);
77
static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
78
    void *buf);
4532 svoboda 79
static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
80
    const void *buf);
4529 svoboda 81
static int drive_identify(int drive_id, disk_t *d);
4507 svoboda 82
 
83
int main(int argc, char **argv)
84
{
85
    uint8_t status;
4529 svoboda 86
    char name[16];
87
    int i, rc;
88
    int n_disks;
4507 svoboda 89
 
90
    printf(NAME ": ATA disk driver\n");
91
 
4557 svoboda 92
    printf("I/O address 0x%x\n", cmd_physical);
4507 svoboda 93
 
94
    if (ata_bd_init() != EOK)
95
        return -1;
96
 
97
    /* Put drives to reset, disable interrupts. */
98
    printf("Reset drives...\n");
99
    pio_write_8(&ctl->device_control, DCR_SRST);
4531 svoboda 100
    /* FIXME: Find out how to do this properly. */
4507 svoboda 101
    async_usleep(100);
102
    pio_write_8(&ctl->device_control, 0);
103
 
104
    do {
105
        status = pio_read_8(&cmd->status);
106
    } while ((status & SR_BSY) != 0);
107
    printf("Done\n");
108
 
109
    printf("Status = 0x%x\n", pio_read_8(&cmd->status));
110
 
4529 svoboda 111
    (void) drive_identify(0, &disk[0]);
112
    (void) drive_identify(1, &disk[1]);
113
 
114
    n_disks = 0;
115
 
116
    for (i = 0; i < MAX_DISKS; i++) {
117
        /* Skip unattached drives. */
118
        if (disk[i].present == false)
119
            continue;
120
 
121
        snprintf(name, 16, "disk%d", i);
4557 svoboda 122
        rc = devmap_device_register(name, &disk[i].dev_handle);
4529 svoboda 123
        if (rc != EOK) {
124
            devmap_hangup_phone(DEVMAP_DRIVER);
125
            printf(NAME ": Unable to register device %s.\n",
126
                name);
127
            return rc;
128
        }
129
        ++n_disks;
130
    }
131
 
132
    if (n_disks == 0) {
133
        printf("No disks detected.\n");
134
        return -1;
135
    }
136
 
137
    printf(NAME ": Accepting connections\n");
138
    async_manager();
139
 
140
    /* Not reached */
141
    return 0;
142
}
143
 
144
static int drive_identify(int disk_id, disk_t *d)
145
{
146
    uint16_t data;
147
    uint8_t status;
4545 svoboda 148
    size_t i;
4529 svoboda 149
 
150
    printf("Identify drive %d\n", disk_id);
151
    pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
4507 svoboda 152
    async_usleep(100);
4531 svoboda 153
    pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
4507 svoboda 154
 
4529 svoboda 155
    status = pio_read_8(&cmd->status);
156
    printf("Status = 0x%x\n", status);
4507 svoboda 157
 
4529 svoboda 158
    d->present = false;
159
 
160
    /*
161
     * Detect if drive is present. This is Qemu only! Need to
162
     * do the right thing to work with real drives.
163
     */
164
    if ((status & SR_DRDY) == 0) {
165
        printf("None attached.\n");
166
        return ENOENT;
167
    }
168
 
4531 svoboda 169
    for (i = 0; i < block_size / 2; i++) {
4507 svoboda 170
        do {
171
            status = pio_read_8(&cmd->status);
172
        } while ((status & SR_DRDY) == 0);
173
 
174
        data = pio_read_16(&cmd->data_port);
175
 
176
        switch (i) {
4529 svoboda 177
        case 1: d->cylinders = data; break;
178
        case 3: d->heads = data; break;
179
        case 6: d->sectors = data; break;
4507 svoboda 180
        }
181
    }
182
 
4529 svoboda 183
    d->blocks = d->cylinders * d->heads * d->sectors;
184
 
4507 svoboda 185
    printf("Geometry: %u cylinders, %u heads, %u sectors\n",
4529 svoboda 186
        d->cylinders, d->heads, d->sectors);
4507 svoboda 187
 
4529 svoboda 188
    d->present = true;
4557 svoboda 189
    fibril_mutex_initialize(&d->lock);
4507 svoboda 190
 
4529 svoboda 191
    return EOK;
4507 svoboda 192
}
193
 
194
static int ata_bd_init(void)
195
{
196
    void *vaddr;
4529 svoboda 197
    int rc;
4507 svoboda 198
 
199
    rc = devmap_driver_register(NAME, ata_bd_connection);
200
    if (rc < 0) {
201
        printf(NAME ": Unable to register driver.\n");
202
        return rc;
203
    }
204
 
205
    rc = pio_enable((void *) cmd_physical, sizeof(ata_cmd_t), &vaddr);
206
    if (rc != EOK) {
207
        printf(NAME ": Could not initialize device I/O space.\n");
208
        return rc;
209
    }
210
 
211
    cmd = vaddr;
212
 
213
    rc = pio_enable((void *) ctl_physical, sizeof(ata_ctl_t), &vaddr);
214
    if (rc != EOK) {
215
        printf(NAME ": Could not initialize device I/O space.\n");
216
        return rc;
217
    }
218
 
219
    ctl = vaddr;
220
 
221
 
222
    return EOK;
223
}
224
 
225
static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
226
{
227
    void *fs_va = NULL;
228
    ipc_callid_t callid;
229
    ipc_call_t call;
230
    ipcarg_t method;
231
    dev_handle_t dh;
232
    int flags;
233
    int retval;
234
    off_t idx;
4545 svoboda 235
    size_t size;
4507 svoboda 236
    int disk_id, i;
237
 
238
    /* Get the device handle. */
239
    dh = IPC_GET_ARG1(*icall);
240
 
241
    /* Determine which disk device is the client connecting to. */
242
    disk_id = -1;
243
    for (i = 0; i < MAX_DISKS; i++)
4557 svoboda 244
        if (disk[i].dev_handle == dh)
4507 svoboda 245
            disk_id = i;
246
 
4529 svoboda 247
    if (disk_id < 0 || disk[disk_id].present == false) {
4507 svoboda 248
        ipc_answer_0(iid, EINVAL);
249
        return;
250
    }
251
 
252
    /* Answer the IPC_M_CONNECT_ME_TO call. */
253
    ipc_answer_0(iid, EOK);
254
 
255
    if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
256
        ipc_answer_0(callid, EHANGUP);
257
        return;
258
    }
259
 
260
    fs_va = as_get_mappable_page(comm_size);
261
    if (fs_va == NULL) {
262
        ipc_answer_0(callid, EHANGUP);
263
        return;
264
    }
265
 
266
    (void) ipc_share_out_finalize(callid, fs_va);
267
 
268
    while (1) {
269
        callid = async_get_call(&call);
270
        method = IPC_GET_METHOD(call);
271
        switch (method) {
272
        case IPC_M_PHONE_HUNGUP:
273
            /* The other side has hung up. */
274
            ipc_answer_0(callid, EOK);
275
            return;
276
        case BD_READ_BLOCK:
277
        case BD_WRITE_BLOCK:
278
            idx = IPC_GET_ARG1(call);
279
            size = IPC_GET_ARG2(call);
280
            if (size > comm_size) {
281
                retval = EINVAL;
282
                break;
283
            }
284
            retval = ata_bd_rdwr(disk_id, method, idx,
285
                size, fs_va);
286
            break;
287
        default:
288
            retval = EINVAL;
289
            break;
290
        }
291
        ipc_answer_0(callid, retval);
292
    }
293
}
294
 
4545 svoboda 295
static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
4507 svoboda 296
    void *buf)
297
{
298
    int rc;
4545 svoboda 299
    size_t now;
4507 svoboda 300
 
301
    while (size > 0) {
4545 svoboda 302
        now = size < block_size ? size : block_size;
4507 svoboda 303
        if (now != block_size)
304
            return EINVAL;
305
 
306
        if (method == BD_READ_BLOCK)
307
            rc = ata_bd_read_block(disk_id, blk_idx, 1, buf);
308
        else
4532 svoboda 309
            rc = ata_bd_write_block(disk_id, blk_idx, 1, buf);
4507 svoboda 310
 
311
        if (rc != EOK)
312
            return rc;
313
 
314
        buf += block_size;
315
        blk_idx++;
316
 
317
        if (size > block_size)
318
            size -= block_size;
319
        else
320
            size = 0;
321
    }
322
 
323
    return EOK;
324
}
325
 
326
 
327
static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
328
    void *buf)
329
{
330
    size_t i;
331
    uint16_t data;
332
    uint8_t status;
333
    uint64_t c, h, s;
334
    uint64_t idx;
335
    uint8_t drv_head;
4529 svoboda 336
    disk_t *d;
4507 svoboda 337
 
4529 svoboda 338
    d = &disk[disk_id];
339
 
4507 svoboda 340
    /* Check device bounds. */
4529 svoboda 341
    if (blk_idx >= d->blocks)
4507 svoboda 342
        return EINVAL;
343
 
344
    /* Compute CHS. */
4529 svoboda 345
    c = blk_idx / (d->heads * d->sectors);
346
    idx = blk_idx % (d->heads * d->sectors);
4507 svoboda 347
 
4529 svoboda 348
    h = idx / d->sectors;
349
    s = 1 + (idx % d->sectors);
4507 svoboda 350
 
351
    /* New value for Drive/Head register */
352
    drv_head =
353
        ((disk_id != 0) ? DHR_DRV : 0) |
354
        (h & 0x0f);
355
 
4557 svoboda 356
    fibril_mutex_lock(&d->lock);
4507 svoboda 357
 
358
    /* Program a Read Sectors operation. */
359
 
360
    pio_write_8(&cmd->drive_head, drv_head);
361
    pio_write_8(&cmd->sector_count, 1);
362
    pio_write_8(&cmd->sector_number, s);
363
    pio_write_8(&cmd->cylinder_low, c & 0xff);
364
    pio_write_8(&cmd->cylinder_high, c >> 16);
4531 svoboda 365
    pio_write_8(&cmd->command, CMD_READ_SECTORS);
4507 svoboda 366
 
367
    /* Read data from the disk buffer. */
368
 
4531 svoboda 369
    for (i = 0; i < block_size / 2; i++) {
4507 svoboda 370
        do {
371
            status = pio_read_8(&cmd->status);
372
        } while ((status & SR_DRDY) == 0);
373
 
374
        data = pio_read_16(&cmd->data_port);
375
        ((uint16_t *) buf)[i] = data;
376
    }
377
 
4557 svoboda 378
    fibril_mutex_unlock(&d->lock);
4507 svoboda 379
    return EOK;
380
}
381
 
4532 svoboda 382
static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
383
    const void *buf)
384
{
385
    size_t i;
386
    uint8_t status;
387
    uint64_t c, h, s;
388
    uint64_t idx;
389
    uint8_t drv_head;
390
    disk_t *d;
4507 svoboda 391
 
4532 svoboda 392
    d = &disk[disk_id];
393
 
394
    /* Check device bounds. */
395
    if (blk_idx >= d->blocks)
396
        return EINVAL;
397
 
398
    /* Compute CHS. */
399
    c = blk_idx / (d->heads * d->sectors);
400
    idx = blk_idx % (d->heads * d->sectors);
401
 
402
    h = idx / d->sectors;
403
    s = 1 + (idx % d->sectors);
404
 
405
    /* New value for Drive/Head register */
406
    drv_head =
407
        ((disk_id != 0) ? DHR_DRV : 0) |
408
        (h & 0x0f);
409
 
4557 svoboda 410
    fibril_mutex_lock(&d->lock);
4532 svoboda 411
 
412
    /* Program a Read Sectors operation. */
413
 
414
    pio_write_8(&cmd->drive_head, drv_head);
415
    pio_write_8(&cmd->sector_count, 1);
416
    pio_write_8(&cmd->sector_number, s);
417
    pio_write_8(&cmd->cylinder_low, c & 0xff);
418
    pio_write_8(&cmd->cylinder_high, c >> 16);
419
    pio_write_8(&cmd->command, CMD_WRITE_SECTORS);
420
 
421
    /* Write data to the disk buffer. */
422
 
423
    for (i = 0; i < block_size / 2; i++) {
424
        do {
425
            status = pio_read_8(&cmd->status);
426
        } while ((status & SR_DRDY) == 0);
427
 
428
        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
429
    }
430
 
4557 svoboda 431
    fibril_mutex_unlock(&d->lock);
4532 svoboda 432
    return EOK;
433
}
434
 
435
 
4507 svoboda 436
/**
437
 * @}
438
 */