[linux-2.6-block.git] / drivers / scsi / libsas / sas_discover.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Serial Attached SCSI (SAS) Discover process
 *
 * Copyright (C) 2005 Adaptec, Inc.  All rights reserved.
 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
 */

#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_eh.h>
#include "sas_internal.h"

#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_sas.h>
#include <scsi/sas_ata.h>
#include "scsi_sas_internal.h"

/* ---------- Basic task processing for discovery purposes ---------- */

void sas_init_dev(struct domain_device *dev)
{
	switch (dev->dev_type) {
	case SAS_END_DEVICE:
		INIT_LIST_HEAD(&dev->ssp_dev.eh_list_node);
		break;
	case SAS_EDGE_EXPANDER_DEVICE:
	case SAS_FANOUT_EXPANDER_DEVICE:
		INIT_LIST_HEAD(&dev->ex_dev.children);
		mutex_init(&dev->ex_dev.cmd_mutex);
		break;
	default:
		break;
	}
}

/* ---------- Domain device discovery ---------- */

/**
 * sas_get_port_device - Discover devices which caused port creation
 * @port: pointer to struct sas_port of interest
 *
 * Devices directly attached to a HA port, have no parent.  This is
 * how we know they are (domain) "root" devices.  All other devices
 * do, and should have their "parent" pointer set appropriately as
 * soon as a child device is discovered.
 */
static int sas_get_port_device(struct asd_sas_port *port)
{
	struct asd_sas_phy *phy;
	struct sas_rphy *rphy;
	struct domain_device *dev;
	int rc = -ENODEV;

	dev = sas_alloc_device();
	if (!dev)
		return -ENOMEM;

	spin_lock_irq(&port->phy_list_lock);
	if (list_empty(&port->phy_list)) {
		spin_unlock_irq(&port->phy_list_lock);
		sas_put_device(dev);
		return -ENODEV;
	}
	phy = container_of(port->phy_list.next, struct asd_sas_phy, port_phy_el);
	spin_lock(&phy->frame_rcvd_lock);
	memcpy(dev->frame_rcvd, phy->frame_rcvd, min(sizeof(dev->frame_rcvd),
					     (size_t)phy->frame_rcvd_size));
	spin_unlock(&phy->frame_rcvd_lock);
	spin_unlock_irq(&port->phy_list_lock);

	if (dev->frame_rcvd[0] == 0x34 && port->oob_mode == SATA_OOB_MODE) {
		struct dev_to_host_fis *fis =
			(struct dev_to_host_fis *) dev->frame_rcvd;
		if (fis->interrupt_reason == 1 && fis->lbal == 1 &&
		    fis->byte_count_low == 0x69 && fis->byte_count_high == 0x96
		    && (fis->device & ~0x10) == 0)
			dev->dev_type = SAS_SATA_PM;
		else
			dev->dev_type = SAS_SATA_DEV;
		dev->tproto = SAS_PROTOCOL_SATA;
	} else if (port->oob_mode == SAS_OOB_MODE) {
		struct sas_identify_frame *id =
			(struct sas_identify_frame *) dev->frame_rcvd;
		dev->dev_type = id->dev_type;
		dev->iproto = id->initiator_bits;
		dev->tproto = id->target_bits;
	} else {
		/* If the oob mode is OOB_NOT_CONNECTED, the port is
		 * disconnected due to race with PHY down. We cannot
		 * continue to discover this port
		 */
		sas_put_device(dev);
		pr_warn("Port %016llx is disconnected when discovering\n",
			SAS_ADDR(port->attached_sas_addr));
		return -ENODEV;
	}

	sas_init_dev(dev);

	dev->port = port;
	switch (dev->dev_type) {
	case SAS_SATA_DEV:
		rc = sas_ata_init(dev);
		if (rc) {
			rphy = NULL;
			break;
		}
		fallthrough;
	case SAS_END_DEVICE:
		rphy = sas_end_device_alloc(port->port);
		break;
	case SAS_EDGE_EXPANDER_DEVICE:
		rphy = sas_expander_alloc(port->port,
					  SAS_EDGE_EXPANDER_DEVICE);
		break;
	case SAS_FANOUT_EXPANDER_DEVICE:
		rphy = sas_expander_alloc(port->port,
					  SAS_FANOUT_EXPANDER_DEVICE);
		break;
	default:
		pr_warn("ERROR: Unidentified device type %d\n", dev->dev_type);
		rphy = NULL;
		break;
	}

	if (!rphy) {
		sas_put_device(dev);
		return rc;
	}

	rphy->identify.phy_identifier = phy->phy->identify.phy_identifier;
	memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE);
	sas_fill_in_rphy(dev, rphy);
	sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr);
	port->port_dev = dev;
	dev->linkrate = port->linkrate;
	dev->min_linkrate = port->linkrate;
	dev->max_linkrate = port->linkrate;
	dev->pathways = port->num_phys;
	memset(port->disc.fanout_sas_addr, 0, SAS_ADDR_SIZE);
	memset(port->disc.eeds_a, 0, SAS_ADDR_SIZE);
	memset(port->disc.eeds_b, 0, SAS_ADDR_SIZE);
	port->disc.max_level = 0;
	sas_device_set_phy(dev, port->port);

	dev->rphy = rphy;
	get_device(&dev->rphy->dev);

	if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEVICE)
		list_add_tail(&dev->disco_list_node, &port->disco_list);
	else {
		spin_lock_irq(&port->dev_list_lock);
		list_add_tail(&dev->dev_list_node, &port->dev_list);
		spin_unlock_irq(&port->dev_list_lock);
	}

	spin_lock_irq(&port->phy_list_lock);
	list_for_each_entry(phy, &port->phy_list, port_phy_el)
		sas_phy_set_target(phy, dev);
	spin_unlock_irq(&port->phy_list_lock);

	return 0;
}

/* ---------- Discover and Revalidate ---------- */

