1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#include <linux/slab.h>
42#include "pm8001_sas.h"
43
44
45
46
47
48
49static int pm8001_find_tag(struct sas_task *task, u32 *tag)
50{
51 if (task->lldd_task) {
52 struct pm8001_ccb_info *ccb;
53 ccb = task->lldd_task;
54 *tag = ccb->ccb_tag;
55 return 1;
56 }
57 return 0;
58}
59
60
61
62
63
64
65static void pm8001_tag_clear(struct pm8001_hba_info *pm8001_ha, u32 tag)
66{
67 void *bitmap = pm8001_ha->tags;
68 clear_bit(tag, bitmap);
69}
70
71void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha, u32 tag)
72{
73 pm8001_tag_clear(pm8001_ha, tag);
74}
75
76static void pm8001_tag_set(struct pm8001_hba_info *pm8001_ha, u32 tag)
77{
78 void *bitmap = pm8001_ha->tags;
79 set_bit(tag, bitmap);
80}
81
82
83
84
85
86
87inline int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha, u32 *tag_out)
88{
89 unsigned int index, tag;
90 void *bitmap = pm8001_ha->tags;
91
92 index = find_first_zero_bit(bitmap, pm8001_ha->tags_num);
93 tag = index;
94 if (tag >= pm8001_ha->tags_num)
95 return -SAS_QUEUE_FULL;
96 pm8001_tag_set(pm8001_ha, tag);
97 *tag_out = tag;
98 return 0;
99}
100
101void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha)
102{
103 int i;
104 for (i = 0; i < pm8001_ha->tags_num; ++i)
105 pm8001_tag_clear(pm8001_ha, i);
106}
107
108
109
110
111
112
113
114
115
116int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
117 dma_addr_t *pphys_addr, u32 *pphys_addr_hi,
118 u32 *pphys_addr_lo, u32 mem_size, u32 align)
119{
120 caddr_t mem_virt_alloc;
121 dma_addr_t mem_dma_handle;
122 u64 phys_align;
123 u64 align_offset = 0;
124 if (align)
125 align_offset = (dma_addr_t)align - 1;
126 mem_virt_alloc =
127 pci_alloc_consistent(pdev, mem_size + align, &mem_dma_handle);
128 if (!mem_virt_alloc) {
129 pm8001_printk("memory allocation error\n");
130 return -1;
131 }
132 memset((void *)mem_virt_alloc, 0, mem_size+align);
133 *pphys_addr = mem_dma_handle;
134 phys_align = (*pphys_addr + align_offset) & ~align_offset;
135 *virt_addr = (void *)mem_virt_alloc + phys_align - *pphys_addr;
136 *pphys_addr_hi = upper_32_bits(phys_align);
137 *pphys_addr_lo = lower_32_bits(phys_align);
138 return 0;
139}
140
141
142
143
144
145static
146struct pm8001_hba_info *pm8001_find_ha_by_dev(struct domain_device *dev)
147{
148 struct sas_ha_struct *sha = dev->port->ha;
149 struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
150 return pm8001_ha;
151}
152
153
154
155
156
157
158
159
160
161
162int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
163 void *funcdata)
164{
165 int rc = 0, phy_id = sas_phy->id;
166 struct pm8001_hba_info *pm8001_ha = NULL;
167 struct sas_phy_linkrates *rates;
168 DECLARE_COMPLETION_ONSTACK(completion);
169 unsigned long flags;
170 pm8001_ha = sas_phy->ha->lldd_ha;
171 pm8001_ha->phy[phy_id].enable_completion = &completion;
172 switch (func) {
173 case PHY_FUNC_SET_LINK_RATE:
174 rates = funcdata;
175 if (rates->minimum_linkrate) {
176 pm8001_ha->phy[phy_id].minimum_linkrate =
177 rates->minimum_linkrate;
178 }
179 if (rates->maximum_linkrate) {
180 pm8001_ha->phy[phy_id].maximum_linkrate =
181 rates->maximum_linkrate;
182 }
183 if (pm8001_ha->phy[phy_id].phy_state == 0) {
184 PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
185 wait_for_completion(&completion);
186 }
187 PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
188 PHY_LINK_RESET);
189 break;
190 case PHY_FUNC_HARD_RESET:
191 if (pm8001_ha->phy[phy_id].phy_state == 0) {
192 PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
193 wait_for_completion(&completion);
194 }
195 PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
196 PHY_HARD_RESET);
197 break;
198 case PHY_FUNC_LINK_RESET:
199 if (pm8001_ha->phy[phy_id].phy_state == 0) {
200 PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
201 wait_for_completion(&completion);
202 }
203 PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
204 PHY_LINK_RESET);
205 break;
206 case PHY_FUNC_RELEASE_SPINUP_HOLD:
207 PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
208 PHY_LINK_RESET);
209 break;
210 case PHY_FUNC_DISABLE:
211 PM8001_CHIP_DISP->phy_stop_req(pm8001_ha, phy_id);
212 break;
213 case PHY_FUNC_GET_EVENTS:
214 spin_lock_irqsave(&pm8001_ha->lock, flags);
215 if (pm8001_ha->chip_id == chip_8001) {
216 if (-1 == pm8001_bar4_shift(pm8001_ha,
217 (phy_id < 4) ? 0x30000 : 0x40000)) {
218 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
219 return -EINVAL;
220 }
221 }
222 {
223 struct sas_phy *phy = sas_phy->phy;
224 uint32_t *qp = (uint32_t *)(((char *)
225 pm8001_ha->io_mem[2].memvirtaddr)
226 + 0x1034 + (0x4000 * (phy_id & 3)));
227
228 phy->invalid_dword_count = qp[0];
229 phy->running_disparity_error_count = qp[1];
230 phy->loss_of_dword_sync_count = qp[3];
231 phy->phy_reset_problem_count = qp[4];
232 }
233 if (pm8001_ha->chip_id == chip_8001)
234 pm8001_bar4_shift(pm8001_ha, 0);
235 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
236 return 0;
237 default:
238 rc = -EOPNOTSUPP;
239 }
240 msleep(300);
241 return rc;
242}
243
244
245
246
247
248
249void pm8001_scan_start(struct Scsi_Host *shost)
250{
251 int i;
252 struct pm8001_hba_info *pm8001_ha;
253 struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
254 pm8001_ha = sha->lldd_ha;
255
256 if (pm8001_ha->chip_id == chip_8001)
257 PM8001_CHIP_DISP->sas_re_init_req(pm8001_ha);
258 for (i = 0; i < pm8001_ha->chip->n_phy; ++i)
259 PM8001_CHIP_DISP->phy_start_req(pm8001_ha, i);
260}
261
262int pm8001_scan_finished(struct Scsi_Host *shost, unsigned long time)
263{
264 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
265
266
267
268 if (time < HZ)
269 return 0;
270
271 sas_drain_work(ha);
272 return 1;
273}
274
275
276
277
278
279
280static int pm8001_task_prep_smp(struct pm8001_hba_info *pm8001_ha,
281 struct pm8001_ccb_info *ccb)
282{
283 return PM8001_CHIP_DISP->smp_req(pm8001_ha, ccb);
284}
285
286u32 pm8001_get_ncq_tag(struct sas_task *task, u32 *tag)
287{
288 struct ata_queued_cmd *qc = task->uldd_task;
289 if (qc) {
290 if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
291 qc->tf.command == ATA_CMD_FPDMA_READ) {
292 *tag = qc->tag;
293 return 1;
294 }
295 }
296 return 0;
297}
298
299
300
301
302
303
304static int pm8001_task_prep_ata(struct pm8001_hba_info *pm8001_ha,
305 struct pm8001_ccb_info *ccb)
306{
307 return PM8001_CHIP_DISP->sata_req(pm8001_ha, ccb);
308}
309
310
311
312
313
314
315
316static int pm8001_task_prep_ssp_tm(struct pm8001_hba_info *pm8001_ha,
317 struct pm8001_ccb_info *ccb, struct pm8001_tmf_task *tmf)
318{
319 return PM8001_CHIP_DISP->ssp_tm_req(pm8001_ha, ccb, tmf);
320}
321
322
323
324
325
326
327static int pm8001_task_prep_ssp(struct pm8001_hba_info *pm8001_ha,
328 struct pm8001_ccb_info *ccb)
329{
330 return PM8001_CHIP_DISP->ssp_io_req(pm8001_ha, ccb);
331}
332
333
334static int sas_find_local_port_id(struct domain_device *dev)
335{
336 struct domain_device *pdev = dev->parent;
337
338
339 if (!pdev)
340 return dev->port->id;
341 while (pdev) {
342 struct domain_device *pdev_p = pdev->parent;
343 if (!pdev_p)
344 return pdev->port->id;
345 pdev = pdev->parent;
346 }
347 return 0;
348}
349
350
351
352
353
354
355
356
357
358
359#define DEV_IS_GONE(pm8001_dev) \
360 ((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
361static int pm8001_task_exec(struct sas_task *task, const int num,
362 gfp_t gfp_flags, int is_tmf, struct pm8001_tmf_task *tmf)
363{
364 struct domain_device *dev = task->dev;
365 struct pm8001_hba_info *pm8001_ha;
366 struct pm8001_device *pm8001_dev;
367 struct pm8001_port *port = NULL;
368 struct sas_task *t = task;
369 struct pm8001_ccb_info *ccb;
370 u32 tag = 0xdeadbeef, rc, n_elem = 0;
371 u32 n = num;
372 unsigned long flags = 0;
373
374 if (!dev->port) {
375 struct task_status_struct *tsm = &t->task_status;
376 tsm->resp = SAS_TASK_UNDELIVERED;
377 tsm->stat = SAS_PHY_DOWN;
378 if (dev->dev_type != SAS_SATA_DEV)
379 t->task_done(t);
380 return 0;
381 }
382 pm8001_ha = pm8001_find_ha_by_dev(task->dev);
383 PM8001_IO_DBG(pm8001_ha, pm8001_printk("pm8001_task_exec device \n "));
384 spin_lock_irqsave(&pm8001_ha->lock, flags);
385 do {
386 dev = t->dev;
387 pm8001_dev = dev->lldd_dev;
388 port = &pm8001_ha->port[sas_find_local_port_id(dev)];
389 if (DEV_IS_GONE(pm8001_dev) || !port->port_attached) {
390 if (sas_protocol_ata(t->task_proto)) {
391 struct task_status_struct *ts = &t->task_status;
392 ts->resp = SAS_TASK_UNDELIVERED;
393 ts->stat = SAS_PHY_DOWN;
394
395 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
396 t->task_done(t);
397 spin_lock_irqsave(&pm8001_ha->lock, flags);
398 if (n > 1)
399 t = list_entry(t->list.next,
400 struct sas_task, list);
401 continue;
402 } else {
403 struct task_status_struct *ts = &t->task_status;
404 ts->resp = SAS_TASK_UNDELIVERED;
405 ts->stat = SAS_PHY_DOWN;
406 t->task_done(t);
407 if (n > 1)
408 t = list_entry(t->list.next,
409 struct sas_task, list);
410 continue;
411 }
412 }
413 rc = pm8001_tag_alloc(pm8001_ha, &tag);
414 if (rc)
415 goto err_out;
416 ccb = &pm8001_ha->ccb_info[tag];
417
418 if (!sas_protocol_ata(t->task_proto)) {
419 if (t->num_scatter) {
420 n_elem = dma_map_sg(pm8001_ha->dev,
421 t->scatter,
422 t->num_scatter,
423 t->data_dir);
424 if (!n_elem) {
425 rc = -ENOMEM;
426 goto err_out_tag;
427 }
428 }
429 } else {
430 n_elem = t->num_scatter;
431 }
432
433 t->lldd_task = ccb;
434 ccb->n_elem = n_elem;
435 ccb->ccb_tag = tag;
436 ccb->task = t;
437 switch (t->task_proto) {
438 case SAS_PROTOCOL_SMP:
439 rc = pm8001_task_prep_smp(pm8001_ha, ccb);
440 break;
441 case SAS_PROTOCOL_SSP:
442 if (is_tmf)
443 rc = pm8001_task_prep_ssp_tm(pm8001_ha,
444 ccb, tmf);
445 else
446 rc = pm8001_task_prep_ssp(pm8001_ha, ccb);
447 break;
448 case SAS_PROTOCOL_SATA:
449 case SAS_PROTOCOL_STP:
450 case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
451 rc = pm8001_task_prep_ata(pm8001_ha, ccb);
452 break;
453 default:
454 dev_printk(KERN_ERR, pm8001_ha->dev,
455 "unknown sas_task proto: 0x%x\n",
456 t->task_proto);
457 rc = -EINVAL;
458 break;
459 }
460
461 if (rc) {
462 PM8001_IO_DBG(pm8001_ha,
463 pm8001_printk("rc is %x\n", rc));
464 goto err_out_tag;
465 }
466
467 spin_lock(&t->task_state_lock);
468 t->task_state_flags |= SAS_TASK_AT_INITIATOR;
469 spin_unlock(&t->task_state_lock);
470 pm8001_dev->running_req++;
471 if (n > 1)
472 t = list_entry(t->list.next, struct sas_task, list);
473 } while (--n);
474 rc = 0;
475 goto out_done;
476
477err_out_tag:
478 pm8001_tag_free(pm8001_ha, tag);
479err_out:
480 dev_printk(KERN_ERR, pm8001_ha->dev, "pm8001 exec failed[%d]!\n", rc);
481 if (!sas_protocol_ata(t->task_proto))
482 if (n_elem)
483 dma_unmap_sg(pm8001_ha->dev, t->scatter, n_elem,
484 t->data_dir);
485out_done:
486 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
487 return rc;
488}
489
490
491
492
493
494
495
496
497
498int pm8001_queue_command(struct sas_task *task, const int num,
499 gfp_t gfp_flags)
500{
501 return pm8001_task_exec(task, num, gfp_flags, 0, NULL);
502}
503
504void pm8001_ccb_free(struct pm8001_hba_info *pm8001_ha, u32 ccb_idx)
505{
506 pm8001_tag_clear(pm8001_ha, ccb_idx);
507}
508
509
510
511
512
513
514
515
516void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha,
517 struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx)
518{
519 if (!ccb->task)
520 return;
521 if (!sas_protocol_ata(task->task_proto))
522 if (ccb->n_elem)
523 dma_unmap_sg(pm8001_ha->dev, task->scatter,
524 task->num_scatter, task->data_dir);
525
526 switch (task->task_proto) {
527 case SAS_PROTOCOL_SMP:
528 dma_unmap_sg(pm8001_ha->dev, &task->smp_task.smp_resp, 1,
529 PCI_DMA_FROMDEVICE);
530 dma_unmap_sg(pm8001_ha->dev, &task->smp_task.smp_req, 1,
531 PCI_DMA_TODEVICE);
532 break;
533
534 case SAS_PROTOCOL_SATA:
535 case SAS_PROTOCOL_STP:
536 case SAS_PROTOCOL_SSP:
537 default:
538
539 break;
540 }
541 task->lldd_task = NULL;
542 ccb->task = NULL;
543 ccb->ccb_tag = 0xFFFFFFFF;
544 ccb->open_retry = 0;
545 pm8001_ccb_free(pm8001_ha, ccb_idx);
546}
547
548
549
550
551
552struct pm8001_device *pm8001_alloc_dev(struct pm8001_hba_info *pm8001_ha)
553{
554 u32 dev;
555 for (dev = 0; dev < PM8001_MAX_DEVICES; dev++) {
556 if (pm8001_ha->devices[dev].dev_type == SAS_PHY_UNUSED) {
557 pm8001_ha->devices[dev].id = dev;
558 return &pm8001_ha->devices[dev];
559 }
560 }
561 if (dev == PM8001_MAX_DEVICES) {
562 PM8001_FAIL_DBG(pm8001_ha,
563 pm8001_printk("max support %d devices, ignore ..\n",
564 PM8001_MAX_DEVICES));
565 }
566 return NULL;
567}
568
569
570
571
572struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha,
573 u32 device_id)
574{
575 u32 dev;
576 for (dev = 0; dev < PM8001_MAX_DEVICES; dev++) {
577 if (pm8001_ha->devices[dev].device_id == device_id)
578 return &pm8001_ha->devices[dev];
579 }
580 if (dev == PM8001_MAX_DEVICES) {
581 PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("NO MATCHING "
582 "DEVICE FOUND !!!\n"));
583 }
584 return NULL;
585}
586
587static void pm8001_free_dev(struct pm8001_device *pm8001_dev)
588{
589 u32 id = pm8001_dev->id;
590 memset(pm8001_dev, 0, sizeof(*pm8001_dev));
591 pm8001_dev->id = id;
592 pm8001_dev->dev_type = SAS_PHY_UNUSED;
593 pm8001_dev->device_id = PM8001_MAX_DEVICES;
594 pm8001_dev->sas_device = NULL;
595}
596
597
598
599
600
601
602
603
604
605
606
607
608
609static int pm8001_dev_found_notify(struct domain_device *dev)
610{
611 unsigned long flags = 0;
612 int res = 0;
613 struct pm8001_hba_info *pm8001_ha = NULL;
614 struct domain_device *parent_dev = dev->parent;
615 struct pm8001_device *pm8001_device;
616 DECLARE_COMPLETION_ONSTACK(completion);
617 u32 flag = 0;
618 pm8001_ha = pm8001_find_ha_by_dev(dev);
619 spin_lock_irqsave(&pm8001_ha->lock, flags);
620
621 pm8001_device = pm8001_alloc_dev(pm8001_ha);
622 if (!pm8001_device) {
623 res = -1;
624 goto found_out;
625 }
626 pm8001_device->sas_device = dev;
627 dev->lldd_dev = pm8001_device;
628 pm8001_device->dev_type = dev->dev_type;
629 pm8001_device->dcompletion = &completion;
630 if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
631 int phy_id;
632 struct ex_phy *phy;
633 for (phy_id = 0; phy_id < parent_dev->ex_dev.num_phys;
634 phy_id++) {
635 phy = &parent_dev->ex_dev.ex_phy[phy_id];
636 if (SAS_ADDR(phy->attached_sas_addr)
637 == SAS_ADDR(dev->sas_addr)) {
638 pm8001_device->attached_phy = phy_id;
639 break;
640 }
641 }
642 if (phy_id == parent_dev->ex_dev.num_phys) {
643 PM8001_FAIL_DBG(pm8001_ha,
644 pm8001_printk("Error: no attached dev:%016llx"
645 " at ex:%016llx.\n", SAS_ADDR(dev->sas_addr),
646 SAS_ADDR(parent_dev->sas_addr)));
647 res = -1;
648 }
649 } else {
650 if (dev->dev_type == SAS_SATA_DEV) {
651 pm8001_device->attached_phy =
652 dev->rphy->identify.phy_identifier;
653 flag = 1;
654 }
655 }
656 PM8001_DISC_DBG(pm8001_ha, pm8001_printk("Found device\n"));
657 PM8001_CHIP_DISP->reg_dev_req(pm8001_ha, pm8001_device, flag);
658 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
659 wait_for_completion(&completion);
660 if (dev->dev_type == SAS_END_DEVICE)
661 msleep(50);
662 pm8001_ha->flags = PM8001F_RUN_TIME;
663 return 0;
664found_out:
665 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
666 return res;
667}
668
669int pm8001_dev_found(struct domain_device *dev)
670{
671 return pm8001_dev_found_notify(dev);
672}
673
674void pm8001_task_done(struct sas_task *task)
675{
676 if (!del_timer(&task->slow_task->timer))
677 return;
678 complete(&task->slow_task->completion);
679}
680
681static void pm8001_tmf_timedout(unsigned long data)
682{
683 struct sas_task *task = (struct sas_task *)data;
684
685 task->task_state_flags |= SAS_TASK_STATE_ABORTED;
686 complete(&task->slow_task->completion);
687}
688
689#define PM8001_TASK_TIMEOUT 20
690
691
692
693
694
695
696
697
698
699
700
701static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
702 void *parameter, u32 para_len, struct pm8001_tmf_task *tmf)
703{
704 int res, retry;
705 struct sas_task *task = NULL;
706 struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
707
708 for (retry = 0; retry < 3; retry++) {
709 task = sas_alloc_slow_task(GFP_KERNEL);
710 if (!task)
711 return -ENOMEM;
712
713 task->dev = dev;
714 task->task_proto = dev->tproto;
715 memcpy(&task->ssp_task, parameter, para_len);
716 task->task_done = pm8001_task_done;
717 task->slow_task->timer.data = (unsigned long)task;
718 task->slow_task->timer.function = pm8001_tmf_timedout;
719 task->slow_task->timer.expires = jiffies + PM8001_TASK_TIMEOUT*HZ;
720 add_timer(&task->slow_task->timer);
721
722 res = pm8001_task_exec(task, 1, GFP_KERNEL, 1, tmf);
723
724 if (res) {
725 del_timer(&task->slow_task->timer);
726 PM8001_FAIL_DBG(pm8001_ha,
727 pm8001_printk("Executing internal task "
728 "failed\n"));
729 goto ex_err;
730 }
731 wait_for_completion(&task->slow_task->completion);
732 res = -TMF_RESP_FUNC_FAILED;
733
734 if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
735 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
736 PM8001_FAIL_DBG(pm8001_ha,
737 pm8001_printk("TMF task[%x]timeout.\n",
738 tmf->tmf));
739 goto ex_err;
740 }
741 }
742
743 if (task->task_status.resp == SAS_TASK_COMPLETE &&
744 task->task_status.stat == SAM_STAT_GOOD) {
745 res = TMF_RESP_FUNC_COMPLETE;
746 break;
747 }
748
749 if (task->task_status.resp == SAS_TASK_COMPLETE &&
750 task->task_status.stat == SAS_DATA_UNDERRUN) {
751
752
753 res = task->task_status.residual;
754 break;
755 }
756
757 if (task->task_status.resp == SAS_TASK_COMPLETE &&
758 task->task_status.stat == SAS_DATA_OVERRUN) {
759 PM8001_FAIL_DBG(pm8001_ha,
760 pm8001_printk("Blocked task error.\n"));
761 res = -EMSGSIZE;
762 break;
763 } else {
764 PM8001_EH_DBG(pm8001_ha,
765 pm8001_printk(" Task to dev %016llx response:"
766 "0x%x status 0x%x\n",
767 SAS_ADDR(dev->sas_addr),
768 task->task_status.resp,
769 task->task_status.stat));
770 sas_free_task(task);
771 task = NULL;
772 }
773 }
774ex_err:
775 BUG_ON(retry == 3 && task != NULL);
776 sas_free_task(task);
777 return res;
778}
779
780static int
781pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
782 struct pm8001_device *pm8001_dev, struct domain_device *dev, u32 flag,
783 u32 task_tag)
784{
785 int res, retry;
786 u32 ccb_tag;
787 struct pm8001_ccb_info *ccb;
788 struct sas_task *task = NULL;
789
790 for (retry = 0; retry < 3; retry++) {
791 task = sas_alloc_slow_task(GFP_KERNEL);
792 if (!task)
793 return -ENOMEM;
794
795 task->dev = dev;
796 task->task_proto = dev->tproto;
797 task->task_done = pm8001_task_done;
798 task->slow_task->timer.data = (unsigned long)task;
799 task->slow_task->timer.function = pm8001_tmf_timedout;
800 task->slow_task->timer.expires = jiffies + PM8001_TASK_TIMEOUT * HZ;
801 add_timer(&task->slow_task->timer);
802
803 res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
804 if (res)
805 return res;
806 ccb = &pm8001_ha->ccb_info[ccb_tag];
807 ccb->device = pm8001_dev;
808 ccb->ccb_tag = ccb_tag;
809 ccb->task = task;
810
811 res = PM8001_CHIP_DISP->task_abort(pm8001_ha,
812 pm8001_dev, flag, task_tag, ccb_tag);
813
814 if (res) {
815 del_timer(&task->slow_task->timer);
816 PM8001_FAIL_DBG(pm8001_ha,
817 pm8001_printk("Executing internal task "
818 "failed\n"));
819 goto ex_err;
820 }
821 wait_for_completion(&task->slow_task->completion);
822 res = TMF_RESP_FUNC_FAILED;
823
824 if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
825 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
826 PM8001_FAIL_DBG(pm8001_ha,
827 pm8001_printk("TMF task timeout.\n"));
828 goto ex_err;
829 }
830 }
831
832 if (task->task_status.resp == SAS_TASK_COMPLETE &&
833 task->task_status.stat == SAM_STAT_GOOD) {
834 res = TMF_RESP_FUNC_COMPLETE;
835 break;
836
837 } else {
838 PM8001_EH_DBG(pm8001_ha,
839 pm8001_printk(" Task to dev %016llx response: "
840 "0x%x status 0x%x\n",
841 SAS_ADDR(dev->sas_addr),
842 task->task_status.resp,
843 task->task_status.stat));
844 sas_free_task(task);
845 task = NULL;
846 }
847 }
848ex_err:
849 BUG_ON(retry == 3 && task != NULL);
850 sas_free_task(task);
851 return res;
852}
853
854
855
856
857
858static void pm8001_dev_gone_notify(struct domain_device *dev)
859{
860 unsigned long flags = 0;
861 u32 tag;
862 struct pm8001_hba_info *pm8001_ha;
863 struct pm8001_device *pm8001_dev = dev->lldd_dev;
864
865 pm8001_ha = pm8001_find_ha_by_dev(dev);
866 spin_lock_irqsave(&pm8001_ha->lock, flags);
867 pm8001_tag_alloc(pm8001_ha, &tag);
868 if (pm8001_dev) {
869 u32 device_id = pm8001_dev->device_id;
870
871 PM8001_DISC_DBG(pm8001_ha,
872 pm8001_printk("found dev[%d:%x] is gone.\n",
873 pm8001_dev->device_id, pm8001_dev->dev_type));
874 if (pm8001_dev->running_req) {
875 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
876 pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
877 dev, 1, 0);
878 spin_lock_irqsave(&pm8001_ha->lock, flags);
879 }
880 PM8001_CHIP_DISP->dereg_dev_req(pm8001_ha, device_id);
881 pm8001_free_dev(pm8001_dev);
882 } else {
883 PM8001_DISC_DBG(pm8001_ha,
884 pm8001_printk("Found dev has gone.\n"));
885 }
886 dev->lldd_dev = NULL;
887 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
888}
889
890void pm8001_dev_gone(struct domain_device *dev)
891{
892 pm8001_dev_gone_notify(dev);
893}
894
895static int pm8001_issue_ssp_tmf(struct domain_device *dev,
896 u8 *lun, struct pm8001_tmf_task *tmf)
897{
898 struct sas_ssp_task ssp_task;
899 if (!(dev->tproto & SAS_PROTOCOL_SSP))
900 return TMF_RESP_FUNC_ESUPP;
901
902 strncpy((u8 *)&ssp_task.LUN, lun, 8);
903 return pm8001_exec_internal_tmf_task(dev, &ssp_task, sizeof(ssp_task),
904 tmf);
905}
906
907
908void pm8001_open_reject_retry(
909 struct pm8001_hba_info *pm8001_ha,
910 struct sas_task *task_to_close,
911 struct pm8001_device *device_to_close)
912{
913 int i;
914 unsigned long flags;
915
916 if (pm8001_ha == NULL)
917 return;
918
919 spin_lock_irqsave(&pm8001_ha->lock, flags);
920
921 for (i = 0; i < PM8001_MAX_CCB; i++) {
922 struct sas_task *task;
923 struct task_status_struct *ts;
924 struct pm8001_device *pm8001_dev;
925 unsigned long flags1;
926 u32 tag;
927 struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[i];
928
929 pm8001_dev = ccb->device;
930 if (!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED))
931 continue;
932 if (!device_to_close) {
933 uintptr_t d = (uintptr_t)pm8001_dev
934 - (uintptr_t)&pm8001_ha->devices;
935 if (((d % sizeof(*pm8001_dev)) != 0)
936 || ((d / sizeof(*pm8001_dev)) >= PM8001_MAX_DEVICES))
937 continue;
938 } else if (pm8001_dev != device_to_close)
939 continue;
940 tag = ccb->ccb_tag;
941 if (!tag || (tag == 0xFFFFFFFF))
942 continue;
943 task = ccb->task;
944 if (!task || !task->task_done)
945 continue;
946 if (task_to_close && (task != task_to_close))
947 continue;
948 ts = &task->task_status;
949 ts->resp = SAS_TASK_COMPLETE;
950
951 ts->stat = SAS_OPEN_REJECT;
952 ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
953 if (pm8001_dev)
954 pm8001_dev->running_req--;
955 spin_lock_irqsave(&task->task_state_lock, flags1);
956 task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
957 task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
958 task->task_state_flags |= SAS_TASK_STATE_DONE;
959 if (unlikely((task->task_state_flags
960 & SAS_TASK_STATE_ABORTED))) {
961 spin_unlock_irqrestore(&task->task_state_lock,
962 flags1);
963 pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
964 } else {
965 spin_unlock_irqrestore(&task->task_state_lock,
966 flags1);
967 pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
968 mb();
969 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
970 task->task_done(task);
971 spin_lock_irqsave(&pm8001_ha->lock, flags);
972 }
973 }
974
975 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
976}
977
978
979
980
981
982int pm8001_I_T_nexus_reset(struct domain_device *dev)
983{
984 int rc = TMF_RESP_FUNC_FAILED;
985 struct pm8001_device *pm8001_dev;
986 struct pm8001_hba_info *pm8001_ha;
987 struct sas_phy *phy;
988
989 if (!dev || !dev->lldd_dev)
990 return -ENODEV;
991
992 pm8001_dev = dev->lldd_dev;
993 pm8001_ha = pm8001_find_ha_by_dev(dev);
994 phy = sas_get_local_phy(dev);
995
996 if (dev_is_sata(dev)) {
997 DECLARE_COMPLETION_ONSTACK(completion_setstate);
998 if (scsi_is_sas_phy_local(phy)) {
999 rc = 0;
1000 goto out;
1001 }
1002 rc = sas_phy_reset(phy, 1);
1003 msleep(2000);
1004 rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
1005 dev, 1, 0);
1006 pm8001_dev->setds_completion = &completion_setstate;
1007 rc = PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
1008 pm8001_dev, 0x01);
1009 wait_for_completion(&completion_setstate);
1010 } else {
1011 rc = sas_phy_reset(phy, 1);
1012 msleep(2000);
1013 }
1014 PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
1015 pm8001_dev->device_id, rc));
1016 out:
1017 sas_put_local_phy(phy);
1018 return rc;
1019}
1020
1021
1022
1023
1024
1025int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
1026{
1027 int rc = TMF_RESP_FUNC_FAILED;
1028 struct pm8001_device *pm8001_dev;
1029 struct pm8001_hba_info *pm8001_ha;
1030 struct sas_phy *phy;
1031 u32 device_id = 0;
1032
1033 if (!dev || !dev->lldd_dev)
1034 return -1;
1035
1036 pm8001_dev = dev->lldd_dev;
1037 device_id = pm8001_dev->device_id;
1038 pm8001_ha = pm8001_find_ha_by_dev(dev);
1039
1040 PM8001_EH_DBG(pm8001_ha,
1041 pm8001_printk("I_T_Nexus handler invoked !!"));
1042
1043 phy = sas_get_local_phy(dev);
1044
1045 if (dev_is_sata(dev)) {
1046 DECLARE_COMPLETION_ONSTACK(completion_setstate);
1047 if (scsi_is_sas_phy_local(phy)) {
1048 rc = 0;
1049 goto out;
1050 }
1051
1052 rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
1053 dev, 1, 0);
1054 msleep(100);
1055
1056
1057 pm8001_dev_gone_notify(dev);
1058 msleep(200);
1059
1060
1061 rc = sas_phy_reset(phy, 1);
1062 msleep(2000);
1063 pm8001_dev->setds_completion = &completion_setstate;
1064
1065 wait_for_completion(&completion_setstate);
1066 } else {
1067
1068 rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
1069 dev, 1, 0);
1070 msleep(100);
1071
1072
1073 pm8001_dev_gone_notify(dev);
1074 msleep(200);
1075
1076
1077 rc = sas_phy_reset(phy, 1);
1078 msleep(2000);
1079 }
1080 PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
1081 pm8001_dev->device_id, rc));
1082out:
1083 sas_put_local_phy(phy);
1084
1085 return rc;
1086}
1087
1088int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
1089{
1090 int rc = TMF_RESP_FUNC_FAILED;
1091 struct pm8001_tmf_task tmf_task;
1092 struct pm8001_device *pm8001_dev = dev->lldd_dev;
1093 struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
1094 if (dev_is_sata(dev)) {
1095 struct sas_phy *phy = sas_get_local_phy(dev);
1096 rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
1097 dev, 1, 0);
1098 rc = sas_phy_reset(phy, 1);
1099 sas_put_local_phy(phy);
1100 rc = PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
1101 pm8001_dev, 0x01);
1102 msleep(2000);
1103 } else {
1104 tmf_task.tmf = TMF_LU_RESET;
1105 rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1106 }
1107
1108 PM8001_EH_DBG(pm8001_ha, pm8001_printk("for device[%x]:rc=%d\n",
1109 pm8001_dev->device_id, rc));
1110 return rc;
1111}
1112
1113
1114int pm8001_query_task(struct sas_task *task)
1115{
1116 u32 tag = 0xdeadbeef;
1117 int i = 0;
1118 struct scsi_lun lun;
1119 struct pm8001_tmf_task tmf_task;
1120 int rc = TMF_RESP_FUNC_FAILED;
1121 if (unlikely(!task || !task->lldd_task || !task->dev))
1122 return rc;
1123
1124 if (task->task_proto & SAS_PROTOCOL_SSP) {
1125 struct scsi_cmnd *cmnd = task->uldd_task;
1126 struct domain_device *dev = task->dev;
1127 struct pm8001_hba_info *pm8001_ha =
1128 pm8001_find_ha_by_dev(dev);
1129
1130 int_to_scsilun(cmnd->device->lun, &lun);
1131 rc = pm8001_find_tag(task, &tag);
1132 if (rc == 0) {
1133 rc = TMF_RESP_FUNC_FAILED;
1134 return rc;
1135 }
1136 PM8001_EH_DBG(pm8001_ha, pm8001_printk("Query:["));
1137 for (i = 0; i < 16; i++)
1138 printk(KERN_INFO "%02x ", cmnd->cmnd[i]);
1139 printk(KERN_INFO "]\n");
1140 tmf_task.tmf = TMF_QUERY_TASK;
1141 tmf_task.tag_of_task_to_be_managed = tag;
1142
1143 rc = pm8001_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
1144 switch (rc) {
1145
1146 case TMF_RESP_FUNC_SUCC:
1147 PM8001_EH_DBG(pm8001_ha,
1148 pm8001_printk("The task is still in Lun\n"));
1149 break;
1150
1151 case TMF_RESP_FUNC_FAILED:
1152 case TMF_RESP_FUNC_COMPLETE:
1153 PM8001_EH_DBG(pm8001_ha,
1154 pm8001_printk("The task is not in Lun or failed,"
1155 " reset the phy\n"));
1156 break;
1157 }
1158 }
1159 pm8001_printk(":rc= %d\n", rc);
1160 return rc;
1161}
1162
1163
1164int pm8001_abort_task(struct sas_task *task)
1165{
1166 unsigned long flags;
1167 u32 tag = 0xdeadbeef;
1168 u32 device_id;
1169 struct domain_device *dev ;
1170 struct pm8001_hba_info *pm8001_ha = NULL;
1171 struct pm8001_ccb_info *ccb;
1172 struct scsi_lun lun;
1173 struct pm8001_device *pm8001_dev;
1174 struct pm8001_tmf_task tmf_task;
1175 int rc = TMF_RESP_FUNC_FAILED;
1176 if (unlikely(!task || !task->lldd_task || !task->dev))
1177 return rc;
1178 spin_lock_irqsave(&task->task_state_lock, flags);
1179 if (task->task_state_flags & SAS_TASK_STATE_DONE) {
1180 spin_unlock_irqrestore(&task->task_state_lock, flags);
1181 rc = TMF_RESP_FUNC_COMPLETE;
1182 goto out;
1183 }
1184 spin_unlock_irqrestore(&task->task_state_lock, flags);
1185 if (task->task_proto & SAS_PROTOCOL_SSP) {
1186 struct scsi_cmnd *cmnd = task->uldd_task;
1187 dev = task->dev;
1188 ccb = task->lldd_task;
1189 pm8001_dev = dev->lldd_dev;
1190 pm8001_ha = pm8001_find_ha_by_dev(dev);
1191 int_to_scsilun(cmnd->device->lun, &lun);
1192 rc = pm8001_find_tag(task, &tag);
1193 if (rc == 0) {
1194 printk(KERN_INFO "No such tag in %s\n", __func__);
1195 rc = TMF_RESP_FUNC_FAILED;
1196 return rc;
1197 }
1198 device_id = pm8001_dev->device_id;
1199 PM8001_EH_DBG(pm8001_ha,
1200 pm8001_printk("abort io to deviceid= %d\n", device_id));
1201 tmf_task.tmf = TMF_ABORT_TASK;
1202 tmf_task.tag_of_task_to_be_managed = tag;
1203 rc = pm8001_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
1204 pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
1205 pm8001_dev->sas_device, 0, tag);
1206 } else if (task->task_proto & SAS_PROTOCOL_SATA ||
1207 task->task_proto & SAS_PROTOCOL_STP) {
1208 dev = task->dev;
1209 pm8001_dev = dev->lldd_dev;
1210 pm8001_ha = pm8001_find_ha_by_dev(dev);
1211 rc = pm8001_find_tag(task, &tag);
1212 if (rc == 0) {
1213 printk(KERN_INFO "No such tag in %s\n", __func__);
1214 rc = TMF_RESP_FUNC_FAILED;
1215 return rc;
1216 }
1217 rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
1218 pm8001_dev->sas_device, 0, tag);
1219 } else if (task->task_proto & SAS_PROTOCOL_SMP) {
1220
1221 dev = task->dev;
1222 pm8001_dev = dev->lldd_dev;
1223 pm8001_ha = pm8001_find_ha_by_dev(dev);
1224 rc = pm8001_find_tag(task, &tag);
1225 if (rc == 0) {
1226 printk(KERN_INFO "No such tag in %s\n", __func__);
1227 rc = TMF_RESP_FUNC_FAILED;
1228 return rc;
1229 }
1230 rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
1231 pm8001_dev->sas_device, 0, tag);
1232
1233 }
1234out:
1235 if (rc != TMF_RESP_FUNC_COMPLETE)
1236 pm8001_printk("rc= %d\n", rc);
1237 return rc;
1238}
1239
1240int pm8001_abort_task_set(struct domain_device *dev, u8 *lun)
1241{
1242 int rc = TMF_RESP_FUNC_FAILED;
1243 struct pm8001_tmf_task tmf_task;
1244
1245 tmf_task.tmf = TMF_ABORT_TASK_SET;
1246 rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1247 return rc;
1248}
1249
1250int pm8001_clear_aca(struct domain_device *dev, u8 *lun)
1251{
1252 int rc = TMF_RESP_FUNC_FAILED;
1253 struct pm8001_tmf_task tmf_task;
1254
1255 tmf_task.tmf = TMF_CLEAR_ACA;
1256 rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1257
1258 return rc;
1259}
1260
1261int pm8001_clear_task_set(struct domain_device *dev, u8 *lun)
1262{
1263 int rc = TMF_RESP_FUNC_FAILED;
1264 struct pm8001_tmf_task tmf_task;
1265 struct pm8001_device *pm8001_dev = dev->lldd_dev;
1266 struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
1267
1268 PM8001_EH_DBG(pm8001_ha,
1269 pm8001_printk("I_T_L_Q clear task set[%x]\n",
1270 pm8001_dev->device_id));
1271 tmf_task.tmf = TMF_CLEAR_TASK_SET;
1272 rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1273 return rc;
1274}
1275
1276