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