sas_scsi_host.c 34 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341
  1. /*
  2. * Serial Attached SCSI (SAS) class SCSI Host glue.
  3. *
  4. * Copyright (C) 2005 Adaptec, Inc. All rights reserved.
  5. * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
  6. *
  7. * This file is licensed under GPLv2.
  8. *
  9. * This program is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU General Public License as
  11. * published by the Free Software Foundation; either version 2 of the
  12. * License, or (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful, but
  15. * WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22. * USA
  23. *
  24. */
  25. #include <linux/kthread.h>
  26. #include "sas_internal.h"
  27. #include <scsi/scsi_host.h>
  28. #include <scsi/scsi_device.h>
  29. #include <scsi/scsi_tcq.h>
  30. #include <scsi/scsi.h>
  31. #include <scsi/scsi_eh.h>
  32. #include <scsi/scsi_transport.h>
  33. #include <scsi/scsi_transport_sas.h>
  34. #include "../scsi_sas_internal.h"
  35. #include "../scsi_transport_api.h"
  36. #include "../scsi_priv.h"
  37. #include <linux/err.h>
  38. #include <linux/blkdev.h>
  39. #include <linux/freezer.h>
  40. #include <linux/scatterlist.h>
  41. #include <linux/libata.h>
  42. /* ---------- SCSI Host glue ---------- */
  43. #define TO_SAS_TASK(_scsi_cmd) ((void *)(_scsi_cmd)->host_scribble)
  44. #define ASSIGN_SAS_TASK(_sc, _t) do { (_sc)->host_scribble = (void *) _t; } while (0)
  45. static void sas_scsi_task_done(struct sas_task *task)
  46. {
  47. struct task_status_struct *ts = &task->task_status;
  48. struct scsi_cmnd *sc = task->uldd_task;
  49. struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(sc->device->host);
  50. unsigned ts_flags = task->task_state_flags;
  51. int hs = 0, stat = 0;
  52. if (unlikely(!sc)) {
  53. SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n");
  54. list_del_init(&task->list);
  55. sas_free_task(task);
  56. return;
  57. }
  58. if (ts->resp == SAS_TASK_UNDELIVERED) {
  59. /* transport error */
  60. hs = DID_NO_CONNECT;
  61. } else { /* ts->resp == SAS_TASK_COMPLETE */
  62. /* task delivered, what happened afterwards? */
  63. switch (ts->stat) {
  64. case SAS_DEV_NO_RESPONSE:
  65. case SAS_INTERRUPTED:
  66. case SAS_PHY_DOWN:
  67. case SAS_NAK_R_ERR:
  68. case SAS_OPEN_TO:
  69. hs = DID_NO_CONNECT;
  70. break;
  71. case SAS_DATA_UNDERRUN:
  72. scsi_set_resid(sc, ts->residual);
  73. if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow)
  74. hs = DID_ERROR;
  75. break;
  76. case SAS_DATA_OVERRUN:
  77. hs = DID_ERROR;
  78. break;
  79. case SAS_QUEUE_FULL:
  80. hs = DID_SOFT_ERROR; /* retry */
  81. break;
  82. case SAS_DEVICE_UNKNOWN:
  83. hs = DID_BAD_TARGET;
  84. break;
  85. case SAS_SG_ERR:
  86. hs = DID_PARITY;
  87. break;
  88. case SAS_OPEN_REJECT:
  89. if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY)
  90. hs = DID_SOFT_ERROR; /* retry */
  91. else
  92. hs = DID_ERROR;
  93. break;
  94. case SAS_PROTO_RESPONSE:
  95. SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP "
  96. "task; please report this\n",
  97. task->dev->port->ha->sas_ha_name);
  98. break;
  99. case SAS_ABORTED_TASK:
  100. hs = DID_ABORT;
  101. break;
  102. case SAM_CHECK_COND:
  103. memcpy(sc->sense_buffer, ts->buf,
  104. max(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size));
  105. stat = SAM_CHECK_COND;
  106. break;
  107. default:
  108. stat = ts->stat;
  109. break;
  110. }
  111. }
  112. ASSIGN_SAS_TASK(sc, NULL);
  113. sc->result = (hs << 16) | stat;
  114. list_del_init(&task->list);
  115. sas_free_task(task);
  116. /* This is very ugly but this is how SCSI Core works. */
  117. if (ts_flags & SAS_TASK_STATE_ABORTED)
  118. scsi_eh_finish_cmd(sc, &sas_ha->eh_done_q);
  119. else
  120. sc->scsi_done(sc);
  121. }
  122. static enum task_attribute sas_scsi_get_task_attr(struct scsi_cmnd *cmd)
  123. {
  124. enum task_attribute ta = TASK_ATTR_SIMPLE;
  125. if (cmd->request && blk_rq_tagged(cmd->request)) {
  126. if (cmd->device->ordered_tags &&
  127. (cmd->request->cmd_flags & REQ_HARDBARRIER))
  128. ta = TASK_ATTR_ORDERED;
  129. }
  130. return ta;
  131. }
  132. static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
  133. struct domain_device *dev,
  134. gfp_t gfp_flags)
  135. {
  136. struct sas_task *task = sas_alloc_task(gfp_flags);
  137. struct scsi_lun lun;
  138. if (!task)
  139. return NULL;
  140. *(u32 *)cmd->sense_buffer = 0;
  141. task->uldd_task = cmd;
  142. ASSIGN_SAS_TASK(cmd, task);
  143. task->dev = dev;
  144. task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */
  145. task->ssp_task.retry_count = 1;
  146. int_to_scsilun(cmd->device->lun, &lun);
  147. memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8);
  148. task->ssp_task.task_attr = sas_scsi_get_task_attr(cmd);
  149. memcpy(task->ssp_task.cdb, cmd->cmnd, 16);
  150. task->scatter = scsi_sglist(cmd);
  151. task->num_scatter = scsi_sg_count(cmd);
  152. task->total_xfer_len = scsi_bufflen(cmd);
  153. task->data_dir = cmd->sc_data_direction;
  154. task->task_done = sas_scsi_task_done;
  155. return task;
  156. }
  157. static int sas_queue_up(struct sas_task *task)
  158. {
  159. struct sas_ha_struct *sas_ha = task->dev->port->ha;
  160. struct scsi_core *core = &sas_ha->core;
  161. unsigned long flags;
  162. LIST_HEAD(list);
  163. spin_lock_irqsave(&core->task_queue_lock, flags);
  164. if (sas_ha->lldd_queue_size < core->task_queue_size + 1) {
  165. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  166. return -SAS_QUEUE_FULL;
  167. }
  168. list_add_tail(&task->list, &core->task_queue);
  169. core->task_queue_size += 1;
  170. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  171. wake_up_process(core->queue_thread);
  172. return 0;
  173. }
  174. static inline int dev_is_sata(struct domain_device *dev)
  175. {
  176. return (dev->rphy->identify.target_port_protocols & SAS_PROTOCOL_SATA);
  177. }
  178. /**
  179. * sas_queuecommand -- Enqueue a command for processing
  180. * @parameters: See SCSI Core documentation
  181. *
  182. * Note: XXX: Remove the host unlock/lock pair when SCSI Core can
  183. * call us without holding an IRQ spinlock...
  184. */
  185. int sas_queuecommand(struct scsi_cmnd *cmd,
  186. void (*scsi_done)(struct scsi_cmnd *))
  187. {
  188. int res = 0;
  189. struct domain_device *dev = cmd_to_domain_dev(cmd);
  190. struct Scsi_Host *host = cmd->device->host;
  191. struct sas_internal *i = to_sas_internal(host->transportt);
  192. spin_unlock_irq(host->host_lock);
  193. {
  194. struct sas_ha_struct *sas_ha = dev->port->ha;
  195. struct sas_task *task;
  196. if (dev_is_sata(dev)) {
  197. res = ata_sas_queuecmd(cmd, scsi_done,
  198. dev->sata_dev.ap);
  199. goto out;
  200. }
  201. res = -ENOMEM;
  202. task = sas_create_task(cmd, dev, GFP_ATOMIC);
  203. if (!task)
  204. goto out;
  205. cmd->scsi_done = scsi_done;
  206. /* Queue up, Direct Mode or Task Collector Mode. */
  207. if (sas_ha->lldd_max_execute_num < 2)
  208. res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
  209. else
  210. res = sas_queue_up(task);
  211. /* Examine */
  212. if (res) {
  213. SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
  214. ASSIGN_SAS_TASK(cmd, NULL);
  215. sas_free_task(task);
  216. if (res == -SAS_QUEUE_FULL) {
  217. cmd->result = DID_SOFT_ERROR << 16; /* retry */
  218. res = 0;
  219. scsi_done(cmd);
  220. }
  221. goto out;
  222. }
  223. }
  224. out:
  225. spin_lock_irq(host->host_lock);
  226. return res;
  227. }
  228. static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd)
  229. {
  230. struct scsi_cmnd *cmd, *n;
  231. list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
  232. if (cmd == my_cmd)
  233. list_del_init(&cmd->eh_entry);
  234. }
  235. }
  236. static void sas_scsi_clear_queue_I_T(struct list_head *error_q,
  237. struct domain_device *dev)
  238. {
  239. struct scsi_cmnd *cmd, *n;
  240. list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
  241. struct domain_device *x = cmd_to_domain_dev(cmd);
  242. if (x == dev)
  243. list_del_init(&cmd->eh_entry);
  244. }
  245. }
  246. static void sas_scsi_clear_queue_port(struct list_head *error_q,
  247. struct asd_sas_port *port)
  248. {
  249. struct scsi_cmnd *cmd, *n;
  250. list_for_each_entry_safe(cmd, n, error_q, eh_entry) {
  251. struct domain_device *dev = cmd_to_domain_dev(cmd);
  252. struct asd_sas_port *x = dev->port;
  253. if (x == port)
  254. list_del_init(&cmd->eh_entry);
  255. }
  256. }
  257. enum task_disposition {
  258. TASK_IS_DONE,
  259. TASK_IS_ABORTED,
  260. TASK_IS_AT_LU,
  261. TASK_IS_NOT_AT_LU,
  262. TASK_ABORT_FAILED,
  263. };
  264. static enum task_disposition sas_scsi_find_task(struct sas_task *task)
  265. {
  266. struct sas_ha_struct *ha = task->dev->port->ha;
  267. unsigned long flags;
  268. int i, res;
  269. struct sas_internal *si =
  270. to_sas_internal(task->dev->port->ha->core.shost->transportt);
  271. if (ha->lldd_max_execute_num > 1) {
  272. struct scsi_core *core = &ha->core;
  273. struct sas_task *t, *n;
  274. spin_lock_irqsave(&core->task_queue_lock, flags);
  275. list_for_each_entry_safe(t, n, &core->task_queue, list) {
  276. if (task == t) {
  277. list_del_init(&t->list);
  278. spin_unlock_irqrestore(&core->task_queue_lock,
  279. flags);
  280. SAS_DPRINTK("%s: task 0x%p aborted from "
  281. "task_queue\n",
  282. __FUNCTION__, task);
  283. return TASK_IS_ABORTED;
  284. }
  285. }
  286. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  287. }
  288. for (i = 0; i < 5; i++) {
  289. SAS_DPRINTK("%s: aborting task 0x%p\n", __FUNCTION__, task);
  290. res = si->dft->lldd_abort_task(task);
  291. spin_lock_irqsave(&task->task_state_lock, flags);
  292. if (task->task_state_flags & SAS_TASK_STATE_DONE) {
  293. spin_unlock_irqrestore(&task->task_state_lock, flags);
  294. SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__,
  295. task);
  296. return TASK_IS_DONE;
  297. }
  298. spin_unlock_irqrestore(&task->task_state_lock, flags);
  299. if (res == TMF_RESP_FUNC_COMPLETE) {
  300. SAS_DPRINTK("%s: task 0x%p is aborted\n",
  301. __FUNCTION__, task);
  302. return TASK_IS_ABORTED;
  303. } else if (si->dft->lldd_query_task) {
  304. SAS_DPRINTK("%s: querying task 0x%p\n",
  305. __FUNCTION__, task);
  306. res = si->dft->lldd_query_task(task);
  307. switch (res) {
  308. case TMF_RESP_FUNC_SUCC:
  309. SAS_DPRINTK("%s: task 0x%p at LU\n",
  310. __FUNCTION__, task);
  311. return TASK_IS_AT_LU;
  312. case TMF_RESP_FUNC_COMPLETE:
  313. SAS_DPRINTK("%s: task 0x%p not at LU\n",
  314. __FUNCTION__, task);
  315. return TASK_IS_NOT_AT_LU;
  316. case TMF_RESP_FUNC_FAILED:
  317. SAS_DPRINTK("%s: task 0x%p failed to abort\n",
  318. __FUNCTION__, task);
  319. return TASK_ABORT_FAILED;
  320. }
  321. }
  322. }
  323. return res;
  324. }
  325. static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd)
  326. {
  327. int res = TMF_RESP_FUNC_FAILED;
  328. struct scsi_lun lun;
  329. struct sas_internal *i =
  330. to_sas_internal(dev->port->ha->core.shost->transportt);
  331. int_to_scsilun(cmd->device->lun, &lun);
  332. SAS_DPRINTK("eh: device %llx LUN %x has the task\n",
  333. SAS_ADDR(dev->sas_addr),
  334. cmd->device->lun);
  335. if (i->dft->lldd_abort_task_set)
  336. res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun);
  337. if (res == TMF_RESP_FUNC_FAILED) {
  338. if (i->dft->lldd_clear_task_set)
  339. res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun);
  340. }
  341. if (res == TMF_RESP_FUNC_FAILED) {
  342. if (i->dft->lldd_lu_reset)
  343. res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
  344. }
  345. return res;
  346. }
  347. static int sas_recover_I_T(struct domain_device *dev)
  348. {
  349. int res = TMF_RESP_FUNC_FAILED;
  350. struct sas_internal *i =
  351. to_sas_internal(dev->port->ha->core.shost->transportt);
  352. SAS_DPRINTK("I_T nexus reset for dev %016llx\n",
  353. SAS_ADDR(dev->sas_addr));
  354. if (i->dft->lldd_I_T_nexus_reset)
  355. res = i->dft->lldd_I_T_nexus_reset(dev);
  356. return res;
  357. }
  358. /* Find the sas_phy that's attached to this device */
  359. struct sas_phy *find_local_sas_phy(struct domain_device *dev)
  360. {
  361. struct domain_device *pdev = dev->parent;
  362. struct ex_phy *exphy = NULL;
  363. int i;
  364. /* Directly attached device */
  365. if (!pdev)
  366. return dev->port->phy;
  367. /* Otherwise look in the expander */
  368. for (i = 0; i < pdev->ex_dev.num_phys; i++)
  369. if (!memcmp(dev->sas_addr,
  370. pdev->ex_dev.ex_phy[i].attached_sas_addr,
  371. SAS_ADDR_SIZE)) {
  372. exphy = &pdev->ex_dev.ex_phy[i];
  373. break;
  374. }
  375. BUG_ON(!exphy);
  376. return exphy->phy;
  377. }
  378. /* Attempt to send a LUN reset message to a device */
  379. int sas_eh_device_reset_handler(struct scsi_cmnd *cmd)
  380. {
  381. struct domain_device *dev = cmd_to_domain_dev(cmd);
  382. struct sas_internal *i =
  383. to_sas_internal(dev->port->ha->core.shost->transportt);
  384. struct scsi_lun lun;
  385. int res;
  386. int_to_scsilun(cmd->device->lun, &lun);
  387. if (!i->dft->lldd_lu_reset)
  388. return FAILED;
  389. res = i->dft->lldd_lu_reset(dev, lun.scsi_lun);
  390. if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE)
  391. return SUCCESS;
  392. return FAILED;
  393. }
  394. /* Attempt to send a phy (bus) reset */
  395. int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd)
  396. {
  397. struct domain_device *dev = cmd_to_domain_dev(cmd);
  398. struct sas_phy *phy = find_local_sas_phy(dev);
  399. int res;
  400. res = sas_phy_reset(phy, 1);
  401. if (res)
  402. SAS_DPRINTK("Bus reset of %s failed 0x%x\n",
  403. phy->dev.kobj.k_name,
  404. res);
  405. if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE)
  406. return SUCCESS;
  407. return FAILED;
  408. }
  409. /* Try to reset a device */
  410. static int try_to_reset_cmd_device(struct Scsi_Host *shost,
  411. struct scsi_cmnd *cmd)
  412. {
  413. int res;
  414. if (!shost->hostt->eh_device_reset_handler)
  415. goto try_bus_reset;
  416. res = shost->hostt->eh_device_reset_handler(cmd);
  417. if (res == SUCCESS)
  418. return res;
  419. try_bus_reset:
  420. if (shost->hostt->eh_bus_reset_handler)
  421. return shost->hostt->eh_bus_reset_handler(cmd);
  422. return FAILED;
  423. }
  424. static int sas_eh_handle_sas_errors(struct Scsi_Host *shost,
  425. struct list_head *work_q,
  426. struct list_head *done_q)
  427. {
  428. struct scsi_cmnd *cmd, *n;
  429. enum task_disposition res = TASK_IS_DONE;
  430. int tmf_resp, need_reset;
  431. struct sas_internal *i = to_sas_internal(shost->transportt);
  432. unsigned long flags;
  433. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  434. Again:
  435. list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
  436. struct sas_task *task = TO_SAS_TASK(cmd);
  437. if (!task)
  438. continue;
  439. list_del_init(&cmd->eh_entry);
  440. spin_lock_irqsave(&task->task_state_lock, flags);
  441. need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET;
  442. spin_unlock_irqrestore(&task->task_state_lock, flags);
  443. SAS_DPRINTK("trying to find task 0x%p\n", task);
  444. res = sas_scsi_find_task(task);
  445. cmd->eh_eflags = 0;
  446. switch (res) {
  447. case TASK_IS_DONE:
  448. SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__,
  449. task);
  450. task->task_done(task);
  451. if (need_reset)
  452. try_to_reset_cmd_device(shost, cmd);
  453. continue;
  454. case TASK_IS_ABORTED:
  455. SAS_DPRINTK("%s: task 0x%p is aborted\n",
  456. __FUNCTION__, task);
  457. task->task_done(task);
  458. if (need_reset)
  459. try_to_reset_cmd_device(shost, cmd);
  460. continue;
  461. case TASK_IS_AT_LU:
  462. SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task);
  463. tmf_resp = sas_recover_lu(task->dev, cmd);
  464. if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
  465. SAS_DPRINTK("dev %016llx LU %x is "
  466. "recovered\n",
  467. SAS_ADDR(task->dev),
  468. cmd->device->lun);
  469. task->task_done(task);
  470. if (need_reset)
  471. try_to_reset_cmd_device(shost, cmd);
  472. sas_scsi_clear_queue_lu(work_q, cmd);
  473. goto Again;
  474. }
  475. /* fallthrough */
  476. case TASK_IS_NOT_AT_LU:
  477. case TASK_ABORT_FAILED:
  478. SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n",
  479. task);
  480. tmf_resp = sas_recover_I_T(task->dev);
  481. if (tmf_resp == TMF_RESP_FUNC_COMPLETE) {
  482. SAS_DPRINTK("I_T %016llx recovered\n",
  483. SAS_ADDR(task->dev->sas_addr));
  484. task->task_done(task);
  485. if (need_reset)
  486. try_to_reset_cmd_device(shost, cmd);
  487. sas_scsi_clear_queue_I_T(work_q, task->dev);
  488. goto Again;
  489. }
  490. /* Hammer time :-) */
  491. if (i->dft->lldd_clear_nexus_port) {
  492. struct asd_sas_port *port = task->dev->port;
  493. SAS_DPRINTK("clearing nexus for port:%d\n",
  494. port->id);
  495. res = i->dft->lldd_clear_nexus_port(port);
  496. if (res == TMF_RESP_FUNC_COMPLETE) {
  497. SAS_DPRINTK("clear nexus port:%d "
  498. "succeeded\n", port->id);
  499. task->task_done(task);
  500. if (need_reset)
  501. try_to_reset_cmd_device(shost, cmd);
  502. sas_scsi_clear_queue_port(work_q,
  503. port);
  504. goto Again;
  505. }
  506. }
  507. if (i->dft->lldd_clear_nexus_ha) {
  508. SAS_DPRINTK("clear nexus ha\n");
  509. res = i->dft->lldd_clear_nexus_ha(ha);
  510. if (res == TMF_RESP_FUNC_COMPLETE) {
  511. SAS_DPRINTK("clear nexus ha "
  512. "succeeded\n");
  513. task->task_done(task);
  514. if (need_reset)
  515. try_to_reset_cmd_device(shost, cmd);
  516. goto out;
  517. }
  518. }
  519. /* If we are here -- this means that no amount
  520. * of effort could recover from errors. Quite
  521. * possibly the HA just disappeared.
  522. */
  523. SAS_DPRINTK("error from device %llx, LUN %x "
  524. "couldn't be recovered in any way\n",
  525. SAS_ADDR(task->dev->sas_addr),
  526. cmd->device->lun);
  527. task->task_done(task);
  528. if (need_reset)
  529. try_to_reset_cmd_device(shost, cmd);
  530. goto clear_q;
  531. }
  532. }
  533. out:
  534. return list_empty(work_q);
  535. clear_q:
  536. SAS_DPRINTK("--- Exit %s -- clear_q\n", __FUNCTION__);
  537. list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
  538. struct sas_task *task = TO_SAS_TASK(cmd);
  539. list_del_init(&cmd->eh_entry);
  540. task->task_done(task);
  541. }
  542. return list_empty(work_q);
  543. }
  544. void sas_scsi_recover_host(struct Scsi_Host *shost)
  545. {
  546. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  547. unsigned long flags;
  548. LIST_HEAD(eh_work_q);
  549. spin_lock_irqsave(shost->host_lock, flags);
  550. list_splice_init(&shost->eh_cmd_q, &eh_work_q);
  551. spin_unlock_irqrestore(shost->host_lock, flags);
  552. SAS_DPRINTK("Enter %s\n", __FUNCTION__);
  553. /*
  554. * Deal with commands that still have SAS tasks (i.e. they didn't
  555. * complete via the normal sas_task completion mechanism)
  556. */
  557. if (sas_eh_handle_sas_errors(shost, &eh_work_q, &ha->eh_done_q))
  558. goto out;
  559. /*
  560. * Now deal with SCSI commands that completed ok but have a an error
  561. * code (and hopefully sense data) attached. This is roughly what
  562. * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any
  563. * command we see here has no sas_task and is thus unknown to the HA.
  564. */
  565. if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q))
  566. scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q);
  567. out:
  568. scsi_eh_flush_done_q(&ha->eh_done_q);
  569. SAS_DPRINTK("--- Exit %s\n", __FUNCTION__);
  570. return;
  571. }
  572. enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
  573. {
  574. struct sas_task *task = TO_SAS_TASK(cmd);
  575. unsigned long flags;
  576. if (!task) {
  577. cmd->timeout_per_command /= 2;
  578. SAS_DPRINTK("command 0x%p, task 0x%p, gone: %s\n",
  579. cmd, task, (cmd->timeout_per_command ?
  580. "EH_RESET_TIMER" : "EH_NOT_HANDLED"));
  581. if (!cmd->timeout_per_command)
  582. return EH_NOT_HANDLED;
  583. return EH_RESET_TIMER;
  584. }
  585. spin_lock_irqsave(&task->task_state_lock, flags);
  586. BUG_ON(task->task_state_flags & SAS_TASK_STATE_ABORTED);
  587. if (task->task_state_flags & SAS_TASK_STATE_DONE) {
  588. spin_unlock_irqrestore(&task->task_state_lock, flags);
  589. SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_HANDLED\n",
  590. cmd, task);
  591. return EH_HANDLED;
  592. }
  593. if (!(task->task_state_flags & SAS_TASK_AT_INITIATOR)) {
  594. spin_unlock_irqrestore(&task->task_state_lock, flags);
  595. SAS_DPRINTK("command 0x%p, task 0x%p, not at initiator: "
  596. "EH_RESET_TIMER\n",
  597. cmd, task);
  598. return EH_RESET_TIMER;
  599. }
  600. task->task_state_flags |= SAS_TASK_STATE_ABORTED;
  601. spin_unlock_irqrestore(&task->task_state_lock, flags);
  602. SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_NOT_HANDLED\n",
  603. cmd, task);
  604. return EH_NOT_HANDLED;
  605. }
  606. static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts)
  607. {
  608. /* Cheesy attempt to translate SAS errors into ATA. Hah! */
  609. /* transport error */
  610. if (ts->resp == SAS_TASK_UNDELIVERED)
  611. return AC_ERR_ATA_BUS;
  612. /* ts->resp == SAS_TASK_COMPLETE */
  613. /* task delivered, what happened afterwards? */
  614. switch (ts->stat) {
  615. case SAS_DEV_NO_RESPONSE:
  616. return AC_ERR_TIMEOUT;
  617. case SAS_INTERRUPTED:
  618. case SAS_PHY_DOWN:
  619. case SAS_NAK_R_ERR:
  620. return AC_ERR_ATA_BUS;
  621. case SAS_DATA_UNDERRUN:
  622. /*
  623. * Some programs that use the taskfile interface
  624. * (smartctl in particular) can cause underrun
  625. * problems. Ignore these errors, perhaps at our
  626. * peril.
  627. */
  628. return 0;
  629. case SAS_DATA_OVERRUN:
  630. case SAS_QUEUE_FULL:
  631. case SAS_DEVICE_UNKNOWN:
  632. case SAS_SG_ERR:
  633. return AC_ERR_INVALID;
  634. case SAM_CHECK_COND:
  635. case SAS_OPEN_TO:
  636. case SAS_OPEN_REJECT:
  637. case SAS_PROTO_RESPONSE:
  638. SAS_DPRINTK("%s: Saw error %d. What to do?\n",
  639. __FUNCTION__, ts->stat);
  640. return AC_ERR_OTHER;
  641. case SAS_ABORTED_TASK:
  642. return AC_ERR_DEV;
  643. default:
  644. return 0;
  645. }
  646. }
  647. static void sas_ata_task_done(struct sas_task *task)
  648. {
  649. struct ata_queued_cmd *qc = task->uldd_task;
  650. struct domain_device *dev = qc->ap->private_data;
  651. struct task_status_struct *stat = &task->task_status;
  652. struct ata_task_resp *resp = (struct ata_task_resp *)stat->buf;
  653. enum ata_completion_errors ac;
  654. ac = sas_to_ata_err(stat);
  655. if (ac) {
  656. SAS_DPRINTK("%s: SAS error %x\n", __FUNCTION__, stat->stat);
  657. /* We saw a SAS error. Send a vague error. */
  658. qc->err_mask = ac;
  659. dev->sata_dev.tf.feature = 0x04; /* status err */
  660. dev->sata_dev.tf.command = ATA_ERR;
  661. goto end;
  662. }
  663. ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf);
  664. qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
  665. dev->sata_dev.sstatus = resp->sstatus;
  666. dev->sata_dev.serror = resp->serror;
  667. dev->sata_dev.scontrol = resp->scontrol;
  668. dev->sata_dev.ap->sactive = resp->sactive;
  669. end:
  670. ata_qc_complete(qc);
  671. list_del_init(&task->list);
  672. sas_free_task(task);
  673. }
  674. int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
  675. {
  676. struct domain_device *dev = sdev_to_domain_dev(sdev);
  677. if (dev_is_sata(dev))
  678. return ata_scsi_ioctl(sdev, cmd, arg);
  679. return -EINVAL;
  680. }
  681. static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
  682. {
  683. int res = -ENOMEM;
  684. struct sas_task *task;
  685. struct domain_device *dev = qc->ap->private_data;
  686. struct sas_ha_struct *sas_ha = dev->port->ha;
  687. struct Scsi_Host *host = sas_ha->core.shost;
  688. struct sas_internal *i = to_sas_internal(host->transportt);
  689. struct scatterlist *sg;
  690. unsigned int num = 0;
  691. unsigned int xfer = 0;
  692. task = sas_alloc_task(GFP_ATOMIC);
  693. if (!task)
  694. goto out;
  695. task->dev = dev;
  696. task->task_proto = SAS_PROTOCOL_STP;
  697. task->task_done = sas_ata_task_done;
  698. ata_tf_to_fis(&qc->tf, (u8*)&task->ata_task.fis, 0);
  699. task->uldd_task = qc;
  700. if (is_atapi_taskfile(&qc->tf)) {
  701. memcpy(task->ata_task.atapi_packet, qc->cdb, ATAPI_CDB_LEN);
  702. task->total_xfer_len = qc->nbytes + qc->pad_len;
  703. task->num_scatter = qc->pad_len ? qc->n_elem + 1 : qc->n_elem;
  704. } else {
  705. ata_for_each_sg(sg, qc) {
  706. num++;
  707. xfer += sg->length;
  708. }
  709. task->total_xfer_len = xfer;
  710. task->num_scatter = num;
  711. }
  712. task->data_dir = qc->dma_dir;
  713. task->scatter = qc->__sg;
  714. task->ata_task.retry_count = 1;
  715. task->task_state_flags = SAS_TASK_STATE_PENDING;
  716. if (qc->tf.protocol == ATA_PROT_DMA)
  717. task->ata_task.dma_xfer = 1;
  718. if (sas_ha->lldd_max_execute_num < 2)
  719. res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
  720. else
  721. res = sas_queue_up(task);
  722. /* Examine */
  723. if (res) {
  724. SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
  725. sas_free_task(task);
  726. if (res == -SAS_QUEUE_FULL)
  727. return -ENOMEM;
  728. }
  729. out:
  730. return res;
  731. }
  732. static u8 sas_ata_check_status(struct ata_port *ap)
  733. {
  734. struct domain_device *dev = ap->private_data;
  735. return dev->sata_dev.tf.command;
  736. }
  737. static void sas_ata_phy_reset(struct ata_port *ap)
  738. {
  739. struct domain_device *dev = ap->private_data;
  740. struct sas_internal *i =
  741. to_sas_internal(dev->port->ha->core.shost->transportt);
  742. int res = 0;
  743. if (i->dft->lldd_I_T_nexus_reset)
  744. res = i->dft->lldd_I_T_nexus_reset(dev);
  745. if (res)
  746. SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __FUNCTION__);
  747. switch (dev->sata_dev.command_set) {
  748. case ATA_COMMAND_SET:
  749. SAS_DPRINTK("%s: Found ATA device.\n", __FUNCTION__);
  750. ap->device[0].class = ATA_DEV_ATA;
  751. break;
  752. case ATAPI_COMMAND_SET:
  753. SAS_DPRINTK("%s: Found ATAPI device.\n", __FUNCTION__);
  754. ap->device[0].class = ATA_DEV_ATAPI;
  755. break;
  756. default:
  757. SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
  758. __FUNCTION__,
  759. dev->sata_dev.command_set);
  760. ap->device[0].class = ATA_DEV_ATA;
  761. break;
  762. }
  763. ap->cbl = ATA_CBL_SATA;
  764. }
  765. static void sas_ata_post_internal(struct ata_queued_cmd *qc)
  766. {
  767. if (qc->flags & ATA_QCFLAG_FAILED)
  768. qc->err_mask |= AC_ERR_OTHER;
  769. if (qc->err_mask)
  770. SAS_DPRINTK("%s: Failure; reset phy!\n", __FUNCTION__);
  771. }
  772. static void sas_ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
  773. {
  774. struct domain_device *dev = ap->private_data;
  775. memcpy(tf, &dev->sata_dev.tf, sizeof (*tf));
  776. }
  777. static void sas_ata_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
  778. u32 val)
  779. {
  780. struct domain_device *dev = ap->private_data;
  781. SAS_DPRINTK("STUB %s\n", __FUNCTION__);
  782. switch (sc_reg_in) {
  783. case SCR_STATUS:
  784. dev->sata_dev.sstatus = val;
  785. break;
  786. case SCR_CONTROL:
  787. dev->sata_dev.scontrol = val;
  788. break;
  789. case SCR_ERROR:
  790. dev->sata_dev.serror = val;
  791. break;
  792. case SCR_ACTIVE:
  793. dev->sata_dev.ap->sactive = val;
  794. break;
  795. }
  796. }
  797. static u32 sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
  798. {
  799. struct domain_device *dev = ap->private_data;
  800. SAS_DPRINTK("STUB %s\n", __FUNCTION__);
  801. switch (sc_reg_in) {
  802. case SCR_STATUS:
  803. return dev->sata_dev.sstatus;
  804. case SCR_CONTROL:
  805. return dev->sata_dev.scontrol;
  806. case SCR_ERROR:
  807. return dev->sata_dev.serror;
  808. case SCR_ACTIVE:
  809. return dev->sata_dev.ap->sactive;
  810. default:
  811. return 0xffffffffU;
  812. }
  813. }
  814. static struct ata_port_operations sas_sata_ops = {
  815. .port_disable = ata_port_disable,
  816. .check_status = sas_ata_check_status,
  817. .check_altstatus = sas_ata_check_status,
  818. .dev_select = ata_noop_dev_select,
  819. .phy_reset = sas_ata_phy_reset,
  820. .post_internal_cmd = sas_ata_post_internal,
  821. .tf_read = sas_ata_tf_read,
  822. .qc_prep = ata_noop_qc_prep,
  823. .qc_issue = sas_ata_qc_issue,
  824. .port_start = ata_sas_port_start,
  825. .port_stop = ata_sas_port_stop,
  826. .scr_read = sas_ata_scr_read,
  827. .scr_write = sas_ata_scr_write
  828. };
  829. static struct ata_port_info sata_port_info = {
  830. .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | ATA_FLAG_SATA_RESET |
  831. ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
  832. .pio_mask = 0x1f, /* PIO0-4 */
  833. .mwdma_mask = 0x07, /* MWDMA0-2 */
  834. .udma_mask = ATA_UDMA6,
  835. .port_ops = &sas_sata_ops
  836. };
  837. struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy)
  838. {
  839. struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent);
  840. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  841. struct domain_device *found_dev = NULL;
  842. int i;
  843. unsigned long flags;
  844. spin_lock_irqsave(&ha->phy_port_lock, flags);
  845. for (i = 0; i < ha->num_phys; i++) {
  846. struct asd_sas_port *port = ha->sas_port[i];
  847. struct domain_device *dev;
  848. spin_lock(&port->dev_list_lock);
  849. list_for_each_entry(dev, &port->dev_list, dev_list_node) {
  850. if (rphy == dev->rphy) {
  851. found_dev = dev;
  852. spin_unlock(&port->dev_list_lock);
  853. goto found;
  854. }
  855. }
  856. spin_unlock(&port->dev_list_lock);
  857. }
  858. found:
  859. spin_unlock_irqrestore(&ha->phy_port_lock, flags);
  860. return found_dev;
  861. }
  862. static inline struct domain_device *sas_find_target(struct scsi_target *starget)
  863. {
  864. struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent);
  865. return sas_find_dev_by_rphy(rphy);
  866. }
  867. int sas_target_alloc(struct scsi_target *starget)
  868. {
  869. struct Scsi_Host *shost = dev_to_shost(&starget->dev);
  870. struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
  871. struct domain_device *found_dev = sas_find_target(starget);
  872. if (!found_dev)
  873. return -ENODEV;
  874. if (dev_is_sata(found_dev)) {
  875. struct ata_port *ap;
  876. ata_host_init(&found_dev->sata_dev.ata_host,
  877. &ha->pcidev->dev,
  878. sata_port_info.flags,
  879. &sas_sata_ops);
  880. ap = ata_sas_port_alloc(&found_dev->sata_dev.ata_host,
  881. &sata_port_info,
  882. shost);
  883. if (!ap) {
  884. SAS_DPRINTK("ata_sas_port_alloc failed.\n");
  885. return -ENODEV;
  886. }
  887. ap->private_data = found_dev;
  888. ap->cbl = ATA_CBL_SATA;
  889. found_dev->sata_dev.ap = ap;
  890. }
  891. starget->hostdata = found_dev;
  892. return 0;
  893. }
  894. #define SAS_DEF_QD 32
  895. #define SAS_MAX_QD 64
  896. int sas_slave_configure(struct scsi_device *scsi_dev)
  897. {
  898. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  899. struct sas_ha_struct *sas_ha;
  900. BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE);
  901. if (dev_is_sata(dev)) {
  902. ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap);
  903. return 0;
  904. }
  905. sas_ha = dev->port->ha;
  906. sas_read_port_mode_page(scsi_dev);
  907. if (scsi_dev->tagged_supported) {
  908. scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG);
  909. scsi_activate_tcq(scsi_dev, SAS_DEF_QD);
  910. } else {
  911. SAS_DPRINTK("device %llx, LUN %x doesn't support "
  912. "TCQ\n", SAS_ADDR(dev->sas_addr),
  913. scsi_dev->lun);
  914. scsi_dev->tagged_supported = 0;
  915. scsi_set_tag_type(scsi_dev, 0);
  916. scsi_deactivate_tcq(scsi_dev, 1);
  917. }
  918. scsi_dev->allow_restart = 1;
  919. return 0;
  920. }
  921. void sas_slave_destroy(struct scsi_device *scsi_dev)
  922. {
  923. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  924. if (dev_is_sata(dev))
  925. ata_port_disable(dev->sata_dev.ap);
  926. }
  927. int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth)
  928. {
  929. int res = min(new_depth, SAS_MAX_QD);
  930. if (scsi_dev->tagged_supported)
  931. scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev),
  932. res);
  933. else {
  934. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  935. sas_printk("device %llx LUN %x queue depth changed to 1\n",
  936. SAS_ADDR(dev->sas_addr),
  937. scsi_dev->lun);
  938. scsi_adjust_queue_depth(scsi_dev, 0, 1);
  939. res = 1;
  940. }
  941. return res;
  942. }
  943. int sas_change_queue_type(struct scsi_device *scsi_dev, int qt)
  944. {
  945. if (!scsi_dev->tagged_supported)
  946. return 0;
  947. scsi_deactivate_tcq(scsi_dev, 1);
  948. scsi_set_tag_type(scsi_dev, qt);
  949. scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth);
  950. return qt;
  951. }
  952. int sas_bios_param(struct scsi_device *scsi_dev,
  953. struct block_device *bdev,
  954. sector_t capacity, int *hsc)
  955. {
  956. hsc[0] = 255;
  957. hsc[1] = 63;
  958. sector_div(capacity, 255*63);
  959. hsc[2] = capacity;
  960. return 0;
  961. }
  962. /* ---------- Task Collector Thread implementation ---------- */
  963. static void sas_queue(struct sas_ha_struct *sas_ha)
  964. {
  965. struct scsi_core *core = &sas_ha->core;
  966. unsigned long flags;
  967. LIST_HEAD(q);
  968. int can_queue;
  969. int res;
  970. struct sas_internal *i = to_sas_internal(core->shost->transportt);
  971. spin_lock_irqsave(&core->task_queue_lock, flags);
  972. while (!kthread_should_stop() &&
  973. !list_empty(&core->task_queue)) {
  974. can_queue = sas_ha->lldd_queue_size - core->task_queue_size;
  975. if (can_queue >= 0) {
  976. can_queue = core->task_queue_size;
  977. list_splice_init(&core->task_queue, &q);
  978. } else {
  979. struct list_head *a, *n;
  980. can_queue = sas_ha->lldd_queue_size;
  981. list_for_each_safe(a, n, &core->task_queue) {
  982. list_move_tail(a, &q);
  983. if (--can_queue == 0)
  984. break;
  985. }
  986. can_queue = sas_ha->lldd_queue_size;
  987. }
  988. core->task_queue_size -= can_queue;
  989. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  990. {
  991. struct sas_task *task = list_entry(q.next,
  992. struct sas_task,
  993. list);
  994. list_del_init(&q);
  995. res = i->dft->lldd_execute_task(task, can_queue,
  996. GFP_KERNEL);
  997. if (unlikely(res))
  998. __list_add(&q, task->list.prev, &task->list);
  999. }
  1000. spin_lock_irqsave(&core->task_queue_lock, flags);
  1001. if (res) {
  1002. list_splice_init(&q, &core->task_queue); /*at head*/
  1003. core->task_queue_size += can_queue;
  1004. }
  1005. }
  1006. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  1007. }
  1008. /**
  1009. * sas_queue_thread -- The Task Collector thread
  1010. * @_sas_ha: pointer to struct sas_ha
  1011. */
  1012. static int sas_queue_thread(void *_sas_ha)
  1013. {
  1014. struct sas_ha_struct *sas_ha = _sas_ha;
  1015. while (1) {
  1016. set_current_state(TASK_INTERRUPTIBLE);
  1017. schedule();
  1018. sas_queue(sas_ha);
  1019. if (kthread_should_stop())
  1020. break;
  1021. }
  1022. return 0;
  1023. }
  1024. int sas_init_queue(struct sas_ha_struct *sas_ha)
  1025. {
  1026. struct scsi_core *core = &sas_ha->core;
  1027. spin_lock_init(&core->task_queue_lock);
  1028. core->task_queue_size = 0;
  1029. INIT_LIST_HEAD(&core->task_queue);
  1030. core->queue_thread = kthread_run(sas_queue_thread, sas_ha,
  1031. "sas_queue_%d", core->shost->host_no);
  1032. if (IS_ERR(core->queue_thread))
  1033. return PTR_ERR(core->queue_thread);
  1034. return 0;
  1035. }
  1036. void sas_shutdown_queue(struct sas_ha_struct *sas_ha)
  1037. {
  1038. unsigned long flags;
  1039. struct scsi_core *core = &sas_ha->core;
  1040. struct sas_task *task, *n;
  1041. kthread_stop(core->queue_thread);
  1042. if (!list_empty(&core->task_queue))
  1043. SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n",
  1044. SAS_ADDR(sas_ha->sas_addr));
  1045. spin_lock_irqsave(&core->task_queue_lock, flags);
  1046. list_for_each_entry_safe(task, n, &core->task_queue, list) {
  1047. struct scsi_cmnd *cmd = task->uldd_task;
  1048. list_del_init(&task->list);
  1049. ASSIGN_SAS_TASK(cmd, NULL);
  1050. sas_free_task(task);
  1051. cmd->result = DID_ABORT << 16;
  1052. cmd->scsi_done(cmd);
  1053. }
  1054. spin_unlock_irqrestore(&core->task_queue_lock, flags);
  1055. }
  1056. /*
  1057. * Call the LLDD task abort routine directly. This function is intended for
  1058. * use by upper layers that need to tell the LLDD to abort a task.
  1059. */
  1060. int __sas_task_abort(struct sas_task *task)
  1061. {
  1062. struct sas_internal *si =
  1063. to_sas_internal(task->dev->port->ha->core.shost->transportt);
  1064. unsigned long flags;
  1065. int res;
  1066. spin_lock_irqsave(&task->task_state_lock, flags);
  1067. if (task->task_state_flags & SAS_TASK_STATE_ABORTED ||
  1068. task->task_state_flags & SAS_TASK_STATE_DONE) {
  1069. spin_unlock_irqrestore(&task->task_state_lock, flags);
  1070. SAS_DPRINTK("%s: Task %p already finished.\n", __FUNCTION__,
  1071. task);
  1072. return 0;
  1073. }
  1074. task->task_state_flags |= SAS_TASK_STATE_ABORTED;
  1075. spin_unlock_irqrestore(&task->task_state_lock, flags);
  1076. if (!si->dft->lldd_abort_task)
  1077. return -ENODEV;
  1078. res = si->dft->lldd_abort_task(task);
  1079. spin_lock_irqsave(&task->task_state_lock, flags);
  1080. if ((task->task_state_flags & SAS_TASK_STATE_DONE) ||
  1081. (res == TMF_RESP_FUNC_COMPLETE))
  1082. {
  1083. spin_unlock_irqrestore(&task->task_state_lock, flags);
  1084. task->task_done(task);
  1085. return 0;
  1086. }
  1087. if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
  1088. task->task_state_flags &= ~SAS_TASK_STATE_ABORTED;
  1089. spin_unlock_irqrestore(&task->task_state_lock, flags);
  1090. return -EAGAIN;
  1091. }
  1092. /*
  1093. * Tell an upper layer that it needs to initiate an abort for a given task.
  1094. * This should only ever be called by an LLDD.
  1095. */
  1096. void sas_task_abort(struct sas_task *task)
  1097. {
  1098. struct scsi_cmnd *sc = task->uldd_task;
  1099. /* Escape for libsas internal commands */
  1100. if (!sc) {
  1101. if (!del_timer(&task->timer))
  1102. return;
  1103. task->timer.function(task->timer.data);
  1104. return;
  1105. }
  1106. scsi_req_abort_cmd(sc);
  1107. scsi_schedule_eh(sc->device->host);
  1108. }
  1109. int sas_slave_alloc(struct scsi_device *scsi_dev)
  1110. {
  1111. struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
  1112. if (dev_is_sata(dev))
  1113. return ata_sas_port_init(dev->sata_dev.ap);
  1114. return 0;
  1115. }
  1116. void sas_target_destroy(struct scsi_target *starget)
  1117. {
  1118. struct domain_device *found_dev = sas_find_target(starget);
  1119. if (!found_dev)
  1120. return;
  1121. if (dev_is_sata(found_dev))
  1122. ata_sas_port_destroy(found_dev->sata_dev.ap);
  1123. return;
  1124. }
  1125. EXPORT_SYMBOL_GPL(sas_queuecommand);
  1126. EXPORT_SYMBOL_GPL(sas_target_alloc);
  1127. EXPORT_SYMBOL_GPL(sas_slave_configure);
  1128. EXPORT_SYMBOL_GPL(sas_slave_destroy);
  1129. EXPORT_SYMBOL_GPL(sas_change_queue_depth);
  1130. EXPORT_SYMBOL_GPL(sas_change_queue_type);
  1131. EXPORT_SYMBOL_GPL(sas_bios_param);
  1132. EXPORT_SYMBOL_GPL(__sas_task_abort);
  1133. EXPORT_SYMBOL_GPL(sas_task_abort);
  1134. EXPORT_SYMBOL_GPL(sas_phy_reset);
  1135. EXPORT_SYMBOL_GPL(sas_phy_enable);
  1136. EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler);
  1137. EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler);
  1138. EXPORT_SYMBOL_GPL(sas_slave_alloc);
  1139. EXPORT_SYMBOL_GPL(sas_target_destroy);
  1140. EXPORT_SYMBOL_GPL(sas_ioctl);