Merge branch 'for-linus' of git://git.kernel.dk/linux-block

Pull follow-up block updates from Jens Axboe:
 "Includes the fix from Eric to resolve the infinite loop in looking up
  or creating an IO context for an exiting task.

  Also a bunch of mtip32xx patches.  Fairly trivial stuff.  It's fairly
  new though, but no point in keeping it out of the tree until 3.6 imho.
  I've thrown it through basic testing locally as well, works fine.  The
  one contentious part is the patch that Greg complained about (sysfs
  file with multiple values, should be a debugfs file), which is
  perfectly valid, but not a regression from what the file contains now.
  That will be fixed up separately."

* 'for-linus' of git://git.kernel.dk/linux-block:
  block: avoid infinite loop in get_task_io_context()
  mtip32xx: Changes to sysfs entries
  mtip32xx: Convert macro definitions for flag bits to enum
  mtip32xx: minor performance tweak
  mtip32xx: Fix to support more than one sector in exec_drive_command()
  mtip32xx: Use plain spinlock for 'cmd_issue_lock'
  mtip32xx: Set block queue boundary variables
  mtip32xx: Fix to handle TFE for PIO(IOCTL/internal) commands
  mtip32xx: Change HDIO_GET_IDENTITY to return stored data
  mtip32xx: Set custom timeouts for PIO commands
  mtip32xx: fix clearing an incorrect register in mtip_init_port

2 files changed, 197 insertions, 127 deletions

diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 304000c3d433..264bc77dcb91 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -294,18 +294,16 @@ static int hba_reset_nosleep(struct driver_data *dd)
  */
 static inline void mtip_issue_ncq_command(struct mtip_port *port, int tag)
 {
-        unsigned long flags = 0;
-
         atomic_set(&port->commands[tag].active, 1);
 
-        spin_lock_irqsave(&port->cmd_issue_lock, flags);
+        spin_lock(&port->cmd_issue_lock);
 
         writel((1 << MTIP_TAG_BIT(tag)),
                         port->s_active[MTIP_TAG_INDEX(tag)]);
         writel((1 << MTIP_TAG_BIT(tag)),
                         port->cmd_issue[MTIP_TAG_INDEX(tag)]);
 
-        spin_unlock_irqrestore(&port->cmd_issue_lock, flags);
+        spin_unlock(&port->cmd_issue_lock);
 
         /* Set the command's timeout value.*/
         port->commands[tag].comp_time = jiffies + msecs_to_jiffies(
@@ -436,8 +434,7 @@ static void mtip_init_port(struct mtip_port *port)
                 writel(0xFFFFFFFF, port->completed[i]);
 
         /* Clear any pending interrupts for this port */
-        writel(readl(port->dd->mmio + PORT_IRQ_STAT),
-                                        port->dd->mmio + PORT_IRQ_STAT);
+        writel(readl(port->mmio + PORT_IRQ_STAT), port->mmio + PORT_IRQ_STAT);
 
         /* Clear any pending interrupts on the HBA. */
         writel(readl(port->dd->mmio + HOST_IRQ_STAT),
@@ -782,13 +779,24 @@ static void mtip_handle_tfe(struct driver_data *dd)
 
         /* Stop the timer to prevent command timeouts. */
         del_timer(&port->cmd_timer);
+        set_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags);
+
+        if (test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags) &&
+                        test_bit(MTIP_TAG_INTERNAL, port->allocated)) {
+                cmd = &port->commands[MTIP_TAG_INTERNAL];
+                dbg_printk(MTIP_DRV_NAME " TFE for the internal command\n");
+
+                atomic_inc(&cmd->active); /* active > 1 indicates error */
+                if (cmd->comp_data && cmd->comp_func) {
+                        cmd->comp_func(port, MTIP_TAG_INTERNAL,
+                                        cmd->comp_data, PORT_IRQ_TF_ERR);
+                }
+                goto handle_tfe_exit;
+        }
 
         /* clear the tag accumulator */
         memset(tagaccum, 0, SLOTBITS_IN_LONGS * sizeof(long));
 
-        /* Set eh_active */
-        set_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags);
-
         /* Loop through all the groups */
         for (group = 0; group < dd->slot_groups; group++) {
                 completed = readl(port->completed[group]);
@@ -940,6 +948,7 @@ static void mtip_handle_tfe(struct driver_data *dd)
         }
         print_tags(dd, "reissued (TFE)", tagaccum, cmd_cnt);
 
