projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] add PCI_VENDOR_ID macro for Brocade in pci_ids.h
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / message / fusion / mptsas.c
CommitLineData
0c33b27d
CH		 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 *
9f4203b3 6 * Copyright (c) 1999-2007 LSI Logic Corporation
16d20101 7 * (mailto:DL-MPTFusionLinux@lsi.com)
9f4203b3 8 * Copyright (c) 2005-2007 Dell
0c33b27d
CH		 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>
cd354f1a 51#include <linux/jiffies.h>
0c33b27d 52#include <linux/workqueue.h>
547f9a21 53#include <linux/delay.h> /* for mdelay */
0c33b27d 54
547f9a21 55#include <scsi/scsi.h>
0c33b27d
CH		 56#include <scsi/scsi_cmnd.h>
57#include <scsi/scsi_device.h>
58#include <scsi/scsi_host.h>
59#include <scsi/scsi_transport_sas.h>
547f9a21 60#include <scsi/scsi_dbg.h>
0c33b27d
CH		 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
e8bf3941
JB		 70/*
71 * Reserved channel for integrated raid
72 */
73#define MPTSAS_RAID_CHANNEL 1
74
0c33b27d
CH		 75MODULE_AUTHOR(MODULEAUTHOR);
76MODULE_DESCRIPTION(my_NAME);
77MODULE_LICENSE("GPL");
9f4203b3 78MODULE_VERSION(my_VERSION);
0c33b27d 79
0c33b27d
CH		 80static int mpt_pt_clear;
81module_param(mpt_pt_clear, int, 0);
82MODULE_PARM_DESC(mpt_pt_clear,
ba856d32 83 " Clear persistency table: enable=1 "
0c33b27d
CH		 84 "(default=MPTSCSIH_PT_CLEAR=0)");
85
793955f5
EM		 86/* scsi-mid layer global parmeter is max_report_luns, which is 511 */
87#define MPTSAS_MAX_LUN (16895)
88static int max_lun = MPTSAS_MAX_LUN;
89module_param(max_lun, int, 0);
90MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
91
0c33b27d
CH		 92static int mptsasDoneCtx = -1;
93static int mptsasTaskCtx = -1;
94static int mptsasInternalCtx = -1; /* Used only for internal commands */
da4fa655 95static int mptsasMgmtCtx = -1;
0c33b27d 96
b506ade9 97static void mptsas_hotplug_work(struct work_struct *work);
0c33b27d 98
df9e062a
EM		 99struct 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
9a28f49a
CH		 105enum mptsas_hotplug_action {
106 MPTSAS_ADD_DEVICE,
107 MPTSAS_DEL_DEVICE,
c73787ee
ME		 108 MPTSAS_ADD_RAID,
109 MPTSAS_DEL_RAID,
b506ade9 110 MPTSAS_ADD_INACTIVE_VOLUME,
bd23e94c 111 MPTSAS_IGNORE_EVENT,
9a28f49a
CH		 112};
113
114struct mptsas_hotplug_event {
115 struct work_struct work;
116 MPT_ADAPTER *ioc;
117 enum mptsas_hotplug_action event_type;
118 u64 sas_address;
b506ade9
EM		 119 u8 channel;
120 u8 id;
9a28f49a
CH		 121 u32 device_info;
122 u16 handle;
123 u16 parent_handle;
124 u8 phy_id;
b506ade9
EM		 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*/
9a28f49a
CH		 128};
129
e6b2d76a
ME		 130struct mptsas_discovery_event {
131 struct work_struct work;
132 MPT_ADAPTER *ioc;
133};
134
0c33b27d
CH		 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
143struct mptsas_devinfo {
144 u16 handle; /* unique id to address this device */
c73787ee 145 u16 handle_parent; /* unique id to address parent device */
e3094447
CH		 146 u16 handle_enclosure; /* enclosure identifier of the enclosure */
147 u16 slot; /* physical slot in enclosure */
0c33b27d
CH		 148 u8 phy_id; /* phy number of parent device */
149 u8 port_id; /* sas physical port this device
150 is assoc'd with */
9a28f49a 151 u8 id; /* logical target id of this device */
b506ade9 152 u32 phys_disk_num; /* phys disk id, for csmi-ioctls */
9a28f49a 153 u8 channel; /* logical bus number of this device */
0c33b27d
CH		 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
547f9a21
EM		 159/*
160 * Specific details on ports, wide/narrow
161 */
162struct mptsas_portinfo_details{
547f9a21
EM		 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
0c33b27d 171struct mptsas_phyinfo {
2ecce492 172 u16 handle; /* unique id to address this */
0c33b27d 173 u8 phy_id; /* phy index */
547f9a21 174 u8 port_id; /* firmware port identifier */
0c33b27d
CH		 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 */
547f9a21 178 u8 sas_port_add_phy; /* flag to request sas_port_add_phy*/
0c33b27d
CH		 179 struct mptsas_devinfo identify; /* point to phy device info */
180 struct mptsas_devinfo attached; /* point to attached device info */
547f9a21
EM		 181 struct sas_phy *phy; /* transport layer phy object */
182 struct mptsas_portinfo *portinfo;
183 struct mptsas_portinfo_details * port_details;
0c33b27d
CH		 184};
185
186struct mptsas_portinfo {
187 struct list_head list;
547f9a21 188 u16 num_phys; /* number of phys */
0c33b27d
CH		 189 struct mptsas_phyinfo *phy_info;
190};
191
e3094447
CH		 192struct 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
547f9a21 204#ifdef MPT_DEBUG_SAS
b5141128
CH		 205static 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
223static 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
243static void mptsas_print_phy_pg1(SasPhyPage1_t *pg1)
244{
245 printk("---- SAS PHY PAGE 1 ------------\n");
f9a2d2e0
CH		 246 printk("Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount);
247 printk("Running Disparity Error Count=0x%x\n",
b5141128 248 pg1->RunningDisparityErrorCount);
f9a2d2e0
CH		 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");
b5141128
CH		 252}
253
254static 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));
e3094447 262 printk("Parent Handle=0x%X\n" ,le16_to_cpu(pg0->ParentDevHandle));
b5141128
CH		 263 printk("Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle));
264 printk("Slot=0x%X\n", le16_to_cpu(pg0->Slot));
f99be43b
EM		 265 printk("SAS Address=0x%llX\n", (unsigned long long)
266 le64_to_cpu(sas_address));
b5141128
CH		 267 printk("Target ID=0x%X\n", pg0->TargetID);
268 printk("Bus=0x%X\n", pg0->Bus);
f9a2d2e0
CH		 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));
b5141128
CH		 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
280static 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);
f9a2d2e0 285 printk("PHY Identifier=0x%X\n", pg1->PhyIdentifier);
b5141128
CH		 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
e3094447
CH		 302static 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
308static 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
e6b2d76a
ME		 314/*
315 * mptsas_find_portinfo_by_handle
316 *
317 * This function should be called with the sas_topology_mutex already held
318 */
319static struct mptsas_portinfo *
320mptsas_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
bd23e94c
ME		 335/*
336 * Returns true if there is a scsi end device
337 */
338static inline int
339mptsas_is_end_device(struct mptsas_devinfo * attached)
340{
547f9a21 341 if ((attached->sas_address) &&
bd23e94c
ME		 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
547f9a21 355/* no mutex */
376ac830 356static void
547f9a21
EM		 357mptsas_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
dc22f16d 369 dsaswideprintk((KERN_DEBUG "%s: [%p]: num_phys=%02d "
f99be43b
EM		 370 "bitmask=0x%016llX\n", __FUNCTION__, port_details,
371 port_details->num_phys, (unsigned long long)
372 port_details->phy_bitmask));
547f9a21
EM		 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
383static inline struct sas_rphy *
384mptsas_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
392static inline void
393mptsas_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
409static inline struct sas_port *
410mptsas_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
418static inline void
419mptsas_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
433static inline struct scsi_target *
434mptsas_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
442static inline void
443mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
444starget)
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 */
376ac830 457static void
547f9a21
EM		 458mptsas_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
dc22f16d
EM		 481 "%s: [%p]: deleting phy = %d\n",
482 __FUNCTION__, port_details, i));
547f9a21
EM		 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",
f99be43b 497 i, (unsigned long long)sas_address));
547f9a21
EM		 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;
547f9a21
EM		 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"
f99be43b
EM		 516 "phy_id=%d sas_address=0x%018llX\n",
517 i, (unsigned long long)sas_address));
547f9a21
EM		 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
f99be43b
EM		 533 "\t\tphy_id=%d sas_address=0x%018llX\n",
534 j, (unsigned long long)
535 phy_info_cmp->attached.sas_address));
547f9a21
EM		 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);
547f9a21
EM		 543 port_details->num_phys =
544 phy_info_cmp->port_details->num_phys;
547f9a21
EM		 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
f99be43b
EM		 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));
547f9a21
EM		 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
df9e062a
EM		 580/**
581 * csmisas_find_vtarget
582 *
583 * @ioc
584 * @volume_id
585 * @volume_bus
586 *
587 **/
588static VirtTarget *
589mptsas_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 **/
618static int
619mptsas_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 **/
547f9a21 664static void
df9e062a
EM		 665mptsas_target_reset_queue(MPT_ADAPTER *ioc,
666 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
547f9a21 667{
df9e062a
EM		 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;
547f9a21 672
df9e062a
EM		 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 **/
712static void
713mptsas_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 **/
801static int
802mptsas_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 **/
815static int
816mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
817{
ba76ef24 818 MPT_SCSI_HOST *hd;
df9e062a
EM		 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
ba76ef24
JL		 830 if (!ioc->sh || !ioc->sh->hostdata)
831 goto out;
832 hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
833 if (!hd->ioc)
df9e062a
EM		 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);
547f9a21 844 }
df9e062a
EM		 845
846 out:
847 return rc;
547f9a21
EM		 848}
849
e3094447 850static int
52435430 851mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
e3094447
CH		 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}
b5141128 914
f013db32
JB		 915static int
916mptsas_slave_configure(struct scsi_device *sdev)
917{
3c0c25b9 918
e8bf3941
JB		 919 if (sdev->channel == MPTSAS_RAID_CHANNEL)
920 goto out;
921
922 sas_read_port_mode_page(sdev);
f013db32 923
e8bf3941 924 out:
f013db32
JB		 925 return mptscsih_slave_configure(sdev);
926}
927
547f9a21
EM		 928static int
929mptsas_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;
793955f5 934 u8 id, channel;
547f9a21
EM		 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;
793955f5
EM		 945 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
946 id = starget->id;
547f9a21
EM		 947 channel = 0;
948
793955f5
EM		 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;
547f9a21 956 goto out;
793955f5 957 }
547f9a21
EM		 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;
793955f5 966 id = p->phy_info[i].attached.id;
547f9a21
EM		 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 */
793955f5
EM		 973 if (mptscsih_is_phys_disk(hd->ioc, channel, id)) {
974 id = mptscsih_raid_id_to_num(hd->ioc,
975 channel, id);
547f9a21
EM		 976 vtarget->tflags |=
977 MPT_TARGET_FLAGS_RAID_COMPONENT;
b506ade9 978 p->phy_info[i].attached.phys_disk_num = id;
547f9a21
EM		 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:
793955f5
EM		 990 vtarget->id = id;
991 vtarget->channel = channel;
547f9a21
EM		 992 starget->hostdata = vtarget;
993 return 0;
994}
995
996static void
997mptsas_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
e8bf3941 1008 if (starget->channel == MPTSAS_RAID_CHANNEL)
547f9a21
EM		 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
0c33b27d 1028static int
c7c82987 1029mptsas_slave_alloc(struct scsi_device *sdev)
0c33b27d 1030{
c7c82987 1031 struct Scsi_Host *host = sdev->host;
0c33b27d
CH		 1032 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
1033 struct sas_rphy *rphy;
1034 struct mptsas_portinfo *p;
1035 VirtDevice *vdev;
c7c82987 1036 struct scsi_target *starget;
547f9a21 1037 int i;
0c33b27d 1038
1ca00bb7 1039 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
0c33b27d 1040 if (!vdev) {
547f9a21 1041 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
0c33b27d
CH		 1042 hd->ioc->name, sizeof(VirtDevice));
1043 return -ENOMEM;
1044 }
c7c82987 1045 starget = scsi_target(sdev);
547f9a21 1046 vdev->vtarget = starget->hostdata;
0c33b27d 1047
e8bf3941 1048 if (sdev->channel == MPTSAS_RAID_CHANNEL)
816aa907 1049 goto out;
816aa907 1050
c7c82987 1051 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
9a28f49a 1052 mutex_lock(&hd->ioc->sas_topology_mutex);
0c33b27d
CH		 1053 list_for_each_entry(p, &hd->ioc->sas_topology, list) {
1054 for (i = 0; i < p->num_phys; i++) {
547f9a21
EM		 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,
793955f5
EM		 1063 p->phy_info[i].attached.channel,
1064 p->phy_info[i].attached.id))
547f9a21
EM		 1065 sdev->no_uld_attach = 1;
1066 mutex_unlock(&hd->ioc->sas_topology_mutex);
1067 goto out;
0c33b27d
CH		 1068 }
1069 }
9a28f49a 1070 mutex_unlock(&hd->ioc->sas_topology_mutex);
0c33b27d 1071
0c33b27d 1072 kfree(vdev);
23f236ed 1073 return -ENXIO;
0c33b27d
CH		 1074
1075 out:
547f9a21
EM		 1076 vdev->vtarget->num_luns++;
1077 sdev->hostdata = vdev;
0c33b27d
CH		 1078 return 0;
1079}
1080
547f9a21
EM		 1081static int
1082mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
9a28f49a 1083{
547f9a21 1084 VirtDevice *vdev = SCpnt->device->hostdata;
7d3eecf7 1085
793955f5 1086 if (!vdev || !vdev->vtarget || vdev->vtarget->deleted) {
547f9a21
EM		 1087 SCpnt->result = DID_NO_CONNECT << 16;
1088 done(SCpnt);
1089 return 0;
7d3eecf7 1090 }
547f9a21 1091
793955f5
EM		 1092// scsi_print_command(SCpnt);
1093
547f9a21 1094 return mptscsih_qcmd(SCpnt,done);
9a28f49a
CH		 1095}
1096
547f9a21 1097
0c33b27d 1098static struct scsi_host_template mptsas_driver_template = {
f78496da 1099 .module = THIS_MODULE,
0c33b27d
CH		 1100 .proc_name = "mptsas",
1101 .proc_info = mptscsih_proc_info,
1102 .name = "MPT SPI Host",
1103 .info = mptscsih_info,
547f9a21
EM		 1104 .queuecommand = mptsas_qcmd,
1105 .target_alloc = mptsas_target_alloc,
0c33b27d 1106 .slave_alloc = mptsas_slave_alloc,
f013db32 1107 .slave_configure = mptsas_slave_configure,
547f9a21
EM		 1108 .target_destroy = mptsas_target_destroy,
1109 .slave_destroy = mptscsih_slave_destroy,
0c33b27d
CH		 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,
edb9068d 1122 .shost_attrs = mptscsih_host_attrs,
0c33b27d
CH		 1123};
1124
b5141128 1125static int mptsas_get_linkerrors(struct sas_phy *phy)
0c33b27d 1126{
b5141128
CH		 1127 MPT_ADAPTER *ioc = phy_to_ioc(phy);
1128 ConfigExtendedPageHeader_t hdr;
1129 CONFIGPARMS cfg;
1130 SasPhyPage1_t *buffer;
1131 dma_addr_t dma_handle;
1132 int error;
0c33b27d 1133
f4ad7b58
JB		 1134 /* FIXME: only have link errors on local phys */
1135 if (!scsi_is_sas_phy_local(phy))
1136 return -EINVAL;
1137
b5141128
CH		 1138 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
1139 hdr.ExtPageLength = 0;
1140 hdr.PageNumber = 1 /* page number 1*/;
1141 hdr.Reserved1 = 0;
1142 hdr.Reserved2 = 0;
1143 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1144 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
0c33b27d 1145
b5141128
CH		 1146 cfg.cfghdr.ehdr = &hdr;
1147 cfg.physAddr = -1;
1148 cfg.pageAddr = phy->identify.phy_identifier;
1149 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1150 cfg.dir = 0; /* read */
1151 cfg.timeout = 10;
0c33b27d 1152
b5141128
CH		 1153 error = mpt_config(ioc, &cfg);
1154 if (error)
1155 return error;
1156 if (!hdr.ExtPageLength)
1157 return -ENXIO;
0c33b27d 1158
b5141128
CH		 1159 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1160 &dma_handle);
1161 if (!buffer)
1162 return -ENOMEM;
0c33b27d 1163
b5141128
CH		 1164 cfg.physAddr = dma_handle;
1165 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1166
1167 error = mpt_config(ioc, &cfg);
1168 if (error)
1169 goto out_free_consistent;
1170
1171 mptsas_print_phy_pg1(buffer);
1172
1173 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
1174 phy->running_disparity_error_count =
1175 le32_to_cpu(buffer->RunningDisparityErrorCount);
1176 phy->loss_of_dword_sync_count =
1177 le32_to_cpu(buffer->LossDwordSynchCount);
1178 phy->phy_reset_problem_count =
1179 le32_to_cpu(buffer->PhyResetProblemCount);
1180
1181 out_free_consistent:
1182 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1183 buffer, dma_handle);
1184 return error;
0c33b27d
CH		 1185}
1186
da4fa655
CH		 1187static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
1188 MPT_FRAME_HDR *reply)
1189{
1190 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
1191 if (reply != NULL) {
1192 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
1193 memcpy(ioc->sas_mgmt.reply, reply,
1194 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
1195 }
1196 complete(&ioc->sas_mgmt.done);
1197 return 1;
1198}
1199
1200static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
1201{
1202 MPT_ADAPTER *ioc = phy_to_ioc(phy);
1203 SasIoUnitControlRequest_t *req;
1204 SasIoUnitControlReply_t *reply;
1205 MPT_FRAME_HDR *mf;
1206 MPIHeader_t *hdr;
1207 unsigned long timeleft;
1208 int error = -ERESTARTSYS;
1209
f4ad7b58
JB		 1210 /* FIXME: fusion doesn't allow non-local phy reset */
1211 if (!scsi_is_sas_phy_local(phy))
1212 return -EINVAL;
1213
da4fa655
CH		 1214 /* not implemented for expanders */
1215 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
1216 return -ENXIO;
1217
eeb846ce 1218 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
da4fa655
CH		 1219 goto out;
1220
1221 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
1222 if (!mf) {
1223 error = -ENOMEM;
1224 goto out_unlock;
1225 }
1226
1227 hdr = (MPIHeader_t *) mf;
1228 req = (SasIoUnitControlRequest_t *)mf;
1229 memset(req, 0, sizeof(SasIoUnitControlRequest_t));
1230 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
1231 req->MsgContext = hdr->MsgContext;
1232 req->Operation = hard_reset ?
1233 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
1234 req->PhyNum = phy->identify.phy_identifier;
1235
1236 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
1237
1238 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
1239 10 * HZ);
1240 if (!timeleft) {
1241 /* On timeout reset the board */
1242 mpt_free_msg_frame(ioc, mf);
1243 mpt_HardResetHandler(ioc, CAN_SLEEP);
1244 error = -ETIMEDOUT;
1245 goto out_unlock;
1246 }
1247
1248 /* a reply frame is expected */
1249 if ((ioc->sas_mgmt.status &
1250 MPT_IOCTL_STATUS_RF_VALID) == 0) {
1251 error = -ENXIO;
1252 goto out_unlock;
1253 }
1254
1255 /* process the completed Reply Message Frame */
1256 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
1257 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
1258 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
1259 __FUNCTION__,
1260 reply->IOCStatus,
1261 reply->IOCLogInfo);
1262 error = -ENXIO;
1263 goto out_unlock;
1264 }
1265
1266 error = 0;
1267
1268 out_unlock:
eeb846ce 1269 mutex_unlock(&ioc->sas_mgmt.mutex);
da4fa655
CH		 1270 out:
1271 return error;
1272}
0c33b27d 1273
e3094447
CH		 1274static int
1275mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
1276{
1277 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1278 int i, error;
1279 struct mptsas_portinfo *p;
1280 struct mptsas_enclosure enclosure_info;
1281 u64 enclosure_handle;
1282
1283 mutex_lock(&ioc->sas_topology_mutex);
1284 list_for_each_entry(p, &ioc->sas_topology, list) {
1285 for (i = 0; i < p->num_phys; i++) {
1286 if (p->phy_info[i].attached.sas_address ==
1287 rphy->identify.sas_address) {
1288 enclosure_handle = p->phy_info[i].
1289 attached.handle_enclosure;
1290 goto found_info;
1291 }
1292 }
1293 }
1294 mutex_unlock(&ioc->sas_topology_mutex);
1295 return -ENXIO;
1296
1297 found_info:
1298 mutex_unlock(&ioc->sas_topology_mutex);
1299 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
52435430 1300 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
e3094447
CH		 1301 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
1302 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
1303 if (!error)
1304 *identifier = enclosure_info.enclosure_logical_id;
1305 return error;
1306}
1307
1308static int
1309mptsas_get_bay_identifier(struct sas_rphy *rphy)
1310{
1311 MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
1312 struct mptsas_portinfo *p;
1313 int i, rc;
1314
1315 mutex_lock(&ioc->sas_topology_mutex);
1316 list_for_each_entry(p, &ioc->sas_topology, list) {
1317 for (i = 0; i < p->num_phys; i++) {
1318 if (p->phy_info[i].attached.sas_address ==
1319 rphy->identify.sas_address) {
1320 rc = p->phy_info[i].attached.slot;
1321 goto out;
1322 }
1323 }
1324 }
1325 rc = -ENXIO;
1326 out:
1327 mutex_unlock(&ioc->sas_topology_mutex);
1328 return rc;
1329}
1330
b5141128
CH		 1331static struct sas_function_template mptsas_transport_functions = {
1332 .get_linkerrors = mptsas_get_linkerrors,
e3094447
CH		 1333 .get_enclosure_identifier = mptsas_get_enclosure_identifier,
1334 .get_bay_identifier = mptsas_get_bay_identifier,
da4fa655 1335 .phy_reset = mptsas_phy_reset,
b5141128
CH		 1336};
1337
1338static struct scsi_transport_template *mptsas_transport_template;
0c33b27d
CH		 1339
1340static int
1341mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
1342{
1343 ConfigExtendedPageHeader_t hdr;
1344 CONFIGPARMS cfg;
1345 SasIOUnitPage0_t *buffer;
1346 dma_addr_t dma_handle;
1347 int error, i;
1348
1349 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
1350 hdr.ExtPageLength = 0;
1351 hdr.PageNumber = 0;
1352 hdr.Reserved1 = 0;
1353 hdr.Reserved2 = 0;
1354 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1355 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1356
1357 cfg.cfghdr.ehdr = &hdr;
1358 cfg.physAddr = -1;
1359 cfg.pageAddr = 0;
1360 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1361 cfg.dir = 0; /* read */
1362 cfg.timeout = 10;
1363
1364 error = mpt_config(ioc, &cfg);
1365 if (error)
1366 goto out;
1367 if (!hdr.ExtPageLength) {
1368 error = -ENXIO;
1369 goto out;
1370 }
1371
1372 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1373 &dma_handle);
1374 if (!buffer) {
1375 error = -ENOMEM;
1376 goto out;
1377 }
1378
1379 cfg.physAddr = dma_handle;
1380 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1381
1382 error = mpt_config(ioc, &cfg);
1383 if (error)
1384 goto out_free_consistent;
1385
1386 port_info->num_phys = buffer->NumPhys;
1387 port_info->phy_info = kcalloc(port_info->num_phys,
547f9a21 1388 sizeof(*port_info->phy_info),GFP_KERNEL);
0c33b27d
CH		 1389 if (!port_info->phy_info) {
1390 error = -ENOMEM;
1391 goto out_free_consistent;
1392 }
1393
edb9068d
PS		 1394 ioc->nvdata_version_persistent =
1395 le16_to_cpu(buffer->NvdataVersionPersistent);
1396 ioc->nvdata_version_default =
1397 le16_to_cpu(buffer->NvdataVersionDefault);
1398
0c33b27d
CH		 1399 for (i = 0; i < port_info->num_phys; i++) {
1400 mptsas_print_phy_data(&buffer->PhyData[i]);
1401 port_info->phy_info[i].phy_id = i;
1402 port_info->phy_info[i].port_id =
1403 buffer->PhyData[i].Port;
1404 port_info->phy_info[i].negotiated_link_rate =
1405 buffer->PhyData[i].NegotiatedLinkRate;
547f9a21 1406 port_info->phy_info[i].portinfo = port_info;
2ecce492
EM		 1407 port_info->phy_info[i].handle =
1408 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
0c33b27d
CH		 1409 }
1410
1411 out_free_consistent:
1412 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1413 buffer, dma_handle);
1414 out:
1415 return error;
1416}
1417
edb9068d
PS		 1418static int
1419mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
1420{
1421 ConfigExtendedPageHeader_t hdr;
1422 CONFIGPARMS cfg;
1423 SasIOUnitPage1_t *buffer;
1424 dma_addr_t dma_handle;
1425 int error;
1426 u16 device_missing_delay;
1427
1428 memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
1429 memset(&cfg, 0, sizeof(CONFIGPARMS));
1430
1431 cfg.cfghdr.ehdr = &hdr;
1432 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1433 cfg.timeout = 10;
1434 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1435 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1436 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
1437 cfg.cfghdr.ehdr->PageNumber = 1;
1438
1439 error = mpt_config(ioc, &cfg);
1440 if (error)
1441 goto out;
1442 if (!hdr.ExtPageLength) {
1443 error = -ENXIO;
1444 goto out;
1445 }
1446
1447 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1448 &dma_handle);
1449 if (!buffer) {
1450 error = -ENOMEM;
1451 goto out;
1452 }
1453
1454 cfg.physAddr = dma_handle;
1455 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1456
1457 error = mpt_config(ioc, &cfg);
1458 if (error)
1459 goto out_free_consistent;
1460
1461 ioc->io_missing_delay =
1462 le16_to_cpu(buffer->IODeviceMissingDelay);
1463 device_missing_delay = le16_to_cpu(buffer->ReportDeviceMissingDelay);
1464 ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ?
1465 (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 :
1466 device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK;
1467
1468 out_free_consistent:
1469 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1470 buffer, dma_handle);
1471 out:
1472 return error;
1473}
1474
0c33b27d
CH		 1475static int
1476mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1477 u32 form, u32 form_specific)
1478{
1479 ConfigExtendedPageHeader_t hdr;
1480 CONFIGPARMS cfg;
1481 SasPhyPage0_t *buffer;
1482 dma_addr_t dma_handle;
1483 int error;
1484
1485 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
1486 hdr.ExtPageLength = 0;
1487 hdr.PageNumber = 0;
1488 hdr.Reserved1 = 0;
1489 hdr.Reserved2 = 0;
1490 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1491 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1492
1493 cfg.cfghdr.ehdr = &hdr;
1494 cfg.dir = 0; /* read */
1495 cfg.timeout = 10;
1496
1497 /* Get Phy Pg 0 for each Phy. */
1498 cfg.physAddr = -1;
1499 cfg.pageAddr = form + form_specific;
1500 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1501
1502 error = mpt_config(ioc, &cfg);
1503 if (error)
1504 goto out;
1505
1506 if (!hdr.ExtPageLength) {
1507 error = -ENXIO;
1508 goto out;
1509 }
1510
1511 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1512 &dma_handle);
1513 if (!buffer) {
1514 error = -ENOMEM;
1515 goto out;
1516 }
1517
1518 cfg.physAddr = dma_handle;
1519 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1520
1521 error = mpt_config(ioc, &cfg);
1522 if (error)
1523 goto out_free_consistent;
1524
1525 mptsas_print_phy_pg0(buffer);
1526
1527 phy_info->hw_link_rate = buffer->HwLinkRate;
1528 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1529 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1530 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1531
1532 out_free_consistent:
1533 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1534 buffer, dma_handle);
1535 out:
1536 return error;
1537}
1538
1539static int
1540mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
1541 u32 form, u32 form_specific)
1542{
1543 ConfigExtendedPageHeader_t hdr;
1544 CONFIGPARMS cfg;
1545 SasDevicePage0_t *buffer;
1546 dma_addr_t dma_handle;
1547 __le64 sas_address;
bd23e94c
ME		 1548 int error=0;
1549
1550 if (ioc->sas_discovery_runtime &&
1551 mptsas_is_end_device(device_info))
1552 goto out;
0c33b27d
CH		 1553
1554 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
1555 hdr.ExtPageLength = 0;
1556 hdr.PageNumber = 0;
1557 hdr.Reserved1 = 0;
1558 hdr.Reserved2 = 0;
1559 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1560 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1561
1562 cfg.cfghdr.ehdr = &hdr;
1563 cfg.pageAddr = form + form_specific;
1564 cfg.physAddr = -1;
1565 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1566 cfg.dir = 0; /* read */
1567 cfg.timeout = 10;
1568
db9c9174 1569 memset(device_info, 0, sizeof(struct mptsas_devinfo));
0c33b27d
CH		 1570 error = mpt_config(ioc, &cfg);
1571 if (error)
1572 goto out;
1573 if (!hdr.ExtPageLength) {
1574 error = -ENXIO;
1575 goto out;
1576 }
1577
1578 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1579 &dma_handle);
1580 if (!buffer) {
1581 error = -ENOMEM;
1582 goto out;
1583 }
1584
1585 cfg.physAddr = dma_handle;
1586 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1587
1588 error = mpt_config(ioc, &cfg);
1589 if (error)
1590 goto out_free_consistent;
1591
1592 mptsas_print_device_pg0(buffer);
1593
1594 device_info->handle = le16_to_cpu(buffer->DevHandle);
c73787ee 1595 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
e3094447
CH		 1596 device_info->handle_enclosure =
1597 le16_to_cpu(buffer->EnclosureHandle);
1598 device_info->slot = le16_to_cpu(buffer->Slot);
0c33b27d
CH		 1599 device_info->phy_id = buffer->PhyNum;
1600 device_info->port_id = buffer->PhysicalPort;
9a28f49a 1601 device_info->id = buffer->TargetID;
b506ade9 1602 device_info->phys_disk_num = ~0;
9a28f49a 1603 device_info->channel = buffer->Bus;
0c33b27d
CH		 1604 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
1605 device_info->sas_address = le64_to_cpu(sas_address);
1606 device_info->device_info =
1607 le32_to_cpu(buffer->DeviceInfo);
1608
1609 out_free_consistent:
1610 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1611 buffer, dma_handle);
1612 out:
1613 return error;
1614}
1615
1616static int
1617mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
1618 u32 form, u32 form_specific)
1619{
1620 ConfigExtendedPageHeader_t hdr;
1621 CONFIGPARMS cfg;
1622 SasExpanderPage0_t *buffer;
1623 dma_addr_t dma_handle;
547f9a21 1624 int i, error;
0c33b27d
CH		 1625
1626 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1627 hdr.ExtPageLength = 0;
1628 hdr.PageNumber = 0;
1629 hdr.Reserved1 = 0;
1630 hdr.Reserved2 = 0;
1631 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1632 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1633
1634 cfg.cfghdr.ehdr = &hdr;
1635 cfg.physAddr = -1;
1636 cfg.pageAddr = form + form_specific;
1637 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1638 cfg.dir = 0; /* read */
1639 cfg.timeout = 10;
1640
db9c9174 1641 memset(port_info, 0, sizeof(struct mptsas_portinfo));
0c33b27d
CH		 1642 error = mpt_config(ioc, &cfg);
1643 if (error)
1644 goto out;
1645
1646 if (!hdr.ExtPageLength) {
1647 error = -ENXIO;
1648 goto out;
1649 }
1650
1651 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1652 &dma_handle);
1653 if (!buffer) {
1654 error = -ENOMEM;
1655 goto out;
1656 }
1657
1658 cfg.physAddr = dma_handle;
1659 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1660
1661 error = mpt_config(ioc, &cfg);
1662 if (error)
1663 goto out_free_consistent;
1664
1665 /* save config data */
1666 port_info->num_phys = buffer->NumPhys;
0c33b27d 1667 port_info->phy_info = kcalloc(port_info->num_phys,
547f9a21 1668 sizeof(*port_info->phy_info),GFP_KERNEL);
0c33b27d
CH		 1669 if (!port_info->phy_info) {
1670 error = -ENOMEM;
1671 goto out_free_consistent;
1672 }
1673
2ecce492 1674 for (i = 0; i < port_info->num_phys; i++) {
547f9a21 1675 port_info->phy_info[i].portinfo = port_info;
2ecce492
EM		 1676 port_info->phy_info[i].handle =
1677 le16_to_cpu(buffer->DevHandle);
1678 }
547f9a21 1679
0c33b27d
CH		 1680 out_free_consistent:
1681 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1682 buffer, dma_handle);
1683 out:
1684 return error;
1685}
1686
1687static int
1688mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
1689 u32 form, u32 form_specific)
1690{
1691 ConfigExtendedPageHeader_t hdr;
1692 CONFIGPARMS cfg;
1693 SasExpanderPage1_t *buffer;
1694 dma_addr_t dma_handle;
bd23e94c
ME		 1695 int error=0;
1696
1697 if (ioc->sas_discovery_runtime &&
1698 mptsas_is_end_device(&phy_info->attached))
1699 goto out;
0c33b27d
CH		 1700
1701 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
1702 hdr.ExtPageLength = 0;
1703 hdr.PageNumber = 1;
1704 hdr.Reserved1 = 0;
1705 hdr.Reserved2 = 0;
1706 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1707 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
1708
1709 cfg.cfghdr.ehdr = &hdr;
1710 cfg.physAddr = -1;
1711 cfg.pageAddr = form + form_specific;
1712 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1713 cfg.dir = 0; /* read */
1714 cfg.timeout = 10;
1715
1716 error = mpt_config(ioc, &cfg);
1717 if (error)
1718 goto out;
1719
1720 if (!hdr.ExtPageLength) {
1721 error = -ENXIO;
1722 goto out;
1723 }
1724
1725 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1726 &dma_handle);
1727 if (!buffer) {
1728 error = -ENOMEM;
1729 goto out;
1730 }
1731
1732 cfg.physAddr = dma_handle;
1733 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1734
1735 error = mpt_config(ioc, &cfg);
1736 if (error)
1737 goto out_free_consistent;
1738
1739
1740 mptsas_print_expander_pg1(buffer);
1741
1742 /* save config data */
024358ee 1743 phy_info->phy_id = buffer->PhyIdentifier;
0c33b27d
CH		 1744 phy_info->port_id = buffer->PhysicalPort;
1745 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
1746 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
1747 phy_info->hw_link_rate = buffer->HwLinkRate;
1748 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
1749 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
1750
0c33b27d
CH		 1751 out_free_consistent:
1752 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
1753 buffer, dma_handle);
1754 out:
1755 return error;
1756}
1757
1758static void
1759mptsas_parse_device_info(struct sas_identify *identify,
1760 struct mptsas_devinfo *device_info)
1761{
1762 u16 protocols;
1763
1764 identify->sas_address = device_info->sas_address;
1765 identify->phy_identifier = device_info->phy_id;
1766
1767 /*
1768 * Fill in Phy Initiator Port Protocol.
1769 * Bits 6:3, more than one bit can be set, fall through cases.
1770 */
1771 protocols = device_info->device_info & 0x78;
1772 identify->initiator_port_protocols = 0;
1773 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
1774 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
1775 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1776 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
1777 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
1778 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
1779 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
1780 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
1781
1782 /*
1783 * Fill in Phy Target Port Protocol.
1784 * Bits 10:7, more than one bit can be set, fall through cases.
1785 */
1786 protocols = device_info->device_info & 0x780;
1787 identify->target_port_protocols = 0;
1788 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1789 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
1790 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
1791 identify->target_port_protocols |= SAS_PROTOCOL_STP;
1792 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
1793 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
1794 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1795 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
1796
1797 /*
1798 * Fill in Attached device type.
1799 */
1800 switch (device_info->device_info &
1801 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
1802 case MPI_SAS_DEVICE_INFO_NO_DEVICE:
1803 identify->device_type = SAS_PHY_UNUSED;
1804 break;
1805 case MPI_SAS_DEVICE_INFO_END_DEVICE:
1806 identify->device_type = SAS_END_DEVICE;
1807 break;
1808 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
1809 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
1810 break;
1811 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
1812 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
1813 break;
1814 }
1815}
1816
1817static int mptsas_probe_one_phy(struct device *dev,
ac01bbbd 1818 struct mptsas_phyinfo *phy_info, int index, int local)
0c33b27d 1819{
e6b2d76a 1820 MPT_ADAPTER *ioc;
9a28f49a 1821 struct sas_phy *phy;
547f9a21
EM		 1822 struct sas_port *port;
1823 int error = 0;
0c33b27d 1824
547f9a21
EM		 1825 if (!dev) {
1826 error = -ENODEV;
1827 goto out;
1828 }
e6b2d76a
ME		 1829
1830 if (!phy_info->phy) {
1831 phy = sas_phy_alloc(dev, index);
547f9a21
EM		 1832 if (!phy) {
1833 error = -ENOMEM;
1834 goto out;
1835 }
e6b2d76a
ME		 1836 } else
1837 phy = phy_info->phy;
0c33b27d 1838
9a28f49a 1839 mptsas_parse_device_info(&phy->identify, &phy_info->identify);
0c33b27d
CH		 1840
1841 /*
1842 * Set Negotiated link rate.
1843 */
1844 switch (phy_info->negotiated_link_rate) {
1845 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
9a28f49a 1846 phy->negotiated_linkrate = SAS_PHY_DISABLED;
0c33b27d
CH		 1847 break;
1848 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
9a28f49a 1849 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
0c33b27d
CH		 1850 break;
1851 case MPI_SAS_IOUNIT0_RATE_1_5:
9a28f49a 1852 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
0c33b27d
CH		 1853 break;
1854 case MPI_SAS_IOUNIT0_RATE_3_0:
9a28f49a 1855 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
0c33b27d
CH		 1856 break;
1857 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
1858 case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
1859 default:
9a28f49a 1860 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
0c33b27d
CH		 1861 break;
1862 }
1863
1864 /*
1865 * Set Max hardware link rate.
1866 */
1867 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1868 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
9a28f49a 1869 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
0c33b27d
CH		 1870 break;
1871 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
9a28f49a 1872 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
0c33b27d
CH		 1873 break;
1874 default:
1875 break;
1876 }
1877
1878 /*
1879 * Set Max programmed link rate.
1880 */
1881 switch (phy_info->programmed_link_rate &
1882 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1883 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
9a28f49a 1884 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
0c33b27d
CH		 1885 break;
1886 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
9a28f49a 1887 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
0c33b27d
CH		 1888 break;
1889 default:
1890 break;
1891 }
1892
1893 /*
1894 * Set Min hardware link rate.
1895 */
1896 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
1897 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
9a28f49a 1898 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
0c33b27d
CH		 1899 break;
1900 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
9a28f49a 1901 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
0c33b27d
CH		 1902 break;
1903 default:
1904 break;
1905 }
1906
1907 /*
1908 * Set Min programmed link rate.
1909 */
1910 switch (phy_info->programmed_link_rate &
1911 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
1912 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
9a28f49a 1913 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
0c33b27d
CH		 1914 break;
1915 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
9a28f49a 1916 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
0c33b27d
CH		 1917 break;
1918 default:
1919 break;
1920 }
1921
e6b2d76a 1922 if (!phy_info->phy) {
ac01bbbd 1923
e6b2d76a
ME		 1924 error = sas_phy_add(phy);
1925 if (error) {
1926 sas_phy_free(phy);
547f9a21 1927 goto out;
e6b2d76a
ME		 1928 }
1929 phy_info->phy = phy;
0c33b27d
CH		 1930 }
1931
547f9a21
EM		 1932 if (!phy_info->attached.handle ||
1933 !phy_info->port_details)
1934 goto out;
1935
1936 port = mptsas_get_port(phy_info);
1937 ioc = phy_to_ioc(phy_info->phy);
1938
1939 if (phy_info->sas_port_add_phy) {
1940
1941 if (!port) {
dc22f16d 1942 port = sas_port_alloc_num(dev);
547f9a21
EM		 1943 if (!port) {
1944 error = -ENOMEM;
1945 goto out;
1946 }
1947 error = sas_port_add(port);
1948 if (error) {
1949 dfailprintk((MYIOC_s_ERR_FMT
1950 "%s: exit at line=%d\n", ioc->name,
1951 __FUNCTION__, __LINE__));
1952 goto out;
1953 }
1954 mptsas_set_port(phy_info, port);
dc22f16d
EM		 1955 dsaswideprintk((KERN_DEBUG
1956 "sas_port_alloc: port=%p dev=%p port_id=%d\n",
1957 port, dev, port->port_identifier));
547f9a21
EM		 1958 }
1959 dsaswideprintk((KERN_DEBUG "sas_port_add_phy: phy_id=%d\n",
1960 phy_info->phy_id));
1961 sas_port_add_phy(port, phy_info->phy);
1962 phy_info->sas_port_add_phy = 0;
1963 }
1964
1965 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
e6b2d76a 1966
0c33b27d 1967 struct sas_rphy *rphy;
2686de27 1968 struct device *parent;
f013db32 1969 struct sas_identify identify;
0c33b27d 1970
2686de27 1971 parent = dev->parent->parent;
e6b2d76a
ME		 1972 /*
1973 * Let the hotplug_work thread handle processing
1974 * the adding/removing of devices that occur
1975 * after start of day.
1976 */
1977 if (ioc->sas_discovery_runtime &&
1978 mptsas_is_end_device(&phy_info->attached))
547f9a21 1979 goto out;
e6b2d76a 1980
f013db32 1981 mptsas_parse_device_info(&identify, &phy_info->attached);
2686de27
JB		 1982 if (scsi_is_host_device(parent)) {
1983 struct mptsas_portinfo *port_info;
1984 int i;
1985
1986 mutex_lock(&ioc->sas_topology_mutex);
1987 port_info = mptsas_find_portinfo_by_handle(ioc,
1988 ioc->handle);
1989 mutex_unlock(&ioc->sas_topology_mutex);
1990
1991 for (i = 0; i < port_info->num_phys; i++)
1992 if (port_info->phy_info[i].identify.sas_address ==
0c269e6d
JB		 1993 identify.sas_address) {
1994 sas_port_mark_backlink(port);
2686de27 1995 goto out;
0c269e6d 1996 }
2686de27
JB		 1997
1998 } else if (scsi_is_sas_rphy(parent)) {
1999 struct sas_rphy *parent_rphy = dev_to_rphy(parent);
2000 if (identify.sas_address ==
0c269e6d
JB		 2001 parent_rphy->identify.sas_address) {
2002 sas_port_mark_backlink(port);
2686de27 2003 goto out;
0c269e6d 2004 }
2686de27
JB		 2005 }
2006
f013db32
JB		 2007 switch (identify.device_type) {
2008 case SAS_END_DEVICE:
547f9a21 2009 rphy = sas_end_device_alloc(port);
f013db32
JB		 2010 break;
2011 case SAS_EDGE_EXPANDER_DEVICE:
2012 case SAS_FANOUT_EXPANDER_DEVICE:
547f9a21 2013 rphy = sas_expander_alloc(port, identify.device_type);
f013db32
JB		 2014 break;
2015 default:
2016 rphy = NULL;
2017 break;
2018 }
547f9a21
EM		 2019 if (!rphy) {
2020 dfailprintk((MYIOC_s_ERR_FMT
2021 "%s: exit at line=%d\n", ioc->name,
2022 __FUNCTION__, __LINE__));
2023 goto out;
2024 }
0c33b27d 2025
f013db32 2026 rphy->identify = identify;
0c33b27d
CH		 2027 error = sas_rphy_add(rphy);
2028 if (error) {
547f9a21
EM		 2029 dfailprintk((MYIOC_s_ERR_FMT
2030 "%s: exit at line=%d\n", ioc->name,
2031 __FUNCTION__, __LINE__));
0c33b27d 2032 sas_rphy_free(rphy);
547f9a21 2033 goto out;
0c33b27d 2034 }
547f9a21 2035 mptsas_set_rphy(phy_info, rphy);
0c33b27d
CH		 2036 }
2037
547f9a21
EM		 2038 out:
2039 return error;
0c33b27d
CH		 2040}
2041
2042static int
e6b2d76a 2043mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
0c33b27d 2044{
e6b2d76a 2045 struct mptsas_portinfo *port_info, *hba;
0c33b27d
CH		 2046 int error = -ENOMEM, i;
2047
e6b2d76a
ME		 2048 hba = kzalloc(sizeof(*port_info), GFP_KERNEL);
2049 if (! hba)
0c33b27d 2050 goto out;
0c33b27d 2051
e6b2d76a 2052 error = mptsas_sas_io_unit_pg0(ioc, hba);
0c33b27d
CH		 2053 if (error)
2054 goto out_free_port_info;
2055
edb9068d 2056 mptsas_sas_io_unit_pg1(ioc);
9a28f49a 2057 mutex_lock(&ioc->sas_topology_mutex);
2ecce492
EM		 2058 ioc->handle = hba->phy_info[0].handle;
2059 port_info = mptsas_find_portinfo_by_handle(ioc, ioc->handle);
e6b2d76a
ME		 2060 if (!port_info) {
2061 port_info = hba;
2062 list_add_tail(&port_info->list, &ioc->sas_topology);
2063 } else {
2ecce492 2064 for (i = 0; i < hba->num_phys; i++) {
e6b2d76a
ME		 2065 port_info->phy_info[i].negotiated_link_rate =
2066 hba->phy_info[i].negotiated_link_rate;
2ecce492
EM		 2067 port_info->phy_info[i].handle =
2068 hba->phy_info[i].handle;
2069 port_info->phy_info[i].port_id =
2070 hba->phy_info[i].port_id;
2071 }
547f9a21 2072 kfree(hba->phy_info);
e6b2d76a
ME		 2073 kfree(hba);
2074 hba = NULL;
2075 }
9a28f49a 2076 mutex_unlock(&ioc->sas_topology_mutex);
0c33b27d
CH		 2077 for (i = 0; i < port_info->num_phys; i++) {
2078 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
2079 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
2080 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
2081
2082 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
2ecce492
EM		 2083 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2084 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2085 port_info->phy_info[i].handle);
024358ee 2086 port_info->phy_info[i].identify.phy_id =
2ecce492 2087 port_info->phy_info[i].phy_id = i;
547f9a21 2088 if (port_info->phy_info[i].attached.handle)
0c33b27d
CH		 2089 mptsas_sas_device_pg0(ioc,
2090 &port_info->phy_info[i].attached,
2091 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2092 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2093 port_info->phy_info[i].attached.handle);
547f9a21 2094 }
0c33b27d 2095
547f9a21
EM		 2096 mptsas_setup_wide_ports(ioc, port_info);
2097
2098 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
0c33b27d 2099 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
e6b2d76a 2100 &port_info->phy_info[i], ioc->sas_index, 1);
0c33b27d
CH		 2101
2102 return 0;
2103
2104 out_free_port_info:
547f9a21 2105 kfree(hba);
0c33b27d
CH		 2106 out:
2107 return error;
2108}
2109
2110static int
e6b2d76a 2111mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)
0c33b27d 2112{
e6b2d76a 2113 struct mptsas_portinfo *port_info, *p, *ex;
547f9a21
EM		 2114 struct device *parent;
2115 struct sas_rphy *rphy;
0c33b27d
CH		 2116 int error = -ENOMEM, i, j;
2117
e6b2d76a
ME		 2118 ex = kzalloc(sizeof(*port_info), GFP_KERNEL);
2119 if (!ex)
0c33b27d 2120 goto out;
0c33b27d 2121
e6b2d76a 2122 error = mptsas_sas_expander_pg0(ioc, ex,
2ecce492
EM		 2123 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
2124 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
0c33b27d
CH		 2125 if (error)
2126 goto out_free_port_info;
2127
2ecce492 2128 *handle = ex->phy_info[0].handle;
0c33b27d 2129
9a28f49a 2130 mutex_lock(&ioc->sas_topology_mutex);
e6b2d76a
ME		 2131 port_info = mptsas_find_portinfo_by_handle(ioc, *handle);
2132 if (!port_info) {
2133 port_info = ex;
2134 list_add_tail(&port_info->list, &ioc->sas_topology);
2135 } else {
2ecce492
EM		 2136 for (i = 0; i < ex->num_phys; i++) {
2137 port_info->phy_info[i].handle =
2138 ex->phy_info[i].handle;
2139 port_info->phy_info[i].port_id =
2140 ex->phy_info[i].port_id;
2141 }
547f9a21 2142 kfree(ex->phy_info);
e6b2d76a
ME		 2143 kfree(ex);
2144 ex = NULL;
2145 }
9a28f49a
CH		 2146 mutex_unlock(&ioc->sas_topology_mutex);
2147
0c33b27d 2148 for (i = 0; i < port_info->num_phys; i++) {
0c33b27d
CH		 2149 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
2150 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
2151 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
2152
2153 if (port_info->phy_info[i].identify.handle) {
2154 mptsas_sas_device_pg0(ioc,
2155 &port_info->phy_info[i].identify,
2156 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2157 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2158 port_info->phy_info[i].identify.handle);
024358ee
EM		 2159 port_info->phy_info[i].identify.phy_id =
2160 port_info->phy_info[i].phy_id;
0c33b27d
CH		 2161 }
2162
2163 if (port_info->phy_info[i].attached.handle) {
2164 mptsas_sas_device_pg0(ioc,
2165 &port_info->phy_info[i].attached,
2166 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
2167 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2168 port_info->phy_info[i].attached.handle);
db9c9174
ME		 2169 port_info->phy_info[i].attached.phy_id =
2170 port_info->phy_info[i].phy_id;
0c33b27d 2171 }
547f9a21 2172 }
0c33b27d 2173
547f9a21
EM		 2174 parent = &ioc->sh->shost_gendev;
2175 for (i = 0; i < port_info->num_phys; i++) {
9a28f49a 2176 mutex_lock(&ioc->sas_topology_mutex);
0c33b27d
CH		 2177 list_for_each_entry(p, &ioc->sas_topology, list) {
2178 for (j = 0; j < p->num_phys; j++) {
547f9a21 2179 if (port_info->phy_info[i].identify.handle !=
0c33b27d 2180 p->phy_info[j].attached.handle)
547f9a21
EM		 2181 continue;
2182 rphy = mptsas_get_rphy(&p->phy_info[j]);
2183 parent = &rphy->dev;
0c33b27d
CH		 2184 }
2185 }
9a28f49a 2186 mutex_unlock(&ioc->sas_topology_mutex);
547f9a21
EM		 2187 }
2188
2189 mptsas_setup_wide_ports(ioc, port_info);
0c33b27d 2190
547f9a21 2191 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
ac01bbbd 2192 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
e6b2d76a 2193 ioc->sas_index, 0);
0c33b27d
CH		 2194
2195 return 0;
2196
2197 out_free_port_info:
e6b2d76a 2198 if (ex) {
547f9a21 2199 kfree(ex->phy_info);
e6b2d76a
ME		 2200 kfree(ex);
2201 }
0c33b27d
CH		 2202 out:
2203 return error;
2204}
2205
e6b2d76a
ME		 2206/*
2207 * mptsas_delete_expander_phys
2208 *
2209 *
2210 * This will traverse topology, and remove expanders
2211 * that are no longer present
2212 */
2213static void
2214mptsas_delete_expander_phys(MPT_ADAPTER *ioc)
2215{
2216 struct mptsas_portinfo buffer;
2217 struct mptsas_portinfo *port_info, *n, *parent;
547f9a21 2218 struct mptsas_phyinfo *phy_info;
547f9a21 2219 struct sas_port * port;
e6b2d76a 2220 int i;
547f9a21 2221 u64 expander_sas_address;
e6b2d76a
ME		 2222
2223 mutex_lock(&ioc->sas_topology_mutex);
2224 list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {
2225
2226 if (port_info->phy_info &&
2227 (!(port_info->phy_info[0].identify.device_info &
2228 MPI_SAS_DEVICE_INFO_SMP_TARGET)))
2229 continue;
2230
2231 if (mptsas_sas_expander_pg0(ioc, &buffer,
2232 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
2ecce492
EM		 2233 MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
2234 port_info->phy_info[0].handle)) {
e6b2d76a
ME		 2235
2236 /*
2237 * Obtain the port_info instance to the parent port
2238 */
2239 parent = mptsas_find_portinfo_by_handle(ioc,
2240 port_info->phy_info[0].identify.handle_parent);
2241
2242 if (!parent)
2243 goto next_port;
2244
547f9a21
EM		 2245 expander_sas_address =
2246 port_info->phy_info[0].identify.sas_address;
2247
e6b2d76a
ME		 2248 /*
2249 * Delete rphys in the parent that point
2250 * to this expander. The transport layer will
2251 * cleanup all the children.
2252 */
547f9a21
EM		 2253 phy_info = parent->phy_info;
2254 for (i = 0; i < parent->num_phys; i++, phy_info++) {
2255 port = mptsas_get_port(phy_info);
2256 if (!port)
2257 continue;
2258 if (phy_info->attached.sas_address !=
2259 expander_sas_address)
e6b2d76a 2260 continue;
547f9a21 2261#ifdef MPT_DEBUG_SAS_WIDE
dc22f16d
EM		 2262 dev_printk(KERN_DEBUG, &port->dev,
2263 "delete port (%d)\n", port->port_identifier);
547f9a21
EM		 2264#endif
2265 sas_port_delete(port);
2266 mptsas_port_delete(phy_info->port_details);
e6b2d76a
ME		 2267 }
2268 next_port:
547f9a21
EM		 2269
2270 phy_info = port_info->phy_info;
2271 for (i = 0; i < port_info->num_phys; i++, phy_info++)
2272 mptsas_port_delete(phy_info->port_details);
2273
e6b2d76a 2274 list_del(&port_info->list);
547f9a21 2275 kfree(port_info->phy_info);
e6b2d76a
ME		 2276 kfree(port_info);
2277 }
2278 /*
2279 * Free this memory allocated from inside
2280 * mptsas_sas_expander_pg0
2281 */
547f9a21 2282 kfree(buffer.phy_info);
e6b2d76a
ME		 2283 }
2284 mutex_unlock(&ioc->sas_topology_mutex);
2285}
2286
2287/*
2288 * Start of day discovery
2289 */
0c33b27d
CH		 2290static void
2291mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
2292{
2293 u32 handle = 0xFFFF;
f44e5461 2294 int i;
0c33b27d 2295
e6b2d76a
ME		 2296 mutex_lock(&ioc->sas_discovery_mutex);
2297 mptsas_probe_hba_phys(ioc);
2298 while (!mptsas_probe_expander_phys(ioc, &handle))
0c33b27d 2299 ;
f44e5461
ME		 2300 /*
2301 Reporting RAID volumes.
2302 */
b506ade9
EM		 2303 if (!ioc->ir_firmware)
2304 goto out;
f44e5461
ME		 2305 if (!ioc->raid_data.pIocPg2)
2306 goto out;
2307 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
2308 goto out;
793955f5 2309 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
e8bf3941 2310 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
f44e5461
ME		 2311 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
2312 }
2313 out:
e6b2d76a
ME		 2314 mutex_unlock(&ioc->sas_discovery_mutex);
2315}
2316
2317/*
2318 * Work queue thread to handle Runtime discovery
2319 * Mere purpose is the hot add/delete of expanders
547f9a21 2320 *(Mutex UNLOCKED)
e6b2d76a
ME		 2321 */
2322static void
547f9a21 2323__mptsas_discovery_work(MPT_ADAPTER *ioc)
e6b2d76a 2324{
e6b2d76a
ME		 2325 u32 handle = 0xFFFF;
2326
e6b2d76a
ME		 2327 ioc->sas_discovery_runtime=1;
2328 mptsas_delete_expander_phys(ioc);
2329 mptsas_probe_hba_phys(ioc);
2330 while (!mptsas_probe_expander_phys(ioc, &handle))
2331 ;
e6b2d76a 2332 ioc->sas_discovery_runtime=0;
547f9a21
EM		 2333}
2334
2335/*
2336 * Work queue thread to handle Runtime discovery
2337 * Mere purpose is the hot add/delete of expanders
2338 *(Mutex LOCKED)
2339 */
2340static void
c4028958 2341mptsas_discovery_work(struct work_struct *work)
547f9a21 2342{
c4028958
DH		 2343 struct mptsas_discovery_event *ev =
2344 container_of(work, struct mptsas_discovery_event, work);
547f9a21
EM		 2345 MPT_ADAPTER *ioc = ev->ioc;
2346
2347 mutex_lock(&ioc->sas_discovery_mutex);
2348 __mptsas_discovery_work(ioc);
e6b2d76a 2349 mutex_unlock(&ioc->sas_discovery_mutex);
547f9a21 2350 kfree(ev);
0c33b27d
CH		 2351}
2352
9a28f49a 2353static struct mptsas_phyinfo *
547f9a21 2354mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
9a28f49a
CH		 2355{
2356 struct mptsas_portinfo *port_info;
9a28f49a 2357 struct mptsas_phyinfo *phy_info = NULL;
547f9a21 2358 int i;
9a28f49a 2359
9a28f49a
CH		 2360 mutex_lock(&ioc->sas_topology_mutex);
2361 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2362 for (i = 0; i < port_info->num_phys; i++) {
b506ade9
EM		 2363 if (!mptsas_is_end_device(
2364 &port_info->phy_info[i].attached))
2365 continue;
547f9a21
EM		 2366 if (port_info->phy_info[i].attached.sas_address
2367 != sas_address)
2368 continue;
b506ade9
EM		 2369 phy_info = &port_info->phy_info[i];
2370 break;
2371 }
2372 }
2373 mutex_unlock(&ioc->sas_topology_mutex);
2374 return phy_info;
2375}
2376
2377static struct mptsas_phyinfo *
2378mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id)
2379{
2380 struct mptsas_portinfo *port_info;
2381 struct mptsas_phyinfo *phy_info = NULL;
2382 int i;
2383
2384 mutex_lock(&ioc->sas_topology_mutex);
2385 list_for_each_entry(port_info, &ioc->sas_topology, list) {
2386 for (i = 0; i < port_info->num_phys; i++) {
547f9a21
EM		 2387 if (!mptsas_is_end_device(
2388 &port_info->phy_info[i].attached))
2389 continue;
b506ade9
EM		 2390 if (port_info->phy_info[i].attached.id != id)
2391 continue;
2392 if (port_info->phy_info[i].attached.channel != channel)
2393 continue;
547f9a21
EM		 2394 phy_info = &port_info->phy_info[i];
2395 break;
9a28f49a
CH		 2396 }
2397 }
2398 mutex_unlock(&ioc->sas_topology_mutex);
9a28f49a
CH		 2399 return phy_info;
2400}
2401
2402static struct mptsas_phyinfo *
b506ade9 2403mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
9a28f49a
CH		 2404{
2405 struct mptsas_portinfo *port_info;
2406 struct mptsas_phyinfo *phy_info = NULL;
2407 int i;
2408
9a28f49a
CH		 2409 mutex_lock(&ioc->sas_topology_mutex);
2410 list_for_each_entry(port_info, &ioc->sas_topology, list) {
547f9a21 2411 for (i = 0; i < port_info->num_phys; i++) {
547f9a21
EM		 2412 if (!mptsas_is_end_device(
2413 &port_info->phy_info[i].attached))
2414 continue;
b506ade9
EM		 2415 if (port_info->phy_info[i].attached.phys_disk_num == ~0)
2416 continue;
2417 if (port_info->phy_info[i].attached.phys_disk_num != id)
2418 continue;
2419 if (port_info->phy_info[i].attached.channel != channel)
2420 continue;
547f9a21
EM		 2421 phy_info = &port_info->phy_info[i];
2422 break;
2423 }
9a28f49a
CH		 2424 }
2425 mutex_unlock(&ioc->sas_topology_mutex);
9a28f49a
CH		 2426 return phy_info;
2427}
2428
4b766471
ME		 2429/*
2430 * Work queue thread to clear the persitency table
2431 */
2432static void
c4028958 2433mptsas_persist_clear_table(struct work_struct *work)
4b766471 2434{
c4028958 2435 MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task);
4b766471
ME		 2436
2437 mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
2438}
2439
f44e5461
ME		 2440static void
2441mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
2442{
f99be43b
EM		 2443 int rc;
2444
f44e5461 2445 sdev->no_uld_attach = data ? 1 : 0;
f99be43b 2446 rc = scsi_device_reprobe(sdev);
f44e5461
ME		 2447}
2448
2449static void
2450mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
2451{
2452 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
2453 mptsas_reprobe_lun);
2454}
2455
b506ade9
EM		 2456static void
2457mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
2458{
2459 CONFIGPARMS cfg;
2460 ConfigPageHeader_t hdr;
2461 dma_addr_t dma_handle;
2462 pRaidVolumePage0_t buffer = NULL;
2463 RaidPhysDiskPage0_t phys_disk;
2464 int i;
2465 struct mptsas_hotplug_event *ev;
2466
2467 memset(&cfg, 0 , sizeof(CONFIGPARMS));
2468 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
2469 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
2470 cfg.pageAddr = (channel << 8) + id;
2471 cfg.cfghdr.hdr = &hdr;
2472 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2473
2474 if (mpt_config(ioc, &cfg) != 0)
2475 goto out;
2476
2477 if (!hdr.PageLength)
2478 goto out;
2479
2480 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
2481 &dma_handle);
2482
2483 if (!buffer)
2484 goto out;
2485
2486 cfg.physAddr = dma_handle;
2487 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2488
2489 if (mpt_config(ioc, &cfg) != 0)
2490 goto out;
2491
2492 if (!(buffer->VolumeStatus.Flags &
2493 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
2494 goto out;
2495
2496 if (!buffer->NumPhysDisks)
2497 goto out;
2498
2499 for (i = 0; i < buffer->NumPhysDisks; i++) {
2500
2501 if (mpt_raid_phys_disk_pg0(ioc,
2502 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
2503 continue;
2504
2505 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2506 if (!ev) {
2507 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2508 goto out;
2509 }
2510
2511 INIT_WORK(&ev->work, mptsas_hotplug_work);
2512 ev->ioc = ioc;
2513 ev->id = phys_disk.PhysDiskID;
2514 ev->channel = phys_disk.PhysDiskBus;
2515 ev->phys_disk_num_valid = 1;
2516 ev->phys_disk_num = phys_disk.PhysDiskNum;
2517 ev->event_type = MPTSAS_ADD_DEVICE;
2518 schedule_work(&ev->work);
2519 }
2520
2521 out:
2522 if (buffer)
2523 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
2524 dma_handle);
2525}
e6b2d76a
ME		 2526/*
2527 * Work queue thread to handle SAS hotplug events
2528 */
9a28f49a 2529static void
c4028958 2530mptsas_hotplug_work(struct work_struct *work)
9a28f49a 2531{
c4028958
DH		 2532 struct mptsas_hotplug_event *ev =
2533 container_of(work, struct mptsas_hotplug_event, work);
b506ade9 2534
9a28f49a
CH		 2535 MPT_ADAPTER *ioc = ev->ioc;
2536 struct mptsas_phyinfo *phy_info;
2537 struct sas_rphy *rphy;
547f9a21 2538 struct sas_port *port;
c73787ee 2539 struct scsi_device *sdev;
547f9a21 2540 struct scsi_target * starget;
f013db32 2541 struct sas_identify identify;
9a28f49a 2542 char *ds = NULL;
c73787ee 2543 struct mptsas_devinfo sas_device;
f44e5461 2544 VirtTarget *vtarget;
547f9a21 2545 VirtDevice *vdevice;
9a28f49a 2546
547f9a21 2547 mutex_lock(&ioc->sas_discovery_mutex);
9a28f49a
CH		 2548 switch (ev->event_type) {
2549 case MPTSAS_DEL_DEVICE:
9a28f49a 2550
b506ade9
EM		 2551 phy_info = NULL;
2552 if (ev->phys_disk_num_valid) {
2553 if (ev->hidden_raid_component){
2554 if (mptsas_sas_device_pg0(ioc, &sas_device,
2555 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
2556 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2557 (ev->channel << 8) + ev->id)) {
2558 dfailprintk((MYIOC_s_ERR_FMT
2559 "%s: exit at line=%d\n", ioc->name,
2560 __FUNCTION__, __LINE__));
2561 break;
2562 }
2563 phy_info = mptsas_find_phyinfo_by_sas_address(
2564 ioc, sas_device.sas_address);
2565 }else
2566 phy_info = mptsas_find_phyinfo_by_phys_disk_num(
2567 ioc, ev->channel, ev->phys_disk_num);
2568 }
2569
2570 if (!phy_info)
2571 phy_info = mptsas_find_phyinfo_by_target(ioc,
2572 ev->channel, ev->id);
e6b2d76a 2573
f44e5461
ME		 2574 /*
2575 * Sanity checks, for non-existing phys and remote rphys.
2576 */
b506ade9
EM		 2577 if (!phy_info){
2578 dfailprintk((MYIOC_s_ERR_FMT
2579 "%s: exit at line=%d\n", ioc->name,
2580 __FUNCTION__, __LINE__));
2581 break;
2582 }
2583 if (!phy_info->port_details) {
547f9a21
EM		 2584 dfailprintk((MYIOC_s_ERR_FMT
2585 "%s: exit at line=%d\n", ioc->name,
2586 __FUNCTION__, __LINE__));
9a28f49a 2587 break;
547f9a21
EM		 2588 }
2589 rphy = mptsas_get_rphy(phy_info);
2590 if (!rphy) {
2591 dfailprintk((MYIOC_s_ERR_FMT
2592 "%s: exit at line=%d\n", ioc->name,
2593 __FUNCTION__, __LINE__));
2594 break;
2595 }
b506ade9 2596
547f9a21
EM		 2597 port = mptsas_get_port(phy_info);
2598 if (!port) {
2599 dfailprintk((MYIOC_s_ERR_FMT
2600 "%s: exit at line=%d\n", ioc->name,
2601 __FUNCTION__, __LINE__));
f44e5461 2602 break;
547f9a21
EM		 2603 }
2604
2605 starget = mptsas_get_starget(phy_info);
2606 if (starget) {
2607 vtarget = starget->hostdata;
f44e5461 2608
547f9a21
EM		 2609 if (!vtarget) {
2610 dfailprintk((MYIOC_s_ERR_FMT
2611 "%s: exit at line=%d\n", ioc->name,
2612 __FUNCTION__, __LINE__));
f44e5461 2613 break;
547f9a21
EM		 2614 }
2615
f44e5461
ME		 2616 /*
2617 * Handling RAID components
2618 */
b506ade9
EM		 2619 if (ev->phys_disk_num_valid &&
2620 ev->hidden_raid_component) {
2621 printk(MYIOC_s_INFO_FMT
2622 "RAID Hidding: channel=%d, id=%d, "
2623 "physdsk %d \n", ioc->name, ev->channel,
2624 ev->id, ev->phys_disk_num);
793955f5 2625 vtarget->id = ev->phys_disk_num;
b506ade9
EM		 2626 vtarget->tflags |=
2627 MPT_TARGET_FLAGS_RAID_COMPONENT;
547f9a21 2628 mptsas_reprobe_target(starget, 1);
b506ade9
EM		 2629 phy_info->attached.phys_disk_num =
2630 ev->phys_disk_num;
2631 break;
f44e5461 2632 }
9a28f49a
CH		 2633 }
2634
b506ade9
EM		 2635 if (phy_info->attached.device_info &
2636 MPI_SAS_DEVICE_INFO_SSP_TARGET)
c73787ee 2637 ds = "ssp";
b506ade9
EM		 2638 if (phy_info->attached.device_info &
2639 MPI_SAS_DEVICE_INFO_STP_TARGET)
c73787ee 2640 ds = "stp";
b506ade9
EM		 2641 if (phy_info->attached.device_info &
2642 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
c73787ee
ME		 2643 ds = "sata";
2644
2645 printk(MYIOC_s_INFO_FMT
2646 "removing %s device, channel %d, id %d, phy %d\n",
2647 ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
547f9a21 2648#ifdef MPT_DEBUG_SAS_WIDE
dc22f16d
EM		 2649 dev_printk(KERN_DEBUG, &port->dev,
2650 "delete port (%d)\n", port->port_identifier);
547f9a21
EM		 2651#endif
2652 sas_port_delete(port);
2653 mptsas_port_delete(phy_info->port_details);
9a28f49a
CH		 2654 break;
2655 case MPTSAS_ADD_DEVICE:
c73787ee 2656
bd23e94c
ME		 2657 if (ev->phys_disk_num_valid)
2658 mpt_findImVolumes(ioc);
2659
c73787ee 2660 /*
e3094447 2661 * Refresh sas device pg0 data
c73787ee 2662 */
e3094447
CH		 2663 if (mptsas_sas_device_pg0(ioc, &sas_device,
2664 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
b506ade9
EM		 2665 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
2666 (ev->channel << 8) + ev->id)) {
547f9a21
EM		 2667 dfailprintk((MYIOC_s_ERR_FMT
2668 "%s: exit at line=%d\n", ioc->name,
2669 __FUNCTION__, __LINE__));
e3094447 2670 break;
547f9a21 2671 }
9a28f49a 2672
547f9a21 2673 __mptsas_discovery_work(ioc);
e6b2d76a 2674
547f9a21
EM		 2675 phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
2676 sas_device.sas_address);
e6b2d76a 2677
547f9a21
EM		 2678 if (!phy_info || !phy_info->port_details) {
2679 dfailprintk((MYIOC_s_ERR_FMT
2680 "%s: exit at line=%d\n", ioc->name,
2681 __FUNCTION__, __LINE__));
2682 break;
e6b2d76a
ME		 2683 }
2684
547f9a21 2685 starget = mptsas_get_starget(phy_info);
b506ade9
EM		 2686 if (starget && (!ev->hidden_raid_component)){
2687
547f9a21 2688 vtarget = starget->hostdata;
9a28f49a 2689
547f9a21
EM		 2690 if (!vtarget) {
2691 dfailprintk((MYIOC_s_ERR_FMT
2692 "%s: exit at line=%d\n", ioc->name,
2693 __FUNCTION__, __LINE__));
f44e5461 2694 break;
547f9a21 2695 }
f44e5461
ME		 2696 /*
2697 * Handling RAID components
2698 */
2699 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
b506ade9
EM		 2700 printk(MYIOC_s_INFO_FMT
2701 "RAID Exposing: channel=%d, id=%d, "
2702 "physdsk %d \n", ioc->name, ev->channel,
2703 ev->id, ev->phys_disk_num);
2704 vtarget->tflags &=
2705 ~MPT_TARGET_FLAGS_RAID_COMPONENT;
793955f5 2706 vtarget->id = ev->id;
547f9a21 2707 mptsas_reprobe_target(starget, 0);
b506ade9 2708 phy_info->attached.phys_disk_num = ~0;
f44e5461 2709 }
9a28f49a
CH		 2710 break;
2711 }
2712
547f9a21
EM		 2713 if (mptsas_get_rphy(phy_info)) {
2714 dfailprintk((MYIOC_s_ERR_FMT
2715 "%s: exit at line=%d\n", ioc->name,
2716 __FUNCTION__, __LINE__));
b506ade9 2717 if (ev->channel) printk("%d\n", __LINE__);
f44e5461 2718 break;
547f9a21 2719 }
b506ade9 2720
547f9a21
EM		 2721 port = mptsas_get_port(phy_info);
2722 if (!port) {
2723 dfailprintk((MYIOC_s_ERR_FMT
2724 "%s: exit at line=%d\n", ioc->name,
2725 __FUNCTION__, __LINE__));
2726 break;
2727 }
e3094447
CH		 2728 memcpy(&phy_info->attached, &sas_device,
2729 sizeof(struct mptsas_devinfo));
9a28f49a 2730
b506ade9
EM		 2731 if (phy_info->attached.device_info &
2732 MPI_SAS_DEVICE_INFO_SSP_TARGET)
c73787ee 2733 ds = "ssp";
b506ade9
EM		 2734 if (phy_info->attached.device_info &
2735 MPI_SAS_DEVICE_INFO_STP_TARGET)
c73787ee 2736 ds = "stp";
b506ade9
EM		 2737 if (phy_info->attached.device_info &
2738 MPI_SAS_DEVICE_INFO_SATA_DEVICE)
c73787ee
ME		 2739 ds = "sata";
2740
2741 printk(MYIOC_s_INFO_FMT
2742 "attaching %s device, channel %d, id %d, phy %d\n",
2743 ioc->name, ds, ev->channel, ev->id, ev->phy_id);
2744
f013db32 2745 mptsas_parse_device_info(&identify, &phy_info->attached);
547f9a21
EM		 2746 rphy = sas_end_device_alloc(port);
2747 if (!rphy) {
2748 dfailprintk((MYIOC_s_ERR_FMT
2749 "%s: exit at line=%d\n", ioc->name,
2750 __FUNCTION__, __LINE__));
9a28f49a 2751 break; /* non-fatal: an rphy can be added later */
547f9a21 2752 }
9a28f49a 2753
f013db32 2754 rphy->identify = identify;
9a28f49a 2755 if (sas_rphy_add(rphy)) {
547f9a21
EM		 2756 dfailprintk((MYIOC_s_ERR_FMT
2757 "%s: exit at line=%d\n", ioc->name,
2758 __FUNCTION__, __LINE__));
9a28f49a
CH		 2759 sas_rphy_free(rphy);
2760 break;
2761 }
547f9a21 2762 mptsas_set_rphy(phy_info, rphy);
9a28f49a 2763 break;
c73787ee 2764 case MPTSAS_ADD_RAID:
e8bf3941
JB		 2765 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
2766 ev->id, 0);
c73787ee
ME		 2767 if (sdev) {
2768 scsi_device_put(sdev);
2769 break;
2770 }
2771 printk(MYIOC_s_INFO_FMT
4b766471 2772 "attaching raid volume, channel %d, id %d\n",
e8bf3941
JB		 2773 ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
2774 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0);
c73787ee
ME		 2775 mpt_findImVolumes(ioc);
2776 break;
2777 case MPTSAS_DEL_RAID:
e8bf3941 2778 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
b506ade9 2779 ev->id, 0);
c73787ee
ME		 2780 if (!sdev)
2781 break;
2782 printk(MYIOC_s_INFO_FMT
4b766471 2783 "removing raid volume, channel %d, id %d\n",
e8bf3941 2784 ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
b506ade9 2785 vdevice = sdev->hostdata;
c73787ee
ME		 2786 scsi_remove_device(sdev);
2787 scsi_device_put(sdev);
2788 mpt_findImVolumes(ioc);
2789 break;
b506ade9
EM		 2790 case MPTSAS_ADD_INACTIVE_VOLUME:
2791 mptsas_adding_inactive_raid_components(ioc,
2792 ev->channel, ev->id);
2793 break;
bd23e94c
ME		 2794 case MPTSAS_IGNORE_EVENT:
2795 default:
2796 break;
9a28f49a
CH		 2797 }
2798
e6b2d76a 2799 mutex_unlock(&ioc->sas_discovery_mutex);
547f9a21 2800 kfree(ev);
9a28f49a
CH		 2801}
2802
2803static void
547f9a21 2804mptsas_send_sas_event(MPT_ADAPTER *ioc,
9a28f49a
CH		 2805 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
2806{
2807 struct mptsas_hotplug_event *ev;
2808 u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
2809 __le64 sas_address;
2810
2811 if ((device_info &
2812 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
2813 MPI_SAS_DEVICE_INFO_STP_TARGET |
2814 MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
2815 return;
2816
4b766471 2817 switch (sas_event_data->ReasonCode) {
4b766471 2818 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
df9e062a
EM		 2819
2820 mptsas_target_reset_queue(ioc, sas_event_data);
2821 break;
2822
2823 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
547f9a21 2824 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
4b766471
ME		 2825 if (!ev) {
2826 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2827 break;
2828 }
9a28f49a 2829
c4028958 2830 INIT_WORK(&ev->work, mptsas_hotplug_work);
4b766471
ME		 2831 ev->ioc = ioc;
2832 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
2833 ev->parent_handle =
2834 le16_to_cpu(sas_event_data->ParentDevHandle);
2835 ev->channel = sas_event_data->Bus;
2836 ev->id = sas_event_data->TargetID;
2837 ev->phy_id = sas_event_data->PhyNum;
2838 memcpy(&sas_address, &sas_event_data->SASAddress,
2839 sizeof(__le64));
2840 ev->sas_address = le64_to_cpu(sas_address);
2841 ev->device_info = device_info;
2842
2843 if (sas_event_data->ReasonCode &
2844 MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
2845 ev->event_type = MPTSAS_ADD_DEVICE;
2846 else
2847 ev->event_type = MPTSAS_DEL_DEVICE;
2848 schedule_work(&ev->work);
2849 break;
2850 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
2851 /*
2852 * Persistent table is full.
2853 */
547f9a21 2854 INIT_WORK(&ioc->sas_persist_task,
c4028958 2855 mptsas_persist_clear_table);
547f9a21 2856 schedule_work(&ioc->sas_persist_task);
4b766471 2857 break;
b506ade9
EM		 2858 /*
2859 * TODO, handle other events
2860 */
4b766471 2861 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
b506ade9 2862 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
4b766471 2863 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
b506ade9
EM		 2864 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
2865 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
2866 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
2867 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
4b766471
ME		 2868 default:
2869 break;
9a28f49a 2870 }
9a28f49a 2871}
c73787ee 2872static void
547f9a21 2873mptsas_send_raid_event(MPT_ADAPTER *ioc,
c73787ee
ME		 2874 EVENT_DATA_RAID *raid_event_data)
2875{
2876 struct mptsas_hotplug_event *ev;
bd23e94c
ME		 2877 int status = le32_to_cpu(raid_event_data->SettingsStatus);
2878 int state = (status >> 8) & 0xff;
c73787ee
ME		 2879
2880 if (ioc->bus_type != SAS)
2881 return;
2882
547f9a21 2883 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
c73787ee
ME		 2884 if (!ev) {
2885 printk(KERN_WARNING "mptsas: lost hotplug event\n");
2886 return;
2887 }
2888
c4028958 2889 INIT_WORK(&ev->work, mptsas_hotplug_work);
c73787ee
ME		 2890 ev->ioc = ioc;
2891 ev->id = raid_event_data->VolumeID;
b506ade9 2892 ev->channel = raid_event_data->VolumeBus;
bd23e94c 2893 ev->event_type = MPTSAS_IGNORE_EVENT;
c73787ee
ME		 2894
2895 switch (raid_event_data->ReasonCode) {
2896 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
b506ade9
EM		 2897 ev->phys_disk_num_valid = 1;
2898 ev->phys_disk_num = raid_event_data->PhysDiskNum;
c73787ee
ME		 2899 ev->event_type = MPTSAS_ADD_DEVICE;
2900 break;
2901 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
f44e5461
ME		 2902 ev->phys_disk_num_valid = 1;
2903 ev->phys_disk_num = raid_event_data->PhysDiskNum;
b506ade9 2904 ev->hidden_raid_component = 1;
c73787ee
ME		 2905 ev->event_type = MPTSAS_DEL_DEVICE;
2906 break;
bd23e94c
ME		 2907 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
2908 switch (state) {
2909 case MPI_PD_STATE_ONLINE:
b506ade9 2910 case MPI_PD_STATE_NOT_COMPATIBLE:
bd23e94c
ME		 2911 ev->phys_disk_num_valid = 1;
2912 ev->phys_disk_num = raid_event_data->PhysDiskNum;
b506ade9 2913 ev->hidden_raid_component = 1;
bd23e94c
ME		 2914 ev->event_type = MPTSAS_ADD_DEVICE;
2915 break;
2916 case MPI_PD_STATE_MISSING:
bd23e94c
ME		 2917 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
2918 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
2919 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
b506ade9
EM		 2920 ev->phys_disk_num_valid = 1;
2921 ev->phys_disk_num = raid_event_data->PhysDiskNum;
bd23e94c
ME		 2922 ev->event_type = MPTSAS_DEL_DEVICE;
2923 break;
2924 default:
2925 break;
2926 }
2927 break;
c73787ee
ME		 2928 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
2929 ev->event_type = MPTSAS_DEL_RAID;
2930 break;
2931 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
2932 ev->event_type = MPTSAS_ADD_RAID;
2933 break;
2934 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
bd23e94c
ME		 2935 switch (state) {
2936 case MPI_RAIDVOL0_STATUS_STATE_FAILED:
2937 case MPI_RAIDVOL0_STATUS_STATE_MISSING:
2938 ev->event_type = MPTSAS_DEL_RAID;
2939 break;
2940 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
2941 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
2942 ev->event_type = MPTSAS_ADD_RAID;
2943 break;
2944 default:
2945 break;
2946 }
c73787ee
ME		 2947 break;
2948 default:
2949 break;
2950 }
2951 schedule_work(&ev->work);
2952}
2953
e6b2d76a 2954static void
547f9a21 2955mptsas_send_discovery_event(MPT_ADAPTER *ioc,
e6b2d76a
ME		 2956 EVENT_DATA_SAS_DISCOVERY *discovery_data)
2957{
2958 struct mptsas_discovery_event *ev;
2959
2960 /*
2961 * DiscoveryStatus
2962 *
2963 * This flag will be non-zero when firmware
2964 * kicks off discovery, and return to zero
2965 * once its completed.
2966 */
2967 if (discovery_data->DiscoveryStatus)
2968 return;
2969
547f9a21 2970 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
e6b2d76a
ME		 2971 if (!ev)
2972 return;
c4028958 2973 INIT_WORK(&ev->work, mptsas_discovery_work);
e6b2d76a
ME		 2974 ev->ioc = ioc;
2975 schedule_work(&ev->work);
2976};
2977
b506ade9
EM		 2978/*
2979 * mptsas_send_ir2_event - handle exposing hidden disk when
2980 * an inactive raid volume is added
2981 *
2982 * @ioc: Pointer to MPT_ADAPTER structure
2983 * @ir2_data
2984 *
2985 */
2986static void
2987mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data)
2988{
2989 struct mptsas_hotplug_event *ev;
2990
2991 if (ir2_data->ReasonCode !=
2992 MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED)
2993 return;
2994
2995 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2996 if (!ev)
2997 return;
2998
2999 INIT_WORK(&ev->work, mptsas_hotplug_work);
3000 ev->ioc = ioc;
3001 ev->id = ir2_data->TargetID;
3002 ev->channel = ir2_data->Bus;
3003 ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME;
3004
3005 schedule_work(&ev->work);
3006};
e6b2d76a 3007
9a28f49a
CH		 3008static int
3009mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
3010{
c73787ee 3011 int rc=1;
9a28f49a
CH		 3012 u8 event = le32_to_cpu(reply->Event) & 0xFF;
3013
3014 if (!ioc->sh)
c73787ee 3015 goto out;
9a28f49a 3016
e6b2d76a
ME		 3017 /*
3018 * sas_discovery_ignore_events
3019 *
3020 * This flag is to prevent anymore processing of
3021 * sas events once mptsas_remove function is called.
3022 */
3023 if (ioc->sas_discovery_ignore_events) {
3024 rc = mptscsih_event_process(ioc, reply);
3025 goto out;
3026 }
3027
9a28f49a
CH		 3028 switch (event) {
3029 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
547f9a21 3030 mptsas_send_sas_event(ioc,
9a28f49a 3031 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
c73787ee
ME		 3032 break;
3033 case MPI_EVENT_INTEGRATED_RAID:
547f9a21 3034 mptsas_send_raid_event(ioc,
c73787ee
ME		 3035 (EVENT_DATA_RAID *)reply->Data);
3036 break;
79de278e 3037 case MPI_EVENT_PERSISTENT_TABLE_FULL:
547f9a21 3038 INIT_WORK(&ioc->sas_persist_task,
c4028958 3039 mptsas_persist_clear_table);
547f9a21 3040 schedule_work(&ioc->sas_persist_task);
79de278e 3041 break;
4b766471 3042 case MPI_EVENT_SAS_DISCOVERY:
547f9a21 3043 mptsas_send_discovery_event(ioc,
e6b2d76a
ME		 3044 (EVENT_DATA_SAS_DISCOVERY *)reply->Data);
3045 break;
b506ade9
EM		 3046 case MPI_EVENT_IR2:
3047 mptsas_send_ir2_event(ioc,
3048 (PTR_MPI_EVENT_DATA_IR2)reply->Data);
3049 break;
9a28f49a 3050 default:
c73787ee
ME		 3051 rc = mptscsih_event_process(ioc, reply);
3052 break;
9a28f49a 3053 }
c73787ee
ME		 3054 out:
3055
3056 return rc;
9a28f49a
CH		 3057}
3058
0c33b27d
CH		 3059static int
3060mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
3061{
3062 struct Scsi_Host *sh;
3063 MPT_SCSI_HOST *hd;
3064 MPT_ADAPTER *ioc;
3065 unsigned long flags;
1ca00bb7 3066 int ii;
0c33b27d
CH		 3067 int numSGE = 0;
3068 int scale;
3069 int ioc_cap;
0c33b27d
CH		 3070 int error=0;
3071 int r;
3072
3073 r = mpt_attach(pdev,id);
3074 if (r)
3075 return r;
3076
3077 ioc = pci_get_drvdata(pdev);
3078 ioc->DoneCtx = mptsasDoneCtx;
3079 ioc->TaskCtx = mptsasTaskCtx;
3080 ioc->InternalCtx = mptsasInternalCtx;
3081
3082 /* Added sanity check on readiness of the MPT adapter.
3083 */
3084 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
3085 printk(MYIOC_s_WARN_FMT
3086 "Skipping because it's not operational!\n",
3087 ioc->name);
7acec1e7
MED		 3088 error = -ENODEV;
3089 goto out_mptsas_probe;
0c33b27d
CH		 3090 }
3091
3092 if (!ioc->active) {
3093 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
3094 ioc->name);
7acec1e7
MED		 3095 error = -ENODEV;
3096 goto out_mptsas_probe;
0c33b27d
CH		 3097 }
3098
3099 /* Sanity check - ensure at least 1 port is INITIATOR capable
3100 */
3101 ioc_cap = 0;
3102 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
3103 if (ioc->pfacts[ii].ProtocolFlags &
3104 MPI_PORTFACTS_PROTOCOL_INITIATOR)
3105 ioc_cap++;
3106 }
3107
3108 if (!ioc_cap) {
3109 printk(MYIOC_s_WARN_FMT
3110 "Skipping ioc=%p because SCSI Initiator mode "
3111 "is NOT enabled!\n", ioc->name, ioc);
466544d8 3112 return 0;
0c33b27d
CH		 3113 }
3114
3115 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
3116 if (!sh) {
3117 printk(MYIOC_s_WARN_FMT
3118 "Unable to register controller with SCSI subsystem\n",
3119 ioc->name);
7acec1e7
MED		 3120 error = -1;
3121 goto out_mptsas_probe;
0c33b27d
CH		 3122 }
3123
3124 spin_lock_irqsave(&ioc->FreeQlock, flags);
3125
3126 /* Attach the SCSI Host to the IOC structure
3127 */
3128 ioc->sh = sh;
3129
3130 sh->io_port = 0;
3131 sh->n_io_port = 0;
3132 sh->irq = 0;
3133
3134 /* set 16 byte cdb's */
3135 sh->max_cmd_len = 16;
3136
793955f5
EM		 3137 sh->max_id = ioc->pfacts[0].PortSCSIID;
3138 sh->max_lun = max_lun;
0c33b27d
CH		 3139
3140 sh->transportt = mptsas_transport_template;
3141
0c33b27d
CH		 3142 sh->this_id = ioc->pfacts[0].PortSCSIID;
3143
3144 /* Required entry.
3145 */
3146 sh->unique_id = ioc->id;
3147
3148 INIT_LIST_HEAD(&ioc->sas_topology);
9a28f49a 3149 mutex_init(&ioc->sas_topology_mutex);
e6b2d76a 3150 mutex_init(&ioc->sas_discovery_mutex);
eeb846ce 3151 mutex_init(&ioc->sas_mgmt.mutex);
da4fa655 3152 init_completion(&ioc->sas_mgmt.done);
0c33b27d
CH		 3153
3154 /* Verify that we won't exceed the maximum
3155 * number of chain buffers
3156 * We can optimize: ZZ = req_sz/sizeof(SGE)
3157 * For 32bit SGE's:
3158 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
3159 * + (req_sz - 64)/sizeof(SGE)
3160 * A slightly different algorithm is required for
3161 * 64bit SGEs.
3162 */
3163 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
3164 if (sizeof(dma_addr_t) == sizeof(u64)) {
3165 numSGE = (scale - 1) *
3166 (ioc->facts.MaxChainDepth-1) + scale +
3167 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
3168 sizeof(u32));
3169 } else {
3170 numSGE = 1 + (scale - 1) *
3171 (ioc->facts.MaxChainDepth-1) + scale +
3172 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
3173 sizeof(u32));
3174 }
3175
3176 if (numSGE < sh->sg_tablesize) {
3177 /* Reset this value */
3178 dprintk((MYIOC_s_INFO_FMT
3179 "Resetting sg_tablesize to %d from %d\n",
3180 ioc->name, numSGE, sh->sg_tablesize));
3181 sh->sg_tablesize = numSGE;
3182 }
3183
0c33b27d
CH		 3184 hd = (MPT_SCSI_HOST *) sh->hostdata;
3185 hd->ioc = ioc;
3186
3187 /* SCSI needs scsi_cmnd lookup table!
3188 * (with size equal to req_depth*PtrSz!)
3189 */
1ca00bb7
CH		 3190 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
3191 if (!hd->ScsiLookup) {
0c33b27d 3192 error = -ENOMEM;
7acec1e7 3193 goto out_mptsas_probe;
0c33b27d
CH		 3194 }
3195
1ca00bb7
CH		 3196 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
3197 ioc->name, hd->ScsiLookup));
0c33b27d 3198
0c33b27d
CH		 3199 /* Clear the TM flags
3200 */
3201 hd->tmPending = 0;
3202 hd->tmState = TM_STATE_NONE;
3203 hd->resetPending = 0;
3204 hd->abortSCpnt = NULL;
3205
3206 /* Clear the pointer used to store
3207 * single-threaded commands, i.e., those
3208 * issued during a bus scan, dv and
3209 * configuration pages.
3210 */
3211 hd->cmdPtr = NULL;
3212
3213 /* Initialize this SCSI Hosts' timers
3214 * To use, set the timer expires field
3215 * and add_timer
3216 */
3217 init_timer(&hd->timer);
3218 hd->timer.data = (unsigned long) hd;
3219 hd->timer.function = mptscsih_timer_expired;
3220
0c33b27d
CH		 3221 ioc->sas_data.ptClear = mpt_pt_clear;
3222
df9e062a
EM		 3223 init_waitqueue_head(&hd->scandv_waitq);
3224 hd->scandv_wait_done = 0;
3225 hd->last_queue_full = 0;
3226 INIT_LIST_HEAD(&hd->target_reset_list);
3227 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
3228
0c33b27d
CH		 3229 if (ioc->sas_data.ptClear==1) {
3230 mptbase_sas_persist_operation(
3231 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
3232 }
3233
0c33b27d
CH		 3234 error = scsi_add_host(sh, &ioc->pcidev->dev);
3235 if (error) {
3236 dprintk((KERN_ERR MYNAM
3237 "scsi_add_host failed\n"));
7acec1e7 3238 goto out_mptsas_probe;
0c33b27d
CH		 3239 }
3240
3241 mptsas_scan_sas_topology(ioc);
3242
3243 return 0;
3244
547f9a21 3245 out_mptsas_probe:
0c33b27d
CH		 3246
3247 mptscsih_remove(pdev);
3248 return error;
3249}
3250
3251static void __devexit mptsas_remove(struct pci_dev *pdev)
3252{
3253 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
3254 struct mptsas_portinfo *p, *n;
547f9a21 3255 int i;
0c33b27d 3256
b506ade9 3257 ioc->sas_discovery_ignore_events = 1;
0c33b27d
CH		 3258 sas_remove_host(ioc->sh);
3259
9a28f49a 3260 mutex_lock(&ioc->sas_topology_mutex);
0c33b27d
CH		 3261 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
3262 list_del(&p->list);
547f9a21
EM		 3263 for (i = 0 ; i < p->num_phys ; i++)
3264 mptsas_port_delete(p->phy_info[i].port_details);
3265 kfree(p->phy_info);
0c33b27d
CH		 3266 kfree(p);
3267 }
9a28f49a 3268 mutex_unlock(&ioc->sas_topology_mutex);
0c33b27d
CH		 3269
3270 mptscsih_remove(pdev);
3271}
3272
3273static struct pci_device_id mptsas_pci_table[] = {
87cf8986 3274 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064,
0c33b27d 3275 PCI_ANY_ID, PCI_ANY_ID },
87cf8986 3276 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068,
0c33b27d 3277 PCI_ANY_ID, PCI_ANY_ID },
87cf8986 3278 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E,
0c33b27d 3279 PCI_ANY_ID, PCI_ANY_ID },
87cf8986 3280 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E,
0c33b27d 3281 PCI_ANY_ID, PCI_ANY_ID },
87cf8986 3282 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078,
0c33b27d
CH		 3283 PCI_ANY_ID, PCI_ANY_ID },
3284 {0} /* Terminating entry */
3285};
3286MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
3287
3288
3289static struct pci_driver mptsas_driver = {
3290 .name = "mptsas",
3291 .id_table = mptsas_pci_table,
3292 .probe = mptsas_probe,
3293 .remove = __devexit_p(mptsas_remove),
3294 .shutdown = mptscsih_shutdown,
3295#ifdef CONFIG_PM
3296 .suspend = mptscsih_suspend,
3297 .resume = mptscsih_resume,
3298#endif
3299};
3300
3301static int __init
3302mptsas_init(void)
3303{
3304 show_mptmod_ver(my_NAME, my_VERSION);
3305
3306 mptsas_transport_template =
3307 sas_attach_transport(&mptsas_transport_functions);
3308 if (!mptsas_transport_template)
3309 return -ENODEV;
3310
3311 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
df9e062a 3312 mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
0c33b27d
CH		 3313 mptsasInternalCtx =
3314 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
da4fa655 3315 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
0c33b27d 3316
9a28f49a 3317 if (mpt_event_register(mptsasDoneCtx, mptsas_event_process) == 0) {
3a892bef 3318 devtverboseprintk((KERN_INFO MYNAM
0c33b27d
CH		 3319 ": Registered for IOC event notifications\n"));
3320 }
3321
df9e062a 3322 if (mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset) == 0) {
0c33b27d
CH		 3323 dprintk((KERN_INFO MYNAM
3324 ": Registered for IOC reset notifications\n"));
3325 }
3326
3327 return pci_register_driver(&mptsas_driver);
3328}
3329
3330static void __exit
3331mptsas_exit(void)
3332{
3333 pci_unregister_driver(&mptsas_driver);
3334 sas_release_transport(mptsas_transport_template);
3335
3336 mpt_reset_deregister(mptsasDoneCtx);
3337 mpt_event_deregister(mptsasDoneCtx);
3338
da4fa655 3339 mpt_deregister(mptsasMgmtCtx);
0c33b27d
CH		 3340 mpt_deregister(mptsasInternalCtx);
3341 mpt_deregister(mptsasTaskCtx);
3342 mpt_deregister(mptsasDoneCtx);
3343}
3344
3345module_init(mptsas_init);
3346module_exit(mptsas_exit);
kernel source for telekom puls (alcatel/mediatek)