Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e6b2d76a authored by Moore, Eric's avatar Moore, Eric Committed by James Bottomley
Browse files

[SCSI] fusion - expander hotplug suport in mptsas module 



This adds support for hot adding and removing
expanders, and its associated attached devices.
When there is a change in topology,
the fusion firmware sends the
MPI_EVENT_SAS_DISCOVERY event to the driver.
The driver will read firmware config pages
to determine what changes took place, and refresh
drivers view of the world stored in ioc->sas_topology.

Here is the details of the action the driver does:

(1) Expander Added :  The mptsas_discovery_work
workqueue is called.  Config pages read, and
ioc->sas_topology is refreshed.  The sas_phy_add()
is called for each phy of the expander.  The
expanders attached devices are added via
sas_rphy_add().  Added end devices are handled within
the MPT_ADD_DEVICE logic in  mptsas_hotplug_work
workqueue.

(2) Expander Delete : The sas_rphy_delete() will be
called for the top most compenent of the parent that the
expander is attached to.  The sas_rphy_delete call
will delete all the children phys, rphys, and end devices.
This is handled from mptsas_discovery_work workqueue.

Signed-off-by: default avatarEric Moore <Eric.Moore@lsil.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@SteelEye.com>
parent f44e5461

drivers/message/fusion/mptbase.h

+4 −0
Original line number Diff line number Diff line
@@ -619,6 +619,10 @@ typedef struct _MPT_ADAPTER 
	struct net_device	*netdev;

	struct list_head	 sas_topology;

	struct mutex		 sas_topology_mutex;

	struct mutex		 sas_discovery_mutex;

	u8			 sas_discovery_runtime;

	u8			 sas_discovery_ignore_events;

	int			 sas_index; /* index refrencing */

	MPT_SAS_MGMT		 sas_mgmt;

	int			 num_ports;

	struct work_struct	 mptscsih_persistTask;

drivers/message/fusion/mptsas.c

+285 −69
Original line number Diff line number Diff line
@@ -108,6 +108,11 @@ struct mptsas_hotplug_event { 
	u8			phys_disk_num_valid;

};



struct mptsas_discovery_event {

	struct work_struct	work;

	MPT_ADAPTER		*ioc;

};



/*

 * SAS topology structures

 *
@@ -163,7 +168,6 @@ struct mptsas_enclosure { 
	u8	sep_channel;		/* SEP channel logical channel id */

};





#ifdef SASDEBUG

static void mptsas_print_phy_data(MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)

{
@@ -273,6 +277,27 @@ static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy) 
	return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;

}



/*

 * mptsas_find_portinfo_by_handle

 *

 * This function should be called with the sas_topology_mutex already held

 */

static struct mptsas_portinfo *

mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)

{

	struct mptsas_portinfo *port_info, *rc=NULL;

	int i;



	list_for_each_entry(port_info, &ioc->sas_topology, list)

		for (i = 0; i < port_info->num_phys; i++)

			if (port_info->phy_info[i].identify.handle == handle) {

				rc = port_info;

				goto out;

			}

 out:

	return rc;

}



static int

mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,

		u32 form, u32 form_specific)
@@ -423,32 +448,8 @@ mptsas_slave_destroy(struct scsi_device *sdev) 
{

	struct Scsi_Host *host = sdev->host;

	MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;

	struct sas_rphy *rphy;

	struct mptsas_portinfo *p;

	int i;

	VirtDevice *vdev;



	/*

	 * Handle hotplug removal case.

	 * We need to clear out attached data structure.

	 */

	rphy = dev_to_rphy(sdev->sdev_target->dev.parent);



	mutex_lock(&hd->ioc->sas_topology_mutex);

	list_for_each_entry(p, &hd->ioc->sas_topology, list) {

		for (i = 0; i < p->num_phys; i++) {

			if (p->phy_info[i].attached.sas_address ==

					rphy->identify.sas_address) {

				memset(&p->phy_info[i].attached, 0,

				    sizeof(struct mptsas_devinfo));

				p->phy_info[i].rphy = NULL;

				goto out;

			}

		}

	}



 out:

	mutex_unlock(&hd->ioc->sas_topology_mutex);

	/*

	 * Issue target reset to flush firmware outstanding commands.

	 */
@@ -1044,7 +1045,6 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 
	phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);

	phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);





 out_free_consistent:

	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,

			    buffer, dma_handle);