+handle_tfe_exit:
         /* clear eh_active */
         clear_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags);
         wake_up_interruptible(&port->svc_wait);
@@ -961,6 +970,8 @@ static inline void mtip_process_sdbf(struct driver_data *dd)
         /* walk all bits in all slot groups */
         for (group = 0; group < dd->slot_groups; group++) {
                 completed = readl(port->completed[group]);
+                if (!completed)
+                        continue;
 
                 /* clear completed status register in the hardware.*/
                 writel(completed, port->completed[group]);
@@ -1329,22 +1340,6 @@ static int mtip_exec_internal_command(struct mtip_port *port,
                         }
                         rv = -EAGAIN;
                 }
-
-                if (readl(port->cmd_issue[MTIP_TAG_INTERNAL])
-                        & (1 << MTIP_TAG_INTERNAL)) {
-                        dev_warn(&port->dd->pdev->dev,
-                                "Retiring internal command but CI is 1.\n");
-                        if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT,
-                                                &port->dd->dd_flag)) {
-                                hba_reset_nosleep(port->dd);
-                                rv = -ENXIO;
-                        } else {
-                                mtip_restart_port(port);
-                                rv = -EAGAIN;
-                        }
-                        goto exec_ic_exit;
-                }
-
         } else {
                 /* Spin for <timeout> checking if command still outstanding */
                 timeout = jiffies + msecs_to_jiffies(timeout);
@@ -1361,21 +1356,25 @@ static int mtip_exec_internal_command(struct mtip_port *port,
                                 rv = -ENXIO;
                                 goto exec_ic_exit;
                         }
+                        if (readl(port->mmio + PORT_IRQ_STAT) & PORT_IRQ_ERR) {
+                                atomic_inc(&int_cmd->active); /* error */
+                                break;
+                        }
                 }
+        }
 
-                if (readl(port->cmd_issue[MTIP_TAG_INTERNAL])
+        if (atomic_read(&int_cmd->active) > 1) {
+                dev_err(&port->dd->pdev->dev,
+                        "Internal command [%02X] failed\n", fis->command);
+                rv = -EIO;
+        }
+        if (readl(port->cmd_issue[MTIP_TAG_INTERNAL])
                         & (1 << MTIP_TAG_INTERNAL)) {
-                        dev_err(&port->dd->pdev->dev,
-                                "Internal command did not complete [atomic]\n");
+                rv = -ENXIO;
+                if (!test_bit(MTIP_DDF_REMOVE_PENDING_BIT,
+                                        &port->dd->dd_flag)) {
+                        mtip_restart_port(port);
                         rv = -EAGAIN;
-                        if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT,
-                                                &port->dd->dd_flag)) {
-                                hba_reset_nosleep(port->dd);
-                                rv = -ENXIO;
-                        } else {
-                                mtip_restart_port(port);
-                                rv = -EAGAIN;
-                        }
                 }
         }
 exec_ic_exit:
