2
* Copyright (C) 2010 - Maxim Levitsky
3
* driver for Ricoh memstick readers
5
* This program is free software; you can redistribute it and/or modify
6
* it under the terms of the GNU General Public License version 2 as
7
* published by the Free Software Foundation.
10
#include <linux/kernel.h>
11
#include <linux/module.h>
12
#include <linux/freezer.h>
13
#include <linux/jiffies.h>
14
#include <linux/interrupt.h>
15
#include <linux/pci.h>
16
#include <linux/pci_ids.h>
17
#include <linux/delay.h>
18
#include <linux/slab.h>
19
#include <linux/kthread.h>
20
#include <linux/sched.h>
21
#include <linux/highmem.h>
22
#include <asm/byteorder.h>
23
#include <linux/swab.h>
26
static int r592_enable_dma = 1;
29
static const char *tpc_names[] = {
30
"MS_TPC_READ_MG_STATUS",
31
"MS_TPC_READ_LONG_DATA",
32
"MS_TPC_READ_SHORT_DATA",
34
"MS_TPC_READ_QUAD_DATA",
37
"MS_TPC_SET_RW_REG_ADRS",
39
"MS_TPC_WRITE_QUAD_DATA",
41
"MS_TPC_WRITE_SHORT_DATA",
42
"MS_TPC_WRITE_LONG_DATA",
47
* memstick_debug_get_tpc_name - debug helper that returns string for
50
const char *memstick_debug_get_tpc_name(int tpc)
52
return tpc_names[tpc-1];
54
EXPORT_SYMBOL(memstick_debug_get_tpc_name);
58
static inline u32 r592_read_reg(struct r592_device *dev, int address)
60
u32 value = readl(dev->mmio + address);
61
dbg_reg("reg #%02d == 0x%08x", address, value);
65
/* Write a register */
66
static inline void r592_write_reg(struct r592_device *dev,
67
int address, u32 value)
69
dbg_reg("reg #%02d <- 0x%08x", address, value);
70
writel(value, dev->mmio + address);
73
/* Reads a big endian DWORD register */
74
static inline u32 r592_read_reg_raw_be(struct r592_device *dev, int address)
76
u32 value = __raw_readl(dev->mmio + address);
77
dbg_reg("reg #%02d == 0x%08x", address, value);
78
return be32_to_cpu(value);
81
/* Writes a big endian DWORD register */
82
static inline void r592_write_reg_raw_be(struct r592_device *dev,
83
int address, u32 value)
85
dbg_reg("reg #%02d <- 0x%08x", address, value);
86
__raw_writel(cpu_to_be32(value), dev->mmio + address);
89
/* Set specific bits in a register (little endian) */
90
static inline void r592_set_reg_mask(struct r592_device *dev,
91
int address, u32 mask)
93
u32 reg = readl(dev->mmio + address);
94
dbg_reg("reg #%02d |= 0x%08x (old =0x%08x)", address, mask, reg);
95
writel(reg | mask , dev->mmio + address);
98
/* Clear specific bits in a register (little endian) */
99
static inline void r592_clear_reg_mask(struct r592_device *dev,
100
int address, u32 mask)
102
u32 reg = readl(dev->mmio + address);
103
dbg_reg("reg #%02d &= 0x%08x (old = 0x%08x, mask = 0x%08x)",
104
address, ~mask, reg, mask);
105
writel(reg & ~mask, dev->mmio + address);
109
/* Wait for status bits while checking for errors */
110
static int r592_wait_status(struct r592_device *dev, u32 mask, u32 wanted_mask)
112
unsigned long timeout = jiffies + msecs_to_jiffies(1000);
113
u32 reg = r592_read_reg(dev, R592_STATUS);
115
if ((reg & mask) == wanted_mask)
118
while (time_before(jiffies, timeout)) {
120
reg = r592_read_reg(dev, R592_STATUS);
122
if ((reg & mask) == wanted_mask)
125
if (reg & (R592_STATUS_SEND_ERR | R592_STATUS_RECV_ERR))
134
/* Enable/disable device */
135
static int r592_enable_device(struct r592_device *dev, bool enable)
137
dbg("%sabling the device", enable ? "en" : "dis");
141
/* Power up the card */
142
r592_write_reg(dev, R592_POWER, R592_POWER_0 | R592_POWER_1);
144
/* Perform a reset */
145
r592_set_reg_mask(dev, R592_IO, R592_IO_RESET);
149
/* Power down the card */
150
r592_write_reg(dev, R592_POWER, 0);
155
/* Set serial/parallel mode */
156
static int r592_set_mode(struct r592_device *dev, bool parallel_mode)
158
if (!parallel_mode) {
159
dbg("switching to serial mode");
161
/* Set serial mode */
162
r592_write_reg(dev, R592_IO_MODE, R592_IO_MODE_SERIAL);
164
r592_clear_reg_mask(dev, R592_POWER, R592_POWER_20);
167
dbg("switching to parallel mode");
169
/* This setting should be set _before_ switch TPC */
170
r592_set_reg_mask(dev, R592_POWER, R592_POWER_20);
172
r592_clear_reg_mask(dev, R592_IO,
173
R592_IO_SERIAL1 | R592_IO_SERIAL2);
175
/* Set the parallel mode now */
176
r592_write_reg(dev, R592_IO_MODE, R592_IO_MODE_PARALLEL);
179
dev->parallel_mode = parallel_mode;
183
/* Perform a controller reset without powering down the card */
184
static void r592_host_reset(struct r592_device *dev)
186
r592_set_reg_mask(dev, R592_IO, R592_IO_RESET);
188
r592_set_mode(dev, dev->parallel_mode);
191
/* Disable all hardware interrupts */
192
static void r592_clear_interrupts(struct r592_device *dev)
194
/* Disable & ACK all interrupts */
195
r592_clear_reg_mask(dev, R592_REG_MSC, IRQ_ALL_ACK_MASK);
196
r592_clear_reg_mask(dev, R592_REG_MSC, IRQ_ALL_EN_MASK);
199
/* Tests if there is an CRC error */
200
static int r592_test_io_error(struct r592_device *dev)
202
if (!(r592_read_reg(dev, R592_STATUS) &
203
(R592_STATUS_SEND_ERR | R592_STATUS_RECV_ERR)))
209
/* Ensure that FIFO is ready for use */
210
static int r592_test_fifo_empty(struct r592_device *dev)
212
if (r592_read_reg(dev, R592_REG_MSC) & R592_REG_MSC_FIFO_EMPTY)
215
dbg("FIFO not ready, trying to reset the device");
216
r592_host_reset(dev);
218
if (r592_read_reg(dev, R592_REG_MSC) & R592_REG_MSC_FIFO_EMPTY)
221
message("FIFO still not ready, giving up");
225
/* Activates the DMA transfer from to FIFO */
226
static void r592_start_dma(struct r592_device *dev, bool is_write)
230
spin_lock_irqsave(&dev->irq_lock, flags);
232
/* Ack interrupts (just in case) + enable them */
233
r592_clear_reg_mask(dev, R592_REG_MSC, DMA_IRQ_ACK_MASK);
234
r592_set_reg_mask(dev, R592_REG_MSC, DMA_IRQ_EN_MASK);
236
/* Set DMA address */
237
r592_write_reg(dev, R592_FIFO_DMA, sg_dma_address(&dev->req->sg));
240
reg = r592_read_reg(dev, R592_FIFO_DMA_SETTINGS);
241
reg |= R592_FIFO_DMA_SETTINGS_EN;
244
reg |= R592_FIFO_DMA_SETTINGS_DIR;
246
reg &= ~R592_FIFO_DMA_SETTINGS_DIR;
247
r592_write_reg(dev, R592_FIFO_DMA_SETTINGS, reg);
249
spin_unlock_irqrestore(&dev->irq_lock, flags);
252
/* Cleanups DMA related settings */
253
static void r592_stop_dma(struct r592_device *dev, int error)
255
r592_clear_reg_mask(dev, R592_FIFO_DMA_SETTINGS,
256
R592_FIFO_DMA_SETTINGS_EN);
258
/* This is only a precation */
259
r592_write_reg(dev, R592_FIFO_DMA,
260
dev->dummy_dma_page_physical_address);
262
r592_clear_reg_mask(dev, R592_REG_MSC, DMA_IRQ_EN_MASK);
263
r592_clear_reg_mask(dev, R592_REG_MSC, DMA_IRQ_ACK_MASK);
264
dev->dma_error = error;
267
/* Test if hardware supports DMA */
268
static void r592_check_dma(struct r592_device *dev)
270
dev->dma_capable = r592_enable_dma &&
271
(r592_read_reg(dev, R592_FIFO_DMA_SETTINGS) &
272
R592_FIFO_DMA_SETTINGS_CAP);
275
/* Transfers fifo contents in/out using DMA */
276
static int r592_transfer_fifo_dma(struct r592_device *dev)
281
if (!dev->dma_capable || !dev->req->long_data)
284
len = dev->req->sg.length;
285
is_write = dev->req->data_dir == WRITE;
287
if (len != R592_LFIFO_SIZE)
290
dbg_verbose("doing dma transfer");
293
INIT_COMPLETION(dev->dma_done);
295
/* TODO: hidden assumption about nenth beeing always 1 */
296
sg_count = dma_map_sg(&dev->pci_dev->dev, &dev->req->sg, 1, is_write ?
297
PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
300
(sg_dma_len(&dev->req->sg) < dev->req->sg.length)) {
301
message("problem in dma_map_sg");
305
r592_start_dma(dev, is_write);
307
/* Wait for DMA completion */
308
if (!wait_for_completion_timeout(
309
&dev->dma_done, msecs_to_jiffies(1000))) {
310
message("DMA timeout");
311
r592_stop_dma(dev, -ETIMEDOUT);
314
dma_unmap_sg(&dev->pci_dev->dev, &dev->req->sg, 1, is_write ?
315
PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
318
return dev->dma_error;
322
* Writes the FIFO in 4 byte chunks.
323
* If length isn't 4 byte aligned, rest of the data if put to a fifo
324
* to be written later
325
* Use r592_flush_fifo_write to flush that fifo when writing for the
328
static void r592_write_fifo_pio(struct r592_device *dev,
329
unsigned char *buffer, int len)
331
/* flush spill from former write */
332
if (!kfifo_is_empty(&dev->pio_fifo)) {
335
int copy_len = kfifo_in(&dev->pio_fifo, buffer, len);
337
if (!kfifo_is_full(&dev->pio_fifo))
342
copy_len = kfifo_out(&dev->pio_fifo, tmp, 4);
343
WARN_ON(copy_len != 4);
344
r592_write_reg_raw_be(dev, R592_FIFO_PIO, *(u32 *)tmp);
347
WARN_ON(!kfifo_is_empty(&dev->pio_fifo));
349
/* write full dwords */
351
r592_write_reg_raw_be(dev, R592_FIFO_PIO, *(u32 *)buffer);
356
/* put remaining bytes to the spill */
358
kfifo_in(&dev->pio_fifo, buffer, len);
361
/* Flushes the temporary FIFO used to make aligned DWORD writes */
362
static void r592_flush_fifo_write(struct r592_device *dev)
364
u8 buffer[4] = { 0 };
367
if (kfifo_is_empty(&dev->pio_fifo))
370
len = kfifo_out(&dev->pio_fifo, buffer, 4);
371
r592_write_reg_raw_be(dev, R592_FIFO_PIO, *(u32 *)buffer);
375
* Read a fifo in 4 bytes chunks.
376
* If input doesn't fit the buffer, it places bytes of last dword in spill
377
* buffer, so that they don't get lost on last read, just throw these away.
379
static void r592_read_fifo_pio(struct r592_device *dev,
380
unsigned char *buffer, int len)
384
/* Read from last spill */
385
if (!kfifo_is_empty(&dev->pio_fifo)) {
387
kfifo_out(&dev->pio_fifo, buffer, min(4, len));
388
buffer += bytes_copied;
391
if (!kfifo_is_empty(&dev->pio_fifo))
395
/* Reads dwords from FIFO */
397
*(u32 *)buffer = r592_read_reg_raw_be(dev, R592_FIFO_PIO);
403
*(u32 *)tmp = r592_read_reg_raw_be(dev, R592_FIFO_PIO);
404
kfifo_in(&dev->pio_fifo, tmp, 4);
405
len -= kfifo_out(&dev->pio_fifo, buffer, len);
412
/* Transfers actual data using PIO. */
413
static int r592_transfer_fifo_pio(struct r592_device *dev)
417
bool is_write = dev->req->tpc >= MS_TPC_SET_RW_REG_ADRS;
418
struct sg_mapping_iter miter;
420
kfifo_reset(&dev->pio_fifo);
422
if (!dev->req->long_data) {
424
r592_write_fifo_pio(dev, dev->req->data,
426
r592_flush_fifo_write(dev);
428
r592_read_fifo_pio(dev, dev->req->data,
433
local_irq_save(flags);
434
sg_miter_start(&miter, &dev->req->sg, 1, SG_MITER_ATOMIC |
435
(is_write ? SG_MITER_FROM_SG : SG_MITER_TO_SG));
437
/* Do the transfer fifo<->memory*/
438
while (sg_miter_next(&miter))
440
r592_write_fifo_pio(dev, miter.addr, miter.length);
442
r592_read_fifo_pio(dev, miter.addr, miter.length);
445
/* Write last few non aligned bytes*/
447
r592_flush_fifo_write(dev);
449
sg_miter_stop(&miter);
450
local_irq_restore(flags);
454
/* Executes one TPC (data is read/written from small or large fifo) */
455
static void r592_execute_tpc(struct r592_device *dev)
457
bool is_write = dev->req->tpc >= MS_TPC_SET_RW_REG_ADRS;
462
message("BUG: tpc execution without request!");
466
len = dev->req->long_data ?
467
dev->req->sg.length : dev->req->data_len;
469
/* Ensure that FIFO can hold the input data */
470
if (len > R592_LFIFO_SIZE) {
471
message("IO: hardware doesn't support TPCs longer that 512");
476
if (!(r592_read_reg(dev, R592_REG_MSC) & R592_REG_MSC_PRSNT)) {
477
dbg("IO: refusing to send TPC because card is absent");
482
dbg("IO: executing %s LEN=%d",
483
memstick_debug_get_tpc_name(dev->req->tpc), len);
485
/* Set IO direction */
487
r592_set_reg_mask(dev, R592_IO, R592_IO_DIRECTION);
489
r592_clear_reg_mask(dev, R592_IO, R592_IO_DIRECTION);
492
error = r592_test_fifo_empty(dev);
496
/* Transfer write data */
498
error = r592_transfer_fifo_dma(dev);
499
if (error == -EINVAL)
500
error = r592_transfer_fifo_pio(dev);
506
/* Trigger the TPC */
507
reg = (len << R592_TPC_EXEC_LEN_SHIFT) |
508
(dev->req->tpc << R592_TPC_EXEC_TPC_SHIFT) |
509
R592_TPC_EXEC_BIG_FIFO;
511
r592_write_reg(dev, R592_TPC_EXEC, reg);
513
/* Wait for TPC completion */
514
status = R592_STATUS_RDY;
515
if (dev->req->need_card_int)
516
status |= R592_STATUS_CED;
518
error = r592_wait_status(dev, status, status);
520
message("card didn't respond");
525
error = r592_test_io_error(dev);
531
/* Read data from FIFO */
533
error = r592_transfer_fifo_dma(dev);
534
if (error == -EINVAL)
535
error = r592_transfer_fifo_pio(dev);
538
/* read INT reg. This can be shortened with shifts, but that way
540
if (dev->parallel_mode && dev->req->need_card_int) {
542
dev->req->int_reg = 0;
543
status = r592_read_reg(dev, R592_STATUS);
545
if (status & R592_STATUS_P_CMDNACK)
546
dev->req->int_reg |= MEMSTICK_INT_CMDNAK;
547
if (status & R592_STATUS_P_BREQ)
548
dev->req->int_reg |= MEMSTICK_INT_BREQ;
549
if (status & R592_STATUS_P_INTERR)
550
dev->req->int_reg |= MEMSTICK_INT_ERR;
551
if (status & R592_STATUS_P_CED)
552
dev->req->int_reg |= MEMSTICK_INT_CED;
556
dbg("FIFO read error");
558
dev->req->error = error;
559
r592_clear_reg_mask(dev, R592_REG_MSC, R592_REG_MSC_LED);
563
/* Main request processing thread */
564
static int r592_process_thread(void *data)
567
struct r592_device *dev = (struct r592_device *)data;
570
while (!kthread_should_stop()) {
571
spin_lock_irqsave(&dev->io_thread_lock, flags);
572
set_current_state(TASK_INTERRUPTIBLE);
573
error = memstick_next_req(dev->host, &dev->req);
574
spin_unlock_irqrestore(&dev->io_thread_lock, flags);
577
if (error == -ENXIO || error == -EAGAIN) {
578
dbg_verbose("IO: done IO, sleeping");
580
dbg("IO: unknown error from "
581
"memstick_next_req %d", error);
584
if (kthread_should_stop())
585
set_current_state(TASK_RUNNING);
589
set_current_state(TASK_RUNNING);
590
r592_execute_tpc(dev);
596
/* Reprogram chip to detect change in card state */
597
/* eg, if card is detected, arm it to detect removal, and vice versa */
598
static void r592_update_card_detect(struct r592_device *dev)
600
u32 reg = r592_read_reg(dev, R592_REG_MSC);
601
bool card_detected = reg & R592_REG_MSC_PRSNT;
603
dbg("update card detect. card state: %s", card_detected ?
604
"present" : "absent");
606
reg &= ~((R592_REG_MSC_IRQ_REMOVE | R592_REG_MSC_IRQ_INSERT) << 16);
609
reg |= (R592_REG_MSC_IRQ_REMOVE << 16);
611
reg |= (R592_REG_MSC_IRQ_INSERT << 16);
613
r592_write_reg(dev, R592_REG_MSC, reg);
616
/* Timer routine that fires 1 second after last card detection event, */
617
static void r592_detect_timer(long unsigned int data)
619
struct r592_device *dev = (struct r592_device *)data;
620
r592_update_card_detect(dev);
621
memstick_detect_change(dev->host);
624
/* Interrupt handler */
625
static irqreturn_t r592_irq(int irq, void *data)
627
struct r592_device *dev = (struct r592_device *)data;
628
irqreturn_t ret = IRQ_NONE;
630
u16 irq_enable, irq_status;
634
spin_lock_irqsave(&dev->irq_lock, flags);
636
reg = r592_read_reg(dev, R592_REG_MSC);
637
irq_enable = reg >> 16;
638
irq_status = reg & 0xFFFF;
640
/* Ack the interrupts */
642
r592_write_reg(dev, R592_REG_MSC, reg);
644
/* Get the IRQ status minus bits that aren't enabled */
645
irq_status &= (irq_enable);
647
/* Due to limitation of memstick core, we don't look at bits that
648
indicate that card was removed/inserted and/or present */
649
if (irq_status & (R592_REG_MSC_IRQ_INSERT | R592_REG_MSC_IRQ_REMOVE)) {
651
bool card_was_added = irq_status & R592_REG_MSC_IRQ_INSERT;
654
message("IRQ: card %s", card_was_added ? "added" : "removed");
656
mod_timer(&dev->detect_timer,
657
jiffies + msecs_to_jiffies(card_was_added ? 500 : 50));
661
(R592_REG_MSC_FIFO_DMA_DONE | R592_REG_MSC_FIFO_DMA_ERR)) {
664
if (irq_status & R592_REG_MSC_FIFO_DMA_ERR) {
665
message("IRQ: DMA error");
668
dbg_verbose("IRQ: dma done");
672
r592_stop_dma(dev, error);
673
complete(&dev->dma_done);
676
spin_unlock_irqrestore(&dev->irq_lock, flags);
680
/* External inteface: set settings */
681
static int r592_set_param(struct memstick_host *host,
682
enum memstick_param param, int value)
684
struct r592_device *dev = memstick_priv(host);
689
case MEMSTICK_POWER_ON:
690
return r592_enable_device(dev, true);
691
case MEMSTICK_POWER_OFF:
692
return r592_enable_device(dev, false);
696
case MEMSTICK_INTERFACE:
698
case MEMSTICK_SERIAL:
699
return r592_set_mode(dev, 0);
701
return r592_set_mode(dev, 1);
710
/* External interface: submit requests */
711
static void r592_submit_req(struct memstick_host *host)
713
struct r592_device *dev = memstick_priv(host);
719
spin_lock_irqsave(&dev->io_thread_lock, flags);
720
if (wake_up_process(dev->io_thread))
721
dbg_verbose("IO thread woken to process requests");
722
spin_unlock_irqrestore(&dev->io_thread_lock, flags);
725
static const struct pci_device_id r592_pci_id_tbl[] = {
727
{ PCI_VDEVICE(RICOH, 0x0592), },
732
static int r592_probe(struct pci_dev *pdev, const struct pci_device_id *id)
735
struct memstick_host *host;
736
struct r592_device *dev;
738
/* Allocate memory */
739
host = memstick_alloc_host(sizeof(struct r592_device), &pdev->dev);
743
dev = memstick_priv(host);
746
pci_set_drvdata(pdev, dev);
748
/* pci initialization */
749
error = pci_enable_device(pdev);
753
pci_set_master(pdev);
754
error = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
758
error = pci_request_regions(pdev, DRV_NAME);
762
dev->mmio = pci_ioremap_bar(pdev, 0);
766
dev->irq = pdev->irq;
767
spin_lock_init(&dev->irq_lock);
768
spin_lock_init(&dev->io_thread_lock);
769
init_completion(&dev->dma_done);
770
INIT_KFIFO(dev->pio_fifo);
771
setup_timer(&dev->detect_timer,
772
r592_detect_timer, (long unsigned int)dev);
774
/* Host initialization */
775
host->caps = MEMSTICK_CAP_PAR4;
776
host->request = r592_submit_req;
777
host->set_param = r592_set_param;
780
dev->io_thread = kthread_run(r592_process_thread, dev, "r592_io");
781
if (IS_ERR(dev->io_thread)) {
782
error = PTR_ERR(dev->io_thread);
786
/* This is just a precation, so don't fail */
787
dev->dummy_dma_page = pci_alloc_consistent(pdev, PAGE_SIZE,
788
&dev->dummy_dma_page_physical_address);
789
r592_stop_dma(dev , 0);
791
if (request_irq(dev->irq, &r592_irq, IRQF_SHARED,
795
r592_update_card_detect(dev);
796
if (memstick_add_host(host))
799
message("driver successfully loaded");
802
free_irq(dev->irq, dev);
804
if (dev->dummy_dma_page)
805
pci_free_consistent(pdev, PAGE_SIZE, dev->dummy_dma_page,
806
dev->dummy_dma_page_physical_address);
808
kthread_stop(dev->io_thread);
812
pci_release_regions(pdev);
814
pci_disable_device(pdev);
816
memstick_free_host(host);
821
static void r592_remove(struct pci_dev *pdev)
824
struct r592_device *dev = pci_get_drvdata(pdev);
826
/* Stop the processing thread.
827
That ensures that we won't take any more requests */
828
kthread_stop(dev->io_thread);
830
r592_enable_device(dev, false);
832
while (!error && dev->req) {
833
dev->req->error = -ETIME;
834
error = memstick_next_req(dev->host, &dev->req);
836
memstick_remove_host(dev->host);
838
free_irq(dev->irq, dev);
840
pci_release_regions(pdev);
841
pci_disable_device(pdev);
842
memstick_free_host(dev->host);
844
if (dev->dummy_dma_page)
845
pci_free_consistent(pdev, PAGE_SIZE, dev->dummy_dma_page,
846
dev->dummy_dma_page_physical_address);
850
static int r592_suspend(struct device *core_dev)
852
struct pci_dev *pdev = to_pci_dev(core_dev);
853
struct r592_device *dev = pci_get_drvdata(pdev);
855
r592_clear_interrupts(dev);
856
memstick_suspend_host(dev->host);
857
del_timer_sync(&dev->detect_timer);
861
static int r592_resume(struct device *core_dev)
863
struct pci_dev *pdev = to_pci_dev(core_dev);
864
struct r592_device *dev = pci_get_drvdata(pdev);
866
r592_clear_interrupts(dev);
867
r592_enable_device(dev, false);
868
memstick_resume_host(dev->host);
869
r592_update_card_detect(dev);
873
SIMPLE_DEV_PM_OPS(r592_pm_ops, r592_suspend, r592_resume);
876
MODULE_DEVICE_TABLE(pci, r592_pci_id_tbl);
878
static struct pci_driver r852_pci_driver = {
880
.id_table = r592_pci_id_tbl,
882
.remove = r592_remove,
884
.driver.pm = &r592_pm_ops,
888
static __init int r592_module_init(void)
890
return pci_register_driver(&r852_pci_driver);
893
static void __exit r592_module_exit(void)
895
pci_unregister_driver(&r852_pci_driver);
898
module_init(r592_module_init);
899
module_exit(r592_module_exit);
901
module_param_named(enable_dma, r592_enable_dma, bool, S_IRUGO);
902
MODULE_PARM_DESC(enable_dma, "Enable usage of the DMA (default)");
903
module_param(debug, int, S_IRUGO | S_IWUSR);
904
MODULE_PARM_DESC(debug, "Debug level (0-3)");
906
MODULE_LICENSE("GPL");
907
MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
908
MODULE_DESCRIPTION("Ricoh R5C592 Memstick/Memstick PRO card reader driver");