PageRenderTime 79ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/scsi/ibmvscsi/ibmvfc.c

https://bitbucket.org/wisechild/galaxy-nexus
C | 4976 lines | 3450 code | 564 blank | 962 comment | 501 complexity | ad5922a1a8e04238825d56a83cc050d6 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1. /*
  2. * ibmvfc.c -- driver for IBM Power Virtual Fibre Channel Adapter
  3. *
  4. * Written By: Brian King <brking@linux.vnet.ibm.com>, IBM Corporation
  5. *
  6. * Copyright (C) IBM Corporation, 2008
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation; either version 2 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program; if not, write to the Free Software
  20. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. *
  22. */
  23. #include <linux/module.h>
  24. #include <linux/moduleparam.h>
  25. #include <linux/dma-mapping.h>
  26. #include <linux/dmapool.h>
  27. #include <linux/delay.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/kthread.h>
  30. #include <linux/slab.h>
  31. #include <linux/of.h>
  32. #include <linux/pm.h>
  33. #include <linux/stringify.h>
  34. #include <asm/firmware.h>
  35. #include <asm/irq.h>
  36. #include <asm/vio.h>
  37. #include <scsi/scsi.h>
  38. #include <scsi/scsi_cmnd.h>
  39. #include <scsi/scsi_host.h>
  40. #include <scsi/scsi_device.h>
  41. #include <scsi/scsi_tcq.h>
  42. #include <scsi/scsi_transport_fc.h>
  43. #include <scsi/scsi_bsg_fc.h>
  44. #include "ibmvfc.h"
  45. static unsigned int init_timeout = IBMVFC_INIT_TIMEOUT;
  46. static unsigned int default_timeout = IBMVFC_DEFAULT_TIMEOUT;
  47. static unsigned int max_lun = IBMVFC_MAX_LUN;
  48. static unsigned int max_targets = IBMVFC_MAX_TARGETS;
  49. static unsigned int max_requests = IBMVFC_MAX_REQUESTS_DEFAULT;
  50. static unsigned int disc_threads = IBMVFC_MAX_DISC_THREADS;
  51. static unsigned int ibmvfc_debug = IBMVFC_DEBUG;
  52. static unsigned int log_level = IBMVFC_DEFAULT_LOG_LEVEL;
  53. static LIST_HEAD(ibmvfc_head);
  54. static DEFINE_SPINLOCK(ibmvfc_driver_lock);
  55. static struct scsi_transport_template *ibmvfc_transport_template;
  56. MODULE_DESCRIPTION("IBM Virtual Fibre Channel Driver");
  57. MODULE_AUTHOR("Brian King <brking@linux.vnet.ibm.com>");
  58. MODULE_LICENSE("GPL");
  59. MODULE_VERSION(IBMVFC_DRIVER_VERSION);
  60. module_param_named(init_timeout, init_timeout, uint, S_IRUGO | S_IWUSR);
  61. MODULE_PARM_DESC(init_timeout, "Initialization timeout in seconds. "
  62. "[Default=" __stringify(IBMVFC_INIT_TIMEOUT) "]");
  63. module_param_named(default_timeout, default_timeout, uint, S_IRUGO | S_IWUSR);
  64. MODULE_PARM_DESC(default_timeout,
  65. "Default timeout in seconds for initialization and EH commands. "
  66. "[Default=" __stringify(IBMVFC_DEFAULT_TIMEOUT) "]");
  67. module_param_named(max_requests, max_requests, uint, S_IRUGO);
  68. MODULE_PARM_DESC(max_requests, "Maximum requests for this adapter. "
  69. "[Default=" __stringify(IBMVFC_MAX_REQUESTS_DEFAULT) "]");
  70. module_param_named(max_lun, max_lun, uint, S_IRUGO);
  71. MODULE_PARM_DESC(max_lun, "Maximum allowed LUN. "
  72. "[Default=" __stringify(IBMVFC_MAX_LUN) "]");
  73. module_param_named(max_targets, max_targets, uint, S_IRUGO);
  74. MODULE_PARM_DESC(max_targets, "Maximum allowed targets. "
  75. "[Default=" __stringify(IBMVFC_MAX_TARGETS) "]");
  76. module_param_named(disc_threads, disc_threads, uint, S_IRUGO);
  77. MODULE_PARM_DESC(disc_threads, "Number of device discovery threads to use. "
  78. "[Default=" __stringify(IBMVFC_MAX_DISC_THREADS) "]");
  79. module_param_named(debug, ibmvfc_debug, uint, S_IRUGO | S_IWUSR);
  80. MODULE_PARM_DESC(debug, "Enable driver debug information. "
  81. "[Default=" __stringify(IBMVFC_DEBUG) "]");
  82. module_param_named(log_level, log_level, uint, 0);
  83. MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver. "
  84. "[Default=" __stringify(IBMVFC_DEFAULT_LOG_LEVEL) "]");
  85. static const struct {
  86. u16 status;
  87. u16 error;
  88. u8 result;
  89. u8 retry;
  90. int log;
  91. char *name;
  92. } cmd_status [] = {
  93. { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_ESTABLISH, DID_ERROR, 1, 1, "unable to establish" },
  94. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_FAULT, DID_OK, 1, 0, "transport fault" },
  95. { IBMVFC_FABRIC_MAPPED, IBMVFC_CMD_TIMEOUT, DID_TIME_OUT, 1, 1, "command timeout" },
  96. { IBMVFC_FABRIC_MAPPED, IBMVFC_ENETDOWN, DID_TRANSPORT_DISRUPTED, 1, 1, "network down" },
  97. { IBMVFC_FABRIC_MAPPED, IBMVFC_HW_FAILURE, DID_ERROR, 1, 1, "hardware failure" },
  98. { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DOWN_ERR, DID_REQUEUE, 0, 0, "link down" },
  99. { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_DEAD_ERR, DID_ERROR, 0, 0, "link dead" },
  100. { IBMVFC_FABRIC_MAPPED, IBMVFC_UNABLE_TO_REGISTER, DID_ERROR, 1, 1, "unable to register" },
  101. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_BUSY, DID_BUS_BUSY, 1, 0, "transport busy" },
  102. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_DEAD, DID_ERROR, 0, 1, "transport dead" },
  103. { IBMVFC_FABRIC_MAPPED, IBMVFC_CONFIG_ERROR, DID_ERROR, 1, 1, "configuration error" },
  104. { IBMVFC_FABRIC_MAPPED, IBMVFC_NAME_SERVER_FAIL, DID_ERROR, 1, 1, "name server failure" },
  105. { IBMVFC_FABRIC_MAPPED, IBMVFC_LINK_HALTED, DID_REQUEUE, 1, 0, "link halted" },
  106. { IBMVFC_FABRIC_MAPPED, IBMVFC_XPORT_GENERAL, DID_OK, 1, 0, "general transport error" },
  107. { IBMVFC_VIOS_FAILURE, IBMVFC_CRQ_FAILURE, DID_REQUEUE, 1, 1, "CRQ failure" },
  108. { IBMVFC_VIOS_FAILURE, IBMVFC_SW_FAILURE, DID_ERROR, 0, 1, "software failure" },
  109. { IBMVFC_VIOS_FAILURE, IBMVFC_INVALID_PARAMETER, DID_ERROR, 0, 1, "invalid parameter" },
  110. { IBMVFC_VIOS_FAILURE, IBMVFC_MISSING_PARAMETER, DID_ERROR, 0, 1, "missing parameter" },
  111. { IBMVFC_VIOS_FAILURE, IBMVFC_HOST_IO_BUS, DID_ERROR, 1, 1, "host I/O bus failure" },
  112. { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED, DID_ERROR, 0, 1, "transaction cancelled" },
  113. { IBMVFC_VIOS_FAILURE, IBMVFC_TRANS_CANCELLED_IMPLICIT, DID_ERROR, 0, 1, "transaction cancelled implicit" },
  114. { IBMVFC_VIOS_FAILURE, IBMVFC_INSUFFICIENT_RESOURCE, DID_REQUEUE, 1, 1, "insufficient resources" },
  115. { IBMVFC_VIOS_FAILURE, IBMVFC_PLOGI_REQUIRED, DID_ERROR, 0, 1, "port login required" },
  116. { IBMVFC_VIOS_FAILURE, IBMVFC_COMMAND_FAILED, DID_ERROR, 1, 1, "command failed" },
  117. { IBMVFC_FC_FAILURE, IBMVFC_INVALID_ELS_CMD_CODE, DID_ERROR, 0, 1, "invalid ELS command code" },
  118. { IBMVFC_FC_FAILURE, IBMVFC_INVALID_VERSION, DID_ERROR, 0, 1, "invalid version level" },
  119. { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_ERROR, DID_ERROR, 1, 1, "logical error" },
  120. { IBMVFC_FC_FAILURE, IBMVFC_INVALID_CT_IU_SIZE, DID_ERROR, 0, 1, "invalid CT_IU size" },
  121. { IBMVFC_FC_FAILURE, IBMVFC_LOGICAL_BUSY, DID_REQUEUE, 1, 0, "logical busy" },
  122. { IBMVFC_FC_FAILURE, IBMVFC_PROTOCOL_ERROR, DID_ERROR, 1, 1, "protocol error" },
  123. { IBMVFC_FC_FAILURE, IBMVFC_UNABLE_TO_PERFORM_REQ, DID_ERROR, 1, 1, "unable to perform request" },
  124. { IBMVFC_FC_FAILURE, IBMVFC_CMD_NOT_SUPPORTED, DID_ERROR, 0, 0, "command not supported" },
  125. { IBMVFC_FC_FAILURE, IBMVFC_SERVER_NOT_AVAIL, DID_ERROR, 0, 1, "server not available" },
  126. { IBMVFC_FC_FAILURE, IBMVFC_CMD_IN_PROGRESS, DID_ERROR, 0, 1, "command already in progress" },
  127. { IBMVFC_FC_FAILURE, IBMVFC_VENDOR_SPECIFIC, DID_ERROR, 1, 1, "vendor specific" },
  128. { IBMVFC_FC_SCSI_ERROR, 0, DID_OK, 1, 0, "SCSI error" },
  129. };
  130. static void ibmvfc_npiv_login(struct ibmvfc_host *);
  131. static void ibmvfc_tgt_send_prli(struct ibmvfc_target *);
  132. static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *);
  133. static void ibmvfc_tgt_query_target(struct ibmvfc_target *);
  134. static void ibmvfc_npiv_logout(struct ibmvfc_host *);
  135. static const char *unknown_error = "unknown error";
  136. #ifdef CONFIG_SCSI_IBMVFC_TRACE
  137. /**
  138. * ibmvfc_trc_start - Log a start trace entry
  139. * @evt: ibmvfc event struct
  140. *
  141. **/
  142. static void ibmvfc_trc_start(struct ibmvfc_event *evt)
  143. {
  144. struct ibmvfc_host *vhost = evt->vhost;
  145. struct ibmvfc_cmd *vfc_cmd = &evt->iu.cmd;
  146. struct ibmvfc_mad_common *mad = &evt->iu.mad_common;
  147. struct ibmvfc_trace_entry *entry;
  148. entry = &vhost->trace[vhost->trace_index++];
  149. entry->evt = evt;
  150. entry->time = jiffies;
  151. entry->fmt = evt->crq.format;
  152. entry->type = IBMVFC_TRC_START;
  153. switch (entry->fmt) {
  154. case IBMVFC_CMD_FORMAT:
  155. entry->op_code = vfc_cmd->iu.cdb[0];
  156. entry->scsi_id = vfc_cmd->tgt_scsi_id;
  157. entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
  158. entry->tmf_flags = vfc_cmd->iu.tmf_flags;
  159. entry->u.start.xfer_len = vfc_cmd->iu.xfer_len;
  160. break;
  161. case IBMVFC_MAD_FORMAT:
  162. entry->op_code = mad->opcode;
  163. break;
  164. default:
  165. break;
  166. };
  167. }
  168. /**
  169. * ibmvfc_trc_end - Log an end trace entry
  170. * @evt: ibmvfc event struct
  171. *
  172. **/
  173. static void ibmvfc_trc_end(struct ibmvfc_event *evt)
  174. {
  175. struct ibmvfc_host *vhost = evt->vhost;
  176. struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
  177. struct ibmvfc_mad_common *mad = &evt->xfer_iu->mad_common;
  178. struct ibmvfc_trace_entry *entry = &vhost->trace[vhost->trace_index++];
  179. entry->evt = evt;
  180. entry->time = jiffies;
  181. entry->fmt = evt->crq.format;
  182. entry->type = IBMVFC_TRC_END;
  183. switch (entry->fmt) {
  184. case IBMVFC_CMD_FORMAT:
  185. entry->op_code = vfc_cmd->iu.cdb[0];
  186. entry->scsi_id = vfc_cmd->tgt_scsi_id;
  187. entry->lun = scsilun_to_int(&vfc_cmd->iu.lun);
  188. entry->tmf_flags = vfc_cmd->iu.tmf_flags;
  189. entry->u.end.status = vfc_cmd->status;
  190. entry->u.end.error = vfc_cmd->error;
  191. entry->u.end.fcp_rsp_flags = vfc_cmd->rsp.flags;
  192. entry->u.end.rsp_code = vfc_cmd->rsp.data.info.rsp_code;
  193. entry->u.end.scsi_status = vfc_cmd->rsp.scsi_status;
  194. break;
  195. case IBMVFC_MAD_FORMAT:
  196. entry->op_code = mad->opcode;
  197. entry->u.end.status = mad->status;
  198. break;
  199. default:
  200. break;
  201. };
  202. }
  203. #else
  204. #define ibmvfc_trc_start(evt) do { } while (0)
  205. #define ibmvfc_trc_end(evt) do { } while (0)
  206. #endif
  207. /**
  208. * ibmvfc_get_err_index - Find the index into cmd_status for the fcp response
  209. * @status: status / error class
  210. * @error: error
  211. *
  212. * Return value:
  213. * index into cmd_status / -EINVAL on failure
  214. **/
  215. static int ibmvfc_get_err_index(u16 status, u16 error)
  216. {
  217. int i;
  218. for (i = 0; i < ARRAY_SIZE(cmd_status); i++)
  219. if ((cmd_status[i].status & status) == cmd_status[i].status &&
  220. cmd_status[i].error == error)
  221. return i;
  222. return -EINVAL;
  223. }
  224. /**
  225. * ibmvfc_get_cmd_error - Find the error description for the fcp response
  226. * @status: status / error class
  227. * @error: error
  228. *
  229. * Return value:
  230. * error description string
  231. **/
  232. static const char *ibmvfc_get_cmd_error(u16 status, u16 error)
  233. {
  234. int rc = ibmvfc_get_err_index(status, error);
  235. if (rc >= 0)
  236. return cmd_status[rc].name;
  237. return unknown_error;
  238. }
  239. /**
  240. * ibmvfc_get_err_result - Find the scsi status to return for the fcp response
  241. * @vfc_cmd: ibmvfc command struct
  242. *
  243. * Return value:
  244. * SCSI result value to return for completed command
  245. **/
  246. static int ibmvfc_get_err_result(struct ibmvfc_cmd *vfc_cmd)
  247. {
  248. int err;
  249. struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
  250. int fc_rsp_len = rsp->fcp_rsp_len;
  251. if ((rsp->flags & FCP_RSP_LEN_VALID) &&
  252. ((fc_rsp_len && fc_rsp_len != 4 && fc_rsp_len != 8) ||
  253. rsp->data.info.rsp_code))
  254. return DID_ERROR << 16;
  255. err = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
  256. if (err >= 0)
  257. return rsp->scsi_status | (cmd_status[err].result << 16);
  258. return rsp->scsi_status | (DID_ERROR << 16);
  259. }
  260. /**
  261. * ibmvfc_retry_cmd - Determine if error status is retryable
  262. * @status: status / error class
  263. * @error: error
  264. *
  265. * Return value:
  266. * 1 if error should be retried / 0 if it should not
  267. **/
  268. static int ibmvfc_retry_cmd(u16 status, u16 error)
  269. {
  270. int rc = ibmvfc_get_err_index(status, error);
  271. if (rc >= 0)
  272. return cmd_status[rc].retry;
  273. return 1;
  274. }
  275. static const char *unknown_fc_explain = "unknown fc explain";
  276. static const struct {
  277. u16 fc_explain;
  278. char *name;
  279. } ls_explain [] = {
  280. { 0x00, "no additional explanation" },
  281. { 0x01, "service parameter error - options" },
  282. { 0x03, "service parameter error - initiator control" },
  283. { 0x05, "service parameter error - recipient control" },
  284. { 0x07, "service parameter error - received data field size" },
  285. { 0x09, "service parameter error - concurrent seq" },
  286. { 0x0B, "service parameter error - credit" },
  287. { 0x0D, "invalid N_Port/F_Port_Name" },
  288. { 0x0E, "invalid node/Fabric Name" },
  289. { 0x0F, "invalid common service parameters" },
  290. { 0x11, "invalid association header" },
  291. { 0x13, "association header required" },
  292. { 0x15, "invalid originator S_ID" },
  293. { 0x17, "invalid OX_ID-RX-ID combination" },
  294. { 0x19, "command (request) already in progress" },
  295. { 0x1E, "N_Port Login requested" },
  296. { 0x1F, "Invalid N_Port_ID" },
  297. };
  298. static const struct {
  299. u16 fc_explain;
  300. char *name;
  301. } gs_explain [] = {
  302. { 0x00, "no additional explanation" },
  303. { 0x01, "port identifier not registered" },
  304. { 0x02, "port name not registered" },
  305. { 0x03, "node name not registered" },
  306. { 0x04, "class of service not registered" },
  307. { 0x06, "initial process associator not registered" },
  308. { 0x07, "FC-4 TYPEs not registered" },
  309. { 0x08, "symbolic port name not registered" },
  310. { 0x09, "symbolic node name not registered" },
  311. { 0x0A, "port type not registered" },
  312. { 0xF0, "authorization exception" },
  313. { 0xF1, "authentication exception" },
  314. { 0xF2, "data base full" },
  315. { 0xF3, "data base empty" },
  316. { 0xF4, "processing request" },
  317. { 0xF5, "unable to verify connection" },
  318. { 0xF6, "devices not in a common zone" },
  319. };
  320. /**
  321. * ibmvfc_get_ls_explain - Return the FC Explain description text
  322. * @status: FC Explain status
  323. *
  324. * Returns:
  325. * error string
  326. **/
  327. static const char *ibmvfc_get_ls_explain(u16 status)
  328. {
  329. int i;
  330. for (i = 0; i < ARRAY_SIZE(ls_explain); i++)
  331. if (ls_explain[i].fc_explain == status)
  332. return ls_explain[i].name;
  333. return unknown_fc_explain;
  334. }
  335. /**
  336. * ibmvfc_get_gs_explain - Return the FC Explain description text
  337. * @status: FC Explain status
  338. *
  339. * Returns:
  340. * error string
  341. **/
  342. static const char *ibmvfc_get_gs_explain(u16 status)
  343. {
  344. int i;
  345. for (i = 0; i < ARRAY_SIZE(gs_explain); i++)
  346. if (gs_explain[i].fc_explain == status)
  347. return gs_explain[i].name;
  348. return unknown_fc_explain;
  349. }
  350. static const struct {
  351. enum ibmvfc_fc_type fc_type;
  352. char *name;
  353. } fc_type [] = {
  354. { IBMVFC_FABRIC_REJECT, "fabric reject" },
  355. { IBMVFC_PORT_REJECT, "port reject" },
  356. { IBMVFC_LS_REJECT, "ELS reject" },
  357. { IBMVFC_FABRIC_BUSY, "fabric busy" },
  358. { IBMVFC_PORT_BUSY, "port busy" },
  359. { IBMVFC_BASIC_REJECT, "basic reject" },
  360. };
  361. static const char *unknown_fc_type = "unknown fc type";
  362. /**
  363. * ibmvfc_get_fc_type - Return the FC Type description text
  364. * @status: FC Type error status
  365. *
  366. * Returns:
  367. * error string
  368. **/
  369. static const char *ibmvfc_get_fc_type(u16 status)
  370. {
  371. int i;
  372. for (i = 0; i < ARRAY_SIZE(fc_type); i++)
  373. if (fc_type[i].fc_type == status)
  374. return fc_type[i].name;
  375. return unknown_fc_type;
  376. }
  377. /**
  378. * ibmvfc_set_tgt_action - Set the next init action for the target
  379. * @tgt: ibmvfc target struct
  380. * @action: action to perform
  381. *
  382. **/
  383. static void ibmvfc_set_tgt_action(struct ibmvfc_target *tgt,
  384. enum ibmvfc_target_action action)
  385. {
  386. switch (tgt->action) {
  387. case IBMVFC_TGT_ACTION_DEL_RPORT:
  388. if (action == IBMVFC_TGT_ACTION_DELETED_RPORT)
  389. tgt->action = action;
  390. case IBMVFC_TGT_ACTION_DELETED_RPORT:
  391. break;
  392. default:
  393. if (action == IBMVFC_TGT_ACTION_DEL_RPORT)
  394. tgt->add_rport = 0;
  395. tgt->action = action;
  396. break;
  397. }
  398. }
  399. /**
  400. * ibmvfc_set_host_state - Set the state for the host
  401. * @vhost: ibmvfc host struct
  402. * @state: state to set host to
  403. *
  404. * Returns:
  405. * 0 if state changed / non-zero if not changed
  406. **/
  407. static int ibmvfc_set_host_state(struct ibmvfc_host *vhost,
  408. enum ibmvfc_host_state state)
  409. {
  410. int rc = 0;
  411. switch (vhost->state) {
  412. case IBMVFC_HOST_OFFLINE:
  413. rc = -EINVAL;
  414. break;
  415. default:
  416. vhost->state = state;
  417. break;
  418. };
  419. return rc;
  420. }
  421. /**
  422. * ibmvfc_set_host_action - Set the next init action for the host
  423. * @vhost: ibmvfc host struct
  424. * @action: action to perform
  425. *
  426. **/
  427. static void ibmvfc_set_host_action(struct ibmvfc_host *vhost,
  428. enum ibmvfc_host_action action)
  429. {
  430. switch (action) {
  431. case IBMVFC_HOST_ACTION_ALLOC_TGTS:
  432. if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT)
  433. vhost->action = action;
  434. break;
  435. case IBMVFC_HOST_ACTION_LOGO_WAIT:
  436. if (vhost->action == IBMVFC_HOST_ACTION_LOGO)
  437. vhost->action = action;
  438. break;
  439. case IBMVFC_HOST_ACTION_INIT_WAIT:
  440. if (vhost->action == IBMVFC_HOST_ACTION_INIT)
  441. vhost->action = action;
  442. break;
  443. case IBMVFC_HOST_ACTION_QUERY:
  444. switch (vhost->action) {
  445. case IBMVFC_HOST_ACTION_INIT_WAIT:
  446. case IBMVFC_HOST_ACTION_NONE:
  447. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  448. vhost->action = action;
  449. break;
  450. default:
  451. break;
  452. };
  453. break;
  454. case IBMVFC_HOST_ACTION_TGT_INIT:
  455. if (vhost->action == IBMVFC_HOST_ACTION_ALLOC_TGTS)
  456. vhost->action = action;
  457. break;
  458. case IBMVFC_HOST_ACTION_INIT:
  459. case IBMVFC_HOST_ACTION_TGT_DEL:
  460. switch (vhost->action) {
  461. case IBMVFC_HOST_ACTION_RESET:
  462. case IBMVFC_HOST_ACTION_REENABLE:
  463. break;
  464. default:
  465. vhost->action = action;
  466. break;
  467. };
  468. break;
  469. case IBMVFC_HOST_ACTION_LOGO:
  470. case IBMVFC_HOST_ACTION_QUERY_TGTS:
  471. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  472. case IBMVFC_HOST_ACTION_NONE:
  473. case IBMVFC_HOST_ACTION_RESET:
  474. case IBMVFC_HOST_ACTION_REENABLE:
  475. default:
  476. vhost->action = action;
  477. break;
  478. };
  479. }
  480. /**
  481. * ibmvfc_reinit_host - Re-start host initialization (no NPIV Login)
  482. * @vhost: ibmvfc host struct
  483. *
  484. * Return value:
  485. * nothing
  486. **/
  487. static void ibmvfc_reinit_host(struct ibmvfc_host *vhost)
  488. {
  489. if (vhost->action == IBMVFC_HOST_ACTION_NONE) {
  490. if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
  491. scsi_block_requests(vhost->host);
  492. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
  493. }
  494. } else
  495. vhost->reinit = 1;
  496. wake_up(&vhost->work_wait_q);
  497. }
  498. /**
  499. * ibmvfc_link_down - Handle a link down event from the adapter
  500. * @vhost: ibmvfc host struct
  501. * @state: ibmvfc host state to enter
  502. *
  503. **/
  504. static void ibmvfc_link_down(struct ibmvfc_host *vhost,
  505. enum ibmvfc_host_state state)
  506. {
  507. struct ibmvfc_target *tgt;
  508. ENTER;
  509. scsi_block_requests(vhost->host);
  510. list_for_each_entry(tgt, &vhost->targets, queue)
  511. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  512. ibmvfc_set_host_state(vhost, state);
  513. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
  514. vhost->events_to_log |= IBMVFC_AE_LINKDOWN;
  515. wake_up(&vhost->work_wait_q);
  516. LEAVE;
  517. }
  518. /**
  519. * ibmvfc_init_host - Start host initialization
  520. * @vhost: ibmvfc host struct
  521. *
  522. * Return value:
  523. * nothing
  524. **/
  525. static void ibmvfc_init_host(struct ibmvfc_host *vhost)
  526. {
  527. struct ibmvfc_target *tgt;
  528. if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
  529. if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
  530. dev_err(vhost->dev,
  531. "Host initialization retries exceeded. Taking adapter offline\n");
  532. ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
  533. return;
  534. }
  535. }
  536. if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
  537. memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
  538. vhost->async_crq.cur = 0;
  539. list_for_each_entry(tgt, &vhost->targets, queue)
  540. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  541. scsi_block_requests(vhost->host);
  542. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
  543. vhost->job_step = ibmvfc_npiv_login;
  544. wake_up(&vhost->work_wait_q);
  545. }
  546. }
  547. /**
  548. * ibmvfc_send_crq - Send a CRQ
  549. * @vhost: ibmvfc host struct
  550. * @word1: the first 64 bits of the data
  551. * @word2: the second 64 bits of the data
  552. *
  553. * Return value:
  554. * 0 on success / other on failure
  555. **/
  556. static int ibmvfc_send_crq(struct ibmvfc_host *vhost, u64 word1, u64 word2)
  557. {
  558. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  559. return plpar_hcall_norets(H_SEND_CRQ, vdev->unit_address, word1, word2);
  560. }
  561. /**
  562. * ibmvfc_send_crq_init - Send a CRQ init message
  563. * @vhost: ibmvfc host struct
  564. *
  565. * Return value:
  566. * 0 on success / other on failure
  567. **/
  568. static int ibmvfc_send_crq_init(struct ibmvfc_host *vhost)
  569. {
  570. ibmvfc_dbg(vhost, "Sending CRQ init\n");
  571. return ibmvfc_send_crq(vhost, 0xC001000000000000LL, 0);
  572. }
  573. /**
  574. * ibmvfc_send_crq_init_complete - Send a CRQ init complete message
  575. * @vhost: ibmvfc host struct
  576. *
  577. * Return value:
  578. * 0 on success / other on failure
  579. **/
  580. static int ibmvfc_send_crq_init_complete(struct ibmvfc_host *vhost)
  581. {
  582. ibmvfc_dbg(vhost, "Sending CRQ init complete\n");
  583. return ibmvfc_send_crq(vhost, 0xC002000000000000LL, 0);
  584. }
  585. /**
  586. * ibmvfc_release_crq_queue - Deallocates data and unregisters CRQ
  587. * @vhost: ibmvfc host struct
  588. *
  589. * Frees irq, deallocates a page for messages, unmaps dma, and unregisters
  590. * the crq with the hypervisor.
  591. **/
  592. static void ibmvfc_release_crq_queue(struct ibmvfc_host *vhost)
  593. {
  594. long rc = 0;
  595. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  596. struct ibmvfc_crq_queue *crq = &vhost->crq;
  597. ibmvfc_dbg(vhost, "Releasing CRQ\n");
  598. free_irq(vdev->irq, vhost);
  599. tasklet_kill(&vhost->tasklet);
  600. do {
  601. if (rc)
  602. msleep(100);
  603. rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
  604. } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
  605. vhost->state = IBMVFC_NO_CRQ;
  606. vhost->logged_in = 0;
  607. dma_unmap_single(vhost->dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
  608. free_page((unsigned long)crq->msgs);
  609. }
  610. /**
  611. * ibmvfc_reenable_crq_queue - reenables the CRQ
  612. * @vhost: ibmvfc host struct
  613. *
  614. * Return value:
  615. * 0 on success / other on failure
  616. **/
  617. static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost)
  618. {
  619. int rc = 0;
  620. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  621. /* Re-enable the CRQ */
  622. do {
  623. if (rc)
  624. msleep(100);
  625. rc = plpar_hcall_norets(H_ENABLE_CRQ, vdev->unit_address);
  626. } while (rc == H_IN_PROGRESS || rc == H_BUSY || H_IS_LONG_BUSY(rc));
  627. if (rc)
  628. dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
  629. return rc;
  630. }
  631. /**
  632. * ibmvfc_reset_crq - resets a crq after a failure
  633. * @vhost: ibmvfc host struct
  634. *
  635. * Return value:
  636. * 0 on success / other on failure
  637. **/
  638. static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
  639. {
  640. int rc = 0;
  641. unsigned long flags;
  642. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  643. struct ibmvfc_crq_queue *crq = &vhost->crq;
  644. /* Close the CRQ */
  645. do {
  646. if (rc)
  647. msleep(100);
  648. rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
  649. } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
  650. spin_lock_irqsave(vhost->host->host_lock, flags);
  651. vhost->state = IBMVFC_NO_CRQ;
  652. vhost->logged_in = 0;
  653. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  654. /* Clean out the queue */
  655. memset(crq->msgs, 0, PAGE_SIZE);
  656. crq->cur = 0;
  657. /* And re-open it again */
  658. rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
  659. crq->msg_token, PAGE_SIZE);
  660. if (rc == H_CLOSED)
  661. /* Adapter is good, but other end is not ready */
  662. dev_warn(vhost->dev, "Partner adapter not ready\n");
  663. else if (rc != 0)
  664. dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
  665. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  666. return rc;
  667. }
  668. /**
  669. * ibmvfc_valid_event - Determines if event is valid.
  670. * @pool: event_pool that contains the event
  671. * @evt: ibmvfc event to be checked for validity
  672. *
  673. * Return value:
  674. * 1 if event is valid / 0 if event is not valid
  675. **/
  676. static int ibmvfc_valid_event(struct ibmvfc_event_pool *pool,
  677. struct ibmvfc_event *evt)
  678. {
  679. int index = evt - pool->events;
  680. if (index < 0 || index >= pool->size) /* outside of bounds */
  681. return 0;
  682. if (evt != pool->events + index) /* unaligned */
  683. return 0;
  684. return 1;
  685. }
  686. /**
  687. * ibmvfc_free_event - Free the specified event
  688. * @evt: ibmvfc_event to be freed
  689. *
  690. **/
  691. static void ibmvfc_free_event(struct ibmvfc_event *evt)
  692. {
  693. struct ibmvfc_host *vhost = evt->vhost;
  694. struct ibmvfc_event_pool *pool = &vhost->pool;
  695. BUG_ON(!ibmvfc_valid_event(pool, evt));
  696. BUG_ON(atomic_inc_return(&evt->free) != 1);
  697. list_add_tail(&evt->queue, &vhost->free);
  698. }
  699. /**
  700. * ibmvfc_scsi_eh_done - EH done function for queuecommand commands
  701. * @evt: ibmvfc event struct
  702. *
  703. * This function does not setup any error status, that must be done
  704. * before this function gets called.
  705. **/
  706. static void ibmvfc_scsi_eh_done(struct ibmvfc_event *evt)
  707. {
  708. struct scsi_cmnd *cmnd = evt->cmnd;
  709. if (cmnd) {
  710. scsi_dma_unmap(cmnd);
  711. cmnd->scsi_done(cmnd);
  712. }
  713. if (evt->eh_comp)
  714. complete(evt->eh_comp);
  715. ibmvfc_free_event(evt);
  716. }
  717. /**
  718. * ibmvfc_fail_request - Fail request with specified error code
  719. * @evt: ibmvfc event struct
  720. * @error_code: error code to fail request with
  721. *
  722. * Return value:
  723. * none
  724. **/
  725. static void ibmvfc_fail_request(struct ibmvfc_event *evt, int error_code)
  726. {
  727. if (evt->cmnd) {
  728. evt->cmnd->result = (error_code << 16);
  729. evt->done = ibmvfc_scsi_eh_done;
  730. } else
  731. evt->xfer_iu->mad_common.status = IBMVFC_MAD_DRIVER_FAILED;
  732. list_del(&evt->queue);
  733. del_timer(&evt->timer);
  734. ibmvfc_trc_end(evt);
  735. evt->done(evt);
  736. }
  737. /**
  738. * ibmvfc_purge_requests - Our virtual adapter just shut down. Purge any sent requests
  739. * @vhost: ibmvfc host struct
  740. * @error_code: error code to fail requests with
  741. *
  742. * Return value:
  743. * none
  744. **/
  745. static void ibmvfc_purge_requests(struct ibmvfc_host *vhost, int error_code)
  746. {
  747. struct ibmvfc_event *evt, *pos;
  748. ibmvfc_dbg(vhost, "Purging all requests\n");
  749. list_for_each_entry_safe(evt, pos, &vhost->sent, queue)
  750. ibmvfc_fail_request(evt, error_code);
  751. }
  752. /**
  753. * ibmvfc_hard_reset_host - Reset the connection to the server by breaking the CRQ
  754. * @vhost: struct ibmvfc host to reset
  755. **/
  756. static void ibmvfc_hard_reset_host(struct ibmvfc_host *vhost)
  757. {
  758. ibmvfc_purge_requests(vhost, DID_ERROR);
  759. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  760. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
  761. }
  762. /**
  763. * __ibmvfc_reset_host - Reset the connection to the server (no locking)
  764. * @vhost: struct ibmvfc host to reset
  765. **/
  766. static void __ibmvfc_reset_host(struct ibmvfc_host *vhost)
  767. {
  768. if (vhost->logged_in && vhost->action != IBMVFC_HOST_ACTION_LOGO_WAIT &&
  769. !ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
  770. scsi_block_requests(vhost->host);
  771. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO);
  772. vhost->job_step = ibmvfc_npiv_logout;
  773. wake_up(&vhost->work_wait_q);
  774. } else
  775. ibmvfc_hard_reset_host(vhost);
  776. }
  777. /**
  778. * ibmvfc_reset_host - Reset the connection to the server
  779. * @vhost: ibmvfc host struct
  780. **/
  781. static void ibmvfc_reset_host(struct ibmvfc_host *vhost)
  782. {
  783. unsigned long flags;
  784. spin_lock_irqsave(vhost->host->host_lock, flags);
  785. __ibmvfc_reset_host(vhost);
  786. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  787. }
  788. /**
  789. * ibmvfc_retry_host_init - Retry host initialization if allowed
  790. * @vhost: ibmvfc host struct
  791. *
  792. * Returns: 1 if init will be retried / 0 if not
  793. *
  794. **/
  795. static int ibmvfc_retry_host_init(struct ibmvfc_host *vhost)
  796. {
  797. int retry = 0;
  798. if (vhost->action == IBMVFC_HOST_ACTION_INIT_WAIT) {
  799. vhost->delay_init = 1;
  800. if (++vhost->init_retries > IBMVFC_MAX_HOST_INIT_RETRIES) {
  801. dev_err(vhost->dev,
  802. "Host initialization retries exceeded. Taking adapter offline\n");
  803. ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
  804. } else if (vhost->init_retries == IBMVFC_MAX_HOST_INIT_RETRIES)
  805. __ibmvfc_reset_host(vhost);
  806. else {
  807. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
  808. retry = 1;
  809. }
  810. }
  811. wake_up(&vhost->work_wait_q);
  812. return retry;
  813. }
  814. /**
  815. * __ibmvfc_get_target - Find the specified scsi_target (no locking)
  816. * @starget: scsi target struct
  817. *
  818. * Return value:
  819. * ibmvfc_target struct / NULL if not found
  820. **/
  821. static struct ibmvfc_target *__ibmvfc_get_target(struct scsi_target *starget)
  822. {
  823. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  824. struct ibmvfc_host *vhost = shost_priv(shost);
  825. struct ibmvfc_target *tgt;
  826. list_for_each_entry(tgt, &vhost->targets, queue)
  827. if (tgt->target_id == starget->id) {
  828. kref_get(&tgt->kref);
  829. return tgt;
  830. }
  831. return NULL;
  832. }
  833. /**
  834. * ibmvfc_get_target - Find the specified scsi_target
  835. * @starget: scsi target struct
  836. *
  837. * Return value:
  838. * ibmvfc_target struct / NULL if not found
  839. **/
  840. static struct ibmvfc_target *ibmvfc_get_target(struct scsi_target *starget)
  841. {
  842. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  843. struct ibmvfc_target *tgt;
  844. unsigned long flags;
  845. spin_lock_irqsave(shost->host_lock, flags);
  846. tgt = __ibmvfc_get_target(starget);
  847. spin_unlock_irqrestore(shost->host_lock, flags);
  848. return tgt;
  849. }
  850. /**
  851. * ibmvfc_get_host_speed - Get host port speed
  852. * @shost: scsi host struct
  853. *
  854. * Return value:
  855. * none
  856. **/
  857. static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
  858. {
  859. struct ibmvfc_host *vhost = shost_priv(shost);
  860. unsigned long flags;
  861. spin_lock_irqsave(shost->host_lock, flags);
  862. if (vhost->state == IBMVFC_ACTIVE) {
  863. switch (vhost->login_buf->resp.link_speed / 100) {
  864. case 1:
  865. fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
  866. break;
  867. case 2:
  868. fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
  869. break;
  870. case 4:
  871. fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
  872. break;
  873. case 8:
  874. fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
  875. break;
  876. case 10:
  877. fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
  878. break;
  879. case 16:
  880. fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
  881. break;
  882. default:
  883. ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
  884. vhost->login_buf->resp.link_speed / 100);
  885. fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
  886. break;
  887. }
  888. } else
  889. fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
  890. spin_unlock_irqrestore(shost->host_lock, flags);
  891. }
  892. /**
  893. * ibmvfc_get_host_port_state - Get host port state
  894. * @shost: scsi host struct
  895. *
  896. * Return value:
  897. * none
  898. **/
  899. static void ibmvfc_get_host_port_state(struct Scsi_Host *shost)
  900. {
  901. struct ibmvfc_host *vhost = shost_priv(shost);
  902. unsigned long flags;
  903. spin_lock_irqsave(shost->host_lock, flags);
  904. switch (vhost->state) {
  905. case IBMVFC_INITIALIZING:
  906. case IBMVFC_ACTIVE:
  907. fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
  908. break;
  909. case IBMVFC_LINK_DOWN:
  910. fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
  911. break;
  912. case IBMVFC_LINK_DEAD:
  913. case IBMVFC_HOST_OFFLINE:
  914. fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
  915. break;
  916. case IBMVFC_HALTED:
  917. fc_host_port_state(shost) = FC_PORTSTATE_BLOCKED;
  918. break;
  919. case IBMVFC_NO_CRQ:
  920. fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
  921. break;
  922. default:
  923. ibmvfc_log(vhost, 3, "Unknown port state: %d\n", vhost->state);
  924. fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
  925. break;
  926. }
  927. spin_unlock_irqrestore(shost->host_lock, flags);
  928. }
  929. /**
  930. * ibmvfc_set_rport_dev_loss_tmo - Set rport's device loss timeout
  931. * @rport: rport struct
  932. * @timeout: timeout value
  933. *
  934. * Return value:
  935. * none
  936. **/
  937. static void ibmvfc_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
  938. {
  939. if (timeout)
  940. rport->dev_loss_tmo = timeout;
  941. else
  942. rport->dev_loss_tmo = 1;
  943. }
  944. /**
  945. * ibmvfc_release_tgt - Free memory allocated for a target
  946. * @kref: kref struct
  947. *
  948. **/
  949. static void ibmvfc_release_tgt(struct kref *kref)
  950. {
  951. struct ibmvfc_target *tgt = container_of(kref, struct ibmvfc_target, kref);
  952. kfree(tgt);
  953. }
  954. /**
  955. * ibmvfc_get_starget_node_name - Get SCSI target's node name
  956. * @starget: scsi target struct
  957. *
  958. * Return value:
  959. * none
  960. **/
  961. static void ibmvfc_get_starget_node_name(struct scsi_target *starget)
  962. {
  963. struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
  964. fc_starget_port_name(starget) = tgt ? tgt->ids.node_name : 0;
  965. if (tgt)
  966. kref_put(&tgt->kref, ibmvfc_release_tgt);
  967. }
  968. /**
  969. * ibmvfc_get_starget_port_name - Get SCSI target's port name
  970. * @starget: scsi target struct
  971. *
  972. * Return value:
  973. * none
  974. **/
  975. static void ibmvfc_get_starget_port_name(struct scsi_target *starget)
  976. {
  977. struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
  978. fc_starget_port_name(starget) = tgt ? tgt->ids.port_name : 0;
  979. if (tgt)
  980. kref_put(&tgt->kref, ibmvfc_release_tgt);
  981. }
  982. /**
  983. * ibmvfc_get_starget_port_id - Get SCSI target's port ID
  984. * @starget: scsi target struct
  985. *
  986. * Return value:
  987. * none
  988. **/
  989. static void ibmvfc_get_starget_port_id(struct scsi_target *starget)
  990. {
  991. struct ibmvfc_target *tgt = ibmvfc_get_target(starget);
  992. fc_starget_port_id(starget) = tgt ? tgt->scsi_id : -1;
  993. if (tgt)
  994. kref_put(&tgt->kref, ibmvfc_release_tgt);
  995. }
  996. /**
  997. * ibmvfc_wait_while_resetting - Wait while the host resets
  998. * @vhost: ibmvfc host struct
  999. *
  1000. * Return value:
  1001. * 0 on success / other on failure
  1002. **/
  1003. static int ibmvfc_wait_while_resetting(struct ibmvfc_host *vhost)
  1004. {
  1005. long timeout = wait_event_timeout(vhost->init_wait_q,
  1006. ((vhost->state == IBMVFC_ACTIVE ||
  1007. vhost->state == IBMVFC_HOST_OFFLINE ||
  1008. vhost->state == IBMVFC_LINK_DEAD) &&
  1009. vhost->action == IBMVFC_HOST_ACTION_NONE),
  1010. (init_timeout * HZ));
  1011. return timeout ? 0 : -EIO;
  1012. }
  1013. /**
  1014. * ibmvfc_issue_fc_host_lip - Re-initiate link initialization
  1015. * @shost: scsi host struct
  1016. *
  1017. * Return value:
  1018. * 0 on success / other on failure
  1019. **/
  1020. static int ibmvfc_issue_fc_host_lip(struct Scsi_Host *shost)
  1021. {
  1022. struct ibmvfc_host *vhost = shost_priv(shost);
  1023. dev_err(vhost->dev, "Initiating host LIP. Resetting connection\n");
  1024. ibmvfc_reset_host(vhost);
  1025. return ibmvfc_wait_while_resetting(vhost);
  1026. }
  1027. /**
  1028. * ibmvfc_gather_partition_info - Gather info about the LPAR
  1029. *
  1030. * Return value:
  1031. * none
  1032. **/
  1033. static void ibmvfc_gather_partition_info(struct ibmvfc_host *vhost)
  1034. {
  1035. struct device_node *rootdn;
  1036. const char *name;
  1037. const unsigned int *num;
  1038. rootdn = of_find_node_by_path("/");
  1039. if (!rootdn)
  1040. return;
  1041. name = of_get_property(rootdn, "ibm,partition-name", NULL);
  1042. if (name)
  1043. strncpy(vhost->partition_name, name, sizeof(vhost->partition_name));
  1044. num = of_get_property(rootdn, "ibm,partition-no", NULL);
  1045. if (num)
  1046. vhost->partition_number = *num;
  1047. of_node_put(rootdn);
  1048. }
  1049. /**
  1050. * ibmvfc_set_login_info - Setup info for NPIV login
  1051. * @vhost: ibmvfc host struct
  1052. *
  1053. * Return value:
  1054. * none
  1055. **/
  1056. static void ibmvfc_set_login_info(struct ibmvfc_host *vhost)
  1057. {
  1058. struct ibmvfc_npiv_login *login_info = &vhost->login_info;
  1059. struct device_node *of_node = vhost->dev->of_node;
  1060. const char *location;
  1061. memset(login_info, 0, sizeof(*login_info));
  1062. login_info->ostype = IBMVFC_OS_LINUX;
  1063. login_info->max_dma_len = IBMVFC_MAX_SECTORS << 9;
  1064. login_info->max_payload = sizeof(struct ibmvfc_fcp_cmd_iu);
  1065. login_info->max_response = sizeof(struct ibmvfc_fcp_rsp);
  1066. login_info->partition_num = vhost->partition_number;
  1067. login_info->vfc_frame_version = 1;
  1068. login_info->fcp_version = 3;
  1069. login_info->flags = IBMVFC_FLUSH_ON_HALT;
  1070. if (vhost->client_migrated)
  1071. login_info->flags |= IBMVFC_CLIENT_MIGRATED;
  1072. login_info->max_cmds = max_requests + IBMVFC_NUM_INTERNAL_REQ;
  1073. login_info->capabilities = IBMVFC_CAN_MIGRATE;
  1074. login_info->async.va = vhost->async_crq.msg_token;
  1075. login_info->async.len = vhost->async_crq.size * sizeof(*vhost->async_crq.msgs);
  1076. strncpy(login_info->partition_name, vhost->partition_name, IBMVFC_MAX_NAME);
  1077. strncpy(login_info->device_name,
  1078. dev_name(&vhost->host->shost_gendev), IBMVFC_MAX_NAME);
  1079. location = of_get_property(of_node, "ibm,loc-code", NULL);
  1080. location = location ? location : dev_name(vhost->dev);
  1081. strncpy(login_info->drc_name, location, IBMVFC_MAX_NAME);
  1082. }
  1083. /**
  1084. * ibmvfc_init_event_pool - Allocates and initializes the event pool for a host
  1085. * @vhost: ibmvfc host who owns the event pool
  1086. *
  1087. * Returns zero on success.
  1088. **/
  1089. static int ibmvfc_init_event_pool(struct ibmvfc_host *vhost)
  1090. {
  1091. int i;
  1092. struct ibmvfc_event_pool *pool = &vhost->pool;
  1093. ENTER;
  1094. pool->size = max_requests + IBMVFC_NUM_INTERNAL_REQ;
  1095. pool->events = kcalloc(pool->size, sizeof(*pool->events), GFP_KERNEL);
  1096. if (!pool->events)
  1097. return -ENOMEM;
  1098. pool->iu_storage = dma_alloc_coherent(vhost->dev,
  1099. pool->size * sizeof(*pool->iu_storage),
  1100. &pool->iu_token, 0);
  1101. if (!pool->iu_storage) {
  1102. kfree(pool->events);
  1103. return -ENOMEM;
  1104. }
  1105. for (i = 0; i < pool->size; ++i) {
  1106. struct ibmvfc_event *evt = &pool->events[i];
  1107. atomic_set(&evt->free, 1);
  1108. evt->crq.valid = 0x80;
  1109. evt->crq.ioba = pool->iu_token + (sizeof(*evt->xfer_iu) * i);
  1110. evt->xfer_iu = pool->iu_storage + i;
  1111. evt->vhost = vhost;
  1112. evt->ext_list = NULL;
  1113. list_add_tail(&evt->queue, &vhost->free);
  1114. }
  1115. LEAVE;
  1116. return 0;
  1117. }
  1118. /**
  1119. * ibmvfc_free_event_pool - Frees memory of the event pool of a host
  1120. * @vhost: ibmvfc host who owns the event pool
  1121. *
  1122. **/
  1123. static void ibmvfc_free_event_pool(struct ibmvfc_host *vhost)
  1124. {
  1125. int i;
  1126. struct ibmvfc_event_pool *pool = &vhost->pool;
  1127. ENTER;
  1128. for (i = 0; i < pool->size; ++i) {
  1129. list_del(&pool->events[i].queue);
  1130. BUG_ON(atomic_read(&pool->events[i].free) != 1);
  1131. if (pool->events[i].ext_list)
  1132. dma_pool_free(vhost->sg_pool,
  1133. pool->events[i].ext_list,
  1134. pool->events[i].ext_list_token);
  1135. }
  1136. kfree(pool->events);
  1137. dma_free_coherent(vhost->dev,
  1138. pool->size * sizeof(*pool->iu_storage),
  1139. pool->iu_storage, pool->iu_token);
  1140. LEAVE;
  1141. }
  1142. /**
  1143. * ibmvfc_get_event - Gets the next free event in pool
  1144. * @vhost: ibmvfc host struct
  1145. *
  1146. * Returns a free event from the pool.
  1147. **/
  1148. static struct ibmvfc_event *ibmvfc_get_event(struct ibmvfc_host *vhost)
  1149. {
  1150. struct ibmvfc_event *evt;
  1151. BUG_ON(list_empty(&vhost->free));
  1152. evt = list_entry(vhost->free.next, struct ibmvfc_event, queue);
  1153. atomic_set(&evt->free, 0);
  1154. list_del(&evt->queue);
  1155. return evt;
  1156. }
  1157. /**
  1158. * ibmvfc_init_event - Initialize fields in an event struct that are always
  1159. * required.
  1160. * @evt: The event
  1161. * @done: Routine to call when the event is responded to
  1162. * @format: SRP or MAD format
  1163. **/
  1164. static void ibmvfc_init_event(struct ibmvfc_event *evt,
  1165. void (*done) (struct ibmvfc_event *), u8 format)
  1166. {
  1167. evt->cmnd = NULL;
  1168. evt->sync_iu = NULL;
  1169. evt->crq.format = format;
  1170. evt->done = done;
  1171. evt->eh_comp = NULL;
  1172. }
  1173. /**
  1174. * ibmvfc_map_sg_list - Initialize scatterlist
  1175. * @scmd: scsi command struct
  1176. * @nseg: number of scatterlist segments
  1177. * @md: memory descriptor list to initialize
  1178. **/
  1179. static void ibmvfc_map_sg_list(struct scsi_cmnd *scmd, int nseg,
  1180. struct srp_direct_buf *md)
  1181. {
  1182. int i;
  1183. struct scatterlist *sg;
  1184. scsi_for_each_sg(scmd, sg, nseg, i) {
  1185. md[i].va = sg_dma_address(sg);
  1186. md[i].len = sg_dma_len(sg);
  1187. md[i].key = 0;
  1188. }
  1189. }
  1190. /**
  1191. * ibmvfc_map_sg_data - Maps dma for a scatterlist and initializes decriptor fields
  1192. * @scmd: Scsi_Cmnd with the scatterlist
  1193. * @evt: ibmvfc event struct
  1194. * @vfc_cmd: vfc_cmd that contains the memory descriptor
  1195. * @dev: device for which to map dma memory
  1196. *
  1197. * Returns:
  1198. * 0 on success / non-zero on failure
  1199. **/
  1200. static int ibmvfc_map_sg_data(struct scsi_cmnd *scmd,
  1201. struct ibmvfc_event *evt,
  1202. struct ibmvfc_cmd *vfc_cmd, struct device *dev)
  1203. {
  1204. int sg_mapped;
  1205. struct srp_direct_buf *data = &vfc_cmd->ioba;
  1206. struct ibmvfc_host *vhost = dev_get_drvdata(dev);
  1207. sg_mapped = scsi_dma_map(scmd);
  1208. if (!sg_mapped) {
  1209. vfc_cmd->flags |= IBMVFC_NO_MEM_DESC;
  1210. return 0;
  1211. } else if (unlikely(sg_mapped < 0)) {
  1212. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1213. scmd_printk(KERN_ERR, scmd, "Failed to map DMA buffer for command\n");
  1214. return sg_mapped;
  1215. }
  1216. if (scmd->sc_data_direction == DMA_TO_DEVICE) {
  1217. vfc_cmd->flags |= IBMVFC_WRITE;
  1218. vfc_cmd->iu.add_cdb_len |= IBMVFC_WRDATA;
  1219. } else {
  1220. vfc_cmd->flags |= IBMVFC_READ;
  1221. vfc_cmd->iu.add_cdb_len |= IBMVFC_RDDATA;
  1222. }
  1223. if (sg_mapped == 1) {
  1224. ibmvfc_map_sg_list(scmd, sg_mapped, data);
  1225. return 0;
  1226. }
  1227. vfc_cmd->flags |= IBMVFC_SCATTERLIST;
  1228. if (!evt->ext_list) {
  1229. evt->ext_list = dma_pool_alloc(vhost->sg_pool, GFP_ATOMIC,
  1230. &evt->ext_list_token);
  1231. if (!evt->ext_list) {
  1232. scsi_dma_unmap(scmd);
  1233. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1234. scmd_printk(KERN_ERR, scmd, "Can't allocate memory for scatterlist\n");
  1235. return -ENOMEM;
  1236. }
  1237. }
  1238. ibmvfc_map_sg_list(scmd, sg_mapped, evt->ext_list);
  1239. data->va = evt->ext_list_token;
  1240. data->len = sg_mapped * sizeof(struct srp_direct_buf);
  1241. data->key = 0;
  1242. return 0;
  1243. }
  1244. /**
  1245. * ibmvfc_timeout - Internal command timeout handler
  1246. * @evt: struct ibmvfc_event that timed out
  1247. *
  1248. * Called when an internally generated command times out
  1249. **/
  1250. static void ibmvfc_timeout(struct ibmvfc_event *evt)
  1251. {
  1252. struct ibmvfc_host *vhost = evt->vhost;
  1253. dev_err(vhost->dev, "Command timed out (%p). Resetting connection\n", evt);
  1254. ibmvfc_reset_host(vhost);
  1255. }
  1256. /**
  1257. * ibmvfc_send_event - Transforms event to u64 array and calls send_crq()
  1258. * @evt: event to be sent
  1259. * @vhost: ibmvfc host struct
  1260. * @timeout: timeout in seconds - 0 means do not time command
  1261. *
  1262. * Returns the value returned from ibmvfc_send_crq(). (Zero for success)
  1263. **/
  1264. static int ibmvfc_send_event(struct ibmvfc_event *evt,
  1265. struct ibmvfc_host *vhost, unsigned long timeout)
  1266. {
  1267. u64 *crq_as_u64 = (u64 *) &evt->crq;
  1268. int rc;
  1269. /* Copy the IU into the transfer area */
  1270. *evt->xfer_iu = evt->iu;
  1271. if (evt->crq.format == IBMVFC_CMD_FORMAT)
  1272. evt->xfer_iu->cmd.tag = (u64)evt;
  1273. else if (evt->crq.format == IBMVFC_MAD_FORMAT)
  1274. evt->xfer_iu->mad_common.tag = (u64)evt;
  1275. else
  1276. BUG();
  1277. list_add_tail(&evt->queue, &vhost->sent);
  1278. init_timer(&evt->timer);
  1279. if (timeout) {
  1280. evt->timer.data = (unsigned long) evt;
  1281. evt->timer.expires = jiffies + (timeout * HZ);
  1282. evt->timer.function = (void (*)(unsigned long))ibmvfc_timeout;
  1283. add_timer(&evt->timer);
  1284. }
  1285. mb();
  1286. if ((rc = ibmvfc_send_crq(vhost, crq_as_u64[0], crq_as_u64[1]))) {
  1287. list_del(&evt->queue);
  1288. del_timer(&evt->timer);
  1289. /* If send_crq returns H_CLOSED, return SCSI_MLQUEUE_HOST_BUSY.
  1290. * Firmware will send a CRQ with a transport event (0xFF) to
  1291. * tell this client what has happened to the transport. This
  1292. * will be handled in ibmvfc_handle_crq()
  1293. */
  1294. if (rc == H_CLOSED) {
  1295. if (printk_ratelimit())
  1296. dev_warn(vhost->dev, "Send warning. Receive queue closed, will retry.\n");
  1297. if (evt->cmnd)
  1298. scsi_dma_unmap(evt->cmnd);
  1299. ibmvfc_free_event(evt);
  1300. return SCSI_MLQUEUE_HOST_BUSY;
  1301. }
  1302. dev_err(vhost->dev, "Send error (rc=%d)\n", rc);
  1303. if (evt->cmnd) {
  1304. evt->cmnd->result = DID_ERROR << 16;
  1305. evt->done = ibmvfc_scsi_eh_done;
  1306. } else
  1307. evt->xfer_iu->mad_common.status = IBMVFC_MAD_CRQ_ERROR;
  1308. evt->done(evt);
  1309. } else
  1310. ibmvfc_trc_start(evt);
  1311. return 0;
  1312. }
  1313. /**
  1314. * ibmvfc_log_error - Log an error for the failed command if appropriate
  1315. * @evt: ibmvfc event to log
  1316. *
  1317. **/
  1318. static void ibmvfc_log_error(struct ibmvfc_event *evt)
  1319. {
  1320. struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
  1321. struct ibmvfc_host *vhost = evt->vhost;
  1322. struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
  1323. struct scsi_cmnd *cmnd = evt->cmnd;
  1324. const char *err = unknown_error;
  1325. int index = ibmvfc_get_err_index(vfc_cmd->status, vfc_cmd->error);
  1326. int logerr = 0;
  1327. int rsp_code = 0;
  1328. if (index >= 0) {
  1329. logerr = cmd_status[index].log;
  1330. err = cmd_status[index].name;
  1331. }
  1332. if (!logerr && (vhost->log_level <= (IBMVFC_DEFAULT_LOG_LEVEL + 1)))
  1333. return;
  1334. if (rsp->flags & FCP_RSP_LEN_VALID)
  1335. rsp_code = rsp->data.info.rsp_code;
  1336. scmd_printk(KERN_ERR, cmnd, "Command (%02X) failed: %s (%x:%x) "
  1337. "flags: %x fcp_rsp: %x, resid=%d, scsi_status: %x\n",
  1338. cmnd->cmnd[0], err, vfc_cmd->status, vfc_cmd->error,
  1339. rsp->flags, rsp_code, scsi_get_resid(cmnd), rsp->scsi_status);
  1340. }
  1341. /**
  1342. * ibmvfc_relogin - Log back into the specified device
  1343. * @sdev: scsi device struct
  1344. *
  1345. **/
  1346. static void ibmvfc_relogin(struct scsi_device *sdev)
  1347. {
  1348. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  1349. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  1350. struct ibmvfc_target *tgt;
  1351. list_for_each_entry(tgt, &vhost->targets, queue) {
  1352. if (rport == tgt->rport) {
  1353. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  1354. break;
  1355. }
  1356. }
  1357. ibmvfc_reinit_host(vhost);
  1358. }
  1359. /**
  1360. * ibmvfc_scsi_done - Handle responses from commands
  1361. * @evt: ibmvfc event to be handled
  1362. *
  1363. * Used as a callback when sending scsi cmds.
  1364. **/
  1365. static void ibmvfc_scsi_done(struct ibmvfc_event *evt)
  1366. {
  1367. struct ibmvfc_cmd *vfc_cmd = &evt->xfer_iu->cmd;
  1368. struct ibmvfc_fcp_rsp *rsp = &vfc_cmd->rsp;
  1369. struct scsi_cmnd *cmnd = evt->cmnd;
  1370. u32 rsp_len = 0;
  1371. u32 sense_len = rsp->fcp_sense_len;
  1372. if (cmnd) {
  1373. if (vfc_cmd->response_flags & IBMVFC_ADAPTER_RESID_VALID)
  1374. scsi_set_resid(cmnd, vfc_cmd->adapter_resid);
  1375. else if (rsp->flags & FCP_RESID_UNDER)
  1376. scsi_set_resid(cmnd, rsp->fcp_resid);
  1377. else
  1378. scsi_set_resid(cmnd, 0);
  1379. if (vfc_cmd->status) {
  1380. cmnd->result = ibmvfc_get_err_result(vfc_cmd);
  1381. if (rsp->flags & FCP_RSP_LEN_VALID)
  1382. rsp_len = rsp->fcp_rsp_len;
  1383. if ((sense_len + rsp_len) > SCSI_SENSE_BUFFERSIZE)
  1384. sense_len = SCSI_SENSE_BUFFERSIZE - rsp_len;
  1385. if ((rsp->flags & FCP_SNS_LEN_VALID) && rsp->fcp_sense_len && rsp_len <= 8)
  1386. memcpy(cmnd->sense_buffer, rsp->data.sense + rsp_len, sense_len);
  1387. if ((vfc_cmd->status & IBMVFC_VIOS_FAILURE) && (vfc_cmd->error == IBMVFC_PLOGI_REQUIRED))
  1388. ibmvfc_relogin(cmnd->device);
  1389. if (!cmnd->result && (!scsi_get_resid(cmnd) || (rsp->flags & FCP_RESID_OVER)))
  1390. cmnd->result = (DID_ERROR << 16);
  1391. ibmvfc_log_error(evt);
  1392. }
  1393. if (!cmnd->result &&
  1394. (scsi_bufflen(cmnd) - scsi_get_resid(cmnd) < cmnd->underflow))
  1395. cmnd->result = (DID_ERROR << 16);
  1396. scsi_dma_unmap(cmnd);
  1397. cmnd->scsi_done(cmnd);
  1398. }
  1399. if (evt->eh_comp)
  1400. complete(evt->eh_comp);
  1401. ibmvfc_free_event(evt);
  1402. }
  1403. /**
  1404. * ibmvfc_host_chkready - Check if the host can accept commands
  1405. * @vhost: struct ibmvfc host
  1406. *
  1407. * Returns:
  1408. * 1 if host can accept command / 0 if not
  1409. **/
  1410. static inline int ibmvfc_host_chkready(struct ibmvfc_host *vhost)
  1411. {
  1412. int result = 0;
  1413. switch (vhost->state) {
  1414. case IBMVFC_LINK_DEAD:
  1415. case IBMVFC_HOST_OFFLINE:
  1416. result = DID_NO_CONNECT << 16;
  1417. break;
  1418. case IBMVFC_NO_CRQ:
  1419. case IBMVFC_INITIALIZING:
  1420. case IBMVFC_HALTED:
  1421. case IBMVFC_LINK_DOWN:
  1422. result = DID_REQUEUE << 16;
  1423. break;
  1424. case IBMVFC_ACTIVE:
  1425. result = 0;
  1426. break;
  1427. };
  1428. return result;
  1429. }
  1430. /**
  1431. * ibmvfc_queuecommand - The queuecommand function of the scsi template
  1432. * @cmnd: struct scsi_cmnd to be executed
  1433. * @done: Callback function to be called when cmnd is completed
  1434. *
  1435. * Returns:
  1436. * 0 on success / other on failure
  1437. **/
  1438. static int ibmvfc_queuecommand_lck(struct scsi_cmnd *cmnd,
  1439. void (*done) (struct scsi_cmnd *))
  1440. {
  1441. struct ibmvfc_host *vhost = shost_priv(cmnd->device->host);
  1442. struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
  1443. struct ibmvfc_cmd *vfc_cmd;
  1444. struct ibmvfc_event *evt;
  1445. u8 tag[2];
  1446. int rc;
  1447. if (unlikely((rc = fc_remote_port_chkready(rport))) ||
  1448. unlikely((rc = ibmvfc_host_chkready(vhost)))) {
  1449. cmnd->result = rc;
  1450. done(cmnd);
  1451. return 0;
  1452. }
  1453. cmnd->result = (DID_OK << 16);
  1454. evt = ibmvfc_get_event(vhost);
  1455. ibmvfc_init_event(evt, ibmvfc_scsi_done, IBMVFC_CMD_FORMAT);
  1456. evt->cmnd = cmnd;
  1457. cmnd->scsi_done = done;
  1458. vfc_cmd = &evt->iu.cmd;
  1459. memset(vfc_cmd, 0, sizeof(*vfc_cmd));
  1460. vfc_cmd->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
  1461. vfc_cmd->resp.len = sizeof(vfc_cmd->rsp);
  1462. vfc_cmd->frame_type = IBMVFC_SCSI_FCP_TYPE;
  1463. vfc_cmd->payload_len = sizeof(vfc_cmd->iu);
  1464. vfc_cmd->resp_len = sizeof(vfc_cmd->rsp);
  1465. vfc_cmd->cancel_key = (unsigned long)cmnd->device->hostdata;
  1466. vfc_cmd->tgt_scsi_id = rport->port_id;
  1467. vfc_cmd->iu.xfer_len = scsi_bufflen(cmnd);
  1468. int_to_scsilun(cmnd->device->lun, &vfc_cmd->iu.lun);
  1469. memcpy(vfc_cmd->iu.cdb, cmnd->cmnd, cmnd->cmd_len);
  1470. if (scsi_populate_tag_msg(cmnd, tag)) {
  1471. vfc_cmd->task_tag = tag[1];
  1472. switch (tag[0]) {
  1473. case MSG_SIMPLE_TAG:
  1474. vfc_cmd->iu.pri_task_attr = IBMVFC_SIMPLE_TASK;
  1475. break;
  1476. case MSG_HEAD_TAG:
  1477. vfc_cmd->iu.pri_task_attr = IBMVFC_HEAD_OF_QUEUE;
  1478. break;
  1479. case MSG_ORDERED_TAG:
  1480. vfc_cmd->iu.pri_task_attr = IBMVFC_ORDERED_TASK;
  1481. break;
  1482. };
  1483. }
  1484. if (likely(!(rc = ibmvfc_map_sg_data(cmnd, evt, vfc_cmd, vhost->dev))))
  1485. return ibmvfc_send_event(evt, vhost, 0);
  1486. ibmvfc_free_event(evt);
  1487. if (rc == -ENOMEM)
  1488. return SCSI_MLQUEUE_HOST_BUSY;
  1489. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1490. scmd_printk(KERN_ERR, cmnd,
  1491. "Failed to map DMA buffer for command. rc=%d\n", rc);
  1492. cmnd->result = DID_ERROR << 16;
  1493. done(cmnd);
  1494. return 0;
  1495. }
  1496. static DEF_SCSI_QCMD(ibmvfc_queuecommand)
  1497. /**
  1498. * ibmvfc_sync_completion - Signal that a synchronous command has completed
  1499. * @evt: ibmvfc event struct
  1500. *
  1501. **/
  1502. static void ibmvfc_sync_completion(struct ibmvfc_event *evt)
  1503. {
  1504. /* copy the response back */
  1505. if (evt->sync_iu)
  1506. *evt->sync_iu = *evt->xfer_iu;
  1507. complete(&evt->comp);
  1508. }
  1509. /**
  1510. * ibmvfc_bsg_timeout_done - Completion handler for cancelling BSG commands
  1511. * @evt: struct ibmvfc_event
  1512. *
  1513. **/
  1514. static void ibmvfc_bsg_timeout_done(struct ibmvfc_event *evt)
  1515. {
  1516. struct ibmvfc_host *vhost = evt->vhost;
  1517. ibmvfc_free_event(evt);
  1518. vhost->aborting_passthru = 0;
  1519. dev_info(vhost->dev, "Passthru command cancelled\n");
  1520. }
  1521. /**
  1522. * ibmvfc_bsg_timeout - Handle a BSG timeout
  1523. * @job: struct fc_bsg_job that timed out
  1524. *
  1525. * Returns:
  1526. * 0 on success / other on failure
  1527. **/
  1528. static int ibmvfc_bsg_timeout(struct fc_bsg_job *job)
  1529. {
  1530. struct ibmvfc_host *vhost = shost_priv(job->shost);
  1531. unsigned long port_id = (unsigned long)job->dd_data;
  1532. struct ibmvfc_event *evt;
  1533. struct ibmvfc_tmf *tmf;
  1534. unsigned long flags;
  1535. int rc;
  1536. ENTER;
  1537. spin_lock_irqsave(vhost->host->host_lock, flags);
  1538. if (vhost->aborting_passthru || vhost->state != IBMVFC_ACTIVE) {
  1539. __ibmvfc_reset_host(vhost);
  1540. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1541. return 0;
  1542. }
  1543. vhost->aborting_passthru = 1;
  1544. evt = ibmvfc_get_event(vhost);
  1545. ibmvfc_init_event(evt, ibmvfc_bsg_timeout_done, IBMVFC_MAD_FORMAT);
  1546. tmf = &evt->iu.tmf;
  1547. memset(tmf, 0, sizeof(*tmf));
  1548. tmf->common.version = 1;
  1549. tmf->common.opcode = IBMVFC_TMF_MAD;
  1550. tmf->common.length = sizeof(*tmf);
  1551. tmf->scsi_id = port_id;
  1552. tmf->cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
  1553. tmf->my_cancel_key = IBMVFC_INTERNAL_CANCEL_KEY;
  1554. rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1555. if (rc != 0) {
  1556. vhost->aborting_passthru = 0;
  1557. dev_err(vhost->dev, "Failed to send cancel event. rc=%d\n", rc);
  1558. rc = -EIO;
  1559. } else
  1560. dev_info(vhost->dev, "Cancelling passthru command to port id 0x%lx\n",
  1561. port_id);
  1562. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1563. LEAVE;
  1564. return rc;
  1565. }
  1566. /**
  1567. * ibmvfc_bsg_plogi - PLOGI into a target to handle a BSG command
  1568. * @vhost: struct ibmvfc_host to send command
  1569. * @port_id: port ID to send command
  1570. *
  1571. * Returns:
  1572. * 0 on success / other on failure
  1573. **/
  1574. static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
  1575. {
  1576. struct ibmvfc_port_login *plogi;
  1577. struct ibmvfc_target *tgt;
  1578. struct ibmvfc_event *evt;
  1579. union ibmvfc_iu rsp_iu;
  1580. unsigned long flags;
  1581. int rc = 0, issue_login = 1;
  1582. ENTER;
  1583. spin_lock_irqsave(vhost->host->host_lock, flags);
  1584. list_for_each_entry(tgt, &vhost->targets, queue) {
  1585. if (tgt->scsi_id == port_id) {
  1586. issue_login = 0;
  1587. break;
  1588. }
  1589. }
  1590. if (!issue_login)
  1591. goto unlock_out;
  1592. if (unlikely((rc = ibmvfc_host_chkready(vhost))))
  1593. goto unlock_out;
  1594. evt = ibmvfc_get_event(vhost);
  1595. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
  1596. plogi = &evt->iu.plogi;
  1597. memset(plogi, 0, sizeof(*plogi));
  1598. plogi->common.version = 1;
  1599. plogi->common.opcode = IBMVFC_PORT_LOGIN;
  1600. plogi->common.length = sizeof(*plogi);
  1601. plogi->scsi_id = port_id;
  1602. evt->sync_iu = &rsp_iu;
  1603. init_completion(&evt->comp);
  1604. rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1605. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1606. if (rc)
  1607. return -EIO;
  1608. wait_for_completion(&evt->comp);
  1609. if (rsp_iu.plogi.common.status)
  1610. rc = -EIO;
  1611. spin_lock_irqsave(vhost->host->host_lock, flags);
  1612. ibmvfc_free_event(evt);
  1613. unlock_out:
  1614. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1615. LEAVE;
  1616. return rc;
  1617. }
  1618. /**
  1619. * ibmvfc_bsg_request - Handle a BSG request
  1620. * @job: struct fc_bsg_job to be executed
  1621. *
  1622. * Returns:
  1623. * 0 on success / other on failure
  1624. **/
  1625. static int ibmvfc_bsg_request(struct fc_bsg_job *job)
  1626. {
  1627. struct ibmvfc_host *vhost = shost_priv(job->shost);
  1628. struct fc_rport *rport = job->rport;
  1629. struct ibmvfc_passthru_mad *mad;
  1630. struct ibmvfc_event *evt;
  1631. union ibmvfc_iu rsp_iu;
  1632. unsigned long flags, port_id = -1;
  1633. unsigned int code = job->request->msgcode;
  1634. int rc = 0, req_seg, rsp_seg, issue_login = 0;
  1635. u32 fc_flags, rsp_len;
  1636. ENTER;
  1637. job->reply->reply_payload_rcv_len = 0;
  1638. if (rport)
  1639. port_id = rport->port_id;
  1640. switch (code) {
  1641. case FC_BSG_HST_ELS_NOLOGIN:
  1642. port_id = (job->request->rqst_data.h_els.port_id[0] << 16) |
  1643. (job->request->rqst_data.h_els.port_id[1] << 8) |
  1644. job->request->rqst_data.h_els.port_id[2];
  1645. case FC_BSG_RPT_ELS:
  1646. fc_flags = IBMVFC_FC_ELS;
  1647. break;
  1648. case FC_BSG_HST_CT:
  1649. issue_login = 1;
  1650. port_id = (job->request->rqst_data.h_ct.port_id[0] << 16) |
  1651. (job->request->rqst_data.h_ct.port_id[1] << 8) |
  1652. job->request->rqst_data.h_ct.port_id[2];
  1653. case FC_BSG_RPT_CT:
  1654. fc_flags = IBMVFC_FC_CT_IU;
  1655. break;
  1656. default:
  1657. return -ENOTSUPP;
  1658. };
  1659. if (port_id == -1)
  1660. return -EINVAL;
  1661. if (!mutex_trylock(&vhost->passthru_mutex))
  1662. return -EBUSY;
  1663. job->dd_data = (void *)port_id;
  1664. req_seg = dma_map_sg(vhost->dev, job->request_payload.sg_list,
  1665. job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1666. if (!req_seg) {
  1667. mutex_unlock(&vhost->passthru_mutex);
  1668. return -ENOMEM;
  1669. }
  1670. rsp_seg = dma_map_sg(vhost->dev, job->reply_payload.sg_list,
  1671. job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  1672. if (!rsp_seg) {
  1673. dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
  1674. job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1675. mutex_unlock(&vhost->passthru_mutex);
  1676. return -ENOMEM;
  1677. }
  1678. if (req_seg > 1 || rsp_seg > 1) {
  1679. rc = -EINVAL;
  1680. goto out;
  1681. }
  1682. if (issue_login)
  1683. rc = ibmvfc_bsg_plogi(vhost, port_id);
  1684. spin_lock_irqsave(vhost->host->host_lock, flags);
  1685. if (unlikely(rc || (rport && (rc = fc_remote_port_chkready(rport)))) ||
  1686. unlikely((rc = ibmvfc_host_chkready(vhost)))) {
  1687. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1688. goto out;
  1689. }
  1690. evt = ibmvfc_get_event(vhost);
  1691. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
  1692. mad = &evt->iu.passthru;
  1693. memset(mad, 0, sizeof(*mad));
  1694. mad->common.version = 1;
  1695. mad->common.opcode = IBMVFC_PASSTHRU;
  1696. mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
  1697. mad->cmd_ioba.va = (u64)evt->crq.ioba +
  1698. offsetof(struct ibmvfc_passthru_mad, iu);
  1699. mad->cmd_ioba.len = sizeof(mad->iu);
  1700. mad->iu.cmd_len = job->request_payload.payload_len;
  1701. mad->iu.rsp_len = job->reply_payload.payload_len;
  1702. mad->iu.flags = fc_flags;
  1703. mad->iu.cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
  1704. mad->iu.cmd.va = sg_dma_address(job->request_payload.sg_list);
  1705. mad->iu.cmd.len = sg_dma_len(job->request_payload.sg_list);
  1706. mad->iu.rsp.va = sg_dma_address(job->reply_payload.sg_list);
  1707. mad->iu.rsp.len = sg_dma_len(job->reply_payload.sg_list);
  1708. mad->iu.scsi_id = port_id;
  1709. mad->iu.tag = (u64)evt;
  1710. rsp_len = mad->iu.rsp.len;
  1711. evt->sync_iu = &rsp_iu;
  1712. init_completion(&evt->comp);
  1713. rc = ibmvfc_send_event(evt, vhost, 0);
  1714. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1715. if (rc) {
  1716. rc = -EIO;
  1717. goto out;
  1718. }
  1719. wait_for_completion(&evt->comp);
  1720. if (rsp_iu.passthru.common.status)
  1721. rc = -EIO;
  1722. else
  1723. job->reply->reply_payload_rcv_len = rsp_len;
  1724. spin_lock_irqsave(vhost->host->host_lock, flags);
  1725. ibmvfc_free_event(evt);
  1726. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1727. job->reply->result = rc;
  1728. job->job_done(job);
  1729. rc = 0;
  1730. out:
  1731. dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
  1732. job->request_payload.sg_cnt, DMA_TO_DEVICE);
  1733. dma_unmap_sg(vhost->dev, job->reply_payload.sg_list,
  1734. job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  1735. mutex_unlock(&vhost->passthru_mutex);
  1736. LEAVE;
  1737. return rc;
  1738. }
  1739. /**
  1740. * ibmvfc_reset_device - Reset the device with the specified reset type
  1741. * @sdev: scsi device to reset
  1742. * @type: reset type
  1743. * @desc: reset type description for log messages
  1744. *
  1745. * Returns:
  1746. * 0 on success / other on failure
  1747. **/
  1748. static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
  1749. {
  1750. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  1751. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  1752. struct ibmvfc_cmd *tmf;
  1753. struct ibmvfc_event *evt = NULL;
  1754. union ibmvfc_iu rsp_iu;
  1755. struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
  1756. int rsp_rc = -EBUSY;
  1757. unsigned long flags;
  1758. int rsp_code = 0;
  1759. spin_lock_irqsave(vhost->host->host_lock, flags);
  1760. if (vhost->state == IBMVFC_ACTIVE) {
  1761. evt = ibmvfc_get_event(vhost);
  1762. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
  1763. tmf = &evt->iu.cmd;
  1764. memset(tmf, 0, sizeof(*tmf));
  1765. tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
  1766. tmf->resp.len = sizeof(tmf->rsp);
  1767. tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
  1768. tmf->payload_len = sizeof(tmf->iu);
  1769. tmf->resp_len = sizeof(tmf->rsp);
  1770. tmf->cancel_key = (unsigned long)sdev->hostdata;
  1771. tmf->tgt_scsi_id = rport->port_id;
  1772. int_to_scsilun(sdev->lun, &tmf->iu.lun);
  1773. tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
  1774. tmf->iu.tmf_flags = type;
  1775. evt->sync_iu = &rsp_iu;
  1776. init_completion(&evt->comp);
  1777. rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1778. }
  1779. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1780. if (rsp_rc != 0) {
  1781. sdev_printk(KERN_ERR, sdev, "Failed to send %s reset event. rc=%d\n",
  1782. desc, rsp_rc);
  1783. return -EIO;
  1784. }
  1785. sdev_printk(KERN_INFO, sdev, "Resetting %s\n", desc);
  1786. wait_for_completion(&evt->comp);
  1787. if (rsp_iu.cmd.status)
  1788. rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
  1789. if (rsp_code) {
  1790. if (fc_rsp->flags & FCP_RSP_LEN_VALID)
  1791. rsp_code = fc_rsp->data.info.rsp_code;
  1792. sdev_printk(KERN_ERR, sdev, "%s reset failed: %s (%x:%x) "
  1793. "flags: %x fcp_rsp: %x, scsi_status: %x\n",
  1794. desc, ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
  1795. rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
  1796. fc_rsp->scsi_status);
  1797. rsp_rc = -EIO;
  1798. } else
  1799. sdev_printk(KERN_INFO, sdev, "%s reset successful\n", desc);
  1800. spin_lock_irqsave(vhost->host->host_lock, flags);
  1801. ibmvfc_free_event(evt);
  1802. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1803. return rsp_rc;
  1804. }
  1805. /**
  1806. * ibmvfc_match_rport - Match function for specified remote port
  1807. * @evt: ibmvfc event struct
  1808. * @device: device to match (rport)
  1809. *
  1810. * Returns:
  1811. * 1 if event matches rport / 0 if event does not match rport
  1812. **/
  1813. static int ibmvfc_match_rport(struct ibmvfc_event *evt, void *rport)
  1814. {
  1815. struct fc_rport *cmd_rport;
  1816. if (evt->cmnd) {
  1817. cmd_rport = starget_to_rport(scsi_target(evt->cmnd->device));
  1818. if (cmd_rport == rport)
  1819. return 1;
  1820. }
  1821. return 0;
  1822. }
  1823. /**
  1824. * ibmvfc_match_target - Match function for specified target
  1825. * @evt: ibmvfc event struct
  1826. * @device: device to match (starget)
  1827. *
  1828. * Returns:
  1829. * 1 if event matches starget / 0 if event does not match starget
  1830. **/
  1831. static int ibmvfc_match_target(struct ibmvfc_event *evt, void *device)
  1832. {
  1833. if (evt->cmnd && scsi_target(evt->cmnd->device) == device)
  1834. return 1;
  1835. return 0;
  1836. }
  1837. /**
  1838. * ibmvfc_match_lun - Match function for specified LUN
  1839. * @evt: ibmvfc event struct
  1840. * @device: device to match (sdev)
  1841. *
  1842. * Returns:
  1843. * 1 if event matches sdev / 0 if event does not match sdev
  1844. **/
  1845. static int ibmvfc_match_lun(struct ibmvfc_event *evt, void *device)
  1846. {
  1847. if (evt->cmnd && evt->cmnd->device == device)
  1848. return 1;
  1849. return 0;
  1850. }
  1851. /**
  1852. * ibmvfc_wait_for_ops - Wait for ops to complete
  1853. * @vhost: ibmvfc host struct
  1854. * @device: device to match (starget or sdev)
  1855. * @match: match function
  1856. *
  1857. * Returns:
  1858. * SUCCESS / FAILED
  1859. **/
  1860. static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
  1861. int (*match) (struct ibmvfc_event *, void *))
  1862. {
  1863. struct ibmvfc_event *evt;
  1864. DECLARE_COMPLETION_ONSTACK(comp);
  1865. int wait;
  1866. unsigned long flags;
  1867. signed long timeout = IBMVFC_ABORT_WAIT_TIMEOUT * HZ;
  1868. ENTER;
  1869. do {
  1870. wait = 0;
  1871. spin_lock_irqsave(vhost->host->host_lock, flags);
  1872. list_for_each_entry(evt, &vhost->sent, queue) {
  1873. if (match(evt, device)) {
  1874. evt->eh_comp = &comp;
  1875. wait++;
  1876. }
  1877. }
  1878. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1879. if (wait) {
  1880. timeout = wait_for_completion_timeout(&comp, timeout);
  1881. if (!timeout) {
  1882. wait = 0;
  1883. spin_lock_irqsave(vhost->host->host_lock, flags);
  1884. list_for_each_entry(evt, &vhost->sent, queue) {
  1885. if (match(evt, device)) {
  1886. evt->eh_comp = NULL;
  1887. wait++;
  1888. }
  1889. }
  1890. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1891. if (wait)
  1892. dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
  1893. LEAVE;
  1894. return wait ? FAILED : SUCCESS;
  1895. }
  1896. }
  1897. } while (wait);
  1898. LEAVE;
  1899. return SUCCESS;
  1900. }
  1901. /**
  1902. * ibmvfc_cancel_all - Cancel all outstanding commands to the device
  1903. * @sdev: scsi device to cancel commands
  1904. * @type: type of error recovery being performed
  1905. *
  1906. * This sends a cancel to the VIOS for the specified device. This does
  1907. * NOT send any abort to the actual device. That must be done separately.
  1908. *
  1909. * Returns:
  1910. * 0 on success / other on failure
  1911. **/
  1912. static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
  1913. {
  1914. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  1915. struct scsi_target *starget = scsi_target(sdev);
  1916. struct fc_rport *rport = starget_to_rport(starget);
  1917. struct ibmvfc_tmf *tmf;
  1918. struct ibmvfc_event *evt, *found_evt;
  1919. union ibmvfc_iu rsp;
  1920. int rsp_rc = -EBUSY;
  1921. unsigned long flags;
  1922. u16 status;
  1923. ENTER;
  1924. spin_lock_irqsave(vhost->host->host_lock, flags);
  1925. found_evt = NULL;
  1926. list_for_each_entry(evt, &vhost->sent, queue) {
  1927. if (evt->cmnd && evt->cmnd->device == sdev) {
  1928. found_evt = evt;
  1929. break;
  1930. }
  1931. }
  1932. if (!found_evt) {
  1933. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  1934. sdev_printk(KERN_INFO, sdev, "No events found to cancel\n");
  1935. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1936. return 0;
  1937. }
  1938. if (vhost->state == IBMVFC_ACTIVE) {
  1939. evt = ibmvfc_get_event(vhost);
  1940. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
  1941. tmf = &evt->iu.tmf;
  1942. memset(tmf, 0, sizeof(*tmf));
  1943. tmf->common.version = 1;
  1944. tmf->common.opcode = IBMVFC_TMF_MAD;
  1945. tmf->common.length = sizeof(*tmf);
  1946. tmf->scsi_id = rport->port_id;
  1947. int_to_scsilun(sdev->lun, &tmf->lun);
  1948. tmf->flags = (type | IBMVFC_TMF_LUA_VALID);
  1949. tmf->cancel_key = (unsigned long)sdev->hostdata;
  1950. tmf->my_cancel_key = (unsigned long)starget->hostdata;
  1951. evt->sync_iu = &rsp;
  1952. init_completion(&evt->comp);
  1953. rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
  1954. }
  1955. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1956. if (rsp_rc != 0) {
  1957. sdev_printk(KERN_ERR, sdev, "Failed to send cancel event. rc=%d\n", rsp_rc);
  1958. return -EIO;
  1959. }
  1960. sdev_printk(KERN_INFO, sdev, "Cancelling outstanding commands.\n");
  1961. wait_for_completion(&evt->comp);
  1962. status = rsp.mad_common.status;
  1963. spin_lock_irqsave(vhost->host->host_lock, flags);
  1964. ibmvfc_free_event(evt);
  1965. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  1966. if (status != IBMVFC_MAD_SUCCESS) {
  1967. sdev_printk(KERN_WARNING, sdev, "Cancel failed with rc=%x\n", status);
  1968. return -EIO;
  1969. }
  1970. sdev_printk(KERN_INFO, sdev, "Successfully cancelled outstanding commands\n");
  1971. return 0;
  1972. }
  1973. /**
  1974. * ibmvfc_match_key - Match function for specified cancel key
  1975. * @evt: ibmvfc event struct
  1976. * @key: cancel key to match
  1977. *
  1978. * Returns:
  1979. * 1 if event matches key / 0 if event does not match key
  1980. **/
  1981. static int ibmvfc_match_key(struct ibmvfc_event *evt, void *key)
  1982. {
  1983. unsigned long cancel_key = (unsigned long)key;
  1984. if (evt->crq.format == IBMVFC_CMD_FORMAT &&
  1985. evt->iu.cmd.cancel_key == cancel_key)
  1986. return 1;
  1987. return 0;
  1988. }
  1989. /**
  1990. * ibmvfc_abort_task_set - Abort outstanding commands to the device
  1991. * @sdev: scsi device to abort commands
  1992. *
  1993. * This sends an Abort Task Set to the VIOS for the specified device. This does
  1994. * NOT send any cancel to the VIOS. That must be done separately.
  1995. *
  1996. * Returns:
  1997. * 0 on success / other on failure
  1998. **/
  1999. static int ibmvfc_abort_task_set(struct scsi_device *sdev)
  2000. {
  2001. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2002. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  2003. struct ibmvfc_cmd *tmf;
  2004. struct ibmvfc_event *evt, *found_evt;
  2005. union ibmvfc_iu rsp_iu;
  2006. struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
  2007. int rc, rsp_rc = -EBUSY;
  2008. unsigned long flags, timeout = IBMVFC_ABORT_TIMEOUT;
  2009. int rsp_code = 0;
  2010. spin_lock_irqsave(vhost->host->host_lock, flags);
  2011. found_evt = NULL;
  2012. list_for_each_entry(evt, &vhost->sent, queue) {
  2013. if (evt->cmnd && evt->cmnd->device == sdev) {
  2014. found_evt = evt;
  2015. break;
  2016. }
  2017. }
  2018. if (!found_evt) {
  2019. if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
  2020. sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
  2021. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2022. return 0;
  2023. }
  2024. if (vhost->state == IBMVFC_ACTIVE) {
  2025. evt = ibmvfc_get_event(vhost);
  2026. ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
  2027. tmf = &evt->iu.cmd;
  2028. memset(tmf, 0, sizeof(*tmf));
  2029. tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
  2030. tmf->resp.len = sizeof(tmf->rsp);
  2031. tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
  2032. tmf->payload_len = sizeof(tmf->iu);
  2033. tmf->resp_len = sizeof(tmf->rsp);
  2034. tmf->cancel_key = (unsigned long)sdev->hostdata;
  2035. tmf->tgt_scsi_id = rport->port_id;
  2036. int_to_scsilun(sdev->lun, &tmf->iu.lun);
  2037. tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
  2038. tmf->iu.tmf_flags = IBMVFC_ABORT_TASK_SET;
  2039. evt->sync_iu = &rsp_iu;
  2040. init_completion(&evt->comp);
  2041. rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
  2042. }
  2043. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2044. if (rsp_rc != 0) {
  2045. sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
  2046. return -EIO;
  2047. }
  2048. sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
  2049. timeout = wait_for_completion_timeout(&evt->comp, timeout);
  2050. if (!timeout) {
  2051. rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
  2052. if (!rc) {
  2053. rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
  2054. if (rc == SUCCESS)
  2055. rc = 0;
  2056. }
  2057. if (rc) {
  2058. sdev_printk(KERN_INFO, sdev, "Cancel failed, resetting host\n");
  2059. ibmvfc_reset_host(vhost);
  2060. rsp_rc = 0;
  2061. goto out;
  2062. }
  2063. }
  2064. if (rsp_iu.cmd.status)
  2065. rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
  2066. if (rsp_code) {
  2067. if (fc_rsp->flags & FCP_RSP_LEN_VALID)
  2068. rsp_code = fc_rsp->data.info.rsp_code;
  2069. sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
  2070. "flags: %x fcp_rsp: %x, scsi_status: %x\n",
  2071. ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
  2072. rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
  2073. fc_rsp->scsi_status);
  2074. rsp_rc = -EIO;
  2075. } else
  2076. sdev_printk(KERN_INFO, sdev, "Abort successful\n");
  2077. out:
  2078. spin_lock_irqsave(vhost->host->host_lock, flags);
  2079. ibmvfc_free_event(evt);
  2080. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2081. return rsp_rc;
  2082. }
  2083. /**
  2084. * ibmvfc_eh_abort_handler - Abort a command
  2085. * @cmd: scsi command to abort
  2086. *
  2087. * Returns:
  2088. * SUCCESS / FAILED
  2089. **/
  2090. static int ibmvfc_eh_abort_handler(struct scsi_cmnd *cmd)
  2091. {
  2092. struct scsi_device *sdev = cmd->device;
  2093. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2094. int cancel_rc, abort_rc;
  2095. int rc = FAILED;
  2096. ENTER;
  2097. fc_block_scsi_eh(cmd);
  2098. ibmvfc_wait_while_resetting(vhost);
  2099. cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
  2100. abort_rc = ibmvfc_abort_task_set(sdev);
  2101. if (!cancel_rc && !abort_rc)
  2102. rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
  2103. LEAVE;
  2104. return rc;
  2105. }
  2106. /**
  2107. * ibmvfc_eh_device_reset_handler - Reset a single LUN
  2108. * @cmd: scsi command struct
  2109. *
  2110. * Returns:
  2111. * SUCCESS / FAILED
  2112. **/
  2113. static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
  2114. {
  2115. struct scsi_device *sdev = cmd->device;
  2116. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2117. int cancel_rc, reset_rc;
  2118. int rc = FAILED;
  2119. ENTER;
  2120. fc_block_scsi_eh(cmd);
  2121. ibmvfc_wait_while_resetting(vhost);
  2122. cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_LUN_RESET);
  2123. reset_rc = ibmvfc_reset_device(sdev, IBMVFC_LUN_RESET, "LUN");
  2124. if (!cancel_rc && !reset_rc)
  2125. rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
  2126. LEAVE;
  2127. return rc;
  2128. }
  2129. /**
  2130. * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
  2131. * @sdev: scsi device struct
  2132. * @data: return code
  2133. *
  2134. **/
  2135. static void ibmvfc_dev_cancel_all_reset(struct scsi_device *sdev, void *data)
  2136. {
  2137. unsigned long *rc = data;
  2138. *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_TGT_RESET);
  2139. }
  2140. /**
  2141. * ibmvfc_eh_target_reset_handler - Reset the target
  2142. * @cmd: scsi command struct
  2143. *
  2144. * Returns:
  2145. * SUCCESS / FAILED
  2146. **/
  2147. static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
  2148. {
  2149. struct scsi_device *sdev = cmd->device;
  2150. struct ibmvfc_host *vhost = shost_priv(sdev->host);
  2151. struct scsi_target *starget = scsi_target(sdev);
  2152. int reset_rc;
  2153. int rc = FAILED;
  2154. unsigned long cancel_rc = 0;
  2155. ENTER;
  2156. fc_block_scsi_eh(cmd);
  2157. ibmvfc_wait_while_resetting(vhost);
  2158. starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_reset);
  2159. reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
  2160. if (!cancel_rc && !reset_rc)
  2161. rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
  2162. LEAVE;
  2163. return rc;
  2164. }
  2165. /**
  2166. * ibmvfc_eh_host_reset_handler - Reset the connection to the server
  2167. * @cmd: struct scsi_cmnd having problems
  2168. *
  2169. **/
  2170. static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd *cmd)
  2171. {
  2172. int rc;
  2173. struct ibmvfc_host *vhost = shost_priv(cmd->device->host);
  2174. fc_block_scsi_eh(cmd);
  2175. dev_err(vhost->dev, "Resetting connection due to error recovery\n");
  2176. rc = ibmvfc_issue_fc_host_lip(vhost->host);
  2177. return rc ? FAILED : SUCCESS;
  2178. }
  2179. /**
  2180. * ibmvfc_terminate_rport_io - Terminate all pending I/O to the rport.
  2181. * @rport: rport struct
  2182. *
  2183. * Return value:
  2184. * none
  2185. **/
  2186. static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
  2187. {
  2188. struct Scsi_Host *shost = rport_to_shost(rport);
  2189. struct ibmvfc_host *vhost = shost_priv(shost);
  2190. struct fc_rport *dev_rport;
  2191. struct scsi_device *sdev;
  2192. unsigned long rc;
  2193. ENTER;
  2194. shost_for_each_device(sdev, shost) {
  2195. dev_rport = starget_to_rport(scsi_target(sdev));
  2196. if (dev_rport != rport)
  2197. continue;
  2198. ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
  2199. ibmvfc_abort_task_set(sdev);
  2200. }
  2201. rc = ibmvfc_wait_for_ops(vhost, rport, ibmvfc_match_rport);
  2202. if (rc == FAILED)
  2203. ibmvfc_issue_fc_host_lip(shost);
  2204. LEAVE;
  2205. }
  2206. static const struct ibmvfc_async_desc ae_desc [] = {
  2207. { "PLOGI", IBMVFC_AE_ELS_PLOGI, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2208. { "LOGO", IBMVFC_AE_ELS_LOGO, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2209. { "PRLO", IBMVFC_AE_ELS_PRLO, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2210. { "N-Port SCN", IBMVFC_AE_SCN_NPORT, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2211. { "Group SCN", IBMVFC_AE_SCN_GROUP, IBMVFC_DEFAULT_LOG_LEVEL + 1 },
  2212. { "Domain SCN", IBMVFC_AE_SCN_DOMAIN, IBMVFC_DEFAULT_LOG_LEVEL },
  2213. { "Fabric SCN", IBMVFC_AE_SCN_FABRIC, IBMVFC_DEFAULT_LOG_LEVEL },
  2214. { "Link Up", IBMVFC_AE_LINK_UP, IBMVFC_DEFAULT_LOG_LEVEL },
  2215. { "Link Down", IBMVFC_AE_LINK_DOWN, IBMVFC_DEFAULT_LOG_LEVEL },
  2216. { "Link Dead", IBMVFC_AE_LINK_DEAD, IBMVFC_DEFAULT_LOG_LEVEL },
  2217. { "Halt", IBMVFC_AE_HALT, IBMVFC_DEFAULT_LOG_LEVEL },
  2218. { "Resume", IBMVFC_AE_RESUME, IBMVFC_DEFAULT_LOG_LEVEL },
  2219. { "Adapter Failed", IBMVFC_AE_ADAPTER_FAILED, IBMVFC_DEFAULT_LOG_LEVEL },
  2220. };
  2221. static const struct ibmvfc_async_desc unknown_ae = {
  2222. "Unknown async", 0, IBMVFC_DEFAULT_LOG_LEVEL
  2223. };
  2224. /**
  2225. * ibmvfc_get_ae_desc - Get text description for async event
  2226. * @ae: async event
  2227. *
  2228. **/
  2229. static const struct ibmvfc_async_desc *ibmvfc_get_ae_desc(u64 ae)
  2230. {
  2231. int i;
  2232. for (i = 0; i < ARRAY_SIZE(ae_desc); i++)
  2233. if (ae_desc[i].ae == ae)
  2234. return &ae_desc[i];
  2235. return &unknown_ae;
  2236. }
  2237. static const struct {
  2238. enum ibmvfc_ae_link_state state;
  2239. const char *desc;
  2240. } link_desc [] = {
  2241. { IBMVFC_AE_LS_LINK_UP, " link up" },
  2242. { IBMVFC_AE_LS_LINK_BOUNCED, " link bounced" },
  2243. { IBMVFC_AE_LS_LINK_DOWN, " link down" },
  2244. { IBMVFC_AE_LS_LINK_DEAD, " link dead" },
  2245. };
  2246. /**
  2247. * ibmvfc_get_link_state - Get text description for link state
  2248. * @state: link state
  2249. *
  2250. **/
  2251. static const char *ibmvfc_get_link_state(enum ibmvfc_ae_link_state state)
  2252. {
  2253. int i;
  2254. for (i = 0; i < ARRAY_SIZE(link_desc); i++)
  2255. if (link_desc[i].state == state)
  2256. return link_desc[i].desc;
  2257. return "";
  2258. }
  2259. /**
  2260. * ibmvfc_handle_async - Handle an async event from the adapter
  2261. * @crq: crq to process
  2262. * @vhost: ibmvfc host struct
  2263. *
  2264. **/
  2265. static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
  2266. struct ibmvfc_host *vhost)
  2267. {
  2268. const struct ibmvfc_async_desc *desc = ibmvfc_get_ae_desc(crq->event);
  2269. struct ibmvfc_target *tgt;
  2270. ibmvfc_log(vhost, desc->log_level, "%s event received. scsi_id: %llx, wwpn: %llx,"
  2271. " node_name: %llx%s\n", desc->desc, crq->scsi_id, crq->wwpn, crq->node_name,
  2272. ibmvfc_get_link_state(crq->link_state));
  2273. switch (crq->event) {
  2274. case IBMVFC_AE_RESUME:
  2275. switch (crq->link_state) {
  2276. case IBMVFC_AE_LS_LINK_DOWN:
  2277. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2278. break;
  2279. case IBMVFC_AE_LS_LINK_DEAD:
  2280. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  2281. break;
  2282. case IBMVFC_AE_LS_LINK_UP:
  2283. case IBMVFC_AE_LS_LINK_BOUNCED:
  2284. default:
  2285. vhost->events_to_log |= IBMVFC_AE_LINKUP;
  2286. vhost->delay_init = 1;
  2287. __ibmvfc_reset_host(vhost);
  2288. break;
  2289. };
  2290. break;
  2291. case IBMVFC_AE_LINK_UP:
  2292. vhost->events_to_log |= IBMVFC_AE_LINKUP;
  2293. vhost->delay_init = 1;
  2294. __ibmvfc_reset_host(vhost);
  2295. break;
  2296. case IBMVFC_AE_SCN_FABRIC:
  2297. case IBMVFC_AE_SCN_DOMAIN:
  2298. vhost->events_to_log |= IBMVFC_AE_RSCN;
  2299. vhost->delay_init = 1;
  2300. __ibmvfc_reset_host(vhost);
  2301. break;
  2302. case IBMVFC_AE_SCN_NPORT:
  2303. case IBMVFC_AE_SCN_GROUP:
  2304. vhost->events_to_log |= IBMVFC_AE_RSCN;
  2305. ibmvfc_reinit_host(vhost);
  2306. break;
  2307. case IBMVFC_AE_ELS_LOGO:
  2308. case IBMVFC_AE_ELS_PRLO:
  2309. case IBMVFC_AE_ELS_PLOGI:
  2310. list_for_each_entry(tgt, &vhost->targets, queue) {
  2311. if (!crq->scsi_id && !crq->wwpn && !crq->node_name)
  2312. break;
  2313. if (crq->scsi_id && tgt->scsi_id != crq->scsi_id)
  2314. continue;
  2315. if (crq->wwpn && tgt->ids.port_name != crq->wwpn)
  2316. continue;
  2317. if (crq->node_name && tgt->ids.node_name != crq->node_name)
  2318. continue;
  2319. if (tgt->need_login && crq->event == IBMVFC_AE_ELS_LOGO)
  2320. tgt->logo_rcvd = 1;
  2321. if (!tgt->need_login || crq->event == IBMVFC_AE_ELS_PLOGI) {
  2322. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2323. ibmvfc_reinit_host(vhost);
  2324. }
  2325. }
  2326. break;
  2327. case IBMVFC_AE_LINK_DOWN:
  2328. case IBMVFC_AE_ADAPTER_FAILED:
  2329. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2330. break;
  2331. case IBMVFC_AE_LINK_DEAD:
  2332. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  2333. break;
  2334. case IBMVFC_AE_HALT:
  2335. ibmvfc_link_down(vhost, IBMVFC_HALTED);
  2336. break;
  2337. default:
  2338. dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
  2339. break;
  2340. };
  2341. }
  2342. /**
  2343. * ibmvfc_handle_crq - Handles and frees received events in the CRQ
  2344. * @crq: Command/Response queue
  2345. * @vhost: ibmvfc host struct
  2346. *
  2347. **/
  2348. static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
  2349. {
  2350. long rc;
  2351. struct ibmvfc_event *evt = (struct ibmvfc_event *)crq->ioba;
  2352. switch (crq->valid) {
  2353. case IBMVFC_CRQ_INIT_RSP:
  2354. switch (crq->format) {
  2355. case IBMVFC_CRQ_INIT:
  2356. dev_info(vhost->dev, "Partner initialized\n");
  2357. /* Send back a response */
  2358. rc = ibmvfc_send_crq_init_complete(vhost);
  2359. if (rc == 0)
  2360. ibmvfc_init_host(vhost);
  2361. else
  2362. dev_err(vhost->dev, "Unable to send init rsp. rc=%ld\n", rc);
  2363. break;
  2364. case IBMVFC_CRQ_INIT_COMPLETE:
  2365. dev_info(vhost->dev, "Partner initialization complete\n");
  2366. ibmvfc_init_host(vhost);
  2367. break;
  2368. default:
  2369. dev_err(vhost->dev, "Unknown crq message type: %d\n", crq->format);
  2370. }
  2371. return;
  2372. case IBMVFC_CRQ_XPORT_EVENT:
  2373. vhost->state = IBMVFC_NO_CRQ;
  2374. vhost->logged_in = 0;
  2375. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  2376. if (crq->format == IBMVFC_PARTITION_MIGRATED) {
  2377. /* We need to re-setup the interpartition connection */
  2378. dev_info(vhost->dev, "Re-enabling adapter\n");
  2379. vhost->client_migrated = 1;
  2380. ibmvfc_purge_requests(vhost, DID_REQUEUE);
  2381. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2382. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_REENABLE);
  2383. } else {
  2384. dev_err(vhost->dev, "Virtual adapter failed (rc=%d)\n", crq->format);
  2385. ibmvfc_purge_requests(vhost, DID_ERROR);
  2386. ibmvfc_link_down(vhost, IBMVFC_LINK_DOWN);
  2387. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_RESET);
  2388. }
  2389. return;
  2390. case IBMVFC_CRQ_CMD_RSP:
  2391. break;
  2392. default:
  2393. dev_err(vhost->dev, "Got an invalid message type 0x%02x\n", crq->valid);
  2394. return;
  2395. }
  2396. if (crq->format == IBMVFC_ASYNC_EVENT)
  2397. return;
  2398. /* The only kind of payload CRQs we should get are responses to
  2399. * things we send. Make sure this response is to something we
  2400. * actually sent
  2401. */
  2402. if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
  2403. dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
  2404. crq->ioba);
  2405. return;
  2406. }
  2407. if (unlikely(atomic_read(&evt->free))) {
  2408. dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
  2409. crq->ioba);
  2410. return;
  2411. }
  2412. del_timer(&evt->timer);
  2413. list_del(&evt->queue);
  2414. ibmvfc_trc_end(evt);
  2415. evt->done(evt);
  2416. }
  2417. /**
  2418. * ibmvfc_scan_finished - Check if the device scan is done.
  2419. * @shost: scsi host struct
  2420. * @time: current elapsed time
  2421. *
  2422. * Returns:
  2423. * 0 if scan is not done / 1 if scan is done
  2424. **/
  2425. static int ibmvfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
  2426. {
  2427. unsigned long flags;
  2428. struct ibmvfc_host *vhost = shost_priv(shost);
  2429. int done = 0;
  2430. spin_lock_irqsave(shost->host_lock, flags);
  2431. if (time >= (init_timeout * HZ)) {
  2432. dev_info(vhost->dev, "Scan taking longer than %d seconds, "
  2433. "continuing initialization\n", init_timeout);
  2434. done = 1;
  2435. }
  2436. if (vhost->scan_complete)
  2437. done = 1;
  2438. spin_unlock_irqrestore(shost->host_lock, flags);
  2439. return done;
  2440. }
  2441. /**
  2442. * ibmvfc_slave_alloc - Setup the device's task set value
  2443. * @sdev: struct scsi_device device to configure
  2444. *
  2445. * Set the device's task set value so that error handling works as
  2446. * expected.
  2447. *
  2448. * Returns:
  2449. * 0 on success / -ENXIO if device does not exist
  2450. **/
  2451. static int ibmvfc_slave_alloc(struct scsi_device *sdev)
  2452. {
  2453. struct Scsi_Host *shost = sdev->host;
  2454. struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
  2455. struct ibmvfc_host *vhost = shost_priv(shost);
  2456. unsigned long flags = 0;
  2457. if (!rport || fc_remote_port_chkready(rport))
  2458. return -ENXIO;
  2459. spin_lock_irqsave(shost->host_lock, flags);
  2460. sdev->hostdata = (void *)(unsigned long)vhost->task_set++;
  2461. spin_unlock_irqrestore(shost->host_lock, flags);
  2462. return 0;
  2463. }
  2464. /**
  2465. * ibmvfc_target_alloc - Setup the target's task set value
  2466. * @starget: struct scsi_target
  2467. *
  2468. * Set the target's task set value so that error handling works as
  2469. * expected.
  2470. *
  2471. * Returns:
  2472. * 0 on success / -ENXIO if device does not exist
  2473. **/
  2474. static int ibmvfc_target_alloc(struct scsi_target *starget)
  2475. {
  2476. struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
  2477. struct ibmvfc_host *vhost = shost_priv(shost);
  2478. unsigned long flags = 0;
  2479. spin_lock_irqsave(shost->host_lock, flags);
  2480. starget->hostdata = (void *)(unsigned long)vhost->task_set++;
  2481. spin_unlock_irqrestore(shost->host_lock, flags);
  2482. return 0;
  2483. }
  2484. /**
  2485. * ibmvfc_slave_configure - Configure the device
  2486. * @sdev: struct scsi_device device to configure
  2487. *
  2488. * Enable allow_restart for a device if it is a disk. Adjust the
  2489. * queue_depth here also.
  2490. *
  2491. * Returns:
  2492. * 0
  2493. **/
  2494. static int ibmvfc_slave_configure(struct scsi_device *sdev)
  2495. {
  2496. struct Scsi_Host *shost = sdev->host;
  2497. unsigned long flags = 0;
  2498. spin_lock_irqsave(shost->host_lock, flags);
  2499. if (sdev->type == TYPE_DISK)
  2500. sdev->allow_restart = 1;
  2501. if (sdev->tagged_supported) {
  2502. scsi_set_tag_type(sdev, MSG_SIMPLE_TAG);
  2503. scsi_activate_tcq(sdev, sdev->queue_depth);
  2504. } else
  2505. scsi_deactivate_tcq(sdev, sdev->queue_depth);
  2506. spin_unlock_irqrestore(shost->host_lock, flags);
  2507. return 0;
  2508. }
  2509. /**
  2510. * ibmvfc_change_queue_depth - Change the device's queue depth
  2511. * @sdev: scsi device struct
  2512. * @qdepth: depth to set
  2513. * @reason: calling context
  2514. *
  2515. * Return value:
  2516. * actual depth set
  2517. **/
  2518. static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth,
  2519. int reason)
  2520. {
  2521. if (reason != SCSI_QDEPTH_DEFAULT)
  2522. return -EOPNOTSUPP;
  2523. if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
  2524. qdepth = IBMVFC_MAX_CMDS_PER_LUN;
  2525. scsi_adjust_queue_depth(sdev, 0, qdepth);
  2526. return sdev->queue_depth;
  2527. }
  2528. /**
  2529. * ibmvfc_change_queue_type - Change the device's queue type
  2530. * @sdev: scsi device struct
  2531. * @tag_type: type of tags to use
  2532. *
  2533. * Return value:
  2534. * actual queue type set
  2535. **/
  2536. static int ibmvfc_change_queue_type(struct scsi_device *sdev, int tag_type)
  2537. {
  2538. if (sdev->tagged_supported) {
  2539. scsi_set_tag_type(sdev, tag_type);
  2540. if (tag_type)
  2541. scsi_activate_tcq(sdev, sdev->queue_depth);
  2542. else
  2543. scsi_deactivate_tcq(sdev, sdev->queue_depth);
  2544. } else
  2545. tag_type = 0;
  2546. return tag_type;
  2547. }
  2548. static ssize_t ibmvfc_show_host_partition_name(struct device *dev,
  2549. struct device_attribute *attr, char *buf)
  2550. {
  2551. struct Scsi_Host *shost = class_to_shost(dev);
  2552. struct ibmvfc_host *vhost = shost_priv(shost);
  2553. return snprintf(buf, PAGE_SIZE, "%s\n",
  2554. vhost->login_buf->resp.partition_name);
  2555. }
  2556. static ssize_t ibmvfc_show_host_device_name(struct device *dev,
  2557. struct device_attribute *attr, char *buf)
  2558. {
  2559. struct Scsi_Host *shost = class_to_shost(dev);
  2560. struct ibmvfc_host *vhost = shost_priv(shost);
  2561. return snprintf(buf, PAGE_SIZE, "%s\n",
  2562. vhost->login_buf->resp.device_name);
  2563. }
  2564. static ssize_t ibmvfc_show_host_loc_code(struct device *dev,
  2565. struct device_attribute *attr, char *buf)
  2566. {
  2567. struct Scsi_Host *shost = class_to_shost(dev);
  2568. struct ibmvfc_host *vhost = shost_priv(shost);
  2569. return snprintf(buf, PAGE_SIZE, "%s\n",
  2570. vhost->login_buf->resp.port_loc_code);
  2571. }
  2572. static ssize_t ibmvfc_show_host_drc_name(struct device *dev,
  2573. struct device_attribute *attr, char *buf)
  2574. {
  2575. struct Scsi_Host *shost = class_to_shost(dev);
  2576. struct ibmvfc_host *vhost = shost_priv(shost);
  2577. return snprintf(buf, PAGE_SIZE, "%s\n",
  2578. vhost->login_buf->resp.drc_name);
  2579. }
  2580. static ssize_t ibmvfc_show_host_npiv_version(struct device *dev,
  2581. struct device_attribute *attr, char *buf)
  2582. {
  2583. struct Scsi_Host *shost = class_to_shost(dev);
  2584. struct ibmvfc_host *vhost = shost_priv(shost);
  2585. return snprintf(buf, PAGE_SIZE, "%d\n", vhost->login_buf->resp.version);
  2586. }
  2587. static ssize_t ibmvfc_show_host_capabilities(struct device *dev,
  2588. struct device_attribute *attr, char *buf)
  2589. {
  2590. struct Scsi_Host *shost = class_to_shost(dev);
  2591. struct ibmvfc_host *vhost = shost_priv(shost);
  2592. return snprintf(buf, PAGE_SIZE, "%llx\n", vhost->login_buf->resp.capabilities);
  2593. }
  2594. /**
  2595. * ibmvfc_show_log_level - Show the adapter's error logging level
  2596. * @dev: class device struct
  2597. * @buf: buffer
  2598. *
  2599. * Return value:
  2600. * number of bytes printed to buffer
  2601. **/
  2602. static ssize_t ibmvfc_show_log_level(struct device *dev,
  2603. struct device_attribute *attr, char *buf)
  2604. {
  2605. struct Scsi_Host *shost = class_to_shost(dev);
  2606. struct ibmvfc_host *vhost = shost_priv(shost);
  2607. unsigned long flags = 0;
  2608. int len;
  2609. spin_lock_irqsave(shost->host_lock, flags);
  2610. len = snprintf(buf, PAGE_SIZE, "%d\n", vhost->log_level);
  2611. spin_unlock_irqrestore(shost->host_lock, flags);
  2612. return len;
  2613. }
  2614. /**
  2615. * ibmvfc_store_log_level - Change the adapter's error logging level
  2616. * @dev: class device struct
  2617. * @buf: buffer
  2618. *
  2619. * Return value:
  2620. * number of bytes printed to buffer
  2621. **/
  2622. static ssize_t ibmvfc_store_log_level(struct device *dev,
  2623. struct device_attribute *attr,
  2624. const char *buf, size_t count)
  2625. {
  2626. struct Scsi_Host *shost = class_to_shost(dev);
  2627. struct ibmvfc_host *vhost = shost_priv(shost);
  2628. unsigned long flags = 0;
  2629. spin_lock_irqsave(shost->host_lock, flags);
  2630. vhost->log_level = simple_strtoul(buf, NULL, 10);
  2631. spin_unlock_irqrestore(shost->host_lock, flags);
  2632. return strlen(buf);
  2633. }
  2634. static DEVICE_ATTR(partition_name, S_IRUGO, ibmvfc_show_host_partition_name, NULL);
  2635. static DEVICE_ATTR(device_name, S_IRUGO, ibmvfc_show_host_device_name, NULL);
  2636. static DEVICE_ATTR(port_loc_code, S_IRUGO, ibmvfc_show_host_loc_code, NULL);
  2637. static DEVICE_ATTR(drc_name, S_IRUGO, ibmvfc_show_host_drc_name, NULL);
  2638. static DEVICE_ATTR(npiv_version, S_IRUGO, ibmvfc_show_host_npiv_version, NULL);
  2639. static DEVICE_ATTR(capabilities, S_IRUGO, ibmvfc_show_host_capabilities, NULL);
  2640. static DEVICE_ATTR(log_level, S_IRUGO | S_IWUSR,
  2641. ibmvfc_show_log_level, ibmvfc_store_log_level);
  2642. #ifdef CONFIG_SCSI_IBMVFC_TRACE
  2643. /**
  2644. * ibmvfc_read_trace - Dump the adapter trace
  2645. * @filp: open sysfs file
  2646. * @kobj: kobject struct
  2647. * @bin_attr: bin_attribute struct
  2648. * @buf: buffer
  2649. * @off: offset
  2650. * @count: buffer size
  2651. *
  2652. * Return value:
  2653. * number of bytes printed to buffer
  2654. **/
  2655. static ssize_t ibmvfc_read_trace(struct file *filp, struct kobject *kobj,
  2656. struct bin_attribute *bin_attr,
  2657. char *buf, loff_t off, size_t count)
  2658. {
  2659. struct device *dev = container_of(kobj, struct device, kobj);
  2660. struct Scsi_Host *shost = class_to_shost(dev);
  2661. struct ibmvfc_host *vhost = shost_priv(shost);
  2662. unsigned long flags = 0;
  2663. int size = IBMVFC_TRACE_SIZE;
  2664. char *src = (char *)vhost->trace;
  2665. if (off > size)
  2666. return 0;
  2667. if (off + count > size) {
  2668. size -= off;
  2669. count = size;
  2670. }
  2671. spin_lock_irqsave(shost->host_lock, flags);
  2672. memcpy(buf, &src[off], count);
  2673. spin_unlock_irqrestore(shost->host_lock, flags);
  2674. return count;
  2675. }
  2676. static struct bin_attribute ibmvfc_trace_attr = {
  2677. .attr = {
  2678. .name = "trace",
  2679. .mode = S_IRUGO,
  2680. },
  2681. .size = 0,
  2682. .read = ibmvfc_read_trace,
  2683. };
  2684. #endif
  2685. static struct device_attribute *ibmvfc_attrs[] = {
  2686. &dev_attr_partition_name,
  2687. &dev_attr_device_name,
  2688. &dev_attr_port_loc_code,
  2689. &dev_attr_drc_name,
  2690. &dev_attr_npiv_version,
  2691. &dev_attr_capabilities,
  2692. &dev_attr_log_level,
  2693. NULL
  2694. };
  2695. static struct scsi_host_template driver_template = {
  2696. .module = THIS_MODULE,
  2697. .name = "IBM POWER Virtual FC Adapter",
  2698. .proc_name = IBMVFC_NAME,
  2699. .queuecommand = ibmvfc_queuecommand,
  2700. .eh_abort_handler = ibmvfc_eh_abort_handler,
  2701. .eh_device_reset_handler = ibmvfc_eh_device_reset_handler,
  2702. .eh_target_reset_handler = ibmvfc_eh_target_reset_handler,
  2703. .eh_host_reset_handler = ibmvfc_eh_host_reset_handler,
  2704. .slave_alloc = ibmvfc_slave_alloc,
  2705. .slave_configure = ibmvfc_slave_configure,
  2706. .target_alloc = ibmvfc_target_alloc,
  2707. .scan_finished = ibmvfc_scan_finished,
  2708. .change_queue_depth = ibmvfc_change_queue_depth,
  2709. .change_queue_type = ibmvfc_change_queue_type,
  2710. .cmd_per_lun = 16,
  2711. .can_queue = IBMVFC_MAX_REQUESTS_DEFAULT,
  2712. .this_id = -1,
  2713. .sg_tablesize = SG_ALL,
  2714. .max_sectors = IBMVFC_MAX_SECTORS,
  2715. .use_clustering = ENABLE_CLUSTERING,
  2716. .shost_attrs = ibmvfc_attrs,
  2717. };
  2718. /**
  2719. * ibmvfc_next_async_crq - Returns the next entry in async queue
  2720. * @vhost: ibmvfc host struct
  2721. *
  2722. * Returns:
  2723. * Pointer to next entry in queue / NULL if empty
  2724. **/
  2725. static struct ibmvfc_async_crq *ibmvfc_next_async_crq(struct ibmvfc_host *vhost)
  2726. {
  2727. struct ibmvfc_async_crq_queue *async_crq = &vhost->async_crq;
  2728. struct ibmvfc_async_crq *crq;
  2729. crq = &async_crq->msgs[async_crq->cur];
  2730. if (crq->valid & 0x80) {
  2731. if (++async_crq->cur == async_crq->size)
  2732. async_crq->cur = 0;
  2733. rmb();
  2734. } else
  2735. crq = NULL;
  2736. return crq;
  2737. }
  2738. /**
  2739. * ibmvfc_next_crq - Returns the next entry in message queue
  2740. * @vhost: ibmvfc host struct
  2741. *
  2742. * Returns:
  2743. * Pointer to next entry in queue / NULL if empty
  2744. **/
  2745. static struct ibmvfc_crq *ibmvfc_next_crq(struct ibmvfc_host *vhost)
  2746. {
  2747. struct ibmvfc_crq_queue *queue = &vhost->crq;
  2748. struct ibmvfc_crq *crq;
  2749. crq = &queue->msgs[queue->cur];
  2750. if (crq->valid & 0x80) {
  2751. if (++queue->cur == queue->size)
  2752. queue->cur = 0;
  2753. rmb();
  2754. } else
  2755. crq = NULL;
  2756. return crq;
  2757. }
  2758. /**
  2759. * ibmvfc_interrupt - Interrupt handler
  2760. * @irq: number of irq to handle, not used
  2761. * @dev_instance: ibmvfc_host that received interrupt
  2762. *
  2763. * Returns:
  2764. * IRQ_HANDLED
  2765. **/
  2766. static irqreturn_t ibmvfc_interrupt(int irq, void *dev_instance)
  2767. {
  2768. struct ibmvfc_host *vhost = (struct ibmvfc_host *)dev_instance;
  2769. unsigned long flags;
  2770. spin_lock_irqsave(vhost->host->host_lock, flags);
  2771. vio_disable_interrupts(to_vio_dev(vhost->dev));
  2772. tasklet_schedule(&vhost->tasklet);
  2773. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2774. return IRQ_HANDLED;
  2775. }
  2776. /**
  2777. * ibmvfc_tasklet - Interrupt handler tasklet
  2778. * @data: ibmvfc host struct
  2779. *
  2780. * Returns:
  2781. * Nothing
  2782. **/
  2783. static void ibmvfc_tasklet(void *data)
  2784. {
  2785. struct ibmvfc_host *vhost = data;
  2786. struct vio_dev *vdev = to_vio_dev(vhost->dev);
  2787. struct ibmvfc_crq *crq;
  2788. struct ibmvfc_async_crq *async;
  2789. unsigned long flags;
  2790. int done = 0;
  2791. spin_lock_irqsave(vhost->host->host_lock, flags);
  2792. while (!done) {
  2793. /* Pull all the valid messages off the async CRQ */
  2794. while ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
  2795. ibmvfc_handle_async(async, vhost);
  2796. async->valid = 0;
  2797. wmb();
  2798. }
  2799. /* Pull all the valid messages off the CRQ */
  2800. while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
  2801. ibmvfc_handle_crq(crq, vhost);
  2802. crq->valid = 0;
  2803. wmb();
  2804. }
  2805. vio_enable_interrupts(vdev);
  2806. if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
  2807. vio_disable_interrupts(vdev);
  2808. ibmvfc_handle_async(async, vhost);
  2809. async->valid = 0;
  2810. wmb();
  2811. } else if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
  2812. vio_disable_interrupts(vdev);
  2813. ibmvfc_handle_crq(crq, vhost);
  2814. crq->valid = 0;
  2815. wmb();
  2816. } else
  2817. done = 1;
  2818. }
  2819. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  2820. }
  2821. /**
  2822. * ibmvfc_init_tgt - Set the next init job step for the target
  2823. * @tgt: ibmvfc target struct
  2824. * @job_step: job step to perform
  2825. *
  2826. **/
  2827. static void ibmvfc_init_tgt(struct ibmvfc_target *tgt,
  2828. void (*job_step) (struct ibmvfc_target *))
  2829. {
  2830. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT);
  2831. tgt->job_step = job_step;
  2832. wake_up(&tgt->vhost->work_wait_q);
  2833. }
  2834. /**
  2835. * ibmvfc_retry_tgt_init - Attempt to retry a step in target initialization
  2836. * @tgt: ibmvfc target struct
  2837. * @job_step: initialization job step
  2838. *
  2839. * Returns: 1 if step will be retried / 0 if not
  2840. *
  2841. **/
  2842. static int ibmvfc_retry_tgt_init(struct ibmvfc_target *tgt,
  2843. void (*job_step) (struct ibmvfc_target *))
  2844. {
  2845. if (++tgt->init_retries > IBMVFC_MAX_TGT_INIT_RETRIES) {
  2846. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2847. wake_up(&tgt->vhost->work_wait_q);
  2848. return 0;
  2849. } else
  2850. ibmvfc_init_tgt(tgt, job_step);
  2851. return 1;
  2852. }
  2853. /* Defined in FC-LS */
  2854. static const struct {
  2855. int code;
  2856. int retry;
  2857. int logged_in;
  2858. } prli_rsp [] = {
  2859. { 0, 1, 0 },
  2860. { 1, 0, 1 },
  2861. { 2, 1, 0 },
  2862. { 3, 1, 0 },
  2863. { 4, 0, 0 },
  2864. { 5, 0, 0 },
  2865. { 6, 0, 1 },
  2866. { 7, 0, 0 },
  2867. { 8, 1, 0 },
  2868. };
  2869. /**
  2870. * ibmvfc_get_prli_rsp - Find PRLI response index
  2871. * @flags: PRLI response flags
  2872. *
  2873. **/
  2874. static int ibmvfc_get_prli_rsp(u16 flags)
  2875. {
  2876. int i;
  2877. int code = (flags & 0x0f00) >> 8;
  2878. for (i = 0; i < ARRAY_SIZE(prli_rsp); i++)
  2879. if (prli_rsp[i].code == code)
  2880. return i;
  2881. return 0;
  2882. }
  2883. /**
  2884. * ibmvfc_tgt_prli_done - Completion handler for Process Login
  2885. * @evt: ibmvfc event struct
  2886. *
  2887. **/
  2888. static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
  2889. {
  2890. struct ibmvfc_target *tgt = evt->tgt;
  2891. struct ibmvfc_host *vhost = evt->vhost;
  2892. struct ibmvfc_process_login *rsp = &evt->xfer_iu->prli;
  2893. struct ibmvfc_prli_svc_parms *parms = &rsp->parms;
  2894. u32 status = rsp->common.status;
  2895. int index, level = IBMVFC_DEFAULT_LOG_LEVEL;
  2896. vhost->discovery_threads--;
  2897. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  2898. switch (status) {
  2899. case IBMVFC_MAD_SUCCESS:
  2900. tgt_dbg(tgt, "Process Login succeeded: %X %02X %04X\n",
  2901. parms->type, parms->flags, parms->service_parms);
  2902. if (parms->type == IBMVFC_SCSI_FCP_TYPE) {
  2903. index = ibmvfc_get_prli_rsp(parms->flags);
  2904. if (prli_rsp[index].logged_in) {
  2905. if (parms->flags & IBMVFC_PRLI_EST_IMG_PAIR) {
  2906. tgt->need_login = 0;
  2907. tgt->ids.roles = 0;
  2908. if (parms->service_parms & IBMVFC_PRLI_TARGET_FUNC)
  2909. tgt->ids.roles |= FC_PORT_ROLE_FCP_TARGET;
  2910. if (parms->service_parms & IBMVFC_PRLI_INITIATOR_FUNC)
  2911. tgt->ids.roles |= FC_PORT_ROLE_FCP_INITIATOR;
  2912. tgt->add_rport = 1;
  2913. } else
  2914. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2915. } else if (prli_rsp[index].retry)
  2916. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
  2917. else
  2918. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2919. } else
  2920. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2921. break;
  2922. case IBMVFC_MAD_DRIVER_FAILED:
  2923. break;
  2924. case IBMVFC_MAD_CRQ_ERROR:
  2925. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
  2926. break;
  2927. case IBMVFC_MAD_FAILED:
  2928. default:
  2929. if ((rsp->status & IBMVFC_VIOS_FAILURE) && rsp->error == IBMVFC_PLOGI_REQUIRED)
  2930. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  2931. else if (tgt->logo_rcvd)
  2932. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  2933. else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  2934. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
  2935. else
  2936. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  2937. tgt_log(tgt, level, "Process Login failed: %s (%x:%x) rc=0x%02X\n",
  2938. ibmvfc_get_cmd_error(rsp->status, rsp->error),
  2939. rsp->status, rsp->error, status);
  2940. break;
  2941. };
  2942. kref_put(&tgt->kref, ibmvfc_release_tgt);
  2943. ibmvfc_free_event(evt);
  2944. wake_up(&vhost->work_wait_q);
  2945. }
  2946. /**
  2947. * ibmvfc_tgt_send_prli - Send a process login
  2948. * @tgt: ibmvfc target struct
  2949. *
  2950. **/
  2951. static void ibmvfc_tgt_send_prli(struct ibmvfc_target *tgt)
  2952. {
  2953. struct ibmvfc_process_login *prli;
  2954. struct ibmvfc_host *vhost = tgt->vhost;
  2955. struct ibmvfc_event *evt;
  2956. if (vhost->discovery_threads >= disc_threads)
  2957. return;
  2958. kref_get(&tgt->kref);
  2959. evt = ibmvfc_get_event(vhost);
  2960. vhost->discovery_threads++;
  2961. ibmvfc_init_event(evt, ibmvfc_tgt_prli_done, IBMVFC_MAD_FORMAT);
  2962. evt->tgt = tgt;
  2963. prli = &evt->iu.prli;
  2964. memset(prli, 0, sizeof(*prli));
  2965. prli->common.version = 1;
  2966. prli->common.opcode = IBMVFC_PROCESS_LOGIN;
  2967. prli->common.length = sizeof(*prli);
  2968. prli->scsi_id = tgt->scsi_id;
  2969. prli->parms.type = IBMVFC_SCSI_FCP_TYPE;
  2970. prli->parms.flags = IBMVFC_PRLI_EST_IMG_PAIR;
  2971. prli->parms.service_parms = IBMVFC_PRLI_INITIATOR_FUNC;
  2972. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  2973. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  2974. vhost->discovery_threads--;
  2975. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  2976. kref_put(&tgt->kref, ibmvfc_release_tgt);
  2977. } else
  2978. tgt_dbg(tgt, "Sent process login\n");
  2979. }
  2980. /**
  2981. * ibmvfc_tgt_plogi_done - Completion handler for Port Login
  2982. * @evt: ibmvfc event struct
  2983. *
  2984. **/
  2985. static void ibmvfc_tgt_plogi_done(struct ibmvfc_event *evt)
  2986. {
  2987. struct ibmvfc_target *tgt = evt->tgt;
  2988. struct ibmvfc_host *vhost = evt->vhost;
  2989. struct ibmvfc_port_login *rsp = &evt->xfer_iu->plogi;
  2990. u32 status = rsp->common.status;
  2991. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  2992. vhost->discovery_threads--;
  2993. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  2994. switch (status) {
  2995. case IBMVFC_MAD_SUCCESS:
  2996. tgt_dbg(tgt, "Port Login succeeded\n");
  2997. if (tgt->ids.port_name &&
  2998. tgt->ids.port_name != wwn_to_u64(rsp->service_parms.port_name)) {
  2999. vhost->reinit = 1;
  3000. tgt_dbg(tgt, "Port re-init required\n");
  3001. break;
  3002. }
  3003. tgt->ids.node_name = wwn_to_u64(rsp->service_parms.node_name);
  3004. tgt->ids.port_name = wwn_to_u64(rsp->service_parms.port_name);
  3005. tgt->ids.port_id = tgt->scsi_id;
  3006. memcpy(&tgt->service_parms, &rsp->service_parms,
  3007. sizeof(tgt->service_parms));
  3008. memcpy(&tgt->service_parms_change, &rsp->service_parms_change,
  3009. sizeof(tgt->service_parms_change));
  3010. ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_prli);
  3011. break;
  3012. case IBMVFC_MAD_DRIVER_FAILED:
  3013. break;
  3014. case IBMVFC_MAD_CRQ_ERROR:
  3015. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  3016. break;
  3017. case IBMVFC_MAD_FAILED:
  3018. default:
  3019. if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3020. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
  3021. else
  3022. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3023. tgt_log(tgt, level, "Port Login failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
  3024. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
  3025. ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
  3026. ibmvfc_get_ls_explain(rsp->fc_explain), rsp->fc_explain, status);
  3027. break;
  3028. };
  3029. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3030. ibmvfc_free_event(evt);
  3031. wake_up(&vhost->work_wait_q);
  3032. }
  3033. /**
  3034. * ibmvfc_tgt_send_plogi - Send PLOGI to the specified target
  3035. * @tgt: ibmvfc target struct
  3036. *
  3037. **/
  3038. static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *tgt)
  3039. {
  3040. struct ibmvfc_port_login *plogi;
  3041. struct ibmvfc_host *vhost = tgt->vhost;
  3042. struct ibmvfc_event *evt;
  3043. if (vhost->discovery_threads >= disc_threads)
  3044. return;
  3045. kref_get(&tgt->kref);
  3046. tgt->logo_rcvd = 0;
  3047. evt = ibmvfc_get_event(vhost);
  3048. vhost->discovery_threads++;
  3049. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3050. ibmvfc_init_event(evt, ibmvfc_tgt_plogi_done, IBMVFC_MAD_FORMAT);
  3051. evt->tgt = tgt;
  3052. plogi = &evt->iu.plogi;
  3053. memset(plogi, 0, sizeof(*plogi));
  3054. plogi->common.version = 1;
  3055. plogi->common.opcode = IBMVFC_PORT_LOGIN;
  3056. plogi->common.length = sizeof(*plogi);
  3057. plogi->scsi_id = tgt->scsi_id;
  3058. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3059. vhost->discovery_threads--;
  3060. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3061. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3062. } else
  3063. tgt_dbg(tgt, "Sent port login\n");
  3064. }
  3065. /**
  3066. * ibmvfc_tgt_implicit_logout_done - Completion handler for Implicit Logout MAD
  3067. * @evt: ibmvfc event struct
  3068. *
  3069. **/
  3070. static void ibmvfc_tgt_implicit_logout_done(struct ibmvfc_event *evt)
  3071. {
  3072. struct ibmvfc_target *tgt = evt->tgt;
  3073. struct ibmvfc_host *vhost = evt->vhost;
  3074. struct ibmvfc_implicit_logout *rsp = &evt->xfer_iu->implicit_logout;
  3075. u32 status = rsp->common.status;
  3076. vhost->discovery_threads--;
  3077. ibmvfc_free_event(evt);
  3078. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3079. switch (status) {
  3080. case IBMVFC_MAD_SUCCESS:
  3081. tgt_dbg(tgt, "Implicit Logout succeeded\n");
  3082. break;
  3083. case IBMVFC_MAD_DRIVER_FAILED:
  3084. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3085. wake_up(&vhost->work_wait_q);
  3086. return;
  3087. case IBMVFC_MAD_FAILED:
  3088. default:
  3089. tgt_err(tgt, "Implicit Logout failed: rc=0x%02X\n", status);
  3090. break;
  3091. };
  3092. if (vhost->action == IBMVFC_HOST_ACTION_TGT_INIT)
  3093. ibmvfc_init_tgt(tgt, ibmvfc_tgt_send_plogi);
  3094. else if (vhost->action == IBMVFC_HOST_ACTION_QUERY_TGTS &&
  3095. tgt->scsi_id != tgt->new_scsi_id)
  3096. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3097. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3098. wake_up(&vhost->work_wait_q);
  3099. }
  3100. /**
  3101. * ibmvfc_tgt_implicit_logout - Initiate an Implicit Logout for specified target
  3102. * @tgt: ibmvfc target struct
  3103. *
  3104. **/
  3105. static void ibmvfc_tgt_implicit_logout(struct ibmvfc_target *tgt)
  3106. {
  3107. struct ibmvfc_implicit_logout *mad;
  3108. struct ibmvfc_host *vhost = tgt->vhost;
  3109. struct ibmvfc_event *evt;
  3110. if (vhost->discovery_threads >= disc_threads)
  3111. return;
  3112. kref_get(&tgt->kref);
  3113. evt = ibmvfc_get_event(vhost);
  3114. vhost->discovery_threads++;
  3115. ibmvfc_init_event(evt, ibmvfc_tgt_implicit_logout_done, IBMVFC_MAD_FORMAT);
  3116. evt->tgt = tgt;
  3117. mad = &evt->iu.implicit_logout;
  3118. memset(mad, 0, sizeof(*mad));
  3119. mad->common.version = 1;
  3120. mad->common.opcode = IBMVFC_IMPLICIT_LOGOUT;
  3121. mad->common.length = sizeof(*mad);
  3122. mad->old_scsi_id = tgt->scsi_id;
  3123. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3124. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3125. vhost->discovery_threads--;
  3126. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3127. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3128. } else
  3129. tgt_dbg(tgt, "Sent Implicit Logout\n");
  3130. }
  3131. /**
  3132. * ibmvfc_adisc_needs_plogi - Does device need PLOGI?
  3133. * @mad: ibmvfc passthru mad struct
  3134. * @tgt: ibmvfc target struct
  3135. *
  3136. * Returns:
  3137. * 1 if PLOGI needed / 0 if PLOGI not needed
  3138. **/
  3139. static int ibmvfc_adisc_needs_plogi(struct ibmvfc_passthru_mad *mad,
  3140. struct ibmvfc_target *tgt)
  3141. {
  3142. if (memcmp(&mad->fc_iu.response[2], &tgt->ids.port_name,
  3143. sizeof(tgt->ids.port_name)))
  3144. return 1;
  3145. if (memcmp(&mad->fc_iu.response[4], &tgt->ids.node_name,
  3146. sizeof(tgt->ids.node_name)))
  3147. return 1;
  3148. if (mad->fc_iu.response[6] != tgt->scsi_id)
  3149. return 1;
  3150. return 0;
  3151. }
  3152. /**
  3153. * ibmvfc_tgt_adisc_done - Completion handler for ADISC
  3154. * @evt: ibmvfc event struct
  3155. *
  3156. **/
  3157. static void ibmvfc_tgt_adisc_done(struct ibmvfc_event *evt)
  3158. {
  3159. struct ibmvfc_target *tgt = evt->tgt;
  3160. struct ibmvfc_host *vhost = evt->vhost;
  3161. struct ibmvfc_passthru_mad *mad = &evt->xfer_iu->passthru;
  3162. u32 status = mad->common.status;
  3163. u8 fc_reason, fc_explain;
  3164. vhost->discovery_threads--;
  3165. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3166. del_timer(&tgt->timer);
  3167. switch (status) {
  3168. case IBMVFC_MAD_SUCCESS:
  3169. tgt_dbg(tgt, "ADISC succeeded\n");
  3170. if (ibmvfc_adisc_needs_plogi(mad, tgt))
  3171. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3172. break;
  3173. case IBMVFC_MAD_DRIVER_FAILED:
  3174. break;
  3175. case IBMVFC_MAD_FAILED:
  3176. default:
  3177. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3178. fc_reason = (mad->fc_iu.response[1] & 0x00ff0000) >> 16;
  3179. fc_explain = (mad->fc_iu.response[1] & 0x0000ff00) >> 8;
  3180. tgt_info(tgt, "ADISC failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
  3181. ibmvfc_get_cmd_error(mad->iu.status, mad->iu.error),
  3182. mad->iu.status, mad->iu.error,
  3183. ibmvfc_get_fc_type(fc_reason), fc_reason,
  3184. ibmvfc_get_ls_explain(fc_explain), fc_explain, status);
  3185. break;
  3186. };
  3187. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3188. ibmvfc_free_event(evt);
  3189. wake_up(&vhost->work_wait_q);
  3190. }
  3191. /**
  3192. * ibmvfc_init_passthru - Initialize an event struct for FC passthru
  3193. * @evt: ibmvfc event struct
  3194. *
  3195. **/
  3196. static void ibmvfc_init_passthru(struct ibmvfc_event *evt)
  3197. {
  3198. struct ibmvfc_passthru_mad *mad = &evt->iu.passthru;
  3199. memset(mad, 0, sizeof(*mad));
  3200. mad->common.version = 1;
  3201. mad->common.opcode = IBMVFC_PASSTHRU;
  3202. mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
  3203. mad->cmd_ioba.va = (u64)evt->crq.ioba +
  3204. offsetof(struct ibmvfc_passthru_mad, iu);
  3205. mad->cmd_ioba.len = sizeof(mad->iu);
  3206. mad->iu.cmd_len = sizeof(mad->fc_iu.payload);
  3207. mad->iu.rsp_len = sizeof(mad->fc_iu.response);
  3208. mad->iu.cmd.va = (u64)evt->crq.ioba +
  3209. offsetof(struct ibmvfc_passthru_mad, fc_iu) +
  3210. offsetof(struct ibmvfc_passthru_fc_iu, payload);
  3211. mad->iu.cmd.len = sizeof(mad->fc_iu.payload);
  3212. mad->iu.rsp.va = (u64)evt->crq.ioba +
  3213. offsetof(struct ibmvfc_passthru_mad, fc_iu) +
  3214. offsetof(struct ibmvfc_passthru_fc_iu, response);
  3215. mad->iu.rsp.len = sizeof(mad->fc_iu.response);
  3216. }
  3217. /**
  3218. * ibmvfc_tgt_adisc_cancel_done - Completion handler when cancelling an ADISC
  3219. * @evt: ibmvfc event struct
  3220. *
  3221. * Just cleanup this event struct. Everything else is handled by
  3222. * the ADISC completion handler. If the ADISC never actually comes
  3223. * back, we still have the timer running on the ADISC event struct
  3224. * which will fire and cause the CRQ to get reset.
  3225. *
  3226. **/
  3227. static void ibmvfc_tgt_adisc_cancel_done(struct ibmvfc_event *evt)
  3228. {
  3229. struct ibmvfc_host *vhost = evt->vhost;
  3230. struct ibmvfc_target *tgt = evt->tgt;
  3231. tgt_dbg(tgt, "ADISC cancel complete\n");
  3232. vhost->abort_threads--;
  3233. ibmvfc_free_event(evt);
  3234. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3235. wake_up(&vhost->work_wait_q);
  3236. }
  3237. /**
  3238. * ibmvfc_adisc_timeout - Handle an ADISC timeout
  3239. * @tgt: ibmvfc target struct
  3240. *
  3241. * If an ADISC times out, send a cancel. If the cancel times
  3242. * out, reset the CRQ. When the ADISC comes back as cancelled,
  3243. * log back into the target.
  3244. **/
  3245. static void ibmvfc_adisc_timeout(struct ibmvfc_target *tgt)
  3246. {
  3247. struct ibmvfc_host *vhost = tgt->vhost;
  3248. struct ibmvfc_event *evt;
  3249. struct ibmvfc_tmf *tmf;
  3250. unsigned long flags;
  3251. int rc;
  3252. tgt_dbg(tgt, "ADISC timeout\n");
  3253. spin_lock_irqsave(vhost->host->host_lock, flags);
  3254. if (vhost->abort_threads >= disc_threads ||
  3255. tgt->action != IBMVFC_TGT_ACTION_INIT_WAIT ||
  3256. vhost->state != IBMVFC_INITIALIZING ||
  3257. vhost->action != IBMVFC_HOST_ACTION_QUERY_TGTS) {
  3258. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3259. return;
  3260. }
  3261. vhost->abort_threads++;
  3262. kref_get(&tgt->kref);
  3263. evt = ibmvfc_get_event(vhost);
  3264. ibmvfc_init_event(evt, ibmvfc_tgt_adisc_cancel_done, IBMVFC_MAD_FORMAT);
  3265. evt->tgt = tgt;
  3266. tmf = &evt->iu.tmf;
  3267. memset(tmf, 0, sizeof(*tmf));
  3268. tmf->common.version = 1;
  3269. tmf->common.opcode = IBMVFC_TMF_MAD;
  3270. tmf->common.length = sizeof(*tmf);
  3271. tmf->scsi_id = tgt->scsi_id;
  3272. tmf->cancel_key = tgt->cancel_key;
  3273. rc = ibmvfc_send_event(evt, vhost, default_timeout);
  3274. if (rc) {
  3275. tgt_err(tgt, "Failed to send cancel event for ADISC. rc=%d\n", rc);
  3276. vhost->abort_threads--;
  3277. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3278. __ibmvfc_reset_host(vhost);
  3279. } else
  3280. tgt_dbg(tgt, "Attempting to cancel ADISC\n");
  3281. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3282. }
  3283. /**
  3284. * ibmvfc_tgt_adisc - Initiate an ADISC for specified target
  3285. * @tgt: ibmvfc target struct
  3286. *
  3287. * When sending an ADISC we end up with two timers running. The
  3288. * first timer is the timer in the ibmvfc target struct. If this
  3289. * fires, we send a cancel to the target. The second timer is the
  3290. * timer on the ibmvfc event for the ADISC, which is longer. If that
  3291. * fires, it means the ADISC timed out and our attempt to cancel it
  3292. * also failed, so we need to reset the CRQ.
  3293. **/
  3294. static void ibmvfc_tgt_adisc(struct ibmvfc_target *tgt)
  3295. {
  3296. struct ibmvfc_passthru_mad *mad;
  3297. struct ibmvfc_host *vhost = tgt->vhost;
  3298. struct ibmvfc_event *evt;
  3299. if (vhost->discovery_threads >= disc_threads)
  3300. return;
  3301. kref_get(&tgt->kref);
  3302. evt = ibmvfc_get_event(vhost);
  3303. vhost->discovery_threads++;
  3304. ibmvfc_init_event(evt, ibmvfc_tgt_adisc_done, IBMVFC_MAD_FORMAT);
  3305. evt->tgt = tgt;
  3306. ibmvfc_init_passthru(evt);
  3307. mad = &evt->iu.passthru;
  3308. mad->iu.flags = IBMVFC_FC_ELS;
  3309. mad->iu.scsi_id = tgt->scsi_id;
  3310. mad->iu.cancel_key = tgt->cancel_key;
  3311. mad->fc_iu.payload[0] = IBMVFC_ADISC;
  3312. memcpy(&mad->fc_iu.payload[2], &vhost->login_buf->resp.port_name,
  3313. sizeof(vhost->login_buf->resp.port_name));
  3314. memcpy(&mad->fc_iu.payload[4], &vhost->login_buf->resp.node_name,
  3315. sizeof(vhost->login_buf->resp.node_name));
  3316. mad->fc_iu.payload[6] = vhost->login_buf->resp.scsi_id & 0x00ffffff;
  3317. if (timer_pending(&tgt->timer))
  3318. mod_timer(&tgt->timer, jiffies + (IBMVFC_ADISC_TIMEOUT * HZ));
  3319. else {
  3320. tgt->timer.data = (unsigned long) tgt;
  3321. tgt->timer.expires = jiffies + (IBMVFC_ADISC_TIMEOUT * HZ);
  3322. tgt->timer.function = (void (*)(unsigned long))ibmvfc_adisc_timeout;
  3323. add_timer(&tgt->timer);
  3324. }
  3325. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3326. if (ibmvfc_send_event(evt, vhost, IBMVFC_ADISC_PLUS_CANCEL_TIMEOUT)) {
  3327. vhost->discovery_threads--;
  3328. del_timer(&tgt->timer);
  3329. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3330. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3331. } else
  3332. tgt_dbg(tgt, "Sent ADISC\n");
  3333. }
  3334. /**
  3335. * ibmvfc_tgt_query_target_done - Completion handler for Query Target MAD
  3336. * @evt: ibmvfc event struct
  3337. *
  3338. **/
  3339. static void ibmvfc_tgt_query_target_done(struct ibmvfc_event *evt)
  3340. {
  3341. struct ibmvfc_target *tgt = evt->tgt;
  3342. struct ibmvfc_host *vhost = evt->vhost;
  3343. struct ibmvfc_query_tgt *rsp = &evt->xfer_iu->query_tgt;
  3344. u32 status = rsp->common.status;
  3345. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3346. vhost->discovery_threads--;
  3347. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3348. switch (status) {
  3349. case IBMVFC_MAD_SUCCESS:
  3350. tgt_dbg(tgt, "Query Target succeeded\n");
  3351. tgt->new_scsi_id = rsp->scsi_id;
  3352. if (rsp->scsi_id != tgt->scsi_id)
  3353. ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
  3354. else
  3355. ibmvfc_init_tgt(tgt, ibmvfc_tgt_adisc);
  3356. break;
  3357. case IBMVFC_MAD_DRIVER_FAILED:
  3358. break;
  3359. case IBMVFC_MAD_CRQ_ERROR:
  3360. ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
  3361. break;
  3362. case IBMVFC_MAD_FAILED:
  3363. default:
  3364. if ((rsp->status & IBMVFC_FABRIC_MAPPED) == IBMVFC_FABRIC_MAPPED &&
  3365. rsp->error == IBMVFC_UNABLE_TO_PERFORM_REQ &&
  3366. rsp->fc_explain == IBMVFC_PORT_NAME_NOT_REG)
  3367. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3368. else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3369. level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_query_target);
  3370. else
  3371. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
  3372. tgt_log(tgt, level, "Query Target failed: %s (%x:%x) %s (%x) %s (%x) rc=0x%02X\n",
  3373. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error,
  3374. ibmvfc_get_fc_type(rsp->fc_type), rsp->fc_type,
  3375. ibmvfc_get_gs_explain(rsp->fc_explain), rsp->fc_explain, status);
  3376. break;
  3377. };
  3378. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3379. ibmvfc_free_event(evt);
  3380. wake_up(&vhost->work_wait_q);
  3381. }
  3382. /**
  3383. * ibmvfc_tgt_query_target - Initiate a Query Target for specified target
  3384. * @tgt: ibmvfc target struct
  3385. *
  3386. **/
  3387. static void ibmvfc_tgt_query_target(struct ibmvfc_target *tgt)
  3388. {
  3389. struct ibmvfc_query_tgt *query_tgt;
  3390. struct ibmvfc_host *vhost = tgt->vhost;
  3391. struct ibmvfc_event *evt;
  3392. if (vhost->discovery_threads >= disc_threads)
  3393. return;
  3394. kref_get(&tgt->kref);
  3395. evt = ibmvfc_get_event(vhost);
  3396. vhost->discovery_threads++;
  3397. evt->tgt = tgt;
  3398. ibmvfc_init_event(evt, ibmvfc_tgt_query_target_done, IBMVFC_MAD_FORMAT);
  3399. query_tgt = &evt->iu.query_tgt;
  3400. memset(query_tgt, 0, sizeof(*query_tgt));
  3401. query_tgt->common.version = 1;
  3402. query_tgt->common.opcode = IBMVFC_QUERY_TARGET;
  3403. query_tgt->common.length = sizeof(*query_tgt);
  3404. query_tgt->wwpn = tgt->ids.port_name;
  3405. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
  3406. if (ibmvfc_send_event(evt, vhost, default_timeout)) {
  3407. vhost->discovery_threads--;
  3408. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_NONE);
  3409. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3410. } else
  3411. tgt_dbg(tgt, "Sent Query Target\n");
  3412. }
  3413. /**
  3414. * ibmvfc_alloc_target - Allocate and initialize an ibmvfc target
  3415. * @vhost: ibmvfc host struct
  3416. * @scsi_id: SCSI ID to allocate target for
  3417. *
  3418. * Returns:
  3419. * 0 on success / other on failure
  3420. **/
  3421. static int ibmvfc_alloc_target(struct ibmvfc_host *vhost, u64 scsi_id)
  3422. {
  3423. struct ibmvfc_target *tgt;
  3424. unsigned long flags;
  3425. spin_lock_irqsave(vhost->host->host_lock, flags);
  3426. list_for_each_entry(tgt, &vhost->targets, queue) {
  3427. if (tgt->scsi_id == scsi_id) {
  3428. if (tgt->need_login)
  3429. ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
  3430. goto unlock_out;
  3431. }
  3432. }
  3433. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3434. tgt = mempool_alloc(vhost->tgt_pool, GFP_NOIO);
  3435. if (!tgt) {
  3436. dev_err(vhost->dev, "Target allocation failure for scsi id %08llx\n",
  3437. scsi_id);
  3438. return -ENOMEM;
  3439. }
  3440. memset(tgt, 0, sizeof(*tgt));
  3441. tgt->scsi_id = scsi_id;
  3442. tgt->new_scsi_id = scsi_id;
  3443. tgt->vhost = vhost;
  3444. tgt->need_login = 1;
  3445. tgt->cancel_key = vhost->task_set++;
  3446. init_timer(&tgt->timer);
  3447. kref_init(&tgt->kref);
  3448. ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
  3449. spin_lock_irqsave(vhost->host->host_lock, flags);
  3450. list_add_tail(&tgt->queue, &vhost->targets);
  3451. unlock_out:
  3452. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3453. return 0;
  3454. }
  3455. /**
  3456. * ibmvfc_alloc_targets - Allocate and initialize ibmvfc targets
  3457. * @vhost: ibmvfc host struct
  3458. *
  3459. * Returns:
  3460. * 0 on success / other on failure
  3461. **/
  3462. static int ibmvfc_alloc_targets(struct ibmvfc_host *vhost)
  3463. {
  3464. int i, rc;
  3465. for (i = 0, rc = 0; !rc && i < vhost->num_targets; i++)
  3466. rc = ibmvfc_alloc_target(vhost,
  3467. vhost->disc_buf->scsi_id[i] & IBMVFC_DISC_TGT_SCSI_ID_MASK);
  3468. return rc;
  3469. }
  3470. /**
  3471. * ibmvfc_discover_targets_done - Completion handler for discover targets MAD
  3472. * @evt: ibmvfc event struct
  3473. *
  3474. **/
  3475. static void ibmvfc_discover_targets_done(struct ibmvfc_event *evt)
  3476. {
  3477. struct ibmvfc_host *vhost = evt->vhost;
  3478. struct ibmvfc_discover_targets *rsp = &evt->xfer_iu->discover_targets;
  3479. u32 mad_status = rsp->common.status;
  3480. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3481. switch (mad_status) {
  3482. case IBMVFC_MAD_SUCCESS:
  3483. ibmvfc_dbg(vhost, "Discover Targets succeeded\n");
  3484. vhost->num_targets = rsp->num_written;
  3485. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_ALLOC_TGTS);
  3486. break;
  3487. case IBMVFC_MAD_FAILED:
  3488. level += ibmvfc_retry_host_init(vhost);
  3489. ibmvfc_log(vhost, level, "Discover Targets failed: %s (%x:%x)\n",
  3490. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
  3491. break;
  3492. case IBMVFC_MAD_DRIVER_FAILED:
  3493. break;
  3494. default:
  3495. dev_err(vhost->dev, "Invalid Discover Targets response: 0x%x\n", mad_status);
  3496. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3497. break;
  3498. }
  3499. ibmvfc_free_event(evt);
  3500. wake_up(&vhost->work_wait_q);
  3501. }
  3502. /**
  3503. * ibmvfc_discover_targets - Send Discover Targets MAD
  3504. * @vhost: ibmvfc host struct
  3505. *
  3506. **/
  3507. static void ibmvfc_discover_targets(struct ibmvfc_host *vhost)
  3508. {
  3509. struct ibmvfc_discover_targets *mad;
  3510. struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
  3511. ibmvfc_init_event(evt, ibmvfc_discover_targets_done, IBMVFC_MAD_FORMAT);
  3512. mad = &evt->iu.discover_targets;
  3513. memset(mad, 0, sizeof(*mad));
  3514. mad->common.version = 1;
  3515. mad->common.opcode = IBMVFC_DISC_TARGETS;
  3516. mad->common.length = sizeof(*mad);
  3517. mad->bufflen = vhost->disc_buf_sz;
  3518. mad->buffer.va = vhost->disc_buf_dma;
  3519. mad->buffer.len = vhost->disc_buf_sz;
  3520. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
  3521. if (!ibmvfc_send_event(evt, vhost, default_timeout))
  3522. ibmvfc_dbg(vhost, "Sent discover targets\n");
  3523. else
  3524. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3525. }
  3526. /**
  3527. * ibmvfc_npiv_login_done - Completion handler for NPIV Login
  3528. * @evt: ibmvfc event struct
  3529. *
  3530. **/
  3531. static void ibmvfc_npiv_login_done(struct ibmvfc_event *evt)
  3532. {
  3533. struct ibmvfc_host *vhost = evt->vhost;
  3534. u32 mad_status = evt->xfer_iu->npiv_login.common.status;
  3535. struct ibmvfc_npiv_login_resp *rsp = &vhost->login_buf->resp;
  3536. unsigned int npiv_max_sectors;
  3537. int level = IBMVFC_DEFAULT_LOG_LEVEL;
  3538. switch (mad_status) {
  3539. case IBMVFC_MAD_SUCCESS:
  3540. ibmvfc_free_event(evt);
  3541. break;
  3542. case IBMVFC_MAD_FAILED:
  3543. if (ibmvfc_retry_cmd(rsp->status, rsp->error))
  3544. level += ibmvfc_retry_host_init(vhost);
  3545. else
  3546. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3547. ibmvfc_log(vhost, level, "NPIV Login failed: %s (%x:%x)\n",
  3548. ibmvfc_get_cmd_error(rsp->status, rsp->error), rsp->status, rsp->error);
  3549. ibmvfc_free_event(evt);
  3550. return;
  3551. case IBMVFC_MAD_CRQ_ERROR:
  3552. ibmvfc_retry_host_init(vhost);
  3553. case IBMVFC_MAD_DRIVER_FAILED:
  3554. ibmvfc_free_event(evt);
  3555. return;
  3556. default:
  3557. dev_err(vhost->dev, "Invalid NPIV Login response: 0x%x\n", mad_status);
  3558. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3559. ibmvfc_free_event(evt);
  3560. return;
  3561. }
  3562. vhost->client_migrated = 0;
  3563. if (!(rsp->flags & IBMVFC_NATIVE_FC)) {
  3564. dev_err(vhost->dev, "Virtual adapter does not support FC. %x\n",
  3565. rsp->flags);
  3566. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3567. wake_up(&vhost->work_wait_q);
  3568. return;
  3569. }
  3570. if (rsp->max_cmds <= IBMVFC_NUM_INTERNAL_REQ) {
  3571. dev_err(vhost->dev, "Virtual adapter supported queue depth too small: %d\n",
  3572. rsp->max_cmds);
  3573. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3574. wake_up(&vhost->work_wait_q);
  3575. return;
  3576. }
  3577. vhost->logged_in = 1;
  3578. npiv_max_sectors = min((uint)(rsp->max_dma_len >> 9), IBMVFC_MAX_SECTORS);
  3579. dev_info(vhost->dev, "Host partition: %s, device: %s %s %s max sectors %u\n",
  3580. rsp->partition_name, rsp->device_name, rsp->port_loc_code,
  3581. rsp->drc_name, npiv_max_sectors);
  3582. fc_host_fabric_name(vhost->host) = rsp->node_name;
  3583. fc_host_node_name(vhost->host) = rsp->node_name;
  3584. fc_host_port_name(vhost->host) = rsp->port_name;
  3585. fc_host_port_id(vhost->host) = rsp->scsi_id;
  3586. fc_host_port_type(vhost->host) = FC_PORTTYPE_NPIV;
  3587. fc_host_supported_classes(vhost->host) = 0;
  3588. if (rsp->service_parms.class1_parms[0] & 0x80000000)
  3589. fc_host_supported_classes(vhost->host) |= FC_COS_CLASS1;
  3590. if (rsp->service_parms.class2_parms[0] & 0x80000000)
  3591. fc_host_supported_classes(vhost->host) |= FC_COS_CLASS2;
  3592. if (rsp->service_parms.class3_parms[0] & 0x80000000)
  3593. fc_host_supported_classes(vhost->host) |= FC_COS_CLASS3;
  3594. fc_host_maxframe_size(vhost->host) =
  3595. rsp->service_parms.common.bb_rcv_sz & 0x0fff;
  3596. vhost->host->can_queue = rsp->max_cmds - IBMVFC_NUM_INTERNAL_REQ;
  3597. vhost->host->max_sectors = npiv_max_sectors;
  3598. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
  3599. wake_up(&vhost->work_wait_q);
  3600. }
  3601. /**
  3602. * ibmvfc_npiv_login - Sends NPIV login
  3603. * @vhost: ibmvfc host struct
  3604. *
  3605. **/
  3606. static void ibmvfc_npiv_login(struct ibmvfc_host *vhost)
  3607. {
  3608. struct ibmvfc_npiv_login_mad *mad;
  3609. struct ibmvfc_event *evt = ibmvfc_get_event(vhost);
  3610. ibmvfc_gather_partition_info(vhost);
  3611. ibmvfc_set_login_info(vhost);
  3612. ibmvfc_init_event(evt, ibmvfc_npiv_login_done, IBMVFC_MAD_FORMAT);
  3613. memcpy(vhost->login_buf, &vhost->login_info, sizeof(vhost->login_info));
  3614. mad = &evt->iu.npiv_login;
  3615. memset(mad, 0, sizeof(struct ibmvfc_npiv_login_mad));
  3616. mad->common.version = 1;
  3617. mad->common.opcode = IBMVFC_NPIV_LOGIN;
  3618. mad->common.length = sizeof(struct ibmvfc_npiv_login_mad);
  3619. mad->buffer.va = vhost->login_buf_dma;
  3620. mad->buffer.len = sizeof(*vhost->login_buf);
  3621. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT_WAIT);
  3622. if (!ibmvfc_send_event(evt, vhost, default_timeout))
  3623. ibmvfc_dbg(vhost, "Sent NPIV login\n");
  3624. else
  3625. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3626. };
  3627. /**
  3628. * ibmvfc_npiv_logout_done - Completion handler for NPIV Logout
  3629. * @vhost: ibmvfc host struct
  3630. *
  3631. **/
  3632. static void ibmvfc_npiv_logout_done(struct ibmvfc_event *evt)
  3633. {
  3634. struct ibmvfc_host *vhost = evt->vhost;
  3635. u32 mad_status = evt->xfer_iu->npiv_logout.common.status;
  3636. ibmvfc_free_event(evt);
  3637. switch (mad_status) {
  3638. case IBMVFC_MAD_SUCCESS:
  3639. if (list_empty(&vhost->sent) &&
  3640. vhost->action == IBMVFC_HOST_ACTION_LOGO_WAIT) {
  3641. ibmvfc_init_host(vhost);
  3642. return;
  3643. }
  3644. break;
  3645. case IBMVFC_MAD_FAILED:
  3646. case IBMVFC_MAD_NOT_SUPPORTED:
  3647. case IBMVFC_MAD_CRQ_ERROR:
  3648. case IBMVFC_MAD_DRIVER_FAILED:
  3649. default:
  3650. ibmvfc_dbg(vhost, "NPIV Logout failed. 0x%X\n", mad_status);
  3651. break;
  3652. }
  3653. ibmvfc_hard_reset_host(vhost);
  3654. }
  3655. /**
  3656. * ibmvfc_npiv_logout - Issue an NPIV Logout
  3657. * @vhost: ibmvfc host struct
  3658. *
  3659. **/
  3660. static void ibmvfc_npiv_logout(struct ibmvfc_host *vhost)
  3661. {
  3662. struct ibmvfc_npiv_logout_mad *mad;
  3663. struct ibmvfc_event *evt;
  3664. evt = ibmvfc_get_event(vhost);
  3665. ibmvfc_init_event(evt, ibmvfc_npiv_logout_done, IBMVFC_MAD_FORMAT);
  3666. mad = &evt->iu.npiv_logout;
  3667. memset(mad, 0, sizeof(*mad));
  3668. mad->common.version = 1;
  3669. mad->common.opcode = IBMVFC_NPIV_LOGOUT;
  3670. mad->common.length = sizeof(struct ibmvfc_npiv_logout_mad);
  3671. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_LOGO_WAIT);
  3672. if (!ibmvfc_send_event(evt, vhost, default_timeout))
  3673. ibmvfc_dbg(vhost, "Sent NPIV logout\n");
  3674. else
  3675. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3676. }
  3677. /**
  3678. * ibmvfc_dev_init_to_do - Is there target initialization work to do?
  3679. * @vhost: ibmvfc host struct
  3680. *
  3681. * Returns:
  3682. * 1 if work to do / 0 if not
  3683. **/
  3684. static int ibmvfc_dev_init_to_do(struct ibmvfc_host *vhost)
  3685. {
  3686. struct ibmvfc_target *tgt;
  3687. list_for_each_entry(tgt, &vhost->targets, queue) {
  3688. if (tgt->action == IBMVFC_TGT_ACTION_INIT ||
  3689. tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
  3690. return 1;
  3691. }
  3692. return 0;
  3693. }
  3694. /**
  3695. * __ibmvfc_work_to_do - Is there task level work to do? (no locking)
  3696. * @vhost: ibmvfc host struct
  3697. *
  3698. * Returns:
  3699. * 1 if work to do / 0 if not
  3700. **/
  3701. static int __ibmvfc_work_to_do(struct ibmvfc_host *vhost)
  3702. {
  3703. struct ibmvfc_target *tgt;
  3704. if (kthread_should_stop())
  3705. return 1;
  3706. switch (vhost->action) {
  3707. case IBMVFC_HOST_ACTION_NONE:
  3708. case IBMVFC_HOST_ACTION_INIT_WAIT:
  3709. case IBMVFC_HOST_ACTION_LOGO_WAIT:
  3710. return 0;
  3711. case IBMVFC_HOST_ACTION_TGT_INIT:
  3712. case IBMVFC_HOST_ACTION_QUERY_TGTS:
  3713. if (vhost->discovery_threads == disc_threads)
  3714. return 0;
  3715. list_for_each_entry(tgt, &vhost->targets, queue)
  3716. if (tgt->action == IBMVFC_TGT_ACTION_INIT)
  3717. return 1;
  3718. list_for_each_entry(tgt, &vhost->targets, queue)
  3719. if (tgt->action == IBMVFC_TGT_ACTION_INIT_WAIT)
  3720. return 0;
  3721. return 1;
  3722. case IBMVFC_HOST_ACTION_LOGO:
  3723. case IBMVFC_HOST_ACTION_INIT:
  3724. case IBMVFC_HOST_ACTION_ALLOC_TGTS:
  3725. case IBMVFC_HOST_ACTION_TGT_DEL:
  3726. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  3727. case IBMVFC_HOST_ACTION_QUERY:
  3728. case IBMVFC_HOST_ACTION_RESET:
  3729. case IBMVFC_HOST_ACTION_REENABLE:
  3730. default:
  3731. break;
  3732. };
  3733. return 1;
  3734. }
  3735. /**
  3736. * ibmvfc_work_to_do - Is there task level work to do?
  3737. * @vhost: ibmvfc host struct
  3738. *
  3739. * Returns:
  3740. * 1 if work to do / 0 if not
  3741. **/
  3742. static int ibmvfc_work_to_do(struct ibmvfc_host *vhost)
  3743. {
  3744. unsigned long flags;
  3745. int rc;
  3746. spin_lock_irqsave(vhost->host->host_lock, flags);
  3747. rc = __ibmvfc_work_to_do(vhost);
  3748. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3749. return rc;
  3750. }
  3751. /**
  3752. * ibmvfc_log_ae - Log async events if necessary
  3753. * @vhost: ibmvfc host struct
  3754. * @events: events to log
  3755. *
  3756. **/
  3757. static void ibmvfc_log_ae(struct ibmvfc_host *vhost, int events)
  3758. {
  3759. if (events & IBMVFC_AE_RSCN)
  3760. fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_RSCN, 0);
  3761. if ((events & IBMVFC_AE_LINKDOWN) &&
  3762. vhost->state >= IBMVFC_HALTED)
  3763. fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
  3764. if ((events & IBMVFC_AE_LINKUP) &&
  3765. vhost->state == IBMVFC_INITIALIZING)
  3766. fc_host_post_event(vhost->host, fc_get_event_number(), FCH_EVT_LINKUP, 0);
  3767. }
  3768. /**
  3769. * ibmvfc_tgt_add_rport - Tell the FC transport about a new remote port
  3770. * @tgt: ibmvfc target struct
  3771. *
  3772. **/
  3773. static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
  3774. {
  3775. struct ibmvfc_host *vhost = tgt->vhost;
  3776. struct fc_rport *rport;
  3777. unsigned long flags;
  3778. tgt_dbg(tgt, "Adding rport\n");
  3779. rport = fc_remote_port_add(vhost->host, 0, &tgt->ids);
  3780. spin_lock_irqsave(vhost->host->host_lock, flags);
  3781. if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
  3782. tgt_dbg(tgt, "Deleting rport\n");
  3783. list_del(&tgt->queue);
  3784. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
  3785. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3786. fc_remote_port_delete(rport);
  3787. del_timer_sync(&tgt->timer);
  3788. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3789. return;
  3790. } else if (rport && tgt->action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
  3791. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3792. return;
  3793. }
  3794. if (rport) {
  3795. tgt_dbg(tgt, "rport add succeeded\n");
  3796. tgt->rport = rport;
  3797. rport->maxframe_size = tgt->service_parms.common.bb_rcv_sz & 0x0fff;
  3798. rport->supported_classes = 0;
  3799. tgt->target_id = rport->scsi_target_id;
  3800. if (tgt->service_parms.class1_parms[0] & 0x80000000)
  3801. rport->supported_classes |= FC_COS_CLASS1;
  3802. if (tgt->service_parms.class2_parms[0] & 0x80000000)
  3803. rport->supported_classes |= FC_COS_CLASS2;
  3804. if (tgt->service_parms.class3_parms[0] & 0x80000000)
  3805. rport->supported_classes |= FC_COS_CLASS3;
  3806. if (rport->rqst_q)
  3807. blk_queue_max_segments(rport->rqst_q, 1);
  3808. } else
  3809. tgt_dbg(tgt, "rport add failed\n");
  3810. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3811. }
  3812. /**
  3813. * ibmvfc_do_work - Do task level work
  3814. * @vhost: ibmvfc host struct
  3815. *
  3816. **/
  3817. static void ibmvfc_do_work(struct ibmvfc_host *vhost)
  3818. {
  3819. struct ibmvfc_target *tgt;
  3820. unsigned long flags;
  3821. struct fc_rport *rport;
  3822. int rc;
  3823. ibmvfc_log_ae(vhost, vhost->events_to_log);
  3824. spin_lock_irqsave(vhost->host->host_lock, flags);
  3825. vhost->events_to_log = 0;
  3826. switch (vhost->action) {
  3827. case IBMVFC_HOST_ACTION_NONE:
  3828. case IBMVFC_HOST_ACTION_LOGO_WAIT:
  3829. case IBMVFC_HOST_ACTION_INIT_WAIT:
  3830. break;
  3831. case IBMVFC_HOST_ACTION_RESET:
  3832. vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
  3833. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3834. rc = ibmvfc_reset_crq(vhost);
  3835. spin_lock_irqsave(vhost->host->host_lock, flags);
  3836. if (rc == H_CLOSED)
  3837. vio_enable_interrupts(to_vio_dev(vhost->dev));
  3838. if (rc || (rc = ibmvfc_send_crq_init(vhost)) ||
  3839. (rc = vio_enable_interrupts(to_vio_dev(vhost->dev)))) {
  3840. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3841. dev_err(vhost->dev, "Error after reset (rc=%d)\n", rc);
  3842. }
  3843. break;
  3844. case IBMVFC_HOST_ACTION_REENABLE:
  3845. vhost->action = IBMVFC_HOST_ACTION_TGT_DEL;
  3846. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3847. rc = ibmvfc_reenable_crq_queue(vhost);
  3848. spin_lock_irqsave(vhost->host->host_lock, flags);
  3849. if (rc || (rc = ibmvfc_send_crq_init(vhost))) {
  3850. ibmvfc_link_down(vhost, IBMVFC_LINK_DEAD);
  3851. dev_err(vhost->dev, "Error after enable (rc=%d)\n", rc);
  3852. }
  3853. break;
  3854. case IBMVFC_HOST_ACTION_LOGO:
  3855. vhost->job_step(vhost);
  3856. break;
  3857. case IBMVFC_HOST_ACTION_INIT:
  3858. BUG_ON(vhost->state != IBMVFC_INITIALIZING);
  3859. if (vhost->delay_init) {
  3860. vhost->delay_init = 0;
  3861. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3862. ssleep(15);
  3863. return;
  3864. } else
  3865. vhost->job_step(vhost);
  3866. break;
  3867. case IBMVFC_HOST_ACTION_QUERY:
  3868. list_for_each_entry(tgt, &vhost->targets, queue)
  3869. ibmvfc_init_tgt(tgt, ibmvfc_tgt_query_target);
  3870. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY_TGTS);
  3871. break;
  3872. case IBMVFC_HOST_ACTION_QUERY_TGTS:
  3873. list_for_each_entry(tgt, &vhost->targets, queue) {
  3874. if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
  3875. tgt->job_step(tgt);
  3876. break;
  3877. }
  3878. }
  3879. if (!ibmvfc_dev_init_to_do(vhost))
  3880. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL);
  3881. break;
  3882. case IBMVFC_HOST_ACTION_TGT_DEL:
  3883. case IBMVFC_HOST_ACTION_TGT_DEL_FAILED:
  3884. list_for_each_entry(tgt, &vhost->targets, queue) {
  3885. if (tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
  3886. tgt_dbg(tgt, "Deleting rport\n");
  3887. rport = tgt->rport;
  3888. tgt->rport = NULL;
  3889. list_del(&tgt->queue);
  3890. ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
  3891. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3892. if (rport)
  3893. fc_remote_port_delete(rport);
  3894. del_timer_sync(&tgt->timer);
  3895. kref_put(&tgt->kref, ibmvfc_release_tgt);
  3896. return;
  3897. }
  3898. }
  3899. if (vhost->state == IBMVFC_INITIALIZING) {
  3900. if (vhost->action == IBMVFC_HOST_ACTION_TGT_DEL_FAILED) {
  3901. if (vhost->reinit) {
  3902. vhost->reinit = 0;
  3903. scsi_block_requests(vhost->host);
  3904. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
  3905. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3906. } else {
  3907. ibmvfc_set_host_state(vhost, IBMVFC_ACTIVE);
  3908. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  3909. wake_up(&vhost->init_wait_q);
  3910. schedule_work(&vhost->rport_add_work_q);
  3911. vhost->init_retries = 0;
  3912. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3913. scsi_unblock_requests(vhost->host);
  3914. }
  3915. return;
  3916. } else {
  3917. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_INIT);
  3918. vhost->job_step = ibmvfc_discover_targets;
  3919. }
  3920. } else {
  3921. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
  3922. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3923. scsi_unblock_requests(vhost->host);
  3924. wake_up(&vhost->init_wait_q);
  3925. return;
  3926. }
  3927. break;
  3928. case IBMVFC_HOST_ACTION_ALLOC_TGTS:
  3929. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_INIT);
  3930. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3931. ibmvfc_alloc_targets(vhost);
  3932. spin_lock_irqsave(vhost->host->host_lock, flags);
  3933. break;
  3934. case IBMVFC_HOST_ACTION_TGT_INIT:
  3935. list_for_each_entry(tgt, &vhost->targets, queue) {
  3936. if (tgt->action == IBMVFC_TGT_ACTION_INIT) {
  3937. tgt->job_step(tgt);
  3938. break;
  3939. }
  3940. }
  3941. if (!ibmvfc_dev_init_to_do(vhost))
  3942. ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_DEL_FAILED);
  3943. break;
  3944. default:
  3945. break;
  3946. };
  3947. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  3948. }
  3949. /**
  3950. * ibmvfc_work - Do task level work
  3951. * @data: ibmvfc host struct
  3952. *
  3953. * Returns:
  3954. * zero
  3955. **/
  3956. static int ibmvfc_work(void *data)
  3957. {
  3958. struct ibmvfc_host *vhost = data;
  3959. int rc;
  3960. set_user_nice(current, -20);
  3961. while (1) {
  3962. rc = wait_event_interruptible(vhost->work_wait_q,
  3963. ibmvfc_work_to_do(vhost));
  3964. BUG_ON(rc);
  3965. if (kthread_should_stop())
  3966. break;
  3967. ibmvfc_do_work(vhost);
  3968. }
  3969. ibmvfc_dbg(vhost, "ibmvfc kthread exiting...\n");
  3970. return 0;
  3971. }
  3972. /**
  3973. * ibmvfc_init_crq - Initializes and registers CRQ with hypervisor
  3974. * @vhost: ibmvfc host struct
  3975. *
  3976. * Allocates a page for messages, maps it for dma, and registers
  3977. * the crq with the hypervisor.
  3978. *
  3979. * Return value:
  3980. * zero on success / other on failure
  3981. **/
  3982. static int ibmvfc_init_crq(struct ibmvfc_host *vhost)
  3983. {
  3984. int rc, retrc = -ENOMEM;
  3985. struct device *dev = vhost->dev;
  3986. struct vio_dev *vdev = to_vio_dev(dev);
  3987. struct ibmvfc_crq_queue *crq = &vhost->crq;
  3988. ENTER;
  3989. crq->msgs = (struct ibmvfc_crq *)get_zeroed_page(GFP_KERNEL);
  3990. if (!crq->msgs)
  3991. return -ENOMEM;
  3992. crq->size = PAGE_SIZE / sizeof(*crq->msgs);
  3993. crq->msg_token = dma_map_single(dev, crq->msgs,
  3994. PAGE_SIZE, DMA_BIDIRECTIONAL);
  3995. if (dma_mapping_error(dev, crq->msg_token))
  3996. goto map_failed;
  3997. retrc = rc = plpar_hcall_norets(H_REG_CRQ, vdev->unit_address,
  3998. crq->msg_token, PAGE_SIZE);
  3999. if (rc == H_RESOURCE)
  4000. /* maybe kexecing and resource is busy. try a reset */
  4001. retrc = rc = ibmvfc_reset_crq(vhost);
  4002. if (rc == H_CLOSED)
  4003. dev_warn(dev, "Partner adapter not ready\n");
  4004. else if (rc) {
  4005. dev_warn(dev, "Error %d opening adapter\n", rc);
  4006. goto reg_crq_failed;
  4007. }
  4008. retrc = 0;
  4009. tasklet_init(&vhost->tasklet, (void *)ibmvfc_tasklet, (unsigned long)vhost);
  4010. if ((rc = request_irq(vdev->irq, ibmvfc_interrupt, 0, IBMVFC_NAME, vhost))) {
  4011. dev_err(dev, "Couldn't register irq 0x%x. rc=%d\n", vdev->irq, rc);
  4012. goto req_irq_failed;
  4013. }
  4014. if ((rc = vio_enable_interrupts(vdev))) {
  4015. dev_err(dev, "Error %d enabling interrupts\n", rc);
  4016. goto req_irq_failed;
  4017. }
  4018. crq->cur = 0;
  4019. LEAVE;
  4020. return retrc;
  4021. req_irq_failed:
  4022. tasklet_kill(&vhost->tasklet);
  4023. do {
  4024. rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
  4025. } while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
  4026. reg_crq_failed:
  4027. dma_unmap_single(dev, crq->msg_token, PAGE_SIZE, DMA_BIDIRECTIONAL);
  4028. map_failed:
  4029. free_page((unsigned long)crq->msgs);
  4030. return retrc;
  4031. }
  4032. /**
  4033. * ibmvfc_free_mem - Free memory for vhost
  4034. * @vhost: ibmvfc host struct
  4035. *
  4036. * Return value:
  4037. * none
  4038. **/
  4039. static void ibmvfc_free_mem(struct ibmvfc_host *vhost)
  4040. {
  4041. struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
  4042. ENTER;
  4043. mempool_destroy(vhost->tgt_pool);
  4044. kfree(vhost->trace);
  4045. dma_free_coherent(vhost->dev, vhost->disc_buf_sz, vhost->disc_buf,
  4046. vhost->disc_buf_dma);
  4047. dma_free_coherent(vhost->dev, sizeof(*vhost->login_buf),
  4048. vhost->login_buf, vhost->login_buf_dma);
  4049. dma_pool_destroy(vhost->sg_pool);
  4050. dma_unmap_single(vhost->dev, async_q->msg_token,
  4051. async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
  4052. free_page((unsigned long)async_q->msgs);
  4053. LEAVE;
  4054. }
  4055. /**
  4056. * ibmvfc_alloc_mem - Allocate memory for vhost
  4057. * @vhost: ibmvfc host struct
  4058. *
  4059. * Return value:
  4060. * 0 on success / non-zero on failure
  4061. **/
  4062. static int ibmvfc_alloc_mem(struct ibmvfc_host *vhost)
  4063. {
  4064. struct ibmvfc_async_crq_queue *async_q = &vhost->async_crq;
  4065. struct device *dev = vhost->dev;
  4066. ENTER;
  4067. async_q->msgs = (struct ibmvfc_async_crq *)get_zeroed_page(GFP_KERNEL);
  4068. if (!async_q->msgs) {
  4069. dev_err(dev, "Couldn't allocate async queue.\n");
  4070. goto nomem;
  4071. }
  4072. async_q->size = PAGE_SIZE / sizeof(struct ibmvfc_async_crq);
  4073. async_q->msg_token = dma_map_single(dev, async_q->msgs,
  4074. async_q->size * sizeof(*async_q->msgs),
  4075. DMA_BIDIRECTIONAL);
  4076. if (dma_mapping_error(dev, async_q->msg_token)) {
  4077. dev_err(dev, "Failed to map async queue\n");
  4078. goto free_async_crq;
  4079. }
  4080. vhost->sg_pool = dma_pool_create(IBMVFC_NAME, dev,
  4081. SG_ALL * sizeof(struct srp_direct_buf),
  4082. sizeof(struct srp_direct_buf), 0);
  4083. if (!vhost->sg_pool) {
  4084. dev_err(dev, "Failed to allocate sg pool\n");
  4085. goto unmap_async_crq;
  4086. }
  4087. vhost->login_buf = dma_alloc_coherent(dev, sizeof(*vhost->login_buf),
  4088. &vhost->login_buf_dma, GFP_KERNEL);
  4089. if (!vhost->login_buf) {
  4090. dev_err(dev, "Couldn't allocate NPIV login buffer\n");
  4091. goto free_sg_pool;
  4092. }
  4093. vhost->disc_buf_sz = sizeof(vhost->disc_buf->scsi_id[0]) * max_targets;
  4094. vhost->disc_buf = dma_alloc_coherent(dev, vhost->disc_buf_sz,
  4095. &vhost->disc_buf_dma, GFP_KERNEL);
  4096. if (!vhost->disc_buf) {
  4097. dev_err(dev, "Couldn't allocate Discover Targets buffer\n");
  4098. goto free_login_buffer;
  4099. }
  4100. vhost->trace = kcalloc(IBMVFC_NUM_TRACE_ENTRIES,
  4101. sizeof(struct ibmvfc_trace_entry), GFP_KERNEL);
  4102. if (!vhost->trace)
  4103. goto free_disc_buffer;
  4104. vhost->tgt_pool = mempool_create_kmalloc_pool(IBMVFC_TGT_MEMPOOL_SZ,
  4105. sizeof(struct ibmvfc_target));
  4106. if (!vhost->tgt_pool) {
  4107. dev_err(dev, "Couldn't allocate target memory pool\n");
  4108. goto free_trace;
  4109. }
  4110. LEAVE;
  4111. return 0;
  4112. free_trace:
  4113. kfree(vhost->trace);
  4114. free_disc_buffer:
  4115. dma_free_coherent(dev, vhost->disc_buf_sz, vhost->disc_buf,
  4116. vhost->disc_buf_dma);
  4117. free_login_buffer:
  4118. dma_free_coherent(dev, sizeof(*vhost->login_buf),
  4119. vhost->login_buf, vhost->login_buf_dma);
  4120. free_sg_pool:
  4121. dma_pool_destroy(vhost->sg_pool);
  4122. unmap_async_crq:
  4123. dma_unmap_single(dev, async_q->msg_token,
  4124. async_q->size * sizeof(*async_q->msgs), DMA_BIDIRECTIONAL);
  4125. free_async_crq:
  4126. free_page((unsigned long)async_q->msgs);
  4127. nomem:
  4128. LEAVE;
  4129. return -ENOMEM;
  4130. }
  4131. /**
  4132. * ibmvfc_rport_add_thread - Worker thread for rport adds
  4133. * @work: work struct
  4134. *
  4135. **/
  4136. static void ibmvfc_rport_add_thread(struct work_struct *work)
  4137. {
  4138. struct ibmvfc_host *vhost = container_of(work, struct ibmvfc_host,
  4139. rport_add_work_q);
  4140. struct ibmvfc_target *tgt;
  4141. struct fc_rport *rport;
  4142. unsigned long flags;
  4143. int did_work;
  4144. ENTER;
  4145. spin_lock_irqsave(vhost->host->host_lock, flags);
  4146. do {
  4147. did_work = 0;
  4148. if (vhost->state != IBMVFC_ACTIVE)
  4149. break;
  4150. list_for_each_entry(tgt, &vhost->targets, queue) {
  4151. if (tgt->add_rport) {
  4152. did_work = 1;
  4153. tgt->add_rport = 0;
  4154. kref_get(&tgt->kref);
  4155. rport = tgt->rport;
  4156. if (!rport) {
  4157. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4158. ibmvfc_tgt_add_rport(tgt);
  4159. } else if (get_device(&rport->dev)) {
  4160. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4161. tgt_dbg(tgt, "Setting rport roles\n");
  4162. fc_remote_port_rolechg(rport, tgt->ids.roles);
  4163. put_device(&rport->dev);
  4164. }
  4165. kref_put(&tgt->kref, ibmvfc_release_tgt);
  4166. spin_lock_irqsave(vhost->host->host_lock, flags);
  4167. break;
  4168. }
  4169. }
  4170. } while(did_work);
  4171. if (vhost->state == IBMVFC_ACTIVE)
  4172. vhost->scan_complete = 1;
  4173. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4174. LEAVE;
  4175. }
  4176. /**
  4177. * ibmvfc_probe - Adapter hot plug add entry point
  4178. * @vdev: vio device struct
  4179. * @id: vio device id struct
  4180. *
  4181. * Return value:
  4182. * 0 on success / non-zero on failure
  4183. **/
  4184. static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
  4185. {
  4186. struct ibmvfc_host *vhost;
  4187. struct Scsi_Host *shost;
  4188. struct device *dev = &vdev->dev;
  4189. int rc = -ENOMEM;
  4190. ENTER;
  4191. shost = scsi_host_alloc(&driver_template, sizeof(*vhost));
  4192. if (!shost) {
  4193. dev_err(dev, "Couldn't allocate host data\n");
  4194. goto out;
  4195. }
  4196. shost->transportt = ibmvfc_transport_template;
  4197. shost->can_queue = max_requests;
  4198. shost->max_lun = max_lun;
  4199. shost->max_id = max_targets;
  4200. shost->max_sectors = IBMVFC_MAX_SECTORS;
  4201. shost->max_cmd_len = IBMVFC_MAX_CDB_LEN;
  4202. shost->unique_id = shost->host_no;
  4203. vhost = shost_priv(shost);
  4204. INIT_LIST_HEAD(&vhost->sent);
  4205. INIT_LIST_HEAD(&vhost->free);
  4206. INIT_LIST_HEAD(&vhost->targets);
  4207. sprintf(vhost->name, IBMVFC_NAME);
  4208. vhost->host = shost;
  4209. vhost->dev = dev;
  4210. vhost->partition_number = -1;
  4211. vhost->log_level = log_level;
  4212. vhost->task_set = 1;
  4213. strcpy(vhost->partition_name, "UNKNOWN");
  4214. init_waitqueue_head(&vhost->work_wait_q);
  4215. init_waitqueue_head(&vhost->init_wait_q);
  4216. INIT_WORK(&vhost->rport_add_work_q, ibmvfc_rport_add_thread);
  4217. mutex_init(&vhost->passthru_mutex);
  4218. if ((rc = ibmvfc_alloc_mem(vhost)))
  4219. goto free_scsi_host;
  4220. vhost->work_thread = kthread_run(ibmvfc_work, vhost, "%s_%d", IBMVFC_NAME,
  4221. shost->host_no);
  4222. if (IS_ERR(vhost->work_thread)) {
  4223. dev_err(dev, "Couldn't create kernel thread: %ld\n",
  4224. PTR_ERR(vhost->work_thread));
  4225. goto free_host_mem;
  4226. }
  4227. if ((rc = ibmvfc_init_crq(vhost))) {
  4228. dev_err(dev, "Couldn't initialize crq. rc=%d\n", rc);
  4229. goto kill_kthread;
  4230. }
  4231. if ((rc = ibmvfc_init_event_pool(vhost))) {
  4232. dev_err(dev, "Couldn't initialize event pool. rc=%d\n", rc);
  4233. goto release_crq;
  4234. }
  4235. if ((rc = scsi_add_host(shost, dev)))
  4236. goto release_event_pool;
  4237. fc_host_dev_loss_tmo(shost) = IBMVFC_DEV_LOSS_TMO;
  4238. if ((rc = ibmvfc_create_trace_file(&shost->shost_dev.kobj,
  4239. &ibmvfc_trace_attr))) {
  4240. dev_err(dev, "Failed to create trace file. rc=%d\n", rc);
  4241. goto remove_shost;
  4242. }
  4243. if (shost_to_fc_host(shost)->rqst_q)
  4244. blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
  4245. dev_set_drvdata(dev, vhost);
  4246. spin_lock(&ibmvfc_driver_lock);
  4247. list_add_tail(&vhost->queue, &ibmvfc_head);
  4248. spin_unlock(&ibmvfc_driver_lock);
  4249. ibmvfc_send_crq_init(vhost);
  4250. scsi_scan_host(shost);
  4251. return 0;
  4252. remove_shost:
  4253. scsi_remove_host(shost);
  4254. release_event_pool:
  4255. ibmvfc_free_event_pool(vhost);
  4256. release_crq:
  4257. ibmvfc_release_crq_queue(vhost);
  4258. kill_kthread:
  4259. kthread_stop(vhost->work_thread);
  4260. free_host_mem:
  4261. ibmvfc_free_mem(vhost);
  4262. free_scsi_host:
  4263. scsi_host_put(shost);
  4264. out:
  4265. LEAVE;
  4266. return rc;
  4267. }
  4268. /**
  4269. * ibmvfc_remove - Adapter hot plug remove entry point
  4270. * @vdev: vio device struct
  4271. *
  4272. * Return value:
  4273. * 0
  4274. **/
  4275. static int ibmvfc_remove(struct vio_dev *vdev)
  4276. {
  4277. struct ibmvfc_host *vhost = dev_get_drvdata(&vdev->dev);
  4278. unsigned long flags;
  4279. ENTER;
  4280. ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
  4281. spin_lock_irqsave(vhost->host->host_lock, flags);
  4282. ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
  4283. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4284. ibmvfc_wait_while_resetting(vhost);
  4285. ibmvfc_release_crq_queue(vhost);
  4286. kthread_stop(vhost->work_thread);
  4287. fc_remove_host(vhost->host);
  4288. scsi_remove_host(vhost->host);
  4289. spin_lock_irqsave(vhost->host->host_lock, flags);
  4290. ibmvfc_purge_requests(vhost, DID_ERROR);
  4291. ibmvfc_free_event_pool(vhost);
  4292. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4293. ibmvfc_free_mem(vhost);
  4294. spin_lock(&ibmvfc_driver_lock);
  4295. list_del(&vhost->queue);
  4296. spin_unlock(&ibmvfc_driver_lock);
  4297. scsi_host_put(vhost->host);
  4298. LEAVE;
  4299. return 0;
  4300. }
  4301. /**
  4302. * ibmvfc_resume - Resume from suspend
  4303. * @dev: device struct
  4304. *
  4305. * We may have lost an interrupt across suspend/resume, so kick the
  4306. * interrupt handler
  4307. *
  4308. */
  4309. static int ibmvfc_resume(struct device *dev)
  4310. {
  4311. unsigned long flags;
  4312. struct ibmvfc_host *vhost = dev_get_drvdata(dev);
  4313. struct vio_dev *vdev = to_vio_dev(dev);
  4314. spin_lock_irqsave(vhost->host->host_lock, flags);
  4315. vio_disable_interrupts(vdev);
  4316. tasklet_schedule(&vhost->tasklet);
  4317. spin_unlock_irqrestore(vhost->host->host_lock, flags);
  4318. return 0;
  4319. }
  4320. /**
  4321. * ibmvfc_get_desired_dma - Calculate DMA resources needed by the driver
  4322. * @vdev: vio device struct
  4323. *
  4324. * Return value:
  4325. * Number of bytes the driver will need to DMA map at the same time in
  4326. * order to perform well.
  4327. */
  4328. static unsigned long ibmvfc_get_desired_dma(struct vio_dev *vdev)
  4329. {
  4330. unsigned long pool_dma = max_requests * sizeof(union ibmvfc_iu);
  4331. return pool_dma + ((512 * 1024) * driver_template.cmd_per_lun);
  4332. }
  4333. static struct vio_device_id ibmvfc_device_table[] __devinitdata = {
  4334. {"fcp", "IBM,vfc-client"},
  4335. { "", "" }
  4336. };
  4337. MODULE_DEVICE_TABLE(vio, ibmvfc_device_table);
  4338. static struct dev_pm_ops ibmvfc_pm_ops = {
  4339. .resume = ibmvfc_resume
  4340. };
  4341. static struct vio_driver ibmvfc_driver = {
  4342. .id_table = ibmvfc_device_table,
  4343. .probe = ibmvfc_probe,
  4344. .remove = ibmvfc_remove,
  4345. .get_desired_dma = ibmvfc_get_desired_dma,
  4346. .driver = {
  4347. .name = IBMVFC_NAME,
  4348. .owner = THIS_MODULE,
  4349. .pm = &ibmvfc_pm_ops,
  4350. }
  4351. };
  4352. static struct fc_function_template ibmvfc_transport_functions = {
  4353. .show_host_fabric_name = 1,
  4354. .show_host_node_name = 1,
  4355. .show_host_port_name = 1,
  4356. .show_host_supported_classes = 1,
  4357. .show_host_port_type = 1,
  4358. .show_host_port_id = 1,
  4359. .show_host_maxframe_size = 1,
  4360. .get_host_port_state = ibmvfc_get_host_port_state,
  4361. .show_host_port_state = 1,
  4362. .get_host_speed = ibmvfc_get_host_speed,
  4363. .show_host_speed = 1,
  4364. .issue_fc_host_lip = ibmvfc_issue_fc_host_lip,
  4365. .terminate_rport_io = ibmvfc_terminate_rport_io,
  4366. .show_rport_maxframe_size = 1,
  4367. .show_rport_supported_classes = 1,
  4368. .set_rport_dev_loss_tmo = ibmvfc_set_rport_dev_loss_tmo,
  4369. .show_rport_dev_loss_tmo = 1,
  4370. .get_starget_node_name = ibmvfc_get_starget_node_name,
  4371. .show_starget_node_name = 1,
  4372. .get_starget_port_name = ibmvfc_get_starget_port_name,
  4373. .show_starget_port_name = 1,
  4374. .get_starget_port_id = ibmvfc_get_starget_port_id,
  4375. .show_starget_port_id = 1,
  4376. .bsg_request = ibmvfc_bsg_request,
  4377. .bsg_timeout = ibmvfc_bsg_timeout,
  4378. };
  4379. /**
  4380. * ibmvfc_module_init - Initialize the ibmvfc module
  4381. *
  4382. * Return value:
  4383. * 0 on success / other on failure
  4384. **/
  4385. static int __init ibmvfc_module_init(void)
  4386. {
  4387. int rc;
  4388. if (!firmware_has_feature(FW_FEATURE_VIO))
  4389. return -ENODEV;
  4390. printk(KERN_INFO IBMVFC_NAME": IBM Virtual Fibre Channel Driver version: %s %s\n",
  4391. IBMVFC_DRIVER_VERSION, IBMVFC_DRIVER_DATE);
  4392. ibmvfc_transport_template = fc_attach_transport(&ibmvfc_transport_functions);
  4393. if (!ibmvfc_transport_template)
  4394. return -ENOMEM;
  4395. rc = vio_register_driver(&ibmvfc_driver);
  4396. if (rc)
  4397. fc_release_transport(ibmvfc_transport_template);
  4398. return rc;
  4399. }
  4400. /**
  4401. * ibmvfc_module_exit - Teardown the ibmvfc module
  4402. *
  4403. * Return value:
  4404. * nothing
  4405. **/
  4406. static void __exit ibmvfc_module_exit(void)
  4407. {
  4408. vio_unregister_driver(&ibmvfc_driver);
  4409. fc_release_transport(ibmvfc_transport_template);
  4410. }
  4411. module_init(ibmvfc_module_init);
  4412. module_exit(ibmvfc_module_exit);