@@ -1134,12 +1134,19 @@ mptsas_parse_device_info(struct sas_identify *identify, 
static int mptsas_probe_one_phy(struct device *dev,

		struct mptsas_phyinfo *phy_info, int index, int local)

{

	MPT_ADAPTER *ioc;

	struct sas_phy *phy;

	int error;



	if (!dev)

		return -ENODEV;



	if (!phy_info->phy) {

		phy = sas_phy_alloc(dev, index);

		if (!phy)

			return -ENOMEM;

	} else

		phy = phy_info->phy;



	phy->port_identifier = phy_info->port_id;

	mptsas_parse_device_info(&phy->identify, &phy_info->identify);
@@ -1225,6 +1232,8 @@ static int mptsas_probe_one_phy(struct device *dev, 
		break;

	}



	if (!phy_info->phy) {



		if (local)

			phy->local_attached = 1;
@@ -1234,10 +1243,24 @@ static int mptsas_probe_one_phy(struct device *dev, 
			return error;

		}

		phy_info->phy = phy;

	}



	if ((phy_info->attached.handle) &&

	    (!phy_info->rphy)) {



	if (phy_info->attached.handle) {

		struct sas_rphy *rphy;



		ioc = phy_to_ioc(phy_info->phy);



		/*

		 * Let the hotplug_work thread handle processing

		 * the adding/removing of devices that occur

		 * after start of day.

		 */

		if (ioc->sas_discovery_runtime &&

			mptsas_is_end_device(&phy_info->attached))

			return 0;



		rphy = sas_rphy_alloc(phy);

		if (!rphy)

			return 0; /* non-fatal: an rphy can be added later */
@@ -1256,24 +1279,37 @@ static int mptsas_probe_one_phy(struct device *dev, 
}



static int

mptsas_probe_hba_phys(MPT_ADAPTER *ioc, int *index)

mptsas_probe_hba_phys(MPT_ADAPTER *ioc)

{

	struct mptsas_portinfo *port_info;

	struct mptsas_portinfo *port_info, *hba;

	u32 handle = 0xFFFF;

	int error = -ENOMEM, i;



	port_info = kzalloc(sizeof(*port_info), GFP_KERNEL);

	if (!port_info)

	hba = kzalloc(sizeof(*port_info), GFP_KERNEL);

	if (! hba)

		goto out;



	error = mptsas_sas_io_unit_pg0(ioc, port_info);

	error = mptsas_sas_io_unit_pg0(ioc, hba);

	if (error)

		goto out_free_port_info;



	ioc->num_ports = port_info->num_phys;

	mutex_lock(&ioc->sas_topology_mutex);

	port_info = mptsas_find_portinfo_by_handle(ioc, hba->handle);

	if (!port_info) {

		port_info = hba;

		list_add_tail(&port_info->list, &ioc->sas_topology);

	} else {

		port_info->handle = hba->handle;

		for (i = 0; i < hba->num_phys; i++)

			port_info->phy_info[i].negotiated_link_rate =

				hba->phy_info[i].negotiated_link_rate;

		if (hba->phy_info)

			kfree(hba->phy_info);

		kfree(hba);

		hba = NULL;

	}

	mutex_unlock(&ioc->sas_topology_mutex);

	ioc->num_ports = port_info->num_phys;



	for (i = 0; i < port_info->num_phys; i++) {

		mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
@@ -1296,38 +1332,49 @@ mptsas_probe_hba_phys(MPT_ADAPTER *ioc, int *index) 
		}



		mptsas_probe_one_phy(&ioc->sh->shost_gendev,

				     &port_info->phy_info[i], *index, 1);

		(*index)++;

		    &port_info->phy_info[i], ioc->sas_index, 1);

		ioc->sas_index++;

	}



	return 0;



 out_free_port_info:

	kfree(port_info);

	if (hba)

		kfree(hba);

 out:

	return error;

}



static int

mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)

mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)

{

	struct mptsas_portinfo *port_info, *p;

	struct mptsas_portinfo *port_info, *p, *ex;

	int error = -ENOMEM, i, j;



	port_info = kzalloc(sizeof(*port_info), GFP_KERNEL);

	if (!port_info)

	ex = kzalloc(sizeof(*port_info), GFP_KERNEL);

	if (!ex)

		goto out;



	error = mptsas_sas_expander_pg0(ioc, port_info,

	error = mptsas_sas_expander_pg0(ioc, ex,

		(MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<

		 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);

	if (error)

		goto out_free_port_info;



	*handle = port_info->handle;

	*handle = ex->handle;



	mutex_lock(&ioc->sas_topology_mutex);

	port_info = mptsas_find_portinfo_by_handle(ioc, *handle);

	if (!port_info) {

		port_info = ex;

		list_add_tail(&port_info->list, &ioc->sas_topology);

	} else {

		port_info->handle = ex->handle;

		if (ex->phy_info)

			kfree(ex->phy_info);

		kfree(ex);

		ex = NULL;

	}

	mutex_unlock(&ioc->sas_topology_mutex);



	for (i = 0; i < port_info->num_phys; i++) {
@@ -1374,28 +1421,101 @@ mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index) 
		mutex_unlock(&ioc->sas_topology_mutex);



		mptsas_probe_one_phy(parent, &port_info->phy_info[i],

				     *index, 0);

		(*index)++;

		    ioc->sas_index, 0);

		ioc->sas_index++;

	}



	return 0;



 out_free_port_info:

	kfree(port_info->phy_info);

	kfree(port_info);

	if (ex) {

		if (ex->phy_info)

			kfree(ex->phy_info);

		kfree(ex);

	}

 out:

	return error;

}



