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.
6 * Copyright (c) 1999-2008 LSI Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
9 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
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.
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.
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.
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
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
44 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46 #include <linux/module.h>
47 #include <linux/kernel.h>
48 #include <linux/slab.h>
49 #include <linux/init.h>
50 #include <linux/errno.h>
51 #include <linux/jiffies.h>
52 #include <linux/workqueue.h>
53 #include <linux/delay.h> /* for mdelay */
55 #include <scsi/scsi.h>
56 #include <scsi/scsi_cmnd.h>
57 #include <scsi/scsi_device.h>
58 #include <scsi/scsi_host.h>
59 #include <scsi/scsi_transport_sas.h>
60 #include <scsi/scsi_transport.h>
61 #include <scsi/scsi_dbg.h>
68 #define my_NAME "Fusion MPT SAS Host driver"
69 #define my_VERSION MPT_LINUX_VERSION_COMMON
70 #define MYNAM "mptsas"
73 * Reserved channel for integrated raid
75 #define MPTSAS_RAID_CHANNEL 1
77 #define SAS_CONFIG_PAGE_TIMEOUT 30
78 MODULE_AUTHOR(MODULEAUTHOR);
79 MODULE_DESCRIPTION(my_NAME);
80 MODULE_LICENSE("GPL");
81 MODULE_VERSION(my_VERSION);
83 static int mpt_pt_clear;
84 module_param(mpt_pt_clear, int, 0);
85 MODULE_PARM_DESC(mpt_pt_clear,
86 " Clear persistency table: enable=1 "
87 "(default=MPTSCSIH_PT_CLEAR=0)");
89 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
90 #define MPTSAS_MAX_LUN (16895)
91 static int max_lun = MPTSAS_MAX_LUN;
92 module_param(max_lun, int, 0);
93 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
95 static int mpt_loadtime_max_sectors = 8192;
96 module_param(mpt_loadtime_max_sectors, int, 0);
97 MODULE_PARM_DESC(mpt_loadtime_max_sectors,
98 " Maximum sector define for Host Bus Adaptor.Range 64 to 8192 default=8192");
100 static u8 mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
101 static u8 mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
102 static u8 mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
103 static u8 mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
104 static u8 mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS;
106 static void mptsas_firmware_event_work(struct work_struct *work);
107 static void mptsas_send_sas_event(struct fw_event_work *fw_event);
108 static void mptsas_send_raid_event(struct fw_event_work *fw_event);
109 static void mptsas_send_ir2_event(struct fw_event_work *fw_event);
110 static void mptsas_parse_device_info(struct sas_identify *identify,
111 struct mptsas_devinfo *device_info);
112 static inline void mptsas_set_rphy(MPT_ADAPTER *ioc,
113 struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy);
114 static struct mptsas_phyinfo *mptsas_find_phyinfo_by_sas_address
115 (MPT_ADAPTER *ioc, u64 sas_address);
116 static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
117 struct mptsas_devinfo *device_info, u32 form, u32 form_specific);
118 static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc,
119 struct mptsas_enclosure *enclosure, u32 form, u32 form_specific);
120 static int mptsas_add_end_device(MPT_ADAPTER *ioc,
121 struct mptsas_phyinfo *phy_info);
122 static void mptsas_del_end_device(MPT_ADAPTER *ioc,
123 struct mptsas_phyinfo *phy_info);
124 static void mptsas_send_link_status_event(struct fw_event_work *fw_event);
125 static struct mptsas_portinfo *mptsas_find_portinfo_by_sas_address
126 (MPT_ADAPTER *ioc, u64 sas_address);
127 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
128 struct mptsas_portinfo *port_info, u8 force);
129 static void mptsas_send_expander_event(struct fw_event_work *fw_event);
130 static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
131 static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
132 static void mptsas_broadcast_primative_work(struct fw_event_work *fw_event);
133 static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event);
134 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id);
135 void mptsas_schedule_target_reset(void *ioc);
137 static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
138 MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
140 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
141 "---- IO UNIT PAGE 0 ------------\n", ioc->name));
142 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
143 ioc->name, le16_to_cpu(phy_data->AttachedDeviceHandle)));
144 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Controller Handle=0x%X\n",
145 ioc->name, le16_to_cpu(phy_data->ControllerDevHandle)));
146 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port=0x%X\n",
147 ioc->name, phy_data->Port));
148 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port Flags=0x%X\n",
149 ioc->name, phy_data->PortFlags));
150 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Flags=0x%X\n",
151 ioc->name, phy_data->PhyFlags));
152 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
153 ioc->name, phy_data->NegotiatedLinkRate));
154 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
155 "Controller PHY Device Info=0x%X\n", ioc->name,
156 le32_to_cpu(phy_data->ControllerPhyDeviceInfo)));
157 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DiscoveryStatus=0x%X\n\n",
158 ioc->name, le32_to_cpu(phy_data->DiscoveryStatus)));
161 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0)
165 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
167 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
168 "---- SAS PHY PAGE 0 ------------\n", ioc->name));
169 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
170 "Attached Device Handle=0x%X\n", ioc->name,
171 le16_to_cpu(pg0->AttachedDevHandle)));
172 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
173 ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
174 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
175 "Attached PHY Identifier=0x%X\n", ioc->name,
176 pg0->AttachedPhyIdentifier));
177 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Attached Device Info=0x%X\n",
178 ioc->name, le32_to_cpu(pg0->AttachedDeviceInfo)));
179 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
180 ioc->name, pg0->ProgrammedLinkRate));
181 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Change Count=0x%X\n",
182 ioc->name, pg0->ChangeCount));
183 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Info=0x%X\n\n",
184 ioc->name, le32_to_cpu(pg0->PhyInfo)));
187 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1)
189 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
190 "---- SAS PHY PAGE 1 ------------\n", ioc->name));
191 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Invalid Dword Count=0x%x\n",
192 ioc->name, pg1->InvalidDwordCount));
193 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
194 "Running Disparity Error Count=0x%x\n", ioc->name,
195 pg1->RunningDisparityErrorCount));
196 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
197 "Loss Dword Synch Count=0x%x\n", ioc->name,
198 pg1->LossDwordSynchCount));
199 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
200 "PHY Reset Problem Count=0x%x\n\n", ioc->name,
201 pg1->PhyResetProblemCount));
204 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0)
208 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
210 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
211 "---- SAS DEVICE PAGE 0 ---------\n", ioc->name));
212 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
213 ioc->name, le16_to_cpu(pg0->DevHandle)));
214 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Handle=0x%X\n",
215 ioc->name, le16_to_cpu(pg0->ParentDevHandle)));
216 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Enclosure Handle=0x%X\n",
217 ioc->name, le16_to_cpu(pg0->EnclosureHandle)));
218 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Slot=0x%X\n",
219 ioc->name, le16_to_cpu(pg0->Slot)));
220 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
221 ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
222 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Target ID=0x%X\n",
223 ioc->name, pg0->TargetID));
224 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Bus=0x%X\n",
225 ioc->name, pg0->Bus));
226 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Phy Num=0x%X\n",
227 ioc->name, pg0->PhyNum));
228 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Access Status=0x%X\n",
229 ioc->name, le16_to_cpu(pg0->AccessStatus)));
230 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Device Info=0x%X\n",
231 ioc->name, le32_to_cpu(pg0->DeviceInfo)));
232 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Flags=0x%X\n",
233 ioc->name, le16_to_cpu(pg0->Flags)));
234 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n\n",
235 ioc->name, pg0->PhysicalPort));
238 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1)
240 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
241 "---- SAS EXPANDER PAGE 1 ------------\n", ioc->name));
242 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n",
243 ioc->name, pg1->PhysicalPort));
244 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Identifier=0x%X\n",
245 ioc->name, pg1->PhyIdentifier));
246 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
247 ioc->name, pg1->NegotiatedLinkRate));
248 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
249 ioc->name, pg1->ProgrammedLinkRate));
250 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hardware Link Rate=0x%X\n",
251 ioc->name, pg1->HwLinkRate));
252 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Owner Device Handle=0x%X\n",
253 ioc->name, le16_to_cpu(pg1->OwnerDevHandle)));
254 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
255 "Attached Device Handle=0x%X\n\n", ioc->name,
256 le16_to_cpu(pg1->AttachedDevHandle)));
259 /* inhibit sas firmware event handling */
261 mptsas_fw_event_off(MPT_ADAPTER *ioc)
265 spin_lock_irqsave(&ioc->fw_event_lock, flags);
266 ioc->fw_events_off = 1;
267 ioc->sas_discovery_quiesce_io = 0;
268 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
272 /* enable sas firmware event handling */
274 mptsas_fw_event_on(MPT_ADAPTER *ioc)
278 spin_lock_irqsave(&ioc->fw_event_lock, flags);
279 ioc->fw_events_off = 0;
280 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
283 /* queue a sas firmware event */
285 mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
290 spin_lock_irqsave(&ioc->fw_event_lock, flags);
291 list_add_tail(&fw_event->list, &ioc->fw_event_list);
292 INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work);
293 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: add (fw_event=0x%p)"
294 "on cpuid %d\n", ioc->name, __func__,
295 fw_event, smp_processor_id()));
296 queue_delayed_work_on(smp_processor_id(), ioc->fw_event_q,
297 &fw_event->work, delay);
298 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
301 /* requeue a sas firmware event */
303 mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
307 spin_lock_irqsave(&ioc->fw_event_lock, flags);
308 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: reschedule task "
309 "(fw_event=0x%p)on cpuid %d\n", ioc->name, __func__,
310 fw_event, smp_processor_id()));
312 queue_delayed_work_on(smp_processor_id(), ioc->fw_event_q,
313 &fw_event->work, msecs_to_jiffies(delay));
314 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
317 /* free memory associated to a sas firmware event */
319 mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event)
323 spin_lock_irqsave(&ioc->fw_event_lock, flags);
324 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: kfree (fw_event=0x%p)\n",
325 ioc->name, __func__, fw_event));
326 list_del(&fw_event->list);
328 spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
331 /* walk the firmware event queue, and either stop or wait for
332 * outstanding events to complete */
334 mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc)
336 struct fw_event_work *fw_event, *next;
337 struct mptsas_target_reset_event *target_reset_list, *n;
338 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
340 /* flush the target_reset_list */
341 if (!list_empty(&hd->target_reset_list)) {
342 list_for_each_entry_safe(target_reset_list, n,
343 &hd->target_reset_list, list) {
344 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
345 "%s: removing target reset for id=%d\n",
347 target_reset_list->sas_event_data.TargetID));
348 list_del(&target_reset_list->list);
349 kfree(target_reset_list);
353 if (list_empty(&ioc->fw_event_list) ||
354 !ioc->fw_event_q || in_interrupt())
357 list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
358 if (cancel_delayed_work(&fw_event->work))
359 mptsas_free_fw_event(ioc, fw_event);
364 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
366 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
367 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
370 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
372 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
373 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
377 * mptsas_find_portinfo_by_handle
379 * This function should be called with the sas_topology_mutex already held
381 static struct mptsas_portinfo *
382 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
384 struct mptsas_portinfo *port_info, *rc=NULL;
387 list_for_each_entry(port_info, &ioc->sas_topology, list)
388 for (i = 0; i < port_info->num_phys; i++)
389 if (port_info->phy_info[i].identify.handle == handle) {
398 * mptsas_find_portinfo_by_sas_address -
399 * @ioc: Pointer to MPT_ADAPTER structure
402 * This function should be called with the sas_topology_mutex already held
405 static struct mptsas_portinfo *
406 mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
408 struct mptsas_portinfo *port_info, *rc = NULL;
411 if (sas_address >= ioc->hba_port_sas_addr &&
412 sas_address < (ioc->hba_port_sas_addr +
413 ioc->hba_port_num_phy))
414 return ioc->hba_port_info;
416 mutex_lock(&ioc->sas_topology_mutex);
417 list_for_each_entry(port_info, &ioc->sas_topology, list)
418 for (i = 0; i < port_info->num_phys; i++)
419 if (port_info->phy_info[i].identify.sas_address ==
425 mutex_unlock(&ioc->sas_topology_mutex);
430 * Returns true if there is a scsi end device
433 mptsas_is_end_device(struct mptsas_devinfo * attached)
435 if ((attached->sas_address) &&
436 (attached->device_info &
437 MPI_SAS_DEVICE_INFO_END_DEVICE) &&
438 ((attached->device_info &
439 MPI_SAS_DEVICE_INFO_SSP_TARGET) |
440 (attached->device_info &
441 MPI_SAS_DEVICE_INFO_STP_TARGET) |
442 (attached->device_info &
443 MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
451 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
453 struct mptsas_portinfo *port_info;
454 struct mptsas_phyinfo *phy_info;
460 port_info = port_details->port_info;
461 phy_info = port_info->phy_info;
463 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
464 "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
465 port_details->num_phys, (unsigned long long)
466 port_details->phy_bitmask));
468 for (i = 0; i < port_info->num_phys; i++, phy_info++) {
469 if(phy_info->port_details != port_details)
471 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
472 mptsas_set_rphy(ioc, phy_info, NULL);
473 phy_info->port_details = NULL;
478 static inline struct sas_rphy *
479 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
481 if (phy_info->port_details)
482 return phy_info->port_details->rphy;
488 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
490 if (phy_info->port_details) {
491 phy_info->port_details->rphy = rphy;
492 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
497 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
498 &rphy->dev, MYIOC_s_FMT "add:", ioc->name));
499 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rphy=%p release=%p\n",
500 ioc->name, rphy, rphy->dev.release));
504 static inline struct sas_port *
505 mptsas_get_port(struct mptsas_phyinfo *phy_info)
507 if (phy_info->port_details)
508 return phy_info->port_details->port;
514 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
516 if (phy_info->port_details)
517 phy_info->port_details->port = port;
520 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
521 &port->dev, MYIOC_s_FMT "add:", ioc->name));
522 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "port=%p release=%p\n",
523 ioc->name, port, port->dev.release));
527 static inline struct scsi_target *
528 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
530 if (phy_info->port_details)
531 return phy_info->port_details->starget;
537 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
540 if (phy_info->port_details)
541 phy_info->port_details->starget = starget;
545 * mptsas_add_device_component -
546 * @ioc: Pointer to MPT_ADAPTER structure
547 * @channel: fw mapped id's
554 mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id,
555 u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id)
557 struct mptsas_device_info *sas_info, *next;
558 struct scsi_device *sdev;
559 struct scsi_target *starget;
560 struct sas_rphy *rphy;
563 * Delete all matching devices out of the list
565 mutex_lock(&ioc->sas_device_info_mutex);
566 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
568 if (!sas_info->is_logical_volume &&
569 (sas_info->sas_address == sas_address ||
570 (sas_info->fw.channel == channel &&
571 sas_info->fw.id == id))) {
572 list_del(&sas_info->list);
577 sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
582 * Set Firmware mapping
584 sas_info->fw.id = id;
585 sas_info->fw.channel = channel;
587 sas_info->sas_address = sas_address;
588 sas_info->device_info = device_info;
589 sas_info->slot = slot;
590 sas_info->enclosure_logical_id = enclosure_logical_id;
591 INIT_LIST_HEAD(&sas_info->list);
592 list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
597 shost_for_each_device(sdev, ioc->sh) {
598 starget = scsi_target(sdev);
599 rphy = dev_to_rphy(starget->dev.parent);
600 if (rphy->identify.sas_address == sas_address) {
601 sas_info->os.id = starget->id;
602 sas_info->os.channel = starget->channel;
607 mutex_unlock(&ioc->sas_device_info_mutex);
612 * mptsas_add_device_component_by_fw -
613 * @ioc: Pointer to MPT_ADAPTER structure
614 * @channel: fw mapped id's
619 mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
621 struct mptsas_devinfo sas_device;
622 struct mptsas_enclosure enclosure_info;
625 rc = mptsas_sas_device_pg0(ioc, &sas_device,
626 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
627 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
628 (channel << 8) + id);
632 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
633 mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
634 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
635 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
636 sas_device.handle_enclosure);
638 mptsas_add_device_component(ioc, sas_device.channel,
639 sas_device.id, sas_device.sas_address, sas_device.device_info,
640 sas_device.slot, enclosure_info.enclosure_logical_id);
644 * mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding each individual device to list
645 * @ioc: Pointer to MPT_ADAPTER structure
646 * @channel: fw mapped id's
651 mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc,
652 struct scsi_target *starget)
655 ConfigPageHeader_t hdr;
656 dma_addr_t dma_handle;
657 pRaidVolumePage0_t buffer = NULL;
659 RaidPhysDiskPage0_t phys_disk;
660 struct mptsas_device_info *sas_info, *next;
662 memset(&cfg, 0 , sizeof(CONFIGPARMS));
663 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
664 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
665 /* assumption that all volumes on channel = 0 */
666 cfg.pageAddr = starget->id;
667 cfg.cfghdr.hdr = &hdr;
668 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
669 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
671 if (mpt_config(ioc, &cfg) != 0)
677 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
683 cfg.physAddr = dma_handle;
684 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
686 if (mpt_config(ioc, &cfg) != 0)
689 if (!buffer->NumPhysDisks)
693 * Adding entry for hidden components
695 for (i = 0; i < buffer->NumPhysDisks; i++) {
697 if (mpt_raid_phys_disk_pg0(ioc,
698 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
701 mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus,
702 phys_disk.PhysDiskID);
704 mutex_lock(&ioc->sas_device_info_mutex);
705 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
707 if (!sas_info->is_logical_volume &&
708 (sas_info->fw.channel == phys_disk.PhysDiskBus &&
709 sas_info->fw.id == phys_disk.PhysDiskID)) {
710 sas_info->is_hidden_raid_component = 1;
711 sas_info->volume_id = starget->id;
714 mutex_unlock(&ioc->sas_device_info_mutex);
719 * Delete all matching devices out of the list
721 mutex_lock(&ioc->sas_device_info_mutex);
722 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
724 if (sas_info->is_logical_volume && sas_info->fw.id ==
726 list_del(&sas_info->list);
731 sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
733 sas_info->fw.id = starget->id;
734 sas_info->os.id = starget->id;
735 sas_info->os.channel = starget->channel;
736 sas_info->is_logical_volume = 1;
737 INIT_LIST_HEAD(&sas_info->list);
738 list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
740 mutex_unlock(&ioc->sas_device_info_mutex);
744 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
749 * mptsas_add_device_component_starget -
750 * @ioc: Pointer to MPT_ADAPTER structure
755 mptsas_add_device_component_starget(MPT_ADAPTER *ioc,
756 struct scsi_target *starget)
759 struct sas_rphy *rphy;
760 struct mptsas_phyinfo *phy_info = NULL;
761 struct mptsas_enclosure enclosure_info;
763 rphy = dev_to_rphy(starget->dev.parent);
764 vtarget = starget->hostdata;
765 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
766 rphy->identify.sas_address);
770 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
771 mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
772 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
773 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
774 phy_info->attached.handle_enclosure);
776 mptsas_add_device_component(ioc, phy_info->attached.channel,
777 phy_info->attached.id, phy_info->attached.sas_address,
778 phy_info->attached.device_info,
779 phy_info->attached.slot, enclosure_info.enclosure_logical_id);
783 * mptsas_del_device_component_by_os - Once a device has been removed, we mark the entry in the list as being cached
784 * @ioc: Pointer to MPT_ADAPTER structure
785 * @channel: os mapped id's
790 mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
792 struct mptsas_device_info *sas_info, *next;
797 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
799 if (sas_info->os.channel == channel && sas_info->os.id == id)
800 sas_info->is_cached = 1;
805 * mptsas_del_device_components - Cleaning the list
806 * @ioc: Pointer to MPT_ADAPTER structure
810 mptsas_del_device_components(MPT_ADAPTER *ioc)
812 struct mptsas_device_info *sas_info, *next;
814 mutex_lock(&ioc->sas_device_info_mutex);
815 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
817 list_del(&sas_info->list);
820 mutex_unlock(&ioc->sas_device_info_mutex);
825 * mptsas_setup_wide_ports
827 * Updates for new and existing narrow/wide port configuration
828 * in the sas_topology
831 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
833 struct mptsas_portinfo_details * port_details;
834 struct mptsas_phyinfo *phy_info, *phy_info_cmp;
838 mutex_lock(&ioc->sas_topology_mutex);
840 phy_info = port_info->phy_info;
841 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
842 if (phy_info->attached.handle)
844 port_details = phy_info->port_details;
847 if (port_details->num_phys < 2)
850 * Removing a phy from a port, letting the last
851 * phy be removed by firmware events.
853 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
854 "%s: [%p]: deleting phy = %d\n",
855 ioc->name, __func__, port_details, i));
856 port_details->num_phys--;
857 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
858 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
860 devtprintk(ioc, dev_printk(KERN_DEBUG,
861 &phy_info->phy->dev, MYIOC_s_FMT
862 "delete phy %d, phy-obj (0x%p)\n", ioc->name,
863 phy_info->phy_id, phy_info->phy));
864 sas_port_delete_phy(port_details->port, phy_info->phy);
866 phy_info->port_details = NULL;
870 * Populate and refresh the tree
872 phy_info = port_info->phy_info;
873 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
874 sas_address = phy_info->attached.sas_address;
875 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
876 ioc->name, i, (unsigned long long)sas_address));
879 port_details = phy_info->port_details;
884 port_details = kzalloc(sizeof(struct
885 mptsas_portinfo_details), GFP_KERNEL);
888 port_details->num_phys = 1;
889 port_details->port_info = port_info;
890 if (phy_info->phy_id < 64 )
891 port_details->phy_bitmask |=
892 (1 << phy_info->phy_id);
893 phy_info->sas_port_add_phy=1;
894 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
895 "phy_id=%d sas_address=0x%018llX\n",
896 ioc->name, i, (unsigned long long)sas_address));
897 phy_info->port_details = port_details;
900 if (i == port_info->num_phys - 1)
902 phy_info_cmp = &port_info->phy_info[i + 1];
903 for (j = i + 1 ; j < port_info->num_phys ; j++,
905 if (!phy_info_cmp->attached.sas_address)
907 if (sas_address != phy_info_cmp->attached.sas_address)
909 if (phy_info_cmp->port_details == port_details )
911 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
912 "\t\tphy_id=%d sas_address=0x%018llX\n",
913 ioc->name, j, (unsigned long long)
914 phy_info_cmp->attached.sas_address));
915 if (phy_info_cmp->port_details) {
917 mptsas_get_rphy(phy_info_cmp);
919 mptsas_get_port(phy_info_cmp);
920 port_details->starget =
921 mptsas_get_starget(phy_info_cmp);
922 port_details->num_phys =
923 phy_info_cmp->port_details->num_phys;
924 if (!phy_info_cmp->port_details->num_phys)
925 kfree(phy_info_cmp->port_details);
927 phy_info_cmp->sas_port_add_phy=1;
929 * Adding a phy to a port
931 phy_info_cmp->port_details = port_details;
932 if (phy_info_cmp->phy_id < 64 )
933 port_details->phy_bitmask |=
934 (1 << phy_info_cmp->phy_id);
935 port_details->num_phys++;
941 for (i = 0; i < port_info->num_phys; i++) {
942 port_details = port_info->phy_info[i].port_details;
945 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
946 "%s: [%p]: phy_id=%02d num_phys=%02d "
947 "bitmask=0x%016llX\n", ioc->name, __func__,
948 port_details, i, port_details->num_phys,
949 (unsigned long long)port_details->phy_bitmask));
950 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
951 ioc->name, port_details->port, port_details->rphy));
953 dsaswideprintk(ioc, printk("\n"));
954 mutex_unlock(&ioc->sas_topology_mutex);
958 * csmisas_find_vtarget
966 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
968 struct scsi_device *sdev;
970 VirtTarget *vtarget = NULL;
972 shost_for_each_device(sdev, ioc->sh) {
973 vdevice = sdev->hostdata;
974 if ((vdevice == NULL) ||
975 (vdevice->vtarget == NULL))
977 if ((vdevice->vtarget->tflags &
978 MPT_TARGET_FLAGS_RAID_COMPONENT ||
979 vdevice->vtarget->raidVolume))
981 if (vdevice->vtarget->id == id &&
982 vdevice->vtarget->channel == channel)
983 vtarget = vdevice->vtarget;
989 mptsas_queue_device_delete(MPT_ADAPTER *ioc,
990 MpiEventDataSasDeviceStatusChange_t *sas_event_data)
992 struct fw_event_work *fw_event;
994 fw_event = kzalloc(sizeof(*fw_event) +
995 sizeof(MpiEventDataSasDeviceStatusChange_t),
998 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
999 ioc->name, __func__, __LINE__);
1002 memcpy(fw_event->event_data, sas_event_data,
1003 sizeof(MpiEventDataSasDeviceStatusChange_t));
1004 fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
1005 fw_event->ioc = ioc;
1006 mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1010 mptsas_queue_rescan(MPT_ADAPTER *ioc)
1012 struct fw_event_work *fw_event;
1014 fw_event = kzalloc(sizeof(*fw_event), GFP_ATOMIC);
1016 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1017 ioc->name, __func__, __LINE__);
1020 fw_event->event = -1;
1021 fw_event->ioc = ioc;
1022 mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1027 * mptsas_target_reset
1029 * Issues TARGET_RESET to end device using handshaking method
1035 * Returns (1) success
1040 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
1043 SCSITaskMgmt_t *pScsiTm;
1044 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
1048 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
1050 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1051 "%s, no msg frames @%d!!\n", ioc->name,
1052 __func__, __LINE__));
1056 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1059 /* Format the Request
1061 pScsiTm = (SCSITaskMgmt_t *) mf;
1062 memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
1063 pScsiTm->TargetID = id;
1064 pScsiTm->Bus = channel;
1065 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1066 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
1067 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
1069 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
1071 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1072 "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
1073 ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
1075 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
1081 mpt_clear_taskmgmt_in_progress_flag(ioc);
1086 mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
1088 scsi_device_set_state(sdev, SDEV_BLOCK);
1092 mptsas_block_io_starget(struct scsi_target *starget)
1095 starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
1099 * mptsas_target_reset_queue
1101 * Receive request for TARGET_RESET after receiving an firmware
1102 * event NOT_RESPONDING_EVENT, then put command in link list
1103 * and queue if task_queue already in use.
1110 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
1111 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
1113 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1114 VirtTarget *vtarget = NULL;
1115 struct mptsas_target_reset_event *target_reset_list;
1118 id = sas_event_data->TargetID;
1119 channel = sas_event_data->Bus;
1121 vtarget = mptsas_find_vtarget(ioc, channel, id);
1123 mptsas_block_io_starget(vtarget->starget);
1124 vtarget->deleted = 1; /* block IO */
1127 target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
1129 if (!target_reset_list) {
1130 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1131 "%s, failed to allocate mem @%d..!!\n",
1132 ioc->name, __func__, __LINE__));
1136 memcpy(&target_reset_list->sas_event_data, sas_event_data,
1137 sizeof(*sas_event_data));
1138 list_add_tail(&target_reset_list->list, &hd->target_reset_list);
1140 target_reset_list->time_count = jiffies;
1142 if (mptsas_target_reset(ioc, channel, id)) {
1143 target_reset_list->target_reset_issued = 1;
1148 * mptsas_schedule_target_reset- send pending target reset
1149 * @iocp: per adapter object
1151 * This function will delete scheduled target reset from the list and
1152 * try to send next target reset. This will be called from completion
1153 * context of any Task management command.
1157 mptsas_schedule_target_reset(void *iocp)
1159 MPT_ADAPTER *ioc = (MPT_ADAPTER *)(iocp);
1160 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1161 struct list_head *head = &hd->target_reset_list;
1162 struct mptsas_target_reset_event *target_reset_list;
1165 * issue target reset to next device in the queue
1168 head = &hd->target_reset_list;
1169 if (list_empty(head))
1172 target_reset_list = list_entry(head->next,
1173 struct mptsas_target_reset_event, list);
1175 id = target_reset_list->sas_event_data.TargetID;
1176 channel = target_reset_list->sas_event_data.Bus;
1177 target_reset_list->time_count = jiffies;
1179 if (mptsas_target_reset(ioc, channel, id))
1180 target_reset_list->target_reset_issued = 1;
1186 * mptsas_taskmgmt_complete - complete SAS task management function
1187 * @ioc: Pointer to MPT_ADAPTER structure
1189 * Completion for TARGET_RESET after NOT_RESPONDING_EVENT, enable work
1190 * queue to finish off removing device from upper layers. then send next
1191 * TARGET_RESET in the queue.
1194 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
1196 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1197 struct list_head *head = &hd->target_reset_list;
1199 struct mptsas_target_reset_event *target_reset_list;
1200 SCSITaskMgmtReply_t *pScsiTmReply;
1202 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
1203 "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
1205 pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
1209 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1210 "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
1211 "\ttask_type = 0x%02X, iocstatus = 0x%04X "
1212 "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
1213 "term_cmnds = %d\n", ioc->name,
1214 pScsiTmReply->Bus, pScsiTmReply->TargetID,
1215 pScsiTmReply->TaskType,
1216 le16_to_cpu(pScsiTmReply->IOCStatus),
1217 le32_to_cpu(pScsiTmReply->IOCLogInfo),
1218 pScsiTmReply->ResponseCode,
1219 le32_to_cpu(pScsiTmReply->TerminationCount)));
1221 if (pScsiTmReply->ResponseCode)
1222 mptscsih_taskmgmt_response_code(ioc,
1223 pScsiTmReply->ResponseCode);
1225 if (pScsiTmReply->TaskType ==
1226 MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
1227 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET) {
1228 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
1229 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
1230 memcpy(ioc->taskmgmt_cmds.reply, mr,
1231 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
1232 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
1233 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
1234 complete(&ioc->taskmgmt_cmds.done);
1240 mpt_clear_taskmgmt_in_progress_flag(ioc);
1242 if (list_empty(head))
1245 target_reset_list = list_entry(head->next,
1246 struct mptsas_target_reset_event, list);
1248 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1249 "TaskMgmt: completed (%d seconds)\n",
1250 ioc->name, jiffies_to_msecs(jiffies -
1251 target_reset_list->time_count)/1000));
1253 id = pScsiTmReply->TargetID;
1254 channel = pScsiTmReply->Bus;
1255 target_reset_list->time_count = jiffies;
1258 * retry target reset
1260 if (!target_reset_list->target_reset_issued) {
1261 if (mptsas_target_reset(ioc, channel, id))
1262 target_reset_list->target_reset_issued = 1;
1267 * enable work queue to remove device from upper layers
1269 list_del(&target_reset_list->list);
1270 if (!ioc->fw_events_off)
1271 mptsas_queue_device_delete(ioc,
1272 &target_reset_list->sas_event_data);
1275 ioc->schedule_target_reset(ioc);
1281 * mptscsih_ioc_reset
1288 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1293 rc = mptscsih_ioc_reset(ioc, reset_phase);
1294 if ((ioc->bus_type != SAS) || (!rc))
1297 hd = shost_priv(ioc->sh);
1301 switch (reset_phase) {
1302 case MPT_IOC_SETUP_RESET:
1303 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1304 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
1305 mptsas_fw_event_off(ioc);
1307 case MPT_IOC_PRE_RESET:
1308 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1309 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
1311 case MPT_IOC_POST_RESET:
1312 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1313 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
1314 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
1315 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
1316 complete(&ioc->sas_mgmt.done);
1318 mptsas_cleanup_fw_event_q(ioc);
1319 mptsas_queue_rescan(ioc);
1331 * enum device_state -
1332 * @DEVICE_RETRY: need to retry the TUR
1333 * @DEVICE_ERROR: TUR return error, don't add device
1334 * @DEVICE_READY: device can be added
1344 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
1345 u32 form, u32 form_specific)
1347 ConfigExtendedPageHeader_t hdr;
1349 SasEnclosurePage0_t *buffer;
1350 dma_addr_t dma_handle;
1352 __le64 le_identifier;
1354 memset(&hdr, 0, sizeof(hdr));
1355 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
1357 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1358 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
1360 cfg.cfghdr.ehdr = &hdr;
1362 cfg.pageAddr = form + form_specific;
1363 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1364 cfg.dir = 0; /* read */
1365 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
1367 error = mpt_config(ioc, &cfg);
1370 if (!hdr.ExtPageLength) {
1375 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1382 cfg.physAddr = dma_handle;
1383 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1385 error = mpt_config(ioc, &cfg);
1387 goto out_free_consistent;
1389 /* save config data */
1390 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
1391 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
1392 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
1393 enclosure->flags = le16_to_cpu(buffer->Flags);
1394 enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
1395 enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
1396 enclosure->start_id = buffer->StartTargetID;
1397 enclosure->start_channel = buffer->StartBus;
1398 enclosure->sep_id = buffer->SEPTargetID;
1399 enclosure->sep_channel = buffer->SEPBus;
1401 out_free_consistent:
1402 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1403 buffer, dma_handle);
1409 * mptsas_add_end_device - report a new end device to sas transport layer
1410 * @ioc: Pointer to MPT_ADAPTER structure
1411 * @phy_info: describes attached device
1413 * return (0) success (1) failure
1417 mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1419 struct sas_rphy *rphy;
1420 struct sas_port *port;
1421 struct sas_identify identify;
1426 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1427 "%s: exit at line=%d\n", ioc->name,
1428 __func__, __LINE__));
1432 fw_id = phy_info->attached.id;
1434 if (mptsas_get_rphy(phy_info)) {
1435 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1436 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1437 __func__, fw_id, __LINE__));
1441 port = mptsas_get_port(phy_info);
1443 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1444 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1445 __func__, fw_id, __LINE__));
1449 if (phy_info->attached.device_info &
1450 MPI_SAS_DEVICE_INFO_SSP_TARGET)
1452 if (phy_info->attached.device_info &
1453 MPI_SAS_DEVICE_INFO_STP_TARGET)
1455 if (phy_info->attached.device_info &
1456 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1459 printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
1460 " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
1461 phy_info->attached.channel, phy_info->attached.id,
1462 phy_info->attached.phy_id, (unsigned long long)
1463 phy_info->attached.sas_address);
1465 mptsas_parse_device_info(&identify, &phy_info->attached);
1466 rphy = sas_end_device_alloc(port);
1468 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1469 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1470 __func__, fw_id, __LINE__));
1471 return 5; /* non-fatal: an rphy can be added later */
1474 rphy->identify = identify;
1475 if (sas_rphy_add(rphy)) {
1476 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1477 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1478 __func__, fw_id, __LINE__));
1479 sas_rphy_free(rphy);
1482 mptsas_set_rphy(ioc, phy_info, rphy);
1487 * mptsas_del_end_device - report a deleted end device to sas transport layer
1488 * @ioc: Pointer to MPT_ADAPTER structure
1489 * @phy_info: describes attached device
1493 mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1495 struct sas_rphy *rphy;
1496 struct sas_port *port;
1497 struct mptsas_portinfo *port_info;
1498 struct mptsas_phyinfo *phy_info_parent;
1507 fw_id = phy_info->attached.id;
1508 sas_address = phy_info->attached.sas_address;
1510 if (!phy_info->port_details) {
1511 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1512 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1513 __func__, fw_id, __LINE__));
1516 rphy = mptsas_get_rphy(phy_info);
1518 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1519 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1520 __func__, fw_id, __LINE__));
1524 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_INITIATOR
1525 || phy_info->attached.device_info
1526 & MPI_SAS_DEVICE_INFO_SMP_INITIATOR
1527 || phy_info->attached.device_info
1528 & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1530 if (phy_info->attached.device_info &
1531 MPI_SAS_DEVICE_INFO_SSP_TARGET)
1533 if (phy_info->attached.device_info &
1534 MPI_SAS_DEVICE_INFO_STP_TARGET)
1536 if (phy_info->attached.device_info &
1537 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1540 dev_printk(KERN_DEBUG, &rphy->dev, MYIOC_s_FMT
1541 "removing %s device: fw_channel %d, fw_id %d, phy %d,"
1542 "sas_addr 0x%llx\n", ioc->name, ds, phy_info->attached.channel,
1543 phy_info->attached.id, phy_info->attached.phy_id,
1544 (unsigned long long) sas_address);
1546 port = mptsas_get_port(phy_info);
1548 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1549 "%s: fw_id=%d exit at line=%d\n", ioc->name,
1550 __func__, fw_id, __LINE__));
1553 port_info = phy_info->portinfo;
1554 phy_info_parent = port_info->phy_info;
1555 for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
1556 if (!phy_info_parent->phy)
1558 if (phy_info_parent->attached.sas_address !=
1561 dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
1562 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
1563 ioc->name, phy_info_parent->phy_id,
1564 phy_info_parent->phy);
1565 sas_port_delete_phy(port, phy_info_parent->phy);
1568 dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
1569 "delete port %d, sas_addr (0x%llx)\n", ioc->name,
1570 port->port_identifier, (unsigned long long)sas_address);
1571 sas_port_delete(port);
1572 mptsas_set_port(ioc, phy_info, NULL);
1573 mptsas_port_delete(ioc, phy_info->port_details);
1576 static struct mptsas_phyinfo *
1577 mptsas_refreshing_device_handles(MPT_ADAPTER *ioc,
1578 struct mptsas_devinfo *sas_device)
1580 struct mptsas_phyinfo *phy_info;
1581 struct mptsas_portinfo *port_info;
1584 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
1585 sas_device->sas_address);
1588 port_info = phy_info->portinfo;
1591 mutex_lock(&ioc->sas_topology_mutex);
1592 for (i = 0; i < port_info->num_phys; i++) {
1593 if (port_info->phy_info[i].attached.sas_address !=
1594 sas_device->sas_address)
1596 port_info->phy_info[i].attached.channel = sas_device->channel;
1597 port_info->phy_info[i].attached.id = sas_device->id;
1598 port_info->phy_info[i].attached.sas_address =
1599 sas_device->sas_address;
1600 port_info->phy_info[i].attached.handle = sas_device->handle;
1601 port_info->phy_info[i].attached.handle_parent =
1602 sas_device->handle_parent;
1603 port_info->phy_info[i].attached.handle_enclosure =
1604 sas_device->handle_enclosure;
1606 mutex_unlock(&ioc->sas_topology_mutex);
1612 * mptsas_firmware_event_work - work thread for processing fw events
1613 * @work: work queue payload containing info describing the event
1618 mptsas_firmware_event_work(struct work_struct *work)
1620 struct fw_event_work *fw_event =
1621 container_of(work, struct fw_event_work, work.work);
1622 MPT_ADAPTER *ioc = fw_event->ioc;
1624 /* special rescan topology handling */
1625 if (fw_event->event == -1) {
1626 if (ioc->in_rescan) {
1627 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1628 "%s: rescan ignored as it is in progress\n",
1629 ioc->name, __func__));
1632 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rescan after "
1633 "reset\n", ioc->name, __func__));
1635 mptsas_not_responding_devices(ioc);
1636 mptsas_scan_sas_topology(ioc);
1638 mptsas_free_fw_event(ioc, fw_event);
1639 mptsas_fw_event_on(ioc);
1643 /* events handling turned off during host reset */
1644 if (ioc->fw_events_off) {
1645 mptsas_free_fw_event(ioc, fw_event);
1649 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_event=(0x%p), "
1650 "event = (0x%02x)\n", ioc->name, __func__, fw_event,
1651 (fw_event->event & 0xFF)));
1653 switch (fw_event->event) {
1654 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
1655 mptsas_send_sas_event(fw_event);
1657 case MPI_EVENT_INTEGRATED_RAID:
1658 mptsas_send_raid_event(fw_event);
1661 mptsas_send_ir2_event(fw_event);
1663 case MPI_EVENT_PERSISTENT_TABLE_FULL:
1664 mptbase_sas_persist_operation(ioc,
1665 MPI_SAS_OP_CLEAR_NOT_PRESENT);
1666 mptsas_free_fw_event(ioc, fw_event);
1668 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
1669 mptsas_broadcast_primative_work(fw_event);
1671 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
1672 mptsas_send_expander_event(fw_event);
1674 case MPI_EVENT_SAS_PHY_LINK_STATUS:
1675 mptsas_send_link_status_event(fw_event);
1677 case MPI_EVENT_QUEUE_FULL:
1678 mptsas_handle_queue_full_event(fw_event);
1686 mptsas_slave_configure(struct scsi_device *sdev)
1688 struct Scsi_Host *host = sdev->host;
1689 MPT_SCSI_HOST *hd = shost_priv(host);
1690 MPT_ADAPTER *ioc = hd->ioc;
1691 VirtDevice *vdevice = sdev->hostdata;
1693 if (vdevice->vtarget->deleted) {
1694 sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
1695 vdevice->vtarget->deleted = 0;
1699 * RAID volumes placed beyond the last expected port.
1700 * Ignore sending sas mode pages in that case..
1702 if (sdev->channel == MPTSAS_RAID_CHANNEL) {
1703 mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
1707 sas_read_port_mode_page(sdev);
1709 mptsas_add_device_component_starget(ioc, scsi_target(sdev));
1712 return mptscsih_slave_configure(sdev);
1716 mptsas_target_alloc(struct scsi_target *starget)
1718 struct Scsi_Host *host = dev_to_shost(&starget->dev);
1719 MPT_SCSI_HOST *hd = shost_priv(host);
1720 VirtTarget *vtarget;
1722 struct sas_rphy *rphy;
1723 struct mptsas_portinfo *p;
1725 MPT_ADAPTER *ioc = hd->ioc;
1727 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
1731 vtarget->starget = starget;
1732 vtarget->ioc_id = ioc->id;
1733 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
1738 * RAID volumes placed beyond the last expected port.
1740 if (starget->channel == MPTSAS_RAID_CHANNEL) {
1741 if (!ioc->raid_data.pIocPg2) {
1745 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
1746 if (id == ioc->raid_data.pIocPg2->
1747 RaidVolume[i].VolumeID) {
1748 channel = ioc->raid_data.pIocPg2->
1749 RaidVolume[i].VolumeBus;
1752 vtarget->raidVolume = 1;
1756 rphy = dev_to_rphy(starget->dev.parent);
1757 mutex_lock(&ioc->sas_topology_mutex);
1758 list_for_each_entry(p, &ioc->sas_topology, list) {
1759 for (i = 0; i < p->num_phys; i++) {
1760 if (p->phy_info[i].attached.sas_address !=
1761 rphy->identify.sas_address)
1763 id = p->phy_info[i].attached.id;
1764 channel = p->phy_info[i].attached.channel;
1765 mptsas_set_starget(&p->phy_info[i], starget);
1768 * Exposing hidden raid components
1770 if (mptscsih_is_phys_disk(ioc, channel, id)) {
1771 id = mptscsih_raid_id_to_num(ioc,
1774 MPT_TARGET_FLAGS_RAID_COMPONENT;
1775 p->phy_info[i].attached.phys_disk_num = id;
1777 mutex_unlock(&ioc->sas_topology_mutex);
1781 mutex_unlock(&ioc->sas_topology_mutex);
1788 vtarget->channel = channel;
1789 starget->hostdata = vtarget;
1794 mptsas_target_destroy(struct scsi_target *starget)
1796 struct Scsi_Host *host = dev_to_shost(&starget->dev);
1797 MPT_SCSI_HOST *hd = shost_priv(host);
1798 struct sas_rphy *rphy;
1799 struct mptsas_portinfo *p;
1801 MPT_ADAPTER *ioc = hd->ioc;
1802 VirtTarget *vtarget;
1804 if (!starget->hostdata)
1807 vtarget = starget->hostdata;
1809 mptsas_del_device_component_by_os(ioc, starget->channel,
1813 if (starget->channel == MPTSAS_RAID_CHANNEL)
1816 rphy = dev_to_rphy(starget->dev.parent);
1817 list_for_each_entry(p, &ioc->sas_topology, list) {
1818 for (i = 0; i < p->num_phys; i++) {
1819 if (p->phy_info[i].attached.sas_address !=
1820 rphy->identify.sas_address)
1823 starget_printk(KERN_INFO, starget, MYIOC_s_FMT
1824 "delete device: fw_channel %d, fw_id %d, phy %d, "
1825 "sas_addr 0x%llx\n", ioc->name,
1826 p->phy_info[i].attached.channel,
1827 p->phy_info[i].attached.id,
1828 p->phy_info[i].attached.phy_id, (unsigned long long)
1829 p->phy_info[i].attached.sas_address);
1831 mptsas_set_starget(&p->phy_info[i], NULL);
1836 vtarget->starget = NULL;
1837 kfree(starget->hostdata);
1838 starget->hostdata = NULL;
1843 mptsas_slave_alloc(struct scsi_device *sdev)
1845 struct Scsi_Host *host = sdev->host;
1846 MPT_SCSI_HOST *hd = shost_priv(host);
1847 struct sas_rphy *rphy;
1848 struct mptsas_portinfo *p;
1849 VirtDevice *vdevice;
1850 struct scsi_target *starget;
1852 MPT_ADAPTER *ioc = hd->ioc;
1854 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
1856 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
1857 ioc->name, sizeof(VirtDevice));
1860 starget = scsi_target(sdev);
1861 vdevice->vtarget = starget->hostdata;
1863 if (sdev->channel == MPTSAS_RAID_CHANNEL)
1866 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1867 mutex_lock(&ioc->sas_topology_mutex);
1868 list_for_each_entry(p, &ioc->sas_topology, list) {
1869 for (i = 0; i < p->num_phys; i++) {
1870 if (p->phy_info[i].attached.sas_address !=
1871 rphy->identify.sas_address)
1873 vdevice->lun = sdev->lun;
1875 * Exposing hidden raid components
1877 if (mptscsih_is_phys_disk(ioc,
1878 p->phy_info[i].attached.channel,
1879 p->phy_info[i].attached.id))
1880 sdev->no_uld_attach = 1;
1881 mutex_unlock(&ioc->sas_topology_mutex);
1885 mutex_unlock(&ioc->sas_topology_mutex);
1891 vdevice->vtarget->num_luns++;
1892 sdev->hostdata = vdevice;
1897 mptsas_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
1901 VirtDevice *vdevice = SCpnt->device->hostdata;
1903 if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
1904 SCpnt->result = DID_NO_CONNECT << 16;
1905 SCpnt->scsi_done(SCpnt);
1909 hd = shost_priv(shost);
1912 if (ioc->sas_discovery_quiesce_io)
1913 return SCSI_MLQUEUE_HOST_BUSY;
1915 if (ioc->debug_level & MPT_DEBUG_SCSI)
1916 scsi_print_command(SCpnt);
1918 return mptscsih_qcmd(SCpnt);
1922 * mptsas_mptsas_eh_timed_out - resets the scsi_cmnd timeout
1923 * if the device under question is currently in the
1924 * device removal delay.
1925 * @sc: scsi command that the midlayer is about to time out
1928 static enum blk_eh_timer_return mptsas_eh_timed_out(struct scsi_cmnd *sc)
1932 VirtDevice *vdevice;
1933 enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1935 hd = shost_priv(sc->device->host);
1937 printk(KERN_ERR MYNAM ": %s: Can't locate host! (sc=%p)\n",
1943 if (ioc->bus_type != SAS) {
1944 printk(KERN_ERR MYNAM ": %s: Wrong bus type (sc=%p)\n",
1949 /* In case if IOC is in reset from internal context.
1950 * Do not execute EEH for the same IOC. SML should to reset timer.
1952 if (ioc->ioc_reset_in_progress) {
1953 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: ioc is in reset,"
1954 "SML need to reset the timer (sc=%p)\n",
1955 ioc->name, __func__, sc));
1956 rc = BLK_EH_RESET_TIMER;
1958 vdevice = sc->device->hostdata;
1959 if (vdevice && vdevice->vtarget && (vdevice->vtarget->inDMD
1960 || vdevice->vtarget->deleted)) {
1961 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: target removed "
1962 "or in device removal delay (sc=%p)\n",
1963 ioc->name, __func__, sc));
1964 rc = BLK_EH_RESET_TIMER;
1973 static struct scsi_host_template mptsas_driver_template = {
1974 .module = THIS_MODULE,
1975 .proc_name = "mptsas",
1976 .show_info = mptscsih_show_info,
1977 .name = "MPT SAS Host",
1978 .info = mptscsih_info,
1979 .queuecommand = mptsas_qcmd,
1980 .target_alloc = mptsas_target_alloc,
1981 .slave_alloc = mptsas_slave_alloc,
1982 .slave_configure = mptsas_slave_configure,
1983 .target_destroy = mptsas_target_destroy,
1984 .slave_destroy = mptscsih_slave_destroy,
1985 .change_queue_depth = mptscsih_change_queue_depth,
1986 .eh_timed_out = mptsas_eh_timed_out,
1987 .eh_abort_handler = mptscsih_abort,
1988 .eh_device_reset_handler = mptscsih_dev_reset,
1989 .eh_host_reset_handler = mptscsih_host_reset,
1990 .bios_param = mptscsih_bios_param,
1991 .can_queue = MPT_SAS_CAN_QUEUE,
1993 .sg_tablesize = MPT_SCSI_SG_DEPTH,
1994 .max_sectors = 8192,
1996 .use_clustering = ENABLE_CLUSTERING,
1997 .shost_attrs = mptscsih_host_attrs,
2001 static int mptsas_get_linkerrors(struct sas_phy *phy)
2003 MPT_ADAPTER *ioc = phy_to_ioc(phy);
2004 ConfigExtendedPageHeader_t hdr;
2006 SasPhyPage1_t *buffer;
2007 dma_addr_t dma_handle;
2010 /* FIXME: only have link errors on local phys */
2011 if (!scsi_is_sas_phy_local(phy))
2014 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
2015 hdr.ExtPageLength = 0;
2016 hdr.PageNumber = 1 /* page number 1*/;
2019 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2020 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2022 cfg.cfghdr.ehdr = &hdr;
2024 cfg.pageAddr = phy->identify.phy_identifier;
2025 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2026 cfg.dir = 0; /* read */
2027 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2029 error = mpt_config(ioc, &cfg);
2032 if (!hdr.ExtPageLength)
2035 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2040 cfg.physAddr = dma_handle;
2041 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2043 error = mpt_config(ioc, &cfg);
2045 goto out_free_consistent;
2047 mptsas_print_phy_pg1(ioc, buffer);
2049 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
2050 phy->running_disparity_error_count =
2051 le32_to_cpu(buffer->RunningDisparityErrorCount);
2052 phy->loss_of_dword_sync_count =
2053 le32_to_cpu(buffer->LossDwordSynchCount);
2054 phy->phy_reset_problem_count =
2055 le32_to_cpu(buffer->PhyResetProblemCount);
2057 out_free_consistent:
2058 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2059 buffer, dma_handle);
2063 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2064 MPT_FRAME_HDR *reply)
2066 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2067 if (reply != NULL) {
2068 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID;
2069 memcpy(ioc->sas_mgmt.reply, reply,
2070 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
2073 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
2074 ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING;
2075 complete(&ioc->sas_mgmt.done);
2081 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
2083 MPT_ADAPTER *ioc = phy_to_ioc(phy);
2084 SasIoUnitControlRequest_t *req;
2085 SasIoUnitControlReply_t *reply;
2088 unsigned long timeleft;
2089 int error = -ERESTARTSYS;
2091 /* FIXME: fusion doesn't allow non-local phy reset */
2092 if (!scsi_is_sas_phy_local(phy))
2095 /* not implemented for expanders */
2096 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
2099 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
2102 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2108 hdr = (MPIHeader_t *) mf;
2109 req = (SasIoUnitControlRequest_t *)mf;
2110 memset(req, 0, sizeof(SasIoUnitControlRequest_t));
2111 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
2112 req->MsgContext = hdr->MsgContext;
2113 req->Operation = hard_reset ?
2114 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
2115 req->PhyNum = phy->identify.phy_identifier;
2117 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2118 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2120 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
2122 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2124 mpt_free_msg_frame(ioc, mf);
2125 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2128 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2132 /* a reply frame is expected */
2133 if ((ioc->sas_mgmt.status &
2134 MPT_MGMT_STATUS_RF_VALID) == 0) {
2139 /* process the completed Reply Message Frame */
2140 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
2141 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
2142 printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
2143 ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
2151 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2152 mutex_unlock(&ioc->sas_mgmt.mutex);
2158 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
2160 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2162 struct mptsas_portinfo *p;
2163 struct mptsas_enclosure enclosure_info;
2164 u64 enclosure_handle;
2166 mutex_lock(&ioc->sas_topology_mutex);
2167 list_for_each_entry(p, &ioc->sas_topology, list) {
2168 for (i = 0; i < p->num_phys; i++) {
2169 if (p->phy_info[i].attached.sas_address ==
2170 rphy->identify.sas_address) {
2171 enclosure_handle = p->phy_info[i].
2172 attached.handle_enclosure;
2177 mutex_unlock(&ioc->sas_topology_mutex);
2181 mutex_unlock(&ioc->sas_topology_mutex);
2182 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
2183 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
2184 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
2185 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
2187 *identifier = enclosure_info.enclosure_logical_id;
2192 mptsas_get_bay_identifier(struct sas_rphy *rphy)
2194 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2195 struct mptsas_portinfo *p;
2198 mutex_lock(&ioc->sas_topology_mutex);
2199 list_for_each_entry(p, &ioc->sas_topology, list) {
2200 for (i = 0; i < p->num_phys; i++) {
2201 if (p->phy_info[i].attached.sas_address ==
2202 rphy->identify.sas_address) {
2203 rc = p->phy_info[i].attached.slot;
2210 mutex_unlock(&ioc->sas_topology_mutex);
2214 static void mptsas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
2215 struct sas_rphy *rphy)
2217 MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
2219 SmpPassthroughRequest_t *smpreq;
2221 unsigned long timeleft;
2223 u64 sas_address = 0;
2224 unsigned int reslen = 0;
2227 /* do we need to support multiple segments? */
2228 if (job->request_payload.sg_cnt > 1 ||
2229 job->reply_payload.sg_cnt > 1) {
2230 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u, rsp %u\n",
2231 ioc->name, __func__, job->request_payload.payload_len,
2232 job->reply_payload.payload_len);
2236 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2240 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2246 smpreq = (SmpPassthroughRequest_t *)mf;
2247 memset(smpreq, 0, sizeof(*smpreq));
2249 smpreq->RequestDataLength =
2250 cpu_to_le16(job->request_payload.payload_len - 4);
2251 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2254 sas_address = rphy->identify.sas_address;
2256 struct mptsas_portinfo *port_info;
2258 mutex_lock(&ioc->sas_topology_mutex);
2259 port_info = ioc->hba_port_info;
2260 if (port_info && port_info->phy_info)
2262 port_info->phy_info[0].phy->identify.sas_address;
2263 mutex_unlock(&ioc->sas_topology_mutex);
2266 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2269 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2272 flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2273 MPI_SGE_FLAGS_END_OF_BUFFER |
2274 MPI_SGE_FLAGS_DIRECTION)
2275 << MPI_SGE_FLAGS_SHIFT;
2277 if (!dma_map_sg(&ioc->pcidev->dev, job->request_payload.sg_list,
2278 1, PCI_DMA_BIDIRECTIONAL))
2281 flagsLength |= (sg_dma_len(job->request_payload.sg_list) - 4);
2282 ioc->add_sge(psge, flagsLength,
2283 sg_dma_address(job->request_payload.sg_list));
2284 psge += ioc->SGE_size;
2287 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2288 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2289 MPI_SGE_FLAGS_IOC_TO_HOST |
2290 MPI_SGE_FLAGS_END_OF_BUFFER;
2292 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2294 if (!dma_map_sg(&ioc->pcidev->dev, job->reply_payload.sg_list,
2295 1, PCI_DMA_BIDIRECTIONAL))
2297 flagsLength |= sg_dma_len(job->reply_payload.sg_list) + 4;
2298 ioc->add_sge(psge, flagsLength,
2299 sg_dma_address(job->reply_payload.sg_list));
2301 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2302 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2304 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2305 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2307 mpt_free_msg_frame(ioc, mf);
2309 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2312 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2317 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2318 SmpPassthroughReply_t *smprep;
2320 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2321 memcpy(job->reply, smprep, sizeof(*smprep));
2322 job->reply_len = sizeof(*smprep);
2323 reslen = smprep->ResponseDataLength;
2325 printk(MYIOC_s_ERR_FMT
2326 "%s: smp passthru reply failed to be returned\n",
2327 ioc->name, __func__);
2332 dma_unmap_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, 1,
2333 PCI_DMA_BIDIRECTIONAL);
2335 dma_unmap_sg(&ioc->pcidev->dev, job->request_payload.sg_list, 1,
2336 PCI_DMA_BIDIRECTIONAL);
2339 mpt_free_msg_frame(ioc, mf);
2341 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2342 mutex_unlock(&ioc->sas_mgmt.mutex);
2344 bsg_job_done(job, ret, reslen);
2347 static struct sas_function_template mptsas_transport_functions = {
2348 .get_linkerrors = mptsas_get_linkerrors,
2349 .get_enclosure_identifier = mptsas_get_enclosure_identifier,
2350 .get_bay_identifier = mptsas_get_bay_identifier,
2351 .phy_reset = mptsas_phy_reset,
2352 .smp_handler = mptsas_smp_handler,
2355 static struct scsi_transport_template *mptsas_transport_template;
2358 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
2360 ConfigExtendedPageHeader_t hdr;
2362 SasIOUnitPage0_t *buffer;
2363 dma_addr_t dma_handle;
2366 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
2367 hdr.ExtPageLength = 0;
2371 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2372 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2374 cfg.cfghdr.ehdr = &hdr;
2377 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2378 cfg.dir = 0; /* read */
2379 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2381 error = mpt_config(ioc, &cfg);
2384 if (!hdr.ExtPageLength) {
2389 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2396 cfg.physAddr = dma_handle;
2397 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2399 error = mpt_config(ioc, &cfg);
2401 goto out_free_consistent;
2403 port_info->num_phys = buffer->NumPhys;
2404 port_info->phy_info = kcalloc(port_info->num_phys,
2405 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2406 if (!port_info->phy_info) {
2408 goto out_free_consistent;
2411 ioc->nvdata_version_persistent =
2412 le16_to_cpu(buffer->NvdataVersionPersistent);
2413 ioc->nvdata_version_default =
2414 le16_to_cpu(buffer->NvdataVersionDefault);
2416 for (i = 0; i < port_info->num_phys; i++) {
2417 mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
2418 port_info->phy_info[i].phy_id = i;
2419 port_info->phy_info[i].port_id =
2420 buffer->PhyData[i].Port;
2421 port_info->phy_info[i].negotiated_link_rate =
2422 buffer->PhyData[i].NegotiatedLinkRate;
2423 port_info->phy_info[i].portinfo = port_info;
2424 port_info->phy_info[i].handle =
2425 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
2428 out_free_consistent:
2429 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2430 buffer, dma_handle);
2436 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
2438 ConfigExtendedPageHeader_t hdr;
2440 SasIOUnitPage1_t *buffer;
2441 dma_addr_t dma_handle;
2443 u8 device_missing_delay;
2445 memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
2446 memset(&cfg, 0, sizeof(CONFIGPARMS));
2448 cfg.cfghdr.ehdr = &hdr;
2449 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2450 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2451 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2452 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2453 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
2454 cfg.cfghdr.ehdr->PageNumber = 1;
2456 error = mpt_config(ioc, &cfg);
2459 if (!hdr.ExtPageLength) {
2464 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2471 cfg.physAddr = dma_handle;
2472 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2474 error = mpt_config(ioc, &cfg);
2476 goto out_free_consistent;
2478 ioc->io_missing_delay =
2479 le16_to_cpu(buffer->IODeviceMissingDelay);
2480 device_missing_delay = buffer->ReportDeviceMissingDelay;
2481 ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
2482 (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
2483 device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
2485 out_free_consistent:
2486 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2487 buffer, dma_handle);
2493 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2494 u32 form, u32 form_specific)
2496 ConfigExtendedPageHeader_t hdr;
2498 SasPhyPage0_t *buffer;
2499 dma_addr_t dma_handle;
2502 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
2503 hdr.ExtPageLength = 0;
2507 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2508 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2510 cfg.cfghdr.ehdr = &hdr;
2511 cfg.dir = 0; /* read */
2512 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2514 /* Get Phy Pg 0 for each Phy. */
2516 cfg.pageAddr = form + form_specific;
2517 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2519 error = mpt_config(ioc, &cfg);
2523 if (!hdr.ExtPageLength) {
2528 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2535 cfg.physAddr = dma_handle;
2536 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2538 error = mpt_config(ioc, &cfg);
2540 goto out_free_consistent;
2542 mptsas_print_phy_pg0(ioc, buffer);
2544 phy_info->hw_link_rate = buffer->HwLinkRate;
2545 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2546 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2547 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2549 out_free_consistent:
2550 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2551 buffer, dma_handle);
2557 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
2558 u32 form, u32 form_specific)
2560 ConfigExtendedPageHeader_t hdr;
2562 SasDevicePage0_t *buffer;
2563 dma_addr_t dma_handle;
2567 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
2568 hdr.ExtPageLength = 0;
2572 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2573 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
2575 cfg.cfghdr.ehdr = &hdr;
2576 cfg.pageAddr = form + form_specific;
2578 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2579 cfg.dir = 0; /* read */
2580 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2582 memset(device_info, 0, sizeof(struct mptsas_devinfo));
2583 error = mpt_config(ioc, &cfg);
2586 if (!hdr.ExtPageLength) {
2591 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2598 cfg.physAddr = dma_handle;
2599 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2601 error = mpt_config(ioc, &cfg);
2603 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2605 goto out_free_consistent;
2609 goto out_free_consistent;
2611 mptsas_print_device_pg0(ioc, buffer);
2613 memset(device_info, 0, sizeof(struct mptsas_devinfo));
2614 device_info->handle = le16_to_cpu(buffer->DevHandle);
2615 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
2616 device_info->handle_enclosure =
2617 le16_to_cpu(buffer->EnclosureHandle);
2618 device_info->slot = le16_to_cpu(buffer->Slot);
2619 device_info->phy_id = buffer->PhyNum;
2620 device_info->port_id = buffer->PhysicalPort;
2621 device_info->id = buffer->TargetID;
2622 device_info->phys_disk_num = ~0;
2623 device_info->channel = buffer->Bus;
2624 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2625 device_info->sas_address = le64_to_cpu(sas_address);
2626 device_info->device_info =
2627 le32_to_cpu(buffer->DeviceInfo);
2628 device_info->flags = le16_to_cpu(buffer->Flags);
2630 out_free_consistent:
2631 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2632 buffer, dma_handle);
2638 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
2639 u32 form, u32 form_specific)
2641 ConfigExtendedPageHeader_t hdr;
2643 SasExpanderPage0_t *buffer;
2644 dma_addr_t dma_handle;
2648 memset(port_info, 0, sizeof(struct mptsas_portinfo));
2649 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
2650 hdr.ExtPageLength = 0;
2654 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2655 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2657 cfg.cfghdr.ehdr = &hdr;
2659 cfg.pageAddr = form + form_specific;
2660 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2661 cfg.dir = 0; /* read */
2662 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2664 memset(port_info, 0, sizeof(struct mptsas_portinfo));
2665 error = mpt_config(ioc, &cfg);
2669 if (!hdr.ExtPageLength) {
2674 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2681 cfg.physAddr = dma_handle;
2682 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2684 error = mpt_config(ioc, &cfg);
2685 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2687 goto out_free_consistent;
2691 goto out_free_consistent;
2693 /* save config data */
2694 port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
2695 port_info->phy_info = kcalloc(port_info->num_phys,
2696 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2697 if (!port_info->phy_info) {
2699 goto out_free_consistent;
2702 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2703 for (i = 0; i < port_info->num_phys; i++) {
2704 port_info->phy_info[i].portinfo = port_info;
2705 port_info->phy_info[i].handle =
2706 le16_to_cpu(buffer->DevHandle);
2707 port_info->phy_info[i].identify.sas_address =
2708 le64_to_cpu(sas_address);
2709 port_info->phy_info[i].identify.handle_parent =
2710 le16_to_cpu(buffer->ParentDevHandle);
2713 out_free_consistent:
2714 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2715 buffer, dma_handle);
2721 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2722 u32 form, u32 form_specific)
2724 ConfigExtendedPageHeader_t hdr;
2726 SasExpanderPage1_t *buffer;
2727 dma_addr_t dma_handle;
2730 hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
2731 hdr.ExtPageLength = 0;
2735 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2736 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2738 cfg.cfghdr.ehdr = &hdr;
2740 cfg.pageAddr = form + form_specific;
2741 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2742 cfg.dir = 0; /* read */
2743 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2745 error = mpt_config(ioc, &cfg);
2749 if (!hdr.ExtPageLength) {
2754 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2761 cfg.physAddr = dma_handle;
2762 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2764 error = mpt_config(ioc, &cfg);
2766 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2768 goto out_free_consistent;
2772 goto out_free_consistent;
2775 mptsas_print_expander_pg1(ioc, buffer);
2777 /* save config data */
2778 phy_info->phy_id = buffer->PhyIdentifier;
2779 phy_info->port_id = buffer->PhysicalPort;
2780 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
2781 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2782 phy_info->hw_link_rate = buffer->HwLinkRate;
2783 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2784 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2786 out_free_consistent:
2787 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2788 buffer, dma_handle);
2793 struct rep_manu_request{
2800 struct rep_manu_reply{
2801 u8 smp_frame_type; /* 0x41 */
2802 u8 function; /* 0x01 */
2805 u16 expander_change_count;
2810 u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
2811 u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
2812 u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
2813 u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
2815 u8 component_revision_id;
2817 u8 vendor_specific[8];
2821 * mptsas_exp_repmanufacture_info -
2822 * @ioc: per adapter object
2823 * @sas_address: expander sas address
2824 * @edev: the sas_expander_device object
2826 * Fills in the sas_expander_device object when SMP port is created.
2828 * Returns 0 for success, non-zero for failure.
2831 mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
2832 u64 sas_address, struct sas_expander_device *edev)
2835 SmpPassthroughRequest_t *smpreq;
2836 SmpPassthroughReply_t *smprep;
2837 struct rep_manu_reply *manufacture_reply;
2838 struct rep_manu_request *manufacture_request;
2841 unsigned long timeleft;
2843 unsigned long flags;
2844 void *data_out = NULL;
2845 dma_addr_t data_out_dma = 0;
2848 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2849 if (ioc->ioc_reset_in_progress) {
2850 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2851 printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
2852 __func__, ioc->name);
2855 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2857 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2861 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2867 smpreq = (SmpPassthroughRequest_t *)mf;
2868 memset(smpreq, 0, sizeof(*smpreq));
2870 sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
2872 data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma);
2874 printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
2875 __FILE__, __LINE__, __func__);
2880 manufacture_request = data_out;
2881 manufacture_request->smp_frame_type = 0x40;
2882 manufacture_request->function = 1;
2883 manufacture_request->reserved = 0;
2884 manufacture_request->request_length = 0;
2886 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2887 smpreq->PhysicalPort = 0xFF;
2888 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2889 smpreq->RequestDataLength = sizeof(struct rep_manu_request);
2892 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2894 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2895 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2896 MPI_SGE_FLAGS_HOST_TO_IOC |
2897 MPI_SGE_FLAGS_END_OF_BUFFER;
2898 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2899 flagsLength |= sizeof(struct rep_manu_request);
2901 ioc->add_sge(psge, flagsLength, data_out_dma);
2902 psge += ioc->SGE_size;
2904 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2905 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2906 MPI_SGE_FLAGS_IOC_TO_HOST |
2907 MPI_SGE_FLAGS_END_OF_BUFFER;
2908 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2909 flagsLength |= sizeof(struct rep_manu_reply);
2910 ioc->add_sge(psge, flagsLength, data_out_dma +
2911 sizeof(struct rep_manu_request));
2913 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2914 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2916 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2917 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2919 mpt_free_msg_frame(ioc, mf);
2921 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2924 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2930 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2933 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2934 if (le16_to_cpu(smprep->ResponseDataLength) !=
2935 sizeof(struct rep_manu_reply))
2938 manufacture_reply = data_out + sizeof(struct rep_manu_request);
2939 strncpy(edev->vendor_id, manufacture_reply->vendor_id,
2940 SAS_EXPANDER_VENDOR_ID_LEN);
2941 strncpy(edev->product_id, manufacture_reply->product_id,
2942 SAS_EXPANDER_PRODUCT_ID_LEN);
2943 strncpy(edev->product_rev, manufacture_reply->product_rev,
2944 SAS_EXPANDER_PRODUCT_REV_LEN);
2945 edev->level = manufacture_reply->sas_format;
2946 if (manufacture_reply->sas_format) {
2947 strncpy(edev->component_vendor_id,
2948 manufacture_reply->component_vendor_id,
2949 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
2950 tmp = (u8 *)&manufacture_reply->component_id;
2951 edev->component_id = tmp[0] << 8 | tmp[1];
2952 edev->component_revision_id =
2953 manufacture_reply->component_revision_id;
2956 printk(MYIOC_s_ERR_FMT
2957 "%s: smp passthru reply failed to be returned\n",
2958 ioc->name, __func__);
2963 pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma);
2966 mpt_free_msg_frame(ioc, mf);
2968 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2969 mutex_unlock(&ioc->sas_mgmt.mutex);
2975 mptsas_parse_device_info(struct sas_identify *identify,
2976 struct mptsas_devinfo *device_info)
2980 identify->sas_address = device_info->sas_address;
2981 identify->phy_identifier = device_info->phy_id;
2984 * Fill in Phy Initiator Port Protocol.
2985 * Bits 6:3, more than one bit can be set, fall through cases.
2987 protocols = device_info->device_info & 0x78;
2988 identify->initiator_port_protocols = 0;
2989 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
2990 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
2991 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
2992 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
2993 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
2994 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
2995 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
2996 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
2999 * Fill in Phy Target Port Protocol.
3000 * Bits 10:7, more than one bit can be set, fall through cases.
3002 protocols = device_info->device_info & 0x780;
3003 identify->target_port_protocols = 0;
3004 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
3005 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
3006 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
3007 identify->target_port_protocols |= SAS_PROTOCOL_STP;
3008 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
3009 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
3010 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
3011 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
3014 * Fill in Attached device type.
3016 switch (device_info->device_info &
3017 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
3018 case MPI_SAS_DEVICE_INFO_NO_DEVICE:
3019 identify->device_type = SAS_PHY_UNUSED;
3021 case MPI_SAS_DEVICE_INFO_END_DEVICE:
3022 identify->device_type = SAS_END_DEVICE;
3024 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
3025 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
3027 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
3028 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
3033 static int mptsas_probe_one_phy(struct device *dev,
3034 struct mptsas_phyinfo *phy_info, int index, int local)
3037 struct sas_phy *phy;
3038 struct sas_port *port;
3040 VirtTarget *vtarget;
3047 if (!phy_info->phy) {
3048 phy = sas_phy_alloc(dev, index);
3054 phy = phy_info->phy;
3056 mptsas_parse_device_info(&phy->identify, &phy_info->identify);
3059 * Set Negotiated link rate.
3061 switch (phy_info->negotiated_link_rate) {
3062 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
3063 phy->negotiated_linkrate = SAS_PHY_DISABLED;
3065 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
3066 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
3068 case MPI_SAS_IOUNIT0_RATE_1_5:
3069 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
3071 case MPI_SAS_IOUNIT0_RATE_3_0:
3072 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
3074 case MPI_SAS_IOUNIT0_RATE_6_0:
3075 phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS;
3077 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
3078 case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
3080 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
3085 * Set Max hardware link rate.
3087 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3088 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
3089 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3091 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3092 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3099 * Set Max programmed link rate.
3101 switch (phy_info->programmed_link_rate &
3102 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3103 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
3104 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3106 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3107 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3114 * Set Min hardware link rate.
3116 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
3117 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
3118 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3120 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3121 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3128 * Set Min programmed link rate.
3130 switch (phy_info->programmed_link_rate &
3131 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
3132 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
3133 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3135 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3136 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3142 if (!phy_info->phy) {
3144 error = sas_phy_add(phy);
3149 phy_info->phy = phy;
3152 if (!phy_info->attached.handle ||
3153 !phy_info->port_details)
3156 port = mptsas_get_port(phy_info);
3157 ioc = phy_to_ioc(phy_info->phy);
3159 if (phy_info->sas_port_add_phy) {
3162 port = sas_port_alloc_num(dev);
3167 error = sas_port_add(port);
3169 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3170 "%s: exit at line=%d\n", ioc->name,
3171 __func__, __LINE__));
3174 mptsas_set_port(ioc, phy_info, port);
3175 devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
3176 MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
3177 ioc->name, port->port_identifier,
3178 (unsigned long long)phy_info->
3179 attached.sas_address));
3181 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3182 "sas_port_add_phy: phy_id=%d\n",
3183 ioc->name, phy_info->phy_id));
3184 sas_port_add_phy(port, phy_info->phy);
3185 phy_info->sas_port_add_phy = 0;
3186 devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3187 MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
3188 phy_info->phy_id, phy_info->phy));
3190 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
3192 struct sas_rphy *rphy;
3193 struct device *parent;
3194 struct sas_identify identify;
3196 parent = dev->parent->parent;
3198 * Let the hotplug_work thread handle processing
3199 * the adding/removing of devices that occur
3200 * after start of day.
3202 if (mptsas_is_end_device(&phy_info->attached) &&
3203 phy_info->attached.handle_parent) {
3207 mptsas_parse_device_info(&identify, &phy_info->attached);
3208 if (scsi_is_host_device(parent)) {
3209 struct mptsas_portinfo *port_info;
3212 port_info = ioc->hba_port_info;
3214 for (i = 0; i < port_info->num_phys; i++)
3215 if (port_info->phy_info[i].identify.sas_address ==
3216 identify.sas_address) {
3217 sas_port_mark_backlink(port);
3221 } else if (scsi_is_sas_rphy(parent)) {
3222 struct sas_rphy *parent_rphy = dev_to_rphy(parent);
3223 if (identify.sas_address ==
3224 parent_rphy->identify.sas_address) {
3225 sas_port_mark_backlink(port);
3230 switch (identify.device_type) {
3231 case SAS_END_DEVICE:
3232 rphy = sas_end_device_alloc(port);
3234 case SAS_EDGE_EXPANDER_DEVICE:
3235 case SAS_FANOUT_EXPANDER_DEVICE:
3236 rphy = sas_expander_alloc(port, identify.device_type);
3243 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3244 "%s: exit at line=%d\n", ioc->name,
3245 __func__, __LINE__));
3249 rphy->identify = identify;
3250 error = sas_rphy_add(rphy);
3252 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3253 "%s: exit at line=%d\n", ioc->name,
3254 __func__, __LINE__));
3255 sas_rphy_free(rphy);
3258 mptsas_set_rphy(ioc, phy_info, rphy);
3259 if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
3260 identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
3261 mptsas_exp_repmanufacture_info(ioc,
3262 identify.sas_address,
3263 rphy_to_expander_device(rphy));
3266 /* If the device exists,verify it wasn't previously flagged
3267 as a missing device. If so, clear it */
3268 vtarget = mptsas_find_vtarget(ioc,
3269 phy_info->attached.channel,
3270 phy_info->attached.id);
3271 if (vtarget && vtarget->inDMD) {
3272 printk(KERN_INFO "Device returned, unsetting inDMD\n");
3281 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
3283 struct mptsas_portinfo *port_info, *hba;
3284 int error = -ENOMEM, i;
3286 hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3290 error = mptsas_sas_io_unit_pg0(ioc, hba);
3292 goto out_free_port_info;
3294 mptsas_sas_io_unit_pg1(ioc);
3295 mutex_lock(&ioc->sas_topology_mutex);
3296 port_info = ioc->hba_port_info;
3298 ioc->hba_port_info = port_info = hba;
3299 ioc->hba_port_num_phy = port_info->num_phys;
3300 list_add_tail(&port_info->list, &ioc->sas_topology);
3302 for (i = 0; i < hba->num_phys; i++) {
3303 port_info->phy_info[i].negotiated_link_rate =
3304 hba->phy_info[i].negotiated_link_rate;
3305 port_info->phy_info[i].handle =
3306 hba->phy_info[i].handle;
3307 port_info->phy_info[i].port_id =
3308 hba->phy_info[i].port_id;
3310 kfree(hba->phy_info);
3314 mutex_unlock(&ioc->sas_topology_mutex);
3315 #if defined(CPQ_CIM)
3316 ioc->num_ports = port_info->num_phys;
3318 for (i = 0; i < port_info->num_phys; i++) {
3319 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
3320 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
3321 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
3322 port_info->phy_info[i].identify.handle =
3323 port_info->phy_info[i].handle;
3324 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
3325 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3326 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3327 port_info->phy_info[i].identify.handle);
3328 if (!ioc->hba_port_sas_addr)
3329 ioc->hba_port_sas_addr =
3330 port_info->phy_info[i].identify.sas_address;
3331 port_info->phy_info[i].identify.phy_id =
3332 port_info->phy_info[i].phy_id = i;
3333 if (port_info->phy_info[i].attached.handle)
3334 mptsas_sas_device_pg0(ioc,
3335 &port_info->phy_info[i].attached,
3336 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3337 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3338 port_info->phy_info[i].attached.handle);
3341 mptsas_setup_wide_ports(ioc, port_info);
3343 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3344 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
3345 &port_info->phy_info[i], ioc->sas_index, 1);
3356 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
3358 struct mptsas_portinfo *parent;
3359 struct device *parent_dev;
3360 struct sas_rphy *rphy;
3362 u64 sas_address; /* expander sas address */
3365 handle = port_info->phy_info[0].handle;
3366 sas_address = port_info->phy_info[0].identify.sas_address;
3367 for (i = 0; i < port_info->num_phys; i++) {
3368 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
3369 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
3370 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
3372 mptsas_sas_device_pg0(ioc,
3373 &port_info->phy_info[i].identify,
3374 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3375 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3376 port_info->phy_info[i].identify.handle);
3377 port_info->phy_info[i].identify.phy_id =
3378 port_info->phy_info[i].phy_id;
3380 if (port_info->phy_info[i].attached.handle) {
3381 mptsas_sas_device_pg0(ioc,
3382 &port_info->phy_info[i].attached,
3383 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3384 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3385 port_info->phy_info[i].attached.handle);
3386 port_info->phy_info[i].attached.phy_id =
3387 port_info->phy_info[i].phy_id;
3391 mutex_lock(&ioc->sas_topology_mutex);
3392 parent = mptsas_find_portinfo_by_handle(ioc,
3393 port_info->phy_info[0].identify.handle_parent);
3395 mutex_unlock(&ioc->sas_topology_mutex);
3398 for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
3400 if (parent->phy_info[i].attached.sas_address == sas_address) {
3401 rphy = mptsas_get_rphy(&parent->phy_info[i]);
3402 parent_dev = &rphy->dev;
3405 mutex_unlock(&ioc->sas_topology_mutex);
3407 mptsas_setup_wide_ports(ioc, port_info);
3408 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3409 mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
3414 mptsas_expander_event_add(MPT_ADAPTER *ioc,
3415 MpiEventDataSasExpanderStatusChange_t *expander_data)
3417 struct mptsas_portinfo *port_info;
3421 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3424 port_info->num_phys = (expander_data->NumPhys) ?
3425 expander_data->NumPhys : 1;
3426 port_info->phy_info = kcalloc(port_info->num_phys,
3427 sizeof(struct mptsas_phyinfo), GFP_KERNEL);
3428 if (!port_info->phy_info)
3430 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3431 for (i = 0; i < port_info->num_phys; i++) {
3432 port_info->phy_info[i].portinfo = port_info;
3433 port_info->phy_info[i].handle =
3434 le16_to_cpu(expander_data->DevHandle);
3435 port_info->phy_info[i].identify.sas_address =
3436 le64_to_cpu(sas_address);
3437 port_info->phy_info[i].identify.handle_parent =
3438 le16_to_cpu(expander_data->ParentDevHandle);
3441 mutex_lock(&ioc->sas_topology_mutex);
3442 list_add_tail(&port_info->list, &ioc->sas_topology);
3443 mutex_unlock(&ioc->sas_topology_mutex);
3445 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3446 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3447 (unsigned long long)sas_address);
3449 mptsas_expander_refresh(ioc, port_info);
3453 * mptsas_delete_expander_siblings - remove siblings attached to expander
3454 * @ioc: Pointer to MPT_ADAPTER structure
3455 * @parent: the parent port_info object
3456 * @expander: the expander port_info object
3459 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
3460 *parent, struct mptsas_portinfo *expander)
3462 struct mptsas_phyinfo *phy_info;
3463 struct mptsas_portinfo *port_info;
3464 struct sas_rphy *rphy;
3467 phy_info = expander->phy_info;
3468 for (i = 0; i < expander->num_phys; i++, phy_info++) {
3469 rphy = mptsas_get_rphy(phy_info);
3472 if (rphy->identify.device_type == SAS_END_DEVICE)
3473 mptsas_del_end_device(ioc, phy_info);
3476 phy_info = expander->phy_info;
3477 for (i = 0; i < expander->num_phys; i++, phy_info++) {
3478 rphy = mptsas_get_rphy(phy_info);
3481 if (rphy->identify.device_type ==
3482 MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
3483 rphy->identify.device_type ==
3484 MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
3485 port_info = mptsas_find_portinfo_by_sas_address(ioc,
3486 rphy->identify.sas_address);
3489 if (port_info == parent) /* backlink rphy */
3492 Delete this expander even if the expdevpage is exists
3493 because the parent expander is already deleted
3495 mptsas_expander_delete(ioc, port_info, 1);
3502 * mptsas_expander_delete - remove this expander
3503 * @ioc: Pointer to MPT_ADAPTER structure
3504 * @port_info: expander port_info struct
3505 * @force: Flag to forcefully delete the expander
3509 static void mptsas_expander_delete(MPT_ADAPTER *ioc,
3510 struct mptsas_portinfo *port_info, u8 force)
3513 struct mptsas_portinfo *parent;
3515 u64 expander_sas_address;
3516 struct mptsas_phyinfo *phy_info;
3517 struct mptsas_portinfo buffer;
3518 struct mptsas_portinfo_details *port_details;
3519 struct sas_port *port;
3524 /* see if expander is still there before deleting */
3525 mptsas_sas_expander_pg0(ioc, &buffer,
3526 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3527 MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
3528 port_info->phy_info[0].identify.handle);
3530 if (buffer.num_phys) {
3531 kfree(buffer.phy_info);
3538 * Obtain the port_info instance to the parent port
3540 port_details = NULL;
3541 expander_sas_address =
3542 port_info->phy_info[0].identify.sas_address;
3543 parent = mptsas_find_portinfo_by_handle(ioc,
3544 port_info->phy_info[0].identify.handle_parent);
3545 mptsas_delete_expander_siblings(ioc, parent, port_info);
3550 * Delete rphys in the parent that point
3553 phy_info = parent->phy_info;
3555 for (i = 0; i < parent->num_phys; i++, phy_info++) {
3558 if (phy_info->attached.sas_address !=
3559 expander_sas_address)
3562 port = mptsas_get_port(phy_info);
3563 port_details = phy_info->port_details;
3565 dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3566 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
3567 phy_info->phy_id, phy_info->phy);
3568 sas_port_delete_phy(port, phy_info->phy);
3571 dev_printk(KERN_DEBUG, &port->dev,
3572 MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
3573 ioc->name, port->port_identifier,
3574 (unsigned long long)expander_sas_address);
3575 sas_port_delete(port);
3576 mptsas_port_delete(ioc, port_details);
3580 printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
3581 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3582 (unsigned long long)expander_sas_address);
3587 list_del(&port_info->list);
3588 kfree(port_info->phy_info);
3594 * mptsas_send_expander_event - expanders events
3595 * @ioc: Pointer to MPT_ADAPTER structure
3596 * @expander_data: event data
3599 * This function handles adding, removing, and refreshing
3600 * device handles within the expander objects.
3603 mptsas_send_expander_event(struct fw_event_work *fw_event)
3606 MpiEventDataSasExpanderStatusChange_t *expander_data;
3607 struct mptsas_portinfo *port_info;
3611 ioc = fw_event->ioc;
3612 expander_data = (MpiEventDataSasExpanderStatusChange_t *)
3613 fw_event->event_data;
3614 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3615 sas_address = le64_to_cpu(sas_address);
3616 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3618 if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
3620 for (i = 0; i < port_info->num_phys; i++) {
3621 port_info->phy_info[i].portinfo = port_info;
3622 port_info->phy_info[i].handle =
3623 le16_to_cpu(expander_data->DevHandle);
3624 port_info->phy_info[i].identify.sas_address =
3625 le64_to_cpu(sas_address);
3626 port_info->phy_info[i].identify.handle_parent =
3627 le16_to_cpu(expander_data->ParentDevHandle);
3629 mptsas_expander_refresh(ioc, port_info);
3630 } else if (!port_info && expander_data->NumPhys)
3631 mptsas_expander_event_add(ioc, expander_data);
3632 } else if (expander_data->ReasonCode ==
3633 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
3634 mptsas_expander_delete(ioc, port_info, 0);
3636 mptsas_free_fw_event(ioc, fw_event);
3641 * mptsas_expander_add -
3642 * @ioc: Pointer to MPT_ADAPTER structure
3646 static struct mptsas_portinfo *
3647 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
3649 struct mptsas_portinfo buffer, *port_info;
3652 if ((mptsas_sas_expander_pg0(ioc, &buffer,
3653 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3654 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
3657 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC);
3659 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3660 "%s: exit at line=%d\n", ioc->name,
3661 __func__, __LINE__));
3664 port_info->num_phys = buffer.num_phys;
3665 port_info->phy_info = buffer.phy_info;
3666 for (i = 0; i < port_info->num_phys; i++)
3667 port_info->phy_info[i].portinfo = port_info;
3668 mutex_lock(&ioc->sas_topology_mutex);
3669 list_add_tail(&port_info->list, &ioc->sas_topology);
3670 mutex_unlock(&ioc->sas_topology_mutex);
3671 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3672 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3673 (unsigned long long)buffer.phy_info[0].identify.sas_address);
3674 mptsas_expander_refresh(ioc, port_info);
3679 mptsas_send_link_status_event(struct fw_event_work *fw_event)
3682 MpiEventDataSasPhyLinkStatus_t *link_data;
3683 struct mptsas_portinfo *port_info;
3684 struct mptsas_phyinfo *phy_info = NULL;
3689 ioc = fw_event->ioc;
3690 link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
3692 memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
3693 sas_address = le64_to_cpu(sas_address);
3694 link_rate = link_data->LinkRates >> 4;
3695 phy_num = link_data->PhyNum;
3697 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3699 phy_info = &port_info->phy_info[phy_num];
3701 phy_info->negotiated_link_rate = link_rate;
3704 if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
3705 link_rate == MPI_SAS_IOUNIT0_RATE_3_0 ||
3706 link_rate == MPI_SAS_IOUNIT0_RATE_6_0) {
3709 if (ioc->old_sas_discovery_protocal) {
3710 port_info = mptsas_expander_add(ioc,
3711 le16_to_cpu(link_data->DevHandle));
3718 if (port_info == ioc->hba_port_info)
3719 mptsas_probe_hba_phys(ioc);
3721 mptsas_expander_refresh(ioc, port_info);
3722 } else if (phy_info && phy_info->phy) {
3723 if (link_rate == MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
3724 phy_info->phy->negotiated_linkrate =
3726 else if (link_rate ==
3727 MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
3728 phy_info->phy->negotiated_linkrate =
3729 SAS_LINK_RATE_FAILED;
3731 phy_info->phy->negotiated_linkrate =
3732 SAS_LINK_RATE_UNKNOWN;
3733 if (ioc->device_missing_delay &&
3734 mptsas_is_end_device(&phy_info->attached)) {
3735 struct scsi_device *sdev;
3736 VirtDevice *vdevice;
3738 id = phy_info->attached.id;
3739 channel = phy_info->attached.channel;
3740 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3741 "Link down for fw_id %d:fw_channel %d\n",
3742 ioc->name, phy_info->attached.id,
3743 phy_info->attached.channel));
3745 shost_for_each_device(sdev, ioc->sh) {
3746 vdevice = sdev->hostdata;
3747 if ((vdevice == NULL) ||
3748 (vdevice->vtarget == NULL))
3750 if ((vdevice->vtarget->tflags &
3751 MPT_TARGET_FLAGS_RAID_COMPONENT ||
3752 vdevice->vtarget->raidVolume))
3754 if (vdevice->vtarget->id == id &&
3755 vdevice->vtarget->channel ==
3758 printk(MYIOC_s_DEBUG_FMT
3759 "SDEV OUTSTANDING CMDS"
3761 atomic_read(&sdev->device_busy)));
3768 mptsas_free_fw_event(ioc, fw_event);
3772 mptsas_not_responding_devices(MPT_ADAPTER *ioc)
3774 struct mptsas_portinfo buffer, *port_info;
3775 struct mptsas_device_info *sas_info;
3776 struct mptsas_devinfo sas_device;
3778 VirtTarget *vtarget = NULL;
3779 struct mptsas_phyinfo *phy_info;
3781 int retval, retry_count;
3782 unsigned long flags;
3784 mpt_findImVolumes(ioc);
3786 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3787 if (ioc->ioc_reset_in_progress) {
3788 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3789 "%s: exiting due to a parallel reset \n", ioc->name,
3791 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3794 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3796 /* devices, logical volumes */
3797 mutex_lock(&ioc->sas_device_info_mutex);
3799 list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
3800 if (sas_info->is_cached)
3802 if (!sas_info->is_logical_volume) {
3803 sas_device.handle = 0;
3806 retval = mptsas_sas_device_pg0(ioc, &sas_device,
3807 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID
3808 << MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3809 (sas_info->fw.channel << 8) +
3812 if (sas_device.handle)
3814 if (retval == -EBUSY) {
3815 spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3816 if (ioc->ioc_reset_in_progress) {
3818 printk(MYIOC_s_DEBUG_FMT
3819 "%s: exiting due to reset\n",
3820 ioc->name, __func__));
3821 spin_unlock_irqrestore
3822 (&ioc->taskmgmt_lock, flags);
3824 sas_device_info_mutex);
3827 spin_unlock_irqrestore(&ioc->taskmgmt_lock,
3831 if (retval && (retval != -ENODEV)) {
3832 if (retry_count < 10) {
3836 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3837 "%s: Config page retry exceeded retry "
3838 "count deleting device 0x%llx\n",
3839 ioc->name, __func__,
3840 sas_info->sas_address));
3845 vtarget = mptsas_find_vtarget(ioc,
3846 sas_info->fw.channel, sas_info->fw.id);
3849 vtarget->deleted = 1;
3851 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
3852 sas_info->sas_address);
3854 mptsas_del_end_device(ioc, phy_info);
3855 goto redo_device_scan;
3857 mptsas_volume_delete(ioc, sas_info->fw.id);
3859 mutex_unlock(&ioc->sas_device_info_mutex);
3862 mutex_lock(&ioc->sas_topology_mutex);
3864 list_for_each_entry(port_info, &ioc->sas_topology, list) {
3866 if (!(port_info->phy_info[0].identify.device_info &
3867 MPI_SAS_DEVICE_INFO_SMP_TARGET))
3871 while (!mptsas_sas_expander_pg0(ioc, &buffer,
3872 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3873 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
3876 handle = buffer.phy_info[0].handle;
3877 if (buffer.phy_info[0].identify.sas_address ==
3878 port_info->phy_info[0].identify.sas_address) {
3881 kfree(buffer.phy_info);
3884 if (!found_expander) {
3885 mptsas_expander_delete(ioc, port_info, 0);
3886 goto redo_expander_scan;
3889 mutex_unlock(&ioc->sas_topology_mutex);
3893 * mptsas_probe_expanders - adding expanders
3894 * @ioc: Pointer to MPT_ADAPTER structure
3898 mptsas_probe_expanders(MPT_ADAPTER *ioc)
3900 struct mptsas_portinfo buffer, *port_info;
3905 while (!mptsas_sas_expander_pg0(ioc, &buffer,
3906 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3907 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
3909 handle = buffer.phy_info[0].handle;
3910 port_info = mptsas_find_portinfo_by_sas_address(ioc,
3911 buffer.phy_info[0].identify.sas_address);
3914 /* refreshing handles */
3915 for (i = 0; i < buffer.num_phys; i++) {
3916 port_info->phy_info[i].handle = handle;
3917 port_info->phy_info[i].identify.handle_parent =
3918 buffer.phy_info[0].identify.handle_parent;
3920 mptsas_expander_refresh(ioc, port_info);
3921 kfree(buffer.phy_info);
3925 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3927 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3928 "%s: exit at line=%d\n", ioc->name,
3929 __func__, __LINE__));
3932 port_info->num_phys = buffer.num_phys;
3933 port_info->phy_info = buffer.phy_info;
3934 for (i = 0; i < port_info->num_phys; i++)
3935 port_info->phy_info[i].portinfo = port_info;
3936 mutex_lock(&ioc->sas_topology_mutex);
3937 list_add_tail(&port_info->list, &ioc->sas_topology);
3938 mutex_unlock(&ioc->sas_topology_mutex);
3939 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3940 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3941 (unsigned long long)buffer.phy_info[0].identify.sas_address);
3942 mptsas_expander_refresh(ioc, port_info);
3947 mptsas_probe_devices(MPT_ADAPTER *ioc)
3950 struct mptsas_devinfo sas_device;
3951 struct mptsas_phyinfo *phy_info;
3954 while (!(mptsas_sas_device_pg0(ioc, &sas_device,
3955 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
3957 handle = sas_device.handle;
3959 if ((sas_device.device_info &
3960 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
3961 MPI_SAS_DEVICE_INFO_STP_TARGET |
3962 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
3965 /* If there is no FW B_T mapping for this device then continue
3967 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
3968 || !(sas_device.flags &
3969 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
3972 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
3976 if (mptsas_get_rphy(phy_info))
3979 mptsas_add_end_device(ioc, phy_info);
3984 * mptsas_scan_sas_topology -
3985 * @ioc: Pointer to MPT_ADAPTER structure
3990 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
3992 struct scsi_device *sdev;
3995 mptsas_probe_hba_phys(ioc);
3996 mptsas_probe_expanders(ioc);
3997 mptsas_probe_devices(ioc);
4000 Reporting RAID volumes.
4002 if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
4003 !ioc->raid_data.pIocPg2->NumActiveVolumes)
4005 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4006 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4007 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4009 scsi_device_put(sdev);
4012 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4013 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4014 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
4015 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4016 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4022 mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
4025 EventDataQueueFull_t *qfull_data;
4026 struct mptsas_device_info *sas_info;
4027 struct scsi_device *sdev;
4031 int fw_id, fw_channel;
4035 ioc = fw_event->ioc;
4036 qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
4037 fw_id = qfull_data->TargetID;
4038 fw_channel = qfull_data->Bus;
4039 current_depth = le16_to_cpu(qfull_data->CurrentDepth);
4041 /* if hidden raid component, look for the volume id */
4042 mutex_lock(&ioc->sas_device_info_mutex);
4043 if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
4044 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4046 if (sas_info->is_cached ||
4047 sas_info->is_logical_volume)
4049 if (sas_info->is_hidden_raid_component &&
4050 (sas_info->fw.channel == fw_channel &&
4051 sas_info->fw.id == fw_id)) {
4052 id = sas_info->volume_id;
4053 channel = MPTSAS_RAID_CHANNEL;
4058 list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4060 if (sas_info->is_cached ||
4061 sas_info->is_hidden_raid_component ||
4062 sas_info->is_logical_volume)
4064 if (sas_info->fw.channel == fw_channel &&
4065 sas_info->fw.id == fw_id) {
4066 id = sas_info->os.id;
4067 channel = sas_info->os.channel;
4075 mutex_unlock(&ioc->sas_device_info_mutex);
4078 shost_for_each_device(sdev, ioc->sh) {
4079 if (sdev->id == id && sdev->channel == channel) {
4080 if (current_depth > sdev->queue_depth) {
4081 sdev_printk(KERN_INFO, sdev,
4082 "strange observation, the queue "
4083 "depth is (%d) meanwhile fw queue "
4084 "depth (%d)\n", sdev->queue_depth,
4088 depth = scsi_track_queue_full(sdev,
4089 sdev->queue_depth - 1);
4091 sdev_printk(KERN_INFO, sdev,
4092 "Queue depth reduced to (%d)\n",
4095 sdev_printk(KERN_INFO, sdev,
4096 "Tagged Command Queueing is being "
4098 else if (depth == 0)
4099 sdev_printk(KERN_DEBUG, sdev,
4100 "Queue depth not changed yet\n");
4105 mptsas_free_fw_event(ioc, fw_event);
4109 static struct mptsas_phyinfo *
4110 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
4112 struct mptsas_portinfo *port_info;
4113 struct mptsas_phyinfo *phy_info = NULL;
4116 mutex_lock(&ioc->sas_topology_mutex);
4117 list_for_each_entry(port_info, &ioc->sas_topology, list) {
4118 for (i = 0; i < port_info->num_phys; i++) {
4119 if (!mptsas_is_end_device(
4120 &port_info->phy_info[i].attached))
4122 if (port_info->phy_info[i].attached.sas_address
4125 phy_info = &port_info->phy_info[i];
4129 mutex_unlock(&ioc->sas_topology_mutex);
4134 * mptsas_find_phyinfo_by_phys_disk_num -
4135 * @ioc: Pointer to MPT_ADAPTER structure
4141 static struct mptsas_phyinfo *
4142 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
4145 struct mptsas_phyinfo *phy_info = NULL;
4146 struct mptsas_portinfo *port_info;
4147 RaidPhysDiskPage1_t *phys_disk = NULL;
4149 u64 sas_address = 0;
4153 if (!ioc->raid_data.pIocPg3)
4155 /* dual port support */
4156 num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
4159 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
4160 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
4163 mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
4164 for (i = 0; i < num_paths; i++) {
4165 if ((phys_disk->Path[i].Flags & 1) != 0)
4166 /* entry no longer valid */
4168 if ((id == phys_disk->Path[i].PhysDiskID) &&
4169 (channel == phys_disk->Path[i].PhysDiskBus)) {
4170 memcpy(&sas_address, &phys_disk->Path[i].WWID,
4172 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4184 * Extra code to handle RAID0 case, where the sas_address is not updated
4185 * in phys_disk_page_1 when hotswapped
4187 mutex_lock(&ioc->sas_topology_mutex);
4188 list_for_each_entry(port_info, &ioc->sas_topology, list) {
4189 for (i = 0; i < port_info->num_phys && !phy_info; i++) {
4190 if (!mptsas_is_end_device(
4191 &port_info->phy_info[i].attached))
4193 if (port_info->phy_info[i].attached.phys_disk_num == ~0)
4195 if ((port_info->phy_info[i].attached.phys_disk_num ==
4197 (port_info->phy_info[i].attached.id == id) &&
4198 (port_info->phy_info[i].attached.channel ==
4200 phy_info = &port_info->phy_info[i];
4203 mutex_unlock(&ioc->sas_topology_mutex);
4208 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
4212 sdev->no_uld_attach = data ? 1 : 0;
4213 rc = scsi_device_reprobe(sdev);
4217 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
4219 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
4220 mptsas_reprobe_lun);
4224 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
4227 ConfigPageHeader_t hdr;
4228 dma_addr_t dma_handle;
4229 pRaidVolumePage0_t buffer = NULL;
4230 RaidPhysDiskPage0_t phys_disk;
4232 struct mptsas_phyinfo *phy_info;
4233 struct mptsas_devinfo sas_device;
4235 memset(&cfg, 0 , sizeof(CONFIGPARMS));
4236 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
4237 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
4238 cfg.pageAddr = (channel << 8) + id;
4239 cfg.cfghdr.hdr = &hdr;
4240 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4241 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
4243 if (mpt_config(ioc, &cfg) != 0)
4246 if (!hdr.PageLength)
4249 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
4255 cfg.physAddr = dma_handle;
4256 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4258 if (mpt_config(ioc, &cfg) != 0)
4261 if (!(buffer->VolumeStatus.Flags &
4262 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
4265 if (!buffer->NumPhysDisks)
4268 for (i = 0; i < buffer->NumPhysDisks; i++) {
4270 if (mpt_raid_phys_disk_pg0(ioc,
4271 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
4274 if (mptsas_sas_device_pg0(ioc, &sas_device,
4275 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4276 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4277 (phys_disk.PhysDiskBus << 8) +
4278 phys_disk.PhysDiskID))
4281 /* If there is no FW B_T mapping for this device then continue
4283 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4284 || !(sas_device.flags &
4285 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4289 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4290 sas_device.sas_address);
4291 mptsas_add_end_device(ioc, phy_info);
4296 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
4300 * Work queue thread to handle SAS hotplug events
4303 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
4304 struct mptsas_hotplug_event *hot_plug_info)
4306 struct mptsas_phyinfo *phy_info;
4307 struct scsi_target * starget;
4308 struct mptsas_devinfo sas_device;
4309 VirtTarget *vtarget;
4311 struct mptsas_portinfo *port_info;
4313 switch (hot_plug_info->event_type) {
4315 case MPTSAS_ADD_PHYSDISK:
4317 if (!ioc->raid_data.pIocPg2)
4320 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4321 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
4322 hot_plug_info->id) {
4323 printk(MYIOC_s_WARN_FMT "firmware bug: unable "
4324 "to add hidden disk - target_id matchs "
4325 "volume_id\n", ioc->name);
4326 mptsas_free_fw_event(ioc, fw_event);
4330 mpt_findImVolumes(ioc);
4332 case MPTSAS_ADD_DEVICE:
4333 memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
4334 mptsas_sas_device_pg0(ioc, &sas_device,
4335 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4336 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4337 (hot_plug_info->channel << 8) +
4340 /* If there is no FW B_T mapping for this device then break
4342 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4343 || !(sas_device.flags &
4344 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4347 if (!sas_device.handle)
4350 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
4351 /* Device hot plug */
4353 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4355 "parent handle of device %x\n", ioc->name,
4356 __func__, __LINE__, sas_device.handle_parent));
4357 port_info = mptsas_find_portinfo_by_handle(ioc,
4358 sas_device.handle_parent);
4360 if (port_info == ioc->hba_port_info)
4361 mptsas_probe_hba_phys(ioc);
4363 mptsas_expander_refresh(ioc, port_info);
4365 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4366 "%s %d port info is NULL\n",
4367 ioc->name, __func__, __LINE__));
4370 phy_info = mptsas_refreshing_device_handles
4375 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4376 "%s %d phy info is NULL\n",
4377 ioc->name, __func__, __LINE__));
4381 if (mptsas_get_rphy(phy_info))
4384 mptsas_add_end_device(ioc, phy_info);
4387 case MPTSAS_DEL_DEVICE:
4388 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4389 hot_plug_info->sas_address);
4390 mptsas_del_end_device(ioc, phy_info);
4393 case MPTSAS_DEL_PHYSDISK:
4395 mpt_findImVolumes(ioc);
4397 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
4398 ioc, hot_plug_info->phys_disk_num,
4399 hot_plug_info->channel,
4401 mptsas_del_end_device(ioc, phy_info);
4404 case MPTSAS_ADD_PHYSDISK_REPROBE:
4406 if (mptsas_sas_device_pg0(ioc, &sas_device,
4407 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4408 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4409 (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4410 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4411 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4412 __func__, hot_plug_info->id, __LINE__));
4416 /* If there is no FW B_T mapping for this device then break
4418 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4419 || !(sas_device.flags &
4420 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4423 phy_info = mptsas_find_phyinfo_by_sas_address(
4424 ioc, sas_device.sas_address);
4427 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4428 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4429 __func__, hot_plug_info->id, __LINE__));
4433 starget = mptsas_get_starget(phy_info);
4435 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4436 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4437 __func__, hot_plug_info->id, __LINE__));
4441 vtarget = starget->hostdata;
4443 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4444 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4445 __func__, hot_plug_info->id, __LINE__));
4449 mpt_findImVolumes(ioc);
4451 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
4452 "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4453 ioc->name, hot_plug_info->channel, hot_plug_info->id,
4454 hot_plug_info->phys_disk_num, (unsigned long long)
4455 sas_device.sas_address);
4457 vtarget->id = hot_plug_info->phys_disk_num;
4458 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4459 phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
4460 mptsas_reprobe_target(starget, 1);
4463 case MPTSAS_DEL_PHYSDISK_REPROBE:
4465 if (mptsas_sas_device_pg0(ioc, &sas_device,
4466 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4467 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4468 (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4469 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4470 "%s: fw_id=%d exit at line=%d\n",
4471 ioc->name, __func__,
4472 hot_plug_info->id, __LINE__));
4476 /* If there is no FW B_T mapping for this device then break
4478 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4479 || !(sas_device.flags &
4480 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4483 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4484 sas_device.sas_address);
4486 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4487 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4488 __func__, hot_plug_info->id, __LINE__));
4492 starget = mptsas_get_starget(phy_info);
4494 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4495 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4496 __func__, hot_plug_info->id, __LINE__));
4500 vtarget = starget->hostdata;
4502 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4503 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4504 __func__, hot_plug_info->id, __LINE__));
4508 if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
4509 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4510 "%s: fw_id=%d exit at line=%d\n", ioc->name,
4511 __func__, hot_plug_info->id, __LINE__));
4515 mpt_findImVolumes(ioc);
4517 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
4518 " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4519 ioc->name, hot_plug_info->channel, hot_plug_info->id,
4520 hot_plug_info->phys_disk_num, (unsigned long long)
4521 sas_device.sas_address);
4523 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4524 vtarget->id = hot_plug_info->id;
4525 phy_info->attached.phys_disk_num = ~0;
4526 mptsas_reprobe_target(starget, 0);
4527 mptsas_add_device_component_by_fw(ioc,
4528 hot_plug_info->channel, hot_plug_info->id);
4531 case MPTSAS_ADD_RAID:
4533 mpt_findImVolumes(ioc);
4534 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4535 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4537 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4538 hot_plug_info->id, 0);
4541 case MPTSAS_DEL_RAID:
4543 mpt_findImVolumes(ioc);
4544 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4545 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4547 scsi_remove_device(hot_plug_info->sdev);
4548 scsi_device_put(hot_plug_info->sdev);
4551 case MPTSAS_ADD_INACTIVE_VOLUME:
4553 mpt_findImVolumes(ioc);
4554 mptsas_adding_inactive_raid_components(ioc,
4555 hot_plug_info->channel, hot_plug_info->id);
4562 mptsas_free_fw_event(ioc, fw_event);
4566 mptsas_send_sas_event(struct fw_event_work *fw_event)
4569 struct mptsas_hotplug_event hot_plug_info;
4570 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
4574 ioc = fw_event->ioc;
4575 sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
4576 fw_event->event_data;
4577 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
4580 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
4581 MPI_SAS_DEVICE_INFO_STP_TARGET |
4582 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) {
4583 mptsas_free_fw_event(ioc, fw_event);
4587 if (sas_event_data->ReasonCode ==
4588 MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
4589 mptbase_sas_persist_operation(ioc,
4590 MPI_SAS_OP_CLEAR_NOT_PRESENT);
4591 mptsas_free_fw_event(ioc, fw_event);
4595 switch (sas_event_data->ReasonCode) {
4596 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
4597 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
4598 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4599 hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
4600 hot_plug_info.channel = sas_event_data->Bus;
4601 hot_plug_info.id = sas_event_data->TargetID;
4602 hot_plug_info.phy_id = sas_event_data->PhyNum;
4603 memcpy(&sas_address, &sas_event_data->SASAddress,
4605 hot_plug_info.sas_address = le64_to_cpu(sas_address);
4606 hot_plug_info.device_info = device_info;
4607 if (sas_event_data->ReasonCode &
4608 MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
4609 hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
4611 hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
4612 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4615 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
4616 mptbase_sas_persist_operation(ioc,
4617 MPI_SAS_OP_CLEAR_NOT_PRESENT);
4618 mptsas_free_fw_event(ioc, fw_event);
4621 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
4623 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
4626 mptsas_free_fw_event(ioc, fw_event);
4632 mptsas_send_raid_event(struct fw_event_work *fw_event)
4635 EVENT_DATA_RAID *raid_event_data;
4636 struct mptsas_hotplug_event hot_plug_info;
4639 struct scsi_device *sdev = NULL;
4640 VirtDevice *vdevice = NULL;
4641 RaidPhysDiskPage0_t phys_disk;
4643 ioc = fw_event->ioc;
4644 raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
4645 status = le32_to_cpu(raid_event_data->SettingsStatus);
4646 state = (status >> 8) & 0xff;
4648 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4649 hot_plug_info.id = raid_event_data->VolumeID;
4650 hot_plug_info.channel = raid_event_data->VolumeBus;
4651 hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
4653 if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
4654 raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
4655 raid_event_data->ReasonCode ==
4656 MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
4657 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4658 hot_plug_info.id, 0);
4659 hot_plug_info.sdev = sdev;
4661 vdevice = sdev->hostdata;
4664 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4665 "ReasonCode=%02x\n", ioc->name, __func__,
4666 raid_event_data->ReasonCode));
4668 switch (raid_event_data->ReasonCode) {
4669 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4670 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
4672 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4673 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
4675 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4677 case MPI_PD_STATE_ONLINE:
4678 case MPI_PD_STATE_NOT_COMPATIBLE:
4679 mpt_raid_phys_disk_pg0(ioc,
4680 raid_event_data->PhysDiskNum, &phys_disk);
4681 hot_plug_info.id = phys_disk.PhysDiskID;
4682 hot_plug_info.channel = phys_disk.PhysDiskBus;
4683 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4685 case MPI_PD_STATE_FAILED:
4686 case MPI_PD_STATE_MISSING:
4687 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
4688 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
4689 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
4690 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4696 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4699 vdevice->vtarget->deleted = 1; /* block IO */
4700 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4702 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4704 scsi_device_put(sdev);
4707 hot_plug_info.event_type = MPTSAS_ADD_RAID;
4709 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4710 if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
4713 vdevice->vtarget->deleted = 1; /* block IO */
4714 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4718 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
4719 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
4722 vdevice->vtarget->deleted = 1; /* block IO */
4723 hot_plug_info.event_type = MPTSAS_DEL_RAID;
4725 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
4726 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
4728 scsi_device_put(sdev);
4731 hot_plug_info.event_type = MPTSAS_ADD_RAID;
4741 if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
4742 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4744 mptsas_free_fw_event(ioc, fw_event);
4748 * mptsas_issue_tm - send mptsas internal tm request
4749 * @ioc: Pointer to MPT_ADAPTER structure
4750 * @type: Task Management type
4751 * @channel: channel number for task management
4752 * @id: Logical Target ID for reset (if appropriate)
4753 * @lun: Logical unit for reset (if appropriate)
4754 * @task_context: Context for the task to be aborted
4755 * @timeout: timeout for task management control
4757 * return 0 on success and -1 on failure:
4761 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun,
4762 int task_context, ulong timeout, u8 *issue_reset)
4765 SCSITaskMgmt_t *pScsiTm;
4767 unsigned long timeleft;
4770 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
4772 retval = -1; /* return failure */
4773 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
4774 "msg frames!!\n", ioc->name));
4778 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
4779 "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
4780 "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
4781 type, timeout, channel, id, (unsigned long long)lun,
4784 pScsiTm = (SCSITaskMgmt_t *) mf;
4785 memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
4786 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4787 pScsiTm->TaskType = type;
4788 pScsiTm->MsgFlags = 0;
4789 pScsiTm->TargetID = id;
4790 pScsiTm->Bus = channel;
4791 pScsiTm->ChainOffset = 0;
4792 pScsiTm->Reserved = 0;
4793 pScsiTm->Reserved1 = 0;
4794 pScsiTm->TaskMsgContext = task_context;
4795 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
4797 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4798 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
4800 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
4802 /* Now wait for the command to complete */
4803 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
4805 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
4806 retval = -1; /* return failure */
4807 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
4808 "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
4809 mpt_free_msg_frame(ioc, mf);
4810 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
4816 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
4817 retval = -1; /* return failure */
4818 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4819 "TaskMgmt request: failed with no reply\n", ioc->name));
4824 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4829 * mptsas_broadcast_primative_work - Handle broadcast primitives
4830 * @work: work queue payload containing info describing the event
4832 * this will be handled in workqueue context.
4835 mptsas_broadcast_primative_work(struct fw_event_work *fw_event)
4837 MPT_ADAPTER *ioc = fw_event->ioc;
4839 VirtDevice *vdevice;
4841 struct scsi_cmnd *sc;
4842 SCSITaskMgmtReply_t *pScsiTmReply;
4847 u32 termination_count;
4850 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4851 "%s - enter\n", ioc->name, __func__));
4853 mutex_lock(&ioc->taskmgmt_cmds.mutex);
4854 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4855 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4856 mptsas_requeue_fw_event(ioc, fw_event, 1000);
4861 termination_count = 0;
4863 mpt_findImVolumes(ioc);
4864 pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
4866 for (ii = 0; ii < ioc->req_depth; ii++) {
4867 if (ioc->fw_events_off)
4869 sc = mptscsih_get_scsi_lookup(ioc, ii);
4872 mf = MPT_INDEX_2_MFPTR(ioc, ii);
4875 task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
4876 vdevice = sc->device->hostdata;
4877 if (!vdevice || !vdevice->vtarget)
4879 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
4880 continue; /* skip hidden raid components */
4881 if (vdevice->vtarget->raidVolume)
4882 continue; /* skip hidden raid components */
4883 channel = vdevice->vtarget->channel;
4884 id = vdevice->vtarget->id;
4886 if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
4887 channel, id, (u64)lun, task_context, 30, &issue_reset))
4890 termination_count +=
4891 le32_to_cpu(pScsiTmReply->TerminationCount);
4892 if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
4893 (pScsiTmReply->ResponseCode ==
4894 MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4895 pScsiTmReply->ResponseCode ==
4896 MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4898 if (mptsas_issue_tm(ioc,
4899 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
4900 channel, id, (u64)lun, 0, 30, &issue_reset))
4902 termination_count +=
4903 le32_to_cpu(pScsiTmReply->TerminationCount);
4907 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4908 "%s - exit, query_count = %d termination_count = %d\n",
4909 ioc->name, __func__, query_count, termination_count));
4911 ioc->broadcast_aen_busy = 0;
4912 mpt_clear_taskmgmt_in_progress_flag(ioc);
4913 mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4916 printk(MYIOC_s_WARN_FMT
4917 "Issuing Reset from %s!! doorbell=0x%08x\n",
4918 ioc->name, __func__, mpt_GetIocState(ioc, 0));
4919 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
4921 mptsas_free_fw_event(ioc, fw_event);
4925 * mptsas_send_ir2_event - handle exposing hidden disk when
4926 * an inactive raid volume is added
4928 * @ioc: Pointer to MPT_ADAPTER structure
4933 mptsas_send_ir2_event(struct fw_event_work *fw_event)
4936 struct mptsas_hotplug_event hot_plug_info;
4937 MPI_EVENT_DATA_IR2 *ir2_data;
4939 RaidPhysDiskPage0_t phys_disk;
4941 ioc = fw_event->ioc;
4942 ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
4943 reasonCode = ir2_data->ReasonCode;
4945 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4946 "ReasonCode=%02x\n", ioc->name, __func__, reasonCode));
4948 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4949 hot_plug_info.id = ir2_data->TargetID;
4950 hot_plug_info.channel = ir2_data->Bus;
4951 switch (reasonCode) {
4952 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
4953 hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
4955 case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
4956 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4957 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4959 case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
4960 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4961 mpt_raid_phys_disk_pg0(ioc,
4962 ir2_data->PhysDiskNum, &phys_disk);
4963 hot_plug_info.id = phys_disk.PhysDiskID;
4964 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4967 mptsas_free_fw_event(ioc, fw_event);
4970 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4974 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
4976 u32 event = le32_to_cpu(reply->Event);
4978 struct fw_event_work *fw_event;
4979 unsigned long delay;
4981 if (ioc->bus_type != SAS)
4984 /* events turned off due to host reset or driver unloading */
4985 if (ioc->fw_events_off)
4988 delay = msecs_to_jiffies(1);
4990 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
4992 EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
4993 (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
4994 if (broadcast_event_data->Primitive !=
4995 MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
4997 if (ioc->broadcast_aen_busy)
4999 ioc->broadcast_aen_busy = 1;
5002 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
5004 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
5005 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
5007 ioc_stat = le16_to_cpu(reply->IOCStatus);
5009 if (sas_event_data->ReasonCode ==
5010 MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
5011 mptsas_target_reset_queue(ioc, sas_event_data);
5014 if (sas_event_data->ReasonCode ==
5015 MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5016 ioc->device_missing_delay &&
5017 (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
5018 VirtTarget *vtarget = NULL;
5021 id = sas_event_data->TargetID;
5022 channel = sas_event_data->Bus;
5024 vtarget = mptsas_find_vtarget(ioc, channel, id);
5026 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5027 "LogInfo (0x%x) available for "
5028 "INTERNAL_DEVICE_RESET"
5029 "fw_id %d fw_channel %d\n", ioc->name,
5030 le32_to_cpu(reply->IOCLogInfo),
5032 if (vtarget->raidVolume) {
5033 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5034 "Skipping Raid Volume for inDMD\n",
5037 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5038 "Setting device flag inDMD\n",
5049 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
5051 MpiEventDataSasExpanderStatusChange_t *expander_data =
5052 (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
5054 if (ioc->old_sas_discovery_protocal)
5057 if (expander_data->ReasonCode ==
5058 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
5059 ioc->device_missing_delay)
5060 delay = HZ * ioc->device_missing_delay;
5063 case MPI_EVENT_SAS_DISCOVERY:
5065 u32 discovery_status;
5066 EventDataSasDiscovery_t *discovery_data =
5067 (EventDataSasDiscovery_t *)reply->Data;
5069 discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
5070 ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
5071 if (ioc->old_sas_discovery_protocal && !discovery_status)
5072 mptsas_queue_rescan(ioc);
5075 case MPI_EVENT_INTEGRATED_RAID:
5076 case MPI_EVENT_PERSISTENT_TABLE_FULL:
5078 case MPI_EVENT_SAS_PHY_LINK_STATUS:
5079 case MPI_EVENT_QUEUE_FULL:
5085 event_data_sz = ((reply->MsgLength * 4) -
5086 offsetof(EventNotificationReply_t, Data));
5087 fw_event = kzalloc(sizeof(*fw_event) + event_data_sz, GFP_ATOMIC);
5089 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
5090 __func__, __LINE__);
5093 memcpy(fw_event->event_data, reply->Data, event_data_sz);
5094 fw_event->event = event;
5095 fw_event->ioc = ioc;
5096 mptsas_add_fw_event(ioc, fw_event, delay);
5100 /* Delete a volume when no longer listed in ioc pg2
5102 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
5104 struct scsi_device *sdev;
5107 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
5110 if (!ioc->raid_data.pIocPg2)
5112 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
5114 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
5115 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
5118 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
5119 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id);
5120 scsi_remove_device(sdev);
5122 scsi_device_put(sdev);
5126 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5128 struct Scsi_Host *sh;
5131 unsigned long flags;
5139 r = mpt_attach(pdev,id);
5143 ioc = pci_get_drvdata(pdev);
5144 mptsas_fw_event_off(ioc);
5145 ioc->DoneCtx = mptsasDoneCtx;
5146 ioc->TaskCtx = mptsasTaskCtx;
5147 ioc->InternalCtx = mptsasInternalCtx;
5148 ioc->schedule_target_reset = &mptsas_schedule_target_reset;
5149 ioc->schedule_dead_ioc_flush_running_cmds =
5150 &mptscsih_flush_running_cmds;
5151 /* Added sanity check on readiness of the MPT adapter.
5153 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
5154 printk(MYIOC_s_WARN_FMT
5155 "Skipping because it's not operational!\n",
5158 goto out_mptsas_probe;
5162 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
5165 goto out_mptsas_probe;
5168 /* Sanity check - ensure at least 1 port is INITIATOR capable
5171 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
5172 if (ioc->pfacts[ii].ProtocolFlags &
5173 MPI_PORTFACTS_PROTOCOL_INITIATOR)
5178 printk(MYIOC_s_WARN_FMT
5179 "Skipping ioc=%p because SCSI Initiator mode "
5180 "is NOT enabled!\n", ioc->name, ioc);
5184 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
5186 printk(MYIOC_s_WARN_FMT
5187 "Unable to register controller with SCSI subsystem\n",
5190 goto out_mptsas_probe;
5193 spin_lock_irqsave(&ioc->FreeQlock, flags);
5195 /* Attach the SCSI Host to the IOC structure
5203 /* set 16 byte cdb's */
5204 sh->max_cmd_len = 16;
5205 sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
5207 sh->max_lun = max_lun;
5208 sh->transportt = mptsas_transport_template;
5212 sh->unique_id = ioc->id;
5214 INIT_LIST_HEAD(&ioc->sas_topology);
5215 mutex_init(&ioc->sas_topology_mutex);
5216 mutex_init(&ioc->sas_discovery_mutex);
5217 mutex_init(&ioc->sas_mgmt.mutex);
5218 init_completion(&ioc->sas_mgmt.done);
5220 /* Verify that we won't exceed the maximum
5221 * number of chain buffers
5222 * We can optimize: ZZ = req_sz/sizeof(SGE)
5224 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
5225 * + (req_sz - 64)/sizeof(SGE)
5226 * A slightly different algorithm is required for
5229 scale = ioc->req_sz/ioc->SGE_size;
5230 if (ioc->sg_addr_size == sizeof(u64)) {
5231 numSGE = (scale - 1) *
5232 (ioc->facts.MaxChainDepth-1) + scale +
5233 (ioc->req_sz - 60) / ioc->SGE_size;
5235 numSGE = 1 + (scale - 1) *
5236 (ioc->facts.MaxChainDepth-1) + scale +
5237 (ioc->req_sz - 64) / ioc->SGE_size;
5240 if (numSGE < sh->sg_tablesize) {
5241 /* Reset this value */
5242 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5243 "Resetting sg_tablesize to %d from %d\n",
5244 ioc->name, numSGE, sh->sg_tablesize));
5245 sh->sg_tablesize = numSGE;
5248 if (mpt_loadtime_max_sectors) {
5249 if (mpt_loadtime_max_sectors < 64 ||
5250 mpt_loadtime_max_sectors > 8192) {
5251 printk(MYIOC_s_INFO_FMT "Invalid value passed for"
5252 "mpt_loadtime_max_sectors %d."
5253 "Range from 64 to 8192\n", ioc->name,
5254 mpt_loadtime_max_sectors);
5256 mpt_loadtime_max_sectors &= 0xFFFFFFFE;
5257 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5258 "Resetting max sector to %d from %d\n",
5259 ioc->name, mpt_loadtime_max_sectors, sh->max_sectors));
5260 sh->max_sectors = mpt_loadtime_max_sectors;
5263 hd = shost_priv(sh);
5266 /* SCSI needs scsi_cmnd lookup table!
5267 * (with size equal to req_depth*PtrSz!)
5269 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
5270 if (!ioc->ScsiLookup) {
5272 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5273 goto out_mptsas_probe;
5275 spin_lock_init(&ioc->scsi_lookup_lock);
5277 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
5278 ioc->name, ioc->ScsiLookup));
5280 ioc->sas_data.ptClear = mpt_pt_clear;
5282 hd->last_queue_full = 0;
5283 INIT_LIST_HEAD(&hd->target_reset_list);
5284 INIT_LIST_HEAD(&ioc->sas_device_info_list);
5285 mutex_init(&ioc->sas_device_info_mutex);
5287 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5289 if (ioc->sas_data.ptClear==1) {
5290 mptbase_sas_persist_operation(
5291 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
5294 error = scsi_add_host(sh, &ioc->pcidev->dev);
5296 dprintk(ioc, printk(MYIOC_s_ERR_FMT
5297 "scsi_add_host failed\n", ioc->name));
5298 goto out_mptsas_probe;
5301 /* older firmware doesn't support expander events */
5302 if ((ioc->facts.HeaderVersion >> 8) < 0xE)
5303 ioc->old_sas_discovery_protocal = 1;
5304 mptsas_scan_sas_topology(ioc);
5305 mptsas_fw_event_on(ioc);
5310 mptscsih_remove(pdev);
5315 mptsas_shutdown(struct pci_dev *pdev)
5317 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5319 mptsas_fw_event_off(ioc);
5320 mptsas_cleanup_fw_event_q(ioc);
5323 static void mptsas_remove(struct pci_dev *pdev)
5325 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5326 struct mptsas_portinfo *p, *n;
5330 printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name);
5335 mptsas_shutdown(pdev);
5337 mptsas_del_device_components(ioc);
5339 ioc->sas_discovery_ignore_events = 1;
5340 sas_remove_host(ioc->sh);
5342 mutex_lock(&ioc->sas_topology_mutex);
5343 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
5345 for (i = 0 ; i < p->num_phys ; i++)
5346 mptsas_port_delete(ioc, p->phy_info[i].port_details);
5351 mutex_unlock(&ioc->sas_topology_mutex);
5352 ioc->hba_port_info = NULL;
5353 mptscsih_remove(pdev);
5356 static struct pci_device_id mptsas_pci_table[] = {
5357 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
5358 PCI_ANY_ID, PCI_ANY_ID },
5359 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
5360 PCI_ANY_ID, PCI_ANY_ID },
5361 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
5362 PCI_ANY_ID, PCI_ANY_ID },
5363 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
5364 PCI_ANY_ID, PCI_ANY_ID },
5365 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
5366 PCI_ANY_ID, PCI_ANY_ID },
5367 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068_820XELP,
5368 PCI_ANY_ID, PCI_ANY_ID },
5369 {0} /* Terminating entry */
5371 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
5374 static struct pci_driver mptsas_driver = {
5376 .id_table = mptsas_pci_table,
5377 .probe = mptsas_probe,
5378 .remove = mptsas_remove,
5379 .shutdown = mptsas_shutdown,
5381 .suspend = mptscsih_suspend,
5382 .resume = mptscsih_resume,
5391 show_mptmod_ver(my_NAME, my_VERSION);
5393 mptsas_transport_template =
5394 sas_attach_transport(&mptsas_transport_functions);
5395 if (!mptsas_transport_template)
5398 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER,
5399 "mptscsih_io_done");
5400 mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER,
5401 "mptscsih_taskmgmt_complete");
5403 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER,
5404 "mptscsih_scandv_complete");
5405 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER,
5406 "mptsas_mgmt_done");
5407 mptsasDeviceResetCtx =
5408 mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER,
5409 "mptsas_taskmgmt_complete");
5411 mpt_event_register(mptsasDoneCtx, mptsas_event_process);
5412 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
5414 error = pci_register_driver(&mptsas_driver);
5416 sas_release_transport(mptsas_transport_template);
5424 pci_unregister_driver(&mptsas_driver);
5425 sas_release_transport(mptsas_transport_template);
5427 mpt_reset_deregister(mptsasDoneCtx);
5428 mpt_event_deregister(mptsasDoneCtx);
5430 mpt_deregister(mptsasMgmtCtx);
5431 mpt_deregister(mptsasInternalCtx);
5432 mpt_deregister(mptsasTaskCtx);
5433 mpt_deregister(mptsasDoneCtx);
5434 mpt_deregister(mptsasDeviceResetCtx);
5437 module_init(mptsas_init);
5438 module_exit(mptsas_exit);