int sas_notify_lldd_dev_found(struct domain_device *dev)
{
	int res = 0;
	struct sas_ha_struct *sas_ha = dev->port->ha;
	struct Scsi_Host *shost = sas_ha->shost;
	struct sas_internal *i = to_sas_internal(shost->transportt);

	if (!i->dft->lldd_dev_found)
		return 0;

	res = i->dft->lldd_dev_found(dev);
	if (res) {
		pr_warn("driver on host %s cannot handle device %016llx, error:%d\n",
			dev_name(sas_ha->dev),
			SAS_ADDR(dev->sas_addr), res);
		return res;
	}
	set_bit(SAS_DEV_FOUND, &dev->state);
	kref_get(&dev->kref);
	return 0;
}


void sas_notify_lldd_dev_gone(struct domain_device *dev)
{
	struct sas_ha_struct *sas_ha = dev->port->ha;
	struct Scsi_Host *shost = sas_ha->shost;
	struct sas_internal *i = to_sas_internal(shost->transportt);

	if (!i->dft->lldd_dev_gone)
		return;

	if (test_and_clear_bit(SAS_DEV_FOUND, &dev->state)) {
		i->dft->lldd_dev_gone(dev);
		sas_put_device(dev);
	}
}

static void sas_probe_devices(struct asd_sas_port *port)
{
	struct domain_device *dev, *n;

	/* devices must be domain members before link recovery and probe */
	list_for_each_entry(dev, &port->disco_list, disco_list_node) {
		spin_lock_irq(&port->dev_list_lock);
		list_add_tail(&dev->dev_list_node, &port->dev_list);
		spin_unlock_irq(&port->dev_list_lock);
	}

	sas_probe_sata(port);

	list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
		int err;

		err = sas_rphy_add(dev->rphy);
		if (err)
			sas_fail_probe(dev, __func__, err);
		else
			list_del_init(&dev->disco_list_node);
	}
}

static void sas_suspend_devices(struct work_struct *work)
{
	struct asd_sas_phy *phy;
	struct domain_device *dev;
	struct sas_discovery_event *ev = to_sas_discovery_event(work);
	struct asd_sas_port *port = ev->port;
	struct Scsi_Host *shost = port->ha->shost;
	struct sas_internal *si = to_sas_internal(shost->transportt);

	clear_bit(DISCE_SUSPEND, &port->disc.pending);

	sas_suspend_sata(port);

	/* lldd is free to forget the domain_device across the
	 * suspension, we force the issue here to keep the reference
	 * counts aligned
	 */
	list_for_each_entry(dev, &port->dev_list, dev_list_node)
		sas_notify_lldd_dev_gone(dev);

	/* we are suspending, so we know events are disabled and
	 * phy_list is not being mutated
	 */
	list_for_each_entry(phy, &port->phy_list, port_phy_el) {
		if (si->dft->lldd_port_deformed)
			si->dft->lldd_port_deformed(phy);
		phy->suspended = 1;
		port->suspended = 1;
	}
}

static void sas_resume_devices(struct work_struct *work)
{
	struct sas_discovery_event *ev = to_sas_discovery_event(work);
	struct asd_sas_port *port = ev->port;

	clear_bit(DISCE_RESUME, &port->disc.pending);

	sas_resume_sata(port);
}

/**
 * sas_discover_end_dev - discover an end device (SSP, etc)
 * @dev: pointer to domain device of interest
 *
 * See comment in sas_discover_sata().
 */
static int sas_discover_end_dev(struct domain_device *dev)
{
	return sas_notify_lldd_dev_found(dev);
}

/* ---------- Device registration and unregistration ---------- */

void sas_free_device(struct kref *kref)
{
	struct domain_device *dev = container_of(kref, typeof(*dev), kref);

	put_device(&dev->rphy->dev);
	dev->rphy = NULL;

	if (dev->parent)
		sas_put_device(dev->parent);

	sas_port_put_phy(dev->phy);
	dev->phy = NULL;

	/* remove the phys and ports, everything else should be gone */
	if (dev_is_expander(dev->dev_type))
		kfree(dev->ex_dev.ex_phy);

	if (dev_is_sata(dev) && dev->sata_dev.ap) {
		ata_sas_tport_delete(dev->sata_dev.ap);
		kfree(dev->sata_dev.ap);
		ata_host_put(dev->sata_dev.ata_host);
		dev->sata_dev.ata_host = NULL;
		dev->sata_dev.ap = NULL;
	}

	kfree(dev);
}

static void sas_unregister_common_dev(struct asd_sas_port *port, struct domain_device *dev)
{
	struct sas_ha_struct *ha = port->ha;

	sas_notify_lldd_dev_gone(dev);
	if (!dev->parent)
		dev->port->port_dev = NULL;
	else
		list_del_init(&dev->siblings);

	spin_lock_irq(&port->dev_list_lock);
	list_del_init(&dev->dev_list_node);
	if (dev_is_sata(dev))
		sas_ata_end_eh(dev->sata_dev.ap);
	spin_unlock_irq(&port->dev_list_lock);

	spin_lock_irq(&ha->lock);
	if (dev->dev_type == SAS_END_DEVICE &&
	    !list_empty(&dev->ssp_dev.eh_list_node)) {
		list_del_init(&dev->ssp_dev.eh_list_node);
		ha->eh_active--;
	}
	spin_unlock_irq(&ha->lock);

	sas_put_device(dev);
}

void sas_destruct_devices(struct asd_sas_port *port)
{
	struct domain_device *dev, *n;

	list_for_each_entry_safe(dev, n, &port->destroy_list, disco_list_node) {
		list_del_init(&dev->disco_list_node);

		sas_remove_children(&dev->rphy->dev);
		sas_rphy_delete(dev->rphy);
		sas_unregister_common_dev(port, dev);
	}
}

