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