oxnas: sata_oxnas: refactoring phase 1
authorFelix Fietkau <nbd@openwrt.org>
Mon, 22 Dec 2014 20:46:49 +0000 (20:46 +0000)
committerFelix Fietkau <nbd@openwrt.org>
Mon, 22 Dec 2014 20:46:49 +0000 (20:46 +0000)
locking for 2nd port and hwraid was added from vendor's GPL code which
doesn't comply with current kernel coding style.

 - moved all global variables into host_priv
 - renamed locks
 - sanetized acquire() and release() parameter list

Signed-off-by: Daniel Golle <daniel@makrotopia.org>
SVN-Revision: 43766

target/linux/oxnas/files/drivers/ata/sata_oxnas.c
target/linux/oxnas/patches-3.14/999-libata-hacks.patch
target/linux/oxnas/patches-3.18/999-libata-hacks.patch

index f8b53f1ef6c4f7803fab2c1d2637d8cf8c000084..39e73d7d1836ba593d7a9d6ca64daf9df4bbc71d 100644 (file)
@@ -335,6 +335,8 @@ enum {
        SATA_SCSI_STACK
 };
 
+typedef irqreturn_t (*oxnas_sata_isr_callback_t)(int, unsigned long, int);
+
 struct sata_oxnas_host_priv {
        void __iomem *port_base;
        void __iomem *dmactl_base;
@@ -353,12 +355,22 @@ struct sata_oxnas_host_priv {
        struct reset_control *rst_sata;
        struct reset_control *rst_link;
        struct reset_control *rst_phy;
+       spinlock_t phy_lock;
+       spinlock_t core_lock;
+       int core_locked;
+       int reentrant_port_no;
+       int hw_lock_count;
+       int direct_lock_count;
+       void *locker_uid;
+       int current_locker_type;
+       int scsi_nonblocking_attempts;
+       oxnas_sata_isr_callback_t isr_callback;
+       void *isr_arg;
+       wait_queue_head_t fast_wait_queue;
+       wait_queue_head_t scsi_wait_queue;
 };
 
-typedef irqreturn_t (*ox820sata_isr_callback_t)(int, unsigned long, int);
 
-static DEFINE_SPINLOCK(oxsphy_lock);
-static DEFINE_SPINLOCK(oxsacs_lock);
 struct sata_oxnas_port_priv {
        void __iomem *port_base;
        void __iomem *dmactl_base;
@@ -375,22 +387,11 @@ static void sata_oxnas_tf_load(struct ata_port *ap,
 static void sata_oxnas_irq_on(struct ata_port *ap);
 static void sata_oxnas_post_reset_init(struct ata_port *ap);
 
-static int sata_oxnas_acquire_hw(int port_no, int may_sleep,
-                               int timeout_jiffies);
-static void sata_oxnas_release_hw(unsigned int port_no);
+static int sata_oxnas_acquire_hw(struct ata_port *ap, int may_sleep,
+                                int timeout_jiffies);
+static void sata_oxnas_release_hw(struct ata_port *ap);
 
-static int core_locked = 0;
-static int reentrant_port_no = -1;
-static int hw_lock_count = 0;
-static int direct_lock_count = 0;
-static void *locker_uid = 0;
-static int current_locker_type = SATA_UNLOCKED;
 static const void *HW_LOCKER_UID = (void*)0xdeadbeef;
-static DECLARE_WAIT_QUEUE_HEAD(fast_wait_queue);
-static DECLARE_WAIT_QUEUE_HEAD(scsi_wait_queue);
-static ox820sata_isr_callback_t ox820sata_isr_callback = NULL;
-static unsigned long ox820sata_isr_arg = 0;
-static int scsi_nonblocking_attempts = 0;
 
 /***************************************************************************
 * ASIC access
@@ -451,14 +452,15 @@ void workaround5458(struct ata_host *ah)
  */
 void sata_oxnas_link_write(struct ata_port *ap, unsigned int link_reg, u32 val)
 {
-       struct sata_oxnas_port_priv *port_priv = ap->private_data;
-       void __iomem *port_base = port_priv->port_base;
+       struct sata_oxnas_port_priv *pd = ap->private_data;
+       struct sata_oxnas_host_priv *hd = ap->host->private_data;
+       void __iomem *port_base = pd->port_base;
        u32 patience;
        unsigned long flags;
 
        DPRINTK("P%d [0x%02x]->0x%08x\n", ap->port_no, link_reg, val);
 
-       spin_lock_irqsave(&oxsphy_lock, flags);
+       spin_lock_irqsave(&hd->phy_lock, flags);
        iowrite32(val, port_base + LINK_DATA);
 
        /* accessed twice as a work around for a bug in the SATA abp bridge
@@ -470,7 +472,7 @@ void sata_oxnas_link_write(struct ata_port *ap, unsigned int link_reg, u32 val)
                if (ioread32(port_base + LINK_CONTROL) & 0x00000001)
                        break;
        }
-       spin_unlock_irqrestore(&oxsphy_lock, flags);
+       spin_unlock_irqrestore(&hd->phy_lock, flags);
 }
 
 static int sata_oxnas_scr_write_port(struct ata_port *ap, unsigned int sc_reg,
@@ -489,12 +491,13 @@ static int sata_oxnas_scr_write(struct ata_link *link, unsigned int sc_reg,
 u32 sata_oxnas_link_read(struct ata_port *ap, unsigned int link_reg)
 {
        struct sata_oxnas_port_priv *pd = ap->private_data;
+       struct sata_oxnas_host_priv *hd = ap->host->private_data;
        void __iomem *port_base = pd->port_base;
        u32 result;
        u32 patience;
        unsigned long flags;
 
-       spin_lock_irqsave(&oxsphy_lock, flags);
+       spin_lock_irqsave(&hd->phy_lock, flags);
        /* accessed twice as a work around for a bug in the SATA abp bridge
         * hardware (bug 6828) */
        iowrite32(link_reg, port_base + LINK_RD_ADDR);
@@ -508,7 +511,7 @@ u32 sata_oxnas_link_read(struct ata_port *ap, unsigned int link_reg)
                DPRINTK("link read timed out for port %d\n", ap->port_no);
 
        result = ioread32(port_base + LINK_DATA);
-       spin_unlock_irqrestore(&oxsphy_lock, flags);
+       spin_unlock_irqrestore(&hd->phy_lock, flags);
 
        return result;
 }
@@ -641,9 +644,10 @@ void sata_oxnas_checkforhotplug(struct ata_port *ap)
  *         sata core.
  */
 static int __acquire_sata_core(
+       struct ata_host *ah,
        int port_no,
-       ox820sata_isr_callback_t callback,
-       unsigned long            arg,
+       oxnas_sata_isr_callback_t callback,
+       void                    *arg,
        int                      may_sleep,
        int                      timeout_jiffies,
        int                      hw_access,
@@ -654,33 +658,40 @@ static int __acquire_sata_core(
        int           acquired = 0;
        unsigned long flags;
        int           timed_out = 0;
+       struct sata_oxnas_host_priv *hd;
+
        DEFINE_WAIT(wait);
 
-       spin_lock_irqsave(&oxsacs_lock, flags);
+       if (!ah)
+               return acquired;
+
+       hd = ah->private_data;
+
+       spin_lock_irqsave(&hd->core_lock, flags);
 
        DPRINTK("Entered uid %p, port %d, h/w count %d, d count %d, callback %p, "
-                   "hw_access %d, core_locked %d, reentrant_port_no %d, ox820sata_isr_callback %p\n",
-               uid, port_no, hw_lock_count, direct_lock_count, callback, hw_access,
-               core_locked, reentrant_port_no, ox820sata_isr_callback);
+                   "hw_access %d, core_locked %d, reentrant_port_no %d, isr_callback %p\n",
+               uid, port_no, hd->hw_lock_count, hd->direct_lock_count, callback, hw_access,
+               hd->core_locked, hd->reentrant_port_no, hd->isr_callback);
 
        while (!timed_out) {
-               if (core_locked || (!hw_access && scsi_nonblocking_attempts)) {
+               if (hd->core_locked || (!hw_access && hd->scsi_nonblocking_attempts)) {
                        /* Can only allow access if from SCSI/SATA stack and if
                           reentrant access is allowed and this access is to the same
                           port for which the lock is current held */
-                       if (hw_access && (port_no == reentrant_port_no)) {
-                               BUG_ON(!hw_lock_count);
-                               ++hw_lock_count;
+                       if (hw_access && (port_no == hd->reentrant_port_no)) {
+                               BUG_ON(!hd->hw_lock_count);
+                               ++(hd->hw_lock_count);
 
                                DPRINTK("Allow SCSI/SATA re-entrant access to uid %p port %d\n", uid, port_no);
                                acquired = 1;
                                break;
                        } else if (!hw_access) {
-                               if ((locker_type == SATA_READER) && (current_locker_type == SATA_READER)) {
+                               if ((locker_type == SATA_READER) && (hd->current_locker_type == SATA_READER)) {
                                        WARN(1,
                                                "Already locked by reader, uid %p, locker_uid %p, port %d, "
-                                               "h/w count %d, d count %d, hw_access %d\n", uid, locker_uid,
-                                               port_no, hw_lock_count, direct_lock_count, hw_access);
+                                               "h/w count %d, d count %d, hw_access %d\n", uid, hd->locker_uid,
+                                               port_no, hd->hw_lock_count, hd->direct_lock_count, hw_access);
                                        goto check_uid;
                                }
 
@@ -689,52 +700,52 @@ static int __acquire_sata_core(
                                }
 
 check_uid:
-                               WARN(uid == locker_uid, "Attempt to lock by locker type %d "
+                               WARN(uid == hd->locker_uid, "Attempt to lock by locker type %d "
                                        "uid %p, already locked by locker type %d with "
                                        "locker_uid %p, port %d, h/w count %d, d count %d, "
-                                       "hw_access %d\n", locker_type, uid, current_locker_type,
-                                       locker_uid, port_no, hw_lock_count, direct_lock_count, hw_access);
+                                       "hw_access %d\n", locker_type, uid, hd->current_locker_type,
+                                       hd->locker_uid, port_no, hd->hw_lock_count, hd->direct_lock_count, hw_access);
                        }
                } else {
-                       WARN(hw_lock_count || direct_lock_count, "Core unlocked but counts "
+                       WARN(hd->hw_lock_count || hd->direct_lock_count, "Core unlocked but counts "
                                "non-zero: uid %p, locker_uid %p, port %d, h/w count %d, "
-                               "d count %d, hw_access %d\n", uid, locker_uid, port_no,
-                               hw_lock_count, direct_lock_count, hw_access);
+                               "d count %d, hw_access %d\n", uid, hd->locker_uid, port_no,
+                               hd->hw_lock_count, hd->direct_lock_count, hw_access);
 
-                       BUG_ON(current_locker_type != SATA_UNLOCKED);
+                       BUG_ON(hd->current_locker_type != SATA_UNLOCKED);
 
-                       WARN(locker_uid, "Attempt to lock uid %p when locker_uid %p is "
+                       WARN(hd->locker_uid, "Attempt to lock uid %p when locker_uid %p is "
                                "non-zero,  port %d, h/w count %d, d count %d, hw_access %d\n",
-                               uid, locker_uid, port_no, hw_lock_count, direct_lock_count,
+                               uid, hd->locker_uid, port_no, hd->hw_lock_count, hd->direct_lock_count,
                                hw_access);
 
                        if (!hw_access) {
                                /* Direct access attempting to acquire non-contented lock */
                                BUG_ON(!callback);      // Must have callback for direct access
-                               BUG_ON(reentrant_port_no != -1); // Sanity check lock state
+                               BUG_ON(hd->reentrant_port_no != -1); // Sanity check lock state
 
-                               ox820sata_isr_callback = callback;
-                               ox820sata_isr_arg = arg;
-                               ++direct_lock_count;
+                               hd->isr_callback = callback;
+                               hd->isr_arg = arg;
+                               ++(hd->direct_lock_count);
 
-                               current_locker_type = locker_type;
+                               hd->current_locker_type = locker_type;
                        } else {
                                /* SCSI/SATA attempting to acquire non-contented lock */
                                BUG_ON(callback);       // No callbacks for SCSI/SATA access
                                BUG_ON(arg);            // No callback args for SCSI/SATA access
 
-                               BUG_ON(ox820sata_isr_callback); // Sanity check lock state
-                               BUG_ON(ox820sata_isr_arg);              // Sanity check lock state
+                               BUG_ON(hd->isr_callback);       // Sanity check lock state
+                               BUG_ON(hd->isr_arg);            // Sanity check lock state
 
-                               ++hw_lock_count;
-                               reentrant_port_no = port_no;
+                               ++(hd->hw_lock_count);
+                               hd->reentrant_port_no = port_no;
 
-                               current_locker_type = SATA_SCSI_STACK;
+                               hd->current_locker_type = SATA_SCSI_STACK;
                        }
 
-                       core_locked = 1;
+                       hd->core_locked = 1;
+                       hd->locker_uid = uid;
                        acquired = 1;
-                       locker_uid = uid;
                        break;
                }
 
@@ -742,10 +753,10 @@ wait_for_lock:
                if (!may_sleep) {
                        DPRINTK("Denying for uid %p locker_type %d, hw_access %d, port %d, "
                        "current_locker_type %d as cannot sleep\n", uid, locker_type,
-                       hw_access, port_no, current_locker_type);
+                       hw_access, port_no, hd->current_locker_type);
 
                        if (hw_access) {
-                               ++scsi_nonblocking_attempts;
+                               ++(hd->scsi_nonblocking_attempts);
                        }
                        break;
                }
@@ -753,9 +764,9 @@ wait_for_lock:
                // Core is locked and we're allowed to sleep, so wait to be awoken when
                // the core is unlocked
                for (;;) {
-                       prepare_to_wait(hw_access ? &scsi_wait_queue : &fast_wait_queue,
+                       prepare_to_wait(hw_access ? &hd->scsi_wait_queue : &hd->fast_wait_queue,
                                &wait, TASK_UNINTERRUPTIBLE);
-                       if (!core_locked && !(!hw_access && scsi_nonblocking_attempts)) {
+                       if (!hd->core_locked && !(!hw_access && hd->scsi_nonblocking_attempts)) {
                                // We're going to use variables that will have been changed by
                                // the waker prior to clearing core_locked so we need to ensure
                                // we see changes to all those variables
@@ -765,28 +776,28 @@ wait_for_lock:
                        if (time_after(jiffies, end)) {
                                printk("__acquire_sata_core() uid %p failing for port %d timed out, "
                                           "locker_uid %p, h/w count %d, d count %d, callback %p, hw_access %d, "
-                                          "core_locked %d, reentrant_port_no %d, ox820sata_isr_callback %p, "
-                                          "ox820sata_isr_arg %p\n", uid, port_no, locker_uid,
-                                          hw_lock_count, direct_lock_count, callback, hw_access,
-                                          core_locked, reentrant_port_no, ox820sata_isr_callback,
-                                          (void*)ox820sata_isr_arg);
+                                          "core_locked %d, reentrant_port_no %d, isr_callback %p, "
+                                          "isr_arg %p\n", uid, port_no, hd->locker_uid,
+                                          hd->hw_lock_count, hd->direct_lock_count, callback, hw_access,
+                                          hd->core_locked, hd->reentrant_port_no, hd->isr_callback,
+                                          hd->isr_arg);
                                timed_out = 1;
                                break;
                        }
-                       spin_unlock_irqrestore(&oxsacs_lock, flags);
+                       spin_unlock_irqrestore(&hd->core_lock, flags);
                        if (!schedule_timeout(4*HZ)) {
                                printk(KERN_INFO "__acquire_sata_core() uid %p, locker_uid %p, "
                                        "timed-out of schedule(), checking overall timeout\n",
-                                       uid, locker_uid);
+                                       uid, hd->locker_uid);
                        }
-                       spin_lock_irqsave(&oxsacs_lock, flags);
+                       spin_lock_irqsave(&hd->core_lock, flags);
                }
-               finish_wait(hw_access ? &scsi_wait_queue : &fast_wait_queue, &wait);
+               finish_wait(hw_access ? &hd->scsi_wait_queue : &hd->fast_wait_queue, &wait);
        }
 
        if (hw_access && acquired) {
-               if (scsi_nonblocking_attempts) {
-                       scsi_nonblocking_attempts = 0;
+               if (hd->scsi_nonblocking_attempts) {
+                       hd->scsi_nonblocking_attempts = 0;
                }
 
                // Wake any other SCSI/SATA waiters so they can get reentrant access to
@@ -794,39 +805,41 @@ wait_for_lock:
                // locked by fast access, or SCSI/SATA access to other port, then can
                // have >1 SCSI/SATA waiters on the wait list so want to give reentrant
                // accessors a chance to get access ASAP
-               if (!list_empty(&scsi_wait_queue.task_list)) {
-                       wake_up(&scsi_wait_queue);
+               if (!list_empty(&hd->scsi_wait_queue.task_list)) {
+                       wake_up(&hd->scsi_wait_queue);
                }
        }
 
        DPRINTK("Leaving uid %p with acquired = %d, port %d, callback %p\n", uid, acquired, port_no, callback);
 
-       spin_unlock_irqrestore(&oxsacs_lock, flags);
+       spin_unlock_irqrestore(&hd->core_lock, flags);
 
        return acquired;
 }
 
-int sata_core_has_fast_waiters(void)
+int sata_core_has_fast_waiters(struct ata_host *ah)
 {
        int has_waiters;
        unsigned long flags;
+       struct sata_oxnas_host_priv *hd = ah->private_data;
 
-       spin_lock_irqsave(&oxsacs_lock, flags);
-       has_waiters = !list_empty(&fast_wait_queue.task_list);
-       spin_unlock_irqrestore(&oxsacs_lock, flags);
+       spin_lock_irqsave(&hd->core_lock, flags);
+       has_waiters = !list_empty(&hd->fast_wait_queue.task_list);
+       spin_unlock_irqrestore(&hd->core_lock, flags);
 
        return has_waiters;
 }
 EXPORT_SYMBOL(sata_core_has_fast_waiters);
 
-int sata_core_has_scsi_waiters(void)
+int sata_core_has_scsi_waiters(struct ata_host *ah)
 {
        int has_waiters;
        unsigned long flags;
+       struct sata_oxnas_host_priv *hd = ah->private_data;
 
-       spin_lock_irqsave(&oxsacs_lock, flags);
-       has_waiters = scsi_nonblocking_attempts || !list_empty(&scsi_wait_queue.task_list);
-       spin_unlock_irqrestore(&oxsacs_lock, flags);
+       spin_lock_irqsave(&hd->core_lock, flags);
+       has_waiters = hd->scsi_nonblocking_attempts || !list_empty(&hd->scsi_wait_queue.task_list);
+       spin_unlock_irqrestore(&hd->core_lock, flags);
 
        return has_waiters;
 }
@@ -839,64 +852,65 @@ EXPORT_SYMBOL(sata_core_has_scsi_waiters);
  * port may be operated on at once.
  */
 static int sata_oxnas_acquire_hw(
-       int port_no,
+       struct ata_port *ap,
        int may_sleep,
        int timeout_jiffies)
 {
-       return __acquire_sata_core(port_no, NULL, 0, may_sleep, timeout_jiffies, 1, (void*)HW_LOCKER_UID, SATA_SCSI_STACK);
+       return __acquire_sata_core(ap->host, ap->port_no, NULL, 0, may_sleep, timeout_jiffies, 1, (void*)HW_LOCKER_UID, SATA_SCSI_STACK);
 }
 
 /*
  * operation to release ownership of the SATA hardware
  */
-static void sata_oxnas_release_hw(unsigned int port_no)
+static void sata_oxnas_release_hw(struct ata_port *ap)
 {
        unsigned long flags;
        int released = 0;
+       struct sata_oxnas_host_priv *hd = ap->host->private_data;
 
-       spin_lock_irqsave(&oxsacs_lock, flags);
+       spin_lock_irqsave(&hd->core_lock, flags);
 
        DPRINTK("Entered port_no = %d, h/w count %d, d count %d, core locked = %d, "
-               "reentrant_port_no = %d, ox820sata_isr_callback %p\n", port_no,
-               hw_lock_count, direct_lock_count, core_locked, reentrant_port_no, ox820sata_isr_callback);
+               "reentrant_port_no = %d, isr_callback %p\n", ap->port_no,
+               hd->hw_lock_count, hd->direct_lock_count, hd->core_locked, hd->reentrant_port_no, hd->isr_callback);
 
-       if (!core_locked) {
+       if (!hd->core_locked) {
                /* Nobody holds the SATA lock */
-               printk(KERN_WARNING "Nobody holds SATA lock, port_no %d\n", port_no);
+               printk(KERN_WARNING "Nobody holds SATA lock, port_no %d\n", ap->port_no);
                released = 1;
-       } else if (!hw_lock_count) {
+       } else if (!hd->hw_lock_count) {
                /* SCSI/SATA has released without holding the lock */
-               printk(KERN_WARNING "SCSI/SATA does not hold SATA lock, port_no %d\n", port_no);
+               printk(KERN_WARNING "SCSI/SATA does not hold SATA lock, port_no %d\n", ap->port_no);
        } else {
                /* Trap incorrect usage */
-               BUG_ON(reentrant_port_no == -1);
-               BUG_ON(port_no != reentrant_port_no);
-               BUG_ON(direct_lock_count);
-               BUG_ON(current_locker_type != SATA_SCSI_STACK);
+               BUG_ON(hd->reentrant_port_no == -1);
+               BUG_ON(ap->port_no != hd->reentrant_port_no);
+               BUG_ON(hd->direct_lock_count);
+               BUG_ON(hd->current_locker_type != SATA_SCSI_STACK);
 
-               WARN(!locker_uid || (locker_uid != HW_LOCKER_UID), "Invalid locker "
+               WARN(!hd->locker_uid || (hd->locker_uid != HW_LOCKER_UID), "Invalid locker "
                        "uid %p, h/w count %d, d count %d, reentrant_port_no %d, "
-                       "core_locked %d, ox820sata_isr_callback %p\n", locker_uid,
-                       hw_lock_count, direct_lock_count, reentrant_port_no, core_locked,
-                       ox820sata_isr_callback);
+                       "core_locked %d, isr_callback %p\n", hd->locker_uid,
+                       hd->hw_lock_count, hd->direct_lock_count, hd->reentrant_port_no,
+                       hd->core_locked, hd->isr_callback);
 
-               if (--hw_lock_count) {
-                       DPRINTK("Still nested port_no %d\n", port_no);
+               if (--(hd->hw_lock_count)) {
+                       DPRINTK("Still nested port_no %d\n", ap->port_no);
                } else {
-                       DPRINTK("Release port_no %d\n", port_no);
-                       reentrant_port_no = -1;
-                       ox820sata_isr_callback = NULL;
-                       current_locker_type = SATA_UNLOCKED;
-                       locker_uid = 0;
-                       core_locked = 0;
+                       DPRINTK("Release port_no %d\n", ap->port_no);
+                       hd->reentrant_port_no = -1;
+                       hd->isr_callback = NULL;
+                       hd->current_locker_type = SATA_UNLOCKED;
+                       hd->locker_uid = 0;
+                       hd->core_locked = 0;
                        released = 1;
-                       wake_up(!list_empty(&scsi_wait_queue.task_list) ? &scsi_wait_queue : &fast_wait_queue);
+                       wake_up(!list_empty(&hd->scsi_wait_queue.task_list) ? &hd->scsi_wait_queue : &hd->fast_wait_queue);
                }
        }
 
-       DPRINTK("Leaving, port_no %d, count %d\n", port_no, hw_lock_count);
+       DPRINTK("Leaving, port_no %d, count %d\n", ap->port_no, hd->hw_lock_count);
 
-       spin_unlock_irqrestore(&oxsacs_lock, flags);
+       spin_unlock_irqrestore(&hd->core_lock, flags);
 
        /* CONFIG_SATA_OX820_DIRECT_HWRAID */
        /*    if (released)
@@ -1468,7 +1482,7 @@ static int sata_oxnas_qc_new(struct ata_port *ap)
        if (hd->port_frozen || hd->port_in_eh)
                return 1;
        else
-               return !sata_oxnas_acquire_hw(ap->port_no, 0, 0);
+               return !sata_oxnas_acquire_hw(ap, 0, 0);
 }
 
 /**
@@ -1477,7 +1491,7 @@ static int sata_oxnas_qc_new(struct ata_port *ap)
 static void sata_oxnas_qc_free(struct ata_queued_cmd *qc)
 {
        DPRINTK("\n");
-       sata_oxnas_release_hw(qc->ap->port_no);
+       sata_oxnas_release_hw(qc->ap);
 }
 
 static void sata_oxnas_freeze(struct ata_port* ap)
@@ -2271,6 +2285,20 @@ static int sata_oxnas_probe(struct platform_device *ofdev)
        host->private_data = host_priv;
        host->iomap = port_base;
 
+       /* initialize core locking and queues */
+       init_waitqueue_head(&host_priv->fast_wait_queue);
+       init_waitqueue_head(&host_priv->scsi_wait_queue);
+       spin_lock_init(&host_priv->phy_lock);
+       spin_lock_init(&host_priv->core_lock);
+       host_priv->core_locked = 0;
+       host_priv->reentrant_port_no = -1;
+       host_priv->hw_lock_count = 0;
+       host_priv->direct_lock_count = 0;
+       host_priv->locker_uid = 0;
+       host_priv->current_locker_type = SATA_UNLOCKED;
+       host_priv->isr_arg = NULL;
+       host_priv->isr_callback = NULL;
+
        /* initialize host controller */
        retval = sata_oxnas_init_controller(host);
        if (retval)
index 39d9e51cf02418ab57d3a01643783e62c1e2b1d0..a1c80d89eb9d184d74dd6577e21ce7b2ef8fd1aa 100644 (file)
@@ -6,9 +6,9 @@ Index: linux-3.18-rc7/drivers/ata/libata-core.c
                return AC_ERR_SYSTEM;
        }
  
-+      if (ap->ops->acquire_hw && !ap->ops->acquire_hw(ap->port_no, 0, 0)) {
++      if (ap->ops->acquire_hw && !ap->ops->acquire_hw(ap, 0, 0)) {
 +              spin_unlock_irqrestore(ap->lock, flags);
-+              if (!ap->ops->acquire_hw(ap->port_no, 1, (2*HZ))) {
++              if (!ap->ops->acquire_hw(ap, 1, (2*HZ))) {
 +                      return AC_ERR_TIMEOUT;
 +              }
 +              spin_lock_irqsave(ap->lock, flags);
@@ -49,11 +49,12 @@ Index: linux-3.18-rc7/include/linux/libata.h
  
        /*
         * Configuration and exception handling
-@@ -974,6 +976,8 @@ struct ata_port_operations {
+@@ -974,6 +976,9 @@ struct ata_port_operations {
        void (*phy_reset)(struct ata_port *ap);
        void (*eng_timeout)(struct ata_port *ap);
  
-+      int (*acquire_hw)(int port_no, int may_sleep, int timeout_jiffies);
++      int (*acquire_hw)(struct ata_port *ap, int may_sleep,
++                        int timeout_jiffies);
 +
        /*
         * ->inherits must be the last field and all the preceding
index 39d9e51cf02418ab57d3a01643783e62c1e2b1d0..a1c80d89eb9d184d74dd6577e21ce7b2ef8fd1aa 100644 (file)
@@ -6,9 +6,9 @@ Index: linux-3.18-rc7/drivers/ata/libata-core.c
                return AC_ERR_SYSTEM;
        }
  
-+      if (ap->ops->acquire_hw && !ap->ops->acquire_hw(ap->port_no, 0, 0)) {
++      if (ap->ops->acquire_hw && !ap->ops->acquire_hw(ap, 0, 0)) {
 +              spin_unlock_irqrestore(ap->lock, flags);
-+              if (!ap->ops->acquire_hw(ap->port_no, 1, (2*HZ))) {
++              if (!ap->ops->acquire_hw(ap, 1, (2*HZ))) {
 +                      return AC_ERR_TIMEOUT;
 +              }
 +              spin_lock_irqsave(ap->lock, flags);
@@ -49,11 +49,12 @@ Index: linux-3.18-rc7/include/linux/libata.h
  
        /*
         * Configuration and exception handling
-@@ -974,6 +976,8 @@ struct ata_port_operations {
+@@ -974,6 +976,9 @@ struct ata_port_operations {
        void (*phy_reset)(struct ata_port *ap);
        void (*eng_timeout)(struct ata_port *ap);
  
-+      int (*acquire_hw)(int port_no, int may_sleep, int timeout_jiffies);
++      int (*acquire_hw)(struct ata_port *ap, int may_sleep,
++                        int timeout_jiffies);
 +
        /*
         * ->inherits must be the last field and all the preceding