static void sas_destruct_ports(struct asd_sas_port *port)
{
	struct sas_port *sas_port, *p;

	list_for_each_entry_safe(sas_port, p, &port->sas_port_del_list, del_list) {
		list_del_init(&sas_port->del_list);
		sas_port_delete(sas_port);
	}
}

static bool sas_abort_cmd(struct request *req, void *data)
{
	struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
	struct domain_device *dev = data;

	if (dev == cmd_to_domain_dev(cmd))
		blk_abort_request(req);
	return true;
}

static void sas_abort_device_scsi_cmds(struct domain_device *dev)
{
	struct sas_ha_struct *sas_ha = dev->port->ha;
	struct Scsi_Host *shost = sas_ha->shost;

	if (dev_is_expander(dev->dev_type))
		return;

	/*
	 * For removed device with active IOs, the user space applications have
	 * to spend very long time waiting for the timeout. This is not
	 * necessary because a removed device will not return the IOs.
	 * Abort the inflight IOs here so that EH can be quickly kicked in.
	 */
	blk_mq_tagset_busy_iter(&shost->tag_set, sas_abort_cmd, dev);
}

void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *dev)
{
	if (!test_bit(SAS_DEV_DESTROY, &dev->state) &&
	    !list_empty(&dev->disco_list_node)) {
		/* this rphy never saw sas_rphy_add */
		list_del_init(&dev->disco_list_node);
		sas_rphy_free(dev->rphy);
		sas_unregister_common_dev(port, dev);
		return;
	}

	if (!test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) {
		if (test_bit(SAS_DEV_GONE, &dev->state))
			sas_abort_device_scsi_cmds(dev);
		sas_rphy_unlink(dev->rphy);
		list_move_tail(&dev->disco_list_node, &port->destroy_list);
	}
}

void sas_unregister_domain_devices(struct asd_sas_port *port, int gone)
{
	struct domain_device *dev, *n;

	list_for_each_entry_safe_reverse(dev, n, &port->dev_list, dev_list_node) {
		if (gone)
			set_bit(SAS_DEV_GONE, &dev->state);
		sas_unregister_dev(port, dev);
	}

	list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node)
		sas_unregister_dev(port, dev);

	port->port->rphy = NULL;

}

void sas_device_set_phy(struct domain_device *dev, struct sas_port *port)
{
	struct sas_ha_struct *ha;
	struct sas_phy *new_phy;

	if (!dev)
		return;

	ha = dev->port->ha;
	new_phy = sas_port_get_phy(port);

	/* pin and record last seen phy */
	spin_lock_irq(&ha->phy_port_lock);
	if (new_phy) {
		sas_port_put_phy(dev->phy);
		dev->phy = new_phy;
	}
	spin_unlock_irq(&ha->phy_port_lock);
}

/* ---------- Discovery and Revalidation ---------- */

/**
 * sas_discover_domain - discover the domain
 * @work: work structure embedded in port domain device.
 *
 * NOTE: this process _must_ quit (return) as soon as any connection
 * errors are encountered.  Connection recovery is done elsewhere.
 * Discover process only interrogates devices in order to discover the
 * domain.
 */
static void sas_discover_domain(struct work_struct *work)
{
	struct domain_device *dev;
	int error = 0;
	struct sas_discovery_event *ev = to_sas_discovery_event(work);
	struct asd_sas_port *port = ev->port;

	clear_bit(DISCE_DISCOVER_DOMAIN, &port->disc.pending);

	if (port->port_dev)
		return;

	error = sas_get_port_device(port);
	if (error)
		return;
	dev = port->port_dev;

	pr_debug("DOING DISCOVERY on port %d, pid:%d\n", port->id,
		 task_pid_nr(current));

	switch (dev->dev_type) {
	case SAS_END_DEVICE:
		error = sas_discover_end_dev(dev);
		break;
	case SAS_EDGE_EXPANDER_DEVICE:
	case SAS_FANOUT_EXPANDER_DEVICE:
		error = sas_discover_root_expander(dev);
		break;
	case SAS_SATA_DEV:
	case SAS_SATA_PM:
		error = sas_discover_sata(dev);
		break;
	default:
		error = -ENXIO;
		pr_err("unhandled device %d\n", dev->dev_type);
		break;
	}

	if (error) {
		sas_rphy_free(dev->rphy);
		list_del_init(&dev->disco_list_node);
		spin_lock_irq(&port->dev_list_lock);
		list_del_init(&dev->dev_list_node);
		spin_unlock_irq(&port->dev_list_lock);

		sas_put_device(dev);
		port->port_dev = NULL;
	}

	sas_probe_devices(port);

	pr_debug("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id,
		 task_pid_nr(current), error);
}

static void sas_revalidate_domain(struct work_struct *work)
{
	int res = 0;
	struct sas_discovery_event *ev = to_sas_discovery_event(work);
	struct asd_sas_port *port = ev->port;
	struct sas_ha_struct *ha = port->ha;
	struct domain_device *ddev = port->port_dev;

	/* prevent revalidation from finding sata links in recovery */
	mutex_lock(&ha->disco_mutex);
	if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) {
		pr_debug("REVALIDATION DEFERRED on port %d, pid:%d\n",
			 port->id, task_pid_nr(current));
		goto out;
	}

	clear_bit(DISCE_REVALIDATE_DOMAIN, &port->disc.pending);

	pr_debug("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id,
		 task_pid_nr(current));

	if (ddev && dev_is_expander(ddev->dev_type))
		res = sas_ex_revalidate_domain(ddev);

	pr_debug("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n",
		 port->id, task_pid_nr(current), res);
 out:
	mutex_unlock(&ha->disco_mutex);

	sas_destruct_devices(port);
	sas_destruct_ports(port);
	sas_probe_devices(port);
}

/* ---------- Events ---------- */