@@ -1893,13 +1892,33 @@ static int exec_drive_command(struct mtip_port *port, u8 *command,
                                 void __user *user_buffer)
 {
         struct host_to_dev_fis  fis;
-        struct host_to_dev_fis *reply = (port->rxfis + RX_FIS_D2H_REG);
+        struct host_to_dev_fis *reply;
+        u8 *buf = NULL;
+        dma_addr_t dma_addr = 0;
+        int rv = 0, xfer_sz = command[3];
+
+        if (xfer_sz) {
+                if (user_buffer)
+                        return -EFAULT;
+
+                buf = dmam_alloc_coherent(&port->dd->pdev->dev,
+                                ATA_SECT_SIZE * xfer_sz,
+                                &dma_addr,
+                                GFP_KERNEL);
+                if (!buf) {
+                        dev_err(&port->dd->pdev->dev,
+                                "Memory allocation failed (%d bytes)\n",
+                                ATA_SECT_SIZE * xfer_sz);
+                        return -ENOMEM;
+                }
+                memset(buf, 0, ATA_SECT_SIZE * xfer_sz);
+        }
 
         /* Build the FIS. */
         memset(&fis, 0, sizeof(struct host_to_dev_fis));
-        fis.type                = 0x27;
-        fis.opts                = 1 << 7;
-        fis.command             = command[0];
+        fis.type        = 0x27;
+        fis.opts        = 1 << 7;
+        fis.command     = command[0];
         fis.features    = command[2];
         fis.sect_count  = command[3];
         if (fis.command == ATA_CMD_SMART) {
@@ -1908,6 +1927,11 @@ static int exec_drive_command(struct mtip_port *port, u8 *command,
                 fis.cyl_hi      = 0xC2;
         }
 
+        if (xfer_sz)
+                reply = (port->rxfis + RX_FIS_PIO_SETUP);
+        else
+                reply = (port->rxfis + RX_FIS_D2H_REG);
+
         dbg_printk(MTIP_DRV_NAME
                 " %s: User Command: cmd %x, sect %x, "
                 "feat %x, sectcnt %x\n",
@@ -1917,43 +1941,46 @@ static int exec_drive_command(struct mtip_port *port, u8 *command,
                 command[2],
                 command[3]);
 
-        memset(port->sector_buffer, 0x00, ATA_SECT_SIZE);
-
         /* Execute the command. */
         if (mtip_exec_internal_command(port,
                                 &fis,
                                  5,
-                                 port->sector_buffer_dma,
-                                 (command[3] != 0) ? ATA_SECT_SIZE : 0,
+                                 (xfer_sz ? dma_addr : 0),
+                                 (xfer_sz ? ATA_SECT_SIZE * xfer_sz : 0),
                                  0,
                                  GFP_KERNEL,
                                  MTIP_IOCTL_COMMAND_TIMEOUT_MS)
                                  < 0) {
-                return -1;
+                rv = -EFAULT;
+                goto exit_drive_command;
         }
 
         /* Collect the completion status. */
         command[0] = reply->command; /* Status*/
         command[1] = reply->features; /* Error*/
-        command[2] = command[3];
+        command[2] = reply->sect_count;
 
         dbg_printk(MTIP_DRV_NAME
                 " %s: Completion Status: stat %x, "
-                "err %x, cmd %x\n",
+                "err %x, nsect %x\n",
                 __func__,
                 command[0],
                 command[1],
                 command[2]);
 
-        if (user_buffer && command[3]) {
+        if (xfer_sz) {
                 if (copy_to_user(user_buffer,
-                                 port->sector_buffer,
+                                 buf,
                                  ATA_SECT_SIZE * command[3])) {
-                        return -EFAULT;
+                        rv = -EFAULT;
+                        goto exit_drive_command;
                 }
         }
-
-        return 0;
+exit_drive_command:
+        if (buf)
+                dmam_free_coherent(&port->dd->pdev->dev,
+                                ATA_SECT_SIZE * xfer_sz, buf, dma_addr);
+        return rv;
 }
 
 /*
@@ -2003,6 +2030,32 @@ static unsigned int implicit_sector(unsigned char command,
         return rv;
 }
 
+static void mtip_set_timeout(struct host_to_dev_fis *fis, unsigned int *timeout)
+{
+        switch (fis->command) {
+        case ATA_CMD_DOWNLOAD_MICRO:
+                *timeout = 120000; /* 2 minutes */
+                break;
+        case ATA_CMD_SEC_ERASE_UNIT:
+        case 0xFC:
+                *timeout = 240000; /* 4 minutes */
+                break;
+        case ATA_CMD_STANDBYNOW1:
+                *timeout = 10000;  /* 10 seconds */
+                break;
+        case 0xF7:
+        case 0xFA:
+                *timeout = 60000;  /* 60 seconds */
+                break;
+        case ATA_CMD_SMART:
+                *timeout = 15000;  /* 15 seconds */
+                break;
+        default:
+                *timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS;
+                break;
+        }
+}
+
 /*
  * Executes a taskfile
  * See ide_taskfile_ioctl() for derivation
@@ -2023,7 +2076,7 @@ static int exec_drive_taskfile(struct driver_data *dd,
         unsigned int taskin = 0;
         unsigned int taskout = 0;
         u8 nsect = 0;
-        unsigned int timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS;
+        unsigned int timeout;
         unsigned int force_single_sector;
         unsigned int transfer_size;
         unsigned long task_file_data;
@@ -2153,32 +2206,7 @@ static int exec_drive_taskfile(struct driver_data *dd,
                 fis.lba_hi,
                 fis.device);
 
-        switch (fis.command) {
-        case ATA_CMD_DOWNLOAD_MICRO:
-                /* Change timeout for Download Microcode to 2 minutes */
-                timeout = 120000;
-                break;
-        case ATA_CMD_SEC_ERASE_UNIT:
-                /* Change timeout for Security Erase Unit to 4 minutes.*/
-                timeout = 240000;
-                break;
-        case ATA_CMD_STANDBYNOW1:
-                /* Change timeout for standby immediate to 10 seconds.*/
-                timeout = 10000;
-                break;
-        case 0xF7:
-        case 0xFA:
-                /* Change timeout for vendor unique command to 10 secs */
-                timeout = 10000;
-                break;
-        case ATA_CMD_SMART:
-                /* Change timeout for vendor unique command to 15 secs */
-                timeout = 15000;
-                break;
-        default:
-                timeout = MTIP_IOCTL_COMMAND_TIMEOUT_MS;
-                break;
-        }
+        mtip_set_timeout(&fis, &timeout);
 
         /* Determine the correct transfer size.*/
         if (force_single_sector)
