?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] fusion: move sas persistent event handling over to the mptsas module
[linux-2.6/cjktty.git] / drivers / message / fusion / mptsas.c
blob90660bfa148cff0696eebc00ffec8dc549c62f68
1 /*
2 * linux/drivers/message/fusion/mptsas.c
3 * For use with LSI Logic PCI chip/adapter(s)
4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
5 *
6 * Copyright (c) 1999-2005 LSI Logic Corporation
7 * (mailto:mpt_linux_developer@lsil.com)
8 * Copyright (c) 2005-2006 Dell
9 */
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11 /*
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; version 2 of the License.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 NO WARRANTY
22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26 solely responsible for determining the appropriateness of using and
27 distributing the Program and assumes all risks associated with its
28 exercise of rights under this Agreement, including but not limited to
29 the risks and costs of program errors, damage to or loss of data,
30 programs or equipment, and unavailability or interruption of operations.
31
32 DISCLAIMER OF LIABILITY
33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40
41 You should have received a copy of the GNU General Public License
42 along with this program; if not, write to the Free Software
43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44 */
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/init.h>
50 #include <linux/errno.h>
51 #include <linux/sched.h>
52 #include <linux/workqueue.h>
53
54 #include <scsi/scsi_cmnd.h>
55 #include <scsi/scsi_device.h>
56 #include <scsi/scsi_host.h>
57 #include <scsi/scsi_transport_sas.h>
58
59 #include "mptbase.h"
60 #include "mptscsih.h"
61
62
63 #define my_NAME "Fusion MPT SAS Host driver"
64 #define my_VERSION MPT_LINUX_VERSION_COMMON
65 #define MYNAM "mptsas"
66
67 MODULE_AUTHOR(MODULEAUTHOR);
68 MODULE_DESCRIPTION(my_NAME);
69 MODULE_LICENSE("GPL");
70
71 static int mpt_pq_filter;
72 module_param(mpt_pq_filter, int, 0);
73 MODULE_PARM_DESC(mpt_pq_filter,
74 "Enable peripheral qualifier filter: enable=1 "
75 "(default=0)");
76
77 static int mpt_pt_clear;
78 module_param(mpt_pt_clear, int, 0);
79 MODULE_PARM_DESC(mpt_pt_clear,
80 "Clear persistency table: enable=1 "
81 "(default=MPTSCSIH_PT_CLEAR=0)");
82
83 static int mptsasDoneCtx = -1;
84 static int mptsasTaskCtx = -1;
85 static int mptsasInternalCtx = -1; /* Used only for internal commands */
86 static int mptsasMgmtCtx = -1;
87
88
89 enum mptsas_hotplug_action {
90 MPTSAS_ADD_DEVICE,
91 MPTSAS_DEL_DEVICE,
92 MPTSAS_ADD_RAID,
93 MPTSAS_DEL_RAID,
94 };
95
96 struct mptsas_hotplug_event {
97 struct work_struct work;
98 MPT_ADAPTER *ioc;
99 enum mptsas_hotplug_action event_type;
100 u64 sas_address;
101 u32 channel;
102 u32 id;
103 u32 device_info;
104 u16 handle;
105 u16 parent_handle;
106 u8 phy_id;
107 };
108
109 /*
110 * SAS topology structures
111 *
112 * The MPT Fusion firmware interface spreads information about the
113 * SAS topology over many manufacture pages, thus we need some data
114 * structure to collect it and process it for the SAS transport class.
115 */
116
117 struct mptsas_devinfo {
118 u16 handle; /* unique id to address this device */
119 u16 handle_parent; /* unique id to address parent device */
120 u8 phy_id; /* phy number of parent device */
121 u8 port_id; /* sas physical port this device
122 is assoc'd with */
123 u8 id; /* logical target id of this device */
124 u8 channel; /* logical bus number of this device */
125 u64 sas_address; /* WWN of this device,
126 SATA is assigned by HBA,expander */
127 u32 device_info; /* bitfield detailed info about this device */
128 };
129
130 struct mptsas_phyinfo {
131 u8 phy_id; /* phy index */
132 u8 port_id; /* port number this phy is part of */
133 u8 negotiated_link_rate; /* nego'd link rate for this phy */
134 u8 hw_link_rate; /* hardware max/min phys link rate */
135 u8 programmed_link_rate; /* programmed max/min phy link rate */
136 struct mptsas_devinfo identify; /* point to phy device info */
137 struct mptsas_devinfo attached; /* point to attached device info */
138 struct sas_phy *phy;
139 struct sas_rphy *rphy;
140 };
141
142 struct mptsas_portinfo {
143 struct list_head list;
144 u16 handle; /* unique id to address this */
145 u8 num_phys; /* number of phys */
146 struct mptsas_phyinfo *phy_info;
147 };
148
149
150 #ifdef SASDEBUG
151 static void mptsas_print_phy_data(MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
152 {
153 printk("---- IO UNIT PAGE 0 ------------\n");
154 printk("Handle=0x%X\n",
155 le16_to_cpu(phy_data->AttachedDeviceHandle));
156 printk("Controller Handle=0x%X\n",
157 le16_to_cpu(phy_data->ControllerDevHandle));
158 printk("Port=0x%X\n", phy_data->Port);
159 printk("Port Flags=0x%X\n", phy_data->PortFlags);
160 printk("PHY Flags=0x%X\n", phy_data->PhyFlags);
161 printk("Negotiated Link Rate=0x%X\n", phy_data->NegotiatedLinkRate);
162 printk("Controller PHY Device Info=0x%X\n",
163 le32_to_cpu(phy_data->ControllerPhyDeviceInfo));
164 printk("DiscoveryStatus=0x%X\n",
165 le32_to_cpu(phy_data->DiscoveryStatus));
166 printk("\n");
167 }
168
169 static void mptsas_print_phy_pg0(SasPhyPage0_t *pg0)
170 {
171 __le64 sas_address;
172
173 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
174
175 printk("---- SAS PHY PAGE 0 ------------\n");
176 printk("Attached Device Handle=0x%X\n",
177 le16_to_cpu(pg0->AttachedDevHandle));
178 printk("SAS Address=0x%llX\n",
179 (unsigned long long)le64_to_cpu(sas_address));
180 printk("Attached PHY Identifier=0x%X\n", pg0->AttachedPhyIdentifier);
181 printk("Attached Device Info=0x%X\n",
182 le32_to_cpu(pg0->AttachedDeviceInfo));
183 printk("Programmed Link Rate=0x%X\n", pg0->ProgrammedLinkRate);
184 printk("Change Count=0x%X\n", pg0->ChangeCount);
185 printk("PHY Info=0x%X\n", le32_to_cpu(pg0->PhyInfo));
186 printk("\n");
187 }
188
189 static void mptsas_print_phy_pg1(SasPhyPage1_t *pg1)
190 {
191 printk("---- SAS PHY PAGE 1 ------------\n");
192 printk("Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount);
193 printk("Running Disparity Error Count=0x%x\n",
194 pg1->RunningDisparityErrorCount);
195 printk("Loss Dword Synch Count=0x%x\n", pg1->LossDwordSynchCount);
196 printk("PHY Reset Problem Count=0x%x\n", pg1->PhyResetProblemCount);
197 printk("\n");
198 }
199
200 static void mptsas_print_device_pg0(SasDevicePage0_t *pg0)
201 {
202 __le64 sas_address;
203
204 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64));
205
206 printk("---- SAS DEVICE PAGE 0 ---------\n");
207 printk("Handle=0x%X\n" ,le16_to_cpu(pg0->DevHandle));
208 printk("Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle));
209 printk("Slot=0x%X\n", le16_to_cpu(pg0->Slot));
210 printk("SAS Address=0x%llX\n", le64_to_cpu(sas_address));
211 printk("Target ID=0x%X\n", pg0->TargetID);
212 printk("Bus=0x%X\n", pg0->Bus);
213 /* The PhyNum field specifies the PHY number of the parent
214 * device this device is linked to
215 */
216 printk("Parent Phy Num=0x%X\n", pg0->PhyNum);
217 printk("Access Status=0x%X\n", le16_to_cpu(pg0->AccessStatus));
218 printk("Device Info=0x%X\n", le32_to_cpu(pg0->DeviceInfo));
219 printk("Flags=0x%X\n", le16_to_cpu(pg0->Flags));
220 printk("Physical Port=0x%X\n", pg0->PhysicalPort);
221 printk("\n");
222 }
223
224 static void mptsas_print_expander_pg1(SasExpanderPage1_t *pg1)
225 {
226 printk("---- SAS EXPANDER PAGE 1 ------------\n");
227
228 printk("Physical Port=0x%X\n", pg1->PhysicalPort);
229 printk("PHY Identifier=0x%X\n", pg1->PhyIdentifier);
230 printk("Negotiated Link Rate=0x%X\n", pg1->NegotiatedLinkRate);
231 printk("Programmed Link Rate=0x%X\n", pg1->ProgrammedLinkRate);
232 printk("Hardware Link Rate=0x%X\n", pg1->HwLinkRate);
233 printk("Owner Device Handle=0x%X\n",
234 le16_to_cpu(pg1->OwnerDevHandle));
235 printk("Attached Device Handle=0x%X\n",
236 le16_to_cpu(pg1->AttachedDevHandle));
237 }
238 #else
239 #define mptsas_print_phy_data(phy_data) do { } while (0)
240 #define mptsas_print_phy_pg0(pg0) do { } while (0)
241 #define mptsas_print_phy_pg1(pg1) do { } while (0)
242 #define mptsas_print_device_pg0(pg0) do { } while (0)
243 #define mptsas_print_expander_pg1(pg1) do { } while (0)
244 #endif
245
246
247 /*
248 * This is pretty ugly. We will be able to seriously clean it up
249 * once the DV code in mptscsih goes away and we can properly
250 * implement ->target_alloc.
251 */
252 static int
253 mptsas_slave_alloc(struct scsi_device *sdev)
254 {
255 struct Scsi_Host *host = sdev->host;
256 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
257 struct sas_rphy *rphy;
258 struct mptsas_portinfo *p;
259 VirtTarget *vtarget;
260 VirtDevice *vdev;
261 struct scsi_target *starget;
262 int i;
263
264 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
265 if (!vdev) {
266 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
267 hd->ioc->name, sizeof(VirtDevice));
268 return -ENOMEM;
269 }
270 vdev->ioc_id = hd->ioc->id;
271 sdev->hostdata = vdev;
272 starget = scsi_target(sdev);
273 vtarget = starget->hostdata;
274 vdev->vtarget = vtarget;
275 if (vtarget->num_luns == 0) {
276 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES|MPT_TARGET_FLAGS_VALID_INQUIRY;
277 hd->Targets[sdev->id] = vtarget;
278 }
279
280 /*
281 RAID volumes placed beyond the last expected port.
282 */
283 if (sdev->channel == hd->ioc->num_ports) {
284 vdev->target_id = sdev->id;
285 vdev->bus_id = 0;
286 vdev->lun = 0;
287 goto out;
288 }
289
290 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
291 mutex_lock(&hd->ioc->sas_topology_mutex);
292 list_for_each_entry(p, &hd->ioc->sas_topology, list) {
293 for (i = 0; i < p->num_phys; i++) {
294 if (p->phy_info[i].attached.sas_address ==
295 rphy->identify.sas_address) {
296 vdev->target_id =
297 p->phy_info[i].attached.id;
298 vdev->bus_id = p->phy_info[i].attached.channel;
299 vdev->lun = sdev->lun;
300 mutex_unlock(&hd->ioc->sas_topology_mutex);
301 goto out;
302 }
303 }
304 }
305 mutex_unlock(&hd->ioc->sas_topology_mutex);
306
307 printk("No matching SAS device found!!\n");
308 kfree(vdev);
309 return -ENODEV;
310
311 out:
312 vtarget->ioc_id = vdev->ioc_id;
313 vtarget->target_id = vdev->target_id;
314 vtarget->bus_id = vdev->bus_id;
315 vtarget->num_luns++;
316 return 0;
317 }
318
319 static void
320 mptsas_slave_destroy(struct scsi_device *sdev)
321 {
322 struct Scsi_Host *host = sdev->host;
323 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata;
324 struct sas_rphy *rphy;
325 struct mptsas_portinfo *p;
326 int i;
327 VirtDevice *vdev;
328
329 /*
330 * Handle hotplug removal case.
331 * We need to clear out attached data structure.
332 */
333 rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
334
335 mutex_lock(&hd->ioc->sas_topology_mutex);
336 list_for_each_entry(p, &hd->ioc->sas_topology, list) {
337 for (i = 0; i < p->num_phys; i++) {
338 if (p->phy_info[i].attached.sas_address ==
339 rphy->identify.sas_address) {
340 memset(&p->phy_info[i].attached, 0,
341 sizeof(struct mptsas_devinfo));
342 p->phy_info[i].rphy = NULL;
343 goto out;
344 }
345 }
346 }
347
348 out:
349 mutex_unlock(&hd->ioc->sas_topology_mutex);
350 /*
351 * Issue target reset to flush firmware outstanding commands.
352 */
353 vdev = sdev->hostdata;
354 if (vdev->configured_lun){
355 if (mptscsih_TMHandler(hd,
356 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
357 vdev->bus_id,
358 vdev->target_id,
359 0, 0, 5 /* 5 second timeout */)
360 < 0){
361
362 /* The TM request failed!
363 * Fatal error case.
364 */
365 printk(MYIOC_s_WARN_FMT
366 "Error processing TaskMgmt id=%d TARGET_RESET\n",
367 hd->ioc->name,
368 vdev->target_id);
369
370 hd->tmPending = 0;
371 hd->tmState = TM_STATE_NONE;
372 }
373 }
374 mptscsih_slave_destroy(sdev);
375 }
376
377 static struct scsi_host_template mptsas_driver_template = {
378 .module = THIS_MODULE,
379 .proc_name = "mptsas",
380 .proc_info = mptscsih_proc_info,
381 .name = "MPT SPI Host",
382 .info = mptscsih_info,
383 .queuecommand = mptscsih_qcmd,
384 .target_alloc = mptscsih_target_alloc,
385 .slave_alloc = mptsas_slave_alloc,
386 .slave_configure = mptscsih_slave_configure,
387 .target_destroy = mptscsih_target_destroy,
388 .slave_destroy = mptsas_slave_destroy,
389 .change_queue_depth = mptscsih_change_queue_depth,
390 .eh_abort_handler = mptscsih_abort,
391 .eh_device_reset_handler = mptscsih_dev_reset,
392 .eh_bus_reset_handler = mptscsih_bus_reset,
393 .eh_host_reset_handler = mptscsih_host_reset,
394 .bios_param = mptscsih_bios_param,
395 .can_queue = MPT_FC_CAN_QUEUE,
396 .this_id = -1,
397 .sg_tablesize = MPT_SCSI_SG_DEPTH,
398 .max_sectors = 8192,
399 .cmd_per_lun = 7,
400 .use_clustering = ENABLE_CLUSTERING,
401 };
402
403 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
404 {
405 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
406 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
407 }
408
409 static int mptsas_get_linkerrors(struct sas_phy *phy)
410 {
411 MPT_ADAPTER *ioc = phy_to_ioc(phy);
412 ConfigExtendedPageHeader_t hdr;
413 CONFIGPARMS cfg;
414 SasPhyPage1_t *buffer;
415 dma_addr_t dma_handle;
416 int error;
417
418 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
419 hdr.ExtPageLength = 0;
420 hdr.PageNumber = 1 /* page number 1*/;
421 hdr.Reserved1 = 0;
422 hdr.Reserved2 = 0;
423 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
424 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
425
426 cfg.cfghdr.ehdr = &hdr;
427 cfg.physAddr = -1;
428 cfg.pageAddr = phy->identify.phy_identifier;
429 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
430 cfg.dir = 0; /* read */
431 cfg.timeout = 10;
432
433 error = mpt_config(ioc, &cfg);
434 if (error)
435 return error;
436 if (!hdr.ExtPageLength)
437 return -ENXIO;
438
439 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
440 &dma_handle);
441 if (!buffer)
442 return -ENOMEM;
443
444 cfg.physAddr = dma_handle;
445 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
446
447 error = mpt_config(ioc, &cfg);
448 if (error)
449 goto out_free_consistent;
450
451 mptsas_print_phy_pg1(buffer);
452
453 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
454 phy->running_disparity_error_count =
455 le32_to_cpu(buffer->RunningDisparityErrorCount);
456 phy->loss_of_dword_sync_count =
457 le32_to_cpu(buffer->LossDwordSynchCount);
458 phy->phy_reset_problem_count =
459 le32_to_cpu(buffer->PhyResetProblemCount);
460
461 out_free_consistent:
462 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
463 buffer, dma_handle);
464 return error;
465 }
466
467 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
468 MPT_FRAME_HDR *reply)
469 {
470 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
471 if (reply != NULL) {
472 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
473 memcpy(ioc->sas_mgmt.reply, reply,
474 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
475 }
476 complete(&ioc->sas_mgmt.done);
477 return 1;
478 }
479
480 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
481 {
482 MPT_ADAPTER *ioc = phy_to_ioc(phy);
483 SasIoUnitControlRequest_t *req;
484 SasIoUnitControlReply_t *reply;
485 MPT_FRAME_HDR *mf;
486 MPIHeader_t *hdr;
487 unsigned long timeleft;
488 int error = -ERESTARTSYS;
489
490 /* not implemented for expanders */
491 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
492 return -ENXIO;
493
494 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
495 goto out;
496
497 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
498 if (!mf) {
499 error = -ENOMEM;
500 goto out_unlock;
501 }
502
503 hdr = (MPIHeader_t *) mf;
504 req = (SasIoUnitControlRequest_t *)mf;
505 memset(req, 0, sizeof(SasIoUnitControlRequest_t));
506 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
507 req->MsgContext = hdr->MsgContext;
508 req->Operation = hard_reset ?
509 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
510 req->PhyNum = phy->identify.phy_identifier;
511
512 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
513
514 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
515 10 * HZ);
516 if (!timeleft) {
517 /* On timeout reset the board */
518 mpt_free_msg_frame(ioc, mf);
519 mpt_HardResetHandler(ioc, CAN_SLEEP);
520 error = -ETIMEDOUT;
521 goto out_unlock;
522 }
523
524 /* a reply frame is expected */
525 if ((ioc->sas_mgmt.status &
526 MPT_IOCTL_STATUS_RF_VALID) == 0) {
527 error = -ENXIO;
528 goto out_unlock;
529 }
530
531 /* process the completed Reply Message Frame */
532 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
533 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
534 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
535 __FUNCTION__,
536 reply->IOCStatus,
537 reply->IOCLogInfo);
538 error = -ENXIO;
539 goto out_unlock;
540 }
541
542 error = 0;
543
544 out_unlock:
545 mutex_unlock(&ioc->sas_mgmt.mutex);
546 out:
547 return error;
548 }
549
550 static struct sas_function_template mptsas_transport_functions = {
551 .get_linkerrors = mptsas_get_linkerrors,
552 .phy_reset = mptsas_phy_reset,
553 };
554
555 static struct scsi_transport_template *mptsas_transport_template;
556
557 static int
558 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
559 {
560 ConfigExtendedPageHeader_t hdr;
561 CONFIGPARMS cfg;
562 SasIOUnitPage0_t *buffer;
563 dma_addr_t dma_handle;
564 int error, i;
565
566 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
567 hdr.ExtPageLength = 0;
568 hdr.PageNumber = 0;
569 hdr.Reserved1 = 0;
570 hdr.Reserved2 = 0;
571 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
572 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
573
574 cfg.cfghdr.ehdr = &hdr;
575 cfg.physAddr = -1;
576 cfg.pageAddr = 0;
577 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
578 cfg.dir = 0; /* read */
579 cfg.timeout = 10;
580
581 error = mpt_config(ioc, &cfg);
582 if (error)
583 goto out;
584 if (!hdr.ExtPageLength) {
585 error = -ENXIO;
586 goto out;
587 }
588
589 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
590 &dma_handle);
591 if (!buffer) {
592 error = -ENOMEM;
593 goto out;
594 }
595
596 cfg.physAddr = dma_handle;
597 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
598
599 error = mpt_config(ioc, &cfg);
600 if (error)
601 goto out_free_consistent;
602
603 port_info->num_phys = buffer->NumPhys;
604 port_info->phy_info = kcalloc(port_info->num_phys,
605 sizeof(struct mptsas_phyinfo),GFP_KERNEL);
606 if (!port_info->phy_info) {
607 error = -ENOMEM;
608 goto out_free_consistent;
609 }
610
611 for (i = 0; i < port_info->num_phys; i++) {
612 mptsas_print_phy_data(&buffer->PhyData[i]);
613 port_info->phy_info[i].phy_id = i;
614 port_info->phy_info[i].port_id =
615 buffer->PhyData[i].Port;
616 port_info->phy_info[i].negotiated_link_rate =
617 buffer->PhyData[i].NegotiatedLinkRate;
618 }
619
620 out_free_consistent:
621 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
622 buffer, dma_handle);
623 out:
624 return error;
625 }
626
627 static int
628 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
629 u32 form, u32 form_specific)
630 {
631 ConfigExtendedPageHeader_t hdr;
632 CONFIGPARMS cfg;
633 SasPhyPage0_t *buffer;
634 dma_addr_t dma_handle;
635 int error;
636
637 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
638 hdr.ExtPageLength = 0;
639 hdr.PageNumber = 0;
640 hdr.Reserved1 = 0;
641 hdr.Reserved2 = 0;
642 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
643 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
644
645 cfg.cfghdr.ehdr = &hdr;
646 cfg.dir = 0; /* read */
647 cfg.timeout = 10;
648
649 /* Get Phy Pg 0 for each Phy. */
650 cfg.physAddr = -1;
651 cfg.pageAddr = form + form_specific;
652 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
653
654 error = mpt_config(ioc, &cfg);
655 if (error)
656 goto out;
657
658 if (!hdr.ExtPageLength) {
659 error = -ENXIO;
660 goto out;
661 }
662
663 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
664 &dma_handle);
665 if (!buffer) {
666 error = -ENOMEM;
667 goto out;
668 }
669
670 cfg.physAddr = dma_handle;
671 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
672
673 error = mpt_config(ioc, &cfg);
674 if (error)
675 goto out_free_consistent;
676
677 mptsas_print_phy_pg0(buffer);
678
679 phy_info->hw_link_rate = buffer->HwLinkRate;
680 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
681 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
682 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
683
684 out_free_consistent:
685 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
686 buffer, dma_handle);
687 out:
688 return error;
689 }
690
691 static int
692 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
693 u32 form, u32 form_specific)
694 {
695 ConfigExtendedPageHeader_t hdr;
696 CONFIGPARMS cfg;
697 SasDevicePage0_t *buffer;
698 dma_addr_t dma_handle;
699 __le64 sas_address;
700 int error;
701
702 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
703 hdr.ExtPageLength = 0;
704 hdr.PageNumber = 0;
705 hdr.Reserved1 = 0;
706 hdr.Reserved2 = 0;
707 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
708 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
709
710 cfg.cfghdr.ehdr = &hdr;
711 cfg.pageAddr = form + form_specific;
712 cfg.physAddr = -1;
713 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
714 cfg.dir = 0; /* read */
715 cfg.timeout = 10;
716
717 error = mpt_config(ioc, &cfg);
718 if (error)
719 goto out;
720 if (!hdr.ExtPageLength) {
721 error = -ENXIO;
722 goto out;
723 }
724
725 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
726 &dma_handle);
727 if (!buffer) {
728 error = -ENOMEM;
729 goto out;
730 }
731
732 cfg.physAddr = dma_handle;
733 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
734
735 error = mpt_config(ioc, &cfg);
736 if (error)
737 goto out_free_consistent;
738
739 mptsas_print_device_pg0(buffer);
740
741 device_info->handle = le16_to_cpu(buffer->DevHandle);
742 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
743 device_info->phy_id = buffer->PhyNum;
744 device_info->port_id = buffer->PhysicalPort;
745 device_info->id = buffer->TargetID;
746 device_info->channel = buffer->Bus;
747 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
748 device_info->sas_address = le64_to_cpu(sas_address);
749 device_info->device_info =
750 le32_to_cpu(buffer->DeviceInfo);
751
752 out_free_consistent:
753 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
754 buffer, dma_handle);
755 out:
756 return error;
757 }
758
759 static int
760 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
761 u32 form, u32 form_specific)
762 {
763 ConfigExtendedPageHeader_t hdr;
764 CONFIGPARMS cfg;
765 SasExpanderPage0_t *buffer;
766 dma_addr_t dma_handle;
767 int error;
768
769 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
770 hdr.ExtPageLength = 0;
771 hdr.PageNumber = 0;
772 hdr.Reserved1 = 0;
773 hdr.Reserved2 = 0;
774 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
775 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
776
777 cfg.cfghdr.ehdr = &hdr;
778 cfg.physAddr = -1;
779 cfg.pageAddr = form + form_specific;
780 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
781 cfg.dir = 0; /* read */
782 cfg.timeout = 10;
783
784 error = mpt_config(ioc, &cfg);
785 if (error)
786 goto out;
787
788 if (!hdr.ExtPageLength) {
789 error = -ENXIO;
790 goto out;
791 }
792
793 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
794 &dma_handle);
795 if (!buffer) {
796 error = -ENOMEM;
797 goto out;
798 }
799
800 cfg.physAddr = dma_handle;
801 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
802
803 error = mpt_config(ioc, &cfg);
804 if (error)
805 goto out_free_consistent;
806
807 /* save config data */
808 port_info->num_phys = buffer->NumPhys;
809 port_info->handle = le16_to_cpu(buffer->DevHandle);
810 port_info->phy_info = kcalloc(port_info->num_phys,
811 sizeof(struct mptsas_phyinfo),GFP_KERNEL);
812 if (!port_info->phy_info) {
813 error = -ENOMEM;
814 goto out_free_consistent;
815 }
816
817 out_free_consistent:
818 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
819 buffer, dma_handle);
820 out:
821 return error;
822 }
823
824 static int
825 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
826 u32 form, u32 form_specific)
827 {
828 ConfigExtendedPageHeader_t hdr;
829 CONFIGPARMS cfg;
830 SasExpanderPage1_t *buffer;
831 dma_addr_t dma_handle;
832 int error;
833
834 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
835 hdr.ExtPageLength = 0;
836 hdr.PageNumber = 1;
837 hdr.Reserved1 = 0;
838 hdr.Reserved2 = 0;
839 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
840 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
841
842 cfg.cfghdr.ehdr = &hdr;
843 cfg.physAddr = -1;
844 cfg.pageAddr = form + form_specific;
845 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
846 cfg.dir = 0; /* read */
847 cfg.timeout = 10;
848
849 error = mpt_config(ioc, &cfg);
850 if (error)
851 goto out;
852
853 if (!hdr.ExtPageLength) {
854 error = -ENXIO;
855 goto out;
856 }
857
858 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
859 &dma_handle);
860 if (!buffer) {
861 error = -ENOMEM;
862 goto out;
863 }
864
865 cfg.physAddr = dma_handle;
866 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
867
868 error = mpt_config(ioc, &cfg);
869 if (error)
870 goto out_free_consistent;
871
872
873 mptsas_print_expander_pg1(buffer);
874
875 /* save config data */
876 phy_info->phy_id = buffer->PhyIdentifier;
877 phy_info->port_id = buffer->PhysicalPort;
878 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
879 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
880 phy_info->hw_link_rate = buffer->HwLinkRate;
881 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
882 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
883
884
885 out_free_consistent:
886 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
887 buffer, dma_handle);
888 out:
889 return error;
890 }
891
892 /*
893 * Returns true if there is a scsi end device
894 */
895 static inline int
896 mptsas_is_end_device(struct mptsas_devinfo * attached)
897 {
898 if ((attached->handle) &&
899 (attached->device_info &
900 MPI_SAS_DEVICE_INFO_END_DEVICE) &&
901 ((attached->device_info &
902 MPI_SAS_DEVICE_INFO_SSP_TARGET) |
903 (attached->device_info &
904 MPI_SAS_DEVICE_INFO_STP_TARGET) |
905 (attached->device_info &
906 MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
907 return 1;
908 else
909 return 0;
910 }
911
912 static void
913 mptsas_parse_device_info(struct sas_identify *identify,
914 struct mptsas_devinfo *device_info)
915 {
916 u16 protocols;
917
918 identify->sas_address = device_info->sas_address;
919 identify->phy_identifier = device_info->phy_id;
920
921 /*
922 * Fill in Phy Initiator Port Protocol.
923 * Bits 6:3, more than one bit can be set, fall through cases.
924 */
925 protocols = device_info->device_info & 0x78;
926 identify->initiator_port_protocols = 0;
927 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
928 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
929 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
930 identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
931 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
932 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
933 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
934 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
935
936 /*
937 * Fill in Phy Target Port Protocol.
938 * Bits 10:7, more than one bit can be set, fall through cases.
939 */
940 protocols = device_info->device_info & 0x780;
941 identify->target_port_protocols = 0;
942 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
943 identify->target_port_protocols |= SAS_PROTOCOL_SSP;
944 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
945 identify->target_port_protocols |= SAS_PROTOCOL_STP;
946 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
947 identify->target_port_protocols |= SAS_PROTOCOL_SMP;
948 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
949 identify->target_port_protocols |= SAS_PROTOCOL_SATA;
950
951 /*
952 * Fill in Attached device type.
953 */
954 switch (device_info->device_info &
955 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
956 case MPI_SAS_DEVICE_INFO_NO_DEVICE:
957 identify->device_type = SAS_PHY_UNUSED;
958 break;
959 case MPI_SAS_DEVICE_INFO_END_DEVICE:
960 identify->device_type = SAS_END_DEVICE;
961 break;
962 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
963 identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
964 break;
965 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
966 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
967 break;
968 }
969 }
970
971 static int mptsas_probe_one_phy(struct device *dev,
972 struct mptsas_phyinfo *phy_info, int index, int local)
973 {
974 struct sas_phy *phy;
975 int error;
976
977 phy = sas_phy_alloc(dev, index);
978 if (!phy)
979 return -ENOMEM;
980
981 phy->port_identifier = phy_info->port_id;
982 mptsas_parse_device_info(&phy->identify, &phy_info->identify);
983
984 /*
985 * Set Negotiated link rate.
986 */
987 switch (phy_info->negotiated_link_rate) {
988 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
989 phy->negotiated_linkrate = SAS_PHY_DISABLED;
990 break;
991 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
992 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
993 break;
994 case MPI_SAS_IOUNIT0_RATE_1_5:
995 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
996 break;
997 case MPI_SAS_IOUNIT0_RATE_3_0:
998 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
999 break;
1000 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
1001 case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
1002 default:
1003 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
1004 break;
1005 }
1006
1007 /*
1008 * Set Max hardware link rate.
1009 */
1010 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1011 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
1012 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1013 break;
1014 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1015 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1016 break;
1017 default:
1018 break;
1019 }
1020
1021 /*
1022 * Set Max programmed link rate.
1023 */
1024 switch (phy_info->programmed_link_rate &
1025 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1026 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
1027 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1028 break;
1029 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1030 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1031 break;
1032 default:
1033 break;
1034 }
1035
1036 /*
1037 * Set Min hardware link rate.
1038 */
1039 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
1040 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
1041 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
1042 break;
1043 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1044 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
1045 break;
1046 default:
1047 break;
1048 }
1049
1050 /*
1051 * Set Min programmed link rate.
1052 */
1053 switch (phy_info->programmed_link_rate &
1054 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
1055 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
1056 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
1057 break;
1058 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1059 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
1060 break;
1061 default:
1062 break;
1063 }
1064
1065 if (local)
1066 phy->local_attached = 1;
1067
1068 error = sas_phy_add(phy);
1069 if (error) {
1070 sas_phy_free(phy);
1071 return error;
1072 }
1073 phy_info->phy = phy;
1074
1075 if (phy_info->attached.handle) {
1076 struct sas_rphy *rphy;
1077
1078 rphy = sas_rphy_alloc(phy);
1079 if (!rphy)
1080 return 0; /* non-fatal: an rphy can be added later */
1081
1082 mptsas_parse_device_info(&rphy->identify, &phy_info->attached);
1083 error = sas_rphy_add(rphy);
1084 if (error) {
1085 sas_rphy_free(rphy);
1086 return error;
1087 }
1088
1089 phy_info->rphy = rphy;
1090 }
1091
1092 return 0;
1093 }
1094
1095 static int
1096 mptsas_probe_hba_phys(MPT_ADAPTER *ioc, int *index)
1097 {
1098 struct mptsas_portinfo *port_info;
1099 u32 handle = 0xFFFF;
1100 int error = -ENOMEM, i;
1101
1102 port_info = kzalloc(sizeof(*port_info), GFP_KERNEL);
1103 if (!port_info)
1104 goto out;
1105
1106 error = mptsas_sas_io_unit_pg0(ioc, port_info);
1107 if (error)
1108 goto out_free_port_info;
1109
1110 ioc->num_ports = port_info->num_phys;
1111 mutex_lock(&ioc->sas_topology_mutex);
1112 list_add_tail(&port_info->list, &ioc->sas_topology);
1113 mutex_unlock(&ioc->sas_topology_mutex);
1114
1115 for (i = 0; i < port_info->num_phys; i++) {
1116 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
1117 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
1118 MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
1119
1120 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
1121 (MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE <<
1122 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), handle);
1123 port_info->phy_info[i].identify.phy_id =
1124 port_info->phy_info[i].phy_id;
1125 handle = port_info->phy_info[i].identify.handle;
1126
1127 if (port_info->phy_info[i].attached.handle) {
1128 mptsas_sas_device_pg0(ioc,
1129 &port_info->phy_info[i].attached,
1130 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1131 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1132 port_info->phy_info[i].attached.handle);
1133 }
1134
1135 mptsas_probe_one_phy(&ioc->sh->shost_gendev,
1136 &port_info->phy_info[i], *index, 1);
1137 (*index)++;
1138 }
1139
1140 return 0;
1141
1142 out_free_port_info:
1143 kfree(port_info);
1144 out:
1145 return error;
1146 }
1147
1148 static int
1149 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle, int *index)
1150 {
1151 struct mptsas_portinfo *port_info, *p;
1152 int error = -ENOMEM, i, j;
1153
1154 port_info = kzalloc(sizeof(*port_info), GFP_KERNEL);
1155 if (!port_info)
1156 goto out;
1157
1158 error = mptsas_sas_expander_pg0(ioc, port_info,
1159 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
1160 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
1161 if (error)
1162 goto out_free_port_info;
1163
1164 *handle = port_info->handle;
1165
1166 mutex_lock(&ioc->sas_topology_mutex);
1167 list_add_tail(&port_info->list, &ioc->sas_topology);
1168 mutex_unlock(&ioc->sas_topology_mutex);
1169
1170 for (i = 0; i < port_info->num_phys; i++) {
1171 struct device *parent;
1172
1173 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
1174 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
1175 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
1176
1177 if (port_info->phy_info[i].identify.handle) {
1178 mptsas_sas_device_pg0(ioc,
1179 &port_info->phy_info[i].identify,
1180 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1181 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1182 port_info->phy_info[i].identify.handle);
1183 port_info->phy_info[i].identify.phy_id =
1184 port_info->phy_info[i].phy_id;
1185 }
1186
1187 if (port_info->phy_info[i].attached.handle) {
1188 mptsas_sas_device_pg0(ioc,
1189 &port_info->phy_info[i].attached,
1190 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1191 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1192 port_info->phy_info[i].attached.handle);
1193 }
1194
1195 /*
1196 * If we find a parent port handle this expander is
1197 * attached to another expander, else it hangs of the
1198 * HBA phys.
1199 */
1200 parent = &ioc->sh->shost_gendev;
1201 mutex_lock(&ioc->sas_topology_mutex);
1202 list_for_each_entry(p, &ioc->sas_topology, list) {
1203 for (j = 0; j < p->num_phys; j++) {
1204 if (port_info->phy_info[i].identify.handle ==
1205 p->phy_info[j].attached.handle)
1206 parent = &p->phy_info[j].rphy->dev;
1207 }
1208 }
1209 mutex_unlock(&ioc->sas_topology_mutex);
1210
1211 mptsas_probe_one_phy(parent, &port_info->phy_info[i],
1212 *index, 0);
1213 (*index)++;
1214 }
1215
1216 return 0;
1217
1218 out_free_port_info:
1219 kfree(port_info);
1220 out:
1221 return error;
1222 }
1223
1224 static void
1225 mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
1226 {
1227 u32 handle = 0xFFFF;
1228 int index = 0;
1229
1230 mptsas_probe_hba_phys(ioc, &index);
1231 while (!mptsas_probe_expander_phys(ioc, &handle, &index))
1232 ;
1233 }
1234
1235 static struct mptsas_phyinfo *
1236 mptsas_find_phyinfo_by_parent(MPT_ADAPTER *ioc, u16 parent_handle, u8 phy_id)
1237 {
1238 struct mptsas_portinfo *port_info;
1239 struct mptsas_devinfo device_info;
1240 struct mptsas_phyinfo *phy_info = NULL;
1241 int i, error;
1242
1243 /*
1244 * Retrieve the parent sas_address
1245 */
1246 error = mptsas_sas_device_pg0(ioc, &device_info,
1247 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1248 MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1249 parent_handle);
1250 if (error) {
1251 printk("mptsas: failed to retrieve device page\n");
1252 return NULL;
1253 }
1254
1255 /*
1256 * The phy_info structures are never deallocated during lifetime of
1257 * a host, so the code below is safe without additional refcounting.
1258 */
1259 mutex_lock(&ioc->sas_topology_mutex);
1260 list_for_each_entry(port_info, &ioc->sas_topology, list) {
1261 for (i = 0; i < port_info->num_phys; i++) {
1262 if (port_info->phy_info[i].identify.sas_address ==
1263 device_info.sas_address &&
1264 port_info->phy_info[i].phy_id == phy_id) {
1265 phy_info = &port_info->phy_info[i];
1266 break;
1267 }
1268 }
1269 }
1270 mutex_unlock(&ioc->sas_topology_mutex);
1271
1272 return phy_info;
1273 }
1274
1275 static struct mptsas_phyinfo *
1276 mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u32 id)
1277 {
1278 struct mptsas_portinfo *port_info;
1279 struct mptsas_phyinfo *phy_info = NULL;
1280 int i;
1281
1282 /*
1283 * The phy_info structures are never deallocated during lifetime of
1284 * a host, so the code below is safe without additional refcounting.
1285 */
1286 mutex_lock(&ioc->sas_topology_mutex);
1287 list_for_each_entry(port_info, &ioc->sas_topology, list) {
1288 for (i = 0; i < port_info->num_phys; i++)
1289 if (mptsas_is_end_device(&port_info->phy_info[i].attached))
1290 if (port_info->phy_info[i].attached.id == id) {
1291 phy_info = &port_info->phy_info[i];
1292 break;
1293 }
1294 }
1295 mutex_unlock(&ioc->sas_topology_mutex);
1296
1297 return phy_info;
1298 }
1299
1300 static void
1301 mptsas_hotplug_work(void *arg)
1302 {
1303 struct mptsas_hotplug_event *ev = arg;
1304 MPT_ADAPTER *ioc = ev->ioc;
1305 struct mptsas_phyinfo *phy_info;
1306 struct sas_rphy *rphy;
1307 struct scsi_device *sdev;
1308 char *ds = NULL;
1309 struct mptsas_devinfo sas_device;
1310
1311 switch (ev->event_type) {
1312 case MPTSAS_DEL_DEVICE:
1313
1314 phy_info = mptsas_find_phyinfo_by_target(ioc, ev->id);
1315 if (!phy_info) {
1316 printk("mptsas: remove event for non-existant PHY.\n");
1317 break;
1318 }
1319
1320 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1321 ds = "ssp";
1322 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_STP_TARGET)
1323 ds = "stp";
1324 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1325 ds = "sata";
1326
1327 printk(MYIOC_s_INFO_FMT
1328 "removing %s device, channel %d, id %d, phy %d\n",
1329 ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
1330
1331 if (phy_info->rphy) {
1332 sas_rphy_delete(phy_info->rphy);
1333 phy_info->rphy = NULL;
1334 }
1335 break;
1336 case MPTSAS_ADD_DEVICE:
1337
1338 /*
1339 * When there is no sas address,
1340 * RAID volumes are being deleted,
1341 * and hidden phy disk are being added.
1342 * We don't know the SAS data yet,
1343 * so lookup sas device page to get
1344 * pertaining info
1345 */
1346 if (!ev->sas_address) {
1347 if (mptsas_sas_device_pg0(ioc,
1348 &sas_device, ev->id,
1349 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
1350 MPI_SAS_DEVICE_PGAD_FORM_SHIFT)))
1351 break;
1352 ev->handle = sas_device.handle;
1353 ev->parent_handle = sas_device.handle_parent;
1354 ev->channel = sas_device.channel;
1355 ev->phy_id = sas_device.phy_id;
1356 ev->sas_address = sas_device.sas_address;
1357 ev->device_info = sas_device.device_info;
1358 }
1359
1360 phy_info = mptsas_find_phyinfo_by_parent(ioc,
1361 ev->parent_handle, ev->phy_id);
1362 if (!phy_info) {
1363 printk("mptsas: add event for non-existant PHY.\n");
1364 break;
1365 }
1366
1367 if (phy_info->rphy) {
1368 printk("mptsas: trying to add existing device.\n");
1369 break;
1370 }
1371
1372 /* fill attached info */
1373 phy_info->attached.handle = ev->handle;
1374 phy_info->attached.phy_id = ev->phy_id;
1375 phy_info->attached.port_id = phy_info->identify.port_id;
1376 phy_info->attached.id = ev->id;
1377 phy_info->attached.channel = ev->channel;
1378 phy_info->attached.sas_address = ev->sas_address;
1379 phy_info->attached.device_info = ev->device_info;
1380
1381 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1382 ds = "ssp";
1383 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_STP_TARGET)
1384 ds = "stp";
1385 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1386 ds = "sata";
1387
1388 printk(MYIOC_s_INFO_FMT
1389 "attaching %s device, channel %d, id %d, phy %d\n",
1390 ioc->name, ds, ev->channel, ev->id, ev->phy_id);
1391
1392
1393 rphy = sas_rphy_alloc(phy_info->phy);
1394 if (!rphy)
1395 break; /* non-fatal: an rphy can be added later */
1396
1397 rphy->scsi_target_id = phy_info->attached.id;
1398 mptsas_parse_device_info(&rphy->identify, &phy_info->attached);
1399 if (sas_rphy_add(rphy)) {
1400 sas_rphy_free(rphy);
1401 break;
1402 }
1403
1404 phy_info->rphy = rphy;
1405 break;
1406 case MPTSAS_ADD_RAID:
1407 sdev = scsi_device_lookup(
1408 ioc->sh,
1409 ioc->num_ports,
1410 ev->id,
1411 0);
1412 if (sdev) {
1413 scsi_device_put(sdev);
1414 break;
1415 }
1416 printk(MYIOC_s_INFO_FMT
1417 "attaching device, channel %d, id %d\n",
1418 ioc->name, ioc->num_ports, ev->id);
1419 scsi_add_device(ioc->sh,
1420 ioc->num_ports,
1421 ev->id,
1422 0);
1423 mpt_findImVolumes(ioc);
1424 break;
1425 case MPTSAS_DEL_RAID:
1426 sdev = scsi_device_lookup(
1427 ioc->sh,
1428 ioc->num_ports,
1429 ev->id,
1430 0);
1431 if (!sdev)
1432 break;
1433 printk(MYIOC_s_INFO_FMT
1434 "removing device, channel %d, id %d\n",
1435 ioc->name, ioc->num_ports, ev->id);
1436 scsi_remove_device(sdev);
1437 scsi_device_put(sdev);
1438 mpt_findImVolumes(ioc);
1439 break;
1440 }
1441
1442 kfree(ev);
1443 }
1444
1445 static void
1446 mptscsih_send_sas_event(MPT_ADAPTER *ioc,
1447 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
1448 {
1449 struct mptsas_hotplug_event *ev;
1450 u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
1451 __le64 sas_address;
1452
1453 if ((device_info &
1454 (MPI_SAS_DEVICE_INFO_SSP_TARGET |
1455 MPI_SAS_DEVICE_INFO_STP_TARGET |
1456 MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
1457 return;
1458
1459 if ((sas_event_data->ReasonCode &
1460 (MPI_EVENT_SAS_DEV_STAT_RC_ADDED |
1461 MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING)) == 0)
1462 return;
1463
1464 ev = kmalloc(sizeof(*ev), GFP_ATOMIC);
1465 if (!ev) {
1466 printk(KERN_WARNING "mptsas: lost hotplug event\n");
1467 return;
1468 }
1469
1470
1471 INIT_WORK(&ev->work, mptsas_hotplug_work, ev);
1472 ev->ioc = ioc;
1473 ev->handle = le16_to_cpu(sas_event_data->DevHandle);
1474 ev->parent_handle = le16_to_cpu(sas_event_data->ParentDevHandle);
1475 ev->channel = sas_event_data->Bus;
1476 ev->id = sas_event_data->TargetID;
1477 ev->phy_id = sas_event_data->PhyNum;
1478 memcpy(&sas_address, &sas_event_data->SASAddress, sizeof(__le64));
1479 ev->sas_address = le64_to_cpu(sas_address);
1480 ev->device_info = device_info;
1481
1482 if (sas_event_data->ReasonCode & MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
1483 ev->event_type = MPTSAS_ADD_DEVICE;
1484 else
1485 ev->event_type = MPTSAS_DEL_DEVICE;
1486
1487 schedule_work(&ev->work);
1488 }
1489
1490 static void
1491 mptscsih_send_raid_event(MPT_ADAPTER *ioc,
1492 EVENT_DATA_RAID *raid_event_data)
1493 {
1494 struct mptsas_hotplug_event *ev;
1495 RAID_VOL0_STATUS * volumeStatus;
1496
1497 if (ioc->bus_type != SAS)
1498 return;
1499
1500 ev = kmalloc(sizeof(*ev), GFP_ATOMIC);
1501 if (!ev) {
1502 printk(KERN_WARNING "mptsas: lost hotplug event\n");
1503 return;
1504 }
1505
1506 memset(ev,0,sizeof(struct mptsas_hotplug_event));
1507 INIT_WORK(&ev->work, mptsas_hotplug_work, ev);
1508 ev->ioc = ioc;
1509 ev->id = raid_event_data->VolumeID;
1510
1511 switch (raid_event_data->ReasonCode) {
1512 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
1513 ev->event_type = MPTSAS_ADD_DEVICE;
1514 break;
1515 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
1516 ev->event_type = MPTSAS_DEL_DEVICE;
1517 break;
1518 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
1519 ev->event_type = MPTSAS_DEL_RAID;
1520 break;
1521 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
1522 ev->event_type = MPTSAS_ADD_RAID;
1523 break;
1524 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
1525 volumeStatus = (RAID_VOL0_STATUS *) &
1526 raid_event_data->SettingsStatus;
1527 ev->event_type = (volumeStatus->State ==
1528 MPI_RAIDVOL0_STATUS_STATE_FAILED) ?
1529 MPTSAS_DEL_RAID : MPTSAS_ADD_RAID;
1530 break;
1531 default:
1532 break;
1533 }
1534 schedule_work(&ev->work);
1535 }
1536
1537 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1538 /* work queue thread to clear the persitency table */
1539 static void
1540 mptscsih_sas_persist_clear_table(void * arg)
1541 {
1542 MPT_ADAPTER *ioc = (MPT_ADAPTER *)arg;
1543
1544 mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
1545 }
1546
1547 static int
1548 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
1549 {
1550 int rc=1;
1551 u8 event = le32_to_cpu(reply->Event) & 0xFF;
1552
1553 if (!ioc->sh)
1554 goto out;
1555
1556 switch (event) {
1557 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
1558 mptscsih_send_sas_event(ioc,
1559 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
1560 break;
1561 case MPI_EVENT_INTEGRATED_RAID:
1562 mptscsih_send_raid_event(ioc,
1563 (EVENT_DATA_RAID *)reply->Data);
1564 break;
1565 case MPI_EVENT_PERSISTENT_TABLE_FULL:
1566 INIT_WORK(&ioc->mptscsih_persistTask,
1567 mptscsih_sas_persist_clear_table,
1568 (void *)ioc);
1569 schedule_work(&ioc->mptscsih_persistTask);
1570 break;
1571 default:
1572 rc = mptscsih_event_process(ioc, reply);
1573 break;
1574 }
1575 out:
1576
1577 return rc;
1578 }
1579
1580 static int
1581 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1582 {
1583 struct Scsi_Host *sh;
1584 MPT_SCSI_HOST *hd;
1585 MPT_ADAPTER *ioc;
1586 unsigned long flags;
1587 int ii;
1588 int numSGE = 0;
1589 int scale;
1590 int ioc_cap;
1591 int error=0;
1592 int r;
1593
1594 r = mpt_attach(pdev,id);
1595 if (r)
1596 return r;
1597
1598 ioc = pci_get_drvdata(pdev);
1599 ioc->DoneCtx = mptsasDoneCtx;
1600 ioc->TaskCtx = mptsasTaskCtx;
1601 ioc->InternalCtx = mptsasInternalCtx;
1602
1603 /* Added sanity check on readiness of the MPT adapter.
1604 */
1605 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1606 printk(MYIOC_s_WARN_FMT
1607 "Skipping because it's not operational!\n",
1608 ioc->name);
1609 error = -ENODEV;
1610 goto out_mptsas_probe;
1611 }
1612
1613 if (!ioc->active) {
1614 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1615 ioc->name);
1616 error = -ENODEV;
1617 goto out_mptsas_probe;
1618 }
1619
1620 /* Sanity check - ensure at least 1 port is INITIATOR capable
1621 */
1622 ioc_cap = 0;
1623 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) {
1624 if (ioc->pfacts[ii].ProtocolFlags &
1625 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1626 ioc_cap++;
1627 }
1628
1629 if (!ioc_cap) {
1630 printk(MYIOC_s_WARN_FMT
1631 "Skipping ioc=%p because SCSI Initiator mode "
1632 "is NOT enabled!\n", ioc->name, ioc);
1633 return 0;
1634 }
1635
1636 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST));
1637 if (!sh) {
1638 printk(MYIOC_s_WARN_FMT
1639 "Unable to register controller with SCSI subsystem\n",
1640 ioc->name);
1641 error = -1;
1642 goto out_mptsas_probe;
1643 }
1644
1645 spin_lock_irqsave(&ioc->FreeQlock, flags);
1646
1647 /* Attach the SCSI Host to the IOC structure
1648 */
1649 ioc->sh = sh;
1650
1651 sh->io_port = 0;
1652 sh->n_io_port = 0;
1653 sh->irq = 0;
1654
1655 /* set 16 byte cdb's */
1656 sh->max_cmd_len = 16;
1657
1658 sh->max_id = ioc->pfacts->MaxDevices + 1;
1659
1660 sh->transportt = mptsas_transport_template;
1661
1662 sh->max_lun = MPT_LAST_LUN + 1;
1663 sh->max_channel = 0;
1664 sh->this_id = ioc->pfacts[0].PortSCSIID;
1665
1666 /* Required entry.
1667 */
1668 sh->unique_id = ioc->id;
1669
1670 INIT_LIST_HEAD(&ioc->sas_topology);
1671 mutex_init(&ioc->sas_topology_mutex);
1672
1673 mutex_init(&ioc->sas_mgmt.mutex);
1674 init_completion(&ioc->sas_mgmt.done);
1675
1676 /* Verify that we won't exceed the maximum
1677 * number of chain buffers
1678 * We can optimize: ZZ = req_sz/sizeof(SGE)
1679 * For 32bit SGE's:
1680 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1681 * + (req_sz - 64)/sizeof(SGE)
1682 * A slightly different algorithm is required for
1683 * 64bit SGEs.
1684 */
1685 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1686 if (sizeof(dma_addr_t) == sizeof(u64)) {
1687 numSGE = (scale - 1) *
1688 (ioc->facts.MaxChainDepth-1) + scale +
1689 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1690 sizeof(u32));
1691 } else {
1692 numSGE = 1 + (scale - 1) *
1693 (ioc->facts.MaxChainDepth-1) + scale +
1694 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1695 sizeof(u32));
1696 }
1697
1698 if (numSGE < sh->sg_tablesize) {
1699 /* Reset this value */
1700 dprintk((MYIOC_s_INFO_FMT
1701 "Resetting sg_tablesize to %d from %d\n",
1702 ioc->name, numSGE, sh->sg_tablesize));
1703 sh->sg_tablesize = numSGE;
1704 }
1705
1706 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1707
1708 hd = (MPT_SCSI_HOST *) sh->hostdata;
1709 hd->ioc = ioc;
1710
1711 /* SCSI needs scsi_cmnd lookup table!
1712 * (with size equal to req_depth*PtrSz!)
1713 */
1714 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1715 if (!hd->ScsiLookup) {
1716 error = -ENOMEM;
1717 goto out_mptsas_probe;
1718 }
1719
1720 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1721 ioc->name, hd->ScsiLookup));
1722
1723 /* Allocate memory for the device structures.
1724 * A non-Null pointer at an offset
1725 * indicates a device exists.
1726 * max_id = 1 + maximum id (hosts.h)
1727 */
1728 hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
1729 if (!hd->Targets) {
1730 error = -ENOMEM;
1731 goto out_mptsas_probe;
1732 }
1733
1734 dprintk((KERN_INFO " vtarget @ %p\n", hd->Targets));
1735
1736 /* Clear the TM flags
1737 */
1738 hd->tmPending = 0;
1739 hd->tmState = TM_STATE_NONE;
1740 hd->resetPending = 0;
1741 hd->abortSCpnt = NULL;
1742
1743 /* Clear the pointer used to store
1744 * single-threaded commands, i.e., those
1745 * issued during a bus scan, dv and
1746 * configuration pages.
1747 */
1748 hd->cmdPtr = NULL;
1749
1750 /* Initialize this SCSI Hosts' timers
1751 * To use, set the timer expires field
1752 * and add_timer
1753 */
1754 init_timer(&hd->timer);
1755 hd->timer.data = (unsigned long) hd;
1756 hd->timer.function = mptscsih_timer_expired;
1757
1758 hd->mpt_pq_filter = mpt_pq_filter;
1759 ioc->sas_data.ptClear = mpt_pt_clear;
1760
1761 if (ioc->sas_data.ptClear==1) {
1762 mptbase_sas_persist_operation(
1763 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT);
1764 }
1765
1766 ddvprintk((MYIOC_s_INFO_FMT
1767 "mpt_pq_filter %x mpt_pq_filter %x\n",
1768 ioc->name,
1769 mpt_pq_filter,
1770 mpt_pq_filter));
1771
1772 init_waitqueue_head(&hd->scandv_waitq);
1773 hd->scandv_wait_done = 0;
1774 hd->last_queue_full = 0;
1775
1776 error = scsi_add_host(sh, &ioc->pcidev->dev);
1777 if (error) {
1778 dprintk((KERN_ERR MYNAM
1779 "scsi_add_host failed\n"));
1780 goto out_mptsas_probe;
1781 }
1782
1783 mptsas_scan_sas_topology(ioc);
1784
1785 /*
1786 Reporting RAID volumes.
1787 */
1788 if (!ioc->raid_data.pIocPg2)
1789 return 0;
1790 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
1791 return 0;
1792 for (ii=0;ii<ioc->raid_data.pIocPg2->NumActiveVolumes;ii++) {
1793 scsi_add_device(sh,
1794 ioc->num_ports,
1795 ioc->raid_data.pIocPg2->RaidVolume[ii].VolumeID,
1796 0);
1797 }
1798
1799 return 0;
1800
1801 out_mptsas_probe:
1802
1803 mptscsih_remove(pdev);
1804 return error;
1805 }
1806
1807 static void __devexit mptsas_remove(struct pci_dev *pdev)
1808 {
1809 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1810 struct mptsas_portinfo *p, *n;
1811
1812 sas_remove_host(ioc->sh);
1813
1814 mutex_lock(&ioc->sas_topology_mutex);
1815 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) {
1816 list_del(&p->list);
1817 kfree(p);
1818 }
1819 mutex_unlock(&ioc->sas_topology_mutex);
1820
1821 mptscsih_remove(pdev);
1822 }
1823
1824 static struct pci_device_id mptsas_pci_table[] = {
1825 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064,
1826 PCI_ANY_ID, PCI_ANY_ID },
1827 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1066,
1828 PCI_ANY_ID, PCI_ANY_ID },
1829 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1068,
1830 PCI_ANY_ID, PCI_ANY_ID },
1831 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064E,
1832 PCI_ANY_ID, PCI_ANY_ID },
1833 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1066E,
1834 PCI_ANY_ID, PCI_ANY_ID },
1835 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1068E,
1836 PCI_ANY_ID, PCI_ANY_ID },
1837 {0} /* Terminating entry */
1838 };
1839 MODULE_DEVICE_TABLE(pci, mptsas_pci_table);
1840
1841
1842 static struct pci_driver mptsas_driver = {
1843 .name = "mptsas",
1844 .id_table = mptsas_pci_table,
1845 .probe = mptsas_probe,
1846 .remove = __devexit_p(mptsas_remove),
1847 .shutdown = mptscsih_shutdown,
1848 #ifdef CONFIG_PM
1849 .suspend = mptscsih_suspend,
1850 .resume = mptscsih_resume,
1851 #endif
1852 };
1853
1854 static int __init
1855 mptsas_init(void)
1856 {
1857 show_mptmod_ver(my_NAME, my_VERSION);
1858
1859 mptsas_transport_template =
1860 sas_attach_transport(&mptsas_transport_functions);
1861 if (!mptsas_transport_template)
1862 return -ENODEV;
1863
1864 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
1865 mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER);
1866 mptsasInternalCtx =
1867 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
1868 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
1869
1870 if (mpt_event_register(mptsasDoneCtx, mptsas_event_process) == 0) {
1871 devtprintk((KERN_INFO MYNAM
1872 ": Registered for IOC event notifications\n"));
1873 }
1874
1875 if (mpt_reset_register(mptsasDoneCtx, mptscsih_ioc_reset) == 0) {
1876 dprintk((KERN_INFO MYNAM
1877 ": Registered for IOC reset notifications\n"));
1878 }
1879
1880 return pci_register_driver(&mptsas_driver);
1881 }
1882
1883 static void __exit
1884 mptsas_exit(void)
1885 {
1886 pci_unregister_driver(&mptsas_driver);
1887 sas_release_transport(mptsas_transport_template);
1888
1889 mpt_reset_deregister(mptsasDoneCtx);
1890 mpt_event_deregister(mptsasDoneCtx);
1891
1892 mpt_deregister(mptsasMgmtCtx);
1893 mpt_deregister(mptsasInternalCtx);
1894 mpt_deregister(mptsasTaskCtx);
1895 mpt_deregister(mptsasDoneCtx);
1896 }
1897
1898 module_init(mptsas_init);
1899 module_exit(mptsas_exit);
CJK support for tty framebuffer vt