static void sas_chain_work(struct sas_ha_struct *ha, struct sas_work *sw)
{
	/* chained work is not subject to SA_HA_DRAINING or
	 * SAS_HA_REGISTERED, because it is either submitted in the
	 * workqueue, or known to be submitted from a context that is
	 * not racing against draining
	 */
	queue_work(ha->disco_q, &sw->work);
}

static void sas_chain_event(int event, unsigned long *pending,
			    struct sas_work *sw,
			    struct sas_ha_struct *ha)
{
	if (!test_and_set_bit(event, pending)) {
		unsigned long flags;

		spin_lock_irqsave(&ha->lock, flags);
		sas_chain_work(ha, sw);
		spin_unlock_irqrestore(&ha->lock, flags);
	}
}

void sas_discover_event(struct asd_sas_port *port, enum discover_event ev)
{
	struct sas_discovery *disc;

	if (!port)
		return;
	disc = &port->disc;

	BUG_ON(ev >= DISC_NUM_EVENTS);

	sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha);
}

/**
 * sas_init_disc - initialize the discovery struct in the port
 * @disc: port discovery structure
 * @port: pointer to struct port
 *
 * Called when the ports are being initialized.
 */
void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port)
{
	int i;

	static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = {
		[DISCE_DISCOVER_DOMAIN] = sas_discover_domain,
		[DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain,
		[DISCE_SUSPEND] = sas_suspend_devices,
		[DISCE_RESUME] = sas_resume_devices,
	};

	disc->pending = 0;
	for (i = 0; i < DISC_NUM_EVENTS; i++) {
		INIT_SAS_WORK(&disc->disc_work[i].work, sas_event_fns[i]);
		disc->disc_work[i].port = port;
	}
}
Commit	Line	Data
86b89cb0	1	// SPDX-License-Identifier: GPL-2.0
2908d778 JB	2	/*
	3	* Serial Attached SCSI (SAS) Discover process
	4	*
	5	* Copyright (C) 2005 Adaptec, Inc. All rights reserved.
	6	* Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com>
2908d778 JB	7	*/
2908d778 JB	8
2908d778	9	#include <linux/scatterlist.h>
5a0e3ad6	10	#include <linux/slab.h>
2908d778 JB	11	#include <scsi/scsi_host.h>
	12	#include <scsi/scsi_eh.h>
	13	#include "sas_internal.h"
	14
	15	#include <scsi/scsi_transport.h>
	16	#include <scsi/scsi_transport_sas.h>
756f173f	17	#include <scsi/sas_ata.h>
e15f669c	18	#include "scsi_sas_internal.h"
2908d778 JB	19
	20	/* ---------- Basic task processing for discovery purposes ---------- */
	21
	22	void sas_init_dev(struct domain_device *dev)
	23	{
89d3cf6a	24	switch (dev->dev_type) {
aa9f8328	25	case SAS_END_DEVICE:
5db45bdc	26	INIT_LIST_HEAD(&dev->ssp_dev.eh_list_node);
89d3cf6a	27	break;
aa9f8328 JB	28	case SAS_EDGE_EXPANDER_DEVICE:
aa9f8328 JB	29	case SAS_FANOUT_EXPANDER_DEVICE:
89d3cf6a JS	30	INIT_LIST_HEAD(&dev->ex_dev.children);
	31	mutex_init(&dev->ex_dev.cmd_mutex);
	32	break;
89d3cf6a JS	33	default:
	34	break;
	35	}
2908d778 JB	36	}
2908d778 JB	37
2908d778 JB	38	/* ---------- Domain device discovery ---------- */
	39
	40	/**
121246ae	41	* sas_get_port_device - Discover devices which caused port creation
2908d778 JB	42	* @port: pointer to struct sas_port of interest
	43	*
	44	* Devices directly attached to a HA port, have no parent. This is
	45	* how we know they are (domain) "root" devices. All other devices
	46	* do, and should have their "parent" pointer set appropriately as
	47	* soon as a child device is discovered.
	48	*/
	49	static int sas_get_port_device(struct asd_sas_port *port)
	50	{
2908d778 JB	51	struct asd_sas_phy *phy;
	52	struct sas_rphy *rphy;
	53	struct domain_device *dev;
b2024459	54	int rc = -ENODEV;
2908d778	55
735f7d2f	56	dev = sas_alloc_device();
2908d778 JB	57	if (!dev)
	58	return -ENOMEM;
	59
899fcf40	60	spin_lock_irq(&port->phy_list_lock);
2908d778	61	if (list_empty(&port->phy_list)) {
899fcf40	62	spin_unlock_irq(&port->phy_list_lock);
735f7d2f	63	sas_put_device(dev);
2908d778 JB	64	return -ENODEV;
	65	}
	66	phy = container_of(port->phy_list.next, struct asd_sas_phy, port_phy_el);
	67	spin_lock(&phy->frame_rcvd_lock);
	68	memcpy(dev->frame_rcvd, phy->frame_rcvd, min(sizeof(dev->frame_rcvd),
	69	(size_t)phy->frame_rcvd_size));
	70	spin_unlock(&phy->frame_rcvd_lock);
899fcf40	71	spin_unlock_irq(&port->phy_list_lock);
2908d778 JB	72
	73	if (dev->frame_rcvd[0] == 0x34 && port->oob_mode == SATA_OOB_MODE) {
	74	struct dev_to_host_fis *fis =
	75	(struct dev_to_host_fis *) dev->frame_rcvd;
	76	if (fis->interrupt_reason == 1 && fis->lbal == 1 &&
857a80bb	77	fis->byte_count_low == 0x69 && fis->byte_count_high == 0x96
2908d778	78	&& (fis->device & ~0x10) == 0)
aa9f8328	79	dev->dev_type = SAS_SATA_PM;
2908d778	80	else
aa9f8328	81	dev->dev_type = SAS_SATA_DEV;
5929faf3	82	dev->tproto = SAS_PROTOCOL_SATA;
f70267f3	83	} else if (port->oob_mode == SAS_OOB_MODE) {
2908d778 JB	84	struct sas_identify_frame *id =
	85	(struct sas_identify_frame *) dev->frame_rcvd;
	86	dev->dev_type = id->dev_type;
	87	dev->iproto = id->initiator_bits;
	88	dev->tproto = id->target_bits;
f70267f3 JY	89	} else {
	90	/* If the oob mode is OOB_NOT_CONNECTED, the port is
	91	* disconnected due to race with PHY down. We cannot
	92	* continue to discover this port
	93	*/
	94	sas_put_device(dev);
	95	pr_warn("Port %016llx is disconnected when discovering\n",
	96	SAS_ADDR(port->attached_sas_addr));
	97	return -ENODEV;
2908d778 JB	98	}
	99
	100	sas_init_dev(dev);
	101
b2024459	102	dev->port = port;
2908d778	103	switch (dev->dev_type) {
aa9f8328	104	case SAS_SATA_DEV:
b2024459 DW	105	rc = sas_ata_init(dev);
	106	if (rc) {
	107	rphy = NULL;
	108	break;
	109	}
df561f66	110	fallthrough;
aa9f8328	111	case SAS_END_DEVICE:
2908d778 JB	112	rphy = sas_end_device_alloc(port->port);
2908d778 JB	113	break;
aa9f8328	114	case SAS_EDGE_EXPANDER_DEVICE:
2908d778 JB	115	rphy = sas_expander_alloc(port->port,
	116	SAS_EDGE_EXPANDER_DEVICE);
	117	break;
aa9f8328	118	case SAS_FANOUT_EXPANDER_DEVICE:
2908d778 JB	119	rphy = sas_expander_alloc(port->port,
	120	SAS_FANOUT_EXPANDER_DEVICE);
	121	break;
2908d778	122	default:
15ba7806	123	pr_warn("ERROR: Unidentified device type %d\n", dev->dev_type);
2908d778 JB	124	rphy = NULL;
	125	break;
	126	}
	127
	128	if (!rphy) {
735f7d2f	129	sas_put_device(dev);
b2024459	130	return rc;
2908d778	131	}
899fcf40	132
2908d778 JB	133	rphy->identify.phy_identifier = phy->phy->identify.phy_identifier;
	134	memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE);
	135	sas_fill_in_rphy(dev, rphy);
	136	sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr);
	137	port->port_dev = dev;
