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/init.h>
49 #include <linux/errno.h>
50 #include <linux/jiffies.h>
51 #include <linux/workqueue.h>
52 #include <linux/delay.h> /* for mdelay */
54 #include <scsi/scsi.h>
55 #include <scsi/scsi_cmnd.h>
56 #include <scsi/scsi_device.h>
57 #include <scsi/scsi_host.h>
58 #include <scsi/scsi_transport_sas.h>
59 #include <scsi/scsi_dbg.h>
66 #define my_NAME "Fusion MPT SAS Host driver"
67 #define my_VERSION MPT_LINUX_VERSION_COMMON
68 #define MYNAM "mptsas"
71 * Reserved channel for integrated raid
73 #define MPTSAS_RAID_CHANNEL 1
75 MODULE_AUTHOR(MODULEAUTHOR);
76 MODULE_DESCRIPTION(my_NAME);
77 MODULE_LICENSE("GPL");
78 MODULE_VERSION(my_VERSION);
80 static int mpt_pt_clear;
81 module_param(mpt_pt_clear, int, 0);
82 MODULE_PARM_DESC(mpt_pt_clear,
83 " Clear persistency table: enable=1 "
84 "(default=MPTSCSIH_PT_CLEAR=0)");
86 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
87 #define MPTSAS_MAX_LUN (16895)
88 static int max_lun = MPTSAS_MAX_LUN;
89 module_param(max_lun, int, 0);
90 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
92 static u8 mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
93 static u8 mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
94 static u8 mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
95 static u8 mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
97 static void mptsas_hotplug_work(struct work_struct *work);
99 static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
100 MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
102 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
103 "---- IO UNIT PAGE 0 ------------\n", ioc->name));
104 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
105 ioc->name, le16_to_cpu(phy_data->AttachedDeviceHandle)));
106 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Controller Handle=0x%X\n",
107 ioc->name, le16_to_cpu(phy_data->ControllerDevHandle)));
108 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port=0x%X\n",
109 ioc->name, phy_data->Port));
110 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port Flags=0x%X\n",
111 ioc->name, phy_data->PortFlags));
112 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Flags=0x%X\n",
113 ioc->name, phy_data->PhyFlags));
114 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
115 ioc->name, phy_data->NegotiatedLinkRate));
116 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
117 "Controller PHY Device Info=0x%X\n", ioc->name,
118 le32_to_cpu(phy_data->ControllerPhyDeviceInfo)));
119 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DiscoveryStatus=0x%X\n\n",
120 ioc->name, le32_to_cpu(phy_data->DiscoveryStatus)));
123 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0)
127 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
129 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
130 "---- SAS PHY PAGE 0 ------------\n", ioc->name));
131 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
132 "Attached Device Handle=0x%X\n", ioc->name,
133 le16_to_cpu(pg0->AttachedDevHandle)));
134 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
135 ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
136 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
137 "Attached PHY Identifier=0x%X\n", ioc->name,
138 pg0->AttachedPhyIdentifier));
139 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Attached Device Info=0x%X\n",
140 ioc->name, le32_to_cpu(pg0->AttachedDeviceInfo)));
141 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
142 ioc->name, pg0->ProgrammedLinkRate));
143 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Change Count=0x%X\n",
144 ioc->name, pg0->ChangeCount));
145 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Info=0x%X\n\n",
146 ioc->name, le32_to_cpu(pg0->PhyInfo)));
149 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1)
151 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
152 "---- SAS PHY PAGE 1 ------------\n", ioc->name));
153 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Invalid Dword Count=0x%x\n",
154 ioc->name, pg1->InvalidDwordCount));
155 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
156 "Running Disparity Error Count=0x%x\n", ioc->name,
157 pg1->RunningDisparityErrorCount));
158 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
159 "Loss Dword Synch Count=0x%x\n", ioc->name,
160 pg1->LossDwordSynchCount));
161 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
162 "PHY Reset Problem Count=0x%x\n\n", ioc->name,
163 pg1->PhyResetProblemCount));
166 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0)
170 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
172 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
173 "---- SAS DEVICE PAGE 0 ---------\n", ioc->name));
174 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
175 ioc->name, le16_to_cpu(pg0->DevHandle)));
176 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Handle=0x%X\n",
177 ioc->name, le16_to_cpu(pg0->ParentDevHandle)));
178 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Enclosure Handle=0x%X\n",
179 ioc->name, le16_to_cpu(pg0->EnclosureHandle)));
180 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Slot=0x%X\n",
181 ioc->name, le16_to_cpu(pg0->Slot)));
182 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
183 ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
184 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Target ID=0x%X\n",
185 ioc->name, pg0->TargetID));
186 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Bus=0x%X\n",
187 ioc->name, pg0->Bus));
188 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Phy Num=0x%X\n",
189 ioc->name, pg0->PhyNum));
190 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Access Status=0x%X\n",
191 ioc->name, le16_to_cpu(pg0->AccessStatus)));
192 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Device Info=0x%X\n",
193 ioc->name, le32_to_cpu(pg0->DeviceInfo)));
194 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Flags=0x%X\n",
195 ioc->name, le16_to_cpu(pg0->Flags)));
196 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n\n",
197 ioc->name, pg0->PhysicalPort));
200 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1)
202 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
203 "---- SAS EXPANDER PAGE 1 ------------\n", ioc->name));
204 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n",
205 ioc->name, pg1->PhysicalPort));
206 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Identifier=0x%X\n",
207 ioc->name, pg1->PhyIdentifier));
208 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
209 ioc->name, pg1->NegotiatedLinkRate));
210 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
211 ioc->name, pg1->ProgrammedLinkRate));
212 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hardware Link Rate=0x%X\n",
213 ioc->name, pg1->HwLinkRate));
214 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Owner Device Handle=0x%X\n",
215 ioc->name, le16_to_cpu(pg1->OwnerDevHandle)));
216 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
217 "Attached Device Handle=0x%X\n\n", ioc->name,
218 le16_to_cpu(pg1->AttachedDevHandle)));
221 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
223 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
224 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
227 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
229 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
230 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
233 static struct mptsas_portinfo *
234 mptsas_get_hba_portinfo(MPT_ADAPTER *ioc)
236 struct list_head *head = &ioc->sas_topology;
237 struct mptsas_portinfo *pi = NULL;
239 /* always the first entry on sas_topology list */
241 if (!list_empty(head))
242 pi = list_entry(head->next, struct mptsas_portinfo, list);
248 * mptsas_find_portinfo_by_handle
250 * This function should be called with the sas_topology_mutex already held
252 static struct mptsas_portinfo *
253 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
255 struct mptsas_portinfo *port_info, *rc=NULL;
258 list_for_each_entry(port_info, &ioc->sas_topology, list)
259 for (i = 0; i < port_info->num_phys; i++)
260 if (port_info->phy_info[i].identify.handle == handle) {
269 * Returns true if there is a scsi end device
272 mptsas_is_end_device(struct mptsas_devinfo * attached)
274 if ((attached->sas_address) &&
275 (attached->device_info &
276 MPI_SAS_DEVICE_INFO_END_DEVICE) &&
277 ((attached->device_info &
278 MPI_SAS_DEVICE_INFO_SSP_TARGET) |
279 (attached->device_info &
280 MPI_SAS_DEVICE_INFO_STP_TARGET) |
281 (attached->device_info &
282 MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
290 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
292 struct mptsas_portinfo *port_info;
293 struct mptsas_phyinfo *phy_info;
299 port_info = port_details->port_info;
300 phy_info = port_info->phy_info;
302 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
303 "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
304 port_details->num_phys, (unsigned long long)
305 port_details->phy_bitmask));
307 for (i = 0; i < port_info->num_phys; i++, phy_info++) {
308 if(phy_info->port_details != port_details)
310 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
311 phy_info->port_details = NULL;
316 static inline struct sas_rphy *
317 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
319 if (phy_info->port_details)
320 return phy_info->port_details->rphy;
326 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
328 if (phy_info->port_details) {
329 phy_info->port_details->rphy = rphy;
330 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
335 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
336 &rphy->dev, MYIOC_s_FMT "add:", ioc->name));
337 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rphy=%p release=%p\n",
338 ioc->name, rphy, rphy->dev.release));
342 static inline struct sas_port *
343 mptsas_get_port(struct mptsas_phyinfo *phy_info)
345 if (phy_info->port_details)
346 return phy_info->port_details->port;
352 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
354 if (phy_info->port_details)
355 phy_info->port_details->port = port;
358 dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
359 &port->dev, MYIOC_s_FMT "add:", ioc->name));
360 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "port=%p release=%p\n",
361 ioc->name, port, port->dev.release));
365 static inline struct scsi_target *
366 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
368 if (phy_info->port_details)
369 return phy_info->port_details->starget;
375 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
378 if (phy_info->port_details)
379 phy_info->port_details->starget = starget;
384 * mptsas_setup_wide_ports
386 * Updates for new and existing narrow/wide port configuration
387 * in the sas_topology
390 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
392 struct mptsas_portinfo_details * port_details;
393 struct mptsas_phyinfo *phy_info, *phy_info_cmp;
397 mutex_lock(&ioc->sas_topology_mutex);
399 phy_info = port_info->phy_info;
400 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
401 if (phy_info->attached.handle)
403 port_details = phy_info->port_details;
406 if (port_details->num_phys < 2)
409 * Removing a phy from a port, letting the last
410 * phy be removed by firmware events.
412 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
413 "%s: [%p]: deleting phy = %d\n",
414 ioc->name, __func__, port_details, i));
415 port_details->num_phys--;
416 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
417 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
418 sas_port_delete_phy(port_details->port, phy_info->phy);
419 phy_info->port_details = NULL;
423 * Populate and refresh the tree
425 phy_info = port_info->phy_info;
426 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
427 sas_address = phy_info->attached.sas_address;
428 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
429 ioc->name, i, (unsigned long long)sas_address));
432 port_details = phy_info->port_details;
437 port_details = kzalloc(sizeof(*port_details),
441 port_details->num_phys = 1;
442 port_details->port_info = port_info;
443 if (phy_info->phy_id < 64 )
444 port_details->phy_bitmask |=
445 (1 << phy_info->phy_id);
446 phy_info->sas_port_add_phy=1;
447 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
448 "phy_id=%d sas_address=0x%018llX\n",
449 ioc->name, i, (unsigned long long)sas_address));
450 phy_info->port_details = port_details;
453 if (i == port_info->num_phys - 1)
455 phy_info_cmp = &port_info->phy_info[i + 1];
456 for (j = i + 1 ; j < port_info->num_phys ; j++,
458 if (!phy_info_cmp->attached.sas_address)
460 if (sas_address != phy_info_cmp->attached.sas_address)
462 if (phy_info_cmp->port_details == port_details )
464 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
465 "\t\tphy_id=%d sas_address=0x%018llX\n",
466 ioc->name, j, (unsigned long long)
467 phy_info_cmp->attached.sas_address));
468 if (phy_info_cmp->port_details) {
470 mptsas_get_rphy(phy_info_cmp);
472 mptsas_get_port(phy_info_cmp);
473 port_details->starget =
474 mptsas_get_starget(phy_info_cmp);
475 port_details->num_phys =
476 phy_info_cmp->port_details->num_phys;
477 if (!phy_info_cmp->port_details->num_phys)
478 kfree(phy_info_cmp->port_details);
480 phy_info_cmp->sas_port_add_phy=1;
482 * Adding a phy to a port
484 phy_info_cmp->port_details = port_details;
485 if (phy_info_cmp->phy_id < 64 )
486 port_details->phy_bitmask |=
487 (1 << phy_info_cmp->phy_id);
488 port_details->num_phys++;
494 for (i = 0; i < port_info->num_phys; i++) {
495 port_details = port_info->phy_info[i].port_details;
498 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
499 "%s: [%p]: phy_id=%02d num_phys=%02d "
500 "bitmask=0x%016llX\n", ioc->name, __func__,
501 port_details, i, port_details->num_phys,
502 (unsigned long long)port_details->phy_bitmask));
503 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
504 ioc->name, port_details->port, port_details->rphy));
506 dsaswideprintk(ioc, printk("\n"));
507 mutex_unlock(&ioc->sas_topology_mutex);
511 * csmisas_find_vtarget
519 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
521 struct scsi_device *sdev;
523 VirtTarget *vtarget = NULL;
525 shost_for_each_device(sdev, ioc->sh) {
526 if ((vdevice = sdev->hostdata) == NULL)
528 if (vdevice->vtarget->id == id &&
529 vdevice->vtarget->channel == channel)
530 vtarget = vdevice->vtarget;
536 * mptsas_target_reset
538 * Issues TARGET_RESET to end device using handshaking method
544 * Returns (1) success
549 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
552 SCSITaskMgmt_t *pScsiTm;
554 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
555 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
556 ioc->name,__func__, __LINE__));
560 /* Format the Request
562 pScsiTm = (SCSITaskMgmt_t *) mf;
563 memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
564 pScsiTm->TargetID = id;
565 pScsiTm->Bus = channel;
566 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
567 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
568 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
570 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
572 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
578 * mptsas_target_reset_queue
580 * Receive request for TARGET_RESET after recieving an firmware
581 * event NOT_RESPONDING_EVENT, then put command in link list
582 * and queue if task_queue already in use.
589 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
590 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
592 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
593 VirtTarget *vtarget = NULL;
594 struct mptsas_target_reset_event *target_reset_list;
597 id = sas_event_data->TargetID;
598 channel = sas_event_data->Bus;
600 if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
603 vtarget->deleted = 1; /* block IO */
605 target_reset_list = kzalloc(sizeof(*target_reset_list),
607 if (!target_reset_list) {
608 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
609 ioc->name,__func__, __LINE__));
613 memcpy(&target_reset_list->sas_event_data, sas_event_data,
614 sizeof(*sas_event_data));
615 list_add_tail(&target_reset_list->list, &hd->target_reset_list);
617 if (hd->resetPending)
620 if (mptsas_target_reset(ioc, channel, id)) {
621 target_reset_list->target_reset_issued = 1;
622 hd->resetPending = 1;
627 * mptsas_dev_reset_complete
629 * Completion for TARGET_RESET after NOT_RESPONDING_EVENT,
630 * enable work queue to finish off removing device from upper layers.
631 * then send next TARGET_RESET in the queue.
637 mptsas_dev_reset_complete(MPT_ADAPTER *ioc)
639 MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
640 struct list_head *head = &hd->target_reset_list;
641 struct mptsas_target_reset_event *target_reset_list;
642 struct mptsas_hotplug_event *ev;
643 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
647 if (list_empty(head))
650 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, list);
652 sas_event_data = &target_reset_list->sas_event_data;
653 id = sas_event_data->TargetID;
654 channel = sas_event_data->Bus;
655 hd->resetPending = 0;
660 if (!target_reset_list->target_reset_issued) {
661 if (mptsas_target_reset(ioc, channel, id)) {
662 target_reset_list->target_reset_issued = 1;
663 hd->resetPending = 1;
669 * enable work queue to remove device from upper layers
671 list_del(&target_reset_list->list);
673 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
675 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
676 ioc->name,__func__, __LINE__));
680 INIT_WORK(&ev->work, mptsas_hotplug_work);
682 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
684 le16_to_cpu(sas_event_data->ParentDevHandle);
685 ev->channel = channel;
687 ev->phy_id = sas_event_data->PhyNum;
688 memcpy(&sas_address, &sas_event_data->SASAddress,
690 ev->sas_address = le64_to_cpu(sas_address);
691 ev->device_info = le32_to_cpu(sas_event_data->DeviceInfo);
692 ev->event_type = MPTSAS_DEL_DEVICE;
693 schedule_work(&ev->work);
694 kfree(target_reset_list);
697 * issue target reset to next device in the queue
700 head = &hd->target_reset_list;
701 if (list_empty(head))
704 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
707 sas_event_data = &target_reset_list->sas_event_data;
708 id = sas_event_data->TargetID;
709 channel = sas_event_data->Bus;
711 if (mptsas_target_reset(ioc, channel, id)) {
712 target_reset_list->target_reset_issued = 1;
713 hd->resetPending = 1;
718 * mptsas_taskmgmt_complete
726 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
728 mptsas_dev_reset_complete(ioc);
729 return mptscsih_taskmgmt_complete(ioc, mf, mr);
740 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
743 struct mptsas_target_reset_event *target_reset_list, *n;
746 rc = mptscsih_ioc_reset(ioc, reset_phase);
748 if (ioc->bus_type != SAS)
751 if (reset_phase != MPT_IOC_POST_RESET)
754 if (!ioc->sh || !ioc->sh->hostdata)
756 hd = shost_priv(ioc->sh);
760 if (list_empty(&hd->target_reset_list))
763 /* flush the target_reset_list */
764 list_for_each_entry_safe(target_reset_list, n,
765 &hd->target_reset_list, list) {
766 list_del(&target_reset_list->list);
767 kfree(target_reset_list);
775 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
776 u32 form, u32 form_specific)
778 ConfigExtendedPageHeader_t hdr;
780 SasEnclosurePage0_t *buffer;
781 dma_addr_t dma_handle;
783 __le64 le_identifier;
785 memset(&hdr, 0, sizeof(hdr));
786 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
788 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
789 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
791 cfg.cfghdr.ehdr = &hdr;
793 cfg.pageAddr = form + form_specific;
794 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
795 cfg.dir = 0; /* read */
798 error = mpt_config(ioc, &cfg);
801 if (!hdr.ExtPageLength) {
806 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
813 cfg.physAddr = dma_handle;
814 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
816 error = mpt_config(ioc, &cfg);
818 goto out_free_consistent;
820 /* save config data */
821 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
822 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
823 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
824 enclosure->flags = le16_to_cpu(buffer->Flags);
825 enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
826 enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
827 enclosure->start_id = buffer->StartTargetID;
828 enclosure->start_channel = buffer->StartBus;
829 enclosure->sep_id = buffer->SEPTargetID;
830 enclosure->sep_channel = buffer->SEPBus;
833 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
840 mptsas_slave_configure(struct scsi_device *sdev)
843 if (sdev->channel == MPTSAS_RAID_CHANNEL)
846 sas_read_port_mode_page(sdev);
849 return mptscsih_slave_configure(sdev);
853 mptsas_target_alloc(struct scsi_target *starget)
855 struct Scsi_Host *host = dev_to_shost(&starget->dev);
856 MPT_SCSI_HOST *hd = shost_priv(host);
859 struct sas_rphy *rphy;
860 struct mptsas_portinfo *p;
862 MPT_ADAPTER *ioc = hd->ioc;
864 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
868 vtarget->starget = starget;
869 vtarget->ioc_id = ioc->id;
870 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
875 * RAID volumes placed beyond the last expected port.
877 if (starget->channel == MPTSAS_RAID_CHANNEL) {
878 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
879 if (id == ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
880 channel = ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
884 rphy = dev_to_rphy(starget->dev.parent);
885 mutex_lock(&ioc->sas_topology_mutex);
886 list_for_each_entry(p, &ioc->sas_topology, list) {
887 for (i = 0; i < p->num_phys; i++) {
888 if (p->phy_info[i].attached.sas_address !=
889 rphy->identify.sas_address)
891 id = p->phy_info[i].attached.id;
892 channel = p->phy_info[i].attached.channel;
893 mptsas_set_starget(&p->phy_info[i], starget);
896 * Exposing hidden raid components
898 if (mptscsih_is_phys_disk(ioc, channel, id)) {
899 id = mptscsih_raid_id_to_num(ioc,
902 MPT_TARGET_FLAGS_RAID_COMPONENT;
903 p->phy_info[i].attached.phys_disk_num = id;
905 mutex_unlock(&ioc->sas_topology_mutex);
909 mutex_unlock(&ioc->sas_topology_mutex);
916 vtarget->channel = channel;
917 starget->hostdata = vtarget;
922 mptsas_target_destroy(struct scsi_target *starget)
924 struct Scsi_Host *host = dev_to_shost(&starget->dev);
925 MPT_SCSI_HOST *hd = shost_priv(host);
926 struct sas_rphy *rphy;
927 struct mptsas_portinfo *p;
929 MPT_ADAPTER *ioc = hd->ioc;
931 if (!starget->hostdata)
934 if (starget->channel == MPTSAS_RAID_CHANNEL)
937 rphy = dev_to_rphy(starget->dev.parent);
938 list_for_each_entry(p, &ioc->sas_topology, list) {
939 for (i = 0; i < p->num_phys; i++) {
940 if (p->phy_info[i].attached.sas_address !=
941 rphy->identify.sas_address)
943 mptsas_set_starget(&p->phy_info[i], NULL);
949 kfree(starget->hostdata);
950 starget->hostdata = NULL;
955 mptsas_slave_alloc(struct scsi_device *sdev)
957 struct Scsi_Host *host = sdev->host;
958 MPT_SCSI_HOST *hd = shost_priv(host);
959 struct sas_rphy *rphy;
960 struct mptsas_portinfo *p;
962 struct scsi_target *starget;
964 MPT_ADAPTER *ioc = hd->ioc;
966 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
968 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
969 ioc->name, sizeof(VirtDevice));
972 starget = scsi_target(sdev);
973 vdevice->vtarget = starget->hostdata;
975 if (sdev->channel == MPTSAS_RAID_CHANNEL)
978 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
979 mutex_lock(&ioc->sas_topology_mutex);
980 list_for_each_entry(p, &ioc->sas_topology, list) {
981 for (i = 0; i < p->num_phys; i++) {
982 if (p->phy_info[i].attached.sas_address !=
983 rphy->identify.sas_address)
985 vdevice->lun = sdev->lun;
987 * Exposing hidden raid components
989 if (mptscsih_is_phys_disk(ioc,
990 p->phy_info[i].attached.channel,
991 p->phy_info[i].attached.id))
992 sdev->no_uld_attach = 1;
993 mutex_unlock(&ioc->sas_topology_mutex);
997 mutex_unlock(&ioc->sas_topology_mutex);
1003 vdevice->vtarget->num_luns++;
1004 sdev->hostdata = vdevice;
1009 mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1011 VirtDevice *vdevice = SCpnt->device->hostdata;
1013 if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
1014 SCpnt->result = DID_NO_CONNECT << 16;
1019 // scsi_print_command(SCpnt);
1021 return mptscsih_qcmd(SCpnt,done);
1025 static struct scsi_host_template mptsas_driver_template = {
1026 .module = THIS_MODULE,
1027 .proc_name = "mptsas",
1028 .proc_info = mptscsih_proc_info,
1029 .name = "MPT SPI Host",
1030 .info = mptscsih_info,
1031 .queuecommand = mptsas_qcmd,
1032 .target_alloc = mptsas_target_alloc,
1033 .slave_alloc = mptsas_slave_alloc,
1034 .slave_configure = mptsas_slave_configure,
1035 .target_destroy = mptsas_target_destroy,
1036 .slave_destroy = mptscsih_slave_destroy,
1037 .change_queue_depth = mptscsih_change_queue_depth,
1038 .eh_abort_handler = mptscsih_abort,
1039 .eh_device_reset_handler = mptscsih_dev_reset,
1040 .eh_bus_reset_handler = mptscsih_bus_reset,
1041 .eh_host_reset_handler = mptscsih_host_reset,
1042 .bios_param = mptscsih_bios_param,
1043 .can_queue = MPT_FC_CAN_QUEUE,
1045 .sg_tablesize = MPT_SCSI_SG_DEPTH,
1046 .max_sectors = 8192,
1048 .use_clustering = ENABLE_CLUSTERING,
1049 .shost_attrs = mptscsih_host_attrs,
1052 static int mptsas_get_linkerrors(struct sas_phy *phy)
1054 MPT_ADAPTER *ioc = phy_to_ioc(phy);
1055 ConfigExtendedPageHeader_t hdr;
1057 SasPhyPage1_t *buffer;
1058 dma_addr_t dma_handle;
1061 /* FIXME: only have link errors on local phys */
1062 if (!scsi_is_sas_phy_local(phy))
1065 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
1066 hdr.ExtPageLength = 0;
1067 hdr.PageNumber = 1 /* page number 1*/;
1070 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1071 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1073 cfg.cfghdr.ehdr = &hdr;
1075 cfg.pageAddr = phy->identify.phy_identifier;
1076 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1077 cfg.dir = 0; /* read */
1080 error = mpt_config(ioc, &cfg);
1083 if (!hdr.ExtPageLength)
1086 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1091 cfg.physAddr = dma_handle;
1092 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1094 error = mpt_config(ioc, &cfg);
1096 goto out_free_consistent;
1098 mptsas_print_phy_pg1(ioc, buffer);
1100 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
1101 phy->running_disparity_error_count =
1102 le32_to_cpu(buffer->RunningDisparityErrorCount);
1103 phy->loss_of_dword_sync_count =
1104 le32_to_cpu(buffer->LossDwordSynchCount);
1105 phy->phy_reset_problem_count =
1106 le32_to_cpu(buffer->PhyResetProblemCount);
1108 out_free_consistent:
1109 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1110 buffer, dma_handle);
1114 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
1115 MPT_FRAME_HDR *reply)
1117 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
1118 if (reply != NULL) {
1119 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
1120 memcpy(ioc->sas_mgmt.reply, reply,
1121 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
1123 complete(&ioc->sas_mgmt.done);
1127 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
1129 MPT_ADAPTER *ioc = phy_to_ioc(phy);
1130 SasIoUnitControlRequest_t *req;
1131 SasIoUnitControlReply_t *reply;
1134 unsigned long timeleft;
1135 int error = -ERESTARTSYS;
1137 /* FIXME: fusion doesn't allow non-local phy reset */
1138 if (!scsi_is_sas_phy_local(phy))
1141 /* not implemented for expanders */
1142 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
1145 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
1148 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
1154 hdr = (MPIHeader_t *) mf;
1155 req = (SasIoUnitControlRequest_t *)mf;
1156 memset(req, 0, sizeof(SasIoUnitControlRequest_t));
1157 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
1158 req->MsgContext = hdr->MsgContext;
1159 req->Operation = hard_reset ?
1160 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
1161 req->PhyNum = phy->identify.phy_identifier;
1163 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
1165 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
1168 /* On timeout reset the board */
1169 mpt_free_msg_frame(ioc, mf);
1170 mpt_HardResetHandler(ioc, CAN_SLEEP);
1175 /* a reply frame is expected */
1176 if ((ioc->sas_mgmt.status &
1177 MPT_IOCTL_STATUS_RF_VALID) == 0) {
1182 /* process the completed Reply Message Frame */
1183 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
1184 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
1185 printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
1186 ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
1194 mutex_unlock(&ioc->sas_mgmt.mutex);
1200 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1202 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1204 struct mptsas_portinfo *p;
1205 struct mptsas_enclosure enclosure_info;
1206 u64 enclosure_handle;
1208 mutex_lock(&ioc->sas_topology_mutex);
1209 list_for_each_entry(p, &ioc->sas_topology, list) {
1210 for (i = 0; i < p->num_phys; i++) {
1211 if (p->phy_info[i].attached.sas_address ==
1212 rphy->identify.sas_address) {
1213 enclosure_handle = p->phy_info[i].
1214 attached.handle_enclosure;
1219 mutex_unlock(&ioc->sas_topology_mutex);
1223 mutex_unlock(&ioc->sas_topology_mutex);
1224 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
1225 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
1226 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
1227 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
1229 *identifier = enclosure_info.enclosure_logical_id;
1234 mptsas_get_bay_identifier(struct sas_rphy *rphy)
1236 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1237 struct mptsas_portinfo *p;
1240 mutex_lock(&ioc->sas_topology_mutex);
1241 list_for_each_entry(p, &ioc->sas_topology, list) {
1242 for (i = 0; i < p->num_phys; i++) {
1243 if (p->phy_info[i].attached.sas_address ==
1244 rphy->identify.sas_address) {
1245 rc = p->phy_info[i].attached.slot;
1252 mutex_unlock(&ioc->sas_topology_mutex);
1256 static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
1257 struct request *req)
1259 MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
1261 SmpPassthroughRequest_t *smpreq;
1262 struct request *rsp = req->next_rq;
1265 unsigned long timeleft;
1267 dma_addr_t dma_addr_in = 0;
1268 dma_addr_t dma_addr_out = 0;
1269 u64 sas_address = 0;
1272 printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n",
1273 ioc->name, __func__);
1277 /* do we need to support multiple segments? */
1278 if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
1279 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
1280 ioc->name, __func__, req->bio->bi_vcnt, req->data_len,
1281 rsp->bio->bi_vcnt, rsp->data_len);
1285 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
1289 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
1295 smpreq = (SmpPassthroughRequest_t *)mf;
1296 memset(smpreq, 0, sizeof(*smpreq));
1298 smpreq->RequestDataLength = cpu_to_le16(req->data_len - 4);
1299 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
1302 sas_address = rphy->identify.sas_address;
1304 struct mptsas_portinfo *port_info;
1306 mutex_lock(&ioc->sas_topology_mutex);
1307 port_info = mptsas_get_hba_portinfo(ioc);
1308 if (port_info && port_info->phy_info)
1310 port_info->phy_info[0].phy->identify.sas_address;
1311 mutex_unlock(&ioc->sas_topology_mutex);
1314 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
1317 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
1320 flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1321 MPI_SGE_FLAGS_END_OF_BUFFER |
1322 MPI_SGE_FLAGS_DIRECTION |
1323 mpt_addr_size()) << MPI_SGE_FLAGS_SHIFT;
1324 flagsLength |= (req->data_len - 4);
1326 dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
1327 req->data_len, PCI_DMA_BIDIRECTIONAL);
1330 mpt_add_sge(psge, flagsLength, dma_addr_out);
1331 psge += (sizeof(u32) + sizeof(dma_addr_t));
1334 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
1335 flagsLength |= rsp->data_len + 4;
1336 dma_addr_in = pci_map_single(ioc->pcidev, bio_data(rsp->bio),
1337 rsp->data_len, PCI_DMA_BIDIRECTIONAL);
1340 mpt_add_sge(psge, flagsLength, dma_addr_in);
1342 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
1344 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
1346 printk(MYIOC_s_ERR_FMT "%s: smp timeout!\n", ioc->name, __func__);
1347 /* On timeout reset the board */
1348 mpt_HardResetHandler(ioc, CAN_SLEEP);
1354 if (ioc->sas_mgmt.status & MPT_IOCTL_STATUS_RF_VALID) {
1355 SmpPassthroughReply_t *smprep;
1357 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
1358 memcpy(req->sense, smprep, sizeof(*smprep));
1359 req->sense_len = sizeof(*smprep);
1360 rsp->resid_len = rsp->data_len - smprep->ResponseDataLength;
1362 printk(MYIOC_s_ERR_FMT "%s: smp passthru reply failed to be returned\n",
1363 ioc->name, __func__);
1368 pci_unmap_single(ioc->pcidev, dma_addr_out, req->data_len,
1369 PCI_DMA_BIDIRECTIONAL);
1371 pci_unmap_single(ioc->pcidev, dma_addr_in, rsp->data_len,
1372 PCI_DMA_BIDIRECTIONAL);
1375 mpt_free_msg_frame(ioc, mf);
1377 mutex_unlock(&ioc->sas_mgmt.mutex);
1382 static struct sas_function_template mptsas_transport_functions = {
1383 .get_linkerrors = mptsas_get_linkerrors,
1384 .get_enclosure_identifier = mptsas_get_enclosure_identifier,
1385 .get_bay_identifier = mptsas_get_bay_identifier,
1386 .phy_reset = mptsas_phy_reset,
1387 .smp_handler = mptsas_smp_handler,
1390 static struct scsi_transport_template *mptsas_transport_template;
1393 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
1395 ConfigExtendedPageHeader_t hdr;
1397 SasIOUnitPage0_t *buffer;
1398 dma_addr_t dma_handle;
1401 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
1402 hdr.ExtPageLength = 0;
1406 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1407 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1409 cfg.cfghdr.ehdr = &hdr;
1412 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1413 cfg.dir = 0; /* read */
1416 error = mpt_config(ioc, &cfg);
1419 if (!hdr.ExtPageLength) {
1424 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1431 cfg.physAddr = dma_handle;
1432 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1434 error = mpt_config(ioc, &cfg);
1436 goto out_free_consistent;
1438 port_info->num_phys = buffer->NumPhys;
1439 port_info->phy_info = kcalloc(port_info->num_phys,
1440 sizeof(*port_info->phy_info),GFP_KERNEL);
1441 if (!port_info->phy_info) {
1443 goto out_free_consistent;
1446 ioc->nvdata_version_persistent =
1447 le16_to_cpu(buffer->NvdataVersionPersistent);
1448 ioc->nvdata_version_default =
1449 le16_to_cpu(buffer->NvdataVersionDefault);
1451 for (i = 0; i < port_info->num_phys; i++) {
1452 mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
1453 port_info->phy_info[i].phy_id = i;
1454 port_info->phy_info[i].port_id =
1455 buffer->PhyData[i].Port;
1456 port_info->phy_info[i].negotiated_link_rate =
1457 buffer->PhyData[i].NegotiatedLinkRate;
1458 port_info->phy_info[i].portinfo = port_info;
1459 port_info->phy_info[i].handle =
1460 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
1463 out_free_consistent:
1464 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1465 buffer, dma_handle);
1471 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
1473 ConfigExtendedPageHeader_t hdr;
1475 SasIOUnitPage1_t *buffer;
1476 dma_addr_t dma_handle;
1478 u16 device_missing_delay;
1480 memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
1481 memset(&cfg, 0, sizeof(CONFIGPARMS));
1483 cfg.cfghdr.ehdr = &hdr;
1484 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1486 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1487 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1488 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
1489 cfg.cfghdr.ehdr->PageNumber = 1;
1491 error = mpt_config(ioc, &cfg);
1494 if (!hdr.ExtPageLength) {
1499 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1506 cfg.physAddr = dma_handle;
1507 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1509 error = mpt_config(ioc, &cfg);
1511 goto out_free_consistent;
1513 ioc->io_missing_delay =
1514 le16_to_cpu(buffer->IODeviceMissingDelay);
1515 device_missing_delay = le16_to_cpu(buffer->ReportDeviceMissingDelay);
1516 ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
1517 (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
1518 device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
1520 out_free_consistent:
1521 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1522 buffer, dma_handle);
1528 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1529 u32 form, u32 form_specific)
1531 ConfigExtendedPageHeader_t hdr;
1533 SasPhyPage0_t *buffer;
1534 dma_addr_t dma_handle;
1537 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
1538 hdr.ExtPageLength = 0;
1542 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1543 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1545 cfg.cfghdr.ehdr = &hdr;
1546 cfg.dir = 0; /* read */
1549 /* Get Phy Pg 0 for each Phy. */
1551 cfg.pageAddr = form + form_specific;
1552 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1554 error = mpt_config(ioc, &cfg);
1558 if (!hdr.ExtPageLength) {
1563 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1570 cfg.physAddr = dma_handle;
1571 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1573 error = mpt_config(ioc, &cfg);
1575 goto out_free_consistent;
1577 mptsas_print_phy_pg0(ioc, buffer);
1579 phy_info->hw_link_rate = buffer->HwLinkRate;
1580 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1581 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1582 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1584 out_free_consistent:
1585 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1586 buffer, dma_handle);
1592 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
1593 u32 form, u32 form_specific)
1595 ConfigExtendedPageHeader_t hdr;
1597 SasDevicePage0_t *buffer;
1598 dma_addr_t dma_handle;
1602 if (ioc->sas_discovery_runtime &&
1603 mptsas_is_end_device(device_info))
1606 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
1607 hdr.ExtPageLength = 0;
1611 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1612 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1614 cfg.cfghdr.ehdr = &hdr;
1615 cfg.pageAddr = form + form_specific;
1617 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1618 cfg.dir = 0; /* read */
1621 memset(device_info, 0, sizeof(struct mptsas_devinfo));
1622 error = mpt_config(ioc, &cfg);
1625 if (!hdr.ExtPageLength) {
1630 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1637 cfg.physAddr = dma_handle;
1638 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1640 error = mpt_config(ioc, &cfg);
1642 goto out_free_consistent;
1644 mptsas_print_device_pg0(ioc, buffer);
1646 device_info->handle = le16_to_cpu(buffer->DevHandle);
1647 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
1648 device_info->handle_enclosure =
1649 le16_to_cpu(buffer->EnclosureHandle);
1650 device_info->slot = le16_to_cpu(buffer->Slot);
1651 device_info->phy_id = buffer->PhyNum;
1652 device_info->port_id = buffer->PhysicalPort;
1653 device_info->id = buffer->TargetID;
1654 device_info->phys_disk_num = ~0;
1655 device_info->channel = buffer->Bus;
1656 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
1657 device_info->sas_address = le64_to_cpu(sas_address);
1658 device_info->device_info =
1659 le32_to_cpu(buffer->DeviceInfo);
1661 out_free_consistent:
1662 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1663 buffer, dma_handle);
1669 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
1670 u32 form, u32 form_specific)
1672 ConfigExtendedPageHeader_t hdr;
1674 SasExpanderPage0_t *buffer;
1675 dma_addr_t dma_handle;
1678 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1679 hdr.ExtPageLength = 0;
1683 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1684 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1686 cfg.cfghdr.ehdr = &hdr;
1688 cfg.pageAddr = form + form_specific;
1689 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1690 cfg.dir = 0; /* read */
1693 memset(port_info, 0, sizeof(struct mptsas_portinfo));
1694 error = mpt_config(ioc, &cfg);
1698 if (!hdr.ExtPageLength) {
1703 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1710 cfg.physAddr = dma_handle;
1711 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1713 error = mpt_config(ioc, &cfg);
1715 goto out_free_consistent;
1717 if (!buffer->NumPhys) {
1719 goto out_free_consistent;
1722 /* save config data */
1723 port_info->num_phys = buffer->NumPhys;
1724 port_info->phy_info = kcalloc(port_info->num_phys,
1725 sizeof(*port_info->phy_info),GFP_KERNEL);
1726 if (!port_info->phy_info) {
1728 goto out_free_consistent;
1731 for (i = 0; i < port_info->num_phys; i++) {
1732 port_info->phy_info[i].portinfo = port_info;
1733 port_info->phy_info[i].handle =
1734 le16_to_cpu(buffer->DevHandle);
1737 out_free_consistent:
1738 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1739 buffer, dma_handle);
1745 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1746 u32 form, u32 form_specific)
1748 ConfigExtendedPageHeader_t hdr;
1750 SasExpanderPage1_t *buffer;
1751 dma_addr_t dma_handle;
1754 if (ioc->sas_discovery_runtime &&
1755 mptsas_is_end_device(&phy_info->attached))
1758 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1759 hdr.ExtPageLength = 0;
1763 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1764 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1766 cfg.cfghdr.ehdr = &hdr;
1768 cfg.pageAddr = form + form_specific;
1769 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1770 cfg.dir = 0; /* read */
1773 error = mpt_config(ioc, &cfg);
1777 if (!hdr.ExtPageLength) {
1782 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1789 cfg.physAddr = dma_handle;
1790 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1792 error = mpt_config(ioc, &cfg);
1794 goto out_free_consistent;
1797 mptsas_print_expander_pg1(ioc, buffer);
1799 /* save config data */
1800 phy_info->phy_id = buffer->PhyIdentifier;
1801 phy_info->port_id = buffer->PhysicalPort;
1802 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
1803 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1804 phy_info->hw_link_rate = buffer->HwLinkRate;
1805 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1806 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1808 out_free_consistent:
1809 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1810 buffer, dma_handle);
1816 mptsas_parse_device_info(struct sas_identify *identify,
1817 struct mptsas_devinfo *device_info)
1821 identify->sas_address = device_info->sas_address;
1822 identify->phy_identifier = device_info->phy_id;
1825 * Fill in Phy Initiator Port Protocol.
1826 * Bits 6:3, more than one bit can be set, fall through cases.
1828 protocols = device_info->device_info & 0x78;
1829 identify->initiator_port_protocols = 0;
1830 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
1831 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
1832 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1833 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
1834 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
1835 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
1836 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
1837 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
1840 * Fill in Phy Target Port Protocol.
1841 * Bits 10:7, more than one bit can be set, fall through cases.
1843 protocols = device_info->device_info & 0x780;
1844 identify->target_port_protocols = 0;
1845 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1846 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
1847 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
1848 identify->target_port_protocols |= SAS_PROTOCOL_STP;
1849 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
1850 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
1851 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1852 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
1855 * Fill in Attached device type.
1857 switch (device_info->device_info &
1858 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
1859 case MPI_SAS_DEVICE_INFO_NO_DEVICE:
1860 identify->device_type = SAS_PHY_UNUSED;
1862 case MPI_SAS_DEVICE_INFO_END_DEVICE:
1863 identify->device_type = SAS_END_DEVICE;
1865 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
1866 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
1868 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
1869 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
1874 static int mptsas_probe_one_phy(struct device *dev,
1875 struct mptsas_phyinfo *phy_info, int index, int local)
1878 struct sas_phy *phy;
1879 struct sas_port *port;
1887 if (!phy_info->phy) {
1888 phy = sas_phy_alloc(dev, index);
1894 phy = phy_info->phy;
1896 mptsas_parse_device_info(&phy->identify, &phy_info->identify);
1899 * Set Negotiated link rate.
1901 switch (phy_info->negotiated_link_rate) {
1902 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
1903 phy->negotiated_linkrate = SAS_PHY_DISABLED;
1905 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
1906 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
1908 case MPI_SAS_IOUNIT0_RATE_1_5:
1909 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
1911 case MPI_SAS_IOUNIT0_RATE_3_0:
1912 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
1914 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
1915 case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
1917 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
1922 * Set Max hardware link rate.
1924 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1925 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
1926 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1928 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1929 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1936 * Set Max programmed link rate.
1938 switch (phy_info->programmed_link_rate &
1939 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1940 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
1941 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1943 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1944 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1951 * Set Min hardware link rate.
1953 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
1954 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
1955 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1957 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1958 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1965 * Set Min programmed link rate.
1967 switch (phy_info->programmed_link_rate &
1968 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
1969 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
1970 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1972 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1973 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1979 if (!phy_info->phy) {
1981 error = sas_phy_add(phy);
1986 phy_info->phy = phy;
1989 if (!phy_info->attached.handle ||
1990 !phy_info->port_details)
1993 port = mptsas_get_port(phy_info);
1994 ioc = phy_to_ioc(phy_info->phy);
1996 if (phy_info->sas_port_add_phy) {
1999 port = sas_port_alloc_num(dev);
2004 error = sas_port_add(port);
2006 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2007 "%s: exit at line=%d\n", ioc->name,
2008 __func__, __LINE__));
2011 mptsas_set_port(ioc, phy_info, port);
2012 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2013 "sas_port_alloc: port=%p dev=%p port_id=%d\n",
2014 ioc->name, port, dev, port->port_identifier));
2016 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_port_add_phy: phy_id=%d\n",
2017 ioc->name, phy_info->phy_id));
2018 sas_port_add_phy(port, phy_info->phy);
2019 phy_info->sas_port_add_phy = 0;
2022 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
2024 struct sas_rphy *rphy;
2025 struct device *parent;
2026 struct sas_identify identify;
2028 parent = dev->parent->parent;
2030 * Let the hotplug_work thread handle processing
2031 * the adding/removing of devices that occur
2032 * after start of day.
2034 if (ioc->sas_discovery_runtime &&
2035 mptsas_is_end_device(&phy_info->attached))
2038 mptsas_parse_device_info(&identify, &phy_info->attached);
2039 if (scsi_is_host_device(parent)) {
2040 struct mptsas_portinfo *port_info;
2043 mutex_lock(&ioc->sas_topology_mutex);
2044 port_info = mptsas_get_hba_portinfo(ioc);
2045 mutex_unlock(&ioc->sas_topology_mutex);
2047 for (i = 0; i < port_info->num_phys; i++)
2048 if (port_info->phy_info[i].identify.sas_address ==
2049 identify.sas_address) {
2050 sas_port_mark_backlink(port);
2054 } else if (scsi_is_sas_rphy(parent)) {
2055 struct sas_rphy *parent_rphy = dev_to_rphy(parent);
2056 if (identify.sas_address ==
2057 parent_rphy->identify.sas_address) {
2058 sas_port_mark_backlink(port);
2063 switch (identify.device_type) {
2064 case SAS_END_DEVICE:
2065 rphy = sas_end_device_alloc(port);
2067 case SAS_EDGE_EXPANDER_DEVICE:
2068 case SAS_FANOUT_EXPANDER_DEVICE:
2069 rphy = sas_expander_alloc(port, identify.device_type);
2076 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2077 "%s: exit at line=%d\n", ioc->name,
2078 __func__, __LINE__));
2082 rphy->identify = identify;
2083 error = sas_rphy_add(rphy);
2085 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2086 "%s: exit at line=%d\n", ioc->name,
2087 __func__, __LINE__));
2088 sas_rphy_free(rphy);
2091 mptsas_set_rphy(ioc, phy_info, rphy);
2099 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
2101 struct mptsas_portinfo *port_info, *hba;
2102 int error = -ENOMEM, i;
2104 hba = kzalloc(sizeof(*port_info), GFP_KERNEL);
2108 error = mptsas_sas_io_unit_pg0(ioc, hba);
2110 goto out_free_port_info;
2112 mptsas_sas_io_unit_pg1(ioc);
2113 mutex_lock(&ioc->sas_topology_mutex);
2114 port_info = mptsas_get_hba_portinfo(ioc);
2117 list_add_tail(&port_info->list, &ioc->sas_topology);
2119 for (i = 0; i < hba->num_phys; i++) {
2120 port_info->phy_info[i].negotiated_link_rate =
2121 hba->phy_info[i].negotiated_link_rate;
2122 port_info->phy_info[i].handle =
2123 hba->phy_info[i].handle;
2124 port_info->phy_info[i].port_id =
2125 hba->phy_info[i].port_id;
2127 kfree(hba->phy_info);
2131 mutex_unlock(&ioc->sas_topology_mutex);
2132 for (i = 0; i < port_info->num_phys; i++) {
2133 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
2134 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
2135 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
2137 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
2138 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2139 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2140 port_info->phy_info[i].handle);
2141 port_info->phy_info[i].identify.phy_id =
2142 port_info->phy_info[i].phy_id = i;
2143 if (port_info->phy_info[i].attached.handle)
2144 mptsas_sas_device_pg0(ioc,
2145 &port_info->phy_info[i].attached,
2146 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2147 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2148 port_info->phy_info[i].attached.handle);
2151 mptsas_setup_wide_ports(ioc, port_info);
2153 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
2154 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
2155 &port_info->phy_info[i], ioc->sas_index, 1);
2166 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)
2168 struct mptsas_portinfo *port_info, *p, *ex;
2169 struct device *parent;
2170 struct sas_rphy *rphy;
2171 int error = -ENOMEM, i, j;
2173 ex = kzalloc(sizeof(*port_info), GFP_KERNEL);
2177 error = mptsas_sas_expander_pg0(ioc, ex,
2178 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
2179 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
2181 goto out_free_port_info;
2183 *handle = ex->phy_info[0].handle;
2185 mutex_lock(&ioc->sas_topology_mutex);
2186 port_info = mptsas_find_portinfo_by_handle(ioc, *handle);
2189 list_add_tail(&port_info->list, &ioc->sas_topology);
2191 for (i = 0; i < ex->num_phys; i++) {
2192 port_info->phy_info[i].handle =
2193 ex->phy_info[i].handle;
2194 port_info->phy_info[i].port_id =
2195 ex->phy_info[i].port_id;
2197 kfree(ex->phy_info);
2201 mutex_unlock(&ioc->sas_topology_mutex);
2203 for (i = 0; i < port_info->num_phys; i++) {
2204 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
2205 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
2206 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
2208 if (port_info->phy_info[i].identify.handle) {
2209 mptsas_sas_device_pg0(ioc,
2210 &port_info->phy_info[i].identify,
2211 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2212 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2213 port_info->phy_info[i].identify.handle);
2214 port_info->phy_info[i].identify.phy_id =
2215 port_info->phy_info[i].phy_id;
2218 if (port_info->phy_info[i].attached.handle) {
2219 mptsas_sas_device_pg0(ioc,
2220 &port_info->phy_info[i].attached,
2221 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2222 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2223 port_info->phy_info[i].attached.handle);
2224 port_info->phy_info[i].attached.phy_id =
2225 port_info->phy_info[i].phy_id;
2229 parent = &ioc->sh->shost_gendev;
2230 for (i = 0; i < port_info->num_phys; i++) {
2231 mutex_lock(&ioc->sas_topology_mutex);
2232 list_for_each_entry(p, &ioc->sas_topology, list) {
2233 for (j = 0; j < p->num_phys; j++) {
2234 if (port_info->phy_info[i].identify.handle !=
2235 p->phy_info[j].attached.handle)
2237 rphy = mptsas_get_rphy(&p->phy_info[j]);
2238 parent = &rphy->dev;
2241 mutex_unlock(&ioc->sas_topology_mutex);
2244 mptsas_setup_wide_ports(ioc, port_info);
2246 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
2247 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
2254 kfree(ex->phy_info);
2262 * mptsas_delete_expander_phys
2265 * This will traverse topology, and remove expanders
2266 * that are no longer present
2269 mptsas_delete_expander_phys(MPT_ADAPTER *ioc)
2271 struct mptsas_portinfo buffer;
2272 struct mptsas_portinfo *port_info, *n, *parent;
2273 struct mptsas_phyinfo *phy_info;
2274 struct sas_port * port;
2276 u64 expander_sas_address;
2278 mutex_lock(&ioc->sas_topology_mutex);
2279 list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {
2281 if (!(port_info->phy_info[0].identify.device_info &
2282 MPI_SAS_DEVICE_INFO_SMP_TARGET))
2285 if (mptsas_sas_expander_pg0(ioc, &buffer,
2286 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
2287 MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
2288 port_info->phy_info[0].handle)) {
2291 * Obtain the port_info instance to the parent port
2293 parent = mptsas_find_portinfo_by_handle(ioc,
2294 port_info->phy_info[0].identify.handle_parent);
2299 expander_sas_address =
2300 port_info->phy_info[0].identify.sas_address;
2303 * Delete rphys in the parent that point
2304 * to this expander. The transport layer will
2305 * cleanup all the children.
2307 phy_info = parent->phy_info;
2308 for (i = 0; i < parent->num_phys; i++, phy_info++) {
2309 port = mptsas_get_port(phy_info);
2312 if (phy_info->attached.sas_address !=
2313 expander_sas_address)
2316 dev_printk(KERN_DEBUG, &port->dev,
2317 MYIOC_s_FMT "delete port (%d)\n", ioc->name,
2318 port->port_identifier));
2319 sas_port_delete(port);
2320 mptsas_port_delete(ioc, phy_info->port_details);
2324 phy_info = port_info->phy_info;
2325 for (i = 0; i < port_info->num_phys; i++, phy_info++)
2326 mptsas_port_delete(ioc, phy_info->port_details);
2328 list_del(&port_info->list);
2329 kfree(port_info->phy_info);
2333 * Free this memory allocated from inside
2334 * mptsas_sas_expander_pg0
2336 kfree(buffer.phy_info);
2338 mutex_unlock(&ioc->sas_topology_mutex);
2342 * Start of day discovery
2345 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
2347 u32 handle = 0xFFFF;
2350 mutex_lock(&ioc->sas_discovery_mutex);
2351 mptsas_probe_hba_phys(ioc);
2352 while (!mptsas_probe_expander_phys(ioc, &handle))
2355 Reporting RAID volumes.
2357 if (!ioc->ir_firmware)
2359 if (!ioc->raid_data.pIocPg2)
2361 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
2363 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
2364 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
2365 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
2368 mutex_unlock(&ioc->sas_discovery_mutex);
2372 * Work queue thread to handle Runtime discovery
2373 * Mere purpose is the hot add/delete of expanders
2377 __mptsas_discovery_work(MPT_ADAPTER *ioc)
2379 u32 handle = 0xFFFF;
2381 ioc->sas_discovery_runtime=1;
2382 mptsas_delete_expander_phys(ioc);
2383 mptsas_probe_hba_phys(ioc);
2384 while (!mptsas_probe_expander_phys(ioc, &handle))
2386 ioc->sas_discovery_runtime=0;
2390 * Work queue thread to handle Runtime discovery
2391 * Mere purpose is the hot add/delete of expanders
2395 mptsas_discovery_work(struct work_struct *work)
2397 struct mptsas_discovery_event *ev =
2398 container_of(work, struct mptsas_discovery_event, work);
2399 MPT_ADAPTER *ioc = ev->ioc;
2401 mutex_lock(&ioc->sas_discovery_mutex);
2402 __mptsas_discovery_work(ioc);
2403 mutex_unlock(&ioc->sas_discovery_mutex);
2407 static struct mptsas_phyinfo *
2408 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
2410 struct mptsas_portinfo *port_info;
2411 struct mptsas_phyinfo *phy_info = NULL;
2414 mutex_lock(&ioc->sas_topology_mutex);
2415 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2416 for (i = 0; i < port_info->num_phys; i++) {
2417 if (!mptsas_is_end_device(
2418 &port_info->phy_info[i].attached))
2420 if (port_info->phy_info[i].attached.sas_address
2423 phy_info = &port_info->phy_info[i];
2427 mutex_unlock(&ioc->sas_topology_mutex);
2431 static struct mptsas_phyinfo *
2432 mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id)
2434 struct mptsas_portinfo *port_info;
2435 struct mptsas_phyinfo *phy_info = NULL;
2438 mutex_lock(&ioc->sas_topology_mutex);
2439 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2440 for (i = 0; i < port_info->num_phys; i++) {
2441 if (!mptsas_is_end_device(
2442 &port_info->phy_info[i].attached))
2444 if (port_info->phy_info[i].attached.id != id)
2446 if (port_info->phy_info[i].attached.channel != channel)
2448 phy_info = &port_info->phy_info[i];
2452 mutex_unlock(&ioc->sas_topology_mutex);
2456 static struct mptsas_phyinfo *
2457 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2459 struct mptsas_portinfo *port_info;
2460 struct mptsas_phyinfo *phy_info = NULL;
2463 mutex_lock(&ioc->sas_topology_mutex);
2464 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2465 for (i = 0; i < port_info->num_phys; i++) {
2466 if (!mptsas_is_end_device(
2467 &port_info->phy_info[i].attached))
2469 if (port_info->phy_info[i].attached.phys_disk_num == ~0)
2471 if (port_info->phy_info[i].attached.phys_disk_num != id)
2473 if (port_info->phy_info[i].attached.channel != channel)
2475 phy_info = &port_info->phy_info[i];
2479 mutex_unlock(&ioc->sas_topology_mutex);
2484 * Work queue thread to clear the persitency table
2487 mptsas_persist_clear_table(struct work_struct *work)
2489 MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task);
2491 mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
2495 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
2499 sdev->no_uld_attach = data ? 1 : 0;
2500 rc = scsi_device_reprobe(sdev);
2504 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
2506 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
2507 mptsas_reprobe_lun);
2511 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
2514 ConfigPageHeader_t hdr;
2515 dma_addr_t dma_handle;
2516 pRaidVolumePage0_t buffer = NULL;
2517 RaidPhysDiskPage0_t phys_disk;
2519 struct mptsas_hotplug_event *ev;
2521 memset(&cfg, 0 , sizeof(CONFIGPARMS));
2522 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
2523 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
2524 cfg.pageAddr = (channel << 8) + id;
2525 cfg.cfghdr.hdr = &hdr;
2526 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2528 if (mpt_config(ioc, &cfg) != 0)
2531 if (!hdr.PageLength)
2534 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
2540 cfg.physAddr = dma_handle;
2541 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2543 if (mpt_config(ioc, &cfg) != 0)
2546 if (!(buffer->VolumeStatus.Flags &
2547 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
2550 if (!buffer->NumPhysDisks)
2553 for (i = 0; i < buffer->NumPhysDisks; i++) {
2555 if (mpt_raid_phys_disk_pg0(ioc,
2556 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
2559 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2561 printk(MYIOC_s_WARN_FMT "mptsas: lost hotplug event\n", ioc->name);
2565 INIT_WORK(&ev->work, mptsas_hotplug_work);
2567 ev->id = phys_disk.PhysDiskID;
2568 ev->channel = phys_disk.PhysDiskBus;
2569 ev->phys_disk_num_valid = 1;
2570 ev->phys_disk_num = phys_disk.PhysDiskNum;
2571 ev->event_type = MPTSAS_ADD_DEVICE;
2572 schedule_work(&ev->work);
2577 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
2581 * Work queue thread to handle SAS hotplug events
2584 mptsas_hotplug_work(struct work_struct *work)
2586 struct mptsas_hotplug_event *ev =
2587 container_of(work, struct mptsas_hotplug_event, work);
2589 MPT_ADAPTER *ioc = ev->ioc;
2590 struct mptsas_phyinfo *phy_info;
2591 struct sas_rphy *rphy;
2592 struct sas_port *port;
2593 struct scsi_device *sdev;
2594 struct scsi_target * starget;
2595 struct sas_identify identify;
2597 struct mptsas_devinfo sas_device;
2598 VirtTarget *vtarget;
2599 VirtDevice *vdevice;
2601 mutex_lock(&ioc->sas_discovery_mutex);
2602 switch (ev->event_type) {
2603 case MPTSAS_DEL_DEVICE:
2606 if (ev->phys_disk_num_valid) {
2607 if (ev->hidden_raid_component){
2608 if (mptsas_sas_device_pg0(ioc, &sas_device,
2609 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2610 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2611 (ev->channel << 8) + ev->id)) {
2612 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2613 "%s: exit at line=%d\n", ioc->name,
2614 __func__, __LINE__));
2617 phy_info = mptsas_find_phyinfo_by_sas_address(
2618 ioc, sas_device.sas_address);
2620 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
2621 ioc, ev->channel, ev->phys_disk_num);
2625 phy_info = mptsas_find_phyinfo_by_target(ioc,
2626 ev->channel, ev->id);
2629 * Sanity checks, for non-existing phys and remote rphys.
2632 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2633 "%s: exit at line=%d\n", ioc->name,
2634 __func__, __LINE__));
2637 if (!phy_info->port_details) {
2638 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2639 "%s: exit at line=%d\n", ioc->name,
2640 __func__, __LINE__));
2643 rphy = mptsas_get_rphy(phy_info);
2645 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2646 "%s: exit at line=%d\n", ioc->name,
2647 __func__, __LINE__));
2651 port = mptsas_get_port(phy_info);
2653 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2654 "%s: exit at line=%d\n", ioc->name,
2655 __func__, __LINE__));
2659 starget = mptsas_get_starget(phy_info);
2661 vtarget = starget->hostdata;
2664 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2665 "%s: exit at line=%d\n", ioc->name,
2666 __func__, __LINE__));
2671 * Handling RAID components
2673 if (ev->phys_disk_num_valid &&
2674 ev->hidden_raid_component) {
2675 printk(MYIOC_s_INFO_FMT
2676 "RAID Hidding: channel=%d, id=%d, "
2677 "physdsk %d \n", ioc->name, ev->channel,
2678 ev->id, ev->phys_disk_num);
2679 vtarget->id = ev->phys_disk_num;
2681 MPT_TARGET_FLAGS_RAID_COMPONENT;
2682 mptsas_reprobe_target(starget, 1);
2683 phy_info->attached.phys_disk_num =
2689 if (phy_info->attached.device_info &
2690 MPI_SAS_DEVICE_INFO_SSP_TARGET)
2692 if (phy_info->attached.device_info &
2693 MPI_SAS_DEVICE_INFO_STP_TARGET)
2695 if (phy_info->attached.device_info &
2696 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2699 printk(MYIOC_s_INFO_FMT
2700 "removing %s device, channel %d, id %d, phy %d\n",
2701 ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
2702 dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
2703 "delete port (%d)\n", ioc->name, port->port_identifier);
2704 sas_port_delete(port);
2705 mptsas_port_delete(ioc, phy_info->port_details);
2707 case MPTSAS_ADD_DEVICE:
2709 if (ev->phys_disk_num_valid)
2710 mpt_findImVolumes(ioc);
2713 * Refresh sas device pg0 data
2715 if (mptsas_sas_device_pg0(ioc, &sas_device,
2716 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2717 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2718 (ev->channel << 8) + ev->id)) {
2719 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2720 "%s: exit at line=%d\n", ioc->name,
2721 __func__, __LINE__));
2725 __mptsas_discovery_work(ioc);
2727 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
2728 sas_device.sas_address);
2730 if (!phy_info || !phy_info->port_details) {
2731 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2732 "%s: exit at line=%d\n", ioc->name,
2733 __func__, __LINE__));
2737 starget = mptsas_get_starget(phy_info);
2738 if (starget && (!ev->hidden_raid_component)){
2740 vtarget = starget->hostdata;
2743 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2744 "%s: exit at line=%d\n", ioc->name,
2745 __func__, __LINE__));
2749 * Handling RAID components
2751 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
2752 printk(MYIOC_s_INFO_FMT
2753 "RAID Exposing: channel=%d, id=%d, "
2754 "physdsk %d \n", ioc->name, ev->channel,
2755 ev->id, ev->phys_disk_num);
2757 ~MPT_TARGET_FLAGS_RAID_COMPONENT;
2758 vtarget->id = ev->id;
2759 mptsas_reprobe_target(starget, 0);
2760 phy_info->attached.phys_disk_num = ~0;
2765 if (mptsas_get_rphy(phy_info)) {
2766 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2767 "%s: exit at line=%d\n", ioc->name,
2768 __func__, __LINE__));
2769 if (ev->channel) printk("%d\n", __LINE__);
2773 port = mptsas_get_port(phy_info);
2775 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2776 "%s: exit at line=%d\n", ioc->name,
2777 __func__, __LINE__));
2780 memcpy(&phy_info->attached, &sas_device,
2781 sizeof(struct mptsas_devinfo));
2783 if (phy_info->attached.device_info &
2784 MPI_SAS_DEVICE_INFO_SSP_TARGET)
2786 if (phy_info->attached.device_info &
2787 MPI_SAS_DEVICE_INFO_STP_TARGET)
2789 if (phy_info->attached.device_info &
2790 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2793 printk(MYIOC_s_INFO_FMT
2794 "attaching %s device, channel %d, id %d, phy %d\n",
2795 ioc->name, ds, ev->channel, ev->id, ev->phy_id);
2797 mptsas_parse_device_info(&identify, &phy_info->attached);
2798 rphy = sas_end_device_alloc(port);
2800 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2801 "%s: exit at line=%d\n", ioc->name,
2802 __func__, __LINE__));
2803 break; /* non-fatal: an rphy can be added later */
2806 rphy->identify = identify;
2807 if (sas_rphy_add(rphy)) {
2808 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
2809 "%s: exit at line=%d\n", ioc->name,
2810 __func__, __LINE__));
2811 sas_rphy_free(rphy);
2814 mptsas_set_rphy(ioc, phy_info, rphy);
2816 case MPTSAS_ADD_RAID:
2817 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2820 scsi_device_put(sdev);
2823 printk(MYIOC_s_INFO_FMT
2824 "attaching raid volume, channel %d, id %d\n",
2825 ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2826 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0);
2827 mpt_findImVolumes(ioc);
2829 case MPTSAS_DEL_RAID:
2830 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2834 printk(MYIOC_s_INFO_FMT
2835 "removing raid volume, channel %d, id %d\n",
2836 ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2837 vdevice = sdev->hostdata;
2838 scsi_remove_device(sdev);
2839 scsi_device_put(sdev);
2840 mpt_findImVolumes(ioc);
2842 case MPTSAS_ADD_INACTIVE_VOLUME:
2843 mptsas_adding_inactive_raid_components(ioc,
2844 ev->channel, ev->id);
2846 case MPTSAS_IGNORE_EVENT:
2851 mutex_unlock(&ioc->sas_discovery_mutex);
2856 mptsas_send_sas_event(MPT_ADAPTER *ioc,
2857 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
2859 struct mptsas_hotplug_event *ev;
2860 u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
2864 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
2865 MPI_SAS_DEVICE_INFO_STP_TARGET |
2866 MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
2869 switch (sas_event_data->ReasonCode) {
2870 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
2872 mptsas_target_reset_queue(ioc, sas_event_data);
2875 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
2876 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2878 printk(MYIOC_s_WARN_FMT "lost hotplug event\n", ioc->name);
2882 INIT_WORK(&ev->work, mptsas_hotplug_work);
2884 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
2886 le16_to_cpu(sas_event_data->ParentDevHandle);
2887 ev->channel = sas_event_data->Bus;
2888 ev->id = sas_event_data->TargetID;
2889 ev->phy_id = sas_event_data->PhyNum;
2890 memcpy(&sas_address, &sas_event_data->SASAddress,
2892 ev->sas_address = le64_to_cpu(sas_address);
2893 ev->device_info = device_info;
2895 if (sas_event_data->ReasonCode &
2896 MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
2897 ev->event_type = MPTSAS_ADD_DEVICE;
2899 ev->event_type = MPTSAS_DEL_DEVICE;
2900 schedule_work(&ev->work);
2902 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
2904 * Persistent table is full.
2906 INIT_WORK(&ioc->sas_persist_task,
2907 mptsas_persist_clear_table);
2908 schedule_work(&ioc->sas_persist_task);
2911 * TODO, handle other events
2913 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
2914 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
2915 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
2916 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
2917 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
2918 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
2919 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
2925 mptsas_send_raid_event(MPT_ADAPTER *ioc,
2926 EVENT_DATA_RAID *raid_event_data)
2928 struct mptsas_hotplug_event *ev;
2929 int status = le32_to_cpu(raid_event_data->SettingsStatus);
2930 int state = (status >> 8) & 0xff;
2932 if (ioc->bus_type != SAS)
2935 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2937 printk(MYIOC_s_WARN_FMT "lost hotplug event\n", ioc->name);
2941 INIT_WORK(&ev->work, mptsas_hotplug_work);
2943 ev->id = raid_event_data->VolumeID;
2944 ev->channel = raid_event_data->VolumeBus;
2945 ev->event_type = MPTSAS_IGNORE_EVENT;
2947 switch (raid_event_data->ReasonCode) {
2948 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
2949 ev->phys_disk_num_valid = 1;
2950 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2951 ev->event_type = MPTSAS_ADD_DEVICE;
2953 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
2954 ev->phys_disk_num_valid = 1;
2955 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2956 ev->hidden_raid_component = 1;
2957 ev->event_type = MPTSAS_DEL_DEVICE;
2959 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
2961 case MPI_PD_STATE_ONLINE:
2962 case MPI_PD_STATE_NOT_COMPATIBLE:
2963 ev->phys_disk_num_valid = 1;
2964 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2965 ev->hidden_raid_component = 1;
2966 ev->event_type = MPTSAS_ADD_DEVICE;
2968 case MPI_PD_STATE_MISSING:
2969 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
2970 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
2971 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
2972 ev->phys_disk_num_valid = 1;
2973 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2974 ev->event_type = MPTSAS_DEL_DEVICE;
2980 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
2981 ev->event_type = MPTSAS_DEL_RAID;
2983 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
2984 ev->event_type = MPTSAS_ADD_RAID;
2986 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
2988 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
2989 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
2990 ev->event_type = MPTSAS_DEL_RAID;
2992 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
2993 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
2994 ev->event_type = MPTSAS_ADD_RAID;
3003 schedule_work(&ev->work);
3007 mptsas_send_discovery_event(MPT_ADAPTER *ioc,
3008 EVENT_DATA_SAS_DISCOVERY *discovery_data)
3010 struct mptsas_discovery_event *ev;
3015 * This flag will be non-zero when firmware
3016 * kicks off discovery, and return to zero
3017 * once its completed.
3019 if (discovery_data->DiscoveryStatus)
3022 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
3025 INIT_WORK(&ev->work, mptsas_discovery_work);
3027 schedule_work(&ev->work);
3031 * mptsas_send_ir2_event - handle exposing hidden disk when
3032 * an inactive raid volume is added
3034 * @ioc: Pointer to MPT_ADAPTER structure
3039 mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data)
3041 struct mptsas_hotplug_event *ev;
3043 if (ir2_data->ReasonCode !=
3044 MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED)
3047 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
3051 INIT_WORK(&ev->work, mptsas_hotplug_work);
3053 ev->id = ir2_data->TargetID;
3054 ev->channel = ir2_data->Bus;
3055 ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME;
3057 schedule_work(&ev->work);
3061 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
3064 u8 event = le32_to_cpu(reply->Event) & 0xFF;
3070 * sas_discovery_ignore_events
3072 * This flag is to prevent anymore processing of
3073 * sas events once mptsas_remove function is called.
3075 if (ioc->sas_discovery_ignore_events) {
3076 rc = mptscsih_event_process(ioc, reply);
3081 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
3082 mptsas_send_sas_event(ioc,
3083 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
3085 case MPI_EVENT_INTEGRATED_RAID:
3086 mptsas_send_raid_event(ioc,
3087 (EVENT_DATA_RAID *)reply->Data);
3089 case MPI_EVENT_PERSISTENT_TABLE_FULL:
3090 INIT_WORK(&ioc->sas_persist_task,
3091 mptsas_persist_clear_table);
3092 schedule_work(&ioc->sas_persist_task);
3094 case MPI_EVENT_SAS_DISCOVERY:
3095 mptsas_send_discovery_event(ioc,
3096 (EVENT_DATA_SAS_DISCOVERY *)reply->Data);
3099 mptsas_send_ir2_event(ioc,
3100 (PTR_MPI_EVENT_DATA_IR2)reply->Data);
3103 rc = mptscsih_event_process(ioc, reply);
3112 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
3114 struct Scsi_Host *sh;
3117 unsigned long flags;
3125 r = mpt_attach(pdev,id);
3129 ioc = pci_get_drvdata(pdev);
3130 ioc->DoneCtx = mptsasDoneCtx;
3131 ioc->TaskCtx = mptsasTaskCtx;
3132 ioc->InternalCtx = mptsasInternalCtx;
3134 /* Added sanity check on readiness of the MPT adapter.
3136 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
3137 printk(MYIOC_s_WARN_FMT
3138 "Skipping because it's not operational!\n",
3141 goto out_mptsas_probe;
3145 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
3148 goto out_mptsas_probe;
3151 /* Sanity check - ensure at least 1 port is INITIATOR capable
3154 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
3155 if (ioc->pfacts[ii].ProtocolFlags &
3156 MPI_PORTFACTS_PROTOCOL_INITIATOR)
3161 printk(MYIOC_s_WARN_FMT
3162 "Skipping ioc=%p because SCSI Initiator mode "
3163 "is NOT enabled!\n", ioc->name, ioc);
3167 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
3169 printk(MYIOC_s_WARN_FMT
3170 "Unable to register controller with SCSI subsystem\n",
3173 goto out_mptsas_probe;
3176 spin_lock_irqsave(&ioc->FreeQlock, flags);
3178 /* Attach the SCSI Host to the IOC structure
3186 /* set 16 byte cdb's */
3187 sh->max_cmd_len = 16;
3189 sh->max_id = ioc->pfacts[0].PortSCSIID;
3190 sh->max_lun = max_lun;
3192 sh->transportt = mptsas_transport_template;
3196 sh->unique_id = ioc->id;
3198 INIT_LIST_HEAD(&ioc->sas_topology);
3199 mutex_init(&ioc->sas_topology_mutex);
3200 mutex_init(&ioc->sas_discovery_mutex);
3201 mutex_init(&ioc->sas_mgmt.mutex);
3202 init_completion(&ioc->sas_mgmt.done);
3204 /* Verify that we won't exceed the maximum
3205 * number of chain buffers
3206 * We can optimize: ZZ = req_sz/sizeof(SGE)
3208 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
3209 * + (req_sz - 64)/sizeof(SGE)
3210 * A slightly different algorithm is required for
3213 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
3214 if (sizeof(dma_addr_t) == sizeof(u64)) {
3215 numSGE = (scale - 1) *
3216 (ioc->facts.MaxChainDepth-1) + scale +
3217 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
3220 numSGE = 1 + (scale - 1) *
3221 (ioc->facts.MaxChainDepth-1) + scale +
3222 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
3226 if (numSGE < sh->sg_tablesize) {
3227 /* Reset this value */
3228 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3229 "Resetting sg_tablesize to %d from %d\n",
3230 ioc->name, numSGE, sh->sg_tablesize));
3231 sh->sg_tablesize = numSGE;
3234 hd = shost_priv(sh);
3237 /* SCSI needs scsi_cmnd lookup table!
3238 * (with size equal to req_depth*PtrSz!)
3240 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
3241 if (!ioc->ScsiLookup) {
3243 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
3244 goto out_mptsas_probe;
3246 spin_lock_init(&ioc->scsi_lookup_lock);
3248 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
3249 ioc->name, ioc->ScsiLookup));
3251 /* Clear the TM flags
3254 hd->tmState = TM_STATE_NONE;
3255 hd->resetPending = 0;
3256 hd->abortSCpnt = NULL;
3258 /* Clear the pointer used to store
3259 * single-threaded commands, i.e., those
3260 * issued during a bus scan, dv and
3261 * configuration pages.
3265 /* Initialize this SCSI Hosts' timers
3266 * To use, set the timer expires field
3269 init_timer(&hd->timer);
3270 hd->timer.data = (unsigned long) hd;
3271 hd->timer.function = mptscsih_timer_expired;
3273 ioc->sas_data.ptClear = mpt_pt_clear;
3275 init_waitqueue_head(&hd->scandv_waitq);
3276 hd->scandv_wait_done = 0;
3277 hd->last_queue_full = 0;
3278 INIT_LIST_HEAD(&hd->target_reset_list);
3279 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
3281 if (ioc->sas_data.ptClear==1) {
3282 mptbase_sas_persist_operation(
3283 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
3286 error = scsi_add_host(sh, &ioc->pcidev->dev);
3288 dprintk(ioc, printk(MYIOC_s_ERR_FMT
3289 "scsi_add_host failed\n", ioc->name));
3290 goto out_mptsas_probe;
3293 mptsas_scan_sas_topology(ioc);
3299 mptscsih_remove(pdev);
3303 static void __devexit mptsas_remove(struct pci_dev *pdev)
3305 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
3306 struct mptsas_portinfo *p, *n;
3309 ioc->sas_discovery_ignore_events = 1;
3310 sas_remove_host(ioc->sh);
3312 mutex_lock(&ioc->sas_topology_mutex);
3313 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
3315 for (i = 0 ; i < p->num_phys ; i++)
3316 mptsas_port_delete(ioc, p->phy_info[i].port_details);
3320 mutex_unlock(&ioc->sas_topology_mutex);
3322 mptscsih_remove(pdev);
3325 static struct pci_device_id mptsas_pci_table[] = {
3326 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
3327 PCI_ANY_ID, PCI_ANY_ID },
3328 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
3329 PCI_ANY_ID, PCI_ANY_ID },
3330 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
3331 PCI_ANY_ID, PCI_ANY_ID },
3332 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
3333 PCI_ANY_ID, PCI_ANY_ID },
3334 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
3335 PCI_ANY_ID, PCI_ANY_ID },
3336 {0} /* Terminating entry */
3338 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
3341 static struct pci_driver mptsas_driver = {
3343 .id_table = mptsas_pci_table,
3344 .probe = mptsas_probe,
3345 .remove = __devexit_p(mptsas_remove),
3346 .shutdown = mptscsih_shutdown,
3348 .suspend = mptscsih_suspend,
3349 .resume = mptscsih_resume,
3358 show_mptmod_ver(my_NAME, my_VERSION);
3360 mptsas_transport_template =
3361 sas_attach_transport(&mptsas_transport_functions);
3362 if (!mptsas_transport_template)
3365 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
3366 mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
3368 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
3369 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
3371 mpt_event_register(mptsasDoneCtx, mptsas_event_process);
3372 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
3374 error = pci_register_driver(&mptsas_driver);
3376 sas_release_transport(mptsas_transport_template);
3384 pci_unregister_driver(&mptsas_driver);
3385 sas_release_transport(mptsas_transport_template);
3387 mpt_reset_deregister(mptsasDoneCtx);
3388 mpt_event_deregister(mptsasDoneCtx);
3390 mpt_deregister(mptsasMgmtCtx);
3391 mpt_deregister(mptsasInternalCtx);
3392 mpt_deregister(mptsasTaskCtx);
3393 mpt_deregister(mptsasDoneCtx);
3396 module_init(mptsas_init);
3397 module_exit(mptsas_exit);