Lines Matching defs:lu
433 static int sbp2util_access_timeout(struct sbp2_lu *lu, int timeout)
438 sbp2_access_wq, lu->access_complete, timeout);
439 lu->access_complete = 0;
471 static void sbp2util_notify_fetch_agent(struct sbp2_lu *lu, u64 offset,
476 if (unlikely(atomic_read(&lu->state) == SBP2LU_STATE_IN_RESET))
479 if (hpsb_node_write(lu->ne, lu->command_block_agent_addr + offset,
485 if (likely(atomic_read(&lu->state) != SBP2LU_STATE_IN_RESET))
486 scsi_unblock_requests(lu->shost);
491 struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
494 data[0] = ORB_SET_NODE_ID(lu->hi->host->node_id);
495 data[1] = lu->last_orb_dma;
497 sbp2util_notify_fetch_agent(lu, SBP2_ORB_POINTER_OFFSET, data, 8);
502 struct sbp2_lu *lu = container_of(work, struct sbp2_lu, protocol_work);
504 sbp2util_notify_fetch_agent(lu, SBP2_DOORBELL_OFFSET, NULL, 4);
507 static int sbp2util_create_command_orb_pool(struct sbp2_lu *lu)
510 struct device *dmadev = lu->hi->host->device.parent;
533 list_add_tail(&cmd->list, &lu->cmd_orb_completed);
546 static void sbp2util_remove_command_orb_pool(struct sbp2_lu *lu,
553 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
554 if (!list_empty(&lu->cmd_orb_completed))
555 list_for_each_safe(lh, next, &lu->cmd_orb_completed) {
566 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
575 struct sbp2_lu *lu, dma_addr_t orb)
580 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
581 if (!list_empty(&lu->cmd_orb_inuse))
582 list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
585 &lu->cmd_orb_lock, flags);
588 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
595 * Must be called with lu->cmd_orb_lock held.
598 struct sbp2_lu *lu, void *SCpnt)
602 if (!list_empty(&lu->cmd_orb_inuse))
603 list_for_each_entry(cmd, &lu->cmd_orb_inuse, list)
610 struct sbp2_lu *lu,
618 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
619 if (!list_empty(&lu->cmd_orb_completed)) {
620 lh = lu->cmd_orb_completed.next;
625 list_add_tail(&cmd->list, &lu->cmd_orb_inuse);
628 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
634 * Must be called with lu->cmd_orb_lock held.
636 static void sbp2util_mark_command_completed(struct sbp2_lu *lu,
640 dma_unmap_sg(lu->ud->ne->host->device.parent,
644 list_move_tail(&cmd->list, &lu->cmd_orb_completed);
648 * Is lu valid? Is the 1394 node still present?
650 static inline int sbp2util_node_is_available(struct sbp2_lu *lu)
652 return lu && lu->ne && !lu->ne->in_limbo;
662 struct sbp2_lu *lu;
671 lu = sbp2_alloc_device(ud);
672 if (!lu)
675 sbp2_parse_unit_directory(lu, ud);
676 return sbp2_start_device(lu);
682 struct sbp2_lu *lu;
686 lu = dev_get_drvdata(&ud->device);
687 if (!lu)
690 if (lu->shost) {
693 if (!sbp2util_node_is_available(lu))
694 sbp2scsi_complete_all_commands(lu, DID_NO_CONNECT);
697 atomic_set(&lu->state, SBP2LU_STATE_IN_SHUTDOWN);
698 scsi_unblock_requests(lu->shost);
700 sdev = lu->sdev;
702 lu->sdev = NULL;
706 sbp2_logout_device(lu);
707 sbp2_remove_device(lu);
714 struct sbp2_lu *lu = dev_get_drvdata(&ud->device);
716 if (sbp2_reconnect_device(lu) != 0) {
722 if (!hpsb_node_entry_valid(lu->ne))
729 sbp2_logout_device(lu);
731 if (sbp2_login_device(lu) != 0) {
732 if (!hpsb_node_entry_valid(lu->ne))
741 sbp2_set_busy_timeout(lu);
742 sbp2_agent_reset(lu, 1);
743 sbp2_max_speed_and_size(lu);
747 sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
751 if (hpsb_node_entry_valid(lu->ne)) {
752 atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
753 scsi_unblock_requests(lu->shost);
762 struct sbp2_lu *lu = NULL;
765 lu = kzalloc(sizeof(*lu), GFP_KERNEL);
766 if (!lu) {
767 SBP2_ERR("failed to create lu");
771 lu->ne = ud->ne;
772 lu->ud = ud;
773 lu->speed_code = IEEE1394_SPEED_100;
774 lu->max_payload_size = sbp2_speedto_max_payload[IEEE1394_SPEED_100];
775 lu->status_fifo_addr = CSR1212_INVALID_ADDR_SPACE;
776 INIT_LIST_HEAD(&lu->cmd_orb_inuse);
777 INIT_LIST_HEAD(&lu->cmd_orb_completed);
778 INIT_LIST_HEAD(&lu->lu_list);
779 spin_lock_init(&lu->cmd_orb_lock);
780 atomic_set(&lu->state, SBP2LU_STATE_RUNNING);
781 INIT_WORK(&lu->protocol_work, NULL);
783 dev_set_drvdata(&ud->device, lu);
818 lu->hi = hi;
821 list_add_tail(&lu->lu_list, &hi->logical_units);
832 lu->status_fifo_addr = hpsb_allocate_and_register_addrspace(
836 if (lu->status_fifo_addr == CSR1212_INVALID_ADDR_SPACE) {
847 shost->hostdata[0] = (unsigned long)lu;
851 lu->shost = shost;
852 return lu;
859 sbp2_remove_device(lu);
866 struct sbp2_lu *lu;
875 list_for_each_entry(lu, &hi->logical_units, lu_list)
876 if (atomic_cmpxchg(&lu->state,
879 scsi_block_requests(lu->shost);
884 static int sbp2_start_device(struct sbp2_lu *lu)
886 struct sbp2_fwhost_info *hi = lu->hi;
889 lu->login_response = dma_alloc_coherent(hi->host->device.parent,
891 &lu->login_response_dma, GFP_KERNEL);
892 if (!lu->login_response)
895 lu->query_logins_orb = dma_alloc_coherent(hi->host->device.parent,
897 &lu->query_logins_orb_dma, GFP_KERNEL);
898 if (!lu->query_logins_orb)
901 lu->query_logins_response = dma_alloc_coherent(hi->host->device.parent,
903 &lu->query_logins_response_dma, GFP_KERNEL);
904 if (!lu->query_logins_response)
907 lu->reconnect_orb = dma_alloc_coherent(hi->host->device.parent,
909 &lu->reconnect_orb_dma, GFP_KERNEL);
910 if (!lu->reconnect_orb)
913 lu->logout_orb = dma_alloc_coherent(hi->host->device.parent,
915 &lu->logout_orb_dma, GFP_KERNEL);
916 if (!lu->logout_orb)
919 lu->login_orb = dma_alloc_coherent(hi->host->device.parent,
921 &lu->login_orb_dma, GFP_KERNEL);
922 if (!lu->login_orb)
925 if (sbp2util_create_command_orb_pool(lu))
931 sbp2_remove_device(lu);
935 if (sbp2_login_device(lu)) {
936 sbp2_remove_device(lu);
940 sbp2_set_busy_timeout(lu);
941 sbp2_agent_reset(lu, 1);
942 sbp2_max_speed_and_size(lu);
944 if (lu->workarounds & SBP2_WORKAROUND_DELAY_INQUIRY)
947 error = scsi_add_device(lu->shost, 0, lu->ud->id, 0);
950 sbp2_logout_device(lu);
951 sbp2_remove_device(lu);
958 SBP2_ERR("Could not allocate memory for lu");
959 sbp2_remove_device(lu);
963 static void sbp2_remove_device(struct sbp2_lu *lu)
968 if (!lu)
970 hi = lu->hi;
974 if (lu->shost) {
975 scsi_remove_host(lu->shost);
976 scsi_host_put(lu->shost);
979 sbp2util_remove_command_orb_pool(lu, hi->host);
982 list_del(&lu->lu_list);
985 if (lu->login_response)
988 lu->login_response,
989 lu->login_response_dma);
990 if (lu->login_orb)
993 lu->login_orb,
994 lu->login_orb_dma);
995 if (lu->reconnect_orb)
998 lu->reconnect_orb,
999 lu->reconnect_orb_dma);
1000 if (lu->logout_orb)
1003 lu->logout_orb,
1004 lu->logout_orb_dma);
1005 if (lu->query_logins_orb)
1008 lu->query_logins_orb,
1009 lu->query_logins_orb_dma);
1010 if (lu->query_logins_response)
1013 lu->query_logins_response,
1014 lu->query_logins_response_dma);
1016 if (lu->status_fifo_addr != CSR1212_INVALID_ADDR_SPACE)
1018 lu->status_fifo_addr);
1020 dev_set_drvdata(&lu->ud->device, NULL);
1024 kfree(lu);
1057 static int sbp2_query_logins(struct sbp2_lu *lu)
1059 struct sbp2_fwhost_info *hi = lu->hi;
1064 lu->query_logins_orb->reserved1 = 0x0;
1065 lu->query_logins_orb->reserved2 = 0x0;
1067 lu->query_logins_orb->query_response_lo = lu->query_logins_response_dma;
1068 lu->query_logins_orb->query_response_hi =
1070 lu->query_logins_orb->lun_misc =
1072 lu->query_logins_orb->lun_misc |= ORB_SET_NOTIFY(1);
1073 lu->query_logins_orb->lun_misc |= ORB_SET_LUN(lu->lun);
1075 lu->query_logins_orb->reserved_resp_length =
1079 lu->query_logins_orb->status_fifo_hi =
1080 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1081 lu->query_logins_orb->status_fifo_lo =
1082 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1084 sbp2util_cpu_to_be32_buffer(lu->query_logins_orb,
1087 memset(lu->query_logins_response, 0,
1091 data[1] = lu->query_logins_orb_dma;
1094 hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1096 if (sbp2util_access_timeout(lu, 2*HZ)) {
1101 if (lu->status_block.ORB_offset_lo != lu->query_logins_orb_dma) {
1106 if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
1111 sbp2util_cpu_to_be32_buffer(lu->query_logins_response,
1115 lu->query_logins_response->length_max_logins);
1119 lu->query_logins_response->length_max_logins);
1129 static int sbp2_login_device(struct sbp2_lu *lu)
1131 struct sbp2_fwhost_info *hi = lu->hi;
1134 if (!lu->login_orb)
1137 if (!sbp2_exclusive_login && sbp2_query_logins(lu)) {
1143 lu->login_orb->password_hi = 0;
1144 lu->login_orb->password_lo = 0;
1146 lu->login_orb->login_response_lo = lu->login_response_dma;
1147 lu->login_orb->login_response_hi = ORB_SET_NODE_ID(hi->host->node_id);
1148 lu->login_orb->lun_misc = ORB_SET_FUNCTION(SBP2_LOGIN_REQUEST);
1151 lu->login_orb->lun_misc |= ORB_SET_RECONNECT(0);
1152 lu->login_orb->lun_misc |= ORB_SET_EXCLUSIVE(sbp2_exclusive_login);
1153 lu->login_orb->lun_misc |= ORB_SET_NOTIFY(1);
1154 lu->login_orb->lun_misc |= ORB_SET_LUN(lu->lun);
1156 lu->login_orb->passwd_resp_lengths =
1159 lu->login_orb->status_fifo_hi =
1160 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1161 lu->login_orb->status_fifo_lo =
1162 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1164 sbp2util_cpu_to_be32_buffer(lu->login_orb,
1167 memset(lu->login_response, 0, sizeof(struct sbp2_login_response));
1170 data[1] = lu->login_orb_dma;
1173 hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1176 if (sbp2util_access_timeout(lu, 20*HZ)) {
1182 if (lu->status_block.ORB_offset_lo != lu->login_orb_dma) {
1187 if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
1192 sbp2util_cpu_to_be32_buffer(lu->login_response,
1194 lu->command_block_agent_addr =
1195 ((u64)lu->login_response->command_block_agent_hi) << 32;
1196 lu->command_block_agent_addr |=
1197 ((u64)lu->login_response->command_block_agent_lo);
1198 lu->command_block_agent_addr &= 0x0000ffffffffffffULL;
1204 static int sbp2_logout_device(struct sbp2_lu *lu)
1206 struct sbp2_fwhost_info *hi = lu->hi;
1210 lu->logout_orb->reserved1 = 0x0;
1211 lu->logout_orb->reserved2 = 0x0;
1212 lu->logout_orb->reserved3 = 0x0;
1213 lu->logout_orb->reserved4 = 0x0;
1215 lu->logout_orb->login_ID_misc = ORB_SET_FUNCTION(SBP2_LOGOUT_REQUEST);
1216 lu->logout_orb->login_ID_misc |=
1217 ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
1218 lu->logout_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1220 lu->logout_orb->reserved5 = 0x0;
1221 lu->logout_orb->status_fifo_hi =
1222 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1223 lu->logout_orb->status_fifo_lo =
1224 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1226 sbp2util_cpu_to_be32_buffer(lu->logout_orb,
1230 data[1] = lu->logout_orb_dma;
1233 error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1238 if (sbp2util_access_timeout(lu, HZ))
1245 static int sbp2_reconnect_device(struct sbp2_lu *lu)
1247 struct sbp2_fwhost_info *hi = lu->hi;
1251 lu->reconnect_orb->reserved1 = 0x0;
1252 lu->reconnect_orb->reserved2 = 0x0;
1253 lu->reconnect_orb->reserved3 = 0x0;
1254 lu->reconnect_orb->reserved4 = 0x0;
1256 lu->reconnect_orb->login_ID_misc =
1258 lu->reconnect_orb->login_ID_misc |=
1259 ORB_SET_LOGIN_ID(lu->login_response->length_login_ID);
1260 lu->reconnect_orb->login_ID_misc |= ORB_SET_NOTIFY(1);
1262 lu->reconnect_orb->reserved5 = 0x0;
1263 lu->reconnect_orb->status_fifo_hi =
1264 ORB_SET_STATUS_FIFO_HI(lu->status_fifo_addr, hi->host->node_id);
1265 lu->reconnect_orb->status_fifo_lo =
1266 ORB_SET_STATUS_FIFO_LO(lu->status_fifo_addr);
1268 sbp2util_cpu_to_be32_buffer(lu->reconnect_orb,
1272 data[1] = lu->reconnect_orb_dma;
1275 error = hpsb_node_write(lu->ne, lu->management_agent_addr, data, 8);
1280 if (sbp2util_access_timeout(lu, HZ)) {
1286 if (lu->status_block.ORB_offset_lo != lu->reconnect_orb_dma) {
1291 if (STATUS_TEST_RDS(lu->status_block.ORB_offset_hi_misc)) {
1304 static int sbp2_set_busy_timeout(struct sbp2_lu *lu)
1309 if (hpsb_node_write(lu->ne, SBP2_BUSY_TIMEOUT_ADDRESS, &data, 4))
1314 static void sbp2_parse_unit_directory(struct sbp2_lu *lu,
1338 lu->lun = ORB_SET_LUN(kv->value.immediate);
1392 sbp2_parse_unit_directory(lu, parent_ud);
1394 lu->management_agent_addr = management_agent_addr;
1395 lu->workarounds = workarounds;
1397 lu->lun = ORB_SET_LUN(ud->lun);
1412 static int sbp2_max_speed_and_size(struct sbp2_lu *lu)
1414 struct sbp2_fwhost_info *hi = lu->hi;
1417 lu->speed_code = hi->host->speed[NODEID_TO_NODE(lu->ne->nodeid)];
1419 if (lu->speed_code > sbp2_max_speed) {
1420 lu->speed_code = sbp2_max_speed;
1427 payload = min(sbp2_speedto_max_payload[lu->speed_code],
1430 if (lu->ne->host->low_addr_space < (1ULL << 32))
1436 NODE_BUS_ARGS(hi->host, lu->ne->nodeid),
1437 hpsb_speedto_str[lu->speed_code],
1440 lu->max_payload_size = payload;
1444 static int sbp2_agent_reset(struct sbp2_lu *lu, int wait)
1451 /* flush lu->protocol_work */
1456 addr = lu->command_block_agent_addr + SBP2_AGENT_RESET_OFFSET;
1459 retval = hpsb_node_write(lu->ne, addr, &data, 4);
1461 retval = sbp2util_node_write_no_wait(lu->ne, addr, &data, 4);
1469 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1470 lu->last_orb = NULL;
1471 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1522 static int sbp2_create_command_orb(struct sbp2_lu *lu,
1526 struct device *dmadev = lu->hi->host->device.parent;
1545 orb->misc = ORB_SET_MAX_PAYLOAD(lu->max_payload_size);
1546 orb->misc |= ORB_SET_SPEED(lu->speed_code);
1567 ret = sbp2_prep_command_orb_sg(orb, lu->hi, cmd,
1582 static void sbp2_link_orb_command(struct sbp2_lu *lu,
1585 struct sbp2_fwhost_info *hi = lu->hi;
1588 u64 addr = lu->command_block_agent_addr;
1594 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1595 last_orb = lu->last_orb;
1596 last_orb_dma = lu->last_orb_dma;
1630 lu->last_orb = &cmd->command_orb;
1631 lu->last_orb_dma = cmd->command_orb_dma;
1632 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1634 if (sbp2util_node_write_no_wait(lu->ne, addr, data, length)) {
1643 scsi_block_requests(lu->shost);
1644 PREPARE_WORK(&lu->protocol_work,
1647 schedule_work(&lu->protocol_work);
1651 static int sbp2_send_command(struct sbp2_lu *lu, struct scsi_cmnd *SCpnt,
1656 cmd = sbp2util_allocate_command_orb(lu, SCpnt, done);
1660 if (sbp2_create_command_orb(lu, cmd, SCpnt))
1663 sbp2_link_orb_command(lu, cmd);
1699 struct sbp2_lu *lu = NULL, *lu_tmp;
1725 lu = lu_tmp;
1731 if (unlikely(!lu)) {
1732 SBP2_ERR("lu is NULL - device is gone?");
1736 /* Put response into lu status fifo buffer. The first two bytes
1740 sb = &lu->status_block;
1749 cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo);
1753 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1754 sbp2util_mark_command_completed(lu, cmd);
1755 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1775 sbp2_agent_reset(lu, 0);
1784 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1785 if (list_empty(&lu->cmd_orb_inuse))
1786 lu->last_orb = NULL;
1787 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1791 if ((sb->ORB_offset_lo == lu->reconnect_orb_dma) ||
1792 (sb->ORB_offset_lo == lu->login_orb_dma) ||
1793 (sb->ORB_offset_lo == lu->query_logins_orb_dma) ||
1794 (sb->ORB_offset_lo == lu->logout_orb_dma)) {
1795 lu->access_complete = 1;
1801 sbp2scsi_complete_command(lu, scsi_status, SCpnt,
1813 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
1817 if (unlikely(!sbp2util_node_is_available(lu)))
1820 hi = lu->hi;
1833 if (unlikely(!hpsb_node_entry_valid(lu->ne))) {
1847 if (sbp2_send_command(lu, SCpnt, done)) {
1849 sbp2scsi_complete_command(lu,
1861 static void sbp2scsi_complete_all_commands(struct sbp2_lu *lu, u32 status)
1867 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
1868 while (!list_empty(&lu->cmd_orb_inuse)) {
1869 lh = lu->cmd_orb_inuse.next;
1871 sbp2util_mark_command_completed(lu, cmd);
1877 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
1885 static void sbp2scsi_complete_command(struct sbp2_lu *lu, u32 scsi_status,
1929 if (!hpsb_node_entry_valid(lu->ne)
1941 struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
1943 if (sdev->lun != 0 || sdev->id != lu->ud->id || sdev->channel != 0)
1946 lu->sdev = sdev;
1952 if (lu->workarounds & SBP2_WORKAROUND_INQUIRY_36)
1959 struct sbp2_lu *lu = (struct sbp2_lu *)sdev->host->hostdata[0];
1968 lu->workarounds & SBP2_WORKAROUND_MODE_SENSE_8)
1970 if (lu->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
1972 if (lu->workarounds & SBP2_WORKAROUND_POWER_CONDITION)
1974 if (lu->workarounds & SBP2_WORKAROUND_128K_MAX_TRANS)
1993 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
2000 if (sbp2util_node_is_available(lu)) {
2001 sbp2_agent_reset(lu, 1);
2004 spin_lock_irqsave(&lu->cmd_orb_lock, flags);
2005 cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt);
2007 sbp2util_mark_command_completed(lu, cmd);
2013 spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
2015 sbp2scsi_complete_all_commands(lu, DID_BUS_BUSY);
2026 struct sbp2_lu *lu = (struct sbp2_lu *)SCpnt->device->host->hostdata[0];
2030 if (sbp2util_node_is_available(lu)) {
2032 sbp2_agent_reset(lu, 1);
2043 struct sbp2_lu *lu;
2048 if (!(lu = (struct sbp2_lu *)sdev->host->hostdata[0]))
2053 (unsigned long long)lu->ne->guid,
2054 lu->ud->directory_id, ORB_SET_LUN(lu->lun));
2057 (unsigned long long)lu->ne->guid,
2058 lu->ud->id, ORB_SET_LUN(lu->lun));