@@ -2295,13 +2323,12 @@ static int mtip_hw_ioctl(struct driver_data *dd, unsigned int cmd,
 {
         switch (cmd) {
         case HDIO_GET_IDENTITY:
-                if (mtip_get_identify(dd->port, (void __user *) arg) < 0) {
-                        dev_warn(&dd->pdev->dev,
-                                "Unable to read identity\n");
-                        return -EIO;
-                }
-
+        {
+                if (copy_to_user((void __user *)arg, dd->port->identify,
+                                                sizeof(u16) * ATA_ID_WORDS))
+                        return -EFAULT;
                 break;
+        }
         case HDIO_DRIVE_CMD:
         {
                 u8 drive_command[4];
@@ -2537,40 +2564,58 @@ static ssize_t mtip_hw_show_registers(struct device *dev,
         int size = 0;
         int n;
 
-        size += sprintf(&buf[size], "S ACTive:\n");
+        size += sprintf(&buf[size], "Hardware\n--------\n");
+        size += sprintf(&buf[size], "S ACTive      : [ 0x");
 
-        for (n = 0; n < dd->slot_groups; n++)
-                size += sprintf(&buf[size], "0x%08x\n",
+        for (n = dd->slot_groups-1; n >= 0; n--)
+                size += sprintf(&buf[size], "%08X ",
                                          readl(dd->port->s_active[n]));
 
-        size += sprintf(&buf[size], "Command Issue:\n");
+        size += sprintf(&buf[size], "]\n");
+        size += sprintf(&buf[size], "Command Issue : [ 0x");
 
-        for (n = 0; n < dd->slot_groups; n++)
-                size += sprintf(&buf[size], "0x%08x\n",
+        for (n = dd->slot_groups-1; n >= 0; n--)
+                size += sprintf(&buf[size], "%08X ",
                                         readl(dd->port->cmd_issue[n]));
 
-        size += sprintf(&buf[size], "Allocated:\n");
+        size += sprintf(&buf[size], "]\n");
+        size += sprintf(&buf[size], "Completed     : [ 0x");
+
+        for (n = dd->slot_groups-1; n >= 0; n--)
+                size += sprintf(&buf[size], "%08X ",
+                                readl(dd->port->completed[n]));
+
+        size += sprintf(&buf[size], "]\n");
+        size += sprintf(&buf[size], "PORT IRQ STAT : [ 0x%08X ]\n",
+                                readl(dd->port->mmio + PORT_IRQ_STAT));
+        size += sprintf(&buf[size], "HOST IRQ STAT : [ 0x%08X ]\n",
+                                readl(dd->mmio + HOST_IRQ_STAT));
+        size += sprintf(&buf[size], "\n");
 
-        for (n = 0; n < dd->slot_groups; n++) {
+        size += sprintf(&buf[size], "Local\n-----\n");
+        size += sprintf(&buf[size], "Allocated    : [ 0x");
+
+        for (n = dd->slot_groups-1; n >= 0; n--) {
                 if (sizeof(long) > sizeof(u32))
                         group_allocated =
                                 dd->port->allocated[n/2] >> (32*(n&1));
                 else
                         group_allocated = dd->port->allocated[n];
-                size += sprintf(&buf[size], "0x%08x\n",
-                                 group_allocated);
+                size += sprintf(&buf[size], "%08X ", group_allocated);
         }
+        size += sprintf(&buf[size], "]\n");
 
-        size += sprintf(&buf[size], "Completed:\n");
-
-        for (n = 0; n < dd->slot_groups; n++)
-                size += sprintf(&buf[size], "0x%08x\n",
-                                readl(dd->port->completed[n]));
+        size += sprintf(&buf[size], "Commands in Q: [ 0x");
 
-        size += sprintf(&buf[size], "PORT IRQ STAT : 0x%08x\n",
-                                readl(dd->port->mmio + PORT_IRQ_STAT));
-        size += sprintf(&buf[size], "HOST IRQ STAT : 0x%08x\n",
-                                readl(dd->mmio + HOST_IRQ_STAT));
+        for (n = dd->slot_groups-1; n >= 0; n--) {
+                if (sizeof(long) > sizeof(u32))
+                        group_allocated =
+                                dd->port->cmds_to_issue[n/2] >> (32*(n&1));
+                else
+                        group_allocated = dd->port->cmds_to_issue[n];
+                size += sprintf(&buf[size], "%08X ", group_allocated);
+        }
+        size += sprintf(&buf[size], "]\n");
 
         return size;
 }
@@ -2592,8 +2637,24 @@ static ssize_t mtip_hw_show_status(struct device *dev,
         return size;
 }
 
+static ssize_t mtip_hw_show_flags(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct driver_data *dd = dev_to_disk(dev)->private_data;
+        int size = 0;
+
+        size += sprintf(&buf[size], "Flag in port struct : [ %08lX ]\n",
+                                                        dd->port->flags);
+        size += sprintf(&buf[size], "Flag in dd struct   : [ %08lX ]\n",
+                                                        dd->dd_flag);
+
+        return size;
+}
+
 static DEVICE_ATTR(registers, S_IRUGO, mtip_hw_show_registers, NULL);
 static DEVICE_ATTR(status, S_IRUGO, mtip_hw_show_status, NULL);
+static DEVICE_ATTR(flags, S_IRUGO, mtip_hw_show_flags, NULL);
 
 /*
  * Create the sysfs related attributes.
@@ -2616,6 +2677,9 @@ static int mtip_hw_sysfs_init(struct driver_data *dd, struct kobject *kobj)
         if (sysfs_create_file(kobj, &dev_attr_status.attr))
                 dev_warn(&dd->pdev->dev,
                         "Error creating 'status' sysfs entry\n");
+        if (sysfs_create_file(kobj, &dev_attr_flags.attr))
+                dev_warn(&dd->pdev->dev,
+                        "Error creating 'flags' sysfs entry\n");
         return 0;
 }
 
@@ -2636,6 +2700,7 @@ static int mtip_hw_sysfs_exit(struct driver_data *dd, struct kobject *kobj)
 
         sysfs_remove_file(kobj, &dev_attr_registers.attr);
         sysfs_remove_file(kobj, &dev_attr_status.attr);
+        sysfs_remove_file(kobj, &dev_attr_flags.attr);
 
         return 0;
 }
@@ -3634,7 +3699,10 @@ skip_create_disk:
         set_bit(QUEUE_FLAG_NONROT, &dd->queue->queue_flags);
         blk_queue_max_segments(dd->queue, MTIP_MAX_SG);
         blk_queue_physical_block_size(dd->queue, 4096);
+        blk_queue_max_hw_sectors(dd->queue, 0xffff);
+        blk_queue_max_segment_size(dd->queue, 0x400000);
         blk_queue_io_min(dd->queue, 4096);
+
         /*
          * write back cache is not supported in the device. FUA depends on
          * write back cache support, hence setting flush support to zero.
diff --git a/drivers/block/mtip32xx/mtip32xx.h b/drivers/block/mtip32xx/mtip32xx.h
index 4ef58336310a..b2c88da26b2a 100644
--- a/drivers/block/mtip32xx/mtip32xx.h
+++ b/drivers/block/mtip32xx/mtip32xx.h
@@ -113,33 +113,35 @@
 
 #define __force_bit2int (unsigned int __force)
 
-/* below are bit numbers in 'flags' defined in mtip_port */
-#define MTIP_PF_IC_ACTIVE_BIT           0 /* pio/ioctl */
-#define MTIP_PF_EH_ACTIVE_BIT           1 /* error handling */
-#define MTIP_PF_SE_ACTIVE_BIT           2 /* secure erase */
-#define MTIP_PF_DM_ACTIVE_BIT           3 /* download microcde */
-#define MTIP_PF_PAUSE_IO        ((1 << MTIP_PF_IC_ACTIVE_BIT) | \
+enum {
+        /* below are bit numbers in 'flags' defined in mtip_port */
+        MTIP_PF_IC_ACTIVE_BIT       = 0, /* pio/ioctl */
+        MTIP_PF_EH_ACTIVE_BIT       = 1, /* error handling */
+        MTIP_PF_SE_ACTIVE_BIT       = 2, /* secure erase */
+        MTIP_PF_DM_ACTIVE_BIT       = 3, /* download microcde */
+        MTIP_PF_PAUSE_IO      = ((1 << MTIP_PF_IC_ACTIVE_BIT) | \
                                 (1 << MTIP_PF_EH_ACTIVE_BIT) | \
                                 (1 << MTIP_PF_SE_ACTIVE_BIT) | \
-                                (1 << MTIP_PF_DM_ACTIVE_BIT))
-
-#define MTIP_PF_SVC_THD_ACTIVE_BIT      4
-#define MTIP_PF_ISSUE_CMDS_BIT          5
-#define MTIP_PF_REBUILD_BIT             6
-#define MTIP_PF_SVC_THD_STOP_BIT        8
-
-/* below are bit numbers in 'dd_flag' defined in driver_data */
-#define MTIP_DDF_REMOVE_PENDING_BIT     1
-#define MTIP_DDF_OVER_TEMP_BIT          2
-#define MTIP_DDF_WRITE_PROTECT_BIT      3
-#define MTIP_DDF_STOP_IO        ((1 << MTIP_DDF_REMOVE_PENDING_BIT) | \
+                                (1 << MTIP_PF_DM_ACTIVE_BIT)),
+
+        MTIP_PF_SVC_THD_ACTIVE_BIT  = 4,
+        MTIP_PF_ISSUE_CMDS_BIT      = 5,
+        MTIP_PF_REBUILD_BIT         = 6,
+        MTIP_PF_SVC_THD_STOP_BIT    = 8,
+
+        /* below are bit numbers in 'dd_flag' defined in driver_data */
+        MTIP_DDF_REMOVE_PENDING_BIT = 1,
+        MTIP_DDF_OVER_TEMP_BIT      = 2,
+        MTIP_DDF_WRITE_PROTECT_BIT  = 3,
+        MTIP_DDF_STOP_IO      = ((1 << MTIP_DDF_REMOVE_PENDING_BIT) | \
                                 (1 << MTIP_DDF_OVER_TEMP_BIT) | \
-                                (1 << MTIP_DDF_WRITE_PROTECT_BIT))
+                                (1 << MTIP_DDF_WRITE_PROTECT_BIT)),
 
-#define MTIP_DDF_CLEANUP_BIT            5
-#define MTIP_DDF_RESUME_BIT             6
-#define MTIP_DDF_INIT_DONE_BIT          7
-#define MTIP_DDF_REBUILD_FAILED_BIT     8
+        MTIP_DDF_CLEANUP_BIT        = 5,
+        MTIP_DDF_RESUME_BIT         = 6,
+        MTIP_DDF_INIT_DONE_BIT      = 7,
+        MTIP_DDF_REBUILD_FAILED_BIT = 8,
+};
 
 __packed struct smart_attr{
         u8 attr_id;