CoCalc -- mptsas.c

GitHub Repository: awilliam/linux-vfio
Path: blob/master/drivers/message/fusion/mptsas.c
¹⁵¹⁰⁹ views
1
/*
2
 *  linux/drivers/message/fusion/mptsas.c
3
 *      For use with LSI PCI chip/adapter(s)
4
 *      running LSI Fusion MPT (Message Passing Technology) firmware.
5
 *
6
 *  Copyright (c) 1999-2008 LSI Corporation
7
 *  (mailto:[email protected])
8
 */
9
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10
/*
11
    This program is free software; you can redistribute it and/or modify
12
    it under the terms of the GNU General Public License as published by
13
    the Free Software Foundation; version 2 of the License.
14

15
    This program is distributed in the hope that it will be useful,
16
    but WITHOUT ANY WARRANTY; without even the implied warranty of
17
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
    GNU General Public License for more details.
19

20
    NO WARRANTY
21
    THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
22
    CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
23
    LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
24
    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
25
    solely responsible for determining the appropriateness of using and
26
    distributing the Program and assumes all risks associated with its
27
    exercise of rights under this Agreement, including but not limited to
28
    the risks and costs of program errors, damage to or loss of data,
29
    programs or equipment, and unavailability or interruption of operations.
30

31
    DISCLAIMER OF LIABILITY
32
    NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
33
    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34
    DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
35
    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
36
    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
37
    USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
38
    HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
39

40
    You should have received a copy of the GNU General Public License
41
    along with this program; if not, write to the Free Software
42
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
43
*/
44
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
45

46
#include <linux/module.h>
47
#include <linux/kernel.h>
48
#include <linux/slab.h>
49
#include <linux/init.h>
50
#include <linux/errno.h>
51
#include <linux/jiffies.h>
52
#include <linux/workqueue.h>
53
#include <linux/delay.h>	/* for mdelay */
54

55
#include <scsi/scsi.h>
56
#include <scsi/scsi_cmnd.h>
57
#include <scsi/scsi_device.h>
58
#include <scsi/scsi_host.h>
59
#include <scsi/scsi_transport_sas.h>
60
#include <scsi/scsi_transport.h>
61
#include <scsi/scsi_dbg.h>
62

63
#include "mptbase.h"
64
#include "mptscsih.h"
65
#include "mptsas.h"
66

67

68
#define my_NAME		"Fusion MPT SAS Host driver"
69
#define my_VERSION	MPT_LINUX_VERSION_COMMON
70
#define MYNAM		"mptsas"
71

72
/*
73
 * Reserved channel for integrated raid
74
 */
75
#define MPTSAS_RAID_CHANNEL	1
76

77
#define SAS_CONFIG_PAGE_TIMEOUT		30
78
MODULE_AUTHOR(MODULEAUTHOR);
79
MODULE_DESCRIPTION(my_NAME);
80
MODULE_LICENSE("GPL");
81
MODULE_VERSION(my_VERSION);
82

83
static int mpt_pt_clear;
84
module_param(mpt_pt_clear, int, 0);
85
MODULE_PARM_DESC(mpt_pt_clear,
86
		" Clear persistency table: enable=1  "
87
		"(default=MPTSCSIH_PT_CLEAR=0)");
88

89
/* scsi-mid layer global parmeter is max_report_luns, which is 511 */
90
#define MPTSAS_MAX_LUN (16895)
91
static int max_lun = MPTSAS_MAX_LUN;
92
module_param(max_lun, int, 0);
93
MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
94

95
static u8	mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
96
static u8	mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
97
static u8	mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
98
static u8	mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
99
static u8	mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS;
100

101
static void mptsas_firmware_event_work(struct work_struct *work);
102
static void mptsas_send_sas_event(struct fw_event_work *fw_event);
103
static void mptsas_send_raid_event(struct fw_event_work *fw_event);
104
static void mptsas_send_ir2_event(struct fw_event_work *fw_event);
105
static void mptsas_parse_device_info(struct sas_identify *identify,
106
		struct mptsas_devinfo *device_info);
107
static inline void mptsas_set_rphy(MPT_ADAPTER *ioc,
108
		struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy);
109
static struct mptsas_phyinfo	*mptsas_find_phyinfo_by_sas_address
110
		(MPT_ADAPTER *ioc, u64 sas_address);
111
static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
112
	struct mptsas_devinfo *device_info, u32 form, u32 form_specific);
113
static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc,
114
	struct mptsas_enclosure *enclosure, u32 form, u32 form_specific);
115
static int mptsas_add_end_device(MPT_ADAPTER *ioc,
116
	struct mptsas_phyinfo *phy_info);
117
static void mptsas_del_end_device(MPT_ADAPTER *ioc,
118
	struct mptsas_phyinfo *phy_info);
119
static void mptsas_send_link_status_event(struct fw_event_work *fw_event);
120
static struct mptsas_portinfo	*mptsas_find_portinfo_by_sas_address
121
		(MPT_ADAPTER *ioc, u64 sas_address);
122
static void mptsas_expander_delete(MPT_ADAPTER *ioc,
123
		struct mptsas_portinfo *port_info, u8 force);
124
static void mptsas_send_expander_event(struct fw_event_work *fw_event);
125
static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
126
static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
127
static void mptsas_broadcast_primative_work(struct fw_event_work *fw_event);
128
static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event);
129
static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id);
130
void	mptsas_schedule_target_reset(void *ioc);
131

132
static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
133
					MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
134
{
135
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
136
	    "---- IO UNIT PAGE 0 ------------\n", ioc->name));
137
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
138
	    ioc->name, le16_to_cpu(phy_data->AttachedDeviceHandle)));
139
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Controller Handle=0x%X\n",
140
	    ioc->name, le16_to_cpu(phy_data->ControllerDevHandle)));
141
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port=0x%X\n",
142
	    ioc->name, phy_data->Port));
143
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port Flags=0x%X\n",
144
	    ioc->name, phy_data->PortFlags));
145
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Flags=0x%X\n",
146
	    ioc->name, phy_data->PhyFlags));
147
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
148
	    ioc->name, phy_data->NegotiatedLinkRate));
149
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
150
	    "Controller PHY Device Info=0x%X\n", ioc->name,
151
	    le32_to_cpu(phy_data->ControllerPhyDeviceInfo)));
152
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DiscoveryStatus=0x%X\n\n",
153
	    ioc->name, le32_to_cpu(phy_data->DiscoveryStatus)));
154
}
155

156
static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0)
157
{
158
	__le64 sas_address;
159

160
	memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
161

162
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
163
	    "---- SAS PHY PAGE 0 ------------\n", ioc->name));
164
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
165
	    "Attached Device Handle=0x%X\n", ioc->name,
166
	    le16_to_cpu(pg0->AttachedDevHandle)));
167
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
168
	    ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
169
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
170
	    "Attached PHY Identifier=0x%X\n", ioc->name,
171
	    pg0->AttachedPhyIdentifier));
172
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Attached Device Info=0x%X\n",
173
	    ioc->name, le32_to_cpu(pg0->AttachedDeviceInfo)));
174
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
175
	    ioc->name,  pg0->ProgrammedLinkRate));
176
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Change Count=0x%X\n",
177
	    ioc->name, pg0->ChangeCount));
178
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Info=0x%X\n\n",
179
	    ioc->name, le32_to_cpu(pg0->PhyInfo)));
180
}
181

182
static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1)
183
{
184
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
185
	    "---- SAS PHY PAGE 1 ------------\n", ioc->name));
186
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Invalid Dword Count=0x%x\n",
187
	    ioc->name,  pg1->InvalidDwordCount));
188
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
189
	    "Running Disparity Error Count=0x%x\n", ioc->name,
190
	    pg1->RunningDisparityErrorCount));
191
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
192
	    "Loss Dword Synch Count=0x%x\n", ioc->name,
193
	    pg1->LossDwordSynchCount));
194
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
195
	    "PHY Reset Problem Count=0x%x\n\n", ioc->name,
196
	    pg1->PhyResetProblemCount));
197
}
198

199
static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0)
200
{
201
	__le64 sas_address;
202

203
	memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
204

205
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
206
	    "---- SAS DEVICE PAGE 0 ---------\n", ioc->name));
207
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n",
208
	    ioc->name, le16_to_cpu(pg0->DevHandle)));
209
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Handle=0x%X\n",
210
	    ioc->name, le16_to_cpu(pg0->ParentDevHandle)));
211
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Enclosure Handle=0x%X\n",
212
	    ioc->name, le16_to_cpu(pg0->EnclosureHandle)));
213
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Slot=0x%X\n",
214
	    ioc->name, le16_to_cpu(pg0->Slot)));
215
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n",
216
	    ioc->name, (unsigned long long)le64_to_cpu(sas_address)));
217
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Target ID=0x%X\n",
218
	    ioc->name, pg0->TargetID));
219
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Bus=0x%X\n",
220
	    ioc->name, pg0->Bus));
221
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Phy Num=0x%X\n",
222
	    ioc->name, pg0->PhyNum));
223
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Access Status=0x%X\n",
224
	    ioc->name, le16_to_cpu(pg0->AccessStatus)));
225
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Device Info=0x%X\n",
226
	    ioc->name, le32_to_cpu(pg0->DeviceInfo)));
227
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Flags=0x%X\n",
228
	    ioc->name, le16_to_cpu(pg0->Flags)));
229
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n\n",
230
	    ioc->name, pg0->PhysicalPort));
231
}
232

233
static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1)
234
{
235
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
236
	    "---- SAS EXPANDER PAGE 1 ------------\n", ioc->name));
237
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n",
238
	    ioc->name, pg1->PhysicalPort));
239
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Identifier=0x%X\n",
240
	    ioc->name, pg1->PhyIdentifier));
241
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n",
242
	    ioc->name, pg1->NegotiatedLinkRate));
243
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n",
244
	    ioc->name, pg1->ProgrammedLinkRate));
245
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hardware Link Rate=0x%X\n",
246
	    ioc->name, pg1->HwLinkRate));
247
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Owner Device Handle=0x%X\n",
248
	    ioc->name, le16_to_cpu(pg1->OwnerDevHandle)));
249
	dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT
250
	    "Attached Device Handle=0x%X\n\n", ioc->name,
251
	    le16_to_cpu(pg1->AttachedDevHandle)));
252
}
253

254
/* inhibit sas firmware event handling */
255
static void
256
mptsas_fw_event_off(MPT_ADAPTER *ioc)
257
{
258
	unsigned long flags;
259

260
	spin_lock_irqsave(&ioc->fw_event_lock, flags);
261
	ioc->fw_events_off = 1;
262
	ioc->sas_discovery_quiesce_io = 0;
263
	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
264

265
}
266

267
/* enable sas firmware event handling */
268
static void
269
mptsas_fw_event_on(MPT_ADAPTER *ioc)
270
{
271
	unsigned long flags;
272

273
	spin_lock_irqsave(&ioc->fw_event_lock, flags);
274
	ioc->fw_events_off = 0;
275
	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
276
}
277

278
/* queue a sas firmware event */
279
static void
280
mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
281
    unsigned long delay)
282
{
283
	unsigned long flags;
284

285
	spin_lock_irqsave(&ioc->fw_event_lock, flags);
286
	list_add_tail(&fw_event->list, &ioc->fw_event_list);
287
	INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work);
288
	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: add (fw_event=0x%p)\n",
289
	    ioc->name, __func__, fw_event));
290
	queue_delayed_work(ioc->fw_event_q, &fw_event->work,
291
	    delay);
292
	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
293
}
294

295
/* requeue a sas firmware event */
296
static void
297
mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
298
    unsigned long delay)
299
{
300
	unsigned long flags;
301
	spin_lock_irqsave(&ioc->fw_event_lock, flags);
302
	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: reschedule task "
303
	    "(fw_event=0x%p)\n", ioc->name, __func__, fw_event));
304
	fw_event->retries++;
305
	queue_delayed_work(ioc->fw_event_q, &fw_event->work,
306
	    msecs_to_jiffies(delay));
307
	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
308
}
309

310
/* free memory associated to a sas firmware event */
311
static void
312
mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event)
313
{
314
	unsigned long flags;
315

316
	spin_lock_irqsave(&ioc->fw_event_lock, flags);
317
	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: kfree (fw_event=0x%p)\n",
318
	    ioc->name, __func__, fw_event));
319
	list_del(&fw_event->list);
320
	kfree(fw_event);
321
	spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
322
}
323

324
/* walk the firmware event queue, and either stop or wait for
325
 * outstanding events to complete */
326
static void
327
mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc)
328
{
329
	struct fw_event_work *fw_event, *next;
330
	struct mptsas_target_reset_event *target_reset_list, *n;
331
	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
332

333
	/* flush the target_reset_list */
334
	if (!list_empty(&hd->target_reset_list)) {
335
		list_for_each_entry_safe(target_reset_list, n,
336
		    &hd->target_reset_list, list) {
337
			dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
338
			    "%s: removing target reset for id=%d\n",
339
			    ioc->name, __func__,
340
			   target_reset_list->sas_event_data.TargetID));
341
			list_del(&target_reset_list->list);
342
			kfree(target_reset_list);
343
		}
344
	}
345

346
	if (list_empty(&ioc->fw_event_list) ||
347
	     !ioc->fw_event_q || in_interrupt())
348
		return;
349

350
	list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
351
		if (cancel_delayed_work(&fw_event->work))
352
			mptsas_free_fw_event(ioc, fw_event);
353
	}
354
}
355

356

357
static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
358
{
359
	struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
360
	return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
361
}
362

363
static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
364
{
365
	struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
366
	return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
367
}
368

369
/*
370
 * mptsas_find_portinfo_by_handle
371
 *
372
 * This function should be called with the sas_topology_mutex already held
373
 */
374
static struct mptsas_portinfo *
375
mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
376
{
377
	struct mptsas_portinfo *port_info, *rc=NULL;
378
	int i;
379

380
	list_for_each_entry(port_info, &ioc->sas_topology, list)
381
		for (i = 0; i < port_info->num_phys; i++)
382
			if (port_info->phy_info[i].identify.handle == handle) {
383
				rc = port_info;
384
				goto out;
385
			}
386
 out:
387
	return rc;
388
}
389

390
/**
391
 *	mptsas_find_portinfo_by_sas_address -
392
 *	@ioc: Pointer to MPT_ADAPTER structure
393
 *	@handle:
394
 *
395
 *	This function should be called with the sas_topology_mutex already held
396
 *
397
 **/
398
static struct mptsas_portinfo *
399
mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
400
{
401
	struct mptsas_portinfo *port_info, *rc = NULL;
402
	int i;
403

404
	if (sas_address >= ioc->hba_port_sas_addr &&
405
	    sas_address < (ioc->hba_port_sas_addr +
406
	    ioc->hba_port_num_phy))
407
		return ioc->hba_port_info;
408

409
	mutex_lock(&ioc->sas_topology_mutex);
410
	list_for_each_entry(port_info, &ioc->sas_topology, list)
411
		for (i = 0; i < port_info->num_phys; i++)
412
			if (port_info->phy_info[i].identify.sas_address ==
413
			    sas_address) {
414
				rc = port_info;
415
				goto out;
416
			}
417
 out:
418
	mutex_unlock(&ioc->sas_topology_mutex);
419
	return rc;
420
}
421

422
/*
423
 * Returns true if there is a scsi end device
424
 */
425
static inline int
426
mptsas_is_end_device(struct mptsas_devinfo * attached)
427
{
428
	if ((attached->sas_address) &&
429
	    (attached->device_info &
430
	    MPI_SAS_DEVICE_INFO_END_DEVICE) &&
431
	    ((attached->device_info &
432
	    MPI_SAS_DEVICE_INFO_SSP_TARGET) |
433
	    (attached->device_info &
434
	    MPI_SAS_DEVICE_INFO_STP_TARGET) |
435
	    (attached->device_info &
436
	    MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
437
		return 1;
438
	else
439
		return 0;
440
}
441

442
/* no mutex */
443
static void
444
mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
445
{
446
	struct mptsas_portinfo *port_info;
447
	struct mptsas_phyinfo *phy_info;
448
	u8	i;
449

450
	if (!port_details)
451
		return;
452

453
	port_info = port_details->port_info;
454
	phy_info = port_info->phy_info;
455

456
	dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
457
	    "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
458
	    port_details->num_phys, (unsigned long long)
459
	    port_details->phy_bitmask));
460

461
	for (i = 0; i < port_info->num_phys; i++, phy_info++) {
462
		if(phy_info->port_details != port_details)
463
			continue;
464
		memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
465
		mptsas_set_rphy(ioc, phy_info, NULL);
466
		phy_info->port_details = NULL;
467
	}
468
	kfree(port_details);
469
}
470

471
static inline struct sas_rphy *
472
mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
473
{
474
	if (phy_info->port_details)
475
		return phy_info->port_details->rphy;
476
	else
477
		return NULL;
478
}
479

480
static inline void
481
mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
482
{
483
	if (phy_info->port_details) {
484
		phy_info->port_details->rphy = rphy;
485
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
486
		    ioc->name, rphy));
487
	}
488

489
	if (rphy) {
490
		dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
491
		    &rphy->dev, MYIOC_s_FMT "add:", ioc->name));
492
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rphy=%p release=%p\n",
493
		    ioc->name, rphy, rphy->dev.release));
494
	}
495
}
496

497
static inline struct sas_port *
498
mptsas_get_port(struct mptsas_phyinfo *phy_info)
499
{
500
	if (phy_info->port_details)
501
		return phy_info->port_details->port;
502
	else
503
		return NULL;
504
}
505

506
static inline void
507
mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
508
{
509
	if (phy_info->port_details)
510
		phy_info->port_details->port = port;
511

512
	if (port) {
513
		dsaswideprintk(ioc, dev_printk(KERN_DEBUG,
514
		    &port->dev, MYIOC_s_FMT "add:", ioc->name));
515
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "port=%p release=%p\n",
516
		    ioc->name, port, port->dev.release));
517
	}
518
}
519

520
static inline struct scsi_target *
521
mptsas_get_starget(struct mptsas_phyinfo *phy_info)
522
{
523
	if (phy_info->port_details)
524
		return phy_info->port_details->starget;
525
	else
526
		return NULL;
527
}
528

529
static inline void
530
mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
531
starget)
532
{
533
	if (phy_info->port_details)
534
		phy_info->port_details->starget = starget;
535
}
536

537
/**
538
 *	mptsas_add_device_component -
539
 *	@ioc: Pointer to MPT_ADAPTER structure
540
 *	@channel: fw mapped id's
541
 *	@id:
542
 *	@sas_address:
543
 *	@device_info:
544
 *
545
 **/
546
static void
547
mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id,
548
	u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id)
549
{
550
	struct mptsas_device_info	*sas_info, *next;
551
	struct scsi_device	*sdev;
552
	struct scsi_target	*starget;
553
	struct sas_rphy	*rphy;
554

555
	/*
556
	 * Delete all matching devices out of the list
557
	 */
558
	mutex_lock(&ioc->sas_device_info_mutex);
559
	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
560
	    list) {
561
		if (!sas_info->is_logical_volume &&
562
		    (sas_info->sas_address == sas_address ||
563
		    (sas_info->fw.channel == channel &&
564
		     sas_info->fw.id == id))) {
565
			list_del(&sas_info->list);
566
			kfree(sas_info);
567
		}
568
	}
569

570
	sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
571
	if (!sas_info)
572
		goto out;
573

574
	/*
575
	 * Set Firmware mapping
576
	 */
577
	sas_info->fw.id = id;
578
	sas_info->fw.channel = channel;
579

580
	sas_info->sas_address = sas_address;
581
	sas_info->device_info = device_info;
582
	sas_info->slot = slot;
583
	sas_info->enclosure_logical_id = enclosure_logical_id;
584
	INIT_LIST_HEAD(&sas_info->list);
585
	list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
586

587
	/*
588
	 * Set OS mapping
589
	 */
590
	shost_for_each_device(sdev, ioc->sh) {
591
		starget = scsi_target(sdev);
592
		rphy = dev_to_rphy(starget->dev.parent);
593
		if (rphy->identify.sas_address == sas_address) {
594
			sas_info->os.id = starget->id;
595
			sas_info->os.channel = starget->channel;
596
		}
597
	}
598

599
 out:
600
	mutex_unlock(&ioc->sas_device_info_mutex);
601
	return;
602
}
603

604
/**
605
 *	mptsas_add_device_component_by_fw -
606
 *	@ioc: Pointer to MPT_ADAPTER structure
607
 *	@channel:  fw mapped id's
608
 *	@id:
609
 *
610
 **/
611
static void
612
mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
613
{
614
	struct mptsas_devinfo sas_device;
615
	struct mptsas_enclosure enclosure_info;
616
	int rc;
617

618
	rc = mptsas_sas_device_pg0(ioc, &sas_device,
619
	    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
620
	     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
621
	    (channel << 8) + id);
622
	if (rc)
623
		return;
624

625
	memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
626
	mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
627
	    (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
628
	     MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
629
	     sas_device.handle_enclosure);
630

631
	mptsas_add_device_component(ioc, sas_device.channel,
632
	    sas_device.id, sas_device.sas_address, sas_device.device_info,
633
	    sas_device.slot, enclosure_info.enclosure_logical_id);
634
}
635

636
/**
637
 *	mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding each individual device to list
638
 *	@ioc: Pointer to MPT_ADAPTER structure
639
 *	@channel: fw mapped id's
640
 *	@id:
641
 *
642
 **/
643
static void
644
mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc,
645
		struct scsi_target *starget)
646
{
647
	CONFIGPARMS			cfg;
648
	ConfigPageHeader_t		hdr;
649
	dma_addr_t			dma_handle;
650
	pRaidVolumePage0_t		buffer = NULL;
651
	int				i;
652
	RaidPhysDiskPage0_t 		phys_disk;
653
	struct mptsas_device_info	*sas_info, *next;
654

655
	memset(&cfg, 0 , sizeof(CONFIGPARMS));
656
	memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
657
	hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
658
	/* assumption that all volumes on channel = 0 */
659
	cfg.pageAddr = starget->id;
660
	cfg.cfghdr.hdr = &hdr;
661
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
662
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
663

664
	if (mpt_config(ioc, &cfg) != 0)
665
		goto out;
666

667
	if (!hdr.PageLength)
668
		goto out;
669

670
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
671
	    &dma_handle);
672

673
	if (!buffer)
674
		goto out;
675

676
	cfg.physAddr = dma_handle;
677
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
678

679
	if (mpt_config(ioc, &cfg) != 0)
680
		goto out;
681

682
	if (!buffer->NumPhysDisks)
683
		goto out;
684

685
	/*
686
	 * Adding entry for hidden components
687
	 */
688
	for (i = 0; i < buffer->NumPhysDisks; i++) {
689

690
		if (mpt_raid_phys_disk_pg0(ioc,
691
		    buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
692
			continue;
693

694
		mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus,
695
		    phys_disk.PhysDiskID);
696

697
		mutex_lock(&ioc->sas_device_info_mutex);
698
		list_for_each_entry(sas_info, &ioc->sas_device_info_list,
699
		    list) {
700
			if (!sas_info->is_logical_volume &&
701
			    (sas_info->fw.channel == phys_disk.PhysDiskBus &&
702
			    sas_info->fw.id == phys_disk.PhysDiskID)) {
703
				sas_info->is_hidden_raid_component = 1;
704
				sas_info->volume_id = starget->id;
705
			}
706
		}
707
		mutex_unlock(&ioc->sas_device_info_mutex);
708

709
	}
710

711
	/*
712
	 * Delete all matching devices out of the list
713
	 */
714
	mutex_lock(&ioc->sas_device_info_mutex);
715
	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
716
	    list) {
717
		if (sas_info->is_logical_volume && sas_info->fw.id ==
718
		    starget->id) {
719
			list_del(&sas_info->list);
720
			kfree(sas_info);
721
		}
722
	}
723

724
	sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL);
725
	if (sas_info) {
726
		sas_info->fw.id = starget->id;
727
		sas_info->os.id = starget->id;
728
		sas_info->os.channel = starget->channel;
729
		sas_info->is_logical_volume = 1;
730
		INIT_LIST_HEAD(&sas_info->list);
731
		list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
732
	}
733
	mutex_unlock(&ioc->sas_device_info_mutex);
734

735
 out:
736
	if (buffer)
737
		pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
738
		    dma_handle);
739
}
740

741
/**
742
 *	mptsas_add_device_component_starget -
743
 *	@ioc: Pointer to MPT_ADAPTER structure
744
 *	@starget:
745
 *
746
 **/
747
static void
748
mptsas_add_device_component_starget(MPT_ADAPTER *ioc,
749
	struct scsi_target *starget)
750
{
751
	VirtTarget	*vtarget;
752
	struct sas_rphy	*rphy;
753
	struct mptsas_phyinfo	*phy_info = NULL;
754
	struct mptsas_enclosure	enclosure_info;
755

756
	rphy = dev_to_rphy(starget->dev.parent);
757
	vtarget = starget->hostdata;
758
	phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
759
			rphy->identify.sas_address);
760
	if (!phy_info)
761
		return;
762

763
	memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
764
	mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
765
		(MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
766
		MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
767
		phy_info->attached.handle_enclosure);
768

769
	mptsas_add_device_component(ioc, phy_info->attached.channel,
770
		phy_info->attached.id, phy_info->attached.sas_address,
771
		phy_info->attached.device_info,
772
		phy_info->attached.slot, enclosure_info.enclosure_logical_id);
773
}
774

775
/**
776
 *	mptsas_del_device_component_by_os - Once a device has been removed, we mark the entry in the list as being cached
777
 *	@ioc: Pointer to MPT_ADAPTER structure
778
 *	@channel: os mapped id's
779
 *	@id:
780
 *
781
 **/
782
static void
783
mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
784
{
785
	struct mptsas_device_info	*sas_info, *next;
786

787
	/*
788
	 * Set is_cached flag
789
	 */
790
	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
791
		list) {
792
		if (sas_info->os.channel == channel && sas_info->os.id == id)
793
			sas_info->is_cached = 1;
794
	}
795
}
796

797
/**
798
 *	mptsas_del_device_components - Cleaning the list
799
 *	@ioc: Pointer to MPT_ADAPTER structure
800
 *
801
 **/
802
static void
803
mptsas_del_device_components(MPT_ADAPTER *ioc)
804
{
805
	struct mptsas_device_info	*sas_info, *next;
806

807
	mutex_lock(&ioc->sas_device_info_mutex);
808
	list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
809
		list) {
810
		list_del(&sas_info->list);
811
		kfree(sas_info);
812
	}
813
	mutex_unlock(&ioc->sas_device_info_mutex);
814
}
815

816

817
/*
818
 * mptsas_setup_wide_ports
819
 *
820
 * Updates for new and existing narrow/wide port configuration
821
 * in the sas_topology
822
 */
823
static void
824
mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
825
{
826
	struct mptsas_portinfo_details * port_details;
827
	struct mptsas_phyinfo *phy_info, *phy_info_cmp;
828
	u64	sas_address;
829
	int	i, j;
830

831
	mutex_lock(&ioc->sas_topology_mutex);
832

833
	phy_info = port_info->phy_info;
834
	for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
835
		if (phy_info->attached.handle)
836
			continue;
837
		port_details = phy_info->port_details;
838
		if (!port_details)
839
			continue;
840
		if (port_details->num_phys < 2)
841
			continue;
842
		/*
843
		 * Removing a phy from a port, letting the last
844
		 * phy be removed by firmware events.
845
		 */
846
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
847
		    "%s: [%p]: deleting phy = %d\n",
848
		    ioc->name, __func__, port_details, i));
849
		port_details->num_phys--;
850
		port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
851
		memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
852
		if (phy_info->phy) {
853
			devtprintk(ioc, dev_printk(KERN_DEBUG,
854
				&phy_info->phy->dev, MYIOC_s_FMT
855
				"delete phy %d, phy-obj (0x%p)\n", ioc->name,
856
				phy_info->phy_id, phy_info->phy));
857
			sas_port_delete_phy(port_details->port, phy_info->phy);
858
		}
859
		phy_info->port_details = NULL;
860
	}
861

862
	/*
863
	 * Populate and refresh the tree
864
	 */
865
	phy_info = port_info->phy_info;
866
	for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
867
		sas_address = phy_info->attached.sas_address;
868
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
869
		    ioc->name, i, (unsigned long long)sas_address));
870
		if (!sas_address)
871
			continue;
872
		port_details = phy_info->port_details;
873
		/*
874
		 * Forming a port
875
		 */
876
		if (!port_details) {
877
			port_details = kzalloc(sizeof(struct
878
				mptsas_portinfo_details), GFP_KERNEL);
879
			if (!port_details)
880
				goto out;
881
			port_details->num_phys = 1;
882
			port_details->port_info = port_info;
883
			if (phy_info->phy_id < 64 )
884
				port_details->phy_bitmask |=
885
				    (1 << phy_info->phy_id);
886
			phy_info->sas_port_add_phy=1;
887
			dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
888
			    "phy_id=%d sas_address=0x%018llX\n",
889
			    ioc->name, i, (unsigned long long)sas_address));
890
			phy_info->port_details = port_details;
891
		}
892

893
		if (i == port_info->num_phys - 1)
894
			continue;
895
		phy_info_cmp = &port_info->phy_info[i + 1];
896
		for (j = i + 1 ; j < port_info->num_phys ; j++,
897
		    phy_info_cmp++) {
898
			if (!phy_info_cmp->attached.sas_address)
899
				continue;
900
			if (sas_address != phy_info_cmp->attached.sas_address)
901
				continue;
902
			if (phy_info_cmp->port_details == port_details )
903
				continue;
904
			dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
905
			    "\t\tphy_id=%d sas_address=0x%018llX\n",
906
			    ioc->name, j, (unsigned long long)
907
			    phy_info_cmp->attached.sas_address));
908
			if (phy_info_cmp->port_details) {
909
				port_details->rphy =
910
				    mptsas_get_rphy(phy_info_cmp);
911
				port_details->port =
912
				    mptsas_get_port(phy_info_cmp);
913
				port_details->starget =
914
				    mptsas_get_starget(phy_info_cmp);
915
				port_details->num_phys =
916
					phy_info_cmp->port_details->num_phys;
917
				if (!phy_info_cmp->port_details->num_phys)
918
					kfree(phy_info_cmp->port_details);
919
			} else
920
				phy_info_cmp->sas_port_add_phy=1;
921
			/*
922
			 * Adding a phy to a port
923
			 */
924
			phy_info_cmp->port_details = port_details;
925
			if (phy_info_cmp->phy_id < 64 )
926
				port_details->phy_bitmask |=
927
				(1 << phy_info_cmp->phy_id);
928
			port_details->num_phys++;
929
		}
930
	}
931

932
 out:
933

934
	for (i = 0; i < port_info->num_phys; i++) {
935
		port_details = port_info->phy_info[i].port_details;
936
		if (!port_details)
937
			continue;
938
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
939
		    "%s: [%p]: phy_id=%02d num_phys=%02d "
940
		    "bitmask=0x%016llX\n", ioc->name, __func__,
941
		    port_details, i, port_details->num_phys,
942
		    (unsigned long long)port_details->phy_bitmask));
943
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
944
		    ioc->name, port_details->port, port_details->rphy));
945
	}
946
	dsaswideprintk(ioc, printk("\n"));
947
	mutex_unlock(&ioc->sas_topology_mutex);
948
}
949

950
/**
951
 * csmisas_find_vtarget
952
 *
953
 * @ioc
954
 * @volume_id
955
 * @volume_bus
956
 *
957
 **/
958
static VirtTarget *
959
mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
960
{
961
	struct scsi_device 		*sdev;
962
	VirtDevice			*vdevice;
963
	VirtTarget 			*vtarget = NULL;
964

965
	shost_for_each_device(sdev, ioc->sh) {
966
		vdevice = sdev->hostdata;
967
		if ((vdevice == NULL) ||
968
			(vdevice->vtarget == NULL))
969
			continue;
970
		if ((vdevice->vtarget->tflags &
971
		    MPT_TARGET_FLAGS_RAID_COMPONENT ||
972
		    vdevice->vtarget->raidVolume))
973
			continue;
974
		if (vdevice->vtarget->id == id &&
975
			vdevice->vtarget->channel == channel)
976
			vtarget = vdevice->vtarget;
977
	}
978
	return vtarget;
979
}
980

981
static void
982
mptsas_queue_device_delete(MPT_ADAPTER *ioc,
983
	MpiEventDataSasDeviceStatusChange_t *sas_event_data)
984
{
985
	struct fw_event_work *fw_event;
986
	int sz;
987

988
	sz = offsetof(struct fw_event_work, event_data) +
989
	    sizeof(MpiEventDataSasDeviceStatusChange_t);
990
	fw_event = kzalloc(sz, GFP_ATOMIC);
991
	if (!fw_event) {
992
		printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
993
		    ioc->name, __func__, __LINE__);
994
		return;
995
	}
996
	memcpy(fw_event->event_data, sas_event_data,
997
	    sizeof(MpiEventDataSasDeviceStatusChange_t));
998
	fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
999
	fw_event->ioc = ioc;
1000
	mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1001
}
1002

1003
static void
1004
mptsas_queue_rescan(MPT_ADAPTER *ioc)
1005
{
1006
	struct fw_event_work *fw_event;
1007
	int sz;
1008

1009
	sz = offsetof(struct fw_event_work, event_data);
1010
	fw_event = kzalloc(sz, GFP_ATOMIC);
1011
	if (!fw_event) {
1012
		printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
1013
		    ioc->name, __func__, __LINE__);
1014
		return;
1015
	}
1016
	fw_event->event = -1;
1017
	fw_event->ioc = ioc;
1018
	mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
1019
}
1020

1021

1022
/**
1023
 * mptsas_target_reset
1024
 *
1025
 * Issues TARGET_RESET to end device using handshaking method
1026
 *
1027
 * @ioc
1028
 * @channel
1029
 * @id
1030
 *
1031
 * Returns (1) success
1032
 *         (0) failure
1033
 *
1034
 **/
1035
static int
1036
mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
1037
{
1038
	MPT_FRAME_HDR	*mf;
1039
	SCSITaskMgmt_t	*pScsiTm;
1040
	if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
1041
		return 0;
1042

1043

1044
	mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
1045
	if (mf == NULL) {
1046
		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1047
			"%s, no msg frames @%d!!\n", ioc->name,
1048
			__func__, __LINE__));
1049
		goto out_fail;
1050
	}
1051

1052
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
1053
		ioc->name, mf));
1054

1055
	/* Format the Request
1056
	 */
1057
	pScsiTm = (SCSITaskMgmt_t *) mf;
1058
	memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
1059
	pScsiTm->TargetID = id;
1060
	pScsiTm->Bus = channel;
1061
	pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
1062
	pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
1063
	pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
1064

1065
	DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
1066

1067
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1068
	   "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
1069
	   ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
1070

1071
	mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
1072

1073
	return 1;
1074

1075
 out_fail:
1076

1077
	mpt_clear_taskmgmt_in_progress_flag(ioc);
1078
	return 0;
1079
}
1080

1081
static void
1082
mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
1083
{
1084
	scsi_device_set_state(sdev, SDEV_BLOCK);
1085
}
1086

1087
static void
1088
mptsas_block_io_starget(struct scsi_target *starget)
1089
{
1090
	if (starget)
1091
		starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
1092
}
1093

1094
/**
1095
 * mptsas_target_reset_queue
1096
 *
1097
 * Receive request for TARGET_RESET after receiving an firmware
1098
 * event NOT_RESPONDING_EVENT, then put command in link list
1099
 * and queue if task_queue already in use.
1100
 *
1101
 * @ioc
1102
 * @sas_event_data
1103
 *
1104
 **/
1105
static void
1106
mptsas_target_reset_queue(MPT_ADAPTER *ioc,
1107
    EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
1108
{
1109
	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
1110
	VirtTarget *vtarget = NULL;
1111
	struct mptsas_target_reset_event *target_reset_list;
1112
	u8		id, channel;
1113

1114
	id = sas_event_data->TargetID;
1115
	channel = sas_event_data->Bus;
1116

1117
	vtarget = mptsas_find_vtarget(ioc, channel, id);
1118
	if (vtarget) {
1119
		mptsas_block_io_starget(vtarget->starget);
1120
		vtarget->deleted = 1; /* block IO */
1121
	}
1122

1123
	target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
1124
	    GFP_ATOMIC);
1125
	if (!target_reset_list) {
1126
		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
1127
			"%s, failed to allocate mem @%d..!!\n",
1128
			ioc->name, __func__, __LINE__));
1129
		return;
1130
	}
1131

1132
	memcpy(&target_reset_list->sas_event_data, sas_event_data,
1133
		sizeof(*sas_event_data));
1134
	list_add_tail(&target_reset_list->list, &hd->target_reset_list);
1135

1136
	target_reset_list->time_count = jiffies;
1137

1138
	if (mptsas_target_reset(ioc, channel, id)) {
1139
		target_reset_list->target_reset_issued = 1;
1140
	}
1141
}
1142

1143
/**
1144
 * mptsas_schedule_target_reset- send pending target reset
1145
 * @iocp: per adapter object
1146
 *
1147
 * This function will delete scheduled target reset from the list and
1148
 * try to send next target reset. This will be called from completion
1149
 * context of any Task management command.
1150
 */
1151

1152
void
1153
mptsas_schedule_target_reset(void *iocp)
1154
{
1155
	MPT_ADAPTER *ioc = (MPT_ADAPTER *)(iocp);
1156
	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
1157
	struct list_head *head = &hd->target_reset_list;
1158
	struct mptsas_target_reset_event	*target_reset_list;
1159
	u8		id, channel;
1160
	/*
1161
	 * issue target reset to next device in the queue
1162
	 */
1163

1164
	head = &hd->target_reset_list;
1165
	if (list_empty(head))
1166
		return;
1167

1168
	target_reset_list = list_entry(head->next,
1169
		struct mptsas_target_reset_event, list);
1170

1171
	id = target_reset_list->sas_event_data.TargetID;
1172
	channel = target_reset_list->sas_event_data.Bus;
1173
	target_reset_list->time_count = jiffies;
1174

1175
	if (mptsas_target_reset(ioc, channel, id))
1176
		target_reset_list->target_reset_issued = 1;
1177
	return;
1178
}
1179

1180

1181
/**
1182
 *	mptsas_taskmgmt_complete - complete SAS task management function
1183
 *	@ioc: Pointer to MPT_ADAPTER structure
1184
 *
1185
 *	Completion for TARGET_RESET after NOT_RESPONDING_EVENT, enable work
1186
 *	queue to finish off removing device from upper layers. then send next
1187
 *	TARGET_RESET in the queue.
1188
 **/
1189
static int
1190
mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
1191
{
1192
	MPT_SCSI_HOST	*hd = shost_priv(ioc->sh);
1193
        struct list_head *head = &hd->target_reset_list;
1194
	u8		id, channel;
1195
	struct mptsas_target_reset_event	*target_reset_list;
1196
	SCSITaskMgmtReply_t *pScsiTmReply;
1197

1198
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
1199
	    "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
1200

1201
	pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
1202
	if (pScsiTmReply) {
1203
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1204
		    "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
1205
		    "\ttask_type = 0x%02X, iocstatus = 0x%04X "
1206
		    "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
1207
		    "term_cmnds = %d\n", ioc->name,
1208
		    pScsiTmReply->Bus, pScsiTmReply->TargetID,
1209
		    pScsiTmReply->TaskType,
1210
		    le16_to_cpu(pScsiTmReply->IOCStatus),
1211
		    le32_to_cpu(pScsiTmReply->IOCLogInfo),
1212
		    pScsiTmReply->ResponseCode,
1213
		    le32_to_cpu(pScsiTmReply->TerminationCount)));
1214

1215
		if (pScsiTmReply->ResponseCode)
1216
			mptscsih_taskmgmt_response_code(ioc,
1217
			pScsiTmReply->ResponseCode);
1218
	}
1219

1220
	if (pScsiTmReply && (pScsiTmReply->TaskType ==
1221
	    MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
1222
	     MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET)) {
1223
		ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
1224
		ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
1225
		memcpy(ioc->taskmgmt_cmds.reply, mr,
1226
		    min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
1227
		if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
1228
			ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
1229
			complete(&ioc->taskmgmt_cmds.done);
1230
			return 1;
1231
		}
1232
		return 0;
1233
	}
1234

1235
	mpt_clear_taskmgmt_in_progress_flag(ioc);
1236

1237
	if (list_empty(head))
1238
		return 1;
1239

1240
	target_reset_list = list_entry(head->next,
1241
	    struct mptsas_target_reset_event, list);
1242

1243
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1244
	    "TaskMgmt: completed (%d seconds)\n",
1245
	    ioc->name, jiffies_to_msecs(jiffies -
1246
	    target_reset_list->time_count)/1000));
1247

1248
	id = pScsiTmReply->TargetID;
1249
	channel = pScsiTmReply->Bus;
1250
	target_reset_list->time_count = jiffies;
1251

1252
	/*
1253
	 * retry target reset
1254
	 */
1255
	if (!target_reset_list->target_reset_issued) {
1256
		if (mptsas_target_reset(ioc, channel, id))
1257
			target_reset_list->target_reset_issued = 1;
1258
		return 1;
1259
	}
1260

1261
	/*
1262
	 * enable work queue to remove device from upper layers
1263
	 */
1264
	list_del(&target_reset_list->list);
1265
	if (!ioc->fw_events_off)
1266
		mptsas_queue_device_delete(ioc,
1267
			&target_reset_list->sas_event_data);
1268

1269

1270
	ioc->schedule_target_reset(ioc);
1271

1272
	return 1;
1273
}
1274

1275
/**
1276
 * mptscsih_ioc_reset
1277
 *
1278
 * @ioc
1279
 * @reset_phase
1280
 *
1281
 **/
1282
static int
1283
mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1284
{
1285
	MPT_SCSI_HOST	*hd;
1286
	int rc;
1287

1288
	rc = mptscsih_ioc_reset(ioc, reset_phase);
1289
	if ((ioc->bus_type != SAS) || (!rc))
1290
		return rc;
1291

1292
	hd = shost_priv(ioc->sh);
1293
	if (!hd->ioc)
1294
		goto out;
1295

1296
	switch (reset_phase) {
1297
	case MPT_IOC_SETUP_RESET:
1298
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1299
		    "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__));
1300
		mptsas_fw_event_off(ioc);
1301
		break;
1302
	case MPT_IOC_PRE_RESET:
1303
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1304
		    "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__));
1305
		break;
1306
	case MPT_IOC_POST_RESET:
1307
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1308
		    "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__));
1309
		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
1310
			ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
1311
			complete(&ioc->sas_mgmt.done);
1312
		}
1313
		mptsas_cleanup_fw_event_q(ioc);
1314
		mptsas_queue_rescan(ioc);
1315
		break;
1316
	default:
1317
		break;
1318
	}
1319

1320
 out:
1321
	return rc;
1322
}
1323

1324

1325
/**
1326
 * enum device_state -
1327
 * @DEVICE_RETRY: need to retry the TUR
1328
 * @DEVICE_ERROR: TUR return error, don't add device
1329
 * @DEVICE_READY: device can be added
1330
 *
1331
 */
1332
enum device_state{
1333
	DEVICE_RETRY,
1334
	DEVICE_ERROR,
1335
	DEVICE_READY,
1336
};
1337

1338
static int
1339
mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
1340
		u32 form, u32 form_specific)
1341
{
1342
	ConfigExtendedPageHeader_t hdr;
1343
	CONFIGPARMS cfg;
1344
	SasEnclosurePage0_t *buffer;
1345
	dma_addr_t dma_handle;
1346
	int error;
1347
	__le64 le_identifier;
1348

1349
	memset(&hdr, 0, sizeof(hdr));
1350
	hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
1351
	hdr.PageNumber = 0;
1352
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1353
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
1354

1355
	cfg.cfghdr.ehdr = &hdr;
1356
	cfg.physAddr = -1;
1357
	cfg.pageAddr = form + form_specific;
1358
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1359
	cfg.dir = 0;	/* read */
1360
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
1361

1362
	error = mpt_config(ioc, &cfg);
1363
	if (error)
1364
		goto out;
1365
	if (!hdr.ExtPageLength) {
1366
		error = -ENXIO;
1367
		goto out;
1368
	}
1369

1370
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1371
			&dma_handle);
1372
	if (!buffer) {
1373
		error = -ENOMEM;
1374
		goto out;
1375
	}
1376

1377
	cfg.physAddr = dma_handle;
1378
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1379

1380
	error = mpt_config(ioc, &cfg);
1381
	if (error)
1382
		goto out_free_consistent;
1383

1384
	/* save config data */
1385
	memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
1386
	enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
1387
	enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
1388
	enclosure->flags = le16_to_cpu(buffer->Flags);
1389
	enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
1390
	enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
1391
	enclosure->start_id = buffer->StartTargetID;
1392
	enclosure->start_channel = buffer->StartBus;
1393
	enclosure->sep_id = buffer->SEPTargetID;
1394
	enclosure->sep_channel = buffer->SEPBus;
1395

