?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.2.0
[davej-history.git] / drivers / net / irda / uircc.c
blob05da78a001ffd2947b43a9363481cb0e58724ab2
1 /*********************************************************************
2 *
3 * Filename: uircc.c
4 * Version: 0.1
5 * Description: Driver for the Sharp Universal Infrared
6 * Communications Controller (UIRCC)
7 * Status: Experimental.
8 * Author: Dag Brattli <dagb@cs.uit.no>
9 * Created at: Sat Dec 26 10:59:03 1998
10 * Modified at: Tue Jan 19 23:54:04 1999
11 * Modified by: Dag Brattli <dagb@cs.uit.no>
12 *
13 * Copyright (c) 1998 Dag Brattli, All Rights Reserved.
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of
18 * the License, or (at your option) any later version.
19 *
20 * Neither Dag Brattli nor University of Tromsø admit liability nor
21 * provide warranty for any of this software. This material is
22 * provided "AS-IS" and at no charge.
23 *
24 * Applicable Models : Tecra 510CDT, 500C Series, 530CDT, 520CDT,
25 * 740CDT, Portege 300CT, 660CDT, Satellite 220C Series,
26 * Satellite Pro, 440C Series, 470CDT, 460C Series, 480C Series
27 *
28 * Notice that FIR mode is not working yet, since I don't know
29 * how to make the UIRCC drive the interrupt line, and not the
30 * UART (which is used for SIR speeds). Please mail me if you know!
31 *
32 ********************************************************************/
33
34 #include <linux/module.h>
35
36 #include <linux/kernel.h>
37 #include <linux/types.h>
38 #include <linux/skbuff.h>
39 #include <linux/netdevice.h>
40 #include <linux/ioport.h>
41 #include <linux/delay.h>
42 #include <linux/malloc.h>
43 #include <linux/delay.h>
44 #include <linux/init.h>
45 #include <linux/init.h>
46
47 #include <asm/io.h>
48 #include <asm/dma.h>
49 #include <asm/byteorder.h>
50
51 #include <net/irda/wrapper.h>
52 #include <net/irda/irda.h>
53 #include <net/irda/irmod.h>
54 #include <net/irda/irlap_frame.h>
55 #include <net/irda/irda_device.h>
56
57 #include <net/irda/uircc.h>
58 #include <net/irda/irport.h>
59
60 static char *driver_name = "uircc";
61
62 #define CHIP_IO_EXTENT 16
63
64 static unsigned int io[] = { 0x300, ~0, ~0, ~0 };
65 static unsigned int io2[] = { 0x3e8, 0, 0, 0};
66 static unsigned int irq[] = { 11, 0, 0, 0 };
67 static unsigned int dma[] = { 5, 0, 0, 0 };
68
69 static struct uircc_cb *dev_self[] = { NULL, NULL, NULL, NULL};
70
71 /* Some prototypes */
72 static int uircc_open( int i, unsigned int iobase, unsigned int board_addr,
73 unsigned int irq, unsigned int dma);
74 static int uircc_close( struct irda_device *idev);
75 static int uircc_probe( int iobase, int board_addr, int irq, int dma);
76 static int uircc_dma_receive( struct irda_device *idev);
77 static int uircc_dma_receive_complete(struct irda_device *idev, int iobase);
78 static int uircc_hard_xmit( struct sk_buff *skb, struct device *dev);
79 static void uircc_dma_write( struct irda_device *idev, int iobase);
80 static void uircc_change_speed( struct irda_device *idev, int baud);
81 static void uircc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
82 static void uircc_wait_until_sent( struct irda_device *idev);
83 static int uircc_is_receiving( struct irda_device *idev);
84
85 static int uircc_net_init( struct device *dev);
86 static int uircc_net_open( struct device *dev);
87 static int uircc_net_close( struct device *dev);
88
89 /*
90 * Function uircc_init ()
91 *
92 * Initialize chip. Just try to find out how many chips we are dealing with
93 * and where they are
94 */
95 __initfunc(int uircc_init(void))
96 {
97 int i;
98
99 for ( i=0; (io[i] < 2000) && (i < 4); i++) {
100 int ioaddr = io[i];
101 if (check_region(ioaddr, CHIP_IO_EXTENT))
102 continue;
103 if (uircc_open( i, io[i], io2[i], irq[i], dma[i]) == 0)
104 return 0;
105 }
106 return -ENODEV;
107 }
108
109 /*
110 * Function uircc_cleanup ()
111 *
112 * Close all configured chips
113 *
114 */
115 #ifdef MODULE
116 static void uircc_cleanup(void)
117 {
118 int i;
119
120 DEBUG( 4, __FUNCTION__ "()\n");
121
122 for ( i=0; i < 4; i++) {
123 if ( dev_self[i])
124 uircc_close( &(dev_self[i]->idev));
125 }
126 }
127 #endif /* MODULE */
128
129 /*
130 * Function uircc_open (iobase, irq)
131 *
132 * Open driver instance
133 *
134 */
135 static int uircc_open( int i, unsigned int iobase, unsigned int iobase2,
136 unsigned int irq, unsigned int dma)
137 {
138 struct uircc_cb *self;
139 struct irda_device *idev;
140 int ret;
141
142 DEBUG( 0, __FUNCTION__ "()\n");
143
144 if (( uircc_probe( iobase, iobase2, irq, dma)) == -1)
145 return -1;
146
147 /*
148 * Allocate new instance of the driver
149 */
150 self = kmalloc( sizeof(struct uircc_cb), GFP_KERNEL);
151 if ( self == NULL) {
152 printk( KERN_ERR "IrDA: Can't allocate memory for "
153 "IrDA control block!\n");
154 return -ENOMEM;
155 }
156 memset( self, 0, sizeof(struct uircc_cb));
157
158 /* Need to store self somewhere */
159 dev_self[i] = self;
160
161 idev = &self->idev;
162
163 /* Initialize IO */
164 idev->io.iobase = iobase;
165 idev->io.iobase2 = iobase2; /* Used by irport */
166 idev->io.irq = irq;
167 idev->io.io_ext = CHIP_IO_EXTENT;
168 idev->io.io_ext2 = 8; /* Used by irport */
169 idev->io.dma = dma;
170 idev->io.fifo_size = 16;
171
172 /* Lock the port that we need */
173 ret = check_region( idev->io.iobase, idev->io.io_ext);
174 if ( ret < 0) {
175 DEBUG( 0, __FUNCTION__ "(), can't get iobase of 0x%03x\n",
176 idev->io.iobase);
177 /* uircc_cleanup( self->idev); */
178 return -ENODEV;
179 }
180 ret = check_region( idev->io.iobase2, idev->io.io_ext2);
181 if ( ret < 0) {
182 DEBUG( 0, __FUNCTION__ "(), can't get iobase of 0x%03x\n",
183 idev->io.iobase2);
184 /* uircc_cleanup( self->idev); */
185 return -ENODEV;
186 }
187 request_region( idev->io.iobase, idev->io.io_ext, idev->name);
188 request_region( idev->io.iobase2, idev->io.io_ext2, idev->name);
189
190 /* Initialize QoS for this device */
191 irda_init_max_qos_capabilies( &idev->qos);
192
193 /* The only value we must override it the baudrate */
194 idev->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600|
195 IR_115200|IR_576000|IR_1152000|(IR_4000000 << 8);
196
197 idev->qos.min_turn_time.bits = 0x07;
198 irda_qos_bits_to_value( &idev->qos);
199
200 /* Specify which buffer allocation policy we need */
201 idev->rx_buff.flags = GFP_KERNEL | GFP_DMA;
202 idev->tx_buff.flags = GFP_KERNEL | GFP_DMA;
203
204 /* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */
205 idev->rx_buff.truesize = 4000;
206 idev->tx_buff.truesize = 4000;
207
208 /* Initialize callbacks */
209 idev->hard_xmit = uircc_hard_xmit;
210 idev->change_speed = uircc_change_speed;
211 idev->wait_until_sent = uircc_wait_until_sent;
212 idev->is_receiving = uircc_is_receiving;
213
214 /* Override the network functions we need to use */
215 idev->netdev.init = uircc_net_init;
216 idev->netdev.hard_start_xmit = uircc_hard_xmit;
217 idev->netdev.open = uircc_net_open;
218 idev->netdev.stop = uircc_net_close;
219
220 irport_open( iobase2);
221
222 /* Open the IrDA device */
223 irda_device_open( idev, driver_name, self);
224
225 return 0;
226 }
227
228 /*
229 * Function uircc_close (idev)
230 *
231 * Close driver instance
232 *
233 */
234 static int uircc_close( struct irda_device *idev)
235 {
236 int iobase;
237
238 DEBUG( 4, __FUNCTION__ "()\n");
239
240 ASSERT( idev != NULL, return -1;);
241 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return -1;);
242
243 iobase = idev->io.iobase;
244
245 /* Disable modem */
246 outb( 0x00, iobase+UIRCC_CR10);
247
248 irport_close( idev->io.iobase2);
249
250 /* Release the PORT that this driver is using */
251 DEBUG( 4, __FUNCTION__ "(), Releasing Region %03x\n", idev->io.iobase);
252 release_region( idev->io.iobase, idev->io.io_ext);
253
254 if ( idev->io.iobase2) {
255 DEBUG( 4, __FUNCTION__ "(), Releasing Region %03x\n",
256 idev->io.iobase2);
257 release_region( idev->io.iobase2, idev->io.io_ext2);
258 }
259
260 irda_device_close( idev);
261
262 return 0;
263 }
264
265 /*
266 * Function uircc_probe (iobase, board_addr, irq, dma)
267 *
268 * Returns non-negative on success.
269 *
270 */
271 static int uircc_probe( int iobase, int iobase2, int irq, int dma)
272 {
273 int version;
274 int probe_irq=0;
275 unsigned long mask;
276 int i;
277
278 DEBUG( 0, __FUNCTION__ "()\n");
279
280 /* read the chip version, should be 0x03 */
281 version = inb( iobase+UIRCC_SR8);
282
283 if ( version != 0x03) {
284 DEBUG( 0, __FUNCTION__ "(), Wrong chip version");
285 return -1;
286 }
287 DEBUG( 0, "UIRCC driver loaded. Version: 0x%02x\n", version);
288
289 /* Reset chip */
290 outb( UIRCC_CR0_SYS_RST, iobase+UIRCC_CR0);
291
292 /* Initialize some registers */
293 outb( 0, iobase+UIRCC_CR11);
294 outb( 0, iobase+UIRCC_CR9);
295
296 /* Enable DMA single mode */
297 outb( UIRCC_CR1_RX_DMA|UIRCC_CR1_TX_DMA|UIRCC_CR1_MUST_SET,
298 iobase+UIRCC_CR1);
299
300 /* Disable interrupts */
301 outb( 0xff, iobase+UIRCC_CR2);
302
303 #if 0
304 irport_close( iobase2);
305
306 for (i=0;i<1;i++) {
307
308 /* Set appropriate speed mode */
309 outb( UIRCC_CR10_FIR, iobase+UIRCC_CR10);
310
311 /* Enable DMA single mode */
312 outb( UIRCC_CR1_RX_DMA|UIRCC_CR1_TX_DMA|UIRCC_CR1_MUST_SET,
313 iobase+UIRCC_CR1);
314
315 /* Set up timer */
316 outb( 0x01, iobase+UIRCC_CR12);
317 outb( 0x00, iobase+UIRCC_CR13);
318
319 /* Set interrupt mask */
320 outb( 0x82, iobase+UIRCC_CR2);
321
322 DEBUG( 0, __FUNCTION__ "(*), sr3=%#x, sr2=%#x, sr10=%#x, sr12=%#x\n",
323 inb( iobase+UIRCC_SR3), inb( iobase+UIRCC_SR2),
324 inb( iobase+UIRCC_SR10), inb( iobase+UIRCC_SR12));
325
326 mask = probe_irq_on();
327
328 /* Enable timer */
329 outb( 0x08, iobase+UIRCC_CR11);
330
331 udelay( 10000); /* Wait for interrupt! */
332
333 probe_irq = probe_irq_off( mask);
334
335 DEBUG( 0, "Found irq=%d\n", probe_irq);
336
337 DEBUG( 0, __FUNCTION__ "(), sr3=%#x, sr2=%#x, sr10=%#x, sr12=%#x\n",
338 inb( iobase+UIRCC_SR3), inb( iobase+UIRCC_SR2),
339 inb( iobase+UIRCC_SR10), inb( iobase+UIRCC_SR12));
340
341
342 /* Diable timer */
343 outb( 0x00, iobase+UIRCC_CR11);
344 }
345 #endif
346
347 /* Set self poll address */
348
349 return 0;
350 }
351
352 /*
353 * Function uircc_change_speed (idev, baud)
354 *
355 * Change the speed of the device
356 *
357 */
358 static void uircc_change_speed( struct irda_device *idev, int speed)
359 {
360 struct uircc_cb *self;
361 int iobase;
362 int modem = UIRCC_CR10_SIR;
363
364 DEBUG( 0, __FUNCTION__ "()\n");
365
366 ASSERT( idev != NULL, return;);
367 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return;);
368
369 self = idev->priv;
370 iobase = idev->io.iobase;
371
372 /* Update accounting for new speed */
373 idev->io.baudrate = speed;
374
375 /* Disable interrupts */
376 outb( 0xff, iobase+UIRCC_CR2);
377
378 switch ( speed) {
379 case 9600:
380 case 19200:
381 case 37600:
382 case 57600:
383 case 115200:
384 /* irport_open( idev->io.iobase2); */
385 irport_change_speed( idev->io.iobase2, speed);
386 modem = UIRCC_CR10_SIR;
387 break;
388 case 576000:
389
390 DEBUG(0, __FUNCTION__ "(), handling baud of 576000\n");
391 break;
392 case 1152000:
393
394 DEBUG(0, __FUNCTION__ "(), handling baud of 1152000\n");
395 break;
396 case 4000000:
397 irport_close( idev->io.iobase2);
398 modem = UIRCC_CR10_FIR;
399 DEBUG(0, __FUNCTION__ "(), handling baud of 4000000\n");
400 break;
401 default:
402 DEBUG( 0, __FUNCTION__ "(), unknown baud rate of %d\n", speed);
403 break;
404 }
405
406 /* Set appropriate speed mode */
407 outb( modem, iobase+UIRCC_CR10);
408
409 idev->netdev.tbusy = 0;
410
411 /* Enable some interrupts so we can receive frames */
412 if ( speed > 115200) {
413 /* Enable DMA single mode */
414 outb( UIRCC_CR1_RX_DMA|UIRCC_CR1_TX_DMA|UIRCC_CR1_MUST_SET,
415 iobase+UIRCC_CR1);
416
417 /* outb( UIRCC_CR2_RECV_MASK, iobase+UIRCC_CR2); */
418 outb( 0, iobase+UIRCC_CR2);
419 uircc_dma_receive( idev);
420 }
421 }
422
423 /*
424 * Function uircc_hard_xmit (skb, dev)
425 *
426 * Transmit the frame!
427 *
428 */
429 static int uircc_hard_xmit( struct sk_buff *skb, struct device *dev)
430 {
431 struct irda_device *idev;
432 int iobase;
433 int mtt;
434
435 idev = (struct irda_device *) dev->priv;
436
437 ASSERT( idev != NULL, return 0;);
438 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return 0;);
439
440 iobase = idev->io.iobase;
441
442 DEBUG(0, __FUNCTION__ "(%ld), skb->len=%d\n", jiffies, (int) skb->len);
443
444 /* Use irport for SIR speeds */
445 if ( idev->io.baudrate <= 115200) {
446 return irport_hard_xmit( skb, dev);
447 }
448
449 if ( dev->tbusy) {
450 __u8 sr3;
451
452 DEBUG( 4, __FUNCTION__ "(), tbusy==TRUE\n");
453
454 return -EBUSY;
455 }
456
457 /* Lock transmit buffer */
458 if ( irda_lock( (void *) &dev->tbusy) == FALSE)
459 return -EBUSY;
460
461 memcpy( idev->tx_buff.data, skb->data, skb->len);
462
463 /* Make sure that the length is a multiple of 16 bits */
464 if ( skb->len & 0x01)
465 skb->len++;
466
467 idev->tx_buff.len = skb->len;
468 idev->tx_buff.head = idev->tx_buff.data;
469 idev->tx_buff.offset = 0;
470
471 mtt = irda_get_mtt( skb);
472
473 /* Use udelay for delays less than 50 us. */
474 if (mtt)
475 udelay( mtt);
476
477 /* Enable transmit interrupts */
478 /* outb( UIRCC_CR2_XMIT_MASK, iobase+UIRCC_CR2); */
479 outb( 0, iobase+UIRCC_CR2);
480
481 uircc_dma_write( idev, iobase);
482
483 dev_kfree_skb( skb);
484
485 return 0;
486 }
487
488 /*
489 * Function uircc_dma_xmit (idev, iobase)
490 *
491 * Transmit data using DMA
492 *
493 */
494 static void uircc_dma_write( struct irda_device *idev, int iobase)
495 {
496 struct uircc_cb *self;
497 int i;
498
499 DEBUG( 0, __FUNCTION__ "()\n");
500
501 ASSERT( idev != NULL, return;);
502 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return;);
503
504 self = idev->priv;
505
506 /* Receiving disable */
507 self->cr3 &= ~UIRCC_CR3_RECV_EN;
508 outb( self->cr3, iobase+UIRCC_CR3);
509
510 setup_dma( idev->io.dma, idev->tx_buff.data, idev->tx_buff.len,
511 DMA_MODE_WRITE);
512
513 DEBUG( 0, __FUNCTION__ "residue=%d\n",
514 get_dma_residue( idev->io.dma));
515
516 idev->io.direction = IO_XMIT;
517
518 /* Set frame length */
519 outb( idev->tx_buff.len & 0xff, iobase+UIRCC_CR4); /* Low byte */
520 outb( idev->tx_buff.len >> 8, iobase+UIRCC_CR5); /* High byte */
521
522 /* Enable transmit and transmit CRC */
523 self->cr3 |= (UIRCC_CR3_XMIT_EN|UIRCC_CR3_TX_CRC_EN);
524 outb( self->cr3, iobase+UIRCC_CR3);
525 }
526
527 /*
528 * Function uircc_dma_xmit_complete (idev)
529 *
530 * The transfer of a frame in finished. This function will only be called
531 * by the interrupt handler
532 *
533 */
534 static void uircc_dma_xmit_complete( struct irda_device *idev, int underrun)
535 {
536 struct uircc_cb *self;
537 int iobase;
538 int len;
539
540 DEBUG( 4, __FUNCTION__ "()\n");
541
542 ASSERT( idev != NULL, return;);
543 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return;);
544
545 self = idev->priv;
546
547 iobase = idev->io.iobase;
548
549 /* Select TX counter */
550 outb( UIRCC_CR0_CNT_SWT, iobase+UIRCC_CR0);
551
552 /* Read TX length counter */
553 len = inb( iobase+UIRCC_SR4); /* Low byte */
554 len |= inb( iobase+UIRCC_SR5) << 8; /* High byte */
555
556 /* Disable transmit */
557 self->cr3 &= ~UIRCC_CR3_XMIT_EN;
558 outb( self->cr3, iobase+UIRCC_CR3);
559
560 /* Check for underrrun! */
561 if ( underrun) {
562 idev->stats.tx_errors++;
563 idev->stats.tx_fifo_errors++;
564 } else {
565 idev->stats.tx_packets++;
566 idev->stats.tx_bytes += idev->tx_buff.len;
567 }
568
569 /* Unlock tx_buff and request another frame */
570 idev->netdev.tbusy = 0; /* Unlock */
571 idev->media_busy = FALSE;
572
573 /* Tell the network layer, that we can accept more frames */
574 mark_bh( NET_BH);
575 }
576
577 /*
578 * Function uircc_dma_receive (idev)
579 *
580 * Get ready for receiving a frame. The device will initiate a DMA
581 * if it starts to receive a frame.
582 *
583 */
584 static int uircc_dma_receive( struct irda_device *idev)
585 {
586 struct uircc_cb *self;
587 int iobase;
588
589 ASSERT( idev != NULL, return -1;);
590 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return -1;);
591
592 DEBUG( 0, __FUNCTION__ "\n");
593
594 self = idev->priv;
595 iobase= idev->io.iobase;
596
597 /* Disable DMA */
598
599 setup_dma( idev->io.dma, idev->rx_buff.data, idev->rx_buff.truesize,
600 DMA_MODE_READ);
601
602 /* driver->media_busy = FALSE; */
603 idev->io.direction = IO_RECV;
604 idev->rx_buff.head = idev->rx_buff.data;
605 idev->rx_buff.offset = 0;
606
607 /* Enable receiving with CRC */
608 self->cr3 |= (UIRCC_CR3_RECV_EN|UIRCC_CR3_RX_CRC_EN);
609 outb( self->cr3, iobase+UIRCC_CR3);
610
611 /* Address check? */
612
613 DEBUG( 4, __FUNCTION__ "(), done!\n");
614
615 return 0;
616 }
617
618 /*
619 * Function uircc_dma_receive_complete (idev)
620 *
621 * Finished with receiving frames
622 *
623 *
624 */
625 static int uircc_dma_receive_complete( struct irda_device *idev, int iobase)
626 {
627 struct sk_buff *skb;
628 struct uircc_cb *self;
629 int len;
630
631 self = idev->priv;
632
633 DEBUG( 0, __FUNCTION__ "()\n");
634
635 /* Check for CRC or framing error */
636 if ( inb( iobase+UIRCC_SR0) & UIRCC_SR0_RX_CRCFRM) {
637 DEBUG( 0, __FUNCTION__ "(), crc or frm error\n");
638 return -1;
639 }
640
641 /* Select receive length counter */
642 outb( 0x00, iobase+UIRCC_CR0);
643
644 /* Read frame length */
645 len = inb( iobase+UIRCC_SR4); /* Low byte */
646 len |= inb( iobase+UIRCC_SR5) << 8; /* High byte */
647
648 DEBUG( 0, __FUNCTION__ "(), len=%d\n", len);
649
650 /* Receiving disable */
651 self->cr3 &= ~UIRCC_CR3_RECV_EN;
652 outb( self->cr3, iobase+UIRCC_CR3);
653
654 skb = dev_alloc_skb( len+1);
655 if (skb == NULL) {
656 printk( KERN_INFO __FUNCTION__
657 "(), memory squeeze, dropping frame.\n");
658 /* Restore bank register */
659 return FALSE;
660 }
661
662 /* Make sure IP header gets aligned */
663 skb_reserve( skb, 1);
664
665 /* Copy frame without CRC */
666 /* if ( idev->io.baudrate < 4000000) { */
667 /* skb_put( skb, len-2); */
668 /* memcpy( skb->data, idev->rx_buff.head, len-2); */
669 /* } else { */
670 /* skb_put( skb, len-4); */
671 /* memcpy( skb->data, idev->rx_buff.head, len-4); */
672 /* } */
673
674 skb_put( skb, len);
675 memcpy( skb->data, idev->rx_buff.head, len);
676 idev->stats.rx_packets++;
677
678 skb->dev = &idev->netdev;
679 skb->mac.raw = skb->data;
680 skb->protocol = htons(ETH_P_IRDA);
681 netif_rx( skb);
682
683 return TRUE;
684 }
685
686 /*
687 * Function uircc_interrupt (irq, dev_id, regs)
688 *
689 * An interrupt from the chip has arrived. Time to do some work
690 *
691 */
692 static void uircc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
693 {
694 __u8 sr3;
695 int iobase;
696
697 struct irda_device *idev = (struct irda_device *) dev_id;
698
699 if (idev == NULL) {
700 printk( KERN_WARNING "%s: irq %d for unknown device.\n",
701 driver_name, irq);
702 return;
703 }
704
705 if (idev->io.baudrate <= 115200)
706 return irport_interrupt( irq, dev_id, regs);
707
708 iobase = idev->io.iobase;
709
710 /* Read interrupt status */
711 sr3 = inb( iobase+UIRCC_SR3);
712 if (!sr3) {
713 return;
714 }
715
716 idev->netdev.interrupt = 1;
717
718 DEBUG( 4, __FUNCTION__ "(), sr3=%#x, sr2=%#x, sr10=%#x\n",
719 inb( iobase+UIRCC_SR3), inb( iobase+UIRCC_SR2),
720 inb( iobase+UIRCC_SR10));
721
722 /*
723 * Check what interrupt this is. The UIRCC will not report two
724 * different interrupts at the same time!
725 */
726 switch( sr3) {
727 case UIRCC_SR3_RX_EOF: /* Check of end of frame */
728 uircc_dma_receive_complete( idev, iobase);
729 break;
730 case UIRCC_SR3_TXUR: /* Check for transmit underrun */
731 uircc_dma_xmit_complete( idev, TRUE);
732 break;
733 case UIRCC_SR3_TX_DONE:
734 uircc_dma_xmit_complete( idev, FALSE);
735 break;
736 case UIRCC_SR3_TMR_OUT:
737 /* Disable timer */
738 outb( inb( iobase+UIRCC_CR11) & ~UIRCC_CR11_TMR_EN,
739 iobase+UIRCC_CR11);
740 break;
741 default:
742 DEBUG( 0, __FUNCTION__ "(), unknown interrupt status=%#x\n",
743 sr3);
744 break;
745 }
746
747 idev->netdev.interrupt = 0;
748 }
749
750 /*
751 * Function uircc_wait_until_sent (idev)
752 *
753 * This function should put the current thread to sleep until all data
754 * have been sent, so it is safe to change the speed.
755 */
756 static void uircc_wait_until_sent( struct irda_device *idev)
757 {
758 /* Just delay 60 ms */
759 current->state = TASK_INTERRUPTIBLE;
760 schedule_timeout(6);
761 }
762
763 /*
764 * Function uircc_is_receiving (idev)
765 *
766 * Return TRUE is we are currently receiving a frame
767 *
768 */
769 static int uircc_is_receiving( struct irda_device *idev)
770 {
771 int status = FALSE;
772 /* int iobase; */
773
774 ASSERT( idev != NULL, return FALSE;);
775 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return FALSE;);
776
777 if ( idev->io.baudrate > 115200) {
778
779 } else
780 status = ( idev->rx_buff.state != OUTSIDE_FRAME);
781
782 return status;
783 }
784
785 /*
786 * Function uircc_net_init (dev)
787 *
788 * Initialize network device
789 *
790 */
791 static int uircc_net_init( struct device *dev)
792 {
793 DEBUG( 4, __FUNCTION__ "()\n");
794
795 /* Setup to be a normal IrDA network device driver */
796 irda_device_setup( dev);
797
798 /* Insert overrides below this line! */
799
800 return 0;
801 }
802
803
804 /*
805 * Function uircc_net_open (dev)
806 *
807 * Start the device
808 *
809 */
810 static int uircc_net_open( struct device *dev)
811 {
812 struct irda_device *idev;
813 int iobase;
814
815 DEBUG( 4, __FUNCTION__ "()\n");
816
817 ASSERT( dev != NULL, return -1;);
818 idev = (struct irda_device *) dev->priv;
819
820 ASSERT( idev != NULL, return 0;);
821 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return 0;);
822
823 iobase = idev->io.iobase;
824
825 if (request_irq( idev->io.irq, uircc_interrupt, 0, idev->name,
826 (void *) idev)) {
827 return -EAGAIN;
828 }
829 /*
830 * Always allocate the DMA channel after the IRQ,
831 * and clean up on failure.
832 */
833 if (request_dma(idev->io.dma, idev->name)) {
834 free_irq( idev->io.irq, idev);
835 return -EAGAIN;
836 }
837
838 /* Ready to play! */
839 dev->tbusy = 0;
840 dev->interrupt = 0;
841 dev->start = 1;
842
843 /* turn on interrupts */
844
845 MOD_INC_USE_COUNT;
846
847 return 0;
848 }
849
850 /*
851 * Function uircc_net_close (dev)
852 *
853 * Stop the device
854 *
855 */
856 static int uircc_net_close(struct device *dev)
857 {
858 struct irda_device *idev;
859 int iobase;
860
861 DEBUG( 4, __FUNCTION__ "()\n");
862
863 /* Stop device */
864 dev->tbusy = 1;
865 dev->start = 0;
866
867 ASSERT( dev != NULL, return -1;);
868 idev = (struct irda_device *) dev->priv;
869
870 ASSERT( idev != NULL, return 0;);
871 ASSERT( idev->magic == IRDA_DEVICE_MAGIC, return 0;);
872
873 iobase = idev->io.iobase;
874
875 disable_dma( idev->io.dma);
876
877 /* Disable interrupts */
878
879 free_irq( idev->io.irq, idev);
880 free_dma( idev->io.dma);
881
882 MOD_DEC_USE_COUNT;
883
884 return 0;
885 }
886
887 #ifdef MODULE
888
889 /*
890 * Function init_module (void)
891 *
892 *
893 *
894 */
895 int init_module(void)
896 {
897 uircc_init();
898
899 return(0);
900 }
901
902 /*
903 * Function cleanup_module (void)
904 *
905 *
906 *
907 */
908 void cleanup_module(void)
909 {
910 uircc_cleanup();
911 }
912
913 #endif
914
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux