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