source: mainline/uspace/srv/bd/ata_bd/ata_bd.c@ d9f4c76

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

Write support in ata_bd. Not used, not tested.
  • Property mode set to 100644
File size: 9.7 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
42#include <stdio.h>
43#include <libarch/ddi.h>
44#include <ddi.h>
45#include <ipc/ipc.h>
46#include <ipc/bd.h>
47#include <async.h>
48#include <as.h>
49#include <futex.h>
50#include <devmap.h>
51#include <sys/types.h>
52#include <errno.h>
53#include <bool.h>
54
55#include "ata_bd.h"
56
57#define NAME "ata_bd"
58
59static const size_t block_size = 512;
60static size_t comm_size;
61
62static uintptr_t cmd_physical = 0x1f0;
63static uintptr_t ctl_physical = 0x170;
64static ata_cmd_t *cmd;
65static ata_ctl_t *ctl;
66
67static dev_handle_t dev_handle[MAX_DISKS];
68
69static atomic_t dev_futex = FUTEX_INITIALIZER;
70
71static disk_t disk[MAX_DISKS];
72
73static int ata_bd_init(void);
74static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
75static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, off_t size,
76 void *buf);
77static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
78 void *buf);
79static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
80 const void *buf);
81static int drive_identify(int drive_id, disk_t *d);
82
83int main(int argc, char **argv)
84{
85 uint8_t status;
86 char name[16];
87 int i, rc;
88 int n_disks;
89
90 printf(NAME ": ATA disk driver\n");
91
92 printf("cmd_physical = 0x%x\n", cmd_physical);
93 printf("ctl_physical = 0x%x\n", ctl_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, &dev_handle[i]);
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 async_manager();
140
141 /* Not reached */
142 return 0;
143}
144
145static int drive_identify(int disk_id, disk_t *d)
146{
147 uint16_t data;
148 uint8_t status;
149 int i;
150
151 printf("Identify drive %d\n", disk_id);
152 pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
153 async_usleep(100);
154 pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
155
156 status = pio_read_8(&cmd->status);
157 printf("Status = 0x%x\n", status);
158
159 d->present = false;
160
161 /*
162 * Detect if drive is present. This is Qemu only! Need to
163 * do the right thing to work with real drives.
164 */
165 if ((status & SR_DRDY) == 0) {
166 printf("None attached.\n");
167 return ENOENT;
168 }
169
170 for (i = 0; i < block_size / 2; i++) {
171 do {
172 status = pio_read_8(&cmd->status);
173 } while ((status & SR_DRDY) == 0);
174
175 data = pio_read_16(&cmd->data_port);
176
177 switch (i) {
178 case 1: d->cylinders = data; break;
179 case 3: d->heads = data; break;
180 case 6: d->sectors = data; break;
181 }
182 }
183
184 printf("\n\nStatus = 0x%x\n", pio_read_8(&cmd->status));
185
186 d->blocks = d->cylinders * d->heads * d->sectors;
187
188 printf("Geometry: %u cylinders, %u heads, %u sectors\n",
189 d->cylinders, d->heads, d->sectors);
190
191 d->present = true;
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 off_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 (dev_handle[i] == 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, off_t size,
298 void *buf)
299{
300 int rc;
301 off_t now;
302
303 while (size > 0) {
304 now = size < block_size ? size : (off_t) 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 futex_down(&dev_futex);
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 futex_up(&dev_futex);
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 futex_down(&dev_futex);
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 futex_up(&dev_futex);
434 return EOK;
435}
436
437
438/**
439 * @}
440 */
Note: See TracBrowser for help on using the repository browser.