2 * Alchemy Semi Au1000 IrDA driver
4 * Copyright 2001 MontaVista Software Inc.
5 * Author: MontaVista Software, Inc.
6 * ppopov@mvista.com or source@mvista.com
8 * This program is free software; you can distribute it and/or modify it
9 * under the terms of the GNU General Public License (Version 2) as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
21 #include <linux/module.h>
22 #include <linux/types.h>
23 #include <linux/init.h>
24 #include <linux/errno.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/slab.h>
28 #include <linux/rtnetlink.h>
29 #include <linux/interrupt.h>
31 #include <linux/bitops.h>
35 #include <asm/au1000.h>
36 #if defined(CONFIG_MIPS_PB1000) || defined(CONFIG_MIPS_PB1100)
37 #include <asm/pb1000.h>
38 #elif defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
39 #include <asm/db1x00.h>
41 #error au1k_ir: unsupported board
44 #include <net/irda/irda.h>
45 #include <net/irda/irmod.h>
46 #include <net/irda/wrapper.h>
47 #include <net/irda/irda_device.h>
48 #include "au1000_ircc.h"
50 static int au1k_irda_net_init(struct net_device
*);
51 static int au1k_irda_start(struct net_device
*);
52 static int au1k_irda_stop(struct net_device
*dev
);
53 static int au1k_irda_hard_xmit(struct sk_buff
*, struct net_device
*);
54 static int au1k_irda_rx(struct net_device
*);
55 static void au1k_irda_interrupt(int, void *);
56 static void au1k_tx_timeout(struct net_device
*);
57 static int au1k_irda_ioctl(struct net_device
*, struct ifreq
*, int);
58 static int au1k_irda_set_speed(struct net_device
*dev
, int speed
);
60 static void *dma_alloc(size_t, dma_addr_t
*);
61 static void dma_free(void *, size_t);
63 static int qos_mtt_bits
= 0x07; /* 1 ms or more */
64 static struct net_device
*ir_devs
[NUM_IR_IFF
];
65 static char version
[] __devinitdata
=
66 "au1k_ircc:1.2 ppopov@mvista.com\n";
68 #define RUN_AT(x) (jiffies + (x))
70 #if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
71 static BCSR
* const bcsr
= (BCSR
*)0xAE000000;
74 static DEFINE_SPINLOCK(ir_lock
);
77 * IrDA peripheral bug. You have to read the register
78 * twice to get the right value.
80 u32
read_ir_reg(u32 addr
)
88 * Buffer allocation/deallocation routines. The buffer descriptor returned
89 * has the virtual and dma address of a buffer suitable for
90 * both, receive and transmit operations.
92 static db_dest_t
*GetFreeDB(struct au1k_private
*aup
)
98 aup
->pDBfree
= pDB
->pnext
;
103 static void ReleaseDB(struct au1k_private
*aup
, db_dest_t
*pDB
)
105 db_dest_t
*pDBfree
= aup
->pDBfree
;
107 pDBfree
->pnext
= pDB
;
113 DMA memory allocation, derived from pci_alloc_consistent.
114 However, the Au1000 data cache is coherent (when programmed
115 so), therefore we return KSEG0 address, not KSEG1.
117 static void *dma_alloc(size_t size
, dma_addr_t
* dma_handle
)
120 int gfp
= GFP_ATOMIC
| GFP_DMA
;
122 ret
= (void *) __get_free_pages(gfp
, get_order(size
));
125 memset(ret
, 0, size
);
126 *dma_handle
= virt_to_bus(ret
);
127 ret
= (void *)KSEG0ADDR(ret
);
133 static void dma_free(void *vaddr
, size_t size
)
135 vaddr
= (void *)KSEG0ADDR(vaddr
);
136 free_pages((unsigned long) vaddr
, get_order(size
));
141 setup_hw_rings(struct au1k_private
*aup
, u32 rx_base
, u32 tx_base
)
144 for (i
=0; i
<NUM_IR_DESC
; i
++) {
145 aup
->rx_ring
[i
] = (volatile ring_dest_t
*)
146 (rx_base
+ sizeof(ring_dest_t
)*i
);
148 for (i
=0; i
<NUM_IR_DESC
; i
++) {
149 aup
->tx_ring
[i
] = (volatile ring_dest_t
*)
150 (tx_base
+ sizeof(ring_dest_t
)*i
);
154 static int au1k_irda_init(void)
156 static unsigned version_printed
= 0;
157 struct au1k_private
*aup
;
158 struct net_device
*dev
;
161 if (version_printed
++ == 0) printk(version
);
163 dev
= alloc_irdadev(sizeof(struct au1k_private
));
167 dev
->irq
= AU1000_IRDA_RX_INT
; /* TX has its own interrupt */
168 err
= au1k_irda_net_init(dev
);
171 err
= register_netdev(dev
);
175 printk(KERN_INFO
"IrDA: Registered device %s\n", dev
->name
);
179 aup
= netdev_priv(dev
);
180 dma_free((void *)aup
->db
[0].vaddr
,
181 MAX_BUF_SIZE
* 2*NUM_IR_DESC
);
182 dma_free((void *)aup
->rx_ring
[0],
183 2 * MAX_NUM_IR_DESC
*(sizeof(ring_dest_t
)));
184 kfree(aup
->rx_buff
.head
);
190 static int au1k_irda_init_iobuf(iobuff_t
*io
, int size
)
192 io
->head
= kmalloc(size
, GFP_KERNEL
);
193 if (io
->head
!= NULL
) {
195 io
->in_frame
= FALSE
;
196 io
->state
= OUTSIDE_FRAME
;
199 return io
->head
? 0 : -ENOMEM
;
202 static const struct net_device_ops au1k_irda_netdev_ops
= {
203 .ndo_open
= au1k_irda_start
,
204 .ndo_stop
= au1k_irda_stop
,
205 .ndo_start_xmit
= au1k_irda_hard_xmit
,
206 .ndo_tx_timeout
= au1k_tx_timeout
,
207 .ndo_do_ioctl
= au1k_irda_ioctl
,
208 .ndo_change_mtu
= eth_change_mtu
,
209 .ndo_validate_addr
= eth_validate_addr
,
210 .ndo_set_mac_address
= eth_mac_addr
,
213 static int au1k_irda_net_init(struct net_device
*dev
)
215 struct au1k_private
*aup
= netdev_priv(dev
);
216 int i
, retval
= 0, err
;
217 db_dest_t
*pDB
, *pDBfree
;
220 err
= au1k_irda_init_iobuf(&aup
->rx_buff
, 14384);
224 dev
->netdev_ops
= &au1k_irda_netdev_ops
;
226 irda_init_max_qos_capabilies(&aup
->qos
);
228 /* The only value we must override it the baudrate */
229 aup
->qos
.baud_rate
.bits
= IR_9600
|IR_19200
|IR_38400
|IR_57600
|
230 IR_115200
|IR_576000
|(IR_4000000
<< 8);
232 aup
->qos
.min_turn_time
.bits
= qos_mtt_bits
;
233 irda_qos_bits_to_value(&aup
->qos
);
237 /* Tx ring follows rx ring + 512 bytes */
238 /* we need a 1k aligned buffer */
239 aup
->rx_ring
[0] = (ring_dest_t
*)
240 dma_alloc(2*MAX_NUM_IR_DESC
*(sizeof(ring_dest_t
)), &temp
);
241 if (!aup
->rx_ring
[0])
244 /* allocate the data buffers */
246 (void *)dma_alloc(MAX_BUF_SIZE
* 2*NUM_IR_DESC
, &temp
);
247 if (!aup
->db
[0].vaddr
)
250 setup_hw_rings(aup
, (u32
)aup
->rx_ring
[0], (u32
)aup
->rx_ring
[0] + 512);
254 for (i
=0; i
<(2*NUM_IR_DESC
); i
++) {
255 pDB
->pnext
= pDBfree
;
258 (u32
*)((unsigned)aup
->db
[0].vaddr
+ MAX_BUF_SIZE
*i
);
259 pDB
->dma_addr
= (dma_addr_t
)virt_to_bus(pDB
->vaddr
);
262 aup
->pDBfree
= pDBfree
;
264 /* attach a data buffer to each descriptor */
265 for (i
=0; i
<NUM_IR_DESC
; i
++) {
266 pDB
= GetFreeDB(aup
);
268 aup
->rx_ring
[i
]->addr_0
= (u8
)(pDB
->dma_addr
& 0xff);
269 aup
->rx_ring
[i
]->addr_1
= (u8
)((pDB
->dma_addr
>>8) & 0xff);
270 aup
->rx_ring
[i
]->addr_2
= (u8
)((pDB
->dma_addr
>>16) & 0xff);
271 aup
->rx_ring
[i
]->addr_3
= (u8
)((pDB
->dma_addr
>>24) & 0xff);
272 aup
->rx_db_inuse
[i
] = pDB
;
274 for (i
=0; i
<NUM_IR_DESC
; i
++) {
275 pDB
= GetFreeDB(aup
);
277 aup
->tx_ring
[i
]->addr_0
= (u8
)(pDB
->dma_addr
& 0xff);
278 aup
->tx_ring
[i
]->addr_1
= (u8
)((pDB
->dma_addr
>>8) & 0xff);
279 aup
->tx_ring
[i
]->addr_2
= (u8
)((pDB
->dma_addr
>>16) & 0xff);
280 aup
->tx_ring
[i
]->addr_3
= (u8
)((pDB
->dma_addr
>>24) & 0xff);
281 aup
->tx_ring
[i
]->count_0
= 0;
282 aup
->tx_ring
[i
]->count_1
= 0;
283 aup
->tx_ring
[i
]->flags
= 0;
284 aup
->tx_db_inuse
[i
] = pDB
;
287 #if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
289 bcsr
->resets
&= ~BCSR_RESETS_IRDA_MODE_MASK
;
290 bcsr
->resets
|= BCSR_RESETS_IRDA_MODE_FULL
;
297 dma_free((void *)aup
->rx_ring
[0],
298 2 * MAX_NUM_IR_DESC
*(sizeof(ring_dest_t
)));
300 kfree(aup
->rx_buff
.head
);
302 printk(KERN_ERR
"au1k_init_module failed. Returns %d\n", retval
);
307 static int au1k_init(struct net_device
*dev
)
309 struct au1k_private
*aup
= netdev_priv(dev
);
314 /* bring the device out of reset */
315 control
= 0xe; /* coherent, clock enable, one half system clock */
317 #ifndef CONFIG_CPU_LITTLE_ENDIAN
324 for (i
=0; i
<NUM_IR_DESC
; i
++) {
325 aup
->rx_ring
[i
]->flags
= AU_OWN
;
328 writel(control
, IR_INTERFACE_CONFIG
);
331 writel(read_ir_reg(IR_ENABLE
) & ~0x8000, IR_ENABLE
); /* disable PHY */
334 writel(MAX_BUF_SIZE
, IR_MAX_PKT_LEN
);
336 ring_address
= (u32
)virt_to_phys((void *)aup
->rx_ring
[0]);
337 writel(ring_address
>> 26, IR_RING_BASE_ADDR_H
);
338 writel((ring_address
>> 10) & 0xffff, IR_RING_BASE_ADDR_L
);
340 writel(RING_SIZE_64
<<8 | RING_SIZE_64
<<12, IR_RING_SIZE
);
342 writel(1<<2 | IR_ONE_PIN
, IR_CONFIG_2
); /* 48MHz */
343 writel(0, IR_RING_ADDR_CMPR
);
345 au1k_irda_set_speed(dev
, 9600);
349 static int au1k_irda_start(struct net_device
*dev
)
353 struct au1k_private
*aup
= netdev_priv(dev
);
355 if ((retval
= au1k_init(dev
))) {
356 printk(KERN_ERR
"%s: error in au1k_init\n", dev
->name
);
360 if ((retval
= request_irq(AU1000_IRDA_TX_INT
, &au1k_irda_interrupt
,
361 0, dev
->name
, dev
))) {
362 printk(KERN_ERR
"%s: unable to get IRQ %d\n",
363 dev
->name
, dev
->irq
);
366 if ((retval
= request_irq(AU1000_IRDA_RX_INT
, &au1k_irda_interrupt
,
367 0, dev
->name
, dev
))) {
368 free_irq(AU1000_IRDA_TX_INT
, dev
);
369 printk(KERN_ERR
"%s: unable to get IRQ %d\n",
370 dev
->name
, dev
->irq
);
374 /* Give self a hardware name */
375 sprintf(hwname
, "Au1000 SIR/FIR");
376 aup
->irlap
= irlap_open(dev
, &aup
->qos
, hwname
);
377 netif_start_queue(dev
);
379 writel(read_ir_reg(IR_CONFIG_2
) | 1<<8, IR_CONFIG_2
); /* int enable */
381 aup
->timer
.expires
= RUN_AT((3*HZ
));
382 aup
->timer
.data
= (unsigned long)dev
;
386 static int au1k_irda_stop(struct net_device
*dev
)
388 struct au1k_private
*aup
= netdev_priv(dev
);
390 /* disable interrupts */
391 writel(read_ir_reg(IR_CONFIG_2
) & ~(1<<8), IR_CONFIG_2
);
392 writel(0, IR_CONFIG_1
);
393 writel(0, IR_INTERFACE_CONFIG
); /* disable clock */
397 irlap_close(aup
->irlap
);
401 netif_stop_queue(dev
);
402 del_timer(&aup
->timer
);
404 /* disable the interrupt */
405 free_irq(AU1000_IRDA_TX_INT
, dev
);
406 free_irq(AU1000_IRDA_RX_INT
, dev
);
410 static void __exit
au1k_irda_exit(void)
412 struct net_device
*dev
= ir_devs
[0];
413 struct au1k_private
*aup
= netdev_priv(dev
);
415 unregister_netdev(dev
);
417 dma_free((void *)aup
->db
[0].vaddr
,
418 MAX_BUF_SIZE
* 2*NUM_IR_DESC
);
419 dma_free((void *)aup
->rx_ring
[0],
420 2 * MAX_NUM_IR_DESC
*(sizeof(ring_dest_t
)));
421 kfree(aup
->rx_buff
.head
);
427 update_tx_stats(struct net_device
*dev
, u32 status
, u32 pkt_len
)
429 struct au1k_private
*aup
= netdev_priv(dev
);
430 struct net_device_stats
*ps
= &aup
->stats
;
433 ps
->tx_bytes
+= pkt_len
;
435 if (status
& IR_TX_ERROR
) {
437 ps
->tx_aborted_errors
++;
442 static void au1k_tx_ack(struct net_device
*dev
)
444 struct au1k_private
*aup
= netdev_priv(dev
);
445 volatile ring_dest_t
*ptxd
;
447 ptxd
= aup
->tx_ring
[aup
->tx_tail
];
448 while (!(ptxd
->flags
& AU_OWN
) && (aup
->tx_tail
!= aup
->tx_head
)) {
449 update_tx_stats(dev
, ptxd
->flags
,
450 ptxd
->count_1
<<8 | ptxd
->count_0
);
455 aup
->tx_tail
= (aup
->tx_tail
+ 1) & (NUM_IR_DESC
- 1);
456 ptxd
= aup
->tx_ring
[aup
->tx_tail
];
460 netif_wake_queue(dev
);
464 if (aup
->tx_tail
== aup
->tx_head
) {
466 au1k_irda_set_speed(dev
, aup
->newspeed
);
470 writel(read_ir_reg(IR_CONFIG_1
) & ~IR_TX_ENABLE
,
473 writel(read_ir_reg(IR_CONFIG_1
) | IR_RX_ENABLE
,
475 writel(0, IR_RING_PROMPT
);
483 * Au1000 transmit routine.
485 static int au1k_irda_hard_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
487 struct au1k_private
*aup
= netdev_priv(dev
);
488 int speed
= irda_get_next_speed(skb
);
489 volatile ring_dest_t
*ptxd
;
495 if (speed
!= aup
->speed
&& speed
!= -1) {
496 aup
->newspeed
= speed
;
499 if ((skb
->len
== 0) && (aup
->newspeed
)) {
500 if (aup
->tx_tail
== aup
->tx_head
) {
501 au1k_irda_set_speed(dev
, speed
);
508 ptxd
= aup
->tx_ring
[aup
->tx_head
];
511 if (flags
& AU_OWN
) {
512 printk(KERN_DEBUG
"%s: tx_full\n", dev
->name
);
513 netif_stop_queue(dev
);
515 return NETDEV_TX_BUSY
;
517 else if (((aup
->tx_head
+ 1) & (NUM_IR_DESC
- 1)) == aup
->tx_tail
) {
518 printk(KERN_DEBUG
"%s: tx_full\n", dev
->name
);
519 netif_stop_queue(dev
);
521 return NETDEV_TX_BUSY
;
524 pDB
= aup
->tx_db_inuse
[aup
->tx_head
];
527 if (read_ir_reg(IR_RX_BYTE_CNT
) != 0) {
528 printk("tx warning: rx byte cnt %x\n",
529 read_ir_reg(IR_RX_BYTE_CNT
));
533 if (aup
->speed
== 4000000) {
535 skb_copy_from_linear_data(skb
, pDB
->vaddr
, skb
->len
);
536 ptxd
->count_0
= skb
->len
& 0xff;
537 ptxd
->count_1
= (skb
->len
>> 8) & 0xff;
542 len
= async_wrap_skb(skb
, (u8
*)pDB
->vaddr
, MAX_BUF_SIZE
);
543 ptxd
->count_0
= len
& 0xff;
544 ptxd
->count_1
= (len
>> 8) & 0xff;
545 ptxd
->flags
|= IR_DIS_CRC
;
546 au_writel(au_readl(0xae00000c) & ~(1<<13), 0xae00000c);
548 ptxd
->flags
|= AU_OWN
;
551 writel(read_ir_reg(IR_CONFIG_1
) | IR_TX_ENABLE
, IR_CONFIG_1
);
552 writel(0, IR_RING_PROMPT
);
556 aup
->tx_head
= (aup
->tx_head
+ 1) & (NUM_IR_DESC
- 1);
557 dev
->trans_start
= jiffies
;
563 update_rx_stats(struct net_device
*dev
, u32 status
, u32 count
)
565 struct au1k_private
*aup
= netdev_priv(dev
);
566 struct net_device_stats
*ps
= &aup
->stats
;
570 if (status
& IR_RX_ERROR
) {
572 if (status
& (IR_PHY_ERROR
|IR_FIFO_OVER
))
573 ps
->rx_missed_errors
++;
574 if (status
& IR_MAX_LEN
)
575 ps
->rx_length_errors
++;
576 if (status
& IR_CRC_ERROR
)
580 ps
->rx_bytes
+= count
;
584 * Au1000 receive routine.
586 static int au1k_irda_rx(struct net_device
*dev
)
588 struct au1k_private
*aup
= netdev_priv(dev
);
590 volatile ring_dest_t
*prxd
;
594 prxd
= aup
->rx_ring
[aup
->rx_head
];
597 while (!(flags
& AU_OWN
)) {
598 pDB
= aup
->rx_db_inuse
[aup
->rx_head
];
599 count
= prxd
->count_1
<<8 | prxd
->count_0
;
600 if (!(flags
& IR_RX_ERROR
)) {
602 update_rx_stats(dev
, flags
, count
);
603 skb
=alloc_skb(count
+1,GFP_ATOMIC
);
605 aup
->netdev
->stats
.rx_dropped
++;
609 if (aup
->speed
== 4000000)
612 skb_put(skb
, count
-2);
613 skb_copy_to_linear_data(skb
, pDB
->vaddr
, count
- 2);
615 skb_reset_mac_header(skb
);
616 skb
->protocol
= htons(ETH_P_IRDA
);
621 prxd
->flags
|= AU_OWN
;
622 aup
->rx_head
= (aup
->rx_head
+ 1) & (NUM_IR_DESC
- 1);
623 writel(0, IR_RING_PROMPT
);
626 /* next descriptor */
627 prxd
= aup
->rx_ring
[aup
->rx_head
];
635 static irqreturn_t
au1k_irda_interrupt(int dummy
, void *dev_id
)
637 struct net_device
*dev
= dev_id
;
639 writel(0, IR_INT_CLEAR
); /* ack irda interrupts */
649 * The Tx ring has been full longer than the watchdog timeout
650 * value. The transmitter must be hung?
652 static void au1k_tx_timeout(struct net_device
*dev
)
655 struct au1k_private
*aup
= netdev_priv(dev
);
657 printk(KERN_ERR
"%s: tx timeout\n", dev
->name
);
660 au1k_irda_set_speed(dev
, speed
);
662 netif_wake_queue(dev
);
667 * Set the IrDA communications speed.
670 au1k_irda_set_speed(struct net_device
*dev
, int speed
)
673 struct au1k_private
*aup
= netdev_priv(dev
);
675 int ret
= 0, timeout
= 10, i
;
676 volatile ring_dest_t
*ptxd
;
677 #if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
678 unsigned long irda_resets
;
681 if (speed
== aup
->speed
)
684 spin_lock_irqsave(&ir_lock
, flags
);
686 /* disable PHY first */
687 writel(read_ir_reg(IR_ENABLE
) & ~0x8000, IR_ENABLE
);
690 writel(read_ir_reg(IR_CONFIG_1
) & ~(IR_RX_ENABLE
|IR_TX_ENABLE
),
693 while (read_ir_reg(IR_ENABLE
) & (IR_RX_STATUS
| IR_TX_STATUS
)) {
696 printk(KERN_ERR
"%s: rx/tx disable timeout\n",
703 writel(read_ir_reg(IR_CONFIG_1
) & ~IR_DMA_ENABLE
, IR_CONFIG_1
);
707 * After we disable tx/rx. the index pointers
710 aup
->tx_head
= aup
->tx_tail
= aup
->rx_head
= 0;
711 for (i
=0; i
<NUM_IR_DESC
; i
++) {
712 ptxd
= aup
->tx_ring
[i
];
718 for (i
=0; i
<NUM_IR_DESC
; i
++) {
719 ptxd
= aup
->rx_ring
[i
];
722 ptxd
->flags
= AU_OWN
;
725 if (speed
== 4000000) {
726 #if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
727 bcsr
->resets
|= BCSR_RESETS_FIR_SEL
;
728 #else /* Pb1000 and Pb1100 */
729 writel(1<<13, CPLD_AUX1
);
733 #if defined(CONFIG_MIPS_DB1000) || defined(CONFIG_MIPS_DB1100)
734 bcsr
->resets
&= ~BCSR_RESETS_FIR_SEL
;
735 #else /* Pb1000 and Pb1100 */
736 writel(readl(CPLD_AUX1
) & ~(1<<13), CPLD_AUX1
);
742 writel(11<<10 | 12<<5, IR_WRITE_PHY_CONFIG
);
743 writel(IR_SIR_MODE
, IR_CONFIG_1
);
746 writel(5<<10 | 12<<5, IR_WRITE_PHY_CONFIG
);
747 writel(IR_SIR_MODE
, IR_CONFIG_1
);
750 writel(2<<10 | 12<<5, IR_WRITE_PHY_CONFIG
);
751 writel(IR_SIR_MODE
, IR_CONFIG_1
);
754 writel(1<<10 | 12<<5, IR_WRITE_PHY_CONFIG
);
755 writel(IR_SIR_MODE
, IR_CONFIG_1
);
758 writel(12<<5, IR_WRITE_PHY_CONFIG
);
759 writel(IR_SIR_MODE
, IR_CONFIG_1
);
762 writel(0xF, IR_WRITE_PHY_CONFIG
);
763 writel(IR_FIR
|IR_DMA_ENABLE
|IR_RX_ENABLE
, IR_CONFIG_1
);
766 printk(KERN_ERR
"%s unsupported speed %x\n", dev
->name
, speed
);
772 writel(read_ir_reg(IR_ENABLE
) | 0x8000, IR_ENABLE
);
775 control
= read_ir_reg(IR_ENABLE
);
776 writel(0, IR_RING_PROMPT
);
779 if (control
& (1<<14)) {
780 printk(KERN_ERR
"%s: configuration error\n", dev
->name
);
783 if (control
& (1<<11))
784 printk(KERN_DEBUG
"%s Valid SIR config\n", dev
->name
);
785 if (control
& (1<<12))
786 printk(KERN_DEBUG
"%s Valid MIR config\n", dev
->name
);
787 if (control
& (1<<13))
788 printk(KERN_DEBUG
"%s Valid FIR config\n", dev
->name
);
789 if (control
& (1<<10))
790 printk(KERN_DEBUG
"%s TX enabled\n", dev
->name
);
791 if (control
& (1<<9))
792 printk(KERN_DEBUG
"%s RX enabled\n", dev
->name
);
795 spin_unlock_irqrestore(&ir_lock
, flags
);
800 au1k_irda_ioctl(struct net_device
*dev
, struct ifreq
*ifreq
, int cmd
)
802 struct if_irda_req
*rq
= (struct if_irda_req
*)ifreq
;
803 struct au1k_private
*aup
= netdev_priv(dev
);
804 int ret
= -EOPNOTSUPP
;
808 if (capable(CAP_NET_ADMIN
)) {
810 * We are unable to set the speed if the
811 * device is not running.
814 ret
= au1k_irda_set_speed(dev
,
817 printk(KERN_ERR
"%s ioctl: !netif_running\n",
826 if (capable(CAP_NET_ADMIN
)) {
827 irda_device_set_media_busy(dev
, TRUE
);
833 rq
->ifr_receiving
= 0;
841 MODULE_AUTHOR("Pete Popov <ppopov@mvista.com>");
842 MODULE_DESCRIPTION("Au1000 IrDA Device Driver");
844 module_init(au1k_irda_init
);
845 module_exit(au1k_irda_exit
);