1396
 out_free_consistent:
1397
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1398
			    buffer, dma_handle);
1399
 out:
1400
	return error;
1401
}
1402

1403
/**
1404
 *	mptsas_add_end_device - report a new end device to sas transport layer
1405
 *	@ioc: Pointer to MPT_ADAPTER structure
1406
 *	@phy_info: describes attached device
1407
 *
1408
 *	return (0) success (1) failure
1409
 *
1410
 **/
1411
static int
1412
mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1413
{
1414
	struct sas_rphy *rphy;
1415
	struct sas_port *port;
1416
	struct sas_identify identify;
1417
	char *ds = NULL;
1418
	u8 fw_id;
1419

1420
	if (!phy_info) {
1421
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1422
			"%s: exit at line=%d\n", ioc->name,
1423
			 __func__, __LINE__));
1424
		return 1;
1425
	}
1426

1427
	fw_id = phy_info->attached.id;
1428

1429
	if (mptsas_get_rphy(phy_info)) {
1430
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1431
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1432
			 __func__, fw_id, __LINE__));
1433
		return 2;
1434
	}
1435

1436
	port = mptsas_get_port(phy_info);
1437
	if (!port) {
1438
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1439
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1440
			 __func__, fw_id, __LINE__));
1441
		return 3;
1442
	}
1443

1444
	if (phy_info->attached.device_info &
1445
	    MPI_SAS_DEVICE_INFO_SSP_TARGET)
1446
		ds = "ssp";
1447
	if (phy_info->attached.device_info &
1448
	    MPI_SAS_DEVICE_INFO_STP_TARGET)
1449
		ds = "stp";
1450
	if (phy_info->attached.device_info &
1451
	    MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1452
		ds = "sata";
1453

1454
	printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
1455
	    " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
1456
	    phy_info->attached.channel, phy_info->attached.id,
1457
	    phy_info->attached.phy_id, (unsigned long long)
1458
	    phy_info->attached.sas_address);
1459

1460
	mptsas_parse_device_info(&identify, &phy_info->attached);
1461
	rphy = sas_end_device_alloc(port);
1462
	if (!rphy) {
1463
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1464
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1465
			 __func__, fw_id, __LINE__));
1466
		return 5; /* non-fatal: an rphy can be added later */
1467
	}
1468

1469
	rphy->identify = identify;
1470
	if (sas_rphy_add(rphy)) {
1471
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1472
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1473
			 __func__, fw_id, __LINE__));
1474
		sas_rphy_free(rphy);
1475
		return 6;
1476
	}
1477
	mptsas_set_rphy(ioc, phy_info, rphy);
1478
	return 0;
1479
}
1480

1481
/**
1482
 *	mptsas_del_end_device - report a deleted end device to sas transport layer
1483
 *	@ioc: Pointer to MPT_ADAPTER structure
1484
 *	@phy_info: describes attached device
1485
 *
1486
 **/
1487
static void
1488
mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
1489
{
1490
	struct sas_rphy *rphy;
1491
	struct sas_port *port;
1492
	struct mptsas_portinfo *port_info;
1493
	struct mptsas_phyinfo *phy_info_parent;
1494
	int i;
1495
	char *ds = NULL;
1496
	u8 fw_id;
1497
	u64 sas_address;
1498

1499
	if (!phy_info)
1500
		return;
1501

1502
	fw_id = phy_info->attached.id;
1503
	sas_address = phy_info->attached.sas_address;
1504

1505
	if (!phy_info->port_details) {
1506
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1507
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1508
			 __func__, fw_id, __LINE__));
1509
		return;
1510
	}
1511
	rphy = mptsas_get_rphy(phy_info);
1512
	if (!rphy) {
1513
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1514
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1515
			 __func__, fw_id, __LINE__));
1516
		return;
1517
	}
1518

1519
	if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_INITIATOR
1520
		|| phy_info->attached.device_info
1521
			& MPI_SAS_DEVICE_INFO_SMP_INITIATOR
1522
		|| phy_info->attached.device_info
1523
			& MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1524
		ds = "initiator";
1525
	if (phy_info->attached.device_info &
1526
	    MPI_SAS_DEVICE_INFO_SSP_TARGET)
1527
		ds = "ssp";
1528
	if (phy_info->attached.device_info &
1529
	    MPI_SAS_DEVICE_INFO_STP_TARGET)
1530
		ds = "stp";
1531
	if (phy_info->attached.device_info &
1532
	    MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1533
		ds = "sata";
1534

1535
	dev_printk(KERN_DEBUG, &rphy->dev, MYIOC_s_FMT
1536
	    "removing %s device: fw_channel %d, fw_id %d, phy %d,"
1537
	    "sas_addr 0x%llx\n", ioc->name, ds, phy_info->attached.channel,
1538
	    phy_info->attached.id, phy_info->attached.phy_id,
1539
	    (unsigned long long) sas_address);
1540

1541
	port = mptsas_get_port(phy_info);
1542
	if (!port) {
1543
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
1544
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
1545
			 __func__, fw_id, __LINE__));
1546
		return;
1547
	}
1548
	port_info = phy_info->portinfo;
1549
	phy_info_parent = port_info->phy_info;
1550
	for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
1551
		if (!phy_info_parent->phy)
1552
			continue;
1553
		if (phy_info_parent->attached.sas_address !=
1554
		    sas_address)
1555
			continue;
1556
		dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
1557
		    MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
1558
		    ioc->name, phy_info_parent->phy_id,
1559
		    phy_info_parent->phy);
1560
		sas_port_delete_phy(port, phy_info_parent->phy);
1561
	}
1562

1563
	dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
1564
	    "delete port %d, sas_addr (0x%llx)\n", ioc->name,
1565
	     port->port_identifier, (unsigned long long)sas_address);
1566
	sas_port_delete(port);
1567
	mptsas_set_port(ioc, phy_info, NULL);
1568
	mptsas_port_delete(ioc, phy_info->port_details);
1569
}
1570

1571
struct mptsas_phyinfo *
1572
mptsas_refreshing_device_handles(MPT_ADAPTER *ioc,
1573
	struct mptsas_devinfo *sas_device)
1574
{
1575
	struct mptsas_phyinfo *phy_info;
1576
	struct mptsas_portinfo *port_info;
1577
	int i;
1578

1579
	phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
1580
	    sas_device->sas_address);
1581
	if (!phy_info)
1582
		goto out;
1583
	port_info = phy_info->portinfo;
1584
	if (!port_info)
1585
		goto out;
1586
	mutex_lock(&ioc->sas_topology_mutex);
1587
	for (i = 0; i < port_info->num_phys; i++) {
1588
		if (port_info->phy_info[i].attached.sas_address !=
1589
			sas_device->sas_address)
1590
			continue;
1591
		port_info->phy_info[i].attached.channel = sas_device->channel;
1592
		port_info->phy_info[i].attached.id = sas_device->id;
1593
		port_info->phy_info[i].attached.sas_address =
1594
		    sas_device->sas_address;
1595
		port_info->phy_info[i].attached.handle = sas_device->handle;
1596
		port_info->phy_info[i].attached.handle_parent =
1597
		    sas_device->handle_parent;
1598
		port_info->phy_info[i].attached.handle_enclosure =
1599
		    sas_device->handle_enclosure;
1600
	}
1601
	mutex_unlock(&ioc->sas_topology_mutex);
1602
 out:
1603
	return phy_info;
1604
}
1605

1606
/**
1607
 * mptsas_firmware_event_work - work thread for processing fw events
1608
 * @work: work queue payload containing info describing the event
1609
 * Context: user
1610
 *
1611
 */
1612
static void
1613
mptsas_firmware_event_work(struct work_struct *work)
1614
{
1615
	struct fw_event_work *fw_event =
1616
		container_of(work, struct fw_event_work, work.work);
1617
	MPT_ADAPTER *ioc = fw_event->ioc;
1618

1619
	/* special rescan topology handling */
1620
	if (fw_event->event == -1) {
1621
		if (ioc->in_rescan) {
1622
			devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1623
				"%s: rescan ignored as it is in progress\n",
1624
				ioc->name, __func__));
1625
			return;
1626
		}
1627
		devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rescan after "
1628
		    "reset\n", ioc->name, __func__));
1629
		ioc->in_rescan = 1;
1630
		mptsas_not_responding_devices(ioc);
1631
		mptsas_scan_sas_topology(ioc);
1632
		ioc->in_rescan = 0;
1633
		mptsas_free_fw_event(ioc, fw_event);
1634
		mptsas_fw_event_on(ioc);
1635
		return;
1636
	}
1637

1638
	/* events handling turned off during host reset */
1639
	if (ioc->fw_events_off) {
1640
		mptsas_free_fw_event(ioc, fw_event);
1641
		return;
1642
	}
1643

1644
	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_event=(0x%p), "
1645
	    "event = (0x%02x)\n", ioc->name, __func__, fw_event,
1646
	    (fw_event->event & 0xFF)));
1647

1648
	switch (fw_event->event) {
1649
	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
1650
		mptsas_send_sas_event(fw_event);
1651
		break;
1652
	case MPI_EVENT_INTEGRATED_RAID:
1653
		mptsas_send_raid_event(fw_event);
1654
		break;
1655
	case MPI_EVENT_IR2:
1656
		mptsas_send_ir2_event(fw_event);
1657
		break;
1658
	case MPI_EVENT_PERSISTENT_TABLE_FULL:
1659
		mptbase_sas_persist_operation(ioc,
1660
		    MPI_SAS_OP_CLEAR_NOT_PRESENT);
1661
		mptsas_free_fw_event(ioc, fw_event);
1662
		break;
1663
	case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
1664
		mptsas_broadcast_primative_work(fw_event);
1665
		break;
1666
	case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
1667
		mptsas_send_expander_event(fw_event);
1668
		break;
1669
	case MPI_EVENT_SAS_PHY_LINK_STATUS:
1670
		mptsas_send_link_status_event(fw_event);
1671
		break;
1672
	case MPI_EVENT_QUEUE_FULL:
1673
		mptsas_handle_queue_full_event(fw_event);
1674
		break;
1675
	}
1676
}
1677

1678

1679

1680
static int
1681
mptsas_slave_configure(struct scsi_device *sdev)
1682
{
1683
	struct Scsi_Host	*host = sdev->host;
1684
	MPT_SCSI_HOST	*hd = shost_priv(host);
1685
	MPT_ADAPTER	*ioc = hd->ioc;
1686
	VirtDevice	*vdevice = sdev->hostdata;
1687

1688
	if (vdevice->vtarget->deleted) {
1689
		sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
1690
		vdevice->vtarget->deleted = 0;
1691
	}
1692

1693
	/*
1694
	 * RAID volumes placed beyond the last expected port.
1695
	 * Ignore sending sas mode pages in that case..
1696
	 */
1697
	if (sdev->channel == MPTSAS_RAID_CHANNEL) {
1698
		mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
1699
		goto out;
1700
	}
1701

1702
	sas_read_port_mode_page(sdev);
1703

1704
	mptsas_add_device_component_starget(ioc, scsi_target(sdev));
1705

1706
 out:
1707
	return mptscsih_slave_configure(sdev);
1708
}
1709

1710
static int
1711
mptsas_target_alloc(struct scsi_target *starget)
1712
{
1713
	struct Scsi_Host *host = dev_to_shost(&starget->dev);
1714
	MPT_SCSI_HOST		*hd = shost_priv(host);
1715
	VirtTarget		*vtarget;
1716
	u8			id, channel;
1717
	struct sas_rphy		*rphy;
1718
	struct mptsas_portinfo	*p;
1719
	int 			 i;
1720
	MPT_ADAPTER		*ioc = hd->ioc;
1721

1722
	vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
1723
	if (!vtarget)
1724
		return -ENOMEM;
1725

1726
	vtarget->starget = starget;
1727
	vtarget->ioc_id = ioc->id;
1728
	vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
1729
	id = starget->id;
1730
	channel = 0;
1731

1732
	/*
1733
	 * RAID volumes placed beyond the last expected port.
1734
	 */
1735
	if (starget->channel == MPTSAS_RAID_CHANNEL) {
1736
		if (!ioc->raid_data.pIocPg2) {
1737
			kfree(vtarget);
1738
			return -ENXIO;
1739
		}
1740
		for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
1741
			if (id == ioc->raid_data.pIocPg2->
1742
					RaidVolume[i].VolumeID) {
1743
				channel = ioc->raid_data.pIocPg2->
1744
					RaidVolume[i].VolumeBus;
1745
			}
1746
		}
1747
		vtarget->raidVolume = 1;
1748
		goto out;
1749
	}
1750

1751
	rphy = dev_to_rphy(starget->dev.parent);
1752
	mutex_lock(&ioc->sas_topology_mutex);
1753
	list_for_each_entry(p, &ioc->sas_topology, list) {
1754
		for (i = 0; i < p->num_phys; i++) {
1755
			if (p->phy_info[i].attached.sas_address !=
1756
					rphy->identify.sas_address)
1757
				continue;
1758
			id = p->phy_info[i].attached.id;
1759
			channel = p->phy_info[i].attached.channel;
1760
			mptsas_set_starget(&p->phy_info[i], starget);
1761

1762
			/*
1763
			 * Exposing hidden raid components
1764
			 */
1765
			if (mptscsih_is_phys_disk(ioc, channel, id)) {
1766
				id = mptscsih_raid_id_to_num(ioc,
1767
						channel, id);
1768
				vtarget->tflags |=
1769
				    MPT_TARGET_FLAGS_RAID_COMPONENT;
1770
				p->phy_info[i].attached.phys_disk_num = id;
1771
			}
1772
			mutex_unlock(&ioc->sas_topology_mutex);
1773
			goto out;
1774
		}
1775
	}
1776
	mutex_unlock(&ioc->sas_topology_mutex);
1777

1778
	kfree(vtarget);
1779
	return -ENXIO;
1780

1781
 out:
1782
	vtarget->id = id;
1783
	vtarget->channel = channel;
1784
	starget->hostdata = vtarget;
1785
	return 0;
1786
}
1787

1788
static void
1789
mptsas_target_destroy(struct scsi_target *starget)
1790
{
1791
	struct Scsi_Host *host = dev_to_shost(&starget->dev);
1792
	MPT_SCSI_HOST		*hd = shost_priv(host);
1793
	struct sas_rphy		*rphy;
1794
	struct mptsas_portinfo	*p;
1795
	int 			 i;
1796
	MPT_ADAPTER	*ioc = hd->ioc;
1797
	VirtTarget	*vtarget;
1798

1799
	if (!starget->hostdata)
1800
		return;
1801

1802
	vtarget = starget->hostdata;
1803

1804
	mptsas_del_device_component_by_os(ioc, starget->channel,
1805
	    starget->id);
1806

1807

1808
	if (starget->channel == MPTSAS_RAID_CHANNEL)
1809
		goto out;
1810

1811
	rphy = dev_to_rphy(starget->dev.parent);
1812
	list_for_each_entry(p, &ioc->sas_topology, list) {
1813
		for (i = 0; i < p->num_phys; i++) {
1814
			if (p->phy_info[i].attached.sas_address !=
1815
					rphy->identify.sas_address)
1816
				continue;
1817

1818
			starget_printk(KERN_INFO, starget, MYIOC_s_FMT
1819
			"delete device: fw_channel %d, fw_id %d, phy %d, "
1820
			"sas_addr 0x%llx\n", ioc->name,
1821
			p->phy_info[i].attached.channel,
1822
			p->phy_info[i].attached.id,
1823
			p->phy_info[i].attached.phy_id, (unsigned long long)
1824
			p->phy_info[i].attached.sas_address);
1825

1826
			mptsas_set_starget(&p->phy_info[i], NULL);
1827
		}
1828
	}
1829

1830
 out:
1831
	vtarget->starget = NULL;
1832
	kfree(starget->hostdata);
1833
	starget->hostdata = NULL;
1834
}
1835

1836

1837
static int
1838
mptsas_slave_alloc(struct scsi_device *sdev)
1839
{
1840
	struct Scsi_Host	*host = sdev->host;
1841
	MPT_SCSI_HOST		*hd = shost_priv(host);
1842
	struct sas_rphy		*rphy;
1843
	struct mptsas_portinfo	*p;
1844
	VirtDevice		*vdevice;
1845
	struct scsi_target 	*starget;
1846
	int 			i;
1847
	MPT_ADAPTER *ioc = hd->ioc;
1848

1849
	vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
1850
	if (!vdevice) {
1851
		printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
1852
				ioc->name, sizeof(VirtDevice));
1853
		return -ENOMEM;
1854
	}
1855
	starget = scsi_target(sdev);
1856
	vdevice->vtarget = starget->hostdata;
1857

1858
	if (sdev->channel == MPTSAS_RAID_CHANNEL)
1859
		goto out;
1860

1861
	rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1862
	mutex_lock(&ioc->sas_topology_mutex);
1863
	list_for_each_entry(p, &ioc->sas_topology, list) {
1864
		for (i = 0; i < p->num_phys; i++) {
1865
			if (p->phy_info[i].attached.sas_address !=
1866
					rphy->identify.sas_address)
1867
				continue;
1868
			vdevice->lun = sdev->lun;
1869
			/*
1870
			 * Exposing hidden raid components
1871
			 */
1872
			if (mptscsih_is_phys_disk(ioc,
1873
			    p->phy_info[i].attached.channel,
1874
			    p->phy_info[i].attached.id))
1875
				sdev->no_uld_attach = 1;
1876
			mutex_unlock(&ioc->sas_topology_mutex);
1877
			goto out;
1878
		}
1879
	}
1880
	mutex_unlock(&ioc->sas_topology_mutex);
1881

1882
	kfree(vdevice);
1883
	return -ENXIO;
1884

1885
 out:
1886
	vdevice->vtarget->num_luns++;
1887
	sdev->hostdata = vdevice;
1888
	return 0;
1889
}
1890

1891
static int
1892
mptsas_qcmd_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1893
{
1894
	MPT_SCSI_HOST	*hd;
1895
	MPT_ADAPTER	*ioc;
1896
	VirtDevice	*vdevice = SCpnt->device->hostdata;
1897

1898
	if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
1899
		SCpnt->result = DID_NO_CONNECT << 16;
1900
		done(SCpnt);
1901
		return 0;
1902
	}
1903

1904
	hd = shost_priv(SCpnt->device->host);
1905
	ioc = hd->ioc;
1906

1907
	if (ioc->sas_discovery_quiesce_io)
1908
		return SCSI_MLQUEUE_HOST_BUSY;
1909

1910
	if (ioc->debug_level & MPT_DEBUG_SCSI)
1911
		scsi_print_command(SCpnt);
1912

1913
	return mptscsih_qcmd(SCpnt,done);
1914
}
1915

1916
static DEF_SCSI_QCMD(mptsas_qcmd)
1917

1918
/**
1919
 *	mptsas_mptsas_eh_timed_out - resets the scsi_cmnd timeout
1920
 *		if the device under question is currently in the
1921
 *		device removal delay.
1922
 *	@sc: scsi command that the midlayer is about to time out
1923
 *
1924
 **/
1925
static enum blk_eh_timer_return mptsas_eh_timed_out(struct scsi_cmnd *sc)
1926
{
1927
	MPT_SCSI_HOST *hd;
1928
	MPT_ADAPTER   *ioc;
1929
	VirtDevice    *vdevice;
1930
	enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1931

1932
	hd = shost_priv(sc->device->host);
1933
	if (hd == NULL) {
1934
		printk(KERN_ERR MYNAM ": %s: Can't locate host! (sc=%p)\n",
1935
		    __func__, sc);
1936
		goto done;
1937
	}
1938

1939
	ioc = hd->ioc;
1940
	if (ioc->bus_type != SAS) {
1941
		printk(KERN_ERR MYNAM ": %s: Wrong bus type (sc=%p)\n",
1942
		    __func__, sc);
1943
		goto done;
1944
	}
1945

1946
	vdevice = sc->device->hostdata;
1947
	if (vdevice && vdevice->vtarget && (vdevice->vtarget->inDMD
1948
		|| vdevice->vtarget->deleted)) {
1949
		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT ": %s: target removed "
1950
		    "or in device removal delay (sc=%p)\n",
1951
		    ioc->name, __func__, sc));
1952
		rc = BLK_EH_RESET_TIMER;
1953
		goto done;
1954
	}
1955

1956
done:
1957
	return rc;
1958
}
1959

1960

1961
static struct scsi_host_template mptsas_driver_template = {
1962
	.module				= THIS_MODULE,
1963
	.proc_name			= "mptsas",
1964
	.proc_info			= mptscsih_proc_info,
1965
	.name				= "MPT SAS Host",
1966
	.info				= mptscsih_info,
1967
	.queuecommand			= mptsas_qcmd,
1968
	.target_alloc			= mptsas_target_alloc,
1969
	.slave_alloc			= mptsas_slave_alloc,
1970
	.slave_configure		= mptsas_slave_configure,
1971
	.target_destroy			= mptsas_target_destroy,
1972
	.slave_destroy			= mptscsih_slave_destroy,
1973
	.change_queue_depth 		= mptscsih_change_queue_depth,
1974
	.eh_abort_handler		= mptscsih_abort,
1975
	.eh_device_reset_handler	= mptscsih_dev_reset,
1976
	.eh_host_reset_handler		= mptscsih_host_reset,
1977
	.bios_param			= mptscsih_bios_param,
1978
	.can_queue			= MPT_SAS_CAN_QUEUE,
1979
	.this_id			= -1,
1980
	.sg_tablesize			= MPT_SCSI_SG_DEPTH,
1981
	.max_sectors			= 8192,
1982
	.cmd_per_lun			= 7,
1983
	.use_clustering			= ENABLE_CLUSTERING,
1984
	.shost_attrs			= mptscsih_host_attrs,
1985
};
1986

1987
static int mptsas_get_linkerrors(struct sas_phy *phy)
1988
{
1989
	MPT_ADAPTER *ioc = phy_to_ioc(phy);
1990
	ConfigExtendedPageHeader_t hdr;
1991
	CONFIGPARMS cfg;
1992
	SasPhyPage1_t *buffer;
1993
	dma_addr_t dma_handle;
1994
	int error;
1995

1996
	/* FIXME: only have link errors on local phys */
1997
	if (!scsi_is_sas_phy_local(phy))
1998
		return -EINVAL;
1999

2000
	hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
2001
	hdr.ExtPageLength = 0;
2002
	hdr.PageNumber = 1 /* page number 1*/;
2003
	hdr.Reserved1 = 0;
2004
	hdr.Reserved2 = 0;
2005
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2006
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2007

2008
	cfg.cfghdr.ehdr = &hdr;
2009
	cfg.physAddr = -1;
2010
	cfg.pageAddr = phy->identify.phy_identifier;
2011
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2012
	cfg.dir = 0;    /* read */
2013
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2014

2015
	error = mpt_config(ioc, &cfg);
2016
	if (error)
2017
		return error;
2018
	if (!hdr.ExtPageLength)
2019
		return -ENXIO;
2020

2021
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2022
				      &dma_handle);