2908d778 JB	138	dev->linkrate = port->linkrate;
	139	dev->min_linkrate = port->linkrate;
	140	dev->max_linkrate = port->linkrate;
	141	dev->pathways = port->num_phys;
	142	memset(port->disc.fanout_sas_addr, 0, SAS_ADDR_SIZE);
	143	memset(port->disc.eeds_a, 0, SAS_ADDR_SIZE);
	144	memset(port->disc.eeds_b, 0, SAS_ADDR_SIZE);
	145	port->disc.max_level = 0;
f41a0c44	146	sas_device_set_phy(dev, port->port);
2908d778 JB	147
2908d778 JB	148	dev->rphy = rphy;
9487669f	149	get_device(&dev->rphy->dev);
87c8331f	150
aa9f8328	151	if (dev_is_sata(dev) \|\| dev->dev_type == SAS_END_DEVICE)
87c8331f DW	152	list_add_tail(&dev->disco_list_node, &port->disco_list);
	153	else {
	154	spin_lock_irq(&port->dev_list_lock);
	155	list_add_tail(&dev->dev_list_node, &port->dev_list);
	156	spin_unlock_irq(&port->dev_list_lock);
	157	}
2908d778	158
ec236e52 DW	159	spin_lock_irq(&port->phy_list_lock);
	160	list_for_each_entry(phy, &port->phy_list, port_phy_el)
	161	sas_phy_set_target(phy, dev);
	162	spin_unlock_irq(&port->phy_list_lock);
	163
2908d778 JB	164	return 0;
	165	}
	166
	167	/* ---------- Discover and Revalidate ---------- */
	168
2908d778 JB	169	int sas_notify_lldd_dev_found(struct domain_device *dev)
	170	{
	171	int res = 0;
	172	struct sas_ha_struct *sas_ha = dev->port->ha;
1136a022	173	struct Scsi_Host *shost = sas_ha->shost;
2908d778 JB	174	struct sas_internal *i = to_sas_internal(shost->transportt);
2908d778 JB	175
303694ee DW	176	if (!i->dft->lldd_dev_found)
	177	return 0;
	178
	179	res = i->dft->lldd_dev_found(dev);
	180	if (res) {
b3e3d4c6	181	pr_warn("driver on host %s cannot handle device %016llx, error:%d\n",
15ba7806 JG	182	dev_name(sas_ha->dev),
15ba7806 JG	183	SAS_ADDR(dev->sas_addr), res);
244359c9	184	return res;
2908d778	185	}
303694ee DW	186	set_bit(SAS_DEV_FOUND, &dev->state);
303694ee DW	187	kref_get(&dev->kref);
244359c9	188	return 0;
2908d778 JB	189	}
	190
	191
	192	void sas_notify_lldd_dev_gone(struct domain_device *dev)
	193	{
	194	struct sas_ha_struct *sas_ha = dev->port->ha;
1136a022	195	struct Scsi_Host *shost = sas_ha->shost;
2908d778 JB	196	struct sas_internal *i = to_sas_internal(shost->transportt);
2908d778 JB	197
303694ee DW	198	if (!i->dft->lldd_dev_gone)
	199	return;
	200
	201	if (test_and_clear_bit(SAS_DEV_FOUND, &dev->state)) {
2908d778	202	i->dft->lldd_dev_gone(dev);
735f7d2f DW	203	sas_put_device(dev);
735f7d2f DW	204	}
2908d778 JB	205	}
2908d778 JB	206
0558f33c	207	static void sas_probe_devices(struct asd_sas_port *port)
92625f9b DW	208	{
92625f9b DW	209	struct domain_device dev, n;
92625f9b	210
9508a66f DW	211	/* devices must be domain members before link recovery and probe */
9508a66f DW	212	list_for_each_entry(dev, &port->disco_list, disco_list_node) {
92625f9b DW	213	spin_lock_irq(&port->dev_list_lock);
	214	list_add_tail(&dev->dev_list_node, &port->dev_list);
	215	spin_unlock_irq(&port->dev_list_lock);
9508a66f	216	}
92625f9b	217
9508a66f	218	sas_probe_sata(port);
92625f9b	219
9508a66f DW	220	list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) {
	221	int err;
	222
	223	err = sas_rphy_add(dev->rphy);
	224	if (err)
	225	sas_fail_probe(dev, __func__, err);
	226	else
92625f9b DW	227	list_del_init(&dev->disco_list_node);
	228	}
	229	}
