aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/ata
diff options
context:
space:
mode:
authorTejun Heo <tj@kernel.org>2010-05-10 15:41:30 -0400
committerJeff Garzik <jgarzik@redhat.com>2010-05-17 22:49:02 -0400
commit3e4ec3443f70fbe144799ccf0b1c3797f78d1715 (patch)
treecfb297e42075baacbbabfb6034e3e7c9a44c73b2 /drivers/ata
parentc7a8209f766961eea4cfc6f22d2d6e06ef63546c (diff)
libata: kill ATA_FLAG_DISABLED
ATA_FLAG_DISABLED is only used by drivers which don't use ->error_handler framework and is largely broken. Its only meaningful function is to make irq handlers skip processing if the flag is set, which is largely useless and even harmful as it makes those ports more likely to cause IRQ storms. Kill ATA_FLAG_DISABLED and makes the callers disable attached devices instead. ata_port_probe() and ata_port_disable() which manipulate the flag are also killed. This simplifies condition check in IRQ handlers. While updating IRQ handlers, remove ap NULL check as libata guarantees consecutive port allocation (unoccupied ports are initialized with dummies) and long-obsolete ATA_QCFLAG_ACTIVE check (checked by ata_qc_from_tag()). Signed-off-by: Tejun Heo <tj@kernel.org> Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
Diffstat (limited to 'drivers/ata')
-rw-r--r--drivers/ata/libata-core.c66
-rw-r--r--drivers/ata/libata-scsi.c3
-rw-r--r--drivers/ata/libata-sff.c10
-rw-r--r--drivers/ata/pata_bf54x.c16
-rw-r--r--drivers/ata/pata_octeon_cf.c9
-rw-r--r--drivers/ata/pdc_adma.c66
-rw-r--r--drivers/ata/sata_inic162x.c17
-rw-r--r--drivers/ata/sata_mv.c18
-rw-r--r--drivers/ata/sata_nv.c236
-rw-r--r--drivers/ata/sata_promise.c6
-rw-r--r--drivers/ata/sata_qstor.c79
-rw-r--r--drivers/ata/sata_sil.c3
-rw-r--r--drivers/ata/sata_sil24.c9
-rw-r--r--drivers/ata/sata_sx4.c3
-rw-r--r--drivers/ata/sata_vsc.c10
15 files changed, 205 insertions, 346 deletions
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 86f405b4831c..3d8b62f7441c 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -1907,22 +1907,6 @@ unsigned ata_exec_internal_sg(struct ata_device *dev,
1907 ap->qc_active = preempted_qc_active; 1907 ap->qc_active = preempted_qc_active;
1908 ap->nr_active_links = preempted_nr_active_links; 1908 ap->nr_active_links = preempted_nr_active_links;
1909 1909
1910 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1911 * Until those drivers are fixed, we detect the condition
1912 * here, fail the command with AC_ERR_SYSTEM and reenable the
1913 * port.
1914 *
1915 * Note that this doesn't change any behavior as internal
1916 * command failure results in disabling the device in the
1917 * higher layer for LLDDs without new reset/EH callbacks.
1918 *
1919 * Kill the following code as soon as those drivers are fixed.
1920 */
1921 if (ap->flags & ATA_FLAG_DISABLED) {
1922 err_mask |= AC_ERR_SYSTEM;
1923 ata_port_probe(ap);
1924 }
1925
1926 spin_unlock_irqrestore(ap->lock, flags); 1910 spin_unlock_irqrestore(ap->lock, flags);
1927 1911
1928 if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout) 1912 if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
@@ -2768,8 +2752,6 @@ int ata_bus_probe(struct ata_port *ap)
2768 int rc; 2752 int rc;
2769 struct ata_device *dev; 2753 struct ata_device *dev;
2770 2754
2771 ata_port_probe(ap);
2772
2773 ata_for_each_dev(dev, &ap->link, ALL) 2755 ata_for_each_dev(dev, &ap->link, ALL)
2774 tries[dev->devno] = ATA_PROBE_MAX_TRIES; 2756 tries[dev->devno] = ATA_PROBE_MAX_TRIES;
2775 2757
@@ -2797,8 +2779,7 @@ int ata_bus_probe(struct ata_port *ap)
2797 ap->ops->phy_reset(ap); 2779 ap->ops->phy_reset(ap);
2798 2780
2799 ata_for_each_dev(dev, &ap->link, ALL) { 2781 ata_for_each_dev(dev, &ap->link, ALL) {
2800 if (!(ap->flags & ATA_FLAG_DISABLED) && 2782 if (dev->class != ATA_DEV_UNKNOWN)
2801 dev->class != ATA_DEV_UNKNOWN)
2802 classes[dev->devno] = dev->class; 2783 classes[dev->devno] = dev->class;
2803 else 2784 else
2804 classes[dev->devno] = ATA_DEV_NONE; 2785 classes[dev->devno] = ATA_DEV_NONE;
@@ -2806,8 +2787,6 @@ int ata_bus_probe(struct ata_port *ap)
2806 dev->class = ATA_DEV_UNKNOWN; 2787 dev->class = ATA_DEV_UNKNOWN;
2807 } 2788 }
2808 2789
2809 ata_port_probe(ap);
2810
2811 /* read IDENTIFY page and configure devices. We have to do the identify 2790 /* read IDENTIFY page and configure devices. We have to do the identify
2812 specific sequence bass-ackwards so that PDIAG- is released by 2791 specific sequence bass-ackwards so that PDIAG- is released by
2813 the slave device */ 2792 the slave device */
@@ -2857,8 +2836,6 @@ int ata_bus_probe(struct ata_port *ap)
2857 ata_for_each_dev(dev, &ap->link, ENABLED) 2836 ata_for_each_dev(dev, &ap->link, ENABLED)
2858 return 0; 2837 return 0;
2859 2838
2860 /* no device present, disable port */
2861 ata_port_disable(ap);
2862 return -ENODEV; 2839 return -ENODEV;
2863 2840
2864 fail: 2841 fail:
@@ -2890,22 +2867,6 @@ int ata_bus_probe(struct ata_port *ap)
2890} 2867}
2891 2868
2892/** 2869/**
2893 * ata_port_probe - Mark port as enabled
2894 * @ap: Port for which we indicate enablement
2895 *
2896 * Modify @ap data structure such that the system
2897 * thinks that the entire port is enabled.
2898 *
2899 * LOCKING: host lock, or some other form of
2900 * serialization.
2901 */
2902
2903void ata_port_probe(struct ata_port *ap)
2904{
2905 ap->flags &= ~ATA_FLAG_DISABLED;
2906}
2907
2908/**
2909 * sata_print_link_status - Print SATA link status 2870 * sata_print_link_status - Print SATA link status
2910 * @link: SATA link to printk link status about 2871 * @link: SATA link to printk link status about
2911 * 2872 *
@@ -2952,26 +2913,6 @@ struct ata_device *ata_dev_pair(struct ata_device *adev)
2952} 2913}
2953 2914
2954/** 2915/**
2955 * ata_port_disable - Disable port.
2956 * @ap: Port to be disabled.
2957 *
2958 * Modify @ap data structure such that the system
2959 * thinks that the entire port is disabled, and should
2960 * never attempt to probe or communicate with devices
2961 * on this port.
2962 *
2963 * LOCKING: host lock, or some other form of
2964 * serialization.
2965 */
2966
2967void ata_port_disable(struct ata_port *ap)
2968{
2969 ap->link.device[0].class = ATA_DEV_NONE;
2970 ap->link.device[1].class = ATA_DEV_NONE;
2971 ap->flags |= ATA_FLAG_DISABLED;
2972}
2973
2974/**
2975 * sata_down_spd_limit - adjust SATA spd limit downward 2916 * sata_down_spd_limit - adjust SATA spd limit downward
2976 * @link: Link to adjust SATA spd limit for 2917 * @link: Link to adjust SATA spd limit for
2977 * @spd_limit: Additional limit 2918 * @spd_limit: Additional limit
@@ -5716,7 +5657,6 @@ struct ata_port *ata_port_alloc(struct ata_host *host)
5716 5657
5717 ap->pflags |= ATA_PFLAG_INITIALIZING; 5658 ap->pflags |= ATA_PFLAG_INITIALIZING;
5718 ap->lock = &host->lock; 5659 ap->lock = &host->lock;
5719 ap->flags = ATA_FLAG_DISABLED;
5720 ap->print_id = -1; 5660 ap->print_id = -1;
5721 ap->ctl = ATA_DEVCTL_OBS; 5661 ap->ctl = ATA_DEVCTL_OBS;
5722 ap->host = host; 5662 ap->host = host;
@@ -6145,8 +6085,6 @@ static void async_port_probe(void *data, async_cookie_t cookie)
6145 struct ata_eh_info *ehi = &ap->link.eh_info; 6085 struct ata_eh_info *ehi = &ap->link.eh_info;
6146 unsigned long flags; 6086 unsigned long flags;
6147 6087
6148 ata_port_probe(ap);
6149
6150 /* kick EH for boot probing */ 6088 /* kick EH for boot probing */
6151 spin_lock_irqsave(ap->lock, flags); 6089 spin_lock_irqsave(ap->lock, flags);
6152 6090
@@ -6823,7 +6761,6 @@ EXPORT_SYMBOL_GPL(ata_port_start);
6823EXPORT_SYMBOL_GPL(ata_do_set_mode); 6761EXPORT_SYMBOL_GPL(ata_do_set_mode);
6824EXPORT_SYMBOL_GPL(ata_std_qc_defer); 6762EXPORT_SYMBOL_GPL(ata_std_qc_defer);
6825EXPORT_SYMBOL_GPL(ata_noop_qc_prep); 6763EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
6826EXPORT_SYMBOL_GPL(ata_port_probe);
6827EXPORT_SYMBOL_GPL(ata_dev_disable); 6764EXPORT_SYMBOL_GPL(ata_dev_disable);
6828EXPORT_SYMBOL_GPL(sata_set_spd); 6765EXPORT_SYMBOL_GPL(sata_set_spd);
6829EXPORT_SYMBOL_GPL(ata_wait_after_reset); 6766EXPORT_SYMBOL_GPL(ata_wait_after_reset);
@@ -6835,7 +6772,6 @@ EXPORT_SYMBOL_GPL(sata_std_hardreset);
6835EXPORT_SYMBOL_GPL(ata_std_postreset); 6772EXPORT_SYMBOL_GPL(ata_std_postreset);
6836EXPORT_SYMBOL_GPL(ata_dev_classify); 6773EXPORT_SYMBOL_GPL(ata_dev_classify);
6837EXPORT_SYMBOL_GPL(ata_dev_pair); 6774EXPORT_SYMBOL_GPL(ata_dev_pair);
6838EXPORT_SYMBOL_GPL(ata_port_disable);
6839EXPORT_SYMBOL_GPL(ata_ratelimit); 6775EXPORT_SYMBOL_GPL(ata_ratelimit);
6840EXPORT_SYMBOL_GPL(ata_wait_register); 6776EXPORT_SYMBOL_GPL(ata_wait_register);
6841EXPORT_SYMBOL_GPL(ata_scsi_queuecmd); 6777EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 0088cdeb0b1e..cfa9dd3d7253 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -3345,9 +3345,6 @@ void ata_scsi_scan_host(struct ata_port *ap, int sync)
3345 struct ata_link *link; 3345 struct ata_link *link;
3346 struct ata_device *dev; 3346 struct ata_device *dev;
3347 3347
3348 if (ap->flags & ATA_FLAG_DISABLED)
3349 return;
3350
3351 repeat: 3348 repeat:
3352 ata_for_each_link(link, ap, EDGE) { 3349 ata_for_each_link(link, ap, EDGE) {
3353 ata_for_each_dev(dev, link, ENABLED) { 3350 ata_for_each_dev(dev, link, ENABLED) {
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index d5dd88d6dea0..0e2c972292cf 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -1807,9 +1807,6 @@ retry:
1807 struct ata_port *ap = host->ports[i]; 1807 struct ata_port *ap = host->ports[i];
1808 struct ata_queued_cmd *qc; 1808 struct ata_queued_cmd *qc;
1809 1809
1810 if (unlikely(ap->flags & ATA_FLAG_DISABLED))
1811 continue;
1812
1813 qc = ata_qc_from_tag(ap, ap->link.active_tag); 1810 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1814 if (qc) { 1811 if (qc) {
1815 if (!(qc->tf.flags & ATA_TFLAG_POLLING)) 1812 if (!(qc->tf.flags & ATA_TFLAG_POLLING))
@@ -1884,11 +1881,8 @@ void ata_sff_lost_interrupt(struct ata_port *ap)
1884 1881
1885 /* Only one outstanding command per SFF channel */ 1882 /* Only one outstanding command per SFF channel */
1886 qc = ata_qc_from_tag(ap, ap->link.active_tag); 1883 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1887 /* Check we have a live one.. */ 1884 /* We cannot lose an interrupt on a non-existent or polled command */
1888 if (qc == NULL || !(qc->flags & ATA_QCFLAG_ACTIVE)) 1885 if (!qc || qc->tf.flags & ATA_TFLAG_POLLING)
1889 return;
1890 /* We cannot lose an interrupt on a polled command */
1891 if (qc->tf.flags & ATA_TFLAG_POLLING)
1892 return; 1886 return;
1893 /* See if the controller thinks it is still busy - if so the command 1887 /* See if the controller thinks it is still busy - if so the command
1894 isn't a lost IRQ but is still in progress */ 1888 isn't a lost IRQ but is still in progress */
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
index 07c110470e25..e9bf44cf4142 100644
--- a/drivers/ata/pata_bf54x.c
+++ b/drivers/ata/pata_bf54x.c
@@ -1400,18 +1400,12 @@ static irqreturn_t bfin_ata_interrupt(int irq, void *dev_instance)
1400 spin_lock_irqsave(&host->lock, flags); 1400 spin_lock_irqsave(&host->lock, flags);
1401 1401
1402 for (i = 0; i < host->n_ports; i++) { 1402 for (i = 0; i < host->n_ports; i++) {
1403 struct ata_port *ap; 1403 struct ata_port *ap = host->ports[i];
1404 struct ata_queued_cmd *qc;
1404 1405
1405 ap = host->ports[i]; 1406 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1406 if (ap && 1407 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)))
1407 !(ap->flags & ATA_FLAG_DISABLED)) { 1408 handled |= bfin_ata_host_intr(ap, qc);
1408 struct ata_queued_cmd *qc;
1409
1410 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1411 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
1412 (qc->flags & ATA_QCFLAG_ACTIVE))
1413 handled |= bfin_ata_host_intr(ap, qc);
1414 }
1415 } 1409 }
1416 1410
1417 spin_unlock_irqrestore(&host->lock, flags); 1411 spin_unlock_irqrestore(&host->lock, flags);
diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c
index 303ca7e82408..3001109352ea 100644
--- a/drivers/ata/pata_octeon_cf.c
+++ b/drivers/ata/pata_octeon_cf.c
@@ -654,9 +654,6 @@ static irqreturn_t octeon_cf_interrupt(int irq, void *dev_instance)
654 ap = host->ports[i]; 654 ap = host->ports[i];
655 ocd = ap->dev->platform_data; 655 ocd = ap->dev->platform_data;
656 656
657 if (ap->flags & ATA_FLAG_DISABLED)
658 continue;
659
660 ocd = ap->dev->platform_data; 657 ocd = ap->dev->platform_data;
661 cf_port = ap->private_data; 658 cf_port = ap->private_data;
662 dma_int.u64 = 659 dma_int.u64 =
@@ -666,8 +663,7 @@ static irqreturn_t octeon_cf_interrupt(int irq, void *dev_instance)
666 663
667 qc = ata_qc_from_tag(ap, ap->link.active_tag); 664 qc = ata_qc_from_tag(ap, ap->link.active_tag);
668 665
669 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) && 666 if (qc && !(qc->tf.flags & ATA_TFLAG_POLLING)) {
670 (qc->flags & ATA_QCFLAG_ACTIVE)) {
671 if (dma_int.s.done && !dma_cfg.s.en) { 667 if (dma_int.s.done && !dma_cfg.s.en) {
672 if (!sg_is_last(qc->cursg)) { 668 if (!sg_is_last(qc->cursg)) {
673 qc->cursg = sg_next(qc->cursg); 669 qc->cursg = sg_next(qc->cursg);
@@ -737,8 +733,7 @@ static void octeon_cf_delayed_finish(struct work_struct *work)
737 goto out; 733 goto out;
738 } 734 }
739 qc = ata_qc_from_tag(ap, ap->link.active_tag); 735 qc = ata_qc_from_tag(ap, ap->link.active_tag);
740 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) && 736 if (qc && !(qc->tf.flags & ATA_TFLAG_POLLING))
741 (qc->flags & ATA_QCFLAG_ACTIVE))
742 octeon_cf_dma_finished(ap, qc); 737 octeon_cf_dma_finished(ap, qc);
743out: 738out:
744 spin_unlock_irqrestore(&host->lock, flags); 739 spin_unlock_irqrestore(&host->lock, flags);
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index 5904cfdb8dbe..ed18d8b42c52 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -442,8 +442,6 @@ static inline unsigned int adma_intr_pkt(struct ata_host *host)
442 continue; 442 continue;
443 handled = 1; 443 handled = 1;
444 adma_enter_reg_mode(ap); 444 adma_enter_reg_mode(ap);
445 if (ap->flags & ATA_FLAG_DISABLED)
446 continue;
447 pp = ap->private_data; 445 pp = ap->private_data;
448 if (!pp || pp->state != adma_state_pkt) 446 if (!pp || pp->state != adma_state_pkt)
449 continue; 447 continue;
@@ -484,42 +482,38 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
484 unsigned int handled = 0, port_no; 482 unsigned int handled = 0, port_no;
485 483
486 for (port_no = 0; port_no < host->n_ports; ++port_no) { 484 for (port_no = 0; port_no < host->n_ports; ++port_no) {
487 struct ata_port *ap; 485 struct ata_port *ap = host->ports[port_no];
488 ap = host->ports[port_no]; 486 struct adma_port_priv *pp = ap->private_data;
489 if (ap && (!(ap->flags & ATA_FLAG_DISABLED))) { 487 struct ata_queued_cmd *qc;
490 struct ata_queued_cmd *qc; 488
491 struct adma_port_priv *pp = ap->private_data; 489 if (!pp || pp->state != adma_state_mmio)
492 if (!pp || pp->state != adma_state_mmio) 490 continue;
491 qc = ata_qc_from_tag(ap, ap->link.active_tag);
492 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
493
494 /* check main status, clearing INTRQ */
495 u8 status = ata_sff_check_status(ap);
496 if ((status & ATA_BUSY))
493 continue; 497 continue;
494 qc = ata_qc_from_tag(ap, ap->link.active_tag); 498 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
495 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) { 499 ap->print_id, qc->tf.protocol, status);
496 500
497 /* check main status, clearing INTRQ */ 501 /* complete taskfile transaction */
498 u8 status = ata_sff_check_status(ap); 502 pp->state = adma_state_idle;
499 if ((status & ATA_BUSY)) 503 qc->err_mask |= ac_err_mask(status);
500 continue; 504 if (!qc->err_mask)
501 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n", 505 ata_qc_complete(qc);
502 ap->print_id, qc->tf.protocol, status); 506 else {
503 507 struct ata_eh_info *ehi = &ap->link.eh_info;
504 /* complete taskfile transaction */ 508 ata_ehi_clear_desc(ehi);
505 pp->state = adma_state_idle; 509 ata_ehi_push_desc(ehi, "status 0x%02X", status);
506 qc->err_mask |= ac_err_mask(status); 510
507 if (!qc->err_mask) 511 if (qc->err_mask == AC_ERR_DEV)
508 ata_qc_complete(qc); 512 ata_port_abort(ap);
509 else { 513 else
510 struct ata_eh_info *ehi = 514 ata_port_freeze(ap);
511 &ap->link.eh_info;
512 ata_ehi_clear_desc(ehi);
513 ata_ehi_push_desc(ehi,
514 "status 0x%02X", status);
515
516 if (qc->err_mask == AC_ERR_DEV)
517 ata_port_abort(ap);
518 else
519 ata_port_freeze(ap);
520 }
521 handled = 1;
522 } 515 }
516 handled = 1;
523 } 517 }
524 } 518 }
525 return handled; 519 return handled;
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index 27dc6c86a4cd..0ac6cdd9d1e8 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -415,22 +415,11 @@ static irqreturn_t inic_interrupt(int irq, void *dev_instance)
415 415
416 spin_lock(&host->lock); 416 spin_lock(&host->lock);
417 417
418 for (i = 0; i < NR_PORTS; i++) { 418 for (i = 0; i < NR_PORTS; i++)
419 struct ata_port *ap = host->ports[i]; 419 if (host_irq_stat & (HIRQ_PORT0 << i)) {
420 420 inic_host_intr(host->ports[i]);
421 if (!(host_irq_stat & (HIRQ_PORT0 << i)))
422 continue;
423
424 if (likely(ap && !(ap->flags & ATA_FLAG_DISABLED))) {
425 inic_host_intr(ap);
426 handled++; 421 handled++;
427 } else {
428 if (ata_ratelimit())
429 dev_printk(KERN_ERR, host->dev, "interrupt "
430 "from disabled port %d (0x%x)\n",
431 i, host_irq_stat);
432 } 422 }
433 }
434 423
435 spin_unlock(&host->lock); 424 spin_unlock(&host->lock);
436 425
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index bd486462951c..318862e8a8a9 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -2355,13 +2355,9 @@ static struct ata_queued_cmd *mv_get_active_qc(struct ata_port *ap)
2355 if (pp->pp_flags & MV_PP_FLAG_NCQ_EN) 2355 if (pp->pp_flags & MV_PP_FLAG_NCQ_EN)
2356 return NULL; 2356 return NULL;
2357 qc = ata_qc_from_tag(ap, ap->link.active_tag); 2357 qc = ata_qc_from_tag(ap, ap->link.active_tag);
2358 if (qc) { 2358 if (qc && !(qc->tf.flags & ATA_TFLAG_POLLING))
2359 if (qc->tf.flags & ATA_TFLAG_POLLING) 2359 return qc;
2360 qc = NULL; 2360 return NULL;
2361 else if (!(qc->flags & ATA_QCFLAG_ACTIVE))
2362 qc = NULL;
2363 }
2364 return qc;
2365} 2361}
2366 2362
2367static void mv_pmp_error_handler(struct ata_port *ap) 2363static void mv_pmp_error_handler(struct ata_port *ap)
@@ -2546,9 +2542,7 @@ static void mv_unexpected_intr(struct ata_port *ap, int edma_was_enabled)
2546 char *when = "idle"; 2542 char *when = "idle";
2547 2543
2548 ata_ehi_clear_desc(ehi); 2544 ata_ehi_clear_desc(ehi);
2549 if (ap->flags & ATA_FLAG_DISABLED) { 2545 if (edma_was_enabled) {
2550 when = "disabled";
2551 } else if (edma_was_enabled) {
2552 when = "EDMA enabled"; 2546 when = "EDMA enabled";
2553 } else { 2547 } else {
2554 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag); 2548 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, ap->link.active_tag);
@@ -2782,10 +2776,6 @@ static void mv_port_intr(struct ata_port *ap, u32 port_cause)
2782 struct mv_port_priv *pp; 2776 struct mv_port_priv *pp;
2783 int edma_was_enabled; 2777 int edma_was_enabled;
2784 2778
2785 if (ap->flags & ATA_FLAG_DISABLED) {
2786 mv_unexpected_intr(ap, 0);
2787 return;
2788 }
2789 /* 2779 /*
2790 * Grab a snapshot of the EDMA_EN flag setting, 2780 * Grab a snapshot of the EDMA_EN flag setting,
2791 * so that we have a consistent view for this port, 2781 * so that we have a consistent view for this port,
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 9d3dbc8a1184..20cc510595db 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -933,107 +933,108 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
933 933
934 for (i = 0; i < host->n_ports; i++) { 934 for (i = 0; i < host->n_ports; i++) {
935 struct ata_port *ap = host->ports[i]; 935 struct ata_port *ap = host->ports[i];
936 struct nv_adma_port_priv *pp = ap->private_data;
937 void __iomem *mmio = pp->ctl_block;
938 u16 status;
939 u32 gen_ctl;
940 u32 notifier, notifier_error;
941
936 notifier_clears[i] = 0; 942 notifier_clears[i] = 0;
937 943
938 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) { 944 /* if ADMA is disabled, use standard ata interrupt handler */
939 struct nv_adma_port_priv *pp = ap->private_data; 945 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
940 void __iomem *mmio = pp->ctl_block; 946 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
941 u16 status; 947 >> (NV_INT_PORT_SHIFT * i);
942 u32 gen_ctl; 948 handled += nv_host_intr(ap, irq_stat);
943 u32 notifier, notifier_error; 949 continue;
944 950 }
945 /* if ADMA is disabled, use standard ata interrupt handler */
946 if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
947 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
948 >> (NV_INT_PORT_SHIFT * i);
949 handled += nv_host_intr(ap, irq_stat);
950 continue;
951 }
952 951
953 /* if in ATA register mode, check for standard interrupts */ 952 /* if in ATA register mode, check for standard interrupts */
954 if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) { 953 if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
955 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804) 954 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
956 >> (NV_INT_PORT_SHIFT * i); 955 >> (NV_INT_PORT_SHIFT * i);
957 if (ata_tag_valid(ap->link.active_tag)) 956 if (ata_tag_valid(ap->link.active_tag))
958 /** NV_INT_DEV indication seems unreliable at times 957 /** NV_INT_DEV indication seems unreliable
959 at least in ADMA mode. Force it on always when a 958 at times at least in ADMA mode. Force it
960 command is active, to prevent losing interrupts. */ 959 on always when a command is active, to
961 irq_stat |= NV_INT_DEV; 960 prevent losing interrupts. */
962 handled += nv_host_intr(ap, irq_stat); 961 irq_stat |= NV_INT_DEV;
963 } 962 handled += nv_host_intr(ap, irq_stat);
963 }
964
965 notifier = readl(mmio + NV_ADMA_NOTIFIER);
966 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR);
967 notifier_clears[i] = notifier | notifier_error;
968
969 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
970
971 if (!NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier &&
972 !notifier_error)
973 /* Nothing to do */
974 continue;
975
976 status = readw(mmio + NV_ADMA_STAT);
977
978 /*
979 * Clear status. Ensure the controller sees the
980 * clearing before we start looking at any of the CPB
981 * statuses, so that any CPB completions after this
982 * point in the handler will raise another interrupt.
983 */
984 writew(status, mmio + NV_ADMA_STAT);
985 readw(mmio + NV_ADMA_STAT); /* flush posted write */
986 rmb();
987
988 handled++; /* irq handled if we got here */
964 989
965 notifier = readl(mmio + NV_ADMA_NOTIFIER); 990 /* freeze if hotplugged or controller error */
966 notifier_error = readl(mmio + NV_ADMA_NOTIFIER_ERROR); 991 if (unlikely(status & (NV_ADMA_STAT_HOTPLUG |
967 notifier_clears[i] = notifier | notifier_error; 992 NV_ADMA_STAT_HOTUNPLUG |
968 993 NV_ADMA_STAT_TIMEOUT |
969 gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL); 994 NV_ADMA_STAT_SERROR))) {
970 995 struct ata_eh_info *ehi = &ap->link.eh_info;
971 if (!NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier && 996
972 !notifier_error) 997 ata_ehi_clear_desc(ehi);
973 /* Nothing to do */ 998 __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status);
974 continue; 999 if (status & NV_ADMA_STAT_TIMEOUT) {
975 1000 ehi->err_mask |= AC_ERR_SYSTEM;
976 status = readw(mmio + NV_ADMA_STAT); 1001 ata_ehi_push_desc(ehi, "timeout");
977 1002 } else if (status & NV_ADMA_STAT_HOTPLUG) {
978 /* Clear status. Ensure the controller sees the clearing before we start 1003 ata_ehi_hotplugged(ehi);
979 looking at any of the CPB statuses, so that any CPB completions after 1004 ata_ehi_push_desc(ehi, "hotplug");
980 this point in the handler will raise another interrupt. */ 1005 } else if (status & NV_ADMA_STAT_HOTUNPLUG) {
981 writew(status, mmio + NV_ADMA_STAT); 1006 ata_ehi_hotplugged(ehi);
982 readw(mmio + NV_ADMA_STAT); /* flush posted write */ 1007 ata_ehi_push_desc(ehi, "hot unplug");
983 rmb(); 1008 } else if (status & NV_ADMA_STAT_SERROR) {
984 1009 /* let EH analyze SError and figure out cause */
985 handled++; /* irq handled if we got here */ 1010 ata_ehi_push_desc(ehi, "SError");
986 1011 } else
987 /* freeze if hotplugged or controller error */ 1012 ata_ehi_push_desc(ehi, "unknown");
988 if (unlikely(status & (NV_ADMA_STAT_HOTPLUG | 1013 ata_port_freeze(ap);
989 NV_ADMA_STAT_HOTUNPLUG | 1014 continue;
990 NV_ADMA_STAT_TIMEOUT | 1015 }
991 NV_ADMA_STAT_SERROR))) { 1016
992 struct ata_eh_info *ehi = &ap->link.eh_info; 1017 if (status & (NV_ADMA_STAT_DONE |
993 1018 NV_ADMA_STAT_CPBERR |
994 ata_ehi_clear_desc(ehi); 1019 NV_ADMA_STAT_CMD_COMPLETE)) {
995 __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status); 1020 u32 check_commands = notifier_clears[i];
996 if (status & NV_ADMA_STAT_TIMEOUT) { 1021 int pos, error = 0;
997 ehi->err_mask |= AC_ERR_SYSTEM; 1022
998 ata_ehi_push_desc(ehi, "timeout"); 1023 if (status & NV_ADMA_STAT_CPBERR) {
999 } else if (status & NV_ADMA_STAT_HOTPLUG) { 1024 /* check all active commands */
1000 ata_ehi_hotplugged(ehi); 1025 if (ata_tag_valid(ap->link.active_tag))
1001 ata_ehi_push_desc(ehi, "hotplug"); 1026 check_commands = 1 <<
1002 } else if (status & NV_ADMA_STAT_HOTUNPLUG) { 1027 ap->link.active_tag;
1003 ata_ehi_hotplugged(ehi); 1028 else
1004 ata_ehi_push_desc(ehi, "hot unplug"); 1029 check_commands = ap->link.sactive;
1005 } else if (status & NV_ADMA_STAT_SERROR) {
1006 /* let libata analyze SError and figure out the cause */
1007 ata_ehi_push_desc(ehi, "SError");
1008 } else
1009 ata_ehi_push_desc(ehi, "unknown");
1010 ata_port_freeze(ap);
1011 continue;
1012 } 1030 }
1013 1031
1014 if (status & (NV_ADMA_STAT_DONE | 1032 /* check CPBs for completed commands */
1015 NV_ADMA_STAT_CPBERR | 1033 while ((pos = ffs(check_commands)) && !error) {
1016 NV_ADMA_STAT_CMD_COMPLETE)) { 1034 pos--;
1017 u32 check_commands = notifier_clears[i]; 1035 error = nv_adma_check_cpb(ap, pos,
1018 int pos, error = 0;
1019
1020 if (status & NV_ADMA_STAT_CPBERR) {
1021 /* Check all active commands */
1022 if (ata_tag_valid(ap->link.active_tag))
1023 check_commands = 1 <<
1024 ap->link.active_tag;
1025 else
1026 check_commands = ap->
1027 link.sactive;
1028 }
1029
1030 /** Check CPBs for completed commands */
1031 while ((pos = ffs(check_commands)) && !error) {
1032 pos--;
1033 error = nv_adma_check_cpb(ap, pos,
1034 notifier_error & (1 << pos)); 1036 notifier_error & (1 << pos));
1035 check_commands &= ~(1 << pos); 1037 check_commands &= ~(1 << pos);
1036 }
1037 } 1038 }
1038 } 1039 }
1039 } 1040 }
@@ -1498,22 +1499,19 @@ static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
1498 spin_lock_irqsave(&host->lock, flags); 1499 spin_lock_irqsave(&host->lock, flags);
1499 1500
1500 for (i = 0; i < host->n_ports; i++) { 1501 for (i = 0; i < host->n_ports; i++) {
1501 struct ata_port *ap; 1502 struct ata_port *ap = host->ports[i];
1502 1503 struct ata_queued_cmd *qc;
1503 ap = host->ports[i];
1504 if (ap &&
1505 !(ap->flags & ATA_FLAG_DISABLED)) {
1506 struct ata_queued_cmd *qc;
1507 1504
1508 qc = ata_qc_from_tag(ap, ap->link.active_tag); 1505 qc = ata_qc_from_tag(ap, ap->link.active_tag);
1509 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) 1506 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
1510 handled += ata_sff_host_intr(ap, qc); 1507 handled += ata_sff_host_intr(ap, qc);
1511 else 1508 } else {
1512 // No request pending? Clear interrupt status 1509 /*
1513 // anyway, in case there's one pending. 1510 * No request pending? Clear interrupt status
1514 ap->ops->sff_check_status(ap); 1511 * anyway, in case there's one pending.
1512 */
1513 ap->ops->sff_check_status(ap);
1515 } 1514 }
1516
1517 } 1515 }
1518 1516
1519 spin_unlock_irqrestore(&host->lock, flags); 1517 spin_unlock_irqrestore(&host->lock, flags);
@@ -1526,11 +1524,7 @@ static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
1526 int i, handled = 0; 1524 int i, handled = 0;
1527 1525
1528 for (i = 0; i < host->n_ports; i++) { 1526 for (i = 0; i < host->n_ports; i++) {
1529 struct ata_port *ap = host->ports[i]; 1527 handled += nv_host_intr(host->ports[i], irq_stat);
1530
1531 if (ap && !(ap->flags & ATA_FLAG_DISABLED))
1532 handled += nv_host_intr(ap, irq_stat);
1533
1534 irq_stat >>= NV_INT_PORT_SHIFT; 1528 irq_stat >>= NV_INT_PORT_SHIFT;
1535 } 1529 }
1536 1530
@@ -2380,16 +2374,14 @@ static irqreturn_t nv_swncq_interrupt(int irq, void *dev_instance)
2380 for (i = 0; i < host->n_ports; i++) { 2374 for (i = 0; i < host->n_ports; i++) {
2381 struct ata_port *ap = host->ports[i]; 2375 struct ata_port *ap = host->ports[i];
2382 2376
2383 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) { 2377 if (ap->link.sactive) {
2384 if (ap->link.sactive) { 2378 nv_swncq_host_interrupt(ap, (u16)irq_stat);
2385 nv_swncq_host_interrupt(ap, (u16)irq_stat); 2379 handled = 1;
2386 handled = 1; 2380 } else {
2387 } else { 2381 if (irq_stat) /* reserve Hotplug */
2388 if (irq_stat) /* reserve Hotplug */ 2382 nv_swncq_irq_clear(ap, 0xfff0);
2389 nv_swncq_irq_clear(ap, 0xfff0);
2390 2383
2391 handled += nv_host_intr(ap, (u8)irq_stat); 2384 handled += nv_host_intr(ap, (u8)irq_stat);
2392 }
2393 } 2385 }
2394 irq_stat >>= NV_INT_PORT_SHIFT_MCP55; 2386 irq_stat >>= NV_INT_PORT_SHIFT_MCP55;
2395 } 2387 }
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index 5356ec00d2b4..2c029ea12c54 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -984,8 +984,7 @@ static irqreturn_t pdc_interrupt(int irq, void *dev_instance)
984 /* check for a plug or unplug event */ 984 /* check for a plug or unplug event */
985 ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4); 985 ata_no = pdc_port_no_to_ata_no(i, is_sataii_tx4);
986 tmp = hotplug_status & (0x11 << ata_no); 986 tmp = hotplug_status & (0x11 << ata_no);
987 if (tmp && ap && 987 if (tmp) {
988 !(ap->flags & ATA_FLAG_DISABLED)) {
989 struct ata_eh_info *ehi = &ap->link.eh_info; 988 struct ata_eh_info *ehi = &ap->link.eh_info;
990 ata_ehi_clear_desc(ehi); 989 ata_ehi_clear_desc(ehi);
991 ata_ehi_hotplugged(ehi); 990 ata_ehi_hotplugged(ehi);
@@ -997,8 +996,7 @@ static irqreturn_t pdc_interrupt(int irq, void *dev_instance)
997 996
998 /* check for a packet interrupt */ 997 /* check for a packet interrupt */
999 tmp = mask & (1 << (i + 1)); 998 tmp = mask & (1 << (i + 1));
1000 if (tmp && ap && 999 if (tmp) {
1001 !(ap->flags & ATA_FLAG_DISABLED)) {
1002 struct ata_queued_cmd *qc; 1000 struct ata_queued_cmd *qc;
1003 1001
1004 qc = ata_qc_from_tag(ap, ap->link.active_tag); 1002 qc = ata_qc_from_tag(ap, ap->link.active_tag);
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index 92ba45e6689b..febc6e748420 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -404,26 +404,24 @@ static inline unsigned int qs_intr_pkt(struct ata_host *host)
404 u8 sHST = sff1 & 0x3f; /* host status */ 404 u8 sHST = sff1 & 0x3f; /* host status */
405 unsigned int port_no = (sff1 >> 8) & 0x03; 405 unsigned int port_no = (sff1 >> 8) & 0x03;
406 struct ata_port *ap = host->ports[port_no]; 406 struct ata_port *ap = host->ports[port_no];
407 struct qs_port_priv *pp = ap->private_data;
408 struct ata_queued_cmd *qc;
407 409
408 DPRINTK("SFF=%08x%08x: sCHAN=%u sHST=%d sDST=%02x\n", 410 DPRINTK("SFF=%08x%08x: sCHAN=%u sHST=%d sDST=%02x\n",
409 sff1, sff0, port_no, sHST, sDST); 411 sff1, sff0, port_no, sHST, sDST);
410 handled = 1; 412 handled = 1;
411 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) { 413 if (!pp || pp->state != qs_state_pkt)
412 struct ata_queued_cmd *qc; 414 continue;
413 struct qs_port_priv *pp = ap->private_data; 415 qc = ata_qc_from_tag(ap, ap->link.active_tag);
414 if (!pp || pp->state != qs_state_pkt) 416 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
415 continue; 417 switch (sHST) {
416 qc = ata_qc_from_tag(ap, ap->link.active_tag); 418 case 0: /* successful CPB */
417 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) { 419 case 3: /* device error */
418 switch (sHST) { 420 qs_enter_reg_mode(qc->ap);
419 case 0: /* successful CPB */ 421 qs_do_or_die(qc, sDST);
420 case 3: /* device error */ 422 break;
421 qs_enter_reg_mode(qc->ap); 423 default:
422 qs_do_or_die(qc, sDST); 424 break;
423 break;
424 default:
425 break;
426 }
427 } 425 }
428 } 426 }
429 } 427 }
@@ -436,33 +434,30 @@ static inline unsigned int qs_intr_mmio(struct ata_host *host)
436 unsigned int handled = 0, port_no; 434 unsigned int handled = 0, port_no;
437 435
438 for (port_no = 0; port_no < host->n_ports; ++port_no) { 436 for (port_no = 0; port_no < host->n_ports; ++port_no) {
439 struct ata_port *ap; 437 struct ata_port *ap = host->ports[port_no];
440 ap = host->ports[port_no]; 438 struct qs_port_priv *pp = ap->private_data;
441 if (ap && 439 struct ata_queued_cmd *qc;
442 !(ap->flags & ATA_FLAG_DISABLED)) { 440
443 struct ata_queued_cmd *qc; 441 qc = ata_qc_from_tag(ap, ap->link.active_tag);
444 struct qs_port_priv *pp; 442 if (!qc) {
445 qc = ata_qc_from_tag(ap, ap->link.active_tag); 443 /*
446 if (!qc || !(qc->flags & ATA_QCFLAG_ACTIVE)) { 444 * The qstor hardware generates spurious
447 /* 445 * interrupts from time to time when switching
448 * The qstor hardware generates spurious 446 * in and out of packet mode. There's no
449 * interrupts from time to time when switching 447 * obvious way to know if we're here now due
450 * in and out of packet mode. 448 * to that, so just ack the irq and pretend we
451 * There's no obvious way to know if we're 449 * knew it was ours.. (ugh). This does not
452 * here now due to that, so just ack the irq 450 * affect packet mode.
453 * and pretend we knew it was ours.. (ugh). 451 */
454 * This does not affect packet mode. 452 ata_sff_check_status(ap);
455 */ 453 handled = 1;
456 ata_sff_check_status(ap); 454 continue;
457 handled = 1;
458 continue;
459 }
460 pp = ap->private_data;
461 if (!pp || pp->state != qs_state_mmio)
462 continue;
463 if (!(qc->tf.flags & ATA_TFLAG_POLLING))
464 handled |= ata_sff_host_intr(ap, qc);
465 } 455 }
456
457 if (!pp || pp->state != qs_state_mmio)
458 continue;
459 if (!(qc->tf.flags & ATA_TFLAG_POLLING))
460 handled |= ata_sff_host_intr(ap, qc);
466 } 461 }
467 return handled; 462 return handled;
468} 463}
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 3cb69d5fb817..9c367f71c627 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -532,9 +532,6 @@ static irqreturn_t sil_interrupt(int irq, void *dev_instance)
532 struct ata_port *ap = host->ports[i]; 532 struct ata_port *ap = host->ports[i];
533 u32 bmdma2 = readl(mmio_base + sil_port[ap->port_no].bmdma2); 533 u32 bmdma2 = readl(mmio_base + sil_port[ap->port_no].bmdma2);
534 534
535 if (unlikely(ap->flags & ATA_FLAG_DISABLED))
536 continue;
537
538 /* turn off SATA_IRQ if not supported */ 535 /* turn off SATA_IRQ if not supported */
539 if (ap->flags & SIL_FLAG_NO_SATA_IRQ) 536 if (ap->flags & SIL_FLAG_NO_SATA_IRQ)
540 bmdma2 &= ~SIL_DMA_SATA_IRQ; 537 bmdma2 &= ~SIL_DMA_SATA_IRQ;
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 433b6b89c795..e9250514734b 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -1160,13 +1160,8 @@ static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
1160 1160
1161 for (i = 0; i < host->n_ports; i++) 1161 for (i = 0; i < host->n_ports; i++)
1162 if (status & (1 << i)) { 1162 if (status & (1 << i)) {
1163 struct ata_port *ap = host->ports[i]; 1163 sil24_host_intr(host->ports[i]);
1164 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) { 1164 handled++;
1165 sil24_host_intr(ap);
1166 handled++;
1167 } else
1168 printk(KERN_ERR DRV_NAME
1169 ": interrupt from disabled port %d\n", i);
1170 } 1165 }
1171 1166
1172 spin_unlock(&host->lock); 1167 spin_unlock(&host->lock);
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 232468f2ea90..7e3a25ec93b1 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -840,8 +840,7 @@ static irqreturn_t pdc20621_interrupt(int irq, void *dev_instance)
840 ap = host->ports[port_no]; 840 ap = host->ports[port_no];
841 tmp = mask & (1 << i); 841 tmp = mask & (1 << i);
842 VPRINTK("seq %u, port_no %u, ap %p, tmp %x\n", i, port_no, ap, tmp); 842 VPRINTK("seq %u, port_no %u, ap %p, tmp %x\n", i, port_no, ap, tmp);
843 if (tmp && ap && 843 if (tmp && ap) {
844 !(ap->flags & ATA_FLAG_DISABLED)) {
845 struct ata_queued_cmd *qc; 844 struct ata_queued_cmd *qc;
846 845
847 qc = ata_qc_from_tag(ap, ap->link.active_tag); 846 qc = ata_qc_from_tag(ap, ap->link.active_tag);
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index 8b2a278b2547..2107952ebff1 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -284,14 +284,8 @@ static irqreturn_t vsc_sata_interrupt(int irq, void *dev_instance)
284 for (i = 0; i < host->n_ports; i++) { 284 for (i = 0; i < host->n_ports; i++) {
285 u8 port_status = (status >> (8 * i)) & 0xff; 285 u8 port_status = (status >> (8 * i)) & 0xff;
286 if (port_status) { 286 if (port_status) {
287 struct ata_port *ap = host->ports[i]; 287 vsc_port_intr(port_status, host->ports[i]);
288 288 handled++;
289 if (ap && !(ap->flags & ATA_FLAG_DISABLED)) {
290 vsc_port_intr(port_status, ap);
291 handled++;
292 } else
293 dev_printk(KERN_ERR, host->dev,
294 "interrupt from disabled port %d\n", i);
295 } 289 }
296 } 290 }
297 291
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-23 02:24:38 -0400