Lines Matching defs:req
37 static void ufs_exec_req(UfsRequest *req);
38 static void ufs_clear_req(UfsRequest *req);
127 static MemTxResult ufs_dma_read_utrd(UfsRequest *req)
129 UfsHc *u = req->hc;
130 hwaddr utrd_addr = ufs_get_utrd_addr(u, req->slot);
133 ret = ufs_addr_read(u, utrd_addr, &req->utrd, sizeof(req->utrd));
135 trace_ufs_err_dma_read_utrd(req->slot, utrd_addr);
140 static MemTxResult ufs_dma_read_req_upiu(UfsRequest *req)
142 UfsHc *u = req->hc;
143 hwaddr req_upiu_base_addr = ufs_get_req_upiu_base_addr(&req->utrd);
144 UtpUpiuReq *req_upiu = &req->req_upiu;
156 trace_ufs_err_dma_read_req_upiu(req->slot, req_upiu_base_addr);
164 if (copy_size > sizeof(req->req_upiu)) {
165 copy_size = sizeof(req->req_upiu);
168 ret = ufs_addr_read(u, req_upiu_base_addr, &req->req_upiu, copy_size);
170 trace_ufs_err_dma_read_req_upiu(req->slot, req_upiu_base_addr);
175 static MemTxResult ufs_dma_read_prdt(UfsRequest *req)
177 UfsHc *u = req->hc;
178 uint16_t prdt_len = le16_to_cpu(req->utrd.prd_table_length);
180 le16_to_cpu(req->utrd.prd_table_offset) * sizeof(uint32_t);
186 assert(!req->sg);
193 req_upiu_base_addr = ufs_get_req_upiu_base_addr(&req->utrd);
198 trace_ufs_err_dma_read_prdt(req->slot, prdt_base_addr);
202 req->sg = g_malloc0(sizeof(QEMUSGList));
203 pci_dma_sglist_init(req->sg, PCI_DEVICE(u), prdt_len);
204 req->data_len = 0;
209 qemu_sglist_add(req->sg, data_dma_addr, data_byte_count);
210 req->data_len += data_byte_count;
215 static MemTxResult ufs_dma_read_upiu(UfsRequest *req)
222 if (!ufs_mcq_req(req)) {
223 ret = ufs_dma_read_utrd(req);
229 ret = ufs_dma_read_req_upiu(req);
234 ret = ufs_dma_read_prdt(req);
242 static MemTxResult ufs_dma_write_utrd(UfsRequest *req)
244 UfsHc *u = req->hc;
245 hwaddr utrd_addr = ufs_get_utrd_addr(u, req->slot);
248 ret = ufs_addr_write(u, utrd_addr, &req->utrd, sizeof(req->utrd));
250 trace_ufs_err_dma_write_utrd(req->slot, utrd_addr);
255 static MemTxResult ufs_dma_write_rsp_upiu(UfsRequest *req)
257 UfsHc *u = req->hc;
258 hwaddr rsp_upiu_base_addr = ufs_get_rsp_upiu_base_addr(&req->utrd);
260 le16_to_cpu(req->utrd.response_upiu_length) * sizeof(uint32_t);
262 be16_to_cpu(req->rsp_upiu.header.data_segment_length);
272 if (copy_size > sizeof(req->rsp_upiu)) {
273 copy_size = sizeof(req->rsp_upiu);
276 ret = ufs_addr_write(u, rsp_upiu_base_addr, &req->rsp_upiu, copy_size);
278 trace_ufs_err_dma_write_rsp_upiu(req->slot, rsp_upiu_base_addr);
283 static MemTxResult ufs_dma_write_upiu(UfsRequest *req)
287 ret = ufs_dma_write_rsp_upiu(req);
292 return ufs_dma_write_utrd(req);
313 UfsRequest *req;
324 req = &u->req_list[slot];
325 if (req->state == UFS_REQUEST_ERROR) {
326 trace_ufs_err_utrl_slot_error(req->slot);
330 if (req->state != UFS_REQUEST_IDLE) {
331 trace_ufs_err_utrl_slot_busy(req->slot);
336 req->state = UFS_REQUEST_READY;
378 static void ufs_mcq_init_req(UfsHc *u, UfsRequest *req, UfsSq *sq)
380 memset(req, 0, sizeof(*req));
382 req->hc = u;
383 req->state = UFS_REQUEST_IDLE;
384 req->slot = UFS_INVALID_SLOT;
385 req->sq = sq;
393 UfsRequest *req;
409 req = QTAILQ_FIRST(&sq->req_list);
410 QTAILQ_REMOVE(&sq->req_list, req, entry);
412 ufs_mcq_init_req(sq->u, req, sq);
413 memcpy(&req->utrd, &sqe, sizeof(req->utrd));
415 req->state = UFS_REQUEST_RUNNING;
416 ufs_exec_req(req);
424 UfsRequest *req, *next;
428 QTAILQ_FOREACH_SAFE(req, &cq->req_list, entry, next)
430 ufs_dma_write_rsp_upiu(req);
432 req->cqe.utp_addr =
433 ((uint64_t)req->utrd.command_desc_base_addr_hi << 32ULL) |
434 req->utrd.command_desc_base_addr_lo;
435 req->cqe.utp_addr |= req->sq->sqid;
436 req->cqe.resp_len = req->utrd.response_upiu_length;
437 req->cqe.resp_off = req->utrd.response_upiu_offset;
438 req->cqe.prdt_len = req->utrd.prd_table_length;
439 req->cqe.prdt_off = req->utrd.prd_table_offset;
440 req->cqe.status = req->utrd.header.dword_2 & 0xf;
441 req->cqe.error = 0;
443 ret = ufs_addr_write(u, cq->addr + tail, &req->cqe, sizeof(req->cqe));
447 QTAILQ_REMOVE(&cq->req_list, req, entry);
449 tail = (tail + sizeof(req->cqe)) % (cq->size * sizeof(req->cqe));
452 ufs_clear_req(req);
453 QTAILQ_INSERT_TAIL(&req->sq->req_list, req, entry);
495 sq->req = g_new0(UfsRequest, sq->size);
498 ufs_mcq_init_req(u, &sq->req[i], sq);
499 QTAILQ_INSERT_TAIL(&sq->req_list, &sq->req[i], entry);
525 g_free(sq->req);
829 void ufs_build_upiu_header(UfsRequest *req, uint8_t trans_type, uint8_t flags,
833 memcpy(&req->rsp_upiu.header, &req->req_upiu.header, sizeof(UtpUpiuHeader));
834 req->rsp_upiu.header.trans_type = trans_type;
835 req->rsp_upiu.header.flags = flags;
836 req->rsp_upiu.header.response = response;
837 req->rsp_upiu.header.scsi_status = scsi_status;
838 req->rsp_upiu.header.data_segment_length = cpu_to_be16(data_segment_length);
841 static UfsReqResult ufs_exec_scsi_cmd(UfsRequest *req)
843 UfsHc *u = req->hc;
844 uint8_t lun = req->req_upiu.header.lun;
848 trace_ufs_exec_scsi_cmd(req->slot, lun, req->req_upiu.sc.cdb[0]);
872 return lu->scsi_op(lu, req);
875 static UfsReqResult ufs_exec_nop_cmd(UfsRequest *req)
877 trace_ufs_exec_nop_cmd(req->slot);
878 ufs_build_upiu_header(req, UFS_UPIU_TRANSACTION_NOP_IN, 0, 0, 0, 0);
991 static QueryRespCode ufs_exec_query_flag(UfsRequest *req, int op)
993 UfsHc *u = req->hc;
994 uint8_t idn = req->req_upiu.qr.idn;
1020 req->rsp_upiu.qr.value = cpu_to_be32(value);
1126 static QueryRespCode ufs_exec_query_attr(UfsRequest *req, int op)
1128 UfsHc *u = req->hc;
1129 uint8_t idn = req->req_upiu.qr.idn;
1141 value = be32_to_cpu(req->req_upiu.qr.value);
1145 req->rsp_upiu.qr.value = cpu_to_be32(value);
1156 static QueryRespCode ufs_read_unit_desc(UfsRequest *req)
1158 UfsHc *u = req->hc;
1159 uint8_t lun = req->req_upiu.qr.index;
1163 trace_ufs_err_query_invalid_index(req->req_upiu.qr.opcode, lun);
1168 memcpy(&req->rsp_upiu.qr.data, &rpmb_unit_desc, rpmb_unit_desc.length);
1170 memcpy(&req->rsp_upiu.qr.data, &u->lus[lun]->unit_desc,
1227 static QueryRespCode ufs_read_string_desc(UfsRequest *req)
1229 UfsHc *u = req->hc;
1230 uint8_t index = req->req_upiu.qr.index;
1235 memcpy(&req->rsp_upiu.qr.data, &desc, desc.length);
1238 memcpy(&req->rsp_upiu.qr.data, &desc, desc.length);
1240 memcpy(&req->rsp_upiu.qr.data, &null_str_desc, null_str_desc.length);
1242 memcpy(&req->rsp_upiu.qr.data, &null_str_desc, null_str_desc.length);
1245 memcpy(&req->rsp_upiu.qr.data, &desc, desc.length);
1247 trace_ufs_err_query_invalid_index(req->req_upiu.qr.opcode, index);
1264 static QueryRespCode ufs_read_desc(UfsRequest *req)
1266 UfsHc *u = req->hc;
1268 uint8_t idn = req->req_upiu.qr.idn;
1269 uint16_t length = be16_to_cpu(req->req_upiu.qr.length);
1274 memcpy(&req->rsp_upiu.qr.data, &u->device_desc, sizeof(u->device_desc));
1278 status = ufs_read_unit_desc(req);
1281 memcpy(&req->rsp_upiu.qr.data, &u->geometry_desc,
1287 memcpy(&req->rsp_upiu.qr.data, &desc, sizeof(InterconnectDescriptor));
1292 status = ufs_read_string_desc(req);
1296 memset(&req->rsp_upiu.qr.data, 0, sizeof(PowerParametersDescriptor));
1297 req->rsp_upiu.qr.data[0] = sizeof(PowerParametersDescriptor);
1298 req->rsp_upiu.qr.data[1] = UFS_QUERY_DESC_IDN_POWER;
1303 memset(&req->rsp_upiu.qr.data, 0, sizeof(DeviceHealthDescriptor));
1304 req->rsp_upiu.qr.data[0] = sizeof(DeviceHealthDescriptor);
1305 req->rsp_upiu.qr.data[1] = UFS_QUERY_DESC_IDN_HEALTH;
1310 trace_ufs_err_query_invalid_idn(req->req_upiu.qr.opcode, idn);
1314 if (length > req->rsp_upiu.qr.data[0]) {
1315 length = req->rsp_upiu.qr.data[0];
1317 req->rsp_upiu.qr.opcode = req->req_upiu.qr.opcode;
1318 req->rsp_upiu.qr.idn = req->req_upiu.qr.idn;
1319 req->rsp_upiu.qr.index = req->req_upiu.qr.index;
1320 req->rsp_upiu.qr.selector = req->req_upiu.qr.selector;
1321 req->rsp_upiu.qr.length = cpu_to_be16(length);
1326 static QueryRespCode ufs_exec_query_read(UfsRequest *req)
1329 switch (req->req_upiu.qr.opcode) {
1334 status = ufs_read_desc(req);
1337 status = ufs_exec_query_attr(req, UFS_QUERY_ATTR_READ);
1340 status = ufs_exec_query_flag(req, UFS_QUERY_FLAG_READ);
1343 trace_ufs_err_query_invalid_opcode(req->req_upiu.qr.opcode);
1351 static QueryRespCode ufs_exec_query_write(UfsRequest *req)
1354 switch (req->req_upiu.qr.opcode) {
1363 status = ufs_exec_query_attr(req, UFS_QUERY_ATTR_WRITE);
1366 status = ufs_exec_query_flag(req, UFS_QUERY_FLAG_SET);
1369 status = ufs_exec_query_flag(req, UFS_QUERY_FLAG_CLEAR);
1372 status = ufs_exec_query_flag(req, UFS_QUERY_FLAG_TOGGLE);
1375 trace_ufs_err_query_invalid_opcode(req->req_upiu.qr.opcode);
1383 static UfsReqResult ufs_exec_query_cmd(UfsRequest *req)
1385 uint8_t query_func = req->req_upiu.header.query_func;
1389 trace_ufs_exec_query_cmd(req->slot, req->req_upiu.qr.opcode);
1391 status = ufs_exec_query_read(req);
1393 status = ufs_exec_query_write(req);
1398 data_segment_length = be16_to_cpu(req->rsp_upiu.qr.length);
1399 ufs_build_upiu_header(req, UFS_UPIU_TRANSACTION_QUERY_RSP, 0, status, 0,
1408 static void ufs_exec_req(UfsRequest *req)
1412 if (ufs_dma_read_upiu(req)) {
1416 switch (req->req_upiu.header.trans_type) {
1418 req_result = ufs_exec_nop_cmd(req);
1421 req_result = ufs_exec_scsi_cmd(req);
1424 req_result = ufs_exec_query_cmd(req);
1427 trace_ufs_err_invalid_trans_code(req->slot,
1428 req->req_upiu.header.trans_type);
1438 ufs_complete_req(req, req_result);
1445 UfsRequest *req;
1449 req = &u->req_list[slot];
1451 if (req->state != UFS_REQUEST_READY) {
1455 req->state = UFS_REQUEST_RUNNING;
1457 ufs_exec_req(req);
1461 void ufs_complete_req(UfsRequest *req, UfsReqResult req_result)
1463 UfsHc *u = req->hc;
1464 assert(req->state == UFS_REQUEST_RUNNING);
1467 req->utrd.header.dword_2 = cpu_to_le32(UFS_OCS_SUCCESS);
1469 req->utrd.header.dword_2 = cpu_to_le32(UFS_OCS_INVALID_CMD_TABLE_ATTR);
1472 req->state = UFS_REQUEST_COMPLETE;
1474 if (ufs_mcq_req(req)) {
1475 trace_ufs_mcq_complete_req(req->sq->sqid);
1476 QTAILQ_INSERT_TAIL(&req->sq->cq->req_list, req, entry);
1477 qemu_bh_schedule(req->sq->cq->bh);
1479 trace_ufs_complete_req(req->slot);
1484 static void ufs_clear_req(UfsRequest *req)
1486 if (req->sg != NULL) {
1487 qemu_sglist_destroy(req->sg);
1488 g_free(req->sg);
1489 req->sg = NULL;
1490 req->data_len = 0;
1493 memset(&req->utrd, 0, sizeof(req->utrd));
1494 memset(&req->req_upiu, 0, sizeof(req->req_upiu));
1495 memset(&req->rsp_upiu, 0, sizeof(req->rsp_upiu));
1501 UfsRequest *req;
1505 req = &u->req_list[slot];
1507 if (req->state != UFS_REQUEST_COMPLETE) {
1511 if (ufs_dma_write_upiu(req)) {
1512 req->state = UFS_REQUEST_ERROR;
1520 if (le32_to_cpu(req->utrd.header.dword_2) != UFS_OCS_SUCCESS ||
1521 le32_to_cpu(req->utrd.header.dword_0) & UFS_UTP_REQ_DESC_INT_CMD) {
1528 trace_ufs_sendback_req(req->slot);
1530 ufs_clear_req(req);
1531 req->state = UFS_REQUEST_IDLE;