libata: clean up the SFF code for coding style (0fe40ff8) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/ata/libata-sff.c

+67 −65

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@ const struct ata_port_operations ata_sff_port_ops = {

		.port_start = ata_sff_port_start,
		};
		EXPORT_SYMBOL_GPL(ata_sff_port_ops);

		const struct ata_port_operations ata_bmdma_port_ops = {
		.inherits = &ata_sff_port_ops,
		@@ -77,6 +78,7 @@ const struct ata_port_operations ata_bmdma_port_ops = {
		.bmdma_stop = ata_bmdma_stop,
		.bmdma_status = ata_bmdma_status,
		};
		EXPORT_SYMBOL_GPL(ata_bmdma_port_ops);

		const struct ata_port_operations ata_bmdma32_port_ops = {
		.inherits = &ata_bmdma_port_ops,
		@@ -174,7 +176,8 @@ static void ata_fill_sg_dumb(struct ata_queued_cmd *qc)
		ap->prd[pi].addr = cpu_to_le32(addr);
		if (blen == 0) {
		/* Some PATA chipsets like the CS5530 can't
		cope with 0x0000 meaning 64K as the spec says */
		cope with 0x0000 meaning 64K as the spec
		says */
		ap->prd[pi].flags_len = cpu_to_le32(0x8000);
		blen = 0x8000;
		ap->prd[++pi].addr = cpu_to_le32(addr + 0x8000);
		@@ -207,6 +210,7 @@ void ata_sff_qc_prep(struct ata_queued_cmd *qc)

		ata_fill_sg(qc);
		}
		EXPORT_SYMBOL_GPL(ata_sff_qc_prep);

		/**
		* ata_sff_dumb_qc_prep - Prepare taskfile for submission
		@@ -224,6 +228,7 @@ void ata_sff_dumb_qc_prep(struct ata_queued_cmd *qc)

		ata_fill_sg_dumb(qc);
		}
		EXPORT_SYMBOL_GPL(ata_sff_dumb_qc_prep);

		/**
		* ata_sff_check_status - Read device status reg & clear interrupt
		@@ -240,6 +245,7 @@ u8 ata_sff_check_status(struct ata_port *ap)
		{
		return ioread8(ap->ioaddr.status_addr);
		}
		EXPORT_SYMBOL_GPL(ata_sff_check_status);

		/**
		* ata_sff_altstatus - Read device alternate status reg
		@@ -326,6 +332,7 @@ void ata_sff_pause(struct ata_port *ap)
		ata_sff_sync(ap);
		ndelay(400);
		}
		EXPORT_SYMBOL_GPL(ata_sff_pause);

		/**
		* ata_sff_dma_pause - Pause before commencing DMA
		@@ -348,6 +355,7 @@ void ata_sff_dma_pause(struct ata_port *ap)
		corruption. */
		BUG();
		}
		EXPORT_SYMBOL_GPL(ata_sff_dma_pause);

		/**
		* ata_sff_busy_sleep - sleep until BSY clears, or timeout
		@@ -403,6 +411,7 @@ int ata_sff_busy_sleep(struct ata_port *ap,

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_busy_sleep);

		static int ata_sff_check_ready(struct ata_link *link)
		{
		@@ -429,6 +438,7 @@ int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline)
		{
		return ata_wait_ready(link, deadline, ata_sff_check_ready);
		}
		EXPORT_SYMBOL_GPL(ata_sff_wait_ready);

		/**
		* ata_sff_dev_select - Select device 0/1 on ATA bus
		@@ -456,6 +466,7 @@ void ata_sff_dev_select(struct ata_port *ap, unsigned int device)
		iowrite8(tmp, ap->ioaddr.device_addr);
		ata_sff_pause(ap); /* needed; also flushes, for mmio */
		}
		EXPORT_SYMBOL_GPL(ata_sff_dev_select);

		/**
		* ata_dev_select - Select device 0/1 on ATA bus
		@@ -520,6 +531,7 @@ u8 ata_sff_irq_on(struct ata_port *ap)

		return tmp;
		}
		EXPORT_SYMBOL_GPL(ata_sff_irq_on);

		/**
		* ata_sff_irq_clear - Clear PCI IDE BMDMA interrupt.
		@@ -541,6 +553,7 @@ void ata_sff_irq_clear(struct ata_port *ap)

		iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
		}
		EXPORT_SYMBOL_GPL(ata_sff_irq_clear);

		/**
		* ata_sff_tf_load - send taskfile registers to host controller
		@@ -600,6 +613,7 @@ void ata_sff_tf_load(struct ata_port ap, const struct ata_taskfile tf)

		ata_wait_idle(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_tf_load);

		/**
		* ata_sff_tf_read - input device's ATA taskfile shadow registers
		@@ -640,6 +654,7 @@ void ata_sff_tf_read(struct ata_port ap, struct ata_taskfile tf)
		WARN_ON(1);
		}
		}
		EXPORT_SYMBOL_GPL(ata_sff_tf_read);

		/**
		* ata_sff_exec_command - issue ATA command to host controller
		@@ -659,6 +674,7 @@ void ata_sff_exec_command(struct ata_port ap, const struct ata_taskfile tf)
		iowrite8(tf->command, ap->ioaddr.command_addr);
		ata_sff_pause(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_exec_command);

		/**
		* ata_tf_to_host - issue ATA taskfile to host controller
		@@ -724,6 +740,7 @@ unsigned int ata_sff_data_xfer(struct ata_device dev, unsigned char buf,

		return words << 1;
		}
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer);

		/**
		* ata_sff_data_xfer32 - Transfer data by PIO
		@@ -799,6 +816,7 @@ unsigned int ata_sff_data_xfer_noirq(struct ata_device dev, unsigned char buf,

		return consumed;
		}
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer_noirq);

		/**
		* ata_pio_sector - Transfer a sector of data.
		@@ -975,13 +993,15 @@ next_sg:
		buf = kmap_atomic(page, KM_IRQ0);

		/* do the actual data transfer */
		consumed = ap->ops->sff_data_xfer(dev, buf + offset, count, rw);
		consumed = ap->ops->sff_data_xfer(dev, buf + offset,
		count, rw);

		kunmap_atomic(buf, KM_IRQ0);
		local_irq_restore(flags);
		} else {
		buf = page_address(page);
		consumed = ap->ops->sff_data_xfer(dev, buf + offset, count, rw);
		consumed = ap->ops->sff_data_xfer(dev, buf + offset,
		count, rw);
		}

		bytes -= min(bytes, consumed);
		@@ -1066,7 +1086,8 @@ static void atapi_pio_bytes(struct ata_queued_cmd *qc)
		* RETURNS:
		* 1 if ok in workqueue, 0 otherwise.
		*/
		static inline int ata_hsm_ok_in_wq(struct ata_port ap, struct ata_queued_cmd qc)
		static inline int ata_hsm_ok_in_wq(struct ata_port *ap,
		struct ata_queued_cmd *qc)
		{
		if (qc->tf.flags & ATA_TFLAG_POLLING)
		return 1;
		@@ -1391,6 +1412,7 @@ fsm_start:

		return poll_next;
		}
		EXPORT_SYMBOL_GPL(ata_sff_hsm_move);

		void ata_pio_task(struct work_struct *work)
		{
		@@ -1560,6 +1582,7 @@ unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_qc_issue);

		/**
		* ata_sff_qc_fill_rtf - fill result TF using ->sff_tf_read
		@@ -1579,6 +1602,7 @@ bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc)
		qc->ap->ops->sff_tf_read(qc->ap, &qc->result_tf);
		return true;
		}
		EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);

		/**
		* ata_sff_host_intr - Handle host interrupt for given (port, task)
		@@ -1676,6 +1700,7 @@ idle_irq:
		#endif
		return 0; /* irq not handled */
		}
		EXPORT_SYMBOL_GPL(ata_sff_host_intr);

		/**
		* ata_sff_interrupt - Default ATA host interrupt handler
		@@ -1720,6 +1745,7 @@ irqreturn_t ata_sff_interrupt(int irq, void *dev_instance)

		return IRQ_RETVAL(handled);
		}
		EXPORT_SYMBOL_GPL(ata_sff_interrupt);

		/**
		* ata_sff_freeze - Freeze SFF controller port
		@@ -1748,6 +1774,7 @@ void ata_sff_freeze(struct ata_port *ap)

		ap->ops->sff_irq_clear(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_freeze);

		/**
		* ata_sff_thaw - Thaw SFF controller port
		@@ -1765,6 +1792,7 @@ void ata_sff_thaw(struct ata_port *ap)
		ap->ops->sff_irq_clear(ap);
		ap->ops->sff_irq_on(ap);
		}
		EXPORT_SYMBOL_GPL(ata_sff_thaw);

		/**
		* ata_sff_prereset - prepare SFF link for reset
		@@ -1806,6 +1834,7 @@ int ata_sff_prereset(struct ata_link *link, unsigned long deadline)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_prereset);

		/**
		* ata_devchk - PATA device presence detection
		@@ -1918,6 +1947,7 @@ unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,

		return class;
		}
		EXPORT_SYMBOL_GPL(ata_sff_dev_classify);

		/**
		* ata_sff_wait_after_reset - wait for devices to become ready after reset
		@@ -1994,6 +2024,7 @@ int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,

		return ret;
		}
		EXPORT_SYMBOL_GPL(ata_sff_wait_after_reset);

		static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
		unsigned long deadline)
		@@ -2066,6 +2097,7 @@ int ata_sff_softreset(struct ata_link link, unsigned int classes,
		DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_softreset);

		/**
		* sata_sff_hardreset - reset host port via SATA phy reset
		@@ -2098,6 +2130,7 @@ int sata_sff_hardreset(struct ata_link link, unsigned int class,
		DPRINTK("EXIT, class=%u\n", *class);
		return rc;
		}
		EXPORT_SYMBOL_GPL(sata_sff_hardreset);

		/**
		* ata_sff_postreset - SFF postreset callback
		@@ -2133,6 +2166,7 @@ void ata_sff_postreset(struct ata_link link, unsigned int classes)
		if (ap->ioaddr.ctl_addr)
		iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
		}
		EXPORT_SYMBOL_GPL(ata_sff_postreset);

		/**
		* ata_sff_error_handler - Stock error handler for BMDMA controller
		@@ -2205,6 +2239,7 @@ void ata_sff_error_handler(struct ata_port *ap)
		ata_do_eh(ap, ap->ops->prereset, softreset, hardreset,
		ap->ops->postreset);
		}
		EXPORT_SYMBOL_GPL(ata_sff_error_handler);

		/**
		* ata_sff_post_internal_cmd - Stock post_internal_cmd for SFF controller
		@@ -2227,6 +2262,7 @@ void ata_sff_post_internal_cmd(struct ata_queued_cmd *qc)

		spin_unlock_irqrestore(ap->lock, flags);
		}
		EXPORT_SYMBOL_GPL(ata_sff_post_internal_cmd);

		/**
		* ata_sff_port_start - Set port up for dma.
		@@ -2247,6 +2283,7 @@ int ata_sff_port_start(struct ata_port *ap)
		return ata_port_start(ap);
		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_sff_port_start);

		/**
		* ata_sff_std_ports - initialize ioaddr with standard port offsets.
		@@ -2272,6 +2309,7 @@ void ata_sff_std_ports(struct ata_ioports *ioaddr)
		ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
		ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
		}
		EXPORT_SYMBOL_GPL(ata_sff_std_ports);

		unsigned long ata_bmdma_mode_filter(struct ata_device *adev,
		unsigned long xfer_mask)
		@@ -2283,6 +2321,7 @@ unsigned long ata_bmdma_mode_filter(struct ata_device *adev,
		xfer_mask &= ~(ATA_MASK_MWDMA \| ATA_MASK_UDMA);
		return xfer_mask;
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_mode_filter);

		/**
		* ata_bmdma_setup - Set up PCI IDE BMDMA transaction
		@@ -2311,6 +2350,7 @@ void ata_bmdma_setup(struct ata_queued_cmd *qc)
		/* issue r/w command */
		ap->ops->sff_exec_command(ap, &qc->tf);
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_setup);

		/**
		* ata_bmdma_start - Start a PCI IDE BMDMA transaction
		@@ -2343,6 +2383,7 @@ void ata_bmdma_start(struct ata_queued_cmd *qc)
		* unneccessarily delayed for MMIO
		*/
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_start);

		/**
		* ata_bmdma_stop - Stop PCI IDE BMDMA transfer
		@@ -2367,6 +2408,7 @@ void ata_bmdma_stop(struct ata_queued_cmd *qc)
		/* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
		ata_sff_dma_pause(ap);
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_stop);

		/**
		* ata_bmdma_status - Read PCI IDE BMDMA status
		@@ -2383,6 +2425,7 @@ u8 ata_bmdma_status(struct ata_port *ap)
		{
		return ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
		}
		EXPORT_SYMBOL_GPL(ata_bmdma_status);

		/**
		* ata_bus_reset - reset host port and associated ATA channel
		@@ -2475,6 +2518,7 @@ err_out:

		DPRINTK("EXIT\n");
		}
		EXPORT_SYMBOL_GPL(ata_bus_reset);

		#ifdef CONFIG_PCI

		@@ -2502,6 +2546,7 @@ int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev)
		return -EOPNOTSUPP;
		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_clear_simplex);

		/**
		* ata_pci_bmdma_init - acquire PCI BMDMA resources and init ATA host
		@@ -2559,6 +2604,7 @@ int ata_pci_bmdma_init(struct ata_host *host)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_init);

		static int ata_resources_present(struct pci_dev *pdev, int port)
		{
		@@ -2651,6 +2697,7 @@ int ata_pci_sff_init_host(struct ata_host *host)

		return 0;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_host);

		/**
		* ata_pci_sff_prepare_host - helper to prepare native PCI ATA host
		@@ -2709,6 +2756,7 @@ int ata_pci_sff_prepare_host(struct pci_dev *pdev,
		devres_release_group(&pdev->dev, NULL);
		return rc;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_prepare_host);

		/**
		* ata_pci_sff_activate_host - start SFF host, request IRQ and register it
		@@ -2802,6 +2850,7 @@ int ata_pci_sff_activate_host(struct ata_host *host,

		return rc;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);

		/**
		* ata_pci_sff_init_one - Initialize/register PCI IDE host controller
		@@ -2876,54 +2925,7 @@ int ata_pci_sff_init_one(struct pci_dev *pdev,

		return rc;
		}
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);

		#endif /* CONFIG_PCI */

		EXPORT_SYMBOL_GPL(ata_sff_port_ops);
		EXPORT_SYMBOL_GPL(ata_bmdma_port_ops);
		EXPORT_SYMBOL_GPL(ata_sff_qc_prep);
		EXPORT_SYMBOL_GPL(ata_sff_dumb_qc_prep);
		EXPORT_SYMBOL_GPL(ata_sff_dev_select);
		EXPORT_SYMBOL_GPL(ata_sff_check_status);
		EXPORT_SYMBOL_GPL(ata_sff_dma_pause);
		EXPORT_SYMBOL_GPL(ata_sff_pause);
		EXPORT_SYMBOL_GPL(ata_sff_busy_sleep);
		EXPORT_SYMBOL_GPL(ata_sff_wait_ready);
		EXPORT_SYMBOL_GPL(ata_sff_tf_load);
		EXPORT_SYMBOL_GPL(ata_sff_tf_read);
		EXPORT_SYMBOL_GPL(ata_sff_exec_command);
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer);
		EXPORT_SYMBOL_GPL(ata_sff_data_xfer_noirq);
		EXPORT_SYMBOL_GPL(ata_sff_irq_on);
		EXPORT_SYMBOL_GPL(ata_sff_irq_clear);
		EXPORT_SYMBOL_GPL(ata_sff_hsm_move);
		EXPORT_SYMBOL_GPL(ata_sff_qc_issue);
		EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);
		EXPORT_SYMBOL_GPL(ata_sff_host_intr);
		EXPORT_SYMBOL_GPL(ata_sff_interrupt);
		EXPORT_SYMBOL_GPL(ata_sff_freeze);
		EXPORT_SYMBOL_GPL(ata_sff_thaw);
		EXPORT_SYMBOL_GPL(ata_sff_prereset);
		EXPORT_SYMBOL_GPL(ata_sff_dev_classify);
		EXPORT_SYMBOL_GPL(ata_sff_wait_after_reset);
		EXPORT_SYMBOL_GPL(ata_sff_softreset);
		EXPORT_SYMBOL_GPL(sata_sff_hardreset);
		EXPORT_SYMBOL_GPL(ata_sff_postreset);
		EXPORT_SYMBOL_GPL(ata_sff_error_handler);
		EXPORT_SYMBOL_GPL(ata_sff_post_internal_cmd);
		EXPORT_SYMBOL_GPL(ata_sff_port_start);
		EXPORT_SYMBOL_GPL(ata_sff_std_ports);
		EXPORT_SYMBOL_GPL(ata_bmdma_mode_filter);
		EXPORT_SYMBOL_GPL(ata_bmdma_setup);
		EXPORT_SYMBOL_GPL(ata_bmdma_start);
		EXPORT_SYMBOL_GPL(ata_bmdma_stop);
		EXPORT_SYMBOL_GPL(ata_bmdma_status);
		EXPORT_SYMBOL_GPL(ata_bus_reset);
		#ifdef CONFIG_PCI
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_clear_simplex);
		EXPORT_SYMBOL_GPL(ata_pci_bmdma_init);
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_host);
		EXPORT_SYMBOL_GPL(ata_pci_sff_prepare_host);
		EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);
		EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);
		#endif /* CONFIG_PCI */