]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blob - src/patches/suse-2.6.27.31/patches.drivers/mpt-fusion-4.00.43.00-update
projects / people / pmueller / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Disable build of xen kernel.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.drivers / mpt-fusion-4.00.43.00-update
1 Subject: Update MPT Fusion driver to v4.00.43.00
2 From: Hannes Reinecke <hare@suse.de>
3 Date: Tue Sep 30 13:38:53 2008 +0200:
4 Git: a958ec0d1685af04282982f2e53b66c947fc7426
5
6 References: bnc#425660
7
8 This patch updates the MPT fusion drivers to v4.00.43.00.
9
10 Signed-off-by: Sathya Prakash <Sathya.Prakash@lsi.com>
11 Signed-off-by: Hannes Reinecke <hare@suse.de>
12
13 ---
14 drivers/message/fusion/Kconfig | 16
15 drivers/message/fusion/Makefile | 13
16 drivers/message/fusion/csmi/csmisas.c | 5888 ++++++++++++++++++
17 drivers/message/fusion/csmi/csmisas.h | 1854 +++++
18 drivers/message/fusion/lsi/mpi.h | 7
19 drivers/message/fusion/lsi/mpi_cnfg.h | 47
20 drivers/message/fusion/lsi/mpi_fc.h | 2
21 drivers/message/fusion/lsi/mpi_history.txt | 86
22 drivers/message/fusion/lsi/mpi_init.h | 2
23 drivers/message/fusion/lsi/mpi_ioc.h | 22
24 drivers/message/fusion/lsi/mpi_lan.h | 2
25 drivers/message/fusion/lsi/mpi_log_fc.h | 2
26 drivers/message/fusion/lsi/mpi_log_sas.h | 31
27 drivers/message/fusion/lsi/mpi_raid.h | 11
28 drivers/message/fusion/lsi/mpi_sas.h | 18
29 drivers/message/fusion/lsi/mpi_targ.h | 2
30 drivers/message/fusion/lsi/mpi_tool.h | 2
31 drivers/message/fusion/lsi/mpi_type.h | 19
32 drivers/message/fusion/mptbase.c | 2700 +++++---
33 drivers/message/fusion/mptbase.h | 291
34 drivers/message/fusion/mptctl.c | 1020 +--
35 drivers/message/fusion/mptctl.h | 5
36 drivers/message/fusion/mptdebug.h | 12
37 drivers/message/fusion/mptfc.c | 189
38 drivers/message/fusion/mptlan.c | 56
39 drivers/message/fusion/mptlan.h | 3
40 drivers/message/fusion/mptsas.c | 5921 ++++++++++++-------
41 drivers/message/fusion/mptsas.h | 71
42 drivers/message/fusion/mptscsih.c | 2252 +++----
43 drivers/message/fusion/mptscsih.h | 13
44 drivers/message/fusion/mptspi.c | 265
45 drivers/message/fusion/rejected_ioctls/diag_buffer.c | 667 ++
46 drivers/message/fusion/rejected_ioctls/diag_buffer.h | 101
47 33 files changed, 16615 insertions(+), 4975 deletions(-)
48
49 --- /dev/null
50 +++ b/drivers/message/fusion/csmi/csmisas.c
51 @@ -0,0 +1,5888 @@
52 +/*
53 + * linux/drivers/message/fusion/csmi/csmisas.c
54 + * For use with LSI PCI chip/adapter(s)
55 + * running LSI Fusion MPT (Message Passing Technology) firmware.
56 + *
57 + * Copyright (c) 1999-2008 LSI Corporation
58 + * (mailto:DL-MPTFusionLinux@lsi.com)
59 + */
60 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
61 +/*
62 + This program is free software; you can redistribute it and/or modify
63 + it under the terms of the GNU General Public License as published by
64 + the Free Software Foundation; version 2 of the License.
65 +
66 + This program is distributed in the hope that it will be useful,
67 + but WITHOUT ANY WARRANTY; without even the implied warranty of
68 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
69 + GNU General Public License for more details.
70 +
71 + NO WARRANTY
72 + THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
73 + CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
74 + LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
75 + MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
76 + solely responsible for determining the appropriateness of using and
77 + distributing the Program and assumes all risks associated with its
78 + exercise of rights under this Agreement, including but not limited to
79 + the risks and costs of program errors, damage to or loss of data,
80 + programs or equipment, and unavailability or interruption of operations.
81 +
82 + DISCLAIMER OF LIABILITY
83 + NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
84 + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
85 + DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
86 + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
87 + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
88 + USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
89 + HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
90 +
91 + You should have received a copy of the GNU General Public License
92 + along with this program; if not, write to the Free Software
93 + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
94 +*/
95 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
96 +
97 +#define MPT_CSMI_DESCRIPTION "LSI Corporation: Fusion MPT Driver "MPT_LINUX_VERSION_COMMON
98 +#define csmisas_is_this_sas_cntr(ioc) (ioc->bus_type == SAS) ? 1 : 0
99 +
100 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
101 +#define __user
102 +#include <asm/div64.h>
103 +#endif
104 +
105 +static int csmisas_do_raid(MPT_ADAPTER *ioc, u8 action, u8 PhysDiskNum, u8 VolumeBus,
106 + u8 VolumeId, pMpiRaidActionReply_t reply);
107 +static u8 map_sas_status_to_csmi(u8 mpi_sas_status);
108 +
109 +/**
110 + * reverse_byte_order64
111 + *
112 + * @data64
113 + *
114 + **/
115 +static u64
116 +reverse_byte_order64(u64 data64)
117 +{
118 + int i;
119 + u64 rc;
120 + u8 *inWord = (u8*)&data64, *outWord = (u8*)&rc;
121 +
122 + for (i = 0 ; i < 8 ; i++)
123 + outWord[i] = inWord[7-i];
124 +
125 + return rc;
126 +}
127 +
128 +/**
129 + * csmisas_is_sata
130 + *
131 + * @phys_disk
132 + *
133 + **/
134 +static int
135 +csmisas_is_sata(RaidPhysDiskPage0_t *phys_disk)
136 +{
137 + if ((phys_disk->ExtDiskIdentifier[0] == 'A') &&
138 + (phys_disk->ExtDiskIdentifier[1] == 'T') &&
139 + (phys_disk->ExtDiskIdentifier[2] == 'A'))
140 + return 1;
141 + else
142 + return 0;
143 +}
144 +
145 +/**
146 + * csmisas_is_end_device
147 + *
148 + * @attached
149 + *
150 + **/
151 +static inline int
152 +csmisas_is_end_device(struct mptsas_devinfo * attached)
153 +{
154 + if ((attached->sas_address) &&
155 + (attached->device_info &
156 + MPI_SAS_DEVICE_INFO_END_DEVICE) &&
157 + ((attached->device_info &
158 + MPI_SAS_DEVICE_INFO_SSP_TARGET) |
159 + (attached->device_info &
160 + MPI_SAS_DEVICE_INFO_STP_TARGET) |
161 + (attached->device_info &
162 + MPI_SAS_DEVICE_INFO_SATA_DEVICE)))
163 + return 1;
164 + else
165 + return 0;
166 +}
167 +
168 +/**
169 + * csmisas_is_phys_disk
170 + *
171 + * returns (1) success (0) fail - not a phys disk
172 + **/
173 +static int
174 +csmisas_is_phys_disk(MPT_ADAPTER *ioc, int channel, int id)
175 +{
176 + struct inactive_raid_component_info *component_info;
177 + int i;
178 + int rc = 0;
179 +
180 + if (!ioc->raid_data.pIocPg3)
181 + goto out;
182 + for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
183 + if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
184 + (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
185 + rc = 1;
186 + goto out;
187 + }
188 + }
189 +
190 + /*
191 + * Check inactive list for matching phys disks
192 + */
193 + if (list_empty(&ioc->raid_data.inactive_list))
194 + goto out;
195 +
196 + down(&ioc->raid_data.inactive_list_mutex);
197 + list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
198 + list) {
199 + if ((component_info->d.PhysDiskID == id) &&
200 + (component_info->d.PhysDiskBus == channel))
201 + rc = 1;
202 + }
203 + up(&ioc->raid_data.inactive_list_mutex);
204 +
205 + out:
206 + return rc;
207 +}
208 +
209 +/**
210 + * csmisas_raid_id_to_num
211 + *
212 + * Obtains the phys disk num for given H:C:T nexus
213 + *
214 + * input (channel/id)
215 + * output (phys disk number - used by SCSI_IO_PASSTHRU to access hidden component)
216 + *
217 + * returns - signed return means failure
218 + **/
219 +static s8
220 +csmisas_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
221 +{
222 + struct inactive_raid_component_info *component_info;
223 + int i;
224 + s8 rc = -ENXIO;
225 +
226 + if (!ioc->raid_data.pIocPg3)
227 + goto out;
228 + for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
229 + if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
230 + (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
231 + rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
232 + goto out;
233 + }
234 + }
235 +
236 + /*
237 + * Check inactive list for matching phys disks
238 + */
239 + if (list_empty(&ioc->raid_data.inactive_list))
240 + goto out;
241 +
242 + down(&ioc->raid_data.inactive_list_mutex);
243 + list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
244 + list) {
245 + if ((component_info->d.PhysDiskID == id) &&
246 + (component_info->d.PhysDiskBus == channel))
247 + rc = component_info->d.PhysDiskNum;
248 + }
249 + up(&ioc->raid_data.inactive_list_mutex);
250 +
251 + out:
252 + return rc;
253 +}
254 +
255 +/**
256 + * csmisas_get_device_component_by_os
257 + *
258 + * Obtain device component object by operating system mapping
259 + *
260 + * @ioc
261 + * @channel
262 + * @id
263 + *
264 + **/
265 +static struct sas_device_info *
266 +csmisas_get_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
267 +{
268 + struct sas_device_info *sas_info, *p;
269 +
270 + sas_info = NULL;
271 +
272 + down(&ioc->sas_device_info_mutex);
273 + list_for_each_entry(p, &ioc->sas_device_info_list, list) {
274 + if (p->os.channel == channel && p->os.id == id) {
275 + sas_info = p;
276 + goto out;
277 + }
278 + }
279 +
280 + out:
281 + up(&ioc->sas_device_info_mutex);
282 + return sas_info;
283 +}
284 +
285 +/**
286 + * csmisas_get_device_component
287 + *
288 + * Obtain device component object by firmware system mapping
289 + *
290 + * @ioc
291 + * @channel
292 + * @id
293 + *
294 + **/
295 +static struct sas_device_info *
296 +csmisas_get_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
297 +{
298 + struct sas_device_info *sas_info, *p;
299 +
300 + sas_info = NULL;
301 +
302 + down(&ioc->sas_device_info_mutex);
303 + list_for_each_entry(p, &ioc->sas_device_info_list, list) {
304 + if (p->fw.channel == channel && p->fw.id == id) {
305 + sas_info = p;
306 + goto out;
307 + }
308 + }
309 +
310 + out:
311 + up(&ioc->sas_device_info_mutex);
312 + return sas_info;
313 +}
314 +
315 +
316 +/**
317 + * csmisas_get_device_component_by_sas_addr
318 + *
319 + * Obtain device component object by sas address
320 + *
321 + * @ioc
322 + * @channel
323 + * @id
324 + *
325 + **/
326 +static struct sas_device_info *
327 +csmisas_get_device_component_by_sas_addr(MPT_ADAPTER *ioc, u64 sas_address)
328 +{
329 + struct sas_device_info *sas_info, *p;
330 +
331 + sas_info = NULL;
332 +
333 + down(&ioc->sas_device_info_mutex);
334 + list_for_each_entry(p, &ioc->sas_device_info_list, list) {
335 + if (p->sas_address == sas_address) {
336 + sas_info = p;
337 + goto out;
338 + }
339 + }
340 +
341 + out:
342 + up(&ioc->sas_device_info_mutex);
343 + return sas_info;
344 +}
345 +
346 +/**
347 + * csmisas_send_command_wait
348 + *
349 + * Send mf to firmware
350 + *
351 + * @ioc
352 + * @mf
353 + * @timeout - timeout
354 + *
355 + * Return: 0 for success
356 + * non-zero, failure
357 + **/
358 +static int
359 +csmisas_send_command_wait(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, unsigned long timeout)
360 +{
361 + int rc;
362 + unsigned long timeleft;
363 +
364 + timeout = max_t(unsigned long, MPT_IOCTL_DEFAULT_TIMEOUT, timeout);
365 + rc = 0;
366 + timeleft = 0;
367 +
368 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
369 +
370 + INITIALIZE_IOCTL_STATUS(ioc->ioctl_cmds.status)
371 + ioc->ioctl_cmds.wait_done = 0;
372 + ioc->ioctl_cmds.timer.expires = jiffies + (MPT_JIFFY * timeout);
373 + ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_TIMER_ACTIVE;
374 + ADD_TIMER(&ioc->ioctl_cmds.timer);
375 + mpt_put_msg_frame(mptctl_id, ioc, mf);
376 + WAIT_EVENT(mptctl_wait, ioc->ioctl_cmds.wait_done);
377 +
378 +#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
379 +
380 + INITIALIZE_IOCTL_STATUS(ioc->ioctl_cmds.status)
381 + ioc->ioctl_cmds.wait_done = 0;
382 + mpt_put_msg_frame(mptctl_id, ioc, mf);
383 +
384 + if ((wait_event_timeout(mptctl_wait,
385 + ioc->ioctl_cmds.wait_done == 1, HZ * timeout) <=0) &&
386 + ioc->ioctl_cmds.wait_done != 1 ) {
387 + mptctl_timeout_expired(ioc,mf);
388 + mpt_free_msg_frame(ioc, mf);
389 + rc = -1;
390 + }
391 +
392 +#else
393 +
394 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
395 + mf->u.hdr.MsgContext);
396 + INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
397 + mpt_put_msg_frame(mptctl_id, ioc, mf);
398 + timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done, timeout*HZ);
399 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
400 + rc = -1;
401 + printk("%s: failed\n", __FUNCTION__);
402 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
403 + mpt_free_msg_frame(ioc, mf);
404 + CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
405 + return rc;
406 + }
407 + if (!timeleft)
408 + mptctl_timeout_expired(ioc, mf);
409 + }
410 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
411 +#endif
412 + return rc;
413 +}
414 +
415 +/**
416 + * csmisas_send_handshake_wait
417 + *
418 + * Handshake a mf to firmware
419 + *
420 + * @ioc
421 + * @mf
422 + * @mf_size
423 + * @timeout - timeout
424 + *
425 + * Return: 0 for success
426 + * non-zero, failure
427 + **/
428 +static int
429 +csmisas_send_handshake_wait(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, unsigned long timeout)
430 +{
431 + int rc;
432 + unsigned long timeleft;
433 +
434 + timeout = max_t(unsigned long, MPT_IOCTL_DEFAULT_TIMEOUT, timeout);
435 + rc = 0;
436 + timeleft = 0;
437 +
438 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
439 +
440 + INITIALIZE_IOCTL_STATUS(ioc->taskmgmt_cmds.status)
441 + ioc->taskmgmt_cmds.timer.expires = jiffies + (MPT_JIFFY*timeout);
442 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_TIMER_ACTIVE;
443 + ioc->taskmgmt_cmds.wait_done = 0;
444 + ADD_TIMER(&ioc->taskmgmt_cmds.timer);
445 + rc = mpt_send_special_message(mptctl_taskmgmt_id, ioc,
446 + sizeof(SCSITaskMgmt_t), (u32*)mf, timeout, CAN_SLEEP);
447 + if (rc != 0)
448 + return rc;
449 + WAIT_EVENT(mptctl_taskmgmt_wait, ioc->taskmgmt_cmds.wait_done);
450 +
451 +#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
452 +
453 + INITIALIZE_IOCTL_STATUS(ioc->taskmgmt_cmds.status)
454 + ioc->taskmgmt_cmds.wait_done = 0;
455 + rc = mpt_send_special_message(mptctl_taskmgmt_id, ioc,
456 + sizeof(SCSITaskMgmt_t), (u32*)mf, timeout, CAN_SLEEP);
457 + if (rc != 0)
458 + return rc;
459 + if ((wait_event_timeout(mptctl_taskmgmt_wait,
460 + ioc->taskmgmt_cmds.wait_done == 1, HZ * timeout) <=0) &&
461 + ioc->taskmgmt_cmds.wait_done != 1 ) {
462 + mptctl_timeout_expired(ioc, mf);
463 + mpt_free_msg_frame(ioc, mf);
464 + rc = -1;
465 + }
466 +
467 +#else
468 + INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
469 + mpt_put_msg_frame_hi_pri(mptctl_taskmgmt_id, ioc, mf);
470 + timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
471 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
472 + rc = -1;
473 + printk("%s: failed\n", __FUNCTION__);
474 + mpt_clear_taskmgmt_in_progress_flag(ioc);
475 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
476 + mpt_free_msg_frame(ioc, mf);
477 + CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
478 + return rc;
479 + }
480 + if (!timeleft)
481 + mptctl_timeout_expired(ioc, mf);
482 + }
483 +#endif
484 + return rc;
485 +}
486 +
487 +/**
488 + * csmisas_get_number_hotspares - returns num hot spares in this ioc
489 + * @ioc: Pointer to MPT_ADAPTER structure
490 + *
491 + * Return: number of hotspares
492 + *
493 + **/
494 +static int
495 +csmisas_get_number_hotspares(MPT_ADAPTER *ioc)
496 +{
497 + ConfigPageHeader_t hdr;
498 + CONFIGPARMS cfg;
499 + IOCPage5_t *buffer = NULL;
500 + dma_addr_t dma_handle;
501 + int data_sz;
502 + int rc;
503 +
504 + memset(&hdr, 0, sizeof(ConfigPageHeader_t));
505 + memset(&cfg, 0, sizeof(CONFIGPARMS));
506 +
507 + rc = 0;
508 + data_sz = 0;
509 + hdr.PageNumber = 5;
510 + hdr.PageType = MPI_CONFIG_PAGETYPE_IOC;
511 + cfg.cfghdr.hdr = &hdr;
512 + cfg.physAddr = -1;
513 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
514 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
515 +
516 + if (mpt_config(ioc, &cfg) != 0)
517 + goto get_ioc_pg5;
518 +
519 + if (hdr.PageLength == 0)
520 + goto get_ioc_pg5;
521 +
522 + data_sz = hdr.PageLength * 4;
523 + buffer = (IOCPage5_t *) pci_alloc_consistent(ioc->pcidev,
524 + data_sz, &dma_handle);
525 + if (!buffer)
526 + goto get_ioc_pg5;
527 +
528 + memset((u8 *)buffer, 0, data_sz);
529 + cfg.physAddr = dma_handle;
530 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
531 +
532 + if (mpt_config(ioc, &cfg) != 0)
533 + goto get_ioc_pg5;
534 +
535 + rc = buffer->NumHotSpares;
536 +
537 + get_ioc_pg5:
538 +
539 + if (buffer)
540 + pci_free_consistent(ioc->pcidev, data_sz,
541 + (u8 *) buffer, dma_handle);
542 +
543 + return rc;
544 +}
545 +
546 +
547 +/**
548 + * csmisas_get_ioc_pg5 - ioc Page 5 hot spares
549 + * @ioc: Pointer to MPT_ADAPTER structure
550 + * @pIocPage5: ioc page 5
551 + * @data_size: expected data size(units=bytes)
552 + *
553 + * Return: 0 for success
554 + * -ENOMEM if no memory available
555 + * -EPERM if not allowed due to ISR context
556 + * -EAGAIN if no msg frames currently available
557 + * -EFAULT for non-successful reply or no reply (timeout)
558 + **/
559 +static int
560 +csmisas_get_ioc_pg5(MPT_ADAPTER *ioc, IOCPage5_t *iocPage5, int data_size)
561 +{
562 + ConfigPageHeader_t hdr;
563 + CONFIGPARMS cfg;
564 + IOCPage5_t *buffer = NULL;
565 + dma_addr_t dma_handle;
566 + int data_sz;
567 + int rc;
568 +
569 + memset(&hdr, 0, sizeof(ConfigPageHeader_t));
570 + memset(&cfg, 0, sizeof(CONFIGPARMS));
571 +
572 + rc = 0;
573 + data_sz = 0;
574 + hdr.PageNumber = 5;
575 + hdr.PageType = MPI_CONFIG_PAGETYPE_IOC;
576 + cfg.cfghdr.hdr = &hdr;
577 + cfg.physAddr = -1;
578 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
579 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
580 +
581 + if ((rc = mpt_config(ioc, &cfg)) != 0)
582 + goto get_ioc_pg5;
583 +
584 + if (hdr.PageLength == 0) {
585 + rc = -EFAULT;
586 + goto get_ioc_pg5;
587 + }
588 +
589 + data_sz = hdr.PageLength * 4;
590 + buffer = (IOCPage5_t *) pci_alloc_consistent(ioc->pcidev,
591 + data_sz, &dma_handle);
592 + if (!buffer) {
593 + rc = -ENOMEM;
594 + goto get_ioc_pg5;
595 + }
596 +
597 + memset((u8 *)buffer, 0, data_sz);
598 + cfg.physAddr = dma_handle;
599 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
600 +
601 + if ((rc = mpt_config(ioc, &cfg)) != 0)
602 + goto get_ioc_pg5;
603 +
604 + memcpy(iocPage5, buffer, data_size);
605 +
606 + get_ioc_pg5:
607 +
608 + if (buffer)
609 + pci_free_consistent(ioc->pcidev, data_sz,
610 + (u8 *) buffer, dma_handle);
611 +
612 + return rc;
613 +}
614 +
615 +/**
616 + * csmisas_sas_device_pg0 - sas device page 0
617 + * @ioc: Pointer to MPT_ADAPTER structure
618 + * @mptsas_devinfo: structure found in mptsas.h
619 + * @form, @form_specific - defines the Page Address field in the config page
620 + * (pls refer to chapter 5.1 in the mpi spec)
621 + *
622 + * Return: 0 for success
623 + * -ENOMEM if no memory available
624 + * -EPERM if not allowed due to ISR context
625 + * -EAGAIN if no msg frames currently available
626 + * -EFAULT for non-successful reply or no reply (timeout)
627 + **/
628 +static int
629 +csmisas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
630 + u32 form, u32 form_specific)
631 +{
632 + ConfigExtendedPageHeader_t hdr;
633 + CONFIGPARMS cfg;
634 + SasDevicePage0_t *buffer;
635 + dma_addr_t dma_handle;
636 + u64 sas_address;
637 + int rc;
638 +
639 + rc = 0;
640 + hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
641 + hdr.ExtPageLength = 0;
642 + hdr.PageNumber = 0;
643 + hdr.Reserved1 = 0;
644 + hdr.Reserved2 = 0;
645 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
646 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
647 +
648 + cfg.cfghdr.ehdr = &hdr;
649 + cfg.pageAddr = form + form_specific;
650 + cfg.physAddr = -1;
651 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
652 + cfg.dir = 0; /* read */
653 + cfg.timeout = 10;
654 +
655 + memset(device_info, 0, sizeof(struct mptsas_devinfo));
656 + if ((rc = mpt_config(ioc, &cfg)) != 0)
657 + goto out;
658 +
659 + if (!hdr.ExtPageLength) {
660 + rc = -ENXIO;
661 + goto out;
662 + }
663 +
664 + buffer = pci_alloc_consistent(ioc->pcidev,
665 + hdr.ExtPageLength * 4, &dma_handle);
666 + if (!buffer) {
667 + rc = -ENOMEM;
668 + goto out;
669 + }
670 +
671 + cfg.physAddr = dma_handle;
672 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
673 +
674 + if ((rc = mpt_config(ioc, &cfg)) != 0)
675 + goto out_free_consistent;
676 +
677 + device_info->handle = le16_to_cpu(buffer->DevHandle);
678 + device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
679 + device_info->handle_enclosure =
680 + le16_to_cpu(buffer->EnclosureHandle);
681 + device_info->slot = le16_to_cpu(buffer->Slot);
682 + device_info->phy_id = buffer->PhyNum;
683 + device_info->port_id = buffer->PhysicalPort;
684 + device_info->id = buffer->TargetID;
685 + device_info->channel = buffer->Bus;
686 + memcpy(&sas_address, &buffer->SASAddress, sizeof(u64));
687 + device_info->sas_address = le64_to_cpu(sas_address);
688 + device_info->device_info =
689 + le32_to_cpu(buffer->DeviceInfo);
690 +
691 + out_free_consistent:
692 + pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
693 + buffer, dma_handle);
694 + out:
695 + return rc;
696 +}
697 +
698 +/**
699 + * Routine for the CSMI Sas Get Driver Info command.
700 + *
701 + * Outputs: None.
702 + * Return: 0 if successful
703 + * -EFAULT if data unavailable
704 + * -ENODEV if no such device/adapter
705 + **/
706 +static int
707 +csmisas_get_driver_info(unsigned long arg)
708 +{
709 +
710 + CSMI_SAS_DRIVER_INFO_BUFFER __user *uarg = (void __user *) arg;
711 + CSMI_SAS_DRIVER_INFO_BUFFER karg;
712 + MPT_ADAPTER *ioc = NULL;
713 + int iocnum;
714 +
715 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_DRIVER_INFO_BUFFER))) {
716 + printk(KERN_ERR "%s@%d::%s - "
717 + "Unable to read in csmi_sas_get_driver_info_buffer struct @ %p\n",
718 + __FILE__, __LINE__, __FUNCTION__, uarg);
719 + return -EFAULT;
720 + }
721 +
722 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
723 + &ioc)) < 0) || (ioc == NULL)) {
724 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
725 + __FILE__, __FUNCTION__, __LINE__, iocnum);
726 + return -ENODEV;
727 + }
728 +
729 + if (!csmisas_is_this_sas_cntr(ioc)) {
730 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
731 + __FILE__, __FUNCTION__, __LINE__, iocnum);
732 + return -ENODEV;
733 + }
734 +
735 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
736 +
737 + /* Fill in the data and return the structure to the calling
738 + * program
739 + */
740 + memcpy( karg.Information.szName, MPT_MISCDEV_BASENAME,
741 + sizeof(MPT_MISCDEV_BASENAME));
742 + memcpy( karg.Information.szDescription, MPT_CSMI_DESCRIPTION,
743 + sizeof(MPT_CSMI_DESCRIPTION));
744 +
745 + karg.Information.usMajorRevision = MPT_LINUX_MAJOR_VERSION;
746 + karg.Information.usMinorRevision = MPT_LINUX_MINOR_VERSION;
747 + karg.Information.usBuildRevision = MPT_LINUX_BUILD_VERSION;
748 + karg.Information.usReleaseRevision = MPT_LINUX_RELEASE_VERSION;
749 +
750 + karg.Information.usCSMIMajorRevision = CSMI_MAJOR_REVISION;
751 + karg.Information.usCSMIMinorRevision = CSMI_MINOR_REVISION;
752 +
753 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
754 +
755 + /* Copy the data from kernel memory to user memory
756 + */
757 + if (copy_to_user(uarg, &karg,
758 + sizeof(CSMI_SAS_DRIVER_INFO_BUFFER))) {
759 + printk(KERN_ERR "%s@%d::%s - "
760 + "Unable to write out csmi_sas_get_driver_info_buffer @ %p\n",
761 + __FILE__, __LINE__, __FUNCTION__, uarg);
762 + return -EFAULT;
763 + }
764 +
765 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
766 + return 0;
767 +}
768 +
769 +/**
770 + * Prototype Routine for the CSMI_SAS_GET_CNTLR_CONFIG command.
771 + *
772 + * Outputs: None.
773 + * Return: 0 if successful
774 + * -EFAULT if data unavailable
775 + * -ENODEV if no such device/adapter
776 + **/
777 +static int
778 +csmisas_get_cntlr_config(unsigned long arg)
779 +{
780 +
781 + CSMI_SAS_CNTLR_CONFIG_BUFFER __user *uarg = (void __user *) arg;
782 + CSMI_SAS_CNTLR_CONFIG_BUFFER karg;
783 + MPT_ADAPTER *ioc = NULL;
784 + int iocnum;
785 + u64 mem_phys;
786 +
787 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_CNTLR_CONFIG_BUFFER))) {
788 + printk(KERN_ERR "%s@%d::%s - "
789 + "Unable to read in csmi_sas_get_cntlr_config_buffer struct @ %p\n",
790 + __FILE__, __LINE__, __FUNCTION__, uarg);
791 + return -EFAULT;
792 + }
793 +
794 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
795 + &ioc)) < 0) || (ioc == NULL)) {
796 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
797 + __FILE__, __FUNCTION__, __LINE__, iocnum);
798 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
799 + return -ENODEV;
800 + }
801 +
802 + if (!csmisas_is_this_sas_cntr(ioc)) {
803 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
804 + __FILE__, __FUNCTION__, __LINE__, iocnum);
805 + return -ENODEV;
806 + }
807 +
808 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
809 +
810 + /* Clear the struct before filling in data. */
811 + memset( &karg.Configuration, 0, sizeof(CSMI_SAS_CNTLR_CONFIG));
812 +
813 + /* Fill in the data and return the structure to the calling
814 + * program
815 + */
816 +
817 + karg.Configuration.uBaseIoAddress = ioc->pio_mem_phys;
818 + karg.Configuration.BaseMemoryAddress.uLowPart = ioc->mem_phys;
819 + if (sizeof(ioc->mem_phys) == sizeof(u64)) {
820 + mem_phys = ioc->mem_phys;
821 + karg.Configuration.BaseMemoryAddress.uHighPart =
822 + (u32)(mem_phys >> 32);
823 + }
824 +
825 + karg.Configuration.uBoardID = (ioc->pcidev->subsystem_device << 16) |
826 + (ioc->pcidev->subsystem_vendor);
827 +
828 + karg.Configuration.usSlotNumber =
829 + (ioc->pci_slot_number = 0xff) ?
830 + SLOT_NUMBER_UNKNOWN : ioc->pci_slot_number;
831 + karg.Configuration.bControllerClass = CSMI_SAS_CNTLR_CLASS_HBA;
832 + karg.Configuration.bIoBusType = CSMI_SAS_BUS_TYPE_PCI;
833 + karg.Configuration.BusAddress.PciAddress.bBusNumber =
834 + ioc->pcidev->bus->number;
835 + karg.Configuration.BusAddress.PciAddress.bDeviceNumber =
836 + PCI_SLOT(ioc->pcidev->devfn);
837 + karg.Configuration.BusAddress.PciAddress.bFunctionNumber =
838 + PCI_FUNC(ioc->pcidev->devfn);
839 + karg.Configuration.BusAddress.PciAddress.bReserved = 0;
840 + memcpy( &karg.Configuration.szSerialNumber, ioc->board_tracer, 16 );
841 + karg.Configuration.usMajorRevision = ioc->facts.FWVersion.Struct.Major;
842 + karg.Configuration.usMinorRevision = ioc->facts.FWVersion.Struct.Minor;
843 + karg.Configuration.usBuildRevision = ioc->facts.FWVersion.Struct.Unit;
844 + karg.Configuration.usReleaseRevision = ioc->facts.FWVersion.Struct.Dev;
845 + karg.Configuration.usBIOSMajorRevision =
846 + (ioc->biosVersion & 0xFF000000) >> 24;
847 + karg.Configuration.usBIOSMinorRevision =
848 + (ioc->biosVersion & 0x00FF0000) >> 16;
849 + karg.Configuration.usBIOSBuildRevision =
850 + (ioc->biosVersion & 0x0000FF00) >> 8;
851 + karg.Configuration.usBIOSReleaseRevision =
852 + (ioc->biosVersion & 0x000000FF);
853 + karg.Configuration.uControllerFlags = CSMI_SAS_CNTLR_SAS_HBA |
854 + CSMI_SAS_CNTLR_FWD_SUPPORT | CSMI_SAS_CNTLR_FWD_ONLINE |
855 + CSMI_SAS_CNTLR_FWD_SRESET ;
856 +
857 + /*
858 + * Enabling CSMI_SAS_CNTLR_SAS_RAID bit when IR fw detected
859 + */
860 + if (ioc->ir_firmware)
861 + karg.Configuration.uControllerFlags |= CSMI_SAS_CNTLR_SAS_RAID;
862 +
863 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
864 +
865 + /* All Rrom entries will be zero. Skip them. */
866 + /* bReserved will also be zeros. */
867 + /* Copy the data from kernel memory to user memory
868 + */
869 + if (copy_to_user(uarg, &karg,
870 + sizeof(CSMI_SAS_DRIVER_INFO_BUFFER))) {
871 + printk(KERN_ERR "%s@%d::%s - "
872 + "Unable to write out csmi_sas_get_driver_info_buffer @ %p\n",
873 + __FILE__, __LINE__, __FUNCTION__, uarg);
874 + return -EFAULT;
875 + }
876 +
877 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
878 + return 0;
879 +}
880 +
881 +/**
882 + * Prototype Routine for the CSMI Sas Get Controller Status command.
883 + *
884 + * Outputs: None.
885 + * Return: 0 if successful
886 + * -EFAULT if data unavailable
887 + * -ENODEV if no such device/adapter
888 + **/
889 +static int
890 +csmisas_get_cntlr_status(unsigned long arg)
891 +{
892 +
893 + CSMI_SAS_CNTLR_STATUS_BUFFER __user *uarg = (void __user *) arg;
894 + MPT_ADAPTER *ioc = NULL;
895 + CSMI_SAS_CNTLR_STATUS_BUFFER karg;
896 + int iocnum;
897 + int rc;
898 +
899 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_CNTLR_STATUS_BUFFER))) {
900 + printk(KERN_ERR "%s@%d::%s - "
901 + "Unable to read in csmi_sas_get_cntlr_status_buffer struct @ %p\n",
902 + __FILE__, __LINE__, __FUNCTION__, uarg);
903 + return -EFAULT;
904 + }
905 +
906 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
907 + &ioc)) < 0) || (ioc == NULL)) {
908 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
909 + __FILE__, __FUNCTION__, __LINE__, iocnum);
910 + return -ENODEV;
911 + }
912 +
913 + if (!csmisas_is_this_sas_cntr(ioc)) {
914 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
915 + __FILE__, __FUNCTION__, __LINE__, iocnum);
916 + return -ENODEV;
917 + }
918 +
919 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
920 +
921 + /* Fill in the data and return the structure to the calling
922 + * program
923 + */
924 +
925 + rc = mpt_GetIocState(ioc, 1);
926 + switch (rc) {
927 + case MPI_IOC_STATE_OPERATIONAL:
928 + karg.Status.uStatus = CSMI_SAS_CNTLR_STATUS_GOOD;
929 + karg.Status.uOfflineReason = 0;
930 + break;
931 +
932 + case MPI_IOC_STATE_FAULT:
933 + karg.Status.uStatus = CSMI_SAS_CNTLR_STATUS_FAILED;
934 + karg.Status.uOfflineReason = 0;
935 + break;
936 +
937 + case MPI_IOC_STATE_RESET:
938 + case MPI_IOC_STATE_READY:
939 + default:
940 + karg.Status.uStatus = CSMI_SAS_CNTLR_STATUS_OFFLINE;
941 + karg.Status.uOfflineReason =
942 + CSMI_SAS_OFFLINE_REASON_INITIALIZING;
943 + break;
944 + }
945 +
946 + memset(&karg.Status.bReserved, 0, 28);
947 +
948 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
949 +
950 + /* Copy the data from kernel memory to user memory
951 + */
952 + if (copy_to_user(uarg, &karg,
953 + sizeof(CSMI_SAS_CNTLR_STATUS_BUFFER))) {
954 + printk(KERN_ERR "%s@%d::%s - "
955 + "Unable to write out csmi_sas_get_cntlr_status @ %p\n",
956 + __FILE__, __LINE__, __FUNCTION__, uarg);
957 + return -EFAULT;
958 + }
959 +
960 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
961 + return 0;
962 +}
963 +
964 +/**
965 + * Prototype Routine for the CSMI Sas Get Phy Info command.
966 + *
967 + * Outputs: None.
968 + * Return: 0 if successful
969 + * -EFAULT if data unavailable
970 + * -ENODEV if no such device/adapter
971 + **/
972 +static int
973 +csmisas_get_phy_info(unsigned long arg)
974 +{
975 + CSMI_SAS_PHY_INFO_BUFFER __user *uarg = (void __user *) arg;
976 + CSMI_SAS_PHY_INFO_BUFFER *karg;
977 + MPT_ADAPTER *ioc = NULL;
978 + ConfigExtendedPageHeader_t hdr;
979 + CONFIGPARMS cfg;
980 + SasIOUnitPage0_t *sasIoUnitPg0;
981 + dma_addr_t sasIoUnitPg0_dma;
982 + int sasIoUnitPg0_data_sz;
983 + SasPhyPage0_t *sasPhyPg0;
984 + dma_addr_t sasPhyPg0_dma;
985 + int sasPhyPg0_data_sz;
986 + u16 protocol;
987 + int iocnum;
988 + int rc;
989 + int ii;
990 + u64 sas_address;
991 + struct mptsas_devinfo device_info;
992 + int memory_pages;
993 +
994 + sasIoUnitPg0=NULL;
995 + sasPhyPg0=NULL;
996 + sasIoUnitPg0_data_sz=0;
997 + sasPhyPg0_data_sz=0;
998 +
999 + memory_pages = get_order(sizeof(CSMI_SAS_PHY_INFO_BUFFER));
1000 + karg = (CSMI_SAS_PHY_INFO_BUFFER *)__get_free_pages(
1001 + GFP_KERNEL, memory_pages);
1002 + if (!karg){
1003 + printk(KERN_ERR "%s@%d::%s() - "
1004 + "Unable to malloc CSMI_SAS_PHY_INFO_BUFFER "
1005 + "malloc_data_sz=%d memory_pages=%d\n",
1006 + __FILE__, __LINE__, __FUNCTION__,
1007 + (int)sizeof(CSMI_SAS_PHY_INFO_BUFFER), memory_pages);
1008 + return -ENOMEM;
1009 + }
1010 +
1011 + memset(karg, 0, sizeof(*karg));
1012 +
1013 + if (copy_from_user(karg, uarg, sizeof(CSMI_SAS_PHY_INFO_BUFFER))) {
1014 + printk(KERN_ERR "%s@%d::%s - "
1015 + "Unable to read in csmisas_get_phy_info_buffer struct @ %p\n",
1016 + __FILE__, __LINE__, __FUNCTION__, uarg);
1017 + free_pages((unsigned long)karg, memory_pages);
1018 + return -EFAULT;
1019 + }
1020 +
1021 + if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
1022 + &ioc)) < 0) || (ioc == NULL)) {
1023 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
1024 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1025 + free_pages((unsigned long)karg, memory_pages);
1026 + return -ENODEV;
1027 + }
1028 +
1029 + if (!csmisas_is_this_sas_cntr(ioc)) {
1030 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
1031 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1032 + free_pages((unsigned long)karg, memory_pages);
1033 + return -ENODEV;
1034 + }
1035 +
1036 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
1037 +
1038 + /* Fill in the data and return the structure to the calling
1039 + * program
1040 + */
1041 +
1042 + /* Issue a config request to get the number of phys
1043 + */
1044 + hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
1045 + hdr.ExtPageLength = 0;
1046 + hdr.PageNumber = 0;
1047 + hdr.Reserved1 = 0;
1048 + hdr.Reserved2 = 0;
1049 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1050 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
1051 +
1052 + cfg.cfghdr.ehdr = &hdr;
1053 + cfg.physAddr = -1;
1054 + cfg.pageAddr = 0;
1055 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1056 + cfg.dir = 0; /* read */
1057 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
1058 +
1059 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1060 + /* Don't check if this failed. Already in a
1061 + * failure case.
1062 + */
1063 + dcsmisasprintk(ioc, printk(KERN_ERR
1064 + ": FAILED: MPI_SASIOUNITPAGE0_PAGEVERSION: HEADER\n"));
1065 + dcsmisasprintk(ioc, printk(": rc=%x\n",rc));
1066 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1067 + goto sas_get_phy_info_exit;
1068 + }
1069 +
1070 + if (hdr.ExtPageLength == 0) {
1071 + /* Don't check if this failed. Already in a
1072 + * failure case.
1073 + */
1074 + dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
1075 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1076 + goto sas_get_phy_info_exit;
1077 + }
1078 +
1079 + sasIoUnitPg0_data_sz = hdr.ExtPageLength * 4;
1080 + rc = -ENOMEM;
1081 +
1082 + sasIoUnitPg0 = (SasIOUnitPage0_t *) pci_alloc_consistent(ioc->pcidev,
1083 + sasIoUnitPg0_data_sz, &sasIoUnitPg0_dma);
1084 +
1085 + if (!sasIoUnitPg0) {
1086 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
1087 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1088 + goto sas_get_phy_info_exit;
1089 + }
1090 +
1091 + memset((u8 *)sasIoUnitPg0, 0, sasIoUnitPg0_data_sz);
1092 + cfg.physAddr = sasIoUnitPg0_dma;
1093 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1094 +
1095 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1096 +
1097 + /* Don't check if this failed. Already in a
1098 + * failure case.
1099 + */
1100 + dcsmisasprintk(ioc, printk(KERN_ERR
1101 + ": FAILED: MPI_SASIOUNITPAGE0_PAGEVERSION: PAGE\n"));
1102 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
1103 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1104 + goto sas_get_phy_info_exit;
1105 + }
1106 +
1107 + /* Number of Phys. */
1108 + karg->Information.bNumberOfPhys = sasIoUnitPg0->NumPhys;
1109 +
1110 + /* Fill in information for each phy. */
1111 + for (ii = 0; ii < karg->Information.bNumberOfPhys; ii++) {
1112 +
1113 +/* EDM : dump IO Unit Page 0 data*/
1114 + dcsmisasprintk(ioc, printk(KERN_DEBUG "---- IO UNIT PAGE 0 ------------\n"));
1115 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n",
1116 + le16_to_cpu(sasIoUnitPg0->PhyData[ii].AttachedDeviceHandle)));
1117 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Controller Handle=0x%X\n",
1118 + le16_to_cpu(sasIoUnitPg0->PhyData[ii].ControllerDevHandle)));
1119 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Port=0x%X\n",
1120 + sasIoUnitPg0->PhyData[ii].Port));
1121 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Port Flags=0x%X\n",
1122 + sasIoUnitPg0->PhyData[ii].PortFlags));
1123 + dcsmisasprintk(ioc, printk(KERN_DEBUG "PHY Flags=0x%X\n",
1124 + sasIoUnitPg0->PhyData[ii].PhyFlags));
1125 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Negotiated Link Rate=0x%X\n",
1126 + sasIoUnitPg0->PhyData[ii].NegotiatedLinkRate));
1127 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Controller PHY Device Info=0x%X\n",
1128 + le32_to_cpu(sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo)));
1129 + dcsmisasprintk(ioc, printk(KERN_DEBUG "DiscoveryStatus=0x%X\n",
1130 + le32_to_cpu(sasIoUnitPg0->PhyData[ii].DiscoveryStatus)));
1131 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
1132 +/* EDM : debug data */
1133 +
1134 + /* PHY stuff. */
1135 + karg->Information.Phy[ii].bPortIdentifier =
1136 + sasIoUnitPg0->PhyData[ii].Port;
1137 +
1138 + /* Get the negotiated link rate for the phy. */
1139 + switch (sasIoUnitPg0->PhyData[ii].NegotiatedLinkRate) {
1140 +
1141 + case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
1142 + karg->Information.Phy[ii].bNegotiatedLinkRate =
1143 + CSMI_SAS_PHY_DISABLED;
1144 + break;
1145 +
1146 + case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
1147 + karg->Information.Phy[ii].bNegotiatedLinkRate =
1148 + CSMI_SAS_LINK_RATE_FAILED;
1149 + break;
1150 +
1151 + case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
1152 + break;
1153 +
1154 + case MPI_SAS_IOUNIT0_RATE_1_5:
1155 + karg->Information.Phy[ii].bNegotiatedLinkRate =
1156 + CSMI_SAS_LINK_RATE_1_5_GBPS;
1157 + break;
1158 +
1159 + case MPI_SAS_IOUNIT0_RATE_3_0:
1160 + karg->Information.Phy[ii].bNegotiatedLinkRate =
1161 + CSMI_SAS_LINK_RATE_3_0_GBPS;
1162 + break;
1163 +
1164 + case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
1165 + default:
1166 + karg->Information.Phy[ii].bNegotiatedLinkRate =
1167 + CSMI_SAS_LINK_RATE_UNKNOWN;
1168 + break;
1169 + }
1170 +
1171 + if (sasIoUnitPg0->PhyData[ii].PortFlags &
1172 + MPI_SAS_IOUNIT0_PORT_FLAGS_DISCOVERY_IN_PROGRESS) {
1173 + karg->Information.Phy[ii].bAutoDiscover =
1174 + CSMI_SAS_DISCOVER_IN_PROGRESS;
1175 + } else {
1176 + karg->Information.Phy[ii].bAutoDiscover =
1177 + CSMI_SAS_DISCOVER_COMPLETE;
1178 + }
1179 +
1180 + /* Issue a config request to get
1181 + * phy information.
1182 + */
1183 + hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
1184 + hdr.ExtPageLength = 0;
1185 + hdr.PageNumber = 0;
1186 + hdr.Reserved1 = 0;
1187 + hdr.Reserved2 = 0;
1188 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1189 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1190 +
1191 + cfg.cfghdr.ehdr = &hdr;
1192 + cfg.physAddr = -1;
1193 + cfg.pageAddr = ii;
1194 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1195 + cfg.dir = 0; /* read */
1196 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
1197 +
1198 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1199 + dcsmisasprintk(ioc, printk(KERN_ERR
1200 + ": FAILED: MPI_SASPHY0_PAGEVERSION: HEADER\n"));
1201 + dcsmisasprintk(ioc, printk(": rc=%x\n",rc));
1202 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1203 + goto sas_get_phy_info_exit;
1204 + }
1205 +
1206 + if (hdr.ExtPageLength == 0) {
1207 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
1208 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1209 + goto sas_get_phy_info_exit;
1210 + }
1211 +
1212 + sasPhyPg0_data_sz = hdr.ExtPageLength * 4;
1213 + rc = -ENOMEM;
1214 +
1215 + sasPhyPg0 = (SasPhyPage0_t *) pci_alloc_consistent(
1216 + ioc->pcidev, sasPhyPg0_data_sz, &sasPhyPg0_dma);
1217 +
1218 + if (! sasPhyPg0) {
1219 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
1220 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1221 + goto sas_get_phy_info_exit;
1222 + }
1223 +
1224 + memset((u8 *)sasPhyPg0, 0, sasPhyPg0_data_sz);
1225 + cfg.physAddr = sasPhyPg0_dma;
1226 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1227 +
1228 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1229 + dcsmisasprintk(ioc, printk(KERN_ERR
1230 + ": FAILED: MPI_SASPHY0_PAGEVERSION: PAGE\n"));
1231 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
1232 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1233 + pci_free_consistent(ioc->pcidev, sasPhyPg0_data_sz,
1234 + (u8 *) sasPhyPg0, sasPhyPg0_dma);
1235 + goto sas_get_phy_info_exit;
1236 + }
1237 +
1238 +/* EDM : dump PHY Page 0 data*/
1239 + memcpy(&sas_address, &sasPhyPg0->SASAddress, sizeof(u64));
1240 + dcsmisasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 0 ------------\n"));
1241 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n",
1242 + le16_to_cpu(sasPhyPg0->AttachedDevHandle)));
1243 + dcsmisasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n",
1244 + (unsigned long long)sas_address));
1245 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Attached PHY Identifier=0x%X\n",
1246 + sasPhyPg0->AttachedPhyIdentifier));
1247 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Attached Device Info=0x%X\n",
1248 + le32_to_cpu(sasPhyPg0->AttachedDeviceInfo)));
1249 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Programmed Link Rate=0x%X\n",
1250 + sasPhyPg0->ProgrammedLinkRate));
1251 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Hardware Link Rate=0x%X\n",
1252 + sasPhyPg0->HwLinkRate));
1253 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Change Count=0x%X\n",
1254 + sasPhyPg0->ChangeCount));
1255 + dcsmisasprintk(ioc, printk(KERN_DEBUG "PHY Info=0x%X\n",
1256 + le32_to_cpu(sasPhyPg0->PhyInfo)));
1257 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
1258 +/* EDM : debug data */
1259 +
1260 + /* save the data */
1261 +
1262 + /* Set Max hardware link rate.
1263 + * This value is hard coded
1264 + * because the HW link rate
1265 + * is currently being
1266 + * overwritten in FW.
1267 + */
1268 +
1269 + /* Set Max hardware link rate. */
1270 + switch (sasPhyPg0->HwLinkRate &
1271 + MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1272 +
1273 + case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
1274 + karg->Information.Phy[ii].bMaximumLinkRate =
1275 + CSMI_SAS_LINK_RATE_1_5_GBPS;
1276 + break;
1277 +
1278 + case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1279 + karg->Information.Phy[ii].bMaximumLinkRate =
1280 + CSMI_SAS_LINK_RATE_3_0_GBPS;
1281 + break;
1282 + default:
1283 + break;
1284 + }
1285 +
1286 + /* Set Max programmed link rate. */
1287 + switch (sasPhyPg0->ProgrammedLinkRate &
1288 + MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
1289 +
1290 + case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
1291 + karg->Information.Phy[ii].bMaximumLinkRate |=
1292 + (CSMI_SAS_PROGRAMMED_LINK_RATE_1_5_GBPS << 4);
1293 + break;
1294 +
1295 + case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
1296 + karg->Information.Phy[ii].bMaximumLinkRate |=
1297 + (CSMI_SAS_PROGRAMMED_LINK_RATE_3_0_GBPS << 4);
1298 + break;
1299 + default:
1300 + break;
1301 + }
1302 +
1303 + /* Set Min hardware link rate. */
1304 + switch (sasPhyPg0->HwLinkRate &
1305 + MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
1306 +
1307 + case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
1308 + karg->Information.Phy[ii].bMinimumLinkRate =
1309 + CSMI_SAS_LINK_RATE_1_5_GBPS;
1310 + break;
1311 +
1312 + case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1313 + karg->Information.Phy[ii].bMinimumLinkRate =
1314 + CSMI_SAS_LINK_RATE_3_0_GBPS;
1315 + break;
1316 + default:
1317 + break;
1318 + }
1319 +
1320 + /* Set Min programmed link rate. */
1321 + switch (sasPhyPg0->ProgrammedLinkRate &
1322 + MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
1323 +
1324 + case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
1325 + karg->Information.Phy[ii].bMinimumLinkRate |=
1326 + (CSMI_SAS_PROGRAMMED_LINK_RATE_1_5_GBPS << 4);
1327 + break;
1328 +
1329 + case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
1330 + karg->Information.Phy[ii].bMinimumLinkRate |=
1331 + (CSMI_SAS_PROGRAMMED_LINK_RATE_3_0_GBPS << 4);
1332 + break;
1333 + default:
1334 + break;
1335 + }
1336 +
1337 + karg->Information.Phy[ii].bPhyChangeCount = sasPhyPg0->ChangeCount;
1338 + if( sasPhyPg0->PhyInfo & MPI_SAS_PHY0_PHYINFO_VIRTUAL_PHY )
1339 + karg->Information.Phy[ii].bPhyFeatures = CSMI_SAS_PHY_VIRTUAL_SMP;
1340 +
1341 + /* Fill in Attached Device
1342 + * Initiator Port Protocol.
1343 + * Bits 6:3
1344 + * More than one bit can be set.
1345 + */
1346 + protocol = le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) & 0x78;
1347 + karg->Information.Phy[ii].Attached.bInitiatorPortProtocol = 0;
1348 + if (protocol & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
1349 + karg->Information.Phy[ii].Attached.bInitiatorPortProtocol =
1350 + CSMI_SAS_PROTOCOL_SSP;
1351 + if (protocol & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
1352 + karg->Information.Phy[ii].Attached.bInitiatorPortProtocol |=
1353 + CSMI_SAS_PROTOCOL_STP;
1354 + if (protocol & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
1355 + karg->Information.Phy[ii].Attached.bInitiatorPortProtocol |=
1356 + CSMI_SAS_PROTOCOL_SMP;
1357 + if (protocol & MPI_SAS_DEVICE_INFO_SATA_HOST)
1358 + karg->Information.Phy[ii].Attached.bInitiatorPortProtocol |=
1359 + CSMI_SAS_PROTOCOL_SATA;
1360 +
1361 + /* Fill in Phy Target Port
1362 + * Protocol. Bits 10:7
1363 + * More than one bit can be set.
1364 + */
1365 + protocol = le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) & 0x780;
1366 + karg->Information.Phy[ii].Attached.bTargetPortProtocol = 0;
1367 + if (protocol & MPI_SAS_DEVICE_INFO_SSP_TARGET)
1368 + karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
1369 + CSMI_SAS_PROTOCOL_SSP;
1370 + if (protocol & MPI_SAS_DEVICE_INFO_STP_TARGET)
1371 + karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
1372 + CSMI_SAS_PROTOCOL_STP;
1373 + if (protocol & MPI_SAS_DEVICE_INFO_SMP_TARGET)
1374 + karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
1375 + CSMI_SAS_PROTOCOL_SMP;
1376 + if (protocol & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
1377 + karg->Information.Phy[ii].Attached.bTargetPortProtocol |=
1378 + CSMI_SAS_PROTOCOL_SATA;
1379 +
1380 +
1381 + /* Fill in Attached device type */
1382 + switch (le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) &
1383 + MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
1384 +
1385 + case MPI_SAS_DEVICE_INFO_NO_DEVICE:
1386 + karg->Information.Phy[ii].Attached.bDeviceType =
1387 + CSMI_SAS_NO_DEVICE_ATTACHED;
1388 + break;
1389 +
1390 + case MPI_SAS_DEVICE_INFO_END_DEVICE:
1391 + karg->Information.Phy[ii].Attached.bDeviceType =
1392 + CSMI_SAS_END_DEVICE;
1393 + break;
1394 +
1395 + case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
1396 + karg->Information.Phy[ii].Attached.bDeviceType =
1397 + CSMI_SAS_EDGE_EXPANDER_DEVICE;
1398 + break;
1399 +
1400 + case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
1401 + karg->Information.Phy[ii].Attached.bDeviceType =
1402 + CSMI_SAS_FANOUT_EXPANDER_DEVICE;
1403 + break;
1404 + }
1405 +
1406 + /* Identify Info. */
1407 + switch (le32_to_cpu(sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo) &
1408 + MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
1409 +
1410 + case MPI_SAS_DEVICE_INFO_NO_DEVICE:
1411 + karg->Information.Phy[ii].Identify.bDeviceType =
1412 + CSMI_SAS_NO_DEVICE_ATTACHED;
1413 + break;
1414 +
1415 + case MPI_SAS_DEVICE_INFO_END_DEVICE:
1416 + karg->Information.Phy[ii].Identify.bDeviceType =
1417 + CSMI_SAS_END_DEVICE;
1418 + break;
1419 +
1420 + case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
1421 + karg->Information.Phy[ii].Identify.bDeviceType =
1422 + CSMI_SAS_EDGE_EXPANDER_DEVICE;
1423 + break;
1424 +
1425 + case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
1426 + karg->Information.Phy[ii].Identify.bDeviceType =
1427 + CSMI_SAS_FANOUT_EXPANDER_DEVICE;
1428 + break;
1429 + }
1430 +
1431 + /* Fill in Phy Initiator Port Protocol. Bits 6:3
1432 + * More than one bit can be set, fall through cases.
1433 + */
1434 + protocol = le32_to_cpu(
1435 + sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo) & 0x78;
1436 + karg->Information.Phy[ii].Identify.bInitiatorPortProtocol = 0;
1437 + if( protocol & MPI_SAS_DEVICE_INFO_SSP_INITIATOR )
1438 + karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
1439 + CSMI_SAS_PROTOCOL_SSP;
1440 + if( protocol & MPI_SAS_DEVICE_INFO_STP_INITIATOR )
1441 + karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
1442 + CSMI_SAS_PROTOCOL_STP;
1443 + if( protocol & MPI_SAS_DEVICE_INFO_SMP_INITIATOR )
1444 + karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
1445 + CSMI_SAS_PROTOCOL_SMP;
1446 + if( protocol & MPI_SAS_DEVICE_INFO_SATA_HOST )
1447 + karg->Information.Phy[ii].Identify.bInitiatorPortProtocol |=
1448 + CSMI_SAS_PROTOCOL_SATA;
1449 +
1450 + /* Fill in Phy Target Port Protocol. Bits 10:7
1451 + * More than one bit can be set, fall through cases.
1452 + */
1453 + protocol = le32_to_cpu(
1454 + sasIoUnitPg0->PhyData[ii].ControllerPhyDeviceInfo) & 0x780;
1455 + karg->Information.Phy[ii].Identify.bTargetPortProtocol = 0;
1456 + if( protocol & MPI_SAS_DEVICE_INFO_SSP_TARGET )
1457 + karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
1458 + CSMI_SAS_PROTOCOL_SSP;
1459 + if( protocol & MPI_SAS_DEVICE_INFO_STP_TARGET )
1460 + karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
1461 + CSMI_SAS_PROTOCOL_STP;
1462 + if( protocol & MPI_SAS_DEVICE_INFO_SMP_TARGET )
1463 + karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
1464 + CSMI_SAS_PROTOCOL_SMP;
1465 + if( protocol & MPI_SAS_DEVICE_INFO_SATA_DEVICE )
1466 + karg->Information.Phy[ii].Identify.bTargetPortProtocol |=
1467 + CSMI_SAS_PROTOCOL_SATA;
1468 +
1469 + /* Setup SAS Address for the attached device */
1470 + if (sasPhyPg0->AttachedDevHandle) {
1471 + sas_address = reverse_byte_order64(sas_address);
1472 + memcpy(karg->Information.Phy[ii].Attached.bSASAddress,
1473 + &sas_address, sizeof(u64));
1474 + karg->Information.Phy[ii].Attached.bPhyIdentifier =
1475 + sasPhyPg0->AttachedPhyIdentifier;
1476 + }
1477 +
1478 + /* Setup SAS Address for the parent device */
1479 + csmisas_sas_device_pg0(ioc, &device_info,
1480 + (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1481 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
1482 + sasIoUnitPg0->PhyData[ii].ControllerDevHandle);
1483 + sas_address = reverse_byte_order64(device_info.sas_address);
1484 + memcpy(karg->Information.Phy[ii].Identify.bSASAddress,
1485 + &sas_address, sizeof(u64));
1486 + karg->Information.Phy[ii].Identify.bPhyIdentifier = ii;
1487 +
1488 + pci_free_consistent(ioc->pcidev, sasPhyPg0_data_sz,
1489 + (u8 *) sasPhyPg0, sasPhyPg0_dma);
1490 + }
1491 +
1492 +sas_get_phy_info_exit:
1493 +
1494 + if (sasIoUnitPg0)
1495 + pci_free_consistent(ioc->pcidev, sasIoUnitPg0_data_sz,
1496 + (u8 *) sasIoUnitPg0, sasIoUnitPg0_dma);
1497 +
1498 + /* Copy the data from kernel memory to user memory
1499 + */
1500 + if (copy_to_user(uarg, karg,
1501 + sizeof(CSMI_SAS_PHY_INFO_BUFFER))) {
1502 + printk(KERN_ERR "%s@%d::%s - "
1503 + "Unable to write out csmisas_get_phy_info_buffer @ %p\n",
1504 + __FILE__, __LINE__, __FUNCTION__, uarg);
1505 + free_pages((unsigned long)karg, memory_pages);
1506 + return -EFAULT;
1507 + }
1508 +
1509 + free_pages((unsigned long)karg, memory_pages);
1510 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
1511 + return 0;
1512 +}
1513 +
1514 +/**
1515 + * Prototype Routine for the CSMI SAS Set PHY Info command.
1516 + *
1517 + * Outputs: None.
1518 + * Return: 0 if successful
1519 + * -EFAULT if data unavailable
1520 + * -ENODEV if no such device/adapter
1521 + **/
1522 +static int
1523 +csmisas_set_phy_info(unsigned long arg)
1524 +{
1525 + CSMI_SAS_SET_PHY_INFO_BUFFER __user *uarg = (void __user *) arg;
1526 + CSMI_SAS_SET_PHY_INFO_BUFFER karg;
1527 + MPT_ADAPTER *ioc = NULL;
1528 + int iocnum;
1529 +
1530 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_SET_PHY_INFO_BUFFER))) {
1531 + printk(KERN_ERR "%s@%d::%s() - "
1532 + "Unable to read in csmi_sas_set_phy_info struct @ %p\n",
1533 + __FILE__, __LINE__, __FUNCTION__, uarg);
1534 + return -EFAULT;
1535 + }
1536 +
1537 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
1538 + &ioc)) < 0) || (ioc == NULL)) {
1539 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
1540 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1541 + return -ENODEV;
1542 + }
1543 +
1544 + if (!csmisas_is_this_sas_cntr(ioc)) {
1545 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
1546 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1547 + return -ENODEV;
1548 + }
1549 +
1550 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
1551 +
1552 +/* TODO - implement IOCTL here */
1553 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
1554 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": not implemented\n"));
1555 +
1556 +// cim_set_phy_info_exit:
1557 +
1558 + /* Copy the data from kernel memory to user memory
1559 + */
1560 + if (copy_to_user(uarg, &karg,
1561 + sizeof(CSMI_SAS_SET_PHY_INFO_BUFFER))) {
1562 + printk(KERN_ERR "%s@%d::%s() - "
1563 + "Unable to write out csmi_sas_set_phy_info @ %p\n",
1564 + __FILE__, __LINE__, __FUNCTION__, uarg);
1565 + return -EFAULT;
1566 + }
1567 +
1568 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
1569 + return 0;
1570 +
1571 +}
1572 +
1573 +/**
1574 + * Prototype Routine for the CSMI Sas Get SCSI Address command.
1575 + *
1576 + * Outputs: None.
1577 + * Return: 0 if successful
1578 + * -EFAULT if data unavailable
1579 + * -ENODEV if no such device/adapter
1580 + **/
1581 +static int
1582 +csmisas_get_scsi_address(unsigned long arg)
1583 +{
1584 + CSMI_SAS_GET_SCSI_ADDRESS_BUFFER __user *uarg = (void __user *) arg;
1585 + CSMI_SAS_GET_SCSI_ADDRESS_BUFFER karg;
1586 + MPT_ADAPTER *ioc = NULL;
1587 + int iocnum;
1588 + u64 sas_address;
1589 + struct sas_device_info *sas_info;
1590 +
1591 + if (copy_from_user(&karg, uarg,
1592 + sizeof(CSMI_SAS_GET_SCSI_ADDRESS_BUFFER))) {
1593 + printk(KERN_ERR "%s@%d::%s() - "
1594 + "Unable to read in csmi_sas_get_scsi_address struct @ %p\n",
1595 + __FILE__, __LINE__, __FUNCTION__, uarg);
1596 + return -EFAULT;
1597 + }
1598 +
1599 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
1600 + &ioc)) < 0) || (ioc == NULL)) {
1601 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
1602 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1603 + return -ENODEV;
1604 + }
1605 +
1606 + if (!csmisas_is_this_sas_cntr(ioc)) {
1607 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
1608 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1609 + return -ENODEV;
1610 + }
1611 +
1612 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
1613 +
1614 + /* reverse byte order the sas address */
1615 + memcpy(&sas_address, karg.bSASAddress, sizeof(u64));
1616 + sas_address = reverse_byte_order64(sas_address);
1617 +
1618 + /* Search the list for the matching SAS address. */
1619 + karg.IoctlHeader.ReturnCode = CSMI_SAS_NO_SCSI_ADDRESS;
1620 + karg.bPathId = 0;
1621 + karg.bTargetId = 0;
1622 + karg.bLun = 0;
1623 +
1624 + sas_info = csmisas_get_device_component_by_sas_addr(ioc, sas_address);
1625 + if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume)
1626 + goto csmisas_get_scsi_address_exit;
1627 +
1628 + karg.bPathId = sas_info->os.channel;
1629 + karg.bTargetId = sas_info->os.id;
1630 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
1631 +
1632 + csmisas_get_scsi_address_exit:
1633 +
1634 + /* Copy the data from kernel memory to user memory
1635 + */
1636 + if (copy_to_user(uarg, &karg,
1637 + sizeof(CSMI_SAS_GET_SCSI_ADDRESS_BUFFER))) {
1638 + printk(KERN_ERR "%s@%d::%s() - "
1639 + "Unable to write out csmi_sas_get_scsi_address @ %p\n",
1640 + __FILE__, __LINE__, __FUNCTION__, uarg);
1641 + return -EFAULT;
1642 + }
1643 +
1644 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
1645 + return 0;
1646 +}
1647 +
1648 +/**
1649 + * Prototype Routine for the CSMI Sas Get SCSI Address command.
1650 + *
1651 + * Outputs: None.
1652 + * Return: 0 if successful
1653 + * -EFAULT if data unavailable
1654 + * -ENODEV if no such device/adapter
1655 + **/
1656 +static int
1657 +csmisas_get_sata_signature(unsigned long arg)
1658 +{
1659 + CSMI_SAS_SATA_SIGNATURE_BUFFER __user *uarg = (void __user *) arg;
1660 + CSMI_SAS_SATA_SIGNATURE_BUFFER karg;
1661 + MPT_ADAPTER *ioc = NULL;
1662 + int iocnum;
1663 + int rc, jj;
1664 + ConfigExtendedPageHeader_t hdr;
1665 + CONFIGPARMS cfg;
1666 + SasPhyPage0_t *sasPhyPg0;
1667 + dma_addr_t sasPhyPg0_dma;
1668 + int sasPhyPg0_data_sz;
1669 + SasDevicePage1_t *sasDevicePg1;
1670 + dma_addr_t sasDevicePg1_dma;
1671 + int sasDevicePg1_data_sz;
1672 + u8 phyId;
1673 + u64 sas_address;
1674 +
1675 + sasPhyPg0=NULL;
1676 + sasPhyPg0_data_sz=0;
1677 + sasDevicePg1=NULL;
1678 + sasDevicePg1_data_sz=0;
1679 +
1680 + if (copy_from_user(&karg, uarg,
1681 + sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER))) {
1682 + printk(KERN_ERR "%s@%d::%s() - "
1683 + "Unable to read in csmi_sas_sata_signature struct @ %p\n",
1684 + __FILE__, __LINE__, __FUNCTION__, uarg);
1685 + return -EFAULT;
1686 + }
1687 +
1688 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
1689 + &ioc)) < 0) || (ioc == NULL)) {
1690 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
1691 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1692 + return -ENODEV;
1693 + }
1694 +
1695 + if (!csmisas_is_this_sas_cntr(ioc)) {
1696 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
1697 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1698 + return -ENODEV;
1699 + }
1700 +
1701 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
1702 + phyId = karg.Signature.bPhyIdentifier;
1703 + if (phyId >= ioc->num_ports) {
1704 + karg.IoctlHeader.ReturnCode = CSMI_SAS_PHY_DOES_NOT_EXIST;
1705 + dcsmisasprintk(ioc, printk(KERN_WARNING ": phyId >= ioc->num_ports\n"));
1706 + goto cim_sata_signature_exit;
1707 + }
1708 +
1709 + /* Default to success.*/
1710 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
1711 +
1712 + /* Issue a config request to get the devHandle of the attached device
1713 + */
1714 +
1715 + /* Issue a config request to get phy information. */
1716 + hdr.PageVersion = MPI_SASPHY0_PAGEVERSION;
1717 + hdr.ExtPageLength = 0;
1718 + hdr.PageNumber = 0;
1719 + hdr.Reserved1 = 0;
1720 + hdr.Reserved2 = 0;
1721 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1722 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
1723 +
1724 + cfg.cfghdr.ehdr = &hdr;
1725 + cfg.physAddr = -1;
1726 + cfg.pageAddr = phyId;
1727 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1728 + cfg.dir = 0; /* read */
1729 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
1730 +
1731 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1732 + /* Don't check if this failed. Already in a
1733 + * failure case.
1734 + */
1735 + dcsmisasprintk(ioc, printk(KERN_ERR
1736 + ": FAILED: MPI_SASPHY0_PAGEVERSION: HEADER\n"));
1737 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
1738 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1739 + goto cim_sata_signature_exit;
1740 + }
1741 +
1742 + if (hdr.ExtPageLength == 0) {
1743 + /* Don't check if this failed. Already in a
1744 + * failure case.
1745 + */
1746 + dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
1747 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1748 + goto cim_sata_signature_exit;
1749 + }
1750 +
1751 +
1752 + sasPhyPg0_data_sz = hdr.ExtPageLength * 4;
1753 + rc = -ENOMEM;
1754 +
1755 + sasPhyPg0 = (SasPhyPage0_t *) pci_alloc_consistent(ioc->pcidev,
1756 + sasPhyPg0_data_sz, &sasPhyPg0_dma);
1757 +
1758 + if (! sasPhyPg0) {
1759 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
1760 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1761 + goto cim_sata_signature_exit;
1762 + }
1763 +
1764 + memset((u8 *)sasPhyPg0, 0, sasPhyPg0_data_sz);
1765 + cfg.physAddr = sasPhyPg0_dma;
1766 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1767 +
1768 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1769 + /* Don't check if this failed. Already in a
1770 + * failure case.
1771 + */
1772 + dcsmisasprintk(ioc, printk(KERN_ERR
1773 + ": FAILED: MPI_SASPHY0_PAGEVERSION: PAGE\n"));
1774 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
1775 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1776 + goto cim_sata_signature_exit;
1777 + }
1778 +
1779 + /* Make sure a SATA device is attached. */
1780 + if ((le32_to_cpu(sasPhyPg0->AttachedDeviceInfo) &
1781 + MPI_SAS_DEVICE_INFO_SATA_DEVICE) == 0) {
1782 + dcsmisasprintk(ioc, printk(KERN_WARNING ": NOT A SATA DEVICE\n"));
1783 + karg.IoctlHeader.ReturnCode = CSMI_SAS_NO_SATA_DEVICE;
1784 + goto cim_sata_signature_exit;
1785 + }
1786 +
1787 + /* Get device page 1 for FIS signature. */
1788 + hdr.PageVersion = MPI_SASDEVICE1_PAGEVERSION;
1789 + hdr.ExtPageLength = 0;
1790 + hdr.PageNumber = 1 /* page number 1 */;
1791 + hdr.Reserved1 = 0;
1792 + hdr.Reserved2 = 0;
1793 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
1794 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
1795 +
1796 + cfg.cfghdr.ehdr = &hdr;
1797 + cfg.physAddr = -1;
1798 +
1799 + cfg.pageAddr = ((MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
1800 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT) |
1801 + le16_to_cpu(sasPhyPg0->AttachedDevHandle));
1802 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
1803 + cfg.dir = 0; /* read */
1804 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
1805 +
1806 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1807 + dcsmisasprintk(ioc, printk(KERN_ERR
1808 + ": FAILED: MPI_SASDEVICE1_PAGEVERSION: HEADER\n"));
1809 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
1810 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1811 + goto cim_sata_signature_exit;
1812 + }
1813 +
1814 + if (hdr.ExtPageLength == 0) {
1815 + dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
1816 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1817 + goto cim_sata_signature_exit;
1818 + }
1819 +
1820 + sasDevicePg1_data_sz = hdr.ExtPageLength * 4;
1821 + rc = -ENOMEM;
1822 +
1823 + sasDevicePg1 = (SasDevicePage1_t *) pci_alloc_consistent
1824 + (ioc->pcidev, sasDevicePg1_data_sz, &sasDevicePg1_dma);
1825 +
1826 + if (! sasDevicePg1) {
1827 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
1828 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1829 + goto cim_sata_signature_exit;
1830 + }
1831 +
1832 + memset((u8 *)sasDevicePg1, 0, sasDevicePg1_data_sz);
1833 + cfg.physAddr = sasDevicePg1_dma;
1834 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
1835 +
1836 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
1837 + dcsmisasprintk(ioc, printk(KERN_ERR
1838 + ": FAILED: MPI_SASDEVICE1_PAGEVERSION: PAGE\n"));
1839 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
1840 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
1841 + goto cim_sata_signature_exit;
1842 + }
1843 +
1844 +/* EDM : dump Device Page 1 data*/
1845 + dcsmisasprintk(ioc, printk(KERN_DEBUG "---- SAS DEVICE PAGE 1 ---------\n"));
1846 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Handle=0x%x\n",sasDevicePg1->DevHandle));
1847 + memcpy(&sas_address, &sasDevicePg1->SASAddress, sizeof(u64));
1848 + dcsmisasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n",
1849 + (unsigned long long)sas_address));
1850 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
1851 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Target ID=0x%x\n",sasDevicePg1->TargetID));
1852 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Bus=0x%x\n",sasDevicePg1->Bus));
1853 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Initial Reg Device FIS="));
1854 + for(jj=0;jj<20;jj++)
1855 + dcsmisasprintk(ioc, printk("%02x ",
1856 + ((u8 *)&sasDevicePg1->InitialRegDeviceFIS)[jj]));
1857 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n\n"));
1858 +/* EDM : debug data */
1859 +
1860 + memcpy(karg.Signature.bSignatureFIS,
1861 + sasDevicePg1->InitialRegDeviceFIS,20);
1862 +
1863 + cim_sata_signature_exit:
1864 +
1865 + if (sasPhyPg0)
1866 + pci_free_consistent(ioc->pcidev, sasPhyPg0_data_sz,
1867 + (u8 *) sasPhyPg0, sasPhyPg0_dma);
1868 +
1869 + if (sasDevicePg1)
1870 + pci_free_consistent(ioc->pcidev, sasDevicePg1_data_sz,
1871 + (u8 *) sasDevicePg1, sasDevicePg1_dma);
1872 +
1873 + /* Copy the data from kernel memory to user memory
1874 + */
1875 + if (copy_to_user(uarg, &karg,
1876 + sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER))) {
1877 + printk(KERN_ERR "%s@%d::%s() - "
1878 + "Unable to write out csmi_sas_sata_signature @ %p\n",
1879 + __FILE__, __LINE__, __FUNCTION__, uarg);
1880 + return -EFAULT;
1881 + }
1882 +
1883 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
1884 + return 0;
1885 +}
1886 +
1887 +/**
1888 + * Prototype Routine for the CSMI Sas Get SCSI Address command.
1889 + *
1890 + * Outputs: None.
1891 + * Return: 0 if successful
1892 + * -EFAULT if data unavailable
1893 + * -ENODEV if no such device/adapter
1894 + **/
1895 +static int
1896 +csmisas_get_device_address(unsigned long arg)
1897 +{
1898 + CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER __user *uarg = (void __user *) arg;
1899 + CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER karg;
1900 + MPT_ADAPTER *ioc = NULL;
1901 + int iocnum;
1902 + struct sas_device_info *sas_info;
1903 + u64 sas_address;
1904 +
1905 + if (copy_from_user(&karg, uarg,
1906 + sizeof(CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER))) {
1907 + printk(KERN_ERR "%s@%d::%s() - "
1908 + "Unable to read in csmi_sas_get_device_address_buffer struct @ %p\n",
1909 + __FILE__, __LINE__, __FUNCTION__, uarg);
1910 + return -EFAULT;
1911 + }
1912 +
1913 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
1914 + &ioc)) < 0) || (ioc == NULL)) {
1915 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
1916 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1917 + return -ENODEV;
1918 + }
1919 +
1920 + if (!csmisas_is_this_sas_cntr(ioc)) {
1921 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
1922 + __FILE__, __FUNCTION__, __LINE__, iocnum);
1923 + return -ENODEV;
1924 + }
1925 +
1926 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
1927 +
1928 + karg.IoctlHeader.ReturnCode = CSMI_SAS_NO_DEVICE_ADDRESS;
1929 + memset(karg.bSASAddress, 0, sizeof(u64));
1930 + memset(karg.bSASLun, 0, sizeof(karg.bSASLun));
1931 +
1932 + /* Search the list for the matching SAS address. */
1933 + sas_info = csmisas_get_device_component_by_os(ioc, karg.bPathId,
1934 + karg.bTargetId);
1935 + if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume)
1936 + goto csmisas_get_device_address_exit;
1937 +
1938 + sas_address = reverse_byte_order64(sas_info->sas_address);
1939 + memcpy(karg.bSASAddress, &sas_address, sizeof(u64));
1940 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
1941 +
1942 + csmisas_get_device_address_exit:
1943 +
1944 + /* Copy the data from kernel memory to user memory
1945 + */
1946 + if (copy_to_user(uarg, &karg,
1947 + sizeof(CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER))) {
1948 + printk(KERN_ERR "%s@%d::%s() - "
1949 + "Unable to write out csmi_sas_get_device_address_buffer @ %p\n",
1950 + __FILE__, __LINE__, __FUNCTION__, uarg);
1951 + return -EFAULT;
1952 + }
1953 +
1954 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
1955 + return 0;
1956 +}
1957 +
1958 +/**
1959 + * Prototype Routine for the CSMI Sas Get Link Errors command.
1960 + *
1961 + * Outputs: None.
1962 + * Return: 0 if successful
1963 + * -EFAULT if data unavailable
1964 + * -ENODEV if no such device/adapter
1965 + **/
1966 +static int
1967 +csmisas_get_link_errors(unsigned long arg)
1968 +{
1969 + CSMI_SAS_LINK_ERRORS_BUFFER __user *uarg = (void __user *) arg;
1970 + CSMI_SAS_LINK_ERRORS_BUFFER karg;
1971 + MPT_ADAPTER *ioc = NULL;
1972 + MPT_FRAME_HDR *mf = NULL;
1973 + MPIHeader_t *mpi_hdr;
1974 + int iocnum;
1975 + int rc;
1976 + ConfigExtendedPageHeader_t hdr;
1977 + CONFIGPARMS cfg;
1978 + SasPhyPage1_t *sasPhyPage1;
1979 + dma_addr_t sasPhyPage1_dma;
1980 + int sasPhyPage1_data_sz;
1981 + SasIoUnitControlRequest_t *sasIoUnitCntrReq;
1982 + SasIoUnitControlReply_t *sasIoUnitCntrReply;
1983 + u8 phyId;
1984 + u16 ioc_status;
1985 + u32 MsgContext;
1986 +
1987 + sasPhyPage1=NULL;
1988 + sasPhyPage1_data_sz=0;
1989 +
1990 + if (copy_from_user(&karg, uarg,
1991 + sizeof(CSMI_SAS_LINK_ERRORS_BUFFER))) {
1992 + printk(KERN_ERR "%s@%d::%s() - "
1993 + "Unable to read in csmisas_get_link_errors struct @ %p\n",
1994 + __FILE__, __LINE__, __FUNCTION__, uarg);
1995 + return -EFAULT;
1996 + }
1997 +
1998 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
1999 + &ioc)) < 0) || (ioc == NULL)) {
2000 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
2001 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2002 + return -ENODEV;
2003 + }
2004 +
2005 + if (!csmisas_is_this_sas_cntr(ioc)) {
2006 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
2007 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2008 + return -ENODEV;
2009 + }
2010 +
2011 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
2012 + phyId = karg.Information.bPhyIdentifier;
2013 + if (phyId >= ioc->num_ports) {
2014 + karg.IoctlHeader.ReturnCode = CSMI_SAS_PHY_DOES_NOT_EXIST;
2015 + dcsmisasprintk(ioc, printk(KERN_WARNING ": phyId >= ioc->num_ports\n"));
2016 + goto cim_get_link_errors_exit;
2017 + }
2018 +
2019 + /* Default to success.*/
2020 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
2021 +
2022 + /* Issue a config request to get the devHandle of the attached device
2023 + */
2024 +
2025 + /* Issue a config request to get phy information. */
2026 + hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
2027 + hdr.ExtPageLength = 0;
2028 + hdr.PageNumber = 1 /* page number 1*/;
2029 + hdr.Reserved1 = 0;
2030 + hdr.Reserved2 = 0;
2031 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
2032 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
2033 +
2034 + cfg.cfghdr.ehdr = &hdr;
2035 + cfg.physAddr = -1;
2036 + cfg.pageAddr = phyId;
2037 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
2038 + cfg.dir = 0; /* read */
2039 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
2040 +
2041 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
2042 + /* Don't check if this failed. Already in a
2043 + * failure case.
2044 + */
2045 + dcsmisasprintk(ioc, printk(KERN_ERR
2046 + ": FAILED: MPI_SASPHY1_PAGEVERSION: HEADER\n"));
2047 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
2048 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2049 + goto cim_get_link_errors_exit;
2050 + }
2051 +
2052 + if (hdr.ExtPageLength == 0) {
2053 + /* Don't check if this failed. Already in a
2054 + * failure case.
2055 + */
2056 + dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
2057 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2058 + goto cim_get_link_errors_exit;
2059 + }
2060 +
2061 +
2062 + sasPhyPage1_data_sz = hdr.ExtPageLength * 4;
2063 + rc = -ENOMEM;
2064 +
2065 + sasPhyPage1 = (SasPhyPage1_t *) pci_alloc_consistent(ioc->pcidev,
2066 + sasPhyPage1_data_sz, &sasPhyPage1_dma);
2067 +
2068 + if (! sasPhyPage1) {
2069 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
2070 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2071 + goto cim_get_link_errors_exit;
2072 + }
2073 +
2074 + memset((u8 *)sasPhyPage1, 0, sasPhyPage1_data_sz);
2075 + cfg.physAddr = sasPhyPage1_dma;
2076 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
2077 +
2078 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
2079 + /* Don't check if this failed. Already in a
2080 + * failure case.
2081 + */
2082 + dcsmisasprintk(ioc, printk(KERN_ERR ": FAILED: MPI_SASPHY1_PAGEVERSION: PAGE\n"));
2083 + dcsmisasprintk(ioc, printk(KERN_ERR ": rc=%x\n",rc));
2084 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2085 + goto cim_get_link_errors_exit;
2086 + }
2087 +
2088 +/* EDM : dump PHY Page 1 data*/
2089 + dcsmisasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 1 ------------\n"));
2090 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Invalid Dword Count=0x%x\n",
2091 + sasPhyPage1->InvalidDwordCount));
2092 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Running Disparity Error Count=0x%x\n",
2093 + sasPhyPage1->RunningDisparityErrorCount));
2094 + dcsmisasprintk(ioc, printk(KERN_DEBUG "Loss Dword Synch Count=0x%x\n",
2095 + sasPhyPage1->LossDwordSynchCount));
2096 + dcsmisasprintk(ioc, printk(KERN_DEBUG "PHY Reset Problem Count=0x%x\n",
2097 + sasPhyPage1->PhyResetProblemCount));
2098 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n\n"));
2099 +/* EDM : debug data */
2100 +
2101 + karg.Information.uInvalidDwordCount =
2102 + le32_to_cpu(sasPhyPage1->InvalidDwordCount);
2103 + karg.Information.uRunningDisparityErrorCount =
2104 + le32_to_cpu(sasPhyPage1->RunningDisparityErrorCount);
2105 + karg.Information.uLossOfDwordSyncCount =
2106 + le32_to_cpu(sasPhyPage1->LossDwordSynchCount);
2107 + karg.Information.uPhyResetProblemCount =
2108 + le32_to_cpu(sasPhyPage1->PhyResetProblemCount);
2109 +
2110 + if (karg.Information.bResetCounts ==
2111 + CSMI_SAS_LINK_ERROR_DONT_RESET_COUNTS ) {
2112 + goto cim_get_link_errors_exit;
2113 + }
2114 +
2115 + /* Clear Error log
2116 + *
2117 + * Issue IOUNIT Control Reqeust Message
2118 + */
2119 +
2120 + /* Get a MF for this command.
2121 + */
2122 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2123 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
2124 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2125 + goto cim_get_link_errors_exit;
2126 + }
2127 +
2128 + mpi_hdr = (MPIHeader_t *) mf;
2129 + MsgContext = mpi_hdr->MsgContext;
2130 + sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
2131 + memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
2132 + sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
2133 + sasIoUnitCntrReq->MsgContext = MsgContext;
2134 + sasIoUnitCntrReq->PhyNum = phyId;
2135 + sasIoUnitCntrReq->Operation = MPI_SAS_OP_PHY_CLEAR_ERROR_LOG;
2136 +
2137 + if (csmisas_send_command_wait(ioc, mf, karg.IoctlHeader.Timeout) != 0) {
2138 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2139 + goto cim_get_link_errors_exit;
2140 + }
2141 +
2142 + /* process the completed Reply Message Frame */
2143 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2144 +
2145 + sasIoUnitCntrReply =
2146 + (SasIoUnitControlReply_t *)ioc->ioctl_cmds.reply;
2147 + ioc_status = le16_to_cpu(sasIoUnitCntrReply->IOCStatus)
2148 + & MPI_IOCSTATUS_MASK;
2149 +
2150 + if (ioc_status != MPI_IOCSTATUS_SUCCESS) {
2151 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": SAS IO Unit Control: "));
2152 + dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X\n",
2153 + sasIoUnitCntrReply->IOCStatus,
2154 + sasIoUnitCntrReply->IOCLogInfo));
2155 + }
2156 + }
2157 +
2158 + cim_get_link_errors_exit:
2159 +
2160 + if (sasPhyPage1)
2161 + pci_free_consistent(ioc->pcidev, sasPhyPage1_data_sz,
2162 + (u8 *) sasPhyPage1, sasPhyPage1_dma);
2163 +
2164 + /* Copy the data from kernel memory to user memory
2165 + */
2166 + if (copy_to_user(uarg, &karg,
2167 + sizeof(CSMI_SAS_LINK_ERRORS_BUFFER))) {
2168 + printk(KERN_ERR "%s@%d::%s() - "
2169 + "Unable to write out csmisas_get_link_errors @ %p\n",
2170 + __FILE__, __LINE__, __FUNCTION__, uarg);
2171 + return -EFAULT;
2172 + }
2173 +
2174 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
2175 + return 0;
2176 +
2177 +}
2178 +
2179 +/**
2180 + * Prototype Routine for the CSMI SAS SMP Passthru command.
2181 + *
2182 + * Outputs: None.
2183 + * Return: 0 if successful
2184 + * -EFAULT if data unavailable
2185 + * -ENODEV if no such device/adapter
2186 + **/
2187 +static int
2188 +csmisas_smp_passthru(unsigned long arg)
2189 +{
2190 + CSMI_SAS_SMP_PASSTHRU_BUFFER __user *uarg = (void __user *) arg;
2191 + MPT_ADAPTER *ioc;
2192 + CSMI_SAS_SMP_PASSTHRU_BUFFER *karg;
2193 + pSmpPassthroughRequest_t smpReq;
2194 + pSmpPassthroughReply_t smpReply;
2195 + MPT_FRAME_HDR *mf = NULL;
2196 + MPIHeader_t *mpi_hdr;
2197 + char *psge;
2198 + int iocnum, flagsLength;
2199 + void * request_data;
2200 + dma_addr_t request_data_dma;
2201 + u32 request_data_sz;
2202 + void * response_data;
2203 + dma_addr_t response_data_dma;
2204 + u32 response_data_sz;
2205 + u16 ioc_status;
2206 + u64 sas_address;
2207 + u32 MsgContext;
2208 + int malloc_data_sz;
2209 + int memory_pages;
2210 +
2211 + malloc_data_sz = sizeof(CSMI_SAS_SMP_PASSTHRU_BUFFER);
2212 + memory_pages = get_order(malloc_data_sz);
2213 + karg = (CSMI_SAS_SMP_PASSTHRU_BUFFER *)__get_free_pages(
2214 + GFP_KERNEL, memory_pages);
2215 + if (!karg){
2216 + printk(KERN_ERR "%s@%d::%s() - "
2217 + "Unable to malloc CSMI_SAS_SMP_PASSTHRU_BUFFER "
2218 + "malloc_data_sz=%d memory_pages=%d\n",
2219 + __FILE__, __LINE__, __FUNCTION__,
2220 + malloc_data_sz, memory_pages);
2221 + return -ENOMEM;
2222 + }
2223 +
2224 + if (copy_from_user(karg, uarg, sizeof(CSMI_SAS_SMP_PASSTHRU_BUFFER))) {
2225 + printk(KERN_ERR "%s@%d::%s() - "
2226 + "Unable to read in csmi_sas_smp_passthru struct @ %p\n",
2227 + __FILE__, __LINE__, __FUNCTION__, uarg);
2228 + free_pages((unsigned long)karg, memory_pages);
2229 + return -EFAULT;
2230 + }
2231 +
2232 + request_data = NULL;
2233 + response_data = NULL;
2234 + response_data_sz = sizeof(CSMI_SAS_SMP_RESPONSE);
2235 + request_data_sz = karg->Parameters.uRequestLength;
2236 +
2237 + if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
2238 + &ioc)) < 0) || (ioc == NULL)) {
2239 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
2240 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2241 + free_pages((unsigned long)karg, memory_pages);
2242 + return -ENODEV;
2243 + }
2244 +
2245 + if (ioc->ioc_reset_in_progress) {
2246 + printk(KERN_ERR "%s@%d::%s - "
2247 + "Busy with IOC Reset \n",
2248 + __FILE__, __LINE__,__FUNCTION__);
2249 + free_pages((unsigned long)karg, memory_pages);
2250 + return -EBUSY;
2251 + }
2252 +
2253 + if (!csmisas_is_this_sas_cntr(ioc)) {
2254 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
2255 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2256 + free_pages((unsigned long)karg, memory_pages);
2257 + return -ENODEV;
2258 + }
2259 +
2260 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
2261 +
2262 + /* Default to success.*/
2263 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
2264 +
2265 + /* Do some error checking on the request. */
2266 + if (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT) {
2267 + karg->IoctlHeader.ReturnCode = CSMI_SAS_SELECT_PHY_OR_PORT;
2268 + goto cim_smp_passthru_exit;
2269 + }
2270 +
2271 + if ((request_data_sz > 0xFFFF) || (!request_data_sz)) {
2272 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2273 + goto cim_smp_passthru_exit;
2274 + }
2275 +
2276 + /* Get a free request frame and save the message context.
2277 + */
2278 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2279 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
2280 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2281 + goto cim_smp_passthru_exit;
2282 + }
2283 +
2284 + mpi_hdr = (MPIHeader_t *) mf;
2285 + MsgContext = mpi_hdr->MsgContext;
2286 + smpReq = (pSmpPassthroughRequest_t ) mf;
2287 +
2288 + memset(smpReq,0,ioc->req_sz);
2289 +
2290 + memcpy(&sas_address, karg->Parameters.bDestinationSASAddress,
2291 + sizeof(u64));
2292 + sas_address = cpu_to_le64(reverse_byte_order64(sas_address));
2293 + memcpy(&smpReq->SASAddress, &sas_address, sizeof(u64));
2294 +
2295 + /* Fill in smp request. */
2296 + smpReq->PhysicalPort = karg->Parameters.bPortIdentifier;
2297 + smpReq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
2298 + smpReq->RequestDataLength = cpu_to_le16(request_data_sz);
2299 + smpReq->ConnectionRate = karg->Parameters.bConnectionRate;
2300 + smpReq->MsgContext = MsgContext;
2301 + smpReq->Reserved2 = 0;
2302 + smpReq->Reserved3 = 0;
2303 +
2304 + /*
2305 + * Prepare the necessary pointers to run
2306 + * through the SGL generation
2307 + */
2308 +
2309 + psge = (char *)&smpReq->SGL;
2310 +
2311 + /* setup the *Request* payload SGE */
2312 + flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2313 + MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2314 + MPI_SGE_FLAGS_HOST_TO_IOC |
2315 + MPI_SGE_FLAGS_END_OF_BUFFER;
2316 +
2317 + flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2318 + flagsLength |= request_data_sz;
2319 +
2320 + request_data = pci_alloc_consistent(
2321 + ioc->pcidev, request_data_sz, &request_data_dma);
2322 +
2323 + if (!request_data) {
2324 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
2325 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2326 + mpt_free_msg_frame(ioc, mf);
2327 + goto cim_smp_passthru_exit;
2328 + }
2329 +
2330 + ioc->add_sge(psge, flagsLength, request_data_dma);
2331 + psge += ioc->SGE_size;
2332 +
2333 + memcpy(request_data, &karg->Parameters.Request, request_data_sz);
2334 +
2335 + /* setup the *Response* payload SGE */
2336 + response_data = pci_alloc_consistent(
2337 + ioc->pcidev, response_data_sz, &response_data_dma);
2338 +
2339 + if (!response_data) {
2340 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
2341 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2342 + mpt_free_msg_frame(ioc, mf);
2343 + goto cim_smp_passthru_exit;
2344 + }
2345 +
2346 + flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2347 + MPI_SGE_FLAGS_SYSTEM_ADDRESS |
2348 + MPI_SGE_FLAGS_IOC_TO_HOST |
2349 + MPI_SGE_FLAGS_END_OF_BUFFER;
2350 +
2351 + flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
2352 + flagsLength |= response_data_sz;
2353 +
2354 + ioc->add_sge(psge, flagsLength, response_data_dma);
2355 +
2356 + if (csmisas_send_command_wait(ioc, mf, karg->IoctlHeader.Timeout) != 0) {
2357 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2358 + goto cim_smp_passthru_exit;
2359 + }
2360 +
2361 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
2362 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": SMP Passthru: oh no, there is no reply!!"));
2363 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2364 + goto cim_smp_passthru_exit;
2365 + }
2366 +
2367 + /* process the completed Reply Message Frame */
2368 + smpReply = (pSmpPassthroughReply_t )ioc->ioctl_cmds.reply;
2369 + ioc_status = le16_to_cpu(smpReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2370 +
2371 + if ((ioc_status != MPI_IOCSTATUS_SUCCESS) &&
2372 + (ioc_status != MPI_IOCSTATUS_SCSI_DATA_UNDERRUN)) {
2373 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2374 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": SMP Passthru: "));
2375 + dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X SASStatus=0x%X\n",
2376 + le16_to_cpu(smpReply->IOCStatus),
2377 + le32_to_cpu(smpReply->IOCLogInfo),
2378 + smpReply->SASStatus));
2379 + goto cim_smp_passthru_exit;
2380 + }
2381 +
2382 + karg->Parameters.bConnectionStatus =
2383 + map_sas_status_to_csmi(smpReply->SASStatus);
2384 +
2385 +
2386 + if (le16_to_cpu(smpReply->ResponseDataLength)) {
2387 + karg->Parameters.uResponseBytes = le16_to_cpu(smpReply->ResponseDataLength);
2388 + memcpy(&karg->Parameters.Response,
2389 + response_data, le16_to_cpu(smpReply->ResponseDataLength));
2390 + }
2391 +
2392 + cim_smp_passthru_exit:
2393 +
2394 + if (request_data)
2395 + pci_free_consistent(ioc->pcidev, request_data_sz,
2396 + (u8 *)request_data, request_data_dma);
2397 +
2398 + if (response_data)
2399 + pci_free_consistent(ioc->pcidev, response_data_sz,
2400 + (u8 *)response_data, response_data_dma);
2401 +
2402 +
2403 + /* Copy the data from kernel memory to user memory
2404 + */
2405 + if (copy_to_user(uarg, karg,
2406 + sizeof(CSMI_SAS_SMP_PASSTHRU_BUFFER))) {
2407 + printk(KERN_ERR "%s@%d::%s() - "
2408 + "Unable to write out csmi_sas_smp_passthru @ %p\n",
2409 + __FILE__, __LINE__, __FUNCTION__, uarg);
2410 + free_pages((unsigned long)karg, memory_pages);
2411 + return -EFAULT;
2412 + }
2413 +
2414 + free_pages((unsigned long)karg, memory_pages);
2415 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": %s exit.\n",__FUNCTION__));
2416 + return 0;
2417 +}
2418 +
2419 +/**
2420 + * Prototype Routine for the CSMI SAS SSP Passthru command.
2421 + *
2422 + * Outputs: None.
2423 + * Return: 0 if successful
2424 + * -EFAULT if data unavailable
2425 + * -ENODEV if no such device/adapter
2426 + **/
2427 +static int csmisas_ssp_passthru(unsigned long arg)
2428 +{
2429 + CSMI_SAS_SSP_PASSTHRU_BUFFER __user *uarg = (void __user *) arg;
2430 + CSMI_SAS_SSP_PASSTHRU_BUFFER karg_hdr, * karg;
2431 + MPT_ADAPTER *ioc = NULL;
2432 + pSCSIIORequest_t pScsiRequest;
2433 + pSCSIIOReply_t pScsiReply;
2434 + MPT_FRAME_HDR *mf = NULL;
2435 + MPIHeader_t *mpi_hdr;
2436 + int iocnum,ii;
2437 + u64 sas_address;
2438 + u16 req_idx;
2439 + char *psge;
2440 + int flagsLength;
2441 + void * request_data;
2442 + dma_addr_t request_data_dma;
2443 + u32 request_data_sz;
2444 + int malloc_data_sz;
2445 + int memory_pages;
2446 + u16 ioc_status;
2447 + u8 volume_id;
2448 + u8 volume_bus;
2449 + u8 is_hidden_raid_component;
2450 + u8 channel;
2451 + u8 id;
2452 + struct sas_device_info *sas_info;
2453 + u8 skey, asc, ascq;
2454 + u32 MsgContext;
2455 +
2456 + if (copy_from_user(&karg_hdr, uarg, sizeof(CSMI_SAS_SSP_PASSTHRU_BUFFER))) {
2457 + printk(KERN_ERR "%s@%d::%s() - "
2458 + "Unable to read in csmi_sas_ssp_passthru struct @ %p\n",
2459 + __FILE__, __LINE__, __FUNCTION__, uarg);
2460 + return -EFAULT;
2461 + }
2462 +
2463 + request_data = NULL;
2464 + request_data_sz = karg_hdr.Parameters.uDataLength;
2465 + channel = 0;
2466 + id = 0;
2467 + volume_id = 0;
2468 + volume_bus = 0;
2469 + is_hidden_raid_component = 0;
2470 +
2471 + malloc_data_sz = (request_data_sz +
2472 + offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER, bDataBuffer));
2473 + memory_pages = get_order(malloc_data_sz);
2474 + karg = (CSMI_SAS_SSP_PASSTHRU_BUFFER *)__get_free_pages(
2475 + GFP_KERNEL, memory_pages);
2476 + if (!karg){
2477 + printk(KERN_ERR "%s@%d::%s() - "
2478 + "Unable to malloc SAS_SSP_PASSTHRU_BUFFER "
2479 + "malloc_data_sz=%d memory_pages=%d\n",
2480 + __FILE__, __LINE__, __FUNCTION__,
2481 + malloc_data_sz, memory_pages);
2482 + return -ENOMEM;
2483 + }
2484 +
2485 + memset(karg, 0, sizeof(*karg));
2486 +
2487 + if (copy_from_user(karg, uarg, request_data_sz +
2488 + offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER,bDataBuffer))) {
2489 + printk(KERN_ERR "%s@%d::%s() - "
2490 + "Unable to read in csmi_sas_ssp_passthru struct @ %p\n",
2491 + __FILE__, __LINE__, __FUNCTION__, uarg);
2492 + free_pages((unsigned long)karg, memory_pages);
2493 + return -EFAULT;
2494 + }
2495 +
2496 + /*
2497 + * some checks of the incoming frame
2498 + */
2499 + if ( offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER,bDataBuffer) +
2500 + request_data_sz - sizeof(IOCTL_HEADER) >
2501 + karg->IoctlHeader.Length ) {
2502 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
2503 + dcsmisasprintk(ioc, printk(KERN_ERR
2504 + "%s::%s()"
2505 + " @%d - expected datalen incorrect!\n",
2506 + __FILE__, __FUNCTION__, __LINE__));
2507 + goto cim_ssp_passthru_exit;
2508 + }
2509 +
2510 + if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
2511 + &ioc)) < 0) || (ioc == NULL)) {
2512 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
2513 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
2514 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2515 + goto cim_ssp_passthru_exit;
2516 + }
2517 +
2518 + if (ioc->ioc_reset_in_progress) {
2519 + printk(KERN_ERR "%s@%d::%s - "
2520 + "Busy with IOC Reset \n",
2521 + __FILE__, __LINE__,__FUNCTION__);
2522 + return -EBUSY;
2523 + }
2524 +
2525 + if (!csmisas_is_this_sas_cntr(ioc)) {
2526 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
2527 + printk(KERN_ERR "%s::%s()@%d - ioc%d not SAS controller!\n",
2528 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2529 + goto cim_ssp_passthru_exit;
2530 + }
2531 +
2532 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
2533 +
2534 + /* Default to success.
2535 + */
2536 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
2537 +
2538 + /* Neither a phy nor a port has been selected.
2539 + */
2540 + if ((karg->Parameters.bPhyIdentifier == CSMI_SAS_USE_PORT_IDENTIFIER) &&
2541 + (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT)) {
2542 + karg->IoctlHeader.ReturnCode = CSMI_SAS_SELECT_PHY_OR_PORT;
2543 + dcsmisasprintk(ioc, printk(KERN_ERR
2544 + "%s::%s()"
2545 + " @%d - incorrect bPhyIdentifier and bPortIdentifier!\n",
2546 + __FILE__, __FUNCTION__, __LINE__));
2547 + goto cim_ssp_passthru_exit;
2548 + }
2549 +
2550 + /* A phy has been selected. Verify that it's valid.
2551 + */
2552 + if (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT) {
2553 +
2554 + /* Is the phy in range? */
2555 + if (karg->Parameters.bPhyIdentifier >= ioc->num_ports) {
2556 + dcsmisasprintk(ioc, printk(KERN_WARNING ": phyId >= ioc->num_ports (%d %d)\n",
2557 + karg->Parameters.bPhyIdentifier,
2558 + ioc->num_ports));
2559 + karg->IoctlHeader.ReturnCode =
2560 + CSMI_SAS_PHY_DOES_NOT_EXIST;
2561 + goto cim_ssp_passthru_exit;
2562 + }
2563 + }
2564 +
2565 + if(karg->Parameters.bAdditionalCDBLength) {
2566 + /* TODO - SCSI IO (32) Request Message support
2567 + */
2568 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": greater than 16-byte cdb "
2569 + "is not supported!\n"));
2570 + karg->IoctlHeader.ReturnCode =
2571 + CSMI_SAS_STATUS_INVALID_PARAMETER;
2572 + goto cim_ssp_passthru_exit;
2573 + }
2574 +
2575 + /* we will use SAS address to resolve the scsi adddressing
2576 + */
2577 + memcpy(&sas_address, karg->Parameters.bDestinationSASAddress,
2578 + sizeof(u64));
2579 + sas_address = reverse_byte_order64(sas_address);
2580 +
2581 + /* Search the list for the matching SAS address.
2582 + */
2583 + sas_info = csmisas_get_device_component_by_sas_addr(ioc, sas_address);
2584 + if (!sas_info || sas_info->is_cached) {
2585 + /*
2586 + *Invalid SAS address
2587 + */
2588 + karg->IoctlHeader.ReturnCode =
2589 + CSMI_SAS_STATUS_INVALID_PARAMETER;
2590 + dcsmisasprintk(ioc, printk(KERN_ERR
2591 + "%s::%s() @%d - couldn't find associated "
2592 + "SASAddress=%llX!\n", __FILE__, __FUNCTION__, __LINE__,
2593 + (unsigned long long)sas_address));
2594 + goto cim_ssp_passthru_exit;
2595 + }
2596 +
2597 + id = sas_info->fw.id;
2598 + channel = sas_info->fw.channel;
2599 +
2600 + if (csmisas_is_phys_disk(ioc, channel, id)) {
2601 + id = csmisas_raid_id_to_num(ioc, channel, id);
2602 + channel = 0;
2603 + is_hidden_raid_component = 1;
2604 + }
2605 +
2606 + /* Get a free request frame and save the message context.
2607 + */
2608 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
2609 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
2610 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2611 + goto cim_ssp_passthru_exit;
2612 + }
2613 +
2614 + mpi_hdr = (MPIHeader_t *) mf;
2615 + MsgContext = mpi_hdr->MsgContext;
2616 + pScsiRequest = (pSCSIIORequest_t) mf;
2617 + req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
2618 +
2619 + memset(pScsiRequest,0,sizeof(SCSIIORequest_t));
2620 +
2621 + /* Fill in SCSI IO (16) request.
2622 + */
2623 +
2624 + pScsiRequest->Function = (is_hidden_raid_component == 1) ?
2625 + MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH : MPI_FUNCTION_SCSI_IO_REQUEST;
2626 + pScsiRequest->TargetID = id;
2627 + pScsiRequest->Bus = channel;
2628 + memcpy(pScsiRequest->LUN, &karg->Parameters.bLun, 8);
2629 + pScsiRequest->CDBLength = karg->Parameters.bCDBLength;
2630 + pScsiRequest->DataLength = cpu_to_le32(request_data_sz);
2631 + pScsiRequest->MsgContext = MsgContext;
2632 + memcpy(pScsiRequest->CDB, karg->Parameters.bCDB,
2633 + pScsiRequest->CDBLength);
2634 +
2635 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\tchannel = %d id = %d ",
2636 + sas_info->fw.channel, sas_info->fw.id));
2637 + dcsmisasprintk(ioc, if(is_hidden_raid_component)
2638 + printk(KERN_DEBUG "num_id = %d ", id));
2639 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
2640 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\tcdb_len = %d request_len = %d\n",
2641 + pScsiRequest->CDBLength, request_data_sz));
2642 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\t"));
2643 + dcsmisasprintk(ioc, for (ii = 0; ii < pScsiRequest->CDBLength; ++ii)
2644 + printk(" %02x", pScsiRequest->CDB[ii]));
2645 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\n"));
2646 +
2647 + /* direction
2648 + */
2649 + if (karg->Parameters.uFlags & CSMI_SAS_SSP_READ) {
2650 + pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_READ);
2651 + } else if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE) {
2652 + pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_WRITE);
2653 + } else if ((karg->Parameters.uFlags & CSMI_SAS_SSP_UNSPECIFIED) &&
2654 + (!karg->Parameters.uDataLength)) {
2655 + /* no data transfer
2656 + */
2657 + pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_NODATATRANSFER);
2658 + } else {
2659 + /* no direction specified
2660 + */
2661 + pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_READ);
2662 + pScsiRequest->MsgFlags =
2663 + MPI_SCSIIO_MSGFLGS_CMD_DETERMINES_DATA_DIR;
2664 + }
2665 +
2666 + pScsiRequest->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
2667 + if (ioc->sg_addr_size == sizeof(u64))
2668 + pScsiRequest->MsgFlags |= MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64;
2669 +
2670 + /* task attributes
2671 + */
2672 + if((karg->Parameters.uFlags && 0xFF) == 0) {
2673 + pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_SIMPLEQ);
2674 + } else if (karg->Parameters.uFlags &
2675 + CSMI_SAS_SSP_TASK_ATTRIBUTE_HEAD_OF_QUEUE) {
2676 + pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_HEADOFQ);
2677 + } else if (karg->Parameters.uFlags &
2678 + CSMI_SAS_SSP_TASK_ATTRIBUTE_ORDERED) {
2679 + pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_ORDEREDQ);
2680 + } else if (karg->Parameters.uFlags &
2681 + CSMI_SAS_SSP_TASK_ATTRIBUTE_ACA) {
2682 + pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_ACAQ);
2683 + } else {
2684 + pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_UNTAGGED);
2685 + }
2686 +
2687 + /* setup sense
2688 + */
2689 + pScsiRequest->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
2690 + pScsiRequest->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma +
2691 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
2692 +
2693 + /* setup databuffer sg, assuming we fit everything one contiguous buffer
2694 + */
2695 + psge = (char *)&pScsiRequest->SGL;
2696 +
2697 + if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE) {
2698 + flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
2699 + } else if (karg->Parameters.uFlags & CSMI_SAS_SSP_READ) {
2700 + flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
2701 + }else {
2702 + flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
2703 + MPI_SGE_FLAGS_DIRECTION )
2704 + << MPI_SGE_FLAGS_SHIFT;
2705 + }
2706 + flagsLength |= request_data_sz;
2707 +
2708 + if ( request_data_sz > 0) {
2709 + request_data = pci_alloc_consistent(
2710 + ioc->pcidev, request_data_sz, &request_data_dma);
2711 +
2712 + if (request_data == NULL) {
2713 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED "
2714 + "request_data_sz=%d\n", request_data_sz));
2715 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2716 + mpt_free_msg_frame(ioc, mf);
2717 + goto cim_ssp_passthru_exit;
2718 + }
2719 +
2720 + ioc->add_sge(psge, flagsLength, request_data_dma);
2721 + if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE)
2722 + memcpy(request_data, karg->bDataBuffer, request_data_sz);
2723 + } else {
2724 + ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
2725 + }
2726 +
2727 + if (csmisas_send_command_wait(ioc, mf, karg->IoctlHeader.Timeout) != 0) {
2728 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2729 + goto cim_ssp_passthru_exit;
2730 + }
2731 +
2732 + memset(&karg->Status,0,sizeof(CSMI_SAS_SSP_PASSTHRU_STATUS));
2733 + karg->Status.bConnectionStatus = CSMI_SAS_OPEN_ACCEPT;
2734 + karg->Status.bDataPresent = CSMI_SAS_SSP_NO_DATA_PRESENT;
2735 + karg->Status.bStatus = GOOD;
2736 + karg->Status.bResponseLength[0] = 0;
2737 + karg->Status.bResponseLength[1] = 0;
2738 + karg->Status.uDataBytes = request_data_sz;
2739 +
2740 + /* process the completed Reply Message Frame */
2741 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
2742 +
2743 + pScsiReply = (pSCSIIOReply_t ) ioc->ioctl_cmds.reply;
2744 + karg->Status.bStatus = pScsiReply->SCSIStatus;
2745 + karg->Status.uDataBytes = min(le32_to_cpu(pScsiReply->TransferCount),
2746 + request_data_sz);
2747 + ioc_status = le16_to_cpu(pScsiReply->IOCStatus) & MPI_IOCSTATUS_MASK;
2748 +
2749 + if (pScsiReply->SCSIState ==
2750 + MPI_SCSI_STATE_AUTOSENSE_VALID) {
2751 + karg->Status.bConnectionStatus =
2752 + CSMI_SAS_SSP_SENSE_DATA_PRESENT;
2753 + karg->Status.bResponseLength[0] =
2754 + (u8)le32_to_cpu(pScsiReply->SenseCount) & 0xFF;
2755 + memcpy(karg->Status.bResponse,
2756 + ioc->ioctl_cmds.sense, le32_to_cpu(pScsiReply->SenseCount));
2757 +
2758 + skey = ioc->ioctl_cmds.sense[2] & 0x0F;
2759 + asc = ioc->ioctl_cmds.sense[12];
2760 + ascq = ioc->ioctl_cmds.sense[13];
2761 +
2762 + dcsmisasprintk(ioc, printk(KERN_DEBUG "\t [sense_key,asc,ascq]: "
2763 + "[0x%02x,0x%02x,0x%02x]\n",
2764 + skey, asc, ascq));
2765 +
2766 + } else if(pScsiReply->SCSIState ==
2767 + MPI_SCSI_STATE_RESPONSE_INFO_VALID) {
2768 + karg->Status.bDataPresent =
2769 + CSMI_SAS_SSP_RESPONSE_DATA_PRESENT;
2770 + karg->Status.bResponseLength[0] =
2771 + sizeof(pScsiReply->ResponseInfo);
2772 + for (ii=0;ii<sizeof(pScsiReply->ResponseInfo);ii++) {
2773 + karg->Status.bResponse[ii] =
2774 + ((u8*)&pScsiReply->ResponseInfo)[
2775 + (sizeof(pScsiReply->ResponseInfo)-1)-ii];
2776 + }
2777 + } else if ((ioc_status != MPI_IOCSTATUS_SUCCESS) &&
2778 + (ioc_status != MPI_IOCSTATUS_SCSI_RECOVERED_ERROR) &&
2779 + (ioc_status != MPI_IOCSTATUS_SCSI_DATA_UNDERRUN)) {
2780 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2781 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": SCSI IO : "));
2782 + dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X\n",
2783 + pScsiReply->IOCStatus,
2784 + pScsiReply->IOCLogInfo));
2785 + }
2786 + }
2787 +
2788 + if ((karg->Status.uDataBytes) && (request_data) &&
2789 + (karg->Parameters.uFlags & CSMI_SAS_SSP_READ)) {
2790 + if (copy_to_user((void __user *)uarg->bDataBuffer,
2791 + request_data, karg->Status.uDataBytes)) {
2792 + printk(KERN_ERR "%s@%d::%s - "
2793 + "Unable to write data to user %p\n",
2794 + __FILE__, __LINE__,__FUNCTION__,
2795 + (void*)karg->bDataBuffer);
2796 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
2797 + }
2798 + }
2799 +
2800 + cim_ssp_passthru_exit:
2801 +
2802 +
2803 + if (request_data)
2804 + pci_free_consistent(ioc->pcidev, request_data_sz,
2805 + (u8 *)request_data, request_data_dma);
2806 +
2807 + /* Copy the data from kernel memory to user memory
2808 + */
2809 + if (copy_to_user(uarg, karg,
2810 + offsetof(CSMI_SAS_SSP_PASSTHRU_BUFFER, bDataBuffer))) {
2811 + printk(KERN_ERR "%s@%d::%s() - "
2812 + "Unable to write out csmi_sas_ssp_passthru @ %p\n",
2813 + __FILE__, __LINE__, __FUNCTION__, uarg);
2814 + free_pages((unsigned long)karg, memory_pages);
2815 + return -EFAULT;
2816 + }
2817 +
2818 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
2819 + free_pages((unsigned long)karg, memory_pages);
2820 + return 0;
2821 +}
2822 +
2823 +/**
2824 + * Prototype Routine for the CSMI SAS STP Passthru command.
2825 + *
2826 + * Outputs: None.
2827 + * Return: 0 if successful
2828 + * -EFAULT if data unavailable
2829 + * -ENODEV if no such device/adapter
2830 + **/
2831 +static int
2832 +csmisas_stp_passthru(unsigned long arg)
2833 +{
2834 + CSMI_SAS_STP_PASSTHRU_BUFFER __user *uarg = (void __user *) arg;
2835 + CSMI_SAS_STP_PASSTHRU_BUFFER karg_hdr, *karg;
2836 + MPT_ADAPTER *ioc = NULL;
2837 + pSataPassthroughRequest_t pSataRequest;
2838 + pSataPassthroughReply_t pSataReply;
2839 + MPT_FRAME_HDR *mf = NULL;
2840 + MPIHeader_t *mpi_hdr;
2841 + int iocnum;
2842 + u32 data_sz;
2843 + u64 sas_address;
2844 + u16 req_idx;
2845 + char *psge;
2846 + int flagsLength;
2847 + void * request_data;
2848 + dma_addr_t request_data_dma;
2849 + u32 request_data_sz;
2850 + int malloc_data_sz;
2851 + int memory_pages;
2852 + u8 channel;
2853 + u8 id;
2854 + u8 volume_id;
2855 + u8 volume_bus;
2856 + struct sas_device_info *sas_info;
2857 + u16 ioc_status;
2858 + u32 MsgContext;
2859 +
2860 + if (copy_from_user(&karg_hdr, uarg, sizeof(CSMI_SAS_STP_PASSTHRU_BUFFER))) {
2861 + printk(KERN_ERR "%s@%d::%s() - "
2862 + "Unable to read struct @ %p\n",
2863 + __FILE__, __LINE__, __FUNCTION__, uarg);
2864 + return -EFAULT;
2865 + }
2866 +
2867 + request_data=NULL;
2868 + request_data_sz = karg_hdr.Parameters.uDataLength;
2869 + volume_id = 0;
2870 + volume_bus = 0;
2871 + channel = 0;
2872 + id = 0;
2873 +
2874 + malloc_data_sz = (request_data_sz +
2875 + offsetof(CSMI_SAS_STP_PASSTHRU_BUFFER, bDataBuffer));
2876 + memory_pages = get_order(malloc_data_sz);
2877 + karg = (CSMI_SAS_STP_PASSTHRU_BUFFER *)__get_free_pages(
2878 + GFP_KERNEL, memory_pages);
2879 + if (!karg){
2880 + printk(KERN_ERR "%s@%d::%s() - "
2881 + "Unable to malloc CSMI_SAS_STP_PASSTHRU_BUFFER "
2882 + "malloc_data_sz=%d memory_pages=%d\n",
2883 + __FILE__, __LINE__, __FUNCTION__,
2884 + malloc_data_sz, memory_pages);
2885 + return -ENOMEM;
2886 + }
2887 +
2888 + memset(karg, 0, sizeof(*karg));
2889 +
2890 + if (copy_from_user(karg, uarg, malloc_data_sz)) {
2891 + printk(KERN_ERR "%s@%d::%s() - "
2892 + "Unable to read in csmi_sas_ssp_passthru struct @ %p\n",
2893 + __FILE__, __LINE__, __FUNCTION__, uarg);
2894 + free_pages((unsigned long)karg, memory_pages);
2895 + return -EFAULT;
2896 + }
2897 +
2898 + if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
2899 + &ioc)) < 0) || (ioc == NULL)) {
2900 + printk(KERN_ERR "%s::%s @%d - ioc%d not found!\n",
2901 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2902 + free_pages((unsigned long)karg, memory_pages);
2903 + return -ENODEV;
2904 + }
2905 +
2906 + if (ioc->ioc_reset_in_progress) {
2907 + printk(KERN_ERR "%s@%d::%s - "
2908 + "Busy with IOC Reset \n",
2909 + __FILE__, __LINE__,__FUNCTION__);
2910 + free_pages((unsigned long)karg, memory_pages);
2911 + return -EBUSY;
2912 + }
2913 +
2914 + if (!csmisas_is_this_sas_cntr(ioc)) {
2915 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
2916 + __FILE__, __FUNCTION__, __LINE__, iocnum);
2917 + free_pages((unsigned long)karg, memory_pages);
2918 + return -ENODEV;
2919 + }
2920 +
2921 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
2922 +
2923 + /* Default to success.
2924 + */
2925 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
2926 +
2927 + /* Neither a phy nor a port has been selected.
2928 + */
2929 + if ((karg->Parameters.bPhyIdentifier == CSMI_SAS_USE_PORT_IDENTIFIER) &&
2930 + (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT)) {
2931 + karg->IoctlHeader.ReturnCode = CSMI_SAS_SELECT_PHY_OR_PORT;
2932 + dcsmisasprintk(ioc, printk(KERN_ERR
2933 + "%s::%s() @%d - incorrect bPhyIdentifier and bPortIdentifier!\n",
2934 + __FILE__,__FUNCTION__, __LINE__));
2935 + goto cim_stp_passthru_exit;
2936 + }
2937 +
2938 + /* A phy has been selected. Verify that it's valid.
2939 + */
2940 + if (karg->Parameters.bPortIdentifier == CSMI_SAS_IGNORE_PORT) {
2941 +
2942 + /* Is the phy in range? */
2943 + if (karg->Parameters.bPhyIdentifier >= ioc->num_ports) {
2944 + karg->IoctlHeader.ReturnCode =
2945 + CSMI_SAS_PHY_DOES_NOT_EXIST;
2946 + goto cim_stp_passthru_exit;
2947 + }
2948 + }
2949 +
2950 + data_sz = sizeof(CSMI_SAS_STP_PASSTHRU_BUFFER) -
2951 + sizeof(IOCTL_HEADER) - sizeof(u8*) +
2952 + request_data_sz;
2953 +
2954 + if ( data_sz > karg->IoctlHeader.Length ) {
2955 + karg->IoctlHeader.ReturnCode =
2956 + CSMI_SAS_STATUS_INVALID_PARAMETER;
2957 + dcsmisasprintk(ioc, printk(KERN_ERR
2958 + "%s::%s() @%d - expected datalen incorrect!\n",
2959 + __FILE__, __FUNCTION__,__LINE__));
2960 + goto cim_stp_passthru_exit;
2961 + }
2962 +
2963 +
2964 + /* we will use SAS address to resolve the scsi adddressing
2965 + */
2966 + memcpy(&sas_address, karg->Parameters.bDestinationSASAddress,
2967 + sizeof(u64));
2968 + sas_address = reverse_byte_order64(sas_address);
2969 +
2970 + /* Search the list for the matching SAS address.
2971 + */
2972 + sas_info = csmisas_get_device_component_by_sas_addr(ioc, sas_address);
2973 + if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume) {
2974 + /*
2975 + *Invalid SAS address
2976 + */
2977 + karg->IoctlHeader.ReturnCode =
2978 + CSMI_SAS_STATUS_INVALID_PARAMETER;
2979 + dcsmisasprintk(ioc, printk(KERN_ERR
2980 + "%s::%s() @%d - couldn't find associated "
2981 + "SASAddress=%llX!\n", __FILE__, __FUNCTION__, __LINE__,
2982 + (unsigned long long)sas_address));
2983 + goto cim_stp_passthru_exit;
2984 + }
2985 +
2986 + id = sas_info->fw.id;
2987 + channel = sas_info->fw.channel;
2988 +
2989 + /* check that this is an STP or SATA target device
2990 + */
2991 + if ( !(sas_info->device_info & MPI_SAS_DEVICE_INFO_STP_TARGET ) &&
2992 + !(sas_info->device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE )) {
2993 + karg->IoctlHeader.ReturnCode =
2994 + CSMI_SAS_STATUS_INVALID_PARAMETER;
2995 + goto cim_stp_passthru_exit;
2996 + }
2997 +
2998 + /* Get a free request frame and save the message context.
2999 + */
3000 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
3001 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
3002 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3003 + goto cim_stp_passthru_exit;
3004 + }
3005 +
3006 + mpi_hdr = (MPIHeader_t *) mf;
3007 + MsgContext = mpi_hdr->MsgContext;
3008 + pSataRequest = (pSataPassthroughRequest_t) mf;
3009 + req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3010 +
3011 + memset(pSataRequest,0,sizeof(pSataPassthroughRequest_t));
3012 +
3013 + pSataRequest->TargetID = id;
3014 + pSataRequest->Bus = channel;
3015 + pSataRequest->Function = MPI_FUNCTION_SATA_PASSTHROUGH;
3016 + pSataRequest->PassthroughFlags = cpu_to_le16(karg->Parameters.uFlags);
3017 + pSataRequest->ConnectionRate = karg->Parameters.bConnectionRate;
3018 + pSataRequest->MsgContext = MsgContext;
3019 + pSataRequest->DataLength = cpu_to_le32(request_data_sz);
3020 + pSataRequest->MsgFlags = 0;
3021 + memcpy( pSataRequest->CommandFIS,karg->Parameters.bCommandFIS, 20);
3022 +
3023 + psge = (char *)&pSataRequest->SGL;
3024 + if (karg->Parameters.uFlags & CSMI_SAS_STP_WRITE) {
3025 + flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
3026 + } else if (karg->Parameters.uFlags & CSMI_SAS_STP_READ) {
3027 + flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
3028 + }else {
3029 + flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
3030 + MPI_SGE_FLAGS_DIRECTION )
3031 + << MPI_SGE_FLAGS_SHIFT;
3032 + }
3033 +
3034 + flagsLength |= request_data_sz;
3035 + if (request_data_sz > 0) {
3036 + request_data = pci_alloc_consistent(
3037 + ioc->pcidev, request_data_sz, &request_data_dma);
3038 +
3039 + if (request_data == NULL) {
3040 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
3041 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3042 + mpt_free_msg_frame(ioc, mf);
3043 + goto cim_stp_passthru_exit;
3044 + }
3045 +
3046 + ioc->add_sge(psge, flagsLength, request_data_dma);
3047 + if (karg->Parameters.uFlags & CSMI_SAS_SSP_WRITE)
3048 + memcpy(request_data, karg->bDataBuffer, request_data_sz);
3049 + } else {
3050 + ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
3051 + }
3052 +
3053 + if (csmisas_send_command_wait(ioc, mf, karg->IoctlHeader.Timeout) != 0) {
3054 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3055 + goto cim_stp_passthru_exit;
3056 + }
3057 +
3058 + memset(&karg->Status,0,sizeof(CSMI_SAS_STP_PASSTHRU_STATUS));
3059 +
3060 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
3061 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": STP Passthru: oh no, there is no reply!!"));
3062 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3063 + goto cim_stp_passthru_exit;
3064 + }
3065 +
3066 + /* process the completed Reply Message Frame */
3067 + pSataReply = (pSataPassthroughReply_t ) ioc->ioctl_cmds.reply;
3068 + ioc_status = le16_to_cpu(pSataReply->IOCStatus) & MPI_IOCSTATUS_MASK;
3069 +
3070 + if (ioc_status != MPI_IOCSTATUS_SUCCESS &&
3071 + ioc_status != MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) {
3072 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3073 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": STP Passthru: "));
3074 + dcsmisasprintk(ioc, printk("IOCStatus=0x%X IOCLogInfo=0x%X SASStatus=0x%X\n",
3075 + le16_to_cpu(pSataReply->IOCStatus),
3076 + le32_to_cpu(pSataReply->IOCLogInfo),
3077 + pSataReply->SASStatus));
3078 + }
3079 +
3080 + karg->Status.bConnectionStatus =
3081 + map_sas_status_to_csmi(pSataReply->SASStatus);
3082 +
3083 + memcpy(karg->Status.bStatusFIS,pSataReply->StatusFIS, 20);
3084 +
3085 + /*
3086 + * for now, just zero out uSCR array,
3087 + * then copy the one dword returned
3088 + * in the reply frame into uSCR[0]
3089 + */
3090 + memset( karg->Status.uSCR, 0, 64);
3091 + karg->Status.uSCR[0] = le32_to_cpu(pSataReply->StatusControlRegisters);
3092 +
3093 + if((le32_to_cpu(pSataReply->TransferCount)) && (request_data) &&
3094 + (karg->Parameters.uFlags & CSMI_SAS_STP_READ)) {
3095 + karg->Status.uDataBytes =
3096 + min(le32_to_cpu(pSataReply->TransferCount),request_data_sz);
3097 + if (copy_to_user((void __user *)uarg->bDataBuffer,
3098 + request_data, karg->Status.uDataBytes)) {
3099 + printk(KERN_ERR "%s::%s() @%d - "
3100 + "Unable to write data to user %p\n",
3101 + __FILE__, __FUNCTION__, __LINE__,
3102 + (void*)karg->bDataBuffer);
3103 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3104 + }
3105 + }
3106 +
3107 + cim_stp_passthru_exit:
3108 +
3109 + if (request_data)
3110 + pci_free_consistent(ioc->pcidev, request_data_sz,
3111 + (u8 *)request_data, request_data_dma);
3112 +
3113 + /* Copy th data from kernel memory to user memory
3114 + */
3115 + if (copy_to_user(uarg, karg,
3116 + offsetof(CSMI_SAS_STP_PASSTHRU_BUFFER, bDataBuffer))) {
3117 + printk(KERN_ERR "%s@%d::%s() - "
3118 + "Unable to write out csmi_sas_ssp_passthru @ %p\n",
3119 + __FILE__, __LINE__, __FUNCTION__, uarg);
3120 + free_pages((unsigned long)karg, memory_pages);
3121 + return -EFAULT;
3122 + }
3123 +
3124 + free_pages((unsigned long)karg, memory_pages);
3125 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": %s exit.\n",__FUNCTION__));
3126 + return 0;
3127 +}
3128 +
3129 +/**
3130 + * Prototype Routine for the CSMI SAS Firmware Download command.
3131 + *
3132 + * Outputs: None.
3133 + * Return: 0 if successful
3134 + * -EFAULT if data unavailable
3135 + * -ENODEV if no such device/adapter
3136 + **/
3137 +static int
3138 +csmisas_firmware_download(unsigned long arg)
3139 +{
3140 + CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER __user *uarg = (void __user *) arg;
3141 + CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER karg;
3142 + MPT_ADAPTER *ioc = NULL;
3143 + int iocnum;
3144 + pMpiFwHeader_t pFwHeader=NULL;
3145 +
3146 + if (copy_from_user(&karg, uarg,
3147 + sizeof(CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER))) {
3148 + printk(KERN_ERR "%s@%d::%s() - "
3149 + "Unable to read in csmi_sas_firmware_download struct @ %p\n",
3150 + __FILE__, __LINE__, __FUNCTION__, uarg);
3151 + return -EFAULT;
3152 + }
3153 +
3154 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
3155 + &ioc)) < 0) || (ioc == NULL)) {
3156 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
3157 + __FILE__, __FUNCTION__, __LINE__, iocnum);
3158 + return -ENODEV;
3159 + }
3160 +
3161 + if (!csmisas_is_this_sas_cntr(ioc)) {
3162 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
3163 + __FILE__, __FUNCTION__, __LINE__, iocnum);
3164 + return -ENODEV;
3165 + }
3166 +
3167 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
3168 +
3169 + /* Default to success.*/
3170 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
3171 + karg.Information.usStatus = CSMI_SAS_FWD_SUCCESS;
3172 + karg.Information.usSeverity = CSMI_SAS_FWD_INFORMATION;
3173 +
3174 + /* some checks of the incoming frame */
3175 + if ((karg.Information.uBufferLength +
3176 + sizeof(CSMI_SAS_FIRMWARE_DOWNLOAD)) >
3177 + karg.IoctlHeader.Length) {
3178 + karg.IoctlHeader.ReturnCode =
3179 + CSMI_SAS_STATUS_INVALID_PARAMETER;
3180 + karg.Information.usStatus = CSMI_SAS_FWD_FAILED;
3181 + goto cim_firmware_download_exit;
3182 + }
3183 +
3184 + if ( karg.Information.uDownloadFlags &
3185 + (CSMI_SAS_FWD_SOFT_RESET | CSMI_SAS_FWD_VALIDATE)) {
3186 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3187 + karg.Information.usStatus = CSMI_SAS_FWD_REJECT;
3188 + karg.Information.usSeverity = CSMI_SAS_FWD_ERROR;
3189 + goto cim_firmware_download_exit;
3190 + }
3191 +
3192 + /* now we need to alloc memory so we can pull in the
3193 + * fw image attached to end of incoming packet.
3194 + */
3195 + pFwHeader = kmalloc(karg.Information.uBufferLength, GFP_KERNEL);
3196 + if (!pFwHeader){
3197 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3198 + karg.Information.usStatus = CSMI_SAS_FWD_REJECT;
3199 + karg.Information.usSeverity = CSMI_SAS_FWD_ERROR;
3200 + goto cim_firmware_download_exit;
3201 + }
3202 + memset(pFwHeader, 0, sizeof(*pFwHeader));
3203 +
3204 + if (copy_from_user(pFwHeader, uarg->bDataBuffer,
3205 + karg.Information.uBufferLength)) {
3206 + printk(KERN_ERR "%s@%d::%s() - "
3207 + "Unable to read in pFwHeader @ %p\n",
3208 + __FILE__, __LINE__, __FUNCTION__, uarg);
3209 + return -EFAULT;
3210 + }
3211 +
3212 + if ( !((pFwHeader->Signature0 == MPI_FW_HEADER_SIGNATURE_0) &&
3213 + (pFwHeader->Signature1 == MPI_FW_HEADER_SIGNATURE_1) &&
3214 + (pFwHeader->Signature2 == MPI_FW_HEADER_SIGNATURE_2))) {
3215 + // the signature check failed
3216 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3217 + karg.Information.usStatus = CSMI_SAS_FWD_REJECT;
3218 + karg.Information.usSeverity = CSMI_SAS_FWD_ERROR;
3219 + goto cim_firmware_download_exit;
3220 + }
3221 +
3222 + if ( mptctl_do_fw_download(karg.IoctlHeader.IOControllerNumber,
3223 + uarg->bDataBuffer, karg.Information.uBufferLength)
3224 + != 0) {
3225 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3226 + karg.Information.usStatus = CSMI_SAS_FWD_FAILED;
3227 + karg.Information.usSeverity = CSMI_SAS_FWD_FATAL;
3228 + goto cim_firmware_download_exit;
3229 + }
3230 +
3231 + if((karg.Information.uDownloadFlags & CSMI_SAS_FWD_SOFT_RESET) ||
3232 + (karg.Information.uDownloadFlags & CSMI_SAS_FWD_HARD_RESET)) {
3233 + if (mpt_HardResetHandler(ioc, CAN_SLEEP) != 0) {
3234 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3235 + karg.Information.usStatus = CSMI_SAS_FWD_FAILED;
3236 + karg.Information.usSeverity = CSMI_SAS_FWD_FATAL;
3237 + }
3238 + }
3239 +
3240 + cim_firmware_download_exit:
3241 +
3242 + if(pFwHeader)
3243 + kfree(pFwHeader);
3244 +
3245 + /* Copy the data from kernel memory to user memory
3246 + */
3247 + if (copy_to_user(uarg, &karg,
3248 + sizeof(CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER))) {
3249 + printk(KERN_ERR "%s@%d::%s() - "
3250 + "Unable to write out csmi_sas_firmware_download @ %p\n",
3251 + __FILE__, __LINE__, __FUNCTION__, uarg);
3252 + return -EFAULT;
3253 + }
3254 +
3255 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
3256 + return 0;
3257 +}
3258 +
3259 +/**
3260 + * Prototype Routine for the CSMI SAS Get RAID Info command.
3261 + *
3262 + * Outputs: None.
3263 + * Return: 0 if successful
3264 + * -EFAULT if data unavailable
3265 + * -ENODEV if no such device/adapter
3266 + **/
3267 +static int
3268 +csmisas_get_raid_info(unsigned long arg)
3269 +{
3270 + CSMI_SAS_RAID_INFO_BUFFER __user *uarg = (void __user *) arg;
3271 + CSMI_SAS_RAID_INFO_BUFFER karg;
3272 + MPT_ADAPTER *ioc = NULL;
3273 + int iocnum;
3274 + u32 raidFlags;
3275 + u8 maxRaidTypes;
3276 + u8 maxDrivesPerSet;
3277 +
3278 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_RAID_INFO_BUFFER))) {
3279 + printk(KERN_ERR "%s@%d::%s() - "
3280 + "Unable to read in csmi_sas_get_raid_info struct @ %p\n",
3281 + __FILE__, __LINE__, __FUNCTION__, uarg);
3282 + return -EFAULT;
3283 + }
3284 +
3285 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
3286 + &ioc)) < 0) || (ioc == NULL)) {
3287 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
3288 + __FILE__, __FUNCTION__, __LINE__, iocnum);
3289 + return -ENODEV;
3290 + }
3291 +
3292 + if (!csmisas_is_this_sas_cntr(ioc)) {
3293 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
3294 + __FILE__, __FUNCTION__, __LINE__, iocnum);
3295 + return -ENODEV;
3296 + }
3297 +
3298 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
3299 +
3300 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3301 + if (!ioc->raid_data.pIocPg2)
3302 + goto csmisas_get_raid_info_out;
3303 + karg.Information.uNumRaidSets =
3304 + ioc->raid_data.pIocPg2->NumActiveVolumes;
3305 + karg.Information.uMaxRaidSets = ioc->raid_data.pIocPg2->MaxVolumes;
3306 + if( ioc->raid_data.pIocPg6 ) {
3307 + // get absolute maximum for all RAID sets
3308 + maxDrivesPerSet = ioc->raid_data.pIocPg6->MaxDrivesIS;
3309 + maxDrivesPerSet = max(ioc->raid_data.pIocPg6->MaxDrivesIM,
3310 + maxDrivesPerSet);
3311 + maxDrivesPerSet = max(ioc->raid_data.pIocPg6->MaxDrivesIME,
3312 + maxDrivesPerSet);
3313 + karg.Information.uMaxDrivesPerSet = maxDrivesPerSet;
3314 + }
3315 + else
3316 + karg.Information.uMaxDrivesPerSet = 8;
3317 + // For bMaxRaidSets, count bits set in bits 0-6 of CapabilitiesFlags
3318 + raidFlags = ioc->raid_data.pIocPg2->CapabilitiesFlags & 0x0000007F;
3319 + for( maxRaidTypes=0; raidFlags; maxRaidTypes++ )
3320 + raidFlags &= raidFlags - 1;
3321 + karg.Information.bMaxRaidTypes = maxRaidTypes;
3322 + // ulMinRaidSetBlocks hard coded to 1MB until available from config page
3323 + karg.Information.ulMinRaidSetBlocks.uLowPart = 2048;
3324 + karg.Information.ulMinRaidSetBlocks.uHighPart = 0;
3325 + karg.Information.ulMaxRaidSetBlocks.uLowPart = 0xffffffff;
3326 + if( ioc->raid_data.pIocPg2->CapabilitiesFlags &
3327 + MPI_IOCPAGE2_CAP_FLAGS_RAID_64_BIT_ADDRESSING )
3328 + karg.Information.ulMaxRaidSetBlocks.uHighPart = 0xffffffff;
3329 + else
3330 + karg.Information.ulMaxRaidSetBlocks.uHighPart = 0;
3331 + karg.Information.uMaxPhysicalDrives =
3332 + ioc->raid_data.pIocPg2->MaxPhysDisks;
3333 + karg.Information.uMaxExtents = 1;
3334 + karg.Information.uMaxModules = 0;
3335 + karg.Information.uMaxTransformationMemory = 0;
3336 + karg.Information.uChangeCount = ioc->csmi_change_count;
3337 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
3338 +
3339 +csmisas_get_raid_info_out:
3340 +
3341 + /* Copy the data from kernel memory to user memory
3342 + */
3343 + if (copy_to_user(uarg, &karg,
3344 + sizeof(CSMI_SAS_RAID_INFO_BUFFER))) {
3345 + printk(KERN_ERR "%s@%d::%s() - "
3346 + "Unable to write out csmi_sas_get_raid_info @ %p\n",
3347 + __FILE__, __LINE__, __FUNCTION__, uarg);
3348 + return -EFAULT;
3349 + }
3350 +
3351 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
3352 + return 0;
3353 +}
3354 +
3355 +/**
3356 + * csmisas_do_raid - Format and Issue a RAID volume request message.
3357 + * @ioc: Pointer to MPT_ADAPTER structure
3358 + * @action: What do be done.
3359 + * @PhysDiskNum: Logical target id.
3360 + * @VolumeBus: Target locations bus.
3361 + * @VolumeId: Volume id
3362 + *
3363 + * Returns: < 0 on a fatal error
3364 + * 0 on success
3365 + *
3366 + * Remark: Wait to return until reply processed by the ISR.
3367 + **/
3368 +static int
3369 +csmisas_do_raid(MPT_ADAPTER *ioc, u8 action, u8 PhysDiskNum, u8 VolumeBus, u8 VolumeId, pMpiRaidActionReply_t reply)
3370 +{
3371 + MpiRaidActionRequest_t *pReq;
3372 + MpiRaidActionReply_t *pReply;
3373 + MPT_FRAME_HDR *mf;
3374 +
3375 + /* Get and Populate a free Frame
3376 + */
3377 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
3378 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
3379 + return -EAGAIN;
3380 + }
3381 + pReq = (MpiRaidActionRequest_t *)mf;
3382 + pReq->Action = action;
3383 + pReq->Reserved1 = 0;
3384 + pReq->ChainOffset = 0;
3385 + pReq->Function = MPI_FUNCTION_RAID_ACTION;
3386 + pReq->VolumeID = VolumeId;
3387 + pReq->VolumeBus = VolumeBus;
3388 + pReq->PhysDiskNum = PhysDiskNum;
3389 + pReq->MsgFlags = 0;
3390 + pReq->Reserved2 = 0;
3391 + pReq->ActionDataWord = 0; /* Reserved for this action */
3392 + //pReq->ActionDataSGE = 0;
3393 +
3394 + ioc->add_sge((char *)&pReq->ActionDataSGE,
3395 + MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
3396 +
3397 + if (csmisas_send_command_wait(ioc, mf, MPT_IOCTL_DEFAULT_TIMEOUT) != 0)
3398 + return -ENODATA;
3399 +
3400 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) &&
3401 + (reply != NULL)){
3402 + pReply = (MpiRaidActionReply_t *)&(ioc->ioctl_cmds.reply);
3403 + memcpy(reply, pReply,
3404 + min(ioc->reply_sz,
3405 + 4*pReply->MsgLength));
3406 + }
3407 +
3408 + return 0;
3409 +}
3410 +
3411 +/**
3412 + * csmisas_raid_inq
3413 + * @ioc = per host instance
3414 + * @opcode = MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH or
3415 + * MPI_FUNCTION_SCSI_IO_REQUEST
3416 + * @id = target id
3417 + * @bus = target bus
3418 + * @inq_vpd = inquiry data, returned
3419 + * @inq_vpd_sz = maximum size of inquiry data
3420 + *
3421 + * Return = 0(sucess), non-zero(failure)
3422 + **/
3423 +static int
3424 +csmisas_raid_inq(MPT_ADAPTER *ioc, u8 opcode, u8 bus, u8 id, u8 inq_vpd_page,
3425 + u8 * inq_vpd, u32 inq_vpd_sz)
3426 +{
3427 + MPT_FRAME_HDR *mf = NULL;
3428 + MPIHeader_t *mpi_hdr;
3429 + pSCSIIORequest_t pScsiRequest;
3430 + u16 req_idx;
3431 + char *psge;
3432 + u8 inq_vpd_cdb[6];
3433 + u8 *request_data=NULL;
3434 + dma_addr_t request_data_dma;
3435 + u32 request_data_sz;
3436 + int rc = 0;
3437 + u32 MsgContext;
3438 +
3439 + request_data_sz = inq_vpd_sz;
3440 +
3441 + /* fill-in cdb */
3442 + memset(inq_vpd_cdb, 0, sizeof(inq_vpd_cdb));
3443 + inq_vpd_cdb[0] = 0x12;
3444 + if (inq_vpd_page) {
3445 + inq_vpd_cdb[1] = 0x01; /* evpd bit */
3446 + inq_vpd_cdb[2] = inq_vpd_page;
3447 + }
3448 + inq_vpd_cdb[3] = (u8)(request_data_sz >> 8);
3449 + inq_vpd_cdb[4] = (u8)request_data_sz;
3450 +
3451 + /* Get a free request frame and save the message context.
3452 + */
3453 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
3454 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
3455 + goto csmisas_raid_inq_exit;
3456 + }
3457 +
3458 + mpi_hdr = (MPIHeader_t *) mf;
3459 + MsgContext = mpi_hdr->MsgContext;
3460 + pScsiRequest = (pSCSIIORequest_t) mf;
3461 + req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
3462 +
3463 + memset(pScsiRequest,0,sizeof(SCSIIORequest_t));
3464 + pScsiRequest->Function = opcode;
3465 + pScsiRequest->TargetID = id;
3466 + pScsiRequest->Bus = bus;
3467 + pScsiRequest->CDBLength = 6;
3468 + pScsiRequest->DataLength = cpu_to_le32(request_data_sz);
3469 + pScsiRequest->MsgContext = MsgContext;
3470 + memcpy(pScsiRequest->CDB,inq_vpd_cdb,pScsiRequest->CDBLength);
3471 + pScsiRequest->Control = cpu_to_le32(MPI_SCSIIO_CONTROL_READ);
3472 + pScsiRequest->Control |= cpu_to_le32(MPI_SCSIIO_CONTROL_SIMPLEQ);
3473 + pScsiRequest->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
3474 + if (ioc->sg_addr_size == sizeof(u64))
3475 + pScsiRequest->MsgFlags |= MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64;
3476 +
3477 + /* setup sense
3478 + */
3479 + pScsiRequest->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
3480 + pScsiRequest->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma +
3481 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
3482 +
3483 + request_data = pci_alloc_consistent(
3484 + ioc->pcidev, request_data_sz, &request_data_dma);
3485 +
3486 + if (request_data == NULL) {
3487 + mpt_free_msg_frame(ioc, mf);
3488 + rc=-1;
3489 + goto csmisas_raid_inq_exit;
3490 + }
3491 +
3492 + memset(request_data,0,request_data_sz);
3493 + psge = (char *)&pScsiRequest->SGL;
3494 + ioc->add_sge(psge, (MPT_SGE_FLAGS_SSIMPLE_READ | 0xFC) ,
3495 + request_data_dma);
3496 +
3497 + if (csmisas_send_command_wait(ioc, mf, MPT_IOCTL_DEFAULT_TIMEOUT) != 0) {
3498 + rc=-1;
3499 + goto csmisas_raid_inq_exit;
3500 + }
3501 +
3502 + /* copy the request_data */
3503 + memcpy(inq_vpd, request_data, request_data_sz);
3504 +
3505 + csmisas_raid_inq_exit:
3506 +
3507 + if (request_data)
3508 + pci_free_consistent(ioc->pcidev, request_data_sz,
3509 + request_data, request_data_dma);
3510 +
3511 + return rc;
3512 +}
3513 +
3514 +/**
3515 + * Prototype Routine for the CSMI SAS Get RAID Config command.
3516 + *
3517 + * Outputs: None.
3518 + * Return: 0 if successful
3519 + * -EFAULT if data unavailable
3520 + * -ENODEV if no such device/adapter
3521 + **/
3522 +static int
3523 +csmisas_get_raid_config(unsigned long arg)
3524 +{
3525 + CSMI_SAS_RAID_CONFIG_BUFFER __user *uarg = (void __user *) arg;
3526 + CSMI_SAS_RAID_CONFIG_BUFFER karg,*pKarg=NULL;
3527 + CONFIGPARMS cfg;
3528 + ConfigPageHeader_t header;
3529 + MPT_ADAPTER *ioc = NULL;
3530 + int iocnum;
3531 + u8 volumeID, VolumeBus;
3532 + u8 physDiskNum, physDiskNumMax;
3533 + int volumepage0sz = 0;
3534 + int physdiskpage0sz = 0, ioc_page5_sz = 0;
3535 + dma_addr_t volume0_dma, physdisk0_dma;
3536 + dma_addr_t ioc_page5_dma = 0;
3537 + pRaidVolumePage0_t pVolume0 = NULL;
3538 + pRaidPhysDiskPage0_t pPhysDisk0 = NULL;
3539 + pMpiRaidActionReply_t pRaidActionReply = NULL;
3540 + u32 device_info = 0;
3541 + pIOCPage5_t pIocPage5 = NULL;
3542 + int i, idx, csmi_sas_raid_config_buffer_sz;
3543 + int memory_pages;
3544 + int copy_buffer_sz = 0;
3545 + u64 totalMaxLBA, tmpTotalMaxLBA;
3546 + u64 sas_address;
3547 + struct sas_device_info *sas_info;
3548 +
3549 + if (copy_from_user(&karg, uarg, sizeof(IOCTL_HEADER))) {
3550 + printk(KERN_ERR "%s@%d::%s() - "
3551 + "Unable to read in csmisas_get_raid_config struct @ %p\n",
3552 + __FILE__, __LINE__, __FUNCTION__, uarg);
3553 + return -EFAULT;
3554 + }
3555 +
3556 + csmi_sas_raid_config_buffer_sz = karg.IoctlHeader.Length;
3557 + memory_pages = get_order(csmi_sas_raid_config_buffer_sz);
3558 + pKarg = (CSMI_SAS_RAID_CONFIG_BUFFER *)__get_free_pages(
3559 + GFP_KERNEL, memory_pages);
3560 + if (!pKarg){
3561 + printk(KERN_ERR "%s@%d::%s() - "
3562 + "Unable to malloc RAID_CONFIG_BUFFER "
3563 + "csmi_sas_raid_config_buffer_sz=%d memory_pages=%d\n",
3564 + __FILE__, __LINE__, __FUNCTION__,
3565 + csmi_sas_raid_config_buffer_sz, memory_pages);
3566 + return -ENOMEM;
3567 + }
3568 + memset(pKarg, 0, sizeof(*pKarg));
3569 +
3570 + if (copy_from_user(pKarg, uarg, csmi_sas_raid_config_buffer_sz)) {
3571 + printk(KERN_ERR "%s@%d::%s() - "
3572 + "Unable to read in csmisas_get_raid_config struct @ %p\n",
3573 + __FILE__, __LINE__, __FUNCTION__, uarg);
3574 + free_pages((unsigned long)pKarg, memory_pages);
3575 + return -EFAULT;
3576 + }
3577 +
3578 + if (((iocnum = mpt_verify_adapter(pKarg->IoctlHeader.IOControllerNumber,
3579 + &ioc)) < 0) || (ioc == NULL)) {
3580 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
3581 + __FILE__, __FUNCTION__, __LINE__, iocnum);
3582 + free_pages((unsigned long)pKarg, memory_pages);
3583 + return -ENODEV;
3584 + }
3585 +
3586 + if (!csmisas_is_this_sas_cntr(ioc)) {
3587 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
3588 + __FILE__, __FUNCTION__, __LINE__, iocnum);
3589 + free_pages((unsigned long)pKarg, memory_pages);
3590 + return -ENODEV;
3591 + }
3592 +
3593 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
3594 +
3595 + if (pKarg->Configuration.uChangeCount != 0 &&
3596 + pKarg->Configuration.uChangeCount != ioc->csmi_change_count ) {
3597 + pKarg->IoctlHeader.ReturnCode =
3598 + CSMI_SAS_STATUS_INVALID_PARAMETER;
3599 + pKarg->Configuration.uFailureCode =
3600 + CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID;
3601 + goto cim_get_raid_config_exit;
3602 + }
3603 +
3604 + if (!ioc->raid_data.pIocPg2) {
3605 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3606 + goto cim_get_raid_config_exit;
3607 + }
3608 +
3609 + /*
3610 + * Check to see if the input uRaidSetIndex is
3611 + * greater than the number of RAID sets
3612 + */
3613 + if (pKarg->Configuration.uRaidSetIndex >=
3614 + ioc->raid_data.pIocPg2->NumActiveVolumes) {
3615 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_RAID_SET_OUT_OF_RANGE;
3616 + goto cim_get_raid_config_exit;
3617 + }
3618 +
3619 + /*
3620 + * get RAID Volume Page 0
3621 + */
3622 + volumeID = ioc->raid_data.pIocPg2->RaidVolume[pKarg->Configuration.uRaidSetIndex].VolumeID;
3623 + VolumeBus = ioc->raid_data.pIocPg2->RaidVolume[pKarg->Configuration.uRaidSetIndex].VolumeBus;
3624 +
3625 + header.PageVersion = 0;
3626 + header.PageLength = 0;
3627 + header.PageNumber = 0;
3628 + header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
3629 + cfg.cfghdr.hdr = &header;
3630 + cfg.physAddr = -1;
3631 + cfg.pageAddr = (VolumeBus << 8) + volumeID;
3632 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
3633 + cfg.dir = 0;
3634 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
3635 + if (mpt_config(ioc, &cfg) != 0) {
3636 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3637 + goto cim_get_raid_config_exit;
3638 + }
3639 +
3640 + if (header.PageLength == 0) {
3641 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3642 + goto cim_get_raid_config_exit;
3643 + }
3644 +
3645 + volumepage0sz = header.PageLength * 4;
3646 + pVolume0 = pci_alloc_consistent(ioc->pcidev, volumepage0sz,
3647 + &volume0_dma);
3648 + if (!pVolume0) {
3649 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3650 + goto cim_get_raid_config_exit;
3651 + }
3652 +
3653 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
3654 + cfg.physAddr = volume0_dma;
3655 + if (mpt_config(ioc, &cfg) != 0) {
3656 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3657 + goto cim_get_raid_config_exit;
3658 + }
3659 +
3660 + totalMaxLBA = (u64)le32_to_cpu(pVolume0->MaxLBA) |
3661 + ((u64)le32_to_cpu(pVolume0->MaxLBAHigh)) << 32;
3662 + tmpTotalMaxLBA = totalMaxLBA + 1;
3663 + do_div(tmpTotalMaxLBA, 2048);
3664 + pKarg->Configuration.bDriveCount = 0;
3665 + pKarg->Configuration.uCapacity = tmpTotalMaxLBA;
3666 + pKarg->Configuration.uStripeSize =
3667 + le32_to_cpu(pVolume0->StripeSize)/2;
3668 +
3669 + switch(pVolume0->VolumeType) {
3670 + case MPI_RAID_VOL_TYPE_IS:
3671 + pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_0;
3672 + break;
3673 + case MPI_RAID_VOL_TYPE_IME:
3674 + pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_10;
3675 + break;
3676 + case MPI_RAID_VOL_TYPE_IM:
3677 + pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_1;
3678 + break;
3679 + default:
3680 + pKarg->Configuration.bRaidType = CSMI_SAS_RAID_TYPE_OTHER;
3681 + break;
3682 + }
3683 +
3684 + switch (pVolume0->VolumeStatus.State) {
3685 + case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
3686 + pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_OK;
3687 + break;
3688 + case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
3689 + /* Volume is degraded, check if Resyncing or Inactive */
3690 + pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_DEGRADED;
3691 + break;
3692 + case MPI_RAIDVOL0_STATUS_STATE_FAILED:
3693 + pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_FAILED;
3694 + break;
3695 + }
3696 +
3697 + /* check flags */
3698 + if (pVolume0->VolumeStatus.Flags &
3699 + MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE)
3700 + pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_OFFLINE;
3701 + else if (pVolume0->VolumeStatus.Flags &
3702 + MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)
3703 + pKarg->Configuration.bStatus = CSMI_SAS_RAID_SET_STATUS_REBUILDING;
3704 +
3705 + pKarg->Configuration.bInformation = 0; /* default */
3706 + if(pVolume0->VolumeStatus.Flags &
3707 + MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS ) {
3708 +
3709 + uint64_t * ptrUint64;
3710 + uint64_t totalBlocks64, blocksRemaining64;
3711 + uint32_t totalBlocks32, blocksRemaining32;
3712 +
3713 + /* get percentage complete */
3714 + pRaidActionReply = kmalloc( sizeof(MPI_RAID_VOL_INDICATOR) +
3715 + offsetof(MSG_RAID_ACTION_REPLY,ActionData),
3716 + GFP_KERNEL);
3717 +
3718 + if (!pRaidActionReply){
3719 + printk(KERN_ERR "%s@%d::%s() - "
3720 + "Unable to malloc @ %p\n",
3721 + __FILE__, __LINE__, __FUNCTION__,pKarg);
3722 + goto cim_get_raid_config_exit;
3723 + }
3724 + memset(pRaidActionReply, 0, sizeof(*pRaidActionReply));
3725 +
3726 + csmisas_do_raid(ioc,
3727 + MPI_RAID_ACTION_INDICATOR_STRUCT,
3728 + 0, VolumeBus, volumeID, pRaidActionReply);
3729 +
3730 + ptrUint64 = (uint64_t *)&pRaidActionReply->ActionData;
3731 + totalBlocks64 = *ptrUint64;
3732 + ptrUint64++;
3733 + blocksRemaining64 = *ptrUint64;
3734 + while(totalBlocks64 > 0xFFFFFFFFUL){
3735 + totalBlocks64 = totalBlocks64 >> 1;
3736 + blocksRemaining64 = blocksRemaining64 >> 1;
3737 + }
3738 + totalBlocks32 = (uint32_t)totalBlocks64;
3739 + blocksRemaining32 = (uint32_t)blocksRemaining64;
3740 +
3741 + if(totalBlocks32)
3742 + pKarg->Configuration.bInformation =
3743 + (totalBlocks32 - blocksRemaining32) /
3744 + (totalBlocks32 / 100);
3745 +
3746 + kfree(pRaidActionReply);
3747 + }
3748 +
3749 + /* fill-in more information depending on data type */
3750 + if (pKarg->Configuration.bDataType ==
3751 + CSMI_SAS_RAID_DATA_ADDITIONAL_DATA) {
3752 + pKarg->Configuration.Data->bLabel[0] = '\0';
3753 + pKarg->Configuration.Data->bRaidSetLun[1] = 0;
3754 + pKarg->Configuration.Data->bWriteProtection =
3755 + CSMI_SAS_RAID_SET_WRITE_PROTECT_UNKNOWN;
3756 + pKarg->Configuration.Data->bCacheSetting =
3757 + CSMI_SAS_RAID_SET_CACHE_UNKNOWN;
3758 + pKarg->Configuration.Data->bCacheRatio = 0;
3759 + pKarg->Configuration.Data->usBlockSize = 512;
3760 + pKarg->Configuration.Data->ulRaidSetExtentOffset.uLowPart = 0;
3761 + pKarg->Configuration.Data->ulRaidSetExtentOffset.uHighPart = 0;
3762 + pKarg->Configuration.Data->ulRaidSetBlocks.uLowPart =
3763 + le32_to_cpu(pVolume0->MaxLBA);
3764 + pKarg->Configuration.Data->ulRaidSetBlocks.uHighPart =
3765 + le32_to_cpu(pVolume0->MaxLBAHigh);
3766 + if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IS ||
3767 + pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IME ) {
3768 + pKarg->Configuration.Data->uStripeSizeInBlocks =
3769 + le32_to_cpu(pVolume0->StripeSize);
3770 + } else {
3771 + pKarg->Configuration.Data->uStripeSizeInBlocks = 0;
3772 + }
3773 + pKarg->Configuration.Data->uSectorsPerTrack = 128;
3774 + for (i=0; i<16; i++) {
3775 + // unsupported
3776 + pKarg->Configuration.Data->bApplicationScratchPad[i] =
3777 + 0xFF;
3778 + }
3779 + pKarg->Configuration.Data->uNumberOfHeads = 16;
3780 +
3781 + tmpTotalMaxLBA = totalMaxLBA;
3782 + do_div(tmpTotalMaxLBA,
3783 + (pKarg->Configuration.Data->uNumberOfHeads *
3784 + pKarg->Configuration.Data->uSectorsPerTrack));
3785 + pKarg->Configuration.Data->uNumberOfTracks = tmpTotalMaxLBA;
3786 + } else if ( pKarg->Configuration.bDataType ==
3787 + CSMI_SAS_RAID_DATA_DEVICE_ID ) {
3788 + /* Send inquiry to get VPD Page 0x83 */
3789 + u32 vpd_page_sz;
3790 + vpd_page_sz = csmi_sas_raid_config_buffer_sz -
3791 + offsetof(CSMI_SAS_RAID_CONFIG,DeviceId);
3792 + if (csmisas_raid_inq(ioc, MPI_FUNCTION_SCSI_IO_REQUEST,
3793 + VolumeBus, volumeID, 0x83,
3794 + (u8*)&pKarg->Configuration.DeviceId->bDeviceIdentificationVPDPage,
3795 + vpd_page_sz) != 0) {
3796 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3797 + goto cim_get_raid_config_exit;
3798 + }
3799 + } else {
3800 + /* suppress drive information */
3801 + if (pKarg->Configuration.bDriveCount ==
3802 + CSMI_SAS_RAID_DRIVE_COUNT_SUPRESSED) {
3803 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
3804 + goto cim_get_raid_config_exit;
3805 + }
3806 + }
3807 +
3808 + /* get hotspare info, used later in this function */
3809 + if (pVolume0->VolumeSettings.HotSparePool) {
3810 + /* Read and save IOC Page 5
3811 + */
3812 + header.PageVersion = 0;
3813 + header.PageLength = 0;
3814 + header.PageNumber = 5;
3815 + header.PageType = MPI_CONFIG_PAGETYPE_IOC;
3816 + cfg.cfghdr.hdr = &header;
3817 + cfg.physAddr = -1;
3818 + cfg.pageAddr = 0;
3819 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
3820 + cfg.dir = 0;
3821 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
3822 + if ((mpt_config(ioc, &cfg) == 0) && (header.PageLength)) {
3823 + ioc_page5_sz = header.PageLength * 4;
3824 + pIocPage5 = pci_alloc_consistent(ioc->pcidev,
3825 + ioc_page5_sz,
3826 + &ioc_page5_dma);
3827 + memset(pIocPage5,0,ioc_page5_sz);
3828 + if (ioc_page5_dma) {
3829 + cfg.physAddr = ioc_page5_dma;
3830 + cfg.action =
3831 + MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
3832 + mpt_config(ioc, &cfg);
3833 + }
3834 + }
3835 + }
3836 +
3837 + /*
3838 + * get RAID Physical Disk Page 0
3839 + */
3840 + header.PageVersion = 0;
3841 + header.PageLength = 0;
3842 + header.PageNumber = 0;
3843 + header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
3844 + cfg.cfghdr.hdr = &header;
3845 + cfg.physAddr = -1;
3846 + cfg.pageAddr = 0;
3847 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
3848 + cfg.dir = 0;
3849 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
3850 + if (mpt_config(ioc, &cfg) != 0) {
3851 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3852 + goto cim_get_raid_config_exit;
3853 + }
3854 +
3855 + if (header.PageLength == 0) {
3856 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3857 + goto cim_get_raid_config_exit;
3858 + }
3859 +
3860 + physdiskpage0sz = header.PageLength * 4;
3861 + pPhysDisk0 = pci_alloc_consistent(ioc->pcidev, physdiskpage0sz,
3862 + &physdisk0_dma);
3863 + if (!pPhysDisk0) {
3864 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3865 + goto cim_get_raid_config_exit;
3866 + }
3867 + cfg.physAddr = physdisk0_dma;
3868 +
3869 + physDiskNumMax = (csmi_sas_raid_config_buffer_sz -
3870 + offsetof(CSMI_SAS_RAID_CONFIG,Drives))
3871 + / sizeof(CSMI_SAS_RAID_DRIVES);
3872 +
3873 + tmpTotalMaxLBA = totalMaxLBA;
3874 + if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IS) {
3875 + do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks);
3876 + dcsmisasprintk(ioc, printk(KERN_DEBUG "IS Volume tmpTotalMaxLBA=%llX\n",
3877 + (unsigned long long)tmpTotalMaxLBA));
3878 + }
3879 + else if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IME) {
3880 + do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks * 2);
3881 + dcsmisasprintk(ioc, printk(KERN_DEBUG "IME Volume tmpTotalMaxLBA=%llX\n",
3882 + (unsigned long long)tmpTotalMaxLBA));
3883 + } else {
3884 + dcsmisasprintk(ioc, printk(KERN_DEBUG "IM Volume tmpTotalMaxLBA=%llX\n",
3885 + (unsigned long long)tmpTotalMaxLBA));
3886 + }
3887 +
3888 + for (i=0; i< min(pVolume0->NumPhysDisks, physDiskNumMax); i++) {
3889 +
3890 + physDiskNum = pVolume0->PhysDisk[i].PhysDiskNum;
3891 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
3892 + cfg.pageAddr = physDiskNum;
3893 + if (mpt_config(ioc, &cfg) != 0){
3894 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
3895 + goto cim_get_raid_config_exit;
3896 + }
3897 +
3898 + pKarg->Configuration.bDriveCount++;
3899 + if (pKarg->Configuration.bDataType != CSMI_SAS_RAID_DATA_DRIVES)
3900 + continue;
3901 +
3902 + /* Search the list for the matching SAS address. */
3903 + sas_info = csmisas_get_device_component_by_fw(ioc, pPhysDisk0->PhysDiskBus,
3904 + pPhysDisk0->PhysDiskID);
3905 + if (sas_info) {
3906 + sas_address = reverse_byte_order64(sas_info->sas_address);
3907 + memcpy(pKarg->Configuration.Drives[i].bSASAddress,
3908 + &sas_address,sizeof(u64));
3909 + if (!device_info)
3910 + device_info = sas_info->device_info;
3911 + }
3912 +
3913 + memcpy(pKarg->Configuration.Drives[i].bModel,
3914 + pPhysDisk0->InquiryData.VendorID,
3915 + offsetof(RAID_PHYS_DISK0_INQUIRY_DATA,ProductRevLevel));
3916 + memcpy(pKarg->Configuration.Drives[i].bFirmware,
3917 + pPhysDisk0->InquiryData.ProductRevLevel,
3918 + sizeof(pPhysDisk0->InquiryData.ProductRevLevel));
3919 + if (csmisas_is_sata(pPhysDisk0)) {
3920 + memcpy(&pKarg->Configuration.Drives[i].bSerialNumber,
3921 + &pPhysDisk0->ExtDiskIdentifier[4],
3922 + 4);
3923 + memcpy(&pKarg->Configuration.Drives[i].bSerialNumber[4],
3924 + &pPhysDisk0->DiskIdentifier,
3925 + sizeof(pPhysDisk0->DiskIdentifier));
3926 + } else {
3927 + memcpy(pKarg->Configuration.Drives[i].bSerialNumber,
3928 + pPhysDisk0->DiskIdentifier,
3929 + sizeof(pPhysDisk0->DiskIdentifier));
3930 + }
3931 +
3932 + pKarg->Configuration.Drives[i].bDriveUsage =
3933 + (pPhysDisk0->PhysDiskStatus.Flags &
3934 + MPI_PHYSDISK0_STATUS_FLAG_INACTIVE_VOLUME) ?
3935 + CSMI_SAS_DRIVE_CONFIG_NOT_USED :
3936 + CSMI_SAS_DRIVE_CONFIG_MEMBER;
3937 +
3938 + pKarg->Configuration.Drives[i].bDriveStatus =
3939 + CSMI_SAS_DRIVE_STATUS_OK;
3940 + if (pPhysDisk0->PhysDiskStatus.State ==
3941 + MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED) {
3942 + pKarg->Configuration.Drives[i].bDriveStatus =
3943 + CSMI_SAS_DRIVE_STATUS_OFFLINE;
3944 + } else if(pPhysDisk0->PhysDiskStatus.State) {
3945 + pKarg->Configuration.Drives[i].bDriveStatus =
3946 + CSMI_SAS_DRIVE_STATUS_FAILED;
3947 + if(pKarg->Configuration.bStatus ==
3948 + CSMI_SAS_RAID_SET_STATUS_DEGRADED)
3949 + pKarg->Configuration.bInformation = i;
3950 + } else if((pVolume0->VolumeStatus.Flags &
3951 + MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) &&
3952 + (pPhysDisk0->PhysDiskStatus.Flags &
3953 + MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC))
3954 + pKarg->Configuration.Drives[i].bDriveStatus =
3955 + CSMI_SAS_DRIVE_STATUS_REBUILDING;
3956 + else if(pPhysDisk0->ErrorData.SmartCount ||
3957 + (pPhysDisk0->PhysDiskStatus.Flags &
3958 + MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC))
3959 + pKarg->Configuration.Drives[i].bDriveStatus =
3960 + CSMI_SAS_DRIVE_STATUS_DEGRADED;
3961 +
3962 + memset(pKarg->Configuration.Drives[i].bSASLun,
3963 + 0, sizeof(pKarg->Configuration.Drives[i].bSASLun));
3964 + if (csmisas_is_sata(pPhysDisk0)) {
3965 + pKarg->Configuration.Drives[i].bDriveType =
3966 + CSMI_SAS_DRIVE_TYPE_SATA;
3967 + } else { /* drive in a volume can only be SAS/SATA */
3968 + pKarg->Configuration.Drives[i].bDriveType =
3969 + CSMI_SAS_DRIVE_TYPE_SINGLE_PORT_SAS;
3970 + if (mpt_raid_phys_disk_get_num_paths(ioc,
3971 + pVolume0->PhysDisk[i].PhysDiskNum) > 1)
3972 + pKarg->Configuration.Drives[i].bDriveType =
3973 + CSMI_SAS_DRIVE_TYPE_DUAL_PORT_SAS;
3974 + }
3975 +
3976 + pKarg->Configuration.Drives[i].usBlockSize = 512;
3977 + pKarg->Configuration.Drives[i].uDriveIndex =
3978 + pPhysDisk0->PhysDiskNum;
3979 + pKarg->Configuration.Drives[i].ulTotalUserBlocks.uLowPart =
3980 + (u32)tmpTotalMaxLBA;
3981 + pKarg->Configuration.Drives[i].ulTotalUserBlocks.uHighPart =
3982 + (u32)(tmpTotalMaxLBA >> 32);
3983 + }
3984 +
3985 + /* adding hot spare info at the end */
3986 + if ((pVolume0->VolumeSettings.HotSparePool) && (pIocPage5) &&
3987 + (pVolume0->VolumeType != MPI_RAID_VOL_TYPE_IS)) {
3988 + for (idx = 0, i = pVolume0->NumPhysDisks ;
3989 + idx < pIocPage5->NumHotSpares ; idx++) {
3990 + if (i >= physDiskNumMax)
3991 + break;
3992 + if ((pVolume0->VolumeSettings.HotSparePool &
3993 + pIocPage5->HotSpare[idx].HotSparePool) == 0)
3994 + continue;
3995 + if(pIocPage5->HotSpare[idx].Flags !=
3996 + MPI_IOC_PAGE_5_HOT_SPARE_ACTIVE)
3997 + continue;
3998 + physDiskNum = pIocPage5->HotSpare[idx].PhysDiskNum;
3999 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4000 + cfg.pageAddr = physDiskNum;
4001 + if (mpt_config(ioc, &cfg) != 0)
4002 + continue;
4003 +
4004 + /* don't mix SSP hot spare
4005 + * in SATA volume
4006 + */
4007 + if (!csmisas_is_sata(pPhysDisk0) &&
4008 + (device_info &
4009 + MPI_SAS_DEVICE_INFO_SATA_DEVICE))
4010 + continue;
4011 +
4012 + /* don't mix SATA hot spare
4013 + * in SSP volume
4014 + */
4015 + if (csmisas_is_sata(pPhysDisk0) &&
4016 + (device_info &
4017 + MPI_SAS_DEVICE_INFO_SSP_TARGET))
4018 + continue;
4019 +
4020 + /* capacity check for IM volumes*/
4021 + if ((pVolume0->VolumeType ==
4022 + MPI_RAID_VOL_TYPE_IM) &&
4023 + (totalMaxLBA +
4024 + (64*2*1024) /* metadata = 64MB*/ >
4025 + le32_to_cpu(pPhysDisk0->MaxLBA)))
4026 + continue;
4027 +
4028 + tmpTotalMaxLBA = totalMaxLBA;
4029 + do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks);
4030 + /* capacity check for IME volumes*/
4031 + if ((pVolume0->VolumeType ==
4032 + MPI_RAID_VOL_TYPE_IME) &&
4033 + (((totalMaxLBA +
4034 + pVolume0->NumPhysDisks) * 2) +
4035 + (64*2*1024 ) /*metadata = 64MB*/ >
4036 + le32_to_cpu(pPhysDisk0->MaxLBA)))
4037 + continue;
4038 +
4039 + pKarg->Configuration.bDriveCount++;
4040 + if (pKarg->Configuration.bDataType !=
4041 + CSMI_SAS_RAID_DATA_DRIVES) {
4042 + i++;
4043 + continue;
4044 + }
4045 +
4046 + /* Search the list for the matching SAS address. */
4047 + sas_info = csmisas_get_device_component_by_fw(ioc,
4048 + pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID);
4049 + if (sas_info) {
4050 + sas_address = reverse_byte_order64(sas_info->sas_address);
4051 + memcpy(pKarg->Configuration.Drives[i].bSASAddress,
4052 + &sas_address,sizeof(u64));
4053 + }
4054 +
4055 + memcpy(pKarg->Configuration.Drives[i].bModel,
4056 + pPhysDisk0->InquiryData.VendorID,
4057 + offsetof(RAID_PHYS_DISK0_INQUIRY_DATA,ProductRevLevel));
4058 + memcpy(pKarg->Configuration.Drives[i].bFirmware,
4059 + pPhysDisk0->InquiryData.ProductRevLevel,
4060 + sizeof(pPhysDisk0->InquiryData.ProductRevLevel));
4061 + if (csmisas_is_sata(pPhysDisk0)) {
4062 + memcpy(&pKarg->Configuration.Drives[i].bSerialNumber,
4063 + &pPhysDisk0->ExtDiskIdentifier[4],
4064 + 4);
4065 + memcpy(&pKarg->Configuration.Drives[i].bSerialNumber[4],
4066 + &pPhysDisk0->DiskIdentifier,
4067 + sizeof(pPhysDisk0->DiskIdentifier));
4068 + } else {
4069 + memcpy(pKarg->Configuration.Drives[i].bSerialNumber,
4070 + pPhysDisk0->DiskIdentifier,
4071 + sizeof(pPhysDisk0->DiskIdentifier));
4072 + }
4073 + pKarg->Configuration.Drives[i].bDriveStatus =
4074 + CSMI_SAS_DRIVE_STATUS_OK;
4075 + if(pPhysDisk0->PhysDiskStatus.State)
4076 + pKarg->Configuration.Drives[i].bDriveStatus =
4077 + CSMI_SAS_DRIVE_STATUS_FAILED;
4078 + else if(pPhysDisk0->ErrorData.SmartCount)
4079 + pKarg->Configuration.Drives[i].bDriveStatus =
4080 + CSMI_SAS_DRIVE_STATUS_DEGRADED;
4081 + pKarg->Configuration.Drives[i].bDriveUsage =
4082 + CSMI_SAS_DRIVE_CONFIG_SPARE;
4083 + pKarg->Configuration.Drives[i].usBlockSize = 512;
4084 + pKarg->Configuration.Drives[i].uDriveIndex =
4085 + pPhysDisk0->PhysDiskNum;
4086 + if (csmisas_is_sata(pPhysDisk0)) {
4087 + pKarg->Configuration.Drives[i].bDriveType =
4088 + CSMI_SAS_DRIVE_TYPE_SATA;
4089 + } else { /* drive in a volume can only be SAS/SATA */
4090 + pKarg->Configuration.Drives[i].bDriveType =
4091 + CSMI_SAS_DRIVE_TYPE_SINGLE_PORT_SAS;
4092 + if (mpt_raid_phys_disk_get_num_paths(ioc,
4093 + pVolume0->PhysDisk[i].PhysDiskNum) > 1)
4094 + pKarg->Configuration.Drives[i].bDriveType =
4095 + CSMI_SAS_DRIVE_TYPE_DUAL_PORT_SAS;
4096 + }
4097 + i++;
4098 + }
4099 + }
4100 +
4101 + // Only return data on the first 240 drives
4102 + if( pKarg->Configuration.bDriveCount > 0xF0 )
4103 + pKarg->Configuration.bDriveCount =
4104 + CSMI_SAS_RAID_DRIVE_COUNT_TOO_BIG;
4105 +
4106 + pKarg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
4107 +
4108 + cim_get_raid_config_exit:
4109 +
4110 + if (pVolume0 != NULL)
4111 + pci_free_consistent(ioc->pcidev, volumepage0sz, pVolume0,
4112 + volume0_dma);
4113 +
4114 + if(pPhysDisk0 != NULL)
4115 + pci_free_consistent(ioc->pcidev, physdiskpage0sz, pPhysDisk0,
4116 + physdisk0_dma);
4117 +
4118 + if(pIocPage5 != NULL)
4119 + pci_free_consistent(ioc->pcidev, ioc_page5_sz, pIocPage5,
4120 + ioc_page5_dma);
4121 +
4122 + /* Copy the data from kernel memory to user memory
4123 + */
4124 +
4125 + /* find the buffer size to copy depending on how much is filled-in */
4126 + switch (pKarg->Configuration.bDataType) {
4127 + case CSMI_SAS_RAID_DATA_ADDITIONAL_DATA:
4128 + copy_buffer_sz = sizeof(IOCTL_HEADER) +
4129 + offsetof(CSMI_SAS_RAID_CONFIG,Data) +
4130 + sizeof(CSMI_SAS_RAID_SET_ADDITIONAL_DATA);
4131 + break;
4132 + case CSMI_SAS_RAID_DATA_DRIVES:
4133 + if (pKarg->Configuration.bDriveCount ==
4134 + CSMI_SAS_RAID_DRIVE_COUNT_SUPRESSED)
4135 + copy_buffer_sz = sizeof(IOCTL_HEADER) +
4136 + offsetof(CSMI_SAS_RAID_CONFIG,Drives);
4137 + else
4138 + copy_buffer_sz = sizeof(IOCTL_HEADER) +
4139 + offsetof(CSMI_SAS_RAID_CONFIG,Drives) +
4140 + (pKarg->Configuration.bDriveCount *
4141 + sizeof(CSMI_SAS_RAID_DRIVES));
4142 + break;
4143 + case CSMI_SAS_RAID_DATA_DEVICE_ID:
4144 + copy_buffer_sz = csmi_sas_raid_config_buffer_sz;
4145 + break;
4146 + }
4147 +
4148 + if (copy_to_user(uarg, pKarg, copy_buffer_sz)) {
4149 + printk(KERN_ERR "%s@%d::%s() - "
4150 + "Unable to write out csmi_sas_get_raid_config @ %p\n",
4151 + __FILE__, __LINE__, __FUNCTION__, uarg);
4152 + free_pages((unsigned long)pKarg, memory_pages);
4153 + return -EFAULT;
4154 + }
4155 +
4156 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
4157 + free_pages((unsigned long)pKarg, memory_pages);
4158 + return 0;
4159 +}
4160 +
4161 +/**
4162 + * Prototype Routine for the CSMI SAS Get RAID Features command.
4163 + *
4164 + * Outputs: None.
4165 + * Return: 0 if successful
4166 + * -EFAULT if data unavailable
4167 + * -ENODEV if no such device/adapter
4168 + **/
4169 +static int
4170 +csmisas_get_raid_features(unsigned long arg)
4171 +{
4172 + CSMI_SAS_RAID_FEATURES_BUFFER __user *uarg = (void __user *) arg;
4173 + CSMI_SAS_RAID_FEATURES_BUFFER karg, *pKarg=NULL;
4174 + int csmi_sas_raid_features_buffer_sz, iocnum;
4175 + int memory_pages;
4176 + MPT_ADAPTER *ioc = NULL;
4177 +
4178 + if (copy_from_user(&karg, uarg, sizeof(IOCTL_HEADER))) {
4179 + printk(KERN_ERR "%s@%d::%s() - "
4180 + "Unable to read in csmi_sas_get_raid_features struct @ %p\n",
4181 + __FILE__, __LINE__, __FUNCTION__, uarg);
4182 + return -EFAULT;
4183 + }
4184 +
4185 + csmi_sas_raid_features_buffer_sz = karg.IoctlHeader.Length;
4186 + memory_pages = get_order(csmi_sas_raid_features_buffer_sz);
4187 + pKarg = (CSMI_SAS_RAID_FEATURES_BUFFER *)__get_free_pages(
4188 + GFP_KERNEL, memory_pages);
4189 + if (!pKarg){
4190 + printk(KERN_ERR "%s@%d::%s() - "
4191 + "Unable to malloc RAID_FEATURES_BUFFER "
4192 + "csmi_sas_raid_features_buffer_sz=%d memory_pages=%d\n",
4193 + __FILE__, __LINE__, __FUNCTION__,
4194 + csmi_sas_raid_features_buffer_sz, memory_pages);
4195 + return -ENOMEM;
4196 + }
4197 + memset(pKarg, 0, sizeof(*pKarg));
4198 +
4199 + if (copy_from_user(pKarg, uarg, csmi_sas_raid_features_buffer_sz)) {
4200 + printk(KERN_ERR "%s@%d::%s() - "
4201 + "Unable to read in csmi_sas_get_raid_features struct @ %p\n",
4202 + __FILE__, __LINE__, __FUNCTION__, uarg);
4203 + free_pages((unsigned long)pKarg, memory_pages);
4204 + return -EFAULT;
4205 + }
4206 +
4207 + if (((iocnum = mpt_verify_adapter(pKarg->IoctlHeader.IOControllerNumber,
4208 + &ioc)) < 0) || (ioc == NULL)) {
4209 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
4210 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4211 + free_pages((unsigned long)pKarg, memory_pages);
4212 + return -ENODEV;
4213 + }
4214 +
4215 + if (!csmisas_is_this_sas_cntr(ioc)) {
4216 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
4217 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4218 + free_pages((unsigned long)pKarg, memory_pages);
4219 + return -ENODEV;
4220 + }
4221 +
4222 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
4223 +
4224 + if (pKarg->Information.uChangeCount != 0 &&
4225 + pKarg->Information.uChangeCount != ioc->csmi_change_count ) {
4226 + pKarg->IoctlHeader.ReturnCode =
4227 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4228 + pKarg->Information.uFailureCode =
4229 + CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID;
4230 + goto cim_get_raid_features_exit;
4231 + }
4232 +
4233 + pKarg->Information.uFeatures = CSMI_SAS_RAID_FEATURE_REBUILD |
4234 + CSMI_SAS_RAID_FEATURE_SURFACE_SCAN |
4235 + CSMI_SAS_RAID_FEATURE_SPARES_SHARED;
4236 + pKarg->Information.bDefaultTransformPriority =
4237 + CSMI_SAS_PRIORITY_UNKNOWN;
4238 + pKarg->Information.bTransformPriority = CSMI_SAS_PRIORITY_UNKNOWN;
4239 + pKarg->Information.bDefaultRebuildPriority = CSMI_SAS_PRIORITY_UNKNOWN;
4240 + pKarg->Information.bRebuildPriority =
4241 + pKarg->Information.bDefaultRebuildPriority;
4242 + pKarg->Information.bDefaultSurfaceScanPriority =
4243 + CSMI_SAS_PRIORITY_UNKNOWN;
4244 + pKarg->Information.bSurfaceScanPriority = CSMI_SAS_PRIORITY_UNKNOWN;
4245 + pKarg->Information.uRaidSetTransformationRules = 0;
4246 +
4247 + /* IS */
4248 + pKarg->Information.RaidType[0].bRaidType = CSMI_SAS_RAID_TYPE_0;
4249 + pKarg->Information.RaidType[0].uSupportedStripeSizeMap = 0x80;
4250 +
4251 + /* IM */
4252 + pKarg->Information.RaidType[1].bRaidType = CSMI_SAS_RAID_TYPE_1;
4253 + pKarg->Information.RaidType[1].uSupportedStripeSizeMap = 0;
4254 +
4255 + /* IME */
4256 + pKarg->Information.RaidType[2].bRaidType = CSMI_SAS_RAID_TYPE_1E;
4257 + pKarg->Information.RaidType[2].uSupportedStripeSizeMap = 0x80;
4258 +
4259 + pKarg->Information.RaidType[3].bRaidType = CSMI_SAS_RAID_TYPE_END;
4260 + pKarg->Information.bCacheRatiosSupported[0] =
4261 + CSMI_SAS_RAID_CACHE_RATIO_END;
4262 +
4263 + cim_get_raid_features_exit:
4264 +
4265 + /*
4266 + * Copy the data from kernel memory to user memory
4267 + */
4268 + if (copy_to_user(uarg, pKarg,
4269 + sizeof(CSMI_SAS_RAID_FEATURES_BUFFER))) {
4270 + printk(KERN_ERR "%s@%d::%s() - "
4271 + "Unable to write out csmi_sas_get_raid_features @ %p\n",
4272 + __FILE__, __LINE__, __FUNCTION__, uarg);
4273 + free_pages((unsigned long)pKarg, memory_pages);
4274 + return -EFAULT;
4275 + }
4276 +
4277 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
4278 + free_pages((unsigned long)pKarg, memory_pages);
4279 + return 0;
4280 +}
4281 +
4282 +/**
4283 + * Prototype Routine for the CSMI SAS Set RAID Control command.
4284 + *
4285 + * Outputs: None.
4286 + * Return: 0 if successful
4287 + * -EFAULT if data unavailable
4288 + * -ENODEV if no such device/adapter
4289 + **/
4290 +static int
4291 +csmisas_set_raid_control(unsigned long arg)
4292 +{
4293 + CSMI_SAS_RAID_CONTROL_BUFFER __user *uarg = (void __user *) arg;
4294 + CSMI_SAS_RAID_CONTROL_BUFFER karg, *pKarg=NULL;
4295 + int csmi_sas_raid_control_buffer_sz, iocnum;
4296 + int memory_pages;
4297 + MPT_ADAPTER *ioc = NULL;
4298 +
4299 + if (copy_from_user(&karg, uarg, sizeof(IOCTL_HEADER))) {
4300 + printk(KERN_ERR "%s@%d::%s() - "
4301 + "Unable to read in csmi_sas_set_raid_control struct @ %p\n",
4302 + __FILE__, __LINE__, __FUNCTION__, uarg);
4303 + return -EFAULT;
4304 + }
4305 +
4306 + csmi_sas_raid_control_buffer_sz = karg.IoctlHeader.Length;
4307 + memory_pages = get_order(csmi_sas_raid_control_buffer_sz);
4308 + pKarg = (CSMI_SAS_RAID_CONTROL_BUFFER *)__get_free_pages(
4309 + GFP_KERNEL, memory_pages);
4310 + if (!pKarg){
4311 + printk(KERN_ERR "%s@%d::%s() - "
4312 + "Unable to malloc RAID_CONTROL_BUFFER "
4313 + "csmi_sas_raid_control_buffer_sz=%d memory_pages=%d\n",
4314 + __FILE__, __LINE__, __FUNCTION__,
4315 + csmi_sas_raid_control_buffer_sz, memory_pages);
4316 + return -ENOMEM;
4317 + }
4318 + memset(pKarg, 0, sizeof(*pKarg));
4319 +
4320 + if (copy_from_user(pKarg, uarg, csmi_sas_raid_control_buffer_sz)) {
4321 + printk(KERN_ERR "%s@%d::%s() - "
4322 + "Unable to read in csmi_sas_set_raid_control struct @ %p\n",
4323 + __FILE__, __LINE__, __FUNCTION__, uarg);
4324 + free_pages((unsigned long)pKarg, memory_pages);
4325 + return -EFAULT;
4326 + }
4327 +
4328 + if (((iocnum = mpt_verify_adapter(pKarg->IoctlHeader.IOControllerNumber,
4329 + &ioc)) < 0) || (ioc == NULL)) {
4330 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
4331 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4332 + free_pages((unsigned long)pKarg, memory_pages);
4333 + return -ENODEV;
4334 + }
4335 +
4336 + if (!csmisas_is_this_sas_cntr(ioc)) {
4337 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
4338 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4339 + free_pages((unsigned long)pKarg, memory_pages);
4340 + return -ENODEV;
4341 + }
4342 +
4343 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
4344 +
4345 + if (pKarg->Information.uChangeCount != 0 &&
4346 + pKarg->Information.uChangeCount != ioc->csmi_change_count ) {
4347 + pKarg->IoctlHeader.ReturnCode =
4348 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4349 + pKarg->Information.uFailureCode =
4350 + CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID;
4351 + goto cim_set_raid_control_exit;
4352 + }
4353 +
4354 + if (pKarg->Information.bTransformPriority !=
4355 + CSMI_SAS_PRIORITY_UNCHANGED) {
4356 + pKarg->IoctlHeader.ReturnCode =
4357 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4358 + pKarg->Information.uFailureCode =
4359 + CSMI_SAS_FAIL_CODE_TRANSFORM_PRIORITY_INVALID;
4360 + goto cim_set_raid_control_exit;
4361 + }
4362 +
4363 + if (pKarg->Information.bRebuildPriority !=
4364 + CSMI_SAS_PRIORITY_AUTO &&
4365 + pKarg->Information.bRebuildPriority !=
4366 + CSMI_SAS_PRIORITY_UNCHANGED) {
4367 + pKarg->IoctlHeader.ReturnCode =
4368 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4369 + pKarg->Information.uFailureCode =
4370 + CSMI_SAS_FAIL_CODE_REBUILD_PRIORITY_INVALID;
4371 + goto cim_set_raid_control_exit;
4372 + }
4373 +
4374 + if (pKarg->Information.bCacheRatioFlag ==
4375 + CSMI_SAS_RAID_CACHE_RATIO_DISABLE) {
4376 + pKarg->IoctlHeader.ReturnCode =
4377 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4378 + pKarg->Information.uFailureCode =
4379 + CSMI_SAS_FAIL_CODE_CACHE_RATIO_INVALID;
4380 + goto cim_set_raid_control_exit;
4381 + }
4382 +
4383 + if( !strcmp(pKarg->Information.bClearConfiguration,
4384 + CSMI_SAS_RAID_CLEAR_CONFIGURATION_SIGNATURE) ) {
4385 + pKarg->IoctlHeader.ReturnCode =
4386 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4387 + pKarg->Information.uFailureCode =
4388 + CSMI_SAS_FAIL_CODE_CLEAR_CONFIGURATION_INVALID;
4389 + goto cim_set_raid_control_exit;
4390 + }
4391 +
4392 + pKarg->Information.bFailureDescription[0] = '\0';
4393 +
4394 + cim_set_raid_control_exit:
4395 +
4396 + /*
4397 + * Copy the data from kernel memory to user memory
4398 + */
4399 + if (copy_to_user(uarg, pKarg,
4400 + sizeof(CSMI_SAS_RAID_CONTROL_BUFFER))) {
4401 + printk(KERN_ERR "%s@%d::%s() - "
4402 + "Unable to write out csmi_sas_set_raid_control @ %p\n",
4403 + __FILE__, __LINE__, __FUNCTION__, uarg);
4404 + free_pages((unsigned long)pKarg, memory_pages);
4405 + return -EFAULT;
4406 + }
4407 +
4408 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
4409 + free_pages((unsigned long)pKarg, memory_pages);
4410 + return 0;
4411 +}
4412 +
4413 +/**
4414 + * Prototype Routine for the CSMI SAS Get Raid Element.
4415 + *
4416 + * Outputs: None.
4417 + * Return: 0 if successful
4418 + * -EFAULT if data unavailable
4419 + * -ENODEV if no such device/adapter
4420 + **/
4421 +static int
4422 +csmisas_get_raid_element(unsigned long arg)
4423 +{
4424 + CSMI_SAS_RAID_ELEMENT_BUFFER __user *uarg = (void __user *) arg;
4425 + CSMI_SAS_RAID_ELEMENT_BUFFER karg;
4426 + MPT_ADAPTER *ioc = NULL;
4427 + int iocnum;
4428 +
4429 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_RAID_ELEMENT_BUFFER))) {
4430 + printk(KERN_ERR "%s@%d::%s() - "
4431 + "Unable to read in csmisas_get_raid_element struct @ %p\n",
4432 + __FILE__, __LINE__, __FUNCTION__, uarg);
4433 + return -EFAULT;
4434 + }
4435 +
4436 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
4437 + &ioc)) < 0) || (ioc == NULL)) {
4438 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
4439 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4440 + return -ENODEV;
4441 + }
4442 +
4443 + if (!csmisas_is_this_sas_cntr(ioc)) {
4444 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
4445 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4446 + return -ENODEV;
4447 + }
4448 +
4449 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
4450 +
4451 +/* TODO - implement IOCTL here */
4452 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
4453 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": not implemented\n"));
4454 +
4455 +// csmisas_get_raid_element_exit:
4456 +
4457 + /* Copy the data from kernel memory to user memory
4458 + */
4459 + if (copy_to_user(uarg, &karg,
4460 + sizeof(CSMI_SAS_RAID_ELEMENT_BUFFER))) {
4461 + printk(KERN_ERR "%s@%d::%s() - "
4462 + "Unable to write out csmisas_get_raid_element @ %p\n",
4463 + __FILE__, __LINE__, __FUNCTION__, uarg);
4464 + return -EFAULT;
4465 + }
4466 +
4467 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
4468 + return 0;
4469 +
4470 +}
4471 +
4472 +/**
4473 + * Prototype Routine for the CSMI SAS Set Raid Operation
4474 + *
4475 + * Outputs: None.
4476 + * Return: 0 if successful
4477 + * -EFAULT if data unavailable
4478 + * -ENODEV if no such device/adapter
4479 + **/
4480 +static int
4481 +csmisas_set_raid_operation(unsigned long arg)
4482 +{
4483 + CSMI_SAS_RAID_SET_OPERATION_BUFFER __user *uarg = (void __user *) arg;
4484 + CSMI_SAS_RAID_SET_OPERATION_BUFFER karg;
4485 + MPT_ADAPTER *ioc = NULL;
4486 + int iocnum;
4487 +
4488 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_RAID_SET_OPERATION_BUFFER))) {
4489 + printk(KERN_ERR "%s@%d::%s() - "
4490 + "Unable to read in csmi_set_raid_operation struct @ %p\n",
4491 + __FILE__, __LINE__, __FUNCTION__, uarg);
4492 + return -EFAULT;
4493 + }
4494 +
4495 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
4496 + &ioc)) < 0) || (ioc == NULL)) {
4497 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
4498 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4499 + return -ENODEV;
4500 + }
4501 +
4502 + if (!csmisas_is_this_sas_cntr(ioc)) {
4503 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
4504 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4505 + return -ENODEV;
4506 + }
4507 +
4508 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
4509 +
4510 +/* TODO - implement IOCTL here */
4511 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
4512 + dcsmisasprintk(ioc, printk(KERN_DEBUG ": not implemented\n"));
4513 +
4514 +// cim_set_raid_operation:
4515 +
4516 + /* Copy the data from kernel memory to user memory
4517 + */
4518 + if (copy_to_user(uarg, &karg,
4519 + sizeof(CSMI_SAS_RAID_SET_OPERATION_BUFFER))) {
4520 + printk(KERN_ERR "%s@%d::%s() - "
4521 + "Unable to write out csmi_set_raid_operation @ %p\n",
4522 + __FILE__, __LINE__, __FUNCTION__, uarg);
4523 + return -EFAULT;
4524 + }
4525 +
4526 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
4527 + return 0;
4528 +
4529 +}
4530 +
4531 +
4532 +/**
4533 + * Prototype Routine for the CSMI SAS Task Managment Config command.
4534 + *
4535 + * Outputs: None.
4536 + * Return: 0 if successful
4537 + * -EFAULT if data unavailable
4538 + * -ENODEV if no such device/adapter
4539 + **/
4540 +static int
4541 +csmisas_task_managment(unsigned long arg)
4542 +{
4543 + CSMI_SAS_SSP_TASK_IU_BUFFER __user *uarg = (void __user *) arg;
4544 + CSMI_SAS_SSP_TASK_IU_BUFFER karg;
4545 + pSCSITaskMgmt_t pScsiTm;
4546 + pSCSITaskMgmtReply_t pScsiTmReply;
4547 + MPT_ADAPTER *ioc = NULL;
4548 + MPT_SCSI_HOST *hd;
4549 + MPT_FRAME_HDR *mf = NULL;
4550 + MPIHeader_t *mpi_hdr;
4551 + int iocnum;
4552 + u8 taskType;
4553 + u8 channel;
4554 + u8 id;
4555 + u8 queueTag;
4556 + u32 TaskMsgContext = 0;
4557 + int i;
4558 + u8 found_qtag;
4559 + struct sas_device_info *sas_info;
4560 + u16 ioc_status;
4561 + u32 MsgContext;
4562 +
4563 + if (copy_from_user(&karg, uarg, sizeof(CSMI_SAS_SSP_TASK_IU_BUFFER))) {
4564 + printk(KERN_ERR "%s@%d::%s() - "
4565 + "Unable to read in csmi_sas_task_managment struct @ %p\n",
4566 + __FILE__, __LINE__, __FUNCTION__, uarg);
4567 + return -EFAULT;
4568 + }
4569 +
4570 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
4571 + &ioc)) < 0) || (ioc == NULL)) {
4572 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
4573 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4574 + return -ENODEV;
4575 + }
4576 +
4577 + if (!csmisas_is_this_sas_cntr(ioc)) {
4578 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
4579 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4580 + return -ENODEV;
4581 + }
4582 +
4583 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
4584 +
4585 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
4586 +
4587 + sas_info = csmisas_get_device_component_by_os(ioc,
4588 + karg.Parameters.bPathId, karg.Parameters.bTargetId);
4589 + if (!sas_info || sas_info->is_cached || sas_info->is_logical_volume)
4590 + goto cim_get_task_managment_exit;
4591 +
4592 + channel = sas_info->fw.channel;
4593 + id = sas_info->fw.id;
4594 + queueTag = (u8)karg.Parameters.uQueueTag & 0xFF;
4595 + hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
4596 +
4597 + /* try to catch an error
4598 + */
4599 + if ((karg.Parameters.uFlags & CSMI_SAS_TASK_IU) &&
4600 + (karg.Parameters.uFlags & CSMI_SAS_HARD_RESET_SEQUENCE))
4601 + goto cim_get_task_managment_exit;
4602 +
4603 + if (karg.Parameters.uFlags & CSMI_SAS_TASK_IU) {
4604 + switch (karg.Parameters.bTaskManagementFunction) {
4605 +
4606 + case CSMI_SAS_SSP_ABORT_TASK:
4607 + taskType = MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK;
4608 + break;
4609 + case CSMI_SAS_SSP_ABORT_TASK_SET:
4610 + taskType = MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET;
4611 + break;
4612 + case CSMI_SAS_SSP_CLEAR_TASK_SET:
4613 + taskType = MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET;
4614 + break;
4615 + case CSMI_SAS_SSP_LOGICAL_UNIT_RESET:
4616 + taskType = MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET;
4617 + break;
4618 + case CSMI_SAS_SSP_CLEAR_ACA:
4619 + case CSMI_SAS_SSP_QUERY_TASK:
4620 + default:
4621 + goto cim_get_task_managment_exit;
4622 + }
4623 + } else if (karg.Parameters.uFlags & CSMI_SAS_HARD_RESET_SEQUENCE)
4624 + taskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
4625 + else
4626 + goto cim_get_task_managment_exit;
4627 +
4628 + switch (karg.Parameters.uInformation) {
4629 + case CSMI_SAS_SSP_TEST:
4630 + dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request for test purposes\n"));
4631 + break;
4632 + case CSMI_SAS_SSP_EXCEEDED:
4633 + dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request due to timeout\n"));
4634 + break;
4635 + case CSMI_SAS_SSP_DEMAND:
4636 + dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request demanded by app\n"));
4637 + break;
4638 + case CSMI_SAS_SSP_TRIGGER:
4639 + dcsmisasprintk(ioc, printk(KERN_DEBUG "TM request sent to trigger event\n"));
4640 + break;
4641 + }
4642 +
4643 + switch (taskType) {
4644 +
4645 + case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
4646 + /*
4647 + * look up qtag in the ScsiLookup[] table
4648 + */
4649 + for (i = 0, found_qtag = 0; i < hd->ioc->req_depth; i++) {
4650 + if ((ioc->ScsiLookup[i]) &&
4651 + (ioc->ScsiLookup[i]->tag == queueTag)) {
4652 + mf = MPT_INDEX_2_MFPTR(hd->ioc, i);
4653 + TaskMsgContext =
4654 + mf->u.frame.hwhdr.msgctxu.MsgContext;
4655 + found_qtag=1;
4656 + break;
4657 + }
4658 + }
4659 +
4660 + if(!found_qtag)
4661 + goto cim_get_task_managment_exit;
4662 +
4663 + case MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET:
4664 + case MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
4665 + case MPI_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET:
4666 + /* for now, this should work
4667 + */
4668 + case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
4669 +
4670 + /* Single threading ....
4671 + */
4672 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
4673 + mutex_lock(&ioc->taskmgmt_cmds.mutex);
4674 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
4675 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4676 + karg.IoctlHeader.ReturnCode =
4677 + CSMI_SAS_STATUS_FAILED;
4678 + goto cim_get_task_managment_exit;
4679 + }
4680 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
4681 + if (mptctl_set_tm_flags(hd) != 0) {
4682 + karg.IoctlHeader.ReturnCode =
4683 + CSMI_SAS_STATUS_FAILED;
4684 + goto cim_get_task_managment_exit;
4685 + }
4686 +#endif
4687 + /* Send request
4688 + */
4689 + if ((mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc)) == NULL) {
4690 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
4691 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
4692 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4693 + mpt_clear_taskmgmt_in_progress_flag(ioc);
4694 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
4695 + mptctl_free_tm_flags(ioc);
4696 +#endif
4697 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
4698 + goto cim_get_task_managment_exit;
4699 + }
4700 +
4701 + mpi_hdr = (MPIHeader_t *) mf;
4702 + MsgContext = mpi_hdr->MsgContext;
4703 + pScsiTm = (pSCSITaskMgmt_t ) mf;
4704 +
4705 + memset(pScsiTm,0,sizeof(SCSITaskMgmt_t));
4706 + pScsiTm->TaskType = taskType;
4707 + pScsiTm->Bus = channel;
4708 + pScsiTm->TargetID = id;
4709 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
4710 + int_to_scsilun(karg.Parameters.bLun,
4711 + (struct scsi_lun *)pScsiTm->LUN);
4712 +#else
4713 + pScsiTm->LUN[1] = karg.Parameters.bLun;
4714 +#endif
4715 + pScsiTm->MsgContext = MsgContext;
4716 + pScsiTm->TaskMsgContext = TaskMsgContext;
4717 + pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
4718 +
4719 + if (csmisas_send_handshake_wait(ioc, mf,
4720 + karg.IoctlHeader.Timeout) != 0) {
4721 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
4722 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4723 +#endif
4724 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
4725 + goto cim_get_task_managment_exit;
4726 + }
4727 +
4728 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
4729 +
4730 + pScsiTmReply =
4731 + (pSCSITaskMgmtReply_t ) ioc->ioctl_cmds.reply;
4732 +
4733 + ioc_status = le16_to_cpu(pScsiTmReply->IOCStatus)
4734 + & MPI_IOCSTATUS_MASK;
4735 +
4736 + memset(&karg.Status,0,
4737 + sizeof(CSMI_SAS_SSP_PASSTHRU_STATUS));
4738 +
4739 + if(ioc_status == MPI_IOCSTATUS_SUCCESS) {
4740 + karg.IoctlHeader.ReturnCode =
4741 + CSMI_SAS_STATUS_SUCCESS;
4742 + karg.Status.bSSPStatus =
4743 + CSMI_SAS_SSP_STATUS_COMPLETED;
4744 + }else if(ioc_status == MPI_IOCSTATUS_INSUFFICIENT_RESOURCES) {
4745 + karg.IoctlHeader.ReturnCode =
4746 + CSMI_SAS_STATUS_SUCCESS;
4747 + karg.Status.bSSPStatus =
4748 + CSMI_SAS_SSP_STATUS_RETRY;
4749 + }else {
4750 + karg.IoctlHeader.ReturnCode =
4751 + CSMI_SAS_STATUS_FAILED;
4752 + karg.Status.bSSPStatus =
4753 + CSMI_SAS_SSP_STATUS_FATAL_ERROR;
4754 + }
4755 + } else
4756 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
4757 +
4758 + break;
4759 +
4760 + default:
4761 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
4762 + break;
4763 + }
4764 +
4765 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15))
4766 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
4767 +#endif
4768 +
4769 + cim_get_task_managment_exit:
4770 +
4771 + /* Copy the data from kernel memory to user memory
4772 + */
4773 + if (copy_to_user(uarg, &karg,
4774 + sizeof(CSMI_SAS_SSP_TASK_IU_BUFFER))) {
4775 + printk(KERN_ERR "%s@%d::%s() - "
4776 + "Unable to write out csmi_sas_task_managment @ %p\n",
4777 + __FILE__, __LINE__, __FUNCTION__, uarg);
4778 + return -EFAULT;
4779 + }
4780 +
4781 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
4782 + return 0;
4783 +}
4784 +
4785 +/**
4786 + * map_sas_status_to_csmi - Conversion for Connection Status
4787 + * @mpi_sas_status: Sas status returned by the firmware
4788 + *
4789 + * Returns converted connection status
4790 + *
4791 + **/
4792 +static u8
4793 +map_sas_status_to_csmi(u8 mpi_sas_status)
4794 +{
4795 + u8 csmi_connect_status;
4796 +
4797 + switch (mpi_sas_status) {
4798 +
4799 + case MPI_SASSTATUS_SUCCESS:
4800 + csmi_connect_status = CSMI_SAS_OPEN_ACCEPT;
4801 + break;
4802 +
4803 + case MPI_SASSTATUS_UTC_BAD_DEST:
4804 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_BAD_DESTINATION;
4805 + break;
4806 +
4807 + case MPI_SASSTATUS_UTC_CONNECT_RATE_NOT_SUPPORTED:
4808 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_RATE_NOT_SUPPORTED;
4809 + break;
4810 +
4811 + case MPI_SASSTATUS_UTC_PROTOCOL_NOT_SUPPORTED:
4812 + csmi_connect_status =
4813 + CSMI_SAS_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED;
4814 + break;
4815 +
4816 + case MPI_SASSTATUS_UTC_STP_RESOURCES_BUSY:
4817 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_STP_RESOURCES_BUSY;
4818 + break;
4819 +
4820 + case MPI_SASSTATUS_UTC_WRONG_DESTINATION:
4821 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_WRONG_DESTINATION;
4822 + break;
4823 +
4824 + case MPI_SASSTATUS_SDSF_NAK_RECEIVED:
4825 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_RETRY;
4826 + break;
4827 +
4828 + case MPI_SASSTATUS_SDSF_CONNECTION_FAILED:
4829 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_PATHWAY_BLOCKED;
4830 + break;
4831 +
4832 + case MPI_SASSTATUS_INITIATOR_RESPONSE_TIMEOUT:
4833 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_NO_DESTINATION;
4834 + break;
4835 +
4836 + case MPI_SASSTATUS_UNKNOWN_ERROR:
4837 + case MPI_SASSTATUS_INVALID_FRAME:
4838 + case MPI_SASSTATUS_UTC_BREAK_RECEIVED:
4839 + case MPI_SASSTATUS_UTC_PORT_LAYER_REQUEST:
4840 + case MPI_SASSTATUS_SHORT_INFORMATION_UNIT:
4841 + case MPI_SASSTATUS_LONG_INFORMATION_UNIT:
4842 + case MPI_SASSTATUS_XFER_RDY_INCORRECT_WRITE_DATA:
4843 + case MPI_SASSTATUS_XFER_RDY_REQUEST_OFFSET_ERROR:
4844 + case MPI_SASSTATUS_XFER_RDY_NOT_EXPECTED:
4845 + case MPI_SASSTATUS_DATA_INCORRECT_DATA_LENGTH:
4846 + case MPI_SASSTATUS_DATA_TOO_MUCH_READ_DATA:
4847 + case MPI_SASSTATUS_DATA_OFFSET_ERROR:
4848 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_RESERVE_STOP;
4849 + break;
4850 +
4851 + default:
4852 + csmi_connect_status = CSMI_SAS_OPEN_REJECT_RESERVE_STOP;
4853 + break;
4854 + }
4855 +
4856 + return csmi_connect_status;
4857 +}
4858 +
4859 +/**
4860 + * csmisas_phy_reset
4861 + * Issues a phy link reset or phy hard reset
4862 + *
4863 + * @ioc - Pointer to MPT_ADAPTER structure
4864 + * @PhyNum - phy number
4865 + * @opcode - {MPI_SAS_OP_PHY_LINK_RESET,MPI_SAS_OP_PHY_HARD_RESET}
4866 + *
4867 + * Returns: 0 for success, non-zero error
4868 + **/
4869 +static int
4870 +csmisas_phy_reset(MPT_ADAPTER *ioc, u8 PhyNum, u8 opcode)
4871 +{
4872 + SasIoUnitControlRequest_t *sasIoUnitCntrReq;
4873 + SasIoUnitControlReply_t *sasIoUnitCntrReply;
4874 + MPT_FRAME_HDR *mf = NULL;
4875 + MPIHeader_t *mpi_hdr;
4876 + u16 ioc_status;
4877 + u32 MsgContext;
4878 +
4879 + if ((opcode != MPI_SAS_OP_PHY_LINK_RESET) &&
4880 + (opcode != MPI_SAS_OP_PHY_HARD_RESET))
4881 + return -1;
4882 +
4883 + /* Get a MF for this command.
4884 + */
4885 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
4886 + dcsmisasprintk(ioc, printk(KERN_ERR ": no msg frames!\n"));
4887 + return -1;
4888 + }
4889 +
4890 + mpi_hdr = (MPIHeader_t *) mf;
4891 + MsgContext = mpi_hdr->MsgContext;
4892 + sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
4893 + memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
4894 + sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
4895 + sasIoUnitCntrReq->MsgContext = MsgContext;
4896 + sasIoUnitCntrReq->Operation = opcode;
4897 + sasIoUnitCntrReq->PhyNum = PhyNum;
4898 +
4899 + if (csmisas_send_command_wait(ioc, mf, MPT_IOCTL_DEFAULT_TIMEOUT) != 0)
4900 + return -1;
4901 +
4902 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0)
4903 + return -1;
4904 +
4905 + /* process the completed Reply Message Frame */
4906 + sasIoUnitCntrReply = (SasIoUnitControlReply_t *)ioc->ioctl_cmds.reply;
4907 + ioc_status = le16_to_cpu(sasIoUnitCntrReply->IOCStatus)
4908 + & MPI_IOCSTATUS_MASK;
4909 + if (ioc_status != MPI_IOCSTATUS_SUCCESS) {
4910 + printk(KERN_DEBUG "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
4911 + __FUNCTION__,
4912 + sasIoUnitCntrReply->IOCStatus,
4913 + sasIoUnitCntrReply->IOCLogInfo);
4914 + return -1;
4915 + }
4916 + return 0;
4917 +}
4918 +
4919 +/** Prototype Routine for the CSMI SAS Phy Control command.
4920 + *
4921 + * Outputs: None.
4922 + * Return: 0 if successful
4923 + * -EFAULT if data unavailable
4924 + * -ENODEV if no such device/adapter
4925 + **/
4926 +static int
4927 +csmisas_phy_control(unsigned long arg)
4928 +{
4929 + CSMI_SAS_PHY_CONTROL_BUFFER __user *uarg = (void __user *) arg;
4930 + IOCTL_HEADER ioctl_header;
4931 + PCSMI_SAS_PHY_CONTROL_BUFFER karg;
4932 + SasIOUnitPage0_t *sasIoUnitPg0=NULL;
4933 + dma_addr_t sasIoUnitPg0_dma;
4934 + int sasIoUnitPg0_data_sz=0;
4935 + SasIOUnitPage1_t *sasIoUnitPg1=NULL;
4936 + dma_addr_t sasIoUnitPg1_dma;
4937 + int sasIoUnitPg1_data_sz=0;
4938 + ConfigExtendedPageHeader_t hdr;
4939 + CONFIGPARMS cfg;
4940 + MPT_ADAPTER *ioc = NULL;
4941 + int iocnum;
4942 + int csmi_sas_phy_control_buffer_sz;
4943 + int memory_pages;
4944 +
4945 + if (copy_from_user(&ioctl_header, uarg, sizeof(IOCTL_HEADER))) {
4946 + printk(KERN_ERR "%s@%d::%s() - "
4947 + "Unable to read in IOCTL_HEADER"
4948 + "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
4949 + return -EFAULT;
4950 + }
4951 +
4952 + csmi_sas_phy_control_buffer_sz = ioctl_header.Length;
4953 + memory_pages = get_order(csmi_sas_phy_control_buffer_sz);
4954 + karg = (PCSMI_SAS_PHY_CONTROL_BUFFER)__get_free_pages(
4955 + GFP_KERNEL, memory_pages);
4956 + if (!karg){
4957 + printk(KERN_ERR "%s@%d::%s() - "
4958 + "Unable to malloc SAS_PHY_CONTROL_BUFFER "
4959 + "csmi_sas_phy_control_buffer_sz=%d memory_pages=%d\n",
4960 + __FILE__, __LINE__, __FUNCTION__,
4961 + csmi_sas_phy_control_buffer_sz, memory_pages);
4962 + return -ENOMEM;
4963 + }
4964 + memset(karg, 0, sizeof(*karg));
4965 +
4966 + if (copy_from_user(karg, uarg, csmi_sas_phy_control_buffer_sz)) {
4967 + printk(KERN_ERR "%s@%d::%s() - "
4968 + "Unable to read in csmi_sas_phy_control_buffer "
4969 + "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
4970 + free_pages((unsigned long)karg, memory_pages);
4971 + return -EFAULT;
4972 + }
4973 +
4974 + if (((iocnum = mpt_verify_adapter(ioctl_header.IOControllerNumber,
4975 + &ioc)) < 0) || (ioc == NULL)) {
4976 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
4977 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4978 + free_pages((unsigned long)karg, memory_pages);
4979 + return -ENODEV;
4980 + }
4981 +
4982 + if (!csmisas_is_this_sas_cntr(ioc)) {
4983 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
4984 + __FILE__, __FUNCTION__, __LINE__, iocnum);
4985 + free_pages((unsigned long)karg, memory_pages);
4986 + return -ENODEV;
4987 + }
4988 +
4989 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
4990 +
4991 + if (karg->bPhyIdentifier >= ioc->num_ports) {
4992 + karg->IoctlHeader.ReturnCode =
4993 + CSMI_SAS_STATUS_INVALID_PARAMETER;
4994 + goto cim_sas_phy_control_exit;
4995 + }
4996 +
4997 + /*
4998 + * Retreive SAS IOUNIT PAGE 0
4999 + */
5000 +
5001 + hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
5002 + hdr.ExtPageLength = 0;
5003 + hdr.PageNumber = 0;
5004 + hdr.Reserved1 = 0;
5005 + hdr.Reserved2 = 0;
5006 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5007 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
5008 +
5009 + cfg.cfghdr.ehdr = &hdr;
5010 + cfg.physAddr = -1;
5011 + cfg.pageAddr = 0;
5012 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5013 + cfg.dir = 0; /* read */
5014 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
5015 +
5016 + if (mpt_config(ioc, &cfg) != 0) {
5017 + dcsmisasprintk(ioc, printk(KERN_ERR
5018 + ": FAILED: READ MPI_SASIOUNITPAGE0: HEADER\n"));
5019 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5020 + goto cim_sas_phy_control_exit;
5021 + }
5022 +
5023 + if (hdr.ExtPageLength == 0) {
5024 + dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
5025 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5026 + goto cim_sas_phy_control_exit;
5027 + }
5028 +
5029 + sasIoUnitPg0_data_sz = hdr.ExtPageLength * 4;
5030 + sasIoUnitPg0 = (SasIOUnitPage0_t *) pci_alloc_consistent(ioc->pcidev,
5031 + sasIoUnitPg0_data_sz, &sasIoUnitPg0_dma);
5032 +
5033 + if (!sasIoUnitPg0) {
5034 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
5035 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5036 + goto cim_sas_phy_control_exit;
5037 + }
5038 +
5039 + memset((u8 *)sasIoUnitPg0, 0, sasIoUnitPg0_data_sz);
5040 + cfg.physAddr = sasIoUnitPg0_dma;
5041 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5042 +
5043 + if (mpt_config(ioc, &cfg) != 0) {
5044 + dcsmisasprintk(ioc, printk(KERN_ERR
5045 + ": FAILED: READ MPI_SASIOUNITPAGE0: CURRENT\n"));
5046 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5047 + goto cim_sas_phy_control_exit;
5048 + }
5049 +
5050 + /*
5051 + * Retreive SAS IOUNIT PAGE 1
5052 + */
5053 +
5054 + hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
5055 + hdr.ExtPageLength = 0;
5056 + hdr.PageNumber = 1;
5057 + hdr.Reserved1 = 0;
5058 + hdr.Reserved2 = 0;
5059 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5060 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
5061 +
5062 + cfg.cfghdr.ehdr = &hdr;
5063 + cfg.physAddr = -1;
5064 + cfg.pageAddr = 0;
5065 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5066 + cfg.dir = 0; /* read */
5067 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
5068 +
5069 + if (mpt_config(ioc, &cfg) != 0) {
5070 + dcsmisasprintk(ioc, printk(KERN_ERR
5071 + ": FAILED: READ MPI_SASIOUNITPAGE1: HEADER\n"));
5072 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5073 + goto cim_sas_phy_control_exit;
5074 + }
5075 +
5076 + if (hdr.ExtPageLength == 0) {
5077 + dcsmisasprintk(ioc, printk(KERN_ERR ": hdr.ExtPageLength == 0\n"));
5078 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5079 + goto cim_sas_phy_control_exit;
5080 + }
5081 +
5082 + sasIoUnitPg1_data_sz = hdr.ExtPageLength * 4;
5083 + sasIoUnitPg1 = (SasIOUnitPage1_t *) pci_alloc_consistent(ioc->pcidev,
5084 + sasIoUnitPg1_data_sz, &sasIoUnitPg1_dma);
5085 +
5086 + if (!sasIoUnitPg1) {
5087 + dcsmisasprintk(ioc, printk(KERN_ERR ": pci_alloc_consistent: FAILED\n"));
5088 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5089 + goto cim_sas_phy_control_exit;
5090 + }
5091 +
5092 + memset((u8 *)sasIoUnitPg1, 0, sasIoUnitPg1_data_sz);
5093 + cfg.physAddr = sasIoUnitPg1_dma;
5094 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5095 +
5096 + if (mpt_config(ioc, &cfg) != 0) {
5097 + dcsmisasprintk(ioc, printk(KERN_ERR
5098 + ": FAILED: READ MPI_SASIOUNITPAGE1: CURRENT\n"));
5099 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5100 + goto cim_sas_phy_control_exit;
5101 + }
5102 +
5103 + switch (karg->uFunction) {
5104 +
5105 + case CSMI_SAS_PC_LINK_RESET:
5106 + case CSMI_SAS_PC_HARD_RESET:
5107 + {
5108 + u8 opcode = (karg->uFunction==CSMI_SAS_PC_LINK_RESET) ?
5109 + MPI_SAS_OP_PHY_LINK_RESET : MPI_SAS_OP_PHY_HARD_RESET;
5110 +
5111 + if((karg->uLinkFlags & CSMI_SAS_PHY_ACTIVATE_CONTROL) &&
5112 + (karg->usLengthOfControl >= sizeof(CSMI_SAS_PHY_CONTROL)) &&
5113 + (karg->bNumberOfControls > 0)){
5114 + if(karg->Control[0].bRate ==
5115 + CSMI_SAS_LINK_RATE_1_5_GBPS) {
5116 + sasIoUnitPg1->PhyData[karg->bPhyIdentifier].MaxMinLinkRate =
5117 + MPI_SAS_IOUNIT1_MAX_RATE_1_5 |
5118 + MPI_SAS_IOUNIT1_MIN_RATE_1_5;
5119 + }
5120 + else if(karg->Control[0].bRate ==
5121 + CSMI_SAS_LINK_RATE_3_0_GBPS) {
5122 + sasIoUnitPg1->PhyData[karg->bPhyIdentifier].MaxMinLinkRate =
5123 + MPI_SAS_IOUNIT1_MAX_RATE_3_0 |
5124 + MPI_SAS_IOUNIT1_MIN_RATE_3_0;
5125 + }
5126 + sasIoUnitPg1->PhyData[karg->bPhyIdentifier].PhyFlags &=
5127 + ~MPI_SAS_IOUNIT1_PHY_FLAGS_PHY_DISABLE;
5128 + cfg.dir = 1;
5129 + cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
5130 + if (mpt_config(ioc, &cfg) != 0) {
5131 + dcsmisasprintk(ioc, printk(KERN_ERR
5132 + ": FAILED: WRITE MPI_SASIOUNITPAGE1 NVRAM\n"));
5133 + karg->IoctlHeader.ReturnCode =
5134 + CSMI_SAS_STATUS_FAILED;
5135 + goto cim_sas_phy_control_exit;
5136 + }
5137 + cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5138 + if (mpt_config(ioc, &cfg) != 0) {
5139 + dcsmisasprintk(ioc, printk(KERN_ERR
5140 + ": FAILED: WRITE MPI_SASIOUNITPAGE1 CURRENT\n"));
5141 + karg->IoctlHeader.ReturnCode =
5142 + CSMI_SAS_STATUS_FAILED;
5143 + goto cim_sas_phy_control_exit;
5144 + }
5145 + }
5146 + if (csmisas_phy_reset(ioc,
5147 + karg->bPhyIdentifier, opcode) != 0) {
5148 + dcsmisasprintk(ioc, printk(KERN_ERR
5149 + ": FAILED: csmisas_phy_reset\n"));
5150 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5151 + goto cim_sas_phy_control_exit;
5152 + }
5153 + break;
5154 +
5155 + }
5156 + case CSMI_SAS_PC_PHY_DISABLE:
5157 + if(karg->usLengthOfControl || karg->bNumberOfControls) {
5158 + karg->IoctlHeader.ReturnCode =
5159 + CSMI_SAS_STATUS_INVALID_PARAMETER;
5160 + break;
5161 + }
5162 + sasIoUnitPg1->PhyData[karg->bPhyIdentifier].PhyFlags |=
5163 + MPI_SAS_IOUNIT1_PHY_FLAGS_PHY_DISABLE;
5164 + cfg.dir = 1;
5165 + cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
5166 + if (mpt_config(ioc, &cfg) != 0) {
5167 + dcsmisasprintk(ioc, printk(KERN_ERR
5168 + ": FAILED: WRITE MPI_SASIOUNITPAGE1 NVRAM\n"));
5169 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5170 + goto cim_sas_phy_control_exit;
5171 + }
5172 + cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5173 + if (mpt_config(ioc, &cfg) != 0) {
5174 + dcsmisasprintk(ioc, printk(KERN_ERR
5175 + ": FAILED: WRITE MPI_SASIOUNITPAGE1 CURRENT\n"));
5176 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5177 + goto cim_sas_phy_control_exit;
5178 + }
5179 + if (csmisas_phy_reset(ioc,
5180 + karg->bPhyIdentifier, MPI_SAS_OP_PHY_HARD_RESET) != 0) {
5181 + dcsmisasprintk(ioc, printk(KERN_ERR
5182 + ": FAILED: csmisas_phy_reset\n"));
5183 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5184 + goto cim_sas_phy_control_exit;
5185 + }
5186 + break;
5187 +
5188 + case CSMI_SAS_PC_GET_PHY_SETTINGS:
5189 + if(karg->usLengthOfControl || karg->bNumberOfControls) {
5190 + karg->IoctlHeader.ReturnCode =
5191 + CSMI_SAS_STATUS_INVALID_PARAMETER;
5192 + break;
5193 + }
5194 + if(csmi_sas_phy_control_buffer_sz <
5195 + offsetof(CSMI_SAS_PHY_CONTROL_BUFFER,Control) +
5196 + (4* sizeof(CSMI_SAS_PHY_CONTROL))) {
5197 + karg->IoctlHeader.ReturnCode =
5198 + CSMI_SAS_STATUS_INVALID_PARAMETER;
5199 + break;
5200 + }
5201 + karg->usLengthOfControl = sizeof(CSMI_SAS_PHY_CONTROL);
5202 + karg->bNumberOfControls = 4;
5203 + karg->Control[0].bType = CSMI_SAS_SAS;
5204 + karg->Control[0].bRate = CSMI_SAS_LINK_RATE_1_5_GBPS;
5205 + karg->Control[1].bType = CSMI_SAS_SAS;
5206 + karg->Control[1].bRate = CSMI_SAS_LINK_RATE_3_0_GBPS;
5207 + karg->Control[2].bType = CSMI_SAS_SATA;
5208 + karg->Control[2].bRate = CSMI_SAS_LINK_RATE_1_5_GBPS;
5209 + karg->Control[3].bType = CSMI_SAS_SATA;
5210 + karg->Control[3].bRate = CSMI_SAS_LINK_RATE_3_0_GBPS;
5211 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
5212 + break;
5213 + default:
5214 + break;
5215 + }
5216 +
5217 + cim_sas_phy_control_exit:
5218 +
5219 + if (sasIoUnitPg0)
5220 + pci_free_consistent(ioc->pcidev, sasIoUnitPg0_data_sz,
5221 + (u8 *) sasIoUnitPg0, sasIoUnitPg0_dma);
5222 +
5223 + if (sasIoUnitPg1)
5224 + pci_free_consistent(ioc->pcidev, sasIoUnitPg1_data_sz,
5225 + (u8 *) sasIoUnitPg1, sasIoUnitPg1_dma);
5226 +
5227 + /* Copy the data from kernel memory to user memory
5228 + */
5229 + if (copy_to_user(uarg, karg,csmi_sas_phy_control_buffer_sz)) {
5230 + printk(KERN_ERR "%s@%d::%s() - "
5231 + "Unable to write out csmi_sas_phy_control_buffer @ %p\n",
5232 + __FILE__, __LINE__, __FUNCTION__, uarg);
5233 + free_pages((unsigned long)karg, memory_pages);
5234 + return -EFAULT;
5235 + }
5236 +
5237 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
5238 + free_pages((unsigned long)karg, memory_pages);
5239 + return 0;
5240 +}
5241 +
5242 +/**
5243 + * csmisas_get_manuf_pg_7 - Fetch Manufacturing config Page7.
5244 + * @ioc: Pointer to MPT_ADAPTER structure
5245 + * @mfgpage7_buffer: pointer to ManufacturingPage7_t that returns config
5246 + * page data
5247 + * @mfg_size - max size of buffer
5248 + *
5249 + * Return: 0 for success
5250 + * -ENOMEM if no memory available
5251 + * -EPERM if not allowed due to ISR context
5252 + * -EAGAIN if no msg frames currently available
5253 + * -EFAULT for non-successful reply or no reply (timeout)
5254 + **/
5255 +static int
5256 +csmisas_get_manuf_pg_7(MPT_ADAPTER *ioc, ManufacturingPage7_t *mfgpage7_buffer, int mfg_size)
5257 +{
5258 + ConfigPageHeader_t hdr;
5259 + CONFIGPARMS cfg;
5260 + ManufacturingPage7_t *mfgPage7 = NULL;
5261 + dma_addr_t mfgPage7_dma;
5262 + int data_sz = 0;
5263 + int rc;
5264 +
5265 + /* Get Manufacturing Page 7 header */
5266 + hdr.PageVersion = MPI_MANUFACTURING0_PAGEVERSION;
5267 + hdr.PageLength = 0;
5268 + hdr.PageNumber = 7;
5269 + hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
5270 + cfg.cfghdr.hdr = &hdr;
5271 + cfg.physAddr = -1;
5272 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5273 + cfg.dir = 0;
5274 + cfg.pageAddr = 0;
5275 + cfg.timeout = 0;
5276 +
5277 + if ((rc = mpt_config(ioc, &cfg)) != 0)
5278 + goto csmisas_get_manuf_pg_7_exit;
5279 +
5280 + if (hdr.PageLength == 0) {
5281 + rc = -EFAULT;
5282 + goto csmisas_get_manuf_pg_7_exit;
5283 + }
5284 +
5285 + data_sz = hdr.PageLength * 4;
5286 + mfgPage7 = pci_alloc_consistent(ioc->pcidev, data_sz, &mfgPage7_dma);
5287 + if (!mfgPage7) {
5288 + rc = -ENOMEM;
5289 + goto csmisas_get_manuf_pg_7_exit;
5290 + }
5291 +
5292 + memset((u8 *)mfgPage7, 0, data_sz);
5293 + cfg.physAddr = mfgPage7_dma;
5294 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5295 +
5296 + if ((rc = mpt_config(ioc, &cfg)) != 0)
5297 + goto csmisas_get_manuf_pg_7_exit;
5298 +
5299 + /* copy buffer back to user */
5300 + memcpy(mfgpage7_buffer, mfgPage7, min(data_sz, mfg_size));
5301 +
5302 + csmisas_get_manuf_pg_7_exit:
5303 +
5304 + if (mfgPage7)
5305 + pci_free_consistent(ioc->pcidev, data_sz, (u8 *)mfgPage7,
5306 + mfgPage7_dma);
5307 +
5308 + return rc;
5309 +}
5310 +
5311 +/**
5312 + * Prototype Routine for the CSMI SAS Get Connector info command.
5313 + *
5314 + * Outputs: None.
5315 + * Return: 0 if successful
5316 + * -EFAULT if data unavailable
5317 + * -ENODEV if no such device/adapter
5318 + **/
5319 +static int
5320 +csmisas_get_connector_info(unsigned long arg)
5321 +{
5322 + CSMI_SAS_CONNECTOR_INFO_BUFFER __user *uarg = (void __user *) arg;
5323 + CSMI_SAS_CONNECTOR_INFO_BUFFER karg;
5324 + MPT_ADAPTER *ioc = NULL;
5325 + ManufacturingPage7_t *mfgPg7 = NULL;
5326 + int mfgPg7_sz;
5327 + int iocnum;
5328 + int i;
5329 +
5330 + if (copy_from_user(&karg, uarg,
5331 + sizeof(CSMI_SAS_CONNECTOR_INFO_BUFFER))) {
5332 + printk(KERN_ERR "%s@%d::%s() - "
5333 + "Unable to read in csmi_sas_connector_info_buffer"
5334 + " struct @ %p\n",
5335 + __FILE__, __LINE__, __FUNCTION__, uarg);
5336 + return -EFAULT;
5337 + }
5338 +
5339 + if (((iocnum = mpt_verify_adapter(karg.IoctlHeader.IOControllerNumber,
5340 + &ioc)) < 0) || (ioc == NULL)) {
5341 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
5342 + __FILE__, __FUNCTION__, __LINE__, iocnum);
5343 + return -ENODEV;
5344 + }
5345 +
5346 + if (!csmisas_is_this_sas_cntr(ioc)) {
5347 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
5348 + __FILE__, __FUNCTION__, __LINE__, iocnum);
5349 + return -ENODEV;
5350 + }
5351 +
5352 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
5353 +
5354 + karg.IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
5355 +
5356 + /* `32` is the sizeof MPI_MANPAGE7_CONNECTOR_INFO */
5357 + for (i = 0; i < 32; i++) {
5358 + karg.Reference[i].uPinout = CSMI_SAS_CON_UNKNOWN;
5359 + strcpy(karg.Reference[i].bConnector,"");
5360 + karg.Reference[i].bLocation = CSMI_SAS_CON_UNKNOWN;
5361 + }
5362 +
5363 + mfgPg7_sz = offsetof(CONFIG_PAGE_MANUFACTURING_7,ConnectorInfo) +
5364 + (ioc->num_ports * sizeof(MPI_MANPAGE7_CONNECTOR_INFO));
5365 + mfgPg7 = kmalloc(mfgPg7_sz, GFP_KERNEL);
5366 + if (!mfgPg7){
5367 + printk(KERN_ERR "%s@%d::%s() - "
5368 + "Unable to malloc @ %p\n",
5369 + __FILE__, __LINE__, __FUNCTION__, mfgPg7);
5370 + return -EFAULT;
5371 + }
5372 + memset(mfgPg7, 0, mfgPg7_sz);
5373 +
5374 + if (!csmisas_get_manuf_pg_7(ioc, mfgPg7, mfgPg7_sz)) {
5375 + for (i = 0; i < ioc->num_ports; i++) {
5376 + karg.Reference[i].uPinout =
5377 + le32_to_cpu(mfgPg7->ConnectorInfo[i].Pinout);
5378 + /*endian conversion , this is u8 * 16 ?? */
5379 + strncpy(karg.Reference[i].bConnector,
5380 + mfgPg7->ConnectorInfo[i].Connector, 16);
5381 + karg.Reference[i].bLocation =
5382 + mfgPg7->ConnectorInfo[i].Location;
5383 + }
5384 + }
5385 +
5386 + kfree(mfgPg7);
5387 +
5388 + /* Copy the data from kernel memory to user memory
5389 + */
5390 + if (copy_to_user(uarg, &karg,
5391 + sizeof(CSMI_SAS_CONNECTOR_INFO_BUFFER))) {
5392 + printk(KERN_ERR "%s@%d::%s() - "
5393 + "Unable to write out csmi_sas_connector_info_buffer @"
5394 + "%p\n",
5395 + __FILE__, __LINE__, __FUNCTION__, uarg);
5396 + return -EFAULT;
5397 + }
5398 +
5399 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
5400 + return 0;
5401 +}
5402 +
5403 +/**
5404 + * csmisas_fill_location_data
5405 + *
5406 + * Outputs: None.
5407 + * Return: 0 if successful
5408 + **/
5409 +static int
5410 +csmisas_fill_location_data(MPT_ADAPTER *ioc, u8 bus, u8 id, u8 opcode,
5411 + CSMI_SAS_LOCATION_IDENTIFIER * location_ident)
5412 +{
5413 +
5414 + ConfigExtendedPageHeader_t hdr;
5415 + CONFIGPARMS cfg;
5416 + int rc;
5417 + SasDevicePage0_t *sasDevicePg0=NULL;
5418 + SasEnclosurePage0_t *sasEnclosurePg0=NULL;
5419 + dma_addr_t sasDevicePg0_dma,sasEnclosurePg0_dma;
5420 + int sasDevicePg0_data_sz=0;
5421 + int sasEnclosurePg0_data_sz=0;
5422 + u64 sas_address;
5423 +
5424 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
5425 + memset (location_ident, 0, sizeof(*location_ident));
5426 +
5427 + /* SAS Device Page 0 */
5428 + hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
5429 + hdr.ExtPageLength = 0;
5430 + hdr.PageNumber = 0;
5431 + hdr.Reserved1 = 0;
5432 + hdr.Reserved2 = 0;
5433 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5434 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE;
5435 +
5436 + cfg.cfghdr.ehdr = &hdr;
5437 + cfg.physAddr = -1;
5438 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5439 + cfg.dir = 0; /* read */
5440 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
5441 +
5442 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
5443 + rc=-1;
5444 + goto fill_location_data_exit;
5445 + }
5446 +
5447 + if (hdr.ExtPageLength == 0) {
5448 + rc=-1;
5449 + goto fill_location_data_exit;
5450 + }
5451 +
5452 + sasDevicePg0_data_sz = hdr.ExtPageLength * 4;
5453 + sasDevicePg0 = (SasDevicePage0_t *) pci_alloc_consistent(
5454 + ioc->pcidev, sasDevicePg0_data_sz, &sasDevicePg0_dma);
5455 + if (!sasDevicePg0) {
5456 + rc=-1;
5457 + goto fill_location_data_exit;
5458 + }
5459 +
5460 + memset((u8 *)sasDevicePg0, 0, sasDevicePg0_data_sz);
5461 + cfg.physAddr = sasDevicePg0_dma;
5462 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5463 + cfg.pageAddr = (bus << 8) + id
5464 + + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
5465 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT);
5466 +
5467 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
5468 + rc=-1;
5469 + goto fill_location_data_exit;
5470 + }
5471 +
5472 + location_ident->bLocationFlags |= CSMI_SAS_LOCATE_SAS_ADDRESS_VALID;
5473 + memcpy(&sas_address, &sasDevicePg0->SASAddress, sizeof(u64));
5474 + sas_address = reverse_byte_order64(sas_address);
5475 + memcpy(location_ident->bSASAddress, &sas_address, sizeof(u64));
5476 +
5477 + location_ident->bLocationFlags |= CSMI_SAS_LOCATE_SAS_LUN_VALID;
5478 + memset(location_ident->bSASLun, 0, sizeof(location_ident->bSASLun));
5479 +
5480 + /* SAS Enclosure Page 0 */
5481 + hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
5482 + hdr.ExtPageLength = 0;
5483 + hdr.PageNumber = 0;
5484 + hdr.Reserved1 = 0;
5485 + hdr.Reserved2 = 0;
5486 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5487 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
5488 +
5489 + cfg.cfghdr.ehdr = &hdr;
5490 + cfg.physAddr = -1;
5491 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5492 + cfg.dir = 0; /* read */
5493 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
5494 +
5495 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
5496 + rc=0;
5497 + goto fill_location_data_exit;
5498 + }
5499 +
5500 + if (hdr.ExtPageLength == 0) {
5501 + rc=0;
5502 + goto fill_location_data_exit;
5503 + }
5504 +
5505 + sasEnclosurePg0_data_sz = hdr.ExtPageLength * 4;
5506 + sasEnclosurePg0 = (SasEnclosurePage0_t *) pci_alloc_consistent(
5507 + ioc->pcidev, sasEnclosurePg0_data_sz, &sasEnclosurePg0_dma);
5508 + if (!sasEnclosurePg0) {
5509 + rc=0;
5510 + goto fill_location_data_exit;
5511 + }
5512 + cfg.physAddr = sasEnclosurePg0_dma;
5513 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5514 + cfg.pageAddr = sasDevicePg0->EnclosureHandle
5515 + + (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << MPI_SAS_ENCLOS_PGAD_FORM_SHIFT);
5516 +
5517 + if ((rc = mpt_config(ioc, &cfg)) != 0) {
5518 + rc=0;
5519 + goto fill_location_data_exit;
5520 + }
5521 +
5522 + location_ident->bLocationFlags |= CSMI_SAS_LOCATE_ENCLOSURE_IDENTIFIER_VALID;
5523 + memcpy(&sas_address, &sasEnclosurePg0->EnclosureLogicalID, sizeof(u64));
5524 + sas_address = reverse_byte_order64(sas_address);
5525 + if (sas_address)
5526 + memcpy(location_ident->bEnclosureIdentifier, &sas_address, sizeof(u64));
5527 + else
5528 + strcpy(location_ident->bEnclosureIdentifier,"Internal");
5529 +
5530 +// bBayPrefix - not supported
5531 +
5532 +// TODO - We need to look at sasEnclosurePg0-.Flags , to determine
5533 +// whether SEP BUS/TargetID is valid. Ifs its a SES device, then
5534 +// issue internal inquiry to (bus/id) to gather the Enclosure name.
5535 +// If the device is SMP, then issue SMP_MANUFACTURING to get enclosure name
5536 +// If its direct attached, there is no enclosure name
5537 + location_ident->bLocationFlags |= CSMI_SAS_LOCATE_ENCLOSURE_NAME_VALID;
5538 + strcpy(location_ident->bEnclosureName,"Not Supported");
5539 +
5540 + location_ident->bLocationFlags |= CSMI_SAS_LOCATE_LOCATION_STATE_VALID;
5541 + location_ident->bLocationState = CSMI_SAS_LOCATE_UNKNOWN;
5542 +
5543 + location_ident->bLocationFlags |= CSMI_SAS_LOCATE_BAY_IDENTIFIER_VALID;
5544 + location_ident->bBayIdentifier = le16_to_cpu(sasDevicePg0->Slot);
5545 +
5546 +
5547 +// TODO - illuminating LEDs,
5548 +// karg->bIdentify = CSMI_SAS_LOCATE_FORCE_OFF, CSMI_SAS_LOCATE_FORCE_ON
5549 +// We can enable/disable LEDs by SCSI Enclosure Processor MPI request message
5550 +// printk("Flags=0x%x\n",sasEnclosurePg0->Flags);
5551 +
5552 +/* check sasEnclosurePg0->Flags -
5553 + * to validate whether we need to send the SEPRequest
5554 + * bit:5 should be set
5555 + * bit:3-0 any bit should be set. If zero, then SEPRequest will fail
5556 +*/
5557 +
5558 +/* MPI_FUNCTION_SCSI_ENCLOSURE_PROCESSOR
5559 + * Look in mpi_init.h
5560 + * SEPRequest_t = structure
5561 + *
5562 + * SEPRequest_t->Action should be set to MPI_SEP_REQ_ACTION_WRITE_STATUS
5563 + *
5564 + * SEPRequest_t->Flags should be set to
5565 + * MPI_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS, to pass along enclosure/slot ids
5566 + *
5567 + * SEPRequest_t->SlotStatus |= MPI_SEP_REQ_SLOTSTATUS_IDENTIFY_REQUEST - this
5568 + * will illuminate the LEDs
5569 + */
5570 +
5571 +fill_location_data_exit:
5572 +
5573 + if (sasDevicePg0 != NULL)
5574 + pci_free_consistent(ioc->pcidev, sasDevicePg0_data_sz,
5575 + sasDevicePg0, sasDevicePg0_dma);
5576 +
5577 + if (sasEnclosurePg0 != NULL)
5578 + pci_free_consistent(ioc->pcidev, sasEnclosurePg0_data_sz,
5579 + sasEnclosurePg0, sasEnclosurePg0_dma);
5580 +
5581 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
5582 + return rc;
5583 +}
5584 +
5585 +static int
5586 +csmisas_fill_location_data_raid(MPT_ADAPTER *ioc, PCSMI_SAS_GET_LOCATION_BUFFER karg, u8 VolumeBus,
5587 + u8 volumeID)
5588 +{
5589 + pRaidVolumePage0_t pVolume0 = NULL;
5590 + pRaidPhysDiskPage0_t pPhysDisk0 = NULL;
5591 + CONFIGPARMS cfg;
5592 + ConfigPageHeader_t header;
5593 + u8 physDiskNumMax;
5594 + int volumepage0sz = 0, physdiskpage0sz = 0;
5595 + dma_addr_t volume0_dma, physdisk0_dma;
5596 + int csmi_sas_get_location_sz;
5597 + int rc = 0, i, idx;
5598 + int num_hotpares;
5599 + u64 totalMaxLBA, tmpTotalMaxLBA;
5600 + IOCPage5_t *iocPage5 = NULL;
5601 + u32 device_info = 0;
5602 + struct sas_device_info *sas_info;
5603 +
5604 + int sz;
5605 +
5606 + csmi_sas_get_location_sz = karg->IoctlHeader.Length;
5607 + physDiskNumMax = (csmi_sas_get_location_sz -
5608 + offsetof(CSMI_SAS_GET_LOCATION_BUFFER,Location))
5609 + / sizeof(CSMI_SAS_LOCATION_IDENTIFIER);
5610 + karg->bNumberOfLocationIdentifiers=0;
5611 +
5612 + /*
5613 + * get RAID Volume Page 0
5614 + */
5615 +
5616 + header.PageVersion = 0;
5617 + header.PageLength = 0;
5618 + header.PageNumber = 0;
5619 + header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
5620 + cfg.cfghdr.hdr = &header;
5621 + cfg.physAddr = -1;
5622 + cfg.pageAddr = (VolumeBus << 8) + volumeID;
5623 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5624 + cfg.dir = 0;
5625 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
5626 + if (mpt_config(ioc, &cfg) != 0) {
5627 + rc = -1;
5628 + goto sas_fill_location_data_raid_exit;
5629 + }
5630 +
5631 + if (header.PageLength == 0) {
5632 + rc = -1;
5633 + goto sas_fill_location_data_raid_exit;
5634 + }
5635 +
5636 + volumepage0sz = header.PageLength * 4;
5637 + pVolume0 = pci_alloc_consistent(ioc->pcidev, volumepage0sz,
5638 + &volume0_dma);
5639 + if (!pVolume0) {
5640 + rc = -1;
5641 + goto sas_fill_location_data_raid_exit;
5642 + }
5643 +
5644 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5645 + cfg.physAddr = volume0_dma;
5646 + if (mpt_config(ioc, &cfg) != 0){
5647 + rc = -1;
5648 + goto sas_fill_location_data_raid_exit;
5649 + }
5650 +
5651 + totalMaxLBA = (u64)le32_to_cpu(pVolume0->MaxLBA) |
5652 + ((u64)le32_to_cpu(pVolume0->MaxLBAHigh)) << 32;
5653 +
5654 + /*
5655 + * get RAID Physical Disk Page 0
5656 + */
5657 + header.PageVersion = 0;
5658 + header.PageLength = 0;
5659 + header.PageNumber = 0;
5660 + header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
5661 + cfg.cfghdr.hdr = &header;
5662 + cfg.physAddr = -1;
5663 + cfg.pageAddr = 0;
5664 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5665 + cfg.dir = 0;
5666 + cfg.timeout = MPT_IOCTL_DEFAULT_TIMEOUT;
5667 + if (mpt_config(ioc, &cfg) != 0) {
5668 + rc = -1;
5669 + goto sas_fill_location_data_raid_exit;
5670 + }
5671 +
5672 + if (header.PageLength == 0) {
5673 + rc = -1;
5674 + goto sas_fill_location_data_raid_exit;
5675 + }
5676 +
5677 + physdiskpage0sz = header.PageLength * 4;
5678 + pPhysDisk0 = pci_alloc_consistent(ioc->pcidev, physdiskpage0sz,
5679 + &physdisk0_dma);
5680 + if (!pPhysDisk0) {
5681 + rc = -1;
5682 + goto sas_fill_location_data_raid_exit;
5683 + }
5684 + cfg.physAddr = physdisk0_dma;
5685 +
5686 + for (i=0; i < min(pVolume0->NumPhysDisks, physDiskNumMax); i++) {
5687 +
5688 + /* obtain a refresh of pPhysDisk0 */
5689 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5690 + cfg.pageAddr = pVolume0->PhysDisk[i].PhysDiskNum;
5691 + if (mpt_config(ioc, &cfg) != 0){
5692 + rc = -1;
5693 + goto sas_fill_location_data_raid_exit;
5694 + }
5695 +
5696 + if((csmisas_fill_location_data(ioc, pPhysDisk0->PhysDiskBus,
5697 + pPhysDisk0->PhysDiskID, karg->bIdentify,
5698 + &karg->Location[karg->bNumberOfLocationIdentifiers])) == 0)
5699 + karg->bNumberOfLocationIdentifiers++;
5700 +
5701 + if (device_info)
5702 + continue;
5703 + sas_info = csmisas_get_device_component_by_fw(ioc,
5704 + pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID);
5705 + if (!sas_info || sas_info->is_cached)
5706 + continue;
5707 + device_info = sas_info->device_info;
5708 + }
5709 +
5710 + if (pVolume0->VolumeType == MPI_RAID_VOL_TYPE_IS)
5711 + goto sas_fill_location_data_raid_exit;
5712 +
5713 + /*
5714 + * hot spare support
5715 + *
5716 + */
5717 +
5718 + num_hotpares = csmisas_get_number_hotspares(ioc);
5719 +
5720 + if (num_hotpares) {
5721 +
5722 + sz = offsetof(IOCPage5_t, HotSpare) +
5723 + num_hotpares * sizeof(IOC_5_HOT_SPARE);
5724 + iocPage5 = kmalloc(sz, GFP_KERNEL);
5725 +
5726 + if (!iocPage5)
5727 + goto sas_fill_location_data_raid_exit;
5728 + memset(iocPage5, 0, sizeof(*iocPage5));
5729 +
5730 + if (csmisas_get_ioc_pg5(ioc, iocPage5, sz) != 0)
5731 + goto sas_fill_location_data_raid_exit;
5732 +
5733 + for(i = 0, idx = pVolume0->NumPhysDisks ; i < num_hotpares;
5734 + i++, idx++) {
5735 +
5736 + if (idx >= physDiskNumMax)
5737 + break;
5738 +
5739 + /* obtain a refresh of pPhysDisk0 */
5740 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5741 + cfg.pageAddr = iocPage5->HotSpare[i].PhysDiskNum;
5742 + if (mpt_config(ioc, &cfg) != 0)
5743 + goto sas_fill_location_data_raid_exit;
5744 +
5745 + /* Search the list for the matching SAS address. */
5746 + sas_info = csmisas_get_device_component_by_fw(ioc,
5747 + pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID);
5748 +
5749 + if (!sas_info || sas_info->is_cached)
5750 + continue;
5751 +
5752 + /* don't mix SSP hot spare
5753 + * in SATA volume
5754 + */
5755 + if (!csmisas_is_sata(pPhysDisk0) &&
5756 + (device_info &
5757 + MPI_SAS_DEVICE_INFO_SATA_DEVICE))
5758 + continue;
5759 +
5760 + /* don't mix SATA hot spare
5761 + * in SSP volume
5762 + */
5763 + if (csmisas_is_sata(pPhysDisk0) &&
5764 + (device_info &
5765 + MPI_SAS_DEVICE_INFO_SSP_TARGET))
5766 + continue;
5767 +
5768 + /* capacity check for IM volumes*/
5769 + if ((pVolume0->VolumeType ==
5770 + MPI_RAID_VOL_TYPE_IM) &&
5771 + (totalMaxLBA +
5772 + (64*2*1024) /* metadata = 64MB*/ >
5773 + le32_to_cpu(pPhysDisk0->MaxLBA)))
5774 + continue;
5775 +
5776 + tmpTotalMaxLBA = totalMaxLBA;
5777 + do_div(tmpTotalMaxLBA, pVolume0->NumPhysDisks);
5778 + /* capacity check for IME volumes*/
5779 + if ((pVolume0->VolumeType ==
5780 + MPI_RAID_VOL_TYPE_IME) &&
5781 + ((tmpTotalMaxLBA * 2) +
5782 + (64*2*1024 ) /*metadata = 64MB*/ >
5783 + le32_to_cpu(pPhysDisk0->MaxLBA)))
5784 + continue;
5785 +
5786 + if((csmisas_fill_location_data(ioc,
5787 + pPhysDisk0->PhysDiskBus, pPhysDisk0->PhysDiskID,
5788 + karg->bIdentify,
5789 + &karg->Location[karg->bNumberOfLocationIdentifiers])) == 0)
5790 + karg->bNumberOfLocationIdentifiers++;
5791 + }
5792 + }
5793 +
5794 +
5795 + sas_fill_location_data_raid_exit:
5796 +
5797 + kfree(iocPage5);
5798 +
5799 + if (pVolume0)
5800 + pci_free_consistent(ioc->pcidev, volumepage0sz, pVolume0,
5801 + volume0_dma);
5802 +
5803 + if(pPhysDisk0)
5804 + pci_free_consistent(ioc->pcidev, physdiskpage0sz, pPhysDisk0,
5805 + physdisk0_dma);
5806 +
5807 + return rc;
5808 +}
5809 +
5810 +/**
5811 + * Prototype Routine for the CSMI SAS Get location command.
5812 + *
5813 + * Outputs: None.
5814 + * Return: 0 if successful
5815 + * -EFAULT if data unavailable
5816 + * -ENODEV if no such device/adapter
5817 + */
5818 +static int
5819 +csmisas_get_location(unsigned long arg)
5820 +{
5821 + CSMI_SAS_GET_LOCATION_BUFFER __user *uarg = (void __user *) arg;
5822 + PCSMI_SAS_GET_LOCATION_BUFFER karg;
5823 + IOCTL_HEADER ioctl_header;
5824 + MPT_ADAPTER *ioc = NULL;
5825 + int iocnum,i;
5826 + int csmi_sas_get_location_sz;
5827 + int memory_pages;
5828 + struct sas_device_info *sas_info;
5829 +
5830 + if (copy_from_user(&ioctl_header, uarg, sizeof(IOCTL_HEADER))) {
5831 + printk(KERN_ERR "%s@%d::%s() - "
5832 + "Unable to read in IOCTL_HEADER"
5833 + "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
5834 + return -EFAULT;
5835 + }
5836 +
5837 + csmi_sas_get_location_sz = ioctl_header.Length;
5838 + memory_pages = get_order(csmi_sas_get_location_sz);
5839 + karg = (PCSMI_SAS_GET_LOCATION_BUFFER)__get_free_pages(
5840 + GFP_KERNEL, memory_pages);
5841 + if (!karg){
5842 + printk(KERN_ERR "%s@%d::%s() - "
5843 + "Unable to malloc GET_LOCATION_BUFFER "
5844 + "csmi_sas_get_location_sz=%d memory_pages=%d\n",
5845 + __FILE__, __LINE__, __FUNCTION__,
5846 + csmi_sas_get_location_sz, memory_pages);
5847 + return -ENOMEM;
5848 + }
5849 + memset(karg, 0, sizeof(*karg));
5850 +
5851 + if (copy_from_user(karg, uarg, csmi_sas_get_location_sz)) {
5852 + printk(KERN_ERR "%s@%d::%s() - "
5853 + "Unable to read in csmi_sas_phy_control_buffer "
5854 + "struct @ %p\n", __FILE__, __LINE__, __FUNCTION__, uarg);
5855 + free_pages((unsigned long)karg, memory_pages);
5856 + return -EFAULT;
5857 + }
5858 +
5859 + if (((iocnum = mpt_verify_adapter(karg->IoctlHeader.IOControllerNumber,
5860 + &ioc)) < 0) || (ioc == NULL)) {
5861 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
5862 + __FILE__, __FUNCTION__, __LINE__, iocnum);
5863 + free_pages((unsigned long)karg, memory_pages);
5864 + return -ENODEV;
5865 + }
5866 +
5867 + if (!csmisas_is_this_sas_cntr(ioc)) {
5868 + printk(KERN_ERR "%s::%s() @%d - ioc%d not SAS controller!\n",
5869 + __FILE__, __FUNCTION__, __LINE__, iocnum);
5870 + free_pages((unsigned long)karg, memory_pages);
5871 + return -ENODEV;
5872 + }
5873 +
5874 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s enter.\n",__FUNCTION__));
5875 +
5876 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_INVALID_PARAMETER;
5877 + if(karg->bLengthOfLocationIdentifier !=
5878 + sizeof(CSMI_SAS_LOCATION_IDENTIFIER))
5879 + goto cim_sas_get_location_exit;
5880 +
5881 + sas_info = csmisas_get_device_component_by_os(ioc, karg->bPathId,
5882 + karg->bTargetId);
5883 + if (!sas_info)
5884 + goto cim_sas_get_location_exit;
5885 +
5886 + /* RAID SUPPORT */
5887 + if (ioc->raid_data.pIocPg2 && sas_info->is_logical_volume) {
5888 + for (i=0; i<ioc->raid_data.pIocPg2->NumActiveVolumes; i++){
5889 + if (sas_info->fw.id ==
5890 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID &&
5891 + sas_info->fw.channel ==
5892 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus) {
5893 + if(csmisas_fill_location_data_raid(ioc, karg,
5894 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus,
5895 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID) == 0)
5896 + karg->IoctlHeader.ReturnCode =
5897 + CSMI_SAS_STATUS_SUCCESS;
5898 + else
5899 + karg->IoctlHeader.ReturnCode =
5900 + CSMI_SAS_STATUS_FAILED;
5901 + goto cim_sas_get_location_exit;
5902 + }
5903 + }
5904 + }
5905 +
5906 + /* NON-RAID SUPPORT */
5907 + if (sas_info->is_cached || sas_info->is_logical_volume)
5908 + goto cim_sas_get_location_exit;
5909 +
5910 + /* make sure there's enough room to populate the Location[] struct */
5911 + if ((csmi_sas_get_location_sz -
5912 + offsetof(CSMI_SAS_GET_LOCATION_BUFFER,Location)) <
5913 + sizeof(CSMI_SAS_LOCATION_IDENTIFIER))
5914 + goto cim_sas_get_location_exit;
5915 +
5916 + karg->bNumberOfLocationIdentifiers=1;
5917 + karg->Location[0].bLocationFlags=0;
5918 + if((csmisas_fill_location_data(ioc, sas_info->fw.channel,
5919 + sas_info->fw.id, karg->bIdentify, &karg->Location[0])) == 0)
5920 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
5921 + else
5922 + karg->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
5923 +
5924 + cim_sas_get_location_exit:
5925 +
5926 + /* Copy the data from kernel memory to user memory
5927 + */
5928 + if (copy_to_user(uarg, karg, csmi_sas_get_location_sz)) {
5929 + printk(KERN_ERR "%s@%d::%s() - "
5930 + "Unable to write out csmi_sas_get_location_buffer "
5931 + "@ %p\n",__FILE__, __LINE__, __FUNCTION__, uarg);
5932 + free_pages((unsigned long)karg, memory_pages);
5933 + return -EFAULT;
5934 + }
5935 +
5936 + dcsmisasprintk(ioc, printk(KERN_DEBUG "%s exit.\n",__FUNCTION__));
5937 + free_pages((unsigned long)karg, memory_pages);
5938 + return 0;
5939 +}
5940 --- /dev/null
5941 +++ b/drivers/message/fusion/csmi/csmisas.h
5942 @@ -0,0 +1,1854 @@
5943 +/**************************************************************************
5944 +
5945 +Module Name:
5946 +
5947 + CSMISAS.H
5948 +
5949 +
5950 +Abstract:
5951 +
5952 + This file contains constants and data structure definitions used by drivers
5953 + that support the Common Storage Management Interface specification for
5954 + SAS or SATA in either the Windows or Linux.
5955 +
5956 + This should be considered as a reference implementation only. Changes may
5957 + be necessary to accommodate a specific build environment or target OS.
5958 +
5959 +Revision History:
5960 +
5961 + 001 SEF 8/12/03 Initial release.
5962 + 002 SEF 8/20/03 Cleanup to match documentation.
5963 + 003 SEF 9/12/03 Additional cleanup, created combined header
5964 + 004 SEF 9/23/03 Changed base types to match linux defaults
5965 + Added RAID signature
5966 + Added bControllerFlags to CSMI_SAS_CNTLR_CONFIG
5967 + Changed CSMI_SAS_BEGIN_PACK to 8 for common structures
5968 + Fixed other typos identified in first compilation test
5969 + 005 SEF 10/03/03 Additions to match first version of CSMI document
5970 + 006 SEF 10/14/03 Fixed typedef struct _CSMI_SAS_SMP_PASSTHRU_BUFFER
5971 + Added defines for bConnectionRate
5972 + 007 SEF 10/15/03 Added Firmware Download Control Code and support
5973 + Added CSMI revision support
5974 + 008 SEF 10/30/03 No functional change, just updated version to track
5975 + spec changes
5976 + 009 SEF 12/09/03 No functional change, just updated version to track
5977 + spec changes
5978 + 010 SEF 3/11/04 Fixed typedef struct CSMI_SAS_RAID_DRIVES to include the
5979 + bFirmware member that is defined in the spec, but
5980 + was missing in this file,
5981 + added CC_CSMI_SAS_TASK_MANAGEMENT
5982 + 011 SEF 4/02/04 No functional change, added comment line before
5983 + CC_CSMI_SAS_TASK_MANAGEMENT
5984 + 012 SEF 4/16/04 Added IOControllerNumber to linux header,
5985 + Modified linux control codes to have upper word of
5986 + 0xCC77.... to indicate CSMI version 77
5987 + Added bSignalClass to CC_CSMI_SET_PHY_INFO
5988 + Added CC_CSMI_SAS_PHY_CONTROL support
5989 + 013 SEF 5/14/04 Added CC_CSMI_SAS_GET_CONNECTOR_INFO support
5990 + 014 SEF 5/24/04 No functional change, just updated version to track spec
5991 + changes
5992 + 015 SEF 6/16/04 changed bPinout to uPinout to reflect proper size,
5993 + changed width of bLocation defines to reflect size
5994 + 016 SEF 6/17/04 changed bLengthOfControls in CSMI_SAS_PHY_CONTROL
5995 + to be proper size
5996 + 017 SEF 9/17/04 added CSMI_SAS_SATA_PORT_SELECTOR,
5997 + CSMI_SAS_LINK_VIRTUAL, CSMI_SAS_CON_NOT_PRESENT, and
5998 + CSMI_SAS_CON_NOT_CONNECTED
5999 + 018 SEF 9/20/04 added CSMI_SAS_PHY_USER_PATTERN,
6000 + changed definition of CSMI_SAS_PHY_FIXED_PATTERN to not
6001 + conflict with activate definition
6002 + 019 SEF 12/06/04 added CSMI_SAS_GET_LOCATION
6003 + added bSSPStatus to CSMI_SAS_SSP_PASSTHRU_STATUS
6004 + structure
6005 + 020 SEF 5/25/05 added CSMI_SAS_PHY_VIRTUAL_SMP, and changes to
6006 + CSMI_SAS_GET_LOCATION
6007 + 021 SEF 11/03/05 added new RAID creation functionality
6008 + 022 SEF 2/01/06 corrected typo bNegotitiatedLInkRate
6009 + Added two more RAID_TYPES, 7 and 8
6010 + 023 SEF 4/04/06 added CSMI_RAID_TYPE_1E
6011 + changed structures that contained surface scan
6012 + to priority approach rather than time, causes
6013 + 0.89 to incompatible with 0.87, so a version
6014 + check is necessary when interpreting the
6015 + raid structures
6016 + Added netware section
6017 + 024 DRG 5/22/06 Added uFailureCode to CSMI_SAS_RAID_CONFIG and
6018 + CSMI_SAS_RAID_FEATURES
6019 + Changed __u64 fields to high and low __u32 fields in
6020 + order to avoid backward compatibility issues with
6021 + packing and alignment.
6022 + Fixed alignment problem in CSMI_SAS_RAID_DRIVES.
6023 + Added CSMI_SAS_CNTLR_SMART_ARRAY to uControllerFlags
6024 + Reassigned the value of CSMI_SAS_CNTLR_RAID_CFG_SUPPORT
6025 + to avoid a conflict.
6026 +
6027 +**************************************************************************/
6028 +
6029 +#ifndef _CSMI_SAS_H_
6030 +#define _CSMI_SAS_H_
6031 +
6032 +// CSMI Specification Revision, the intent is that all versions of the
6033 +// specification will be backward compatible after the 1.00 release.
6034 +// Major revision number, corresponds to xxxx. of CSMI specification
6035 +// Minor revision number, corresponds to .xxxx of CSMI specification
6036 +#define CSMI_MAJOR_REVISION 0
6037 +#define CSMI_MINOR_REVISION 90
6038 +
6039 +/*************************************************************************/
6040 +/* PATCHES FOR TYPOS */
6041 +/*************************************************************************/
6042 +
6043 +#define bNegotitiatedLInkRate bNegotiatedLinkRate
6044 +
6045 +/*************************************************************************/
6046 +/* TARGET OS LINUX SPECIFIC CODE */
6047 +/*************************************************************************/
6048 +
6049 +// EDM #ifdef _linux
6050 +#ifdef __KERNEL__
6051 +
6052 +// Linux base types
6053 +
6054 +#include <linux/types.h>
6055 +
6056 +#define __i8 char
6057 +
6058 +// pack definition
6059 +
6060 +// EDM #define CSMI_SAS_BEGIN_PACK(x) pack(x)
6061 +// EDM #define CSMI_SAS_END_PACK pack()
6062 +
6063 +// IOCTL Control Codes
6064 +// (IoctlHeader.ControlCode)
6065 +
6066 +// Control Codes prior to 0.77
6067 +
6068 +// Control Codes requiring CSMI_ALL_SIGNATURE
6069 +
6070 +// #define CC_CSMI_SAS_GET_DRIVER_INFO 0x12345678
6071 +// #define CC_CSMI_SAS_GET_CNTLR_CONFIG 0x23456781
6072 +// #define CC_CSMI_SAS_GET_CNTLR_STATUS 0x34567812
6073 +// #define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 0x92345678
6074 +
6075 +// Control Codes requiring CSMI_RAID_SIGNATURE
6076 +
6077 +// #define CC_CSMI_SAS_GET_RAID_INFO 0x45678123
6078 +// #define CC_CSMI_SAS_GET_RAID_CONFIG 0x56781234
6079 +
6080 +// Control Codes requiring CSMI_SAS_SIGNATURE
6081 +
6082 +// #define CC_CSMI_SAS_GET_PHY_INFO 0x67812345
6083 +// #define CC_CSMI_SAS_SET_PHY_INFO 0x78123456
6084 +// #define CC_CSMI_SAS_GET_LINK_ERRORS 0x81234567
6085 +// #define CC_CSMI_SAS_SMP_PASSTHRU 0xA1234567
6086 +// #define CC_CSMI_SAS_SSP_PASSTHRU 0xB1234567
6087 +// #define CC_CSMI_SAS_STP_PASSTHRU 0xC1234567
6088 +// #define CC_CSMI_SAS_GET_SATA_SIGNATURE 0xD1234567
6089 +// #define CC_CSMI_SAS_GET_SCSI_ADDRESS 0xE1234567
6090 +// #define CC_CSMI_SAS_GET_DEVICE_ADDRESS 0xF1234567
6091 +// #define CC_CSMI_SAS_TASK_MANAGEMENT 0xA2345678
6092 +
6093 +// Control Codes for 0.77 and later
6094 +
6095 +// Control Codes requiring CSMI_ALL_SIGNATURE
6096 +
6097 +#define CC_CSMI_SAS_GET_DRIVER_INFO 0xCC770001
6098 +#define CC_CSMI_SAS_GET_CNTLR_CONFIG 0xCC770002
6099 +#define CC_CSMI_SAS_GET_CNTLR_STATUS 0xCC770003
6100 +#define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 0xCC770004
6101 +
6102 +// Control Codes requiring CSMI_RAID_SIGNATURE
6103 +
6104 +#define CC_CSMI_SAS_GET_RAID_INFO 0xCC77000A
6105 +#define CC_CSMI_SAS_GET_RAID_CONFIG 0xCC77000B
6106 +#define CC_CSMI_SAS_GET_RAID_FEATURES 0xCC77000C
6107 +#define CC_CSMI_SAS_SET_RAID_CONTROL 0xCC77000D
6108 +#define CC_CSMI_SAS_GET_RAID_ELEMENT 0xCC77000E
6109 +#define CC_CSMI_SAS_SET_RAID_OPERATION 0xCC77000F
6110 +
6111 +// Control Codes requiring CSMI_SAS_SIGNATURE
6112 +
6113 +#define CC_CSMI_SAS_GET_PHY_INFO 0xCC770014
6114 +#define CC_CSMI_SAS_SET_PHY_INFO 0xCC770015
6115 +#define CC_CSMI_SAS_GET_LINK_ERRORS 0xCC770016
6116 +#define CC_CSMI_SAS_SMP_PASSTHRU 0xCC770017
6117 +#define CC_CSMI_SAS_SSP_PASSTHRU 0xCC770018
6118 +#define CC_CSMI_SAS_STP_PASSTHRU 0xCC770019
6119 +#define CC_CSMI_SAS_GET_SATA_SIGNATURE 0xCC770020
6120 +#define CC_CSMI_SAS_GET_SCSI_ADDRESS 0xCC770021
6121 +#define CC_CSMI_SAS_GET_DEVICE_ADDRESS 0xCC770022
6122 +#define CC_CSMI_SAS_TASK_MANAGEMENT 0xCC770023
6123 +#define CC_CSMI_SAS_GET_CONNECTOR_INFO 0xCC770024
6124 +#define CC_CSMI_SAS_GET_LOCATION 0xCC770025
6125 +
6126 +
6127 +// Control Codes requiring CSMI_PHY_SIGNATURE
6128 +
6129 +#define CC_CSMI_SAS_PHY_CONTROL 0xCC77003C
6130 +
6131 +// EDM #pragma CSMI_SAS_BEGIN_PACK(8)
6132 +#pragma pack(8)
6133 +
6134 +// IOCTL_HEADER
6135 +typedef struct _IOCTL_HEADER {
6136 + __u32 IOControllerNumber;
6137 + __u32 Length;
6138 + __u32 ReturnCode;
6139 + __u32 Timeout;
6140 + __u16 Direction;
6141 +} IOCTL_HEADER,
6142 + *PIOCTL_HEADER;
6143 +
6144 +// EDM #pragma CSMI_SAS_END_PACK
6145 +#pragma pack()
6146 +
6147 +#endif
6148 +
6149 +/*************************************************************************/
6150 +/* TARGET OS WINDOWS SPECIFIC CODE */
6151 +/*************************************************************************/
6152 +
6153 +#ifdef _WIN32
6154 +
6155 +// windows IOCTL definitions
6156 +
6157 +#ifndef _NTDDSCSIH_
6158 +#include <ntddscsi.h>
6159 +#endif
6160 +
6161 +// pack definition
6162 +
6163 +#if defined _MSC_VER
6164 + #define CSMI_SAS_BEGIN_PACK(x) pack(push,x)
6165 + #define CSMI_SAS_END_PACK pack(pop)
6166 +#elif defined __BORLANDC__
6167 + #define CSMI_SAS_BEGIN_PACK(x) option -a##x
6168 + #define CSMI_SAS_END_PACK option -a.
6169 +#else
6170 + #error "CSMISAS.H - Must externally define a pack compiler designator."
6171 +#endif
6172 +
6173 +// base types
6174 +
6175 +#define __u8 unsigned char
6176 +#define __u16 unsigned short
6177 +#define __u32 unsigned long
6178 +#define __u64 unsigned __int64
6179 +
6180 +#define __i8 char
6181 +
6182 +// IOCTL Control Codes
6183 +// (IoctlHeader.ControlCode)
6184 +
6185 +// Control Codes requiring CSMI_ALL_SIGNATURE
6186 +
6187 +#define CC_CSMI_SAS_GET_DRIVER_INFO 1
6188 +#define CC_CSMI_SAS_GET_CNTLR_CONFIG 2
6189 +#define CC_CSMI_SAS_GET_CNTLR_STATUS 3
6190 +#define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 4
6191 +
6192 +// Control Codes requiring CSMI_RAID_SIGNATURE
6193 +
6194 +#define CC_CSMI_SAS_GET_RAID_INFO 10
6195 +#define CC_CSMI_SAS_GET_RAID_CONFIG 11
6196 +#define CC_CSMI_SAS_GET_RAID_FEATURES 12
6197 +#define CC_CSMI_SAS_SET_RAID_CONTROL 13
6198 +#define CC_CSMI_SAS_GET_RAID_ELEMENT 14
6199 +#define CC_CSMI_SAS_SET_RAID_OPERATION 15
6200 +
6201 +// Control Codes requiring CSMI_SAS_SIGNATURE
6202 +
6203 +#define CC_CSMI_SAS_GET_PHY_INFO 20
6204 +#define CC_CSMI_SAS_SET_PHY_INFO 21
6205 +#define CC_CSMI_SAS_GET_LINK_ERRORS 22
6206 +#define CC_CSMI_SAS_SMP_PASSTHRU 23
6207 +#define CC_CSMI_SAS_SSP_PASSTHRU 24
6208 +#define CC_CSMI_SAS_STP_PASSTHRU 25
6209 +#define CC_CSMI_SAS_GET_SATA_SIGNATURE 26
6210 +#define CC_CSMI_SAS_GET_SCSI_ADDRESS 27
6211 +#define CC_CSMI_SAS_GET_DEVICE_ADDRESS 28
6212 +#define CC_CSMI_SAS_TASK_MANAGEMENT 29
6213 +#define CC_CSMI_SAS_GET_CONNECTOR_INFO 30
6214 +#define CC_CSMI_SAS_GET_LOCATION 31
6215 +
6216 +// Control Codes requiring CSMI_PHY_SIGNATURE
6217 +
6218 +#define CC_CSMI_SAS_PHY_CONTROL 60
6219 +
6220 +#define IOCTL_HEADER SRB_IO_CONTROL
6221 +#define PIOCTL_HEADER PSRB_IO_CONTROL
6222 +
6223 +#endif
6224 +
6225 +/*************************************************************************/
6226 +/* TARGET OS NETWARE SPECIFIC CODE */
6227 +/*************************************************************************/
6228 +
6229 +#ifdef _NETWARE
6230 +
6231 +// NetWare IOCTL definitions
6232 +
6233 +#define CSMI_SAS_BEGIN_PACK(x) pack(x)
6234 +#define CSMI_SAS_END_PACK pack()
6235 +
6236 +#ifndef LONG
6237 +typedef unsigned long LONG;
6238 +#endif
6239 +
6240 +#ifndef WORD
6241 +typedef unsigned short WORD;
6242 +#endif
6243 +
6244 +#ifndef BYTE
6245 +typedef unsigned char BYTE;
6246 +#endif
6247 +
6248 +/* Need to have these definitions for Netware */
6249 +#define __u8 unsigned char
6250 +#define __u16 unsigned short
6251 +#define __u32 unsigned long
6252 +#define __u64 unsigned __int64
6253 +
6254 +#define __i8 char
6255 +
6256 +
6257 +// EDM #pragma CSMI_SAS_BEGIN_PACK(8)
6258 +#pragma pack(8)
6259 +
6260 +// IOCTL_HEADER
6261 +typedef struct _IOCTL_HEADER {
6262 + __u32 Length;
6263 + __u32 ReturnCode;
6264 +} IOCTL_HEADER,
6265 + *PIOCTL_HEADER;
6266 +
6267 +// EDM #pragma CSMI_SAS_END_PACK
6268 +#pragma pack()
6269 +
6270 +// IOCTL Control Codes
6271 +// (IoctlHeader.ControlCode)
6272 +
6273 +// Control Codes requiring CSMI_ALL_SIGNATURE
6274 +
6275 +#define CC_CSMI_SAS_GET_DRIVER_INFO 0x01FF0001
6276 +#define CC_CSMI_SAS_GET_CNTLR_CONFIG 0x01FF0002
6277 +#define CC_CSMI_SAS_GET_CNTLR_STATUS 0x01FF0003
6278 +#define CC_CSMI_SAS_FIRMWARE_DOWNLOAD 0x01FF0004
6279 +
6280 +// Control Codes requiring CSMI_RAID_SIGNATURE
6281 +
6282 +#define CC_CSMI_SAS_GET_RAID_INFO 0x01FF000A
6283 +#define CC_CSMI_SAS_GET_RAID_CONFIG 0x01FF000B
6284 +#define CC_CSMI_SAS_GET_RAID_FEATURES 0x01FF000C
6285 +#define CC_CSMI_SAS_SET_RAID_CONTROL 0x01FF000D
6286 +#define CC_CSMI_SAS_GET_RAID_ELEMENT 0x01FF000E
6287 +#define CC_CSMI_SAS_SET_RAID_OPERATION 0x01FF000F
6288 +
6289 +// Control Codes requiring CSMI_SAS_SIGNATURE
6290 +
6291 +#define CC_CSMI_SAS_GET_PHY_INFO 0x01FF0014
6292 +#define CC_CSMI_SAS_SET_PHY_INFO 0x01FF0015
6293 +#define CC_CSMI_SAS_GET_LINK_ERRORS 0x01FF0016
6294 +#define CC_CSMI_SAS_SMP_PASSTHRU 0x01FF0017
6295 +#define CC_CSMI_SAS_SSP_PASSTHRU 0x01FF0018
6296 +#define CC_CSMI_SAS_STP_PASSTHRU 0x01FF0019
6297 +#define CC_CSMI_SAS_GET_SATA_SIGNATURE 0x01FF001A
6298 +#define CC_CSMI_SAS_GET_SCSI_ADDRESS 0x01FF001B
6299 +#define CC_CSMI_SAS_GET_DEVICE_ADDRESS 0x01FF001C
6300 +#define CC_CSMI_SAS_TASK_MANAGEMENT 0x01FF001D
6301 +#define CC_CSMI_SAS_GET_CONNECTOR_INFO 0x01FF001E
6302 +#define CC_CSMI_SAS_GET_LOCATION 0x01FF001F
6303 +
6304 +// Control Codes requiring CSMI_PHY_SIGNATURE
6305 +
6306 +#define CC_CSMI_SAS_PHY_CONTROL 60
6307 +
6308 +#endif
6309 +
6310 +/*************************************************************************/
6311 +/* TARGET OS NOT DEFINED ERROR */
6312 +/*************************************************************************/
6313 +
6314 +// EDM
6315 +//#if (!_WIN32 && !_linux && !_NETWARE)
6316 +// #error "Unknown target OS."
6317 +//#endif
6318 +
6319 +/*************************************************************************/
6320 +/* OS INDEPENDENT CODE */
6321 +/*************************************************************************/
6322 +
6323 +/* * * * * * * * * * Class Independent IOCTL Constants * * * * * * * * * */
6324 +
6325 +// Return codes for all IOCTL's regardless of class
6326 +// (IoctlHeader.ReturnCode)
6327 +
6328 +#define CSMI_SAS_STATUS_SUCCESS 0
6329 +#define CSMI_SAS_STATUS_FAILED 1
6330 +#define CSMI_SAS_STATUS_BAD_CNTL_CODE 2
6331 +#define CSMI_SAS_STATUS_INVALID_PARAMETER 3
6332 +#define CSMI_SAS_STATUS_WRITE_ATTEMPTED 4
6333 +
6334 +// Signature value
6335 +// (IoctlHeader.Signature)
6336 +
6337 +#define CSMI_ALL_SIGNATURE "CSMIALL"
6338 +
6339 +// Timeout value default of 60 seconds
6340 +// (IoctlHeader.Timeout)
6341 +
6342 +#define CSMI_ALL_TIMEOUT 60
6343 +
6344 +// Direction values for data flow on this IOCTL
6345 +// (IoctlHeader.Direction, Linux only)
6346 +#define CSMI_SAS_DATA_READ 0
6347 +#define CSMI_SAS_DATA_WRITE 1
6348 +
6349 +// I/O Bus Types
6350 +// ISA and EISA bus types are not supported
6351 +// (bIoBusType)
6352 +
6353 +#define CSMI_SAS_BUS_TYPE_PCI 3
6354 +#define CSMI_SAS_BUS_TYPE_PCMCIA 4
6355 +
6356 +// Controller Status
6357 +// (uStatus)
6358 +
6359 +#define CSMI_SAS_CNTLR_STATUS_GOOD 1
6360 +#define CSMI_SAS_CNTLR_STATUS_FAILED 2
6361 +#define CSMI_SAS_CNTLR_STATUS_OFFLINE 3
6362 +#define CSMI_SAS_CNTLR_STATUS_POWEROFF 4
6363 +
6364 +// Offline Status Reason
6365 +// (uOfflineReason)
6366 +
6367 +#define CSMI_SAS_OFFLINE_REASON_NO_REASON 0
6368 +#define CSMI_SAS_OFFLINE_REASON_INITIALIZING 1
6369 +#define CSMI_SAS_OFFLINE_REASON_BACKSIDE_BUS_DEGRADED 2
6370 +#define CSMI_SAS_OFFLINE_REASON_BACKSIDE_BUS_FAILURE 3
6371 +
6372 +// Controller Class
6373 +// (bControllerClass)
6374 +
6375 +#define CSMI_SAS_CNTLR_CLASS_HBA 5
6376 +
6377 +// Controller Flag bits
6378 +// (uControllerFlags)
6379 +
6380 +#define CSMI_SAS_CNTLR_SAS_HBA 0x00000001
6381 +#define CSMI_SAS_CNTLR_SAS_RAID 0x00000002
6382 +#define CSMI_SAS_CNTLR_SATA_HBA 0x00000004
6383 +#define CSMI_SAS_CNTLR_SATA_RAID 0x00000008
6384 +#define CSMI_SAS_CNTLR_SMART_ARRAY 0x00000010
6385 +
6386 +// for firmware download
6387 +#define CSMI_SAS_CNTLR_FWD_SUPPORT 0x00010000
6388 +#define CSMI_SAS_CNTLR_FWD_ONLINE 0x00020000
6389 +#define CSMI_SAS_CNTLR_FWD_SRESET 0x00040000
6390 +#define CSMI_SAS_CNTLR_FWD_HRESET 0x00080000
6391 +#define CSMI_SAS_CNTLR_FWD_RROM 0x00100000
6392 +
6393 +// for RAID configuration supported
6394 +#define CSMI_SAS_CNTLR_RAID_CFG_SUPPORT 0x01000000
6395 +
6396 +// Download Flag bits
6397 +// (uDownloadFlags)
6398 +#define CSMI_SAS_FWD_VALIDATE 0x00000001
6399 +#define CSMI_SAS_FWD_SOFT_RESET 0x00000002
6400 +#define CSMI_SAS_FWD_HARD_RESET 0x00000004
6401 +
6402 +// Firmware Download Status
6403 +// (usStatus)
6404 +#define CSMI_SAS_FWD_SUCCESS 0
6405 +#define CSMI_SAS_FWD_FAILED 1
6406 +#define CSMI_SAS_FWD_USING_RROM 2
6407 +#define CSMI_SAS_FWD_REJECT 3
6408 +#define CSMI_SAS_FWD_DOWNREV 4
6409 +
6410 +// Firmware Download Severity
6411 +// (usSeverity>
6412 +#define CSMI_SAS_FWD_INFORMATION 0
6413 +#define CSMI_SAS_FWD_WARNING 1
6414 +#define CSMI_SAS_FWD_ERROR 2
6415 +#define CSMI_SAS_FWD_FATAL 3
6416 +
6417 +/* * * * * * * * * * SAS RAID Class IOCTL Constants * * * * * * * * */
6418 +
6419 +// Return codes for the RAID IOCTL's regardless of class
6420 +// (IoctlHeader.ReturnCode)
6421 +
6422 +#define CSMI_SAS_RAID_SET_OUT_OF_RANGE 1000
6423 +#define CSMI_SAS_RAID_SET_BUFFER_TOO_SMALL 1001
6424 +#define CSMI_SAS_RAID_SET_DATA_CHANGED 1002
6425 +
6426 +// Signature value
6427 +// (IoctlHeader.Signature)
6428 +
6429 +#define CSMI_RAID_SIGNATURE "CSMIARY"
6430 +
6431 +// Timeout value default of 60 seconds
6432 +// (IoctlHeader.Timeout)
6433 +
6434 +#define CSMI_RAID_TIMEOUT 60
6435 +
6436 +// RAID Types
6437 +// (bRaidType)
6438 +#define CSMI_SAS_RAID_TYPE_NONE 0
6439 +#define CSMI_SAS_RAID_TYPE_0 1
6440 +#define CSMI_SAS_RAID_TYPE_1 2
6441 +#define CSMI_SAS_RAID_TYPE_10 3
6442 +#define CSMI_SAS_RAID_TYPE_5 4
6443 +#define CSMI_SAS_RAID_TYPE_15 5
6444 +#define CSMI_SAS_RAID_TYPE_6 6
6445 +#define CSMI_SAS_RAID_TYPE_50 7
6446 +#define CSMI_SAS_RAID_TYPE_VOLUME 8
6447 +#define CSMI_SAS_RAID_TYPE_1E 9
6448 +#define CSMI_SAS_RAID_TYPE_OTHER 255
6449 +// the last value 255 was already defined for other
6450 +// so end is defined as 254
6451 +#define CSMI_SAS_RAID_TYPE_END 254
6452 +
6453 +// RAID Status
6454 +// (bStatus)
6455 +#define CSMI_SAS_RAID_SET_STATUS_OK 0
6456 +#define CSMI_SAS_RAID_SET_STATUS_DEGRADED 1
6457 +#define CSMI_SAS_RAID_SET_STATUS_REBUILDING 2
6458 +#define CSMI_SAS_RAID_SET_STATUS_FAILED 3
6459 +#define CSMI_SAS_RAID_SET_STATUS_OFFLINE 4
6460 +#define CSMI_SAS_RAID_SET_STATUS_TRANSFORMING 5
6461 +#define CSMI_SAS_RAID_SET_STATUS_QUEUED_FOR_REBUILD 6
6462 +#define CSMI_SAS_RAID_SET_STATUS_QUEUED_FOR_TRANSFORMATION 7
6463 +
6464 +// RAID Drive Count
6465 +// (bDriveCount, 0xF1 to 0xFF are reserved)
6466 +#define CSMI_SAS_RAID_DRIVE_COUNT_TOO_BIG 0xF1
6467 +#define CSMI_SAS_RAID_DRIVE_COUNT_SUPRESSED 0xF2
6468 +
6469 +// RAID Data Type
6470 +// (bDataType)
6471 +#define CSMI_SAS_RAID_DATA_DRIVES 0
6472 +#define CSMI_SAS_RAID_DATA_DEVICE_ID 1
6473 +#define CSMI_SAS_RAID_DATA_ADDITIONAL_DATA 2
6474 +
6475 +// RAID Drive Status
6476 +// (bDriveStatus)
6477 +#define CSMI_SAS_DRIVE_STATUS_OK 0
6478 +#define CSMI_SAS_DRIVE_STATUS_REBUILDING 1
6479 +#define CSMI_SAS_DRIVE_STATUS_FAILED 2
6480 +#define CSMI_SAS_DRIVE_STATUS_DEGRADED 3
6481 +#define CSMI_SAS_DRIVE_STATUS_OFFLINE 4
6482 +#define CSMI_SAS_DRIVE_STATUS_QUEUED_FOR_REBUILD 5
6483 +
6484 +// RAID Drive Usage
6485 +// (bDriveUsage)
6486 +#define CSMI_SAS_DRIVE_CONFIG_NOT_USED 0
6487 +#define CSMI_SAS_DRIVE_CONFIG_MEMBER 1
6488 +#define CSMI_SAS_DRIVE_CONFIG_SPARE 2
6489 +#define CSMI_SAS_DRIVE_CONFIG_SPARE_ACTIVE 3
6490 +
6491 +// RAID Drive Type
6492 +// (bDriveType)
6493 +#define CSMI_SAS_DRIVE_TYPE_UNKNOWN 0
6494 +#define CSMI_SAS_DRIVE_TYPE_SINGLE_PORT_SAS 1
6495 +#define CSMI_SAS_DRIVE_TYPE_DUAL_PORT_SAS 2
6496 +#define CSMI_SAS_DRIVE_TYPE_SATA 3
6497 +#define CSMI_SAS_DRIVE_TYPE_SATA_PS 4
6498 +#define CSMI_SAS_DRIVE_TYPE_OTHER 255
6499 +
6500 +// RAID Write Protect
6501 +// (bWriteProtect)
6502 +#define CSMI_SAS_RAID_SET_WRITE_PROTECT_UNKNOWN 0
6503 +#define CSMI_SAS_RAID_SET_WRITE_PROTECT_UNCHANGED 0
6504 +#define CSMI_SAS_RAID_SET_WRITE_PROTECT_ENABLED 1
6505 +#define CSMI_SAS_RAID_SET_WRITE_PROTECT_DISABLED 2
6506 +
6507 +// RAID Cache Setting
6508 +// (bCacheSetting)
6509 +#define CSMI_SAS_RAID_SET_CACHE_UNKNOWN 0
6510 +#define CSMI_SAS_RAID_SET_CACHE_UNCHANGED 0
6511 +#define CSMI_SAS_RAID_SET_CACHE_ENABLED 1
6512 +#define CSMI_SAS_RAID_SET_CACHE_DISABLED 2
6513 +#define CSMI_SAS_RAID_SET_CACHE_CORRUPT 3
6514 +
6515 +// RAID Features
6516 +// (uFeatures)
6517 +#define CSMI_SAS_RAID_FEATURE_TRANSFORMATION 0x00000001
6518 +#define CSMI_SAS_RAID_FEATURE_REBUILD 0x00000002
6519 +#define CSMI_SAS_RAID_FEATURE_SPLIT_MIRROR 0x00000004
6520 +#define CSMI_SAS_RAID_FEATURE_MERGE_MIRROR 0x00000008
6521 +#define CSMI_SAS_RAID_FEATURE_LUN_RENUMBER 0x00000010
6522 +#define CSMI_SAS_RAID_FEATURE_SURFACE_SCAN 0x00000020
6523 +#define CSMI_SAS_RAID_FEATURE_SPARES_SHARED 0x00000040
6524 +
6525 +// RAID Priority
6526 +// (bDefaultTransformPriority, etc.)
6527 +#define CSMI_SAS_PRIORITY_UNKNOWN 0
6528 +#define CSMI_SAS_PRIORITY_UNCHANGED 0
6529 +#define CSMI_SAS_PRIORITY_AUTO 1
6530 +#define CSMI_SAS_PRIORITY_OFF 2
6531 +#define CSMI_SAS_PRIORITY_LOW 3
6532 +#define CSMI_SAS_PRIORITY_MEDIUM 4
6533 +#define CSMI_SAS_PRIORITY_HIGH 5
6534 +
6535 +// RAID Transformation Rules
6536 +// (uRaidSetTransformationRules)
6537 +#define CSMI_SAS_RAID_RULE_AVAILABLE_MEMORY 0x00000001
6538 +#define CSMI_SAS_RAID_RULE_OVERLAPPED_EXTENTS 0x00000002
6539 +
6540 +// RAID Cache Ratios Supported
6541 +// (bCacheRatiosSupported)
6542 +// from 0 to 100 defines the write to read ratio, 0 is 100% write
6543 +#define CSMI_SAS_RAID_CACHE_RATIO_RANGE 101
6544 +#define CSMI_SAS_RAID_CACHE_RATIO_FIXED 102
6545 +#define CSMI_SAS_RAID_CACHE_RATIO_AUTO 103
6546 +#define CSMI_SAS_RAID_CACHE_RATIO_END 255
6547 +
6548 +// RAID Cache Ratio Flag
6549 +// (bCacheRatioFlag)
6550 +#define CSMI_SAS_RAID_CACHE_RATIO_DISABLE 0
6551 +#define CSMI_SAS_RAID_CACHE_RATIO_ENABLE 1
6552 +
6553 +// RAID Clear Configuration Signature
6554 +// (bClearConfiguration)
6555 +#define CSMI_SAS_RAID_CLEAR_CONFIGURATION_SIGNATURE "RAIDCLR"
6556 +
6557 +// RAID Failure Codes
6558 +// (uFailureCode)
6559 +#define CSMI_SAS_FAIL_CODE_OK 0
6560 +#define CSMI_SAS_FAIL_CODE_PARAMETER_INVALID 1000
6561 +#define CSMI_SAS_FAIL_CODE_TRANSFORM_PRIORITY_INVALID 1001
6562 +#define CSMI_SAS_FAIL_CODE_REBUILD_PRIORITY_INVALID 1002
6563 +#define CSMI_SAS_FAIL_CODE_CACHE_RATIO_INVALID 1003
6564 +#define CSMI_SAS_FAIL_CODE_SURFACE_SCAN_INVALID 1004
6565 +#define CSMI_SAS_FAIL_CODE_CLEAR_CONFIGURATION_INVALID 1005
6566 +#define CSMI_SAS_FAIL_CODE_ELEMENT_INDEX_INVALID 1006
6567 +#define CSMI_SAS_FAIL_CODE_SUBELEMENT_INDEX_INVALID 1007
6568 +#define CSMI_SAS_FAIL_CODE_EXTENT_INVALID 1008
6569 +#define CSMI_SAS_FAIL_CODE_BLOCK_COUNT_INVALID 1009
6570 +#define CSMI_SAS_FAIL_CODE_DRIVE_INDEX_INVALID 1010
6571 +#define CSMI_SAS_FAIL_CODE_EXISTING_LUN_INVALID 1011
6572 +#define CSMI_SAS_FAIL_CODE_RAID_TYPE_INVALID 1012
6573 +#define CSMI_SAS_FAIL_CODE_STRIPE_SIZE_INVALID 1013
6574 +#define CSMI_SAS_FAIL_CODE_TRANSFORMATION_INVALID 1014
6575 +#define CSMI_SAS_FAIL_CODE_CHANGE_COUNT_INVALID 1015
6576 +#define CSMI_SAS_FAIL_CODE_ENUMERATION_TYPE_INVALID 1016
6577 +
6578 +#define CSMI_SAS_FAIL_CODE_EXCEEDED_RAID_SET_COUNT 2000
6579 +#define CSMI_SAS_FAIL_CODE_DUPLICATE_LUN 2001
6580 +
6581 +#define CSMI_SAS_FAIL_CODE_WAIT_FOR_OPERATION 3000
6582 +
6583 +// RAID Enumeration Types
6584 +// (uEnumerationType)
6585 +#define CSMI_SAS_RAID_ELEMENT_TYPE_DRIVE 0
6586 +#define CSMI_SAS_RAID_ELEMENT_TYPE_MODULE 1
6587 +#define CSMI_SAS_RAID_ELEMENT_TYPE_DRIVE_RAID_SET 2
6588 +#define CSMI_SAS_RAID_ELEMENT_TYPE_EXTENT_DRIVE 3
6589 +
6590 +// RAID Extent Types
6591 +// (bExtentType)
6592 +#define CSMI_SAS_RAID_EXTENT_RESERVED 0
6593 +#define CSMI_SAS_RAID_EXTENT_METADATA 1
6594 +#define CSMI_SAS_RAID_EXTENT_ALLOCATED 2
6595 +#define CSMI_SAS_RAID_EXTENT_UNALLOCATED 3
6596 +
6597 +// RAID Operation Types
6598 +// (uOperationType)
6599 +#define CSMI_SAS_RAID_SET_CREATE 0
6600 +#define CSMI_SAS_RAID_SET_LABEL 1
6601 +#define CSMI_SAS_RAID_SET_TRANSFORM 2
6602 +#define CSMI_SAS_RAID_SET_DELETE 3
6603 +#define CSMI_SAS_RAID_SET_WRITE_PROTECT 4
6604 +#define CSMI_SAS_RAID_SET_CACHE 5
6605 +#define CSMI_SAS_RAID_SET_ONLINE_STATE 6
6606 +#define CSMI_SAS_RAID_SET_SPARE 7
6607 +
6608 +// RAID Transform Types
6609 +// (bTransformType)
6610 +#define CSMI_SAS_RAID_SET_TRANSFORM_SPLIT_MIRROR 0
6611 +#define CSMI_SAS_RAID_SET_TRANSFORM_MERGE_RAID_0 1
6612 +#define CSMI_SAS_RAID_SET_TRANSFORM_LUN_RENUMBER 2
6613 +#define CSMI_SAS_RAID_SET_TRANSFORM_RAID_SET 3
6614 +
6615 +// RAID Online State
6616 +// (bOnlineState)
6617 +#define CSMI_SAS_RAID_SET_STATE_UNKNOWN 0
6618 +#define CSMI_SAS_RAID_SET_STATE_ONLINE 1
6619 +#define CSMI_SAS_RAID_SET_STATE_OFFLINE 2
6620 +
6621 +/* * * * * * * * * * SAS HBA Class IOCTL Constants * * * * * * * * * */
6622 +
6623 +// Return codes for SAS IOCTL's
6624 +// (IoctlHeader.ReturnCode)
6625 +
6626 +#define CSMI_SAS_PHY_INFO_CHANGED CSMI_SAS_STATUS_SUCCESS
6627 +#define CSMI_SAS_PHY_INFO_NOT_CHANGEABLE 2000
6628 +#define CSMI_SAS_LINK_RATE_OUT_OF_RANGE 2001
6629 +
6630 +#define CSMI_SAS_PHY_DOES_NOT_EXIST 2002
6631 +#define CSMI_SAS_PHY_DOES_NOT_MATCH_PORT 2003
6632 +#define CSMI_SAS_PHY_CANNOT_BE_SELECTED 2004
6633 +#define CSMI_SAS_SELECT_PHY_OR_PORT 2005
6634 +#define CSMI_SAS_PORT_DOES_NOT_EXIST 2006
6635 +#define CSMI_SAS_PORT_CANNOT_BE_SELECTED 2007
6636 +#define CSMI_SAS_CONNECTION_FAILED 2008
6637 +
6638 +#define CSMI_SAS_NO_SATA_DEVICE 2009
6639 +#define CSMI_SAS_NO_SATA_SIGNATURE 2010
6640 +#define CSMI_SAS_SCSI_EMULATION 2011
6641 +#define CSMI_SAS_NOT_AN_END_DEVICE 2012
6642 +#define CSMI_SAS_NO_SCSI_ADDRESS 2013
6643 +#define CSMI_SAS_NO_DEVICE_ADDRESS 2014
6644 +
6645 +// Signature value
6646 +// (IoctlHeader.Signature)
6647 +
6648 +#define CSMI_SAS_SIGNATURE "CSMISAS"
6649 +
6650 +// Timeout value default of 60 seconds
6651 +// (IoctlHeader.Timeout)
6652 +
6653 +#define CSMI_SAS_TIMEOUT 60
6654 +
6655 +// Device types
6656 +// (bDeviceType)
6657 +
6658 +#define CSMI_SAS_PHY_UNUSED 0x00
6659 +#define CSMI_SAS_NO_DEVICE_ATTACHED 0x00
6660 +#define CSMI_SAS_END_DEVICE 0x10
6661 +#define CSMI_SAS_EDGE_EXPANDER_DEVICE 0x20
6662 +#define CSMI_SAS_FANOUT_EXPANDER_DEVICE 0x30
6663 +
6664 +// Protocol options
6665 +// (bInitiatorPortProtocol, bTargetPortProtocol)
6666 +
6667 +#define CSMI_SAS_PROTOCOL_SATA 0x01
6668 +#define CSMI_SAS_PROTOCOL_SMP 0x02
6669 +#define CSMI_SAS_PROTOCOL_STP 0x04
6670 +#define CSMI_SAS_PROTOCOL_SSP 0x08
6671 +
6672 +// Negotiated and hardware link rates
6673 +// (bNegotiatedLinkRate, bMinimumLinkRate, bMaximumLinkRate)
6674 +
6675 +#define CSMI_SAS_LINK_RATE_UNKNOWN 0x00
6676 +#define CSMI_SAS_PHY_DISABLED 0x01
6677 +#define CSMI_SAS_LINK_RATE_FAILED 0x02
6678 +#define CSMI_SAS_SATA_SPINUP_HOLD 0x03
6679 +#define CSMI_SAS_SATA_PORT_SELECTOR 0x04
6680 +#define CSMI_SAS_LINK_RATE_1_5_GBPS 0x08
6681 +#define CSMI_SAS_LINK_RATE_3_0_GBPS 0x09
6682 +#define CSMI_SAS_LINK_VIRTUAL 0x10
6683 +
6684 +// Discover state
6685 +// (bAutoDiscover)
6686 +
6687 +#define CSMI_SAS_DISCOVER_NOT_SUPPORTED 0x00
6688 +#define CSMI_SAS_DISCOVER_NOT_STARTED 0x01
6689 +#define CSMI_SAS_DISCOVER_IN_PROGRESS 0x02
6690 +#define CSMI_SAS_DISCOVER_COMPLETE 0x03
6691 +#define CSMI_SAS_DISCOVER_ERROR 0x04
6692 +
6693 +// Phy features
6694 +
6695 +#define CSMI_SAS_PHY_VIRTUAL_SMP 0x01
6696 +
6697 +// Programmed link rates
6698 +// (bMinimumLinkRate, bMaximumLinkRate)
6699 +// (bProgrammedMinimumLinkRate, bProgrammedMaximumLinkRate)
6700 +
6701 +#define CSMI_SAS_PROGRAMMED_LINK_RATE_UNCHANGED 0x00
6702 +#define CSMI_SAS_PROGRAMMED_LINK_RATE_1_5_GBPS 0x08
6703 +#define CSMI_SAS_PROGRAMMED_LINK_RATE_3_0_GBPS 0x09
6704 +
6705 +// Link rate
6706 +// (bNegotiatedLinkRate in CSMI_SAS_SET_PHY_INFO)
6707 +
6708 +#define CSMI_SAS_LINK_RATE_NEGOTIATE 0x00
6709 +#define CSMI_SAS_LINK_RATE_PHY_DISABLED 0x01
6710 +
6711 +// Signal class
6712 +// (bSignalClass in CSMI_SAS_SET_PHY_INFO)
6713 +
6714 +#define CSMI_SAS_SIGNAL_CLASS_UNKNOWN 0x00
6715 +#define CSMI_SAS_SIGNAL_CLASS_DIRECT 0x01
6716 +#define CSMI_SAS_SIGNAL_CLASS_SERVER 0x02
6717 +#define CSMI_SAS_SIGNAL_CLASS_ENCLOSURE 0x03
6718 +
6719 +// Link error reset
6720 +// (bResetCounts)
6721 +
6722 +#define CSMI_SAS_LINK_ERROR_DONT_RESET_COUNTS 0x00
6723 +#define CSMI_SAS_LINK_ERROR_RESET_COUNTS 0x01
6724 +
6725 +// Phy identifier
6726 +// (bPhyIdentifier)
6727 +
6728 +#define CSMI_SAS_USE_PORT_IDENTIFIER 0xFF
6729 +
6730 +// Port identifier
6731 +// (bPortIdentifier)
6732 +
6733 +#define CSMI_SAS_IGNORE_PORT 0xFF
6734 +
6735 +// Programmed link rates
6736 +// (bConnectionRate)
6737 +
6738 +#define CSMI_SAS_LINK_RATE_NEGOTIATED 0x00
6739 +#define CSMI_SAS_LINK_RATE_1_5_GBPS 0x08
6740 +#define CSMI_SAS_LINK_RATE_3_0_GBPS 0x09
6741 +
6742 +// Connection status
6743 +// (bConnectionStatus)
6744 +
6745 +#define CSMI_SAS_OPEN_ACCEPT 0
6746 +#define CSMI_SAS_OPEN_REJECT_BAD_DESTINATION 1
6747 +#define CSMI_SAS_OPEN_REJECT_RATE_NOT_SUPPORTED 2
6748 +#define CSMI_SAS_OPEN_REJECT_NO_DESTINATION 3
6749 +#define CSMI_SAS_OPEN_REJECT_PATHWAY_BLOCKED 4
6750 +#define CSMI_SAS_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED 5
6751 +#define CSMI_SAS_OPEN_REJECT_RESERVE_ABANDON 6
6752 +#define CSMI_SAS_OPEN_REJECT_RESERVE_CONTINUE 7
6753 +#define CSMI_SAS_OPEN_REJECT_RESERVE_INITIALIZE 8
6754 +#define CSMI_SAS_OPEN_REJECT_RESERVE_STOP 9
6755 +#define CSMI_SAS_OPEN_REJECT_RETRY 10
6756 +#define CSMI_SAS_OPEN_REJECT_STP_RESOURCES_BUSY 11
6757 +#define CSMI_SAS_OPEN_REJECT_WRONG_DESTINATION 12
6758 +
6759 +// SSP Status
6760 +// (bSSPStatus)
6761 +
6762 +#define CSMI_SAS_SSP_STATUS_UNKNOWN 0x00
6763 +#define CSMI_SAS_SSP_STATUS_WAITING 0x01
6764 +#define CSMI_SAS_SSP_STATUS_COMPLETED 0x02
6765 +#define CSMI_SAS_SSP_STATUS_FATAL_ERROR 0x03
6766 +#define CSMI_SAS_SSP_STATUS_RETRY 0x04
6767 +#define CSMI_SAS_SSP_STATUS_NO_TAG 0x05
6768 +
6769 +// SSP Flags
6770 +// (uFlags)
6771 +
6772 +#define CSMI_SAS_SSP_READ 0x00000001
6773 +#define CSMI_SAS_SSP_WRITE 0x00000002
6774 +#define CSMI_SAS_SSP_UNSPECIFIED 0x00000004
6775 +
6776 +#define CSMI_SAS_SSP_TASK_ATTRIBUTE_SIMPLE 0x00000000
6777 +#define CSMI_SAS_SSP_TASK_ATTRIBUTE_HEAD_OF_QUEUE 0x00000010
6778 +#define CSMI_SAS_SSP_TASK_ATTRIBUTE_ORDERED 0x00000020
6779 +#define CSMI_SAS_SSP_TASK_ATTRIBUTE_ACA 0x00000040
6780 +
6781 +// SSP Data present
6782 +// (bDataPresent)
6783 +
6784 +#define CSMI_SAS_SSP_NO_DATA_PRESENT 0x00
6785 +#define CSMI_SAS_SSP_RESPONSE_DATA_PRESENT 0x01
6786 +#define CSMI_SAS_SSP_SENSE_DATA_PRESENT 0x02
6787 +
6788 +// STP Flags
6789 +// (uFlags)
6790 +
6791 +#define CSMI_SAS_STP_READ 0x00000001
6792 +#define CSMI_SAS_STP_WRITE 0x00000002
6793 +#define CSMI_SAS_STP_UNSPECIFIED 0x00000004
6794 +#define CSMI_SAS_STP_PIO 0x00000010
6795 +#define CSMI_SAS_STP_DMA 0x00000020
6796 +#define CSMI_SAS_STP_PACKET 0x00000040
6797 +#define CSMI_SAS_STP_DMA_QUEUED 0x00000080
6798 +#define CSMI_SAS_STP_EXECUTE_DIAG 0x00000100
6799 +#define CSMI_SAS_STP_RESET_DEVICE 0x00000200
6800 +
6801 +// Task Management Flags
6802 +// (uFlags)
6803 +
6804 +#define CSMI_SAS_TASK_IU 0x00000001
6805 +#define CSMI_SAS_HARD_RESET_SEQUENCE 0x00000002
6806 +#define CSMI_SAS_SUPPRESS_RESULT 0x00000004
6807 +
6808 +// Task Management Functions
6809 +// (bTaskManagement)
6810 +
6811 +#define CSMI_SAS_SSP_ABORT_TASK 0x01
6812 +#define CSMI_SAS_SSP_ABORT_TASK_SET 0x02
6813 +#define CSMI_SAS_SSP_CLEAR_TASK_SET 0x04
6814 +#define CSMI_SAS_SSP_LOGICAL_UNIT_RESET 0x08
6815 +#define CSMI_SAS_SSP_CLEAR_ACA 0x40
6816 +#define CSMI_SAS_SSP_QUERY_TASK 0x80
6817 +
6818 +// Task Management Information
6819 +// (uInformation)
6820 +
6821 +#define CSMI_SAS_SSP_TEST 1
6822 +#define CSMI_SAS_SSP_EXCEEDED 2
6823 +#define CSMI_SAS_SSP_DEMAND 3
6824 +#define CSMI_SAS_SSP_TRIGGER 4
6825 +
6826 +// Connector Pinout Information
6827 +// (uPinout)
6828 +
6829 +#define CSMI_SAS_CON_UNKNOWN 0x00000001
6830 +#define CSMI_SAS_CON_SFF_8482 0x00000002
6831 +#define CSMI_SAS_CON_SFF_8470_LANE_1 0x00000100
6832 +#define CSMI_SAS_CON_SFF_8470_LANE_2 0x00000200
6833 +#define CSMI_SAS_CON_SFF_8470_LANE_3 0x00000400
6834 +#define CSMI_SAS_CON_SFF_8470_LANE_4 0x00000800
6835 +#define CSMI_SAS_CON_SFF_8484_LANE_1 0x00010000
6836 +#define CSMI_SAS_CON_SFF_8484_LANE_2 0x00020000
6837 +#define CSMI_SAS_CON_SFF_8484_LANE_3 0x00040000
6838 +#define CSMI_SAS_CON_SFF_8484_LANE_4 0x00080000
6839 +
6840 +// Connector Location Information
6841 +// (bLocation)
6842 +
6843 +// same as uPinout above...
6844 +// #define CSMI_SAS_CON_UNKNOWN 0x01
6845 +#define CSMI_SAS_CON_INTERNAL 0x02
6846 +#define CSMI_SAS_CON_EXTERNAL 0x04
6847 +#define CSMI_SAS_CON_SWITCHABLE 0x08
6848 +#define CSMI_SAS_CON_AUTO 0x10
6849 +#define CSMI_SAS_CON_NOT_PRESENT 0x20
6850 +#define CSMI_SAS_CON_NOT_CONNECTED 0x80
6851 +
6852 +// Device location identification
6853 +// (bIdentify)
6854 +
6855 +#define CSMI_SAS_LOCATE_UNKNOWN 0x00
6856 +#define CSMI_SAS_LOCATE_FORCE_OFF 0x01
6857 +#define CSMI_SAS_LOCATE_FORCE_ON 0x02
6858 +
6859 +// Location Valid flags
6860 +// (uLocationFlags)
6861 +
6862 +#define CSMI_SAS_LOCATE_SAS_ADDRESS_VALID 0x00000001
6863 +#define CSMI_SAS_LOCATE_SAS_LUN_VALID 0x00000002
6864 +#define CSMI_SAS_LOCATE_ENCLOSURE_IDENTIFIER_VALID 0x00000004
6865 +#define CSMI_SAS_LOCATE_ENCLOSURE_NAME_VALID 0x00000008
6866 +#define CSMI_SAS_LOCATE_BAY_PREFIX_VALID 0x00000010
6867 +#define CSMI_SAS_LOCATE_BAY_IDENTIFIER_VALID 0x00000020
6868 +#define CSMI_SAS_LOCATE_LOCATION_STATE_VALID 0x00000040
6869 +
6870 +/* * * * * * * * SAS Phy Control Class IOCTL Constants * * * * * * * * */
6871 +
6872 +// Return codes for SAS Phy Control IOCTL's
6873 +// (IoctlHeader.ReturnCode)
6874 +
6875 +// Signature value
6876 +// (IoctlHeader.Signature)
6877 +
6878 +#define CSMI_PHY_SIGNATURE "CSMIPHY"
6879 +
6880 +// Phy Control Functions
6881 +// (bFunction)
6882 +
6883 +// values 0x00 to 0xFF are consistent in definition with the SMP PHY CONTROL
6884 +// function defined in the SAS spec
6885 +#define CSMI_SAS_PC_NOP 0x00000000
6886 +#define CSMI_SAS_PC_LINK_RESET 0x00000001
6887 +#define CSMI_SAS_PC_HARD_RESET 0x00000002
6888 +#define CSMI_SAS_PC_PHY_DISABLE 0x00000003
6889 +// 0x04 to 0xFF reserved...
6890 +#define CSMI_SAS_PC_GET_PHY_SETTINGS 0x00000100
6891 +
6892 +// Link Flags
6893 +#define CSMI_SAS_PHY_ACTIVATE_CONTROL 0x00000001
6894 +#define CSMI_SAS_PHY_UPDATE_SPINUP_RATE 0x00000002
6895 +#define CSMI_SAS_PHY_AUTO_COMWAKE 0x00000004
6896 +
6897 +// Device Types for Phy Settings
6898 +// (bType)
6899 +#define CSMI_SAS_UNDEFINED 0x00
6900 +#define CSMI_SAS_SATA 0x01
6901 +#define CSMI_SAS_SAS 0x02
6902 +
6903 +// Transmitter Flags
6904 +// (uTransmitterFlags)
6905 +#define CSMI_SAS_PHY_PREEMPHASIS_DISABLED 0x00000001
6906 +
6907 +// Receiver Flags
6908 +// (uReceiverFlags)
6909 +#define CSMI_SAS_PHY_EQUALIZATION_DISABLED 0x00000001
6910 +
6911 +// Pattern Flags
6912 +// (uPatternFlags)
6913 +// #define CSMI_SAS_PHY_ACTIVATE_CONTROL 0x00000001
6914 +#define CSMI_SAS_PHY_DISABLE_SCRAMBLING 0x00000002
6915 +#define CSMI_SAS_PHY_DISABLE_ALIGN 0x00000004
6916 +#define CSMI_SAS_PHY_DISABLE_SSC 0x00000008
6917 +
6918 +#define CSMI_SAS_PHY_FIXED_PATTERN 0x00000010
6919 +#define CSMI_SAS_PHY_USER_PATTERN 0x00000020
6920 +
6921 +// Fixed Patterns
6922 +// (bFixedPattern)
6923 +#define CSMI_SAS_PHY_CJPAT 0x00000001
6924 +#define CSMI_SAS_PHY_ALIGN 0x00000002
6925 +
6926 +// Type Flags
6927 +// (bTypeFlags)
6928 +#define CSMI_SAS_PHY_POSITIVE_DISPARITY 0x01
6929 +#define CSMI_SAS_PHY_NEGATIVE_DISPARITY 0x02
6930 +#define CSMI_SAS_PHY_CONTROL_CHARACTER 0x04
6931 +
6932 +// Miscellaneous
6933 +#define SLOT_NUMBER_UNKNOWN 0xFFFF
6934 +
6935 +/*************************************************************************/
6936 +/* DATA STRUCTURES */
6937 +/*************************************************************************/
6938 +
6939 +/* * * * * * * * * * Class Independent Structures * * * * * * * * * */
6940 +
6941 +// EDM #pragma CSMI_SAS_BEGIN_PACK(8)
6942 +#pragma pack(8)
6943 +
6944 +// CC_CSMI_SAS_DRIVER_INFO
6945 +
6946 +typedef struct _CSMI_SAS_DRIVER_INFO {
6947 + __u8 szName[81];
6948 + __u8 szDescription[81];
6949 + __u16 usMajorRevision;
6950 + __u16 usMinorRevision;
6951 + __u16 usBuildRevision;
6952 + __u16 usReleaseRevision;
6953 + __u16 usCSMIMajorRevision;
6954 + __u16 usCSMIMinorRevision;
6955 +} CSMI_SAS_DRIVER_INFO,
6956 + *PCSMI_SAS_DRIVER_INFO;
6957 +
6958 +typedef struct _CSMI_SAS_DRIVER_INFO_BUFFER {
6959 + IOCTL_HEADER IoctlHeader;
6960 + CSMI_SAS_DRIVER_INFO Information;
6961 +} CSMI_SAS_DRIVER_INFO_BUFFER,
6962 + *PCSMI_SAS_DRIVER_INFO_BUFFER;
6963 +
6964 +// CC_CSMI_SAS_CNTLR_CONFIGURATION
6965 +
6966 +typedef struct _CSMI_SAS_PCI_BUS_ADDRESS {
6967 + __u8 bBusNumber;
6968 + __u8 bDeviceNumber;
6969 + __u8 bFunctionNumber;
6970 + __u8 bReserved;
6971 +} CSMI_SAS_PCI_BUS_ADDRESS,
6972 + *PCSMI_SAS_PCI_BUS_ADDRESS;
6973 +
6974 +typedef union _CSMI_SAS_IO_BUS_ADDRESS {
6975 + CSMI_SAS_PCI_BUS_ADDRESS PciAddress;
6976 + __u8 bReserved[32];
6977 +} CSMI_SAS_IO_BUS_ADDRESS,
6978 + *PCSMI_SAS_IO_BUS_ADDRESS;
6979 +
6980 +typedef struct _CSMI_SAS_CNTLR_CONFIG {
6981 + __u32 uBaseIoAddress;
6982 + struct {
6983 + __u32 uLowPart;
6984 + __u32 uHighPart;
6985 + } BaseMemoryAddress;
6986 + __u32 uBoardID;
6987 + __u16 usSlotNumber;
6988 + __u8 bControllerClass;
6989 + __u8 bIoBusType;
6990 + CSMI_SAS_IO_BUS_ADDRESS BusAddress;
6991 + __u8 szSerialNumber[81];
6992 + __u16 usMajorRevision;
6993 + __u16 usMinorRevision;
6994 + __u16 usBuildRevision;
6995 + __u16 usReleaseRevision;
6996 + __u16 usBIOSMajorRevision;
6997 + __u16 usBIOSMinorRevision;
6998 + __u16 usBIOSBuildRevision;
6999 + __u16 usBIOSReleaseRevision;
7000 + __u32 uControllerFlags;
7001 + __u16 usRromMajorRevision;
7002 + __u16 usRromMinorRevision;
7003 + __u16 usRromBuildRevision;
7004 + __u16 usRromReleaseRevision;
7005 + __u16 usRromBIOSMajorRevision;
7006 + __u16 usRromBIOSMinorRevision;
7007 + __u16 usRromBIOSBuildRevision;
7008 + __u16 usRromBIOSReleaseRevision;
7009 + __u8 bReserved[7];
7010 +} CSMI_SAS_CNTLR_CONFIG,
7011 + *PCSMI_SAS_CNTLR_CONFIG;
7012 +
7013 +typedef struct _CSMI_SAS_CNTLR_CONFIG_BUFFER {
7014 + IOCTL_HEADER IoctlHeader;
7015 + CSMI_SAS_CNTLR_CONFIG Configuration;
7016 +} CSMI_SAS_CNTLR_CONFIG_BUFFER,
7017 + *PCSMI_SAS_CNTLR_CONFIG_BUFFER;
7018 +
7019 +// CC_CSMI_SAS_CNTLR_STATUS
7020 +
7021 +typedef struct _CSMI_SAS_CNTLR_STATUS {
7022 + __u32 uStatus;
7023 + __u32 uOfflineReason;
7024 + __u8 bReserved[28];
7025 +} CSMI_SAS_CNTLR_STATUS,
7026 + *PCSMI_SAS_CNTLR_STATUS;
7027 +
7028 +typedef struct _CSMI_SAS_CNTLR_STATUS_BUFFER {
7029 + IOCTL_HEADER IoctlHeader;
7030 + CSMI_SAS_CNTLR_STATUS Status;
7031 +} CSMI_SAS_CNTLR_STATUS_BUFFER,
7032 + *PCSMI_SAS_CNTLR_STATUS_BUFFER;
7033 +
7034 +// CC_CSMI_SAS_FIRMWARE_DOWNLOAD
7035 +
7036 +typedef struct _CSMI_SAS_FIRMWARE_DOWNLOAD {
7037 + __u32 uBufferLength;
7038 + __u32 uDownloadFlags;
7039 + __u8 bReserved[32];
7040 + __u16 usStatus;
7041 + __u16 usSeverity;
7042 +} CSMI_SAS_FIRMWARE_DOWNLOAD,
7043 + *PCSMI_SAS_FIRMWARE_DOWNLOAD;
7044 +
7045 +typedef struct _CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER {
7046 + IOCTL_HEADER IoctlHeader;
7047 + CSMI_SAS_FIRMWARE_DOWNLOAD Information;
7048 + __u8 bDataBuffer[1];
7049 +} CSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER,
7050 + *PCSMI_SAS_FIRMWARE_DOWNLOAD_BUFFER;
7051 +
7052 +// CC_CSMI_SAS_RAID_INFO
7053 +
7054 +typedef struct _CSMI_SAS_RAID_INFO {
7055 + __u32 uNumRaidSets;
7056 + __u32 uMaxDrivesPerSet;
7057 + __u32 uMaxRaidSets;
7058 + __u8 bMaxRaidTypes;
7059 + __u8 bReservedByteFields[7];
7060 + struct
7061 + {
7062 + __u32 uLowPart;
7063 + __u32 uHighPart;
7064 + } ulMinRaidSetBlocks;
7065 + struct
7066 + {
7067 + __u32 uLowPart;
7068 + __u32 uHighPart;
7069 + } ulMaxRaidSetBlocks;
7070 + __u32 uMaxPhysicalDrives;
7071 + __u32 uMaxExtents;
7072 + __u32 uMaxModules;
7073 + __u32 uMaxTransformationMemory;
7074 + __u32 uChangeCount;
7075 + __u8 bReserved[44];
7076 +} CSMI_SAS_RAID_INFO,
7077 + *PCSMI_SAS_RAID_INFO;
7078 +
7079 +typedef struct _CSMI_SAS_RAID_INFO_BUFFER {
7080 + IOCTL_HEADER IoctlHeader;
7081 + CSMI_SAS_RAID_INFO Information;
7082 +} CSMI_SAS_RAID_INFO_BUFFER,
7083 + *PCSMI_SAS_RAID_INFO_BUFFER;
7084 +
7085 +// CC_CSMI_SAS_GET_RAID_CONFIG
7086 +
7087 +typedef struct _CSMI_SAS_RAID_DRIVES {
7088 + __u8 bModel[40];
7089 + __u8 bFirmware[8];
7090 + __u8 bSerialNumber[40];
7091 + __u8 bSASAddress[8];
7092 + __u8 bSASLun[8];
7093 + __u8 bDriveStatus;
7094 + __u8 bDriveUsage;
7095 + __u16 usBlockSize;
7096 + __u8 bDriveType;
7097 + __u8 bReserved[15];
7098 + __u32 uDriveIndex;
7099 + struct
7100 + {
7101 + __u32 uLowPart;
7102 + __u32 uHighPart;
7103 + } ulTotalUserBlocks;
7104 +} CSMI_SAS_RAID_DRIVES,
7105 + *PCSMI_SAS_RAID_DRIVES;
7106 +
7107 +typedef struct _CSMI_SAS_RAID_DEVICE_ID {
7108 + __u8 bDeviceIdentificationVPDPage[1];
7109 +} CSMI_SAS_RAID_DEVICE_ID,
7110 + *PCSMI_SAS_RAID_DEVICE_ID;
7111 +
7112 +typedef struct _CSMI_SAS_RAID_SET_ADDITIONAL_DATA {
7113 + __u8 bLabel[16];
7114 + __u8 bRaidSetLun[8];
7115 + __u8 bWriteProtection;
7116 + __u8 bCacheSetting;
7117 + __u8 bCacheRatio;
7118 + __u16 usBlockSize;
7119 + __u8 bReservedBytes[11];
7120 + struct
7121 + {
7122 + __u32 uLowPart;
7123 + __u32 uHighPart;
7124 + } ulRaidSetExtentOffset;
7125 + struct
7126 + {
7127 + __u32 uLowPart;
7128 + __u32 uHighPart;
7129 + } ulRaidSetBlocks;
7130 + __u32 uStripeSizeInBlocks;
7131 + __u32 uSectorsPerTrack;
7132 + __u8 bApplicationScratchPad[16];
7133 + __u32 uNumberOfHeads;
7134 + __u32 uNumberOfTracks;
7135 + __u8 bReserved[24];
7136 +} CSMI_SAS_RAID_SET_ADDITIONAL_DATA,
7137 + *PCSMI_SAS_RAID_SET_ADDITIONAL_DATA;
7138 +
7139 +typedef struct _CSMI_SAS_RAID_CONFIG {
7140 + __u32 uRaidSetIndex;
7141 + __u32 uCapacity;
7142 + __u32 uStripeSize;
7143 + __u8 bRaidType;
7144 + __u8 bStatus;
7145 + __u8 bInformation;
7146 + __u8 bDriveCount;
7147 + __u8 bDataType;
7148 + __u8 bReserved[11];
7149 + __u32 uFailureCode;
7150 + __u32 uChangeCount;
7151 + union {
7152 + CSMI_SAS_RAID_DRIVES Drives[1];
7153 + CSMI_SAS_RAID_DEVICE_ID DeviceId[1];
7154 + CSMI_SAS_RAID_SET_ADDITIONAL_DATA Data[1];
7155 + };
7156 +} CSMI_SAS_RAID_CONFIG,
7157 + *PCSMI_SAS_RAID_CONFIG;
7158 +
7159 +typedef struct _CSMI_SAS_RAID_CONFIG_BUFFER {
7160 + IOCTL_HEADER IoctlHeader;
7161 + CSMI_SAS_RAID_CONFIG Configuration;
7162 +} CSMI_SAS_RAID_CONFIG_BUFFER,
7163 + *PCSMI_SAS_RAID_CONFIG_BUFFER;
7164 +
7165 +// CC_CSMI_SAS_GET_RAID_FEATURES
7166 +
7167 +typedef struct _CSMI_SAS_RAID_TYPE_DESCRIPTION {
7168 + __u8 bRaidType;
7169 + __u8 bReservedBytes[7];
7170 + __u32 uSupportedStripeSizeMap;
7171 + __u8 bReserved[24];
7172 +} CSMI_SAS_RAID_TYPE_DESCRIPTION,
7173 + *PCSMI_SAS_RAID_TYPE_DESCRIPTION;
7174 +
7175 +typedef struct _CSMI_SAS_RAID_FEATURES {
7176 + __u32 uFeatures;
7177 + __u8 bReservedFeatures[32];
7178 + __u8 bDefaultTransformPriority;
7179 + __u8 bTransformPriority;
7180 + __u8 bDefaultRebuildPriority;
7181 + __u8 bRebuildPriority;
7182 + __u8 bDefaultSurfaceScanPriority;
7183 + __u8 bSurfaceScanPriority;
7184 + __u16 usReserved;
7185 + __u32 uRaidSetTransformationRules;
7186 + __u32 uReserved[11];
7187 + CSMI_SAS_RAID_TYPE_DESCRIPTION RaidType[24];
7188 + __u8 bCacheRatiosSupported[104];
7189 + __u32 uChangeCount;
7190 + __u32 uFailureCode;
7191 + __u8 bReserved[120];
7192 +} CSMI_SAS_RAID_FEATURES,
7193 + *PCSMI_SAS_RAID_FEATURES;
7194 +
7195 +typedef struct _CSMI_SAS_RAID_FEATURES_BUFFER {
7196 + IOCTL_HEADER IoctlHeader;
7197 + CSMI_SAS_RAID_FEATURES Information;
7198 +} CSMI_SAS_RAID_FEATURES_BUFFER,
7199 + *PCSMI_SAS_RAID_FEATURES_BUFFER;
7200 +
7201 +// CC_CSMI_SAS_SET_RAID_CONTROL
7202 +
7203 +typedef struct _CSMI_SAS_RAID_CONTROL {
7204 + __u8 bTransformPriority;
7205 + __u8 bRebuildPriority;
7206 + __u8 bCacheRatioFlag;
7207 + __u8 bCacheRatio;
7208 + __u8 bSurfaceScanPriority;
7209 + __u8 bReservedBytes[15];
7210 + __u8 bClearConfiguration[8];
7211 + __u32 uChangeCount;
7212 + __u8 bReserved[88];
7213 + __u32 uFailureCode;
7214 + __u8 bFailureDescription[80];
7215 +} CSMI_SAS_RAID_CONTROL,
7216 + *PCSMI_SAS_RAID_CONTROL;
7217 +
7218 +typedef struct _CSMI_SAS_RAID_CONTROL_BUFFER {
7219 + IOCTL_HEADER IoctlHeader;
7220 + CSMI_SAS_RAID_CONTROL Information;
7221 +} CSMI_SAS_RAID_CONTROL_BUFFER,
7222 + *PCSMI_SAS_RAID_CONTROL_BUFFER;
7223 +
7224 +// CC_CSMI_SAS_GET_RAID_ELEMENT
7225 +
7226 +typedef struct _CSMI_SAS_DRIVE_EXTENT_INFO {
7227 + __u32 uDriveIndex;
7228 + __u8 bExtentType;
7229 + __u8 bReservedBytes[7];
7230 + struct
7231 + {
7232 + __u32 uLowPart;
7233 + __u32 uHighPart;
7234 + } ulExtentOffset;
7235 + struct
7236 + {
7237 + __u32 uLowPart;
7238 + __u32 uHighPart;
7239 + } ulExtentBlocks;
7240 + __u32 uRaidSetIndex;
7241 + __u8 bReserved[96];
7242 +} CSMI_SAS_DRIVE_EXTENT_INFO,
7243 + *PCSMI_SAS_DRIVE_EXTENT_INFO;
7244 +
7245 +typedef struct _CSMI_SAS_RAID_MODULE_INFO {
7246 + __u8 bReserved[128];
7247 +} CSMI_SAS_RAID_MODULE_INFO,
7248 + *PCSMI_SAS_RAID_MODULE_INFO;
7249 +
7250 +typedef struct _CSMI_SAS_DRIVE_LOCATION {
7251 + __u8 bConnector[16];
7252 + __u8 bBoxName[16];
7253 + __u32 uBay;
7254 + __u8 bReservedBytes[4];
7255 + __u8 bAttachedSASAddress[8];
7256 + __u8 bAttachedPhyIdentifier;
7257 + __u8 bReserved[79];
7258 +} CSMI_SAS_DRIVE_LOCATION,
7259 + *PCSMI_SAS_DRIVE_LOCATION;
7260 +
7261 +typedef struct _CSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA {
7262 + __u8 bNegotiatedLinkRate[2];
7263 + __u8 bReserved[126];
7264 +} CSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA,
7265 + *PCSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA;
7266 +
7267 +typedef struct _CSMI_SAS_DRIVE_INFO {
7268 + CSMI_SAS_RAID_DRIVES Device;
7269 + CSMI_SAS_RAID_DRIVES_ADDITIONAL_DATA Data;
7270 + CSMI_SAS_DRIVE_LOCATION Location;
7271 + __u8 bReserved[16];
7272 +} CSMI_SAS_DRIVE_INFO,
7273 + *PCSMI_SAS_DRIVE_INFO;
7274 +
7275 +typedef struct _CSMI_SAS_RAID_ELEMENT {
7276 + __u32 uEnumerationType;
7277 + __u32 uElementIndex;
7278 + __u32 uNumElements;
7279 + __u32 uChangeCount;
7280 + __u32 uSubElementIndex;
7281 + __u8 bReserved[32];
7282 + __u32 uFailureCode;
7283 + __u8 bFailureDescription[80];
7284 + union {
7285 + CSMI_SAS_DRIVE_INFO Drive;
7286 + CSMI_SAS_RAID_MODULE_INFO Module;
7287 + CSMI_SAS_DRIVE_EXTENT_INFO Extent;
7288 + } Element;
7289 +} CSMI_SAS_RAID_ELEMENT,
7290 + *PCSMI_SAS_RAID_ELEMENT;
7291 +
7292 +typedef struct _CSMI_SAS_RAID_ELEMENT_BUFFER {
7293 + IOCTL_HEADER IoctlHeader;
7294 + CSMI_SAS_RAID_ELEMENT Information;
7295 +} CSMI_SAS_RAID_ELEMENT_BUFFER,
7296 + *PCSMI_SAS_RAID_ELEMENT_BUFFER;
7297 +
7298 +// CC_CSMI_SAS_SET_RAID_OPERATION
7299 +
7300 +typedef struct _CSMI_SAS_RAID_SET_LIST {
7301 + __u32 uRaidSetIndex;
7302 + __u8 bExistingLun[8];
7303 + __u8 bNewLun[8];
7304 + __u8 bReserved[12];
7305 +} CSMI_SAS_RAID_SET_LIST,
7306 + *PCSMI_SAS_RAID_SET_LIST;
7307 +
7308 +typedef struct _CSMI_SAS_RAID_SET_DRIVE_LIST {
7309 + __u32 uDriveIndex;
7310 + __u8 bDriveUsage;
7311 + __u8 bReserved[27];
7312 +} CSMI_SAS_RAID_SET_DRIVE_LIST,
7313 + *PCSMI_SAS_RAID_SET_DRIVE_LIST;
7314 +
7315 +typedef struct _CSMI_SAS_RAID_SET_SPARE_INFO {
7316 + __u32 uRaidSetIndex;
7317 + __u32 uDriveCount;
7318 + __u8 bApplicationScratchPad[16];
7319 + __u8 bReserved[104];
7320 +} CSMI_SAS_RAID_SET_SPARE_INFO,
7321 + *PCSMI_SAS_RAID_SET_SPARE_INFO;
7322 +
7323 +typedef struct _CSMI_SAS_RAID_SET_ONLINE_STATE_INFO {
7324 + __u32 uRaidSetIndex;
7325 + __u8 bOnlineState;
7326 + __u8 bReserved[123];
7327 +} CSMI_SAS_RAID_SET_ONLINE_STATE_INFO,
7328 + *PCSMI_SAS_RAID_SET_ONLINE_STATE_INFO;
7329 +
7330 +typedef struct _CSMI_SAS_RAID_SET_CACHE_INFO {
7331 + __u32 uRaidSetIndex;
7332 + __u8 bCacheSetting;
7333 + __u8 bCacheRatioFlag;
7334 + __u8 bCacheRatio;
7335 + __u8 bReserved[121];
7336 +} CSMI_SAS_RAID_SET_CACHE_INFO,
7337 + *PCSMI_SAS_RAID_SET_CACHE_INFO;
7338 +
7339 +typedef struct _CSMI_SAS_RAID_SET_WRITE_PROTECT_INFO {
7340 + __u32 uRaidSetIndex;
7341 + __u8 bWriteProtectSetting;
7342 + __u8 bReserved[123];
7343 +} CSMI_SAS_RAID_SET_WRITE_PROTECT_INFO,
7344 + *PCSMI_SAS_RAID_SET_WRITE_PROTECT_INFO;
7345 +
7346 +typedef struct _CSMI_SAS_RAID_SET_DELETE_INFO {
7347 + __u32 uRaidSetIndex;
7348 + __u8 bReserved[124];
7349 +} CSMI_SAS_RAID_SET_DELETE_INFO,
7350 + *PCSMI_SAS_RAID_SET_DELETE_INFO;
7351 +
7352 +typedef struct _CSMI_SAS_RAID_SET_MODIFY_INFO {
7353 + __u8 bRaidType;
7354 + __u8 bReservedBytes[7];
7355 + __u32 uStripeSize;
7356 + struct
7357 + {
7358 + __u32 uLowPart;
7359 + __u32 uHighPart;
7360 + } ulRaidSetBlocks;
7361 + struct
7362 + {
7363 + __u32 uLowPart;
7364 + __u32 uHighPart;
7365 + } ulRaidSetExtentOffset;
7366 + __u32 uDriveCount;
7367 + __u8 bReserved[96];
7368 +} CSMI_SAS_RAID_SET_MODIFY_INFO,
7369 + *PCSMI_SAS_RAID_SET_MODIFY_INFO;
7370 +
7371 +typedef struct _CSMI_SAS_RAID_SET_TRANSFORM_INFO {
7372 + __u8 bTransformType;
7373 + __u8 bReservedBytes[3];
7374 + __u32 uRaidSetIndex;
7375 + __u8 bRaidType;
7376 + __u8 bReservedBytes2[11];
7377 + __u32 uAdditionalRaidSetIndex;
7378 + __u32 uRaidSetCount;
7379 + __u8 bApplicationScratchPad[16];
7380 + CSMI_SAS_RAID_SET_MODIFY_INFO Modify;
7381 + __u8 bReserved[80];
7382 +} CSMI_SAS_RAID_SET_TRANSFORM_INFO,
7383 + *PCSMI_SAS_RAID_SET_TRANSFORM_INFO;
7384 +
7385 +typedef struct _CSMI_SAS_RAID_SET_LABEL_INFO {
7386 + __u32 uRaidSetIndex;
7387 + __u8 bLabel[16];
7388 + __u8 bReserved[108];
7389 +} CSMI_SAS_RAID_SET_LABEL_INFO,
7390 + *PCSMI_SAS_RAID_SET_LABEL_INFO;
7391 +
7392 +typedef struct _CSMI_SAS_RAID_SET_CREATE_INFO {
7393 + __u8 bRaidType;
7394 + __u8 bReservedBytes[7];
7395 + __u32 uStripeSize;
7396 + __u32 uTrackSectorCount;
7397 + struct
7398 + {
7399 + __u32 uLowPart;
7400 + __u32 uHighPart;
7401 + } ulRaidSetBlocks;
7402 + struct
7403 + {
7404 + __u32 uLowPart;
7405 + __u32 uHighPart;
7406 + } ulRaidSetExtentOffset;
7407 + __u32 uDriveCount;
7408 + __u8 bLabel[16];
7409 + __u32 uRaidSetIndex;
7410 + __u8 bApplicationScratchPad[16];
7411 + __u32 uNumberOfHeads;
7412 + __u32 uNumberOfTracks;
7413 + __u8 bReserved[48];
7414 +} CSMI_SAS_RAID_SET_CREATE_INFO,
7415 + *PCSMI_SAS_RAID_SET_CREATE_INFO;
7416 +
7417 +typedef struct _CSMI_SAS_RAID_SET_OPERATION {
7418 + __u32 uOperationType;
7419 + __u32 uChangeCount;
7420 + __u32 uFailureCode;
7421 + __u8 bFailureDescription[80];
7422 + __u8 bReserved[28];
7423 + union {
7424 + CSMI_SAS_RAID_SET_CREATE_INFO Create;
7425 + CSMI_SAS_RAID_SET_LABEL_INFO Label;
7426 + CSMI_SAS_RAID_SET_TRANSFORM_INFO Transform;
7427 + CSMI_SAS_RAID_SET_DELETE_INFO Delete;
7428 + CSMI_SAS_RAID_SET_WRITE_PROTECT_INFO Protect;
7429 + CSMI_SAS_RAID_SET_CACHE_INFO Cache;
7430 + CSMI_SAS_RAID_SET_ONLINE_STATE_INFO State;
7431 + CSMI_SAS_RAID_SET_SPARE_INFO Spare;
7432 + } Operation;
7433 + union {
7434 + CSMI_SAS_RAID_SET_DRIVE_LIST DriveList[1];
7435 + CSMI_SAS_RAID_SET_LIST RaidSetList[1];
7436 + } Parameters;
7437 +} CSMI_SAS_RAID_SET_OPERATION,
7438 + *PCSMI_SAS_RAID_SET_OPERATION;
7439 +
7440 +typedef struct _CSMI_SAS_RAID_SET_OPERATION_BUFFER {
7441 + IOCTL_HEADER IoctlHeader;
7442 + CSMI_SAS_RAID_SET_OPERATION Information;
7443 +} CSMI_SAS_RAID_SET_OPERATION_BUFFER,
7444 + *PCSMI_SAS_RAID_SET_OPERATION_BUFFER;
7445 +
7446 +/* * * * * * * * * * SAS HBA Class Structures * * * * * * * * * */
7447 +
7448 +// CC_CSMI_SAS_GET_PHY_INFO
7449 +
7450 +typedef struct _CSMI_SAS_IDENTIFY {
7451 + __u8 bDeviceType;
7452 + __u8 bRestricted;
7453 + __u8 bInitiatorPortProtocol;
7454 + __u8 bTargetPortProtocol;
7455 + __u8 bRestricted2[8];
7456 + __u8 bSASAddress[8];
7457 + __u8 bPhyIdentifier;
7458 + __u8 bSignalClass;
7459 + __u8 bReserved[6];
7460 +} CSMI_SAS_IDENTIFY,
7461 + *PCSMI_SAS_IDENTIFY;
7462 +
7463 +typedef struct _CSMI_SAS_PHY_ENTITY {
7464 + CSMI_SAS_IDENTIFY Identify;
7465 + __u8 bPortIdentifier;
7466 + __u8 bNegotiatedLinkRate;
7467 + __u8 bMinimumLinkRate;
7468 + __u8 bMaximumLinkRate;
7469 + __u8 bPhyChangeCount;
7470 + __u8 bAutoDiscover;
7471 + __u8 bPhyFeatures;
7472 + __u8 bReserved;
7473 + CSMI_SAS_IDENTIFY Attached;
7474 +} CSMI_SAS_PHY_ENTITY,
7475 + *PCSMI_SAS_PHY_ENTITY;
7476 +
7477 +typedef struct _CSMI_SAS_PHY_INFO {
7478 + __u8 bNumberOfPhys;
7479 + __u8 bReserved[3];
7480 + CSMI_SAS_PHY_ENTITY Phy[32];
7481 +} CSMI_SAS_PHY_INFO,
7482 + *PCSMI_SAS_PHY_INFO;
7483 +
7484 +typedef struct _CSMI_SAS_PHY_INFO_BUFFER {
7485 + IOCTL_HEADER IoctlHeader;
7486 + CSMI_SAS_PHY_INFO Information;
7487 +} CSMI_SAS_PHY_INFO_BUFFER,
7488 + *PCSMI_SAS_PHY_INFO_BUFFER;
7489 +
7490 +// CC_CSMI_SAS_SET_PHY_INFO
7491 +
7492 +typedef struct _CSMI_SAS_SET_PHY_INFO {
7493 + __u8 bPhyIdentifier;
7494 + __u8 bNegotiatedLinkRate;
7495 + __u8 bProgrammedMinimumLinkRate;
7496 + __u8 bProgrammedMaximumLinkRate;
7497 + __u8 bSignalClass;
7498 + __u8 bReserved[3];
7499 +} CSMI_SAS_SET_PHY_INFO,
7500 + *PCSMI_SAS_SET_PHY_INFO;
7501 +
7502 +typedef struct _CSMI_SAS_SET_PHY_INFO_BUFFER {
7503 + IOCTL_HEADER IoctlHeader;
7504 + CSMI_SAS_SET_PHY_INFO Information;
7505 +} CSMI_SAS_SET_PHY_INFO_BUFFER,
7506 + *PCSMI_SAS_SET_PHY_INFO_BUFFER;
7507 +
7508 +// CC_CSMI_SAS_GET_LINK_ERRORS
7509 +
7510 +typedef struct _CSMI_SAS_LINK_ERRORS {
7511 + __u8 bPhyIdentifier;
7512 + __u8 bResetCounts;
7513 + __u8 bReserved[2];
7514 + __u32 uInvalidDwordCount;
7515 + __u32 uRunningDisparityErrorCount;
7516 + __u32 uLossOfDwordSyncCount;
7517 + __u32 uPhyResetProblemCount;
7518 +} CSMI_SAS_LINK_ERRORS,
7519 + *PCSMI_SAS_LINK_ERRORS;
7520 +
7521 +typedef struct _CSMI_SAS_LINK_ERRORS_BUFFER {
7522 + IOCTL_HEADER IoctlHeader;
7523 + CSMI_SAS_LINK_ERRORS Information;
7524 +} CSMI_SAS_LINK_ERRORS_BUFFER,
7525 + *PCSMI_SAS_LINK_ERRORS_BUFFER;
7526 +
7527 +// CC_CSMI_SAS_SMP_PASSTHRU
7528 +
7529 +typedef struct _CSMI_SAS_SMP_REQUEST {
7530 + __u8 bFrameType;
7531 + __u8 bFunction;
7532 + __u8 bReserved[2];
7533 + __u8 bAdditionalRequestBytes[1016];
7534 +} CSMI_SAS_SMP_REQUEST,
7535 + *PCSMI_SAS_SMP_REQUEST;
7536 +
7537 +typedef struct _CSMI_SAS_SMP_RESPONSE {
7538 + __u8 bFrameType;
7539 + __u8 bFunction;
7540 + __u8 bFunctionResult;
7541 + __u8 bReserved;
7542 + __u8 bAdditionalResponseBytes[1016];
7543 +} CSMI_SAS_SMP_RESPONSE,
7544 + *PCSMI_SAS_SMP_RESPONSE;
7545 +
7546 +typedef struct _CSMI_SAS_SMP_PASSTHRU {
7547 + __u8 bPhyIdentifier;
7548 + __u8 bPortIdentifier;
7549 + __u8 bConnectionRate;
7550 + __u8 bReserved;
7551 + __u8 bDestinationSASAddress[8];
7552 + __u32 uRequestLength;
7553 + CSMI_SAS_SMP_REQUEST Request;
7554 + __u8 bConnectionStatus;
7555 + __u8 bReserved2[3];
7556 + __u32 uResponseBytes;
7557 + CSMI_SAS_SMP_RESPONSE Response;
7558 +} CSMI_SAS_SMP_PASSTHRU,
7559 + *PCSMI_SAS_SMP_PASSTHRU;
7560 +
7561 +typedef struct _CSMI_SAS_SMP_PASSTHRU_BUFFER {
7562 + IOCTL_HEADER IoctlHeader;
7563 + CSMI_SAS_SMP_PASSTHRU Parameters;
7564 +} CSMI_SAS_SMP_PASSTHRU_BUFFER,
7565 + *PCSMI_SAS_SMP_PASSTHRU_BUFFER;
7566 +
7567 +// CC_CSMI_SAS_SSP_PASSTHRU
7568 +
7569 +typedef struct _CSMI_SAS_SSP_PASSTHRU {
7570 + __u8 bPhyIdentifier;
7571 + __u8 bPortIdentifier;
7572 + __u8 bConnectionRate;
7573 + __u8 bReserved;
7574 + __u8 bDestinationSASAddress[8];
7575 + __u8 bLun[8];
7576 + __u8 bCDBLength;
7577 + __u8 bAdditionalCDBLength;
7578 + __u8 bReserved2[2];
7579 + __u8 bCDB[16];
7580 + __u32 uFlags;
7581 + __u8 bAdditionalCDB[24];
7582 + __u32 uDataLength;
7583 +} CSMI_SAS_SSP_PASSTHRU,
7584 + *PCSMI_SAS_SSP_PASSTHRU;
7585 +
7586 +typedef struct _CSMI_SAS_SSP_PASSTHRU_STATUS {
7587 + __u8 bConnectionStatus;
7588 + __u8 bSSPStatus;
7589 + __u8 bReserved[2];
7590 + __u8 bDataPresent;
7591 + __u8 bStatus;
7592 + __u8 bResponseLength[2];
7593 + __u8 bResponse[256];
7594 + __u32 uDataBytes;
7595 +} CSMI_SAS_SSP_PASSTHRU_STATUS,
7596 + *PCSMI_SAS_SSP_PASSTHRU_STATUS;
7597 +
7598 +typedef struct _CSMI_SAS_SSP_PASSTHRU_BUFFER {
7599 + IOCTL_HEADER IoctlHeader;
7600 + CSMI_SAS_SSP_PASSTHRU Parameters;
7601 + CSMI_SAS_SSP_PASSTHRU_STATUS Status;
7602 + __u8 bDataBuffer[1];
7603 +} CSMI_SAS_SSP_PASSTHRU_BUFFER,
7604 + *PCSMI_SAS_SSP_PASSTHRU_BUFFER;
7605 +
7606 +// CC_CSMI_SAS_STP_PASSTHRU
7607 +
7608 +typedef struct _CSMI_SAS_STP_PASSTHRU {
7609 + __u8 bPhyIdentifier;
7610 + __u8 bPortIdentifier;
7611 + __u8 bConnectionRate;
7612 + __u8 bReserved;
7613 + __u8 bDestinationSASAddress[8];
7614 + __u8 bReserved2[4];
7615 + __u8 bCommandFIS[20];
7616 + __u32 uFlags;
7617 + __u32 uDataLength;
7618 +} CSMI_SAS_STP_PASSTHRU,
7619 + *PCSMI_SAS_STP_PASSTHRU;
7620 +
7621 +typedef struct _CSMI_SAS_STP_PASSTHRU_STATUS {
7622 + __u8 bConnectionStatus;
7623 + __u8 bReserved[3];
7624 + __u8 bStatusFIS[20];
7625 + __u32 uSCR[16];
7626 + __u32 uDataBytes;
7627 +} CSMI_SAS_STP_PASSTHRU_STATUS,
7628 + *PCSMI_SAS_STP_PASSTHRU_STATUS;
7629 +
7630 +typedef struct _CSMI_SAS_STP_PASSTHRU_BUFFER {
7631 + IOCTL_HEADER IoctlHeader;
7632 + CSMI_SAS_STP_PASSTHRU Parameters;
7633 + CSMI_SAS_STP_PASSTHRU_STATUS Status;
7634 + __u8 bDataBuffer[1];
7635 +} CSMI_SAS_STP_PASSTHRU_BUFFER,
7636 + *PCSMI_SAS_STP_PASSTHRU_BUFFER;
7637 +
7638 +// CC_CSMI_SAS_GET_SATA_SIGNATURE
7639 +
7640 +typedef struct _CSMI_SAS_SATA_SIGNATURE {
7641 + __u8 bPhyIdentifier;
7642 + __u8 bReserved[3];
7643 + __u8 bSignatureFIS[20];
7644 +} CSMI_SAS_SATA_SIGNATURE,
7645 + *PCSMI_SAS_SATA_SIGNATURE;
7646 +
7647 +typedef struct _CSMI_SAS_SATA_SIGNATURE_BUFFER {
7648 + IOCTL_HEADER IoctlHeader;
7649 + CSMI_SAS_SATA_SIGNATURE Signature;
7650 +} CSMI_SAS_SATA_SIGNATURE_BUFFER,
7651 + *PCSMI_SAS_SATA_SIGNATURE_BUFFER;
7652 +
7653 +// CC_CSMI_SAS_GET_SCSI_ADDRESS
7654 +
7655 +typedef struct _CSMI_SAS_GET_SCSI_ADDRESS_BUFFER {
7656 + IOCTL_HEADER IoctlHeader;
7657 + __u8 bSASAddress[8];
7658 + __u8 bSASLun[8];
7659 + __u8 bHostIndex;
7660 + __u8 bPathId;
7661 + __u8 bTargetId;
7662 + __u8 bLun;
7663 +} CSMI_SAS_GET_SCSI_ADDRESS_BUFFER,
7664 + *PCSMI_SAS_GET_SCSI_ADDRESS_BUFFER;
7665 +
7666 +// CC_CSMI_SAS_GET_DEVICE_ADDRESS
7667 +
7668 +typedef struct _CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER {
7669 + IOCTL_HEADER IoctlHeader;
7670 + __u8 bHostIndex;
7671 + __u8 bPathId;
7672 + __u8 bTargetId;
7673 + __u8 bLun;
7674 + __u8 bSASAddress[8];
7675 + __u8 bSASLun[8];
7676 +} CSMI_SAS_GET_DEVICE_ADDRESS_BUFFER,
7677 + *PCSMI_SAS_GET_DEVICE_ADDRESS_BUFFER;
7678 +
7679 +// CC_CSMI_SAS_TASK_MANAGEMENT
7680 +
7681 +typedef struct _CSMI_SAS_SSP_TASK_IU {
7682 + __u8 bHostIndex;
7683 + __u8 bPathId;
7684 + __u8 bTargetId;
7685 + __u8 bLun;
7686 + __u32 uFlags;
7687 + __u32 uQueueTag;
7688 + __u32 uReserved;
7689 + __u8 bTaskManagementFunction;
7690 + __u8 bReserved[7];
7691 + __u32 uInformation;
7692 +} CSMI_SAS_SSP_TASK_IU,
7693 + *PCSMI_SAS_SSP_TASK_IU;
7694 +
7695 +typedef struct _CSMI_SAS_SSP_TASK_IU_BUFFER {
7696 + IOCTL_HEADER IoctlHeader;
7697 + CSMI_SAS_SSP_TASK_IU Parameters;
7698 + CSMI_SAS_SSP_PASSTHRU_STATUS Status;
7699 +} CSMI_SAS_SSP_TASK_IU_BUFFER,
7700 + *PCSMI_SAS_SSP_TASK_IU_BUFFER;
7701 +
7702 +// CC_CSMI_SAS_GET_CONNECTOR_INFO
7703 +
7704 +typedef struct _CSMI_SAS_GET_CONNECTOR_INFO {
7705 + __u32 uPinout;
7706 + __u8 bConnector[16];
7707 + __u8 bLocation;
7708 + __u8 bReserved[15];
7709 +} CSMI_SAS_CONNECTOR_INFO,
7710 + *PCSMI_SAS_CONNECTOR_INFO;
7711 +
7712 +typedef struct _CSMI_SAS_CONNECTOR_INFO_BUFFER {
7713 + IOCTL_HEADER IoctlHeader;
7714 + CSMI_SAS_CONNECTOR_INFO Reference[32];
7715 +} CSMI_SAS_CONNECTOR_INFO_BUFFER,
7716 + *PCSMI_SAS_CONNECTOR_INFO_BUFFER;
7717 +
7718 +// CC_CSMI_SAS_GET_LOCATION
7719 +
7720 +typedef struct _CSMI_SAS_LOCATION_IDENTIFIER {
7721 + __u32 bLocationFlags;
7722 + __u8 bSASAddress[8];
7723 + __u8 bSASLun[8];
7724 + __u8 bEnclosureIdentifier[8];
7725 + __u8 bEnclosureName[32];
7726 + __u8 bBayPrefix[32];
7727 + __u8 bBayIdentifier;
7728 + __u8 bLocationState;
7729 + __u8 bReserved[2];
7730 +} CSMI_SAS_LOCATION_IDENTIFIER,
7731 + *PCSMI_SAS_LOCATION_IDENTIFIER;
7732 +
7733 +typedef struct _CSMI_SAS_GET_LOCATION_BUFFER {
7734 + IOCTL_HEADER IoctlHeader;
7735 + __u8 bHostIndex;
7736 + __u8 bPathId;
7737 + __u8 bTargetId;
7738 + __u8 bLun;
7739 + __u8 bIdentify;
7740 + __u8 bNumberOfLocationIdentifiers;
7741 + __u8 bLengthOfLocationIdentifier;
7742 + CSMI_SAS_LOCATION_IDENTIFIER Location[1];
7743 +} CSMI_SAS_GET_LOCATION_BUFFER,
7744 + *PCSMI_SAS_GET_LOCATION_BUFFER;
7745 +
7746 +// CC_CSMI_SAS_PHY_CONTROL
7747 +
7748 +typedef struct _CSMI_SAS_CHARACTER {
7749 + __u8 bTypeFlags;
7750 + __u8 bValue;
7751 +} CSMI_SAS_CHARACTER,
7752 + *PCSMI_SAS_CHARACTER;
7753 +
7754 +typedef struct _CSMI_SAS_PHY_CONTROL {
7755 + __u8 bType;
7756 + __u8 bRate;
7757 + __u8 bReserved[6];
7758 + __u32 uVendorUnique[8];
7759 + __u32 uTransmitterFlags;
7760 + __i8 bTransmitAmplitude;
7761 + __i8 bTransmitterPreemphasis;
7762 + __i8 bTransmitterSlewRate;
7763 + __i8 bTransmitterReserved[13];
7764 + __u8 bTransmitterVendorUnique[64];
7765 + __u32 uReceiverFlags;
7766 + __i8 bReceiverThreshold;
7767 + __i8 bReceiverEqualizationGain;
7768 + __i8 bReceiverReserved[14];
7769 + __u8 bReceiverVendorUnique[64];
7770 + __u32 uPatternFlags;
7771 + __u8 bFixedPattern;
7772 + __u8 bUserPatternLength;
7773 + __u8 bPatternReserved[6];
7774 + CSMI_SAS_CHARACTER UserPatternBuffer[16];
7775 +} CSMI_SAS_PHY_CONTROL,
7776 + *PCSMI_SAS_PHY_CONTROL;
7777 +
7778 +typedef struct _CSMI_SAS_PHY_CONTROL_BUFFER {
7779 + IOCTL_HEADER IoctlHeader;
7780 + __u32 uFunction;
7781 + __u8 bPhyIdentifier;
7782 + __u16 usLengthOfControl;
7783 + __u8 bNumberOfControls;
7784 + __u8 bReserved[4];
7785 + __u32 uLinkFlags;
7786 + __u8 bSpinupRate;
7787 + __u8 bLinkReserved[7];
7788 + __u32 uVendorUnique[8];
7789 + CSMI_SAS_PHY_CONTROL Control[1];
7790 +} CSMI_SAS_PHY_CONTROL_BUFFER,
7791 + *PCSMI_SAS_PHY_CONTROL_BUFFER;
7792 +
7793 +//EDM #pragma CSMI_SAS_END_PACK
7794 +#pragma pack()
7795 +
7796 +#endif // _CSMI_SAS_H_
7797 --- a/drivers/message/fusion/Kconfig
7798 +++ b/drivers/message/fusion/Kconfig
7799 @@ -61,13 +61,25 @@ config FUSION_SAS
7800 LSISAS1078
7801
7802 config FUSION_MAX_SGE
7803 - int "Maximum number of scatter gather entries (16 - 128)"
7804 + int "Maximum number of scatter gather entries for SAS and SPI (16 - 128)"
7805 default "128"
7806 range 16 128
7807 help
7808 This option allows you to specify the maximum number of scatter-
7809 gather entries per I/O. The driver default is 128, which matches
7810 - SCSI_MAX_PHYS_SEGMENTS. However, it may decreased down to 16.
7811 + SAFE_PHYS_SEGMENTS. However, it may decreased down to 16.
7812 + Decreasing this parameter will reduce memory requirements
7813 + on a per controller instance.
7814 +
7815 +config FUSION_MAX_FC_SGE
7816 + int "Maximum number of scatter gather entries for FC (16 - 256)"
7817 + depends on FUSION_FC
7818 + default "256"
7819 + range 16 256
7820 + help
7821 + This option allows you to specify the maximum number of scatter-
7822 + gather entries per I/O. The driver default is 256, which matches
7823 + MAX_PHYS_SEGMENTS. However, it may decreased down to 16.
7824 Decreasing this parameter will reduce memory requirements
7825 on a per controller instance.
7826
7827 --- a/drivers/message/fusion/lsi/mpi_cnfg.h
7828 +++ b/drivers/message/fusion/lsi/mpi_cnfg.h
7829 @@ -6,7 +6,7 @@
7830 * Title: MPI Config message, structures, and Pages
7831 * Creation Date: July 27, 2000
7832 *
7833 - * mpi_cnfg.h Version: 01.05.15
7834 + * mpi_cnfg.h Version: 01.05.18
7835 *
7836 * Version History
7837 * ---------------
7838 @@ -308,6 +308,20 @@
7839 * Expander Page 0 Flags field.
7840 * Fixed define for
7841 * MPI_SAS_EXPANDER1_DISCINFO_BAD_PHY_DISABLED.
7842 + * 08-07-07 01.05.16 Added MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT
7843 + * define.
7844 + * Added BIOS Page 4 structure.
7845 + * Added MPI_RAID_PHYS_DISK1_PATH_MAX define for RAID
7846 + * Physcial Disk Page 1.
7847 + * 01-15-07 01.05.17 Added additional bit defines for ExtFlags field of
7848 + * Manufacturing Page 4.
7849 + * Added Solid State Drives Supported bit to IOC Page 6
7850 + * Capabilities Flags.
7851 + * Added new value for AccessStatus field of SAS Device
7852 + * Page 0 (_SATA_NEEDS_INITIALIZATION).
7853 + * 03-28-08 01.05.18 Defined new bits in Manufacturing Page 4 ExtFlags field
7854 + * to control coercion size and the mixing of SAS and SATA
7855 + * SSD drives.
7856 * --------------------------------------------------------------------------
7857 */
7858
7859 @@ -686,6 +700,14 @@ typedef struct _CONFIG_PAGE_MANUFACTURIN
7860 #define MPI_MANPAGE4_IR_NO_MIX_SAS_SATA (0x01)
7861
7862 /* defines for the ExtFlags field */
7863 +#define MPI_MANPAGE4_EXTFLAGS_MASK_COERCION_SIZE (0x0180)
7864 +#define MPI_MANPAGE4_EXTFLAGS_SHIFT_COERCION_SIZE (7)
7865 +#define MPI_MANPAGE4_EXTFLAGS_1GB_COERCION_SIZE (0)
7866 +#define MPI_MANPAGE4_EXTFLAGS_128MB_COERCION_SIZE (1)
7867 +
7868 +#define MPI_MANPAGE4_EXTFLAGS_NO_MIX_SSD_SAS_SATA (0x0040)
7869 +#define MPI_MANPAGE4_EXTFLAGS_MIX_SSD_AND_NON_SSD (0x0020)
7870 +#define MPI_MANPAGE4_EXTFLAGS_DUAL_PORT_SUPPORT (0x0010)
7871 #define MPI_MANPAGE4_EXTFLAGS_HIDE_NON_IR_METADATA (0x0008)
7872 #define MPI_MANPAGE4_EXTFLAGS_SAS_CACHE_DISABLE (0x0004)
7873 #define MPI_MANPAGE4_EXTFLAGS_SATA_CACHE_DISABLE (0x0002)
7874 @@ -1159,6 +1181,8 @@ typedef struct _CONFIG_PAGE_IOC_6
7875
7876 /* IOC Page 6 Capabilities Flags */
7877
7878 +#define MPI_IOCPAGE6_CAP_FLAGS_SSD_SUPPORT (0x00000020)
7879 +#define MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT (0x00000010)
7880 #define MPI_IOCPAGE6_CAP_FLAGS_DISABLE_SMART_POLLING (0x00000008)
7881
7882 #define MPI_IOCPAGE6_CAP_FLAGS_MASK_METADATA_SIZE (0x00000006)
7883 @@ -1428,6 +1452,15 @@ typedef struct _CONFIG_PAGE_BIOS_2
7884 #define MPI_BIOSPAGE2_FORM_SAS_WWN (0x05)
7885 #define MPI_BIOSPAGE2_FORM_ENCLOSURE_SLOT (0x06)
7886
7887 +typedef struct _CONFIG_PAGE_BIOS_4
7888 +{
7889 + CONFIG_PAGE_HEADER Header; /* 00h */
7890 + U64 ReassignmentBaseWWID; /* 04h */
7891 +} CONFIG_PAGE_BIOS_4, MPI_POINTER PTR_CONFIG_PAGE_BIOS_4,
7892 + BIOSPage4_t, MPI_POINTER pBIOSPage4_t;
7893 +
7894 +#define MPI_BIOSPAGE4_PAGEVERSION (0x00)
7895 +
7896
7897 /****************************************************************************
7898 * SCSI Port Config Pages
7899 @@ -2419,6 +2452,15 @@ typedef struct _RAID_PHYS_DISK1_PATH
7900 #define MPI_RAID_PHYSDISK1_FLAG_BROKEN (0x0002)
7901 #define MPI_RAID_PHYSDISK1_FLAG_INVALID (0x0001)
7902
7903 +
7904 +/*
7905 + * Host code (drivers, BIOS, utilities, etc.) should leave this define set to
7906 + * one and check Header.PageLength or NumPhysDiskPaths at runtime.
7907 + */
7908 +#ifndef MPI_RAID_PHYS_DISK1_PATH_MAX
7909 +#define MPI_RAID_PHYS_DISK1_PATH_MAX (1)
7910 +#endif
7911 +
7912 typedef struct _CONFIG_PAGE_RAID_PHYS_DISK_1
7913 {
7914 CONFIG_PAGE_HEADER Header; /* 00h */
7915 @@ -2426,7 +2468,7 @@ typedef struct _CONFIG_PAGE_RAID_PHYS_DI
7916 U8 PhysDiskNum; /* 05h */
7917 U16 Reserved2; /* 06h */
7918 U32 Reserved1; /* 08h */
7919 - RAID_PHYS_DISK1_PATH Path[1]; /* 0Ch */
7920 + RAID_PHYS_DISK1_PATH Path[MPI_RAID_PHYS_DISK1_PATH_MAX];/* 0Ch */
7921 } CONFIG_PAGE_RAID_PHYS_DISK_1, MPI_POINTER PTR_CONFIG_PAGE_RAID_PHYS_DISK_1,
7922 RaidPhysDiskPage1_t, MPI_POINTER pRaidPhysDiskPage1_t;
7923
7924 @@ -2844,6 +2886,7 @@ typedef struct _CONFIG_PAGE_SAS_DEVICE_0
7925 #define MPI_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED (0x01)
7926 #define MPI_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED (0x02)
7927 #define MPI_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT (0x03)
7928 +#define MPI_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION (0x04)
7929 /* specific values for SATA Init failures */
7930 #define MPI_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN (0x10)
7931 #define MPI_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT (0x11)
7932 --- a/drivers/message/fusion/lsi/mpi_fc.h
7933 +++ b/drivers/message/fusion/lsi/mpi_fc.h
7934 @@ -1,5 +1,5 @@
7935 /*
7936 - * Copyright (c) 2000-2004 LSI Corporation.
7937 + * Copyright (c) 2000-2008 LSI Corporation.
7938 *
7939 *
7940 * Name: mpi_fc.h
7941 --- a/drivers/message/fusion/lsi/mpi.h
7942 +++ b/drivers/message/fusion/lsi/mpi.h
7943 @@ -6,7 +6,7 @@
7944 * Title: MPI Message independent structures and definitions
7945 * Creation Date: July 27, 2000
7946 *
7947 - * mpi.h Version: 01.05.13
7948 + * mpi.h Version: 01.05.16
7949 *
7950 * Version History
7951 * ---------------
7952 @@ -79,6 +79,9 @@
7953 * 03-27-06 01.05.11 Bumped MPI_HEADER_VERSION_UNIT.
7954 * 10-11-06 01.05.12 Bumped MPI_HEADER_VERSION_UNIT.
7955 * 05-24-07 01.05.13 Bumped MPI_HEADER_VERSION_UNIT.
7956 + * 08-07-07 01.05.14 Bumped MPI_HEADER_VERSION_UNIT.
7957 + * 01-15-08 01.05.15 Bumped MPI_HEADER_VERSION_UNIT.
7958 + * 03-28-08 01.05.16 Bumped MPI_HEADER_VERSION_UNIT.
7959 * --------------------------------------------------------------------------
7960 */
7961
7962 @@ -109,7 +112,7 @@
7963 /* Note: The major versions of 0xe0 through 0xff are reserved */
7964
7965 /* versioning for this MPI header set */
7966 -#define MPI_HEADER_VERSION_UNIT (0x10)
7967 +#define MPI_HEADER_VERSION_UNIT (0x13)
7968 #define MPI_HEADER_VERSION_DEV (0x00)
7969 #define MPI_HEADER_VERSION_UNIT_MASK (0xFF00)
7970 #define MPI_HEADER_VERSION_UNIT_SHIFT (8)
7971 --- a/drivers/message/fusion/lsi/mpi_history.txt
7972 +++ b/drivers/message/fusion/lsi/mpi_history.txt
7973 @@ -3,28 +3,28 @@
7974 MPI Header File Change History
7975 ==============================
7976
7977 - Copyright (c) 2000-2007 LSI Corporation.
7978 + Copyright (c) 2000-2008 LSI Corporation.
7979
7980 ---------------------------------------
7981 - Header Set Release Version: 01.05.16
7982 - Header Set Release Date: 05-24-07
7983 + Header Set Release Version: 01.05.19
7984 + Header Set Release Date: 03-28-08
7985 ---------------------------------------
7986
7987 Filename Current version Prior version
7988 ---------- --------------- -------------
7989 - mpi.h 01.05.13 01.05.12
7990 - mpi_ioc.h 01.05.14 01.05.13
7991 - mpi_cnfg.h 01.05.15 01.05.14
7992 + mpi.h 01.05.16 01.05.15
7993 + mpi_ioc.h 01.05.16 01.05.15
7994 + mpi_cnfg.h 01.05.18 01.05.17
7995 mpi_init.h 01.05.09 01.05.09
7996 mpi_targ.h 01.05.06 01.05.06
7997 mpi_fc.h 01.05.01 01.05.01
7998 mpi_lan.h 01.05.01 01.05.01
7999 - mpi_raid.h 01.05.03 01.05.03
8000 + mpi_raid.h 01.05.05 01.05.05
8001 mpi_tool.h 01.05.03 01.05.03
8002 mpi_inb.h 01.05.01 01.05.01
8003 - mpi_sas.h 01.05.04 01.05.04
8004 + mpi_sas.h 01.05.05 01.05.05
8005 mpi_type.h 01.05.02 01.05.02
8006 - mpi_history.txt 01.05.14 01.05.14
8007 + mpi_history.txt 01.05.19 01.05.18
8008
8009
8010 * Date Version Description
8011 @@ -96,6 +96,9 @@ mpi.h
8012 * 03-27-06 01.05.11 Bumped MPI_HEADER_VERSION_UNIT.
8013 * 10-11-06 01.05.12 Bumped MPI_HEADER_VERSION_UNIT.
8014 * 05-24-07 01.05.13 Bumped MPI_HEADER_VERSION_UNIT.
8015 + * 08-07-07 01.05.14 Bumped MPI_HEADER_VERSION_UNIT.
8016 + * 01-15-08 01.05.15 Bumped MPI_HEADER_VERSION_UNIT.
8017 + * 03-28-08 01.05.16 Bumped MPI_HEADER_VERSION_UNIT.
8018 * --------------------------------------------------------------------------
8019
8020 mpi_ioc.h
8021 @@ -127,7 +130,7 @@ mpi_ioc.h
8022 * 08-08-01 01.02.01 Original release for v1.2 work.
8023 * New format for FWVersion and ProductId in
8024 * MSG_IOC_FACTS_REPLY and MPI_FW_HEADER.
8025 - * 08-31-01 01.02.02 Added event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
8026 + * 08-31-01 01.02.02 Addded event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
8027 * related structure and defines.
8028 * Added event MPI_EVENT_ON_BUS_TIMER_EXPIRED.
8029 * Added MPI_IOCINIT_FLAGS_DISCARD_FW_IMAGE.
8030 @@ -187,7 +190,7 @@ mpi_ioc.h
8031 * 10-11-06 01.05.12 Added MPI_IOCFACTS_EXCEPT_METADATA_UNSUPPORTED.
8032 * Added MaxInitiators field to PortFacts reply.
8033 * Added SAS Device Status Change ReasonCode for
8034 - * asynchronous notification.
8035 + * asynchronous notificaiton.
8036 * Added MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE and event
8037 * data structure.
8038 * Added new ImageType values for FWDownload and FWUpload
8039 @@ -199,6 +202,16 @@ mpi_ioc.h
8040 * added _MULTI_PORT_DOMAIN.
8041 * 05-24-07 01.05.14 Added Common Boot Block type to FWDownload Request.
8042 * Added Common Boot Block type to FWUpload Request.
8043 + * 08-07-07 01.05.15 Added MPI_EVENT_SAS_INIT_RC_REMOVED define.
8044 + * Added MPI_EVENT_IR2_RC_DUAL_PORT_ADDED and
8045 + * MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED for IR2 event data.
8046 + * Added SASAddress field to SAS Initiator Device Table
8047 + * Overflow event data structure.
8048 + * 03-28-08 01.05.16 Added two new ReasonCode values to SAS Device Status
8049 + * Change Event data to indicate completion of internally
8050 + * generated task management.
8051 + * Added MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE define.
8052 + * Added MPI_EVENT_SAS_INIT_RC_INACCESSIBLE define.
8053 * --------------------------------------------------------------------------
8054
8055 mpi_cnfg.h
8056 @@ -213,7 +226,7 @@ mpi_cnfg.h
8057 * Added _RESPONSE_ID_MASK definition to SCSI_PORT_1
8058 * page and updated the page version.
8059 * Added Information field and _INFO_PARAMS_NEGOTIATED
8060 - * definition to SCSI_DEVICE_0 page.
8061 + * definitionto SCSI_DEVICE_0 page.
8062 * 06-22-00 01.00.03 Removed batch controls from LAN_0 page and updated the
8063 * page version.
8064 * Added BucketsRemaining to LAN_1 page, redefined the
8065 @@ -496,6 +509,20 @@ mpi_cnfg.h
8066 * Expander Page 0 Flags field.
8067 * Fixed define for
8068 * MPI_SAS_EXPANDER1_DISCINFO_BAD_PHY_DISABLED.
8069 + * 08-07-07 01.05.16 Added MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT
8070 + * define.
8071 + * Added BIOS Page 4 structure.
8072 + * Added MPI_RAID_PHYS_DISK1_PATH_MAX define for RAID
8073 + * Physcial Disk Page 1.
8074 + * 01-15-07 01.05.17 Added additional bit defines for ExtFlags field of
8075 + * Manufacturing Page 4.
8076 + * Added Solid State Drives Supported bit to IOC Page 6
8077 + * Capabilities Flags.
8078 + * Added new value for AccessStatus field of SAS Device
8079 + * Page 0 (_SATA_NEEDS_INITIALIZATION).
8080 + * 03-28-08 01.05.18 Defined new bits in Manufacturing Page 4 ExtFlags field
8081 + * to control coercion size and the mixing of SAS and SATA
8082 + * SSD drives.
8083 * --------------------------------------------------------------------------
8084
8085 mpi_init.h
8086 @@ -661,6 +688,9 @@ mpi_raid.h
8087 * _SET_RESYNC_RATE and _SET_DATA_SCRUB_RATE.
8088 * 02-28-07 01.05.03 Added new RAID Action, Device FW Update Mode, and
8089 * associated defines.
8090 + * 08-07-07 01.05.04 Added Disable Full Rebuild bit to the ActionDataWord
8091 + * for the RAID Action MPI_RAID_ACTION_DISABLE_VOLUME.
8092 + * 01-15-08 01.05.05 Added define for MPI_RAID_ACTION_SET_VOLUME_NAME.
8093 * --------------------------------------------------------------------------
8094
8095 mpi_tool.h
8096 @@ -694,6 +724,10 @@ mpi_sas.h
8097 * reply.
8098 * 10-11-06 01.05.04 Fixed the name of a define for Operation field of SAS IO
8099 * Unit Control request.
8100 + * 01-15-08 01.05.05 Added support for MPI_SAS_OP_SET_IOC_PARAMETER,
8101 + * including adding IOCParameter and IOCParameter value
8102 + * fields to SAS IO Unit Control Request.
8103 + * Added MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC define.
8104 * --------------------------------------------------------------------------
8105
8106 mpi_type.h
8107 @@ -709,20 +743,20 @@ mpi_type.h
8108
8109 mpi_history.txt Parts list history
8110
8111 -Filename 01.05.15 01.05.15
8112 ----------- -------- --------
8113 -mpi.h 01.05.12 01.05.13
8114 -mpi_ioc.h 01.05.13 01.05.14
8115 -mpi_cnfg.h 01.05.14 01.05.15
8116 -mpi_init.h 01.05.09 01.05.09
8117 -mpi_targ.h 01.05.06 01.05.06
8118 -mpi_fc.h 01.05.01 01.05.01
8119 -mpi_lan.h 01.05.01 01.05.01
8120 -mpi_raid.h 01.05.03 01.05.03
8121 -mpi_tool.h 01.05.03 01.05.03
8122 -mpi_inb.h 01.05.01 01.05.01
8123 -mpi_sas.h 01.05.04 01.05.04
8124 -mpi_type.h 01.05.02 01.05.02
8125 +Filename 01.05.19 01.05.18 01.05.17 01.05.16 01.05.15
8126 +---------- -------- -------- -------- -------- --------
8127 +mpi.h 01.05.16 01.05.15 01.05.14 01.05.13 01.05.12
8128 +mpi_ioc.h 01.05.16 01.05.15 01.05.15 01.05.14 01.05.13
8129 +mpi_cnfg.h 01.05.18 01.05.17 01.05.16 01.05.15 01.05.14
8130 +mpi_init.h 01.05.09 01.05.09 01.05.09 01.05.09 01.05.09
8131 +mpi_targ.h 01.05.06 01.05.06 01.05.06 01.05.06 01.05.06
8132 +mpi_fc.h 01.05.01 01.05.01 01.05.01 01.05.01 01.05.01
8133 +mpi_lan.h 01.05.01 01.05.01 01.05.01 01.05.01 01.05.01
8134 +mpi_raid.h 01.05.05 01.05.05 01.05.04 01.05.03 01.05.03
8135 +mpi_tool.h 01.05.03 01.05.03 01.05.03 01.05.03 01.05.03
8136 +mpi_inb.h 01.05.01 01.05.01 01.05.01 01.05.01 01.05.01
8137 +mpi_sas.h 01.05.05 01.05.05 01.05.04 01.05.04 01.05.04
8138 +mpi_type.h 01.05.02 01.05.02 01.05.02 01.05.02 01.05.02
8139
8140 Filename 01.05.14 01.05.13 01.05.12 01.05.11 01.05.10 01.05.09
8141 ---------- -------- -------- -------- -------- -------- --------
8142 --- a/drivers/message/fusion/lsi/mpi_init.h
8143 +++ b/drivers/message/fusion/lsi/mpi_init.h
8144 @@ -1,5 +1,5 @@
8145 /*
8146 - * Copyright (c) 2000-2007 LSI Corporation.
8147 + * Copyright (c) 2000-2008 LSI Corporation.
8148 *
8149 *
8150 * Name: mpi_init.h
8151 --- a/drivers/message/fusion/lsi/mpi_ioc.h
8152 +++ b/drivers/message/fusion/lsi/mpi_ioc.h
8153 @@ -1,12 +1,12 @@
8154 /*
8155 - * Copyright (c) 2000-2007 LSI Corporation.
8156 + * Copyright (c) 2000-2008 LSI Corporation.
8157 *
8158 *
8159 * Name: mpi_ioc.h
8160 * Title: MPI IOC, Port, Event, FW Download, and FW Upload messages
8161 * Creation Date: August 11, 2000
8162 *
8163 - * mpi_ioc.h Version: 01.05.14
8164 + * mpi_ioc.h Version: 01.05.16
8165 *
8166 * Version History
8167 * ---------------
8168 @@ -113,6 +113,16 @@
8169 * added _MULTI_PORT_DOMAIN.
8170 * 05-24-07 01.05.14 Added Common Boot Block type to FWDownload Request.
8171 * Added Common Boot Block type to FWUpload Request.
8172 + * 08-07-07 01.05.15 Added MPI_EVENT_SAS_INIT_RC_REMOVED define.
8173 + * Added MPI_EVENT_IR2_RC_DUAL_PORT_ADDED and
8174 + * MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED for IR2 event data.
8175 + * Added SASAddress field to SAS Initiator Device Table
8176 + * Overflow event data structure.
8177 + * 03-28-08 01.05.16 Added two new ReasonCode values to SAS Device Status
8178 + * Change Event data to indicate completion of internally
8179 + * generated task management.
8180 + * Added MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE define.
8181 + * Added MPI_EVENT_SAS_INIT_RC_INACCESSIBLE define.
8182 * --------------------------------------------------------------------------
8183 */
8184
8185 @@ -612,6 +622,8 @@ typedef struct _EVENT_DATA_SAS_DEVICE_ST
8186 #define MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL (0x0B)
8187 #define MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL (0x0C)
8188 #define MPI_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION (0x0D)
8189 +#define MPI_EVENT_SAS_DEV_STAT_RC_CMPL_INTERNAL_DEV_RESET (0x0E)
8190 +#define MPI_EVENT_SAS_DEV_STAT_RC_CMPL_TASK_ABORT_INTERNAL (0x0F)
8191
8192
8193 /* SCSI Event data for Queue Full event */
8194 @@ -708,6 +720,8 @@ typedef struct _MPI_EVENT_DATA_IR2
8195 #define MPI_EVENT_IR2_RC_PD_REMOVED (0x05)
8196 #define MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED (0x06)
8197 #define MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR (0x07)
8198 +#define MPI_EVENT_IR2_RC_DUAL_PORT_ADDED (0x08)
8199 +#define MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED (0x09)
8200
8201 /* defines for logical disk states */
8202 #define MPI_LD_STATE_OPTIMAL (0x00)
8203 @@ -867,6 +881,7 @@ typedef struct _EVENT_DATA_DISCOVERY_ERR
8204 #define MPI_EVENT_DSCVRY_ERR_DS_UNSUPPORTED_DEVICE (0x00000800)
8205 #define MPI_EVENT_DSCVRY_ERR_DS_MAX_SATA_TARGETS (0x00001000)
8206 #define MPI_EVENT_DSCVRY_ERR_DS_MULTI_PORT_DOMAIN (0x00002000)
8207 +#define MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE (0x00004000)
8208
8209 /* SAS SMP Error Event data */
8210
8211 @@ -902,6 +917,8 @@ typedef struct _EVENT_DATA_SAS_INIT_DEV_
8212
8213 /* defines for the ReasonCode field of the SAS Initiator Device Status Change event */
8214 #define MPI_EVENT_SAS_INIT_RC_ADDED (0x01)
8215 +#define MPI_EVENT_SAS_INIT_RC_REMOVED (0x02)
8216 +#define MPI_EVENT_SAS_INIT_RC_INACCESSIBLE (0x03)
8217
8218 /* SAS Initiator Device Table Overflow Event data */
8219
8220 @@ -910,6 +927,7 @@ typedef struct _EVENT_DATA_SAS_INIT_TABL
8221 U8 MaxInit; /* 00h */
8222 U8 CurrentInit; /* 01h */
8223 U16 Reserved1; /* 02h */
8224 + U64 SASAddress; /* 04h */
8225 } EVENT_DATA_SAS_INIT_TABLE_OVERFLOW,
8226 MPI_POINTER PTR_EVENT_DATA_SAS_INIT_TABLE_OVERFLOW,
8227 MpiEventDataSasInitTableOverflow_t,
8228 --- a/drivers/message/fusion/lsi/mpi_lan.h
8229 +++ b/drivers/message/fusion/lsi/mpi_lan.h
8230 @@ -1,5 +1,5 @@
8231 /*
8232 - * Copyright (c) 2000-2004 LSI Corporation.
8233 + * Copyright (c) 2000-2008 LSI Corporation.
8234 *
8235 *
8236 * Name: mpi_lan.h
8237 --- a/drivers/message/fusion/lsi/mpi_log_fc.h
8238 +++ b/drivers/message/fusion/lsi/mpi_log_fc.h
8239 @@ -1,5 +1,5 @@
8240 /*
8241 - * Copyright (c) 2000-2001 LSI Corporation. All rights reserved.
8242 + * Copyright (c) 2000-2008 LSI Corporation. All rights reserved.
8243 *
8244 * NAME: fc_log.h
8245 * SUMMARY: MPI IocLogInfo definitions for the SYMFC9xx chips
8246 --- a/drivers/message/fusion/lsi/mpi_log_sas.h
8247 +++ b/drivers/message/fusion/lsi/mpi_log_sas.h
8248 @@ -1,6 +1,6 @@
8249 /***************************************************************************
8250 * *
8251 - * Copyright 2003 LSI Corporation. All rights reserved. *
8252 + * Copyright (c) 2000-2008 LSI Corporation. All rights reserved. *
8253 * *
8254 * Description *
8255 * ------------ *
8256 @@ -73,6 +73,8 @@
8257 #define IOP_LOGINFO_CODE_TARGET_MODE_ABORT_EXACT_IO (0x00070004)
8258 #define IOP_LOGINFO_CODE_TARGET_MODE_ABORT_EXACT_IO_REQ (0x00070005)
8259
8260 +#define IOP_LOGINFO_CODE_LOG_TIMESTAMP_EVENT (0x00080000)
8261 +
8262 /****************************************************************************/
8263 /* PL LOGINFO_CODE defines, valid if IOC_LOGINFO_ORIGINATOR = PL */
8264 /****************************************************************************/
8265 @@ -92,7 +94,7 @@
8266 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_OPEN_TIMEOUT_EXP (0x0000000C)
8267 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_UNUSED_0D (0x0000000D)
8268 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_DVTBLE_ACCSS_FAIL (0x0000000E)
8269 -#define PL_LOGINFO_SUB CODE_OPEN_FAIL_BAD_DEST (0x00000011)
8270 +#define PL_LOGINFO_SUB_CODE_OPEN_FAIL_BAD_DEST (0x00000011)
8271 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_RATE_NOT_SUPP (0x00000012)
8272 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_PROT_NOT_SUPP (0x00000013)
8273 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_RESERVED_ABANDON0 (0x00000014)
8274 @@ -162,7 +164,7 @@
8275 #define PL_LOGINFO_SUB_CODE_FRAME_XFER_ERROR (0x00000400) /* Bits 0-3 encode Transport Status Register (offset 0x08) */
8276 /* Bit 0 is Status Bit 0: FrameXferErr */
8277 /* Bit 1 & 2 are Status Bits 16 and 17: FrameXmitErrStatus */
8278 - /* Bit 3 is Status Bit 18 WriteDataLengthGTDataLengthErr */
8279 + /* Bit 3 is Status Bit 18 WriteDataLenghtGTDataLengthErr */
8280
8281 #define PL_LOGINFO_SUB_CODE_TX_FM_CONNECTED_LOW (0x00000500)
8282 #define PL_LOGINFO_SUB_CODE_SATA_NON_NCQ_RW_ERR_BIT_SET (0x00000600)
8283 @@ -177,6 +179,10 @@
8284 #define PL_LOGINFO_SUB_CODE_DISCOVERY_REMOTE_SEP_RESET (0x00000E01)
8285 #define PL_LOGINFO_SUB_CODE_SECOND_OPEN (0x00000F00)
8286 #define PL_LOGINFO_SUB_CODE_DSCVRY_SATA_INIT_TIMEOUT (0x00001000)
8287 +#define PL_LOGINFO_SUB_CODE_BREAK_ON_SATA_CONNECTION (0x00002000) /* not currently used in mainline */
8288 +#define PL_LOGINFO_SUB_CODE_BREAK_ON_STUCK_LINK (0x00003000)
8289 +#define PL_LOGINFO_SUB_CODE_BREAK_ON_STUCK_LINK_AIP (0x00004000)
8290 +#define PL_LOGINFO_SUB_CODE_BREAK_ON_INCOMPLETE_BREAK_RCVD (0x00005000)
8291
8292 #define PL_LOGINFO_CODE_ENCL_MGMT_SMP_FRAME_FAILURE (0x00200000) /* Can't get SMP Frame */
8293 #define PL_LOGINFO_CODE_ENCL_MGMT_SMP_READ_ERROR (0x00200010) /* Error occured on SMP Read */
8294 @@ -243,6 +249,8 @@
8295 #define IR_LOGINFO_VOLUME_ACTIVATE_VOLUME_FAILED (0x00010014)
8296 /* Activation failed trying to import the volume */
8297 #define IR_LOGINFO_VOLUME_ACTIVATING_IMPORT_VOLUME_FAILED (0x00010015)
8298 +/* Activation failed trying to import the volume */
8299 +#define IR_LOGINFO_VOLUME_ACTIVATING_TOO_MANY_PHYS_DISKS (0x00010016)
8300
8301 /* Phys Disk failed, too many phys disks */
8302 #define IR_LOGINFO_PHYSDISK_CREATE_TOO_MANY_DISKS (0x00010020)
8303 @@ -285,6 +293,23 @@
8304 /* Compatibility Error : IME size limited to < 2TB */
8305 #define IR_LOGINFO_COMPAT_ERROR_IME_VOL_NOT_CURRENTLY_SUPPORTED (0x0001003D)
8306
8307 +/* Device Firmware Update: DFU can only be started once */
8308 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_DFU_IN_PROGRESS (0x00010050)
8309 +/* Device Firmware Update: Volume must be Optimal/Active/non-Quiesced */
8310 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_DEVICE_IN_INVALID_STATE (0x00010051)
8311 +/* Device Firmware Update: DFU Timeout cannot be zero */
8312 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_INVALID_TIMEOUT (0x00010052)
8313 +/* Device Firmware Update: CREATE TIMER FAILED */
8314 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_NO_TIMERS (0x00010053)
8315 +/* Device Firmware Update: Failed to read SAS_IO_UNIT_PG_1 */
8316 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_READING_CFG_PAGE (0x00010054)
8317 +/* Device Firmware Update: Invalid SAS_IO_UNIT_PG_1 value(s) */
8318 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_PORT_IO_TIMEOUTS_REQUIRED (0x00010055)
8319 +/* Device Firmware Update: Unable to allocate memory for page */
8320 +#define IR_LOGINFO_DEV_FW_UPDATE_ERR_ALLOC_CFG_PAGE (0x00010056)
8321 +/* Device Firmware Update: */
8322 +//#define IR_LOGINFO_DEV_FW_UPDATE_ERR_ (0x00010054)
8323 +
8324
8325 /****************************************************************************/
8326 /* Defines for convenience */
8327 --- a/drivers/message/fusion/lsi/mpi_raid.h
8328 +++ b/drivers/message/fusion/lsi/mpi_raid.h
8329 @@ -1,12 +1,12 @@
8330 /*
8331 - * Copyright (c) 2001-2007 LSI Corporation.
8332 + * Copyright (c) 2001-2008 LSI Corporation.
8333 *
8334 *
8335 * Name: mpi_raid.h
8336 * Title: MPI RAID message and structures
8337 * Creation Date: February 27, 2001
8338 *
8339 - * mpi_raid.h Version: 01.05.03
8340 + * mpi_raid.h Version: 01.05.05
8341 *
8342 * Version History
8343 * ---------------
8344 @@ -34,6 +34,9 @@
8345 * _SET_RESYNC_RATE and _SET_DATA_SCRUB_RATE.
8346 * 02-28-07 01.05.03 Added new RAID Action, Device FW Update Mode, and
8347 * associated defines.
8348 + * 08-07-07 01.05.04 Added Disable Full Rebuild bit to the ActionDataWord
8349 + * for the RAID Action MPI_RAID_ACTION_DISABLE_VOLUME.
8350 + * 01-15-08 01.05.05 Added define for MPI_RAID_ACTION_SET_VOLUME_NAME.
8351 * --------------------------------------------------------------------------
8352 */
8353
8354 @@ -93,6 +96,7 @@ typedef struct _MSG_RAID_ACTION
8355 #define MPI_RAID_ACTION_SET_RESYNC_RATE (0x13)
8356 #define MPI_RAID_ACTION_SET_DATA_SCRUB_RATE (0x14)
8357 #define MPI_RAID_ACTION_DEVICE_FW_UPDATE_MODE (0x15)
8358 +#define MPI_RAID_ACTION_SET_VOLUME_NAME (0x16)
8359
8360 /* ActionDataWord defines for use with MPI_RAID_ACTION_CREATE_VOLUME action */
8361 #define MPI_RAID_ACTION_ADATA_DO_NOT_SYNC (0x00000001)
8362 @@ -105,6 +109,9 @@ typedef struct _MSG_RAID_ACTION
8363 #define MPI_RAID_ACTION_ADATA_KEEP_LBA0 (0x00000000)
8364 #define MPI_RAID_ACTION_ADATA_ZERO_LBA0 (0x00000002)
8365
8366 +/* ActionDataWord defines for use with MPI_RAID_ACTION_DISABLE_VOLUME action */
8367 +#define MPI_RAID_ACTION_ADATA_DISABLE_FULL_REBUILD (0x00000001)
8368 +
8369 /* ActionDataWord defines for use with MPI_RAID_ACTION_ACTIVATE_VOLUME action */
8370 #define MPI_RAID_ACTION_ADATA_INACTIVATE_ALL (0x00000001)
8371
8372 --- a/drivers/message/fusion/lsi/mpi_sas.h
8373 +++ b/drivers/message/fusion/lsi/mpi_sas.h
8374 @@ -1,12 +1,12 @@
8375 /*
8376 - * Copyright (c) 2004-2006 LSI Corporation.
8377 + * Copyright (c) 2004-2008 LSI Corporation.
8378 *
8379 *
8380 * Name: mpi_sas.h
8381 * Title: MPI Serial Attached SCSI structures and definitions
8382 * Creation Date: August 19, 2004
8383 *
8384 - * mpi_sas.h Version: 01.05.04
8385 + * mpi_sas.h Version: 01.05.05
8386 *
8387 * Version History
8388 * ---------------
8389 @@ -23,6 +23,10 @@
8390 * reply.
8391 * 10-11-06 01.05.04 Fixed the name of a define for Operation field of SAS IO
8392 * Unit Control request.
8393 + * 01-15-08 01.05.05 Added support for MPI_SAS_OP_SET_IOC_PARAMETER,
8394 + * including adding IOCParameter and IOCParameter value
8395 + * fields to SAS IO Unit Control Request.
8396 + * Added MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC define.
8397 * --------------------------------------------------------------------------
8398 */
8399
8400 @@ -60,6 +64,8 @@
8401 * Values for the SAS DeviceInfo field used in SAS Device Status Change Event
8402 * data and SAS IO Unit Configuration pages.
8403 */
8404 +#define MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC (0xF0000000)
8405 +
8406 #define MPI_SAS_DEVICE_INFO_SEP (0x00004000)
8407 #define MPI_SAS_DEVICE_INFO_ATAPI_DEVICE (0x00002000)
8408 #define MPI_SAS_DEVICE_INFO_LSI_DEVICE (0x00001000)
8409 @@ -216,7 +222,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
8410 U8 ChainOffset; /* 02h */
8411 U8 Function; /* 03h */
8412 U16 DevHandle; /* 04h */
8413 - U8 Reserved3; /* 06h */
8414 + U8 IOCParameter; /* 06h */
8415 U8 MsgFlags; /* 07h */
8416 U32 MsgContext; /* 08h */
8417 U8 TargetID; /* 0Ch */
8418 @@ -225,7 +231,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
8419 U8 PrimFlags; /* 0Fh */
8420 U32 Primitive; /* 10h */
8421 U64 SASAddress; /* 14h */
8422 - U32 Reserved4; /* 1Ch */
8423 + U32 IOCParameterValue; /* 1Ch */
8424 } MSG_SAS_IOUNIT_CONTROL_REQUEST, MPI_POINTER PTR_MSG_SAS_IOUNIT_CONTROL_REQUEST,
8425 SasIoUnitControlRequest_t, MPI_POINTER pSasIoUnitControlRequest_t;
8426
8427 @@ -241,6 +247,8 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
8428 #define MPI_SAS_OP_TRANSMIT_PORT_SELECT_SIGNAL (0x0C)
8429 #define MPI_SAS_OP_TRANSMIT_REMOVE_DEVICE (0x0D) /* obsolete name */
8430 #define MPI_SAS_OP_REMOVE_DEVICE (0x0D)
8431 +#define MPI_SAS_OP_SET_IOC_PARAMETER (0x0E)
8432 +#define MPI_SAS_OP_PRODUCT_SPECIFIC_MIN (0x80)
8433
8434 /* values for the PrimFlags field */
8435 #define MPI_SAS_PRIMFLAGS_SINGLE (0x08)
8436 @@ -256,7 +264,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_R
8437 U8 MsgLength; /* 02h */
8438 U8 Function; /* 03h */
8439 U16 DevHandle; /* 04h */
8440 - U8 Reserved3; /* 06h */
8441 + U8 IOCParameter; /* 06h */
8442 U8 MsgFlags; /* 07h */
8443 U32 MsgContext; /* 08h */
8444 U16 Reserved4; /* 0Ch */
8445 --- a/drivers/message/fusion/lsi/mpi_targ.h
8446 +++ b/drivers/message/fusion/lsi/mpi_targ.h
8447 @@ -1,5 +1,5 @@
8448 /*
8449 - * Copyright (c) 2000-2004 LSI Corporation.
8450 + * Copyright (c) 2000-2008 LSI Corporation.
8451 *
8452 *
8453 * Name: mpi_targ.h
8454 --- a/drivers/message/fusion/lsi/mpi_tool.h
8455 +++ b/drivers/message/fusion/lsi/mpi_tool.h
8456 @@ -1,5 +1,5 @@
8457 /*
8458 - * Copyright (c) 2001-2005 LSI Corporation.
8459 + * Copyright (c) 2001-2008 LSI Corporation.
8460 *
8461 *
8462 * Name: mpi_tool.h
8463 --- a/drivers/message/fusion/lsi/mpi_type.h
8464 +++ b/drivers/message/fusion/lsi/mpi_type.h
8465 @@ -1,12 +1,12 @@
8466 /*
8467 - * Copyright (c) 2000-2004 LSI Corporation.
8468 + * Copyright (c) 2000-2008 LSI Corporation.
8469 *
8470 *
8471 * Name: mpi_type.h
8472 * Title: MPI Basic type definitions
8473 * Creation Date: June 6, 2000
8474 *
8475 - * mpi_type.h Version: 01.05.01
8476 + * mpi_type.h Version: 01.05.02
8477 *
8478 * Version History
8479 * ---------------
8480 @@ -20,6 +20,7 @@
8481 * 08-08-01 01.02.01 Original release for v1.2 work.
8482 * 05-11-04 01.03.01 Original release for MPI v1.3.
8483 * 08-19-04 01.05.01 Original release for MPI v1.5.
8484 + * 08-30-05 01.05.02 Added PowerPC option to #ifdef's.
8485 * --------------------------------------------------------------------------
8486 */
8487
8488 @@ -49,8 +50,18 @@ typedef signed short S16;
8489 typedef unsigned short U16;
8490
8491
8492 -typedef int32_t S32;
8493 -typedef u_int32_t U32;
8494 +#if defined(unix) || defined(__arm) || defined(ALPHA) || defined(__PPC__) || defined(__ppc)
8495 +
8496 + typedef signed int S32;
8497 + typedef unsigned int U32;
8498 +
8499 +#else
8500 +
8501 + typedef signed long S32;
8502 + typedef unsigned long U32;
8503 +
8504 +#endif
8505 +
8506
8507 typedef struct _S64
8508 {
8509 --- a/drivers/message/fusion/Makefile
8510 +++ b/drivers/message/fusion/Makefile
8511 @@ -1,12 +1,17 @@
8512 -# Fusion MPT drivers; recognized debug defines...
8513 +#
8514 +# LSI mpt fusion
8515 +#
8516 +
8517 +# csmi ioctls enable
8518 +EXTRA_CFLAGS += -DCPQ_CIM
8519 +EXTRA_CFLAGS += -DDIAG_BUFFER_SUPPORT
8520 +
8521 +EXTRA_CFLAGS += -DCONFIG_FUSION_LOGGING
8522
8523 # enable verbose logging
8524 # CONFIG_FUSION_LOGGING needs to be enabled in Kconfig
8525 #EXTRA_CFLAGS += -DMPT_DEBUG_VERBOSE
8526
8527 -
8528 -#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-} LSI_LOGIC
8529 -
8530 obj-$(CONFIG_FUSION_SPI) += mptbase.o mptscsih.o mptspi.o
8531 obj-$(CONFIG_FUSION_FC) += mptbase.o mptscsih.o mptfc.o
8532 obj-$(CONFIG_FUSION_SAS) += mptbase.o mptscsih.o mptsas.o
8533 --- a/drivers/message/fusion/mptbase.c
8534 +++ b/drivers/message/fusion/mptbase.c
8535 @@ -58,6 +58,7 @@
8536 #include <linux/delay.h>
8537 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
8538 #include <linux/dma-mapping.h>
8539 +#include <linux/sort.h>
8540 #include <asm/io.h>
8541 #ifdef CONFIG_MTRR
8542 #include <asm/mtrr.h>
8543 @@ -79,19 +80,38 @@ MODULE_VERSION(my_VERSION);
8544 /*
8545 * cmd line parameters
8546 */
8547 -static int mpt_msi_enable = -1;
8548 -module_param(mpt_msi_enable, int, 0);
8549 -MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
8550 +
8551 +static int mpt_msi_enable_spi;
8552 +module_param(mpt_msi_enable_spi, int, 0);
8553 +MODULE_PARM_DESC(mpt_msi_enable_spi, " Enable MSI Support for SPI controllers (default=0)");
8554 +
8555 +static int mpt_msi_enable_fc;
8556 +module_param(mpt_msi_enable_fc, int, 0);
8557 +MODULE_PARM_DESC(mpt_msi_enable_fc, " Enable MSI Support for FC controllers (default=0)");
8558 +
8559 +static int mpt_msi_enable_sas = 1;
8560 +module_param(mpt_msi_enable_sas, int, 0);
8561 +MODULE_PARM_DESC(mpt_msi_enable_sas, " Enable MSI Support for SAS controllers (default=1)");
8562 +
8563
8564 static int mpt_channel_mapping;
8565 module_param(mpt_channel_mapping, int, 0);
8566 MODULE_PARM_DESC(mpt_channel_mapping, " Mapping id's to channels (default=0)");
8567
8568 -static int mpt_debug_level;
8569 +int mpt_debug_level;
8570 static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
8571 module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
8572 &mpt_debug_level, 0600);
8573 MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h - (default=0)");
8574 +EXPORT_SYMBOL(mpt_debug_level);
8575 +
8576 +int mpt_fwfault_debug;
8577 +module_param_call(mpt_fwfault_debug, param_set_int, param_get_int,
8578 + &mpt_fwfault_debug, 0600);
8579 +MODULE_PARM_DESC(mpt_fwfault_debug, "Enable detection of Firmware fault"
8580 + " and halt Firmware on fault - (default=0)");
8581 +EXPORT_SYMBOL(mpt_fwfault_debug);
8582 +
8583
8584 #ifdef MFCNT
8585 static int mfcounter = 0;
8586 @@ -102,8 +122,7 @@ static int mfcounter = 0;
8587 /*
8588 * Public data...
8589 */
8590 -
8591 -static struct proc_dir_entry *mpt_proc_root_dir;
8592 +struct proc_dir_entry *mpt_proc_root_dir;
8593
8594 #define WHOINIT_UNKNOWN 0xAA
8595
8596 @@ -125,6 +144,8 @@ static struct mpt_pci_driver *MptDevice
8597
8598 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
8599
8600 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
8601 +
8602 /*
8603 * Driver Callback Index's
8604 */
8605 @@ -135,8 +156,7 @@ static u8 last_drv_idx;
8606 /*
8607 * Forward protos...
8608 */
8609 -static irqreturn_t mpt_interrupt(int irq, void *bus_id);
8610 -static int mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
8611 +static int mptbase_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
8612 static int mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
8613 u32 *req, int replyBytes, u16 *u16reply, int maxwait,
8614 int sleepFlag);
8615 @@ -167,9 +187,8 @@ static int mpt_GetScsiPortSettings(MPT_A
8616 static int mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
8617 static void mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
8618 static void mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
8619 -static void mpt_timer_expired(unsigned long data);
8620 static void mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
8621 -static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
8622 +static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch, int sleepFlag);
8623 static int SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
8624 static int mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
8625 static int mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
8626 @@ -184,7 +203,6 @@ static int procmpt_iocinfo_read(char *bu
8627 #endif
8628 static void mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
8629
8630 -//int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
8631 static int ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
8632 static void mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
8633 static void mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
8634 @@ -193,6 +211,7 @@ static void mpt_sas_log_info(MPT_ADAPTER
8635 static int mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
8636 static void mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
8637
8638 +
8639 /* module entry point */
8640 static int __init fusion_init (void);
8641 static void __exit fusion_exit (void);
8642 @@ -223,7 +242,16 @@ pci_enable_io_access(struct pci_dev *pde
8643 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
8644 }
8645
8646 -static int mpt_set_debug_level(const char *val, struct kernel_param *kp)
8647 +/**
8648 + * mpt_set_debug_level - global setting of the mpt_debug_level
8649 + * found via /sys/module/mptbase/parameters/mpt_debug_level
8650 + * @val:
8651 + * @kp:
8652 + *
8653 + * Returns
8654 + **/
8655 +static int
8656 +mpt_set_debug_level(const char *val, struct kernel_param *kp)
8657 {
8658 int ret = param_set_int(val, kp);
8659 MPT_ADAPTER *ioc;
8660 @@ -254,6 +282,56 @@ mpt_get_cb_idx(MPT_DRIVER_CLASS dclass)
8661 }
8662
8663 /**
8664 + * mpt_is_discovery_complete - determine if discovery has completed
8665 + * @ioc: per adatper instance
8666 + *
8667 + * Returns 1 when discovery completed, else zero.
8668 + */
8669 +static int
8670 +mpt_is_discovery_complete(MPT_ADAPTER *ioc)
8671 +{
8672 + ConfigExtendedPageHeader_t hdr;
8673 + CONFIGPARMS cfg;
8674 + SasIOUnitPage0_t *buffer;
8675 + dma_addr_t dma_handle;
8676 + int rc = 0;
8677 +
8678 + memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t));
8679 + memset(&cfg, 0, sizeof(CONFIGPARMS));
8680 + hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION;
8681 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
8682 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
8683 + cfg.cfghdr.ehdr = &hdr;
8684 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
8685 +
8686 + if ((mpt_config(ioc, &cfg)))
8687 + goto out;
8688 + if (!hdr.ExtPageLength)
8689 + goto out;
8690 +
8691 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
8692 + &dma_handle);
8693 + if (!buffer)
8694 + goto out;
8695 +
8696 + cfg.physAddr = dma_handle;
8697 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
8698 +
8699 + if ((mpt_config(ioc, &cfg)))
8700 + goto out_free_consistent;
8701 +
8702 + if (!(buffer->PhyData[0].PortFlags &
8703 + MPI_SAS_IOUNIT0_PORT_FLAGS_DISCOVERY_IN_PROGRESS))
8704 + rc = 1;
8705 +
8706 + out_free_consistent:
8707 + pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
8708 + buffer, dma_handle);
8709 + out:
8710 + return rc;
8711 +}
8712 +
8713 +/**
8714 * mpt_fault_reset_work - work performed on workq after ioc fault
8715 * @work: input argument, used to derive ioc
8716 *
8717 @@ -267,23 +345,29 @@ mpt_fault_reset_work(struct work_struct
8718 int rc;
8719 unsigned long flags;
8720
8721 - if (ioc->diagPending || !ioc->active)
8722 + if (ioc->ioc_reset_in_progress || !ioc->active)
8723 goto out;
8724
8725 ioc_raw_state = mpt_GetIocState(ioc, 0);
8726 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
8727 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state (%04xh)!!!\n",
8728 - ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
8729 + ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
8730 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
8731 - ioc->name, __func__);
8732 + ioc->name, __FUNCTION__);
8733 rc = mpt_HardResetHandler(ioc, CAN_SLEEP);
8734 printk(MYIOC_s_WARN_FMT "%s: HardReset: %s\n", ioc->name,
8735 - __func__, (rc == 0) ? "success" : "failed");
8736 + __FUNCTION__, (rc == 0) ? "success" : "failed");
8737 ioc_raw_state = mpt_GetIocState(ioc, 0);
8738 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT)
8739 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state after "
8740 "reset (%04xh)\n", ioc->name, ioc_raw_state &
8741 MPI_DOORBELL_DATA_MASK);
8742 + } else if (ioc->bus_type == SAS && ioc->sas_discovery_quiesce_io) {
8743 + if ((mpt_is_discovery_complete(ioc))) {
8744 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "clearing "
8745 + "discovery_quiesce_io flag\n", ioc->name));
8746 + ioc->sas_discovery_quiesce_io = 0;
8747 + }
8748 }
8749
8750 out:
8751 @@ -294,14 +378,13 @@ mpt_fault_reset_work(struct work_struct
8752 ioc = ioc->alt_ioc;
8753
8754 /* rearm the timer */
8755 - spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
8756 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
8757 if (ioc->reset_work_q)
8758 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
8759 msecs_to_jiffies(MPT_POLLING_INTERVAL));
8760 - spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
8761 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
8762 }
8763
8764 -
8765 /*
8766 * Process turbo (context) reply...
8767 */
8768 @@ -354,9 +437,9 @@ mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa
8769
8770 /* Check for (valid) IO callback! */
8771 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
8772 - MptCallbacks[cb_idx] == NULL) {
8773 + MptCallbacks[cb_idx] == NULL) {
8774 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
8775 - __func__, ioc->name, cb_idx);
8776 + __FUNCTION__, ioc->name, cb_idx);
8777 goto out;
8778 }
8779
8780 @@ -398,6 +481,7 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
8781
8782 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
8783 ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
8784 +
8785 DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mr);
8786
8787 /* Check/log IOC log info
8788 @@ -413,14 +497,17 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
8789 mpt_sas_log_info(ioc, log_info);
8790 }
8791
8792 + /* TODO - add shost_attrs, or command line option, and
8793 + * extend this to SAS/FC
8794 + */
8795 if (ioc_stat & MPI_IOCSTATUS_MASK)
8796 mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
8797
8798 /* Check for (valid) IO callback! */
8799 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
8800 - MptCallbacks[cb_idx] == NULL) {
8801 + MptCallbacks[cb_idx] == NULL) {
8802 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
8803 - __func__, ioc->name, cb_idx);
8804 + __FUNCTION__, ioc->name, cb_idx);
8805 freeme = 0;
8806 goto out;
8807 }
8808 @@ -436,11 +523,11 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
8809 mb();
8810 }
8811
8812 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
8813 /**
8814 * mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
8815 * @irq: irq number (not used)
8816 * @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
8817 + * @r: pt_regs pointer (not used)
8818 *
8819 * This routine is registered via the request_irq() kernel API call,
8820 * and handles all interrupts generated from a specific MPT adapter
8821 @@ -452,7 +539,7 @@ mpt_reply(MPT_ADAPTER *ioc, u32 pa)
8822 * This routine handles register-level access of the adapter but
8823 * dispatches (calls) a protocol-specific callback routine to handle
8824 * the protocol-specific details of the MPT request completion.
8825 - */
8826 + **/
8827 static irqreturn_t
8828 mpt_interrupt(int irq, void *bus_id)
8829 {
8830 @@ -478,9 +565,9 @@ mpt_interrupt(int irq, void *bus_id)
8831
8832 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
8833 /**
8834 - * mpt_base_reply - MPT base driver's callback routine
8835 + * mptbase_reply - MPT base driver's callback routine
8836 * @ioc: Pointer to MPT_ADAPTER structure
8837 - * @mf: Pointer to original MPT request frame
8838 + * @req: Pointer to original MPT request frame
8839 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
8840 *
8841 * MPT base driver's callback routine; all base driver
8842 @@ -491,122 +578,49 @@ mpt_interrupt(int irq, void *bus_id)
8843 * should be freed, or 0 if it shouldn't.
8844 */
8845 static int
8846 -mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
8847 +mptbase_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
8848 {
8849 + EventNotificationReply_t *pEventReply;
8850 + u8 event;
8851 + int evHandlers;
8852 int freereq = 1;
8853 - u8 func;
8854 -
8855 - dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply() called\n", ioc->name));
8856 -#ifdef CONFIG_FUSION_LOGGING
8857 - if ((ioc->debug_level & MPT_DEBUG_MSG_FRAME) &&
8858 - !(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
8859 - dmfprintk(ioc, printk(MYIOC_s_INFO_FMT ": Original request frame (@%p) header\n",
8860 - ioc->name, mf));
8861 - DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)mf);
8862 - }
8863 -#endif
8864 -
8865 - func = reply->u.hdr.Function;
8866 - dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, Function=%02Xh\n",
8867 - ioc->name, func));
8868 -
8869 - if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
8870 - EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
8871 - int evHandlers = 0;
8872 - int results;
8873 -
8874 - results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
8875 - if (results != evHandlers) {
8876 - /* CHECKME! Any special handling needed here? */
8877 - devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
8878 - ioc->name, evHandlers, results));
8879 - }
8880
8881 - /*
8882 - * Hmmm... It seems that EventNotificationReply is an exception
8883 - * to the rule of one reply per request.
8884 - */
8885 - if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
8886 + switch (reply->u.hdr.Function) {
8887 + case MPI_FUNCTION_EVENT_NOTIFICATION:
8888 + pEventReply = (EventNotificationReply_t *)reply;
8889 + evHandlers = 0;
8890 + ProcessEventNotification(ioc, pEventReply, &evHandlers);
8891 + event = le32_to_cpu(pEventReply->Event) & 0xFF;
8892 + if (pEventReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)
8893 freereq = 0;
8894 - } else {
8895 - devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
8896 - ioc->name, pEvReply));
8897 - }
8898 -
8899 -#ifdef CONFIG_PROC_FS
8900 -// LogEvent(ioc, pEvReply);
8901 -#endif
8902 -
8903 - } else if (func == MPI_FUNCTION_EVENT_ACK) {
8904 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, EventAck reply received\n",
8905 - ioc->name));
8906 - } else if (func == MPI_FUNCTION_CONFIG) {
8907 - CONFIGPARMS *pCfg;
8908 - unsigned long flags;
8909 -
8910 - dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "config_complete (mf=%p,mr=%p)\n",
8911 - ioc->name, mf, reply));
8912 -
8913 - pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
8914 -
8915 - if (pCfg) {
8916 - /* disable timer and remove from linked list */
8917 - del_timer(&pCfg->timer);
8918 -
8919 - spin_lock_irqsave(&ioc->FreeQlock, flags);
8920 - list_del(&pCfg->linkage);
8921 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
8922 -
8923 - /*
8924 - * If IOC Status is SUCCESS, save the header
8925 - * and set the status code to GOOD.
8926 - */
8927 - pCfg->status = MPT_CONFIG_ERROR;
8928 - if (reply) {
8929 - ConfigReply_t *pReply = (ConfigReply_t *)reply;
8930 - u16 status;
8931 -
8932 - status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
8933 - dcprintk(ioc, printk(MYIOC_s_NOTE_FMT " IOCStatus=%04xh, IOCLogInfo=%08xh\n",
8934 - ioc->name, status, le32_to_cpu(pReply->IOCLogInfo)));
8935 -
8936 - pCfg->status = status;
8937 - if (status == MPI_IOCSTATUS_SUCCESS) {
8938 - if ((pReply->Header.PageType &
8939 - MPI_CONFIG_PAGETYPE_MASK) ==
8940 - MPI_CONFIG_PAGETYPE_EXTENDED) {
8941 - pCfg->cfghdr.ehdr->ExtPageLength =
8942 - le16_to_cpu(pReply->ExtPageLength);
8943 - pCfg->cfghdr.ehdr->ExtPageType =
8944 - pReply->ExtPageType;
8945 - }
8946 - pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
8947 -
8948 - /* If this is a regular header, save PageLength. */
8949 - /* LMP Do this better so not using a reserved field! */
8950 - pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
8951 - pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
8952 - pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
8953 - }
8954 - }
8955 -
8956 - /*
8957 - * Wake up the original calling thread
8958 - */
8959 - pCfg->wait_done = 1;
8960 - wake_up(&mpt_waitq);
8961 - }
8962 - } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
8963 - /* we should be always getting a reply frame */
8964 - memcpy(ioc->persist_reply_frame, reply,
8965 - min(MPT_DEFAULT_FRAME_SIZE,
8966 - 4*reply->u.reply.MsgLength));
8967 - del_timer(&ioc->persist_timer);
8968 - ioc->persist_wait_done = 1;
8969 - wake_up(&mpt_waitq);
8970 - } else {
8971 - printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
8972 - ioc->name, func);
8973 + if (event != MPI_EVENT_EVENT_CHANGE)
8974 + break;
8975 + case MPI_FUNCTION_CONFIG:
8976 + case MPI_FUNCTION_SAS_IO_UNIT_CONTROL:
8977 + ioc->mptbase_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
8978 + if (reply) {
8979 + ioc->mptbase_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
8980 + memcpy(ioc->mptbase_cmds.reply, reply,
8981 + min(MPT_DEFAULT_FRAME_SIZE,
8982 + 4 * reply->u.reply.MsgLength));
8983 + }
8984 + if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_PENDING) {
8985 + ioc->mptbase_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
8986 + complete(&ioc->mptbase_cmds.done);
8987 + } else
8988 + freereq = 0;
8989 + if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_FREE_MF)
8990 + freereq = 1;
8991 + break;
8992 + case MPI_FUNCTION_EVENT_ACK:
8993 + devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
8994 + "EventAck reply received\n", ioc->name));
8995 + break;
8996 + default:
8997 + printk(MYIOC_s_ERR_FMT
8998 + "Unexpected msg function (=%02Xh) reply received!\n",
8999 + ioc->name, reply->u.hdr.Function);
9000 + break;
9001 }
9002
9003 /*
9004 @@ -616,7 +630,6 @@ mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRA
9005 return freereq;
9006 }
9007
9008 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9009 /**
9010 * mpt_register - Register protocol-specific main callback handler.
9011 * @cbfunc: callback function pointer
9012 @@ -635,7 +648,7 @@ mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRA
9013 * {N,...,7,6,5,...,1} if successful.
9014 * A return value of MPT_MAX_PROTOCOL_DRIVERS (including zero!) should be
9015 * considered an error by the caller.
9016 - */
9017 + **/
9018 u8
9019 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
9020 {
9021 @@ -659,14 +672,13 @@ mpt_register(MPT_CALLBACK cbfunc, MPT_DR
9022 return last_drv_idx;
9023 }
9024
9025 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9026 /**
9027 * mpt_deregister - Deregister a protocol drivers resources.
9028 * @cb_idx: previously registered callback handle
9029 *
9030 * Each protocol-specific driver should call this routine when its
9031 * module is unloaded.
9032 - */
9033 + **/
9034 void
9035 mpt_deregister(u8 cb_idx)
9036 {
9037 @@ -679,9 +691,9 @@ mpt_deregister(u8 cb_idx)
9038 }
9039 }
9040
9041 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9042 /**
9043 - * mpt_event_register - Register protocol-specific event callback handler.
9044 + * mpt_event_register - Register protocol-specific event callback
9045 + * handler.
9046 * @cb_idx: previously registered (via mpt_register) callback handle
9047 * @ev_cbfunc: callback function
9048 *
9049 @@ -689,7 +701,7 @@ mpt_deregister(u8 cb_idx)
9050 * if/when they choose to be notified of MPT events.
9051 *
9052 * Returns 0 for success.
9053 - */
9054 + **/
9055 int
9056 mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
9057 {
9058 @@ -700,15 +712,15 @@ mpt_event_register(u8 cb_idx, MPT_EVHAND
9059 return 0;
9060 }
9061
9062 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9063 /**
9064 - * mpt_event_deregister - Deregister protocol-specific event callback handler
9065 + * mpt_event_deregister - Deregister protocol-specific event callback
9066 + * handler.
9067 * @cb_idx: previously registered callback handle
9068 *
9069 * Each protocol-specific driver should call this routine
9070 * when it does not (or can no longer) handle events,
9071 * or when its module is unloaded.
9072 - */
9073 + **/
9074 void
9075 mpt_event_deregister(u8 cb_idx)
9076 {
9077 @@ -718,7 +730,6 @@ mpt_event_deregister(u8 cb_idx)
9078 MptEvHandlers[cb_idx] = NULL;
9079 }
9080
9081 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9082 /**
9083 * mpt_reset_register - Register protocol-specific IOC reset handler.
9084 * @cb_idx: previously registered (via mpt_register) callback handle
9085 @@ -728,7 +739,7 @@ mpt_event_deregister(u8 cb_idx)
9086 * if/when they choose to be notified of IOC resets.
9087 *
9088 * Returns 0 for success.
9089 - */
9090 + **/
9091 int
9092 mpt_reset_register(u8 cb_idx, MPT_RESETHANDLER reset_func)
9093 {
9094 @@ -739,7 +750,6 @@ mpt_reset_register(u8 cb_idx, MPT_RESETH
9095 return 0;
9096 }
9097
9098 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9099 /**
9100 * mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
9101 * @cb_idx: previously registered callback handle
9102 @@ -747,7 +757,7 @@ mpt_reset_register(u8 cb_idx, MPT_RESETH
9103 * Each protocol-specific driver should call this routine
9104 * when it does not (or can no longer) handle IOC reset handling,
9105 * or when its module is unloaded.
9106 - */
9107 + **/
9108 void
9109 mpt_reset_deregister(u8 cb_idx)
9110 {
9111 @@ -757,12 +767,11 @@ mpt_reset_deregister(u8 cb_idx)
9112 MptResetHandlers[cb_idx] = NULL;
9113 }
9114
9115 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9116 /**
9117 * mpt_device_driver_register - Register device driver hooks
9118 * @dd_cbfunc: driver callbacks struct
9119 * @cb_idx: MPT protocol driver index
9120 - */
9121 + **/
9122 int
9123 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, u8 cb_idx)
9124 {
9125 @@ -776,20 +785,21 @@ mpt_device_driver_register(struct mpt_pc
9126
9127 /* call per pci device probe entry point */
9128 list_for_each_entry(ioc, &ioc_list, list) {
9129 + if (!pci_get_drvdata(ioc->pcidev))
9130 + continue;
9131 id = ioc->pcidev->driver ?
9132 ioc->pcidev->driver->id_table : NULL;
9133 if (dd_cbfunc->probe)
9134 dd_cbfunc->probe(ioc->pcidev, id);
9135 - }
9136 + }
9137
9138 return 0;
9139 }
9140
9141 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9142 /**
9143 * mpt_device_driver_deregister - DeRegister device driver hooks
9144 * @cb_idx: MPT protocol driver index
9145 - */
9146 + **/
9147 void
9148 mpt_device_driver_deregister(u8 cb_idx)
9149 {
9150 @@ -809,19 +819,15 @@ mpt_device_driver_deregister(u8 cb_idx)
9151 MptDeviceDriverHandlers[cb_idx] = NULL;
9152 }
9153
9154 -
9155 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9156 /**
9157 - * mpt_get_msg_frame - Obtain an MPT request frame from the pool
9158 + * mpt_get_msg_frame - Obtain a MPT request frame from the pool (of 1024)
9159 + * allocated per MPT adapter.
9160 * @cb_idx: Handle of registered MPT protocol driver
9161 * @ioc: Pointer to MPT adapter structure
9162 *
9163 - * Obtain an MPT request frame from the pool (of 1024) that are
9164 - * allocated per MPT adapter.
9165 - *
9166 * Returns pointer to a MPT request frame or %NULL if none are available
9167 * or IOC is not active.
9168 - */
9169 + **/
9170 MPT_FRAME_HDR*
9171 mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
9172 {
9173 @@ -851,7 +857,6 @@ mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER
9174 mf->u.frame.linkage.arg1 = 0;
9175 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
9176 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
9177 - /* u16! */
9178 req_idx = req_offset / ioc->req_sz;
9179 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
9180 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
9181 @@ -881,16 +886,16 @@ mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER
9182 return mf;
9183 }
9184
9185 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9186 /**
9187 - * mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
9188 + * mpt_put_msg_frame - Send a protocol specific MPT request frame
9189 + * to a IOC.
9190 * @cb_idx: Handle of registered MPT protocol driver
9191 * @ioc: Pointer to MPT adapter structure
9192 * @mf: Pointer to MPT request frame
9193 *
9194 - * This routine posts an MPT request frame to the request post FIFO of a
9195 + * This routine posts a MPT request frame to the request post FIFO of a
9196 * specific MPT adapter.
9197 - */
9198 + **/
9199 void
9200 mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
9201 {
9202 @@ -901,14 +906,14 @@ mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER
9203 /* ensure values are reset properly! */
9204 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
9205 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
9206 - /* u16! */
9207 req_idx = req_offset / ioc->req_sz;
9208 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
9209 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
9210
9211 DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
9212
9213 - mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
9214 + mf_dma_addr = (ioc->req_frames_low_dma + req_offset) |
9215 + ioc->RequestNB[req_idx];
9216 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d "
9217 "RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx,
9218 ioc->RequestNB[req_idx]));
9219 @@ -916,15 +921,13 @@ mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER
9220 }
9221
9222 /**
9223 - * mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
9224 + * mpt_put_msg_frame_hi_pri - Send a protocol specific MPT request frame
9225 + * to a IOC using hi priority request queue.
9226 * @cb_idx: Handle of registered MPT protocol driver
9227 * @ioc: Pointer to MPT adapter structure
9228 * @mf: Pointer to MPT request frame
9229 *
9230 - * Send a protocol-specific MPT request frame to an IOC using
9231 - * hi-priority request queue.
9232 - *
9233 - * This routine posts an MPT request frame to the request post FIFO of a
9234 + * This routine posts a MPT request frame to the request post FIFO of a
9235 * specific MPT adapter.
9236 **/
9237 void
9238 @@ -949,7 +952,6 @@ mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_
9239 CHIPREG_WRITE32(&ioc->chip->RequestHiPriFifo, mf_dma_addr);
9240 }
9241
9242 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9243 /**
9244 * mpt_free_msg_frame - Place MPT request frame back on FreeQ.
9245 * @handle: Handle of registered MPT protocol driver
9246 @@ -958,7 +960,7 @@ mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_
9247 *
9248 * This routine places a MPT request frame back on the MPT adapter's
9249 * FreeQ.
9250 - */
9251 + **/
9252 void
9253 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
9254 {
9255 @@ -966,43 +968,144 @@ mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT
9256
9257 /* Put Request back on FreeQ! */
9258 spin_lock_irqsave(&ioc->FreeQlock, flags);
9259 - mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
9260 + if (cpu_to_le32(mf->u.frame.linkage.arg1) == 0xdeadbeaf)
9261 + goto out;
9262 + mf->u.frame.linkage.arg1 = cpu_to_le32(0xdeadbeaf); /* signature to know if this mf is freed */
9263 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
9264 #ifdef MFCNT
9265 ioc->mfcnt--;
9266 #endif
9267 + out:
9268 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
9269 }
9270
9271 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9272 /**
9273 - * mpt_add_sge - Place a simple SGE at address pAddr.
9274 + * mpt_add_sge - Place a simple 32 bit SGE at address pAddr.
9275 * @pAddr: virtual address for SGE
9276 * @flagslength: SGE flags and data transfer length
9277 * @dma_addr: Physical address
9278 *
9279 * This routine places a MPT request frame back on the MPT adapter's
9280 * FreeQ.
9281 - */
9282 -void
9283 + **/
9284 +static void
9285 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
9286 {
9287 - if (sizeof(dma_addr_t) == sizeof(u64)) {
9288 - SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
9289 - u32 tmp = dma_addr & 0xFFFFFFFF;
9290 + SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
9291 + pSge->FlagsLength = cpu_to_le32(flagslength);
9292 + pSge->Address = cpu_to_le32(dma_addr);
9293 +}
9294
9295 - pSge->FlagsLength = cpu_to_le32(flagslength);
9296 - pSge->Address.Low = cpu_to_le32(tmp);
9297 - tmp = (u32) ((u64)dma_addr >> 32);
9298 - pSge->Address.High = cpu_to_le32(tmp);
9299
9300 - } else {
9301 - SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
9302 - pSge->FlagsLength = cpu_to_le32(flagslength);
9303 - pSge->Address = cpu_to_le32(dma_addr);
9304 +/**
9305 + * mpt_add_sge_64bit - Place a simple 64 bit SGE at address pAddr.
9306 + * @pAddr: virtual address for SGE
9307 + * @flagslength: SGE flags and data transfer length
9308 + * @dma_addr: Physical address
9309 + *
9310 + * This routine places a MPT request frame back on the MPT adapter's
9311 + * FreeQ.
9312 + **/
9313 +static void
9314 +mpt_add_sge_64bit(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
9315 +{
9316 + SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
9317 + u32 tmp;
9318 +
9319 + tmp = dma_addr & 0xFFFFFFFF;
9320 + pSge->Address.Low = cpu_to_le32(tmp);
9321 + tmp = (u32) ((u64)dma_addr >> 32);
9322 + pSge->Address.High = cpu_to_le32(tmp);
9323 + pSge->FlagsLength = cpu_to_le32(
9324 + (flagslength | MPT_SGE_FLAGS_64_BIT_ADDRESSING));
9325 +}
9326 +
9327 +
9328 +/**
9329 + * mpt_add_sge_64bit_1078 - Place a simple 64 bit SGE at address pAddr
9330 + * (1078 workaround).
9331 + * @pAddr: virtual address for SGE
9332 + * @flagslength: SGE flags and data transfer length
9333 + * @dma_addr: Physical address
9334 + *
9335 + * This routine places a MPT request frame back on the MPT adapter's
9336 + * FreeQ.
9337 + **/
9338 +static void
9339 +mpt_add_sge_64bit_1078(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
9340 +{
9341 + SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
9342 + u32 tmp;
9343 +
9344 + tmp = dma_addr & 0xFFFFFFFF;
9345 + pSge->Address.Low = cpu_to_le32(tmp);
9346 + tmp = (u32) ((u64)dma_addr >> 32);
9347 +
9348 + /*
9349 + * 1078 errata workaround for the 36GB limitation
9350 + */
9351 + if ((((u64)dma_addr + MPI_SGE_LENGTH(flagslength)) >> 32) == 9) {
9352 + flagslength |=
9353 + MPI_SGE_SET_FLAGS(MPI_SGE_FLAGS_LOCAL_ADDRESS);
9354 + tmp |= (1<<31);
9355 + if (mpt_debug_level & MPT_DEBUG_36GB_MEM)
9356 + printk(KERN_DEBUG "1078 P0M2 addressing for "
9357 + "addr = 0x%llx len = %d\n",
9358 + (unsigned long long)dma_addr,
9359 + MPI_SGE_LENGTH(flagslength));
9360 }
9361 +
9362 + pSge->Address.High = cpu_to_le32(tmp);
9363 + pSge->FlagsLength = cpu_to_le32(
9364 + (flagslength | MPT_SGE_FLAGS_64_BIT_ADDRESSING));
9365 +}
9366 +
9367 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9368 +/**
9369 + * mpt_add_chain - Place a 32 bit chain SGE at address pAddr.
9370 + * @pAddr: virtual address for SGE
9371 + * @next: nextChainOffset value (u32's)
9372 + * @length: length of next SGL segment
9373 + * @dma_addr: Physical address
9374 + *
9375 + */
9376 +static void
9377 +mpt_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
9378 +{
9379 + SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
9380 + pChain->Length = cpu_to_le16(length);
9381 + pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT;
9382 + pChain->NextChainOffset = next;
9383 + pChain->Address = cpu_to_le32(dma_addr);
9384 +}
9385 +
9386 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9387 +/**
9388 + * mpt_add_chain_64bit - Place a 64 bit chain SGE at address pAddr.
9389 + * @pAddr: virtual address for SGE
9390 + * @next: nextChainOffset value (u32's)
9391 + * @length: length of next SGL segment
9392 + * @dma_addr: Physical address
9393 + *
9394 + */
9395 +static void
9396 +mpt_add_chain_64bit(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
9397 +{
9398 + SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
9399 + u32 tmp = dma_addr & 0xFFFFFFFF;
9400 +
9401 + pChain->Length = cpu_to_le16(length);
9402 + pChain->Flags = (MPI_SGE_FLAGS_CHAIN_ELEMENT |
9403 + MPI_SGE_FLAGS_64_BIT_ADDRESSING);
9404 +
9405 + pChain->NextChainOffset = next;
9406 +
9407 + pChain->Address.Low = cpu_to_le32(tmp);
9408 + tmp = (u32) ((u64)dma_addr >> 32);
9409 + pChain->Address.High = cpu_to_le32(tmp);
9410 }
9411
9412 +
9413 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9414 /**
9415 * mpt_send_handshake_request - Send MPT request via doorbell handshake method.
9416 @@ -1019,11 +1122,11 @@ mpt_add_sge(char *pAddr, u32 flagslength
9417 * request which are greater than 1 byte in size.
9418 *
9419 * Returns 0 for success, non-zero for failure.
9420 - */
9421 + **/
9422 int
9423 mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
9424 {
9425 - int r = 0;
9426 + int r = 0;
9427 u8 *req_as_bytes;
9428 int ii;
9429
9430 @@ -1038,7 +1141,7 @@ mpt_send_handshake_request(u8 cb_idx, MP
9431 * is in proper (pre-alloc'd) request buffer range...
9432 */
9433 ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
9434 - if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
9435 + if (ii >= 0 && ii < ioc->req_depth) {
9436 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
9437 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
9438 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
9439 @@ -1096,7 +1199,6 @@ mpt_send_handshake_request(u8 cb_idx, MP
9440 return r;
9441 }
9442
9443 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9444 /**
9445 * mpt_host_page_access_control - control the IOC's Host Page Buffer access
9446 * @ioc: Pointer to MPT adapter structure
9447 @@ -1113,8 +1215,7 @@ mpt_send_handshake_request(u8 cb_idx, MP
9448 * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
9449 *
9450 * Returns 0 for success, non-zero for failure.
9451 - */
9452 -
9453 + **/
9454 static int
9455 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
9456 {
9457 @@ -1139,7 +1240,6 @@ mpt_host_page_access_control(MPT_ADAPTER
9458 return 0;
9459 }
9460
9461 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9462 /**
9463 * mpt_host_page_alloc - allocate system memory for the fw
9464 * @ioc: Pointer to pointer to IOC adapter
9465 @@ -1147,7 +1247,7 @@ mpt_host_page_access_control(MPT_ADAPTER
9466 *
9467 * If we already allocated memory in past, then resend the same pointer.
9468 * Returns 0 for success, non-zero for failure.
9469 - */
9470 + **/
9471 static int
9472 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
9473 {
9474 @@ -1171,7 +1271,7 @@ mpt_host_page_alloc(MPT_ADAPTER *ioc, pI
9475 host_page_buffer_sz,
9476 &ioc->HostPageBuffer_dma)) != NULL) {
9477
9478 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
9479 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
9480 "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
9481 ioc->name, ioc->HostPageBuffer,
9482 (u32)ioc->HostPageBuffer_dma,
9483 @@ -1195,21 +1295,16 @@ mpt_host_page_alloc(MPT_ADAPTER *ioc, pI
9484 psge = (char *)&ioc_init->HostPageBufferSGE;
9485 flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
9486 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
9487 - MPI_SGE_FLAGS_32_BIT_ADDRESSING |
9488 MPI_SGE_FLAGS_HOST_TO_IOC |
9489 MPI_SGE_FLAGS_END_OF_BUFFER;
9490 - if (sizeof(dma_addr_t) == sizeof(u64)) {
9491 - flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
9492 - }
9493 flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
9494 flags_length |= ioc->HostPageBuffer_sz;
9495 - mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
9496 + ioc->add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
9497 ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
9498
9499 return 0;
9500 }
9501
9502 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9503 /**
9504 * mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
9505 * @iocid: IOC unique identifier (integer)
9506 @@ -1220,7 +1315,7 @@ return 0;
9507 *
9508 * Returns iocid and sets iocpp if iocid is found.
9509 * Returns -1 if iocid is not found.
9510 - */
9511 + **/
9512 int
9513 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
9514 {
9515 @@ -1493,7 +1588,6 @@ mpt_mapresources(MPT_ADAPTER *ioc)
9516 unsigned long port;
9517 u32 msize;
9518 u32 psize;
9519 - u8 revision;
9520 int r = -ENODEV;
9521 struct pci_dev *pdev;
9522
9523 @@ -1509,24 +1603,39 @@ mpt_mapresources(MPT_ADAPTER *ioc)
9524 "MEM failed\n", ioc->name);
9525 return r;
9526 }
9527 + if (sizeof(dma_addr_t) > 4) {
9528 + const uint64_t required_mask = dma_get_required_mask(&pdev->dev);
9529 + if (required_mask > DMA_32BIT_MASK
9530 + && !pci_set_dma_mask(pdev, DMA_64BIT_MASK)
9531 + && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
9532 + ioc->dma_mask = DMA_64BIT_MASK;
9533 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
9534 + ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
9535 + ioc->name));
9536 + } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
9537 + && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
9538 + ioc->dma_mask = DMA_32BIT_MASK;
9539 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
9540 + ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
9541 + ioc->name));
9542 + } else {
9543 + printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
9544 + ioc->name, pci_name(pdev));
9545 + return r;
9546 + }
9547
9548 - pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
9549 -
9550 - if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)
9551 - && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
9552 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
9553 - ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
9554 - ioc->name));
9555 - } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
9556 - && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
9557 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
9558 - ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
9559 - ioc->name));
9560 } else {
9561 - printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
9562 - ioc->name, pci_name(pdev));
9563 - pci_release_selected_regions(pdev, ioc->bars);
9564 - return r;
9565 + if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
9566 + && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
9567 + ioc->dma_mask = DMA_32BIT_MASK;
9568 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
9569 + ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
9570 + ioc->name));
9571 + } else {
9572 + printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
9573 + ioc->name, pci_name(pdev));
9574 + return r;
9575 + }
9576 }
9577
9578 mem_phys = msize = 0;
9579 @@ -1554,7 +1663,7 @@ mpt_mapresources(MPT_ADAPTER *ioc)
9580 mem = ioremap(mem_phys, msize);
9581 if (mem == NULL) {
9582 printk(MYIOC_s_ERR_FMT ": ERROR - Unable to map adapter"
9583 - " memory!\n", ioc->name);
9584 + "memory!\n", ioc->name);
9585 return -EINVAL;
9586 }
9587 ioc->memmap = mem;
9588 @@ -1565,13 +1674,15 @@ mpt_mapresources(MPT_ADAPTER *ioc)
9589 ioc->chip = (SYSIF_REGS __iomem *)mem;
9590
9591 /* Save Port IO values in case we need to do downloadboot */
9592 - ioc->pio_mem_phys = port;
9593 - ioc->pio_chip = (SYSIF_REGS __iomem *)port;
9594 + {
9595 + u8 *pmem = (u8*)port;
9596 + ioc->pio_mem_phys = port;
9597 + ioc->pio_chip = (SYSIF_REGS __iomem *)pmem;
9598 + }
9599
9600 return 0;
9601 }
9602
9603 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9604 /**
9605 * mpt_attach - Install a PCI intelligent MPT adapter.
9606 * @pdev: Pointer to pci_dev structure
9607 @@ -1588,7 +1699,7 @@ mpt_mapresources(MPT_ADAPTER *ioc)
9608 * Returns 0 for success, non-zero for failure.
9609 *
9610 * TODO: Add support for polled controllers
9611 - */
9612 + **/
9613 int
9614 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
9615 {
9616 @@ -1610,6 +1721,7 @@ mpt_attach(struct pci_dev *pdev, const s
9617
9618 ioc->id = mpt_ids++;
9619 sprintf(ioc->name, "ioc%d", ioc->id);
9620 + dinitprintk(ioc, printk(KERN_WARNING MYNAM ": mpt_adapter_install\n"));
9621
9622 /*
9623 * set initial debug level
9624 @@ -1620,7 +1732,6 @@ mpt_attach(struct pci_dev *pdev, const s
9625 if (mpt_debug_level)
9626 printk(KERN_INFO "mpt_debug_level=%xh\n", mpt_debug_level);
9627
9628 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": mpt_adapter_install\n", ioc->name));
9629
9630 ioc->pcidev = pdev;
9631 if (mpt_mapresources(ioc)) {
9632 @@ -1628,14 +1739,34 @@ mpt_attach(struct pci_dev *pdev, const s
9633 return r;
9634 }
9635
9636 + /*
9637 + * Setting up proper handlers for scatter gather handling
9638 + */
9639 + if (ioc->dma_mask == DMA_64BIT_MASK) {
9640 + if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1078)
9641 + ioc->add_sge = &mpt_add_sge_64bit_1078;
9642 + else
9643 + ioc->add_sge = &mpt_add_sge_64bit;
9644 + ioc->add_chain = &mpt_add_chain_64bit;
9645 + ioc->sg_addr_size = 8;
9646 + } else {
9647 + ioc->add_sge = &mpt_add_sge;
9648 + ioc->add_chain = &mpt_add_chain;
9649 + ioc->sg_addr_size = 4;
9650 + }
9651 + ioc->SGE_size = sizeof(u32) + ioc->sg_addr_size;
9652 +
9653 ioc->alloc_total = sizeof(MPT_ADAPTER);
9654 ioc->req_sz = MPT_DEFAULT_FRAME_SIZE; /* avoid div by zero! */
9655 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
9656
9657 - ioc->pcidev = pdev;
9658 - ioc->diagPending = 0;
9659 - spin_lock_init(&ioc->diagLock);
9660 - spin_lock_init(&ioc->initializing_hba_lock);
9661 + spin_lock_init(&ioc->taskmgmt_lock);
9662 + mutex_init(&ioc->internal_cmds.mutex);
9663 + init_completion(&ioc->internal_cmds.done);
9664 + mutex_init(&ioc->mptbase_cmds.mutex);
9665 + init_completion(&ioc->mptbase_cmds.done);
9666 + mutex_init(&ioc->taskmgmt_cmds.mutex);
9667 + init_completion(&ioc->taskmgmt_cmds.done);
9668
9669 /* Initialize the event logging.
9670 */
9671 @@ -1648,16 +1779,13 @@ mpt_attach(struct pci_dev *pdev, const s
9672 ioc->mfcnt = 0;
9673 #endif
9674
9675 + ioc->sh = NULL;
9676 ioc->cached_fw = NULL;
9677
9678 /* Initilize SCSI Config Data structure
9679 */
9680 memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
9681
9682 - /* Initialize the running configQ head.
9683 - */
9684 - INIT_LIST_HEAD(&ioc->configQ);
9685 -
9686 /* Initialize the fc rport list head.
9687 */
9688 INIT_LIST_HEAD(&ioc->fc_rports);
9689 @@ -1665,11 +1793,10 @@ mpt_attach(struct pci_dev *pdev, const s
9690 /* Find lookup slot. */
9691 INIT_LIST_HEAD(&ioc->list);
9692
9693 -
9694 - /* Initialize workqueue */
9695 + /* Initialize work */
9696 INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
9697 - spin_lock_init(&ioc->fault_reset_work_lock);
9698
9699 + /* Initialize workqueue */
9700 snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
9701 "mpt_poll_%d", ioc->id);
9702 ioc->reset_work_q =
9703 @@ -1682,8 +1809,8 @@ mpt_attach(struct pci_dev *pdev, const s
9704 return -ENOMEM;
9705 }
9706
9707 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts @ %p, pfacts[0] @ %p\n",
9708 - ioc->name, &ioc->facts, &ioc->pfacts[0]));
9709 + dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts @ %p, pfacts[0] @ %p\n",
9710 + ioc->name, &ioc->facts, &ioc->pfacts[0]));
9711
9712 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
9713 mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
9714 @@ -1703,14 +1830,14 @@ mpt_attach(struct pci_dev *pdev, const s
9715 case MPI_MANUFACTPAGE_DEVICEID_FC929X:
9716 if (revision < XL_929) {
9717 /* 929X Chip Fix. Set Split transactions level
9718 - * for PCIX. Set MOST bits to zero.
9719 - */
9720 + * for PCIX. Set MOST bits to zero.
9721 + */
9722 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
9723 pcixcmd &= 0x8F;
9724 pci_write_config_byte(pdev, 0x6a, pcixcmd);
9725 } else {
9726 /* 929XL Chip Fix. Set MMRBC to 0x08.
9727 - */
9728 + */
9729 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
9730 pcixcmd |= 0x08;
9731 pci_write_config_byte(pdev, 0x6a, pcixcmd);
9732 @@ -1728,6 +1855,7 @@ mpt_attach(struct pci_dev *pdev, const s
9733 ioc->bus_type = FC;
9734 break;
9735
9736 +
9737 case MPI_MANUFACTPAGE_DEVID_53C1030:
9738 /* 1030 Chip Fix. Disable Split transactions
9739 * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
9740 @@ -1745,22 +1873,33 @@ mpt_attach(struct pci_dev *pdev, const s
9741 case MPI_MANUFACTPAGE_DEVID_SAS1064:
9742 case MPI_MANUFACTPAGE_DEVID_SAS1068:
9743 ioc->errata_flag_1064 = 1;
9744 + ioc->bus_type = SAS;
9745 + break;
9746
9747 case MPI_MANUFACTPAGE_DEVID_SAS1064E:
9748 case MPI_MANUFACTPAGE_DEVID_SAS1068E:
9749 case MPI_MANUFACTPAGE_DEVID_SAS1078:
9750 ioc->bus_type = SAS;
9751 + break;
9752 }
9753
9754 - if (mpt_msi_enable == -1) {
9755 - /* Enable on SAS, disable on FC and SPI */
9756 - if (ioc->bus_type == SAS)
9757 - ioc->msi_enable = 1;
9758 - else
9759 - ioc->msi_enable = 0;
9760 - } else
9761 - /* follow flag: 0 - disable; 1 - enable */
9762 - ioc->msi_enable = mpt_msi_enable;
9763 + switch (ioc->bus_type) {
9764 + case SAS:
9765 + ioc->msi_enable = mpt_msi_enable_sas;
9766 + break;
9767 +
9768 + case SPI:
9769 + ioc->msi_enable = mpt_msi_enable_spi;
9770 + break;
9771 +
9772 + case FC:
9773 + ioc->msi_enable = mpt_msi_enable_fc;
9774 + break;
9775 +
9776 + default:
9777 + ioc->msi_enable = 0;
9778 + break;
9779 + }
9780
9781 if (ioc->errata_flag_1064)
9782 pci_disable_io_access(pdev);
9783 @@ -1772,9 +1911,6 @@ mpt_attach(struct pci_dev *pdev, const s
9784 ioc->active = 0;
9785 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
9786
9787 - /* Set IOC ptr in the pcidev's driver data. */
9788 - pci_set_drvdata(ioc->pcidev, ioc);
9789 -
9790 /* Set lookup ptr. */
9791 list_add_tail(&ioc->list, &ioc_list);
9792
9793 @@ -1782,10 +1918,17 @@ mpt_attach(struct pci_dev *pdev, const s
9794 */
9795 mpt_detect_bound_ports(ioc, pdev);
9796
9797 +
9798 + INIT_LIST_HEAD(&ioc->fw_event_list);
9799 + spin_lock_init(&ioc->fw_event_lock);
9800 + snprintf(ioc->fw_event_q_name, sizeof(ioc->fw_event_q_name),
9801 + "mpt/%d", ioc->id);
9802 + ioc->fw_event_q = create_singlethread_workqueue(ioc->fw_event_q_name);
9803 +
9804 if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
9805 CAN_SLEEP)) != 0){
9806 printk(MYIOC_s_ERR_FMT "didn't initialize properly! (%d)\n",
9807 - ioc->name, r);
9808 + ioc->name, r);
9809
9810 list_del(&ioc->list);
9811 if (ioc->alt_ioc)
9812 @@ -1796,7 +1939,8 @@ mpt_attach(struct pci_dev *pdev, const s
9813
9814 destroy_workqueue(ioc->reset_work_q);
9815 ioc->reset_work_q = NULL;
9816 -
9817 + destroy_workqueue(ioc->fw_event_q);
9818 + ioc->fw_event_q = NULL;
9819 kfree(ioc);
9820 pci_set_drvdata(pdev, NULL);
9821 return r;
9822 @@ -1832,35 +1976,37 @@ mpt_attach(struct pci_dev *pdev, const s
9823 if (!ioc->alt_ioc)
9824 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
9825 msecs_to_jiffies(MPT_POLLING_INTERVAL));
9826 -
9827 return 0;
9828 }
9829
9830 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9831 /**
9832 * mpt_detach - Remove a PCI intelligent MPT adapter.
9833 * @pdev: Pointer to pci_dev structure
9834 - */
9835 -
9836 + **/
9837 void
9838 mpt_detach(struct pci_dev *pdev)
9839 {
9840 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
9841 char pname[32];
9842 u8 cb_idx;
9843 - unsigned long flags;
9844 + unsigned long flags;
9845 struct workqueue_struct *wq;
9846
9847 /*
9848 * Stop polling ioc for fault condition
9849 */
9850 - spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
9851 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
9852 wq = ioc->reset_work_q;
9853 ioc->reset_work_q = NULL;
9854 - spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
9855 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
9856 cancel_delayed_work(&ioc->fault_reset_work);
9857 destroy_workqueue(wq);
9858
9859 + spin_lock_irqsave(&ioc->fw_event_lock, flags);
9860 + wq = ioc->fw_event_q;
9861 + ioc->fw_event_q = NULL;
9862 + spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
9863 + destroy_workqueue(wq);
9864
9865 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
9866 remove_proc_entry(pname, NULL);
9867 @@ -1877,32 +2023,18 @@ mpt_detach(struct pci_dev *pdev)
9868 }
9869 }
9870
9871 - /* Disable interrupts! */
9872 - CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
9873 -
9874 - ioc->active = 0;
9875 - synchronize_irq(pdev->irq);
9876 -
9877 - /* Clear any lingering interrupt */
9878 - CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
9879 -
9880 - CHIPREG_READ32(&ioc->chip->IntStatus);
9881 -
9882 - mpt_adapter_dispose(ioc);
9883 -
9884 - pci_set_drvdata(pdev, NULL);
9885 -}
9886 + mpt_adapter_dispose(ioc);
9887 +}
9888
9889 /**************************************************************************
9890 * Power Management
9891 */
9892 #ifdef CONFIG_PM
9893 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9894 /**
9895 * mpt_suspend - Fusion MPT base driver suspend routine.
9896 * @pdev: Pointer to pci_dev structure
9897 * @state: new state to enter
9898 - */
9899 + **/
9900 int
9901 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
9902 {
9903 @@ -1923,7 +2055,6 @@ mpt_suspend(struct pci_dev *pdev, pm_mes
9904 /* disable interrupts */
9905 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
9906 ioc->active = 0;
9907 -
9908 /* Clear any lingering interrupt */
9909 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
9910
9911 @@ -1938,11 +2069,10 @@ mpt_suspend(struct pci_dev *pdev, pm_mes
9912 return 0;
9913 }
9914
9915 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9916 /**
9917 * mpt_resume - Fusion MPT base driver resume routine.
9918 * @pdev: Pointer to pci_dev structure
9919 - */
9920 + **/
9921 int
9922 mpt_resume(struct pci_dev *pdev)
9923 {
9924 @@ -1962,6 +2092,22 @@ mpt_resume(struct pci_dev *pdev)
9925 err = mpt_mapresources(ioc);
9926 if (err)
9927 return err;
9928 +
9929 + if (ioc->dma_mask == DMA_64BIT_MASK) {
9930 + if (pdev->device == MPI_MANUFACTPAGE_DEVID_SAS1078)
9931 + ioc->add_sge = &mpt_add_sge_64bit_1078;
9932 + else
9933 + ioc->add_sge = &mpt_add_sge_64bit;
9934 + ioc->add_chain = &mpt_add_chain_64bit;
9935 + ioc->sg_addr_size = 8;
9936 + } else {
9937 +
9938 + ioc->add_sge = &mpt_add_sge;
9939 + ioc->add_chain = &mpt_add_chain;
9940 + ioc->sg_addr_size = 4;
9941 + }
9942 + ioc->SGE_size = sizeof(u32) + ioc->sg_addr_size;
9943 +
9944
9945 printk(MYIOC_s_INFO_FMT "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
9946 ioc->name, (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
9947 @@ -1986,9 +2132,7 @@ mpt_resume(struct pci_dev *pdev)
9948
9949 /* bring ioc to operational state */
9950 printk(MYIOC_s_INFO_FMT "Sending mpt_do_ioc_recovery\n", ioc->name);
9951 - recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
9952 - CAN_SLEEP);
9953 - if (recovery_state != 0)
9954 + if ((recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP, CAN_SLEEP)) != 0)
9955 printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover, "
9956 "error:[%x]\n", ioc->name, recovery_state);
9957 else
9958 @@ -1996,7 +2140,6 @@ mpt_resume(struct pci_dev *pdev)
9959 "pci-resume: success\n", ioc->name);
9960 out:
9961 return 0;
9962 -
9963 }
9964 #endif
9965
9966 @@ -2015,7 +2158,6 @@ mpt_signal_reset(u8 index, MPT_ADAPTER *
9967 return (MptResetHandlers[index])(ioc, reset_phase);
9968 }
9969
9970 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
9971 /**
9972 * mpt_do_ioc_recovery - Initialize or recover MPT adapter.
9973 * @ioc: Pointer to MPT adapter structure
9974 @@ -2034,9 +2176,7 @@ mpt_signal_reset(u8 index, MPT_ADAPTER *
9975 * -2 if READY but IOCFacts Failed
9976 * -3 if READY but PrimeIOCFifos Failed
9977 * -4 if READY but IOCInit Failed
9978 - * -5 if failed to enable_device and/or request_selected_regions
9979 - * -6 if failed to upload firmware
9980 - */
9981 + **/
9982 static int
9983 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
9984 {
9985 @@ -2045,14 +2185,12 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
9986 int hard;
9987 int rc=0;
9988 int ii;
9989 - u8 cb_idx;
9990 - int handlers;
9991 int ret = 0;
9992 int reset_alt_ioc_active = 0;
9993 int irq_allocated = 0;
9994 u8 *a;
9995
9996 - printk(MYIOC_s_INFO_FMT "Initiating %s\n", ioc->name,
9997 + printk(MYIOC_s_DEBUG_FMT "Initiating %s\n", ioc->name,
9998 reason == MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
9999
10000 /* Disable reply interrupts (also blocks FreeQ) */
10001 @@ -2060,7 +2198,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10002 ioc->active = 0;
10003
10004 if (ioc->alt_ioc) {
10005 - if (ioc->alt_ioc->active)
10006 + if (ioc->alt_ioc->active || reason == MPT_HOSTEVENT_IOC_RECOVER)
10007 reset_alt_ioc_active = 1;
10008
10009 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
10010 @@ -2079,16 +2217,17 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10011
10012 if (reset_alt_ioc_active && ioc->alt_ioc) {
10013 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
10014 - dprintk(ioc, printk(MYIOC_s_INFO_FMT
10015 - "alt_ioc reply irq re-enabled\n", ioc->alt_ioc->name));
10016 + dprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": alt-ioc reply irq re-enabled\n",
10017 + ioc->alt_ioc->name));
10018 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
10019 ioc->alt_ioc->active = 1;
10020 }
10021
10022 } else {
10023 - printk(MYIOC_s_WARN_FMT "NOT READY!\n", ioc->name);
10024 + printk(MYIOC_s_WARN_FMT "NOT READY WARNING!\n", ioc->name);
10025 }
10026 - return -1;
10027 + ret = -1;
10028 + goto out;
10029 }
10030
10031 /* hard_reset_done = 0 if a soft reset was performed
10032 @@ -2098,7 +2237,8 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10033 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
10034 alt_ioc_ready = 1;
10035 else
10036 - printk(MYIOC_s_WARN_FMT "alt_ioc not ready!\n", ioc->alt_ioc->name);
10037 + printk(MYIOC_s_WARN_FMT
10038 + ": alt-ioc Not ready WARNING!\n", ioc->alt_ioc->name);
10039 }
10040
10041 for (ii=0; ii<5; ii++) {
10042 @@ -2156,23 +2296,28 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10043 if (ioc->pcidev->irq) {
10044 if (ioc->msi_enable && !pci_enable_msi(ioc->pcidev))
10045 printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
10046 - ioc->name);
10047 + ioc->name);
10048 else
10049 ioc->msi_enable = 0;
10050 +
10051 rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
10052 IRQF_SHARED, ioc->name, ioc);
10053 if (rc < 0) {
10054 printk(MYIOC_s_ERR_FMT "Unable to allocate "
10055 - "interrupt %d!\n", ioc->name, ioc->pcidev->irq);
10056 + "interrupt %d!\n", ioc->name,
10057 + ioc->pcidev->irq);
10058 if (ioc->msi_enable)
10059 pci_disable_msi(ioc->pcidev);
10060 - return -EBUSY;
10061 + ret = -EBUSY;
10062 + goto out;
10063 }
10064 irq_allocated = 1;
10065 ioc->pci_irq = ioc->pcidev->irq;
10066 pci_set_master(ioc->pcidev); /* ?? */
10067 - dprintk(ioc, printk(MYIOC_s_INFO_FMT "installed at interrupt "
10068 - "%d\n", ioc->name, ioc->pcidev->irq));
10069 + pci_set_drvdata(ioc->pcidev, ioc);
10070 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
10071 + "installed at interrupt %d\n", ioc->name,
10072 + ioc->pcidev->irq));
10073 }
10074 }
10075
10076 @@ -2181,18 +2326,22 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10077 * init as upper addresses are needed for init.
10078 * If fails, continue with alt-ioc processing
10079 */
10080 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "PrimeIocFifos\n",
10081 + ioc->name));
10082 if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
10083 ret = -3;
10084
10085 /* May need to check/upload firmware & data here!
10086 * If fails, continue with alt-ioc processing
10087 */
10088 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "SendIocInit\n",
10089 + ioc->name));
10090 if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
10091 ret = -4;
10092 // NEW!
10093 if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
10094 - printk(MYIOC_s_WARN_FMT ": alt_ioc (%d) FIFO mgmt alloc!\n",
10095 - ioc->alt_ioc->name, rc);
10096 + printk(MYIOC_s_WARN_FMT ": alt-ioc (%d) FIFO mgmt alloc WARNING!\n",
10097 + ioc->alt_ioc->name, rc);
10098 alt_ioc_ready = 0;
10099 reset_alt_ioc_active = 0;
10100 }
10101 @@ -2201,15 +2350,16 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10102 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
10103 alt_ioc_ready = 0;
10104 reset_alt_ioc_active = 0;
10105 - printk(MYIOC_s_WARN_FMT "alt_ioc (%d) init failure!\n",
10106 - ioc->alt_ioc->name, rc);
10107 + printk(MYIOC_s_WARN_FMT
10108 + ": alt-ioc: (%d) init failure WARNING!\n",
10109 + ioc->alt_ioc->name, rc);
10110 }
10111 }
10112
10113 if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
10114 if (ioc->upload_fw) {
10115 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
10116 - "firmware upload required!\n", ioc->name));
10117 + "firmware upload required!\n", ioc->name));
10118
10119 /* Controller is not operational, cannot do upload
10120 */
10121 @@ -2232,34 +2382,39 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10122 } else {
10123 printk(MYIOC_s_WARN_FMT
10124 "firmware upload failure!\n", ioc->name);
10125 - ret = -6;
10126 + ret = -5;
10127 }
10128 }
10129 }
10130 }
10131
10132 + /* Enable MPT base driver management of EventNotification
10133 + * and EventAck handling.
10134 + */
10135 + if ((ret == 0) && (!ioc->facts.EventState)) {
10136 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "SendEventNotification\n",
10137 + ioc->name));
10138 + ret = SendEventNotification(ioc, 1, sleepFlag); /* 1=Enable */
10139 + }
10140 +
10141 + if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
10142 + rc = SendEventNotification(ioc->alt_ioc, 1, sleepFlag);
10143 +
10144 if (ret == 0) {
10145 /* Enable! (reply interrupt) */
10146 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
10147 ioc->active = 1;
10148 }
10149 -
10150 - if (reset_alt_ioc_active && ioc->alt_ioc) {
10151 - /* (re)Enable alt-IOC! (reply interrupt) */
10152 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "alt_ioc reply irq re-enabled\n",
10153 - ioc->alt_ioc->name));
10154 - CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
10155 - ioc->alt_ioc->active = 1;
10156 + if (rc == 0) { /* alt ioc */
10157 + if (reset_alt_ioc_active && ioc->alt_ioc) {
10158 + /* (re)Enable alt-IOC! (reply interrupt) */
10159 + dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "alt-ioc reply irq re-enabled\n",
10160 + ioc->alt_ioc->name));
10161 + CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
10162 + ioc->alt_ioc->active = 1;
10163 + }
10164 }
10165
10166 - /* Enable MPT base driver management of EventNotification
10167 - * and EventAck handling.
10168 - */
10169 - if ((ret == 0) && (!ioc->facts.EventState))
10170 - (void) SendEventNotification(ioc, 1); /* 1=Enable EventNotification */
10171 -
10172 - if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
10173 - (void) SendEventNotification(ioc->alt_ioc, 1); /* 1=Enable EventNotification */
10174
10175 /* Add additional "reason" check before call to GetLanConfigPages
10176 * (combined with GetIoUnitPage2 call). This prevents a somewhat
10177 @@ -2272,11 +2427,12 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10178 /*
10179 * Initalize link list for inactive raid volumes.
10180 */
10181 - mutex_init(&ioc->raid_data.inactive_list_mutex);
10182 + init_MUTEX(&ioc->raid_data.inactive_list_mutex);
10183 INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
10184
10185 - if (ioc->bus_type == SAS) {
10186 + switch (ioc->bus_type) {
10187
10188 + case SAS:
10189 /* clear persistency table */
10190 if(ioc->facts.IOCExceptions &
10191 MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
10192 @@ -2290,8 +2446,15 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10193 */
10194 mpt_findImVolumes(ioc);
10195
10196 - } else if (ioc->bus_type == FC) {
10197 - if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
10198 + /* Check, and possibly reset, the coalescing value
10199 + */
10200 + mpt_read_ioc_pg_1(ioc);
10201 +
10202 + break;
10203 +
10204 + case FC:
10205 + if ((ioc->pfacts[0].ProtocolFlags &
10206 + MPI_PORTFACTS_PROTOCOL_LAN) &&
10207 (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
10208 /*
10209 * Pre-fetch the ports LAN MAC address!
10210 @@ -2300,11 +2463,14 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10211 (void) GetLanConfigPages(ioc);
10212 a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
10213 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
10214 - "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
10215 - ioc->name, a[5], a[4], a[3], a[2], a[1], a[0]));
10216 -
10217 + "LanAddr = %02X:%02X:%02X"
10218 + ":%02X:%02X:%02X\n",
10219 + ioc->name, a[5], a[4],
10220 + a[3], a[2], a[1], a[0]));
10221 }
10222 - } else {
10223 + break;
10224 +
10225 + case SPI:
10226 /* Get NVRAM and adapter maximums from SPP 0 and 2
10227 */
10228 mpt_GetScsiPortSettings(ioc, 0);
10229 @@ -2323,41 +2489,16 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10230 mpt_read_ioc_pg_1(ioc);
10231
10232 mpt_read_ioc_pg_4(ioc);
10233 +
10234 + break;
10235 }
10236
10237 GetIoUnitPage2(ioc);
10238 mpt_get_manufacturing_pg_0(ioc);
10239 }
10240
10241 - /*
10242 - * Call each currently registered protocol IOC reset handler
10243 - * with post-reset indication.
10244 - * NOTE: If we're doing _IOC_BRINGUP, there can be no
10245 - * MptResetHandlers[] registered yet.
10246 - */
10247 - if (hard_reset_done) {
10248 - rc = handlers = 0;
10249 - for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
10250 - if ((ret == 0) && MptResetHandlers[cb_idx]) {
10251 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
10252 - "Calling IOC post_reset handler #%d\n",
10253 - ioc->name, cb_idx));
10254 - rc += mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
10255 - handlers++;
10256 - }
10257 -
10258 - if (alt_ioc_ready && MptResetHandlers[cb_idx]) {
10259 - drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
10260 - "Calling IOC post_reset handler #%d\n",
10261 - ioc->alt_ioc->name, cb_idx));
10262 - rc += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
10263 - handlers++;
10264 - }
10265 - }
10266 - /* FIXME? Examine results here? */
10267 - }
10268 -
10269 out:
10270 +
10271 if ((ret != 0) && irq_allocated) {
10272 free_irq(ioc->pci_irq, ioc);
10273 if (ioc->msi_enable)
10274 @@ -2366,7 +2507,6 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10275 return ret;
10276 }
10277
10278 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10279 /**
10280 * mpt_detect_bound_ports - Search for matching PCI bus/dev_function
10281 * @ioc: Pointer to MPT adapter structure
10282 @@ -2378,7 +2518,7 @@ mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u3
10283 *
10284 * If match on PCI dev_function +/-1 is found, bind the two MPT adapters
10285 * using alt_ioc pointer fields in their %MPT_ADAPTER structures.
10286 - */
10287 + **/
10288 static void
10289 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
10290 {
10291 @@ -2389,8 +2529,8 @@ mpt_detect_bound_ports(MPT_ADAPTER *ioc,
10292
10293 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PCI device %s devfn=%x/%x,"
10294 " searching for devfn match on %x or %x\n",
10295 - ioc->name, pci_name(pdev), pdev->bus->number,
10296 - pdev->devfn, func-1, func+1));
10297 + ioc->name, pci_name(pdev), pdev->bus->number,
10298 + pdev->devfn, func-1, func+1));
10299
10300 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
10301 if (!peer) {
10302 @@ -2404,16 +2544,16 @@ mpt_detect_bound_ports(MPT_ADAPTER *ioc,
10303 if (_pcidev == peer) {
10304 /* Paranoia checks */
10305 if (ioc->alt_ioc != NULL) {
10306 - printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
10307 - ioc->name, ioc->alt_ioc->name);
10308 + printk(MYIOC_s_WARN_FMT "Oops, already bound (%s <==> %s)!\n",
10309 + ioc->name, ioc->name, ioc->alt_ioc->name);
10310 break;
10311 } else if (ioc_srch->alt_ioc != NULL) {
10312 - printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
10313 - ioc_srch->name, ioc_srch->alt_ioc->name);
10314 + printk(MYIOC_s_WARN_FMT "Oops, already bound (%s <==> %s)!\n",
10315 + ioc_srch->name, ioc_srch->name, ioc_srch->alt_ioc->name);
10316 break;
10317 }
10318 - dprintk(ioc, printk(MYIOC_s_INFO_FMT "FOUND! binding to %s\n",
10319 - ioc->name, ioc_srch->name));
10320 + dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FOUND! binding %s <==> %s\n",
10321 + ioc->name, ioc->name, ioc_srch->name));
10322 ioc_srch->alt_ioc = ioc;
10323 ioc->alt_ioc = ioc_srch;
10324 }
10325 @@ -2421,11 +2561,10 @@ mpt_detect_bound_ports(MPT_ADAPTER *ioc,
10326 pci_dev_put(peer);
10327 }
10328
10329 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10330 /**
10331 * mpt_adapter_disable - Disable misbehaving MPT adapter.
10332 * @ioc: Pointer to MPT adapter structure
10333 - */
10334 + **/
10335 static void
10336 mpt_adapter_disable(MPT_ADAPTER *ioc)
10337 {
10338 @@ -2433,26 +2572,43 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
10339 int ret;
10340
10341 if (ioc->cached_fw != NULL) {
10342 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Pushing FW onto "
10343 - "adapter\n", __func__, ioc->name));
10344 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_adapter_disable: "
10345 + "Pushing FW onto adapter\n", ioc->name));
10346 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)
10347 ioc->cached_fw, CAN_SLEEP)) < 0) {
10348 printk(MYIOC_s_WARN_FMT
10349 - ": firmware downloadboot failure (%d)!\n",
10350 - ioc->name, ret);
10351 + ": firmware downloadboot failure (%d)!\n", ioc->name, ret);
10352 }
10353 }
10354
10355 + /*
10356 + * Put the controller into ready state (if its not already)
10357 + */
10358 + if (mpt_GetIocState(ioc, 1) != MPI_IOC_STATE_READY) {
10359 + if(!SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET,
10360 + CAN_SLEEP)) {
10361 + if (mpt_GetIocState(ioc, 1) != MPI_IOC_STATE_READY)
10362 + printk(MYIOC_s_ERR_FMT "%s: IOC msg unit "
10363 + "reset failed to put ioc in ready state!\n",
10364 + ioc->name, __FUNCTION__);
10365 + } else
10366 + printk(MYIOC_s_ERR_FMT "%s: IOC msg unit reset "
10367 + "failed!\n", ioc->name, __FUNCTION__);
10368 + }
10369 +
10370 /* Disable adapter interrupts! */
10371 + synchronize_irq(ioc->pcidev->irq);
10372 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
10373 ioc->active = 0;
10374 +
10375 /* Clear any lingering interrupt */
10376 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
10377 + CHIPREG_READ32(&ioc->chip->IntStatus);
10378
10379 if (ioc->alloc != NULL) {
10380 sz = ioc->alloc_sz;
10381 - dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "free @ %p, sz=%d bytes\n",
10382 - ioc->name, ioc->alloc, ioc->alloc_sz));
10383 + dexitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free @ %p, sz=%d bytes\n",
10384 + ioc->name, ioc->alloc, ioc->alloc_sz));
10385 pci_free_consistent(ioc->pcidev, sz,
10386 ioc->alloc, ioc->alloc_dma);
10387 ioc->reply_frames = NULL;
10388 @@ -2482,8 +2638,10 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
10389 mpt_inactive_raid_list_free(ioc);
10390 kfree(ioc->raid_data.pIocPg2);
10391 kfree(ioc->raid_data.pIocPg3);
10392 + kfree(ioc->raid_data.pIocPg6);
10393 ioc->spi_data.nvram = NULL;
10394 ioc->raid_data.pIocPg3 = NULL;
10395 + ioc->raid_data.pIocPg6 = NULL;
10396
10397 if (ioc->spi_data.pIocPg4 != NULL) {
10398 sz = ioc->spi_data.IocPg4Sz;
10399 @@ -2507,27 +2665,29 @@ mpt_adapter_disable(MPT_ADAPTER *ioc)
10400 if((ret = mpt_host_page_access_control(ioc,
10401 MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
10402 printk(MYIOC_s_ERR_FMT
10403 - "host page buffers free failed (%d)!\n",
10404 - ioc->name, ret);
10405 + ": %s: host page buffers free failed (%d)!\n",
10406 + ioc->name, __FUNCTION__, ret);
10407 }
10408 - dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
10409 + dexitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
10410 ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
10411 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
10412 - ioc->HostPageBuffer, ioc->HostPageBuffer_dma);
10413 + ioc->HostPageBuffer,
10414 + ioc->HostPageBuffer_dma);
10415 ioc->HostPageBuffer = NULL;
10416 ioc->HostPageBuffer_sz = 0;
10417 ioc->alloc_total -= ioc->HostPageBuffer_sz;
10418 }
10419 +
10420 + pci_set_drvdata(ioc->pcidev, NULL);
10421 }
10422
10423 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10424 /**
10425 * mpt_adapter_dispose - Free all resources associated with an MPT adapter
10426 * @ioc: Pointer to MPT adapter structure
10427 *
10428 * This routine unregisters h/w resources and frees all alloc'd memory
10429 * associated with a MPT adapter structure.
10430 - */
10431 + **/
10432 static void
10433 mpt_adapter_dispose(MPT_ADAPTER *ioc)
10434 {
10435 @@ -2558,7 +2718,7 @@ mpt_adapter_dispose(MPT_ADAPTER *ioc)
10436 #if defined(CONFIG_MTRR) && 0
10437 if (ioc->mtrr_reg > 0) {
10438 mtrr_del(ioc->mtrr_reg, 0, 0);
10439 - dprintk(ioc, printk(MYIOC_s_INFO_FMT "MTRR region de-registered\n", ioc->name));
10440 + dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MTRR region de-registered\n", ioc->name));
10441 }
10442 #endif
10443
10444 @@ -2566,8 +2726,8 @@ mpt_adapter_dispose(MPT_ADAPTER *ioc)
10445 list_del(&ioc->list);
10446
10447 sz_last = ioc->alloc_total;
10448 - dprintk(ioc, printk(MYIOC_s_INFO_FMT "free'd %d of %d bytes\n",
10449 - ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
10450 + dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free'd %d of %d bytes\n",
10451 + ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
10452
10453 if (ioc->alt_ioc)
10454 ioc->alt_ioc->alt_ioc = NULL;
10455 @@ -2575,11 +2735,10 @@ mpt_adapter_dispose(MPT_ADAPTER *ioc)
10456 kfree(ioc);
10457 }
10458
10459 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10460 /**
10461 * MptDisplayIocCapabilities - Disply IOC's capabilities.
10462 * @ioc: Pointer to MPT adapter structure
10463 - */
10464 + **/
10465 static void
10466 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
10467 {
10468 @@ -2618,7 +2777,6 @@ MptDisplayIocCapabilities(MPT_ADAPTER *i
10469 printk("}\n");
10470 }
10471
10472 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10473 /**
10474 * MakeIocReady - Get IOC to a READY state, using KickStart if needed.
10475 * @ioc: Pointer to MPT_ADAPTER structure
10476 @@ -2632,7 +2790,7 @@ MptDisplayIocCapabilities(MPT_ADAPTER *i
10477 * -2 - Msg Unit Reset Failed
10478 * -3 - IO Unit Reset Failed
10479 * -4 - IOC owned by a PEER
10480 - */
10481 + **/
10482 static int
10483 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
10484 {
10485 @@ -2646,7 +2804,7 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10486
10487 /* Get current [raw] IOC state */
10488 ioc_state = mpt_GetIocState(ioc, 0);
10489 - dhsprintk(ioc, printk(MYIOC_s_INFO_FMT "MakeIocReady [raw] state=%08x\n", ioc->name, ioc_state));
10490 + dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MakeIocReady, [raw] state=%08x\n", ioc->name, ioc_state));
10491
10492 /*
10493 * Check to see if IOC got left/stuck in doorbell handshake
10494 @@ -2659,8 +2817,11 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10495 }
10496
10497 /* Is it already READY? */
10498 - if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
10499 + if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY) {
10500 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "IOC is in READY state\n",
10501 + ioc->name));
10502 return 0;
10503 + }
10504
10505 /*
10506 * Check to see if IOC is in FAULT state.
10507 @@ -2668,9 +2829,9 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10508 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
10509 statefault = 2;
10510 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
10511 - ioc->name);
10512 - printk(MYIOC_s_WARN_FMT " FAULT code = %04xh\n",
10513 - ioc->name, ioc_state & MPI_DOORBELL_DATA_MASK);
10514 + ioc->name);
10515 + printk(KERN_WARNING " FAULT code = %04xh\n",
10516 + ioc_state & MPI_DOORBELL_DATA_MASK);
10517 }
10518
10519 /*
10520 @@ -2686,7 +2847,7 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10521 * Else, fall through to KickStart case
10522 */
10523 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
10524 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
10525 + dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
10526 "whoinit 0x%x statefault %d force %d\n",
10527 ioc->name, whoinit, statefault, force));
10528 if (whoinit == MPI_WHOINIT_PCI_PEER)
10529 @@ -2733,15 +2894,15 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10530
10531 ii++; cntdn--;
10532 if (!cntdn) {
10533 - printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
10534 - ioc->name, (int)((ii+5)/HZ));
10535 + printk(MYIOC_s_ERR_FMT "Wait IOC_READY state (0x%x) timeout(%d)!\n",
10536 + ioc->name, ioc_state, (int)((ii+5)/HZ));
10537 return -ETIME;
10538 }
10539
10540 if (sleepFlag == CAN_SLEEP) {
10541 msleep(1);
10542 } else {
10543 - mdelay (1); /* 1 msec delay */
10544 + mdelay(1); /* 1 msec delay */
10545 }
10546
10547 }
10548 @@ -2755,7 +2916,6 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10549 return hard_reset_done;
10550 }
10551
10552 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10553 /**
10554 * mpt_GetIocState - Get the current state of a MPT adapter.
10555 * @ioc: Pointer to MPT_ADAPTER structure
10556 @@ -2763,7 +2923,7 @@ MakeIocReady(MPT_ADAPTER *ioc, int force
10557 *
10558 * Returns all IOC Doorbell register bits if cooked==0, else just the
10559 * Doorbell bits in MPI_IOC_STATE_MASK.
10560 - */
10561 + **/
10562 u32
10563 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
10564 {
10565 @@ -2779,7 +2939,6 @@ mpt_GetIocState(MPT_ADAPTER *ioc, int co
10566 return cooked ? sc : s;
10567 }
10568
10569 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10570 /**
10571 * GetIocFacts - Send IOCFacts request to MPT adapter.
10572 * @ioc: Pointer to MPT_ADAPTER structure
10573 @@ -2787,7 +2946,7 @@ mpt_GetIocState(MPT_ADAPTER *ioc, int co
10574 * @reason: If recovery, only update facts.
10575 *
10576 * Returns 0 for success, non-zero for failure.
10577 - */
10578 + **/
10579 static int
10580 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
10581 {
10582 @@ -2802,8 +2961,9 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10583
10584 /* IOC *must* NOT be in RESET state! */
10585 if (ioc->last_state == MPI_IOC_STATE_RESET) {
10586 - printk(MYIOC_s_ERR_FMT "Can't get IOCFacts NOT READY! (%08x)\n",
10587 - ioc->name, ioc->last_state );
10588 + printk(KERN_ERR MYNAM ": ERROR - Can't get IOCFacts, %s NOT READY! (%08x)\n",
10589 + ioc->name,
10590 + ioc->last_state );
10591 return -44;
10592 }
10593
10594 @@ -2820,7 +2980,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10595 get_facts.Function = MPI_FUNCTION_IOC_FACTS;
10596 /* Assert: All other get_facts fields are zero! */
10597
10598 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
10599 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
10600 "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
10601 ioc->name, req_sz, reply_sz));
10602
10603 @@ -2850,6 +3010,8 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10604 }
10605
10606 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
10607 + if (facts->MsgVersion == MPI_VERSION_01_05)
10608 + facts->HeaderVersion = le16_to_cpu(facts->HeaderVersion);
10609 facts->MsgContext = le32_to_cpu(facts->MsgContext);
10610 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
10611 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
10612 @@ -2865,7 +3027,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10613 * Old: u16{Major(4),Minor(4),SubMinor(8)}
10614 * New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
10615 */
10616 - if (facts->MsgVersion < 0x0102) {
10617 + if (facts->MsgVersion < MPI_VERSION_01_02) {
10618 /*
10619 * Handle old FC f/w style, convert to new...
10620 */
10621 @@ -2877,9 +3039,11 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10622 facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
10623
10624 facts->ProductID = le16_to_cpu(facts->ProductID);
10625 +
10626 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
10627 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
10628 ioc->ir_firmware = 1;
10629 +
10630 facts->CurrentHostMfaHighAddr =
10631 le32_to_cpu(facts->CurrentHostMfaHighAddr);
10632 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
10633 @@ -2895,7 +3059,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10634 * to 14 in MPI-1.01.0x.
10635 */
10636 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
10637 - facts->MsgVersion > 0x0100) {
10638 + facts->MsgVersion > MPI_VERSION_01_00) {
10639 facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
10640 }
10641
10642 @@ -2956,7 +3120,6 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10643 return 0;
10644 }
10645
10646 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10647 /**
10648 * GetPortFacts - Send PortFacts request to MPT adapter.
10649 * @ioc: Pointer to MPT_ADAPTER structure
10650 @@ -2964,7 +3127,7 @@ GetIocFacts(MPT_ADAPTER *ioc, int sleepF
10651 * @sleepFlag: Specifies whether the process can sleep
10652 *
10653 * Returns 0 for success, non-zero for failure.
10654 - */
10655 + **/
10656 static int
10657 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
10658 {
10659 @@ -2977,8 +3140,8 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
10660
10661 /* IOC *must* NOT be in RESET state! */
10662 if (ioc->last_state == MPI_IOC_STATE_RESET) {
10663 - printk(MYIOC_s_ERR_FMT "Can't get PortFacts NOT READY! (%08x)\n",
10664 - ioc->name, ioc->last_state );
10665 + printk(MYIOC_s_ERR_FMT "Can't get PortFacts, "
10666 + " NOT READY! (%08x)\n", ioc->name, ioc->last_state );
10667 return -4;
10668 }
10669
10670 @@ -2996,14 +3159,14 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
10671 get_pfacts.PortNumber = portnum;
10672 /* Assert: All other get_pfacts fields are zero! */
10673
10674 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending get PortFacts(%d) request\n",
10675 - ioc->name, portnum));
10676 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "Sending get PortFacts(%d) request\n",
10677 + ioc->name, portnum));
10678
10679 /* No non-zero fields in the get_pfacts request are greater than
10680 * 1 byte in size, so we can just fire it off as is.
10681 */
10682 ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
10683 - reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
10684 + reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
10685 if (ii != 0)
10686 return ii;
10687
10688 @@ -3038,7 +3201,6 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
10689 return 0;
10690 }
10691
10692 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10693 /**
10694 * SendIocInit - Send IOCInit request to MPT adapter.
10695 * @ioc: Pointer to MPT_ADAPTER structure
10696 @@ -3047,7 +3209,7 @@ GetPortFacts(MPT_ADAPTER *ioc, int portn
10697 * Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
10698 *
10699 * Returns 0 for success, non-zero for failure.
10700 - */
10701 + **/
10702 static int
10703 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
10704 {
10705 @@ -3077,7 +3239,8 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
10706
10707 ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
10708 ioc_init.MaxBuses = (U8)ioc->number_of_buses;
10709 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts.MsgVersion=%x\n",
10710 +
10711 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts.MsgVersion=%x\n",
10712 ioc->name, ioc->facts.MsgVersion));
10713 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
10714 // set MsgVersion and HeaderVersion host driver was built with
10715 @@ -3091,7 +3254,7 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
10716 }
10717 ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz); /* in BYTES */
10718
10719 - if (sizeof(dma_addr_t) == sizeof(u64)) {
10720 + if (ioc->sg_addr_size == sizeof(u64)) {
10721 /* Save the upper 32-bits of the request
10722 * (reply) and sense buffers.
10723 */
10724 @@ -3160,7 +3323,6 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
10725 return r;
10726 }
10727
10728 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10729 /**
10730 * SendPortEnable - Send PortEnable request to MPT adapter port.
10731 * @ioc: Pointer to MPT_ADAPTER structure
10732 @@ -3170,7 +3332,7 @@ SendIocInit(MPT_ADAPTER *ioc, int sleepF
10733 * Send PortEnable to bring IOC to OPERATIONAL state.
10734 *
10735 * Returns 0 for success, non-zero for failure.
10736 - */
10737 + **/
10738 static int
10739 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
10740 {
10741 @@ -3193,7 +3355,7 @@ SendPortEnable(MPT_ADAPTER *ioc, int por
10742 /* port_enable.MsgFlags = 0; */
10743 /* port_enable.MsgContext = 0; */
10744
10745 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Port(%d)Enable (req @ %p)\n",
10746 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "Sending Port(%d)Enable (req @ %p)\n",
10747 ioc->name, portnum, &port_enable));
10748
10749 /* RAID FW may take a long time to enable
10750 @@ -3273,7 +3435,6 @@ mpt_free_fw_memory(MPT_ADAPTER *ioc)
10751 ioc->cached_fw = NULL;
10752 }
10753
10754 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10755 /**
10756 * mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
10757 * @ioc: Pointer to MPT_ADAPTER structure
10758 @@ -3286,7 +3447,7 @@ mpt_free_fw_memory(MPT_ADAPTER *ioc)
10759 * on the bound IOC, the second image is discarded
10760 * and memory is free'd. Both channels must upload to prevent
10761 * IOC from running in degraded mode.
10762 - */
10763 + **/
10764 static int
10765 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
10766 {
10767 @@ -3294,22 +3455,19 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
10768 FWUpload_t *prequest;
10769 FWUploadReply_t *preply;
10770 FWUploadTCSGE_t *ptcsge;
10771 - int sgeoffset;
10772 u32 flagsLength;
10773 - int ii, sz, reply_sz;
10774 + int ii, reply_sz;
10775 int cmdStatus;
10776 + int request_size;
10777
10778 /* If the image size is 0, we are done.
10779 */
10780 - if ((sz = ioc->facts.FWImageSize) == 0)
10781 + if (!ioc->facts.FWImageSize)
10782 return 0;
10783
10784 if (mpt_alloc_fw_memory(ioc, ioc->facts.FWImageSize) != 0)
10785 return -ENOMEM;
10786
10787 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Image @ %p[%p], sz=%d[%x] bytes\n",
10788 - ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
10789 -
10790 prequest = (sleepFlag == NO_SLEEP) ? kzalloc(ioc->req_sz, GFP_ATOMIC) :
10791 kzalloc(ioc->req_sz, GFP_KERNEL);
10792 if (!prequest) {
10793 @@ -3326,49 +3484,47 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
10794
10795 prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
10796 prequest->Function = MPI_FUNCTION_FW_UPLOAD;
10797 -
10798 ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
10799 ptcsge->DetailsLength = 12;
10800 ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
10801 - ptcsge->ImageSize = cpu_to_le32(sz);
10802 + ptcsge->ImageSize = cpu_to_le32(ioc->facts.FWImageSize);
10803 ptcsge++;
10804
10805 - sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
10806 -
10807 - flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
10808 - mpt_add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
10809 -
10810 - sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
10811 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
10812 - ioc->name, prequest, sgeoffset));
10813 + flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | ioc->facts.FWImageSize;
10814 + ioc->add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
10815 + request_size = offsetof(FWUpload_t, SGL) + sizeof(FWUploadTCSGE_t) +
10816 + ioc->SGE_size;
10817 + dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending FW Upload "
10818 + " (req @ %p) fw_size=%d mf_request_size=%d\n", ioc->name, prequest,
10819 + ioc->facts.FWImageSize, request_size));
10820 DBG_DUMP_FW_REQUEST_FRAME(ioc, (u32 *)prequest);
10821
10822 - ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
10823 - reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
10824 + ii = mpt_handshake_req_reply_wait(ioc, request_size, (u32*)prequest,
10825 + reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
10826
10827 - dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Upload completed rc=%x \n", ioc->name, ii));
10828 + dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FW Upload completed "
10829 + "rc=%x \n", ioc->name, ii));
10830
10831 cmdStatus = -EFAULT;
10832 if (ii == 0) {
10833 /* Handshake transfer was complete and successful.
10834 * Check the Reply Frame.
10835 */
10836 - int status, transfer_sz;
10837 - status = le16_to_cpu(preply->IOCStatus);
10838 - if (status == MPI_IOCSTATUS_SUCCESS) {
10839 - transfer_sz = le32_to_cpu(preply->ActualImageSize);
10840 - if (transfer_sz == sz)
10841 - cmdStatus = 0;
10842 - }
10843 + int status;
10844 + status = le16_to_cpu(preply->IOCStatus) &
10845 + MPI_IOCSTATUS_MASK;
10846 + if (status == MPI_IOCSTATUS_SUCCESS &&
10847 + ioc->facts.FWImageSize ==
10848 + le32_to_cpu(preply->ActualImageSize));
10849 + cmdStatus = 0;
10850 }
10851 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": do_upload cmdStatus=%d \n",
10852 - ioc->name, cmdStatus));
10853 + dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "do_upload cmdStatus=%d \n",
10854 + ioc->name, cmdStatus));
10855
10856
10857 if (cmdStatus) {
10858 -
10859 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": fw upload failed, freeing image \n",
10860 - ioc->name));
10861 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "fw upload failed, "
10862 + "freeing image \n", ioc->name));
10863 mpt_free_fw_memory(ioc);
10864 }
10865 kfree(prequest);
10866 @@ -3376,7 +3532,6 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
10867 return cmdStatus;
10868 }
10869
10870 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
10871 /**
10872 * mpt_downloadboot - DownloadBoot code
10873 * @ioc: Pointer to MPT_ADAPTER structure
10874 @@ -3389,7 +3544,7 @@ mpt_do_upload(MPT_ADAPTER *ioc, int slee
10875 * -1 FW Image size is 0
10876 * -2 No valid cached_fw Pointer
10877 * <0 for fw upload failure.
10878 - */
10879 + **/
10880 static int
10881 mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
10882 {
10883 @@ -3401,10 +3556,10 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10884 u32 diagRwData;
10885 u32 nextImage;
10886 u32 load_addr;
10887 - u32 ioc_state=0;
10888 + u32 doorbell;
10889
10890 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
10891 - ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
10892 + ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
10893
10894 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
10895 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
10896 @@ -3416,11 +3571,10 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10897 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
10898
10899 /* wait 1 msec */
10900 - if (sleepFlag == CAN_SLEEP) {
10901 + if (sleepFlag == CAN_SLEEP)
10902 msleep(1);
10903 - } else {
10904 - mdelay (1);
10905 - }
10906 + else
10907 + mdelay(1);
10908
10909 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
10910 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
10911 @@ -3433,11 +3587,10 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10912 break;
10913 }
10914 /* wait .1 sec */
10915 - if (sleepFlag == CAN_SLEEP) {
10916 + if (sleepFlag == CAN_SLEEP)
10917 msleep (100);
10918 - } else {
10919 + else
10920 mdelay (100);
10921 - }
10922 }
10923
10924 if ( count == 30 ) {
10925 @@ -3455,6 +3608,7 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10926 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
10927
10928 /* Set the DiagRwEn and Disable ARM bits */
10929 + diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
10930 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
10931
10932 fwSize = (pFwHeader->ImageSize + 3)/4;
10933 @@ -3468,13 +3622,12 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10934
10935 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
10936 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "LoadStart addr written 0x%x \n",
10937 - ioc->name, pFwHeader->LoadStartAddress));
10938 + ioc->name, pFwHeader->LoadStartAddress));
10939
10940 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write FW Image: 0x%x bytes @ %p\n",
10941 - ioc->name, fwSize*4, ptrFw));
10942 - while (fwSize--) {
10943 + ioc->name, fwSize*4, ptrFw));
10944 + while (fwSize--)
10945 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
10946 - }
10947
10948 nextImage = pFwHeader->NextImageHeaderOffset;
10949 while (nextImage) {
10950 @@ -3486,21 +3639,22 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10951 ptrFw = (u32 *)pExtImage;
10952
10953 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
10954 - ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
10955 + ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
10956 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
10957
10958 - while (fwSize--) {
10959 + while (fwSize--)
10960 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
10961 - }
10962 nextImage = pExtImage->NextImageHeaderOffset;
10963 }
10964
10965 /* Write the IopResetVectorRegAddr */
10966 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n", ioc->name, pFwHeader->IopResetRegAddr));
10967 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n",
10968 + ioc->name, pFwHeader->IopResetRegAddr));
10969 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
10970
10971 /* Write the IopResetVectorValue */
10972 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
10973 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n",
10974 + ioc->name, pFwHeader->IopResetVectorValue));
10975 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
10976
10977 /* Clear the internal flash bad bit - autoincrementing register,
10978 @@ -3517,75 +3671,75 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
10979 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
10980 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
10981
10982 - } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
10983 - diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
10984 - CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
10985 - MPI_DIAG_CLEAR_FLASH_BAD_SIG);
10986 -
10987 - /* wait 1 msec */
10988 - if (sleepFlag == CAN_SLEEP) {
10989 - msleep (1);
10990 - } else {
10991 - mdelay (1);
10992 - }
10993 }
10994
10995 if (ioc->errata_flag_1064)
10996 pci_disable_io_access(ioc->pcidev);
10997
10998 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
10999 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot diag0val=%x, "
11000 - "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
11001 - ioc->name, diag0val));
11002 - diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
11003 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot now diag0val=%x\n",
11004 - ioc->name, diag0val));
11005 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "diag0val=%x, turning off"
11006 + " PREVENT_IOC_BOOT and DISABLE_ARM\n", ioc->name, diag0val));
11007 + diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM);
11008 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "diag0val=%x\n",
11009 + ioc->name, diag0val));
11010 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
11011
11012 - /* Write 0xFF to reset the sequencer */
11013 - CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
11014 + if (ioc->bus_type == SAS ) {
11015 + /* wait 1 sec */
11016 + if (sleepFlag == CAN_SLEEP)
11017 + msleep(1000);
11018 + else
11019 + mdelay(1000);
11020
11021 - if (ioc->bus_type == SAS) {
11022 - ioc_state = mpt_GetIocState(ioc, 0);
11023 - if ( (GetIocFacts(ioc, sleepFlag,
11024 - MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
11025 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "GetIocFacts failed: IocState=%x\n",
11026 - ioc->name, ioc_state));
11027 - return -EFAULT;
11028 + diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11029 + ddlprintk(ioc, printk (MYIOC_s_DEBUG_FMT
11030 + "diag0val=%x, turning off RW_ENABLE\n", ioc->name,
11031 + diag0val));
11032 + diag0val &= ~(MPI_DIAG_RW_ENABLE);
11033 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11034 + "now diag0val=%x\n", ioc->name, diag0val));
11035 + CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
11036 +
11037 + diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11038 + if (diag0val & MPI_DIAG_FLASH_BAD_SIG) {
11039 + diag0val |= MPI_DIAG_CLEAR_FLASH_BAD_SIG;
11040 + CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
11041 + diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11042 }
11043 + diag0val &= ~(MPI_DIAG_DISABLE_ARM);
11044 + CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
11045 + diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11046 + CHIPREG_WRITE32(&ioc->chip->DiagRwAddress, 0x3f000004);
11047 }
11048
11049 - for (count=0; count<HZ*20; count++) {
11050 - if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
11051 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11052 - "downloadboot successful! (count=%d) IocState=%x\n",
11053 - ioc->name, count, ioc_state));
11054 - if (ioc->bus_type == SAS) {
11055 + /* Write 0xFF to reset the sequencer */
11056 + CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
11057 +
11058 + for (count = 0; count < 30; count ++) {
11059 + doorbell = CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_IOC_STATE_MASK;
11060 + if (doorbell == MPI_IOC_STATE_READY) {
11061 + if (ioc->bus_type == SAS)
11062 return 0;
11063 - }
11064 if ((SendIocInit(ioc, sleepFlag)) != 0) {
11065 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11066 - "downloadboot: SendIocInit failed\n",
11067 - ioc->name));
11068 + ddlprintk(ioc, printk(MYIOC_s_WARN_FMT
11069 + "SendIocInit failed\n", ioc->name));
11070 return -EFAULT;
11071 }
11072 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11073 - "downloadboot: SendIocInit successful\n",
11074 - ioc->name));
11075 + "SendIocInit successful\n", ioc->name));
11076 return 0;
11077 }
11078 - if (sleepFlag == CAN_SLEEP) {
11079 - msleep (10);
11080 - } else {
11081 - mdelay (10);
11082 - }
11083 + ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "looking for READY STATE:"
11084 + " doorbell=%x count=%d\n", ioc->name, doorbell, count));
11085 + if (sleepFlag == CAN_SLEEP)
11086 + msleep(1000);
11087 + else
11088 + mdelay(1000);
11089 }
11090 - ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11091 - "downloadboot failed! IocState=%x\n",ioc->name, ioc_state));
11092 + ddlprintk(ioc, printk(MYIOC_s_WARN_FMT "downloadboot failed! count=%d\n", ioc->name, count));
11093 return -EFAULT;
11094 }
11095
11096 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11097 /**
11098 * KickStart - Perform hard reset of MPT adapter.
11099 * @ioc: Pointer to MPT_ADAPTER structure
11100 @@ -3610,7 +3764,7 @@ mpt_downloadboot(MPT_ADAPTER *ioc, MpiFw
11101 * OR reset but failed to come READY
11102 * -2 - no reset, could not enter DIAG mode
11103 * -3 - reset but bad FW bit
11104 - */
11105 + **/
11106 static int
11107 KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
11108 {
11109 @@ -3618,7 +3772,7 @@ KickStart(MPT_ADAPTER *ioc, int force, i
11110 u32 ioc_state=0;
11111 int cnt,cntdn;
11112
11113 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStarting!\n", ioc->name));
11114 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": KickStart\n", ioc->name));
11115 if (ioc->bus_type == SPI) {
11116 /* Always issue a Msg Unit Reset first. This will clear some
11117 * SCSI bus hang conditions.
11118 @@ -3636,14 +3790,15 @@ KickStart(MPT_ADAPTER *ioc, int force, i
11119 if (hard_reset_done < 0)
11120 return hard_reset_done;
11121
11122 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset successful!\n",
11123 - ioc->name));
11124 + /* may not have worked but hard_reset_done doesn't always signal failure */
11125 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "Diagnostic reset completed!\n",
11126 + ioc->name));
11127
11128 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2; /* 2 seconds */
11129 for (cnt=0; cnt<cntdn; cnt++) {
11130 ioc_state = mpt_GetIocState(ioc, 1);
11131 if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
11132 - dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStart successful! (cnt=%d)\n",
11133 + dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "KickStart successful! (cnt=%d)\n",
11134 ioc->name, cnt));
11135 return hard_reset_done;
11136 }
11137 @@ -3655,11 +3810,10 @@ KickStart(MPT_ADAPTER *ioc, int force, i
11138 }
11139
11140 dinitprintk(ioc, printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
11141 - ioc->name, mpt_GetIocState(ioc, 0)));
11142 + ioc->name, mpt_GetIocState(ioc, 0)));
11143 return -1;
11144 }
11145
11146 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11147 /**
11148 * mpt_diag_reset - Perform hard reset of the adapter.
11149 * @ioc: Pointer to MPT_ADAPTER structure
11150 @@ -3677,30 +3831,46 @@ KickStart(MPT_ADAPTER *ioc, int force, i
11151 * 0 no reset performed because reset history bit set
11152 * -2 enabling diagnostic mode failed
11153 * -3 diagnostic reset failed
11154 - */
11155 + **/
11156 static int
11157 mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
11158 {
11159 u32 diag0val;
11160 - u32 doorbell;
11161 + u32 doorbell = 0;
11162 int hard_reset_done = 0;
11163 int count = 0;
11164 u32 diag1val = 0;
11165 MpiFwHeader_t *cached_fw; /* Pointer to FW */
11166 + u8 cb_idx;
11167
11168 /* Clear any existing interrupts */
11169 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
11170
11171 if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078) {
11172 +
11173 + if (!ignore)
11174 + return 0;
11175 +
11176 drsprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: Doorbell=%p; 1078 reset "
11177 - "address=%p\n", ioc->name, __func__,
11178 - &ioc->chip->Doorbell, &ioc->chip->Reset_1078));
11179 + "address=%p\n", ioc->name, __FUNCTION__, &ioc->chip->Doorbell,
11180 + &ioc->chip->Reset_1078));
11181 CHIPREG_WRITE32(&ioc->chip->Reset_1078, 0x07);
11182 if (sleepFlag == CAN_SLEEP)
11183 msleep(1);
11184 else
11185 mdelay(1);
11186
11187 + /*
11188 + * Call each currently registered protocol IOC reset handler
11189 + * with pre-reset indication.
11190 + * NOTE: If we're doing _IOC_BRINGUP, there can be no
11191 + * MptResetHandlers[] registered yet.
11192 + */
11193 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
11194 + if (MptResetHandlers[cb_idx])
11195 + (*(MptResetHandlers[cb_idx]))(ioc, MPT_IOC_PRE_RESET);
11196 + }
11197 +
11198 for (count = 0; count < 60; count ++) {
11199 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
11200 doorbell &= MPI_IOC_STATE_MASK;
11201 @@ -3709,9 +3879,15 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11202 "looking for READY STATE: doorbell=%x"
11203 " count=%d\n",
11204 ioc->name, doorbell, count));
11205 - if (doorbell == MPI_IOC_STATE_READY) {
11206 +
11207 + if (doorbell == MPI_IOC_STATE_READY)
11208 return 1;
11209 - }
11210 +
11211 + /*
11212 + * Early out for hard fault
11213 + */
11214 + if (count && doorbell == MPI_IOC_STATE_FAULT)
11215 + break;
11216
11217 /* wait 1 sec */
11218 if (sleepFlag == CAN_SLEEP)
11219 @@ -3719,16 +3895,20 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11220 else
11221 mdelay(1000);
11222 }
11223 +
11224 + if (doorbell != MPI_IOC_STATE_READY)
11225 + printk(MYIOC_s_ERR_FMT "Failed to come READY after "
11226 + "reset! IocState=%x", ioc->name, doorbell);
11227 return -1;
11228 }
11229
11230 /* Use "Diagnostic reset" method! (only thing available!) */
11231 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11232
11233 - if (ioc->debug_level & MPT_DEBUG) {
11234 + if (ioc->debug_level & MPT_DEBUG_RESET) {
11235 if (ioc->alt_ioc)
11236 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
11237 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
11238 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
11239 ioc->name, diag0val, diag1val));
11240 }
11241
11242 @@ -3748,11 +3928,10 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11243 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
11244
11245 /* wait 100 msec */
11246 - if (sleepFlag == CAN_SLEEP) {
11247 + if (sleepFlag == CAN_SLEEP)
11248 msleep (100);
11249 - } else {
11250 + else
11251 mdelay (100);
11252 - }
11253
11254 count++;
11255 if (count > 20) {
11256 @@ -3764,14 +3943,14 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11257
11258 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11259
11260 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
11261 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
11262 ioc->name, diag0val));
11263 }
11264
11265 - if (ioc->debug_level & MPT_DEBUG) {
11266 + if (ioc->debug_level & MPT_DEBUG_RESET) {
11267 if (ioc->alt_ioc)
11268 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
11269 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
11270 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
11271 ioc->name, diag0val, diag1val));
11272 }
11273 /*
11274 @@ -3787,7 +3966,7 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11275 */
11276 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
11277 hard_reset_done = 1;
11278 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
11279 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
11280 ioc->name));
11281
11282 /*
11283 @@ -3796,25 +3975,13 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11284 * NOTE: If we're doing _IOC_BRINGUP, there can be no
11285 * MptResetHandlers[] registered yet.
11286 */
11287 - {
11288 - u8 cb_idx;
11289 - int r = 0;
11290 -
11291 - for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
11292 - if (MptResetHandlers[cb_idx]) {
11293 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11294 - "Calling IOC pre_reset handler #%d\n",
11295 - ioc->name, cb_idx));
11296 - r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
11297 - if (ioc->alt_ioc) {
11298 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11299 - "Calling alt-%s pre_reset handler #%d\n",
11300 - ioc->name, ioc->alt_ioc->name, cb_idx));
11301 - r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
11302 - }
11303 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
11304 + if (MptResetHandlers[cb_idx]) {
11305 + mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
11306 + if (ioc->alt_ioc) {
11307 + mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
11308 }
11309 }
11310 - /* FIXME? Examine results here? */
11311 }
11312
11313 if (ioc->cached_fw)
11314 @@ -3834,20 +4001,18 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11315 break;
11316 }
11317
11318 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
11319 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
11320 ioc->name, diag0val, count));
11321 /* wait 1 sec */
11322 - if (sleepFlag == CAN_SLEEP) {
11323 + if (sleepFlag == CAN_SLEEP)
11324 msleep (1000);
11325 - } else {
11326 + else
11327 mdelay (1000);
11328 - }
11329 }
11330 if ((count = mpt_downloadboot(ioc, cached_fw, sleepFlag)) < 0) {
11331 printk(MYIOC_s_WARN_FMT
11332 "firmware downloadboot failure (%d)!\n", ioc->name, count);
11333 }
11334 -
11335 } else {
11336 /* Wait for FW to reload and for board
11337 * to go to the READY state.
11338 @@ -3859,25 +4024,38 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11339 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
11340 doorbell &= MPI_IOC_STATE_MASK;
11341
11342 - if (doorbell == MPI_IOC_STATE_READY) {
11343 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11344 + "looking for READY STATE: doorbell=%x"
11345 + " count=%d\n", ioc->name, doorbell, count));
11346 +
11347 + if (doorbell == MPI_IOC_STATE_READY)
11348 + break;
11349 +
11350 + /*
11351 + * Early out for hard fault
11352 + */
11353 + if (count && doorbell == MPI_IOC_STATE_FAULT)
11354 break;
11355 - }
11356
11357 /* wait 1 sec */
11358 - if (sleepFlag == CAN_SLEEP) {
11359 + if (sleepFlag == CAN_SLEEP)
11360 msleep (1000);
11361 - } else {
11362 + else
11363 mdelay (1000);
11364 - }
11365 }
11366 +
11367 + if (doorbell != MPI_IOC_STATE_READY)
11368 + printk(MYIOC_s_ERR_FMT "Failed to come READY "
11369 + "after reset! IocState=%x", ioc->name,
11370 + doorbell);
11371 }
11372 }
11373
11374 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
11375 - if (ioc->debug_level & MPT_DEBUG) {
11376 + if (ioc->debug_level & MPT_DEBUG_RESET) {
11377 if (ioc->alt_ioc)
11378 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
11379 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
11380 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
11381 ioc->name, diag0val, diag1val));
11382 }
11383
11384 @@ -3898,11 +4076,10 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11385 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
11386
11387 /* wait 100 msec */
11388 - if (sleepFlag == CAN_SLEEP) {
11389 + if (sleepFlag == CAN_SLEEP)
11390 msleep (100);
11391 - } else {
11392 + else
11393 mdelay (100);
11394 - }
11395
11396 count++;
11397 if (count > 20) {
11398 @@ -3933,11 +4110,11 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11399 return -3;
11400 }
11401
11402 - if (ioc->debug_level & MPT_DEBUG) {
11403 + if (ioc->debug_level & MPT_DEBUG_RESET) {
11404 if (ioc->alt_ioc)
11405 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
11406 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
11407 - ioc->name, diag0val, diag1val));
11408 + drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
11409 + ioc->name, diag0val, diag1val));
11410 }
11411
11412 /*
11413 @@ -3951,7 +4128,6 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11414 return hard_reset_done;
11415 }
11416
11417 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11418 /**
11419 * SendIocReset - Send IOCReset request to MPT adapter.
11420 * @ioc: Pointer to MPT_ADAPTER structure
11421 @@ -3962,7 +4138,7 @@ mpt_diag_reset(MPT_ADAPTER *ioc, int ign
11422 * Send IOCReset request to the MPT adapter.
11423 *
11424 * Returns 0 for success, non-zero for failure.
11425 - */
11426 + **/
11427 static int
11428 SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
11429 {
11430 @@ -3973,7 +4149,7 @@ SendIocReset(MPT_ADAPTER *ioc, u8 reset_
11431 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOC reset(0x%02x)!\n",
11432 ioc->name, reset_type));
11433 CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
11434 - if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
11435 + if ((r = WaitForDoorbellAck(ioc, 15, sleepFlag)) < 0)
11436 return r;
11437
11438 /* FW ACK'd request, wait for READY state
11439 @@ -3988,15 +4164,15 @@ SendIocReset(MPT_ADAPTER *ioc, u8 reset_
11440 if (sleepFlag != CAN_SLEEP)
11441 count *= 10;
11442
11443 - printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
11444 - ioc->name, (int)((count+5)/HZ));
11445 + printk(MYIOC_s_ERR_FMT "Wait IOC_READY state (0x%x) timeout(%d)!\n",
11446 + ioc->name, state, (int)((count+5)/HZ));
11447 return -ETIME;
11448 }
11449
11450 if (sleepFlag == CAN_SLEEP) {
11451 msleep(1);
11452 } else {
11453 - mdelay (1); /* 1 msec delay */
11454 + mdelay(1); /* 1 msec delay */
11455 }
11456 }
11457
11458 @@ -4010,14 +4186,13 @@ SendIocReset(MPT_ADAPTER *ioc, u8 reset_
11459 return 0;
11460 }
11461
11462 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11463 /**
11464 * initChainBuffers - Allocate memory for and initialize chain buffers
11465 * @ioc: Pointer to MPT_ADAPTER structure
11466 *
11467 * Allocates memory for and initializes chain buffers,
11468 * chain buffer control arrays and spinlock.
11469 - */
11470 + **/
11471 static int
11472 initChainBuffers(MPT_ADAPTER *ioc)
11473 {
11474 @@ -4059,24 +4234,30 @@ initChainBuffers(MPT_ADAPTER *ioc)
11475 * num_sge = num sge in request frame + last chain buffer
11476 * scale = num sge per chain buffer if no chain element
11477 */
11478 - scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
11479 - if (sizeof(dma_addr_t) == sizeof(u64))
11480 - num_sge = scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
11481 + scale = ioc->req_sz/ ioc->SGE_size;
11482 + if (ioc->sg_addr_size == sizeof(u64))
11483 + num_sge = scale + (ioc->req_sz - 60) / ioc->SGE_size;
11484 else
11485 - num_sge = 1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
11486 + num_sge = 1+ scale + (ioc->req_sz - 64) / ioc->SGE_size;
11487
11488 - if (sizeof(dma_addr_t) == sizeof(u64)) {
11489 + if (ioc->sg_addr_size == sizeof(u64)) {
11490 numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
11491 - (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
11492 + (ioc->req_sz - 60) / ioc->SGE_size;
11493 } else {
11494 numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
11495 - (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
11496 + (ioc->req_sz - 64) / ioc->SGE_size;
11497 }
11498 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "num_sge=%d numSGE=%d\n",
11499 ioc->name, num_sge, numSGE));
11500
11501 - if ( numSGE > MPT_SCSI_SG_DEPTH )
11502 - numSGE = MPT_SCSI_SG_DEPTH;
11503 + if (ioc->bus_type == FC) {
11504 + if (numSGE > MPT_SCSI_FC_SG_DEPTH)
11505 + numSGE = MPT_SCSI_FC_SG_DEPTH;
11506 + }
11507 + else {
11508 + if (numSGE > MPT_SCSI_SG_DEPTH)
11509 + numSGE = MPT_SCSI_SG_DEPTH;
11510 + }
11511
11512 num_chain = 1;
11513 while (numSGE - num_sge > 0) {
11514 @@ -4111,7 +4292,6 @@ initChainBuffers(MPT_ADAPTER *ioc)
11515 return num_chain;
11516 }
11517
11518 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11519 /**
11520 * PrimeIocFifos - Initialize IOC request and reply FIFOs.
11521 * @ioc: Pointer to MPT_ADAPTER structure
11522 @@ -4121,7 +4301,7 @@ initChainBuffers(MPT_ADAPTER *ioc)
11523 * reply frames.
11524 *
11525 * Returns 0 for success, non-zero for failure.
11526 - */
11527 + **/
11528 static int
11529 PrimeIocFifos(MPT_ADAPTER *ioc)
11530 {
11531 @@ -4130,13 +4310,36 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
11532 dma_addr_t alloc_dma;
11533 u8 *mem;
11534 int i, reply_sz, sz, total_size, num_chain;
11535 + u64 dma_mask;
11536
11537 - /* Prime reply FIFO... */
11538 + dma_mask = 0;
11539
11540 + /* Prime reply FIFO... */
11541 if (ioc->reply_frames == NULL) {
11542 if ( (num_chain = initChainBuffers(ioc)) < 0)
11543 return -1;
11544
11545 + /*
11546 + * 1078 errata workaround for the 36GB limitation
11547 + */
11548 + if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078 &&
11549 + ioc->dma_mask > MPT_DMA_35BIT_MASK) {
11550 + if (!pci_set_dma_mask(ioc->pcidev, DMA_32BIT_MASK)
11551 + && !pci_set_consistent_dma_mask(ioc->pcidev,
11552 + DMA_32BIT_MASK)) {
11553 + dma_mask = MPT_DMA_35BIT_MASK;
11554 + d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11555 + "setting 35 bit addressing for "
11556 + "Request/Reply/Chain and Sense Buffers\n",
11557 + ioc->name));
11558 + } else {
11559 + d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11560 + "failed setting 35 bit addressing for "
11561 + "Request/Reply/Chain and Sense Buffers\n",
11562 + ioc->name));
11563 + }
11564 + }
11565 +
11566 total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
11567 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
11568 ioc->name, ioc->reply_sz, ioc->reply_depth));
11569 @@ -4274,9 +4477,16 @@ PrimeIocFifos(MPT_ADAPTER *ioc)
11570 alloc_dma += ioc->reply_sz;
11571 }
11572
11573 + if (dma_mask == MPT_DMA_35BIT_MASK && !pci_set_dma_mask(ioc->pcidev,
11574 + ioc->dma_mask) && !pci_set_consistent_dma_mask(ioc->pcidev,
11575 + ioc->dma_mask))
11576 + d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11577 + "restoring 64 bit addressing\n", ioc->name));
11578 +
11579 return 0;
11580
11581 out_fail:
11582 +
11583 if (ioc->alloc != NULL) {
11584 sz = ioc->alloc_sz;
11585 pci_free_consistent(ioc->pcidev,
11586 @@ -4293,10 +4503,16 @@ out_fail:
11587 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
11588 ioc->sense_buf_pool = NULL;
11589 }
11590 +
11591 + if (dma_mask == MPT_DMA_35BIT_MASK && !pci_set_dma_mask(ioc->pcidev,
11592 + DMA_64BIT_MASK) && !pci_set_consistent_dma_mask(ioc->pcidev,
11593 + DMA_64BIT_MASK))
11594 + d36memprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11595 + "restoring 64 bit addressing\n", ioc->name));
11596 +
11597 return -1;
11598 }
11599
11600 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11601 /**
11602 * mpt_handshake_req_reply_wait - Send MPT request to and receive reply
11603 * from IOC via doorbell handshake method.
11604 @@ -4314,7 +4530,7 @@ out_fail:
11605 * greater than 1 byte in size.
11606 *
11607 * Returns 0 for success, non-zero for failure.
11608 - */
11609 + **/
11610 static int
11611 mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
11612 int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
11613 @@ -4408,7 +4624,6 @@ mpt_handshake_req_reply_wait(MPT_ADAPTER
11614 return -failcnt;
11615 }
11616
11617 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11618 /**
11619 * WaitForDoorbellAck - Wait for IOC doorbell handshake acknowledge
11620 * @ioc: Pointer to MPT_ADAPTER structure
11621 @@ -4420,7 +4635,7 @@ mpt_handshake_req_reply_wait(MPT_ADAPTER
11622 * bit in its IntStatus register being clear.
11623 *
11624 * Returns a negative value on failure, else wait loop count.
11625 - */
11626 + **/
11627 static int
11628 WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
11629 {
11630 @@ -4459,7 +4674,6 @@ WaitForDoorbellAck(MPT_ADAPTER *ioc, int
11631 return -1;
11632 }
11633
11634 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11635 /**
11636 * WaitForDoorbellInt - Wait for IOC to set its doorbell interrupt bit
11637 * @ioc: Pointer to MPT_ADAPTER structure
11638 @@ -4470,7 +4684,7 @@ WaitForDoorbellAck(MPT_ADAPTER *ioc, int
11639 * (MPI_HIS_DOORBELL_INTERRUPT) to be set in the IntStatus register.
11640 *
11641 * Returns a negative value on failure, else wait loop count.
11642 - */
11643 + **/
11644 static int
11645 WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
11646 {
11647 @@ -4481,18 +4695,18 @@ WaitForDoorbellInt(MPT_ADAPTER *ioc, int
11648 cntdn = 1000 * howlong;
11649 if (sleepFlag == CAN_SLEEP) {
11650 while (--cntdn) {
11651 + msleep(1);
11652 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
11653 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
11654 break;
11655 - msleep(1);
11656 count++;
11657 }
11658 } else {
11659 while (--cntdn) {
11660 + udelay (1000);
11661 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
11662 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
11663 break;
11664 - udelay (1000);
11665 count++;
11666 }
11667 }
11668 @@ -4508,7 +4722,6 @@ WaitForDoorbellInt(MPT_ADAPTER *ioc, int
11669 return -1;
11670 }
11671
11672 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11673 /**
11674 * WaitForDoorbellReply - Wait for and capture an IOC handshake reply.
11675 * @ioc: Pointer to MPT_ADAPTER structure
11676 @@ -4520,7 +4733,7 @@ WaitForDoorbellInt(MPT_ADAPTER *ioc, int
11677 * of 128 bytes of reply data.
11678 *
11679 * Returns a negative value on failure, else size of reply in WORDS.
11680 - */
11681 + **/
11682 static int
11683 WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
11684 {
11685 @@ -4594,7 +4807,6 @@ WaitForDoorbellReply(MPT_ADAPTER *ioc, i
11686 return u16cnt/2;
11687 }
11688
11689 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11690 /**
11691 * GetLanConfigPages - Fetch LANConfig pages.
11692 * @ioc: Pointer to MPT_ADAPTER structure
11693 @@ -4604,7 +4816,7 @@ WaitForDoorbellReply(MPT_ADAPTER *ioc, i
11694 * -EPERM if not allowed due to ISR context
11695 * -EAGAIN if no msg frames currently available
11696 * -EFAULT for non-successful reply or no reply (timeout)
11697 - */
11698 + **/
11699 static int
11700 GetLanConfigPages(MPT_ADAPTER *ioc)
11701 {
11702 @@ -4705,7 +4917,6 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
11703 return rc;
11704 }
11705
11706 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11707 /**
11708 * mptbase_sas_persist_operation - Perform operation on SAS Persistent Table
11709 * @ioc: Pointer to MPT_ADAPTER structure
11710 @@ -4718,9 +4929,7 @@ GetLanConfigPages(MPT_ADAPTER *ioc)
11711 * NOTE: Don't use not this function during interrupt time.
11712 *
11713 * Returns 0 for success, non-zero error
11714 - */
11715 -
11716 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11717 + **/
11718 int
11719 mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
11720 {
11721 @@ -4728,7 +4937,14 @@ mptbase_sas_persist_operation(MPT_ADAPTE
11722 SasIoUnitControlReply_t *sasIoUnitCntrReply;
11723 MPT_FRAME_HDR *mf = NULL;
11724 MPIHeader_t *mpi_hdr;
11725 + int ret = 0;
11726 + unsigned long timeleft;
11727 +
11728 + mutex_lock(&ioc->mptbase_cmds.mutex);
11729
11730 + /* init the internal cmd struct */
11731 + memset(ioc->mptbase_cmds.reply, 0 , MPT_DEFAULT_FRAME_SIZE);
11732 + INITIALIZE_MGMT_STATUS(ioc->mptbase_cmds.status)
11733
11734 /* insure garbage is not sent to fw */
11735 switch(persist_opcode) {
11736 @@ -4738,17 +4954,18 @@ mptbase_sas_persist_operation(MPT_ADAPTE
11737 break;
11738
11739 default:
11740 - return -1;
11741 - break;
11742 + ret = -1;
11743 + goto out;
11744 }
11745
11746 - printk("%s: persist_opcode=%x\n",__func__, persist_opcode);
11747 + printk("%s: persist_opcode=%x\n",__FUNCTION__, persist_opcode);
11748
11749 /* Get a MF for this command.
11750 */
11751 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
11752 - printk("%s: no msg frames!\n",__func__);
11753 - return -1;
11754 + printk("%s: no msg frames!\n",__FUNCTION__);
11755 + ret = -1;
11756 + goto out;
11757 }
11758
11759 mpi_hdr = (MPIHeader_t *) mf;
11760 @@ -4758,31 +4975,44 @@ mptbase_sas_persist_operation(MPT_ADAPTE
11761 sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
11762 sasIoUnitCntrReq->Operation = persist_opcode;
11763
11764 - init_timer(&ioc->persist_timer);
11765 - ioc->persist_timer.data = (unsigned long) ioc;
11766 - ioc->persist_timer.function = mpt_timer_expired;
11767 - ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
11768 - ioc->persist_wait_done=0;
11769 - add_timer(&ioc->persist_timer);
11770 mpt_put_msg_frame(mpt_base_index, ioc, mf);
11771 - wait_event(mpt_waitq, ioc->persist_wait_done);
11772 + timeleft = wait_for_completion_timeout(&ioc->mptbase_cmds.done, 10*HZ);
11773 + if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
11774 + ret = -ETIME;
11775 + printk("%s: failed\n", __FUNCTION__);
11776 + if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
11777 + goto out;
11778 + if (!timeleft) {
11779 + printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
11780 + ioc->name, __FUNCTION__);
11781 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
11782 + mpt_HardResetHandler(ioc, CAN_SLEEP);
11783 + mpt_free_msg_frame(ioc, mf);
11784 + }
11785 + goto out;
11786 + }
11787 +
11788 + if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
11789 + ret = -1;
11790 + goto out;
11791 + }
11792
11793 sasIoUnitCntrReply =
11794 - (SasIoUnitControlReply_t *)ioc->persist_reply_frame;
11795 + (SasIoUnitControlReply_t *)ioc->mptbase_cmds.reply;
11796 if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
11797 - printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
11798 - __func__,
11799 - sasIoUnitCntrReply->IOCStatus,
11800 - sasIoUnitCntrReply->IOCLogInfo);
11801 - return -1;
11802 - }
11803 + printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n", __FUNCTION__,
11804 + sasIoUnitCntrReply->IOCStatus, sasIoUnitCntrReply->IOCLogInfo);
11805 + printk("%s: failed\n",__FUNCTION__);
11806 + ret = -1;
11807 + } else
11808 + printk("%s: success\n",__FUNCTION__);
11809 + out:
11810
11811 - printk("%s: success\n",__func__);
11812 - return 0;
11813 + CLEAR_MGMT_STATUS(ioc->mptbase_cmds.status)
11814 + mutex_unlock(&ioc->mptbase_cmds.mutex);
11815 + return ret;
11816 }
11817
11818 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11819 -
11820 static void
11821 mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
11822 MpiEventDataRaid_t * pRaidEventData)
11823 @@ -4913,7 +5143,6 @@ mptbase_raid_process_event_data(MPT_ADAP
11824 }
11825 }
11826
11827 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11828 /**
11829 * GetIoUnitPage2 - Retrieve BIOS version and boot order information.
11830 * @ioc: Pointer to MPT_ADAPTER structure
11831 @@ -4923,7 +5152,7 @@ mptbase_raid_process_event_data(MPT_ADAP
11832 * -EPERM if not allowed due to ISR context
11833 * -EAGAIN if no msg frames currently available
11834 * -EFAULT for non-successful reply or no reply (timeout)
11835 - */
11836 + **/
11837 static int
11838 GetIoUnitPage2(MPT_ADAPTER *ioc)
11839 {
11840 @@ -4971,7 +5200,6 @@ GetIoUnitPage2(MPT_ADAPTER *ioc)
11841 return rc;
11842 }
11843
11844 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11845 /**
11846 * mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
11847 * @ioc: Pointer to a Adapter Strucutre
11848 @@ -4991,7 +5219,7 @@ GetIoUnitPage2(MPT_ADAPTER *ioc)
11849 * Both valid
11850 * Return 0
11851 * CHECK - what type of locking mechanisms should be used????
11852 - */
11853 + **/
11854 static int
11855 mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
11856 {
11857 @@ -5051,8 +5279,8 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
11858 ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
11859 rc = 1;
11860 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11861 - "Unable to read PortPage0 minSyncFactor=%x\n",
11862 - ioc->name, ioc->spi_data.minSyncFactor));
11863 + "Unable to read PortPage0 minSyncFactor=%x\n",
11864 + ioc->name, ioc->spi_data.minSyncFactor));
11865 } else {
11866 /* Save the Port Page 0 data
11867 */
11868 @@ -5062,8 +5290,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
11869
11870 if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
11871 ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
11872 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11873 - "noQas due to Capabilities=%x\n",
11874 + ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "noQas due to Capabilities=%x\n",
11875 ioc->name, pPP0->Capabilities));
11876 }
11877 ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
11878 @@ -5072,8 +5299,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
11879 ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
11880 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
11881 ioc->spi_data.minSyncFactor = (u8) (data >> 8);
11882 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11883 - "PortPage0 minSyncFactor=%x\n",
11884 + ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PortPage0 minSyncFactor=%x\n",
11885 ioc->name, ioc->spi_data.minSyncFactor));
11886 } else {
11887 ioc->spi_data.maxSyncOffset = 0;
11888 @@ -5089,8 +5315,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
11889
11890 if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
11891 ioc->spi_data.minSyncFactor = MPT_ULTRA;
11892 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
11893 - "HVD or SE detected, minSyncFactor=%x\n",
11894 + ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HVD or SE detected, minSyncFactor=%x\n",
11895 ioc->name, ioc->spi_data.minSyncFactor));
11896 }
11897 }
11898 @@ -5195,7 +5420,6 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
11899 return rc;
11900 }
11901
11902 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11903 /**
11904 * mpt_readScsiDevicePageHeaders - save version and length of SDP1
11905 * @ioc: Pointer to a Adapter Strucutre
11906 @@ -5203,7 +5427,7 @@ mpt_GetScsiPortSettings(MPT_ADAPTER *ioc
11907 *
11908 * Return: -EFAULT if read of config page header fails
11909 * or 0 if success.
11910 - */
11911 + **/
11912 static int
11913 mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
11914 {
11915 @@ -5246,9 +5470,73 @@ mpt_readScsiDevicePageHeaders(MPT_ADAPTE
11916 return 0;
11917 }
11918
11919 +static void
11920 +mpt_read_ioc_pg_6(MPT_ADAPTER *ioc)
11921 +{
11922 + CONFIGPARMS cfg;
11923 + ConfigPageHeader_t header;
11924 + IOCPage6_t *pIoc6=NULL;
11925 + dma_addr_t ioc6_dma;
11926 + int iocpage6sz;
11927 + void *mem;
11928 +
11929 + /* Free the old page
11930 + */
11931 + if (ioc->raid_data.pIocPg6) {
11932 + kfree(ioc->raid_data.pIocPg6);
11933 + ioc->raid_data.pIocPg6 = NULL;
11934 + }
11935 +
11936 + /* There is at least one physical disk.
11937 + * Read and save IOC Page 3
11938 + */
11939 + header.PageVersion = 0;
11940 + header.PageLength = 0;
11941 + header.PageNumber = 6;
11942 + header.PageType = MPI_CONFIG_PAGETYPE_IOC;
11943 + cfg.cfghdr.hdr = &header;
11944 + cfg.physAddr = -1;
11945 + cfg.pageAddr = 0;
11946 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
11947 + cfg.dir = 0;
11948 + cfg.timeout = 0;
11949 + if (mpt_config(ioc, &cfg) != 0)
11950 + goto out;
11951 +
11952 + if (header.PageLength == 0)
11953 + goto out;
11954 +
11955 + /* Read Header good, alloc memory
11956 + */
11957 + iocpage6sz = header.PageLength * 4;
11958 + pIoc6 = pci_alloc_consistent(ioc->pcidev, iocpage6sz, &ioc6_dma);
11959 + if (!pIoc6)
11960 + goto out;
11961 +
11962 + /* Read the Page and save the data
11963 + * into malloc'd memory.
11964 + */
11965 + cfg.physAddr = ioc6_dma;
11966 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
11967 + if (mpt_config(ioc, &cfg) != 0)
11968 + goto out;
11969 +
11970 + mem = kmalloc(iocpage6sz, GFP_ATOMIC);
11971 + if (!mem)
11972 + goto out;
11973 +
11974 + memcpy(mem, pIoc6, iocpage6sz);
11975 + ioc->raid_data.pIocPg6 = mem;
11976 +
11977 + out:
11978 + if (pIoc6)
11979 + pci_free_consistent(ioc->pcidev, iocpage6sz, pIoc6, ioc6_dma);
11980 +}
11981 +
11982 /**
11983 - * mpt_inactive_raid_list_free - This clears this link list.
11984 - * @ioc : pointer to per adapter structure
11985 + * mpt_inactive_raid_list_free - This clears this link list.
11986 + * @ioc : pointer to per adapter structure
11987 + *
11988 **/
11989 static void
11990 mpt_inactive_raid_list_free(MPT_ADAPTER *ioc)
11991 @@ -5258,21 +5546,23 @@ mpt_inactive_raid_list_free(MPT_ADAPTER
11992 if (list_empty(&ioc->raid_data.inactive_list))
11993 return;
11994
11995 - mutex_lock(&ioc->raid_data.inactive_list_mutex);
11996 + down(&ioc->raid_data.inactive_list_mutex);
11997 list_for_each_entry_safe(component_info, pNext,
11998 &ioc->raid_data.inactive_list, list) {
11999 list_del(&component_info->list);
12000 kfree(component_info);
12001 }
12002 - mutex_unlock(&ioc->raid_data.inactive_list_mutex);
12003 + up(&ioc->raid_data.inactive_list_mutex);
12004 }
12005
12006 /**
12007 - * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums for devices belonging in an inactive volume
12008 - *
12009 - * @ioc : pointer to per adapter structure
12010 - * @channel : volume channel
12011 - * @id : volume target id
12012 + * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums
12013 + * for devices belonging in an inactive volume
12014 + *
12015 + * @ioc : pointer to per adapter structure
12016 + * @channel : volume channel
12017 + * @id : volume target id
12018 + *
12019 **/
12020 static void
12021 mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
12022 @@ -5281,10 +5571,12 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
12023 ConfigPageHeader_t hdr;
12024 dma_addr_t dma_handle;
12025 pRaidVolumePage0_t buffer = NULL;
12026 - int i;
12027 + int i, j;
12028 RaidPhysDiskPage0_t phys_disk;
12029 + RaidPhysDiskPage1_t *phys_disk_1;
12030 struct inactive_raid_component_info *component_info;
12031 int handle_inactive_volumes;
12032 + int num_paths, device_is_online;
12033
12034 memset(&cfg, 0 , sizeof(CONFIGPARMS));
12035 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
12036 @@ -5323,14 +5615,37 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
12037 if (!handle_inactive_volumes)
12038 goto out;
12039
12040 - mutex_lock(&ioc->raid_data.inactive_list_mutex);
12041 + down(&ioc->raid_data.inactive_list_mutex);
12042 for (i = 0; i < buffer->NumPhysDisks; i++) {
12043 if(mpt_raid_phys_disk_pg0(ioc,
12044 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
12045 continue;
12046
12047 + if (phys_disk.PhysDiskStatus.State !=
12048 + MPI_PHYSDISK0_STATUS_ONLINE)
12049 + continue;
12050 +
12051 + /* check to see if device is online by checking phys_disk_pg1 */
12052 + device_is_online = 0;
12053 + num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
12054 + buffer->PhysDisk[i].PhysDiskNum);
12055 + if (num_paths < 2)
12056 + continue;
12057 + phys_disk_1 = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
12058 + (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
12059 + if (!phys_disk_1)
12060 + continue;
12061 + mpt_raid_phys_disk_pg1(ioc, buffer->PhysDisk[i].PhysDiskNum,
12062 + phys_disk_1);
12063 + for (j = 0; j < num_paths && !device_is_online; j++)
12064 + if (!phys_disk_1->Path[j].Flags)
12065 + device_is_online = 1;
12066 + kfree(phys_disk_1);
12067 + if (!device_is_online)
12068 + continue;
12069 +
12070 if ((component_info = kmalloc(sizeof (*component_info),
12071 - GFP_KERNEL)) == NULL)
12072 + GFP_KERNEL)) == NULL)
12073 continue;
12074
12075 component_info->volumeID = id;
12076 @@ -5343,7 +5658,7 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
12077 list_add_tail(&component_info->list,
12078 &ioc->raid_data.inactive_list);
12079 }
12080 - mutex_unlock(&ioc->raid_data.inactive_list_mutex);
12081 + up(&ioc->raid_data.inactive_list_mutex);
12082
12083 out:
12084 if (buffer)
12085 @@ -5363,7 +5678,7 @@ mpt_inactive_raid_volumes(MPT_ADAPTER *i
12086 * -ENOMEM if pci_alloc failed
12087 **/
12088 int
12089 -mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk)
12090 +mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, RaidPhysDiskPage0_t *phys_disk)
12091 {
12092 CONFIGPARMS cfg;
12093 ConfigPageHeader_t hdr;
12094 @@ -5373,7 +5688,9 @@ mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc,
12095
12096 memset(&cfg, 0 , sizeof(CONFIGPARMS));
12097 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
12098 + memset(phys_disk, 0, sizeof(RaidPhysDiskPage0_t));
12099
12100 + hdr.PageVersion = MPI_RAIDPHYSDISKPAGE0_PAGEVERSION;
12101 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
12102 cfg.cfghdr.hdr = &hdr;
12103 cfg.physAddr = -1;
12104 @@ -5420,6 +5737,181 @@ mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc,
12105 }
12106
12107 /**
12108 + * mpt_raid_phys_disk_get_num_paths - returns number paths associated to this phys_num
12109 + * @ioc: Pointer to a Adapter Structure
12110 + * @phys_disk_num: io unit unique phys disk num generated by the ioc
12111 + *
12112 + * Return:
12113 + * returns number paths
12114 + **/
12115 +int
12116 +mpt_raid_phys_disk_get_num_paths(MPT_ADAPTER *ioc, u8 phys_disk_num)
12117 +{
12118 + CONFIGPARMS cfg;
12119 + ConfigPageHeader_t hdr;
12120 + dma_addr_t dma_handle;
12121 + pRaidPhysDiskPage1_t buffer = NULL;
12122 + int rc;
12123 +
12124 + memset(&cfg, 0 , sizeof(CONFIGPARMS));
12125 + memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
12126 +
12127 + hdr.PageVersion = MPI_RAIDPHYSDISKPAGE1_PAGEVERSION;
12128 + hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
12129 + hdr.PageNumber = 1;
12130 + cfg.cfghdr.hdr = &hdr;
12131 + cfg.physAddr = -1;
12132 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
12133 +
12134 + if (mpt_config(ioc, &cfg) != 0) {
12135 + rc = 0;
12136 + goto out;
12137 + }
12138 +
12139 + if (!hdr.PageLength) {
12140 + rc = 0;
12141 + goto out;
12142 + }
12143 +
12144 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
12145 + &dma_handle);
12146 +
12147 + if (!buffer) {
12148 + rc = 0;
12149 + goto out;
12150 + }
12151 +
12152 + cfg.physAddr = dma_handle;
12153 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
12154 + cfg.pageAddr = phys_disk_num;
12155 +
12156 + if (mpt_config(ioc, &cfg) != 0) {
12157 + rc = 0;
12158 + goto out;
12159 + }
12160 +
12161 + rc = buffer->NumPhysDiskPaths;
12162 + out:
12163 +
12164 + if (buffer)
12165 + pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
12166 + dma_handle);
12167 +
12168 + return rc;
12169 +}
12170 +
12171 +/**
12172 + * mpt_raid_phys_disk_pg1 - returns phys disk page 1
12173 + * @ioc: Pointer to a Adapter Structure
12174 + * @phys_disk_num: io unit unique phys disk num generated by the ioc
12175 + * @phys_disk: requested payload data returned
12176 + *
12177 + * Return:
12178 + * 0 on success
12179 + * -EFAULT if read of config page header fails or data pointer not NULL
12180 + * -ENOMEM if pci_alloc failed
12181 + **/
12182 +int
12183 +mpt_raid_phys_disk_pg1(MPT_ADAPTER *ioc, u8 phys_disk_num, RaidPhysDiskPage1_t *phys_disk)
12184 +{
12185 + CONFIGPARMS cfg;
12186 + ConfigPageHeader_t hdr;
12187 + dma_addr_t dma_handle;
12188 + pRaidPhysDiskPage1_t buffer = NULL;
12189 + int rc;
12190 + int i;
12191 + __le64 sas_address;
12192 +
12193 + memset(&cfg, 0 , sizeof(CONFIGPARMS));
12194 + memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
12195 + rc = 0;
12196 +
12197 + hdr.PageVersion = MPI_RAIDPHYSDISKPAGE1_PAGEVERSION;
12198 + hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
12199 + hdr.PageNumber = 1;
12200 + cfg.cfghdr.hdr = &hdr;
12201 + cfg.physAddr = -1;
12202 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
12203 +
12204 + if (mpt_config(ioc, &cfg) != 0) {
12205 + rc = -EFAULT;
12206 + goto out;
12207 + }
12208 +
12209 + if (!hdr.PageLength) {
12210 + rc = -EFAULT;
12211 + goto out;
12212 + }
12213 +
12214 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
12215 + &dma_handle);
12216 +
12217 + if (!buffer) {
12218 + rc = -ENOMEM;
12219 + goto out;
12220 + }
12221 +
12222 + cfg.physAddr = dma_handle;
12223 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
12224 + cfg.pageAddr = phys_disk_num;
12225 +
12226 + if (mpt_config(ioc, &cfg) != 0) {
12227 + rc = -EFAULT;
12228 + goto out;
12229 + }
12230 +
12231 + phys_disk->NumPhysDiskPaths = buffer->NumPhysDiskPaths;
12232 + phys_disk->PhysDiskNum = phys_disk_num;
12233 + for (i = 0; i < phys_disk->NumPhysDiskPaths; i++) {
12234 + phys_disk->Path[i].PhysDiskID = buffer->Path[i].PhysDiskID;
12235 + phys_disk->Path[i].PhysDiskBus = buffer->Path[i].PhysDiskBus;
12236 + phys_disk->Path[i].OwnerIdentifier = buffer->Path[i].OwnerIdentifier;
12237 + phys_disk->Path[i].Flags = le16_to_cpu(buffer->Path[i].Flags);
12238 + memcpy(&sas_address, &buffer->Path[i].WWID, sizeof(__le64));
12239 + sas_address = le64_to_cpu(sas_address);
12240 + memcpy(&phys_disk->Path[i].WWID, &sas_address, sizeof(__le64));
12241 + memcpy(&sas_address, &buffer->Path[i].OwnerWWID, sizeof(__le64));
12242 + sas_address = le64_to_cpu(sas_address);
12243 + memcpy(&phys_disk->Path[i].OwnerWWID, &sas_address, sizeof(__le64));
12244 + }
12245 +
12246 + out:
12247 +
12248 + if (buffer)
12249 + pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
12250 + dma_handle);
12251 +
12252 + return rc;
12253 +}
12254 +
12255 +/**
12256 + * mpt_sort_ioc_pg2 - compare function for sorting volumes
12257 + * in ascending order
12258 + * @a: ioc_pg2 raid volume page
12259 + * @b: ioc_pg2 raid volume page
12260 + *
12261 + * Return:
12262 + * 0 same, 1 (a is bigger), -1 (b is bigger)
12263 + **/
12264 +static int
12265 +mpt_sort_ioc_pg2(const void *a, const void *b)
12266 +{
12267 + ConfigPageIoc2RaidVol_t * volume_a = (ConfigPageIoc2RaidVol_t *)a;
12268 + ConfigPageIoc2RaidVol_t * volume_b = (ConfigPageIoc2RaidVol_t *)b;
12269 +
12270 + if (volume_a->VolumeBus == volume_b->VolumeBus) {
12271 + if (volume_a->VolumeID == volume_b->VolumeID)
12272 + return 0;
12273 + if (volume_a->VolumeID < volume_b->VolumeID)
12274 + return -1;
12275 + return 1;
12276 + }
12277 + if (volume_a->VolumeBus < volume_b->VolumeBus)
12278 + return -1;
12279 + return 1;
12280 +}
12281 +
12282 +/**
12283 * mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
12284 * @ioc: Pointer to a Adapter Strucutre
12285 * @portnum: IOC port number
12286 @@ -5482,16 +5974,22 @@ mpt_findImVolumes(MPT_ADAPTER *ioc)
12287 if (!mem)
12288 goto out;
12289
12290 + /*
12291 + * sort volumes in ascending order
12292 + */
12293 + sort(pIoc2->RaidVolume, pIoc2->NumActiveVolumes,
12294 + sizeof(ConfigPageIoc2RaidVol_t), mpt_sort_ioc_pg2, NULL);
12295 memcpy(mem, (u8 *)pIoc2, iocpage2sz);
12296 ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
12297
12298 - mpt_read_ioc_pg_3(ioc);
12299 -
12300 for (i = 0; i < pIoc2->NumActiveVolumes ; i++)
12301 mpt_inactive_raid_volumes(ioc,
12302 pIoc2->RaidVolume[i].VolumeBus,
12303 pIoc2->RaidVolume[i].VolumeID);
12304
12305 + mpt_read_ioc_pg_3(ioc);
12306 + mpt_read_ioc_pg_6(ioc);
12307 +
12308 out:
12309 pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
12310
12311 @@ -5651,6 +6149,9 @@ mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
12312 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
12313 if (mpt_config(ioc, &cfg) == 0) {
12314
12315 +#if defined(CPQ_CIM)
12316 + ioc->pci_slot_number = pIoc1->PCISlotNum;
12317 +#endif
12318 tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
12319 if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
12320 tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
12321 @@ -5671,19 +6172,16 @@ mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
12322
12323 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
12324 if (mpt_config(ioc, &cfg) == 0) {
12325 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12326 - "Reset NVRAM Coalescing Timeout to = %d\n",
12327 + dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset NVRAM Coalescing Timeout to = %d\n",
12328 ioc->name, MPT_COALESCING_TIMEOUT));
12329 } else {
12330 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12331 - "Reset NVRAM Coalescing Timeout Failed\n",
12332 - ioc->name));
12333 + dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset NVRAM Coalescing Timeout Failed\n",
12334 + ioc->name));
12335 }
12336
12337 } else {
12338 - dprintk(ioc, printk(MYIOC_s_WARN_FMT
12339 - "Reset of Current Coalescing Timeout Failed!\n",
12340 - ioc->name));
12341 + dprintk(ioc, printk(MYIOC_s_WARN_FMT "Reset of Current Coalescing Timeout Failed!\n",
12342 + ioc->name));
12343 }
12344 }
12345
12346 @@ -5740,43 +6238,39 @@ mpt_get_manufacturing_pg_0(MPT_ADAPTER *
12347 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
12348 }
12349
12350 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12351 /**
12352 * SendEventNotification - Send EventNotification (on or off) request to adapter
12353 * @ioc: Pointer to MPT_ADAPTER structure
12354 * @EvSwitch: Event switch flags
12355 - */
12356 + * @sleepFlag: Specifies whether the process can sleep
12357 + **/
12358 static int
12359 -SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
12360 +SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch, int sleepFlag)
12361 {
12362 - EventNotification_t *evnp;
12363 -
12364 - evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
12365 - if (evnp == NULL) {
12366 - devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
12367 - ioc->name));
12368 - return 0;
12369 - }
12370 - memset(evnp, 0, sizeof(*evnp));
12371 + EventNotification_t evn;
12372 + MPIDefaultReply_t reply_buf;
12373
12374 - devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
12375 + memset(&evn, 0, sizeof(EventNotification_t));
12376 + memset(&reply_buf, 0, sizeof(MPIDefaultReply_t));
12377
12378 - evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
12379 - evnp->ChainOffset = 0;
12380 - evnp->MsgFlags = 0;
12381 - evnp->Switch = EvSwitch;
12382 + evn.Function = MPI_FUNCTION_EVENT_NOTIFICATION;
12383 + evn.Switch = EvSwitch;
12384 + evn.MsgContext = cpu_to_le32(mpt_base_index << 16);
12385
12386 - mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
12387 + devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12388 + "Sending EventNotification (%d) request %p\n",
12389 + ioc->name, EvSwitch, &evn));
12390
12391 - return 0;
12392 + return mpt_handshake_req_reply_wait(ioc, sizeof(EventNotification_t),
12393 + (u32*)&evn, sizeof(MPIDefaultReply_t), (u16*)&reply_buf, 30,
12394 + sleepFlag);
12395 }
12396
12397 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12398 /**
12399 * SendEventAck - Send EventAck request to MPT adapter.
12400 * @ioc: Pointer to MPT_ADAPTER structure
12401 * @evnp: Pointer to original EventNotification request
12402 - */
12403 + **/
12404 static int
12405 SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
12406 {
12407 @@ -5784,7 +6278,7 @@ SendEventAck(MPT_ADAPTER *ioc, EventNoti
12408
12409 if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
12410 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
12411 - ioc->name,__func__));
12412 + ioc->name,__FUNCTION__));
12413 return -1;
12414 }
12415
12416 @@ -5803,7 +6297,6 @@ SendEventAck(MPT_ADAPTER *ioc, EventNoti
12417 return 0;
12418 }
12419
12420 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12421 /**
12422 * mpt_config - Generic function to issue config message
12423 * @ioc: Pointer to an adapter structure
12424 @@ -5816,35 +6309,62 @@ SendEventAck(MPT_ADAPTER *ioc, EventNoti
12425 * -EPERM if not allowed due to ISR context
12426 * -EAGAIN if no msg frames currently available
12427 * -EFAULT for non-successful reply or no reply (timeout)
12428 - */
12429 + **/
12430 int
12431 mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
12432 {
12433 Config_t *pReq;
12434 + ConfigReply_t *pReply;
12435 ConfigExtendedPageHeader_t *pExtHdr = NULL;
12436 MPT_FRAME_HDR *mf;
12437 - unsigned long flags;
12438 - int ii, rc;
12439 + int ii;
12440 int flagsLength;
12441 - int in_isr;
12442 + long timeout;
12443 + int ret;
12444 + u8 page_type = 0, extend_page;
12445 + unsigned long timeleft;
12446 + unsigned long flags;
12447 + u8 issue_hard_reset = 0;
12448 + u8 retry_count = 0;
12449
12450 - /* Prevent calling wait_event() (below), if caller happens
12451 - * to be in ISR context, because that is fatal!
12452 - */
12453 - in_isr = in_interrupt();
12454 - if (in_isr) {
12455 - dcprintk(ioc, printk(MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
12456 - ioc->name));
12457 + if (in_interrupt())
12458 return -EPERM;
12459 +
12460 + /* don't send a config page during diag reset */
12461 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
12462 + if (ioc->ioc_reset_in_progress) {
12463 + dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12464 + "%s: busy with host reset\n", ioc->name, __FUNCTION__));
12465 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12466 + return -EBUSY;
12467 + }
12468 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12469 +
12470 + /* don't send if no chance of success */
12471 + if (!ioc->active ||
12472 + mpt_GetIocState(ioc, 1) != MPI_IOC_STATE_OPERATIONAL) {
12473 + dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12474 + "%s: ioc not operational, %d, %xh\n",
12475 + ioc->name, __FUNCTION__, ioc->active,
12476 + mpt_GetIocState(ioc, 0)));
12477 + return -EFAULT;
12478 }
12479
12480 + retry_config:
12481 + mutex_lock(&ioc->mptbase_cmds.mutex);
12482 + /* init the internal cmd struct */
12483 + memset(ioc->mptbase_cmds.reply, 0 , MPT_DEFAULT_FRAME_SIZE);
12484 + INITIALIZE_MGMT_STATUS(ioc->mptbase_cmds.status)
12485 +
12486 /* Get and Populate a free Frame
12487 */
12488 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
12489 - dcprintk(ioc, printk(MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
12490 - ioc->name));
12491 - return -EAGAIN;
12492 + dcprintk(ioc, printk(MYIOC_s_WARN_FMT
12493 + "mpt_config: no msg frames!\n", ioc->name));
12494 + ret = -EAGAIN;
12495 + goto out;
12496 }
12497 +
12498 pReq = (Config_t *)mf;
12499 pReq->Action = pCfg->action;
12500 pReq->Reserved = 0;
12501 @@ -5870,7 +6390,9 @@ mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS
12502 pReq->ExtPageType = pExtHdr->ExtPageType;
12503 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
12504
12505 - /* Page Length must be treated as a reserved field for the extended header. */
12506 + /* Page Length must be treated as a reserved field for the
12507 + * extended header.
12508 + */
12509 pReq->Header.PageLength = 0;
12510 }
12511
12512 @@ -5883,126 +6405,126 @@ mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS
12513 else
12514 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
12515
12516 - if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
12517 + if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) ==
12518 + MPI_CONFIG_PAGETYPE_EXTENDED) {
12519 flagsLength |= pExtHdr->ExtPageLength * 4;
12520 -
12521 - dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
12522 - ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
12523 - }
12524 - else {
12525 + page_type = pReq->ExtPageType;
12526 + extend_page = 1;
12527 + } else {
12528 flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
12529 -
12530 - dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
12531 - ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
12532 + page_type = pReq->Header.PageType;
12533 + extend_page = 0;
12534 }
12535
12536 - mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
12537 + dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12538 + "Sending Config request type 0x%x, page 0x%x and action %d\n",
12539 + ioc->name, page_type, pReq->Header.PageNumber, pReq->Action));
12540
12541 - /* Append pCfg pointer to end of mf
12542 - */
12543 - *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
12544 -
12545 - /* Initalize the timer
12546 - */
12547 - init_timer(&pCfg->timer);
12548 - pCfg->timer.data = (unsigned long) ioc;
12549 - pCfg->timer.function = mpt_timer_expired;
12550 - pCfg->wait_done = 0;
12551 -
12552 - /* Set the timer; ensure 10 second minimum */
12553 - if (pCfg->timeout < 10)
12554 - pCfg->timer.expires = jiffies + HZ*10;
12555 - else
12556 - pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
12557 -
12558 - /* Add to end of Q, set timer and then issue this command */
12559 - spin_lock_irqsave(&ioc->FreeQlock, flags);
12560 - list_add_tail(&pCfg->linkage, &ioc->configQ);
12561 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
12562 -
12563 - add_timer(&pCfg->timer);
12564 + ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
12565 + timeout = (pCfg->timeout < 15) ? HZ*15 : HZ*pCfg->timeout;
12566 mpt_put_msg_frame(mpt_base_index, ioc, mf);
12567 - wait_event(mpt_waitq, pCfg->wait_done);
12568 -
12569 - /* mf has been freed - do not access */
12570 -
12571 - rc = pCfg->status;
12572 + timeleft = wait_for_completion_timeout(&ioc->mptbase_cmds.done, timeout);
12573 + if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
12574 + ret = -ETIME;
12575 + dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12576 + "Failed Sending Config request type 0x%x, page 0x%x,"
12577 + " action %d, status %xh, time left %ld\n\n",
12578 + ioc->name, page_type, pReq->Header.PageNumber,
12579 + pReq->Action, ioc->mptbase_cmds.status, timeleft));
12580 + if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
12581 + goto out;
12582 + if (!timeleft)
12583 + issue_hard_reset = 1;
12584 + goto out;
12585 + }
12586
12587 - return rc;
12588 -}
12589 + if (!(ioc->mptbase_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
12590 + ret = -1;
12591 + goto out;
12592 + }
12593 + pReply = (ConfigReply_t *)ioc->mptbase_cmds.reply;
12594 + ret = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
12595 + if (ret == MPI_IOCSTATUS_SUCCESS) {
12596 + if (extend_page) {
12597 + pCfg->cfghdr.ehdr->ExtPageLength =
12598 + le16_to_cpu(pReply->ExtPageLength);
12599 + pCfg->cfghdr.ehdr->ExtPageType =
12600 + pReply->ExtPageType;
12601 + }
12602 + pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
12603 + pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
12604 + pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
12605 + pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
12606
12607 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12608 -/**
12609 - * mpt_timer_expired - Callback for timer process.
12610 - * Used only internal config functionality.
12611 - * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
12612 - */
12613 -static void
12614 -mpt_timer_expired(unsigned long data)
12615 -{
12616 - MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
12617 + }
12618
12619 - dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired! \n", ioc->name));
12620 + if (retry_count)
12621 + printk(MYIOC_s_INFO_FMT "Retry completed ret=0x%x timeleft=%ld\n",
12622 + ioc->name, ret, timeleft);
12623
12624 - /* Perform a FW reload */
12625 - if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
12626 - printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
12627 + dcprintk(ioc, printk(KERN_DEBUG "IOCStatus=%04xh, IOCLogInfo=%08xh\n",
12628 + ret, le32_to_cpu(pReply->IOCLogInfo)));
12629
12630 - /* No more processing.
12631 - * Hard reset clean-up will wake up
12632 - * process and free all resources.
12633 - */
12634 - dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired complete!\n", ioc->name));
12635 + out:
12636
12637 - return;
12638 + CLEAR_MGMT_STATUS(ioc->mptbase_cmds.status)
12639 + mutex_unlock(&ioc->mptbase_cmds.mutex);
12640 + if (issue_hard_reset) {
12641 + issue_hard_reset = 0;
12642 + printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
12643 + ioc->name, __FUNCTION__);
12644 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
12645 + mpt_HardResetHandler(ioc, CAN_SLEEP);
12646 + mpt_free_msg_frame(ioc, mf);
12647 + /* attempt one retry for a timed out command */
12648 + if (!retry_count) {
12649 + printk(MYIOC_s_INFO_FMT
12650 + "Attempting Retry Config request type 0x%x, page 0x%x,"
12651 + " action %d\n", ioc->name, page_type,
12652 + pCfg->cfghdr.hdr->PageNumber, pCfg->action);
12653 + retry_count++;
12654 + goto retry_config;
12655 + }
12656 + }
12657 + return ret;
12658 }
12659
12660 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12661 -/**
12662 - * mpt_ioc_reset - Base cleanup for hard reset
12663 - * @ioc: Pointer to the adapter structure
12664 - * @reset_phase: Indicates pre- or post-reset functionality
12665 - *
12666 - * Remark: Frees resources with internally generated commands.
12667 - */
12668 -static int
12669 -mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
12670 -{
12671 - CONFIGPARMS *pCfg;
12672 - unsigned long flags;
12673 -
12674 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12675 - ": IOC %s_reset routed to MPT base driver!\n",
12676 - ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
12677 - reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
12678 -
12679 - if (reset_phase == MPT_IOC_SETUP_RESET) {
12680 - ;
12681 - } else if (reset_phase == MPT_IOC_PRE_RESET) {
12682 - /* If the internal config Q is not empty -
12683 - * delete timer. MF resources will be freed when
12684 - * the FIFO's are primed.
12685 - */
12686 - spin_lock_irqsave(&ioc->FreeQlock, flags);
12687 - list_for_each_entry(pCfg, &ioc->configQ, linkage)
12688 - del_timer(&pCfg->timer);
12689 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
12690 -
12691 - } else {
12692 - CONFIGPARMS *pNext;
12693 -
12694 - /* Search the configQ for internal commands.
12695 - * Flush the Q, and wake up all suspended threads.
12696 - */
12697 - spin_lock_irqsave(&ioc->FreeQlock, flags);
12698 - list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
12699 - list_del(&pCfg->linkage);
12700 -
12701 - pCfg->status = MPT_CONFIG_ERROR;
12702 - pCfg->wait_done = 1;
12703 - wake_up(&mpt_waitq);
12704 +/**
12705 + * mpt_ioc_reset - Base cleanup for hard reset
12706 + * @ioc: Pointer to the adapter structure
12707 + * @reset_phase: Indicates pre- or post-reset functionality
12708 + *
12709 + * Remark: Frees resources with internally generated commands.
12710 + **/
12711 +static int
12712 +mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
12713 +{
12714 + switch(reset_phase) {
12715 + case MPT_IOC_SETUP_RESET:
12716 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12717 + "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
12718 + ioc->taskmgmt_quiesce_io = 1;
12719 + break;
12720 + case MPT_IOC_PRE_RESET:
12721 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12722 + "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
12723 + break;
12724 + case MPT_IOC_POST_RESET:
12725 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12726 + "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
12727 +/* wake up mptbase_cmds */
12728 + if (ioc->mptbase_cmds.status & MPT_MGMT_STATUS_PENDING) {
12729 + ioc->mptbase_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
12730 + complete(&ioc->mptbase_cmds.done);
12731 + }
12732 +/* wake up taskmgmt_cmds */
12733 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
12734 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
12735 + complete(&ioc->taskmgmt_cmds.done);
12736 }
12737 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
12738 + break;
12739 + default:
12740 + break;
12741 }
12742
12743 return 1; /* currently means nothing really */
12744 @@ -6010,16 +6532,11 @@ mpt_ioc_reset(MPT_ADAPTER *ioc, int rese
12745
12746
12747 #ifdef CONFIG_PROC_FS /* { */
12748 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12749 -/*
12750 - * procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
12751 - */
12752 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12753 /**
12754 * procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
12755 *
12756 * Returns 0 for success, non-zero for failure.
12757 - */
12758 + **/
12759 static int
12760 procmpt_create(void)
12761 {
12762 @@ -6040,12 +6557,11 @@ procmpt_create(void)
12763 return 0;
12764 }
12765
12766 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12767 /**
12768 * procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
12769 *
12770 * Returns 0 for success, non-zero for failure.
12771 - */
12772 + **/
12773 static void
12774 procmpt_destroy(void)
12775 {
12776 @@ -6054,7 +6570,6 @@ procmpt_destroy(void)
12777 remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
12778 }
12779
12780 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12781 /**
12782 * procmpt_summary_read - Handle read request of a summary file
12783 * @buf: Pointer to area to write information
12784 @@ -6066,7 +6581,7 @@ procmpt_destroy(void)
12785 *
12786 * Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
12787 * Returns number of characters written to process performing the read.
12788 - */
12789 + **/
12790 static int
12791 procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
12792 {
12793 @@ -6098,7 +6613,6 @@ procmpt_summary_read(char *buf, char **s
12794 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
12795 }
12796
12797 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12798 /**
12799 * procmpt_version_read - Handle read request from /proc/mpt/version.
12800 * @buf: Pointer to area to write information
12801 @@ -6109,7 +6623,7 @@ procmpt_summary_read(char *buf, char **s
12802 * @data: Pointer
12803 *
12804 * Returns number of characters written to process performing the read.
12805 - */
12806 + **/
12807 static int
12808 procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
12809 {
12810 @@ -6154,7 +6668,6 @@ procmpt_version_read(char *buf, char **s
12811 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
12812 }
12813
12814 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12815 /**
12816 * procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
12817 * @buf: Pointer to area to write information
12818 @@ -6165,7 +6678,7 @@ procmpt_version_read(char *buf, char **s
12819 * @data: Pointer
12820 *
12821 * Returns number of characters written to process performing the read.
12822 - */
12823 + **/
12824 static int
12825 procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
12826 {
12827 @@ -6251,7 +6764,6 @@ procmpt_iocinfo_read(char *buf, char **s
12828
12829 #endif /* CONFIG_PROC_FS } */
12830
12831 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12832 static void
12833 mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
12834 {
12835 @@ -6267,7 +6779,6 @@ mpt_get_fw_exp_ver(char *buf, MPT_ADAPTE
12836 }
12837 }
12838
12839 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12840 /**
12841 * mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
12842 * @ioc: Pointer to MPT_ADAPTER structure
12843 @@ -6278,7 +6789,7 @@ mpt_get_fw_exp_ver(char *buf, MPT_ADAPTE
12844 *
12845 * This routine writes (english readable) ASCII text, which represents
12846 * a summary of IOC information, to a buffer.
12847 - */
12848 + **/
12849 void
12850 mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
12851 {
12852 @@ -6319,6 +6830,220 @@ mpt_print_ioc_summary(MPT_ADAPTER *ioc,
12853 /*
12854 * Reset Handling
12855 */
12856 +
12857 +/**
12858 + * mpt_set_taskmgmt_in_progress_flag - set flags associated with task managment
12859 + * @ioc: Pointer to MPT_ADAPTER structure
12860 + *
12861 + * Returns 0 for SUCCESS or -1 if FAILED.
12862 + *
12863 + * If -1 is return, then it was not possible to set the flags
12864 + **/
12865 +int
12866 +mpt_set_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc)
12867 +{
12868 + unsigned long flags;
12869 + int retval;
12870 +
12871 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
12872 + if (ioc->ioc_reset_in_progress || ioc->taskmgmt_in_progress ||
12873 + (ioc->alt_ioc && ioc->alt_ioc->taskmgmt_in_progress)) {
12874 + retval = -1;
12875 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12876 + goto out;
12877 + }
12878 + retval = 0;
12879 + ioc->taskmgmt_in_progress = 1;
12880 + ioc->taskmgmt_quiesce_io = 1;
12881 + if (ioc->alt_ioc) {
12882 + ioc->alt_ioc->taskmgmt_in_progress = 1;
12883 + ioc->alt_ioc->taskmgmt_quiesce_io = 1;
12884 + }
12885 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12886 +
12887 + out:
12888 + return retval;
12889 +}
12890 +
12891 +/**
12892 + * mpt_clear_taskmgmt_in_progress_flag - clear flags associated with task managment
12893 + * @ioc: Pointer to MPT_ADAPTER structure
12894 + *
12895 + **/
12896 +void
12897 +mpt_clear_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc)
12898 +{
12899 + unsigned long flags;
12900 +
12901 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
12902 + ioc->taskmgmt_in_progress = 0;
12903 + ioc->taskmgmt_quiesce_io = 0;
12904 + if (ioc->alt_ioc) {
12905 + ioc->alt_ioc->taskmgmt_in_progress = 0;
12906 + ioc->alt_ioc->taskmgmt_quiesce_io = 0;
12907 + }
12908 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12909 +}
12910 +
12911 +/**
12912 + * mpt_halt_firmware - Halts the firmware if it is operational and panic
12913 + * the kernel
12914 + * @ioc: Pointer to MPT_ADAPTER structure
12915 + *
12916 + **/
12917 +void
12918 +mpt_halt_firmware(MPT_ADAPTER *ioc)
12919 +{
12920 + u32 ioc_raw_state;
12921 +
12922 + ioc_raw_state = mpt_GetIocState(ioc, 0);
12923 +
12924 + if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
12925 + printk(MYIOC_s_ERR_FMT "IOC is in FAULT state (%04xh)!!!\n",
12926 + ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
12927 + if(mpt_fwfault_debug == 2)
12928 + for(;;);
12929 + else
12930 + panic("%s: IOC Fault (%04xh)!!!\n",ioc->name,
12931 + ioc_raw_state & MPI_DOORBELL_DATA_MASK);
12932 + } else {
12933 + CHIPREG_WRITE32(&ioc->chip->Doorbell, 0xC0FFEE00);
12934 + if(mpt_fwfault_debug == 2) {
12935 + printk("%s: Firmware is halted due to command timeout\n"
12936 + ,ioc->name);
12937 + for(;;);
12938 + }
12939 + else
12940 + panic("%s: Firmware is halted due to command timeout\n",
12941 + ioc->name);
12942 + }
12943 +}
12944 +
12945 +/**
12946 + * mpt_SoftResetHandler - Issues a less expensive reset
12947 + * @ioc: Pointer to MPT_ADAPTER structure
12948 + * @sleepFlag: Indicates if sleep or schedule must be called.
12949 +
12950 + *
12951 + * Returns 0 for SUCCESS or -1 if FAILED.
12952 + *
12953 + * Message Unit Reset - instructs the IOC to reset the Reply Post and
12954 + * Free FIFO's. All the Message Frames on Reply Free FIFO are discarded.
12955 + * All posted buffers are freed, and event notification is turned off.
12956 + * IOC doesnt reply to any outstanding request. This will transfer IOC
12957 + * to READY state.
12958 + **/
12959 +int
12960 +mpt_SoftResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
12961 +{
12962 + int rc;
12963 + int ii;
12964 + u8 cb_idx;
12965 + unsigned long flags;
12966 + u32 ioc_state;
12967 + unsigned long time_count;
12968 +
12969 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SoftResetHandler Entered!\n", ioc->name));
12970 +
12971 + ioc_state = mpt_GetIocState(ioc, 0) & MPI_IOC_STATE_MASK;
12972 +
12973 + if(mpt_fwfault_debug)
12974 + mpt_halt_firmware(ioc);
12975 +
12976 + if (ioc_state == MPI_IOC_STATE_FAULT || ioc_state == MPI_IOC_STATE_RESET) {
12977 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
12978 + "skipping, either in FAULT or RESET state!\n", ioc->name));
12979 + return -1;
12980 + }
12981 +
12982 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
12983 + if (ioc->ioc_reset_in_progress) {
12984 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12985 + return -1;
12986 + }
12987 + ioc->ioc_reset_in_progress = 1;
12988 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
12989 +
12990 + rc = -1;
12991 +
12992 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
12993 + if (MptResetHandlers[cb_idx])
12994 + mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
12995 + }
12996 +
12997 + /* Disable reply interrupts (also blocks FreeQ) */
12998 + CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
12999 + ioc->active = 0;
13000 + time_count = jiffies;
13001 +
13002 + rc = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);
13003 +
13004 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
13005 + if (MptResetHandlers[cb_idx])
13006 + mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
13007 + }
13008 +
13009 + if (rc)
13010 + goto out;
13011 +
13012 + ioc_state = mpt_GetIocState(ioc, 0) & MPI_IOC_STATE_MASK;
13013 + if (ioc_state != MPI_IOC_STATE_READY)
13014 + goto out;
13015 +
13016 + for (ii = 0; ii < 5; ii++) {
13017 + /* Get IOC facts! Allow 5 retries */
13018 + if ((rc = GetIocFacts(ioc, sleepFlag,
13019 + MPT_HOSTEVENT_IOC_RECOVER)) == 0)
13020 + break;
13021 + if (sleepFlag == CAN_SLEEP) {
13022 + msleep(100);
13023 + } else {
13024 + mdelay(100);
13025 + }
13026 + }
13027 + if (ii == 5)
13028 + goto out;
13029 +
13030 + if ((rc = PrimeIocFifos(ioc)) != 0)
13031 + goto out;
13032 +
13033 + if ((rc = SendIocInit(ioc, sleepFlag)) != 0)
13034 + goto out;
13035 +
13036 + if ((rc = SendEventNotification(ioc, 1, sleepFlag)) != 0)
13037 + goto out;
13038 +
13039 + if (ioc->hard_resets < -1)
13040 + ioc->hard_resets++;
13041 +
13042 + /*
13043 + * At this point, we know soft reset succeeded.
13044 + */
13045 +
13046 + ioc->active = 1;
13047 + CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
13048 +
13049 + out:
13050 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
13051 + ioc->ioc_reset_in_progress = 0;
13052 + ioc->taskmgmt_quiesce_io = 0;
13053 + ioc->taskmgmt_in_progress = 0;
13054 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
13055 +
13056 + if (ioc->active) { /* otherwise, hard reset coming */
13057 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
13058 + if (MptResetHandlers[cb_idx])
13059 + mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
13060 + }
13061 + }
13062 +
13063 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SoftResetHandler: completed (%d seconds): %s\n",
13064 + ioc->name, jiffies_to_msecs(jiffies - time_count)/1000,
13065 + ((rc == 0) ? "SUCCESS" : "FAILED")));
13066 +
13067 + return rc;
13068 +}
13069 +
13070 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13071 /**
13072 * mpt_HardResetHandler - Generic reset handler
13073 @@ -6335,12 +7060,14 @@ mpt_print_ioc_summary(MPT_ADAPTER *ioc,
13074 * FW reload/initialization failed.
13075 *
13076 * Returns 0 for SUCCESS or -1 if FAILED.
13077 - */
13078 + **/
13079 int
13080 mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
13081 {
13082 - int rc;
13083 + int rc;
13084 + u8 cb_idx;
13085 unsigned long flags;
13086 + unsigned long time_count;
13087
13088 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler Entered!\n", ioc->name));
13089 #ifdef MFCNT
13090 @@ -6348,67 +7075,82 @@ mpt_HardResetHandler(MPT_ADAPTER *ioc, i
13091 printk("MF count 0x%x !\n", ioc->mfcnt);
13092 #endif
13093
13094 + if(mpt_fwfault_debug)
13095 + mpt_halt_firmware(ioc);
13096 +
13097 /* Reset the adapter. Prevent more than 1 call to
13098 * mpt_do_ioc_recovery at any instant in time.
13099 */
13100 - spin_lock_irqsave(&ioc->diagLock, flags);
13101 - if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
13102 - spin_unlock_irqrestore(&ioc->diagLock, flags);
13103 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
13104 + if (ioc->ioc_reset_in_progress) {
13105 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
13106 return 0;
13107 - } else {
13108 - ioc->diagPending = 1;
13109 }
13110 - spin_unlock_irqrestore(&ioc->diagLock, flags);
13111 + ioc->ioc_reset_in_progress = 1;
13112 + if (ioc->alt_ioc)
13113 + ioc->alt_ioc->ioc_reset_in_progress = 1;
13114 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
13115
13116 - /* FIXME: If do_ioc_recovery fails, repeat....
13117 - */
13118
13119 /* The SCSI driver needs to adjust timeouts on all current
13120 * commands prior to the diagnostic reset being issued.
13121 * Prevents timeouts occurring during a diagnostic reset...very bad.
13122 * For all other protocol drivers, this is a no-op.
13123 */
13124 - {
13125 - u8 cb_idx;
13126 - int r = 0;
13127 -
13128 - for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
13129 - if (MptResetHandlers[cb_idx]) {
13130 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling IOC reset_setup handler #%d\n",
13131 - ioc->name, cb_idx));
13132 - r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
13133 - if (ioc->alt_ioc) {
13134 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling alt-%s setup reset handler #%d\n",
13135 - ioc->name, ioc->alt_ioc->name, cb_idx));
13136 - r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
13137 - }
13138 - }
13139 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
13140 + if (MptResetHandlers[cb_idx]) {
13141 + mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
13142 + if (ioc->alt_ioc)
13143 + mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
13144 }
13145 }
13146
13147 + time_count = jiffies;
13148 if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
13149 - printk(MYIOC_s_WARN_FMT "Cannot recover rc = %d!\n", ioc->name, rc);
13150 + printk(KERN_WARNING MYNAM ": WARNING - (%d) Cannot recover %s\n",
13151 + rc, ioc->name);
13152 + } else {
13153 + if (ioc->hard_resets < -1)
13154 + ioc->hard_resets++;
13155 }
13156 - ioc->reload_fw = 0;
13157 - if (ioc->alt_ioc)
13158 - ioc->alt_ioc->reload_fw = 0;
13159
13160 - spin_lock_irqsave(&ioc->diagLock, flags);
13161 - ioc->diagPending = 0;
13162 - if (ioc->alt_ioc)
13163 - ioc->alt_ioc->diagPending = 0;
13164 - spin_unlock_irqrestore(&ioc->diagLock, flags);
13165 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
13166 + ioc->ioc_reset_in_progress = 0;
13167 + ioc->taskmgmt_quiesce_io = 0;
13168 + ioc->taskmgmt_in_progress = 0;
13169 + if (ioc->alt_ioc) {
13170 + ioc->alt_ioc->ioc_reset_in_progress = 0;
13171 + ioc->alt_ioc->taskmgmt_quiesce_io = 0;
13172 + ioc->alt_ioc->taskmgmt_in_progress = 0;
13173 + }
13174 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
13175
13176 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
13177 + for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
13178 + if (MptResetHandlers[cb_idx]) {
13179 + mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
13180 + if (ioc->alt_ioc)
13181 + mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
13182 + }
13183 + }
13184
13185 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler: completed (%d seconds): %s\n",
13186 + ioc->name, jiffies_to_msecs(jiffies - time_count)/1000,
13187 + ((rc == 0) ? "SUCCESS" : "FAILED")));
13188 return rc;
13189 }
13190
13191 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13192 +#ifdef CONFIG_FUSION_LOGGING
13193 static void
13194 -EventDescriptionStr(u8 event, u32 evData0, char *evStr)
13195 +mpt_display_event_info(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply)
13196 {
13197 char *ds = NULL;
13198 + u32 evData0;
13199 + int ii;
13200 + u8 event;
13201 + char *evStr = ioc->evStr;
13202 +
13203 + event = le32_to_cpu(pEventReply->Event) & 0xFF;
13204 + evData0 = le32_to_cpu(pEventReply->Data[0]);
13205
13206 switch(event) {
13207 case MPI_EVENT_NONE:
13208 @@ -6442,9 +7184,9 @@ EventDescriptionStr(u8 event, u32 evData
13209 if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
13210 ds = "Loop State(LIP) Change";
13211 else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
13212 - ds = "Loop State(LPE) Change"; /* ??? */
13213 + ds = "Loop State(LPE) Change";
13214 else
13215 - ds = "Loop State(LPB) Change"; /* ??? */
13216 + ds = "Loop State(LPB) Change";
13217 break;
13218 case MPI_EVENT_LOGOUT:
13219 ds = "Logout";
13220 @@ -6540,6 +7282,11 @@ EventDescriptionStr(u8 event, u32 evData
13221 "SAS Device Status Change: Internal Device "
13222 "Reset : id=%d channel=%d", id, channel);
13223 break;
13224 + case MPI_EVENT_SAS_DEV_STAT_RC_CMPL_INTERNAL_DEV_RESET:
13225 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13226 + "SAS Device Status Change: Internal Device "
13227 + "Reset Completed: id=%d channel=%d", id, channel);
13228 + break;
13229 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
13230 snprintf(evStr, EVENT_DESCR_STR_SZ,
13231 "SAS Device Status Change: Internal Task "
13232 @@ -6560,6 +7307,11 @@ EventDescriptionStr(u8 event, u32 evData
13233 "SAS Device Status Change: Internal Query "
13234 "Task : id=%d channel=%d", id, channel);
13235 break;
13236 + case MPI_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
13237 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13238 + "SAS Device Status Change: Async Notification "
13239 + "Task : id=%d channel=%d", id, channel);
13240 + break;
13241 default:
13242 snprintf(evStr, EVENT_DESCR_STR_SZ,
13243 "SAS Device Status Change: Unknown: "
13244 @@ -6644,28 +7396,65 @@ EventDescriptionStr(u8 event, u32 evData
13245 }
13246 case MPI_EVENT_IR2:
13247 {
13248 + u8 id = (u8)(evData0);
13249 + u8 channel = (u8)(evData0 >> 8);
13250 + u8 phys_num = (u8)(evData0 >> 24);
13251 u8 ReasonCode = (u8)(evData0 >> 16);
13252 +
13253 switch (ReasonCode) {
13254 case MPI_EVENT_IR2_RC_LD_STATE_CHANGED:
13255 - ds = "IR2: LD State Changed";
13256 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13257 + "IR2: LD State Changed: "
13258 + "id=%d channel=%d phys_num=%d",
13259 + id, channel, phys_num);
13260 break;
13261 case MPI_EVENT_IR2_RC_PD_STATE_CHANGED:
13262 - ds = "IR2: PD State Changed";
13263 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13264 + "IR2: PD State Changed "
13265 + "id=%d channel=%d phys_num=%d",
13266 + id, channel, phys_num);
13267 break;
13268 case MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL:
13269 - ds = "IR2: Bad Block Table Full";
13270 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13271 + "IR2: Bad Block Table Full: "
13272 + "id=%d channel=%d phys_num=%d",
13273 + id, channel, phys_num);
13274 break;
13275 case MPI_EVENT_IR2_RC_PD_INSERTED:
13276 - ds = "IR2: PD Inserted";
13277 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13278 + "IR2: PD Inserted: "
13279 + "id=%d channel=%d phys_num=%d",
13280 + id, channel, phys_num);
13281 break;
13282 case MPI_EVENT_IR2_RC_PD_REMOVED:
13283 - ds = "IR2: PD Removed";
13284 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13285 + "IR2: PD Removed: "
13286 + "id=%d channel=%d phys_num=%d",
13287 + id, channel, phys_num);
13288 break;
13289 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
13290 - ds = "IR2: Foreign CFG Detected";
13291 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13292 + "IR2: Foreign CFG Detected: "
13293 + "id=%d channel=%d phys_num=%d",
13294 + id, channel, phys_num);
13295 break;
13296 case MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR:
13297 - ds = "IR2: Rebuild Medium Error";
13298 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13299 + "IR2: Rebuild Medium Error: "
13300 + "id=%d channel=%d phys_num=%d",
13301 + id, channel, phys_num);
13302 + break;
13303 + case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
13304 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13305 + "IR2: Dual Port Added: "
13306 + "id=%d channel=%d phys_num=%d",
13307 + id, channel, phys_num);
13308 + break;
13309 + case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
13310 + snprintf(evStr, EVENT_DESCR_STR_SZ,
13311 + "IR2: Dual Port Removed: "
13312 + "id=%d channel=%d phys_num=%d",
13313 + id, channel, phys_num);
13314 break;
13315 default:
13316 ds = "IR2";
13317 @@ -6689,25 +7478,46 @@ EventDescriptionStr(u8 event, u32 evData
13318 {
13319 u8 phy_num = (u8)(evData0);
13320 u8 port_num = (u8)(evData0 >> 8);
13321 - u8 port_width = (u8)(evData0 >> 16);
13322 + u8 num_phys = (u8)(evData0 >> 16);
13323 u8 primative = (u8)(evData0 >> 24);
13324 + char *primative_str = NULL;
13325 +
13326 + switch (primative) {
13327 + case MPI_EVENT_PRIMITIVE_CHANGE:
13328 + primative_str = "change";
13329 + break;
13330 + case MPI_EVENT_PRIMITIVE_EXPANDER:
13331 + primative_str = "expander";
13332 + break;
13333 + case MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT:
13334 + primative_str = "asyn event";
13335 + break;
13336 + default:
13337 + primative_str = "reserved";
13338 + break;
13339 + }
13340 snprintf(evStr, EVENT_DESCR_STR_SZ,
13341 - "SAS Broadcase Primative: phy=%d port=%d "
13342 - "width=%d primative=0x%02x",
13343 - phy_num, port_num, port_width, primative);
13344 + "SAS Broadcast Primative: phy=%d port=%d "
13345 + "num_phys=%d primative=%s (0x%02x)",
13346 + phy_num, port_num, num_phys, primative_str, primative);
13347 break;
13348 }
13349
13350 case MPI_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE:
13351 {
13352 u8 reason = (u8)(evData0);
13353 - u8 port_num = (u8)(evData0 >> 8);
13354 - u16 handle = le16_to_cpu(evData0 >> 16);
13355
13356 - snprintf(evStr, EVENT_DESCR_STR_SZ,
13357 - "SAS Initiator Device Status Change: reason=0x%02x "
13358 - "port=%d handle=0x%04x",
13359 - reason, port_num, handle);
13360 + switch (reason) {
13361 + case MPI_EVENT_SAS_INIT_RC_ADDED:
13362 + ds = "SAS Initiator Status Change: Added";
13363 + break;
13364 + case MPI_EVENT_SAS_INIT_RC_REMOVED:
13365 + ds = "SAS Initiator Status Change: Deleted";
13366 + break;
13367 + default:
13368 + ds = "SAS Initiator Status Change";
13369 + break;
13370 + }
13371 break;
13372 }
13373
13374 @@ -6755,6 +7565,24 @@ EventDescriptionStr(u8 event, u32 evData
13375 break;
13376 }
13377
13378 + case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
13379 + {
13380 + u8 reason = (u8)(evData0);
13381 +
13382 + switch (reason) {
13383 + case MPI_EVENT_SAS_EXP_RC_ADDED:
13384 + ds = "Expander Status Change: Added";
13385 + break;
13386 + case MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING:
13387 + ds = "Expander Status Change: Deleted";
13388 + break;
13389 + default:
13390 + ds = "Expander Status Change";
13391 + break;
13392 + }
13393 + break;
13394 + }
13395 +
13396 /*
13397 * MPT base "custom" events may be added here...
13398 */
13399 @@ -6764,9 +7592,21 @@ EventDescriptionStr(u8 event, u32 evData
13400 }
13401 if (ds)
13402 strncpy(evStr, ds, EVENT_DESCR_STR_SZ);
13403 +
13404 +
13405 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
13406 + "MPT event:(%02Xh) : %s\n",
13407 + ioc->name, event, evStr));
13408 +
13409 + devtverboseprintk(ioc, printk(KERN_DEBUG MYNAM
13410 + ": Event data:\n"));
13411 + for (ii = 0; ii < le16_to_cpu(pEventReply->EventDataLength); ii++)
13412 + devtverboseprintk(ioc, printk(" %08x",
13413 + le32_to_cpu(pEventReply->Data[ii])));
13414 + devtverboseprintk(ioc, printk(KERN_DEBUG "\n"));
13415 }
13416 +#endif
13417
13418 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13419 /**
13420 * ProcessEventNotification - Route EventNotificationReply to all event handlers
13421 * @ioc: Pointer to MPT_ADAPTER structure
13422 @@ -6776,43 +7616,30 @@ EventDescriptionStr(u8 event, u32 evData
13423 * Routes a received EventNotificationReply to all currently registered
13424 * event handlers.
13425 * Returns sum of event handlers return values.
13426 - */
13427 + **/
13428 static int
13429 ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
13430 {
13431 u16 evDataLen;
13432 u32 evData0 = 0;
13433 -// u32 evCtx;
13434 int ii;
13435 u8 cb_idx;
13436 int r = 0;
13437 int handlers = 0;
13438 - char evStr[EVENT_DESCR_STR_SZ];
13439 u8 event;
13440
13441 +
13442 /*
13443 * Do platform normalization of values
13444 */
13445 event = le32_to_cpu(pEventReply->Event) & 0xFF;
13446 -// evCtx = le32_to_cpu(pEventReply->EventContext);
13447 evDataLen = le16_to_cpu(pEventReply->EventDataLength);
13448 - if (evDataLen) {
13449 + if (evDataLen)
13450 evData0 = le32_to_cpu(pEventReply->Data[0]);
13451 - }
13452 -
13453 - EventDescriptionStr(event, evData0, evStr);
13454 - devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event:(%02Xh) : %s\n",
13455 - ioc->name,
13456 - event,
13457 - evStr));
13458
13459 #ifdef CONFIG_FUSION_LOGGING
13460 - devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
13461 - ": Event data:\n", ioc->name));
13462 - for (ii = 0; ii < evDataLen; ii++)
13463 - devtverboseprintk(ioc, printk(" %08x",
13464 - le32_to_cpu(pEventReply->Data[ii])));
13465 - devtverboseprintk(ioc, printk("\n"));
13466 + if (evDataLen)
13467 + mpt_display_event_info(ioc, pEventReply);
13468 #endif
13469
13470 /*
13471 @@ -6867,8 +7694,8 @@ ProcessEventNotification(MPT_ADAPTER *io
13472 */
13473 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
13474 if (MptEvHandlers[cb_idx]) {
13475 - devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Routing Event to event handler #%d\n",
13476 - ioc->name, cb_idx));
13477 + devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
13478 + "Routing Event to event handler #%d\n", ioc->name, cb_idx));
13479 r += (*(MptEvHandlers[cb_idx]))(ioc, pEventReply);
13480 handlers++;
13481 }
13482 @@ -6935,7 +7762,6 @@ mpt_fc_log_info(MPT_ADAPTER *ioc, u32 lo
13483 ioc->name, log_info, desc, (log_info & 0xFFFFFF));
13484 }
13485
13486 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13487 /**
13488 * mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
13489 * @ioc: Pointer to MPT_ADAPTER structure
13490 @@ -6943,7 +7769,7 @@ mpt_fc_log_info(MPT_ADAPTER *ioc, u32 lo
13491 * @log_info: U32 LogInfo word from the IOC
13492 *
13493 * Refer to lsi/sp_log.h.
13494 - */
13495 + **/
13496 static void
13497 mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
13498 {
13499 @@ -6953,8 +7779,6 @@ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 l
13500 switch (info) {
13501 case 0x00010000:
13502 desc = "bug! MID not found";
13503 - if (ioc->reload_fw == 0)
13504 - ioc->reload_fw++;
13505 break;
13506
13507 case 0x00020000:
13508 @@ -7149,7 +7973,6 @@ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 l
13509 "Compatibility Error: IME Size Limited to < 2TB", /* 3Dh */
13510 };
13511
13512 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13513 /**
13514 * mpt_sas_log_info - Log information returned from SAS IOC.
13515 * @ioc: Pointer to MPT_ADAPTER structure
13516 @@ -7229,7 +8052,6 @@ union loginfo_type {
13517 sas_loginfo.dw.code, sas_loginfo.dw.subcode);
13518 }
13519
13520 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13521 /**
13522 * mpt_iocstatus_info_config - IOCSTATUS information for config pages
13523 * @ioc: Pointer to MPT_ADAPTER structure
13524 @@ -7531,8 +8353,7 @@ mpt_iocstatus_info(MPT_ADAPTER *ioc, u32
13525 if (!desc)
13526 return;
13527
13528 - dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n",
13529 - ioc->name, status, desc));
13530 + dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n", ioc->name, status, desc));
13531 }
13532
13533 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13534 @@ -7543,6 +8364,7 @@ EXPORT_SYMBOL(mpt_resume);
13535 EXPORT_SYMBOL(mpt_suspend);
13536 #endif
13537 EXPORT_SYMBOL(ioc_list);
13538 +EXPORT_SYMBOL(mpt_proc_root_dir);
13539 EXPORT_SYMBOL(mpt_register);
13540 EXPORT_SYMBOL(mpt_deregister);
13541 EXPORT_SYMBOL(mpt_event_register);
13542 @@ -7555,25 +8377,29 @@ EXPORT_SYMBOL(mpt_get_msg_frame);
13543 EXPORT_SYMBOL(mpt_put_msg_frame);
13544 EXPORT_SYMBOL(mpt_put_msg_frame_hi_pri);
13545 EXPORT_SYMBOL(mpt_free_msg_frame);
13546 -EXPORT_SYMBOL(mpt_add_sge);
13547 EXPORT_SYMBOL(mpt_send_handshake_request);
13548 EXPORT_SYMBOL(mpt_verify_adapter);
13549 EXPORT_SYMBOL(mpt_GetIocState);
13550 EXPORT_SYMBOL(mpt_print_ioc_summary);
13551 EXPORT_SYMBOL(mpt_HardResetHandler);
13552 +EXPORT_SYMBOL(mpt_SoftResetHandler);
13553 EXPORT_SYMBOL(mpt_config);
13554 EXPORT_SYMBOL(mpt_findImVolumes);
13555 EXPORT_SYMBOL(mpt_alloc_fw_memory);
13556 EXPORT_SYMBOL(mpt_free_fw_memory);
13557 EXPORT_SYMBOL(mptbase_sas_persist_operation);
13558 EXPORT_SYMBOL(mpt_raid_phys_disk_pg0);
13559 +EXPORT_SYMBOL(mpt_raid_phys_disk_pg1);
13560 +EXPORT_SYMBOL(mpt_raid_phys_disk_get_num_paths);
13561 +EXPORT_SYMBOL(mpt_set_taskmgmt_in_progress_flag);
13562 +EXPORT_SYMBOL(mpt_clear_taskmgmt_in_progress_flag);
13563 +EXPORT_SYMBOL(mpt_halt_firmware);
13564
13565 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13566 /**
13567 * fusion_init - Fusion MPT base driver initialization routine.
13568 *
13569 * Returns 0 for success, non-zero for failure.
13570 - */
13571 + **/
13572 static int __init
13573 fusion_init(void)
13574 {
13575 @@ -7592,7 +8418,7 @@ fusion_init(void)
13576 /* Register ourselves (mptbase) in order to facilitate
13577 * EventNotification handling.
13578 */
13579 - mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
13580 + mpt_base_index = mpt_register(mptbase_reply, MPTBASE_DRIVER);
13581
13582 /* Register for hard reset handling callbacks.
13583 */
13584 @@ -7604,17 +8430,15 @@ fusion_init(void)
13585 return 0;
13586 }
13587
13588 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13589 /**
13590 * fusion_exit - Perform driver unload cleanup.
13591 *
13592 * This routine frees all resources associated with each MPT adapter
13593 * and removes all %MPT_PROCFS_MPTBASEDIR entries.
13594 - */
13595 + **/
13596 static void __exit
13597 fusion_exit(void)
13598 {
13599 -
13600 mpt_reset_deregister(mpt_base_index);
13601
13602 #ifdef CONFIG_PROC_FS
13603 --- a/drivers/message/fusion/mptbase.h
13604 +++ b/drivers/message/fusion/mptbase.h
13605 @@ -49,10 +49,6 @@
13606 #define MPTBASE_H_INCLUDED
13607 /*{-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13608
13609 -#include <linux/kernel.h>
13610 -#include <linux/pci.h>
13611 -#include <linux/mutex.h>
13612 -
13613 #include "lsi/mpi_type.h"
13614 #include "lsi/mpi.h" /* Fusion MPI(nterface) basic defs */
13615 #include "lsi/mpi_ioc.h" /* Fusion MPT IOC(ontroller) defs */
13616 @@ -76,9 +72,13 @@
13617 #define COPYRIGHT "Copyright (c) 1999-2008 " MODULEAUTHOR
13618 #endif
13619
13620 -#define MPT_LINUX_VERSION_COMMON "3.04.07"
13621 -#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-3.04.07"
13622 +#define MPT_LINUX_VERSION_COMMON "4.00.43.00"
13623 +#define MPT_LINUX_PACKAGE_NAME "@(#)mptlinux-4.00.43.00"
13624 #define WHAT_MAGIC_STRING "@" "(" "#" ")"
13625 +#define MPT_LINUX_MAJOR_VERSION 4
13626 +#define MPT_LINUX_MINOR_VERSION 00
13627 +#define MPT_LINUX_BUILD_VERSION 43
13628 +#define MPT_LINUX_RELEASE_VERSION 00
13629
13630 #define show_mptmod_ver(s,ver) \
13631 printk(KERN_INFO "%s %s\n", s, ver);
13632 @@ -87,6 +87,8 @@
13633 /*
13634 * Fusion MPT(linux) driver configurable stuff...
13635 */
13636 +#define MPT_POLLING_INTERVAL 1000 /* in milliseconds */
13637 +
13638 #define MPT_MAX_ADAPTERS 18
13639 #define MPT_MAX_PROTOCOL_DRIVERS 16
13640 #define MPT_MAX_BUS 1 /* Do not change */
13641 @@ -134,6 +136,8 @@
13642
13643 #define MPT_COALESCING_TIMEOUT 0x10
13644
13645 +#define MPT_DMA_35BIT_MASK 0x00000007ffffffffULL
13646 +
13647 /*
13648 * SCSI transfer rate defines.
13649 */
13650 @@ -173,10 +177,21 @@
13651 #define MPT_SCSI_SG_DEPTH 40
13652 #endif
13653
13654 +#ifdef CONFIG_FUSION_MAX_FC_SGE
13655 +#if CONFIG_FUSION_MAX_FC_SGE < 16
13656 +#define MPT_SCSI_FC_SG_DEPTH 16
13657 +#elif CONFIG_FUSION_MAX_FC_SGE > 256
13658 +#define MPT_SCSI_FC_SG_DEPTH 256
13659 +#else
13660 +#define MPT_SCSI_FC_SG_DEPTH CONFIG_FUSION_MAX_FC_SGE
13661 +#endif
13662 +#else
13663 +#define MPT_SCSI_FC_SG_DEPTH 40
13664 +#endif
13665 +
13666 /* debug print string length used for events and iocstatus */
13667 -# define EVENT_DESCR_STR_SZ 100
13668 +# define EVENT_DESCR_STR_SZ 100
13669
13670 -#define MPT_POLLING_INTERVAL 1000 /* in milliseconds */
13671
13672 #ifdef __KERNEL__ /* { */
13673 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13674 @@ -224,7 +239,6 @@ typedef struct _ATTO_CONFIG_PAGE_SCSI_PO
13675 } fATTO_CONFIG_PAGE_SCSI_PORT_2, MPI_POINTER PTR_ATTO_CONFIG_PAGE_SCSI_PORT_2,
13676 ATTO_SCSIPortPage2_t, MPI_POINTER pATTO_SCSIPortPage2_t;
13677
13678 -
13679 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13680 /*
13681 * MPT protocol driver defs...
13682 @@ -372,8 +386,8 @@ typedef struct _VirtTarget {
13683 struct scsi_target *starget;
13684 u8 tflags;
13685 u8 ioc_id;
13686 - u8 id;
13687 - u8 channel;
13688 + u8 id; /* logical target id */
13689 + u8 channel; /* logical channel number */
13690 u8 minSyncFactor; /* 0xFF is async */
13691 u8 maxOffset; /* 0 if async */
13692 u8 maxWidth; /* 0 if narrow, 1 if wide */
13693 @@ -381,7 +395,7 @@ typedef struct _VirtTarget {
13694 u8 raidVolume; /* set, if RAID Volume */
13695 u8 type; /* byte 0 of Inquiry data */
13696 u8 deleted; /* target in process of being removed */
13697 - u32 num_luns;
13698 + int num_luns;
13699 } VirtTarget;
13700
13701 typedef struct _VirtDevice {
13702 @@ -427,42 +441,33 @@ do { \
13703 } while (0)
13704
13705
13706 -/*
13707 - * IOCTL structure and associated defines
13708 - */
13709 -
13710 -#define MPT_IOCTL_STATUS_DID_IOCRESET 0x01 /* IOC Reset occurred on the current*/
13711 -#define MPT_IOCTL_STATUS_RF_VALID 0x02 /* The Reply Frame is VALID */
13712 -#define MPT_IOCTL_STATUS_TIMER_ACTIVE 0x04 /* The timer is running */
13713 -#define MPT_IOCTL_STATUS_SENSE_VALID 0x08 /* Sense data is valid */
13714 -#define MPT_IOCTL_STATUS_COMMAND_GOOD 0x10 /* Command Status GOOD */
13715 -#define MPT_IOCTL_STATUS_TMTIMER_ACTIVE 0x20 /* The TM timer is running */
13716 -#define MPT_IOCTL_STATUS_TM_FAILED 0x40 /* User TM request failed */
13717 -
13718 -#define MPTCTL_RESET_OK 0x01 /* Issue Bus Reset */
13719 -
13720 -typedef struct _MPT_IOCTL {
13721 - struct _MPT_ADAPTER *ioc;
13722 - u8 ReplyFrame[MPT_DEFAULT_FRAME_SIZE]; /* reply frame data */
13723 - u8 sense[MPT_SENSE_BUFFER_ALLOC];
13724 - int wait_done; /* wake-up value for this ioc */
13725 - u8 rsvd;
13726 - u8 status; /* current command status */
13727 - u8 reset; /* 1 if bus reset allowed */
13728 - u8 id; /* target for reset */
13729 - struct mutex ioctl_mutex;
13730 -} MPT_IOCTL;
13731 -
13732 -#define MPT_SAS_MGMT_STATUS_RF_VALID 0x02 /* The Reply Frame is VALID */
13733 -#define MPT_SAS_MGMT_STATUS_COMMAND_GOOD 0x10 /* Command Status GOOD */
13734 -#define MPT_SAS_MGMT_STATUS_TM_FAILED 0x40 /* User TM request failed */
13735 +#define MPT_MGMT_STATUS_RF_VALID 0x01 /* The Reply Frame is VALID */
13736 +#define MPT_MGMT_STATUS_COMMAND_GOOD 0x02 /* Command Status GOOD */
13737 +#define MPT_MGMT_STATUS_PENDING 0x04 /* command is pending */
13738 +#define MPT_MGMT_STATUS_DID_IOCRESET 0x08 /* IOC Reset occurred on the current*/
13739 +#define MPT_MGMT_STATUS_SENSE_VALID 0x10 /* valid sense info */
13740 +#define MPT_MGMT_STATUS_TIMER_ACTIVE 0x20 /* obsolete */
13741 +#define MPT_MGMT_STATUS_FREE_MF 0x40 /* free the mf from complete routine */
13742 +
13743 +
13744 +#define INITIALIZE_MGMT_STATUS(status) \
13745 + status = MPT_MGMT_STATUS_PENDING;
13746 +#define CLEAR_MGMT_STATUS(status) \
13747 + status = 0;
13748 +#define CLEAR_MGMT_PENDING_STATUS(status) \
13749 + status &= ~MPT_MGMT_STATUS_PENDING;
13750 +#define SET_MGMT_MSG_CONTEXT(msg_context, value) \
13751 + msg_context = value;
13752
13753 -typedef struct _MPT_SAS_MGMT {
13754 +typedef struct _MPT_MGMT {
13755 struct mutex mutex;
13756 struct completion done;
13757 u8 reply[MPT_DEFAULT_FRAME_SIZE]; /* reply frame data */
13758 + u8 sense[MPT_SENSE_BUFFER_ALLOC];
13759 u8 status; /* current command status */
13760 -}MPT_SAS_MGMT;
13761 + int completion_code;
13762 + u32 msg_context;
13763 +}MPT_MGMT;
13764
13765 /*
13766 * Event Structure and define
13767 @@ -534,7 +539,8 @@ struct inactive_raid_component_info {
13768 typedef struct _RaidCfgData {
13769 IOCPage2_t *pIocPg2; /* table of Raid Volumes */
13770 IOCPage3_t *pIocPg3; /* table of physical disks */
13771 - struct mutex inactive_list_mutex;
13772 + IOCPage6_t *pIocPg6; /* table of IR static data */
13773 + struct semaphore inactive_list_mutex;
13774 struct list_head inactive_list; /* link list for physical
13775 disk that belong in
13776 inactive volumes */
13777 @@ -564,6 +570,9 @@ struct mptfc_rport_info
13778 u8 flags;
13779 };
13780
13781 +typedef void (*MPT_ADD_SGE)(char *pAddr, u32 flagslength, dma_addr_t dma_addr);
13782 +typedef void (*MPT_ADD_CHAIN)(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr);
13783 +
13784 /*
13785 * Adapter Structure - pci_dev specific. Maximum: MPT_MAX_ADAPTERS
13786 */
13787 @@ -573,6 +582,9 @@ typedef struct _MPT_ADAPTER
13788 int pci_irq; /* This irq */
13789 char name[MPT_NAME_LENGTH]; /* "iocN" */
13790 char prod_name[MPT_NAME_LENGTH]; /* "LSIFC9x9" */
13791 +#ifdef CONFIG_FUSION_LOGGING
13792 + char evStr[EVENT_DESCR_STR_SZ]; /* used in mpt_display_event_info */
13793 +#endif
13794 char board_name[16];
13795 char board_assembly[16];
13796 char board_tracer[16];
13797 @@ -584,8 +596,8 @@ typedef struct _MPT_ADAPTER
13798 SYSIF_REGS __iomem *chip; /* == c8817000 (mmap) */
13799 SYSIF_REGS __iomem *pio_chip; /* Programmed IO (downloadboot) */
13800 u8 bus_type;
13801 - u32 mem_phys; /* == f4020000 (mmap) */
13802 - u32 pio_mem_phys; /* Programmed IO (downloadboot) */
13803 + unsigned long mem_phys; /* == f4020000 (mmap) */
13804 + unsigned long pio_mem_phys; /* Programmed IO (downloadboot) */
13805 int mem_size; /* mmap memory size */
13806 int number_of_buses;
13807 int devices_per_bus;
13808 @@ -600,6 +612,8 @@ typedef struct _MPT_ADAPTER
13809 int reply_depth; /* Num Allocated reply frames */
13810 int reply_sz; /* Reply frame size */
13811 int num_chain; /* Number of chain buffers */
13812 + MPT_ADD_SGE add_sge; /* Pointer to add_sge function */
13813 + MPT_ADD_CHAIN add_chain; /* Pointer to add_chain function */
13814 /* Pool of buffers for chaining. ReqToChain
13815 * and ChainToChain track index of chain buffers.
13816 * ChainBuffer (DMA) virt/phys addresses.
13817 @@ -628,31 +642,27 @@ typedef struct _MPT_ADAPTER
13818 dma_addr_t sense_buf_pool_dma;
13819 u32 sense_buf_low_dma;
13820 u8 *HostPageBuffer; /* SAS - host page buffer support */
13821 - u32 HostPageBuffer_sz;
13822 - dma_addr_t HostPageBuffer_dma;
13823 + u32 HostPageBuffer_sz;
13824 + dma_addr_t HostPageBuffer_dma;
13825 int mtrr_reg;
13826 struct pci_dev *pcidev; /* struct pci_dev pointer */
13827 - int bars; /* bitmask of BAR's that must be configured */
13828 - int msi_enable;
13829 + int bars; /* bitmask of BAR's that must be configured */
13830 + int msi_enable;
13831 u8 __iomem *memmap; /* mmap address */
13832 struct Scsi_Host *sh; /* Scsi Host pointer */
13833 - SpiCfgData spi_data; /* Scsi config. data */
13834 - RaidCfgData raid_data; /* Raid config. data */
13835 - SasCfgData sas_data; /* Sas config. data */
13836 - FcCfgData fc_data; /* Fc config. data */
13837 - MPT_IOCTL *ioctl; /* ioctl data pointer */
13838 + SpiCfgData spi_data; /* Scsi config. data */
13839 + RaidCfgData raid_data; /* Raid config. data */
13840 + SasCfgData sas_data; /* Sas config. data */
13841 + FcCfgData fc_data; /* Fc config. data */
13842 struct proc_dir_entry *ioc_dentry;
13843 struct _MPT_ADAPTER *alt_ioc; /* ptr to 929 bound adapter port */
13844 - spinlock_t diagLock; /* diagnostic reset lock */
13845 - int diagPending;
13846 u32 biosVersion; /* BIOS version from IO Unit Page 2 */
13847 int eventTypes; /* Event logging parameters */
13848 int eventContext; /* Next event context */
13849 int eventLogSize; /* Max number of cached events */
13850 struct _mpt_ioctl_events *events; /* pointer to event log */
13851 u8 *cached_fw; /* Pointer to FW */
13852 - dma_addr_t cached_fw_dma;
13853 - struct list_head configQ; /* linked list of config. requests */
13854 + dma_addr_t cached_fw_dma;
13855 int hs_reply_idx;
13856 #ifndef MFCNT
13857 u32 pad0;
13858 @@ -665,13 +675,16 @@ typedef struct _MPT_ADAPTER
13859 IOCFactsReply_t facts;
13860 PortFactsReply_t pfacts[2];
13861 FCPortPage0_t fc_port_page0[2];
13862 - struct timer_list persist_timer; /* persist table timer */
13863 - int persist_wait_done; /* persist completion flag */
13864 - u8 persist_reply_frame[MPT_DEFAULT_FRAME_SIZE]; /* persist reply */
13865 LANPage0_t lan_cnfg_page0;
13866 LANPage1_t lan_cnfg_page1;
13867 +#if defined(CPQ_CIM)
13868 + u32 csmi_change_count; /* count to track all IR
13869 + events for CSMI */
13870 + u8 pci_slot_number; /* ioc page 1 - pci slot number */
13871 +#endif
13872
13873 u8 ir_firmware; /* =1 if IR firmware detected */
13874 +
13875 /*
13876 * Description: errata_flag_1064
13877 * If a PCIX read occurs within 1 or 2 cycles after the chip receives
13878 @@ -682,25 +695,46 @@ typedef struct _MPT_ADAPTER
13879 int aen_event_read_flag; /* flag to indicate event log was read*/
13880 u8 FirstWhoInit;
13881 u8 upload_fw; /* If set, do a fw upload */
13882 - u8 reload_fw; /* Force a FW Reload on next reset */
13883 u8 NBShiftFactor; /* NB Shift Factor based on Block Size (Facts) */
13884 - u8 pad1[4];
13885 u8 DoneCtx;
13886 u8 TaskCtx;
13887 u8 InternalCtx;
13888 - spinlock_t initializing_hba_lock;
13889 - int initializing_hba_lock_flag;
13890 struct list_head list;
13891 struct net_device *netdev;
13892 struct list_head sas_topology;
13893 struct mutex sas_topology_mutex;
13894 - struct mutex sas_discovery_mutex;
13895 - u8 sas_discovery_runtime;
13896 - u8 sas_discovery_ignore_events;
13897 + u8 disable_hotplug_remove;
13898 +
13899 + struct workqueue_struct *fw_event_q;
13900 + struct list_head fw_event_list;
13901 + spinlock_t fw_event_lock;
13902 + u8 fw_events_off; /* if '1', then ignore events */
13903 + char fw_event_q_name[20];
13904 +
13905 + struct mptsas_portinfo *hba_port_info; /* port_info object for the host */
13906 + u64 hba_port_sas_addr;
13907 + u16 hba_port_num_phy;
13908 + struct list_head sas_device_info_list;
13909 + struct semaphore sas_device_info_mutex;
13910 + u8 old_sas_discovery_protocal;
13911 + u8 sas_discovery_quiesce_io;
13912 int sas_index; /* index refrencing */
13913 - MPT_SAS_MGMT sas_mgmt;
13914 - struct work_struct sas_persist_task;
13915 + MPT_MGMT sas_mgmt;
13916 + MPT_MGMT internal_cmds;
13917 + MPT_MGMT mptbase_cmds; /* for sending config pages */
13918 + MPT_MGMT taskmgmt_cmds;
13919 + MPT_MGMT ioctl_cmds; /* ioctl data pointer */
13920 + spinlock_t taskmgmt_lock; /* diagnostic reset lock */
13921 + int taskmgmt_in_progress;
13922 + u8 taskmgmt_quiesce_io;
13923 + u8 ioc_reset_in_progress;
13924 +#if defined(CPQ_CIM)
13925 + u8 num_ports;
13926 +#endif
13927
13928 + char reset_work_q_name[20];
13929 + struct workqueue_struct *reset_work_q;
13930 + struct delayed_work fault_reset_work;
13931 struct work_struct fc_setup_reset_work;
13932 struct list_head fc_rports;
13933 struct work_struct fc_lsc_work;
13934 @@ -709,14 +743,27 @@ typedef struct _MPT_ADAPTER
13935 struct work_struct fc_rescan_work;
13936 char fc_rescan_work_q_name[20];
13937 struct workqueue_struct *fc_rescan_work_q;
13938 + unsigned long hard_resets; /* driver forced bus resets count */
13939 + unsigned long soft_resets; /* fw/external bus resets count */
13940 + unsigned long timeouts; /* cmd timeouts */
13941 struct scsi_cmnd **ScsiLookup;
13942 spinlock_t scsi_lookup_lock;
13943 -
13944 - char reset_work_q_name[20];
13945 - struct workqueue_struct *reset_work_q;
13946 - struct delayed_work fault_reset_work;
13947 - spinlock_t fault_reset_work_lock;
13948 -
13949 + int sdev_queue_depth; /* sdev queue depth */
13950 + u64 dma_mask;
13951 + u32 broadcast_aen_busy;
13952 +#if defined(DIAG_BUFFER_SUPPORT)
13953 + u8 *DiagBuffer[MPI_DIAG_BUF_TYPE_COUNT];
13954 + u32 DataSize[MPI_DIAG_BUF_TYPE_COUNT];
13955 + u32 DiagBuffer_sz[MPI_DIAG_BUF_TYPE_COUNT];
13956 + dma_addr_t DiagBuffer_dma[MPI_DIAG_BUF_TYPE_COUNT];
13957 + u8 TraceLevel[MPI_DIAG_BUF_TYPE_COUNT];
13958 + u8 DiagBuffer_Status[MPI_DIAG_BUF_TYPE_COUNT];
13959 + u32 UniqueId[MPI_DIAG_BUF_TYPE_COUNT];
13960 + u32 ExtendedType[MPI_DIAG_BUF_TYPE_COUNT];
13961 + u32 ProductSpecific[MPI_DIAG_BUF_TYPE_COUNT][4];
13962 +#endif
13963 + u8 sg_addr_size;
13964 + u8 SGE_size;
13965 } MPT_ADAPTER;
13966
13967 /*
13968 @@ -753,13 +800,12 @@ typedef struct _mpt_sge {
13969 dma_addr_t Address;
13970 } MptSge_t;
13971
13972 -#define mpt_addr_size() \
13973 - ((sizeof(dma_addr_t) == sizeof(u64)) ? MPI_SGE_FLAGS_64_BIT_ADDRESSING : \
13974 - MPI_SGE_FLAGS_32_BIT_ADDRESSING)
13975 -
13976 -#define mpt_msg_flags() \
13977 - ((sizeof(dma_addr_t) == sizeof(u64)) ? MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64 : \
13978 - MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_32)
13979 +#define mpt_msg_flags(ioc) \
13980 + (ioc->sg_addr_size == sizeof(u64)) ? MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_64 : \
13981 + MPI_SCSIIO_MSGFLGS_SENSE_WIDTH_32
13982 +
13983 +#define MPT_SGE_FLAGS_64_BIT_ADDRESSING \
13984 + (MPI_SGE_FLAGS_64_BIT_ADDRESSING << MPI_SGE_FLAGS_SHIFT)
13985
13986 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13987 /*
13988 @@ -778,26 +824,10 @@ typedef struct _mpt_sge {
13989
13990 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13991
13992 -#define SCSI_STD_SENSE_BYTES 18
13993 -#define SCSI_STD_INQUIRY_BYTES 36
13994 -#define SCSI_MAX_INQUIRY_BYTES 96
13995 -
13996 /*
13997 * MPT_SCSI_HOST defines - Used by the IOCTL and the SCSI drivers
13998 * Private to the driver.
13999 */
14000 -/* LOCAL structure and fields used when processing
14001 - * internally generated commands. These include:
14002 - * bus scan, dv and config requests.
14003 - */
14004 -typedef struct _MPT_LOCAL_REPLY {
14005 - ConfigPageHeader_t header;
14006 - int completion;
14007 - u8 sense[SCSI_STD_SENSE_BYTES];
14008 - u8 scsiStatus;
14009 - u8 skip;
14010 - u32 pad;
14011 -} MPT_LOCAL_REPLY;
14012
14013 #define MPT_HOST_BUS_UNKNOWN (0xFF)
14014 #define MPT_HOST_TOO_MANY_TM (0x05)
14015 @@ -813,13 +843,6 @@ typedef struct _MPT_LOCAL_REPLY {
14016 #define MPT_NVRAM_WIDE_DISABLE (0x00100000)
14017 #define MPT_NVRAM_BOOT_CHOICE (0x00200000)
14018
14019 -/* The TM_STATE variable is used to provide strict single threading of TM
14020 - * requests as well as communicate TM error conditions.
14021 - */
14022 -#define TM_STATE_NONE (0)
14023 -#define TM_STATE_IN_PROGRESS (1)
14024 -#define TM_STATE_ERROR (2)
14025 -
14026 typedef enum {
14027 FC,
14028 SPI,
14029 @@ -828,63 +851,28 @@ typedef enum {
14030
14031 typedef struct _MPT_SCSI_HOST {
14032 MPT_ADAPTER *ioc;
14033 - int port;
14034 - u32 pad0;
14035 - MPT_LOCAL_REPLY *pLocal; /* used for internal commands */
14036 - struct timer_list timer;
14037 - /* Pool of memory for holding SCpnts before doing
14038 - * OS callbacks. freeQ is the free pool.
14039 - */
14040 - u8 tmPending;
14041 - u8 resetPending;
14042 - u8 negoNvram; /* DV disabled, nego NVRAM */
14043 - u8 pad1;
14044 - u8 tmState;
14045 - u8 rsvd[2];
14046 - MPT_FRAME_HDR *cmdPtr; /* Ptr to nonOS request */
14047 - struct scsi_cmnd *abortSCpnt;
14048 - MPT_LOCAL_REPLY localReply; /* internal cmd reply struct */
14049 - unsigned long hard_resets; /* driver forced bus resets count */
14050 - unsigned long soft_resets; /* fw/external bus resets count */
14051 - unsigned long timeouts; /* cmd timeouts */
14052 ushort sel_timeout[MPT_MAX_FC_DEVICES];
14053 char *info_kbuf;
14054 - wait_queue_head_t scandv_waitq;
14055 - int scandv_wait_done;
14056 long last_queue_full;
14057 - u16 tm_iocstatus;
14058 u16 spi_pending;
14059 struct list_head target_reset_list;
14060 } MPT_SCSI_HOST;
14061
14062 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14063 /*
14064 - * More Dynamic Multi-Pathing stuff...
14065 - */
14066 -
14067 -/* Forward decl, a strange C thing, to prevent gcc compiler warnings */
14068 -struct scsi_cmnd;
14069 -
14070 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14071 -/*
14072 * Generic structure passed to the base mpt_config function.
14073 */
14074 typedef struct _x_config_parms {
14075 - struct list_head linkage; /* linked list */
14076 - struct timer_list timer; /* timer function for this request */
14077 union {
14078 ConfigExtendedPageHeader_t *ehdr;
14079 ConfigPageHeader_t *hdr;
14080 } cfghdr;
14081 dma_addr_t physAddr;
14082 - int wait_done; /* wait for this request */
14083 u32 pageAddr; /* properly formatted */
14084 + u16 status;
14085 u8 action;
14086 u8 dir;
14087 u8 timeout; /* seconds */
14088 - u8 pad1;
14089 - u16 status;
14090 - u16 pad2;
14091 } CONFIGPARMS;
14092
14093 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14094 @@ -909,29 +897,37 @@ extern MPT_FRAME_HDR *mpt_get_msg_frame(
14095 extern void mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf);
14096 extern void mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf);
14097 extern void mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf);
14098 -extern void mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr);
14099 -
14100 extern int mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag);
14101 extern int mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp);
14102 extern u32 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked);
14103 extern void mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buf, int *size, int len, int showlan);
14104 extern int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
14105 +extern int mpt_SoftResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
14106 extern int mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *cfg);
14107 extern int mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size);
14108 extern void mpt_free_fw_memory(MPT_ADAPTER *ioc);
14109 extern int mpt_findImVolumes(MPT_ADAPTER *ioc);
14110 extern int mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
14111 extern int mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk);
14112 +extern int mpt_raid_phys_disk_pg1(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage1_t phys_disk);
14113 +extern int mpt_raid_phys_disk_get_num_paths(MPT_ADAPTER *ioc, u8 phys_disk_num);
14114 +
14115 +extern int mpt_set_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc);
14116 +extern void mpt_clear_taskmgmt_in_progress_flag(MPT_ADAPTER *ioc);
14117 +extern void mpt_halt_firmware(MPT_ADAPTER *ioc);
14118
14119 /*
14120 * Public data decl's...
14121 */
14122 extern struct list_head ioc_list;
14123 +extern struct proc_dir_entry *mpt_proc_root_dir;
14124 +extern int mpt_debug_level;
14125 +extern int mpt_fwfault_debug;
14126
14127 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14128 #endif /* } __KERNEL__ */
14129
14130 -#ifdef CONFIG_64BIT
14131 +#if defined(__alpha__) || defined(__sparc_v9__) || defined(__ia64__) || defined(__x86_64__) || defined(__powerpc64__)
14132 #define CAST_U32_TO_PTR(x) ((void *)(u64)x)
14133 #define CAST_PTR_TO_U32(x) ((u32)(u64)x)
14134 #else
14135 @@ -956,7 +952,6 @@ extern struct list_head ioc_list;
14136 #define MPT_SGE_FLAGS_END_OF_BUFFER (0x40000000)
14137 #define MPT_SGE_FLAGS_LOCAL_ADDRESS (0x08000000)
14138 #define MPT_SGE_FLAGS_DIRECTION (0x04000000)
14139 -#define MPT_SGE_FLAGS_ADDRESSING (mpt_addr_size() << MPI_SGE_FLAGS_SHIFT)
14140 #define MPT_SGE_FLAGS_END_OF_LIST (0x01000000)
14141
14142 #define MPT_SGE_FLAGS_TRANSACTION_ELEMENT (0x00000000)
14143 @@ -969,14 +964,12 @@ extern struct list_head ioc_list;
14144 MPT_SGE_FLAGS_END_OF_BUFFER | \
14145 MPT_SGE_FLAGS_END_OF_LIST | \
14146 MPT_SGE_FLAGS_SIMPLE_ELEMENT | \
14147 - MPT_SGE_FLAGS_ADDRESSING | \
14148 MPT_TRANSFER_IOC_TO_HOST)
14149 #define MPT_SGE_FLAGS_SSIMPLE_WRITE \
14150 (MPT_SGE_FLAGS_LAST_ELEMENT | \
14151 MPT_SGE_FLAGS_END_OF_BUFFER | \
14152 MPT_SGE_FLAGS_END_OF_LIST | \
14153 MPT_SGE_FLAGS_SIMPLE_ELEMENT | \
14154 - MPT_SGE_FLAGS_ADDRESSING | \
14155 MPT_TRANSFER_HOST_TO_IOC)
14156
14157 /*}-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14158 --- a/drivers/message/fusion/mptctl.c
14159 +++ b/drivers/message/fusion/mptctl.c
14160 @@ -45,6 +45,7 @@
14161 */
14162 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14163
14164 +#include <linux/version.h>
14165 #include <linux/kernel.h>
14166 #include <linux/module.h>
14167 #include <linux/errno.h>
14168 @@ -71,6 +72,15 @@
14169 #include "mptbase.h"
14170 #include "mptctl.h"
14171
14172 +#if defined(CPQ_CIM)
14173 +#include "mptsas.h"
14174 +#include "csmi/csmisas.h"
14175 +#endif // CPQ_CIM
14176 +
14177 +#if defined(DIAG_BUFFER_SUPPORT)
14178 +#include "rejected_ioctls/diag_buffer.h"
14179 +#endif
14180 +
14181 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14182 #define my_NAME "Fusion MPT misc device (ioctl) driver"
14183 #define my_VERSION MPT_LINUX_VERSION_COMMON
14184 @@ -84,6 +94,7 @@ MODULE_VERSION(my_VERSION);
14185 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14186
14187 static u8 mptctl_id = MPT_MAX_PROTOCOL_DRIVERS;
14188 +static u8 mptctl_taskmgmt_id = MPT_MAX_PROTOCOL_DRIVERS;
14189
14190 static DECLARE_WAIT_QUEUE_HEAD ( mptctl_wait );
14191
14192 @@ -112,6 +123,42 @@ static int mptctl_do_reset(unsigned long
14193 static int mptctl_hp_hostinfo(unsigned long arg, unsigned int cmd);
14194 static int mptctl_hp_targetinfo(unsigned long arg);
14195
14196 +#if defined(CPQ_CIM)
14197 +/* csmisas proto's*/
14198 +static int csmisas_get_driver_info(unsigned long arg);
14199 +static int csmisas_get_cntlr_status(unsigned long arg);
14200 +static int csmisas_get_cntlr_config(unsigned long arg);
14201 +static int csmisas_get_phy_info(unsigned long arg);
14202 +static int csmisas_get_scsi_address(unsigned long arg);
14203 +static int csmisas_get_link_errors(unsigned long arg);
14204 +static int csmisas_smp_passthru(unsigned long arg);
14205 +static int csmisas_firmware_download(unsigned long arg);
14206 +static int csmisas_get_raid_info(unsigned long arg);
14207 +static int csmisas_get_raid_config(unsigned long arg);
14208 +static int csmisas_get_raid_features(unsigned long arg);
14209 +static int csmisas_set_raid_control(unsigned long arg);
14210 +static int csmisas_get_raid_element(unsigned long arg);
14211 +static int csmisas_set_raid_operation(unsigned long arg);
14212 +static int csmisas_set_phy_info(unsigned long arg);
14213 +static int csmisas_ssp_passthru(unsigned long arg);
14214 +static int csmisas_stp_passthru(unsigned long arg);
14215 +static int csmisas_get_sata_signature(unsigned long arg);
14216 +static int csmisas_get_device_address(unsigned long arg);
14217 +static int csmisas_task_managment(unsigned long arg);
14218 +static int csmisas_phy_control(unsigned long arg);
14219 +static int csmisas_get_connector_info(unsigned long arg);
14220 +static int csmisas_get_location(unsigned long arg);
14221 +#endif // CPQ_CIM
14222 +
14223 +#if defined(DIAG_BUFFER_SUPPORT)
14224 +/* diag_buffer proto's */
14225 +static int mptctl_register_diag_buffer(unsigned long arg);
14226 +static int mptctl_release_diag_buffer(unsigned long arg);
14227 +static int mptctl_unregister_diag_buffer(unsigned long arg);
14228 +static int mptctl_query_diag_buffer(unsigned long arg);
14229 +static int mptctl_read_diag_buffer(unsigned long arg);
14230 +#endif // DIAG_BUFFER_SUPPORT
14231 +
14232 static int mptctl_probe(struct pci_dev *, const struct pci_device_id *);
14233 static void mptctl_remove(struct pci_dev *);
14234
14235 @@ -127,10 +174,6 @@ static MptSge_t *kbuf_alloc_2_sgl(int by
14236 struct buflist **blp, dma_addr_t *sglbuf_dma, MPT_ADAPTER *ioc);
14237 static void kfree_sgl(MptSge_t *sgl, dma_addr_t sgl_dma,
14238 struct buflist *buflist, MPT_ADAPTER *ioc);
14239 -static void mptctl_timeout_expired (MPT_IOCTL *ioctl);
14240 -static int mptctl_bus_reset(MPT_IOCTL *ioctl);
14241 -static int mptctl_set_tm_flags(MPT_SCSI_HOST *hd);
14242 -static void mptctl_free_tm_flags(MPT_ADAPTER *ioc);
14243
14244 /*
14245 * Reset Handler cleanup function
14246 @@ -183,10 +226,10 @@ mptctl_syscall_down(MPT_ADAPTER *ioc, in
14247 int rc = 0;
14248
14249 if (nonblock) {
14250 - if (!mutex_trylock(&ioc->ioctl->ioctl_mutex))
14251 + if (!mutex_trylock(&ioc->ioctl_cmds.mutex))
14252 rc = -EAGAIN;
14253 } else {
14254 - if (mutex_lock_interruptible(&ioc->ioctl->ioctl_mutex))
14255 + if (mutex_lock_interruptible(&ioc->ioctl_cmds.mutex))
14256 rc = -ERESTARTSYS;
14257 }
14258 return rc;
14259 @@ -202,131 +245,104 @@ mptctl_syscall_down(MPT_ADAPTER *ioc, in
14260 static int
14261 mptctl_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
14262 {
14263 - char *sense_data;
14264 - int sz, req_index;
14265 - u16 iocStatus;
14266 - u8 cmd;
14267 -
14268 - if (req)
14269 - cmd = req->u.hdr.Function;
14270 - else
14271 - return 1;
14272 - dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tcompleting mpi function (0x%02X), req=%p, "
14273 - "reply=%p\n", ioc->name, req->u.hdr.Function, req, reply));
14274 -
14275 - if (ioc->ioctl) {
14276 + char *sense_data;
14277 + int req_index;
14278 + int sz;
14279
14280 - if (reply==NULL) {
14281 + if (!req)
14282 + return 0;
14283
14284 - dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_reply() NULL Reply "
14285 - "Function=%x!\n", ioc->name, cmd));
14286 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "completing mpi function "
14287 + "(0x%02X), req=%p, reply=%p\n", ioc->name, req->u.hdr.Function,
14288 + req, reply));
14289
14290 - ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
14291 - ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
14292 + /*
14293 + * Handling continuation of the same reply. Processing the first
14294 + * reply, and eating the other replys that come later.
14295 + */
14296 + if (ioc->ioctl_cmds.msg_context != req->u.hdr.MsgContext)
14297 + goto out_continuation;
14298
14299 - /* We are done, issue wake up
14300 - */
14301 - ioc->ioctl->wait_done = 1;
14302 - wake_up (&mptctl_wait);
14303 - return 1;
14304 + ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
14305
14306 - }
14307 + if (!reply)
14308 + goto out;
14309
14310 - /* Copy the reply frame (which much exist
14311 - * for non-SCSI I/O) to the IOC structure.
14312 - */
14313 - memcpy(ioc->ioctl->ReplyFrame, reply,
14314 - min(ioc->reply_sz, 4*reply->u.reply.MsgLength));
14315 - ioc->ioctl->status |= MPT_IOCTL_STATUS_RF_VALID;
14316 + ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
14317 + sz = min(ioc->reply_sz, 4*reply->u.reply.MsgLength);
14318 + memcpy(ioc->ioctl_cmds.reply, reply, sz);
14319
14320 - /* Set the command status to GOOD if IOC Status is GOOD
14321 - * OR if SCSI I/O cmd and data underrun or recovered error.
14322 - */
14323 - iocStatus = le16_to_cpu(reply->u.reply.IOCStatus) & MPI_IOCSTATUS_MASK;
14324 - if (iocStatus == MPI_IOCSTATUS_SUCCESS)
14325 - ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
14326 -
14327 - if (iocStatus || reply->u.reply.IOCLogInfo)
14328 - dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tiocstatus (0x%04X), "
14329 - "loginfo (0x%08X)\n", ioc->name,
14330 - iocStatus,
14331 - le32_to_cpu(reply->u.reply.IOCLogInfo)));
14332 -
14333 - if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
14334 - (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
14335 -
14336 - if (reply->u.sreply.SCSIStatus || reply->u.sreply.SCSIState)
14337 - dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14338 - "\tscsi_status (0x%02x), scsi_state (0x%02x), "
14339 - "tag = (0x%04x), transfer_count (0x%08x)\n", ioc->name,
14340 - reply->u.sreply.SCSIStatus,
14341 - reply->u.sreply.SCSIState,
14342 - le16_to_cpu(reply->u.sreply.TaskTag),
14343 - le32_to_cpu(reply->u.sreply.TransferCount)));
14344 -
14345 - ioc->ioctl->reset &= ~MPTCTL_RESET_OK;
14346 -
14347 - if ((iocStatus == MPI_IOCSTATUS_SCSI_DATA_UNDERRUN) ||
14348 - (iocStatus == MPI_IOCSTATUS_SCSI_RECOVERED_ERROR)) {
14349 - ioc->ioctl->status |= MPT_IOCTL_STATUS_COMMAND_GOOD;
14350 - }
14351 - }
14352 + if (reply->u.reply.IOCStatus || reply->u.reply.IOCLogInfo)
14353 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14354 + "iocstatus (0x%04X), loginfo (0x%08X)\n", ioc->name,
14355 + le16_to_cpu(reply->u.reply.IOCStatus),
14356 + le32_to_cpu(reply->u.reply.IOCLogInfo)));
14357 +
14358 + if ((req->u.hdr.Function == MPI_FUNCTION_SCSI_IO_REQUEST) ||
14359 + (req->u.hdr.Function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
14360 +
14361 + if (reply->u.sreply.SCSIStatus || reply->u.sreply.SCSIState)
14362 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14363 + "scsi_status (0x%02x), scsi_state (0x%02x), "
14364 + "tag = (0x%04x), transfer_count (0x%08x)\n", ioc->name,
14365 + reply->u.sreply.SCSIStatus,
14366 + reply->u.sreply.SCSIState,
14367 + le16_to_cpu(reply->u.sreply.TaskTag),
14368 + le32_to_cpu(reply->u.sreply.TransferCount)));
14369
14370 - /* Copy the sense data - if present
14371 - */
14372 - if ((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) &&
14373 - (reply->u.sreply.SCSIState &
14374 - MPI_SCSI_STATE_AUTOSENSE_VALID)){
14375 + if (reply->u.sreply.SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
14376 sz = req->u.scsireq.SenseBufferLength;
14377 req_index =
14378 le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
14379 - sense_data =
14380 - ((u8 *)ioc->sense_buf_pool +
14381 + sense_data = ((u8 *)ioc->sense_buf_pool +
14382 (req_index * MPT_SENSE_BUFFER_ALLOC));
14383 - memcpy(ioc->ioctl->sense, sense_data, sz);
14384 - ioc->ioctl->status |= MPT_IOCTL_STATUS_SENSE_VALID;
14385 + memcpy(ioc->ioctl_cmds.sense, sense_data, sz);
14386 + ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_SENSE_VALID;
14387 }
14388 + }
14389
14390 - if (cmd == MPI_FUNCTION_SCSI_TASK_MGMT)
14391 - mptctl_free_tm_flags(ioc);
14392 -
14393 - /* We are done, issue wake up
14394 - */
14395 - ioc->ioctl->wait_done = 1;
14396 - wake_up (&mptctl_wait);
14397 + out:
14398 + /* We are done, issue wake up
14399 + */
14400 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
14401 + if (req->u.hdr.Function == MPI_FUNCTION_SCSI_TASK_MGMT)
14402 + mpt_clear_taskmgmt_in_progress_flag(ioc);
14403 + ioc->ioctl_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
14404 + complete(&ioc->ioctl_cmds.done);
14405 }
14406 +
14407 + out_continuation:
14408 + if (reply && (reply->u.reply.MsgFlags &
14409 + MPI_MSGFLAGS_CONTINUATION_REPLY))
14410 + return 0;
14411 return 1;
14412 }
14413
14414 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14415 -/* mptctl_timeout_expired
14416 - *
14417 - * Expecting an interrupt, however timed out.
14418 - *
14419 - */
14420 -static void mptctl_timeout_expired (MPT_IOCTL *ioctl)
14421 +static int
14422 +mptctl_taskmgmt_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
14423 {
14424 - int rc = 1;
14425 + if (!mf)
14426 + return 0;
14427
14428 - dctlprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT ": Timeout Expired! Host %d\n",
14429 - ioctl->ioc->name, ioctl->ioc->id));
14430 - if (ioctl == NULL)
14431 - return;
14432 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed (mf=%p, mr=%p)\n",
14433 + ioc->name, mf, mr));
14434
14435 - ioctl->wait_done = 0;
14436 - if (ioctl->reset & MPTCTL_RESET_OK)
14437 - rc = mptctl_bus_reset(ioctl);
14438 -
14439 - if (rc) {
14440 - /* Issue a reset for this device.
14441 - * The IOC is not responding.
14442 - */
14443 - dctlprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
14444 - ioctl->ioc->name));
14445 - mpt_HardResetHandler(ioctl->ioc, CAN_SLEEP);
14446 - }
14447 - return;
14448 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
14449 +
14450 + if (!mr)
14451 + goto out;
14452
14453 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
14454 + memcpy(ioc->taskmgmt_cmds.reply, mr,
14455 + min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
14456 + out:
14457 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
14458 + mpt_clear_taskmgmt_in_progress_flag(ioc);
14459 + ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
14460 + complete(&ioc->taskmgmt_cmds.done);
14461 + return 1;
14462 + }
14463 + return 0;
14464 }
14465
14466 /* mptctl_bus_reset
14467 @@ -334,132 +350,181 @@ static void mptctl_timeout_expired (MPT_
14468 * Bus reset code.
14469 *
14470 */
14471 -static int mptctl_bus_reset(MPT_IOCTL *ioctl)
14472 +static int
14473 +mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
14474 {
14475 MPT_FRAME_HDR *mf;
14476 SCSITaskMgmt_t *pScsiTm;
14477 - MPT_SCSI_HOST *hd;
14478 + SCSITaskMgmtReply_t *pScsiTmReply;
14479 int ii;
14480 - int retval=0;
14481 -
14482 -
14483 - ioctl->reset &= ~MPTCTL_RESET_OK;
14484 -
14485 - if (ioctl->ioc->sh == NULL)
14486 + int retval;
14487 + unsigned long timeout;
14488 + unsigned long time_count;
14489 + u16 iocstatus;
14490 +
14491 + /* bus reset is only good for SCSI IO, RAID PASSTHRU */
14492 + if (!(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) ||
14493 + (function == MPI_FUNCTION_SCSI_IO_REQUEST)) {
14494 + dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt, not SCSI_IO!!\n",
14495 + ioc->name));
14496 return -EPERM;
14497 + }
14498
14499 - hd = shost_priv(ioctl->ioc->sh);
14500 - if (hd == NULL)
14501 + mutex_lock(&ioc->taskmgmt_cmds.mutex);
14502 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
14503 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
14504 return -EPERM;
14505 + }
14506
14507 - /* Single threading ....
14508 - */
14509 - if (mptctl_set_tm_flags(hd) != 0)
14510 - return -EPERM;
14511 + retval = 0;
14512
14513 /* Send request
14514 */
14515 - if ((mf = mpt_get_msg_frame(mptctl_id, ioctl->ioc)) == NULL) {
14516 - dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt, no msg frames!!\n",
14517 - ioctl->ioc->name));
14518 -
14519 - mptctl_free_tm_flags(ioctl->ioc);
14520 - return -ENOMEM;
14521 + if ((mf = mpt_get_msg_frame(mptctl_taskmgmt_id, ioc)) == NULL) {
14522 + dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
14523 + ioc->name));
14524 + mpt_clear_taskmgmt_in_progress_flag(ioc);
14525 + retval = -ENOMEM;
14526 + goto mptctl_bus_reset_done;
14527 }
14528
14529 - dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt request @ %p\n",
14530 - ioctl->ioc->name, mf));
14531 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
14532 + ioc->name, mf));
14533
14534 pScsiTm = (SCSITaskMgmt_t *) mf;
14535 - pScsiTm->TargetID = ioctl->id;
14536 - pScsiTm->Bus = hd->port; /* 0 */
14537 - pScsiTm->ChainOffset = 0;
14538 + memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
14539 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
14540 - pScsiTm->Reserved = 0;
14541 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS;
14542 - pScsiTm->Reserved1 = 0;
14543 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
14544 -
14545 + pScsiTm->TargetID = 0;
14546 + pScsiTm->Bus = 0;
14547 + pScsiTm->ChainOffset = 0;
14548 + pScsiTm->Reserved = 0;
14549 + pScsiTm->Reserved1 = 0;
14550 + pScsiTm->TaskMsgContext = 0;
14551 for (ii= 0; ii < 8; ii++)
14552 pScsiTm->LUN[ii] = 0;
14553 -
14554 for (ii=0; ii < 7; ii++)
14555 pScsiTm->Reserved2[ii] = 0;
14556
14557 - pScsiTm->TaskMsgContext = 0;
14558 - dtmprintk(ioctl->ioc, printk(MYIOC_s_DEBUG_FMT
14559 - "mptctl_bus_reset: issued.\n", ioctl->ioc->name));
14560 -
14561 - DBG_DUMP_TM_REQUEST_FRAME(ioctl->ioc, (u32 *)mf);
14562 + switch (ioc->bus_type) {
14563 + case FC:
14564 + timeout = 40;
14565 + break;
14566 + case SAS:
14567 + timeout = 30;
14568 + break;
14569 + case SPI:
14570 + default:
14571 + timeout = 2;
14572 + break;
14573 + }
14574
14575 - ioctl->wait_done=0;
14576 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
14577 + ioc->name, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, timeout));
14578
14579 - if ((ioctl->ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
14580 - (ioctl->ioc->facts.MsgVersion >= MPI_VERSION_01_05))
14581 - mpt_put_msg_frame_hi_pri(mptctl_id, ioctl->ioc, mf);
14582 + INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
14583 + CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
14584 + time_count = jiffies;
14585 + if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
14586 + (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
14587 + mpt_put_msg_frame_hi_pri(mptctl_taskmgmt_id, ioc, mf);
14588 else {
14589 - retval = mpt_send_handshake_request(mptctl_id, ioctl->ioc,
14590 - sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
14591 + retval = mpt_send_handshake_request(mptctl_taskmgmt_id, ioc,
14592 + sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
14593 if (retval != 0) {
14594 - dfailprintk(ioctl->ioc, printk(MYIOC_s_ERR_FMT "_send_handshake FAILED!"
14595 - " (hd %p, ioc %p, mf %p) \n", hd->ioc->name, hd,
14596 - hd->ioc, mf));
14597 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt send_handshake FAILED!"
14598 + " (ioc %p, mf %p, rc=%d) \n", ioc->name,
14599 + ioc, mf, retval));
14600 + mpt_clear_taskmgmt_in_progress_flag(ioc);
14601 goto mptctl_bus_reset_done;
14602 }
14603 }
14604
14605 /* Now wait for the command to complete */
14606 - ii = wait_event_timeout(mptctl_wait,
14607 - ioctl->wait_done == 1,
14608 - HZ*5 /* 5 second timeout */);
14609 -
14610 - if(ii <=0 && (ioctl->wait_done != 1 )) {
14611 - mpt_free_msg_frame(hd->ioc, mf);
14612 - ioctl->wait_done = 0;
14613 - retval = -1; /* return failure */
14614 + ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
14615 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
14616 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14617 + "TaskMgmt failed\n", ioc->name));
14618 + mpt_free_msg_frame(ioc, mf);
14619 + mpt_clear_taskmgmt_in_progress_flag(ioc);
14620 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
14621 + retval = 0;
14622 + else
14623 + retval = -1; /* return failure */
14624 + goto mptctl_bus_reset_done;
14625 }
14626
14627 -mptctl_bus_reset_done:
14628 -
14629 - mptctl_free_tm_flags(ioctl->ioc);
14630 - return retval;
14631 -}
14632 -
14633 -static int
14634 -mptctl_set_tm_flags(MPT_SCSI_HOST *hd) {
14635 - unsigned long flags;
14636 -
14637 - spin_lock_irqsave(&hd->ioc->FreeQlock, flags);
14638 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
14639 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14640 + "TaskMgmt failed\n", ioc->name));
14641 + retval = -1; /* return failure */
14642 + goto mptctl_bus_reset_done;
14643 + }
14644
14645 - if (hd->tmState == TM_STATE_NONE) {
14646 - hd->tmState = TM_STATE_IN_PROGRESS;
14647 - hd->tmPending = 1;
14648 - spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
14649 - } else {
14650 - spin_unlock_irqrestore(&hd->ioc->FreeQlock, flags);
14651 - return -EBUSY;
14652 + pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
14653 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14654 + "TaskMgmt fw_channel = %d, fw_id = %d, task_type=0x%02X, "
14655 + "iocstatus=0x%04X\n\tloginfo=0x%08X, response_code=0x%02X, "
14656 + "term_cmnds=%d\n", ioc->name, pScsiTmReply->Bus,
14657 + pScsiTmReply->TargetID, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
14658 + le16_to_cpu(pScsiTmReply->IOCStatus),
14659 + le32_to_cpu(pScsiTmReply->IOCLogInfo),
14660 + pScsiTmReply->ResponseCode,
14661 + le32_to_cpu(pScsiTmReply->TerminationCount)));
14662 +
14663 + iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
14664 +
14665 + if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
14666 + iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
14667 + iocstatus == MPI_IOCSTATUS_SUCCESS)
14668 + retval = 0;
14669 + else {
14670 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14671 + "TaskMgmt failed\n", ioc->name));
14672 + retval = -1; /* return failure */
14673 }
14674
14675 - return 0;
14676 +
14677 + mptctl_bus_reset_done:
14678 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
14679 + CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
14680 + return retval;
14681 }
14682
14683 static void
14684 -mptctl_free_tm_flags(MPT_ADAPTER *ioc)
14685 +mptctl_timeout_expired(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
14686 {
14687 - MPT_SCSI_HOST * hd;
14688 unsigned long flags;
14689
14690 - hd = shost_priv(ioc->sh);
14691 - if (hd == NULL)
14692 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": %s\n",
14693 + ioc->name, __FUNCTION__));
14694 +
14695 + if(mpt_fwfault_debug)
14696 + mpt_halt_firmware(ioc);
14697 +
14698 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
14699 + if (ioc->ioc_reset_in_progress) {
14700 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
14701 + CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
14702 + mpt_free_msg_frame(ioc, mf);
14703 return;
14704 + }
14705 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
14706
14707 - spin_lock_irqsave(&ioc->FreeQlock, flags);
14708
14709 - hd->tmState = TM_STATE_NONE;
14710 - hd->tmPending = 0;
14711 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
14712 + if (!mptctl_bus_reset(ioc, mf->u.hdr.Function))
14713 + return;
14714
14715 - return;
14716 + /* Issue a reset for this device.
14717 + * The IOC is not responding.
14718 + */
14719 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
14720 + ioc->name));
14721 + CLEAR_MGMT_PENDING_STATUS(ioc->ioctl_cmds.status)
14722 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
14723 + mpt_HardResetHandler(ioc, CAN_SLEEP);
14724 + mpt_free_msg_frame(ioc, mf);
14725 }
14726
14727 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
14728 @@ -472,22 +537,23 @@ mptctl_free_tm_flags(MPT_ADAPTER *ioc)
14729 static int
14730 mptctl_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
14731 {
14732 - MPT_IOCTL *ioctl = ioc->ioctl;
14733 - dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOC %s_reset routed to IOCTL driver!\n", ioc->name,
14734 - reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
14735 - reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
14736 -
14737 - if(ioctl == NULL)
14738 - return 1;
14739 -
14740 switch(reset_phase) {
14741 case MPT_IOC_SETUP_RESET:
14742 - ioctl->status |= MPT_IOCTL_STATUS_DID_IOCRESET;
14743 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14744 + "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
14745 + break;
14746 + case MPT_IOC_PRE_RESET:
14747 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14748 + "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
14749 break;
14750 case MPT_IOC_POST_RESET:
14751 - ioctl->status &= ~MPT_IOCTL_STATUS_DID_IOCRESET;
14752 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
14753 + "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
14754 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_PENDING) {
14755 + ioc->ioctl_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
14756 + complete(&ioc->ioctl_cmds.done);
14757 + }
14758 break;
14759 - case MPT_IOC_PRE_RESET:
14760 default:
14761 break;
14762 }
14763 @@ -505,7 +571,7 @@ mptctl_event_process(MPT_ADAPTER *ioc, E
14764 event = le32_to_cpu(pEvReply->Event) & 0xFF;
14765
14766 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s() called\n",
14767 - ioc->name, __func__));
14768 + ioc->name, __FUNCTION__));
14769 if(async_queue == NULL)
14770 return 1;
14771
14772 @@ -548,15 +614,11 @@ static int
14773 mptctl_fasync(int fd, struct file *filep, int mode)
14774 {
14775 MPT_ADAPTER *ioc;
14776 - int ret;
14777
14778 - lock_kernel();
14779 list_for_each_entry(ioc, &ioc_list, list)
14780 ioc->aen_event_read_flag=0;
14781
14782 - ret = fasync_helper(fd, filep, mode, &async_queue);
14783 - unlock_kernel();
14784 - return ret;
14785 + return fasync_helper(fd, filep, mode, &async_queue);
14786 }
14787
14788 static int
14789 @@ -582,6 +644,7 @@ __mptctl_ioctl(struct file *file, unsign
14790 int ret;
14791 MPT_ADAPTER *iocp = NULL;
14792
14793 +
14794 if (copy_from_user(&khdr, uhdr, sizeof(khdr))) {
14795 printk(KERN_ERR MYNAM "%s::mptctl_ioctl() @%d - "
14796 "Unable to copy mpt_ioctl_header data @ %p\n",
14797 @@ -596,17 +659,12 @@ __mptctl_ioctl(struct file *file, unsign
14798 iocnumX = khdr.iocnum & 0xFF;
14799 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
14800 (iocp == NULL)) {
14801 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
14802 printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - ioc%d not found!\n",
14803 __FILE__, __LINE__, iocnumX);
14804 return -ENODEV;
14805 }
14806
14807 - if (!iocp->active) {
14808 - printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
14809 - __FILE__, __LINE__);
14810 - return -EFAULT;
14811 - }
14812 -
14813 /* Handle those commands that are just returning
14814 * information stored in the driver.
14815 * These commands should never time out and are unaffected
14816 @@ -626,6 +684,25 @@ __mptctl_ioctl(struct file *file, unsign
14817 return mptctl_eventreport(arg);
14818 } else if (cmd == MPTFWREPLACE) {
14819 return mptctl_replace_fw(arg);
14820 +#if defined(DIAG_BUFFER_SUPPORT)
14821 +/* diag_buffer static data calls*/
14822 + } else if (cmd == MPTDIAGQUERY) {
14823 + return mptctl_query_diag_buffer(arg);
14824 + } else if (cmd == MPTDIAGUNREGISTER) {
14825 + return mptctl_unregister_diag_buffer(arg);
14826 +#endif
14827 +
14828 +#if defined(CPQ_CIM)
14829 +/* csmisas static data calls*/
14830 + } else if (cmd == CC_CSMI_SAS_GET_DRIVER_INFO) {
14831 + return csmisas_get_driver_info(arg);
14832 + } else if (cmd == CC_CSMI_SAS_GET_CNTLR_STATUS) {
14833 + return csmisas_get_cntlr_status(arg);
14834 + } else if (cmd == CC_CSMI_SAS_GET_SCSI_ADDRESS) {
14835 + return csmisas_get_scsi_address(arg);
14836 + } else if (cmd == CC_CSMI_SAS_GET_DEVICE_ADDRESS){
14837 + return csmisas_get_device_address(arg);
14838 +#endif // CPQ_CIM
14839 }
14840
14841 /* All of these commands require an interrupt or
14842 @@ -634,6 +711,8 @@ __mptctl_ioctl(struct file *file, unsign
14843 if ((ret = mptctl_syscall_down(iocp, nonblock)) != 0)
14844 return ret;
14845
14846 +// dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT ": mptctl_ioctl()\n", iocp->name));
14847 +
14848 if (cmd == MPTFWDOWNLOAD)
14849 ret = mptctl_fw_download(arg);
14850 else if (cmd == MPTCOMMAND)
14851 @@ -644,10 +723,61 @@ __mptctl_ioctl(struct file *file, unsign
14852 ret = mptctl_hp_hostinfo(arg, _IOC_SIZE(cmd));
14853 else if (cmd == HP_GETTARGETINFO)
14854 ret = mptctl_hp_targetinfo(arg);
14855 +#if defined(CPQ_CIM)
14856 +/* csmisas requiring fw calls*/
14857 + else if (cmd == CC_CSMI_SAS_GET_CNTLR_CONFIG)
14858 + ret = csmisas_get_cntlr_config(arg);
14859 + else if (cmd == CC_CSMI_SAS_GET_PHY_INFO)
14860 + ret = csmisas_get_phy_info(arg);
14861 + else if (cmd == CC_CSMI_SAS_GET_SATA_SIGNATURE)
14862 + ret = csmisas_get_sata_signature(arg);
14863 + else if (cmd == CC_CSMI_SAS_GET_LINK_ERRORS)
14864 + ret = csmisas_get_link_errors(arg);
14865 + else if (cmd == CC_CSMI_SAS_SMP_PASSTHRU)
14866 + ret = csmisas_smp_passthru(arg);
14867 + else if (cmd == CC_CSMI_SAS_SSP_PASSTHRU)
14868 + ret = csmisas_ssp_passthru(arg);
14869 + else if (cmd == CC_CSMI_SAS_FIRMWARE_DOWNLOAD)
14870 + ret = csmisas_firmware_download(arg);
14871 + else if (cmd == CC_CSMI_SAS_GET_RAID_INFO)
14872 + ret = csmisas_get_raid_info(arg);
14873 + else if (cmd == CC_CSMI_SAS_GET_RAID_CONFIG)
14874 + ret = csmisas_get_raid_config(arg);
14875 + else if (cmd == CC_CSMI_SAS_GET_RAID_FEATURES)
14876 + ret = csmisas_get_raid_features(arg);
14877 + else if (cmd == CC_CSMI_SAS_SET_RAID_CONTROL)
14878 + ret = csmisas_set_raid_control(arg);
14879 + else if (cmd == CC_CSMI_SAS_GET_RAID_ELEMENT)
14880 + ret = csmisas_get_raid_element(arg);
14881 + else if (cmd == CC_CSMI_SAS_SET_RAID_OPERATION)
14882 + ret = csmisas_set_raid_operation(arg);
14883 + else if (cmd == CC_CSMI_SAS_SET_PHY_INFO)
14884 + ret = csmisas_set_phy_info(arg);
14885 + else if (cmd == CC_CSMI_SAS_STP_PASSTHRU)
14886 + ret = csmisas_stp_passthru(arg);
14887 + else if (cmd == CC_CSMI_SAS_TASK_MANAGEMENT)
14888 + ret = csmisas_task_managment(arg);
14889 + else if (cmd == CC_CSMI_SAS_PHY_CONTROL)
14890 + ret = csmisas_phy_control(arg);
14891 + else if (cmd == CC_CSMI_SAS_GET_CONNECTOR_INFO)
14892 + ret = csmisas_get_connector_info(arg);
14893 + else if (cmd == CC_CSMI_SAS_GET_LOCATION)
14894 + ret = csmisas_get_location(arg);
14895 +#endif // CPQ_CIM
14896 +
14897 +#if defined(DIAG_BUFFER_SUPPORT)
14898 +/* diag_buffer requiring fw calls*/
14899 + else if (cmd == MPTDIAGREGISTER)
14900 + ret = mptctl_register_diag_buffer(arg);
14901 + else if (cmd == MPTDIAGRELEASE)
14902 + ret = mptctl_release_diag_buffer(arg);
14903 + else if (cmd == MPTDIAGREADBUFFER)
14904 + ret = mptctl_read_diag_buffer(arg);
14905 +#endif // DIAG_BUFFER_SUPPORT
14906 else
14907 ret = -EINVAL;
14908
14909 - mutex_unlock(&iocp->ioctl->ioctl_mutex);
14910 + mutex_unlock(&iocp->ioctl_cmds.mutex);
14911
14912 return ret;
14913 }
14914 @@ -676,6 +806,7 @@ static int mptctl_do_reset(unsigned long
14915 }
14916
14917 if (mpt_verify_adapter(krinfo.hdr.iocnum, &iocp) < 0) {
14918 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
14919 printk(KERN_DEBUG MYNAM "%s@%d::mptctl_do_reset - ioc%d not found!\n",
14920 __FILE__, __LINE__, krinfo.hdr.iocnum);
14921 return -ENODEV; /* (-6) No such device or address */
14922 @@ -763,10 +894,11 @@ mptctl_do_fw_download(int ioc, char __us
14923 int sge_offset = 0;
14924 u16 iocstat;
14925 pFWDownloadReply_t ReplyMsg = NULL;
14926 + unsigned long timeleft;
14927
14928 if (mpt_verify_adapter(ioc, &iocp) < 0) {
14929 - printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n",
14930 - ioc);
14931 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
14932 + printk(KERN_DEBUG MYNAM "ioctl_fwdl - ioc%d not found!\n", ioc);
14933 return -ENODEV; /* (-6) No such device or address */
14934 } else {
14935
14936 @@ -847,10 +979,10 @@ mptctl_do_fw_download(int ioc, char __us
14937 * 64 4
14938 */
14939 maxfrags = (iocp->req_sz - sizeof(MPIHeader_t) - sizeof(FWDownloadTCSGE_t))
14940 - / (sizeof(dma_addr_t) + sizeof(u32));
14941 + / iocp->SGE_size;
14942 if (numfrags > maxfrags) {
14943 ret = -EMLINK;
14944 - goto fwdl_out;
14945 + goto fwdl_out;
14946 }
14947
14948 dctlprintk(iocp, printk(MYIOC_s_DEBUG_FMT "DbG: sgl buffer = %p, sgfrags = %d\n",
14949 @@ -875,19 +1007,19 @@ mptctl_do_fw_download(int ioc, char __us
14950 if (nib == 0 || nib == 3) {
14951 ;
14952 } else if (sgIn->Address) {
14953 - mpt_add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
14954 + iocp->add_sge(sgOut, sgIn->FlagsLength, sgIn->Address);
14955 n++;
14956 if (copy_from_user(bl->kptr, ufwbuf+fw_bytes_copied, bl->len)) {
14957 printk(MYIOC_s_ERR_FMT "%s@%d::_ioctl_fwdl - "
14958 - "Unable to copy f/w buffer hunk#%d @ %p\n",
14959 - iocp->name, __FILE__, __LINE__, n, ufwbuf);
14960 + "Unable to copy f/w buffer hunk#%d @ %p\n",
14961 + iocp->name, __FILE__, __LINE__, n, ufwbuf);
14962 goto fwdl_out;
14963 }
14964 fw_bytes_copied += bl->len;
14965 }
14966 sgIn++;
14967 bl++;
14968 - sgOut += (sizeof(dma_addr_t) + sizeof(u32));
14969 + sgOut += iocp->SGE_size;
14970 }
14971
14972 DBG_DUMP_FW_DOWNLOAD(iocp, (u32 *)mf, numfrags);
14973 @@ -896,16 +1028,27 @@ mptctl_do_fw_download(int ioc, char __us
14974 * Finally, perform firmware download.
14975 */
14976 ReplyMsg = NULL;
14977 + SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, dlmsg->MsgContext);
14978 + INITIALIZE_MGMT_STATUS(iocp->ioctl_cmds.status)
14979 mpt_put_msg_frame(mptctl_id, iocp, mf);
14980
14981 /* Now wait for the command to complete */
14982 - ret = wait_event_timeout(mptctl_wait,
14983 - iocp->ioctl->wait_done == 1,
14984 - HZ*60);
14985 -
14986 - if(ret <=0 && (iocp->ioctl->wait_done != 1 )) {
14987 - /* Now we need to reset the board */
14988 - mptctl_timeout_expired(iocp->ioctl);
14989 + timeleft = wait_for_completion_timeout(&iocp->ioctl_cmds.done, HZ*60);
14990 + if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
14991 + ret = -ETIME;
14992 + printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __FUNCTION__);
14993 + if (iocp->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
14994 + mpt_free_msg_frame(iocp, mf);
14995 + goto fwdl_out;
14996 + }
14997 + if (!timeleft)
14998 + mptctl_timeout_expired(iocp, mf);
14999 + goto fwdl_out;
15000 + }
15001 +
15002 + if (!(iocp->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
15003 + printk(MYIOC_s_WARN_FMT "%s: failed\n", iocp->name, __FUNCTION__);
15004 + mpt_free_msg_frame(iocp, mf);
15005 ret = -ENODATA;
15006 goto fwdl_out;
15007 }
15008 @@ -913,31 +1056,34 @@ mptctl_do_fw_download(int ioc, char __us
15009 if (sgl)
15010 kfree_sgl(sgl, sgl_dma, buflist, iocp);
15011
15012 - ReplyMsg = (pFWDownloadReply_t)iocp->ioctl->ReplyFrame;
15013 + ReplyMsg = (pFWDownloadReply_t)iocp->ioctl_cmds.reply;
15014 iocstat = le16_to_cpu(ReplyMsg->IOCStatus) & MPI_IOCSTATUS_MASK;
15015 if (iocstat == MPI_IOCSTATUS_SUCCESS) {
15016 - printk(MYIOC_s_INFO_FMT "F/W update successfull!\n", iocp->name);
15017 + printk(MYIOC_s_INFO_FMT ": F/W update successfully sent!\n", iocp->name);
15018 return 0;
15019 } else if (iocstat == MPI_IOCSTATUS_INVALID_FUNCTION) {
15020 - printk(MYIOC_s_WARN_FMT "Hmmm... F/W download not supported!?!\n",
15021 - iocp->name);
15022 + printk(MYIOC_s_WARN_FMT "Hmmm... doesn't support F/W download?\n",
15023 + iocp->name);
15024 printk(MYIOC_s_WARN_FMT "(time to go bang on somebodies door)\n",
15025 - iocp->name);
15026 + iocp->name);
15027 return -EBADRQC;
15028 } else if (iocstat == MPI_IOCSTATUS_BUSY) {
15029 printk(MYIOC_s_WARN_FMT "IOC_BUSY!\n", iocp->name);
15030 printk(MYIOC_s_WARN_FMT "(try again later?)\n", iocp->name);
15031 return -EBUSY;
15032 } else {
15033 - printk(MYIOC_s_WARN_FMT "ioctl_fwdl() returned [bad] status = %04xh\n",
15034 - iocp->name, iocstat);
15035 + printk(MYIOC_s_WARN_FMT "returned [bad] status = %04xh\n",
15036 + iocp->name, iocstat);
15037 printk(MYIOC_s_WARN_FMT "(bad VooDoo)\n", iocp->name);
15038 return -ENOMSG;
15039 }
15040 return 0;
15041
15042 fwdl_out:
15043 - kfree_sgl(sgl, sgl_dma, buflist, iocp);
15044 +
15045 + CLEAR_MGMT_STATUS(iocp->ioctl_cmds.status);
15046 + SET_MGMT_MSG_CONTEXT(iocp->ioctl_cmds.msg_context, 0);
15047 + kfree_sgl(sgl, sgl_dma, buflist, iocp);
15048 return ret;
15049 }
15050
15051 @@ -1008,7 +1154,7 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
15052 *
15053 */
15054 sgl = sglbuf;
15055 - sg_spill = ((ioc->req_sz - sge_offset)/(sizeof(dma_addr_t) + sizeof(u32))) - 1;
15056 + sg_spill = ((ioc->req_sz - sge_offset)/ioc->SGE_size) - 1;
15057 while (bytes_allocd < bytes) {
15058 this_alloc = min(alloc_sz, bytes-bytes_allocd);
15059 buflist[buflist_ent].len = this_alloc;
15060 @@ -1019,9 +1165,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
15061 alloc_sz = alloc_sz / 2;
15062 if (alloc_sz == 0) {
15063 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
15064 - "not enough memory! :-(\n", ioc->name);
15065 + "not enough memory! :-(\n", ioc->name);
15066 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
15067 - ioc->name, numfrags);
15068 + ioc->name, numfrags);
15069 goto free_and_fail;
15070 }
15071 continue;
15072 @@ -1029,7 +1175,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
15073 dma_addr_t dma_addr;
15074
15075 bytes_allocd += this_alloc;
15076 - sgl->FlagsLength = (0x10000000|MPT_SGE_FLAGS_ADDRESSING|sgdir|this_alloc);
15077 + sgl->FlagsLength = (0x10000000|sgdir|this_alloc);
15078 + if (ioc->sg_addr_size == sizeof(u64))
15079 + sgl->FlagsLength |= MPT_SGE_FLAGS_64_BIT_ADDRESSING;
15080 dma_addr = pci_map_single(ioc->pcidev, buflist[buflist_ent].kptr, this_alloc, dir);
15081 sgl->Address = dma_addr;
15082
15083 @@ -1044,8 +1192,8 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
15084
15085 /* Need to chain? */
15086 if (fragcnt == sg_spill) {
15087 - printk(MYIOC_s_WARN_FMT
15088 - "-SG: No can do - " "Chain required! :-(\n", ioc->name);
15089 + printk(MYIOC_s_WARN_FMT "-SG: No can do - "
15090 + "Chain required! :-(\n", ioc->name);
15091 printk(MYIOC_s_WARN_FMT "(freeing %d frags)\n", ioc->name, numfrags);
15092 goto free_and_fail;
15093 }
15094 @@ -1054,9 +1202,9 @@ kbuf_alloc_2_sgl(int bytes, u32 sgdir, i
15095 if (numfrags*8 > MAX_SGL_BYTES){
15096 /* GRRRRR... */
15097 printk(MYIOC_s_WARN_FMT "-SG: No can do - "
15098 - "too many SG frags! :-(\n", ioc->name);
15099 + "too many SG frags! :-(\n", ioc->name);
15100 printk(MYIOC_s_WARN_FMT "-SG: (freeing %d frags)\n",
15101 - ioc->name, numfrags);
15102 + ioc->name, numfrags);
15103 goto free_and_fail;
15104 }
15105 }
15106 @@ -1213,6 +1361,7 @@ mptctl_getiocinfo (unsigned long arg, un
15107
15108 if (((iocnum = mpt_verify_adapter(karg->hdr.iocnum, &ioc)) < 0) ||
15109 (ioc == NULL)) {
15110 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15111 printk(KERN_DEBUG MYNAM "%s::mptctl_getiocinfo() @%d - ioc%d not found!\n",
15112 __FILE__, __LINE__, iocnum);
15113 kfree(karg);
15114 @@ -1222,8 +1371,8 @@ mptctl_getiocinfo (unsigned long arg, un
15115 /* Verify the data transfer size is correct. */
15116 if (karg->hdr.maxDataSize != data_size) {
15117 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_getiocinfo - "
15118 - "Structure size mismatch. Command not completed.\n",
15119 - ioc->name, __FILE__, __LINE__);
15120 + "Structure size mismatch. Command not completed.\n",
15121 + ioc->name, __FILE__, __LINE__);
15122 kfree(karg);
15123 return -EFAULT;
15124 }
15125 @@ -1275,6 +1424,8 @@ mptctl_getiocinfo (unsigned long arg, un
15126 if (ioc->sh) {
15127 shost_for_each_device(sdev, ioc->sh) {
15128 vdevice = sdev->hostdata;
15129 + if (vdevice == NULL || vdevice->vtarget == NULL)
15130 + continue;
15131 if (vdevice->vtarget->tflags &
15132 MPT_TARGET_FLAGS_RAID_COMPONENT)
15133 continue;
15134 @@ -1346,6 +1497,7 @@ mptctl_gettargetinfo (unsigned long arg)
15135
15136 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15137 (ioc == NULL)) {
15138 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15139 printk(KERN_DEBUG MYNAM "%s::mptctl_gettargetinfo() @%d - ioc%d not found!\n",
15140 __FILE__, __LINE__, iocnum);
15141 return -ENODEV;
15142 @@ -1362,8 +1514,8 @@ mptctl_gettargetinfo (unsigned long arg)
15143 port = karg.hdr.port;
15144
15145 if (maxWordsLeft <= 0) {
15146 - printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
15147 - ioc->name, __FILE__, __LINE__);
15148 + printk(MYIOC_s_ERR_FMT "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
15149 + ioc->name, __FILE__, __LINE__);
15150 return -ENOMEM;
15151 }
15152
15153 @@ -1383,8 +1535,8 @@ mptctl_gettargetinfo (unsigned long arg)
15154 */
15155 pmem = kzalloc(numBytes, GFP_KERNEL);
15156 if (!pmem) {
15157 - printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_gettargetinfo() - no memory available!\n",
15158 - ioc->name, __FILE__, __LINE__);
15159 + printk(MYIOC_s_ERR_FMT "%s::mptctl_gettargetinfo() @%d - no memory available!\n",
15160 + ioc->name, __FILE__, __LINE__);
15161 return -ENOMEM;
15162 }
15163 pdata = (int *) pmem;
15164 @@ -1396,6 +1548,8 @@ mptctl_gettargetinfo (unsigned long arg)
15165 if (!maxWordsLeft)
15166 continue;
15167 vdevice = sdev->hostdata;
15168 + if (vdevice == NULL || vdevice->vtarget == NULL)
15169 + continue;
15170 if (vdevice->vtarget->tflags &
15171 MPT_TARGET_FLAGS_RAID_COMPONENT)
15172 continue;
15173 @@ -1460,6 +1614,7 @@ mptctl_readtest (unsigned long arg)
15174
15175 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15176 (ioc == NULL)) {
15177 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15178 printk(KERN_DEBUG MYNAM "%s::mptctl_readtest() @%d - ioc%d not found!\n",
15179 __FILE__, __LINE__, iocnum);
15180 return -ENODEV;
15181 @@ -1521,6 +1676,7 @@ mptctl_eventquery (unsigned long arg)
15182
15183 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15184 (ioc == NULL)) {
15185 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15186 printk(KERN_DEBUG MYNAM "%s::mptctl_eventquery() @%d - ioc%d not found!\n",
15187 __FILE__, __LINE__, iocnum);
15188 return -ENODEV;
15189 @@ -1560,6 +1716,7 @@ mptctl_eventenable (unsigned long arg)
15190
15191 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15192 (ioc == NULL)) {
15193 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15194 printk(KERN_DEBUG MYNAM "%s::mptctl_eventenable() @%d - ioc%d not found!\n",
15195 __FILE__, __LINE__, iocnum);
15196 return -ENODEV;
15197 @@ -1573,8 +1730,7 @@ mptctl_eventenable (unsigned long arg)
15198 int sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
15199 ioc->events = kzalloc(sz, GFP_KERNEL);
15200 if (!ioc->events) {
15201 - printk(MYIOC_s_ERR_FMT
15202 - ": ERROR - Insufficient memory to add adapter!\n",
15203 + printk(MYIOC_s_ERR_FMT "Insufficient memory to add adapter!\n",
15204 ioc->name);
15205 return -ENOMEM;
15206 }
15207 @@ -1609,13 +1765,14 @@ mptctl_eventreport (unsigned long arg)
15208
15209 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15210 (ioc == NULL)) {
15211 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15212 printk(KERN_DEBUG MYNAM "%s::mptctl_eventreport() @%d - ioc%d not found!\n",
15213 __FILE__, __LINE__, iocnum);
15214 return -ENODEV;
15215 }
15216 +
15217 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_eventreport called.\n",
15218 ioc->name));
15219 -
15220 numBytes = karg.hdr.maxDataSize - sizeof(mpt_ioctl_header);
15221 maxEvents = numBytes/sizeof(MPT_IOCTL_EVENTS);
15222
15223 @@ -1663,6 +1820,7 @@ mptctl_replace_fw (unsigned long arg)
15224
15225 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15226 (ioc == NULL)) {
15227 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15228 printk(KERN_DEBUG MYNAM "%s::mptctl_replace_fw() @%d - ioc%d not found!\n",
15229 __FILE__, __LINE__, iocnum);
15230 return -ENODEV;
15231 @@ -1694,8 +1852,8 @@ mptctl_replace_fw (unsigned long arg)
15232 */
15233 if (copy_from_user(ioc->cached_fw, uarg->newImage, newFwSize)) {
15234 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_replace_fw - "
15235 - "Unable to read in mpt_ioctl_replace_fw image "
15236 - "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
15237 + "Unable to read in mpt_ioctl_replace_fw image "
15238 + "@ %p\n", ioc->name, __FILE__, __LINE__, uarg);
15239 mpt_free_fw_memory(ioc);
15240 return -EFAULT;
15241 }
15242 @@ -1712,7 +1870,7 @@ mptctl_replace_fw (unsigned long arg)
15243 *
15244 * Outputs: None.
15245 * Return: 0 if successful
15246 - * -EBUSY if previous command timeout and IOC reset is not complete.
15247 + * -EBUSY if previous command timout and IOC reset is not complete.
15248 * -EFAULT if data unavailable
15249 * -ENODEV if no such device/adapter
15250 * -ETIME if timer expires
15251 @@ -1737,6 +1895,7 @@ mptctl_mpt_command (unsigned long arg)
15252
15253 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15254 (ioc == NULL)) {
15255 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15256 printk(KERN_DEBUG MYNAM "%s::mptctl_mpt_command() @%d - ioc%d not found!\n",
15257 __FILE__, __LINE__, iocnum);
15258 return -ENODEV;
15259 @@ -1752,7 +1911,7 @@ mptctl_mpt_command (unsigned long arg)
15260 *
15261 * Outputs: None.
15262 * Return: 0 if successful
15263 - * -EBUSY if previous command timeout and IOC reset is not complete.
15264 + * -EBUSY if previous command timout and IOC reset is not complete.
15265 * -EFAULT if data unavailable
15266 * -ENODEV if no such device/adapter
15267 * -ETIME if timer expires
15268 @@ -1775,8 +1934,11 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15269 int sz, rc = 0;
15270 int msgContext;
15271 u16 req_idx;
15272 - ulong timeout;
15273 + unsigned long timeout;
15274 + unsigned long timeleft;
15275 struct scsi_device *sdev;
15276 + unsigned long flags;
15277 + u8 function;
15278
15279 /* bufIn and bufOut are used for user to kernel space transfers
15280 */
15281 @@ -1785,28 +1947,28 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15282
15283 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15284 (ioc == NULL)) {
15285 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15286 printk(KERN_DEBUG MYNAM "%s::mptctl_do_mpt_command() @%d - ioc%d not found!\n",
15287 __FILE__, __LINE__, iocnum);
15288 return -ENODEV;
15289 }
15290 - if (!ioc->ioctl) {
15291 - printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
15292 - "No memory available during driver init.\n",
15293 - __FILE__, __LINE__);
15294 - return -ENOMEM;
15295 - } else if (ioc->ioctl->status & MPT_IOCTL_STATUS_DID_IOCRESET) {
15296 +
15297 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
15298 + if (ioc->ioc_reset_in_progress) {
15299 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
15300 printk(KERN_ERR MYNAM "%s@%d::mptctl_do_mpt_command - "
15301 - "Busy with IOC Reset \n", __FILE__, __LINE__);
15302 + "Busy with diagnostic reset\n", __FILE__, __LINE__);
15303 return -EBUSY;
15304 }
15305 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
15306
15307 /* Verify that the final request frame will not be too large.
15308 */
15309 sz = karg.dataSgeOffset * 4;
15310 if (karg.dataInSize > 0)
15311 - sz += sizeof(dma_addr_t) + sizeof(u32);
15312 + sz += ioc->SGE_size;
15313 if (karg.dataOutSize > 0)
15314 - sz += sizeof(dma_addr_t) + sizeof(u32);
15315 + sz += ioc->SGE_size;
15316
15317 if (sz > ioc->req_sz) {
15318 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15319 @@ -1832,18 +1994,19 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15320 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15321 "Unable to read MF from mpt_ioctl_command struct @ %p\n",
15322 ioc->name, __FILE__, __LINE__, mfPtr);
15323 + function = -1;
15324 rc = -EFAULT;
15325 goto done_free_mem;
15326 }
15327 hdr->MsgContext = cpu_to_le32(msgContext);
15328 -
15329 + function = hdr->Function;
15330
15331 /* Verify that this request is allowed.
15332 */
15333 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sending mpi function (0x%02X), req=%p\n",
15334 - ioc->name, hdr->Function, mf));
15335 + ioc->name, function, mf));
15336
15337 - switch (hdr->Function) {
15338 + switch (function) {
15339 case MPI_FUNCTION_IOC_FACTS:
15340 case MPI_FUNCTION_PORT_FACTS:
15341 karg.dataOutSize = karg.dataInSize = 0;
15342 @@ -1898,7 +2061,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15343 }
15344
15345 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
15346 - pScsiReq->MsgFlags |= mpt_msg_flags();
15347 + pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
15348
15349
15350 /* verify that app has not requested
15351 @@ -1920,6 +2083,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15352 struct scsi_target *starget = scsi_target(sdev);
15353 VirtTarget *vtarget = starget->hostdata;
15354
15355 + if (vtarget == NULL)
15356 + continue;
15357 if ((pScsiReq->TargetID == vtarget->id) &&
15358 (pScsiReq->Bus == vtarget->channel) &&
15359 (vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
15360 @@ -1940,9 +2105,6 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15361 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
15362 pScsiReq->DataLength = cpu_to_le32(dataSize);
15363
15364 - ioc->ioctl->reset = MPTCTL_RESET_OK;
15365 - ioc->ioctl->id = pScsiReq->TargetID;
15366 -
15367 } else {
15368 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15369 "SCSI driver is not loaded. \n",
15370 @@ -1955,7 +2117,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15371 case MPI_FUNCTION_SMP_PASSTHROUGH:
15372 /* Check mf->PassthruFlags to determine if
15373 * transfer is ImmediateMode or not.
15374 - * Immediate mode returns data in the ReplyFrame.
15375 + * Immediate mode returns data in the reply.
15376 * Else, we are sending request and response data
15377 * in two SGLs at the end of the mf.
15378 */
15379 @@ -1984,7 +2146,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15380 int dataSize;
15381
15382 pScsiReq->MsgFlags &= ~MPI_SCSIIO_MSGFLGS_SENSE_WIDTH;
15383 - pScsiReq->MsgFlags |= mpt_msg_flags();
15384 + pScsiReq->MsgFlags |= mpt_msg_flags(ioc);
15385
15386
15387 /* verify that app has not requested
15388 @@ -2019,8 +2181,6 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15389 pScsiReq->Control = cpu_to_le32(scsidir | qtag);
15390 pScsiReq->DataLength = cpu_to_le32(dataSize);
15391
15392 - ioc->ioctl->reset = MPTCTL_RESET_OK;
15393 - ioc->ioctl->id = pScsiReq->TargetID;
15394 } else {
15395 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15396 "SCSI driver is not loaded. \n",
15397 @@ -2031,20 +2191,15 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15398 break;
15399
15400 case MPI_FUNCTION_SCSI_TASK_MGMT:
15401 - {
15402 - MPT_SCSI_HOST *hd = NULL;
15403 - if ((ioc->sh == NULL) || ((hd = shost_priv(ioc->sh)) == NULL)) {
15404 - printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15405 - "SCSI driver not loaded or SCSI host not found. \n",
15406 - ioc->name, __FILE__, __LINE__);
15407 - rc = -EFAULT;
15408 - goto done_free_mem;
15409 - } else if (mptctl_set_tm_flags(hd) != 0) {
15410 - rc = -EPERM;
15411 - goto done_free_mem;
15412 - }
15413 - }
15414 + {
15415 + SCSITaskMgmt_t *pScsiTm;
15416 + pScsiTm = (SCSITaskMgmt_t *)mf;
15417 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\tTaskType=0x%x MsgFlags=0x%x "
15418 + "TaskMsgContext=0x%x id=%d channel=%d\n", ioc->name, pScsiTm->TaskType,
15419 + le32_to_cpu(pScsiTm->TaskMsgContext), pScsiTm->MsgFlags,
15420 + pScsiTm->TargetID, pScsiTm->Bus));
15421 break;
15422 + }
15423
15424 case MPI_FUNCTION_IOC_INIT:
15425 {
15426 @@ -2054,7 +2209,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15427 /* Verify that all entries in the IOC INIT match
15428 * existing setup (and in LE format).
15429 */
15430 - if (sizeof(dma_addr_t) == sizeof(u64)) {
15431 + if (ioc->sg_addr_size == sizeof(u64)) {
15432 high_addr = cpu_to_le32((u32)((u64)ioc->req_frames_dma >> 32));
15433 sense_high= cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
15434 } else {
15435 @@ -2062,6 +2217,11 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15436 sense_high= 0;
15437 }
15438
15439 + if (!pInit->MaxDevices && !pInit->MaxBuses) {
15440 + pInit->MaxDevices = ioc->facts.MaxDevices;
15441 + pInit->MaxBuses = ioc->facts.MaxBuses;
15442 + }
15443 +
15444 if ((pInit->Flags != 0) || (pInit->MaxDevices != ioc->facts.MaxDevices) ||
15445 (pInit->MaxBuses != ioc->facts.MaxBuses) ||
15446 (pInit->ReplyFrameSize != cpu_to_le16(ioc->reply_sz)) ||
15447 @@ -2102,7 +2262,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15448
15449 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15450 "Illegal request (function 0x%x) \n",
15451 - ioc->name, __FILE__, __LINE__, hdr->Function);
15452 + ioc->name, __FILE__, __LINE__, function);
15453 rc = -EFAULT;
15454 goto done_free_mem;
15455 }
15456 @@ -2128,8 +2288,7 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15457 if (karg.dataInSize > 0) {
15458 flagsLength = ( MPI_SGE_FLAGS_SIMPLE_ELEMENT |
15459 MPI_SGE_FLAGS_END_OF_BUFFER |
15460 - MPI_SGE_FLAGS_DIRECTION |
15461 - mpt_addr_size() )
15462 + MPI_SGE_FLAGS_DIRECTION )
15463 << MPI_SGE_FLAGS_SHIFT;
15464 } else {
15465 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
15466 @@ -2146,8 +2305,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15467 /* Set up this SGE.
15468 * Copy to MF and to sglbuf
15469 */
15470 - mpt_add_sge(psge, flagsLength, dma_addr_out);
15471 - psge += (sizeof(u32) + sizeof(dma_addr_t));
15472 + ioc->add_sge(psge, flagsLength, dma_addr_out);
15473 + psge += ioc->SGE_size;
15474
15475 /* Copy user data to kernel space.
15476 */
15477 @@ -2180,17 +2339,24 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15478 /* Set up this SGE
15479 * Copy to MF and to sglbuf
15480 */
15481 - mpt_add_sge(psge, flagsLength, dma_addr_in);
15482 + ioc->add_sge(psge, flagsLength, dma_addr_in);
15483 }
15484 }
15485 } else {
15486 /* Add a NULL SGE
15487 */
15488 - mpt_add_sge(psge, flagsLength, (dma_addr_t) -1);
15489 + ioc->add_sge(psge, flagsLength, (dma_addr_t) -1);
15490 }
15491
15492 - ioc->ioctl->wait_done = 0;
15493 - if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT) {
15494 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, hdr->MsgContext);
15495 + INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
15496 + if (function == MPI_FUNCTION_SCSI_TASK_MGMT) {
15497 +
15498 + mutex_lock(&ioc->taskmgmt_cmds.mutex);
15499 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
15500 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
15501 + goto done_free_mem;
15502 + }
15503
15504 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
15505
15506 @@ -2198,53 +2364,57 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15507 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
15508 mpt_put_msg_frame_hi_pri(mptctl_id, ioc, mf);
15509 else {
15510 - rc =mpt_send_handshake_request(mptctl_id, ioc,
15511 - sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
15512 + rc = mpt_send_handshake_request(mptctl_id, ioc,
15513 + sizeof(SCSITaskMgmt_t), (u32*)mf, CAN_SLEEP);
15514 if (rc != 0) {
15515 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
15516 - "_send_handshake FAILED! (ioc %p, mf %p)\n",
15517 + "send_handshake FAILED! (ioc %p, mf %p)\n",
15518 ioc->name, ioc, mf));
15519 - mptctl_free_tm_flags(ioc);
15520 + mpt_clear_taskmgmt_in_progress_flag(ioc);
15521 rc = -ENODATA;
15522 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
15523 goto done_free_mem;
15524 }
15525 }
15526 -
15527 } else
15528 mpt_put_msg_frame(mptctl_id, ioc, mf);
15529
15530 /* Now wait for the command to complete */
15531 timeout = (karg.timeout > 0) ? karg.timeout : MPT_IOCTL_DEFAULT_TIMEOUT;
15532 - timeout = wait_event_timeout(mptctl_wait,
15533 - ioc->ioctl->wait_done == 1,
15534 - HZ*timeout);
15535 -
15536 - if(timeout <=0 && (ioc->ioctl->wait_done != 1 )) {
15537 - /* Now we need to reset the board */
15538 -
15539 - if (hdr->Function == MPI_FUNCTION_SCSI_TASK_MGMT)
15540 - mptctl_free_tm_flags(ioc);
15541 -
15542 - mptctl_timeout_expired(ioc->ioctl);
15543 - rc = -ENODATA;
15544 + timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done, HZ*timeout);
15545 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
15546 + rc = -ETIME;
15547 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "%s: TIMED OUT!\n",
15548 + ioc->name, __FUNCTION__));
15549 + if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
15550 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
15551 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
15552 + goto done_free_mem;
15553 + }
15554 + if (!timeleft) {
15555 + mptctl_timeout_expired(ioc, mf);
15556 + mf = NULL;
15557 + }
15558 goto done_free_mem;
15559 }
15560
15561 + if (function == MPI_FUNCTION_SCSI_TASK_MGMT)
15562 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
15563 +
15564 mf = NULL;
15565
15566 /* If a valid reply frame, copy to the user.
15567 * Offset 2: reply length in U32's
15568 */
15569 - if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID) {
15570 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) {
15571 if (karg.maxReplyBytes < ioc->reply_sz) {
15572 - sz = min(karg.maxReplyBytes, 4*ioc->ioctl->ReplyFrame[2]);
15573 + sz = min(karg.maxReplyBytes, 4*ioc->ioctl_cmds.reply[2]);
15574 } else {
15575 - sz = min(ioc->reply_sz, 4*ioc->ioctl->ReplyFrame[2]);
15576 + sz = min(ioc->reply_sz, 4*ioc->ioctl_cmds.reply[2]);
15577 }
15578 -
15579 if (sz > 0) {
15580 if (copy_to_user(karg.replyFrameBufPtr,
15581 - &ioc->ioctl->ReplyFrame, sz)){
15582 + ioc->ioctl_cmds.reply, sz)){
15583 printk(MYIOC_s_ERR_FMT
15584 "%s@%d::mptctl_do_mpt_command - "
15585 "Unable to write out reply frame %p\n",
15586 @@ -2257,10 +2427,10 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15587
15588 /* If valid sense data, copy to user.
15589 */
15590 - if (ioc->ioctl->status & MPT_IOCTL_STATUS_SENSE_VALID) {
15591 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_SENSE_VALID) {
15592 sz = min(karg.maxSenseBytes, MPT_SENSE_BUFFER_SIZE);
15593 if (sz > 0) {
15594 - if (copy_to_user(karg.senseDataPtr, ioc->ioctl->sense, sz)) {
15595 + if (copy_to_user(karg.senseDataPtr, ioc->ioctl_cmds.sense, sz)) {
15596 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15597 "Unable to write sense data to user %p\n",
15598 ioc->name, __FILE__, __LINE__,
15599 @@ -2274,9 +2444,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15600 /* If the overall status is _GOOD and data in, copy data
15601 * to user.
15602 */
15603 - if ((ioc->ioctl->status & MPT_IOCTL_STATUS_COMMAND_GOOD) &&
15604 - (karg.dataInSize > 0) && (bufIn.kptr)) {
15605 -
15606 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD) &&
15607 + (karg.dataInSize > 0) && (bufIn.kptr)) {
15608 if (copy_to_user(karg.dataInBufPtr,
15609 bufIn.kptr, karg.dataInSize)) {
15610 printk(MYIOC_s_ERR_FMT "%s@%d::mptctl_do_mpt_command - "
15611 @@ -2289,9 +2458,8 @@ mptctl_do_mpt_command (struct mpt_ioctl_
15612
15613 done_free_mem:
15614
15615 - ioc->ioctl->status &= ~(MPT_IOCTL_STATUS_COMMAND_GOOD |
15616 - MPT_IOCTL_STATUS_SENSE_VALID |
15617 - MPT_IOCTL_STATUS_RF_VALID );
15618 + CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
15619 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
15620
15621 /* Free the allocated memory.
15622 */
15623 @@ -2320,7 +2488,7 @@ done_free_mem:
15624 * Outputs: None.
15625 * Return: 0 if successful
15626 * -EFAULT if data unavailable
15627 - * -EBUSY if previous command timeout and IOC reset is not complete.
15628 + * -EBUSY if previous command timout and IOC reset is not complete.
15629 * -ENODEV if no such device/adapter
15630 * -ETIME if timer expires
15631 * -ENOMEM if memory allocation error
15632 @@ -2331,16 +2499,17 @@ mptctl_hp_hostinfo(unsigned long arg, un
15633 hp_host_info_t __user *uarg = (void __user *) arg;
15634 MPT_ADAPTER *ioc;
15635 struct pci_dev *pdev;
15636 - char *pbuf=NULL;
15637 + char *pbuf=NULL;
15638 dma_addr_t buf_dma;
15639 hp_host_info_t karg;
15640 - CONFIGPARMS cfg;
15641 - ConfigPageHeader_t hdr;
15642 int iocnum;
15643 - int rc, cim_rev;
15644 + int cim_rev;
15645 ToolboxIstwiReadWriteRequest_t *IstwiRWRequest;
15646 MPT_FRAME_HDR *mf = NULL;
15647 MPIHeader_t *mpi_hdr;
15648 + unsigned long timeleft;
15649 + int retval;
15650 + u32 MsgContext;
15651
15652 /* Reset long to int. Should affect IA64 and SPARC only
15653 */
15654 @@ -2360,13 +2529,14 @@ mptctl_hp_hostinfo(unsigned long arg, un
15655
15656 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15657 (ioc == NULL)) {
15658 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15659 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_hostinfo() @%d - ioc%d not found!\n",
15660 __FILE__, __LINE__, iocnum);
15661 return -ENODEV;
15662 }
15663 +
15664 dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_hostinfo called.\n",
15665 ioc->name));
15666 -
15667 /* Fill in the data and return the structure to the calling
15668 * program
15669 */
15670 @@ -2406,42 +2576,9 @@ mptctl_hp_hostinfo(unsigned long arg, un
15671 karg.fw_version[10] = (ioc->facts.FWVersion.Struct.Dev % 10 ) + '0';
15672 karg.fw_version[11] = '\0';
15673
15674 - /* Issue a config request to get the device serial number
15675 - */
15676 - hdr.PageVersion = 0;
15677 - hdr.PageLength = 0;
15678 - hdr.PageNumber = 0;
15679 - hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
15680 - cfg.cfghdr.hdr = &hdr;
15681 - cfg.physAddr = -1;
15682 - cfg.pageAddr = 0;
15683 - cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
15684 - cfg.dir = 0; /* read */
15685 - cfg.timeout = 10;
15686 + strncpy(karg.serial_number, ioc->board_tracer, 16);
15687
15688 - strncpy(karg.serial_number, " ", 24);
15689 - if (mpt_config(ioc, &cfg) == 0) {
15690 - if (cfg.cfghdr.hdr->PageLength > 0) {
15691 - /* Issue the second config page request */
15692 - cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
15693 -
15694 - pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
15695 - if (pbuf) {
15696 - cfg.physAddr = buf_dma;
15697 - if (mpt_config(ioc, &cfg) == 0) {
15698 - ManufacturingPage0_t *pdata = (ManufacturingPage0_t *) pbuf;
15699 - if (strlen(pdata->BoardTracerNumber) > 1) {
15700 - strncpy(karg.serial_number, pdata->BoardTracerNumber, 24);
15701 - karg.serial_number[24-1]='\0';
15702 - }
15703 - }
15704 - pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
15705 - pbuf = NULL;
15706 - }
15707 - }
15708 - }
15709 - rc = mpt_GetIocState(ioc, 1);
15710 - switch (rc) {
15711 + switch (mpt_GetIocState(ioc, 1)) {
15712 case MPI_IOC_STATE_OPERATIONAL:
15713 karg.ioc_status = HP_STATUS_OK;
15714 break;
15715 @@ -2468,12 +2605,12 @@ mptctl_hp_hostinfo(unsigned long arg, un
15716 karg.soft_resets = 0;
15717 karg.timeouts = 0;
15718 if (ioc->sh != NULL) {
15719 - MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
15720 + MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata;
15721
15722 if (hd && (cim_rev == 1)) {
15723 - karg.hard_resets = hd->hard_resets;
15724 - karg.soft_resets = hd->soft_resets;
15725 - karg.timeouts = hd->timeouts;
15726 + karg.hard_resets = ioc->hard_resets;
15727 + karg.soft_resets = ioc->soft_resets;
15728 + karg.timeouts = ioc->timeouts;
15729 }
15730 }
15731
15732 @@ -2482,16 +2619,18 @@ mptctl_hp_hostinfo(unsigned long arg, un
15733 */
15734 if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL) {
15735 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
15736 - ioc->name,__func__));
15737 + ioc->name,__FUNCTION__));
15738 + retval = -ENOMEM;
15739 goto out;
15740 }
15741
15742 IstwiRWRequest = (ToolboxIstwiReadWriteRequest_t *)mf;
15743 mpi_hdr = (MPIHeader_t *) mf;
15744 + MsgContext = mpi_hdr->MsgContext;
15745 memset(IstwiRWRequest,0,sizeof(ToolboxIstwiReadWriteRequest_t));
15746 IstwiRWRequest->Function = MPI_FUNCTION_TOOLBOX;
15747 IstwiRWRequest->Tool = MPI_TOOLBOX_ISTWI_READ_WRITE_TOOL;
15748 - IstwiRWRequest->MsgContext = mpi_hdr->MsgContext;
15749 + IstwiRWRequest->MsgContext = MsgContext;
15750 IstwiRWRequest->Flags = MPI_TB_ISTWI_FLAGS_READ;
15751 IstwiRWRequest->NumAddressBytes = 0x01;
15752 IstwiRWRequest->DataLength = cpu_to_le16(0x04);
15753 @@ -2501,28 +2640,30 @@ mptctl_hp_hostinfo(unsigned long arg, un
15754 IstwiRWRequest->DeviceAddr = 0xB0;
15755
15756 pbuf = pci_alloc_consistent(ioc->pcidev, 4, &buf_dma);
15757 - if (!pbuf)
15758 + if (!pbuf) {
15759 + retval = -ENOMEM;
15760 goto out;
15761 - mpt_add_sge((char *)&IstwiRWRequest->SGL,
15762 - (MPT_SGE_FLAGS_SSIMPLE_READ|4), buf_dma);
15763 + }
15764 + ioc->add_sge((char *)&IstwiRWRequest->SGL, (MPT_SGE_FLAGS_SSIMPLE_READ|4),buf_dma);
15765
15766 - ioc->ioctl->wait_done = 0;
15767 + retval = 0;
15768 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, IstwiRWRequest->MsgContext);
15769 + INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
15770 mpt_put_msg_frame(mptctl_id, ioc, mf);
15771 -
15772 - rc = wait_event_timeout(mptctl_wait,
15773 - ioc->ioctl->wait_done == 1,
15774 - HZ*MPT_IOCTL_DEFAULT_TIMEOUT /* 10 sec */);
15775 -
15776 - if(rc <=0 && (ioc->ioctl->wait_done != 1 )) {
15777 - /*
15778 - * Now we need to reset the board
15779 - */
15780 - mpt_free_msg_frame(ioc, mf);
15781 - mptctl_timeout_expired(ioc->ioctl);
15782 + timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done, HZ*MPT_IOCTL_DEFAULT_TIMEOUT);
15783 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
15784 + retval = -ETIME;
15785 + printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name, __FUNCTION__);
15786 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
15787 + mpt_free_msg_frame(ioc, mf);
15788 + goto out;
15789 + }
15790 + if (!timeleft)
15791 + mptctl_timeout_expired(ioc, mf);
15792 goto out;
15793 }
15794
15795 - /*
15796 + /*
15797 *ISTWI Data Definition
15798 * pbuf[0] = FW_VERSION = 0x4
15799 * pbuf[1] = Bay Count = 6 or 4 or 2, depending on
15800 @@ -2531,10 +2672,13 @@ mptctl_hp_hostinfo(unsigned long arg, un
15801 * bays have drives in them
15802 * pbuf[3] = Checksum (0x100 = (byte0 + byte2 + byte3)
15803 */
15804 - if (ioc->ioctl->status & MPT_IOCTL_STATUS_RF_VALID)
15805 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID)
15806 karg.rsvd = *(u32 *)pbuf;
15807
15808 out:
15809 + CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
15810 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
15811 +
15812 if (pbuf)
15813 pci_free_consistent(ioc->pcidev, 4, pbuf, buf_dma);
15814
15815 @@ -2547,7 +2691,7 @@ mptctl_hp_hostinfo(unsigned long arg, un
15816 return -EFAULT;
15817 }
15818
15819 - return 0;
15820 + return retval;
15821
15822 }
15823
15824 @@ -2557,7 +2701,7 @@ mptctl_hp_hostinfo(unsigned long arg, un
15825 * Outputs: None.
15826 * Return: 0 if successful
15827 * -EFAULT if data unavailable
15828 - * -EBUSY if previous command timeout and IOC reset is not complete.
15829 + * -EBUSY if previous command timout and IOC reset is not complete.
15830 * -ENODEV if no such device/adapter
15831 * -ETIME if timer expires
15832 * -ENOMEM if memory allocation error
15833 @@ -2587,13 +2731,14 @@ mptctl_hp_targetinfo(unsigned long arg)
15834
15835 if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
15836 (ioc == NULL)) {
15837 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15838 printk(KERN_DEBUG MYNAM "%s::mptctl_hp_targetinfo() @%d - ioc%d not found!\n",
15839 __FILE__, __LINE__, iocnum);
15840 return -ENODEV;
15841 }
15842 - dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mptctl_hp_targetinfo called.\n",
15843 - ioc->name));
15844
15845 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": mptctl_hp_targetinfo called.\n",
15846 + ioc->name));
15847 /* There is nothing to do for FCP parts.
15848 */
15849 if ((ioc->bus_type == SAS) || (ioc->bus_type == FC))
15850 @@ -2685,7 +2830,7 @@ mptctl_hp_targetinfo(unsigned long arg)
15851 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) pg3_alloc, page_dma);
15852 }
15853 }
15854 - hd = shost_priv(ioc->sh);
15855 + hd = (MPT_SCSI_HOST *) ioc->sh->hostdata;
15856 if (hd != NULL)
15857 karg.select_timeouts = hd->sel_timeout[karg.hdr.id];
15858
15859 @@ -2703,7 +2848,7 @@ mptctl_hp_targetinfo(unsigned long arg)
15860
15861 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
15862
15863 -static const struct file_operations mptctl_fops = {
15864 +static struct file_operations mptctl_fops = {
15865 .owner = THIS_MODULE,
15866 .llseek = no_llseek,
15867 .release = mptctl_release,
15868 @@ -2743,8 +2888,9 @@ compat_mptfwxfer_ioctl(struct file *filp
15869 iocnumX = kfw32.iocnum & 0xFF;
15870 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
15871 (iocp == NULL)) {
15872 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15873 printk(KERN_DEBUG MYNAM "::compat_mptfwxfer_ioctl @%d - ioc%d not found!\n",
15874 - __LINE__, iocnumX);
15875 + __LINE__, iocnumX);
15876 return -ENODEV;
15877 }
15878
15879 @@ -2759,7 +2905,7 @@ compat_mptfwxfer_ioctl(struct file *filp
15880
15881 ret = mptctl_do_fw_download(kfw.iocnum, kfw.bufp, kfw.fwlen);
15882
15883 - mutex_unlock(&iocp->ioctl->ioctl_mutex);
15884 + mutex_unlock(&iocp->ioctl_cmds.mutex);
15885
15886 return ret;
15887 }
15888 @@ -2783,8 +2929,9 @@ compat_mpt_command(struct file *filp, un
15889 iocnumX = karg32.hdr.iocnum & 0xFF;
15890 if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
15891 (iocp == NULL)) {
15892 + if (mpt_debug_level & MPT_DEBUG_IOCTL)
15893 printk(KERN_DEBUG MYNAM "::compat_mpt_command @%d - ioc%d not found!\n",
15894 - __LINE__, iocnumX);
15895 + __LINE__, iocnumX);
15896 return -ENODEV;
15897 }
15898
15899 @@ -2813,7 +2960,7 @@ compat_mpt_command(struct file *filp, un
15900 */
15901 ret = mptctl_do_mpt_command (karg, &uarg->MF);
15902
15903 - mutex_unlock(&iocp->ioctl->ioctl_mutex);
15904 + mutex_unlock(&iocp->ioctl_cmds.mutex);
15905
15906 return ret;
15907 }
15908 @@ -2833,6 +2980,31 @@ static long compat_mpctl_ioctl(struct fi
15909 case MPTHARDRESET:
15910 case HP_GETHOSTINFO:
15911 case HP_GETTARGETINFO:
15912 +#if defined(CPQ_CIM)
15913 + case CC_CSMI_SAS_GET_DRIVER_INFO:
15914 + case CC_CSMI_SAS_GET_CNTLR_CONFIG:
15915 + case CC_CSMI_SAS_GET_CNTLR_STATUS:
15916 + case CC_CSMI_SAS_GET_SCSI_ADDRESS:
15917 + case CC_CSMI_SAS_GET_DEVICE_ADDRESS:
15918 + case CC_CSMI_SAS_GET_PHY_INFO:
15919 + case CC_CSMI_SAS_GET_SATA_SIGNATURE:
15920 + case CC_CSMI_SAS_GET_LINK_ERRORS:
15921 + case CC_CSMI_SAS_SMP_PASSTHRU:
15922 + case CC_CSMI_SAS_SSP_PASSTHRU:
15923 + case CC_CSMI_SAS_FIRMWARE_DOWNLOAD:
15924 + case CC_CSMI_SAS_GET_RAID_INFO:
15925 + case CC_CSMI_SAS_GET_RAID_CONFIG:
15926 + case CC_CSMI_SAS_GET_RAID_FEATURES:
15927 + case CC_CSMI_SAS_SET_RAID_CONTROL:
15928 + case CC_CSMI_SAS_GET_RAID_ELEMENT:
15929 + case CC_CSMI_SAS_SET_RAID_OPERATION:
15930 + case CC_CSMI_SAS_SET_PHY_INFO:
15931 + case CC_CSMI_SAS_STP_PASSTHRU:
15932 + case CC_CSMI_SAS_TASK_MANAGEMENT:
15933 + case CC_CSMI_SAS_PHY_CONTROL:
15934 + case CC_CSMI_SAS_GET_CONNECTOR_INFO:
15935 + case CC_CSMI_SAS_GET_LOCATION:
15936 +#endif /* CPQ_CIM */
15937 case MPTTEST:
15938 ret = __mptctl_ioctl(f, cmd, arg);
15939 break;
15940 @@ -2865,21 +3037,11 @@ static long compat_mpctl_ioctl(struct fi
15941 static int
15942 mptctl_probe(struct pci_dev *pdev, const struct pci_device_id *id)
15943 {
15944 - MPT_IOCTL *mem;
15945 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
15946
15947 - /*
15948 - * Allocate and inite a MPT_IOCTL structure
15949 - */
15950 - mem = kzalloc(sizeof(MPT_IOCTL), GFP_KERNEL);
15951 - if (!mem) {
15952 - mptctl_remove(pdev);
15953 - return -ENOMEM;
15954 - }
15955 + mutex_init(&ioc->ioctl_cmds.mutex);
15956 + init_completion(&ioc->ioctl_cmds.done);
15957
15958 - ioc->ioctl = mem;
15959 - ioc->ioctl->ioc = ioc;
15960 - mutex_init(&ioc->ioctl->ioctl_mutex);
15961 return 0;
15962 }
15963
15964 @@ -2893,9 +3055,22 @@ mptctl_probe(struct pci_dev *pdev, const
15965 static void
15966 mptctl_remove(struct pci_dev *pdev)
15967 {
15968 +#if defined(DIAG_BUFFER_SUPPORT)
15969 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
15970 + int i;
15971
15972 - kfree ( ioc->ioctl );
15973 + /*
15974 + * Cleanup diag buffer allocated memory
15975 + */
15976 + for (i = 0; i < MPI_DIAG_BUF_TYPE_COUNT; i++) {
15977 + if (ioc->DiagBuffer[i] == NULL)
15978 + continue;
15979 + pci_free_consistent(ioc->pcidev, ioc->DiagBuffer_sz[i],
15980 + ioc->DiagBuffer[i], ioc->DiagBuffer_dma[i]);
15981 + ioc->DiagBuffer[i] = NULL;
15982 + ioc->DiagBuffer_Status[i] = 0;
15983 + }
15984 +#endif
15985 }
15986
15987 static struct mpt_pci_driver mptctl_driver = {
15988 @@ -2935,6 +3110,7 @@ static int __init mptctl_init(void)
15989 goto out_fail;
15990 }
15991
15992 + mptctl_taskmgmt_id = mpt_register(mptctl_taskmgmt_reply, MPTCTL_DRIVER);
15993 mpt_reset_register(mptctl_id, mptctl_ioc_reset);
15994 mpt_event_register(mptctl_id, mptctl_event_process);
15995
15996 @@ -2956,15 +3132,23 @@ static void mptctl_exit(void)
15997
15998 /* De-register reset handler from base module */
15999 mpt_reset_deregister(mptctl_id);
16000 + mpt_reset_deregister(mptctl_taskmgmt_id);
16001
16002 /* De-register callback handler from base module */
16003 mpt_deregister(mptctl_id);
16004
16005 mpt_device_driver_deregister(MPTCTL_DRIVER);
16006 -
16007 }
16008
16009 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16010
16011 +#if defined(CPQ_CIM)
16012 +#include "csmi/csmisas.c"
16013 +#endif // CPQ_CIM
16014 +
16015 +#if defined(DIAG_BUFFER_SUPPORT)
16016 +#include "rejected_ioctls/diag_buffer.c"
16017 +#endif
16018 +
16019 module_init(mptctl_init);
16020 module_exit(mptctl_exit);
16021 --- a/drivers/message/fusion/mptctl.h
16022 +++ b/drivers/message/fusion/mptctl.h
16023 @@ -1,5 +1,5 @@
16024 /*
16025 - * linux/drivers/message/fusion/mptioctl.h
16026 + * linux/drivers/message/fusion/mptctl.h
16027 * Fusion MPT misc device (ioctl) driver.
16028 * For use with PCI chip/adapter(s):
16029 * LSIFC9xx/LSI409xx Fibre Channel
16030 @@ -460,8 +460,5 @@ typedef struct _hp_target_info {
16031
16032 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16033
16034 -
16035 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16036 -
16037 #endif
16038
16039 --- a/drivers/message/fusion/mptdebug.h
16040 +++ b/drivers/message/fusion/mptdebug.h
16041 @@ -17,6 +17,10 @@
16042 *
16043 * Example: (programming for MPT_DEBUG_EVENTS on host 5)
16044 *
16045 + * global setting:
16046 + * echo 8 > /sys/module/mptbase/parameters/mpt_debug_level
16047 + *
16048 + * per host setting:
16049 * echo 8 > /sys/class/scsi_host/host5/debug_level
16050 *
16051 * --------------------------------------------------------
16052 @@ -55,9 +59,11 @@
16053 #define MPT_DEBUG_RESET 0x00008000
16054 #define MPT_DEBUG_SCSI 0x00010000
16055 #define MPT_DEBUG_IOCTL 0x00020000
16056 +#define MPT_DEBUG_CSMISAS 0x00040000
16057 #define MPT_DEBUG_FC 0x00080000
16058 #define MPT_DEBUG_SAS 0x00100000
16059 #define MPT_DEBUG_SAS_WIDE 0x00200000
16060 +#define MPT_DEBUG_36GB_MEM 0x00400000
16061
16062 /*
16063 * CONFIG_FUSION_LOGGING - enabled in Kconfig
16064 @@ -126,6 +132,9 @@
16065 #define dctlprintk(IOC, CMD) \
16066 MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_IOCTL)
16067
16068 +#define dcsmisasprintk(IOC, CMD) \
16069 + MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_CSMISAS)
16070 +
16071 #define dfcprintk(IOC, CMD) \
16072 MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_FC)
16073
16074 @@ -135,7 +144,8 @@
16075 #define dsaswideprintk(IOC, CMD) \
16076 MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_SAS_WIDE)
16077
16078 -
16079 +#define d36memprintk(IOC, CMD) \
16080 + MPT_CHECK_LOGGING(IOC, CMD, MPT_DEBUG_36GB_MEM)
16081
16082 /*
16083 * Verbose logging
16084 --- a/drivers/message/fusion/mptfc.c
16085 +++ b/drivers/message/fusion/mptfc.c
16086 @@ -43,6 +43,7 @@
16087 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16088 */
16089 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16090 +
16091 #include <linux/module.h>
16092 #include <linux/kernel.h>
16093 #include <linux/init.h>
16094 @@ -52,8 +53,10 @@
16095 #include <linux/delay.h> /* for mdelay */
16096 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
16097 #include <linux/reboot.h> /* notifier code */
16098 +#include <linux/sched.h>
16099 #include <linux/workqueue.h>
16100 #include <linux/sort.h>
16101 +#include <linux/pci.h>
16102
16103 #include <scsi/scsi.h>
16104 #include <scsi/scsi_cmnd.h>
16105 @@ -84,6 +87,14 @@ MODULE_PARM_DESC(mptfc_dev_loss_tmo, " I
16106 " return following a device loss event."
16107 " Default=60.");
16108
16109 +static int mpt_sdev_queue_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
16110 +static int mptfc_set_sdev_queue_depth(const char *val, struct kernel_param *kp);
16111 +module_param_call(mpt_sdev_queue_depth, mptfc_set_sdev_queue_depth,
16112 + param_get_int, &mpt_sdev_queue_depth, 0600);
16113 +MODULE_PARM_DESC(mpt_sdev_queue_depth,
16114 + " Max Device Queue Depth (default="
16115 + __MODULE_STRING(MPT_SCSI_CMD_PER_DEV_HIGH) ")");
16116 +
16117 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
16118 #define MPTFC_MAX_LUN (16895)
16119 static int max_lun = MPTFC_MAX_LUN;
16120 @@ -183,6 +194,34 @@ static struct fc_function_template mptfc
16121 .show_host_symbolic_name = 1,
16122 };
16123
16124 +/**
16125 + * mptfc_set_sdev_queue_depth - global setting of the mpt_sdev_queue_depth
16126 + * found via /sys/module/mptfc/parameters/mpt_sdev_queue_depth
16127 + * @val:
16128 + * @kp:
16129 + *
16130 + * Returns
16131 + **/
16132 +static int
16133 +mptfc_set_sdev_queue_depth(const char *val, struct kernel_param *kp)
16134 +{
16135 + int ret = param_set_int(val, kp);
16136 + MPT_ADAPTER *ioc;
16137 + struct scsi_device *sdev;
16138 +
16139 + if (ret)
16140 + return ret;
16141 +
16142 + list_for_each_entry(ioc, &ioc_list, list) {
16143 + if (ioc->bus_type != FC)
16144 + continue;
16145 + shost_for_each_device(sdev, ioc->sh)
16146 + mptscsih_change_queue_depth(sdev, mpt_sdev_queue_depth);
16147 + ioc->sdev_queue_depth = mpt_sdev_queue_depth;
16148 + }
16149 + return 0;
16150 +}
16151 +
16152 static int
16153 mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
16154 int (*func)(struct scsi_cmnd *SCpnt),
16155 @@ -194,7 +233,7 @@ mptfc_block_error_handler(struct scsi_cm
16156 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
16157 unsigned long flags;
16158 int ready;
16159 - MPT_ADAPTER *ioc;
16160 + MPT_ADAPTER *ioc;
16161
16162 hd = shost_priv(SCpnt->device->host);
16163 ioc = hd->ioc;
16164 @@ -231,28 +270,28 @@ static int
16165 mptfc_abort(struct scsi_cmnd *SCpnt)
16166 {
16167 return
16168 - mptfc_block_error_handler(SCpnt, mptscsih_abort, __func__);
16169 + mptfc_block_error_handler(SCpnt, mptscsih_abort, __FUNCTION__);
16170 }
16171
16172 static int
16173 mptfc_dev_reset(struct scsi_cmnd *SCpnt)
16174 {
16175 return
16176 - mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __func__);
16177 + mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __FUNCTION__);
16178 }
16179
16180 static int
16181 mptfc_bus_reset(struct scsi_cmnd *SCpnt)
16182 {
16183 return
16184 - mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __func__);
16185 + mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __FUNCTION__);
16186 }
16187
16188 static int
16189 mptfc_host_reset(struct scsi_cmnd *SCpnt)
16190 {
16191 return
16192 - mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __func__);
16193 + mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __FUNCTION__);
16194 }
16195
16196 static void
16197 @@ -476,6 +515,7 @@ mptfc_register_dev(MPT_ADAPTER *ioc, int
16198 if (vtarget) {
16199 vtarget->id = pg0->CurrentTargetID;
16200 vtarget->channel = pg0->CurrentBus;
16201 + vtarget->deleted = 0;
16202 }
16203 }
16204 *((struct mptfc_rport_info **)rport->dd_data) = ri;
16205 @@ -513,6 +553,7 @@ mptfc_target_destroy(struct scsi_target
16206 struct fc_rport *rport;
16207 struct mptfc_rport_info *ri;
16208
16209 + printk("%s - starget=%p\n", __FUNCTION__, starget);
16210 rport = starget_to_rport(starget);
16211 if (rport) {
16212 ri = *((struct mptfc_rport_info **)rport->dd_data);
16213 @@ -560,6 +601,7 @@ mptfc_target_alloc(struct scsi_target *s
16214
16215 return rc;
16216 }
16217 +
16218 /*
16219 * mptfc_dump_lun_info
16220 * @ioc
16221 @@ -589,7 +631,6 @@ mptfc_dump_lun_info(MPT_ADAPTER *ioc, st
16222 (unsigned long long)nn));
16223 }
16224
16225 -
16226 /*
16227 * OS entry point to allow host driver to alloc memory
16228 * for each scsi device. Called once per device the bus scan.
16229 @@ -604,7 +645,7 @@ mptfc_slave_alloc(struct scsi_device *sd
16230 VirtDevice *vdevice;
16231 struct scsi_target *starget;
16232 struct fc_rport *rport;
16233 - MPT_ADAPTER *ioc;
16234 + MPT_ADAPTER *ioc;
16235
16236 starget = scsi_target(sdev);
16237 rport = starget_to_rport(starget);
16238 @@ -614,11 +655,10 @@ mptfc_slave_alloc(struct scsi_device *sd
16239
16240 hd = shost_priv(sdev->host);
16241 ioc = hd->ioc;
16242 -
16243 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
16244 if (!vdevice) {
16245 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
16246 - ioc->name, sizeof(VirtDevice));
16247 + ioc->name, sizeof(VirtDevice));
16248 return -ENOMEM;
16249 }
16250
16251 @@ -635,10 +675,7 @@ mptfc_slave_alloc(struct scsi_device *sd
16252 vdevice->lun = sdev->lun;
16253
16254 vtarget->num_luns++;
16255 -
16256 -
16257 mptfc_dump_lun_info(ioc, rport, sdev, vtarget);
16258 -
16259 return 0;
16260 }
16261
16262 @@ -944,11 +981,12 @@ start_over:
16263 return rc;
16264 }
16265
16266 -static void
16267 +static int
16268 mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc)
16269 {
16270 int ii;
16271 FCPortPage1_t *pp1;
16272 + int rc;
16273
16274 #define MPTFC_FW_DEVICE_TIMEOUT (1)
16275 #define MPTFC_FW_IO_PEND_TIMEOUT (1)
16276 @@ -956,8 +994,8 @@ mptfc_SetFcPortPage1_defaults(MPT_ADAPTE
16277 #define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS)
16278
16279 for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
16280 - if (mptfc_GetFcPortPage1(ioc, ii) != 0)
16281 - continue;
16282 + if ((rc = mptfc_GetFcPortPage1(ioc, ii)) < 0)
16283 + return rc;
16284 pp1 = ioc->fc_data.fc_port_page1[ii].data;
16285 if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT)
16286 && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT)
16287 @@ -968,8 +1006,10 @@ mptfc_SetFcPortPage1_defaults(MPT_ADAPTE
16288 pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT;
16289 pp1->Flags &= ~OFF_FLAGS;
16290 pp1->Flags |= ON_FLAGS;
16291 - mptfc_WriteFcPortPage1(ioc, ii);
16292 + if ((rc = mptfc_WriteFcPortPage1(ioc, ii)) < 0)
16293 + return rc;
16294 }
16295 + return 0;
16296 }
16297
16298
16299 @@ -1082,10 +1122,13 @@ mptfc_link_status_change(struct work_str
16300 static void
16301 mptfc_setup_reset(struct work_struct *work)
16302 {
16303 - MPT_ADAPTER *ioc =
16304 + MPT_ADAPTER *ioc =
16305 container_of(work, MPT_ADAPTER, fc_setup_reset_work);
16306 u64 pn;
16307 struct mptfc_rport_info *ri;
16308 + struct scsi_target *starget;
16309 + VirtTarget *vtarget;
16310 +
16311
16312 /* reset about to happen, delete (block) all rports */
16313 list_for_each_entry(ri, &ioc->fc_rports, list) {
16314 @@ -1093,6 +1136,12 @@ mptfc_setup_reset(struct work_struct *wo
16315 ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED;
16316 fc_remote_port_delete(ri->rport); /* won't sleep */
16317 ri->rport = NULL;
16318 + starget = ri->starget;
16319 + if (starget) {
16320 + vtarget = starget->hostdata;
16321 + if (vtarget)
16322 + vtarget->deleted = 1;
16323 + }
16324
16325 pn = (u64)ri->pg0.WWPN.High << 32 |
16326 (u64)ri->pg0.WWPN.Low;
16327 @@ -1111,8 +1160,22 @@ mptfc_rescan_devices(struct work_struct
16328 MPT_ADAPTER *ioc =
16329 container_of(work, MPT_ADAPTER, fc_rescan_work);
16330 int ii;
16331 + int rc;
16332 u64 pn;
16333 struct mptfc_rport_info *ri;
16334 + struct scsi_target *starget;
16335 + VirtTarget *vtarget;
16336 +
16337 + /*
16338 + * if cannot set defaults, something's really wrong, bail out
16339 + */
16340 +
16341 + if ((rc = mptfc_SetFcPortPage1_defaults(ioc)) < 0) {
16342 + dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
16343 + "mptfc_rescan.%d: unable to set PP1 defaults, rc %d.\n",
16344 + ioc->name, ioc->sh->host_no, rc));
16345 + return;
16346 + }
16347
16348 /* start by tagging all ports as missing */
16349 list_for_each_entry(ri, &ioc->fc_rports, list) {
16350 @@ -1140,6 +1203,12 @@ mptfc_rescan_devices(struct work_struct
16351 MPT_RPORT_INFO_FLAGS_MISSING);
16352 fc_remote_port_delete(ri->rport); /* won't sleep */
16353 ri->rport = NULL;
16354 + starget = ri->starget;
16355 + if (starget) {
16356 + vtarget = starget->hostdata;
16357 + if (vtarget)
16358 + vtarget->deleted = 1;
16359 + }
16360
16361 pn = (u64)ri->pg0.WWPN.High << 32 |
16362 (u64)ri->pg0.WWPN.Low;
16363 @@ -1238,6 +1307,10 @@ mptfc_probe(struct pci_dev *pdev, const
16364 sh->max_id = ioc->pfacts->MaxDevices;
16365 sh->max_lun = max_lun;
16366
16367 + sh->this_id = ioc->pfacts[0].PortSCSIID;
16368 +
16369 + ioc->sdev_queue_depth = mpt_sdev_queue_depth;
16370 +
16371 /* Required entry.
16372 */
16373 sh->unique_id = ioc->id;
16374 @@ -1251,17 +1324,15 @@ mptfc_probe(struct pci_dev *pdev, const
16375 * A slightly different algorithm is required for
16376 * 64bit SGEs.
16377 */
16378 - scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
16379 - if (sizeof(dma_addr_t) == sizeof(u64)) {
16380 + scale = ioc->req_sz/ioc->SGE_size;
16381 + if (ioc->sg_addr_size == sizeof(u64)) {
16382 numSGE = (scale - 1) *
16383 (ioc->facts.MaxChainDepth-1) + scale +
16384 - (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
16385 - sizeof(u32));
16386 + (ioc->req_sz - 60) / ioc->SGE_size;
16387 } else {
16388 numSGE = 1 + (scale - 1) *
16389 (ioc->facts.MaxChainDepth-1) + scale +
16390 - (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
16391 - sizeof(u32));
16392 + (ioc->req_sz - 64) / ioc->SGE_size;
16393 }
16394
16395 if (numSGE < sh->sg_tablesize) {
16396 @@ -1290,30 +1361,6 @@ mptfc_probe(struct pci_dev *pdev, const
16397 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
16398 ioc->name, ioc->ScsiLookup));
16399
16400 - /* Clear the TM flags
16401 - */
16402 - hd->tmPending = 0;
16403 - hd->tmState = TM_STATE_NONE;
16404 - hd->resetPending = 0;
16405 - hd->abortSCpnt = NULL;
16406 -
16407 - /* Clear the pointer used to store
16408 - * single-threaded commands, i.e., those
16409 - * issued during a bus scan, dv and
16410 - * configuration pages.
16411 - */
16412 - hd->cmdPtr = NULL;
16413 -
16414 - /* Initialize this SCSI Hosts' timers
16415 - * To use, set the timer expires field
16416 - * and add_timer
16417 - */
16418 - init_timer(&hd->timer);
16419 - hd->timer.data = (unsigned long) hd;
16420 - hd->timer.function = mptscsih_timer_expired;
16421 -
16422 - init_waitqueue_head(&hd->scandv_waitq);
16423 - hd->scandv_wait_done = 0;
16424 hd->last_queue_full = 0;
16425
16426 sh->transportt = mptfc_transport_template;
16427 @@ -1326,8 +1373,8 @@ mptfc_probe(struct pci_dev *pdev, const
16428
16429 /* initialize workqueue */
16430
16431 - snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name),
16432 - "mptfc_wq_%d", sh->host_no);
16433 + snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name), "mptfc_wq_%d",
16434 + sh->host_no);
16435 ioc->fc_rescan_work_q =
16436 create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
16437 if (!ioc->fc_rescan_work_q)
16438 @@ -1340,7 +1387,6 @@ mptfc_probe(struct pci_dev *pdev, const
16439 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
16440 (void) mptfc_GetFcPortPage0(ioc, ii);
16441 }
16442 - mptfc_SetFcPortPage1_defaults(ioc);
16443
16444 /*
16445 * scan for rports -
16446 @@ -1378,9 +1424,6 @@ mptfc_event_process(MPT_ADAPTER *ioc, Ev
16447 unsigned long flags;
16448 int rc=1;
16449
16450 - devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
16451 - ioc->name, event));
16452 -
16453 if (ioc->sh == NULL ||
16454 ((hd = shost_priv(ioc->sh)) == NULL))
16455 return 1;
16456 @@ -1416,45 +1459,45 @@ mptfc_ioc_reset(MPT_ADAPTER *ioc, int re
16457 unsigned long flags;
16458
16459 rc = mptscsih_ioc_reset(ioc,reset_phase);
16460 - if (rc == 0)
16461 + if ((ioc->bus_type != FC) || (!rc))
16462 return rc;
16463
16464 -
16465 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
16466 - ": IOC %s_reset routed to FC host driver!\n",ioc->name,
16467 - reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
16468 - reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
16469 -
16470 - if (reset_phase == MPT_IOC_SETUP_RESET) {
16471 + switch(reset_phase) {
16472 + case MPT_IOC_SETUP_RESET:
16473 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
16474 + "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
16475 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
16476 if (ioc->fc_rescan_work_q) {
16477 queue_work(ioc->fc_rescan_work_q,
16478 &ioc->fc_setup_reset_work);
16479 }
16480 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
16481 - }
16482 -
16483 - else if (reset_phase == MPT_IOC_PRE_RESET) {
16484 - }
16485 -
16486 - else { /* MPT_IOC_POST_RESET */
16487 - mptfc_SetFcPortPage1_defaults(ioc);
16488 + break;
16489 + case MPT_IOC_PRE_RESET:
16490 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
16491 + "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
16492 + break;
16493 + case MPT_IOC_POST_RESET:
16494 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
16495 + "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
16496 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
16497 if (ioc->fc_rescan_work_q) {
16498 queue_work(ioc->fc_rescan_work_q,
16499 &ioc->fc_rescan_work);
16500 }
16501 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
16502 + break;
16503 + default:
16504 + break;
16505 }
16506 return 1;
16507 }
16508
16509 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16510 /**
16511 * mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
16512 *
16513 * Returns 0 for success, non-zero for failure.
16514 - */
16515 + **/
16516 static int __init
16517 mptfc_init(void)
16518 {
16519 @@ -1486,12 +1529,11 @@ mptfc_init(void)
16520 return error;
16521 }
16522
16523 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16524 /**
16525 * mptfc_remove - Remove fc infrastructure for devices
16526 * @pdev: Pointer to pci_dev structure
16527 *
16528 - */
16529 + **/
16530 static void __devexit
16531 mptfc_remove(struct pci_dev *pdev)
16532 {
16533 @@ -1501,6 +1543,8 @@ mptfc_remove(struct pci_dev *pdev)
16534 unsigned long flags;
16535 int ii;
16536
16537 + printk("%s -pdev=%p\n", __FUNCTION__, pdev);
16538 +
16539 /* destroy workqueue */
16540 if ((work_q=ioc->fc_rescan_work_q)) {
16541 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
16542 @@ -1543,7 +1587,6 @@ mptfc_exit(void)
16543
16544 mpt_reset_deregister(mptfcDoneCtx);
16545 mpt_event_deregister(mptfcDoneCtx);
16546 -
16547 mpt_deregister(mptfcInternalCtx);
16548 mpt_deregister(mptfcTaskCtx);
16549 mpt_deregister(mptfcDoneCtx);
16550 --- a/drivers/message/fusion/mptlan.c
16551 +++ b/drivers/message/fusion/mptlan.c
16552 @@ -6,7 +6,6 @@
16553 *
16554 * Copyright (c) 2000-2008 LSI Corporation
16555 * (mailto:DL-MPTFusionLinux@lsi.com)
16556 - *
16557 */
16558 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16559 /*
16560 @@ -165,6 +164,11 @@ DEFINE_RWLOCK(bad_naa_lock);
16561 #endif
16562
16563 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16564 +/*
16565 + * Fusion MPT LAN external data
16566 + */
16567 +
16568 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16569 /**
16570 * lan_reply - Handle all data sent from the hardware.
16571 * @ioc: Pointer to MPT_ADAPTER structure
16572 @@ -190,8 +194,7 @@ lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_H
16573 u32 tmsg = CAST_PTR_TO_U32(reply);
16574
16575 dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n",
16576 - IOC_AND_NETDEV_NAMES_s_s(dev),
16577 - tmsg));
16578 + IOC_AND_NETDEV_NAMES_s_s(dev), tmsg));
16579
16580 switch (GET_LAN_FORM(tmsg)) {
16581
16582 @@ -440,6 +443,7 @@ mpt_lan_open(struct net_device *dev)
16583 dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtl\n"));
16584
16585 mpt_lan_post_receive_buckets(priv);
16586 +
16587 printk(KERN_INFO MYNAM ": %s/%s: interface up & active\n",
16588 IOC_AND_NETDEV_NAMES_s_s(dev));
16589
16590 @@ -610,7 +614,7 @@ mpt_lan_send_turbo(struct net_device *de
16591
16592 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
16593 IOC_AND_NETDEV_NAMES_s_s(dev),
16594 - __func__, sent));
16595 + __FUNCTION__, sent));
16596
16597 priv->SendCtl[ctx].skb = NULL;
16598 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
16599 @@ -676,7 +680,7 @@ mpt_lan_send_reply(struct net_device *de
16600
16601 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
16602 IOC_AND_NETDEV_NAMES_s_s(dev),
16603 - __func__, sent));
16604 + __FUNCTION__, sent));
16605
16606 priv->SendCtl[ctx].skb = NULL;
16607 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
16608 @@ -715,7 +719,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
16609 u16 cur_naa = 0x1000;
16610
16611 dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
16612 - __func__, skb));
16613 + __FUNCTION__, skb));
16614
16615 spin_lock_irqsave(&priv->txfidx_lock, flags);
16616 if (priv->mpt_txfidx_tail < 0) {
16617 @@ -723,7 +727,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
16618 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
16619
16620 printk (KERN_ERR "%s: no tx context available: %u\n",
16621 - __func__, priv->mpt_txfidx_tail);
16622 + __FUNCTION__, priv->mpt_txfidx_tail);
16623 return 1;
16624 }
16625
16626 @@ -733,7 +737,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
16627 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
16628
16629 printk (KERN_ERR "%s: Unable to alloc request frame\n",
16630 - __func__);
16631 + __FUNCTION__);
16632 return 1;
16633 }
16634
16635 @@ -780,6 +784,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
16636 // ctx, skb, skb->data));
16637
16638 mac = skb_mac_header(skb);
16639 +
16640 #ifdef QLOGIC_NAA_WORKAROUND
16641 {
16642 struct NAA_Hosed *nh;
16643 @@ -805,6 +810,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
16644 }
16645 #endif
16646
16647 +
16648 pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa << 16) |
16649 (mac[0] << 8) |
16650 (mac[1] << 0));
16651 @@ -828,7 +834,7 @@ mpt_lan_sdu_send (struct sk_buff *skb, s
16652 MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
16653 skb->len);
16654 pSimple->Address.Low = cpu_to_le32((u32) dma);
16655 - if (sizeof(dma_addr_t) > sizeof(u32))
16656 + if (mpt_dev->sg_addr_size > sizeof(u32))
16657 pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
16658 else
16659 pSimple->Address.High = 0;
16660 @@ -1117,7 +1123,6 @@ mpt_lan_receive_post_reply(struct net_de
16661 PCI_DMA_FROMDEVICE);
16662
16663 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
16664 -
16665 pci_dma_sync_single_for_device(mpt_dev->pcidev,
16666 priv->RcvCtl[ctx].dma,
16667 priv->RcvCtl[ctx].len,
16668 @@ -1208,7 +1213,7 @@ mpt_lan_post_receive_buckets(struct mpt_
16669
16670 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
16671 IOC_AND_NETDEV_NAMES_s_s(dev),
16672 - __func__, buckets, curr));
16673 + __FUNCTION__, buckets, curr));
16674
16675 max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
16676 (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
16677 @@ -1217,9 +1222,9 @@ mpt_lan_post_receive_buckets(struct mpt_
16678 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
16679 if (mf == NULL) {
16680 printk (KERN_ERR "%s: Unable to alloc request frame\n",
16681 - __func__);
16682 + __FUNCTION__);
16683 dioprintk((KERN_ERR "%s: %u buckets remaining\n",
16684 - __func__, buckets));
16685 + __FUNCTION__, buckets));
16686 goto out;
16687 }
16688 pRecvReq = (LANReceivePostRequest_t *) mf;
16689 @@ -1244,7 +1249,7 @@ mpt_lan_post_receive_buckets(struct mpt_
16690 spin_lock_irqsave(&priv->rxfidx_lock, flags);
16691 if (priv->mpt_rxfidx_tail < 0) {
16692 printk (KERN_ERR "%s: Can't alloc context\n",
16693 - __func__);
16694 + __FUNCTION__);
16695 spin_unlock_irqrestore(&priv->rxfidx_lock,
16696 flags);
16697 break;
16698 @@ -1267,7 +1272,7 @@ mpt_lan_post_receive_buckets(struct mpt_
16699 if (skb == NULL) {
16700 printk (KERN_WARNING
16701 MYNAM "/%s: Can't alloc skb\n",
16702 - __func__);
16703 + __FUNCTION__);
16704 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
16705 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
16706 break;
16707 @@ -1295,7 +1300,7 @@ mpt_lan_post_receive_buckets(struct mpt_
16708 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
16709 MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
16710 pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
16711 - if (sizeof(dma_addr_t) > sizeof(u32))
16712 + if (mpt_dev->sg_addr_size > sizeof(u32))
16713 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
16714 else
16715 pSimple->Address.High = 0;
16716 @@ -1305,7 +1310,7 @@ mpt_lan_post_receive_buckets(struct mpt_
16717
16718 if (pSimple == NULL) {
16719 /**/ printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
16720 -/**/ __func__);
16721 +/**/ __FUNCTION__);
16722 mpt_free_msg_frame(mpt_dev, mf);
16723 goto out;
16724 }
16725 @@ -1329,9 +1334,9 @@ mpt_lan_post_receive_buckets(struct mpt_
16726
16727 out:
16728 dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
16729 - __func__, buckets, atomic_read(&priv->buckets_out)));
16730 + __FUNCTION__, buckets, atomic_read(&priv->buckets_out)));
16731 dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
16732 - __func__, priv->total_posted, priv->total_received));
16733 + __FUNCTION__, priv->total_posted, priv->total_received));
16734
16735 clear_bit(0, &priv->post_buckets_active);
16736 }
16737 @@ -1340,18 +1345,17 @@ static void
16738 mpt_lan_post_receive_buckets_work(struct work_struct *work)
16739 {
16740 mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
16741 - post_buckets_task.work));
16742 + post_buckets_task.work));
16743 }
16744
16745 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16746 static struct net_device *
16747 mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
16748 {
16749 - struct net_device *dev;
16750 - struct mpt_lan_priv *priv;
16751 + struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
16752 + struct mpt_lan_priv *priv = NULL;
16753 u8 HWaddr[FC_ALEN], *a;
16754
16755 - dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
16756 if (!dev)
16757 return NULL;
16758
16759 @@ -1363,8 +1367,9 @@ mpt_register_lan_device (MPT_ADAPTER *mp
16760 priv->mpt_dev = mpt_dev;
16761 priv->pnum = pnum;
16762
16763 + memset(&priv->post_buckets_task, 0, sizeof(priv->post_buckets_task));
16764 INIT_DELAYED_WORK(&priv->post_buckets_task,
16765 - mpt_lan_post_receive_buckets_work);
16766 + mpt_lan_post_receive_buckets_work);
16767 priv->post_buckets_active = 0;
16768
16769 dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
16770 @@ -1387,6 +1392,8 @@ mpt_register_lan_device (MPT_ADAPTER *mp
16771 spin_lock_init(&priv->txfidx_lock);
16772 spin_lock_init(&priv->rxfidx_lock);
16773
16774 + memset(&priv->stats, 0, sizeof(priv->stats));
16775 +
16776 /* Grab pre-fetched LANPage1 stuff. :-) */
16777 a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
16778
16779 @@ -1421,6 +1428,7 @@ mpt_register_lan_device (MPT_ADAPTER *mp
16780 dlprintk((KERN_INFO MYNAM ": Finished registering dev "
16781 "and setting initial values\n"));
16782
16783 +
16784 if (register_netdev(dev) != 0) {
16785 free_netdev(dev);
16786 dev = NULL;
16787 --- a/drivers/message/fusion/mptlan.h
16788 +++ b/drivers/message/fusion/mptlan.h
16789 @@ -6,7 +6,6 @@
16790 *
16791 * Copyright (c) 2000-2008 LSI Corporation
16792 * (mailto:DL-MPTFusionLinux@lsi.com)
16793 - *
16794 */
16795 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
16796 /*
16797 @@ -55,6 +54,7 @@
16798 #include <linux/module.h>
16799 #endif
16800
16801 +#include <linux/version.h>
16802 #include <linux/netdevice.h>
16803 #include <linux/errno.h>
16804 // #include <linux/etherdevice.h>
16805 @@ -73,6 +73,7 @@
16806
16807 #include <asm/uaccess.h>
16808 #include <asm/io.h>
16809 +#include <linux/pci.h>
16810
16811 /* Override mptbase.h by pre-defining these! */
16812 #define MODULEAUTHOR "LSI Corporation"
16813 --- a/drivers/message/fusion/mptsas.c
16814 +++ b/drivers/message/fusion/mptsas.c
16815 @@ -47,9 +47,11 @@
16816 #include <linux/kernel.h>
16817 #include <linux/init.h>
16818 #include <linux/errno.h>
16819 -#include <linux/jiffies.h>
16820 +#include <linux/sched.h>
16821 #include <linux/workqueue.h>
16822 +#include <linux/interrupt.h>
16823 #include <linux/delay.h> /* for mdelay */
16824 +#include <linux/pci.h>
16825
16826 #include <scsi/scsi.h>
16827 #include <scsi/scsi_cmnd.h>
16828 @@ -62,7 +64,6 @@
16829 #include "mptscsih.h"
16830 #include "mptsas.h"
16831
16832 -
16833 #define my_NAME "Fusion MPT SAS Host driver"
16834 #define my_VERSION MPT_LINUX_VERSION_COMMON
16835 #define MYNAM "mptsas"
16836 @@ -72,6 +73,8 @@
16837 */
16838 #define MPTSAS_RAID_CHANNEL 1
16839
16840 +#define SAS_CONFIG_PAGE_TIMEOUT 30
16841 +
16842 MODULE_AUTHOR(MODULEAUTHOR);
16843 MODULE_DESCRIPTION(my_NAME);
16844 MODULE_LICENSE("GPL");
16845 @@ -83,6 +86,25 @@ MODULE_PARM_DESC(mpt_pt_clear,
16846 " Clear persistency table: enable=1 "
16847 "(default=MPTSCSIH_PT_CLEAR=0)");
16848
16849 +static int mpt_cmd_retry_count = 144;
16850 +module_param(mpt_cmd_retry_count, int, 0);
16851 +MODULE_PARM_DESC(mpt_cmd_retry_count,
16852 + " Device discovery TUR command retry count: default=144");
16853 +
16854 +static int mpt_disable_hotplug_remove = 0;
16855 +module_param(mpt_disable_hotplug_remove, int, 0);
16856 +MODULE_PARM_DESC(mpt_disable_hotplug_remove,
16857 + " Disable hotpug remove events: default=0");
16858 +
16859 +static int mpt_sdev_queue_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
16860 +static int mptsas_set_sdev_queue_depth(const char *val,
16861 + struct kernel_param *kp);
16862 +module_param_call(mpt_sdev_queue_depth, mptsas_set_sdev_queue_depth,
16863 + param_get_int, &mpt_sdev_queue_depth, 0600);
16864 +MODULE_PARM_DESC(mpt_sdev_queue_depth,
16865 + " Max Device Queue Depth (default="
16866 + __MODULE_STRING(MPT_SCSI_CMD_PER_DEV_HIGH) ")");
16867 +
16868 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */
16869 #define MPTSAS_MAX_LUN (16895)
16870 static int max_lun = MPTSAS_MAX_LUN;
16871 @@ -93,8 +115,53 @@ static u8 mptsasDoneCtx = MPT_MAX_PROTOC
16872 static u8 mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
16873 static u8 mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
16874 static u8 mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS;
16875 +static u8 mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS;
16876 +
16877 +static inline void mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy);
16878 +static struct mptsas_phyinfo * mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc,
16879 + u64 sas_address);
16880 +static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
16881 + u32 form, u32 form_specific);
16882 +static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
16883 + u32 form, u32 form_specific);
16884 +
16885 +static int mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info);
16886 +static void mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info);
16887 +static void mptsas_expander_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info);
16888 +static int mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
16889 + u32 form, u32 form_specific);
16890 +static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc);
16891 +static void mptsas_not_responding_devices(MPT_ADAPTER *ioc);
16892 +
16893 +static void mptsas_firmware_event_work(struct work_struct *work);
16894 +
16895 +/**
16896 + * mptsas_set_sdev_queue_depth - global setting of the mpt_sdev_queue_depth
16897 + * found via /sys/module/mptsas/parameters/mpt_sdev_queue_depth
16898 + * @val:
16899 + * @kp:
16900 + *
16901 + * Returns
16902 + **/
16903 +static int
16904 +mptsas_set_sdev_queue_depth(const char *val, struct kernel_param *kp)
16905 +{
16906 + int ret = param_set_int(val, kp);
16907 + MPT_ADAPTER *ioc;
16908 + struct scsi_device *sdev;
16909
16910 -static void mptsas_hotplug_work(struct work_struct *work);
16911 + if (ret)
16912 + return ret;
16913 +
16914 + list_for_each_entry(ioc, &ioc_list, list) {
16915 + if (ioc->bus_type != SAS)
16916 + continue;
16917 + shost_for_each_device(sdev, ioc->sh)
16918 + mptscsih_change_queue_depth(sdev, mpt_sdev_queue_depth);
16919 + ioc->sdev_queue_depth = mpt_sdev_queue_depth;
16920 + }
16921 + return 0;
16922 +}
16923
16924 static void mptsas_print_phy_data(MPT_ADAPTER *ioc,
16925 MPI_SAS_IO_UNIT0_PHY_DATA *phy_data)
16926 @@ -218,37 +285,183 @@ static void mptsas_print_expander_pg1(MP
16927 le16_to_cpu(pg1->AttachedDevHandle)));
16928 }
16929
16930 -static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy)
16931 +/* inhibit sas firmware event handling */
16932 +static void
16933 +mptsas_fw_event_off(MPT_ADAPTER *ioc)
16934 +{
16935 + unsigned long flags;
16936 +
16937 + spin_lock_irqsave(&ioc->fw_event_lock, flags);
16938 + ioc->fw_events_off = 1;
16939 + spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
16940 +
16941 +}
16942 +
16943 +/* enable sas firmware event handling */
16944 +static void
16945 +mptsas_fw_event_on(MPT_ADAPTER *ioc)
16946 +{
16947 + unsigned long flags;
16948 +
16949 + spin_lock_irqsave(&ioc->fw_event_lock, flags);
16950 + ioc->fw_events_off = 0;
16951 + spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
16952 +}
16953 +
16954 +/* queue a sas firmware event */
16955 +static void
16956 +mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
16957 + unsigned long delay)
16958 +{
16959 + unsigned long flags;
16960 +
16961 +#if defined(CPQ_CIM)
16962 + ioc->csmi_change_count++;
16963 +#endif
16964 +
16965 + spin_lock_irqsave(&ioc->fw_event_lock, flags);
16966 + list_add_tail(&fw_event->list, &ioc->fw_event_list);
16967 + INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work);
16968 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: add (fw_event=0x%p)\n",
16969 + ioc->name,__FUNCTION__, fw_event));
16970 + queue_delayed_work(ioc->fw_event_q, &fw_event->work,
16971 + msecs_to_jiffies(delay));
16972 + spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
16973 +}
16974 +
16975 +/* requeue a sas firmware event */
16976 +static void
16977 +mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
16978 + unsigned long delay)
16979 +{
16980 + unsigned long flags;
16981 + spin_lock_irqsave(&ioc->fw_event_lock, flags);
16982 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: reschedule task "
16983 + "(fw_event=0x%p)\n", ioc->name,__FUNCTION__, fw_event));
16984 + fw_event->retries++;
16985 + queue_delayed_work(ioc->fw_event_q, &fw_event->work,
16986 + msecs_to_jiffies(delay));
16987 + spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
16988 +}
16989 +
16990 +/* free memory assoicated to a sas firmware event */
16991 +static void
16992 +mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event)
16993 +{
16994 + unsigned long flags;
16995 +
16996 + spin_lock_irqsave(&ioc->fw_event_lock, flags);
16997 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: kfree (fw_event=0x%p)\n",
16998 + ioc->name,__FUNCTION__, fw_event));
16999 + list_del(&fw_event->list);
17000 + kfree(fw_event);
17001 + spin_unlock_irqrestore(&ioc->fw_event_lock, flags);
17002 +}
17003 +
17004 +/* walk the firmware event queue, and either stop or wait for outstanding events to complete */
17005 +static void
17006 +mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc)
17007 +{
17008 + struct fw_event_work *fw_event, *next;
17009 + struct mptsas_target_reset_event *target_reset_list, *n;
17010 + u8 flush_q;
17011 + MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
17012 +
17013 + /* flush the target_reset_list */
17014 + if (!list_empty(&hd->target_reset_list)) {
17015 + list_for_each_entry_safe(target_reset_list, n,
17016 + &hd->target_reset_list, list) {
17017 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
17018 + "%s: removing target reset for id=%d\n",
17019 + ioc->name, __FUNCTION__,
17020 + target_reset_list->sas_event_data.TargetID));
17021 + list_del(&target_reset_list->list);
17022 + kfree(target_reset_list);
17023 + }
17024 + }
17025 +
17026 + if (list_empty(&ioc->fw_event_list) ||
17027 + !ioc->fw_event_q || in_interrupt())
17028 + return;
17029 +
17030 + flush_q = 0;
17031 + list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) {
17032 + if (cancel_delayed_work(&fw_event->work))
17033 + mptsas_free_fw_event(ioc, fw_event);
17034 + else
17035 + flush_q = 1;
17036 + }
17037 + if (flush_q)
17038 + flush_workqueue(ioc->fw_event_q);
17039 +}
17040 +
17041 +
17042 +/**
17043 + * phy_to_ioc -
17044 + * @phy:
17045 + *
17046 + *
17047 + **/
17048 +static inline MPT_ADAPTER *
17049 +phy_to_ioc(struct sas_phy *phy)
17050 {
17051 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent);
17052 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
17053 }
17054
17055 -static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy)
17056 +/**
17057 + * rphy_to_ioc -
17058 + * @rphy:
17059 + *
17060 + *
17061 + **/
17062 +static inline MPT_ADAPTER *
17063 +rphy_to_ioc(struct sas_rphy *rphy)
17064 {
17065 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent);
17066 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc;
17067 }
17068
17069 +/**
17070 + * mptsas_find_portinfo_by_sas_address -
17071 + * @ioc: Pointer to MPT_ADAPTER structure
17072 + * @handle:
17073 + *
17074 + * This function should be called with the sas_topology_mutex already held
17075 + *
17076 + **/
17077 static struct mptsas_portinfo *
17078 -mptsas_get_hba_portinfo(MPT_ADAPTER *ioc)
17079 +mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
17080 {
17081 - struct list_head *head = &ioc->sas_topology;
17082 - struct mptsas_portinfo *pi = NULL;
17083 -
17084 - /* always the first entry on sas_topology list */
17085 -
17086 - if (!list_empty(head))
17087 - pi = list_entry(head->next, struct mptsas_portinfo, list);
17088 + struct mptsas_portinfo *port_info, *rc=NULL;
17089 + int i;
17090 +
17091 + if (sas_address >= ioc->hba_port_sas_addr &&
17092 + sas_address < (ioc->hba_port_sas_addr +
17093 + ioc->hba_port_num_phy))
17094 + return ioc->hba_port_info;
17095
17096 - return pi;
17097 + mutex_lock(&ioc->sas_topology_mutex);
17098 + list_for_each_entry(port_info, &ioc->sas_topology, list)
17099 + for (i = 0; i < port_info->num_phys; i++)
17100 + if (port_info->phy_info[i].identify.sas_address ==
17101 + sas_address) {
17102 + rc = port_info;
17103 + goto out;
17104 + }
17105 + out:
17106 + mutex_unlock(&ioc->sas_topology_mutex);
17107 + return rc;
17108 }
17109
17110 -/*
17111 - * mptsas_find_portinfo_by_handle
17112 +/**
17113 + * mptsas_find_portinfo_by_handle -
17114 + * @ioc: Pointer to MPT_ADAPTER structure
17115 + * @handle:
17116 *
17117 - * This function should be called with the sas_topology_mutex already held
17118 - */
17119 + * This function should be called with the sas_topology_mutex already held
17120 + *
17121 + **/
17122 static struct mptsas_portinfo *
17123 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle)
17124 {
17125 @@ -265,9 +478,12 @@ mptsas_find_portinfo_by_handle(MPT_ADAPT
17126 return rc;
17127 }
17128
17129 -/*
17130 - * Returns true if there is a scsi end device
17131 - */
17132 +/**
17133 + * mptsas_is_end_device -
17134 + * @attached:
17135 + *
17136 + * Returns true if there is a scsi end device
17137 + **/
17138 static inline int
17139 mptsas_is_end_device(struct mptsas_devinfo * attached)
17140 {
17141 @@ -285,7 +501,14 @@ mptsas_is_end_device(struct mptsas_devin
17142 return 0;
17143 }
17144
17145 -/* no mutex */
17146 +/**
17147 + * mptsas_port_delete -
17148 + * @ioc: Pointer to MPT_ADAPTER structure
17149 + * @port_details:
17150 + *
17151 + * (no mutex)
17152 + *
17153 + **/
17154 static void
17155 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details)
17156 {
17157 @@ -300,7 +523,7 @@ mptsas_port_delete(MPT_ADAPTER *ioc, str
17158 phy_info = port_info->phy_info;
17159
17160 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d "
17161 - "bitmask=0x%016llX\n", ioc->name, __func__, port_details,
17162 + "bitmask=0x%016llX\n", ioc->name, __FUNCTION__, port_details,
17163 port_details->num_phys, (unsigned long long)
17164 port_details->phy_bitmask));
17165
17166 @@ -308,11 +531,17 @@ mptsas_port_delete(MPT_ADAPTER *ioc, str
17167 if(phy_info->port_details != port_details)
17168 continue;
17169 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
17170 + mptsas_set_rphy(ioc, phy_info, NULL);
17171 phy_info->port_details = NULL;
17172 }
17173 kfree(port_details);
17174 }
17175
17176 +/**
17177 + * mptsas_get_rphy -
17178 + * @phy_info:
17179 + *
17180 + **/
17181 static inline struct sas_rphy *
17182 mptsas_get_rphy(struct mptsas_phyinfo *phy_info)
17183 {
17184 @@ -322,13 +551,20 @@ mptsas_get_rphy(struct mptsas_phyinfo *p
17185 return NULL;
17186 }
17187
17188 +/**
17189 + * mptsas_set_rphy -
17190 + * @ioc: Pointer to MPT_ADAPTER structure
17191 + * @phy_info:
17192 + * @rphy:
17193 + *
17194 + **/
17195 static inline void
17196 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy)
17197 {
17198 if (phy_info->port_details) {
17199 phy_info->port_details->rphy = rphy;
17200 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n",
17201 - ioc->name, rphy));
17202 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
17203 + "sas_rphy_add: rphy=%p\n", ioc->name, rphy));
17204 }
17205
17206 if (rphy) {
17207 @@ -339,6 +575,11 @@ mptsas_set_rphy(MPT_ADAPTER *ioc, struct
17208 }
17209 }
17210
17211 +/**
17212 + * mptsas_get_port -
17213 + * @phy_info:
17214 + *
17215 + **/
17216 static inline struct sas_port *
17217 mptsas_get_port(struct mptsas_phyinfo *phy_info)
17218 {
17219 @@ -348,6 +589,13 @@ mptsas_get_port(struct mptsas_phyinfo *p
17220 return NULL;
17221 }
17222
17223 +/**
17224 + * mptsas_set_port -
17225 + * @ioc: Pointer to MPT_ADAPTER structure
17226 + * @phy_info:
17227 + * @port:
17228 + *
17229 + **/
17230 static inline void
17231 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port)
17232 {
17233 @@ -362,6 +610,11 @@ mptsas_set_port(MPT_ADAPTER *ioc, struct
17234 }
17235 }
17236
17237 +/**
17238 + * mptsas_get_starget -
17239 + * @phy_info:
17240 + *
17241 + **/
17242 static inline struct scsi_target *
17243 mptsas_get_starget(struct mptsas_phyinfo *phy_info)
17244 {
17245 @@ -371,6 +624,12 @@ mptsas_get_starget(struct mptsas_phyinfo
17246 return NULL;
17247 }
17248
17249 +/**
17250 + * mptsas_set_starget -
17251 + * @phy_info:
17252 + * @starget:
17253 + *
17254 + **/
17255 static inline void
17256 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target *
17257 starget)
17258 @@ -379,714 +638,787 @@ starget)
17259 phy_info->port_details->starget = starget;
17260 }
17261
17262 -
17263 -/*
17264 - * mptsas_setup_wide_ports
17265 +/**
17266 + * mptsas_add_device_component -
17267 + * @ioc: Pointer to MPT_ADAPTER structure
17268 + * @channel: fw mapped id's
17269 + * @id:
17270 + * @sas_address:
17271 + * @device_info:
17272 *
17273 - * Updates for new and existing narrow/wide port configuration
17274 - * in the sas_topology
17275 - */
17276 + **/
17277 static void
17278 -mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
17279 +mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id,
17280 + u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id)
17281 {
17282 - struct mptsas_portinfo_details * port_details;
17283 - struct mptsas_phyinfo *phy_info, *phy_info_cmp;
17284 - u64 sas_address;
17285 - int i, j;
17286 -
17287 - mutex_lock(&ioc->sas_topology_mutex);
17288 -
17289 - phy_info = port_info->phy_info;
17290 - for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
17291 - if (phy_info->attached.handle)
17292 - continue;
17293 - port_details = phy_info->port_details;
17294 - if (!port_details)
17295 - continue;
17296 - if (port_details->num_phys < 2)
17297 - continue;
17298 - /*
17299 - * Removing a phy from a port, letting the last
17300 - * phy be removed by firmware events.
17301 - */
17302 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
17303 - "%s: [%p]: deleting phy = %d\n",
17304 - ioc->name, __func__, port_details, i));
17305 - port_details->num_phys--;
17306 - port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
17307 - memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
17308 - sas_port_delete_phy(port_details->port, phy_info->phy);
17309 - phy_info->port_details = NULL;
17310 + struct sas_device_info *sas_info, *next;
17311 + struct scsi_device *sdev;
17312 + struct scsi_target *starget;
17313 + struct sas_rphy *rphy;
17314 +
17315 + /*
17316 + * Delete all matching devices out of the list
17317 + */
17318 + down(&ioc->sas_device_info_mutex);
17319 + list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
17320 + list) {
17321 + if (!sas_info->is_logical_volume &&
17322 + (sas_info->sas_address == sas_address ||
17323 + (sas_info->fw.channel == channel &&
17324 + sas_info->fw.id == id))) {
17325 + list_del(&sas_info->list);
17326 + kfree(sas_info);
17327 + }
17328 }
17329
17330 + if (!(sas_info = kzalloc(sizeof(struct sas_device_info), GFP_KERNEL)))
17331 + goto out;
17332 +
17333 /*
17334 - * Populate and refresh the tree
17335 + * Set Firmware mapping
17336 */
17337 - phy_info = port_info->phy_info;
17338 - for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
17339 - sas_address = phy_info->attached.sas_address;
17340 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
17341 - ioc->name, i, (unsigned long long)sas_address));
17342 - if (!sas_address)
17343 - continue;
17344 - port_details = phy_info->port_details;
17345 - /*
17346 - * Forming a port
17347 - */
17348 - if (!port_details) {
17349 - port_details = kzalloc(sizeof(*port_details),
17350 - GFP_KERNEL);
17351 - if (!port_details)
17352 - goto out;
17353 - port_details->num_phys = 1;
17354 - port_details->port_info = port_info;
17355 - if (phy_info->phy_id < 64 )
17356 - port_details->phy_bitmask |=
17357 - (1 << phy_info->phy_id);
17358 - phy_info->sas_port_add_phy=1;
17359 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
17360 - "phy_id=%d sas_address=0x%018llX\n",
17361 - ioc->name, i, (unsigned long long)sas_address));
17362 - phy_info->port_details = port_details;
17363 - }
17364 + sas_info->fw.id = id;
17365 + sas_info->fw.channel = channel;
17366
17367 - if (i == port_info->num_phys - 1)
17368 - continue;
17369 - phy_info_cmp = &port_info->phy_info[i + 1];
17370 - for (j = i + 1 ; j < port_info->num_phys ; j++,
17371 - phy_info_cmp++) {
17372 - if (!phy_info_cmp->attached.sas_address)
17373 - continue;
17374 - if (sas_address != phy_info_cmp->attached.sas_address)
17375 - continue;
17376 - if (phy_info_cmp->port_details == port_details )
17377 - continue;
17378 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
17379 - "\t\tphy_id=%d sas_address=0x%018llX\n",
17380 - ioc->name, j, (unsigned long long)
17381 - phy_info_cmp->attached.sas_address));
17382 - if (phy_info_cmp->port_details) {
17383 - port_details->rphy =
17384 - mptsas_get_rphy(phy_info_cmp);
17385 - port_details->port =
17386 - mptsas_get_port(phy_info_cmp);
17387 - port_details->starget =
17388 - mptsas_get_starget(phy_info_cmp);
17389 - port_details->num_phys =
17390 - phy_info_cmp->port_details->num_phys;
17391 - if (!phy_info_cmp->port_details->num_phys)
17392 - kfree(phy_info_cmp->port_details);
17393 - } else
17394 - phy_info_cmp->sas_port_add_phy=1;
17395 - /*
17396 - * Adding a phy to a port
17397 - */
17398 - phy_info_cmp->port_details = port_details;
17399 - if (phy_info_cmp->phy_id < 64 )
17400 - port_details->phy_bitmask |=
17401 - (1 << phy_info_cmp->phy_id);
17402 - port_details->num_phys++;
17403 + sas_info->sas_address = sas_address;
17404 + sas_info->device_info = device_info;
17405 + sas_info->slot = slot;
17406 + sas_info->enclosure_logical_id = enclosure_logical_id;
17407 + INIT_LIST_HEAD(&sas_info->list);
17408 + list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
17409 +
17410 + /*
17411 + * Set OS mapping
17412 + */
17413 + shost_for_each_device(sdev, ioc->sh) {
17414 + starget = scsi_target(sdev);
17415 + rphy = dev_to_rphy(starget->dev.parent);
17416 + if (rphy->identify.sas_address == sas_address) {
17417 + sas_info->os.id = starget->id;
17418 + sas_info->os.channel = starget->channel;
17419 }
17420 }
17421
17422 out:
17423 -
17424 - for (i = 0; i < port_info->num_phys; i++) {
17425 - port_details = port_info->phy_info[i].port_details;
17426 - if (!port_details)
17427 - continue;
17428 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
17429 - "%s: [%p]: phy_id=%02d num_phys=%02d "
17430 - "bitmask=0x%016llX\n", ioc->name, __func__,
17431 - port_details, i, port_details->num_phys,
17432 - (unsigned long long)port_details->phy_bitmask));
17433 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
17434 - ioc->name, port_details->port, port_details->rphy));
17435 - }
17436 - dsaswideprintk(ioc, printk("\n"));
17437 - mutex_unlock(&ioc->sas_topology_mutex);
17438 + up(&ioc->sas_device_info_mutex);
17439 + return;
17440 }
17441
17442 /**
17443 - * csmisas_find_vtarget
17444 - *
17445 - * @ioc
17446 - * @volume_id
17447 - * @volume_bus
17448 + * mptsas_add_device_component_by_fw -
17449 + * @ioc: Pointer to MPT_ADAPTER structure
17450 + * @channel: fw mapped id's
17451 + * @id:
17452 *
17453 **/
17454 -static VirtTarget *
17455 -mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
17456 +static void
17457 +mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id)
17458 {
17459 - struct scsi_device *sdev;
17460 - VirtDevice *vdevice;
17461 - VirtTarget *vtarget = NULL;
17462 + struct mptsas_devinfo sas_device;
17463 + struct mptsas_enclosure enclosure_info;
17464 + int rc;
17465
17466 - shost_for_each_device(sdev, ioc->sh) {
17467 - if ((vdevice = sdev->hostdata) == NULL)
17468 - continue;
17469 - if (vdevice->vtarget->id == id &&
17470 - vdevice->vtarget->channel == channel)
17471 - vtarget = vdevice->vtarget;
17472 - }
17473 - return vtarget;
17474 + rc = mptsas_sas_device_pg0(ioc, &sas_device,
17475 + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
17476 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
17477 + (channel << 8) + id);
17478 + if (rc)
17479 + return;
17480 +
17481 + memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
17482 + mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
17483 + (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
17484 + MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
17485 + sas_device.handle_enclosure);
17486 +
17487 + mptsas_add_device_component(ioc, sas_device.channel,
17488 + sas_device.id, sas_device.sas_address, sas_device.device_info,
17489 + sas_device.slot, enclosure_info.enclosure_logical_id);
17490 }
17491
17492 /**
17493 - * mptsas_target_reset
17494 - *
17495 - * Issues TARGET_RESET to end device using handshaking method
17496 - *
17497 - * @ioc
17498 - * @channel
17499 - * @id
17500 - *
17501 - * Returns (1) success
17502 - * (0) failure
17503 - *
17504 - **/
17505 -static int
17506 -mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
17507 -{
17508 - MPT_FRAME_HDR *mf;
17509 - SCSITaskMgmt_t *pScsiTm;
17510 -
17511 - if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
17512 - dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
17513 - ioc->name,__func__, __LINE__));
17514 - return 0;
17515 - }
17516 -
17517 - /* Format the Request
17518 - */
17519 - pScsiTm = (SCSITaskMgmt_t *) mf;
17520 - memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
17521 - pScsiTm->TargetID = id;
17522 - pScsiTm->Bus = channel;
17523 - pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
17524 - pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
17525 - pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
17526 -
17527 - DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
17528 -
17529 - mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
17530 -
17531 - return 1;
17532 -}
17533 -
17534 -/**
17535 - * mptsas_target_reset_queue
17536 - *
17537 - * Receive request for TARGET_RESET after recieving an firmware
17538 - * event NOT_RESPONDING_EVENT, then put command in link list
17539 - * and queue if task_queue already in use.
17540 - *
17541 - * @ioc
17542 - * @sas_event_data
17543 + * mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding
17544 + * each individual device to list
17545 + * @ioc: Pointer to MPT_ADAPTER structure
17546 + * @channel: fw mapped id's
17547 + * @id:
17548 *
17549 **/
17550 static void
17551 -mptsas_target_reset_queue(MPT_ADAPTER *ioc,
17552 - EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
17553 +mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc, struct scsi_target *starget)
17554 {
17555 - MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
17556 - VirtTarget *vtarget = NULL;
17557 - struct mptsas_target_reset_event *target_reset_list;
17558 - u8 id, channel;
17559 + CONFIGPARMS cfg;
17560 + ConfigPageHeader_t hdr;
17561 + dma_addr_t dma_handle;
17562 + pRaidVolumePage0_t buffer = NULL;
17563 + int i;
17564 + RaidPhysDiskPage0_t phys_disk;
17565 + struct sas_device_info *sas_info, *next;
17566
17567 - id = sas_event_data->TargetID;
17568 - channel = sas_event_data->Bus;
17569 + memset(&cfg, 0 , sizeof(CONFIGPARMS));
17570 + memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
17571 + hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
17572 + /* assumption that all volumes on channel = 0 */
17573 + cfg.pageAddr = starget->id;
17574 + cfg.cfghdr.hdr = &hdr;
17575 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
17576 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
17577
17578 - if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
17579 - return;
17580 + if (mpt_config(ioc, &cfg) != 0)
17581 + goto out;
17582
17583 - vtarget->deleted = 1; /* block IO */
17584 + if (!hdr.PageLength)
17585 + goto out;
17586
17587 - target_reset_list = kzalloc(sizeof(*target_reset_list),
17588 - GFP_ATOMIC);
17589 - if (!target_reset_list) {
17590 - dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
17591 - ioc->name,__func__, __LINE__));
17592 - return;
17593 - }
17594 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
17595 + &dma_handle);
17596
17597 - memcpy(&target_reset_list->sas_event_data, sas_event_data,
17598 - sizeof(*sas_event_data));
17599 - list_add_tail(&target_reset_list->list, &hd->target_reset_list);
17600 + if (!buffer)
17601 + goto out;
17602
17603 - if (hd->resetPending)
17604 - return;
17605 + cfg.physAddr = dma_handle;
17606 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
17607
17608 - if (mptsas_target_reset(ioc, channel, id)) {
17609 - target_reset_list->target_reset_issued = 1;
17610 - hd->resetPending = 1;
17611 - }
17612 -}
17613 + if (mpt_config(ioc, &cfg) != 0)
17614 + goto out;
17615
17616 -/**
17617 - * mptsas_dev_reset_complete
17618 - *
17619 - * Completion for TARGET_RESET after NOT_RESPONDING_EVENT,
17620 - * enable work queue to finish off removing device from upper layers.
17621 - * then send next TARGET_RESET in the queue.
17622 - *
17623 - * @ioc
17624 - *
17625 - **/
17626 -static void
17627 -mptsas_dev_reset_complete(MPT_ADAPTER *ioc)
17628 -{
17629 - MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
17630 - struct list_head *head = &hd->target_reset_list;
17631 - struct mptsas_target_reset_event *target_reset_list;
17632 - struct mptsas_hotplug_event *ev;
17633 - EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
17634 - u8 id, channel;
17635 - __le64 sas_address;
17636 + if (!buffer->NumPhysDisks)
17637 + goto out;
17638
17639 - if (list_empty(head))
17640 - return;
17641 + /*
17642 + * Adding entry for hidden components
17643 + */
17644 + for (i = 0; i < buffer->NumPhysDisks; i++) {
17645
17646 - target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, list);
17647 + if(mpt_raid_phys_disk_pg0(ioc,
17648 + buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
17649 + continue;
17650
17651 - sas_event_data = &target_reset_list->sas_event_data;
17652 - id = sas_event_data->TargetID;
17653 - channel = sas_event_data->Bus;
17654 - hd->resetPending = 0;
17655 + mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus,
17656 + phys_disk.PhysDiskID);
17657
17658 - /*
17659 - * retry target reset
17660 - */
17661 - if (!target_reset_list->target_reset_issued) {
17662 - if (mptsas_target_reset(ioc, channel, id)) {
17663 - target_reset_list->target_reset_issued = 1;
17664 - hd->resetPending = 1;
17665 + down(&ioc->sas_device_info_mutex);
17666 + list_for_each_entry(sas_info, &ioc->sas_device_info_list,
17667 + list) {
17668 + if (!sas_info->is_logical_volume &&
17669 + (sas_info->fw.channel == phys_disk.PhysDiskBus &&
17670 + sas_info->fw.id == phys_disk.PhysDiskID)) {
17671 + sas_info->is_hidden_raid_component = 1;
17672 + sas_info->volume_id = starget->id;
17673 + }
17674 }
17675 - return;
17676 + up(&ioc->sas_device_info_mutex);
17677 }
17678
17679 /*
17680 - * enable work queue to remove device from upper layers
17681 + * Delete all matching devices out of the list
17682 */
17683 - list_del(&target_reset_list->list);
17684 + down(&ioc->sas_device_info_mutex);
17685 + list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
17686 + list) {
17687 + if (sas_info->is_logical_volume && sas_info->fw.id ==
17688 + starget->id) {
17689 + list_del(&sas_info->list);
17690 + kfree(sas_info);
17691 + }
17692 + }
17693
17694 - ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
17695 - if (!ev) {
17696 - dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
17697 - ioc->name,__func__, __LINE__));
17698 - return;
17699 + sas_info = kzalloc(sizeof(struct sas_device_info), GFP_KERNEL);
17700 + if (sas_info) {
17701 + sas_info->fw.id = starget->id;
17702 + sas_info->os.id = starget->id;
17703 + sas_info->os.channel = starget->channel;
17704 + sas_info->is_logical_volume = 1;
17705 + INIT_LIST_HEAD(&sas_info->list);
17706 + list_add_tail(&sas_info->list, &ioc->sas_device_info_list);
17707 }
17708 + up(&ioc->sas_device_info_mutex);
17709
17710 - INIT_WORK(&ev->work, mptsas_hotplug_work);
17711 - ev->ioc = ioc;
17712 - ev->handle = le16_to_cpu(sas_event_data->DevHandle);
17713 - ev->parent_handle =
17714 - le16_to_cpu(sas_event_data->ParentDevHandle);
17715 - ev->channel = channel;
17716 - ev->id =id;
17717 - ev->phy_id = sas_event_data->PhyNum;
17718 - memcpy(&sas_address, &sas_event_data->SASAddress,
17719 - sizeof(__le64));
17720 - ev->sas_address = le64_to_cpu(sas_address);
17721 - ev->device_info = le32_to_cpu(sas_event_data->DeviceInfo);
17722 - ev->event_type = MPTSAS_DEL_DEVICE;
17723 - schedule_work(&ev->work);
17724 - kfree(target_reset_list);
17725 + out:
17726 + if (buffer)
17727 + pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
17728 + dma_handle);
17729 +}
17730
17731 - /*
17732 - * issue target reset to next device in the queue
17733 - */
17734 +/**
17735 + * mptsas_add_device_component_starget -
17736 + * @ioc: Pointer to MPT_ADAPTER structure
17737 + * @starget:
17738 + *
17739 + **/
17740 +static void
17741 +mptsas_add_device_component_starget(MPT_ADAPTER *ioc, struct scsi_target *starget)
17742 +{
17743 + VirtTarget *vtarget;
17744 + struct sas_rphy *rphy;
17745 + struct mptsas_phyinfo *phy_info = NULL;
17746 + struct mptsas_enclosure enclosure_info;
17747
17748 - head = &hd->target_reset_list;
17749 - if (list_empty(head))
17750 + rphy = dev_to_rphy(starget->dev.parent);
17751 + vtarget = starget->hostdata;
17752 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
17753 + rphy->identify.sas_address);
17754 + if (!phy_info)
17755 return;
17756
17757 - target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
17758 - list);
17759 -
17760 - sas_event_data = &target_reset_list->sas_event_data;
17761 - id = sas_event_data->TargetID;
17762 - channel = sas_event_data->Bus;
17763 -
17764 - if (mptsas_target_reset(ioc, channel, id)) {
17765 - target_reset_list->target_reset_issued = 1;
17766 - hd->resetPending = 1;
17767 - }
17768 + memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
17769 + mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
17770 + (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
17771 + MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
17772 + phy_info->attached.handle_enclosure);
17773 +
17774 + mptsas_add_device_component(ioc, phy_info->attached.channel,
17775 + phy_info->attached.id, phy_info->attached.sas_address,
17776 + phy_info->attached.device_info,
17777 + phy_info->attached.slot, enclosure_info.enclosure_logical_id);
17778 }
17779
17780 /**
17781 - * mptsas_taskmgmt_complete
17782 - *
17783 - * @ioc
17784 - * @mf
17785 - * @mr
17786 + * mptsas_del_device_component_by_os - Once a device has been removed, we
17787 + * mark the entry in the list as being cached
17788 + * @ioc: Pointer to MPT_ADAPTER structure
17789 + * @channel: os mapped id's
17790 + * @id:
17791 *
17792 **/
17793 -static int
17794 -mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
17795 +static void
17796 +mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id)
17797 {
17798 - mptsas_dev_reset_complete(ioc);
17799 - return mptscsih_taskmgmt_complete(ioc, mf, mr);
17800 + struct sas_device_info *sas_info, *next;
17801 +
17802 + /*
17803 + * Set is_cached flag
17804 + */
17805 + list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
17806 + list) {
17807 + if (sas_info->os.channel == channel && sas_info->os.id == id)
17808 + sas_info->is_cached = 1;
17809 + }
17810 }
17811
17812 /**
17813 - * mptscsih_ioc_reset
17814 - *
17815 - * @ioc
17816 - * @reset_phase
17817 + * mptsas_del_device_components - Cleaning the list
17818 + * @ioc: Pointer to MPT_ADAPTER structure
17819 *
17820 **/
17821 -static int
17822 -mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
17823 +static void
17824 +mptsas_del_device_components(MPT_ADAPTER *ioc)
17825 {
17826 - MPT_SCSI_HOST *hd;
17827 - struct mptsas_target_reset_event *target_reset_list, *n;
17828 - int rc;
17829 -
17830 - rc = mptscsih_ioc_reset(ioc, reset_phase);
17831 -
17832 - if (ioc->bus_type != SAS)
17833 - goto out;
17834 -
17835 - if (reset_phase != MPT_IOC_POST_RESET)
17836 - goto out;
17837 + struct sas_device_info *sas_info, *next;
17838
17839 - if (!ioc->sh || !ioc->sh->hostdata)
17840 - goto out;
17841 - hd = shost_priv(ioc->sh);
17842 - if (!hd->ioc)
17843 - goto out;
17844 -
17845 - if (list_empty(&hd->target_reset_list))
17846 - goto out;
17847 -
17848 - /* flush the target_reset_list */
17849 - list_for_each_entry_safe(target_reset_list, n,
17850 - &hd->target_reset_list, list) {
17851 - list_del(&target_reset_list->list);
17852 - kfree(target_reset_list);
17853 + down(&ioc->sas_device_info_mutex);
17854 + list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list,
17855 + list) {
17856 + list_del(&sas_info->list);
17857 + kfree(sas_info);
17858 }
17859 -
17860 - out:
17861 - return rc;
17862 + up(&ioc->sas_device_info_mutex);
17863 }
17864
17865 -static int
17866 -mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
17867 - u32 form, u32 form_specific)
17868 +/**
17869 + * mptsas_setup_wide_ports - Updates for new and existing narrow/wide port
17870 + * configuration
17871 + * in the sas_topology
17872 + * @ioc: Pointer to MPT_ADAPTER structure
17873 + * @port_info:
17874 + *
17875 + */
17876 +static void
17877 +mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
17878 {
17879 - ConfigExtendedPageHeader_t hdr;
17880 - CONFIGPARMS cfg;
17881 - SasEnclosurePage0_t *buffer;
17882 - dma_addr_t dma_handle;
17883 - int error;
17884 - __le64 le_identifier;
17885 -
17886 - memset(&hdr, 0, sizeof(hdr));
17887 - hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
17888 - hdr.PageNumber = 0;
17889 - hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
17890 - hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
17891 + struct mptsas_portinfo_details * port_details;
17892 + struct mptsas_phyinfo *phy_info, *phy_info_cmp;
17893 + u64 sas_address;
17894 + int i, j;
17895
17896 - cfg.cfghdr.ehdr = &hdr;
17897 - cfg.physAddr = -1;
17898 - cfg.pageAddr = form + form_specific;
17899 - cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
17900 - cfg.dir = 0; /* read */
17901 - cfg.timeout = 10;
17902 + mutex_lock(&ioc->sas_topology_mutex);
17903
17904 - error = mpt_config(ioc, &cfg);
17905 - if (error)
17906 - goto out;
17907 - if (!hdr.ExtPageLength) {
17908 - error = -ENXIO;
17909 - goto out;
17910 - }
17911 + phy_info = port_info->phy_info;
17912 + for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
17913 + if (phy_info->attached.handle)
17914 + continue;
17915 + port_details = phy_info->port_details;
17916 + if (!port_details)
17917 + continue;
17918 + if (port_details->num_phys < 2)
17919 + continue;
17920
17921 - buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
17922 - &dma_handle);
17923 - if (!buffer) {
17924 - error = -ENOMEM;
17925 - goto out;
17926 + /*
17927 + * Removing a phy from a port, letting the last
17928 + * phy be removed by firmware events.
17929 + */
17930 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
17931 + "%s: [%p]: deleting phy = %d\n",
17932 + ioc->name, __FUNCTION__, port_details, i));
17933 + port_details->num_phys--;
17934 + port_details->phy_bitmask &= ~ (1 << phy_info->phy_id);
17935 + memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo));
17936 + devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
17937 + MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
17938 + phy_info->phy_id, phy_info->phy));
17939 + sas_port_delete_phy(port_details->port, phy_info->phy);
17940 + phy_info->port_details = NULL;
17941 }
17942
17943 - cfg.physAddr = dma_handle;
17944 - cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
17945 -
17946 - error = mpt_config(ioc, &cfg);
17947 - if (error)
17948 - goto out_free_consistent;
17949 -
17950 - /* save config data */
17951 - memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
17952 - enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
17953 - enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
17954 - enclosure->flags = le16_to_cpu(buffer->Flags);
17955 - enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
17956 - enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
17957 - enclosure->start_id = buffer->StartTargetID;
17958 - enclosure->start_channel = buffer->StartBus;
17959 - enclosure->sep_id = buffer->SEPTargetID;
17960 - enclosure->sep_channel = buffer->SEPBus;
17961 + /*
17962 + * Populate and refresh the tree
17963 + */
17964 + phy_info = port_info->phy_info;
17965 + for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) {
17966 + sas_address = phy_info->attached.sas_address;
17967 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n",
17968 + ioc->name, i, (unsigned long long)sas_address));
17969 + if (!sas_address)
17970 + continue;
17971 + port_details = phy_info->port_details;
17972 + /*
17973 + * Forming a port
17974 + */
17975 + if (!port_details) {
17976 + port_details = kzalloc(sizeof(struct mptsas_portinfo_details),
17977 + GFP_KERNEL);
17978 + if (!port_details)
17979 + goto out;
17980 + port_details->num_phys = 1;
17981 + port_details->port_info = port_info;
17982 + if (phy_info->phy_id < 64 )
17983 + port_details->phy_bitmask |=
17984 + (1 << phy_info->phy_id);
17985 + phy_info->sas_port_add_phy=1;
17986 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t"
17987 + "phy_id=%d sas_address=0x%018llX\n", ioc->name, i,
17988 + (unsigned long long) sas_address));
17989 + phy_info->port_details = port_details;
17990 + }
17991 +
17992 + if (i == port_info->num_phys - 1)
17993 + continue;
17994 + phy_info_cmp = &port_info->phy_info[i + 1];
17995 + for (j = i + 1 ; j < port_info->num_phys ; j++,
17996 + phy_info_cmp++) {
17997 + if (!phy_info_cmp->attached.sas_address)
17998 + continue;
17999 + if (sas_address != phy_info_cmp->attached.sas_address)
18000 + continue;
18001 + if (phy_info_cmp->port_details == port_details )
18002 + continue;
18003 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18004 + "\t\tphy_id=%d sas_address=0x%018llX\n",
18005 + ioc->name, j, (unsigned long long)
18006 + phy_info_cmp->attached.sas_address));
18007 + if (phy_info_cmp->port_details) {
18008 + port_details->rphy =
18009 + mptsas_get_rphy(phy_info_cmp);
18010 + port_details->port =
18011 + mptsas_get_port(phy_info_cmp);
18012 + port_details->starget =
18013 + mptsas_get_starget(phy_info_cmp);
18014 + port_details->num_phys =
18015 + phy_info_cmp->port_details->num_phys;
18016 + if (!phy_info_cmp->port_details->num_phys)
18017 + kfree(phy_info_cmp->port_details);
18018 + } else
18019 + phy_info_cmp->sas_port_add_phy=1;
18020 + /*
18021 + * Adding a phy to a port
18022 + */
18023 + phy_info_cmp->port_details = port_details;
18024 + if (phy_info_cmp->phy_id < 64 )
18025 + port_details->phy_bitmask |=
18026 + (1 << phy_info_cmp->phy_id);
18027 + port_details->num_phys++;
18028 + }
18029 + }
18030
18031 - out_free_consistent:
18032 - pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
18033 - buffer, dma_handle);
18034 out:
18035 - return error;
18036 +
18037 + for (i = 0; i < port_info->num_phys; i++) {
18038 + port_details = port_info->phy_info[i].port_details;
18039 + if (!port_details)
18040 + continue;
18041 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18042 + "%s: [%p]: phy_id=%02d num_phys=%02d "
18043 + "bitmask=0x%016llX\n", ioc->name, __FUNCTION__,
18044 + port_details, i, port_details->num_phys,
18045 + (unsigned long long)port_details->phy_bitmask));
18046 + dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n",
18047 + ioc->name, port_details->port, port_details->rphy));
18048 + }
18049 + dsaswideprintk(ioc, printk("\n"));
18050 + mutex_unlock(&ioc->sas_topology_mutex);
18051 }
18052
18053 -static int
18054 -mptsas_slave_configure(struct scsi_device *sdev)
18055 +/**
18056 + * mptsas_find_vtarget - obtain vtarget object for non-raid devices
18057 + * @ioc: Pointer to MPT_ADAPTER structure
18058 + * @channel:
18059 + * @id:
18060 + *
18061 + **/
18062 +static VirtTarget *
18063 +mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id)
18064 +{
18065 + struct scsi_device *sdev;
18066 + VirtDevice *vdevice;
18067 + VirtTarget *vtarget = NULL;
18068 +
18069 + shost_for_each_device(sdev, ioc->sh) {
18070 + if ((vdevice = sdev->hostdata) == NULL ||
18071 + (vdevice->vtarget == NULL))
18072 + continue;
18073 + if ((vdevice->vtarget->tflags &
18074 + MPT_TARGET_FLAGS_RAID_COMPONENT ||
18075 + vdevice->vtarget->raidVolume))
18076 + continue;
18077 + if (vdevice->vtarget->id == id &&
18078 + vdevice->vtarget->channel == channel)
18079 + vtarget = vdevice->vtarget;
18080 + }
18081 + return vtarget;
18082 +}
18083 +
18084 +static void
18085 +mptsas_queue_device_delete(MPT_ADAPTER *ioc,
18086 + MpiEventDataSasDeviceStatusChange_t *sas_event_data)
18087 {
18088 + struct fw_event_work *fw_event;
18089 + int sz;
18090
18091 - if (sdev->channel == MPTSAS_RAID_CHANNEL)
18092 - goto out;
18093 + sz = offsetof(struct fw_event_work, event_data) +
18094 + sizeof(MpiEventDataSasDeviceStatusChange_t);
18095 + fw_event = kzalloc(sz, GFP_ATOMIC);
18096 + if (!fw_event) {
18097 + printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
18098 + ioc->name, __FUNCTION__, __LINE__);
18099 + return;
18100 + }
18101 + memcpy(fw_event->event_data, sas_event_data,
18102 + sizeof(MpiEventDataSasDeviceStatusChange_t));
18103 + fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE;
18104 + fw_event->ioc = ioc;
18105 + mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
18106 +}
18107
18108 - sas_read_port_mode_page(sdev);
18109 +static void
18110 +mptsas_queue_rescan(MPT_ADAPTER *ioc)
18111 +{
18112 + struct fw_event_work *fw_event;
18113 + int sz;
18114
18115 - out:
18116 - return mptscsih_slave_configure(sdev);
18117 + sz = offsetof(struct fw_event_work, event_data);
18118 + fw_event = kzalloc(sz, GFP_ATOMIC);
18119 + if (!fw_event) {
18120 + printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n",
18121 + ioc->name, __FUNCTION__, __LINE__);
18122 + return;
18123 + }
18124 + fw_event->event = -1;
18125 + fw_event->ioc = ioc;
18126 + mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1));
18127 }
18128
18129 +
18130 +/**
18131 + * mptsas_target_reset - Issues TARGET_RESET to end device using
18132 + * handshaking method
18133 + * @ioc: Pointer to MPT_ADAPTER structure
18134 + * @channel:
18135 + * @id:
18136 + *
18137 + * Returns (1) success
18138 + * (0) failure
18139 + *
18140 + **/
18141 static int
18142 -mptsas_target_alloc(struct scsi_target *starget)
18143 +mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
18144 {
18145 - struct Scsi_Host *host = dev_to_shost(&starget->dev);
18146 - MPT_SCSI_HOST *hd = shost_priv(host);
18147 - VirtTarget *vtarget;
18148 - u8 id, channel;
18149 - struct sas_rphy *rphy;
18150 - struct mptsas_portinfo *p;
18151 - int i;
18152 - MPT_ADAPTER *ioc = hd->ioc;
18153 + MPT_FRAME_HDR *mf;
18154 + SCSITaskMgmt_t *pScsiTm;
18155
18156 - vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
18157 - if (!vtarget)
18158 - return -ENOMEM;
18159 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0)
18160 + return 0;
18161
18162 - vtarget->starget = starget;
18163 - vtarget->ioc_id = ioc->id;
18164 - vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
18165 - id = starget->id;
18166 - channel = 0;
18167 + if ((mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc)) == NULL) {
18168 + dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n",
18169 + ioc->name,__FUNCTION__, __LINE__));
18170 + goto out_fail;
18171 + }
18172
18173 - /*
18174 - * RAID volumes placed beyond the last expected port.
18175 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
18176 + ioc->name, mf));
18177 +
18178 + /* Format the Request
18179 */
18180 - if (starget->channel == MPTSAS_RAID_CHANNEL) {
18181 - for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
18182 - if (id == ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
18183 - channel = ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
18184 - goto out;
18185 - }
18186 + pScsiTm = (SCSITaskMgmt_t *) mf;
18187 + memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t));
18188 + pScsiTm->TargetID = id;
18189 + pScsiTm->Bus = channel;
18190 + pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
18191 + pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
18192 + pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
18193
18194 - rphy = dev_to_rphy(starget->dev.parent);
18195 - mutex_lock(&ioc->sas_topology_mutex);
18196 - list_for_each_entry(p, &ioc->sas_topology, list) {
18197 - for (i = 0; i < p->num_phys; i++) {
18198 - if (p->phy_info[i].attached.sas_address !=
18199 - rphy->identify.sas_address)
18200 - continue;
18201 - id = p->phy_info[i].attached.id;
18202 - channel = p->phy_info[i].attached.channel;
18203 - mptsas_set_starget(&p->phy_info[i], starget);
18204 + DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf);
18205
18206 - /*
18207 - * Exposing hidden raid components
18208 - */
18209 - if (mptscsih_is_phys_disk(ioc, channel, id)) {
18210 - id = mptscsih_raid_id_to_num(ioc,
18211 - channel, id);
18212 - vtarget->tflags |=
18213 - MPT_TARGET_FLAGS_RAID_COMPONENT;
18214 - p->phy_info[i].attached.phys_disk_num = id;
18215 - }
18216 - mutex_unlock(&ioc->sas_topology_mutex);
18217 - goto out;
18218 - }
18219 - }
18220 - mutex_unlock(&ioc->sas_topology_mutex);
18221 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18222 + "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n",
18223 + ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id));
18224
18225 - kfree(vtarget);
18226 - return -ENXIO;
18227 + mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
18228
18229 - out:
18230 - vtarget->id = id;
18231 - vtarget->channel = channel;
18232 - starget->hostdata = vtarget;
18233 + return 1;
18234 +
18235 + out_fail:
18236 +
18237 + mpt_clear_taskmgmt_in_progress_flag(ioc);
18238 return 0;
18239 }
18240 -
18241 +/**
18242 + * mptsas_target_reset_queue -
18243 + * @ioc: Pointer to MPT_ADAPTER structure
18244 + * @sas_event_data:
18245 + *
18246 + * Receive request for TARGET_RESET after
18247 + * recieving an firmware event NOT_RESPONDING_EVENT, then put command in
18248 + * link list and queue if task_queue already in use.
18249 + **/
18250 static void
18251 -mptsas_target_destroy(struct scsi_target *starget)
18252 +mptsas_target_reset_queue(MPT_ADAPTER *ioc,
18253 + EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
18254 {
18255 - struct Scsi_Host *host = dev_to_shost(&starget->dev);
18256 - MPT_SCSI_HOST *hd = shost_priv(host);
18257 - struct sas_rphy *rphy;
18258 - struct mptsas_portinfo *p;
18259 - int i;
18260 - MPT_ADAPTER *ioc = hd->ioc;
18261 + MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
18262 + VirtTarget *vtarget = NULL;
18263 + struct mptsas_target_reset_event *target_reset_list;
18264 + u8 id, channel;
18265
18266 - if (!starget->hostdata)
18267 - return;
18268 + id = sas_event_data->TargetID;
18269 + channel = sas_event_data->Bus;
18270
18271 - if (starget->channel == MPTSAS_RAID_CHANNEL)
18272 - goto out;
18273 + if ((vtarget = mptsas_find_vtarget(ioc, channel, id))) {
18274 + if (!ioc->disable_hotplug_remove)
18275 + vtarget->deleted = 1; /* block IO */
18276 + }
18277
18278 - rphy = dev_to_rphy(starget->dev.parent);
18279 - list_for_each_entry(p, &ioc->sas_topology, list) {
18280 - for (i = 0; i < p->num_phys; i++) {
18281 - if (p->phy_info[i].attached.sas_address !=
18282 - rphy->identify.sas_address)
18283 - continue;
18284 - mptsas_set_starget(&p->phy_info[i], NULL);
18285 - goto out;
18286 - }
18287 + target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
18288 + GFP_ATOMIC);
18289 + if (!target_reset_list) {
18290 + dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n",
18291 + ioc->name,__FUNCTION__, __LINE__));
18292 + return;
18293 }
18294
18295 - out:
18296 - kfree(starget->hostdata);
18297 - starget->hostdata = NULL;
18298 -}
18299 + memcpy(&target_reset_list->sas_event_data, sas_event_data,
18300 + sizeof(*sas_event_data));
18301 + list_add_tail(&target_reset_list->list, &hd->target_reset_list);
18302 +
18303 + target_reset_list->time_count = jiffies;
18304
18305 + if (mptsas_target_reset(ioc, channel, id))
18306 + target_reset_list->target_reset_issued = 1;
18307 +}
18308
18309 +/**
18310 + * mptsas_taskmgmt_complete - Completion for TARGET_RESET after
18311 + * NOT_RESPONDING_EVENT, enable work queue to finish off removing device
18312 + * from upper layers. then send next TARGET_RESET in the queue.
18313 + * @ioc: Pointer to MPT_ADAPTER structure
18314 + *
18315 + **/
18316 static int
18317 -mptsas_slave_alloc(struct scsi_device *sdev)
18318 +mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
18319 {
18320 - struct Scsi_Host *host = sdev->host;
18321 - MPT_SCSI_HOST *hd = shost_priv(host);
18322 - struct sas_rphy *rphy;
18323 - struct mptsas_portinfo *p;
18324 - VirtDevice *vdevice;
18325 - struct scsi_target *starget;
18326 - int i;
18327 - MPT_ADAPTER *ioc = hd->ioc;
18328 + MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
18329 + struct list_head *head = &hd->target_reset_list;
18330 + struct mptsas_target_reset_event *target_reset_list;
18331 + u8 id, channel;
18332 + SCSITaskMgmtReply_t *pScsiTmReply;
18333
18334 - vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
18335 - if (!vdevice) {
18336 - printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
18337 - ioc->name, sizeof(VirtDevice));
18338 - return -ENOMEM;
18339 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: "
18340 + "(mf = %p, mr = %p)\n", ioc->name, mf, mr));
18341 +
18342 + pScsiTmReply = (SCSITaskMgmtReply_t *)mr;
18343 + if (pScsiTmReply) {
18344 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18345 + "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n"
18346 + "\ttask_type = 0x%02X, iocstatus = 0x%04X "
18347 + "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, "
18348 + "term_cmnds = %d\n", ioc->name,
18349 + pScsiTmReply->Bus, pScsiTmReply->TargetID,
18350 + pScsiTmReply->TaskType,
18351 + le16_to_cpu(pScsiTmReply->IOCStatus),
18352 + le32_to_cpu(pScsiTmReply->IOCLogInfo),
18353 + pScsiTmReply->ResponseCode,
18354 + le32_to_cpu(pScsiTmReply->TerminationCount)));
18355 +
18356 + if (pScsiTmReply->ResponseCode)
18357 + mptscsih_taskmgmt_response_code(ioc,
18358 + pScsiTmReply->ResponseCode);
18359 + }
18360 +
18361 + if (pScsiTmReply && (pScsiTmReply->TaskType ==
18362 + MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType ==
18363 + MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET)) {
18364 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
18365 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
18366 + memcpy(ioc->taskmgmt_cmds.reply, mr,
18367 + min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
18368 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
18369 + ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
18370 + complete(&ioc->taskmgmt_cmds.done);
18371 + return 1;
18372 + }
18373 + return 0;
18374 }
18375 - starget = scsi_target(sdev);
18376 - vdevice->vtarget = starget->hostdata;
18377
18378 - if (sdev->channel == MPTSAS_RAID_CHANNEL)
18379 - goto out;
18380 + mpt_clear_taskmgmt_in_progress_flag(ioc);
18381
18382 - rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
18383 - mutex_lock(&ioc->sas_topology_mutex);
18384 - list_for_each_entry(p, &ioc->sas_topology, list) {
18385 - for (i = 0; i < p->num_phys; i++) {
18386 - if (p->phy_info[i].attached.sas_address !=
18387 - rphy->identify.sas_address)
18388 - continue;
18389 - vdevice->lun = sdev->lun;
18390 - /*
18391 - * Exposing hidden raid components
18392 - */
18393 - if (mptscsih_is_phys_disk(ioc,
18394 - p->phy_info[i].attached.channel,
18395 - p->phy_info[i].attached.id))
18396 - sdev->no_uld_attach = 1;
18397 - mutex_unlock(&ioc->sas_topology_mutex);
18398 - goto out;
18399 - }
18400 + if (list_empty(head))
18401 + return 1;
18402 +
18403 + target_reset_list = list_entry(head->next,
18404 + struct mptsas_target_reset_event, list);
18405 +
18406 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18407 + "TaskMgmt: completed (%d seconds)\n",
18408 + ioc->name, jiffies_to_msecs(jiffies -
18409 + target_reset_list->time_count)/1000));
18410 +
18411 + id = pScsiTmReply->TargetID;
18412 + channel = pScsiTmReply->Bus;
18413 + target_reset_list->time_count = jiffies;
18414 +
18415 + /*
18416 + * retry target reset
18417 + */
18418 + if (!target_reset_list->target_reset_issued) {
18419 + if (mptsas_target_reset(ioc, channel, id))
18420 + target_reset_list->target_reset_issued = 1;
18421 + return 1;
18422 }
18423 - mutex_unlock(&ioc->sas_topology_mutex);
18424
18425 - kfree(vdevice);
18426 - return -ENXIO;
18427 + /*
18428 + * enable work queue to remove device from upper layers
18429 + */
18430 + list_del(&target_reset_list->list);
18431 + if ((mptsas_find_vtarget(ioc, channel, id)) && !ioc->fw_events_off)
18432 + mptsas_queue_device_delete(ioc, &target_reset_list->sas_event_data);
18433
18434 - out:
18435 - vdevice->vtarget->num_luns++;
18436 - sdev->hostdata = vdevice;
18437 - return 0;
18438 +
18439 + /*
18440 + * issue target reset to next device in the queue
18441 + */
18442 +
18443 + head = &hd->target_reset_list;
18444 + if (list_empty(head))
18445 + return 1;
18446 +
18447 + target_reset_list = list_entry(head->next, struct mptsas_target_reset_event,
18448 + list);
18449 +
18450 + id = target_reset_list->sas_event_data.TargetID;
18451 + channel = target_reset_list->sas_event_data.Bus;
18452 + target_reset_list->time_count = jiffies;
18453 +
18454 + if (mptsas_target_reset(ioc, channel, id))
18455 + target_reset_list->target_reset_issued = 1;
18456 +
18457 + return 1;
18458 }
18459
18460 +/**
18461 + * mptsas_ioc_reset -
18462 + * @ioc: Pointer to MPT_ADAPTER structure
18463 + * @reset_phase:
18464 + *
18465 + **/
18466 static int
18467 -mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
18468 +mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
18469 {
18470 - VirtDevice *vdevice = SCpnt->device->hostdata;
18471 -
18472 - if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
18473 - SCpnt->result = DID_NO_CONNECT << 16;
18474 - done(SCpnt);
18475 - return 0;
18476 - }
18477 + MPT_SCSI_HOST *hd;
18478 + int rc;
18479
18480 -// scsi_print_command(SCpnt);
18481 + rc = mptscsih_ioc_reset(ioc, reset_phase);
18482 + if ((ioc->bus_type != SAS) || (!rc))
18483 + return rc;
18484
18485 - return mptscsih_qcmd(SCpnt,done);
18486 -}
18487 + hd = shost_priv(ioc->sh);
18488 + if (!hd->ioc)
18489 + goto out;
18490
18491 + switch(reset_phase) {
18492 + case MPT_IOC_SETUP_RESET:
18493 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18494 + "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
18495 + mptsas_fw_event_off(ioc);
18496 + break;
18497 + case MPT_IOC_PRE_RESET:
18498 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18499 + "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
18500 + break;
18501 + case MPT_IOC_POST_RESET:
18502 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
18503 + "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
18504 + if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
18505 + ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET;
18506 + complete(&ioc->sas_mgmt.done);
18507 + }
18508 + mptsas_cleanup_fw_event_q(ioc);
18509 + mptsas_queue_rescan(ioc);
18510 + mptsas_fw_event_on(ioc);
18511 + break;
18512 + default:
18513 + break;
18514 + }
18515
18516 -static struct scsi_host_template mptsas_driver_template = {
18517 - .module = THIS_MODULE,
18518 - .proc_name = "mptsas",
18519 - .proc_info = mptscsih_proc_info,
18520 - .name = "MPT SPI Host",
18521 - .info = mptscsih_info,
18522 - .queuecommand = mptsas_qcmd,
18523 - .target_alloc = mptsas_target_alloc,
18524 - .slave_alloc = mptsas_slave_alloc,
18525 - .slave_configure = mptsas_slave_configure,
18526 - .target_destroy = mptsas_target_destroy,
18527 - .slave_destroy = mptscsih_slave_destroy,
18528 - .change_queue_depth = mptscsih_change_queue_depth,
18529 - .eh_abort_handler = mptscsih_abort,
18530 - .eh_device_reset_handler = mptscsih_dev_reset,
18531 - .eh_bus_reset_handler = mptscsih_bus_reset,
18532 - .eh_host_reset_handler = mptscsih_host_reset,
18533 - .bios_param = mptscsih_bios_param,
18534 - .can_queue = MPT_FC_CAN_QUEUE,
18535 - .this_id = -1,
18536 - .sg_tablesize = MPT_SCSI_SG_DEPTH,
18537 - .max_sectors = 8192,
18538 - .cmd_per_lun = 7,
18539 - .use_clustering = ENABLE_CLUSTERING,
18540 - .shost_attrs = mptscsih_host_attrs,
18541 -};
18542 + out:
18543 + return rc;
18544 +}
18545
18546 -static int mptsas_get_linkerrors(struct sas_phy *phy)
18547 +/**
18548 + * mptsas_sas_enclosure_pg0 -
18549 + * @ioc: Pointer to MPT_ADAPTER structure
18550 + * @enclosure:
18551 + * @form:
18552 + * @form_specific:
18553 + *
18554 + **/
18555 +static int
18556 +mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure,
18557 + u32 form, u32 form_specific)
18558 {
18559 - MPT_ADAPTER *ioc = phy_to_ioc(phy);
18560 ConfigExtendedPageHeader_t hdr;
18561 CONFIGPARMS cfg;
18562 - SasPhyPage1_t *buffer;
18563 + SasEnclosurePage0_t *buffer;
18564 dma_addr_t dma_handle;
18565 int error;
18566 + __le64 le_identifier;
18567
18568 - /* FIXME: only have link errors on local phys */
18569 - if (!scsi_is_sas_phy_local(phy))
18570 - return -EINVAL;
18571 -
18572 - hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
18573 - hdr.ExtPageLength = 0;
18574 - hdr.PageNumber = 1 /* page number 1*/;
18575 - hdr.Reserved1 = 0;
18576 - hdr.Reserved2 = 0;
18577 + memset(&hdr, 0, sizeof(hdr));
18578 + hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION;
18579 + hdr.PageNumber = 0;
18580 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
18581 - hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
18582 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE;
18583
18584 cfg.cfghdr.ehdr = &hdr;
18585 cfg.physAddr = -1;
18586 - cfg.pageAddr = phy->identify.phy_identifier;
18587 + cfg.pageAddr = form + form_specific;
18588 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
18589 - cfg.dir = 0; /* read */
18590 - cfg.timeout = 10;
18591 + cfg.dir = 0; /* read */
18592 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
18593
18594 error = mpt_config(ioc, &cfg);
18595 if (error)
18596 - return error;
18597 - if (!hdr.ExtPageLength)
18598 - return -ENXIO;
18599 + goto out;
18600 + if (!hdr.ExtPageLength) {
18601 + error = -ENXIO;
18602 + goto out;
18603 + }
18604
18605 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
18606 - &dma_handle);
18607 - if (!buffer)
18608 - return -ENOMEM;
18609 + &dma_handle);
18610 + if (!buffer) {
18611 + error = -ENOMEM;
18612 + goto out;
18613 + }
18614
18615 cfg.physAddr = dma_handle;
18616 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
18617 @@ -1095,289 +1427,852 @@ static int mptsas_get_linkerrors(struct
18618 if (error)
18619 goto out_free_consistent;
18620
18621 - mptsas_print_phy_pg1(ioc, buffer);
18622 -
18623 - phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
18624 - phy->running_disparity_error_count =
18625 - le32_to_cpu(buffer->RunningDisparityErrorCount);
18626 - phy->loss_of_dword_sync_count =
18627 - le32_to_cpu(buffer->LossDwordSynchCount);
18628 - phy->phy_reset_problem_count =
18629 - le32_to_cpu(buffer->PhyResetProblemCount);
18630 + /* save config data */
18631 + memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64));
18632 + enclosure->enclosure_logical_id = le64_to_cpu(le_identifier);
18633 + enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle);
18634 + enclosure->flags = le16_to_cpu(buffer->Flags);
18635 + enclosure->num_slot = le16_to_cpu(buffer->NumSlots);
18636 + enclosure->start_slot = le16_to_cpu(buffer->StartSlot);
18637 + enclosure->start_id = buffer->StartTargetID;
18638 + enclosure->start_channel = buffer->StartBus;
18639 + enclosure->sep_id = buffer->SEPTargetID;
18640 + enclosure->sep_channel = buffer->SEPBus;
18641
18642 out_free_consistent:
18643 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
18644 buffer, dma_handle);
18645 + out:
18646 return error;
18647 }
18648
18649 -static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
18650 - MPT_FRAME_HDR *reply)
18651 +/**
18652 + * mptsas_get_lun_number - returns the first entry in report_luns table
18653 + * @ioc: Pointer to MPT_ADAPTER structure
18654 + * @channel:
18655 + * @id:
18656 + * @lun:
18657 + *
18658 + */
18659 +static int
18660 +mptsas_get_lun_number(MPT_ADAPTER *ioc, u8 channel, u8 id, int *lun)
18661 {
18662 - ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD;
18663 - if (reply != NULL) {
18664 - ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID;
18665 - memcpy(ioc->sas_mgmt.reply, reply,
18666 - min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
18667 - }
18668 - complete(&ioc->sas_mgmt.done);
18669 - return 1;
18670 -}
18671 + INTERNAL_CMD *iocmd;
18672 + struct scsi_lun *lun_data;
18673 + dma_addr_t lun_data_dma;
18674 + u32 lun_data_len;
18675 + u8 *data;
18676 + MPT_SCSI_HOST *hd;
18677 + int rc;
18678 + u32 length, num_luns;
18679
18680 -static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
18681 -{
18682 - MPT_ADAPTER *ioc = phy_to_ioc(phy);
18683 - SasIoUnitControlRequest_t *req;
18684 - SasIoUnitControlReply_t *reply;
18685 - MPT_FRAME_HDR *mf;
18686 - MPIHeader_t *hdr;
18687 - unsigned long timeleft;
18688 - int error = -ERESTARTSYS;
18689 + iocmd = NULL;
18690 + hd = shost_priv(ioc->sh);
18691 + lun_data_len = (255 * sizeof(struct scsi_lun));
18692 + lun_data = pci_alloc_consistent(ioc->pcidev, lun_data_len,
18693 + &lun_data_dma);
18694 + if (!lun_data) {
18695 + printk(MYIOC_s_ERR_FMT "%s: pci_alloc_consistent(%d) FAILED!\n",
18696 + ioc->name, __FUNCTION__, lun_data_len);
18697 + rc = -ENOMEM;
18698 + goto out;
18699 + }
18700
18701 - /* FIXME: fusion doesn't allow non-local phy reset */
18702 - if (!scsi_is_sas_phy_local(phy))
18703 - return -EINVAL;
18704 + iocmd = kzalloc(sizeof(INTERNAL_CMD), GFP_KERNEL);
18705 + if (!iocmd) {
18706 + printk(MYIOC_s_ERR_FMT "%s: kzalloc(%zd) FAILED!\n",
18707 + ioc->name, __FUNCTION__, sizeof(INTERNAL_CMD));
18708 + rc = -ENOMEM;
18709 + goto out;
18710 + }
18711
18712 - /* not implemented for expanders */
18713 - if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
18714 - return -ENXIO;
18715 + /*
18716 + * Report Luns
18717 + */
18718 + iocmd->cmd = REPORT_LUNS;
18719 + iocmd->data_dma = lun_data_dma;
18720 + iocmd->data = (u8 *)lun_data;
18721 + iocmd->size = lun_data_len;
18722 + iocmd->channel = channel;
18723 + iocmd->id = id;
18724
18725 - if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
18726 + if ((rc = mptscsih_do_cmd(hd, iocmd)) < 0) {
18727 + printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
18728 + "report_luns failed due to rc=0x%x\n", ioc->name,
18729 + __FUNCTION__, channel, id, rc);
18730 goto out;
18731 + }
18732
18733 - mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
18734 - if (!mf) {
18735 - error = -ENOMEM;
18736 - goto out_unlock;
18737 + if (rc != MPT_SCANDV_GOOD) {
18738 + printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
18739 + "report_luns failed due to rc=0x%x\n", ioc->name,
18740 + __FUNCTION__, channel, id, rc);
18741 + rc = -rc;
18742 + goto out;
18743 }
18744
18745 - hdr = (MPIHeader_t *) mf;
18746 - req = (SasIoUnitControlRequest_t *)mf;
18747 - memset(req, 0, sizeof(SasIoUnitControlRequest_t));
18748 - req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
18749 - req->MsgContext = hdr->MsgContext;
18750 - req->Operation = hard_reset ?
18751 - MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
18752 - req->PhyNum = phy->identify.phy_identifier;
18753 + data = (u8 *)lun_data;
18754 + length = ((data[0] << 24) | (data[1] << 16) |
18755 + (data[2] << 8) | (data[3] << 0));
18756
18757 - mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
18758 + num_luns = (length / sizeof(struct scsi_lun));
18759 + if (!num_luns)
18760 + goto out;
18761 + /* return 1st lun in the list */
18762 + *lun = scsilun_to_int(&lun_data[1]);
18763
18764 - timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done,
18765 - 10 * HZ);
18766 - if (!timeleft) {
18767 - /* On timeout reset the board */
18768 - mpt_free_msg_frame(ioc, mf);
18769 - mpt_HardResetHandler(ioc, CAN_SLEEP);
18770 - error = -ETIMEDOUT;
18771 - goto out_unlock;
18772 +#if 0
18773 + /* some debugging, left commented out */
18774 + {
18775 + struct scsi_lun *lunp;
18776 + for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++)
18777 + printk("%x\n", scsilun_to_int(lunp));
18778 }
18779 +#endif
18780
18781 - /* a reply frame is expected */
18782 - if ((ioc->sas_mgmt.status &
18783 - MPT_IOCTL_STATUS_RF_VALID) == 0) {
18784 - error = -ENXIO;
18785 - goto out_unlock;
18786 - }
18787 + out:
18788 + if (lun_data)
18789 + pci_free_consistent(ioc->pcidev, lun_data_len, lun_data,
18790 + lun_data_dma);
18791 + kfree(iocmd);
18792 + return rc;
18793 +}
18794
18795 - /* process the completed Reply Message Frame */
18796 - reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
18797 - if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
18798 - printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
18799 - ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo);
18800 - error = -ENXIO;
18801 - goto out_unlock;
18802 +/**
18803 + * enum device_state -
18804 + * @DEVICE_RETRY: need to retry the TUR
18805 + * @DEVICE_ERROR: TUR return error, don't add device
18806 + * @DEVICE_READY: device can be added
18807 + *
18808 + */
18809 +enum device_state{
18810 + DEVICE_RETRY,
18811 + DEVICE_ERROR,
18812 + DEVICE_READY,
18813 +};
18814 +
18815 +/**
18816 + * mptsas_test_unit_ready -
18817 + * @ioc: Pointer to MPT_ADAPTER structure
18818 + * @channel:
18819 + * @id:
18820 + * @count: retry count
18821 + *
18822 + */
18823 +enum device_state
18824 +mptsas_test_unit_ready(MPT_ADAPTER *ioc, u8 channel, u8 id, u16 count)
18825 +{
18826 + INTERNAL_CMD *iocmd;
18827 + MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
18828 + enum device_state state;
18829 + int rc;
18830 + u8 skey, asc, ascq;
18831 + u8 retry_ua;
18832 +
18833 + if (count >= mpt_cmd_retry_count)
18834 + return DEVICE_ERROR;
18835 +
18836 + retry_ua = 0;
18837 + iocmd = kzalloc(sizeof(INTERNAL_CMD), GFP_KERNEL);
18838 + if (!iocmd) {
18839 + printk(MYIOC_s_ERR_FMT "%s: kzalloc(%zd) FAILED!\n",
18840 + __FUNCTION__, ioc->name, sizeof(INTERNAL_CMD));
18841 + return DEVICE_ERROR;
18842 + }
18843 +
18844 + state = DEVICE_ERROR;
18845 + iocmd->cmd = TEST_UNIT_READY;
18846 + iocmd->data_dma = -1;
18847 + iocmd->data = NULL;
18848 +
18849 + if (mptscsih_is_phys_disk(ioc, channel, id)) {
18850 + iocmd->flags |= MPT_ICFLAG_PHYS_DISK;
18851 + iocmd->physDiskNum = mptscsih_raid_id_to_num(ioc, channel, id);
18852 + iocmd->id = id;
18853 + }
18854 + iocmd->channel = channel;
18855 + iocmd->id = id;
18856 +
18857 + retry:
18858 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_channel=%d "
18859 + "fw_id=%d retry=%d\n", ioc->name, __FUNCTION__, channel, id, count));
18860 + rc = mptscsih_do_cmd(hd, iocmd);
18861 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rc=0x%02x\n",
18862 + ioc->name, __FUNCTION__, rc));
18863 + if (rc < 0) {
18864 + printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
18865 + "tur failed due to timeout\n", ioc->name,
18866 + __FUNCTION__, channel, id);
18867 + goto tur_done;
18868 + }
18869 +
18870 + switch(rc) {
18871 + case MPT_SCANDV_GOOD:
18872 + state = DEVICE_READY;
18873 + goto tur_done;
18874 + case MPT_SCANDV_BUSY:
18875 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: "
18876 + "fw_channel=%d fw_id=%d : device busy\n",
18877 + ioc->name, __FUNCTION__, channel, id));
18878 + state = DEVICE_RETRY;
18879 + break;
18880 + case MPT_SCANDV_DID_RESET:
18881 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: "
18882 + "fw_channel=%d fw_id=%d : did reset\n",
18883 + ioc->name, __FUNCTION__, channel, id));
18884 + state = DEVICE_RETRY;
18885 + break;
18886 + case MPT_SCANDV_SENSE:
18887 + skey = ioc->internal_cmds.sense[2] & 0x0F;
18888 + asc = ioc->internal_cmds.sense[12];
18889 + ascq = ioc->internal_cmds.sense[13];
18890 +
18891 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: "
18892 + "fw_channel=%d fw_id=%d : [sense_key,asc,"
18893 + "ascq]: [0x%02x,0x%02x,0x%02x]\n", ioc->name,
18894 + __FUNCTION__, channel, id, skey, asc, ascq));
18895 +
18896 + if (skey == UNIT_ATTENTION) {
18897 + if (!retry_ua) {
18898 + retry_ua++;
18899 + goto retry;
18900 + }
18901 + } else if (skey == NOT_READY) {
18902 + /*
18903 + * medium isn't present
18904 + */
18905 + if (asc == 0x3a) {
18906 + state = DEVICE_READY;
18907 + goto tur_done;
18908 + }
18909 + /*
18910 + * LU becoming ready, or
18911 + * LU hasn't self-configured yet
18912 + */
18913 + if ((asc == 0x04 && ascq == 0x01) ||
18914 + (asc == 0x04 && ascq == 0x11) ||
18915 + asc == 0x3e) {
18916 + state = DEVICE_RETRY;
18917 + break;
18918 + }
18919 + } else if (skey == ILLEGAL_REQUEST) {
18920 + /* try sending a tur to a non-zero lun number */
18921 + if (!iocmd->lun && !mptsas_get_lun_number(ioc,
18922 + channel, id, &iocmd->lun) && iocmd->lun)
18923 + goto retry;
18924 + }
18925 + printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d : "
18926 + "tur failed due to [sense_key,asc,ascq]: "
18927 + "[0x%02x,0x%02x,0x%02x]\n", ioc->name,
18928 + __FUNCTION__, channel, id, skey, asc, ascq);
18929 + goto tur_done;
18930 + case MPT_SCANDV_SELECTION_TIMEOUT:
18931 + printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
18932 + "tur failed due to no device\n", ioc->name,
18933 + __FUNCTION__, channel,
18934 + id);
18935 + goto tur_done;
18936 + case MPT_SCANDV_SOME_ERROR:
18937 + printk(MYIOC_s_ERR_FMT "%s: fw_channel=%d fw_id=%d: "
18938 + "tur failed due to some error\n", ioc->name,
18939 + __FUNCTION__,
18940 + channel, id);
18941 + goto tur_done;
18942 + default:
18943 + printk(MYIOC_s_ERR_FMT
18944 + "%s: fw_channel=%d fw_id=%d: tur failed due to "
18945 + "unknown rc=0x%02x\n", ioc->name, __FUNCTION__,
18946 + channel, id, rc );
18947 + goto tur_done;
18948 + }
18949 + tur_done:
18950 + kfree(iocmd);
18951 + return state;
18952 +}
18953 +
18954 +/**
18955 + * mptsas_issue_tlr - Enabling Transport Layer Retries
18956 + * @hd:
18957 + * @sdev:
18958 + *
18959 + **/
18960 +static void
18961 +mptsas_issue_tlr(MPT_SCSI_HOST *hd, struct scsi_device *sdev)
18962 +{
18963 + INTERNAL_CMD *iocmd;
18964 + VirtDevice *vdevice = sdev->hostdata;
18965 + u8 retries;
18966 + u8 rc;
18967 + MPT_ADAPTER *ioc = hd->ioc;
18968 +
18969 + if ( sdev->inquiry[8] == 'H' &&
18970 + sdev->inquiry[9] == 'P' &&
18971 + sdev->inquiry[10] == ' ' &&
18972 + sdev->inquiry[11] == ' ' &&
18973 + sdev->inquiry[12] == ' ' &&
18974 + sdev->inquiry[13] == ' ' &&
18975 + sdev->inquiry[14] == ' ' &&
18976 + sdev->inquiry[15] == ' ' ) {
18977 +
18978 + iocmd = kzalloc(sizeof(INTERNAL_CMD), GFP_KERNEL);
18979 + if (!iocmd) {
18980 + printk(MYIOC_s_ERR_FMT "%s: kzalloc(%zd) FAILED!\n",
18981 + __FUNCTION__, ioc->name, sizeof(INTERNAL_CMD));
18982 + return;
18983 + }
18984 + iocmd->id = vdevice->vtarget->id;
18985 + iocmd->channel = vdevice->vtarget->channel;
18986 + iocmd->lun = vdevice->lun;
18987 + iocmd->physDiskNum = -1;
18988 + iocmd->cmd = TRANSPORT_LAYER_RETRIES;
18989 + iocmd->data_dma = -1;
18990 + for (retries = 0, rc = -1; retries < 3; retries++) {
18991 + rc = mptscsih_do_cmd(hd, iocmd);
18992 + if (!rc)
18993 + break;
18994 + }
18995 + if (rc != 0)
18996 + printk(MYIOC_s_DEBUG_FMT "unable to enable TLR on"
18997 + " fw_channel %d, fw_id %d, lun=%d\n",
18998 + ioc->name, vdevice->vtarget->channel,
18999 + vdevice->vtarget->id, sdev->lun);
19000 + kfree(iocmd);
19001 }
19002 +}
19003
19004 - error = 0;
19005 +/**
19006 + * mptsas_slave_configure -
19007 + * @sdev:
19008 + *
19009 + **/
19010 +static int
19011 +mptsas_slave_configure(struct scsi_device *sdev)
19012 +{
19013 + struct Scsi_Host *host = sdev->host;
19014 + MPT_SCSI_HOST *hd = shost_priv(host);
19015 + MPT_ADAPTER *ioc = hd->ioc;
19016 + VirtDevice *vdevice = sdev->hostdata;
19017 +
19018 +
19019 + if (vdevice->vtarget->deleted) {
19020 + sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n");
19021 + vdevice->vtarget->deleted = 0;
19022 + }
19023
19024 - out_unlock:
19025 - mutex_unlock(&ioc->sas_mgmt.mutex);
19026 + /*
19027 + * RAID volumes placed beyond the last expected port.
19028 + * Ignore sending sas mode pages in that case..
19029 + */
19030 + if (sdev->channel == MPTSAS_RAID_CHANNEL) {
19031 + mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev));
19032 + goto out;
19033 + }
19034 +
19035 + sas_read_port_mode_page(sdev);
19036 +
19037 + mptsas_add_device_component_starget(ioc, scsi_target(sdev));
19038 +
19039 + if (sdev->type == TYPE_TAPE &&
19040 + (ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_TLR ))
19041 + mptsas_issue_tlr(hd, sdev);
19042 out:
19043 - return error;
19044 +
19045 + return mptscsih_slave_configure(sdev);
19046 }
19047
19048 +/**
19049 + * mptsas_target_alloc -
19050 + * @starget:
19051 + *
19052 + **/
19053 static int
19054 -mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
19055 +mptsas_target_alloc(struct scsi_target *starget)
19056 {
19057 - MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
19058 - int i, error;
19059 - struct mptsas_portinfo *p;
19060 - struct mptsas_enclosure enclosure_info;
19061 - u64 enclosure_handle;
19062 + struct Scsi_Host *host = dev_to_shost(&starget->dev);
19063 + MPT_SCSI_HOST *hd = shost_priv(host);
19064 + VirtTarget *vtarget;
19065 + u8 id, channel;
19066 + struct sas_rphy *rphy;
19067 + struct mptsas_portinfo *p;
19068 + int i;
19069 + MPT_ADAPTER *ioc = hd->ioc;
19070 +
19071 + vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
19072 + if (!vtarget)
19073 + return -ENOMEM;
19074 +
19075 + vtarget->starget = starget;
19076 + vtarget->ioc_id = ioc->id;
19077 + vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
19078 + id = starget->id;
19079 + channel = 0;
19080 +
19081 + /*
19082 + * RAID volumes placed beyond the last expected port.
19083 + */
19084 + if (starget->channel == MPTSAS_RAID_CHANNEL) {
19085 + if (!ioc->raid_data.pIocPg2) {
19086 + kfree(vtarget);
19087 + return -ENXIO;
19088 + }
19089 + for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
19090 + if (id == ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID)
19091 + channel = ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus;
19092 + vtarget->raidVolume = 1;
19093 + goto out;
19094 + }
19095
19096 + rphy = dev_to_rphy(starget->dev.parent);
19097 mutex_lock(&ioc->sas_topology_mutex);
19098 list_for_each_entry(p, &ioc->sas_topology, list) {
19099 for (i = 0; i < p->num_phys; i++) {
19100 - if (p->phy_info[i].attached.sas_address ==
19101 - rphy->identify.sas_address) {
19102 - enclosure_handle = p->phy_info[i].
19103 - attached.handle_enclosure;
19104 - goto found_info;
19105 + if (p->phy_info[i].attached.sas_address !=
19106 + rphy->identify.sas_address)
19107 + continue;
19108 + id = p->phy_info[i].attached.id;
19109 + channel = p->phy_info[i].attached.channel;
19110 + mptsas_set_starget(&p->phy_info[i], starget);
19111 +
19112 + starget_printk(KERN_INFO, starget, MYIOC_s_FMT
19113 + "add device: fw_channel %d, fw_id %d, phy %d, sas_addr 0x%llx\n",
19114 + ioc->name, p->phy_info[i].attached.channel,
19115 + p->phy_info[i].attached.id, p->phy_info[i].attached.phy_id,
19116 + (unsigned long long)p->phy_info[i].attached.sas_address);
19117 +
19118 + /*
19119 + * Exposing hidden raid components
19120 + */
19121 + if (mptscsih_is_phys_disk(ioc, channel, id)) {
19122 + id = mptscsih_raid_id_to_num(ioc,
19123 + channel, id);
19124 + vtarget->tflags |=
19125 + MPT_TARGET_FLAGS_RAID_COMPONENT;
19126 + p->phy_info[i].attached.phys_disk_num = id;
19127 }
19128 + mutex_unlock(&ioc->sas_topology_mutex);
19129 + goto out;
19130 }
19131 }
19132 mutex_unlock(&ioc->sas_topology_mutex);
19133 +
19134 + kfree(vtarget);
19135 return -ENXIO;
19136
19137 - found_info:
19138 - mutex_unlock(&ioc->sas_topology_mutex);
19139 - memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
19140 - error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
19141 - (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
19142 - MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle);
19143 - if (!error)
19144 - *identifier = enclosure_info.enclosure_logical_id;
19145 - return error;
19146 + out:
19147 + vtarget->id = id;
19148 + vtarget->channel = channel;
19149 + starget->hostdata = vtarget;
19150 + return 0;
19151 }
19152
19153 -static int
19154 -mptsas_get_bay_identifier(struct sas_rphy *rphy)
19155 +/**
19156 + * mptsas_target_destroy -
19157 + * @starget:
19158 + *
19159 + **/
19160 +static void
19161 +mptsas_target_destroy(struct scsi_target *starget)
19162 {
19163 - MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
19164 - struct mptsas_portinfo *p;
19165 - int i, rc;
19166 + struct Scsi_Host *host = dev_to_shost(&starget->dev);
19167 + MPT_SCSI_HOST *hd = shost_priv(host);
19168 + struct sas_rphy *rphy;
19169 + struct mptsas_portinfo *p;
19170 + int i;
19171 + MPT_ADAPTER *ioc = hd->ioc;
19172
19173 - mutex_lock(&ioc->sas_topology_mutex);
19174 + if (!starget->hostdata)
19175 + return;
19176 +
19177 + mptsas_del_device_component_by_os(ioc, starget->channel,
19178 + starget->id);
19179 +
19180 + if (starget->channel == MPTSAS_RAID_CHANNEL)
19181 + goto out;
19182 +
19183 + rphy = dev_to_rphy(starget->dev.parent);
19184 list_for_each_entry(p, &ioc->sas_topology, list) {
19185 for (i = 0; i < p->num_phys; i++) {
19186 - if (p->phy_info[i].attached.sas_address ==
19187 - rphy->identify.sas_address) {
19188 - rc = p->phy_info[i].attached.slot;
19189 - goto out;
19190 - }
19191 + if (p->phy_info[i].attached.sas_address !=
19192 + rphy->identify.sas_address)
19193 + continue;
19194 +
19195 + starget_printk(KERN_INFO, starget, MYIOC_s_FMT
19196 + "delete device: fw_channel %d, fw_id %d, phy %d, "
19197 + "sas_addr 0x%llx\n", ioc->name,
19198 + p->phy_info[i].attached.channel,
19199 + p->phy_info[i].attached.id,
19200 + p->phy_info[i].attached.phy_id, (unsigned long long)
19201 + p->phy_info[i].attached.sas_address);
19202 +
19203 + mptsas_port_delete(ioc, p->phy_info[i].port_details);
19204 }
19205 }
19206 - rc = -ENXIO;
19207 +
19208 out:
19209 - mutex_unlock(&ioc->sas_topology_mutex);
19210 - return rc;
19211 + kfree(starget->hostdata);
19212 + starget->hostdata = NULL;
19213 }
19214
19215 -static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
19216 - struct request *req)
19217 +/**
19218 + * mptsas_slave_alloc -
19219 + * @sdev:
19220 + *
19221 + **/
19222 +static int
19223 +mptsas_slave_alloc(struct scsi_device *sdev)
19224 {
19225 - MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc;
19226 - MPT_FRAME_HDR *mf;
19227 - SmpPassthroughRequest_t *smpreq;
19228 - struct request *rsp = req->next_rq;
19229 - int ret;
19230 - int flagsLength;
19231 - unsigned long timeleft;
19232 - char *psge;
19233 - dma_addr_t dma_addr_in = 0;
19234 - dma_addr_t dma_addr_out = 0;
19235 - u64 sas_address = 0;
19236 -
19237 - if (!rsp) {
19238 - printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n",
19239 - ioc->name, __func__);
19240 - return -EINVAL;
19241 - }
19242 + struct Scsi_Host *host = sdev->host;
19243 + MPT_SCSI_HOST *hd = shost_priv(host);
19244 + struct sas_rphy *rphy;
19245 + struct mptsas_portinfo *p;
19246 + VirtDevice *vdevice;
19247 + struct scsi_target *starget;
19248 + int i;
19249 + MPT_ADAPTER *ioc = hd->ioc;
19250
19251 - /* do we need to support multiple segments? */
19252 - if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
19253 - printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
19254 - ioc->name, __func__, req->bio->bi_vcnt, req->data_len,
19255 - rsp->bio->bi_vcnt, rsp->data_len);
19256 - return -EINVAL;
19257 + vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
19258 + if (!vdevice) {
19259 + printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n",
19260 + ioc->name, sizeof(VirtDevice));
19261 + return -ENOMEM;
19262 }
19263 + starget = scsi_target(sdev);
19264 + vdevice->vtarget = starget->hostdata;
19265
19266 - ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
19267 - if (ret)
19268 + /*
19269 + * RAID volumes placed beyond the last expected port.
19270 + */
19271 + if (sdev->channel == MPTSAS_RAID_CHANNEL)
19272 goto out;
19273
19274 - mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
19275 - if (!mf) {
19276 - ret = -ENOMEM;
19277 - goto out_unlock;
19278 + rphy = dev_to_rphy(sdev->sdev_target->dev.parent);
19279 + mutex_lock(&ioc->sas_topology_mutex);
19280 + list_for_each_entry(p, &ioc->sas_topology, list) {
19281 + for (i = 0; i < p->num_phys; i++) {
19282 + if (p->phy_info[i].attached.sas_address !=
19283 + rphy->identify.sas_address)
19284 + continue;
19285 + vdevice->lun = sdev->lun;
19286 + /*
19287 + * Exposing hidden raid components
19288 + */
19289 + if (mptscsih_is_phys_disk(ioc,
19290 + p->phy_info[i].attached.channel,
19291 + p->phy_info[i].attached.id))
19292 + sdev->no_uld_attach = 1;
19293 + mutex_unlock(&ioc->sas_topology_mutex);
19294 + goto out;
19295 + }
19296 }
19297 + mutex_unlock(&ioc->sas_topology_mutex);
19298
19299 - smpreq = (SmpPassthroughRequest_t *)mf;
19300 - memset(smpreq, 0, sizeof(*smpreq));
19301 + kfree(vdevice);
19302 + return -ENXIO;
19303
19304 - smpreq->RequestDataLength = cpu_to_le16(req->data_len - 4);
19305 - smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
19306 + out:
19307 + vdevice->vtarget->num_luns++;
19308 + sdev->hostdata = vdevice;
19309 + return 0;
19310 +}
19311
19312 - if (rphy)
19313 - sas_address = rphy->identify.sas_address;
19314 - else {
19315 - struct mptsas_portinfo *port_info;
19316 +/**
19317 + * mptsas_qcmd -
19318 + * @SCpnt:
19319 + * @done:
19320 + *
19321 + **/
19322 +static int
19323 +mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
19324 +{
19325 + MPT_SCSI_HOST *hd;
19326 + MPT_ADAPTER *ioc;
19327 + VirtDevice *vdevice = SCpnt->device->hostdata;
19328
19329 - mutex_lock(&ioc->sas_topology_mutex);
19330 - port_info = mptsas_get_hba_portinfo(ioc);
19331 - if (port_info && port_info->phy_info)
19332 - sas_address =
19333 - port_info->phy_info[0].phy->identify.sas_address;
19334 - mutex_unlock(&ioc->sas_topology_mutex);
19335 + if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) {
19336 + SCpnt->result = DID_NO_CONNECT << 16;
19337 + done(SCpnt);
19338 + return 0;
19339 }
19340
19341 - *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
19342 + hd = shost_priv(SCpnt->device->host);
19343 + ioc = hd->ioc;
19344
19345 - psge = (char *)
19346 - (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
19347 + if (ioc->sas_discovery_quiesce_io)
19348 + return SCSI_MLQUEUE_HOST_BUSY;
19349
19350 - /* request */
19351 - flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
19352 - MPI_SGE_FLAGS_END_OF_BUFFER |
19353 - MPI_SGE_FLAGS_DIRECTION |
19354 - mpt_addr_size()) << MPI_SGE_FLAGS_SHIFT;
19355 - flagsLength |= (req->data_len - 4);
19356 -
19357 - dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
19358 - req->data_len, PCI_DMA_BIDIRECTIONAL);
19359 - if (!dma_addr_out)
19360 - goto put_mf;
19361 - mpt_add_sge(psge, flagsLength, dma_addr_out);
19362 - psge += (sizeof(u32) + sizeof(dma_addr_t));
19363 -
19364 - /* response */
19365 - flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
19366 - flagsLength |= rsp->data_len + 4;
19367 - dma_addr_in = pci_map_single(ioc->pcidev, bio_data(rsp->bio),
19368 - rsp->data_len, PCI_DMA_BIDIRECTIONAL);
19369 - if (!dma_addr_in)
19370 - goto unmap;
19371 - mpt_add_sge(psge, flagsLength, dma_addr_in);
19372 +// scsi_print_command(SCpnt);
19373 + return mptscsih_qcmd(SCpnt,done);
19374 +}
19375
19376 - mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
19377
19378 - timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
19379 - if (!timeleft) {
19380 - printk(MYIOC_s_ERR_FMT "%s: smp timeout!\n", ioc->name, __func__);
19381 - /* On timeout reset the board */
19382 - mpt_HardResetHandler(ioc, CAN_SLEEP);
19383 - ret = -ETIMEDOUT;
19384 - goto unmap;
19385 - }
19386 - mf = NULL;
19387 -
19388 - if (ioc->sas_mgmt.status & MPT_IOCTL_STATUS_RF_VALID) {
19389 - SmpPassthroughReply_t *smprep;
19390 -
19391 - smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
19392 - memcpy(req->sense, smprep, sizeof(*smprep));
19393 - req->sense_len = sizeof(*smprep);
19394 - req->data_len = 0;
19395 - rsp->data_len -= smprep->ResponseDataLength;
19396 - } else {
19397 - printk(MYIOC_s_ERR_FMT "%s: smp passthru reply failed to be returned\n",
19398 - ioc->name, __func__);
19399 - ret = -ENXIO;
19400 - }
19401 -unmap:
19402 - if (dma_addr_out)
19403 - pci_unmap_single(ioc->pcidev, dma_addr_out, req->data_len,
19404 - PCI_DMA_BIDIRECTIONAL);
19405 - if (dma_addr_in)
19406 - pci_unmap_single(ioc->pcidev, dma_addr_in, rsp->data_len,
19407 - PCI_DMA_BIDIRECTIONAL);
19408 -put_mf:
19409 - if (mf)
19410 +static struct scsi_host_template mptsas_driver_template = {
19411 + .module = THIS_MODULE,
19412 + .proc_name = "mptsas",
19413 + .proc_info = mptscsih_proc_info,
19414 + .name = "MPT SPI Host",
19415 + .info = mptscsih_info,
19416 + .queuecommand = mptsas_qcmd,
19417 + .target_alloc = mptsas_target_alloc,
19418 + .slave_alloc = mptsas_slave_alloc,
19419 + .slave_configure = mptsas_slave_configure,
19420 + .target_destroy = mptsas_target_destroy,
19421 + .slave_destroy = mptscsih_slave_destroy,
19422 + .change_queue_depth = mptscsih_change_queue_depth,
19423 + .eh_abort_handler = mptscsih_abort,
19424 + .eh_device_reset_handler = mptscsih_dev_reset,
19425 + .eh_bus_reset_handler = mptscsih_bus_reset,
19426 + .eh_host_reset_handler = mptscsih_host_reset,
19427 + .bios_param = mptscsih_bios_param,
19428 + .can_queue = MPT_FC_CAN_QUEUE,
19429 + .this_id = -1,
19430 + .sg_tablesize = MPT_SCSI_SG_DEPTH,
19431 + .max_sectors = 8192,
19432 + .cmd_per_lun = 7,
19433 + .use_clustering = ENABLE_CLUSTERING,
19434 + .shost_attrs = mptscsih_host_attrs,
19435 +};
19436 +
19437 +/**
19438 + * mptsas_get_linkerrors -
19439 + * @phy:
19440 + *
19441 + **/
19442 +static int mptsas_get_linkerrors(struct sas_phy *phy)
19443 +{
19444 + MPT_ADAPTER *ioc = phy_to_ioc(phy);
19445 + ConfigExtendedPageHeader_t hdr;
19446 + CONFIGPARMS cfg;
19447 + SasPhyPage1_t *buffer;
19448 + dma_addr_t dma_handle;
19449 + int error;
19450 +
19451 + /* FIXME: only have link errors on local phys */
19452 + if (!scsi_is_sas_phy_local(phy))
19453 + return -EINVAL;
19454 +
19455 + hdr.PageVersion = MPI_SASPHY1_PAGEVERSION;
19456 + hdr.ExtPageLength = 0;
19457 + hdr.PageNumber = 1 /* page number 1*/;
19458 + hdr.Reserved1 = 0;
19459 + hdr.Reserved2 = 0;
19460 + hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
19461 + hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY;
19462 +
19463 + cfg.cfghdr.ehdr = &hdr;
19464 + cfg.physAddr = -1;
19465 + cfg.pageAddr = phy->identify.phy_identifier;
19466 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19467 + cfg.dir = 0; /* read */
19468 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19469 +
19470 + error = mpt_config(ioc, &cfg);
19471 + if (error)
19472 + return error;
19473 + if (!hdr.ExtPageLength)
19474 + return -ENXIO;
19475 +
19476 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
19477 + &dma_handle);
19478 + if (!buffer)
19479 + return -ENOMEM;
19480 +
19481 + cfg.physAddr = dma_handle;
19482 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
19483 +
19484 + error = mpt_config(ioc, &cfg);
19485 + if (error)
19486 + goto out_free_consistent;
19487 +
19488 + mptsas_print_phy_pg1(ioc, buffer);
19489 +
19490 + phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount);
19491 + phy->running_disparity_error_count =
19492 + le32_to_cpu(buffer->RunningDisparityErrorCount);
19493 + phy->loss_of_dword_sync_count =
19494 + le32_to_cpu(buffer->LossDwordSynchCount);
19495 + phy->phy_reset_problem_count =
19496 + le32_to_cpu(buffer->PhyResetProblemCount);
19497 +
19498 + out_free_consistent:
19499 + pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
19500 + buffer, dma_handle);
19501 + return error;
19502 +}
19503 +
19504 +/**
19505 + * mptsas_mgmt_done -
19506 + * @ioc: Pointer to MPT_ADAPTER structure
19507 + * @req:
19508 + * @reply:
19509 + *
19510 + **/
19511 +static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req,
19512 + MPT_FRAME_HDR *reply)
19513 +{
19514 + ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
19515 + if (reply != NULL) {
19516 + ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID;
19517 + memcpy(ioc->sas_mgmt.reply, reply,
19518 + min(ioc->reply_sz, 4 * reply->u.reply.MsgLength));
19519 + }
19520 +
19521 + if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) {
19522 + ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING;
19523 + complete(&ioc->sas_mgmt.done);
19524 + return 1;
19525 + }
19526 + return 0;
19527 +}
19528 +
19529 +/**
19530 + * mptsas_phy_reset -
19531 + * @phy:
19532 + * @hard_reset:
19533 + *
19534 + **/
19535 +static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset)
19536 +{
19537 + MPT_ADAPTER *ioc = phy_to_ioc(phy);
19538 + SasIoUnitControlRequest_t *req;
19539 + SasIoUnitControlReply_t *reply;
19540 + MPT_FRAME_HDR *mf;
19541 + MPIHeader_t *hdr;
19542 + unsigned long timeleft;
19543 + int error = -ERESTARTSYS;
19544 +
19545 + /* FIXME: fusion doesn't allow non-local phy reset */
19546 + if (!scsi_is_sas_phy_local(phy))
19547 + return -EINVAL;
19548 +
19549 + /* not implemented for expanders */
19550 + if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP)
19551 + return -ENXIO;
19552 +
19553 + if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex))
19554 + goto out;
19555 +
19556 + mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
19557 + if (!mf) {
19558 + error = -ENOMEM;
19559 + goto out_unlock;
19560 + }
19561 +
19562 + hdr = (MPIHeader_t *) mf;
19563 + req = (SasIoUnitControlRequest_t *)mf;
19564 + memset(req, 0, sizeof(SasIoUnitControlRequest_t));
19565 + req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
19566 + req->MsgContext = hdr->MsgContext;
19567 + req->Operation = hard_reset ?
19568 + MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET;
19569 + req->PhyNum = phy->identify.phy_identifier;
19570 +
19571 + INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
19572 + mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
19573 + timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10*HZ);
19574 + if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
19575 + error = -ETIME;
19576 mpt_free_msg_frame(ioc, mf);
19577 -out_unlock:
19578 + if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
19579 + goto out;
19580 + if (!timeleft) {
19581 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
19582 + mpt_HardResetHandler(ioc, CAN_SLEEP);
19583 + }
19584 + goto out_unlock;
19585 + }
19586 +
19587 + /* a reply frame is expected */
19588 + if ((ioc->sas_mgmt.status &
19589 + MPT_MGMT_STATUS_RF_VALID) == 0) {
19590 + error = -ENXIO;
19591 + goto out_unlock;
19592 + }
19593 +
19594 + /* process the completed Reply Message Frame */
19595 + reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply;
19596 + if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) {
19597 + printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
19598 + ioc->name, __FUNCTION__, reply->IOCStatus, reply->IOCLogInfo);
19599 + error = -ENXIO;
19600 + goto out_unlock;
19601 + }
19602 +
19603 + error = 0;
19604 +
19605 + out_unlock:
19606 + CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
19607 mutex_unlock(&ioc->sas_mgmt.mutex);
19608 -out:
19609 - return ret;
19610 + out:
19611 + return error;
19612 +}
19613 +
19614 +/**
19615 + * mptsas_get_enclosure_identifier -
19616 + * @rphy:
19617 + * @identifier:
19618 + *
19619 + **/
19620 +static int
19621 +mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
19622 +{
19623 + MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
19624 + int i, error;
19625 + struct mptsas_portinfo *p;
19626 + struct mptsas_enclosure enclosure_info;
19627 + u64 enclosure_handle;
19628 +
19629 + mutex_lock(&ioc->sas_topology_mutex);
19630 + list_for_each_entry(p, &ioc->sas_topology, list) {
19631 + for (i = 0; i < p->num_phys; i++) {
19632 + if (p->phy_info[i].attached.sas_address ==
19633 + rphy->identify.sas_address) {
19634 + enclosure_handle = p->phy_info[i].
19635 + attached.handle_enclosure;
19636 + goto found_info;
19637 + }
19638 + }
19639 + }
19640 + mutex_unlock(&ioc->sas_topology_mutex);
19641 + return -ENXIO;
19642 +
19643 + found_info:
19644 + mutex_unlock(&ioc->sas_topology_mutex);
19645 + memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure));
19646 + error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info,
19647 + (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE <<
19648 + MPI_SAS_ENCLOS_PGAD_FORM_SHIFT),
19649 + enclosure_handle);
19650 + if (!error)
19651 + *identifier = enclosure_info.enclosure_logical_id;
19652 + return error;
19653 +}
19654 +
19655 +/**
19656 + * mptsas_get_bay_identifier -
19657 + * @rphy:
19658 + *
19659 + **/
19660 +static int
19661 +mptsas_get_bay_identifier(struct sas_rphy *rphy)
19662 +{
19663 + MPT_ADAPTER *ioc = rphy_to_ioc(rphy);
19664 + struct mptsas_portinfo *p;
19665 + int i, rc;
19666 +
19667 + mutex_lock(&ioc->sas_topology_mutex);
19668 + list_for_each_entry(p, &ioc->sas_topology, list) {
19669 + for (i = 0; i < p->num_phys; i++) {
19670 + if (p->phy_info[i].attached.sas_address ==
19671 + rphy->identify.sas_address) {
19672 + rc = p->phy_info[i].attached.slot;
19673 + goto out;
19674 + }
19675 + }
19676 + }
19677 + rc = -ENXIO;
19678 + out:
19679 + mutex_unlock(&ioc->sas_topology_mutex);
19680 + return rc;
19681 }
19682
19683 static struct sas_function_template mptsas_transport_functions = {
19684 @@ -1385,11 +2280,16 @@ static struct sas_function_template mpts
19685 .get_enclosure_identifier = mptsas_get_enclosure_identifier,
19686 .get_bay_identifier = mptsas_get_bay_identifier,
19687 .phy_reset = mptsas_phy_reset,
19688 - .smp_handler = mptsas_smp_handler,
19689 };
19690
19691 static struct scsi_transport_template *mptsas_transport_template;
19692
19693 +/**
19694 + * mptsas_sas_io_unit_pg0 -
19695 + * @ioc: Pointer to MPT_ADAPTER structure
19696 + * @port_info:
19697 + *
19698 + **/
19699 static int
19700 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
19701 {
19702 @@ -1412,7 +2312,7 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
19703 cfg.pageAddr = 0;
19704 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19705 cfg.dir = 0; /* read */
19706 - cfg.timeout = 10;
19707 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19708
19709 error = mpt_config(ioc, &cfg);
19710 if (error)
19711 @@ -1438,7 +2338,7 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
19712
19713 port_info->num_phys = buffer->NumPhys;
19714 port_info->phy_info = kcalloc(port_info->num_phys,
19715 - sizeof(*port_info->phy_info),GFP_KERNEL);
19716 + sizeof(struct mptsas_phyinfo),GFP_KERNEL);
19717 if (!port_info->phy_info) {
19718 error = -ENOMEM;
19719 goto out_free_consistent;
19720 @@ -1459,6 +2359,8 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
19721 port_info->phy_info[i].portinfo = port_info;
19722 port_info->phy_info[i].handle =
19723 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle);
19724 + port_info->phy_info[i].port_flags =
19725 + buffer->PhyData[i].PortFlags;
19726 }
19727
19728 out_free_consistent:
19729 @@ -1468,6 +2370,11 @@ mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc,
19730 return error;
19731 }
19732
19733 +/**
19734 + * mptsas_sas_io_unit_pg1 -
19735 + * @ioc: Pointer to MPT_ADAPTER structure
19736 + *
19737 + **/
19738 static int
19739 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
19740 {
19741 @@ -1483,11 +2390,11 @@ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
19742
19743 cfg.cfghdr.ehdr = &hdr;
19744 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19745 - cfg.timeout = 10;
19746 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
19747 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
19748 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION;
19749 cfg.cfghdr.ehdr->PageNumber = 1;
19750 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19751
19752 error = mpt_config(ioc, &cfg);
19753 if (error)
19754 @@ -1525,6 +2432,14 @@ mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc)
19755 return error;
19756 }
19757
19758 +/**
19759 + * mptsas_sas_phy_pg0 -
19760 + * @ioc: Pointer to MPT_ADAPTER structure
19761 + * @phy_info:
19762 + * @form:
19763 + * @form_specific:
19764 + *
19765 + **/
19766 static int
19767 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
19768 u32 form, u32 form_specific)
19769 @@ -1545,12 +2460,12 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, str
19770
19771 cfg.cfghdr.ehdr = &hdr;
19772 cfg.dir = 0; /* read */
19773 - cfg.timeout = 10;
19774
19775 /* Get Phy Pg 0 for each Phy. */
19776 cfg.physAddr = -1;
19777 cfg.pageAddr = form + form_specific;
19778 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19779 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19780
19781 error = mpt_config(ioc, &cfg);
19782 if (error)
19783 @@ -1581,6 +2496,8 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, str
19784 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
19785 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
19786 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
19787 + phy_info->change_count = buffer->ChangeCount;
19788 + phy_info->phy_info = le32_to_cpu(buffer->PhyInfo);
19789
19790 out_free_consistent:
19791 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
19792 @@ -1589,6 +2506,14 @@ mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, str
19793 return error;
19794 }
19795
19796 +/**
19797 + * mptsas_sas_device_pg0 -
19798 + * @ioc: Pointer to MPT_ADAPTER structure
19799 + * @device_info:
19800 + * @form:
19801 + * @form_specific:
19802 + *
19803 + **/
19804 static int
19805 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info,
19806 u32 form, u32 form_specific)
19807 @@ -1600,10 +2525,6 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
19808 __le64 sas_address;
19809 int error=0;
19810
19811 - if (ioc->sas_discovery_runtime &&
19812 - mptsas_is_end_device(device_info))
19813 - goto out;
19814 -
19815 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION;
19816 hdr.ExtPageLength = 0;
19817 hdr.PageNumber = 0;
19818 @@ -1617,9 +2538,8 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
19819 cfg.physAddr = -1;
19820 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19821 cfg.dir = 0; /* read */
19822 - cfg.timeout = 10;
19823 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19824
19825 - memset(device_info, 0, sizeof(struct mptsas_devinfo));
19826 error = mpt_config(ioc, &cfg);
19827 if (error)
19828 goto out;
19829 @@ -1639,11 +2559,18 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
19830 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
19831
19832 error = mpt_config(ioc, &cfg);
19833 +
19834 + if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
19835 + error = -ENODEV;
19836 + goto out_free_consistent;
19837 + }
19838 +
19839 if (error)
19840 goto out_free_consistent;
19841
19842 mptsas_print_device_pg0(ioc, buffer);
19843
19844 + memset(device_info, 0, sizeof(struct mptsas_devinfo));
19845 device_info->handle = le16_to_cpu(buffer->DevHandle);
19846 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle);
19847 device_info->handle_enclosure =
19848 @@ -1666,6 +2593,14 @@ mptsas_sas_device_pg0(MPT_ADAPTER *ioc,
19849 return error;
19850 }
19851
19852 +/**
19853 + * mptsas_sas_expander_pg0 -
19854 + * @ioc: Pointer to MPT_ADAPTER structure
19855 + * @port_info:
19856 + * @form:
19857 + * @form_specific:
19858 + *
19859 + **/
19860 static int
19861 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info,
19862 u32 form, u32 form_specific)
19863 @@ -1675,7 +2610,9 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
19864 SasExpanderPage0_t *buffer;
19865 dma_addr_t dma_handle;
19866 int i, error;
19867 + __le64 sas_address;
19868
19869 + memset(port_info, 0, sizeof(struct mptsas_portinfo));
19870 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
19871 hdr.ExtPageLength = 0;
19872 hdr.PageNumber = 0;
19873 @@ -1689,9 +2626,8 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
19874 cfg.pageAddr = form + form_specific;
19875 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19876 cfg.dir = 0; /* read */
19877 - cfg.timeout = 10;
19878 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19879
19880 - memset(port_info, 0, sizeof(struct mptsas_portinfo));
19881 error = mpt_config(ioc, &cfg);
19882 if (error)
19883 goto out;
19884 @@ -1712,27 +2648,32 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
19885 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
19886
19887 error = mpt_config(ioc, &cfg);
19888 - if (error)
19889 - goto out_free_consistent;
19890 -
19891 - if (!buffer->NumPhys) {
19892 + if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
19893 error = -ENODEV;
19894 goto out_free_consistent;
19895 }
19896
19897 + if (error)
19898 + goto out_free_consistent;
19899 +
19900 /* save config data */
19901 - port_info->num_phys = buffer->NumPhys;
19902 + port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1;
19903 port_info->phy_info = kcalloc(port_info->num_phys,
19904 - sizeof(*port_info->phy_info),GFP_KERNEL);
19905 + sizeof(struct mptsas_phyinfo),GFP_KERNEL);
19906 if (!port_info->phy_info) {
19907 error = -ENOMEM;
19908 goto out_free_consistent;
19909 }
19910
19911 + memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64));
19912 for (i = 0; i < port_info->num_phys; i++) {
19913 port_info->phy_info[i].portinfo = port_info;
19914 port_info->phy_info[i].handle =
19915 le16_to_cpu(buffer->DevHandle);
19916 + port_info->phy_info[i].identify.sas_address =
19917 + le64_to_cpu(sas_address);
19918 + port_info->phy_info[i].identify.handle_parent =
19919 + le16_to_cpu(buffer->ParentDevHandle);
19920 }
19921
19922 out_free_consistent:
19923 @@ -1742,6 +2683,14 @@ mptsas_sas_expander_pg0(MPT_ADAPTER *ioc
19924 return error;
19925 }
19926
19927 +/**
19928 + * mptsas_sas_expander_pg1 -
19929 + * @ioc: Pointer to MPT_ADAPTER structure
19930 + * @phy_info:
19931 + * @form:
19932 + * @form_specific:
19933 + *
19934 + **/
19935 static int
19936 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
19937 u32 form, u32 form_specific)
19938 @@ -1752,11 +2701,7 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc
19939 dma_addr_t dma_handle;
19940 int error=0;
19941
19942 - if (ioc->sas_discovery_runtime &&
19943 - mptsas_is_end_device(&phy_info->attached))
19944 - goto out;
19945 -
19946 - hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION;
19947 + hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION;
19948 hdr.ExtPageLength = 0;
19949 hdr.PageNumber = 1;
19950 hdr.Reserved1 = 0;
19951 @@ -1764,1352 +2709,2349 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc
19952 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
19953 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER;
19954
19955 - cfg.cfghdr.ehdr = &hdr;
19956 - cfg.physAddr = -1;
19957 - cfg.pageAddr = form + form_specific;
19958 + cfg.cfghdr.ehdr = &hdr;
19959 + cfg.physAddr = -1;
19960 + cfg.pageAddr = form + form_specific;
19961 + cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
19962 + cfg.dir = 0; /* read */
19963 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
19964 +
19965 + error = mpt_config(ioc, &cfg);
19966 + if (error)
19967 + goto out;
19968 +
19969 + if (!hdr.ExtPageLength) {
19970 + error = -ENXIO;
19971 + goto out;
19972 + }
19973 +
19974 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
19975 + &dma_handle);
19976 + if (!buffer) {
19977 + error = -ENOMEM;
19978 + goto out;
19979 + }
19980 +
19981 + cfg.physAddr = dma_handle;
19982 + cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
19983 +
19984 + error = mpt_config(ioc, &cfg);
19985 + if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
19986 + error = -ENODEV;
19987 + goto out;
19988 + }
19989 +
19990 + if (error)
19991 + goto out_free_consistent;
19992 +
19993 +
19994 + mptsas_print_expander_pg1(ioc, buffer);
19995 +
19996 + /* save config data */
19997 + phy_info->phy_id = buffer->PhyIdentifier;
19998 + phy_info->port_id = buffer->PhysicalPort;
19999 + phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
20000 + phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
20001 + phy_info->hw_link_rate = buffer->HwLinkRate;
20002 + phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
20003 + phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
20004 + phy_info->change_count = buffer->ChangeCount;
20005 + phy_info->phy_info = le32_to_cpu(buffer->PhyInfo);
20006 +
20007 + out_free_consistent:
20008 + pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
20009 + buffer, dma_handle);
20010 + out:
20011 + return error;
20012 +}
20013 +
20014 +/**
20015 + * mptsas_parse_device_info -
20016 + * @identify:
20017 + * @device_info:
20018 + *
20019 + **/
20020 +static void
20021 +mptsas_parse_device_info(struct sas_identify *identify,
20022 + struct mptsas_devinfo *device_info)
20023 +{
20024 + u16 protocols;
20025 +
20026 + identify->sas_address = device_info->sas_address;
20027 + identify->phy_identifier = device_info->phy_id;
20028 +
20029 + /*
20030 + * Fill in Phy Initiator Port Protocol.
20031 + * Bits 6:3, more than one bit can be set, fall through cases.
20032 + */
20033 + protocols = device_info->device_info & 0x78;
20034 + identify->initiator_port_protocols = 0;
20035 + if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
20036 + identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
20037 + if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
20038 + identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
20039 + if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
20040 + identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
20041 + if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
20042 + identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
20043 +
20044 + /*
20045 + * Fill in Phy Target Port Protocol.
20046 + * Bits 10:7, more than one bit can be set, fall through cases.
20047 + */
20048 + protocols = device_info->device_info & 0x780;
20049 + identify->target_port_protocols = 0;
20050 + if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
20051 + identify->target_port_protocols |= SAS_PROTOCOL_SSP;
20052 + if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
20053 + identify->target_port_protocols |= SAS_PROTOCOL_STP;
20054 + if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
20055 + identify->target_port_protocols |= SAS_PROTOCOL_SMP;
20056 + if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
20057 + identify->target_port_protocols |= SAS_PROTOCOL_SATA;
20058 +
20059 + /*
20060 + * Fill in Attached device type.
20061 + */
20062 + switch (device_info->device_info &
20063 + MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
20064 + case MPI_SAS_DEVICE_INFO_NO_DEVICE:
20065 + identify->device_type = SAS_PHY_UNUSED;
20066 + break;
20067 + case MPI_SAS_DEVICE_INFO_END_DEVICE:
20068 + identify->device_type = SAS_END_DEVICE;
20069 + break;
20070 + case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
20071 + identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
20072 + break;
20073 + case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
20074 + identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
20075 + break;
20076 + }
20077 +}
20078 +
20079 +/**
20080 + * mptsas_probe_one_phy -
20081 + * @dev:
20082 + * @phy_info:
20083 + * @local:
20084 + *
20085 + **/
20086 +static int mptsas_probe_one_phy(struct device *dev,
20087 + struct mptsas_phyinfo *phy_info, int index, int local)
20088 +{
20089 + MPT_ADAPTER *ioc;
20090 + struct sas_phy *phy;
20091 + struct sas_port *port;
20092 + int error = 0;
20093 +
20094 + if (!dev) {
20095 + error = -ENODEV;
20096 + goto out;
20097 + }
20098 +
20099 + if (!phy_info->phy) {
20100 + phy = sas_phy_alloc(dev, index);
20101 + if (!phy) {
20102 + error = -ENOMEM;
20103 + goto out;
20104 + }
20105 + } else
20106 + phy = phy_info->phy;
20107 +
20108 + mptsas_parse_device_info(&phy->identify, &phy_info->identify);
20109 +
20110 + /*
20111 + * Set Negotiated link rate.
20112 + */
20113 + switch (phy_info->negotiated_link_rate) {
20114 + case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
20115 + phy->negotiated_linkrate = SAS_PHY_DISABLED;
20116 + break;
20117 + case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
20118 + phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
20119 + break;
20120 + case MPI_SAS_IOUNIT0_RATE_1_5:
20121 + phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
20122 + break;
20123 + case MPI_SAS_IOUNIT0_RATE_3_0:
20124 + phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
20125 + break;
20126 + case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
20127 + case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
20128 + default:
20129 + phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
20130 + break;
20131 + }
20132 +
20133 + /*
20134 + * Set Max hardware link rate.
20135 + */
20136 + switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
20137 + case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
20138 + phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
20139 + break;
20140 + case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
20141 + phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
20142 + break;
20143 + default:
20144 + break;
20145 + }
20146 +
20147 + /*
20148 + * Set Max programmed link rate.
20149 + */
20150 + switch (phy_info->programmed_link_rate &
20151 + MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
20152 + case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
20153 + phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
20154 + break;
20155 + case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
20156 + phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
20157 + break;
20158 + default:
20159 + break;
20160 + }
20161 +
20162 + /*
20163 + * Set Min hardware link rate.
20164 + */
20165 + switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
20166 + case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
20167 + phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
20168 + break;
20169 + case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
20170 + phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
20171 + break;
20172 + default:
20173 + break;
20174 + }
20175 +
20176 + /*
20177 + * Set Min programmed link rate.
20178 + */
20179 + switch (phy_info->programmed_link_rate &
20180 + MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
20181 + case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
20182 + phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
20183 + break;
20184 + case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
20185 + phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
20186 + break;
20187 + default:
20188 + break;
20189 + }
20190 +
20191 + if (!phy_info->phy) {
20192 +
20193 + error = sas_phy_add(phy);
20194 + if (error) {
20195 + sas_phy_free(phy);
20196 + goto out;
20197 + }
20198 + phy_info->phy = phy;
20199 + }
20200 +
20201 + if (!phy_info->attached.handle ||
20202 + !phy_info->port_details)
20203 + goto out;
20204 +
20205 + port = mptsas_get_port(phy_info);
20206 + ioc = phy_to_ioc(phy_info->phy);
20207 +
20208 + if (phy_info->sas_port_add_phy) {
20209 + if (!port) {
20210 + port = sas_port_alloc_num(dev);
20211 + if (!port) {
20212 + error = -ENOMEM;
20213 + goto out;
20214 + }
20215 + error = sas_port_add(port);
20216 + if (error) {
20217 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20218 + "%s: exit at line=%d\n", ioc->name,
20219 + __FUNCTION__, __LINE__));
20220 + goto out;
20221 + }
20222 + mptsas_set_port(ioc, phy_info, port);
20223 + devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev,
20224 + MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n",
20225 + ioc->name, port->port_identifier,
20226 + (unsigned long long)phy_info->attached.sas_address));
20227 + }
20228 + sas_port_add_phy(port, phy_info->phy);
20229 + phy_info->sas_port_add_phy = 0;
20230 + devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev,
20231 + MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name,
20232 + phy_info->phy_id, phy_info->phy));
20233 + }
20234 +
20235 + if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
20236 +
20237 + struct sas_rphy *rphy;
20238 + struct device *parent;
20239 + struct sas_identify identify;
20240 +
20241 + parent = dev->parent->parent;
20242 +
20243 + if (mptsas_is_end_device(&phy_info->attached) &&
20244 + phy_info->attached.handle_parent) {
20245 + goto out;
20246 + }
20247 +
20248 + mptsas_parse_device_info(&identify, &phy_info->attached);
20249 + if (scsi_is_host_device(parent)) {
20250 + struct mptsas_portinfo *port_info;
20251 + int i;
20252 +
20253 + port_info = ioc->hba_port_info;
20254 + for (i = 0; i < port_info->num_phys; i++)
20255 + if (port_info->phy_info[i].identify.sas_address ==
20256 + identify.sas_address) {
20257 + sas_port_mark_backlink(port);
20258 + goto out;
20259 + }
20260 +
20261 + } else if (scsi_is_sas_rphy(parent)) {
20262 + struct sas_rphy *parent_rphy = dev_to_rphy(parent);
20263 + if (identify.sas_address ==
20264 + parent_rphy->identify.sas_address) {
20265 + sas_port_mark_backlink(port);
20266 + goto out;
20267 + }
20268 + }
20269 +
20270 + switch (identify.device_type) {
20271 + case SAS_END_DEVICE:
20272 + rphy = sas_end_device_alloc(port);
20273 + break;
20274 + case SAS_EDGE_EXPANDER_DEVICE:
20275 + case SAS_FANOUT_EXPANDER_DEVICE:
20276 + rphy = sas_expander_alloc(port, identify.device_type);
20277 + break;
20278 + default:
20279 + rphy = NULL;
20280 + break;
20281 + }
20282 + if (!rphy) {
20283 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20284 + "%s: exit at line=%d\n", ioc->name,
20285 + __FUNCTION__, __LINE__));
20286 + goto out;
20287 + }
20288 +
20289 + rphy->identify = identify;
20290 + error = sas_rphy_add(rphy);
20291 + if (error) {
20292 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20293 + "%s: exit at line=%d\n", ioc->name,
20294 + __FUNCTION__, __LINE__));
20295 + sas_rphy_free(rphy);
20296 + goto out;
20297 + }
20298 + mptsas_set_rphy(ioc, phy_info, rphy);
20299 + }
20300 +
20301 + out:
20302 + return error;
20303 +}
20304 +
20305 +/**
20306 + * mptsas_probe_hba_phys -
20307 + * @ioc: Pointer to MPT_ADAPTER structure
20308 + * @handle:
20309 + *
20310 + **/
20311 +static int
20312 +mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
20313 +{
20314 + struct mptsas_portinfo *port_info, *hba;
20315 + int error = -ENOMEM, i;
20316 +
20317 + hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
20318 + if (! hba)
20319 + goto out;
20320 +
20321 + error = mptsas_sas_io_unit_pg0(ioc, hba);
20322 + if (error)
20323 + goto out_free_port_info;
20324 +
20325 + mptsas_sas_io_unit_pg1(ioc);
20326 + mutex_lock(&ioc->sas_topology_mutex);
20327 + port_info = ioc->hba_port_info;
20328 + if (!port_info) {
20329 + ioc->hba_port_info = port_info = hba;
20330 + ioc->hba_port_num_phy = port_info->num_phys;
20331 + list_add_tail(&port_info->list, &ioc->sas_topology);
20332 + } else {
20333 + for (i = 0; i < hba->num_phys; i++) {
20334 + port_info->phy_info[i].negotiated_link_rate =
20335 + hba->phy_info[i].negotiated_link_rate;
20336 + port_info->phy_info[i].handle =
20337 + hba->phy_info[i].handle;
20338 + port_info->phy_info[i].port_id =
20339 + hba->phy_info[i].port_id;
20340 + port_info->phy_info[i].port_flags =
20341 + hba->phy_info[i].port_flags;
20342 + }
20343 + kfree(hba->phy_info);
20344 + kfree(hba);
20345 + hba = NULL;
20346 + }
20347 + mutex_unlock(&ioc->sas_topology_mutex);
20348 +#if defined(CPQ_CIM)
20349 + ioc->num_ports = port_info->num_phys;
20350 +#endif
20351 + for (i = 0; i < port_info->num_phys; i++) {
20352 + mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
20353 + (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
20354 + MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
20355 + port_info->phy_info[i].identify.handle =
20356 + port_info->phy_info[i].handle;
20357 + mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
20358 + (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
20359 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
20360 + port_info->phy_info[i].identify.handle);
20361 + if (!ioc->hba_port_sas_addr)
20362 + ioc->hba_port_sas_addr =
20363 + port_info->phy_info[i].identify.sas_address;
20364 + port_info->phy_info[i].identify.phy_id =
20365 + port_info->phy_info[i].phy_id = i;
20366 + if (port_info->phy_info[i].attached.handle)
20367 + mptsas_sas_device_pg0(ioc,
20368 + &port_info->phy_info[i].attached,
20369 + (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
20370 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
20371 + port_info->phy_info[i].attached.handle);
20372 + }
20373 +
20374 + mptsas_setup_wide_ports(ioc, port_info);
20375 +
20376 + for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
20377 + mptsas_probe_one_phy(&ioc->sh->shost_gendev,
20378 + &port_info->phy_info[i], ioc->sas_index, 1);
20379 +
20380 + return 0;
20381 +
20382 + out_free_port_info:
20383 + kfree(hba);
20384 + out:
20385 + return error;
20386 +}
20387 +
20388 +/**
20389 + * mptsas_find_phyinfo_by_sas_address -
20390 + * @ioc: Pointer to MPT_ADAPTER structure
20391 + * @sas_address:
20392 + *
20393 + **/
20394 +static struct mptsas_phyinfo *
20395 +mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
20396 +{
20397 + struct mptsas_portinfo *port_info;
20398 + struct mptsas_phyinfo *phy_info = NULL;
20399 + int i;
20400 +
20401 + mutex_lock(&ioc->sas_topology_mutex);
20402 + list_for_each_entry(port_info, &ioc->sas_topology, list) {
20403 + for (i = 0; i < port_info->num_phys; i++) {
20404 + if (!mptsas_is_end_device(
20405 + &port_info->phy_info[i].attached))
20406 + continue;
20407 + if (port_info->phy_info[i].attached.sas_address
20408 + != sas_address)
20409 + continue;
20410 + phy_info = &port_info->phy_info[i];
20411 + break;
20412 + }
20413 + }
20414 + mutex_unlock(&ioc->sas_topology_mutex);
20415 + return phy_info;
20416 +}
20417 +
20418 +/**
20419 + * mptsas_find_phyinfo_by_phys_disk_num -
20420 + * @ioc: Pointer to MPT_ADAPTER structure
20421 + * @phys_disk_num:
20422 + * @channel:
20423 + * @id:
20424 + *
20425 + **/
20426 +static struct mptsas_phyinfo *
20427 +mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num,
20428 + u8 channel, u8 id)
20429 +{
20430 + struct mptsas_phyinfo *phy_info;
20431 + struct mptsas_portinfo *port_info;
20432 + RaidPhysDiskPage1_t *phys_disk = NULL;
20433 + int num_paths;
20434 + u64 sas_address = 0;
20435 + int i;
20436 +
20437 + phy_info = NULL;
20438 + if (!ioc->raid_data.pIocPg3)
20439 + return NULL;
20440 + /* dual port support */
20441 + num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num);
20442 + if (!num_paths)
20443 + goto out;
20444 + phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
20445 + (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
20446 + if (!phys_disk)
20447 + goto out;
20448 + mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk);
20449 + for (i = 0; i < num_paths; i++) {
20450 + if ((phys_disk->Path[i].Flags & 1) != 0)
20451 + /* entry no longer valid */
20452 + continue;
20453 + if ((id == phys_disk->Path[i].PhysDiskID) &&
20454 + (channel == phys_disk->Path[i].PhysDiskBus)) {
20455 + memcpy(&sas_address, &phys_disk->Path[i].WWID,
20456 + sizeof(u64));
20457 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc, sas_address);
20458 + goto out;
20459 + }
20460 + }
20461 +
20462 + out:
20463 + kfree(phys_disk);
20464 + if (phy_info)
20465 + return phy_info;
20466 +
20467 + /*
20468 + * Extra code to handle RAID0 case, where the sas_address is not updated
20469 + * in phys_disk_page_1 when hotswapped
20470 + */
20471 + mutex_lock(&ioc->sas_topology_mutex);
20472 + list_for_each_entry(port_info, &ioc->sas_topology, list) {
20473 + for (i = 0; i < port_info->num_phys && !phy_info; i++) {
20474 + if (!mptsas_is_end_device(
20475 + &port_info->phy_info[i].attached))
20476 + continue;
20477 + if (port_info->phy_info[i].attached.phys_disk_num == ~0)
20478 + continue;
20479 + if (port_info->phy_info[i].attached.phys_disk_num == phys_disk_num &&
20480 + port_info->phy_info[i].attached.id == id &&
20481 + port_info->phy_info[i].attached.channel == channel)
20482 + phy_info = &port_info->phy_info[i];
20483 + }
20484 + }
20485 + mutex_unlock(&ioc->sas_topology_mutex);
20486 + return phy_info;
20487 +}
20488 +
20489 +/**
20490 + * mptsas_reprobe_lun -
20491 + * @sdev:
20492 + * @data:
20493 + *
20494 + **/
20495 +static void
20496 +mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
20497 +{
20498 + int rc;
20499 +
20500 + sdev->no_uld_attach = data ? 1 : 0;
20501 + rc = scsi_device_reprobe(sdev);
20502 +}
20503 +
20504 +/**
20505 + * mptsas_reprobe_target -
20506 + * @starget:
20507 + * @uld_attach:
20508 + *
20509 + **/
20510 +static void
20511 +mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
20512 +{
20513 + starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
20514 + mptsas_reprobe_lun);
20515 +}
20516 +
20517 +/**
20518 + * mptsas_adding_inactive_raid_components -
20519 + * @ioc: Pointer to MPT_ADAPTER structure
20520 + * @channel:
20521 + * @id:
20522 + *
20523 + *
20524 + * TODO: check for hotspares
20525 + **/
20526 +static void
20527 +mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
20528 +{
20529 + CONFIGPARMS cfg;
20530 + ConfigPageHeader_t hdr;
20531 + dma_addr_t dma_handle;
20532 + pRaidVolumePage0_t buffer = NULL;
20533 + RaidPhysDiskPage0_t phys_disk;
20534 + int i;
20535 + struct mptsas_phyinfo *phy_info;
20536 + struct mptsas_devinfo sas_device;
20537 +
20538 + memset(&cfg, 0 , sizeof(CONFIGPARMS));
20539 + memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
20540 + hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
20541 + cfg.pageAddr = (channel << 8) + id;
20542 + cfg.cfghdr.hdr = &hdr;
20543 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
20544 - cfg.dir = 0; /* read */
20545 - cfg.timeout = 10;
20546 + cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT;
20547
20548 - error = mpt_config(ioc, &cfg);
20549 - if (error)
20550 + if (mpt_config(ioc, &cfg) != 0)
20551 goto out;
20552
20553 - if (!hdr.ExtPageLength) {
20554 - error = -ENXIO;
20555 + if (!hdr.PageLength)
20556 goto out;
20557 - }
20558
20559 - buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
20560 - &dma_handle);
20561 - if (!buffer) {
20562 - error = -ENOMEM;
20563 + buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
20564 + &dma_handle);
20565 +
20566 + if (!buffer)
20567 goto out;
20568 - }
20569
20570 cfg.physAddr = dma_handle;
20571 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
20572
20573 - error = mpt_config(ioc, &cfg);
20574 - if (error)
20575 - goto out_free_consistent;
20576 -
20577 -
20578 - mptsas_print_expander_pg1(ioc, buffer);
20579 -
20580 - /* save config data */
20581 - phy_info->phy_id = buffer->PhyIdentifier;
20582 - phy_info->port_id = buffer->PhysicalPort;
20583 - phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate;
20584 - phy_info->programmed_link_rate = buffer->ProgrammedLinkRate;
20585 - phy_info->hw_link_rate = buffer->HwLinkRate;
20586 - phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle);
20587 - phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle);
20588 + if (mpt_config(ioc, &cfg) != 0)
20589 + goto out;
20590
20591 - out_free_consistent:
20592 - pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4,
20593 - buffer, dma_handle);
20594 - out:
20595 - return error;
20596 -}
20597 + if (!(buffer->VolumeStatus.Flags &
20598 + MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
20599 + goto out;
20600
20601 -static void
20602 -mptsas_parse_device_info(struct sas_identify *identify,
20603 - struct mptsas_devinfo *device_info)
20604 -{
20605 - u16 protocols;
20606 + if (!buffer->NumPhysDisks)
20607 + goto out;
20608
20609 - identify->sas_address = device_info->sas_address;
20610 - identify->phy_identifier = device_info->phy_id;
20611 + for (i = 0; i < buffer->NumPhysDisks; i++) {
20612
20613 - /*
20614 - * Fill in Phy Initiator Port Protocol.
20615 - * Bits 6:3, more than one bit can be set, fall through cases.
20616 - */
20617 - protocols = device_info->device_info & 0x78;
20618 - identify->initiator_port_protocols = 0;
20619 - if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR)
20620 - identify->initiator_port_protocols |= SAS_PROTOCOL_SSP;
20621 - if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR)
20622 - identify->initiator_port_protocols |= SAS_PROTOCOL_STP;
20623 - if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR)
20624 - identify->initiator_port_protocols |= SAS_PROTOCOL_SMP;
20625 - if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST)
20626 - identify->initiator_port_protocols |= SAS_PROTOCOL_SATA;
20627 + if (mpt_raid_phys_disk_pg0(ioc,
20628 + buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
20629 + continue;
20630
20631 - /*
20632 - * Fill in Phy Target Port Protocol.
20633 - * Bits 10:7, more than one bit can be set, fall through cases.
20634 - */
20635 - protocols = device_info->device_info & 0x780;
20636 - identify->target_port_protocols = 0;
20637 - if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET)
20638 - identify->target_port_protocols |= SAS_PROTOCOL_SSP;
20639 - if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET)
20640 - identify->target_port_protocols |= SAS_PROTOCOL_STP;
20641 - if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET)
20642 - identify->target_port_protocols |= SAS_PROTOCOL_SMP;
20643 - if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE)
20644 - identify->target_port_protocols |= SAS_PROTOCOL_SATA;
20645 + if (mptsas_sas_device_pg0(ioc, &sas_device,
20646 + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
20647 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
20648 + (phys_disk.PhysDiskBus << 8) +
20649 + phys_disk.PhysDiskID))
20650 + continue;
20651
20652 - /*
20653 - * Fill in Attached device type.
20654 - */
20655 - switch (device_info->device_info &
20656 - MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
20657 - case MPI_SAS_DEVICE_INFO_NO_DEVICE:
20658 - identify->device_type = SAS_PHY_UNUSED;
20659 - break;
20660 - case MPI_SAS_DEVICE_INFO_END_DEVICE:
20661 - identify->device_type = SAS_END_DEVICE;
20662 - break;
20663 - case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER:
20664 - identify->device_type = SAS_EDGE_EXPANDER_DEVICE;
20665 - break;
20666 - case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER:
20667 - identify->device_type = SAS_FANOUT_EXPANDER_DEVICE;
20668 - break;
20669 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
20670 + sas_device.sas_address);
20671 + mptsas_add_end_device(ioc, phy_info);
20672 }
20673 +
20674 + out:
20675 + if (buffer)
20676 + pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
20677 + dma_handle);
20678 }
20679
20680 -static int mptsas_probe_one_phy(struct device *dev,
20681 - struct mptsas_phyinfo *phy_info, int index, int local)
20682 +/**
20683 + * mptsas_add_end_device - report a new end device to sas transport layer
20684 + * @ioc: Pointer to MPT_ADAPTER structure
20685 + * @phy_info: decribes attached device
20686 + *
20687 + * return (0) success (1) failure
20688 + *
20689 + **/
20690 +static int
20691 +mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
20692 {
20693 - MPT_ADAPTER *ioc;
20694 - struct sas_phy *phy;
20695 + struct sas_rphy *rphy;
20696 struct sas_port *port;
20697 - int error = 0;
20698 + struct sas_identify identify;
20699 + char *ds = NULL;
20700 + u8 fw_id;
20701
20702 - if (!dev) {
20703 - error = -ENODEV;
20704 - goto out;
20705 + if (!phy_info){
20706 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20707 + "%s: exit at line=%d\n", ioc->name,
20708 + __FUNCTION__, __LINE__));
20709 + return 1;
20710 }
20711
20712 - if (!phy_info->phy) {
20713 - phy = sas_phy_alloc(dev, index);
20714 - if (!phy) {
20715 - error = -ENOMEM;
20716 - goto out;
20717 - }
20718 - } else
20719 - phy = phy_info->phy;
20720 -
20721 - mptsas_parse_device_info(&phy->identify, &phy_info->identify);
20722 -
20723 - /*
20724 - * Set Negotiated link rate.
20725 - */
20726 - switch (phy_info->negotiated_link_rate) {
20727 - case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED:
20728 - phy->negotiated_linkrate = SAS_PHY_DISABLED;
20729 - break;
20730 - case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION:
20731 - phy->negotiated_linkrate = SAS_LINK_RATE_FAILED;
20732 - break;
20733 - case MPI_SAS_IOUNIT0_RATE_1_5:
20734 - phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
20735 - break;
20736 - case MPI_SAS_IOUNIT0_RATE_3_0:
20737 - phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
20738 - break;
20739 - case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE:
20740 - case MPI_SAS_IOUNIT0_RATE_UNKNOWN:
20741 - default:
20742 - phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN;
20743 - break;
20744 - }
20745 + fw_id = phy_info->attached.id;
20746
20747 - /*
20748 - * Set Max hardware link rate.
20749 - */
20750 - switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
20751 - case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5:
20752 - phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
20753 - break;
20754 - case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
20755 - phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
20756 - break;
20757 - default:
20758 - break;
20759 + if (mptsas_get_rphy(phy_info)) {
20760 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20761 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20762 + __FUNCTION__, fw_id, __LINE__));
20763 + return 2;
20764 }
20765
20766 - /*
20767 - * Set Max programmed link rate.
20768 - */
20769 - switch (phy_info->programmed_link_rate &
20770 - MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) {
20771 - case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5:
20772 - phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS;
20773 - break;
20774 - case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0:
20775 - phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS;
20776 - break;
20777 - default:
20778 - break;
20779 + port = mptsas_get_port(phy_info);
20780 + if (!port) {
20781 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20782 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20783 + __FUNCTION__, fw_id, __LINE__));
20784 + return 3;
20785 + }
20786 +
20787 + if (phy_info->attached.device_info &
20788 + MPI_SAS_DEVICE_INFO_SSP_TARGET)
20789 + ds = "ssp";
20790 + if (phy_info->attached.device_info &
20791 + MPI_SAS_DEVICE_INFO_STP_TARGET)
20792 + ds = "stp";
20793 + if (phy_info->attached.device_info &
20794 + MPI_SAS_DEVICE_INFO_SATA_DEVICE)
20795 + ds = "sata";
20796 +
20797 + printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d,"
20798 + " phy %d, sas_addr 0x%llx\n", ioc->name, ds,
20799 + phy_info->attached.channel, phy_info->attached.id,
20800 + phy_info->attached.phy_id, (unsigned long long)
20801 + phy_info->attached.sas_address);
20802 +
20803 + mptsas_parse_device_info(&identify, &phy_info->attached);
20804 + rphy = sas_end_device_alloc(port);
20805 + if (!rphy) {
20806 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20807 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20808 + __FUNCTION__, fw_id, __LINE__));
20809 + return 5; /* non-fatal: an rphy can be added later */
20810 + }
20811 +
20812 + rphy->identify = identify;
20813 + if (sas_rphy_add(rphy)) {
20814 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20815 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20816 + __FUNCTION__, fw_id, __LINE__));
20817 + sas_rphy_free(rphy);
20818 + return 6;
20819 }
20820 + mptsas_set_rphy(ioc, phy_info, rphy);
20821 + return 0;
20822 +}
20823
20824 - /*
20825 - * Set Min hardware link rate.
20826 - */
20827 - switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) {
20828 - case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5:
20829 - phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
20830 - break;
20831 - case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
20832 - phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS;
20833 - break;
20834 - default:
20835 - break;
20836 - }
20837 +/**
20838 + * mptsas_del_end_device - report a deleted end device to sas transport
20839 + * layer
20840 + * @ioc: Pointer to MPT_ADAPTER structure
20841 + * @phy_info: decribes attached device
20842 + *
20843 + **/
20844 +static void
20845 +mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info)
20846 +{
20847 + struct sas_rphy *rphy;
20848 + struct sas_port *port;
20849 + struct mptsas_portinfo *port_info;
20850 + struct mptsas_phyinfo *phy_info_parent;
20851 + int i;
20852 + struct scsi_target * starget;
20853 + char *ds = NULL;
20854 + u8 fw_id;
20855 + u64 sas_address;
20856
20857 - /*
20858 - * Set Min programmed link rate.
20859 - */
20860 - switch (phy_info->programmed_link_rate &
20861 - MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) {
20862 - case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5:
20863 - phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
20864 - break;
20865 - case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0:
20866 - phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS;
20867 - break;
20868 - default:
20869 - break;
20870 - }
20871 + if (!phy_info)
20872 + return;
20873
20874 - if (!phy_info->phy) {
20875 + fw_id = phy_info->attached.id;
20876 + sas_address = phy_info->attached.sas_address;
20877
20878 - error = sas_phy_add(phy);
20879 - if (error) {
20880 - sas_phy_free(phy);
20881 - goto out;
20882 - }
20883 - phy_info->phy = phy;
20884 + if (!phy_info->port_details) {
20885 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20886 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20887 + __FUNCTION__, fw_id, __LINE__));
20888 + return;
20889 }
20890 -
20891 - if (!phy_info->attached.handle ||
20892 - !phy_info->port_details)
20893 - goto out;
20894 + rphy = mptsas_get_rphy(phy_info);
20895 + if (!rphy) {
20896 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20897 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20898 + __FUNCTION__, fw_id, __LINE__));
20899 + return;
20900 + }
20901 + if (phy_info->attached.device_info &
20902 + MPI_SAS_DEVICE_INFO_SSP_TARGET)
20903 + ds = "ssp";
20904 + if (phy_info->attached.device_info &
20905 + MPI_SAS_DEVICE_INFO_STP_TARGET)
20906 + ds = "stp";
20907 + if (phy_info->attached.device_info &
20908 + MPI_SAS_DEVICE_INFO_SATA_DEVICE)
20909 + ds = "sata";
20910 +
20911 + starget = mptsas_get_starget(phy_info);
20912 +
20913 + printk(MYIOC_s_INFO_FMT "removing %s device: fw_channel %d,"
20914 + " fw_id %d, phy %d, sas_addr 0x%llx\n", ioc->name, ds,
20915 + phy_info->attached.channel, phy_info->attached.id,
20916 + phy_info->attached.phy_id, (unsigned long long)
20917 + sas_address);
20918
20919 port = mptsas_get_port(phy_info);
20920 - ioc = phy_to_ioc(phy_info->phy);
20921 + if (!port) {
20922 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20923 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
20924 + __FUNCTION__, fw_id, __LINE__));
20925 + return;
20926 + }
20927 + port_info = phy_info->portinfo;
20928 + phy_info_parent = port_info->phy_info;
20929 + for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) {
20930 + if(!phy_info_parent->phy)
20931 + continue;
20932 + if (phy_info_parent->attached.sas_address !=
20933 + sas_address)
20934 + continue;
20935 + dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev,
20936 + MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n",
20937 + ioc->name, phy_info_parent->phy_id,
20938 + phy_info_parent->phy);
20939 + sas_port_delete_phy(port, phy_info_parent->phy);
20940 + }
20941 +
20942 + dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
20943 + "delete port %d, sas_addr (0x%llx)\n", ioc->name,
20944 + port->port_identifier, (unsigned long long)sas_address);
20945 + sas_port_delete(port);
20946 +// mptsas_port_delete(ioc, phy_info->port_details);
20947 +}
20948
20949 - if (phy_info->sas_port_add_phy) {
20950 +struct mptsas_phyinfo *
20951 +mptsas_refreshing_device_handles(MPT_ADAPTER *ioc, struct mptsas_devinfo *sas_device)
20952 +{
20953 + struct mptsas_phyinfo *phy_info;
20954 + struct mptsas_portinfo *port_info;
20955 + int i;
20956
20957 - if (!port) {
20958 - port = sas_port_alloc_num(dev);
20959 - if (!port) {
20960 - error = -ENOMEM;
20961 - goto out;
20962 - }
20963 - error = sas_port_add(port);
20964 - if (error) {
20965 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
20966 - "%s: exit at line=%d\n", ioc->name,
20967 - __func__, __LINE__));
20968 - goto out;
20969 - }
20970 - mptsas_set_port(ioc, phy_info, port);
20971 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT
20972 - "sas_port_alloc: port=%p dev=%p port_id=%d\n",
20973 - ioc->name, port, dev, port->port_identifier));
20974 - }
20975 - dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_port_add_phy: phy_id=%d\n",
20976 - ioc->name, phy_info->phy_id));
20977 - sas_port_add_phy(port, phy_info->phy);
20978 - phy_info->sas_port_add_phy = 0;
20979 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
20980 + sas_device->sas_address);
20981 + if (!phy_info)
20982 + goto out;
20983 + port_info = phy_info->portinfo;
20984 + if (!port_info)
20985 + goto out;
20986 + mutex_lock(&ioc->sas_topology_mutex);
20987 + for (i = 0; i < port_info->num_phys; i++) {
20988 + if(port_info->phy_info[i].attached.sas_address !=
20989 + sas_device->sas_address)
20990 + continue;
20991 + port_info->phy_info[i].attached.channel = sas_device->channel;
20992 + port_info->phy_info[i].attached.id = sas_device->id;
20993 + port_info->phy_info[i].attached.sas_address =
20994 + sas_device->sas_address;
20995 + port_info->phy_info[i].attached.handle = sas_device->handle;
20996 + port_info->phy_info[i].attached.handle_parent =
20997 + sas_device->handle_parent;
20998 + port_info->phy_info[i].attached.handle_enclosure =
20999 + sas_device->handle_enclosure;
21000 }
21001 + mutex_unlock(&ioc->sas_topology_mutex);
21002 + out:
21003 + return phy_info;
21004 +}
21005
21006 - if (!mptsas_get_rphy(phy_info) && port && !port->rphy) {
21007 -
21008 - struct sas_rphy *rphy;
21009 - struct device *parent;
21010 - struct sas_identify identify;
21011
21012 - parent = dev->parent->parent;
21013 - /*
21014 - * Let the hotplug_work thread handle processing
21015 - * the adding/removing of devices that occur
21016 - * after start of day.
21017 - */
21018 - if (ioc->sas_discovery_runtime &&
21019 - mptsas_is_end_device(&phy_info->attached))
21020 - goto out;
21021 +/**
21022 + * mptsas_hotplug_work - Work queue thread to handle SAS hotplug events
21023 + *
21024 + *
21025 + **/
21026 +static void
21027 +mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event,
21028 + struct mptsas_hotplug_event *hot_plug_info)
21029 +{
21030 + struct mptsas_phyinfo *phy_info;
21031 + struct scsi_target * starget;
21032 + struct mptsas_devinfo sas_device;
21033 + VirtTarget *vtarget;
21034 + enum device_state state;
21035 + int i;
21036
21037 - mptsas_parse_device_info(&identify, &phy_info->attached);
21038 - if (scsi_is_host_device(parent)) {
21039 - struct mptsas_portinfo *port_info;
21040 - int i;
21041 + switch (hot_plug_info->event_type) {
21042
21043 - mutex_lock(&ioc->sas_topology_mutex);
21044 - port_info = mptsas_get_hba_portinfo(ioc);
21045 - mutex_unlock(&ioc->sas_topology_mutex);
21046 + case MPTSAS_ADD_PHYSDISK:
21047
21048 - for (i = 0; i < port_info->num_phys; i++)
21049 - if (port_info->phy_info[i].identify.sas_address ==
21050 - identify.sas_address) {
21051 - sas_port_mark_backlink(port);
21052 - goto out;
21053 - }
21054 + if (!ioc->raid_data.pIocPg2)
21055 + break;
21056
21057 - } else if (scsi_is_sas_rphy(parent)) {
21058 - struct sas_rphy *parent_rphy = dev_to_rphy(parent);
21059 - if (identify.sas_address ==
21060 - parent_rphy->identify.sas_address) {
21061 - sas_port_mark_backlink(port);
21062 - goto out;
21063 + for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
21064 + if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID ==
21065 + hot_plug_info->id) {
21066 + printk(MYIOC_s_WARN_FMT "firmware bug: unable "
21067 + "to add hidden disk - target_id matchs "
21068 + "volume_id\n", ioc->name);
21069 + mptsas_free_fw_event(ioc, fw_event);
21070 + return;
21071 }
21072 }
21073
21074 - switch (identify.device_type) {
21075 - case SAS_END_DEVICE:
21076 - rphy = sas_end_device_alloc(port);
21077 - break;
21078 - case SAS_EDGE_EXPANDER_DEVICE:
21079 - case SAS_FANOUT_EXPANDER_DEVICE:
21080 - rphy = sas_expander_alloc(port, identify.device_type);
21081 + case MPTSAS_ADD_DEVICE:
21082 + memset(&sas_device, 0, sizeof(struct mptsas_devinfo));
21083 + mptsas_sas_device_pg0(ioc, &sas_device,
21084 + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
21085 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21086 + (hot_plug_info->channel << 8) +
21087 + hot_plug_info->id);
21088 +
21089 + if (!sas_device.handle)
21090 + return;
21091 +
21092 + phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
21093 + if (!phy_info)
21094 break;
21095 - default:
21096 - rphy = NULL;
21097 +
21098 + if (mptsas_get_rphy(phy_info))
21099 break;
21100 - }
21101 - if (!rphy) {
21102 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21103 - "%s: exit at line=%d\n", ioc->name,
21104 - __func__, __LINE__));
21105 - goto out;
21106 - }
21107
21108 - rphy->identify = identify;
21109 - error = sas_rphy_add(rphy);
21110 - if (error) {
21111 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21112 - "%s: exit at line=%d\n", ioc->name,
21113 - __func__, __LINE__));
21114 - sas_rphy_free(rphy);
21115 - goto out;
21116 + state = mptsas_test_unit_ready(ioc, phy_info->attached.channel,
21117 + phy_info->attached.id, fw_event->retries);
21118 +
21119 + if (state == DEVICE_RETRY && !ioc->fw_events_off) {
21120 + mptsas_requeue_fw_event(ioc, fw_event, 1000);
21121 + return;
21122 }
21123 - mptsas_set_rphy(ioc, phy_info, rphy);
21124 - }
21125
21126 - out:
21127 - return error;
21128 -}
21129 + if (state == DEVICE_READY)
21130 + mptsas_add_end_device(ioc, phy_info);
21131 + break;
21132
21133 -static int
21134 -mptsas_probe_hba_phys(MPT_ADAPTER *ioc)
21135 -{
21136 - struct mptsas_portinfo *port_info, *hba;
21137 - int error = -ENOMEM, i;
21138 + case MPTSAS_DEL_DEVICE:
21139
21140 - hba = kzalloc(sizeof(*port_info), GFP_KERNEL);
21141 - if (! hba)
21142 - goto out;
21143 + if (!ioc->disable_hotplug_remove) {
21144 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
21145 + hot_plug_info->sas_address);
21146 + mptsas_del_end_device(ioc, phy_info);
21147 + }
21148 + break;
21149
21150 - error = mptsas_sas_io_unit_pg0(ioc, hba);
21151 - if (error)
21152 - goto out_free_port_info;
21153 + case MPTSAS_DEL_PHYSDISK:
21154
21155 - mptsas_sas_io_unit_pg1(ioc);
21156 - mutex_lock(&ioc->sas_topology_mutex);
21157 - port_info = mptsas_get_hba_portinfo(ioc);
21158 - if (!port_info) {
21159 - port_info = hba;
21160 - list_add_tail(&port_info->list, &ioc->sas_topology);
21161 - } else {
21162 - for (i = 0; i < hba->num_phys; i++) {
21163 - port_info->phy_info[i].negotiated_link_rate =
21164 - hba->phy_info[i].negotiated_link_rate;
21165 - port_info->phy_info[i].handle =
21166 - hba->phy_info[i].handle;
21167 - port_info->phy_info[i].port_id =
21168 - hba->phy_info[i].port_id;
21169 - }
21170 - kfree(hba->phy_info);
21171 - kfree(hba);
21172 - hba = NULL;
21173 - }
21174 - mutex_unlock(&ioc->sas_topology_mutex);
21175 - for (i = 0; i < port_info->num_phys; i++) {
21176 - mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i],
21177 - (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER <<
21178 - MPI_SAS_PHY_PGAD_FORM_SHIFT), i);
21179 + mpt_findImVolumes(ioc);
21180
21181 - mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify,
21182 - (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
21183 - MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21184 - port_info->phy_info[i].handle);
21185 - port_info->phy_info[i].identify.phy_id =
21186 - port_info->phy_info[i].phy_id = i;
21187 - if (port_info->phy_info[i].attached.handle)
21188 - mptsas_sas_device_pg0(ioc,
21189 - &port_info->phy_info[i].attached,
21190 - (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
21191 - MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21192 - port_info->phy_info[i].attached.handle);
21193 - }
21194 + phy_info = mptsas_find_phyinfo_by_phys_disk_num(
21195 + ioc, hot_plug_info->phys_disk_num, hot_plug_info->channel,
21196 + hot_plug_info->id);
21197 + mptsas_del_end_device(ioc, phy_info);
21198 + break;
21199
21200 - mptsas_setup_wide_ports(ioc, port_info);
21201 + case MPTSAS_ADD_PHYSDISK_REPROBE:
21202
21203 - for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
21204 - mptsas_probe_one_phy(&ioc->sh->shost_gendev,
21205 - &port_info->phy_info[i], ioc->sas_index, 1);
21206 + if (mptsas_sas_device_pg0(ioc, &sas_device,
21207 + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
21208 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21209 + (hot_plug_info->channel << 8) + hot_plug_info->id)) {
21210 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21211 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21212 + __FUNCTION__, hot_plug_info->id, __LINE__));
21213 + break;
21214 + }
21215
21216 - return 0;
21217 + phy_info = mptsas_find_phyinfo_by_sas_address(
21218 + ioc, sas_device.sas_address);
21219
21220 - out_free_port_info:
21221 - kfree(hba);
21222 - out:
21223 - return error;
21224 -}
21225 + if (!phy_info){
21226 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21227 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21228 + __FUNCTION__, hot_plug_info->id, __LINE__));
21229 + break;
21230 + }
21231
21232 -static int
21233 -mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle)
21234 -{
21235 - struct mptsas_portinfo *port_info, *p, *ex;
21236 - struct device *parent;
21237 - struct sas_rphy *rphy;
21238 - int error = -ENOMEM, i, j;
21239 + starget = mptsas_get_starget(phy_info);
21240 + if (!starget) {
21241 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21242 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21243 + __FUNCTION__, hot_plug_info->id, __LINE__));
21244 + break;
21245 + }
21246
21247 - ex = kzalloc(sizeof(*port_info), GFP_KERNEL);
21248 - if (!ex)
21249 - goto out;
21250 + vtarget = starget->hostdata;
21251 + if (!vtarget) {
21252 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21253 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21254 + __FUNCTION__, hot_plug_info->id, __LINE__));
21255 + break;
21256 + }
21257
21258 - error = mptsas_sas_expander_pg0(ioc, ex,
21259 - (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
21260 - MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle);
21261 - if (error)
21262 - goto out_free_port_info;
21263 + mpt_findImVolumes(ioc);
21264
21265 - *handle = ex->phy_info[0].handle;
21266 + starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: "
21267 + "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
21268 + ioc->name, hot_plug_info->channel, hot_plug_info->id,
21269 + hot_plug_info->phys_disk_num, (unsigned long long)
21270 + sas_device.sas_address);
21271 +
21272 + vtarget->id = hot_plug_info->phys_disk_num;
21273 + vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
21274 + phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num;
21275 + mptsas_reprobe_target(starget, 1);
21276 + break;
21277
21278 - mutex_lock(&ioc->sas_topology_mutex);
21279 - port_info = mptsas_find_portinfo_by_handle(ioc, *handle);
21280 - if (!port_info) {
21281 - port_info = ex;
21282 - list_add_tail(&port_info->list, &ioc->sas_topology);
21283 - } else {
21284 - for (i = 0; i < ex->num_phys; i++) {
21285 - port_info->phy_info[i].handle =
21286 - ex->phy_info[i].handle;
21287 - port_info->phy_info[i].port_id =
21288 - ex->phy_info[i].port_id;
21289 + case MPTSAS_DEL_PHYSDISK_REPROBE:
21290 +
21291 + if (mptsas_sas_device_pg0(ioc, &sas_device,
21292 + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
21293 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21294 + (hot_plug_info->channel << 8) + hot_plug_info->id)) {
21295 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21296 + "%s: fw_id=%d exit at line=%d\n",
21297 + ioc->name, __FUNCTION__,
21298 + hot_plug_info->id, __LINE__));
21299 + break;
21300 }
21301 - kfree(ex->phy_info);
21302 - kfree(ex);
21303 - ex = NULL;
21304 - }
21305 - mutex_unlock(&ioc->sas_topology_mutex);
21306
21307 - for (i = 0; i < port_info->num_phys; i++) {
21308 - mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
21309 - (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
21310 - MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle);
21311 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
21312 + sas_device.sas_address);
21313 + if (!phy_info) {
21314 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21315 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21316 + __FUNCTION__, hot_plug_info->id, __LINE__));
21317 + break;
21318 + }
21319
21320 - if (port_info->phy_info[i].identify.handle) {
21321 - mptsas_sas_device_pg0(ioc,
21322 - &port_info->phy_info[i].identify,
21323 - (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
21324 - MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21325 - port_info->phy_info[i].identify.handle);
21326 - port_info->phy_info[i].identify.phy_id =
21327 - port_info->phy_info[i].phy_id;
21328 + starget = mptsas_get_starget(phy_info);
21329 + if (!starget) {
21330 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21331 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21332 + __FUNCTION__, hot_plug_info->id, __LINE__));
21333 + break;
21334 }
21335
21336 - if (port_info->phy_info[i].attached.handle) {
21337 - mptsas_sas_device_pg0(ioc,
21338 - &port_info->phy_info[i].attached,
21339 - (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
21340 - MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
21341 - port_info->phy_info[i].attached.handle);
21342 - port_info->phy_info[i].attached.phy_id =
21343 - port_info->phy_info[i].phy_id;
21344 + vtarget = starget->hostdata;
21345 + if (!vtarget) {
21346 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21347 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21348 + __FUNCTION__, hot_plug_info->id, __LINE__));
21349 + break;
21350 }
21351 - }
21352
21353 - parent = &ioc->sh->shost_gendev;
21354 - for (i = 0; i < port_info->num_phys; i++) {
21355 - mutex_lock(&ioc->sas_topology_mutex);
21356 - list_for_each_entry(p, &ioc->sas_topology, list) {
21357 - for (j = 0; j < p->num_phys; j++) {
21358 - if (port_info->phy_info[i].identify.handle !=
21359 - p->phy_info[j].attached.handle)
21360 - continue;
21361 - rphy = mptsas_get_rphy(&p->phy_info[j]);
21362 - parent = &rphy->dev;
21363 - }
21364 + if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) {
21365 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
21366 + "%s: fw_id=%d exit at line=%d\n", ioc->name,
21367 + __FUNCTION__, hot_plug_info->id, __LINE__));
21368 + break;
21369 }
21370 - mutex_unlock(&ioc->sas_topology_mutex);
21371 - }
21372
21373 - mptsas_setup_wide_ports(ioc, port_info);
21374 + mpt_findImVolumes(ioc);
21375 +
21376 + starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:"
21377 + " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n",
21378 + ioc->name, hot_plug_info->channel, hot_plug_info->id,
21379 + hot_plug_info->phys_disk_num, (unsigned long long)
21380 + sas_device.sas_address);
21381 +
21382 + vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
21383 + vtarget->id = hot_plug_info->id;
21384 + phy_info->attached.phys_disk_num = ~0;
21385 + mptsas_reprobe_target(starget, 0);
21386 + mptsas_add_device_component_by_fw(ioc,
21387 + hot_plug_info->channel, hot_plug_info->id);
21388 + break;
21389 +
21390 + case MPTSAS_ADD_RAID:
21391 +
21392 + mpt_findImVolumes(ioc);
21393 + printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
21394 + "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
21395 + hot_plug_info->id);
21396 + scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
21397 + hot_plug_info->id, 0);
21398 + break;
21399 +
21400 + case MPTSAS_DEL_RAID:
21401 +
21402 + mpt_findImVolumes(ioc);
21403 + printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
21404 + "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
21405 + hot_plug_info->id);
21406 + scsi_remove_device(hot_plug_info->sdev);
21407 + scsi_device_put(hot_plug_info->sdev);
21408 + break;
21409
21410 - for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
21411 - mptsas_probe_one_phy(parent, &port_info->phy_info[i],
21412 - ioc->sas_index, 0);
21413 + case MPTSAS_ADD_INACTIVE_VOLUME:
21414
21415 - return 0;
21416 + mpt_findImVolumes(ioc);
21417 + mptsas_adding_inactive_raid_components(ioc,
21418 + hot_plug_info->channel, hot_plug_info->id);
21419 + break;
21420
21421 - out_free_port_info:
21422 - if (ex) {
21423 - kfree(ex->phy_info);
21424 - kfree(ex);
21425 + default:
21426 + break;
21427 }
21428 - out:
21429 - return error;
21430 +
21431 + mptsas_free_fw_event(ioc, fw_event);
21432 }
21433
21434 -/*
21435 - * mptsas_delete_expander_phys
21436 +/**
21437 + * mptsas_send_sas_event
21438 *
21439 *
21440 - * This will traverse topology, and remove expanders
21441 - * that are no longer present
21442 - */
21443 + * @ioc
21444 + * @sas_event_data
21445 + *
21446 + **/
21447 static void
21448 -mptsas_delete_expander_phys(MPT_ADAPTER *ioc)
21449 +mptsas_send_sas_event(struct fw_event_work *fw_event)
21450 {
21451 - struct mptsas_portinfo buffer;
21452 - struct mptsas_portinfo *port_info, *n, *parent;
21453 - struct mptsas_phyinfo *phy_info;
21454 - struct sas_port * port;
21455 - int i;
21456 - u64 expander_sas_address;
21457 + MPT_ADAPTER *ioc;
21458 + struct mptsas_hotplug_event hot_plug_info;
21459 + EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data;
21460 + u32 device_info;
21461 + u64 sas_address;
21462
21463 - mutex_lock(&ioc->sas_topology_mutex);
21464 - list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) {
21465 + ioc = fw_event->ioc;
21466 + sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)
21467 + fw_event->event_data;
21468 + device_info = le32_to_cpu(sas_event_data->DeviceInfo);
21469
21470 - if (port_info->phy_info &&
21471 - (!(port_info->phy_info[0].identify.device_info &
21472 - MPI_SAS_DEVICE_INFO_SMP_TARGET)))
21473 - continue;
21474 + if ((device_info &
21475 + (MPI_SAS_DEVICE_INFO_SSP_TARGET |
21476 + MPI_SAS_DEVICE_INFO_STP_TARGET |
21477 + MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0) {
21478 + mptsas_free_fw_event(ioc, fw_event);
21479 + return;
21480 + }
21481
21482 - if (mptsas_sas_expander_pg0(ioc, &buffer,
21483 - (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
21484 - MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
21485 - port_info->phy_info[0].handle)) {
21486 + if (sas_event_data->ReasonCode ==
21487 + MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) {
21488 + mptbase_sas_persist_operation(ioc,
21489 + MPI_SAS_OP_CLEAR_NOT_PRESENT);
21490 + mptsas_free_fw_event(ioc, fw_event);
21491 + return;
21492 + }
21493
21494 - /*
21495 - * Obtain the port_info instance to the parent port
21496 - */
21497 - parent = mptsas_find_portinfo_by_handle(ioc,
21498 - port_info->phy_info[0].identify.handle_parent);
21499 + switch (sas_event_data->ReasonCode) {
21500 + case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
21501 + case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
21502 + memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
21503 + hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle);
21504 + hot_plug_info.channel = sas_event_data->Bus;
21505 + hot_plug_info.id = sas_event_data->TargetID;
21506 + hot_plug_info.phy_id = sas_event_data->PhyNum;
21507 + memcpy(&sas_address, &sas_event_data->SASAddress,
21508 + sizeof(u64));
21509 + hot_plug_info.sas_address = le64_to_cpu(sas_address);
21510 + hot_plug_info.device_info = device_info;
21511 + if (sas_event_data->ReasonCode &
21512 + MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
21513 + hot_plug_info.event_type = MPTSAS_ADD_DEVICE;
21514 + else
21515 + hot_plug_info.event_type = MPTSAS_DEL_DEVICE;
21516 + mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
21517 + break;
21518 +
21519 + case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
21520 + mptbase_sas_persist_operation(ioc,
21521 + MPI_SAS_OP_CLEAR_NOT_PRESENT);
21522 + mptsas_free_fw_event(ioc, fw_event);
21523 + break;
21524
21525 - if (!parent)
21526 - goto next_port;
21527 + case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
21528 + /* TODO */
21529 + case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
21530 + /* TODO */
21531 + default:
21532 + mptsas_free_fw_event(ioc, fw_event);
21533 + break;
21534 + }
21535 +}
21536
21537 - expander_sas_address =
21538 - port_info->phy_info[0].identify.sas_address;
21539
21540 - /*
21541 - * Delete rphys in the parent that point
21542 - * to this expander. The transport layer will
21543 - * cleanup all the children.
21544 - */
21545 - phy_info = parent->phy_info;
21546 - for (i = 0; i < parent->num_phys; i++, phy_info++) {
21547 - port = mptsas_get_port(phy_info);
21548 - if (!port)
21549 - continue;
21550 - if (phy_info->attached.sas_address !=
21551 - expander_sas_address)
21552 - continue;
21553 - dsaswideprintk(ioc,
21554 - dev_printk(KERN_DEBUG, &port->dev,
21555 - MYIOC_s_FMT "delete port (%d)\n", ioc->name,
21556 - port->port_identifier));
21557 - sas_port_delete(port);
21558 - mptsas_port_delete(ioc, phy_info->port_details);
21559 - }
21560 - next_port:
21561 -
21562 - phy_info = port_info->phy_info;
21563 - for (i = 0; i < port_info->num_phys; i++, phy_info++)
21564 - mptsas_port_delete(ioc, phy_info->port_details);
21565 -
21566 - list_del(&port_info->list);
21567 - kfree(port_info->phy_info);
21568 - kfree(port_info);
21569 +/**
21570 + * mptsas_send_raid_event
21571 + *
21572 + *
21573 + * @ioc
21574 + * @raid_event_data
21575 + *
21576 + **/
21577 +static void
21578 +mptsas_send_raid_event(struct fw_event_work *fw_event)
21579 +{
21580 + MPT_ADAPTER *ioc;
21581 + EVENT_DATA_RAID *raid_event_data;
21582 + struct mptsas_hotplug_event hot_plug_info;
21583 + int status;
21584 + int state;
21585 + struct scsi_device *sdev = NULL;
21586 + VirtDevice *vdevice = NULL;
21587 + RaidPhysDiskPage0_t phys_disk;
21588 +
21589 + ioc = fw_event->ioc;
21590 + raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data;
21591 + status = le32_to_cpu(raid_event_data->SettingsStatus);
21592 + state = (status >> 8) & 0xff;
21593 +
21594 + memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
21595 + hot_plug_info.id = raid_event_data->VolumeID;
21596 + hot_plug_info.channel = raid_event_data->VolumeBus;
21597 + hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum;
21598 +
21599 + if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED ||
21600 + raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED ||
21601 + raid_event_data->ReasonCode ==
21602 + MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) {
21603 + sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
21604 + hot_plug_info.id, 0);
21605 + hot_plug_info.sdev = sdev;
21606 + if (sdev)
21607 + vdevice = sdev->hostdata;
21608 + }
21609 +
21610 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "Entering %s: "
21611 + "ReasonCode=%02x\n", ioc->name, __FUNCTION__,
21612 + raid_event_data->ReasonCode));
21613 +
21614 + switch (raid_event_data->ReasonCode) {
21615 + case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
21616 + hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE;
21617 + break;
21618 + case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
21619 + hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE;
21620 + break;
21621 + case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
21622 + switch (state) {
21623 + case MPI_PD_STATE_ONLINE:
21624 + case MPI_PD_STATE_NOT_COMPATIBLE:
21625 + mpt_raid_phys_disk_pg0(ioc,
21626 + raid_event_data->PhysDiskNum, &phys_disk);
21627 + hot_plug_info.id = phys_disk.PhysDiskID;
21628 + hot_plug_info.channel = phys_disk.PhysDiskBus;
21629 + hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
21630 + break;
21631 + case MPI_PD_STATE_FAILED:
21632 + case MPI_PD_STATE_MISSING:
21633 + case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
21634 + case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
21635 + case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
21636 + hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
21637 + break;
21638 + default:
21639 + break;
21640 }
21641 - /*
21642 - * Free this memory allocated from inside
21643 - * mptsas_sas_expander_pg0
21644 - */
21645 - kfree(buffer.phy_info);
21646 + break;
21647 + case MPI_EVENT_RAID_RC_VOLUME_DELETED:
21648 + if (!sdev)
21649 + break;
21650 + vdevice->vtarget->deleted = 1; /* block IO */
21651 + hot_plug_info.event_type = MPTSAS_DEL_RAID;
21652 + break;
21653 + case MPI_EVENT_RAID_RC_VOLUME_CREATED:
21654 + if (sdev) {
21655 + scsi_device_put(sdev);
21656 + break;
21657 + }
21658 + hot_plug_info.event_type = MPTSAS_ADD_RAID;
21659 + break;
21660 + case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
21661 + if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) {
21662 + if (!sdev)
21663 + break;
21664 + vdevice->vtarget->deleted = 1; /* block IO */
21665 + hot_plug_info.event_type = MPTSAS_DEL_RAID;
21666 + break;
21667 + }
21668 + switch (state) {
21669 + case MPI_RAIDVOL0_STATUS_STATE_FAILED:
21670 + case MPI_RAIDVOL0_STATUS_STATE_MISSING:
21671 + if (!sdev)
21672 + break;
21673 + vdevice->vtarget->deleted = 1; /* block IO */
21674 + hot_plug_info.event_type = MPTSAS_DEL_RAID;
21675 + break;
21676 + case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
21677 + case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
21678 + if (sdev) {
21679 + scsi_device_put(sdev);
21680 + break;
21681 + }
21682 + hot_plug_info.event_type = MPTSAS_ADD_RAID;
21683 + break;
21684 + default:
21685 + break;
21686 + }
21687 + break;
21688 + default:
21689 + break;
21690 }
21691 - mutex_unlock(&ioc->sas_topology_mutex);
21692 +
21693 + if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT)
21694 + mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
21695 + else
21696 + mptsas_free_fw_event(ioc, fw_event);
21697 }
21698
21699 -/*
21700 - * Start of day discovery
21701 - */
21702 -static void
21703 -mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
21704 +/**
21705 + * mptsas_issue_tm - send mptsas internal tm request
21706 + * @ioc: Pointer to MPT_ADAPTER structure
21707 + * @type
21708 + * @channel
21709 + * @id
21710 + * @lun
21711 + * @task_context
21712 + * @timeout
21713 + *
21714 + * return:
21715 + *
21716 + **/
21717 +static int
21718 +mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun, int task_context, ulong timeout,
21719 + u8 *issue_reset)
21720 {
21721 - u32 handle = 0xFFFF;
21722 - int i;
21723 + MPT_FRAME_HDR *mf;
21724 + SCSITaskMgmt_t *pScsiTm;
21725 + int retval;
21726 + unsigned long timeleft;
21727
21728 - mutex_lock(&ioc->sas_discovery_mutex);
21729 - mptsas_probe_hba_phys(ioc);
21730 - while (!mptsas_probe_expander_phys(ioc, &handle))
21731 - ;
21732 - /*
21733 - Reporting RAID volumes.
21734 - */
21735 - if (!ioc->ir_firmware)
21736 + *issue_reset = 0;
21737 + if ((mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc)) == NULL) {
21738 + retval = -1; /* return failure */
21739 + dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no "
21740 + "msg frames!!\n", ioc->name));
21741 goto out;
21742 - if (!ioc->raid_data.pIocPg2)
21743 + }
21744 +
21745 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, "
21746 + "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, "
21747 + "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf,
21748 + type, timeout, channel, id, (unsigned long long)lun,
21749 + task_context));
21750 +
21751 + pScsiTm = (SCSITaskMgmt_t *) mf;
21752 + memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
21753 + pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
21754 + pScsiTm->TaskType = type;
21755 + pScsiTm->MsgFlags = 0;
21756 + pScsiTm->TargetID = id;
21757 + pScsiTm->Bus = channel;
21758 + pScsiTm->ChainOffset = 0;
21759 + pScsiTm->Reserved = 0;
21760 + pScsiTm->Reserved1 = 0;
21761 + pScsiTm->TaskMsgContext = task_context;
21762 + int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
21763 +
21764 + INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
21765 + CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
21766 + retval = 0;
21767 + mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf);
21768 +
21769 + /* Now wait for the command to complete */
21770 + timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done,
21771 + timeout*HZ);
21772 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
21773 + retval = -1; /* return failure */
21774 + dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
21775 + "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf));
21776 + mpt_free_msg_frame(ioc, mf);
21777 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
21778 + goto out;
21779 + *issue_reset = 1;
21780 goto out;
21781 - if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
21782 + }
21783 +
21784 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
21785 + retval = -1; /* return failure */
21786 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
21787 + "TaskMgmt request: failed with no reply\n", ioc->name));
21788 goto out;
21789 - for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
21790 - scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
21791 - ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
21792 }
21793 +
21794 out:
21795 - mutex_unlock(&ioc->sas_discovery_mutex);
21796 + CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
21797 + return retval;
21798 }
21799
21800 -/*
21801 - * Work queue thread to handle Runtime discovery
21802 - * Mere purpose is the hot add/delete of expanders
21803 - *(Mutex UNLOCKED)
21804 - */
21805 +/**
21806 + * mptsas_broadcast_primative_work - Work queue thread to handle
21807 + * broadcast primitive events
21808 + * @work: work queue payload containing info describing the event
21809 + *
21810 + **/
21811 static void
21812 -__mptsas_discovery_work(MPT_ADAPTER *ioc)
21813 +mptsas_broadcast_primative_work(struct fw_event_work *fw_event)
21814 {
21815 - u32 handle = 0xFFFF;
21816 + MPT_ADAPTER *ioc = fw_event->ioc;
21817 + MPT_FRAME_HDR *mf;
21818 + VirtDevice *vdevice;
21819 + int ii;
21820 + struct scsi_cmnd *sc;
21821 + SCSITaskMgmtReply_t * pScsiTmReply;
21822 + u8 issue_reset;
21823 + int task_context;
21824 + u8 channel, id;
21825 + int lun;
21826 + u32 termination_count;
21827 + u32 query_count;
21828 +
21829 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
21830 + "%s - enter\n", ioc->name, __FUNCTION__));
21831 +
21832 + mutex_lock(&ioc->taskmgmt_cmds.mutex);
21833 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
21834 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
21835 + mptsas_requeue_fw_event(ioc, fw_event, 1000);
21836 + return;
21837 + }
21838
21839 - ioc->sas_discovery_runtime=1;
21840 - mptsas_delete_expander_phys(ioc);
21841 - mptsas_probe_hba_phys(ioc);
21842 - while (!mptsas_probe_expander_phys(ioc, &handle))
21843 - ;
21844 - ioc->sas_discovery_runtime=0;
21845 + issue_reset = 0;
21846 + termination_count = 0;
21847 + query_count = 0;
21848 + mpt_findImVolumes(ioc);
21849 + pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
21850 +
21851 + for (ii = 0; ii < ioc->req_depth; ii++) {
21852 + sc = mptscsih_get_scsi_lookup(ioc, ii);
21853 + if (!sc)
21854 + continue;
21855 + mf = MPT_INDEX_2_MFPTR(ioc, ii);
21856 + if (!mf)
21857 + continue;
21858 + task_context = mf->u.frame.hwhdr.msgctxu.MsgContext;
21859 + vdevice = sc->device->hostdata;
21860 + if (!vdevice || !vdevice->vtarget)
21861 + continue;
21862 + if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)
21863 + continue; /* skip hidden raid components */
21864 + if (vdevice->vtarget->raidVolume)
21865 + continue; /* skip hidden raid components */
21866 + channel = vdevice->vtarget->channel;
21867 + id = vdevice->vtarget->id;
21868 + lun = vdevice->lun;
21869 + if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK,
21870 + channel, id, (u64)lun, task_context, 30, &issue_reset))
21871 + goto out;
21872 + query_count++;
21873 + termination_count +=
21874 + le32_to_cpu(pScsiTmReply->TerminationCount);
21875 + if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) &&
21876 + (pScsiTmReply->ResponseCode ==
21877 + MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
21878 + pScsiTmReply->ResponseCode ==
21879 + MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC))
21880 + continue;
21881 + if (mptsas_issue_tm(ioc,
21882 + MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET,
21883 + channel, id, (u64)lun, 0, 30, &issue_reset))
21884 + goto out;
21885 + termination_count +=
21886 + le32_to_cpu(pScsiTmReply->TerminationCount);
21887 + }
21888 +
21889 + out:
21890 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
21891 + "%s - exit, query_count = %d termination_count = %d\n",
21892 + ioc->name, __FUNCTION__, query_count, termination_count));
21893 +
21894 + ioc->broadcast_aen_busy = 0;
21895 + mpt_clear_taskmgmt_in_progress_flag(ioc);
21896 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
21897 +
21898 + if (issue_reset) {
21899 + printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
21900 + ioc->name, __FUNCTION__);
21901 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP))
21902 + mpt_HardResetHandler(ioc, CAN_SLEEP);
21903 + }
21904 + mptsas_free_fw_event(ioc, fw_event);
21905 }
21906
21907 -/*
21908 - * Work queue thread to handle Runtime discovery
21909 - * Mere purpose is the hot add/delete of expanders
21910 - *(Mutex LOCKED)
21911 - */
21912 +/**
21913 + * mptsas_send_ir2_event - handle exposing hidden disk when an inactive raid volume is added
21914 + * @ioc: Pointer to MPT_ADAPTER structure
21915 + * @ir2_data:
21916 + *
21917 + **/
21918 static void
21919 -mptsas_discovery_work(struct work_struct *work)
21920 +mptsas_send_ir2_event(struct fw_event_work *fw_event)
21921 {
21922 - struct mptsas_discovery_event *ev =
21923 - container_of(work, struct mptsas_discovery_event, work);
21924 - MPT_ADAPTER *ioc = ev->ioc;
21925 -
21926 - mutex_lock(&ioc->sas_discovery_mutex);
21927 - __mptsas_discovery_work(ioc);
21928 - mutex_unlock(&ioc->sas_discovery_mutex);
21929 - kfree(ev);
21930 + MPT_ADAPTER *ioc;
21931 + struct mptsas_hotplug_event hot_plug_info;
21932 + MPI_EVENT_DATA_IR2 * ir2_data;
21933 + u8 reasonCode;
21934 + RaidPhysDiskPage0_t phys_disk;
21935 +
21936 + ioc = fw_event->ioc;
21937 + ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data;
21938 + reasonCode = ir2_data->ReasonCode;
21939 +
21940 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "Entering %s: "
21941 + "ReasonCode=%02x\n", ioc->name,__FUNCTION__, reasonCode));
21942 +
21943 + memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event));
21944 + hot_plug_info.id = ir2_data->TargetID;
21945 + hot_plug_info.channel = ir2_data->Bus;
21946 + switch (reasonCode) {
21947 + case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
21948 + hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME;
21949 + break;
21950 + case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED:
21951 + hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
21952 + hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK;
21953 + break;
21954 + case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED:
21955 + hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum;
21956 + mpt_raid_phys_disk_pg0(ioc,
21957 + ir2_data->PhysDiskNum, &phys_disk);
21958 + hot_plug_info.id = phys_disk.PhysDiskID;
21959 + hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK;
21960 + break;
21961 + default:
21962 + mptsas_free_fw_event(ioc, fw_event);
21963 + return;
21964 + }
21965 + mptsas_hotplug_work(ioc, fw_event, &hot_plug_info);
21966 }
21967
21968 -static struct mptsas_phyinfo *
21969 -mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address)
21970 +static void
21971 +mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
21972 {
21973 - struct mptsas_portinfo *port_info;
21974 - struct mptsas_phyinfo *phy_info = NULL;
21975 - int i;
21976 + struct mptsas_portinfo *parent;
21977 + struct device *parent_dev;
21978 + struct sas_rphy *rphy;
21979 + int i;
21980 + u64 sas_address; /* expander sas address */
21981 + u32 handle;
21982
21983 - mutex_lock(&ioc->sas_topology_mutex);
21984 - list_for_each_entry(port_info, &ioc->sas_topology, list) {
21985 - for (i = 0; i < port_info->num_phys; i++) {
21986 - if (!mptsas_is_end_device(
21987 - &port_info->phy_info[i].attached))
21988 - continue;
21989 - if (port_info->phy_info[i].attached.sas_address
21990 - != sas_address)
21991 - continue;
21992 - phy_info = &port_info->phy_info[i];
21993 - break;
21994 - }
21995 - }
21996 - mutex_unlock(&ioc->sas_topology_mutex);
21997 - return phy_info;
21998 -}
21999 + handle = port_info->phy_info[0].handle;
22000 + sas_address = port_info->phy_info[0].identify.sas_address;
22001 + for (i = 0; i < port_info->num_phys; i++) {
22002 + mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i],
22003 + (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM <<
22004 + MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle);
22005
22006 -static struct mptsas_phyinfo *
22007 -mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id)
22008 -{
22009 - struct mptsas_portinfo *port_info;
22010 - struct mptsas_phyinfo *phy_info = NULL;
22011 - int i;
22012 + mptsas_sas_device_pg0(ioc,
22013 + &port_info->phy_info[i].identify,
22014 + (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
22015 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
22016 + port_info->phy_info[i].identify.handle);
22017 + port_info->phy_info[i].identify.phy_id =
22018 + port_info->phy_info[i].phy_id;
22019
22020 - mutex_lock(&ioc->sas_topology_mutex);
22021 - list_for_each_entry(port_info, &ioc->sas_topology, list) {
22022 - for (i = 0; i < port_info->num_phys; i++) {
22023 - if (!mptsas_is_end_device(
22024 - &port_info->phy_info[i].attached))
22025 - continue;
22026 - if (port_info->phy_info[i].attached.id != id)
22027 - continue;
22028 - if (port_info->phy_info[i].attached.channel != channel)
22029 - continue;
22030 - phy_info = &port_info->phy_info[i];
22031 - break;
22032 + if (port_info->phy_info[i].attached.handle) {
22033 + mptsas_sas_device_pg0(ioc,
22034 + &port_info->phy_info[i].attached,
22035 + (MPI_SAS_DEVICE_PGAD_FORM_HANDLE <<
22036 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
22037 + port_info->phy_info[i].attached.handle);
22038 + port_info->phy_info[i].attached.phy_id =
22039 + port_info->phy_info[i].phy_id;
22040 }
22041 }
22042 - mutex_unlock(&ioc->sas_topology_mutex);
22043 - return phy_info;
22044 -}
22045 -
22046 -static struct mptsas_phyinfo *
22047 -mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
22048 -{
22049 - struct mptsas_portinfo *port_info;
22050 - struct mptsas_phyinfo *phy_info = NULL;
22051 - int i;
22052
22053 mutex_lock(&ioc->sas_topology_mutex);
22054 - list_for_each_entry(port_info, &ioc->sas_topology, list) {
22055 - for (i = 0; i < port_info->num_phys; i++) {
22056 - if (!mptsas_is_end_device(
22057 - &port_info->phy_info[i].attached))
22058 - continue;
22059 - if (port_info->phy_info[i].attached.phys_disk_num == ~0)
22060 - continue;
22061 - if (port_info->phy_info[i].attached.phys_disk_num != id)
22062 - continue;
22063 - if (port_info->phy_info[i].attached.channel != channel)
22064 - continue;
22065 - phy_info = &port_info->phy_info[i];
22066 - break;
22067 + parent = mptsas_find_portinfo_by_handle(ioc,
22068 + port_info->phy_info[0].identify.handle_parent);
22069 + if (!parent) {
22070 + mutex_unlock(&ioc->sas_topology_mutex);
22071 + return;
22072 + }
22073 + for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev;
22074 + i++) {
22075 + if (parent->phy_info[i].attached.sas_address == sas_address) {
22076 + rphy = mptsas_get_rphy(&parent->phy_info[i]);
22077 + parent_dev = &rphy->dev;
22078 }
22079 }
22080 mutex_unlock(&ioc->sas_topology_mutex);
22081 - return phy_info;
22082 +
22083 + mptsas_setup_wide_ports(ioc, port_info);
22084 + for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++)
22085 + mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i],
22086 + ioc->sas_index, 0);
22087 }
22088
22089 -/*
22090 - * Work queue thread to clear the persitency table
22091 - */
22092 static void
22093 -mptsas_persist_clear_table(struct work_struct *work)
22094 +mptsas_expander_event_add(MPT_ADAPTER *ioc,
22095 + MpiEventDataSasExpanderStatusChange_t* expander_data)
22096 {
22097 - MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task);
22098 + struct mptsas_portinfo *port_info;
22099 + int i;
22100 + __le64 sas_address;
22101
22102 - mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT);
22103 -}
22104 + port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
22105 + if (!port_info)
22106 + BUG();
22107 + port_info->num_phys = (expander_data->NumPhys) ?
22108 + expander_data->NumPhys : 1;
22109 + port_info->phy_info = kcalloc(port_info->num_phys,
22110 + sizeof(struct mptsas_phyinfo),GFP_KERNEL);
22111 + if (!port_info->phy_info)
22112 + BUG();
22113 + memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
22114 + for (i = 0; i < port_info->num_phys; i++) {
22115 + port_info->phy_info[i].portinfo = port_info;
22116 + port_info->phy_info[i].handle =
22117 + le16_to_cpu(expander_data->DevHandle);
22118 + port_info->phy_info[i].identify.sas_address =
22119 + le64_to_cpu(sas_address);
22120 + port_info->phy_info[i].identify.handle_parent =
22121 + le16_to_cpu(expander_data->ParentDevHandle);
22122 + }
22123
22124 -static void
22125 -mptsas_reprobe_lun(struct scsi_device *sdev, void *data)
22126 -{
22127 - int rc;
22128 + mutex_lock(&ioc->sas_topology_mutex);
22129 + list_add_tail(&port_info->list, &ioc->sas_topology);
22130 + mutex_unlock(&ioc->sas_topology_mutex);
22131
22132 - sdev->no_uld_attach = data ? 1 : 0;
22133 - rc = scsi_device_reprobe(sdev);
22134 -}
22135 + printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
22136 + "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
22137 + (unsigned long long)sas_address);
22138
22139 -static void
22140 -mptsas_reprobe_target(struct scsi_target *starget, int uld_attach)
22141 -{
22142 - starget_for_each_device(starget, uld_attach ? (void *)1 : NULL,
22143 - mptsas_reprobe_lun);
22144 + mptsas_expander_refresh(ioc, port_info);
22145 }
22146
22147 +/**
22148 + * mptsas_delete_expander_siblings - remove siblings attached to expander
22149 + * @ioc: Pointer to MPT_ADAPTER structure
22150 + * @parent: the parent port_info object
22151 + * @expander: the expander port_info object
22152 + **/
22153 static void
22154 -mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id)
22155 +mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo
22156 + *parent, struct mptsas_portinfo *expander)
22157 {
22158 - CONFIGPARMS cfg;
22159 - ConfigPageHeader_t hdr;
22160 - dma_addr_t dma_handle;
22161 - pRaidVolumePage0_t buffer = NULL;
22162 - RaidPhysDiskPage0_t phys_disk;
22163 - int i;
22164 - struct mptsas_hotplug_event *ev;
22165 + struct mptsas_phyinfo *phy_info;
22166 + struct mptsas_portinfo *port_info;
22167 + struct sas_rphy *rphy;
22168 + int i;
22169
22170 - memset(&cfg, 0 , sizeof(CONFIGPARMS));
22171 - memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
22172 - hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
22173 - cfg.pageAddr = (channel << 8) + id;
22174 - cfg.cfghdr.hdr = &hdr;
22175 - cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
22176 + phy_info = expander->phy_info;
22177 + for (i = 0; i < expander->num_phys; i++, phy_info++) {
22178 + if (!(rphy = mptsas_get_rphy(phy_info)))
22179 + continue;
22180 + if (rphy->identify.device_type == SAS_END_DEVICE)
22181 + mptsas_del_end_device(ioc, phy_info);
22182 + }
22183
22184 - if (mpt_config(ioc, &cfg) != 0)
22185 - goto out;
22186 + phy_info = expander->phy_info;
22187 + for (i = 0; i < expander->num_phys; i++, phy_info++) {
22188 + if (!(rphy = mptsas_get_rphy(phy_info)))
22189 + continue;
22190 + if (rphy->identify.device_type ==
22191 + MPI_SAS_DEVICE_INFO_EDGE_EXPANDER ||
22192 + rphy->identify.device_type ==
22193 + MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) {
22194 + port_info = mptsas_find_portinfo_by_sas_address(ioc,
22195 + rphy->identify.sas_address);
22196 + if (!port_info)
22197 + continue;
22198 + if (port_info == parent) /* backlink rphy */
22199 + continue;
22200 + mptsas_expander_delete(ioc, port_info);
22201 + }
22202 + }
22203 +}
22204
22205 - if (!hdr.PageLength)
22206 - goto out;
22207
22208 - buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
22209 - &dma_handle);
22210 +/**
22211 + * mptsas_expander_delete - remove this expander
22212 + * @ioc: Pointer to MPT_ADAPTER structure
22213 + * @port_info: expander port_info struct
22214 + *
22215 + **/
22216
22217 - if (!buffer)
22218 - goto out;
22219 +static void
22220 +mptsas_expander_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info)
22221 +{
22222
22223 - cfg.physAddr = dma_handle;
22224 - cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
22225 + struct mptsas_portinfo *parent;
22226 + int i;
22227 + u64 expander_sas_address;
22228 + struct mptsas_phyinfo *phy_info;
22229 + struct mptsas_portinfo buffer;
22230 + struct mptsas_portinfo_details * port_details;
22231 + struct sas_port * port;
22232
22233 - if (mpt_config(ioc, &cfg) != 0)
22234 - goto out;
22235 + if (!port_info)
22236 + return;
22237
22238 - if (!(buffer->VolumeStatus.Flags &
22239 - MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE))
22240 - goto out;
22241 + /* see if expander is still there before deleting */
22242 + mptsas_sas_expander_pg0(ioc, &buffer,
22243 + (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
22244 + MPI_SAS_EXPAND_PGAD_FORM_SHIFT),
22245 + port_info->phy_info[0].identify.handle);
22246
22247 - if (!buffer->NumPhysDisks)
22248 - goto out;
22249 + if (buffer.num_phys) {
22250 + kfree(buffer.phy_info);
22251 + return;
22252 + }
22253
22254 - for (i = 0; i < buffer->NumPhysDisks; i++) {
22255
22256 - if (mpt_raid_phys_disk_pg0(ioc,
22257 - buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
22258 - continue;
22259 + /*
22260 + * Obtain the port_info instance to the parent port
22261 + */
22262 + port_details = NULL;
22263 + expander_sas_address =
22264 + port_info->phy_info[0].identify.sas_address;
22265 + parent = mptsas_find_portinfo_by_handle(ioc,
22266 + port_info->phy_info[0].identify.handle_parent);
22267 + mptsas_delete_expander_siblings(ioc, parent, port_info);
22268 + if (!parent)
22269 + goto out;
22270
22271 - ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
22272 - if (!ev) {
22273 - printk(MYIOC_s_WARN_FMT "mptsas: lost hotplug event\n", ioc->name);
22274 - goto out;
22275 + /*
22276 + * Delete rphys in the parent that point
22277 + * to this expander.
22278 + */
22279 + phy_info = parent->phy_info;
22280 + port = NULL;
22281 + for (i = 0; i < parent->num_phys; i++, phy_info++) {
22282 + if(!phy_info->phy)
22283 + continue;
22284 + if (phy_info->attached.sas_address !=
22285 + expander_sas_address)
22286 + continue;
22287 + if (!port) {
22288 + port = mptsas_get_port(phy_info);
22289 + port_details = phy_info->port_details;
22290 }
22291 -
22292 - INIT_WORK(&ev->work, mptsas_hotplug_work);
22293 - ev->ioc = ioc;
22294 - ev->id = phys_disk.PhysDiskID;
22295 - ev->channel = phys_disk.PhysDiskBus;
22296 - ev->phys_disk_num_valid = 1;
22297 - ev->phys_disk_num = phys_disk.PhysDiskNum;
22298 - ev->event_type = MPTSAS_ADD_DEVICE;
22299 - schedule_work(&ev->work);
22300 + dev_printk(KERN_DEBUG, &phy_info->phy->dev,
22301 + MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name,
22302 + phy_info->phy_id, phy_info->phy);
22303 + sas_port_delete_phy(port, phy_info->phy);
22304 + }
22305 + if (port) {
22306 + dev_printk(KERN_DEBUG, &port->dev,
22307 + MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n",
22308 + ioc->name, port->port_identifier,
22309 + (unsigned long long)expander_sas_address);
22310 + sas_port_delete(port);
22311 + mptsas_port_delete(ioc, port_details);
22312 }
22313 -
22314 out:
22315 - if (buffer)
22316 - pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
22317 - dma_handle);
22318 +
22319 + printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, "
22320 + "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
22321 + (unsigned long long)expander_sas_address);
22322 +
22323 + /*
22324 + * free link
22325 + */
22326 + list_del(&port_info->list);
22327 + kfree(port_info->phy_info);
22328 + kfree(port_info);
22329 }
22330 -/*
22331 - * Work queue thread to handle SAS hotplug events
22332 +
22333 +
22334 +/**
22335 + * mptsas_send_expander_event - expanders events
22336 + * @ioc: Pointer to MPT_ADAPTER structure
22337 + * @expander_data: event data
22338 + *
22339 + *
22340 + * This function handles adding, removing, and refreshing
22341 + * device handles within the expander objects.
22342 */
22343 static void
22344 -mptsas_hotplug_work(struct work_struct *work)
22345 +mptsas_send_expander_event(struct fw_event_work *fw_event)
22346 {
22347 - struct mptsas_hotplug_event *ev =
22348 - container_of(work, struct mptsas_hotplug_event, work);
22349 + MPT_ADAPTER *ioc;
22350 + MpiEventDataSasExpanderStatusChange_t* expander_data;
22351 + struct mptsas_portinfo *port_info;
22352 + __le64 sas_address;
22353 + int i;
22354
22355 - MPT_ADAPTER *ioc = ev->ioc;
22356 - struct mptsas_phyinfo *phy_info;
22357 - struct sas_rphy *rphy;
22358 - struct sas_port *port;
22359 - struct scsi_device *sdev;
22360 - struct scsi_target * starget;
22361 - struct sas_identify identify;
22362 - char *ds = NULL;
22363 - struct mptsas_devinfo sas_device;
22364 - VirtTarget *vtarget;
22365 - VirtDevice *vdevice;
22366 + ioc = fw_event->ioc;
22367 + expander_data = (MpiEventDataSasExpanderStatusChange_t *)
22368 + fw_event->event_data;
22369 + memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64));
22370 + port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
22371 +
22372 + if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) {
22373 + if (port_info) {
22374 + for (i = 0; i < port_info->num_phys; i++) {
22375 + port_info->phy_info[i].portinfo = port_info;
22376 + port_info->phy_info[i].handle =
22377 + le16_to_cpu(expander_data->DevHandle);
22378 + port_info->phy_info[i].identify.sas_address =
22379 + le64_to_cpu(sas_address);
22380 + port_info->phy_info[i].identify.handle_parent =
22381 + le16_to_cpu(expander_data->ParentDevHandle);
22382 + }
22383 + mptsas_expander_refresh(ioc, port_info);
22384 + } else if (!port_info && expander_data->NumPhys)
22385 + mptsas_expander_event_add(ioc, expander_data);
22386 + } else if (expander_data->ReasonCode ==
22387 + MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING)
22388 + mptsas_expander_delete(ioc, port_info);
22389
22390 - mutex_lock(&ioc->sas_discovery_mutex);
22391 - switch (ev->event_type) {
22392 - case MPTSAS_DEL_DEVICE:
22393 + mptsas_free_fw_event(ioc, fw_event);
22394 +}
22395
22396 - phy_info = NULL;
22397 - if (ev->phys_disk_num_valid) {
22398 - if (ev->hidden_raid_component){
22399 - if (mptsas_sas_device_pg0(ioc, &sas_device,
22400 - (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
22401 - MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
22402 - (ev->channel << 8) + ev->id)) {
22403 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22404 - "%s: exit at line=%d\n", ioc->name,
22405 - __func__, __LINE__));
22406 - break;
22407 - }
22408 - phy_info = mptsas_find_phyinfo_by_sas_address(
22409 - ioc, sas_device.sas_address);
22410 - }else
22411 - phy_info = mptsas_find_phyinfo_by_phys_disk_num(
22412 - ioc, ev->channel, ev->phys_disk_num);
22413 - }
22414
22415 - if (!phy_info)
22416 - phy_info = mptsas_find_phyinfo_by_target(ioc,
22417 - ev->channel, ev->id);
22418 +/**
22419 + * mptsas_expander_add -
22420 + * @ioc: Pointer to MPT_ADAPTER structure
22421 + * @handle:
22422 + *
22423 + */
22424 +struct mptsas_portinfo *
22425 +mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle)
22426 +{
22427 + struct mptsas_portinfo buffer, *port_info;
22428 + int i;
22429
22430 - /*
22431 - * Sanity checks, for non-existing phys and remote rphys.
22432 - */
22433 - if (!phy_info){
22434 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22435 - "%s: exit at line=%d\n", ioc->name,
22436 - __func__, __LINE__));
22437 - break;
22438 - }
22439 - if (!phy_info->port_details) {
22440 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22441 - "%s: exit at line=%d\n", ioc->name,
22442 - __func__, __LINE__));
22443 - break;
22444 - }
22445 - rphy = mptsas_get_rphy(phy_info);
22446 - if (!rphy) {
22447 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22448 - "%s: exit at line=%d\n", ioc->name,
22449 - __func__, __LINE__));
22450 - break;
22451 - }
22452 + if ((mptsas_sas_expander_pg0(ioc, &buffer,
22453 + (MPI_SAS_EXPAND_PGAD_FORM_HANDLE <<
22454 + MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)))
22455 + return NULL;
22456
22457 - port = mptsas_get_port(phy_info);
22458 - if (!port) {
22459 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22460 - "%s: exit at line=%d\n", ioc->name,
22461 - __func__, __LINE__));
22462 - break;
22463 - }
22464 + port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC);
22465 + if (!port_info) {
22466 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22467 + "%s: exit at line=%d\n", ioc->name,
22468 + __FUNCTION__, __LINE__));
22469 + return NULL;
22470 + }
22471 + port_info->num_phys = buffer.num_phys;
22472 + port_info->phy_info = buffer.phy_info;
22473 + for (i = 0; i < port_info->num_phys; i++)
22474 + port_info->phy_info[i].portinfo = port_info;
22475 + mutex_lock(&ioc->sas_topology_mutex);
22476 + list_add_tail(&port_info->list, &ioc->sas_topology);
22477 + mutex_unlock(&ioc->sas_topology_mutex);
22478 + printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
22479 + "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
22480 + (unsigned long long)buffer.phy_info[0].identify.sas_address);
22481 + mptsas_expander_refresh(ioc, port_info);
22482 + return port_info;
22483 +}
22484
22485 - starget = mptsas_get_starget(phy_info);
22486 - if (starget) {
22487 - vtarget = starget->hostdata;
22488 +static void
22489 +mptsas_send_link_status_event(struct fw_event_work *fw_event)
22490 +{
22491 + MPT_ADAPTER *ioc;
22492 + MpiEventDataSasPhyLinkStatus_t *link_data;
22493 + struct mptsas_portinfo *port_info;
22494 + struct mptsas_phyinfo *phy_info = NULL;
22495 + __le64 sas_address;
22496 + u8 phy_num;
22497 + u8 link_rate;
22498
22499 - if (!vtarget) {
22500 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22501 - "%s: exit at line=%d\n", ioc->name,
22502 - __func__, __LINE__));
22503 - break;
22504 - }
22505 + ioc = fw_event->ioc;
22506 + link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data;
22507
22508 - /*
22509 - * Handling RAID components
22510 - */
22511 - if (ev->phys_disk_num_valid &&
22512 - ev->hidden_raid_component) {
22513 - printk(MYIOC_s_INFO_FMT
22514 - "RAID Hidding: channel=%d, id=%d, "
22515 - "physdsk %d \n", ioc->name, ev->channel,
22516 - ev->id, ev->phys_disk_num);
22517 - vtarget->id = ev->phys_disk_num;
22518 - vtarget->tflags |=
22519 - MPT_TARGET_FLAGS_RAID_COMPONENT;
22520 - mptsas_reprobe_target(starget, 1);
22521 - phy_info->attached.phys_disk_num =
22522 - ev->phys_disk_num;
22523 - break;
22524 + memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64));
22525 + sas_address = le64_to_cpu(sas_address);
22526 + link_rate = link_data->LinkRates >> 4;
22527 + phy_num = link_data->PhyNum;
22528 +
22529 + port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address);
22530 + if (port_info) {
22531 + phy_info = &port_info->phy_info[phy_num];
22532 + if (phy_info)
22533 + phy_info->negotiated_link_rate = link_rate;
22534 + }
22535 +
22536 + if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 ||
22537 + link_rate == MPI_SAS_IOUNIT0_RATE_3_0) {
22538 +
22539 + if (!port_info) {
22540 + if (ioc->old_sas_discovery_protocal) {
22541 + port_info = mptsas_expander_add(ioc,
22542 + le16_to_cpu(link_data->DevHandle));
22543 + if (port_info)
22544 + goto out;
22545 }
22546 + goto out;
22547 }
22548 + if (port_info == ioc->hba_port_info)
22549 + mptsas_probe_hba_phys(ioc);
22550 + else
22551 + mptsas_expander_refresh(ioc, port_info);
22552 + } else if (phy_info && phy_info->phy) {
22553 + if (link_rate == MPI_SAS_IOUNIT0_RATE_PHY_DISABLED)
22554 + phy_info->phy->negotiated_linkrate =
22555 + SAS_PHY_DISABLED;
22556 + else if (link_rate ==
22557 + MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION)
22558 + phy_info->phy->negotiated_linkrate =
22559 + SAS_LINK_RATE_FAILED;
22560 + else
22561 + phy_info->phy->negotiated_linkrate =
22562 + SAS_LINK_RATE_UNKNOWN;
22563 + }
22564 + out:
22565 + mptsas_free_fw_event(ioc, fw_event);
22566 +}
22567
22568 - if (phy_info->attached.device_info &
22569 - MPI_SAS_DEVICE_INFO_SSP_TARGET)
22570 - ds = "ssp";
22571 - if (phy_info->attached.device_info &
22572 - MPI_SAS_DEVICE_INFO_STP_TARGET)
22573 - ds = "stp";
22574 - if (phy_info->attached.device_info &
22575 - MPI_SAS_DEVICE_INFO_SATA_DEVICE)
22576 - ds = "sata";
22577 -
22578 - printk(MYIOC_s_INFO_FMT
22579 - "removing %s device, channel %d, id %d, phy %d\n",
22580 - ioc->name, ds, ev->channel, ev->id, phy_info->phy_id);
22581 - dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT
22582 - "delete port (%d)\n", ioc->name, port->port_identifier);
22583 - sas_port_delete(port);
22584 - mptsas_port_delete(ioc, phy_info->port_details);
22585 - break;
22586 - case MPTSAS_ADD_DEVICE:
22587 -
22588 - if (ev->phys_disk_num_valid)
22589 - mpt_findImVolumes(ioc);
22590
22591 - /*
22592 - * Refresh sas device pg0 data
22593 - */
22594 - if (mptsas_sas_device_pg0(ioc, &sas_device,
22595 - (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
22596 - MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
22597 - (ev->channel << 8) + ev->id)) {
22598 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22599 - "%s: exit at line=%d\n", ioc->name,
22600 - __func__, __LINE__));
22601 - break;
22602 +static void
22603 +mptsas_handle_queue_full_event(struct fw_event_work *fw_event)
22604 +{
22605 + MPT_ADAPTER *ioc;
22606 + EventDataQueueFull_t *qfull_data;
22607 + struct sas_device_info *sas_info;
22608 + struct scsi_device *sdev;
22609 + int depth;
22610 + int id = -1;
22611 + int channel = -1;
22612 + int fw_id, fw_channel;
22613 + u16 current_depth;
22614 +
22615 +
22616 + ioc = fw_event->ioc;
22617 + qfull_data = (EventDataQueueFull_t *)fw_event->event_data;
22618 + fw_id = qfull_data->TargetID;
22619 + fw_channel = qfull_data->Bus;
22620 + current_depth = le16_to_cpu(qfull_data->CurrentDepth);
22621 +
22622 + /* if hidden raid component, look for the volume id */
22623 + down(&ioc->sas_device_info_mutex);
22624 + if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) {
22625 + list_for_each_entry(sas_info, &ioc->sas_device_info_list,
22626 + list) {
22627 + if (sas_info->is_cached ||
22628 + sas_info->is_logical_volume)
22629 + continue;
22630 + if (sas_info->is_hidden_raid_component &&
22631 + (sas_info->fw.channel == fw_channel &&
22632 + sas_info->fw.id == fw_id)) {
22633 + id = sas_info->volume_id;
22634 + channel = MPTSAS_RAID_CHANNEL;
22635 + goto out;
22636 + }
22637 }
22638 -
22639 - __mptsas_discovery_work(ioc);
22640 -
22641 - phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
22642 - sas_device.sas_address);
22643 -
22644 - if (!phy_info || !phy_info->port_details) {
22645 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22646 - "%s: exit at line=%d\n", ioc->name,
22647 - __func__, __LINE__));
22648 - break;
22649 + } else {
22650 + list_for_each_entry(sas_info, &ioc->sas_device_info_list,
22651 + list) {
22652 + if (sas_info->is_cached ||
22653 + sas_info->is_hidden_raid_component ||
22654 + sas_info->is_logical_volume)
22655 + continue;
22656 + if (sas_info->fw.channel == fw_channel &&
22657 + sas_info->fw.id == fw_id) {
22658 + id = sas_info->os.id;
22659 + channel = sas_info->os.channel;
22660 + goto out;
22661 + }
22662 }
22663
22664 - starget = mptsas_get_starget(phy_info);
22665 - if (starget && (!ev->hidden_raid_component)){
22666 -
22667 - vtarget = starget->hostdata;
22668 + }
22669
22670 - if (!vtarget) {
22671 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22672 - "%s: exit at line=%d\n", ioc->name,
22673 - __func__, __LINE__));
22674 - break;
22675 - }
22676 - /*
22677 - * Handling RAID components
22678 - */
22679 - if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
22680 - printk(MYIOC_s_INFO_FMT
22681 - "RAID Exposing: channel=%d, id=%d, "
22682 - "physdsk %d \n", ioc->name, ev->channel,
22683 - ev->id, ev->phys_disk_num);
22684 - vtarget->tflags &=
22685 - ~MPT_TARGET_FLAGS_RAID_COMPONENT;
22686 - vtarget->id = ev->id;
22687 - mptsas_reprobe_target(starget, 0);
22688 - phy_info->attached.phys_disk_num = ~0;
22689 + out:
22690 + up(&ioc->sas_device_info_mutex);
22691 +
22692 + if (id != -1) {
22693 + shost_for_each_device(sdev, ioc->sh) {
22694 + if (sdev->id == id && sdev->channel == channel) {
22695 + if (current_depth > sdev->queue_depth) {
22696 + sdev_printk(KERN_INFO, sdev,
22697 + "strange observation, the queue "
22698 + "depth is (%d) meanwhile fw queue "
22699 + "depth (%d)\n", sdev->queue_depth,
22700 + current_depth);
22701 + continue;
22702 + }
22703 + depth = scsi_track_queue_full(sdev,
22704 + current_depth - 1);
22705 + if (depth > 0)
22706 + sdev_printk(KERN_INFO, sdev,
22707 + "Queue depth reduced to (%d)\n",
22708 + depth);
22709 + else if (depth < 0)
22710 + sdev_printk(KERN_INFO, sdev,
22711 + "Tagged Command Queueing is being "
22712 + "disabled\n");
22713 + else if (depth == 0)
22714 + sdev_printk(KERN_INFO, sdev,
22715 + "Queue depth not changed yet\n");
22716 }
22717 - break;
22718 }
22719 + }
22720
22721 - if (mptsas_get_rphy(phy_info)) {
22722 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22723 - "%s: exit at line=%d\n", ioc->name,
22724 - __func__, __LINE__));
22725 - if (ev->channel) printk("%d\n", __LINE__);
22726 - break;
22727 - }
22728 + mptsas_free_fw_event(ioc, fw_event);
22729 +}
22730
22731 - port = mptsas_get_port(phy_info);
22732 - if (!port) {
22733 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22734 - "%s: exit at line=%d\n", ioc->name,
22735 - __func__, __LINE__));
22736 - break;
22737 - }
22738 - memcpy(&phy_info->attached, &sas_device,
22739 - sizeof(struct mptsas_devinfo));
22740 +/**
22741 + * mptsas_firmware_event_work - work thread for processing fw events
22742 + * @work: work queue payload containing info describing the event
22743 + * Context: user
22744 + *
22745 + */
22746 +static void
22747 +mptsas_firmware_event_work(struct work_struct *work)
22748 +{
22749 + struct fw_event_work *fw_event =
22750 + container_of(work, struct fw_event_work, work.work);
22751 + MPT_ADAPTER *ioc = fw_event->ioc;
22752 +
22753 + /* special rescan topology handling */
22754 + if (fw_event->event == -1) {
22755 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: rescan after "
22756 + "reset\n", ioc->name,__FUNCTION__));
22757 + mptsas_not_responding_devices(ioc);
22758 + mptsas_scan_sas_topology(ioc);
22759 + mptsas_free_fw_event(ioc, fw_event);
22760 + return;
22761 + }
22762
22763 - if (phy_info->attached.device_info &
22764 - MPI_SAS_DEVICE_INFO_SSP_TARGET)
22765 - ds = "ssp";
22766 - if (phy_info->attached.device_info &
22767 - MPI_SAS_DEVICE_INFO_STP_TARGET)
22768 - ds = "stp";
22769 - if (phy_info->attached.device_info &
22770 - MPI_SAS_DEVICE_INFO_SATA_DEVICE)
22771 - ds = "sata";
22772 -
22773 - printk(MYIOC_s_INFO_FMT
22774 - "attaching %s device, channel %d, id %d, phy %d\n",
22775 - ioc->name, ds, ev->channel, ev->id, ev->phy_id);
22776 + /* events handling turned off during host reset */
22777 + if (ioc->fw_events_off) {
22778 + mptsas_free_fw_event(ioc, fw_event);
22779 + return;
22780 + }
22781
22782 - mptsas_parse_device_info(&identify, &phy_info->attached);
22783 - rphy = sas_end_device_alloc(port);
22784 - if (!rphy) {
22785 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22786 - "%s: exit at line=%d\n", ioc->name,
22787 - __func__, __LINE__));
22788 - break; /* non-fatal: an rphy can be added later */
22789 - }
22790 + devtprintk(ioc, printk(MYIOC_s_INFO_FMT "%s: fw_event=(0x%p), "
22791 + "event = (0x%02x)\n", ioc->name,__FUNCTION__, fw_event,
22792 + (fw_event->event & 0xFF)));
22793
22794 - rphy->identify = identify;
22795 - if (sas_rphy_add(rphy)) {
22796 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
22797 - "%s: exit at line=%d\n", ioc->name,
22798 - __func__, __LINE__));
22799 - sas_rphy_free(rphy);
22800 - break;
22801 - }
22802 - mptsas_set_rphy(ioc, phy_info, rphy);
22803 + switch (fw_event->event) {
22804 + case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
22805 + mptsas_send_sas_event(fw_event);
22806 break;
22807 - case MPTSAS_ADD_RAID:
22808 - sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
22809 - ev->id, 0);
22810 - if (sdev) {
22811 - scsi_device_put(sdev);
22812 - break;
22813 - }
22814 - printk(MYIOC_s_INFO_FMT
22815 - "attaching raid volume, channel %d, id %d\n",
22816 - ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
22817 - scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0);
22818 - mpt_findImVolumes(ioc);
22819 + case MPI_EVENT_INTEGRATED_RAID:
22820 + mptsas_send_raid_event(fw_event);
22821 break;
22822 - case MPTSAS_DEL_RAID:
22823 - sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
22824 - ev->id, 0);
22825 - if (!sdev)
22826 - break;
22827 - printk(MYIOC_s_INFO_FMT
22828 - "removing raid volume, channel %d, id %d\n",
22829 - ioc->name, MPTSAS_RAID_CHANNEL, ev->id);
22830 - vdevice = sdev->hostdata;
22831 - scsi_remove_device(sdev);
22832 - scsi_device_put(sdev);
22833 - mpt_findImVolumes(ioc);
22834 + case MPI_EVENT_IR2:
22835 + mptsas_send_ir2_event(fw_event);
22836 break;
22837 - case MPTSAS_ADD_INACTIVE_VOLUME:
22838 - mptsas_adding_inactive_raid_components(ioc,
22839 - ev->channel, ev->id);
22840 + case MPI_EVENT_PERSISTENT_TABLE_FULL:
22841 + mptbase_sas_persist_operation(ioc,
22842 + MPI_SAS_OP_CLEAR_NOT_PRESENT);
22843 + mptsas_free_fw_event(ioc, fw_event);
22844 break;
22845 - case MPTSAS_IGNORE_EVENT:
22846 - default:
22847 + case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
22848 + mptsas_broadcast_primative_work(fw_event);
22849 + break;
22850 + case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
22851 + mptsas_send_expander_event(fw_event);
22852 + break;
22853 + case MPI_EVENT_SAS_PHY_LINK_STATUS:
22854 + mptsas_send_link_status_event(fw_event);
22855 + break;
22856 + case MPI_EVENT_QUEUE_FULL:
22857 + mptsas_handle_queue_full_event(fw_event);
22858 break;
22859 }
22860 -
22861 - mutex_unlock(&ioc->sas_discovery_mutex);
22862 - kfree(ev);
22863 }
22864
22865 -static void
22866 -mptsas_send_sas_event(MPT_ADAPTER *ioc,
22867 - EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data)
22868 -{
22869 - struct mptsas_hotplug_event *ev;
22870 - u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo);
22871 - __le64 sas_address;
22872
22873 - if ((device_info &
22874 - (MPI_SAS_DEVICE_INFO_SSP_TARGET |
22875 - MPI_SAS_DEVICE_INFO_STP_TARGET |
22876 - MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0)
22877 - return;
22878 +/**
22879 + * mptsas_event_process -
22880 + * @ioc: Pointer to MPT_ADAPTER structure
22881 + * @reply:
22882 + *
22883 + **/
22884 +static int
22885 +mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
22886 +{
22887 + u32 event = le32_to_cpu(reply->Event);
22888 + int sz, event_data_sz;
22889 + struct fw_event_work *fw_event;
22890 + unsigned long delay;
22891
22892 - switch (sas_event_data->ReasonCode) {
22893 - case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
22894 + /* events turned off due to host reset or driver unloading */
22895 + if (ioc->fw_events_off)
22896 + return 0;
22897
22898 - mptsas_target_reset_queue(ioc, sas_event_data);
22899 + delay = msecs_to_jiffies(1);
22900 + switch (event) {
22901 + case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
22902 + {
22903 + EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data =
22904 + (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data;
22905 + if (broadcast_event_data->Primitive !=
22906 + MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT)
22907 + return 0;
22908 + if (ioc->broadcast_aen_busy)
22909 + return 0;
22910 + ioc->broadcast_aen_busy = 1;
22911 break;
22912 + }
22913 + case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
22914 + {
22915 + EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data =
22916 + (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data;
22917
22918 - case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
22919 - ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
22920 - if (!ev) {
22921 - printk(MYIOC_s_WARN_FMT "lost hotplug event\n", ioc->name);
22922 - break;
22923 + if (sas_event_data->ReasonCode ==
22924 + MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) {
22925 + mptsas_target_reset_queue(ioc, sas_event_data);
22926 + return 0;
22927 }
22928 + break;
22929 + }
22930 + case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE:
22931 + {
22932 + MpiEventDataSasExpanderStatusChange_t *expander_data =
22933 + (MpiEventDataSasExpanderStatusChange_t *)reply->Data;
22934
22935 - INIT_WORK(&ev->work, mptsas_hotplug_work);
22936 - ev->ioc = ioc;
22937 - ev->handle = le16_to_cpu(sas_event_data->DevHandle);
22938 - ev->parent_handle =
22939 - le16_to_cpu(sas_event_data->ParentDevHandle);
22940 - ev->channel = sas_event_data->Bus;
22941 - ev->id = sas_event_data->TargetID;
22942 - ev->phy_id = sas_event_data->PhyNum;
22943 - memcpy(&sas_address, &sas_event_data->SASAddress,
22944 - sizeof(__le64));
22945 - ev->sas_address = le64_to_cpu(sas_address);
22946 - ev->device_info = device_info;
22947 + if (ioc->old_sas_discovery_protocal)
22948 + return 0;
22949
22950 - if (sas_event_data->ReasonCode &
22951 - MPI_EVENT_SAS_DEV_STAT_RC_ADDED)
22952 - ev->event_type = MPTSAS_ADD_DEVICE;
22953 - else
22954 - ev->event_type = MPTSAS_DEL_DEVICE;
22955 - schedule_work(&ev->work);
22956 + if (expander_data->ReasonCode ==
22957 + MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING &&
22958 + ioc->device_missing_delay)
22959 + delay = HZ * ioc->device_missing_delay;
22960 break;
22961 - case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
22962 - /*
22963 - * Persistent table is full.
22964 - */
22965 - INIT_WORK(&ioc->sas_persist_task,
22966 - mptsas_persist_clear_table);
22967 - schedule_work(&ioc->sas_persist_task);
22968 + }
22969 + case MPI_EVENT_SAS_DISCOVERY:
22970 + {
22971 + u32 discovery_status;
22972 + EventDataSasDiscovery_t *discovery_data =
22973 + (EventDataSasDiscovery_t *)reply->Data;
22974 +
22975 + discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus);
22976 + ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0;
22977 + if (ioc->old_sas_discovery_protocal && !discovery_status)
22978 + mptsas_queue_rescan(ioc);
22979 + return 0;
22980 + }
22981 + case MPI_EVENT_INTEGRATED_RAID:
22982 + case MPI_EVENT_PERSISTENT_TABLE_FULL:
22983 + case MPI_EVENT_IR2:
22984 + case MPI_EVENT_SAS_PHY_LINK_STATUS:
22985 + case MPI_EVENT_QUEUE_FULL:
22986 break;
22987 - /*
22988 - * TODO, handle other events
22989 - */
22990 - case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
22991 - case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
22992 - case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
22993 - case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
22994 - case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
22995 - case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
22996 - case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
22997 default:
22998 - break;
22999 + return 0;
23000 }
23001 +
23002 + event_data_sz = ((reply->MsgLength * 4) -
23003 + offsetof(EventNotificationReply_t, Data));
23004 + sz = offsetof(struct fw_event_work, event_data) + event_data_sz;
23005 + fw_event = kzalloc(sz, GFP_ATOMIC);
23006 + if (!fw_event) {
23007 + printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name,
23008 + __FUNCTION__, __LINE__);
23009 + return 0;
23010 + }
23011 + memcpy(fw_event->event_data, reply->Data, event_data_sz);
23012 + fw_event->event = event;
23013 + fw_event->ioc = ioc;
23014 + mptsas_add_fw_event(ioc, fw_event, delay);
23015 + return 0;
23016 }
23017 -static void
23018 -mptsas_send_raid_event(MPT_ADAPTER *ioc,
23019 - EVENT_DATA_RAID *raid_event_data)
23020 +
23021 +
23022 +/* Delete a volume when no longer listed in ioc pg2
23023 + */
23024 +static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id)
23025 {
23026 - struct mptsas_hotplug_event *ev;
23027 - int status = le32_to_cpu(raid_event_data->SettingsStatus);
23028 - int state = (status >> 8) & 0xff;
23029 + struct scsi_device *sdev;
23030 + int i;
23031
23032 - if (ioc->bus_type != SAS)
23033 + sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0);
23034 + if (!sdev)
23035 return;
23036 + if (!ioc->raid_data.pIocPg2)
23037 + goto out;
23038 + if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
23039 + goto out;
23040 + for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++)
23041 + if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id)
23042 + goto release_sdev;
23043 + out:
23044 + printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, "
23045 + "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,id);
23046 + scsi_remove_device(sdev);
23047 + release_sdev:
23048 + scsi_device_put(sdev);
23049 +}
23050 +
23051 +static void
23052 +mptsas_not_responding_devices(MPT_ADAPTER *ioc)
23053 +{
23054 + struct mptsas_portinfo buffer, *port_info;
23055 + struct sas_device_info *sas_info;
23056 + struct mptsas_devinfo sas_device;
23057 + u32 handle;
23058 + VirtTarget *vtarget = NULL;
23059 + struct mptsas_phyinfo *phy_info;
23060 + u8 found_expander;
23061
23062 - ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
23063 - if (!ev) {
23064 - printk(MYIOC_s_WARN_FMT "lost hotplug event\n", ioc->name);
23065 + if (ioc->disable_hotplug_remove)
23066 return;
23067 +
23068 + mpt_findImVolumes(ioc);
23069 +
23070 + /* devices, logical volumes */
23071 + redo_device_scan:
23072 + list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) {
23073 + if (sas_info->is_cached)
23074 + continue;
23075 + if (!sas_info->is_logical_volume) {
23076 + sas_device.handle = 0;
23077 + mptsas_sas_device_pg0(ioc, &sas_device,
23078 + (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID <<
23079 + MPI_SAS_DEVICE_PGAD_FORM_SHIFT),
23080 + (sas_info->fw.channel << 8) +
23081 + sas_info->fw.id);
23082 + if (sas_device.handle)
23083 + continue;
23084 + /* delete device */
23085 + if ((vtarget = mptsas_find_vtarget(ioc,
23086 + sas_info->fw.channel,
23087 + sas_info->fw.id)))
23088 + vtarget->deleted = 1;
23089 + phy_info = mptsas_find_phyinfo_by_sas_address(ioc,
23090 + sas_info->sas_address);
23091 + if (phy_info) {
23092 + mptsas_del_end_device(ioc, phy_info);
23093 + goto redo_device_scan;
23094 + }
23095 + } else
23096 + mptsas_volume_delete(ioc, sas_info->fw.id);
23097 }
23098
23099 - INIT_WORK(&ev->work, mptsas_hotplug_work);
23100 - ev->ioc = ioc;
23101 - ev->id = raid_event_data->VolumeID;
23102 - ev->channel = raid_event_data->VolumeBus;
23103 - ev->event_type = MPTSAS_IGNORE_EVENT;
23104 + /* expanders */
23105 + redo_expander_scan:
23106 + list_for_each_entry(port_info, &ioc->sas_topology, list) {
23107
23108 - switch (raid_event_data->ReasonCode) {
23109 - case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
23110 - ev->phys_disk_num_valid = 1;
23111 - ev->phys_disk_num = raid_event_data->PhysDiskNum;
23112 - ev->event_type = MPTSAS_ADD_DEVICE;
23113 - break;
23114 - case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
23115 - ev->phys_disk_num_valid = 1;
23116 - ev->phys_disk_num = raid_event_data->PhysDiskNum;
23117 - ev->hidden_raid_component = 1;
23118 - ev->event_type = MPTSAS_DEL_DEVICE;
23119 - break;
23120 - case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
23121 - switch (state) {
23122 - case MPI_PD_STATE_ONLINE:
23123 - case MPI_PD_STATE_NOT_COMPATIBLE:
23124 - ev->phys_disk_num_valid = 1;
23125 - ev->phys_disk_num = raid_event_data->PhysDiskNum;
23126 - ev->hidden_raid_component = 1;
23127 - ev->event_type = MPTSAS_ADD_DEVICE;
23128 - break;
23129 - case MPI_PD_STATE_MISSING:
23130 - case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST:
23131 - case MPI_PD_STATE_FAILED_AT_HOST_REQUEST:
23132 - case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON:
23133 - ev->phys_disk_num_valid = 1;
23134 - ev->phys_disk_num = raid_event_data->PhysDiskNum;
23135 - ev->event_type = MPTSAS_DEL_DEVICE;
23136 - break;
23137 - default:
23138 - break;
23139 + if (port_info->phy_info &&
23140 + (!(port_info->phy_info[0].identify.device_info &
23141 + MPI_SAS_DEVICE_INFO_SMP_TARGET)))
23142 + continue;
23143 + found_expander = 0;
23144 + handle = 0xFFFF;
23145 + while (!mptsas_sas_expander_pg0(ioc, &buffer,
23146 + (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
23147 + MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) &&
23148 + !found_expander) {
23149 +
23150 + handle = buffer.phy_info[0].handle;
23151 + if (buffer.phy_info[0].identify.sas_address ==
23152 + port_info->phy_info[0].identify.sas_address) {
23153 + found_expander = 1;
23154 + }
23155 + kfree(buffer.phy_info);
23156 }
23157 - break;
23158 - case MPI_EVENT_RAID_RC_VOLUME_DELETED:
23159 - ev->event_type = MPTSAS_DEL_RAID;
23160 - break;
23161 - case MPI_EVENT_RAID_RC_VOLUME_CREATED:
23162 - ev->event_type = MPTSAS_ADD_RAID;
23163 - break;
23164 - case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
23165 - switch (state) {
23166 - case MPI_RAIDVOL0_STATUS_STATE_FAILED:
23167 - case MPI_RAIDVOL0_STATUS_STATE_MISSING:
23168 - ev->event_type = MPTSAS_DEL_RAID;
23169 - break;
23170 - case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL:
23171 - case MPI_RAIDVOL0_STATUS_STATE_DEGRADED:
23172 - ev->event_type = MPTSAS_ADD_RAID;
23173 - break;
23174 - default:
23175 - break;
23176 +
23177 + if (!found_expander) {
23178 + mptsas_expander_delete(ioc, port_info);
23179 + goto redo_expander_scan;
23180 }
23181 - break;
23182 - default:
23183 - break;
23184 }
23185 - schedule_work(&ev->work);
23186 }
23187
23188 +/**
23189 + * mptsas_probe_expanders - adding expanders
23190 + * @ioc: Pointer to MPT_ADAPTER structure
23191 + *
23192 + **/
23193 static void
23194 -mptsas_send_discovery_event(MPT_ADAPTER *ioc,
23195 - EVENT_DATA_SAS_DISCOVERY *discovery_data)
23196 +mptsas_probe_expanders(MPT_ADAPTER *ioc)
23197 {
23198 - struct mptsas_discovery_event *ev;
23199 + struct mptsas_portinfo buffer, *port_info;
23200 + u32 handle;
23201 + int i;
23202
23203 - /*
23204 - * DiscoveryStatus
23205 - *
23206 - * This flag will be non-zero when firmware
23207 - * kicks off discovery, and return to zero
23208 - * once its completed.
23209 - */
23210 - if (discovery_data->DiscoveryStatus)
23211 - return;
23212 + handle = 0xFFFF;
23213 + while (!mptsas_sas_expander_pg0(ioc, &buffer,
23214 + (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE <<
23215 + MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) {
23216
23217 - ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
23218 - if (!ev)
23219 - return;
23220 - INIT_WORK(&ev->work, mptsas_discovery_work);
23221 - ev->ioc = ioc;
23222 - schedule_work(&ev->work);
23223 -};
23224 + handle = buffer.phy_info[0].handle;
23225 + port_info = mptsas_find_portinfo_by_sas_address(ioc,
23226 + buffer.phy_info[0].identify.sas_address);
23227 +
23228 + if (port_info) {
23229 + /* refreshing handles */
23230 + for (i = 0; i < buffer.num_phys; i++) {
23231 + port_info->phy_info[i].handle = handle;
23232 + port_info->phy_info[i].identify.handle_parent =
23233 + buffer.phy_info[0].identify.handle_parent;
23234 + }
23235 + mptsas_expander_refresh(ioc, port_info);
23236 + kfree(buffer.phy_info);
23237 + continue;
23238 + }
23239 +
23240 + port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL);
23241 + if (!port_info) {
23242 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT
23243 + "%s: exit at line=%d\n", ioc->name,
23244 + __FUNCTION__, __LINE__));
23245 + return;
23246 + }
23247 + port_info->num_phys = buffer.num_phys;
23248 + port_info->phy_info = buffer.phy_info;
23249 + for (i = 0; i < port_info->num_phys; i++)
23250 + port_info->phy_info[i].portinfo = port_info;
23251 + mutex_lock(&ioc->sas_topology_mutex);
23252 + list_add_tail(&port_info->list, &ioc->sas_topology);
23253 + mutex_unlock(&ioc->sas_topology_mutex);
23254 + printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, "
23255 + "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys,
23256 + (unsigned long long)buffer.phy_info[0].identify.sas_address);
23257 + mptsas_expander_refresh(ioc, port_info);
23258 + }
23259 +}
23260
23261 -/*
23262 - * mptsas_send_ir2_event - handle exposing hidden disk when
23263 - * an inactive raid volume is added
23264 - *
23265 - * @ioc: Pointer to MPT_ADAPTER structure
23266 - * @ir2_data
23267 - *
23268 - */
23269 static void
23270 -mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data)
23271 +mptsas_probe_devices(MPT_ADAPTER *ioc)
23272 {
23273 - struct mptsas_hotplug_event *ev;
23274 + u16 retry_count;
23275 + u16 handle;
23276 + struct mptsas_devinfo sas_device;
23277 + struct mptsas_phyinfo *phy_info;
23278 + enum device_state state;
23279
23280 - if (ir2_data->ReasonCode !=
23281 - MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED)
23282 - return;
23283 + handle = 0xFFFF;
23284 + while (!(mptsas_sas_device_pg0(ioc, &sas_device,
23285 + MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
23286 +
23287 + handle = sas_device.handle;
23288 +
23289 + if ((sas_device.device_info &
23290 + (MPI_SAS_DEVICE_INFO_SSP_TARGET |
23291 + MPI_SAS_DEVICE_INFO_STP_TARGET |
23292 + MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0)
23293 + continue;
23294
23295 - ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
23296 - if (!ev)
23297 - return;
23298 + phy_info = mptsas_refreshing_device_handles(ioc, &sas_device);
23299 + if (!phy_info)
23300 + continue;
23301
23302 - INIT_WORK(&ev->work, mptsas_hotplug_work);
23303 - ev->ioc = ioc;
23304 - ev->id = ir2_data->TargetID;
23305 - ev->channel = ir2_data->Bus;
23306 - ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME;
23307 + if (mptsas_get_rphy(phy_info))
23308 + continue;
23309
23310 - schedule_work(&ev->work);
23311 -};
23312 + state = DEVICE_RETRY;
23313 + retry_count = 0;
23314 + while(state == DEVICE_RETRY) {
23315 + state = mptsas_test_unit_ready(ioc, sas_device.channel,
23316 + sas_device.id, retry_count++);
23317 + ssleep(1);
23318 + }
23319 + if (state == DEVICE_READY)
23320 + mptsas_add_end_device(ioc, phy_info);
23321 + }
23322 +}
23323
23324 -static int
23325 -mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
23326 +/**
23327 + * mptsas_scan_sas_topology -
23328 + * @ioc: Pointer to MPT_ADAPTER structure
23329 + * @sas_address:
23330 + *
23331 + **/
23332 +static void
23333 +mptsas_scan_sas_topology(MPT_ADAPTER *ioc)
23334 {
23335 - int rc=1;
23336 - u8 event = le32_to_cpu(reply->Event) & 0xFF;
23337 + struct scsi_device *sdev;
23338 + int i;
23339
23340 - if (!ioc->sh)
23341 - goto out;
23342 + mptsas_probe_hba_phys(ioc);
23343 + mptsas_probe_expanders(ioc);
23344 + mptsas_probe_devices(ioc);
23345
23346 /*
23347 - * sas_discovery_ignore_events
23348 - *
23349 - * This flag is to prevent anymore processing of
23350 - * sas events once mptsas_remove function is called.
23351 - */
23352 - if (ioc->sas_discovery_ignore_events) {
23353 - rc = mptscsih_event_process(ioc, reply);
23354 - goto out;
23355 - }
23356 -
23357 - switch (event) {
23358 - case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
23359 - mptsas_send_sas_event(ioc,
23360 - (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data);
23361 - break;
23362 - case MPI_EVENT_INTEGRATED_RAID:
23363 - mptsas_send_raid_event(ioc,
23364 - (EVENT_DATA_RAID *)reply->Data);
23365 - break;
23366 - case MPI_EVENT_PERSISTENT_TABLE_FULL:
23367 - INIT_WORK(&ioc->sas_persist_task,
23368 - mptsas_persist_clear_table);
23369 - schedule_work(&ioc->sas_persist_task);
23370 - break;
23371 - case MPI_EVENT_SAS_DISCOVERY:
23372 - mptsas_send_discovery_event(ioc,
23373 - (EVENT_DATA_SAS_DISCOVERY *)reply->Data);
23374 - break;
23375 - case MPI_EVENT_IR2:
23376 - mptsas_send_ir2_event(ioc,
23377 - (PTR_MPI_EVENT_DATA_IR2)reply->Data);
23378 - break;
23379 - default:
23380 - rc = mptscsih_event_process(ioc, reply);
23381 - break;
23382 + Reporting RAID volumes.
23383 + */
23384 + if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 ||
23385 + !ioc->raid_data.pIocPg2->NumActiveVolumes)
23386 + return;
23387 + for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
23388 + if ((sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL,
23389 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0))) {
23390 + scsi_device_put(sdev);
23391 + continue;
23392 + }
23393 + printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, "
23394 + "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL,
23395 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID);
23396 + scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL,
23397 + ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0);
23398 }
23399 - out:
23400 -
23401 - return rc;
23402 }
23403
23404 +/**
23405 + * mptsas_probe -
23406 + * @pdev:
23407 + * @id:
23408 + *
23409 + **/
23410 static int
23411 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id)
23412 {
23413 @@ -3129,6 +5071,7 @@ mptsas_probe(struct pci_dev *pdev, const
23414 return r;
23415
23416 ioc = pci_get_drvdata(pdev);
23417 + mptsas_fw_event_off(ioc);
23418 ioc->DoneCtx = mptsasDoneCtx;
23419 ioc->TaskCtx = mptsasTaskCtx;
23420 ioc->InternalCtx = mptsasInternalCtx;
23421 @@ -3173,7 +5116,7 @@ mptsas_probe(struct pci_dev *pdev, const
23422 ioc->name);
23423 error = -1;
23424 goto out_mptsas_probe;
23425 - }
23426 + }
23427
23428 spin_lock_irqsave(&ioc->FreeQlock, flags);
23429
23430 @@ -3187,10 +5130,9 @@ mptsas_probe(struct pci_dev *pdev, const
23431
23432 /* set 16 byte cdb's */
23433 sh->max_cmd_len = 16;
23434 -
23435 + sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue);
23436 sh->max_id = ioc->pfacts[0].PortSCSIID;
23437 sh->max_lun = max_lun;
23438 -
23439 sh->transportt = mptsas_transport_template;
23440
23441 /* Required entry.
23442 @@ -3199,10 +5141,10 @@ mptsas_probe(struct pci_dev *pdev, const
23443
23444 INIT_LIST_HEAD(&ioc->sas_topology);
23445 mutex_init(&ioc->sas_topology_mutex);
23446 - mutex_init(&ioc->sas_discovery_mutex);
23447 mutex_init(&ioc->sas_mgmt.mutex);
23448 init_completion(&ioc->sas_mgmt.done);
23449
23450 +
23451 /* Verify that we won't exceed the maximum
23452 * number of chain buffers
23453 * We can optimize: ZZ = req_sz/sizeof(SGE)
23454 @@ -3212,17 +5154,16 @@ mptsas_probe(struct pci_dev *pdev, const
23455 * A slightly different algorithm is required for
23456 * 64bit SGEs.
23457 */
23458 - scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
23459 - if (sizeof(dma_addr_t) == sizeof(u64)) {
23460 +
23461 + scale = ioc->req_sz/ioc->SGE_size;
23462 + if (ioc->sg_addr_size == sizeof(u64)) {
23463 numSGE = (scale - 1) *
23464 (ioc->facts.MaxChainDepth-1) + scale +
23465 - (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
23466 - sizeof(u32));
23467 + (ioc->req_sz - 60) / ioc->SGE_size;
23468 } else {
23469 numSGE = 1 + (scale - 1) *
23470 (ioc->facts.MaxChainDepth-1) + scale +
23471 - (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
23472 - sizeof(u32));
23473 + (ioc->req_sz - 64) / ioc->SGE_size;
23474 }
23475
23476 if (numSGE < sh->sg_tablesize) {
23477 @@ -3250,34 +5191,17 @@ mptsas_probe(struct pci_dev *pdev, const
23478 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
23479 ioc->name, ioc->ScsiLookup));
23480
23481 - /* Clear the TM flags
23482 - */
23483 - hd->tmPending = 0;
23484 - hd->tmState = TM_STATE_NONE;
23485 - hd->resetPending = 0;
23486 - hd->abortSCpnt = NULL;
23487 -
23488 - /* Clear the pointer used to store
23489 - * single-threaded commands, i.e., those
23490 - * issued during a bus scan, dv and
23491 - * configuration pages.
23492 - */
23493 - hd->cmdPtr = NULL;
23494 -
23495 - /* Initialize this SCSI Hosts' timers
23496 - * To use, set the timer expires field
23497 - * and add_timer
23498 - */
23499 - init_timer(&hd->timer);
23500 - hd->timer.data = (unsigned long) hd;
23501 - hd->timer.function = mptscsih_timer_expired;
23502 -
23503 + ioc->sdev_queue_depth = mpt_sdev_queue_depth;
23504 ioc->sas_data.ptClear = mpt_pt_clear;
23505 -
23506 - init_waitqueue_head(&hd->scandv_waitq);
23507 - hd->scandv_wait_done = 0;
23508 hd->last_queue_full = 0;
23509 + ioc->disable_hotplug_remove = mpt_disable_hotplug_remove;
23510 + if (ioc->disable_hotplug_remove)
23511 + printk(MYIOC_s_INFO_FMT "disabling hotplug remove\n", ioc->name);
23512 +
23513 INIT_LIST_HEAD(&hd->target_reset_list);
23514 + INIT_LIST_HEAD(&ioc->sas_device_info_list);
23515 + init_MUTEX(&ioc->sas_device_info_mutex);
23516 +
23517 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
23518
23519 if (ioc->sas_data.ptClear==1) {
23520 @@ -3292,8 +5216,11 @@ mptsas_probe(struct pci_dev *pdev, const
23521 goto out_mptsas_probe;
23522 }
23523
23524 + /* older firmware doesn't support expander events */
23525 + if ((ioc->facts.HeaderVersion >> 8) < 0xE)
23526 + ioc->old_sas_discovery_protocal = 1;
23527 mptsas_scan_sas_topology(ioc);
23528 -
23529 + mptsas_fw_event_on(ioc);
23530 return 0;
23531
23532 out_mptsas_probe:
23533 @@ -3302,13 +5229,23 @@ mptsas_probe(struct pci_dev *pdev, const
23534 return error;
23535 }
23536
23537 -static void __devexit mptsas_remove(struct pci_dev *pdev)
23538 +/**
23539 + * mptsas_remove -
23540 + * @pdev:
23541 + *
23542 + **/
23543 +static void __devexit
23544 +mptsas_remove(struct pci_dev *pdev)
23545 {
23546 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
23547 struct mptsas_portinfo *p, *n;
23548 int i;
23549
23550 - ioc->sas_discovery_ignore_events = 1;
23551 + mptsas_fw_event_off(ioc);
23552 + mptsas_cleanup_fw_event_q(ioc);
23553 +
23554 + mptsas_del_device_components(ioc);
23555 +
23556 sas_remove_host(ioc->sh);
23557
23558 mutex_lock(&ioc->sas_topology_mutex);
23559 @@ -3316,11 +5253,12 @@ static void __devexit mptsas_remove(stru
23560 list_del(&p->list);
23561 for (i = 0 ; i < p->num_phys ; i++)
23562 mptsas_port_delete(ioc, p->phy_info[i].port_details);
23563 +
23564 kfree(p->phy_info);
23565 kfree(p);
23566 }
23567 mutex_unlock(&ioc->sas_topology_mutex);
23568 -
23569 + ioc->hba_port_info = NULL;
23570 mptscsih_remove(pdev);
23571 }
23572
23573 @@ -3352,6 +5290,10 @@ static struct pci_driver mptsas_driver =
23574 #endif
23575 };
23576
23577 +/**
23578 + * mptsas_init -
23579 + *
23580 + **/
23581 static int __init
23582 mptsas_init(void)
23583 {
23584 @@ -3365,10 +5307,12 @@ mptsas_init(void)
23585 return -ENODEV;
23586
23587 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER);
23588 - mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
23589 + mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER);
23590 mptsasInternalCtx =
23591 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER);
23592 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER);
23593 + mptsasDeviceResetCtx =
23594 + mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER);
23595
23596 mpt_event_register(mptsasDoneCtx, mptsas_event_process);
23597 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset);
23598 @@ -3380,6 +5324,10 @@ mptsas_init(void)
23599 return error;
23600 }
23601
23602 +/**
23603 + * mptsas_exit -
23604 + *
23605 + **/
23606 static void __exit
23607 mptsas_exit(void)
23608 {
23609 @@ -3393,6 +5341,7 @@ mptsas_exit(void)
23610 mpt_deregister(mptsasInternalCtx);
23611 mpt_deregister(mptsasTaskCtx);
23612 mpt_deregister(mptsasDoneCtx);
23613 + mpt_deregister(mptsasDeviceResetCtx);
23614 }
23615
23616 module_init(mptsas_init);
23617 --- a/drivers/message/fusion/mptsas.h
23618 +++ b/drivers/message/fusion/mptsas.h
23619 @@ -50,9 +50,10 @@
23620 /*{-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23621
23622 struct mptsas_target_reset_event {
23623 - struct list_head list;
23624 - EVENT_DATA_SAS_DEVICE_STATUS_CHANGE sas_event_data;
23625 + struct list_head list;
23626 + MpiEventDataSasDeviceStatusChange_t sas_event_data;
23627 u8 target_reset_issued;
23628 + unsigned long time_count;
23629 };
23630
23631 enum mptsas_hotplug_action {
23632 @@ -61,11 +62,34 @@ enum mptsas_hotplug_action {
23633 MPTSAS_ADD_RAID,
23634 MPTSAS_DEL_RAID,
23635 MPTSAS_ADD_INACTIVE_VOLUME,
23636 + MPTSAS_ADD_PHYSDISK,
23637 + MPTSAS_ADD_PHYSDISK_REPROBE,
23638 + MPTSAS_DEL_PHYSDISK,
23639 + MPTSAS_DEL_PHYSDISK_REPROBE,
23640 + MPTSAS_REQUEUE_EVENT,
23641 MPTSAS_IGNORE_EVENT,
23642 };
23643
23644 +struct sas_mapping{
23645 + u8 id;
23646 + u8 channel;
23647 +};
23648 +
23649 +struct sas_device_info {
23650 + struct list_head list;
23651 + struct sas_mapping os; /* operating system mapping*/
23652 + struct sas_mapping fw; /* firmware mapping */
23653 + u64 sas_address;
23654 + u32 device_info; /* specific bits for devices */
23655 + u16 slot; /* enclosure slot id */
23656 + u64 enclosure_logical_id; /*enclosure address */
23657 + u8 is_logical_volume; /* is this logical volume */
23658 + u8 is_hidden_raid_component; /* this belongs to volume */
23659 + u8 volume_id; /* this valid when is_hidden_raid_component set */
23660 + u8 is_cached; /* cached data for a removed device */
23661 +};
23662 +
23663 struct mptsas_hotplug_event {
23664 - struct work_struct work;
23665 MPT_ADAPTER *ioc;
23666 enum mptsas_hotplug_action event_type;
23667 u64 sas_address;
23668 @@ -73,17 +97,28 @@ struct mptsas_hotplug_event {
23669 u8 id;
23670 u32 device_info;
23671 u16 handle;
23672 - u16 parent_handle;
23673 u8 phy_id;
23674 - u8 phys_disk_num_valid; /* hrc (hidden raid component) */
23675 u8 phys_disk_num; /* hrc - unique index*/
23676 - u8 hidden_raid_component; /* hrc - don't expose*/
23677 + struct scsi_device *sdev;
23678 };
23679
23680 -struct mptsas_discovery_event {
23681 +
23682 +struct fw_event_work {
23683 + struct list_head list;
23684 + struct delayed_work work;
23685 + MPT_ADAPTER *ioc;
23686 + u32 event;
23687 + u8 retries;
23688 + u8 event_data[1];
23689 +};
23690 +
23691 +#if 0
23692 +struct mptsas_link_status_event {
23693 struct work_struct work;
23694 + MpiEventDataSasPhyLinkStatus_t link_data;
23695 MPT_ADAPTER *ioc;
23696 };
23697 +#endif
23698
23699 /*
23700 * SAS topology structures
23701 @@ -113,32 +148,35 @@ struct mptsas_devinfo {
23702 * Specific details on ports, wide/narrow
23703 */
23704 struct mptsas_portinfo_details{
23705 - u16 num_phys; /* number of phys belong to this port */
23706 - u64 phy_bitmask; /* TODO, extend support for 255 phys */
23707 - struct sas_rphy *rphy; /* transport layer rphy object */
23708 + u16 num_phys; /* number of phys beloing to this port */
23709 + u64 phy_bitmask; /* this needs extending to support 128 phys */
23710 + struct sas_rphy *rphy; /* rphy for end devices */
23711 struct sas_port *port; /* transport layer port object */
23712 struct scsi_target *starget;
23713 struct mptsas_portinfo *port_info;
23714 };
23715
23716 struct mptsas_phyinfo {
23717 - u16 handle; /* unique id to address this */
23718 - u8 phy_id; /* phy index */
23719 - u8 port_id; /* firmware port identifier */
23720 + u16 handle; /* handle for this phy */
23721 + u8 phy_id; /* phy index */
23722 + u8 port_id; /* port number this phy is part of */
23723 u8 negotiated_link_rate; /* nego'd link rate for this phy */
23724 - u8 hw_link_rate; /* hardware max/min phys link rate */
23725 + u8 hw_link_rate; /* hardware max/min phys link rate */
23726 u8 programmed_link_rate; /* programmed max/min phy link rate */
23727 u8 sas_port_add_phy; /* flag to request sas_port_add_phy*/
23728 + u8 change_count; /* change count of the phy */
23729 + u8 port_flags; /* info wrt host sas ports */
23730 + u32 phy_info; /* various info wrt the phy */
23731 struct mptsas_devinfo identify; /* point to phy device info */
23732 struct mptsas_devinfo attached; /* point to attached device info */
23733 - struct sas_phy *phy; /* transport layer phy object */
23734 + struct sas_phy *phy;
23735 struct mptsas_portinfo *portinfo;
23736 struct mptsas_portinfo_details * port_details;
23737 };
23738
23739 struct mptsas_portinfo {
23740 struct list_head list;
23741 - u16 num_phys; /* number of phys */
23742 + u16 num_phys; /* number of phys */
23743 struct mptsas_phyinfo *phy_info;
23744 };
23745
23746 @@ -156,3 +194,4 @@ struct mptsas_enclosure {
23747
23748 /*}-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23749 #endif
23750 +
23751 --- a/drivers/message/fusion/mptscsih.c
23752 +++ b/drivers/message/fusion/mptscsih.c
23753 @@ -53,7 +53,9 @@
23754 #include <linux/delay.h> /* for mdelay */
23755 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
23756 #include <linux/reboot.h> /* notifier code */
23757 +#include <linux/sched.h>
23758 #include <linux/workqueue.h>
23759 +#include <linux/pci.h>
23760
23761 #include <scsi/scsi.h>
23762 #include <scsi/scsi_cmnd.h>
23763 @@ -77,10 +79,15 @@ MODULE_LICENSE("GPL");
23764 MODULE_VERSION(my_VERSION);
23765
23766 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23767 +typedef struct _BIG_SENSE_BUF {
23768 + u8 data[MPT_SENSE_BUFFER_ALLOC];
23769 +} BIG_SENSE_BUF;
23770 +
23771 +
23772 /*
23773 * Other private/forward protos...
23774 */
23775 -static struct scsi_cmnd * mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
23776 +struct scsi_cmnd * mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
23777 static struct scsi_cmnd * mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i);
23778 static void mptscsih_set_scsi_lookup(MPT_ADAPTER *ioc, int i, struct scsi_cmnd *scmd);
23779 static int SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *scmd);
23780 @@ -92,17 +99,10 @@ static int mptscsih_AddSGE(MPT_ADAPTER *
23781 SCSIIORequest_t *pReq, int req_idx);
23782 static void mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx);
23783 static void mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply);
23784 -static int mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd);
23785 -static int mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout );
23786 -
23787 -static int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
23788
23789 int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
23790 int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
23791 -
23792 -int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
23793 -static int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
23794 -static void mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice);
23795 +static void mptscsih_synchronize_cache(struct scsi_device *sdev, MPT_SCSI_HOST *hd, VirtDevice *vdevice);
23796
23797 void mptscsih_remove(struct pci_dev *);
23798 void mptscsih_shutdown(struct pci_dev *);
23799 @@ -111,81 +111,17 @@ int mptscsih_suspend(struct pci_dev *p
23800 int mptscsih_resume(struct pci_dev *pdev);
23801 #endif
23802
23803 -#define SNS_LEN(scp) SCSI_SENSE_BUFFERSIZE
23804 -
23805 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23806 -/**
23807 - * mptscsih_add_sge - Place a simple SGE at address pAddr.
23808 - * @pAddr: virtual address for SGE
23809 - * @flagslength: SGE flags and data transfer length
23810 - * @dma_addr: Physical address
23811 - *
23812 - * This routine places a MPT request frame back on the MPT adapter's
23813 - * FreeQ.
23814 - */
23815 -static inline void
23816 -mptscsih_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
23817 -{
23818 - if (sizeof(dma_addr_t) == sizeof(u64)) {
23819 - SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
23820 - u32 tmp = dma_addr & 0xFFFFFFFF;
23821 -
23822 - pSge->FlagsLength = cpu_to_le32(flagslength);
23823 - pSge->Address.Low = cpu_to_le32(tmp);
23824 - tmp = (u32) ((u64)dma_addr >> 32);
23825 - pSge->Address.High = cpu_to_le32(tmp);
23826 -
23827 - } else {
23828 - SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
23829 - pSge->FlagsLength = cpu_to_le32(flagslength);
23830 - pSge->Address = cpu_to_le32(dma_addr);
23831 - }
23832 -} /* mptscsih_add_sge() */
23833 +#define SNS_LEN(scp) sizeof((scp)->sense_buffer)
23834
23835 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23836 /**
23837 - * mptscsih_add_chain - Place a chain SGE at address pAddr.
23838 - * @pAddr: virtual address for SGE
23839 - * @next: nextChainOffset value (u32's)
23840 - * @length: length of next SGL segment
23841 - * @dma_addr: Physical address
23842 - *
23843 - * This routine places a MPT request frame back on the MPT adapter's
23844 - * FreeQ.
23845 - */
23846 -static inline void
23847 -mptscsih_add_chain(char *pAddr, u8 next, u16 length, dma_addr_t dma_addr)
23848 -{
23849 - if (sizeof(dma_addr_t) == sizeof(u64)) {
23850 - SGEChain64_t *pChain = (SGEChain64_t *) pAddr;
23851 - u32 tmp = dma_addr & 0xFFFFFFFF;
23852 -
23853 - pChain->Length = cpu_to_le16(length);
23854 - pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
23855 -
23856 - pChain->NextChainOffset = next;
23857 -
23858 - pChain->Address.Low = cpu_to_le32(tmp);
23859 - tmp = (u32) ((u64)dma_addr >> 32);
23860 - pChain->Address.High = cpu_to_le32(tmp);
23861 - } else {
23862 - SGEChain32_t *pChain = (SGEChain32_t *) pAddr;
23863 - pChain->Length = cpu_to_le16(length);
23864 - pChain->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT | mpt_addr_size();
23865 - pChain->NextChainOffset = next;
23866 - pChain->Address = cpu_to_le32(dma_addr);
23867 - }
23868 -} /* mptscsih_add_chain() */
23869 -
23870 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23871 -/*
23872 * mptscsih_getFreeChainBuffer - Function to get a free chain
23873 * from the MPT_SCSI_HOST FreeChainQ.
23874 * @ioc: Pointer to MPT_ADAPTER structure
23875 * @req_idx: Index of the SCSI IO request frame. (output)
23876 *
23877 * return SUCCESS or FAILED
23878 - */
23879 + **/
23880 static inline int
23881 mptscsih_getFreeChainBuffer(MPT_ADAPTER *ioc, int *retIndex)
23882 {
23883 @@ -195,7 +131,7 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
23884 int chain_idx;
23885
23886 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer called\n",
23887 - ioc->name));
23888 + ioc->name));
23889 spin_lock_irqsave(&ioc->FreeQlock, flags);
23890 if (!list_empty(&ioc->FreeChainQ)) {
23891 int offset;
23892 @@ -206,14 +142,13 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
23893 offset = (u8 *)chainBuf - (u8 *)ioc->ChainBuffer;
23894 chain_idx = offset / ioc->req_sz;
23895 rc = SUCCESS;
23896 - dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT
23897 - "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
23898 - ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
23899 + dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "getFreeChainBuffer chainBuf=%p ChainBuffer=%p offset=%d chain_idx=%d\n",
23900 + ioc->name, chainBuf, ioc->ChainBuffer, offset, chain_idx));
23901 } else {
23902 rc = FAILED;
23903 chain_idx = MPT_HOST_NO_CHAIN;
23904 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "getFreeChainBuffer failed\n",
23905 - ioc->name));
23906 + ioc->name));
23907 }
23908 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
23909
23910 @@ -222,7 +157,7 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
23911 } /* mptscsih_getFreeChainBuffer() */
23912
23913 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
23914 -/*
23915 +/**
23916 * mptscsih_AddSGE - Add a SGE (plus chain buffers) to the
23917 * SCSIIORequest_t Message Frame.
23918 * @ioc: Pointer to MPT_ADAPTER structure
23919 @@ -230,7 +165,7 @@ mptscsih_getFreeChainBuffer(MPT_ADAPTER
23920 * @pReq: Pointer to SCSIIORequest_t structure
23921 *
23922 * Returns ...
23923 - */
23924 + **/
23925 static int
23926 mptscsih_AddSGE(MPT_ADAPTER *ioc, struct scsi_cmnd *SCpnt,
23927 SCSIIORequest_t *pReq, int req_idx)
23928 @@ -281,10 +216,10 @@ mptscsih_AddSGE(MPT_ADAPTER *ioc, struct
23929 */
23930
23931 nextSGEset:
23932 - numSgeSlots = ((frm_sz - sgeOffset) / (sizeof(u32) + sizeof(dma_addr_t)) );
23933 + numSgeSlots = ((frm_sz - sgeOffset) / ioc->SGE_size );
23934 numSgeThisFrame = (sges_left < numSgeSlots) ? sges_left : numSgeSlots;
23935
23936 - sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | MPT_SGE_FLAGS_ADDRESSING | sgdir;
23937 + sgflags = MPT_SGE_FLAGS_SIMPLE_ELEMENT | sgdir;
23938
23939 /* Get first (num - 1) SG elements
23940 * Skip any SG entries with a length of 0
23941 @@ -299,11 +234,11 @@ nextSGEset:
23942 }
23943
23944 v2 = sg_dma_address(sg);
23945 - mptscsih_add_sge(psge, sgflags | thisxfer, v2);
23946 + ioc->add_sge(psge, sgflags | thisxfer, v2);
23947
23948 sg = sg_next(sg); /* Get next SG element from the OS */
23949 - psge += (sizeof(u32) + sizeof(dma_addr_t));
23950 - sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
23951 + psge += ioc->SGE_size;
23952 + sgeOffset += ioc->SGE_size;
23953 sg_done++;
23954 }
23955
23956 @@ -320,12 +255,8 @@ nextSGEset:
23957 thisxfer = sg_dma_len(sg);
23958
23959 v2 = sg_dma_address(sg);
23960 - mptscsih_add_sge(psge, sgflags | thisxfer, v2);
23961 - /*
23962 - sg = sg_next(sg);
23963 - psge += (sizeof(u32) + sizeof(dma_addr_t));
23964 - */
23965 - sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
23966 + ioc->add_sge(psge, sgflags | thisxfer, v2);
23967 + sgeOffset += ioc->SGE_size;
23968 sg_done++;
23969
23970 if (chainSge) {
23971 @@ -334,7 +265,7 @@ nextSGEset:
23972 * Update the chain element
23973 * Offset and Length fields.
23974 */
23975 - mptscsih_add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
23976 + ioc->add_chain((char *)chainSge, 0, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
23977 } else {
23978 /* The current buffer is the original MF
23979 * and there is no Chain buffer.
23980 @@ -367,7 +298,7 @@ nextSGEset:
23981 * set properly).
23982 */
23983 if (sg_done) {
23984 - u32 *ptmp = (u32 *) (psge - (sizeof(u32) + sizeof(dma_addr_t)));
23985 + u32 *ptmp = (u32 *) (psge - ioc->SGE_size);
23986 sgflags = le32_to_cpu(*ptmp);
23987 sgflags |= MPT_SGE_FLAGS_LAST_ELEMENT;
23988 *ptmp = cpu_to_le32(sgflags);
23989 @@ -381,8 +312,8 @@ nextSGEset:
23990 * Old chain element is now complete.
23991 */
23992 u8 nextChain = (u8) (sgeOffset >> 2);
23993 - sgeOffset += (sizeof(u32) + sizeof(dma_addr_t));
23994 - mptscsih_add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
23995 + sgeOffset += ioc->SGE_size;
23996 + ioc->add_chain((char *)chainSge, nextChain, sgeOffset, ioc->ChainBufferDMA + chain_dma_off);
23997 } else {
23998 /* The original MF buffer requires a chain buffer -
23999 * set the offset.
24000 @@ -461,7 +392,7 @@ mptscsih_issue_sep_command(MPT_ADAPTER *
24001
24002 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
24003 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!!\n",
24004 - ioc->name,__func__));
24005 + ioc->name,__FUNCTION__));
24006 return;
24007 }
24008
24009 @@ -592,14 +523,14 @@ mptscsih_info_scsiio(MPT_ADAPTER *ioc, s
24010 }
24011
24012 scsi_print_command(sc);
24013 - printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d\n",
24014 - ioc->name, pScsiReply->Bus, pScsiReply->TargetID);
24015 - printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, "
24016 - "resid = %d\n", ioc->name, scsi_bufflen(sc), sc->underflow,
24017 - scsi_get_resid(sc));
24018 - printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, "
24019 - "sc->result = %08X\n", ioc->name, le16_to_cpu(pScsiReply->TaskTag),
24020 + printk(MYIOC_s_DEBUG_FMT "\tfw_channel = %d, fw_id = %d, lun = %d\n",
24021 + ioc->name, pScsiReply->Bus, pScsiReply->TargetID, sc->device->lun);
24022 + printk(MYIOC_s_DEBUG_FMT "\trequest_len = %d, underflow = %d, resid = %d\n",
24023 + ioc->name, scsi_bufflen(sc), sc->underflow, scsi_get_resid(sc));
24024 + printk(MYIOC_s_DEBUG_FMT "\ttag = %d, transfer_count = %d, sc->result = %08X\n",
24025 + ioc->name, le16_to_cpu(pScsiReply->TaskTag),
24026 le32_to_cpu(pScsiReply->TransferCount), sc->result);
24027 +
24028 printk(MYIOC_s_DEBUG_FMT "\tiocstatus = %s (0x%04x), "
24029 "scsi_status = %s (0x%02x), scsi_state = (0x%02x)\n",
24030 ioc->name, desc, ioc_status, desc1, pScsiReply->SCSIStatus,
24031 @@ -625,7 +556,7 @@ mptscsih_info_scsiio(MPT_ADAPTER *ioc, s
24032 #endif
24033
24034 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24035 -/*
24036 +/**
24037 * mptscsih_io_done - Main SCSI IO callback routine registered to
24038 * Fusion MPT (base) driver
24039 * @ioc: Pointer to MPT_ADAPTER structure
24040 @@ -638,7 +569,7 @@ mptscsih_info_scsiio(MPT_ADAPTER *ioc, s
24041 * load/init time via the mpt_register() API call.
24042 *
24043 * Returns 1 indicating alloc'd request frame ptr should be freed.
24044 - */
24045 + **/
24046 int
24047 mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
24048 {
24049 @@ -651,14 +582,15 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24050 VirtTarget *vtarget;
24051
24052 hd = shost_priv(ioc->sh);
24053 +
24054 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
24055 req_idx_MR = (mr != NULL) ?
24056 le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx) : req_idx;
24057 if ((req_idx != req_idx_MR) ||
24058 - (mf->u.frame.linkage.arg1 == 0xdeadbeaf)) {
24059 - printk(MYIOC_s_ERR_FMT "Received a mf that was already freed\n",
24060 - ioc->name);
24061 - printk (MYIOC_s_ERR_FMT
24062 + (le32_to_cpu(mf->u.frame.linkage.arg1) == 0xdeadbeaf)) {
24063 + printk(MYIOC_s_WARN_FMT
24064 + "Received a mf that was already freed\n", ioc->name);
24065 + printk (MYIOC_s_WARN_FMT
24066 "req_idx=%x req_idx_MR=%x mf=%p mr=%p sc=%p\n",
24067 ioc->name, req_idx, req_idx_MR, mf, mr,
24068 mptscsih_get_scsi_lookup(ioc, req_idx_MR));
24069 @@ -693,7 +625,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24070
24071 if((ioc->facts.MsgVersion >= MPI_VERSION_01_05) && pScsiReply){
24072 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24073 - "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task-tag=%d)\n",
24074 + "ScsiDone (mf=%p,mr=%p,sc=%p,idx=%d,task_tag=%d)\n",
24075 ioc->name, mf, mr, sc, req_idx, pScsiReply->TaskTag));
24076 }else{
24077 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24078 @@ -706,6 +638,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24079 ;
24080 } else {
24081 u32 xfer_cnt;
24082 + u32 difftransfer;
24083 u16 status;
24084 u8 scsi_state, scsi_status;
24085 u32 log_info;
24086 @@ -716,6 +649,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24087 xfer_cnt = le32_to_cpu(pScsiReply->TransferCount);
24088 scsi_set_resid(sc, scsi_bufflen(sc) - xfer_cnt);
24089 log_info = le32_to_cpu(pScsiReply->IOCLogInfo);
24090 + vdevice = sc->device->hostdata;
24091
24092 /*
24093 * if we get a data underrun indication, yet no data was
24094 @@ -733,20 +667,9 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24095 if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)
24096 mptscsih_copy_sense_data(sc, hd, mf, pScsiReply);
24097
24098 - /*
24099 - * Look for + dump FCP ResponseInfo[]!
24100 - */
24101 - if (scsi_state & MPI_SCSI_STATE_RESPONSE_INFO_VALID &&
24102 - pScsiReply->ResponseInfo) {
24103 - printk(MYIOC_s_NOTE_FMT "[%d:%d:%d:%d] "
24104 - "FCP_ResponseInfo=%08xh\n", ioc->name,
24105 - sc->device->host->host_no, sc->device->channel,
24106 - sc->device->id, sc->device->lun,
24107 - le32_to_cpu(pScsiReply->ResponseInfo));
24108 - }
24109 -
24110 switch(status) {
24111 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
24112 + case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
24113 /* CHECKME!
24114 * Maybe: DRIVER_BUSY | SUGGEST_RETRY | DID_SOFT_ERROR (retry)
24115 * But not: DID_BUS_BUSY lest one risk
24116 @@ -771,7 +694,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24117 if (hd->sel_timeout[pScsiReq->TargetID] < 0xFFFF)
24118 hd->sel_timeout[pScsiReq->TargetID]++;
24119
24120 - vdevice = sc->device->hostdata;
24121 if (!vdevice)
24122 break;
24123 vtarget = vdevice->vtarget;
24124 @@ -793,14 +715,11 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24125 }
24126 }
24127 } else if (ioc->bus_type == FC) {
24128 - /*
24129 - * The FC IOC may kill a request for variety of
24130 - * reasons, some of which may be recovered by a
24131 - * retry, some which are unlikely to be
24132 - * recovered. Return DID_ERROR instead of
24133 - * DID_RESET to permit retry of the command,
24134 - * just not an infinite number of them
24135 - */
24136 + /* The FC IOC may kill a request for variety of reasons,
24137 + some of which may be recovered by a retry, some which
24138 + are unlikely to be recovered. Return DID_ERROR instead
24139 + of DID_RESET to permit retry of the command, just not
24140 + an infinite number of them */
24141 sc->result = DID_ERROR << 16;
24142 break;
24143 }
24144 @@ -810,12 +729,16 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24145 */
24146
24147 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
24148 - case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
24149 /* Linux handles an unsolicited DID_RESET better
24150 * than an unsolicited DID_ABORT.
24151 */
24152 sc->result = DID_RESET << 16;
24153
24154 + case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
24155 + if ( ioc->bus_type == FC )
24156 + sc->result = DID_ERROR << 16;
24157 + else
24158 + sc->result = DID_RESET << 16;
24159 break;
24160
24161 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
24162 @@ -824,9 +747,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24163 sc->result=DID_SOFT_ERROR << 16;
24164 else /* Sufficient data transfer occurred */
24165 sc->result = (DID_OK << 16) | scsi_status;
24166 - dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24167 - "RESIDUAL_MISMATCH: result=%x on channel=%d id=%d\n",
24168 - ioc->name, sc->result, sc->device->channel, sc->device->id));
24169 break;
24170
24171 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
24172 @@ -835,11 +755,34 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24173 * precedence!
24174 */
24175 sc->result = (DID_OK << 16) | scsi_status;
24176 - if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
24177 - /* Have already saved the status and sense data
24178 +
24179 + if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
24180 +
24181 + /*
24182 + * For an Errata on LSI53C1030
24183 + * When the length of request data
24184 + * and transfer data are different
24185 + * with result of command (READ or VERIFY),
24186 + * DID_SOFT_ERROR is set.
24187 */
24188 - ;
24189 - } else {
24190 + if (ioc->bus_type == SPI && vdevice &&
24191 + vdevice->vtarget->type == TYPE_DISK) {
24192 + if (pScsiReq->CDB[0] == READ_6 ||
24193 + pScsiReq->CDB[0] == READ_10 ||
24194 + pScsiReq->CDB[0] == READ_12 ||
24195 + pScsiReq->CDB[0] == READ_16 ||
24196 + pScsiReq->CDB[0] == VERIFY ||
24197 + pScsiReq->CDB[0] == VERIFY_16) {
24198 + if (scsi_bufflen(sc) !=
24199 + xfer_cnt) {
24200 + sc->result = DID_SOFT_ERROR << 16;
24201 + printk(MYIOC_s_WARN_FMT "Errata"
24202 + "on LSI53C1030 occurred. sc->request_bufflen=0x%02x, "
24203 + "xfer_cnt=0x%02x\n", ioc->name, scsi_bufflen(sc), xfer_cnt);
24204 + }
24205 + }
24206 + }
24207 +
24208 if (xfer_cnt < sc->underflow) {
24209 if (scsi_status == SAM_STAT_BUSY)
24210 sc->result = SAM_STAT_BUSY;
24211 @@ -848,7 +791,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24212 }
24213 if (scsi_state & (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)) {
24214 /* What to do?
24215 - */
24216 + */
24217 sc->result = DID_SOFT_ERROR << 16;
24218 }
24219 else if (scsi_state & MPI_SCSI_STATE_TERMINATED) {
24220 @@ -857,13 +800,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24221 }
24222 }
24223
24224 -
24225 - dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24226 - " sc->underflow={report ERR if < %02xh bytes xfer'd}\n",
24227 - ioc->name, sc->underflow));
24228 - dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24229 - " ActBytesXferd=%02xh\n", ioc->name, xfer_cnt));
24230 -
24231 /* Report Queue Full
24232 */
24233 if (scsi_status == MPI_SCSI_STATUS_TASK_SET_FULL)
24234 @@ -879,6 +815,44 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24235 if (scsi_state == 0) {
24236 ;
24237 } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
24238 +
24239 + /*
24240 + * For potential trouble on LSI53C1030. (date:2007.xx.)
24241 + * It is checked whether the length of request data is equal to
24242 + * the length of transfer and residual.
24243 + * MEDIUM_ERROR is set by incorrect data.
24244 + */
24245 + if (ioc->bus_type == SPI && vdevice &&
24246 + vdevice->vtarget->type == TYPE_DISK) {
24247 + if (sc->sense_buffer[2] & 0x20) {
24248 + difftransfer =
24249 + sc->sense_buffer[3] << 24 |
24250 + sc->sense_buffer[4] << 16 |
24251 + sc->sense_buffer[5] << 8 |
24252 + sc->sense_buffer[6];
24253 + if ((sc->sense_buffer[3] & 0x80) == 0x80) {
24254 + if (scsi_bufflen(sc) != xfer_cnt) {
24255 + sc->sense_buffer[2] = MEDIUM_ERROR;
24256 + sc->sense_buffer[12] = 0xff;
24257 + sc->sense_buffer[13] = 0xff;
24258 + printk(MYIOC_s_WARN_FMT "Errata on "
24259 + "LSI53C1030 occurred. sc->request_bufflen=0x%02x,"
24260 + "xfer_cnt=0x%02x\n", ioc->name, scsi_bufflen(sc), xfer_cnt);
24261 + }
24262 + } else {
24263 + if (scsi_bufflen(sc) != xfer_cnt + difftransfer) {
24264 + sc->sense_buffer[2] = MEDIUM_ERROR;
24265 + sc->sense_buffer[12] = 0xff;
24266 + sc->sense_buffer[13] = 0xff;
24267 + printk(MYIOC_s_WARN_FMT "Errata on "
24268 + "LSI53C1030 occurred. sc->request_bufflen=0x%02x,"
24269 + " xfer_cnt=0x%02x, difftransfer=0x%02x\n",
24270 + ioc->name, scsi_bufflen(sc) , xfer_cnt, difftransfer);
24271 + }
24272 + }
24273 + }
24274 + }
24275 +
24276 /*
24277 * If running against circa 200003dd 909 MPT f/w,
24278 * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
24279 @@ -890,7 +864,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24280
24281 }
24282 else if (scsi_state &
24283 - (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
24284 + (MPI_SCSI_STATE_AUTOSENSE_FAILED | MPI_SCSI_STATE_NO_SCSI_STATUS)
24285 ) {
24286 /*
24287 * What to do?
24288 @@ -926,7 +900,6 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24289 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
24290 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
24291 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
24292 - case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
24293 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
24294 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
24295 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
24296 @@ -957,7 +930,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24297 return 1;
24298 }
24299
24300 -/*
24301 +/**
24302 * mptscsih_flush_running_cmds - For each command found, search
24303 * Scsi_Host instance taskQ and reply to OS.
24304 * Called only if recovering from a FW reload.
24305 @@ -966,7 +939,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_F
24306 * Returns: None.
24307 *
24308 * Must be called while new I/Os are being queued.
24309 - */
24310 + **/
24311 static void
24312 mptscsih_flush_running_cmds(MPT_SCSI_HOST *hd)
24313 {
24314 @@ -992,14 +965,14 @@ mptscsih_flush_running_cmds(MPT_SCSI_HOS
24315 scsi_dma_unmap(sc);
24316 sc->result = DID_RESET << 16;
24317 sc->host_scribble = NULL;
24318 - sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
24319 - "completing cmds: fw_channel %d, fw_id %d, sc=%p,"
24320 - " mf = %p, idx=%x\n", ioc->name, channel, id, sc, mf, ii);
24321 + dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT
24322 + "completing cmds: fw_channel %d, fw_id %d, sc=%p, mf = %p, "
24323 + "idx=%x\n", ioc->name, channel, id, sc, mf, ii));
24324 sc->scsi_done(sc);
24325 }
24326 }
24327
24328 -/*
24329 +/**
24330 * mptscsih_search_running_cmds - Delete any commands associated
24331 * with the specified target and lun. Function called only
24332 * when a lun is disable by mid-layer.
24333 @@ -1012,15 +985,15 @@ mptscsih_flush_running_cmds(MPT_SCSI_HOS
24334 * Returns: None.
24335 *
24336 * Called from slave_destroy.
24337 - */
24338 + **/
24339 static void
24340 mptscsih_search_running_cmds(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
24341 {
24342 SCSIIORequest_t *mf = NULL;
24343 int ii;
24344 struct scsi_cmnd *sc;
24345 - struct scsi_lun lun;
24346 - MPT_ADAPTER *ioc = hd->ioc;
24347 + struct scsi_lun lun;
24348 + MPT_ADAPTER *ioc = hd->ioc;
24349 unsigned long flags;
24350
24351 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
24352 @@ -1030,8 +1003,11 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
24353 mf = (SCSIIORequest_t *)MPT_INDEX_2_MFPTR(ioc, ii);
24354 if (mf == NULL)
24355 continue;
24356 - /* If the device is a hidden raid component, then its
24357 - * expected that the mf->function will be RAID_SCSI_IO
24358 +
24359 + /*
24360 + * If the device is a hidden raid component,
24361 + * then its expected that
24362 + * the function would be raid scsi io
24363 */
24364 if (vdevice->vtarget->tflags &
24365 MPT_TARGET_FLAGS_RAID_COMPONENT && mf->Function !=
24366 @@ -1053,9 +1029,11 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
24367 scsi_dma_unmap(sc);
24368 sc->host_scribble = NULL;
24369 sc->result = DID_NO_CONNECT << 16;
24370 - sdev_printk(KERN_INFO, sc->device, MYIOC_s_FMT "completing cmds: fw_channel %d,"
24371 - "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name, vdevice->vtarget->channel,
24372 - vdevice->vtarget->id, sc, mf, ii);
24373 + dtmprintk(ioc, sdev_printk(KERN_INFO, sc->device,
24374 + MYIOC_s_FMT "completing cmds: fw_channel %d, "
24375 + "fw_id %d, sc=%p, mf = %p, idx=%x\n", ioc->name,
24376 + vdevice->vtarget->channel, vdevice->vtarget->id,
24377 + sc, mf, ii));
24378 sc->scsi_done(sc);
24379 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
24380 }
24381 @@ -1067,7 +1045,7 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
24382 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24383
24384 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24385 -/*
24386 +/**
24387 * mptscsih_report_queue_full - Report QUEUE_FULL status returned
24388 * from a SCSI target device.
24389 * @sc: Pointer to scsi_cmnd structure
24390 @@ -1077,12 +1055,12 @@ mptscsih_search_running_cmds(MPT_SCSI_HO
24391 * This routine periodically reports QUEUE_FULL status returned from a
24392 * SCSI target device. It reports this to the console via kernel
24393 * printk() API call, not more than once every 10 seconds.
24394 - */
24395 + **/
24396 static void
24397 mptscsih_report_queue_full(struct scsi_cmnd *sc, SCSIIOReply_t *pScsiReply, SCSIIORequest_t *pScsiReq)
24398 {
24399 long time = jiffies;
24400 - MPT_SCSI_HOST *hd;
24401 + MPT_SCSI_HOST *hd;
24402 MPT_ADAPTER *ioc;
24403
24404 if (sc->device == NULL)
24405 @@ -1100,12 +1078,12 @@ mptscsih_report_queue_full(struct scsi_c
24406 }
24407
24408 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24409 -/*
24410 +/**
24411 * mptscsih_remove - Removed scsi devices
24412 * @pdev: Pointer to pci_dev structure
24413 *
24414 *
24415 - */
24416 + **/
24417 void
24418 mptscsih_remove(struct pci_dev *pdev)
24419 {
24420 @@ -1151,10 +1129,10 @@ mptscsih_remove(struct pci_dev *pdev)
24421 }
24422
24423 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24424 -/*
24425 +/**
24426 * mptscsih_shutdown - reboot notifier
24427 *
24428 - */
24429 + **/
24430 void
24431 mptscsih_shutdown(struct pci_dev *pdev)
24432 {
24433 @@ -1162,11 +1140,11 @@ mptscsih_shutdown(struct pci_dev *pdev)
24434
24435 #ifdef CONFIG_PM
24436 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24437 -/*
24438 +/**
24439 * mptscsih_suspend - Fusion MPT scsi driver suspend routine.
24440 *
24441 *
24442 - */
24443 + **/
24444 int
24445 mptscsih_suspend(struct pci_dev *pdev, pm_message_t state)
24446 {
24447 @@ -1179,11 +1157,11 @@ mptscsih_suspend(struct pci_dev *pdev, p
24448 }
24449
24450 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24451 -/*
24452 +/**
24453 * mptscsih_resume - Fusion MPT scsi driver resume routine.
24454 *
24455 *
24456 - */
24457 + **/
24458 int
24459 mptscsih_resume(struct pci_dev *pdev)
24460 {
24461 @@ -1205,7 +1183,7 @@ mptscsih_resume(struct pci_dev *pdev)
24462 * (linux scsi_host_template.info routine)
24463 *
24464 * Returns pointer to buffer where information was written.
24465 - */
24466 + **/
24467 const char *
24468 mptscsih_info(struct Scsi_Host *SChost)
24469 {
24470 @@ -1338,7 +1316,7 @@ mptscsih_proc_info(struct Scsi_Host *hos
24471 * from a linux scsi_cmnd request and send it to the IOC.
24472 *
24473 * Returns 0. (rtn value discarded by linux scsi mid-layer)
24474 - */
24475 + **/
24476 int
24477 mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
24478 {
24479 @@ -1346,7 +1324,6 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
24480 MPT_FRAME_HDR *mf;
24481 SCSIIORequest_t *pScsiReq;
24482 VirtDevice *vdevice = SCpnt->device->hostdata;
24483 - int lun;
24484 u32 datalen;
24485 u32 scsictl;
24486 u32 scsidir;
24487 @@ -1357,24 +1334,20 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
24488
24489 hd = shost_priv(SCpnt->device->host);
24490 ioc = hd->ioc;
24491 - lun = SCpnt->device->lun;
24492 SCpnt->scsi_done = done;
24493
24494 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p, done()=%p\n",
24495 ioc->name, SCpnt, done));
24496
24497 - if (hd->resetPending) {
24498 - dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
24499 - ioc->name, SCpnt));
24500 + if (ioc->taskmgmt_quiesce_io)
24501 return SCSI_MLQUEUE_HOST_BUSY;
24502 - }
24503
24504 /*
24505 * Put together a MPT SCSI request...
24506 */
24507 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
24508 dprintk(ioc, printk(MYIOC_s_WARN_FMT "QueueCmd, no msg frames!!\n",
24509 - ioc->name));
24510 + ioc->name));
24511 return SCSI_MLQUEUE_HOST_BUSY;
24512 }
24513
24514 @@ -1422,7 +1395,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
24515 pScsiReq->CDBLength = SCpnt->cmd_len;
24516 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
24517 pScsiReq->Reserved = 0;
24518 - pScsiReq->MsgFlags = mpt_msg_flags();
24519 + pScsiReq->MsgFlags = mpt_msg_flags(ioc);
24520 int_to_scsilun(SCpnt->device->lun, (struct scsi_lun *)pScsiReq->LUN);
24521 pScsiReq->Control = cpu_to_le32(scsictl);
24522
24523 @@ -1448,7 +1421,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
24524 */
24525 if (datalen == 0) {
24526 /* Add a NULL SGE */
24527 - mptscsih_add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0,
24528 + ioc->add_sge((char *)&pScsiReq->SGL, MPT_SGE_FLAGS_SSIMPLE_READ | 0,
24529 (dma_addr_t) -1);
24530 } else {
24531 /* Add a 32 or 64 bit SGE */
24532 @@ -1472,7 +1445,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
24533 }
24534
24535 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24536 -/*
24537 +/**
24538 * mptscsih_freeChainBuffers - Function to free chain buffers associated
24539 * with a SCSI IO request
24540 * @hd: Pointer to the MPT_SCSI_HOST instance
24541 @@ -1480,7 +1453,7 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, v
24542 *
24543 * Called if SG chain buffer allocation fails and mptscsih callbacks.
24544 * No return.
24545 - */
24546 + **/
24547 static void
24548 mptscsih_freeChainBuffers(MPT_ADAPTER *ioc, int req_idx)
24549 {
24550 @@ -1527,243 +1500,457 @@ mptscsih_freeChainBuffers(MPT_ADAPTER *i
24551 */
24552
24553 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24554 -/**
24555 - * mptscsih_TMHandler - Generic handler for SCSI Task Management.
24556 - * @hd: Pointer to MPT SCSI HOST structure
24557 - * @type: Task Management type
24558 - * @channel: channel number for task management
24559 - * @id: Logical Target ID for reset (if appropriate)
24560 - * @lun: Logical Unit for reset (if appropriate)
24561 - * @ctx2abort: Context for the task to be aborted (if appropriate)
24562 - * @timeout: timeout for task management control
24563 - *
24564 - * Fall through to mpt_HardResetHandler if: not operational, too many
24565 - * failed TM requests or handshake failure.
24566 - *
24567 - * Remark: Currently invoked from a non-interrupt thread (_bh).
24568 - *
24569 - * Note: With old EH code, at most 1 SCSI TaskMgmt function per IOC
24570 - * will be active.
24571 - *
24572 - * Returns 0 for SUCCESS, or %FAILED.
24573 - **/
24574 -int
24575 -mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout)
24576 -{
24577 - MPT_ADAPTER *ioc;
24578 - int rc = -1;
24579 - u32 ioc_raw_state;
24580 - unsigned long flags;
24581 -
24582 - ioc = hd->ioc;
24583 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler Entered!\n", ioc->name));
24584 -
24585 - // SJR - CHECKME - Can we avoid this here?
24586 - // (mpt_HardResetHandler has this check...)
24587 - spin_lock_irqsave(&ioc->diagLock, flags);
24588 - if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)) {
24589 - spin_unlock_irqrestore(&ioc->diagLock, flags);
24590 - return FAILED;
24591 - }
24592 - spin_unlock_irqrestore(&ioc->diagLock, flags);
24593 -
24594 - /* Wait a fixed amount of time for the TM pending flag to be cleared.
24595 - * If we time out and not bus reset, then we return a FAILED status
24596 - * to the caller.
24597 - * The call to mptscsih_tm_pending_wait() will set the pending flag
24598 - * if we are
24599 - * successful. Otherwise, reload the FW.
24600 - */
24601 - if (mptscsih_tm_pending_wait(hd) == FAILED) {
24602 - if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
24603 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler abort: "
24604 - "Timed out waiting for last TM (%d) to complete! \n",
24605 - ioc->name, hd->tmPending));
24606 - return FAILED;
24607 - } else if (type == MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET) {
24608 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler target "
24609 - "reset: Timed out waiting for last TM (%d) "
24610 - "to complete! \n", ioc->name,
24611 - hd->tmPending));
24612 - return FAILED;
24613 - } else if (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS) {
24614 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TMHandler bus reset: "
24615 - "Timed out waiting for last TM (%d) to complete! \n",
24616 - ioc->name, hd->tmPending));
24617 - return FAILED;
24618 - }
24619 - } else {
24620 - spin_lock_irqsave(&ioc->FreeQlock, flags);
24621 - hd->tmPending |= (1 << type);
24622 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
24623 - }
24624 -
24625 - ioc_raw_state = mpt_GetIocState(ioc, 0);
24626 -
24627 - if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
24628 - printk(MYIOC_s_WARN_FMT
24629 - "TM Handler for type=%x: IOC Not operational (0x%x)!\n",
24630 - ioc->name, type, ioc_raw_state);
24631 - printk(MYIOC_s_WARN_FMT " Issuing HardReset!!\n", ioc->name);
24632 - if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
24633 - printk(MYIOC_s_WARN_FMT "TMHandler: HardReset "
24634 - "FAILED!!\n", ioc->name);
24635 - return FAILED;
24636 - }
24637 -
24638 - if (ioc_raw_state & MPI_DOORBELL_ACTIVE) {
24639 - printk(MYIOC_s_WARN_FMT
24640 - "TM Handler for type=%x: ioc_state: "
24641 - "DOORBELL_ACTIVE (0x%x)!\n",
24642 - ioc->name, type, ioc_raw_state);
24643 - return FAILED;
24644 - }
24645 -
24646 - /* Isse the Task Mgmt request.
24647 - */
24648 - if (hd->hard_resets < -1)
24649 - hd->hard_resets++;
24650 -
24651 - rc = mptscsih_IssueTaskMgmt(hd, type, channel, id, lun,
24652 - ctx2abort, timeout);
24653 - if (rc)
24654 - printk(MYIOC_s_INFO_FMT "Issue of TaskMgmt failed!\n",
24655 - ioc->name);
24656 - else
24657 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Issue of TaskMgmt Successful!\n",
24658 - ioc->name));
24659 -
24660 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24661 - "TMHandler rc = %d!\n", ioc->name, rc));
24662 -
24663 - return rc;
24664 -}
24665 -
24666 -
24667 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
24668 -/**
24669 - * mptscsih_IssueTaskMgmt - Generic send Task Management function.
24670 - * @hd: Pointer to MPT_SCSI_HOST structure
24671 - * @type: Task Management type
24672 - * @channel: channel number for task management
24673 - * @id: Logical Target ID for reset (if appropriate)
24674 - * @lun: Logical Unit for reset (if appropriate)
24675 - * @ctx2abort: Context for the task to be aborted (if appropriate)
24676 - * @timeout: timeout for task management control
24677 - *
24678 - * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
24679 - * or a non-interrupt thread. In the former, must not call schedule().
24680 - *
24681 - * Not all fields are meaningfull for all task types.
24682 - *
24683 - * Returns 0 for SUCCESS, or FAILED.
24684 - *
24685 - **/
24686 +
24687 static int
24688 -mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout)
24689 +mptscsih_scandv_bus_reset(MPT_ADAPTER *ioc)
24690 {
24691 MPT_FRAME_HDR *mf;
24692 SCSITaskMgmt_t *pScsiTm;
24693 + SCSITaskMgmtReply_t *pScsiTmReply;
24694 int ii;
24695 int retval;
24696 - MPT_ADAPTER *ioc = hd->ioc;
24697 + unsigned long timeout;
24698 + unsigned long time_count;
24699 + u16 iocstatus;
24700 +
24701 + mutex_lock(&ioc->taskmgmt_cmds.mutex);
24702 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
24703 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
24704 + return -EPERM;
24705 + }
24706
24707 - /* Return Fail to calling function if no message frames available.
24708 + /* Send request
24709 */
24710 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
24711 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "IssueTaskMgmt, no msg frames!!\n",
24712 + dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt, no msg frames!!\n",
24713 ioc->name));
24714 - return FAILED;
24715 + mpt_clear_taskmgmt_in_progress_flag(ioc);
24716 + retval = -ENOMEM;
24717 + goto out;
24718 }
24719 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt request @ %p\n",
24720 - ioc->name, mf));
24721
24722 - /* Format the Request
24723 - */
24724 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
24725 + ioc->name, mf));
24726 +
24727 pScsiTm = (SCSITaskMgmt_t *) mf;
24728 - pScsiTm->TargetID = id;
24729 - pScsiTm->Bus = channel;
24730 - pScsiTm->ChainOffset = 0;
24731 + memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t));
24732 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
24733 -
24734 + pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS;
24735 + pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION;
24736 + pScsiTm->TargetID = 0;
24737 + pScsiTm->Bus = 0;
24738 + pScsiTm->ChainOffset = 0;
24739 pScsiTm->Reserved = 0;
24740 - pScsiTm->TaskType = type;
24741 pScsiTm->Reserved1 = 0;
24742 - pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
24743 - ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
24744 -
24745 - int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
24746 -
24747 + pScsiTm->TaskMsgContext = 0;
24748 + for (ii= 0; ii < 8; ii++)
24749 + pScsiTm->LUN[ii] = 0;
24750 for (ii=0; ii < 7; ii++)
24751 pScsiTm->Reserved2[ii] = 0;
24752
24753 - pScsiTm->TaskMsgContext = ctx2abort;
24754 -
24755 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IssueTaskMgmt: ctx2abort (0x%08x) "
24756 - "type=%d\n", ioc->name, ctx2abort, type));
24757 + switch (ioc->bus_type) {
24758 + case FC:
24759 + timeout = 40;
24760 + break;
24761 + case SAS:
24762 + timeout = 30;
24763 + break;
24764 + case SPI:
24765 + default:
24766 + timeout = 2;
24767 + break;
24768 + }
24769
24770 - DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
24771 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt type=%d timeout=%ld\n",
24772 + ioc->name, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, timeout));
24773
24774 + INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
24775 + CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
24776 + retval = 0;
24777 + time_count = jiffies;
24778 if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
24779 (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
24780 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
24781 else {
24782 retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
24783 - sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
24784 - if (retval) {
24785 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "send_handshake FAILED!"
24786 - " (hd %p, ioc %p, mf %p, rc=%d) \n", ioc->name, hd,
24787 - ioc, mf, retval));
24788 - goto fail_out;
24789 + sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
24790 + if (retval != 0) {
24791 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt send_handshake FAILED!"
24792 + " (ioc %p, mf %p, rc=%d) \n", ioc->name,
24793 + ioc, mf, retval));
24794 + mpt_clear_taskmgmt_in_progress_flag(ioc);
24795 + goto out;
24796 }
24797 }
24798
24799 - if(mptscsih_tm_wait_for_completion(hd, timeout) == FAILED) {
24800 - dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "task management request TIMED OUT!"
24801 - " (hd %p, ioc %p, mf %p) \n", ioc->name, hd,
24802 - ioc, mf));
24803 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling HardReset! \n",
24804 - ioc->name));
24805 - retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
24806 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rc=%d \n",
24807 - ioc->name, retval));
24808 - goto fail_out;
24809 + /* Now wait for the command to complete */
24810 + ii = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
24811 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
24812 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24813 + "TaskMgmt failed\n", ioc->name));
24814 + mpt_free_msg_frame(ioc, mf);
24815 + mpt_clear_taskmgmt_in_progress_flag(ioc);
24816 + retval = -1; /* return failure */
24817 + goto out;
24818 }
24819
24820 - /*
24821 - * Handle success case, see if theres a non-zero ioc_status.
24822 - */
24823 - if (hd->tm_iocstatus == MPI_IOCSTATUS_SUCCESS ||
24824 - hd->tm_iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
24825 - hd->tm_iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
24826 - retval = 0;
24827 - else
24828 - retval = FAILED;
24829 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
24830 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24831 + "TaskMgmt failed\n", ioc->name));
24832 + retval = -1; /* return failure */
24833 + goto out;
24834 + }
24835
24836 - return retval;
24837 + pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply;
24838 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24839 + "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
24840 + "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
24841 + "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
24842 + pScsiTmReply->TargetID, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
24843 + le16_to_cpu(pScsiTmReply->IOCStatus),
24844 + le32_to_cpu(pScsiTmReply->IOCLogInfo),
24845 + pScsiTmReply->ResponseCode,
24846 + le32_to_cpu(pScsiTmReply->TerminationCount)));
24847
24848 - fail_out:
24849 + iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
24850
24851 - /*
24852 - * Free task management mf, and corresponding tm flags
24853 - */
24854 - mpt_free_msg_frame(ioc, mf);
24855 - hd->tmPending = 0;
24856 - hd->tmState = TM_STATE_NONE;
24857 - return FAILED;
24858 + if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
24859 + iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED ||
24860 + iocstatus == MPI_IOCSTATUS_SUCCESS)
24861 + retval = 0;
24862 + else {
24863 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24864 + "TaskMgmt failed\n", ioc->name));
24865 + retval = -1; /* return failure */
24866 + }
24867 +
24868 + out:
24869 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
24870 + CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
24871 + return retval;
24872 }
24873
24874 -static int
24875 -mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
24876 +int
24877 +mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
24878 {
24879 - switch (ioc->bus_type) {
24880 - case FC:
24881 - return 40;
24882 - case SAS:
24883 - return 10;
24884 + MPT_SCSI_HOST *hd;
24885 +
24886 + if ((ioc->sh == NULL) || (ioc->sh->hostdata == NULL))
24887 + return 0;
24888 +
24889 + switch (reset_phase) {
24890 + case MPT_IOC_SETUP_RESET:
24891 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24892 + "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __FUNCTION__));
24893 + break;
24894 + case MPT_IOC_PRE_RESET:
24895 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24896 + "%s: MPT_IOC_PRE_RESET\n", ioc->name, __FUNCTION__));
24897 + hd = shost_priv(ioc->sh);
24898 + mptscsih_flush_running_cmds(hd);
24899 + break;
24900 + case MPT_IOC_POST_RESET:
24901 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24902 + "%s: MPT_IOC_POST_RESET\n", ioc->name, __FUNCTION__));
24903 + if (ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING) {
24904 + ioc->internal_cmds.status |= MPT_MGMT_STATUS_DID_IOCRESET;
24905 + complete(&ioc->internal_cmds.done);
24906 + }
24907 + break;
24908 + default:
24909 + break;
24910 + }
24911 + return 1; /* currently means nothing really */
24912 +}
24913 +
24914 +void
24915 +mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
24916 +{
24917 + char *desc;
24918 +
24919 + switch (response_code) {
24920 + case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
24921 + desc = "The task completed.";
24922 + break;
24923 + case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
24924 + desc = "The IOC received an invalid frame status.";
24925 + break;
24926 + case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
24927 + desc = "The task type is not supported.";
24928 + break;
24929 + case MPI_SCSITASKMGMT_RSP_TM_FAILED:
24930 + desc = "The requested task failed.";
24931 + break;
24932 + case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
24933 + desc = "The task completed successfully.";
24934 + break;
24935 + case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
24936 + desc = "The LUN request is invalid.";
24937 + break;
24938 + case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
24939 + desc = "The task is in the IOC queue and has not been sent to target.";
24940 + break;
24941 + default:
24942 + desc = "unknown";
24943 + break;
24944 + }
24945 + printk(MYIOC_s_DEBUG_FMT "Response Code(0x%08x): F/W: %s\n",
24946 + ioc->name, response_code, desc);
24947 +}
24948 +
24949 +static int
24950 +mptscsih_taskmgmt_reply(MPT_ADAPTER *ioc, u8 type, SCSITaskMgmtReply_t *pScsiTmReply)
24951 +{
24952 + u16 iocstatus;
24953 + u32 termination_count;
24954 + int retval;
24955 +
24956 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) {
24957 + retval = FAILED;
24958 + goto out;
24959 + }
24960 +
24961 + DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
24962 +
24963 + iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
24964 + termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
24965 +
24966 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
24967 + "TaskMgmt fw_channel = %d, fw_id = %d, task_type = 0x%02X,\n"
24968 + "\tiocstatus = 0x%04X, loginfo = 0x%08X, response_code = 0x%02X,\n"
24969 + "\tterm_cmnds = %d\n", ioc->name, pScsiTmReply->Bus,
24970 + pScsiTmReply->TargetID, type, le16_to_cpu(pScsiTmReply->IOCStatus),
24971 + le32_to_cpu(pScsiTmReply->IOCLogInfo), pScsiTmReply->ResponseCode,
24972 + termination_count));
24973 +
24974 + if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
24975 + pScsiTmReply->ResponseCode)
24976 + mptscsih_taskmgmt_response_code(ioc,
24977 + pScsiTmReply->ResponseCode);
24978 +
24979 + if (iocstatus == MPI_IOCSTATUS_SUCCESS) {
24980 + retval = 0;
24981 + goto out;
24982 + }
24983 +
24984 + retval = FAILED;
24985 + if (type == MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK) {
24986 + if (termination_count == 1)
24987 + retval = 0;
24988 + goto out;
24989 + }
24990 +
24991 + if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_TERMINATED ||
24992 + iocstatus == MPI_IOCSTATUS_SCSI_IOC_TERMINATED)
24993 + retval = 0;
24994 +
24995 + out:
24996 + return retval;
24997 +}
24998 +
24999 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25000 +/**
25001 + * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
25002 + * @ioc: Pointer to MPT_ADAPTER structure
25003 + * @mf: Pointer to SCSI task mgmt request frame
25004 + * @mr: Pointer to SCSI task mgmt reply frame
25005 + *
25006 + * This routine is called from mptbase.c::mpt_interrupt() at the completion
25007 + * of any SCSI task management request.
25008 + * This routine is registered with the MPT (base) driver at driver
25009 + * load/init time via the mpt_register() API call.
25010 + *
25011 + * Returns 1 indicating alloc'd request frame ptr should be freed.
25012 + **/
25013 +int
25014 +mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
25015 +{
25016 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed (mf=%p, mr=%p)\n",
25017 + ioc->name, mf, mr));
25018 +
25019 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
25020 +
25021 + if (!mr)
25022 + goto out;
25023 +
25024 + ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
25025 + memcpy(ioc->taskmgmt_cmds.reply, mr,
25026 + min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength));
25027 + out:
25028 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) {
25029 + mpt_clear_taskmgmt_in_progress_flag(ioc);
25030 + ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
25031 + complete(&ioc->taskmgmt_cmds.done);
25032 + return 1;
25033 + }
25034 + return 0;
25035 +}
25036 +
25037 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25038 +/**
25039 + * mptscsih_IssueTaskMgmt - Generic send Task Management function.
25040 + * @hd: Pointer to MPT_SCSI_HOST structure
25041 + * @type: Task Management type
25042 + * @channel: channel number for task management
25043 + * @id: Logical Target ID for reset (if appropriate)
25044 + * @lun: Logical Unit for reset (if appropriate)
25045 + * @ctx2abort: Context for the task to be aborted (if appropriate)
25046 + * @timeout: timeout for task management control
25047 + *
25048 + * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
25049 + * or a non-interrupt thread. In the former, must not call schedule().
25050 + *
25051 + * Not all fields are meaningfull for all task types.
25052 + *
25053 + * Returns 0 for SUCCESS, or FAILED.
25054 + *
25055 + **/
25056 +int
25057 +mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout)
25058 +{
25059 + MPT_FRAME_HDR *mf = NULL;
25060 + SCSITaskMgmt_t *pScsiTm;
25061 + int ii;
25062 + int retval;
25063 + MPT_ADAPTER *ioc = hd->ioc;
25064 + unsigned long timeleft;
25065 + u8 issue_hard_reset;
25066 + u32 ioc_raw_state;
25067 + unsigned long time_count;
25068 +
25069 + issue_hard_reset = 0;
25070 + ioc_raw_state = mpt_GetIocState(ioc, 0);
25071 +
25072 + if ((ioc_raw_state & MPI_IOC_STATE_MASK) != MPI_IOC_STATE_OPERATIONAL) {
25073 + printk(MYIOC_s_WARN_FMT
25074 + "TaskMgmt type=%x: IOC Not operational (0x%x)!\n",
25075 + ioc->name, type, ioc_raw_state);
25076 + printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
25077 + ioc->name, __FUNCTION__);
25078 + if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0)
25079 + printk(MYIOC_s_WARN_FMT "TaskMgmt HardReset "
25080 + "FAILED!!\n", ioc->name);
25081 + return 0;
25082 + }
25083 +
25084 + if (ioc_raw_state & MPI_DOORBELL_ACTIVE) {
25085 + printk(MYIOC_s_WARN_FMT
25086 + "TaskMgmt type=%x: ioc_state: "
25087 + "DOORBELL_ACTIVE (0x%x)!\n",
25088 + ioc->name, type, ioc_raw_state);
25089 + return FAILED;
25090 + }
25091 +
25092 + mutex_lock(&ioc->taskmgmt_cmds.mutex);
25093 + if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) {
25094 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
25095 + retval = FAILED;
25096 + goto out;
25097 + }
25098 +
25099 + /* Return Fail to calling function if no message frames available.
25100 + */
25101 + if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) {
25102 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt no msg frames!!\n",
25103 + ioc->name));
25104 + retval = FAILED;
25105 + mpt_clear_taskmgmt_in_progress_flag(ioc);
25106 + goto out;
25107 + }
25108 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n",
25109 + ioc->name, mf));
25110 +
25111 + /* Format the Request
25112 + */
25113 + pScsiTm = (SCSITaskMgmt_t *) mf;
25114 + pScsiTm->TargetID = id;
25115 + pScsiTm->Bus = channel;
25116 + pScsiTm->ChainOffset = 0;
25117 + pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT;
25118 +
25119 + pScsiTm->Reserved = 0;
25120 + pScsiTm->TaskType = type;
25121 + pScsiTm->Reserved1 = 0;
25122 + pScsiTm->MsgFlags = (type == MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS)
25123 + ? MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION : 0;
25124 +
25125 + int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN);
25126 +
25127 + for (ii=0; ii < 7; ii++)
25128 + pScsiTm->Reserved2[ii] = 0;
25129 +
25130 + pScsiTm->TaskMsgContext = ctx2abort;
25131 +
25132 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt: ctx2abort (0x%08x) "
25133 + "task_type = 0x%02X, timeout = %ld\n", ioc->name, ctx2abort,
25134 + type, timeout));
25135 +
25136 + DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)pScsiTm);
25137 +
25138 + INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status)
25139 + time_count = jiffies;
25140 + if ((ioc->facts.IOCCapabilities & MPI_IOCFACTS_CAPABILITY_HIGH_PRI_Q) &&
25141 + (ioc->facts.MsgVersion >= MPI_VERSION_01_05))
25142 + mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf);
25143 + else {
25144 + retval = mpt_send_handshake_request(ioc->TaskCtx, ioc,
25145 + sizeof(SCSITaskMgmt_t), (u32*)pScsiTm, CAN_SLEEP);
25146 + if (retval) {
25147 + dfailprintk(ioc, printk(MYIOC_s_ERR_FMT "TaskMgmt handshake FAILED!"
25148 + " (mf=%p, rc=%d) \n", ioc->name, mf, retval));
25149 + mpt_free_msg_frame(ioc, mf);
25150 + mpt_clear_taskmgmt_in_progress_flag(ioc);
25151 + goto out;
25152 + }
25153 + }
25154 +
25155 + timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, timeout*HZ);
25156 + if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
25157 + retval = FAILED;
25158 + dtmprintk(ioc, printk(MYIOC_s_ERR_FMT
25159 + "TaskMgmt TIMED OUT!(mf=%p)\n", ioc->name, mf));
25160 + mpt_clear_taskmgmt_in_progress_flag(ioc);
25161 + if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
25162 + goto out;
25163 + issue_hard_reset = 1;
25164 + goto out;
25165 + }
25166 +
25167 + retval = mptscsih_taskmgmt_reply(ioc, type,
25168 + (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply);
25169 +
25170 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25171 + "TaskMgmt completed (%d seconds)\n",
25172 + ioc->name, jiffies_to_msecs(jiffies - time_count)/1000));
25173 +
25174 + out:
25175 +
25176 + CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status)
25177 + if(issue_hard_reset) {
25178 + printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
25179 + ioc->name, __FUNCTION__);
25180 + if ((retval = mpt_SoftResetHandler(ioc, CAN_SLEEP)) != 0)
25181 + retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
25182 + mpt_free_msg_frame(ioc, mf);
25183 + }
25184 +
25185 + retval = (retval == 0) ? 0 : FAILED;
25186 + mutex_unlock(&ioc->taskmgmt_cmds.mutex);
25187 + return retval;
25188 +}
25189 +
25190 +static int
25191 +mptscsih_get_tm_timeout(MPT_ADAPTER *ioc)
25192 +{
25193 + switch (ioc->bus_type) {
25194 + case FC:
25195 + return 40;
25196 + case SAS:
25197 + return 30;
25198 case SPI:
25199 default:
25200 - return 2;
25201 + return 10;
25202 }
25203 }
25204
25205 @@ -1786,7 +1973,7 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
25206 int retval;
25207 VirtDevice *vdevice;
25208 ulong sn = SCpnt->serial_number;
25209 - MPT_ADAPTER *ioc;
25210 + MPT_ADAPTER *ioc;
25211
25212 /* If we can't locate our host adapter structure, return FAILED status.
25213 */
25214 @@ -1810,7 +1997,21 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
25215 ioc->name, SCpnt));
25216 SCpnt->result = DID_NO_CONNECT << 16;
25217 SCpnt->scsi_done(SCpnt);
25218 - retval = 0;
25219 + retval = SUCCESS;
25220 + goto out;
25221 + }
25222 +
25223 + /* Find this command
25224 + */
25225 + if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
25226 + /* Cmd not found in ScsiLookup.
25227 + * Do OS callback.
25228 + */
25229 + SCpnt->result = DID_RESET << 16;
25230 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25231 + "task abort: command not in the active list! (sc=%p)\n",
25232 + ioc->name, SCpnt));
25233 + retval = SUCCESS;
25234 goto out;
25235 }
25236
25237 @@ -1825,27 +2026,23 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
25238 goto out;
25239 }
25240
25241 - /* Find this command
25242 + /* Task aborts are not supported for volumes.
25243 */
25244 - if ((scpnt_idx = SCPNT_TO_LOOKUP_IDX(ioc, SCpnt)) < 0) {
25245 - /* Cmd not found in ScsiLookup.
25246 - * Do OS callback.
25247 - */
25248 + if (vdevice->vtarget->raidVolume) {
25249 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25250 + "task abort: raid volume (sc=%p)\n",
25251 + ioc->name, SCpnt));
25252 SCpnt->result = DID_RESET << 16;
25253 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
25254 - "Command not in the active list! (sc=%p)\n", ioc->name,
25255 - SCpnt));
25256 - retval = 0;
25257 - goto out;
25258 - }
25259 -
25260 - if (hd->resetPending) {
25261 retval = FAILED;
25262 goto out;
25263 }
25264
25265 - if (hd->timeouts < -1)
25266 - hd->timeouts++;
25267 + if(mpt_fwfault_debug)
25268 + mpt_halt_firmware(ioc);
25269 +
25270 + if (ioc->timeouts < -1)
25271 + ioc->timeouts++;
25272 +
25273
25274 /* Most important! Set TaskMsgContext to SCpnt's MsgContext!
25275 * (the IO to be ABORT'd)
25276 @@ -1856,25 +2053,31 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
25277 */
25278 mf = MPT_INDEX_2_MFPTR(ioc, scpnt_idx);
25279 ctx2abort = mf->u.frame.hwhdr.msgctxu.MsgContext;
25280 -
25281 - hd->abortSCpnt = SCpnt;
25282 -
25283 - retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
25284 + mptscsih_IssueTaskMgmt(hd, MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
25285 vdevice->vtarget->channel, vdevice->vtarget->id, vdevice->lun,
25286 ctx2abort, mptscsih_get_tm_timeout(ioc));
25287
25288 + /* check to see whether command actually completed and/or
25289 + * terminated
25290 + */
25291 if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx &&
25292 - SCpnt->serial_number == sn)
25293 + SCpnt->serial_number == sn) {
25294 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25295 + "task abort: command still in active list! (sc=%p)\n",
25296 + ioc->name, SCpnt));
25297 retval = FAILED;
25298 + } else {
25299 + dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25300 + "task abort: command cleared from active list! (sc=%p)\n",
25301 + ioc->name, SCpnt));
25302 + retval = SUCCESS;
25303 + }
25304
25305 out:
25306 printk(MYIOC_s_INFO_FMT "task abort: %s (sc=%p)\n",
25307 - ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
25308 + ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED" ), SCpnt);
25309
25310 - if (retval == 0)
25311 - return SUCCESS;
25312 - else
25313 - return FAILED;
25314 + return retval;
25315 }
25316
25317 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25318 @@ -1907,14 +2110,9 @@ mptscsih_dev_reset(struct scsi_cmnd * SC
25319 ioc->name, SCpnt);
25320 scsi_print_command(SCpnt);
25321
25322 - if (hd->resetPending) {
25323 - retval = FAILED;
25324 - goto out;
25325 - }
25326 -
25327 vdevice = SCpnt->device->hostdata;
25328 if (!vdevice || !vdevice->vtarget) {
25329 - retval = 0;
25330 + retval = SUCCESS;
25331 goto out;
25332 }
25333
25334 @@ -1925,12 +2123,12 @@ mptscsih_dev_reset(struct scsi_cmnd * SC
25335 goto out;
25336 }
25337
25338 - retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
25339 - vdevice->vtarget->channel, vdevice->vtarget->id, 0, 0,
25340 - mptscsih_get_tm_timeout(ioc));
25341 + retval = mptscsih_IssueTaskMgmt(hd,
25342 + MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, vdevice->vtarget->channel,
25343 + vdevice->vtarget->id, 0, 0, mptscsih_get_tm_timeout(ioc));
25344
25345 out:
25346 - printk (MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
25347 + printk(MYIOC_s_INFO_FMT "target reset: %s (sc=%p)\n",
25348 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
25349
25350 if (retval == 0)
25351 @@ -1955,12 +2153,12 @@ mptscsih_bus_reset(struct scsi_cmnd * SC
25352 MPT_SCSI_HOST *hd;
25353 int retval;
25354 VirtDevice *vdevice;
25355 - MPT_ADAPTER *ioc;
25356 + MPT_ADAPTER *ioc;
25357
25358 /* If we can't locate our host adapter structure, return FAILED status.
25359 */
25360 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
25361 - printk(KERN_ERR MYNAM ": bus reset: "
25362 + printk(KERN_ERR MYNAM ": bus_reset: "
25363 "Can't locate host! (sc=%p)\n", SCpnt);
25364 return FAILED;
25365 }
25366 @@ -1970,11 +2168,13 @@ mptscsih_bus_reset(struct scsi_cmnd * SC
25367 ioc->name, SCpnt);
25368 scsi_print_command(SCpnt);
25369
25370 - if (hd->timeouts < -1)
25371 - hd->timeouts++;
25372 + if (ioc->timeouts < -1)
25373 + ioc->timeouts++;
25374
25375 vdevice = SCpnt->device->hostdata;
25376 - retval = mptscsih_TMHandler(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
25377 + if (!vdevice || !vdevice->vtarget)
25378 + return SUCCESS;
25379 + retval = mptscsih_IssueTaskMgmt(hd, MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
25380 vdevice->vtarget->channel, 0, 0, 0, mptscsih_get_tm_timeout(ioc));
25381
25382 printk(MYIOC_s_INFO_FMT "bus reset: %s (sc=%p)\n",
25383 @@ -1999,8 +2199,9 @@ int
25384 mptscsih_host_reset(struct scsi_cmnd *SCpnt)
25385 {
25386 MPT_SCSI_HOST * hd;
25387 - int retval;
25388 - MPT_ADAPTER *ioc;
25389 + int status = SUCCESS;
25390 + MPT_ADAPTER *ioc;
25391 + int retval;
25392
25393 /* If we can't locate the host to reset, then we failed. */
25394 if ((hd = shost_priv(SCpnt->device->host)) == NULL){
25395 @@ -2011,237 +2212,29 @@ mptscsih_host_reset(struct scsi_cmnd *SC
25396
25397 ioc = hd->ioc;
25398 printk(MYIOC_s_INFO_FMT "attempting host reset! (sc=%p)\n",
25399 - ioc->name, SCpnt);
25400 + ioc->name, SCpnt);
25401
25402 /* If our attempts to reset the host failed, then return a failed
25403 * status. The host will be taken off line by the SCSI mid-layer.
25404 */
25405 - if (mpt_HardResetHandler(ioc, CAN_SLEEP) < 0) {
25406 - retval = FAILED;
25407 - } else {
25408 - /* Make sure TM pending is cleared and TM state is set to
25409 - * NONE.
25410 - */
25411 - retval = 0;
25412 - hd->tmPending = 0;
25413 - hd->tmState = TM_STATE_NONE;
25414 - }
25415 + if ((retval = mpt_SoftResetHandler(ioc, CAN_SLEEP)) != 0)
25416 + retval = mpt_HardResetHandler(ioc, CAN_SLEEP);
25417 +
25418 + if (retval < 0)
25419 + status = FAILED;
25420 + else
25421 + status = SUCCESS;
25422
25423 printk(MYIOC_s_INFO_FMT "host reset: %s (sc=%p)\n",
25424 ioc->name, ((retval == 0) ? "SUCCESS" : "FAILED" ), SCpnt);
25425
25426 - return retval;
25427 -}
25428 -
25429 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25430 -/**
25431 - * mptscsih_tm_pending_wait - wait for pending task management request to complete
25432 - * @hd: Pointer to MPT host structure.
25433 - *
25434 - * Returns {SUCCESS,FAILED}.
25435 - */
25436 -static int
25437 -mptscsih_tm_pending_wait(MPT_SCSI_HOST * hd)
25438 -{
25439 - unsigned long flags;
25440 - int loop_count = 4 * 10; /* Wait 10 seconds */
25441 - int status = FAILED;
25442 - MPT_ADAPTER *ioc = hd->ioc;
25443 -
25444 - do {
25445 - spin_lock_irqsave(&ioc->FreeQlock, flags);
25446 - if (hd->tmState == TM_STATE_NONE) {
25447 - hd->tmState = TM_STATE_IN_PROGRESS;
25448 - hd->tmPending = 1;
25449 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
25450 - status = SUCCESS;
25451 - break;
25452 - }
25453 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
25454 - msleep(250);
25455 - } while (--loop_count);
25456 -
25457 return status;
25458 }
25459
25460 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25461 /**
25462 - * mptscsih_tm_wait_for_completion - wait for completion of TM task
25463 - * @hd: Pointer to MPT host structure.
25464 - * @timeout: timeout value
25465 - *
25466 - * Returns {SUCCESS,FAILED}.
25467 - */
25468 -static int
25469 -mptscsih_tm_wait_for_completion(MPT_SCSI_HOST * hd, ulong timeout )
25470 -{
25471 - unsigned long flags;
25472 - int loop_count = 4 * timeout;
25473 - int status = FAILED;
25474 - MPT_ADAPTER *ioc = hd->ioc;
25475 -
25476 - do {
25477 - spin_lock_irqsave(&ioc->FreeQlock, flags);
25478 - if(hd->tmPending == 0) {
25479 - status = SUCCESS;
25480 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
25481 - break;
25482 - }
25483 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
25484 - msleep(250);
25485 - } while (--loop_count);
25486 -
25487 - return status;
25488 -}
25489 -
25490 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25491 -static void
25492 -mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code)
25493 -{
25494 - char *desc;
25495 -
25496 - switch (response_code) {
25497 - case MPI_SCSITASKMGMT_RSP_TM_COMPLETE:
25498 - desc = "The task completed.";
25499 - break;
25500 - case MPI_SCSITASKMGMT_RSP_INVALID_FRAME:
25501 - desc = "The IOC received an invalid frame status.";
25502 - break;
25503 - case MPI_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
25504 - desc = "The task type is not supported.";
25505 - break;
25506 - case MPI_SCSITASKMGMT_RSP_TM_FAILED:
25507 - desc = "The requested task failed.";
25508 - break;
25509 - case MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED:
25510 - desc = "The task completed successfully.";
25511 - break;
25512 - case MPI_SCSITASKMGMT_RSP_TM_INVALID_LUN:
25513 - desc = "The LUN request is invalid.";
25514 - break;
25515 - case MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
25516 - desc = "The task is in the IOC queue and has not been sent to target.";
25517 - break;
25518 - default:
25519 - desc = "unknown";
25520 - break;
25521 - }
25522 - printk(MYIOC_s_INFO_FMT "Response Code(0x%08x): F/W: %s\n",
25523 - ioc->name, response_code, desc);
25524 -}
25525 -
25526 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25527 -/**
25528 - * mptscsih_taskmgmt_complete - Registered with Fusion MPT base driver
25529 - * @ioc: Pointer to MPT_ADAPTER structure
25530 - * @mf: Pointer to SCSI task mgmt request frame
25531 - * @mr: Pointer to SCSI task mgmt reply frame
25532 - *
25533 - * This routine is called from mptbase.c::mpt_interrupt() at the completion
25534 - * of any SCSI task management request.
25535 - * This routine is registered with the MPT (base) driver at driver
25536 - * load/init time via the mpt_register() API call.
25537 - *
25538 - * Returns 1 indicating alloc'd request frame ptr should be freed.
25539 - **/
25540 -int
25541 -mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
25542 -{
25543 - SCSITaskMgmtReply_t *pScsiTmReply;
25544 - SCSITaskMgmt_t *pScsiTmReq;
25545 - MPT_SCSI_HOST *hd;
25546 - unsigned long flags;
25547 - u16 iocstatus;
25548 - u8 tmType;
25549 - u32 termination_count;
25550 -
25551 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed (mf=%p,mr=%p)\n",
25552 - ioc->name, mf, mr));
25553 - if (!ioc->sh) {
25554 - dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
25555 - "TaskMgmt Complete: NULL Scsi Host Ptr\n", ioc->name));
25556 - return 1;
25557 - }
25558 -
25559 - if (mr == NULL) {
25560 - dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
25561 - "ERROR! TaskMgmt Reply: NULL Request %p\n", ioc->name, mf));
25562 - return 1;
25563 - }
25564 -
25565 - hd = shost_priv(ioc->sh);
25566 - pScsiTmReply = (SCSITaskMgmtReply_t*)mr;
25567 - pScsiTmReq = (SCSITaskMgmt_t*)mf;
25568 - tmType = pScsiTmReq->TaskType;
25569 - iocstatus = le16_to_cpu(pScsiTmReply->IOCStatus) & MPI_IOCSTATUS_MASK;
25570 - termination_count = le32_to_cpu(pScsiTmReply->TerminationCount);
25571 -
25572 - if (ioc->facts.MsgVersion >= MPI_VERSION_01_05 &&
25573 - pScsiTmReply->ResponseCode)
25574 - mptscsih_taskmgmt_response_code(ioc,
25575 - pScsiTmReply->ResponseCode);
25576 - DBG_DUMP_TM_REPLY_FRAME(ioc, (u32 *)pScsiTmReply);
25577 -
25578 -#ifdef CONFIG_FUSION_LOGGING
25579 - if ((ioc->debug_level & MPT_DEBUG_REPLY) ||
25580 - (ioc->debug_level & MPT_DEBUG_TM ))
25581 - printk("%s: ha=%d [%d:%d:0] task_type=0x%02X "
25582 - "iocstatus=0x%04X\n\tloginfo=0x%08X response_code=0x%02X "
25583 - "term_cmnds=%d\n", __func__, ioc->id, pScsiTmReply->Bus,
25584 - pScsiTmReply->TargetID, pScsiTmReq->TaskType,
25585 - le16_to_cpu(pScsiTmReply->IOCStatus),
25586 - le32_to_cpu(pScsiTmReply->IOCLogInfo),pScsiTmReply->ResponseCode,
25587 - le32_to_cpu(pScsiTmReply->TerminationCount));
25588 -#endif
25589 - if (!iocstatus) {
25590 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT " TaskMgmt SUCCESS\n", ioc->name));
25591 - hd->abortSCpnt = NULL;
25592 - goto out;
25593 - }
25594 -
25595 - /* Error? (anything non-zero?) */
25596 -
25597 - /* clear flags and continue.
25598 - */
25599 - switch (tmType) {
25600 -
25601 - case MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
25602 - if (termination_count == 1)
25603 - iocstatus = MPI_IOCSTATUS_SCSI_TASK_TERMINATED;
25604 - hd->abortSCpnt = NULL;
25605 - break;
25606 -
25607 - case MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS:
25608 -
25609 - /* If an internal command is present
25610 - * or the TM failed - reload the FW.
25611 - * FC FW may respond FAILED to an ABORT
25612 - */
25613 - if (iocstatus == MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED ||
25614 - hd->cmdPtr)
25615 - if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
25616 - printk(MYIOC_s_WARN_FMT " Firmware Reload FAILED!!\n", ioc->name);
25617 - break;
25618 -
25619 - case MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
25620 - default:
25621 - break;
25622 - }
25623 -
25624 - out:
25625 - spin_lock_irqsave(&ioc->FreeQlock, flags);
25626 - hd->tmPending = 0;
25627 - hd->tmState = TM_STATE_NONE;
25628 - hd->tm_iocstatus = iocstatus;
25629 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
25630 -
25631 - return 1;
25632 -}
25633 -
25634 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25635 -/*
25636 * This is anyones guess quite frankly.
25637 - */
25638 + **/
25639 int
25640 mptscsih_bios_param(struct scsi_device * sdev, struct block_device *bdev,
25641 sector_t capacity, int geom[])
25642 @@ -2278,40 +2271,82 @@ mptscsih_bios_param(struct scsi_device *
25643 return 0;
25644 }
25645
25646 -/* Search IOC page 3 to determine if this is hidden physical disk
25647 +/**
25648 + * Search IOC page 3 to determine if this is hidden physical disk
25649 *
25650 - */
25651 + **/
25652 int
25653 mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id)
25654 {
25655 struct inactive_raid_component_info *component_info;
25656 - int i;
25657 + u8 i, j;
25658 + RaidPhysDiskPage1_t *phys_disk;
25659 int rc = 0;
25660 + int num_paths;
25661
25662 if (!ioc->raid_data.pIocPg3)
25663 goto out;
25664 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
25665 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
25666 - (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
25667 + (channel ==
25668 + ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
25669 rc = 1;
25670 goto out;
25671 }
25672 }
25673
25674 + if (ioc->bus_type != SAS)
25675 + goto out;
25676 +
25677 + /*
25678 + * Check if dual path
25679 + */
25680 + for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
25681 + num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
25682 + ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
25683 + if (num_paths < 2)
25684 + continue;
25685 + phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
25686 + (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
25687 + if (!phys_disk)
25688 + continue;
25689 + if ((mpt_raid_phys_disk_pg1(ioc,
25690 + ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
25691 + phys_disk))) {
25692 + kfree(phys_disk);
25693 + continue;
25694 + }
25695 + for (j = 0; j < num_paths; j++) {
25696 + if ((phys_disk->Path[j].Flags &
25697 + MPI_RAID_PHYSDISK1_FLAG_INVALID))
25698 + continue;
25699 + if ((phys_disk->Path[j].Flags &
25700 + MPI_RAID_PHYSDISK1_FLAG_BROKEN))
25701 + continue;
25702 + if ((id == phys_disk->Path[j].PhysDiskID) &&
25703 + (channel == phys_disk->Path[j].PhysDiskBus)) {
25704 + rc = 1;
25705 + kfree(phys_disk);
25706 + goto out;
25707 + }
25708 + }
25709 + kfree(phys_disk);
25710 + }
25711 +
25712 /*
25713 * Check inactive list for matching phys disks
25714 */
25715 if (list_empty(&ioc->raid_data.inactive_list))
25716 goto out;
25717
25718 - mutex_lock(&ioc->raid_data.inactive_list_mutex);
25719 + down(&ioc->raid_data.inactive_list_mutex);
25720 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
25721 list) {
25722 if ((component_info->d.PhysDiskID == id) &&
25723 (component_info->d.PhysDiskBus == channel))
25724 rc = 1;
25725 }
25726 - mutex_unlock(&ioc->raid_data.inactive_list_mutex);
25727 + up(&ioc->raid_data.inactive_list_mutex);
25728
25729 out:
25730 return rc;
25731 @@ -2322,43 +2357,84 @@ u8
25732 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id)
25733 {
25734 struct inactive_raid_component_info *component_info;
25735 - int i;
25736 + int i,j;
25737 + RaidPhysDiskPage1_t *phys_disk;
25738 int rc = -ENXIO;
25739 + u8 num_paths;
25740
25741 if (!ioc->raid_data.pIocPg3)
25742 goto out;
25743 for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
25744 if ((id == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskID) &&
25745 - (channel == ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
25746 + (channel ==
25747 + ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskBus)) {
25748 rc = ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum;
25749 goto out;
25750 }
25751 }
25752
25753 + if (ioc->bus_type != SAS)
25754 + goto out;
25755 +
25756 + /*
25757 + * Check if dual path
25758 + */
25759 + for (i = 0; i < ioc->raid_data.pIocPg3->NumPhysDisks; i++) {
25760 + num_paths = mpt_raid_phys_disk_get_num_paths(ioc,
25761 + ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum);
25762 + if (num_paths < 2)
25763 + continue;
25764 + phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t,Path) +
25765 + (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL);
25766 + if (!phys_disk)
25767 + continue;
25768 + if ((mpt_raid_phys_disk_pg1(ioc,
25769 + ioc->raid_data.pIocPg3->PhysDisk[i].PhysDiskNum,
25770 + phys_disk))) {
25771 + kfree(phys_disk);
25772 + continue;
25773 + }
25774 + for (j = 0; j < num_paths; j++) {
25775 + if ((phys_disk->Path[j].Flags &
25776 + MPI_RAID_PHYSDISK1_FLAG_INVALID))
25777 + continue;
25778 + if ((phys_disk->Path[j].Flags &
25779 + MPI_RAID_PHYSDISK1_FLAG_BROKEN))
25780 + continue;
25781 + if ((id == phys_disk->Path[j].PhysDiskID) &&
25782 + (channel == phys_disk->Path[j].PhysDiskBus)) {
25783 + rc = phys_disk->PhysDiskNum;
25784 + kfree(phys_disk);
25785 + goto out;
25786 + }
25787 + }
25788 + kfree(phys_disk);
25789 + }
25790 +
25791 /*
25792 * Check inactive list for matching phys disks
25793 */
25794 if (list_empty(&ioc->raid_data.inactive_list))
25795 goto out;
25796
25797 - mutex_lock(&ioc->raid_data.inactive_list_mutex);
25798 + down(&ioc->raid_data.inactive_list_mutex);
25799 list_for_each_entry(component_info, &ioc->raid_data.inactive_list,
25800 list) {
25801 if ((component_info->d.PhysDiskID == id) &&
25802 (component_info->d.PhysDiskBus == channel))
25803 rc = component_info->d.PhysDiskNum;
25804 }
25805 - mutex_unlock(&ioc->raid_data.inactive_list_mutex);
25806 + up(&ioc->raid_data.inactive_list_mutex);
25807
25808 out:
25809 return rc;
25810 }
25811 EXPORT_SYMBOL(mptscsih_raid_id_to_num);
25812
25813 -/*
25814 +/**
25815 * OS entry point to allow for host driver to free allocated memory
25816 * Called if no device present or device being unloaded
25817 - */
25818 + **/
25819 void
25820 mptscsih_slave_destroy(struct scsi_device *sdev)
25821 {
25822 @@ -2370,23 +2446,25 @@ mptscsih_slave_destroy(struct scsi_devic
25823
25824 starget = scsi_target(sdev);
25825 vtarget = starget->hostdata;
25826 + vtarget->num_luns--;
25827 vdevice = sdev->hostdata;
25828 + if (!vdevice)
25829 + return;
25830
25831 mptscsih_search_running_cmds(hd, vdevice);
25832 - vtarget->num_luns--;
25833 - mptscsih_synchronize_cache(hd, vdevice);
25834 + mptscsih_synchronize_cache(sdev, hd, vdevice);
25835 kfree(vdevice);
25836 sdev->hostdata = NULL;
25837 }
25838
25839 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25840 -/*
25841 +/**
25842 * mptscsih_change_queue_depth - This function will set a devices queue depth
25843 * @sdev: per scsi_device pointer
25844 * @qdepth: requested queue depth
25845 *
25846 * Adding support for new 'change_queue_depth' api.
25847 -*/
25848 + **/
25849 int
25850 mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
25851 {
25852 @@ -2401,15 +2479,16 @@ mptscsih_change_queue_depth(struct scsi_
25853 vtarget = starget->hostdata;
25854
25855 if (ioc->bus_type == SPI) {
25856 - if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
25857 - max_depth = 1;
25858 - else if (sdev->type == TYPE_DISK &&
25859 - vtarget->minSyncFactor <= MPT_ULTRA160)
25860 + if (sdev->type == TYPE_DISK &&
25861 + vtarget->minSyncFactor <= MPT_ULTRA160)
25862 max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
25863 else
25864 max_depth = MPT_SCSI_CMD_PER_DEV_LOW;
25865 } else
25866 - max_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
25867 + max_depth = ioc->sh->can_queue;
25868 +
25869 + if (!sdev->tagged_supported)
25870 + max_depth = 1;
25871
25872 if (qdepth > max_depth)
25873 qdepth = max_depth;
25874 @@ -2419,15 +2498,24 @@ mptscsih_change_queue_depth(struct scsi_
25875 tagged = MSG_SIMPLE_TAG;
25876
25877 scsi_adjust_queue_depth(sdev, tagged, qdepth);
25878 +
25879 + if (sdev->inquiry_len > 7)
25880 + sdev_printk(KERN_INFO, sdev, MYIOC_s_FMT "qdepth=%d, "
25881 + "tagged=%d, simple=%d, ordered=%d, scsi_level=%d, "
25882 + "cmd_que=%d\n", ioc->name, sdev->queue_depth,
25883 + sdev->tagged_supported, sdev->simple_tags,
25884 + sdev->ordered_tags, sdev->scsi_level,
25885 + (sdev->inquiry[7] & 2) >> 1);
25886 +
25887 return sdev->queue_depth;
25888 }
25889
25890 -/*
25891 +/**
25892 * OS entry point to adjust the queue_depths on a per-device basis.
25893 * Called once per device the bus scan. Use it to force the queue_depth
25894 * member to 1 if a device does not support Q tags.
25895 * Return non-zero if fails.
25896 - */
25897 + **/
25898 int
25899 mptscsih_slave_configure(struct scsi_device *sdev)
25900 {
25901 @@ -2436,52 +2524,37 @@ mptscsih_slave_configure(struct scsi_dev
25902 VirtDevice *vdevice;
25903 struct scsi_target *starget;
25904 MPT_SCSI_HOST *hd = shost_priv(sh);
25905 - MPT_ADAPTER *ioc = hd->ioc;
25906 + MPT_ADAPTER *ioc = hd->ioc;
25907
25908 starget = scsi_target(sdev);
25909 vtarget = starget->hostdata;
25910 vdevice = sdev->hostdata;
25911 + vdevice->configured_lun = 1;
25912
25913 - dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25914 - "device @ %p, channel=%d, id=%d, lun=%d\n",
25915 - ioc->name, sdev, sdev->channel, sdev->id, sdev->lun));
25916 - if (ioc->bus_type == SPI)
25917 - dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25918 - "sdtr %d wdtr %d ppr %d inq length=%d\n",
25919 - ioc->name, sdev->sdtr, sdev->wdtr,
25920 - sdev->ppr, sdev->inquiry_len));
25921 + if ((ioc->bus_type != SAS) && (sdev->id > sh->max_id)) {
25922 + /* error case, should never happen */
25923 + scsi_adjust_queue_depth(sdev, 0, 1);
25924 + goto slave_configure_exit;
25925 + }
25926
25927 - vdevice->configured_lun = 1;
25928 - mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
25929 + mptscsih_change_queue_depth(sdev, ioc->sdev_queue_depth);
25930
25931 - dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25932 - "Queue depth=%d, tflags=%x\n",
25933 - ioc->name, sdev->queue_depth, vtarget->tflags));
25934 -
25935 - if (ioc->bus_type == SPI)
25936 - dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25937 - "negoFlags=%x, maxOffset=%x, SyncFactor=%x\n",
25938 - ioc->name, vtarget->negoFlags, vtarget->maxOffset,
25939 - vtarget->minSyncFactor));
25940 -
25941 - dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
25942 - "tagged %d, simple %d, ordered %d\n",
25943 - ioc->name,sdev->tagged_supported, sdev->simple_tags,
25944 - sdev->ordered_tags));
25945 +slave_configure_exit:
25946
25947 return 0;
25948 }
25949
25950 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25951 -/*
25952 +/**
25953 * Private routines...
25954 */
25955
25956 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
25957 -/* Utility function to copy sense data from the scsi_cmnd buffer
25958 +/**
25959 + * Utility function to copy sense data from the scsi_cmnd buffer
25960 * to the FC and SCSI target structures.
25961 *
25962 - */
25963 + **/
25964 static void
25965 mptscsih_copy_sense_data(struct scsi_cmnd *sc, MPT_SCSI_HOST *hd, MPT_FRAME_HDR *mf, SCSIIOReply_t *pScsiReply)
25966 {
25967 @@ -2521,31 +2594,31 @@ mptscsih_copy_sense_data(struct scsi_cmn
25968 ioc->events[idx].data[1] = (sense_data[13] << 8) | sense_data[12];
25969
25970 ioc->eventContext++;
25971 - if (ioc->pcidev->vendor ==
25972 - PCI_VENDOR_ID_IBM) {
25973 - mptscsih_issue_sep_command(ioc,
25974 - vdevice->vtarget, MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
25975 - vdevice->vtarget->tflags |=
25976 - MPT_TARGET_FLAGS_LED_ON;
25977 + if (ioc->pcidev->vendor == PCI_VENDOR_ID_IBM) {
25978 + mptscsih_issue_sep_command(ioc, vdevice->vtarget,
25979 + MPI_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
25980 + vdevice->vtarget->tflags |= MPT_TARGET_FLAGS_LED_ON;
25981 }
25982 }
25983 }
25984 } else {
25985 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hmmm... SenseData len=0! (?)\n",
25986 - ioc->name));
25987 + ioc->name));
25988 }
25989 }
25990
25991 /**
25992 * mptscsih_get_scsi_lookup
25993 - * @ioc: Pointer to MPT_ADAPTER structure
25994 - * @i: index into the array
25995 *
25996 * retrieves scmd entry from ScsiLookup[] array list
25997 *
25998 + * @ioc: Pointer to MPT_ADAPTER structure
25999 + * @i: index into the array
26000 + *
26001 * Returns the scsi_cmd pointer
26002 + *
26003 **/
26004 -static struct scsi_cmnd *
26005 +struct scsi_cmnd *
26006 mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i)
26007 {
26008 unsigned long flags;
26009 @@ -2560,12 +2633,14 @@ mptscsih_get_scsi_lookup(MPT_ADAPTER *io
26010
26011 /**
26012 * mptscsih_getclear_scsi_lookup
26013 - * @ioc: Pointer to MPT_ADAPTER structure
26014 - * @i: index into the array
26015 *
26016 * retrieves and clears scmd entry from ScsiLookup[] array list
26017 *
26018 + * @ioc: Pointer to MPT_ADAPTER structure
26019 + * @i: index into the array
26020 + *
26021 * Returns the scsi_cmd pointer
26022 + *
26023 **/
26024 static struct scsi_cmnd *
26025 mptscsih_getclear_scsi_lookup(MPT_ADAPTER *ioc, int i)
26026 @@ -2602,10 +2677,14 @@ mptscsih_set_scsi_lookup(MPT_ADAPTER *io
26027 }
26028
26029 /**
26030 - * SCPNT_TO_LOOKUP_IDX - searches for a given scmd in the ScsiLookup[] array list
26031 + * SCPNT_TO_LOOKUP_IDX
26032 + *
26033 + * search's for a given scmd in the ScsiLookup[] array list
26034 + *
26035 * @ioc: Pointer to MPT_ADAPTER structure
26036 - * @sc: scsi_cmnd pointer
26037 - */
26038 + * @scmd: scsi_cmnd pointer
26039 + *
26040 + **/
26041 static int
26042 SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, struct scsi_cmnd *sc)
26043 {
26044 @@ -2627,380 +2706,226 @@ SCPNT_TO_LOOKUP_IDX(MPT_ADAPTER *ioc, st
26045
26046 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26047 int
26048 -mptscsih_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
26049 +mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
26050 {
26051 - MPT_SCSI_HOST *hd;
26052 - unsigned long flags;
26053 -
26054 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26055 - ": IOC %s_reset routed to SCSI host driver!\n",
26056 - ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
26057 - reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
26058 -
26059 - /* If a FW reload request arrives after base installed but
26060 - * before all scsi hosts have been attached, then an alt_ioc
26061 - * may have a NULL sh pointer.
26062 - */
26063 - if (ioc->sh == NULL || shost_priv(ioc->sh) == NULL)
26064 - return 0;
26065 - else
26066 - hd = shost_priv(ioc->sh);
26067 -
26068 - if (reset_phase == MPT_IOC_SETUP_RESET) {
26069 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Setup-Diag Reset\n", ioc->name));
26070 -
26071 - /* Clean Up:
26072 - * 1. Set Hard Reset Pending Flag
26073 - * All new commands go to doneQ
26074 - */
26075 - hd->resetPending = 1;
26076 -
26077 - } else if (reset_phase == MPT_IOC_PRE_RESET) {
26078 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Pre-Diag Reset\n", ioc->name));
26079 -
26080 - /* 2. Flush running commands
26081 - * Clean ScsiLookup (and associated memory)
26082 - * AND clean mytaskQ
26083 - */
26084 + u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
26085
26086 - /* 2b. Reply to OS all known outstanding I/O commands.
26087 - */
26088 - mptscsih_flush_running_cmds(hd);
26089 + devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26090 + "MPT event (=%02Xh) routed to SCSI host driver!\n",
26091 + ioc->name, event));
26092
26093 - /* 2c. If there was an internal command that
26094 - * has not completed, configuration or io request,
26095 - * free these resources.
26096 - */
26097 - if (hd->cmdPtr) {
26098 - del_timer(&hd->timer);
26099 - mpt_free_msg_frame(ioc, hd->cmdPtr);
26100 - }
26101 + if ((event == MPI_EVENT_IOC_BUS_RESET ||
26102 + event == MPI_EVENT_EXT_BUS_RESET) &&
26103 + (ioc->bus_type == SPI) && (ioc->soft_resets < -1))
26104 + ioc->soft_resets++;
26105
26106 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Pre-Reset complete.\n", ioc->name));
26107 + return 1; /* currently means nothing really */
26108 +}
26109
26110 - } else {
26111 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Post-Diag Reset\n", ioc->name));
26112 +int
26113 +mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
26114 +{
26115 + MPT_ADAPTER *ioc = hd->ioc;
26116 + MpiRaidActionRequest_t *pReq;
26117 + MPT_FRAME_HDR *mf;
26118 + int ret;
26119 + unsigned long timeleft;
26120
26121 - /* Once a FW reload begins, all new OS commands are
26122 - * redirected to the doneQ w/ a reset status.
26123 - * Init all control structures.
26124 - */
26125 + mutex_lock(&ioc->internal_cmds.mutex);
26126
26127 - /* 2. Chain Buffer initialization
26128 - */
26129 + /* Get and Populate a free Frame
26130 + */
26131 + if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
26132 + dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT "%s: no msg frames!\n",
26133 + ioc->name, __FUNCTION__));
26134 + ret = -EAGAIN;
26135 + goto out;
26136 + }
26137 + pReq = (MpiRaidActionRequest_t *)mf;
26138 + if (quiesce)
26139 + pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
26140 + else
26141 + pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
26142 + pReq->Reserved1 = 0;
26143 + pReq->ChainOffset = 0;
26144 + pReq->Function = MPI_FUNCTION_RAID_ACTION;
26145 + pReq->VolumeID = id;
26146 + pReq->VolumeBus = channel;
26147 + pReq->PhysDiskNum = 0;
26148 + pReq->MsgFlags = 0;
26149 + pReq->Reserved2 = 0;
26150 + pReq->ActionDataWord = 0; /* Reserved for this action */
26151
26152 - /* 4. Renegotiate to all devices, if SPI
26153 - */
26154 + ioc->add_sge((char *)&pReq->ActionDataSGE,
26155 + MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
26156
26157 - /* 5. Enable new commands to be posted
26158 - */
26159 - spin_lock_irqsave(&ioc->FreeQlock, flags);
26160 - hd->tmPending = 0;
26161 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
26162 - hd->resetPending = 0;
26163 - hd->tmState = TM_STATE_NONE;
26164 + ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
26165 + ioc->name, pReq->Action, channel, id));
26166
26167 - /* 6. If there was an internal command,
26168 - * wake this process up.
26169 - */
26170 - if (hd->cmdPtr) {
26171 - /*
26172 - * Wake up the original calling thread
26173 - */
26174 - hd->pLocal = &hd->localReply;
26175 - hd->pLocal->completion = MPT_SCANDV_DID_RESET;
26176 - hd->scandv_wait_done = 1;
26177 - wake_up(&hd->scandv_waitq);
26178 - hd->cmdPtr = NULL;
26179 + INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
26180 + mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
26181 + timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
26182 + if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
26183 + ret = -ETIME;
26184 + dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
26185 + ioc->name, __FUNCTION__));
26186 + if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
26187 + goto out;
26188 + if (!timeleft) {
26189 + printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
26190 + ioc->name, __FUNCTION__);
26191 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
26192 + mpt_HardResetHandler(ioc, CAN_SLEEP);
26193 + mpt_free_msg_frame(ioc, mf);
26194 }
26195 -
26196 - dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Post-Reset complete.\n", ioc->name));
26197 -
26198 + goto out;
26199 }
26200
26201 - return 1; /* currently means nothing really */
26202 + ret = ioc->internal_cmds.completion_code;
26203 +
26204 + out:
26205 + CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
26206 + mutex_unlock(&ioc->internal_cmds.mutex);
26207 + return ret;
26208 }
26209
26210 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26211 -int
26212 -mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
26213 +/**
26214 + * mptscsih_get_completion_code -
26215 + * @ioc: Pointer to MPT_ADAPTER structure
26216 + * @reply:
26217 + * @cmd:
26218 + *
26219 + **/
26220 +static int
26221 +mptscsih_get_completion_code(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
26222 {
26223 - MPT_SCSI_HOST *hd;
26224 - u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
26225 + SCSIIOReply_t *pReply;
26226 + MpiRaidActionReply_t *pr;
26227 + u8 scsi_status;
26228 + u16 status;
26229 + int completion_code;
26230
26231 - devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
26232 - ioc->name, event));
26233 + pReply = (SCSIIOReply_t *)reply;
26234 + status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
26235 + scsi_status = pReply->SCSIStatus;
26236
26237 - if (ioc->sh == NULL ||
26238 - ((hd = shost_priv(ioc->sh)) == NULL))
26239 - return 1;
26240 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26241 + "IOCStatus=%04xh, SCSIState=%02xh, SCSIStatus=%02xh, IOCLogInfo=%08xh\n",
26242 + ioc->name, status, pReply->SCSIState, scsi_status, le32_to_cpu(pReply->IOCLogInfo)));
26243
26244 - switch (event) {
26245 - case MPI_EVENT_UNIT_ATTENTION: /* 03 */
26246 - /* FIXME! */
26247 - break;
26248 - case MPI_EVENT_IOC_BUS_RESET: /* 04 */
26249 - case MPI_EVENT_EXT_BUS_RESET: /* 05 */
26250 - if (hd && (ioc->bus_type == SPI) && (hd->soft_resets < -1))
26251 - hd->soft_resets++;
26252 - break;
26253 - case MPI_EVENT_LOGOUT: /* 09 */
26254 - /* FIXME! */
26255 + switch(status) {
26256 +
26257 + case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
26258 + completion_code = MPT_SCANDV_SELECTION_TIMEOUT;
26259 break;
26260
26261 - case MPI_EVENT_RESCAN: /* 06 */
26262 + case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
26263 + case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
26264 + case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
26265 + case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
26266 + completion_code = MPT_SCANDV_DID_RESET;
26267 break;
26268
26269 - /*
26270 - * CHECKME! Don't think we need to do
26271 - * anything for these, but...
26272 - */
26273 - case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */
26274 - case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */
26275 - /*
26276 - * CHECKME! Falling thru...
26277 - */
26278 + case MPI_IOCSTATUS_BUSY:
26279 + case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES:
26280 + completion_code = MPT_SCANDV_BUSY;
26281 break;
26282
26283 - case MPI_EVENT_INTEGRATED_RAID: /* 0B */
26284 + case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
26285 + case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
26286 + case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
26287 + if (pReply->Function == MPI_FUNCTION_CONFIG) {
26288 + completion_code = MPT_SCANDV_GOOD;
26289 + } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
26290 + pr = (MpiRaidActionReply_t *)reply;
26291 + if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
26292 + completion_code = MPT_SCANDV_GOOD;
26293 + else
26294 + completion_code = MPT_SCANDV_SOME_ERROR;
26295 + } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)
26296 + completion_code = MPT_SCANDV_SENSE;
26297 + else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
26298 + if (req->u.scsireq.CDB[0] == INQUIRY)
26299 + completion_code = MPT_SCANDV_ISSUE_SENSE;
26300 + else
26301 + completion_code = MPT_SCANDV_DID_RESET;
26302 + }
26303 + else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
26304 + completion_code = MPT_SCANDV_DID_RESET;
26305 + else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
26306 + completion_code = MPT_SCANDV_DID_RESET;
26307 + else if (scsi_status == MPI_SCSI_STATUS_BUSY)
26308 + completion_code = MPT_SCANDV_BUSY;
26309 + else
26310 + completion_code = MPT_SCANDV_GOOD;
26311 break;
26312
26313 - case MPI_EVENT_NONE: /* 00 */
26314 - case MPI_EVENT_LOG_DATA: /* 01 */
26315 - case MPI_EVENT_STATE_CHANGE: /* 02 */
26316 - case MPI_EVENT_EVENT_CHANGE: /* 0A */
26317 + case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
26318 + if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
26319 + completion_code = MPT_SCANDV_DID_RESET;
26320 + else
26321 + completion_code = MPT_SCANDV_SOME_ERROR;
26322 + break;
26323 default:
26324 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": Ignoring event (=%02Xh)\n",
26325 - ioc->name, event));
26326 + completion_code = MPT_SCANDV_SOME_ERROR;
26327 break;
26328 - }
26329
26330 - return 1; /* currently means nothing really */
26331 -}
26332 + } /* switch(status) */
26333
26334 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26335 -/*
26336 - * Bus Scan and Domain Validation functionality ...
26337 - */
26338 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26339 + " completionCode set to %08xh\n", ioc->name, completion_code));
26340 + return completion_code;
26341 +}
26342
26343 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26344 -/*
26345 - * mptscsih_scandv_complete - Scan and DV callback routine registered
26346 - * to Fustion MPT (base) driver.
26347 - *
26348 +/**
26349 + * mptscsih_scandv_complete -
26350 * @ioc: Pointer to MPT_ADAPTER structure
26351 - * @mf: Pointer to original MPT request frame
26352 - * @mr: Pointer to MPT reply frame (NULL if TurboReply)
26353 + * @req:
26354 + * @reply:
26355 *
26356 - * This routine is called from mpt.c::mpt_interrupt() at the completion
26357 - * of any SCSI IO request.
26358 - * This routine is registered with the Fusion MPT (base) driver at driver
26359 - * load/init time via the mpt_register() API call.
26360 - *
26361 - * Returns 1 indicating alloc'd request frame ptr should be freed.
26362 - *
26363 - * Remark: Sets a completion code and (possibly) saves sense data
26364 - * in the IOC member localReply structure.
26365 - * Used ONLY for DV and other internal commands.
26366 - */
26367 + **/
26368 int
26369 -mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
26370 +mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
26371 {
26372 - MPT_SCSI_HOST *hd;
26373 SCSIIORequest_t *pReq;
26374 - int completionCode;
26375 + SCSIIOReply_t *pReply;
26376 + u8 cmd;
26377 u16 req_idx;
26378 + u8 *sense_data;
26379 + int sz;
26380
26381 - hd = shost_priv(ioc->sh);
26382 -
26383 - if ((mf == NULL) ||
26384 - (mf >= MPT_INDEX_2_MFPTR(ioc, ioc->req_depth))) {
26385 - printk(MYIOC_s_ERR_FMT
26386 - "ScanDvComplete, %s req frame ptr! (=%p)\n",
26387 - ioc->name, mf?"BAD":"NULL", (void *) mf);
26388 - goto wakeup;
26389 - }
26390 -
26391 - del_timer(&hd->timer);
26392 - req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
26393 - mptscsih_set_scsi_lookup(ioc, req_idx, NULL);
26394 - pReq = (SCSIIORequest_t *) mf;
26395 + ioc->internal_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD;
26396 + ioc->internal_cmds.completion_code = MPT_SCANDV_GOOD;
26397 + if (!reply)
26398 + goto out;
26399
26400 - if (mf != hd->cmdPtr) {
26401 - printk(MYIOC_s_WARN_FMT "ScanDvComplete (mf=%p, cmdPtr=%p, idx=%d)\n",
26402 - ioc->name, (void *)mf, (void *) hd->cmdPtr, req_idx);
26403 + pReply = (SCSIIOReply_t *) reply;
26404 + pReq = (SCSIIORequest_t *) req;
26405 + ioc->internal_cmds.completion_code =
26406 + mptscsih_get_completion_code(ioc, req, reply);
26407 + ioc->internal_cmds.status |= MPT_MGMT_STATUS_RF_VALID;
26408 + memcpy(ioc->internal_cmds.reply, reply,
26409 + min(MPT_DEFAULT_FRAME_SIZE, 4 * reply->u.reply.MsgLength));
26410 + cmd = reply->u.hdr.Function;
26411 + if (((cmd == MPI_FUNCTION_SCSI_IO_REQUEST) ||
26412 + (cmd == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) &&
26413 + (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
26414 + req_idx = le16_to_cpu(req->u.frame.hwhdr.msgctxu.fld.req_idx);
26415 + sense_data = ((u8 *)ioc->sense_buf_pool +
26416 + (req_idx * MPT_SENSE_BUFFER_ALLOC));
26417 + sz = min_t(int, pReq->SenseBufferLength,
26418 + MPT_SENSE_BUFFER_ALLOC);
26419 + memcpy(ioc->internal_cmds.sense, sense_data, sz);
26420 }
26421 - hd->cmdPtr = NULL;
26422 -
26423 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScanDvComplete (mf=%p,mr=%p,idx=%d)\n",
26424 - ioc->name, mf, mr, req_idx));
26425 -
26426 - hd->pLocal = &hd->localReply;
26427 - hd->pLocal->scsiStatus = 0;
26428 -
26429 - /* If target struct exists, clear sense valid flag.
26430 - */
26431 - if (mr == NULL) {
26432 - completionCode = MPT_SCANDV_GOOD;
26433 - } else {
26434 - SCSIIOReply_t *pReply;
26435 - u16 status;
26436 - u8 scsi_status;
26437 -
26438 - pReply = (SCSIIOReply_t *) mr;
26439 -
26440 - status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
26441 - scsi_status = pReply->SCSIStatus;
26442 -
26443 -
26444 - switch(status) {
26445 -
26446 - case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
26447 - completionCode = MPT_SCANDV_SELECTION_TIMEOUT;
26448 - break;
26449 -
26450 - case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
26451 - case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
26452 - case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
26453 - case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
26454 - completionCode = MPT_SCANDV_DID_RESET;
26455 - break;
26456 -
26457 - case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
26458 - case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
26459 - case MPI_IOCSTATUS_SUCCESS: /* 0x0000 */
26460 - if (pReply->Function == MPI_FUNCTION_CONFIG) {
26461 - ConfigReply_t *pr = (ConfigReply_t *)mr;
26462 - completionCode = MPT_SCANDV_GOOD;
26463 - hd->pLocal->header.PageVersion = pr->Header.PageVersion;
26464 - hd->pLocal->header.PageLength = pr->Header.PageLength;
26465 - hd->pLocal->header.PageNumber = pr->Header.PageNumber;
26466 - hd->pLocal->header.PageType = pr->Header.PageType;
26467 -
26468 - } else if (pReply->Function == MPI_FUNCTION_RAID_ACTION) {
26469 - /* If the RAID Volume request is successful,
26470 - * return GOOD, else indicate that
26471 - * some type of error occurred.
26472 - */
26473 - MpiRaidActionReply_t *pr = (MpiRaidActionReply_t *)mr;
26474 - if (le16_to_cpu(pr->ActionStatus) == MPI_RAID_ACTION_ASTATUS_SUCCESS)
26475 - completionCode = MPT_SCANDV_GOOD;
26476 - else
26477 - completionCode = MPT_SCANDV_SOME_ERROR;
26478 - memcpy(hd->pLocal->sense, pr, sizeof(hd->pLocal->sense));
26479 -
26480 - } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) {
26481 - u8 *sense_data;
26482 - int sz;
26483 -
26484 - /* save sense data in global structure
26485 - */
26486 - completionCode = MPT_SCANDV_SENSE;
26487 - hd->pLocal->scsiStatus = scsi_status;
26488 - sense_data = ((u8 *)ioc->sense_buf_pool +
26489 - (req_idx * MPT_SENSE_BUFFER_ALLOC));
26490 -
26491 - sz = min_t(int, pReq->SenseBufferLength,
26492 - SCSI_STD_SENSE_BYTES);
26493 - memcpy(hd->pLocal->sense, sense_data, sz);
26494 -
26495 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT " Check Condition, sense ptr %p\n",
26496 - ioc->name, sense_data));
26497 - } else if (pReply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) {
26498 - if (pReq->CDB[0] == INQUIRY)
26499 - completionCode = MPT_SCANDV_ISSUE_SENSE;
26500 - else
26501 - completionCode = MPT_SCANDV_DID_RESET;
26502 - }
26503 - else if (pReply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS)
26504 - completionCode = MPT_SCANDV_DID_RESET;
26505 - else if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
26506 - completionCode = MPT_SCANDV_DID_RESET;
26507 - else {
26508 - completionCode = MPT_SCANDV_GOOD;
26509 - hd->pLocal->scsiStatus = scsi_status;
26510 - }
26511 - break;
26512 -
26513 - case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
26514 - if (pReply->SCSIState & MPI_SCSI_STATE_TERMINATED)
26515 - completionCode = MPT_SCANDV_DID_RESET;
26516 - else
26517 - completionCode = MPT_SCANDV_SOME_ERROR;
26518 - break;
26519 -
26520 - default:
26521 - completionCode = MPT_SCANDV_SOME_ERROR;
26522 - break;
26523 -
26524 - } /* switch(status) */
26525 -
26526 - } /* end of address reply case */
26527 -
26528 - hd->pLocal->completion = completionCode;
26529 -
26530 - /* MF and RF are freed in mpt_interrupt
26531 - */
26532 -wakeup:
26533 - /* Free Chain buffers (will never chain) in scan or dv */
26534 - //mptscsih_freeChainBuffers(ioc, req_idx);
26535 -
26536 - /*
26537 - * Wake up the original calling thread
26538 - */
26539 - hd->scandv_wait_done = 1;
26540 - wake_up(&hd->scandv_waitq);
26541 -
26542 + out:
26543 + if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_PENDING))
26544 + return 0;
26545 + ioc->internal_cmds.status &= ~MPT_MGMT_STATUS_PENDING;
26546 + complete(&ioc->internal_cmds.done);
26547 return 1;
26548 }
26549
26550 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26551 -/* mptscsih_timer_expired - Call back for timer process.
26552 - * Used only for dv functionality.
26553 - * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
26554 - *
26555 - */
26556 -void
26557 -mptscsih_timer_expired(unsigned long data)
26558 -{
26559 - MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) data;
26560 - MPT_ADAPTER *ioc = hd->ioc;
26561 -
26562 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Timer Expired! Cmd %p\n", ioc->name, hd->cmdPtr));
26563 -
26564 - if (hd->cmdPtr) {
26565 - MPIHeader_t *cmd = (MPIHeader_t *)hd->cmdPtr;
26566 -
26567 - if (cmd->Function == MPI_FUNCTION_SCSI_IO_REQUEST) {
26568 - /* Desire to issue a task management request here.
26569 - * TM requests MUST be single threaded.
26570 - * If old eh code and no TM current, issue request.
26571 - * If new eh code, do nothing. Wait for OS cmd timeout
26572 - * for bus reset.
26573 - */
26574 - } else {
26575 - /* Perform a FW reload */
26576 - if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0) {
26577 - printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
26578 - }
26579 - }
26580 - } else {
26581 - /* This should NEVER happen */
26582 - printk(MYIOC_s_WARN_FMT "Null cmdPtr!!!!\n", ioc->name);
26583 - }
26584 -
26585 - /* No more processing.
26586 - * TM call will generate an interrupt for SCSI TM Management.
26587 - * The FW will reply to all outstanding commands, callback will finish cleanup.
26588 - * Hard reset clean-up will free all resources.
26589 - */
26590 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Timer Expired Complete!\n", ioc->name));
26591 -
26592 - return;
26593 -}
26594 -
26595 -
26596 -/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26597 /**
26598 * mptscsih_do_cmd - Do internal command.
26599 * @hd: MPT_SCSI_HOST pointer
26600 @@ -3019,28 +2944,33 @@ mptscsih_timer_expired(unsigned long dat
26601 * 0 if good
26602 *
26603 * > 0 if command complete but some type of completion error.
26604 - */
26605 -static int
26606 + **/
26607 +int
26608 mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *io)
26609 {
26610 MPT_FRAME_HDR *mf;
26611 SCSIIORequest_t *pScsiReq;
26612 - SCSIIORequest_t ReqCopy;
26613 int my_idx, ii, dir;
26614 - int rc, cmdTimeout;
26615 - int in_isr;
26616 + int timeout;
26617 char cmdLen;
26618 char CDB[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
26619 - char cmd = io->cmd;
26620 - MPT_ADAPTER *ioc = hd->ioc;
26621 + u8 cmd = io->cmd;
26622 + MPT_ADAPTER *ioc = hd->ioc;
26623 + int ret = 0;
26624 + unsigned long timeleft;
26625 + unsigned long flags;
26626
26627 - in_isr = in_interrupt();
26628 - if (in_isr) {
26629 - dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Internal SCSI IO request not allowed in ISR context!\n",
26630 - ioc->name));
26631 - return -EPERM;
26632 + /* don't send internal command during diag reset */
26633 + spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
26634 + if (ioc->ioc_reset_in_progress) {
26635 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
26636 + dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26637 + "%s: busy with host reset\n", ioc->name, __FUNCTION__));
26638 + return MPT_SCANDV_BUSY;
26639 }
26640 + spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
26641
26642 + mutex_lock(&ioc->internal_cmds.mutex);
26643
26644 /* Set command specific information
26645 */
26646 @@ -3050,13 +2980,13 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26647 dir = MPI_SCSIIO_CONTROL_READ;
26648 CDB[0] = cmd;
26649 CDB[4] = io->size;
26650 - cmdTimeout = 10;
26651 + timeout = 10;
26652 break;
26653
26654 case TEST_UNIT_READY:
26655 cmdLen = 6;
26656 dir = MPI_SCSIIO_CONTROL_READ;
26657 - cmdTimeout = 10;
26658 + timeout = 10;
26659 break;
26660
26661 case START_STOP:
26662 @@ -3064,7 +2994,7 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26663 dir = MPI_SCSIIO_CONTROL_READ;
26664 CDB[0] = cmd;
26665 CDB[4] = 1; /*Spin up the disk */
26666 - cmdTimeout = 15;
26667 + timeout = 15;
26668 break;
26669
26670 case REQUEST_SENSE:
26671 @@ -3072,7 +3002,7 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26672 CDB[0] = cmd;
26673 CDB[4] = io->size;
26674 dir = MPI_SCSIIO_CONTROL_READ;
26675 - cmdTimeout = 10;
26676 + timeout = 10;
26677 break;
26678
26679 case READ_BUFFER:
26680 @@ -3091,7 +3021,7 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26681 CDB[6] = (io->size >> 16) & 0xFF;
26682 CDB[7] = (io->size >> 8) & 0xFF;
26683 CDB[8] = io->size & 0xFF;
26684 - cmdTimeout = 10;
26685 + timeout = 10;
26686 break;
26687
26688 case WRITE_BUFFER:
26689 @@ -3106,21 +3036,21 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26690 CDB[6] = (io->size >> 16) & 0xFF;
26691 CDB[7] = (io->size >> 8) & 0xFF;
26692 CDB[8] = io->size & 0xFF;
26693 - cmdTimeout = 10;
26694 + timeout = 10;
26695 break;
26696
26697 case RESERVE:
26698 cmdLen = 6;
26699 dir = MPI_SCSIIO_CONTROL_READ;
26700 CDB[0] = cmd;
26701 - cmdTimeout = 10;
26702 + timeout = 10;
26703 break;
26704
26705 case RELEASE:
26706 cmdLen = 6;
26707 dir = MPI_SCSIIO_CONTROL_READ;
26708 CDB[0] = cmd;
26709 - cmdTimeout = 10;
26710 + timeout = 10;
26711 break;
26712
26713 case SYNCHRONIZE_CACHE:
26714 @@ -3128,20 +3058,42 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26715 dir = MPI_SCSIIO_CONTROL_READ;
26716 CDB[0] = cmd;
26717 // CDB[1] = 0x02; /* set immediate bit */
26718 - cmdTimeout = 10;
26719 + timeout = 10;
26720 + break;
26721 +
26722 + case REPORT_LUNS:
26723 + cmdLen = 12;
26724 + dir = MPI_SCSIIO_CONTROL_READ;
26725 + CDB[0] = cmd;
26726 + CDB[6] = (io->size >> 24) & 0xFF;
26727 + CDB[7] = (io->size >> 16) & 0xFF;
26728 + CDB[8] = (io->size >> 8) & 0xFF;
26729 + CDB[9] = io->size & 0xFF;
26730 + timeout = 10;
26731 + break;
26732 +
26733 + case TRANSPORT_LAYER_RETRIES:
26734 + CDB[0] = cmd;
26735 + CDB[1] = 0x01;
26736 + cmdLen = 6;
26737 + dir = MPI_SCSIIO_CONTROL_READ;
26738 + timeout = 10;
26739 break;
26740
26741 default:
26742 /* Error Case */
26743 - return -EFAULT;
26744 + ret = -EFAULT;
26745 + goto out;
26746 }
26747
26748 /* Get and Populate a free Frame
26749 + * MsgContext set in mpt_get_msg_frame call
26750 */
26751 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
26752 - dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "No msg frames!\n",
26753 - ioc->name));
26754 - return -EBUSY;
26755 + dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: No msg frames!\n",
26756 + ioc->name, __FUNCTION__));
26757 + ret = MPT_SCANDV_BUSY;
26758 + goto out;
26759 }
26760
26761 pScsiReq = (SCSIIORequest_t *) mf;
26762 @@ -3164,14 +3116,10 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26763
26764 pScsiReq->CDBLength = cmdLen;
26765 pScsiReq->SenseBufferLength = MPT_SENSE_BUFFER_SIZE;
26766 -
26767 pScsiReq->Reserved = 0;
26768 -
26769 - pScsiReq->MsgFlags = mpt_msg_flags();
26770 - /* MsgContext set in mpt_get_msg_fram call */
26771 + pScsiReq->MsgFlags = mpt_msg_flags(ioc);
26772
26773 int_to_scsilun(io->lun, (struct scsi_lun *)pScsiReq->LUN);
26774 -
26775 if (io->flags & MPT_ICFLAG_TAGGED_CMD)
26776 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_SIMPLEQ);
26777 else
26778 @@ -3179,74 +3127,61 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26779
26780 if (cmd == REQUEST_SENSE) {
26781 pScsiReq->Control = cpu_to_le32(dir | MPI_SCSIIO_CONTROL_UNTAGGED);
26782 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Untagged! 0x%2x\n",
26783 - ioc->name, cmd));
26784 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26785 + "%s: Untagged! 0x%02x\n", ioc->name, __FUNCTION__, cmd));
26786 }
26787
26788 - for (ii=0; ii < 16; ii++)
26789 - pScsiReq->CDB[ii] = CDB[ii];
26790 + for (ii = 0; ii < 16; ii++)
26791 + pScsiReq->CDB[ii] = CDB[ii];
26792
26793 pScsiReq->DataLength = cpu_to_le32(io->size);
26794 pScsiReq->SenseBufferLowAddr = cpu_to_le32(ioc->sense_buf_low_dma
26795 + (my_idx * MPT_SENSE_BUFFER_ALLOC));
26796
26797 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Command 0x%x for (%d:%d:%d)\n",
26798 - ioc->name, cmd, io->channel, io->id, io->lun));
26799 -
26800 - if (dir == MPI_SCSIIO_CONTROL_READ) {
26801 - mpt_add_sge((char *) &pScsiReq->SGL,
26802 - MPT_SGE_FLAGS_SSIMPLE_READ | io->size,
26803 - io->data_dma);
26804 - } else {
26805 - mpt_add_sge((char *) &pScsiReq->SGL,
26806 - MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size,
26807 - io->data_dma);
26808 - }
26809 -
26810 - /* The ISR will free the request frame, but we need
26811 - * the information to initialize the target. Duplicate.
26812 - */
26813 - memcpy(&ReqCopy, pScsiReq, sizeof(SCSIIORequest_t));
26814 -
26815 - /* Issue this command after:
26816 - * finish init
26817 - * add timer
26818 - * Wait until the reply has been received
26819 - * ScsiScanDvCtx callback function will
26820 - * set hd->pLocal;
26821 - * set scandv_wait_done and call wake_up
26822 - */
26823 - hd->pLocal = NULL;
26824 - hd->timer.expires = jiffies + HZ*cmdTimeout;
26825 - hd->scandv_wait_done = 0;
26826 -
26827 - /* Save cmd pointer, for resource free if timeout or
26828 - * FW reload occurs
26829 - */
26830 - hd->cmdPtr = mf;
26831 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26832 + "%s: Sending Command 0x%02x for fw_channel=%d fw_id=%d lun=%d\n",
26833 + ioc->name, __FUNCTION__, cmd, io->channel, io->id, io->lun));
26834 +
26835 + if (dir == MPI_SCSIIO_CONTROL_READ)
26836 + ioc->add_sge((char *) &pScsiReq->SGL,
26837 + MPT_SGE_FLAGS_SSIMPLE_READ | io->size, io->data_dma);
26838 + else
26839 + ioc->add_sge((char *) &pScsiReq->SGL,
26840 + MPT_SGE_FLAGS_SSIMPLE_WRITE | io->size, io->data_dma);
26841
26842 - add_timer(&hd->timer);
26843 + INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
26844 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
26845 - wait_event(hd->scandv_waitq, hd->scandv_wait_done);
26846 -
26847 - if (hd->pLocal) {
26848 - rc = hd->pLocal->completion;
26849 - hd->pLocal->skip = 0;
26850 -
26851 - /* Always set fatal error codes in some cases.
26852 - */
26853 - if (rc == MPT_SCANDV_SELECTION_TIMEOUT)
26854 - rc = -ENXIO;
26855 - else if (rc == MPT_SCANDV_SOME_ERROR)
26856 - rc = -rc;
26857 - } else {
26858 - rc = -EFAULT;
26859 - /* This should never happen. */
26860 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "_do_cmd: Null pLocal!!!\n",
26861 - ioc->name));
26862 + timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done,
26863 + timeout*HZ);
26864 + if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
26865 + ret = MPT_SCANDV_DID_RESET;
26866 + dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT
26867 + "%s: TIMED OUT for cmd=0x%02x\n", ioc->name, __FUNCTION__,
26868 + cmd));
26869 + if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
26870 + mpt_free_msg_frame(ioc, mf);
26871 + goto out;
26872 + }
26873 + if (!timeleft) {
26874 + if (!mptscsih_scandv_bus_reset(ioc))
26875 + goto out;
26876 + printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
26877 + ioc->name, __FUNCTION__);
26878 + if (mpt_SoftResetHandler(ioc, CAN_SLEEP) != 0)
26879 + mpt_HardResetHandler(ioc, CAN_SLEEP);
26880 + mpt_free_msg_frame(ioc, mf);
26881 + }
26882 + goto out;
26883 }
26884
26885 - return rc;
26886 + ret = ioc->internal_cmds.completion_code;
26887 + devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: success, rc=0x%02x\n",
26888 + ioc->name, __FUNCTION__, ret));
26889 +
26890 + out:
26891 + CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
26892 + mutex_unlock(&ioc->internal_cmds.mutex);
26893 + return ret;
26894 }
26895
26896 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
26897 @@ -3260,9 +3195,10 @@ mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTER
26898 *
26899 */
26900 static void
26901 -mptscsih_synchronize_cache(MPT_SCSI_HOST *hd, VirtDevice *vdevice)
26902 +mptscsih_synchronize_cache(struct scsi_device *sdev, MPT_SCSI_HOST *hd, VirtDevice *vdevice)
26903 {
26904 INTERNAL_CMD iocmd;
26905 + MPT_ADAPTER *ioc = hd->ioc;
26906
26907 /* Ignore hidden raid components, this is handled when the command
26908 * is sent to the volume
26909 @@ -3274,23 +3210,23 @@ mptscsih_synchronize_cache(MPT_SCSI_HOST
26910 !vdevice->configured_lun)
26911 return;
26912
26913 - /* Following parameters will not change
26914 - * in this routine.
26915 - */
26916 + memset(&iocmd, 0, sizeof(INTERNAL_CMD));
26917 iocmd.cmd = SYNCHRONIZE_CACHE;
26918 - iocmd.flags = 0;
26919 iocmd.physDiskNum = -1;
26920 iocmd.data = NULL;
26921 iocmd.data_dma = -1;
26922 - iocmd.size = 0;
26923 - iocmd.rsvd = iocmd.rsvd2 = 0;
26924 iocmd.channel = vdevice->vtarget->channel;
26925 iocmd.id = vdevice->vtarget->id;
26926 iocmd.lun = vdevice->lun;
26927
26928 + sdev_printk(KERN_INFO, sdev, MYIOC_s_FMT "SYNCHRONIZE_CACHE: fw_channel %d,"
26929 + " fw_id %d\n", ioc->name, vdevice->vtarget->channel, vdevice->vtarget->id);
26930 mptscsih_do_cmd(hd, &iocmd);
26931 }
26932
26933 +/*
26934 + * shost attributes
26935 + */
26936 static ssize_t
26937 mptscsih_version_fw_show(struct device *dev, struct device_attribute *attr,
26938 char *buf)
26939 @@ -3464,13 +3400,44 @@ mptscsih_debug_level_store(struct device
26940 return -EINVAL;
26941
26942 ioc->debug_level = val;
26943 - printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n",
26944 - ioc->name, ioc->debug_level);
26945 + printk(MYIOC_s_INFO_FMT "debug_level=%08xh\n", ioc->name,
26946 + ioc->debug_level);
26947 return strlen(buf);
26948 }
26949 static DEVICE_ATTR(debug_level, S_IRUGO | S_IWUSR,
26950 mptscsih_debug_level_show, mptscsih_debug_level_store);
26951
26952 +static ssize_t
26953 +mptscsih_disable_hotplug_remove_show(struct device *dev, struct device_attribute *attr, char *buf)
26954 +{
26955 + struct Scsi_Host *host = class_to_shost(dev);
26956 + MPT_SCSI_HOST *hd = shost_priv(host);
26957 + MPT_ADAPTER *ioc = hd->ioc;
26958 +
26959 + return snprintf(buf, PAGE_SIZE, "%02xh\n", ioc->disable_hotplug_remove);
26960 +}
26961 +static ssize_t
26962 +mptscsih_disable_hotplug_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
26963 +{
26964 + struct Scsi_Host *host = class_to_shost(dev);
26965 + MPT_SCSI_HOST *hd = shost_priv(host);
26966 + MPT_ADAPTER *ioc = hd->ioc;
26967 + int val = 0;
26968 +
26969 + if (sscanf(buf, "%x", &val) != 1)
26970 + return -EINVAL;
26971 +
26972 + ioc->disable_hotplug_remove = val;
26973 + if (ioc->disable_hotplug_remove)
26974 + printk(MYIOC_s_INFO_FMT "disabling hotplug remove\n",
26975 + ioc->name);
26976 + else
26977 + printk(MYIOC_s_INFO_FMT "eanbling hotplug remove\n", ioc->name);
26978 + return strlen(buf);
26979 +}
26980 +static DEVICE_ATTR(disable_hotplug_remove, S_IRUGO | S_IWUSR,
26981 + mptscsih_disable_hotplug_remove_show, mptscsih_disable_hotplug_remove_store);
26982 +
26983 struct device_attribute *mptscsih_host_attrs[] = {
26984 &dev_attr_version_fw,
26985 &dev_attr_version_bios,
26986 @@ -3484,6 +3451,7 @@ struct device_attribute *mptscsih_host_a
26987 &dev_attr_io_delay,
26988 &dev_attr_device_delay,
26989 &dev_attr_debug_level,
26990 + &dev_attr_disable_hotplug_remove,
26991 NULL,
26992 };
26993 EXPORT_SYMBOL(mptscsih_host_attrs);
26994 @@ -3510,7 +3478,9 @@ EXPORT_SYMBOL(mptscsih_scandv_complete);
26995 EXPORT_SYMBOL(mptscsih_event_process);
26996 EXPORT_SYMBOL(mptscsih_ioc_reset);
26997 EXPORT_SYMBOL(mptscsih_change_queue_depth);
26998 -EXPORT_SYMBOL(mptscsih_timer_expired);
26999 -EXPORT_SYMBOL(mptscsih_TMHandler);
27000 -
27001 +EXPORT_SYMBOL(mptscsih_IssueTaskMgmt);
27002 +EXPORT_SYMBOL(mptscsih_do_cmd);
27003 +EXPORT_SYMBOL(mptscsih_quiesce_raid);
27004 +EXPORT_SYMBOL(mptscsih_get_scsi_lookup);
27005 +EXPORT_SYMBOL(mptscsih_taskmgmt_response_code);
27006 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27007 --- a/drivers/message/fusion/mptscsih.h
27008 +++ b/drivers/message/fusion/mptscsih.h
27009 @@ -60,6 +60,7 @@
27010 #define MPT_SCANDV_SELECTION_TIMEOUT (0x00000008)
27011 #define MPT_SCANDV_ISSUE_SENSE (0x00000010)
27012 #define MPT_SCANDV_FALLBACK (0x00000020)
27013 +#define MPT_SCANDV_BUSY (0x00000040)
27014
27015 #define MPT_SCANDV_MAX_RETRIES (10)
27016
27017 @@ -71,6 +72,7 @@
27018 #define MPT_ICFLAG_DID_RESET 0x20 /* Bus Reset occurred with this command */
27019 #define MPT_ICFLAG_RESERVED 0x40 /* Reserved has been issued */
27020
27021 +
27022 #define MPT_SCSI_CMD_PER_DEV_HIGH 64
27023 #define MPT_SCSI_CMD_PER_DEV_LOW 32
27024
27025 @@ -84,9 +86,11 @@
27026 #define MPTSCSIH_DOMAIN_VALIDATION 1
27027 #define MPTSCSIH_MAX_WIDTH 1
27028 #define MPTSCSIH_MIN_SYNC 0x08
27029 +#define MPTSCSIH_QAS 1
27030 #define MPTSCSIH_SAF_TE 0
27031 #define MPTSCSIH_PT_CLEAR 0
27032
27033 +#define TRANSPORT_LAYER_RETRIES 0xC2
27034 #endif
27035
27036 typedef struct _internal_cmd {
27037 @@ -112,7 +116,7 @@ extern int mptscsih_resume(struct pci_de
27038 extern int mptscsih_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int func);
27039 extern const char * mptscsih_info(struct Scsi_Host *SChost);
27040 extern int mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *));
27041 -extern void mptscsih_slave_destroy(struct scsi_device *device);
27042 +extern void mptscsih_slave_destroy(struct scsi_device *sdev);
27043 extern int mptscsih_slave_configure(struct scsi_device *device);
27044 extern int mptscsih_abort(struct scsi_cmnd * SCpnt);
27045 extern int mptscsih_dev_reset(struct scsi_cmnd * SCpnt);
27046 @@ -125,8 +129,11 @@ extern int mptscsih_scandv_complete(MPT_
27047 extern int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
27048 extern int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
27049 extern int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth);
27050 -extern void mptscsih_timer_expired(unsigned long data);
27051 -extern int mptscsih_TMHandler(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
27052 +extern int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel, u8 id, int lun, int ctx2abort, ulong timeout);
27053 extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id);
27054 extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id);
27055 +extern int mptscsih_do_cmd(MPT_SCSI_HOST *hd, INTERNAL_CMD *iocmd);
27056 extern struct device_attribute *mptscsih_host_attrs[];
27057 +extern int mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id);
27058 +extern struct scsi_cmnd * mptscsih_get_scsi_lookup(MPT_ADAPTER *ioc, int i);
27059 +extern void mptscsih_taskmgmt_response_code(MPT_ADAPTER *ioc, u8 response_code);
27060 --- a/drivers/message/fusion/mptspi.c
27061 +++ b/drivers/message/fusion/mptspi.c
27062 @@ -53,8 +53,10 @@
27063 #include <linux/delay.h> /* for mdelay */
27064 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
27065 #include <linux/reboot.h> /* notifier code */
27066 +#include <linux/sched.h>
27067 #include <linux/workqueue.h>
27068 #include <linux/raid_class.h>
27069 +#include <linux/pci.h>
27070
27071 #include <scsi/scsi.h>
27072 #include <scsi/scsi_cmnd.h>
27073 @@ -83,6 +85,10 @@ static int mpt_saf_te = MPTSCSIH_SAF_TE;
27074 module_param(mpt_saf_te, int, 0);
27075 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
27076
27077 +static int mpt_qas = MPTSCSIH_QAS;
27078 +module_param(mpt_qas, int, 1);
27079 +MODULE_PARM_DESC(mpt_qas, " Quick Arbitration and Selection (QAS) enabled=1, disabled=0 (default=MPTSCSIH_QAS=1)");
27080 +
27081 static void mptspi_write_offset(struct scsi_target *, int);
27082 static void mptspi_write_width(struct scsi_target *, int);
27083 static int mptspi_write_spi_device_pg1(struct scsi_target *,
27084 @@ -95,12 +101,12 @@ static u8 mptspiTaskCtx = MPT_MAX_PROTOC
27085 static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
27086
27087 /**
27088 - * mptspi_setTargetNegoParms - Update the target negotiation parameters
27089 + * mptspi_setTargetNegoParms - Update the target negotiation parameters
27090 * @hd: Pointer to a SCSI Host Structure
27091 * @target: per target private data
27092 * @sdev: SCSI device
27093 *
27094 - * Update the target negotiation parameters based on the the Inquiry
27095 + * Update the target negotiation parameters based on the the Inquiry
27096 * data, adapter capabilities, and NVRAM settings.
27097 **/
27098 static void
27099 @@ -131,7 +137,7 @@ mptspi_setTargetNegoParms(MPT_SCSI_HOST
27100 if (scsi_device_sync(sdev)) {
27101 factor = pspi_data->minSyncFactor;
27102 if (!scsi_device_dt(sdev))
27103 - factor = MPT_ULTRA2;
27104 + factor = MPT_ULTRA2;
27105 else {
27106 if (!scsi_device_ius(sdev) &&
27107 !scsi_device_qas(sdev))
27108 @@ -209,6 +215,10 @@ mptspi_setTargetNegoParms(MPT_SCSI_HOST
27109 target->maxOffset = offset;
27110 target->maxWidth = width;
27111
27112 + spi_min_period(scsi_target(sdev)) = factor;
27113 + spi_max_offset(scsi_target(sdev)) = offset;
27114 + spi_max_width(scsi_target(sdev)) = width;
27115 +
27116 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
27117
27118 /* Disable unused features.
27119 @@ -230,7 +240,7 @@ mptspi_setTargetNegoParms(MPT_SCSI_HOST
27120 */
27121
27122 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
27123 - "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
27124 + "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
27125 }
27126 }
27127
27128 @@ -262,7 +272,7 @@ mptspi_writeIOCPage4(MPT_SCSI_HOST *hd,
27129 */
27130 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
27131 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
27132 - "writeIOCPage4 : no msg frames!\n",ioc->name));
27133 + "writeIOCPage4 : no msg frames!\n", ioc->name));
27134 return -EAGAIN;
27135 }
27136
27137 @@ -300,11 +310,11 @@ mptspi_writeIOCPage4(MPT_SCSI_HOST *hd,
27138 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
27139 (IOCPage4Ptr->Header.PageLength + ii) * 4;
27140
27141 - mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
27142 + ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
27143
27144 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
27145 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
27146 - ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
27147 + ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
27148
27149 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
27150
27151 @@ -371,7 +381,7 @@ mptspi_initTarget(MPT_SCSI_HOST *hd, Vir
27152 * non-zero = true
27153 * zero = false
27154 *
27155 - */
27156 + **/
27157 static int
27158 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
27159 {
27160 @@ -399,12 +409,11 @@ static int mptspi_target_alloc(struct sc
27161 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
27162 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
27163 VirtTarget *vtarget;
27164 - MPT_ADAPTER *ioc;
27165 + MPT_ADAPTER *ioc = hd->ioc;
27166
27167 if (hd == NULL)
27168 return -ENODEV;
27169
27170 - ioc = hd->ioc;
27171 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
27172 if (!vtarget)
27173 return -ENOMEM;
27174 @@ -471,9 +480,12 @@ mptspi_target_destroy(struct scsi_target
27175 static void
27176 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
27177 {
27178 - ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
27179 + if (!(hd->ioc->debug_level & MPT_DEBUG_DV))
27180 + return;
27181 +
27182 + starget_printk(KERN_DEBUG, starget, MYIOC_s_FMT "Wrote = 0x%08x"
27183 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
27184 - hd->ioc->name, starget->id, ii,
27185 + hd->ioc->name, ii,
27186 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
27187 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
27188 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
27189 @@ -483,7 +495,7 @@ mptspi_print_write_nego(struct _MPT_SCSI
27190 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
27191 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
27192 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
27193 - ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
27194 + ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "");
27195 }
27196
27197 /**
27198 @@ -496,9 +508,12 @@ mptspi_print_write_nego(struct _MPT_SCSI
27199 static void
27200 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
27201 {
27202 - ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
27203 + if (!(hd->ioc->debug_level & MPT_DEBUG_DV))
27204 + return;
27205 +
27206 + starget_printk(KERN_DEBUG, starget, MYIOC_s_FMT "Read = 0x%08x"
27207 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
27208 - hd->ioc->name, starget->id, ii,
27209 + hd->ioc->name, ii,
27210 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
27211 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
27212 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
27213 @@ -508,7 +523,7 @@ mptspi_print_read_nego(struct _MPT_SCSI_
27214 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
27215 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
27216 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
27217 - ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
27218 + ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": "");
27219 }
27220
27221 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
27222 @@ -557,9 +572,11 @@ static int mptspi_read_spi_device_pg0(st
27223 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
27224 cfg.dir = 0;
27225 cfg.pageAddr = starget->id;
27226 + cfg.timeout = 60;
27227
27228 if (mpt_config(ioc, &cfg)) {
27229 - starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
27230 + starget_printk(KERN_ERR, starget,
27231 + MYIOC_s_FMT "mpt_config failed\n", ioc->name);
27232 goto out_free;
27233 }
27234 err = 0;
27235 @@ -614,64 +631,11 @@ static void mptspi_read_parameters(struc
27236 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
27237 }
27238
27239 -static int
27240 -mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
27241 -{
27242 - MpiRaidActionRequest_t *pReq;
27243 - MPT_FRAME_HDR *mf;
27244 - MPT_ADAPTER *ioc = hd->ioc;
27245 -
27246 - /* Get and Populate a free Frame
27247 - */
27248 - if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
27249 - ddvprintk(ioc, printk(MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
27250 - ioc->name));
27251 - return -EAGAIN;
27252 - }
27253 - pReq = (MpiRaidActionRequest_t *)mf;
27254 - if (quiesce)
27255 - pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
27256 - else
27257 - pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
27258 - pReq->Reserved1 = 0;
27259 - pReq->ChainOffset = 0;
27260 - pReq->Function = MPI_FUNCTION_RAID_ACTION;
27261 - pReq->VolumeID = id;
27262 - pReq->VolumeBus = channel;
27263 - pReq->PhysDiskNum = 0;
27264 - pReq->MsgFlags = 0;
27265 - pReq->Reserved2 = 0;
27266 - pReq->ActionDataWord = 0; /* Reserved for this action */
27267 -
27268 - mpt_add_sge((char *)&pReq->ActionDataSGE,
27269 - MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
27270 -
27271 - ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
27272 - ioc->name, pReq->Action, channel, id));
27273 -
27274 - hd->pLocal = NULL;
27275 - hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
27276 - hd->scandv_wait_done = 0;
27277 -
27278 - /* Save cmd pointer, for resource free if timeout or
27279 - * FW reload occurs
27280 - */
27281 - hd->cmdPtr = mf;
27282 -
27283 - add_timer(&hd->timer);
27284 - mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
27285 - wait_event(hd->scandv_waitq, hd->scandv_wait_done);
27286 -
27287 - if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
27288 - return -1;
27289 -
27290 - return 0;
27291 -}
27292 -
27293 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
27294 struct scsi_device *sdev)
27295 {
27296 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
27297 + struct scsi_target *starget = scsi_target(sdev);
27298 MPT_ADAPTER *ioc = hd->ioc;
27299
27300 /* no DV on RAID devices */
27301 @@ -679,11 +643,20 @@ static void mptspi_dv_device(struct _MPT
27302 mptspi_is_raid(hd, sdev->id))
27303 return;
27304
27305 + if (ioc->debug_level & MPT_DEBUG_DV)
27306 + starget_printk(KERN_DEBUG, starget, MYIOC_s_FMT
27307 + "sdtr=%d, wdtr=%d, ppr=%d, min_period=0x%02x, "
27308 + "max_offset=0x%02x, max_width=%d, nego_flags=0x%02x, "
27309 + "tflags=0x%02x\n", ioc->name, sdev->sdtr, sdev->wdtr,
27310 + sdev->ppr, spi_min_period(starget),
27311 + spi_max_offset(starget), spi_max_width(starget),
27312 + vtarget->negoFlags, vtarget->tflags);
27313 +
27314 /* If this is a piece of a RAID, then quiesce first */
27315 if (sdev->channel == 1 &&
27316 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
27317 - starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
27318 - "Integrated RAID quiesce failed\n", ioc->name);
27319 + starget_printk(KERN_ERR, scsi_target(sdev),
27320 + MYIOC_s_FMT "Integrated RAID quiesce failed\n", ioc->name);
27321 return;
27322 }
27323
27324 @@ -693,8 +666,8 @@ static void mptspi_dv_device(struct _MPT
27325
27326 if (sdev->channel == 1 &&
27327 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
27328 - starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
27329 - "Integrated RAID resume failed\n", ioc->name);
27330 + starget_printk(KERN_ERR, scsi_target(sdev),
27331 + MYIOC_s_FMT "Integrated RAID resume failed\n", ioc->name);
27332
27333 mptspi_read_parameters(sdev->sdev_target);
27334 spi_display_xfer_agreement(sdev->sdev_target);
27335 @@ -716,7 +689,7 @@ static int mptspi_slave_alloc(struct scs
27336 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
27337 if (!vdevice) {
27338 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
27339 - ioc->name, sizeof(VirtDevice));
27340 + ioc->name, sizeof(VirtDevice));
27341 return -ENOMEM;
27342 }
27343
27344 @@ -738,21 +711,13 @@ static int mptspi_slave_configure(struct
27345 {
27346 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
27347 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
27348 - int ret;
27349 + int ret;
27350
27351 mptspi_initTarget(hd, vtarget, sdev);
27352 -
27353 ret = mptscsih_slave_configure(sdev);
27354 -
27355 if (ret)
27356 return ret;
27357
27358 - ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
27359 - " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
27360 - sdev->id, spi_min_period(scsi_target(sdev)),
27361 - spi_max_offset(scsi_target(sdev)),
27362 - spi_max_width(scsi_target(sdev))));
27363 -
27364 if ((sdev->channel == 1 ||
27365 !(mptspi_is_raid(hd, sdev->id))) &&
27366 !spi_initial_dv(sdev->sdev_target))
27367 @@ -857,8 +822,8 @@ static int mptspi_write_spi_device_pg1(s
27368
27369 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
27370 if (pg1 == NULL) {
27371 - starget_printk(KERN_ERR, starget, MYIOC_s_FMT
27372 - "dma_alloc_coherent for parameters failed\n", ioc->name);
27373 + starget_printk(KERN_ERR, starget,
27374 + MYIOC_s_FMT "dma_alloc_coherent for parameters failed\n", ioc->name);
27375 return -EINVAL;
27376 }
27377
27378 @@ -887,8 +852,8 @@ static int mptspi_write_spi_device_pg1(s
27379 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
27380
27381 if (mpt_config(ioc, &cfg)) {
27382 - starget_printk(KERN_ERR, starget, MYIOC_s_FMT
27383 - "mpt_config failed\n", ioc->name);
27384 + starget_printk(KERN_ERR, starget,
27385 + MYIOC_s_FMT "mpt_config failed\n", ioc->name);
27386 goto out_free;
27387 }
27388 err = 0;
27389 @@ -963,14 +928,15 @@ static void mptspi_write_dt(struct scsi_
27390 if (spi_period(starget) == -1)
27391 mptspi_read_parameters(starget);
27392
27393 - if (!dt && spi_period(starget) < 10)
27394 - spi_period(starget) = 10;
27395 + if (!dt) {
27396 + spi_qas(starget) = 0;
27397 + spi_iu(starget) = 0;
27398 + }
27399
27400 spi_dt(starget) = dt;
27401
27402 nego = mptspi_getRP(starget);
27403
27404 -
27405 pg1.RequestedParameters = cpu_to_le32(nego);
27406 pg1.Reserved = 0;
27407 pg1.Configuration = 0;
27408 @@ -986,9 +952,6 @@ static void mptspi_write_iu(struct scsi_
27409 if (spi_period(starget) == -1)
27410 mptspi_read_parameters(starget);
27411
27412 - if (!iu && spi_period(starget) < 9)
27413 - spi_period(starget) = 9;
27414 -
27415 spi_iu(starget) = iu;
27416
27417 nego = mptspi_getRP(starget);
27418 @@ -1030,9 +993,11 @@ static void mptspi_write_qas(struct scsi
27419 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
27420 VirtTarget *vtarget = starget->hostdata;
27421 u32 nego;
27422 + MPT_ADAPTER *ioc = hd->ioc;
27423
27424 - if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
27425 - hd->ioc->spi_data.noQas)
27426 + if (!mpt_qas ||
27427 + (vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
27428 + ioc->spi_data.noQas)
27429 spi_qas(starget) = 0;
27430 else
27431 spi_qas(starget) = qas;
27432 @@ -1053,8 +1018,8 @@ static void mptspi_write_width(struct sc
27433
27434 if (!width) {
27435 spi_dt(starget) = 0;
27436 - if (spi_period(starget) < 10)
27437 - spi_period(starget) = 10;
27438 + spi_qas(starget) = 0;
27439 + spi_iu(starget) = 0;
27440 }
27441
27442 spi_width(starget) = width;
27443 @@ -1074,7 +1039,8 @@ struct work_queue_wrapper {
27444 int disk;
27445 };
27446
27447 -static void mpt_work_wrapper(struct work_struct *work)
27448 +static void
27449 +mpt_work_wrapper(struct work_struct *work)
27450 {
27451 struct work_queue_wrapper *wqw =
27452 container_of(work, struct work_queue_wrapper, work);
27453 @@ -1105,12 +1071,12 @@ static void mpt_work_wrapper(struct work
27454 if(vtarget->id != disk)
27455 continue;
27456
27457 - starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
27458 - "Integrated RAID requests DV of new device\n", ioc->name);
27459 + starget_printk(KERN_INFO, vtarget->starget,
27460 + MYIOC_s_FMT "Integrated RAID requests DV of new device\n", ioc->name);
27461 mptspi_dv_device(hd, sdev);
27462 }
27463 - shost_printk(KERN_INFO, shost, MYIOC_s_FMT
27464 - "Integrated RAID detects new device %d\n", ioc->name, disk);
27465 + shost_printk(KERN_INFO, shost,
27466 + MYIOC_s_FMT "Integrated RAID detects new device %d\n", ioc->name, disk);
27467 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
27468 }
27469
27470 @@ -1121,8 +1087,8 @@ static void mpt_dv_raid(struct _MPT_SCSI
27471 MPT_ADAPTER *ioc = hd->ioc;
27472
27473 if (!wqw) {
27474 - shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
27475 - "Failed to act on RAID event for physical disk %d\n",
27476 + shost_printk(KERN_ERR, ioc->sh,
27477 + MYIOC_s_FMT "Failed to act on RAID event for physical disk %d\n",
27478 ioc->name, disk);
27479 return;
27480 }
27481 @@ -1213,9 +1179,9 @@ static struct pci_device_id mptspi_pci_t
27482 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
27483
27484
27485 -/*
27486 +/**
27487 * renegotiate for a given target
27488 - */
27489 + **/
27490 static void
27491 mptspi_dv_renegotiate_work(struct work_struct *work)
27492 {
27493 @@ -1261,32 +1227,33 @@ mptspi_dv_renegotiate(struct _MPT_SCSI_H
27494 schedule_work(&wqw->work);
27495 }
27496
27497 -/*
27498 +/**
27499 * spi module reset handler
27500 - */
27501 + **/
27502 static int
27503 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
27504 {
27505 + struct _MPT_SCSI_HOST *hd = NULL;
27506 int rc;
27507
27508 rc = mptscsih_ioc_reset(ioc, reset_phase);
27509 + if ((ioc->bus_type != SPI) || (!rc))
27510 + goto out;
27511
27512 - /* only try to do a renegotiation if we're properly set up
27513 - * if we get an ioc fault on bringup, ioc->sh will be NULL */
27514 - if (reset_phase == MPT_IOC_POST_RESET &&
27515 - ioc->sh) {
27516 - struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
27517 + hd = shost_priv(ioc->sh);
27518 + if (!hd->ioc)
27519 + goto out;
27520
27521 + if (ioc->active && reset_phase == MPT_IOC_POST_RESET)
27522 mptspi_dv_renegotiate(hd);
27523 - }
27524 -
27525 + out:
27526 return rc;
27527 }
27528
27529 #ifdef CONFIG_PM
27530 -/*
27531 +/**
27532 * spi module resume handler
27533 - */
27534 + **/
27535 static int
27536 mptspi_resume(struct pci_dev *pdev)
27537 {
27538 @@ -1303,13 +1270,13 @@ mptspi_resume(struct pci_dev *pdev)
27539
27540 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27541 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27542 -/*
27543 +/**
27544 * mptspi_probe - Installs scsi devices per bus.
27545 * @pdev: Pointer to pci_dev structure
27546 *
27547 * Returns 0 for success, non-zero for failure.
27548 *
27549 - */
27550 + **/
27551 static int
27552 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
27553 {
27554 @@ -1423,19 +1390,18 @@ mptspi_probe(struct pci_dev *pdev, const
27555 * A slightly different algorithm is required for
27556 * 64bit SGEs.
27557 */
27558 - scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
27559 - if (sizeof(dma_addr_t) == sizeof(u64)) {
27560 + scale = ioc->req_sz/ioc->SGE_size;
27561 + if (ioc->sg_addr_size == sizeof(u64)) {
27562 numSGE = (scale - 1) *
27563 (ioc->facts.MaxChainDepth-1) + scale +
27564 - (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
27565 - sizeof(u32));
27566 + (ioc->req_sz - 60) / ioc->SGE_size;
27567 } else {
27568 numSGE = 1 + (scale - 1) *
27569 (ioc->facts.MaxChainDepth-1) + scale +
27570 - (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
27571 - sizeof(u32));
27572 + (ioc->req_sz - 64) / ioc->SGE_size;
27573 }
27574
27575 +
27576 if (numSGE < sh->sg_tablesize) {
27577 /* Reset this value */
27578 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
27579 @@ -1444,11 +1410,11 @@ mptspi_probe(struct pci_dev *pdev, const
27580 sh->sg_tablesize = numSGE;
27581 }
27582
27583 - spin_unlock_irqrestore(&ioc->FreeQlock, flags);
27584 -
27585 hd = shost_priv(sh);
27586 hd->ioc = ioc;
27587
27588 + spin_unlock_irqrestore(&ioc->FreeQlock, flags);
27589 +
27590 /* SCSI needs scsi_cmnd lookup table!
27591 * (with size equal to req_depth*PtrSz!)
27592 */
27593 @@ -1462,39 +1428,12 @@ mptspi_probe(struct pci_dev *pdev, const
27594 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
27595 ioc->name, ioc->ScsiLookup));
27596
27597 - /* Clear the TM flags
27598 - */
27599 - hd->tmPending = 0;
27600 - hd->tmState = TM_STATE_NONE;
27601 - hd->resetPending = 0;
27602 - hd->abortSCpnt = NULL;
27603 -
27604 - /* Clear the pointer used to store
27605 - * single-threaded commands, i.e., those
27606 - * issued during a bus scan, dv and
27607 - * configuration pages.
27608 - */
27609 - hd->cmdPtr = NULL;
27610 -
27611 - /* Initialize this SCSI Hosts' timers
27612 - * To use, set the timer expires field
27613 - * and add_timer
27614 - */
27615 - init_timer(&hd->timer);
27616 - hd->timer.data = (unsigned long) hd;
27617 - hd->timer.function = mptscsih_timer_expired;
27618 -
27619 + ioc->sdev_queue_depth = MPT_SCSI_CMD_PER_DEV_HIGH;
27620 ioc->spi_data.Saf_Te = mpt_saf_te;
27621 -
27622 - hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
27623 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
27624 - "saf_te %x\n",
27625 - ioc->name,
27626 - mpt_saf_te));
27627 - ioc->spi_data.noQas = 0;
27628 + "saf_te %x\n", ioc->name, mpt_saf_te));
27629 + ioc->spi_data.noQas = mpt_qas ? 0 : MPT_TARGET_NO_NEGO_QAS;
27630
27631 - init_waitqueue_head(&hd->scandv_waitq);
27632 - hd->scandv_wait_done = 0;
27633 hd->last_queue_full = 0;
27634 hd->spi_pending = 0;
27635
27636 @@ -1514,7 +1453,7 @@ mptspi_probe(struct pci_dev *pdev, const
27637 * issue internal bus reset
27638 */
27639 if (ioc->spi_data.bus_reset)
27640 - mptscsih_TMHandler(hd,
27641 + mptscsih_IssueTaskMgmt(hd,
27642 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
27643 0, 0, 0, 0, 5);
27644
27645 @@ -1544,7 +1483,7 @@ static struct pci_driver mptspi_driver =
27646 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
27647 *
27648 * Returns 0 for success, non-zero for failure.
27649 - */
27650 + **/
27651 static int __init
27652 mptspi_init(void)
27653 {
27654 @@ -1574,7 +1513,8 @@ mptspi_init(void)
27655 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27656 /**
27657 * mptspi_exit - Unregisters MPT adapter(s)
27658 - */
27659 + *
27660 + **/
27661 static void __exit
27662 mptspi_exit(void)
27663 {
27664 @@ -1582,7 +1522,6 @@ mptspi_exit(void)
27665
27666 mpt_reset_deregister(mptspiDoneCtx);
27667 mpt_event_deregister(mptspiDoneCtx);
27668 -
27669 mpt_deregister(mptspiInternalCtx);
27670 mpt_deregister(mptspiTaskCtx);
27671 mpt_deregister(mptspiDoneCtx);
27672 --- /dev/null
27673 +++ b/drivers/message/fusion/rejected_ioctls/diag_buffer.c
27674 @@ -0,0 +1,667 @@
27675 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27676 +/* REGISTER DIAG BUFFER Routine.
27677 + *
27678 + * Outputs: None.
27679 + * Return: 0 if successful
27680 + * -EFAULT if data unavailable
27681 + * -EBUSY if previous command timout and IOC reset is not complete.
27682 + * -ENODEV if no such device/adapter
27683 + * -ETIME if timer expires
27684 + * -ENOMEM if memory allocation error
27685 + */
27686 +static int
27687 +mptctl_register_diag_buffer (unsigned long arg)
27688 +{
27689 + mpt_diag_register_t __user *uarg = (void __user *) arg;
27690 + mpt_diag_register_t karg;
27691 + MPT_ADAPTER *ioc;
27692 + int iocnum, rc, ii;
27693 + void * request_data;
27694 + dma_addr_t request_data_dma;
27695 + u32 request_data_sz;
27696 + MPT_FRAME_HDR *mf;
27697 + DiagBufferPostRequest_t *diag_buffer_post_request;
27698 + DiagBufferPostReply_t *diag_buffer_post_reply;
27699 + u32 tmp;
27700 + u8 buffer_type;
27701 + unsigned long timeleft;
27702 +
27703 + rc = 0;
27704 + if (copy_from_user(&karg, uarg, sizeof(mpt_diag_register_t))) {
27705 + printk(KERN_ERR "%s@%d::%s - "
27706 + "Unable to read in mpt_diag_register_t struct @ %p\n",
27707 + __FILE__, __LINE__, __FUNCTION__, uarg);
27708 + return -EFAULT;
27709 + }
27710 +
27711 + if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
27712 + (ioc == NULL)) {
27713 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
27714 + __FILE__, __FUNCTION__, __LINE__, iocnum);
27715 + return -ENODEV;
27716 + }
27717 +
27718 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
27719 + __FUNCTION__));
27720 + buffer_type = karg.data.BufferType;
27721 + if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
27722 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
27723 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
27724 + return -ENODEV;
27725 + }
27726 +
27727 + if (ioc->DiagBuffer_Status[buffer_type] &
27728 + MPT_DIAG_BUFFER_IS_REGISTERED) {
27729 + printk(MYIOC_s_DEBUG_FMT "%s: already has a Registered "
27730 + "buffer for buffer_type=%x\n", ioc->name, __FUNCTION__,
27731 + buffer_type);
27732 + return -EFAULT;
27733 + }
27734 +
27735 + /* Get a free request frame and save the message context.
27736 + */
27737 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
27738 + return -EAGAIN;
27739 +
27740 + request_data = ioc->DiagBuffer[buffer_type];
27741 + request_data_sz = karg.data.RequestedBufferSize;
27742 +
27743 + if (request_data) {
27744 + request_data_dma = ioc->DiagBuffer_dma[buffer_type];
27745 + if (request_data_sz != ioc->DiagBuffer_sz[buffer_type]) {
27746 + pci_free_consistent(ioc->pcidev,
27747 + ioc->DiagBuffer_sz[buffer_type],
27748 + request_data, request_data_dma);
27749 + request_data = NULL;
27750 + }
27751 + }
27752 +
27753 + if (request_data == NULL) {
27754 + ioc->DiagBuffer_sz[buffer_type] = 0;
27755 + ioc->DiagBuffer_dma[buffer_type] = 0;
27756 + ioc->DataSize[buffer_type] = 0;
27757 + request_data = pci_alloc_consistent(
27758 + ioc->pcidev, request_data_sz, &request_data_dma);
27759 + if (request_data == NULL) {
27760 + printk(MYIOC_s_DEBUG_FMT "%s: pci_alloc_consistent"
27761 + " FAILED, (request_sz=%d)\n", ioc->name,
27762 + __FUNCTION__, request_data_sz);
27763 + mpt_free_msg_frame(ioc, mf);
27764 + return -EAGAIN;
27765 + }
27766 + ioc->DiagBuffer[buffer_type] = request_data;
27767 + ioc->DiagBuffer_sz[buffer_type] = request_data_sz;
27768 + ioc->DiagBuffer_dma[buffer_type] = request_data_dma;
27769 + }
27770 +
27771 + ioc->DiagBuffer_Status[buffer_type] = 0;
27772 + diag_buffer_post_request = (DiagBufferPostRequest_t *)mf;
27773 + diag_buffer_post_request->Function = MPI_FUNCTION_DIAG_BUFFER_POST;
27774 + diag_buffer_post_request->ChainOffset = 0;
27775 + diag_buffer_post_request->BufferType = karg.data.BufferType;
27776 + diag_buffer_post_request->TraceLevel = ioc->TraceLevel[buffer_type] =
27777 + karg.data.TraceLevel;
27778 + diag_buffer_post_request->MsgFlags = 0;
27779 + diag_buffer_post_request->Reserved1 = 0;
27780 + diag_buffer_post_request->Reserved2 = 0;
27781 + diag_buffer_post_request->Reserved3 = 0;
27782 + diag_buffer_post_request->BufferAddress.High = 0;
27783 + if (buffer_type == MPI_DIAG_BUF_TYPE_EXTENDED)
27784 + ioc->ExtendedType[buffer_type] = karg.data.ExtendedType;
27785 + else
27786 + ioc->ExtendedType[buffer_type] = 0;
27787 + diag_buffer_post_request->ExtendedType =
27788 + cpu_to_le32(ioc->ExtendedType[buffer_type]);
27789 + ioc->UniqueId[buffer_type] = karg.data.UniqueId;
27790 + diag_buffer_post_request->BufferLength = cpu_to_le32(request_data_sz);
27791 + for (ii = 0; ii < 4; ii++) {
27792 + ioc->ProductSpecific[buffer_type][ii] =
27793 + karg.data.ProductSpecific[ii];
27794 + diag_buffer_post_request->ProductSpecific[ii] =
27795 + cpu_to_le32(ioc->ProductSpecific[buffer_type][ii]);
27796 + }
27797 +
27798 + tmp = request_data_dma & 0xFFFFFFFF;
27799 + diag_buffer_post_request->BufferAddress.Low = cpu_to_le32(tmp);
27800 + if (ioc->sg_addr_size == sizeof(u64)) {
27801 + tmp = (u32)((u64)request_data_dma >> 32);
27802 + diag_buffer_post_request->BufferAddress.High = cpu_to_le32(tmp);
27803 + }
27804 +
27805 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
27806 + diag_buffer_post_request->MsgContext);
27807 + INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
27808 + mpt_put_msg_frame(mptctl_id, ioc, mf);
27809 + timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
27810 + MPT_IOCTL_DEFAULT_TIMEOUT*HZ);
27811 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
27812 + rc = -ETIME;
27813 + printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name,
27814 + __FUNCTION__);
27815 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
27816 + mpt_free_msg_frame(ioc, mf);
27817 + goto out;
27818 + }
27819 + if (!timeleft)
27820 + mptctl_timeout_expired(ioc, mf);
27821 + goto out;
27822 + }
27823 +
27824 + /* process the completed Reply Message Frame */
27825 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
27826 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: status=%x\n",
27827 + ioc->name, __FUNCTION__, ioc->ioctl_cmds.status));
27828 + rc = -EFAULT;
27829 + goto out;
27830 + }
27831 +
27832 + diag_buffer_post_reply = (DiagBufferPostReply_t *)ioc->ioctl_cmds.reply;
27833 + if (le16_to_cpu(diag_buffer_post_reply->IOCStatus) ==
27834 + MPI_IOCSTATUS_SUCCESS) {
27835 + if (diag_buffer_post_reply->MsgLength > 5)
27836 + ioc->DataSize[buffer_type] =
27837 + le32_to_cpu(diag_buffer_post_reply->TransferLength);
27838 + ioc->DiagBuffer_Status[buffer_type] |=
27839 + MPT_DIAG_BUFFER_IS_REGISTERED;
27840 + } else {
27841 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: IOCStatus=%x "
27842 + "IOCLogInfo=%x\n", ioc->name, __FUNCTION__,
27843 + diag_buffer_post_reply->IOCStatus,
27844 + diag_buffer_post_reply->IOCLogInfo));
27845 + rc = -EFAULT;
27846 + }
27847 +
27848 + out:
27849 +
27850 + CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
27851 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
27852 + if (rc)
27853 + pci_free_consistent(ioc->pcidev, request_data_sz,
27854 + request_data, request_data_dma);
27855 + return rc;
27856 +}
27857 +
27858 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27859 +/* RELEASE DIAG BUFFER Routine.
27860 + *
27861 + * Outputs: None.
27862 + * Return: 0 if successful
27863 + * -EFAULT if data unavailable
27864 + * -EBUSY if previous command timout and IOC reset is not complete.
27865 + * -ENODEV if no such device/adapter
27866 + * -ETIME if timer expires
27867 + * -ENOMEM if memory allocation error
27868 + */
27869 +static int
27870 +mptctl_release_diag_buffer (unsigned long arg)
27871 +{
27872 + mpt_diag_release_t __user *uarg = (void __user *) arg;
27873 + mpt_diag_release_t karg;
27874 + MPT_ADAPTER *ioc;
27875 + void * request_data;
27876 + int iocnum, rc;
27877 + MPT_FRAME_HDR *mf;
27878 + DiagReleaseRequest_t *diag_release;
27879 + DiagReleaseReply_t *diag_release_reply;
27880 + u8 buffer_type;
27881 + unsigned long timeleft;
27882 +
27883 + rc = 0;
27884 + if (copy_from_user(&karg, uarg, sizeof(mpt_diag_release_t))) {
27885 + printk(KERN_ERR "%s@%d::%s - "
27886 + "Unable to read in mpt_diag_release_t struct @ %p\n",
27887 + __FILE__, __LINE__, __FUNCTION__, uarg);
27888 + return -EFAULT;
27889 + }
27890 +
27891 + if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
27892 + (ioc == NULL)) {
27893 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
27894 + __FILE__, __FUNCTION__, __LINE__, iocnum);
27895 + return -ENODEV;
27896 + }
27897 +
27898 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
27899 + __FUNCTION__));
27900 + buffer_type = karg.data.UniqueId & 0x000000ff;
27901 + if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
27902 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
27903 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
27904 + return -ENODEV;
27905 + }
27906 +
27907 + if ((ioc->DiagBuffer_Status[buffer_type] &
27908 + MPT_DIAG_BUFFER_IS_REGISTERED) == 0 ) {
27909 + printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x is not "
27910 + "registered\n", ioc->name, __FUNCTION__, buffer_type);
27911 + return -EFAULT;
27912 + }
27913 +
27914 + if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
27915 + printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not registered\n",
27916 + ioc->name, __FUNCTION__, karg.data.UniqueId);
27917 + return -EFAULT;
27918 + }
27919 +
27920 + if (ioc->DiagBuffer_Status[buffer_type] & MPT_DIAG_BUFFER_IS_RELEASED) {
27921 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x "
27922 + "is already released\n", ioc->name, __FUNCTION__,
27923 + buffer_type));
27924 + return rc;
27925 + }
27926 +
27927 + request_data = ioc->DiagBuffer[buffer_type];
27928 +
27929 + if (request_data == NULL) {
27930 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
27931 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
27932 + return -ENODEV;
27933 + }
27934 +
27935 + /* Get a free request frame and save the message context.
27936 + */
27937 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
27938 + return -EAGAIN;
27939 +
27940 + diag_release = (DiagReleaseRequest_t *)mf;
27941 + diag_release->Function = MPI_FUNCTION_DIAG_RELEASE;
27942 + diag_release->BufferType = buffer_type;
27943 + diag_release->ChainOffset = 0;
27944 + diag_release->Reserved1 = 0;
27945 + diag_release->Reserved2 = 0;
27946 + diag_release->Reserved3 = 0;
27947 + diag_release->MsgFlags = 0;
27948 +
27949 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
27950 + diag_release->MsgContext);
27951 + INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
27952 + mpt_put_msg_frame(mptctl_id, ioc, mf);
27953 + timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
27954 + MPT_IOCTL_DEFAULT_TIMEOUT*HZ);
27955 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
27956 + rc = -ETIME;
27957 + printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name,
27958 + __FUNCTION__);
27959 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
27960 + mpt_free_msg_frame(ioc, mf);
27961 + goto out;
27962 + }
27963 + if (!timeleft)
27964 + mptctl_timeout_expired(ioc, mf);
27965 + goto out;
27966 + }
27967 +
27968 + /* process the completed Reply Message Frame */
27969 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
27970 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: status=%x\n",
27971 + ioc->name, __FUNCTION__, ioc->ioctl_cmds.status));
27972 + rc = -EFAULT;
27973 + goto out;
27974 + }
27975 +
27976 + diag_release_reply = (DiagReleaseReply_t *)ioc->ioctl_cmds.reply;
27977 + if (le16_to_cpu(diag_release_reply->IOCStatus) !=
27978 + MPI_IOCSTATUS_SUCCESS) {
27979 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: IOCStatus=%x "
27980 + "IOCLogInfo=%x\n",
27981 + ioc->name, __FUNCTION__, diag_release_reply->IOCStatus,
27982 + diag_release_reply->IOCLogInfo));
27983 + rc = -EFAULT;
27984 + } else
27985 + ioc->DiagBuffer_Status[buffer_type] |=
27986 + MPT_DIAG_BUFFER_IS_RELEASED;
27987 +
27988 + out:
27989 +
27990 + CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
27991 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
27992 + return rc;
27993 +}
27994 +
27995 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
27996 +/* UNREGISTER DIAG BUFFER Routine.
27997 + *
27998 + * Outputs: None.
27999 + * Return: 0 if successful
28000 + * -EFAULT if data unavailable
28001 + * -EBUSY if previous command timout and IOC reset is not complete.
28002 + * -ENODEV if no such device/adapter
28003 + * -ETIME if timer expires
28004 + * -ENOMEM if memory allocation error
28005 + */
28006 +static int
28007 +mptctl_unregister_diag_buffer (unsigned long arg)
28008 +{
28009 + mpt_diag_unregister_t __user *uarg = (void __user *) arg;
28010 + mpt_diag_unregister_t karg;
28011 + MPT_ADAPTER *ioc;
28012 + int iocnum;
28013 + void * request_data;
28014 + dma_addr_t request_data_dma;
28015 + u32 request_data_sz;
28016 + u8 buffer_type;
28017 +
28018 + if (copy_from_user(&karg, uarg, sizeof(mpt_diag_unregister_t))) {
28019 + printk(KERN_ERR "%s@%d::%s - "
28020 + "Unable to read in mpt_diag_unregister_t struct @ %p\n",
28021 + __FILE__, __LINE__, __FUNCTION__, uarg);
28022 + return -EFAULT;
28023 + }
28024 +
28025 + if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
28026 + (ioc == NULL)) {
28027 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
28028 + __FILE__, __FUNCTION__, __LINE__, iocnum);
28029 + return -ENODEV;
28030 + }
28031 +
28032 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
28033 + __FUNCTION__));
28034 + buffer_type = karg.data.UniqueId & 0x000000ff;
28035 + if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
28036 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
28037 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
28038 + return -ENODEV;
28039 + }
28040 +
28041 + if ((ioc->DiagBuffer_Status[buffer_type] &
28042 + MPT_DIAG_BUFFER_IS_REGISTERED) == 0) {
28043 + printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x is not "
28044 + "registered\n", ioc->name, __FUNCTION__, buffer_type);
28045 + return -EFAULT;
28046 + }
28047 + if ((ioc->DiagBuffer_Status[buffer_type] &
28048 + MPT_DIAG_BUFFER_IS_RELEASED) == 0) {
28049 + printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x has not been "
28050 + "released\n", ioc->name, __FUNCTION__, buffer_type);
28051 + return -EFAULT;
28052 + }
28053 +
28054 + if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
28055 + printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not registered\n",
28056 + ioc->name, __FUNCTION__, karg.data.UniqueId);
28057 + return -EFAULT;
28058 + }
28059 +
28060 + request_data = ioc->DiagBuffer[buffer_type];
28061 + if (!request_data) {
28062 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
28063 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
28064 + return -ENODEV;
28065 + }
28066 +
28067 + request_data_sz = ioc->DiagBuffer_sz[buffer_type];
28068 + request_data_dma = ioc->DiagBuffer_dma[buffer_type];
28069 + pci_free_consistent(ioc->pcidev, request_data_sz,
28070 + request_data, request_data_dma);
28071 + ioc->DiagBuffer[buffer_type] = NULL;
28072 + ioc->DiagBuffer_Status[buffer_type] = 0;
28073 + return 0;
28074 +}
28075 +
28076 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
28077 +/* QUERY DIAG BUFFER Routine.
28078 + *
28079 + * Outputs: None.
28080 + * Return: 0 if successful
28081 + * -EFAULT if data unavailable
28082 + * -EBUSY if previous command timout and IOC reset is not complete.
28083 + * -ENODEV if no such device/adapter
28084 + * -ETIME if timer expires
28085 + * -ENOMEM if memory allocation error
28086 + */
28087 +static int
28088 +mptctl_query_diag_buffer (unsigned long arg)
28089 +{
28090 + mpt_diag_query_t __user *uarg = (void __user *)arg;
28091 + mpt_diag_query_t karg;
28092 + MPT_ADAPTER *ioc;
28093 + void * request_data;
28094 + int iocnum, ii, rc;
28095 + u8 buffer_type;
28096 +
28097 + rc = -EFAULT;
28098 + if (copy_from_user(&karg, uarg, sizeof(mpt_diag_query_t))) {
28099 + printk(KERN_ERR "%s@%d::%s - "
28100 + "Unable to read in mpt_diag_query_t struct @ %p\n",
28101 + __FILE__, __LINE__, __FUNCTION__, uarg);
28102 + return -EFAULT;
28103 + }
28104 +
28105 + karg.data.Flags = 0;
28106 + if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
28107 + (ioc == NULL)) {
28108 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
28109 + __FILE__, __FUNCTION__, __LINE__, iocnum);
28110 + goto out;
28111 + }
28112 +
28113 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
28114 + __FUNCTION__));
28115 + buffer_type = karg.data.BufferType;
28116 + if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
28117 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability for "
28118 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
28119 + goto out;
28120 + }
28121 +
28122 + if ((ioc->DiagBuffer_Status[buffer_type] &
28123 + MPT_DIAG_BUFFER_IS_REGISTERED) == 0) {
28124 + printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x is not "
28125 + "registered\n", ioc->name, __FUNCTION__, buffer_type);
28126 + goto out;
28127 + }
28128 +
28129 + if (karg.data.UniqueId & 0xffffff00) {
28130 + if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
28131 + printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not "
28132 + "registered\n", ioc->name, __FUNCTION__,
28133 + karg.data.UniqueId);
28134 + goto out;
28135 + }
28136 + }
28137 +
28138 + request_data = ioc->DiagBuffer[buffer_type];
28139 + if (!request_data) {
28140 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
28141 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
28142 + goto out;
28143 + }
28144 +
28145 + rc = 0;
28146 + if (buffer_type == MPI_DIAG_BUF_TYPE_EXTENDED) {
28147 + if (karg.data.ExtendedType != ioc->ExtendedType[buffer_type])
28148 + goto out;
28149 + } else
28150 + karg.data.ExtendedType = 0;
28151 +
28152 + if (ioc->DiagBuffer_Status[buffer_type] & MPT_DIAG_BUFFER_IS_RELEASED)
28153 + karg.data.Flags = 3;
28154 + else
28155 + karg.data.Flags = 7;
28156 + karg.data.TraceLevel = ioc->TraceLevel[buffer_type];
28157 + for (ii = 0; ii < 4; ii++)
28158 + karg.data.ProductSpecific[ii] =
28159 + ioc->ProductSpecific[buffer_type][ii];
28160 + karg.data.DataSize = ioc->DiagBuffer_sz[buffer_type];
28161 + karg.data.DriverAddedBufferSize = 0;
28162 + karg.data.UniqueId = ioc->UniqueId[buffer_type];
28163 +
28164 + out:
28165 + if (copy_to_user(uarg, &karg, sizeof(mpt_diag_query_t))) {
28166 + printk(MYIOC_s_ERR_FMT "%s Unable to write mpt_diag_query_t "
28167 + "data @ %p\n", ioc->name, __FUNCTION__, uarg);
28168 + return -EFAULT;
28169 + }
28170 + return rc;
28171 +}
28172 +
28173 +/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
28174 +/* READ DIAG BUFFER Routine.
28175 + *
28176 + * Outputs: None.
28177 + * Return: 0 if successful
28178 + * -EFAULT if data unavailable
28179 + * -EBUSY if previous command timout and IOC reset is not complete.
28180 + * -ENODEV if no such device/adapter
28181 + * -ETIME if timer expires
28182 + * -ENOMEM if memory allocation error
28183 + */
28184 +static int
28185 +mptctl_read_diag_buffer (unsigned long arg)
28186 +{
28187 + mpt_diag_read_buffer_t __user *uarg = (void __user *) arg;
28188 + mpt_diag_read_buffer_t karg;
28189 + MPT_ADAPTER *ioc;
28190 + void *request_data, *diagData;
28191 + dma_addr_t request_data_dma;
28192 + DiagBufferPostRequest_t *diag_buffer_post_request;
28193 + DiagBufferPostReply_t *diag_buffer_post_reply;
28194 + MPT_FRAME_HDR *mf;
28195 + int iocnum, rc, ii;
28196 + u8 buffer_type;
28197 + u32 tmp;
28198 + unsigned long timeleft;
28199 +
28200 + rc = 0;
28201 + if (copy_from_user(&karg, uarg, sizeof(mpt_diag_read_buffer_t))) {
28202 + printk(KERN_ERR "%s@%d::%s - "
28203 + "Unable to read in mpt_diag_read_buffer_t struct @ %p\n",
28204 + __FILE__, __LINE__, __FUNCTION__, uarg);
28205 + return -EFAULT;
28206 + }
28207 +
28208 + if (((iocnum = mpt_verify_adapter(karg.hdr.iocnum, &ioc)) < 0) ||
28209 + (ioc == NULL)) {
28210 + printk(KERN_ERR "%s::%s() @%d - ioc%d not found!\n",
28211 + __FILE__, __FUNCTION__, __LINE__, iocnum);
28212 + return -ENODEV;
28213 + }
28214 +
28215 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s enter.\n", ioc->name,
28216 + __FUNCTION__));
28217 + buffer_type = karg.data.UniqueId & 0x000000ff;
28218 + if (!(ioc->facts.IOCCapabilities & MPT_DIAG_CAPABILITY(buffer_type))) {
28219 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have Capability "
28220 + "for buffer_type=%x\n", ioc->name, __FUNCTION__,
28221 + buffer_type);
28222 + return -EFAULT;
28223 + }
28224 +
28225 + if (karg.data.UniqueId != ioc->UniqueId[buffer_type]) {
28226 + printk(MYIOC_s_DEBUG_FMT "%s: unique_id=%x is not registered\n",
28227 + ioc->name, __FUNCTION__, karg.data.UniqueId);
28228 + return -EFAULT;
28229 + }
28230 +
28231 + request_data = ioc->DiagBuffer[buffer_type];
28232 + if (!request_data) {
28233 + printk(MYIOC_s_DEBUG_FMT "%s: doesn't have buffer for "
28234 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type);
28235 + return -EFAULT;
28236 + }
28237 +
28238 + diagData = (void *)(request_data + karg.data.StartingOffset);
28239 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: diagData=%p "
28240 + "request_data=%p StartingOffset=%x\n", ioc->name, __FUNCTION__,
28241 + diagData, request_data, karg.data.StartingOffset));
28242 +
28243 + if (copy_to_user((void __user *)&uarg->data.DiagnosticData[0],
28244 + diagData, karg.data.BytesToRead)) {
28245 + printk(MYIOC_s_ERR_FMT "%s: Unable to write "
28246 + "mpt_diag_read_buffer_t data @ %p\n", ioc->name,
28247 + __FUNCTION__, diagData);
28248 + return -EFAULT;
28249 + }
28250 +
28251 + if ((karg.data.Flags & MPI_FW_DIAG_FLAG_REREGISTER) == 0)
28252 + goto out;
28253 +
28254 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Reregister "
28255 + "buffer_type=%x\n", ioc->name, __FUNCTION__, buffer_type));
28256 + if ((ioc->DiagBuffer_Status[buffer_type] &
28257 + MPT_DIAG_BUFFER_IS_RELEASED) == 0) {
28258 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: buffer_type=%x "
28259 + "is still registered\n", ioc->name, __FUNCTION__,
28260 + buffer_type));
28261 + return rc;
28262 + }
28263 + /* Get a free request frame and save the message context.
28264 + */
28265 + if ((mf = mpt_get_msg_frame(mptctl_id, ioc)) == NULL)
28266 + return -EAGAIN;
28267 +
28268 + diag_buffer_post_request = (DiagBufferPostRequest_t *)mf;
28269 + diag_buffer_post_request->Function = MPI_FUNCTION_DIAG_BUFFER_POST;
28270 + diag_buffer_post_request->ChainOffset = 0;
28271 + diag_buffer_post_request->BufferType = buffer_type;
28272 + diag_buffer_post_request->TraceLevel =
28273 + ioc->TraceLevel[buffer_type];
28274 + diag_buffer_post_request->MsgFlags = 0;
28275 + diag_buffer_post_request->Reserved1 = 0;
28276 + diag_buffer_post_request->Reserved2 = 0;
28277 + diag_buffer_post_request->Reserved3 = 0;
28278 + diag_buffer_post_request->BufferAddress.High = 0;
28279 + if ( buffer_type == MPI_DIAG_BUF_TYPE_EXTENDED )
28280 + diag_buffer_post_request->ExtendedType =
28281 + cpu_to_le32(ioc->ExtendedType[buffer_type]);
28282 + diag_buffer_post_request->BufferLength =
28283 + cpu_to_le32(ioc->DiagBuffer_sz[buffer_type]);
28284 + for (ii = 0; ii < 4; ii++)
28285 + diag_buffer_post_request->ProductSpecific[ii] =
28286 + cpu_to_le32(ioc->ProductSpecific[buffer_type][ii]);
28287 + request_data_dma = ioc->DiagBuffer_dma[buffer_type];
28288 + tmp = request_data_dma & 0xFFFFFFFF;
28289 + diag_buffer_post_request->BufferAddress.Low = cpu_to_le32(tmp);
28290 + if (ioc->sg_addr_size == sizeof(u64)) {
28291 + tmp = (u32)((u64)request_data_dma >> 32);
28292 + diag_buffer_post_request->BufferAddress.High = cpu_to_le32(tmp);
28293 + }
28294 +
28295 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context,
28296 + diag_buffer_post_request->MsgContext);
28297 + INITIALIZE_MGMT_STATUS(ioc->ioctl_cmds.status)
28298 + mpt_put_msg_frame(mptctl_id, ioc, mf);
28299 + timeleft = wait_for_completion_timeout(&ioc->ioctl_cmds.done,
28300 + MPT_IOCTL_DEFAULT_TIMEOUT*HZ);
28301 + if (!(ioc->ioctl_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
28302 + rc = -ETIME;
28303 + printk(MYIOC_s_WARN_FMT "%s: failed\n", ioc->name,
28304 + __FUNCTION__);
28305 + if (ioc->ioctl_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) {
28306 + mpt_free_msg_frame(ioc, mf);
28307 + goto out;
28308 + }
28309 + if (!timeleft)
28310 + mptctl_timeout_expired(ioc, mf);
28311 + goto out;
28312 + }
28313 +
28314 + /* process the completed Reply Message Frame */
28315 + if ((ioc->ioctl_cmds.status & MPT_MGMT_STATUS_RF_VALID) == 0) {
28316 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: status=%x\n",
28317 + ioc->name, __FUNCTION__, ioc->ioctl_cmds.status));
28318 + rc = -EFAULT;
28319 + }
28320 +
28321 + diag_buffer_post_reply = (DiagBufferPostReply_t *)ioc->ioctl_cmds.reply;
28322 + if (le16_to_cpu(diag_buffer_post_reply->IOCStatus) ==
28323 + MPI_IOCSTATUS_SUCCESS) {
28324 + if (diag_buffer_post_reply->MsgLength > 5)
28325 + ioc->DataSize[buffer_type] =
28326 + le32_to_cpu(diag_buffer_post_reply->TransferLength);
28327 + ioc->DiagBuffer_Status[buffer_type] |=
28328 + MPT_DIAG_BUFFER_IS_REGISTERED;
28329 + } else {
28330 + dctlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: IOCStatus=%x "
28331 + "IOCLogInfo=%x\n", ioc->name, __FUNCTION__,
28332 + diag_buffer_post_reply->IOCStatus,
28333 + diag_buffer_post_reply->IOCLogInfo));
28334 + rc = -EFAULT;
28335 + }
28336 +
28337 + out:
28338 + CLEAR_MGMT_STATUS(ioc->ioctl_cmds.status)
28339 + SET_MGMT_MSG_CONTEXT(ioc->ioctl_cmds.msg_context, 0);
28340 + return rc;
28341 +}
28342 --- /dev/null
28343 +++ b/drivers/message/fusion/rejected_ioctls/diag_buffer.h
28344 @@ -0,0 +1,101 @@
28345 +#define MPTDIAGREGISTER _IOWR(MPT_MAGIC_NUMBER,26,mpt_diag_register_t)
28346 +#define MPTDIAGRELEASE _IOWR(MPT_MAGIC_NUMBER,27,mpt_diag_release_t)
28347 +#define MPTDIAGUNREGISTER _IOWR(MPT_MAGIC_NUMBER,28,mpt_diag_unregister_t)
28348 +#define MPTDIAGQUERY _IOWR(MPT_MAGIC_NUMBER,29,mpt_diag_query_t)
28349 +#define MPTDIAGREADBUFFER _IOWR(MPT_MAGIC_NUMBER,30,mpt_diag_read_buffer_t)
28350 +
28351 +#define MPI_FW_DIAG_IOCTL (0x80646961)
28352 +#define MPI_FW_DIAG_TYPE_REGISTER (0x00000001)
28353 +#define MPI_FW_DIAG_TYPE_UNREGISTER (0x00000002)
28354 +#define MPI_FW_DIAG_TYPE_QUERY (0x00000003)
28355 +#define MPI_FW_DIAG_TYPE_READ_BUFFER (0x00000004)
28356 +#define MPI_FW_DIAG_TYPE_RELEASE (0x00000005)
28357 +
28358 +#define MPI_FW_DIAG_INVALID_UID (0x00000000)
28359 +#define FW_DIAGNOSTIC_BUFFER_COUNT (3)
28360 +#define FW_DIAGNOSTIC_UID_NOT_FOUND (0xFF)
28361 +
28362 +#define MPI_FW_DIAG_ERROR_SUCCESS (0x00000000)
28363 +#define MPI_FW_DIAG_ERROR_FAILURE (0x00000001)
28364 +#define MPI_FW_DIAG_ERROR_INVALID_PARAMETER (0x00000002)
28365 +#define MPI_FW_DIAG_ERROR_POST_FAILED (0x00000010)
28366 +#define MPI_FW_DIAG_ERROR_INVALID_UID (0x00000011)
28367 +
28368 +#define MPI_FW_DIAG_ERROR_RELEASE_FAILED (0x00000012)
28369 +#define MPI_FW_DIAG_ERROR_NO_BUFFER (0x00000013)
28370 +#define MPI_FW_DIAG_ERROR_ALREADY_RELEASED (0x00000014)
28371 +
28372 +#define MPT_DIAG_CAPABILITY(bufftype) (MPI_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER << bufftype)
28373 +
28374 +#define MPT_DIAG_BUFFER_IS_REGISTERED 1
28375 +#define MPT_DIAG_BUFFER_IS_RELEASED 2
28376 +
28377 +typedef struct _MPI_FW_DIAG_REGISTER {
28378 + u8 TraceLevel;
28379 + u8 BufferType;
28380 + u16 Flags;
28381 + u32 ExtendedType;
28382 + u32 ProductSpecific[4];
28383 + u32 RequestedBufferSize;
28384 + u32 UniqueId;
28385 +} MPI_FW_DIAG_REGISTER, *PTR_MPI_FW_DIAG_REGISTER;
28386 +
28387 +typedef struct _mpt_diag_register {
28388 + mpt_ioctl_header hdr;
28389 + MPI_FW_DIAG_REGISTER data;
28390 +} mpt_diag_register_t;
28391 +
28392 +typedef struct _MPI_FW_DIAG_UNREGISTER {
28393 + u32 UniqueId;
28394 +} MPI_FW_DIAG_UNREGISTER, *PTR_MPI_FW_DIAG_UNREGISTER;
28395 +
28396 +typedef struct _mpt_diag_unregister {
28397 + mpt_ioctl_header hdr;
28398 + MPI_FW_DIAG_UNREGISTER data;
28399 +} mpt_diag_unregister_t;
28400 +
28401 +#define MPI_FW_DIAG_FLAG_APP_OWNED (0x0001)
28402 +#define MPI_FW_DIAG_FLAG_BUFFER_VALID (0x0002)
28403 +#define MPI_FW_DIAG_FLAG_FW_BUFFER_ACCESS (0x0004)
28404 +
28405 +typedef struct _MPI_FW_DIAG_QUERY {
28406 + u8 TraceLevel;
28407 + u8 BufferType;
28408 + u16 Flags;
28409 + u32 ExtendedType;
28410 + u32 ProductSpecific[4];
28411 + u32 DataSize;
28412 + u32 DriverAddedBufferSize;
28413 + u32 UniqueId;
28414 +} MPI_FW_DIAG_QUERY, *PTR_MPI_FW_DIAG_QUERY;
28415 +
28416 +typedef struct _mpt_diag_query {
28417 + mpt_ioctl_header hdr;
28418 + MPI_FW_DIAG_QUERY data;
28419 +} mpt_diag_query_t;
28420 +
28421 +typedef struct _MPI_FW_DIAG_RELEASE {
28422 + u32 UniqueId;
28423 +} MPI_FW_DIAG_RELEASE, *PTR_MPI_FW_DIAG_RELEASE;
28424 +
28425 +typedef struct _mpt_diag_release {
28426 + mpt_ioctl_header hdr;
28427 + MPI_FW_DIAG_RELEASE data;
28428 +} mpt_diag_release_t;
28429 +
28430 +#define MPI_FW_DIAG_FLAG_REREGISTER (0x0001)
28431 +
28432 +typedef struct _MPI_FW_DIAG_READ_BUFFER {
28433 + u8 Status;
28434 + u8 Reserved;
28435 + u16 Flags;
28436 + u32 StartingOffset;
28437 + u32 BytesToRead;
28438 + u32 UniqueId;
28439 + u32 DiagnosticData[1];
28440 +} MPI_FW_DIAG_READ_BUFFER, *PTR_MPI_FW_DIAG_READ_BUFFER;
28441 +
28442 +typedef struct _mpt_diag_read_buffer {
28443 + mpt_ioctl_header hdr;
28444 + MPI_FW_DIAG_READ_BUFFER data;
28445 +} mpt_diag_read_buffer_t;
Peter's tree of IPFire 2.x