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