tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

scsi: pm8001: Simplify pm8001_ccb_task_free()

The task argument of the pm8001_ccb_task_free() function can be inferred
from the ccb argument ccb_task field. So there is no need to have this
argument. Likewise, the ccb_index argument is always equal to the ccb tag
field and is not needed either. Remove both arguments and update all call
sites. The pm8001_ccb_task_free_done() helper is also modified to match
this change.

Link: https://lore.kernel.org/r/20220220031810.738362-30-damien.lemoal@opensource.wdc.com
Reviewed-by: Jack Wang <jinpu.wang@ionos.com>
Signed-off-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

authored by

Damien Le Moal and committed by
Martin K. Petersen 304fe11b e29c47fe

+52 -62
+19 -23
drivers/scsi/pm8001/pm8001_hwi.c
··· 1564 1564 spin_unlock_irqrestore(&t->task_state_lock, flags1); 1565 1565 pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 1566 1566 t, pw->handler, ts->resp, ts->stat); 1567 - pm8001_ccb_task_free(pm8001_ha, t, ccb, ccb->ccb_tag); 1567 + pm8001_ccb_task_free(pm8001_ha, ccb); 1568 1568 spin_unlock_irqrestore(&pm8001_ha->lock, flags); 1569 1569 } else { 1570 1570 spin_unlock_irqrestore(&t->task_state_lock, flags1); 1571 - pm8001_ccb_task_free(pm8001_ha, t, ccb, ccb->ccb_tag); 1571 + pm8001_ccb_task_free(pm8001_ha, ccb); 1572 1572 mb();/* in order to force CPU ordering */ 1573 1573 spin_unlock_irqrestore(&pm8001_ha->lock, flags); 1574 1574 t->task_done(t); ··· 1697 1697 continue; 1698 1698 } 1699 1699 /*complete sas task and update to top layer */ 1700 - pm8001_ccb_task_free(pm8001_ha, task, ccb, 1701 - ccb->ccb_tag); 1700 + pm8001_ccb_task_free(pm8001_ha, ccb); 1702 1701 ts->resp = SAS_TASK_COMPLETE; 1703 1702 task->task_done(task); 1704 1703 } else if (ccb->ccb_tag != PM8001_INVALID_TAG) { ··· 2083 2084 spin_unlock_irqrestore(&t->task_state_lock, flags); 2084 2085 pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2085 2086 t, status, ts->resp, ts->stat); 2086 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2087 + pm8001_ccb_task_free(pm8001_ha, ccb); 2087 2088 } else { 2088 2089 spin_unlock_irqrestore(&t->task_state_lock, flags); 2089 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2090 + pm8001_ccb_task_free(pm8001_ha, ccb); 2090 2091 mb();/* in order to force CPU ordering */ 2091 2092 t->task_done(t); 2092 2093 } ··· 2250 2251 spin_unlock_irqrestore(&t->task_state_lock, flags); 2251 2252 pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2252 2253 t, event, ts->resp, ts->stat); 2253 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2254 + pm8001_ccb_task_free(pm8001_ha, ccb); 2254 2255 } else { 2255 2256 spin_unlock_irqrestore(&t->task_state_lock, flags); 2256 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2257 + pm8001_ccb_task_free(pm8001_ha, ccb); 2257 2258 mb();/* in order to force CPU ordering */ 2258 2259 t->task_done(t); 2259 2260 } ··· 2479 2480 IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS); 2480 2481 ts->resp = SAS_TASK_UNDELIVERED; 2481 2482 ts->stat = SAS_QUEUE_FULL; 2482 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2483 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2483 2484 return; 2484 2485 } 2485 2486 break; ··· 2495 2496 IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS); 2496 2497 ts->resp = SAS_TASK_UNDELIVERED; 2497 2498 ts->stat = SAS_QUEUE_FULL; 2498 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2499 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2499 2500 return; 2500 2501 } 2501 2502 break; ··· 2517 2518 IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY); 2518 2519 ts->resp = SAS_TASK_UNDELIVERED; 2519 2520 ts->stat = SAS_QUEUE_FULL; 2520 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2521 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2521 2522 return; 2522 2523 } 2523 2524 break; ··· 2588 2589 IO_DS_NON_OPERATIONAL); 2589 2590 ts->resp = SAS_TASK_UNDELIVERED; 2590 2591 ts->stat = SAS_QUEUE_FULL; 2591 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2592 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2592 2593 return; 2593 2594 } 2594 2595 break; ··· 2608 2609 IO_DS_IN_ERROR); 2609 2610 ts->resp = SAS_TASK_UNDELIVERED; 2610 2611 ts->stat = SAS_QUEUE_FULL; 2611 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2612 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2612 2613 return; 2613 2614 } 2614 2615 break; ··· 2638 2639 pm8001_dbg(pm8001_ha, FAIL, 2639 2640 "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2640 2641 t, status, ts->resp, ts->stat); 2641 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2642 + pm8001_ccb_task_free(pm8001_ha, ccb); 2642 2643 } else { 2643 2644 spin_unlock_irqrestore(&t->task_state_lock, flags); 2644 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2645 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2645 2646 } 2646 2647 } 2647 2648 ··· 2993 2994 spin_unlock_irqrestore(&t->task_state_lock, flags); 2994 2995 pm8001_dbg(pm8001_ha, FAIL, "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2995 2996 t, status, ts->resp, ts->stat); 2996 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2997 + pm8001_ccb_task_free(pm8001_ha, ccb); 2997 2998 } else { 2998 2999 spin_unlock_irqrestore(&t->task_state_lock, flags); 2999 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 3000 - mb();/* in order to force CPU ordering */ 3001 - t->task_done(t); 3000 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 3002 3001 } 3003 3002 } 3004 3003 ··· 3646 3649 t->task_state_flags &= ~SAS_TASK_STATE_PENDING; 3647 3650 t->task_state_flags |= SAS_TASK_STATE_DONE; 3648 3651 spin_unlock_irqrestore(&t->task_state_lock, flags); 3649 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 3652 + pm8001_ccb_task_free(pm8001_ha, ccb); 3650 3653 mb(); 3651 3654 3652 3655 if (pm8001_dev->id & NCQ_ABORT_ALL_FLAG) { ··· 4284 4287 "task 0x%p resp 0x%x stat 0x%x but aborted by upper layer\n", 4285 4288 task, ts->resp, 4286 4289 ts->stat); 4287 - pm8001_ccb_task_free(pm8001_ha, task, ccb, tag); 4290 + pm8001_ccb_task_free(pm8001_ha, ccb); 4288 4291 } else { 4289 4292 spin_unlock_irqrestore(&task->task_state_lock, 4290 4293 flags); 4291 - pm8001_ccb_task_free_done(pm8001_ha, task, 4292 - ccb, tag); 4294 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 4293 4295 return 0; 4294 4296 } 4295 4297 }
+12 -13
drivers/scsi/pm8001/pm8001_sas.c
··· 489 489 /** 490 490 * pm8001_ccb_task_free - free the sg for ssp and smp command, free the ccb. 491 491 * @pm8001_ha: our hba card information 492 - * @ccb: the ccb which attached to ssp task 493 - * @task: the task to be free. 494 - * @ccb_idx: ccb index. 492 + * @ccb: the ccb which attached to ssp task to free 495 493 */ 496 494 void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha, 497 - struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx) 495 + struct pm8001_ccb_info *ccb) 498 496 { 497 + struct sas_task *task = ccb->task; 499 498 struct ata_queued_cmd *qc; 500 499 struct pm8001_device *pm8001_dev; 501 500 502 - if (!ccb->task) 501 + if (!task) 503 502 return; 504 - if (!sas_protocol_ata(task->task_proto)) 505 - if (ccb->n_elem) 506 - dma_unmap_sg(pm8001_ha->dev, task->scatter, 507 - task->num_scatter, task->data_dir); 503 + 504 + if (!sas_protocol_ata(task->task_proto) && ccb->n_elem) 505 + dma_unmap_sg(pm8001_ha->dev, task->scatter, 506 + task->num_scatter, task->data_dir); 508 507 509 508 switch (task->task_proto) { 510 509 case SAS_PROTOCOL_SMP: ··· 522 523 } 523 524 524 525 if (sas_protocol_ata(task->task_proto)) { 525 - // For SCSI/ATA commands uldd_task points to ata_queued_cmd 526 + /* For SCSI/ATA commands uldd_task points to ata_queued_cmd */ 526 527 qc = task->uldd_task; 527 528 pm8001_dev = ccb->device; 528 529 trace_pm80xx_request_complete(pm8001_ha->id, 529 530 pm8001_dev ? pm8001_dev->attached_phy : PM8001_MAX_PHYS, 530 - ccb_idx, 0 /* ctlr_opcode not known */, 531 + ccb->ccb_tag, 0 /* ctlr_opcode not known */, 531 532 qc ? qc->tf.command : 0, // ata opcode 532 533 pm8001_dev ? atomic_read(&pm8001_dev->running_req) : -1); 533 534 } ··· 843 844 & SAS_TASK_STATE_ABORTED))) { 844 845 spin_unlock_irqrestore(&task->task_state_lock, 845 846 flags1); 846 - pm8001_ccb_task_free(pm8001_ha, task, ccb, ccb->ccb_tag); 847 + pm8001_ccb_task_free(pm8001_ha, ccb); 847 848 } else { 848 849 spin_unlock_irqrestore(&task->task_state_lock, 849 850 flags1); 850 - pm8001_ccb_task_free(pm8001_ha, task, ccb, ccb->ccb_tag); 851 + pm8001_ccb_task_free(pm8001_ha, ccb); 851 852 mb();/* in order to force CPU ordering */ 852 853 spin_unlock_irqrestore(&pm8001_ha->lock, flags); 853 854 task->task_done(task);
+6 -6
drivers/scsi/pm8001/pm8001_sas.h
··· 637 637 void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha); 638 638 u32 pm8001_get_ncq_tag(struct sas_task *task, u32 *tag); 639 639 void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha, 640 - struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx); 640 + struct pm8001_ccb_info *ccb); 641 641 int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func, 642 642 void *funcdata); 643 643 void pm8001_scan_start(struct Scsi_Host *shost); ··· 780 780 pm8001_tag_free(pm8001_ha, tag); 781 781 } 782 782 783 - static inline void 784 - pm8001_ccb_task_free_done(struct pm8001_hba_info *pm8001_ha, 785 - struct sas_task *task, struct pm8001_ccb_info *ccb, 786 - u32 ccb_idx) 783 + static inline void pm8001_ccb_task_free_done(struct pm8001_hba_info *pm8001_ha, 784 + struct pm8001_ccb_info *ccb) 787 785 { 788 - pm8001_ccb_task_free(pm8001_ha, task, ccb, ccb_idx); 786 + struct sas_task *task = ccb->task; 787 + 788 + pm8001_ccb_task_free(pm8001_ha, ccb); 789 789 smp_mb(); /*in order to force CPU ordering*/ 790 790 task->task_done(task); 791 791 }
+15 -20
drivers/scsi/pm8001/pm80xx_hwi.c
··· 2157 2157 pm8001_dbg(pm8001_ha, FAIL, 2158 2158 "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2159 2159 t, status, ts->resp, ts->stat); 2160 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2160 + pm8001_ccb_task_free(pm8001_ha, ccb); 2161 2161 if (t->slow_task) 2162 2162 complete(&t->slow_task->completion); 2163 2163 } else { 2164 2164 spin_unlock_irqrestore(&t->task_state_lock, flags); 2165 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2166 - mb();/* in order to force CPU ordering */ 2167 - t->task_done(t); 2165 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2168 2166 } 2169 2167 } 2170 2168 ··· 2338 2340 pm8001_dbg(pm8001_ha, FAIL, 2339 2341 "task 0x%p done with event 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2340 2342 t, event, ts->resp, ts->stat); 2341 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2343 + pm8001_ccb_task_free(pm8001_ha, ccb); 2342 2344 } else { 2343 2345 spin_unlock_irqrestore(&t->task_state_lock, flags); 2344 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2345 - mb();/* in order to force CPU ordering */ 2346 - t->task_done(t); 2346 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2347 2347 } 2348 2348 } 2349 2349 ··· 2575 2579 ts->stat = SAS_QUEUE_FULL; 2576 2580 spin_unlock_irqrestore(&circularQ->oq_lock, 2577 2581 circularQ->lock_flags); 2578 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2582 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2579 2583 spin_lock_irqsave(&circularQ->oq_lock, 2580 2584 circularQ->lock_flags); 2581 2585 return; ··· 2595 2599 ts->stat = SAS_QUEUE_FULL; 2596 2600 spin_unlock_irqrestore(&circularQ->oq_lock, 2597 2601 circularQ->lock_flags); 2598 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2602 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2599 2603 spin_lock_irqsave(&circularQ->oq_lock, 2600 2604 circularQ->lock_flags); 2601 2605 return; ··· 2623 2627 ts->stat = SAS_QUEUE_FULL; 2624 2628 spin_unlock_irqrestore(&circularQ->oq_lock, 2625 2629 circularQ->lock_flags); 2626 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2630 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2627 2631 spin_lock_irqsave(&circularQ->oq_lock, 2628 2632 circularQ->lock_flags); 2629 2633 return; ··· 2698 2702 ts->stat = SAS_QUEUE_FULL; 2699 2703 spin_unlock_irqrestore(&circularQ->oq_lock, 2700 2704 circularQ->lock_flags); 2701 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2705 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2702 2706 spin_lock_irqsave(&circularQ->oq_lock, 2703 2707 circularQ->lock_flags); 2704 2708 return; ··· 2722 2726 ts->stat = SAS_QUEUE_FULL; 2723 2727 spin_unlock_irqrestore(&circularQ->oq_lock, 2724 2728 circularQ->lock_flags); 2725 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2729 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2726 2730 spin_lock_irqsave(&circularQ->oq_lock, 2727 2731 circularQ->lock_flags); 2728 2732 return; ··· 2756 2760 pm8001_dbg(pm8001_ha, FAIL, 2757 2761 "task 0x%p done with io_status 0x%x resp 0x%x stat 0x%x but aborted by upper layer!\n", 2758 2762 t, status, ts->resp, ts->stat); 2759 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 2763 + pm8001_ccb_task_free(pm8001_ha, ccb); 2760 2764 if (t->slow_task) 2761 2765 complete(&t->slow_task->completion); 2762 2766 } else { 2763 2767 spin_unlock_irqrestore(&t->task_state_lock, flags); 2764 2768 spin_unlock_irqrestore(&circularQ->oq_lock, 2765 2769 circularQ->lock_flags); 2766 - pm8001_ccb_task_free_done(pm8001_ha, t, ccb, tag); 2770 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 2767 2771 spin_lock_irqsave(&circularQ->oq_lock, 2768 2772 circularQ->lock_flags); 2769 2773 } ··· 3167 3171 pm8001_dbg(pm8001_ha, FAIL, 3168 3172 "task 0x%p done with io_status 0x%x resp 0x%xstat 0x%x but aborted by upper layer!\n", 3169 3173 t, status, ts->resp, ts->stat); 3170 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 3174 + pm8001_ccb_task_free(pm8001_ha, ccb); 3171 3175 } else { 3172 3176 spin_unlock_irqrestore(&t->task_state_lock, flags); 3173 - pm8001_ccb_task_free(pm8001_ha, t, ccb, tag); 3177 + pm8001_ccb_task_free(pm8001_ha, ccb); 3174 3178 mb();/* in order to force CPU ordering */ 3175 3179 t->task_done(t); 3176 3180 } ··· 4698 4702 "task 0x%p resp 0x%x stat 0x%x but aborted by upper layer\n", 4699 4703 task, ts->resp, 4700 4704 ts->stat); 4701 - pm8001_ccb_task_free(pm8001_ha, task, ccb, tag); 4705 + pm8001_ccb_task_free(pm8001_ha, ccb); 4702 4706 return 0; 4703 4707 } else { 4704 4708 spin_unlock_irqrestore(&task->task_state_lock, 4705 4709 flags); 4706 - pm8001_ccb_task_free_done(pm8001_ha, task, 4707 - ccb, tag); 4710 + pm8001_ccb_task_free_done(pm8001_ha, ccb); 4708 4711 atomic_dec(&pm8001_ha_dev->running_req); 4709 4712 return 0; 4710 4713 }