xref: /openbmc/linux/drivers/message/fusion/mptsas.c (revision 95a24cf1)
1 /*
2  *  linux/drivers/message/fusion/mptsas.c
3  *      For use with LSI PCI chip/adapter(s)
4  *      running LSI Fusion MPT (Message Passing Technology) firmware.
5  *
6  *  Copyright (c) 1999-2008 LSI Corporation
7  *  (mailto:DL-MPTFusionLinux@lsi.com)
8  */
9 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10 /*
11     This program is free software; you can redistribute it and/or modify
12     it under the terms of the GNU General Public License as published by
13     the Free Software Foundation; version 2 of the License.
14 
15     This program is distributed in the hope that it will be useful,
16     but WITHOUT ANY WARRANTY; without even the implied warranty of
17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18     GNU General Public License for more details.
19 
20     NO WARRANTY
21     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
22     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
23     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
24     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
25     solely responsible for determining the appropriateness of using and
26     distributing the Program and assumes all risks associated with its
27     exercise of rights under this Agreement, including but not limited to
28     the risks and costs of program errors, damage to or loss of data,
29     programs or equipment, and unavailability or interruption of operations.
30 
31     DISCLAIMER OF LIABILITY
32     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
33     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
35     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
36     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
37     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
38     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
39 
40     You should have received a copy of the GNU General Public License
41     along with this program; if not, write to the Free Software
42     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
43 */
44 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
45 
46 #include <linux/module.h>
47 #include <linux/kernel.h>
48 #include <linux/slab.h>
49 #include <linux/init.h>
50 #include <linux/errno.h>
51 #include <linux/jiffies.h>
52 #include <linux/workqueue.h>
53 #include <linux/delay.h>	/* for mdelay */
54 
55 #include <scsi/scsi.h>
56 #include <scsi/scsi_cmnd.h>
57 #include <scsi/scsi_device.h>
58 #include <scsi/scsi_host.h>
59 #include <scsi/scsi_transport_sas.h>
60 #include <scsi/scsi_transport.h>
61 #include <scsi/scsi_dbg.h>
62 
63 #include "mptbase.h"
64 #include "mptscsih.h"
65 #include "mptsas.h"
66 
67 
68 #define my_NAME		"Fusion MPT SAS Host driver"
69 #define my_VERSION	MPT_LINUX_VERSION_COMMON
70 #define MYNAM		"mptsas"
71 
72 /*
73  * Reserved channel for integrated raid
74  */
75 #define MPTSAS_RAID_CHANNEL	1
76 
77 #define SAS_CONFIG_PAGE_TIMEOUT		30
78 MODULE_AUTHOR(MODULEAUTHOR);
79 MODULE_DESCRIPTION(my_NAME);
80 MODULE_LICENSE("GPL");
81 MODULE_VERSION(my_VERSION);
82 
83 static int mpt_pt_clear;
84 module_param(mpt_pt_clear, int, 0);
85 MODULE_PARM_DESC(mpt_pt_clear,
86 		" Clear persistency table: enable=1  "
87 		"(default=MPTSCSIH_PT_CLEAR=0)");
88 
89 /* scsi-mid layer global parameter is max_report_luns, which is 511 */
90 #define MPTSAS_MAX_LUN (16895)
91 static int max_lun = MPTSAS_MAX_LUN;
92 module_param(max_lun, int, 0);
93 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
94 
95 static int mpt_loadtime_max_sectors = 8192;
96 module_param(mpt_loadtime_max_sectors, int, 0);
97 MODULE_PARM_DESC(mpt_loadtime_max_sectors,
98 		" Maximum sector define for Host Bus Adaptor.Range 64 to 8192 default=8192");
99 
100 static u8	mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
101 static u8	mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
102 static u8	mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
103 static u8	mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
104 static u8	mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS;
105 
106 static void mptsas_firmware_event_work(struct work_struct *work);
107 static void mptsas_send_sas_event(struct fw_event_work *fw_event);
108 static void mptsas_send_raid_event(struct fw_event_work *fw_event);
109 static void mptsas_send_ir2_event(struct fw_event_work *fw_event);
110 static void mptsas_parse_device_info(struct sas_identify *identify,
111 		struct mptsas_devinfo *device_info);
112 static inline void mptsas_set_rphy(MPT_ADAPTER *ioc,
113 		struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy);
114 static struct mptsas_phyinfo	*mptsas_find_phyinfo_by_sas_address
115 		(MPT_ADAPTER *ioc, u64 sas_address);
116 static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
117 	struct mptsas_devinfo *device_info, u32 form, u32 form_specific);
118 static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc,
119 	struct mptsas_enclosure *enclosure, u32 form, u32 form_specific);
120 static int mptsas_add_end_device(MPT_ADAPTER *ioc,
121 	struct mptsas_phyinfo *phy_info);
122 static void mptsas_del_end_device(MPT_ADAPTER *ioc,
123 	struct mptsas_phyinfo *phy_info);
124 static void mptsas_send_link_status_event(struct fw_event_work *fw_event);
125 static struct mptsas_portinfo	*mptsas_find_portinfo_by_sas_address
126 		(MPT_ADAPTER *ioc, u64 sas_address);
127 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
128 		struct mptsas_portinfo *port_info, u8 force);
129 static void mptsas_send_expander_event(struct fw_event_work *fw_event);
130 static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
131 static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
132 static void mptsas_broadcast_primitive_work(struct fw_event_work *fw_event);
133 static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event);
134 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id);
135 void	mptsas_schedule_target_reset(void *ioc);
136 
mptsas_print_phy_data(MPT_ADAPTER * ioc,MPI_SAS_IO_UNIT0_PHY_DATA * phy_data)137 static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
138 					MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
139 {
140 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
141 	    "---- IO UNIT PAGE 0 ------------\n", ioc->name));
142 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
143 	    ioc->name, le16_to_cpu(phy_data->AttachedDeviceHandle)));
144 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Controller Handle=0x%X\n",
145 	    ioc->name, le16_to_cpu(phy_data->ControllerDevHandle)));
146 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port=0x%X\n",
147 	    ioc->name, phy_data->Port));
148 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port Flags=0x%X\n",
149 	    ioc->name, phy_data->PortFlags));
150 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Flags=0x%X\n",
151 	    ioc->name, phy_data->PhyFlags));
152 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
153 	    ioc->name, phy_data->NegotiatedLinkRate));
154 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
155 	    "Controller PHY Device Info=0x%X\n", ioc->name,
156 	    le32_to_cpu(phy_data->ControllerPhyDeviceInfo)));
157 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DiscoveryStatus=0x%X\n\n",
158 	    ioc->name, le32_to_cpu(phy_data->DiscoveryStatus)));
159 }
160 
mptsas_print_phy_pg0(MPT_ADAPTER * ioc,SasPhyPage0_t * pg0)161 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0)
162 {
163 	__le64 sas_address;
164 
165 	memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
166 
167 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
168 	    "---- SAS PHY PAGE 0 ------------\n", ioc->name));
169 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
170 	    "Attached Device Handle=0x%X\n", ioc->name,
171 	    le16_to_cpu(pg0->AttachedDevHandle)));
172 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
173 	    ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
174 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
175 	    "Attached PHY Identifier=0x%X\n", ioc->name,
176 	    pg0->AttachedPhyIdentifier));
177 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Attached Device Info=0x%X\n",
178 	    ioc->name, le32_to_cpu(pg0->AttachedDeviceInfo)));
179 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
180 	    ioc->name,  pg0->ProgrammedLinkRate));
181 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Change Count=0x%X\n",
182 	    ioc->name, pg0->ChangeCount));
183 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Info=0x%X\n\n",
184 	    ioc->name, le32_to_cpu(pg0->PhyInfo)));
185 }
186 
mptsas_print_phy_pg1(MPT_ADAPTER * ioc,SasPhyPage1_t * pg1)187 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1)
188 {
189 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
190 	    "---- SAS PHY PAGE 1 ------------\n", ioc->name));
191 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Invalid Dword Count=0x%x\n",
192 	    ioc->name,  pg1->InvalidDwordCount));
193 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
194 	    "Running Disparity Error Count=0x%x\n", ioc->name,
195 	    pg1->RunningDisparityErrorCount));
196 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
197 	    "Loss Dword Synch Count=0x%x\n", ioc->name,
198 	    pg1->LossDwordSynchCount));
199 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
200 	    "PHY Reset Problem Count=0x%x\n\n", ioc->name,
201 	    pg1->PhyResetProblemCount));
202 }
203 
mptsas_print_device_pg0(MPT_ADAPTER * ioc,SasDevicePage0_t * pg0)204 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0)
205 {
206 	__le64 sas_address;
207 
208 	memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
209 
210 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
211 	    "---- SAS DEVICE PAGE 0 ---------\n", ioc->name));
212 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
213 	    ioc->name, le16_to_cpu(pg0->DevHandle)));
214 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Handle=0x%X\n",
215 	    ioc->name, le16_to_cpu(pg0->ParentDevHandle)));
216 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Enclosure Handle=0x%X\n",
217 	    ioc->name, le16_to_cpu(pg0->EnclosureHandle)));
218 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Slot=0x%X\n",
219 	    ioc->name, le16_to_cpu(pg0->Slot)));
220 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
221 	    ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
222 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Target ID=0x%X\n",
223 	    ioc->name, pg0->TargetID));
224 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Bus=0x%X\n",
225 	    ioc->name, pg0->Bus));
226 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Phy Num=0x%X\n",
227 	    ioc->name, pg0->PhyNum));
228 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Access Status=0x%X\n",
229 	    ioc->name, le16_to_cpu(pg0->AccessStatus)));
230 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Device Info=0x%X\n",
231 	    ioc->name, le32_to_cpu(pg0->DeviceInfo)));
232 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Flags=0x%X\n",
233 	    ioc->name, le16_to_cpu(pg0->Flags)));
234 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n\n",
235 	    ioc->name, pg0->PhysicalPort));
236 }
237 
mptsas_print_expander_pg1(MPT_ADAPTER * ioc,SasExpanderPage1_t * pg1)238 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1)
239 {
240 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
241 	    "---- SAS EXPANDER PAGE 1 ------------\n", ioc->name));
242 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n",
243 	    ioc->name, pg1->PhysicalPort));
244 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Identifier=0x%X\n",
245 	    ioc->name, pg1->PhyIdentifier));
246 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
247 	    ioc->name, pg1->NegotiatedLinkRate));
248 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
249 	    ioc->name, pg1->ProgrammedLinkRate));
250 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hardware Link Rate=0x%X\n",
251 	    ioc->name, pg1->HwLinkRate));
252 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Owner Device Handle=0x%X\n",
253 	    ioc->name, le16_to_cpu(pg1->OwnerDevHandle)));
254 	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
255 	    "Attached Device Handle=0x%X\n\n", ioc->name,
256 	    le16_to_cpu(pg1->AttachedDevHandle)));
257 }
258 
259 /* inhibit sas firmware event handling */
260 static void
mptsas_fw_event_off(MPT_ADAPTER * ioc)261 mptsas_fw_event_off(MPT_ADAPTER *ioc)
262 {
263 	unsigned long flags;
264 
265 	spin_lock_irqsave(&ioc->fw_event_lock, flags);
266 	ioc->fw_events_off = 1;
267 	ioc->sas_discovery_quiesce_io = 0;
268 	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
269 
270 }
271 
272 /* enable sas firmware event handling */
273 static void
mptsas_fw_event_on(MPT_ADAPTER * ioc)274 mptsas_fw_event_on(MPT_ADAPTER *ioc)
275 {
276 	unsigned long flags;
277 
278 	spin_lock_irqsave(&ioc->fw_event_lock, flags);
279 	ioc->fw_events_off = 0;
280 	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
281 }
282 
283 /* queue a sas firmware event */
284 static void
mptsas_add_fw_event(MPT_ADAPTER * ioc,struct fw_event_work * fw_event,unsigned long delay)285 mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
286     unsigned long delay)
287 {
288 	unsigned long flags;
289 
290 	spin_lock_irqsave(&ioc->fw_event_lock, flags);
291 	list_add_tail(&fw_event->list, &ioc->fw_event_list);
292 	fw_event->users = 1;
293 	INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work);
294 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: add (fw_event=0x%p)"
295 		"on cpuid %d\n", ioc->name, __func__,
296 		fw_event, smp_processor_id()));
297 	queue_delayed_work_on(smp_processor_id(), ioc->fw_event_q,
298 	    &fw_event->work, delay);
299 	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
300 }
301 
302 /* requeue a sas firmware event */
303 static void
mptsas_requeue_fw_event(MPT_ADAPTER * ioc,struct fw_event_work * fw_event,unsigned long delay)304 mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
305     unsigned long delay)
306 {
307 	unsigned long flags;
308 	spin_lock_irqsave(&ioc->fw_event_lock, flags);
309 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: reschedule task "
310 	    "(fw_event=0x%p)on cpuid %d\n", ioc->name, __func__,
311 		fw_event, smp_processor_id()));
312 	fw_event->retries++;
313 	queue_delayed_work_on(smp_processor_id(), ioc->fw_event_q,
314 	    &fw_event->work, msecs_to_jiffies(delay));
315 	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
316 }
317 
__mptsas_free_fw_event(MPT_ADAPTER * ioc,struct fw_event_work * fw_event)318 static void __mptsas_free_fw_event(MPT_ADAPTER *ioc,
319 				   struct fw_event_work *fw_event)
320 {
321 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: kfree (fw_event=0x%p)\n",
322 	    ioc->name, __func__, fw_event));
323 	list_del(&fw_event->list);
324 	kfree(fw_event);
325 }
326 
327 /* free memory associated to a sas firmware event */
328 static void
mptsas_free_fw_event(MPT_ADAPTER * ioc,struct fw_event_work * fw_event)329 mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event)
330 {
331 	unsigned long flags;
332 
333 	spin_lock_irqsave(&ioc->fw_event_lock, flags);
334 	fw_event->users--;
335 	if (!fw_event->users)
336 		__mptsas_free_fw_event(ioc, fw_event);
337 	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
338 }
339 
340 /* walk the firmware event queue, and either stop or wait for
341  * outstanding events to complete */
342 static void
mptsas_cleanup_fw_event_q(MPT_ADAPTER * ioc)343 mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc)
344 {
345 	struct fw_event_work *fw_event;
346 	struct mptsas_target_reset_event *target_reset_list, *n;
347 	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
348 	unsigned long flags;
349 
350 	/* flush the target_reset_list */
351 	if (!list_empty(&hd->target_reset_list)) {
352 		list_for_each_entry_safe(target_reset_list, n,
353 		    &hd->target_reset_list, list) {
354 			dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
355 			    "%s: removing target reset for id=%d\n",
356 			    ioc->name, __func__,
357 			   target_reset_list->sas_event_data.TargetID));
358 			list_del(&target_reset_list->list);
359 			kfree(target_reset_list);
360 		}
361 	}
362 
363 	if (list_empty(&ioc->fw_event_list) || !ioc->fw_event_q)
364 		return;
365 
366 	spin_lock_irqsave(&ioc->fw_event_lock, flags);
367 
368 	while (!list_empty(&ioc->fw_event_list)) {
369 		bool canceled = false;
370 
371 		fw_event = list_first_entry(&ioc->fw_event_list,
372 					    struct fw_event_work, list);
373 		fw_event->users++;
374 		spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
375 		if (cancel_delayed_work_sync(&fw_event->work))
376 			canceled = true;
377 
378 		spin_lock_irqsave(&ioc->fw_event_lock, flags);
379 		if (canceled)
380 			fw_event->users--;
381 		fw_event->users--;
382 		WARN_ON_ONCE(fw_event->users);
383 		__mptsas_free_fw_event(ioc, fw_event);
384 	}
385 	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
386 }
387 
388 
phy_to_ioc(struct sas_phy * phy)389 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
390 {
391 	struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
392 	return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
393 }
394 
rphy_to_ioc(struct sas_rphy * rphy)395 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
396 {
397 	struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
398 	return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
399 }
400 
401 /*
402  * mptsas_find_portinfo_by_handle
403  *
404  * This function should be called with the sas_topology_mutex already held
405  */
406 static struct mptsas_portinfo *
mptsas_find_portinfo_by_handle(MPT_ADAPTER * ioc,u16 handle)407 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
408 {
409 	struct mptsas_portinfo *port_info, *rc=NULL;
410 	int i;
411 
412 	list_for_each_entry(port_info, &ioc->sas_topology, list)
413 		for (i = 0; i < port_info->num_phys; i++)
414 			if (port_info->phy_info[i].identify.handle == handle) {
415 				rc = port_info;
416 				goto out;
417 			}
418  out:
419 	return rc;
420 }
421 
422 /**
423  *	mptsas_find_portinfo_by_sas_address - find and return portinfo for
424  *		this sas_address
425  *	@ioc: Pointer to MPT_ADAPTER structure
426  *	@sas_address: expander sas address
427  *
428  *	This function should be called with the sas_topology_mutex already held.
429  *
430  *	Return: %NULL if not found.
431  **/
432 static struct mptsas_portinfo *
mptsas_find_portinfo_by_sas_address(MPT_ADAPTER * ioc,u64 sas_address)433 mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
434 {
435 	struct mptsas_portinfo *port_info, *rc = NULL;
436 	int i;
437 
438 	if (sas_address >= ioc->hba_port_sas_addr &&
439 	    sas_address < (ioc->hba_port_sas_addr +
440 	    ioc->hba_port_num_phy))
441 		return ioc->hba_port_info;
442 
443 	mutex_lock(&ioc->sas_topology_mutex);
444 	list_for_each_entry(port_info, &ioc->sas_topology, list)
445 		for (i = 0; i < port_info->num_phys; i++)
446 			if (port_info->phy_info[i].identify.sas_address ==
447 			    sas_address) {
448 				rc = port_info;
449 				goto out;
450 			}
451  out:
452 	mutex_unlock(&ioc->sas_topology_mutex);
453 	return rc;
454 }
455 
456 /*
457  * Returns true if there is a scsi end device
458  */
459 static inline int
mptsas_is_end_device(struct mptsas_devinfo * attached)460 mptsas_is_end_device(struct mptsas_devinfo * attached)
461 {
462 	if ((attached->sas_address) &&
463 	    (attached->device_info &
464 	    MPI_SAS_DEVICE_INFO_END_DEVICE) &&
465 	    ((attached->device_info &
466 	    MPI_SAS_DEVICE_INFO_SSP_TARGET) |
467 	    (attached->device_info &
468 	    MPI_SAS_DEVICE_INFO_STP_TARGET) |
469 	    (attached->device_info &
470 	    MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
471 		return 1;
472 	else
473 		return 0;
474 }
475 
476 /* no mutex */
477 static void
mptsas_port_delete(MPT_ADAPTER * ioc,struct mptsas_portinfo_details * port_details)478 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
479 {
480 	struct mptsas_portinfo *port_info;
481 	struct mptsas_phyinfo *phy_info;
482 	u8	i;
483 
484 	if (!port_details)
485 		return;
486 
487 	port_info = port_details->port_info;
488 	phy_info = port_info->phy_info;
489 
490 	dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
491 	    "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
492 	    port_details->num_phys, (unsigned long long)
493 	    port_details->phy_bitmask));
494 
495 	for (i = 0; i < port_info->num_phys; i++, phy_info++) {
496 		if(phy_info->port_details != port_details)
497 			continue;
498 		memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
499 		mptsas_set_rphy(ioc, phy_info, NULL);
500 		phy_info->port_details = NULL;
501 	}
502 	kfree(port_details);
503 }
504 
505 static inline struct sas_rphy *
mptsas_get_rphy(struct mptsas_phyinfo * phy_info)506 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
507 {
508 	if (phy_info->port_details)
509 		return phy_info->port_details->rphy;
510 	else
511 		return NULL;
512 }
513 
514 static inline void
mptsas_set_rphy(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info,struct sas_rphy * rphy)515 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
516 {
517 	if (phy_info->port_details) {
518 		phy_info->port_details->rphy = rphy;
519 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
520 		    ioc->name, rphy));
521 	}
522 
523 	if (rphy) {
524 		dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
525 		    &rphy->dev, MYIOC_s_FMT "add:", ioc->name));
526 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rphy=%p release=%p\n",
527 		    ioc->name, rphy, rphy->dev.release));
528 	}
529 }
530 
531 static inline struct sas_port *
mptsas_get_port(struct mptsas_phyinfo * phy_info)532 mptsas_get_port(struct mptsas_phyinfo *phy_info)
533 {
534 	if (phy_info->port_details)
535 		return phy_info->port_details->port;
536 	else
537 		return NULL;
538 }
539 
540 static inline void
mptsas_set_port(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info,struct sas_port * port)541 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
542 {
543 	if (phy_info->port_details)
544 		phy_info->port_details->port = port;
545 
546 	if (port) {
547 		dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
548 		    &port->dev, MYIOC_s_FMT "add:", ioc->name));
549 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "port=%p release=%p\n",
550 		    ioc->name, port, port->dev.release));
551 	}
552 }
553 
554 static inline struct scsi_target *
mptsas_get_starget(struct mptsas_phyinfo * phy_info)555 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
556 {
557 	if (phy_info->port_details)
558 		return phy_info->port_details->starget;
559 	else
560 		return NULL;
561 }
562 
563 static inline void
mptsas_set_starget(struct mptsas_phyinfo * phy_info,struct scsi_target * starget)564 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
565 starget)
566 {
567 	if (phy_info->port_details)
568 		phy_info->port_details->starget = starget;
569 }
570 
571 /**
572  *	mptsas_add_device_component - adds a new device component to our lists
573  *	@ioc: Pointer to MPT_ADAPTER structure
574  *	@channel: channel number
575  *	@id: Logical Target ID for reset (if appropriate)
576  *	@sas_address: expander sas address
577  *	@device_info: specific bits (flags) for devices
578  *	@slot: enclosure slot ID
579  *	@enclosure_logical_id: enclosure WWN
580  *
581  **/
582 static void
mptsas_add_device_component(MPT_ADAPTER * ioc,u8 channel,u8 id,u64 sas_address,u32 device_info,u16 slot,u64 enclosure_logical_id)583 mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id,
584 	u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id)
585 {
586 	struct mptsas_device_info	*sas_info, *next;
587 	struct scsi_device	*sdev;
588 	struct scsi_target	*starget;
589 	struct sas_rphy	*rphy;
590 
591 	/*
592 	 * Delete all matching devices out of the list
593 	 */
594 	mutex_lock(&ioc->sas_device_info_mutex);
595 	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
596 	    list) {
597 		if (!sas_info->is_logical_volume &&
598 		    (sas_info->sas_address == sas_address ||
599 		    (sas_info->fw.channel == channel &&
600 		     sas_info->fw.id == id))) {
601 			list_del(&sas_info->list);
602 			kfree(sas_info);
603 		}
604 	}
605 
606 	sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
607 	if (!sas_info)
608 		goto out;
609 
610 	/*
611 	 * Set Firmware mapping
612 	 */
613 	sas_info->fw.id = id;
614 	sas_info->fw.channel = channel;
615 
616 	sas_info->sas_address = sas_address;
617 	sas_info->device_info = device_info;
618 	sas_info->slot = slot;
619 	sas_info->enclosure_logical_id = enclosure_logical_id;
620 	INIT_LIST_HEAD(&sas_info->list);
621 	list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
622 
623 	/*
624 	 * Set OS mapping
625 	 */
626 	shost_for_each_device(sdev, ioc->sh) {
627 		starget = scsi_target(sdev);
628 		rphy = dev_to_rphy(starget->dev.parent);
629 		if (rphy->identify.sas_address == sas_address) {
630 			sas_info->os.id = starget->id;
631 			sas_info->os.channel = starget->channel;
632 		}
633 	}
634 
635  out:
636 	mutex_unlock(&ioc->sas_device_info_mutex);
637 	return;
638 }
639 
640 /**
641  *	mptsas_add_device_component_by_fw - adds a new device component by FW ID
642  *	@ioc: Pointer to MPT_ADAPTER structure
643  *	@channel: channel number
644  *	@id: Logical Target ID
645  *
646  **/
647 static void
mptsas_add_device_component_by_fw(MPT_ADAPTER * ioc,u8 channel,u8 id)648 mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
649 {
650 	struct mptsas_devinfo sas_device;
651 	struct mptsas_enclosure enclosure_info;
652 	int rc;
653 
654 	rc = mptsas_sas_device_pg0(ioc, &sas_device,
655 	    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
656 	     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
657 	    (channel << 8) + id);
658 	if (rc)
659 		return;
660 
661 	memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
662 	mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
663 	    (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
664 	     MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
665 	     sas_device.handle_enclosure);
666 
667 	mptsas_add_device_component(ioc, sas_device.channel,
668 	    sas_device.id, sas_device.sas_address, sas_device.device_info,
669 	    sas_device.slot, enclosure_info.enclosure_logical_id);
670 }
671 
672 /**
673  *	mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding each individual device to list
674  *	@ioc: Pointer to MPT_ADAPTER structure
675  *	@starget: SCSI target for this SCSI device
676  *
677  **/
678 static void
mptsas_add_device_component_starget_ir(MPT_ADAPTER * ioc,struct scsi_target * starget)679 mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc,
680 		struct scsi_target *starget)
681 {
682 	CONFIGPARMS			cfg;
683 	ConfigPageHeader_t		hdr;
684 	dma_addr_t			dma_handle;
685 	pRaidVolumePage0_t		buffer = NULL;
686 	int				i;
687 	RaidPhysDiskPage0_t 		phys_disk;
688 	struct mptsas_device_info	*sas_info, *next;
689 
690 	memset(&cfg, 0 , sizeof(CONFIGPARMS));
691 	memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
692 	hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
693 	/* assumption that all volumes on channel = 0 */
694 	cfg.pageAddr = starget->id;
695 	cfg.cfghdr.hdr = &hdr;
696 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
697 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
698 
699 	if (mpt_config(ioc, &cfg) != 0)
700 		goto out;
701 
702 	if (!hdr.PageLength)
703 		goto out;
704 
705 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
706 				    &dma_handle, GFP_KERNEL);
707 
708 	if (!buffer)
709 		goto out;
710 
711 	cfg.physAddr = dma_handle;
712 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
713 
714 	if (mpt_config(ioc, &cfg) != 0)
715 		goto out;
716 
717 	if (!buffer->NumPhysDisks)
718 		goto out;
719 
720 	/*
721 	 * Adding entry for hidden components
722 	 */
723 	for (i = 0; i < buffer->NumPhysDisks; i++) {
724 
725 		if (mpt_raid_phys_disk_pg0(ioc,
726 		    buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
727 			continue;
728 
729 		mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus,
730 		    phys_disk.PhysDiskID);
731 
732 		mutex_lock(&ioc->sas_device_info_mutex);
733 		list_for_each_entry(sas_info, &ioc->sas_device_info_list,
734 		    list) {
735 			if (!sas_info->is_logical_volume &&
736 			    (sas_info->fw.channel == phys_disk.PhysDiskBus &&
737 			    sas_info->fw.id == phys_disk.PhysDiskID)) {
738 				sas_info->is_hidden_raid_component = 1;
739 				sas_info->volume_id = starget->id;
740 			}
741 		}
742 		mutex_unlock(&ioc->sas_device_info_mutex);
743 
744 	}
745 
746 	/*
747 	 * Delete all matching devices out of the list
748 	 */
749 	mutex_lock(&ioc->sas_device_info_mutex);
750 	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
751 	    list) {
752 		if (sas_info->is_logical_volume && sas_info->fw.id ==
753 		    starget->id) {
754 			list_del(&sas_info->list);
755 			kfree(sas_info);
756 		}
757 	}
758 
759 	sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
760 	if (sas_info) {
761 		sas_info->fw.id = starget->id;
762 		sas_info->os.id = starget->id;
763 		sas_info->os.channel = starget->channel;
764 		sas_info->is_logical_volume = 1;
765 		INIT_LIST_HEAD(&sas_info->list);
766 		list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
767 	}
768 	mutex_unlock(&ioc->sas_device_info_mutex);
769 
770  out:
771 	if (buffer)
772 		dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
773 				  buffer, dma_handle);
774 }
775 
776 /**
777  *	mptsas_add_device_component_starget - adds a SCSI target device component
778  *	@ioc: Pointer to MPT_ADAPTER structure
779  *	@starget: SCSI target for this SCSI device
780  *
781  **/
782 static void
mptsas_add_device_component_starget(MPT_ADAPTER * ioc,struct scsi_target * starget)783 mptsas_add_device_component_starget(MPT_ADAPTER *ioc,
784 	struct scsi_target *starget)
785 {
786 	struct sas_rphy	*rphy;
787 	struct mptsas_phyinfo	*phy_info = NULL;
788 	struct mptsas_enclosure	enclosure_info;
789 
790 	rphy = dev_to_rphy(starget->dev.parent);
791 	phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
792 			rphy->identify.sas_address);
793 	if (!phy_info)
794 		return;
795 
796 	memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
797 	mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
798 		(MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
799 		MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
800 		phy_info->attached.handle_enclosure);
801 
802 	mptsas_add_device_component(ioc, phy_info->attached.channel,
803 		phy_info->attached.id, phy_info->attached.sas_address,
804 		phy_info->attached.device_info,
805 		phy_info->attached.slot, enclosure_info.enclosure_logical_id);
806 }
807 
808 /**
809  *	mptsas_del_device_component_by_os - Once a device has been removed, we mark the entry in the list as being cached
810  *	@ioc: Pointer to MPT_ADAPTER structure
811  *	@channel: os mapped id's
812  *	@id: Logical Target ID
813  *
814  **/
815 static void
mptsas_del_device_component_by_os(MPT_ADAPTER * ioc,u8 channel,u8 id)816 mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
817 {
818 	struct mptsas_device_info	*sas_info, *next;
819 
820 	/*
821 	 * Set is_cached flag
822 	 */
823 	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
824 		list) {
825 		if (sas_info->os.channel == channel && sas_info->os.id == id)
826 			sas_info->is_cached = 1;
827 	}
828 }
829 
830 /**
831  *	mptsas_del_device_components - Cleaning the list
832  *	@ioc: Pointer to MPT_ADAPTER structure
833  *
834  **/
835 static void
mptsas_del_device_components(MPT_ADAPTER * ioc)836 mptsas_del_device_components(MPT_ADAPTER *ioc)
837 {
838 	struct mptsas_device_info	*sas_info, *next;
839 
840 	mutex_lock(&ioc->sas_device_info_mutex);
841 	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
842 		list) {
843 		list_del(&sas_info->list);
844 		kfree(sas_info);
845 	}
846 	mutex_unlock(&ioc->sas_device_info_mutex);
847 }
848 
849 
850 /*
851  * mptsas_setup_wide_ports
852  *
853  * Updates for new and existing narrow/wide port configuration
854  * in the sas_topology
855  */
856 static void
mptsas_setup_wide_ports(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info)857 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
858 {
859 	struct mptsas_portinfo_details * port_details;
860 	struct mptsas_phyinfo *phy_info, *phy_info_cmp;
861 	u64	sas_address;
862 	int	i, j;
863 
864 	mutex_lock(&ioc->sas_topology_mutex);
865 
866 	phy_info = port_info->phy_info;
867 	for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
868 		if (phy_info->attached.handle)
869 			continue;
870 		port_details = phy_info->port_details;
871 		if (!port_details)
872 			continue;
873 		if (port_details->num_phys < 2)
874 			continue;
875 		/*
876 		 * Removing a phy from a port, letting the last
877 		 * phy be removed by firmware events.
878 		 */
879 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
880 		    "%s: [%p]: deleting phy = %d\n",
881 		    ioc->name, __func__, port_details, i));
882 		port_details->num_phys--;
883 		port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
884 		memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
885 		if (phy_info->phy) {
886 			devtprintk(ioc, dev_printk(KERN_DEBUG,
887 				&phy_info->phy->dev, MYIOC_s_FMT
888 				"delete phy %d, phy-obj (0x%p)\n", ioc->name,
889 				phy_info->phy_id, phy_info->phy));
890 			sas_port_delete_phy(port_details->port, phy_info->phy);
891 		}
892 		phy_info->port_details = NULL;
893 	}
894 
895 	/*
896 	 * Populate and refresh the tree
897 	 */
898 	phy_info = port_info->phy_info;
899 	for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
900 		sas_address = phy_info->attached.sas_address;
901 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
902 		    ioc->name, i, (unsigned long long)sas_address));
903 		if (!sas_address)
904 			continue;
905 		port_details = phy_info->port_details;
906 		/*
907 		 * Forming a port
908 		 */
909 		if (!port_details) {
910 			port_details = kzalloc(sizeof(struct
911 				mptsas_portinfo_details), GFP_KERNEL);
912 			if (!port_details)
913 				goto out;
914 			port_details->num_phys = 1;
915 			port_details->port_info = port_info;
916 			if (phy_info->phy_id < 64 )
917 				port_details->phy_bitmask |=
918 				    (1 << phy_info->phy_id);
919 			phy_info->sas_port_add_phy=1;
920 			dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
921 			    "phy_id=%d sas_address=0x%018llX\n",
922 			    ioc->name, i, (unsigned long long)sas_address));
923 			phy_info->port_details = port_details;
924 		}
925 
926 		if (i == port_info->num_phys - 1)
927 			continue;
928 		phy_info_cmp = &port_info->phy_info[i + 1];
929 		for (j = i + 1 ; j < port_info->num_phys ; j++,
930 		    phy_info_cmp++) {
931 			if (!phy_info_cmp->attached.sas_address)
932 				continue;
933 			if (sas_address != phy_info_cmp->attached.sas_address)
934 				continue;
935 			if (phy_info_cmp->port_details == port_details )
936 				continue;
937 			dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
938 			    "\t\tphy_id=%d sas_address=0x%018llX\n",
939 			    ioc->name, j, (unsigned long long)
940 			    phy_info_cmp->attached.sas_address));
941 			if (phy_info_cmp->port_details) {
942 				port_details->rphy =
943 				    mptsas_get_rphy(phy_info_cmp);
944 				port_details->port =
945 				    mptsas_get_port(phy_info_cmp);
946 				port_details->starget =
947 				    mptsas_get_starget(phy_info_cmp);
948 				port_details->num_phys =
949 					phy_info_cmp->port_details->num_phys;
950 				if (!phy_info_cmp->port_details->num_phys)
951 					kfree(phy_info_cmp->port_details);
952 			} else
953 				phy_info_cmp->sas_port_add_phy=1;
954 			/*
955 			 * Adding a phy to a port
956 			 */
957 			phy_info_cmp->port_details = port_details;
958 			if (phy_info_cmp->phy_id < 64 )
959 				port_details->phy_bitmask |=
960 				(1 << phy_info_cmp->phy_id);
961 			port_details->num_phys++;
962 		}
963 	}
964 
965  out:
966 
967 	for (i = 0; i < port_info->num_phys; i++) {
968 		port_details = port_info->phy_info[i].port_details;
969 		if (!port_details)
970 			continue;
971 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
972 		    "%s: [%p]: phy_id=%02d num_phys=%02d "
973 		    "bitmask=0x%016llX\n", ioc->name, __func__,
974 		    port_details, i, port_details->num_phys,
975 		    (unsigned long long)port_details->phy_bitmask));
976 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
977 		    ioc->name, port_details->port, port_details->rphy));
978 	}
979 	dsaswideprintk(ioc, printk("\n"));
980 	mutex_unlock(&ioc->sas_topology_mutex);
981 }
982 
983 /**
984  * mptsas_find_vtarget - find a virtual target device (FC LUN device or
985  *				SCSI target device)
986  *
987  * @ioc: Pointer to MPT_ADAPTER structure
988  * @channel: channel number
989  * @id: Logical Target ID
990  *
991  **/
992 static VirtTarget *
mptsas_find_vtarget(MPT_ADAPTER * ioc,u8 channel,u8 id)993 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
994 {
995 	struct scsi_device 		*sdev;
996 	VirtDevice			*vdevice;
997 	VirtTarget 			*vtarget = NULL;
998 
999 	shost_for_each_device(sdev, ioc->sh) {
1000 		vdevice = sdev->hostdata;
1001 		if ((vdevice == NULL) ||
1002 			(vdevice->vtarget == NULL))
1003 			continue;
1004 		if ((vdevice->vtarget->tflags &
1005 		    MPT_TARGET_FLAGS_RAID_COMPONENT ||
1006 		    vdevice->vtarget->raidVolume))
1007 			continue;
1008 		if (vdevice->vtarget->id == id &&
1009 			vdevice->vtarget->channel == channel)
1010 			vtarget = vdevice->vtarget;
1011 	}
1012 	return vtarget;
1013 }
1014 
1015 static void
mptsas_queue_device_delete(MPT_ADAPTER * ioc,MpiEventDataSasDeviceStatusChange_t * sas_event_data)1016 mptsas_queue_device_delete(MPT_ADAPTER *ioc,
1017 	MpiEventDataSasDeviceStatusChange_t *sas_event_data)
1018 {
1019 	struct fw_event_work *fw_event;
1020 
1021 	fw_event = kzalloc(sizeof(*fw_event) +
1022 			   sizeof(MpiEventDataSasDeviceStatusChange_t),
1023 			   GFP_ATOMIC);
1024 	if (!fw_event) {
1025 		printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1026 		    ioc->name, __func__, __LINE__);
1027 		return;
1028 	}
1029 	memcpy(fw_event->event_data, sas_event_data,
1030 	    sizeof(MpiEventDataSasDeviceStatusChange_t));
1031 	fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
1032 	fw_event->ioc = ioc;
1033 	mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1034 }
1035 
1036 static void
mptsas_queue_rescan(MPT_ADAPTER * ioc)1037 mptsas_queue_rescan(MPT_ADAPTER *ioc)
1038 {
1039 	struct fw_event_work *fw_event;
1040 
1041 	fw_event = kzalloc(sizeof(*fw_event), GFP_ATOMIC);
1042 	if (!fw_event) {
1043 		printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1044 		    ioc->name, __func__, __LINE__);
1045 		return;
1046 	}
1047 	fw_event->event = -1;
1048 	fw_event->ioc = ioc;
1049 	mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1050 }
1051 
1052 
1053 /**
1054  * mptsas_target_reset - Issues TARGET_RESET to end device using
1055  *			 handshaking method
1056  *
1057  * @ioc: Pointer to MPT_ADAPTER structure
1058  * @channel: channel number
1059  * @id: Logical Target ID for reset
1060  *
1061  * Return: (1) success
1062  *         (0) failure
1063  *
1064  **/
1065 static int
mptsas_target_reset(MPT_ADAPTER * ioc,u8 channel,u8 id)1066 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
1067 {
1068 	MPT_FRAME_HDR	*mf;
1069 	SCSITaskMgmt_t	*pScsiTm;
1070 	if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
1071 		return 0;
1072 
1073 
1074 	mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
1075 	if (mf == NULL) {
1076 		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1077 			"%s, no msg frames @%d!!\n", ioc->name,
1078 			__func__, __LINE__));
1079 		goto out_fail;
1080 	}
1081 
1082 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1083 		ioc->name, mf));
1084 
1085 	/* Format the Request
1086 	 */
1087 	pScsiTm = (SCSITaskMgmt_t *) mf;
1088 	memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
1089 	pScsiTm->TargetID = id;
1090 	pScsiTm->Bus = channel;
1091 	pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1092 	pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
1093 	pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
1094 
1095 	DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
1096 
1097 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1098 	   "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
1099 	   ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
1100 
1101 	mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
1102 
1103 	return 1;
1104 
1105  out_fail:
1106 
1107 	mpt_clear_taskmgmt_in_progress_flag(ioc);
1108 	return 0;
1109 }
1110 
1111 static void
mptsas_block_io_sdev(struct scsi_device * sdev,void * data)1112 mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
1113 {
1114 	scsi_device_set_state(sdev, SDEV_BLOCK);
1115 }
1116 
1117 static void
mptsas_block_io_starget(struct scsi_target * starget)1118 mptsas_block_io_starget(struct scsi_target *starget)
1119 {
1120 	if (starget)
1121 		starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
1122 }
1123 
1124 /**
1125  * mptsas_target_reset_queue - queue a target reset
1126  *
1127  * @ioc: Pointer to MPT_ADAPTER structure
1128  * @sas_event_data: SAS Device Status Change Event data
1129  *
1130  * Receive request for TARGET_RESET after receiving a firmware
1131  * event NOT_RESPONDING_EVENT, then put command in link list
1132  * and queue if task_queue already in use.
1133  *
1134  **/
1135 static void
mptsas_target_reset_queue(MPT_ADAPTER * ioc,EVENT_DATA_SAS_DEVICE_STATUS_CHANGE * sas_event_data)1136 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
1137     EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
1138 {
1139 	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
1140 	VirtTarget *vtarget = NULL;
1141 	struct mptsas_target_reset_event *target_reset_list;
1142 	u8		id, channel;
1143 
1144 	id = sas_event_data->TargetID;
1145 	channel = sas_event_data->Bus;
1146 
1147 	vtarget = mptsas_find_vtarget(ioc, channel, id);
1148 	if (vtarget) {
1149 		mptsas_block_io_starget(vtarget->starget);
1150 		vtarget->deleted = 1; /* block IO */
1151 	}
1152 
1153 	target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
1154 	    GFP_ATOMIC);
1155 	if (!target_reset_list) {
1156 		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1157 			"%s, failed to allocate mem @%d..!!\n",
1158 			ioc->name, __func__, __LINE__));
1159 		return;
1160 	}
1161 
1162 	memcpy(&target_reset_list->sas_event_data, sas_event_data,
1163 		sizeof(*sas_event_data));
1164 	list_add_tail(&target_reset_list->list, &hd->target_reset_list);
1165 
1166 	target_reset_list->time_count = jiffies;
1167 
1168 	if (mptsas_target_reset(ioc, channel, id)) {
1169 		target_reset_list->target_reset_issued = 1;
1170 	}
1171 }
1172 
1173 /**
1174  * mptsas_schedule_target_reset- send pending target reset
1175  * @iocp: per adapter object
1176  *
1177  * This function will delete scheduled target reset from the list and
1178  * try to send next target reset. This will be called from completion
1179  * context of any Task management command.
1180  */
1181 
1182 void
mptsas_schedule_target_reset(void * iocp)1183 mptsas_schedule_target_reset(void *iocp)
1184 {
1185 	MPT_ADAPTER *ioc = (MPT_ADAPTER *)(iocp);
1186 	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
1187 	struct list_head *head = &hd->target_reset_list;
1188 	struct mptsas_target_reset_event	*target_reset_list;
1189 	u8		id, channel;
1190 	/*
1191 	 * issue target reset to next device in the queue
1192 	 */
1193 
1194 	if (list_empty(head))
1195 		return;
1196 
1197 	target_reset_list = list_entry(head->next,
1198 		struct mptsas_target_reset_event, list);
1199 
1200 	id = target_reset_list->sas_event_data.TargetID;
1201 	channel = target_reset_list->sas_event_data.Bus;
1202 	target_reset_list->time_count = jiffies;
1203 
1204 	if (mptsas_target_reset(ioc, channel, id))
1205 		target_reset_list->target_reset_issued = 1;
1206 	return;
1207 }
1208 
1209 
1210 /**
1211  *	mptsas_taskmgmt_complete - complete SAS task management function
1212  *	@ioc: Pointer to MPT_ADAPTER structure
1213  *	@mf: MPT message frame
1214  *	@mr: SCSI Task Management Reply structure ptr (may be %NULL)
1215  *
1216  *	Completion for TARGET_RESET after NOT_RESPONDING_EVENT, enable work
1217  *	queue to finish off removing device from upper layers, then send next
1218  *	TARGET_RESET in the queue.
1219  **/
1220 static int
mptsas_taskmgmt_complete(MPT_ADAPTER * ioc,MPT_FRAME_HDR * mf,MPT_FRAME_HDR * mr)1221 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
1222 {
1223 	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
1224         struct list_head *head = &hd->target_reset_list;
1225 	u8		id, channel;
1226 	struct mptsas_target_reset_event	*target_reset_list;
1227 	SCSITaskMgmtReply_t *pScsiTmReply;
1228 
1229 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
1230 	    "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
1231 
1232 	pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
1233 	if (!pScsiTmReply)
1234 		return 0;
1235 
1236 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1237 	    "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
1238 	    "\ttask_type = 0x%02X, iocstatus = 0x%04X "
1239 	    "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
1240 	    "term_cmnds = %d\n", ioc->name,
1241 	    pScsiTmReply->Bus, pScsiTmReply->TargetID,
1242 	    pScsiTmReply->TaskType,
1243 	    le16_to_cpu(pScsiTmReply->IOCStatus),
1244 	    le32_to_cpu(pScsiTmReply->IOCLogInfo),
1245 	    pScsiTmReply->ResponseCode,
1246 	    le32_to_cpu(pScsiTmReply->TerminationCount)));
1247 
1248 	if (pScsiTmReply->ResponseCode)
1249 		mptscsih_taskmgmt_response_code(ioc,
1250 		pScsiTmReply->ResponseCode);
1251 
1252 	if (pScsiTmReply->TaskType ==
1253 	    MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
1254 	     MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET) {
1255 		ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
1256 		ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
1257 		memcpy(ioc->taskmgmt_cmds.reply, mr,
1258 		    min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
1259 		if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
1260 			ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
1261 			complete(&ioc->taskmgmt_cmds.done);
1262 			return 1;
1263 		}
1264 		return 0;
1265 	}
1266 
1267 	mpt_clear_taskmgmt_in_progress_flag(ioc);
1268 
1269 	if (list_empty(head))
1270 		return 1;
1271 
1272 	target_reset_list = list_entry(head->next,
1273 	    struct mptsas_target_reset_event, list);
1274 
1275 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1276 	    "TaskMgmt: completed (%d seconds)\n",
1277 	    ioc->name, jiffies_to_msecs(jiffies -
1278 	    target_reset_list->time_count)/1000));
1279 
1280 	id = pScsiTmReply->TargetID;
1281 	channel = pScsiTmReply->Bus;
1282 	target_reset_list->time_count = jiffies;
1283 
1284 	/*
1285 	 * retry target reset
1286 	 */
1287 	if (!target_reset_list->target_reset_issued) {
1288 		if (mptsas_target_reset(ioc, channel, id))
1289 			target_reset_list->target_reset_issued = 1;
1290 		return 1;
1291 	}
1292 
1293 	/*
1294 	 * enable work queue to remove device from upper layers
1295 	 */
1296 	list_del(&target_reset_list->list);
1297 	if (!ioc->fw_events_off)
1298 		mptsas_queue_device_delete(ioc,
1299 			&target_reset_list->sas_event_data);
1300 
1301 
1302 	ioc->schedule_target_reset(ioc);
1303 
1304 	return 1;
1305 }
1306 
1307 /**
1308  * mptsas_ioc_reset - issue an IOC reset for this reset phase
1309  *
1310  * @ioc: Pointer to MPT_ADAPTER structure
1311  * @reset_phase: id of phase of reset
1312  *
1313  **/
1314 static int
mptsas_ioc_reset(MPT_ADAPTER * ioc,int reset_phase)1315 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1316 {
1317 	MPT_SCSI_HOST	*hd;
1318 	int rc;
1319 
1320 	rc = mptscsih_ioc_reset(ioc, reset_phase);
1321 	if ((ioc->bus_type != SAS) || (!rc))
1322 		return rc;
1323 
1324 	hd = shost_priv(ioc->sh);
1325 	if (!hd->ioc)
1326 		goto out;
1327 
1328 	switch (reset_phase) {
1329 	case MPT_IOC_SETUP_RESET:
1330 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1331 		    "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
1332 		mptsas_fw_event_off(ioc);
1333 		break;
1334 	case MPT_IOC_PRE_RESET:
1335 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1336 		    "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
1337 		break;
1338 	case MPT_IOC_POST_RESET:
1339 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1340 		    "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
1341 		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
1342 			ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
1343 			complete(&ioc->sas_mgmt.done);
1344 		}
1345 		mptsas_cleanup_fw_event_q(ioc);
1346 		mptsas_queue_rescan(ioc);
1347 		break;
1348 	default:
1349 		break;
1350 	}
1351 
1352  out:
1353 	return rc;
1354 }
1355 
1356 
1357 /**
1358  * enum device_state - TUR device state
1359  * @DEVICE_RETRY: need to retry the TUR
1360  * @DEVICE_ERROR: TUR return error, don't add device
1361  * @DEVICE_READY: device can be added
1362  *
1363  */
1364 enum device_state{
1365 	DEVICE_RETRY,
1366 	DEVICE_ERROR,
1367 	DEVICE_READY,
1368 };
1369 
1370 static int
mptsas_sas_enclosure_pg0(MPT_ADAPTER * ioc,struct mptsas_enclosure * enclosure,u32 form,u32 form_specific)1371 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
1372 		u32 form, u32 form_specific)
1373 {
1374 	ConfigExtendedPageHeader_t hdr;
1375 	CONFIGPARMS cfg;
1376 	SasEnclosurePage0_t *buffer;
1377 	dma_addr_t dma_handle;
1378 	int error;
1379 	__le64 le_identifier;
1380 
1381 	memset(&hdr, 0, sizeof(hdr));
1382 	hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
1383 	hdr.PageNumber = 0;
1384 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1385 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
1386 
1387 	cfg.cfghdr.ehdr = &hdr;
1388 	cfg.physAddr = -1;
1389 	cfg.pageAddr = form + form_specific;
1390 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1391 	cfg.dir = 0;	/* read */
1392 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
1393 
1394 	error = mpt_config(ioc, &cfg);
1395 	if (error)
1396 		goto out;
1397 	if (!hdr.ExtPageLength) {
1398 		error = -ENXIO;
1399 		goto out;
1400 	}
1401 
1402 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
1403 				    &dma_handle, GFP_KERNEL);
1404 	if (!buffer) {
1405 		error = -ENOMEM;
1406 		goto out;
1407 	}
1408 
1409 	cfg.physAddr = dma_handle;
1410 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1411 
1412 	error = mpt_config(ioc, &cfg);
1413 	if (error)
1414 		goto out_free_consistent;
1415 
1416 	/* save config data */
1417 	memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
1418 	enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
1419 	enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
1420 	enclosure->flags = le16_to_cpu(buffer->Flags);
1421 	enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
1422 	enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
1423 	enclosure->start_id = buffer->StartTargetID;
1424 	enclosure->start_channel = buffer->StartBus;
1425 	enclosure->sep_id = buffer->SEPTargetID;
1426 	enclosure->sep_channel = buffer->SEPBus;
1427 
1428  out_free_consistent:
1429 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
1430 			  dma_handle);
1431  out:
1432 	return error;
1433 }
1434 
1435 /**
1436  *	mptsas_add_end_device - report a new end device to sas transport layer
1437  *	@ioc: Pointer to MPT_ADAPTER structure
1438  *	@phy_info: describes attached device
1439  *
1440  *	return (0) success (1) failure
1441  *
1442  **/
1443 static int
mptsas_add_end_device(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info)1444 mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1445 {
1446 	struct sas_rphy *rphy;
1447 	struct sas_port *port;
1448 	struct sas_identify identify;
1449 	char *ds = NULL;
1450 	u8 fw_id;
1451 
1452 	if (!phy_info) {
1453 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1454 			"%s: exit at line=%d\n", ioc->name,
1455 			 __func__, __LINE__));
1456 		return 1;
1457 	}
1458 
1459 	fw_id = phy_info->attached.id;
1460 
1461 	if (mptsas_get_rphy(phy_info)) {
1462 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1463 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1464 			 __func__, fw_id, __LINE__));
1465 		return 2;
1466 	}
1467 
1468 	port = mptsas_get_port(phy_info);
1469 	if (!port) {
1470 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1471 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1472 			 __func__, fw_id, __LINE__));
1473 		return 3;
1474 	}
1475 
1476 	if (phy_info->attached.device_info &
1477 	    MPI_SAS_DEVICE_INFO_SSP_TARGET)
1478 		ds = "ssp";
1479 	if (phy_info->attached.device_info &
1480 	    MPI_SAS_DEVICE_INFO_STP_TARGET)
1481 		ds = "stp";
1482 	if (phy_info->attached.device_info &
1483 	    MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1484 		ds = "sata";
1485 
1486 	printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
1487 	    " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
1488 	    phy_info->attached.channel, phy_info->attached.id,
1489 	    phy_info->attached.phy_id, (unsigned long long)
1490 	    phy_info->attached.sas_address);
1491 
1492 	mptsas_parse_device_info(&identify, &phy_info->attached);
1493 	rphy = sas_end_device_alloc(port);
1494 	if (!rphy) {
1495 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1496 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1497 			 __func__, fw_id, __LINE__));
1498 		return 5; /* non-fatal: an rphy can be added later */
1499 	}
1500 
1501 	rphy->identify = identify;
1502 	if (sas_rphy_add(rphy)) {
1503 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1504 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1505 			 __func__, fw_id, __LINE__));
1506 		sas_rphy_free(rphy);
1507 		return 6;
1508 	}
1509 	mptsas_set_rphy(ioc, phy_info, rphy);
1510 	return 0;
1511 }
1512 
1513 /**
1514  *	mptsas_del_end_device - report a deleted end device to sas transport layer
1515  *	@ioc: Pointer to MPT_ADAPTER structure
1516  *	@phy_info: describes attached device
1517  *
1518  **/
1519 static void
mptsas_del_end_device(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info)1520 mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1521 {
1522 	struct sas_rphy *rphy;
1523 	struct sas_port *port;
1524 	struct mptsas_portinfo *port_info;
1525 	struct mptsas_phyinfo *phy_info_parent;
1526 	int i;
1527 	char *ds = NULL;
1528 	u8 fw_id;
1529 	u64 sas_address;
1530 
1531 	if (!phy_info)
1532 		return;
1533 
1534 	fw_id = phy_info->attached.id;
1535 	sas_address = phy_info->attached.sas_address;
1536 
1537 	if (!phy_info->port_details) {
1538 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1539 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1540 			 __func__, fw_id, __LINE__));
1541 		return;
1542 	}
1543 	rphy = mptsas_get_rphy(phy_info);
1544 	if (!rphy) {
1545 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1546 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1547 			 __func__, fw_id, __LINE__));
1548 		return;
1549 	}
1550 
1551 	if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_INITIATOR
1552 		|| phy_info->attached.device_info
1553 			& MPI_SAS_DEVICE_INFO_SMP_INITIATOR
1554 		|| phy_info->attached.device_info
1555 			& MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1556 		ds = "initiator";
1557 	if (phy_info->attached.device_info &
1558 	    MPI_SAS_DEVICE_INFO_SSP_TARGET)
1559 		ds = "ssp";
1560 	if (phy_info->attached.device_info &
1561 	    MPI_SAS_DEVICE_INFO_STP_TARGET)
1562 		ds = "stp";
1563 	if (phy_info->attached.device_info &
1564 	    MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1565 		ds = "sata";
1566 
1567 	dev_printk(KERN_DEBUG, &rphy->dev, MYIOC_s_FMT
1568 	    "removing %s device: fw_channel %d, fw_id %d, phy %d,"
1569 	    "sas_addr 0x%llx\n", ioc->name, ds, phy_info->attached.channel,
1570 	    phy_info->attached.id, phy_info->attached.phy_id,
1571 	    (unsigned long long) sas_address);
1572 
1573 	port = mptsas_get_port(phy_info);
1574 	if (!port) {
1575 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1576 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1577 			 __func__, fw_id, __LINE__));
1578 		return;
1579 	}
1580 	port_info = phy_info->portinfo;
1581 	phy_info_parent = port_info->phy_info;
1582 	for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
1583 		if (!phy_info_parent->phy)
1584 			continue;
1585 		if (phy_info_parent->attached.sas_address !=
1586 		    sas_address)
1587 			continue;
1588 		dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
1589 		    MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
1590 		    ioc->name, phy_info_parent->phy_id,
1591 		    phy_info_parent->phy);
1592 		sas_port_delete_phy(port, phy_info_parent->phy);
1593 	}
1594 
1595 	dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
1596 	    "delete port %d, sas_addr (0x%llx)\n", ioc->name,
1597 	     port->port_identifier, (unsigned long long)sas_address);
1598 	sas_port_delete(port);
1599 	mptsas_set_port(ioc, phy_info, NULL);
1600 	mptsas_port_delete(ioc, phy_info->port_details);
1601 }
1602 
1603 static struct mptsas_phyinfo *
mptsas_refreshing_device_handles(MPT_ADAPTER * ioc,struct mptsas_devinfo * sas_device)1604 mptsas_refreshing_device_handles(MPT_ADAPTER *ioc,
1605 	struct mptsas_devinfo *sas_device)
1606 {
1607 	struct mptsas_phyinfo *phy_info;
1608 	struct mptsas_portinfo *port_info;
1609 	int i;
1610 
1611 	phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
1612 	    sas_device->sas_address);
1613 	if (!phy_info)
1614 		goto out;
1615 	port_info = phy_info->portinfo;
1616 	if (!port_info)
1617 		goto out;
1618 	mutex_lock(&ioc->sas_topology_mutex);
1619 	for (i = 0; i < port_info->num_phys; i++) {
1620 		if (port_info->phy_info[i].attached.sas_address !=
1621 			sas_device->sas_address)
1622 			continue;
1623 		port_info->phy_info[i].attached.channel = sas_device->channel;
1624 		port_info->phy_info[i].attached.id = sas_device->id;
1625 		port_info->phy_info[i].attached.sas_address =
1626 		    sas_device->sas_address;
1627 		port_info->phy_info[i].attached.handle = sas_device->handle;
1628 		port_info->phy_info[i].attached.handle_parent =
1629 		    sas_device->handle_parent;
1630 		port_info->phy_info[i].attached.handle_enclosure =
1631 		    sas_device->handle_enclosure;
1632 	}
1633 	mutex_unlock(&ioc->sas_topology_mutex);
1634  out:
1635 	return phy_info;
1636 }
1637 
1638 /**
1639  * mptsas_firmware_event_work - work thread for processing fw events
1640  * @work: work queue payload containing info describing the event
1641  * Context: user
1642  *
1643  */
1644 static void
mptsas_firmware_event_work(struct work_struct * work)1645 mptsas_firmware_event_work(struct work_struct *work)
1646 {
1647 	struct fw_event_work *fw_event =
1648 		container_of(work, struct fw_event_work, work.work);
1649 	MPT_ADAPTER *ioc = fw_event->ioc;
1650 
1651 	/* special rescan topology handling */
1652 	if (fw_event->event == -1) {
1653 		if (ioc->in_rescan) {
1654 			devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1655 				"%s: rescan ignored as it is in progress\n",
1656 				ioc->name, __func__));
1657 			return;
1658 		}
1659 		devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rescan after "
1660 		    "reset\n", ioc->name, __func__));
1661 		ioc->in_rescan = 1;
1662 		mptsas_not_responding_devices(ioc);
1663 		mptsas_scan_sas_topology(ioc);
1664 		ioc->in_rescan = 0;
1665 		mptsas_free_fw_event(ioc, fw_event);
1666 		mptsas_fw_event_on(ioc);
1667 		return;
1668 	}
1669 
1670 	/* events handling turned off during host reset */
1671 	if (ioc->fw_events_off) {
1672 		mptsas_free_fw_event(ioc, fw_event);
1673 		return;
1674 	}
1675 
1676 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_event=(0x%p), "
1677 	    "event = (0x%02x)\n", ioc->name, __func__, fw_event,
1678 	    (fw_event->event & 0xFF)));
1679 
1680 	switch (fw_event->event) {
1681 	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
1682 		mptsas_send_sas_event(fw_event);
1683 		break;
1684 	case MPI_EVENT_INTEGRATED_RAID:
1685 		mptsas_send_raid_event(fw_event);
1686 		break;
1687 	case MPI_EVENT_IR2:
1688 		mptsas_send_ir2_event(fw_event);
1689 		break;
1690 	case MPI_EVENT_PERSISTENT_TABLE_FULL:
1691 		mptbase_sas_persist_operation(ioc,
1692 		    MPI_SAS_OP_CLEAR_NOT_PRESENT);
1693 		mptsas_free_fw_event(ioc, fw_event);
1694 		break;
1695 	case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
1696 		mptsas_broadcast_primitive_work(fw_event);
1697 		break;
1698 	case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
1699 		mptsas_send_expander_event(fw_event);
1700 		break;
1701 	case MPI_EVENT_SAS_PHY_LINK_STATUS:
1702 		mptsas_send_link_status_event(fw_event);
1703 		break;
1704 	case MPI_EVENT_QUEUE_FULL:
1705 		mptsas_handle_queue_full_event(fw_event);
1706 		break;
1707 	}
1708 }
1709 
1710 
1711 
1712 static int
mptsas_slave_configure(struct scsi_device * sdev)1713 mptsas_slave_configure(struct scsi_device *sdev)
1714 {
1715 	struct Scsi_Host	*host = sdev->host;
1716 	MPT_SCSI_HOST	*hd = shost_priv(host);
1717 	MPT_ADAPTER	*ioc = hd->ioc;
1718 	VirtDevice	*vdevice = sdev->hostdata;
1719 
1720 	if (vdevice->vtarget->deleted) {
1721 		sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
1722 		vdevice->vtarget->deleted = 0;
1723 	}
1724 
1725 	/*
1726 	 * RAID volumes placed beyond the last expected port.
1727 	 * Ignore sending sas mode pages in that case..
1728 	 */
1729 	if (sdev->channel == MPTSAS_RAID_CHANNEL) {
1730 		mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
1731 		goto out;
1732 	}
1733 
1734 	sas_read_port_mode_page(sdev);
1735 
1736 	mptsas_add_device_component_starget(ioc, scsi_target(sdev));
1737 
1738  out:
1739 	return mptscsih_slave_configure(sdev);
1740 }
1741 
1742 static int
mptsas_target_alloc(struct scsi_target * starget)1743 mptsas_target_alloc(struct scsi_target *starget)
1744 {
1745 	struct Scsi_Host *host = dev_to_shost(&starget->dev);
1746 	MPT_SCSI_HOST		*hd = shost_priv(host);
1747 	VirtTarget		*vtarget;
1748 	u8			id, channel;
1749 	struct sas_rphy		*rphy;
1750 	struct mptsas_portinfo	*p;
1751 	int 			 i;
1752 	MPT_ADAPTER		*ioc = hd->ioc;
1753 
1754 	vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
1755 	if (!vtarget)
1756 		return -ENOMEM;
1757 
1758 	vtarget->starget = starget;
1759 	vtarget->ioc_id = ioc->id;
1760 	vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
1761 	id = starget->id;
1762 	channel = 0;
1763 
1764 	/*
1765 	 * RAID volumes placed beyond the last expected port.
1766 	 */
1767 	if (starget->channel == MPTSAS_RAID_CHANNEL) {
1768 		if (!ioc->raid_data.pIocPg2) {
1769 			kfree(vtarget);
1770 			return -ENXIO;
1771 		}
1772 		for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
1773 			if (id == ioc->raid_data.pIocPg2->
1774 					RaidVolume[i].VolumeID) {
1775 				channel = ioc->raid_data.pIocPg2->
1776 					RaidVolume[i].VolumeBus;
1777 			}
1778 		}
1779 		vtarget->raidVolume = 1;
1780 		goto out;
1781 	}
1782 
1783 	rphy = dev_to_rphy(starget->dev.parent);
1784 	mutex_lock(&ioc->sas_topology_mutex);
1785 	list_for_each_entry(p, &ioc->sas_topology, list) {
1786 		for (i = 0; i < p->num_phys; i++) {
1787 			if (p->phy_info[i].attached.sas_address !=
1788 					rphy->identify.sas_address)
1789 				continue;
1790 			id = p->phy_info[i].attached.id;
1791 			channel = p->phy_info[i].attached.channel;
1792 			mptsas_set_starget(&p->phy_info[i], starget);
1793 
1794 			/*
1795 			 * Exposing hidden raid components
1796 			 */
1797 			if (mptscsih_is_phys_disk(ioc, channel, id)) {
1798 				id = mptscsih_raid_id_to_num(ioc,
1799 						channel, id);
1800 				vtarget->tflags |=
1801 				    MPT_TARGET_FLAGS_RAID_COMPONENT;
1802 				p->phy_info[i].attached.phys_disk_num = id;
1803 			}
1804 			mutex_unlock(&ioc->sas_topology_mutex);
1805 			goto out;
1806 		}
1807 	}
1808 	mutex_unlock(&ioc->sas_topology_mutex);
1809 
1810 	kfree(vtarget);
1811 	return -ENXIO;
1812 
1813  out:
1814 	vtarget->id = id;
1815 	vtarget->channel = channel;
1816 	starget->hostdata = vtarget;
1817 	return 0;
1818 }
1819 
1820 static void
mptsas_target_destroy(struct scsi_target * starget)1821 mptsas_target_destroy(struct scsi_target *starget)
1822 {
1823 	struct Scsi_Host *host = dev_to_shost(&starget->dev);
1824 	MPT_SCSI_HOST		*hd = shost_priv(host);
1825 	struct sas_rphy		*rphy;
1826 	struct mptsas_portinfo	*p;
1827 	int 			 i;
1828 	MPT_ADAPTER	*ioc = hd->ioc;
1829 	VirtTarget	*vtarget;
1830 
1831 	if (!starget->hostdata)
1832 		return;
1833 
1834 	vtarget = starget->hostdata;
1835 
1836 	mptsas_del_device_component_by_os(ioc, starget->channel,
1837 	    starget->id);
1838 
1839 
1840 	if (starget->channel == MPTSAS_RAID_CHANNEL)
1841 		goto out;
1842 
1843 	rphy = dev_to_rphy(starget->dev.parent);
1844 	list_for_each_entry(p, &ioc->sas_topology, list) {
1845 		for (i = 0; i < p->num_phys; i++) {
1846 			if (p->phy_info[i].attached.sas_address !=
1847 					rphy->identify.sas_address)
1848 				continue;
1849 
1850 			starget_printk(KERN_INFO, starget, MYIOC_s_FMT
1851 			"delete device: fw_channel %d, fw_id %d, phy %d, "
1852 			"sas_addr 0x%llx\n", ioc->name,
1853 			p->phy_info[i].attached.channel,
1854 			p->phy_info[i].attached.id,
1855 			p->phy_info[i].attached.phy_id, (unsigned long long)
1856 			p->phy_info[i].attached.sas_address);
1857 
1858 			mptsas_set_starget(&p->phy_info[i], NULL);
1859 		}
1860 	}
1861 
1862  out:
1863 	vtarget->starget = NULL;
1864 	kfree(starget->hostdata);
1865 	starget->hostdata = NULL;
1866 }
1867 
1868 
1869 static int
mptsas_slave_alloc(struct scsi_device * sdev)1870 mptsas_slave_alloc(struct scsi_device *sdev)
1871 {
1872 	struct Scsi_Host	*host = sdev->host;
1873 	MPT_SCSI_HOST		*hd = shost_priv(host);
1874 	struct sas_rphy		*rphy;
1875 	struct mptsas_portinfo	*p;
1876 	VirtDevice		*vdevice;
1877 	struct scsi_target 	*starget;
1878 	int 			i;
1879 	MPT_ADAPTER *ioc = hd->ioc;
1880 
1881 	vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
1882 	if (!vdevice) {
1883 		printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
1884 				ioc->name, sizeof(VirtDevice));
1885 		return -ENOMEM;
1886 	}
1887 	starget = scsi_target(sdev);
1888 	vdevice->vtarget = starget->hostdata;
1889 
1890 	if (sdev->channel == MPTSAS_RAID_CHANNEL)
1891 		goto out;
1892 
1893 	rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1894 	mutex_lock(&ioc->sas_topology_mutex);
1895 	list_for_each_entry(p, &ioc->sas_topology, list) {
1896 		for (i = 0; i < p->num_phys; i++) {
1897 			if (p->phy_info[i].attached.sas_address !=
1898 					rphy->identify.sas_address)
1899 				continue;
1900 			vdevice->lun = sdev->lun;
1901 			/*
1902 			 * Exposing hidden raid components
1903 			 */
1904 			if (mptscsih_is_phys_disk(ioc,
1905 			    p->phy_info[i].attached.channel,
1906 			    p->phy_info[i].attached.id))
1907 				sdev->no_uld_attach = 1;
1908 			mutex_unlock(&ioc->sas_topology_mutex);
1909 			goto out;
1910 		}
1911 	}
1912 	mutex_unlock(&ioc->sas_topology_mutex);
1913 
1914 	kfree(vdevice);
1915 	return -ENXIO;
1916 
1917  out:
1918 	vdevice->vtarget->num_luns++;
1919 	sdev->hostdata = vdevice;
1920 	return 0;
1921 }
1922 
1923 static int
mptsas_qcmd(struct Scsi_Host * shost,struct scsi_cmnd * SCpnt)1924 mptsas_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
1925 {
1926 	MPT_SCSI_HOST	*hd;
1927 	MPT_ADAPTER	*ioc;
1928 	VirtDevice	*vdevice = SCpnt->device->hostdata;
1929 
1930 	if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
1931 		SCpnt->result = DID_NO_CONNECT << 16;
1932 		scsi_done(SCpnt);
1933 		return 0;
1934 	}
1935 
1936 	hd = shost_priv(shost);
1937 	ioc = hd->ioc;
1938 
1939 	if (ioc->sas_discovery_quiesce_io)
1940 		return SCSI_MLQUEUE_HOST_BUSY;
1941 
1942 	if (ioc->debug_level & MPT_DEBUG_SCSI)
1943 		scsi_print_command(SCpnt);
1944 
1945 	return mptscsih_qcmd(SCpnt);
1946 }
1947 
1948 /**
1949  *	mptsas_eh_timed_out - resets the scsi_cmnd timeout
1950  *		if the device under question is currently in the
1951  *		device removal delay.
1952  *	@sc: scsi command that the midlayer is about to time out
1953  *
1954  **/
mptsas_eh_timed_out(struct scsi_cmnd * sc)1955 static enum scsi_timeout_action mptsas_eh_timed_out(struct scsi_cmnd *sc)
1956 {
1957 	MPT_SCSI_HOST *hd;
1958 	MPT_ADAPTER   *ioc;
1959 	VirtDevice    *vdevice;
1960 	enum scsi_timeout_action rc = SCSI_EH_NOT_HANDLED;
1961 
1962 	hd = shost_priv(sc->device->host);
1963 	if (hd == NULL) {
1964 		printk(KERN_ERR MYNAM ": %s: Can't locate host! (sc=%p)\n",
1965 		    __func__, sc);
1966 		goto done;
1967 	}
1968 
1969 	ioc = hd->ioc;
1970 	if (ioc->bus_type != SAS) {
1971 		printk(KERN_ERR MYNAM ": %s: Wrong bus type (sc=%p)\n",
1972 		    __func__, sc);
1973 		goto done;
1974 	}
1975 
1976 	/* In case if IOC is in reset from internal context.
1977 	*  Do not execute EEH for the same IOC. SML should to reset timer.
1978 	*/
1979 	if (ioc->ioc_reset_in_progress) {
1980 		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: ioc is in reset,"
1981 		    "SML need to reset the timer (sc=%p)\n",
1982 		    ioc->name, __func__, sc));
1983 		rc = SCSI_EH_RESET_TIMER;
1984 	}
1985 	vdevice = sc->device->hostdata;
1986 	if (vdevice && vdevice->vtarget && (vdevice->vtarget->inDMD
1987 		|| vdevice->vtarget->deleted)) {
1988 		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: target removed "
1989 		    "or in device removal delay (sc=%p)\n",
1990 		    ioc->name, __func__, sc));
1991 		rc = SCSI_EH_RESET_TIMER;
1992 		goto done;
1993 	}
1994 
1995 done:
1996 	return rc;
1997 }
1998 
1999 
2000 static const struct scsi_host_template mptsas_driver_template = {
2001 	.module				= THIS_MODULE,
2002 	.proc_name			= "mptsas",
2003 	.show_info			= mptscsih_show_info,
2004 	.name				= "MPT SAS Host",
2005 	.info				= mptscsih_info,
2006 	.queuecommand			= mptsas_qcmd,
2007 	.target_alloc			= mptsas_target_alloc,
2008 	.slave_alloc			= mptsas_slave_alloc,
2009 	.slave_configure		= mptsas_slave_configure,
2010 	.target_destroy			= mptsas_target_destroy,
2011 	.slave_destroy			= mptscsih_slave_destroy,
2012 	.change_queue_depth 		= mptscsih_change_queue_depth,
2013 	.eh_timed_out			= mptsas_eh_timed_out,
2014 	.eh_abort_handler		= mptscsih_abort,
2015 	.eh_device_reset_handler	= mptscsih_dev_reset,
2016 	.eh_host_reset_handler		= mptscsih_host_reset,
2017 	.bios_param			= mptscsih_bios_param,
2018 	.can_queue			= MPT_SAS_CAN_QUEUE,
2019 	.this_id			= -1,
2020 	.sg_tablesize			= MPT_SCSI_SG_DEPTH,
2021 	.max_sectors			= 8192,
2022 	.cmd_per_lun			= 7,
2023 	.shost_groups			= mptscsih_host_attr_groups,
2024 	.no_write_same			= 1,
2025 };
2026 
mptsas_get_linkerrors(struct sas_phy * phy)2027 static int mptsas_get_linkerrors(struct sas_phy *phy)
2028 {
2029 	MPT_ADAPTER *ioc = phy_to_ioc(phy);
2030 	ConfigExtendedPageHeader_t hdr;
2031 	CONFIGPARMS cfg;
2032 	SasPhyPage1_t *buffer;
2033 	dma_addr_t dma_handle;
2034 	int error;
2035 
2036 	/* FIXME: only have link errors on local phys */
2037 	if (!scsi_is_sas_phy_local(phy))
2038 		return -EINVAL;
2039 
2040 	hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
2041 	hdr.ExtPageLength = 0;
2042 	hdr.PageNumber = 1 /* page number 1*/;
2043 	hdr.Reserved1 = 0;
2044 	hdr.Reserved2 = 0;
2045 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2046 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2047 
2048 	cfg.cfghdr.ehdr = &hdr;
2049 	cfg.physAddr = -1;
2050 	cfg.pageAddr = phy->identify.phy_identifier;
2051 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2052 	cfg.dir = 0;    /* read */
2053 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2054 
2055 	error = mpt_config(ioc, &cfg);
2056 	if (error)
2057 		return error;
2058 	if (!hdr.ExtPageLength)
2059 		return -ENXIO;
2060 
2061 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2062 				    &dma_handle, GFP_KERNEL);
2063 	if (!buffer)
2064 		return -ENOMEM;
2065 
2066 	cfg.physAddr = dma_handle;
2067 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2068 
2069 	error = mpt_config(ioc, &cfg);
2070 	if (error)
2071 		goto out_free_consistent;
2072 
2073 	mptsas_print_phy_pg1(ioc, buffer);
2074 
2075 	phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
2076 	phy->running_disparity_error_count =
2077 		le32_to_cpu(buffer->RunningDisparityErrorCount);
2078 	phy->loss_of_dword_sync_count =
2079 		le32_to_cpu(buffer->LossDwordSynchCount);
2080 	phy->phy_reset_problem_count =
2081 		le32_to_cpu(buffer->PhyResetProblemCount);
2082 
2083  out_free_consistent:
2084 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2085 			  dma_handle);
2086 	return error;
2087 }
2088 
mptsas_mgmt_done(MPT_ADAPTER * ioc,MPT_FRAME_HDR * req,MPT_FRAME_HDR * reply)2089 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2090 		MPT_FRAME_HDR *reply)
2091 {
2092 	ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2093 	if (reply != NULL) {
2094 		ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID;
2095 		memcpy(ioc->sas_mgmt.reply, reply,
2096 		    min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
2097 	}
2098 
2099 	if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
2100 		ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING;
2101 		complete(&ioc->sas_mgmt.done);
2102 		return 1;
2103 	}
2104 	return 0;
2105 }
2106 
mptsas_phy_reset(struct sas_phy * phy,int hard_reset)2107 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
2108 {
2109 	MPT_ADAPTER *ioc = phy_to_ioc(phy);
2110 	SasIoUnitControlRequest_t *req;
2111 	SasIoUnitControlReply_t *reply;
2112 	MPT_FRAME_HDR *mf;
2113 	MPIHeader_t *hdr;
2114 	unsigned long timeleft;
2115 	int error = -ERESTARTSYS;
2116 
2117 	/* FIXME: fusion doesn't allow non-local phy reset */
2118 	if (!scsi_is_sas_phy_local(phy))
2119 		return -EINVAL;
2120 
2121 	/* not implemented for expanders */
2122 	if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
2123 		return -ENXIO;
2124 
2125 	if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
2126 		goto out;
2127 
2128 	mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2129 	if (!mf) {
2130 		error = -ENOMEM;
2131 		goto out_unlock;
2132 	}
2133 
2134 	hdr = (MPIHeader_t *) mf;
2135 	req = (SasIoUnitControlRequest_t *)mf;
2136 	memset(req, 0, sizeof(SasIoUnitControlRequest_t));
2137 	req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
2138 	req->MsgContext = hdr->MsgContext;
2139 	req->Operation = hard_reset ?
2140 		MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
2141 	req->PhyNum = phy->identify.phy_identifier;
2142 
2143 	INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2144 	mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2145 
2146 	timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
2147 			10 * HZ);
2148 	if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2149 		error = -ETIME;
2150 		mpt_free_msg_frame(ioc, mf);
2151 		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2152 			goto out_unlock;
2153 		if (!timeleft)
2154 			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2155 		goto out_unlock;
2156 	}
2157 
2158 	/* a reply frame is expected */
2159 	if ((ioc->sas_mgmt.status &
2160 	    MPT_MGMT_STATUS_RF_VALID) == 0) {
2161 		error = -ENXIO;
2162 		goto out_unlock;
2163 	}
2164 
2165 	/* process the completed Reply Message Frame */
2166 	reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
2167 	if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
2168 		printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
2169 		    ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
2170 		error = -ENXIO;
2171 		goto out_unlock;
2172 	}
2173 
2174 	error = 0;
2175 
2176  out_unlock:
2177 	CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2178 	mutex_unlock(&ioc->sas_mgmt.mutex);
2179  out:
2180 	return error;
2181 }
2182 
2183 static int
mptsas_get_enclosure_identifier(struct sas_rphy * rphy,u64 * identifier)2184 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
2185 {
2186 	MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2187 	int i, error;
2188 	struct mptsas_portinfo *p;
2189 	struct mptsas_enclosure enclosure_info;
2190 	u64 enclosure_handle;
2191 
2192 	mutex_lock(&ioc->sas_topology_mutex);
2193 	list_for_each_entry(p, &ioc->sas_topology, list) {
2194 		for (i = 0; i < p->num_phys; i++) {
2195 			if (p->phy_info[i].attached.sas_address ==
2196 			    rphy->identify.sas_address) {
2197 				enclosure_handle = p->phy_info[i].
2198 					attached.handle_enclosure;
2199 				goto found_info;
2200 			}
2201 		}
2202 	}
2203 	mutex_unlock(&ioc->sas_topology_mutex);
2204 	return -ENXIO;
2205 
2206  found_info:
2207 	mutex_unlock(&ioc->sas_topology_mutex);
2208 	memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
2209 	error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
2210 			(MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
2211 			 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
2212 	if (!error)
2213 		*identifier = enclosure_info.enclosure_logical_id;
2214 	return error;
2215 }
2216 
2217 static int
mptsas_get_bay_identifier(struct sas_rphy * rphy)2218 mptsas_get_bay_identifier(struct sas_rphy *rphy)
2219 {
2220 	MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2221 	struct mptsas_portinfo *p;
2222 	int i, rc;
2223 
2224 	mutex_lock(&ioc->sas_topology_mutex);
2225 	list_for_each_entry(p, &ioc->sas_topology, list) {
2226 		for (i = 0; i < p->num_phys; i++) {
2227 			if (p->phy_info[i].attached.sas_address ==
2228 			    rphy->identify.sas_address) {
2229 				rc = p->phy_info[i].attached.slot;
2230 				goto out;
2231 			}
2232 		}
2233 	}
2234 	rc = -ENXIO;
2235  out:
2236 	mutex_unlock(&ioc->sas_topology_mutex);
2237 	return rc;
2238 }
2239 
mptsas_smp_handler(struct bsg_job * job,struct Scsi_Host * shost,struct sas_rphy * rphy)2240 static void mptsas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
2241 		struct sas_rphy *rphy)
2242 {
2243 	MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
2244 	MPT_FRAME_HDR *mf;
2245 	SmpPassthroughRequest_t *smpreq;
2246 	int flagsLength;
2247 	unsigned long timeleft;
2248 	char *psge;
2249 	u64 sas_address = 0;
2250 	unsigned int reslen = 0;
2251 	int ret = -EINVAL;
2252 
2253 	/* do we need to support multiple segments? */
2254 	if (job->request_payload.sg_cnt > 1 ||
2255 	    job->reply_payload.sg_cnt > 1) {
2256 		printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u, rsp %u\n",
2257 		    ioc->name, __func__, job->request_payload.payload_len,
2258 		    job->reply_payload.payload_len);
2259 		goto out;
2260 	}
2261 
2262 	ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2263 	if (ret)
2264 		goto out;
2265 
2266 	mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2267 	if (!mf) {
2268 		ret = -ENOMEM;
2269 		goto out_unlock;
2270 	}
2271 
2272 	smpreq = (SmpPassthroughRequest_t *)mf;
2273 	memset(smpreq, 0, sizeof(*smpreq));
2274 
2275 	smpreq->RequestDataLength =
2276 		cpu_to_le16(job->request_payload.payload_len - 4);
2277 	smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2278 
2279 	if (rphy)
2280 		sas_address = rphy->identify.sas_address;
2281 	else {
2282 		struct mptsas_portinfo *port_info;
2283 
2284 		mutex_lock(&ioc->sas_topology_mutex);
2285 		port_info = ioc->hba_port_info;
2286 		if (port_info && port_info->phy_info)
2287 			sas_address =
2288 				port_info->phy_info[0].phy->identify.sas_address;
2289 		mutex_unlock(&ioc->sas_topology_mutex);
2290 	}
2291 
2292 	*((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2293 
2294 	psge = (char *)
2295 		(((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2296 
2297 	/* request */
2298 	flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2299 		       MPI_SGE_FLAGS_END_OF_BUFFER |
2300 		       MPI_SGE_FLAGS_DIRECTION)
2301 		       << MPI_SGE_FLAGS_SHIFT;
2302 
2303 	if (!dma_map_sg(&ioc->pcidev->dev, job->request_payload.sg_list,
2304 			1, DMA_BIDIRECTIONAL))
2305 		goto put_mf;
2306 
2307 	flagsLength |= (sg_dma_len(job->request_payload.sg_list) - 4);
2308 	ioc->add_sge(psge, flagsLength,
2309 			sg_dma_address(job->request_payload.sg_list));
2310 	psge += ioc->SGE_size;
2311 
2312 	/* response */
2313 	flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2314 		MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2315 		MPI_SGE_FLAGS_IOC_TO_HOST |
2316 		MPI_SGE_FLAGS_END_OF_BUFFER;
2317 
2318 	flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2319 
2320 	if (!dma_map_sg(&ioc->pcidev->dev, job->reply_payload.sg_list,
2321 			1, DMA_BIDIRECTIONAL))
2322 		goto unmap_out;
2323 	flagsLength |= sg_dma_len(job->reply_payload.sg_list) + 4;
2324 	ioc->add_sge(psge, flagsLength,
2325 			sg_dma_address(job->reply_payload.sg_list));
2326 
2327 	INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2328 	mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2329 
2330 	timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2331 	if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2332 		ret = -ETIME;
2333 		mpt_free_msg_frame(ioc, mf);
2334 		mf = NULL;
2335 		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2336 			goto unmap_in;
2337 		if (!timeleft)
2338 			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2339 		goto unmap_in;
2340 	}
2341 	mf = NULL;
2342 
2343 	if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2344 		SmpPassthroughReply_t *smprep;
2345 
2346 		smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2347 		memcpy(job->reply, smprep, sizeof(*smprep));
2348 		job->reply_len = sizeof(*smprep);
2349 		reslen = smprep->ResponseDataLength;
2350 	} else {
2351 		printk(MYIOC_s_ERR_FMT
2352 		    "%s: smp passthru reply failed to be returned\n",
2353 		    ioc->name, __func__);
2354 		ret = -ENXIO;
2355 	}
2356 
2357 unmap_in:
2358 	dma_unmap_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, 1,
2359 			DMA_BIDIRECTIONAL);
2360 unmap_out:
2361 	dma_unmap_sg(&ioc->pcidev->dev, job->request_payload.sg_list, 1,
2362 			DMA_BIDIRECTIONAL);
2363 put_mf:
2364 	if (mf)
2365 		mpt_free_msg_frame(ioc, mf);
2366 out_unlock:
2367 	CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2368 	mutex_unlock(&ioc->sas_mgmt.mutex);
2369 out:
2370 	bsg_job_done(job, ret, reslen);
2371 }
2372 
2373 static struct sas_function_template mptsas_transport_functions = {
2374 	.get_linkerrors		= mptsas_get_linkerrors,
2375 	.get_enclosure_identifier = mptsas_get_enclosure_identifier,
2376 	.get_bay_identifier	= mptsas_get_bay_identifier,
2377 	.phy_reset		= mptsas_phy_reset,
2378 	.smp_handler		= mptsas_smp_handler,
2379 };
2380 
2381 static struct scsi_transport_template *mptsas_transport_template;
2382 
2383 static int
mptsas_sas_io_unit_pg0(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info)2384 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
2385 {
2386 	ConfigExtendedPageHeader_t hdr;
2387 	CONFIGPARMS cfg;
2388 	SasIOUnitPage0_t *buffer;
2389 	dma_addr_t dma_handle;
2390 	int error, i;
2391 
2392 	hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
2393 	hdr.ExtPageLength = 0;
2394 	hdr.PageNumber = 0;
2395 	hdr.Reserved1 = 0;
2396 	hdr.Reserved2 = 0;
2397 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2398 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2399 
2400 	cfg.cfghdr.ehdr = &hdr;
2401 	cfg.physAddr = -1;
2402 	cfg.pageAddr = 0;
2403 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2404 	cfg.dir = 0;	/* read */
2405 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2406 
2407 	error = mpt_config(ioc, &cfg);
2408 	if (error)
2409 		goto out;
2410 	if (!hdr.ExtPageLength) {
2411 		error = -ENXIO;
2412 		goto out;
2413 	}
2414 
2415 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2416 				    &dma_handle, GFP_KERNEL);
2417 	if (!buffer) {
2418 		error = -ENOMEM;
2419 		goto out;
2420 	}
2421 
2422 	cfg.physAddr = dma_handle;
2423 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2424 
2425 	error = mpt_config(ioc, &cfg);
2426 	if (error)
2427 		goto out_free_consistent;
2428 
2429 	port_info->num_phys = buffer->NumPhys;
2430 	port_info->phy_info = kcalloc(port_info->num_phys,
2431 		sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2432 	if (!port_info->phy_info) {
2433 		error = -ENOMEM;
2434 		goto out_free_consistent;
2435 	}
2436 
2437 	ioc->nvdata_version_persistent =
2438 	    le16_to_cpu(buffer->NvdataVersionPersistent);
2439 	ioc->nvdata_version_default =
2440 	    le16_to_cpu(buffer->NvdataVersionDefault);
2441 
2442 	for (i = 0; i < port_info->num_phys; i++) {
2443 		mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
2444 		port_info->phy_info[i].phy_id = i;
2445 		port_info->phy_info[i].port_id =
2446 		    buffer->PhyData[i].Port;
2447 		port_info->phy_info[i].negotiated_link_rate =
2448 		    buffer->PhyData[i].NegotiatedLinkRate;
2449 		port_info->phy_info[i].portinfo = port_info;
2450 		port_info->phy_info[i].handle =
2451 		    le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
2452 	}
2453 
2454  out_free_consistent:
2455 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2456 			  dma_handle);
2457  out:
2458 	return error;
2459 }
2460 
2461 static int
mptsas_sas_io_unit_pg1(MPT_ADAPTER * ioc)2462 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
2463 {
2464 	ConfigExtendedPageHeader_t hdr;
2465 	CONFIGPARMS cfg;
2466 	SasIOUnitPage1_t *buffer;
2467 	dma_addr_t dma_handle;
2468 	int error;
2469 	u8 device_missing_delay;
2470 
2471 	memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
2472 	memset(&cfg, 0, sizeof(CONFIGPARMS));
2473 
2474 	cfg.cfghdr.ehdr = &hdr;
2475 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2476 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2477 	cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2478 	cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2479 	cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
2480 	cfg.cfghdr.ehdr->PageNumber = 1;
2481 
2482 	error = mpt_config(ioc, &cfg);
2483 	if (error)
2484 		goto out;
2485 	if (!hdr.ExtPageLength) {
2486 		error = -ENXIO;
2487 		goto out;
2488 	}
2489 
2490 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2491 				    &dma_handle, GFP_KERNEL);
2492 	if (!buffer) {
2493 		error = -ENOMEM;
2494 		goto out;
2495 	}
2496 
2497 	cfg.physAddr = dma_handle;
2498 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2499 
2500 	error = mpt_config(ioc, &cfg);
2501 	if (error)
2502 		goto out_free_consistent;
2503 
2504 	ioc->io_missing_delay  =
2505 	    le16_to_cpu(buffer->IODeviceMissingDelay);
2506 	device_missing_delay = buffer->ReportDeviceMissingDelay;
2507 	ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
2508 	    (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
2509 	    device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
2510 
2511  out_free_consistent:
2512 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2513 			  dma_handle);
2514  out:
2515 	return error;
2516 }
2517 
2518 static int
mptsas_sas_phy_pg0(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info,u32 form,u32 form_specific)2519 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2520 		u32 form, u32 form_specific)
2521 {
2522 	ConfigExtendedPageHeader_t hdr;
2523 	CONFIGPARMS cfg;
2524 	SasPhyPage0_t *buffer;
2525 	dma_addr_t dma_handle;
2526 	int error;
2527 
2528 	hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
2529 	hdr.ExtPageLength = 0;
2530 	hdr.PageNumber = 0;
2531 	hdr.Reserved1 = 0;
2532 	hdr.Reserved2 = 0;
2533 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2534 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2535 
2536 	cfg.cfghdr.ehdr = &hdr;
2537 	cfg.dir = 0;	/* read */
2538 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2539 
2540 	/* Get Phy Pg 0 for each Phy. */
2541 	cfg.physAddr = -1;
2542 	cfg.pageAddr = form + form_specific;
2543 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2544 
2545 	error = mpt_config(ioc, &cfg);
2546 	if (error)
2547 		goto out;
2548 
2549 	if (!hdr.ExtPageLength) {
2550 		error = -ENXIO;
2551 		goto out;
2552 	}
2553 
2554 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2555 				    &dma_handle, GFP_KERNEL);
2556 	if (!buffer) {
2557 		error = -ENOMEM;
2558 		goto out;
2559 	}
2560 
2561 	cfg.physAddr = dma_handle;
2562 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2563 
2564 	error = mpt_config(ioc, &cfg);
2565 	if (error)
2566 		goto out_free_consistent;
2567 
2568 	mptsas_print_phy_pg0(ioc, buffer);
2569 
2570 	phy_info->hw_link_rate = buffer->HwLinkRate;
2571 	phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2572 	phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2573 	phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2574 
2575  out_free_consistent:
2576 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2577 			  dma_handle);
2578  out:
2579 	return error;
2580 }
2581 
2582 static int
mptsas_sas_device_pg0(MPT_ADAPTER * ioc,struct mptsas_devinfo * device_info,u32 form,u32 form_specific)2583 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
2584 		u32 form, u32 form_specific)
2585 {
2586 	ConfigExtendedPageHeader_t hdr;
2587 	CONFIGPARMS cfg;
2588 	SasDevicePage0_t *buffer;
2589 	dma_addr_t dma_handle;
2590 	__le64 sas_address;
2591 	int error=0;
2592 
2593 	hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
2594 	hdr.ExtPageLength = 0;
2595 	hdr.PageNumber = 0;
2596 	hdr.Reserved1 = 0;
2597 	hdr.Reserved2 = 0;
2598 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2599 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
2600 
2601 	cfg.cfghdr.ehdr = &hdr;
2602 	cfg.pageAddr = form + form_specific;
2603 	cfg.physAddr = -1;
2604 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2605 	cfg.dir = 0;	/* read */
2606 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2607 
2608 	memset(device_info, 0, sizeof(struct mptsas_devinfo));
2609 	error = mpt_config(ioc, &cfg);
2610 	if (error)
2611 		goto out;
2612 	if (!hdr.ExtPageLength) {
2613 		error = -ENXIO;
2614 		goto out;
2615 	}
2616 
2617 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2618 				    &dma_handle, GFP_KERNEL);
2619 	if (!buffer) {
2620 		error = -ENOMEM;
2621 		goto out;
2622 	}
2623 
2624 	cfg.physAddr = dma_handle;
2625 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2626 
2627 	error = mpt_config(ioc, &cfg);
2628 
2629 	if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2630 		error = -ENODEV;
2631 		goto out_free_consistent;
2632 	}
2633 
2634 	if (error)
2635 		goto out_free_consistent;
2636 
2637 	mptsas_print_device_pg0(ioc, buffer);
2638 
2639 	memset(device_info, 0, sizeof(struct mptsas_devinfo));
2640 	device_info->handle = le16_to_cpu(buffer->DevHandle);
2641 	device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
2642 	device_info->handle_enclosure =
2643 	    le16_to_cpu(buffer->EnclosureHandle);
2644 	device_info->slot = le16_to_cpu(buffer->Slot);
2645 	device_info->phy_id = buffer->PhyNum;
2646 	device_info->port_id = buffer->PhysicalPort;
2647 	device_info->id = buffer->TargetID;
2648 	device_info->phys_disk_num = ~0;
2649 	device_info->channel = buffer->Bus;
2650 	memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2651 	device_info->sas_address = le64_to_cpu(sas_address);
2652 	device_info->device_info =
2653 	    le32_to_cpu(buffer->DeviceInfo);
2654 	device_info->flags = le16_to_cpu(buffer->Flags);
2655 
2656  out_free_consistent:
2657 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2658 			  dma_handle);
2659  out:
2660 	return error;
2661 }
2662 
2663 static int
mptsas_sas_expander_pg0(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info,u32 form,u32 form_specific)2664 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
2665 		u32 form, u32 form_specific)
2666 {
2667 	ConfigExtendedPageHeader_t hdr;
2668 	CONFIGPARMS cfg;
2669 	SasExpanderPage0_t *buffer;
2670 	dma_addr_t dma_handle;
2671 	int i, error;
2672 	__le64 sas_address;
2673 
2674 	memset(port_info, 0, sizeof(struct mptsas_portinfo));
2675 	hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
2676 	hdr.ExtPageLength = 0;
2677 	hdr.PageNumber = 0;
2678 	hdr.Reserved1 = 0;
2679 	hdr.Reserved2 = 0;
2680 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2681 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2682 
2683 	cfg.cfghdr.ehdr = &hdr;
2684 	cfg.physAddr = -1;
2685 	cfg.pageAddr = form + form_specific;
2686 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2687 	cfg.dir = 0;	/* read */
2688 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2689 
2690 	memset(port_info, 0, sizeof(struct mptsas_portinfo));
2691 	error = mpt_config(ioc, &cfg);
2692 	if (error)
2693 		goto out;
2694 
2695 	if (!hdr.ExtPageLength) {
2696 		error = -ENXIO;
2697 		goto out;
2698 	}
2699 
2700 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2701 				    &dma_handle, GFP_KERNEL);
2702 	if (!buffer) {
2703 		error = -ENOMEM;
2704 		goto out;
2705 	}
2706 
2707 	cfg.physAddr = dma_handle;
2708 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2709 
2710 	error = mpt_config(ioc, &cfg);
2711 	if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2712 		error = -ENODEV;
2713 		goto out_free_consistent;
2714 	}
2715 
2716 	if (error)
2717 		goto out_free_consistent;
2718 
2719 	/* save config data */
2720 	port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
2721 	port_info->phy_info = kcalloc(port_info->num_phys,
2722 		sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2723 	if (!port_info->phy_info) {
2724 		error = -ENOMEM;
2725 		goto out_free_consistent;
2726 	}
2727 
2728 	memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2729 	for (i = 0; i < port_info->num_phys; i++) {
2730 		port_info->phy_info[i].portinfo = port_info;
2731 		port_info->phy_info[i].handle =
2732 		    le16_to_cpu(buffer->DevHandle);
2733 		port_info->phy_info[i].identify.sas_address =
2734 		    le64_to_cpu(sas_address);
2735 		port_info->phy_info[i].identify.handle_parent =
2736 		    le16_to_cpu(buffer->ParentDevHandle);
2737 	}
2738 
2739  out_free_consistent:
2740 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2741 			  dma_handle);
2742  out:
2743 	return error;
2744 }
2745 
2746 static int
mptsas_sas_expander_pg1(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info,u32 form,u32 form_specific)2747 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2748 		u32 form, u32 form_specific)
2749 {
2750 	ConfigExtendedPageHeader_t hdr;
2751 	CONFIGPARMS cfg;
2752 	SasExpanderPage1_t *buffer;
2753 	dma_addr_t dma_handle;
2754 	int error=0;
2755 
2756 	hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
2757 	hdr.ExtPageLength = 0;
2758 	hdr.PageNumber = 1;
2759 	hdr.Reserved1 = 0;
2760 	hdr.Reserved2 = 0;
2761 	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2762 	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2763 
2764 	cfg.cfghdr.ehdr = &hdr;
2765 	cfg.physAddr = -1;
2766 	cfg.pageAddr = form + form_specific;
2767 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2768 	cfg.dir = 0;	/* read */
2769 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2770 
2771 	error = mpt_config(ioc, &cfg);
2772 	if (error)
2773 		goto out;
2774 
2775 	if (!hdr.ExtPageLength) {
2776 		error = -ENXIO;
2777 		goto out;
2778 	}
2779 
2780 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
2781 				    &dma_handle, GFP_KERNEL);
2782 	if (!buffer) {
2783 		error = -ENOMEM;
2784 		goto out;
2785 	}
2786 
2787 	cfg.physAddr = dma_handle;
2788 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2789 
2790 	error = mpt_config(ioc, &cfg);
2791 
2792 	if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2793 		error = -ENODEV;
2794 		goto out_free_consistent;
2795 	}
2796 
2797 	if (error)
2798 		goto out_free_consistent;
2799 
2800 
2801 	mptsas_print_expander_pg1(ioc, buffer);
2802 
2803 	/* save config data */
2804 	phy_info->phy_id = buffer->PhyIdentifier;
2805 	phy_info->port_id = buffer->PhysicalPort;
2806 	phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
2807 	phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2808 	phy_info->hw_link_rate = buffer->HwLinkRate;
2809 	phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2810 	phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2811 
2812  out_free_consistent:
2813 	dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
2814 			  dma_handle);
2815  out:
2816 	return error;
2817 }
2818 
2819 struct rep_manu_request{
2820 	u8 smp_frame_type;
2821 	u8 function;
2822 	u8 reserved;
2823 	u8 request_length;
2824 };
2825 
2826 struct rep_manu_reply{
2827 	u8 smp_frame_type; /* 0x41 */
2828 	u8 function; /* 0x01 */
2829 	u8 function_result;
2830 	u8 response_length;
2831 	u16 expander_change_count;
2832 	u8 reserved0[2];
2833 	u8 sas_format:1;
2834 	u8 reserved1:7;
2835 	u8 reserved2[3];
2836 	u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
2837 	u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
2838 	u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
2839 	u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
2840 	u16 component_id;
2841 	u8 component_revision_id;
2842 	u8 reserved3;
2843 	u8 vendor_specific[8];
2844 };
2845 
2846 /**
2847   * mptsas_exp_repmanufacture_info - sets expander manufacturer info
2848   * @ioc: per adapter object
2849   * @sas_address: expander sas address
2850   * @edev: the sas_expander_device object
2851   *
2852   * For an edge expander or a fanout expander:
2853   * fills in the sas_expander_device object when SMP port is created.
2854   *
2855   * Return: 0 for success, non-zero for failure.
2856   */
2857 static int
mptsas_exp_repmanufacture_info(MPT_ADAPTER * ioc,u64 sas_address,struct sas_expander_device * edev)2858 mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
2859 	u64 sas_address, struct sas_expander_device *edev)
2860 {
2861 	MPT_FRAME_HDR *mf;
2862 	SmpPassthroughRequest_t *smpreq;
2863 	SmpPassthroughReply_t *smprep;
2864 	struct rep_manu_reply *manufacture_reply;
2865 	struct rep_manu_request *manufacture_request;
2866 	int ret;
2867 	int flagsLength;
2868 	unsigned long timeleft;
2869 	char *psge;
2870 	unsigned long flags;
2871 	void *data_out = NULL;
2872 	dma_addr_t data_out_dma = 0;
2873 	u32 sz;
2874 
2875 	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2876 	if (ioc->ioc_reset_in_progress) {
2877 		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2878 		printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
2879 			__func__, ioc->name);
2880 		return -EFAULT;
2881 	}
2882 	spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2883 
2884 	ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2885 	if (ret)
2886 		goto out;
2887 
2888 	mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2889 	if (!mf) {
2890 		ret = -ENOMEM;
2891 		goto out_unlock;
2892 	}
2893 
2894 	smpreq = (SmpPassthroughRequest_t *)mf;
2895 	memset(smpreq, 0, sizeof(*smpreq));
2896 
2897 	sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
2898 
2899 	data_out = dma_alloc_coherent(&ioc->pcidev->dev, sz, &data_out_dma,
2900 				      GFP_KERNEL);
2901 	if (!data_out) {
2902 		printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
2903 			__FILE__, __LINE__, __func__);
2904 		ret = -ENOMEM;
2905 		goto put_mf;
2906 	}
2907 
2908 	manufacture_request = data_out;
2909 	manufacture_request->smp_frame_type = 0x40;
2910 	manufacture_request->function = 1;
2911 	manufacture_request->reserved = 0;
2912 	manufacture_request->request_length = 0;
2913 
2914 	smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2915 	smpreq->PhysicalPort = 0xFF;
2916 	*((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2917 	smpreq->RequestDataLength = sizeof(struct rep_manu_request);
2918 
2919 	psge = (char *)
2920 		(((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2921 
2922 	flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2923 		MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2924 		MPI_SGE_FLAGS_HOST_TO_IOC |
2925 		MPI_SGE_FLAGS_END_OF_BUFFER;
2926 	flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2927 	flagsLength |= sizeof(struct rep_manu_request);
2928 
2929 	ioc->add_sge(psge, flagsLength, data_out_dma);
2930 	psge += ioc->SGE_size;
2931 
2932 	flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2933 		MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2934 		MPI_SGE_FLAGS_IOC_TO_HOST |
2935 		MPI_SGE_FLAGS_END_OF_BUFFER;
2936 	flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2937 	flagsLength |= sizeof(struct rep_manu_reply);
2938 	ioc->add_sge(psge, flagsLength, data_out_dma +
2939 	sizeof(struct rep_manu_request));
2940 
2941 	INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2942 	mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2943 
2944 	timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2945 	if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2946 		ret = -ETIME;
2947 		mpt_free_msg_frame(ioc, mf);
2948 		mf = NULL;
2949 		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2950 			goto out_free;
2951 		if (!timeleft)
2952 			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2953 		goto out_free;
2954 	}
2955 
2956 	mf = NULL;
2957 
2958 	if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2959 		u8 *tmp;
2960 
2961 		smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2962 		if (le16_to_cpu(smprep->ResponseDataLength) !=
2963 		    sizeof(struct rep_manu_reply))
2964 			goto out_free;
2965 
2966 		manufacture_reply = data_out + sizeof(struct rep_manu_request);
2967 		strncpy(edev->vendor_id, manufacture_reply->vendor_id,
2968 			SAS_EXPANDER_VENDOR_ID_LEN);
2969 		strncpy(edev->product_id, manufacture_reply->product_id,
2970 			SAS_EXPANDER_PRODUCT_ID_LEN);
2971 		strncpy(edev->product_rev, manufacture_reply->product_rev,
2972 			SAS_EXPANDER_PRODUCT_REV_LEN);
2973 		edev->level = manufacture_reply->sas_format;
2974 		if (manufacture_reply->sas_format) {
2975 			strncpy(edev->component_vendor_id,
2976 				manufacture_reply->component_vendor_id,
2977 				SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
2978 			tmp = (u8 *)&manufacture_reply->component_id;
2979 			edev->component_id = tmp[0] << 8 | tmp[1];
2980 			edev->component_revision_id =
2981 				manufacture_reply->component_revision_id;
2982 		}
2983 	} else {
2984 		printk(MYIOC_s_ERR_FMT
2985 			"%s: smp passthru reply failed to be returned\n",
2986 			ioc->name, __func__);
2987 		ret = -ENXIO;
2988 	}
2989 out_free:
2990 	if (data_out_dma)
2991 		dma_free_coherent(&ioc->pcidev->dev, sz, data_out,
2992 				  data_out_dma);
2993 put_mf:
2994 	if (mf)
2995 		mpt_free_msg_frame(ioc, mf);
2996 out_unlock:
2997 	CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2998 	mutex_unlock(&ioc->sas_mgmt.mutex);
2999 out:
3000 	return ret;
3001 }
3002 
3003 static void
mptsas_parse_device_info(struct sas_identify * identify,struct mptsas_devinfo * device_info)3004 mptsas_parse_device_info(struct sas_identify *identify,
3005 		struct mptsas_devinfo *device_info)
3006 {
3007 	u16 protocols;
3008 
3009 	identify->sas_address = device_info->sas_address;
3010 	identify->phy_identifier = device_info->phy_id;
3011 
3012 	/*
3013 	 * Fill in Phy Initiator Port Protocol.
3014 	 * Bits 6:3, more than one bit can be set, fall through cases.
3015 	 */
3016 	protocols = device_info->device_info & 0x78;
3017 	identify->initiator_port_protocols = 0;
3018 	if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
3019 		identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
3020 	if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
3021 		identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
3022 	if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
3023 		identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
3024 	if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
3025 		identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
3026 
3027 	/*
3028 	 * Fill in Phy Target Port Protocol.
3029 	 * Bits 10:7, more than one bit can be set, fall through cases.
3030 	 */
3031 	protocols = device_info->device_info & 0x780;
3032 	identify->target_port_protocols = 0;
3033 	if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
3034 		identify->target_port_protocols |= SAS_PROTOCOL_SSP;
3035 	if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
3036 		identify->target_port_protocols |= SAS_PROTOCOL_STP;
3037 	if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
3038 		identify->target_port_protocols |= SAS_PROTOCOL_SMP;
3039 	if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
3040 		identify->target_port_protocols |= SAS_PROTOCOL_SATA;
3041 
3042 	/*
3043 	 * Fill in Attached device type.
3044 	 */
3045 	switch (device_info->device_info &
3046 			MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
3047 	case MPI_SAS_DEVICE_INFO_NO_DEVICE:
3048 		identify->device_type = SAS_PHY_UNUSED;
3049 		break;
3050 	case MPI_SAS_DEVICE_INFO_END_DEVICE:
3051 		identify->device_type = SAS_END_DEVICE;
3052 		break;
3053 	case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
3054 		identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
3055 		break;
3056 	case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
3057 		identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
3058 		break;
3059 	}
3060 }
3061 
mptsas_probe_one_phy(struct device * dev,struct mptsas_phyinfo * phy_info,int index,int local)3062 static int mptsas_probe_one_phy(struct device *dev,
3063 		struct mptsas_phyinfo *phy_info, int index, int local)
3064 {
3065 	MPT_ADAPTER *ioc;
3066 	struct sas_phy *phy;
3067 	struct sas_port *port;
3068 	int error = 0;
3069 	VirtTarget *vtarget;
3070 
3071 	if (!dev) {
3072 		error = -ENODEV;
3073 		goto out;
3074 	}
3075 
3076 	if (!phy_info->phy) {
3077 		phy = sas_phy_alloc(dev, index);
3078 		if (!phy) {
3079 			error = -ENOMEM;
3080 			goto out;
3081 		}
3082 	} else
3083 		phy = phy_info->phy;
3084 
3085 	mptsas_parse_device_info(&phy->identify, &phy_info->identify);
3086 
3087 	/*
3088 	 * Set Negotiated link rate.
3089 	 */
3090 	switch (phy_info->negotiated_link_rate) {
3091 	case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
3092 		phy->negotiated_linkrate = SAS_PHY_DISABLED;
3093 		break;
3094 	case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
3095 		phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
3096 		break;
3097 	case MPI_SAS_IOUNIT0_RATE_1_5:
3098 		phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
3099 		break;
3100 	case MPI_SAS_IOUNIT0_RATE_3_0:
3101 		phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
3102 		break;
3103 	case MPI_SAS_IOUNIT0_RATE_6_0:
3104 		phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS;
3105 		break;
3106 	case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
3107 	case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
3108 	default:
3109 		phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
3110 		break;
3111 	}
3112 
3113 	/*
3114 	 * Set Max hardware link rate.
3115 	 */
3116 	switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3117 	case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
3118 		phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3119 		break;
3120 	case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3121 		phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3122 		break;
3123 	default:
3124 		break;
3125 	}
3126 
3127 	/*
3128 	 * Set Max programmed link rate.
3129 	 */
3130 	switch (phy_info->programmed_link_rate &
3131 			MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3132 	case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
3133 		phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3134 		break;
3135 	case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3136 		phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3137 		break;
3138 	default:
3139 		break;
3140 	}
3141 
3142 	/*
3143 	 * Set Min hardware link rate.
3144 	 */
3145 	switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
3146 	case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
3147 		phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3148 		break;
3149 	case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3150 		phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3151 		break;
3152 	default:
3153 		break;
3154 	}
3155 
3156 	/*
3157 	 * Set Min programmed link rate.
3158 	 */
3159 	switch (phy_info->programmed_link_rate &
3160 			MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
3161 	case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
3162 		phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3163 		break;
3164 	case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3165 		phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3166 		break;
3167 	default:
3168 		break;
3169 	}
3170 
3171 	if (!phy_info->phy) {
3172 
3173 		error = sas_phy_add(phy);
3174 		if (error) {
3175 			sas_phy_free(phy);
3176 			goto out;
3177 		}
3178 		phy_info->phy = phy;
3179 	}
3180 
3181 	if (!phy_info->attached.handle ||
3182 			!phy_info->port_details)
3183 		goto out;
3184 
3185 	port = mptsas_get_port(phy_info);
3186 	ioc = phy_to_ioc(phy_info->phy);
3187 
3188 	if (phy_info->sas_port_add_phy) {
3189 
3190 		if (!port) {
3191 			port = sas_port_alloc_num(dev);
3192 			if (!port) {
3193 				error = -ENOMEM;
3194 				goto out;
3195 			}
3196 			error = sas_port_add(port);
3197 			if (error) {
3198 				dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3199 					"%s: exit at line=%d\n", ioc->name,
3200 					__func__, __LINE__));
3201 				goto out;
3202 			}
3203 			mptsas_set_port(ioc, phy_info, port);
3204 			devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
3205 			    MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
3206 			    ioc->name, port->port_identifier,
3207 			    (unsigned long long)phy_info->
3208 			    attached.sas_address));
3209 		}
3210 		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3211 			"sas_port_add_phy: phy_id=%d\n",
3212 			ioc->name, phy_info->phy_id));
3213 		sas_port_add_phy(port, phy_info->phy);
3214 		phy_info->sas_port_add_phy = 0;
3215 		devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3216 		    MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
3217 		     phy_info->phy_id, phy_info->phy));
3218 	}
3219 	if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
3220 
3221 		struct sas_rphy *rphy;
3222 		struct device *parent;
3223 		struct sas_identify identify;
3224 
3225 		parent = dev->parent->parent;
3226 		/*
3227 		 * Let the hotplug_work thread handle processing
3228 		 * the adding/removing of devices that occur
3229 		 * after start of day.
3230 		 */
3231 		if (mptsas_is_end_device(&phy_info->attached) &&
3232 		    phy_info->attached.handle_parent) {
3233 			goto out;
3234 		}
3235 
3236 		mptsas_parse_device_info(&identify, &phy_info->attached);
3237 		if (scsi_is_host_device(parent)) {
3238 			struct mptsas_portinfo *port_info;
3239 			int i;
3240 
3241 			port_info = ioc->hba_port_info;
3242 
3243 			for (i = 0; i < port_info->num_phys; i++)
3244 				if (port_info->phy_info[i].identify.sas_address ==
3245 				    identify.sas_address) {
3246 					sas_port_mark_backlink(port);
3247 					goto out;
3248 				}
3249 
3250 		} else if (scsi_is_sas_rphy(parent)) {
3251 			struct sas_rphy *parent_rphy = dev_to_rphy(parent);
3252 			if (identify.sas_address ==
3253 			    parent_rphy->identify.sas_address) {
3254 				sas_port_mark_backlink(port);
3255 				goto out;
3256 			}
3257 		}
3258 
3259 		switch (identify.device_type) {
3260 		case SAS_END_DEVICE:
3261 			rphy = sas_end_device_alloc(port);
3262 			break;
3263 		case SAS_EDGE_EXPANDER_DEVICE:
3264 		case SAS_FANOUT_EXPANDER_DEVICE:
3265 			rphy = sas_expander_alloc(port, identify.device_type);
3266 			break;
3267 		default:
3268 			rphy = NULL;
3269 			break;
3270 		}
3271 		if (!rphy) {
3272 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3273 				"%s: exit at line=%d\n", ioc->name,
3274 				__func__, __LINE__));
3275 			goto out;
3276 		}
3277 
3278 		rphy->identify = identify;
3279 		error = sas_rphy_add(rphy);
3280 		if (error) {
3281 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3282 				"%s: exit at line=%d\n", ioc->name,
3283 				__func__, __LINE__));
3284 			sas_rphy_free(rphy);
3285 			goto out;
3286 		}
3287 		mptsas_set_rphy(ioc, phy_info, rphy);
3288 		if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
3289 			identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
3290 				mptsas_exp_repmanufacture_info(ioc,
3291 					identify.sas_address,
3292 					rphy_to_expander_device(rphy));
3293 	}
3294 
3295 	/* If the device exists, verify it wasn't previously flagged
3296 	as a missing device.  If so, clear it */
3297 	vtarget = mptsas_find_vtarget(ioc,
3298 	    phy_info->attached.channel,
3299 	    phy_info->attached.id);
3300 	if (vtarget && vtarget->inDMD) {
3301 		printk(KERN_INFO "Device returned, unsetting inDMD\n");
3302 		vtarget->inDMD = 0;
3303 	}
3304 
3305  out:
3306 	return error;
3307 }
3308 
3309 static int
mptsas_probe_hba_phys(MPT_ADAPTER * ioc)3310 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
3311 {
3312 	struct mptsas_portinfo *port_info, *hba;
3313 	int error = -ENOMEM, i;
3314 
3315 	hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3316 	if (! hba)
3317 		goto out;
3318 
3319 	error = mptsas_sas_io_unit_pg0(ioc, hba);
3320 	if (error)
3321 		goto out_free_port_info;
3322 
3323 	mptsas_sas_io_unit_pg1(ioc);
3324 	mutex_lock(&ioc->sas_topology_mutex);
3325 	port_info = ioc->hba_port_info;
3326 	if (!port_info) {
3327 		ioc->hba_port_info = port_info = hba;
3328 		ioc->hba_port_num_phy = port_info->num_phys;
3329 		list_add_tail(&port_info->list, &ioc->sas_topology);
3330 	} else {
3331 		for (i = 0; i < hba->num_phys; i++) {
3332 			port_info->phy_info[i].negotiated_link_rate =
3333 				hba->phy_info[i].negotiated_link_rate;
3334 			port_info->phy_info[i].handle =
3335 				hba->phy_info[i].handle;
3336 			port_info->phy_info[i].port_id =
3337 				hba->phy_info[i].port_id;
3338 		}
3339 		kfree(hba->phy_info);
3340 		kfree(hba);
3341 		hba = NULL;
3342 	}
3343 	mutex_unlock(&ioc->sas_topology_mutex);
3344 #if defined(CPQ_CIM)
3345 	ioc->num_ports = port_info->num_phys;
3346 #endif
3347 	for (i = 0; i < port_info->num_phys; i++) {
3348 		mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
3349 			(MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
3350 			 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
3351 		port_info->phy_info[i].identify.handle =
3352 		    port_info->phy_info[i].handle;
3353 		mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
3354 			(MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3355 			 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3356 			 port_info->phy_info[i].identify.handle);
3357 		if (!ioc->hba_port_sas_addr)
3358 			ioc->hba_port_sas_addr =
3359 			    port_info->phy_info[i].identify.sas_address;
3360 		port_info->phy_info[i].identify.phy_id =
3361 		    port_info->phy_info[i].phy_id = i;
3362 		if (port_info->phy_info[i].attached.handle)
3363 			mptsas_sas_device_pg0(ioc,
3364 				&port_info->phy_info[i].attached,
3365 				(MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3366 				 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3367 				port_info->phy_info[i].attached.handle);
3368 	}
3369 
3370 	mptsas_setup_wide_ports(ioc, port_info);
3371 
3372 	for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3373 		mptsas_probe_one_phy(&ioc->sh->shost_gendev,
3374 		    &port_info->phy_info[i], ioc->sas_index, 1);
3375 
3376 	return 0;
3377 
3378  out_free_port_info:
3379 	kfree(hba);
3380  out:
3381 	return error;
3382 }
3383 
3384 static void
mptsas_expander_refresh(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info)3385 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
3386 {
3387 	struct mptsas_portinfo *parent;
3388 	struct device *parent_dev;
3389 	struct sas_rphy	*rphy;
3390 	int		i;
3391 	u64		sas_address; /* expander sas address */
3392 	u32		handle;
3393 
3394 	handle = port_info->phy_info[0].handle;
3395 	sas_address = port_info->phy_info[0].identify.sas_address;
3396 	for (i = 0; i < port_info->num_phys; i++) {
3397 		mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
3398 		    (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
3399 		    MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
3400 
3401 		mptsas_sas_device_pg0(ioc,
3402 		    &port_info->phy_info[i].identify,
3403 		    (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3404 		    MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3405 		    port_info->phy_info[i].identify.handle);
3406 		port_info->phy_info[i].identify.phy_id =
3407 		    port_info->phy_info[i].phy_id;
3408 
3409 		if (port_info->phy_info[i].attached.handle) {
3410 			mptsas_sas_device_pg0(ioc,
3411 			    &port_info->phy_info[i].attached,
3412 			    (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3413 			     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3414 			    port_info->phy_info[i].attached.handle);
3415 			port_info->phy_info[i].attached.phy_id =
3416 			    port_info->phy_info[i].phy_id;
3417 		}
3418 	}
3419 
3420 	mutex_lock(&ioc->sas_topology_mutex);
3421 	parent = mptsas_find_portinfo_by_handle(ioc,
3422 	    port_info->phy_info[0].identify.handle_parent);
3423 	if (!parent) {
3424 		mutex_unlock(&ioc->sas_topology_mutex);
3425 		return;
3426 	}
3427 	for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
3428 	    i++) {
3429 		if (parent->phy_info[i].attached.sas_address == sas_address) {
3430 			rphy = mptsas_get_rphy(&parent->phy_info[i]);
3431 			parent_dev = &rphy->dev;
3432 		}
3433 	}
3434 	mutex_unlock(&ioc->sas_topology_mutex);
3435 
3436 	mptsas_setup_wide_ports(ioc, port_info);
3437 	for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3438 		mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
3439 		    ioc->sas_index, 0);
3440 }
3441 
3442 static void
mptsas_expander_event_add(MPT_ADAPTER * ioc,MpiEventDataSasExpanderStatusChange_t * expander_data)3443 mptsas_expander_event_add(MPT_ADAPTER *ioc,
3444     MpiEventDataSasExpanderStatusChange_t *expander_data)
3445 {
3446 	struct mptsas_portinfo *port_info;
3447 	int i;
3448 	__le64 sas_address;
3449 
3450 	port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3451 	BUG_ON(!port_info);
3452 	port_info->num_phys = (expander_data->NumPhys) ?
3453 	    expander_data->NumPhys : 1;
3454 	port_info->phy_info = kcalloc(port_info->num_phys,
3455 	    sizeof(struct mptsas_phyinfo), GFP_KERNEL);
3456 	BUG_ON(!port_info->phy_info);
3457 	memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3458 	for (i = 0; i < port_info->num_phys; i++) {
3459 		port_info->phy_info[i].portinfo = port_info;
3460 		port_info->phy_info[i].handle =
3461 		    le16_to_cpu(expander_data->DevHandle);
3462 		port_info->phy_info[i].identify.sas_address =
3463 		    le64_to_cpu(sas_address);
3464 		port_info->phy_info[i].identify.handle_parent =
3465 		    le16_to_cpu(expander_data->ParentDevHandle);
3466 	}
3467 
3468 	mutex_lock(&ioc->sas_topology_mutex);
3469 	list_add_tail(&port_info->list, &ioc->sas_topology);
3470 	mutex_unlock(&ioc->sas_topology_mutex);
3471 
3472 	printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3473 	    "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3474 	    (unsigned long long)sas_address);
3475 
3476 	mptsas_expander_refresh(ioc, port_info);
3477 }
3478 
3479 /**
3480  * mptsas_delete_expander_siblings - remove siblings attached to expander
3481  * @ioc: Pointer to MPT_ADAPTER structure
3482  * @parent: the parent port_info object
3483  * @expander: the expander port_info object
3484  **/
3485 static void
mptsas_delete_expander_siblings(MPT_ADAPTER * ioc,struct mptsas_portinfo * parent,struct mptsas_portinfo * expander)3486 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
3487     *parent, struct mptsas_portinfo *expander)
3488 {
3489 	struct mptsas_phyinfo *phy_info;
3490 	struct mptsas_portinfo *port_info;
3491 	struct sas_rphy *rphy;
3492 	int i;
3493 
3494 	phy_info = expander->phy_info;
3495 	for (i = 0; i < expander->num_phys; i++, phy_info++) {
3496 		rphy = mptsas_get_rphy(phy_info);
3497 		if (!rphy)
3498 			continue;
3499 		if (rphy->identify.device_type == SAS_END_DEVICE)
3500 			mptsas_del_end_device(ioc, phy_info);
3501 	}
3502 
3503 	phy_info = expander->phy_info;
3504 	for (i = 0; i < expander->num_phys; i++, phy_info++) {
3505 		rphy = mptsas_get_rphy(phy_info);
3506 		if (!rphy)
3507 			continue;
3508 		if (rphy->identify.device_type ==
3509 		    MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
3510 		    rphy->identify.device_type ==
3511 		    MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
3512 			port_info = mptsas_find_portinfo_by_sas_address(ioc,
3513 			    rphy->identify.sas_address);
3514 			if (!port_info)
3515 				continue;
3516 			if (port_info == parent) /* backlink rphy */
3517 				continue;
3518 			/*
3519 			Delete this expander even if the expdevpage is exists
3520 			because the parent expander is already deleted
3521 			*/
3522 			mptsas_expander_delete(ioc, port_info, 1);
3523 		}
3524 	}
3525 }
3526 
3527 
3528 /**
3529  *	mptsas_expander_delete - remove this expander
3530  *	@ioc: Pointer to MPT_ADAPTER structure
3531  *	@port_info: expander port_info struct
3532  *	@force: Flag to forcefully delete the expander
3533  *
3534  **/
3535 
mptsas_expander_delete(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info,u8 force)3536 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
3537 		struct mptsas_portinfo *port_info, u8 force)
3538 {
3539 
3540 	struct mptsas_portinfo *parent;
3541 	int		i;
3542 	u64		expander_sas_address;
3543 	struct mptsas_phyinfo *phy_info;
3544 	struct mptsas_portinfo buffer;
3545 	struct mptsas_portinfo_details *port_details;
3546 	struct sas_port *port;
3547 
3548 	if (!port_info)
3549 		return;
3550 
3551 	/* see if expander is still there before deleting */
3552 	mptsas_sas_expander_pg0(ioc, &buffer,
3553 	    (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3554 	    MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
3555 	    port_info->phy_info[0].identify.handle);
3556 
3557 	if (buffer.num_phys) {
3558 		kfree(buffer.phy_info);
3559 		if (!force)
3560 			return;
3561 	}
3562 
3563 
3564 	/*
3565 	 * Obtain the port_info instance to the parent port
3566 	 */
3567 	port_details = NULL;
3568 	expander_sas_address =
3569 	    port_info->phy_info[0].identify.sas_address;
3570 	parent = mptsas_find_portinfo_by_handle(ioc,
3571 	    port_info->phy_info[0].identify.handle_parent);
3572 	mptsas_delete_expander_siblings(ioc, parent, port_info);
3573 	if (!parent)
3574 		goto out;
3575 
3576 	/*
3577 	 * Delete rphys in the parent that point
3578 	 * to this expander.
3579 	 */
3580 	phy_info = parent->phy_info;
3581 	port = NULL;
3582 	for (i = 0; i < parent->num_phys; i++, phy_info++) {
3583 		if (!phy_info->phy)
3584 			continue;
3585 		if (phy_info->attached.sas_address !=
3586 		    expander_sas_address)
3587 			continue;
3588 		if (!port) {
3589 			port = mptsas_get_port(phy_info);
3590 			port_details = phy_info->port_details;
3591 		}
3592 		dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3593 		    MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
3594 		    phy_info->phy_id, phy_info->phy);
3595 		sas_port_delete_phy(port, phy_info->phy);
3596 	}
3597 	if (port) {
3598 		dev_printk(KERN_DEBUG, &port->dev,
3599 		    MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
3600 		    ioc->name, port->port_identifier,
3601 		    (unsigned long long)expander_sas_address);
3602 		sas_port_delete(port);
3603 		mptsas_port_delete(ioc, port_details);
3604 	}
3605  out:
3606 
3607 	printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
3608 	    "sas_addr (0x%llx)\n",  ioc->name, port_info->num_phys,
3609 	    (unsigned long long)expander_sas_address);
3610 
3611 	/*
3612 	 * free link
3613 	 */
3614 	list_del(&port_info->list);
3615 	kfree(port_info->phy_info);
3616 	kfree(port_info);
3617 }
3618 
3619 
3620 /**
3621  * mptsas_send_expander_event - expanders events
3622  * @fw_event: event data
3623  *
3624  *
3625  * This function handles adding, removing, and refreshing
3626  * device handles within the expander objects.
3627  */
3628 static void
mptsas_send_expander_event(struct fw_event_work * fw_event)3629 mptsas_send_expander_event(struct fw_event_work *fw_event)
3630 {
3631 	MPT_ADAPTER *ioc;
3632 	MpiEventDataSasExpanderStatusChange_t *expander_data;
3633 	struct mptsas_portinfo *port_info;
3634 	__le64 sas_address;
3635 	int i;
3636 
3637 	ioc = fw_event->ioc;
3638 	expander_data = (MpiEventDataSasExpanderStatusChange_t *)
3639 	    fw_event->event_data;
3640 	memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3641 	sas_address = le64_to_cpu(sas_address);
3642 	port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3643 
3644 	if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
3645 		if (port_info) {
3646 			for (i = 0; i < port_info->num_phys; i++) {
3647 				port_info->phy_info[i].portinfo = port_info;
3648 				port_info->phy_info[i].handle =
3649 				    le16_to_cpu(expander_data->DevHandle);
3650 				port_info->phy_info[i].identify.sas_address =
3651 				    le64_to_cpu(sas_address);
3652 				port_info->phy_info[i].identify.handle_parent =
3653 				    le16_to_cpu(expander_data->ParentDevHandle);
3654 			}
3655 			mptsas_expander_refresh(ioc, port_info);
3656 		} else if (!port_info && expander_data->NumPhys)
3657 			mptsas_expander_event_add(ioc, expander_data);
3658 	} else if (expander_data->ReasonCode ==
3659 	    MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
3660 		mptsas_expander_delete(ioc, port_info, 0);
3661 
3662 	mptsas_free_fw_event(ioc, fw_event);
3663 }
3664 
3665 
3666 /**
3667  * mptsas_expander_add - adds a newly discovered expander
3668  * @ioc: Pointer to MPT_ADAPTER structure
3669  * @handle: device handle
3670  *
3671  */
3672 static struct mptsas_portinfo *
mptsas_expander_add(MPT_ADAPTER * ioc,u16 handle)3673 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
3674 {
3675 	struct mptsas_portinfo buffer, *port_info;
3676 	int i;
3677 
3678 	if ((mptsas_sas_expander_pg0(ioc, &buffer,
3679 	    (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3680 	    MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
3681 		return NULL;
3682 
3683 	port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3684 	if (!port_info) {
3685 		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3686 		"%s: exit at line=%d\n", ioc->name,
3687 		__func__, __LINE__));
3688 		return NULL;
3689 	}
3690 	port_info->num_phys = buffer.num_phys;
3691 	port_info->phy_info = buffer.phy_info;
3692 	for (i = 0; i < port_info->num_phys; i++)
3693 		port_info->phy_info[i].portinfo = port_info;
3694 	mutex_lock(&ioc->sas_topology_mutex);
3695 	list_add_tail(&port_info->list, &ioc->sas_topology);
3696 	mutex_unlock(&ioc->sas_topology_mutex);
3697 	printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3698 	    "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3699 	    (unsigned long long)buffer.phy_info[0].identify.sas_address);
3700 	mptsas_expander_refresh(ioc, port_info);
3701 	return port_info;
3702 }
3703 
3704 static void
mptsas_send_link_status_event(struct fw_event_work * fw_event)3705 mptsas_send_link_status_event(struct fw_event_work *fw_event)
3706 {
3707 	MPT_ADAPTER *ioc;
3708 	MpiEventDataSasPhyLinkStatus_t *link_data;
3709 	struct mptsas_portinfo *port_info;
3710 	struct mptsas_phyinfo *phy_info = NULL;
3711 	__le64 sas_address;
3712 	u8 phy_num;
3713 	u8 link_rate;
3714 
3715 	ioc = fw_event->ioc;
3716 	link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
3717 
3718 	memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
3719 	sas_address = le64_to_cpu(sas_address);
3720 	link_rate = link_data->LinkRates >> 4;
3721 	phy_num = link_data->PhyNum;
3722 
3723 	port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3724 	if (port_info) {
3725 		phy_info = &port_info->phy_info[phy_num];
3726 		if (phy_info)
3727 			phy_info->negotiated_link_rate = link_rate;
3728 	}
3729 
3730 	if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
3731 	    link_rate == MPI_SAS_IOUNIT0_RATE_3_0 ||
3732 	    link_rate == MPI_SAS_IOUNIT0_RATE_6_0) {
3733 
3734 		if (!port_info) {
3735 			if (ioc->old_sas_discovery_protocal) {
3736 				port_info = mptsas_expander_add(ioc,
3737 					le16_to_cpu(link_data->DevHandle));
3738 				if (port_info)
3739 					goto out;
3740 			}
3741 			goto out;
3742 		}
3743 
3744 		if (port_info == ioc->hba_port_info)
3745 			mptsas_probe_hba_phys(ioc);
3746 		else
3747 			mptsas_expander_refresh(ioc, port_info);
3748 	} else if (phy_info && phy_info->phy) {
3749 		if (link_rate ==  MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
3750 			phy_info->phy->negotiated_linkrate =
3751 			    SAS_PHY_DISABLED;
3752 		else if (link_rate ==
3753 		    MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
3754 			phy_info->phy->negotiated_linkrate =
3755 			    SAS_LINK_RATE_FAILED;
3756 		else {
3757 			phy_info->phy->negotiated_linkrate =
3758 			    SAS_LINK_RATE_UNKNOWN;
3759 			if (ioc->device_missing_delay &&
3760 			    mptsas_is_end_device(&phy_info->attached)) {
3761 				struct scsi_device		*sdev;
3762 				VirtDevice			*vdevice;
3763 				u8	channel, id;
3764 				id = phy_info->attached.id;
3765 				channel = phy_info->attached.channel;
3766 				devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3767 				"Link down for fw_id %d:fw_channel %d\n",
3768 				    ioc->name, phy_info->attached.id,
3769 				    phy_info->attached.channel));
3770 
3771 				shost_for_each_device(sdev, ioc->sh) {
3772 					vdevice = sdev->hostdata;
3773 					if ((vdevice == NULL) ||
3774 						(vdevice->vtarget == NULL))
3775 						continue;
3776 					if ((vdevice->vtarget->tflags &
3777 					    MPT_TARGET_FLAGS_RAID_COMPONENT ||
3778 					    vdevice->vtarget->raidVolume))
3779 						continue;
3780 					if (vdevice->vtarget->id == id &&
3781 						vdevice->vtarget->channel ==
3782 						channel)
3783 						devtprintk(ioc,
3784 						printk(MYIOC_s_DEBUG_FMT
3785 						"SDEV OUTSTANDING CMDS"
3786 						"%d\n", ioc->name,
3787 						scsi_device_busy(sdev)));
3788 				}
3789 
3790 			}
3791 		}
3792 	}
3793  out:
3794 	mptsas_free_fw_event(ioc, fw_event);
3795 }
3796 
3797 static void
mptsas_not_responding_devices(MPT_ADAPTER * ioc)3798 mptsas_not_responding_devices(MPT_ADAPTER *ioc)
3799 {
3800 	struct mptsas_portinfo buffer, *port_info;
3801 	struct mptsas_device_info	*sas_info;
3802 	struct mptsas_devinfo sas_device;
3803 	u32	handle;
3804 	VirtTarget *vtarget = NULL;
3805 	struct mptsas_phyinfo *phy_info;
3806 	u8 found_expander;
3807 	int retval, retry_count;
3808 	unsigned long flags;
3809 
3810 	mpt_findImVolumes(ioc);
3811 
3812 	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3813 	if (ioc->ioc_reset_in_progress) {
3814 		dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3815 		   "%s: exiting due to a parallel reset \n", ioc->name,
3816 		    __func__));
3817 		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3818 		return;
3819 	}
3820 	spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3821 
3822 	/* devices, logical volumes */
3823 	mutex_lock(&ioc->sas_device_info_mutex);
3824  redo_device_scan:
3825 	list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
3826 		if (sas_info->is_cached)
3827 			continue;
3828 		if (!sas_info->is_logical_volume) {
3829 			sas_device.handle = 0;
3830 			retry_count = 0;
3831 retry_page:
3832 			retval = mptsas_sas_device_pg0(ioc, &sas_device,
3833 				(MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID
3834 				<< MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3835 				(sas_info->fw.channel << 8) +
3836 				sas_info->fw.id);
3837 
3838 			if (sas_device.handle)
3839 				continue;
3840 			if (retval == -EBUSY) {
3841 				spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3842 				if (ioc->ioc_reset_in_progress) {
3843 					dfailprintk(ioc,
3844 					printk(MYIOC_s_DEBUG_FMT
3845 					"%s: exiting due to reset\n",
3846 					ioc->name, __func__));
3847 					spin_unlock_irqrestore
3848 					(&ioc->taskmgmt_lock, flags);
3849 					mutex_unlock(&ioc->
3850 					sas_device_info_mutex);
3851 					return;
3852 				}
3853 				spin_unlock_irqrestore(&ioc->taskmgmt_lock,
3854 				flags);
3855 			}
3856 
3857 			if (retval && (retval != -ENODEV)) {
3858 				if (retry_count < 10) {
3859 					retry_count++;
3860 					goto retry_page;
3861 				} else {
3862 					devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3863 					"%s: Config page retry exceeded retry "
3864 					"count deleting device 0x%llx\n",
3865 					ioc->name, __func__,
3866 					sas_info->sas_address));
3867 				}
3868 			}
3869 
3870 			/* delete device */
3871 			vtarget = mptsas_find_vtarget(ioc,
3872 				sas_info->fw.channel, sas_info->fw.id);
3873 
3874 			if (vtarget)
3875 				vtarget->deleted = 1;
3876 
3877 			phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
3878 					sas_info->sas_address);
3879 
3880 			mptsas_del_end_device(ioc, phy_info);
3881 			goto redo_device_scan;
3882 		} else
3883 			mptsas_volume_delete(ioc, sas_info->fw.id);
3884 	}
3885 	mutex_unlock(&ioc->sas_device_info_mutex);
3886 
3887 	/* expanders */
3888 	mutex_lock(&ioc->sas_topology_mutex);
3889  redo_expander_scan:
3890 	list_for_each_entry(port_info, &ioc->sas_topology, list) {
3891 
3892 		if (!(port_info->phy_info[0].identify.device_info &
3893 		    MPI_SAS_DEVICE_INFO_SMP_TARGET))
3894 			continue;
3895 		found_expander = 0;
3896 		handle = 0xFFFF;
3897 		while (!mptsas_sas_expander_pg0(ioc, &buffer,
3898 		    (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3899 		     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
3900 		    !found_expander) {
3901 
3902 			handle = buffer.phy_info[0].handle;
3903 			if (buffer.phy_info[0].identify.sas_address ==
3904 			    port_info->phy_info[0].identify.sas_address) {
3905 				found_expander = 1;
3906 			}
3907 			kfree(buffer.phy_info);
3908 		}
3909 
3910 		if (!found_expander) {
3911 			mptsas_expander_delete(ioc, port_info, 0);
3912 			goto redo_expander_scan;
3913 		}
3914 	}
3915 	mutex_unlock(&ioc->sas_topology_mutex);
3916 }
3917 
3918 /**
3919  *	mptsas_probe_expanders - adding expanders
3920  *	@ioc: Pointer to MPT_ADAPTER structure
3921  *
3922  **/
3923 static void
mptsas_probe_expanders(MPT_ADAPTER * ioc)3924 mptsas_probe_expanders(MPT_ADAPTER *ioc)
3925 {
3926 	struct mptsas_portinfo buffer, *port_info;
3927 	u32 			handle;
3928 	int i;
3929 
3930 	handle = 0xFFFF;
3931 	while (!mptsas_sas_expander_pg0(ioc, &buffer,
3932 	    (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3933 	     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
3934 
3935 		handle = buffer.phy_info[0].handle;
3936 		port_info = mptsas_find_portinfo_by_sas_address(ioc,
3937 		    buffer.phy_info[0].identify.sas_address);
3938 
3939 		if (port_info) {
3940 			/* refreshing handles */
3941 			for (i = 0; i < buffer.num_phys; i++) {
3942 				port_info->phy_info[i].handle = handle;
3943 				port_info->phy_info[i].identify.handle_parent =
3944 				    buffer.phy_info[0].identify.handle_parent;
3945 			}
3946 			mptsas_expander_refresh(ioc, port_info);
3947 			kfree(buffer.phy_info);
3948 			continue;
3949 		}
3950 
3951 		port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3952 		if (!port_info) {
3953 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3954 			"%s: exit at line=%d\n", ioc->name,
3955 			__func__, __LINE__));
3956 			return;
3957 		}
3958 		port_info->num_phys = buffer.num_phys;
3959 		port_info->phy_info = buffer.phy_info;
3960 		for (i = 0; i < port_info->num_phys; i++)
3961 			port_info->phy_info[i].portinfo = port_info;
3962 		mutex_lock(&ioc->sas_topology_mutex);
3963 		list_add_tail(&port_info->list, &ioc->sas_topology);
3964 		mutex_unlock(&ioc->sas_topology_mutex);
3965 		printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3966 		    "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3967 	    (unsigned long long)buffer.phy_info[0].identify.sas_address);
3968 		mptsas_expander_refresh(ioc, port_info);
3969 	}
3970 }
3971 
3972 static void
mptsas_probe_devices(MPT_ADAPTER * ioc)3973 mptsas_probe_devices(MPT_ADAPTER *ioc)
3974 {
3975 	u16 handle;
3976 	struct mptsas_devinfo sas_device;
3977 	struct mptsas_phyinfo *phy_info;
3978 
3979 	handle = 0xFFFF;
3980 	while (!(mptsas_sas_device_pg0(ioc, &sas_device,
3981 	    MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
3982 
3983 		handle = sas_device.handle;
3984 
3985 		if ((sas_device.device_info &
3986 		     (MPI_SAS_DEVICE_INFO_SSP_TARGET |
3987 		      MPI_SAS_DEVICE_INFO_STP_TARGET |
3988 		      MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
3989 			continue;
3990 
3991 		/* If there is no FW B_T mapping for this device then continue
3992 		 * */
3993 		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
3994 			|| !(sas_device.flags &
3995 			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
3996 			continue;
3997 
3998 		phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
3999 		if (!phy_info)
4000 			continue;
4001 
4002 		if (mptsas_get_rphy(phy_info))
4003 			continue;
4004 
4005 		mptsas_add_end_device(ioc, phy_info);
4006 	}
4007 }
4008 
4009 /**
4010  *	mptsas_scan_sas_topology - scans new SAS topology
4011  *	  (part of probe or rescan)
4012  *	@ioc: Pointer to MPT_ADAPTER structure
4013  *
4014  **/
4015 static void
mptsas_scan_sas_topology(MPT_ADAPTER * ioc)4016 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
4017 {
4018 	struct scsi_device *sdev;
4019 	int i;
4020 
4021 	mptsas_probe_hba_phys(ioc);
4022 	mptsas_probe_expanders(ioc);
4023 	mptsas_probe_devices(ioc);
4024 
4025 	/*
4026 	  Reporting RAID volumes.
4027 	*/
4028 	if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
4029 	    !ioc->raid_data.pIocPg2->NumActiveVolumes)
4030 		return;
4031 	for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4032 		sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4033 		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4034 		if (sdev) {
4035 			scsi_device_put(sdev);
4036 			continue;
4037 		}
4038 		printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4039 		    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4040 		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
4041 		scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4042 		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4043 	}
4044 }
4045 
4046 
4047 static void
mptsas_handle_queue_full_event(struct fw_event_work * fw_event)4048 mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
4049 {
4050 	MPT_ADAPTER *ioc;
4051 	EventDataQueueFull_t *qfull_data;
4052 	struct mptsas_device_info *sas_info;
4053 	struct scsi_device	*sdev;
4054 	int depth;
4055 	int id = -1;
4056 	int channel = -1;
4057 	int fw_id, fw_channel;
4058 	u16 current_depth;
4059 
4060 
4061 	ioc = fw_event->ioc;
4062 	qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
4063 	fw_id = qfull_data->TargetID;
4064 	fw_channel = qfull_data->Bus;
4065 	current_depth = le16_to_cpu(qfull_data->CurrentDepth);
4066 
4067 	/* if hidden raid component, look for the volume id */
4068 	mutex_lock(&ioc->sas_device_info_mutex);
4069 	if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
4070 		list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4071 		    list) {
4072 			if (sas_info->is_cached ||
4073 			    sas_info->is_logical_volume)
4074 				continue;
4075 			if (sas_info->is_hidden_raid_component &&
4076 			    (sas_info->fw.channel == fw_channel &&
4077 			    sas_info->fw.id == fw_id)) {
4078 				id = sas_info->volume_id;
4079 				channel = MPTSAS_RAID_CHANNEL;
4080 				goto out;
4081 			}
4082 		}
4083 	} else {
4084 		list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4085 		    list) {
4086 			if (sas_info->is_cached ||
4087 			    sas_info->is_hidden_raid_component ||
4088 			    sas_info->is_logical_volume)
4089 				continue;
4090 			if (sas_info->fw.channel == fw_channel &&
4091 			    sas_info->fw.id == fw_id) {
4092 				id = sas_info->os.id;
4093 				channel = sas_info->os.channel;
4094 				goto out;
4095 			}
4096 		}
4097 
4098 	}
4099 
4100  out:
4101 	mutex_unlock(&ioc->sas_device_info_mutex);
4102 
4103 	if (id != -1) {
4104 		shost_for_each_device(sdev, ioc->sh) {
4105 			if (sdev->id == id && sdev->channel == channel) {
4106 				if (current_depth > sdev->queue_depth) {
4107 					sdev_printk(KERN_INFO, sdev,
4108 					    "strange observation, the queue "
4109 					    "depth is (%d) meanwhile fw queue "
4110 					    "depth (%d)\n", sdev->queue_depth,
4111 					    current_depth);
4112 					continue;
4113 				}
4114 				depth = scsi_track_queue_full(sdev,
4115 					sdev->queue_depth - 1);
4116 				if (depth > 0)
4117 					sdev_printk(KERN_INFO, sdev,
4118 					"Queue depth reduced to (%d)\n",
4119 					   depth);
4120 				else if (depth < 0)
4121 					sdev_printk(KERN_INFO, sdev,
4122 					"Tagged Command Queueing is being "
4123 					"disabled\n");
4124 				else if (depth == 0)
4125 					sdev_printk(KERN_DEBUG, sdev,
4126 					"Queue depth not changed yet\n");
4127 			}
4128 		}
4129 	}
4130 
4131 	mptsas_free_fw_event(ioc, fw_event);
4132 }
4133 
4134 
4135 static struct mptsas_phyinfo *
mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER * ioc,u64 sas_address)4136 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
4137 {
4138 	struct mptsas_portinfo *port_info;
4139 	struct mptsas_phyinfo *phy_info = NULL;
4140 	int i;
4141 
4142 	mutex_lock(&ioc->sas_topology_mutex);
4143 	list_for_each_entry(port_info, &ioc->sas_topology, list) {
4144 		for (i = 0; i < port_info->num_phys; i++) {
4145 			if (!mptsas_is_end_device(
4146 				&port_info->phy_info[i].attached))
4147 				continue;
4148 			if (port_info->phy_info[i].attached.sas_address
4149 			    != sas_address)
4150 				continue;
4151 			phy_info = &port_info->phy_info[i];
4152 			break;
4153 		}
4154 	}
4155 	mutex_unlock(&ioc->sas_topology_mutex);
4156 	return phy_info;
4157 }
4158 
4159 /**
4160  *	mptsas_find_phyinfo_by_phys_disk_num - find phyinfo for the
4161  *	  specified @phys_disk_num
4162  *	@ioc: Pointer to MPT_ADAPTER structure
4163  *	@phys_disk_num: (hot plug) physical disk number (for RAID support)
4164  *	@channel: channel number
4165  *	@id: Logical Target ID
4166  *
4167  **/
4168 static struct mptsas_phyinfo *
mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER * ioc,u8 phys_disk_num,u8 channel,u8 id)4169 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
4170 	u8 channel, u8 id)
4171 {
4172 	struct mptsas_phyinfo *phy_info = NULL;
4173 	struct mptsas_portinfo *port_info;
4174 	RaidPhysDiskPage1_t *phys_disk = NULL;
4175 	int num_paths;
4176 	u64 sas_address = 0;
4177 	int i;
4178 
4179 	phy_info = NULL;
4180 	if (!ioc->raid_data.pIocPg3)
4181 		return NULL;
4182 	/* dual port support */
4183 	num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
4184 	if (!num_paths)
4185 		goto out;
4186 	phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
4187 	   (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
4188 	if (!phys_disk)
4189 		goto out;
4190 	mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
4191 	for (i = 0; i < num_paths; i++) {
4192 		if ((phys_disk->Path[i].Flags & 1) != 0)
4193 			/* entry no longer valid */
4194 			continue;
4195 		if ((id == phys_disk->Path[i].PhysDiskID) &&
4196 		    (channel == phys_disk->Path[i].PhysDiskBus)) {
4197 			memcpy(&sas_address, &phys_disk->Path[i].WWID,
4198 				sizeof(u64));
4199 			phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4200 					sas_address);
4201 			goto out;
4202 		}
4203 	}
4204 
4205  out:
4206 	kfree(phys_disk);
4207 	if (phy_info)
4208 		return phy_info;
4209 
4210 	/*
4211 	 * Extra code to handle RAID0 case, where the sas_address is not updated
4212 	 * in phys_disk_page_1 when hotswapped
4213 	 */
4214 	mutex_lock(&ioc->sas_topology_mutex);
4215 	list_for_each_entry(port_info, &ioc->sas_topology, list) {
4216 		for (i = 0; i < port_info->num_phys && !phy_info; i++) {
4217 			if (!mptsas_is_end_device(
4218 				&port_info->phy_info[i].attached))
4219 				continue;
4220 			if (port_info->phy_info[i].attached.phys_disk_num == ~0)
4221 				continue;
4222 			if ((port_info->phy_info[i].attached.phys_disk_num ==
4223 			    phys_disk_num) &&
4224 			    (port_info->phy_info[i].attached.id == id) &&
4225 			    (port_info->phy_info[i].attached.channel ==
4226 			     channel))
4227 				phy_info = &port_info->phy_info[i];
4228 		}
4229 	}
4230 	mutex_unlock(&ioc->sas_topology_mutex);
4231 	return phy_info;
4232 }
4233 
4234 static void
mptsas_reprobe_lun(struct scsi_device * sdev,void * data)4235 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
4236 {
4237 	int rc;
4238 
4239 	sdev->no_uld_attach = data ? 1 : 0;
4240 	rc = scsi_device_reprobe(sdev);
4241 }
4242 
4243 static void
mptsas_reprobe_target(struct scsi_target * starget,int uld_attach)4244 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
4245 {
4246 	starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
4247 			mptsas_reprobe_lun);
4248 }
4249 
4250 static void
mptsas_adding_inactive_raid_components(MPT_ADAPTER * ioc,u8 channel,u8 id)4251 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
4252 {
4253 	CONFIGPARMS			cfg;
4254 	ConfigPageHeader_t		hdr;
4255 	dma_addr_t			dma_handle;
4256 	pRaidVolumePage0_t		buffer = NULL;
4257 	RaidPhysDiskPage0_t 		phys_disk;
4258 	int				i;
4259 	struct mptsas_phyinfo	*phy_info;
4260 	struct mptsas_devinfo		sas_device;
4261 
4262 	memset(&cfg, 0 , sizeof(CONFIGPARMS));
4263 	memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
4264 	hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
4265 	cfg.pageAddr = (channel << 8) + id;
4266 	cfg.cfghdr.hdr = &hdr;
4267 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4268 	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
4269 
4270 	if (mpt_config(ioc, &cfg) != 0)
4271 		goto out;
4272 
4273 	if (!hdr.PageLength)
4274 		goto out;
4275 
4276 	buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
4277 				    &dma_handle, GFP_KERNEL);
4278 
4279 	if (!buffer)
4280 		goto out;
4281 
4282 	cfg.physAddr = dma_handle;
4283 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4284 
4285 	if (mpt_config(ioc, &cfg) != 0)
4286 		goto out;
4287 
4288 	if (!(buffer->VolumeStatus.Flags &
4289 	    MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
4290 		goto out;
4291 
4292 	if (!buffer->NumPhysDisks)
4293 		goto out;
4294 
4295 	for (i = 0; i < buffer->NumPhysDisks; i++) {
4296 
4297 		if (mpt_raid_phys_disk_pg0(ioc,
4298 		    buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
4299 			continue;
4300 
4301 		if (mptsas_sas_device_pg0(ioc, &sas_device,
4302 		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4303 		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4304 			(phys_disk.PhysDiskBus << 8) +
4305 			phys_disk.PhysDiskID))
4306 			continue;
4307 
4308 		/* If there is no FW B_T mapping for this device then continue
4309 		 * */
4310 		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4311 			|| !(sas_device.flags &
4312 			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4313 			continue;
4314 
4315 
4316 		phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4317 		    sas_device.sas_address);
4318 		mptsas_add_end_device(ioc, phy_info);
4319 	}
4320 
4321  out:
4322 	if (buffer)
4323 		dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
4324 				  buffer, dma_handle);
4325 }
4326 /*
4327  * Work queue thread to handle SAS hotplug events
4328  */
4329 static void
mptsas_hotplug_work(MPT_ADAPTER * ioc,struct fw_event_work * fw_event,struct mptsas_hotplug_event * hot_plug_info)4330 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
4331     struct mptsas_hotplug_event *hot_plug_info)
4332 {
4333 	struct mptsas_phyinfo *phy_info;
4334 	struct scsi_target * starget;
4335 	struct mptsas_devinfo sas_device;
4336 	VirtTarget *vtarget;
4337 	int i;
4338 	struct mptsas_portinfo *port_info;
4339 
4340 	switch (hot_plug_info->event_type) {
4341 
4342 	case MPTSAS_ADD_PHYSDISK:
4343 
4344 		if (!ioc->raid_data.pIocPg2)
4345 			break;
4346 
4347 		for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4348 			if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
4349 			    hot_plug_info->id) {
4350 				printk(MYIOC_s_WARN_FMT "firmware bug: unable "
4351 				    "to add hidden disk - target_id matches "
4352 				    "volume_id\n", ioc->name);
4353 				mptsas_free_fw_event(ioc, fw_event);
4354 				return;
4355 			}
4356 		}
4357 		mpt_findImVolumes(ioc);
4358 		fallthrough;
4359 
4360 	case MPTSAS_ADD_DEVICE:
4361 		memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
4362 		mptsas_sas_device_pg0(ioc, &sas_device,
4363 		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4364 		    MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4365 		    (hot_plug_info->channel << 8) +
4366 		    hot_plug_info->id);
4367 
4368 		/* If there is no FW B_T mapping for this device then break
4369 		 * */
4370 		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4371 			|| !(sas_device.flags &
4372 			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4373 			break;
4374 
4375 		if (!sas_device.handle)
4376 			return;
4377 
4378 		phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
4379 		/* Device hot plug */
4380 		if (!phy_info) {
4381 			devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4382 				"%s %d HOT PLUG: "
4383 				"parent handle of device %x\n", ioc->name,
4384 				__func__, __LINE__, sas_device.handle_parent));
4385 			port_info = mptsas_find_portinfo_by_handle(ioc,
4386 				sas_device.handle_parent);
4387 
4388 			if (port_info == ioc->hba_port_info)
4389 				mptsas_probe_hba_phys(ioc);
4390 			else if (port_info)
4391 				mptsas_expander_refresh(ioc, port_info);
4392 			else {
4393 				dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4394 					"%s %d port info is NULL\n",
4395 					ioc->name, __func__, __LINE__));
4396 				break;
4397 			}
4398 			phy_info = mptsas_refreshing_device_handles
4399 				(ioc, &sas_device);
4400 		}
4401 
4402 		if (!phy_info) {
4403 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4404 				"%s %d phy info is NULL\n",
4405 				ioc->name, __func__, __LINE__));
4406 			break;
4407 		}
4408 
4409 		if (mptsas_get_rphy(phy_info))
4410 			break;
4411 
4412 		mptsas_add_end_device(ioc, phy_info);
4413 		break;
4414 
4415 	case MPTSAS_DEL_DEVICE:
4416 		phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4417 		    hot_plug_info->sas_address);
4418 		mptsas_del_end_device(ioc, phy_info);
4419 		break;
4420 
4421 	case MPTSAS_DEL_PHYSDISK:
4422 
4423 		mpt_findImVolumes(ioc);
4424 
4425 		phy_info = mptsas_find_phyinfo_by_phys_disk_num(
4426 				ioc, hot_plug_info->phys_disk_num,
4427 				hot_plug_info->channel,
4428 				hot_plug_info->id);
4429 		mptsas_del_end_device(ioc, phy_info);
4430 		break;
4431 
4432 	case MPTSAS_ADD_PHYSDISK_REPROBE:
4433 
4434 		if (mptsas_sas_device_pg0(ioc, &sas_device,
4435 		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4436 		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4437 		    (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4438 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4439 			"%s: fw_id=%d exit at line=%d\n", ioc->name,
4440 				 __func__, hot_plug_info->id, __LINE__));
4441 			break;
4442 		}
4443 
4444 		/* If there is no FW B_T mapping for this device then break
4445 		 * */
4446 		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4447 			|| !(sas_device.flags &
4448 			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4449 			break;
4450 
4451 		phy_info = mptsas_find_phyinfo_by_sas_address(
4452 		    ioc, sas_device.sas_address);
4453 
4454 		if (!phy_info) {
4455 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4456 				"%s: fw_id=%d exit at line=%d\n", ioc->name,
4457 				 __func__, hot_plug_info->id, __LINE__));
4458 			break;
4459 		}
4460 
4461 		starget = mptsas_get_starget(phy_info);
4462 		if (!starget) {
4463 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4464 				"%s: fw_id=%d exit at line=%d\n", ioc->name,
4465 				 __func__, hot_plug_info->id, __LINE__));
4466 			break;
4467 		}
4468 
4469 		vtarget = starget->hostdata;
4470 		if (!vtarget) {
4471 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4472 				"%s: fw_id=%d exit at line=%d\n", ioc->name,
4473 				 __func__, hot_plug_info->id, __LINE__));
4474 			break;
4475 		}
4476 
4477 		mpt_findImVolumes(ioc);
4478 
4479 		starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
4480 		    "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4481 		    ioc->name, hot_plug_info->channel, hot_plug_info->id,
4482 		    hot_plug_info->phys_disk_num, (unsigned long long)
4483 		    sas_device.sas_address);
4484 
4485 		vtarget->id = hot_plug_info->phys_disk_num;
4486 		vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4487 		phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
4488 		mptsas_reprobe_target(starget, 1);
4489 		break;
4490 
4491 	case MPTSAS_DEL_PHYSDISK_REPROBE:
4492 
4493 		if (mptsas_sas_device_pg0(ioc, &sas_device,
4494 		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4495 		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4496 			(hot_plug_info->channel << 8) + hot_plug_info->id)) {
4497 				dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4498 				    "%s: fw_id=%d exit at line=%d\n",
4499 				    ioc->name, __func__,
4500 				    hot_plug_info->id, __LINE__));
4501 			break;
4502 		}
4503 
4504 		/* If there is no FW B_T mapping for this device then break
4505 		 * */
4506 		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4507 			|| !(sas_device.flags &
4508 			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4509 			break;
4510 
4511 		phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4512 				sas_device.sas_address);
4513 		if (!phy_info) {
4514 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4515 			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4516 			 __func__, hot_plug_info->id, __LINE__));
4517 			break;
4518 		}
4519 
4520 		starget = mptsas_get_starget(phy_info);
4521 		if (!starget) {
4522 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4523 			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4524 			 __func__, hot_plug_info->id, __LINE__));
4525 			break;
4526 		}
4527 
4528 		vtarget = starget->hostdata;
4529 		if (!vtarget) {
4530 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4531 			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4532 			 __func__, hot_plug_info->id, __LINE__));
4533 			break;
4534 		}
4535 
4536 		if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
4537 			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4538 			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4539 			 __func__, hot_plug_info->id, __LINE__));
4540 			break;
4541 		}
4542 
4543 		mpt_findImVolumes(ioc);
4544 
4545 		starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
4546 		    " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4547 		    ioc->name, hot_plug_info->channel, hot_plug_info->id,
4548 		    hot_plug_info->phys_disk_num, (unsigned long long)
4549 		    sas_device.sas_address);
4550 
4551 		vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4552 		vtarget->id = hot_plug_info->id;
4553 		phy_info->attached.phys_disk_num = ~0;
4554 		mptsas_reprobe_target(starget, 0);
4555 		mptsas_add_device_component_by_fw(ioc,
4556 		    hot_plug_info->channel, hot_plug_info->id);
4557 		break;
4558 
4559 	case MPTSAS_ADD_RAID:
4560 
4561 		mpt_findImVolumes(ioc);
4562 		printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4563 		    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4564 		    hot_plug_info->id);
4565 		scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4566 		    hot_plug_info->id, 0);
4567 		break;
4568 
4569 	case MPTSAS_DEL_RAID:
4570 
4571 		mpt_findImVolumes(ioc);
4572 		printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4573 		    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4574 		    hot_plug_info->id);
4575 		scsi_remove_device(hot_plug_info->sdev);
4576 		scsi_device_put(hot_plug_info->sdev);
4577 		break;
4578 
4579 	case MPTSAS_ADD_INACTIVE_VOLUME:
4580 
4581 		mpt_findImVolumes(ioc);
4582 		mptsas_adding_inactive_raid_components(ioc,
4583 		    hot_plug_info->channel, hot_plug_info->id);
4584 		break;
4585 
4586 	default:
4587 		break;
4588 	}
4589 
4590 	mptsas_free_fw_event(ioc, fw_event);
4591 }
4592 
4593 static void
mptsas_send_sas_event(struct fw_event_work * fw_event)4594 mptsas_send_sas_event(struct fw_event_work *fw_event)
4595 {
4596 	MPT_ADAPTER *ioc;
4597 	struct mptsas_hotplug_event hot_plug_info;
4598 	EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
4599 	u32 device_info;
4600 	u64 sas_address;
4601 
4602 	ioc = fw_event->ioc;
4603 	sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
4604 	    fw_event->event_data;
4605 	device_info = le32_to_cpu(sas_event_data->DeviceInfo);
4606 
4607 	if ((device_info &
4608 		(MPI_SAS_DEVICE_INFO_SSP_TARGET |
4609 		MPI_SAS_DEVICE_INFO_STP_TARGET |
4610 		MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) {
4611 		mptsas_free_fw_event(ioc, fw_event);
4612 		return;
4613 	}
4614 
4615 	if (sas_event_data->ReasonCode ==
4616 		MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
4617 		mptbase_sas_persist_operation(ioc,
4618 		MPI_SAS_OP_CLEAR_NOT_PRESENT);
4619 		mptsas_free_fw_event(ioc, fw_event);
4620 		return;
4621 	}
4622 
4623 	switch (sas_event_data->ReasonCode) {
4624 	case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
4625 	case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
4626 		memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4627 		hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
4628 		hot_plug_info.channel = sas_event_data->Bus;
4629 		hot_plug_info.id = sas_event_data->TargetID;
4630 		hot_plug_info.phy_id = sas_event_data->PhyNum;
4631 		memcpy(&sas_address, &sas_event_data->SASAddress,
4632 		    sizeof(u64));
4633 		hot_plug_info.sas_address = le64_to_cpu(sas_address);
4634 		hot_plug_info.device_info = device_info;
4635 		if (sas_event_data->ReasonCode &
4636 		    MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
4637 			hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
4638 		else
4639 			hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
4640 		mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4641 		break;
4642 
4643 	case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
4644 		mptbase_sas_persist_operation(ioc,
4645 		    MPI_SAS_OP_CLEAR_NOT_PRESENT);
4646 		mptsas_free_fw_event(ioc, fw_event);
4647 		break;
4648 
4649 	case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
4650 	/* TODO */
4651 	case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
4652 	/* TODO */
4653 	default:
4654 		mptsas_free_fw_event(ioc, fw_event);
4655 		break;
4656 	}
4657 }
4658 
4659 static void
mptsas_send_raid_event(struct fw_event_work * fw_event)4660 mptsas_send_raid_event(struct fw_event_work *fw_event)
4661 {
4662 	MPT_ADAPTER *ioc;
4663 	EVENT_DATA_RAID *raid_event_data;
4664 	struct mptsas_hotplug_event hot_plug_info;
4665 	int status;
4666 	int state;
4667 	struct scsi_device *sdev = NULL;
4668 	VirtDevice *vdevice = NULL;
4669 	RaidPhysDiskPage0_t phys_disk;
4670 
4671 	ioc = fw_event->ioc;
4672 	raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
4673 	status = le32_to_cpu(raid_event_data->SettingsStatus);
4674 	state = (status >> 8) & 0xff;
4675 
4676 	memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4677 	hot_plug_info.id = raid_event_data->VolumeID;
4678 	hot_plug_info.channel = raid_event_data->VolumeBus;
4679 	hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
4680 
4681 	if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
4682 	    raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
4683 	    raid_event_data->ReasonCode ==
4684 	    MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
4685 		sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4686 		    hot_plug_info.id, 0);
4687 		hot_plug_info.sdev = sdev;
4688 		if (sdev)
4689 			vdevice = sdev->hostdata;
4690 	}
4691 
4692 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4693 	    "ReasonCode=%02x\n", ioc->name, __func__,
4694 	    raid_event_data->ReasonCode));
4695 
4696 	switch (raid_event_data->ReasonCode) {
4697 	case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4698 		hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
4699 		break;
4700 	case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4701 		hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
4702 		break;
4703 	case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4704 		switch (state) {
4705 		case MPI_PD_STATE_ONLINE:
4706 		case MPI_PD_STATE_NOT_COMPATIBLE:
4707 			mpt_raid_phys_disk_pg0(ioc,
4708 			    raid_event_data->PhysDiskNum, &phys_disk);
4709 			hot_plug_info.id = phys_disk.PhysDiskID;
4710 			hot_plug_info.channel = phys_disk.PhysDiskBus;
4711 			hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4712 			break;
4713 		case MPI_PD_STATE_FAILED:
4714 		case MPI_PD_STATE_MISSING:
4715 		case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
4716 		case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
4717 		case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
4718 			hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4719 			break;
4720 		default:
4721 			break;
4722 		}
4723 		break;
4724 	case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4725 		if (!sdev)
4726 			break;
4727 		vdevice->vtarget->deleted = 1; /* block IO */
4728 		hot_plug_info.event_type = MPTSAS_DEL_RAID;
4729 		break;
4730 	case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4731 		if (sdev) {
4732 			scsi_device_put(sdev);
4733 			break;
4734 		}
4735 		hot_plug_info.event_type = MPTSAS_ADD_RAID;
4736 		break;
4737 	case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4738 		if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
4739 			if (!sdev)
4740 				break;
4741 			vdevice->vtarget->deleted = 1; /* block IO */
4742 			hot_plug_info.event_type = MPTSAS_DEL_RAID;
4743 			break;
4744 		}
4745 		switch (state) {
4746 		case MPI_RAIDVOL0_STATUS_STATE_FAILED:
4747 		case MPI_RAIDVOL0_STATUS_STATE_MISSING:
4748 			if (!sdev)
4749 				break;
4750 			vdevice->vtarget->deleted = 1; /* block IO */
4751 			hot_plug_info.event_type = MPTSAS_DEL_RAID;
4752 			break;
4753 		case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
4754 		case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
4755 			if (sdev) {
4756 				scsi_device_put(sdev);
4757 				break;
4758 			}
4759 			hot_plug_info.event_type = MPTSAS_ADD_RAID;
4760 			break;
4761 		default:
4762 			break;
4763 		}
4764 		break;
4765 	default:
4766 		break;
4767 	}
4768 
4769 	if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
4770 		mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4771 	else
4772 		mptsas_free_fw_event(ioc, fw_event);
4773 }
4774 
4775 /**
4776  *	mptsas_issue_tm - send mptsas internal tm request
4777  *	@ioc: Pointer to MPT_ADAPTER structure
4778  *	@type: Task Management type
4779  *	@channel: channel number for task management
4780  *	@id: Logical Target ID for reset (if appropriate)
4781  *	@lun: Logical unit for reset (if appropriate)
4782  *	@task_context: Context for the task to be aborted
4783  *	@timeout: timeout for task management control
4784  *	@issue_reset: set to 1 on return if reset is needed, else 0
4785  *
4786  *	Return: 0 on success or -1 on failure.
4787  *
4788  */
4789 static int
mptsas_issue_tm(MPT_ADAPTER * ioc,u8 type,u8 channel,u8 id,u64 lun,int task_context,ulong timeout,u8 * issue_reset)4790 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun,
4791 	int task_context, ulong timeout, u8 *issue_reset)
4792 {
4793 	MPT_FRAME_HDR	*mf;
4794 	SCSITaskMgmt_t	*pScsiTm;
4795 	int		 retval;
4796 	unsigned long	 timeleft;
4797 
4798 	*issue_reset = 0;
4799 	mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
4800 	if (mf == NULL) {
4801 		retval = -1; /* return failure */
4802 		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
4803 		    "msg frames!!\n", ioc->name));
4804 		goto out;
4805 	}
4806 
4807 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
4808 	    "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
4809 	    "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
4810 	     type, timeout, channel, id, (unsigned long long)lun,
4811 	     task_context));
4812 
4813 	pScsiTm = (SCSITaskMgmt_t *) mf;
4814 	memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
4815 	pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4816 	pScsiTm->TaskType = type;
4817 	pScsiTm->MsgFlags = 0;
4818 	pScsiTm->TargetID = id;
4819 	pScsiTm->Bus = channel;
4820 	pScsiTm->ChainOffset = 0;
4821 	pScsiTm->Reserved = 0;
4822 	pScsiTm->Reserved1 = 0;
4823 	pScsiTm->TaskMsgContext = task_context;
4824 	int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
4825 
4826 	INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4827 	CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
4828 	retval = 0;
4829 	mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
4830 
4831 	/* Now wait for the command to complete */
4832 	timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
4833 	    timeout*HZ);
4834 	if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
4835 		retval = -1; /* return failure */
4836 		dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
4837 		    "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
4838 		mpt_free_msg_frame(ioc, mf);
4839 		if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
4840 			goto out;
4841 		*issue_reset = 1;
4842 		goto out;
4843 	}
4844 
4845 	if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
4846 		retval = -1; /* return failure */
4847 		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4848 		    "TaskMgmt request: failed with no reply\n", ioc->name));
4849 		goto out;
4850 	}
4851 
4852  out:
4853 	CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4854 	return retval;
4855 }
4856 
4857 /**
4858  *	mptsas_broadcast_primitive_work - Handle broadcast primitives
4859  *	@fw_event: work queue payload containing info describing the event
4860  *
4861  *	This will be handled in workqueue context.
4862  */
4863 static void
mptsas_broadcast_primitive_work(struct fw_event_work * fw_event)4864 mptsas_broadcast_primitive_work(struct fw_event_work *fw_event)
4865 {
4866 	MPT_ADAPTER *ioc = fw_event->ioc;
4867 	MPT_FRAME_HDR	*mf;
4868 	VirtDevice	*vdevice;
4869 	int			ii;
4870 	struct scsi_cmnd	*sc;
4871 	SCSITaskMgmtReply_t	*pScsiTmReply;
4872 	u8			issue_reset;
4873 	int			task_context;
4874 	u8			channel, id;
4875 	int			 lun;
4876 	u32			 termination_count;
4877 	u32			 query_count;
4878 
4879 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4880 	    "%s - enter\n", ioc->name, __func__));
4881 
4882 	mutex_lock(&ioc->taskmgmt_cmds.mutex);
4883 	if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4884 		mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4885 		mptsas_requeue_fw_event(ioc, fw_event, 1000);
4886 		return;
4887 	}
4888 
4889 	issue_reset = 0;
4890 	termination_count = 0;
4891 	query_count = 0;
4892 	mpt_findImVolumes(ioc);
4893 	pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
4894 
4895 	for (ii = 0; ii < ioc->req_depth; ii++) {
4896 		if (ioc->fw_events_off)
4897 			goto out;
4898 		sc = mptscsih_get_scsi_lookup(ioc, ii);
4899 		if (!sc)
4900 			continue;
4901 		mf = MPT_INDEX_2_MFPTR(ioc, ii);
4902 		if (!mf)
4903 			continue;
4904 		task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
4905 		vdevice = sc->device->hostdata;
4906 		if (!vdevice || !vdevice->vtarget)
4907 			continue;
4908 		if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
4909 			continue; /* skip hidden raid components */
4910 		if (vdevice->vtarget->raidVolume)
4911 			continue; /* skip hidden raid components */
4912 		channel = vdevice->vtarget->channel;
4913 		id = vdevice->vtarget->id;
4914 		lun = vdevice->lun;
4915 		if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
4916 		    channel, id, (u64)lun, task_context, 30, &issue_reset))
4917 			goto out;
4918 		query_count++;
4919 		termination_count +=
4920 		    le32_to_cpu(pScsiTmReply->TerminationCount);
4921 		if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
4922 		    (pScsiTmReply->ResponseCode ==
4923 		    MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4924 		    pScsiTmReply->ResponseCode ==
4925 		    MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4926 			continue;
4927 		if (mptsas_issue_tm(ioc,
4928 		    MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
4929 		    channel, id, (u64)lun, 0, 30, &issue_reset))
4930 			goto out;
4931 		termination_count +=
4932 		    le32_to_cpu(pScsiTmReply->TerminationCount);
4933 	}
4934 
4935  out:
4936 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4937 	    "%s - exit, query_count = %d termination_count = %d\n",
4938 	    ioc->name, __func__, query_count, termination_count));
4939 
4940 	ioc->broadcast_aen_busy = 0;
4941 	mpt_clear_taskmgmt_in_progress_flag(ioc);
4942 	mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4943 
4944 	if (issue_reset) {
4945 		printk(MYIOC_s_WARN_FMT
4946 		       "Issuing Reset from %s!! doorbell=0x%08x\n",
4947 		       ioc->name, __func__, mpt_GetIocState(ioc, 0));
4948 		mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
4949 	}
4950 	mptsas_free_fw_event(ioc, fw_event);
4951 }
4952 
4953 /*
4954  * mptsas_send_ir2_event - handle exposing hidden disk when
4955  * an inactive raid volume is added
4956  *
4957  * @ioc: Pointer to MPT_ADAPTER structure
4958  * @ir2_data
4959  *
4960  */
4961 static void
mptsas_send_ir2_event(struct fw_event_work * fw_event)4962 mptsas_send_ir2_event(struct fw_event_work *fw_event)
4963 {
4964 	MPT_ADAPTER	*ioc;
4965 	struct mptsas_hotplug_event hot_plug_info;
4966 	MPI_EVENT_DATA_IR2	*ir2_data;
4967 	u8 reasonCode;
4968 	RaidPhysDiskPage0_t phys_disk;
4969 
4970 	ioc = fw_event->ioc;
4971 	ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
4972 	reasonCode = ir2_data->ReasonCode;
4973 
4974 	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4975 	    "ReasonCode=%02x\n", ioc->name, __func__, reasonCode));
4976 
4977 	memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4978 	hot_plug_info.id = ir2_data->TargetID;
4979 	hot_plug_info.channel = ir2_data->Bus;
4980 	switch (reasonCode) {
4981 	case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
4982 		hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
4983 		break;
4984 	case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
4985 		hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4986 		hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4987 		break;
4988 	case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
4989 		hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4990 		mpt_raid_phys_disk_pg0(ioc,
4991 		    ir2_data->PhysDiskNum, &phys_disk);
4992 		hot_plug_info.id = phys_disk.PhysDiskID;
4993 		hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4994 		break;
4995 	default:
4996 		mptsas_free_fw_event(ioc, fw_event);
4997 		return;
4998 	}
4999 	mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
5000 }
5001 
5002 static int
mptsas_event_process(MPT_ADAPTER * ioc,EventNotificationReply_t * reply)5003 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
5004 {
5005 	u32 event = le32_to_cpu(reply->Event);
5006 	int event_data_sz;
5007 	struct fw_event_work *fw_event;
5008 	unsigned long delay;
5009 
5010 	if (ioc->bus_type != SAS)
5011 		return 0;
5012 
5013 	/* events turned off due to host reset or driver unloading */
5014 	if (ioc->fw_events_off)
5015 		return 0;
5016 
5017 	delay = msecs_to_jiffies(1);
5018 	switch (event) {
5019 	case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
5020 	{
5021 		EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
5022 		    (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
5023 		if (broadcast_event_data->Primitive !=
5024 		    MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
5025 			return 0;
5026 		if (ioc->broadcast_aen_busy)
5027 			return 0;
5028 		ioc->broadcast_aen_busy = 1;
5029 		break;
5030 	}
5031 	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
5032 	{
5033 		EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
5034 		    (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
5035 		u16	ioc_stat;
5036 		ioc_stat = le16_to_cpu(reply->IOCStatus);
5037 
5038 		if (sas_event_data->ReasonCode ==
5039 		    MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
5040 			mptsas_target_reset_queue(ioc, sas_event_data);
5041 			return 0;
5042 		}
5043 		if (sas_event_data->ReasonCode ==
5044 			MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5045 			ioc->device_missing_delay &&
5046 			(ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
5047 			VirtTarget *vtarget = NULL;
5048 			u8		id, channel;
5049 
5050 			id = sas_event_data->TargetID;
5051 			channel = sas_event_data->Bus;
5052 
5053 			vtarget = mptsas_find_vtarget(ioc, channel, id);
5054 			if (vtarget) {
5055 				devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5056 				    "LogInfo (0x%x) available for "
5057 				   "INTERNAL_DEVICE_RESET"
5058 				   "fw_id %d fw_channel %d\n", ioc->name,
5059 				   le32_to_cpu(reply->IOCLogInfo),
5060 				   id, channel));
5061 				if (vtarget->raidVolume) {
5062 					devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5063 					"Skipping Raid Volume for inDMD\n",
5064 					ioc->name));
5065 				} else {
5066 					devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5067 					"Setting device flag inDMD\n",
5068 					ioc->name));
5069 					vtarget->inDMD = 1;
5070 				}
5071 
5072 			}
5073 
5074 		}
5075 
5076 		break;
5077 	}
5078 	case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
5079 	{
5080 		MpiEventDataSasExpanderStatusChange_t *expander_data =
5081 		    (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
5082 
5083 		if (ioc->old_sas_discovery_protocal)
5084 			return 0;
5085 
5086 		if (expander_data->ReasonCode ==
5087 		    MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
5088 		    ioc->device_missing_delay)
5089 			delay = HZ * ioc->device_missing_delay;
5090 		break;
5091 	}
5092 	case MPI_EVENT_SAS_DISCOVERY:
5093 	{
5094 		u32 discovery_status;
5095 		EventDataSasDiscovery_t *discovery_data =
5096 		    (EventDataSasDiscovery_t *)reply->Data;
5097 
5098 		discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
5099 		ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
5100 		if (ioc->old_sas_discovery_protocal && !discovery_status)
5101 			mptsas_queue_rescan(ioc);
5102 		return 0;
5103 	}
5104 	case MPI_EVENT_INTEGRATED_RAID:
5105 	case MPI_EVENT_PERSISTENT_TABLE_FULL:
5106 	case MPI_EVENT_IR2:
5107 	case MPI_EVENT_SAS_PHY_LINK_STATUS:
5108 	case MPI_EVENT_QUEUE_FULL:
5109 		break;
5110 	default:
5111 		return 0;
5112 	}
5113 
5114 	event_data_sz = ((reply->MsgLength * 4) -
5115 	    offsetof(EventNotificationReply_t, Data));
5116 	fw_event = kzalloc(sizeof(*fw_event) + event_data_sz, GFP_ATOMIC);
5117 	if (!fw_event) {
5118 		printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
5119 		 __func__, __LINE__);
5120 		return 0;
5121 	}
5122 	memcpy(fw_event->event_data, reply->Data, event_data_sz);
5123 	fw_event->event = event;
5124 	fw_event->ioc = ioc;
5125 	mptsas_add_fw_event(ioc, fw_event, delay);
5126 	return 0;
5127 }
5128 
5129 /* Delete a volume when no longer listed in ioc pg2
5130  */
mptsas_volume_delete(MPT_ADAPTER * ioc,u8 id)5131 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
5132 {
5133 	struct scsi_device *sdev;
5134 	int i;
5135 
5136 	sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
5137 	if (!sdev)
5138 		return;
5139 	if (!ioc->raid_data.pIocPg2)
5140 		goto out;
5141 	if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
5142 		goto out;
5143 	for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
5144 		if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
5145 			goto release_sdev;
5146  out:
5147 	printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
5148 	    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id);
5149 	scsi_remove_device(sdev);
5150  release_sdev:
5151 	scsi_device_put(sdev);
5152 }
5153 
5154 static int
mptsas_probe(struct pci_dev * pdev,const struct pci_device_id * id)5155 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5156 {
5157 	struct Scsi_Host	*sh;
5158 	MPT_SCSI_HOST		*hd;
5159 	MPT_ADAPTER 		*ioc;
5160 	unsigned long		 flags;
5161 	int			 ii;
5162 	int			 numSGE = 0;
5163 	int			 scale;
5164 	int			 ioc_cap;
5165 	int			error=0;
5166 	int			r;
5167 
5168 	r = mpt_attach(pdev,id);
5169 	if (r)
5170 		return r;
5171 
5172 	ioc = pci_get_drvdata(pdev);
5173 	mptsas_fw_event_off(ioc);
5174 	ioc->DoneCtx = mptsasDoneCtx;
5175 	ioc->TaskCtx = mptsasTaskCtx;
5176 	ioc->InternalCtx = mptsasInternalCtx;
5177 	ioc->schedule_target_reset = &mptsas_schedule_target_reset;
5178 	ioc->schedule_dead_ioc_flush_running_cmds =
5179 				&mptscsih_flush_running_cmds;
5180 	/*  Added sanity check on readiness of the MPT adapter.
5181 	 */
5182 	if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
5183 		printk(MYIOC_s_WARN_FMT
5184 		  "Skipping because it's not operational!\n",
5185 		  ioc->name);
5186 		error = -ENODEV;
5187 		goto out_mptsas_probe;
5188 	}
5189 
5190 	if (!ioc->active) {
5191 		printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
5192 		  ioc->name);
5193 		error = -ENODEV;
5194 		goto out_mptsas_probe;
5195 	}
5196 
5197 	/*  Sanity check - ensure at least 1 port is INITIATOR capable
5198 	 */
5199 	ioc_cap = 0;
5200 	for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
5201 		if (ioc->pfacts[ii].ProtocolFlags &
5202 				MPI_PORTFACTS_PROTOCOL_INITIATOR)
5203 			ioc_cap++;
5204 	}
5205 
5206 	if (!ioc_cap) {
5207 		printk(MYIOC_s_WARN_FMT
5208 			"Skipping ioc=%p because SCSI Initiator mode "
5209 			"is NOT enabled!\n", ioc->name, ioc);
5210 		return 0;
5211 	}
5212 
5213 	sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
5214 	if (!sh) {
5215 		printk(MYIOC_s_WARN_FMT
5216 			"Unable to register controller with SCSI subsystem\n",
5217 			ioc->name);
5218 		error = -1;
5219 		goto out_mptsas_probe;
5220         }
5221 
5222 	spin_lock_irqsave(&ioc->FreeQlock, flags);
5223 
5224 	/* Attach the SCSI Host to the IOC structure
5225 	 */
5226 	ioc->sh = sh;
5227 
5228 	sh->io_port = 0;
5229 	sh->n_io_port = 0;
5230 	sh->irq = 0;
5231 
5232 	/* set 16 byte cdb's */
5233 	sh->max_cmd_len = 16;
5234 	sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
5235 	sh->max_id = -1;
5236 	sh->max_lun = max_lun;
5237 	sh->transportt = mptsas_transport_template;
5238 
5239 	/* Required entry.
5240 	 */
5241 	sh->unique_id = ioc->id;
5242 
5243 	INIT_LIST_HEAD(&ioc->sas_topology);
5244 	mutex_init(&ioc->sas_topology_mutex);
5245 	mutex_init(&ioc->sas_discovery_mutex);
5246 	mutex_init(&ioc->sas_mgmt.mutex);
5247 	init_completion(&ioc->sas_mgmt.done);
5248 
5249 	/* Verify that we won't exceed the maximum
5250 	 * number of chain buffers
5251 	 * We can optimize:  ZZ = req_sz/sizeof(SGE)
5252 	 * For 32bit SGE's:
5253 	 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
5254 	 *               + (req_sz - 64)/sizeof(SGE)
5255 	 * A slightly different algorithm is required for
5256 	 * 64bit SGEs.
5257 	 */
5258 	scale = ioc->req_sz/ioc->SGE_size;
5259 	if (ioc->sg_addr_size == sizeof(u64)) {
5260 		numSGE = (scale - 1) *
5261 		  (ioc->facts.MaxChainDepth-1) + scale +
5262 		  (ioc->req_sz - 60) / ioc->SGE_size;
5263 	} else {
5264 		numSGE = 1 + (scale - 1) *
5265 		  (ioc->facts.MaxChainDepth-1) + scale +
5266 		  (ioc->req_sz - 64) / ioc->SGE_size;
5267 	}
5268 
5269 	if (numSGE < sh->sg_tablesize) {
5270 		/* Reset this value */
5271 		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5272 		  "Resetting sg_tablesize to %d from %d\n",
5273 		  ioc->name, numSGE, sh->sg_tablesize));
5274 		sh->sg_tablesize = numSGE;
5275 	}
5276 
5277 	if (mpt_loadtime_max_sectors) {
5278 		if (mpt_loadtime_max_sectors < 64 ||
5279 			mpt_loadtime_max_sectors > 8192) {
5280 			printk(MYIOC_s_INFO_FMT "Invalid value passed for"
5281 				"mpt_loadtime_max_sectors %d."
5282 				"Range from 64 to 8192\n", ioc->name,
5283 				mpt_loadtime_max_sectors);
5284 		}
5285 		mpt_loadtime_max_sectors &=  0xFFFFFFFE;
5286 		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5287 			"Resetting max sector to %d from %d\n",
5288 		  ioc->name, mpt_loadtime_max_sectors, sh->max_sectors));
5289 		sh->max_sectors = mpt_loadtime_max_sectors;
5290 	}
5291 
5292 	hd = shost_priv(sh);
5293 	hd->ioc = ioc;
5294 
5295 	/* SCSI needs scsi_cmnd lookup table!
5296 	 * (with size equal to req_depth*PtrSz!)
5297 	 */
5298 	ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
5299 	if (!ioc->ScsiLookup) {
5300 		error = -ENOMEM;
5301 		spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5302 		goto out_mptsas_probe;
5303 	}
5304 	spin_lock_init(&ioc->scsi_lookup_lock);
5305 
5306 	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
5307 		 ioc->name, ioc->ScsiLookup));
5308 
5309 	ioc->sas_data.ptClear = mpt_pt_clear;
5310 
5311 	hd->last_queue_full = 0;
5312 	INIT_LIST_HEAD(&hd->target_reset_list);
5313 	INIT_LIST_HEAD(&ioc->sas_device_info_list);
5314 	mutex_init(&ioc->sas_device_info_mutex);
5315 
5316 	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5317 
5318 	if (ioc->sas_data.ptClear==1) {
5319 		mptbase_sas_persist_operation(
5320 		    ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
5321 	}
5322 
5323 	error = scsi_add_host(sh, &ioc->pcidev->dev);
5324 	if (error) {
5325 		dprintk(ioc, printk(MYIOC_s_ERR_FMT
5326 		  "scsi_add_host failed\n", ioc->name));
5327 		goto out_mptsas_probe;
5328 	}
5329 
5330 	/* older firmware doesn't support expander events */
5331 	if ((ioc->facts.HeaderVersion >> 8) < 0xE)
5332 		ioc->old_sas_discovery_protocal = 1;
5333 	mptsas_scan_sas_topology(ioc);
5334 	mptsas_fw_event_on(ioc);
5335 	return 0;
5336 
5337  out_mptsas_probe:
5338 
5339 	mptscsih_remove(pdev);
5340 	return error;
5341 }
5342 
5343 static void
mptsas_shutdown(struct pci_dev * pdev)5344 mptsas_shutdown(struct pci_dev *pdev)
5345 {
5346 	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5347 
5348 	mptsas_fw_event_off(ioc);
5349 	mptsas_cleanup_fw_event_q(ioc);
5350 }
5351 
mptsas_remove(struct pci_dev * pdev)5352 static void mptsas_remove(struct pci_dev *pdev)
5353 {
5354 	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5355 	struct mptsas_portinfo *p, *n;
5356 	int i;
5357 
5358 	if (!ioc->sh) {
5359 		printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name);
5360 		mpt_detach(pdev);
5361 		return;
5362 	}
5363 
5364 	mptsas_shutdown(pdev);
5365 
5366 	mptsas_del_device_components(ioc);
5367 
5368 	ioc->sas_discovery_ignore_events = 1;
5369 	sas_remove_host(ioc->sh);
5370 
5371 	mutex_lock(&ioc->sas_topology_mutex);
5372 	list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
5373 		list_del(&p->list);
5374 		for (i = 0 ; i < p->num_phys ; i++)
5375 			mptsas_port_delete(ioc, p->phy_info[i].port_details);
5376 
5377 		kfree(p->phy_info);
5378 		kfree(p);
5379 	}
5380 	mutex_unlock(&ioc->sas_topology_mutex);
5381 	ioc->hba_port_info = NULL;
5382 	mptscsih_remove(pdev);
5383 }
5384 
5385 static struct pci_device_id mptsas_pci_table[] = {
5386 	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
5387 		PCI_ANY_ID, PCI_ANY_ID },
5388 	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
5389 		PCI_ANY_ID, PCI_ANY_ID },
5390 	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
5391 		PCI_ANY_ID, PCI_ANY_ID },
5392 	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
5393 		PCI_ANY_ID, PCI_ANY_ID },
5394 	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
5395 		PCI_ANY_ID, PCI_ANY_ID },
5396 	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068_820XELP,
5397 		PCI_ANY_ID, PCI_ANY_ID },
5398 	{0}	/* Terminating entry */
5399 };
5400 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
5401 
5402 
5403 static struct pci_driver mptsas_driver = {
5404 	.name		= "mptsas",
5405 	.id_table	= mptsas_pci_table,
5406 	.probe		= mptsas_probe,
5407 	.remove		= mptsas_remove,
5408 	.shutdown	= mptsas_shutdown,
5409 #ifdef CONFIG_PM
5410 	.suspend	= mptscsih_suspend,
5411 	.resume		= mptscsih_resume,
5412 #endif
5413 };
5414 
5415 static int __init
mptsas_init(void)5416 mptsas_init(void)
5417 {
5418 	int error;
5419 
5420 	show_mptmod_ver(my_NAME, my_VERSION);
5421 
5422 	mptsas_transport_template =
5423 	    sas_attach_transport(&mptsas_transport_functions);
5424 	if (!mptsas_transport_template)
5425 		return -ENODEV;
5426 
5427 	mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER,
5428 	    "mptscsih_io_done");
5429 	mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER,
5430 	    "mptscsih_taskmgmt_complete");
5431 	mptsasInternalCtx =
5432 		mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER,
5433 		    "mptscsih_scandv_complete");
5434 	mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER,
5435 	    "mptsas_mgmt_done");
5436 	mptsasDeviceResetCtx =
5437 		mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER,
5438 		    "mptsas_taskmgmt_complete");
5439 
5440 	mpt_event_register(mptsasDoneCtx, mptsas_event_process);
5441 	mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
5442 
5443 	error = pci_register_driver(&mptsas_driver);
5444 	if (error)
5445 		sas_release_transport(mptsas_transport_template);
5446 
5447 	return error;
5448 }
5449 
5450 static void __exit
mptsas_exit(void)5451 mptsas_exit(void)
5452 {
5453 	pci_unregister_driver(&mptsas_driver);
5454 	sas_release_transport(mptsas_transport_template);
5455 
5456 	mpt_reset_deregister(mptsasDoneCtx);
5457 	mpt_event_deregister(mptsasDoneCtx);
5458 
5459 	mpt_deregister(mptsasMgmtCtx);
5460 	mpt_deregister(mptsasInternalCtx);
5461 	mpt_deregister(mptsasTaskCtx);
5462 	mpt_deregister(mptsasDoneCtx);
5463 	mpt_deregister(mptsasDeviceResetCtx);
5464 }
5465 
5466 module_init(mptsas_init);
5467 module_exit(mptsas_exit);
5468