2023
	if (!buffer)
2024
		return -ENOMEM;
2025

2026
	cfg.physAddr = dma_handle;
2027
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2028

2029
	error = mpt_config(ioc, &cfg);
2030
	if (error)
2031
		goto out_free_consistent;
2032

2033
	mptsas_print_phy_pg1(ioc, buffer);
2034

2035
	phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
2036
	phy->running_disparity_error_count =
2037
		le32_to_cpu(buffer->RunningDisparityErrorCount);
2038
	phy->loss_of_dword_sync_count =
2039
		le32_to_cpu(buffer->LossDwordSynchCount);
2040
	phy->phy_reset_problem_count =
2041
		le32_to_cpu(buffer->PhyResetProblemCount);
2042

2043
 out_free_consistent:
2044
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2045
			    buffer, dma_handle);
2046
	return error;
2047
}
2048

2049
static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
2050
		MPT_FRAME_HDR *reply)
2051
{
2052
	ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
2053
	if (reply != NULL) {
2054
		ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID;
2055
		memcpy(ioc->sas_mgmt.reply, reply,
2056
		    min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
2057
	}
2058

2059
	if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
2060
		ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING;
2061
		complete(&ioc->sas_mgmt.done);
2062
		return 1;
2063
	}
2064
	return 0;
2065
}
2066

2067
static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
2068
{
2069
	MPT_ADAPTER *ioc = phy_to_ioc(phy);
2070
	SasIoUnitControlRequest_t *req;
2071
	SasIoUnitControlReply_t *reply;
2072
	MPT_FRAME_HDR *mf;
2073
	MPIHeader_t *hdr;
2074
	unsigned long timeleft;
2075
	int error = -ERESTARTSYS;
2076

2077
	/* FIXME: fusion doesn't allow non-local phy reset */
2078
	if (!scsi_is_sas_phy_local(phy))
2079
		return -EINVAL;
2080

2081
	/* not implemented for expanders */
2082
	if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
2083
		return -ENXIO;
2084

2085
	if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
2086
		goto out;
2087

2088
	mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2089
	if (!mf) {
2090
		error = -ENOMEM;
2091
		goto out_unlock;
2092
	}
2093

2094
	hdr = (MPIHeader_t *) mf;
2095
	req = (SasIoUnitControlRequest_t *)mf;
2096
	memset(req, 0, sizeof(SasIoUnitControlRequest_t));
2097
	req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
2098
	req->MsgContext = hdr->MsgContext;
2099
	req->Operation = hard_reset ?
2100
		MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
2101
	req->PhyNum = phy->identify.phy_identifier;
2102

2103
	INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2104
	mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2105

2106
	timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
2107
			10 * HZ);
2108
	if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2109
		error = -ETIME;
2110
		mpt_free_msg_frame(ioc, mf);
2111
		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2112
			goto out_unlock;
2113
		if (!timeleft)
2114
			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2115
		goto out_unlock;
2116
	}
2117

2118
	/* a reply frame is expected */
2119
	if ((ioc->sas_mgmt.status &
2120
	    MPT_MGMT_STATUS_RF_VALID) == 0) {
2121
		error = -ENXIO;
2122
		goto out_unlock;
2123
	}
2124

2125
	/* process the completed Reply Message Frame */
2126
	reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
2127
	if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
2128
		printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
2129
		    ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
2130
		error = -ENXIO;
2131
		goto out_unlock;
2132
	}
2133

2134
	error = 0;
2135

2136
 out_unlock:
2137
	CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2138
	mutex_unlock(&ioc->sas_mgmt.mutex);
2139
 out:
2140
	return error;
2141
}
2142

2143
static int
2144
mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
2145
{
2146
	MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2147
	int i, error;
2148
	struct mptsas_portinfo *p;
2149
	struct mptsas_enclosure enclosure_info;
2150
	u64 enclosure_handle;
2151

2152
	mutex_lock(&ioc->sas_topology_mutex);
2153
	list_for_each_entry(p, &ioc->sas_topology, list) {
2154
		for (i = 0; i < p->num_phys; i++) {
2155
			if (p->phy_info[i].attached.sas_address ==
2156
			    rphy->identify.sas_address) {
2157
				enclosure_handle = p->phy_info[i].
2158
					attached.handle_enclosure;
2159
				goto found_info;
2160
			}
2161
		}
2162
	}
2163
	mutex_unlock(&ioc->sas_topology_mutex);
2164
	return -ENXIO;
2165

2166
 found_info:
2167
	mutex_unlock(&ioc->sas_topology_mutex);
2168
	memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
2169
	error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
2170
			(MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
2171
			 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
2172
	if (!error)
2173
		*identifier = enclosure_info.enclosure_logical_id;
2174
	return error;
2175
}
2176

2177
static int
2178
mptsas_get_bay_identifier(struct sas_rphy *rphy)
2179
{
2180
	MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
2181
	struct mptsas_portinfo *p;
2182
	int i, rc;
2183

2184
	mutex_lock(&ioc->sas_topology_mutex);
2185
	list_for_each_entry(p, &ioc->sas_topology, list) {
2186
		for (i = 0; i < p->num_phys; i++) {
2187
			if (p->phy_info[i].attached.sas_address ==
2188
			    rphy->identify.sas_address) {
2189
				rc = p->phy_info[i].attached.slot;
2190
				goto out;
2191
			}
2192
		}
2193
	}
2194
	rc = -ENXIO;
2195
 out:
2196
	mutex_unlock(&ioc->sas_topology_mutex);
2197
	return rc;
2198
}
2199

2200
static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
2201
			      struct request *req)
2202
{
2203
	MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
2204
	MPT_FRAME_HDR *mf;
2205
	SmpPassthroughRequest_t *smpreq;
2206
	struct request *rsp = req->next_rq;
2207
	int ret;
2208
	int flagsLength;
2209
	unsigned long timeleft;
2210
	char *psge;
2211
	dma_addr_t dma_addr_in = 0;
2212
	dma_addr_t dma_addr_out = 0;
2213
	u64 sas_address = 0;
2214

2215
	if (!rsp) {
2216
		printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n",
2217
		    ioc->name, __func__);
2218
		return -EINVAL;
2219
	}
2220

2221
	/* do we need to support multiple segments? */
2222
	if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
2223
		printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
2224
		    ioc->name, __func__, req->bio->bi_vcnt, blk_rq_bytes(req),
2225
		    rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
2226
		return -EINVAL;
2227
	}
2228

2229
	ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2230
	if (ret)
2231
		goto out;
2232

2233
	mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2234
	if (!mf) {
2235
		ret = -ENOMEM;
2236
		goto out_unlock;
2237
	}
2238

2239
	smpreq = (SmpPassthroughRequest_t *)mf;
2240
	memset(smpreq, 0, sizeof(*smpreq));
2241

2242
	smpreq->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
2243
	smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2244

2245
	if (rphy)
2246
		sas_address = rphy->identify.sas_address;
2247
	else {
2248
		struct mptsas_portinfo *port_info;
2249

2250
		mutex_lock(&ioc->sas_topology_mutex);
2251
		port_info = ioc->hba_port_info;
2252
		if (port_info && port_info->phy_info)
2253
			sas_address =
2254
				port_info->phy_info[0].phy->identify.sas_address;
2255
		mutex_unlock(&ioc->sas_topology_mutex);
2256
	}
2257

2258
	*((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2259

2260
	psge = (char *)
2261
		(((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2262

2263
	/* request */
2264
	flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2265
		       MPI_SGE_FLAGS_END_OF_BUFFER |
2266
		       MPI_SGE_FLAGS_DIRECTION)
2267
		       << MPI_SGE_FLAGS_SHIFT;
2268
	flagsLength |= (blk_rq_bytes(req) - 4);
2269

2270
	dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
2271
				      blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
2272
	if (!dma_addr_out)
2273
		goto put_mf;
2274
	ioc->add_sge(psge, flagsLength, dma_addr_out);
2275
	psge += ioc->SGE_size;
2276

2277
	/* response */
2278
	flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2279
		MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2280
		MPI_SGE_FLAGS_IOC_TO_HOST |
2281
		MPI_SGE_FLAGS_END_OF_BUFFER;
2282

2283
	flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2284
	flagsLength |= blk_rq_bytes(rsp) + 4;
2285
	dma_addr_in =  pci_map_single(ioc->pcidev, bio_data(rsp->bio),
2286
				      blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
2287
	if (!dma_addr_in)
2288
		goto unmap;
2289
	ioc->add_sge(psge, flagsLength, dma_addr_in);
2290

2291
	INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2292
	mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2293

2294
	timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2295
	if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2296
		ret = -ETIME;
2297
		mpt_free_msg_frame(ioc, mf);
2298
		mf = NULL;
2299
		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2300
			goto unmap;
2301
		if (!timeleft)
2302
			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2303
		goto unmap;
2304
	}
2305
	mf = NULL;
2306

2307
	if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2308
		SmpPassthroughReply_t *smprep;
2309

2310
		smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2311
		memcpy(req->sense, smprep, sizeof(*smprep));
2312
		req->sense_len = sizeof(*smprep);
2313
		req->resid_len = 0;
2314
		rsp->resid_len -= smprep->ResponseDataLength;
2315
	} else {
2316
		printk(MYIOC_s_ERR_FMT
2317
		    "%s: smp passthru reply failed to be returned\n",
2318
		    ioc->name, __func__);
2319
		ret = -ENXIO;
2320
	}
2321
unmap:
2322
	if (dma_addr_out)
2323
		pci_unmap_single(ioc->pcidev, dma_addr_out, blk_rq_bytes(req),
2324
				 PCI_DMA_BIDIRECTIONAL);
2325
	if (dma_addr_in)
2326
		pci_unmap_single(ioc->pcidev, dma_addr_in, blk_rq_bytes(rsp),
2327
				 PCI_DMA_BIDIRECTIONAL);
2328
put_mf:
2329
	if (mf)
2330
		mpt_free_msg_frame(ioc, mf);
2331
out_unlock:
2332
	CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2333
	mutex_unlock(&ioc->sas_mgmt.mutex);
2334
out:
2335
	return ret;
2336
}
2337

2338
static struct sas_function_template mptsas_transport_functions = {
2339
	.get_linkerrors		= mptsas_get_linkerrors,
2340
	.get_enclosure_identifier = mptsas_get_enclosure_identifier,
2341
	.get_bay_identifier	= mptsas_get_bay_identifier,
2342
	.phy_reset		= mptsas_phy_reset,
2343
	.smp_handler		= mptsas_smp_handler,
2344
};
2345

2346
static struct scsi_transport_template *mptsas_transport_template;
2347

2348
static int
2349
mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
2350
{
2351
	ConfigExtendedPageHeader_t hdr;
2352
	CONFIGPARMS cfg;
2353
	SasIOUnitPage0_t *buffer;
2354
	dma_addr_t dma_handle;
2355
	int error, i;
2356

2357
	hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
2358
	hdr.ExtPageLength = 0;
2359
	hdr.PageNumber = 0;
2360
	hdr.Reserved1 = 0;
2361
	hdr.Reserved2 = 0;
2362
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2363
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2364

2365
	cfg.cfghdr.ehdr = &hdr;
2366
	cfg.physAddr = -1;
2367
	cfg.pageAddr = 0;
2368
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2369
	cfg.dir = 0;	/* read */
2370
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2371

2372
	error = mpt_config(ioc, &cfg);
2373
	if (error)
2374
		goto out;
2375
	if (!hdr.ExtPageLength) {
2376
		error = -ENXIO;
2377
		goto out;
2378
	}
2379

2380
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2381
					    &dma_handle);
2382
	if (!buffer) {
2383
		error = -ENOMEM;
2384
		goto out;
2385
	}
2386

2387
	cfg.physAddr = dma_handle;
2388
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2389

2390
	error = mpt_config(ioc, &cfg);
2391
	if (error)
2392
		goto out_free_consistent;
2393

2394
	port_info->num_phys = buffer->NumPhys;
2395
	port_info->phy_info = kcalloc(port_info->num_phys,
2396
		sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2397
	if (!port_info->phy_info) {
2398
		error = -ENOMEM;
2399
		goto out_free_consistent;
2400
	}
2401

2402
	ioc->nvdata_version_persistent =
2403
	    le16_to_cpu(buffer->NvdataVersionPersistent);
2404
	ioc->nvdata_version_default =
2405
	    le16_to_cpu(buffer->NvdataVersionDefault);
2406

2407
	for (i = 0; i < port_info->num_phys; i++) {
2408
		mptsas_print_phy_data(ioc, &buffer->PhyData[i]);
2409
		port_info->phy_info[i].phy_id = i;
2410
		port_info->phy_info[i].port_id =
2411
		    buffer->PhyData[i].Port;
2412
		port_info->phy_info[i].negotiated_link_rate =
2413
		    buffer->PhyData[i].NegotiatedLinkRate;
2414
		port_info->phy_info[i].portinfo = port_info;
2415
		port_info->phy_info[i].handle =
2416
		    le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
2417
	}
2418

2419
 out_free_consistent:
2420
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2421
			    buffer, dma_handle);
2422
 out:
2423
	return error;
2424
}
2425

2426
static int
2427
mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
2428
{
2429
	ConfigExtendedPageHeader_t hdr;
2430
	CONFIGPARMS cfg;
2431
	SasIOUnitPage1_t *buffer;
2432
	dma_addr_t dma_handle;
2433
	int error;
2434
	u8 device_missing_delay;
2435

2436
	memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
2437
	memset(&cfg, 0, sizeof(CONFIGPARMS));
2438

2439
	cfg.cfghdr.ehdr = &hdr;
2440
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2441
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2442
	cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2443
	cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
2444
	cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
2445
	cfg.cfghdr.ehdr->PageNumber = 1;
2446

2447
	error = mpt_config(ioc, &cfg);
2448
	if (error)
2449
		goto out;
2450
	if (!hdr.ExtPageLength) {
2451
		error = -ENXIO;
2452
		goto out;
2453
	}
2454

2455
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2456
					    &dma_handle);
2457
	if (!buffer) {
2458
		error = -ENOMEM;
2459
		goto out;
2460
	}
2461

2462
	cfg.physAddr = dma_handle;
2463
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2464

2465
	error = mpt_config(ioc, &cfg);
2466
	if (error)
2467
		goto out_free_consistent;
2468

2469
	ioc->io_missing_delay  =
2470
	    le16_to_cpu(buffer->IODeviceMissingDelay);
2471
	device_missing_delay = buffer->ReportDeviceMissingDelay;
2472
	ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
2473
	    (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
2474
	    device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
2475

2476
 out_free_consistent:
2477
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2478
			    buffer, dma_handle);
2479
 out:
2480
	return error;
2481
}
2482

2483
static int
2484
mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2485
		u32 form, u32 form_specific)
2486
{
2487
	ConfigExtendedPageHeader_t hdr;
2488
	CONFIGPARMS cfg;
2489
	SasPhyPage0_t *buffer;
2490
	dma_addr_t dma_handle;
2491
	int error;
2492

2493
	hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
2494
	hdr.ExtPageLength = 0;
2495
	hdr.PageNumber = 0;
2496
	hdr.Reserved1 = 0;
2497
	hdr.Reserved2 = 0;
2498
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2499
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2500

2501
	cfg.cfghdr.ehdr = &hdr;
2502
	cfg.dir = 0;	/* read */
2503
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2504

2505
	/* Get Phy Pg 0 for each Phy. */
2506
	cfg.physAddr = -1;
2507
	cfg.pageAddr = form + form_specific;
2508
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2509

2510
	error = mpt_config(ioc, &cfg);
2511
	if (error)
2512
		goto out;
2513

2514
	if (!hdr.ExtPageLength) {
2515
		error = -ENXIO;
2516
		goto out;
2517
	}
2518

2519
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2520
				      &dma_handle);
2521
	if (!buffer) {
2522
		error = -ENOMEM;
2523
		goto out;
2524
	}
2525

2526
	cfg.physAddr = dma_handle;
2527
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2528

2529
	error = mpt_config(ioc, &cfg);
2530
	if (error)
2531
		goto out_free_consistent;
2532

2533
	mptsas_print_phy_pg0(ioc, buffer);
2534

2535
	phy_info->hw_link_rate = buffer->HwLinkRate;
2536
	phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2537
	phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2538
	phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2539

2540
 out_free_consistent:
2541
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2542
			    buffer, dma_handle);
2543
 out:
2544
	return error;
2545
}
2546

2547
static int
2548
mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
2549
		u32 form, u32 form_specific)
2550
{
2551
	ConfigExtendedPageHeader_t hdr;
2552
	CONFIGPARMS cfg;
2553
	SasDevicePage0_t *buffer;
2554
	dma_addr_t dma_handle;
2555
	__le64 sas_address;
2556
	int error=0;
2557

2558
	hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
2559
	hdr.ExtPageLength = 0;
2560
	hdr.PageNumber = 0;
2561
	hdr.Reserved1 = 0;
2562
	hdr.Reserved2 = 0;
2563
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2564
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
2565

2566
	cfg.cfghdr.ehdr = &hdr;
2567
	cfg.pageAddr = form + form_specific;
2568
	cfg.physAddr = -1;
2569
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2570
	cfg.dir = 0;	/* read */
2571
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2572

2573
	memset(device_info, 0, sizeof(struct mptsas_devinfo));
2574
	error = mpt_config(ioc, &cfg);
2575
	if (error)
2576
		goto out;
2577
	if (!hdr.ExtPageLength) {
2578
		error = -ENXIO;
2579
		goto out;
2580
	}
2581

2582
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2583
				      &dma_handle);
2584
	if (!buffer) {
2585
		error = -ENOMEM;
2586
		goto out;
2587
	}
2588

2589
	cfg.physAddr = dma_handle;
2590
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2591

2592
	error = mpt_config(ioc, &cfg);
2593

2594
	if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2595
		error = -ENODEV;
2596
		goto out_free_consistent;
2597
	}
2598

2599
	if (error)
2600
		goto out_free_consistent;
2601

2602
	mptsas_print_device_pg0(ioc, buffer);
2603

2604
	memset(device_info, 0, sizeof(struct mptsas_devinfo));
2605
	device_info->handle = le16_to_cpu(buffer->DevHandle);
2606
	device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
2607
	device_info->handle_enclosure =
2608
	    le16_to_cpu(buffer->EnclosureHandle);
2609
	device_info->slot = le16_to_cpu(buffer->Slot);
2610
	device_info->phy_id = buffer->PhyNum;
2611
	device_info->port_id = buffer->PhysicalPort;
2612
	device_info->id = buffer->TargetID;
2613
	device_info->phys_disk_num = ~0;
2614
	device_info->channel = buffer->Bus;
2615
	memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2616
	device_info->sas_address = le64_to_cpu(sas_address);
2617
	device_info->device_info =
2618
	    le32_to_cpu(buffer->DeviceInfo);
2619
	device_info->flags = le16_to_cpu(buffer->Flags);
2620

2621
 out_free_consistent:
2622
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2623
			    buffer, dma_handle);
2624
 out:
2625
	return error;
2626
}
2627

2628
static int
2629
mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
2630
		u32 form, u32 form_specific)
2631
{
2632
	ConfigExtendedPageHeader_t hdr;
2633
	CONFIGPARMS cfg;
2634
	SasExpanderPage0_t *buffer;
2635
	dma_addr_t dma_handle;
2636
	int i, error;
2637
	__le64 sas_address;
2638

2639
	memset(port_info, 0, sizeof(struct mptsas_portinfo));
2640
	hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
2641
	hdr.ExtPageLength = 0;
2642
	hdr.PageNumber = 0;
2643
	hdr.Reserved1 = 0;
2644
	hdr.Reserved2 = 0;
2645
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2646
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2647

2648
	cfg.cfghdr.ehdr = &hdr;
2649
	cfg.physAddr = -1;
2650
	cfg.pageAddr = form + form_specific;
2651
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2652
	cfg.dir = 0;	/* read */
2653
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2654

2655
	memset(port_info, 0, sizeof(struct mptsas_portinfo));
2656
	error = mpt_config(ioc, &cfg);
2657
	if (error)
2658
		goto out;
2659

2660
	if (!hdr.ExtPageLength) {
2661
		error = -ENXIO;
2662
		goto out;
2663
	}
2664

2665
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2666
				      &dma_handle);
2667
	if (!buffer) {
2668
		error = -ENOMEM;
2669
		goto out;
2670
	}
2671

2672
	cfg.physAddr = dma_handle;
2673
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2674

2675
	error = mpt_config(ioc, &cfg);
2676
	if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2677
		error = -ENODEV;
2678
		goto out_free_consistent;
2679
	}
2680

2681
	if (error)
2682
		goto out_free_consistent;
2683

2684
	/* save config data */
2685
	port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
2686
	port_info->phy_info = kcalloc(port_info->num_phys,
2687
		sizeof(struct mptsas_phyinfo), GFP_KERNEL);
2688
	if (!port_info->phy_info) {
2689
		error = -ENOMEM;
2690
		goto out_free_consistent;
2691
	}
2692

2693
	memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
2694
	for (i = 0; i < port_info->num_phys; i++) {
2695
		port_info->phy_info[i].portinfo = port_info;
2696
		port_info->phy_info[i].handle =
2697
		    le16_to_cpu(buffer->DevHandle);
2698
		port_info->phy_info[i].identify.sas_address =
2699
		    le64_to_cpu(sas_address);
2700
		port_info->phy_info[i].identify.handle_parent =
2701
		    le16_to_cpu(buffer->ParentDevHandle);
2702
	}
2703

2704
 out_free_consistent:
2705
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2706
			    buffer, dma_handle);
2707
 out:
2708
	return error;
2709
}
2710

2711
static int
2712
mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
2713
		u32 form, u32 form_specific)
2714
{
2715
	ConfigExtendedPageHeader_t hdr;
2716
	CONFIGPARMS cfg;
2717
	SasExpanderPage1_t *buffer;
2718
	dma_addr_t dma_handle;
2719
	int error=0;
2720

2721
	hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
2722
	hdr.ExtPageLength = 0;
2723
	hdr.PageNumber = 1;
2724
	hdr.Reserved1 = 0;
2725
	hdr.Reserved2 = 0;
2726
	hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2727
	hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
2728

2729
	cfg.cfghdr.ehdr = &hdr;
2730
	cfg.physAddr = -1;
2731
	cfg.pageAddr = form + form_specific;
2732
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2733
	cfg.dir = 0;	/* read */
2734
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
2735

2736
	error = mpt_config(ioc, &cfg);
2737
	if (error)
2738
		goto out;
2739

2740
	if (!hdr.ExtPageLength) {
2741
		error = -ENXIO;
2742
		goto out;
2743
	}
2744

2745
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2746
				      &dma_handle);
