aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/block
diff options
context:
space:
mode:
authorrchinthekindi <rchinthekindi@stec-inc.com>2013-10-24 07:51:23 -0400
committerJens Axboe <axboe@kernel.dk>2013-11-08 11:10:29 -0500
commit2e44b42718ac49a397324a360df4ecab617b3fe2 (patch)
tree5e8990267db92cfdd089c48bd806077b06cfd413 /drivers/block
parentf721bb0dbd3fd37f16c49c97155f40f22496a970 (diff)
skd: Replaced custom debug PRINTKs with pr_debug
Replaced DPRINTK() and VPRINTK() with pr_debug(). Signed-off-by: Ramprasad C <ramprasad.chinthekindi@hgst.com> Signed-off-by: Jens Axboe <axboe@kernel.dk>
Diffstat (limited to 'drivers/block')
-rw-r--r--drivers/block/skd_main.c691
1 files changed, 407 insertions, 284 deletions
diff --git a/drivers/block/skd_main.c b/drivers/block/skd_main.c
index 308bf474dc39..ab17bff6b4f9 100644
--- a/drivers/block/skd_main.c
+++ b/drivers/block/skd_main.c
@@ -68,14 +68,6 @@ enum {
68 SKD_FLUSH_DATA_SECOND, 68 SKD_FLUSH_DATA_SECOND,
69}; 69};
70 70
71#define DPRINTK(skdev, fmt, args ...) \
72 do { \
73 if (unlikely((skdev)->dbg_level > 0)) { \
74 pr_err("%s:%s:%d " fmt, (skdev)->name, \
75 __func__, __LINE__, ## args); \
76 } \
77 } while (0)
78
79#define SKD_ASSERT(expr) \ 71#define SKD_ASSERT(expr) \
80 do { \ 72 do { \
81 if (unlikely(!(expr))) { \ 73 if (unlikely(!(expr))) { \
@@ -84,15 +76,6 @@ enum {
84 } \ 76 } \
85 } while (0) 77 } while (0)
86 78
87#define VPRINTK(skdev, fmt, args ...) \
88 do { \
89 if (unlikely((skdev)->dbg_level > 1)) { \
90 pr_err("%s:%s:%d " fmt, (skdev)->name, \
91 __func__, __LINE__, ## args); \
92 } \
93 } while (0)
94
95
96#define DRV_NAME "skd" 79#define DRV_NAME "skd"
97#define DRV_VERSION "2.2.1" 80#define DRV_VERSION "2.2.1"
98#define DRV_BUILD_ID "0260" 81#define DRV_BUILD_ID "0260"
@@ -408,7 +391,8 @@ static inline u32 skd_reg_read32(struct skd_device *skdev, u32 offset)
408 barrier(); 391 barrier();
409 val = readl(skdev->mem_map[1] + offset); 392 val = readl(skdev->mem_map[1] + offset);
410 barrier(); 393 barrier();
411 VPRINTK(skdev, "offset %x = %x\n", offset, val); 394 pr_debug("%s:%s:%d offset %x = %x\n",
395 skdev->name, __func__, __LINE__, offset, val);
412 return val; 396 return val;
413 } 397 }
414 398
@@ -424,7 +408,8 @@ static inline void skd_reg_write32(struct skd_device *skdev, u32 val,
424 barrier(); 408 barrier();
425 writel(val, skdev->mem_map[1] + offset); 409 writel(val, skdev->mem_map[1] + offset);
426 barrier(); 410 barrier();
427 VPRINTK(skdev, "offset %x = %x\n", offset, val); 411 pr_debug("%s:%s:%d offset %x = %x\n",
412 skdev->name, __func__, __LINE__, offset, val);
428 } 413 }
429} 414}
430 415
@@ -438,7 +423,8 @@ static inline void skd_reg_write64(struct skd_device *skdev, u64 val,
438 barrier(); 423 barrier();
439 writeq(val, skdev->mem_map[1] + offset); 424 writeq(val, skdev->mem_map[1] + offset);
440 barrier(); 425 barrier();
441 VPRINTK(skdev, "offset %x = %016llx\n", offset, val); 426 pr_debug("%s:%s:%d offset %x = %016llx\n",
427 skdev->name, __func__, __LINE__, offset, val);
442 } 428 }
443} 429}
444 430
@@ -764,15 +750,17 @@ static void skd_request_fn(struct request_queue *q)
764 if (io_flags & REQ_FUA) 750 if (io_flags & REQ_FUA)
765 fua++; 751 fua++;
766 752
767 VPRINTK(skdev, 753 pr_debug("%s:%s:%d new req=%p lba=%u(0x%x) "
768 "new req=%p lba=%u(0x%x) count=%u(0x%x) dir=%d\n", 754 "count=%u(0x%x) dir=%d\n",
769 req, lba, lba, count, count, data_dir); 755 skdev->name, __func__, __LINE__,
756 req, lba, lba, count, count, data_dir);
770 } else { 757 } else {
771 if (!list_empty(&skdev->flush_list)) { 758 if (!list_empty(&skdev->flush_list)) {
772 /* Process data part of FLUSH request. */ 759 /* Process data part of FLUSH request. */
773 bio = (struct bio *)skd_flush_cmd_dequeue(skdev); 760 bio = (struct bio *)skd_flush_cmd_dequeue(skdev);
774 flush++; 761 flush++;
775 VPRINTK(skdev, "processing FLUSH request with data.\n"); 762 pr_debug("%s:%s:%d processing FLUSH request with data.\n",
763 skdev->name, __func__, __LINE__);
776 } else { 764 } else {
777 /* peek at our bio queue */ 765 /* peek at our bio queue */
778 bio = bio_list_peek(&skdev->bio_queue); 766 bio = bio_list_peek(&skdev->bio_queue);
@@ -787,9 +775,10 @@ static void skd_request_fn(struct request_queue *q)
787 data_dir = bio_data_dir(bio); 775 data_dir = bio_data_dir(bio);
788 io_flags = bio->bi_rw; 776 io_flags = bio->bi_rw;
789 777
790 VPRINTK(skdev, 778 pr_debug("%s:%s:%d new bio=%p lba=%u(0x%x) "
791 "new bio=%p lba=%u(0x%x) count=%u(0x%x) dir=%d\n", 779 "count=%u(0x%x) dir=%d\n",
792 bio, lba, lba, count, count, data_dir); 780 skdev->name, __func__, __LINE__,
781 bio, lba, lba, count, count, data_dir);
793 782
794 if (io_flags & REQ_FLUSH) 783 if (io_flags & REQ_FLUSH)
795 flush++; 784 flush++;
@@ -805,15 +794,17 @@ static void skd_request_fn(struct request_queue *q)
805 794
806 /* Are too many requets already in progress? */ 795 /* Are too many requets already in progress? */
807 if (skdev->in_flight >= skdev->cur_max_queue_depth) { 796 if (skdev->in_flight >= skdev->cur_max_queue_depth) {
808 VPRINTK(skdev, "qdepth %d, limit %d\n", 797 pr_debug("%s:%s:%d qdepth %d, limit %d\n",
809 skdev->in_flight, skdev->cur_max_queue_depth); 798 skdev->name, __func__, __LINE__,
799 skdev->in_flight, skdev->cur_max_queue_depth);
810 break; 800 break;
811 } 801 }
812 802
813 /* Is a skd_request_context available? */ 803 /* Is a skd_request_context available? */
814 skreq = skdev->skreq_free_list; 804 skreq = skdev->skreq_free_list;
815 if (skreq == NULL) { 805 if (skreq == NULL) {
816 VPRINTK(skdev, "Out of req=%p\n", q); 806 pr_debug("%s:%s:%d Out of req=%p\n",
807 skdev->name, __func__, __LINE__, q);
817 break; 808 break;
818 } 809 }
819 SKD_ASSERT(skreq->state == SKD_REQ_STATE_IDLE); 810 SKD_ASSERT(skreq->state == SKD_REQ_STATE_IDLE);
@@ -822,7 +813,8 @@ static void skd_request_fn(struct request_queue *q)
822 /* Now we check to see if we can get a fit msg */ 813 /* Now we check to see if we can get a fit msg */
823 if (skmsg == NULL) { 814 if (skmsg == NULL) {
824 if (skdev->skmsg_free_list == NULL) { 815 if (skdev->skmsg_free_list == NULL) {
825 VPRINTK(skdev, "Out of msg\n"); 816 pr_debug("%s:%s:%d Out of msg\n",
817 skdev->name, __func__, __LINE__);
826 break; 818 break;
827 } 819 }
828 } 820 }
@@ -862,7 +854,9 @@ static void skd_request_fn(struct request_queue *q)
862 /* Are there any FIT msg buffers available? */ 854 /* Are there any FIT msg buffers available? */
863 skmsg = skdev->skmsg_free_list; 855 skmsg = skdev->skmsg_free_list;
864 if (skmsg == NULL) { 856 if (skmsg == NULL) {
865 VPRINTK(skdev, "Out of msg skdev=%p\n", skdev); 857 pr_debug("%s:%s:%d Out of msg skdev=%p\n",
858 skdev->name, __func__, __LINE__,
859 skdev);
866 break; 860 break;
867 } 861 }
868 SKD_ASSERT(skmsg->state == SKD_MSG_STATE_IDLE); 862 SKD_ASSERT(skmsg->state == SKD_MSG_STATE_IDLE);
@@ -945,7 +939,8 @@ static void skd_request_fn(struct request_queue *q)
945 * only resource that has been allocated but might 939 * only resource that has been allocated but might
946 * not be used is that the FIT msg could be empty. 940 * not be used is that the FIT msg could be empty.
947 */ 941 */
948 DPRINTK(skdev, "error Out\n"); 942 pr_debug("%s:%s:%d error Out\n",
943 skdev->name, __func__, __LINE__);
949 skd_end_request(skdev, skreq, error); 944 skd_end_request(skdev, skreq, error);
950 continue; 945 continue;
951 } 946 }
@@ -970,8 +965,9 @@ skip_sg:
970 timo_slot = skreq->timeout_stamp & SKD_TIMEOUT_SLOT_MASK; 965 timo_slot = skreq->timeout_stamp & SKD_TIMEOUT_SLOT_MASK;
971 skdev->timeout_slot[timo_slot]++; 966 skdev->timeout_slot[timo_slot]++;
972 skdev->in_flight++; 967 skdev->in_flight++;
973 VPRINTK(skdev, "req=0x%x busy=%d\n", 968 pr_debug("%s:%s:%d req=0x%x busy=%d\n",
974 skreq->id, skdev->in_flight); 969 skdev->name, __func__, __LINE__,
970 skreq->id, skdev->in_flight);
975 971
976 /* 972 /*
977 * If the FIT msg buffer is full send it. 973 * If the FIT msg buffer is full send it.
@@ -993,8 +989,9 @@ skip_sg:
993 if (skmsg != NULL) { 989 if (skmsg != NULL) {
994 /* Bigger than just a FIT msg header? */ 990 /* Bigger than just a FIT msg header? */
995 if (skmsg->length > sizeof(struct fit_msg_hdr)) { 991 if (skmsg->length > sizeof(struct fit_msg_hdr)) {
996 VPRINTK(skdev, "sending msg=%p, len %d\n", 992 pr_debug("%s:%s:%d sending msg=%p, len %d\n",
997 skmsg, skmsg->length); 993 skdev->name, __func__, __LINE__,
994 skmsg, skmsg->length);
998 skd_send_fitmsg(skdev, skmsg); 995 skd_send_fitmsg(skdev, skmsg);
999 } else { 996 } else {
1000 /* 997 /*
@@ -1027,7 +1024,8 @@ static void skd_end_request_blk(struct skd_device *skdev,
1027 1024
1028 if ((io_flags & REQ_DISCARD) && 1025 if ((io_flags & REQ_DISCARD) &&
1029 (skreq->discard_page == 1)) { 1026 (skreq->discard_page == 1)) {
1030 VPRINTK(skdev, "skd_end_request_blk, free the page!"); 1027 pr_debug("%s:%s:%d skd_end_request_blk, free the page!",
1028 skdev->name, __func__, __LINE__);
1031 free_page((unsigned long)req->buffer); 1029 free_page((unsigned long)req->buffer);
1032 req->buffer = NULL; 1030 req->buffer = NULL;
1033 } 1031 }
@@ -1041,7 +1039,8 @@ static void skd_end_request_blk(struct skd_device *skdev,
1041 pr_err("(%s): Error cmd=%s sect=%u count=%u id=0x%x\n", 1039 pr_err("(%s): Error cmd=%s sect=%u count=%u id=0x%x\n",
1042 skd_name(skdev), cmd, lba, count, skreq->id); 1040 skd_name(skdev), cmd, lba, count, skreq->id);
1043 } else 1041 } else
1044 VPRINTK(skdev, "id=0x%x error=%d\n", skreq->id, error); 1042 pr_debug("%s:%s:%d id=0x%x error=%d\n",
1043 skdev->name, __func__, __LINE__, skreq->id, error);
1045 1044
1046 __blk_end_request_all(skreq->req, error); 1045 __blk_end_request_all(skreq->req, error);
1047} 1046}
@@ -1093,14 +1092,16 @@ static int skd_preop_sg_list_blk(struct skd_device *skdev,
1093 skreq->sksg_list[n_sg - 1].control = FIT_SGD_CONTROL_LAST; 1092 skreq->sksg_list[n_sg - 1].control = FIT_SGD_CONTROL_LAST;
1094 1093
1095 if (unlikely(skdev->dbg_level > 1)) { 1094 if (unlikely(skdev->dbg_level > 1)) {
1096 VPRINTK(skdev, "skreq=%x sksg_list=%p sksg_dma=%llx\n", 1095 pr_debug("%s:%s:%d skreq=%x sksg_list=%p sksg_dma=%llx\n",
1097 skreq->id, skreq->sksg_list, skreq->sksg_dma_address); 1096 skdev->name, __func__, __LINE__,
1097 skreq->id, skreq->sksg_list, skreq->sksg_dma_address);
1098 for (i = 0; i < n_sg; i++) { 1098 for (i = 0; i < n_sg; i++) {
1099 struct fit_sg_descriptor *sgd = &skreq->sksg_list[i]; 1099 struct fit_sg_descriptor *sgd = &skreq->sksg_list[i];
1100 VPRINTK(skdev, " sg[%d] count=%u ctrl=0x%x " 1100 pr_debug("%s:%s:%d sg[%d] count=%u ctrl=0x%x "
1101 "addr=0x%llx next=0x%llx\n", 1101 "addr=0x%llx next=0x%llx\n",
1102 i, sgd->byte_count, sgd->control, 1102 skdev->name, __func__, __LINE__,
1103 sgd->host_side_addr, sgd->next_desc_ptr); 1103 i, sgd->byte_count, sgd->control,
1104 sgd->host_side_addr, sgd->next_desc_ptr);
1104 } 1105 }
1105 } 1106 }
1106 1107
@@ -1132,7 +1133,8 @@ static void skd_end_request_bio(struct skd_device *skdev,
1132 1133
1133 if ((io_flags & REQ_DISCARD) && 1134 if ((io_flags & REQ_DISCARD) &&
1134 (skreq->discard_page == 1)) { 1135 (skreq->discard_page == 1)) {
1135 VPRINTK(skdev, "biomode: skd_end_request: freeing DISCARD page.\n"); 1136 pr_debug("%s:%s:%d biomode: skd_end_request: freeing DISCARD page.\n",
1137 skdev->name, __func__, __LINE__);
1136 free_page((unsigned long)page_address(bio->bi_io_vec->bv_page)); 1138 free_page((unsigned long)page_address(bio->bi_io_vec->bv_page));
1137 } 1139 }
1138 1140
@@ -1157,7 +1159,8 @@ static void skd_end_request_bio(struct skd_device *skdev,
1157 part_stat_unlock(); 1159 part_stat_unlock();
1158 } 1160 }
1159 1161
1160 VPRINTK(skdev, "id=0x%x error=%d\n", skreq->id, error); 1162 pr_debug("%s:%s:%d id=0x%x error=%d\n",
1163 skdev->name, __func__, __LINE__, skreq->id, error);
1161 1164
1162 bio_endio(skreq->bio, error); 1165 bio_endio(skreq->bio, error);
1163} 1166}
@@ -1229,14 +1232,16 @@ static int skd_preop_sg_list_bio(struct skd_device *skdev,
1229 } 1232 }
1230 1233
1231 if (unlikely(skdev->dbg_level > 1)) { 1234 if (unlikely(skdev->dbg_level > 1)) {
1232 VPRINTK(skdev, "skreq=%x sksg_list=%p sksg_dma=%llx\n", 1235 pr_debug("%s:%s:%d skreq=%x sksg_list=%p sksg_dma=%llx\n",
1233 skreq->id, skreq->sksg_list, skreq->sksg_dma_address); 1236 skdev->name, __func__, __LINE__,
1237 skreq->id, skreq->sksg_list, skreq->sksg_dma_address);
1234 for (i = 0; i < n_sg; i++) { 1238 for (i = 0; i < n_sg; i++) {
1235 struct fit_sg_descriptor *sgd = &skreq->sksg_list[i]; 1239 struct fit_sg_descriptor *sgd = &skreq->sksg_list[i];
1236 VPRINTK(skdev, " sg[%d] count=%u ctrl=0x%x " 1240 pr_debug("%s:%s:%d sg[%d] count=%u ctrl=0x%x "
1237 "addr=0x%llx next=0x%llx\n", 1241 "addr=0x%llx next=0x%llx\n",
1238 i, sgd->byte_count, sgd->control, 1242 skdev->name, __func__, __LINE__,
1239 sgd->host_side_addr, sgd->next_desc_ptr); 1243 i, sgd->byte_count, sgd->control,
1244 sgd->host_side_addr, sgd->next_desc_ptr);
1240 } 1245 }
1241 } 1246 }
1242 1247
@@ -1391,8 +1396,9 @@ static void skd_timer_tick(ulong arg)
1391 /* Something is overdue */ 1396 /* Something is overdue */
1392 overdue_timestamp = skdev->timeout_stamp - SKD_N_TIMEOUT_SLOT; 1397 overdue_timestamp = skdev->timeout_stamp - SKD_N_TIMEOUT_SLOT;
1393 1398
1394 DPRINTK(skdev, "found %d timeouts, draining busy=%d\n", 1399 pr_debug("%s:%s:%d found %d timeouts, draining busy=%d\n",
1395 skdev->timeout_slot[timo_slot], skdev->in_flight); 1400 skdev->name, __func__, __LINE__,
1401 skdev->timeout_slot[timo_slot], skdev->in_flight);
1396 pr_err("(%s): Overdue IOs (%d), busy %d\n", 1402 pr_err("(%s): Overdue IOs (%d), busy %d\n",
1397 skd_name(skdev), skdev->timeout_slot[timo_slot], 1403 skd_name(skdev), skdev->timeout_slot[timo_slot],
1398 skdev->in_flight); 1404 skdev->in_flight);
@@ -1415,8 +1421,9 @@ static void skd_timer_tick_not_online(struct skd_device *skdev)
1415 case SKD_DRVR_STATE_LOAD: 1421 case SKD_DRVR_STATE_LOAD:
1416 break; 1422 break;
1417 case SKD_DRVR_STATE_BUSY_SANITIZE: 1423 case SKD_DRVR_STATE_BUSY_SANITIZE:
1418 VPRINTK(skdev, "drive busy sanitize[%x], driver[%x]\n", 1424 pr_debug("%s:%s:%d drive busy sanitize[%x], driver[%x]\n",
1419 skdev->drive_state, skdev->state); 1425 skdev->name, __func__, __LINE__,
1426 skdev->drive_state, skdev->state);
1420 /* If we've been in sanitize for 3 seconds, we figure we're not 1427 /* If we've been in sanitize for 3 seconds, we figure we're not
1421 * going to get anymore completions, so recover requests now 1428 * going to get anymore completions, so recover requests now
1422 */ 1429 */
@@ -1430,14 +1437,16 @@ static void skd_timer_tick_not_online(struct skd_device *skdev)
1430 case SKD_DRVR_STATE_BUSY: 1437 case SKD_DRVR_STATE_BUSY:
1431 case SKD_DRVR_STATE_BUSY_IMMINENT: 1438 case SKD_DRVR_STATE_BUSY_IMMINENT:
1432 case SKD_DRVR_STATE_BUSY_ERASE: 1439 case SKD_DRVR_STATE_BUSY_ERASE:
1433 VPRINTK(skdev, "busy[%x], countdown=%d\n", 1440 pr_debug("%s:%s:%d busy[%x], countdown=%d\n",
1434 skdev->state, skdev->timer_countdown); 1441 skdev->name, __func__, __LINE__,
1442 skdev->state, skdev->timer_countdown);
1435 if (skdev->timer_countdown > 0) { 1443 if (skdev->timer_countdown > 0) {
1436 skdev->timer_countdown--; 1444 skdev->timer_countdown--;
1437 return; 1445 return;
1438 } 1446 }
1439 DPRINTK(skdev, "busy[%x], timedout=%d, restarting device.", 1447 pr_debug("%s:%s:%d busy[%x], timedout=%d, restarting device.",
1440 skdev->state, skdev->timer_countdown); 1448 skdev->name, __func__, __LINE__,
1449 skdev->state, skdev->timer_countdown);
1441 skd_restart_device(skdev); 1450 skd_restart_device(skdev);
1442 break; 1451 break;
1443 1452
@@ -1470,15 +1479,17 @@ static void skd_timer_tick_not_online(struct skd_device *skdev)
1470 break; 1479 break;
1471 1480
1472 case SKD_DRVR_STATE_DRAINING_TIMEOUT: 1481 case SKD_DRVR_STATE_DRAINING_TIMEOUT:
1473 DPRINTK(skdev, 1482 pr_debug("%s:%s:%d "
1474 "draining busy [%d] tick[%d] qdb[%d] tmls[%d]\n", 1483 "draining busy [%d] tick[%d] qdb[%d] tmls[%d]\n",
1475 skdev->timo_slot, 1484 skdev->name, __func__, __LINE__,
1476 skdev->timer_countdown, 1485 skdev->timo_slot,
1477 skdev->in_flight, 1486 skdev->timer_countdown,
1478 skdev->timeout_slot[skdev->timo_slot]); 1487 skdev->in_flight,
1488 skdev->timeout_slot[skdev->timo_slot]);
1479 /* if the slot has cleared we can let the I/O continue */ 1489 /* if the slot has cleared we can let the I/O continue */
1480 if (skdev->timeout_slot[skdev->timo_slot] == 0) { 1490 if (skdev->timeout_slot[skdev->timo_slot] == 0) {
1481 DPRINTK(skdev, "Slot drained, starting queue.\n"); 1491 pr_debug("%s:%s:%d Slot drained, starting queue.\n",
1492 skdev->name, __func__, __LINE__);
1482 skdev->state = SKD_DRVR_STATE_ONLINE; 1493 skdev->state = SKD_DRVR_STATE_ONLINE;
1483 skd_start_queue(skdev); 1494 skd_start_queue(skdev);
1484 return; 1495 return;
@@ -1601,8 +1612,9 @@ static int skd_bdev_ioctl(struct block_device *bdev, fmode_t mode,
1601 struct skd_device *skdev = disk->private_data; 1612 struct skd_device *skdev = disk->private_data;
1602 void __user *p = (void *)arg; 1613 void __user *p = (void *)arg;
1603 1614
1604 DPRINTK(skdev, "%s: CMD[%s] ioctl mode 0x%x, cmd 0x%x arg %0lx\n", 1615 pr_debug("%s:%s:%d %s: CMD[%s] ioctl mode 0x%x, cmd 0x%x arg %0lx\n",
1605 disk->disk_name, current->comm, mode, cmd_in, arg); 1616 skdev->name, __func__, __LINE__,
1617 disk->disk_name, current->comm, mode, cmd_in, arg);
1606 1618
1607 if (!capable(CAP_SYS_ADMIN)) 1619 if (!capable(CAP_SYS_ADMIN))
1608 return -EPERM; 1620 return -EPERM;
@@ -1622,7 +1634,8 @@ static int skd_bdev_ioctl(struct block_device *bdev, fmode_t mode,
1622 break; 1634 break;
1623 } 1635 }
1624 1636
1625 DPRINTK(skdev, "%s: completion rc %d\n", disk->disk_name, rc); 1637 pr_debug("%s:%s:%d %s: completion rc %d\n",
1638 skdev->name, __func__, __LINE__, disk->disk_name, rc);
1626 return rc; 1639 return rc;
1627} 1640}
1628 1641
@@ -1643,7 +1656,8 @@ static int skd_ioctl_sg_io(struct skd_device *skdev, fmode_t mode,
1643 break; 1656 break;
1644 1657
1645 default: 1658 default:
1646 DPRINTK(skdev, "drive not online\n"); 1659 pr_debug("%s:%s:%d drive not online\n",
1660 skdev->name, __func__, __LINE__);
1647 rc = -ENXIO; 1661 rc = -ENXIO;
1648 goto out; 1662 goto out;
1649 } 1663 }
@@ -1697,33 +1711,38 @@ static int skd_sg_io_get_and_check_args(struct skd_device *skdev,
1697 int i, acc; 1711 int i, acc;
1698 1712
1699 if (!access_ok(VERIFY_WRITE, sksgio->argp, sizeof(sg_io_hdr_t))) { 1713 if (!access_ok(VERIFY_WRITE, sksgio->argp, sizeof(sg_io_hdr_t))) {
1700 DPRINTK(skdev, "access sg failed %p\n", sksgio->argp); 1714 pr_debug("%s:%s:%d access sg failed %p\n",
1715 skdev->name, __func__, __LINE__, sksgio->argp);
1701 return -EFAULT; 1716 return -EFAULT;
1702 } 1717 }
1703 1718
1704 if (__copy_from_user(sgp, sksgio->argp, sizeof(sg_io_hdr_t))) { 1719 if (__copy_from_user(sgp, sksgio->argp, sizeof(sg_io_hdr_t))) {
1705 DPRINTK(skdev, "copy_from_user sg failed %p\n", sksgio->argp); 1720 pr_debug("%s:%s:%d copy_from_user sg failed %p\n",
1721 skdev->name, __func__, __LINE__, sksgio->argp);
1706 return -EFAULT; 1722 return -EFAULT;
1707 } 1723 }
1708 1724
1709 if (sgp->interface_id != SG_INTERFACE_ID_ORIG) { 1725 if (sgp->interface_id != SG_INTERFACE_ID_ORIG) {
1710 DPRINTK(skdev, "interface_id invalid 0x%x\n", 1726 pr_debug("%s:%s:%d interface_id invalid 0x%x\n",
1711 sgp->interface_id); 1727 skdev->name, __func__, __LINE__, sgp->interface_id);
1712 return -EINVAL; 1728 return -EINVAL;
1713 } 1729 }
1714 1730
1715 if (sgp->cmd_len > sizeof(sksgio->cdb)) { 1731 if (sgp->cmd_len > sizeof(sksgio->cdb)) {
1716 DPRINTK(skdev, "cmd_len invalid %d\n", sgp->cmd_len); 1732 pr_debug("%s:%s:%d cmd_len invalid %d\n",
1733 skdev->name, __func__, __LINE__, sgp->cmd_len);
1717 return -EINVAL; 1734 return -EINVAL;
1718 } 1735 }
1719 1736
1720 if (sgp->iovec_count > 256) { 1737 if (sgp->iovec_count > 256) {
1721 DPRINTK(skdev, "iovec_count invalid %d\n", sgp->iovec_count); 1738 pr_debug("%s:%s:%d iovec_count invalid %d\n",
1739 skdev->name, __func__, __LINE__, sgp->iovec_count);
1722 return -EINVAL; 1740 return -EINVAL;
1723 } 1741 }
1724 1742
1725 if (sgp->dxfer_len > (PAGE_SIZE * SKD_N_SG_PER_SPECIAL)) { 1743 if (sgp->dxfer_len > (PAGE_SIZE * SKD_N_SG_PER_SPECIAL)) {
1726 DPRINTK(skdev, "dxfer_len invalid %d\n", sgp->dxfer_len); 1744 pr_debug("%s:%s:%d dxfer_len invalid %d\n",
1745 skdev->name, __func__, __LINE__, sgp->dxfer_len);
1727 return -EINVAL; 1746 return -EINVAL;
1728 } 1747 }
1729 1748
@@ -1742,18 +1761,21 @@ static int skd_sg_io_get_and_check_args(struct skd_device *skdev,
1742 break; 1761 break;
1743 1762
1744 default: 1763 default:
1745 DPRINTK(skdev, "dxfer_dir invalid %d\n", sgp->dxfer_direction); 1764 pr_debug("%s:%s:%d dxfer_dir invalid %d\n",
1765 skdev->name, __func__, __LINE__, sgp->dxfer_direction);
1746 return -EINVAL; 1766 return -EINVAL;
1747 } 1767 }
1748 1768
1749 if (copy_from_user(sksgio->cdb, sgp->cmdp, sgp->cmd_len)) { 1769 if (copy_from_user(sksgio->cdb, sgp->cmdp, sgp->cmd_len)) {
1750 DPRINTK(skdev, "copy_from_user cmdp failed %p\n", sgp->cmdp); 1770 pr_debug("%s:%s:%d copy_from_user cmdp failed %p\n",
1771 skdev->name, __func__, __LINE__, sgp->cmdp);
1751 return -EFAULT; 1772 return -EFAULT;
1752 } 1773 }
1753 1774
1754 if (sgp->mx_sb_len != 0) { 1775 if (sgp->mx_sb_len != 0) {
1755 if (!access_ok(VERIFY_WRITE, sgp->sbp, sgp->mx_sb_len)) { 1776 if (!access_ok(VERIFY_WRITE, sgp->sbp, sgp->mx_sb_len)) {
1756 DPRINTK(skdev, "access sbp failed %p\n", sgp->sbp); 1777 pr_debug("%s:%s:%d access sbp failed %p\n",
1778 skdev->name, __func__, __LINE__, sgp->sbp);
1757 return -EFAULT; 1779 return -EFAULT;
1758 } 1780 }
1759 } 1781 }
@@ -1770,16 +1792,17 @@ static int skd_sg_io_get_and_check_args(struct skd_device *skdev,
1770 1792
1771 iov = kmalloc(nbytes, GFP_KERNEL); 1793 iov = kmalloc(nbytes, GFP_KERNEL);
1772 if (iov == NULL) { 1794 if (iov == NULL) {
1773 DPRINTK(skdev, "alloc iovec failed %d\n", 1795 pr_debug("%s:%s:%d alloc iovec failed %d\n",
1774 sgp->iovec_count); 1796 skdev->name, __func__, __LINE__,
1797 sgp->iovec_count);
1775 return -ENOMEM; 1798 return -ENOMEM;
1776 } 1799 }
1777 sksgio->iov = iov; 1800 sksgio->iov = iov;
1778 sksgio->iovcnt = sgp->iovec_count; 1801 sksgio->iovcnt = sgp->iovec_count;
1779 1802
1780 if (copy_from_user(iov, sgp->dxferp, nbytes)) { 1803 if (copy_from_user(iov, sgp->dxferp, nbytes)) {
1781 DPRINTK(skdev, "copy_from_user iovec failed %p\n", 1804 pr_debug("%s:%s:%d copy_from_user iovec failed %p\n",
1782 sgp->dxferp); 1805 skdev->name, __func__, __LINE__, sgp->dxferp);
1783 return -EFAULT; 1806 return -EFAULT;
1784 } 1807 }
1785 1808
@@ -1807,8 +1830,9 @@ static int skd_sg_io_get_and_check_args(struct skd_device *skdev,
1807 struct sg_iovec *iov = sksgio->iov; 1830 struct sg_iovec *iov = sksgio->iov;
1808 for (i = 0; i < sksgio->iovcnt; i++, iov++) { 1831 for (i = 0; i < sksgio->iovcnt; i++, iov++) {
1809 if (!access_ok(acc, iov->iov_base, iov->iov_len)) { 1832 if (!access_ok(acc, iov->iov_base, iov->iov_len)) {
1810 DPRINTK(skdev, "access data failed %p/%d\n", 1833 pr_debug("%s:%s:%d access data failed %p/%d\n",
1811 iov->iov_base, (int)iov->iov_len); 1834 skdev->name, __func__, __LINE__,
1835 iov->iov_base, (int)iov->iov_len);
1812 return -EFAULT; 1836 return -EFAULT;
1813 } 1837 }
1814 } 1838 }
@@ -1843,14 +1867,16 @@ static int skd_sg_io_obtain_skspcl(struct skd_device *skdev,
1843 break; 1867 break;
1844 } 1868 }
1845 1869
1846 DPRINTK(skdev, "blocking\n"); 1870 pr_debug("%s:%s:%d blocking\n",
1871 skdev->name, __func__, __LINE__);
1847 1872
1848 rc = wait_event_interruptible_timeout( 1873 rc = wait_event_interruptible_timeout(
1849 skdev->waitq, 1874 skdev->waitq,
1850 (skdev->skspcl_free_list != NULL), 1875 (skdev->skspcl_free_list != NULL),
1851 msecs_to_jiffies(sksgio->sg.timeout)); 1876 msecs_to_jiffies(sksgio->sg.timeout));
1852 1877
1853 DPRINTK(skdev, "unblocking, rc=%d\n", rc); 1878 pr_debug("%s:%s:%d unblocking, rc=%d\n",
1879 skdev->name, __func__, __LINE__, rc);
1854 1880
1855 if (rc <= 0) { 1881 if (rc <= 0) {
1856 if (rc == 0) 1882 if (rc == 0)
@@ -1927,15 +1953,17 @@ static int skd_skreq_prep_buffering(struct skd_device *skdev,
1927 if (unlikely(skdev->dbg_level > 1)) { 1953 if (unlikely(skdev->dbg_level > 1)) {
1928 u32 i; 1954 u32 i;
1929 1955
1930 VPRINTK(skdev, "skreq=%x sksg_list=%p sksg_dma=%llx\n", 1956 pr_debug("%s:%s:%d skreq=%x sksg_list=%p sksg_dma=%llx\n",
1931 skreq->id, skreq->sksg_list, skreq->sksg_dma_address); 1957 skdev->name, __func__, __LINE__,
1958 skreq->id, skreq->sksg_list, skreq->sksg_dma_address);
1932 for (i = 0; i < skreq->n_sg; i++) { 1959 for (i = 0; i < skreq->n_sg; i++) {
1933 struct fit_sg_descriptor *sgd = &skreq->sksg_list[i]; 1960 struct fit_sg_descriptor *sgd = &skreq->sksg_list[i];
1934 1961
1935 VPRINTK(skdev, " sg[%d] count=%u ctrl=0x%x " 1962 pr_debug("%s:%s:%d sg[%d] count=%u ctrl=0x%x "
1936 "addr=0x%llx next=0x%llx\n", 1963 "addr=0x%llx next=0x%llx\n",
1937 i, sgd->byte_count, sgd->control, 1964 skdev->name, __func__, __LINE__,
1938 sgd->host_side_addr, sgd->next_desc_ptr); 1965 i, sgd->byte_count, sgd->control,
1966 sgd->host_side_addr, sgd->next_desc_ptr);
1939 } 1967 }
1940 } 1968 }
1941 1969
@@ -2057,7 +2085,8 @@ static int skd_sg_io_await(struct skd_device *skdev, struct skd_sg_io *sksgio)
2057 spin_lock_irqsave(&skdev->lock, flags); 2085 spin_lock_irqsave(&skdev->lock, flags);
2058 2086
2059 if (sksgio->skspcl->req.state == SKD_REQ_STATE_ABORTED) { 2087 if (sksgio->skspcl->req.state == SKD_REQ_STATE_ABORTED) {
2060 DPRINTK(skdev, "skspcl %p aborted\n", sksgio->skspcl); 2088 pr_debug("%s:%s:%d skspcl %p aborted\n",
2089 skdev->name, __func__, __LINE__, sksgio->skspcl);
2061 2090
2062 /* Build check cond, sense and let command finish. */ 2091 /* Build check cond, sense and let command finish. */
2063 /* For a timeout, we must fabricate completion and sense 2092 /* For a timeout, we must fabricate completion and sense
@@ -2082,11 +2111,13 @@ static int skd_sg_io_await(struct skd_device *skdev, struct skd_sg_io *sksgio)
2082 sksgio->skspcl->orphaned = 1; 2111 sksgio->skspcl->orphaned = 1;
2083 sksgio->skspcl = NULL; 2112 sksgio->skspcl = NULL;
2084 if (rc == 0) { 2113 if (rc == 0) {
2085 DPRINTK(skdev, "timed out %p (%u ms)\n", sksgio, 2114 pr_debug("%s:%s:%d timed out %p (%u ms)\n",
2086 sksgio->sg.timeout); 2115 skdev->name, __func__, __LINE__,
2116 sksgio, sksgio->sg.timeout);
2087 rc = -ETIMEDOUT; 2117 rc = -ETIMEDOUT;
2088 } else { 2118 } else {
2089 DPRINTK(skdev, "cntlc %p\n", sksgio); 2119 pr_debug("%s:%s:%d cntlc %p\n",
2120 skdev->name, __func__, __LINE__, sksgio);
2090 rc = -EINTR; 2121 rc = -EINTR;
2091 } 2122 }
2092 } 2123 }
@@ -2116,8 +2147,9 @@ static int skd_sg_io_put_status(struct skd_device *skdev,
2116 if (sgp->masked_status || sgp->host_status || sgp->driver_status) 2147 if (sgp->masked_status || sgp->host_status || sgp->driver_status)
2117 sgp->info |= SG_INFO_CHECK; 2148 sgp->info |= SG_INFO_CHECK;
2118 2149
2119 DPRINTK(skdev, "status %x masked %x resid 0x%x\n", sgp->status, 2150 pr_debug("%s:%s:%d status %x masked %x resid 0x%x\n",
2120 sgp->masked_status, sgp->resid); 2151 skdev->name, __func__, __LINE__,
2152 sgp->status, sgp->masked_status, sgp->resid);
2121 2153
2122 if (sgp->masked_status == SAM_STAT_CHECK_CONDITION) { 2154 if (sgp->masked_status == SAM_STAT_CHECK_CONDITION) {
2123 if (sgp->mx_sb_len > 0) { 2155 if (sgp->mx_sb_len > 0) {
@@ -2129,15 +2161,17 @@ static int skd_sg_io_put_status(struct skd_device *skdev,
2129 sgp->sb_len_wr = nbytes; 2161 sgp->sb_len_wr = nbytes;
2130 2162
2131 if (__copy_to_user(sgp->sbp, ei, nbytes)) { 2163 if (__copy_to_user(sgp->sbp, ei, nbytes)) {
2132 DPRINTK(skdev, "copy_to_user sense failed %p\n", 2164 pr_debug("%s:%s:%d copy_to_user sense failed %p\n",
2133 sgp->sbp); 2165 skdev->name, __func__, __LINE__,
2166 sgp->sbp);
2134 return -EFAULT; 2167 return -EFAULT;
2135 } 2168 }
2136 } 2169 }
2137 } 2170 }
2138 2171
2139 if (__copy_to_user(sksgio->argp, sgp, sizeof(sg_io_hdr_t))) { 2172 if (__copy_to_user(sksgio->argp, sgp, sizeof(sg_io_hdr_t))) {
2140 DPRINTK(skdev, "copy_to_user sg failed %p\n", sksgio->argp); 2173 pr_debug("%s:%s:%d copy_to_user sg failed %p\n",
2174 skdev->name, __func__, __LINE__, sksgio->argp);
2141 return -EFAULT; 2175 return -EFAULT;
2142 } 2176 }
2143 2177
@@ -2325,7 +2359,8 @@ static void skd_complete_internal(struct skd_device *skdev,
2325 2359
2326 SKD_ASSERT(skspcl == &skdev->internal_skspcl); 2360 SKD_ASSERT(skspcl == &skdev->internal_skspcl);
2327 2361
2328 DPRINTK(skdev, "complete internal %x\n", scsi->cdb[0]); 2362 pr_debug("%s:%s:%d complete internal %x\n",
2363 skdev->name, __func__, __LINE__, scsi->cdb[0]);
2329 2364
2330 skspcl->req.completion = *skcomp; 2365 skspcl->req.completion = *skcomp;
2331 skspcl->req.state = SKD_REQ_STATE_IDLE; 2366 skspcl->req.state = SKD_REQ_STATE_IDLE;
@@ -2345,11 +2380,13 @@ static void skd_complete_internal(struct skd_device *skdev,
2345 skd_send_internal_skspcl(skdev, skspcl, WRITE_BUFFER); 2380 skd_send_internal_skspcl(skdev, skspcl, WRITE_BUFFER);
2346 else { 2381 else {
2347 if (skdev->state == SKD_DRVR_STATE_STOPPING) { 2382 if (skdev->state == SKD_DRVR_STATE_STOPPING) {
2348 VPRINTK(skdev, "TUR failed, don't send anymore" 2383 pr_debug("%s:%s:%d TUR failed, don't send anymore state 0x%x\n",
2349 "state 0x%x\n", skdev->state); 2384 skdev->name, __func__, __LINE__,
2385 skdev->state);
2350 return; 2386 return;
2351 } 2387 }
2352 DPRINTK(skdev, "**** TUR failed, retry skerr\n"); 2388 pr_debug("%s:%s:%d **** TUR failed, retry skerr\n",
2389 skdev->name, __func__, __LINE__);
2353 skd_send_internal_skspcl(skdev, skspcl, 0x00); 2390 skd_send_internal_skspcl(skdev, skspcl, 0x00);
2354 } 2391 }
2355 break; 2392 break;
@@ -2359,12 +2396,13 @@ static void skd_complete_internal(struct skd_device *skdev,
2359 skd_send_internal_skspcl(skdev, skspcl, READ_BUFFER); 2396 skd_send_internal_skspcl(skdev, skspcl, READ_BUFFER);
2360 else { 2397 else {
2361 if (skdev->state == SKD_DRVR_STATE_STOPPING) { 2398 if (skdev->state == SKD_DRVR_STATE_STOPPING) {
2362 VPRINTK(skdev, "write buffer failed, don't send" 2399 pr_debug("%s:%s:%d write buffer failed, don't send anymore state 0x%x\n",
2363 " anymore state 0x%x\n", skdev->state); 2400 skdev->name, __func__, __LINE__,
2401 skdev->state);
2364 return; 2402 return;
2365 } 2403 }
2366 DPRINTK(skdev, 2404 pr_debug("%s:%s:%d **** write buffer failed, retry skerr\n",
2367 "**** write buffer failed, retry skerr\n"); 2405 skdev->name, __func__, __LINE__);
2368 skd_send_internal_skspcl(skdev, skspcl, 0x00); 2406 skd_send_internal_skspcl(skdev, skspcl, 0x00);
2369 } 2407 }
2370 break; 2408 break;
@@ -2392,13 +2430,15 @@ static void skd_complete_internal(struct skd_device *skdev,
2392 2430
2393 } else { 2431 } else {
2394 if (skdev->state == SKD_DRVR_STATE_STOPPING) { 2432 if (skdev->state == SKD_DRVR_STATE_STOPPING) {
2395 VPRINTK(skdev, 2433 pr_debug("%s:%s:%d "
2396 "read buffer failed, don't send anymore" 2434 "read buffer failed, don't send anymore state 0x%x\n",
2397 "state 0x%x\n", skdev->state); 2435 skdev->name, __func__, __LINE__,
2436 skdev->state);
2398 return; 2437 return;
2399 } 2438 }
2400 DPRINTK(skdev, 2439 pr_debug("%s:%s:%d "
2401 "**** read buffer failed, retry skerr\n"); 2440 "**** read buffer failed, retry skerr\n",
2441 skdev->name, __func__, __LINE__);
2402 skd_send_internal_skspcl(skdev, skspcl, 0x00); 2442 skd_send_internal_skspcl(skdev, skspcl, 0x00);
2403 } 2443 }
2404 break; 2444 break;
@@ -2413,9 +2453,10 @@ static void skd_complete_internal(struct skd_device *skdev,
2413 (buf[4] << 24) | (buf[5] << 16) | 2453 (buf[4] << 24) | (buf[5] << 16) |
2414 (buf[6] << 8) | buf[7]; 2454 (buf[6] << 8) | buf[7];
2415 2455
2416 DPRINTK(skdev, "last lba %d, bs %d\n", 2456 pr_debug("%s:%s:%d last lba %d, bs %d\n",
2417 skdev->read_cap_last_lba, 2457 skdev->name, __func__, __LINE__,
2418 skdev->read_cap_blocksize); 2458 skdev->read_cap_last_lba,
2459 skdev->read_cap_blocksize);
2419 2460
2420 set_capacity(skdev->disk, skdev->read_cap_last_lba + 1); 2461 set_capacity(skdev->disk, skdev->read_cap_last_lba + 1);
2421 2462
@@ -2426,11 +2467,13 @@ static void skd_complete_internal(struct skd_device *skdev,
2426 (skerr->key == MEDIUM_ERROR)) { 2467 (skerr->key == MEDIUM_ERROR)) {
2427 skdev->read_cap_last_lba = ~0; 2468 skdev->read_cap_last_lba = ~0;
2428 set_capacity(skdev->disk, skdev->read_cap_last_lba + 1); 2469 set_capacity(skdev->disk, skdev->read_cap_last_lba + 1);
2429 DPRINTK(skdev, 2470 pr_debug("%s:%s:%d "
2430 "**** MEDIUM ERROR caused READCAP to fail, ignore failure and continue to inquiry\n"); 2471 "**** MEDIUM ERROR caused READCAP to fail, ignore failure and continue to inquiry\n",
2472 skdev->name, __func__, __LINE__);
2431 skd_send_internal_skspcl(skdev, skspcl, INQUIRY); 2473 skd_send_internal_skspcl(skdev, skspcl, INQUIRY);
2432 } else { 2474 } else {
2433 DPRINTK(skdev, "**** READCAP failed, retry TUR\n"); 2475 pr_debug("%s:%s:%d **** READCAP failed, retry TUR\n",
2476 skdev->name, __func__, __LINE__);
2434 skd_send_internal_skspcl(skdev, skspcl, 2477 skd_send_internal_skspcl(skdev, skspcl,
2435 TEST_UNIT_READY); 2478 TEST_UNIT_READY);
2436 } 2479 }
@@ -2447,7 +2490,8 @@ static void skd_complete_internal(struct skd_device *skdev,
2447 } 2490 }
2448 2491
2449 if (skd_unquiesce_dev(skdev) < 0) 2492 if (skd_unquiesce_dev(skdev) < 0)
2450 DPRINTK(skdev, "**** failed, to ONLINE device\n"); 2493 pr_debug("%s:%s:%d **** failed, to ONLINE device\n",
2494 skdev->name, __func__, __LINE__);
2451 /* connection is complete */ 2495 /* connection is complete */
2452 skdev->connect_retries = 0; 2496 skdev->connect_retries = 0;
2453 break; 2497 break;
@@ -2477,10 +2521,12 @@ static void skd_send_fitmsg(struct skd_device *skdev,
2477 u64 qcmd; 2521 u64 qcmd;
2478 struct fit_msg_hdr *fmh; 2522 struct fit_msg_hdr *fmh;
2479 2523
2480 VPRINTK(skdev, "dma address 0x%llx, busy=%d\n", 2524 pr_debug("%s:%s:%d dma address 0x%llx, busy=%d\n",
2481 skmsg->mb_dma_address, skdev->in_flight); 2525 skdev->name, __func__, __LINE__,
2482 VPRINTK(skdev, "msg_buf 0x%p, offset %x\n", 2526 skmsg->mb_dma_address, skdev->in_flight);
2483 skmsg->msg_buf, skmsg->offset); 2527 pr_debug("%s:%s:%d msg_buf 0x%p, offset %x\n",
2528 skdev->name, __func__, __LINE__,
2529 skmsg->msg_buf, skmsg->offset);
2484 2530
2485 qcmd = skmsg->mb_dma_address; 2531 qcmd = skmsg->mb_dma_address;
2486 qcmd |= FIT_QCMD_QID_NORMAL; 2532 qcmd |= FIT_QCMD_QID_NORMAL;
@@ -2492,11 +2538,12 @@ static void skd_send_fitmsg(struct skd_device *skdev,
2492 u8 *bp = (u8 *)skmsg->msg_buf; 2538 u8 *bp = (u8 *)skmsg->msg_buf;
2493 int i; 2539 int i;
2494 for (i = 0; i < skmsg->length; i += 8) { 2540 for (i = 0; i < skmsg->length; i += 8) {
2495 VPRINTK(skdev, " msg[%2d] %02x %02x %02x %02x " 2541 pr_debug("%s:%s:%d msg[%2d] %02x %02x %02x %02x "
2496 "%02x %02x %02x %02x\n", 2542 "%02x %02x %02x %02x\n",
2497 i, bp[i + 0], bp[i + 1], bp[i + 2], 2543 skdev->name, __func__, __LINE__,
2498 bp[i + 3], bp[i + 4], bp[i + 5], 2544 i, bp[i + 0], bp[i + 1], bp[i + 2],
2499 bp[i + 6], bp[i + 7]); 2545 bp[i + 3], bp[i + 4], bp[i + 5],
2546 bp[i + 6], bp[i + 7]);
2500 if (i == 0) 2547 if (i == 0)
2501 i = 64 - 8; 2548 i = 64 - 8;
2502 } 2549 }
@@ -2530,26 +2577,28 @@ static void skd_send_special_fitmsg(struct skd_device *skdev,
2530 int i; 2577 int i;
2531 2578
2532 for (i = 0; i < SKD_N_SPECIAL_FITMSG_BYTES; i += 8) { 2579 for (i = 0; i < SKD_N_SPECIAL_FITMSG_BYTES; i += 8) {
2533 VPRINTK(skdev, 2580 pr_debug("%s:%s:%d spcl[%2d] %02x %02x %02x %02x "
2534 " spcl[%2d] %02x %02x %02x %02x " 2581 "%02x %02x %02x %02x\n",
2535 "%02x %02x %02x %02x\n", i, 2582 skdev->name, __func__, __LINE__, i,
2536 bp[i + 0], bp[i + 1], bp[i + 2], bp[i + 3], 2583 bp[i + 0], bp[i + 1], bp[i + 2], bp[i + 3],
2537 bp[i + 4], bp[i + 5], bp[i + 6], bp[i + 7]); 2584 bp[i + 4], bp[i + 5], bp[i + 6], bp[i + 7]);
2538 if (i == 0) 2585 if (i == 0)
2539 i = 64 - 8; 2586 i = 64 - 8;
2540 } 2587 }
2541 2588
2542 VPRINTK(skdev, "skspcl=%p id=%04x sksg_list=%p sksg_dma=%llx\n", 2589 pr_debug("%s:%s:%d skspcl=%p id=%04x sksg_list=%p sksg_dma=%llx\n",
2543 skspcl, skspcl->req.id, skspcl->req.sksg_list, 2590 skdev->name, __func__, __LINE__,
2544 skspcl->req.sksg_dma_address); 2591 skspcl, skspcl->req.id, skspcl->req.sksg_list,
2592 skspcl->req.sksg_dma_address);
2545 for (i = 0; i < skspcl->req.n_sg; i++) { 2593 for (i = 0; i < skspcl->req.n_sg; i++) {
2546 struct fit_sg_descriptor *sgd = 2594 struct fit_sg_descriptor *sgd =
2547 &skspcl->req.sksg_list[i]; 2595 &skspcl->req.sksg_list[i];
2548 2596
2549 VPRINTK(skdev, " sg[%d] count=%u ctrl=0x%x " 2597 pr_debug("%s:%s:%d sg[%d] count=%u ctrl=0x%x "
2550 "addr=0x%llx next=0x%llx\n", 2598 "addr=0x%llx next=0x%llx\n",
2551 i, sgd->byte_count, sgd->control, 2599 skdev->name, __func__, __LINE__,
2552 sgd->host_side_addr, sgd->next_desc_ptr); 2600 i, sgd->byte_count, sgd->control,
2601 sgd->host_side_addr, sgd->next_desc_ptr);
2553 } 2602 }
2554 } 2603 }
2555 2604
@@ -2632,9 +2681,9 @@ static enum skd_check_status_action skd_check_status(struct skd_device *skdev,
2632 skd_name(skdev), skerr->key, skerr->code, skerr->qual, 2681 skd_name(skdev), skerr->key, skerr->code, skerr->qual,
2633 skerr->fruc); 2682 skerr->fruc);
2634 2683
2635 VPRINTK(skdev, "stat: t=%02x stat=%02x k=%02x c=%02x q=%02x " 2684 pr_debug("%s:%s:%d stat: t=%02x stat=%02x k=%02x c=%02x q=%02x fruc=%02x\n",
2636 "fruc=%02x\n", skerr->type, cmp_status, skerr->key, 2685 skdev->name, __func__, __LINE__, skerr->type, cmp_status,
2637 skerr->code, skerr->qual, skerr->fruc); 2686 skerr->key, skerr->code, skerr->qual, skerr->fruc);
2638 2687
2639 /* Does the info match an entry in the good category? */ 2688 /* Does the info match an entry in the good category? */
2640 n = sizeof(skd_chkstat_table) / sizeof(skd_chkstat_table[0]); 2689 n = sizeof(skd_chkstat_table) / sizeof(skd_chkstat_table[0]);
@@ -2674,11 +2723,13 @@ static enum skd_check_status_action skd_check_status(struct skd_device *skdev,
2674 * zero status means good 2723 * zero status means good
2675 */ 2724 */
2676 if (cmp_status) { 2725 if (cmp_status) {
2677 DPRINTK(skdev, "status check: error\n"); 2726 pr_debug("%s:%s:%d status check: error\n",
2727 skdev->name, __func__, __LINE__);
2678 return SKD_CHECK_STATUS_REPORT_ERROR; 2728 return SKD_CHECK_STATUS_REPORT_ERROR;
2679 } 2729 }
2680 2730
2681 DPRINTK(skdev, "status check good default\n"); 2731 pr_debug("%s:%s:%d status check good default\n",
2732 skdev->name, __func__, __LINE__);
2682 return SKD_CHECK_STATUS_REPORT_GOOD; 2733 return SKD_CHECK_STATUS_REPORT_GOOD;
2683} 2734}
2684 2735
@@ -2816,7 +2867,8 @@ static void skd_do_inq_page_00(struct skd_device *skdev,
2816 /* Caller requested "supported pages". The driver needs to insert 2867 /* Caller requested "supported pages". The driver needs to insert
2817 * its page. 2868 * its page.
2818 */ 2869 */
2819 VPRINTK(skdev, "skd_do_driver_inquiry: modify supported pages.\n"); 2870 pr_debug("%s:%s:%d skd_do_driver_inquiry: modify supported pages.\n",
2871 skdev->name, __func__, __LINE__);
2820 2872
2821 /* If the device rejected the request because the CDB was 2873 /* If the device rejected the request because the CDB was
2822 * improperly formed, then just leave. 2874 * improperly formed, then just leave.
@@ -2913,7 +2965,8 @@ static void skd_do_inq_page_da(struct skd_device *skdev,
2913 struct driver_inquiry_data inq; 2965 struct driver_inquiry_data inq;
2914 u16 val; 2966 u16 val;
2915 2967
2916 VPRINTK(skdev, "skd_do_driver_inquiry: return driver page\n"); 2968 pr_debug("%s:%s:%d skd_do_driver_inquiry: return driver page\n",
2969 skdev->name, __func__, __LINE__);
2917 2970
2918 memset(&inq, 0, sizeof(inq)); 2971 memset(&inq, 0, sizeof(inq));
2919 2972
@@ -3045,14 +3098,16 @@ static int skd_isr_completion_posted(struct skd_device *skdev,
3045 3098
3046 skerr = &skdev->skerr_table[skdev->skcomp_ix]; 3099 skerr = &skdev->skerr_table[skdev->skcomp_ix];
3047 3100
3048 VPRINTK(skdev, 3101 pr_debug("%s:%s:%d "
3049 "cycle=%d ix=%d got cycle=%d cmdctxt=0x%x stat=%d " 3102 "cycle=%d ix=%d got cycle=%d cmdctxt=0x%x stat=%d "
3050 "busy=%d rbytes=0x%x proto=%d\n", skdev->skcomp_cycle, 3103 "busy=%d rbytes=0x%x proto=%d\n",
3051 skdev->skcomp_ix, cmp_cycle, cmp_cntxt, cmp_status, 3104 skdev->name, __func__, __LINE__, skdev->skcomp_cycle,
3052 skdev->in_flight, cmp_bytes, skdev->proto_ver); 3105 skdev->skcomp_ix, cmp_cycle, cmp_cntxt, cmp_status,
3106 skdev->in_flight, cmp_bytes, skdev->proto_ver);
3053 3107
3054 if (cmp_cycle != skdev->skcomp_cycle) { 3108 if (cmp_cycle != skdev->skcomp_cycle) {
3055 VPRINTK(skdev, "end of completions\n"); 3109 pr_debug("%s:%s:%d end of completions\n",
3110 skdev->name, __func__, __LINE__);
3056 break; 3111 break;
3057 } 3112 }
3058 /* 3113 /*
@@ -3088,8 +3143,9 @@ static int skd_isr_completion_posted(struct skd_device *skdev,
3088 * Make sure the request ID for the slot matches. 3143 * Make sure the request ID for the slot matches.
3089 */ 3144 */
3090 if (skreq->id != req_id) { 3145 if (skreq->id != req_id) {
3091 DPRINTK(skdev, "mismatch comp_id=0x%x req_id=0x%x\n", 3146 pr_debug("%s:%s:%d mismatch comp_id=0x%x req_id=0x%x\n",
3092 req_id, skreq->id); 3147 skdev->name, __func__, __LINE__,
3148 req_id, skreq->id);
3093 { 3149 {
3094 u16 new_id = cmp_cntxt; 3150 u16 new_id = cmp_cntxt;
3095 pr_err("(%s): Completion mismatch " 3151 pr_err("(%s): Completion mismatch "
@@ -3104,8 +3160,9 @@ static int skd_isr_completion_posted(struct skd_device *skdev,
3104 SKD_ASSERT(skreq->state == SKD_REQ_STATE_BUSY); 3160 SKD_ASSERT(skreq->state == SKD_REQ_STATE_BUSY);
3105 3161
3106 if (skreq->state == SKD_REQ_STATE_ABORTED) { 3162 if (skreq->state == SKD_REQ_STATE_ABORTED) {
3107 DPRINTK(skdev, "reclaim req %p id=%04x\n", 3163 pr_debug("%s:%s:%d reclaim req %p id=%04x\n",
3108 skreq, skreq->id); 3164 skdev->name, __func__, __LINE__,
3165 skreq, skreq->id);
3109 /* a previously timed out command can 3166 /* a previously timed out command can
3110 * now be cleaned up */ 3167 * now be cleaned up */
3111 skd_release_skreq(skdev, skreq); 3168 skd_release_skreq(skdev, skreq);
@@ -3125,9 +3182,10 @@ static int skd_isr_completion_posted(struct skd_device *skdev,
3125 3182
3126 if (((!skd_bio) && !skreq->req) || 3183 if (((!skd_bio) && !skreq->req) ||
3127 ((skd_bio) && !skreq->bio)) { 3184 ((skd_bio) && !skreq->bio)) {
3128 DPRINTK(skdev, "NULL backptr skdreq %p, " 3185 pr_debug("%s:%s:%d NULL backptr skdreq %p, "
3129 "req=0x%x req_id=0x%x\n", 3186 "req=0x%x req_id=0x%x\n",
3130 skreq, skreq->id, req_id); 3187 skdev->name, __func__, __LINE__,
3188 skreq, skreq->id, req_id);
3131 } else { 3189 } else {
3132 /* 3190 /*
3133 * Capture the outcome and post it back to the 3191 * Capture the outcome and post it back to the
@@ -3196,8 +3254,9 @@ static void skd_complete_other(struct skd_device *skdev,
3196 req_table = req_id & SKD_ID_TABLE_MASK; 3254 req_table = req_id & SKD_ID_TABLE_MASK;
3197 req_slot = req_id & SKD_ID_SLOT_MASK; 3255 req_slot = req_id & SKD_ID_SLOT_MASK;
3198 3256
3199 DPRINTK(skdev, "table=0x%x id=0x%x slot=%d\n", req_table, req_id, 3257 pr_debug("%s:%s:%d table=0x%x id=0x%x slot=%d\n",
3200 req_slot); 3258 skdev->name, __func__, __LINE__,
3259 req_table, req_id, req_slot);
3201 3260
3202 /* 3261 /*
3203 * Based on the request id, determine how to dispatch this completion. 3262 * Based on the request id, determine how to dispatch this completion.
@@ -3265,12 +3324,14 @@ static void skd_complete_special(struct skd_device *skdev,
3265 volatile struct fit_comp_error_info *skerr, 3324 volatile struct fit_comp_error_info *skerr,
3266 struct skd_special_context *skspcl) 3325 struct skd_special_context *skspcl)
3267{ 3326{
3268 DPRINTK(skdev, " completing special request %p\n", skspcl); 3327 pr_debug("%s:%s:%d completing special request %p\n",
3328 skdev->name, __func__, __LINE__, skspcl);
3269 if (skspcl->orphaned) { 3329 if (skspcl->orphaned) {
3270 /* Discard orphaned request */ 3330 /* Discard orphaned request */
3271 /* ?: Can this release directly or does it need 3331 /* ?: Can this release directly or does it need
3272 * to use a worker? */ 3332 * to use a worker? */
3273 DPRINTK(skdev, "release orphaned %p\n", skspcl); 3333 pr_debug("%s:%s:%d release orphaned %p\n",
3334 skdev->name, __func__, __LINE__, skspcl);
3274 skd_release_special(skdev, skspcl); 3335 skd_release_special(skdev, skspcl);
3275 return; 3336 return;
3276 } 3337 }
@@ -3308,7 +3369,8 @@ static void skd_release_special(struct skd_device *skdev,
3308 skdev->skspcl_free_list = (struct skd_special_context *)skspcl; 3369 skdev->skspcl_free_list = (struct skd_special_context *)skspcl;
3309 3370
3310 if (was_depleted) { 3371 if (was_depleted) {
3311 DPRINTK(skdev, "skspcl was depleted\n"); 3372 pr_debug("%s:%s:%d skspcl was depleted\n",
3373 skdev->name, __func__, __LINE__);
3312 /* Free list was depleted. Their might be waiters. */ 3374 /* Free list was depleted. Their might be waiters. */
3313 wake_up_interruptible(&skdev->waitq); 3375 wake_up_interruptible(&skdev->waitq);
3314 } 3376 }
@@ -3373,7 +3435,8 @@ static skd_isr(int irq, void *ptr)
3373 ack = FIT_INT_DEF_MASK; 3435 ack = FIT_INT_DEF_MASK;
3374 ack &= intstat; 3436 ack &= intstat;
3375 3437
3376 VPRINTK(skdev, "intstat=0x%x ack=0x%x\n", intstat, ack); 3438 pr_debug("%s:%s:%d intstat=0x%x ack=0x%x\n",
3439 skdev->name, __func__, __LINE__, intstat, ack);
3377 3440
3378 /* As long as there is an int pending on device, keep 3441 /* As long as there is an int pending on device, keep
3379 * running loop. When none, get out, but if we've never 3442 * running loop. When none, get out, but if we've never
@@ -3534,7 +3597,8 @@ static void skd_isr_fwstate(struct skd_device *skdev)
3534 } 3597 }
3535 break; 3598 break;
3536 case FIT_SR_DRIVE_FW_BOOTING: 3599 case FIT_SR_DRIVE_FW_BOOTING:
3537 VPRINTK(skdev, "ISR FIT_SR_DRIVE_FW_BOOTING %s\n", skdev->name); 3600 pr_debug("%s:%s:%d ISR FIT_SR_DRIVE_FW_BOOTING %s\n",
3601 skdev->name, __func__, __LINE__, skdev->name);
3538 skdev->state = SKD_DRVR_STATE_WAIT_BOOT; 3602 skdev->state = SKD_DRVR_STATE_WAIT_BOOT;
3539 skdev->timer_countdown = SKD_WAIT_BOOT_TIMO; 3603 skdev->timer_countdown = SKD_WAIT_BOOT_TIMO;
3540 break; 3604 break;
@@ -3643,10 +3707,14 @@ static void skd_recover_requests(struct skd_device *skdev, int requeue)
3643 */ 3707 */
3644 if (skspcl->req.state == SKD_REQ_STATE_BUSY) { 3708 if (skspcl->req.state == SKD_REQ_STATE_BUSY) {
3645 if (skspcl->orphaned) { 3709 if (skspcl->orphaned) {
3646 DPRINTK(skdev, "orphaned %p\n", skspcl); 3710 pr_debug("%s:%s:%d orphaned %p\n",
3711 skdev->name, __func__, __LINE__,
3712 skspcl);
3647 skd_release_special(skdev, skspcl); 3713 skd_release_special(skdev, skspcl);
3648 } else { 3714 } else {
3649 DPRINTK(skdev, "not orphaned %p\n", skspcl); 3715 pr_debug("%s:%s:%d not orphaned %p\n",
3716 skdev->name, __func__, __LINE__,
3717 skspcl);
3650 skspcl->req.state = SKD_REQ_STATE_ABORTED; 3718 skspcl->req.state = SKD_REQ_STATE_ABORTED;
3651 } 3719 }
3652 } 3720 }
@@ -3667,7 +3735,8 @@ static void skd_isr_msg_from_dev(struct skd_device *skdev)
3667 3735
3668 mfd = SKD_READL(skdev, FIT_MSG_FROM_DEVICE); 3736 mfd = SKD_READL(skdev, FIT_MSG_FROM_DEVICE);
3669 3737
3670 DPRINTK(skdev, "mfd=0x%x last_mtd=0x%x\n", mfd, skdev->last_mtd); 3738 pr_debug("%s:%s:%d mfd=0x%x last_mtd=0x%x\n",
3739 skdev->name, __func__, __LINE__, mfd, skdev->last_mtd);
3671 3740
3672 /* ignore any mtd that is an ack for something we didn't send */ 3741 /* ignore any mtd that is an ack for something we didn't send */
3673 if (FIT_MXD_TYPE(mfd) != FIT_MXD_TYPE(skdev->last_mtd)) 3742 if (FIT_MXD_TYPE(mfd) != FIT_MXD_TYPE(skdev->last_mtd))
@@ -3762,7 +3831,8 @@ static void skd_disable_interrupts(struct skd_device *skdev)
3762 sense = SKD_READL(skdev, FIT_CONTROL); 3831 sense = SKD_READL(skdev, FIT_CONTROL);
3763 sense &= ~FIT_CR_ENABLE_INTERRUPTS; 3832 sense &= ~FIT_CR_ENABLE_INTERRUPTS;
3764 SKD_WRITEL(skdev, sense, FIT_CONTROL); 3833 SKD_WRITEL(skdev, sense, FIT_CONTROL);
3765 DPRINTK(skdev, "sense 0x%x\n", sense); 3834 pr_debug("%s:%s:%d sense 0x%x\n",
3835 skdev->name, __func__, __LINE__, sense);
3766 3836
3767 /* Note that the 1s is written. A 1-bit means 3837 /* Note that the 1s is written. A 1-bit means
3768 * disable, a 0 means enable. 3838 * disable, a 0 means enable.
@@ -3781,11 +3851,13 @@ static void skd_enable_interrupts(struct skd_device *skdev)
3781 /* Note that the compliment of mask is written. A 1-bit means 3851 /* Note that the compliment of mask is written. A 1-bit means
3782 * disable, a 0 means enable. */ 3852 * disable, a 0 means enable. */
3783 SKD_WRITEL(skdev, ~val, FIT_INT_MASK_HOST); 3853 SKD_WRITEL(skdev, ~val, FIT_INT_MASK_HOST);
3784 DPRINTK(skdev, "interrupt mask=0x%x\n", ~val); 3854 pr_debug("%s:%s:%d interrupt mask=0x%x\n",
3855 skdev->name, __func__, __LINE__, ~val);
3785 3856
3786 val = SKD_READL(skdev, FIT_CONTROL); 3857 val = SKD_READL(skdev, FIT_CONTROL);
3787 val |= FIT_CR_ENABLE_INTERRUPTS; 3858 val |= FIT_CR_ENABLE_INTERRUPTS;
3788 DPRINTK(skdev, "control=0x%x\n", val); 3859 pr_debug("%s:%s:%d control=0x%x\n",
3860 skdev->name, __func__, __LINE__, val);
3789 SKD_WRITEL(skdev, val, FIT_CONTROL); 3861 SKD_WRITEL(skdev, val, FIT_CONTROL);
3790} 3862}
3791 3863
@@ -3801,7 +3873,8 @@ static void skd_soft_reset(struct skd_device *skdev)
3801 3873
3802 val = SKD_READL(skdev, FIT_CONTROL); 3874 val = SKD_READL(skdev, FIT_CONTROL);
3803 val |= (FIT_CR_SOFT_RESET); 3875 val |= (FIT_CR_SOFT_RESET);
3804 DPRINTK(skdev, "control=0x%x\n", val); 3876 pr_debug("%s:%s:%d control=0x%x\n",
3877 skdev->name, __func__, __LINE__, val);
3805 SKD_WRITEL(skdev, val, FIT_CONTROL); 3878 SKD_WRITEL(skdev, val, FIT_CONTROL);
3806} 3879}
3807 3880
@@ -3818,7 +3891,8 @@ static void skd_start_device(struct skd_device *skdev)
3818 3891
3819 sense = SKD_READL(skdev, FIT_STATUS); 3892 sense = SKD_READL(skdev, FIT_STATUS);
3820 3893
3821 DPRINTK(skdev, "initial status=0x%x\n", sense); 3894 pr_debug("%s:%s:%d initial status=0x%x\n",
3895 skdev->name, __func__, __LINE__, sense);
3822 3896
3823 state = sense & FIT_SR_DRIVE_STATE_MASK; 3897 state = sense & FIT_SR_DRIVE_STATE_MASK;
3824 skdev->drive_state = state; 3898 skdev->drive_state = state;
@@ -3835,7 +3909,8 @@ static void skd_start_device(struct skd_device *skdev)
3835 break; 3909 break;
3836 3910
3837 case FIT_SR_DRIVE_FW_BOOTING: 3911 case FIT_SR_DRIVE_FW_BOOTING:
3838 VPRINTK(skdev, "FIT_SR_DRIVE_FW_BOOTING %s\n", skdev->name); 3912 pr_debug("%s:%s:%d FIT_SR_DRIVE_FW_BOOTING %s\n",
3913 skdev->name, __func__, __LINE__, skdev->name);
3839 skdev->state = SKD_DRVR_STATE_WAIT_BOOT; 3914 skdev->state = SKD_DRVR_STATE_WAIT_BOOT;
3840 skdev->timer_countdown = SKD_WAIT_BOOT_TIMO; 3915 skdev->timer_countdown = SKD_WAIT_BOOT_TIMO;
3841 break; 3916 break;
@@ -3876,7 +3951,8 @@ static void skd_start_device(struct skd_device *skdev)
3876 */ 3951 */
3877 skd_drive_fault(skdev); 3952 skd_drive_fault(skdev);
3878 /*start the queue so we can respond with error to requests */ 3953 /*start the queue so we can respond with error to requests */
3879 VPRINTK(skdev, "starting %s queue\n", skdev->name); 3954 pr_debug("%s:%s:%d starting %s queue\n",
3955 skdev->name, __func__, __LINE__, skdev->name);
3880 skd_start_queue(skdev); 3956 skd_start_queue(skdev);
3881 skdev->gendisk_on = -1; 3957 skdev->gendisk_on = -1;
3882 wake_up_interruptible(&skdev->waitq); 3958 wake_up_interruptible(&skdev->waitq);
@@ -3887,8 +3963,8 @@ static void skd_start_device(struct skd_device *skdev)
3887 * to the BAR1 addresses. */ 3963 * to the BAR1 addresses. */
3888 skd_drive_disappeared(skdev); 3964 skd_drive_disappeared(skdev);
3889 /*start the queue so we can respond with error to requests */ 3965 /*start the queue so we can respond with error to requests */
3890 VPRINTK(skdev, "starting %s queue to error-out reqs\n", 3966 pr_debug("%s:%s:%d starting %s queue to error-out reqs\n",
3891 skdev->name); 3967 skdev->name, __func__, __LINE__, skdev->name);
3892 skd_start_queue(skdev); 3968 skd_start_queue(skdev);
3893 skdev->gendisk_on = -1; 3969 skdev->gendisk_on = -1;
3894 wake_up_interruptible(&skdev->waitq); 3970 wake_up_interruptible(&skdev->waitq);
@@ -3901,19 +3977,24 @@ static void skd_start_device(struct skd_device *skdev)
3901 } 3977 }
3902 3978
3903 state = SKD_READL(skdev, FIT_CONTROL); 3979 state = SKD_READL(skdev, FIT_CONTROL);
3904 DPRINTK(skdev, "FIT Control Status=0x%x\n", state); 3980 pr_debug("%s:%s:%d FIT Control Status=0x%x\n",
3981 skdev->name, __func__, __LINE__, state);
3905 3982
3906 state = SKD_READL(skdev, FIT_INT_STATUS_HOST); 3983 state = SKD_READL(skdev, FIT_INT_STATUS_HOST);
3907 DPRINTK(skdev, "Intr Status=0x%x\n", state); 3984 pr_debug("%s:%s:%d Intr Status=0x%x\n",
3985 skdev->name, __func__, __LINE__, state);
3908 3986
3909 state = SKD_READL(skdev, FIT_INT_MASK_HOST); 3987 state = SKD_READL(skdev, FIT_INT_MASK_HOST);
3910 DPRINTK(skdev, "Intr Mask=0x%x\n", state); 3988 pr_debug("%s:%s:%d Intr Mask=0x%x\n",
3989 skdev->name, __func__, __LINE__, state);
3911 3990
3912 state = SKD_READL(skdev, FIT_MSG_FROM_DEVICE); 3991 state = SKD_READL(skdev, FIT_MSG_FROM_DEVICE);
3913 DPRINTK(skdev, "Msg from Dev=0x%x\n", state); 3992 pr_debug("%s:%s:%d Msg from Dev=0x%x\n",
3993 skdev->name, __func__, __LINE__, state);
3914 3994
3915 state = SKD_READL(skdev, FIT_HW_VERSION); 3995 state = SKD_READL(skdev, FIT_HW_VERSION);
3916 DPRINTK(skdev, "HW version=0x%x\n", state); 3996 pr_debug("%s:%s:%d HW version=0x%x\n",
3997 skdev->name, __func__, __LINE__, state);
3917 3998
3918 spin_unlock_irqrestore(&skdev->lock, flags); 3999 spin_unlock_irqrestore(&skdev->lock, flags);
3919} 4000}
@@ -4006,7 +4087,8 @@ static void skd_restart_device(struct skd_device *skdev)
4006 4087
4007 state = SKD_READL(skdev, FIT_STATUS); 4088 state = SKD_READL(skdev, FIT_STATUS);
4008 4089
4009 DPRINTK(skdev, "drive status=0x%x\n", state); 4090 pr_debug("%s:%s:%d drive status=0x%x\n",
4091 skdev->name, __func__, __LINE__, state);
4010 4092
4011 state &= FIT_SR_DRIVE_STATE_MASK; 4093 state &= FIT_SR_DRIVE_STATE_MASK;
4012 skdev->drive_state = state; 4094 skdev->drive_state = state;
@@ -4026,7 +4108,8 @@ static int skd_quiesce_dev(struct skd_device *skdev)
4026 switch (skdev->state) { 4108 switch (skdev->state) {
4027 case SKD_DRVR_STATE_BUSY: 4109 case SKD_DRVR_STATE_BUSY:
4028 case SKD_DRVR_STATE_BUSY_IMMINENT: 4110 case SKD_DRVR_STATE_BUSY_IMMINENT:
4029 VPRINTK(skdev, "stopping %s queue\n", skdev->name); 4111 pr_debug("%s:%s:%d stopping %s queue\n",
4112 skdev->name, __func__, __LINE__, skdev->name);
4030 skd_stop_queue(skdev); 4113 skd_stop_queue(skdev);
4031 break; 4114 break;
4032 case SKD_DRVR_STATE_ONLINE: 4115 case SKD_DRVR_STATE_ONLINE:
@@ -4039,7 +4122,8 @@ static int skd_quiesce_dev(struct skd_device *skdev)
4039 case SKD_DRVR_STATE_RESUMING: 4122 case SKD_DRVR_STATE_RESUMING:
4040 default: 4123 default:
4041 rc = -EINVAL; 4124 rc = -EINVAL;
4042 VPRINTK(skdev, "state [%d] not implemented\n", skdev->state); 4125 pr_debug("%s:%s:%d state [%d] not implemented\n",
4126 skdev->name, __func__, __LINE__, skdev->state);
4043 } 4127 }
4044 return rc; 4128 return rc;
4045} 4129}
@@ -4051,7 +4135,8 @@ static int skd_unquiesce_dev(struct skd_device *skdev)
4051 4135
4052 skd_log_skdev(skdev, "unquiesce"); 4136 skd_log_skdev(skdev, "unquiesce");
4053 if (skdev->state == SKD_DRVR_STATE_ONLINE) { 4137 if (skdev->state == SKD_DRVR_STATE_ONLINE) {
4054 DPRINTK(skdev, "**** device already ONLINE\n"); 4138 pr_debug("%s:%s:%d **** device already ONLINE\n",
4139 skdev->name, __func__, __LINE__);
4055 return 0; 4140 return 0;
4056 } 4141 }
4057 if (skdev->drive_state != FIT_SR_DRIVE_ONLINE) { 4142 if (skdev->drive_state != FIT_SR_DRIVE_ONLINE) {
@@ -4064,7 +4149,8 @@ static int skd_unquiesce_dev(struct skd_device *skdev)
4064 * to become available. 4149 * to become available.
4065 */ 4150 */
4066 skdev->state = SKD_DRVR_STATE_BUSY; 4151 skdev->state = SKD_DRVR_STATE_BUSY;
4067 DPRINTK(skdev, "drive BUSY state\n"); 4152 pr_debug("%s:%s:%d drive BUSY state\n",
4153 skdev->name, __func__, __LINE__);
4068 return 0; 4154 return 0;
4069 } 4155 }
4070 4156
@@ -4088,8 +4174,10 @@ static int skd_unquiesce_dev(struct skd_device *skdev)
4088 skd_skdev_state_to_str(prev_driver_state), 4174 skd_skdev_state_to_str(prev_driver_state),
4089 prev_driver_state, skd_skdev_state_to_str(skdev->state), 4175 prev_driver_state, skd_skdev_state_to_str(skdev->state),
4090 skdev->state); 4176 skdev->state);
4091 DPRINTK(skdev, "**** device ONLINE...starting block queue\n"); 4177 pr_debug("%s:%s:%d **** device ONLINE...starting block queue\n",
4092 VPRINTK(skdev, "starting %s queue\n", skdev->name); 4178 skdev->name, __func__, __LINE__);
4179 pr_debug("%s:%s:%d starting %s queue\n",
4180 skdev->name, __func__, __LINE__, skdev->name);
4093 pr_info("(%s): STEC s1120 ONLINE\n", skd_name(skdev)); 4181 pr_info("(%s): STEC s1120 ONLINE\n", skd_name(skdev));
4094 skd_start_queue(skdev); 4182 skd_start_queue(skdev);
4095 skdev->gendisk_on = 1; 4183 skdev->gendisk_on = 1;
@@ -4098,8 +4186,9 @@ static int skd_unquiesce_dev(struct skd_device *skdev)
4098 4186
4099 case SKD_DRVR_STATE_DISAPPEARED: 4187 case SKD_DRVR_STATE_DISAPPEARED:
4100 default: 4188 default:
4101 DPRINTK(skdev, "**** driver state %d, not implemented \n", 4189 pr_debug("%s:%s:%d **** driver state %d, not implemented \n",
4102 skdev->state); 4190 skdev->name, __func__, __LINE__,
4191 skdev->state);
4103 return -EBUSY; 4192 return -EBUSY;
4104 } 4193 }
4105 return 0; 4194 return 0;
@@ -4117,7 +4206,9 @@ static irqreturn_t skd_reserved_isr(int irq, void *skd_host_data)
4117 unsigned long flags; 4206 unsigned long flags;
4118 4207
4119 spin_lock_irqsave(&skdev->lock, flags); 4208 spin_lock_irqsave(&skdev->lock, flags);
4120 VPRINTK(skdev, "MSIX = 0x%x\n", SKD_READL(skdev, FIT_INT_STATUS_HOST)); 4209 pr_debug("%s:%s:%d MSIX = 0x%x\n",
4210 skdev->name, __func__, __LINE__,
4211 SKD_READL(skdev, FIT_INT_STATUS_HOST));
4121 pr_err("(%s): MSIX reserved irq %d = 0x%x\n", skd_name(skdev), 4212 pr_err("(%s): MSIX reserved irq %d = 0x%x\n", skd_name(skdev),
4122 irq, SKD_READL(skdev, FIT_INT_STATUS_HOST)); 4213 irq, SKD_READL(skdev, FIT_INT_STATUS_HOST));
4123 SKD_WRITEL(skdev, FIT_INT_RESERVED_MASK, FIT_INT_STATUS_HOST); 4214 SKD_WRITEL(skdev, FIT_INT_RESERVED_MASK, FIT_INT_STATUS_HOST);
@@ -4131,7 +4222,9 @@ static irqreturn_t skd_statec_isr(int irq, void *skd_host_data)
4131 unsigned long flags; 4222 unsigned long flags;
4132 4223
4133 spin_lock_irqsave(&skdev->lock, flags); 4224 spin_lock_irqsave(&skdev->lock, flags);
4134 VPRINTK(skdev, "MSIX = 0x%x\n", SKD_READL(skdev, FIT_INT_STATUS_HOST)); 4225 pr_debug("%s:%s:%d MSIX = 0x%x\n",
4226 skdev->name, __func__, __LINE__,
4227 SKD_READL(skdev, FIT_INT_STATUS_HOST));
4135 SKD_WRITEL(skdev, FIT_ISH_FW_STATE_CHANGE, FIT_INT_STATUS_HOST); 4228 SKD_WRITEL(skdev, FIT_ISH_FW_STATE_CHANGE, FIT_INT_STATUS_HOST);
4136 skd_isr_fwstate(skdev); 4229 skd_isr_fwstate(skdev);
4137 spin_unlock_irqrestore(&skdev->lock, flags); 4230 spin_unlock_irqrestore(&skdev->lock, flags);
@@ -4146,7 +4239,9 @@ static irqreturn_t skd_comp_q(int irq, void *skd_host_data)
4146 int deferred; 4239 int deferred;
4147 4240
4148 spin_lock_irqsave(&skdev->lock, flags); 4241 spin_lock_irqsave(&skdev->lock, flags);
4149 VPRINTK(skdev, "MSIX = 0x%x\n", SKD_READL(skdev, FIT_INT_STATUS_HOST)); 4242 pr_debug("%s:%s:%d MSIX = 0x%x\n",
4243 skdev->name, __func__, __LINE__,
4244 SKD_READL(skdev, FIT_INT_STATUS_HOST));
4150 SKD_WRITEL(skdev, FIT_ISH_COMPLETION_POSTED, FIT_INT_STATUS_HOST); 4245 SKD_WRITEL(skdev, FIT_ISH_COMPLETION_POSTED, FIT_INT_STATUS_HOST);
4151 deferred = skd_isr_completion_posted(skdev, skd_isr_comp_limit, 4246 deferred = skd_isr_completion_posted(skdev, skd_isr_comp_limit,
4152 &flush_enqueued); 4247 &flush_enqueued);
@@ -4170,7 +4265,9 @@ static irqreturn_t skd_msg_isr(int irq, void *skd_host_data)
4170 unsigned long flags; 4265 unsigned long flags;
4171 4266
4172 spin_lock_irqsave(&skdev->lock, flags); 4267 spin_lock_irqsave(&skdev->lock, flags);
4173 VPRINTK(skdev, "MSIX = 0x%x\n", SKD_READL(skdev, FIT_INT_STATUS_HOST)); 4268 pr_debug("%s:%s:%d MSIX = 0x%x\n",
4269 skdev->name, __func__, __LINE__,
4270 SKD_READL(skdev, FIT_INT_STATUS_HOST));
4174 SKD_WRITEL(skdev, FIT_ISH_MSG_FROM_DEV, FIT_INT_STATUS_HOST); 4271 SKD_WRITEL(skdev, FIT_ISH_MSG_FROM_DEV, FIT_INT_STATUS_HOST);
4175 skd_isr_msg_from_dev(skdev); 4272 skd_isr_msg_from_dev(skdev);
4176 spin_unlock_irqrestore(&skdev->lock, flags); 4273 spin_unlock_irqrestore(&skdev->lock, flags);
@@ -4183,7 +4280,9 @@ static irqreturn_t skd_qfull_isr(int irq, void *skd_host_data)
4183 unsigned long flags; 4280 unsigned long flags;
4184 4281
4185 spin_lock_irqsave(&skdev->lock, flags); 4282 spin_lock_irqsave(&skdev->lock, flags);
4186 VPRINTK(skdev, "MSIX = 0x%x\n", SKD_READL(skdev, FIT_INT_STATUS_HOST)); 4283 pr_debug("%s:%s:%d MSIX = 0x%x\n",
4284 skdev->name, __func__, __LINE__,
4285 SKD_READL(skdev, FIT_INT_STATUS_HOST));
4187 SKD_WRITEL(skdev, FIT_INT_QUEUE_FULL, FIT_INT_STATUS_HOST); 4286 SKD_WRITEL(skdev, FIT_INT_QUEUE_FULL, FIT_INT_STATUS_HOST);
4188 spin_unlock_irqrestore(&skdev->lock, flags); 4287 spin_unlock_irqrestore(&skdev->lock, flags);
4189 return IRQ_HANDLED; 4288 return IRQ_HANDLED;
@@ -4275,8 +4374,9 @@ static int skd_acquire_msix(struct skd_device *skdev)
4275 skd_name(skdev), rc); 4374 skd_name(skdev), rc);
4276 goto msix_out; 4375 goto msix_out;
4277 } 4376 }
4278 DPRINTK(skdev, "%s: <%s> allocated %d MSI-X vectors\n", 4377 pr_debug("%s:%s:%d %s: <%s> allocated %d MSI-X vectors\n",
4279 pci_name(pdev), skdev->name, rc); 4378 skdev->name, __func__, __LINE__,
4379 pci_name(pdev), skdev->name, rc);
4280 4380
4281 skdev->msix_count = rc; 4381 skdev->msix_count = rc;
4282 rc = pci_enable_msix(pdev, entries, skdev->msix_count); 4382 rc = pci_enable_msix(pdev, entries, skdev->msix_count);
@@ -4303,9 +4403,10 @@ static int skd_acquire_msix(struct skd_device *skdev)
4303 qentry->entry = entries[i].entry; 4403 qentry->entry = entries[i].entry;
4304 qentry->rsp = NULL; 4404 qentry->rsp = NULL;
4305 qentry->have_irq = 0; 4405 qentry->have_irq = 0;
4306 DPRINTK(skdev, "%s: <%s> msix (%d) vec %d, entry %x\n", 4406 pr_debug("%s:%s:%d %s: <%s> msix (%d) vec %d, entry %x\n",
4307 pci_name(pdev), skdev->name, 4407 skdev->name, __func__, __LINE__,
4308 i, qentry->vector, qentry->entry); 4408 pci_name(pdev), skdev->name,
4409 i, qentry->vector, qentry->entry);
4309 qentry++; 4410 qentry++;
4310 } 4411 }
4311 4412
@@ -4328,8 +4429,9 @@ static int skd_acquire_msix(struct skd_device *skdev)
4328 qentry->rsp = skdev; 4429 qentry->rsp = skdev;
4329 } 4430 }
4330 } 4431 }
4331 DPRINTK(skdev, "%s: <%s> msix %d irq(s) enabled\n", 4432 pr_debug("%s:%s:%d %s: <%s> msix %d irq(s) enabled\n",
4332 pci_name(pdev), skdev->name, skdev->msix_count); 4433 skdev->name, __func__, __LINE__,
4434 pci_name(pdev), skdev->name, skdev->msix_count);
4333 return 0; 4435 return 0;
4334 4436
4335msix_out: 4437msix_out:
@@ -4489,43 +4591,42 @@ static struct skd_device *skd_construct(struct pci_dev *pdev)
4489 INIT_WORK(&skdev->completion_worker, skd_completion_worker); 4591 INIT_WORK(&skdev->completion_worker, skd_completion_worker);
4490 INIT_LIST_HEAD(&skdev->flush_list); 4592 INIT_LIST_HEAD(&skdev->flush_list);
4491 4593
4492 VPRINTK(skdev, "skcomp\n"); 4594 pr_debug("%s:%s:%d skcomp\n", skdev->name, __func__, __LINE__);
4493 rc = skd_cons_skcomp(skdev); 4595 rc = skd_cons_skcomp(skdev);
4494 if (rc < 0) 4596 if (rc < 0)
4495 goto err_out; 4597 goto err_out;
4496 4598
4497 VPRINTK(skdev, "skmsg\n"); 4599 pr_debug("%s:%s:%d skmsg\n", skdev->name, __func__, __LINE__);
4498 rc = skd_cons_skmsg(skdev); 4600 rc = skd_cons_skmsg(skdev);
4499 if (rc < 0) 4601 if (rc < 0)
4500 goto err_out; 4602 goto err_out;
4501 4603
4502 VPRINTK(skdev, "skreq\n"); 4604 pr_debug("%s:%s:%d skreq\n", skdev->name, __func__, __LINE__);
4503 rc = skd_cons_skreq(skdev); 4605 rc = skd_cons_skreq(skdev);
4504 if (rc < 0) 4606 if (rc < 0)
4505 goto err_out; 4607 goto err_out;
4506 4608
4507 VPRINTK(skdev, "skspcl\n"); 4609 pr_debug("%s:%s:%d skspcl\n", skdev->name, __func__, __LINE__);
4508 rc = skd_cons_skspcl(skdev); 4610 rc = skd_cons_skspcl(skdev);
4509 if (rc < 0) 4611 if (rc < 0)
4510 goto err_out; 4612 goto err_out;
4511 4613
4512 VPRINTK(skdev, "sksb\n"); 4614 pr_debug("%s:%s:%d sksb\n", skdev->name, __func__, __LINE__);
4513 rc = skd_cons_sksb(skdev); 4615 rc = skd_cons_sksb(skdev);
4514 if (rc < 0) 4616 if (rc < 0)
4515 goto err_out; 4617 goto err_out;
4516 4618
4517 VPRINTK(skdev, "disk\n"); 4619 pr_debug("%s:%s:%d disk\n", skdev->name, __func__, __LINE__);
4518 rc = skd_cons_disk(skdev); 4620 rc = skd_cons_disk(skdev);
4519 if (rc < 0) 4621 if (rc < 0)
4520 goto err_out; 4622 goto err_out;
4521 4623
4522 4624 pr_debug("%s:%s:%d VICTORY\n", skdev->name, __func__, __LINE__);
4523
4524 DPRINTK(skdev, "VICTORY\n");
4525 return skdev; 4625 return skdev;
4526 4626
4527err_out: 4627err_out:
4528 DPRINTK(skdev, "construct failed\n"); 4628 pr_debug("%s:%s:%d construct failed\n",
4629 skdev->name, __func__, __LINE__);
4529 skd_destruct(skdev); 4630 skd_destruct(skdev);
4530 return NULL; 4631 return NULL;
4531} 4632}
@@ -4539,8 +4640,9 @@ static int skd_cons_skcomp(struct skd_device *skdev)
4539 nbytes = sizeof(*skcomp) * SKD_N_COMPLETION_ENTRY; 4640 nbytes = sizeof(*skcomp) * SKD_N_COMPLETION_ENTRY;
4540 nbytes += sizeof(struct fit_comp_error_info) * SKD_N_COMPLETION_ENTRY; 4641 nbytes += sizeof(struct fit_comp_error_info) * SKD_N_COMPLETION_ENTRY;
4541 4642
4542 VPRINTK(skdev, "comp pci_alloc, total bytes %d entries %d\n", nbytes, 4643 pr_debug("%s:%s:%d comp pci_alloc, total bytes %d entries %d\n",
4543 SKD_N_COMPLETION_ENTRY); 4644 skdev->name, __func__, __LINE__,
4645 nbytes, SKD_N_COMPLETION_ENTRY);
4544 4646
4545 skcomp = pci_alloc_consistent(skdev->pdev, nbytes, 4647 skcomp = pci_alloc_consistent(skdev->pdev, nbytes,
4546 &skdev->cq_dma_address); 4648 &skdev->cq_dma_address);
@@ -4566,10 +4668,11 @@ static int skd_cons_skmsg(struct skd_device *skdev)
4566 int rc = 0; 4668 int rc = 0;
4567 u32 i; 4669 u32 i;
4568 4670
4569 VPRINTK(skdev, "skmsg_table kzalloc, struct %lu, count %u total %lu\n", 4671 pr_debug("%s:%s:%d skmsg_table kzalloc, struct %lu, count %u total %lu\n",
4570 sizeof(struct skd_fitmsg_context), 4672 skdev->name, __func__, __LINE__,
4571 skdev->num_fitmsg_context, 4673 sizeof(struct skd_fitmsg_context),
4572 sizeof(struct skd_fitmsg_context) * skdev->num_fitmsg_context); 4674 skdev->num_fitmsg_context,
4675 sizeof(struct skd_fitmsg_context) * skdev->num_fitmsg_context);
4573 4676
4574 skdev->skmsg_table = kzalloc(sizeof(struct skd_fitmsg_context) 4677 skdev->skmsg_table = kzalloc(sizeof(struct skd_fitmsg_context)
4575 *skdev->num_fitmsg_context, GFP_KERNEL); 4678 *skdev->num_fitmsg_context, GFP_KERNEL);
@@ -4620,10 +4723,11 @@ static int skd_cons_skreq(struct skd_device *skdev)
4620 int rc = 0; 4723 int rc = 0;
4621 u32 i; 4724 u32 i;
4622 4725
4623 VPRINTK(skdev, "skreq_table kzalloc, struct %lu, count %u total %lu\n", 4726 pr_debug("%s:%s:%d skreq_table kzalloc, struct %lu, count %u total %lu\n",
4624 sizeof(struct skd_request_context), 4727 skdev->name, __func__, __LINE__,
4625 skdev->num_req_context, 4728 sizeof(struct skd_request_context),
4626 sizeof(struct skd_request_context) * skdev->num_req_context); 4729 skdev->num_req_context,
4730 sizeof(struct skd_request_context) * skdev->num_req_context);
4627 4731
4628 skdev->skreq_table = kzalloc(sizeof(struct skd_request_context) 4732 skdev->skreq_table = kzalloc(sizeof(struct skd_request_context)
4629 * skdev->num_req_context, GFP_KERNEL); 4733 * skdev->num_req_context, GFP_KERNEL);
@@ -4632,9 +4736,10 @@ static int skd_cons_skreq(struct skd_device *skdev)
4632 goto err_out; 4736 goto err_out;
4633 } 4737 }
4634 4738
4635 VPRINTK(skdev, "alloc sg_table sg_per_req %u scatlist %lu total %lu\n", 4739 pr_debug("%s:%s:%d alloc sg_table sg_per_req %u scatlist %lu total %lu\n",
4636 skdev->sgs_per_request, sizeof(struct scatterlist), 4740 skdev->name, __func__, __LINE__,
4637 skdev->sgs_per_request * sizeof(struct scatterlist)); 4741 skdev->sgs_per_request, sizeof(struct scatterlist),
4742 skdev->sgs_per_request * sizeof(struct scatterlist));
4638 4743
4639 for (i = 0; i < skdev->num_req_context; i++) { 4744 for (i = 0; i < skdev->num_req_context; i++) {
4640 struct skd_request_context *skreq; 4745 struct skd_request_context *skreq;
@@ -4677,10 +4782,11 @@ static int skd_cons_skspcl(struct skd_device *skdev)
4677 int rc = 0; 4782 int rc = 0;
4678 u32 i, nbytes; 4783 u32 i, nbytes;
4679 4784
4680 VPRINTK(skdev, "skspcl_table kzalloc, struct %lu, count %u total %lu\n", 4785 pr_debug("%s:%s:%d skspcl_table kzalloc, struct %lu, count %u total %lu\n",
4681 sizeof(struct skd_special_context), 4786 skdev->name, __func__, __LINE__,
4682 skdev->n_special, 4787 sizeof(struct skd_special_context),
4683 sizeof(struct skd_special_context) * skdev->n_special); 4788 skdev->n_special,
4789 sizeof(struct skd_special_context) * skdev->n_special);
4684 4790
4685 skdev->skspcl_table = kzalloc(sizeof(struct skd_special_context) 4791 skdev->skspcl_table = kzalloc(sizeof(struct skd_special_context)
4686 * skdev->n_special, GFP_KERNEL); 4792 * skdev->n_special, GFP_KERNEL);
@@ -4872,7 +4978,8 @@ static int skd_cons_disk(struct skd_device *skdev)
4872 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q); 4978 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);
4873 4979
4874 spin_lock_irqsave(&skdev->lock, flags); 4980 spin_lock_irqsave(&skdev->lock, flags);
4875 VPRINTK(skdev, "stopping %s queue\n", skdev->name); 4981 pr_debug("%s:%s:%d stopping %s queue\n",
4982 skdev->name, __func__, __LINE__, skdev->name);
4876 skd_stop_queue(skdev); 4983 skd_stop_queue(skdev);
4877 spin_unlock_irqrestore(&skdev->lock, flags); 4984 spin_unlock_irqrestore(&skdev->lock, flags);
4878 4985
@@ -4902,25 +5009,25 @@ static void skd_destruct(struct skd_device *skdev)
4902 return; 5009 return;
4903 5010
4904 5011
4905 VPRINTK(skdev, "disk\n"); 5012 pr_debug("%s:%s:%d disk\n", skdev->name, __func__, __LINE__);
4906 skd_free_disk(skdev); 5013 skd_free_disk(skdev);
4907 5014
4908 VPRINTK(skdev, "sksb\n"); 5015 pr_debug("%s:%s:%d sksb\n", skdev->name, __func__, __LINE__);
4909 skd_free_sksb(skdev); 5016 skd_free_sksb(skdev);
4910 5017
4911 VPRINTK(skdev, "skspcl\n"); 5018 pr_debug("%s:%s:%d skspcl\n", skdev->name, __func__, __LINE__);
4912 skd_free_skspcl(skdev); 5019 skd_free_skspcl(skdev);
4913 5020
4914 VPRINTK(skdev, "skreq\n"); 5021 pr_debug("%s:%s:%d skreq\n", skdev->name, __func__, __LINE__);
4915 skd_free_skreq(skdev); 5022 skd_free_skreq(skdev);
4916 5023
4917 VPRINTK(skdev, "skmsg\n"); 5024 pr_debug("%s:%s:%d skmsg\n", skdev->name, __func__, __LINE__);
4918 skd_free_skmsg(skdev); 5025 skd_free_skmsg(skdev);
4919 5026
4920 VPRINTK(skdev, "skcomp\n"); 5027 pr_debug("%s:%s:%d skcomp\n", skdev->name, __func__, __LINE__);
4921 skd_free_skcomp(skdev); 5028 skd_free_skcomp(skdev);
4922 5029
4923 VPRINTK(skdev, "skdev\n"); 5030 pr_debug("%s:%s:%d skdev\n", skdev->name, __func__, __LINE__);
4924 kfree(skdev); 5031 kfree(skdev);
4925} 5032}
4926 5033
@@ -5106,8 +5213,9 @@ static int skd_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo)
5106 5213
5107 skdev = bdev->bd_disk->private_data; 5214 skdev = bdev->bd_disk->private_data;
5108 5215
5109 DPRINTK(skdev, "%s: CMD[%s] getgeo device\n", 5216 pr_debug("%s:%s:%d %s: CMD[%s] getgeo device\n",
5110 bdev->bd_disk->disk_name, current->comm); 5217 skdev->name, __func__, __LINE__,
5218 bdev->bd_disk->disk_name, current->comm);
5111 5219
5112 if (skdev->read_cap_is_valid) { 5220 if (skdev->read_cap_is_valid) {
5113 capacity = get_capacity(skdev->disk); 5221 capacity = get_capacity(skdev->disk);
@@ -5122,7 +5230,7 @@ static int skd_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo)
5122 5230
5123static int skd_bdev_attach(struct skd_device *skdev) 5231static int skd_bdev_attach(struct skd_device *skdev)
5124{ 5232{
5125 DPRINTK(skdev, "add_disk\n"); 5233 pr_debug("%s:%s:%d add_disk\n", skdev->name, __func__, __LINE__);
5126 add_disk(skdev->disk); 5234 add_disk(skdev->disk);
5127 return 0; 5235 return 0;
5128} 5236}
@@ -5245,9 +5353,10 @@ static int skd_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
5245 rc = -ENODEV; 5353 rc = -ENODEV;
5246 goto err_out_iounmap; 5354 goto err_out_iounmap;
5247 } 5355 }
5248 DPRINTK(skdev, "mem_map=%p, phyd=%016llx, size=%d\n", 5356 pr_debug("%s:%s:%d mem_map=%p, phyd=%016llx, size=%d\n",
5249 skdev->mem_map[i], 5357 skdev->name, __func__, __LINE__,
5250 (uint64_t)skdev->mem_phys[i], skdev->mem_size[i]); 5358 skdev->mem_map[i],
5359 (uint64_t)skdev->mem_phys[i], skdev->mem_size[i]);
5251 } 5360 }
5252 5361
5253 rc = skd_acquire_irq(skdev); 5362 rc = skd_acquire_irq(skdev);
@@ -5441,9 +5550,10 @@ static int skd_pci_resume(struct pci_dev *pdev)
5441 rc = -ENODEV; 5550 rc = -ENODEV;
5442 goto err_out_iounmap; 5551 goto err_out_iounmap;
5443 } 5552 }
5444 DPRINTK(skdev, "mem_map=%p, phyd=%016llx, size=%d\n", 5553 pr_debug("%s:%s:%d mem_map=%p, phyd=%016llx, size=%d\n",
5445 skdev->mem_map[i], 5554 skdev->name, __func__, __LINE__,
5446 (uint64_t)skdev->mem_phys[i], skdev->mem_size[i]); 5555 skdev->mem_map[i],
5556 (uint64_t)skdev->mem_phys[i], skdev->mem_size[i]);
5447 } 5557 }
5448 rc = skd_acquire_irq(skdev); 5558 rc = skd_acquire_irq(skdev);
5449 if (rc) { 5559 if (rc) {
@@ -5643,35 +5753,44 @@ const char *skd_skreq_state_to_str(enum skd_req_state state)
5643 5753
5644static void skd_log_skdev(struct skd_device *skdev, const char *event) 5754static void skd_log_skdev(struct skd_device *skdev, const char *event)
5645{ 5755{
5646 DPRINTK(skdev, "(%s) skdev=%p event='%s'\n", skdev->name, skdev, event); 5756 pr_debug("%s:%s:%d (%s) skdev=%p event='%s'\n",
5647 DPRINTK(skdev, " drive_state=%s(%d) driver_state=%s(%d)\n", 5757 skdev->name, __func__, __LINE__, skdev->name, skdev, event);
5648 skd_drive_state_to_str(skdev->drive_state), skdev->drive_state, 5758 pr_debug("%s:%s:%d drive_state=%s(%d) driver_state=%s(%d)\n",
5649 skd_skdev_state_to_str(skdev->state), skdev->state); 5759 skdev->name, __func__, __LINE__,
5650 DPRINTK(skdev, " busy=%d limit=%d dev=%d lowat=%d\n", 5760 skd_drive_state_to_str(skdev->drive_state), skdev->drive_state,
5651 skdev->in_flight, skdev->cur_max_queue_depth, 5761 skd_skdev_state_to_str(skdev->state), skdev->state);
5652 skdev->dev_max_queue_depth, skdev->queue_low_water_mark); 5762 pr_debug("%s:%s:%d busy=%d limit=%d dev=%d lowat=%d\n",
5653 DPRINTK(skdev, " timestamp=0x%x cycle=%d cycle_ix=%d\n", 5763 skdev->name, __func__, __LINE__,
5654 skdev->timeout_stamp, skdev->skcomp_cycle, skdev->skcomp_ix); 5764 skdev->in_flight, skdev->cur_max_queue_depth,
5765 skdev->dev_max_queue_depth, skdev->queue_low_water_mark);
5766 pr_debug("%s:%s:%d timestamp=0x%x cycle=%d cycle_ix=%d\n",
5767 skdev->name, __func__, __LINE__,
5768 skdev->timeout_stamp, skdev->skcomp_cycle, skdev->skcomp_ix);
5655} 5769}
5656 5770
5657static void skd_log_skmsg(struct skd_device *skdev, 5771static void skd_log_skmsg(struct skd_device *skdev,
5658 struct skd_fitmsg_context *skmsg, const char *event) 5772 struct skd_fitmsg_context *skmsg, const char *event)
5659{ 5773{
5660 DPRINTK(skdev, "(%s) skmsg=%p event='%s'\n", skdev->name, skmsg, event); 5774 pr_debug("%s:%s:%d (%s) skmsg=%p event='%s'\n",
5661 DPRINTK(skdev, " state=%s(%d) id=0x%04x length=%d\n", 5775 skdev->name, __func__, __LINE__, skdev->name, skmsg, event);
5662 skd_skmsg_state_to_str(skmsg->state), skmsg->state, 5776 pr_debug("%s:%s:%d state=%s(%d) id=0x%04x length=%d\n",
5663 skmsg->id, skmsg->length); 5777 skdev->name, __func__, __LINE__,
5778 skd_skmsg_state_to_str(skmsg->state), skmsg->state,
5779 skmsg->id, skmsg->length);
5664} 5780}
5665 5781
5666static void skd_log_skreq(struct skd_device *skdev, 5782static void skd_log_skreq(struct skd_device *skdev,
5667 struct skd_request_context *skreq, const char *event) 5783 struct skd_request_context *skreq, const char *event)
5668{ 5784{
5669 DPRINTK(skdev, "(%s) skreq=%p event='%s'\n", skdev->name, skreq, event); 5785 pr_debug("%s:%s:%d (%s) skreq=%p event='%s'\n",
5670 DPRINTK(skdev, " state=%s(%d) id=0x%04x fitmsg=0x%04x\n", 5786 skdev->name, __func__, __LINE__, skdev->name, skreq, event);
5671 skd_skreq_state_to_str(skreq->state), skreq->state, 5787 pr_debug("%s:%s:%d state=%s(%d) id=0x%04x fitmsg=0x%04x\n",
5672 skreq->id, skreq->fitmsg_id); 5788 skdev->name, __func__, __LINE__,
5673 DPRINTK(skdev, " timo=0x%x sg_dir=%d n_sg=%d\n", 5789 skd_skreq_state_to_str(skreq->state), skreq->state,
5674 skreq->timeout_stamp, skreq->sg_data_dir, skreq->n_sg); 5790 skreq->id, skreq->fitmsg_id);
5791 pr_debug("%s:%s:%d timo=0x%x sg_dir=%d n_sg=%d\n",
5792 skdev->name, __func__, __LINE__,
5793 skreq->timeout_stamp, skreq->sg_data_dir, skreq->n_sg);
5675 5794
5676 if (!skd_bio) { 5795 if (!skd_bio) {
5677 if (skreq->req != NULL) { 5796 if (skreq->req != NULL) {
@@ -5679,24 +5798,28 @@ static void skd_log_skreq(struct skd_device *skdev,
5679 u32 lba = (u32)blk_rq_pos(req); 5798 u32 lba = (u32)blk_rq_pos(req);
5680 u32 count = blk_rq_sectors(req); 5799 u32 count = blk_rq_sectors(req);
5681 5800
5682 DPRINTK(skdev, 5801 pr_debug("%s:%s:%d "
5683 " req=%p lba=%u(0x%x) count=%u(0x%x) dir=%d\n", 5802 "req=%p lba=%u(0x%x) count=%u(0x%x) dir=%d\n",
5684 req, lba, lba, count, count, 5803 skdev->name, __func__, __LINE__,
5685 (int)rq_data_dir(req)); 5804 req, lba, lba, count, count,
5805 (int)rq_data_dir(req));
5686 } else 5806 } else
5687 DPRINTK(skdev, " req=NULL\n"); 5807 pr_debug("%s:%s:%d req=NULL\n",
5808 skdev->name, __func__, __LINE__);
5688 } else { 5809 } else {
5689 if (skreq->bio != NULL) { 5810 if (skreq->bio != NULL) {
5690 struct bio *bio = skreq->bio; 5811 struct bio *bio = skreq->bio;
5691 u32 lba = (u32)bio->bi_sector; 5812 u32 lba = (u32)bio->bi_sector;
5692 u32 count = bio_sectors(bio); 5813 u32 count = bio_sectors(bio);
5693 5814
5694 DPRINTK(skdev, 5815 pr_debug("%s:%s:%d "
5695 " bio=%p lba=%u(0x%x) count=%u(0x%x) dir=%d\n", 5816 "bio=%p lba=%u(0x%x) count=%u(0x%x) dir=%d\n",
5696 bio, lba, lba, count, count, 5817 skdev->name, __func__, __LINE__,
5697 (int)bio_data_dir(bio)); 5818 bio, lba, lba, count, count,
5819 (int)bio_data_dir(bio));
5698 } else 5820 } else
5699 DPRINTK(skdev, " req=NULL\n"); 5821 pr_debug("%s:%s:%d req=NULL\n",
5822 skdev->name, __func__, __LINE__);
5700 } 5823 }
5701} 5824}
5702 5825
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-20 17:46:16 -0400