/*

 * mptsas_delete_expander_phys

 *

 *

 * This will traverse topology, and remove expanders

 * that are no longer present

 */

static void

mptsas_delete_expander_phys(MPT_ADAPTER *ioc)

{

	struct mptsas_portinfo buffer;

	struct mptsas_portinfo *port_info, *n, *parent;

	int i;



	mutex_lock(&ioc->sas_topology_mutex);

	list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {



		if (port_info->phy_info &&

		    (!(port_info->phy_info[0].identify.device_info &

		    MPI_SAS_DEVICE_INFO_SMP_TARGET)))

			continue;



		if (mptsas_sas_expander_pg0(ioc, &buffer,

		     (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<

		     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), port_info->handle)) {



			/*

			 * Obtain the port_info instance to the parent port

			 */

			parent = mptsas_find_portinfo_by_handle(ioc,

			    port_info->phy_info[0].identify.handle_parent);



			if (!parent)

				goto next_port;



			/*

			 * Delete rphys in the parent that point

			 * to this expander.  The transport layer will

			 * cleanup all the children.

			 */

			for (i = 0; i < parent->num_phys; i++) {

				if ((!parent->phy_info[i].rphy) ||

				    (parent->phy_info[i].attached.sas_address !=

				   port_info->phy_info[i].identify.sas_address))

					continue;

				sas_rphy_delete(parent->phy_info[i].rphy);

				memset(&parent->phy_info[i].attached, 0,

				    sizeof(struct mptsas_devinfo));

				parent->phy_info[i].rphy = NULL;

				parent->phy_info[i].starget = NULL;

			}

 next_port:

			list_del(&port_info->list);

			if (port_info->phy_info)

				kfree(port_info->phy_info);

			kfree(port_info);

		}

		/*

		* Free this memory allocated from inside

		* mptsas_sas_expander_pg0

		*/

		if (buffer.phy_info)

			kfree(buffer.phy_info);

	}

	mutex_unlock(&ioc->sas_topology_mutex);

}



/*

 * Start of day discovery

 */

static void

mptsas_scan_sas_topology(MPT_ADAPTER *ioc)

{

	u32 handle = 0xFFFF;

	int index = 0;

	int i;



	mptsas_probe_hba_phys(ioc, &index);

	while (!mptsas_probe_expander_phys(ioc, &handle, &index))

	mutex_lock(&ioc->sas_discovery_mutex);

	mptsas_probe_hba_phys(ioc);

	while (!mptsas_probe_expander_phys(ioc, &handle))

		;

	/*

	  Reporting RAID volumes.
@@ -1409,7 +1529,29 @@ mptsas_scan_sas_topology(MPT_ADAPTER *ioc) 
		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);

	}

 out:

	return;

	mutex_unlock(&ioc->sas_discovery_mutex);

}



/*

 * Work queue thread to handle Runtime discovery

 * Mere purpose is the hot add/delete of expanders

 */

static void

mptscsih_discovery_work(void * arg)

{

	struct mptsas_discovery_event *ev = arg;

	MPT_ADAPTER *ioc = ev->ioc;

	u32 handle = 0xFFFF;



	mutex_lock(&ioc->sas_discovery_mutex);

	ioc->sas_discovery_runtime=1;

	mptsas_delete_expander_phys(ioc);

	mptsas_probe_hba_phys(ioc);

	while (!mptsas_probe_expander_phys(ioc, &handle))

		;

	kfree(ev);

	ioc->sas_discovery_runtime=0;

	mutex_unlock(&ioc->sas_discovery_mutex);

}



static struct mptsas_phyinfo *
@@ -1427,10 +1569,8 @@ mptsas_find_phyinfo_by_parent(MPT_ADAPTER *ioc, u16 parent_handle, u8 phy_id) 
		(MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<

		 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),

		parent_handle);

	if (error) {

		printk("mptsas: failed to retrieve device page\n");

	if (error)

		return NULL;

	}



	/*

	 * The phy_info structures are never deallocated during lifetime of
@@ -1502,6 +1642,10 @@ mptsas_reprobe_target(struct scsi_target *starget, int uld_attach) 
			mptsas_reprobe_lun);

}





/*

 * Work queue thread to handle SAS hotplug events

 */

static void

mptsas_hotplug_work(void *arg)

