diff options
Diffstat (limited to 'drivers/block/mtip32xx/mtip32xx.c')
-rw-r--r-- | drivers/block/mtip32xx/mtip32xx.c | 860 |
1 files changed, 664 insertions, 196 deletions
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c index 8eb81c96608f..00f9fc992090 100644 --- a/drivers/block/mtip32xx/mtip32xx.c +++ b/drivers/block/mtip32xx/mtip32xx.c | |||
@@ -36,6 +36,7 @@ | |||
36 | #include <linux/idr.h> | 36 | #include <linux/idr.h> |
37 | #include <linux/kthread.h> | 37 | #include <linux/kthread.h> |
38 | #include <../drivers/ata/ahci.h> | 38 | #include <../drivers/ata/ahci.h> |
39 | #include <linux/export.h> | ||
39 | #include "mtip32xx.h" | 40 | #include "mtip32xx.h" |
40 | 41 | ||
41 | #define HW_CMD_SLOT_SZ (MTIP_MAX_COMMAND_SLOTS * 32) | 42 | #define HW_CMD_SLOT_SZ (MTIP_MAX_COMMAND_SLOTS * 32) |
@@ -44,6 +45,7 @@ | |||
44 | #define HW_PORT_PRIV_DMA_SZ \ | 45 | #define HW_PORT_PRIV_DMA_SZ \ |
45 | (HW_CMD_SLOT_SZ + HW_CMD_TBL_AR_SZ + AHCI_RX_FIS_SZ) | 46 | (HW_CMD_SLOT_SZ + HW_CMD_TBL_AR_SZ + AHCI_RX_FIS_SZ) |
46 | 47 | ||
48 | #define HOST_CAP_NZDMA (1 << 19) | ||
47 | #define HOST_HSORG 0xFC | 49 | #define HOST_HSORG 0xFC |
48 | #define HSORG_DISABLE_SLOTGRP_INTR (1<<24) | 50 | #define HSORG_DISABLE_SLOTGRP_INTR (1<<24) |
49 | #define HSORG_DISABLE_SLOTGRP_PXIS (1<<16) | 51 | #define HSORG_DISABLE_SLOTGRP_PXIS (1<<16) |
@@ -139,6 +141,12 @@ static void mtip_command_cleanup(struct driver_data *dd) | |||
139 | int group = 0, commandslot = 0, commandindex = 0; | 141 | int group = 0, commandslot = 0, commandindex = 0; |
140 | struct mtip_cmd *command; | 142 | struct mtip_cmd *command; |
141 | struct mtip_port *port = dd->port; | 143 | struct mtip_port *port = dd->port; |
144 | static int in_progress; | ||
145 | |||
146 | if (in_progress) | ||
147 | return; | ||
148 | |||
149 | in_progress = 1; | ||
142 | 150 | ||
143 | for (group = 0; group < 4; group++) { | 151 | for (group = 0; group < 4; group++) { |
144 | for (commandslot = 0; commandslot < 32; commandslot++) { | 152 | for (commandslot = 0; commandslot < 32; commandslot++) { |
@@ -165,7 +173,8 @@ static void mtip_command_cleanup(struct driver_data *dd) | |||
165 | 173 | ||
166 | up(&port->cmd_slot); | 174 | up(&port->cmd_slot); |
167 | 175 | ||
168 | atomic_set(&dd->drv_cleanup_done, true); | 176 | set_bit(MTIP_DDF_CLEANUP_BIT, &dd->dd_flag); |
177 | in_progress = 0; | ||
169 | } | 178 | } |
170 | 179 | ||
171 | /* | 180 | /* |
@@ -262,6 +271,9 @@ static int hba_reset_nosleep(struct driver_data *dd) | |||
262 | && time_before(jiffies, timeout)) | 271 | && time_before(jiffies, timeout)) |
263 | mdelay(1); | 272 | mdelay(1); |
264 | 273 | ||
274 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag)) | ||
275 | return -1; | ||
276 | |||
265 | if (readl(dd->mmio + HOST_CTL) & HOST_RESET) | 277 | if (readl(dd->mmio + HOST_CTL) & HOST_RESET) |
266 | return -1; | 278 | return -1; |
267 | 279 | ||
@@ -294,6 +306,10 @@ static inline void mtip_issue_ncq_command(struct mtip_port *port, int tag) | |||
294 | port->cmd_issue[MTIP_TAG_INDEX(tag)]); | 306 | port->cmd_issue[MTIP_TAG_INDEX(tag)]); |
295 | 307 | ||
296 | spin_unlock_irqrestore(&port->cmd_issue_lock, flags); | 308 | spin_unlock_irqrestore(&port->cmd_issue_lock, flags); |
309 | |||
310 | /* Set the command's timeout value.*/ | ||
311 | port->commands[tag].comp_time = jiffies + msecs_to_jiffies( | ||
312 | MTIP_NCQ_COMMAND_TIMEOUT_MS); | ||
297 | } | 313 | } |
298 | 314 | ||
299 | /* | 315 | /* |
@@ -420,7 +436,12 @@ static void mtip_init_port(struct mtip_port *port) | |||
420 | writel(0xFFFFFFFF, port->completed[i]); | 436 | writel(0xFFFFFFFF, port->completed[i]); |
421 | 437 | ||
422 | /* Clear any pending interrupts for this port */ | 438 | /* Clear any pending interrupts for this port */ |
423 | writel(readl(port->mmio + PORT_IRQ_STAT), port->mmio + PORT_IRQ_STAT); | 439 | writel(readl(port->dd->mmio + PORT_IRQ_STAT), |
440 | port->dd->mmio + PORT_IRQ_STAT); | ||
441 | |||
442 | /* Clear any pending interrupts on the HBA. */ | ||
443 | writel(readl(port->dd->mmio + HOST_IRQ_STAT), | ||
444 | port->dd->mmio + HOST_IRQ_STAT); | ||
424 | 445 | ||
425 | /* Enable port interrupts */ | 446 | /* Enable port interrupts */ |
426 | writel(DEF_PORT_IRQ, port->mmio + PORT_IRQ_MASK); | 447 | writel(DEF_PORT_IRQ, port->mmio + PORT_IRQ_MASK); |
@@ -447,6 +468,9 @@ static void mtip_restart_port(struct mtip_port *port) | |||
447 | && time_before(jiffies, timeout)) | 468 | && time_before(jiffies, timeout)) |
448 | ; | 469 | ; |
449 | 470 | ||
471 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &port->dd->dd_flag)) | ||
472 | return; | ||
473 | |||
450 | /* | 474 | /* |
451 | * Chip quirk: escalate to hba reset if | 475 | * Chip quirk: escalate to hba reset if |
452 | * PxCMD.CR not clear after 500 ms | 476 | * PxCMD.CR not clear after 500 ms |
@@ -475,6 +499,9 @@ static void mtip_restart_port(struct mtip_port *port) | |||
475 | while (time_before(jiffies, timeout)) | 499 | while (time_before(jiffies, timeout)) |
476 | ; | 500 | ; |
477 | 501 | ||
502 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &port->dd->dd_flag)) | ||
503 | return; | ||
504 | |||
478 | /* Clear PxSCTL.DET */ | 505 | /* Clear PxSCTL.DET */ |
479 | writel(readl(port->mmio + PORT_SCR_CTL) & ~1, | 506 | writel(readl(port->mmio + PORT_SCR_CTL) & ~1, |
480 | port->mmio + PORT_SCR_CTL); | 507 | port->mmio + PORT_SCR_CTL); |
@@ -486,15 +513,35 @@ static void mtip_restart_port(struct mtip_port *port) | |||
486 | && time_before(jiffies, timeout)) | 513 | && time_before(jiffies, timeout)) |
487 | ; | 514 | ; |
488 | 515 | ||
516 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &port->dd->dd_flag)) | ||
517 | return; | ||
518 | |||
489 | if ((readl(port->mmio + PORT_SCR_STAT) & 0x01) == 0) | 519 | if ((readl(port->mmio + PORT_SCR_STAT) & 0x01) == 0) |
490 | dev_warn(&port->dd->pdev->dev, | 520 | dev_warn(&port->dd->pdev->dev, |
491 | "COM reset failed\n"); | 521 | "COM reset failed\n"); |
492 | 522 | ||
493 | /* Clear SError, the PxSERR.DIAG.x should be set so clear it */ | 523 | mtip_init_port(port); |
494 | writel(readl(port->mmio + PORT_SCR_ERR), port->mmio + PORT_SCR_ERR); | 524 | mtip_start_port(port); |
495 | 525 | ||
496 | /* Enable the DMA engine */ | 526 | } |
497 | mtip_enable_engine(port, 1); | 527 | |
528 | /* | ||
529 | * Helper function for tag logging | ||
530 | */ | ||
531 | static void print_tags(struct driver_data *dd, | ||
532 | char *msg, | ||
533 | unsigned long *tagbits, | ||
534 | int cnt) | ||
535 | { | ||
536 | unsigned char tagmap[128]; | ||
537 | int group, tagmap_len = 0; | ||
538 | |||
539 | memset(tagmap, 0, sizeof(tagmap)); | ||
540 | for (group = SLOTBITS_IN_LONGS; group > 0; group--) | ||
541 | tagmap_len = sprintf(tagmap + tagmap_len, "%016lX ", | ||
542 | tagbits[group-1]); | ||
543 | dev_warn(&dd->pdev->dev, | ||
544 | "%d command(s) %s: tagmap [%s]", cnt, msg, tagmap); | ||
498 | } | 545 | } |
499 | 546 | ||
500 | /* | 547 | /* |
@@ -514,15 +561,18 @@ static void mtip_timeout_function(unsigned long int data) | |||
514 | int tag, cmdto_cnt = 0; | 561 | int tag, cmdto_cnt = 0; |
515 | unsigned int bit, group; | 562 | unsigned int bit, group; |
516 | unsigned int num_command_slots = port->dd->slot_groups * 32; | 563 | unsigned int num_command_slots = port->dd->slot_groups * 32; |
564 | unsigned long to, tagaccum[SLOTBITS_IN_LONGS]; | ||
517 | 565 | ||
518 | if (unlikely(!port)) | 566 | if (unlikely(!port)) |
519 | return; | 567 | return; |
520 | 568 | ||
521 | if (atomic_read(&port->dd->resumeflag) == true) { | 569 | if (test_bit(MTIP_DDF_RESUME_BIT, &port->dd->dd_flag)) { |
522 | mod_timer(&port->cmd_timer, | 570 | mod_timer(&port->cmd_timer, |
523 | jiffies + msecs_to_jiffies(30000)); | 571 | jiffies + msecs_to_jiffies(30000)); |
524 | return; | 572 | return; |
525 | } | 573 | } |
574 | /* clear the tag accumulator */ | ||
575 | memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long)); | ||
526 | 576 | ||
527 | for (tag = 0; tag < num_command_slots; tag++) { | 577 | for (tag = 0; tag < num_command_slots; tag++) { |
528 | /* | 578 | /* |
@@ -540,12 +590,10 @@ static void mtip_timeout_function(unsigned long int data) | |||
540 | command = &port->commands[tag]; | 590 | command = &port->commands[tag]; |
541 | fis = (struct host_to_dev_fis *) command->command; | 591 | fis = (struct host_to_dev_fis *) command->command; |
542 | 592 | ||
543 | dev_warn(&port->dd->pdev->dev, | 593 | set_bit(tag, tagaccum); |
544 | "Timeout for command tag %d\n", tag); | ||
545 | |||
546 | cmdto_cnt++; | 594 | cmdto_cnt++; |
547 | if (cmdto_cnt == 1) | 595 | if (cmdto_cnt == 1) |
548 | set_bit(MTIP_FLAG_EH_ACTIVE_BIT, &port->flags); | 596 | set_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags); |
549 | 597 | ||
550 | /* | 598 | /* |
551 | * Clear the completed bit. This should prevent | 599 | * Clear the completed bit. This should prevent |
@@ -578,15 +626,29 @@ static void mtip_timeout_function(unsigned long int data) | |||
578 | } | 626 | } |
579 | } | 627 | } |
580 | 628 | ||
581 | if (cmdto_cnt) { | 629 | if (cmdto_cnt && !test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags)) { |
582 | dev_warn(&port->dd->pdev->dev, | 630 | print_tags(port->dd, "timed out", tagaccum, cmdto_cnt); |
583 | "%d commands timed out: restarting port", | 631 | |
584 | cmdto_cnt); | ||
585 | mtip_restart_port(port); | 632 | mtip_restart_port(port); |
586 | clear_bit(MTIP_FLAG_EH_ACTIVE_BIT, &port->flags); | 633 | clear_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags); |
587 | wake_up_interruptible(&port->svc_wait); | 634 | wake_up_interruptible(&port->svc_wait); |
588 | } | 635 | } |
589 | 636 | ||
637 | if (port->ic_pause_timer) { | ||
638 | to = port->ic_pause_timer + msecs_to_jiffies(1000); | ||
639 | if (time_after(jiffies, to)) { | ||
640 | if (!test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags)) { | ||
641 | port->ic_pause_timer = 0; | ||
642 | clear_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags); | ||
643 | clear_bit(MTIP_PF_DM_ACTIVE_BIT, &port->flags); | ||
644 | clear_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags); | ||
645 | wake_up_interruptible(&port->svc_wait); | ||
646 | } | ||
647 | |||
648 | |||
649 | } | ||
650 | } | ||
651 | |||
590 | /* Restart the timer */ | 652 | /* Restart the timer */ |
591 | mod_timer(&port->cmd_timer, | 653 | mod_timer(&port->cmd_timer, |
592 | jiffies + msecs_to_jiffies(MTIP_TIMEOUT_CHECK_PERIOD)); | 654 | jiffies + msecs_to_jiffies(MTIP_TIMEOUT_CHECK_PERIOD)); |
@@ -681,23 +743,18 @@ static void mtip_completion(struct mtip_port *port, | |||
681 | complete(waiting); | 743 | complete(waiting); |
682 | } | 744 | } |
683 | 745 | ||
684 | /* | 746 | static void mtip_null_completion(struct mtip_port *port, |
685 | * Helper function for tag logging | 747 | int tag, |
686 | */ | 748 | void *data, |
687 | static void print_tags(struct driver_data *dd, | 749 | int status) |
688 | char *msg, | ||
689 | unsigned long *tagbits) | ||
690 | { | 750 | { |
691 | unsigned int tag, count = 0; | 751 | return; |
692 | |||
693 | for (tag = 0; tag < (dd->slot_groups) * 32; tag++) { | ||
694 | if (test_bit(tag, tagbits)) | ||
695 | count++; | ||
696 | } | ||
697 | if (count) | ||
698 | dev_info(&dd->pdev->dev, "%s [%i tags]\n", msg, count); | ||
699 | } | 752 | } |
700 | 753 | ||
754 | static int mtip_read_log_page(struct mtip_port *port, u8 page, u16 *buffer, | ||
755 | dma_addr_t buffer_dma, unsigned int sectors); | ||
756 | static int mtip_get_smart_attr(struct mtip_port *port, unsigned int id, | ||
757 | struct smart_attr *attrib); | ||
701 | /* | 758 | /* |
702 | * Handle an error. | 759 | * Handle an error. |
703 | * | 760 | * |
@@ -708,12 +765,16 @@ static void print_tags(struct driver_data *dd, | |||
708 | */ | 765 | */ |
709 | static void mtip_handle_tfe(struct driver_data *dd) | 766 | static void mtip_handle_tfe(struct driver_data *dd) |
710 | { | 767 | { |
711 | int group, tag, bit, reissue; | 768 | int group, tag, bit, reissue, rv; |
712 | struct mtip_port *port; | 769 | struct mtip_port *port; |
713 | struct mtip_cmd *command; | 770 | struct mtip_cmd *cmd; |
714 | u32 completed; | 771 | u32 completed; |
715 | struct host_to_dev_fis *fis; | 772 | struct host_to_dev_fis *fis; |
716 | unsigned long tagaccum[SLOTBITS_IN_LONGS]; | 773 | unsigned long tagaccum[SLOTBITS_IN_LONGS]; |
774 | unsigned int cmd_cnt = 0; | ||
775 | unsigned char *buf; | ||
776 | char *fail_reason = NULL; | ||
777 | int fail_all_ncq_write = 0, fail_all_ncq_cmds = 0; | ||
717 | 778 | ||
718 | dev_warn(&dd->pdev->dev, "Taskfile error\n"); | 779 | dev_warn(&dd->pdev->dev, "Taskfile error\n"); |
719 | 780 | ||
@@ -722,8 +783,11 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
722 | /* Stop the timer to prevent command timeouts. */ | 783 | /* Stop the timer to prevent command timeouts. */ |
723 | del_timer(&port->cmd_timer); | 784 | del_timer(&port->cmd_timer); |
724 | 785 | ||
786 | /* clear the tag accumulator */ | ||
787 | memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long)); | ||
788 | |||
725 | /* Set eh_active */ | 789 | /* Set eh_active */ |
726 | set_bit(MTIP_FLAG_EH_ACTIVE_BIT, &port->flags); | 790 | set_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags); |
727 | 791 | ||
728 | /* Loop through all the groups */ | 792 | /* Loop through all the groups */ |
729 | for (group = 0; group < dd->slot_groups; group++) { | 793 | for (group = 0; group < dd->slot_groups; group++) { |
@@ -732,9 +796,6 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
732 | /* clear completed status register in the hardware.*/ | 796 | /* clear completed status register in the hardware.*/ |
733 | writel(completed, port->completed[group]); | 797 | writel(completed, port->completed[group]); |
734 | 798 | ||
735 | /* clear the tag accumulator */ | ||
736 | memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long)); | ||
737 | |||
738 | /* Process successfully completed commands */ | 799 | /* Process successfully completed commands */ |
739 | for (bit = 0; bit < 32 && completed; bit++) { | 800 | for (bit = 0; bit < 32 && completed; bit++) { |
740 | if (!(completed & (1<<bit))) | 801 | if (!(completed & (1<<bit))) |
@@ -745,13 +806,14 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
745 | if (tag == MTIP_TAG_INTERNAL) | 806 | if (tag == MTIP_TAG_INTERNAL) |
746 | continue; | 807 | continue; |
747 | 808 | ||
748 | command = &port->commands[tag]; | 809 | cmd = &port->commands[tag]; |
749 | if (likely(command->comp_func)) { | 810 | if (likely(cmd->comp_func)) { |
750 | set_bit(tag, tagaccum); | 811 | set_bit(tag, tagaccum); |
751 | atomic_set(&port->commands[tag].active, 0); | 812 | cmd_cnt++; |
752 | command->comp_func(port, | 813 | atomic_set(&cmd->active, 0); |
814 | cmd->comp_func(port, | ||
753 | tag, | 815 | tag, |
754 | command->comp_data, | 816 | cmd->comp_data, |
755 | 0); | 817 | 0); |
756 | } else { | 818 | } else { |
757 | dev_err(&port->dd->pdev->dev, | 819 | dev_err(&port->dd->pdev->dev, |
@@ -765,12 +827,45 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
765 | } | 827 | } |
766 | } | 828 | } |
767 | } | 829 | } |
768 | print_tags(dd, "TFE tags completed:", tagaccum); | 830 | |
831 | print_tags(dd, "completed (TFE)", tagaccum, cmd_cnt); | ||
769 | 832 | ||
770 | /* Restart the port */ | 833 | /* Restart the port */ |
771 | mdelay(20); | 834 | mdelay(20); |
772 | mtip_restart_port(port); | 835 | mtip_restart_port(port); |
773 | 836 | ||
837 | /* Trying to determine the cause of the error */ | ||
838 | rv = mtip_read_log_page(dd->port, ATA_LOG_SATA_NCQ, | ||
839 | dd->port->log_buf, | ||
840 | dd->port->log_buf_dma, 1); | ||
841 | if (rv) { | ||
842 | dev_warn(&dd->pdev->dev, | ||
843 | "Error in READ LOG EXT (10h) command\n"); | ||
844 | /* non-critical error, don't fail the load */ | ||
845 | } else { | ||
846 | buf = (unsigned char *)dd->port->log_buf; | ||
847 | if (buf[259] & 0x1) { | ||
848 | dev_info(&dd->pdev->dev, | ||
849 | "Write protect bit is set.\n"); | ||
850 | set_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag); | ||
851 | fail_all_ncq_write = 1; | ||
852 | fail_reason = "write protect"; | ||
853 | } | ||
854 | if (buf[288] == 0xF7) { | ||
855 | dev_info(&dd->pdev->dev, | ||
856 | "Exceeded Tmax, drive in thermal shutdown.\n"); | ||
857 | set_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag); | ||
858 | fail_all_ncq_cmds = 1; | ||
859 | fail_reason = "thermal shutdown"; | ||
860 | } | ||
861 | if (buf[288] == 0xBF) { | ||
862 | dev_info(&dd->pdev->dev, | ||
863 | "Drive indicates rebuild has failed.\n"); | ||
864 | fail_all_ncq_cmds = 1; | ||
865 | fail_reason = "rebuild failed"; | ||
866 | } | ||
867 | } | ||
868 | |||
774 | /* clear the tag accumulator */ | 869 | /* clear the tag accumulator */ |
775 | memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long)); | 870 | memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long)); |
776 | 871 | ||
@@ -779,32 +874,47 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
779 | for (bit = 0; bit < 32; bit++) { | 874 | for (bit = 0; bit < 32; bit++) { |
780 | reissue = 1; | 875 | reissue = 1; |
781 | tag = (group << 5) + bit; | 876 | tag = (group << 5) + bit; |
877 | cmd = &port->commands[tag]; | ||
782 | 878 | ||
783 | /* If the active bit is set re-issue the command */ | 879 | /* If the active bit is set re-issue the command */ |
784 | if (atomic_read(&port->commands[tag].active) == 0) | 880 | if (atomic_read(&cmd->active) == 0) |
785 | continue; | 881 | continue; |
786 | 882 | ||
787 | fis = (struct host_to_dev_fis *) | 883 | fis = (struct host_to_dev_fis *)cmd->command; |
788 | port->commands[tag].command; | ||
789 | 884 | ||
790 | /* Should re-issue? */ | 885 | /* Should re-issue? */ |
791 | if (tag == MTIP_TAG_INTERNAL || | 886 | if (tag == MTIP_TAG_INTERNAL || |
792 | fis->command == ATA_CMD_SET_FEATURES) | 887 | fis->command == ATA_CMD_SET_FEATURES) |
793 | reissue = 0; | 888 | reissue = 0; |
889 | else { | ||
890 | if (fail_all_ncq_cmds || | ||
891 | (fail_all_ncq_write && | ||
892 | fis->command == ATA_CMD_FPDMA_WRITE)) { | ||
893 | dev_warn(&dd->pdev->dev, | ||
894 | " Fail: %s w/tag %d [%s].\n", | ||
895 | fis->command == ATA_CMD_FPDMA_WRITE ? | ||
896 | "write" : "read", | ||
897 | tag, | ||
898 | fail_reason != NULL ? | ||
899 | fail_reason : "unknown"); | ||
900 | atomic_set(&cmd->active, 0); | ||
901 | if (cmd->comp_func) { | ||
902 | cmd->comp_func(port, tag, | ||
903 | cmd->comp_data, | ||
904 | -ENODATA); | ||
905 | } | ||
906 | continue; | ||
907 | } | ||
908 | } | ||
794 | 909 | ||
795 | /* | 910 | /* |
796 | * First check if this command has | 911 | * First check if this command has |
797 | * exceeded its retries. | 912 | * exceeded its retries. |
798 | */ | 913 | */ |
799 | if (reissue && | 914 | if (reissue && (cmd->retries-- > 0)) { |
800 | (port->commands[tag].retries-- > 0)) { | ||
801 | 915 | ||
802 | set_bit(tag, tagaccum); | 916 | set_bit(tag, tagaccum); |
803 | 917 | ||
804 | /* Update the timeout value. */ | ||
805 | port->commands[tag].comp_time = | ||
806 | jiffies + msecs_to_jiffies( | ||
807 | MTIP_NCQ_COMMAND_TIMEOUT_MS); | ||
808 | /* Re-issue the command. */ | 918 | /* Re-issue the command. */ |
809 | mtip_issue_ncq_command(port, tag); | 919 | mtip_issue_ncq_command(port, tag); |
810 | 920 | ||
@@ -814,13 +924,13 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
814 | /* Retire a command that will not be reissued */ | 924 | /* Retire a command that will not be reissued */ |
815 | dev_warn(&port->dd->pdev->dev, | 925 | dev_warn(&port->dd->pdev->dev, |
816 | "retiring tag %d\n", tag); | 926 | "retiring tag %d\n", tag); |
817 | atomic_set(&port->commands[tag].active, 0); | 927 | atomic_set(&cmd->active, 0); |
818 | 928 | ||
819 | if (port->commands[tag].comp_func) | 929 | if (cmd->comp_func) |
820 | port->commands[tag].comp_func( | 930 | cmd->comp_func( |
821 | port, | 931 | port, |
822 | tag, | 932 | tag, |
823 | port->commands[tag].comp_data, | 933 | cmd->comp_data, |
824 | PORT_IRQ_TF_ERR); | 934 | PORT_IRQ_TF_ERR); |
825 | else | 935 | else |
826 | dev_warn(&port->dd->pdev->dev, | 936 | dev_warn(&port->dd->pdev->dev, |
@@ -828,10 +938,10 @@ static void mtip_handle_tfe(struct driver_data *dd) | |||
828 | tag); | 938 | tag); |
829 | } | 939 | } |
830 | } | 940 | } |
831 | print_tags(dd, "TFE tags reissued:", tagaccum); | 941 | print_tags(dd, "reissued (TFE)", tagaccum, cmd_cnt); |
832 | 942 | ||
833 | /* clear eh_active */ | 943 | /* clear eh_active */ |
834 | clear_bit(MTIP_FLAG_EH_ACTIVE_BIT, &port->flags); | 944 | clear_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags); |
835 | wake_up_interruptible(&port->svc_wait); | 945 | wake_up_interruptible(&port->svc_wait); |
836 | 946 | ||
837 | mod_timer(&port->cmd_timer, | 947 | mod_timer(&port->cmd_timer, |
@@ -899,7 +1009,7 @@ static inline void mtip_process_legacy(struct driver_data *dd, u32 port_stat) | |||
899 | struct mtip_port *port = dd->port; | 1009 | struct mtip_port *port = dd->port; |
900 | struct mtip_cmd *cmd = &port->commands[MTIP_TAG_INTERNAL]; | 1010 | struct mtip_cmd *cmd = &port->commands[MTIP_TAG_INTERNAL]; |
901 | 1011 | ||
902 | if (test_bit(MTIP_FLAG_IC_ACTIVE_BIT, &port->flags) && | 1012 | if (test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags) && |
903 | (cmd != NULL) && !(readl(port->cmd_issue[MTIP_TAG_INTERNAL]) | 1013 | (cmd != NULL) && !(readl(port->cmd_issue[MTIP_TAG_INTERNAL]) |
904 | & (1 << MTIP_TAG_INTERNAL))) { | 1014 | & (1 << MTIP_TAG_INTERNAL))) { |
905 | if (cmd->comp_func) { | 1015 | if (cmd->comp_func) { |
@@ -911,8 +1021,6 @@ static inline void mtip_process_legacy(struct driver_data *dd, u32 port_stat) | |||
911 | } | 1021 | } |
912 | } | 1022 | } |
913 | 1023 | ||
914 | dev_warn(&dd->pdev->dev, "IRQ status 0x%x ignored.\n", port_stat); | ||
915 | |||
916 | return; | 1024 | return; |
917 | } | 1025 | } |
918 | 1026 | ||
@@ -968,6 +1076,9 @@ static inline irqreturn_t mtip_handle_irq(struct driver_data *data) | |||
968 | /* don't proceed further */ | 1076 | /* don't proceed further */ |
969 | return IRQ_HANDLED; | 1077 | return IRQ_HANDLED; |
970 | } | 1078 | } |
1079 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
1080 | &dd->dd_flag)) | ||
1081 | return rv; | ||
971 | 1082 | ||
972 | mtip_process_errors(dd, port_stat & PORT_IRQ_ERR); | 1083 | mtip_process_errors(dd, port_stat & PORT_IRQ_ERR); |
973 | } | 1084 | } |
@@ -1015,6 +1126,39 @@ static void mtip_issue_non_ncq_command(struct mtip_port *port, int tag) | |||
1015 | port->cmd_issue[MTIP_TAG_INDEX(tag)]); | 1126 | port->cmd_issue[MTIP_TAG_INDEX(tag)]); |
1016 | } | 1127 | } |
1017 | 1128 | ||
1129 | static bool mtip_pause_ncq(struct mtip_port *port, | ||
1130 | struct host_to_dev_fis *fis) | ||
1131 | { | ||
1132 | struct host_to_dev_fis *reply; | ||
1133 | unsigned long task_file_data; | ||
1134 | |||
1135 | reply = port->rxfis + RX_FIS_D2H_REG; | ||
1136 | task_file_data = readl(port->mmio+PORT_TFDATA); | ||
1137 | |||
1138 | if ((task_file_data & 1) || (fis->command == ATA_CMD_SEC_ERASE_UNIT)) | ||
1139 | return false; | ||
1140 | |||
1141 | if (fis->command == ATA_CMD_SEC_ERASE_PREP) { | ||
1142 | set_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags); | ||
1143 | port->ic_pause_timer = jiffies; | ||
1144 | return true; | ||
1145 | } else if ((fis->command == ATA_CMD_DOWNLOAD_MICRO) && | ||
1146 | (fis->features == 0x03)) { | ||
1147 | set_bit(MTIP_PF_DM_ACTIVE_BIT, &port->flags); | ||
1148 | port->ic_pause_timer = jiffies; | ||
1149 | return true; | ||
1150 | } else if ((fis->command == ATA_CMD_SEC_ERASE_UNIT) || | ||
1151 | ((fis->command == 0xFC) && | ||
1152 | (fis->features == 0x27 || fis->features == 0x72 || | ||
1153 | fis->features == 0x62 || fis->features == 0x26))) { | ||
1154 | /* Com reset after secure erase or lowlevel format */ | ||
1155 | mtip_restart_port(port); | ||
1156 | return false; | ||
1157 | } | ||
1158 | |||
1159 | return false; | ||
1160 | } | ||
1161 | |||
1018 | /* | 1162 | /* |
1019 | * Wait for port to quiesce | 1163 | * Wait for port to quiesce |
1020 | * | 1164 | * |
@@ -1033,11 +1177,13 @@ static int mtip_quiesce_io(struct mtip_port *port, unsigned long timeout) | |||
1033 | 1177 | ||
1034 | to = jiffies + msecs_to_jiffies(timeout); | 1178 | to = jiffies + msecs_to_jiffies(timeout); |
1035 | do { | 1179 | do { |
1036 | if (test_bit(MTIP_FLAG_SVC_THD_ACTIVE_BIT, &port->flags) && | 1180 | if (test_bit(MTIP_PF_SVC_THD_ACTIVE_BIT, &port->flags) && |
1037 | test_bit(MTIP_FLAG_ISSUE_CMDS_BIT, &port->flags)) { | 1181 | test_bit(MTIP_PF_ISSUE_CMDS_BIT, &port->flags)) { |
1038 | msleep(20); | 1182 | msleep(20); |
1039 | continue; /* svc thd is actively issuing commands */ | 1183 | continue; /* svc thd is actively issuing commands */ |
1040 | } | 1184 | } |
1185 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &port->dd->dd_flag)) | ||
1186 | return -EFAULT; | ||
1041 | /* | 1187 | /* |
1042 | * Ignore s_active bit 0 of array element 0. | 1188 | * Ignore s_active bit 0 of array element 0. |
1043 | * This bit will always be set | 1189 | * This bit will always be set |
@@ -1074,7 +1220,7 @@ static int mtip_quiesce_io(struct mtip_port *port, unsigned long timeout) | |||
1074 | * -EAGAIN Time out waiting for command to complete. | 1220 | * -EAGAIN Time out waiting for command to complete. |
1075 | */ | 1221 | */ |
1076 | static int mtip_exec_internal_command(struct mtip_port *port, | 1222 | static int mtip_exec_internal_command(struct mtip_port *port, |
1077 | void *fis, | 1223 | struct host_to_dev_fis *fis, |
1078 | int fis_len, | 1224 | int fis_len, |
1079 | dma_addr_t buffer, | 1225 | dma_addr_t buffer, |
1080 | int buf_len, | 1226 | int buf_len, |
@@ -1084,8 +1230,9 @@ static int mtip_exec_internal_command(struct mtip_port *port, | |||
1084 | { | 1230 | { |
1085 | struct mtip_cmd_sg *command_sg; | 1231 | struct mtip_cmd_sg *command_sg; |
1086 | DECLARE_COMPLETION_ONSTACK(wait); | 1232 | DECLARE_COMPLETION_ONSTACK(wait); |
1087 | int rv = 0; | 1233 | int rv = 0, ready2go = 1; |
1088 | struct mtip_cmd *int_cmd = &port->commands[MTIP_TAG_INTERNAL]; | 1234 | struct mtip_cmd *int_cmd = &port->commands[MTIP_TAG_INTERNAL]; |
1235 | unsigned long to; | ||
1089 | 1236 | ||
1090 | /* Make sure the buffer is 8 byte aligned. This is asic specific. */ | 1237 | /* Make sure the buffer is 8 byte aligned. This is asic specific. */ |
1091 | if (buffer & 0x00000007) { | 1238 | if (buffer & 0x00000007) { |
@@ -1094,23 +1241,38 @@ static int mtip_exec_internal_command(struct mtip_port *port, | |||
1094 | return -EFAULT; | 1241 | return -EFAULT; |
1095 | } | 1242 | } |
1096 | 1243 | ||
1097 | /* Only one internal command should be running at a time */ | 1244 | to = jiffies + msecs_to_jiffies(timeout); |
1098 | if (test_and_set_bit(MTIP_TAG_INTERNAL, port->allocated)) { | 1245 | do { |
1246 | ready2go = !test_and_set_bit(MTIP_TAG_INTERNAL, | ||
1247 | port->allocated); | ||
1248 | if (ready2go) | ||
1249 | break; | ||
1250 | mdelay(100); | ||
1251 | } while (time_before(jiffies, to)); | ||
1252 | if (!ready2go) { | ||
1099 | dev_warn(&port->dd->pdev->dev, | 1253 | dev_warn(&port->dd->pdev->dev, |
1100 | "Internal command already active\n"); | 1254 | "Internal cmd active. new cmd [%02X]\n", fis->command); |
1101 | return -EBUSY; | 1255 | return -EBUSY; |
1102 | } | 1256 | } |
1103 | set_bit(MTIP_FLAG_IC_ACTIVE_BIT, &port->flags); | 1257 | set_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags); |
1258 | port->ic_pause_timer = 0; | ||
1259 | |||
1260 | if (fis->command == ATA_CMD_SEC_ERASE_UNIT) | ||
1261 | clear_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags); | ||
1262 | else if (fis->command == ATA_CMD_DOWNLOAD_MICRO) | ||
1263 | clear_bit(MTIP_PF_DM_ACTIVE_BIT, &port->flags); | ||
1104 | 1264 | ||
1105 | if (atomic == GFP_KERNEL) { | 1265 | if (atomic == GFP_KERNEL) { |
1106 | /* wait for io to complete if non atomic */ | 1266 | if (fis->command != ATA_CMD_STANDBYNOW1) { |
1107 | if (mtip_quiesce_io(port, 5000) < 0) { | 1267 | /* wait for io to complete if non atomic */ |
1108 | dev_warn(&port->dd->pdev->dev, | 1268 | if (mtip_quiesce_io(port, 5000) < 0) { |
1109 | "Failed to quiesce IO\n"); | 1269 | dev_warn(&port->dd->pdev->dev, |
1110 | release_slot(port, MTIP_TAG_INTERNAL); | 1270 | "Failed to quiesce IO\n"); |
1111 | clear_bit(MTIP_FLAG_IC_ACTIVE_BIT, &port->flags); | 1271 | release_slot(port, MTIP_TAG_INTERNAL); |
1112 | wake_up_interruptible(&port->svc_wait); | 1272 | clear_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags); |
1113 | return -EBUSY; | 1273 | wake_up_interruptible(&port->svc_wait); |
1274 | return -EBUSY; | ||
1275 | } | ||
1114 | } | 1276 | } |
1115 | 1277 | ||
1116 | /* Set the completion function and data for the command. */ | 1278 | /* Set the completion function and data for the command. */ |
@@ -1120,7 +1282,7 @@ static int mtip_exec_internal_command(struct mtip_port *port, | |||
1120 | } else { | 1282 | } else { |
1121 | /* Clear completion - we're going to poll */ | 1283 | /* Clear completion - we're going to poll */ |
1122 | int_cmd->comp_data = NULL; | 1284 | int_cmd->comp_data = NULL; |
1123 | int_cmd->comp_func = NULL; | 1285 | int_cmd->comp_func = mtip_null_completion; |
1124 | } | 1286 | } |
1125 | 1287 | ||
1126 | /* Copy the command to the command table */ | 1288 | /* Copy the command to the command table */ |
@@ -1159,6 +1321,12 @@ static int mtip_exec_internal_command(struct mtip_port *port, | |||
1159 | "Internal command did not complete [%d] " | 1321 | "Internal command did not complete [%d] " |
1160 | "within timeout of %lu ms\n", | 1322 | "within timeout of %lu ms\n", |
1161 | atomic, timeout); | 1323 | atomic, timeout); |
1324 | if (mtip_check_surprise_removal(port->dd->pdev) || | ||
1325 | test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
1326 | &port->dd->dd_flag)) { | ||
1327 | rv = -ENXIO; | ||
1328 | goto exec_ic_exit; | ||
1329 | } | ||
1162 | rv = -EAGAIN; | 1330 | rv = -EAGAIN; |
1163 | } | 1331 | } |
1164 | 1332 | ||
@@ -1166,31 +1334,59 @@ static int mtip_exec_internal_command(struct mtip_port *port, | |||
1166 | & (1 << MTIP_TAG_INTERNAL)) { | 1334 | & (1 << MTIP_TAG_INTERNAL)) { |
1167 | dev_warn(&port->dd->pdev->dev, | 1335 | dev_warn(&port->dd->pdev->dev, |
1168 | "Retiring internal command but CI is 1.\n"); | 1336 | "Retiring internal command but CI is 1.\n"); |
1337 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
1338 | &port->dd->dd_flag)) { | ||
1339 | hba_reset_nosleep(port->dd); | ||
1340 | rv = -ENXIO; | ||
1341 | } else { | ||
1342 | mtip_restart_port(port); | ||
1343 | rv = -EAGAIN; | ||
1344 | } | ||
1345 | goto exec_ic_exit; | ||
1169 | } | 1346 | } |
1170 | 1347 | ||
1171 | } else { | 1348 | } else { |
1172 | /* Spin for <timeout> checking if command still outstanding */ | 1349 | /* Spin for <timeout> checking if command still outstanding */ |
1173 | timeout = jiffies + msecs_to_jiffies(timeout); | 1350 | timeout = jiffies + msecs_to_jiffies(timeout); |
1174 | 1351 | while ((readl(port->cmd_issue[MTIP_TAG_INTERNAL]) | |
1175 | while ((readl( | 1352 | & (1 << MTIP_TAG_INTERNAL)) |
1176 | port->cmd_issue[MTIP_TAG_INTERNAL]) | 1353 | && time_before(jiffies, timeout)) { |
1177 | & (1 << MTIP_TAG_INTERNAL)) | 1354 | if (mtip_check_surprise_removal(port->dd->pdev)) { |
1178 | && time_before(jiffies, timeout)) | 1355 | rv = -ENXIO; |
1179 | ; | 1356 | goto exec_ic_exit; |
1357 | } | ||
1358 | if ((fis->command != ATA_CMD_STANDBYNOW1) && | ||
1359 | test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
1360 | &port->dd->dd_flag)) { | ||
1361 | rv = -ENXIO; | ||
1362 | goto exec_ic_exit; | ||
1363 | } | ||
1364 | } | ||
1180 | 1365 | ||
1181 | if (readl(port->cmd_issue[MTIP_TAG_INTERNAL]) | 1366 | if (readl(port->cmd_issue[MTIP_TAG_INTERNAL]) |
1182 | & (1 << MTIP_TAG_INTERNAL)) { | 1367 | & (1 << MTIP_TAG_INTERNAL)) { |
1183 | dev_err(&port->dd->pdev->dev, | 1368 | dev_err(&port->dd->pdev->dev, |
1184 | "Internal command did not complete [%d]\n", | 1369 | "Internal command did not complete [atomic]\n"); |
1185 | atomic); | ||
1186 | rv = -EAGAIN; | 1370 | rv = -EAGAIN; |
1371 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
1372 | &port->dd->dd_flag)) { | ||
1373 | hba_reset_nosleep(port->dd); | ||
1374 | rv = -ENXIO; | ||
1375 | } else { | ||
1376 | mtip_restart_port(port); | ||
1377 | rv = -EAGAIN; | ||
1378 | } | ||
1187 | } | 1379 | } |
1188 | } | 1380 | } |
1189 | 1381 | exec_ic_exit: | |
1190 | /* Clear the allocated and active bits for the internal command. */ | 1382 | /* Clear the allocated and active bits for the internal command. */ |
1191 | atomic_set(&int_cmd->active, 0); | 1383 | atomic_set(&int_cmd->active, 0); |
1192 | release_slot(port, MTIP_TAG_INTERNAL); | 1384 | release_slot(port, MTIP_TAG_INTERNAL); |
1193 | clear_bit(MTIP_FLAG_IC_ACTIVE_BIT, &port->flags); | 1385 | if (rv >= 0 && mtip_pause_ncq(port, fis)) { |
1386 | /* NCQ paused */ | ||
1387 | return rv; | ||
1388 | } | ||
1389 | clear_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags); | ||
1194 | wake_up_interruptible(&port->svc_wait); | 1390 | wake_up_interruptible(&port->svc_wait); |
1195 | 1391 | ||
1196 | return rv; | 1392 | return rv; |
@@ -1240,6 +1436,9 @@ static int mtip_get_identify(struct mtip_port *port, void __user *user_buffer) | |||
1240 | int rv = 0; | 1436 | int rv = 0; |
1241 | struct host_to_dev_fis fis; | 1437 | struct host_to_dev_fis fis; |
1242 | 1438 | ||
1439 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &port->dd->dd_flag)) | ||
1440 | return -EFAULT; | ||
1441 | |||
1243 | /* Build the FIS. */ | 1442 | /* Build the FIS. */ |
1244 | memset(&fis, 0, sizeof(struct host_to_dev_fis)); | 1443 | memset(&fis, 0, sizeof(struct host_to_dev_fis)); |
1245 | fis.type = 0x27; | 1444 | fis.type = 0x27; |
@@ -1313,6 +1512,7 @@ static int mtip_standby_immediate(struct mtip_port *port) | |||
1313 | { | 1512 | { |
1314 | int rv; | 1513 | int rv; |
1315 | struct host_to_dev_fis fis; | 1514 | struct host_to_dev_fis fis; |
1515 | unsigned long start; | ||
1316 | 1516 | ||
1317 | /* Build the FIS. */ | 1517 | /* Build the FIS. */ |
1318 | memset(&fis, 0, sizeof(struct host_to_dev_fis)); | 1518 | memset(&fis, 0, sizeof(struct host_to_dev_fis)); |
@@ -1320,15 +1520,150 @@ static int mtip_standby_immediate(struct mtip_port *port) | |||
1320 | fis.opts = 1 << 7; | 1520 | fis.opts = 1 << 7; |
1321 | fis.command = ATA_CMD_STANDBYNOW1; | 1521 | fis.command = ATA_CMD_STANDBYNOW1; |
1322 | 1522 | ||
1323 | /* Execute the command. Use a 15-second timeout for large drives. */ | 1523 | start = jiffies; |
1324 | rv = mtip_exec_internal_command(port, | 1524 | rv = mtip_exec_internal_command(port, |
1325 | &fis, | 1525 | &fis, |
1326 | 5, | 1526 | 5, |
1327 | 0, | 1527 | 0, |
1328 | 0, | 1528 | 0, |
1329 | 0, | 1529 | 0, |
1330 | GFP_KERNEL, | 1530 | GFP_ATOMIC, |
1331 | 15000); | 1531 | 15000); |
1532 | dbg_printk(MTIP_DRV_NAME "Time taken to complete standby cmd: %d ms\n", | ||
1533 | jiffies_to_msecs(jiffies - start)); | ||
1534 | if (rv) | ||
1535 | dev_warn(&port->dd->pdev->dev, | ||
1536 | "STANDBY IMMEDIATE command failed.\n"); | ||
1537 | |||
1538 | return rv; | ||
1539 | } | ||
1540 | |||
1541 | /* | ||
1542 | * Issue a READ LOG EXT command to the device. | ||
1543 | * | ||
1544 | * @port pointer to the port structure. | ||
1545 | * @page page number to fetch | ||
1546 | * @buffer pointer to buffer | ||
1547 | * @buffer_dma dma address corresponding to @buffer | ||
1548 | * @sectors page length to fetch, in sectors | ||
1549 | * | ||
1550 | * return value | ||
1551 | * @rv return value from mtip_exec_internal_command() | ||
1552 | */ | ||
1553 | static int mtip_read_log_page(struct mtip_port *port, u8 page, u16 *buffer, | ||
1554 | dma_addr_t buffer_dma, unsigned int sectors) | ||
1555 | { | ||
1556 | struct host_to_dev_fis fis; | ||
1557 | |||
1558 | memset(&fis, 0, sizeof(struct host_to_dev_fis)); | ||
1559 | fis.type = 0x27; | ||
1560 | fis.opts = 1 << 7; | ||
1561 | fis.command = ATA_CMD_READ_LOG_EXT; | ||
1562 | fis.sect_count = sectors & 0xFF; | ||
1563 | fis.sect_cnt_ex = (sectors >> 8) & 0xFF; | ||
1564 | fis.lba_low = page; | ||
1565 | fis.lba_mid = 0; | ||
1566 | fis.device = ATA_DEVICE_OBS; | ||
1567 | |||
1568 | memset(buffer, 0, sectors * ATA_SECT_SIZE); | ||
1569 | |||
1570 | return mtip_exec_internal_command(port, | ||
1571 | &fis, | ||
1572 | 5, | ||
1573 | buffer_dma, | ||
1574 | sectors * ATA_SECT_SIZE, | ||
1575 | 0, | ||
1576 | GFP_ATOMIC, | ||
1577 | MTIP_INTERNAL_COMMAND_TIMEOUT_MS); | ||
1578 | } | ||
1579 | |||
1580 | /* | ||
1581 | * Issue a SMART READ DATA command to the device. | ||
1582 | * | ||
1583 | * @port pointer to the port structure. | ||
1584 | * @buffer pointer to buffer | ||
1585 | * @buffer_dma dma address corresponding to @buffer | ||
1586 | * | ||
1587 | * return value | ||
1588 | * @rv return value from mtip_exec_internal_command() | ||
1589 | */ | ||
1590 | static int mtip_get_smart_data(struct mtip_port *port, u8 *buffer, | ||
1591 | dma_addr_t buffer_dma) | ||
1592 | { | ||
1593 | struct host_to_dev_fis fis; | ||
1594 | |||
1595 | memset(&fis, 0, sizeof(struct host_to_dev_fis)); | ||
1596 | fis.type = 0x27; | ||
1597 | fis.opts = 1 << 7; | ||
1598 | fis.command = ATA_CMD_SMART; | ||
1599 | fis.features = 0xD0; | ||
1600 | fis.sect_count = 1; | ||
1601 | fis.lba_mid = 0x4F; | ||
1602 | fis.lba_hi = 0xC2; | ||
1603 | fis.device = ATA_DEVICE_OBS; | ||
1604 | |||
1605 | return mtip_exec_internal_command(port, | ||
1606 | &fis, | ||
1607 | 5, | ||
1608 | buffer_dma, | ||
1609 | ATA_SECT_SIZE, | ||
1610 | 0, | ||
1611 | GFP_ATOMIC, | ||
1612 | 15000); | ||
1613 | } | ||
1614 | |||
1615 | /* | ||
1616 | * Get the value of a smart attribute | ||
1617 | * | ||
1618 | * @port pointer to the port structure | ||
1619 | * @id attribute number | ||
1620 | * @attrib pointer to return attrib information corresponding to @id | ||
1621 | * | ||
1622 | * return value | ||
1623 | * -EINVAL NULL buffer passed or unsupported attribute @id. | ||
1624 | * -EPERM Identify data not valid, SMART not supported or not enabled | ||
1625 | */ | ||
1626 | static int mtip_get_smart_attr(struct mtip_port *port, unsigned int id, | ||
1627 | struct smart_attr *attrib) | ||
1628 | { | ||
1629 | int rv, i; | ||
1630 | struct smart_attr *pattr; | ||
1631 | |||
1632 | if (!attrib) | ||
1633 | return -EINVAL; | ||
1634 | |||
1635 | if (!port->identify_valid) { | ||
1636 | dev_warn(&port->dd->pdev->dev, "IDENTIFY DATA not valid\n"); | ||
1637 | return -EPERM; | ||
1638 | } | ||
1639 | if (!(port->identify[82] & 0x1)) { | ||
1640 | dev_warn(&port->dd->pdev->dev, "SMART not supported\n"); | ||
1641 | return -EPERM; | ||
1642 | } | ||
1643 | if (!(port->identify[85] & 0x1)) { | ||
1644 | dev_warn(&port->dd->pdev->dev, "SMART not enabled\n"); | ||
1645 | return -EPERM; | ||
1646 | } | ||
1647 | |||
1648 | memset(port->smart_buf, 0, ATA_SECT_SIZE); | ||
1649 | rv = mtip_get_smart_data(port, port->smart_buf, port->smart_buf_dma); | ||
1650 | if (rv) { | ||
1651 | dev_warn(&port->dd->pdev->dev, "Failed to ge SMART data\n"); | ||
1652 | return rv; | ||
1653 | } | ||
1654 | |||
1655 | pattr = (struct smart_attr *)(port->smart_buf + 2); | ||
1656 | for (i = 0; i < 29; i++, pattr++) | ||
1657 | if (pattr->attr_id == id) { | ||
1658 | memcpy(attrib, pattr, sizeof(struct smart_attr)); | ||
1659 | break; | ||
1660 | } | ||
1661 | |||
1662 | if (i == 29) { | ||
1663 | dev_warn(&port->dd->pdev->dev, | ||
1664 | "Query for invalid SMART attribute ID\n"); | ||
1665 | rv = -EINVAL; | ||
1666 | } | ||
1332 | 1667 | ||
1333 | return rv; | 1668 | return rv; |
1334 | } | 1669 | } |
@@ -1504,10 +1839,7 @@ static int exec_drive_task(struct mtip_port *port, u8 *command) | |||
1504 | fis.cyl_hi = command[5]; | 1839 | fis.cyl_hi = command[5]; |
1505 | fis.device = command[6] & ~0x10; /* Clear the dev bit*/ | 1840 | fis.device = command[6] & ~0x10; /* Clear the dev bit*/ |
1506 | 1841 | ||
1507 | 1842 | dbg_printk(MTIP_DRV_NAME " %s: User Command: cmd %x, feat %x, nsect %x, sect %x, lcyl %x, hcyl %x, sel %x\n", | |
1508 | dbg_printk(MTIP_DRV_NAME "%s: User Command: cmd %x, feat %x, " | ||
1509 | "nsect %x, sect %x, lcyl %x, " | ||
1510 | "hcyl %x, sel %x\n", | ||
1511 | __func__, | 1843 | __func__, |
1512 | command[0], | 1844 | command[0], |
1513 | command[1], | 1845 | command[1], |
@@ -1534,8 +1866,7 @@ static int exec_drive_task(struct mtip_port *port, u8 *command) | |||
1534 | command[4] = reply->cyl_low; | 1866 | command[4] = reply->cyl_low; |
1535 | command[5] = reply->cyl_hi; | 1867 | command[5] = reply->cyl_hi; |
1536 | 1868 | ||
1537 | dbg_printk(MTIP_DRV_NAME "%s: Completion Status: stat %x, " | 1869 | dbg_printk(MTIP_DRV_NAME " %s: Completion Status: stat %x, err %x , cyl_lo %x cyl_hi %x\n", |
1538 | "err %x , cyl_lo %x cyl_hi %x\n", | ||
1539 | __func__, | 1870 | __func__, |
1540 | command[0], | 1871 | command[0], |
1541 | command[1], | 1872 | command[1], |
@@ -1578,7 +1909,7 @@ static int exec_drive_command(struct mtip_port *port, u8 *command, | |||
1578 | } | 1909 | } |
1579 | 1910 | ||
1580 | dbg_printk(MTIP_DRV_NAME | 1911 | dbg_printk(MTIP_DRV_NAME |
1581 | "%s: User Command: cmd %x, sect %x, " | 1912 | " %s: User Command: cmd %x, sect %x, " |
1582 | "feat %x, sectcnt %x\n", | 1913 | "feat %x, sectcnt %x\n", |
1583 | __func__, | 1914 | __func__, |
1584 | command[0], | 1915 | command[0], |
@@ -1607,7 +1938,7 @@ static int exec_drive_command(struct mtip_port *port, u8 *command, | |||
1607 | command[2] = command[3]; | 1938 | command[2] = command[3]; |
1608 | 1939 | ||
1609 | dbg_printk(MTIP_DRV_NAME | 1940 | dbg_printk(MTIP_DRV_NAME |
1610 | "%s: Completion Status: stat %x, " | 1941 | " %s: Completion Status: stat %x, " |
1611 | "err %x, cmd %x\n", | 1942 | "err %x, cmd %x\n", |
1612 | __func__, | 1943 | __func__, |
1613 | command[0], | 1944 | command[0], |
@@ -1810,9 +2141,10 @@ static int exec_drive_taskfile(struct driver_data *dd, | |||
1810 | } | 2141 | } |
1811 | 2142 | ||
1812 | dbg_printk(MTIP_DRV_NAME | 2143 | dbg_printk(MTIP_DRV_NAME |
1813 | "taskfile: cmd %x, feat %x, nsect %x," | 2144 | " %s: cmd %x, feat %x, nsect %x," |
1814 | " sect/lbal %x, lcyl/lbam %x, hcyl/lbah %x," | 2145 | " sect/lbal %x, lcyl/lbam %x, hcyl/lbah %x," |
1815 | " head/dev %x\n", | 2146 | " head/dev %x\n", |
2147 | __func__, | ||
1816 | fis.command, | 2148 | fis.command, |
1817 | fis.features, | 2149 | fis.features, |
1818 | fis.sect_count, | 2150 | fis.sect_count, |
@@ -1823,8 +2155,8 @@ static int exec_drive_taskfile(struct driver_data *dd, | |||
1823 | 2155 | ||
1824 | switch (fis.command) { | 2156 | switch (fis.command) { |
1825 | case ATA_CMD_DOWNLOAD_MICRO: | 2157 | case ATA_CMD_DOWNLOAD_MICRO: |
1826 | /* Change timeout for Download Microcode to 60 seconds.*/ | 2158 | /* Change timeout for Download Microcode to 2 minutes */ |
1827 | timeout = 60000; | 2159 | timeout = 120000; |
1828 | break; | 2160 | break; |
1829 | case ATA_CMD_SEC_ERASE_UNIT: | 2161 | case ATA_CMD_SEC_ERASE_UNIT: |
1830 | /* Change timeout for Security Erase Unit to 4 minutes.*/ | 2162 | /* Change timeout for Security Erase Unit to 4 minutes.*/ |
@@ -1840,8 +2172,8 @@ static int exec_drive_taskfile(struct driver_data *dd, | |||
1840 | timeout = 10000; | 2172 | timeout = 10000; |
1841 | break; | 2173 | break; |
1842 | case ATA_CMD_SMART: | 2174 | case ATA_CMD_SMART: |
1843 | /* Change timeout for vendor unique command to 10 secs */ | 2175 | /* Change timeout for vendor unique command to 15 secs */ |
1844 | timeout = 10000; | 2176 | timeout = 15000; |
1845 | break; | 2177 | break; |
1846 | default: | 2178 | default: |
1847 | timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS; | 2179 | timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS; |
@@ -1903,18 +2235,8 @@ static int exec_drive_taskfile(struct driver_data *dd, | |||
1903 | req_task->hob_ports[1] = reply->features_ex; | 2235 | req_task->hob_ports[1] = reply->features_ex; |
1904 | req_task->hob_ports[2] = reply->sect_cnt_ex; | 2236 | req_task->hob_ports[2] = reply->sect_cnt_ex; |
1905 | } | 2237 | } |
1906 | |||
1907 | /* Com rest after secure erase or lowlevel format */ | ||
1908 | if (((fis.command == ATA_CMD_SEC_ERASE_UNIT) || | ||
1909 | ((fis.command == 0xFC) && | ||
1910 | (fis.features == 0x27 || fis.features == 0x72 || | ||
1911 | fis.features == 0x62 || fis.features == 0x26))) && | ||
1912 | !(reply->command & 1)) { | ||
1913 | mtip_restart_port(dd->port); | ||
1914 | } | ||
1915 | |||
1916 | dbg_printk(MTIP_DRV_NAME | 2238 | dbg_printk(MTIP_DRV_NAME |
1917 | "%s: Completion: stat %x," | 2239 | " %s: Completion: stat %x," |
1918 | "err %x, sect_cnt %x, lbalo %x," | 2240 | "err %x, sect_cnt %x, lbalo %x," |
1919 | "lbamid %x, lbahi %x, dev %x\n", | 2241 | "lbamid %x, lbahi %x, dev %x\n", |
1920 | __func__, | 2242 | __func__, |
@@ -2080,14 +2402,10 @@ static void mtip_hw_submit_io(struct driver_data *dd, sector_t start, | |||
2080 | struct host_to_dev_fis *fis; | 2402 | struct host_to_dev_fis *fis; |
2081 | struct mtip_port *port = dd->port; | 2403 | struct mtip_port *port = dd->port; |
2082 | struct mtip_cmd *command = &port->commands[tag]; | 2404 | struct mtip_cmd *command = &port->commands[tag]; |
2405 | int dma_dir = (dir == READ) ? DMA_FROM_DEVICE : DMA_TO_DEVICE; | ||
2083 | 2406 | ||
2084 | /* Map the scatter list for DMA access */ | 2407 | /* Map the scatter list for DMA access */ |
2085 | if (dir == READ) | 2408 | nents = dma_map_sg(&dd->pdev->dev, command->sg, nents, dma_dir); |
2086 | nents = dma_map_sg(&dd->pdev->dev, command->sg, | ||
2087 | nents, DMA_FROM_DEVICE); | ||
2088 | else | ||
2089 | nents = dma_map_sg(&dd->pdev->dev, command->sg, | ||
2090 | nents, DMA_TO_DEVICE); | ||
2091 | 2409 | ||
2092 | command->scatter_ents = nents; | 2410 | command->scatter_ents = nents; |
2093 | 2411 | ||
@@ -2127,7 +2445,7 @@ static void mtip_hw_submit_io(struct driver_data *dd, sector_t start, | |||
2127 | */ | 2445 | */ |
2128 | command->comp_data = dd; | 2446 | command->comp_data = dd; |
2129 | command->comp_func = mtip_async_complete; | 2447 | command->comp_func = mtip_async_complete; |
2130 | command->direction = (dir == READ ? DMA_FROM_DEVICE : DMA_TO_DEVICE); | 2448 | command->direction = dma_dir; |
2131 | 2449 | ||
2132 | /* | 2450 | /* |
2133 | * Set the completion function and data for the command passed | 2451 | * Set the completion function and data for the command passed |
@@ -2140,19 +2458,16 @@ static void mtip_hw_submit_io(struct driver_data *dd, sector_t start, | |||
2140 | * To prevent this command from being issued | 2458 | * To prevent this command from being issued |
2141 | * if an internal command is in progress or error handling is active. | 2459 | * if an internal command is in progress or error handling is active. |
2142 | */ | 2460 | */ |
2143 | if (unlikely(test_bit(MTIP_FLAG_IC_ACTIVE_BIT, &port->flags) || | 2461 | if (port->flags & MTIP_PF_PAUSE_IO) { |
2144 | test_bit(MTIP_FLAG_EH_ACTIVE_BIT, &port->flags))) { | ||
2145 | set_bit(tag, port->cmds_to_issue); | 2462 | set_bit(tag, port->cmds_to_issue); |
2146 | set_bit(MTIP_FLAG_ISSUE_CMDS_BIT, &port->flags); | 2463 | set_bit(MTIP_PF_ISSUE_CMDS_BIT, &port->flags); |
2147 | return; | 2464 | return; |
2148 | } | 2465 | } |
2149 | 2466 | ||
2150 | /* Issue the command to the hardware */ | 2467 | /* Issue the command to the hardware */ |
2151 | mtip_issue_ncq_command(port, tag); | 2468 | mtip_issue_ncq_command(port, tag); |
2152 | 2469 | ||
2153 | /* Set the command's timeout value.*/ | 2470 | return; |
2154 | port->commands[tag].comp_time = jiffies + msecs_to_jiffies( | ||
2155 | MTIP_NCQ_COMMAND_TIMEOUT_MS); | ||
2156 | } | 2471 | } |
2157 | 2472 | ||
2158 | /* | 2473 | /* |
@@ -2191,6 +2506,10 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd, | |||
2191 | down(&dd->port->cmd_slot); | 2506 | down(&dd->port->cmd_slot); |
2192 | *tag = get_slot(dd->port); | 2507 | *tag = get_slot(dd->port); |
2193 | 2508 | ||
2509 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag))) { | ||
2510 | up(&dd->port->cmd_slot); | ||
2511 | return NULL; | ||
2512 | } | ||
2194 | if (unlikely(*tag < 0)) | 2513 | if (unlikely(*tag < 0)) |
2195 | return NULL; | 2514 | return NULL; |
2196 | 2515 | ||
@@ -2207,7 +2526,7 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd, | |||
2207 | * return value | 2526 | * return value |
2208 | * The size, in bytes, of the data copied into buf. | 2527 | * The size, in bytes, of the data copied into buf. |
2209 | */ | 2528 | */ |
2210 | static ssize_t hw_show_registers(struct device *dev, | 2529 | static ssize_t mtip_hw_show_registers(struct device *dev, |
2211 | struct device_attribute *attr, | 2530 | struct device_attribute *attr, |
2212 | char *buf) | 2531 | char *buf) |
2213 | { | 2532 | { |
@@ -2216,7 +2535,7 @@ static ssize_t hw_show_registers(struct device *dev, | |||
2216 | int size = 0; | 2535 | int size = 0; |
2217 | int n; | 2536 | int n; |
2218 | 2537 | ||
2219 | size += sprintf(&buf[size], "%s:\ns_active:\n", __func__); | 2538 | size += sprintf(&buf[size], "S ACTive:\n"); |
2220 | 2539 | ||
2221 | for (n = 0; n < dd->slot_groups; n++) | 2540 | for (n = 0; n < dd->slot_groups; n++) |
2222 | size += sprintf(&buf[size], "0x%08x\n", | 2541 | size += sprintf(&buf[size], "0x%08x\n", |
@@ -2240,20 +2559,39 @@ static ssize_t hw_show_registers(struct device *dev, | |||
2240 | group_allocated); | 2559 | group_allocated); |
2241 | } | 2560 | } |
2242 | 2561 | ||
2243 | size += sprintf(&buf[size], "completed:\n"); | 2562 | size += sprintf(&buf[size], "Completed:\n"); |
2244 | 2563 | ||
2245 | for (n = 0; n < dd->slot_groups; n++) | 2564 | for (n = 0; n < dd->slot_groups; n++) |
2246 | size += sprintf(&buf[size], "0x%08x\n", | 2565 | size += sprintf(&buf[size], "0x%08x\n", |
2247 | readl(dd->port->completed[n])); | 2566 | readl(dd->port->completed[n])); |
2248 | 2567 | ||
2249 | size += sprintf(&buf[size], "PORT_IRQ_STAT 0x%08x\n", | 2568 | size += sprintf(&buf[size], "PORT IRQ STAT : 0x%08x\n", |
2250 | readl(dd->port->mmio + PORT_IRQ_STAT)); | 2569 | readl(dd->port->mmio + PORT_IRQ_STAT)); |
2251 | size += sprintf(&buf[size], "HOST_IRQ_STAT 0x%08x\n", | 2570 | size += sprintf(&buf[size], "HOST IRQ STAT : 0x%08x\n", |
2252 | readl(dd->mmio + HOST_IRQ_STAT)); | 2571 | readl(dd->mmio + HOST_IRQ_STAT)); |
2253 | 2572 | ||
2254 | return size; | 2573 | return size; |
2255 | } | 2574 | } |
2256 | static DEVICE_ATTR(registers, S_IRUGO, hw_show_registers, NULL); | 2575 | |
2576 | static ssize_t mtip_hw_show_status(struct device *dev, | ||
2577 | struct device_attribute *attr, | ||
2578 | char *buf) | ||
2579 | { | ||
2580 | struct driver_data *dd = dev_to_disk(dev)->private_data; | ||
2581 | int size = 0; | ||
2582 | |||
2583 | if (test_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag)) | ||
2584 | size += sprintf(buf, "%s", "thermal_shutdown\n"); | ||
2585 | else if (test_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag)) | ||
2586 | size += sprintf(buf, "%s", "write_protect\n"); | ||
2587 | else | ||
2588 | size += sprintf(buf, "%s", "online\n"); | ||
2589 | |||
2590 | return size; | ||
2591 | } | ||
2592 | |||
2593 | static DEVICE_ATTR(registers, S_IRUGO, mtip_hw_show_registers, NULL); | ||
2594 | static DEVICE_ATTR(status, S_IRUGO, mtip_hw_show_status, NULL); | ||
2257 | 2595 | ||
2258 | /* | 2596 | /* |
2259 | * Create the sysfs related attributes. | 2597 | * Create the sysfs related attributes. |
@@ -2272,7 +2610,10 @@ static int mtip_hw_sysfs_init(struct driver_data *dd, struct kobject *kobj) | |||
2272 | 2610 | ||
2273 | if (sysfs_create_file(kobj, &dev_attr_registers.attr)) | 2611 | if (sysfs_create_file(kobj, &dev_attr_registers.attr)) |
2274 | dev_warn(&dd->pdev->dev, | 2612 | dev_warn(&dd->pdev->dev, |
2275 | "Error creating registers sysfs entry\n"); | 2613 | "Error creating 'registers' sysfs entry\n"); |
2614 | if (sysfs_create_file(kobj, &dev_attr_status.attr)) | ||
2615 | dev_warn(&dd->pdev->dev, | ||
2616 | "Error creating 'status' sysfs entry\n"); | ||
2276 | return 0; | 2617 | return 0; |
2277 | } | 2618 | } |
2278 | 2619 | ||
@@ -2292,6 +2633,7 @@ static int mtip_hw_sysfs_exit(struct driver_data *dd, struct kobject *kobj) | |||
2292 | return -EINVAL; | 2633 | return -EINVAL; |
2293 | 2634 | ||
2294 | sysfs_remove_file(kobj, &dev_attr_registers.attr); | 2635 | sysfs_remove_file(kobj, &dev_attr_registers.attr); |
2636 | sysfs_remove_file(kobj, &dev_attr_status.attr); | ||
2295 | 2637 | ||
2296 | return 0; | 2638 | return 0; |
2297 | } | 2639 | } |
@@ -2384,10 +2726,12 @@ static int mtip_ftl_rebuild_poll(struct driver_data *dd) | |||
2384 | "FTL rebuild in progress. Polling for completion.\n"); | 2726 | "FTL rebuild in progress. Polling for completion.\n"); |
2385 | 2727 | ||
2386 | start = jiffies; | 2728 | start = jiffies; |
2387 | dd->ftlrebuildflag = 1; | ||
2388 | timeout = jiffies + msecs_to_jiffies(MTIP_FTL_REBUILD_TIMEOUT_MS); | 2729 | timeout = jiffies + msecs_to_jiffies(MTIP_FTL_REBUILD_TIMEOUT_MS); |
2389 | 2730 | ||
2390 | do { | 2731 | do { |
2732 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
2733 | &dd->dd_flag))) | ||
2734 | return -EFAULT; | ||
2391 | if (mtip_check_surprise_removal(dd->pdev)) | 2735 | if (mtip_check_surprise_removal(dd->pdev)) |
2392 | return -EFAULT; | 2736 | return -EFAULT; |
2393 | 2737 | ||
@@ -2408,22 +2752,17 @@ static int mtip_ftl_rebuild_poll(struct driver_data *dd) | |||
2408 | dev_warn(&dd->pdev->dev, | 2752 | dev_warn(&dd->pdev->dev, |
2409 | "FTL rebuild complete (%d secs).\n", | 2753 | "FTL rebuild complete (%d secs).\n", |
2410 | jiffies_to_msecs(jiffies - start) / 1000); | 2754 | jiffies_to_msecs(jiffies - start) / 1000); |
2411 | dd->ftlrebuildflag = 0; | ||
2412 | mtip_block_initialize(dd); | 2755 | mtip_block_initialize(dd); |
2413 | break; | 2756 | return 0; |
2414 | } | 2757 | } |
2415 | ssleep(10); | 2758 | ssleep(10); |
2416 | } while (time_before(jiffies, timeout)); | 2759 | } while (time_before(jiffies, timeout)); |
2417 | 2760 | ||
2418 | /* Check for timeout */ | 2761 | /* Check for timeout */ |
2419 | if (dd->ftlrebuildflag) { | 2762 | dev_err(&dd->pdev->dev, |
2420 | dev_err(&dd->pdev->dev, | ||
2421 | "Timed out waiting for FTL rebuild to complete (%d secs).\n", | 2763 | "Timed out waiting for FTL rebuild to complete (%d secs).\n", |
2422 | jiffies_to_msecs(jiffies - start) / 1000); | 2764 | jiffies_to_msecs(jiffies - start) / 1000); |
2423 | return -EFAULT; | 2765 | return -EFAULT; |
2424 | } | ||
2425 | |||
2426 | return 0; | ||
2427 | } | 2766 | } |
2428 | 2767 | ||
2429 | /* | 2768 | /* |
@@ -2448,14 +2787,17 @@ static int mtip_service_thread(void *data) | |||
2448 | * is in progress nor error handling is active | 2787 | * is in progress nor error handling is active |
2449 | */ | 2788 | */ |
2450 | wait_event_interruptible(port->svc_wait, (port->flags) && | 2789 | wait_event_interruptible(port->svc_wait, (port->flags) && |
2451 | !test_bit(MTIP_FLAG_IC_ACTIVE_BIT, &port->flags) && | 2790 | !(port->flags & MTIP_PF_PAUSE_IO)); |
2452 | !test_bit(MTIP_FLAG_EH_ACTIVE_BIT, &port->flags)); | ||
2453 | 2791 | ||
2454 | if (kthread_should_stop()) | 2792 | if (kthread_should_stop()) |
2455 | break; | 2793 | break; |
2456 | 2794 | ||
2457 | set_bit(MTIP_FLAG_SVC_THD_ACTIVE_BIT, &port->flags); | 2795 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, |
2458 | if (test_bit(MTIP_FLAG_ISSUE_CMDS_BIT, &port->flags)) { | 2796 | &dd->dd_flag))) |
2797 | break; | ||
2798 | |||
2799 | set_bit(MTIP_PF_SVC_THD_ACTIVE_BIT, &port->flags); | ||
2800 | if (test_bit(MTIP_PF_ISSUE_CMDS_BIT, &port->flags)) { | ||
2459 | slot = 1; | 2801 | slot = 1; |
2460 | /* used to restrict the loop to one iteration */ | 2802 | /* used to restrict the loop to one iteration */ |
2461 | slot_start = num_cmd_slots; | 2803 | slot_start = num_cmd_slots; |
@@ -2480,21 +2822,19 @@ static int mtip_service_thread(void *data) | |||
2480 | /* Issue the command to the hardware */ | 2822 | /* Issue the command to the hardware */ |
2481 | mtip_issue_ncq_command(port, slot); | 2823 | mtip_issue_ncq_command(port, slot); |
2482 | 2824 | ||
2483 | /* Set the command's timeout value.*/ | ||
2484 | port->commands[slot].comp_time = jiffies + | ||
2485 | msecs_to_jiffies(MTIP_NCQ_COMMAND_TIMEOUT_MS); | ||
2486 | |||
2487 | clear_bit(slot, port->cmds_to_issue); | 2825 | clear_bit(slot, port->cmds_to_issue); |
2488 | } | 2826 | } |
2489 | 2827 | ||
2490 | clear_bit(MTIP_FLAG_ISSUE_CMDS_BIT, &port->flags); | 2828 | clear_bit(MTIP_PF_ISSUE_CMDS_BIT, &port->flags); |
2491 | } else if (test_bit(MTIP_FLAG_REBUILD_BIT, &port->flags)) { | 2829 | } else if (test_bit(MTIP_PF_REBUILD_BIT, &port->flags)) { |
2492 | mtip_ftl_rebuild_poll(dd); | 2830 | if (!mtip_ftl_rebuild_poll(dd)) |
2493 | clear_bit(MTIP_FLAG_REBUILD_BIT, &port->flags); | 2831 | set_bit(MTIP_DDF_REBUILD_FAILED_BIT, |
2832 | &dd->dd_flag); | ||
2833 | clear_bit(MTIP_PF_REBUILD_BIT, &port->flags); | ||
2494 | } | 2834 | } |
2495 | clear_bit(MTIP_FLAG_SVC_THD_ACTIVE_BIT, &port->flags); | 2835 | clear_bit(MTIP_PF_SVC_THD_ACTIVE_BIT, &port->flags); |
2496 | 2836 | ||
2497 | if (test_bit(MTIP_FLAG_SVC_THD_SHOULD_STOP_BIT, &port->flags)) | 2837 | if (test_bit(MTIP_PF_SVC_THD_STOP_BIT, &port->flags)) |
2498 | break; | 2838 | break; |
2499 | } | 2839 | } |
2500 | return 0; | 2840 | return 0; |
@@ -2513,6 +2853,9 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2513 | int i; | 2853 | int i; |
2514 | int rv; | 2854 | int rv; |
2515 | unsigned int num_command_slots; | 2855 | unsigned int num_command_slots; |
2856 | unsigned long timeout, timetaken; | ||
2857 | unsigned char *buf; | ||
2858 | struct smart_attr attr242; | ||
2516 | 2859 | ||
2517 | dd->mmio = pcim_iomap_table(dd->pdev)[MTIP_ABAR]; | 2860 | dd->mmio = pcim_iomap_table(dd->pdev)[MTIP_ABAR]; |
2518 | 2861 | ||
@@ -2547,7 +2890,7 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2547 | /* Allocate memory for the command list. */ | 2890 | /* Allocate memory for the command list. */ |
2548 | dd->port->command_list = | 2891 | dd->port->command_list = |
2549 | dmam_alloc_coherent(&dd->pdev->dev, | 2892 | dmam_alloc_coherent(&dd->pdev->dev, |
2550 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 2), | 2893 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 4), |
2551 | &dd->port->command_list_dma, | 2894 | &dd->port->command_list_dma, |
2552 | GFP_KERNEL); | 2895 | GFP_KERNEL); |
2553 | if (!dd->port->command_list) { | 2896 | if (!dd->port->command_list) { |
@@ -2560,7 +2903,7 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2560 | /* Clear the memory we have allocated. */ | 2903 | /* Clear the memory we have allocated. */ |
2561 | memset(dd->port->command_list, | 2904 | memset(dd->port->command_list, |
2562 | 0, | 2905 | 0, |
2563 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 2)); | 2906 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 4)); |
2564 | 2907 | ||
2565 | /* Setup the addresse of the RX FIS. */ | 2908 | /* Setup the addresse of the RX FIS. */ |
2566 | dd->port->rxfis = dd->port->command_list + HW_CMD_SLOT_SZ; | 2909 | dd->port->rxfis = dd->port->command_list + HW_CMD_SLOT_SZ; |
@@ -2576,10 +2919,19 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2576 | dd->port->identify_dma = dd->port->command_tbl_dma + | 2919 | dd->port->identify_dma = dd->port->command_tbl_dma + |
2577 | HW_CMD_TBL_AR_SZ; | 2920 | HW_CMD_TBL_AR_SZ; |
2578 | 2921 | ||
2579 | /* Setup the address of the sector buffer. */ | 2922 | /* Setup the address of the sector buffer - for some non-ncq cmds */ |
2580 | dd->port->sector_buffer = (void *) dd->port->identify + ATA_SECT_SIZE; | 2923 | dd->port->sector_buffer = (void *) dd->port->identify + ATA_SECT_SIZE; |
2581 | dd->port->sector_buffer_dma = dd->port->identify_dma + ATA_SECT_SIZE; | 2924 | dd->port->sector_buffer_dma = dd->port->identify_dma + ATA_SECT_SIZE; |
2582 | 2925 | ||
2926 | /* Setup the address of the log buf - for read log command */ | ||
2927 | dd->port->log_buf = (void *)dd->port->sector_buffer + ATA_SECT_SIZE; | ||
2928 | dd->port->log_buf_dma = dd->port->sector_buffer_dma + ATA_SECT_SIZE; | ||
2929 | |||
2930 | /* Setup the address of the smart buf - for smart read data command */ | ||
2931 | dd->port->smart_buf = (void *)dd->port->log_buf + ATA_SECT_SIZE; | ||
2932 | dd->port->smart_buf_dma = dd->port->log_buf_dma + ATA_SECT_SIZE; | ||
2933 | |||
2934 | |||
2583 | /* Point the command headers at the command tables. */ | 2935 | /* Point the command headers at the command tables. */ |
2584 | for (i = 0; i < num_command_slots; i++) { | 2936 | for (i = 0; i < num_command_slots; i++) { |
2585 | dd->port->commands[i].command_header = | 2937 | dd->port->commands[i].command_header = |
@@ -2623,14 +2975,43 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2623 | dd->port->mmio + i*0x80 + PORT_SDBV; | 2975 | dd->port->mmio + i*0x80 + PORT_SDBV; |
2624 | } | 2976 | } |
2625 | 2977 | ||
2626 | /* Reset the HBA. */ | 2978 | timetaken = jiffies; |
2627 | if (mtip_hba_reset(dd) < 0) { | 2979 | timeout = jiffies + msecs_to_jiffies(30000); |
2628 | dev_err(&dd->pdev->dev, | 2980 | while (((readl(dd->port->mmio + PORT_SCR_STAT) & 0x0F) != 0x03) && |
2629 | "Card did not reset within timeout\n"); | 2981 | time_before(jiffies, timeout)) { |
2630 | rv = -EIO; | 2982 | mdelay(100); |
2983 | } | ||
2984 | if (unlikely(mtip_check_surprise_removal(dd->pdev))) { | ||
2985 | timetaken = jiffies - timetaken; | ||
2986 | dev_warn(&dd->pdev->dev, | ||
2987 | "Surprise removal detected at %u ms\n", | ||
2988 | jiffies_to_msecs(timetaken)); | ||
2989 | rv = -ENODEV; | ||
2990 | goto out2 ; | ||
2991 | } | ||
2992 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag))) { | ||
2993 | timetaken = jiffies - timetaken; | ||
2994 | dev_warn(&dd->pdev->dev, | ||
2995 | "Removal detected at %u ms\n", | ||
2996 | jiffies_to_msecs(timetaken)); | ||
2997 | rv = -EFAULT; | ||
2631 | goto out2; | 2998 | goto out2; |
2632 | } | 2999 | } |
2633 | 3000 | ||
3001 | /* Conditionally reset the HBA. */ | ||
3002 | if (!(readl(dd->mmio + HOST_CAP) & HOST_CAP_NZDMA)) { | ||
3003 | if (mtip_hba_reset(dd) < 0) { | ||
3004 | dev_err(&dd->pdev->dev, | ||
3005 | "Card did not reset within timeout\n"); | ||
3006 | rv = -EIO; | ||
3007 | goto out2; | ||
3008 | } | ||
3009 | } else { | ||
3010 | /* Clear any pending interrupts on the HBA */ | ||
3011 | writel(readl(dd->mmio + HOST_IRQ_STAT), | ||
3012 | dd->mmio + HOST_IRQ_STAT); | ||
3013 | } | ||
3014 | |||
2634 | mtip_init_port(dd->port); | 3015 | mtip_init_port(dd->port); |
2635 | mtip_start_port(dd->port); | 3016 | mtip_start_port(dd->port); |
2636 | 3017 | ||
@@ -2660,6 +3041,12 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2660 | mod_timer(&dd->port->cmd_timer, | 3041 | mod_timer(&dd->port->cmd_timer, |
2661 | jiffies + msecs_to_jiffies(MTIP_TIMEOUT_CHECK_PERIOD)); | 3042 | jiffies + msecs_to_jiffies(MTIP_TIMEOUT_CHECK_PERIOD)); |
2662 | 3043 | ||
3044 | |||
3045 | if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag)) { | ||
3046 | rv = -EFAULT; | ||
3047 | goto out3; | ||
3048 | } | ||
3049 | |||
2663 | if (mtip_get_identify(dd->port, NULL) < 0) { | 3050 | if (mtip_get_identify(dd->port, NULL) < 0) { |
2664 | rv = -EFAULT; | 3051 | rv = -EFAULT; |
2665 | goto out3; | 3052 | goto out3; |
@@ -2667,10 +3054,47 @@ static int mtip_hw_init(struct driver_data *dd) | |||
2667 | 3054 | ||
2668 | if (*(dd->port->identify + MTIP_FTL_REBUILD_OFFSET) == | 3055 | if (*(dd->port->identify + MTIP_FTL_REBUILD_OFFSET) == |
2669 | MTIP_FTL_REBUILD_MAGIC) { | 3056 | MTIP_FTL_REBUILD_MAGIC) { |
2670 | set_bit(MTIP_FLAG_REBUILD_BIT, &dd->port->flags); | 3057 | set_bit(MTIP_PF_REBUILD_BIT, &dd->port->flags); |
2671 | return MTIP_FTL_REBUILD_MAGIC; | 3058 | return MTIP_FTL_REBUILD_MAGIC; |
2672 | } | 3059 | } |
2673 | mtip_dump_identify(dd->port); | 3060 | mtip_dump_identify(dd->port); |
3061 | |||
3062 | /* check write protect, over temp and rebuild statuses */ | ||
3063 | rv = mtip_read_log_page(dd->port, ATA_LOG_SATA_NCQ, | ||
3064 | dd->port->log_buf, | ||
3065 | dd->port->log_buf_dma, 1); | ||
3066 | if (rv) { | ||
3067 | dev_warn(&dd->pdev->dev, | ||
3068 | "Error in READ LOG EXT (10h) command\n"); | ||
3069 | /* non-critical error, don't fail the load */ | ||
3070 | } else { | ||
3071 | buf = (unsigned char *)dd->port->log_buf; | ||
3072 | if (buf[259] & 0x1) { | ||
3073 | dev_info(&dd->pdev->dev, | ||
3074 | "Write protect bit is set.\n"); | ||
3075 | set_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag); | ||
3076 | } | ||
3077 | if (buf[288] == 0xF7) { | ||
3078 | dev_info(&dd->pdev->dev, | ||
3079 | "Exceeded Tmax, drive in thermal shutdown.\n"); | ||
3080 | set_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag); | ||
3081 | } | ||
3082 | if (buf[288] == 0xBF) { | ||
3083 | dev_info(&dd->pdev->dev, | ||
3084 | "Drive indicates rebuild has failed.\n"); | ||
3085 | /* TODO */ | ||
3086 | } | ||
3087 | } | ||
3088 | |||
3089 | /* get write protect progess */ | ||
3090 | memset(&attr242, 0, sizeof(struct smart_attr)); | ||
3091 | if (mtip_get_smart_attr(dd->port, 242, &attr242)) | ||
3092 | dev_warn(&dd->pdev->dev, | ||
3093 | "Unable to check write protect progress\n"); | ||
3094 | else | ||
3095 | dev_info(&dd->pdev->dev, | ||
3096 | "Write protect progress: %d%% (%d blocks)\n", | ||
3097 | attr242.cur, attr242.data); | ||
2674 | return rv; | 3098 | return rv; |
2675 | 3099 | ||
2676 | out3: | 3100 | out3: |
@@ -2688,7 +3112,7 @@ out2: | |||
2688 | 3112 | ||
2689 | /* Free the command/command header memory. */ | 3113 | /* Free the command/command header memory. */ |
2690 | dmam_free_coherent(&dd->pdev->dev, | 3114 | dmam_free_coherent(&dd->pdev->dev, |
2691 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 2), | 3115 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 4), |
2692 | dd->port->command_list, | 3116 | dd->port->command_list, |
2693 | dd->port->command_list_dma); | 3117 | dd->port->command_list_dma); |
2694 | out1: | 3118 | out1: |
@@ -2712,9 +3136,12 @@ static int mtip_hw_exit(struct driver_data *dd) | |||
2712 | * Send standby immediate (E0h) to the drive so that it | 3136 | * Send standby immediate (E0h) to the drive so that it |
2713 | * saves its state. | 3137 | * saves its state. |
2714 | */ | 3138 | */ |
2715 | if (atomic_read(&dd->drv_cleanup_done) != true) { | 3139 | if (!test_bit(MTIP_DDF_CLEANUP_BIT, &dd->dd_flag)) { |
2716 | 3140 | ||
2717 | mtip_standby_immediate(dd->port); | 3141 | if (!test_bit(MTIP_PF_REBUILD_BIT, &dd->port->flags)) |
3142 | if (mtip_standby_immediate(dd->port)) | ||
3143 | dev_warn(&dd->pdev->dev, | ||
3144 | "STANDBY IMMEDIATE failed\n"); | ||
2718 | 3145 | ||
2719 | /* de-initialize the port. */ | 3146 | /* de-initialize the port. */ |
2720 | mtip_deinit_port(dd->port); | 3147 | mtip_deinit_port(dd->port); |
@@ -2734,7 +3161,7 @@ static int mtip_hw_exit(struct driver_data *dd) | |||
2734 | 3161 | ||
2735 | /* Free the command/command header memory. */ | 3162 | /* Free the command/command header memory. */ |
2736 | dmam_free_coherent(&dd->pdev->dev, | 3163 | dmam_free_coherent(&dd->pdev->dev, |
2737 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 2), | 3164 | HW_PORT_PRIV_DMA_SZ + (ATA_SECT_SIZE * 4), |
2738 | dd->port->command_list, | 3165 | dd->port->command_list, |
2739 | dd->port->command_list_dma); | 3166 | dd->port->command_list_dma); |
2740 | /* Free the memory allocated for the for structure. */ | 3167 | /* Free the memory allocated for the for structure. */ |
@@ -2892,6 +3319,9 @@ static int mtip_block_ioctl(struct block_device *dev, | |||
2892 | if (!dd) | 3319 | if (!dd) |
2893 | return -ENOTTY; | 3320 | return -ENOTTY; |
2894 | 3321 | ||
3322 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag))) | ||
3323 | return -ENOTTY; | ||
3324 | |||
2895 | switch (cmd) { | 3325 | switch (cmd) { |
2896 | case BLKFLSBUF: | 3326 | case BLKFLSBUF: |
2897 | return -ENOTTY; | 3327 | return -ENOTTY; |
@@ -2927,6 +3357,9 @@ static int mtip_block_compat_ioctl(struct block_device *dev, | |||
2927 | if (!dd) | 3357 | if (!dd) |
2928 | return -ENOTTY; | 3358 | return -ENOTTY; |
2929 | 3359 | ||
3360 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag))) | ||
3361 | return -ENOTTY; | ||
3362 | |||
2930 | switch (cmd) { | 3363 | switch (cmd) { |
2931 | case BLKFLSBUF: | 3364 | case BLKFLSBUF: |
2932 | return -ENOTTY; | 3365 | return -ENOTTY; |
@@ -3049,6 +3482,24 @@ static void mtip_make_request(struct request_queue *queue, struct bio *bio) | |||
3049 | int nents = 0; | 3482 | int nents = 0; |
3050 | int tag = 0; | 3483 | int tag = 0; |
3051 | 3484 | ||
3485 | if (unlikely(dd->dd_flag & MTIP_DDF_STOP_IO)) { | ||
3486 | if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT, | ||
3487 | &dd->dd_flag))) { | ||
3488 | bio_endio(bio, -ENXIO); | ||
3489 | return; | ||
3490 | } | ||
3491 | if (unlikely(test_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag))) { | ||
3492 | bio_endio(bio, -ENODATA); | ||
3493 | return; | ||
3494 | } | ||
3495 | if (unlikely(test_bit(MTIP_DDF_WRITE_PROTECT_BIT, | ||
3496 | &dd->dd_flag) && | ||
3497 | bio_data_dir(bio))) { | ||
3498 | bio_endio(bio, -ENODATA); | ||
3499 | return; | ||
3500 | } | ||
3501 | } | ||
3502 | |||
3052 | if (unlikely(!bio_has_data(bio))) { | 3503 | if (unlikely(!bio_has_data(bio))) { |
3053 | blk_queue_flush(queue, 0); | 3504 | blk_queue_flush(queue, 0); |
3054 | bio_endio(bio, 0); | 3505 | bio_endio(bio, 0); |
@@ -3061,7 +3512,7 @@ static void mtip_make_request(struct request_queue *queue, struct bio *bio) | |||
3061 | 3512 | ||
3062 | if (unlikely((bio)->bi_vcnt > MTIP_MAX_SG)) { | 3513 | if (unlikely((bio)->bi_vcnt > MTIP_MAX_SG)) { |
3063 | dev_warn(&dd->pdev->dev, | 3514 | dev_warn(&dd->pdev->dev, |
3064 | "Maximum number of SGL entries exceeded"); | 3515 | "Maximum number of SGL entries exceeded\n"); |
3065 | bio_io_error(bio); | 3516 | bio_io_error(bio); |
3066 | mtip_hw_release_scatterlist(dd, tag); | 3517 | mtip_hw_release_scatterlist(dd, tag); |
3067 | return; | 3518 | return; |
@@ -3210,8 +3661,10 @@ skip_create_disk: | |||
3210 | kobject_put(kobj); | 3661 | kobject_put(kobj); |
3211 | } | 3662 | } |
3212 | 3663 | ||
3213 | if (dd->mtip_svc_handler) | 3664 | if (dd->mtip_svc_handler) { |
3665 | set_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag); | ||
3214 | return rv; /* service thread created for handling rebuild */ | 3666 | return rv; /* service thread created for handling rebuild */ |
3667 | } | ||
3215 | 3668 | ||
3216 | start_service_thread: | 3669 | start_service_thread: |
3217 | sprintf(thd_name, "mtip_svc_thd_%02d", index); | 3670 | sprintf(thd_name, "mtip_svc_thd_%02d", index); |
@@ -3220,12 +3673,15 @@ start_service_thread: | |||
3220 | dd, thd_name); | 3673 | dd, thd_name); |
3221 | 3674 | ||
3222 | if (IS_ERR(dd->mtip_svc_handler)) { | 3675 | if (IS_ERR(dd->mtip_svc_handler)) { |
3223 | printk(KERN_ERR "mtip32xx: service thread failed to start\n"); | 3676 | dev_err(&dd->pdev->dev, "service thread failed to start\n"); |
3224 | dd->mtip_svc_handler = NULL; | 3677 | dd->mtip_svc_handler = NULL; |
3225 | rv = -EFAULT; | 3678 | rv = -EFAULT; |
3226 | goto kthread_run_error; | 3679 | goto kthread_run_error; |
3227 | } | 3680 | } |
3228 | 3681 | ||
3682 | if (wait_for_rebuild == MTIP_FTL_REBUILD_MAGIC) | ||
3683 | rv = wait_for_rebuild; | ||
3684 | |||
3229 | return rv; | 3685 | return rv; |
3230 | 3686 | ||
3231 | kthread_run_error: | 3687 | kthread_run_error: |
@@ -3266,16 +3722,18 @@ static int mtip_block_remove(struct driver_data *dd) | |||
3266 | struct kobject *kobj; | 3722 | struct kobject *kobj; |
3267 | 3723 | ||
3268 | if (dd->mtip_svc_handler) { | 3724 | if (dd->mtip_svc_handler) { |
3269 | set_bit(MTIP_FLAG_SVC_THD_SHOULD_STOP_BIT, &dd->port->flags); | 3725 | set_bit(MTIP_PF_SVC_THD_STOP_BIT, &dd->port->flags); |
3270 | wake_up_interruptible(&dd->port->svc_wait); | 3726 | wake_up_interruptible(&dd->port->svc_wait); |
3271 | kthread_stop(dd->mtip_svc_handler); | 3727 | kthread_stop(dd->mtip_svc_handler); |
3272 | } | 3728 | } |
3273 | 3729 | ||
3274 | /* Clean up the sysfs attributes managed by the protocol layer. */ | 3730 | /* Clean up the sysfs attributes, if created */ |
3275 | kobj = kobject_get(&disk_to_dev(dd->disk)->kobj); | 3731 | if (test_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag)) { |
3276 | if (kobj) { | 3732 | kobj = kobject_get(&disk_to_dev(dd->disk)->kobj); |
3277 | mtip_hw_sysfs_exit(dd, kobj); | 3733 | if (kobj) { |
3278 | kobject_put(kobj); | 3734 | mtip_hw_sysfs_exit(dd, kobj); |
3735 | kobject_put(kobj); | ||
3736 | } | ||
3279 | } | 3737 | } |
3280 | 3738 | ||
3281 | /* | 3739 | /* |
@@ -3283,6 +3741,11 @@ static int mtip_block_remove(struct driver_data *dd) | |||
3283 | * from /dev | 3741 | * from /dev |
3284 | */ | 3742 | */ |
3285 | del_gendisk(dd->disk); | 3743 | del_gendisk(dd->disk); |
3744 | |||
3745 | spin_lock(&rssd_index_lock); | ||
3746 | ida_remove(&rssd_index_ida, dd->index); | ||
3747 | spin_unlock(&rssd_index_lock); | ||
3748 | |||
3286 | blk_cleanup_queue(dd->queue); | 3749 | blk_cleanup_queue(dd->queue); |
3287 | dd->disk = NULL; | 3750 | dd->disk = NULL; |
3288 | dd->queue = NULL; | 3751 | dd->queue = NULL; |
@@ -3312,6 +3775,11 @@ static int mtip_block_shutdown(struct driver_data *dd) | |||
3312 | 3775 | ||
3313 | /* Delete our gendisk structure, and cleanup the blk queue. */ | 3776 | /* Delete our gendisk structure, and cleanup the blk queue. */ |
3314 | del_gendisk(dd->disk); | 3777 | del_gendisk(dd->disk); |
3778 | |||
3779 | spin_lock(&rssd_index_lock); | ||
3780 | ida_remove(&rssd_index_ida, dd->index); | ||
3781 | spin_unlock(&rssd_index_lock); | ||
3782 | |||
3315 | blk_cleanup_queue(dd->queue); | 3783 | blk_cleanup_queue(dd->queue); |
3316 | dd->disk = NULL; | 3784 | dd->disk = NULL; |
3317 | dd->queue = NULL; | 3785 | dd->queue = NULL; |
@@ -3359,11 +3827,6 @@ static int mtip_pci_probe(struct pci_dev *pdev, | |||
3359 | return -ENOMEM; | 3827 | return -ENOMEM; |
3360 | } | 3828 | } |
3361 | 3829 | ||
3362 | /* Set the atomic variable as 1 in case of SRSI */ | ||
3363 | atomic_set(&dd->drv_cleanup_done, true); | ||
3364 | |||
3365 | atomic_set(&dd->resumeflag, false); | ||
3366 | |||
3367 | /* Attach the private data to this PCI device. */ | 3830 | /* Attach the private data to this PCI device. */ |
3368 | pci_set_drvdata(pdev, dd); | 3831 | pci_set_drvdata(pdev, dd); |
3369 | 3832 | ||
@@ -3420,7 +3883,8 @@ static int mtip_pci_probe(struct pci_dev *pdev, | |||
3420 | * instance number. | 3883 | * instance number. |
3421 | */ | 3884 | */ |
3422 | instance++; | 3885 | instance++; |
3423 | 3886 | if (rv != MTIP_FTL_REBUILD_MAGIC) | |
3887 | set_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag); | ||
3424 | goto done; | 3888 | goto done; |
3425 | 3889 | ||
3426 | block_initialize_err: | 3890 | block_initialize_err: |
@@ -3434,9 +3898,6 @@ iomap_err: | |||
3434 | pci_set_drvdata(pdev, NULL); | 3898 | pci_set_drvdata(pdev, NULL); |
3435 | return rv; | 3899 | return rv; |
3436 | done: | 3900 | done: |
3437 | /* Set the atomic variable as 0 in case of SRSI */ | ||
3438 | atomic_set(&dd->drv_cleanup_done, true); | ||
3439 | |||
3440 | return rv; | 3901 | return rv; |
3441 | } | 3902 | } |
3442 | 3903 | ||
@@ -3452,8 +3913,10 @@ static void mtip_pci_remove(struct pci_dev *pdev) | |||
3452 | struct driver_data *dd = pci_get_drvdata(pdev); | 3913 | struct driver_data *dd = pci_get_drvdata(pdev); |
3453 | int counter = 0; | 3914 | int counter = 0; |
3454 | 3915 | ||
3916 | set_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag); | ||
3917 | |||
3455 | if (mtip_check_surprise_removal(pdev)) { | 3918 | if (mtip_check_surprise_removal(pdev)) { |
3456 | while (atomic_read(&dd->drv_cleanup_done) == false) { | 3919 | while (!test_bit(MTIP_DDF_CLEANUP_BIT, &dd->dd_flag)) { |
3457 | counter++; | 3920 | counter++; |
3458 | msleep(20); | 3921 | msleep(20); |
3459 | if (counter == 10) { | 3922 | if (counter == 10) { |
@@ -3463,8 +3926,6 @@ static void mtip_pci_remove(struct pci_dev *pdev) | |||
3463 | } | 3926 | } |
3464 | } | 3927 | } |
3465 | } | 3928 | } |
3466 | /* Set the atomic variable as 1 in case of SRSI */ | ||
3467 | atomic_set(&dd->drv_cleanup_done, true); | ||
3468 | 3929 | ||
3469 | /* Clean up the block layer. */ | 3930 | /* Clean up the block layer. */ |
3470 | mtip_block_remove(dd); | 3931 | mtip_block_remove(dd); |
@@ -3493,7 +3954,7 @@ static int mtip_pci_suspend(struct pci_dev *pdev, pm_message_t mesg) | |||
3493 | return -EFAULT; | 3954 | return -EFAULT; |
3494 | } | 3955 | } |
3495 | 3956 | ||
3496 | atomic_set(&dd->resumeflag, true); | 3957 | set_bit(MTIP_DDF_RESUME_BIT, &dd->dd_flag); |
3497 | 3958 | ||
3498 | /* Disable ports & interrupts then send standby immediate */ | 3959 | /* Disable ports & interrupts then send standby immediate */ |
3499 | rv = mtip_block_suspend(dd); | 3960 | rv = mtip_block_suspend(dd); |
@@ -3559,7 +4020,7 @@ static int mtip_pci_resume(struct pci_dev *pdev) | |||
3559 | dev_err(&pdev->dev, "Unable to resume\n"); | 4020 | dev_err(&pdev->dev, "Unable to resume\n"); |
3560 | 4021 | ||
3561 | err: | 4022 | err: |
3562 | atomic_set(&dd->resumeflag, false); | 4023 | clear_bit(MTIP_DDF_RESUME_BIT, &dd->dd_flag); |
3563 | 4024 | ||
3564 | return rv; | 4025 | return rv; |
3565 | } | 4026 | } |
@@ -3608,18 +4069,25 @@ MODULE_DEVICE_TABLE(pci, mtip_pci_tbl); | |||
3608 | */ | 4069 | */ |
3609 | static int __init mtip_init(void) | 4070 | static int __init mtip_init(void) |
3610 | { | 4071 | { |
4072 | int error; | ||
4073 | |||
3611 | printk(KERN_INFO MTIP_DRV_NAME " Version " MTIP_DRV_VERSION "\n"); | 4074 | printk(KERN_INFO MTIP_DRV_NAME " Version " MTIP_DRV_VERSION "\n"); |
3612 | 4075 | ||
3613 | /* Allocate a major block device number to use with this driver. */ | 4076 | /* Allocate a major block device number to use with this driver. */ |
3614 | mtip_major = register_blkdev(0, MTIP_DRV_NAME); | 4077 | error = register_blkdev(0, MTIP_DRV_NAME); |
3615 | if (mtip_major < 0) { | 4078 | if (error <= 0) { |
3616 | printk(KERN_ERR "Unable to register block device (%d)\n", | 4079 | printk(KERN_ERR "Unable to register block device (%d)\n", |
3617 | mtip_major); | 4080 | error); |
3618 | return -EBUSY; | 4081 | return -EBUSY; |
3619 | } | 4082 | } |
4083 | mtip_major = error; | ||
3620 | 4084 | ||
3621 | /* Register our PCI operations. */ | 4085 | /* Register our PCI operations. */ |
3622 | return pci_register_driver(&mtip_pci_driver); | 4086 | error = pci_register_driver(&mtip_pci_driver); |
4087 | if (error) | ||
4088 | unregister_blkdev(mtip_major, MTIP_DRV_NAME); | ||
4089 | |||
4090 | return error; | ||
3623 | } | 4091 | } |
3624 | 4092 | ||
3625 | /* | 4093 | /* |