2747
	if (!buffer) {
2748
		error = -ENOMEM;
2749
		goto out;
2750
	}
2751

2752
	cfg.physAddr = dma_handle;
2753
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2754

2755
	error = mpt_config(ioc, &cfg);
2756

2757
	if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
2758
		error = -ENODEV;
2759
		goto out_free_consistent;
2760
	}
2761

2762
	if (error)
2763
		goto out_free_consistent;
2764

2765

2766
	mptsas_print_expander_pg1(ioc, buffer);
2767

2768
	/* save config data */
2769
	phy_info->phy_id = buffer->PhyIdentifier;
2770
	phy_info->port_id = buffer->PhysicalPort;
2771
	phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
2772
	phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
2773
	phy_info->hw_link_rate = buffer->HwLinkRate;
2774
	phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
2775
	phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
2776

2777
 out_free_consistent:
2778
	pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
2779
			    buffer, dma_handle);
2780
 out:
2781
	return error;
2782
}
2783

2784
struct rep_manu_request{
2785
	u8 smp_frame_type;
2786
	u8 function;
2787
	u8 reserved;
2788
	u8 request_length;
2789
};
2790

2791
struct rep_manu_reply{
2792
	u8 smp_frame_type; /* 0x41 */
2793
	u8 function; /* 0x01 */
2794
	u8 function_result;
2795
	u8 response_length;
2796
	u16 expander_change_count;
2797
	u8 reserved0[2];
2798
	u8 sas_format:1;
2799
	u8 reserved1:7;
2800
	u8 reserved2[3];
2801
	u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
2802
	u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
2803
	u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
2804
	u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
2805
	u16 component_id;
2806
	u8 component_revision_id;
2807
	u8 reserved3;
2808
	u8 vendor_specific[8];
2809
};
2810

2811
/**
2812
  * mptsas_exp_repmanufacture_info -
2813
  * @ioc: per adapter object
2814
  * @sas_address: expander sas address
2815
  * @edev: the sas_expander_device object
2816
  *
2817
  * Fills in the sas_expander_device object when SMP port is created.
2818
  *
2819
  * Returns 0 for success, non-zero for failure.
2820
  */
2821
static int
2822
mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
2823
	u64 sas_address, struct sas_expander_device *edev)
2824
{
2825
	MPT_FRAME_HDR *mf;
2826
	SmpPassthroughRequest_t *smpreq;
2827
	SmpPassthroughReply_t *smprep;
2828
	struct rep_manu_reply *manufacture_reply;
2829
	struct rep_manu_request *manufacture_request;
2830
	int ret;
2831
	int flagsLength;
2832
	unsigned long timeleft;
2833
	char *psge;
2834
	unsigned long flags;
2835
	void *data_out = NULL;
2836
	dma_addr_t data_out_dma = 0;
2837
	u32 sz;
2838

2839
	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
2840
	if (ioc->ioc_reset_in_progress) {
2841
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2842
		printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
2843
			__func__, ioc->name);
2844
		return -EFAULT;
2845
	}
2846
	spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
2847

2848
	ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
2849
	if (ret)
2850
		goto out;
2851

2852
	mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
2853
	if (!mf) {
2854
		ret = -ENOMEM;
2855
		goto out_unlock;
2856
	}
2857

2858
	smpreq = (SmpPassthroughRequest_t *)mf;
2859
	memset(smpreq, 0, sizeof(*smpreq));
2860

2861
	sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
2862

2863
	data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma);
2864
	if (!data_out) {
2865
		printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
2866
			__FILE__, __LINE__, __func__);
2867
		ret = -ENOMEM;
2868
		goto put_mf;
2869
	}
2870

2871
	manufacture_request = data_out;
2872
	manufacture_request->smp_frame_type = 0x40;
2873
	manufacture_request->function = 1;
2874
	manufacture_request->reserved = 0;
2875
	manufacture_request->request_length = 0;
2876

2877
	smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2878
	smpreq->PhysicalPort = 0xFF;
2879
	*((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
2880
	smpreq->RequestDataLength = sizeof(struct rep_manu_request);
2881

2882
	psge = (char *)
2883
		(((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
2884

2885
	flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2886
		MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2887
		MPI_SGE_FLAGS_HOST_TO_IOC |
2888
		MPI_SGE_FLAGS_END_OF_BUFFER;
2889
	flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2890
	flagsLength |= sizeof(struct rep_manu_request);
2891

2892
	ioc->add_sge(psge, flagsLength, data_out_dma);
2893
	psge += ioc->SGE_size;
2894

2895
	flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2896
		MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2897
		MPI_SGE_FLAGS_IOC_TO_HOST |
2898
		MPI_SGE_FLAGS_END_OF_BUFFER;
2899
	flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2900
	flagsLength |= sizeof(struct rep_manu_reply);
2901
	ioc->add_sge(psge, flagsLength, data_out_dma +
2902
	sizeof(struct rep_manu_request));
2903

2904
	INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
2905
	mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
2906

2907
	timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
2908
	if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
2909
		ret = -ETIME;
2910
		mpt_free_msg_frame(ioc, mf);
2911
		mf = NULL;
2912
		if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
2913
			goto out_free;
2914
		if (!timeleft)
2915
			mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
2916
		goto out_free;
2917
	}
2918

2919
	mf = NULL;
2920

2921
	if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
2922
		u8 *tmp;
2923

2924
	smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
2925
	if (le16_to_cpu(smprep->ResponseDataLength) !=
2926
		sizeof(struct rep_manu_reply))
2927
			goto out_free;
2928

2929
	manufacture_reply = data_out + sizeof(struct rep_manu_request);
2930
	strncpy(edev->vendor_id, manufacture_reply->vendor_id,
2931
		SAS_EXPANDER_VENDOR_ID_LEN);
2932
	strncpy(edev->product_id, manufacture_reply->product_id,
2933
		SAS_EXPANDER_PRODUCT_ID_LEN);
2934
	strncpy(edev->product_rev, manufacture_reply->product_rev,
2935
		SAS_EXPANDER_PRODUCT_REV_LEN);
2936
	edev->level = manufacture_reply->sas_format;
2937
	if (manufacture_reply->sas_format) {
2938
		strncpy(edev->component_vendor_id,
2939
			manufacture_reply->component_vendor_id,
2940
				SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
2941
		tmp = (u8 *)&manufacture_reply->component_id;
2942
		edev->component_id = tmp[0] << 8 | tmp[1];
2943
		edev->component_revision_id =
2944
			manufacture_reply->component_revision_id;
2945
		}
2946
	} else {
2947
		printk(MYIOC_s_ERR_FMT
2948
			"%s: smp passthru reply failed to be returned\n",
2949
			ioc->name, __func__);
2950
		ret = -ENXIO;
2951
	}
2952
out_free:
2953
	if (data_out_dma)
2954
		pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma);
2955
put_mf:
2956
	if (mf)
2957
		mpt_free_msg_frame(ioc, mf);
2958
out_unlock:
2959
	CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
2960
	mutex_unlock(&ioc->sas_mgmt.mutex);
2961
out:
2962
	return ret;
2963
 }
2964

2965
static void
2966
mptsas_parse_device_info(struct sas_identify *identify,
2967
		struct mptsas_devinfo *device_info)
2968
{
2969
	u16 protocols;
2970

2971
	identify->sas_address = device_info->sas_address;
2972
	identify->phy_identifier = device_info->phy_id;
2973

2974
	/*
2975
	 * Fill in Phy Initiator Port Protocol.
2976
	 * Bits 6:3, more than one bit can be set, fall through cases.
2977
	 */
2978
	protocols = device_info->device_info & 0x78;
2979
	identify->initiator_port_protocols = 0;
2980
	if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
2981
		identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
2982
	if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
2983
		identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
2984
	if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
2985
		identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
2986
	if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
2987
		identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
2988

2989
	/*
2990
	 * Fill in Phy Target Port Protocol.
2991
	 * Bits 10:7, more than one bit can be set, fall through cases.
2992
	 */
2993
	protocols = device_info->device_info & 0x780;
2994
	identify->target_port_protocols = 0;
2995
	if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
2996
		identify->target_port_protocols |= SAS_PROTOCOL_SSP;
2997
	if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
2998
		identify->target_port_protocols |= SAS_PROTOCOL_STP;
2999
	if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
3000
		identify->target_port_protocols |= SAS_PROTOCOL_SMP;
3001
	if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
3002
		identify->target_port_protocols |= SAS_PROTOCOL_SATA;
3003

3004
	/*
3005
	 * Fill in Attached device type.
3006
	 */
3007
	switch (device_info->device_info &
3008
			MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
3009
	case MPI_SAS_DEVICE_INFO_NO_DEVICE:
3010
		identify->device_type = SAS_PHY_UNUSED;
3011
		break;
3012
	case MPI_SAS_DEVICE_INFO_END_DEVICE:
3013
		identify->device_type = SAS_END_DEVICE;
3014
		break;
3015
	case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
3016
		identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
3017
		break;
3018
	case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
3019
		identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
3020
		break;
3021
	}
3022
}
3023

3024
static int mptsas_probe_one_phy(struct device *dev,
3025
		struct mptsas_phyinfo *phy_info, int index, int local)
3026
{
3027
	MPT_ADAPTER *ioc;
3028
	struct sas_phy *phy;
3029
	struct sas_port *port;
3030
	int error = 0;
3031
	VirtTarget *vtarget;
3032

3033
	if (!dev) {
3034
		error = -ENODEV;
3035
		goto out;
3036
	}
3037

3038
	if (!phy_info->phy) {
3039
		phy = sas_phy_alloc(dev, index);
3040
		if (!phy) {
3041
			error = -ENOMEM;
3042
			goto out;
3043
		}
3044
	} else
3045
		phy = phy_info->phy;
3046

3047
	mptsas_parse_device_info(&phy->identify, &phy_info->identify);
3048

3049
	/*
3050
	 * Set Negotiated link rate.
3051
	 */
3052
	switch (phy_info->negotiated_link_rate) {
3053
	case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
3054
		phy->negotiated_linkrate = SAS_PHY_DISABLED;
3055
		break;
3056
	case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
3057
		phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
3058
		break;
3059
	case MPI_SAS_IOUNIT0_RATE_1_5:
3060
		phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
3061
		break;
3062
	case MPI_SAS_IOUNIT0_RATE_3_0:
3063
		phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
3064
		break;
3065
	case MPI_SAS_IOUNIT0_RATE_6_0:
3066
		phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS;
3067
		break;
3068
	case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
3069
	case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
3070
	default:
3071
		phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
3072
		break;
3073
	}
3074

3075
	/*
3076
	 * Set Max hardware link rate.
3077
	 */
3078
	switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3079
	case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
3080
		phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3081
		break;
3082
	case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3083
		phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3084
		break;
3085
	default:
3086
		break;
3087
	}
3088

3089
	/*
3090
	 * Set Max programmed link rate.
3091
	 */
3092
	switch (phy_info->programmed_link_rate &
3093
			MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
3094
	case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
3095
		phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3096
		break;
3097
	case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
3098
		phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3099
		break;
3100
	default:
3101
		break;
3102
	}
3103

3104
	/*
3105
	 * Set Min hardware link rate.
3106
	 */
3107
	switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
3108
	case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
3109
		phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
3110
		break;
3111
	case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3112
		phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
3113
		break;
3114
	default:
3115
		break;
3116
	}
3117

3118
	/*
3119
	 * Set Min programmed link rate.
3120
	 */
3121
	switch (phy_info->programmed_link_rate &
3122
			MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
3123
	case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
3124
		phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
3125
		break;
3126
	case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
3127
		phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
3128
		break;
3129
	default:
3130
		break;
3131
	}
3132

3133
	if (!phy_info->phy) {
3134

3135
		error = sas_phy_add(phy);
3136
		if (error) {
3137
			sas_phy_free(phy);
3138
			goto out;
3139
		}
3140
		phy_info->phy = phy;
3141
	}
3142

3143
	if (!phy_info->attached.handle ||
3144
			!phy_info->port_details)
3145
		goto out;
3146

3147
	port = mptsas_get_port(phy_info);
3148
	ioc = phy_to_ioc(phy_info->phy);
3149

3150
	if (phy_info->sas_port_add_phy) {
3151

3152
		if (!port) {
3153
			port = sas_port_alloc_num(dev);
3154
			if (!port) {
3155
				error = -ENOMEM;
3156
				goto out;
3157
			}
3158
			error = sas_port_add(port);
3159
			if (error) {
3160
				dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3161
					"%s: exit at line=%d\n", ioc->name,
3162
					__func__, __LINE__));
3163
				goto out;
3164
			}
3165
			mptsas_set_port(ioc, phy_info, port);
3166
			devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
3167
			    MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
3168
			    ioc->name, port->port_identifier,
3169
			    (unsigned long long)phy_info->
3170
			    attached.sas_address));
3171
		}
3172
		dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3173
			"sas_port_add_phy: phy_id=%d\n",
3174
			ioc->name, phy_info->phy_id));
3175
		sas_port_add_phy(port, phy_info->phy);
3176
		phy_info->sas_port_add_phy = 0;
3177
		devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3178
		    MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
3179
		     phy_info->phy_id, phy_info->phy));
3180
	}
3181
	if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
3182

3183
		struct sas_rphy *rphy;
3184
		struct device *parent;
3185
		struct sas_identify identify;
3186

3187
		parent = dev->parent->parent;
3188
		/*
3189
		 * Let the hotplug_work thread handle processing
3190
		 * the adding/removing of devices that occur
3191
		 * after start of day.
3192
		 */
3193
		if (mptsas_is_end_device(&phy_info->attached) &&
3194
		    phy_info->attached.handle_parent) {
3195
			goto out;
3196
		}
3197

3198
		mptsas_parse_device_info(&identify, &phy_info->attached);
3199
		if (scsi_is_host_device(parent)) {
3200
			struct mptsas_portinfo *port_info;
3201
			int i;
3202

3203
			port_info = ioc->hba_port_info;
3204

3205
			for (i = 0; i < port_info->num_phys; i++)
3206
				if (port_info->phy_info[i].identify.sas_address ==
3207
				    identify.sas_address) {
3208
					sas_port_mark_backlink(port);
3209
					goto out;
3210
				}
3211

3212
		} else if (scsi_is_sas_rphy(parent)) {
3213
			struct sas_rphy *parent_rphy = dev_to_rphy(parent);
3214
			if (identify.sas_address ==
3215
			    parent_rphy->identify.sas_address) {
3216
				sas_port_mark_backlink(port);
3217
				goto out;
3218
			}
3219
		}
3220

3221
		switch (identify.device_type) {
3222
		case SAS_END_DEVICE:
3223
			rphy = sas_end_device_alloc(port);
3224
			break;
3225
		case SAS_EDGE_EXPANDER_DEVICE:
3226
		case SAS_FANOUT_EXPANDER_DEVICE:
3227
			rphy = sas_expander_alloc(port, identify.device_type);
3228
			break;
3229
		default:
3230
			rphy = NULL;
3231
			break;
3232
		}
3233
		if (!rphy) {
3234
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3235
				"%s: exit at line=%d\n", ioc->name,
3236
				__func__, __LINE__));
3237
			goto out;
3238
		}
3239

3240
		rphy->identify = identify;
3241
		error = sas_rphy_add(rphy);
3242
		if (error) {
3243
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3244
				"%s: exit at line=%d\n", ioc->name,
3245
				__func__, __LINE__));
3246
			sas_rphy_free(rphy);
3247
			goto out;
3248
		}
3249
		mptsas_set_rphy(ioc, phy_info, rphy);
3250
		if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
3251
			identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
3252
				mptsas_exp_repmanufacture_info(ioc,
3253
					identify.sas_address,
3254
					rphy_to_expander_device(rphy));
3255
	}
3256

3257
	/* If the device exists,verify it wasn't previously flagged
3258
	as a missing device.  If so, clear it */
3259
	vtarget = mptsas_find_vtarget(ioc,
3260
	    phy_info->attached.channel,
3261
	    phy_info->attached.id);
3262
	if (vtarget && vtarget->inDMD) {
3263
		printk(KERN_INFO "Device returned, unsetting inDMD\n");
3264
		vtarget->inDMD = 0;
3265
	}
3266

3267
 out:
3268
	return error;
3269
}
3270

