db9238f2ecb8b7596dda9c2d4132000af0910bd7
[linux-2.6.git] / drivers / scsi / libsas / sas_ata.c
1 /*
2  * Support for SATA devices on Serial Attached SCSI (SAS) controllers
3  *
4  * Copyright (C) 2006 IBM Corporation
5  *
6  * Written by: Darrick J. Wong <djwong@us.ibm.com>, IBM Corporation
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of the
11  * License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * 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
21  * USA
22  */
23
24 #include <linux/scatterlist.h>
25 #include <linux/slab.h>
26
27 #include <scsi/sas_ata.h>
28 #include "sas_internal.h"
29 #include <scsi/scsi_host.h>
30 #include <scsi/scsi_device.h>
31 #include <scsi/scsi_tcq.h>
32 #include <scsi/scsi.h>
33 #include <scsi/scsi_transport.h>
34 #include <scsi/scsi_transport_sas.h>
35 #include "../scsi_sas_internal.h"
36 #include "../scsi_transport_api.h"
37 #include <scsi/scsi_eh.h>
38
39 static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts)
40 {
41         /* Cheesy attempt to translate SAS errors into ATA.  Hah! */
42
43         /* transport error */
44         if (ts->resp == SAS_TASK_UNDELIVERED)
45                 return AC_ERR_ATA_BUS;
46
47         /* ts->resp == SAS_TASK_COMPLETE */
48         /* task delivered, what happened afterwards? */
49         switch (ts->stat) {
50                 case SAS_DEV_NO_RESPONSE:
51                         return AC_ERR_TIMEOUT;
52
53                 case SAS_INTERRUPTED:
54                 case SAS_PHY_DOWN:
55                 case SAS_NAK_R_ERR:
56                         return AC_ERR_ATA_BUS;
57
58
59                 case SAS_DATA_UNDERRUN:
60                         /*
61                          * Some programs that use the taskfile interface
62                          * (smartctl in particular) can cause underrun
63                          * problems.  Ignore these errors, perhaps at our
64                          * peril.
65                          */
66                         return 0;
67
68                 case SAS_DATA_OVERRUN:
69                 case SAS_QUEUE_FULL:
70                 case SAS_DEVICE_UNKNOWN:
71                 case SAS_SG_ERR:
72                         return AC_ERR_INVALID;
73
74                 case SAS_OPEN_TO:
75                 case SAS_OPEN_REJECT:
76                         SAS_DPRINTK("%s: Saw error %d.  What to do?\n",
77                                     __func__, ts->stat);
78                         return AC_ERR_OTHER;
79
80                 case SAM_STAT_CHECK_CONDITION:
81                 case SAS_ABORTED_TASK:
82                         return AC_ERR_DEV;
83
84                 case SAS_PROTO_RESPONSE:
85                         /* This means the ending_fis has the error
86                          * value; return 0 here to collect it */
87                         return 0;
88                 default:
89                         return 0;
90         }
91 }
92
93 static void sas_ata_task_done(struct sas_task *task)
94 {
95         struct ata_queued_cmd *qc = task->uldd_task;
96         struct domain_device *dev;
97         struct task_status_struct *stat = &task->task_status;
98         struct ata_task_resp *resp = (struct ata_task_resp *)stat->buf;
99         struct sas_ha_struct *sas_ha;
100         enum ata_completion_errors ac;
101         unsigned long flags;
102         struct ata_link *link;
103
104         if (!qc)
105                 goto qc_already_gone;
106
107         dev = qc->ap->private_data;
108         sas_ha = dev->port->ha;
109         link = &dev->sata_dev.ap->link;
110
111         spin_lock_irqsave(dev->sata_dev.ap->lock, flags);
112         if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD ||
113             ((stat->stat == SAM_STAT_CHECK_CONDITION &&
114               dev->sata_dev.command_set == ATAPI_COMMAND_SET))) {
115                 ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf);
116
117                 if (!link->sactive) {
118                         qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
119                 } else {
120                         link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.tf.command);
121                         if (unlikely(link->eh_info.err_mask))
122                                 qc->flags |= ATA_QCFLAG_FAILED;
123                 }
124
125                 dev->sata_dev.sstatus = resp->sstatus;
126                 dev->sata_dev.serror = resp->serror;
127                 dev->sata_dev.scontrol = resp->scontrol;
128         } else {
129                 ac = sas_to_ata_err(stat);
130                 if (ac) {
131                         SAS_DPRINTK("%s: SAS error %x\n", __func__,
132                                     stat->stat);
133                         /* We saw a SAS error. Send a vague error. */
134                         if (!link->sactive) {
135                                 qc->err_mask = ac;
136                         } else {
137                                 link->eh_info.err_mask |= AC_ERR_DEV;
138                                 qc->flags |= ATA_QCFLAG_FAILED;
139                         }
140
141                         dev->sata_dev.tf.feature = 0x04; /* status err */
142                         dev->sata_dev.tf.command = ATA_ERR;
143                 }
144         }
145
146         qc->lldd_task = NULL;
147         if (qc->scsicmd)
148                 ASSIGN_SAS_TASK(qc->scsicmd, NULL);
149         ata_qc_complete(qc);
150         spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags);
151
152         /*
153          * If the sas_task has an ata qc, a scsi_cmnd and the aborted
154          * flag is set, then we must have come in via the libsas EH
155          * functions.  When we exit this function, we need to put the
156          * scsi_cmnd on the list of finished errors.  The ata_qc_complete
157          * call cleans up the libata side of things but we're protected
158          * from the scsi_cmnd going away because the scsi_cmnd is owned
159          * by the EH, making libata's call to scsi_done a NOP.
160          */
161         spin_lock_irqsave(&task->task_state_lock, flags);
162         if (qc->scsicmd && task->task_state_flags & SAS_TASK_STATE_ABORTED)
163                 scsi_eh_finish_cmd(qc->scsicmd, &sas_ha->eh_done_q);
164         spin_unlock_irqrestore(&task->task_state_lock, flags);
165
166 qc_already_gone:
167         list_del_init(&task->list);
168         sas_free_task(task);
169 }
170
171 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
172 {
173         int res;
174         struct sas_task *task;
175         struct domain_device *dev = qc->ap->private_data;
176         struct sas_ha_struct *sas_ha = dev->port->ha;
177         struct Scsi_Host *host = sas_ha->core.shost;
178         struct sas_internal *i = to_sas_internal(host->transportt);
179         struct scatterlist *sg;
180         unsigned int xfer = 0;
181         unsigned int si;
182
183         /* If the device fell off, no sense in issuing commands */
184         if (dev->gone)
185                 return AC_ERR_SYSTEM;
186
187         task = sas_alloc_task(GFP_ATOMIC);
188         if (!task)
189                 return AC_ERR_SYSTEM;
190         task->dev = dev;
191         task->task_proto = SAS_PROTOCOL_STP;
192         task->task_done = sas_ata_task_done;
193
194         if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
195             qc->tf.command == ATA_CMD_FPDMA_READ) {
196                 /* Need to zero out the tag libata assigned us */
197                 qc->tf.nsect = 0;
198         }
199
200         ata_tf_to_fis(&qc->tf, 1, 0, (u8*)&task->ata_task.fis);
201         task->uldd_task = qc;
202         if (ata_is_atapi(qc->tf.protocol)) {
203                 memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len);
204                 task->total_xfer_len = qc->nbytes;
205                 task->num_scatter = qc->n_elem;
206         } else {
207                 for_each_sg(qc->sg, sg, qc->n_elem, si)
208                         xfer += sg->length;
209
210                 task->total_xfer_len = xfer;
211                 task->num_scatter = si;
212         }
213
214         task->data_dir = qc->dma_dir;
215         task->scatter = qc->sg;
216         task->ata_task.retry_count = 1;
217         task->task_state_flags = SAS_TASK_STATE_PENDING;
218         qc->lldd_task = task;
219
220         switch (qc->tf.protocol) {
221         case ATA_PROT_NCQ:
222                 task->ata_task.use_ncq = 1;
223                 /* fall through */
224         case ATAPI_PROT_DMA:
225         case ATA_PROT_DMA:
226                 task->ata_task.dma_xfer = 1;
227                 break;
228         }
229
230         if (qc->scsicmd)
231                 ASSIGN_SAS_TASK(qc->scsicmd, task);
232
233         if (sas_ha->lldd_max_execute_num < 2)
234                 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
235         else
236                 res = sas_queue_up(task);
237
238         /* Examine */
239         if (res) {
240                 SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
241
242                 if (qc->scsicmd)
243                         ASSIGN_SAS_TASK(qc->scsicmd, NULL);
244                 sas_free_task(task);
245                 return AC_ERR_SYSTEM;
246         }
247
248         return 0;
249 }
250
251 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
252 {
253         struct domain_device *dev = qc->ap->private_data;
254
255         memcpy(&qc->result_tf, &dev->sata_dev.tf, sizeof(qc->result_tf));
256         return true;
257 }
258
259 static int sas_ata_hard_reset(struct ata_link *link, unsigned int *class,
260                                unsigned long deadline)
261 {
262         struct ata_port *ap = link->ap;
263         struct domain_device *dev = ap->private_data;
264         struct sas_internal *i =
265                 to_sas_internal(dev->port->ha->core.shost->transportt);
266         int res = TMF_RESP_FUNC_FAILED;
267         int ret = 0;
268
269         if (i->dft->lldd_I_T_nexus_reset)
270                 res = i->dft->lldd_I_T_nexus_reset(dev);
271
272         if (res != TMF_RESP_FUNC_COMPLETE) {
273                 SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __func__);
274                 ret = -EAGAIN;
275         }
276
277         switch (dev->sata_dev.command_set) {
278                 case ATA_COMMAND_SET:
279                         SAS_DPRINTK("%s: Found ATA device.\n", __func__);
280                         *class = ATA_DEV_ATA;
281                         break;
282                 case ATAPI_COMMAND_SET:
283                         SAS_DPRINTK("%s: Found ATAPI device.\n", __func__);
284                         *class = ATA_DEV_ATAPI;
285                         break;
286                 default:
287                         SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
288                                     __func__,
289                                     dev->sata_dev.command_set);
290                         *class = ATA_DEV_UNKNOWN;
291                         break;
292         }
293
294         ap->cbl = ATA_CBL_SATA;
295         return ret;
296 }
297
298 static int sas_ata_soft_reset(struct ata_link *link, unsigned int *class,
299                                unsigned long deadline)
300 {
301         struct ata_port *ap = link->ap;
302         struct domain_device *dev = ap->private_data;
303         struct sas_internal *i =
304                 to_sas_internal(dev->port->ha->core.shost->transportt);
305         int res = TMF_RESP_FUNC_FAILED;
306         int ret = 0;
307
308         if (i->dft->lldd_ata_soft_reset)
309                 res = i->dft->lldd_ata_soft_reset(dev);
310
311         if (res != TMF_RESP_FUNC_COMPLETE) {
312                 SAS_DPRINTK("%s: Unable to soft reset\n", __func__);
313                 ret = -EAGAIN;
314         }
315
316         switch (dev->sata_dev.command_set) {
317         case ATA_COMMAND_SET:
318                 SAS_DPRINTK("%s: Found ATA device.\n", __func__);
319                 *class = ATA_DEV_ATA;
320                 break;
321         case ATAPI_COMMAND_SET:
322                 SAS_DPRINTK("%s: Found ATAPI device.\n", __func__);
323                 *class = ATA_DEV_ATAPI;
324                 break;
325         default:
326                 SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
327                             __func__, dev->sata_dev.command_set);
328                 *class = ATA_DEV_UNKNOWN;
329                 break;
330         }
331
332         ap->cbl = ATA_CBL_SATA;
333         return ret;
334 }
335
336 static void sas_ata_post_internal(struct ata_queued_cmd *qc)
337 {
338         if (qc->flags & ATA_QCFLAG_FAILED)
339                 qc->err_mask |= AC_ERR_OTHER;
340
341         if (qc->err_mask) {
342                 /*
343                  * Find the sas_task and kill it.  By this point,
344                  * libata has decided to kill the qc, so we needn't
345                  * bother with sas_ata_task_done.  But we still
346                  * ought to abort the task.
347                  */
348                 struct sas_task *task = qc->lldd_task;
349                 unsigned long flags;
350
351                 qc->lldd_task = NULL;
352                 if (task) {
353                         /* Should this be a AT(API) device reset? */
354                         spin_lock_irqsave(&task->task_state_lock, flags);
355                         task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
356                         spin_unlock_irqrestore(&task->task_state_lock, flags);
357
358                         task->uldd_task = NULL;
359                         __sas_task_abort(task);
360                 }
361         }
362 }
363
364 static struct ata_port_operations sas_sata_ops = {
365         .prereset               = ata_std_prereset,
366         .softreset              = sas_ata_soft_reset,
367         .hardreset              = sas_ata_hard_reset,
368         .postreset              = ata_std_postreset,
369         .error_handler          = ata_std_error_handler,
370         .post_internal_cmd      = sas_ata_post_internal,
371         .qc_defer               = ata_std_qc_defer,
372         .qc_prep                = ata_noop_qc_prep,
373         .qc_issue               = sas_ata_qc_issue,
374         .qc_fill_rtf            = sas_ata_qc_fill_rtf,
375         .port_start             = ata_sas_port_start,
376         .port_stop              = ata_sas_port_stop,
377 };
378
379 static struct ata_port_info sata_port_info = {
380         .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ,
381         .pio_mask = ATA_PIO4,
382         .mwdma_mask = ATA_MWDMA2,
383         .udma_mask = ATA_UDMA6,
384         .port_ops = &sas_sata_ops
385 };
386
387 int sas_ata_init_host_and_port(struct domain_device *found_dev,
388                                struct scsi_target *starget)
389 {
390         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
391         struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
392         struct ata_port *ap;
393
394         ata_host_init(&found_dev->sata_dev.ata_host,
395                       ha->dev,
396                       sata_port_info.flags,
397                       &sas_sata_ops);
398         ap = ata_sas_port_alloc(&found_dev->sata_dev.ata_host,
399                                 &sata_port_info,
400                                 shost);
401         if (!ap) {
402                 SAS_DPRINTK("ata_sas_port_alloc failed.\n");
403                 return -ENODEV;
404         }
405
406         ap->private_data = found_dev;
407         ap->cbl = ATA_CBL_SATA;
408         ap->scsi_host = shost;
409         found_dev->sata_dev.ap = ap;
410
411         return 0;
412 }
413
414 void sas_ata_task_abort(struct sas_task *task)
415 {
416         struct ata_queued_cmd *qc = task->uldd_task;
417         struct completion *waiting;
418
419         /* Bounce SCSI-initiated commands to the SCSI EH */
420         if (qc->scsicmd) {
421                 struct request_queue *q = qc->scsicmd->device->request_queue;
422                 unsigned long flags;
423
424                 spin_lock_irqsave(q->queue_lock, flags);
425                 blk_abort_request(qc->scsicmd->request);
426                 spin_unlock_irqrestore(q->queue_lock, flags);
427                 scsi_schedule_eh(qc->scsicmd->device->host);
428                 return;
429         }
430
431         /* Internal command, fake a timeout and complete. */
432         qc->flags &= ~ATA_QCFLAG_ACTIVE;
433         qc->flags |= ATA_QCFLAG_FAILED;
434         qc->err_mask |= AC_ERR_TIMEOUT;
435         waiting = qc->private_data;
436         complete(waiting);
437 }
438
439 static void sas_task_timedout(unsigned long _task)
440 {
441         struct sas_task *task = (void *) _task;
442         unsigned long flags;
443
444         spin_lock_irqsave(&task->task_state_lock, flags);
445         if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
446                 task->task_state_flags |= SAS_TASK_STATE_ABORTED;
447         spin_unlock_irqrestore(&task->task_state_lock, flags);
448
449         complete(&task->completion);
450 }
451
452 static void sas_disc_task_done(struct sas_task *task)
453 {
454         if (!del_timer(&task->timer))
455                 return;
456         complete(&task->completion);
457 }
458
459 #define SAS_DEV_TIMEOUT 10
460
461 /**
462  * sas_execute_task -- Basic task processing for discovery
463  * @task: the task to be executed
464  * @buffer: pointer to buffer to do I/O
465  * @size: size of @buffer
466  * @dma_dir: DMA direction.  DMA_xxx
467  */
468 static int sas_execute_task(struct sas_task *task, void *buffer, int size,
469                             enum dma_data_direction dma_dir)
470 {
471         int res = 0;
472         struct scatterlist *scatter = NULL;
473         struct task_status_struct *ts = &task->task_status;
474         int num_scatter = 0;
475         int retries = 0;
476         struct sas_internal *i =
477                 to_sas_internal(task->dev->port->ha->core.shost->transportt);
478
479         if (dma_dir != DMA_NONE) {
480                 scatter = kzalloc(sizeof(*scatter), GFP_KERNEL);
481                 if (!scatter)
482                         goto out;
483
484                 sg_init_one(scatter, buffer, size);
485                 num_scatter = 1;
486         }
487
488         task->task_proto = task->dev->tproto;
489         task->scatter = scatter;
490         task->num_scatter = num_scatter;
491         task->total_xfer_len = size;
492         task->data_dir = dma_dir;
493         task->task_done = sas_disc_task_done;
494         if (dma_dir != DMA_NONE &&
495             sas_protocol_ata(task->task_proto)) {
496                 task->num_scatter = dma_map_sg(task->dev->port->ha->dev,
497                                                task->scatter,
498                                                task->num_scatter,
499                                                task->data_dir);
500         }
501
502         for (retries = 0; retries < 5; retries++) {
503                 task->task_state_flags = SAS_TASK_STATE_PENDING;
504                 init_completion(&task->completion);
505
506                 task->timer.data = (unsigned long) task;
507                 task->timer.function = sas_task_timedout;
508                 task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ;
509                 add_timer(&task->timer);
510
511                 res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL);
512                 if (res) {
513                         del_timer(&task->timer);
514                         SAS_DPRINTK("executing SAS discovery task failed:%d\n",
515                                     res);
516                         goto ex_err;
517                 }
518                 wait_for_completion(&task->completion);
519                 res = -ECOMM;
520                 if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
521                         int res2;
522                         SAS_DPRINTK("task aborted, flags:0x%x\n",
523                                     task->task_state_flags);
524                         res2 = i->dft->lldd_abort_task(task);
525                         SAS_DPRINTK("came back from abort task\n");
526                         if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
527                                 if (res2 == TMF_RESP_FUNC_COMPLETE)
528                                         continue; /* Retry the task */
529                                 else
530                                         goto ex_err;
531                         }
532                 }
533                 if (task->task_status.stat == SAM_STAT_BUSY ||
534                            task->task_status.stat == SAM_STAT_TASK_SET_FULL ||
535                            task->task_status.stat == SAS_QUEUE_FULL) {
536                         SAS_DPRINTK("task: q busy, sleeping...\n");
537                         schedule_timeout_interruptible(HZ);
538                 } else if (task->task_status.stat == SAM_STAT_CHECK_CONDITION) {
539                         struct scsi_sense_hdr shdr;
540
541                         if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size,
542                                                   &shdr)) {
543                                 SAS_DPRINTK("couldn't normalize sense\n");
544                                 continue;
545                         }
546                         if ((shdr.sense_key == 6 && shdr.asc == 0x29) ||
547                             (shdr.sense_key == 2 && shdr.asc == 4 &&
548                              shdr.ascq == 1)) {
549                                 SAS_DPRINTK("device %016llx LUN: %016llx "
550                                             "powering up or not ready yet, "
551                                             "sleeping...\n",
552                                             SAS_ADDR(task->dev->sas_addr),
553                                             SAS_ADDR(task->ssp_task.LUN));
554
555                                 schedule_timeout_interruptible(5*HZ);
556                         } else if (shdr.sense_key == 1) {
557                                 res = 0;
558                                 break;
559                         } else if (shdr.sense_key == 5) {
560                                 break;
561                         } else {
562                                 SAS_DPRINTK("dev %016llx LUN: %016llx "
563                                             "sense key:0x%x ASC:0x%x ASCQ:0x%x"
564                                             "\n",
565                                             SAS_ADDR(task->dev->sas_addr),
566                                             SAS_ADDR(task->ssp_task.LUN),
567                                             shdr.sense_key,
568                                             shdr.asc, shdr.ascq);
569                         }
570                 } else if (task->task_status.resp != SAS_TASK_COMPLETE ||
571                            task->task_status.stat != SAM_STAT_GOOD) {
572                         SAS_DPRINTK("task finished with resp:0x%x, "
573                                     "stat:0x%x\n",
574                                     task->task_status.resp,
575                                     task->task_status.stat);
576                         goto ex_err;
577                 } else {
578                         res = 0;
579                         break;
580                 }
581         }
582 ex_err:
583         if (dma_dir != DMA_NONE) {
584                 if (sas_protocol_ata(task->task_proto))
585                         dma_unmap_sg(task->dev->port->ha->dev,
586                                      task->scatter, task->num_scatter,
587                                      task->data_dir);
588                 kfree(scatter);
589         }
590 out:
591         return res;
592 }
593
594 /* ---------- SATA ---------- */
595
596 static void sas_get_ata_command_set(struct domain_device *dev)
597 {
598         struct dev_to_host_fis *fis =
599                 (struct dev_to_host_fis *) dev->frame_rcvd;
600
601         if ((fis->sector_count == 1 && /* ATA */
602              fis->lbal         == 1 &&
603              fis->lbam         == 0 &&
604              fis->lbah         == 0 &&
605              fis->device       == 0)
606             ||
607             (fis->sector_count == 0 && /* CE-ATA (mATA) */
608              fis->lbal         == 0 &&
609              fis->lbam         == 0xCE &&
610              fis->lbah         == 0xAA &&
611              (fis->device & ~0x10) == 0))
612
613                 dev->sata_dev.command_set = ATA_COMMAND_SET;
614
615         else if ((fis->interrupt_reason == 1 && /* ATAPI */
616                   fis->lbal             == 1 &&
617                   fis->byte_count_low   == 0x14 &&
618                   fis->byte_count_high  == 0xEB &&
619                   (fis->device & ~0x10) == 0))
620
621                 dev->sata_dev.command_set = ATAPI_COMMAND_SET;
622
623         else if ((fis->sector_count == 1 && /* SEMB */
624                   fis->lbal         == 1 &&
625                   fis->lbam         == 0x3C &&
626                   fis->lbah         == 0xC3 &&
627                   fis->device       == 0)
628                 ||
629                  (fis->interrupt_reason == 1 && /* SATA PM */
630                   fis->lbal             == 1 &&
631                   fis->byte_count_low   == 0x69 &&
632                   fis->byte_count_high  == 0x96 &&
633                   (fis->device & ~0x10) == 0))
634
635                 /* Treat it as a superset? */
636                 dev->sata_dev.command_set = ATAPI_COMMAND_SET;
637 }
638
639 /**
640  * sas_issue_ata_cmd -- Basic SATA command processing for discovery
641  * @dev: the device to send the command to
642  * @command: the command register
643  * @features: the features register
644  * @buffer: pointer to buffer to do I/O
645  * @size: size of @buffer
646  * @dma_dir: DMA direction.  DMA_xxx
647  */
648 static int sas_issue_ata_cmd(struct domain_device *dev, u8 command,
649                              u8 features, void *buffer, int size,
650                              enum dma_data_direction dma_dir)
651 {
652         int res = 0;
653         struct sas_task *task;
654         struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *)
655                 &dev->frame_rcvd[0];
656
657         res = -ENOMEM;
658         task = sas_alloc_task(GFP_KERNEL);
659         if (!task)
660                 goto out;
661
662         task->dev = dev;
663
664         task->ata_task.fis.fis_type = 0x27;
665         task->ata_task.fis.command = command;
666         task->ata_task.fis.features = features;
667         task->ata_task.fis.device = d2h_fis->device;
668         task->ata_task.retry_count = 1;
669
670         res = sas_execute_task(task, buffer, size, dma_dir);
671
672         sas_free_task(task);
673 out:
674         return res;
675 }
676
677 #define ATA_IDENTIFY_DEV         0xEC
678 #define ATA_IDENTIFY_PACKET_DEV  0xA1
679 #define ATA_SET_FEATURES         0xEF
680 #define ATA_FEATURE_PUP_STBY_SPIN_UP 0x07
681
682 /**
683  * sas_discover_sata_dev -- discover a STP/SATA device (SATA_DEV)
684  * @dev: STP/SATA device of interest (ATA/ATAPI)
685  *
686  * The LLDD has already been notified of this device, so that we can
687  * send FISes to it.  Here we try to get IDENTIFY DEVICE or IDENTIFY
688  * PACKET DEVICE, if ATAPI device, so that the LLDD can fine-tune its
689  * performance for this device.
690  */
691 static int sas_discover_sata_dev(struct domain_device *dev)
692 {
693         int     res;
694         __le16  *identify_x;
695         u8      command;
696
697         identify_x = kzalloc(512, GFP_KERNEL);
698         if (!identify_x)
699                 return -ENOMEM;
700
701         if (dev->sata_dev.command_set == ATA_COMMAND_SET) {
702                 dev->sata_dev.identify_device = identify_x;
703                 command = ATA_IDENTIFY_DEV;
704         } else {
705                 dev->sata_dev.identify_packet_device = identify_x;
706                 command = ATA_IDENTIFY_PACKET_DEV;
707         }
708
709         res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512,
710                                 DMA_FROM_DEVICE);
711         if (res)
712                 goto out_err;
713
714         /* lives on the media? */
715         if (le16_to_cpu(identify_x[0]) & 4) {
716                 /* incomplete response */
717                 SAS_DPRINTK("sending SET FEATURE/PUP_STBY_SPIN_UP to "
718                             "dev %llx\n", SAS_ADDR(dev->sas_addr));
719                 if (!(identify_x[83] & cpu_to_le16(1<<6)))
720                         goto cont1;
721                 res = sas_issue_ata_cmd(dev, ATA_SET_FEATURES,
722                                         ATA_FEATURE_PUP_STBY_SPIN_UP,
723                                         NULL, 0, DMA_NONE);
724                 if (res)
725                         goto cont1;
726
727                 schedule_timeout_interruptible(5*HZ); /* More time? */
728                 res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512,
729                                         DMA_FROM_DEVICE);
730                 if (res)
731                         goto out_err;
732         }
733 cont1:
734         /* XXX Hint: register this SATA device with SATL.
735            When this returns, dev->sata_dev->lu is alive and
736            present.
737         sas_satl_register_dev(dev);
738         */
739
740         sas_fill_in_rphy(dev, dev->rphy);
741
742         return 0;
743 out_err:
744         dev->sata_dev.identify_packet_device = NULL;
745         dev->sata_dev.identify_device = NULL;
746         kfree(identify_x);
747         return res;
748 }
749
750 static int sas_discover_sata_pm(struct domain_device *dev)
751 {
752         return -ENODEV;
753 }
754
755 /**
756  * sas_discover_sata -- discover an STP/SATA domain device
757  * @dev: pointer to struct domain_device of interest
758  *
759  * First we notify the LLDD of this device, so we can send frames to
760  * it.  Then depending on the type of device we call the appropriate
761  * discover functions.  Once device discover is done, we notify the
762  * LLDD so that it can fine-tune its parameters for the device, by
763  * removing it and then adding it.  That is, the second time around,
764  * the driver would have certain fields, that it is looking at, set.
765  * Finally we initialize the kobj so that the device can be added to
766  * the system at registration time.  Devices directly attached to a HA
767  * port, have no parents.  All other devices do, and should have their
768  * "parent" pointer set appropriately before calling this function.
769  */
770 int sas_discover_sata(struct domain_device *dev)
771 {
772         int res;
773
774         sas_get_ata_command_set(dev);
775
776         res = sas_notify_lldd_dev_found(dev);
777         if (res)
778                 return res;
779
780         switch (dev->dev_type) {
781         case SATA_DEV:
782                 res = sas_discover_sata_dev(dev);
783                 break;
784         case SATA_PM:
785                 res = sas_discover_sata_pm(dev);
786                 break;
787         default:
788                 break;
789         }
790         sas_notify_lldd_dev_gone(dev);
791         if (!res) {
792                 sas_notify_lldd_dev_found(dev);
793                 res = sas_rphy_add(dev->rphy);
794         }
795
796         return res;
797 }
798
799 void sas_ata_strategy_handler(struct Scsi_Host *shost)
800 {
801         struct scsi_device *sdev;
802
803         shost_for_each_device(sdev, shost) {
804                 struct domain_device *ddev = sdev_to_domain_dev(sdev);
805                 struct ata_port *ap = ddev->sata_dev.ap;
806
807                 if (!dev_is_sata(ddev))
808                         continue;
809
810                 ata_port_printk(ap, KERN_DEBUG, "sas eh calling libata port error handler");
811                 ata_scsi_port_error_handler(shost, ap);
812         }
813 }
814
815 int sas_ata_timed_out(struct scsi_cmnd *cmd, struct sas_task *task,
816                       enum blk_eh_timer_return *rtn)
817 {
818         struct domain_device *ddev = cmd_to_domain_dev(cmd);
819
820         if (!dev_is_sata(ddev) || task)
821                 return 0;
822
823         /* we're a sata device with no task, so this must be a libata
824          * eh timeout.  Ideally should hook into libata timeout
825          * handling, but there's no point, it just wants to activate
826          * the eh thread */
827         *rtn = BLK_EH_NOT_HANDLED;
828         return 1;
829 }
830
831 int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q,
832                struct list_head *done_q)
833 {
834         int rtn = 0;
835         struct scsi_cmnd *cmd, *n;
836         struct ata_port *ap;
837
838         do {
839                 LIST_HEAD(sata_q);
840
841                 ap = NULL;
842
843                 list_for_each_entry_safe(cmd, n, work_q, eh_entry) {
844                         struct domain_device *ddev = cmd_to_domain_dev(cmd);
845
846                         if (!dev_is_sata(ddev) || TO_SAS_TASK(cmd))
847                                 continue;
848                         if (ap && ap != ddev->sata_dev.ap)
849                                 continue;
850                         ap = ddev->sata_dev.ap;
851                         rtn = 1;
852                         list_move(&cmd->eh_entry, &sata_q);
853                 }
854
855                 if (!list_empty(&sata_q)) {
856                         ata_port_printk(ap, KERN_DEBUG, "sas eh calling libata cmd error handler\n");
857                         ata_scsi_cmd_error_handler(shost, ap, &sata_q);
858                         /*
859                          * ata's error handler may leave the cmd on the list
860                          * so make sure they don't remain on a stack list
861                          * about to go out of scope.
862                          *
863                          * This looks strange, since the commands are
864                          * now part of no list, but the next error
865                          * action will be ata_port_error_handler()
866                          * which takes no list and sweeps them up
867                          * anyway from the ata tag array.
868                          */
869                         while (!list_empty(&sata_q))
870                                 list_del_init(sata_q.next);
871                 }
872         } while (ap);
873
874         return rtn;
875 }