2908d778	230
303694ee DW	231	static void sas_suspend_devices(struct work_struct *work)
	232	{
	233	struct asd_sas_phy *phy;
	234	struct domain_device *dev;
	235	struct sas_discovery_event *ev = to_sas_discovery_event(work);
	236	struct asd_sas_port *port = ev->port;
1136a022	237	struct Scsi_Host *shost = port->ha->shost;
303694ee DW	238	struct sas_internal *si = to_sas_internal(shost->transportt);
	239
	240	clear_bit(DISCE_SUSPEND, &port->disc.pending);
	241
	242	sas_suspend_sata(port);
	243
	244	/* lldd is free to forget the domain_device across the
	245	* suspension, we force the issue here to keep the reference
	246	* counts aligned
	247	*/
	248	list_for_each_entry(dev, &port->dev_list, dev_list_node)
	249	sas_notify_lldd_dev_gone(dev);
	250
	251	/* we are suspending, so we know events are disabled and
	252	* phy_list is not being mutated
	253	*/
	254	list_for_each_entry(phy, &port->phy_list, port_phy_el) {
640208a1	255	if (si->dft->lldd_port_deformed)
303694ee DW	256	si->dft->lldd_port_deformed(phy);
	257	phy->suspended = 1;
	258	port->suspended = 1;
	259	}
	260	}
	261
	262	static void sas_resume_devices(struct work_struct *work)
	263	{
	264	struct sas_discovery_event *ev = to_sas_discovery_event(work);
	265	struct asd_sas_port *port = ev->port;
	266
	267	clear_bit(DISCE_RESUME, &port->disc.pending);
	268
	269	sas_resume_sata(port);
	270	}
	271
2908d778	272	/**
121246ae BVA	273	* sas_discover_end_dev - discover an end device (SSP, etc)
121246ae BVA	274	* @dev: pointer to domain device of interest
2908d778 JB	275	*
	276	* See comment in sas_discover_sata().
	277	*/
1345a7d9	278	static int sas_discover_end_dev(struct domain_device *dev)
2908d778	279	{
3d1a99e2	280	return sas_notify_lldd_dev_found(dev);
2908d778 JB	281	}
	282
	283	/* ---------- Device registration and unregistration ---------- */
	284
735f7d2f DW	285	void sas_free_device(struct kref *kref)
	286	{
	287	struct domain_device dev = container_of(kref, typeof(dev), kref);
	288
9487669f DW	289	put_device(&dev->rphy->dev);
	290	dev->rphy = NULL;
	291
735f7d2f DW	292	if (dev->parent)
	293	sas_put_device(dev->parent);
	294
f41a0c44 DW	295	sas_port_put_phy(dev->phy);
	296	dev->phy = NULL;
	297
735f7d2f	298	/* remove the phys and ports, everything else should be gone */
924a3541	299	if (dev_is_expander(dev->dev_type))
735f7d2f DW	300	kfree(dev->ex_dev.ex_phy);
735f7d2f DW	301
8abda4d2	302	if (dev_is_sata(dev) && dev->sata_dev.ap) {
b6240a4d	303	ata_sas_tport_delete(dev->sata_dev.ap);
6c2fe21e	304	kfree(dev->sata_dev.ap);
2fa4a326 JY	305	ata_host_put(dev->sata_dev.ata_host);
2fa4a326 JY	306	dev->sata_dev.ata_host = NULL;
8abda4d2 DW	307	dev->sata_dev.ap = NULL;
	308	}
	309
735f7d2f DW	310	kfree(dev);
	311	}
	312
1a34c064	313	static void sas_unregister_common_dev(struct asd_sas_port port, struct domain_device dev)
2908d778	314	{
5db45bdc DW	315	struct sas_ha_struct *ha = port->ha;
5db45bdc DW	316
2908d778 JB	317	sas_notify_lldd_dev_gone(dev);
	318	if (!dev->parent)
	319	dev->port->port_dev = NULL;
	320	else
	321	list_del_init(&dev->siblings);
1a34c064 DW	322
1a34c064 DW	323	spin_lock_irq(&port->dev_list_lock);
2908d778	324	list_del_init(&dev->dev_list_node);
e4a9c373 DW	325	if (dev_is_sata(dev))
e4a9c373 DW	326	sas_ata_end_eh(dev->sata_dev.ap);
1a34c064	327	spin_unlock_irq(&port->dev_list_lock);
735f7d2f	328
5db45bdc	329	spin_lock_irq(&ha->lock);
aa9f8328	330	if (dev->dev_type == SAS_END_DEVICE &&
5db45bdc DW	331	!list_empty(&dev->ssp_dev.eh_list_node)) {
	332	list_del_init(&dev->ssp_dev.eh_list_node);
	333	ha->eh_active--;
	334	}
	335	spin_unlock_irq(&ha->lock);
	336
735f7d2f	337	sas_put_device(dev);
2908d778 JB	338	}
2908d778 JB	339
0558f33c	340	void sas_destruct_devices(struct asd_sas_port *port)
2908d778	341	{
87c8331f	342	struct domain_device dev, n;
87c8331f DW	343
	344	list_for_each_entry_safe(dev, n, &port->destroy_list, disco_list_node) {
	345	list_del_init(&dev->disco_list_node);
	346
2908d778 JB	347	sas_remove_children(&dev->rphy->dev);
2908d778 JB	348	sas_rphy_delete(dev->rphy);
87c8331f	349	sas_unregister_common_dev(port, dev);
87c8331f DW	350	}
	351	}
	352