3271
static int
3272
mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
3273
{
3274
	struct mptsas_portinfo *port_info, *hba;
3275
	int error = -ENOMEM, i;
3276

3277
	hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3278
	if (! hba)
3279
		goto out;
3280

3281
	error = mptsas_sas_io_unit_pg0(ioc, hba);
3282
	if (error)
3283
		goto out_free_port_info;
3284

3285
	mptsas_sas_io_unit_pg1(ioc);
3286
	mutex_lock(&ioc->sas_topology_mutex);
3287
	port_info = ioc->hba_port_info;
3288
	if (!port_info) {
3289
		ioc->hba_port_info = port_info = hba;
3290
		ioc->hba_port_num_phy = port_info->num_phys;
3291
		list_add_tail(&port_info->list, &ioc->sas_topology);
3292
	} else {
3293
		for (i = 0; i < hba->num_phys; i++) {
3294
			port_info->phy_info[i].negotiated_link_rate =
3295
				hba->phy_info[i].negotiated_link_rate;
3296
			port_info->phy_info[i].handle =
3297
				hba->phy_info[i].handle;
3298
			port_info->phy_info[i].port_id =
3299
				hba->phy_info[i].port_id;
3300
		}
3301
		kfree(hba->phy_info);
3302
		kfree(hba);
3303
		hba = NULL;
3304
	}
3305
	mutex_unlock(&ioc->sas_topology_mutex);
3306
#if defined(CPQ_CIM)
3307
	ioc->num_ports = port_info->num_phys;
3308
#endif
3309
	for (i = 0; i < port_info->num_phys; i++) {
3310
		mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
3311
			(MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
3312
			 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
3313
		port_info->phy_info[i].identify.handle =
3314
		    port_info->phy_info[i].handle;
3315
		mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
3316
			(MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3317
			 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3318
			 port_info->phy_info[i].identify.handle);
3319
		if (!ioc->hba_port_sas_addr)
3320
			ioc->hba_port_sas_addr =
3321
			    port_info->phy_info[i].identify.sas_address;
3322
		port_info->phy_info[i].identify.phy_id =
3323
		    port_info->phy_info[i].phy_id = i;
3324
		if (port_info->phy_info[i].attached.handle)
3325
			mptsas_sas_device_pg0(ioc,
3326
				&port_info->phy_info[i].attached,
3327
				(MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3328
				 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3329
				port_info->phy_info[i].attached.handle);
3330
	}
3331

3332
	mptsas_setup_wide_ports(ioc, port_info);
3333

3334
	for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3335
		mptsas_probe_one_phy(&ioc->sh->shost_gendev,
3336
		    &port_info->phy_info[i], ioc->sas_index, 1);
3337

3338
	return 0;
3339

3340
 out_free_port_info:
3341
	kfree(hba);
3342
 out:
3343
	return error;
3344
}
3345

3346
static void
3347
mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
3348
{
3349
	struct mptsas_portinfo *parent;
3350
	struct device *parent_dev;
3351
	struct sas_rphy	*rphy;
3352
	int		i;
3353
	u64		sas_address; /* expander sas address */
3354
	u32		handle;
3355

3356
	handle = port_info->phy_info[0].handle;
3357
	sas_address = port_info->phy_info[0].identify.sas_address;
3358
	for (i = 0; i < port_info->num_phys; i++) {
3359
		mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
3360
		    (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
3361
		    MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
3362

3363
		mptsas_sas_device_pg0(ioc,
3364
		    &port_info->phy_info[i].identify,
3365
		    (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3366
		    MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3367
		    port_info->phy_info[i].identify.handle);
3368
		port_info->phy_info[i].identify.phy_id =
3369
		    port_info->phy_info[i].phy_id;
3370

3371
		if (port_info->phy_info[i].attached.handle) {
3372
			mptsas_sas_device_pg0(ioc,
3373
			    &port_info->phy_info[i].attached,
3374
			    (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
3375
			     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3376
			    port_info->phy_info[i].attached.handle);
3377
			port_info->phy_info[i].attached.phy_id =
3378
			    port_info->phy_info[i].phy_id;
3379
		}
3380
	}
3381

3382
	mutex_lock(&ioc->sas_topology_mutex);
3383
	parent = mptsas_find_portinfo_by_handle(ioc,
3384
	    port_info->phy_info[0].identify.handle_parent);
3385
	if (!parent) {
3386
		mutex_unlock(&ioc->sas_topology_mutex);
3387
		return;
3388
	}
3389
	for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
3390
	    i++) {
3391
		if (parent->phy_info[i].attached.sas_address == sas_address) {
3392
			rphy = mptsas_get_rphy(&parent->phy_info[i]);
3393
			parent_dev = &rphy->dev;
3394
		}
3395
	}
3396
	mutex_unlock(&ioc->sas_topology_mutex);
3397

3398
	mptsas_setup_wide_ports(ioc, port_info);
3399
	for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
3400
		mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
3401
		    ioc->sas_index, 0);
3402
}
3403

3404
static void
3405
mptsas_expander_event_add(MPT_ADAPTER *ioc,
3406
    MpiEventDataSasExpanderStatusChange_t *expander_data)
3407
{
3408
	struct mptsas_portinfo *port_info;
3409
	int i;
3410
	__le64 sas_address;
3411

3412
	port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3413
	if (!port_info)
3414
		BUG();
3415
	port_info->num_phys = (expander_data->NumPhys) ?
3416
	    expander_data->NumPhys : 1;
3417
	port_info->phy_info = kcalloc(port_info->num_phys,
3418
	    sizeof(struct mptsas_phyinfo), GFP_KERNEL);
3419
	if (!port_info->phy_info)
3420
		BUG();
3421
	memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3422
	for (i = 0; i < port_info->num_phys; i++) {
3423
		port_info->phy_info[i].portinfo = port_info;
3424
		port_info->phy_info[i].handle =
3425
		    le16_to_cpu(expander_data->DevHandle);
3426
		port_info->phy_info[i].identify.sas_address =
3427
		    le64_to_cpu(sas_address);
3428
		port_info->phy_info[i].identify.handle_parent =
3429
		    le16_to_cpu(expander_data->ParentDevHandle);
3430
	}
3431

3432
	mutex_lock(&ioc->sas_topology_mutex);
3433
	list_add_tail(&port_info->list, &ioc->sas_topology);
3434
	mutex_unlock(&ioc->sas_topology_mutex);
3435

3436
	printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3437
	    "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3438
	    (unsigned long long)sas_address);
3439

3440
	mptsas_expander_refresh(ioc, port_info);
3441
}
3442

3443
/**
3444
 * mptsas_delete_expander_siblings - remove siblings attached to expander
3445
 * @ioc: Pointer to MPT_ADAPTER structure
3446
 * @parent: the parent port_info object
3447
 * @expander: the expander port_info object
3448
 **/
3449
static void
3450
mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
3451
    *parent, struct mptsas_portinfo *expander)
3452
{
3453
	struct mptsas_phyinfo *phy_info;
3454
	struct mptsas_portinfo *port_info;
3455
	struct sas_rphy *rphy;
3456
	int i;
3457

3458
	phy_info = expander->phy_info;
3459
	for (i = 0; i < expander->num_phys; i++, phy_info++) {
3460
		rphy = mptsas_get_rphy(phy_info);
3461
		if (!rphy)
3462
			continue;
3463
		if (rphy->identify.device_type == SAS_END_DEVICE)
3464
			mptsas_del_end_device(ioc, phy_info);
3465
	}
3466

3467
	phy_info = expander->phy_info;
3468
	for (i = 0; i < expander->num_phys; i++, phy_info++) {
3469
		rphy = mptsas_get_rphy(phy_info);
3470
		if (!rphy)
3471
			continue;
3472
		if (rphy->identify.device_type ==
3473
		    MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
3474
		    rphy->identify.device_type ==
3475
		    MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
3476
			port_info = mptsas_find_portinfo_by_sas_address(ioc,
3477
			    rphy->identify.sas_address);
3478
			if (!port_info)
3479
				continue;
3480
			if (port_info == parent) /* backlink rphy */
3481
				continue;
3482
			/*
3483
			Delete this expander even if the expdevpage is exists
3484
			because the parent expander is already deleted
3485
			*/
3486
			mptsas_expander_delete(ioc, port_info, 1);
3487
		}
3488
	}
3489
}
3490

3491

3492
/**
3493
 *	mptsas_expander_delete - remove this expander
3494
 *	@ioc: Pointer to MPT_ADAPTER structure
3495
 *	@port_info: expander port_info struct
3496
 *	@force: Flag to forcefully delete the expander
3497
 *
3498
 **/
3499

3500
static void mptsas_expander_delete(MPT_ADAPTER *ioc,
3501
		struct mptsas_portinfo *port_info, u8 force)
3502
{
3503

3504
	struct mptsas_portinfo *parent;
3505
	int		i;
3506
	u64		expander_sas_address;
3507
	struct mptsas_phyinfo *phy_info;
3508
	struct mptsas_portinfo buffer;
3509
	struct mptsas_portinfo_details *port_details;
3510
	struct sas_port *port;
3511

3512
	if (!port_info)
3513
		return;
3514

3515
	/* see if expander is still there before deleting */
3516
	mptsas_sas_expander_pg0(ioc, &buffer,
3517
	    (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3518
	    MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
3519
	    port_info->phy_info[0].identify.handle);
3520

3521
	if (buffer.num_phys) {
3522
		kfree(buffer.phy_info);
3523
		if (!force)
3524
			return;
3525
	}
3526

3527

3528
	/*
3529
	 * Obtain the port_info instance to the parent port
3530
	 */
3531
	port_details = NULL;
3532
	expander_sas_address =
3533
	    port_info->phy_info[0].identify.sas_address;
3534
	parent = mptsas_find_portinfo_by_handle(ioc,
3535
	    port_info->phy_info[0].identify.handle_parent);
3536
	mptsas_delete_expander_siblings(ioc, parent, port_info);
3537
	if (!parent)
3538
		goto out;
3539

3540
	/*
3541
	 * Delete rphys in the parent that point
3542
	 * to this expander.
3543
	 */
3544
	phy_info = parent->phy_info;
3545
	port = NULL;
3546
	for (i = 0; i < parent->num_phys; i++, phy_info++) {
3547
		if (!phy_info->phy)
3548
			continue;
3549
		if (phy_info->attached.sas_address !=
3550
		    expander_sas_address)
3551
			continue;
3552
		if (!port) {
3553
			port = mptsas_get_port(phy_info);
3554
			port_details = phy_info->port_details;
3555
		}
3556
		dev_printk(KERN_DEBUG, &phy_info->phy->dev,
3557
		    MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
3558
		    phy_info->phy_id, phy_info->phy);
3559
		sas_port_delete_phy(port, phy_info->phy);
3560
	}
3561
	if (port) {
3562
		dev_printk(KERN_DEBUG, &port->dev,
3563
		    MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
3564
		    ioc->name, port->port_identifier,
3565
		    (unsigned long long)expander_sas_address);
3566
		sas_port_delete(port);
3567
		mptsas_port_delete(ioc, port_details);
3568
	}
3569
 out:
3570

3571
	printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
3572
	    "sas_addr (0x%llx)\n",  ioc->name, port_info->num_phys,
3573
	    (unsigned long long)expander_sas_address);
3574

3575
	/*
3576
	 * free link
3577
	 */
3578
	list_del(&port_info->list);
3579
	kfree(port_info->phy_info);
3580
	kfree(port_info);
3581
}
3582

3583

3584
/**
3585
 * mptsas_send_expander_event - expanders events
3586
 * @ioc: Pointer to MPT_ADAPTER structure
3587
 * @expander_data: event data
3588
 *
3589
 *
3590
 * This function handles adding, removing, and refreshing
3591
 * device handles within the expander objects.
3592
 */
3593
static void
3594
mptsas_send_expander_event(struct fw_event_work *fw_event)
3595
{
3596
	MPT_ADAPTER *ioc;
3597
	MpiEventDataSasExpanderStatusChange_t *expander_data;
3598
	struct mptsas_portinfo *port_info;
3599
	__le64 sas_address;
3600
	int i;
3601

3602
	ioc = fw_event->ioc;
3603
	expander_data = (MpiEventDataSasExpanderStatusChange_t *)
3604
	    fw_event->event_data;
3605
	memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
3606
	sas_address = le64_to_cpu(sas_address);
3607
	port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3608

3609
	if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
3610
		if (port_info) {
3611
			for (i = 0; i < port_info->num_phys; i++) {
3612
				port_info->phy_info[i].portinfo = port_info;
3613
				port_info->phy_info[i].handle =
3614
				    le16_to_cpu(expander_data->DevHandle);
3615
				port_info->phy_info[i].identify.sas_address =
3616
				    le64_to_cpu(sas_address);
3617
				port_info->phy_info[i].identify.handle_parent =
3618
				    le16_to_cpu(expander_data->ParentDevHandle);
3619
			}
3620
			mptsas_expander_refresh(ioc, port_info);
3621
		} else if (!port_info && expander_data->NumPhys)
3622
			mptsas_expander_event_add(ioc, expander_data);
3623
	} else if (expander_data->ReasonCode ==
3624
	    MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
3625
		mptsas_expander_delete(ioc, port_info, 0);
3626

3627
	mptsas_free_fw_event(ioc, fw_event);
3628
}
3629

3630

3631
/**
3632
 * mptsas_expander_add -
3633
 * @ioc: Pointer to MPT_ADAPTER structure
3634
 * @handle:
3635
 *
3636
 */
3637
struct mptsas_portinfo *
3638
mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
3639
{
3640
	struct mptsas_portinfo buffer, *port_info;
3641
	int i;
3642

3643
	if ((mptsas_sas_expander_pg0(ioc, &buffer,
3644
	    (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
3645
	    MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
3646
		return NULL;
3647

3648
	port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC);
3649
	if (!port_info) {
3650
		dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3651
		"%s: exit at line=%d\n", ioc->name,
3652
		__func__, __LINE__));
3653
		return NULL;
3654
	}
3655
	port_info->num_phys = buffer.num_phys;
3656
	port_info->phy_info = buffer.phy_info;
3657
	for (i = 0; i < port_info->num_phys; i++)
3658
		port_info->phy_info[i].portinfo = port_info;
3659
	mutex_lock(&ioc->sas_topology_mutex);
3660
	list_add_tail(&port_info->list, &ioc->sas_topology);
3661
	mutex_unlock(&ioc->sas_topology_mutex);
3662
	printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3663
	    "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3664
	    (unsigned long long)buffer.phy_info[0].identify.sas_address);
3665
	mptsas_expander_refresh(ioc, port_info);
3666
	return port_info;
3667
}
3668

3669
static void
3670
mptsas_send_link_status_event(struct fw_event_work *fw_event)
3671
{
3672
	MPT_ADAPTER *ioc;
3673
	MpiEventDataSasPhyLinkStatus_t *link_data;
3674
	struct mptsas_portinfo *port_info;
3675
	struct mptsas_phyinfo *phy_info = NULL;
3676
	__le64 sas_address;
3677
	u8 phy_num;
3678
	u8 link_rate;
3679

3680
	ioc = fw_event->ioc;
3681
	link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
3682

3683
	memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
3684
	sas_address = le64_to_cpu(sas_address);
3685
	link_rate = link_data->LinkRates >> 4;
3686
	phy_num = link_data->PhyNum;
3687

3688
	port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
3689
	if (port_info) {
3690
		phy_info = &port_info->phy_info[phy_num];
3691
		if (phy_info)
3692
			phy_info->negotiated_link_rate = link_rate;
3693
	}
3694

3695
	if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
3696
	    link_rate == MPI_SAS_IOUNIT0_RATE_3_0 ||
3697
	    link_rate == MPI_SAS_IOUNIT0_RATE_6_0) {
3698

3699
		if (!port_info) {
3700
			if (ioc->old_sas_discovery_protocal) {
3701
				port_info = mptsas_expander_add(ioc,
3702
					le16_to_cpu(link_data->DevHandle));
3703
				if (port_info)
3704
					goto out;
3705
			}
3706
			goto out;
3707
		}
3708

3709
		if (port_info == ioc->hba_port_info)
3710
			mptsas_probe_hba_phys(ioc);
3711
		else
3712
			mptsas_expander_refresh(ioc, port_info);
3713
	} else if (phy_info && phy_info->phy) {
3714
		if (link_rate ==  MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
3715
			phy_info->phy->negotiated_linkrate =
3716
			    SAS_PHY_DISABLED;
3717
		else if (link_rate ==
3718
		    MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
3719
			phy_info->phy->negotiated_linkrate =
3720
			    SAS_LINK_RATE_FAILED;
3721
		else {
3722
			phy_info->phy->negotiated_linkrate =
3723
			    SAS_LINK_RATE_UNKNOWN;
3724
			if (ioc->device_missing_delay &&
3725
			    mptsas_is_end_device(&phy_info->attached)) {
3726
				struct scsi_device		*sdev;
3727
				VirtDevice			*vdevice;
3728
				u8	channel, id;
3729
				id = phy_info->attached.id;
3730
				channel = phy_info->attached.channel;
3731
				devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3732
				"Link down for fw_id %d:fw_channel %d\n",
3733
				    ioc->name, phy_info->attached.id,
3734
				    phy_info->attached.channel));
3735

3736
				shost_for_each_device(sdev, ioc->sh) {
3737
					vdevice = sdev->hostdata;
3738
					if ((vdevice == NULL) ||
3739
						(vdevice->vtarget == NULL))
3740
						continue;
3741
					if ((vdevice->vtarget->tflags &
3742
					    MPT_TARGET_FLAGS_RAID_COMPONENT ||
3743
					    vdevice->vtarget->raidVolume))
3744
						continue;
3745
					if (vdevice->vtarget->id == id &&
3746
						vdevice->vtarget->channel ==
3747
						channel)
3748
						devtprintk(ioc,
3749
						printk(MYIOC_s_DEBUG_FMT
3750
						"SDEV OUTSTANDING CMDS"
3751
						"%d\n", ioc->name,
3752
						sdev->device_busy));
3753
				}
3754

3755
			}
3756
		}
3757
	}
3758
 out:
3759
	mptsas_free_fw_event(ioc, fw_event);
3760
}
3761

3762
static void
3763
mptsas_not_responding_devices(MPT_ADAPTER *ioc)
3764
{
3765
	struct mptsas_portinfo buffer, *port_info;
3766
	struct mptsas_device_info	*sas_info;
3767
	struct mptsas_devinfo sas_device;
3768
	u32	handle;
3769
	VirtTarget *vtarget = NULL;
3770
	struct mptsas_phyinfo *phy_info;
3771
	u8 found_expander;
3772
	int retval, retry_count;
3773
	unsigned long flags;
3774

3775
	mpt_findImVolumes(ioc);
3776

3777
	spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3778
	if (ioc->ioc_reset_in_progress) {
3779
		dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3780
		   "%s: exiting due to a parallel reset \n", ioc->name,
3781
		    __func__));
3782
		spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3783
		return;
3784
	}
3785
	spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
3786

3787
	/* devices, logical volumes */
3788
	mutex_lock(&ioc->sas_device_info_mutex);
3789
 redo_device_scan:
3790
	list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
3791
		if (sas_info->is_cached)
3792
			continue;
3793
		if (!sas_info->is_logical_volume) {
3794
			sas_device.handle = 0;
3795
			retry_count = 0;
3796
retry_page:
3797
			retval = mptsas_sas_device_pg0(ioc, &sas_device,
3798
				(MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID
3799
				<< MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
3800
				(sas_info->fw.channel << 8) +
3801
				sas_info->fw.id);
3802

3803
			if (sas_device.handle)
3804
				continue;
3805
			if (retval == -EBUSY) {
3806
				spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
3807
				if (ioc->ioc_reset_in_progress) {
3808
					dfailprintk(ioc,
3809
					printk(MYIOC_s_DEBUG_FMT
3810
					"%s: exiting due to reset\n",
3811
					ioc->name, __func__));
3812
					spin_unlock_irqrestore
3813
					(&ioc->taskmgmt_lock, flags);
3814
					mutex_unlock(&ioc->
3815
					sas_device_info_mutex);
3816
					return;
3817
				}
3818
				spin_unlock_irqrestore(&ioc->taskmgmt_lock,
3819
				flags);
3820
			}
3821

3822
			if (retval && (retval != -ENODEV)) {
3823
				if (retry_count < 10) {
3824
					retry_count++;
3825
					goto retry_page;
3826
				} else {
3827
					devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3828
					"%s: Config page retry exceeded retry "
3829
					"count deleting device 0x%llx\n",
3830
					ioc->name, __func__,
3831
					sas_info->sas_address));
3832
				}
3833
			}
3834

3835
			/* delete device */
3836
			vtarget = mptsas_find_vtarget(ioc,
3837
				sas_info->fw.channel, sas_info->fw.id);
3838

3839
			if (vtarget)
3840
				vtarget->deleted = 1;
3841

3842
			phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
3843
					sas_info->sas_address);
3844

3845
			if (phy_info) {
3846
				mptsas_del_end_device(ioc, phy_info);
3847
				goto redo_device_scan;
3848
			}
3849
		} else
3850
			mptsas_volume_delete(ioc, sas_info->fw.id);
3851
	}
3852
	mutex_unlock(&ioc->sas_device_info_mutex);
3853

3854
	/* expanders */
3855
	mutex_lock(&ioc->sas_topology_mutex);
3856
 redo_expander_scan:
3857
	list_for_each_entry(port_info, &ioc->sas_topology, list) {
3858

3859
		if (port_info->phy_info &&
3860
		    (!(port_info->phy_info[0].identify.device_info &
3861
		    MPI_SAS_DEVICE_INFO_SMP_TARGET)))
3862
			continue;
3863
		found_expander = 0;
3864
		handle = 0xFFFF;
3865
		while (!mptsas_sas_expander_pg0(ioc, &buffer,
3866
		    (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3867
		     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
3868
		    !found_expander) {
3869

3870
			handle = buffer.phy_info[0].handle;
3871
			if (buffer.phy_info[0].identify.sas_address ==
3872
			    port_info->phy_info[0].identify.sas_address) {
3873
				found_expander = 1;
3874
			}
3875
			kfree(buffer.phy_info);
3876
		}
3877

3878
		if (!found_expander) {
3879
			mptsas_expander_delete(ioc, port_info, 0);
3880
			goto redo_expander_scan;
3881
		}
3882
	}
3883
	mutex_unlock(&ioc->sas_topology_mutex);
3884
}
3885

3886
/**
3887
 *	mptsas_probe_expanders - adding expanders
3888
 *	@ioc: Pointer to MPT_ADAPTER structure
3889
 *
3890
 **/
3891
static void
3892
mptsas_probe_expanders(MPT_ADAPTER *ioc)
3893
{
3894
	struct mptsas_portinfo buffer, *port_info;
3895
	u32 			handle;
3896
	int i;
3897

3898
	handle = 0xFFFF;
3899
	while (!mptsas_sas_expander_pg0(ioc, &buffer,
3900
	    (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
3901
	     MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
3902

3903
		handle = buffer.phy_info[0].handle;
3904
		port_info = mptsas_find_portinfo_by_sas_address(ioc,
3905
		    buffer.phy_info[0].identify.sas_address);
3906

3907
		if (port_info) {
3908
			/* refreshing handles */
3909
			for (i = 0; i < buffer.num_phys; i++) {
3910
				port_info->phy_info[i].handle = handle;
3911
				port_info->phy_info[i].identify.handle_parent =
3912
				    buffer.phy_info[0].identify.handle_parent;
3913
			}
3914
			mptsas_expander_refresh(ioc, port_info);
3915
			kfree(buffer.phy_info);
3916
			continue;
3917
		}
3918

3919
		port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
3920
		if (!port_info) {
3921
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
3922
			"%s: exit at line=%d\n", ioc->name,
3923
			__func__, __LINE__));
3924
			return;
3925
		}
3926
		port_info->num_phys = buffer.num_phys;
3927
		port_info->phy_info = buffer.phy_info;
3928
		for (i = 0; i < port_info->num_phys; i++)
3929
			port_info->phy_info[i].portinfo = port_info;
3930
		mutex_lock(&ioc->sas_topology_mutex);
3931
		list_add_tail(&port_info->list, &ioc->sas_topology);
3932
		mutex_unlock(&ioc->sas_topology_mutex);
3933
		printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
3934
		    "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
3935
	    (unsigned long long)buffer.phy_info[0].identify.sas_address);
3936
		mptsas_expander_refresh(ioc, port_info);
3937
	}
3938
}
3939

