Rev 4532 | Rev 4621 | 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. |
||
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> |
||
4529 | svoboda | 53 | #include <bool.h> |
4507 | svoboda | 54 | |
4530 | svoboda | 55 | #include "ata_bd.h" |
56 | |||
4507 | svoboda | 57 | #define NAME "ata_bd" |
58 | |||
59 | static const size_t block_size = 512; |
||
60 | static size_t comm_size; |
||
61 | |||
62 | static uintptr_t cmd_physical = 0x1f0; |
||
63 | static uintptr_t ctl_physical = 0x170; |
||
64 | static ata_cmd_t *cmd; |
||
65 | static ata_ctl_t *ctl; |
||
66 | |||
67 | static dev_handle_t dev_handle[MAX_DISKS]; |
||
68 | |||
69 | static atomic_t dev_futex = FUTEX_INITIALIZER; |
||
70 | |||
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 | |||
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); |
||
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); |
||
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 | |||
145 | static int drive_identify(int disk_id, disk_t *d) |
||
146 | { |
||
147 | uint16_t data; |
||
148 | uint8_t status; |
||
4545 | svoboda | 149 | size_t i; |
4529 | svoboda | 150 | |
151 | printf("Identify drive %d\n", disk_id); |
||
152 | pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0)); |
||
4507 | svoboda | 153 | async_usleep(100); |
4531 | svoboda | 154 | pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE); |
4507 | svoboda | 155 | |
4529 | svoboda | 156 | status = pio_read_8(&cmd->status); |
157 | printf("Status = 0x%x\n", status); |
||
4507 | svoboda | 158 | |
4529 | svoboda | 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 | |||
4531 | svoboda | 170 | for (i = 0; i < block_size / 2; i++) { |
4507 | svoboda | 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) { |
||
4529 | svoboda | 178 | case 1: d->cylinders = data; break; |
179 | case 3: d->heads = data; break; |
||
180 | case 6: d->sectors = data; break; |
||
4507 | svoboda | 181 | } |
182 | } |
||
183 | |||
184 | printf("\n\nStatus = 0x%x\n", pio_read_8(&cmd->status)); |
||
185 | |||
4529 | svoboda | 186 | d->blocks = d->cylinders * d->heads * d->sectors; |
187 | |||
4507 | svoboda | 188 | printf("Geometry: %u cylinders, %u heads, %u sectors\n", |
4529 | svoboda | 189 | d->cylinders, d->heads, d->sectors); |
4507 | svoboda | 190 | |
4529 | svoboda | 191 | d->present = true; |
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++) |
||
246 | if (dev_handle[i] == dh) |
||
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 | |||
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); |
||
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 | |||
380 | futex_up(&dev_futex); |
||
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 | |||
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 | |||
4507 | svoboda | 438 | /** |
439 | * @} |
||
440 | */ |