1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/fs.h>
26#include <linux/init.h>
27#include <linux/types.h>
28#include <linux/errno.h>
29#include <linux/kernel.h>
30#include <linux/ioport.h>
31#include <linux/delay.h>
32#include <linux/pci.h>
33#include <linux/wait.h>
34#include <linux/spinlock.h>
35#include <linux/sched.h>
36#include <linux/interrupt.h>
37#include <linux/blkdev.h>
38#include <linux/firmware.h>
39#include <linux/module.h>
40#include <linux/moduleparam.h>
41#include <linux/hdreg.h>
42#include <linux/io.h>
43#include <linux/slab.h>
44#include <asm/irq.h>
45#include <asm/processor.h>
46#include <linux/libata.h>
47#include <linux/mutex.h>
48#include <linux/ktime.h>
49#include <scsi/scsi.h>
50#include <scsi/scsi_host.h>
51#include <scsi/scsi_device.h>
52#include <scsi/scsi_tcq.h>
53#include <scsi/scsi_eh.h>
54#include <scsi/scsi_cmnd.h>
55#include <scsi/scsicam.h>
56
57#include "pmcraid.h"
58
59
60
61
62static unsigned int pmcraid_debug_log;
63static unsigned int pmcraid_disable_aen;
64static unsigned int pmcraid_log_level = IOASC_LOG_LEVEL_MUST;
65static unsigned int pmcraid_enable_msix;
66
67
68
69
70
71static atomic_t pmcraid_adapter_count = ATOMIC_INIT(0);
72
73
74
75
76
77
78static unsigned int pmcraid_major;
79static struct class *pmcraid_class;
80static DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);
81
82
83
84
85MODULE_AUTHOR("Anil Ravindranath<anil_ravindranath@pmc-sierra.com>");
86MODULE_DESCRIPTION("PMC Sierra MaxRAID Controller Driver");
87MODULE_LICENSE("GPL");
88MODULE_VERSION(PMCRAID_DRIVER_VERSION);
89
90module_param_named(log_level, pmcraid_log_level, uint, (S_IRUGO | S_IWUSR));
91MODULE_PARM_DESC(log_level,
92 "Enables firmware error code logging, default :1 high-severity"
93 " errors, 2: all errors including high-severity errors,"
94 " 0: disables logging");
95
96module_param_named(debug, pmcraid_debug_log, uint, (S_IRUGO | S_IWUSR));
97MODULE_PARM_DESC(debug,
98 "Enable driver verbose message logging. Set 1 to enable."
99 "(default: 0)");
100
101module_param_named(disable_aen, pmcraid_disable_aen, uint, (S_IRUGO | S_IWUSR));
102MODULE_PARM_DESC(disable_aen,
103 "Disable driver aen notifications to apps. Set 1 to disable."
104 "(default: 0)");
105
106
107
108
109static struct pmcraid_chip_details pmcraid_chip_cfg[] = {
110 {
111 .ioastatus = 0x0,
112 .ioarrin = 0x00040,
113 .mailbox = 0x7FC30,
114 .global_intr_mask = 0x00034,
115 .ioa_host_intr = 0x0009C,
116 .ioa_host_intr_clr = 0x000A0,
117 .ioa_host_msix_intr = 0x7FC40,
118 .ioa_host_mask = 0x7FC28,
119 .ioa_host_mask_clr = 0x7FC28,
120 .host_ioa_intr = 0x00020,
121 .host_ioa_intr_clr = 0x00020,
122 .transop_timeout = 300
123 }
124};
125
126
127
128
129static struct pci_device_id pmcraid_pci_table[] = {
130 { PCI_DEVICE(PCI_VENDOR_ID_PMC, PCI_DEVICE_ID_PMC_MAXRAID),
131 0, 0, (kernel_ulong_t)&pmcraid_chip_cfg[0]
132 },
133 {}
134};
135
136MODULE_DEVICE_TABLE(pci, pmcraid_pci_table);
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152static int pmcraid_slave_alloc(struct scsi_device *scsi_dev)
153{
154 struct pmcraid_resource_entry *temp, *res = NULL;
155 struct pmcraid_instance *pinstance;
156 u8 target, bus, lun;
157 unsigned long lock_flags;
158 int rc = -ENXIO;
159 u16 fw_version;
160
161 pinstance = shost_priv(scsi_dev->host);
162
163 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
164
165
166
167
168
169
170 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
171 list_for_each_entry(temp, &pinstance->used_res_q, queue) {
172
173
174 if (RES_IS_VSET(temp->cfg_entry)) {
175 if (fw_version <= PMCRAID_FW_VERSION_1)
176 target = temp->cfg_entry.unique_flags1;
177 else
178 target = le16_to_cpu(temp->cfg_entry.array_id) & 0xFF;
179
180 if (target > PMCRAID_MAX_VSET_TARGETS)
181 continue;
182 bus = PMCRAID_VSET_BUS_ID;
183 lun = 0;
184 } else if (RES_IS_GSCSI(temp->cfg_entry)) {
185 target = RES_TARGET(temp->cfg_entry.resource_address);
186 bus = PMCRAID_PHYS_BUS_ID;
187 lun = RES_LUN(temp->cfg_entry.resource_address);
188 } else {
189 continue;
190 }
191
192 if (bus == scsi_dev->channel &&
193 target == scsi_dev->id &&
194 lun == scsi_dev->lun) {
195 res = temp;
196 break;
197 }
198 }
199
200 if (res) {
201 res->scsi_dev = scsi_dev;
202 scsi_dev->hostdata = res;
203 res->change_detected = 0;
204 atomic_set(&res->read_failures, 0);
205 atomic_set(&res->write_failures, 0);
206 rc = 0;
207 }
208 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
209 return rc;
210}
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
226{
227 struct pmcraid_resource_entry *res = scsi_dev->hostdata;
228
229 if (!res)
230 return 0;
231
232
233 if (RES_IS_GSCSI(res->cfg_entry) &&
234 scsi_dev->type != TYPE_ENCLOSURE)
235 return -ENXIO;
236
237 pmcraid_info("configuring %x:%x:%x:%x\n",
238 scsi_dev->host->unique_id,
239 scsi_dev->channel,
240 scsi_dev->id,
241 (u8)scsi_dev->lun);
242
243 if (RES_IS_GSCSI(res->cfg_entry)) {
244 scsi_dev->allow_restart = 1;
245 } else if (RES_IS_VSET(res->cfg_entry)) {
246 scsi_dev->allow_restart = 1;
247 blk_queue_rq_timeout(scsi_dev->request_queue,
248 PMCRAID_VSET_IO_TIMEOUT);
249 blk_queue_max_hw_sectors(scsi_dev->request_queue,
250 PMCRAID_VSET_MAX_SECTORS);
251 }
252
253
254
255
256 if (!RES_IS_GSCSI(res->cfg_entry) && !RES_IS_VSET(res->cfg_entry))
257 scsi_dev->tagged_supported = 0;
258
259 return 0;
260}
261
262
263
264
265
266
267
268
269
270
271
272
273static void pmcraid_slave_destroy(struct scsi_device *scsi_dev)
274{
275 struct pmcraid_resource_entry *res;
276
277 res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;
278
279 if (res)
280 res->scsi_dev = NULL;
281
282 scsi_dev->hostdata = NULL;
283}
284
285
286
287
288
289
290
291
292
293static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth)
294{
295 if (depth > PMCRAID_MAX_CMD_PER_LUN)
296 depth = PMCRAID_MAX_CMD_PER_LUN;
297 return scsi_change_queue_depth(scsi_dev, depth);
298}
299
300
301
302
303
304
305
306
307
308
309static void pmcraid_init_cmdblk(struct pmcraid_cmd *cmd, int index)
310{
311 struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
312 dma_addr_t dma_addr = cmd->ioa_cb_bus_addr;
313
314 if (index >= 0) {
315
316 u32 ioasa_offset =
317 offsetof(struct pmcraid_control_block, ioasa);
318
319 cmd->index = index;
320 ioarcb->response_handle = cpu_to_le32(index << 2);
321 ioarcb->ioarcb_bus_addr = cpu_to_le64(dma_addr);
322 ioarcb->ioasa_bus_addr = cpu_to_le64(dma_addr + ioasa_offset);
323 ioarcb->ioasa_len = cpu_to_le16(sizeof(struct pmcraid_ioasa));
324 } else {
325
326
327
328 memset(&cmd->ioa_cb->ioarcb.cdb, 0, PMCRAID_MAX_CDB_LEN);
329 ioarcb->hrrq_id = 0;
330 ioarcb->request_flags0 = 0;
331 ioarcb->request_flags1 = 0;
332 ioarcb->cmd_timeout = 0;
333 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~0x1FULL);
334 ioarcb->ioadl_bus_addr = 0;
335 ioarcb->ioadl_length = 0;
336 ioarcb->data_transfer_length = 0;
337 ioarcb->add_cmd_param_length = 0;
338 ioarcb->add_cmd_param_offset = 0;
339 cmd->ioa_cb->ioasa.ioasc = 0;
340 cmd->ioa_cb->ioasa.residual_data_length = 0;
341 cmd->time_left = 0;
342 }
343
344 cmd->cmd_done = NULL;
345 cmd->scsi_cmd = NULL;
346 cmd->release = 0;
347 cmd->completion_req = 0;
348 cmd->sense_buffer = NULL;
349 cmd->sense_buffer_dma = 0;
350 cmd->dma_handle = 0;
351 init_timer(&cmd->timer);
352}
353
354
355
356
357
358
359
360
361
362static void pmcraid_reinit_cmdblk(struct pmcraid_cmd *cmd)
363{
364 pmcraid_init_cmdblk(cmd, -1);
365}
366
367
368
369
370
371
372
373
374static struct pmcraid_cmd *pmcraid_get_free_cmd(
375 struct pmcraid_instance *pinstance
376)
377{
378 struct pmcraid_cmd *cmd = NULL;
379 unsigned long lock_flags;
380
381
382 spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
383
384 if (!list_empty(&pinstance->free_cmd_pool)) {
385 cmd = list_entry(pinstance->free_cmd_pool.next,
386 struct pmcraid_cmd, free_list);
387 list_del(&cmd->free_list);
388 }
389 spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
390
391
392 if (cmd != NULL)
393 pmcraid_reinit_cmdblk(cmd);
394 return cmd;
395}
396
397
398
399
400
401
402
403
404static void pmcraid_return_cmd(struct pmcraid_cmd *cmd)
405{
406 struct pmcraid_instance *pinstance = cmd->drv_inst;
407 unsigned long lock_flags;
408
409 spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
410 list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool);
411 spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
412}
413
414
415
416
417
418
419
420
421
422static u32 pmcraid_read_interrupts(struct pmcraid_instance *pinstance)
423{
424 return (pinstance->interrupt_mode) ?
425 ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) :
426 ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
427}
428
429
430
431
432
433
434
435
436
437
438static void pmcraid_disable_interrupts(
439 struct pmcraid_instance *pinstance,
440 u32 intrs
441)
442{
443 u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
444 u32 nmask = gmask | GLOBAL_INTERRUPT_MASK;
445
446 iowrite32(intrs, pinstance->int_regs.ioa_host_interrupt_clr_reg);
447 iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
448 ioread32(pinstance->int_regs.global_interrupt_mask_reg);
449
450 if (!pinstance->interrupt_mode) {
451 iowrite32(intrs,
452 pinstance->int_regs.ioa_host_interrupt_mask_reg);
453 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
454 }
455}
456
457
458
459
460
461
462
463
464
465
466static void pmcraid_enable_interrupts(
467 struct pmcraid_instance *pinstance,
468 u32 intrs
469)
470{
471 u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
472 u32 nmask = gmask & (~GLOBAL_INTERRUPT_MASK);
473
474 iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
475
476 if (!pinstance->interrupt_mode) {
477 iowrite32(~intrs,
478 pinstance->int_regs.ioa_host_interrupt_mask_reg);
479 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
480 }
481
482 pmcraid_info("enabled interrupts global mask = %x intr_mask = %x\n",
483 ioread32(pinstance->int_regs.global_interrupt_mask_reg),
484 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg));
485}
486
487
488
489
490
491
492
493
494
495static void pmcraid_clr_trans_op(
496 struct pmcraid_instance *pinstance
497)
498{
499 unsigned long lock_flags;
500
501 if (!pinstance->interrupt_mode) {
502 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
503 pinstance->int_regs.ioa_host_interrupt_mask_reg);
504 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
505 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
506 pinstance->int_regs.ioa_host_interrupt_clr_reg);
507 ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg);
508 }
509
510 if (pinstance->reset_cmd != NULL) {
511 del_timer(&pinstance->reset_cmd->timer);
512 spin_lock_irqsave(
513 pinstance->host->host_lock, lock_flags);
514 pinstance->reset_cmd->cmd_done(pinstance->reset_cmd);
515 spin_unlock_irqrestore(
516 pinstance->host->host_lock, lock_flags);
517 }
518}
519
520
521
522
523
524
525
526
527
528
529static void pmcraid_reset_type(struct pmcraid_instance *pinstance)
530{
531 u32 mask;
532 u32 intrs;
533 u32 alerts;
534
535 mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
536 intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
537 alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
538
539 if ((mask & INTRS_HRRQ_VALID) == 0 ||
540 (alerts & DOORBELL_IOA_RESET_ALERT) ||
541 (intrs & PMCRAID_ERROR_INTERRUPTS)) {
542 pmcraid_info("IOA requires hard reset\n");
543 pinstance->ioa_hard_reset = 1;
544 }
545
546
547 if (intrs & INTRS_IOA_UNIT_CHECK)
548 pinstance->ioa_unit_check = 1;
549}
550
551
552
553
554
555
556
557
558static void pmcraid_ioa_reset(struct pmcraid_cmd *);
559
560static void pmcraid_bist_done(struct pmcraid_cmd *cmd)
561{
562 struct pmcraid_instance *pinstance = cmd->drv_inst;
563 unsigned long lock_flags;
564 int rc;
565 u16 pci_reg;
566
567 rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
568
569
570 if ((rc != PCIBIOS_SUCCESSFUL || (!(pci_reg & PCI_COMMAND_MEMORY))) &&
571 cmd->time_left > 0) {
572 pmcraid_info("BIST not complete, waiting another 2 secs\n");
573 cmd->timer.expires = jiffies + cmd->time_left;
574 cmd->time_left = 0;
575 cmd->timer.data = (unsigned long)cmd;
576 cmd->timer.function =
577 (void (*)(unsigned long))pmcraid_bist_done;
578 add_timer(&cmd->timer);
579 } else {
580 cmd->time_left = 0;
581 pmcraid_info("BIST is complete, proceeding with reset\n");
582 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
583 pmcraid_ioa_reset(cmd);
584 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
585 }
586}
587
588
589
590
591
592
593
594static void pmcraid_start_bist(struct pmcraid_cmd *cmd)
595{
596 struct pmcraid_instance *pinstance = cmd->drv_inst;
597 u32 doorbells, intrs;
598
599
600 iowrite32(DOORBELL_IOA_START_BIST,
601 pinstance->int_regs.host_ioa_interrupt_reg);
602 doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
603 intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
604 pmcraid_info("doorbells after start bist: %x intrs: %x\n",
605 doorbells, intrs);
606
607 cmd->time_left = msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
608 cmd->timer.data = (unsigned long)cmd;
609 cmd->timer.expires = jiffies + msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
610 cmd->timer.function = (void (*)(unsigned long))pmcraid_bist_done;
611 add_timer(&cmd->timer);
612}
613
614
615
616
617
618
619
620static void pmcraid_reset_alert_done(struct pmcraid_cmd *cmd)
621{
622 struct pmcraid_instance *pinstance = cmd->drv_inst;
623 u32 status = ioread32(pinstance->ioa_status);
624 unsigned long lock_flags;
625
626
627
628
629
630 if (((status & INTRS_CRITICAL_OP_IN_PROGRESS) == 0) ||
631 cmd->time_left <= 0) {
632 pmcraid_info("critical op is reset proceeding with reset\n");
633 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
634 pmcraid_ioa_reset(cmd);
635 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
636 } else {
637 pmcraid_info("critical op is not yet reset waiting again\n");
638
639 cmd->time_left -= PMCRAID_CHECK_FOR_RESET_TIMEOUT;
640 cmd->timer.data = (unsigned long)cmd;
641 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
642 cmd->timer.function =
643 (void (*)(unsigned long))pmcraid_reset_alert_done;
644 add_timer(&cmd->timer);
645 }
646}
647
648
649
650
651
652
653
654
655
656
657static void pmcraid_notify_ioastate(struct pmcraid_instance *, u32);
658static void pmcraid_reset_alert(struct pmcraid_cmd *cmd)
659{
660 struct pmcraid_instance *pinstance = cmd->drv_inst;
661 u32 doorbells;
662 int rc;
663 u16 pci_reg;
664
665
666
667
668
669
670 rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
671 if ((rc == PCIBIOS_SUCCESSFUL) && (pci_reg & PCI_COMMAND_MEMORY)) {
672
673
674
675
676
677
678 cmd->time_left = PMCRAID_RESET_TIMEOUT;
679 cmd->timer.data = (unsigned long)cmd;
680 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
681 cmd->timer.function =
682 (void (*)(unsigned long))pmcraid_reset_alert_done;
683 add_timer(&cmd->timer);
684
685 iowrite32(DOORBELL_IOA_RESET_ALERT,
686 pinstance->int_regs.host_ioa_interrupt_reg);
687 doorbells =
688 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
689 pmcraid_info("doorbells after reset alert: %x\n", doorbells);
690 } else {
691 pmcraid_info("PCI config is not accessible starting BIST\n");
692 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
693 pmcraid_start_bist(cmd);
694 }
695}
696
697
698
699
700
701
702
703
704
705
706
707static void pmcraid_timeout_handler(struct pmcraid_cmd *cmd)
708{
709 struct pmcraid_instance *pinstance = cmd->drv_inst;
710 unsigned long lock_flags;
711
712 dev_info(&pinstance->pdev->dev,
713 "Adapter being reset due to cmd(CDB[0] = %x) timeout\n",
714 cmd->ioa_cb->ioarcb.cdb[0]);
715
716
717
718
719
720
721
722 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
723 if (!pinstance->ioa_reset_in_progress) {
724 pinstance->ioa_reset_attempts = 0;
725 cmd = pmcraid_get_free_cmd(pinstance);
726
727
728
729
730 if (cmd == NULL) {
731 spin_unlock_irqrestore(pinstance->host->host_lock,
732 lock_flags);
733 pmcraid_err("no free cmnd block for timeout handler\n");
734 return;
735 }
736
737 pinstance->reset_cmd = cmd;
738 pinstance->ioa_reset_in_progress = 1;
739 } else {
740 pmcraid_info("reset is already in progress\n");
741
742 if (pinstance->reset_cmd != cmd) {
743
744
745
746
747 pmcraid_err("cmd is pending but reset in progress\n");
748 }
749
750
751
752
753
754
755 if (cmd == pinstance->reset_cmd)
756 cmd->cmd_done = pmcraid_ioa_reset;
757 }
758
759
760 if (pinstance->scn.ioa_state != PMC_DEVICE_EVENT_RESET_START &&
761 pinstance->scn.ioa_state != PMC_DEVICE_EVENT_SHUTDOWN_START)
762 pmcraid_notify_ioastate(pinstance,
763 PMC_DEVICE_EVENT_RESET_START);
764
765 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
766 scsi_block_requests(pinstance->host);
767 pmcraid_reset_alert(cmd);
768 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
769}
770
771
772
773
774
775
776
777
778
779static void pmcraid_internal_done(struct pmcraid_cmd *cmd)
780{
781 pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
782 cmd->ioa_cb->ioarcb.cdb[0],
783 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
784
785
786
787
788
789
790 if (cmd->completion_req) {
791 cmd->completion_req = 0;
792 complete(&cmd->wait_for_completion);
793 }
794
795
796
797
798
799 if (cmd->release) {
800 cmd->release = 0;
801 pmcraid_return_cmd(cmd);
802 }
803}
804
805
806
807
808
809
810
811
812
813
814
815
816
817static void pmcraid_reinit_cfgtable_done(struct pmcraid_cmd *cmd)
818{
819 pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
820 cmd->ioa_cb->ioarcb.cdb[0],
821 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
822
823 if (cmd->release) {
824 cmd->release = 0;
825 pmcraid_return_cmd(cmd);
826 }
827 pmcraid_info("scheduling worker for config table reinitialization\n");
828 schedule_work(&cmd->drv_inst->worker_q);
829}
830
831
832
833
834
835
836
837
838
839
840
841static void pmcraid_erp_done(struct pmcraid_cmd *cmd)
842{
843 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
844 struct pmcraid_instance *pinstance = cmd->drv_inst;
845 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
846
847 if (PMCRAID_IOASC_SENSE_KEY(ioasc) > 0) {
848 scsi_cmd->result |= (DID_ERROR << 16);
849 scmd_printk(KERN_INFO, scsi_cmd,
850 "command CDB[0] = %x failed with IOASC: 0x%08X\n",
851 cmd->ioa_cb->ioarcb.cdb[0], ioasc);
852 }
853
854
855
856
857 if (cmd->sense_buffer != NULL) {
858 memcpy(scsi_cmd->sense_buffer,
859 cmd->sense_buffer,
860 SCSI_SENSE_BUFFERSIZE);
861 pci_free_consistent(pinstance->pdev,
862 SCSI_SENSE_BUFFERSIZE,
863 cmd->sense_buffer, cmd->sense_buffer_dma);
864 cmd->sense_buffer = NULL;
865 cmd->sense_buffer_dma = 0;
866 }
867
868 scsi_dma_unmap(scsi_cmd);
869 pmcraid_return_cmd(cmd);
870 scsi_cmd->scsi_done(scsi_cmd);
871}
872
873
874
875
876
877
878
879
880
881
882
883
884static void _pmcraid_fire_command(struct pmcraid_cmd *cmd)
885{
886 struct pmcraid_instance *pinstance = cmd->drv_inst;
887 unsigned long lock_flags;
888
889
890
891
892
893
894 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
895 list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool);
896 spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
897 atomic_inc(&pinstance->outstanding_cmds);
898
899
900 mb();
901 iowrite32(le64_to_cpu(cmd->ioa_cb->ioarcb.ioarcb_bus_addr), pinstance->ioarrin);
902}
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918static void pmcraid_send_cmd(
919 struct pmcraid_cmd *cmd,
920 void (*cmd_done) (struct pmcraid_cmd *),
921 unsigned long timeout,
922 void (*timeout_func) (struct pmcraid_cmd *)
923)
924{
925
926 cmd->cmd_done = cmd_done;
927
928 if (timeout_func) {
929
930 cmd->timer.data = (unsigned long)cmd;
931 cmd->timer.expires = jiffies + timeout;
932 cmd->timer.function = (void (*)(unsigned long))timeout_func;
933 add_timer(&cmd->timer);
934 }
935
936
937 _pmcraid_fire_command(cmd);
938}
939
940
941
942
943
944
945
946
947static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd)
948{
949 struct pmcraid_instance *pinstance = cmd->drv_inst;
950 unsigned long lock_flags;
951
952 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
953 pmcraid_ioa_reset(cmd);
954 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
955}
956
957
958
959
960
961
962
963
964
965static void pmcraid_ioa_shutdown(struct pmcraid_cmd *cmd)
966{
967 pmcraid_info("response for Cancel CCN CDB[0] = %x ioasc = %x\n",
968 cmd->ioa_cb->ioarcb.cdb[0],
969 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
970
971
972
973
974 pmcraid_reinit_cmdblk(cmd);
975 cmd->ioa_cb->ioarcb.request_type = REQ_TYPE_IOACMD;
976 cmd->ioa_cb->ioarcb.resource_handle =
977 cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
978 cmd->ioa_cb->ioarcb.cdb[0] = PMCRAID_IOA_SHUTDOWN;
979 cmd->ioa_cb->ioarcb.cdb[1] = PMCRAID_SHUTDOWN_NORMAL;
980
981
982 pmcraid_info("firing normal shutdown command (%d) to IOA\n",
983 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle));
984
985 pmcraid_notify_ioastate(cmd->drv_inst, PMC_DEVICE_EVENT_SHUTDOWN_START);
986
987 pmcraid_send_cmd(cmd, pmcraid_ioa_shutdown_done,
988 PMCRAID_SHUTDOWN_TIMEOUT,
989 pmcraid_timeout_handler);
990}
991
992
993
994
995
996
997
998
999
1000static void pmcraid_querycfg(struct pmcraid_cmd *);
1001
1002static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd)
1003{
1004 struct pmcraid_instance *pinstance = cmd->drv_inst;
1005 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1006 unsigned long lock_flags;
1007
1008
1009
1010
1011
1012 if (ioasc) {
1013 pmcraid_err("IOA Inquiry failed with %x\n", ioasc);
1014 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
1015 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
1016 pmcraid_reset_alert(cmd);
1017 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1018 } else {
1019 pmcraid_querycfg(cmd);
1020 }
1021}
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031static void pmcraid_get_fwversion(struct pmcraid_cmd *cmd)
1032{
1033 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1034 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
1035 struct pmcraid_instance *pinstance = cmd->drv_inst;
1036 u16 data_size = sizeof(struct pmcraid_inquiry_data);
1037
1038 pmcraid_reinit_cmdblk(cmd);
1039 ioarcb->request_type = REQ_TYPE_SCSI;
1040 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
1041 ioarcb->cdb[0] = INQUIRY;
1042 ioarcb->cdb[1] = 1;
1043 ioarcb->cdb[2] = 0xD0;
1044 ioarcb->cdb[3] = (data_size >> 8) & 0xFF;
1045 ioarcb->cdb[4] = data_size & 0xFF;
1046
1047
1048
1049 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
1050 offsetof(struct pmcraid_ioarcb,
1051 add_data.u.ioadl[0]));
1052 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
1053 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL));
1054
1055 ioarcb->request_flags0 |= NO_LINK_DESCS;
1056 ioarcb->data_transfer_length = cpu_to_le32(data_size);
1057 ioadl = &(ioarcb->add_data.u.ioadl[0]);
1058 ioadl->flags = IOADL_FLAGS_LAST_DESC;
1059 ioadl->address = cpu_to_le64(pinstance->inq_data_baddr);
1060 ioadl->data_len = cpu_to_le32(data_size);
1061
1062 pmcraid_send_cmd(cmd, pmcraid_get_fwversion_done,
1063 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
1064}
1065
1066
1067
1068
1069
1070
1071
1072
1073static void pmcraid_identify_hrrq(struct pmcraid_cmd *cmd)
1074{
1075 struct pmcraid_instance *pinstance = cmd->drv_inst;
1076 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1077 int index = cmd->hrrq_index;
1078 __be64 hrrq_addr = cpu_to_be64(pinstance->hrrq_start_bus_addr[index]);
1079 __be32 hrrq_size = cpu_to_be32(sizeof(u32) * PMCRAID_MAX_CMD);
1080 void (*done_function)(struct pmcraid_cmd *);
1081
1082 pmcraid_reinit_cmdblk(cmd);
1083 cmd->hrrq_index = index + 1;
1084
1085 if (cmd->hrrq_index < pinstance->num_hrrq) {
1086 done_function = pmcraid_identify_hrrq;
1087 } else {
1088 cmd->hrrq_index = 0;
1089 done_function = pmcraid_get_fwversion;
1090 }
1091
1092
1093 ioarcb->request_type = REQ_TYPE_IOACMD;
1094 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
1095
1096
1097 ioarcb->hrrq_id = index;
1098 ioarcb->cdb[0] = PMCRAID_IDENTIFY_HRRQ;
1099 ioarcb->cdb[1] = index;
1100
1101
1102
1103
1104 pmcraid_info("HRRQ_IDENTIFY with hrrq:ioarcb:index => %llx:%llx:%x\n",
1105 hrrq_addr, ioarcb->ioarcb_bus_addr, index);
1106
1107 memcpy(&(ioarcb->cdb[2]), &hrrq_addr, sizeof(hrrq_addr));
1108 memcpy(&(ioarcb->cdb[10]), &hrrq_size, sizeof(hrrq_size));
1109
1110
1111
1112
1113
1114 pmcraid_send_cmd(cmd, done_function,
1115 PMCRAID_INTERNAL_TIMEOUT,
1116 pmcraid_timeout_handler);
1117}
1118
1119static void pmcraid_process_ccn(struct pmcraid_cmd *cmd);
1120static void pmcraid_process_ldn(struct pmcraid_cmd *cmd);
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130static void pmcraid_send_hcam_cmd(struct pmcraid_cmd *cmd)
1131{
1132 if (cmd->ioa_cb->ioarcb.cdb[1] == PMCRAID_HCAM_CODE_CONFIG_CHANGE)
1133 atomic_set(&(cmd->drv_inst->ccn.ignore), 0);
1134 else
1135 atomic_set(&(cmd->drv_inst->ldn.ignore), 0);
1136
1137 pmcraid_send_cmd(cmd, cmd->cmd_done, 0, NULL);
1138}
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149static struct pmcraid_cmd *pmcraid_init_hcam
1150(
1151 struct pmcraid_instance *pinstance,
1152 u8 type
1153)
1154{
1155 struct pmcraid_cmd *cmd;
1156 struct pmcraid_ioarcb *ioarcb;
1157 struct pmcraid_ioadl_desc *ioadl;
1158 struct pmcraid_hostrcb *hcam;
1159 void (*cmd_done) (struct pmcraid_cmd *);
1160 dma_addr_t dma;
1161 int rcb_size;
1162
1163 cmd = pmcraid_get_free_cmd(pinstance);
1164
1165 if (!cmd) {
1166 pmcraid_err("no free command blocks for hcam\n");
1167 return cmd;
1168 }
1169
1170 if (type == PMCRAID_HCAM_CODE_CONFIG_CHANGE) {
1171 rcb_size = sizeof(struct pmcraid_hcam_ccn_ext);
1172 cmd_done = pmcraid_process_ccn;
1173 dma = pinstance->ccn.baddr + PMCRAID_AEN_HDR_SIZE;
1174 hcam = &pinstance->ccn;
1175 } else {
1176 rcb_size = sizeof(struct pmcraid_hcam_ldn);
1177 cmd_done = pmcraid_process_ldn;
1178 dma = pinstance->ldn.baddr + PMCRAID_AEN_HDR_SIZE;
1179 hcam = &pinstance->ldn;
1180 }
1181
1182
1183 hcam->cmd = cmd;
1184
1185 ioarcb = &cmd->ioa_cb->ioarcb;
1186 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
1187 offsetof(struct pmcraid_ioarcb,
1188 add_data.u.ioadl[0]));
1189 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
1190 ioadl = ioarcb->add_data.u.ioadl;
1191
1192
1193 ioarcb->request_type = REQ_TYPE_HCAM;
1194 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
1195 ioarcb->cdb[0] = PMCRAID_HOST_CONTROLLED_ASYNC;
1196 ioarcb->cdb[1] = type;
1197 ioarcb->cdb[7] = (rcb_size >> 8) & 0xFF;
1198 ioarcb->cdb[8] = (rcb_size) & 0xFF;
1199
1200 ioarcb->data_transfer_length = cpu_to_le32(rcb_size);
1201
1202 ioadl[0].flags |= IOADL_FLAGS_READ_LAST;
1203 ioadl[0].data_len = cpu_to_le32(rcb_size);
1204 ioadl[0].address = cpu_to_le64(dma);
1205
1206 cmd->cmd_done = cmd_done;
1207 return cmd;
1208}
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220static void pmcraid_send_hcam(struct pmcraid_instance *pinstance, u8 type)
1221{
1222 struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type);
1223 pmcraid_send_hcam_cmd(cmd);
1224}
1225
1226
1227
1228
1229
1230
1231
1232
1233static void pmcraid_prepare_cancel_cmd(
1234 struct pmcraid_cmd *cmd,
1235 struct pmcraid_cmd *cmd_to_cancel
1236)
1237{
1238 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1239 __be64 ioarcb_addr;
1240
1241
1242
1243
1244
1245 ioarcb_addr = cpu_to_be64(le64_to_cpu(cmd_to_cancel->ioa_cb->ioarcb.ioarcb_bus_addr));
1246
1247
1248
1249
1250 ioarcb->resource_handle = cmd_to_cancel->ioa_cb->ioarcb.resource_handle;
1251 ioarcb->request_type = REQ_TYPE_IOACMD;
1252 memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
1253 ioarcb->cdb[0] = PMCRAID_ABORT_CMD;
1254
1255 memcpy(&(ioarcb->cdb[2]), &ioarcb_addr, sizeof(ioarcb_addr));
1256}
1257
1258
1259
1260
1261
1262
1263
1264
1265static void pmcraid_cancel_hcam(
1266 struct pmcraid_cmd *cmd,
1267 u8 type,
1268 void (*cmd_done) (struct pmcraid_cmd *)
1269)
1270{
1271 struct pmcraid_instance *pinstance;
1272 struct pmcraid_hostrcb *hcam;
1273
1274 pinstance = cmd->drv_inst;
1275 hcam = (type == PMCRAID_HCAM_CODE_LOG_DATA) ?
1276 &pinstance->ldn : &pinstance->ccn;
1277
1278
1279
1280
1281 if (hcam->cmd == NULL)
1282 return;
1283
1284 pmcraid_prepare_cancel_cmd(cmd, hcam->cmd);
1285
1286
1287
1288
1289 pmcraid_send_cmd(cmd, cmd_done,
1290 PMCRAID_INTERNAL_TIMEOUT,
1291 pmcraid_timeout_handler);
1292}
1293
1294
1295
1296
1297
1298
1299static void pmcraid_cancel_ccn(struct pmcraid_cmd *cmd)
1300{
1301 pmcraid_info("response for Cancel LDN CDB[0] = %x ioasc = %x\n",
1302 cmd->ioa_cb->ioarcb.cdb[0],
1303 le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
1304
1305 pmcraid_reinit_cmdblk(cmd);
1306
1307 pmcraid_cancel_hcam(cmd,
1308 PMCRAID_HCAM_CODE_CONFIG_CHANGE,
1309 pmcraid_ioa_shutdown);
1310}
1311
1312
1313
1314
1315
1316
1317static void pmcraid_cancel_ldn(struct pmcraid_cmd *cmd)
1318{
1319 pmcraid_cancel_hcam(cmd,
1320 PMCRAID_HCAM_CODE_LOG_DATA,
1321 pmcraid_cancel_ccn);
1322}
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333static int pmcraid_expose_resource(u16 fw_version,
1334 struct pmcraid_config_table_entry *cfgte)
1335{
1336 int retval = 0;
1337
1338 if (cfgte->resource_type == RES_TYPE_VSET) {
1339 if (fw_version <= PMCRAID_FW_VERSION_1)
1340 retval = ((cfgte->unique_flags1 & 0x80) == 0);
1341 else
1342 retval = ((cfgte->unique_flags0 & 0x80) == 0 &&
1343 (cfgte->unique_flags1 & 0x80) == 0);
1344
1345 } else if (cfgte->resource_type == RES_TYPE_GSCSI)
1346 retval = (RES_BUS(cfgte->resource_address) !=
1347 PMCRAID_VIRTUAL_ENCL_BUS_ID);
1348 return retval;
1349}
1350
1351
1352enum {
1353 PMCRAID_AEN_ATTR_UNSPEC,
1354 PMCRAID_AEN_ATTR_EVENT,
1355 __PMCRAID_AEN_ATTR_MAX,
1356};
1357#define PMCRAID_AEN_ATTR_MAX (__PMCRAID_AEN_ATTR_MAX - 1)
1358
1359
1360enum {
1361 PMCRAID_AEN_CMD_UNSPEC,
1362 PMCRAID_AEN_CMD_EVENT,
1363 __PMCRAID_AEN_CMD_MAX,
1364};
1365#define PMCRAID_AEN_CMD_MAX (__PMCRAID_AEN_CMD_MAX - 1)
1366
1367static struct genl_multicast_group pmcraid_mcgrps[] = {
1368 { .name = "events", },
1369};
1370
1371static struct genl_family pmcraid_event_family __ro_after_init = {
1372 .module = THIS_MODULE,
1373 .name = "pmcraid",
1374 .version = 1,
1375 .maxattr = PMCRAID_AEN_ATTR_MAX,
1376 .mcgrps = pmcraid_mcgrps,
1377 .n_mcgrps = ARRAY_SIZE(pmcraid_mcgrps),
1378};
1379
1380
1381
1382
1383
1384
1385
1386
1387static int __init pmcraid_netlink_init(void)
1388{
1389 int result;
1390
1391 result = genl_register_family(&pmcraid_event_family);
1392
1393 if (result)
1394 return result;
1395
1396 pmcraid_info("registered NETLINK GENERIC group: %d\n",
1397 pmcraid_event_family.id);
1398
1399 return result;
1400}
1401
1402
1403
1404
1405
1406
1407
1408static void pmcraid_netlink_release(void)
1409{
1410 genl_unregister_family(&pmcraid_event_family);
1411}
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421static int pmcraid_notify_aen(
1422 struct pmcraid_instance *pinstance,
1423 struct pmcraid_aen_msg *aen_msg,
1424 u32 data_size
1425)
1426{
1427 struct sk_buff *skb;
1428 void *msg_header;
1429 u32 total_size, nla_genl_hdr_total_size;
1430 int result;
1431
1432 aen_msg->hostno = (pinstance->host->unique_id << 16 |
1433 MINOR(pinstance->cdev.dev));
1434 aen_msg->length = data_size;
1435
1436 data_size += sizeof(*aen_msg);
1437
1438 total_size = nla_total_size(data_size);
1439
1440 nla_genl_hdr_total_size =
1441 (total_size + (GENL_HDRLEN +
1442 ((struct genl_family *)&pmcraid_event_family)->hdrsize)
1443 + NLMSG_HDRLEN);
1444 skb = genlmsg_new(nla_genl_hdr_total_size, GFP_ATOMIC);
1445
1446
1447 if (!skb) {
1448 pmcraid_err("Failed to allocate aen data SKB of size: %x\n",
1449 total_size);
1450 return -ENOMEM;
1451 }
1452
1453
1454 msg_header = genlmsg_put(skb, 0, 0,
1455 &pmcraid_event_family, 0,
1456 PMCRAID_AEN_CMD_EVENT);
1457 if (!msg_header) {
1458 pmcraid_err("failed to copy command details\n");
1459 nlmsg_free(skb);
1460 return -ENOMEM;
1461 }
1462
1463 result = nla_put(skb, PMCRAID_AEN_ATTR_EVENT, data_size, aen_msg);
1464
1465 if (result) {
1466 pmcraid_err("failed to copy AEN attribute data\n");
1467 nlmsg_free(skb);
1468 return -EINVAL;
1469 }
1470
1471
1472 genlmsg_end(skb, msg_header);
1473
1474 result = genlmsg_multicast(&pmcraid_event_family, skb,
1475 0, 0, GFP_ATOMIC);
1476
1477
1478
1479
1480 if (result)
1481 pmcraid_info("error (%x) sending aen event message\n", result);
1482 return result;
1483}
1484
1485
1486
1487
1488
1489
1490
1491
1492static int pmcraid_notify_ccn(struct pmcraid_instance *pinstance)
1493{
1494 return pmcraid_notify_aen(pinstance,
1495 pinstance->ccn.msg,
1496 le32_to_cpu(pinstance->ccn.hcam->data_len) +
1497 sizeof(struct pmcraid_hcam_hdr));
1498}
1499
1500
1501
1502
1503
1504
1505
1506
1507static int pmcraid_notify_ldn(struct pmcraid_instance *pinstance)
1508{
1509 return pmcraid_notify_aen(pinstance,
1510 pinstance->ldn.msg,
1511 le32_to_cpu(pinstance->ldn.hcam->data_len) +
1512 sizeof(struct pmcraid_hcam_hdr));
1513}
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523static void pmcraid_notify_ioastate(struct pmcraid_instance *pinstance, u32 evt)
1524{
1525 pinstance->scn.ioa_state = evt;
1526 pmcraid_notify_aen(pinstance,
1527 &pinstance->scn.msg,
1528 sizeof(u32));
1529}
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
1540{
1541 struct pmcraid_config_table_entry *cfg_entry;
1542 struct pmcraid_hcam_ccn *ccn_hcam;
1543 struct pmcraid_cmd *cmd;
1544 struct pmcraid_cmd *cfgcmd;
1545 struct pmcraid_resource_entry *res = NULL;
1546 unsigned long lock_flags;
1547 unsigned long host_lock_flags;
1548 u32 new_entry = 1;
1549 u32 hidden_entry = 0;
1550 u16 fw_version;
1551 int rc;
1552
1553 ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam;
1554 cfg_entry = &ccn_hcam->cfg_entry;
1555 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
1556
1557 pmcraid_info("CCN(%x): %x timestamp: %llx type: %x lost: %x flags: %x \
1558 res: %x:%x:%x:%x\n",
1559 le32_to_cpu(pinstance->ccn.hcam->ilid),
1560 pinstance->ccn.hcam->op_code,
1561 (le32_to_cpu(pinstance->ccn.hcam->timestamp1) |
1562 ((le32_to_cpu(pinstance->ccn.hcam->timestamp2) & 0xffffffffLL) << 32)),
1563 pinstance->ccn.hcam->notification_type,
1564 pinstance->ccn.hcam->notification_lost,
1565 pinstance->ccn.hcam->flags,
1566 pinstance->host->unique_id,
1567 RES_IS_VSET(*cfg_entry) ? PMCRAID_VSET_BUS_ID :
1568 (RES_IS_GSCSI(*cfg_entry) ? PMCRAID_PHYS_BUS_ID :
1569 RES_BUS(cfg_entry->resource_address)),
1570 RES_IS_VSET(*cfg_entry) ?
1571 (fw_version <= PMCRAID_FW_VERSION_1 ?
1572 cfg_entry->unique_flags1 :
1573 le16_to_cpu(cfg_entry->array_id) & 0xFF) :
1574 RES_TARGET(cfg_entry->resource_address),
1575 RES_LUN(cfg_entry->resource_address));
1576
1577
1578
1579 if (pinstance->ccn.hcam->notification_lost) {
1580 cfgcmd = pmcraid_get_free_cmd(pinstance);
1581 if (cfgcmd) {
1582 pmcraid_info("lost CCN, reading config table\b");
1583 pinstance->reinit_cfg_table = 1;
1584 pmcraid_querycfg(cfgcmd);
1585 } else {
1586 pmcraid_err("lost CCN, no free cmd for querycfg\n");
1587 }
1588 goto out_notify_apps;
1589 }
1590
1591
1592
1593
1594
1595 if (pinstance->ccn.hcam->notification_type ==
1596 NOTIFICATION_TYPE_ENTRY_CHANGED &&
1597 cfg_entry->resource_type == RES_TYPE_VSET) {
1598
1599 if (fw_version <= PMCRAID_FW_VERSION_1)
1600 hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;
1601 else
1602 hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;
1603
1604 } else if (!pmcraid_expose_resource(fw_version, cfg_entry)) {
1605 goto out_notify_apps;
1606 }
1607
1608 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
1609 list_for_each_entry(res, &pinstance->used_res_q, queue) {
1610 rc = memcmp(&res->cfg_entry.resource_address,
1611 &cfg_entry->resource_address,
1612 sizeof(cfg_entry->resource_address));
1613 if (!rc) {
1614 new_entry = 0;
1615 break;
1616 }
1617 }
1618
1619 if (new_entry) {
1620
1621 if (hidden_entry) {
1622 spin_unlock_irqrestore(&pinstance->resource_lock,
1623 lock_flags);
1624 goto out_notify_apps;
1625 }
1626
1627
1628
1629
1630
1631 if (list_empty(&pinstance->free_res_q)) {
1632 spin_unlock_irqrestore(&pinstance->resource_lock,
1633 lock_flags);
1634 pmcraid_err("too many resources attached\n");
1635 spin_lock_irqsave(pinstance->host->host_lock,
1636 host_lock_flags);
1637 pmcraid_send_hcam(pinstance,
1638 PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1639 spin_unlock_irqrestore(pinstance->host->host_lock,
1640 host_lock_flags);
1641 return;
1642 }
1643
1644 res = list_entry(pinstance->free_res_q.next,
1645 struct pmcraid_resource_entry, queue);
1646
1647 list_del(&res->queue);
1648 res->scsi_dev = NULL;
1649 res->reset_progress = 0;
1650 list_add_tail(&res->queue, &pinstance->used_res_q);
1651 }
1652
1653 memcpy(&res->cfg_entry, cfg_entry, pinstance->config_table_entry_size);
1654
1655 if (pinstance->ccn.hcam->notification_type ==
1656 NOTIFICATION_TYPE_ENTRY_DELETED || hidden_entry) {
1657 if (res->scsi_dev) {
1658 if (fw_version <= PMCRAID_FW_VERSION_1)
1659 res->cfg_entry.unique_flags1 &= 0x7F;
1660 else
1661 res->cfg_entry.array_id &= cpu_to_le16(0xFF);
1662 res->change_detected = RES_CHANGE_DEL;
1663 res->cfg_entry.resource_handle =
1664 PMCRAID_INVALID_RES_HANDLE;
1665 schedule_work(&pinstance->worker_q);
1666 } else {
1667
1668 list_move_tail(&res->queue, &pinstance->free_res_q);
1669 }
1670 } else if (!res->scsi_dev) {
1671 res->change_detected = RES_CHANGE_ADD;
1672 schedule_work(&pinstance->worker_q);
1673 }
1674 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
1675
1676out_notify_apps:
1677
1678
1679 if (!pmcraid_disable_aen)
1680 pmcraid_notify_ccn(pinstance);
1681
1682 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1683 if (cmd)
1684 pmcraid_send_hcam_cmd(cmd);
1685}
1686
1687
1688
1689
1690
1691
1692
1693static struct pmcraid_ioasc_error *pmcraid_get_error_info(u32 ioasc)
1694{
1695 int i;
1696 for (i = 0; i < ARRAY_SIZE(pmcraid_ioasc_error_table); i++) {
1697 if (pmcraid_ioasc_error_table[i].ioasc_code == ioasc)
1698 return &pmcraid_ioasc_error_table[i];
1699 }
1700 return NULL;
1701}
1702
1703
1704
1705
1706
1707
1708static void pmcraid_ioasc_logger(u32 ioasc, struct pmcraid_cmd *cmd)
1709{
1710 struct pmcraid_ioasc_error *error_info = pmcraid_get_error_info(ioasc);
1711
1712 if (error_info == NULL ||
1713 cmd->drv_inst->current_log_level < error_info->log_level)
1714 return;
1715
1716
1717 pmcraid_err("cmd [%x] for resource %x failed with %x(%s)\n",
1718 cmd->ioa_cb->ioarcb.cdb[0],
1719 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),
1720 ioasc, error_info->error_string);
1721}
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731static void pmcraid_handle_error_log(struct pmcraid_instance *pinstance)
1732{
1733 struct pmcraid_hcam_ldn *hcam_ldn;
1734 u32 ioasc;
1735
1736 hcam_ldn = (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
1737
1738 pmcraid_info
1739 ("LDN(%x): %x type: %x lost: %x flags: %x overlay id: %x\n",
1740 pinstance->ldn.hcam->ilid,
1741 pinstance->ldn.hcam->op_code,
1742 pinstance->ldn.hcam->notification_type,
1743 pinstance->ldn.hcam->notification_lost,
1744 pinstance->ldn.hcam->flags,
1745 pinstance->ldn.hcam->overlay_id);
1746
1747
1748 if (pinstance->ldn.hcam->notification_type !=
1749 NOTIFICATION_TYPE_ERROR_LOG)
1750 return;
1751
1752 if (pinstance->ldn.hcam->notification_lost ==
1753 HOSTRCB_NOTIFICATIONS_LOST)
1754 dev_info(&pinstance->pdev->dev, "Error notifications lost\n");
1755
1756 ioasc = le32_to_cpu(hcam_ldn->error_log.fd_ioasc);
1757
1758 if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||
1759 ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER) {
1760 dev_info(&pinstance->pdev->dev,
1761 "UnitAttention due to IOA Bus Reset\n");
1762 scsi_report_bus_reset(
1763 pinstance->host,
1764 RES_BUS(hcam_ldn->error_log.fd_ra));
1765 }
1766
1767 return;
1768}
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780static void pmcraid_process_ccn(struct pmcraid_cmd *cmd)
1781{
1782 struct pmcraid_instance *pinstance = cmd->drv_inst;
1783 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1784 unsigned long lock_flags;
1785
1786 pinstance->ccn.cmd = NULL;
1787 pmcraid_return_cmd(cmd);
1788
1789
1790
1791
1792
1793 if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
1794 atomic_read(&pinstance->ccn.ignore) == 1) {
1795 return;
1796 } else if (ioasc) {
1797 dev_info(&pinstance->pdev->dev,
1798 "Host RCB (CCN) failed with IOASC: 0x%08X\n", ioasc);
1799 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
1800 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1801 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1802 } else {
1803 pmcraid_handle_config_change(pinstance);
1804 }
1805}
1806
1807
1808
1809
1810
1811
1812
1813
1814static void pmcraid_initiate_reset(struct pmcraid_instance *);
1815static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd);
1816
1817static void pmcraid_process_ldn(struct pmcraid_cmd *cmd)
1818{
1819 struct pmcraid_instance *pinstance = cmd->drv_inst;
1820 struct pmcraid_hcam_ldn *ldn_hcam =
1821 (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
1822 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1823 u32 fd_ioasc = le32_to_cpu(ldn_hcam->error_log.fd_ioasc);
1824 unsigned long lock_flags;
1825
1826
1827 pinstance->ldn.cmd = NULL;
1828 pmcraid_return_cmd(cmd);
1829
1830
1831
1832
1833
1834 if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
1835 atomic_read(&pinstance->ccn.ignore) == 1) {
1836 return;
1837 } else if (!ioasc) {
1838 pmcraid_handle_error_log(pinstance);
1839 if (fd_ioasc == PMCRAID_IOASC_NR_IOA_RESET_REQUIRED) {
1840 spin_lock_irqsave(pinstance->host->host_lock,
1841 lock_flags);
1842 pmcraid_initiate_reset(pinstance);
1843 spin_unlock_irqrestore(pinstance->host->host_lock,
1844 lock_flags);
1845 return;
1846 }
1847 if (fd_ioasc == PMCRAID_IOASC_TIME_STAMP_OUT_OF_SYNC) {
1848 pinstance->timestamp_error = 1;
1849 pmcraid_set_timestamp(cmd);
1850 }
1851 } else {
1852 dev_info(&pinstance->pdev->dev,
1853 "Host RCB(LDN) failed with IOASC: 0x%08X\n", ioasc);
1854 }
1855
1856 if (!pmcraid_disable_aen)
1857 pmcraid_notify_ldn(pinstance);
1858
1859 cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1860 if (cmd)
1861 pmcraid_send_hcam_cmd(cmd);
1862}
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872static void pmcraid_register_hcams(struct pmcraid_instance *pinstance)
1873{
1874 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1875 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1876}
1877
1878
1879
1880
1881
1882static void pmcraid_unregister_hcams(struct pmcraid_cmd *cmd)
1883{
1884 struct pmcraid_instance *pinstance = cmd->drv_inst;
1885
1886
1887
1888
1889
1890
1891 atomic_set(&pinstance->ccn.ignore, 1);
1892 atomic_set(&pinstance->ldn.ignore, 1);
1893
1894
1895
1896
1897
1898 if ((pinstance->force_ioa_reset && !pinstance->ioa_bringdown) ||
1899 pinstance->ioa_unit_check) {
1900 pinstance->force_ioa_reset = 0;
1901 pinstance->ioa_unit_check = 0;
1902 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
1903 pmcraid_reset_alert(cmd);
1904 return;
1905 }
1906
1907
1908
1909
1910
1911 pmcraid_cancel_ldn(cmd);
1912}
1913
1914
1915
1916
1917
1918
1919
1920static void pmcraid_reinit_buffers(struct pmcraid_instance *);
1921
1922static int pmcraid_reset_enable_ioa(struct pmcraid_instance *pinstance)
1923{
1924 u32 intrs;
1925
1926 pmcraid_reinit_buffers(pinstance);
1927 intrs = pmcraid_read_interrupts(pinstance);
1928
1929 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
1930
1931 if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {
1932 if (!pinstance->interrupt_mode) {
1933 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
1934 pinstance->int_regs.
1935 ioa_host_interrupt_mask_reg);
1936 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
1937 pinstance->int_regs.ioa_host_interrupt_clr_reg);
1938 }
1939 return 1;
1940 } else {
1941 return 0;
1942 }
1943}
1944
1945
1946
1947
1948
1949
1950
1951
1952static void pmcraid_soft_reset(struct pmcraid_cmd *cmd)
1953{
1954 struct pmcraid_instance *pinstance = cmd->drv_inst;
1955 u32 int_reg;
1956 u32 doorbell;
1957
1958
1959
1960
1961
1962 cmd->cmd_done = pmcraid_ioa_reset;
1963 cmd->timer.data = (unsigned long)cmd;
1964 cmd->timer.expires = jiffies +
1965 msecs_to_jiffies(PMCRAID_TRANSOP_TIMEOUT);
1966 cmd->timer.function = (void (*)(unsigned long))pmcraid_timeout_handler;
1967
1968 if (!timer_pending(&cmd->timer))
1969 add_timer(&cmd->timer);
1970
1971
1972
1973
1974 doorbell = DOORBELL_RUNTIME_RESET |
1975 DOORBELL_ENABLE_DESTRUCTIVE_DIAGS;
1976
1977
1978
1979
1980 if (pinstance->interrupt_mode) {
1981 iowrite32(DOORBELL_INTR_MODE_MSIX,
1982 pinstance->int_regs.host_ioa_interrupt_reg);
1983 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
1984 }
1985
1986 iowrite32(doorbell, pinstance->int_regs.host_ioa_interrupt_reg);
1987 ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
1988 int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
1989
1990 pmcraid_info("Waiting for IOA to become operational %x:%x\n",
1991 ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
1992 int_reg);
1993}
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003static void pmcraid_get_dump(struct pmcraid_instance *pinstance)
2004{
2005 pmcraid_info("%s is not yet implemented\n", __func__);
2006}
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020static void pmcraid_fail_outstanding_cmds(struct pmcraid_instance *pinstance)
2021{
2022 struct pmcraid_cmd *cmd, *temp;
2023 unsigned long lock_flags;
2024
2025
2026
2027
2028 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
2029 list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool,
2030 free_list) {
2031 list_del(&cmd->free_list);
2032 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
2033 lock_flags);
2034 cmd->ioa_cb->ioasa.ioasc =
2035 cpu_to_le32(PMCRAID_IOASC_IOA_WAS_RESET);
2036 cmd->ioa_cb->ioasa.ilid =
2037 cpu_to_le32(PMCRAID_DRIVER_ILID);
2038
2039
2040 del_timer(&cmd->timer);
2041
2042
2043
2044
2045
2046
2047 if (cmd->scsi_cmd) {
2048
2049 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2050 __le32 resp = cmd->ioa_cb->ioarcb.response_handle;
2051
2052 scsi_cmd->result |= DID_ERROR << 16;
2053
2054 scsi_dma_unmap(scsi_cmd);
2055 pmcraid_return_cmd(cmd);
2056
2057 pmcraid_info("failing(%d) CDB[0] = %x result: %x\n",
2058 le32_to_cpu(resp) >> 2,
2059 cmd->ioa_cb->ioarcb.cdb[0],
2060 scsi_cmd->result);
2061 scsi_cmd->scsi_done(scsi_cmd);
2062 } else if (cmd->cmd_done == pmcraid_internal_done ||
2063 cmd->cmd_done == pmcraid_erp_done) {
2064 cmd->cmd_done(cmd);
2065 } else if (cmd->cmd_done != pmcraid_ioa_reset &&
2066 cmd->cmd_done != pmcraid_ioa_shutdown_done) {
2067 pmcraid_return_cmd(cmd);
2068 }
2069
2070 atomic_dec(&pinstance->outstanding_cmds);
2071 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
2072 }
2073
2074 spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
2075}
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092static void pmcraid_ioa_reset(struct pmcraid_cmd *cmd)
2093{
2094 struct pmcraid_instance *pinstance = cmd->drv_inst;
2095 u8 reset_complete = 0;
2096
2097 pinstance->ioa_reset_in_progress = 1;
2098
2099 if (pinstance->reset_cmd != cmd) {
2100 pmcraid_err("reset is called with different command block\n");
2101 pinstance->reset_cmd = cmd;
2102 }
2103
2104 pmcraid_info("reset_engine: state = %d, command = %p\n",
2105 pinstance->ioa_state, cmd);
2106
2107 switch (pinstance->ioa_state) {
2108
2109 case IOA_STATE_DEAD:
2110
2111
2112
2113
2114 pmcraid_err("IOA is offline no reset is possible\n");
2115 reset_complete = 1;
2116 break;
2117
2118 case IOA_STATE_IN_BRINGDOWN:
2119
2120
2121
2122
2123 pmcraid_disable_interrupts(pinstance, ~0);
2124 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2125 pmcraid_reset_alert(cmd);
2126 break;
2127
2128 case IOA_STATE_UNKNOWN:
2129
2130
2131
2132 scsi_block_requests(pinstance->host);
2133
2134
2135
2136
2137
2138 if (pinstance->ioa_hard_reset == 0) {
2139 if (ioread32(pinstance->ioa_status) &
2140 INTRS_TRANSITION_TO_OPERATIONAL) {
2141 pmcraid_info("sticky bit set, bring-up\n");
2142 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2143 pmcraid_reinit_cmdblk(cmd);
2144 pmcraid_identify_hrrq(cmd);
2145 } else {
2146 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
2147 pmcraid_soft_reset(cmd);
2148 }
2149 } else {
2150
2151
2152
2153 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2154 pmcraid_reset_alert(cmd);
2155 }
2156 break;
2157
2158 case IOA_STATE_IN_RESET_ALERT:
2159
2160
2161
2162
2163
2164 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
2165 pmcraid_start_bist(cmd);
2166 break;
2167
2168 case IOA_STATE_IN_HARD_RESET:
2169 pinstance->ioa_reset_attempts++;
2170
2171
2172 if (pinstance->ioa_reset_attempts > PMCRAID_RESET_ATTEMPTS) {
2173 pinstance->ioa_reset_attempts = 0;
2174 pmcraid_err("IOA didn't respond marking it as dead\n");
2175 pinstance->ioa_state = IOA_STATE_DEAD;
2176
2177 if (pinstance->ioa_bringdown)
2178 pmcraid_notify_ioastate(pinstance,
2179 PMC_DEVICE_EVENT_SHUTDOWN_FAILED);
2180 else
2181 pmcraid_notify_ioastate(pinstance,
2182 PMC_DEVICE_EVENT_RESET_FAILED);
2183 reset_complete = 1;
2184 break;
2185 }
2186
2187
2188
2189
2190 pci_restore_state(pinstance->pdev);
2191
2192
2193 pmcraid_fail_outstanding_cmds(pinstance);
2194
2195
2196 if (pinstance->ioa_unit_check) {
2197 pmcraid_info("unit check is active\n");
2198 pinstance->ioa_unit_check = 0;
2199 pmcraid_get_dump(pinstance);
2200 pinstance->ioa_reset_attempts--;
2201 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2202 pmcraid_reset_alert(cmd);
2203 break;
2204 }
2205
2206
2207
2208
2209
2210 if (pinstance->ioa_bringdown) {
2211 pmcraid_info("bringing down the adapter\n");
2212 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2213 pinstance->ioa_bringdown = 0;
2214 pinstance->ioa_state = IOA_STATE_UNKNOWN;
2215 pmcraid_notify_ioastate(pinstance,
2216 PMC_DEVICE_EVENT_SHUTDOWN_SUCCESS);
2217 reset_complete = 1;
2218 } else {
2219
2220
2221
2222
2223 if (pmcraid_reset_enable_ioa(pinstance)) {
2224 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2225 pmcraid_info("bringing up the adapter\n");
2226 pmcraid_reinit_cmdblk(cmd);
2227 pmcraid_identify_hrrq(cmd);
2228 } else {
2229 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
2230 pmcraid_soft_reset(cmd);
2231 }
2232 }
2233 break;
2234
2235 case IOA_STATE_IN_SOFT_RESET:
2236
2237
2238
2239 pmcraid_info("In softreset proceeding with bring-up\n");
2240 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2241
2242
2243
2244
2245
2246 pmcraid_identify_hrrq(cmd);
2247 break;
2248
2249 case IOA_STATE_IN_BRINGUP:
2250
2251
2252
2253 pinstance->ioa_state = IOA_STATE_OPERATIONAL;
2254 reset_complete = 1;
2255 break;
2256
2257 case IOA_STATE_OPERATIONAL:
2258 default:
2259
2260
2261
2262
2263
2264 if (pinstance->ioa_shutdown_type == SHUTDOWN_NONE &&
2265 pinstance->force_ioa_reset == 0) {
2266 pmcraid_notify_ioastate(pinstance,
2267 PMC_DEVICE_EVENT_RESET_SUCCESS);
2268 reset_complete = 1;
2269 } else {
2270 if (pinstance->ioa_shutdown_type != SHUTDOWN_NONE)
2271 pinstance->ioa_state = IOA_STATE_IN_BRINGDOWN;
2272 pmcraid_reinit_cmdblk(cmd);
2273 pmcraid_unregister_hcams(cmd);
2274 }
2275 break;
2276 }
2277
2278
2279
2280
2281
2282
2283 if (reset_complete) {
2284 pinstance->ioa_reset_in_progress = 0;
2285 pinstance->ioa_reset_attempts = 0;
2286 pinstance->reset_cmd = NULL;
2287 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2288 pinstance->ioa_bringdown = 0;
2289 pmcraid_return_cmd(cmd);
2290
2291
2292
2293
2294 if (pinstance->ioa_state == IOA_STATE_OPERATIONAL)
2295 pmcraid_register_hcams(pinstance);
2296
2297 wake_up_all(&pinstance->reset_wait_q);
2298 }
2299
2300 return;
2301}
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314static void pmcraid_initiate_reset(struct pmcraid_instance *pinstance)
2315{
2316 struct pmcraid_cmd *cmd;
2317
2318
2319
2320
2321 if (!pinstance->ioa_reset_in_progress) {
2322 scsi_block_requests(pinstance->host);
2323 cmd = pmcraid_get_free_cmd(pinstance);
2324
2325 if (cmd == NULL) {
2326 pmcraid_err("no cmnd blocks for initiate_reset\n");
2327 return;
2328 }
2329
2330 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2331 pinstance->reset_cmd = cmd;
2332 pinstance->force_ioa_reset = 1;
2333 pmcraid_notify_ioastate(pinstance,
2334 PMC_DEVICE_EVENT_RESET_START);
2335 pmcraid_ioa_reset(cmd);
2336 }
2337}
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353static int pmcraid_reset_reload(
2354 struct pmcraid_instance *pinstance,
2355 u8 shutdown_type,
2356 u8 target_state
2357)
2358{
2359 struct pmcraid_cmd *reset_cmd = NULL;
2360 unsigned long lock_flags;
2361 int reset = 1;
2362
2363 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2364
2365 if (pinstance->ioa_reset_in_progress) {
2366 pmcraid_info("reset_reload: reset is already in progress\n");
2367
2368 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2369
2370 wait_event(pinstance->reset_wait_q,
2371 !pinstance->ioa_reset_in_progress);
2372
2373 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2374
2375 if (pinstance->ioa_state == IOA_STATE_DEAD) {
2376 pmcraid_info("reset_reload: IOA is dead\n");
2377 goto out_unlock;
2378 }
2379
2380 if (pinstance->ioa_state == target_state) {
2381 reset = 0;
2382 goto out_unlock;
2383 }
2384 }
2385
2386 pmcraid_info("reset_reload: proceeding with reset\n");
2387 scsi_block_requests(pinstance->host);
2388 reset_cmd = pmcraid_get_free_cmd(pinstance);
2389 if (reset_cmd == NULL) {
2390 pmcraid_err("no free cmnd for reset_reload\n");
2391 goto out_unlock;
2392 }
2393
2394 if (shutdown_type == SHUTDOWN_NORMAL)
2395 pinstance->ioa_bringdown = 1;
2396
2397 pinstance->ioa_shutdown_type = shutdown_type;
2398 pinstance->reset_cmd = reset_cmd;
2399 pinstance->force_ioa_reset = reset;
2400 pmcraid_info("reset_reload: initiating reset\n");
2401 pmcraid_ioa_reset(reset_cmd);
2402 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2403 pmcraid_info("reset_reload: waiting for reset to complete\n");
2404 wait_event(pinstance->reset_wait_q,
2405 !pinstance->ioa_reset_in_progress);
2406
2407 pmcraid_info("reset_reload: reset is complete !!\n");
2408 scsi_unblock_requests(pinstance->host);
2409 return pinstance->ioa_state != target_state;
2410
2411out_unlock:
2412 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2413 return reset;
2414}
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424static int pmcraid_reset_bringdown(struct pmcraid_instance *pinstance)
2425{
2426 return pmcraid_reset_reload(pinstance,
2427 SHUTDOWN_NORMAL,
2428 IOA_STATE_UNKNOWN);
2429}
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439static int pmcraid_reset_bringup(struct pmcraid_instance *pinstance)
2440{
2441 pmcraid_notify_ioastate(pinstance, PMC_DEVICE_EVENT_RESET_START);
2442
2443 return pmcraid_reset_reload(pinstance,
2444 SHUTDOWN_NONE,
2445 IOA_STATE_OPERATIONAL);
2446}
2447
2448
2449
2450
2451
2452
2453
2454
2455static void pmcraid_request_sense(struct pmcraid_cmd *cmd)
2456{
2457 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
2458 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
2459
2460
2461 cmd->sense_buffer = pci_alloc_consistent(cmd->drv_inst->pdev,
2462 SCSI_SENSE_BUFFERSIZE,
2463 &cmd->sense_buffer_dma);
2464
2465 if (cmd->sense_buffer == NULL) {
2466 pmcraid_err
2467 ("couldn't allocate sense buffer for request sense\n");
2468 pmcraid_erp_done(cmd);
2469 return;
2470 }
2471
2472
2473 memset(&cmd->ioa_cb->ioasa, 0, sizeof(struct pmcraid_ioasa));
2474 memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
2475 ioarcb->request_flags0 = (SYNC_COMPLETE |
2476 NO_LINK_DESCS |
2477 INHIBIT_UL_CHECK);
2478 ioarcb->request_type = REQ_TYPE_SCSI;
2479 ioarcb->cdb[0] = REQUEST_SENSE;
2480 ioarcb->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2481
2482 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
2483 offsetof(struct pmcraid_ioarcb,
2484 add_data.u.ioadl[0]));
2485 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
2486
2487 ioarcb->data_transfer_length = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);
2488
2489 ioadl->address = cpu_to_le64(cmd->sense_buffer_dma);
2490 ioadl->data_len = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);
2491 ioadl->flags = IOADL_FLAGS_LAST_DESC;
2492
2493
2494
2495
2496
2497
2498 pmcraid_send_cmd(cmd, pmcraid_erp_done,
2499 PMCRAID_REQUEST_SENSE_TIMEOUT,
2500 pmcraid_timeout_handler);
2501}
2502
2503
2504
2505
2506
2507
2508
2509
2510static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, u32 sense)
2511{
2512 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2513 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
2514 struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;
2515 void (*cmd_done) (struct pmcraid_cmd *) = sense ? pmcraid_erp_done
2516 : pmcraid_request_sense;
2517
2518 memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
2519 ioarcb->request_flags0 = SYNC_OVERRIDE;
2520 ioarcb->request_type = REQ_TYPE_IOACMD;
2521 ioarcb->cdb[0] = PMCRAID_CANCEL_ALL_REQUESTS;
2522
2523 if (RES_IS_GSCSI(res->cfg_entry))
2524 ioarcb->cdb[1] = PMCRAID_SYNC_COMPLETE_AFTER_CANCEL;
2525
2526 ioarcb->ioadl_bus_addr = 0;
2527 ioarcb->ioadl_length = 0;
2528 ioarcb->data_transfer_length = 0;
2529 ioarcb->ioarcb_bus_addr &= cpu_to_le64((~0x1FULL));
2530
2531
2532
2533
2534 pmcraid_send_cmd(cmd, cmd_done,
2535 PMCRAID_REQUEST_SENSE_TIMEOUT,
2536 pmcraid_timeout_handler);
2537}
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547static void pmcraid_frame_auto_sense(struct pmcraid_cmd *cmd)
2548{
2549 u8 *sense_buf = cmd->scsi_cmd->sense_buffer;
2550 struct pmcraid_resource_entry *res = cmd->scsi_cmd->device->hostdata;
2551 struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
2552 u32 ioasc = le32_to_cpu(ioasa->ioasc);
2553 u32 failing_lba = 0;
2554
2555 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
2556 cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
2557
2558 if (RES_IS_VSET(res->cfg_entry) &&
2559 ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC &&
2560 ioasa->u.vset.failing_lba_hi != 0) {
2561
2562 sense_buf[0] = 0x72;
2563 sense_buf[1] = PMCRAID_IOASC_SENSE_KEY(ioasc);
2564 sense_buf[2] = PMCRAID_IOASC_SENSE_CODE(ioasc);
2565 sense_buf[3] = PMCRAID_IOASC_SENSE_QUAL(ioasc);
2566
2567 sense_buf[7] = 12;
2568 sense_buf[8] = 0;
2569 sense_buf[9] = 0x0A;
2570 sense_buf[10] = 0x80;
2571
2572 failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_hi);
2573
2574 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
2575 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
2576 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
2577 sense_buf[15] = failing_lba & 0x000000ff;
2578
2579 failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_lo);
2580
2581 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
2582 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
2583 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
2584 sense_buf[19] = failing_lba & 0x000000ff;
2585 } else {
2586 sense_buf[0] = 0x70;
2587 sense_buf[2] = PMCRAID_IOASC_SENSE_KEY(ioasc);
2588 sense_buf[12] = PMCRAID_IOASC_SENSE_CODE(ioasc);
2589 sense_buf[13] = PMCRAID_IOASC_SENSE_QUAL(ioasc);
2590
2591 if (ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC) {
2592 if (RES_IS_VSET(res->cfg_entry))
2593 failing_lba =
2594 le32_to_cpu(ioasa->u.
2595 vset.failing_lba_lo);
2596 sense_buf[0] |= 0x80;
2597 sense_buf[3] = (failing_lba >> 24) & 0xff;
2598 sense_buf[4] = (failing_lba >> 16) & 0xff;
2599 sense_buf[5] = (failing_lba >> 8) & 0xff;
2600 sense_buf[6] = failing_lba & 0xff;
2601 }
2602
2603 sense_buf[7] = 6;
2604 }
2605}
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619static int pmcraid_error_handler(struct pmcraid_cmd *cmd)
2620{
2621 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2622 struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;
2623 struct pmcraid_instance *pinstance = cmd->drv_inst;
2624 struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
2625 u32 ioasc = le32_to_cpu(ioasa->ioasc);
2626 u32 masked_ioasc = ioasc & PMCRAID_IOASC_SENSE_MASK;
2627 u32 sense_copied = 0;
2628
2629 if (!res) {
2630 pmcraid_info("resource pointer is NULL\n");
2631 return 0;
2632 }
2633
2634
2635 if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_READ_CMD)
2636 atomic_inc(&res->read_failures);
2637 else if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_WRITE_CMD)
2638 atomic_inc(&res->write_failures);
2639
2640 if (!RES_IS_GSCSI(res->cfg_entry) &&
2641 masked_ioasc != PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR) {
2642 pmcraid_frame_auto_sense(cmd);
2643 }
2644
2645
2646 pmcraid_ioasc_logger(ioasc, cmd);
2647
2648 switch (masked_ioasc) {
2649
2650 case PMCRAID_IOASC_AC_TERMINATED_BY_HOST:
2651 scsi_cmd->result |= (DID_ABORT << 16);
2652 break;
2653
2654 case PMCRAID_IOASC_IR_INVALID_RESOURCE_HANDLE:
2655 case PMCRAID_IOASC_HW_CANNOT_COMMUNICATE:
2656 scsi_cmd->result |= (DID_NO_CONNECT << 16);
2657 break;
2658
2659 case PMCRAID_IOASC_NR_SYNC_REQUIRED:
2660 res->sync_reqd = 1;
2661 scsi_cmd->result |= (DID_IMM_RETRY << 16);
2662 break;
2663
2664 case PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC:
2665 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
2666 break;
2667
2668 case PMCRAID_IOASC_UA_BUS_WAS_RESET:
2669 case PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER:
2670 if (!res->reset_progress)
2671 scsi_report_bus_reset(pinstance->host,
2672 scsi_cmd->device->channel);
2673 scsi_cmd->result |= (DID_ERROR << 16);
2674 break;
2675
2676 case PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR:
2677 scsi_cmd->result |= PMCRAID_IOASC_SENSE_STATUS(ioasc);
2678 res->sync_reqd = 1;
2679
2680
2681
2682
2683 if (PMCRAID_IOASC_SENSE_STATUS(ioasc) !=
2684 SAM_STAT_CHECK_CONDITION &&
2685 PMCRAID_IOASC_SENSE_STATUS(ioasc) != SAM_STAT_ACA_ACTIVE)
2686 return 0;
2687
2688
2689
2690
2691 if (ioasa->auto_sense_length != 0) {
2692 short sense_len = le16_to_cpu(ioasa->auto_sense_length);
2693 int data_size = min_t(u16, sense_len,
2694 SCSI_SENSE_BUFFERSIZE);
2695
2696 memcpy(scsi_cmd->sense_buffer,
2697 ioasa->sense_data,
2698 data_size);
2699 sense_copied = 1;
2700 }
2701
2702 if (RES_IS_GSCSI(res->cfg_entry))
2703 pmcraid_cancel_all(cmd, sense_copied);
2704 else if (sense_copied)
2705 pmcraid_erp_done(cmd);
2706 else
2707 pmcraid_request_sense(cmd);
2708
2709 return 1;
2710
2711 case PMCRAID_IOASC_NR_INIT_CMD_REQUIRED:
2712 break;
2713
2714 default:
2715 if (PMCRAID_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
2716 scsi_cmd->result |= (DID_ERROR << 16);
2717 break;
2718 }
2719 return 0;
2720}
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735static int pmcraid_reset_device(
2736 struct scsi_cmnd *scsi_cmd,
2737 unsigned long timeout,
2738 u8 modifier
2739)
2740{
2741 struct pmcraid_cmd *cmd;
2742 struct pmcraid_instance *pinstance;
2743 struct pmcraid_resource_entry *res;
2744 struct pmcraid_ioarcb *ioarcb;
2745 unsigned long lock_flags;
2746 u32 ioasc;
2747
2748 pinstance =
2749 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
2750 res = scsi_cmd->device->hostdata;
2751
2752 if (!res) {
2753 sdev_printk(KERN_ERR, scsi_cmd->device,
2754 "reset_device: NULL resource pointer\n");
2755 return FAILED;
2756 }
2757
2758
2759
2760
2761
2762 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2763 if (pinstance->ioa_reset_in_progress ||
2764 pinstance->ioa_state == IOA_STATE_DEAD) {
2765 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2766 return FAILED;
2767 }
2768
2769 res->reset_progress = 1;
2770 pmcraid_info("Resetting %s resource with addr %x\n",
2771 ((modifier & RESET_DEVICE_LUN) ? "LUN" :
2772 ((modifier & RESET_DEVICE_TARGET) ? "TARGET" : "BUS")),
2773 le32_to_cpu(res->cfg_entry.resource_address));
2774
2775
2776 cmd = pmcraid_get_free_cmd(pinstance);
2777
2778 if (cmd == NULL) {
2779 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2780 pmcraid_err("%s: no cmd blocks are available\n", __func__);
2781 return FAILED;
2782 }
2783
2784 ioarcb = &cmd->ioa_cb->ioarcb;
2785 ioarcb->resource_handle = res->cfg_entry.resource_handle;
2786 ioarcb->request_type = REQ_TYPE_IOACMD;
2787 ioarcb->cdb[0] = PMCRAID_RESET_DEVICE;
2788
2789
2790 if (modifier)
2791 modifier = ENABLE_RESET_MODIFIER | modifier;
2792
2793 ioarcb->cdb[1] = modifier;
2794
2795 init_completion(&cmd->wait_for_completion);
2796 cmd->completion_req = 1;
2797
2798 pmcraid_info("cmd(CDB[0] = %x) for %x with index = %d\n",
2799 cmd->ioa_cb->ioarcb.cdb[0],
2800 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),
2801 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);
2802
2803 pmcraid_send_cmd(cmd,
2804 pmcraid_internal_done,
2805 timeout,
2806 pmcraid_timeout_handler);
2807
2808 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2809
2810
2811
2812
2813
2814 wait_for_completion(&cmd->wait_for_completion);
2815
2816
2817
2818
2819 pmcraid_return_cmd(cmd);
2820 res->reset_progress = 0;
2821 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
2822
2823
2824 return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
2825}
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843static int _pmcraid_io_done(struct pmcraid_cmd *cmd, int reslen, int ioasc)
2844{
2845 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2846 int rc = 0;
2847
2848 scsi_set_resid(scsi_cmd, reslen);
2849
2850 pmcraid_info("response(%d) CDB[0] = %x ioasc:result: %x:%x\n",
2851 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
2852 cmd->ioa_cb->ioarcb.cdb[0],
2853 ioasc, scsi_cmd->result);
2854
2855 if (PMCRAID_IOASC_SENSE_KEY(ioasc) != 0)
2856 rc = pmcraid_error_handler(cmd);
2857
2858 if (rc == 0) {
2859 scsi_dma_unmap(scsi_cmd);
2860 scsi_cmd->scsi_done(scsi_cmd);
2861 }
2862
2863 return rc;
2864}
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878static void pmcraid_io_done(struct pmcraid_cmd *cmd)
2879{
2880 u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
2881 u32 reslen = le32_to_cpu(cmd->ioa_cb->ioasa.residual_data_length);
2882
2883 if (_pmcraid_io_done(cmd, reslen, ioasc) == 0)
2884 pmcraid_return_cmd(cmd);
2885}
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895static struct pmcraid_cmd *pmcraid_abort_cmd(struct pmcraid_cmd *cmd)
2896{
2897 struct pmcraid_cmd *cancel_cmd;
2898 struct pmcraid_instance *pinstance;
2899 struct pmcraid_resource_entry *res;
2900
2901 pinstance = (struct pmcraid_instance *)cmd->drv_inst;
2902 res = cmd->scsi_cmd->device->hostdata;
2903
2904 cancel_cmd = pmcraid_get_free_cmd(pinstance);
2905
2906 if (cancel_cmd == NULL) {
2907 pmcraid_err("%s: no cmd blocks are available\n", __func__);
2908 return NULL;
2909 }
2910
2911 pmcraid_prepare_cancel_cmd(cancel_cmd, cmd);
2912
2913 pmcraid_info("aborting command CDB[0]= %x with index = %d\n",
2914 cmd->ioa_cb->ioarcb.cdb[0],
2915 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);
2916
2917 init_completion(&cancel_cmd->wait_for_completion);
2918 cancel_cmd->completion_req = 1;
2919
2920 pmcraid_info("command (%d) CDB[0] = %x for %x\n",
2921 le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.response_handle) >> 2,
2922 cancel_cmd->ioa_cb->ioarcb.cdb[0],
2923 le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.resource_handle));
2924
2925 pmcraid_send_cmd(cancel_cmd,
2926 pmcraid_internal_done,
2927 PMCRAID_INTERNAL_TIMEOUT,
2928 pmcraid_timeout_handler);
2929 return cancel_cmd;
2930}
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941static int pmcraid_abort_complete(struct pmcraid_cmd *cancel_cmd)
2942{
2943 struct pmcraid_resource_entry *res;
2944 u32 ioasc;
2945
2946 wait_for_completion(&cancel_cmd->wait_for_completion);
2947 res = cancel_cmd->res;
2948 cancel_cmd->res = NULL;
2949 ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc);
2950
2951
2952
2953
2954
2955
2956 if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||
2957 ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED) {
2958 if (ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED)
2959 res->sync_reqd = 1;
2960 ioasc = 0;
2961 }
2962
2963
2964 pmcraid_return_cmd(cancel_cmd);
2965 return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
2966}
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd)
2979{
2980 struct pmcraid_instance *pinstance;
2981 struct pmcraid_cmd *cmd;
2982 struct pmcraid_resource_entry *res;
2983 unsigned long host_lock_flags;
2984 unsigned long pending_lock_flags;
2985 struct pmcraid_cmd *cancel_cmd = NULL;
2986 int cmd_found = 0;
2987 int rc = FAILED;
2988
2989 pinstance =
2990 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
2991
2992 scmd_printk(KERN_INFO, scsi_cmd,
2993 "I/O command timed out, aborting it.\n");
2994
2995 res = scsi_cmd->device->hostdata;
2996
2997 if (res == NULL)
2998 return rc;
2999
3000
3001
3002
3003
3004
3005 spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags);
3006
3007 if (pinstance->ioa_reset_in_progress ||
3008 pinstance->ioa_state == IOA_STATE_DEAD) {
3009 spin_unlock_irqrestore(pinstance->host->host_lock,
3010 host_lock_flags);
3011 return rc;
3012 }
3013
3014
3015
3016
3017
3018
3019 spin_lock_irqsave(&pinstance->pending_pool_lock, pending_lock_flags);
3020 list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) {
3021
3022 if (cmd->scsi_cmd == scsi_cmd) {
3023 cmd_found = 1;
3024 break;
3025 }
3026 }
3027
3028 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
3029 pending_lock_flags);
3030
3031
3032
3033
3034 if (cmd_found)
3035 cancel_cmd = pmcraid_abort_cmd(cmd);
3036
3037 spin_unlock_irqrestore(pinstance->host->host_lock,
3038 host_lock_flags);
3039
3040 if (cancel_cmd) {
3041 cancel_cmd->res = cmd->scsi_cmd->device->hostdata;
3042 rc = pmcraid_abort_complete(cancel_cmd);
3043 }
3044
3045 return cmd_found ? rc : SUCCESS;
3046}
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062static int pmcraid_eh_device_reset_handler(struct scsi_cmnd *scmd)
3063{
3064 scmd_printk(KERN_INFO, scmd,
3065 "resetting device due to an I/O command timeout.\n");
3066 return pmcraid_reset_device(scmd,
3067 PMCRAID_INTERNAL_TIMEOUT,
3068 RESET_DEVICE_LUN);
3069}
3070
3071static int pmcraid_eh_bus_reset_handler(struct scsi_cmnd *scmd)
3072{
3073 scmd_printk(KERN_INFO, scmd,
3074 "Doing bus reset due to an I/O command timeout.\n");
3075 return pmcraid_reset_device(scmd,
3076 PMCRAID_RESET_BUS_TIMEOUT,
3077 RESET_DEVICE_BUS);
3078}
3079
3080static int pmcraid_eh_target_reset_handler(struct scsi_cmnd *scmd)
3081{
3082 scmd_printk(KERN_INFO, scmd,
3083 "Doing target reset due to an I/O command timeout.\n");
3084 return pmcraid_reset_device(scmd,
3085 PMCRAID_INTERNAL_TIMEOUT,
3086 RESET_DEVICE_TARGET);
3087}
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099static int pmcraid_eh_host_reset_handler(struct scsi_cmnd *scmd)
3100{
3101 unsigned long interval = 10000;
3102 int waits = jiffies_to_msecs(PMCRAID_RESET_HOST_TIMEOUT) / interval;
3103 struct pmcraid_instance *pinstance =
3104 (struct pmcraid_instance *)(scmd->device->host->hostdata);
3105
3106
3107
3108
3109
3110
3111 while (waits--) {
3112 if (atomic_read(&pinstance->outstanding_cmds) <=
3113 PMCRAID_MAX_HCAM_CMD)
3114 return SUCCESS;
3115 msleep(interval);
3116 }
3117
3118 dev_err(&pinstance->pdev->dev,
3119 "Adapter being reset due to an I/O command timeout.\n");
3120 return pmcraid_reset_bringup(pinstance) == 0 ? SUCCESS : FAILED;
3121}
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132static struct pmcraid_ioadl_desc *
3133pmcraid_init_ioadls(struct pmcraid_cmd *cmd, int sgcount)
3134{
3135 struct pmcraid_ioadl_desc *ioadl;
3136 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3137 int ioadl_count = 0;
3138
3139 if (ioarcb->add_cmd_param_length)
3140 ioadl_count = DIV_ROUND_UP(le16_to_cpu(ioarcb->add_cmd_param_length), 16);
3141 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc) * sgcount);
3142
3143 if ((sgcount + ioadl_count) > (ARRAY_SIZE(ioarcb->add_data.u.ioadl))) {
3144
3145
3146
3147
3148
3149 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL));
3150 ioarcb->ioadl_bus_addr =
3151 cpu_to_le64((cmd->ioa_cb_bus_addr) +
3152 offsetof(struct pmcraid_ioarcb,
3153 add_data.u.ioadl[3]));
3154 ioadl = &ioarcb->add_data.u.ioadl[3];
3155 } else {
3156 ioarcb->ioadl_bus_addr =
3157 cpu_to_le64((cmd->ioa_cb_bus_addr) +
3158 offsetof(struct pmcraid_ioarcb,
3159 add_data.u.ioadl[ioadl_count]));
3160
3161 ioadl = &ioarcb->add_data.u.ioadl[ioadl_count];
3162 ioarcb->ioarcb_bus_addr |=
3163 cpu_to_le64(DIV_ROUND_CLOSEST(sgcount + ioadl_count, 8));
3164 }
3165
3166 return ioadl;
3167}
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180static int pmcraid_build_ioadl(
3181 struct pmcraid_instance *pinstance,
3182 struct pmcraid_cmd *cmd
3183)
3184{
3185 int i, nseg;
3186 struct scatterlist *sglist;
3187
3188 struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
3189 struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
3190 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
3191
3192 u32 length = scsi_bufflen(scsi_cmd);
3193
3194 if (!length)
3195 return 0;
3196
3197 nseg = scsi_dma_map(scsi_cmd);
3198
3199 if (nseg < 0) {
3200 scmd_printk(KERN_ERR, scsi_cmd, "scsi_map_dma failed!\n");
3201 return -1;
3202 } else if (nseg > PMCRAID_MAX_IOADLS) {
3203 scsi_dma_unmap(scsi_cmd);
3204 scmd_printk(KERN_ERR, scsi_cmd,
3205 "sg count is (%d) more than allowed!\n", nseg);
3206 return -1;
3207 }
3208
3209
3210 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE)
3211 ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;
3212
3213 ioarcb->request_flags0 |= NO_LINK_DESCS;
3214 ioarcb->data_transfer_length = cpu_to_le32(length);
3215 ioadl = pmcraid_init_ioadls(cmd, nseg);
3216
3217
3218 scsi_for_each_sg(scsi_cmd, sglist, nseg, i) {
3219 ioadl[i].data_len = cpu_to_le32(sg_dma_len(sglist));
3220 ioadl[i].address = cpu_to_le64(sg_dma_address(sglist));
3221 ioadl[i].flags = 0;
3222 }
3223
3224 ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
3225
3226 return 0;
3227}
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238static void pmcraid_free_sglist(struct pmcraid_sglist *sglist)
3239{
3240 int i;
3241
3242 for (i = 0; i < sglist->num_sg; i++)
3243 __free_pages(sg_page(&(sglist->scatterlist[i])),
3244 sglist->order);
3245
3246 kfree(sglist);
3247}
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259static struct pmcraid_sglist *pmcraid_alloc_sglist(int buflen)
3260{
3261 struct pmcraid_sglist *sglist;
3262 struct scatterlist *scatterlist;
3263 struct page *page;
3264 int num_elem, i, j;
3265 int sg_size;
3266 int order;
3267 int bsize_elem;
3268
3269 sg_size = buflen / (PMCRAID_MAX_IOADLS - 1);
3270 order = (sg_size > 0) ? get_order(sg_size) : 0;
3271 bsize_elem = PAGE_SIZE * (1 << order);
3272
3273
3274 if (buflen % bsize_elem)
3275 num_elem = (buflen / bsize_elem) + 1;
3276 else
3277 num_elem = buflen / bsize_elem;
3278
3279
3280 sglist = kzalloc(sizeof(struct pmcraid_sglist) +
3281 (sizeof(struct scatterlist) * (num_elem - 1)),
3282 GFP_KERNEL);
3283
3284 if (sglist == NULL)
3285 return NULL;
3286
3287 scatterlist = sglist->scatterlist;
3288 sg_init_table(scatterlist, num_elem);
3289 sglist->order = order;
3290 sglist->num_sg = num_elem;
3291 sg_size = buflen;
3292
3293 for (i = 0; i < num_elem; i++) {
3294 page = alloc_pages(GFP_KERNEL|GFP_DMA|__GFP_ZERO, order);
3295 if (!page) {
3296 for (j = i - 1; j >= 0; j--)
3297 __free_pages(sg_page(&scatterlist[j]), order);
3298 kfree(sglist);
3299 return NULL;
3300 }
3301
3302 sg_set_page(&scatterlist[i], page,
3303 sg_size < bsize_elem ? sg_size : bsize_elem, 0);
3304 sg_size -= bsize_elem;
3305 }
3306
3307 return sglist;
3308}
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322static int pmcraid_copy_sglist(
3323 struct pmcraid_sglist *sglist,
3324 void __user *buffer,
3325 u32 len,
3326 int direction
3327)
3328{
3329 struct scatterlist *scatterlist;
3330 void *kaddr;
3331 int bsize_elem;
3332 int i;
3333 int rc = 0;
3334
3335
3336 bsize_elem = PAGE_SIZE * (1 << sglist->order);
3337
3338 scatterlist = sglist->scatterlist;
3339
3340 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3341 struct page *page = sg_page(&scatterlist[i]);
3342
3343 kaddr = kmap(page);
3344 if (direction == DMA_TO_DEVICE)
3345 rc = copy_from_user(kaddr, buffer, bsize_elem);
3346 else
3347 rc = copy_to_user(buffer, kaddr, bsize_elem);
3348
3349 kunmap(page);
3350
3351 if (rc) {
3352 pmcraid_err("failed to copy user data into sg list\n");
3353 return -EFAULT;
3354 }
3355
3356 scatterlist[i].length = bsize_elem;
3357 }
3358
3359 if (len % bsize_elem) {
3360 struct page *page = sg_page(&scatterlist[i]);
3361
3362 kaddr = kmap(page);
3363
3364 if (direction == DMA_TO_DEVICE)
3365 rc = copy_from_user(kaddr, buffer, len % bsize_elem);
3366 else
3367 rc = copy_to_user(buffer, kaddr, len % bsize_elem);
3368
3369 kunmap(page);
3370
3371 scatterlist[i].length = len % bsize_elem;
3372 }
3373
3374 if (rc) {
3375 pmcraid_err("failed to copy user data into sg list\n");
3376 rc = -EFAULT;
3377 }
3378
3379 return rc;
3380}
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396static int pmcraid_queuecommand_lck(
3397 struct scsi_cmnd *scsi_cmd,
3398 void (*done) (struct scsi_cmnd *)
3399)
3400{
3401 struct pmcraid_instance *pinstance;
3402 struct pmcraid_resource_entry *res;
3403 struct pmcraid_ioarcb *ioarcb;
3404 struct pmcraid_cmd *cmd;
3405 u32 fw_version;
3406 int rc = 0;
3407
3408 pinstance =
3409 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
3410 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
3411 scsi_cmd->scsi_done = done;
3412 res = scsi_cmd->device->hostdata;
3413 scsi_cmd->result = (DID_OK << 16);
3414
3415
3416
3417
3418 if (pinstance->ioa_state == IOA_STATE_DEAD) {
3419 pmcraid_info("IOA is dead, but queuecommand is scheduled\n");
3420 scsi_cmd->result = (DID_NO_CONNECT << 16);
3421 scsi_cmd->scsi_done(scsi_cmd);
3422 return 0;
3423 }
3424
3425
3426 if (pinstance->ioa_reset_in_progress)
3427 return SCSI_MLQUEUE_HOST_BUSY;
3428
3429
3430
3431
3432 if (scsi_cmd->cmnd[0] == SYNCHRONIZE_CACHE) {
3433 pmcraid_info("SYNC_CACHE(0x35), completing in driver itself\n");
3434 scsi_cmd->scsi_done(scsi_cmd);
3435 return 0;
3436 }
3437
3438
3439 cmd = pmcraid_get_free_cmd(pinstance);
3440
3441 if (cmd == NULL) {
3442 pmcraid_err("free command block is not available\n");
3443 return SCSI_MLQUEUE_HOST_BUSY;
3444 }
3445
3446 cmd->scsi_cmd = scsi_cmd;
3447 ioarcb = &(cmd->ioa_cb->ioarcb);
3448 memcpy(ioarcb->cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
3449 ioarcb->resource_handle = res->cfg_entry.resource_handle;
3450 ioarcb->request_type = REQ_TYPE_SCSI;
3451
3452
3453
3454
3455
3456
3457 ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3458 pinstance->num_hrrq;
3459 cmd->cmd_done = pmcraid_io_done;
3460
3461 if (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry)) {
3462 if (scsi_cmd->underflow == 0)
3463 ioarcb->request_flags0 |= INHIBIT_UL_CHECK;
3464
3465 if (res->sync_reqd) {
3466 ioarcb->request_flags0 |= SYNC_COMPLETE;
3467 res->sync_reqd = 0;
3468 }
3469
3470 ioarcb->request_flags0 |= NO_LINK_DESCS;
3471
3472 if (scsi_cmd->flags & SCMD_TAGGED)
3473 ioarcb->request_flags1 |= TASK_TAG_SIMPLE;
3474
3475 if (RES_IS_GSCSI(res->cfg_entry))
3476 ioarcb->request_flags1 |= DELAY_AFTER_RESET;
3477 }
3478
3479 rc = pmcraid_build_ioadl(pinstance, cmd);
3480
3481 pmcraid_info("command (%d) CDB[0] = %x for %x:%x:%x:%x\n",
3482 le32_to_cpu(ioarcb->response_handle) >> 2,
3483 scsi_cmd->cmnd[0], pinstance->host->unique_id,
3484 RES_IS_VSET(res->cfg_entry) ? PMCRAID_VSET_BUS_ID :
3485 PMCRAID_PHYS_BUS_ID,
3486 RES_IS_VSET(res->cfg_entry) ?
3487 (fw_version <= PMCRAID_FW_VERSION_1 ?
3488 res->cfg_entry.unique_flags1 :
3489 le16_to_cpu(res->cfg_entry.array_id) & 0xFF) :
3490 RES_TARGET(res->cfg_entry.resource_address),
3491 RES_LUN(res->cfg_entry.resource_address));
3492
3493 if (likely(rc == 0)) {
3494 _pmcraid_fire_command(cmd);
3495 } else {
3496 pmcraid_err("queuecommand could not build ioadl\n");
3497 pmcraid_return_cmd(cmd);
3498 rc = SCSI_MLQUEUE_HOST_BUSY;
3499 }
3500
3501 return rc;
3502}
3503
3504static DEF_SCSI_QCMD(pmcraid_queuecommand)
3505
3506
3507
3508
3509static int pmcraid_chr_open(struct inode *inode, struct file *filep)
3510{
3511 struct pmcraid_instance *pinstance;
3512
3513 if (!capable(CAP_SYS_ADMIN))
3514 return -EACCES;
3515
3516
3517 pinstance = container_of(inode->i_cdev, struct pmcraid_instance, cdev);
3518 filep->private_data = pinstance;
3519
3520 return 0;
3521}
3522
3523
3524
3525
3526
3527
3528
3529static int pmcraid_chr_fasync(int fd, struct file *filep, int mode)
3530{
3531 struct pmcraid_instance *pinstance;
3532 int rc;
3533
3534 pinstance = filep->private_data;
3535 mutex_lock(&pinstance->aen_queue_lock);
3536 rc = fasync_helper(fd, filep, mode, &pinstance->aen_queue);
3537 mutex_unlock(&pinstance->aen_queue_lock);
3538
3539 return rc;
3540}
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554static int pmcraid_build_passthrough_ioadls(
3555 struct pmcraid_cmd *cmd,
3556 int buflen,
3557 int direction
3558)
3559{
3560 struct pmcraid_sglist *sglist = NULL;
3561 struct scatterlist *sg = NULL;
3562 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3563 struct pmcraid_ioadl_desc *ioadl;
3564 int i;
3565
3566 sglist = pmcraid_alloc_sglist(buflen);
3567
3568 if (!sglist) {
3569 pmcraid_err("can't allocate memory for passthrough SGls\n");
3570 return -ENOMEM;
3571 }
3572
3573 sglist->num_dma_sg = pci_map_sg(cmd->drv_inst->pdev,
3574 sglist->scatterlist,
3575 sglist->num_sg, direction);
3576
3577 if (!sglist->num_dma_sg || sglist->num_dma_sg > PMCRAID_MAX_IOADLS) {
3578 dev_err(&cmd->drv_inst->pdev->dev,
3579 "Failed to map passthrough buffer!\n");
3580 pmcraid_free_sglist(sglist);
3581 return -EIO;
3582 }
3583
3584 cmd->sglist = sglist;
3585 ioarcb->request_flags0 |= NO_LINK_DESCS;
3586
3587 ioadl = pmcraid_init_ioadls(cmd, sglist->num_dma_sg);
3588
3589
3590 for_each_sg(sglist->scatterlist, sg, sglist->num_dma_sg, i) {
3591 ioadl[i].data_len = cpu_to_le32(sg_dma_len(sg));
3592 ioadl[i].address = cpu_to_le64(sg_dma_address(sg));
3593 ioadl[i].flags = 0;
3594 }
3595
3596
3597 ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
3598
3599 return 0;
3600}
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613static void pmcraid_release_passthrough_ioadls(
3614 struct pmcraid_cmd *cmd,
3615 int buflen,
3616 int direction
3617)
3618{
3619 struct pmcraid_sglist *sglist = cmd->sglist;
3620
3621 if (buflen > 0) {
3622 pci_unmap_sg(cmd->drv_inst->pdev,
3623 sglist->scatterlist,
3624 sglist->num_sg,
3625 direction);
3626 pmcraid_free_sglist(sglist);
3627 cmd->sglist = NULL;
3628 }
3629}
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641static long pmcraid_ioctl_passthrough(
3642 struct pmcraid_instance *pinstance,
3643 unsigned int ioctl_cmd,
3644 unsigned int buflen,
3645 void __user *arg
3646)
3647{
3648 struct pmcraid_passthrough_ioctl_buffer *buffer;
3649 struct pmcraid_ioarcb *ioarcb;
3650 struct pmcraid_cmd *cmd;
3651 struct pmcraid_cmd *cancel_cmd;
3652 void __user *request_buffer;
3653 unsigned long request_offset;
3654 unsigned long lock_flags;
3655 void __user *ioasa;
3656 u32 ioasc;
3657 int request_size;
3658 int buffer_size;
3659 u8 access, direction;
3660 int rc = 0;
3661
3662
3663 if (pinstance->ioa_reset_in_progress) {
3664 rc = wait_event_interruptible_timeout(
3665 pinstance->reset_wait_q,
3666 !pinstance->ioa_reset_in_progress,
3667 msecs_to_jiffies(10000));
3668
3669 if (!rc)
3670 return -ETIMEDOUT;
3671 else if (rc < 0)
3672 return -ERESTARTSYS;
3673 }
3674
3675
3676 if (pinstance->ioa_state != IOA_STATE_OPERATIONAL) {
3677 pmcraid_err("IOA is not operational\n");
3678 return -ENOTTY;
3679 }
3680
3681 buffer_size = sizeof(struct pmcraid_passthrough_ioctl_buffer);
3682 buffer = kmalloc(buffer_size, GFP_KERNEL);
3683
3684 if (!buffer) {
3685 pmcraid_err("no memory for passthrough buffer\n");
3686 return -ENOMEM;
3687 }
3688
3689 request_offset =
3690 offsetof(struct pmcraid_passthrough_ioctl_buffer, request_buffer);
3691
3692 request_buffer = arg + request_offset;
3693
3694 rc = copy_from_user(buffer, arg,
3695 sizeof(struct pmcraid_passthrough_ioctl_buffer));
3696
3697 ioasa = arg + offsetof(struct pmcraid_passthrough_ioctl_buffer, ioasa);
3698
3699 if (rc) {
3700 pmcraid_err("ioctl: can't copy passthrough buffer\n");
3701 rc = -EFAULT;
3702 goto out_free_buffer;
3703 }
3704
3705 request_size = le32_to_cpu(buffer->ioarcb.data_transfer_length);
3706
3707 if (buffer->ioarcb.request_flags0 & TRANSFER_DIR_WRITE) {
3708 access = VERIFY_READ;
3709 direction = DMA_TO_DEVICE;
3710 } else {
3711 access = VERIFY_WRITE;
3712 direction = DMA_FROM_DEVICE;
3713 }
3714
3715 if (request_size < 0) {
3716 rc = -EINVAL;
3717 goto out_free_buffer;
3718 }
3719
3720
3721 if (le16_to_cpu(buffer->ioarcb.add_cmd_param_length)
3722 > PMCRAID_ADD_CMD_PARAM_LEN) {
3723 rc = -EINVAL;
3724 goto out_free_buffer;
3725 }
3726
3727 cmd = pmcraid_get_free_cmd(pinstance);
3728
3729 if (!cmd) {
3730 pmcraid_err("free command block is not available\n");
3731 rc = -ENOMEM;
3732 goto out_free_buffer;
3733 }
3734
3735 cmd->scsi_cmd = NULL;
3736 ioarcb = &(cmd->ioa_cb->ioarcb);
3737
3738
3739 ioarcb->resource_handle = buffer->ioarcb.resource_handle;
3740 ioarcb->data_transfer_length = buffer->ioarcb.data_transfer_length;
3741 ioarcb->cmd_timeout = buffer->ioarcb.cmd_timeout;
3742 ioarcb->request_type = buffer->ioarcb.request_type;
3743 ioarcb->request_flags0 = buffer->ioarcb.request_flags0;
3744 ioarcb->request_flags1 = buffer->ioarcb.request_flags1;
3745 memcpy(ioarcb->cdb, buffer->ioarcb.cdb, PMCRAID_MAX_CDB_LEN);
3746
3747 if (buffer->ioarcb.add_cmd_param_length) {
3748 ioarcb->add_cmd_param_length =
3749 buffer->ioarcb.add_cmd_param_length;
3750 ioarcb->add_cmd_param_offset =
3751 buffer->ioarcb.add_cmd_param_offset;
3752 memcpy(ioarcb->add_data.u.add_cmd_params,
3753 buffer->ioarcb.add_data.u.add_cmd_params,
3754 le16_to_cpu(buffer->ioarcb.add_cmd_param_length));
3755 }
3756
3757
3758
3759
3760
3761
3762 ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3763 pinstance->num_hrrq;
3764
3765 if (request_size) {
3766 rc = pmcraid_build_passthrough_ioadls(cmd,
3767 request_size,
3768 direction);
3769 if (rc) {
3770 pmcraid_err("couldn't build passthrough ioadls\n");
3771 goto out_free_cmd;
3772 }
3773 }
3774
3775
3776
3777
3778 if (direction == DMA_TO_DEVICE && request_size > 0) {
3779 rc = pmcraid_copy_sglist(cmd->sglist,
3780 request_buffer,
3781 request_size,
3782 direction);
3783 if (rc) {
3784 pmcraid_err("failed to copy user buffer\n");
3785 goto out_free_sglist;
3786 }
3787 }
3788
3789
3790
3791
3792 cmd->cmd_done = pmcraid_internal_done;
3793 init_completion(&cmd->wait_for_completion);
3794 cmd->completion_req = 1;
3795
3796 pmcraid_info("command(%d) (CDB[0] = %x) for %x\n",
3797 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
3798 cmd->ioa_cb->ioarcb.cdb[0],
3799 le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle));
3800
3801 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3802 _pmcraid_fire_command(cmd);
3803 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3804
3805
3806
3807
3808
3809
3810
3811 buffer->ioarcb.cmd_timeout = 0;
3812
3813
3814
3815
3816
3817 if (buffer->ioarcb.cmd_timeout == 0) {
3818 wait_for_completion(&cmd->wait_for_completion);
3819 } else if (!wait_for_completion_timeout(
3820 &cmd->wait_for_completion,
3821 msecs_to_jiffies(le16_to_cpu(buffer->ioarcb.cmd_timeout) * 1000))) {
3822
3823 pmcraid_info("aborting cmd %d (CDB[0] = %x) due to timeout\n",
3824 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
3825 cmd->ioa_cb->ioarcb.cdb[0]);
3826
3827 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3828 cancel_cmd = pmcraid_abort_cmd(cmd);
3829 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3830
3831 if (cancel_cmd) {
3832 wait_for_completion(&cancel_cmd->wait_for_completion);
3833 ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc);
3834 pmcraid_return_cmd(cancel_cmd);
3835
3836
3837
3838
3839
3840
3841
3842 if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
3843 PMCRAID_IOASC_SENSE_KEY(ioasc) == 0x00) {
3844 if (ioasc != PMCRAID_IOASC_GC_IOARCB_NOTFOUND)
3845 rc = -ETIMEDOUT;
3846 goto out_handle_response;
3847 }
3848 }
3849
3850
3851
3852
3853
3854 if (!wait_for_completion_timeout(
3855 &cmd->wait_for_completion,
3856 msecs_to_jiffies(150 * 1000))) {
3857 pmcraid_reset_bringup(cmd->drv_inst);
3858 rc = -ETIMEDOUT;
3859 }
3860 }
3861
3862out_handle_response:
3863
3864
3865
3866
3867 if (copy_to_user(ioasa, &cmd->ioa_cb->ioasa,
3868 sizeof(struct pmcraid_ioasa))) {
3869 pmcraid_err("failed to copy ioasa buffer to user\n");
3870 rc = -EFAULT;
3871 }
3872
3873
3874
3875
3876 else if (direction == DMA_FROM_DEVICE && request_size > 0) {
3877 rc = pmcraid_copy_sglist(cmd->sglist,
3878 request_buffer,
3879 request_size,
3880 direction);
3881 if (rc) {
3882 pmcraid_err("failed to copy user buffer\n");
3883 rc = -EFAULT;
3884 }
3885 }
3886
3887out_free_sglist:
3888 pmcraid_release_passthrough_ioadls(cmd, request_size, direction);
3889
3890out_free_cmd:
3891 pmcraid_return_cmd(cmd);
3892
3893out_free_buffer:
3894 kfree(buffer);
3895
3896 return rc;
3897}
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913static long pmcraid_ioctl_driver(
3914 struct pmcraid_instance *pinstance,
3915 unsigned int cmd,
3916 unsigned int buflen,
3917 void __user *user_buffer
3918)
3919{
3920 int rc = -ENOSYS;
3921
3922 switch (cmd) {
3923 case PMCRAID_IOCTL_RESET_ADAPTER:
3924 pmcraid_reset_bringup(pinstance);
3925 rc = 0;
3926 break;
3927
3928 default:
3929 break;
3930 }
3931
3932 return rc;
3933}
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947static int pmcraid_check_ioctl_buffer(
3948 int cmd,
3949 void __user *arg,
3950 struct pmcraid_ioctl_header *hdr
3951)
3952{
3953 int rc;
3954
3955 if (copy_from_user(hdr, arg, sizeof(struct pmcraid_ioctl_header))) {
3956 pmcraid_err("couldn't copy ioctl header from user buffer\n");
3957 return -EFAULT;
3958 }
3959
3960
3961 rc = memcmp(hdr->signature,
3962 PMCRAID_IOCTL_SIGNATURE,
3963 sizeof(hdr->signature));
3964 if (rc) {
3965 pmcraid_err("signature verification failed\n");
3966 return -EINVAL;
3967 }
3968
3969 return 0;
3970}
3971
3972
3973
3974
3975static long pmcraid_chr_ioctl(
3976 struct file *filep,
3977 unsigned int cmd,
3978 unsigned long arg
3979)
3980{
3981 struct pmcraid_instance *pinstance = NULL;
3982 struct pmcraid_ioctl_header *hdr = NULL;
3983 void __user *argp = (void __user *)arg;
3984 int retval = -ENOTTY;
3985
3986 hdr = kmalloc(sizeof(struct pmcraid_ioctl_header), GFP_KERNEL);
3987
3988 if (!hdr) {
3989 pmcraid_err("failed to allocate memory for ioctl header\n");
3990 return -ENOMEM;
3991 }
3992
3993 retval = pmcraid_check_ioctl_buffer(cmd, argp, hdr);
3994
3995 if (retval) {
3996 pmcraid_info("chr_ioctl: header check failed\n");
3997 kfree(hdr);
3998 return retval;
3999 }
4000
4001 pinstance = filep->private_data;
4002
4003 if (!pinstance) {
4004 pmcraid_info("adapter instance is not found\n");
4005 kfree(hdr);
4006 return -ENOTTY;
4007 }
4008
4009 switch (_IOC_TYPE(cmd)) {
4010
4011 case PMCRAID_PASSTHROUGH_IOCTL:
4012
4013
4014
4015 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
4016 scsi_block_requests(pinstance->host);
4017
4018 retval = pmcraid_ioctl_passthrough(pinstance, cmd,
4019 hdr->buffer_length, argp);
4020
4021 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
4022 scsi_unblock_requests(pinstance->host);
4023 break;
4024
4025 case PMCRAID_DRIVER_IOCTL:
4026 arg += sizeof(struct pmcraid_ioctl_header);
4027 retval = pmcraid_ioctl_driver(pinstance, cmd,
4028 hdr->buffer_length, argp);
4029 break;
4030
4031 default:
4032 retval = -ENOTTY;
4033 break;
4034 }
4035
4036 kfree(hdr);
4037
4038 return retval;
4039}
4040
4041
4042
4043
4044static const struct file_operations pmcraid_fops = {
4045 .owner = THIS_MODULE,
4046 .open = pmcraid_chr_open,
4047 .fasync = pmcraid_chr_fasync,
4048 .unlocked_ioctl = pmcraid_chr_ioctl,
4049#ifdef CONFIG_COMPAT
4050 .compat_ioctl = pmcraid_chr_ioctl,
4051#endif
4052 .llseek = noop_llseek,
4053};
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066static ssize_t pmcraid_show_log_level(
4067 struct device *dev,
4068 struct device_attribute *attr,
4069 char *buf)
4070{
4071 struct Scsi_Host *shost = class_to_shost(dev);
4072 struct pmcraid_instance *pinstance =
4073 (struct pmcraid_instance *)shost->hostdata;
4074 return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level);
4075}
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086static ssize_t pmcraid_store_log_level(
4087 struct device *dev,
4088 struct device_attribute *attr,
4089 const char *buf,
4090 size_t count
4091)
4092{
4093 struct Scsi_Host *shost;
4094 struct pmcraid_instance *pinstance;
4095 u8 val;
4096
4097 if (kstrtou8(buf, 10, &val))
4098 return -EINVAL;
4099
4100 if (val > 2)
4101 return -EINVAL;
4102
4103 shost = class_to_shost(dev);
4104 pinstance = (struct pmcraid_instance *)shost->hostdata;
4105 pinstance->current_log_level = val;
4106
4107 return strlen(buf);
4108}
4109
4110static struct device_attribute pmcraid_log_level_attr = {
4111 .attr = {
4112 .name = "log_level",
4113 .mode = S_IRUGO | S_IWUSR,
4114 },
4115 .show = pmcraid_show_log_level,
4116 .store = pmcraid_store_log_level,
4117};
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127static ssize_t pmcraid_show_drv_version(
4128 struct device *dev,
4129 struct device_attribute *attr,
4130 char *buf
4131)
4132{
4133 return snprintf(buf, PAGE_SIZE, "version: %s\n",
4134 PMCRAID_DRIVER_VERSION);
4135}
4136
4137static struct device_attribute pmcraid_driver_version_attr = {
4138 .attr = {
4139 .name = "drv_version",
4140 .mode = S_IRUGO,
4141 },
4142 .show = pmcraid_show_drv_version,
4143};
4144
4145
4146
4147
4148
4149
4150
4151
4152
4153static ssize_t pmcraid_show_adapter_id(
4154 struct device *dev,
4155 struct device_attribute *attr,
4156 char *buf
4157)
4158{
4159 struct Scsi_Host *shost = class_to_shost(dev);
4160 struct pmcraid_instance *pinstance =
4161 (struct pmcraid_instance *)shost->hostdata;
4162 u32 adapter_id = (pinstance->pdev->bus->number << 8) |
4163 pinstance->pdev->devfn;
4164 u32 aen_group = pmcraid_event_family.id;
4165
4166 return snprintf(buf, PAGE_SIZE,
4167 "adapter id: %d\nminor: %d\naen group: %d\n",
4168 adapter_id, MINOR(pinstance->cdev.dev), aen_group);
4169}
4170
4171static struct device_attribute pmcraid_adapter_id_attr = {
4172 .attr = {
4173 .name = "adapter_id",
4174 .mode = S_IRUGO,
4175 },
4176 .show = pmcraid_show_adapter_id,
4177};
4178
4179static struct device_attribute *pmcraid_host_attrs[] = {
4180 &pmcraid_log_level_attr,
4181 &pmcraid_driver_version_attr,
4182 &pmcraid_adapter_id_attr,
4183 NULL,
4184};
4185
4186
4187
4188static struct scsi_host_template pmcraid_host_template = {
4189 .module = THIS_MODULE,
4190 .name = PMCRAID_DRIVER_NAME,
4191 .queuecommand = pmcraid_queuecommand,
4192 .eh_abort_handler = pmcraid_eh_abort_handler,
4193 .eh_bus_reset_handler = pmcraid_eh_bus_reset_handler,
4194 .eh_target_reset_handler = pmcraid_eh_target_reset_handler,
4195 .eh_device_reset_handler = pmcraid_eh_device_reset_handler,
4196 .eh_host_reset_handler = pmcraid_eh_host_reset_handler,
4197
4198 .slave_alloc = pmcraid_slave_alloc,
4199 .slave_configure = pmcraid_slave_configure,
4200 .slave_destroy = pmcraid_slave_destroy,
4201 .change_queue_depth = pmcraid_change_queue_depth,
4202 .can_queue = PMCRAID_MAX_IO_CMD,
4203 .this_id = -1,
4204 .sg_tablesize = PMCRAID_MAX_IOADLS,
4205 .max_sectors = PMCRAID_IOA_MAX_SECTORS,
4206 .no_write_same = 1,
4207 .cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN,
4208 .use_clustering = ENABLE_CLUSTERING,
4209 .shost_attrs = pmcraid_host_attrs,
4210 .proc_name = PMCRAID_DRIVER_NAME,
4211};
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id)
4223{
4224 struct pmcraid_isr_param *hrrq_vector;
4225 struct pmcraid_instance *pinstance;
4226 unsigned long lock_flags;
4227 u32 intrs_val;
4228 int hrrq_id;
4229
4230 hrrq_vector = (struct pmcraid_isr_param *)dev_id;
4231 hrrq_id = hrrq_vector->hrrq_id;
4232 pinstance = hrrq_vector->drv_inst;
4233
4234 if (!hrrq_id) {
4235
4236 intrs_val = pmcraid_read_interrupts(pinstance);
4237 if (intrs_val &&
4238 ((ioread32(pinstance->int_regs.host_ioa_interrupt_reg)
4239 & DOORBELL_INTR_MSIX_CLR) == 0)) {
4240
4241
4242
4243
4244
4245 if (intrs_val & PMCRAID_ERROR_INTERRUPTS) {
4246 if (intrs_val & INTRS_IOA_UNIT_CHECK)
4247 pinstance->ioa_unit_check = 1;
4248
4249 pmcraid_err("ISR: error interrupts: %x \
4250 initiating reset\n", intrs_val);
4251 spin_lock_irqsave(pinstance->host->host_lock,
4252 lock_flags);
4253 pmcraid_initiate_reset(pinstance);
4254 spin_unlock_irqrestore(
4255 pinstance->host->host_lock,
4256 lock_flags);
4257 }
4258
4259
4260
4261
4262 if (intrs_val & INTRS_TRANSITION_TO_OPERATIONAL)
4263 pmcraid_clr_trans_op(pinstance);
4264
4265
4266
4267
4268
4269 iowrite32(DOORBELL_INTR_MSIX_CLR,
4270 pinstance->int_regs.host_ioa_interrupt_reg);
4271 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
4272
4273
4274 }
4275 }
4276
4277 tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id]));
4278
4279 return IRQ_HANDLED;
4280}
4281
4282
4283
4284
4285
4286
4287
4288
4289
4290
4291static irqreturn_t pmcraid_isr(int irq, void *dev_id)
4292{
4293 struct pmcraid_isr_param *hrrq_vector;
4294 struct pmcraid_instance *pinstance;
4295 u32 intrs;
4296 unsigned long lock_flags;
4297 int hrrq_id = 0;
4298
4299
4300
4301
4302 if (!dev_id) {
4303 printk(KERN_INFO "%s(): NULL host pointer\n", __func__);
4304 return IRQ_NONE;
4305 }
4306 hrrq_vector = (struct pmcraid_isr_param *)dev_id;
4307 pinstance = hrrq_vector->drv_inst;
4308
4309 intrs = pmcraid_read_interrupts(pinstance);
4310
4311 if (unlikely((intrs & PMCRAID_PCI_INTERRUPTS) == 0))
4312 return IRQ_NONE;
4313
4314
4315
4316
4317
4318 if (intrs & PMCRAID_ERROR_INTERRUPTS) {
4319
4320 if (intrs & INTRS_IOA_UNIT_CHECK)
4321 pinstance->ioa_unit_check = 1;
4322
4323 iowrite32(intrs,
4324 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4325 pmcraid_err("ISR: error interrupts: %x initiating reset\n",
4326 intrs);
4327 intrs = ioread32(
4328 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4329 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
4330 pmcraid_initiate_reset(pinstance);
4331 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
4332 } else {
4333
4334
4335
4336
4337 if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {
4338 pmcraid_clr_trans_op(pinstance);
4339 } else {
4340 iowrite32(intrs,
4341 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4342 ioread32(
4343 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4344
4345 tasklet_schedule(
4346 &(pinstance->isr_tasklet[hrrq_id]));
4347 }
4348 }
4349
4350 return IRQ_HANDLED;
4351}
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363static void pmcraid_worker_function(struct work_struct *workp)
4364{
4365 struct pmcraid_instance *pinstance;
4366 struct pmcraid_resource_entry *res;
4367 struct pmcraid_resource_entry *temp;
4368 struct scsi_device *sdev;
4369 unsigned long lock_flags;
4370 unsigned long host_lock_flags;
4371 u16 fw_version;
4372 u8 bus, target, lun;
4373
4374 pinstance = container_of(workp, struct pmcraid_instance, worker_q);
4375
4376 if (!atomic_read(&pinstance->expose_resources))
4377 return;
4378
4379 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
4380
4381 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
4382 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) {
4383
4384 if (res->change_detected == RES_CHANGE_DEL && res->scsi_dev) {
4385 sdev = res->scsi_dev;
4386
4387
4388
4389
4390 spin_lock_irqsave(pinstance->host->host_lock,
4391 host_lock_flags);
4392 if (!scsi_device_get(sdev)) {
4393 spin_unlock_irqrestore(
4394 pinstance->host->host_lock,
4395 host_lock_flags);
4396 pmcraid_info("deleting %x from midlayer\n",
4397 res->cfg_entry.resource_address);
4398 list_move_tail(&res->queue,
4399 &pinstance->free_res_q);
4400 spin_unlock_irqrestore(
4401 &pinstance->resource_lock,
4402 lock_flags);
4403 scsi_remove_device(sdev);
4404 scsi_device_put(sdev);
4405 spin_lock_irqsave(&pinstance->resource_lock,
4406 lock_flags);
4407 res->change_detected = 0;
4408 } else {
4409 spin_unlock_irqrestore(
4410 pinstance->host->host_lock,
4411 host_lock_flags);
4412 }
4413 }
4414 }
4415
4416 list_for_each_entry(res, &pinstance->used_res_q, queue) {
4417
4418 if (res->change_detected == RES_CHANGE_ADD) {
4419
4420 if (!pmcraid_expose_resource(fw_version,
4421 &res->cfg_entry))
4422 continue;
4423
4424 if (RES_IS_VSET(res->cfg_entry)) {
4425 bus = PMCRAID_VSET_BUS_ID;
4426 if (fw_version <= PMCRAID_FW_VERSION_1)
4427 target = res->cfg_entry.unique_flags1;
4428 else
4429 target = le16_to_cpu(res->cfg_entry.array_id) & 0xFF;
4430 lun = PMCRAID_VSET_LUN_ID;
4431 } else {
4432 bus = PMCRAID_PHYS_BUS_ID;
4433 target =
4434 RES_TARGET(
4435 res->cfg_entry.resource_address);
4436 lun = RES_LUN(res->cfg_entry.resource_address);
4437 }
4438
4439 res->change_detected = 0;
4440 spin_unlock_irqrestore(&pinstance->resource_lock,
4441 lock_flags);
4442 scsi_add_device(pinstance->host, bus, target, lun);
4443 spin_lock_irqsave(&pinstance->resource_lock,
4444 lock_flags);
4445 }
4446 }
4447
4448 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
4449}
4450
4451
4452
4453
4454
4455
4456
4457
4458
4459static void pmcraid_tasklet_function(unsigned long instance)
4460{
4461 struct pmcraid_isr_param *hrrq_vector;
4462 struct pmcraid_instance *pinstance;
4463 unsigned long hrrq_lock_flags;
4464 unsigned long pending_lock_flags;
4465 unsigned long host_lock_flags;
4466 spinlock_t *lockp;
4467 int id;
4468 u32 resp;
4469
4470 hrrq_vector = (struct pmcraid_isr_param *)instance;
4471 pinstance = hrrq_vector->drv_inst;
4472 id = hrrq_vector->hrrq_id;
4473 lockp = &(pinstance->hrrq_lock[id]);
4474
4475
4476
4477
4478
4479
4480
4481 spin_lock_irqsave(lockp, hrrq_lock_flags);
4482
4483 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4484
4485 while ((resp & HRRQ_TOGGLE_BIT) ==
4486 pinstance->host_toggle_bit[id]) {
4487
4488 int cmd_index = resp >> 2;
4489 struct pmcraid_cmd *cmd = NULL;
4490
4491 if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) {
4492 pinstance->hrrq_curr[id]++;
4493 } else {
4494 pinstance->hrrq_curr[id] = pinstance->hrrq_start[id];
4495 pinstance->host_toggle_bit[id] ^= 1u;
4496 }
4497
4498 if (cmd_index >= PMCRAID_MAX_CMD) {
4499
4500 pmcraid_err("Invalid response handle %d\n", cmd_index);
4501 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4502 continue;
4503 }
4504
4505 cmd = pinstance->cmd_list[cmd_index];
4506 spin_unlock_irqrestore(lockp, hrrq_lock_flags);
4507
4508 spin_lock_irqsave(&pinstance->pending_pool_lock,
4509 pending_lock_flags);
4510 list_del(&cmd->free_list);
4511 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
4512 pending_lock_flags);
4513 del_timer(&cmd->timer);
4514 atomic_dec(&pinstance->outstanding_cmds);
4515
4516 if (cmd->cmd_done == pmcraid_ioa_reset) {
4517 spin_lock_irqsave(pinstance->host->host_lock,
4518 host_lock_flags);
4519 cmd->cmd_done(cmd);
4520 spin_unlock_irqrestore(pinstance->host->host_lock,
4521 host_lock_flags);
4522 } else if (cmd->cmd_done != NULL) {
4523 cmd->cmd_done(cmd);
4524 }
4525
4526 spin_lock_irqsave(lockp, hrrq_lock_flags);
4527 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4528 }
4529
4530 spin_unlock_irqrestore(lockp, hrrq_lock_flags);
4531}
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543static
4544void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance)
4545{
4546 struct pci_dev *pdev = pinstance->pdev;
4547 int i;
4548
4549 for (i = 0; i < pinstance->num_hrrq; i++)
4550 free_irq(pci_irq_vector(pdev, i), &pinstance->hrrq_vector[i]);
4551
4552 pinstance->interrupt_mode = 0;
4553 pci_free_irq_vectors(pdev);
4554}
4555
4556
4557
4558
4559
4560
4561
4562
4563static int
4564pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance)
4565{
4566 struct pci_dev *pdev = pinstance->pdev;
4567 unsigned int irq_flag = PCI_IRQ_LEGACY, flag;
4568 int num_hrrq, rc, i;
4569 irq_handler_t isr;
4570
4571 if (pmcraid_enable_msix)
4572 irq_flag |= PCI_IRQ_MSIX;
4573
4574 num_hrrq = pci_alloc_irq_vectors(pdev, 1, PMCRAID_NUM_MSIX_VECTORS,
4575 irq_flag);
4576 if (num_hrrq < 0)
4577 return num_hrrq;
4578
4579 if (pdev->msix_enabled) {
4580 flag = 0;
4581 isr = pmcraid_isr_msix;
4582 } else {
4583 flag = IRQF_SHARED;
4584 isr = pmcraid_isr;
4585 }
4586
4587 for (i = 0; i < num_hrrq; i++) {
4588 struct pmcraid_isr_param *vec = &pinstance->hrrq_vector[i];
4589
4590 vec->hrrq_id = i;
4591 vec->drv_inst = pinstance;
4592 rc = request_irq(pci_irq_vector(pdev, i), isr, flag,
4593 PMCRAID_DRIVER_NAME, vec);
4594 if (rc)
4595 goto out_unwind;
4596 }
4597
4598 pinstance->num_hrrq = num_hrrq;
4599 if (pdev->msix_enabled) {
4600 pinstance->interrupt_mode = 1;
4601 iowrite32(DOORBELL_INTR_MODE_MSIX,
4602 pinstance->int_regs.host_ioa_interrupt_reg);
4603 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
4604 }
4605
4606 return 0;
4607
4608out_unwind:
4609 while (--i > 0)
4610 free_irq(pci_irq_vector(pdev, i), &pinstance->hrrq_vector[i]);
4611 pci_free_irq_vectors(pdev);
4612 return rc;
4613}
4614
4615
4616
4617
4618
4619
4620
4621
4622
4623static void
4624pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index)
4625{
4626 int i;
4627 for (i = 0; i < max_index; i++) {
4628 kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]);
4629 pinstance->cmd_list[i] = NULL;
4630 }
4631 kmem_cache_destroy(pinstance->cmd_cachep);
4632 pinstance->cmd_cachep = NULL;
4633}
4634
4635
4636
4637
4638
4639
4640
4641
4642
4643
4644
4645
4646static void
4647pmcraid_release_control_blocks(
4648 struct pmcraid_instance *pinstance,
4649 int max_index
4650)
4651{
4652 int i;
4653
4654 if (pinstance->control_pool == NULL)
4655 return;
4656
4657 for (i = 0; i < max_index; i++) {
4658 pci_pool_free(pinstance->control_pool,
4659 pinstance->cmd_list[i]->ioa_cb,
4660 pinstance->cmd_list[i]->ioa_cb_bus_addr);
4661 pinstance->cmd_list[i]->ioa_cb = NULL;
4662 pinstance->cmd_list[i]->ioa_cb_bus_addr = 0;
4663 }
4664 pci_pool_destroy(pinstance->control_pool);
4665 pinstance->control_pool = NULL;
4666}
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677static int pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance)
4678{
4679 int i;
4680
4681 sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d",
4682 pinstance->host->unique_id);
4683
4684
4685 pinstance->cmd_cachep = kmem_cache_create(
4686 pinstance->cmd_pool_name,
4687 sizeof(struct pmcraid_cmd), 0,
4688 SLAB_HWCACHE_ALIGN, NULL);
4689 if (!pinstance->cmd_cachep)
4690 return -ENOMEM;
4691
4692 for (i = 0; i < PMCRAID_MAX_CMD; i++) {
4693 pinstance->cmd_list[i] =
4694 kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL);
4695 if (!pinstance->cmd_list[i]) {
4696 pmcraid_release_cmd_blocks(pinstance, i);
4697 return -ENOMEM;
4698 }
4699 }
4700 return 0;
4701}
4702
4703
4704
4705
4706
4707
4708
4709
4710
4711
4712
4713static int pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance)
4714{
4715 int i;
4716
4717 sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d",
4718 pinstance->host->unique_id);
4719
4720 pinstance->control_pool =
4721 pci_pool_create(pinstance->ctl_pool_name,
4722 pinstance->pdev,
4723 sizeof(struct pmcraid_control_block),
4724 PMCRAID_IOARCB_ALIGNMENT, 0);
4725
4726 if (!pinstance->control_pool)
4727 return -ENOMEM;
4728
4729 for (i = 0; i < PMCRAID_MAX_CMD; i++) {
4730 pinstance->cmd_list[i]->ioa_cb =
4731 pci_pool_alloc(
4732 pinstance->control_pool,
4733 GFP_KERNEL,
4734 &(pinstance->cmd_list[i]->ioa_cb_bus_addr));
4735
4736 if (!pinstance->cmd_list[i]->ioa_cb) {
4737 pmcraid_release_control_blocks(pinstance, i);
4738 return -ENOMEM;
4739 }
4740 memset(pinstance->cmd_list[i]->ioa_cb, 0,
4741 sizeof(struct pmcraid_control_block));
4742 }
4743 return 0;
4744}
4745
4746
4747
4748
4749
4750
4751
4752
4753
4754static void
4755pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex)
4756{
4757 int i;
4758 for (i = 0; i < maxindex; i++) {
4759
4760 pci_free_consistent(pinstance->pdev,
4761 HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD,
4762 pinstance->hrrq_start[i],
4763 pinstance->hrrq_start_bus_addr[i]);
4764
4765
4766 pinstance->hrrq_start[i] = NULL;
4767 pinstance->hrrq_start_bus_addr[i] = 0;
4768 pinstance->host_toggle_bit[i] = 0;
4769 }
4770}
4771
4772
4773
4774
4775
4776
4777
4778
4779static int pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance)
4780{
4781 int i, buffer_size;
4782
4783 buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;
4784
4785 for (i = 0; i < pinstance->num_hrrq; i++) {
4786 pinstance->hrrq_start[i] =
4787 pci_alloc_consistent(
4788 pinstance->pdev,
4789 buffer_size,
4790 &(pinstance->hrrq_start_bus_addr[i]));
4791
4792 if (!pinstance->hrrq_start[i]) {
4793 pmcraid_err("pci_alloc failed for hrrq vector : %d\n",
4794 i);
4795 pmcraid_release_host_rrqs(pinstance, i);
4796 return -ENOMEM;
4797 }
4798
4799 memset(pinstance->hrrq_start[i], 0, buffer_size);
4800 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
4801 pinstance->hrrq_end[i] =
4802 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
4803 pinstance->host_toggle_bit[i] = 1;
4804 spin_lock_init(&pinstance->hrrq_lock[i]);
4805 }
4806 return 0;
4807}
4808
4809
4810
4811
4812
4813
4814
4815
4816
4817static void pmcraid_release_hcams(struct pmcraid_instance *pinstance)
4818{
4819 if (pinstance->ccn.msg != NULL) {
4820 pci_free_consistent(pinstance->pdev,
4821 PMCRAID_AEN_HDR_SIZE +
4822 sizeof(struct pmcraid_hcam_ccn_ext),
4823 pinstance->ccn.msg,
4824 pinstance->ccn.baddr);
4825
4826 pinstance->ccn.msg = NULL;
4827 pinstance->ccn.hcam = NULL;
4828 pinstance->ccn.baddr = 0;
4829 }
4830
4831 if (pinstance->ldn.msg != NULL) {
4832 pci_free_consistent(pinstance->pdev,
4833 PMCRAID_AEN_HDR_SIZE +
4834 sizeof(struct pmcraid_hcam_ldn),
4835 pinstance->ldn.msg,
4836 pinstance->ldn.baddr);
4837
4838 pinstance->ldn.msg = NULL;
4839 pinstance->ldn.hcam = NULL;
4840 pinstance->ldn.baddr = 0;
4841 }
4842}
4843
4844
4845
4846
4847
4848
4849
4850
4851static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance)
4852{
4853 pinstance->ccn.msg = pci_alloc_consistent(
4854 pinstance->pdev,
4855 PMCRAID_AEN_HDR_SIZE +
4856 sizeof(struct pmcraid_hcam_ccn_ext),
4857 &(pinstance->ccn.baddr));
4858
4859 pinstance->ldn.msg = pci_alloc_consistent(
4860 pinstance->pdev,
4861 PMCRAID_AEN_HDR_SIZE +
4862 sizeof(struct pmcraid_hcam_ldn),
4863 &(pinstance->ldn.baddr));
4864
4865 if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) {
4866 pmcraid_release_hcams(pinstance);
4867 } else {
4868 pinstance->ccn.hcam =
4869 (void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE;
4870 pinstance->ldn.hcam =
4871 (void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE;
4872
4873 atomic_set(&pinstance->ccn.ignore, 0);
4874 atomic_set(&pinstance->ldn.ignore, 0);
4875 }
4876
4877 return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0;
4878}
4879
4880
4881
4882
4883
4884
4885
4886
4887static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance)
4888{
4889 if (pinstance->cfg_table != NULL &&
4890 pinstance->cfg_table_bus_addr != 0) {
4891 pci_free_consistent(pinstance->pdev,
4892 sizeof(struct pmcraid_config_table),
4893 pinstance->cfg_table,
4894 pinstance->cfg_table_bus_addr);
4895 pinstance->cfg_table = NULL;
4896 pinstance->cfg_table_bus_addr = 0;
4897 }
4898
4899 if (pinstance->res_entries != NULL) {
4900 int i;
4901
4902 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)
4903 list_del(&pinstance->res_entries[i].queue);
4904 kfree(pinstance->res_entries);
4905 pinstance->res_entries = NULL;
4906 }
4907
4908 pmcraid_release_hcams(pinstance);
4909}
4910
4911
4912
4913
4914
4915
4916
4917
4918static int pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance)
4919{
4920 int i;
4921
4922 pinstance->res_entries =
4923 kzalloc(sizeof(struct pmcraid_resource_entry) *
4924 PMCRAID_MAX_RESOURCES, GFP_KERNEL);
4925
4926 if (NULL == pinstance->res_entries) {
4927 pmcraid_err("failed to allocate memory for resource table\n");
4928 return -ENOMEM;
4929 }
4930
4931 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)
4932 list_add_tail(&pinstance->res_entries[i].queue,
4933 &pinstance->free_res_q);
4934
4935 pinstance->cfg_table =
4936 pci_alloc_consistent(pinstance->pdev,
4937 sizeof(struct pmcraid_config_table),
4938 &pinstance->cfg_table_bus_addr);
4939
4940 if (NULL == pinstance->cfg_table) {
4941 pmcraid_err("couldn't alloc DMA memory for config table\n");
4942 pmcraid_release_config_buffers(pinstance);
4943 return -ENOMEM;
4944 }
4945
4946 if (pmcraid_allocate_hcams(pinstance)) {
4947 pmcraid_err("could not alloc DMA memory for HCAMS\n");
4948 pmcraid_release_config_buffers(pinstance);
4949 return -ENOMEM;
4950 }
4951
4952 return 0;
4953}
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance)
4964{
4965 int i;
4966 for (i = 0; i < pinstance->num_hrrq; i++)
4967 tasklet_init(&pinstance->isr_tasklet[i],
4968 pmcraid_tasklet_function,
4969 (unsigned long)&pinstance->hrrq_vector[i]);
4970}
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance)
4981{
4982 int i;
4983 for (i = 0; i < pinstance->num_hrrq; i++)
4984 tasklet_kill(&pinstance->isr_tasklet[i]);
4985}
4986
4987
4988
4989
4990
4991
4992
4993
4994
4995static void pmcraid_release_buffers(struct pmcraid_instance *pinstance)
4996{
4997 pmcraid_release_config_buffers(pinstance);
4998 pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD);
4999 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
5000 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5001
5002 if (pinstance->inq_data != NULL) {
5003 pci_free_consistent(pinstance->pdev,
5004 sizeof(struct pmcraid_inquiry_data),
5005 pinstance->inq_data,
5006 pinstance->inq_data_baddr);
5007
5008 pinstance->inq_data = NULL;
5009 pinstance->inq_data_baddr = 0;
5010 }
5011
5012 if (pinstance->timestamp_data != NULL) {
5013 pci_free_consistent(pinstance->pdev,
5014 sizeof(struct pmcraid_timestamp_data),
5015 pinstance->timestamp_data,
5016 pinstance->timestamp_data_baddr);
5017
5018 pinstance->timestamp_data = NULL;
5019 pinstance->timestamp_data_baddr = 0;
5020 }
5021}
5022
5023
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036static int pmcraid_init_buffers(struct pmcraid_instance *pinstance)
5037{
5038 int i;
5039
5040 if (pmcraid_allocate_host_rrqs(pinstance)) {
5041 pmcraid_err("couldn't allocate memory for %d host rrqs\n",
5042 pinstance->num_hrrq);
5043 return -ENOMEM;
5044 }
5045
5046 if (pmcraid_allocate_config_buffers(pinstance)) {
5047 pmcraid_err("couldn't allocate memory for config buffers\n");
5048 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5049 return -ENOMEM;
5050 }
5051
5052 if (pmcraid_allocate_cmd_blocks(pinstance)) {
5053 pmcraid_err("couldn't allocate memory for cmd blocks\n");
5054 pmcraid_release_config_buffers(pinstance);
5055 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5056 return -ENOMEM;
5057 }
5058
5059 if (pmcraid_allocate_control_blocks(pinstance)) {
5060 pmcraid_err("couldn't allocate memory control blocks\n");
5061 pmcraid_release_config_buffers(pinstance);
5062 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
5063 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5064 return -ENOMEM;
5065 }
5066
5067
5068 pinstance->inq_data = pci_alloc_consistent(
5069 pinstance->pdev,
5070 sizeof(struct pmcraid_inquiry_data),
5071 &pinstance->inq_data_baddr);
5072
5073 if (pinstance->inq_data == NULL) {
5074 pmcraid_err("couldn't allocate DMA memory for INQUIRY\n");
5075 pmcraid_release_buffers(pinstance);
5076 return -ENOMEM;
5077 }
5078
5079
5080 pinstance->timestamp_data = pci_alloc_consistent(
5081 pinstance->pdev,
5082 sizeof(struct pmcraid_timestamp_data),
5083 &pinstance->timestamp_data_baddr);
5084
5085 if (pinstance->timestamp_data == NULL) {
5086 pmcraid_err("couldn't allocate DMA memory for \
5087 set time_stamp \n");
5088 pmcraid_release_buffers(pinstance);
5089 return -ENOMEM;
5090 }
5091
5092
5093
5094
5095
5096
5097 for (i = 0; i < PMCRAID_MAX_CMD; i++) {
5098 struct pmcraid_cmd *cmdp = pinstance->cmd_list[i];
5099 pmcraid_init_cmdblk(cmdp, i);
5100 cmdp->drv_inst = pinstance;
5101 list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool);
5102 }
5103
5104 return 0;
5105}
5106
5107
5108
5109
5110
5111
5112
5113static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance)
5114{
5115 int i;
5116 int buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;
5117
5118 for (i = 0; i < pinstance->num_hrrq; i++) {
5119 memset(pinstance->hrrq_start[i], 0, buffer_size);
5120 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
5121 pinstance->hrrq_end[i] =
5122 pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
5123 pinstance->host_toggle_bit[i] = 1;
5124 }
5125}
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136static int pmcraid_init_instance(struct pci_dev *pdev, struct Scsi_Host *host,
5137 void __iomem *mapped_pci_addr)
5138{
5139 struct pmcraid_instance *pinstance =
5140 (struct pmcraid_instance *)host->hostdata;
5141
5142 pinstance->host = host;
5143 pinstance->pdev = pdev;
5144
5145
5146 pinstance->mapped_dma_addr = mapped_pci_addr;
5147
5148
5149 {
5150 struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg;
5151 struct pmcraid_interrupts *pint_regs = &pinstance->int_regs;
5152
5153 pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin;
5154
5155 pint_regs->ioa_host_interrupt_reg =
5156 mapped_pci_addr + chip_cfg->ioa_host_intr;
5157 pint_regs->ioa_host_interrupt_clr_reg =
5158 mapped_pci_addr + chip_cfg->ioa_host_intr_clr;
5159 pint_regs->ioa_host_msix_interrupt_reg =
5160 mapped_pci_addr + chip_cfg->ioa_host_msix_intr;
5161 pint_regs->host_ioa_interrupt_reg =
5162 mapped_pci_addr + chip_cfg->host_ioa_intr;
5163 pint_regs->host_ioa_interrupt_clr_reg =
5164 mapped_pci_addr + chip_cfg->host_ioa_intr_clr;
5165
5166
5167
5168
5169 pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox;
5170 pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus;
5171 pint_regs->ioa_host_interrupt_mask_reg =
5172 mapped_pci_addr + chip_cfg->ioa_host_mask;
5173 pint_regs->ioa_host_interrupt_mask_clr_reg =
5174 mapped_pci_addr + chip_cfg->ioa_host_mask_clr;
5175 pint_regs->global_interrupt_mask_reg =
5176 mapped_pci_addr + chip_cfg->global_intr_mask;
5177 };
5178
5179 pinstance->ioa_reset_attempts = 0;
5180 init_waitqueue_head(&pinstance->reset_wait_q);
5181
5182 atomic_set(&pinstance->outstanding_cmds, 0);
5183 atomic_set(&pinstance->last_message_id, 0);
5184 atomic_set(&pinstance->expose_resources, 0);
5185
5186 INIT_LIST_HEAD(&pinstance->free_res_q);
5187 INIT_LIST_HEAD(&pinstance->used_res_q);
5188 INIT_LIST_HEAD(&pinstance->free_cmd_pool);
5189 INIT_LIST_HEAD(&pinstance->pending_cmd_pool);
5190
5191 spin_lock_init(&pinstance->free_pool_lock);
5192 spin_lock_init(&pinstance->pending_pool_lock);
5193 spin_lock_init(&pinstance->resource_lock);
5194 mutex_init(&pinstance->aen_queue_lock);
5195
5196
5197 INIT_WORK(&pinstance->worker_q, pmcraid_worker_function);
5198
5199
5200 pinstance->current_log_level = pmcraid_log_level;
5201
5202
5203 pinstance->ioa_state = IOA_STATE_UNKNOWN;
5204 pinstance->reset_cmd = NULL;
5205 return 0;
5206}
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217static void pmcraid_shutdown(struct pci_dev *pdev)
5218{
5219 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5220 pmcraid_reset_bringdown(pinstance);
5221}
5222
5223
5224
5225
5226
5227static unsigned short pmcraid_get_minor(void)
5228{
5229 int minor;
5230
5231 minor = find_first_zero_bit(pmcraid_minor, sizeof(pmcraid_minor));
5232 __set_bit(minor, pmcraid_minor);
5233 return minor;
5234}
5235
5236
5237
5238
5239static void pmcraid_release_minor(unsigned short minor)
5240{
5241 __clear_bit(minor, pmcraid_minor);
5242}
5243
5244
5245
5246
5247
5248
5249
5250
5251
5252static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance)
5253{
5254 int minor;
5255 int error;
5256
5257 minor = pmcraid_get_minor();
5258 cdev_init(&pinstance->cdev, &pmcraid_fops);
5259 pinstance->cdev.owner = THIS_MODULE;
5260
5261 error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1);
5262
5263 if (error)
5264 pmcraid_release_minor(minor);
5265 else
5266 device_create(pmcraid_class, NULL, MKDEV(pmcraid_major, minor),
5267 NULL, "%s%u", PMCRAID_DEVFILE, minor);
5268 return error;
5269}
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)
5280{
5281 pmcraid_release_minor(MINOR(pinstance->cdev.dev));
5282 device_destroy(pmcraid_class,
5283 MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));
5284 cdev_del(&pinstance->cdev);
5285}
5286
5287
5288
5289
5290
5291
5292
5293
5294static void pmcraid_remove(struct pci_dev *pdev)
5295{
5296 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5297
5298
5299 pmcraid_release_chrdev(pinstance);
5300
5301
5302 scsi_remove_host(pinstance->host);
5303
5304
5305 scsi_block_requests(pinstance->host);
5306
5307
5308 pmcraid_shutdown(pdev);
5309
5310 pmcraid_disable_interrupts(pinstance, ~0);
5311 flush_work(&pinstance->worker_q);
5312
5313 pmcraid_kill_tasklets(pinstance);
5314 pmcraid_unregister_interrupt_handler(pinstance);
5315 pmcraid_release_buffers(pinstance);
5316 iounmap(pinstance->mapped_dma_addr);
5317 pci_release_regions(pdev);
5318 scsi_host_put(pinstance->host);
5319 pci_disable_device(pdev);
5320
5321 return;
5322}
5323
5324#ifdef CONFIG_PM
5325
5326
5327
5328
5329
5330
5331
5332static int pmcraid_suspend(struct pci_dev *pdev, pm_message_t state)
5333{
5334 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5335
5336 pmcraid_shutdown(pdev);
5337 pmcraid_disable_interrupts(pinstance, ~0);
5338 pmcraid_kill_tasklets(pinstance);
5339 pci_set_drvdata(pinstance->pdev, pinstance);
5340 pmcraid_unregister_interrupt_handler(pinstance);
5341 pci_save_state(pdev);
5342 pci_disable_device(pdev);
5343 pci_set_power_state(pdev, pci_choose_state(pdev, state));
5344
5345 return 0;
5346}
5347
5348
5349
5350
5351
5352
5353
5354static int pmcraid_resume(struct pci_dev *pdev)
5355{
5356 struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5357 struct Scsi_Host *host = pinstance->host;
5358 int rc;
5359
5360 pci_set_power_state(pdev, PCI_D0);
5361 pci_enable_wake(pdev, PCI_D0, 0);
5362 pci_restore_state(pdev);
5363
5364 rc = pci_enable_device(pdev);
5365
5366 if (rc) {
5367 dev_err(&pdev->dev, "resume: Enable device failed\n");
5368 return rc;
5369 }
5370
5371 pci_set_master(pdev);
5372
5373 if ((sizeof(dma_addr_t) == 4) ||
5374 pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
5375 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
5376
5377 if (rc == 0)
5378 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
5379
5380 if (rc != 0) {
5381 dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n");
5382 goto disable_device;
5383 }
5384
5385 pmcraid_disable_interrupts(pinstance, ~0);
5386 atomic_set(&pinstance->outstanding_cmds, 0);
5387 rc = pmcraid_register_interrupt_handler(pinstance);
5388
5389 if (rc) {
5390 dev_err(&pdev->dev,
5391 "resume: couldn't register interrupt handlers\n");
5392 rc = -ENODEV;
5393 goto release_host;
5394 }
5395
5396 pmcraid_init_tasklets(pinstance);
5397 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
5398
5399
5400
5401
5402 pinstance->ioa_hard_reset = 1;
5403
5404
5405
5406
5407 if (pmcraid_reset_bringup(pinstance)) {
5408 dev_err(&pdev->dev, "couldn't initialize IOA\n");
5409 rc = -ENODEV;
5410 goto release_tasklets;
5411 }
5412
5413 return 0;
5414
5415release_tasklets:
5416 pmcraid_disable_interrupts(pinstance, ~0);
5417 pmcraid_kill_tasklets(pinstance);
5418 pmcraid_unregister_interrupt_handler(pinstance);
5419
5420release_host:
5421 scsi_host_put(host);
5422
5423disable_device:
5424 pci_disable_device(pdev);
5425
5426 return rc;
5427}
5428
5429#else
5430
5431#define pmcraid_suspend NULL
5432#define pmcraid_resume NULL
5433
5434#endif
5435
5436
5437
5438
5439
5440
5441static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd)
5442{
5443 struct pmcraid_instance *pinstance = cmd->drv_inst;
5444 unsigned long flags;
5445
5446 spin_lock_irqsave(pinstance->host->host_lock, flags);
5447 pmcraid_ioa_reset(cmd);
5448 spin_unlock_irqrestore(pinstance->host->host_lock, flags);
5449 scsi_unblock_requests(pinstance->host);
5450 schedule_work(&pinstance->worker_q);
5451}
5452
5453
5454
5455
5456
5457
5458
5459
5460
5461static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd)
5462{
5463 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5464 void (*cmd_done) (struct pmcraid_cmd *) = pmcraid_complete_ioa_reset;
5465
5466 pmcraid_reinit_cmdblk(cmd);
5467
5468 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
5469 ioarcb->request_type = REQ_TYPE_IOACMD;
5470 ioarcb->cdb[0] = PMCRAID_SET_SUPPORTED_DEVICES;
5471 ioarcb->cdb[1] = ALL_DEVICES_SUPPORTED;
5472
5473
5474
5475
5476
5477 if (cmd->drv_inst->reinit_cfg_table) {
5478 cmd->drv_inst->reinit_cfg_table = 0;
5479 cmd->release = 1;
5480 cmd_done = pmcraid_reinit_cfgtable_done;
5481 }
5482
5483
5484
5485
5486
5487 pmcraid_send_cmd(cmd,
5488 cmd_done,
5489 PMCRAID_SET_SUP_DEV_TIMEOUT,
5490 pmcraid_timeout_handler);
5491 return;
5492}
5493
5494
5495
5496
5497
5498
5499
5500
5501
5502static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd)
5503{
5504 struct pmcraid_instance *pinstance = cmd->drv_inst;
5505 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5506 __be32 time_stamp_len = cpu_to_be32(PMCRAID_TIMESTAMP_LEN);
5507 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
5508 u64 timestamp;
5509
5510 timestamp = ktime_get_real_seconds() * 1000;
5511
5512 pinstance->timestamp_data->timestamp[0] = (__u8)(timestamp);
5513 pinstance->timestamp_data->timestamp[1] = (__u8)((timestamp) >> 8);
5514 pinstance->timestamp_data->timestamp[2] = (__u8)((timestamp) >> 16);
5515 pinstance->timestamp_data->timestamp[3] = (__u8)((timestamp) >> 24);
5516 pinstance->timestamp_data->timestamp[4] = (__u8)((timestamp) >> 32);
5517 pinstance->timestamp_data->timestamp[5] = (__u8)((timestamp) >> 40);
5518
5519 pmcraid_reinit_cmdblk(cmd);
5520 ioarcb->request_type = REQ_TYPE_SCSI;
5521 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
5522 ioarcb->cdb[0] = PMCRAID_SCSI_SET_TIMESTAMP;
5523 ioarcb->cdb[1] = PMCRAID_SCSI_SERVICE_ACTION;
5524 memcpy(&(ioarcb->cdb[6]), &time_stamp_len, sizeof(time_stamp_len));
5525
5526 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
5527 offsetof(struct pmcraid_ioarcb,
5528 add_data.u.ioadl[0]));
5529 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
5530 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL));
5531
5532 ioarcb->request_flags0 |= NO_LINK_DESCS;
5533 ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;
5534 ioarcb->data_transfer_length =
5535 cpu_to_le32(sizeof(struct pmcraid_timestamp_data));
5536 ioadl = &(ioarcb->add_data.u.ioadl[0]);
5537 ioadl->flags = IOADL_FLAGS_LAST_DESC;
5538 ioadl->address = cpu_to_le64(pinstance->timestamp_data_baddr);
5539 ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_timestamp_data));
5540
5541 if (!pinstance->timestamp_error) {
5542 pinstance->timestamp_error = 0;
5543 pmcraid_send_cmd(cmd, pmcraid_set_supported_devs,
5544 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
5545 } else {
5546 pmcraid_send_cmd(cmd, pmcraid_return_cmd,
5547 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
5548 return;
5549 }
5550}
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565static void pmcraid_init_res_table(struct pmcraid_cmd *cmd)
5566{
5567 struct pmcraid_instance *pinstance = cmd->drv_inst;
5568 struct pmcraid_resource_entry *res, *temp;
5569 struct pmcraid_config_table_entry *cfgte;
5570 unsigned long lock_flags;
5571 int found, rc, i;
5572 u16 fw_version;
5573 LIST_HEAD(old_res);
5574
5575 if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED)
5576 pmcraid_err("IOA requires microcode download\n");
5577
5578 fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
5579
5580
5581
5582
5583
5584 spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
5585
5586 list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue)
5587 list_move_tail(&res->queue, &old_res);
5588
5589 for (i = 0; i < le16_to_cpu(pinstance->cfg_table->num_entries); i++) {
5590 if (be16_to_cpu(pinstance->inq_data->fw_version) <=
5591 PMCRAID_FW_VERSION_1)
5592 cfgte = &pinstance->cfg_table->entries[i];
5593 else
5594 cfgte = (struct pmcraid_config_table_entry *)
5595 &pinstance->cfg_table->entries_ext[i];
5596
5597 if (!pmcraid_expose_resource(fw_version, cfgte))
5598 continue;
5599
5600 found = 0;
5601
5602
5603 list_for_each_entry_safe(res, temp, &old_res, queue) {
5604
5605 rc = memcmp(&res->cfg_entry.resource_address,
5606 &cfgte->resource_address,
5607 sizeof(cfgte->resource_address));
5608 if (!rc) {
5609 list_move_tail(&res->queue,
5610 &pinstance->used_res_q);
5611 found = 1;
5612 break;
5613 }
5614 }
5615
5616
5617 if (!found) {
5618
5619 if (list_empty(&pinstance->free_res_q)) {
5620 pmcraid_err("Too many devices attached\n");
5621 break;
5622 }
5623
5624 found = 1;
5625 res = list_entry(pinstance->free_res_q.next,
5626 struct pmcraid_resource_entry, queue);
5627
5628 res->scsi_dev = NULL;
5629 res->change_detected = RES_CHANGE_ADD;
5630 res->reset_progress = 0;
5631 list_move_tail(&res->queue, &pinstance->used_res_q);
5632 }
5633
5634
5635
5636
5637 if (found) {
5638 memcpy(&res->cfg_entry, cfgte,
5639 pinstance->config_table_entry_size);
5640 pmcraid_info("New res type:%x, vset:%x, addr:%x:\n",
5641 res->cfg_entry.resource_type,
5642 (fw_version <= PMCRAID_FW_VERSION_1 ?
5643 res->cfg_entry.unique_flags1 :
5644 le16_to_cpu(res->cfg_entry.array_id) & 0xFF),
5645 le32_to_cpu(res->cfg_entry.resource_address));
5646 }
5647 }
5648
5649
5650 list_for_each_entry_safe(res, temp, &old_res, queue) {
5651
5652 if (res->scsi_dev) {
5653 res->change_detected = RES_CHANGE_DEL;
5654 res->cfg_entry.resource_handle =
5655 PMCRAID_INVALID_RES_HANDLE;
5656 list_move_tail(&res->queue, &pinstance->used_res_q);
5657 } else {
5658 list_move_tail(&res->queue, &pinstance->free_res_q);
5659 }
5660 }
5661
5662
5663 spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
5664 pmcraid_set_timestamp(cmd);
5665}
5666
5667
5668
5669
5670
5671
5672
5673
5674
5675
5676
5677static void pmcraid_querycfg(struct pmcraid_cmd *cmd)
5678{
5679 struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5680 struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
5681 struct pmcraid_instance *pinstance = cmd->drv_inst;
5682 __be32 cfg_table_size = cpu_to_be32(sizeof(struct pmcraid_config_table));
5683
5684 if (be16_to_cpu(pinstance->inq_data->fw_version) <=
5685 PMCRAID_FW_VERSION_1)
5686 pinstance->config_table_entry_size =
5687 sizeof(struct pmcraid_config_table_entry);
5688 else
5689 pinstance->config_table_entry_size =
5690 sizeof(struct pmcraid_config_table_entry_ext);
5691
5692 ioarcb->request_type = REQ_TYPE_IOACMD;
5693 ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
5694
5695 ioarcb->cdb[0] = PMCRAID_QUERY_IOA_CONFIG;
5696
5697
5698 memcpy(&(ioarcb->cdb[10]), &cfg_table_size, sizeof(cfg_table_size));
5699
5700
5701
5702
5703 ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
5704 offsetof(struct pmcraid_ioarcb,
5705 add_data.u.ioadl[0]));
5706 ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
5707 ioarcb->ioarcb_bus_addr &= cpu_to_le64(~0x1FULL);
5708
5709 ioarcb->request_flags0 |= NO_LINK_DESCS;
5710 ioarcb->data_transfer_length =
5711 cpu_to_le32(sizeof(struct pmcraid_config_table));
5712
5713 ioadl = &(ioarcb->add_data.u.ioadl[0]);
5714 ioadl->flags = IOADL_FLAGS_LAST_DESC;
5715 ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr);
5716 ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_config_table));
5717
5718 pmcraid_send_cmd(cmd, pmcraid_init_res_table,
5719 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
5720}
5721
5722
5723
5724
5725
5726
5727
5728
5729
5730
5731
5732static int pmcraid_probe(struct pci_dev *pdev,
5733 const struct pci_device_id *dev_id)
5734{
5735 struct pmcraid_instance *pinstance;
5736 struct Scsi_Host *host;
5737 void __iomem *mapped_pci_addr;
5738 int rc = PCIBIOS_SUCCESSFUL;
5739
5740 if (atomic_read(&pmcraid_adapter_count) >= PMCRAID_MAX_ADAPTERS) {
5741 pmcraid_err
5742 ("maximum number(%d) of supported adapters reached\n",
5743 atomic_read(&pmcraid_adapter_count));
5744 return -ENOMEM;
5745 }
5746
5747 atomic_inc(&pmcraid_adapter_count);
5748 rc = pci_enable_device(pdev);
5749
5750 if (rc) {
5751 dev_err(&pdev->dev, "Cannot enable adapter\n");
5752 atomic_dec(&pmcraid_adapter_count);
5753 return rc;
5754 }
5755
5756 dev_info(&pdev->dev,
5757 "Found new IOA(%x:%x), Total IOA count: %d\n",
5758 pdev->vendor, pdev->device,
5759 atomic_read(&pmcraid_adapter_count));
5760
5761 rc = pci_request_regions(pdev, PMCRAID_DRIVER_NAME);
5762
5763 if (rc < 0) {
5764 dev_err(&pdev->dev,
5765 "Couldn't register memory range of registers\n");
5766 goto out_disable_device;
5767 }
5768
5769 mapped_pci_addr = pci_iomap(pdev, 0, 0);
5770
5771 if (!mapped_pci_addr) {
5772 dev_err(&pdev->dev, "Couldn't map PCI registers memory\n");
5773 rc = -ENOMEM;
5774 goto out_release_regions;
5775 }
5776
5777 pci_set_master(pdev);
5778
5779
5780
5781
5782
5783
5784
5785
5786 if ((sizeof(dma_addr_t) == 4) ||
5787 pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
5788 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
5789
5790
5791
5792
5793 if (rc == 0)
5794 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
5795
5796 if (rc != 0) {
5797 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
5798 goto cleanup_nomem;
5799 }
5800
5801 host = scsi_host_alloc(&pmcraid_host_template,
5802 sizeof(struct pmcraid_instance));
5803
5804 if (!host) {
5805 dev_err(&pdev->dev, "scsi_host_alloc failed!\n");
5806 rc = -ENOMEM;
5807 goto cleanup_nomem;
5808 }
5809
5810 host->max_id = PMCRAID_MAX_NUM_TARGETS_PER_BUS;
5811 host->max_lun = PMCRAID_MAX_NUM_LUNS_PER_TARGET;
5812 host->unique_id = host->host_no;
5813 host->max_channel = PMCRAID_MAX_BUS_TO_SCAN;
5814 host->max_cmd_len = PMCRAID_MAX_CDB_LEN;
5815
5816
5817 pinstance = (struct pmcraid_instance *)host->hostdata;
5818 memset(pinstance, 0, sizeof(*pinstance));
5819
5820 pinstance->chip_cfg =
5821 (struct pmcraid_chip_details *)(dev_id->driver_data);
5822
5823 rc = pmcraid_init_instance(pdev, host, mapped_pci_addr);
5824
5825 if (rc < 0) {
5826 dev_err(&pdev->dev, "failed to initialize adapter instance\n");
5827 goto out_scsi_host_put;
5828 }
5829
5830 pci_set_drvdata(pdev, pinstance);
5831
5832
5833 rc = pci_save_state(pinstance->pdev);
5834
5835 if (rc != 0) {
5836 dev_err(&pdev->dev, "Failed to save PCI config space\n");
5837 goto out_scsi_host_put;
5838 }
5839
5840 pmcraid_disable_interrupts(pinstance, ~0);
5841
5842 rc = pmcraid_register_interrupt_handler(pinstance);
5843
5844 if (rc) {
5845 dev_err(&pdev->dev, "couldn't register interrupt handler\n");
5846 goto out_scsi_host_put;
5847 }
5848
5849 pmcraid_init_tasklets(pinstance);
5850
5851
5852 rc = pmcraid_init_buffers(pinstance);
5853
5854 if (rc) {
5855 pmcraid_err("couldn't allocate memory blocks\n");
5856 goto out_unregister_isr;
5857 }
5858
5859
5860 pmcraid_reset_type(pinstance);
5861
5862 pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
5863
5864
5865
5866
5867 pmcraid_info("starting IOA initialization sequence\n");
5868 if (pmcraid_reset_bringup(pinstance)) {
5869 dev_err(&pdev->dev, "couldn't initialize IOA\n");
5870 rc = 1;
5871 goto out_release_bufs;
5872 }
5873
5874
5875 rc = scsi_add_host(pinstance->host, &pdev->dev);
5876 if (rc != 0) {
5877 pmcraid_err("couldn't add host into mid-layer: %d\n", rc);
5878 goto out_release_bufs;
5879 }
5880
5881 scsi_scan_host(pinstance->host);
5882
5883 rc = pmcraid_setup_chrdev(pinstance);
5884
5885 if (rc != 0) {
5886 pmcraid_err("couldn't create mgmt interface, error: %x\n",
5887 rc);
5888 goto out_remove_host;
5889 }
5890
5891
5892
5893
5894 atomic_set(&pinstance->expose_resources, 1);
5895 schedule_work(&pinstance->worker_q);
5896 return rc;
5897
5898out_remove_host:
5899 scsi_remove_host(host);
5900
5901out_release_bufs:
5902 pmcraid_release_buffers(pinstance);
5903
5904out_unregister_isr:
5905 pmcraid_kill_tasklets(pinstance);
5906 pmcraid_unregister_interrupt_handler(pinstance);
5907
5908out_scsi_host_put:
5909 scsi_host_put(host);
5910
5911cleanup_nomem:
5912 iounmap(mapped_pci_addr);
5913
5914out_release_regions:
5915 pci_release_regions(pdev);
5916
5917out_disable_device:
5918 atomic_dec(&pmcraid_adapter_count);
5919 pci_disable_device(pdev);
5920 return -ENODEV;
5921}
5922
5923
5924
5925
5926static struct pci_driver pmcraid_driver = {
5927 .name = PMCRAID_DRIVER_NAME,
5928 .id_table = pmcraid_pci_table,
5929 .probe = pmcraid_probe,
5930 .remove = pmcraid_remove,
5931 .suspend = pmcraid_suspend,
5932 .resume = pmcraid_resume,
5933 .shutdown = pmcraid_shutdown
5934};
5935
5936
5937
5938
5939static int __init pmcraid_init(void)
5940{
5941 dev_t dev;
5942 int error;
5943
5944 pmcraid_info("%s Device Driver version: %s\n",
5945 PMCRAID_DRIVER_NAME, PMCRAID_DRIVER_VERSION);
5946
5947 error = alloc_chrdev_region(&dev, 0,
5948 PMCRAID_MAX_ADAPTERS,
5949 PMCRAID_DEVFILE);
5950
5951 if (error) {
5952 pmcraid_err("failed to get a major number for adapters\n");
5953 goto out_init;
5954 }
5955
5956 pmcraid_major = MAJOR(dev);
5957 pmcraid_class = class_create(THIS_MODULE, PMCRAID_DEVFILE);
5958
5959 if (IS_ERR(pmcraid_class)) {
5960 error = PTR_ERR(pmcraid_class);
5961 pmcraid_err("failed to register with sysfs, error = %x\n",
5962 error);
5963 goto out_unreg_chrdev;
5964 }
5965
5966 error = pmcraid_netlink_init();
5967
5968 if (error) {
5969 class_destroy(pmcraid_class);
5970 goto out_unreg_chrdev;
5971 }
5972
5973 error = pci_register_driver(&pmcraid_driver);
5974
5975 if (error == 0)
5976 goto out_init;
5977
5978 pmcraid_err("failed to register pmcraid driver, error = %x\n",
5979 error);
5980 class_destroy(pmcraid_class);
5981 pmcraid_netlink_release();
5982
5983out_unreg_chrdev:
5984 unregister_chrdev_region(MKDEV(pmcraid_major, 0), PMCRAID_MAX_ADAPTERS);
5985
5986out_init:
5987 return error;
5988}
5989
5990
5991
5992
5993static void __exit pmcraid_exit(void)
5994{
5995 pmcraid_netlink_release();
5996 unregister_chrdev_region(MKDEV(pmcraid_major, 0),
5997 PMCRAID_MAX_ADAPTERS);
5998 pci_unregister_driver(&pmcraid_driver);
5999 class_destroy(pmcraid_class);
6000}
6001
6002module_init(pmcraid_init);
6003module_exit(pmcraid_exit);
6004