Return to blockcmd.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src

Annotation of qemu/roms/seabios/src/blockcmd.c, revision 1.1.1.1

1.1       root        1: // Support for several common scsi like command data block requests
                      2: //
                      3: // Copyright (C) 2010  Kevin O'Connor <[email protected]>
                      4: // Copyright (C) 2002  MandrakeSoft S.A.
                      5: //
                      6: // This file may be distributed under the terms of the GNU LGPLv3 license.
                      7: 
                      8: #include "biosvar.h" // GET_GLOBAL
                      9: #include "util.h" // htonl
                     10: #include "disk.h" // struct disk_op_s
                     11: #include "blockcmd.h" // struct cdb_request_sense
                     12: #include "ata.h" // atapi_cmd_data
                     13: #include "usb-msc.h" // usb_cmd_data
                     14: 
                     15: // Route command to low-level handler.
                     16: static int
                     17: cdb_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize)
                     18: {
                     19:     u8 type = GET_GLOBAL(op->drive_g->type);
                     20:     switch (type) {
                     21:     case DTYPE_ATAPI:
                     22:         return atapi_cmd_data(op, cdbcmd, blocksize);
                     23:     case DTYPE_USB:
                     24:         return usb_cmd_data(op, cdbcmd, blocksize);
                     25:     default:
                     26:         op->count = 0;
                     27:         return DISK_RET_EPARAM;
                     28:     }
                     29: }
                     30: 
                     31: int
                     32: cdb_get_inquiry(struct disk_op_s *op, struct cdbres_inquiry *data)
                     33: {
                     34:     struct cdb_request_sense cmd;
                     35:     memset(&cmd, 0, sizeof(cmd));
                     36:     cmd.command = CDB_CMD_INQUIRY;
                     37:     cmd.length = sizeof(*data);
                     38:     op->count = 1;
                     39:     op->buf_fl = data;
                     40:     return cdb_cmd_data(op, &cmd, sizeof(*data));
                     41: }
                     42: 
                     43: // Request SENSE
                     44: int
                     45: cdb_get_sense(struct disk_op_s *op, struct cdbres_request_sense *data)
                     46: {
                     47:     struct cdb_request_sense cmd;
                     48:     memset(&cmd, 0, sizeof(cmd));
                     49:     cmd.command = CDB_CMD_REQUEST_SENSE;
                     50:     cmd.length = sizeof(*data);
                     51:     op->count = 1;
                     52:     op->buf_fl = data;
                     53:     return cdb_cmd_data(op, &cmd, sizeof(*data));
                     54: }
                     55: 
                     56: // Request capacity
                     57: int
                     58: cdb_read_capacity(struct disk_op_s *op, struct cdbres_read_capacity *data)
                     59: {
                     60:     struct cdb_read_capacity cmd;
                     61:     memset(&cmd, 0, sizeof(cmd));
                     62:     cmd.command = CDB_CMD_READ_CAPACITY;
                     63:     op->count = 1;
                     64:     op->buf_fl = data;
                     65:     return cdb_cmd_data(op, &cmd, sizeof(*data));
                     66: }
                     67: 
                     68: // Read sectors.
                     69: int
                     70: cdb_read(struct disk_op_s *op)
                     71: {
                     72:     struct cdb_rwdata_10 cmd;
                     73:     memset(&cmd, 0, sizeof(cmd));
                     74:     cmd.command = CDB_CMD_READ_10;
                     75:     cmd.lba = htonl(op->lba);
                     76:     cmd.count = htons(op->count);
                     77:     return cdb_cmd_data(op, &cmd, GET_GLOBAL(op->drive_g->blksize));
                     78: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.