projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[deliverable/linux.git] / drivers / message / fusion / mptsas.c
1 /*
2 * linux/drivers/message/fusion/mptsas.c
3 * For use with LSI Logic PCI chip/adapter(s)
4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
5 *
6 * Copyright (c) 1999-2007 LSI Logic Corporation
7 * (mailto:mpt_linux_developer@lsi.com)
8 * Copyright (c) 2005-2007 Dell
9 */
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11 /*
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; version 2 of the License.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 NO WARRANTY
22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26 solely responsible for determining the appropriateness of using and
27 distributing the Program and assumes all risks associated with its
28 exercise of rights under this Agreement, including but not limited to
29 the risks and costs of program errors, damage to or loss of data,
30 programs or equipment, and unavailability or interruption of operations.
31
32 DISCLAIMER OF LIABILITY
33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40
41 You should have received a copy of the GNU General Public License
42 along with this program; if not, write to the Free Software
43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44 */
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/init.h>
50 #include <linux/errno.h>
51 #include <linux/jiffies.h>
52 #include <linux/workqueue.h>
53 #include <linux/delay.h> /* for mdelay */
54
55 #include <scsi/scsi.h>
56 #include <scsi/scsi_cmnd.h>
57 #include <scsi/scsi_device.h>
58 #include <scsi/scsi_host.h>
59 #include <scsi/scsi_transport_sas.h>
60 #include <scsi/scsi_dbg.h>
61
62 #include "mptbase.h"
63 #include "mptscsih.h"
64
65
66 #define my_NAME "Fusion MPT SAS Host driver"
67 #define my_VERSION MPT_LINUX_VERSION_COMMON
68 #define MYNAM "mptsas"
69
70 /*
71 * Reserved channel for integrated raid
72 */
73 #define MPTSAS_RAID_CHANNEL 1
74
75 MODULE_AUTHOR(MODULEAUTHOR);
76 MODULE_DESCRIPTION(my_NAME);
77 MODULE_LICENSE("GPL");
78 MODULE_VERSION(my_VERSION);
79
80 static int mpt_pt_clear;
81 module_param(mpt_pt_clear, int, 0);
82 MODULE_PARM_DESC(mpt_pt_clear,
83 " Clear persistency table: enable=1 "
84 "(default=MPTSCSIH_PT_CLEAR=0)");
85
86 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
87 #define MPTSAS_MAX_LUN (16895)
88 static int max_lun = MPTSAS_MAX_LUN;
89 module_param(max_lun, int, 0);
90 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
91
92 static int mptsasDoneCtx = -1;
93 static int mptsasTaskCtx = -1;
94 static int mptsasInternalCtx = -1; /* Used only for internal commands */
95 static int mptsasMgmtCtx = -1;
96
97 static void mptsas_hotplug_work(struct work_struct *work);
98
99 struct mptsas_target_reset_event {
100 struct list_head list;
101 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE sas_event_data;
102 u8 target_reset_issued;
103 };
104
105 enum mptsas_hotplug_action {
106 MPTSAS_ADD_DEVICE,
107 MPTSAS_DEL_DEVICE,
108 MPTSAS_ADD_RAID,
109 MPTSAS_DEL_RAID,
110 MPTSAS_ADD_INACTIVE_VOLUME,
111 MPTSAS_IGNORE_EVENT,
112 };
113
114 struct mptsas_hotplug_event {
115 struct work_struct work;
116 MPT_ADAPTER *ioc;
117 enum mptsas_hotplug_action event_type;
118 u64 sas_address;
119 u8 channel;
120 u8 id;
121 u32 device_info;
122 u16 handle;
123 u16 parent_handle;
124 u8 phy_id;
125 u8 phys_disk_num_valid; /* hrc (hidden raid component) */
126 u8 phys_disk_num; /* hrc - unique index*/
127 u8 hidden_raid_component; /* hrc - don't expose*/
128 };
129
130 struct mptsas_discovery_event {
131 struct work_struct work;
132 MPT_ADAPTER *ioc;
133 };
134
135 /*
136 * SAS topology structures
137 *
138 * The MPT Fusion firmware interface spreads information about the
139 * SAS topology over many manufacture pages, thus we need some data
140 * structure to collect it and process it for the SAS transport class.
141 */
142
143 struct mptsas_devinfo {
144 u16 handle; /* unique id to address this device */
145 u16 handle_parent; /* unique id to address parent device */
146 u16 handle_enclosure; /* enclosure identifier of the enclosure */
147 u16 slot; /* physical slot in enclosure */
148 u8 phy_id; /* phy number of parent device */
149 u8 port_id; /* sas physical port this device
150 is assoc'd with */
151 u8 id; /* logical target id of this device */
152 u32 phys_disk_num; /* phys disk id, for csmi-ioctls */
153 u8 channel; /* logical bus number of this device */
154 u64 sas_address; /* WWN of this device,
155 SATA is assigned by HBA,expander */
156 u32 device_info; /* bitfield detailed info about this device */
157 };
158
159 /*
160 * Specific details on ports, wide/narrow
161 */
162 struct mptsas_portinfo_details{
163 u16 num_phys; /* number of phys belong to this port */
164 u64 phy_bitmask; /* TODO, extend support for 255 phys */
165 struct sas_rphy *rphy; /* transport layer rphy object */
166 struct sas_port *port; /* transport layer port object */
167 struct scsi_target *starget;
168 struct mptsas_portinfo *port_info;
169 };
170
171 struct mptsas_phyinfo {
172 u16 handle; /* unique id to address this */
173 u8 phy_id; /* phy index */
174 u8 port_id; /* firmware port identifier */
175 u8 negotiated_link_rate; /* nego'd link rate for this phy */
176 u8 hw_link_rate; /* hardware max/min phys link rate */
177 u8 programmed_link_rate; /* programmed max/min phy link rate */
178 u8 sas_port_add_phy; /* flag to request sas_port_add_phy*/
179 struct mptsas_devinfo identify; /* point to phy device info */
180 struct mptsas_devinfo attached; /* point to attached device info */
181 struct sas_phy *phy; /* transport layer phy object */
182 struct mptsas_portinfo *portinfo;
183 struct mptsas_portinfo_details * port_details;
184 };
185
186 struct mptsas_portinfo {
187 struct list_head list;
188 u16 num_phys; /* number of phys */
189 struct mptsas_phyinfo *phy_info;
190 };
191
192 struct mptsas_enclosure {
193 u64 enclosure_logical_id; /* The WWN for the enclosure */
194 u16 enclosure_handle; /* unique id to address this */
195 u16 flags; /* details enclosure management */
196 u16 num_slot; /* num slots */
197 u16 start_slot; /* first slot */
198 u8 start_id; /* starting logical target id */
199 u8 start_channel; /* starting logical channel id */
200 u8 sep_id; /* SEP device logical target id */
201 u8 sep_channel; /* SEP channel logical channel id */
202 };
203
204 #ifdef MPT_DEBUG_SAS
205 static void mptsas_print_phy_data(MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
206 {
207 printk("---- IO UNIT PAGE 0 ------------\n");
208 printk("Handle=0x%X\n",
209 le16_to_cpu(phy_data->AttachedDeviceHandle));
210 printk("Controller Handle=0x%X\n",
211 le16_to_cpu(phy_data->ControllerDevHandle));
212 printk("Port=0x%X\n", phy_data->Port);
213 printk("Port Flags=0x%X\n", phy_data->PortFlags);
214 printk("PHY Flags=0x%X\n", phy_data->PhyFlags);
215 printk("Negotiated Link Rate=0x%X\n", phy_data->NegotiatedLinkRate);
216 printk("Controller PHY Device Info=0x%X\n",
217 le32_to_cpu(phy_data->ControllerPhyDeviceInfo));
218 printk("DiscoveryStatus=0x%X\n",
219 le32_to_cpu(phy_data->DiscoveryStatus));
220 printk("\n");
221 }
222
223 static void mptsas_print_phy_pg0(SasPhyPage0_t *pg0)
224 {
225 __le64 sas_address;
226
227 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
228
229 printk("---- SAS PHY PAGE 0 ------------\n");
230 printk("Attached Device Handle=0x%X\n",
231 le16_to_cpu(pg0->AttachedDevHandle));
232 printk("SAS Address=0x%llX\n",
233 (unsigned long long)le64_to_cpu(sas_address));
234 printk("Attached PHY Identifier=0x%X\n", pg0->AttachedPhyIdentifier);
235 printk("Attached Device Info=0x%X\n",
236 le32_to_cpu(pg0->AttachedDeviceInfo));
237 printk("Programmed Link Rate=0x%X\n", pg0->ProgrammedLinkRate);
238 printk("Change Count=0x%X\n", pg0->ChangeCount);
239 printk("PHY Info=0x%X\n", le32_to_cpu(pg0->PhyInfo));
240 printk("\n");
241 }
242
243 static void mptsas_print_phy_pg1(SasPhyPage1_t *pg1)
244 {
245 printk("---- SAS PHY PAGE 1 ------------\n");
246 printk("Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount);
247 printk("Running Disparity Error Count=0x%x\n",
248 pg1->RunningDisparityErrorCount);
249 printk("Loss Dword Synch Count=0x%x\n", pg1->LossDwordSynchCount);
250 printk("PHY Reset Problem Count=0x%x\n", pg1->PhyResetProblemCount);
251 printk("\n");
252 }
253
254 static void mptsas_print_device_pg0(SasDevicePage0_t *pg0)
255 {
256 __le64 sas_address;
257
258 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
259
260 printk("---- SAS DEVICE PAGE 0 ---------\n");
261 printk("Handle=0x%X\n" ,le16_to_cpu(pg0->DevHandle));
262 printk("Parent Handle=0x%X\n" ,le16_to_cpu(pg0->ParentDevHandle));
263 printk("Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle));
264 printk("Slot=0x%X\n", le16_to_cpu(pg0->Slot));
265 printk("SAS Address=0x%llX\n", (unsigned long long)
266 le64_to_cpu(sas_address));
267 printk("Target ID=0x%X\n", pg0->TargetID);
268 printk("Bus=0x%X\n", pg0->Bus);
269 /* The PhyNum field specifies the PHY number of the parent
270 * device this device is linked to
271 */
272 printk("Parent Phy Num=0x%X\n", pg0->PhyNum);
273 printk("Access Status=0x%X\n", le16_to_cpu(pg0->AccessStatus));
274 printk("Device Info=0x%X\n", le32_to_cpu(pg0->DeviceInfo));
275 printk("Flags=0x%X\n", le16_to_cpu(pg0->Flags));
276 printk("Physical Port=0x%X\n", pg0->PhysicalPort);
277 printk("\n");
278 }
279
280 static void mptsas_print_expander_pg1(SasExpanderPage1_t *pg1)
281 {
282 printk("---- SAS EXPANDER PAGE 1 ------------\n");
283
284 printk("Physical Port=0x%X\n", pg1->PhysicalPort);
285 printk("PHY Identifier=0x%X\n", pg1->PhyIdentifier);
286 printk("Negotiated Link Rate=0x%X\n", pg1->NegotiatedLinkRate);
287 printk("Programmed Link Rate=0x%X\n", pg1->ProgrammedLinkRate);
288 printk("Hardware Link Rate=0x%X\n", pg1->HwLinkRate);
289 printk("Owner Device Handle=0x%X\n",
290 le16_to_cpu(pg1->OwnerDevHandle));
291 printk("Attached Device Handle=0x%X\n",
292 le16_to_cpu(pg1->AttachedDevHandle));
293 }
294 #else
295 #define mptsas_print_phy_data(phy_data) do { } while (0)
296 #define mptsas_print_phy_pg0(pg0) do { } while (0)
297 #define mptsas_print_phy_pg1(pg1) do { } while (0)
298 #define mptsas_print_device_pg0(pg0) do { } while (0)
299 #define mptsas_print_expander_pg1(pg1) do { } while (0)
300 #endif
301
302 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
303 {
304 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
305 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
306 }
307
308 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
309 {
310 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
311 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
312 }
313
314 /*
315 * mptsas_find_portinfo_by_handle
316 *
317 * This function should be called with the sas_topology_mutex already held
318 */
319 static struct mptsas_portinfo *
320 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
321 {
322 struct mptsas_portinfo *port_info, *rc=NULL;
323 int i;
324
325 list_for_each_entry(port_info, &ioc->sas_topology, list)
326 for (i = 0; i < port_info->num_phys; i++)
327 if (port_info->phy_info[i].identify.handle == handle) {
328 rc = port_info;
329 goto out;
330 }
331 out:
332 return rc;
333 }
334
335 /*
336 * Returns true if there is a scsi end device
337 */
338 static inline int
339 mptsas_is_end_device(struct mptsas_devinfo * attached)
340 {
341 if ((attached->sas_address) &&
342 (attached->device_info &
343 MPI_SAS_DEVICE_INFO_END_DEVICE) &&
344 ((attached->device_info &
345 MPI_SAS_DEVICE_INFO_SSP_TARGET) |
346 (attached->device_info &
347 MPI_SAS_DEVICE_INFO_STP_TARGET) |
348 (attached->device_info &
349 MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
350 return 1;
351 else
352 return 0;
353 }
354
355 /* no mutex */
356 static void
357 mptsas_port_delete(struct mptsas_portinfo_details * port_details)
358 {
359 struct mptsas_portinfo *port_info;
360 struct mptsas_phyinfo *phy_info;
361 u8 i;
362
363 if (!port_details)
364 return;
365
366 port_info = port_details->port_info;
367 phy_info = port_info->phy_info;
368
369 dsaswideprintk((KERN_DEBUG "%s: [%p]: num_phys=%02d "
370 "bitmask=0x%016llX\n", __FUNCTION__, port_details,
371 port_details->num_phys, (unsigned long long)
372 port_details->phy_bitmask));
373
374 for (i = 0; i < port_info->num_phys; i++, phy_info++) {
375 if(phy_info->port_details != port_details)
376 continue;
377 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
378 phy_info->port_details = NULL;
379 }
380 kfree(port_details);
381 }
382
383 static inline struct sas_rphy *
384 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
385 {
386 if (phy_info->port_details)
387 return phy_info->port_details->rphy;
388 else
389 return NULL;
390 }
391
392 static inline void
393 mptsas_set_rphy(struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
394 {
395 if (phy_info->port_details) {
396 phy_info->port_details->rphy = rphy;
397 dsaswideprintk((KERN_DEBUG "sas_rphy_add: rphy=%p\n", rphy));
398 }
399
400 #ifdef MPT_DEBUG_SAS_WIDE
401 if (rphy) {
402 dev_printk(KERN_DEBUG, &rphy->dev, "add:");
403 printk("rphy=%p release=%p\n",
404 rphy, rphy->dev.release);
405 }
406 #endif
407 }
408
409 static inline struct sas_port *
410 mptsas_get_port(struct mptsas_phyinfo *phy_info)
411 {
412 if (phy_info->port_details)
413 return phy_info->port_details->port;
414 else
415 return NULL;
416 }
417
418 static inline void
419 mptsas_set_port(struct mptsas_phyinfo *phy_info, struct sas_port *port)
420 {
421 if (phy_info->port_details)
422 phy_info->port_details->port = port;
423
424 #ifdef MPT_DEBUG_SAS_WIDE
425 if (port) {
426 dev_printk(KERN_DEBUG, &port->dev, "add: ");
427 printk("port=%p release=%p\n",
428 port, port->dev.release);
429 }
430 #endif
431 }
432
433 static inline struct scsi_target *
434 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
435 {
436 if (phy_info->port_details)
437 return phy_info->port_details->starget;
438 else
439 return NULL;
440 }
441
442 static inline void
443 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
444 starget)
445 {
446 if (phy_info->port_details)
447 phy_info->port_details->starget = starget;
448 }
449
450
451 /*
452 * mptsas_setup_wide_ports
453 *
454 * Updates for new and existing narrow/wide port configuration
455 * in the sas_topology
456 */
457 static void
458 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
459 {
460 struct mptsas_portinfo_details * port_details;
461 struct mptsas_phyinfo *phy_info, *phy_info_cmp;
462 u64 sas_address;
463 int i, j;
464
465 mutex_lock(&ioc->sas_topology_mutex);
466
467 phy_info = port_info->phy_info;
468 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
469 if (phy_info->attached.handle)
470 continue;
471 port_details = phy_info->port_details;
472 if (!port_details)
473 continue;
474 if (port_details->num_phys < 2)
475 continue;
476 /*
477 * Removing a phy from a port, letting the last
478 * phy be removed by firmware events.
479 */
480 dsaswideprintk((KERN_DEBUG
481 "%s: [%p]: deleting phy = %d\n",
482 __FUNCTION__, port_details, i));
483 port_details->num_phys--;
484 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
485 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
486 sas_port_delete_phy(port_details->port, phy_info->phy);
487 phy_info->port_details = NULL;
488 }
489
490 /*
491 * Populate and refresh the tree
492 */
493 phy_info = port_info->phy_info;
494 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
495 sas_address = phy_info->attached.sas_address;
496 dsaswideprintk((KERN_DEBUG "phy_id=%d sas_address=0x%018llX\n",
497 i, (unsigned long long)sas_address));
498 if (!sas_address)
499 continue;
500 port_details = phy_info->port_details;
501 /*
502 * Forming a port
503 */
504 if (!port_details) {
505 port_details = kzalloc(sizeof(*port_details),
506 GFP_KERNEL);
507 if (!port_details)
508 goto out;
509 port_details->num_phys = 1;
510 port_details->port_info = port_info;
511 if (phy_info->phy_id < 64 )
512 port_details->phy_bitmask |=
513 (1 << phy_info->phy_id);
514 phy_info->sas_port_add_phy=1;
515 dsaswideprintk((KERN_DEBUG "\t\tForming port\n\t\t"
516 "phy_id=%d sas_address=0x%018llX\n",
517 i, (unsigned long long)sas_address));
518 phy_info->port_details = port_details;
519 }
520
521 if (i == port_info->num_phys - 1)
522 continue;
523 phy_info_cmp = &port_info->phy_info[i + 1];
524 for (j = i + 1 ; j < port_info->num_phys ; j++,
525 phy_info_cmp++) {
526 if (!phy_info_cmp->attached.sas_address)
527 continue;
528 if (sas_address != phy_info_cmp->attached.sas_address)
529 continue;
530 if (phy_info_cmp->port_details == port_details )
531 continue;
532 dsaswideprintk((KERN_DEBUG
533 "\t\tphy_id=%d sas_address=0x%018llX\n",
534 j, (unsigned long long)
535 phy_info_cmp->attached.sas_address));
536 if (phy_info_cmp->port_details) {
537 port_details->rphy =
538 mptsas_get_rphy(phy_info_cmp);
539 port_details->port =
540 mptsas_get_port(phy_info_cmp);
541 port_details->starget =
542 mptsas_get_starget(phy_info_cmp);
543 port_details->num_phys =
544 phy_info_cmp->port_details->num_phys;
545 if (!phy_info_cmp->port_details->num_phys)
546 kfree(phy_info_cmp->port_details);
547 } else
548 phy_info_cmp->sas_port_add_phy=1;
549 /*
550 * Adding a phy to a port
551 */
552 phy_info_cmp->port_details = port_details;
553 if (phy_info_cmp->phy_id < 64 )
554 port_details->phy_bitmask |=
555 (1 << phy_info_cmp->phy_id);
556 port_details->num_phys++;
557 }
558 }
559
560 out:
561
562 #ifdef MPT_DEBUG_SAS_WIDE
563 for (i = 0; i < port_info->num_phys; i++) {
564 port_details = port_info->phy_info[i].port_details;
565 if (!port_details)
566 continue;
567 dsaswideprintk((KERN_DEBUG
568 "%s: [%p]: phy_id=%02d num_phys=%02d "
569 "bitmask=0x%016llX\n", __FUNCTION__,
570 port_details, i, port_details->num_phys,
571 (unsigned long long)port_details->phy_bitmask));
572 dsaswideprintk((KERN_DEBUG"\t\tport = %p rphy=%p\n",
573 port_details->port, port_details->rphy));
574 }
575 dsaswideprintk((KERN_DEBUG"\n"));
576 #endif
577 mutex_unlock(&ioc->sas_topology_mutex);
578 }
579
580 /**
581 * csmisas_find_vtarget
582 *
583 * @ioc
584 * @volume_id
585 * @volume_bus
586 *
587 **/
588 static VirtTarget *
589 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
590 {
591 struct scsi_device *sdev;
592 VirtDevice *vdev;
593 VirtTarget *vtarget = NULL;
594
595 shost_for_each_device(sdev, ioc->sh) {
596 if ((vdev = sdev->hostdata) == NULL)
597 continue;
598 if (vdev->vtarget->id == id &&
599 vdev->vtarget->channel == channel)
600 vtarget = vdev->vtarget;
601 }
602 return vtarget;
603 }
604
605 /**
606 * mptsas_target_reset
607 *
608 * Issues TARGET_RESET to end device using handshaking method
609 *
610 * @ioc
611 * @channel
612 * @id
613 *
614 * Returns (1) success
615 * (0) failure
616 *
617 **/
618 static int
619 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
620 {
621 MPT_FRAME_HDR *mf;
622 SCSITaskMgmt_t *pScsiTm;
623
624 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
625 dfailprintk((MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
626 ioc->name,__FUNCTION__, __LINE__));
627 return 0;
628 }
629
630 /* Format the Request
631 */
632 pScsiTm = (SCSITaskMgmt_t *) mf;
633 memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
634 pScsiTm->TargetID = id;
635 pScsiTm->Bus = channel;
636 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
637 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
638 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
639
640 DBG_DUMP_TM_REQUEST_FRAME(mf);
641
642 if (mpt_send_handshake_request(ioc->TaskCtx, ioc,
643 sizeof(SCSITaskMgmt_t), (u32 *)mf, NO_SLEEP)) {
644 mpt_free_msg_frame(ioc, mf);
645 dfailprintk((MYIOC_s_WARN_FMT "%s, tm handshake failed @%d!!\n",
646 ioc->name,__FUNCTION__, __LINE__));
647 return 0;
648 }
649
650 return 1;
651 }
652
653 /**
654 * mptsas_target_reset_queue
655 *
656 * Receive request for TARGET_RESET after recieving an firmware
657 * event NOT_RESPONDING_EVENT, then put command in link list
658 * and queue if task_queue already in use.
659 *
660 * @ioc
661 * @sas_event_data
662 *
663 **/
664 static void
665 mptsas_target_reset_queue(MPT_ADAPTER *ioc,
666 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
667 {
668 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
669 VirtTarget *vtarget = NULL;
670 struct mptsas_target_reset_event *target_reset_list;
671 u8 id, channel;
672
673 id = sas_event_data->TargetID;
674 channel = sas_event_data->Bus;
675
676 if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
677 return;
678
679 vtarget->deleted = 1; /* block IO */
680
681 target_reset_list = kzalloc(sizeof(*target_reset_list),
682 GFP_ATOMIC);
683 if (!target_reset_list) {
684 dfailprintk((MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
685 ioc->name,__FUNCTION__, __LINE__));
686 return;
687 }
688
689 memcpy(&target_reset_list->sas_event_data, sas_event_data,
690 sizeof(*sas_event_data));
691 list_add_tail(&target_reset_list->list, &hd->target_reset_list);
692
693 if (hd->resetPending)
694 return;
695
696 if (mptsas_target_reset(ioc, channel, id)) {
697 target_reset_list->target_reset_issued = 1;
698 hd->resetPending = 1;
699 }
700 }
701
702 /**
703 * mptsas_dev_reset_complete
704 *
705 * Completion for TARGET_RESET after NOT_RESPONDING_EVENT,
706 * enable work queue to finish off removing device from upper layers.
707 * then send next TARGET_RESET in the queue.
708 *
709 * @ioc
710 *
711 **/
712 static void
713 mptsas_dev_reset_complete(MPT_ADAPTER *ioc)
714 {
715 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
716 struct list_head *head = &hd->target_reset_list;
717 struct mptsas_target_reset_event *target_reset_list;
718 struct mptsas_hotplug_event *ev;
719 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
720 u8 id, channel;
721 __le64 sas_address;
722
723 if (list_empty(head))
724 return;
725
726 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, list);
727
728 sas_event_data = &target_reset_list->sas_event_data;
729 id = sas_event_data->TargetID;
730 channel = sas_event_data->Bus;
731 hd->resetPending = 0;
732
733 /*
734 * retry target reset
735 */
736 if (!target_reset_list->target_reset_issued) {
737 if (mptsas_target_reset(ioc, channel, id)) {
738 target_reset_list->target_reset_issued = 1;
739 hd->resetPending = 1;
740 }
741 return;
742 }
743
744 /*
745 * enable work queue to remove device from upper layers
746 */
747 list_del(&target_reset_list->list);
748
749 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
750 if (!ev) {
751 dfailprintk((MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
752 ioc->name,__FUNCTION__, __LINE__));
753 return;
754 }
755
756 INIT_WORK(&ev->work, mptsas_hotplug_work);
757 ev->ioc = ioc;
758 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
759 ev->parent_handle =
760 le16_to_cpu(sas_event_data->ParentDevHandle);
761 ev->channel = channel;
762 ev->id =id;
763 ev->phy_id = sas_event_data->PhyNum;
764 memcpy(&sas_address, &sas_event_data->SASAddress,
765 sizeof(__le64));
766 ev->sas_address = le64_to_cpu(sas_address);
767 ev->device_info = le32_to_cpu(sas_event_data->DeviceInfo);
768 ev->event_type = MPTSAS_DEL_DEVICE;
769 schedule_work(&ev->work);
770 kfree(target_reset_list);
771
772 /*
773 * issue target reset to next device in the queue
774 */
775
776 head = &hd->target_reset_list;
777 if (list_empty(head))
778 return;
779
780 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
781 list);
782
783 sas_event_data = &target_reset_list->sas_event_data;
784 id = sas_event_data->TargetID;
785 channel = sas_event_data->Bus;
786
787 if (mptsas_target_reset(ioc, channel, id)) {
788 target_reset_list->target_reset_issued = 1;
789 hd->resetPending = 1;
790 }
791 }
792
793 /**
794 * mptsas_taskmgmt_complete
795 *
796 * @ioc
797 * @mf
798 * @mr
799 *
800 **/
801 static int
802 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
803 {
804 mptsas_dev_reset_complete(ioc);
805 return mptscsih_taskmgmt_complete(ioc, mf, mr);
806 }
807
808 /**
809 * mptscsih_ioc_reset
810 *
811 * @ioc
812 * @reset_phase
813 *
814 **/
815 static int
816 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
817 {
818 MPT_SCSI_HOST *hd;
819 struct mptsas_target_reset_event *target_reset_list, *n;
820 int rc;
821
822 rc = mptscsih_ioc_reset(ioc, reset_phase);
823
824 if (ioc->bus_type != SAS)
825 goto out;
826
827 if (reset_phase != MPT_IOC_POST_RESET)
828 goto out;
829
830 if (!ioc->sh || !ioc->sh->hostdata)
831 goto out;
832 hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
833 if (!hd->ioc)
834 goto out;
835
836 if (list_empty(&hd->target_reset_list))
837 goto out;
838
839 /* flush the target_reset_list */
840 list_for_each_entry_safe(target_reset_list, n,
841 &hd->target_reset_list, list) {
842 list_del(&target_reset_list->list);
843 kfree(target_reset_list);
844 }
845
846 out:
847 return rc;
848 }
849
850 static int
851 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
852 u32 form, u32 form_specific)
853 {
854 ConfigExtendedPageHeader_t hdr;
855 CONFIGPARMS cfg;
856 SasEnclosurePage0_t *buffer;
857 dma_addr_t dma_handle;
858 int error;
859 __le64 le_identifier;
860
861 memset(&hdr, 0, sizeof(hdr));
862 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
863 hdr.PageNumber = 0;
864 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
865 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
866
867 cfg.cfghdr.ehdr = &hdr;
868 cfg.physAddr = -1;
869 cfg.pageAddr = form + form_specific;
870 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
871 cfg.dir = 0; /* read */
872 cfg.timeout = 10;
873
874 error = mpt_config(ioc, &cfg);
875 if (error)
876 goto out;
877 if (!hdr.ExtPageLength) {
878 error = -ENXIO;
879 goto out;
880 }
881
882 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
883 &dma_handle);
884 if (!buffer) {
885 error = -ENOMEM;
886 goto out;
887 }
888
889 cfg.physAddr = dma_handle;
890 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
891
892 error = mpt_config(ioc, &cfg);
893 if (error)
894 goto out_free_consistent;
895
896 /* save config data */
897 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
898 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
899 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
900 enclosure->flags = le16_to_cpu(buffer->Flags);
901 enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
902 enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
903 enclosure->start_id = buffer->StartTargetID;
904 enclosure->start_channel = buffer->StartBus;
905 enclosure->sep_id = buffer->SEPTargetID;
906 enclosure->sep_channel = buffer->SEPBus;
907
908 out_free_consistent:
909 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
910 buffer, dma_handle);
911 out:
912 return error;
913 }
914
915 static int
916 mptsas_slave_configure(struct scsi_device *sdev)
917 {
918
919 if (sdev->channel == MPTSAS_RAID_CHANNEL)
920 goto out;
921
922 sas_read_port_mode_page(sdev);
923
924 out:
925 return mptscsih_slave_configure(sdev);
926 }
927
928 static int
929 mptsas_target_alloc(struct scsi_target *starget)
930 {
931 struct Scsi_Host *host = dev_to_shost(&starget->dev);
932 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
933 VirtTarget *vtarget;
934 u8 id, channel;
935 struct sas_rphy *rphy;
936 struct mptsas_portinfo *p;
937 int i;
938
939 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
940 if (!vtarget)
941 return -ENOMEM;
942
943 vtarget->starget = starget;
944 vtarget->ioc_id = hd->ioc->id;
945 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
946 id = starget->id;
947 channel = 0;
948
949 /*
950 * RAID volumes placed beyond the last expected port.
951 */
952 if (starget->channel == MPTSAS_RAID_CHANNEL) {
953 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
954 if (id == hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
955 channel = hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
956 goto out;
957 }
958
959 rphy = dev_to_rphy(starget->dev.parent);
960 mutex_lock(&hd->ioc->sas_topology_mutex);
961 list_for_each_entry(p, &hd->ioc->sas_topology, list) {
962 for (i = 0; i < p->num_phys; i++) {
963 if (p->phy_info[i].attached.sas_address !=
964 rphy->identify.sas_address)
965 continue;
966 id = p->phy_info[i].attached.id;
967 channel = p->phy_info[i].attached.channel;
968 mptsas_set_starget(&p->phy_info[i], starget);
969
970 /*
971 * Exposing hidden raid components
972 */
973 if (mptscsih_is_phys_disk(hd->ioc, channel, id)) {
974 id = mptscsih_raid_id_to_num(hd->ioc,
975 channel, id);
976 vtarget->tflags |=
977 MPT_TARGET_FLAGS_RAID_COMPONENT;
978 p->phy_info[i].attached.phys_disk_num = id;
979 }
980 mutex_unlock(&hd->ioc->sas_topology_mutex);
981 goto out;
982 }
983 }
984 mutex_unlock(&hd->ioc->sas_topology_mutex);
985
986 kfree(vtarget);
987 return -ENXIO;
988
989 out:
990 vtarget->id = id;
991 vtarget->channel = channel;
992 starget->hostdata = vtarget;
993 return 0;
994 }
995
996 static void
997 mptsas_target_destroy(struct scsi_target *starget)
998 {
999 struct Scsi_Host *host = dev_to_shost(&starget->dev);
1000 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
1001 struct sas_rphy *rphy;
1002 struct mptsas_portinfo *p;
1003 int i;
1004
1005 if (!starget->hostdata)
1006 return;
1007
1008 if (starget->channel == MPTSAS_RAID_CHANNEL)
1009 goto out;
1010
1011 rphy = dev_to_rphy(starget->dev.parent);
1012 list_for_each_entry(p, &hd->ioc->sas_topology, list) {
1013 for (i = 0; i < p->num_phys; i++) {
1014 if (p->phy_info[i].attached.sas_address !=
1015 rphy->identify.sas_address)
1016 continue;
1017 mptsas_set_starget(&p->phy_info[i], NULL);
1018 goto out;
1019 }
1020 }
1021
1022 out:
1023 kfree(starget->hostdata);
1024 starget->hostdata = NULL;
1025 }
1026
1027
1028 static int
1029 mptsas_slave_alloc(struct scsi_device *sdev)
1030 {
1031 struct Scsi_Host *host = sdev->host;
1032 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
1033 struct sas_rphy *rphy;
1034 struct mptsas_portinfo *p;
1035 VirtDevice *vdev;
1036 struct scsi_target *starget;
1037 int i;
1038
1039 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
1040 if (!vdev) {
1041 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
1042 hd->ioc->name, sizeof(VirtDevice));
1043 return -ENOMEM;
1044 }
1045 starget = scsi_target(sdev);
1046 vdev->vtarget = starget->hostdata;
1047
1048 if (sdev->channel == MPTSAS_RAID_CHANNEL)
1049 goto out;
1050
1051 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
1052 mutex_lock(&hd->ioc->sas_topology_mutex);
1053 list_for_each_entry(p, &hd->ioc->sas_topology, list) {
1054 for (i = 0; i < p->num_phys; i++) {
1055 if (p->phy_info[i].attached.sas_address !=
1056 rphy->identify.sas_address)
1057 continue;
1058 vdev->lun = sdev->lun;
1059 /*
1060 * Exposing hidden raid components
1061 */
1062 if (mptscsih_is_phys_disk(hd->ioc,
1063 p->phy_info[i].attached.channel,
1064 p->phy_info[i].attached.id))
1065 sdev->no_uld_attach = 1;
1066 mutex_unlock(&hd->ioc->sas_topology_mutex);
1067 goto out;
1068 }
1069 }
1070 mutex_unlock(&hd->ioc->sas_topology_mutex);
1071
1072 kfree(vdev);
1073 return -ENXIO;
1074
1075 out:
1076 vdev->vtarget->num_luns++;
1077 sdev->hostdata = vdev;
1078 return 0;
1079 }
1080
1081 static int
1082 mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1083 {
1084 VirtDevice *vdev = SCpnt->device->hostdata;
1085
1086 if (!vdev || !vdev->vtarget || vdev->vtarget->deleted) {
1087 SCpnt->result = DID_NO_CONNECT << 16;
1088 done(SCpnt);
1089 return 0;
1090 }
1091
1092 // scsi_print_command(SCpnt);
1093
1094 return mptscsih_qcmd(SCpnt,done);
1095 }
1096
1097
1098 static struct scsi_host_template mptsas_driver_template = {
1099 .module = THIS_MODULE,
1100 .proc_name = "mptsas",
1101 .proc_info = mptscsih_proc_info,
1102 .name = "MPT SPI Host",
1103 .info = mptscsih_info,
1104 .queuecommand = mptsas_qcmd,
1105 .target_alloc = mptsas_target_alloc,
1106 .slave_alloc = mptsas_slave_alloc,
1107 .slave_configure = mptsas_slave_configure,
1108 .target_destroy = mptsas_target_destroy,
1109 .slave_destroy = mptscsih_slave_destroy,
1110 .change_queue_depth = mptscsih_change_queue_depth,
1111 .eh_abort_handler = mptscsih_abort,
1112 .eh_device_reset_handler = mptscsih_dev_reset,
1113 .eh_bus_reset_handler = mptscsih_bus_reset,
1114 .eh_host_reset_handler = mptscsih_host_reset,
1115 .bios_param = mptscsih_bios_param,
1116 .can_queue = MPT_FC_CAN_QUEUE,
1117 .this_id = -1,
1118 .sg_tablesize = MPT_SCSI_SG_DEPTH,
1119 .max_sectors = 8192,
1120 .cmd_per_lun = 7,
1121 .use_clustering = ENABLE_CLUSTERING,
1122 };
1123
1124 static int mptsas_get_linkerrors(struct sas_phy *phy)
1125 {
1126 MPT_ADAPTER *ioc = phy_to_ioc(phy);
1127 ConfigExtendedPageHeader_t hdr;
1128 CONFIGPARMS cfg;
1129 SasPhyPage1_t *buffer;
1130 dma_addr_t dma_handle;
1131 int error;
1132
1133 /* FIXME: only have link errors on local phys */
1134 if (!scsi_is_sas_phy_local(phy))
1135 return -EINVAL;
1136
1137 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
1138 hdr.ExtPageLength = 0;
1139 hdr.PageNumber = 1 /* page number 1*/;
1140 hdr.Reserved1 = 0;
1141 hdr.Reserved2 = 0;
1142 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1143 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1144
1145 cfg.cfghdr.ehdr = &hdr;
1146 cfg.physAddr = -1;
1147 cfg.pageAddr = phy->identify.phy_identifier;
1148 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1149 cfg.dir = 0; /* read */
1150 cfg.timeout = 10;
1151
1152 error = mpt_config(ioc, &cfg);
1153 if (error)
1154 return error;
1155 if (!hdr.ExtPageLength)
1156 return -ENXIO;
1157
1158 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1159 &dma_handle);
1160 if (!buffer)
1161 return -ENOMEM;
1162
1163 cfg.physAddr = dma_handle;
1164 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1165
1166 error = mpt_config(ioc, &cfg);
1167 if (error)
1168 goto out_free_consistent;
1169
1170 mptsas_print_phy_pg1(buffer);
1171
1172 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
1173 phy->running_disparity_error_count =
1174 le32_to_cpu(buffer->RunningDisparityErrorCount);
1175 phy->loss_of_dword_sync_count =
1176 le32_to_cpu(buffer->LossDwordSynchCount);
1177 phy->phy_reset_problem_count =
1178 le32_to_cpu(buffer->PhyResetProblemCount);
1179
1180 out_free_consistent:
1181 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1182 buffer, dma_handle);
1183 return error;
1184 }
1185
1186 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
1187 MPT_FRAME_HDR *reply)
1188 {
1189 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
1190 if (reply != NULL) {
1191 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
1192 memcpy(ioc->sas_mgmt.reply, reply,
1193 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
1194 }
1195 complete(&ioc->sas_mgmt.done);
1196 return 1;
1197 }
1198
1199 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
1200 {
1201 MPT_ADAPTER *ioc = phy_to_ioc(phy);
1202 SasIoUnitControlRequest_t *req;
1203 SasIoUnitControlReply_t *reply;
1204 MPT_FRAME_HDR *mf;
1205 MPIHeader_t *hdr;
1206 unsigned long timeleft;
1207 int error = -ERESTARTSYS;
1208
1209 /* FIXME: fusion doesn't allow non-local phy reset */
1210 if (!scsi_is_sas_phy_local(phy))
1211 return -EINVAL;
1212
1213 /* not implemented for expanders */
1214 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
1215 return -ENXIO;
1216
1217 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
1218 goto out;
1219
1220 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
1221 if (!mf) {
1222 error = -ENOMEM;
1223 goto out_unlock;
1224 }
1225
1226 hdr = (MPIHeader_t *) mf;
1227 req = (SasIoUnitControlRequest_t *)mf;
1228 memset(req, 0, sizeof(SasIoUnitControlRequest_t));
1229 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
1230 req->MsgContext = hdr->MsgContext;
1231 req->Operation = hard_reset ?
1232 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
1233 req->PhyNum = phy->identify.phy_identifier;
1234
1235 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
1236
1237 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
1238 10 * HZ);
1239 if (!timeleft) {
1240 /* On timeout reset the board */
1241 mpt_free_msg_frame(ioc, mf);
1242 mpt_HardResetHandler(ioc, CAN_SLEEP);
1243 error = -ETIMEDOUT;
1244 goto out_unlock;
1245 }
1246
1247 /* a reply frame is expected */
1248 if ((ioc->sas_mgmt.status &
1249 MPT_IOCTL_STATUS_RF_VALID) == 0) {
1250 error = -ENXIO;
1251 goto out_unlock;
1252 }
1253
1254 /* process the completed Reply Message Frame */
1255 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
1256 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
1257 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
1258 __FUNCTION__,
1259 reply->IOCStatus,
1260 reply->IOCLogInfo);
1261 error = -ENXIO;
1262 goto out_unlock;
1263 }
1264
1265 error = 0;
1266
1267 out_unlock:
1268 mutex_unlock(&ioc->sas_mgmt.mutex);
1269 out:
1270 return error;
1271 }
1272
1273 static int
1274 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1275 {
1276 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1277 int i, error;
1278 struct mptsas_portinfo *p;
1279 struct mptsas_enclosure enclosure_info;
1280 u64 enclosure_handle;
1281
1282 mutex_lock(&ioc->sas_topology_mutex);
1283 list_for_each_entry(p, &ioc->sas_topology, list) {
1284 for (i = 0; i < p->num_phys; i++) {
1285 if (p->phy_info[i].attached.sas_address ==
1286 rphy->identify.sas_address) {
1287 enclosure_handle = p->phy_info[i].
1288 attached.handle_enclosure;
1289 goto found_info;
1290 }
1291 }
1292 }
1293 mutex_unlock(&ioc->sas_topology_mutex);
1294 return -ENXIO;
1295
1296 found_info:
1297 mutex_unlock(&ioc->sas_topology_mutex);
1298 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
1299 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
1300 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
1301 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
1302 if (!error)
1303 *identifier = enclosure_info.enclosure_logical_id;
1304 return error;
1305 }
1306
1307 static int
1308 mptsas_get_bay_identifier(struct sas_rphy *rphy)
1309 {
1310 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1311 struct mptsas_portinfo *p;
1312 int i, rc;
1313
1314 mutex_lock(&ioc->sas_topology_mutex);
1315 list_for_each_entry(p, &ioc->sas_topology, list) {
1316 for (i = 0; i < p->num_phys; i++) {
1317 if (p->phy_info[i].attached.sas_address ==
1318 rphy->identify.sas_address) {
1319 rc = p->phy_info[i].attached.slot;
1320 goto out;
1321 }
1322 }
1323 }
1324 rc = -ENXIO;
1325 out:
1326 mutex_unlock(&ioc->sas_topology_mutex);
1327 return rc;
1328 }
1329
1330 static struct sas_function_template mptsas_transport_functions = {
1331 .get_linkerrors = mptsas_get_linkerrors,
1332 .get_enclosure_identifier = mptsas_get_enclosure_identifier,
1333 .get_bay_identifier = mptsas_get_bay_identifier,
1334 .phy_reset = mptsas_phy_reset,
1335 };
1336
1337 static struct scsi_transport_template *mptsas_transport_template;
1338
1339 static int
1340 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
1341 {
1342 ConfigExtendedPageHeader_t hdr;
1343 CONFIGPARMS cfg;
1344 SasIOUnitPage0_t *buffer;
1345 dma_addr_t dma_handle;
1346 int error, i;
1347
1348 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
1349 hdr.ExtPageLength = 0;
1350 hdr.PageNumber = 0;
1351 hdr.Reserved1 = 0;
1352 hdr.Reserved2 = 0;
1353 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1354 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1355
1356 cfg.cfghdr.ehdr = &hdr;
1357 cfg.physAddr = -1;
1358 cfg.pageAddr = 0;
1359 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1360 cfg.dir = 0; /* read */
1361 cfg.timeout = 10;
1362
1363 error = mpt_config(ioc, &cfg);
1364 if (error)
1365 goto out;
1366 if (!hdr.ExtPageLength) {
1367 error = -ENXIO;
1368 goto out;
1369 }
1370
1371 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1372 &dma_handle);
1373 if (!buffer) {
1374 error = -ENOMEM;
1375 goto out;
1376 }
1377
1378 cfg.physAddr = dma_handle;
1379 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1380
1381 error = mpt_config(ioc, &cfg);
1382 if (error)
1383 goto out_free_consistent;
1384
1385 port_info->num_phys = buffer->NumPhys;
1386 port_info->phy_info = kcalloc(port_info->num_phys,
1387 sizeof(*port_info->phy_info),GFP_KERNEL);
1388 if (!port_info->phy_info) {
1389 error = -ENOMEM;
1390 goto out_free_consistent;
1391 }
1392
1393 for (i = 0; i < port_info->num_phys; i++) {
1394 mptsas_print_phy_data(&buffer->PhyData[i]);
1395 port_info->phy_info[i].phy_id = i;
1396 port_info->phy_info[i].port_id =
1397 buffer->PhyData[i].Port;
1398 port_info->phy_info[i].negotiated_link_rate =
1399 buffer->PhyData[i].NegotiatedLinkRate;
1400 port_info->phy_info[i].portinfo = port_info;
1401 port_info->phy_info[i].handle =
1402 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
1403 }
1404
1405 out_free_consistent:
1406 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1407 buffer, dma_handle);
1408 out:
1409 return error;
1410 }
1411
1412 static int
1413 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1414 u32 form, u32 form_specific)
1415 {
1416 ConfigExtendedPageHeader_t hdr;
1417 CONFIGPARMS cfg;
1418 SasPhyPage0_t *buffer;
1419 dma_addr_t dma_handle;
1420 int error;
1421
1422 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
1423 hdr.ExtPageLength = 0;
1424 hdr.PageNumber = 0;
1425 hdr.Reserved1 = 0;
1426 hdr.Reserved2 = 0;
1427 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1428 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1429
1430 cfg.cfghdr.ehdr = &hdr;
1431 cfg.dir = 0; /* read */
1432 cfg.timeout = 10;
1433
1434 /* Get Phy Pg 0 for each Phy. */
1435 cfg.physAddr = -1;
1436 cfg.pageAddr = form + form_specific;
1437 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1438
1439 error = mpt_config(ioc, &cfg);
1440 if (error)
1441 goto out;
1442
1443 if (!hdr.ExtPageLength) {
1444 error = -ENXIO;
1445 goto out;
1446 }
1447
1448 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1449 &dma_handle);
1450 if (!buffer) {
1451 error = -ENOMEM;
1452 goto out;
1453 }
1454
1455 cfg.physAddr = dma_handle;
1456 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1457
1458 error = mpt_config(ioc, &cfg);
1459 if (error)
1460 goto out_free_consistent;
1461
1462 mptsas_print_phy_pg0(buffer);
1463
1464 phy_info->hw_link_rate = buffer->HwLinkRate;
1465 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1466 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1467 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1468
1469 out_free_consistent:
1470 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1471 buffer, dma_handle);
1472 out:
1473 return error;
1474 }
1475
1476 static int
1477 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
1478 u32 form, u32 form_specific)
1479 {
1480 ConfigExtendedPageHeader_t hdr;
1481 CONFIGPARMS cfg;
1482 SasDevicePage0_t *buffer;
1483 dma_addr_t dma_handle;
1484 __le64 sas_address;
1485 int error=0;
1486
1487 if (ioc->sas_discovery_runtime &&
1488 mptsas_is_end_device(device_info))
1489 goto out;
1490
1491 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
1492 hdr.ExtPageLength = 0;
1493 hdr.PageNumber = 0;
1494 hdr.Reserved1 = 0;
1495 hdr.Reserved2 = 0;
1496 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1497 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1498
1499 cfg.cfghdr.ehdr = &hdr;
1500 cfg.pageAddr = form + form_specific;
1501 cfg.physAddr = -1;
1502 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1503 cfg.dir = 0; /* read */
1504 cfg.timeout = 10;
1505
1506 memset(device_info, 0, sizeof(struct mptsas_devinfo));
1507 error = mpt_config(ioc, &cfg);
1508 if (error)
1509 goto out;
1510 if (!hdr.ExtPageLength) {
1511 error = -ENXIO;
1512 goto out;
1513 }
1514
1515 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1516 &dma_handle);
1517 if (!buffer) {
1518 error = -ENOMEM;
1519 goto out;
1520 }
1521
1522 cfg.physAddr = dma_handle;
1523 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1524
1525 error = mpt_config(ioc, &cfg);
1526 if (error)
1527 goto out_free_consistent;
1528
1529 mptsas_print_device_pg0(buffer);
1530
1531 device_info->handle = le16_to_cpu(buffer->DevHandle);
1532 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
1533 device_info->handle_enclosure =
1534 le16_to_cpu(buffer->EnclosureHandle);
1535 device_info->slot = le16_to_cpu(buffer->Slot);
1536 device_info->phy_id = buffer->PhyNum;
1537 device_info->port_id = buffer->PhysicalPort;
1538 device_info->id = buffer->TargetID;
1539 device_info->phys_disk_num = ~0;
1540 device_info->channel = buffer->Bus;
1541 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
1542 device_info->sas_address = le64_to_cpu(sas_address);
1543 device_info->device_info =
1544 le32_to_cpu(buffer->DeviceInfo);
1545
1546 out_free_consistent:
1547 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1548 buffer, dma_handle);
1549 out:
1550 return error;
1551 }
1552
1553 static int
1554 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
1555 u32 form, u32 form_specific)
1556 {
1557 ConfigExtendedPageHeader_t hdr;
1558 CONFIGPARMS cfg;
1559 SasExpanderPage0_t *buffer;
1560 dma_addr_t dma_handle;
1561 int i, error;
1562
1563 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1564 hdr.ExtPageLength = 0;
1565 hdr.PageNumber = 0;
1566 hdr.Reserved1 = 0;
1567 hdr.Reserved2 = 0;
1568 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1569 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1570
1571 cfg.cfghdr.ehdr = &hdr;
1572 cfg.physAddr = -1;
1573 cfg.pageAddr = form + form_specific;
1574 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1575 cfg.dir = 0; /* read */
1576 cfg.timeout = 10;
1577
1578 memset(port_info, 0, sizeof(struct mptsas_portinfo));
1579 error = mpt_config(ioc, &cfg);
1580 if (error)
1581 goto out;
1582
1583 if (!hdr.ExtPageLength) {
1584 error = -ENXIO;
1585 goto out;
1586 }
1587
1588 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1589 &dma_handle);
1590 if (!buffer) {
1591 error = -ENOMEM;
1592 goto out;
1593 }
1594
1595 cfg.physAddr = dma_handle;
1596 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1597
1598 error = mpt_config(ioc, &cfg);
1599 if (error)
1600 goto out_free_consistent;
1601
1602 /* save config data */
1603 port_info->num_phys = buffer->NumPhys;
1604 port_info->phy_info = kcalloc(port_info->num_phys,
1605 sizeof(*port_info->phy_info),GFP_KERNEL);
1606 if (!port_info->phy_info) {
1607 error = -ENOMEM;
1608 goto out_free_consistent;
1609 }
1610
1611 for (i = 0; i < port_info->num_phys; i++) {
1612 port_info->phy_info[i].portinfo = port_info;
1613 port_info->phy_info[i].handle =
1614 le16_to_cpu(buffer->DevHandle);
1615 }
1616
1617 out_free_consistent:
1618 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1619 buffer, dma_handle);
1620 out:
1621 return error;
1622 }
1623
1624 static int
1625 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1626 u32 form, u32 form_specific)
1627 {
1628 ConfigExtendedPageHeader_t hdr;
1629 CONFIGPARMS cfg;
1630 SasExpanderPage1_t *buffer;
1631 dma_addr_t dma_handle;
1632 int error=0;
1633
1634 if (ioc->sas_discovery_runtime &&
1635 mptsas_is_end_device(&phy_info->attached))
1636 goto out;
1637
1638 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1639 hdr.ExtPageLength = 0;
1640 hdr.PageNumber = 1;
1641 hdr.Reserved1 = 0;
1642 hdr.Reserved2 = 0;
1643 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1644 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1645
1646 cfg.cfghdr.ehdr = &hdr;
1647 cfg.physAddr = -1;
1648 cfg.pageAddr = form + form_specific;
1649 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1650 cfg.dir = 0; /* read */
1651 cfg.timeout = 10;
1652
1653 error = mpt_config(ioc, &cfg);
1654 if (error)
1655 goto out;
1656
1657 if (!hdr.ExtPageLength) {
1658 error = -ENXIO;
1659 goto out;
1660 }
1661
1662 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1663 &dma_handle);
1664 if (!buffer) {
1665 error = -ENOMEM;
1666 goto out;
1667 }
1668
1669 cfg.physAddr = dma_handle;
1670 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1671
1672 error = mpt_config(ioc, &cfg);
1673 if (error)
1674 goto out_free_consistent;
1675
1676
1677 mptsas_print_expander_pg1(buffer);
1678
1679 /* save config data */
1680 phy_info->phy_id = buffer->PhyIdentifier;
1681 phy_info->port_id = buffer->PhysicalPort;
1682 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
1683 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1684 phy_info->hw_link_rate = buffer->HwLinkRate;
1685 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1686 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1687
1688 out_free_consistent:
1689 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1690 buffer, dma_handle);
1691 out:
1692 return error;
1693 }
1694
1695 static void
1696 mptsas_parse_device_info(struct sas_identify *identify,
1697 struct mptsas_devinfo *device_info)
1698 {
1699 u16 protocols;
1700
1701 identify->sas_address = device_info->sas_address;
1702 identify->phy_identifier = device_info->phy_id;
1703
1704 /*
1705 * Fill in Phy Initiator Port Protocol.
1706 * Bits 6:3, more than one bit can be set, fall through cases.
1707 */
1708 protocols = device_info->device_info & 0x78;
1709 identify->initiator_port_protocols = 0;
1710 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
1711 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
1712 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1713 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
1714 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
1715 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
1716 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
1717 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
1718
1719 /*
1720 * Fill in Phy Target Port Protocol.
1721 * Bits 10:7, more than one bit can be set, fall through cases.
1722 */
1723 protocols = device_info->device_info & 0x780;
1724 identify->target_port_protocols = 0;
1725 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1726 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
1727 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
1728 identify->target_port_protocols |= SAS_PROTOCOL_STP;
1729 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
1730 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
1731 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1732 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
1733
1734 /*
1735 * Fill in Attached device type.
1736 */
1737 switch (device_info->device_info &
1738 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
1739 case MPI_SAS_DEVICE_INFO_NO_DEVICE:
1740 identify->device_type = SAS_PHY_UNUSED;
1741 break;
1742 case MPI_SAS_DEVICE_INFO_END_DEVICE:
1743 identify->device_type = SAS_END_DEVICE;
1744 break;
1745 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
1746 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
1747 break;
1748 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
1749 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
1750 break;
1751 }
1752 }
1753
1754 static int mptsas_probe_one_phy(struct device *dev,
1755 struct mptsas_phyinfo *phy_info, int index, int local)
1756 {
1757 MPT_ADAPTER *ioc;
1758 struct sas_phy *phy;
1759 struct sas_port *port;
1760 int error = 0;
1761
1762 if (!dev) {
1763 error = -ENODEV;
1764 goto out;
1765 }
1766
1767 if (!phy_info->phy) {
1768 phy = sas_phy_alloc(dev, index);
1769 if (!phy) {
1770 error = -ENOMEM;
1771 goto out;
1772 }
1773 } else
1774 phy = phy_info->phy;
1775
1776 mptsas_parse_device_info(&phy->identify, &phy_info->identify);
1777
1778 /*
1779 * Set Negotiated link rate.
1780 */
1781 switch (phy_info->negotiated_link_rate) {
1782 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
1783 phy->negotiated_linkrate = SAS_PHY_DISABLED;
1784 break;
1785 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
1786 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
1787 break;
1788 case MPI_SAS_IOUNIT0_RATE_1_5:
1789 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
1790 break;
1791 case MPI_SAS_IOUNIT0_RATE_3_0:
1792 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
1793 break;
1794 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
1795 case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
1796 default:
1797 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
1798 break;
1799 }
1800
1801 /*
1802 * Set Max hardware link rate.
1803 */
1804 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1805 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
1806 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1807 break;
1808 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1809 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1810 break;
1811 default:
1812 break;
1813 }
1814
1815 /*
1816 * Set Max programmed link rate.
1817 */
1818 switch (phy_info->programmed_link_rate &
1819 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1820 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
1821 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1822 break;
1823 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1824 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1825 break;
1826 default:
1827 break;
1828 }
1829
1830 /*
1831 * Set Min hardware link rate.
1832 */
1833 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
1834 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
1835 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1836 break;
1837 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1838 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1839 break;
1840 default:
1841 break;
1842 }
1843
1844 /*
1845 * Set Min programmed link rate.
1846 */
1847 switch (phy_info->programmed_link_rate &
1848 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
1849 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
1850 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1851 break;
1852 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1853 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1854 break;
1855 default:
1856 break;
1857 }
1858
1859 if (!phy_info->phy) {
1860
1861 error = sas_phy_add(phy);
1862 if (error) {
1863 sas_phy_free(phy);
1864 goto out;
1865 }
1866 phy_info->phy = phy;
1867 }
1868
1869 if (!phy_info->attached.handle ||
1870 !phy_info->port_details)
1871 goto out;
1872
1873 port = mptsas_get_port(phy_info);
1874 ioc = phy_to_ioc(phy_info->phy);
1875
1876 if (phy_info->sas_port_add_phy) {
1877
1878 if (!port) {
1879 port = sas_port_alloc_num(dev);
1880 if (!port) {
1881 error = -ENOMEM;
1882 goto out;
1883 }
1884 error = sas_port_add(port);
1885 if (error) {
1886 dfailprintk((MYIOC_s_ERR_FMT
1887 "%s: exit at line=%d\n", ioc->name,
1888 __FUNCTION__, __LINE__));
1889 goto out;
1890 }
1891 mptsas_set_port(phy_info, port);
1892 dsaswideprintk((KERN_DEBUG
1893 "sas_port_alloc: port=%p dev=%p port_id=%d\n",
1894 port, dev, port->port_identifier));
1895 }
1896 dsaswideprintk((KERN_DEBUG "sas_port_add_phy: phy_id=%d\n",
1897 phy_info->phy_id));
1898 sas_port_add_phy(port, phy_info->phy);
1899 phy_info->sas_port_add_phy = 0;
1900 }
1901
1902 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
1903
1904 struct sas_rphy *rphy;
1905 struct device *parent;
1906 struct sas_identify identify;
1907
1908 parent = dev->parent->parent;
1909 /*
1910 * Let the hotplug_work thread handle processing
1911 * the adding/removing of devices that occur
1912 * after start of day.
1913 */
1914 if (ioc->sas_discovery_runtime &&
1915 mptsas_is_end_device(&phy_info->attached))
1916 goto out;
1917
1918 mptsas_parse_device_info(&identify, &phy_info->attached);
1919 if (scsi_is_host_device(parent)) {
1920 struct mptsas_portinfo *port_info;
1921 int i;
1922
1923 mutex_lock(&ioc->sas_topology_mutex);
1924 port_info = mptsas_find_portinfo_by_handle(ioc,
1925 ioc->handle);
1926 mutex_unlock(&ioc->sas_topology_mutex);
1927
1928 for (i = 0; i < port_info->num_phys; i++)
1929 if (port_info->phy_info[i].identify.sas_address ==
1930 identify.sas_address) {
1931 sas_port_mark_backlink(port);
1932 goto out;
1933 }
1934
1935 } else if (scsi_is_sas_rphy(parent)) {
1936 struct sas_rphy *parent_rphy = dev_to_rphy(parent);
1937 if (identify.sas_address ==
1938 parent_rphy->identify.sas_address) {
1939 sas_port_mark_backlink(port);
1940 goto out;
1941 }
1942 }
1943
1944 switch (identify.device_type) {
1945 case SAS_END_DEVICE:
1946 rphy = sas_end_device_alloc(port);
1947 break;
1948 case SAS_EDGE_EXPANDER_DEVICE:
1949 case SAS_FANOUT_EXPANDER_DEVICE:
1950 rphy = sas_expander_alloc(port, identify.device_type);
1951 break;
1952 default:
1953 rphy = NULL;
1954 break;
1955 }
1956 if (!rphy) {
1957 dfailprintk((MYIOC_s_ERR_FMT
1958 "%s: exit at line=%d\n", ioc->name,
1959 __FUNCTION__, __LINE__));
1960 goto out;
1961 }
1962
1963 rphy->identify = identify;
1964 error = sas_rphy_add(rphy);
1965 if (error) {
1966 dfailprintk((MYIOC_s_ERR_FMT
1967 "%s: exit at line=%d\n", ioc->name,
1968 __FUNCTION__, __LINE__));
1969 sas_rphy_free(rphy);
1970 goto out;
1971 }
1972 mptsas_set_rphy(phy_info, rphy);
1973 }
1974
1975 out:
1976 return error;
1977 }
1978
1979 static int
1980 mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
1981 {
1982 struct mptsas_portinfo *port_info, *hba;
1983 int error = -ENOMEM, i;
1984
1985 hba = kzalloc(sizeof(*port_info), GFP_KERNEL);
1986 if (! hba)
1987 goto out;
1988
1989 error = mptsas_sas_io_unit_pg0(ioc, hba);
1990 if (error)
1991 goto out_free_port_info;
1992
1993 mutex_lock(&ioc->sas_topology_mutex);
1994 ioc->handle = hba->phy_info[0].handle;
1995 port_info = mptsas_find_portinfo_by_handle(ioc, ioc->handle);
1996 if (!port_info) {
1997 port_info = hba;
1998 list_add_tail(&port_info->list, &ioc->sas_topology);
1999 } else {
2000 for (i = 0; i < hba->num_phys; i++) {
2001 port_info->phy_info[i].negotiated_link_rate =
2002 hba->phy_info[i].negotiated_link_rate;
2003 port_info->phy_info[i].handle =
2004 hba->phy_info[i].handle;
2005 port_info->phy_info[i].port_id =
2006 hba->phy_info[i].port_id;
2007 }
2008 kfree(hba->phy_info);
2009 kfree(hba);
2010 hba = NULL;
2011 }
2012 mutex_unlock(&ioc->sas_topology_mutex);
2013 for (i = 0; i < port_info->num_phys; i++) {
2014 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
2015 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
2016 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
2017
2018 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
2019 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2020 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2021 port_info->phy_info[i].handle);
2022 port_info->phy_info[i].identify.phy_id =
2023 port_info->phy_info[i].phy_id = i;
2024 if (port_info->phy_info[i].attached.handle)
2025 mptsas_sas_device_pg0(ioc,
2026 &port_info->phy_info[i].attached,
2027 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2028 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2029 port_info->phy_info[i].attached.handle);
2030 }
2031
2032 mptsas_setup_wide_ports(ioc, port_info);
2033
2034 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
2035 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
2036 &port_info->phy_info[i], ioc->sas_index, 1);
2037
2038 return 0;
2039
2040 out_free_port_info:
2041 kfree(hba);
2042 out:
2043 return error;
2044 }
2045
2046 static int
2047 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)
2048 {
2049 struct mptsas_portinfo *port_info, *p, *ex;
2050 struct device *parent;
2051 struct sas_rphy *rphy;
2052 int error = -ENOMEM, i, j;
2053
2054 ex = kzalloc(sizeof(*port_info), GFP_KERNEL);
2055 if (!ex)
2056 goto out;
2057
2058 error = mptsas_sas_expander_pg0(ioc, ex,
2059 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
2060 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
2061 if (error)
2062 goto out_free_port_info;
2063
2064 *handle = ex->phy_info[0].handle;
2065
2066 mutex_lock(&ioc->sas_topology_mutex);
2067 port_info = mptsas_find_portinfo_by_handle(ioc, *handle);
2068 if (!port_info) {
2069 port_info = ex;
2070 list_add_tail(&port_info->list, &ioc->sas_topology);
2071 } else {
2072 for (i = 0; i < ex->num_phys; i++) {
2073 port_info->phy_info[i].handle =
2074 ex->phy_info[i].handle;
2075 port_info->phy_info[i].port_id =
2076 ex->phy_info[i].port_id;
2077 }
2078 kfree(ex->phy_info);
2079 kfree(ex);
2080 ex = NULL;
2081 }
2082 mutex_unlock(&ioc->sas_topology_mutex);
2083
2084 for (i = 0; i < port_info->num_phys; i++) {
2085 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
2086 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
2087 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
2088
2089 if (port_info->phy_info[i].identify.handle) {
2090 mptsas_sas_device_pg0(ioc,
2091 &port_info->phy_info[i].identify,
2092 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2093 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2094 port_info->phy_info[i].identify.handle);
2095 port_info->phy_info[i].identify.phy_id =
2096 port_info->phy_info[i].phy_id;
2097 }
2098
2099 if (port_info->phy_info[i].attached.handle) {
2100 mptsas_sas_device_pg0(ioc,
2101 &port_info->phy_info[i].attached,
2102 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2103 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2104 port_info->phy_info[i].attached.handle);
2105 port_info->phy_info[i].attached.phy_id =
2106 port_info->phy_info[i].phy_id;
2107 }
2108 }
2109
2110 parent = &ioc->sh->shost_gendev;
2111 for (i = 0; i < port_info->num_phys; i++) {
2112 mutex_lock(&ioc->sas_topology_mutex);
2113 list_for_each_entry(p, &ioc->sas_topology, list) {
2114 for (j = 0; j < p->num_phys; j++) {
2115 if (port_info->phy_info[i].identify.handle !=
2116 p->phy_info[j].attached.handle)
2117 continue;
2118 rphy = mptsas_get_rphy(&p->phy_info[j]);
2119 parent = &rphy->dev;
2120 }
2121 }
2122 mutex_unlock(&ioc->sas_topology_mutex);
2123 }
2124
2125 mptsas_setup_wide_ports(ioc, port_info);
2126
2127 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
2128 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
2129 ioc->sas_index, 0);
2130
2131 return 0;
2132
2133 out_free_port_info:
2134 if (ex) {
2135 kfree(ex->phy_info);
2136 kfree(ex);
2137 }
2138 out:
2139 return error;
2140 }
2141
2142 /*
2143 * mptsas_delete_expander_phys
2144 *
2145 *
2146 * This will traverse topology, and remove expanders
2147 * that are no longer present
2148 */
2149 static void
2150 mptsas_delete_expander_phys(MPT_ADAPTER *ioc)
2151 {
2152 struct mptsas_portinfo buffer;
2153 struct mptsas_portinfo *port_info, *n, *parent;
2154 struct mptsas_phyinfo *phy_info;
2155 struct sas_port * port;
2156 int i;
2157 u64 expander_sas_address;
2158
2159 mutex_lock(&ioc->sas_topology_mutex);
2160 list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {
2161
2162 if (port_info->phy_info &&
2163 (!(port_info->phy_info[0].identify.device_info &
2164 MPI_SAS_DEVICE_INFO_SMP_TARGET)))
2165 continue;
2166
2167 if (mptsas_sas_expander_pg0(ioc, &buffer,
2168 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
2169 MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
2170 port_info->phy_info[0].handle)) {
2171
2172 /*
2173 * Obtain the port_info instance to the parent port
2174 */
2175 parent = mptsas_find_portinfo_by_handle(ioc,
2176 port_info->phy_info[0].identify.handle_parent);
2177
2178 if (!parent)
2179 goto next_port;
2180
2181 expander_sas_address =
2182 port_info->phy_info[0].identify.sas_address;
2183
2184 /*
2185 * Delete rphys in the parent that point
2186 * to this expander. The transport layer will
2187 * cleanup all the children.
2188 */
2189 phy_info = parent->phy_info;
2190 for (i = 0; i < parent->num_phys; i++, phy_info++) {
2191 port = mptsas_get_port(phy_info);
2192 if (!port)
2193 continue;
2194 if (phy_info->attached.sas_address !=
2195 expander_sas_address)
2196 continue;
2197 #ifdef MPT_DEBUG_SAS_WIDE
2198 dev_printk(KERN_DEBUG, &port->dev,
2199 "delete port (%d)\n", port->port_identifier);
2200 #endif
2201 sas_port_delete(port);
2202 mptsas_port_delete(phy_info->port_details);
2203 }
2204 next_port:
2205
2206 phy_info = port_info->phy_info;
2207 for (i = 0; i < port_info->num_phys; i++, phy_info++)
2208 mptsas_port_delete(phy_info->port_details);
2209
2210 list_del(&port_info->list);
2211 kfree(port_info->phy_info);
2212 kfree(port_info);
2213 }
2214 /*
2215 * Free this memory allocated from inside
2216 * mptsas_sas_expander_pg0
2217 */
2218 kfree(buffer.phy_info);
2219 }
2220 mutex_unlock(&ioc->sas_topology_mutex);
2221 }
2222
2223 /*
2224 * Start of day discovery
2225 */
2226 static void
2227 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
2228 {
2229 u32 handle = 0xFFFF;
2230 int i;
2231
2232 mutex_lock(&ioc->sas_discovery_mutex);
2233 mptsas_probe_hba_phys(ioc);
2234 while (!mptsas_probe_expander_phys(ioc, &handle))
2235 ;
2236 /*
2237 Reporting RAID volumes.
2238 */
2239 if (!ioc->ir_firmware)
2240 goto out;
2241 if (!ioc->raid_data.pIocPg2)
2242 goto out;
2243 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
2244 goto out;
2245 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
2246 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
2247 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
2248 }
2249 out:
2250 mutex_unlock(&ioc->sas_discovery_mutex);
2251 }
2252
2253 /*
2254 * Work queue thread to handle Runtime discovery
2255 * Mere purpose is the hot add/delete of expanders
2256 *(Mutex UNLOCKED)
2257 */
2258 static void
2259 __mptsas_discovery_work(MPT_ADAPTER *ioc)
2260 {
2261 u32 handle = 0xFFFF;
2262
2263 ioc->sas_discovery_runtime=1;
2264 mptsas_delete_expander_phys(ioc);
2265 mptsas_probe_hba_phys(ioc);
2266 while (!mptsas_probe_expander_phys(ioc, &handle))
2267 ;
2268 ioc->sas_discovery_runtime=0;
2269 }
2270
2271 /*
2272 * Work queue thread to handle Runtime discovery
2273 * Mere purpose is the hot add/delete of expanders
2274 *(Mutex LOCKED)
2275 */
2276 static void
2277 mptsas_discovery_work(struct work_struct *work)
2278 {
2279 struct mptsas_discovery_event *ev =
2280 container_of(work, struct mptsas_discovery_event, work);
2281 MPT_ADAPTER *ioc = ev->ioc;
2282
2283 mutex_lock(&ioc->sas_discovery_mutex);
2284 __mptsas_discovery_work(ioc);
2285 mutex_unlock(&ioc->sas_discovery_mutex);
2286 kfree(ev);
2287 }
2288
2289 static struct mptsas_phyinfo *
2290 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
2291 {
2292 struct mptsas_portinfo *port_info;
2293 struct mptsas_phyinfo *phy_info = NULL;
2294 int i;
2295
2296 mutex_lock(&ioc->sas_topology_mutex);
2297 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2298 for (i = 0; i < port_info->num_phys; i++) {
2299 if (!mptsas_is_end_device(
2300 &port_info->phy_info[i].attached))
2301 continue;
2302 if (port_info->phy_info[i].attached.sas_address
2303 != sas_address)
2304 continue;
2305 phy_info = &port_info->phy_info[i];
2306 break;
2307 }
2308 }
2309 mutex_unlock(&ioc->sas_topology_mutex);
2310 return phy_info;
2311 }
2312
2313 static struct mptsas_phyinfo *
2314 mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id)
2315 {
2316 struct mptsas_portinfo *port_info;
2317 struct mptsas_phyinfo *phy_info = NULL;
2318 int i;
2319
2320 mutex_lock(&ioc->sas_topology_mutex);
2321 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2322 for (i = 0; i < port_info->num_phys; i++) {
2323 if (!mptsas_is_end_device(
2324 &port_info->phy_info[i].attached))
2325 continue;
2326 if (port_info->phy_info[i].attached.id != id)
2327 continue;
2328 if (port_info->phy_info[i].attached.channel != channel)
2329 continue;
2330 phy_info = &port_info->phy_info[i];
2331 break;
2332 }
2333 }
2334 mutex_unlock(&ioc->sas_topology_mutex);
2335 return phy_info;
2336 }
2337
2338 static struct mptsas_phyinfo *
2339 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
2340 {
2341 struct mptsas_portinfo *port_info;
2342 struct mptsas_phyinfo *phy_info = NULL;
2343 int i;
2344
2345 mutex_lock(&ioc->sas_topology_mutex);
2346 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2347 for (i = 0; i < port_info->num_phys; i++) {
2348 if (!mptsas_is_end_device(
2349 &port_info->phy_info[i].attached))
2350 continue;
2351 if (port_info->phy_info[i].attached.phys_disk_num == ~0)
2352 continue;
2353 if (port_info->phy_info[i].attached.phys_disk_num != id)
2354 continue;
2355 if (port_info->phy_info[i].attached.channel != channel)
2356 continue;
2357 phy_info = &port_info->phy_info[i];
2358 break;
2359 }
2360 }
2361 mutex_unlock(&ioc->sas_topology_mutex);
2362 return phy_info;
2363 }
2364
2365 /*
2366 * Work queue thread to clear the persitency table
2367 */
2368 static void
2369 mptsas_persist_clear_table(struct work_struct *work)
2370 {
2371 MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task);
2372
2373 mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
2374 }
2375
2376 static void
2377 mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
2378 {
2379 int rc;
2380
2381 sdev->no_uld_attach = data ? 1 : 0;
2382 rc = scsi_device_reprobe(sdev);
2383 }
2384
2385 static void
2386 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
2387 {
2388 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
2389 mptsas_reprobe_lun);
2390 }
2391
2392 static void
2393 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
2394 {
2395 CONFIGPARMS cfg;
2396 ConfigPageHeader_t hdr;
2397 dma_addr_t dma_handle;
2398 pRaidVolumePage0_t buffer = NULL;
2399 RaidPhysDiskPage0_t phys_disk;
2400 int i;
2401 struct mptsas_hotplug_event *ev;
2402
2403 memset(&cfg, 0 , sizeof(CONFIGPARMS));
2404 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
2405 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
2406 cfg.pageAddr = (channel << 8) + id;
2407 cfg.cfghdr.hdr = &hdr;
2408 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2409
2410 if (mpt_config(ioc, &cfg) != 0)
2411 goto out;
2412
2413 if (!hdr.PageLength)
2414 goto out;
2415
2416 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
2417 &dma_handle);
2418
2419 if (!buffer)
2420 goto out;
2421
2422 cfg.physAddr = dma_handle;
2423 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2424
2425 if (mpt_config(ioc, &cfg) != 0)
2426 goto out;
2427
2428 if (!(buffer->VolumeStatus.Flags &
2429 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
2430 goto out;
2431
2432 if (!buffer->NumPhysDisks)
2433 goto out;
2434
2435 for (i = 0; i < buffer->NumPhysDisks; i++) {
2436
2437 if (mpt_raid_phys_disk_pg0(ioc,
2438 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
2439 continue;
2440
2441 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2442 if (!ev) {
2443 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2444 goto out;
2445 }
2446
2447 INIT_WORK(&ev->work, mptsas_hotplug_work);
2448 ev->ioc = ioc;
2449 ev->id = phys_disk.PhysDiskID;
2450 ev->channel = phys_disk.PhysDiskBus;
2451 ev->phys_disk_num_valid = 1;
2452 ev->phys_disk_num = phys_disk.PhysDiskNum;
2453 ev->event_type = MPTSAS_ADD_DEVICE;
2454 schedule_work(&ev->work);
2455 }
2456
2457 out:
2458 if (buffer)
2459 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
2460 dma_handle);
2461 }
2462 /*
2463 * Work queue thread to handle SAS hotplug events
2464 */
2465 static void
2466 mptsas_hotplug_work(struct work_struct *work)
2467 {
2468 struct mptsas_hotplug_event *ev =
2469 container_of(work, struct mptsas_hotplug_event, work);
2470
2471 MPT_ADAPTER *ioc = ev->ioc;
2472 struct mptsas_phyinfo *phy_info;
2473 struct sas_rphy *rphy;
2474 struct sas_port *port;
2475 struct scsi_device *sdev;
2476 struct scsi_target * starget;
2477 struct sas_identify identify;
2478 char *ds = NULL;
2479 struct mptsas_devinfo sas_device;
2480 VirtTarget *vtarget;
2481 VirtDevice *vdevice;
2482
2483 mutex_lock(&ioc->sas_discovery_mutex);
2484 switch (ev->event_type) {
2485 case MPTSAS_DEL_DEVICE:
2486
2487 phy_info = NULL;
2488 if (ev->phys_disk_num_valid) {
2489 if (ev->hidden_raid_component){
2490 if (mptsas_sas_device_pg0(ioc, &sas_device,
2491 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2492 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2493 (ev->channel << 8) + ev->id)) {
2494 dfailprintk((MYIOC_s_ERR_FMT
2495 "%s: exit at line=%d\n", ioc->name,
2496 __FUNCTION__, __LINE__));
2497 break;
2498 }
2499 phy_info = mptsas_find_phyinfo_by_sas_address(
2500 ioc, sas_device.sas_address);
2501 }else
2502 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
2503 ioc, ev->channel, ev->phys_disk_num);
2504 }
2505
2506 if (!phy_info)
2507 phy_info = mptsas_find_phyinfo_by_target(ioc,
2508 ev->channel, ev->id);
2509
2510 /*
2511 * Sanity checks, for non-existing phys and remote rphys.
2512 */
2513 if (!phy_info){
2514 dfailprintk((MYIOC_s_ERR_FMT
2515 "%s: exit at line=%d\n", ioc->name,
2516 __FUNCTION__, __LINE__));
2517 break;
2518 }
2519 if (!phy_info->port_details) {
2520 dfailprintk((MYIOC_s_ERR_FMT
2521 "%s: exit at line=%d\n", ioc->name,
2522 __FUNCTION__, __LINE__));
2523 break;
2524 }
2525 rphy = mptsas_get_rphy(phy_info);
2526 if (!rphy) {
2527 dfailprintk((MYIOC_s_ERR_FMT
2528 "%s: exit at line=%d\n", ioc->name,
2529 __FUNCTION__, __LINE__));
2530 break;
2531 }
2532
2533 port = mptsas_get_port(phy_info);
2534 if (!port) {
2535 dfailprintk((MYIOC_s_ERR_FMT
2536 "%s: exit at line=%d\n", ioc->name,
2537 __FUNCTION__, __LINE__));
2538 break;
2539 }
2540
2541 starget = mptsas_get_starget(phy_info);
2542 if (starget) {
2543 vtarget = starget->hostdata;
2544
2545 if (!vtarget) {
2546 dfailprintk((MYIOC_s_ERR_FMT
2547 "%s: exit at line=%d\n", ioc->name,
2548 __FUNCTION__, __LINE__));
2549 break;
2550 }
2551
2552 /*
2553 * Handling RAID components
2554 */
2555 if (ev->phys_disk_num_valid &&
2556 ev->hidden_raid_component) {
2557 printk(MYIOC_s_INFO_FMT
2558 "RAID Hidding: channel=%d, id=%d, "
2559 "physdsk %d \n", ioc->name, ev->channel,
2560 ev->id, ev->phys_disk_num);
2561 vtarget->id = ev->phys_disk_num;
2562 vtarget->tflags |=
2563 MPT_TARGET_FLAGS_RAID_COMPONENT;
2564 mptsas_reprobe_target(starget, 1);
2565 phy_info->attached.phys_disk_num =
2566 ev->phys_disk_num;
2567 break;
2568 }
2569 }
2570
2571 if (phy_info->attached.device_info &
2572 MPI_SAS_DEVICE_INFO_SSP_TARGET)
2573 ds = "ssp";
2574 if (phy_info->attached.device_info &
2575 MPI_SAS_DEVICE_INFO_STP_TARGET)
2576 ds = "stp";
2577 if (phy_info->attached.device_info &
2578 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2579 ds = "sata";
2580
2581 printk(MYIOC_s_INFO_FMT
2582 "removing %s device, channel %d, id %d, phy %d\n",
2583 ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
2584 #ifdef MPT_DEBUG_SAS_WIDE
2585 dev_printk(KERN_DEBUG, &port->dev,
2586 "delete port (%d)\n", port->port_identifier);
2587 #endif
2588 sas_port_delete(port);
2589 mptsas_port_delete(phy_info->port_details);
2590 break;
2591 case MPTSAS_ADD_DEVICE:
2592
2593 if (ev->phys_disk_num_valid)
2594 mpt_findImVolumes(ioc);
2595
2596 /*
2597 * Refresh sas device pg0 data
2598 */
2599 if (mptsas_sas_device_pg0(ioc, &sas_device,
2600 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2601 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2602 (ev->channel << 8) + ev->id)) {
2603 dfailprintk((MYIOC_s_ERR_FMT
2604 "%s: exit at line=%d\n", ioc->name,
2605 __FUNCTION__, __LINE__));
2606 break;
2607 }
2608
2609 __mptsas_discovery_work(ioc);
2610
2611 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
2612 sas_device.sas_address);
2613
2614 if (!phy_info || !phy_info->port_details) {
2615 dfailprintk((MYIOC_s_ERR_FMT
2616 "%s: exit at line=%d\n", ioc->name,
2617 __FUNCTION__, __LINE__));
2618 break;
2619 }
2620
2621 starget = mptsas_get_starget(phy_info);
2622 if (starget && (!ev->hidden_raid_component)){
2623
2624 vtarget = starget->hostdata;
2625
2626 if (!vtarget) {
2627 dfailprintk((MYIOC_s_ERR_FMT
2628 "%s: exit at line=%d\n", ioc->name,
2629 __FUNCTION__, __LINE__));
2630 break;
2631 }
2632 /*
2633 * Handling RAID components
2634 */
2635 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
2636 printk(MYIOC_s_INFO_FMT
2637 "RAID Exposing: channel=%d, id=%d, "
2638 "physdsk %d \n", ioc->name, ev->channel,
2639 ev->id, ev->phys_disk_num);
2640 vtarget->tflags &=
2641 ~MPT_TARGET_FLAGS_RAID_COMPONENT;
2642 vtarget->id = ev->id;
2643 mptsas_reprobe_target(starget, 0);
2644 phy_info->attached.phys_disk_num = ~0;
2645 }
2646 break;
2647 }
2648
2649 if (mptsas_get_rphy(phy_info)) {
2650 dfailprintk((MYIOC_s_ERR_FMT
2651 "%s: exit at line=%d\n", ioc->name,
2652 __FUNCTION__, __LINE__));
2653 if (ev->channel) printk("%d\n", __LINE__);
2654 break;
2655 }
2656
2657 port = mptsas_get_port(phy_info);
2658 if (!port) {
2659 dfailprintk((MYIOC_s_ERR_FMT
2660 "%s: exit at line=%d\n", ioc->name,
2661 __FUNCTION__, __LINE__));
2662 break;
2663 }
2664 memcpy(&phy_info->attached, &sas_device,
2665 sizeof(struct mptsas_devinfo));
2666
2667 if (phy_info->attached.device_info &
2668 MPI_SAS_DEVICE_INFO_SSP_TARGET)
2669 ds = "ssp";
2670 if (phy_info->attached.device_info &
2671 MPI_SAS_DEVICE_INFO_STP_TARGET)
2672 ds = "stp";
2673 if (phy_info->attached.device_info &
2674 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
2675 ds = "sata";
2676
2677 printk(MYIOC_s_INFO_FMT
2678 "attaching %s device, channel %d, id %d, phy %d\n",
2679 ioc->name, ds, ev->channel, ev->id, ev->phy_id);
2680
2681 mptsas_parse_device_info(&identify, &phy_info->attached);
2682 rphy = sas_end_device_alloc(port);
2683 if (!rphy) {
2684 dfailprintk((MYIOC_s_ERR_FMT
2685 "%s: exit at line=%d\n", ioc->name,
2686 __FUNCTION__, __LINE__));
2687 break; /* non-fatal: an rphy can be added later */
2688 }
2689
2690 rphy->identify = identify;
2691 if (sas_rphy_add(rphy)) {
2692 dfailprintk((MYIOC_s_ERR_FMT
2693 "%s: exit at line=%d\n", ioc->name,
2694 __FUNCTION__, __LINE__));
2695 sas_rphy_free(rphy);
2696 break;
2697 }
2698 mptsas_set_rphy(phy_info, rphy);
2699 break;
2700 case MPTSAS_ADD_RAID:
2701 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2702 ev->id, 0);
2703 if (sdev) {
2704 scsi_device_put(sdev);
2705 break;
2706 }
2707 printk(MYIOC_s_INFO_FMT
2708 "attaching raid volume, channel %d, id %d\n",
2709 ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2710 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0);
2711 mpt_findImVolumes(ioc);
2712 break;
2713 case MPTSAS_DEL_RAID:
2714 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2715 ev->id, 0);
2716 if (!sdev)
2717 break;
2718 printk(MYIOC_s_INFO_FMT
2719 "removing raid volume, channel %d, id %d\n",
2720 ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2721 vdevice = sdev->hostdata;
2722 scsi_remove_device(sdev);
2723 scsi_device_put(sdev);
2724 mpt_findImVolumes(ioc);
2725 break;
2726 case MPTSAS_ADD_INACTIVE_VOLUME:
2727 mptsas_adding_inactive_raid_components(ioc,
2728 ev->channel, ev->id);
2729 break;
2730 case MPTSAS_IGNORE_EVENT:
2731 default:
2732 break;
2733 }
2734
2735 mutex_unlock(&ioc->sas_discovery_mutex);
2736 kfree(ev);
2737 }
2738
2739 static void
2740 mptsas_send_sas_event(MPT_ADAPTER *ioc,
2741 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
2742 {
2743 struct mptsas_hotplug_event *ev;
2744 u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
2745 __le64 sas_address;
2746
2747 if ((device_info &
2748 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
2749 MPI_SAS_DEVICE_INFO_STP_TARGET |
2750 MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
2751 return;
2752
2753 switch (sas_event_data->ReasonCode) {
2754 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
2755
2756 mptsas_target_reset_queue(ioc, sas_event_data);
2757 break;
2758
2759 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
2760 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2761 if (!ev) {
2762 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2763 break;
2764 }
2765
2766 INIT_WORK(&ev->work, mptsas_hotplug_work);
2767 ev->ioc = ioc;
2768 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
2769 ev->parent_handle =
2770 le16_to_cpu(sas_event_data->ParentDevHandle);
2771 ev->channel = sas_event_data->Bus;
2772 ev->id = sas_event_data->TargetID;
2773 ev->phy_id = sas_event_data->PhyNum;
2774 memcpy(&sas_address, &sas_event_data->SASAddress,
2775 sizeof(__le64));
2776 ev->sas_address = le64_to_cpu(sas_address);
2777 ev->device_info = device_info;
2778
2779 if (sas_event_data->ReasonCode &
2780 MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
2781 ev->event_type = MPTSAS_ADD_DEVICE;
2782 else
2783 ev->event_type = MPTSAS_DEL_DEVICE;
2784 schedule_work(&ev->work);
2785 break;
2786 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
2787 /*
2788 * Persistent table is full.
2789 */
2790 INIT_WORK(&ioc->sas_persist_task,
2791 mptsas_persist_clear_table);
2792 schedule_work(&ioc->sas_persist_task);
2793 break;
2794 /*
2795 * TODO, handle other events
2796 */
2797 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
2798 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
2799 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
2800 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
2801 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
2802 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
2803 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
2804 default:
2805 break;
2806 }
2807 }
2808 static void
2809 mptsas_send_raid_event(MPT_ADAPTER *ioc,
2810 EVENT_DATA_RAID *raid_event_data)
2811 {
2812 struct mptsas_hotplug_event *ev;
2813 int status = le32_to_cpu(raid_event_data->SettingsStatus);
2814 int state = (status >> 8) & 0xff;
2815
2816 if (ioc->bus_type != SAS)
2817 return;
2818
2819 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2820 if (!ev) {
2821 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2822 return;
2823 }
2824
2825 INIT_WORK(&ev->work, mptsas_hotplug_work);
2826 ev->ioc = ioc;
2827 ev->id = raid_event_data->VolumeID;
2828 ev->channel = raid_event_data->VolumeBus;
2829 ev->event_type = MPTSAS_IGNORE_EVENT;
2830
2831 switch (raid_event_data->ReasonCode) {
2832 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
2833 ev->phys_disk_num_valid = 1;
2834 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2835 ev->event_type = MPTSAS_ADD_DEVICE;
2836 break;
2837 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
2838 ev->phys_disk_num_valid = 1;
2839 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2840 ev->hidden_raid_component = 1;
2841 ev->event_type = MPTSAS_DEL_DEVICE;
2842 break;
2843 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
2844 switch (state) {
2845 case MPI_PD_STATE_ONLINE:
2846 case MPI_PD_STATE_NOT_COMPATIBLE:
2847 ev->phys_disk_num_valid = 1;
2848 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2849 ev->hidden_raid_component = 1;
2850 ev->event_type = MPTSAS_ADD_DEVICE;
2851 break;
2852 case MPI_PD_STATE_MISSING:
2853 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
2854 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
2855 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
2856 ev->phys_disk_num_valid = 1;
2857 ev->phys_disk_num = raid_event_data->PhysDiskNum;
2858 ev->event_type = MPTSAS_DEL_DEVICE;
2859 break;
2860 default:
2861 break;
2862 }
2863 break;
2864 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
2865 ev->event_type = MPTSAS_DEL_RAID;
2866 break;
2867 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
2868 ev->event_type = MPTSAS_ADD_RAID;
2869 break;
2870 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
2871 switch (state) {
2872 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
2873 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
2874 ev->event_type = MPTSAS_DEL_RAID;
2875 break;
2876 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
2877 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
2878 ev->event_type = MPTSAS_ADD_RAID;
2879 break;
2880 default:
2881 break;
2882 }
2883 break;
2884 default:
2885 break;
2886 }
2887 schedule_work(&ev->work);
2888 }
2889
2890 static void
2891 mptsas_send_discovery_event(MPT_ADAPTER *ioc,
2892 EVENT_DATA_SAS_DISCOVERY *discovery_data)
2893 {
2894 struct mptsas_discovery_event *ev;
2895
2896 /*
2897 * DiscoveryStatus
2898 *
2899 * This flag will be non-zero when firmware
2900 * kicks off discovery, and return to zero
2901 * once its completed.
2902 */
2903 if (discovery_data->DiscoveryStatus)
2904 return;
2905
2906 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2907 if (!ev)
2908 return;
2909 INIT_WORK(&ev->work, mptsas_discovery_work);
2910 ev->ioc = ioc;
2911 schedule_work(&ev->work);
2912 };
2913
2914 /*
2915 * mptsas_send_ir2_event - handle exposing hidden disk when
2916 * an inactive raid volume is added
2917 *
2918 * @ioc: Pointer to MPT_ADAPTER structure
2919 * @ir2_data
2920 *
2921 */
2922 static void
2923 mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data)
2924 {
2925 struct mptsas_hotplug_event *ev;
2926
2927 if (ir2_data->ReasonCode !=
2928 MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED)
2929 return;
2930
2931 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2932 if (!ev)
2933 return;
2934
2935 INIT_WORK(&ev->work, mptsas_hotplug_work);
2936 ev->ioc = ioc;
2937 ev->id = ir2_data->TargetID;
2938 ev->channel = ir2_data->Bus;
2939 ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME;
2940
2941 schedule_work(&ev->work);
2942 };
2943
2944 static int
2945 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
2946 {
2947 int rc=1;
2948 u8 event = le32_to_cpu(reply->Event) & 0xFF;
2949
2950 if (!ioc->sh)
2951 goto out;
2952
2953 /*
2954 * sas_discovery_ignore_events
2955 *
2956 * This flag is to prevent anymore processing of
2957 * sas events once mptsas_remove function is called.
2958 */
2959 if (ioc->sas_discovery_ignore_events) {
2960 rc = mptscsih_event_process(ioc, reply);
2961 goto out;
2962 }
2963
2964 switch (event) {
2965 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
2966 mptsas_send_sas_event(ioc,
2967 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
2968 break;
2969 case MPI_EVENT_INTEGRATED_RAID:
2970 mptsas_send_raid_event(ioc,
2971 (EVENT_DATA_RAID *)reply->Data);
2972 break;
2973 case MPI_EVENT_PERSISTENT_TABLE_FULL:
2974 INIT_WORK(&ioc->sas_persist_task,
2975 mptsas_persist_clear_table);
2976 schedule_work(&ioc->sas_persist_task);
2977 break;
2978 case MPI_EVENT_SAS_DISCOVERY:
2979 mptsas_send_discovery_event(ioc,
2980 (EVENT_DATA_SAS_DISCOVERY *)reply->Data);
2981 break;
2982 case MPI_EVENT_IR2:
2983 mptsas_send_ir2_event(ioc,
2984 (PTR_MPI_EVENT_DATA_IR2)reply->Data);
2985 break;
2986 default:
2987 rc = mptscsih_event_process(ioc, reply);
2988 break;
2989 }
2990 out:
2991
2992 return rc;
2993 }
2994
2995 static int
2996 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
2997 {
2998 struct Scsi_Host *sh;
2999 MPT_SCSI_HOST *hd;
3000 MPT_ADAPTER *ioc;
3001 unsigned long flags;
3002 int ii;
3003 int numSGE = 0;
3004 int scale;
3005 int ioc_cap;
3006 int error=0;
3007 int r;
3008
3009 r = mpt_attach(pdev,id);
3010 if (r)
3011 return r;
3012
3013 ioc = pci_get_drvdata(pdev);
3014 ioc->DoneCtx = mptsasDoneCtx;
3015 ioc->TaskCtx = mptsasTaskCtx;
3016 ioc->InternalCtx = mptsasInternalCtx;
3017
3018 /* Added sanity check on readiness of the MPT adapter.
3019 */
3020 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
3021 printk(MYIOC_s_WARN_FMT
3022 "Skipping because it's not operational!\n",
3023 ioc->name);
3024 error = -ENODEV;
3025 goto out_mptsas_probe;
3026 }
3027
3028 if (!ioc->active) {
3029 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
3030 ioc->name);
3031 error = -ENODEV;
3032 goto out_mptsas_probe;
3033 }
3034
3035 /* Sanity check - ensure at least 1 port is INITIATOR capable
3036 */
3037 ioc_cap = 0;
3038 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
3039 if (ioc->pfacts[ii].ProtocolFlags &
3040 MPI_PORTFACTS_PROTOCOL_INITIATOR)
3041 ioc_cap++;
3042 }
3043
3044 if (!ioc_cap) {
3045 printk(MYIOC_s_WARN_FMT
3046 "Skipping ioc=%p because SCSI Initiator mode "
3047 "is NOT enabled!\n", ioc->name, ioc);
3048 return 0;
3049 }
3050
3051 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
3052 if (!sh) {
3053 printk(MYIOC_s_WARN_FMT
3054 "Unable to register controller with SCSI subsystem\n",
3055 ioc->name);
3056 error = -1;
3057 goto out_mptsas_probe;
3058 }
3059
3060 spin_lock_irqsave(&ioc->FreeQlock, flags);
3061
3062 /* Attach the SCSI Host to the IOC structure
3063 */
3064 ioc->sh = sh;
3065
3066 sh->io_port = 0;
3067 sh->n_io_port = 0;
3068 sh->irq = 0;
3069
3070 /* set 16 byte cdb's */
3071 sh->max_cmd_len = 16;
3072
3073 sh->max_id = ioc->pfacts[0].PortSCSIID;
3074 sh->max_lun = max_lun;
3075
3076 sh->transportt = mptsas_transport_template;
3077
3078 sh->this_id = ioc->pfacts[0].PortSCSIID;
3079
3080 /* Required entry.
3081 */
3082 sh->unique_id = ioc->id;
3083
3084 INIT_LIST_HEAD(&ioc->sas_topology);
3085 mutex_init(&ioc->sas_topology_mutex);
3086 mutex_init(&ioc->sas_discovery_mutex);
3087 mutex_init(&ioc->sas_mgmt.mutex);
3088 init_completion(&ioc->sas_mgmt.done);
3089
3090 /* Verify that we won't exceed the maximum
3091 * number of chain buffers
3092 * We can optimize: ZZ = req_sz/sizeof(SGE)
3093 * For 32bit SGE's:
3094 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
3095 * + (req_sz - 64)/sizeof(SGE)
3096 * A slightly different algorithm is required for
3097 * 64bit SGEs.
3098 */
3099 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
3100 if (sizeof(dma_addr_t) == sizeof(u64)) {
3101 numSGE = (scale - 1) *
3102 (ioc->facts.MaxChainDepth-1) + scale +
3103 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
3104 sizeof(u32));
3105 } else {
3106 numSGE = 1 + (scale - 1) *
3107 (ioc->facts.MaxChainDepth-1) + scale +
3108 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
3109 sizeof(u32));
3110 }
3111
3112 if (numSGE < sh->sg_tablesize) {
3113 /* Reset this value */
3114 dprintk((MYIOC_s_INFO_FMT
3115 "Resetting sg_tablesize to %d from %d\n",
3116 ioc->name, numSGE, sh->sg_tablesize));
3117 sh->sg_tablesize = numSGE;
3118 }
3119
3120 hd = (MPT_SCSI_HOST *) sh->hostdata;
3121 hd->ioc = ioc;
3122
3123 /* SCSI needs scsi_cmnd lookup table!
3124 * (with size equal to req_depth*PtrSz!)
3125 */
3126 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
3127 if (!hd->ScsiLookup) {
3128 error = -ENOMEM;
3129 goto out_mptsas_probe;
3130 }
3131
3132 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
3133 ioc->name, hd->ScsiLookup));
3134
3135 /* Clear the TM flags
3136 */
3137 hd->tmPending = 0;
3138 hd->tmState = TM_STATE_NONE;
3139 hd->resetPending = 0;
3140 hd->abortSCpnt = NULL;
3141
3142 /* Clear the pointer used to store
3143 * single-threaded commands, i.e., those
3144 * issued during a bus scan, dv and
3145 * configuration pages.
3146 */
3147 hd->cmdPtr = NULL;
3148
3149 /* Initialize this SCSI Hosts' timers
3150 * To use, set the timer expires field
3151 * and add_timer
3152 */
3153 init_timer(&hd->timer);
3154 hd->timer.data = (unsigned long) hd;
3155 hd->timer.function = mptscsih_timer_expired;
3156
3157 ioc->sas_data.ptClear = mpt_pt_clear;
3158
3159 init_waitqueue_head(&hd->scandv_waitq);
3160 hd->scandv_wait_done = 0;
3161 hd->last_queue_full = 0;
3162 INIT_LIST_HEAD(&hd->target_reset_list);
3163 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
3164
3165 if (ioc->sas_data.ptClear==1) {
3166 mptbase_sas_persist_operation(
3167 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
3168 }
3169
3170 error = scsi_add_host(sh, &ioc->pcidev->dev);
3171 if (error) {
3172 dprintk((KERN_ERR MYNAM
3173 "scsi_add_host failed\n"));
3174 goto out_mptsas_probe;
3175 }
3176
3177 mptsas_scan_sas_topology(ioc);
3178
3179 return 0;
3180
3181 out_mptsas_probe:
3182
3183 mptscsih_remove(pdev);
3184 return error;
3185 }
3186
3187 static void __devexit mptsas_remove(struct pci_dev *pdev)
3188 {
3189 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
3190 struct mptsas_portinfo *p, *n;
3191 int i;
3192
3193 ioc->sas_discovery_ignore_events = 1;
3194 sas_remove_host(ioc->sh);
3195
3196 mutex_lock(&ioc->sas_topology_mutex);
3197 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
3198 list_del(&p->list);
3199 for (i = 0 ; i < p->num_phys ; i++)
3200 mptsas_port_delete(p->phy_info[i].port_details);
3201 kfree(p->phy_info);
3202 kfree(p);
3203 }
3204 mutex_unlock(&ioc->sas_topology_mutex);
3205
3206 mptscsih_remove(pdev);
3207 }
3208
3209 static struct pci_device_id mptsas_pci_table[] = {
3210 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
3211 PCI_ANY_ID, PCI_ANY_ID },
3212 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
3213 PCI_ANY_ID, PCI_ANY_ID },
3214 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
3215 PCI_ANY_ID, PCI_ANY_ID },
3216 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
3217 PCI_ANY_ID, PCI_ANY_ID },
3218 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
3219 PCI_ANY_ID, PCI_ANY_ID },
3220 {0} /* Terminating entry */
3221 };
3222 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
3223
3224
3225 static struct pci_driver mptsas_driver = {
3226 .name = "mptsas",
3227 .id_table = mptsas_pci_table,
3228 .probe = mptsas_probe,
3229 .remove = __devexit_p(mptsas_remove),
3230 .shutdown = mptscsih_shutdown,
3231 #ifdef CONFIG_PM
3232 .suspend = mptscsih_suspend,
3233 .resume = mptscsih_resume,
3234 #endif
3235 };
3236
3237 static int __init
3238 mptsas_init(void)
3239 {
3240 show_mptmod_ver(my_NAME, my_VERSION);
3241
3242 mptsas_transport_template =
3243 sas_attach_transport(&mptsas_transport_functions);
3244 if (!mptsas_transport_template)
3245 return -ENODEV;
3246
3247 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
3248 mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
3249 mptsasInternalCtx =
3250 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
3251 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
3252
3253 if (mpt_event_register(mptsasDoneCtx, mptsas_event_process) == 0) {
3254 devtverboseprintk((KERN_INFO MYNAM
3255 ": Registered for IOC event notifications\n"));
3256 }
3257
3258 if (mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset) == 0) {
3259 dprintk((KERN_INFO MYNAM
3260 ": Registered for IOC reset notifications\n"));
3261 }
3262
3263 return pci_register_driver(&mptsas_driver);
3264 }
3265
3266 static void __exit
3267 mptsas_exit(void)
3268 {
3269 pci_unregister_driver(&mptsas_driver);
3270 sas_release_transport(mptsas_transport_template);
3271
3272 mpt_reset_deregister(mptsasDoneCtx);
3273 mpt_event_deregister(mptsasDoneCtx);
3274
3275 mpt_deregister(mptsasMgmtCtx);
3276 mpt_deregister(mptsasInternalCtx);
3277 mpt_deregister(mptsasTaskCtx);
3278 mpt_deregister(mptsasDoneCtx);
3279 }
3280
3281 module_init(mptsas_init);
3282 module_exit(mptsas_exit);
Linux kernel - Deliverables
This page took 0.190447 seconds and 5 git commands to generate.