forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/scsi/pm8001/pm8001_sas.c
....@@ -116,10 +116,10 @@
116116 	u64 align_offset = 0;
117117 	if (align)
118118 		align_offset = (dma_addr_t)align - 1;
119
-	mem_virt_alloc = pci_zalloc_consistent(pdev, mem_size + align,
120
-					       &mem_dma_handle);
119
+	mem_virt_alloc = dma_alloc_coherent(&pdev->dev, mem_size + align,
120
+					    &mem_dma_handle, GFP_KERNEL);
121121 	if (!mem_virt_alloc) {
122
-		pm8001_printk("memory allocation error\n");
122
+		pr_err("pm80xx: memory allocation error\n");
123123 		return -1;
124124 	}
125125 	*pphys_addr = mem_dma_handle;
....@@ -129,6 +129,7 @@
129129 	*pphys_addr_lo = lower_32_bits(phys_align);
130130 	return 0;
131131 }
132
+
132133 /**
133134   * pm8001_find_ha_by_dev - from domain device which come from sas layer to
134135   * find out our hba struct.
....@@ -157,9 +158,11 @@
157158 	int rc = 0, phy_id = sas_phy->id;
158159 	struct pm8001_hba_info *pm8001_ha = NULL;
159160 	struct sas_phy_linkrates *rates;
161
+	struct pm8001_phy *phy;
160162 	DECLARE_COMPLETION_ONSTACK(completion);
161163 	unsigned long flags;
162164 	pm8001_ha = sas_phy->ha->lldd_ha;
165
+	phy = &pm8001_ha->phy[phy_id];
163166 	pm8001_ha->phy[phy_id].enable_completion = &completion;
164167 	switch (func) {
165168 	case PHY_FUNC_SET_LINK_RATE:
....@@ -172,7 +175,7 @@
172175 			pm8001_ha->phy[phy_id].maximum_linkrate =
173176 				rates->maximum_linkrate;
174177 		}
175
-		if (pm8001_ha->phy[phy_id].phy_state == 0) {
178
+		if (pm8001_ha->phy[phy_id].phy_state ==  PHY_LINK_DISABLE) {
176179 			PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
177180 			wait_for_completion(&completion);
178181 		}
....@@ -180,7 +183,7 @@
180183 					      PHY_LINK_RESET);
181184 		break;
182185 	case PHY_FUNC_HARD_RESET:
183
-		if (pm8001_ha->phy[phy_id].phy_state == 0) {
186
+		if (pm8001_ha->phy[phy_id].phy_state == PHY_LINK_DISABLE) {
184187 			PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
185188 			wait_for_completion(&completion);
186189 		}
....@@ -188,7 +191,7 @@
188191 					      PHY_HARD_RESET);
189192 		break;
190193 	case PHY_FUNC_LINK_RESET:
191
-		if (pm8001_ha->phy[phy_id].phy_state == 0) {
194
+		if (pm8001_ha->phy[phy_id].phy_state == PHY_LINK_DISABLE) {
192195 			PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
193196 			wait_for_completion(&completion);
194197 		}
....@@ -200,6 +203,23 @@
200203 					      PHY_LINK_RESET);
201204 		break;
202205 	case PHY_FUNC_DISABLE:
206
+		if (pm8001_ha->chip_id != chip_8001) {
207
+			if (pm8001_ha->phy[phy_id].phy_state ==
208
+				PHY_STATE_LINK_UP_SPCV) {
209
+				sas_phy_disconnected(&phy->sas_phy);
210
+				sas_notify_phy_event(&phy->sas_phy,
211
+					PHYE_LOSS_OF_SIGNAL);
212
+				phy->phy_attached = 0;
213
+			}
214
+		} else {
215
+			if (pm8001_ha->phy[phy_id].phy_state ==
216
+				PHY_STATE_LINK_UP_SPC) {
217
+				sas_phy_disconnected(&phy->sas_phy);
218
+				sas_notify_phy_event(&phy->sas_phy,
219
+					PHYE_LOSS_OF_SIGNAL);
220
+				phy->phy_attached = 0;
221
+			}
222
+		}
203223 		PM8001_CHIP_DISP->phy_stop_req(pm8001_ha, phy_id);
204224 		break;
205225 	case PHY_FUNC_GET_EVENTS:
....@@ -227,6 +247,7 @@
227247 		spin_unlock_irqrestore(&pm8001_ha->lock, flags);
228248 		return 0;
229249 	default:
250
+		pm8001_dbg(pm8001_ha, DEVIO, "func 0x%x\n", func);
230251 		rc = -EOPNOTSUPP;
231252 	}
232253 	msleep(300);
....@@ -243,12 +264,17 @@
243264 	int i;
244265 	struct pm8001_hba_info *pm8001_ha;
245266 	struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
267
+	DECLARE_COMPLETION_ONSTACK(completion);
246268 	pm8001_ha = sha->lldd_ha;
247269 	/* SAS_RE_INITIALIZATION not available in SPCv/ve */
248270 	if (pm8001_ha->chip_id == chip_8001)
249271 		PM8001_CHIP_DISP->sas_re_init_req(pm8001_ha);
250
-	for (i = 0; i < pm8001_ha->chip->n_phy; ++i)
272
+	for (i = 0; i < pm8001_ha->chip->n_phy; ++i) {
273
+		pm8001_ha->phy[i].enable_completion = &completion;
251274 		PM8001_CHIP_DISP->phy_start_req(pm8001_ha, i);
275
+		wait_for_completion(&completion);
276
+		msleep(300);
277
+	}
252278 }
253279 
254280 int pm8001_scan_finished(struct Scsi_Host *shost, unsigned long time)
....@@ -342,17 +368,15 @@
342368 	return 0;
343369 }
344370 
371
+#define DEV_IS_GONE(pm8001_dev)	\
372
+	((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
345373 /**
346374   * pm8001_task_exec - queue the task(ssp, smp && ata) to the hardware.
347375   * @task: the task to be execute.
348
-  * @num: if can_queue great than 1, the task can be queued up. for SMP task,
349
-  * we always execute one one time.
350376   * @gfp_flags: gfp_flags.
351377   * @is_tmf: if it is task management task.
352378   * @tmf: the task management IU
353379   */
354
-#define DEV_IS_GONE(pm8001_dev)	\
355
-	((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
356380 static int pm8001_task_exec(struct sas_task *task,
357381 	gfp_t gfp_flags, int is_tmf, struct pm8001_tmf_task *tmf)
358382 {
....@@ -362,8 +386,9 @@
362386 	struct pm8001_port *port = NULL;
363387 	struct sas_task *t = task;
364388 	struct pm8001_ccb_info *ccb;
365
-	u32 tag = 0xdeadbeef, rc, n_elem = 0;
389
+	u32 tag = 0xdeadbeef, rc = 0, n_elem = 0;
366390 	unsigned long flags = 0;
391
+	enum sas_protocol task_proto = t->task_proto;
367392 
368393 	if (!dev->port) {
369394 		struct task_status_struct *tsm = &t->task_status;
....@@ -381,14 +406,14 @@
381406 		t->task_done(t);
382407 		return 0;
383408 	}
384
-	PM8001_IO_DBG(pm8001_ha, pm8001_printk("pm8001_task_exec device \n "));
409
+	pm8001_dbg(pm8001_ha, IO, "pm8001_task_exec device\n");
385410 	spin_lock_irqsave(&pm8001_ha->lock, flags);
386411 	do {
387412 		dev = t->dev;
388413 		pm8001_dev = dev->lldd_dev;
389414 		port = &pm8001_ha->port[sas_find_local_port_id(dev)];
390415 		if (DEV_IS_GONE(pm8001_dev) || !port->port_attached) {
391
-			if (sas_protocol_ata(t->task_proto)) {
416
+			if (sas_protocol_ata(task_proto)) {
392417 				struct task_status_struct *ts = &t->task_status;
393418 				ts->resp = SAS_TASK_UNDELIVERED;
394419 				ts->stat = SAS_PHY_DOWN;
....@@ -410,7 +435,7 @@
410435 			goto err_out;
411436 		ccb = &pm8001_ha->ccb_info[tag];
412437 
413
-		if (!sas_protocol_ata(t->task_proto)) {
438
+		if (!sas_protocol_ata(task_proto)) {
414439 			if (t->num_scatter) {
415440 				n_elem = dma_map_sg(pm8001_ha->dev,
416441 					t->scatter,
....@@ -430,11 +455,13 @@
430455 		ccb->ccb_tag = tag;
431456 		ccb->task = t;
432457 		ccb->device = pm8001_dev;
433
-		switch (t->task_proto) {
458
+		switch (task_proto) {
434459 		case SAS_PROTOCOL_SMP:
460
+			atomic_inc(&pm8001_dev->running_req);
435461 			rc = pm8001_task_prep_smp(pm8001_ha, ccb);
436462 			break;
437463 		case SAS_PROTOCOL_SSP:
464
+			atomic_inc(&pm8001_dev->running_req);
438465 			if (is_tmf)
439466 				rc = pm8001_task_prep_ssp_tm(pm8001_ha,
440467 					ccb, tmf);
....@@ -443,26 +470,25 @@
443470 			break;
444471 		case SAS_PROTOCOL_SATA:
445472 		case SAS_PROTOCOL_STP:
473
+			atomic_inc(&pm8001_dev->running_req);
446474 			rc = pm8001_task_prep_ata(pm8001_ha, ccb);
447475 			break;
448476 		default:
449477 			dev_printk(KERN_ERR, pm8001_ha->dev,
450
-				"unknown sas_task proto: 0x%x\n",
451
-				t->task_proto);
478
+				"unknown sas_task proto: 0x%x\n", task_proto);
452479 			rc = -EINVAL;
453480 			break;
454481 		}
455482 
456483 		if (rc) {
457
-			PM8001_IO_DBG(pm8001_ha,
458
-				pm8001_printk("rc is %x\n", rc));
484
+			pm8001_dbg(pm8001_ha, IO, "rc is %x\n", rc);
485
+			atomic_dec(&pm8001_dev->running_req);
459486 			goto err_out_tag;
460487 		}
461488 		/* TODO: select normal or high priority */
462489 		spin_lock(&t->task_state_lock);
463490 		t->task_state_flags |= SAS_TASK_AT_INITIATOR;
464491 		spin_unlock(&t->task_state_lock);
465
-		pm8001_dev->running_req++;
466492 	} while (0);
467493 	rc = 0;
468494 	goto out_done;
....@@ -471,7 +497,7 @@
471497 	pm8001_tag_free(pm8001_ha, tag);
472498 err_out:
473499 	dev_printk(KERN_ERR, pm8001_ha->dev, "pm8001 exec failed[%d]!\n", rc);
474
-	if (!sas_protocol_ata(t->task_proto))
500
+	if (!sas_protocol_ata(task_proto))
475501 		if (n_elem)
476502 			dma_unmap_sg(pm8001_ha->dev, t->scatter, t->num_scatter,
477503 				t->data_dir);
....@@ -511,9 +537,9 @@
511537 	switch (task->task_proto) {
512538 	case SAS_PROTOCOL_SMP:
513539 		dma_unmap_sg(pm8001_ha->dev, &task->smp_task.smp_resp, 1,
514
-			PCI_DMA_FROMDEVICE);
540
+			DMA_FROM_DEVICE);
515541 		dma_unmap_sg(pm8001_ha->dev, &task->smp_task.smp_req, 1,
516
-			PCI_DMA_TODEVICE);
542
+			DMA_TO_DEVICE);
517543 		break;
518544 
519545 	case SAS_PROTOCOL_SATA:
....@@ -544,15 +570,16 @@
544570 		}
545571 	}
546572 	if (dev == PM8001_MAX_DEVICES) {
547
-		PM8001_FAIL_DBG(pm8001_ha,
548
-			pm8001_printk("max support %d devices, ignore ..\n",
549
-			PM8001_MAX_DEVICES));
573
+		pm8001_dbg(pm8001_ha, FAIL,
574
+			   "max support %d devices, ignore ..\n",
575
+			   PM8001_MAX_DEVICES);
550576 	}
551577 	return NULL;
552578 }
553579 /**
554580   * pm8001_find_dev - find a matching pm8001_device
555581   * @pm8001_ha: our hba card information
582
+  * @device_id: device ID to match against
556583   */
557584 struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha,
558585 					u32 device_id)
....@@ -563,8 +590,7 @@
563590 			return &pm8001_ha->devices[dev];
564591 	}
565592 	if (dev == PM8001_MAX_DEVICES) {
566
-		PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("NO MATCHING "
567
-				"DEVICE FOUND !!!\n"));
593
+		pm8001_dbg(pm8001_ha, FAIL, "NO MATCHING DEVICE FOUND !!!\n");
568594 	}
569595 	return NULL;
570596 }
....@@ -612,7 +638,7 @@
612638 	dev->lldd_dev = pm8001_device;
613639 	pm8001_device->dev_type = dev->dev_type;
614640 	pm8001_device->dcompletion = &completion;
615
-	if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
641
+	if (parent_dev && dev_is_expander(parent_dev->dev_type)) {
616642 		int phy_id;
617643 		struct ex_phy *phy;
618644 		for (phy_id = 0; phy_id < parent_dev->ex_dev.num_phys;
....@@ -625,20 +651,20 @@
625651 			}
626652 		}
627653 		if (phy_id == parent_dev->ex_dev.num_phys) {
628
-			PM8001_FAIL_DBG(pm8001_ha,
629
-			pm8001_printk("Error: no attached dev:%016llx"
630
-			" at ex:%016llx.\n", SAS_ADDR(dev->sas_addr),
631
-				SAS_ADDR(parent_dev->sas_addr)));
654
+			pm8001_dbg(pm8001_ha, FAIL,
655
+				   "Error: no attached dev:%016llx at ex:%016llx.\n",
656
+				   SAS_ADDR(dev->sas_addr),
657
+				   SAS_ADDR(parent_dev->sas_addr));
632658 			res = -1;
633659 		}
634660 	} else {
635661 		if (dev->dev_type == SAS_SATA_DEV) {
636662 			pm8001_device->attached_phy =
637663 				dev->rphy->identify.phy_identifier;
638
-				flag = 1; /* directly sata*/
664
+			flag = 1; /* directly sata */
639665 		}
640666 	} /*register this device to HBA*/
641
-	PM8001_DISC_DBG(pm8001_ha, pm8001_printk("Found device\n"));
667
+	pm8001_dbg(pm8001_ha, DISC, "Found device\n");
642668 	PM8001_CHIP_DISP->reg_dev_req(pm8001_ha, pm8001_device, flag);
643669 	spin_unlock_irqrestore(&pm8001_ha->lock, flags);
644670 	wait_for_completion(&completion);
....@@ -658,8 +684,7 @@
658684 
659685 void pm8001_task_done(struct sas_task *task)
660686 {
661
-	if (!del_timer(&task->slow_task->timer))
662
-		return;
687
+	del_timer(&task->slow_task->timer);
663688 	complete(&task->slow_task->completion);
664689 }
665690 
....@@ -667,9 +692,14 @@
667692 {
668693 	struct sas_task_slow *slow = from_timer(slow, t, timer);
669694 	struct sas_task *task = slow->task;
695
+	unsigned long flags;
670696 
671
-	task->task_state_flags |= SAS_TASK_STATE_ABORTED;
672
-	complete(&task->slow_task->completion);
697
+	spin_lock_irqsave(&task->task_state_lock, flags);
698
+	if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
699
+		task->task_state_flags |= SAS_TASK_STATE_ABORTED;
700
+		complete(&task->slow_task->completion);
701
+	}
702
+	spin_unlock_irqrestore(&task->task_state_lock, flags);
673703 }
674704 
675705 #define PM8001_TASK_TIMEOUT 20
....@@ -710,31 +740,31 @@
710740 
711741 		if (res) {
712742 			del_timer(&task->slow_task->timer);
713
-			PM8001_FAIL_DBG(pm8001_ha,
714
-				pm8001_printk("Executing internal task "
715
-				"failed\n"));
743
+			pm8001_dbg(pm8001_ha, FAIL, "Executing internal task failed\n");
716744 			goto ex_err;
717745 		}
718746 		wait_for_completion(&task->slow_task->completion);
719747 		if (pm8001_ha->chip_id != chip_8001) {
720748 			pm8001_dev->setds_completion = &completion_setstate;
721
-				PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
722
-					pm8001_dev, 0x01);
749
+			PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
750
+				pm8001_dev, 0x01);
723751 			wait_for_completion(&completion_setstate);
724752 		}
725753 		res = -TMF_RESP_FUNC_FAILED;
726754 		/* Even TMF timed out, return direct. */
727
-		if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
728
-			if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
729
-				PM8001_FAIL_DBG(pm8001_ha,
730
-					pm8001_printk("TMF task[%x]timeout.\n",
731
-					tmf->tmf));
732
-				goto ex_err;
733
-			}
755
+		if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
756
+			struct pm8001_ccb_info *ccb = task->lldd_task;
757
+
758
+			pm8001_dbg(pm8001_ha, FAIL, "TMF task[%x]timeout.\n",
759
+				   tmf->tmf);
760
+
761
+			if (ccb)
762
+				ccb->task = NULL;
763
+			goto ex_err;
734764 		}
735765 
736766 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
737
-			task->task_status.stat == SAM_STAT_GOOD) {
767
+			task->task_status.stat == SAS_SAM_STAT_GOOD) {
738768 			res = TMF_RESP_FUNC_COMPLETE;
739769 			break;
740770 		}
....@@ -749,17 +779,15 @@
749779 
750780 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
751781 			task->task_status.stat == SAS_DATA_OVERRUN) {
752
-			PM8001_FAIL_DBG(pm8001_ha,
753
-				pm8001_printk("Blocked task error.\n"));
782
+			pm8001_dbg(pm8001_ha, FAIL, "Blocked task error.\n");
754783 			res = -EMSGSIZE;
755784 			break;
756785 		} else {
757
-			PM8001_EH_DBG(pm8001_ha,
758
-				pm8001_printk(" Task to dev %016llx response:"
759
-				"0x%x status 0x%x\n",
760
-				SAS_ADDR(dev->sas_addr),
761
-				task->task_status.resp,
762
-				task->task_status.stat));
786
+			pm8001_dbg(pm8001_ha, EH,
787
+				   " Task to dev %016llx response:0x%x status 0x%x\n",
788
+				   SAS_ADDR(dev->sas_addr),
789
+				   task->task_status.resp,
790
+				   task->task_status.stat);
763791 			sas_free_task(task);
764792 			task = NULL;
765793 		}
....@@ -803,37 +831,31 @@
803831 
804832 		res = PM8001_CHIP_DISP->task_abort(pm8001_ha,
805833 			pm8001_dev, flag, task_tag, ccb_tag);
806
-
807834 		if (res) {
808835 			del_timer(&task->slow_task->timer);
809
-			PM8001_FAIL_DBG(pm8001_ha,
810
-				pm8001_printk("Executing internal task "
811
-				"failed\n"));
836
+			pm8001_dbg(pm8001_ha, FAIL, "Executing internal task failed\n");
837
+			pm8001_tag_free(pm8001_ha, ccb_tag);
812838 			goto ex_err;
813839 		}
814840 		wait_for_completion(&task->slow_task->completion);
815841 		res = TMF_RESP_FUNC_FAILED;
816842 		/* Even TMF timed out, return direct. */
817
-		if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
818
-			if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
819
-				PM8001_FAIL_DBG(pm8001_ha,
820
-					pm8001_printk("TMF task timeout.\n"));
821
-				goto ex_err;
822
-			}
843
+		if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
844
+			pm8001_dbg(pm8001_ha, FAIL, "TMF task timeout.\n");
845
+			goto ex_err;
823846 		}
824847 
825848 		if (task->task_status.resp == SAS_TASK_COMPLETE &&
826
-			task->task_status.stat == SAM_STAT_GOOD) {
849
+			task->task_status.stat == SAS_SAM_STAT_GOOD) {
827850 			res = TMF_RESP_FUNC_COMPLETE;
828851 			break;
829852 
830853 		} else {
831
-			PM8001_EH_DBG(pm8001_ha,
832
-				pm8001_printk(" Task to dev %016llx response: "
833
-					"0x%x status 0x%x\n",
834
-				SAS_ADDR(dev->sas_addr),
835
-				task->task_status.resp,
836
-				task->task_status.stat));
854
+			pm8001_dbg(pm8001_ha, EH,
855
+				   " Task to dev %016llx response: 0x%x status 0x%x\n",
856
+				   SAS_ADDR(dev->sas_addr),
857
+				   task->task_status.resp,
858
+				   task->task_status.stat);
837859 			sas_free_task(task);
838860 			task = NULL;
839861 		}
....@@ -859,22 +881,20 @@
859881 	if (pm8001_dev) {
860882 		u32 device_id = pm8001_dev->device_id;
861883 
862
-		PM8001_DISC_DBG(pm8001_ha,
863
-			pm8001_printk("found dev[%d:%x] is gone.\n",
864
-			pm8001_dev->device_id, pm8001_dev->dev_type));
865
-		if (pm8001_dev->running_req) {
884
+		pm8001_dbg(pm8001_ha, DISC, "found dev[%d:%x] is gone.\n",
885
+			   pm8001_dev->device_id, pm8001_dev->dev_type);
886
+		if (atomic_read(&pm8001_dev->running_req)) {
866887 			spin_unlock_irqrestore(&pm8001_ha->lock, flags);
867888 			pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
868889 				dev, 1, 0);
869
-			while (pm8001_dev->running_req)
890
+			while (atomic_read(&pm8001_dev->running_req))
870891 				msleep(20);
871892 			spin_lock_irqsave(&pm8001_ha->lock, flags);
872893 		}
873894 		PM8001_CHIP_DISP->dereg_dev_req(pm8001_ha, device_id);
874895 		pm8001_free_dev(pm8001_dev);
875896 	} else {
876
-		PM8001_DISC_DBG(pm8001_ha,
877
-			pm8001_printk("Found dev has gone.\n"));
897
+		pm8001_dbg(pm8001_ha, DISC, "Found dev has gone.\n");
878898 	}
879899 	dev->lldd_dev = NULL;
880900 	spin_unlock_irqrestore(&pm8001_ha->lock, flags);
....@@ -944,7 +964,7 @@
944964 		ts->stat = SAS_OPEN_REJECT;
945965 		ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
946966 		if (pm8001_dev)
947
-			pm8001_dev->running_req--;
967
+			atomic_dec(&pm8001_dev->running_req);
948968 		spin_lock_irqsave(&task->task_state_lock, flags1);
949969 		task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
950970 		task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
....@@ -971,6 +991,7 @@
971991 /**
972992   * Standard mandates link reset for ATA  (type 0) and hard reset for
973993   * SSP (type 1) , only for RECOVERY
994
+  * @dev: the device structure for the device to reset.
974995   */
975996 int pm8001_I_T_nexus_reset(struct domain_device *dev)
976997 {
....@@ -993,9 +1014,9 @@
9931014 		}
9941015 		rc = sas_phy_reset(phy, 1);
9951016 		if (rc) {
996
-			PM8001_EH_DBG(pm8001_ha,
997
-			pm8001_printk("phy reset failed for device %x\n"
998
-			"with rc %d\n", pm8001_dev->device_id, rc));
1017
+			pm8001_dbg(pm8001_ha, EH,
1018
+				   "phy reset failed for device %x\n"
1019
+				   "with rc %d\n", pm8001_dev->device_id, rc);
9991020 			rc = TMF_RESP_FUNC_FAILED;
10001021 			goto out;
10011022 		}
....@@ -1003,17 +1024,16 @@
10031024 		rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
10041025 			dev, 1, 0);
10051026 		if (rc) {
1006
-			PM8001_EH_DBG(pm8001_ha,
1007
-			pm8001_printk("task abort failed %x\n"
1008
-			"with rc %d\n", pm8001_dev->device_id, rc));
1027
+			pm8001_dbg(pm8001_ha, EH, "task abort failed %x\n"
1028
+				   "with rc %d\n", pm8001_dev->device_id, rc);
10091029 			rc = TMF_RESP_FUNC_FAILED;
10101030 		}
10111031 	} else {
10121032 		rc = sas_phy_reset(phy, 1);
10131033 		msleep(2000);
10141034 	}
1015
-	PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
1016
-		pm8001_dev->device_id, rc));
1035
+	pm8001_dbg(pm8001_ha, EH, " for device[%x]:rc=%d\n",
1036
+		   pm8001_dev->device_id, rc);
10171037  out:
10181038 	sas_put_local_phy(phy);
10191039 	return rc;
....@@ -1029,17 +1049,14 @@
10291049 	struct pm8001_device *pm8001_dev;
10301050 	struct pm8001_hba_info *pm8001_ha;
10311051 	struct sas_phy *phy;
1032
-	u32 device_id = 0;
10331052 
10341053 	if (!dev || !dev->lldd_dev)
10351054 		return -1;
10361055 
10371056 	pm8001_dev = dev->lldd_dev;
1038
-	device_id = pm8001_dev->device_id;
10391057 	pm8001_ha = pm8001_find_ha_by_dev(dev);
10401058 
1041
-	PM8001_EH_DBG(pm8001_ha,
1042
-			pm8001_printk("I_T_Nexus handler invoked !!"));
1059
+	pm8001_dbg(pm8001_ha, EH, "I_T_Nexus handler invoked !!\n");
10431060 
10441061 	phy = sas_get_local_phy(dev);
10451062 
....@@ -1078,8 +1095,8 @@
10781095 		rc = sas_phy_reset(phy, 1);
10791096 		msleep(2000);
10801097 	}
1081
-	PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
1082
-		pm8001_dev->device_id, rc));
1098
+	pm8001_dbg(pm8001_ha, EH, " for device[%x]:rc=%d\n",
1099
+		   pm8001_dev->device_id, rc);
10831100 out:
10841101 	sas_put_local_phy(phy);
10851102 
....@@ -1108,8 +1125,8 @@
11081125 		rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
11091126 	}
11101127 	/* If failed, fall-through I_T_Nexus reset */
1111
-	PM8001_EH_DBG(pm8001_ha, pm8001_printk("for device[%x]:rc=%d\n",
1112
-		pm8001_dev->device_id, rc));
1128
+	pm8001_dbg(pm8001_ha, EH, "for device[%x]:rc=%d\n",
1129
+		   pm8001_dev->device_id, rc);
11131130 	return rc;
11141131 }
11151132 
....@@ -1117,7 +1134,6 @@
11171134 int pm8001_query_task(struct sas_task *task)
11181135 {
11191136 	u32 tag = 0xdeadbeef;
1120
-	int i = 0;
11211137 	struct scsi_lun lun;
11221138 	struct pm8001_tmf_task tmf_task;
11231139 	int rc = TMF_RESP_FUNC_FAILED;
....@@ -1136,10 +1152,7 @@
11361152 			rc = TMF_RESP_FUNC_FAILED;
11371153 			return rc;
11381154 		}
1139
-		PM8001_EH_DBG(pm8001_ha, pm8001_printk("Query:["));
1140
-		for (i = 0; i < 16; i++)
1141
-			printk(KERN_INFO "%02x ", cmnd->cmnd[i]);
1142
-		printk(KERN_INFO "]\n");
1155
+		pm8001_dbg(pm8001_ha, EH, "Query:[%16ph]\n", cmnd->cmnd);
11431156 		tmf_task.tmf = 	TMF_QUERY_TASK;
11441157 		tmf_task.tag_of_task_to_be_managed = tag;
11451158 
....@@ -1147,28 +1160,26 @@
11471160 		switch (rc) {
11481161 		/* The task is still in Lun, release it then */
11491162 		case TMF_RESP_FUNC_SUCC:
1150
-			PM8001_EH_DBG(pm8001_ha,
1151
-				pm8001_printk("The task is still in Lun\n"));
1163
+			pm8001_dbg(pm8001_ha, EH,
1164
+				   "The task is still in Lun\n");
11521165 			break;
11531166 		/* The task is not in Lun or failed, reset the phy */
11541167 		case TMF_RESP_FUNC_FAILED:
11551168 		case TMF_RESP_FUNC_COMPLETE:
1156
-			PM8001_EH_DBG(pm8001_ha,
1157
-			pm8001_printk("The task is not in Lun or failed,"
1158
-			" reset the phy\n"));
1169
+			pm8001_dbg(pm8001_ha, EH,
1170
+				   "The task is not in Lun or failed, reset the phy\n");
11591171 			break;
11601172 		}
11611173 	}
1162
-	pm8001_printk(":rc= %d\n", rc);
1174
+	pr_err("pm80xx: rc= %d\n", rc);
11631175 	return rc;
11641176 }
11651177 
1166
-/*  mandatory SAM-3, still need free task/ccb info, abord the specified task */
1178
+/*  mandatory SAM-3, still need free task/ccb info, abort the specified task */
11671179 int pm8001_abort_task(struct sas_task *task)
11681180 {
11691181 	unsigned long flags;
11701182 	u32 tag;
1171
-	u32 device_id;
11721183 	struct domain_device *dev ;
11731184 	struct pm8001_hba_info *pm8001_ha;
11741185 	struct scsi_lun lun;
....@@ -1182,7 +1193,6 @@
11821193 	dev = task->dev;
11831194 	pm8001_dev = dev->lldd_dev;
11841195 	pm8001_ha = pm8001_find_ha_by_dev(dev);
1185
-	device_id = pm8001_dev->device_id;
11861196 	phy_id = pm8001_dev->attached_phy;
11871197 	ret = pm8001_find_tag(task, &tag);
11881198 	if (ret == 0) {
....@@ -1243,8 +1253,8 @@
12431253 			 * leaking the task in libsas or losing the race and
12441254 			 * getting a double free.
12451255 			 */
1246
-			PM8001_MSG_DBG(pm8001_ha,
1247
-				pm8001_printk("Waiting for local phy ctl\n"));
1256
+			pm8001_dbg(pm8001_ha, MSG,
1257
+				   "Waiting for local phy ctl\n");
12481258 			ret = wait_for_completion_timeout(&completion,
12491259 					PM8001_TASK_TIMEOUT * HZ);
12501260 			if (!ret || !phy->reset_success) {
....@@ -1254,8 +1264,8 @@
12541264 				/* 3. Wait for Port Reset complete or
12551265 				 * Port reset TMO
12561266 				 */
1257
-				PM8001_MSG_DBG(pm8001_ha,
1258
-				pm8001_printk("Waiting for Port reset\n"));
1267
+				pm8001_dbg(pm8001_ha, MSG,
1268
+					   "Waiting for Port reset\n");
12591269 				ret = wait_for_completion_timeout(
12601270 					&completion_reset,
12611271 					PM8001_TASK_TIMEOUT * HZ);
....@@ -1314,37 +1324,29 @@
13141324 
13151325 int pm8001_abort_task_set(struct domain_device *dev, u8 *lun)
13161326 {
1317
-	int rc = TMF_RESP_FUNC_FAILED;
13181327 	struct pm8001_tmf_task tmf_task;
13191328 
13201329 	tmf_task.tmf = TMF_ABORT_TASK_SET;
1321
-	rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1322
-	return rc;
1330
+	return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
13231331 }
13241332 
13251333 int pm8001_clear_aca(struct domain_device *dev, u8 *lun)
13261334 {
1327
-	int rc = TMF_RESP_FUNC_FAILED;
13281335 	struct pm8001_tmf_task tmf_task;
13291336 
13301337 	tmf_task.tmf = TMF_CLEAR_ACA;
1331
-	rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1332
-
1333
-	return rc;
1338
+	return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
13341339 }
13351340 
13361341 int pm8001_clear_task_set(struct domain_device *dev, u8 *lun)
13371342 {
1338
-	int rc = TMF_RESP_FUNC_FAILED;
13391343 	struct pm8001_tmf_task tmf_task;
13401344 	struct pm8001_device *pm8001_dev = dev->lldd_dev;
13411345 	struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
13421346 
1343
-	PM8001_EH_DBG(pm8001_ha,
1344
-		pm8001_printk("I_T_L_Q clear task set[%x]\n",
1345
-		pm8001_dev->device_id));
1347
+	pm8001_dbg(pm8001_ha, EH, "I_T_L_Q clear task set[%x]\n",
1348
+		   pm8001_dev->device_id);
13461349 	tmf_task.tmf = TMF_CLEAR_TASK_SET;
1347
-	rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
1348
-	return rc;
1350
+	return pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
13491351 }
13501352