Lines Matching refs:req
53 static int read_peer_guid(u64 *guid, const struct sbp_management_request *req)
58 ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
59 req->node_addr, req->generation, req->speed,
65 ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
66 req->node_addr, req->generation, req->speed,
259 struct sbp_management_agent *agent, struct sbp_management_request *req,
272 LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)), &ret);
275 LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
277 req->status.status = cpu_to_be32(
283 ret = read_peer_guid(&guid, req);
287 req->status.status = cpu_to_be32(
325 if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
329 req->status.status = cpu_to_be32(
342 req->status.status = cpu_to_be32(
356 req->status.status = cpu_to_be32(
374 req->status.status = cpu_to_be32(
381 sess->node_id = req->node_addr;
382 sess->card = fw_card_get(req->card);
383 sess->generation = req->generation;
384 sess->speed = req->speed;
392 1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)),
401 req->status.status = cpu_to_be32(
409 login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
410 login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
421 req->status.status = cpu_to_be32(
438 req->status.status = cpu_to_be32(
445 LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)),
456 sbp2_pointer_to_addr(&req->orb.ptr2), response,
464 req->status.status = cpu_to_be32(
472 req->status.status = cpu_to_be32(
478 struct sbp_management_agent *agent, struct sbp_management_request *req,
484 req->status.status = cpu_to_be32(
490 struct sbp_management_agent *agent, struct sbp_management_request *req,
499 ret = read_peer_guid(&guid, req);
503 req->status.status = cpu_to_be32(
512 RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)));
517 req->status.status = cpu_to_be32(
526 req->status.status = cpu_to_be32(
537 login->sess->generation = req->generation;
538 login->sess->node_id = req->node_addr;
539 login->sess->card = fw_card_get(req->card);
540 login->sess->speed = req->speed;
543 req->status.status = cpu_to_be32(
549 struct sbp_management_agent *agent, struct sbp_management_request *req,
557 id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc));
563 req->status.status = cpu_to_be32(
572 if (req->node_addr != login->sess->node_id) {
575 req->status.status = cpu_to_be32(
583 req->status.status = cpu_to_be32(
856 struct sbp_target_request *req =
860 req->orb_pointer,
861 sbp2_pointer_to_addr(&req->orb.next_orb),
862 sbp2_pointer_to_addr(&req->orb.data_descriptor),
863 be32_to_cpu(req->orb.misc));
865 if (req->orb_pointer >> 32)
868 switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) {
870 sbp_handle_command(req);
874 req->status.status |= cpu_to_be32(
881 sbp_send_status(req);
884 req->status.status |= cpu_to_be32(
891 sbp_send_status(req);
914 struct sbp_target_request *req;
921 req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag];
922 memset(req, 0, sizeof(*req));
923 req->se_cmd.map_tag = tag;
924 req->se_cmd.map_cpu = cpu;
925 req->se_cmd.tag = next_orb;
927 return req;
935 struct sbp_target_request *req;
941 req = sbp_mgt_get_req(sess, sess->card, next_orb);
942 if (IS_ERR(req)) {
949 req->login = agent->login;
950 req->orb_pointer = next_orb;
952 req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH(
953 req->orb_pointer >> 32));
954 req->status.orb_low = cpu_to_be32(
955 req->orb_pointer & 0xfffffffc);
960 req->orb_pointer, &req->orb, sizeof(req->orb));
963 req->status.status |= cpu_to_be32(
976 sbp_send_status(req);
981 if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) {
983 req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
986 next_orb = sbp2_pointer_to_addr(&req->orb.next_orb);
987 req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
992 INIT_WORK(&req->work, tgt_agent_process_work);
993 queue_work(system_unbound_wq, &req->work);
996 sbp_free_request(req);
1085 static int sbp_run_request_transaction(struct sbp_target_request *req,
1089 struct sbp_login_descriptor *login = req->login;
1109 static int sbp_fetch_command(struct sbp_target_request *req)
1113 cmd_len = scsi_command_size(req->orb.command_block);
1115 req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL);
1116 if (!req->cmd_buf)
1119 memcpy(req->cmd_buf, req->orb.command_block,
1120 min_t(int, cmd_len, sizeof(req->orb.command_block)));
1122 if (cmd_len > sizeof(req->orb.command_block)) {
1124 copy_len = cmd_len - sizeof(req->orb.command_block);
1126 ret = sbp_run_request_transaction(req,
1128 req->orb_pointer + sizeof(req->orb),
1129 req->cmd_buf + sizeof(req->orb.command_block),
1138 static int sbp_fetch_page_table(struct sbp_target_request *req)
1143 if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc)))
1146 pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) *
1153 ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST,
1154 sbp2_pointer_to_addr(&req->orb.data_descriptor),
1161 req->pg_tbl = pg_tbl;
1165 static void sbp_calc_data_length_direction(struct sbp_target_request *req,
1170 data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
1171 direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc));
1181 if (req->pg_tbl) {
1185 req->pg_tbl[idx].segment_length);
1192 static void sbp_handle_command(struct sbp_target_request *req)
1194 struct sbp_login_descriptor *login = req->login;
1200 ret = sbp_fetch_command(req);
1206 ret = sbp_fetch_page_table(req);
1213 unpacked_lun = req->login->login_lun;
1214 sbp_calc_data_length_direction(req, &data_length, &data_dir);
1217 req->orb_pointer, unpacked_lun, data_length, data_dir);
1220 req->se_cmd.tag = req->orb_pointer;
1221 if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
1222 req->sense_buf, unpacked_lun, data_length,
1229 req->status.status |= cpu_to_be32(
1234 sbp_send_status(req);
1241 static int sbp_rw_data(struct sbp_target_request *req)
1243 struct sbp_session *sess = req->login->sess;
1252 if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {
1260 max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc));
1261 speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc));
1263 pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc));
1275 if (req->pg_tbl) {
1276 pte = req->pg_tbl;
1277 num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
1285 offset = sbp2_pointer_to_addr(&req->orb.data_descriptor);
1286 length = req->se_cmd.data_length;
1289 sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,
1331 static int sbp_send_status(struct sbp_target_request *req)
1334 struct sbp_login_descriptor *login = req->login;
1336 length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4;
1338 rc = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST,
1339 login->status_fifo_addr, &req->status, length);
1347 req->orb_pointer);
1354 target_put_sess_cmd(&req->se_cmd);
1358 static void sbp_sense_mangle(struct sbp_target_request *req)
1360 struct se_cmd *se_cmd = &req->se_cmd;
1361 u8 *sense = req->sense_buf;
1362 u8 *status = req->status.data;
1382 req->status.status |= cpu_to_be32(
1418 req->status.status |= cpu_to_be32(
1425 static int sbp_send_sense(struct sbp_target_request *req)
1427 struct se_cmd *se_cmd = &req->se_cmd;
1430 sbp_sense_mangle(req);
1432 req->status.status |= cpu_to_be32(
1439 return sbp_send_status(req);
1442 static void sbp_free_request(struct sbp_target_request *req)
1444 struct se_cmd *se_cmd = &req->se_cmd;
1447 kfree(req->pg_tbl);
1448 kfree(req->cmd_buf);
1457 struct sbp_management_request *req = agent->request;
1462 ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST,
1463 req->node_addr, req->generation, req->speed,
1464 agent->orb_offset, &req->orb, sizeof(req->orb));
1471 sbp2_pointer_to_addr(&req->orb.ptr1),
1472 sbp2_pointer_to_addr(&req->orb.ptr2),
1473 be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length),
1474 sbp2_pointer_to_addr(&req->orb.status_fifo));
1476 if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) ||
1477 ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) {
1482 switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) {
1484 sbp_management_request_login(agent, req, &status_data_len);
1488 sbp_management_request_query_logins(agent, req,
1493 sbp_management_request_reconnect(agent, req, &status_data_len);
1499 req->status.status = cpu_to_be32(
1506 sbp_management_request_logout(agent, req, &status_data_len);
1512 req->status.status = cpu_to_be32(
1521 req->status.status = cpu_to_be32(
1530 req->status.status = cpu_to_be32(
1539 req->status.status = cpu_to_be32(
1547 MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc)));
1549 req->status.status = cpu_to_be32(
1556 req->status.status |= cpu_to_be32(
1560 req->status.orb_low = cpu_to_be32(agent->orb_offset);
1563 ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST,
1564 req->node_addr, req->generation, req->speed,
1565 sbp2_pointer_to_addr(&req->orb.status_fifo),
1566 &req->status, 8 + status_data_len);
1573 fw_card_put(req->card);
1574 kfree(req);
1597 struct sbp_management_request *req;
1610 req = kzalloc(sizeof(*req), GFP_ATOMIC);
1611 if (!req) {
1616 req->card = fw_card_get(card);
1617 req->generation = generation;
1618 req->node_addr = source;
1619 req->speed = fw_get_request_speed(request);
1622 agent->request = req;
1705 struct sbp_target_request *req = container_of(se_cmd,
1708 sbp_free_request(req);
1718 struct sbp_target_request *req = container_of(se_cmd,
1722 ret = sbp_rw_data(req);
1724 req->status.status |= cpu_to_be32(
1731 sbp_send_status(req);
1751 struct sbp_target_request *req = container_of(se_cmd,
1755 ret = sbp_rw_data(req);
1757 req->status.status |= cpu_to_be32(
1762 sbp_send_status(req);
1766 return sbp_send_sense(req);
1775 struct sbp_target_request *req = container_of(se_cmd,
1778 return sbp_send_sense(req);
1792 struct sbp_target_request *req = container_of(se_cmd,
1795 return transport_generic_free_cmd(&req->se_cmd, 0);