{
@@ -1514,10 +1658,13 @@ mptsas_hotplug_work(void *arg) 
	struct mptsas_devinfo sas_device;

	VirtTarget *vtarget;



	mutex_lock(&ioc->sas_discovery_mutex);



	switch (ev->event_type) {

	case MPTSAS_DEL_DEVICE:



		phy_info = mptsas_find_phyinfo_by_target(ioc, ev->id);



		/*

		 * Sanity checks, for non-existing phys and remote rphys.

		 */
@@ -1567,10 +1714,38 @@ mptsas_hotplug_work(void *arg) 
		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT), ev->id))

			break;



		phy_info = mptsas_find_phyinfo_by_parent(ioc,

				sas_device.handle_parent, sas_device.phy_id);



		if (!phy_info) {

			u32 handle = 0xFFFF;



			/*

			* Its possible when an expander has been hot added

			* containing attached devices, the sas firmware

			* may send a RC_ADDED event prior to the

			* DISCOVERY STOP event. If that occurs, our

			* view of the topology in the driver in respect to this

			* expander might of not been setup, and we hit this

			* condition.

			* Therefore, this code kicks off discovery to

			* refresh the data.

			* Then again, we check whether the parent phy has

			* been created.

			*/

			ioc->sas_discovery_runtime=1;

			mptsas_delete_expander_phys(ioc);

			mptsas_probe_hba_phys(ioc);

			while (!mptsas_probe_expander_phys(ioc, &handle))

				;

			ioc->sas_discovery_runtime=0;



			phy_info = mptsas_find_phyinfo_by_parent(ioc,

				sas_device.handle_parent, sas_device.phy_id);

			if (!phy_info)

				break;

		}



		if (phy_info->starget) {

			vtarget = phy_info->starget->hostdata;
@@ -1604,7 +1779,6 @@ mptsas_hotplug_work(void *arg) 
		       "attaching %s device, channel %d, id %d, phy %d\n",

		       ioc->name, ds, ev->channel, ev->id, ev->phy_id);





		rphy = sas_rphy_alloc(phy_info->phy);

		if (!rphy)

			break; /* non-fatal: an rphy can be added later */
@@ -1654,6 +1828,7 @@ mptsas_hotplug_work(void *arg) 
	}



	kfree(ev);

	mutex_unlock(&ioc->sas_discovery_mutex);

}



static void
@@ -1767,6 +1942,32 @@ mptscsih_send_raid_event(MPT_ADAPTER *ioc, 
	schedule_work(&ev->work);

}



static void

mptscsih_send_discovery(MPT_ADAPTER *ioc,

	EVENT_DATA_SAS_DISCOVERY *discovery_data)

{

	struct mptsas_discovery_event *ev;



	/*

	 * DiscoveryStatus

	 *

	 * This flag will be non-zero when firmware

	 * kicks off discovery, and return to zero

	 * once its completed.

	 */

	if (discovery_data->DiscoveryStatus)

		return;



	ev = kmalloc(sizeof(*ev), GFP_ATOMIC);

	if (!ev)

		return;

	memset(ev,0,sizeof(struct mptsas_discovery_event));

	INIT_WORK(&ev->work, mptscsih_discovery_work, ev);

	ev->ioc = ioc;

	schedule_work(&ev->work);

};





static int

mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)

{
@@ -1776,6 +1977,17 @@ mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply) 
	if (!ioc->sh)

		goto out;



	/*

	 * sas_discovery_ignore_events

	 *

	 * This flag is to prevent anymore processing of

	 * sas events once mptsas_remove function is called.

	 */

	if (ioc->sas_discovery_ignore_events) {

		rc = mptscsih_event_process(ioc, reply);

		goto out;

	}



	switch (event) {

	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:

		mptscsih_send_sas_event(ioc,
@@ -1792,6 +2004,9 @@ mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply) 
		schedule_work(&ioc->mptscsih_persistTask);

		break;

	 case MPI_EVENT_SAS_DISCOVERY:

		mptscsih_send_discovery(ioc,

			(EVENT_DATA_SAS_DISCOVERY *)reply->Data);

		break;

	default:

		rc = mptscsih_event_process(ioc, reply);

		break;
@@ -1893,7 +2108,7 @@ mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) 


	INIT_LIST_HEAD(&ioc->sas_topology);

	mutex_init(&ioc->sas_topology_mutex);



	mutex_init(&ioc->sas_discovery_mutex);

	mutex_init(&ioc->sas_mgmt.mutex);

	init_completion(&ioc->sas_mgmt.done);
@@ -2019,6 +2234,7 @@ static void __devexit mptsas_remove(struct pci_dev *pdev) 
	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);

	struct mptsas_portinfo *p, *n;



	ioc->sas_discovery_ignore_events=1;

	sas_remove_host(ioc->sh);



	mutex_lock(&ioc->sas_topology_mutex);