2 * linux/drivers/net/irda/pxaficp_ir.c
4 * Based on sa1100_ir.c by Russell King
6 * Changes copyright (C) 2003-2005 MontaVista Software, Inc.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * Infra-red driver (SIR/FIR) for the PXA2xx embedded microprocessor
15 #include <linux/module.h>
16 #include <linux/netdevice.h>
17 #include <linux/platform_device.h>
18 #include <linux/clk.h>
20 #include <net/irda/irda.h>
21 #include <net/irda/irmod.h>
22 #include <net/irda/wrapper.h>
23 #include <net/irda/irda_device.h>
26 #include <mach/irda.h>
27 #include <mach/pxa-regs.h>
29 #define FICP __REG(0x40800000) /* Start of FICP area */
30 #define ICCR0 __REG(0x40800000) /* ICP Control Register 0 */
31 #define ICCR1 __REG(0x40800004) /* ICP Control Register 1 */
32 #define ICCR2 __REG(0x40800008) /* ICP Control Register 2 */
33 #define ICDR __REG(0x4080000c) /* ICP Data Register */
34 #define ICSR0 __REG(0x40800014) /* ICP Status Register 0 */
35 #define ICSR1 __REG(0x40800018) /* ICP Status Register 1 */
37 #define ICCR0_AME (1 << 7) /* Address match enable */
38 #define ICCR0_TIE (1 << 6) /* Transmit FIFO interrupt enable */
39 #define ICCR0_RIE (1 << 5) /* Recieve FIFO interrupt enable */
40 #define ICCR0_RXE (1 << 4) /* Receive enable */
41 #define ICCR0_TXE (1 << 3) /* Transmit enable */
42 #define ICCR0_TUS (1 << 2) /* Transmit FIFO underrun select */
43 #define ICCR0_LBM (1 << 1) /* Loopback mode */
44 #define ICCR0_ITR (1 << 0) /* IrDA transmission */
46 #define ICCR2_RXP (1 << 3) /* Receive Pin Polarity select */
47 #define ICCR2_TXP (1 << 2) /* Transmit Pin Polarity select */
48 #define ICCR2_TRIG (3 << 0) /* Receive FIFO Trigger threshold */
49 #define ICCR2_TRIG_8 (0 << 0) /* >= 8 bytes */
50 #define ICCR2_TRIG_16 (1 << 0) /* >= 16 bytes */
51 #define ICCR2_TRIG_32 (2 << 0) /* >= 32 bytes */
54 #define ICSR0_EOC (1 << 6) /* DMA End of Descriptor Chain */
56 #define ICSR0_FRE (1 << 5) /* Framing error */
57 #define ICSR0_RFS (1 << 4) /* Receive FIFO service request */
58 #define ICSR0_TFS (1 << 3) /* Transnit FIFO service request */
59 #define ICSR0_RAB (1 << 2) /* Receiver abort */
60 #define ICSR0_TUR (1 << 1) /* Trunsmit FIFO underun */
61 #define ICSR0_EIF (1 << 0) /* End/Error in FIFO */
63 #define ICSR1_ROR (1 << 6) /* Receiver FIFO underrun */
64 #define ICSR1_CRE (1 << 5) /* CRC error */
65 #define ICSR1_EOF (1 << 4) /* End of frame */
66 #define ICSR1_TNF (1 << 3) /* Transmit FIFO not full */
67 #define ICSR1_RNE (1 << 2) /* Receive FIFO not empty */
68 #define ICSR1_TBY (1 << 1) /* Tramsmiter busy flag */
69 #define ICSR1_RSY (1 << 0) /* Recevier synchronized flag */
71 #define IrSR_RXPL_NEG_IS_ZERO (1<<4)
72 #define IrSR_RXPL_POS_IS_ZERO 0x0
73 #define IrSR_TXPL_NEG_IS_ZERO (1<<3)
74 #define IrSR_TXPL_POS_IS_ZERO 0x0
75 #define IrSR_XMODE_PULSE_1_6 (1<<2)
76 #define IrSR_XMODE_PULSE_3_16 0x0
77 #define IrSR_RCVEIR_IR_MODE (1<<1)
78 #define IrSR_RCVEIR_UART_MODE 0x0
79 #define IrSR_XMITIR_IR_MODE (1<<0)
80 #define IrSR_XMITIR_UART_MODE 0x0
82 #define IrSR_IR_RECEIVE_ON (\
83 IrSR_RXPL_NEG_IS_ZERO | \
84 IrSR_TXPL_POS_IS_ZERO | \
85 IrSR_XMODE_PULSE_3_16 | \
86 IrSR_RCVEIR_IR_MODE | \
87 IrSR_XMITIR_UART_MODE)
89 #define IrSR_IR_TRANSMIT_ON (\
90 IrSR_RXPL_NEG_IS_ZERO | \
91 IrSR_TXPL_POS_IS_ZERO | \
92 IrSR_XMODE_PULSE_3_16 | \
93 IrSR_RCVEIR_UART_MODE | \
99 unsigned long last_oscr
;
101 unsigned char *dma_rx_buff
;
102 unsigned char *dma_tx_buff
;
103 dma_addr_t dma_rx_buff_phy
;
104 dma_addr_t dma_tx_buff_phy
;
105 unsigned int dma_tx_buff_len
;
109 struct net_device_stats stats
;
110 struct irlap_cb
*irlap
;
117 struct pxaficp_platform_data
*pdata
;
123 static inline void pxa_irda_disable_clk(struct pxa_irda
*si
)
126 clk_disable(si
->cur_clk
);
130 static inline void pxa_irda_enable_firclk(struct pxa_irda
*si
)
132 si
->cur_clk
= si
->fir_clk
;
133 clk_enable(si
->fir_clk
);
136 static inline void pxa_irda_enable_sirclk(struct pxa_irda
*si
)
138 si
->cur_clk
= si
->sir_clk
;
139 clk_enable(si
->sir_clk
);
143 #define IS_FIR(si) ((si)->speed >= 4000000)
144 #define IRDA_FRAME_SIZE_LIMIT 2047
146 inline static void pxa_irda_fir_dma_rx_start(struct pxa_irda
*si
)
148 DCSR(si
->rxdma
) = DCSR_NODESC
;
149 DSADR(si
->rxdma
) = __PREG(ICDR
);
150 DTADR(si
->rxdma
) = si
->dma_rx_buff_phy
;
151 DCMD(si
->rxdma
) = DCMD_INCTRGADDR
| DCMD_FLOWSRC
| DCMD_WIDTH1
| DCMD_BURST32
| IRDA_FRAME_SIZE_LIMIT
;
152 DCSR(si
->rxdma
) |= DCSR_RUN
;
155 inline static void pxa_irda_fir_dma_tx_start(struct pxa_irda
*si
)
157 DCSR(si
->txdma
) = DCSR_NODESC
;
158 DSADR(si
->txdma
) = si
->dma_tx_buff_phy
;
159 DTADR(si
->txdma
) = __PREG(ICDR
);
160 DCMD(si
->txdma
) = DCMD_INCSRCADDR
| DCMD_FLOWTRG
| DCMD_ENDIRQEN
| DCMD_WIDTH1
| DCMD_BURST32
| si
->dma_tx_buff_len
;
161 DCSR(si
->txdma
) |= DCSR_RUN
;
165 * Set the IrDA communications speed.
167 static int pxa_irda_set_speed(struct pxa_irda
*si
, int speed
)
170 unsigned int divisor
;
173 case 9600: case 19200: case 38400:
174 case 57600: case 115200:
176 /* refer to PXA250/210 Developer's Manual 10-7 */
177 /* BaudRate = 14.7456 MHz / (16*Divisor) */
178 divisor
= 14745600 / (16 * speed
);
180 local_irq_save(flags
);
184 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
187 pxa_irda_disable_clk(si
);
189 /* set board transceiver to SIR mode */
190 si
->pdata
->transceiver_mode(si
->dev
, IR_SIRMODE
);
192 /* enable the STUART clock */
193 pxa_irda_enable_sirclk(si
);
196 /* disable STUART first */
199 /* access DLL & DLH */
201 STDLL
= divisor
& 0xff;
202 STDLH
= divisor
>> 8;
206 STISR
= IrSR_IR_RECEIVE_ON
| IrSR_XMODE_PULSE_1_6
;
207 STIER
= IER_UUE
| IER_RLSE
| IER_RAVIE
| IER_RTIOE
;
209 local_irq_restore(flags
);
213 local_irq_save(flags
);
218 pxa_irda_disable_clk(si
);
220 /* disable FICP first */
223 /* set board transceiver to FIR mode */
224 si
->pdata
->transceiver_mode(si
->dev
, IR_FIRMODE
);
226 /* enable the FICP clock */
227 pxa_irda_enable_firclk(si
);
230 pxa_irda_fir_dma_rx_start(si
);
231 ICCR0
= ICCR0_ITR
| ICCR0_RXE
;
233 local_irq_restore(flags
);
243 /* SIR interrupt service routine. */
244 static irqreturn_t
pxa_irda_sir_irq(int irq
, void *dev_id
)
246 struct net_device
*dev
= dev_id
;
247 struct pxa_irda
*si
= netdev_priv(dev
);
252 switch (iir
& 0x0F) {
253 case 0x06: /* Receiver Line Status */
255 while (lsr
& LSR_FIFOE
) {
257 if (lsr
& (LSR_OE
| LSR_PE
| LSR_FE
| LSR_BI
)) {
258 printk(KERN_DEBUG
"pxa_ir: sir receiving error\n");
259 si
->stats
.rx_errors
++;
261 si
->stats
.rx_frame_errors
++;
263 si
->stats
.rx_fifo_errors
++;
265 si
->stats
.rx_bytes
++;
266 async_unwrap_char(dev
, &si
->stats
, &si
->rx_buff
, data
);
270 dev
->last_rx
= jiffies
;
271 si
->last_oscr
= OSCR
;
274 case 0x04: /* Received Data Available */
277 case 0x0C: /* Character Timeout Indication */
279 si
->stats
.rx_bytes
++;
280 async_unwrap_char(dev
, &si
->stats
, &si
->rx_buff
, STRBR
);
281 } while (STLSR
& LSR_DR
);
282 dev
->last_rx
= jiffies
;
283 si
->last_oscr
= OSCR
;
286 case 0x02: /* Transmit FIFO Data Request */
287 while ((si
->tx_buff
.len
) && (STLSR
& LSR_TDRQ
)) {
288 STTHR
= *si
->tx_buff
.data
++;
289 si
->tx_buff
.len
-= 1;
292 if (si
->tx_buff
.len
== 0) {
293 si
->stats
.tx_packets
++;
294 si
->stats
.tx_bytes
+= si
->tx_buff
.data
-
297 /* We need to ensure that the transmitter has finished. */
298 while ((STLSR
& LSR_TEMT
) == 0)
300 si
->last_oscr
= OSCR
;
303 * Ok, we've finished transmitting. Now enable
304 * the receiver. Sometimes we get a receive IRQ
305 * immediately after a transmit...
308 pxa_irda_set_speed(si
, si
->newspeed
);
311 /* enable IR Receiver, disable IR Transmitter */
312 STISR
= IrSR_IR_RECEIVE_ON
| IrSR_XMODE_PULSE_1_6
;
313 /* enable STUART and receive interrupts */
314 STIER
= IER_UUE
| IER_RLSE
| IER_RAVIE
| IER_RTIOE
;
317 netif_wake_queue(dev
);
325 /* FIR Receive DMA interrupt handler */
326 static void pxa_irda_fir_dma_rx_irq(int channel
, void *data
)
328 int dcsr
= DCSR(channel
);
330 DCSR(channel
) = dcsr
& ~DCSR_RUN
;
332 printk(KERN_DEBUG
"pxa_ir: fir rx dma bus error %#x\n", dcsr
);
335 /* FIR Transmit DMA interrupt handler */
336 static void pxa_irda_fir_dma_tx_irq(int channel
, void *data
)
338 struct net_device
*dev
= data
;
339 struct pxa_irda
*si
= netdev_priv(dev
);
342 dcsr
= DCSR(channel
);
343 DCSR(channel
) = dcsr
& ~DCSR_RUN
;
345 if (dcsr
& DCSR_ENDINTR
) {
346 si
->stats
.tx_packets
++;
347 si
->stats
.tx_bytes
+= si
->dma_tx_buff_len
;
349 si
->stats
.tx_errors
++;
352 while (ICSR1
& ICSR1_TBY
)
354 si
->last_oscr
= OSCR
;
357 * HACK: It looks like the TBY bit is dropped too soon.
358 * Without this delay things break.
363 pxa_irda_set_speed(si
, si
->newspeed
);
369 pxa_irda_fir_dma_rx_start(si
);
370 while ((ICSR1
& ICSR1_RNE
) && i
--)
372 ICCR0
= ICCR0_ITR
| ICCR0_RXE
;
375 printk(KERN_ERR
"pxa_ir: cannot clear Rx FIFO!\n");
377 netif_wake_queue(dev
);
380 /* EIF(Error in FIFO/End in Frame) handler for FIR */
381 static void pxa_irda_fir_irq_eif(struct pxa_irda
*si
, struct net_device
*dev
, int icsr0
)
383 unsigned int len
, stat
, data
;
385 /* Get the current data position. */
386 len
= DTADR(si
->rxdma
) - si
->dma_rx_buff_phy
;
389 /* Read Status, and then Data. */
394 if (stat
& (ICSR1_CRE
| ICSR1_ROR
)) {
395 si
->stats
.rx_errors
++;
396 if (stat
& ICSR1_CRE
) {
397 printk(KERN_DEBUG
"pxa_ir: fir receive CRC error\n");
398 si
->stats
.rx_crc_errors
++;
400 if (stat
& ICSR1_ROR
) {
401 printk(KERN_DEBUG
"pxa_ir: fir receive overrun\n");
402 si
->stats
.rx_over_errors
++;
405 si
->dma_rx_buff
[len
++] = data
;
407 /* If we hit the end of frame, there's no point in continuing. */
408 if (stat
& ICSR1_EOF
)
410 } while (ICSR0
& ICSR0_EIF
);
412 if (stat
& ICSR1_EOF
) {
416 if (icsr0
& ICSR0_FRE
) {
417 printk(KERN_ERR
"pxa_ir: dropping erroneous frame\n");
418 si
->stats
.rx_dropped
++;
422 skb
= alloc_skb(len
+1,GFP_ATOMIC
);
424 printk(KERN_ERR
"pxa_ir: fir out of memory for receive skb\n");
425 si
->stats
.rx_dropped
++;
429 /* Align IP header to 20 bytes */
431 skb_copy_to_linear_data(skb
, si
->dma_rx_buff
, len
);
434 /* Feed it to IrLAP */
436 skb_reset_mac_header(skb
);
437 skb
->protocol
= htons(ETH_P_IRDA
);
440 si
->stats
.rx_packets
++;
441 si
->stats
.rx_bytes
+= len
;
443 dev
->last_rx
= jiffies
;
447 /* FIR interrupt handler */
448 static irqreturn_t
pxa_irda_fir_irq(int irq
, void *dev_id
)
450 struct net_device
*dev
= dev_id
;
451 struct pxa_irda
*si
= netdev_priv(dev
);
455 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
456 si
->last_oscr
= OSCR
;
459 if (icsr0
& (ICSR0_FRE
| ICSR0_RAB
)) {
460 if (icsr0
& ICSR0_FRE
) {
461 printk(KERN_DEBUG
"pxa_ir: fir receive frame error\n");
462 si
->stats
.rx_frame_errors
++;
464 printk(KERN_DEBUG
"pxa_ir: fir receive abort\n");
465 si
->stats
.rx_errors
++;
467 ICSR0
= icsr0
& (ICSR0_FRE
| ICSR0_RAB
);
470 if (icsr0
& ICSR0_EIF
) {
471 /* An error in FIFO occured, or there is a end of frame */
472 pxa_irda_fir_irq_eif(si
, dev
, icsr0
);
476 pxa_irda_fir_dma_rx_start(si
);
477 while ((ICSR1
& ICSR1_RNE
) && i
--)
479 ICCR0
= ICCR0_ITR
| ICCR0_RXE
;
482 printk(KERN_ERR
"pxa_ir: cannot clear Rx FIFO!\n");
487 /* hard_xmit interface of irda device */
488 static int pxa_irda_hard_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
490 struct pxa_irda
*si
= netdev_priv(dev
);
491 int speed
= irda_get_next_speed(skb
);
494 * Does this packet contain a request to change the interface
495 * speed? If so, remember it until we complete the transmission
498 if (speed
!= si
->speed
&& speed
!= -1)
499 si
->newspeed
= speed
;
502 * If this is an empty frame, we can bypass a lot.
507 pxa_irda_set_speed(si
, speed
);
513 netif_stop_queue(dev
);
516 si
->tx_buff
.data
= si
->tx_buff
.head
;
517 si
->tx_buff
.len
= async_wrap_skb(skb
, si
->tx_buff
.data
, si
->tx_buff
.truesize
);
519 /* Disable STUART interrupts and switch to transmit mode. */
521 STISR
= IrSR_IR_TRANSMIT_ON
| IrSR_XMODE_PULSE_1_6
;
523 /* enable STUART and transmit interrupts */
524 STIER
= IER_UUE
| IER_TIE
;
526 unsigned long mtt
= irda_get_mtt(skb
);
528 si
->dma_tx_buff_len
= skb
->len
;
529 skb_copy_from_linear_data(skb
, si
->dma_tx_buff
, skb
->len
);
532 while ((unsigned)(OSCR
- si
->last_oscr
)/4 < mtt
)
535 /* stop RX DMA, disable FICP */
536 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
539 pxa_irda_fir_dma_tx_start(si
);
540 ICCR0
= ICCR0_ITR
| ICCR0_TXE
;
544 dev
->trans_start
= jiffies
;
548 static int pxa_irda_ioctl(struct net_device
*dev
, struct ifreq
*ifreq
, int cmd
)
550 struct if_irda_req
*rq
= (struct if_irda_req
*)ifreq
;
551 struct pxa_irda
*si
= netdev_priv(dev
);
557 if (capable(CAP_NET_ADMIN
)) {
559 * We are unable to set the speed if the
560 * device is not running.
562 if (netif_running(dev
)) {
563 ret
= pxa_irda_set_speed(si
,
566 printk(KERN_INFO
"pxa_ir: SIOCSBANDWIDTH: !netif_running\n");
574 if (capable(CAP_NET_ADMIN
)) {
575 irda_device_set_media_busy(dev
, TRUE
);
582 rq
->ifr_receiving
= IS_FIR(si
) ? 0
583 : si
->rx_buff
.state
!= OUTSIDE_FRAME
;
594 static struct net_device_stats
*pxa_irda_stats(struct net_device
*dev
)
596 struct pxa_irda
*si
= netdev_priv(dev
);
600 static void pxa_irda_startup(struct pxa_irda
*si
)
602 /* Disable STUART interrupts */
604 /* enable STUART interrupt to the processor */
606 /* configure SIR frame format: StartBit - Data 7 ... Data 0 - Stop Bit */
607 STLCR
= LCR_WLS0
| LCR_WLS1
;
608 /* enable FIFO, we use FIFO to improve performance */
609 STFCR
= FCR_TRFIFOE
| FCR_ITL_32
;
613 /* configure FICP ICCR2 */
614 ICCR2
= ICCR2_TXP
| ICCR2_TRIG_32
;
617 DRCMR(17) = si
->rxdma
| DRCMR_MAPVLD
;
618 DRCMR(18) = si
->txdma
| DRCMR_MAPVLD
;
620 /* force SIR reinitialization */
622 pxa_irda_set_speed(si
, 9600);
624 printk(KERN_DEBUG
"pxa_ir: irda startup\n");
627 static void pxa_irda_shutdown(struct pxa_irda
*si
)
631 local_irq_save(flags
);
633 /* disable STUART and interrupt */
635 /* disable STUART SIR mode */
639 DCSR(si
->txdma
) &= ~DCSR_RUN
;
640 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
644 /* disable the STUART or FICP clocks */
645 pxa_irda_disable_clk(si
);
650 local_irq_restore(flags
);
652 /* power off board transceiver */
653 si
->pdata
->transceiver_mode(si
->dev
, IR_OFF
);
655 printk(KERN_DEBUG
"pxa_ir: irda shutdown\n");
658 static int pxa_irda_start(struct net_device
*dev
)
660 struct pxa_irda
*si
= netdev_priv(dev
);
665 err
= request_irq(IRQ_STUART
, pxa_irda_sir_irq
, 0, dev
->name
, dev
);
669 err
= request_irq(IRQ_ICP
, pxa_irda_fir_irq
, 0, dev
->name
, dev
);
674 * The interrupt must remain disabled for now.
676 disable_irq(IRQ_STUART
);
677 disable_irq(IRQ_ICP
);
680 si
->rxdma
= pxa_request_dma("FICP_RX",DMA_PRIO_LOW
, pxa_irda_fir_dma_rx_irq
, dev
);
684 si
->txdma
= pxa_request_dma("FICP_TX",DMA_PRIO_LOW
, pxa_irda_fir_dma_tx_irq
, dev
);
689 si
->dma_rx_buff
= dma_alloc_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
,
690 &si
->dma_rx_buff_phy
, GFP_KERNEL
);
691 if (!si
->dma_rx_buff
)
692 goto err_dma_rx_buff
;
694 si
->dma_tx_buff
= dma_alloc_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
,
695 &si
->dma_tx_buff_phy
, GFP_KERNEL
);
696 if (!si
->dma_tx_buff
)
697 goto err_dma_tx_buff
;
699 /* Setup the serial port for the initial speed. */
700 pxa_irda_startup(si
);
703 * Open a new IrLAP layer instance.
705 si
->irlap
= irlap_open(dev
, &si
->qos
, "pxa");
711 * Now enable the interrupt and start the queue
713 enable_irq(IRQ_STUART
);
715 netif_start_queue(dev
);
717 printk(KERN_DEBUG
"pxa_ir: irda driver opened\n");
722 pxa_irda_shutdown(si
);
723 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_tx_buff
, si
->dma_tx_buff_phy
);
725 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_rx_buff
, si
->dma_rx_buff_phy
);
727 pxa_free_dma(si
->txdma
);
729 pxa_free_dma(si
->rxdma
);
731 free_irq(IRQ_ICP
, dev
);
733 free_irq(IRQ_STUART
, dev
);
739 static int pxa_irda_stop(struct net_device
*dev
)
741 struct pxa_irda
*si
= netdev_priv(dev
);
743 netif_stop_queue(dev
);
745 pxa_irda_shutdown(si
);
749 irlap_close(si
->irlap
);
753 free_irq(IRQ_STUART
, dev
);
754 free_irq(IRQ_ICP
, dev
);
756 pxa_free_dma(si
->rxdma
);
757 pxa_free_dma(si
->txdma
);
760 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_tx_buff
, si
->dma_tx_buff_phy
);
762 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_rx_buff
, si
->dma_rx_buff_phy
);
764 printk(KERN_DEBUG
"pxa_ir: irda driver closed\n");
768 static int pxa_irda_suspend(struct platform_device
*_dev
, pm_message_t state
)
770 struct net_device
*dev
= platform_get_drvdata(_dev
);
773 if (dev
&& netif_running(dev
)) {
774 si
= netdev_priv(dev
);
775 netif_device_detach(dev
);
776 pxa_irda_shutdown(si
);
782 static int pxa_irda_resume(struct platform_device
*_dev
)
784 struct net_device
*dev
= platform_get_drvdata(_dev
);
787 if (dev
&& netif_running(dev
)) {
788 si
= netdev_priv(dev
);
789 pxa_irda_startup(si
);
790 netif_device_attach(dev
);
791 netif_wake_queue(dev
);
798 static int pxa_irda_init_iobuf(iobuff_t
*io
, int size
)
800 io
->head
= kmalloc(size
, GFP_KERNEL
| GFP_DMA
);
801 if (io
->head
!= NULL
) {
803 io
->in_frame
= FALSE
;
804 io
->state
= OUTSIDE_FRAME
;
807 return io
->head
? 0 : -ENOMEM
;
810 static int pxa_irda_probe(struct platform_device
*pdev
)
812 struct net_device
*dev
;
814 unsigned int baudrate_mask
;
817 if (!pdev
->dev
.platform_data
)
820 err
= request_mem_region(__PREG(STUART
), 0x24, "IrDA") ? 0 : -EBUSY
;
824 err
= request_mem_region(__PREG(FICP
), 0x1c, "IrDA") ? 0 : -EBUSY
;
828 dev
= alloc_irdadev(sizeof(struct pxa_irda
));
832 si
= netdev_priv(dev
);
833 si
->dev
= &pdev
->dev
;
834 si
->pdata
= pdev
->dev
.platform_data
;
836 si
->sir_clk
= clk_get(&pdev
->dev
, "UARTCLK");
837 si
->fir_clk
= clk_get(&pdev
->dev
, "FICPCLK");
838 if (IS_ERR(si
->sir_clk
) || IS_ERR(si
->fir_clk
)) {
839 err
= PTR_ERR(IS_ERR(si
->sir_clk
) ? si
->sir_clk
: si
->fir_clk
);
844 * Initialise the SIR buffers
846 err
= pxa_irda_init_iobuf(&si
->rx_buff
, 14384);
849 err
= pxa_irda_init_iobuf(&si
->tx_buff
, 4000);
853 if (si
->pdata
->startup
)
854 err
= si
->pdata
->startup(si
->dev
);
858 dev
->hard_start_xmit
= pxa_irda_hard_xmit
;
859 dev
->open
= pxa_irda_start
;
860 dev
->stop
= pxa_irda_stop
;
861 dev
->do_ioctl
= pxa_irda_ioctl
;
862 dev
->get_stats
= pxa_irda_stats
;
864 irda_init_max_qos_capabilies(&si
->qos
);
867 if (si
->pdata
->transceiver_cap
& IR_SIRMODE
)
868 baudrate_mask
|= IR_9600
|IR_19200
|IR_38400
|IR_57600
|IR_115200
;
869 if (si
->pdata
->transceiver_cap
& IR_FIRMODE
)
870 baudrate_mask
|= IR_4000000
<< 8;
872 si
->qos
.baud_rate
.bits
&= baudrate_mask
;
873 si
->qos
.min_turn_time
.bits
= 7; /* 1ms or more */
875 irda_qos_bits_to_value(&si
->qos
);
877 err
= register_netdev(dev
);
880 dev_set_drvdata(&pdev
->dev
, dev
);
883 if (si
->pdata
->shutdown
)
884 si
->pdata
->shutdown(si
->dev
);
886 kfree(si
->tx_buff
.head
);
888 kfree(si
->rx_buff
.head
);
890 if (si
->sir_clk
&& !IS_ERR(si
->sir_clk
))
891 clk_put(si
->sir_clk
);
892 if (si
->fir_clk
&& !IS_ERR(si
->fir_clk
))
893 clk_put(si
->fir_clk
);
896 release_mem_region(__PREG(FICP
), 0x1c);
898 release_mem_region(__PREG(STUART
), 0x24);
904 static int pxa_irda_remove(struct platform_device
*_dev
)
906 struct net_device
*dev
= platform_get_drvdata(_dev
);
909 struct pxa_irda
*si
= netdev_priv(dev
);
910 unregister_netdev(dev
);
911 if (si
->pdata
->shutdown
)
912 si
->pdata
->shutdown(si
->dev
);
913 kfree(si
->tx_buff
.head
);
914 kfree(si
->rx_buff
.head
);
915 clk_put(si
->fir_clk
);
916 clk_put(si
->sir_clk
);
920 release_mem_region(__PREG(STUART
), 0x24);
921 release_mem_region(__PREG(FICP
), 0x1c);
926 static struct platform_driver pxa_ir_driver
= {
929 .owner
= THIS_MODULE
,
931 .probe
= pxa_irda_probe
,
932 .remove
= pxa_irda_remove
,
933 .suspend
= pxa_irda_suspend
,
934 .resume
= pxa_irda_resume
,
937 static int __init
pxa_irda_init(void)
939 return platform_driver_register(&pxa_ir_driver
);
942 static void __exit
pxa_irda_exit(void)
944 platform_driver_unregister(&pxa_ir_driver
);
947 module_init(pxa_irda_init
);
948 module_exit(pxa_irda_exit
);
950 MODULE_LICENSE("GPL");
951 MODULE_ALIAS("platform:pxa2xx-ir");