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