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/hardware.h>
28 #include <mach/pxa-regs.h>
29 #include <mach/regs-uart.h>
31 #define FICP __REG(0x40800000) /* Start of FICP area */
32 #define ICCR0 __REG(0x40800000) /* ICP Control Register 0 */
33 #define ICCR1 __REG(0x40800004) /* ICP Control Register 1 */
34 #define ICCR2 __REG(0x40800008) /* ICP Control Register 2 */
35 #define ICDR __REG(0x4080000c) /* ICP Data Register */
36 #define ICSR0 __REG(0x40800014) /* ICP Status Register 0 */
37 #define ICSR1 __REG(0x40800018) /* ICP Status Register 1 */
39 #define ICCR0_AME (1 << 7) /* Address match enable */
40 #define ICCR0_TIE (1 << 6) /* Transmit FIFO interrupt enable */
41 #define ICCR0_RIE (1 << 5) /* Recieve FIFO interrupt enable */
42 #define ICCR0_RXE (1 << 4) /* Receive enable */
43 #define ICCR0_TXE (1 << 3) /* Transmit enable */
44 #define ICCR0_TUS (1 << 2) /* Transmit FIFO underrun select */
45 #define ICCR0_LBM (1 << 1) /* Loopback mode */
46 #define ICCR0_ITR (1 << 0) /* IrDA transmission */
48 #define ICCR2_RXP (1 << 3) /* Receive Pin Polarity select */
49 #define ICCR2_TXP (1 << 2) /* Transmit Pin Polarity select */
50 #define ICCR2_TRIG (3 << 0) /* Receive FIFO Trigger threshold */
51 #define ICCR2_TRIG_8 (0 << 0) /* >= 8 bytes */
52 #define ICCR2_TRIG_16 (1 << 0) /* >= 16 bytes */
53 #define ICCR2_TRIG_32 (2 << 0) /* >= 32 bytes */
56 #define ICSR0_EOC (1 << 6) /* DMA End of Descriptor Chain */
58 #define ICSR0_FRE (1 << 5) /* Framing error */
59 #define ICSR0_RFS (1 << 4) /* Receive FIFO service request */
60 #define ICSR0_TFS (1 << 3) /* Transnit FIFO service request */
61 #define ICSR0_RAB (1 << 2) /* Receiver abort */
62 #define ICSR0_TUR (1 << 1) /* Trunsmit FIFO underun */
63 #define ICSR0_EIF (1 << 0) /* End/Error in FIFO */
65 #define ICSR1_ROR (1 << 6) /* Receiver FIFO underrun */
66 #define ICSR1_CRE (1 << 5) /* CRC error */
67 #define ICSR1_EOF (1 << 4) /* End of frame */
68 #define ICSR1_TNF (1 << 3) /* Transmit FIFO not full */
69 #define ICSR1_RNE (1 << 2) /* Receive FIFO not empty */
70 #define ICSR1_TBY (1 << 1) /* Tramsmiter busy flag */
71 #define ICSR1_RSY (1 << 0) /* Recevier synchronized flag */
73 #define IrSR_RXPL_NEG_IS_ZERO (1<<4)
74 #define IrSR_RXPL_POS_IS_ZERO 0x0
75 #define IrSR_TXPL_NEG_IS_ZERO (1<<3)
76 #define IrSR_TXPL_POS_IS_ZERO 0x0
77 #define IrSR_XMODE_PULSE_1_6 (1<<2)
78 #define IrSR_XMODE_PULSE_3_16 0x0
79 #define IrSR_RCVEIR_IR_MODE (1<<1)
80 #define IrSR_RCVEIR_UART_MODE 0x0
81 #define IrSR_XMITIR_IR_MODE (1<<0)
82 #define IrSR_XMITIR_UART_MODE 0x0
84 #define IrSR_IR_RECEIVE_ON (\
85 IrSR_RXPL_NEG_IS_ZERO | \
86 IrSR_TXPL_POS_IS_ZERO | \
87 IrSR_XMODE_PULSE_3_16 | \
88 IrSR_RCVEIR_IR_MODE | \
89 IrSR_XMITIR_UART_MODE)
91 #define IrSR_IR_TRANSMIT_ON (\
92 IrSR_RXPL_NEG_IS_ZERO | \
93 IrSR_TXPL_POS_IS_ZERO | \
94 IrSR_XMODE_PULSE_3_16 | \
95 IrSR_RCVEIR_UART_MODE | \
101 unsigned long last_oscr
;
103 unsigned char *dma_rx_buff
;
104 unsigned char *dma_tx_buff
;
105 dma_addr_t dma_rx_buff_phy
;
106 dma_addr_t dma_tx_buff_phy
;
107 unsigned int dma_tx_buff_len
;
111 struct net_device_stats stats
;
112 struct irlap_cb
*irlap
;
119 struct pxaficp_platform_data
*pdata
;
125 static inline void pxa_irda_disable_clk(struct pxa_irda
*si
)
128 clk_disable(si
->cur_clk
);
132 static inline void pxa_irda_enable_firclk(struct pxa_irda
*si
)
134 si
->cur_clk
= si
->fir_clk
;
135 clk_enable(si
->fir_clk
);
138 static inline void pxa_irda_enable_sirclk(struct pxa_irda
*si
)
140 si
->cur_clk
= si
->sir_clk
;
141 clk_enable(si
->sir_clk
);
145 #define IS_FIR(si) ((si)->speed >= 4000000)
146 #define IRDA_FRAME_SIZE_LIMIT 2047
148 inline static void pxa_irda_fir_dma_rx_start(struct pxa_irda
*si
)
150 DCSR(si
->rxdma
) = DCSR_NODESC
;
151 DSADR(si
->rxdma
) = __PREG(ICDR
);
152 DTADR(si
->rxdma
) = si
->dma_rx_buff_phy
;
153 DCMD(si
->rxdma
) = DCMD_INCTRGADDR
| DCMD_FLOWSRC
| DCMD_WIDTH1
| DCMD_BURST32
| IRDA_FRAME_SIZE_LIMIT
;
154 DCSR(si
->rxdma
) |= DCSR_RUN
;
157 inline static void pxa_irda_fir_dma_tx_start(struct pxa_irda
*si
)
159 DCSR(si
->txdma
) = DCSR_NODESC
;
160 DSADR(si
->txdma
) = si
->dma_tx_buff_phy
;
161 DTADR(si
->txdma
) = __PREG(ICDR
);
162 DCMD(si
->txdma
) = DCMD_INCSRCADDR
| DCMD_FLOWTRG
| DCMD_ENDIRQEN
| DCMD_WIDTH1
| DCMD_BURST32
| si
->dma_tx_buff_len
;
163 DCSR(si
->txdma
) |= DCSR_RUN
;
167 * Set the IrDA communications speed.
169 static int pxa_irda_set_speed(struct pxa_irda
*si
, int speed
)
172 unsigned int divisor
;
175 case 9600: case 19200: case 38400:
176 case 57600: case 115200:
178 /* refer to PXA250/210 Developer's Manual 10-7 */
179 /* BaudRate = 14.7456 MHz / (16*Divisor) */
180 divisor
= 14745600 / (16 * speed
);
182 local_irq_save(flags
);
186 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
189 pxa_irda_disable_clk(si
);
191 /* set board transceiver to SIR mode */
192 si
->pdata
->transceiver_mode(si
->dev
, IR_SIRMODE
);
194 /* enable the STUART clock */
195 pxa_irda_enable_sirclk(si
);
198 /* disable STUART first */
201 /* access DLL & DLH */
203 STDLL
= divisor
& 0xff;
204 STDLH
= divisor
>> 8;
208 STISR
= IrSR_IR_RECEIVE_ON
| IrSR_XMODE_PULSE_1_6
;
209 STIER
= IER_UUE
| IER_RLSE
| IER_RAVIE
| IER_RTIOE
;
211 local_irq_restore(flags
);
215 local_irq_save(flags
);
220 pxa_irda_disable_clk(si
);
222 /* disable FICP first */
225 /* set board transceiver to FIR mode */
226 si
->pdata
->transceiver_mode(si
->dev
, IR_FIRMODE
);
228 /* enable the FICP clock */
229 pxa_irda_enable_firclk(si
);
232 pxa_irda_fir_dma_rx_start(si
);
233 ICCR0
= ICCR0_ITR
| ICCR0_RXE
;
235 local_irq_restore(flags
);
245 /* SIR interrupt service routine. */
246 static irqreturn_t
pxa_irda_sir_irq(int irq
, void *dev_id
)
248 struct net_device
*dev
= dev_id
;
249 struct pxa_irda
*si
= netdev_priv(dev
);
254 switch (iir
& 0x0F) {
255 case 0x06: /* Receiver Line Status */
257 while (lsr
& LSR_FIFOE
) {
259 if (lsr
& (LSR_OE
| LSR_PE
| LSR_FE
| LSR_BI
)) {
260 printk(KERN_DEBUG
"pxa_ir: sir receiving error\n");
261 si
->stats
.rx_errors
++;
263 si
->stats
.rx_frame_errors
++;
265 si
->stats
.rx_fifo_errors
++;
267 si
->stats
.rx_bytes
++;
268 async_unwrap_char(dev
, &si
->stats
, &si
->rx_buff
, data
);
272 si
->last_oscr
= OSCR
;
275 case 0x04: /* Received Data Available */
278 case 0x0C: /* Character Timeout Indication */
280 si
->stats
.rx_bytes
++;
281 async_unwrap_char(dev
, &si
->stats
, &si
->rx_buff
, STRBR
);
282 } while (STLSR
& LSR_DR
);
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
;
445 /* FIR interrupt handler */
446 static irqreturn_t
pxa_irda_fir_irq(int irq
, void *dev_id
)
448 struct net_device
*dev
= dev_id
;
449 struct pxa_irda
*si
= netdev_priv(dev
);
453 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
454 si
->last_oscr
= OSCR
;
457 if (icsr0
& (ICSR0_FRE
| ICSR0_RAB
)) {
458 if (icsr0
& ICSR0_FRE
) {
459 printk(KERN_DEBUG
"pxa_ir: fir receive frame error\n");
460 si
->stats
.rx_frame_errors
++;
462 printk(KERN_DEBUG
"pxa_ir: fir receive abort\n");
463 si
->stats
.rx_errors
++;
465 ICSR0
= icsr0
& (ICSR0_FRE
| ICSR0_RAB
);
468 if (icsr0
& ICSR0_EIF
) {
469 /* An error in FIFO occured, or there is a end of frame */
470 pxa_irda_fir_irq_eif(si
, dev
, icsr0
);
474 pxa_irda_fir_dma_rx_start(si
);
475 while ((ICSR1
& ICSR1_RNE
) && i
--)
477 ICCR0
= ICCR0_ITR
| ICCR0_RXE
;
480 printk(KERN_ERR
"pxa_ir: cannot clear Rx FIFO!\n");
485 /* hard_xmit interface of irda device */
486 static int pxa_irda_hard_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
488 struct pxa_irda
*si
= netdev_priv(dev
);
489 int speed
= irda_get_next_speed(skb
);
492 * Does this packet contain a request to change the interface
493 * speed? If so, remember it until we complete the transmission
496 if (speed
!= si
->speed
&& speed
!= -1)
497 si
->newspeed
= speed
;
500 * If this is an empty frame, we can bypass a lot.
505 pxa_irda_set_speed(si
, speed
);
511 netif_stop_queue(dev
);
514 si
->tx_buff
.data
= si
->tx_buff
.head
;
515 si
->tx_buff
.len
= async_wrap_skb(skb
, si
->tx_buff
.data
, si
->tx_buff
.truesize
);
517 /* Disable STUART interrupts and switch to transmit mode. */
519 STISR
= IrSR_IR_TRANSMIT_ON
| IrSR_XMODE_PULSE_1_6
;
521 /* enable STUART and transmit interrupts */
522 STIER
= IER_UUE
| IER_TIE
;
524 unsigned long mtt
= irda_get_mtt(skb
);
526 si
->dma_tx_buff_len
= skb
->len
;
527 skb_copy_from_linear_data(skb
, si
->dma_tx_buff
, skb
->len
);
530 while ((unsigned)(OSCR
- si
->last_oscr
)/4 < mtt
)
533 /* stop RX DMA, disable FICP */
534 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
537 pxa_irda_fir_dma_tx_start(si
);
538 ICCR0
= ICCR0_ITR
| ICCR0_TXE
;
542 dev
->trans_start
= jiffies
;
546 static int pxa_irda_ioctl(struct net_device
*dev
, struct ifreq
*ifreq
, int cmd
)
548 struct if_irda_req
*rq
= (struct if_irda_req
*)ifreq
;
549 struct pxa_irda
*si
= netdev_priv(dev
);
555 if (capable(CAP_NET_ADMIN
)) {
557 * We are unable to set the speed if the
558 * device is not running.
560 if (netif_running(dev
)) {
561 ret
= pxa_irda_set_speed(si
,
564 printk(KERN_INFO
"pxa_ir: SIOCSBANDWIDTH: !netif_running\n");
572 if (capable(CAP_NET_ADMIN
)) {
573 irda_device_set_media_busy(dev
, TRUE
);
580 rq
->ifr_receiving
= IS_FIR(si
) ? 0
581 : si
->rx_buff
.state
!= OUTSIDE_FRAME
;
592 static struct net_device_stats
*pxa_irda_stats(struct net_device
*dev
)
594 struct pxa_irda
*si
= netdev_priv(dev
);
598 static void pxa_irda_startup(struct pxa_irda
*si
)
600 /* Disable STUART interrupts */
602 /* enable STUART interrupt to the processor */
604 /* configure SIR frame format: StartBit - Data 7 ... Data 0 - Stop Bit */
605 STLCR
= LCR_WLS0
| LCR_WLS1
;
606 /* enable FIFO, we use FIFO to improve performance */
607 STFCR
= FCR_TRFIFOE
| FCR_ITL_32
;
611 /* configure FICP ICCR2 */
612 ICCR2
= ICCR2_TXP
| ICCR2_TRIG_32
;
615 DRCMR(17) = si
->rxdma
| DRCMR_MAPVLD
;
616 DRCMR(18) = si
->txdma
| DRCMR_MAPVLD
;
618 /* force SIR reinitialization */
620 pxa_irda_set_speed(si
, 9600);
622 printk(KERN_DEBUG
"pxa_ir: irda startup\n");
625 static void pxa_irda_shutdown(struct pxa_irda
*si
)
629 local_irq_save(flags
);
631 /* disable STUART and interrupt */
633 /* disable STUART SIR mode */
637 DCSR(si
->txdma
) &= ~DCSR_RUN
;
638 DCSR(si
->rxdma
) &= ~DCSR_RUN
;
642 /* disable the STUART or FICP clocks */
643 pxa_irda_disable_clk(si
);
648 local_irq_restore(flags
);
650 /* power off board transceiver */
651 si
->pdata
->transceiver_mode(si
->dev
, IR_OFF
);
653 printk(KERN_DEBUG
"pxa_ir: irda shutdown\n");
656 static int pxa_irda_start(struct net_device
*dev
)
658 struct pxa_irda
*si
= netdev_priv(dev
);
663 err
= request_irq(IRQ_STUART
, pxa_irda_sir_irq
, 0, dev
->name
, dev
);
667 err
= request_irq(IRQ_ICP
, pxa_irda_fir_irq
, 0, dev
->name
, dev
);
672 * The interrupt must remain disabled for now.
674 disable_irq(IRQ_STUART
);
675 disable_irq(IRQ_ICP
);
678 si
->rxdma
= pxa_request_dma("FICP_RX",DMA_PRIO_LOW
, pxa_irda_fir_dma_rx_irq
, dev
);
682 si
->txdma
= pxa_request_dma("FICP_TX",DMA_PRIO_LOW
, pxa_irda_fir_dma_tx_irq
, dev
);
687 si
->dma_rx_buff
= dma_alloc_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
,
688 &si
->dma_rx_buff_phy
, GFP_KERNEL
);
689 if (!si
->dma_rx_buff
)
690 goto err_dma_rx_buff
;
692 si
->dma_tx_buff
= dma_alloc_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
,
693 &si
->dma_tx_buff_phy
, GFP_KERNEL
);
694 if (!si
->dma_tx_buff
)
695 goto err_dma_tx_buff
;
697 /* Setup the serial port for the initial speed. */
698 pxa_irda_startup(si
);
701 * Open a new IrLAP layer instance.
703 si
->irlap
= irlap_open(dev
, &si
->qos
, "pxa");
709 * Now enable the interrupt and start the queue
711 enable_irq(IRQ_STUART
);
713 netif_start_queue(dev
);
715 printk(KERN_DEBUG
"pxa_ir: irda driver opened\n");
720 pxa_irda_shutdown(si
);
721 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_tx_buff
, si
->dma_tx_buff_phy
);
723 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_rx_buff
, si
->dma_rx_buff_phy
);
725 pxa_free_dma(si
->txdma
);
727 pxa_free_dma(si
->rxdma
);
729 free_irq(IRQ_ICP
, dev
);
731 free_irq(IRQ_STUART
, dev
);
737 static int pxa_irda_stop(struct net_device
*dev
)
739 struct pxa_irda
*si
= netdev_priv(dev
);
741 netif_stop_queue(dev
);
743 pxa_irda_shutdown(si
);
747 irlap_close(si
->irlap
);
751 free_irq(IRQ_STUART
, dev
);
752 free_irq(IRQ_ICP
, dev
);
754 pxa_free_dma(si
->rxdma
);
755 pxa_free_dma(si
->txdma
);
758 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_tx_buff
, si
->dma_tx_buff_phy
);
760 dma_free_coherent(si
->dev
, IRDA_FRAME_SIZE_LIMIT
, si
->dma_rx_buff
, si
->dma_rx_buff_phy
);
762 printk(KERN_DEBUG
"pxa_ir: irda driver closed\n");
766 static int pxa_irda_suspend(struct platform_device
*_dev
, pm_message_t state
)
768 struct net_device
*dev
= platform_get_drvdata(_dev
);
771 if (dev
&& netif_running(dev
)) {
772 si
= netdev_priv(dev
);
773 netif_device_detach(dev
);
774 pxa_irda_shutdown(si
);
780 static int pxa_irda_resume(struct platform_device
*_dev
)
782 struct net_device
*dev
= platform_get_drvdata(_dev
);
785 if (dev
&& netif_running(dev
)) {
786 si
= netdev_priv(dev
);
787 pxa_irda_startup(si
);
788 netif_device_attach(dev
);
789 netif_wake_queue(dev
);
796 static int pxa_irda_init_iobuf(iobuff_t
*io
, int size
)
798 io
->head
= kmalloc(size
, GFP_KERNEL
| GFP_DMA
);
799 if (io
->head
!= NULL
) {
801 io
->in_frame
= FALSE
;
802 io
->state
= OUTSIDE_FRAME
;
805 return io
->head
? 0 : -ENOMEM
;
808 static int pxa_irda_probe(struct platform_device
*pdev
)
810 struct net_device
*dev
;
812 unsigned int baudrate_mask
;
815 if (!pdev
->dev
.platform_data
)
818 err
= request_mem_region(__PREG(STUART
), 0x24, "IrDA") ? 0 : -EBUSY
;
822 err
= request_mem_region(__PREG(FICP
), 0x1c, "IrDA") ? 0 : -EBUSY
;
826 dev
= alloc_irdadev(sizeof(struct pxa_irda
));
830 si
= netdev_priv(dev
);
831 si
->dev
= &pdev
->dev
;
832 si
->pdata
= pdev
->dev
.platform_data
;
834 si
->sir_clk
= clk_get(&pdev
->dev
, "UARTCLK");
835 si
->fir_clk
= clk_get(&pdev
->dev
, "FICPCLK");
836 if (IS_ERR(si
->sir_clk
) || IS_ERR(si
->fir_clk
)) {
837 err
= PTR_ERR(IS_ERR(si
->sir_clk
) ? si
->sir_clk
: si
->fir_clk
);
842 * Initialise the SIR buffers
844 err
= pxa_irda_init_iobuf(&si
->rx_buff
, 14384);
847 err
= pxa_irda_init_iobuf(&si
->tx_buff
, 4000);
851 if (si
->pdata
->startup
)
852 err
= si
->pdata
->startup(si
->dev
);
856 dev
->hard_start_xmit
= pxa_irda_hard_xmit
;
857 dev
->open
= pxa_irda_start
;
858 dev
->stop
= pxa_irda_stop
;
859 dev
->do_ioctl
= pxa_irda_ioctl
;
860 dev
->get_stats
= pxa_irda_stats
;
862 irda_init_max_qos_capabilies(&si
->qos
);
865 if (si
->pdata
->transceiver_cap
& IR_SIRMODE
)
866 baudrate_mask
|= IR_9600
|IR_19200
|IR_38400
|IR_57600
|IR_115200
;
867 if (si
->pdata
->transceiver_cap
& IR_FIRMODE
)
868 baudrate_mask
|= IR_4000000
<< 8;
870 si
->qos
.baud_rate
.bits
&= baudrate_mask
;
871 si
->qos
.min_turn_time
.bits
= 7; /* 1ms or more */
873 irda_qos_bits_to_value(&si
->qos
);
875 err
= register_netdev(dev
);
878 dev_set_drvdata(&pdev
->dev
, dev
);
881 if (si
->pdata
->shutdown
)
882 si
->pdata
->shutdown(si
->dev
);
884 kfree(si
->tx_buff
.head
);
886 kfree(si
->rx_buff
.head
);
888 if (si
->sir_clk
&& !IS_ERR(si
->sir_clk
))
889 clk_put(si
->sir_clk
);
890 if (si
->fir_clk
&& !IS_ERR(si
->fir_clk
))
891 clk_put(si
->fir_clk
);
894 release_mem_region(__PREG(FICP
), 0x1c);
896 release_mem_region(__PREG(STUART
), 0x24);
902 static int pxa_irda_remove(struct platform_device
*_dev
)
904 struct net_device
*dev
= platform_get_drvdata(_dev
);
907 struct pxa_irda
*si
= netdev_priv(dev
);
908 unregister_netdev(dev
);
909 if (si
->pdata
->shutdown
)
910 si
->pdata
->shutdown(si
->dev
);
911 kfree(si
->tx_buff
.head
);
912 kfree(si
->rx_buff
.head
);
913 clk_put(si
->fir_clk
);
914 clk_put(si
->sir_clk
);
918 release_mem_region(__PREG(STUART
), 0x24);
919 release_mem_region(__PREG(FICP
), 0x1c);
924 static struct platform_driver pxa_ir_driver
= {
927 .owner
= THIS_MODULE
,
929 .probe
= pxa_irda_probe
,
930 .remove
= pxa_irda_remove
,
931 .suspend
= pxa_irda_suspend
,
932 .resume
= pxa_irda_resume
,
935 static int __init
pxa_irda_init(void)
937 return platform_driver_register(&pxa_ir_driver
);
940 static void __exit
pxa_irda_exit(void)
942 platform_driver_unregister(&pxa_ir_driver
);
945 module_init(pxa_irda_init
);
946 module_exit(pxa_irda_exit
);
948 MODULE_LICENSE("GPL");
949 MODULE_ALIAS("platform:pxa2xx-ir");