source: mainline/uspace/srv/bd/ata_bd/ata_bd.c@ 1757ffce

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1757ffce was 95bc57c, checked in by Jiri Svoboda <jirik.svoboda@…>, 16 years ago

Servers can return value as soon as they are up. Use this with block-device drivers to start them synchronously. Eliminate ad-hoc sleeping.
  • Property mode set to 100644
File size: 9.8 KB
Line 
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.
40 *
41 * The driver services a single controller which can have up to two disks
42 * attached.
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>
52#include <fibril_sync.h>
53#include <devmap.h>
54#include <sys/types.h>
55#include <errno.h>
56#include <bool.h>
57#include <task.h>
58
59#include "ata_bd.h"
60
61#define NAME "ata_bd"
62
63static const size_t block_size = 512;
64static size_t comm_size;
65
66static uintptr_t cmd_physical = 0x1f0;
67static uintptr_t ctl_physical = 0x170;
68static ata_cmd_t *cmd;
69static ata_ctl_t *ctl;
70
71/** Per-disk state. */
72static disk_t disk[MAX_DISKS];
73
74static int ata_bd_init(void);
75static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
76static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size,
77 void *buf);
78static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
79 void *buf);
80static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
81 const void *buf);
82static int drive_identify(int drive_id, disk_t *d);
83
84int main(int argc, char **argv)
85{
86 uint8_t status;
87 char name[16];
88 int i, rc;
89 int n_disks;
90
91 printf(NAME ": ATA disk driver\n");
92
93 printf("I/O address 0x%x\n", cmd_physical);
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);
101 /* FIXME: Find out how to do this properly. */
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
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);
123 rc = devmap_device_register(name, &disk[i].dev_handle);
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");
139 task_retval(0);
140 async_manager();
141
142 /* Not reached */
143 return 0;
144}
145
146static int drive_identify(int disk_id, disk_t *d)
147{
148 uint16_t data;
149 uint8_t status;
150 size_t i;
151
152 printf("Identify drive %d\n", disk_id);
153 pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
154 async_usleep(100);
155 pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
156
157 status = pio_read_8(&cmd->status);
158 printf("Status = 0x%x\n", status);
159
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
171 for (i = 0; i < block_size / 2; i++) {
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) {
179 case 1: d->cylinders = data; break;
180 case 3: d->heads = data; break;
181 case 6: d->sectors = data; break;
182 }
183 }
184
185 d->blocks = d->cylinders * d->heads * d->sectors;
186
187 printf("Geometry: %u cylinders, %u heads, %u sectors\n",
188 d->cylinders, d->heads, d->sectors);
189
190 d->present = true;
191 fibril_mutex_initialize(&d->lock);
192
193 return EOK;
194}
195
196static int ata_bd_init(void)
197{
198 void *vaddr;
199 int rc;
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
227static 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;
237 size_t size;
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++)
246 if (disk[i].dev_handle == dh)
247 disk_id = i;
248
249 if (disk_id < 0 || disk[disk_id].present == false) {
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
297static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
298 void *buf)
299{
300 int rc;
301 size_t now;
302
303 while (size > 0) {
304 now = size < block_size ? size : block_size;
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
311 rc = ata_bd_write_block(disk_id, blk_idx, 1, buf);
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
329static 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;
338 disk_t *d;
339
340 d = &disk[disk_id];
341
342 /* Check device bounds. */
343 if (blk_idx >= d->blocks)
344 return EINVAL;
345
346 /* Compute CHS. */
347 c = blk_idx / (d->heads * d->sectors);
348 idx = blk_idx % (d->heads * d->sectors);
349
350 h = idx / d->sectors;
351 s = 1 + (idx % d->sectors);
352
353 /* New value for Drive/Head register */
354 drv_head =
355 ((disk_id != 0) ? DHR_DRV : 0) |
356 (h & 0x0f);
357
358 fibril_mutex_lock(&d->lock);
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);
367 pio_write_8(&cmd->command, CMD_READ_SECTORS);
368
369 /* Read data from the disk buffer. */
370
371 for (i = 0; i < block_size / 2; i++) {
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
380 fibril_mutex_unlock(&d->lock);
381 return EOK;
382}
383
384static 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;
393
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
412 fibril_mutex_lock(&d->lock);
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
433 fibril_mutex_unlock(&d->lock);
434 return EOK;
435}
436
437
438/**
439 * @}
440 */
Note: See TracBrowser for help on using the repository browser.