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