Merge remote-tracking branch 'remotes/cody/tags/block-pull-request' into staging
[qemu.git] / pc-bios / s390-ccw / virtio-scsi.c
1 /*
2 * Virtio-SCSI implementation for s390 machine loader for qemu
3 *
4 * Copyright 2015 IBM Corp.
5 * Author: Eugene "jno" Dvurechenski <jno@linux.vnet.ibm.com>
6 *
7 * This work is licensed under the terms of the GNU GPL, version 2 or (at
8 * your option) any later version. See the COPYING file in the top-level
9 * directory.
10 */
11
12 #include "s390-ccw.h"
13 #include "virtio.h"
14 #include "scsi.h"
15 #include "virtio-scsi.h"
16
17 static ScsiDevice default_scsi_device;
18 static VirtioScsiCmdReq req;
19 static VirtioScsiCmdResp resp;
20
21 static uint8_t scsi_inquiry_std_response[256];
22
23 static inline void vs_assert(bool term, const char **msgs)
24 {
25 if (!term) {
26 int i = 0;
27
28 sclp_print("\n! ");
29 while (msgs[i]) {
30 sclp_print(msgs[i++]);
31 }
32 panic(" !\n");
33 }
34 }
35
36 static void virtio_scsi_verify_response(VirtioScsiCmdResp *resp,
37 const char *title)
38 {
39 const char *mr[] = {
40 title, ": response ", virtio_scsi_response_msg(resp), 0
41 };
42 const char *ms[] = {
43 title,
44 CDB_STATUS_VALID(resp->status) ? ": " : ": invalid ",
45 scsi_cdb_status_msg(resp->status),
46 resp->status == CDB_STATUS_CHECK_CONDITION ? " " : 0,
47 resp->sense_len ? scsi_cdb_asc_msg(resp->sense)
48 : "no sense data",
49 scsi_sense_response(resp->sense) == 0x70 ? ", sure" : "?",
50 0
51 };
52
53 vs_assert(resp->response == VIRTIO_SCSI_S_OK, mr);
54 vs_assert(resp->status == CDB_STATUS_GOOD, ms);
55 }
56
57 static void prepare_request(VDev *vdev, const void *cdb, int cdb_size,
58 void *data, uint32_t data_size)
59 {
60 const ScsiDevice *sdev = vdev->scsi_device;
61
62 memset(&req, 0, sizeof(req));
63 req.lun = make_lun(sdev->channel, sdev->target, sdev->lun);
64 memcpy(&req.cdb, cdb, cdb_size);
65
66 memset(&resp, 0, sizeof(resp));
67 resp.status = 0xff; /* set invalid */
68 resp.response = 0xff; /* */
69
70 if (data && data_size) {
71 memset(data, 0, data_size);
72 }
73 }
74
75 static inline void vs_io_assert(bool term, const char *msg)
76 {
77 if (!term) {
78 virtio_scsi_verify_response(&resp, msg);
79 }
80 }
81
82 static void vs_run(const char *title, VirtioCmd *cmd, VDev *vdev,
83 const void *cdb, int cdb_size,
84 void *data, uint32_t data_size)
85 {
86 prepare_request(vdev, cdb, cdb_size, data, data_size);
87 vs_io_assert(virtio_run(vdev, VR_REQUEST, cmd) == 0, title);
88 }
89
90 /* SCSI protocol implementation routines */
91
92 static bool scsi_inquiry(VDev *vdev, void *data, uint32_t data_size)
93 {
94 ScsiCdbInquiry cdb = {
95 .command = 0x12,
96 .alloc_len = data_size < 65535 ? data_size : 65535,
97 };
98 VirtioCmd inquiry[] = {
99 { &req, sizeof(req), VRING_DESC_F_NEXT },
100 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
101 { data, data_size, VRING_DESC_F_WRITE },
102 };
103
104 vs_run("inquiry", inquiry, vdev, &cdb, sizeof(cdb), data, data_size);
105
106 return virtio_scsi_response_ok(&resp);
107 }
108
109 static bool scsi_test_unit_ready(VDev *vdev)
110 {
111 ScsiCdbTestUnitReady cdb = {
112 .command = 0x00,
113 };
114 VirtioCmd test_unit_ready[] = {
115 { &req, sizeof(req), VRING_DESC_F_NEXT },
116 { &resp, sizeof(resp), VRING_DESC_F_WRITE },
117 };
118
119 prepare_request(vdev, &cdb, sizeof(cdb), 0, 0);
120 virtio_run(vdev, VR_REQUEST, test_unit_ready); /* ignore errors here */
121
122 return virtio_scsi_response_ok(&resp);
123 }
124
125 static bool scsi_report_luns(VDev *vdev, void *data, uint32_t data_size)
126 {
127 ScsiCdbReportLuns cdb = {
128 .command = 0xa0,
129 .select_report = 0x02, /* REPORT ALL */
130 .alloc_len = data_size,
131 };
132 VirtioCmd report_luns[] = {
133 { &req, sizeof(req), VRING_DESC_F_NEXT },
134 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
135 { data, data_size, VRING_DESC_F_WRITE },
136 };
137
138 vs_run("report luns", report_luns,
139 vdev, &cdb, sizeof(cdb), data, data_size);
140
141 return virtio_scsi_response_ok(&resp);
142 }
143
144 static bool scsi_read_10(VDev *vdev,
145 ulong sector, int sectors, void *data)
146 {
147 int f = vdev->blk_factor;
148 unsigned int data_size = sectors * virtio_get_block_size() * f;
149 ScsiCdbRead10 cdb = {
150 .command = 0x28,
151 .lba = sector * f,
152 .xfer_length = sectors * f,
153 };
154 VirtioCmd read_10[] = {
155 { &req, sizeof(req), VRING_DESC_F_NEXT },
156 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
157 { data, data_size * f, VRING_DESC_F_WRITE },
158 };
159
160 debug_print_int("read_10 sector", sector);
161 debug_print_int("read_10 sectors", sectors);
162
163 vs_run("read(10)", read_10, vdev, &cdb, sizeof(cdb), data, data_size);
164
165 return virtio_scsi_response_ok(&resp);
166 }
167
168 static bool scsi_read_capacity(VDev *vdev,
169 void *data, uint32_t data_size)
170 {
171 ScsiCdbReadCapacity16 cdb = {
172 .command = 0x9e, /* SERVICE_ACTION_IN_16 */
173 .service_action = 0x10, /* SA_READ_CAPACITY */
174 .alloc_len = data_size,
175 };
176 VirtioCmd read_capacity_16[] = {
177 { &req, sizeof(req), VRING_DESC_F_NEXT },
178 { &resp, sizeof(resp), VRING_DESC_F_WRITE | VRING_DESC_F_NEXT },
179 { data, data_size, VRING_DESC_F_WRITE },
180 };
181
182 vs_run("read capacity", read_capacity_16,
183 vdev, &cdb, sizeof(cdb), data, data_size);
184
185 return virtio_scsi_response_ok(&resp);
186 }
187
188 /* virtio-scsi routines */
189
190 static void virtio_scsi_locate_device(VDev *vdev)
191 {
192 const uint16_t channel = 0; /* again, it's what QEMU does */
193 uint16_t target;
194 static uint8_t data[16 + 8 * 63];
195 ScsiLunReport *r = (void *) data;
196 ScsiDevice *sdev = vdev->scsi_device;
197 int i, luns;
198
199 /* QEMU has hardcoded channel #0 in many places.
200 * If this hardcoded value is ever changed, we'll need to add code for
201 * vdev->config.scsi.max_channel != 0 here.
202 */
203 debug_print_int("config.scsi.max_channel", vdev->config.scsi.max_channel);
204 debug_print_int("config.scsi.max_target ", vdev->config.scsi.max_target);
205 debug_print_int("config.scsi.max_lun ", vdev->config.scsi.max_lun);
206
207 if (vdev->scsi_device_selected) {
208 sdev->channel = vdev->selected_scsi_device.channel;
209 sdev->target = vdev->selected_scsi_device.target;
210 sdev->lun = vdev->selected_scsi_device.lun;
211
212 IPL_check(sdev->channel == 0, "non-zero channel requested");
213 IPL_check(sdev->target <= vdev->config.scsi.max_target, "target# high");
214 IPL_check(sdev->lun <= vdev->config.scsi.max_lun, "LUN# high");
215 return;
216 }
217
218 for (target = 0; target <= vdev->config.scsi.max_target; target++) {
219 sdev->channel = channel;
220 sdev->target = target; /* sdev->lun will be 0 here */
221 if (!scsi_report_luns(vdev, data, sizeof(data))) {
222 if (resp.response == VIRTIO_SCSI_S_BAD_TARGET) {
223 continue;
224 }
225 print_int("target", target);
226 virtio_scsi_verify_response(&resp, "SCSI cannot report LUNs");
227 }
228 if (r->lun_list_len == 0) {
229 print_int("no LUNs for target", target);
230 continue;
231 }
232 luns = r->lun_list_len / 8;
233 debug_print_int("LUNs reported", luns);
234 if (luns == 1) {
235 /* There is no ",lun=#" arg for -device or ",lun=0" given.
236 * Hence, the only LUN reported.
237 * Usually, it's 0.
238 */
239 sdev->lun = r->lun[0].v16[0]; /* it's returned this way */
240 debug_print_int("Have to use LUN", sdev->lun);
241 return; /* we have to use this device */
242 }
243 for (i = 0; i < luns; i++) {
244 if (r->lun[i].v64) {
245 /* Look for non-zero LUN - we have where to choose from */
246 sdev->lun = r->lun[i].v16[0];
247 debug_print_int("Will use LUN", sdev->lun);
248 return; /* we have found a device */
249 }
250 }
251 }
252 panic("\n! Cannot locate virtio-scsi device !\n");
253 }
254
255 int virtio_scsi_read_many(VDev *vdev,
256 ulong sector, void *load_addr, int sec_num)
257 {
258 if (!scsi_read_10(vdev, sector, sec_num, load_addr)) {
259 virtio_scsi_verify_response(&resp, "virtio-scsi:read_many");
260 }
261
262 return 0;
263 }
264
265 static bool virtio_scsi_inquiry_response_is_cdrom(void *data)
266 {
267 const ScsiInquiryStd *response = data;
268 const int resp_data_fmt = response->b3 & 0x0f;
269 int i;
270
271 IPL_check(resp_data_fmt == 2, "Wrong INQUIRY response format");
272 if (resp_data_fmt != 2) {
273 return false; /* cannot decode */
274 }
275
276 if ((response->peripheral_qdt & 0x1f) == SCSI_INQ_RDT_CDROM) {
277 return true;
278 }
279
280 for (i = 0; i < sizeof(response->prod_id); i++) {
281 if (response->prod_id[i] != QEMU_CDROM_SIGNATURE[i]) {
282 return false;
283 }
284 }
285 return true;
286 }
287
288 static void scsi_parse_capacity_report(void *data,
289 uint64_t *last_lba, uint32_t *lb_len)
290 {
291 ScsiReadCapacity16Data *p = data;
292
293 if (last_lba) {
294 *last_lba = p->ret_lba;
295 }
296
297 if (lb_len) {
298 *lb_len = p->lb_len;
299 }
300 }
301
302 void virtio_scsi_setup(VDev *vdev)
303 {
304 int retry_test_unit_ready = 3;
305 uint8_t data[256];
306 uint32_t data_size = sizeof(data);
307
308 vdev->scsi_device = &default_scsi_device;
309 virtio_scsi_locate_device(vdev);
310
311 /* We have to "ping" the device before it becomes readable */
312 while (!scsi_test_unit_ready(vdev)) {
313
314 if (!virtio_scsi_response_ok(&resp)) {
315 uint8_t code = resp.sense[0] & SCSI_SENSE_CODE_MASK;
316 uint8_t sense_key = resp.sense[2] & SCSI_SENSE_KEY_MASK;
317
318 IPL_assert(resp.sense_len != 0, "virtio-scsi:setup: no SENSE data");
319
320 IPL_assert(retry_test_unit_ready && code == 0x70 &&
321 sense_key == SCSI_SENSE_KEY_UNIT_ATTENTION,
322 "virtio-scsi:setup: cannot retry");
323
324 /* retry on CHECK_CONDITION/UNIT_ATTENTION as it
325 * may not designate a real error, but it may be
326 * a result of device reset, etc.
327 */
328 retry_test_unit_ready--;
329 sleep(1);
330 continue;
331 }
332
333 virtio_scsi_verify_response(&resp, "virtio-scsi:setup");
334 }
335
336 /* read and cache SCSI INQUIRY response */
337 if (!scsi_inquiry(vdev, scsi_inquiry_std_response,
338 sizeof(scsi_inquiry_std_response))) {
339 virtio_scsi_verify_response(&resp, "virtio-scsi:setup:inquiry");
340 }
341
342 if (virtio_scsi_inquiry_response_is_cdrom(scsi_inquiry_std_response)) {
343 sclp_print("SCSI CD-ROM detected.\n");
344 vdev->is_cdrom = true;
345 vdev->scsi_block_size = VIRTIO_ISO_BLOCK_SIZE;
346 }
347
348 if (!scsi_read_capacity(vdev, data, data_size)) {
349 virtio_scsi_verify_response(&resp, "virtio-scsi:setup:read_capacity");
350 }
351 scsi_parse_capacity_report(data, &vdev->scsi_last_block,
352 (uint32_t *) &vdev->scsi_block_size);
353 }