3940
static void
3941
mptsas_probe_devices(MPT_ADAPTER *ioc)
3942
{
3943
	u16 handle;
3944
	struct mptsas_devinfo sas_device;
3945
	struct mptsas_phyinfo *phy_info;
3946

3947
	handle = 0xFFFF;
3948
	while (!(mptsas_sas_device_pg0(ioc, &sas_device,
3949
	    MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
3950

3951
		handle = sas_device.handle;
3952

3953
		if ((sas_device.device_info &
3954
		     (MPI_SAS_DEVICE_INFO_SSP_TARGET |
3955
		      MPI_SAS_DEVICE_INFO_STP_TARGET |
3956
		      MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
3957
			continue;
3958

3959
		/* If there is no FW B_T mapping for this device then continue
3960
		 * */
3961
		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
3962
			|| !(sas_device.flags &
3963
			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
3964
			continue;
3965

3966
		phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
3967
		if (!phy_info)
3968
			continue;
3969

3970
		if (mptsas_get_rphy(phy_info))
3971
			continue;
3972

3973
		mptsas_add_end_device(ioc, phy_info);
3974
	}
3975
}
3976

3977
/**
3978
 *	mptsas_scan_sas_topology -
3979
 *	@ioc: Pointer to MPT_ADAPTER structure
3980
 *	@sas_address:
3981
 *
3982
 **/
3983
static void
3984
mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
3985
{
3986
	struct scsi_device *sdev;
3987
	int i;
3988

3989
	mptsas_probe_hba_phys(ioc);
3990
	mptsas_probe_expanders(ioc);
3991
	mptsas_probe_devices(ioc);
3992

3993
	/*
3994
	  Reporting RAID volumes.
3995
	*/
3996
	if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
3997
	    !ioc->raid_data.pIocPg2->NumActiveVolumes)
3998
		return;
3999
	for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4000
		sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4001
		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4002
		if (sdev) {
4003
			scsi_device_put(sdev);
4004
			continue;
4005
		}
4006
		printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4007
		    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4008
		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
4009
		scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4010
		    ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
4011
	}
4012
}
4013

4014

4015
static void
4016
mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
4017
{
4018
	MPT_ADAPTER *ioc;
4019
	EventDataQueueFull_t *qfull_data;
4020
	struct mptsas_device_info *sas_info;
4021
	struct scsi_device	*sdev;
4022
	int depth;
4023
	int id = -1;
4024
	int channel = -1;
4025
	int fw_id, fw_channel;
4026
	u16 current_depth;
4027

4028

4029
	ioc = fw_event->ioc;
4030
	qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
4031
	fw_id = qfull_data->TargetID;
4032
	fw_channel = qfull_data->Bus;
4033
	current_depth = le16_to_cpu(qfull_data->CurrentDepth);
4034

4035
	/* if hidden raid component, look for the volume id */
4036
	mutex_lock(&ioc->sas_device_info_mutex);
4037
	if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
4038
		list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4039
		    list) {
4040
			if (sas_info->is_cached ||
4041
			    sas_info->is_logical_volume)
4042
				continue;
4043
			if (sas_info->is_hidden_raid_component &&
4044
			    (sas_info->fw.channel == fw_channel &&
4045
			    sas_info->fw.id == fw_id)) {
4046
				id = sas_info->volume_id;
4047
				channel = MPTSAS_RAID_CHANNEL;
4048
				goto out;
4049
			}
4050
		}
4051
	} else {
4052
		list_for_each_entry(sas_info, &ioc->sas_device_info_list,
4053
		    list) {
4054
			if (sas_info->is_cached ||
4055
			    sas_info->is_hidden_raid_component ||
4056
			    sas_info->is_logical_volume)
4057
				continue;
4058
			if (sas_info->fw.channel == fw_channel &&
4059
			    sas_info->fw.id == fw_id) {
4060
				id = sas_info->os.id;
4061
				channel = sas_info->os.channel;
4062
				goto out;
4063
			}
4064
		}
4065

4066
	}
4067

4068
 out:
4069
	mutex_unlock(&ioc->sas_device_info_mutex);
4070

4071
	if (id != -1) {
4072
		shost_for_each_device(sdev, ioc->sh) {
4073
			if (sdev->id == id && sdev->channel == channel) {
4074
				if (current_depth > sdev->queue_depth) {
4075
					sdev_printk(KERN_INFO, sdev,
4076
					    "strange observation, the queue "
4077
					    "depth is (%d) meanwhile fw queue "
4078
					    "depth (%d)\n", sdev->queue_depth,
4079
					    current_depth);
4080
					continue;
4081
				}
4082
				depth = scsi_track_queue_full(sdev,
4083
				    current_depth - 1);
4084
				if (depth > 0)
4085
					sdev_printk(KERN_INFO, sdev,
4086
					"Queue depth reduced to (%d)\n",
4087
					   depth);
4088
				else if (depth < 0)
4089
					sdev_printk(KERN_INFO, sdev,
4090
					"Tagged Command Queueing is being "
4091
					"disabled\n");
4092
				else if (depth == 0)
4093
					sdev_printk(KERN_INFO, sdev,
4094
					"Queue depth not changed yet\n");
4095
			}
4096
		}
4097
	}
4098

4099
	mptsas_free_fw_event(ioc, fw_event);
4100
}
4101

4102

4103
static struct mptsas_phyinfo *
4104
mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
4105
{
4106
	struct mptsas_portinfo *port_info;
4107
	struct mptsas_phyinfo *phy_info = NULL;
4108
	int i;
4109

4110
	mutex_lock(&ioc->sas_topology_mutex);
4111
	list_for_each_entry(port_info, &ioc->sas_topology, list) {
4112
		for (i = 0; i < port_info->num_phys; i++) {
4113
			if (!mptsas_is_end_device(
4114
				&port_info->phy_info[i].attached))
4115
				continue;
4116
			if (port_info->phy_info[i].attached.sas_address
4117
			    != sas_address)
4118
				continue;
4119
			phy_info = &port_info->phy_info[i];
4120
			break;
4121
		}
4122
	}
4123
	mutex_unlock(&ioc->sas_topology_mutex);
4124
	return phy_info;
4125
}
4126

4127
/**
4128
 *	mptsas_find_phyinfo_by_phys_disk_num -
4129
 *	@ioc: Pointer to MPT_ADAPTER structure
4130
 *	@phys_disk_num:
4131
 *	@channel:
4132
 *	@id:
4133
 *
4134
 **/
4135
static struct mptsas_phyinfo *
4136
mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
4137
	u8 channel, u8 id)
4138
{
4139
	struct mptsas_phyinfo *phy_info = NULL;
4140
	struct mptsas_portinfo *port_info;
4141
	RaidPhysDiskPage1_t *phys_disk = NULL;
4142
	int num_paths;
4143
	u64 sas_address = 0;
4144
	int i;
4145

4146
	phy_info = NULL;
4147
	if (!ioc->raid_data.pIocPg3)
4148
		return NULL;
4149
	/* dual port support */
4150
	num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
4151
	if (!num_paths)
4152
		goto out;
4153
	phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) +
4154
	   (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
4155
	if (!phys_disk)
4156
		goto out;
4157
	mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
4158
	for (i = 0; i < num_paths; i++) {
4159
		if ((phys_disk->Path[i].Flags & 1) != 0)
4160
			/* entry no longer valid */
4161
			continue;
4162
		if ((id == phys_disk->Path[i].PhysDiskID) &&
4163
		    (channel == phys_disk->Path[i].PhysDiskBus)) {
4164
			memcpy(&sas_address, &phys_disk->Path[i].WWID,
4165
				sizeof(u64));
4166
			phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4167
					sas_address);
4168
			goto out;
4169
		}
4170
	}
4171

4172
 out:
4173
	kfree(phys_disk);
4174
	if (phy_info)
4175
		return phy_info;
4176

4177
	/*
4178
	 * Extra code to handle RAID0 case, where the sas_address is not updated
4179
	 * in phys_disk_page_1 when hotswapped
4180
	 */
4181
	mutex_lock(&ioc->sas_topology_mutex);
4182
	list_for_each_entry(port_info, &ioc->sas_topology, list) {
4183
		for (i = 0; i < port_info->num_phys && !phy_info; i++) {
4184
			if (!mptsas_is_end_device(
4185
				&port_info->phy_info[i].attached))
4186
				continue;
4187
			if (port_info->phy_info[i].attached.phys_disk_num == ~0)
4188
				continue;
4189
			if ((port_info->phy_info[i].attached.phys_disk_num ==
4190
			    phys_disk_num) &&
4191
			    (port_info->phy_info[i].attached.id == id) &&
4192
			    (port_info->phy_info[i].attached.channel ==
4193
			     channel))
4194
				phy_info = &port_info->phy_info[i];
4195
		}
4196
	}
4197
	mutex_unlock(&ioc->sas_topology_mutex);
4198
	return phy_info;
4199
}
4200

4201
static void
4202
mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
4203
{
4204
	int rc;
4205

4206
	sdev->no_uld_attach = data ? 1 : 0;
4207
	rc = scsi_device_reprobe(sdev);
4208
}
4209

4210
static void
4211
mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
4212
{
4213
	starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
4214
			mptsas_reprobe_lun);
4215
}
4216

4217
static void
4218
mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
4219
{
4220
	CONFIGPARMS			cfg;
4221
	ConfigPageHeader_t		hdr;
4222
	dma_addr_t			dma_handle;
4223
	pRaidVolumePage0_t		buffer = NULL;
4224
	RaidPhysDiskPage0_t 		phys_disk;
4225
	int				i;
4226
	struct mptsas_phyinfo	*phy_info;
4227
	struct mptsas_devinfo		sas_device;
4228

4229
	memset(&cfg, 0 , sizeof(CONFIGPARMS));
4230
	memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
4231
	hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
4232
	cfg.pageAddr = (channel << 8) + id;
4233
	cfg.cfghdr.hdr = &hdr;
4234
	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4235
	cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
4236

4237
	if (mpt_config(ioc, &cfg) != 0)
4238
		goto out;
4239

4240
	if (!hdr.PageLength)
4241
		goto out;
4242

4243
	buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
4244
	    &dma_handle);
4245

4246
	if (!buffer)
4247
		goto out;
4248

4249
	cfg.physAddr = dma_handle;
4250
	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4251

4252
	if (mpt_config(ioc, &cfg) != 0)
4253
		goto out;
4254

4255
	if (!(buffer->VolumeStatus.Flags &
4256
	    MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
4257
		goto out;
4258

4259
	if (!buffer->NumPhysDisks)
4260
		goto out;
4261

4262
	for (i = 0; i < buffer->NumPhysDisks; i++) {
4263

4264
		if (mpt_raid_phys_disk_pg0(ioc,
4265
		    buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
4266
			continue;
4267

4268
		if (mptsas_sas_device_pg0(ioc, &sas_device,
4269
		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4270
		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4271
			(phys_disk.PhysDiskBus << 8) +
4272
			phys_disk.PhysDiskID))
4273
			continue;
4274

4275
		/* If there is no FW B_T mapping for this device then continue
4276
		 * */
4277
		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4278
			|| !(sas_device.flags &
4279
			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4280
			continue;
4281

4282

4283
		phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4284
		    sas_device.sas_address);
4285
		mptsas_add_end_device(ioc, phy_info);
4286
	}
4287

4288
 out:
4289
	if (buffer)
4290
		pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
4291
		    dma_handle);
4292
}
4293
/*
4294
 * Work queue thread to handle SAS hotplug events
4295
 */
4296
static void
4297
mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
4298
    struct mptsas_hotplug_event *hot_plug_info)
4299
{
4300
	struct mptsas_phyinfo *phy_info;
4301
	struct scsi_target * starget;
4302
	struct mptsas_devinfo sas_device;
4303
	VirtTarget *vtarget;
4304
	int i;
4305
	struct mptsas_portinfo *port_info;
4306

4307
	switch (hot_plug_info->event_type) {
4308

4309
	case MPTSAS_ADD_PHYSDISK:
4310

4311
		if (!ioc->raid_data.pIocPg2)
4312
			break;
4313

4314
		for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
4315
			if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
4316
			    hot_plug_info->id) {
4317
				printk(MYIOC_s_WARN_FMT "firmware bug: unable "
4318
				    "to add hidden disk - target_id matchs "
4319
				    "volume_id\n", ioc->name);
4320
				mptsas_free_fw_event(ioc, fw_event);
4321
				return;
4322
			}
4323
		}
4324
		mpt_findImVolumes(ioc);
4325

4326
	case MPTSAS_ADD_DEVICE:
4327
		memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
4328
		mptsas_sas_device_pg0(ioc, &sas_device,
4329
		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4330
		    MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4331
		    (hot_plug_info->channel << 8) +
4332
		    hot_plug_info->id);
4333

4334
		/* If there is no FW B_T mapping for this device then break
4335
		 * */
4336
		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4337
			|| !(sas_device.flags &
4338
			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4339
			break;
4340

4341
		if (!sas_device.handle)
4342
			return;
4343

4344
		phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
4345
		/* Only For SATA Device ADD */
4346
		if (!phy_info && (sas_device.device_info &
4347
				MPI_SAS_DEVICE_INFO_SATA_DEVICE)) {
4348
			devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4349
				"%s %d SATA HOT PLUG: "
4350
				"parent handle of device %x\n", ioc->name,
4351
				__func__, __LINE__, sas_device.handle_parent));
4352
			port_info = mptsas_find_portinfo_by_handle(ioc,
4353
				sas_device.handle_parent);
4354

4355
			if (port_info == ioc->hba_port_info)
4356
				mptsas_probe_hba_phys(ioc);
4357
			else if (port_info)
4358
				mptsas_expander_refresh(ioc, port_info);
4359
			else {
4360
				dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4361
					"%s %d port info is NULL\n",
4362
					ioc->name, __func__, __LINE__));
4363
				break;
4364
			}
4365
			phy_info = mptsas_refreshing_device_handles
4366
				(ioc, &sas_device);
4367
		}
4368

4369
		if (!phy_info) {
4370
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4371
				"%s %d phy info is NULL\n",
4372
				ioc->name, __func__, __LINE__));
4373
			break;
4374
		}
4375

4376
		if (mptsas_get_rphy(phy_info))
4377
			break;
4378

4379
		mptsas_add_end_device(ioc, phy_info);
4380
		break;
4381

4382
	case MPTSAS_DEL_DEVICE:
4383
		phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4384
		    hot_plug_info->sas_address);
4385
		mptsas_del_end_device(ioc, phy_info);
4386
		break;
4387

4388
	case MPTSAS_DEL_PHYSDISK:
4389

4390
		mpt_findImVolumes(ioc);
4391

4392
		phy_info = mptsas_find_phyinfo_by_phys_disk_num(
4393
				ioc, hot_plug_info->phys_disk_num,
4394
				hot_plug_info->channel,
4395
				hot_plug_info->id);
4396
		mptsas_del_end_device(ioc, phy_info);
4397
		break;
4398

4399
	case MPTSAS_ADD_PHYSDISK_REPROBE:
4400

4401
		if (mptsas_sas_device_pg0(ioc, &sas_device,
4402
		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4403
		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4404
		    (hot_plug_info->channel << 8) + hot_plug_info->id)) {
4405
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4406
			"%s: fw_id=%d exit at line=%d\n", ioc->name,
4407
				 __func__, hot_plug_info->id, __LINE__));
4408
			break;
4409
		}
4410

4411
		/* If there is no FW B_T mapping for this device then break
4412
		 * */
4413
		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4414
			|| !(sas_device.flags &
4415
			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4416
			break;
4417

4418
		phy_info = mptsas_find_phyinfo_by_sas_address(
4419
		    ioc, sas_device.sas_address);
4420

4421
		if (!phy_info) {
4422
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4423
				"%s: fw_id=%d exit at line=%d\n", ioc->name,
4424
				 __func__, hot_plug_info->id, __LINE__));
4425
			break;
4426
		}
4427

4428
		starget = mptsas_get_starget(phy_info);
4429
		if (!starget) {
4430
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4431
				"%s: fw_id=%d exit at line=%d\n", ioc->name,
4432
				 __func__, hot_plug_info->id, __LINE__));
4433
			break;
4434
		}
4435

4436
		vtarget = starget->hostdata;
4437
		if (!vtarget) {
4438
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4439
				"%s: fw_id=%d exit at line=%d\n", ioc->name,
4440
				 __func__, hot_plug_info->id, __LINE__));
4441
			break;
4442
		}
4443

4444
		mpt_findImVolumes(ioc);
4445

4446
		starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
4447
		    "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4448
		    ioc->name, hot_plug_info->channel, hot_plug_info->id,
4449
		    hot_plug_info->phys_disk_num, (unsigned long long)
4450
		    sas_device.sas_address);
4451

4452
		vtarget->id = hot_plug_info->phys_disk_num;
4453
		vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
4454
		phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
4455
		mptsas_reprobe_target(starget, 1);
4456
		break;
4457

4458
	case MPTSAS_DEL_PHYSDISK_REPROBE:
4459

4460
		if (mptsas_sas_device_pg0(ioc, &sas_device,
4461
		    (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
4462
		     MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
4463
			(hot_plug_info->channel << 8) + hot_plug_info->id)) {
4464
				dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4465
				    "%s: fw_id=%d exit at line=%d\n",
4466
				    ioc->name, __func__,
4467
				    hot_plug_info->id, __LINE__));
4468
			break;
4469
		}
4470

4471
		/* If there is no FW B_T mapping for this device then break
4472
		 * */
4473
		if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)
4474
			|| !(sas_device.flags &
4475
			MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED))
4476
			break;
4477

4478
		phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
4479
				sas_device.sas_address);
4480
		if (!phy_info) {
4481
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4482
			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4483
			 __func__, hot_plug_info->id, __LINE__));
4484
			break;
4485
		}
4486

4487
		starget = mptsas_get_starget(phy_info);
4488
		if (!starget) {
4489
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4490
			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4491
			 __func__, hot_plug_info->id, __LINE__));
4492
			break;
4493
		}
4494

4495
		vtarget = starget->hostdata;
4496
		if (!vtarget) {
4497
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4498
			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4499
			 __func__, hot_plug_info->id, __LINE__));
4500
			break;
4501
		}
4502

4503
		if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
4504
			dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
4505
			    "%s: fw_id=%d exit at line=%d\n", ioc->name,
4506
			 __func__, hot_plug_info->id, __LINE__));
4507
			break;
4508
		}
4509

4510
		mpt_findImVolumes(ioc);
4511

4512
		starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
4513
		    " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
4514
		    ioc->name, hot_plug_info->channel, hot_plug_info->id,
4515
		    hot_plug_info->phys_disk_num, (unsigned long long)
4516
		    sas_device.sas_address);
4517

4518
		vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
4519
		vtarget->id = hot_plug_info->id;
4520
		phy_info->attached.phys_disk_num = ~0;
4521
		mptsas_reprobe_target(starget, 0);
4522
		mptsas_add_device_component_by_fw(ioc,
4523
		    hot_plug_info->channel, hot_plug_info->id);
4524
		break;
4525

4526
	case MPTSAS_ADD_RAID:
4527

4528
		mpt_findImVolumes(ioc);
4529
		printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
4530
		    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4531
		    hot_plug_info->id);
4532
		scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
4533
		    hot_plug_info->id, 0);
4534
		break;
4535

4536
	case MPTSAS_DEL_RAID:
4537

4538
		mpt_findImVolumes(ioc);
4539
		printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
4540
		    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
4541
		    hot_plug_info->id);
4542
		scsi_remove_device(hot_plug_info->sdev);
4543
		scsi_device_put(hot_plug_info->sdev);
4544
		break;
4545

4546
	case MPTSAS_ADD_INACTIVE_VOLUME:
4547

4548
		mpt_findImVolumes(ioc);
4549
		mptsas_adding_inactive_raid_components(ioc,
4550
		    hot_plug_info->channel, hot_plug_info->id);
4551
		break;
4552

4553
	default:
4554
		break;
4555
	}
4556

4557
	mptsas_free_fw_event(ioc, fw_event);
4558
}
4559

4560
static void
4561
mptsas_send_sas_event(struct fw_event_work *fw_event)
4562
{
4563
	MPT_ADAPTER *ioc;
4564
	struct mptsas_hotplug_event hot_plug_info;
4565
	EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
4566
	u32 device_info;
4567
	u64 sas_address;
4568

4569
	ioc = fw_event->ioc;
4570
	sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
4571
	    fw_event->event_data;
4572
	device_info = le32_to_cpu(sas_event_data->DeviceInfo);
4573

4574
	if ((device_info &
4575
		(MPI_SAS_DEVICE_INFO_SSP_TARGET |
4576
		MPI_SAS_DEVICE_INFO_STP_TARGET |
4577
		MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) {
4578
		mptsas_free_fw_event(ioc, fw_event);
4579
		return;
4580
	}
4581

4582
	if (sas_event_data->ReasonCode ==
4583
		MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
4584
		mptbase_sas_persist_operation(ioc,
4585
		MPI_SAS_OP_CLEAR_NOT_PRESENT);
4586
		mptsas_free_fw_event(ioc, fw_event);
4587
		return;
4588
	}
4589

4590
	switch (sas_event_data->ReasonCode) {
4591
	case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
4592
	case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
4593
		memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4594
		hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
4595
		hot_plug_info.channel = sas_event_data->Bus;
4596
		hot_plug_info.id = sas_event_data->TargetID;
4597
		hot_plug_info.phy_id = sas_event_data->PhyNum;
4598
		memcpy(&sas_address, &sas_event_data->SASAddress,
4599
		    sizeof(u64));
4600
		hot_plug_info.sas_address = le64_to_cpu(sas_address);
4601
		hot_plug_info.device_info = device_info;
4602
		if (sas_event_data->ReasonCode &
4603
		    MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
4604
			hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
4605
		else
4606
			hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
4607
		mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4608
		break;
4609

4610
	case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
4611
		mptbase_sas_persist_operation(ioc,
4612
		    MPI_SAS_OP_CLEAR_NOT_PRESENT);
4613
		mptsas_free_fw_event(ioc, fw_event);
4614
		break;
4615

4616
	case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
4617
	/* TODO */
4618
	case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
4619
	/* TODO */
4620
	default:
4621
		mptsas_free_fw_event(ioc, fw_event);
4622
		break;
4623
	}
4624
}
4625

4626
static void
4627
mptsas_send_raid_event(struct fw_event_work *fw_event)
4628
{
4629
	MPT_ADAPTER *ioc;
4630
	EVENT_DATA_RAID *raid_event_data;
4631
	struct mptsas_hotplug_event hot_plug_info;
4632
	int status;
4633
	int state;
4634
	struct scsi_device *sdev = NULL;
4635
	VirtDevice *vdevice = NULL;
4636
	RaidPhysDiskPage0_t phys_disk;
4637

4638
	ioc = fw_event->ioc;
4639
	raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
4640
	status = le32_to_cpu(raid_event_data->SettingsStatus);
4641
	state = (status >> 8) & 0xff;
4642

4643
	memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4644
	hot_plug_info.id = raid_event_data->VolumeID;
4645
	hot_plug_info.channel = raid_event_data->VolumeBus;
4646
	hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
4647

4648
	if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
4649
	    raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
4650
	    raid_event_data->ReasonCode ==
4651
	    MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
4652
		sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
4653
		    hot_plug_info.id, 0);
4654
		hot_plug_info.sdev = sdev;
4655
		if (sdev)
4656
			vdevice = sdev->hostdata;
4657
	}
4658

4659
	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4660
	    "ReasonCode=%02x\n", ioc->name, __func__,
4661
	    raid_event_data->ReasonCode));
4662

4663
	switch (raid_event_data->ReasonCode) {
4664
	case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4665
		hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
4666
		break;
4667
	case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4668
		hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
4669
		break;
4670
	case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4671
		switch (state) {
4672
		case MPI_PD_STATE_ONLINE:
4673
		case MPI_PD_STATE_NOT_COMPATIBLE:
4674
			mpt_raid_phys_disk_pg0(ioc,
4675
			    raid_event_data->PhysDiskNum, &phys_disk);
4676
			hot_plug_info.id = phys_disk.PhysDiskID;
4677
			hot_plug_info.channel = phys_disk.PhysDiskBus;
4678
			hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4679
			break;
4680
		case MPI_PD_STATE_FAILED:
4681
		case MPI_PD_STATE_MISSING:
4682
		case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
4683
		case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
4684
		case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
4685
			hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4686
			break;
4687
		default:
4688
			break;
4689
		}
4690
		break;
4691
	case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4692
		if (!sdev)
4693
			break;
4694
		vdevice->vtarget->deleted = 1; /* block IO */
4695
		hot_plug_info.event_type = MPTSAS_DEL_RAID;
4696
		break;
4697
	case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4698
		if (sdev) {
4699
			scsi_device_put(sdev);
4700
			break;
4701
		}
4702
		hot_plug_info.event_type = MPTSAS_ADD_RAID;
4703
		break;
4704
	case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4705
		if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
4706
			if (!sdev)
4707
				break;
4708
			vdevice->vtarget->deleted = 1; /* block IO */
4709
			hot_plug_info.event_type = MPTSAS_DEL_RAID;
4710
			break;
4711
		}
4712
		switch (state) {
4713
		case MPI_RAIDVOL0_STATUS_STATE_FAILED:
4714
		case MPI_RAIDVOL0_STATUS_STATE_MISSING:
4715
			if (!sdev)
4716
				break;
4717
			vdevice->vtarget->deleted = 1; /* block IO */
4718
			hot_plug_info.event_type = MPTSAS_DEL_RAID;
4719
			break;
4720
		case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
4721
		case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
4722
			if (sdev) {
4723
				scsi_device_put(sdev);
4724
				break;
4725
			}
4726
			hot_plug_info.event_type = MPTSAS_ADD_RAID;
4727
			break;
4728
		default:
4729
			break;
4730
		}
4731
		break;
4732
	default:
4733
		break;
4734
	}
4735

4736
	if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
4737
		mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4738
	else
4739
		mptsas_free_fw_event(ioc, fw_event);
4740
}
4741

4742
/**
4743
 *	mptsas_issue_tm - send mptsas internal tm request
4744
 *	@ioc: Pointer to MPT_ADAPTER structure
4745
 *	@type: Task Management type
4746
 *	@channel: channel number for task management
4747
 *	@id: Logical Target ID for reset (if appropriate)
4748
 *	@lun: Logical unit for reset (if appropriate)
4749
 *	@task_context: Context for the task to be aborted
4750
 *	@timeout: timeout for task management control
4751
 *
4752
 *	return 0 on success and -1 on failure:
4753
 *
4754
 */
4755
static int
4756
mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun,
4757
	int task_context, ulong timeout, u8 *issue_reset)
