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