1 // Support for several common scsi like command data block requests
3 // Copyright (C) 2010 Kevin O'Connor <kevin@koconnor.net>
4 // Copyright (C) 2002 MandrakeSoft S.A.
6 // This file may be distributed under the terms of the GNU LGPLv3 license.
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 "ahci.h" // atapi_cmd_data
14 #include "usb-msc.h" // usb_cmd_data
16 // Route command to low-level handler.
18 cdb_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize)
20 u8 type = GET_GLOBAL(op->drive_g->type);
23 return atapi_cmd_data(op, cdbcmd, blocksize);
25 return usb_cmd_data(op, cdbcmd, blocksize);
27 return ahci_cmd_data(op, cdbcmd, blocksize);
30 return DISK_RET_EPARAM;
35 scsi_is_ready(struct disk_op_s *op)
37 dprintf(6, "scsi_is_ready (drive=%p)\n", op->drive_g);
39 /* Retry TEST UNIT READY for 5 seconds unless MEDIUM NOT PRESENT is
40 * reported by the device. If the device reports "IN PROGRESS",
41 * 30 seconds is added. */
43 u64 end = calc_future_tsc(5000);
46 dprintf(1, "test unit ready failed\n");
50 int ret = cdb_test_unit_ready(op);
55 struct cdbres_request_sense sense;
56 ret = cdb_get_sense(op, &sense);
62 if (sense.asc == 0x3a) { /* MEDIUM NOT PRESENT */
63 dprintf(1, "Device reports MEDIUM NOT PRESENT\n");
67 if (sense.asc == 0x04 && sense.ascq == 0x01 && !in_progress) {
68 /* IN PROGRESS OF BECOMING READY */
69 printf("Waiting for device to detect medium... ");
70 /* Allow 30 seconds more */
71 end = calc_future_tsc(30000);
78 // Validate drive and find block size and sector count.
80 scsi_init_drive(struct drive_s *drive, const char *s, int *pdt, char **desc)
86 memset(&dop, 0, sizeof(dop));
88 struct cdbres_inquiry data;
89 int ret = cdb_get_inquiry(&dop, &data);
92 char vendor[sizeof(data.vendor)+1], product[sizeof(data.product)+1];
93 char rev[sizeof(data.rev)+1];
94 strtcpy(vendor, data.vendor, sizeof(vendor));
95 nullTrailingSpace(vendor);
96 strtcpy(product, data.product, sizeof(product));
97 nullTrailingSpace(product);
98 strtcpy(rev, data.rev, sizeof(rev));
99 nullTrailingSpace(rev);
100 *pdt = data.pdt & 0x1f;
101 int removable = !!(data.removable & 0x80);
102 dprintf(1, "%s vendor='%s' product='%s' rev='%s' type=%d removable=%d\n"
103 , s, vendor, product, rev, *pdt, removable);
104 drive->removable = removable;
106 if (*pdt == SCSI_TYPE_CDROM) {
107 drive->blksize = CDROM_SECTOR_SIZE;
108 drive->sectors = (u64)-1;
110 *desc = znprintf(MAXDESCSIZE, "DVD/CD [%s Drive %s %s %s]"
111 , s, vendor, product, rev);
115 ret = scsi_is_ready(&dop);
117 dprintf(1, "scsi_is_ready returned %d\n", ret);
121 struct cdbres_read_capacity capdata;
122 ret = cdb_read_capacity(&dop, &capdata);
126 // READ CAPACITY returns the address of the last block.
127 // We do not bother with READ CAPACITY(16) because BIOS does not support
128 // 64-bit LBA anyway.
129 drive->blksize = ntohl(capdata.blksize);
130 drive->sectors = (u64)ntohl(capdata.sectors) + 1;
131 dprintf(1, "%s blksize=%d sectors=%d\n"
132 , s, drive->blksize, (unsigned)drive->sectors);
134 struct cdbres_mode_sense_geom geomdata;
135 ret = cdb_mode_sense_geom(&dop, &geomdata);
138 cylinders = geomdata.cyl[0] << 16;
139 cylinders |= geomdata.cyl[1] << 8;
140 cylinders |= geomdata.cyl[2];
141 if (cylinders && geomdata.heads &&
142 drive->sectors <= 0xFFFFFFFFULL &&
143 ((u32)drive->sectors % (geomdata.heads * cylinders) == 0)) {
144 drive->pchs.cylinders = cylinders;
145 drive->pchs.heads = geomdata.heads;
146 drive->pchs.spt = (u32)drive->sectors
147 / (geomdata.heads * cylinders);
151 *desc = znprintf(MAXDESCSIZE, "%s Drive %s %s %s"
152 , s, vendor, product, rev);
157 cdb_get_inquiry(struct disk_op_s *op, struct cdbres_inquiry *data)
159 struct cdb_request_sense cmd;
160 memset(&cmd, 0, sizeof(cmd));
161 cmd.command = CDB_CMD_INQUIRY;
162 cmd.length = sizeof(*data);
165 return cdb_cmd_data(op, &cmd, sizeof(*data));
170 cdb_get_sense(struct disk_op_s *op, struct cdbres_request_sense *data)
172 struct cdb_request_sense cmd;
173 memset(&cmd, 0, sizeof(cmd));
174 cmd.command = CDB_CMD_REQUEST_SENSE;
175 cmd.length = sizeof(*data);
178 return cdb_cmd_data(op, &cmd, sizeof(*data));
183 cdb_test_unit_ready(struct disk_op_s *op)
185 struct cdb_request_sense cmd;
186 memset(&cmd, 0, sizeof(cmd));
187 cmd.command = CDB_CMD_TEST_UNIT_READY;
190 return cdb_cmd_data(op, &cmd, 0);
195 cdb_read_capacity(struct disk_op_s *op, struct cdbres_read_capacity *data)
197 struct cdb_read_capacity cmd;
198 memset(&cmd, 0, sizeof(cmd));
199 cmd.command = CDB_CMD_READ_CAPACITY;
202 return cdb_cmd_data(op, &cmd, sizeof(*data));
205 // Mode sense, geometry page.
207 cdb_mode_sense_geom(struct disk_op_s *op, struct cdbres_mode_sense_geom *data)
209 struct cdb_mode_sense cmd;
210 memset(&cmd, 0, sizeof(cmd));
211 cmd.command = CDB_CMD_MODE_SENSE;
212 cmd.flags = 8; /* DBD */
213 cmd.page = MODE_PAGE_HD_GEOMETRY;
214 cmd.count = htons(sizeof(*data));
217 return cdb_cmd_data(op, &cmd, sizeof(*data));
222 cdb_read(struct disk_op_s *op)
224 struct cdb_rwdata_10 cmd;
225 memset(&cmd, 0, sizeof(cmd));
226 cmd.command = CDB_CMD_READ_10;
227 cmd.lba = htonl(op->lba);
228 cmd.count = htons(op->count);
229 return cdb_cmd_data(op, &cmd, GET_GLOBAL(op->drive_g->blksize));
234 cdb_write(struct disk_op_s *op)
236 struct cdb_rwdata_10 cmd;
237 memset(&cmd, 0, sizeof(cmd));
238 cmd.command = CDB_CMD_WRITE_10;
239 cmd.lba = htonl(op->lba);
240 cmd.count = htons(op->count);
241 return cdb_cmd_data(op, &cmd, GET_GLOBAL(op->drive_g->blksize));