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_obj(struct mptsas_device_info);
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_obj(struct mptsas_device_info);
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_obj(struct mptsas_portinfo_details);
911 if (!port_details)
912 goto out;
913 port_details->num_phys = 1;
914 port_details->port_info = port_info;
915 if (phy_info->phy_id < 64 )
916 port_details->phy_bitmask |=
917 (1 << phy_info->phy_id);
918 phy_info->sas_port_add_phy=1;
919 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
920 "phy_id=%d sas_address=0x%018llX\n",
921 ioc->name, i, (unsigned long long)sas_address));
922 phy_info->port_details = port_details;
923 }
924
925 if (i == port_info->num_phys - 1)
926 continue;
927 phy_info_cmp = &port_info->phy_info[i + 1];
928 for (j = i + 1 ; j < port_info->num_phys ; j++,
929 phy_info_cmp++) {
930 if (!phy_info_cmp->attached.sas_address)
931 continue;
932 if (sas_address != phy_info_cmp->attached.sas_address)
933 continue;
934 if (phy_info_cmp->port_details == port_details )
935 continue;
936 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
937 "\t\tphy_id=%d sas_address=0x%018llX\n",
938 ioc->name, j, (unsigned long long)
939 phy_info_cmp->attached.sas_address));
940 if (phy_info_cmp->port_details) {
941 port_details->rphy =
942 mptsas_get_rphy(phy_info_cmp);
943 port_details->port =
944 mptsas_get_port(phy_info_cmp);
945 port_details->starget =
946 mptsas_get_starget(phy_info_cmp);
947 port_details->num_phys =
948 phy_info_cmp->port_details->num_phys;
949 if (!phy_info_cmp->port_details->num_phys)
950 kfree(phy_info_cmp->port_details);
951 } else
952 phy_info_cmp->sas_port_add_phy=1;
953 /*
954 * Adding a phy to a port
955 */
956 phy_info_cmp->port_details = port_details;
957 if (phy_info_cmp->phy_id < 64 )
958 port_details->phy_bitmask |=
959 (1 << phy_info_cmp->phy_id);
960 port_details->num_phys++;
961 }
962 }
963
964 out:
965
966 for (i = 0; i < port_info->num_phys; i++) {
967 port_details = port_info->phy_info[i].port_details;
968 if (!port_details)
969 continue;
970 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
971 "%s: [%p]: phy_id=%02d num_phys=%02d "
972 "bitmask=0x%016llX\n", ioc->name, __func__,
973 port_details, i, port_details->num_phys,
974 (unsigned long long)port_details->phy_bitmask));
975 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
976 ioc->name, port_details->port, port_details->rphy));
977 }
978 dsaswideprintk(ioc, printk("\n"));
979 mutex_unlock(&ioc->sas_topology_mutex);
980 }
981
982 /**
983 * mptsas_find_vtarget - find a virtual target device (FC LUN device or
984 * SCSI target device)
985 *
986 * @ioc: Pointer to MPT_ADAPTER structure
987 * @channel: channel number
988 * @id: Logical Target ID
989 *
990 **/
991 static VirtTarget *
mptsas_find_vtarget(MPT_ADAPTER * ioc,u8 channel,u8 id)992 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
993 {
994 struct scsi_device *sdev;
995 VirtDevice *vdevice;
996 VirtTarget *vtarget = NULL;
997
998 shost_for_each_device(sdev, ioc->sh) {
999 vdevice = sdev->hostdata;
1000 if ((vdevice == NULL) ||
1001 (vdevice->vtarget == NULL))
1002 continue;
1003 if ((vdevice->vtarget->tflags &
1004 MPT_TARGET_FLAGS_RAID_COMPONENT ||
1005 vdevice->vtarget->raidVolume))
1006 continue;
1007 if (vdevice->vtarget->id == id &&
1008 vdevice->vtarget->channel == channel)
1009 vtarget = vdevice->vtarget;
1010 }
1011 return vtarget;
1012 }
1013
1014 static void
mptsas_queue_device_delete(MPT_ADAPTER * ioc,MpiEventDataSasDeviceStatusChange_t * sas_event_data)1015 mptsas_queue_device_delete(MPT_ADAPTER *ioc,
1016 MpiEventDataSasDeviceStatusChange_t *sas_event_data)
1017 {
1018 struct fw_event_work *fw_event;
1019
1020 fw_event = kzalloc(sizeof(*fw_event) +
1021 sizeof(MpiEventDataSasDeviceStatusChange_t),
1022 GFP_ATOMIC);
1023 if (!fw_event) {
1024 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1025 ioc->name, __func__, __LINE__);
1026 return;
1027 }
1028 memcpy(fw_event->event_data, sas_event_data,
1029 sizeof(MpiEventDataSasDeviceStatusChange_t));
1030 fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
1031 fw_event->ioc = ioc;
1032 mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1033 }
1034
1035 static void
mptsas_queue_rescan(MPT_ADAPTER * ioc)1036 mptsas_queue_rescan(MPT_ADAPTER *ioc)
1037 {
1038 struct fw_event_work *fw_event;
1039
1040 fw_event = kzalloc_obj(*fw_event, GFP_ATOMIC);
1041 if (!fw_event) {
1042 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1043 ioc->name, __func__, __LINE__);
1044 return;
1045 }
1046 fw_event->event = -1;
1047 fw_event->ioc = ioc;
1048 mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1049 }
1050
1051
1052 /**
1053 * mptsas_target_reset - Issues TARGET_RESET to end device using
1054 * handshaking method
1055 *
1056 * @ioc: Pointer to MPT_ADAPTER structure
1057 * @channel: channel number
1058 * @id: Logical Target ID for reset
1059 *
1060 * Return: (1) success
1061 * (0) failure
1062 *
1063 **/
1064 static int
mptsas_target_reset(MPT_ADAPTER * ioc,u8 channel,u8 id)1065 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
1066 {
1067 MPT_FRAME_HDR *mf;
1068 SCSITaskMgmt_t *pScsiTm;
1069 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
1070 return 0;
1071
1072
1073 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
1074 if (mf == NULL) {
1075 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1076 "%s, no msg frames @%d!!\n", ioc->name,
1077 __func__, __LINE__));
1078 goto out_fail;
1079 }
1080
1081 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1082 ioc->name, mf));
1083
1084 /* Format the Request
1085 */
1086 pScsiTm = (SCSITaskMgmt_t *) mf;
1087 memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
1088 pScsiTm->TargetID = id;
1089 pScsiTm->Bus = channel;
1090 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1091 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
1092 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
1093
1094 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
1095
1096 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1097 "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
1098 ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
1099
1100 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
1101
1102 return 1;
1103
1104 out_fail:
1105
1106 mpt_clear_taskmgmt_in_progress_flag(ioc);
1107 return 0;
1108 }
1109
1110 static void
mptsas_block_io_sdev(struct scsi_device * sdev,void * data)1111 mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
1112 {
1113 scsi_device_set_state(sdev, SDEV_BLOCK);
1114 }
1115
1116 static void
mptsas_block_io_starget(struct scsi_target * starget)1117 mptsas_block_io_starget(struct scsi_target *starget)
1118 {
1119 if (starget)
1120 starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
1121 }
1122
1123 /**
1124 * mptsas_target_reset_queue - queue a target reset
1125 *
1126 * @ioc: Pointer to MPT_ADAPTER structure
1127 * @sas_event_data: SAS Device Status Change Event data
1128 *
1129 * Receive request for TARGET_RESET after receiving a firmware
1130 * event NOT_RESPONDING_EVENT, then put command in link list
1131 * and queue if task_queue already in use.
1132 *
1133 **/
1134 static void
mptsas_target_reset_queue(MPT_ADAPTER * ioc,EVENT_DATA_SAS_DEVICE_STATUS_CHANGE * sas_event_data)1135 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
1136 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
1137 {
1138 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1139 VirtTarget *vtarget = NULL;
1140 struct mptsas_target_reset_event *target_reset_list;
1141 u8 id, channel;
1142
1143 id = sas_event_data->TargetID;
1144 channel = sas_event_data->Bus;
1145
1146 vtarget = mptsas_find_vtarget(ioc, channel, id);
1147 if (vtarget) {
1148 mptsas_block_io_starget(vtarget->starget);
1149 vtarget->deleted = 1; /* block IO */
1150 }
1151
1152 target_reset_list = kzalloc_obj(struct mptsas_target_reset_event,
1153 GFP_ATOMIC);
1154 if (!target_reset_list) {
1155 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1156 "%s, failed to allocate mem @%d..!!\n",
1157 ioc->name, __func__, __LINE__));
1158 return;
1159 }
1160
1161 memcpy(&target_reset_list->sas_event_data, sas_event_data,
1162 sizeof(*sas_event_data));
1163 list_add_tail(&target_reset_list->list, &hd->target_reset_list);
1164
1165 target_reset_list->time_count = jiffies;
1166
1167 if (mptsas_target_reset(ioc, channel, id)) {
1168 target_reset_list->target_reset_issued = 1;
1169 }
1170 }
1171
1172 /**
1173 * mptsas_schedule_target_reset- send pending target reset
1174 * @iocp: per adapter object
1175 *
1176 * This function will delete scheduled target reset from the list and
1177 * try to send next target reset. This will be called from completion
1178 * context of any Task management command.
1179 */
1180
1181 void
mptsas_schedule_target_reset(void * iocp)1182 mptsas_schedule_target_reset(void *iocp)
1183 {
1184 MPT_ADAPTER *ioc = (MPT_ADAPTER *)(iocp);
1185 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1186 struct list_head *head = &hd->target_reset_list;
1187 struct mptsas_target_reset_event *target_reset_list;
1188 u8 id, channel;
1189 /*
1190 * issue target reset to next device in the queue
1191 */
1192
1193 if (list_empty(head))
1194 return;
1195
1196 target_reset_list = list_entry(head->next,
1197 struct mptsas_target_reset_event, list);
1198
1199 id = target_reset_list->sas_event_data.TargetID;
1200 channel = target_reset_list->sas_event_data.Bus;
1201 target_reset_list->time_count = jiffies;
1202
1203 if (mptsas_target_reset(ioc, channel, id))
1204 target_reset_list->target_reset_issued = 1;
1205 return;
1206 }
1207
1208
1209 /**
1210 * mptsas_taskmgmt_complete - complete SAS task management function
1211 * @ioc: Pointer to MPT_ADAPTER structure
1212 * @mf: MPT message frame
1213 * @mr: SCSI Task Management Reply structure ptr (may be %NULL)
1214 *
1215 * Completion for TARGET_RESET after NOT_RESPONDING_EVENT, enable work
1216 * queue to finish off removing device from upper layers, then send next
1217 * TARGET_RESET in the queue.
1218 **/
1219 static int
mptsas_taskmgmt_complete(MPT_ADAPTER * ioc,MPT_FRAME_HDR * mf,MPT_FRAME_HDR * mr)1220 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
1221 {
1222 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1223 struct list_head *head = &hd->target_reset_list;
1224 u8 id, channel;
1225 struct mptsas_target_reset_event *target_reset_list;
1226 SCSITaskMgmtReply_t *pScsiTmReply;
1227
1228 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
1229 "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
1230
1231 pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
1232 if (!pScsiTmReply)
1233 return 0;
1234
1235 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1236 "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
1237 "\ttask_type = 0x%02X, iocstatus = 0x%04X "
1238 "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
1239 "term_cmnds = %d\n", ioc->name,
1240 pScsiTmReply->Bus, pScsiTmReply->TargetID,
1241 pScsiTmReply->TaskType,
1242 le16_to_cpu(pScsiTmReply->IOCStatus),
1243 le32_to_cpu(pScsiTmReply->IOCLogInfo),
1244 pScsiTmReply->ResponseCode,
1245 le32_to_cpu(pScsiTmReply->TerminationCount)));
1246
1247 if (pScsiTmReply->ResponseCode)
1248 mptscsih_taskmgmt_response_code(ioc,
1249 pScsiTmReply->ResponseCode);
1250
1251 if (pScsiTmReply->TaskType ==
1252 MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
1253 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET) {
1254 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
1255 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
1256 memcpy(ioc->taskmgmt_cmds.reply, mr,
1257 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
1258 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
1259 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
1260 complete(&ioc->taskmgmt_cmds.done);
1261 return 1;
1262 }
1263 return 0;
1264 }
1265
1266 mpt_clear_taskmgmt_in_progress_flag(ioc);
1267
1268 if (list_empty(head))
1269 return 1;
1270
1271 target_reset_list = list_entry(head->next,
1272 struct mptsas_target_reset_event, list);
1273
1274 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1275 "TaskMgmt: completed (%d seconds)\n",
1276 ioc->name, jiffies_to_msecs(jiffies -
1277 target_reset_list->time_count)/1000));
1278
1279 id = pScsiTmReply->TargetID;
1280 channel = pScsiTmReply->Bus;
1281 target_reset_list->time_count = jiffies;
1282
1283 /*
1284 * retry target reset
1285 */
1286 if (!target_reset_list->target_reset_issued) {
1287 if (mptsas_target_reset(ioc, channel, id))
1288 target_reset_list->target_reset_issued = 1;
1289 return 1;
1290 }
1291
1292 /*
1293 * enable work queue to remove device from upper layers
1294 */
1295 list_del(&target_reset_list->list);
1296 if (!ioc->fw_events_off)
1297 mptsas_queue_device_delete(ioc,
1298 &target_reset_list->sas_event_data);
1299
1300
1301 ioc->schedule_target_reset(ioc);
1302
1303 return 1;
1304 }
1305
1306 /**
1307 * mptsas_ioc_reset - issue an IOC reset for this reset phase
1308 *
1309 * @ioc: Pointer to MPT_ADAPTER structure
1310 * @reset_phase: id of phase of reset
1311 *
1312 **/
1313 static int
mptsas_ioc_reset(MPT_ADAPTER * ioc,int reset_phase)1314 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1315 {
1316 MPT_SCSI_HOST *hd;
1317 int rc;
1318
1319 rc = mptscsih_ioc_reset(ioc, reset_phase);
1320 if ((ioc->bus_type != SAS) || (!rc))
1321 return rc;
1322
1323 hd = shost_priv(ioc->sh);
1324 if (!hd->ioc)
1325 goto out;
1326
1327 switch (reset_phase) {
1328 case MPT_IOC_SETUP_RESET:
1329 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1330 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
1331 mptsas_fw_event_off(ioc);
1332 break;
1333 case MPT_IOC_PRE_RESET:
1334 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1335 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
1336 break;
1337 case MPT_IOC_POST_RESET:
1338 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1339 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
1340 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
1341 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
1342 complete(&ioc->sas_mgmt.done);
1343 }
1344 mptsas_cleanup_fw_event_q(ioc);
1345 mptsas_queue_rescan(ioc);
1346 break;
1347 default:
1348 break;
1349 }
1350
1351 out:
1352 return rc;
1353 }
1354
1355
1356 /**
1357 * enum device_state - TUR device state
1358 * @DEVICE_RETRY: need to retry the TUR
1359 * @DEVICE_ERROR: TUR return error, don't add device
1360 * @DEVICE_READY: device can be added
1361 *
1362 */
1363 enum device_state{
1364 DEVICE_RETRY,
1365 DEVICE_ERROR,
1366 DEVICE_READY,
1367 };
1368
1369 static int
mptsas_sas_enclosure_pg0(MPT_ADAPTER * ioc,struct mptsas_enclosure * enclosure,u32 form,u32 form_specific)1370 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
1371 u32 form, u32 form_specific)
1372 {
1373 ConfigExtendedPageHeader_t hdr;
1374 CONFIGPARMS cfg;
1375 SasEnclosurePage0_t *buffer;
1376 dma_addr_t dma_handle;
1377 int error;
1378 __le64 le_identifier;
1379
1380 memset(&hdr, 0, sizeof(hdr));
1381 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
1382 hdr.PageNumber = 0;
1383 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1384 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
1385
1386 cfg.cfghdr.ehdr = &hdr;
1387 cfg.physAddr = -1;
1388 cfg.pageAddr = form + form_specific;
1389 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1390 cfg.dir = 0; /* read */
1391 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
1392
1393 error = mpt_config(ioc, &cfg);
1394 if (error)
1395 goto out;
1396 if (!hdr.ExtPageLength) {
1397 error = -ENXIO;
1398 goto out;
1399 }
1400
1401 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4,
1402 &dma_handle, GFP_KERNEL);
1403 if (!buffer) {
1404 error = -ENOMEM;
1405 goto out;
1406 }
1407
1408 cfg.physAddr = dma_handle;
1409 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1410
1411 error = mpt_config(ioc, &cfg);
1412 if (error)
1413 goto out_free_consistent;
1414
1415 /* save config data */
1416 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
1417 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
1418 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
1419 enclosure->flags = le16_to_cpu(buffer->Flags);
1420 enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
1421 enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
1422 enclosure->start_id = buffer->StartTargetID;
1423 enclosure->start_channel = buffer->StartBus;
1424 enclosure->sep_id = buffer->SEPTargetID;
1425 enclosure->sep_channel = buffer->SEPBus;
1426
1427 out_free_consistent:
1428 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer,
1429 dma_handle);
1430 out:
1431 return error;
1432 }
1433
1434 /**
1435 * mptsas_add_end_device - report a new end device to sas transport layer
1436 * @ioc: Pointer to MPT_ADAPTER structure
1437 * @phy_info: describes attached device
1438 *
1439 * return (0) success (1) failure
1440 *
1441 **/
1442 static int
mptsas_add_end_device(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info)1443 mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1444 {
1445 struct sas_rphy *rphy;
1446 struct sas_port *port;
1447 struct sas_identify identify;
1448 char *ds = NULL;
1449 u8 fw_id;
1450
1451 if (!phy_info) {
1452 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1453 "%s: exit at line=%d\n", ioc->name,
1454 __func__, __LINE__));
1455 return 1;
1456 }
1457
1458 fw_id = phy_info->attached.id;
1459
1460 if (mptsas_get_rphy(phy_info)) {
1461 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1462 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1463 __func__, fw_id, __LINE__));
1464 return 2;
1465 }
1466
1467 port = mptsas_get_port(phy_info);
1468 if (!port) {
1469 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1470 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1471 __func__, fw_id, __LINE__));
1472 return 3;
1473 }
1474
1475 if (phy_info->attached.device_info &
1476 MPI_SAS_DEVICE_INFO_SSP_TARGET)
1477 ds = "ssp";
1478 if (phy_info->attached.device_info &
1479 MPI_SAS_DEVICE_INFO_STP_TARGET)
1480 ds = "stp";
1481 if (phy_info->attached.device_info &
1482 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1483 ds = "sata";
1484
1485 printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
1486 " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
1487 phy_info->attached.channel, phy_info->attached.id,
1488 phy_info->attached.phy_id, (unsigned long long)
1489 phy_info->attached.sas_address);
1490
1491 mptsas_parse_device_info(&identify, &phy_info->attached);
1492 rphy = sas_end_device_alloc(port);
1493 if (!rphy) {
1494 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1495 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1496 __func__, fw_id, __LINE__));
1497 return 5; /* non-fatal: an rphy can be added later */
1498 }
1499
1500 rphy->identify = identify;
1501 if (sas_rphy_add(rphy)) {
1502 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1503 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1504 __func__, fw_id, __LINE__));
1505 sas_rphy_free(rphy);
1506 return 6;
1507 }
1508 mptsas_set_rphy(ioc, phy_info, rphy);
1509 return 0;
1510 }
1511
1512 /**
1513 * mptsas_del_end_device - report a deleted end device to sas transport layer
1514 * @ioc: Pointer to MPT_ADAPTER structure
1515 * @phy_info: describes attached device
1516 *
1517 **/
1518 static void
mptsas_del_end_device(MPT_ADAPTER * ioc,struct mptsas_phyinfo * phy_info)1519 mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1520 {
1521 struct sas_rphy *rphy;
1522 struct sas_port *port;
1523 struct mptsas_portinfo *port_info;
1524 struct mptsas_phyinfo *phy_info_parent;
1525 int i;
1526 char *ds = NULL;
1527 u8 fw_id;
1528 u64 sas_address;
1529
1530 if (!phy_info)
1531 return;
1532
1533 fw_id = phy_info->attached.id;
1534 sas_address = phy_info->attached.sas_address;
1535
1536 if (!phy_info->port_details) {
1537 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1538 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1539 __func__, fw_id, __LINE__));
1540 return;
1541 }
1542 rphy = mptsas_get_rphy(phy_info);
1543 if (!rphy) {
1544 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1545 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1546 __func__, fw_id, __LINE__));
1547 return;
1548 }
1549
1550 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_INITIATOR
1551 || phy_info->attached.device_info
1552 & MPI_SAS_DEVICE_INFO_SMP_INITIATOR
1553 || phy_info->attached.device_info
1554 & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1555 ds = "initiator";
1556 if (phy_info->attached.device_info &
1557 MPI_SAS_DEVICE_INFO_SSP_TARGET)
1558 ds = "ssp";
1559 if (phy_info->attached.device_info &
1560 MPI_SAS_DEVICE_INFO_STP_TARGET)
1561 ds = "stp";
1562 if (phy_info->attached.device_info &
1563 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1564 ds = "sata";
1565
1566 dev_printk(KERN_DEBUG, &rphy->dev, MYIOC_s_FMT
1567 "removing %s device: fw_channel %d, fw_id %d, phy %d,"
1568 "sas_addr 0x%llx\n", ioc->name, ds, phy_info->attached.channel,
1569 phy_info->attached.id, phy_info->attached.phy_id,
1570 (unsigned long long) sas_address);
1571
1572 port = mptsas_get_port(phy_info);
1573 if (!port) {
1574 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1575 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1576 __func__, fw_id, __LINE__));
1577 return;
1578 }
1579 port_info = phy_info->portinfo;
1580 phy_info_parent = port_info->phy_info;
1581 for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
1582 if (!phy_info_parent->phy)
1583 continue;
1584 if (phy_info_parent->attached.sas_address !=
1585 sas_address)
1586 continue;
1587 dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
1588 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
1589 ioc->name, phy_info_parent->phy_id,
1590 phy_info_parent->phy);
1591 sas_port_delete_phy(port, phy_info_parent->phy);
1592 }
1593
1594 dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
1595 "delete port %d, sas_addr (0x%llx)\n", ioc->name,
1596 port->port_identifier, (unsigned long long)sas_address);
1597 sas_port_delete(port);
1598 mptsas_set_port(ioc, phy_info, NULL);
1599 mptsas_port_delete(ioc, phy_info->port_details);
1600 }
1601
1602 static struct mptsas_phyinfo *
mptsas_refreshing_device_handles(MPT_ADAPTER * ioc,struct mptsas_devinfo * sas_device)1603 mptsas_refreshing_device_handles(MPT_ADAPTER *ioc,
1604 struct mptsas_devinfo *sas_device)
1605 {
1606 struct mptsas_phyinfo *phy_info;
1607 struct mptsas_portinfo *port_info;
1608 int i;
1609
1610 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
1611 sas_device->sas_address);
1612 if (!phy_info)
1613 goto out;
1614 port_info = phy_info->portinfo;
1615 if (!port_info)
1616 goto out;
1617 mutex_lock(&ioc->sas_topology_mutex);
1618 for (i = 0; i < port_info->num_phys; i++) {
1619 if (port_info->phy_info[i].attached.sas_address !=
1620 sas_device->sas_address)
1621 continue;
1622 port_info->phy_info[i].attached.channel = sas_device->channel;
1623 port_info->phy_info[i].attached.id = sas_device->id;
1624 port_info->phy_info[i].attached.sas_address =
1625 sas_device->sas_address;
1626 port_info->phy_info[i].attached.handle = sas_device->handle;
1627 port_info->phy_info[i].attached.handle_parent =
1628 sas_device->handle_parent;
1629 port_info->phy_info[i].attached.handle_enclosure =
1630 sas_device->handle_enclosure;
1631 }
1632 mutex_unlock(&ioc->sas_topology_mutex);
1633 out:
1634 return phy_info;
1635 }
1636
1637 /**
1638 * mptsas_firmware_event_work - work thread for processing fw events
1639 * @work: work queue payload containing info describing the event
1640 * Context: user
1641 *
1642 */
1643 static void
mptsas_firmware_event_work(struct work_struct * work)1644 mptsas_firmware_event_work(struct work_struct *work)
1645 {
1646 struct fw_event_work *fw_event =
1647 container_of(work, struct fw_event_work, work.work);
1648 MPT_ADAPTER *ioc = fw_event->ioc;
1649
1650 /* special rescan topology handling */
1651 if (fw_event->event == -1) {
1652 if (ioc->in_rescan) {
1653 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1654 "%s: rescan ignored as it is in progress\n",
1655 ioc->name, __func__));
1656 return;
1657 }
1658 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rescan after "
1659 "reset\n", ioc->name, __func__));
1660 ioc->in_rescan = 1;
1661 mptsas_not_responding_devices(ioc);
1662 mptsas_scan_sas_topology(ioc);
1663 ioc->in_rescan = 0;
1664 mptsas_free_fw_event(ioc, fw_event);
1665 mptsas_fw_event_on(ioc);
1666 return;
1667 }
1668
1669 /* events handling turned off during host reset */
1670 if (ioc->fw_events_off) {
1671 mptsas_free_fw_event(ioc, fw_event);
1672 return;
1673 }
1674
1675 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_event=(0x%p), "
1676 "event = (0x%02x)\n", ioc->name, __func__, fw_event,
1677 (fw_event->event & 0xFF)));
1678
1679 switch (fw_event->event) {
1680 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
1681 mptsas_send_sas_event(fw_event);
1682 break;
1683 case MPI_EVENT_INTEGRATED_RAID:
1684 mptsas_send_raid_event(fw_event);
1685 break;
1686 case MPI_EVENT_IR2:
1687 mptsas_send_ir2_event(fw_event);
1688 break;
1689 case MPI_EVENT_PERSISTENT_TABLE_FULL:
1690 mptbase_sas_persist_operation(ioc,
1691 MPI_SAS_OP_CLEAR_NOT_PRESENT);
1692 mptsas_free_fw_event(ioc, fw_event);
1693 break;
1694 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
1695 mptsas_broadcast_primitive_work(fw_event);
1696 break;
1697 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
1698 mptsas_send_expander_event(fw_event);
1699 break;
1700 case MPI_EVENT_SAS_PHY_LINK_STATUS:
1701 mptsas_send_link_status_event(fw_event);
1702 break;
1703 case MPI_EVENT_QUEUE_FULL:
1704 mptsas_handle_queue_full_event(fw_event);
1705 break;
1706 }
1707 }
1708
1709
1710
1711 static int
mptsas_sdev_configure(struct scsi_device * sdev,struct queue_limits * lim)1712 mptsas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)
1713 {
1714 struct Scsi_Host *host = sdev->host;
1715 MPT_SCSI_HOST *hd = shost_priv(host);
1716 MPT_ADAPTER *ioc = hd->ioc;
1717 VirtDevice *vdevice = sdev->hostdata;
1718
1719 if (vdevice->vtarget->deleted) {
1720 sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
1721 vdevice->vtarget->deleted = 0;
1722 }
1723
1724 /*
1725 * RAID volumes placed beyond the last expected port.
1726 * Ignore sending sas mode pages in that case..
1727 */
1728 if (sdev->channel == MPTSAS_RAID_CHANNEL) {
1729 mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
1730 goto out;
1731 }
1732
1733 sas_read_port_mode_page(sdev);
1734
1735 mptsas_add_device_component_starget(ioc, scsi_target(sdev));
1736
1737 out:
1738 return mptscsih_sdev_configure(sdev, lim);
1739 }
1740
1741 static int
mptsas_target_alloc(struct scsi_target * starget)1742 mptsas_target_alloc(struct scsi_target *starget)
1743 {
1744 struct Scsi_Host *host = dev_to_shost(&starget->dev);
1745 MPT_SCSI_HOST *hd = shost_priv(host);
1746 VirtTarget *vtarget;
1747 u8 id, channel;
1748 struct sas_rphy *rphy;
1749 struct mptsas_portinfo *p;
1750 int i;
1751 MPT_ADAPTER *ioc = hd->ioc;
1752
1753 vtarget = kzalloc_obj(VirtTarget);
1754 if (!vtarget)
1755 return -ENOMEM;
1756
1757 vtarget->starget = starget;
1758 vtarget->ioc_id = ioc->id;
1759 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
1760 id = starget->id;
1761 channel = 0;
1762
1763 /*
1764 * RAID volumes placed beyond the last expected port.
1765 */
1766 if (starget->channel == MPTSAS_RAID_CHANNEL) {
1767 if (!ioc->raid_data.pIocPg2) {
1768 kfree(vtarget);
1769 return -ENXIO;
1770 }
1771 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
1772 if (id == ioc->raid_data.pIocPg2->
1773 RaidVolume[i].VolumeID) {
1774 channel = ioc->raid_data.pIocPg2->
1775 RaidVolume[i].VolumeBus;
1776 }
1777 }
1778 vtarget->raidVolume = 1;
1779 goto out;
1780 }
1781
1782 rphy = dev_to_rphy(starget->dev.parent);
1783 mutex_lock(&ioc->sas_topology_mutex);
1784 list_for_each_entry(p, &ioc->sas_topology, list) {
1785 for (i = 0; i < p->num_phys; i++) {
1786 if (p->phy_info[i].attached.sas_address !=
1787 rphy->identify.sas_address)
1788 continue;
1789 id = p->phy_info[i].attached.id;
1790 channel = p->phy_info[i].attached.channel;
1791 mptsas_set_starget(&p->phy_info[i], starget);
1792
1793 /*
1794 * Exposing hidden raid components
1795 */
1796 if (mptscsih_is_phys_disk(ioc, channel, id)) {
1797 id = mptscsih_raid_id_to_num(ioc,
1798 channel, id);
1799 vtarget->tflags |=
1800 MPT_TARGET_FLAGS_RAID_COMPONENT;
1801 p->phy_info[i].attached.phys_disk_num = id;
1802 }
1803 mutex_unlock(&ioc->sas_topology_mutex);
1804 goto out;
1805 }
1806 }
1807 mutex_unlock(&ioc->sas_topology_mutex);
1808
1809 kfree(vtarget);
1810 return -ENXIO;
1811
1812 out:
1813 vtarget->id = id;
1814 vtarget->channel = channel;
1815 starget->hostdata = vtarget;
1816 return 0;
1817 }
1818
1819 static void
mptsas_target_destroy(struct scsi_target * starget)1820 mptsas_target_destroy(struct scsi_target *starget)
1821 {
1822 struct Scsi_Host *host = dev_to_shost(&starget->dev);
1823 MPT_SCSI_HOST *hd = shost_priv(host);
1824 struct sas_rphy *rphy;
1825 struct mptsas_portinfo *p;
1826 int i;
1827 MPT_ADAPTER *ioc = hd->ioc;
1828 VirtTarget *vtarget;
1829
1830 if (!starget->hostdata)
1831 return;
1832
1833 vtarget = starget->hostdata;
1834
1835 mptsas_del_device_component_by_os(ioc, starget->channel,
1836 starget->id);
1837
1838
1839 if (starget->channel == MPTSAS_RAID_CHANNEL)
1840 goto out;
1841
1842 rphy = dev_to_rphy(starget->dev.parent);
1843 list_for_each_entry(p, &ioc->sas_topology, list) {
1844 for (i = 0; i < p->num_phys; i++) {
1845 if (p->phy_info[i].attached.sas_address !=
1846 rphy->identify.sas_address)
1847 continue;
1848
1849 starget_printk(KERN_INFO, starget, MYIOC_s_FMT
1850 "delete device: fw_channel %d, fw_id %d, phy %d, "
1851 "sas_addr 0x%llx\n", ioc->name,
1852 p->phy_info[i].attached.channel,
1853 p->phy_info[i].attached.id,
1854 p->phy_info[i].attached.phy_id, (unsigned long long)
1855 p->phy_info[i].attached.sas_address);
1856
1857 mptsas_set_starget(&p->phy_info[i], NULL);
1858 }
1859 }
1860
1861 out:
1862 vtarget->starget = NULL;
1863 kfree(starget->hostdata);
1864 starget->hostdata = NULL;
1865 }
1866
1867
1868 static int
mptsas_sdev_init(struct scsi_device * sdev)1869 mptsas_sdev_init(struct scsi_device *sdev)
1870 {
1871 struct Scsi_Host *host = sdev->host;
1872 MPT_SCSI_HOST *hd = shost_priv(host);
1873 struct sas_rphy *rphy;
1874 struct mptsas_portinfo *p;
1875 VirtDevice *vdevice;
1876 struct scsi_target *starget;
1877 int i;
1878 MPT_ADAPTER *ioc = hd->ioc;
1879
1880 vdevice = kzalloc_obj(VirtDevice);
1881 if (!vdevice) {
1882 printk(MYIOC_s_ERR_FMT "sdev_init kzalloc(%zd) FAILED!\n",
1883 ioc->name, sizeof(VirtDevice));
1884 return -ENOMEM;
1885 }
1886 starget = scsi_target(sdev);
1887 vdevice->vtarget = starget->hostdata;
1888
1889 if (sdev->channel == MPTSAS_RAID_CHANNEL)
1890 goto out;
1891
1892 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1893 mutex_lock(&ioc->sas_topology_mutex);
1894 list_for_each_entry(p, &ioc->sas_topology, list) {
1895 for (i = 0; i < p->num_phys; i++) {
1896 if (p->phy_info[i].attached.sas_address !=
1897 rphy->identify.sas_address)
1898 continue;
1899 vdevice->lun = sdev->lun;
1900 /*
1901 * Exposing hidden raid components
1902 */
1903 if (mptscsih_is_phys_disk(ioc,
1904 p->phy_info[i].attached.channel,
1905 p->phy_info[i].attached.id))
1906 sdev->no_uld_attach = 1;
1907 mutex_unlock(&ioc->sas_topology_mutex);
1908 goto out;
1909 }
1910 }
1911 mutex_unlock(&ioc->sas_topology_mutex);
1912
1913 kfree(vdevice);
1914 return -ENXIO;
1915
1916 out:
1917 vdevice->vtarget->num_luns++;
1918 sdev->hostdata = vdevice;
1919 return 0;
1920 }
1921
mptsas_qcmd(struct Scsi_Host * shost,struct scsi_cmnd * SCpnt)1922 static enum scsi_qc_status mptsas_qcmd(struct Scsi_Host *shost,
1923 struct scsi_cmnd *SCpnt)
1924 {
1925 MPT_SCSI_HOST *hd;
1926 MPT_ADAPTER *ioc;
1927 VirtDevice *vdevice = SCpnt->device->hostdata;
1928
1929 if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
1930 SCpnt->result = DID_NO_CONNECT << 16;
1931 scsi_done(SCpnt);
1932 return 0;
1933 }
1934
1935 hd = shost_priv(shost);
1936 ioc = hd->ioc;
1937
1938 if (ioc->sas_discovery_quiesce_io)
1939 return SCSI_MLQUEUE_HOST_BUSY;
1940
1941 if (ioc->debug_level & MPT_DEBUG_SCSI)
1942 scsi_print_command(SCpnt);
1943
1944 return mptscsih_qcmd(SCpnt);
1945 }
1946
1947 /**
1948 * mptsas_eh_timed_out - resets the scsi_cmnd timeout
1949 * if the device under question is currently in the
1950 * device removal delay.
1951 * @sc: scsi command that the midlayer is about to time out
1952 *
1953 **/
mptsas_eh_timed_out(struct scsi_cmnd * sc)1954 static enum scsi_timeout_action mptsas_eh_timed_out(struct scsi_cmnd *sc)
1955 {
1956 MPT_SCSI_HOST *hd;
1957 MPT_ADAPTER *ioc;
1958 VirtDevice *vdevice;
1959 enum scsi_timeout_action rc = SCSI_EH_NOT_HANDLED;
1960
1961 hd = shost_priv(sc->device->host);
1962 if (hd == NULL) {
1963 printk(KERN_ERR MYNAM ": %s: Can't locate host! (sc=%p)\n",
1964 __func__, sc);
1965 goto done;
1966 }
1967
1968 ioc = hd->ioc;
1969 if (ioc->bus_type != SAS) {
1970 printk(KERN_ERR MYNAM ": %s: Wrong bus type (sc=%p)\n",
1971 __func__, sc);
1972 goto done;
1973 }
1974
1975 /* In case if IOC is in reset from internal context.
1976 * Do not execute EEH for the same IOC. SML should to reset timer.
1977 */
1978 if (ioc->ioc_reset_in_progress) {
1979 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: ioc is in reset,"
1980 "SML need to reset the timer (sc=%p)\n",
1981 ioc->name, __func__, sc));
1982 rc = SCSI_EH_RESET_TIMER;
1983 }
1984 vdevice = sc->device->hostdata;
1985 if (vdevice && vdevice->vtarget && (vdevice->vtarget->inDMD
1986 || vdevice->vtarget->deleted)) {
1987 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: target removed "
1988 "or in device removal delay (sc=%p)\n",
1989 ioc->name, __func__, sc));
1990 rc = SCSI_EH_RESET_TIMER;
1991 goto done;
1992 }
1993
1994 done:
1995 return rc;
1996 }
1997
1998
1999 static const struct scsi_host_template mptsas_driver_template = {
2000 .module = THIS_MODULE,
2001 .proc_name = "mptsas",
2002 .show_info = mptscsih_show_info,
2003 .name = "MPT SAS Host",
2004 .info = mptscsih_info,
2005 .queuecommand = mptsas_qcmd,
2006 .target_alloc = mptsas_target_alloc,
2007 .sdev_init = mptsas_sdev_init,
2008 .sdev_configure = mptsas_sdev_configure,
2009 .target_destroy = mptsas_target_destroy,
2010 .sdev_destroy = mptscsih_sdev_destroy,
2011 .change_queue_depth = mptscsih_change_queue_depth,
2012 .eh_timed_out = mptsas_eh_timed_out,
2013 .eh_abort_handler = mptscsih_abort,
2014 .eh_device_reset_handler = mptscsih_dev_reset,
2015 .eh_host_reset_handler = mptscsih_host_reset,
2016 .bios_param = mptscsih_bios_param,
2017 .can_queue = MPT_SAS_CAN_QUEUE,
2018 .this_id = -1,
2019 .sg_tablesize = MPT_SCSI_SG_DEPTH,
2020 .max_sectors = 8192,
2021 .cmd_per_lun = 7,
2022 .dma_alignment = 511,
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 = kzalloc_objs(struct mptsas_phyinfo,
2431 port_info->num_phys);
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 = kzalloc_objs(struct mptsas_phyinfo,
2722 port_info->num_phys);
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] __nonstring;
2837 u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN] __nonstring;
2838 u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN] __nonstring;
2839 u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN] __nonstring;
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 memtostr(edev->vendor_id, manufacture_reply->vendor_id);
2968 memtostr(edev->product_id, manufacture_reply->product_id);
2969 memtostr(edev->product_rev, manufacture_reply->product_rev);
2970 edev->level = manufacture_reply->sas_format;
2971 if (manufacture_reply->sas_format) {
2972 memtostr(edev->component_vendor_id,
2973 manufacture_reply->component_vendor_id);
2974 tmp = (u8 *)&manufacture_reply->component_id;
2975 edev->component_id = tmp[0] << 8 | tmp[1];
2976 edev->component_revision_id =
2977 manufacture_reply->component_revision_id;
2978 }
2979 } else {
2980 printk(MYIOC_s_ERR_FMT
2981 "%s: smp passthru reply failed to be returned\n",
2982 ioc->name, __func__);
2983 ret = -ENXIO;
2984 }
2985 out_free:
2986 if (data_out_dma)
2987 dma_free_coherent(&ioc->pcidev->dev, sz, data_out,
2988 data_out_dma);
2989 put_mf:
2990 if (mf)
2991 mpt_free_msg_frame(ioc, mf);
2992 out_unlock:
2993 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2994 mutex_unlock(&ioc->sas_mgmt.mutex);
2995 out:
2996 return ret;
2997 }
2998
2999 static void
mptsas_parse_device_info(struct sas_identify * identify,struct mptsas_devinfo * device_info)3000 mptsas_parse_device_info(struct sas_identify *identify,
3001 struct mptsas_devinfo *device_info)
3002 {
3003 u16 protocols;
3004
3005 identify->sas_address = device_info->sas_address;
3006 identify->phy_identifier = device_info->phy_id;
3007
3008 /*
3009 * Fill in Phy Initiator Port Protocol.
3010 * Bits 6:3, more than one bit can be set, fall through cases.
3011 */
3012 protocols = device_info->device_info & 0x78;
3013 identify->initiator_port_protocols = 0;
3014 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
3015 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
3016 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
3017 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
3018 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
3019 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
3020 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
3021 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
3022
3023 /*
3024 * Fill in Phy Target Port Protocol.
3025 * Bits 10:7, more than one bit can be set, fall through cases.
3026 */
3027 protocols = device_info->device_info & 0x780;
3028 identify->target_port_protocols = 0;
3029 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
3030 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
3031 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
3032 identify->target_port_protocols |= SAS_PROTOCOL_STP;
3033 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
3034 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
3035 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
3036 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
3037
3038 /*
3039 * Fill in Attached device type.
3040 */
3041 switch (device_info->device_info &
3042 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
3043 case MPI_SAS_DEVICE_INFO_NO_DEVICE:
3044 identify->device_type = SAS_PHY_UNUSED;
3045 break;
3046 case MPI_SAS_DEVICE_INFO_END_DEVICE:
3047 identify->device_type = SAS_END_DEVICE;
3048 break;
3049 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
3050 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
3051 break;
3052 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
3053 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
3054 break;
3055 }
3056 }
3057
mptsas_probe_one_phy(struct device * dev,struct mptsas_phyinfo * phy_info,int index,int local)3058 static int mptsas_probe_one_phy(struct device *dev,
3059 struct mptsas_phyinfo *phy_info, int index, int local)
3060 {
3061 MPT_ADAPTER *ioc;
3062 struct sas_phy *phy;
3063 struct sas_port *port;
3064 int error = 0;
3065 VirtTarget *vtarget;
3066
3067 if (!dev) {
3068 error = -ENODEV;
3069 goto out;
3070 }
3071
3072 if (!phy_info->phy) {
3073 phy = sas_phy_alloc(dev, index);
3074 if (!phy) {
3075 error = -ENOMEM;
3076 goto out;
3077 }
3078 } else
3079 phy = phy_info->phy;
3080
3081 mptsas_parse_device_info(&phy->identify, &phy_info->identify);
3082
3083 /*
3084 * Set Negotiated link rate.
3085 */
3086 switch (phy_info->negotiated_link_rate) {
3087 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
3088 phy->negotiated_linkrate = SAS_PHY_DISABLED;
3089 break;
3090 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
3091 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
3092 break;
3093 case MPI_SAS_IOUNIT0_RATE_1_5:
3094 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
3095 break;
3096 case MPI_SAS_IOUNIT0_RATE_3_0:
3097 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
3098 break;
3099 case MPI_SAS_IOUNIT0_RATE_6_0:
3100 phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS;
3101 break;
3102 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
3103 case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
3104 default:
3105 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
3106 break;
3107 }
3108
3109 /*
3110 * Set Max hardware link rate.
3111 */
3112 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3113 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
3114 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3115 break;
3116 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3117 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3118 break;
3119 default:
3120 break;
3121 }
3122
3123 /*
3124 * Set Max programmed link rate.
3125 */
3126 switch (phy_info->programmed_link_rate &
3127 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3128 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
3129 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3130 break;
3131 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3132 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3133 break;
3134 default:
3135 break;
3136 }
3137
3138 /*
3139 * Set Min hardware link rate.
3140 */
3141 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
3142 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
3143 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3144 break;
3145 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3146 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3147 break;
3148 default:
3149 break;
3150 }
3151
3152 /*
3153 * Set Min programmed link rate.
3154 */
3155 switch (phy_info->programmed_link_rate &
3156 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
3157 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
3158 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3159 break;
3160 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3161 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3162 break;
3163 default:
3164 break;
3165 }
3166
3167 if (!phy_info->phy) {
3168
3169 error = sas_phy_add(phy);
3170 if (error) {
3171 sas_phy_free(phy);
3172 goto out;
3173 }
3174 phy_info->phy = phy;
3175 }
3176
3177 if (!phy_info->attached.handle ||
3178 !phy_info->port_details)
3179 goto out;
3180
3181 port = mptsas_get_port(phy_info);
3182 ioc = phy_to_ioc(phy_info->phy);
3183
3184 if (phy_info->sas_port_add_phy) {
3185
3186 if (!port) {
3187 port = sas_port_alloc_num(dev);
3188 if (!port) {
3189 error = -ENOMEM;
3190 goto out;
3191 }
3192 error = sas_port_add(port);
3193 if (error) {
3194 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3195 "%s: exit at line=%d\n", ioc->name,
3196 __func__, __LINE__));
3197 goto out;
3198 }
3199 mptsas_set_port(ioc, phy_info, port);
3200 devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
3201 MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
3202 ioc->name, port->port_identifier,
3203 (unsigned long long)phy_info->
3204 attached.sas_address));
3205 }
3206 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3207 "sas_port_add_phy: phy_id=%d\n",
3208 ioc->name, phy_info->phy_id));
3209 sas_port_add_phy(port, phy_info->phy);
3210 phy_info->sas_port_add_phy = 0;
3211 devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3212 MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
3213 phy_info->phy_id, phy_info->phy));
3214 }
3215 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
3216
3217 struct sas_rphy *rphy;
3218 struct device *parent;
3219 struct sas_identify identify;
3220
3221 parent = dev->parent->parent;
3222 /*
3223 * Let the hotplug_work thread handle processing
3224 * the adding/removing of devices that occur
3225 * after start of day.
3226 */
3227 if (mptsas_is_end_device(&phy_info->attached) &&
3228 phy_info->attached.handle_parent) {
3229 goto out;
3230 }
3231
3232 mptsas_parse_device_info(&identify, &phy_info->attached);
3233 if (scsi_is_host_device(parent)) {
3234 struct mptsas_portinfo *port_info;
3235 int i;
3236
3237 port_info = ioc->hba_port_info;
3238
3239 for (i = 0; i < port_info->num_phys; i++)
3240 if (port_info->phy_info[i].identify.sas_address ==
3241 identify.sas_address) {
3242 sas_port_mark_backlink(port);
3243 goto out;
3244 }
3245
3246 } else if (scsi_is_sas_rphy(parent)) {
3247 struct sas_rphy *parent_rphy = dev_to_rphy(parent);
3248 if (identify.sas_address ==
3249 parent_rphy->identify.sas_address) {
3250 sas_port_mark_backlink(port);
3251 goto out;
3252 }
3253 }
3254
3255 switch (identify.device_type) {
3256 case SAS_END_DEVICE:
3257 rphy = sas_end_device_alloc(port);
3258 break;
3259 case SAS_EDGE_EXPANDER_DEVICE:
3260 case SAS_FANOUT_EXPANDER_DEVICE:
3261 rphy = sas_expander_alloc(port, identify.device_type);
3262 break;
3263 default:
3264 rphy = NULL;
3265 break;
3266 }
3267 if (!rphy) {
3268 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3269 "%s: exit at line=%d\n", ioc->name,
3270 __func__, __LINE__));
3271 goto out;
3272 }
3273
3274 rphy->identify = identify;
3275 error = sas_rphy_add(rphy);
3276 if (error) {
3277 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3278 "%s: exit at line=%d\n", ioc->name,
3279 __func__, __LINE__));
3280 sas_rphy_free(rphy);
3281 goto out;
3282 }
3283 mptsas_set_rphy(ioc, phy_info, rphy);
3284 if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
3285 identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
3286 mptsas_exp_repmanufacture_info(ioc,
3287 identify.sas_address,
3288 rphy_to_expander_device(rphy));
3289 }
3290
3291 /* If the device exists, verify it wasn't previously flagged
3292 as a missing device. If so, clear it */
3293 vtarget = mptsas_find_vtarget(ioc,
3294 phy_info->attached.channel,
3295 phy_info->attached.id);
3296 if (vtarget && vtarget->inDMD) {
3297 printk(KERN_INFO "Device returned, unsetting inDMD\n");
3298 vtarget->inDMD = 0;
3299 }
3300
3301 out:
3302 return error;
3303 }
3304
3305 static int
mptsas_probe_hba_phys(MPT_ADAPTER * ioc)3306 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
3307 {
3308 struct mptsas_portinfo *port_info, *hba;
3309 int error = -ENOMEM, i;
3310
3311 hba = kzalloc_obj(struct mptsas_portinfo);
3312 if (! hba)
3313 goto out;
3314
3315 error = mptsas_sas_io_unit_pg0(ioc, hba);
3316 if (error)
3317 goto out_free_port_info;
3318
3319 mptsas_sas_io_unit_pg1(ioc);
3320 mutex_lock(&ioc->sas_topology_mutex);
3321 port_info = ioc->hba_port_info;
3322 if (!port_info) {
3323 ioc->hba_port_info = port_info = hba;
3324 ioc->hba_port_num_phy = port_info->num_phys;
3325 list_add_tail(&port_info->list, &ioc->sas_topology);
3326 } else {
3327 for (i = 0; i < hba->num_phys; i++) {
3328 port_info->phy_info[i].negotiated_link_rate =
3329 hba->phy_info[i].negotiated_link_rate;
3330 port_info->phy_info[i].handle =
3331 hba->phy_info[i].handle;
3332 port_info->phy_info[i].port_id =
3333 hba->phy_info[i].port_id;
3334 }
3335 kfree(hba->phy_info);
3336 kfree(hba);
3337 hba = NULL;
3338 }
3339 mutex_unlock(&ioc->sas_topology_mutex);
3340 #if defined(CPQ_CIM)
3341 ioc->num_ports = port_info->num_phys;
3342 #endif
3343 for (i = 0; i < port_info->num_phys; i++) {
3344 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
3345 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
3346 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
3347 port_info->phy_info[i].identify.handle =
3348 port_info->phy_info[i].handle;
3349 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
3350 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3351 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3352 port_info->phy_info[i].identify.handle);
3353 if (!ioc->hba_port_sas_addr)
3354 ioc->hba_port_sas_addr =
3355 port_info->phy_info[i].identify.sas_address;
3356 port_info->phy_info[i].identify.phy_id =
3357 port_info->phy_info[i].phy_id = i;
3358 if (port_info->phy_info[i].attached.handle)
3359 mptsas_sas_device_pg0(ioc,
3360 &port_info->phy_info[i].attached,
3361 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3362 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3363 port_info->phy_info[i].attached.handle);
3364 }
3365
3366 mptsas_setup_wide_ports(ioc, port_info);
3367
3368 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3369 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
3370 &port_info->phy_info[i], ioc->sas_index, 1);
3371
3372 return 0;
3373
3374 out_free_port_info:
3375 kfree(hba);
3376 out:
3377 return error;
3378 }
3379
3380 static void
mptsas_expander_refresh(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info)3381 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
3382 {
3383 struct mptsas_portinfo *parent;
3384 struct device *parent_dev;
3385 struct sas_rphy *rphy;
3386 int i;
3387 u64 sas_address; /* expander sas address */
3388 u32 handle;
3389
3390 handle = port_info->phy_info[0].handle;
3391 sas_address = port_info->phy_info[0].identify.sas_address;
3392 for (i = 0; i < port_info->num_phys; i++) {
3393 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
3394 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
3395 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
3396
3397 mptsas_sas_device_pg0(ioc,
3398 &port_info->phy_info[i].identify,
3399 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3400 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3401 port_info->phy_info[i].identify.handle);
3402 port_info->phy_info[i].identify.phy_id =
3403 port_info->phy_info[i].phy_id;
3404
3405 if (port_info->phy_info[i].attached.handle) {
3406 mptsas_sas_device_pg0(ioc,
3407 &port_info->phy_info[i].attached,
3408 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3409 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3410 port_info->phy_info[i].attached.handle);
3411 port_info->phy_info[i].attached.phy_id =
3412 port_info->phy_info[i].phy_id;
3413 }
3414 }
3415
3416 mutex_lock(&ioc->sas_topology_mutex);
3417 parent = mptsas_find_portinfo_by_handle(ioc,
3418 port_info->phy_info[0].identify.handle_parent);
3419 if (!parent) {
3420 mutex_unlock(&ioc->sas_topology_mutex);
3421 return;
3422 }
3423 for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
3424 i++) {
3425 if (parent->phy_info[i].attached.sas_address == sas_address) {
3426 rphy = mptsas_get_rphy(&parent->phy_info[i]);
3427 parent_dev = &rphy->dev;
3428 }
3429 }
3430 mutex_unlock(&ioc->sas_topology_mutex);
3431
3432 mptsas_setup_wide_ports(ioc, port_info);
3433 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3434 mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
3435 ioc->sas_index, 0);
3436 }
3437
3438 static void
mptsas_expander_event_add(MPT_ADAPTER * ioc,MpiEventDataSasExpanderStatusChange_t * expander_data)3439 mptsas_expander_event_add(MPT_ADAPTER *ioc,
3440 MpiEventDataSasExpanderStatusChange_t *expander_data)
3441 {
3442 struct mptsas_portinfo *port_info;
3443 int i;
3444 __le64 sas_address;
3445
3446 port_info = kzalloc_obj(struct mptsas_portinfo);
3447 BUG_ON(!port_info);
3448 port_info->num_phys = (expander_data->NumPhys) ?
3449 expander_data->NumPhys : 1;
3450 port_info->phy_info = kzalloc_objs(struct mptsas_phyinfo,
3451 port_info->num_phys);
3452 BUG_ON(!port_info->phy_info);
3453 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3454 for (i = 0; i < port_info->num_phys; i++) {
3455 port_info->phy_info[i].portinfo = port_info;
3456 port_info->phy_info[i].handle =
3457 le16_to_cpu(expander_data->DevHandle);
3458 port_info->phy_info[i].identify.sas_address =
3459 le64_to_cpu(sas_address);
3460 port_info->phy_info[i].identify.handle_parent =
3461 le16_to_cpu(expander_data->ParentDevHandle);
3462 }
3463
3464 mutex_lock(&ioc->sas_topology_mutex);
3465 list_add_tail(&port_info->list, &ioc->sas_topology);
3466 mutex_unlock(&ioc->sas_topology_mutex);
3467
3468 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3469 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3470 (unsigned long long)sas_address);
3471
3472 mptsas_expander_refresh(ioc, port_info);
3473 }
3474
3475 /**
3476 * mptsas_delete_expander_siblings - remove siblings attached to expander
3477 * @ioc: Pointer to MPT_ADAPTER structure
3478 * @parent: the parent port_info object
3479 * @expander: the expander port_info object
3480 **/
3481 static void
mptsas_delete_expander_siblings(MPT_ADAPTER * ioc,struct mptsas_portinfo * parent,struct mptsas_portinfo * expander)3482 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
3483 *parent, struct mptsas_portinfo *expander)
3484 {
3485 struct mptsas_phyinfo *phy_info;
3486 struct mptsas_portinfo *port_info;
3487 struct sas_rphy *rphy;
3488 int i;
3489
3490 phy_info = expander->phy_info;
3491 for (i = 0; i < expander->num_phys; i++, phy_info++) {
3492 rphy = mptsas_get_rphy(phy_info);
3493 if (!rphy)
3494 continue;
3495 if (rphy->identify.device_type == SAS_END_DEVICE)
3496 mptsas_del_end_device(ioc, phy_info);
3497 }
3498
3499 phy_info = expander->phy_info;
3500 for (i = 0; i < expander->num_phys; i++, phy_info++) {
3501 rphy = mptsas_get_rphy(phy_info);
3502 if (!rphy)
3503 continue;
3504 if (rphy->identify.device_type ==
3505 MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
3506 rphy->identify.device_type ==
3507 MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
3508 port_info = mptsas_find_portinfo_by_sas_address(ioc,
3509 rphy->identify.sas_address);
3510 if (!port_info)
3511 continue;
3512 if (port_info == parent) /* backlink rphy */
3513 continue;
3514 /*
3515 Delete this expander even if the expdevpage is exists
3516 because the parent expander is already deleted
3517 */
3518 mptsas_expander_delete(ioc, port_info, 1);
3519 }
3520 }
3521 }
3522
3523
3524 /**
3525 * mptsas_expander_delete - remove this expander
3526 * @ioc: Pointer to MPT_ADAPTER structure
3527 * @port_info: expander port_info struct
3528 * @force: Flag to forcefully delete the expander
3529 *
3530 **/
3531
mptsas_expander_delete(MPT_ADAPTER * ioc,struct mptsas_portinfo * port_info,u8 force)3532 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
3533 struct mptsas_portinfo *port_info, u8 force)
3534 {
3535
3536 struct mptsas_portinfo *parent;
3537 int i;
3538 u64 expander_sas_address;
3539 struct mptsas_phyinfo *phy_info;
3540 struct mptsas_portinfo buffer;
3541 struct mptsas_portinfo_details *port_details;
3542 struct sas_port *port;
3543
3544 if (!port_info)
3545 return;
3546
3547 /* see if expander is still there before deleting */
3548 mptsas_sas_expander_pg0(ioc, &buffer,
3549 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3550 MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
3551 port_info->phy_info[0].identify.handle);
3552
3553 if (buffer.num_phys) {
3554 kfree(buffer.phy_info);
3555 if (!force)
3556 return;
3557 }
3558
3559
3560 /*
3561 * Obtain the port_info instance to the parent port
3562 */
3563 port_details = NULL;
3564 expander_sas_address =
3565 port_info->phy_info[0].identify.sas_address;
3566 parent = mptsas_find_portinfo_by_handle(ioc,
3567 port_info->phy_info[0].identify.handle_parent);
3568 mptsas_delete_expander_siblings(ioc, parent, port_info);
3569 if (!parent)
3570 goto out;
3571
3572 /*
3573 * Delete rphys in the parent that point
3574 * to this expander.
3575 */
3576 phy_info = parent->phy_info;
3577 port = NULL;
3578 for (i = 0; i < parent->num_phys; i++, phy_info++) {
3579 if (!phy_info->phy)
3580 continue;
3581 if (phy_info->attached.sas_address !=
3582 expander_sas_address)
3583 continue;
3584 if (!port) {
3585 port = mptsas_get_port(phy_info);
3586 port_details = phy_info->port_details;
3587 }
3588 dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3589 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
3590 phy_info->phy_id, phy_info->phy);
3591 sas_port_delete_phy(port, phy_info->phy);
3592 }
3593 if (port) {
3594 dev_printk(KERN_DEBUG, &port->dev,
3595 MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
3596 ioc->name, port->port_identifier,
3597 (unsigned long long)expander_sas_address);
3598 sas_port_delete(port);
3599 mptsas_port_delete(ioc, port_details);
3600 }
3601 out:
3602
3603 printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
3604 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3605 (unsigned long long)expander_sas_address);
3606
3607 /*
3608 * free link
3609 */
3610 list_del(&port_info->list);
3611 kfree(port_info->phy_info);
3612 kfree(port_info);
3613 }
3614
3615
3616 /**
3617 * mptsas_send_expander_event - expanders events
3618 * @fw_event: event data
3619 *
3620 *
3621 * This function handles adding, removing, and refreshing
3622 * device handles within the expander objects.
3623 */
3624 static void
mptsas_send_expander_event(struct fw_event_work * fw_event)3625 mptsas_send_expander_event(struct fw_event_work *fw_event)
3626 {
3627 MPT_ADAPTER *ioc;
3628 MpiEventDataSasExpanderStatusChange_t *expander_data;
3629 struct mptsas_portinfo *port_info;
3630 __le64 sas_address;
3631 int i;
3632
3633 ioc = fw_event->ioc;
3634 expander_data = (MpiEventDataSasExpanderStatusChange_t *)
3635 fw_event->event_data;
3636 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3637 sas_address = le64_to_cpu(sas_address);
3638 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3639
3640 if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
3641 if (port_info) {
3642 for (i = 0; i < port_info->num_phys; i++) {
3643 port_info->phy_info[i].portinfo = port_info;
3644 port_info->phy_info[i].handle =
3645 le16_to_cpu(expander_data->DevHandle);
3646 port_info->phy_info[i].identify.sas_address =
3647 le64_to_cpu(sas_address);
3648 port_info->phy_info[i].identify.handle_parent =
3649 le16_to_cpu(expander_data->ParentDevHandle);
3650 }
3651 mptsas_expander_refresh(ioc, port_info);
3652 } else if (!port_info && expander_data->NumPhys)
3653 mptsas_expander_event_add(ioc, expander_data);
3654 } else if (expander_data->ReasonCode ==
3655 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
3656 mptsas_expander_delete(ioc, port_info, 0);
3657
3658 mptsas_free_fw_event(ioc, fw_event);
3659 }
3660
3661
3662 /**
3663 * mptsas_expander_add - adds a newly discovered expander
3664 * @ioc: Pointer to MPT_ADAPTER structure
3665 * @handle: device handle
3666 *
3667 */
3668 static struct mptsas_portinfo *
mptsas_expander_add(MPT_ADAPTER * ioc,u16 handle)3669 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
3670 {
3671 struct mptsas_portinfo buffer, *port_info;
3672 int i;
3673
3674 if ((mptsas_sas_expander_pg0(ioc, &buffer,
3675 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3676 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
3677 return NULL;
3678
3679 port_info = kzalloc_obj(struct mptsas_portinfo);
3680 if (!port_info) {
3681 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3682 "%s: exit at line=%d\n", ioc->name,
3683 __func__, __LINE__));
3684 return NULL;
3685 }
3686 port_info->num_phys = buffer.num_phys;
3687 port_info->phy_info = buffer.phy_info;
3688 for (i = 0; i < port_info->num_phys; i++)
3689 port_info->phy_info[i].portinfo = port_info;
3690 mutex_lock(&ioc->sas_topology_mutex);
3691 list_add_tail(&port_info->list, &ioc->sas_topology);
3692 mutex_unlock(&ioc->sas_topology_mutex);
3693 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3694 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3695 (unsigned long long)buffer.phy_info[0].identify.sas_address);
3696 mptsas_expander_refresh(ioc, port_info);
3697 return port_info;
3698 }
3699
3700 static void
mptsas_send_link_status_event(struct fw_event_work * fw_event)3701 mptsas_send_link_status_event(struct fw_event_work *fw_event)
3702 {
3703 MPT_ADAPTER *ioc;
3704 MpiEventDataSasPhyLinkStatus_t *link_data;
3705 struct mptsas_portinfo *port_info;
3706 struct mptsas_phyinfo *phy_info = NULL;
3707 __le64 sas_address;
3708 u8 phy_num;
3709 u8 link_rate;
3710
3711 ioc = fw_event->ioc;
3712 link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
3713
3714 memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
3715 sas_address = le64_to_cpu(sas_address);
3716 link_rate = link_data->LinkRates >> 4;
3717 phy_num = link_data->PhyNum;
3718
3719 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3720 if (port_info) {
3721 phy_info = &port_info->phy_info[phy_num];
3722 if (phy_info)
3723 phy_info->negotiated_link_rate = link_rate;
3724 }
3725
3726 if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
3727 link_rate == MPI_SAS_IOUNIT0_RATE_3_0 ||
3728 link_rate == MPI_SAS_IOUNIT0_RATE_6_0) {
3729
3730 if (!port_info) {
3731 if (ioc->old_sas_discovery_protocal) {
3732 port_info = mptsas_expander_add(ioc,
3733 le16_to_cpu(link_data->DevHandle));
3734 if (port_info)
3735 goto out;
3736 }
3737 goto out;
3738 }
3739
3740 if (port_info == ioc->hba_port_info)
3741 mptsas_probe_hba_phys(ioc);
3742 else
3743 mptsas_expander_refresh(ioc, port_info);
3744 } else if (phy_info && phy_info->phy) {
3745 if (link_rate == MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
3746 phy_info->phy->negotiated_linkrate =
3747 SAS_PHY_DISABLED;
3748 else if (link_rate ==
3749 MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
3750 phy_info->phy->negotiated_linkrate =
3751 SAS_LINK_RATE_FAILED;
3752 else {
3753 phy_info->phy->negotiated_linkrate =
3754 SAS_LINK_RATE_UNKNOWN;
3755 if (ioc->device_missing_delay &&
3756 mptsas_is_end_device(&phy_info->attached)) {
3757 struct scsi_device *sdev;
3758 VirtDevice *vdevice;
3759 u8 channel, id;
3760 id = phy_info->attached.id;
3761 channel = phy_info->attached.channel;
3762 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3763 "Link down for fw_id %d:fw_channel %d\n",
3764 ioc->name, phy_info->attached.id,
3765 phy_info->attached.channel));
3766
3767 shost_for_each_device(sdev, ioc->sh) {
3768 vdevice = sdev->hostdata;
3769 if ((vdevice == NULL) ||
3770 (vdevice->vtarget == NULL))
3771 continue;
3772 if ((vdevice->vtarget->tflags &
3773 MPT_TARGET_FLAGS_RAID_COMPONENT ||
3774 vdevice->vtarget->raidVolume))
3775 continue;
3776 if (vdevice->vtarget->id == id &&
3777 vdevice->vtarget->channel ==
3778 channel)
3779 devtprintk(ioc,
3780 printk(MYIOC_s_DEBUG_FMT
3781 "SDEV OUTSTANDING CMDS"
3782 "%d\n", ioc->name,
3783 scsi_device_busy(sdev)));
3784 }
3785
3786 }
3787 }
3788 }
3789 out:
3790 mptsas_free_fw_event(ioc, fw_event);
3791 }
3792
3793 static void
mptsas_not_responding_devices(MPT_ADAPTER * ioc)3794 mptsas_not_responding_devices(MPT_ADAPTER *ioc)
3795 {
3796 struct mptsas_portinfo buffer, *port_info;
3797 struct mptsas_device_info *sas_info;
3798 struct mptsas_devinfo sas_device;
3799 u32 handle;
3800 VirtTarget *vtarget = NULL;
3801 struct mptsas_phyinfo *phy_info;
3802 u8 found_expander;
3803 int retval, retry_count;
3804 unsigned long flags;
3805
3806 mpt_findImVolumes(ioc);
3807
3808 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3809 if (ioc->ioc_reset_in_progress) {
3810 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3811 "%s: exiting due to a parallel reset \n", ioc->name,
3812 __func__));
3813 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3814 return;
3815 }
3816 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3817
3818 /* devices, logical volumes */
3819 mutex_lock(&ioc->sas_device_info_mutex);
3820 redo_device_scan:
3821 list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
3822 if (sas_info->is_cached)
3823 continue;
3824 if (!sas_info->is_logical_volume) {
3825 sas_device.handle = 0;
3826 retry_count = 0;
3827 retry_page:
3828 retval = mptsas_sas_device_pg0(ioc, &sas_device,
3829 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID
3830 << MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3831 (sas_info->fw.channel << 8) +
3832 sas_info->fw.id);
3833
3834 if (sas_device.handle)
3835 continue;
3836 if (retval == -EBUSY) {
3837 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3838 if (ioc->ioc_reset_in_progress) {
3839 dfailprintk(ioc,
3840 printk(MYIOC_s_DEBUG_FMT
3841 "%s: exiting due to reset\n",
3842 ioc->name, __func__));
3843 spin_unlock_irqrestore
3844 (&ioc->taskmgmt_lock, flags);
3845 mutex_unlock(&ioc->
3846 sas_device_info_mutex);
3847 return;
3848 }
3849 spin_unlock_irqrestore(&ioc->taskmgmt_lock,
3850 flags);
3851 }
3852
3853 if (retval && (retval != -ENODEV)) {
3854 if (retry_count < 10) {
3855 retry_count++;
3856 goto retry_page;
3857 } else {
3858 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3859 "%s: Config page retry exceeded retry "
3860 "count deleting device 0x%llx\n",
3861 ioc->name, __func__,
3862 sas_info->sas_address));
3863 }
3864 }
3865
3866 /* delete device */
3867 vtarget = mptsas_find_vtarget(ioc,
3868 sas_info->fw.channel, sas_info->fw.id);
3869
3870 if (vtarget)
3871 vtarget->deleted = 1;
3872
3873 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
3874 sas_info->sas_address);
3875
3876 mptsas_del_end_device(ioc, phy_info);
3877 goto redo_device_scan;
3878 } else
3879 mptsas_volume_delete(ioc, sas_info->fw.id);
3880 }
3881 mutex_unlock(&ioc->sas_device_info_mutex);
3882
3883 /* expanders */
3884 mutex_lock(&ioc->sas_topology_mutex);
3885 redo_expander_scan:
3886 list_for_each_entry(port_info, &ioc->sas_topology, list) {
3887
3888 if (!(port_info->phy_info[0].identify.device_info &
3889 MPI_SAS_DEVICE_INFO_SMP_TARGET))
3890 continue;
3891 found_expander = 0;
3892 handle = 0xFFFF;
3893 while (!mptsas_sas_expander_pg0(ioc, &buffer,
3894 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3895 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
3896 !found_expander) {
3897
3898 handle = buffer.phy_info[0].handle;
3899 if (buffer.phy_info[0].identify.sas_address ==
3900 port_info->phy_info[0].identify.sas_address) {
3901 found_expander = 1;
3902 }
3903 kfree(buffer.phy_info);
3904 }
3905
3906 if (!found_expander) {
3907 mptsas_expander_delete(ioc, port_info, 0);
3908 goto redo_expander_scan;
3909 }
3910 }
3911 mutex_unlock(&ioc->sas_topology_mutex);
3912 }
3913
3914 /**
3915 * mptsas_probe_expanders - adding expanders
3916 * @ioc: Pointer to MPT_ADAPTER structure
3917 *
3918 **/
3919 static void
mptsas_probe_expanders(MPT_ADAPTER * ioc)3920 mptsas_probe_expanders(MPT_ADAPTER *ioc)
3921 {
3922 struct mptsas_portinfo buffer, *port_info;
3923 u32 handle;
3924 int i;
3925
3926 handle = 0xFFFF;
3927 while (!mptsas_sas_expander_pg0(ioc, &buffer,
3928 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3929 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
3930
3931 handle = buffer.phy_info[0].handle;
3932 port_info = mptsas_find_portinfo_by_sas_address(ioc,
3933 buffer.phy_info[0].identify.sas_address);
3934
3935 if (port_info) {
3936 /* refreshing handles */
3937 for (i = 0; i < buffer.num_phys; i++) {
3938 port_info->phy_info[i].handle = handle;
3939 port_info->phy_info[i].identify.handle_parent =
3940 buffer.phy_info[0].identify.handle_parent;
3941 }
3942 mptsas_expander_refresh(ioc, port_info);
3943 kfree(buffer.phy_info);
3944 continue;
3945 }
3946
3947 port_info = kzalloc_obj(struct mptsas_portinfo);
3948 if (!port_info) {
3949 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3950 "%s: exit at line=%d\n", ioc->name,
3951 __func__, __LINE__));
3952 return;
3953 }
3954 port_info->num_phys = buffer.num_phys;
3955 port_info->phy_info = buffer.phy_info;
3956 for (i = 0; i < port_info->num_phys; i++)
3957 port_info->phy_info[i].portinfo = port_info;
3958 mutex_lock(&ioc->sas_topology_mutex);
3959 list_add_tail(&port_info->list, &ioc->sas_topology);
3960 mutex_unlock(&ioc->sas_topology_mutex);
3961 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3962 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3963 (unsigned long long)buffer.phy_info[0].identify.sas_address);
3964 mptsas_expander_refresh(ioc, port_info);
3965 }
3966 }
3967
3968 static void
mptsas_probe_devices(MPT_ADAPTER * ioc)3969 mptsas_probe_devices(MPT_ADAPTER *ioc)
3970 {
3971 u16 handle;
3972 struct mptsas_devinfo sas_device;
3973 struct mptsas_phyinfo *phy_info;
3974
3975 handle = 0xFFFF;
3976 while (!(mptsas_sas_device_pg0(ioc, &sas_device,
3977 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
3978
3979 handle = sas_device.handle;
3980
3981 if ((sas_device.device_info &
3982 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
3983 MPI_SAS_DEVICE_INFO_STP_TARGET |
3984 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
3985 continue;
3986
3987 /* If there is no FW B_T mapping for this device then continue
3988 * */
3989 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
3990 || !(sas_device.flags &
3991 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
3992 continue;
3993
3994 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
3995 if (!phy_info)
3996 continue;
3997
3998 if (mptsas_get_rphy(phy_info))
3999 continue;
4000
4001 mptsas_add_end_device(ioc, phy_info);
4002 }
4003 }
4004
4005 /**
4006 * mptsas_scan_sas_topology - scans new SAS topology
4007 * (part of probe or rescan)
4008 * @ioc: Pointer to MPT_ADAPTER structure
4009 *
4010 **/
4011 static void
mptsas_scan_sas_topology(MPT_ADAPTER * ioc)4012 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
4013 {
4014 struct scsi_device *sdev;
4015 int i;
4016
4017 mptsas_probe_hba_phys(ioc);
4018 mptsas_probe_expanders(ioc);
4019 mptsas_probe_devices(ioc);
4020
4021 /*
4022 Reporting RAID volumes.
4023 */
4024 if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
4025 !ioc->raid_data.pIocPg2->NumActiveVolumes)
4026 return;
4027 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4028 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4029 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4030 if (sdev) {
4031 scsi_device_put(sdev);
4032 continue;
4033 }
4034 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4035 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4036 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
4037 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4038 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4039 }
4040 }
4041
4042
4043 static void
mptsas_handle_queue_full_event(struct fw_event_work * fw_event)4044 mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
4045 {
4046 MPT_ADAPTER *ioc;
4047 EventDataQueueFull_t *qfull_data;
4048 struct mptsas_device_info *sas_info;
4049 struct scsi_device *sdev;
4050 int depth;
4051 int id = -1;
4052 int channel = -1;
4053 int fw_id, fw_channel;
4054 u16 current_depth;
4055
4056
4057 ioc = fw_event->ioc;
4058 qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
4059 fw_id = qfull_data->TargetID;
4060 fw_channel = qfull_data->Bus;
4061 current_depth = le16_to_cpu(qfull_data->CurrentDepth);
4062
4063 /* if hidden raid component, look for the volume id */
4064 mutex_lock(&ioc->sas_device_info_mutex);
4065 if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
4066 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4067 list) {
4068 if (sas_info->is_cached ||
4069 sas_info->is_logical_volume)
4070 continue;
4071 if (sas_info->is_hidden_raid_component &&
4072 (sas_info->fw.channel == fw_channel &&
4073 sas_info->fw.id == fw_id)) {
4074 id = sas_info->volume_id;
4075 channel = MPTSAS_RAID_CHANNEL;
4076 goto out;
4077 }
4078 }
4079 } else {
4080 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4081 list) {
4082 if (sas_info->is_cached ||
4083 sas_info->is_hidden_raid_component ||
4084 sas_info->is_logical_volume)
4085 continue;
4086 if (sas_info->fw.channel == fw_channel &&
4087 sas_info->fw.id == fw_id) {
4088 id = sas_info->os.id;
4089 channel = sas_info->os.channel;
4090 goto out;
4091 }
4092 }
4093
4094 }
4095
4096 out:
4097 mutex_unlock(&ioc->sas_device_info_mutex);
4098
4099 if (id != -1) {
4100 shost_for_each_device(sdev, ioc->sh) {
4101 if (sdev->id == id && sdev->channel == channel) {
4102 if (current_depth > sdev->queue_depth) {
4103 sdev_printk(KERN_INFO, sdev,
4104 "strange observation, the queue "
4105 "depth is (%d) meanwhile fw queue "
4106 "depth (%d)\n", sdev->queue_depth,
4107 current_depth);
4108 continue;
4109 }
4110 depth = scsi_track_queue_full(sdev,
4111 sdev->queue_depth - 1);
4112 if (depth > 0)
4113 sdev_printk(KERN_INFO, sdev,
4114 "Queue depth reduced to (%d)\n",
4115 depth);
4116 else if (depth < 0)
4117 sdev_printk(KERN_INFO, sdev,
4118 "Tagged Command Queueing is being "
4119 "disabled\n");
4120 else if (depth == 0)
4121 sdev_printk(KERN_DEBUG, sdev,
4122 "Queue depth not changed yet\n");
4123 }
4124 }
4125 }
4126
4127 mptsas_free_fw_event(ioc, fw_event);
4128 }
4129
4130
4131 static struct mptsas_phyinfo *
mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER * ioc,u64 sas_address)4132 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
4133 {
4134 struct mptsas_portinfo *port_info;
4135 struct mptsas_phyinfo *phy_info = NULL;
4136 int i;
4137
4138 mutex_lock(&ioc->sas_topology_mutex);
4139 list_for_each_entry(port_info, &ioc->sas_topology, list) {
4140 for (i = 0; i < port_info->num_phys; i++) {
4141 if (!mptsas_is_end_device(
4142 &port_info->phy_info[i].attached))
4143 continue;
4144 if (port_info->phy_info[i].attached.sas_address
4145 != sas_address)
4146 continue;
4147 phy_info = &port_info->phy_info[i];
4148 break;
4149 }
4150 }
4151 mutex_unlock(&ioc->sas_topology_mutex);
4152 return phy_info;
4153 }
4154
4155 /**
4156 * mptsas_find_phyinfo_by_phys_disk_num - find phyinfo for the
4157 * specified @phys_disk_num
4158 * @ioc: Pointer to MPT_ADAPTER structure
4159 * @phys_disk_num: (hot plug) physical disk number (for RAID support)
4160 * @channel: channel number
4161 * @id: Logical Target ID
4162 *
4163 **/
4164 static struct mptsas_phyinfo *
mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER * ioc,u8 phys_disk_num,u8 channel,u8 id)4165 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
4166 u8 channel, u8 id)
4167 {
4168 struct mptsas_phyinfo *phy_info = NULL;
4169 struct mptsas_portinfo *port_info;
4170 RaidPhysDiskPage1_t *phys_disk = NULL;
4171 int num_paths;
4172 u64 sas_address = 0;
4173 int i;
4174
4175 phy_info = NULL;
4176 if (!ioc->raid_data.pIocPg3)
4177 return NULL;
4178 /* dual port support */
4179 num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
4180 if (!num_paths)
4181 goto out;
4182 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
4183 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
4184 if (!phys_disk)
4185 goto out;
4186 mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
4187 for (i = 0; i < num_paths; i++) {
4188 if ((phys_disk->Path[i].Flags & 1) != 0)
4189 /* entry no longer valid */
4190 continue;
4191 if ((id == phys_disk->Path[i].PhysDiskID) &&
4192 (channel == phys_disk->Path[i].PhysDiskBus)) {
4193 memcpy(&sas_address, &phys_disk->Path[i].WWID,
4194 sizeof(u64));
4195 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4196 sas_address);
4197 goto out;
4198 }
4199 }
4200
4201 out:
4202 kfree(phys_disk);
4203 if (phy_info)
4204 return phy_info;
4205
4206 /*
4207 * Extra code to handle RAID0 case, where the sas_address is not updated
4208 * in phys_disk_page_1 when hotswapped
4209 */
4210 mutex_lock(&ioc->sas_topology_mutex);
4211 list_for_each_entry(port_info, &ioc->sas_topology, list) {
4212 for (i = 0; i < port_info->num_phys && !phy_info; i++) {
4213 if (!mptsas_is_end_device(
4214 &port_info->phy_info[i].attached))
4215 continue;
4216 if (port_info->phy_info[i].attached.phys_disk_num == ~0)
4217 continue;
4218 if ((port_info->phy_info[i].attached.phys_disk_num ==
4219 phys_disk_num) &&
4220 (port_info->phy_info[i].attached.id == id) &&
4221 (port_info->phy_info[i].attached.channel ==
4222 channel))
4223 phy_info = &port_info->phy_info[i];
4224 }
4225 }
4226 mutex_unlock(&ioc->sas_topology_mutex);
4227 return phy_info;
4228 }
4229
4230 static void
mptsas_reprobe_lun(struct scsi_device * sdev,void * data)4231 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
4232 {
4233 sdev->no_uld_attach = data ? 1 : 0;
4234 WARN_ON(scsi_device_reprobe(sdev));
4235 }
4236
4237 static void
mptsas_reprobe_target(struct scsi_target * starget,int uld_attach)4238 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
4239 {
4240 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
4241 mptsas_reprobe_lun);
4242 }
4243
4244 static void
mptsas_adding_inactive_raid_components(MPT_ADAPTER * ioc,u8 channel,u8 id)4245 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
4246 {
4247 CONFIGPARMS cfg;
4248 ConfigPageHeader_t hdr;
4249 dma_addr_t dma_handle;
4250 pRaidVolumePage0_t buffer = NULL;
4251 RaidPhysDiskPage0_t phys_disk;
4252 int i;
4253 struct mptsas_phyinfo *phy_info;
4254 struct mptsas_devinfo sas_device;
4255
4256 memset(&cfg, 0 , sizeof(CONFIGPARMS));
4257 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
4258 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
4259 cfg.pageAddr = (channel << 8) + id;
4260 cfg.cfghdr.hdr = &hdr;
4261 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4262 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
4263
4264 if (mpt_config(ioc, &cfg) != 0)
4265 goto out;
4266
4267 if (!hdr.PageLength)
4268 goto out;
4269
4270 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
4271 &dma_handle, GFP_KERNEL);
4272
4273 if (!buffer)
4274 goto out;
4275
4276 cfg.physAddr = dma_handle;
4277 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4278
4279 if (mpt_config(ioc, &cfg) != 0)
4280 goto out;
4281
4282 if (!(buffer->VolumeStatus.Flags &
4283 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
4284 goto out;
4285
4286 if (!buffer->NumPhysDisks)
4287 goto out;
4288
4289 for (i = 0; i < buffer->NumPhysDisks; i++) {
4290
4291 if (mpt_raid_phys_disk_pg0(ioc,
4292 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
4293 continue;
4294
4295 if (mptsas_sas_device_pg0(ioc, &sas_device,
4296 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4297 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4298 (phys_disk.PhysDiskBus << 8) +
4299 phys_disk.PhysDiskID))
4300 continue;
4301
4302 /* If there is no FW B_T mapping for this device then continue
4303 * */
4304 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4305 || !(sas_device.flags &
4306 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4307 continue;
4308
4309
4310 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4311 sas_device.sas_address);
4312 mptsas_add_end_device(ioc, phy_info);
4313 }
4314
4315 out:
4316 if (buffer)
4317 dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4,
4318 buffer, dma_handle);
4319 }
4320 /*
4321 * Work queue thread to handle SAS hotplug events
4322 */
4323 static void
mptsas_hotplug_work(MPT_ADAPTER * ioc,struct fw_event_work * fw_event,struct mptsas_hotplug_event * hot_plug_info)4324 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
4325 struct mptsas_hotplug_event *hot_plug_info)
4326 {
4327 struct mptsas_phyinfo *phy_info;
4328 struct scsi_target * starget;
4329 struct mptsas_devinfo sas_device;
4330 VirtTarget *vtarget;
4331 int i;
4332 struct mptsas_portinfo *port_info;
4333
4334 switch (hot_plug_info->event_type) {
4335
4336 case MPTSAS_ADD_PHYSDISK:
4337
4338 if (!ioc->raid_data.pIocPg2)
4339 break;
4340
4341 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4342 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
4343 hot_plug_info->id) {
4344 printk(MYIOC_s_WARN_FMT "firmware bug: unable "
4345 "to add hidden disk - target_id matches "
4346 "volume_id\n", ioc->name);
4347 mptsas_free_fw_event(ioc, fw_event);
4348 return;
4349 }
4350 }
4351 mpt_findImVolumes(ioc);
4352 fallthrough;
4353
4354 case MPTSAS_ADD_DEVICE:
4355 memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
4356 mptsas_sas_device_pg0(ioc, &sas_device,
4357 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4358 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4359 (hot_plug_info->channel << 8) +
4360 hot_plug_info->id);
4361
4362 /* If there is no FW B_T mapping for this device then break
4363 * */
4364 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4365 || !(sas_device.flags &
4366 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4367 break;
4368
4369 if (!sas_device.handle)
4370 return;
4371
4372 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
4373 /* Device hot plug */
4374 if (!phy_info) {
4375 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4376 "%s %d HOT PLUG: "
4377 "parent handle of device %x\n", ioc->name,
4378 __func__, __LINE__, sas_device.handle_parent));
4379 port_info = mptsas_find_portinfo_by_handle(ioc,
4380 sas_device.handle_parent);
4381
4382 if (port_info == ioc->hba_port_info)
4383 mptsas_probe_hba_phys(ioc);
4384 else if (port_info)
4385 mptsas_expander_refresh(ioc, port_info);
4386 else {
4387 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4388 "%s %d port info is NULL\n",
4389 ioc->name, __func__, __LINE__));
4390 break;
4391 }
4392 phy_info = mptsas_refreshing_device_handles
4393 (ioc, &sas_device);
4394 }
4395
4396 if (!phy_info) {
4397 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4398 "%s %d phy info is NULL\n",
4399 ioc->name, __func__, __LINE__));
4400 break;
4401 }
4402
4403 if (mptsas_get_rphy(phy_info))
4404 break;
4405
4406 mptsas_add_end_device(ioc, phy_info);
4407 break;
4408
4409 case MPTSAS_DEL_DEVICE:
4410 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4411 hot_plug_info->sas_address);
4412 mptsas_del_end_device(ioc, phy_info);
4413 break;
4414
4415 case MPTSAS_DEL_PHYSDISK:
4416
4417 mpt_findImVolumes(ioc);
4418
4419 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
4420 ioc, hot_plug_info->phys_disk_num,
4421 hot_plug_info->channel,
4422 hot_plug_info->id);
4423 mptsas_del_end_device(ioc, phy_info);
4424 break;
4425
4426 case MPTSAS_ADD_PHYSDISK_REPROBE:
4427
4428 if (mptsas_sas_device_pg0(ioc, &sas_device,
4429 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4430 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4431 (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4432 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4433 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4434 __func__, hot_plug_info->id, __LINE__));
4435 break;
4436 }
4437
4438 /* If there is no FW B_T mapping for this device then break
4439 * */
4440 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4441 || !(sas_device.flags &
4442 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4443 break;
4444
4445 phy_info = mptsas_find_phyinfo_by_sas_address(
4446 ioc, sas_device.sas_address);
4447
4448 if (!phy_info) {
4449 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4450 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4451 __func__, hot_plug_info->id, __LINE__));
4452 break;
4453 }
4454
4455 starget = mptsas_get_starget(phy_info);
4456 if (!starget) {
4457 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4458 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4459 __func__, hot_plug_info->id, __LINE__));
4460 break;
4461 }
4462
4463 vtarget = starget->hostdata;
4464 if (!vtarget) {
4465 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4466 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4467 __func__, hot_plug_info->id, __LINE__));
4468 break;
4469 }
4470
4471 mpt_findImVolumes(ioc);
4472
4473 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
4474 "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4475 ioc->name, hot_plug_info->channel, hot_plug_info->id,
4476 hot_plug_info->phys_disk_num, (unsigned long long)
4477 sas_device.sas_address);
4478
4479 vtarget->id = hot_plug_info->phys_disk_num;
4480 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4481 phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
4482 mptsas_reprobe_target(starget, 1);
4483 break;
4484
4485 case MPTSAS_DEL_PHYSDISK_REPROBE:
4486
4487 if (mptsas_sas_device_pg0(ioc, &sas_device,
4488 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4489 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4490 (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4491 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4492 "%s: fw_id=%d exit at line=%d\n",
4493 ioc->name, __func__,
4494 hot_plug_info->id, __LINE__));
4495 break;
4496 }
4497
4498 /* If there is no FW B_T mapping for this device then break
4499 * */
4500 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4501 || !(sas_device.flags &
4502 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4503 break;
4504
4505 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4506 sas_device.sas_address);
4507 if (!phy_info) {
4508 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4509 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4510 __func__, hot_plug_info->id, __LINE__));
4511 break;
4512 }
4513
4514 starget = mptsas_get_starget(phy_info);
4515 if (!starget) {
4516 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4517 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4518 __func__, hot_plug_info->id, __LINE__));
4519 break;
4520 }
4521
4522 vtarget = starget->hostdata;
4523 if (!vtarget) {
4524 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4525 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4526 __func__, hot_plug_info->id, __LINE__));
4527 break;
4528 }
4529
4530 if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
4531 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4532 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4533 __func__, hot_plug_info->id, __LINE__));
4534 break;
4535 }
4536
4537 mpt_findImVolumes(ioc);
4538
4539 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
4540 " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4541 ioc->name, hot_plug_info->channel, hot_plug_info->id,
4542 hot_plug_info->phys_disk_num, (unsigned long long)
4543 sas_device.sas_address);
4544
4545 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4546 vtarget->id = hot_plug_info->id;
4547 phy_info->attached.phys_disk_num = ~0;
4548 mptsas_reprobe_target(starget, 0);
4549 mptsas_add_device_component_by_fw(ioc,
4550 hot_plug_info->channel, hot_plug_info->id);
4551 break;
4552
4553 case MPTSAS_ADD_RAID:
4554
4555 mpt_findImVolumes(ioc);
4556 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4557 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4558 hot_plug_info->id);
4559 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4560 hot_plug_info->id, 0);
4561 break;
4562
4563 case MPTSAS_DEL_RAID:
4564
4565 mpt_findImVolumes(ioc);
4566 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4567 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4568 hot_plug_info->id);
4569 scsi_remove_device(hot_plug_info->sdev);
4570 scsi_device_put(hot_plug_info->sdev);
4571 break;
4572
4573 case MPTSAS_ADD_INACTIVE_VOLUME:
4574
4575 mpt_findImVolumes(ioc);
4576 mptsas_adding_inactive_raid_components(ioc,
4577 hot_plug_info->channel, hot_plug_info->id);
4578 break;
4579
4580 default:
4581 break;
4582 }
4583
4584 mptsas_free_fw_event(ioc, fw_event);
4585 }
4586
4587 static void
mptsas_send_sas_event(struct fw_event_work * fw_event)4588 mptsas_send_sas_event(struct fw_event_work *fw_event)
4589 {
4590 MPT_ADAPTER *ioc;
4591 struct mptsas_hotplug_event hot_plug_info;
4592 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
4593 u32 device_info;
4594 u64 sas_address;
4595
4596 ioc = fw_event->ioc;
4597 sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
4598 fw_event->event_data;
4599 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
4600
4601 if ((device_info &
4602 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
4603 MPI_SAS_DEVICE_INFO_STP_TARGET |
4604 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) {
4605 mptsas_free_fw_event(ioc, fw_event);
4606 return;
4607 }
4608
4609 if (sas_event_data->ReasonCode ==
4610 MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
4611 mptbase_sas_persist_operation(ioc,
4612 MPI_SAS_OP_CLEAR_NOT_PRESENT);
4613 mptsas_free_fw_event(ioc, fw_event);
4614 return;
4615 }
4616
4617 switch (sas_event_data->ReasonCode) {
4618 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
4619 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
4620 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4621 hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
4622 hot_plug_info.channel = sas_event_data->Bus;
4623 hot_plug_info.id = sas_event_data->TargetID;
4624 hot_plug_info.phy_id = sas_event_data->PhyNum;
4625 memcpy(&sas_address, &sas_event_data->SASAddress,
4626 sizeof(u64));
4627 hot_plug_info.sas_address = le64_to_cpu(sas_address);
4628 hot_plug_info.device_info = device_info;
4629 if (sas_event_data->ReasonCode &
4630 MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
4631 hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
4632 else
4633 hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
4634 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4635 break;
4636
4637 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
4638 mptbase_sas_persist_operation(ioc,
4639 MPI_SAS_OP_CLEAR_NOT_PRESENT);
4640 mptsas_free_fw_event(ioc, fw_event);
4641 break;
4642
4643 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
4644 /* TODO */
4645 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
4646 /* TODO */
4647 default:
4648 mptsas_free_fw_event(ioc, fw_event);
4649 break;
4650 }
4651 }
4652
4653 static void
mptsas_send_raid_event(struct fw_event_work * fw_event)4654 mptsas_send_raid_event(struct fw_event_work *fw_event)
4655 {
4656 MPT_ADAPTER *ioc;
4657 EVENT_DATA_RAID *raid_event_data;
4658 struct mptsas_hotplug_event hot_plug_info;
4659 int status;
4660 int state;
4661 struct scsi_device *sdev = NULL;
4662 VirtDevice *vdevice = NULL;
4663 RaidPhysDiskPage0_t phys_disk;
4664
4665 ioc = fw_event->ioc;
4666 raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
4667 status = le32_to_cpu(raid_event_data->SettingsStatus);
4668 state = (status >> 8) & 0xff;
4669
4670 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4671 hot_plug_info.id = raid_event_data->VolumeID;
4672 hot_plug_info.channel = raid_event_data->VolumeBus;
4673 hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
4674
4675 if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
4676 raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
4677 raid_event_data->ReasonCode ==
4678 MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
4679 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4680 hot_plug_info.id, 0);
4681 hot_plug_info.sdev = sdev;
4682 if (sdev)
4683 vdevice = sdev->hostdata;
4684 }
4685
4686 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4687 "ReasonCode=%02x\n", ioc->name, __func__,
4688 raid_event_data->ReasonCode));
4689
4690 switch (raid_event_data->ReasonCode) {
4691 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4692 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
4693 break;
4694 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4695 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
4696 break;
4697 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4698 switch (state) {
4699 case MPI_PD_STATE_ONLINE:
4700 case MPI_PD_STATE_NOT_COMPATIBLE:
4701 mpt_raid_phys_disk_pg0(ioc,
4702 raid_event_data->PhysDiskNum, &phys_disk);
4703 hot_plug_info.id = phys_disk.PhysDiskID;
4704 hot_plug_info.channel = phys_disk.PhysDiskBus;
4705 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4706 break;
4707 case MPI_PD_STATE_FAILED:
4708 case MPI_PD_STATE_MISSING:
4709 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
4710 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
4711 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
4712 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4713 break;
4714 default:
4715 break;
4716 }
4717 break;
4718 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4719 if (!sdev)
4720 break;
4721 vdevice->vtarget->deleted = 1; /* block IO */
4722 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4723 break;
4724 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4725 if (sdev) {
4726 scsi_device_put(sdev);
4727 break;
4728 }
4729 hot_plug_info.event_type = MPTSAS_ADD_RAID;
4730 break;
4731 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4732 if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
4733 if (!sdev)
4734 break;
4735 vdevice->vtarget->deleted = 1; /* block IO */
4736 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4737 break;
4738 }
4739 switch (state) {
4740 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
4741 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
4742 if (!sdev)
4743 break;
4744 vdevice->vtarget->deleted = 1; /* block IO */
4745 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4746 break;
4747 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
4748 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
4749 if (sdev) {
4750 scsi_device_put(sdev);
4751 break;
4752 }
4753 hot_plug_info.event_type = MPTSAS_ADD_RAID;
4754 break;
4755 default:
4756 break;
4757 }
4758 break;
4759 default:
4760 break;
4761 }
4762
4763 if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
4764 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4765 else
4766 mptsas_free_fw_event(ioc, fw_event);
4767 }
4768
4769 /**
4770 * mptsas_issue_tm - send mptsas internal tm request
4771 * @ioc: Pointer to MPT_ADAPTER structure
4772 * @type: Task Management type
4773 * @channel: channel number for task management
4774 * @id: Logical Target ID for reset (if appropriate)
4775 * @lun: Logical unit for reset (if appropriate)
4776 * @task_context: Context for the task to be aborted
4777 * @timeout: timeout for task management control
4778 * @issue_reset: set to 1 on return if reset is needed, else 0
4779 *
4780 * Return: 0 on success or -1 on failure.
4781 *
4782 */
4783 static int
mptsas_issue_tm(MPT_ADAPTER * ioc,u8 type,u8 channel,u8 id,u64 lun,int task_context,ulong timeout,u8 * issue_reset)4784 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun,
4785 int task_context, ulong timeout, u8 *issue_reset)
4786 {
4787 MPT_FRAME_HDR *mf;
4788 SCSITaskMgmt_t *pScsiTm;
4789 int retval;
4790 unsigned long timeleft;
4791
4792 *issue_reset = 0;
4793 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
4794 if (mf == NULL) {
4795 retval = -1; /* return failure */
4796 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
4797 "msg frames!!\n", ioc->name));
4798 goto out;
4799 }
4800
4801 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
4802 "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
4803 "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
4804 type, timeout, channel, id, (unsigned long long)lun,
4805 task_context));
4806
4807 pScsiTm = (SCSITaskMgmt_t *) mf;
4808 memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
4809 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4810 pScsiTm->TaskType = type;
4811 pScsiTm->MsgFlags = 0;
4812 pScsiTm->TargetID = id;
4813 pScsiTm->Bus = channel;
4814 pScsiTm->ChainOffset = 0;
4815 pScsiTm->Reserved = 0;
4816 pScsiTm->Reserved1 = 0;
4817 pScsiTm->TaskMsgContext = task_context;
4818 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
4819
4820 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4821 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
4822 retval = 0;
4823 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
4824
4825 /* Now wait for the command to complete */
4826 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
4827 timeout*HZ);
4828 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
4829 retval = -1; /* return failure */
4830 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
4831 "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
4832 mpt_free_msg_frame(ioc, mf);
4833 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
4834 goto out;
4835 *issue_reset = 1;
4836 goto out;
4837 }
4838
4839 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
4840 retval = -1; /* return failure */
4841 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4842 "TaskMgmt request: failed with no reply\n", ioc->name));
4843 goto out;
4844 }
4845
4846 out:
4847 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4848 return retval;
4849 }
4850
4851 /**
4852 * mptsas_broadcast_primitive_work - Handle broadcast primitives
4853 * @fw_event: work queue payload containing info describing the event
4854 *
4855 * This will be handled in workqueue context.
4856 */
4857 static void
mptsas_broadcast_primitive_work(struct fw_event_work * fw_event)4858 mptsas_broadcast_primitive_work(struct fw_event_work *fw_event)
4859 {
4860 MPT_ADAPTER *ioc = fw_event->ioc;
4861 MPT_FRAME_HDR *mf;
4862 VirtDevice *vdevice;
4863 int ii;
4864 struct scsi_cmnd *sc;
4865 SCSITaskMgmtReply_t *pScsiTmReply;
4866 u8 issue_reset;
4867 int task_context;
4868 u8 channel, id;
4869 int lun;
4870 u32 termination_count;
4871 u32 query_count;
4872
4873 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4874 "%s - enter\n", ioc->name, __func__));
4875
4876 mutex_lock(&ioc->taskmgmt_cmds.mutex);
4877 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4878 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4879 mptsas_requeue_fw_event(ioc, fw_event, 1000);
4880 return;
4881 }
4882
4883 issue_reset = 0;
4884 termination_count = 0;
4885 query_count = 0;
4886 mpt_findImVolumes(ioc);
4887 pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
4888
4889 for (ii = 0; ii < ioc->req_depth; ii++) {
4890 if (ioc->fw_events_off)
4891 goto out;
4892 sc = mptscsih_get_scsi_lookup(ioc, ii);
4893 if (!sc)
4894 continue;
4895 mf = MPT_INDEX_2_MFPTR(ioc, ii);
4896 if (!mf)
4897 continue;
4898 task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
4899 vdevice = sc->device->hostdata;
4900 if (!vdevice || !vdevice->vtarget)
4901 continue;
4902 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
4903 continue; /* skip hidden raid components */
4904 if (vdevice->vtarget->raidVolume)
4905 continue; /* skip hidden raid components */
4906 channel = vdevice->vtarget->channel;
4907 id = vdevice->vtarget->id;
4908 lun = vdevice->lun;
4909 if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
4910 channel, id, (u64)lun, task_context, 30, &issue_reset))
4911 goto out;
4912 query_count++;
4913 termination_count +=
4914 le32_to_cpu(pScsiTmReply->TerminationCount);
4915 if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
4916 (pScsiTmReply->ResponseCode ==
4917 MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4918 pScsiTmReply->ResponseCode ==
4919 MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4920 continue;
4921 if (mptsas_issue_tm(ioc,
4922 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
4923 channel, id, (u64)lun, 0, 30, &issue_reset))
4924 goto out;
4925 termination_count +=
4926 le32_to_cpu(pScsiTmReply->TerminationCount);
4927 }
4928
4929 out:
4930 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4931 "%s - exit, query_count = %d termination_count = %d\n",
4932 ioc->name, __func__, query_count, termination_count));
4933
4934 ioc->broadcast_aen_busy = 0;
4935 mpt_clear_taskmgmt_in_progress_flag(ioc);
4936 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4937
4938 if (issue_reset) {
4939 printk(MYIOC_s_WARN_FMT
4940 "Issuing Reset from %s!! doorbell=0x%08x\n",
4941 ioc->name, __func__, mpt_GetIocState(ioc, 0));
4942 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
4943 }
4944 mptsas_free_fw_event(ioc, fw_event);
4945 }
4946
4947 /*
4948 * mptsas_send_ir2_event - handle exposing hidden disk when
4949 * an inactive raid volume is added
4950 *
4951 * @ioc: Pointer to MPT_ADAPTER structure
4952 * @ir2_data
4953 *
4954 */
4955 static void
mptsas_send_ir2_event(struct fw_event_work * fw_event)4956 mptsas_send_ir2_event(struct fw_event_work *fw_event)
4957 {
4958 MPT_ADAPTER *ioc;
4959 struct mptsas_hotplug_event hot_plug_info;
4960 MPI_EVENT_DATA_IR2 *ir2_data;
4961 u8 reasonCode;
4962 RaidPhysDiskPage0_t phys_disk;
4963
4964 ioc = fw_event->ioc;
4965 ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
4966 reasonCode = ir2_data->ReasonCode;
4967
4968 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4969 "ReasonCode=%02x\n", ioc->name, __func__, reasonCode));
4970
4971 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4972 hot_plug_info.id = ir2_data->TargetID;
4973 hot_plug_info.channel = ir2_data->Bus;
4974 switch (reasonCode) {
4975 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
4976 hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
4977 break;
4978 case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
4979 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4980 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4981 break;
4982 case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
4983 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4984 mpt_raid_phys_disk_pg0(ioc,
4985 ir2_data->PhysDiskNum, &phys_disk);
4986 hot_plug_info.id = phys_disk.PhysDiskID;
4987 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4988 break;
4989 default:
4990 mptsas_free_fw_event(ioc, fw_event);
4991 return;
4992 }
4993 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4994 }
4995
4996 static int
mptsas_event_process(MPT_ADAPTER * ioc,EventNotificationReply_t * reply)4997 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
4998 {
4999 u32 event = le32_to_cpu(reply->Event);
5000 int event_data_sz;
5001 struct fw_event_work *fw_event;
5002 unsigned long delay;
5003
5004 if (ioc->bus_type != SAS)
5005 return 0;
5006
5007 /* events turned off due to host reset or driver unloading */
5008 if (ioc->fw_events_off)
5009 return 0;
5010
5011 delay = msecs_to_jiffies(1);
5012 switch (event) {
5013 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
5014 {
5015 EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
5016 (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
5017 if (broadcast_event_data->Primitive !=
5018 MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
5019 return 0;
5020 if (ioc->broadcast_aen_busy)
5021 return 0;
5022 ioc->broadcast_aen_busy = 1;
5023 break;
5024 }
5025 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
5026 {
5027 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
5028 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
5029 u16 ioc_stat;
5030 ioc_stat = le16_to_cpu(reply->IOCStatus);
5031
5032 if (sas_event_data->ReasonCode ==
5033 MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
5034 mptsas_target_reset_queue(ioc, sas_event_data);
5035 return 0;
5036 }
5037 if (sas_event_data->ReasonCode ==
5038 MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5039 ioc->device_missing_delay &&
5040 (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
5041 VirtTarget *vtarget = NULL;
5042 u8 id, channel;
5043
5044 id = sas_event_data->TargetID;
5045 channel = sas_event_data->Bus;
5046
5047 vtarget = mptsas_find_vtarget(ioc, channel, id);
5048 if (vtarget) {
5049 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5050 "LogInfo (0x%x) available for "
5051 "INTERNAL_DEVICE_RESET"
5052 "fw_id %d fw_channel %d\n", ioc->name,
5053 le32_to_cpu(reply->IOCLogInfo),
5054 id, channel));
5055 if (vtarget->raidVolume) {
5056 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5057 "Skipping Raid Volume for inDMD\n",
5058 ioc->name));
5059 } else {
5060 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5061 "Setting device flag inDMD\n",
5062 ioc->name));
5063 vtarget->inDMD = 1;
5064 }
5065
5066 }
5067
5068 }
5069
5070 break;
5071 }
5072 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
5073 {
5074 MpiEventDataSasExpanderStatusChange_t *expander_data =
5075 (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
5076
5077 if (ioc->old_sas_discovery_protocal)
5078 return 0;
5079
5080 if (expander_data->ReasonCode ==
5081 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
5082 ioc->device_missing_delay)
5083 delay = HZ * ioc->device_missing_delay;
5084 break;
5085 }
5086 case MPI_EVENT_SAS_DISCOVERY:
5087 {
5088 u32 discovery_status;
5089 EventDataSasDiscovery_t *discovery_data =
5090 (EventDataSasDiscovery_t *)reply->Data;
5091
5092 discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
5093 ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
5094 if (ioc->old_sas_discovery_protocal && !discovery_status)
5095 mptsas_queue_rescan(ioc);
5096 return 0;
5097 }
5098 case MPI_EVENT_INTEGRATED_RAID:
5099 case MPI_EVENT_PERSISTENT_TABLE_FULL:
5100 case MPI_EVENT_IR2:
5101 case MPI_EVENT_SAS_PHY_LINK_STATUS:
5102 case MPI_EVENT_QUEUE_FULL:
5103 break;
5104 default:
5105 return 0;
5106 }
5107
5108 event_data_sz = ((reply->MsgLength * 4) -
5109 offsetof(EventNotificationReply_t, Data));
5110 fw_event = kzalloc(sizeof(*fw_event) + event_data_sz, GFP_ATOMIC);
5111 if (!fw_event) {
5112 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
5113 __func__, __LINE__);
5114 return 0;
5115 }
5116 memcpy(fw_event->event_data, reply->Data, event_data_sz);
5117 fw_event->event = event;
5118 fw_event->ioc = ioc;
5119 mptsas_add_fw_event(ioc, fw_event, delay);
5120 return 0;
5121 }
5122
5123 /* Delete a volume when no longer listed in ioc pg2
5124 */
mptsas_volume_delete(MPT_ADAPTER * ioc,u8 id)5125 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
5126 {
5127 struct scsi_device *sdev;
5128 int i;
5129
5130 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
5131 if (!sdev)
5132 return;
5133 if (!ioc->raid_data.pIocPg2)
5134 goto out;
5135 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
5136 goto out;
5137 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
5138 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
5139 goto release_sdev;
5140 out:
5141 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
5142 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id);
5143 scsi_remove_device(sdev);
5144 release_sdev:
5145 scsi_device_put(sdev);
5146 }
5147
5148 static int
mptsas_probe(struct pci_dev * pdev,const struct pci_device_id * id)5149 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5150 {
5151 struct Scsi_Host *sh;
5152 MPT_SCSI_HOST *hd;
5153 MPT_ADAPTER *ioc;
5154 unsigned long flags;
5155 int ii;
5156 int numSGE = 0;
5157 int scale;
5158 int ioc_cap;
5159 int error=0;
5160 int r;
5161
5162 r = mpt_attach(pdev,id);
5163 if (r)
5164 return r;
5165
5166 ioc = pci_get_drvdata(pdev);
5167 mptsas_fw_event_off(ioc);
5168 ioc->DoneCtx = mptsasDoneCtx;
5169 ioc->TaskCtx = mptsasTaskCtx;
5170 ioc->InternalCtx = mptsasInternalCtx;
5171 ioc->schedule_target_reset = &mptsas_schedule_target_reset;
5172 ioc->schedule_dead_ioc_flush_running_cmds =
5173 &mptscsih_flush_running_cmds;
5174 /* Added sanity check on readiness of the MPT adapter.
5175 */
5176 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
5177 printk(MYIOC_s_WARN_FMT
5178 "Skipping because it's not operational!\n",
5179 ioc->name);
5180 error = -ENODEV;
5181 goto out_mptsas_probe;
5182 }
5183
5184 if (!ioc->active) {
5185 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
5186 ioc->name);
5187 error = -ENODEV;
5188 goto out_mptsas_probe;
5189 }
5190
5191 /* Sanity check - ensure at least 1 port is INITIATOR capable
5192 */
5193 ioc_cap = 0;
5194 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
5195 if (ioc->pfacts[ii].ProtocolFlags &
5196 MPI_PORTFACTS_PROTOCOL_INITIATOR)
5197 ioc_cap++;
5198 }
5199
5200 if (!ioc_cap) {
5201 printk(MYIOC_s_WARN_FMT
5202 "Skipping ioc=%p because SCSI Initiator mode "
5203 "is NOT enabled!\n", ioc->name, ioc);
5204 return 0;
5205 }
5206
5207 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
5208 if (!sh) {
5209 printk(MYIOC_s_WARN_FMT
5210 "Unable to register controller with SCSI subsystem\n",
5211 ioc->name);
5212 error = -1;
5213 goto out_mptsas_probe;
5214 }
5215
5216 spin_lock_irqsave(&ioc->FreeQlock, flags);
5217
5218 /* Attach the SCSI Host to the IOC structure
5219 */
5220 ioc->sh = sh;
5221
5222 sh->io_port = 0;
5223 sh->n_io_port = 0;
5224 sh->irq = 0;
5225
5226 /* set 16 byte cdb's */
5227 sh->max_cmd_len = 16;
5228 sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
5229 sh->max_id = -1;
5230 sh->max_lun = max_lun;
5231 sh->transportt = mptsas_transport_template;
5232
5233 /* Required entry.
5234 */
5235 sh->unique_id = ioc->id;
5236
5237 INIT_LIST_HEAD(&ioc->sas_topology);
5238 mutex_init(&ioc->sas_topology_mutex);
5239 mutex_init(&ioc->sas_discovery_mutex);
5240 mutex_init(&ioc->sas_mgmt.mutex);
5241 init_completion(&ioc->sas_mgmt.done);
5242
5243 /* Verify that we won't exceed the maximum
5244 * number of chain buffers
5245 * We can optimize: ZZ = req_sz/sizeof(SGE)
5246 * For 32bit SGE's:
5247 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
5248 * + (req_sz - 64)/sizeof(SGE)
5249 * A slightly different algorithm is required for
5250 * 64bit SGEs.
5251 */
5252 scale = ioc->req_sz/ioc->SGE_size;
5253 if (ioc->sg_addr_size == sizeof(u64)) {
5254 numSGE = (scale - 1) *
5255 (ioc->facts.MaxChainDepth-1) + scale +
5256 (ioc->req_sz - 60) / ioc->SGE_size;
5257 } else {
5258 numSGE = 1 + (scale - 1) *
5259 (ioc->facts.MaxChainDepth-1) + scale +
5260 (ioc->req_sz - 64) / ioc->SGE_size;
5261 }
5262
5263 if (numSGE < sh->sg_tablesize) {
5264 /* Reset this value */
5265 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5266 "Resetting sg_tablesize to %d from %d\n",
5267 ioc->name, numSGE, sh->sg_tablesize));
5268 sh->sg_tablesize = numSGE;
5269 }
5270
5271 if (mpt_loadtime_max_sectors) {
5272 if (mpt_loadtime_max_sectors < 64 ||
5273 mpt_loadtime_max_sectors > 8192) {
5274 printk(MYIOC_s_INFO_FMT "Invalid value passed for"
5275 "mpt_loadtime_max_sectors %d."
5276 "Range from 64 to 8192\n", ioc->name,
5277 mpt_loadtime_max_sectors);
5278 }
5279 mpt_loadtime_max_sectors &= 0xFFFFFFFE;
5280 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5281 "Resetting max sector to %d from %d\n",
5282 ioc->name, mpt_loadtime_max_sectors, sh->max_sectors));
5283 sh->max_sectors = mpt_loadtime_max_sectors;
5284 }
5285
5286 hd = shost_priv(sh);
5287 hd->ioc = ioc;
5288
5289 /* SCSI needs scsi_cmnd lookup table!
5290 * (with size equal to req_depth*PtrSz!)
5291 */
5292 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
5293 if (!ioc->ScsiLookup) {
5294 error = -ENOMEM;
5295 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5296 goto out_mptsas_probe;
5297 }
5298 spin_lock_init(&ioc->scsi_lookup_lock);
5299
5300 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
5301 ioc->name, ioc->ScsiLookup));
5302
5303 ioc->sas_data.ptClear = mpt_pt_clear;
5304
5305 hd->last_queue_full = 0;
5306 INIT_LIST_HEAD(&hd->target_reset_list);
5307 INIT_LIST_HEAD(&ioc->sas_device_info_list);
5308 mutex_init(&ioc->sas_device_info_mutex);
5309
5310 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5311
5312 if (ioc->sas_data.ptClear==1) {
5313 mptbase_sas_persist_operation(
5314 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
5315 }
5316
5317 error = scsi_add_host(sh, &ioc->pcidev->dev);
5318 if (error) {
5319 dprintk(ioc, printk(MYIOC_s_ERR_FMT
5320 "scsi_add_host failed\n", ioc->name));
5321 goto out_mptsas_probe;
5322 }
5323
5324 /* older firmware doesn't support expander events */
5325 if ((ioc->facts.HeaderVersion >> 8) < 0xE)
5326 ioc->old_sas_discovery_protocal = 1;
5327 mptsas_scan_sas_topology(ioc);
5328 mptsas_fw_event_on(ioc);
5329 return 0;
5330
5331 out_mptsas_probe:
5332
5333 mptscsih_remove(pdev);
5334 return error;
5335 }
5336
5337 static void
mptsas_shutdown(struct pci_dev * pdev)5338 mptsas_shutdown(struct pci_dev *pdev)
5339 {
5340 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5341
5342 mptsas_fw_event_off(ioc);
5343 mptsas_cleanup_fw_event_q(ioc);
5344 }
5345
mptsas_remove(struct pci_dev * pdev)5346 static void mptsas_remove(struct pci_dev *pdev)
5347 {
5348 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5349 struct mptsas_portinfo *p, *n;
5350 int i;
5351
5352 if (!ioc->sh) {
5353 printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name);
5354 mpt_detach(pdev);
5355 return;
5356 }
5357
5358 mptsas_shutdown(pdev);
5359
5360 mptsas_del_device_components(ioc);
5361
5362 ioc->sas_discovery_ignore_events = 1;
5363 sas_remove_host(ioc->sh);
5364
5365 mutex_lock(&ioc->sas_topology_mutex);
5366 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
5367 list_del(&p->list);
5368 for (i = 0 ; i < p->num_phys ; i++)
5369 mptsas_port_delete(ioc, p->phy_info[i].port_details);
5370
5371 kfree(p->phy_info);
5372 kfree(p);
5373 }
5374 mutex_unlock(&ioc->sas_topology_mutex);
5375 ioc->hba_port_info = NULL;
5376 mptscsih_remove(pdev);
5377 }
5378
5379 static const struct pci_device_id mptsas_pci_table[] = {
5380 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
5381 PCI_ANY_ID, PCI_ANY_ID },
5382 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
5383 PCI_ANY_ID, PCI_ANY_ID },
5384 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
5385 PCI_ANY_ID, PCI_ANY_ID },
5386 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
5387 PCI_ANY_ID, PCI_ANY_ID },
5388 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
5389 PCI_ANY_ID, PCI_ANY_ID },
5390 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068_820XELP,
5391 PCI_ANY_ID, PCI_ANY_ID },
5392 {0} /* Terminating entry */
5393 };
5394 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
5395
5396
5397 static struct pci_driver mptsas_driver = {
5398 .name = "mptsas",
5399 .id_table = mptsas_pci_table,
5400 .probe = mptsas_probe,
5401 .remove = mptsas_remove,
5402 .shutdown = mptsas_shutdown,
5403 #ifdef CONFIG_PM
5404 .suspend = mptscsih_suspend,
5405 .resume = mptscsih_resume,
5406 #endif
5407 };
5408
5409 static int __init
mptsas_init(void)5410 mptsas_init(void)
5411 {
5412 int error;
5413
5414 show_mptmod_ver(my_NAME, my_VERSION);
5415
5416 mptsas_transport_template =
5417 sas_attach_transport(&mptsas_transport_functions);
5418 if (!mptsas_transport_template)
5419 return -ENODEV;
5420
5421 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER,
5422 "mptscsih_io_done");
5423 mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER,
5424 "mptscsih_taskmgmt_complete");
5425 mptsasInternalCtx =
5426 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER,
5427 "mptscsih_scandv_complete");
5428 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER,
5429 "mptsas_mgmt_done");
5430 mptsasDeviceResetCtx =
5431 mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER,
5432 "mptsas_taskmgmt_complete");
5433
5434 mpt_event_register(mptsasDoneCtx, mptsas_event_process);
5435 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
5436
5437 error = pci_register_driver(&mptsas_driver);
5438 if (error)
5439 sas_release_transport(mptsas_transport_template);
5440
5441 return error;
5442 }
5443
5444 static void __exit
mptsas_exit(void)5445 mptsas_exit(void)
5446 {
5447 pci_unregister_driver(&mptsas_driver);
5448 sas_release_transport(mptsas_transport_template);
5449
5450 mpt_reset_deregister(mptsasDoneCtx);
5451 mpt_event_deregister(mptsasDoneCtx);
5452
5453 mpt_deregister(mptsasMgmtCtx);
5454 mpt_deregister(mptsasInternalCtx);
5455 mpt_deregister(mptsasTaskCtx);
5456 mpt_deregister(mptsasDoneCtx);
5457 mpt_deregister(mptsasDeviceResetCtx);
5458 }
5459
5460 module_init(mptsas_init);
5461 module_exit(mptsas_exit);
5462