libata: kill probe_ent and related helpers (6bfff31e) · Commits · e / devices / android_kernel_xiaomi_sm6125

drivers/ata/libata-core.c

+0 −153

Original line number	Diff line number	Diff line
		@@ -6132,131 +6132,6 @@ int ata_host_activate(struct ata_host *host, int irq,
		return rc;
		}

		/**
		* ata_device_add - Register hardware device with ATA and SCSI layers
		* @ent: Probe information describing hardware device to be registered
		*
		* This function processes the information provided in the probe
		* information struct @ent, allocates the necessary ATA and SCSI
		* host information structures, initializes them, and registers
		* everything with requisite kernel subsystems.
		*
		* This function requests irqs, probes the ATA bus, and probes
		* the SCSI bus.
		*
		* LOCKING:
		* PCI/etc. bus probe sem.
		*
		* RETURNS:
		* Number of ports registered. Zero on error (no ports registered).
		*/
		int ata_device_add(const struct ata_probe_ent *ent)
		{
		unsigned int i;
		struct device *dev = ent->dev;
		struct ata_host *host;
		int rc;

		DPRINTK("ENTER\n");

		if (ent->irq == 0) {
		dev_printk(KERN_ERR, dev, "is not available: No interrupt assigned.\n");
		return 0;
		}

		if (!ent->port_ops->error_handler &&
		!(ent->port_flags & (ATA_FLAG_SATA_RESET \| ATA_FLAG_SRST))) {
		dev_printk(KERN_ERR, dev, "no reset mechanism available\n");
		return 0;
		}

		if (!devres_open_group(dev, ata_device_add, GFP_KERNEL))
		return 0;

		/* allocate host */
		host = ata_host_alloc(dev, ent->n_ports);

		host->irq = ent->irq;
		host->irq2 = ent->irq2;
		host->iomap = ent->iomap;
		host->private_data = ent->private_data;
		host->ops = ent->port_ops;
		host->flags = ent->_host_flags;

		for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap = host->ports[i];

		/* dummy? */
		if (ent->dummy_port_mask & (1 << i)) {
		ap->ops = &ata_dummy_port_ops;
		continue;
		}

		if (ap->port_no == 1 && ent->pinfo2) {
		ap->pio_mask = ent->pinfo2->pio_mask;
		ap->mwdma_mask = ent->pinfo2->mwdma_mask;
		ap->udma_mask = ent->pinfo2->udma_mask;
		ap->flags \|= ent->pinfo2->flags;
		ap->ops = ent->pinfo2->port_ops;
		} else {
		ap->pio_mask = ent->pio_mask;
		ap->mwdma_mask = ent->mwdma_mask;
		ap->udma_mask = ent->udma_mask;
		ap->flags \|= ent->port_flags;
		ap->ops = ent->port_ops;
		}

		memcpy(&ap->ioaddr, &ent->port[ap->port_no],
		sizeof(struct ata_ioports));
		}

		/* start and freeze ports before requesting IRQ */
		rc = ata_host_start(host);
		if (rc)
		goto err_out;

		/* obtain irq, that may be shared between channels */
		rc = devm_request_irq(dev, ent->irq, ent->port_ops->irq_handler,
		ent->irq_flags, DRV_NAME, host);
		if (rc) {
		dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
		ent->irq, rc);
		goto err_out;
		}

		/* do we have a second IRQ for the other channel, eg legacy mode */
		if (ent->irq2) {
		/* We will get weird core code crashes later if this is true
		so trap it now */
		BUG_ON(ent->irq == ent->irq2);

		rc = devm_request_irq(dev, ent->irq2,
		ent->port_ops->irq_handler, ent->irq_flags,
		DRV_NAME, host);
		if (rc) {
		dev_printk(KERN_ERR, dev, "irq %lu request failed: %d\n",
		ent->irq2, rc);
		goto err_out;
		}
		}

		/* resource acquisition complete */
		devres_remove_group(dev, ata_device_add);

		/* register */
		rc = ata_host_register(host, ent->sht);
		if (rc)
		goto err_out;

		VPRINTK("EXIT, returning %u\n", host->n_ports);
		return host->n_ports; /* success */

		err_out:
		devres_release_group(dev, ata_device_add);
		VPRINTK("EXIT, returning 0\n");
		return 0;
		}

		/**
		* ata_port_detach - Detach ATA port in prepration of device removal
		* @ap: ATA port to be detached
		@@ -6332,32 +6207,6 @@ void ata_host_detach(struct ata_host *host)
		ata_port_detach(host->ports[i]);
		}

		struct ata_probe_ent *
		ata_probe_ent_alloc(struct device dev, const struct ata_port_info port)
		{
		struct ata_probe_ent *probe_ent;

		probe_ent = devm_kzalloc(dev, sizeof(*probe_ent), GFP_KERNEL);
		if (!probe_ent) {
		printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
		kobject_name(&(dev->kobj)));
		return NULL;
		}

		INIT_LIST_HEAD(&probe_ent->node);
		probe_ent->dev = dev;

		probe_ent->sht = port->sht;
		probe_ent->port_flags = port->flags;
		probe_ent->pio_mask = port->pio_mask;
		probe_ent->mwdma_mask = port->mwdma_mask;
		probe_ent->udma_mask = port->udma_mask;
		probe_ent->port_ops = port->port_ops;
		probe_ent->private_data = port->private_data;

		return probe_ent;
		}

		/**
		* ata_std_ports - initialize ioaddr with standard port offsets.
		* @ioaddr: IO address structure to be initialized
		@@ -6647,7 +6496,6 @@ EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
		EXPORT_SYMBOL_GPL(ata_host_start);
		EXPORT_SYMBOL_GPL(ata_host_register);
		EXPORT_SYMBOL_GPL(ata_host_activate);
		EXPORT_SYMBOL_GPL(ata_device_add);
		EXPORT_SYMBOL_GPL(ata_host_detach);
		EXPORT_SYMBOL_GPL(ata_sg_init);
		EXPORT_SYMBOL_GPL(ata_sg_init_one);
		@@ -6730,7 +6578,6 @@ EXPORT_SYMBOL_GPL(ata_timing_merge);

		#ifdef CONFIG_PCI
		EXPORT_SYMBOL_GPL(pci_test_config_bits);
		EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
		EXPORT_SYMBOL_GPL(ata_pci_init_native_host);
		EXPORT_SYMBOL_GPL(ata_pci_prepare_native_host);
		EXPORT_SYMBOL_GPL(ata_pci_init_one);

drivers/ata/libata-sff.c

+0 −95

Original line number	Diff line number	Diff line
		@@ -532,101 +532,6 @@ static int ata_resources_present(struct pci_dev *pdev, int port)
		return 1;
		}

		/**
		* ata_pci_init_native_mode - Initialize native-mode driver
		* @pdev: pci device to be initialized
		* @port: array[2] of pointers to port info structures.
		* @ports: bitmap of ports present
		*
		* Utility function which allocates and initializes an
		* ata_probe_ent structure for a standard dual-port
		* PIO-based IDE controller. The returned ata_probe_ent
		* structure can be passed to ata_device_add(). The returned
		* ata_probe_ent structure should then be freed with kfree().
		*
		* The caller need only pass the address of the primary port, the
		* secondary will be deduced automatically. If the device has non
		* standard secondary port mappings this function can be called twice,
		* once for each interface.
		*/

		struct ata_probe_ent *
		ata_pci_init_native_mode(struct pci_dev pdev, struct ata_port_info *port, int ports)
		{
		struct ata_probe_ent *probe_ent;
		int i;
		void __iomem * const *iomap;

		/* Discard disabled ports. Some controllers show their unused
		* channels this way. Disabled ports will be made dummy.
		*/
		if (ata_resources_present(pdev, 0) == 0)
		ports &= ~ATA_PORT_PRIMARY;
		if (ata_resources_present(pdev, 1) == 0)
		ports &= ~ATA_PORT_SECONDARY;

		if (!ports) {
		dev_printk(KERN_ERR, &pdev->dev, "no available port\n");
		return NULL;
		}

		/* iomap BARs */
		for (i = 0; i < 4; i++) {
		if (!(ports & (1 << (i / 2))))
		continue;
		if (pcim_iomap(pdev, i, 0) == NULL) {
		dev_printk(KERN_ERR, &pdev->dev,
		"failed to iomap PCI BAR %d\n", i);
		return NULL;
		}
		}

		pcim_iomap(pdev, 4, 0); /* may fail */
		iomap = pcim_iomap_table(pdev);

		/* alloc and init probe_ent */
		probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
		if (!probe_ent)
		return NULL;

		probe_ent->n_ports = 2;
		probe_ent->irq = pdev->irq;
		probe_ent->irq_flags = IRQF_SHARED;

		if (ports & ATA_PORT_PRIMARY) {
		probe_ent->port[0].cmd_addr = iomap[0];
		probe_ent->port[0].altstatus_addr =
		probe_ent->port[0].ctl_addr = (void __iomem *)
		((unsigned long)iomap[1] \| ATA_PCI_CTL_OFS);
		if (iomap[4]) {
		if ((!(port[0]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
		(ioread8(iomap[4] + 2) & 0x80))
		probe_ent->_host_flags \|= ATA_HOST_SIMPLEX;
		probe_ent->port[0].bmdma_addr = iomap[4];
		}
		ata_std_ports(&probe_ent->port[0]);
		} else
		probe_ent->dummy_port_mask \|= ATA_PORT_PRIMARY;

		if (ports & ATA_PORT_SECONDARY) {
		probe_ent->port[1].cmd_addr = iomap[2];
		probe_ent->port[1].altstatus_addr =
		probe_ent->port[1].ctl_addr = (void __iomem *)
		((unsigned long)iomap[3] \| ATA_PCI_CTL_OFS);
		if (iomap[4]) {
		if ((!(port[1]->flags & ATA_FLAG_IGN_SIMPLEX)) &&
		(ioread8(iomap[4] + 10) & 0x80))
		probe_ent->_host_flags \|= ATA_HOST_SIMPLEX;
		probe_ent->port[1].bmdma_addr = iomap[4] + 8;
		}
		ata_std_ports(&probe_ent->port[1]);
		probe_ent->pinfo2 = port[1];
		} else
		probe_ent->dummy_port_mask \|= ATA_PORT_SECONDARY;

		return probe_ent;
		}

		/**
		* ata_pci_init_bmdma - acquire PCI BMDMA resources and init ATA host
		* @host: target ATA host

drivers/ata/libata.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -93,8 +93,6 @@ extern int ata_flush_cache(struct ata_device *dev);
		extern void ata_dev_init(struct ata_device *dev);
		extern int ata_task_ioctl(struct scsi_device scsidev, void __user arg);
		extern int ata_cmd_ioctl(struct scsi_device scsidev, void __user arg);
		extern struct ata_probe_ent ata_probe_ent_alloc(struct device dev,
		const struct ata_port_info *port);
		extern struct ata_port ata_port_alloc(struct ata_host host);

		/* libata-acpi.c */

include/linux/libata.h

+0 −31

Original line number	Diff line number	Diff line
		@@ -368,34 +368,6 @@ struct ata_ioports {
		void __iomem *scr_addr;
		};

		struct ata_probe_ent {
		struct list_head node;
		struct device *dev;
		const struct ata_port_operations *port_ops;
		struct scsi_host_template *sht;
		struct ata_ioports port[ATA_MAX_PORTS];
		unsigned int n_ports;
		unsigned int dummy_port_mask;
		unsigned int pio_mask;
		unsigned int mwdma_mask;
		unsigned int udma_mask;
		unsigned long irq;
		unsigned long irq2;
		unsigned int irq_flags;
		unsigned long port_flags;
		unsigned long _host_flags;
		void __iomem * const *iomap;
		void *private_data;

		/* port_info for the secondary port. Together with irq2, it's
		* used to implement non-uniform secondary port. Currently,
		* the only user is ata_piix combined mode. This workaround
		* will be removed together with ata_probe_ent when init model
		* is updated.
		*/
		const struct ata_port_info *pinfo2;
		};

		struct ata_host {
		spinlock_t lock;
		struct device *dev;
		@@ -744,7 +716,6 @@ extern int ata_host_register(struct ata_host *host,
		extern int ata_host_activate(struct ata_host *host, int irq,
		irq_handler_t irq_handler, unsigned long irq_flags,
		struct scsi_host_template *sht);
		extern int ata_device_add(const struct ata_probe_ent *ent);
		extern void ata_host_detach(struct ata_host *host);
		extern void ata_host_init(struct ata_host , struct device ,
		unsigned long, const struct ata_port_operations *);
		@@ -892,8 +863,6 @@ struct pci_bits {
		unsigned long val;
		};

		extern struct ata_probe_ent *
		ata_pci_init_native_mode(struct pci_dev pdev, struct ata_port_info *port, int portmask);
		extern int ata_pci_init_native_host(struct ata_host *host,
		unsigned int port_mask);
		extern int ata_pci_prepare_native_host(struct pci_dev *pdev,