4758
{
4759
	MPT_FRAME_HDR	*mf;
4760
	SCSITaskMgmt_t	*pScsiTm;
4761
	int		 retval;
4762
	unsigned long	 timeleft;
4763

4764
	*issue_reset = 0;
4765
	mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc);
4766
	if (mf == NULL) {
4767
		retval = -1; /* return failure */
4768
		dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
4769
		    "msg frames!!\n", ioc->name));
4770
		goto out;
4771
	}
4772

4773
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
4774
	    "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
4775
	    "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
4776
	     type, timeout, channel, id, (unsigned long long)lun,
4777
	     task_context));
4778

4779
	pScsiTm = (SCSITaskMgmt_t *) mf;
4780
	memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
4781
	pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4782
	pScsiTm->TaskType = type;
4783
	pScsiTm->MsgFlags = 0;
4784
	pScsiTm->TargetID = id;
4785
	pScsiTm->Bus = channel;
4786
	pScsiTm->ChainOffset = 0;
4787
	pScsiTm->Reserved = 0;
4788
	pScsiTm->Reserved1 = 0;
4789
	pScsiTm->TaskMsgContext = task_context;
4790
	int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
4791

4792
	INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4793
	CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
4794
	retval = 0;
4795
	mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
4796

4797
	/* Now wait for the command to complete */
4798
	timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
4799
	    timeout*HZ);
4800
	if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
4801
		retval = -1; /* return failure */
4802
		dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
4803
		    "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
4804
		mpt_free_msg_frame(ioc, mf);
4805
		if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
4806
			goto out;
4807
		*issue_reset = 1;
4808
		goto out;
4809
	}
4810

4811
	if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
4812
		retval = -1; /* return failure */
4813
		dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4814
		    "TaskMgmt request: failed with no reply\n", ioc->name));
4815
		goto out;
4816
	}
4817

4818
 out:
4819
	CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
4820
	return retval;
4821
}
4822

4823
/**
4824
 *	mptsas_broadcast_primative_work - Handle broadcast primitives
4825
 *	@work: work queue payload containing info describing the event
4826
 *
4827
 *	this will be handled in workqueue context.
4828
 */
4829
static void
4830
mptsas_broadcast_primative_work(struct fw_event_work *fw_event)
4831
{
4832
	MPT_ADAPTER *ioc = fw_event->ioc;
4833
	MPT_FRAME_HDR	*mf;
4834
	VirtDevice	*vdevice;
4835
	int			ii;
4836
	struct scsi_cmnd	*sc;
4837
	SCSITaskMgmtReply_t	*pScsiTmReply;
4838
	u8			issue_reset;
4839
	int			task_context;
4840
	u8			channel, id;
4841
	int			 lun;
4842
	u32			 termination_count;
4843
	u32			 query_count;
4844

4845
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4846
	    "%s - enter\n", ioc->name, __func__));
4847

4848
	mutex_lock(&ioc->taskmgmt_cmds.mutex);
4849
	if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4850
		mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4851
		mptsas_requeue_fw_event(ioc, fw_event, 1000);
4852
		return;
4853
	}
4854

4855
	issue_reset = 0;
4856
	termination_count = 0;
4857
	query_count = 0;
4858
	mpt_findImVolumes(ioc);
4859
	pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
4860

4861
	for (ii = 0; ii < ioc->req_depth; ii++) {
4862
		if (ioc->fw_events_off)
4863
			goto out;
4864
		sc = mptscsih_get_scsi_lookup(ioc, ii);
4865
		if (!sc)
4866
			continue;
4867
		mf = MPT_INDEX_2_MFPTR(ioc, ii);
4868
		if (!mf)
4869
			continue;
4870
		task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
4871
		vdevice = sc->device->hostdata;
4872
		if (!vdevice || !vdevice->vtarget)
4873
			continue;
4874
		if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
4875
			continue; /* skip hidden raid components */
4876
		if (vdevice->vtarget->raidVolume)
4877
			continue; /* skip hidden raid components */
4878
		channel = vdevice->vtarget->channel;
4879
		id = vdevice->vtarget->id;
4880
		lun = vdevice->lun;
4881
		if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
4882
		    channel, id, (u64)lun, task_context, 30, &issue_reset))
4883
			goto out;
4884
		query_count++;
4885
		termination_count +=
4886
		    le32_to_cpu(pScsiTmReply->TerminationCount);
4887
		if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
4888
		    (pScsiTmReply->ResponseCode ==
4889
		    MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
4890
		    pScsiTmReply->ResponseCode ==
4891
		    MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
4892
			continue;
4893
		if (mptsas_issue_tm(ioc,
4894
		    MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
4895
		    channel, id, (u64)lun, 0, 30, &issue_reset))
4896
			goto out;
4897
		termination_count +=
4898
		    le32_to_cpu(pScsiTmReply->TerminationCount);
4899
	}
4900

4901
 out:
4902
	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
4903
	    "%s - exit, query_count = %d termination_count = %d\n",
4904
	    ioc->name, __func__, query_count, termination_count));
4905

4906
	ioc->broadcast_aen_busy = 0;
4907
	mpt_clear_taskmgmt_in_progress_flag(ioc);
4908
	mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4909

4910
	if (issue_reset) {
4911
		printk(MYIOC_s_WARN_FMT
4912
		       "Issuing Reset from %s!! doorbell=0x%08x\n",
4913
		       ioc->name, __func__, mpt_GetIocState(ioc, 0));
4914
		mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP);
4915
	}
4916
	mptsas_free_fw_event(ioc, fw_event);
4917
}
4918

4919
/*
4920
 * mptsas_send_ir2_event - handle exposing hidden disk when
4921
 * an inactive raid volume is added
4922
 *
4923
 * @ioc: Pointer to MPT_ADAPTER structure
4924
 * @ir2_data
4925
 *
4926
 */
4927
static void
4928
mptsas_send_ir2_event(struct fw_event_work *fw_event)
4929
{
4930
	MPT_ADAPTER	*ioc;
4931
	struct mptsas_hotplug_event hot_plug_info;
4932
	MPI_EVENT_DATA_IR2	*ir2_data;
4933
	u8 reasonCode;
4934
	RaidPhysDiskPage0_t phys_disk;
4935

4936
	ioc = fw_event->ioc;
4937
	ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
4938
	reasonCode = ir2_data->ReasonCode;
4939

4940
	devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: "
4941
	    "ReasonCode=%02x\n", ioc->name, __func__, reasonCode));
4942

4943
	memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
4944
	hot_plug_info.id = ir2_data->TargetID;
4945
	hot_plug_info.channel = ir2_data->Bus;
4946
	switch (reasonCode) {
4947
	case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
4948
		hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
4949
		break;
4950
	case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
4951
		hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4952
		hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
4953
		break;
4954
	case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
4955
		hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
4956
		mpt_raid_phys_disk_pg0(ioc,
4957
		    ir2_data->PhysDiskNum, &phys_disk);
4958
		hot_plug_info.id = phys_disk.PhysDiskID;
4959
		hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
4960
		break;
4961
	default:
4962
		mptsas_free_fw_event(ioc, fw_event);
4963
		return;
4964
	}
4965
	mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
4966
}
4967

4968
static int
4969
mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
4970
{
4971
	u32 event = le32_to_cpu(reply->Event);
4972
	int sz, event_data_sz;
4973
	struct fw_event_work *fw_event;
4974
	unsigned long delay;
4975

4976
	if (ioc->bus_type != SAS)
4977
		return 0;
4978

4979
	/* events turned off due to host reset or driver unloading */
4980
	if (ioc->fw_events_off)
4981
		return 0;
4982

4983
	delay = msecs_to_jiffies(1);
4984
	switch (event) {
4985
	case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
4986
	{
4987
		EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
4988
		    (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
4989
		if (broadcast_event_data->Primitive !=
4990
		    MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
4991
			return 0;
4992
		if (ioc->broadcast_aen_busy)
4993
			return 0;
4994
		ioc->broadcast_aen_busy = 1;
4995
		break;
4996
	}
4997
	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
4998
	{
4999
		EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
5000
		    (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
5001
		u16	ioc_stat;
5002
		ioc_stat = le16_to_cpu(reply->IOCStatus);
5003

5004
		if (sas_event_data->ReasonCode ==
5005
		    MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
5006
			mptsas_target_reset_queue(ioc, sas_event_data);
5007
			return 0;
5008
		}
5009
		if (sas_event_data->ReasonCode ==
5010
			MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
5011
			ioc->device_missing_delay &&
5012
			(ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
5013
			VirtTarget *vtarget = NULL;
5014
			u8		id, channel;
5015

5016
			id = sas_event_data->TargetID;
5017
			channel = sas_event_data->Bus;
5018

5019
			vtarget = mptsas_find_vtarget(ioc, channel, id);
5020
			if (vtarget) {
5021
				devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5022
				    "LogInfo (0x%x) available for "
5023
				   "INTERNAL_DEVICE_RESET"
5024
				   "fw_id %d fw_channel %d\n", ioc->name,
5025
				   le32_to_cpu(reply->IOCLogInfo),
5026
				   id, channel));
5027
				if (vtarget->raidVolume) {
5028
					devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5029
					"Skipping Raid Volume for inDMD\n",
5030
					ioc->name));
5031
				} else {
5032
					devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5033
					"Setting device flag inDMD\n",
5034
					ioc->name));
5035
					vtarget->inDMD = 1;
5036
				}
5037

5038
			}
5039

5040
		}
5041

5042
		break;
5043
	}
5044
	case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
5045
	{
5046
		MpiEventDataSasExpanderStatusChange_t *expander_data =
5047
		    (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
5048

5049
		if (ioc->old_sas_discovery_protocal)
5050
			return 0;
5051

5052
		if (expander_data->ReasonCode ==
5053
		    MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
5054
		    ioc->device_missing_delay)
5055
			delay = HZ * ioc->device_missing_delay;
5056
		break;
5057
	}
5058
	case MPI_EVENT_SAS_DISCOVERY:
5059
	{
5060
		u32 discovery_status;
5061
		EventDataSasDiscovery_t *discovery_data =
5062
		    (EventDataSasDiscovery_t *)reply->Data;
5063

5064
		discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
5065
		ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
5066
		if (ioc->old_sas_discovery_protocal && !discovery_status)
5067
			mptsas_queue_rescan(ioc);
5068
		return 0;
5069
	}
5070
	case MPI_EVENT_INTEGRATED_RAID:
5071
	case MPI_EVENT_PERSISTENT_TABLE_FULL:
5072
	case MPI_EVENT_IR2:
5073
	case MPI_EVENT_SAS_PHY_LINK_STATUS:
5074
	case MPI_EVENT_QUEUE_FULL:
5075
		break;
5076
	default:
5077
		return 0;
5078
	}
5079

5080
	event_data_sz = ((reply->MsgLength * 4) -
5081
	    offsetof(EventNotificationReply_t, Data));
5082
	sz = offsetof(struct fw_event_work, event_data) + event_data_sz;
5083
	fw_event = kzalloc(sz, GFP_ATOMIC);
5084
	if (!fw_event) {
5085
		printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
5086
		 __func__, __LINE__);
5087
		return 0;
5088
	}
5089
	memcpy(fw_event->event_data, reply->Data, event_data_sz);
5090
	fw_event->event = event;
5091
	fw_event->ioc = ioc;
5092
	mptsas_add_fw_event(ioc, fw_event, delay);
5093
	return 0;
5094
}
5095

5096
/* Delete a volume when no longer listed in ioc pg2
5097
 */
5098
static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
5099
{
5100
	struct scsi_device *sdev;
5101
	int i;
5102

5103
	sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
5104
	if (!sdev)
5105
		return;
5106
	if (!ioc->raid_data.pIocPg2)
5107
		goto out;
5108
	if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
5109
		goto out;
5110
	for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
5111
		if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
5112
			goto release_sdev;
5113
 out:
5114
	printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
5115
	    "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id);
5116
	scsi_remove_device(sdev);
5117
 release_sdev:
5118
	scsi_device_put(sdev);
5119
}
5120

5121
static int
5122
mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
5123
{
5124
	struct Scsi_Host	*sh;
5125
	MPT_SCSI_HOST		*hd;
5126
	MPT_ADAPTER 		*ioc;
5127
	unsigned long		 flags;
5128
	int			 ii;
5129
	int			 numSGE = 0;
5130
	int			 scale;
5131
	int			 ioc_cap;
5132
	int			error=0;
5133
	int			r;
5134

5135
	r = mpt_attach(pdev,id);
5136
	if (r)
5137
		return r;
5138

5139
	ioc = pci_get_drvdata(pdev);
5140
	mptsas_fw_event_off(ioc);
5141
	ioc->DoneCtx = mptsasDoneCtx;
5142
	ioc->TaskCtx = mptsasTaskCtx;
5143
	ioc->InternalCtx = mptsasInternalCtx;
5144
	ioc->schedule_target_reset = &mptsas_schedule_target_reset;
5145
	/*  Added sanity check on readiness of the MPT adapter.
5146
	 */
5147
	if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
5148
		printk(MYIOC_s_WARN_FMT
5149
		  "Skipping because it's not operational!\n",
5150
		  ioc->name);
5151
		error = -ENODEV;
5152
		goto out_mptsas_probe;
5153
	}
5154

5155
	if (!ioc->active) {
5156
		printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
5157
		  ioc->name);
5158
		error = -ENODEV;
5159
		goto out_mptsas_probe;
5160
	}
5161

5162
	/*  Sanity check - ensure at least 1 port is INITIATOR capable
5163
	 */
5164
	ioc_cap = 0;
5165
	for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
5166
		if (ioc->pfacts[ii].ProtocolFlags &
5167
				MPI_PORTFACTS_PROTOCOL_INITIATOR)
5168
			ioc_cap++;
5169
	}
5170

5171
	if (!ioc_cap) {
5172
		printk(MYIOC_s_WARN_FMT
5173
			"Skipping ioc=%p because SCSI Initiator mode "
5174
			"is NOT enabled!\n", ioc->name, ioc);
5175
		return 0;
5176
	}
5177

5178
	sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
5179
	if (!sh) {
5180
		printk(MYIOC_s_WARN_FMT
5181
			"Unable to register controller with SCSI subsystem\n",
5182
			ioc->name);
5183
		error = -1;
5184
		goto out_mptsas_probe;
5185
        }
5186

5187
	spin_lock_irqsave(&ioc->FreeQlock, flags);
5188

5189
	/* Attach the SCSI Host to the IOC structure
5190
	 */
5191
	ioc->sh = sh;
5192

5193
	sh->io_port = 0;
5194
	sh->n_io_port = 0;
5195
	sh->irq = 0;
5196

5197
	/* set 16 byte cdb's */
5198
	sh->max_cmd_len = 16;
5199
	sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
5200
	sh->max_id = -1;
5201
	sh->max_lun = max_lun;
5202
	sh->transportt = mptsas_transport_template;
5203

5204
	/* Required entry.
5205
	 */
5206
	sh->unique_id = ioc->id;
5207

5208
	INIT_LIST_HEAD(&ioc->sas_topology);
5209
	mutex_init(&ioc->sas_topology_mutex);
5210
	mutex_init(&ioc->sas_discovery_mutex);
5211
	mutex_init(&ioc->sas_mgmt.mutex);
5212
	init_completion(&ioc->sas_mgmt.done);
5213

5214
	/* Verify that we won't exceed the maximum
5215
	 * number of chain buffers
5216
	 * We can optimize:  ZZ = req_sz/sizeof(SGE)
5217
	 * For 32bit SGE's:
5218
	 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
5219
	 *               + (req_sz - 64)/sizeof(SGE)
5220
	 * A slightly different algorithm is required for
5221
	 * 64bit SGEs.
5222
	 */
5223
	scale = ioc->req_sz/ioc->SGE_size;
5224
	if (ioc->sg_addr_size == sizeof(u64)) {
5225
		numSGE = (scale - 1) *
5226
		  (ioc->facts.MaxChainDepth-1) + scale +
5227
		  (ioc->req_sz - 60) / ioc->SGE_size;
5228
	} else {
5229
		numSGE = 1 + (scale - 1) *
5230
		  (ioc->facts.MaxChainDepth-1) + scale +
5231
		  (ioc->req_sz - 64) / ioc->SGE_size;
5232
	}
5233

5234
	if (numSGE < sh->sg_tablesize) {
5235
		/* Reset this value */
5236
		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5237
		  "Resetting sg_tablesize to %d from %d\n",
5238
		  ioc->name, numSGE, sh->sg_tablesize));
5239
		sh->sg_tablesize = numSGE;
5240
	}
5241

5242
	hd = shost_priv(sh);
5243
	hd->ioc = ioc;
5244

5245
	/* SCSI needs scsi_cmnd lookup table!
5246
	 * (with size equal to req_depth*PtrSz!)
5247
	 */
5248
	ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
5249
	if (!ioc->ScsiLookup) {
5250
		error = -ENOMEM;
5251
		spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5252
		goto out_mptsas_probe;
5253
	}
5254
	spin_lock_init(&ioc->scsi_lookup_lock);
5255

5256
	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
5257
		 ioc->name, ioc->ScsiLookup));
5258

5259
	ioc->sas_data.ptClear = mpt_pt_clear;
5260

5261
	hd->last_queue_full = 0;
5262
	INIT_LIST_HEAD(&hd->target_reset_list);
5263
	INIT_LIST_HEAD(&ioc->sas_device_info_list);
5264
	mutex_init(&ioc->sas_device_info_mutex);
5265

5266
	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5267

5268
	if (ioc->sas_data.ptClear==1) {
5269
		mptbase_sas_persist_operation(
5270
		    ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
5271
	}
5272

5273
	error = scsi_add_host(sh, &ioc->pcidev->dev);
5274
	if (error) {
5275
		dprintk(ioc, printk(MYIOC_s_ERR_FMT
5276
		  "scsi_add_host failed\n", ioc->name));
5277
		goto out_mptsas_probe;
5278
	}
5279

5280
	/* older firmware doesn't support expander events */
5281
	if ((ioc->facts.HeaderVersion >> 8) < 0xE)
5282
		ioc->old_sas_discovery_protocal = 1;
5283
	mptsas_scan_sas_topology(ioc);
5284
	mptsas_fw_event_on(ioc);
5285
	return 0;
5286

5287
 out_mptsas_probe:
5288

5289
	mptscsih_remove(pdev);
5290
	return error;
5291
}
5292

5293
void
5294
mptsas_shutdown(struct pci_dev *pdev)
5295
{
5296
	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5297

5298
	mptsas_fw_event_off(ioc);
5299
	mptsas_cleanup_fw_event_q(ioc);
5300
}
5301

5302
static void __devexit mptsas_remove(struct pci_dev *pdev)
5303
{
5304
	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
5305
	struct mptsas_portinfo *p, *n;
5306
	int i;
5307

5308
	if (!ioc->sh) {
5309
		printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name);
5310
		mpt_detach(pdev);
5311
		return;
5312
	}
5313

5314
	mptsas_shutdown(pdev);
5315

5316
	mptsas_del_device_components(ioc);
5317

5318
	ioc->sas_discovery_ignore_events = 1;
5319
	sas_remove_host(ioc->sh);
5320

5321
	mutex_lock(&ioc->sas_topology_mutex);
5322
	list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
5323
		list_del(&p->list);
5324
		for (i = 0 ; i < p->num_phys ; i++)
5325
			mptsas_port_delete(ioc, p->phy_info[i].port_details);
5326

5327
		kfree(p->phy_info);
5328
		kfree(p);
5329
	}
5330
	mutex_unlock(&ioc->sas_topology_mutex);
5331
	ioc->hba_port_info = NULL;
5332
	mptscsih_remove(pdev);
5333
}
5334

5335
static struct pci_device_id mptsas_pci_table[] = {
5336
	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
5337
		PCI_ANY_ID, PCI_ANY_ID },
5338
	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
5339
		PCI_ANY_ID, PCI_ANY_ID },
5340
	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
5341
		PCI_ANY_ID, PCI_ANY_ID },
5342
	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
5343
		PCI_ANY_ID, PCI_ANY_ID },
5344
	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
5345
		PCI_ANY_ID, PCI_ANY_ID },
5346
	{0}	/* Terminating entry */
5347
};
5348
MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
5349

5350

5351
static struct pci_driver mptsas_driver = {
5352
	.name		= "mptsas",
5353
	.id_table	= mptsas_pci_table,
5354
	.probe		= mptsas_probe,
5355
	.remove		= __devexit_p(mptsas_remove),
5356
	.shutdown	= mptsas_shutdown,
5357
#ifdef CONFIG_PM
5358
	.suspend	= mptscsih_suspend,
5359
	.resume		= mptscsih_resume,
5360
#endif
5361
};
5362

5363
static int __init
5364
mptsas_init(void)
5365
{
5366
	int error;
5367

5368
	show_mptmod_ver(my_NAME, my_VERSION);
5369

5370
	mptsas_transport_template =
5371
	    sas_attach_transport(&mptsas_transport_functions);
5372
	if (!mptsas_transport_template)
5373
		return -ENODEV;
5374
	mptsas_transport_template->eh_timed_out = mptsas_eh_timed_out;
5375

5376
	mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER,
5377
	    "mptscsih_io_done");
5378
	mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER,
5379
	    "mptscsih_taskmgmt_complete");
5380
	mptsasInternalCtx =
5381
		mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER,
5382
		    "mptscsih_scandv_complete");
5383
	mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER,
5384
	    "mptsas_mgmt_done");
5385
	mptsasDeviceResetCtx =
5386
		mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER,
5387
		    "mptsas_taskmgmt_complete");
5388

5389
	mpt_event_register(mptsasDoneCtx, mptsas_event_process);
5390
	mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
5391

5392
	error = pci_register_driver(&mptsas_driver);
5393
	if (error)
5394
		sas_release_transport(mptsas_transport_template);
5395

5396
	return error;
5397
}
5398

5399
static void __exit
5400
mptsas_exit(void)
5401
{
5402
	pci_unregister_driver(&mptsas_driver);
5403
	sas_release_transport(mptsas_transport_template);
5404

5405
	mpt_reset_deregister(mptsasDoneCtx);
5406
	mpt_event_deregister(mptsasDoneCtx);
5407

5408
	mpt_deregister(mptsasMgmtCtx);
5409
	mpt_deregister(mptsasInternalCtx);
5410
	mpt_deregister(mptsasTaskCtx);
5411
	mpt_deregister(mptsasDoneCtx);
5412
	mpt_deregister(mptsasDeviceResetCtx);
5413
}
5414

5415
module_init(mptsas_init);
5416
module_exit(mptsas_exit);
5417

5418
Product

Resources

Company