0558f33c JY	353	static void sas_destruct_ports(struct asd_sas_port *port)
	354	{
	355	struct sas_port sas_port, p;
	356
	357	list_for_each_entry_safe(sas_port, p, &port->sas_port_del_list, del_list) {
	358	list_del_init(&sas_port->del_list);
	359	sas_port_delete(sas_port);
	360	}
	361	}
	362
0e4b1791 JY	363	static bool sas_abort_cmd(struct request req, void data)
	364	{
	365	struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(req);
	366	struct domain_device *dev = data;
	367
	368	if (dev == cmd_to_domain_dev(cmd))
	369	blk_abort_request(req);
	370	return true;
	371	}
	372
	373	static void sas_abort_device_scsi_cmds(struct domain_device *dev)
	374	{
	375	struct sas_ha_struct *sas_ha = dev->port->ha;
1136a022	376	struct Scsi_Host *shost = sas_ha->shost;
0e4b1791 JY	377
	378	if (dev_is_expander(dev->dev_type))
	379	return;
	380
	381	/*
	382	* For removed device with active IOs, the user space applications have
	383	* to spend very long time waiting for the timeout. This is not
	384	* necessary because a removed device will not return the IOs.
	385	* Abort the inflight IOs here so that EH can be quickly kicked in.
	386	*/
	387	blk_mq_tagset_busy_iter(&shost->tag_set, sas_abort_cmd, dev);
	388	}
	389
87c8331f DW	390	void sas_unregister_dev(struct asd_sas_port port, struct domain_device dev)
	391	{
	392	if (!test_bit(SAS_DEV_DESTROY, &dev->state) &&
	393	!list_empty(&dev->disco_list_node)) {
	394	/* this rphy never saw sas_rphy_add */
	395	list_del_init(&dev->disco_list_node);
	396	sas_rphy_free(dev->rphy);
87c8331f	397	sas_unregister_common_dev(port, dev);
9487669f	398	return;
87c8331f DW	399	}
87c8331f DW	400
9487669f	401	if (!test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) {
0e4b1791 JY	402	if (test_bit(SAS_DEV_GONE, &dev->state))
0e4b1791 JY	403	sas_abort_device_scsi_cmds(dev);
87c8331f DW	404	sas_rphy_unlink(dev->rphy);
87c8331f DW	405	list_move_tail(&dev->disco_list_node, &port->destroy_list);
2908d778	406	}
2908d778 JB	407	}
2908d778 JB	408
7d05919a	409	void sas_unregister_domain_devices(struct asd_sas_port *port, int gone)
2908d778 JB	410	{
	411	struct domain_device dev, n;
	412
7d05919a DW	413	list_for_each_entry_safe_reverse(dev, n, &port->dev_list, dev_list_node) {
	414	if (gone)
	415	set_bit(SAS_DEV_GONE, &dev->state);
1a34c064	416	sas_unregister_dev(port, dev);
7d05919a DW	417	}
7d05919a DW	418
87c8331f DW	419	list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node)
87c8331f DW	420	sas_unregister_dev(port, dev);
2908d778 JB	421
	422	port->port->rphy = NULL;
	423
	424	}
	425
f41a0c44 DW	426	void sas_device_set_phy(struct domain_device dev, struct sas_port port)
	427	{
	428	struct sas_ha_struct *ha;
	429	struct sas_phy *new_phy;
	430
	431	if (!dev)
	432	return;
	433
	434	ha = dev->port->ha;
	435	new_phy = sas_port_get_phy(port);
	436
	437	/* pin and record last seen phy */
	438	spin_lock_irq(&ha->phy_port_lock);
	439	if (new_phy) {
	440	sas_port_put_phy(dev->phy);
	441	dev->phy = new_phy;
	442	}
	443	spin_unlock_irq(&ha->phy_port_lock);
	444	}
	445
2908d778 JB	446	/* ---------- Discovery and Revalidation ---------- */
	447
	448	/**
121246ae BVA	449	* sas_discover_domain - discover the domain
121246ae BVA	450	* @work: work structure embedded in port domain device.
2908d778 JB	451	*
	452	* NOTE: this process _must_ quit (return) as soon as any connection
	453	* errors are encountered. Connection recovery is done elsewhere.
	454	* Discover process only interrogates devices in order to discover the
	455	* domain.
	456	*/
