2 * Copyright © 2009 - Maxim Levitsky
3 * driver for Ricoh xD 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/jiffies.h>
13 #include <linux/workqueue.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 <asm/byteorder.h>
20 #include <linux/sched.h>
21 #include "sm_common.h"
25 static int r852_enable_dma
= 1;
26 module_param(r852_enable_dma
, bool, S_IRUGO
);
27 MODULE_PARM_DESC(r852_enable_dma
, "Enable usage of the DMA (default)");
30 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
31 MODULE_PARM_DESC(debug
, "Debug level (0-2)");
34 static inline uint8_t r852_read_reg(struct r852_device
*dev
, int address
)
36 uint8_t reg
= readb(dev
->mmio
+ address
);
41 static inline void r852_write_reg(struct r852_device
*dev
,
42 int address
, uint8_t value
)
44 writeb(value
, dev
->mmio
+ address
);
49 /* read dword sized register */
50 static inline uint32_t r852_read_reg_dword(struct r852_device
*dev
, int address
)
52 uint32_t reg
= le32_to_cpu(readl(dev
->mmio
+ address
));
56 /* write dword sized register */
57 static inline void r852_write_reg_dword(struct r852_device
*dev
,
58 int address
, uint32_t value
)
60 writel(cpu_to_le32(value
), dev
->mmio
+ address
);
64 /* returns pointer to our private structure */
65 static inline struct r852_device
*r852_get_dev(struct mtd_info
*mtd
)
67 struct nand_chip
*chip
= (struct nand_chip
*)mtd
->priv
;
68 return (struct r852_device
*)chip
->priv
;
72 /* check if controller supports dma */
73 static void r852_dma_test(struct r852_device
*dev
)
75 dev
->dma_usable
= (r852_read_reg(dev
, R852_DMA_CAP
) &
76 (R852_DMA1
| R852_DMA2
)) == (R852_DMA1
| R852_DMA2
);
79 message("Non dma capable device detected, dma disabled");
81 if (!r852_enable_dma
) {
82 message("disabling dma on user request");
88 * Enable dma. Enables ether first or second stage of the DMA,
89 * Expects dev->dma_dir and dev->dma_state be set
91 static void r852_dma_enable(struct r852_device
*dev
)
93 uint8_t dma_reg
, dma_irq_reg
;
95 /* Set up dma settings */
96 dma_reg
= r852_read_reg_dword(dev
, R852_DMA_SETTINGS
);
97 dma_reg
&= ~(R852_DMA_READ
| R852_DMA_INTERNAL
| R852_DMA_MEMORY
);
100 dma_reg
|= R852_DMA_READ
;
102 if (dev
->dma_state
== DMA_INTERNAL
) {
103 dma_reg
|= R852_DMA_INTERNAL
;
104 /* Precaution to make sure HW doesn't write */
105 /* to random kernel memory */
106 r852_write_reg_dword(dev
, R852_DMA_ADDR
,
107 cpu_to_le32(dev
->phys_bounce_buffer
));
109 dma_reg
|= R852_DMA_MEMORY
;
110 r852_write_reg_dword(dev
, R852_DMA_ADDR
,
111 cpu_to_le32(dev
->phys_dma_addr
));
114 /* Precaution: make sure write reached the device */
115 r852_read_reg_dword(dev
, R852_DMA_ADDR
);
117 r852_write_reg_dword(dev
, R852_DMA_SETTINGS
, dma_reg
);
120 dma_irq_reg
= r852_read_reg_dword(dev
, R852_DMA_IRQ_ENABLE
);
121 r852_write_reg_dword(dev
, R852_DMA_IRQ_ENABLE
,
123 R852_DMA_IRQ_INTERNAL
|
125 R852_DMA_IRQ_MEMORY
);
129 * Disable dma, called from the interrupt handler, which specifies
130 * success of the operation via 'error' argument
132 static void r852_dma_done(struct r852_device
*dev
, int error
)
134 WARN_ON(dev
->dma_stage
== 0);
136 r852_write_reg_dword(dev
, R852_DMA_IRQ_STA
,
137 r852_read_reg_dword(dev
, R852_DMA_IRQ_STA
));
139 r852_write_reg_dword(dev
, R852_DMA_SETTINGS
, 0);
140 r852_write_reg_dword(dev
, R852_DMA_IRQ_ENABLE
, 0);
142 /* Precaution to make sure HW doesn't write to random kernel memory */
143 r852_write_reg_dword(dev
, R852_DMA_ADDR
,
144 cpu_to_le32(dev
->phys_bounce_buffer
));
145 r852_read_reg_dword(dev
, R852_DMA_ADDR
);
147 dev
->dma_error
= error
;
150 if (dev
->phys_dma_addr
&& dev
->phys_dma_addr
!= dev
->phys_bounce_buffer
)
151 pci_unmap_single(dev
->pci_dev
, dev
->phys_dma_addr
, R852_DMA_LEN
,
152 dev
->dma_dir
? PCI_DMA_FROMDEVICE
: PCI_DMA_TODEVICE
);
153 complete(&dev
->dma_done
);
157 * Wait, till dma is done, which includes both phases of it
159 static int r852_dma_wait(struct r852_device
*dev
)
161 long timeout
= wait_for_completion_timeout(&dev
->dma_done
,
162 msecs_to_jiffies(1000));
164 dbg("timeout waiting for DMA interrupt");
172 * Read/Write one page using dma. Only pages can be read (512 bytes)
174 static void r852_do_dma(struct r852_device
*dev
, uint8_t *buf
, int do_read
)
182 /* Set dma direction */
183 dev
->dma_dir
= do_read
;
186 dbg_verbose("doing dma %s ", do_read
? "read" : "write");
188 /* Set intial dma state: for reading first fill on board buffer,
189 from device, for writes first fill the buffer from memory*/
190 dev
->dma_state
= do_read
? DMA_INTERNAL
: DMA_MEMORY
;
192 /* if incoming buffer is not page aligned, we should do bounce */
193 if ((unsigned long)buf
& (R852_DMA_LEN
-1))
197 dev
->phys_dma_addr
= pci_map_single(dev
->pci_dev
, (void *)buf
,
199 (do_read
? PCI_DMA_FROMDEVICE
: PCI_DMA_TODEVICE
));
201 if (pci_dma_mapping_error(dev
->pci_dev
, dev
->phys_dma_addr
))
206 dbg_verbose("dma: using bounce buffer");
207 dev
->phys_dma_addr
= dev
->phys_bounce_buffer
;
209 memcpy(dev
->bounce_buffer
, buf
, R852_DMA_LEN
);
213 spin_lock_irqsave(&dev
->irqlock
, flags
);
214 r852_dma_enable(dev
);
215 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
217 /* Wait till complete */
218 error
= r852_dma_wait(dev
);
221 r852_dma_done(dev
, error
);
225 if (do_read
&& bounce
)
226 memcpy((void *)buf
, dev
->bounce_buffer
, R852_DMA_LEN
);
230 * Program data lines of the nand chip to send data to it
232 void r852_write_buf(struct mtd_info
*mtd
, const uint8_t *buf
, int len
)
234 struct r852_device
*dev
= r852_get_dev(mtd
);
237 /* Don't allow any access to hardware if we suspect card removal */
238 if (dev
->card_unstable
)
241 /* Special case for whole sector read */
242 if (len
== R852_DMA_LEN
&& dev
->dma_usable
) {
243 r852_do_dma(dev
, (uint8_t *)buf
, 0);
247 /* write DWORD chinks - faster */
249 reg
= buf
[0] | buf
[1] << 8 | buf
[2] << 16 | buf
[3] << 24;
250 r852_write_reg_dword(dev
, R852_DATALINE
, reg
);
258 r852_write_reg(dev
, R852_DATALINE
, *buf
++);
262 * Read data lines of the nand chip to retrieve data
264 void r852_read_buf(struct mtd_info
*mtd
, uint8_t *buf
, int len
)
266 struct r852_device
*dev
= r852_get_dev(mtd
);
269 if (dev
->card_unstable
) {
270 /* since we can't signal error here, at least, return
271 predictable buffer */
276 /* special case for whole sector read */
277 if (len
== R852_DMA_LEN
&& dev
->dma_usable
) {
278 r852_do_dma(dev
, buf
, 1);
282 /* read in dword sized chunks */
285 reg
= r852_read_reg_dword(dev
, R852_DATALINE
);
287 *buf
++ = (reg
>> 8) & 0xFF;
288 *buf
++ = (reg
>> 16) & 0xFF;
289 *buf
++ = (reg
>> 24) & 0xFF;
293 /* read the reset by bytes */
295 *buf
++ = r852_read_reg(dev
, R852_DATALINE
);
299 * Read one byte from nand chip
301 static uint8_t r852_read_byte(struct mtd_info
*mtd
)
303 struct r852_device
*dev
= r852_get_dev(mtd
);
305 /* Same problem as in r852_read_buf.... */
306 if (dev
->card_unstable
)
309 return r852_read_reg(dev
, R852_DATALINE
);
314 * Readback the buffer to verify it
316 int r852_verify_buf(struct mtd_info
*mtd
, const uint8_t *buf
, int len
)
318 struct r852_device
*dev
= r852_get_dev(mtd
);
320 /* We can't be sure about anything here... */
321 if (dev
->card_unstable
)
324 /* This will never happen, unless you wired up a nand chip
325 with > 512 bytes page size to the reader */
326 if (len
> SM_SECTOR_SIZE
)
329 r852_read_buf(mtd
, dev
->tmp_buffer
, len
);
330 return memcmp(buf
, dev
->tmp_buffer
, len
);
334 * Control several chip lines & send commands
336 void r852_cmdctl(struct mtd_info
*mtd
, int dat
, unsigned int ctrl
)
338 struct r852_device
*dev
= r852_get_dev(mtd
);
340 if (dev
->card_unstable
)
343 if (ctrl
& NAND_CTRL_CHANGE
) {
345 dev
->ctlreg
&= ~(R852_CTL_DATA
| R852_CTL_COMMAND
|
346 R852_CTL_ON
| R852_CTL_CARDENABLE
);
349 dev
->ctlreg
|= R852_CTL_DATA
;
352 dev
->ctlreg
|= R852_CTL_COMMAND
;
355 dev
->ctlreg
|= (R852_CTL_CARDENABLE
| R852_CTL_ON
);
357 dev
->ctlreg
&= ~R852_CTL_WRITE
;
359 /* when write is stareted, enable write access */
360 if (dat
== NAND_CMD_ERASE1
)
361 dev
->ctlreg
|= R852_CTL_WRITE
;
363 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
);
366 /* HACK: NAND_CMD_SEQIN is called without NAND_CTRL_CHANGE, but we need
368 if (dat
== NAND_CMD_SEQIN
&& (dev
->ctlreg
& R852_CTL_COMMAND
)) {
369 dev
->ctlreg
|= R852_CTL_WRITE
;
370 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
);
373 if (dat
!= NAND_CMD_NONE
)
374 r852_write_reg(dev
, R852_DATALINE
, dat
);
378 * Wait till card is ready.
379 * based on nand_wait, but returns errors on DMA error
381 int r852_wait(struct mtd_info
*mtd
, struct nand_chip
*chip
)
383 struct r852_device
*dev
= (struct r852_device
*)chip
->priv
;
385 unsigned long timeout
;
388 timeout
= jiffies
+ (chip
->state
== FL_ERASING
?
389 msecs_to_jiffies(400) : msecs_to_jiffies(20));
391 while (time_before(jiffies
, timeout
))
392 if (chip
->dev_ready(mtd
))
395 chip
->cmdfunc(mtd
, NAND_CMD_STATUS
, -1, -1);
396 status
= (int)chip
->read_byte(mtd
);
398 /* Unfortunelly, no way to send detailed error status... */
399 if (dev
->dma_error
) {
400 status
|= NAND_STATUS_FAIL
;
407 * Check if card is ready
410 int r852_ready(struct mtd_info
*mtd
)
412 struct r852_device
*dev
= r852_get_dev(mtd
);
413 return !(r852_read_reg(dev
, R852_CARD_STA
) & R852_CARD_STA_BUSY
);
418 * Set ECC engine mode
421 void r852_ecc_hwctl(struct mtd_info
*mtd
, int mode
)
423 struct r852_device
*dev
= r852_get_dev(mtd
);
425 if (dev
->card_unstable
)
431 /* enable ecc generation/check*/
432 dev
->ctlreg
|= R852_CTL_ECC_ENABLE
;
434 /* flush ecc buffer */
435 r852_write_reg(dev
, R852_CTL
,
436 dev
->ctlreg
| R852_CTL_ECC_ACCESS
);
438 r852_read_reg_dword(dev
, R852_DATALINE
);
439 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
);
442 case NAND_ECC_READSYN
:
443 /* disable ecc generation */
444 dev
->ctlreg
&= ~R852_CTL_ECC_ENABLE
;
445 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
);
450 * Calculate ECC, only used for writes
453 int r852_ecc_calculate(struct mtd_info
*mtd
, const uint8_t *dat
,
456 struct r852_device
*dev
= r852_get_dev(mtd
);
457 struct sm_oob
*oob
= (struct sm_oob
*)ecc_code
;
460 if (dev
->card_unstable
)
463 dev
->ctlreg
&= ~R852_CTL_ECC_ENABLE
;
464 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
| R852_CTL_ECC_ACCESS
);
466 ecc1
= r852_read_reg_dword(dev
, R852_DATALINE
);
467 ecc2
= r852_read_reg_dword(dev
, R852_DATALINE
);
469 oob
->ecc1
[0] = (ecc1
) & 0xFF;
470 oob
->ecc1
[1] = (ecc1
>> 8) & 0xFF;
471 oob
->ecc1
[2] = (ecc1
>> 16) & 0xFF;
473 oob
->ecc2
[0] = (ecc2
) & 0xFF;
474 oob
->ecc2
[1] = (ecc2
>> 8) & 0xFF;
475 oob
->ecc2
[2] = (ecc2
>> 16) & 0xFF;
477 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
);
482 * Correct the data using ECC, hw did almost everything for us
485 int r852_ecc_correct(struct mtd_info
*mtd
, uint8_t *dat
,
486 uint8_t *read_ecc
, uint8_t *calc_ecc
)
489 uint8_t ecc_status
, err_byte
;
492 struct r852_device
*dev
= r852_get_dev(mtd
);
494 if (dev
->card_unstable
)
497 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
| R852_CTL_ECC_ACCESS
);
498 ecc_reg
= r852_read_reg_dword(dev
, R852_DATALINE
);
499 r852_write_reg(dev
, R852_CTL
, dev
->ctlreg
);
501 for (i
= 0 ; i
<= 1 ; i
++) {
503 ecc_status
= (ecc_reg
>> 8) & 0xFF;
505 /* ecc uncorrectable error */
506 if (ecc_status
& R852_ECC_FAIL
) {
507 dbg("ecc: unrecoverable error, in half %d", i
);
512 /* correctable error */
513 if (ecc_status
& R852_ECC_CORRECTABLE
) {
515 err_byte
= ecc_reg
& 0xFF;
516 dbg("ecc: recoverable error, "
517 "in half %d, byte %d, bit %d", i
,
518 err_byte
, ecc_status
& R852_ECC_ERR_BIT_MSK
);
521 1 << (ecc_status
& R852_ECC_ERR_BIT_MSK
);
533 * This is copy of nand_read_oob_std
534 * nand_read_oob_syndrome assumes we can send column address - we can't
536 static int r852_read_oob(struct mtd_info
*mtd
, struct nand_chip
*chip
,
537 int page
, int sndcmd
)
540 chip
->cmdfunc(mtd
, NAND_CMD_READOOB
, 0, page
);
543 chip
->read_buf(mtd
, chip
->oob_poi
, mtd
->oobsize
);
548 * Start the nand engine
551 void r852_engine_enable(struct r852_device
*dev
)
553 if (r852_read_reg_dword(dev
, R852_HW
) & R852_HW_UNKNOWN
) {
554 r852_write_reg(dev
, R852_CTL
, R852_CTL_RESET
| R852_CTL_ON
);
555 r852_write_reg_dword(dev
, R852_HW
, R852_HW_ENABLED
);
557 r852_write_reg_dword(dev
, R852_HW
, R852_HW_ENABLED
);
558 r852_write_reg(dev
, R852_CTL
, R852_CTL_RESET
| R852_CTL_ON
);
561 r852_write_reg(dev
, R852_CTL
, 0);
566 * Stop the nand engine
569 void r852_engine_disable(struct r852_device
*dev
)
571 r852_write_reg_dword(dev
, R852_HW
, 0);
572 r852_write_reg(dev
, R852_CTL
, R852_CTL_RESET
);
576 * Test if card is present
579 void r852_card_update_present(struct r852_device
*dev
)
584 spin_lock_irqsave(&dev
->irqlock
, flags
);
585 reg
= r852_read_reg(dev
, R852_CARD_STA
);
586 dev
->card_detected
= !!(reg
& R852_CARD_STA_PRESENT
);
587 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
591 * Update card detection IRQ state according to current card state
592 * which is read in r852_card_update_present
594 void r852_update_card_detect(struct r852_device
*dev
)
596 int card_detect_reg
= r852_read_reg(dev
, R852_CARD_IRQ_ENABLE
);
597 dev
->card_unstable
= 0;
599 card_detect_reg
&= ~(R852_CARD_IRQ_REMOVE
| R852_CARD_IRQ_INSERT
);
600 card_detect_reg
|= R852_CARD_IRQ_GENABLE
;
602 card_detect_reg
|= dev
->card_detected
?
603 R852_CARD_IRQ_REMOVE
: R852_CARD_IRQ_INSERT
;
605 r852_write_reg(dev
, R852_CARD_IRQ_ENABLE
, card_detect_reg
);
608 ssize_t
r852_media_type_show(struct device
*sys_dev
,
609 struct device_attribute
*attr
, char *buf
)
611 struct mtd_info
*mtd
= container_of(sys_dev
, struct mtd_info
, dev
);
612 struct r852_device
*dev
= r852_get_dev(mtd
);
613 char *data
= dev
->sm
? "smartmedia" : "xd";
619 DEVICE_ATTR(media_type
, S_IRUGO
, r852_media_type_show
, NULL
);
622 /* Detect properties of card in slot */
623 void r852_update_media_status(struct r852_device
*dev
)
629 spin_lock_irqsave(&dev
->irqlock
, flags
);
630 if (!dev
->card_detected
) {
631 message("card removed");
632 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
636 readonly
= r852_read_reg(dev
, R852_CARD_STA
) & R852_CARD_STA_RO
;
637 reg
= r852_read_reg(dev
, R852_DMA_CAP
);
638 dev
->sm
= (reg
& (R852_DMA1
| R852_DMA2
)) && (reg
& R852_SMBIT
);
640 message("detected %s %s card in slot",
641 dev
->sm
? "SmartMedia" : "xD",
642 readonly
? "readonly" : "writeable");
644 dev
->readonly
= readonly
;
645 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
649 * Register the nand device
650 * Called when the card is detected
652 int r852_register_nand_device(struct r852_device
*dev
)
654 dev
->mtd
= kzalloc(sizeof(struct mtd_info
), GFP_KERNEL
);
659 WARN_ON(dev
->card_registred
);
661 dev
->mtd
->owner
= THIS_MODULE
;
662 dev
->mtd
->priv
= dev
->chip
;
663 dev
->mtd
->dev
.parent
= &dev
->pci_dev
->dev
;
666 dev
->chip
->options
|= NAND_ROM
;
668 r852_engine_enable(dev
);
670 if (sm_register_device(dev
->mtd
, dev
->sm
))
673 if (device_create_file(&dev
->mtd
->dev
, &dev_attr_media_type
))
674 message("can't create media type sysfs attribute");
676 dev
->card_registred
= 1;
681 /* Force card redetect */
682 dev
->card_detected
= 0;
687 * Unregister the card
690 void r852_unregister_nand_device(struct r852_device
*dev
)
692 if (!dev
->card_registred
)
695 device_remove_file(&dev
->mtd
->dev
, &dev_attr_media_type
);
696 nand_release(dev
->mtd
);
697 r852_engine_disable(dev
);
698 dev
->card_registred
= 0;
703 /* Card state updater */
704 void r852_card_detect_work(struct work_struct
*work
)
706 struct r852_device
*dev
=
707 container_of(work
, struct r852_device
, card_detect_work
.work
);
709 r852_card_update_present(dev
);
710 dev
->card_unstable
= 0;
713 if (dev
->card_detected
== dev
->card_registred
)
716 /* Read media properties */
717 r852_update_media_status(dev
);
719 /* Register the card */
720 if (dev
->card_detected
)
721 r852_register_nand_device(dev
);
723 r852_unregister_nand_device(dev
);
725 /* Update detection logic */
726 r852_update_card_detect(dev
);
729 /* Ack + disable IRQ generation */
730 static void r852_disable_irqs(struct r852_device
*dev
)
733 reg
= r852_read_reg(dev
, R852_CARD_IRQ_ENABLE
);
734 r852_write_reg(dev
, R852_CARD_IRQ_ENABLE
, reg
& ~R852_CARD_IRQ_MASK
);
736 reg
= r852_read_reg_dword(dev
, R852_DMA_IRQ_ENABLE
);
737 r852_write_reg_dword(dev
, R852_DMA_IRQ_ENABLE
,
738 reg
& ~R852_DMA_IRQ_MASK
);
740 r852_write_reg(dev
, R852_CARD_IRQ_STA
, R852_CARD_IRQ_MASK
);
741 r852_write_reg_dword(dev
, R852_DMA_IRQ_STA
, R852_DMA_IRQ_MASK
);
744 /* Interrupt handler */
745 static irqreturn_t
r852_irq(int irq
, void *data
)
747 struct r852_device
*dev
= (struct r852_device
*)data
;
749 uint8_t card_status
, dma_status
;
751 irqreturn_t ret
= IRQ_NONE
;
753 spin_lock_irqsave(&dev
->irqlock
, flags
);
755 /* We can recieve shared interrupt while pci is suspended
756 in that case reads will return 0xFFFFFFFF.... */
760 /* handle card detection interrupts first */
761 card_status
= r852_read_reg(dev
, R852_CARD_IRQ_STA
);
762 r852_write_reg(dev
, R852_CARD_IRQ_STA
, card_status
);
764 if (card_status
& (R852_CARD_IRQ_INSERT
|R852_CARD_IRQ_REMOVE
)) {
767 dev
->card_detected
= !!(card_status
& R852_CARD_IRQ_INSERT
);
769 /* we shouldn't recieve any interrupts if we wait for card
771 WARN_ON(dev
->card_unstable
);
773 /* disable irqs while card is unstable */
774 /* this will timeout DMA if active, but better that garbage */
775 r852_disable_irqs(dev
);
777 if (dev
->card_unstable
)
780 /* let, card state to settle a bit, and then do the work */
781 dev
->card_unstable
= 1;
782 queue_delayed_work(dev
->card_workqueue
,
783 &dev
->card_detect_work
, msecs_to_jiffies(100));
788 /* Handle dma interrupts */
789 dma_status
= r852_read_reg_dword(dev
, R852_DMA_IRQ_STA
);
790 r852_write_reg_dword(dev
, R852_DMA_IRQ_STA
, dma_status
);
792 if (dma_status
& R852_DMA_IRQ_MASK
) {
796 if (dma_status
& R852_DMA_IRQ_ERROR
) {
797 dbg("recieved dma error IRQ");
798 r852_dma_done(dev
, -EIO
);
802 /* recieved DMA interrupt out of nowhere? */
803 WARN_ON_ONCE(dev
->dma_stage
== 0);
805 if (dev
->dma_stage
== 0)
808 /* done device access */
809 if (dev
->dma_state
== DMA_INTERNAL
&&
810 (dma_status
& R852_DMA_IRQ_INTERNAL
)) {
812 dev
->dma_state
= DMA_MEMORY
;
816 /* done memory DMA */
817 if (dev
->dma_state
== DMA_MEMORY
&&
818 (dma_status
& R852_DMA_IRQ_MEMORY
)) {
819 dev
->dma_state
= DMA_INTERNAL
;
823 /* Enable 2nd half of dma dance */
824 if (dev
->dma_stage
== 2)
825 r852_dma_enable(dev
);
828 if (dev
->dma_stage
== 3)
829 r852_dma_done(dev
, 0);
833 /* Handle unknown interrupts */
835 dbg("bad dma IRQ status = %x", dma_status
);
837 if (card_status
& ~R852_CARD_STA_CD
)
838 dbg("strange card status = %x", card_status
);
841 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
845 int r852_probe(struct pci_dev
*pci_dev
, const struct pci_device_id
*id
)
848 struct nand_chip
*chip
;
849 struct r852_device
*dev
;
851 /* pci initialization */
852 error
= pci_enable_device(pci_dev
);
857 pci_set_master(pci_dev
);
859 error
= pci_set_dma_mask(pci_dev
, DMA_BIT_MASK(32));
863 error
= pci_request_regions(pci_dev
, DRV_NAME
);
870 /* init nand chip, but register it only on card insert */
871 chip
= kzalloc(sizeof(struct nand_chip
), GFP_KERNEL
);
877 chip
->cmd_ctrl
= r852_cmdctl
;
878 chip
->waitfunc
= r852_wait
;
879 chip
->dev_ready
= r852_ready
;
882 chip
->read_byte
= r852_read_byte
;
883 chip
->read_buf
= r852_read_buf
;
884 chip
->write_buf
= r852_write_buf
;
885 chip
->verify_buf
= r852_verify_buf
;
888 chip
->ecc
.mode
= NAND_ECC_HW_SYNDROME
;
889 chip
->ecc
.size
= R852_DMA_LEN
;
890 chip
->ecc
.bytes
= SM_OOB_SIZE
;
891 chip
->ecc
.hwctl
= r852_ecc_hwctl
;
892 chip
->ecc
.calculate
= r852_ecc_calculate
;
893 chip
->ecc
.correct
= r852_ecc_correct
;
896 chip
->ecc
.read_oob
= r852_read_oob
;
898 /* init our device structure */
899 dev
= kzalloc(sizeof(struct r852_device
), GFP_KERNEL
);
906 dev
->pci_dev
= pci_dev
;
907 pci_set_drvdata(pci_dev
, dev
);
909 dev
->bounce_buffer
= pci_alloc_consistent(pci_dev
, R852_DMA_LEN
,
910 &dev
->phys_bounce_buffer
);
912 if (!dev
->bounce_buffer
)
917 dev
->mmio
= pci_ioremap_bar(pci_dev
, 0);
923 dev
->tmp_buffer
= kzalloc(SM_SECTOR_SIZE
, GFP_KERNEL
);
925 if (!dev
->tmp_buffer
)
928 init_completion(&dev
->dma_done
);
930 dev
->card_workqueue
= create_freezeable_workqueue(DRV_NAME
);
932 if (!dev
->card_workqueue
)
935 INIT_DELAYED_WORK(&dev
->card_detect_work
, r852_card_detect_work
);
937 /* shutdown everything - precation */
938 r852_engine_disable(dev
);
939 r852_disable_irqs(dev
);
943 /*register irq handler*/
945 if (request_irq(pci_dev
->irq
, &r852_irq
, IRQF_SHARED
,
949 dev
->irq
= pci_dev
->irq
;
950 spin_lock_init(&dev
->irqlock
);
952 /* kick initial present test */
953 dev
->card_detected
= 0;
954 r852_card_update_present(dev
);
955 queue_delayed_work(dev
->card_workqueue
,
956 &dev
->card_detect_work
, 0);
959 printk(KERN_NOTICE DRV_NAME
": driver loaded succesfully\n");
963 destroy_workqueue(dev
->card_workqueue
);
965 kfree(dev
->tmp_buffer
);
967 pci_iounmap(pci_dev
, dev
->mmio
);
969 pci_free_consistent(pci_dev
, R852_DMA_LEN
,
970 dev
->bounce_buffer
, dev
->phys_bounce_buffer
);
976 pci_release_regions(pci_dev
);
979 pci_disable_device(pci_dev
);
984 void r852_remove(struct pci_dev
*pci_dev
)
986 struct r852_device
*dev
= pci_get_drvdata(pci_dev
);
988 /* Stop detect workqueue -
989 we are going to unregister the device anyway*/
990 cancel_delayed_work_sync(&dev
->card_detect_work
);
991 destroy_workqueue(dev
->card_workqueue
);
993 /* Unregister the device, this might make more IO */
994 r852_unregister_nand_device(dev
);
996 /* Stop interrupts */
997 r852_disable_irqs(dev
);
998 synchronize_irq(dev
->irq
);
999 free_irq(dev
->irq
, dev
);
1002 kfree(dev
->tmp_buffer
);
1003 pci_iounmap(pci_dev
, dev
->mmio
);
1004 pci_free_consistent(pci_dev
, R852_DMA_LEN
,
1005 dev
->bounce_buffer
, dev
->phys_bounce_buffer
);
1010 /* Shutdown the PCI device */
1011 pci_release_regions(pci_dev
);
1012 pci_disable_device(pci_dev
);
1015 void r852_shutdown(struct pci_dev
*pci_dev
)
1017 struct r852_device
*dev
= pci_get_drvdata(pci_dev
);
1019 cancel_delayed_work_sync(&dev
->card_detect_work
);
1020 r852_disable_irqs(dev
);
1021 synchronize_irq(dev
->irq
);
1022 pci_disable_device(pci_dev
);
1026 int r852_suspend(struct device
*device
)
1028 struct r852_device
*dev
= pci_get_drvdata(to_pci_dev(device
));
1029 unsigned long flags
;
1031 if (dev
->ctlreg
& R852_CTL_CARDENABLE
)
1034 /* First make sure the detect work is gone */
1035 cancel_delayed_work_sync(&dev
->card_detect_work
);
1037 /* Turn off the interrupts and stop the device */
1038 r852_disable_irqs(dev
);
1039 r852_engine_disable(dev
);
1041 spin_lock_irqsave(&dev
->irqlock
, flags
);
1043 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1045 /* At that point, even if interrupt handler is running, it will quit */
1046 /* So wait for this to happen explictly */
1047 synchronize_irq(dev
->irq
);
1049 /* If card was pulled off just during the suspend, which is very
1050 unlikely, we will remove it on resume, it too late now
1052 dev
->card_unstable
= 0;
1054 pci_save_state(to_pci_dev(device
));
1055 return pci_prepare_to_sleep(to_pci_dev(device
));
1058 int r852_resume(struct device
*device
)
1060 struct r852_device
*dev
= pci_get_drvdata(to_pci_dev(device
));
1061 unsigned long flags
;
1063 /* Turn on the hardware */
1064 pci_back_from_sleep(to_pci_dev(device
));
1065 pci_restore_state(to_pci_dev(device
));
1067 r852_disable_irqs(dev
);
1068 r852_card_update_present(dev
);
1069 r852_engine_disable(dev
);
1072 /* Now its safe for IRQ to run */
1073 spin_lock_irqsave(&dev
->irqlock
, flags
);
1075 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1078 /* If card status changed, just do the work */
1079 if (dev
->card_detected
!= dev
->card_registred
) {
1080 dbg("card was %s during low power state",
1081 dev
->card_detected
? "added" : "removed");
1083 queue_delayed_work(dev
->card_workqueue
,
1084 &dev
->card_detect_work
, 1000);
1088 /* Otherwise, initialize the card */
1089 if (dev
->card_registred
) {
1090 r852_engine_enable(dev
);
1091 dev
->chip
->select_chip(dev
->mtd
, 0);
1092 dev
->chip
->cmdfunc(dev
->mtd
, NAND_CMD_RESET
, -1, -1);
1093 dev
->chip
->select_chip(dev
->mtd
, -1);
1096 /* Program card detection IRQ */
1097 r852_update_card_detect(dev
);
1101 #define r852_suspend NULL
1102 #define r852_resume NULL
1105 static const struct pci_device_id r852_pci_id_tbl
[] = {
1107 { PCI_VDEVICE(RICOH
, 0x0852), },
1111 MODULE_DEVICE_TABLE(pci
, r852_pci_id_tbl
);
1113 SIMPLE_DEV_PM_OPS(r852_pm_ops
, r852_suspend
, r852_resume
);
1116 static struct pci_driver r852_pci_driver
= {
1118 .id_table
= r852_pci_id_tbl
,
1119 .probe
= r852_probe
,
1120 .remove
= r852_remove
,
1121 .shutdown
= r852_shutdown
,
1122 .driver
.pm
= &r852_pm_ops
,
1125 static __init
int r852_module_init(void)
1127 return pci_register_driver(&r852_pci_driver
);
1130 static void __exit
r852_module_exit(void)
1132 pci_unregister_driver(&r852_pci_driver
);
1135 module_init(r852_module_init
);
1136 module_exit(r852_module_exit
);
1138 MODULE_LICENSE("GPL");
1139 MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
1140 MODULE_DESCRIPTION("Ricoh 85xx xD/smartmedia card reader driver");