[tcpip] Allow supported address families to be detected at runtime
[ipxe.git] / src / drivers / block / ata.c
1 /*
2 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 #include <stddef.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <assert.h>
30 #include <errno.h>
31 #include <byteswap.h>
32 #include <ipxe/list.h>
33 #include <ipxe/interface.h>
34 #include <ipxe/blockdev.h>
35 #include <ipxe/edd.h>
36 #include <ipxe/ata.h>
37
38 /** @file
39 *
40 * ATA block device
41 *
42 */
43
44 /******************************************************************************
45 *
46 * Interface methods
47 *
48 ******************************************************************************
49 */
50
51 /**
52 * Issue ATA command
53 *
54 * @v control ATA control interface
55 * @v data ATA data interface
56 * @v command ATA command
57 * @ret tag Command tag, or negative error
58 */
59 int ata_command ( struct interface *control, struct interface *data,
60 struct ata_cmd *command ) {
61 struct interface *dest;
62 ata_command_TYPE ( void * ) *op =
63 intf_get_dest_op ( control, ata_command, &dest );
64 void *object = intf_object ( dest );
65 int tag;
66
67 if ( op ) {
68 tag = op ( object, data, command );
69 } else {
70 /* Default is to fail to issue the command */
71 tag = -EOPNOTSUPP;
72 }
73
74 intf_put ( dest );
75 return tag;
76 }
77
78 /******************************************************************************
79 *
80 * ATA devices and commands
81 *
82 ******************************************************************************
83 */
84
85 /** List of all ATA commands */
86 static LIST_HEAD ( ata_commands );
87
88 /** An ATA device */
89 struct ata_device {
90 /** Reference count */
91 struct refcnt refcnt;
92 /** Block control interface */
93 struct interface block;
94 /** ATA control interface */
95 struct interface ata;
96
97 /** Device number
98 *
99 * Must be ATA_DEV_MASTER or ATA_DEV_SLAVE.
100 */
101 unsigned int device;
102 /** Maximum number of blocks per single transfer */
103 unsigned int max_count;
104 /** Device uses LBA48 extended addressing */
105 int lba48;
106 };
107
108 /** An ATA command */
109 struct ata_command {
110 /** Reference count */
111 struct refcnt refcnt;
112 /** ATA device */
113 struct ata_device *atadev;
114 /** List of ATA commands */
115 struct list_head list;
116
117 /** Block data interface */
118 struct interface block;
119 /** ATA data interface */
120 struct interface ata;
121
122 /** Command type */
123 struct ata_command_type *type;
124 /** Command tag */
125 uint32_t tag;
126
127 /** Private data */
128 uint8_t priv[0];
129 };
130
131 /** An ATA command type */
132 struct ata_command_type {
133 /** Name */
134 const char *name;
135 /** Additional working space */
136 size_t priv_len;
137 /** Command for non-LBA48-capable devices */
138 uint8_t cmd_lba;
139 /** Command for LBA48-capable devices */
140 uint8_t cmd_lba48;
141 /**
142 * Calculate data-in buffer
143 *
144 * @v atacmd ATA command
145 * @v buffer Available buffer
146 * @v len Available buffer length
147 * @ret data_in Data-in buffer
148 * @ret data_in_len Data-in buffer length
149 */
150 void ( * data_in ) ( struct ata_command *atacmd, userptr_t buffer,
151 size_t len, userptr_t *data_in,
152 size_t *data_in_len );
153 /**
154 * Calculate data-out buffer
155 *
156 *
157 * @v atacmd ATA command
158 * @v buffer Available buffer
159 * @v len Available buffer length
160 * @ret data_out Data-out buffer
161 * @ret data_out_len Data-out buffer length
162 */
163 void ( * data_out ) ( struct ata_command *atacmd, userptr_t buffer,
164 size_t len, userptr_t *data_out,
165 size_t *data_out_len );
166 /**
167 * Handle ATA command completion
168 *
169 * @v atacmd ATA command
170 * @v rc Reason for completion
171 */
172 void ( * done ) ( struct ata_command *atacmd, int rc );
173 };
174
175 /**
176 * Get reference to ATA device
177 *
178 * @v atadev ATA device
179 * @ret atadev ATA device
180 */
181 static inline __attribute__ (( always_inline )) struct ata_device *
182 atadev_get ( struct ata_device *atadev ) {
183 ref_get ( &atadev->refcnt );
184 return atadev;
185 }
186
187 /**
188 * Drop reference to ATA device
189 *
190 * @v atadev ATA device
191 */
192 static inline __attribute__ (( always_inline )) void
193 atadev_put ( struct ata_device *atadev ) {
194 ref_put ( &atadev->refcnt );
195 }
196
197 /**
198 * Get reference to ATA command
199 *
200 * @v atacmd ATA command
201 * @ret atacmd ATA command
202 */
203 static inline __attribute__ (( always_inline )) struct ata_command *
204 atacmd_get ( struct ata_command *atacmd ) {
205 ref_get ( &atacmd->refcnt );
206 return atacmd;
207 }
208
209 /**
210 * Drop reference to ATA command
211 *
212 * @v atacmd ATA command
213 */
214 static inline __attribute__ (( always_inline )) void
215 atacmd_put ( struct ata_command *atacmd ) {
216 ref_put ( &atacmd->refcnt );
217 }
218
219 /**
220 * Get ATA command private data
221 *
222 * @v atacmd ATA command
223 * @ret priv Private data
224 */
225 static inline __attribute__ (( always_inline )) void *
226 atacmd_priv ( struct ata_command *atacmd ) {
227 return atacmd->priv;
228 }
229
230 /**
231 * Free ATA command
232 *
233 * @v refcnt Reference count
234 */
235 static void atacmd_free ( struct refcnt *refcnt ) {
236 struct ata_command *atacmd =
237 container_of ( refcnt, struct ata_command, refcnt );
238
239 /* Remove from list of commands */
240 list_del ( &atacmd->list );
241 atadev_put ( atacmd->atadev );
242
243 /* Free command */
244 free ( atacmd );
245 }
246
247 /**
248 * Close ATA command
249 *
250 * @v atacmd ATA command
251 * @v rc Reason for close
252 */
253 static void atacmd_close ( struct ata_command *atacmd, int rc ) {
254 struct ata_device *atadev = atacmd->atadev;
255
256 if ( rc != 0 ) {
257 DBGC ( atadev, "ATA %p tag %08x closed: %s\n",
258 atadev, atacmd->tag, strerror ( rc ) );
259 }
260
261 /* Shut down interfaces */
262 intf_shutdown ( &atacmd->ata, rc );
263 intf_shutdown ( &atacmd->block, rc );
264 }
265
266 /**
267 * Handle ATA command completion
268 *
269 * @v atacmd ATA command
270 * @v rc Reason for close
271 */
272 static void atacmd_done ( struct ata_command *atacmd, int rc ) {
273
274 /* Hand over to the command completion handler */
275 atacmd->type->done ( atacmd, rc );
276 }
277
278 /**
279 * Use provided data buffer for ATA command
280 *
281 * @v atacmd ATA command
282 * @v buffer Available buffer
283 * @v len Available buffer length
284 * @ret data Data buffer
285 * @ret data_len Data buffer length
286 */
287 static void atacmd_data_buffer ( struct ata_command *atacmd __unused,
288 userptr_t buffer, size_t len,
289 userptr_t *data, size_t *data_len ) {
290 *data = buffer;
291 *data_len = len;
292 }
293
294 /**
295 * Use no data buffer for ATA command
296 *
297 * @v atacmd ATA command
298 * @v buffer Available buffer
299 * @v len Available buffer length
300 * @ret data Data buffer
301 * @ret data_len Data buffer length
302 */
303 static void atacmd_data_none ( struct ata_command *atacmd __unused,
304 userptr_t buffer __unused, size_t len __unused,
305 userptr_t *data __unused,
306 size_t *data_len __unused ) {
307 /* Nothing to do */
308 }
309
310 /**
311 * Use private data buffer for ATA command
312 *
313 * @v atacmd ATA command
314 * @v buffer Available buffer
315 * @v len Available buffer length
316 * @ret data Data buffer
317 * @ret data_len Data buffer length
318 */
319 static void atacmd_data_priv ( struct ata_command *atacmd,
320 userptr_t buffer __unused, size_t len __unused,
321 userptr_t *data, size_t *data_len ) {
322 *data = virt_to_user ( atacmd_priv ( atacmd ) );
323 *data_len = atacmd->type->priv_len;
324 }
325
326 /** ATA READ command type */
327 static struct ata_command_type atacmd_read = {
328 .name = "READ",
329 .cmd_lba = ATA_CMD_READ,
330 .cmd_lba48 = ATA_CMD_READ_EXT,
331 .data_in = atacmd_data_buffer,
332 .data_out = atacmd_data_none,
333 .done = atacmd_close,
334 };
335
336 /** ATA WRITE command type */
337 static struct ata_command_type atacmd_write = {
338 .name = "WRITE",
339 .cmd_lba = ATA_CMD_WRITE,
340 .cmd_lba48 = ATA_CMD_WRITE_EXT,
341 .data_in = atacmd_data_none,
342 .data_out = atacmd_data_buffer,
343 .done = atacmd_close,
344 };
345
346 /** ATA IDENTIFY private data */
347 struct ata_identify_private {
348 /** Identity data */
349 struct ata_identity identity;
350 };
351
352 /**
353 * Return ATA model string (for debugging)
354 *
355 * @v identify ATA identity data
356 * @ret model Model string
357 */
358 static const char * ata_model ( struct ata_identity *identity ) {
359 static union {
360 uint16_t words[ sizeof ( identity->model ) / 2 ];
361 char text[ sizeof ( identity->model ) + 1 /* NUL */ ];
362 } buf;
363 unsigned int i;
364
365 for ( i = 0 ; i < ( sizeof ( identity->model ) / 2 ) ; i++ )
366 buf.words[i] = bswap_16 ( identity->model[i] );
367
368 return buf.text;
369 }
370
371 /**
372 * Handle ATA IDENTIFY command completion
373 *
374 * @v atacmd ATA command
375 * @v rc Reason for completion
376 */
377 static void atacmd_identify_done ( struct ata_command *atacmd, int rc ) {
378 struct ata_device *atadev = atacmd->atadev;
379 struct ata_identify_private *priv = atacmd_priv ( atacmd );
380 struct ata_identity *identity = &priv->identity;
381 struct block_device_capacity capacity;
382
383 /* Close if command failed */
384 if ( rc != 0 ) {
385 atacmd_close ( atacmd, rc );
386 return;
387 }
388
389 /* Extract capacity */
390 if ( identity->supports_lba48 & cpu_to_le16 ( ATA_SUPPORTS_LBA48 ) ) {
391 atadev->lba48 = 1;
392 capacity.blocks = le64_to_cpu ( identity->lba48_sectors );
393 } else {
394 capacity.blocks = le32_to_cpu ( identity->lba_sectors );
395 }
396 capacity.blksize = ATA_SECTOR_SIZE;
397 capacity.max_count = atadev->max_count;
398 DBGC ( atadev, "ATA %p is a %s\n", atadev, ata_model ( identity ) );
399 DBGC ( atadev, "ATA %p has %#llx blocks (%ld MB) and uses %s\n",
400 atadev, capacity.blocks,
401 ( ( signed long ) ( capacity.blocks >> 11 ) ),
402 ( atadev->lba48 ? "LBA48" : "LBA" ) );
403
404 /* Return capacity to caller */
405 block_capacity ( &atacmd->block, &capacity );
406
407 /* Close command */
408 atacmd_close ( atacmd, 0 );
409 }
410
411 /** ATA IDENTITY command type */
412 static struct ata_command_type atacmd_identify = {
413 .name = "IDENTIFY",
414 .priv_len = sizeof ( struct ata_identify_private ),
415 .cmd_lba = ATA_CMD_IDENTIFY,
416 .cmd_lba48 = ATA_CMD_IDENTIFY,
417 .data_in = atacmd_data_priv,
418 .data_out = atacmd_data_none,
419 .done = atacmd_identify_done,
420 };
421
422 /** ATA command block interface operations */
423 static struct interface_operation atacmd_block_op[] = {
424 INTF_OP ( intf_close, struct ata_command *, atacmd_close ),
425 };
426
427 /** ATA command block interface descriptor */
428 static struct interface_descriptor atacmd_block_desc =
429 INTF_DESC_PASSTHRU ( struct ata_command, block,
430 atacmd_block_op, ata );
431
432 /** ATA command ATA interface operations */
433 static struct interface_operation atacmd_ata_op[] = {
434 INTF_OP ( intf_close, struct ata_command *, atacmd_done ),
435 };
436
437 /** ATA command ATA interface descriptor */
438 static struct interface_descriptor atacmd_ata_desc =
439 INTF_DESC_PASSTHRU ( struct ata_command, ata,
440 atacmd_ata_op, block );
441
442 /**
443 * Create ATA command
444 *
445 * @v atadev ATA device
446 * @v block Block data interface
447 * @v type ATA command type
448 * @v lba Starting logical block address
449 * @v count Number of blocks to transfer
450 * @v buffer Data buffer
451 * @v len Length of data buffer
452 * @ret rc Return status code
453 */
454 static int atadev_command ( struct ata_device *atadev,
455 struct interface *block,
456 struct ata_command_type *type,
457 uint64_t lba, unsigned int count,
458 userptr_t buffer, size_t len ) {
459 struct ata_command *atacmd;
460 struct ata_cmd command;
461 int tag;
462 int rc;
463
464 /* Allocate and initialise structure */
465 atacmd = zalloc ( sizeof ( *atacmd ) + type->priv_len );
466 if ( ! atacmd ) {
467 rc = -ENOMEM;
468 goto err_zalloc;
469 }
470 ref_init ( &atacmd->refcnt, atacmd_free );
471 intf_init ( &atacmd->block, &atacmd_block_desc, &atacmd->refcnt );
472 intf_init ( &atacmd->ata, &atacmd_ata_desc,
473 &atacmd->refcnt );
474 atacmd->atadev = atadev_get ( atadev );
475 list_add ( &atacmd->list, &ata_commands );
476 atacmd->type = type;
477
478 /* Sanity check */
479 if ( len != ( count * ATA_SECTOR_SIZE ) ) {
480 DBGC ( atadev, "ATA %p tag %08x buffer length mismatch (count "
481 "%d len %zd)\n", atadev, atacmd->tag, count, len );
482 rc = -EINVAL;
483 goto err_len;
484 }
485
486 /* Construct command */
487 memset ( &command, 0, sizeof ( command ) );
488 command.cb.lba.native = lba;
489 command.cb.count.native = count;
490 command.cb.device = ( atadev->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
491 command.cb.lba48 = atadev->lba48;
492 if ( ! atadev->lba48 )
493 command.cb.device |= command.cb.lba.bytes.low_prev;
494 command.cb.cmd_stat =
495 ( atadev->lba48 ? type->cmd_lba48 : type->cmd_lba );
496 type->data_in ( atacmd, buffer, len,
497 &command.data_in, &command.data_in_len );
498 type->data_out ( atacmd, buffer, len,
499 &command.data_out, &command.data_out_len );
500
501 /* Issue command */
502 if ( ( tag = ata_command ( &atadev->ata, &atacmd->ata,
503 &command ) ) < 0 ) {
504 rc = tag;
505 DBGC ( atadev, "ATA %p tag %08x could not issue command: %s\n",
506 atadev, atacmd->tag, strerror ( rc ) );
507 goto err_command;
508 }
509 atacmd->tag = tag;
510
511 DBGC2 ( atadev, "ATA %p tag %08x %s cmd %02x dev %02x LBA%s %08llx "
512 "count %04x\n", atadev, atacmd->tag, atacmd->type->name,
513 command.cb.cmd_stat, command.cb.device,
514 ( command.cb.lba48 ? "48" : "" ),
515 ( unsigned long long ) command.cb.lba.native,
516 command.cb.count.native );
517
518 /* Attach to parent interface, mortalise self, and return */
519 intf_plug_plug ( &atacmd->block, block );
520 ref_put ( &atacmd->refcnt );
521 return 0;
522
523 err_command:
524 err_len:
525 atacmd_close ( atacmd, rc );
526 ref_put ( &atacmd->refcnt );
527 err_zalloc:
528 return rc;
529 }
530
531 /**
532 * Issue ATA block read
533 *
534 * @v atadev ATA device
535 * @v block Block data interface
536 * @v lba Starting logical block address
537 * @v count Number of blocks to transfer
538 * @v buffer Data buffer
539 * @v len Length of data buffer
540 * @ret rc Return status code
541
542 */
543 static int atadev_read ( struct ata_device *atadev,
544 struct interface *block,
545 uint64_t lba, unsigned int count,
546 userptr_t buffer, size_t len ) {
547 return atadev_command ( atadev, block, &atacmd_read,
548 lba, count, buffer, len );
549 }
550
551 /**
552 * Issue ATA block write
553 *
554 * @v atadev ATA device
555 * @v block Block data interface
556 * @v lba Starting logical block address
557 * @v count Number of blocks to transfer
558 * @v buffer Data buffer
559 * @v len Length of data buffer
560 * @ret rc Return status code
561 */
562 static int atadev_write ( struct ata_device *atadev,
563 struct interface *block,
564 uint64_t lba, unsigned int count,
565 userptr_t buffer, size_t len ) {
566 return atadev_command ( atadev, block, &atacmd_write,
567 lba, count, buffer, len );
568 }
569
570 /**
571 * Read ATA device capacity
572 *
573 * @v atadev ATA device
574 * @v block Block data interface
575 * @ret rc Return status code
576 */
577 static int atadev_read_capacity ( struct ata_device *atadev,
578 struct interface *block ) {
579 struct ata_identity *identity;
580
581 assert ( atacmd_identify.priv_len == sizeof ( *identity ) );
582 assert ( atacmd_identify.priv_len == ATA_SECTOR_SIZE );
583 return atadev_command ( atadev, block, &atacmd_identify,
584 0, 1, UNULL, ATA_SECTOR_SIZE );
585 }
586
587 /**
588 * Close ATA device
589 *
590 * @v atadev ATA device
591 * @v rc Reason for close
592 */
593 static void atadev_close ( struct ata_device *atadev, int rc ) {
594 struct ata_command *atacmd;
595 struct ata_command *tmp;
596
597 /* Shut down interfaces */
598 intf_shutdown ( &atadev->block, rc );
599 intf_shutdown ( &atadev->ata, rc );
600
601 /* Shut down any remaining commands */
602 list_for_each_entry_safe ( atacmd, tmp, &ata_commands, list ) {
603 if ( atacmd->atadev != atadev )
604 continue;
605 atacmd_get ( atacmd );
606 atacmd_close ( atacmd, rc );
607 atacmd_put ( atacmd );
608 }
609 }
610
611 /**
612 * Describe ATA device using EDD
613 *
614 * @v atadev ATA device
615 * @v type EDD interface type
616 * @v path EDD device path
617 * @ret rc Return status code
618 */
619 static int atadev_edd_describe ( struct ata_device *atadev,
620 struct edd_interface_type *type,
621 union edd_device_path *path ) {
622
623 type->type = cpu_to_le64 ( EDD_INTF_TYPE_ATA );
624 path->ata.slave = ( ( atadev->device == ATA_DEV_SLAVE ) ? 0x01 : 0x00 );
625 return 0;
626 }
627
628 /** ATA device block interface operations */
629 static struct interface_operation atadev_block_op[] = {
630 INTF_OP ( block_read, struct ata_device *, atadev_read ),
631 INTF_OP ( block_write, struct ata_device *, atadev_write ),
632 INTF_OP ( block_read_capacity, struct ata_device *,
633 atadev_read_capacity ),
634 INTF_OP ( intf_close, struct ata_device *, atadev_close ),
635 INTF_OP ( edd_describe, struct ata_device *, atadev_edd_describe ),
636 };
637
638 /** ATA device block interface descriptor */
639 static struct interface_descriptor atadev_block_desc =
640 INTF_DESC_PASSTHRU ( struct ata_device, block,
641 atadev_block_op, ata );
642
643 /** ATA device ATA interface operations */
644 static struct interface_operation atadev_ata_op[] = {
645 INTF_OP ( intf_close, struct ata_device *, atadev_close ),
646 };
647
648 /** ATA device ATA interface descriptor */
649 static struct interface_descriptor atadev_ata_desc =
650 INTF_DESC_PASSTHRU ( struct ata_device, ata,
651 atadev_ata_op, block );
652
653 /**
654 * Open ATA device
655 *
656 * @v block Block control interface
657 * @v ata ATA control interface
658 * @v device ATA device number
659 * @v max_count Maximum number of blocks per single transfer
660 * @ret rc Return status code
661 */
662 int ata_open ( struct interface *block, struct interface *ata,
663 unsigned int device, unsigned int max_count ) {
664 struct ata_device *atadev;
665
666 /* Allocate and initialise structure */
667 atadev = zalloc ( sizeof ( *atadev ) );
668 if ( ! atadev )
669 return -ENOMEM;
670 ref_init ( &atadev->refcnt, NULL );
671 intf_init ( &atadev->block, &atadev_block_desc, &atadev->refcnt );
672 intf_init ( &atadev->ata, &atadev_ata_desc, &atadev->refcnt );
673 atadev->device = device;
674 atadev->max_count = max_count;
675
676 /* Attach to ATA and parent and interfaces, mortalise self,
677 * and return
678 */
679 intf_plug_plug ( &atadev->ata, ata );
680 intf_plug_plug ( &atadev->block, block );
681 ref_put ( &atadev->refcnt );
682 return 0;
683 }