c4028958	457	static void sas_discover_domain(struct work_struct *work)
2908d778	458	{
6f63caae	459	struct domain_device *dev;
2908d778	460	int error = 0;
22b9153f	461	struct sas_discovery_event *ev = to_sas_discovery_event(work);
c4028958	462	struct asd_sas_port *port = ev->port;
2908d778	463
b15ebe0b	464	clear_bit(DISCE_DISCOVER_DOMAIN, &port->disc.pending);
2908d778 JB	465
2908d778 JB	466	if (port->port_dev)
6f63caae DW	467	return;
	468
	469	error = sas_get_port_device(port);
	470	if (error)
	471	return;
	472	dev = port->port_dev;
2908d778	473
15ba7806 JG	474	pr_debug("DOING DISCOVERY on port %d, pid:%d\n", port->id,
15ba7806 JG	475	task_pid_nr(current));
2908d778	476
6f63caae	477	switch (dev->dev_type) {
aa9f8328	478	case SAS_END_DEVICE:
6f63caae	479	error = sas_discover_end_dev(dev);
2908d778	480	break;
aa9f8328 JB	481	case SAS_EDGE_EXPANDER_DEVICE:
aa9f8328 JB	482	case SAS_FANOUT_EXPANDER_DEVICE:
6f63caae	483	error = sas_discover_root_expander(dev);
2908d778	484	break;
aa9f8328 JB	485	case SAS_SATA_DEV:
aa9f8328 JB	486	case SAS_SATA_PM:
6f63caae	487	error = sas_discover_sata(dev);
2908d778 JB	488	break;
2908d778 JB	489	default:
b9142174	490	error = -ENXIO;
15ba7806	491	pr_err("unhandled device %d\n", dev->dev_type);
2908d778 JB	492	break;
	493	}
	494
	495	if (error) {
6f63caae	496	sas_rphy_free(dev->rphy);
87c8331f	497	list_del_init(&dev->disco_list_node);
9d720d82	498	spin_lock_irq(&port->dev_list_lock);
6f63caae	499	list_del_init(&dev->dev_list_node);
9d720d82	500	spin_unlock_irq(&port->dev_list_lock);
88808398	501
735f7d2f	502	sas_put_device(dev);
2908d778 JB	503	port->port_dev = NULL;
	504	}
	505
0558f33c JY	506	sas_probe_devices(port);
0558f33c JY	507
15ba7806 JG	508	pr_debug("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id,
15ba7806 JG	509	task_pid_nr(current), error);
2908d778 JB	510	}
2908d778 JB	511
c4028958	512	static void sas_revalidate_domain(struct work_struct *work)
2908d778 JB	513	{
2908d778 JB	514	int res = 0;
22b9153f	515	struct sas_discovery_event *ev = to_sas_discovery_event(work);
c4028958	516	struct asd_sas_port *port = ev->port;
87c8331f	517	struct sas_ha_struct *ha = port->ha;
6302ce4d	518	struct domain_device *ddev = port->port_dev;
87c8331f DW	519
	520	/* prevent revalidation from finding sata links in recovery */
	521	mutex_lock(&ha->disco_mutex);
	522	if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) {
15ba7806 JG	523	pr_debug("REVALIDATION DEFERRED on port %d, pid:%d\n",
15ba7806 JG	524	port->id, task_pid_nr(current));
87c8331f DW	525	goto out;
87c8331f DW	526	}
2908d778	527
b15ebe0b	528	clear_bit(DISCE_REVALIDATE_DOMAIN, &port->disc.pending);
2908d778	529
15ba7806 JG	530	pr_debug("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id,
15ba7806 JG	531	task_pid_nr(current));
87c8331f	532
924a3541	533	if (ddev && dev_is_expander(ddev->dev_type))
6302ce4d	534	res = sas_ex_revalidate_domain(ddev);
2908d778	535
15ba7806 JG	536	pr_debug("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n",
15ba7806 JG	537	port->id, task_pid_nr(current), res);
87c8331f DW	538	out:
87c8331f DW	539	mutex_unlock(&ha->disco_mutex);
0558f33c JY	540
	541	sas_destruct_devices(port);
	542	sas_destruct_ports(port);
	543	sas_probe_devices(port);
2908d778 JB	544	}
	545
	546	/* ---------- Events ---------- */
	547
22b9153f	548	static void sas_chain_work(struct sas_ha_struct ha, struct sas_work sw)
b1124cd3	549	{
22b9153f DW	550	/* chained work is not subject to SA_HA_DRAINING or
	551	* SAS_HA_REGISTERED, because it is either submitted in the
	552	* workqueue, or known to be submitted from a context that is
	553	* not racing against draining
	554	*/
93bdbd06	555	queue_work(ha->disco_q, &sw->work);
b1124cd3 DW	556	}
	557
	558	static void sas_chain_event(int event, unsigned long *pending,
22b9153f	559	struct sas_work *sw,
b1124cd3 DW	560	struct sas_ha_struct *ha)
	561	{
	562	if (!test_and_set_bit(event, pending)) {
	563	unsigned long flags;
	564
e4a9c373	565	spin_lock_irqsave(&ha->lock, flags);
22b9153f	566	sas_chain_work(ha, sw);
e4a9c373	567	spin_unlock_irqrestore(&ha->lock, flags);
b1124cd3 DW	568	}
	569	}
	570
26d4a969	571	void sas_discover_event(struct asd_sas_port *port, enum discover_event ev)
2908d778 JB	572	{
	573	struct sas_discovery *disc;
	574
	575	if (!port)
26d4a969	576	return;
2908d778 JB	577	disc = &port->disc;
	578
	579	BUG_ON(ev >= DISC_NUM_EVENTS);
	580
b1124cd3	581	sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha);
2908d778 JB	582	}
	583
	584	/**
121246ae BVA	585	* sas_init_disc - initialize the discovery struct in the port
121246ae BVA	586	* @disc: port discovery structure
2908d778 JB	587	* @port: pointer to struct port
	588	*
	589	* Called when the ports are being initialized.
	590	*/
	591	void sas_init_disc(struct sas_discovery disc, struct asd_sas_port port)
	592	{
	593	int i;
	594
c4028958	595	static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = {
2908d778 JB	596	[DISCE_DISCOVER_DOMAIN] = sas_discover_domain,
2908d778 JB	597	[DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain,
303694ee DW	598	[DISCE_SUSPEND] = sas_suspend_devices,
303694ee DW	599	[DISCE_RESUME] = sas_resume_devices,
2908d778 JB	600	};
2908d778 JB	601
2908d778	602	disc->pending = 0;
c4028958	603	for (i = 0; i < DISC_NUM_EVENTS; i++) {
22b9153f	604	INIT_SAS_WORK(&disc->disc_work[i].work, sas_event_fns[i]);
c4028958 DH	605	disc->disc_work[i].port = port;
c4028958 DH	606	}
2908d778	607	}