5 * Authors: Joshua Morris <josh.h.morris@us.ibm.com>
6 * Philip Kelleher <pjk1939@linux.vnet.ibm.com>
8 * (C) Copyright 2013 IBM Corporation
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of the
13 * License, or (at your option) any later version.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/kernel.h>
26 #include <linux/init.h>
27 #include <linux/interrupt.h>
28 #include <linux/module.h>
29 #include <linux/pci.h>
30 #include <linux/reboot.h>
31 #include <linux/slab.h>
32 #include <linux/bitops.h>
33 #include <linux/delay.h>
35 #include <linux/genhd.h>
36 #include <linux/idr.h>
38 #include "rsxx_priv.h"
42 #define SYNC_START_TIMEOUT (10 * 60) /* 10 minutes */
44 MODULE_DESCRIPTION("IBM Flash Adapter 900GB Full Height Device Driver");
45 MODULE_AUTHOR("Joshua Morris/Philip Kelleher, IBM");
46 MODULE_LICENSE("GPL");
47 MODULE_VERSION(DRIVER_VERSION
);
49 static unsigned int force_legacy
= NO_LEGACY
;
50 module_param(force_legacy
, uint
, 0444);
51 MODULE_PARM_DESC(force_legacy
, "Force the use of legacy type PCI interrupts");
53 static unsigned int sync_start
= 1;
54 module_param(sync_start
, uint
, 0444);
55 MODULE_PARM_DESC(sync_start
, "On by Default: Driver load will not complete "
56 "until the card startup has completed.");
58 static DEFINE_IDA(rsxx_disk_ida
);
59 static DEFINE_SPINLOCK(rsxx_ida_lock
);
61 /*----------------- Interrupt Control & Handling -------------------*/
63 static void rsxx_mask_interrupts(struct rsxx_cardinfo
*card
)
69 static void __enable_intr(unsigned int *mask
, unsigned int intr
)
74 static void __disable_intr(unsigned int *mask
, unsigned int intr
)
80 * NOTE: Disabling the IER will disable the hardware interrupt.
81 * Disabling the ISR will disable the software handling of the ISR bit.
83 * Enable/Disable interrupt functions assume the card->irq_lock
84 * is held by the caller.
86 void rsxx_enable_ier(struct rsxx_cardinfo
*card
, unsigned int intr
)
88 if (unlikely(card
->halt
) ||
89 unlikely(card
->eeh_state
))
92 __enable_intr(&card
->ier_mask
, intr
);
93 iowrite32(card
->ier_mask
, card
->regmap
+ IER
);
96 void rsxx_disable_ier(struct rsxx_cardinfo
*card
, unsigned int intr
)
98 if (unlikely(card
->eeh_state
))
101 __disable_intr(&card
->ier_mask
, intr
);
102 iowrite32(card
->ier_mask
, card
->regmap
+ IER
);
105 void rsxx_enable_ier_and_isr(struct rsxx_cardinfo
*card
,
108 if (unlikely(card
->halt
) ||
109 unlikely(card
->eeh_state
))
112 __enable_intr(&card
->isr_mask
, intr
);
113 __enable_intr(&card
->ier_mask
, intr
);
114 iowrite32(card
->ier_mask
, card
->regmap
+ IER
);
116 void rsxx_disable_ier_and_isr(struct rsxx_cardinfo
*card
,
119 if (unlikely(card
->eeh_state
))
122 __disable_intr(&card
->isr_mask
, intr
);
123 __disable_intr(&card
->ier_mask
, intr
);
124 iowrite32(card
->ier_mask
, card
->regmap
+ IER
);
127 static irqreturn_t
rsxx_isr(int irq
, void *pdata
)
129 struct rsxx_cardinfo
*card
= pdata
;
135 spin_lock(&card
->irq_lock
);
140 if (unlikely(card
->eeh_state
))
143 isr
= ioread32(card
->regmap
+ ISR
);
144 if (isr
== 0xffffffff) {
146 * A few systems seem to have an intermittent issue
147 * where PCI reads return all Fs, but retrying the read
148 * a little later will return as expected.
150 dev_info(CARD_TO_DEV(card
),
151 "ISR = 0xFFFFFFFF, retrying later\n");
155 isr
&= card
->isr_mask
;
159 for (i
= 0; i
< card
->n_targets
; i
++) {
160 if (isr
& CR_INTR_DMA(i
)) {
161 if (card
->ier_mask
& CR_INTR_DMA(i
)) {
162 rsxx_disable_ier(card
, CR_INTR_DMA(i
));
165 queue_work(card
->ctrl
[i
].done_wq
,
166 &card
->ctrl
[i
].dma_done_work
);
171 if (isr
& CR_INTR_CREG
) {
172 queue_work(card
->creg_ctrl
.creg_wq
,
173 &card
->creg_ctrl
.done_work
);
177 if (isr
& CR_INTR_EVENT
) {
178 queue_work(card
->event_wq
, &card
->event_work
);
179 rsxx_disable_ier_and_isr(card
, CR_INTR_EVENT
);
182 } while (reread_isr
);
184 spin_unlock(&card
->irq_lock
);
186 return handled
? IRQ_HANDLED
: IRQ_NONE
;
189 /*----------------- Card Event Handler -------------------*/
190 static const char * const rsxx_card_state_to_str(unsigned int state
)
192 static const char * const state_strings
[] = {
193 "Unknown", "Shutdown", "Starting", "Formatting",
194 "Uninitialized", "Good", "Shutting Down",
195 "Fault", "Read Only Fault", "dStroying"
198 return state_strings
[ffs(state
)];
201 static void card_state_change(struct rsxx_cardinfo
*card
,
202 unsigned int new_state
)
206 dev_info(CARD_TO_DEV(card
),
207 "card state change detected.(%s -> %s)\n",
208 rsxx_card_state_to_str(card
->state
),
209 rsxx_card_state_to_str(new_state
));
211 card
->state
= new_state
;
213 /* Don't attach DMA interfaces if the card has an invalid config */
214 if (!card
->config_valid
)
218 case CARD_STATE_RD_ONLY_FAULT
:
219 dev_crit(CARD_TO_DEV(card
),
220 "Hardware has entered read-only mode!\n");
222 * Fall through so the DMA devices can be attached and
223 * the user can attempt to pull off their data.
225 case CARD_STATE_GOOD
:
226 st
= rsxx_get_card_size8(card
, &card
->size8
);
228 dev_err(CARD_TO_DEV(card
),
229 "Failed attaching DMA devices\n");
231 if (card
->config_valid
)
232 set_capacity(card
->gendisk
, card
->size8
>> 9);
235 case CARD_STATE_FAULT
:
236 dev_crit(CARD_TO_DEV(card
),
237 "Hardware Fault reported!\n");
240 /* Everything else, detach DMA interface if it's attached. */
241 case CARD_STATE_SHUTDOWN
:
242 case CARD_STATE_STARTING
:
243 case CARD_STATE_FORMATTING
:
244 case CARD_STATE_UNINITIALIZED
:
245 case CARD_STATE_SHUTTING_DOWN
:
247 * dStroy is a term coined by marketing to represent the low level
250 case CARD_STATE_DSTROYING
:
251 set_capacity(card
->gendisk
, 0);
256 static void card_event_handler(struct work_struct
*work
)
258 struct rsxx_cardinfo
*card
;
263 card
= container_of(work
, struct rsxx_cardinfo
, event_work
);
265 if (unlikely(card
->halt
))
269 * Enable the interrupt now to avoid any weird race conditions where a
270 * state change might occur while rsxx_get_card_state() is
271 * processing a returned creg cmd.
273 spin_lock_irqsave(&card
->irq_lock
, flags
);
274 rsxx_enable_ier_and_isr(card
, CR_INTR_EVENT
);
275 spin_unlock_irqrestore(&card
->irq_lock
, flags
);
277 st
= rsxx_get_card_state(card
, &state
);
279 dev_info(CARD_TO_DEV(card
),
280 "Failed reading state after event.\n");
284 if (card
->state
!= state
)
285 card_state_change(card
, state
);
287 if (card
->creg_ctrl
.creg_stats
.stat
& CREG_STAT_LOG_PENDING
)
288 rsxx_read_hw_log(card
);
291 /*----------------- Card Operations -------------------*/
292 static int card_shutdown(struct rsxx_cardinfo
*card
)
296 const int timeout
= msecs_to_jiffies(120000);
299 /* We can't issue a shutdown if the card is in a transition state */
302 st
= rsxx_get_card_state(card
, &state
);
305 } while (state
== CARD_STATE_STARTING
&&
306 (jiffies
- start
< timeout
));
308 if (state
== CARD_STATE_STARTING
)
311 /* Only issue a shutdown if we need to */
312 if ((state
!= CARD_STATE_SHUTTING_DOWN
) &&
313 (state
!= CARD_STATE_SHUTDOWN
)) {
314 st
= rsxx_issue_card_cmd(card
, CARD_CMD_SHUTDOWN
);
321 st
= rsxx_get_card_state(card
, &state
);
324 } while (state
!= CARD_STATE_SHUTDOWN
&&
325 (jiffies
- start
< timeout
));
327 if (state
!= CARD_STATE_SHUTDOWN
)
333 static int rsxx_eeh_frozen(struct pci_dev
*dev
)
335 struct rsxx_cardinfo
*card
= pci_get_drvdata(dev
);
339 dev_warn(&dev
->dev
, "IBM Flash Adapter PCI: preparing for slot reset.\n");
342 rsxx_mask_interrupts(card
);
345 * We need to guarantee that the write for eeh_state and masking
346 * interrupts does not become reordered. This will prevent a possible
347 * race condition with the EEH code.
351 pci_disable_device(dev
);
353 st
= rsxx_eeh_save_issued_dmas(card
);
357 rsxx_eeh_save_issued_creg(card
);
359 for (i
= 0; i
< card
->n_targets
; i
++) {
360 if (card
->ctrl
[i
].status
.buf
)
361 pci_free_consistent(card
->dev
, STATUS_BUFFER_SIZE8
,
362 card
->ctrl
[i
].status
.buf
,
363 card
->ctrl
[i
].status
.dma_addr
);
364 if (card
->ctrl
[i
].cmd
.buf
)
365 pci_free_consistent(card
->dev
, COMMAND_BUFFER_SIZE8
,
366 card
->ctrl
[i
].cmd
.buf
,
367 card
->ctrl
[i
].cmd
.dma_addr
);
373 static void rsxx_eeh_failure(struct pci_dev
*dev
)
375 struct rsxx_cardinfo
*card
= pci_get_drvdata(dev
);
379 dev_err(&dev
->dev
, "IBM Flash Adapter PCI: disabling failed card.\n");
384 for (i
= 0; i
< card
->n_targets
; i
++) {
385 spin_lock_bh(&card
->ctrl
[i
].queue_lock
);
386 cnt
= rsxx_cleanup_dma_queue(&card
->ctrl
[i
],
387 &card
->ctrl
[i
].queue
);
388 spin_unlock_bh(&card
->ctrl
[i
].queue_lock
);
390 cnt
+= rsxx_dma_cancel(&card
->ctrl
[i
]);
393 dev_info(CARD_TO_DEV(card
),
394 "Freed %d queued DMAs on channel %d\n",
395 cnt
, card
->ctrl
[i
].id
);
399 static int rsxx_eeh_fifo_flush_poll(struct rsxx_cardinfo
*card
)
404 /* We need to wait for the hardware to reset */
405 while (iter
++ < 10) {
406 status
= ioread32(card
->regmap
+ PCI_RECONFIG
);
408 if (status
& RSXX_FLUSH_BUSY
) {
413 if (status
& RSXX_FLUSH_TIMEOUT
)
414 dev_warn(CARD_TO_DEV(card
), "HW: flash controller timeout\n");
418 /* Hardware failed resetting itself. */
422 static pci_ers_result_t
rsxx_error_detected(struct pci_dev
*dev
,
423 enum pci_channel_state error
)
427 if (dev
->revision
< RSXX_EEH_SUPPORT
)
428 return PCI_ERS_RESULT_NONE
;
430 if (error
== pci_channel_io_perm_failure
) {
431 rsxx_eeh_failure(dev
);
432 return PCI_ERS_RESULT_DISCONNECT
;
435 st
= rsxx_eeh_frozen(dev
);
437 dev_err(&dev
->dev
, "Slot reset setup failed\n");
438 rsxx_eeh_failure(dev
);
439 return PCI_ERS_RESULT_DISCONNECT
;
442 return PCI_ERS_RESULT_NEED_RESET
;
445 static pci_ers_result_t
rsxx_slot_reset(struct pci_dev
*dev
)
447 struct rsxx_cardinfo
*card
= pci_get_drvdata(dev
);
453 "IBM Flash Adapter PCI: recovering from slot reset.\n");
455 st
= pci_enable_device(dev
);
457 goto failed_hw_setup
;
461 st
= rsxx_eeh_fifo_flush_poll(card
);
463 goto failed_hw_setup
;
465 rsxx_dma_queue_reset(card
);
467 for (i
= 0; i
< card
->n_targets
; i
++) {
468 st
= rsxx_hw_buffers_init(dev
, &card
->ctrl
[i
]);
470 goto failed_hw_buffers_init
;
473 if (card
->config_valid
)
474 rsxx_dma_configure(card
);
476 /* Clears the ISR register from spurious interrupts */
477 st
= ioread32(card
->regmap
+ ISR
);
481 st
= rsxx_eeh_remap_dmas(card
);
483 goto failed_remap_dmas
;
485 spin_lock_irqsave(&card
->irq_lock
, flags
);
486 if (card
->n_targets
& RSXX_MAX_TARGETS
)
487 rsxx_enable_ier_and_isr(card
, CR_INTR_ALL_G
);
489 rsxx_enable_ier_and_isr(card
, CR_INTR_ALL_C
);
490 spin_unlock_irqrestore(&card
->irq_lock
, flags
);
492 rsxx_kick_creg_queue(card
);
494 for (i
= 0; i
< card
->n_targets
; i
++) {
495 spin_lock(&card
->ctrl
[i
].queue_lock
);
496 if (list_empty(&card
->ctrl
[i
].queue
)) {
497 spin_unlock(&card
->ctrl
[i
].queue_lock
);
500 spin_unlock(&card
->ctrl
[i
].queue_lock
);
502 queue_work(card
->ctrl
[i
].issue_wq
,
503 &card
->ctrl
[i
].issue_dma_work
);
506 dev_info(&dev
->dev
, "IBM Flash Adapter PCI: recovery complete.\n");
508 return PCI_ERS_RESULT_RECOVERED
;
510 failed_hw_buffers_init
:
512 for (i
= 0; i
< card
->n_targets
; i
++) {
513 if (card
->ctrl
[i
].status
.buf
)
514 pci_free_consistent(card
->dev
,
516 card
->ctrl
[i
].status
.buf
,
517 card
->ctrl
[i
].status
.dma_addr
);
518 if (card
->ctrl
[i
].cmd
.buf
)
519 pci_free_consistent(card
->dev
,
520 COMMAND_BUFFER_SIZE8
,
521 card
->ctrl
[i
].cmd
.buf
,
522 card
->ctrl
[i
].cmd
.dma_addr
);
525 rsxx_eeh_failure(dev
);
526 return PCI_ERS_RESULT_DISCONNECT
;
530 /*----------------- Driver Initialization & Setup -------------------*/
531 /* Returns: 0 if the driver is compatible with the device
532 -1 if the driver is NOT compatible with the device */
533 static int rsxx_compatibility_check(struct rsxx_cardinfo
*card
)
535 unsigned char pci_rev
;
537 pci_read_config_byte(card
->dev
, PCI_REVISION_ID
, &pci_rev
);
539 if (pci_rev
> RS70_PCI_REV_SUPPORTED
)
544 static int rsxx_pci_probe(struct pci_dev
*dev
,
545 const struct pci_device_id
*id
)
547 struct rsxx_cardinfo
*card
;
549 unsigned int sync_timeout
;
551 dev_info(&dev
->dev
, "PCI-Flash SSD discovered\n");
553 card
= kzalloc(sizeof(*card
), GFP_KERNEL
);
558 pci_set_drvdata(dev
, card
);
561 if (!ida_pre_get(&rsxx_disk_ida
, GFP_KERNEL
)) {
566 spin_lock(&rsxx_ida_lock
);
567 st
= ida_get_new(&rsxx_disk_ida
, &card
->disk_id
);
568 spin_unlock(&rsxx_ida_lock
);
569 } while (st
== -EAGAIN
);
574 st
= pci_enable_device(dev
);
579 pci_set_dma_max_seg_size(dev
, RSXX_HW_BLK_SIZE
);
581 st
= pci_set_dma_mask(dev
, DMA_BIT_MASK(64));
583 dev_err(CARD_TO_DEV(card
),
584 "No usable DMA configuration,aborting\n");
585 goto failed_dma_mask
;
588 st
= pci_request_regions(dev
, DRIVER_NAME
);
590 dev_err(CARD_TO_DEV(card
),
591 "Failed to request memory region\n");
592 goto failed_request_regions
;
595 if (pci_resource_len(dev
, 0) == 0) {
596 dev_err(CARD_TO_DEV(card
), "BAR0 has length 0!\n");
601 card
->regmap
= pci_iomap(dev
, 0, 0);
603 dev_err(CARD_TO_DEV(card
), "Failed to map BAR0\n");
608 spin_lock_init(&card
->irq_lock
);
612 spin_lock_irq(&card
->irq_lock
);
613 rsxx_disable_ier_and_isr(card
, CR_INTR_ALL
);
614 spin_unlock_irq(&card
->irq_lock
);
617 st
= pci_enable_msi(dev
);
619 dev_warn(CARD_TO_DEV(card
),
620 "Failed to enable MSI\n");
623 st
= request_irq(dev
->irq
, rsxx_isr
, IRQF_DISABLED
| IRQF_SHARED
,
626 dev_err(CARD_TO_DEV(card
),
627 "Failed requesting IRQ%d\n", dev
->irq
);
631 /************* Setup Processor Command Interface *************/
632 st
= rsxx_creg_setup(card
);
634 dev_err(CARD_TO_DEV(card
), "Failed to setup creg interface.\n");
635 goto failed_creg_setup
;
638 spin_lock_irq(&card
->irq_lock
);
639 rsxx_enable_ier_and_isr(card
, CR_INTR_CREG
);
640 spin_unlock_irq(&card
->irq_lock
);
642 st
= rsxx_compatibility_check(card
);
644 dev_warn(CARD_TO_DEV(card
),
645 "Incompatible driver detected. Please update the driver.\n");
647 goto failed_compatiblity_check
;
650 /************* Load Card Config *************/
651 st
= rsxx_load_config(card
);
653 dev_err(CARD_TO_DEV(card
),
654 "Failed loading card config\n");
656 /************* Setup DMA Engine *************/
657 st
= rsxx_get_num_targets(card
, &card
->n_targets
);
659 dev_info(CARD_TO_DEV(card
),
660 "Failed reading the number of DMA targets\n");
662 card
->ctrl
= kzalloc(card
->n_targets
* sizeof(*card
->ctrl
), GFP_KERNEL
);
665 goto failed_dma_setup
;
668 st
= rsxx_dma_setup(card
);
670 dev_info(CARD_TO_DEV(card
),
671 "Failed to setup DMA engine\n");
672 goto failed_dma_setup
;
675 /************* Setup Card Event Handler *************/
676 card
->event_wq
= create_singlethread_workqueue(DRIVER_NAME
"_event");
677 if (!card
->event_wq
) {
678 dev_err(CARD_TO_DEV(card
), "Failed card event setup.\n");
679 goto failed_event_handler
;
682 INIT_WORK(&card
->event_work
, card_event_handler
);
684 st
= rsxx_setup_dev(card
);
686 goto failed_create_dev
;
688 rsxx_get_card_state(card
, &card
->state
);
690 dev_info(CARD_TO_DEV(card
),
692 rsxx_card_state_to_str(card
->state
));
695 * Now that the DMA Engine and devices have been setup,
696 * we can enable the event interrupt(it kicks off actions in
697 * those layers so we couldn't enable it right away.)
699 spin_lock_irq(&card
->irq_lock
);
700 rsxx_enable_ier_and_isr(card
, CR_INTR_EVENT
);
701 spin_unlock_irq(&card
->irq_lock
);
703 if (card
->state
== CARD_STATE_SHUTDOWN
) {
704 st
= rsxx_issue_card_cmd(card
, CARD_CMD_STARTUP
);
706 dev_crit(CARD_TO_DEV(card
),
707 "Failed issuing card startup\n");
709 sync_timeout
= SYNC_START_TIMEOUT
;
711 dev_info(CARD_TO_DEV(card
),
712 "Waiting for card to startup\n");
718 rsxx_get_card_state(card
, &card
->state
);
719 } while (sync_timeout
&&
720 (card
->state
== CARD_STATE_STARTING
));
722 if (card
->state
== CARD_STATE_STARTING
) {
723 dev_warn(CARD_TO_DEV(card
),
724 "Card startup timed out\n");
727 dev_info(CARD_TO_DEV(card
),
729 rsxx_card_state_to_str(card
->state
));
730 st
= rsxx_get_card_size8(card
, &card
->size8
);
735 } else if (card
->state
== CARD_STATE_GOOD
||
736 card
->state
== CARD_STATE_RD_ONLY_FAULT
) {
737 st
= rsxx_get_card_size8(card
, &card
->size8
);
742 rsxx_attach_dev(card
);
747 destroy_workqueue(card
->event_wq
);
748 card
->event_wq
= NULL
;
749 failed_event_handler
:
750 rsxx_dma_destroy(card
);
752 failed_compatiblity_check
:
753 destroy_workqueue(card
->creg_ctrl
.creg_wq
);
754 card
->creg_ctrl
.creg_wq
= NULL
;
756 spin_lock_irq(&card
->irq_lock
);
757 rsxx_disable_ier_and_isr(card
, CR_INTR_ALL
);
758 spin_unlock_irq(&card
->irq_lock
);
759 free_irq(dev
->irq
, card
);
761 pci_disable_msi(dev
);
763 pci_iounmap(dev
, card
->regmap
);
765 pci_release_regions(dev
);
766 failed_request_regions
:
768 pci_disable_device(dev
);
770 spin_lock(&rsxx_ida_lock
);
771 ida_remove(&rsxx_disk_ida
, card
->disk_id
);
772 spin_unlock(&rsxx_ida_lock
);
779 static void rsxx_pci_remove(struct pci_dev
*dev
)
781 struct rsxx_cardinfo
*card
= pci_get_drvdata(dev
);
789 dev_info(CARD_TO_DEV(card
),
790 "Removing PCI-Flash SSD.\n");
792 rsxx_detach_dev(card
);
794 for (i
= 0; i
< card
->n_targets
; i
++) {
795 spin_lock_irqsave(&card
->irq_lock
, flags
);
796 rsxx_disable_ier_and_isr(card
, CR_INTR_DMA(i
));
797 spin_unlock_irqrestore(&card
->irq_lock
, flags
);
800 st
= card_shutdown(card
);
802 dev_crit(CARD_TO_DEV(card
), "Shutdown failed!\n");
804 /* Sync outstanding event handlers. */
805 spin_lock_irqsave(&card
->irq_lock
, flags
);
806 rsxx_disable_ier_and_isr(card
, CR_INTR_EVENT
);
807 spin_unlock_irqrestore(&card
->irq_lock
, flags
);
809 cancel_work_sync(&card
->event_work
);
811 rsxx_destroy_dev(card
);
812 rsxx_dma_destroy(card
);
814 spin_lock_irqsave(&card
->irq_lock
, flags
);
815 rsxx_disable_ier_and_isr(card
, CR_INTR_ALL
);
816 spin_unlock_irqrestore(&card
->irq_lock
, flags
);
818 /* Prevent work_structs from re-queuing themselves. */
821 free_irq(dev
->irq
, card
);
824 pci_disable_msi(dev
);
826 rsxx_creg_destroy(card
);
828 pci_iounmap(dev
, card
->regmap
);
830 pci_disable_device(dev
);
831 pci_release_regions(dev
);
836 static int rsxx_pci_suspend(struct pci_dev
*dev
, pm_message_t state
)
838 /* We don't support suspend at this time. */
842 static void rsxx_pci_shutdown(struct pci_dev
*dev
)
844 struct rsxx_cardinfo
*card
= pci_get_drvdata(dev
);
851 dev_info(CARD_TO_DEV(card
), "Shutting down PCI-Flash SSD.\n");
853 rsxx_detach_dev(card
);
855 for (i
= 0; i
< card
->n_targets
; i
++) {
856 spin_lock_irqsave(&card
->irq_lock
, flags
);
857 rsxx_disable_ier_and_isr(card
, CR_INTR_DMA(i
));
858 spin_unlock_irqrestore(&card
->irq_lock
, flags
);
864 static const struct pci_error_handlers rsxx_err_handler
= {
865 .error_detected
= rsxx_error_detected
,
866 .slot_reset
= rsxx_slot_reset
,
869 static DEFINE_PCI_DEVICE_TABLE(rsxx_pci_ids
) = {
870 {PCI_DEVICE(PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_FS70_FLASH
)},
871 {PCI_DEVICE(PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_FS80_FLASH
)},
875 MODULE_DEVICE_TABLE(pci
, rsxx_pci_ids
);
877 static struct pci_driver rsxx_pci_driver
= {
879 .id_table
= rsxx_pci_ids
,
880 .probe
= rsxx_pci_probe
,
881 .remove
= rsxx_pci_remove
,
882 .suspend
= rsxx_pci_suspend
,
883 .shutdown
= rsxx_pci_shutdown
,
884 .err_handler
= &rsxx_err_handler
,
887 static int __init
rsxx_core_init(void)
891 st
= rsxx_dev_init();
895 st
= rsxx_dma_init();
897 goto dma_init_failed
;
899 st
= rsxx_creg_init();
901 goto creg_init_failed
;
903 return pci_register_driver(&rsxx_pci_driver
);
913 static void __exit
rsxx_core_cleanup(void)
915 pci_unregister_driver(&rsxx_pci_driver
);
921 module_init(rsxx_core_init
);
922 module_exit(rsxx_core_cleanup
);