ali-ircc.c revision c31f28e778ab299a5035ea2bda64f245b8915d7c
1/********************************************************************* 2 * 3 * Filename: ali-ircc.h 4 * Version: 0.5 5 * Description: Driver for the ALI M1535D and M1543C FIR Controller 6 * Status: Experimental. 7 * Author: Benjamin Kong <benjamin_kong@ali.com.tw> 8 * Created at: 2000/10/16 03:46PM 9 * Modified at: 2001/1/3 02:55PM 10 * Modified by: Benjamin Kong <benjamin_kong@ali.com.tw> 11 * Modified at: 2003/11/6 and support for ALi south-bridge chipsets M1563 12 * Modified by: Clear Zhang <clear_zhang@ali.com.tw> 13 * 14 * Copyright (c) 2000 Benjamin Kong <benjamin_kong@ali.com.tw> 15 * All Rights Reserved 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License as 19 * published by the Free Software Foundation; either version 2 of 20 * the License, or (at your option) any later version. 21 * 22 ********************************************************************/ 23 24#include <linux/module.h> 25 26#include <linux/kernel.h> 27#include <linux/types.h> 28#include <linux/skbuff.h> 29#include <linux/netdevice.h> 30#include <linux/ioport.h> 31#include <linux/delay.h> 32#include <linux/slab.h> 33#include <linux/init.h> 34#include <linux/rtnetlink.h> 35#include <linux/serial_reg.h> 36#include <linux/dma-mapping.h> 37#include <linux/platform_device.h> 38 39#include <asm/io.h> 40#include <asm/dma.h> 41#include <asm/byteorder.h> 42 43#include <net/irda/wrapper.h> 44#include <net/irda/irda.h> 45#include <net/irda/irda_device.h> 46 47#include "ali-ircc.h" 48 49#define CHIP_IO_EXTENT 8 50#define BROKEN_DONGLE_ID 51 52#define ALI_IRCC_DRIVER_NAME "ali-ircc" 53 54/* Power Management */ 55static int ali_ircc_suspend(struct platform_device *dev, pm_message_t state); 56static int ali_ircc_resume(struct platform_device *dev); 57 58static struct platform_driver ali_ircc_driver = { 59 .suspend = ali_ircc_suspend, 60 .resume = ali_ircc_resume, 61 .driver = { 62 .name = ALI_IRCC_DRIVER_NAME, 63 }, 64}; 65 66/* Module parameters */ 67static int qos_mtt_bits = 0x07; /* 1 ms or more */ 68 69/* Use BIOS settions by default, but user may supply module parameters */ 70static unsigned int io[] = { ~0, ~0, ~0, ~0 }; 71static unsigned int irq[] = { 0, 0, 0, 0 }; 72static unsigned int dma[] = { 0, 0, 0, 0 }; 73 74static int ali_ircc_probe_53(ali_chip_t *chip, chipio_t *info); 75static int ali_ircc_init_43(ali_chip_t *chip, chipio_t *info); 76static int ali_ircc_init_53(ali_chip_t *chip, chipio_t *info); 77 78/* These are the currently known ALi sourth-bridge chipsets, the only one difference 79 * is that M1543C doesn't support HP HDSL-3600 80 */ 81static ali_chip_t chips[] = 82{ 83 { "M1543", { 0x3f0, 0x370 }, 0x51, 0x23, 0x20, 0x43, ali_ircc_probe_53, ali_ircc_init_43 }, 84 { "M1535", { 0x3f0, 0x370 }, 0x51, 0x23, 0x20, 0x53, ali_ircc_probe_53, ali_ircc_init_53 }, 85 { "M1563", { 0x3f0, 0x370 }, 0x51, 0x23, 0x20, 0x63, ali_ircc_probe_53, ali_ircc_init_53 }, 86 { NULL } 87}; 88 89/* Max 4 instances for now */ 90static struct ali_ircc_cb *dev_self[] = { NULL, NULL, NULL, NULL }; 91 92/* Dongle Types */ 93static char *dongle_types[] = { 94 "TFDS6000", 95 "HP HSDL-3600", 96 "HP HSDL-1100", 97 "No dongle connected", 98}; 99 100/* Some prototypes */ 101static int ali_ircc_open(int i, chipio_t *info); 102 103static int ali_ircc_close(struct ali_ircc_cb *self); 104 105static int ali_ircc_setup(chipio_t *info); 106static int ali_ircc_is_receiving(struct ali_ircc_cb *self); 107static int ali_ircc_net_open(struct net_device *dev); 108static int ali_ircc_net_close(struct net_device *dev); 109static int ali_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 110static void ali_ircc_change_speed(struct ali_ircc_cb *self, __u32 baud); 111static struct net_device_stats *ali_ircc_net_get_stats(struct net_device *dev); 112 113/* SIR function */ 114static int ali_ircc_sir_hard_xmit(struct sk_buff *skb, struct net_device *dev); 115static irqreturn_t ali_ircc_sir_interrupt(struct ali_ircc_cb *self); 116static void ali_ircc_sir_receive(struct ali_ircc_cb *self); 117static void ali_ircc_sir_write_wakeup(struct ali_ircc_cb *self); 118static int ali_ircc_sir_write(int iobase, int fifo_size, __u8 *buf, int len); 119static void ali_ircc_sir_change_speed(struct ali_ircc_cb *priv, __u32 speed); 120 121/* FIR function */ 122static int ali_ircc_fir_hard_xmit(struct sk_buff *skb, struct net_device *dev); 123static void ali_ircc_fir_change_speed(struct ali_ircc_cb *priv, __u32 speed); 124static irqreturn_t ali_ircc_fir_interrupt(struct ali_ircc_cb *self); 125static int ali_ircc_dma_receive(struct ali_ircc_cb *self); 126static int ali_ircc_dma_receive_complete(struct ali_ircc_cb *self); 127static int ali_ircc_dma_xmit_complete(struct ali_ircc_cb *self); 128static void ali_ircc_dma_xmit(struct ali_ircc_cb *self); 129 130/* My Function */ 131static int ali_ircc_read_dongle_id (int i, chipio_t *info); 132static void ali_ircc_change_dongle_speed(struct ali_ircc_cb *priv, int speed); 133 134/* ALi chip function */ 135static void SIR2FIR(int iobase); 136static void FIR2SIR(int iobase); 137static void SetCOMInterrupts(struct ali_ircc_cb *self , unsigned char enable); 138 139/* 140 * Function ali_ircc_init () 141 * 142 * Initialize chip. Find out whay kinds of chips we are dealing with 143 * and their configuation registers address 144 */ 145static int __init ali_ircc_init(void) 146{ 147 ali_chip_t *chip; 148 chipio_t info; 149 int ret; 150 int cfg, cfg_base; 151 int reg, revision; 152 int i = 0; 153 154 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 155 156 ret = platform_driver_register(&ali_ircc_driver); 157 if (ret) { 158 IRDA_ERROR("%s, Can't register driver!\n", 159 ALI_IRCC_DRIVER_NAME); 160 return ret; 161 } 162 163 ret = -ENODEV; 164 165 /* Probe for all the ALi chipsets we know about */ 166 for (chip= chips; chip->name; chip++, i++) 167 { 168 IRDA_DEBUG(2, "%s(), Probing for %s ...\n", __FUNCTION__, chip->name); 169 170 /* Try all config registers for this chip */ 171 for (cfg=0; cfg<2; cfg++) 172 { 173 cfg_base = chip->cfg[cfg]; 174 if (!cfg_base) 175 continue; 176 177 memset(&info, 0, sizeof(chipio_t)); 178 info.cfg_base = cfg_base; 179 info.fir_base = io[i]; 180 info.dma = dma[i]; 181 info.irq = irq[i]; 182 183 184 /* Enter Configuration */ 185 outb(chip->entr1, cfg_base); 186 outb(chip->entr2, cfg_base); 187 188 /* Select Logical Device 5 Registers (UART2) */ 189 outb(0x07, cfg_base); 190 outb(0x05, cfg_base+1); 191 192 /* Read Chip Identification Register */ 193 outb(chip->cid_index, cfg_base); 194 reg = inb(cfg_base+1); 195 196 if (reg == chip->cid_value) 197 { 198 IRDA_DEBUG(2, "%s(), Chip found at 0x%03x\n", __FUNCTION__, cfg_base); 199 200 outb(0x1F, cfg_base); 201 revision = inb(cfg_base+1); 202 IRDA_DEBUG(2, "%s(), Found %s chip, revision=%d\n", __FUNCTION__, 203 chip->name, revision); 204 205 /* 206 * If the user supplies the base address, then 207 * we init the chip, if not we probe the values 208 * set by the BIOS 209 */ 210 if (io[i] < 2000) 211 { 212 chip->init(chip, &info); 213 } 214 else 215 { 216 chip->probe(chip, &info); 217 } 218 219 if (ali_ircc_open(i, &info) == 0) 220 ret = 0; 221 i++; 222 } 223 else 224 { 225 IRDA_DEBUG(2, "%s(), No %s chip at 0x%03x\n", __FUNCTION__, chip->name, cfg_base); 226 } 227 /* Exit configuration */ 228 outb(0xbb, cfg_base); 229 } 230 } 231 232 IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); 233 234 if (ret) 235 platform_driver_unregister(&ali_ircc_driver); 236 237 return ret; 238} 239 240/* 241 * Function ali_ircc_cleanup () 242 * 243 * Close all configured chips 244 * 245 */ 246static void __exit ali_ircc_cleanup(void) 247{ 248 int i; 249 250 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 251 252 for (i=0; i < ARRAY_SIZE(dev_self); i++) { 253 if (dev_self[i]) 254 ali_ircc_close(dev_self[i]); 255 } 256 257 platform_driver_unregister(&ali_ircc_driver); 258 259 IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); 260} 261 262/* 263 * Function ali_ircc_open (int i, chipio_t *inf) 264 * 265 * Open driver instance 266 * 267 */ 268static int ali_ircc_open(int i, chipio_t *info) 269{ 270 struct net_device *dev; 271 struct ali_ircc_cb *self; 272 int dongle_id; 273 int err; 274 275 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 276 277 if (i >= ARRAY_SIZE(dev_self)) { 278 IRDA_ERROR("%s(), maximum number of supported chips reached!\n", 279 __FUNCTION__); 280 return -ENOMEM; 281 } 282 283 /* Set FIR FIFO and DMA Threshold */ 284 if ((ali_ircc_setup(info)) == -1) 285 return -1; 286 287 dev = alloc_irdadev(sizeof(*self)); 288 if (dev == NULL) { 289 IRDA_ERROR("%s(), can't allocate memory for control block!\n", 290 __FUNCTION__); 291 return -ENOMEM; 292 } 293 294 self = dev->priv; 295 self->netdev = dev; 296 spin_lock_init(&self->lock); 297 298 /* Need to store self somewhere */ 299 dev_self[i] = self; 300 self->index = i; 301 302 /* Initialize IO */ 303 self->io.cfg_base = info->cfg_base; /* In ali_ircc_probe_53 assign */ 304 self->io.fir_base = info->fir_base; /* info->sir_base = info->fir_base */ 305 self->io.sir_base = info->sir_base; /* ALi SIR and FIR use the same address */ 306 self->io.irq = info->irq; 307 self->io.fir_ext = CHIP_IO_EXTENT; 308 self->io.dma = info->dma; 309 self->io.fifo_size = 16; /* SIR: 16, FIR: 32 Benjamin 2000/11/1 */ 310 311 /* Reserve the ioports that we need */ 312 if (!request_region(self->io.fir_base, self->io.fir_ext, 313 ALI_IRCC_DRIVER_NAME)) { 314 IRDA_WARNING("%s(), can't get iobase of 0x%03x\n", __FUNCTION__, 315 self->io.fir_base); 316 err = -ENODEV; 317 goto err_out1; 318 } 319 320 /* Initialize QoS for this device */ 321 irda_init_max_qos_capabilies(&self->qos); 322 323 /* The only value we must override it the baudrate */ 324 self->qos.baud_rate.bits = IR_9600|IR_19200|IR_38400|IR_57600| 325 IR_115200|IR_576000|IR_1152000|(IR_4000000 << 8); // benjamin 2000/11/8 05:27PM 326 327 self->qos.min_turn_time.bits = qos_mtt_bits; 328 329 irda_qos_bits_to_value(&self->qos); 330 331 /* Max DMA buffer size needed = (data_size + 6) * (window_size) + 6; */ 332 self->rx_buff.truesize = 14384; 333 self->tx_buff.truesize = 14384; 334 335 /* Allocate memory if needed */ 336 self->rx_buff.head = 337 dma_alloc_coherent(NULL, self->rx_buff.truesize, 338 &self->rx_buff_dma, GFP_KERNEL); 339 if (self->rx_buff.head == NULL) { 340 err = -ENOMEM; 341 goto err_out2; 342 } 343 memset(self->rx_buff.head, 0, self->rx_buff.truesize); 344 345 self->tx_buff.head = 346 dma_alloc_coherent(NULL, self->tx_buff.truesize, 347 &self->tx_buff_dma, GFP_KERNEL); 348 if (self->tx_buff.head == NULL) { 349 err = -ENOMEM; 350 goto err_out3; 351 } 352 memset(self->tx_buff.head, 0, self->tx_buff.truesize); 353 354 self->rx_buff.in_frame = FALSE; 355 self->rx_buff.state = OUTSIDE_FRAME; 356 self->tx_buff.data = self->tx_buff.head; 357 self->rx_buff.data = self->rx_buff.head; 358 359 /* Reset Tx queue info */ 360 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; 361 self->tx_fifo.tail = self->tx_buff.head; 362 363 364 /* Keep track of module usage */ 365 SET_MODULE_OWNER(dev); 366 367 /* Override the network functions we need to use */ 368 dev->hard_start_xmit = ali_ircc_sir_hard_xmit; 369 dev->open = ali_ircc_net_open; 370 dev->stop = ali_ircc_net_close; 371 dev->do_ioctl = ali_ircc_net_ioctl; 372 dev->get_stats = ali_ircc_net_get_stats; 373 374 err = register_netdev(dev); 375 if (err) { 376 IRDA_ERROR("%s(), register_netdev() failed!\n", __FUNCTION__); 377 goto err_out4; 378 } 379 IRDA_MESSAGE("IrDA: Registered device %s\n", dev->name); 380 381 /* Check dongle id */ 382 dongle_id = ali_ircc_read_dongle_id(i, info); 383 IRDA_MESSAGE("%s(), %s, Found dongle: %s\n", __FUNCTION__, 384 ALI_IRCC_DRIVER_NAME, dongle_types[dongle_id]); 385 386 self->io.dongle_id = dongle_id; 387 388 IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); 389 390 return 0; 391 392 err_out4: 393 dma_free_coherent(NULL, self->tx_buff.truesize, 394 self->tx_buff.head, self->tx_buff_dma); 395 err_out3: 396 dma_free_coherent(NULL, self->rx_buff.truesize, 397 self->rx_buff.head, self->rx_buff_dma); 398 err_out2: 399 release_region(self->io.fir_base, self->io.fir_ext); 400 err_out1: 401 dev_self[i] = NULL; 402 free_netdev(dev); 403 return err; 404} 405 406 407/* 408 * Function ali_ircc_close (self) 409 * 410 * Close driver instance 411 * 412 */ 413static int __exit ali_ircc_close(struct ali_ircc_cb *self) 414{ 415 int iobase; 416 417 IRDA_DEBUG(4, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 418 419 IRDA_ASSERT(self != NULL, return -1;); 420 421 iobase = self->io.fir_base; 422 423 /* Remove netdevice */ 424 unregister_netdev(self->netdev); 425 426 /* Release the PORT that this driver is using */ 427 IRDA_DEBUG(4, "%s(), Releasing Region %03x\n", __FUNCTION__, self->io.fir_base); 428 release_region(self->io.fir_base, self->io.fir_ext); 429 430 if (self->tx_buff.head) 431 dma_free_coherent(NULL, self->tx_buff.truesize, 432 self->tx_buff.head, self->tx_buff_dma); 433 434 if (self->rx_buff.head) 435 dma_free_coherent(NULL, self->rx_buff.truesize, 436 self->rx_buff.head, self->rx_buff_dma); 437 438 dev_self[self->index] = NULL; 439 free_netdev(self->netdev); 440 441 IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); 442 443 return 0; 444} 445 446/* 447 * Function ali_ircc_init_43 (chip, info) 448 * 449 * Initialize the ALi M1543 chip. 450 */ 451static int ali_ircc_init_43(ali_chip_t *chip, chipio_t *info) 452{ 453 /* All controller information like I/O address, DMA channel, IRQ 454 * are set by BIOS 455 */ 456 457 return 0; 458} 459 460/* 461 * Function ali_ircc_init_53 (chip, info) 462 * 463 * Initialize the ALi M1535 chip. 464 */ 465static int ali_ircc_init_53(ali_chip_t *chip, chipio_t *info) 466{ 467 /* All controller information like I/O address, DMA channel, IRQ 468 * are set by BIOS 469 */ 470 471 return 0; 472} 473 474/* 475 * Function ali_ircc_probe_53 (chip, info) 476 * 477 * Probes for the ALi M1535D or M1535 478 */ 479static int ali_ircc_probe_53(ali_chip_t *chip, chipio_t *info) 480{ 481 int cfg_base = info->cfg_base; 482 int hi, low, reg; 483 484 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 485 486 /* Enter Configuration */ 487 outb(chip->entr1, cfg_base); 488 outb(chip->entr2, cfg_base); 489 490 /* Select Logical Device 5 Registers (UART2) */ 491 outb(0x07, cfg_base); 492 outb(0x05, cfg_base+1); 493 494 /* Read address control register */ 495 outb(0x60, cfg_base); 496 hi = inb(cfg_base+1); 497 outb(0x61, cfg_base); 498 low = inb(cfg_base+1); 499 info->fir_base = (hi<<8) + low; 500 501 info->sir_base = info->fir_base; 502 503 IRDA_DEBUG(2, "%s(), probing fir_base=0x%03x\n", __FUNCTION__, info->fir_base); 504 505 /* Read IRQ control register */ 506 outb(0x70, cfg_base); 507 reg = inb(cfg_base+1); 508 info->irq = reg & 0x0f; 509 IRDA_DEBUG(2, "%s(), probing irq=%d\n", __FUNCTION__, info->irq); 510 511 /* Read DMA channel */ 512 outb(0x74, cfg_base); 513 reg = inb(cfg_base+1); 514 info->dma = reg & 0x07; 515 516 if(info->dma == 0x04) 517 IRDA_WARNING("%s(), No DMA channel assigned !\n", __FUNCTION__); 518 else 519 IRDA_DEBUG(2, "%s(), probing dma=%d\n", __FUNCTION__, info->dma); 520 521 /* Read Enabled Status */ 522 outb(0x30, cfg_base); 523 reg = inb(cfg_base+1); 524 info->enabled = (reg & 0x80) && (reg & 0x01); 525 IRDA_DEBUG(2, "%s(), probing enabled=%d\n", __FUNCTION__, info->enabled); 526 527 /* Read Power Status */ 528 outb(0x22, cfg_base); 529 reg = inb(cfg_base+1); 530 info->suspended = (reg & 0x20); 531 IRDA_DEBUG(2, "%s(), probing suspended=%d\n", __FUNCTION__, info->suspended); 532 533 /* Exit configuration */ 534 outb(0xbb, cfg_base); 535 536 IRDA_DEBUG(2, "%s(), ----------------- End -----------------\n", __FUNCTION__); 537 538 return 0; 539} 540 541/* 542 * Function ali_ircc_setup (info) 543 * 544 * Set FIR FIFO and DMA Threshold 545 * Returns non-negative on success. 546 * 547 */ 548static int ali_ircc_setup(chipio_t *info) 549{ 550 unsigned char tmp; 551 int version; 552 int iobase = info->fir_base; 553 554 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 555 556 /* Locking comments : 557 * Most operations here need to be protected. We are called before 558 * the device instance is created in ali_ircc_open(), therefore 559 * nobody can bother us - Jean II */ 560 561 /* Switch to FIR space */ 562 SIR2FIR(iobase); 563 564 /* Master Reset */ 565 outb(0x40, iobase+FIR_MCR); // benjamin 2000/11/30 11:45AM 566 567 /* Read FIR ID Version Register */ 568 switch_bank(iobase, BANK3); 569 version = inb(iobase+FIR_ID_VR); 570 571 /* Should be 0x00 in the M1535/M1535D */ 572 if(version != 0x00) 573 { 574 IRDA_ERROR("%s, Wrong chip version %02x\n", 575 ALI_IRCC_DRIVER_NAME, version); 576 return -1; 577 } 578 579 /* Set FIR FIFO Threshold Register */ 580 switch_bank(iobase, BANK1); 581 outb(RX_FIFO_Threshold, iobase+FIR_FIFO_TR); 582 583 /* Set FIR DMA Threshold Register */ 584 outb(RX_DMA_Threshold, iobase+FIR_DMA_TR); 585 586 /* CRC enable */ 587 switch_bank(iobase, BANK2); 588 outb(inb(iobase+FIR_IRDA_CR) | IRDA_CR_CRC, iobase+FIR_IRDA_CR); 589 590 /* NDIS driver set TX Length here BANK2 Alias 3, Alias4*/ 591 592 /* Switch to Bank 0 */ 593 switch_bank(iobase, BANK0); 594 595 tmp = inb(iobase+FIR_LCR_B); 596 tmp &=~0x20; // disable SIP 597 tmp |= 0x80; // these two steps make RX mode 598 tmp &= 0xbf; 599 outb(tmp, iobase+FIR_LCR_B); 600 601 /* Disable Interrupt */ 602 outb(0x00, iobase+FIR_IER); 603 604 605 /* Switch to SIR space */ 606 FIR2SIR(iobase); 607 608 IRDA_MESSAGE("%s, driver loaded (Benjamin Kong)\n", 609 ALI_IRCC_DRIVER_NAME); 610 611 /* Enable receive interrupts */ 612 // outb(UART_IER_RDI, iobase+UART_IER); //benjamin 2000/11/23 01:25PM 613 // Turn on the interrupts in ali_ircc_net_open 614 615 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__); 616 617 return 0; 618} 619 620/* 621 * Function ali_ircc_read_dongle_id (int index, info) 622 * 623 * Try to read dongle indentification. This procedure needs to be executed 624 * once after power-on/reset. It also needs to be used whenever you suspect 625 * that the user may have plugged/unplugged the IrDA Dongle. 626 */ 627static int ali_ircc_read_dongle_id (int i, chipio_t *info) 628{ 629 int dongle_id, reg; 630 int cfg_base = info->cfg_base; 631 632 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 633 634 /* Enter Configuration */ 635 outb(chips[i].entr1, cfg_base); 636 outb(chips[i].entr2, cfg_base); 637 638 /* Select Logical Device 5 Registers (UART2) */ 639 outb(0x07, cfg_base); 640 outb(0x05, cfg_base+1); 641 642 /* Read Dongle ID */ 643 outb(0xf0, cfg_base); 644 reg = inb(cfg_base+1); 645 dongle_id = ((reg>>6)&0x02) | ((reg>>5)&0x01); 646 IRDA_DEBUG(2, "%s(), probing dongle_id=%d, dongle_types=%s\n", __FUNCTION__, 647 dongle_id, dongle_types[dongle_id]); 648 649 /* Exit configuration */ 650 outb(0xbb, cfg_base); 651 652 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__); 653 654 return dongle_id; 655} 656 657/* 658 * Function ali_ircc_interrupt (irq, dev_id, regs) 659 * 660 * An interrupt from the chip has arrived. Time to do some work 661 * 662 */ 663static irqreturn_t ali_ircc_interrupt(int irq, void *dev_id) 664{ 665 struct net_device *dev = dev_id; 666 struct ali_ircc_cb *self; 667 int ret; 668 669 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 670 671 self = dev->priv; 672 673 spin_lock(&self->lock); 674 675 /* Dispatch interrupt handler for the current speed */ 676 if (self->io.speed > 115200) 677 ret = ali_ircc_fir_interrupt(self); 678 else 679 ret = ali_ircc_sir_interrupt(self); 680 681 spin_unlock(&self->lock); 682 683 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__); 684 return ret; 685} 686/* 687 * Function ali_ircc_fir_interrupt(irq, struct ali_ircc_cb *self) 688 * 689 * Handle MIR/FIR interrupt 690 * 691 */ 692static irqreturn_t ali_ircc_fir_interrupt(struct ali_ircc_cb *self) 693{ 694 __u8 eir, OldMessageCount; 695 int iobase, tmp; 696 697 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 698 699 iobase = self->io.fir_base; 700 701 switch_bank(iobase, BANK0); 702 self->InterruptID = inb(iobase+FIR_IIR); 703 self->BusStatus = inb(iobase+FIR_BSR); 704 705 OldMessageCount = (self->LineStatus + 1) & 0x07; 706 self->LineStatus = inb(iobase+FIR_LSR); 707 //self->ier = inb(iobase+FIR_IER); 2000/12/1 04:32PM 708 eir = self->InterruptID & self->ier; /* Mask out the interesting ones */ 709 710 IRDA_DEBUG(1, "%s(), self->InterruptID = %x\n", __FUNCTION__,self->InterruptID); 711 IRDA_DEBUG(1, "%s(), self->LineStatus = %x\n", __FUNCTION__,self->LineStatus); 712 IRDA_DEBUG(1, "%s(), self->ier = %x\n", __FUNCTION__,self->ier); 713 IRDA_DEBUG(1, "%s(), eir = %x\n", __FUNCTION__,eir); 714 715 /* Disable interrupts */ 716 SetCOMInterrupts(self, FALSE); 717 718 /* Tx or Rx Interrupt */ 719 720 if (eir & IIR_EOM) 721 { 722 if (self->io.direction == IO_XMIT) /* TX */ 723 { 724 IRDA_DEBUG(1, "%s(), ******* IIR_EOM (Tx) *******\n", __FUNCTION__); 725 726 if(ali_ircc_dma_xmit_complete(self)) 727 { 728 if (irda_device_txqueue_empty(self->netdev)) 729 { 730 /* Prepare for receive */ 731 ali_ircc_dma_receive(self); 732 self->ier = IER_EOM; 733 } 734 } 735 else 736 { 737 self->ier = IER_EOM; 738 } 739 740 } 741 else /* RX */ 742 { 743 IRDA_DEBUG(1, "%s(), ******* IIR_EOM (Rx) *******\n", __FUNCTION__); 744 745 if(OldMessageCount > ((self->LineStatus+1) & 0x07)) 746 { 747 self->rcvFramesOverflow = TRUE; 748 IRDA_DEBUG(1, "%s(), ******* self->rcvFramesOverflow = TRUE ******** \n", __FUNCTION__); 749 } 750 751 if (ali_ircc_dma_receive_complete(self)) 752 { 753 IRDA_DEBUG(1, "%s(), ******* receive complete ******** \n", __FUNCTION__); 754 755 self->ier = IER_EOM; 756 } 757 else 758 { 759 IRDA_DEBUG(1, "%s(), ******* Not receive complete ******** \n", __FUNCTION__); 760 761 self->ier = IER_EOM | IER_TIMER; 762 } 763 764 } 765 } 766 /* Timer Interrupt */ 767 else if (eir & IIR_TIMER) 768 { 769 if(OldMessageCount > ((self->LineStatus+1) & 0x07)) 770 { 771 self->rcvFramesOverflow = TRUE; 772 IRDA_DEBUG(1, "%s(), ******* self->rcvFramesOverflow = TRUE ******* \n", __FUNCTION__); 773 } 774 /* Disable Timer */ 775 switch_bank(iobase, BANK1); 776 tmp = inb(iobase+FIR_CR); 777 outb( tmp& ~CR_TIMER_EN, iobase+FIR_CR); 778 779 /* Check if this is a Tx timer interrupt */ 780 if (self->io.direction == IO_XMIT) 781 { 782 ali_ircc_dma_xmit(self); 783 784 /* Interrupt on EOM */ 785 self->ier = IER_EOM; 786 787 } 788 else /* Rx */ 789 { 790 if(ali_ircc_dma_receive_complete(self)) 791 { 792 self->ier = IER_EOM; 793 } 794 else 795 { 796 self->ier = IER_EOM | IER_TIMER; 797 } 798 } 799 } 800 801 /* Restore Interrupt */ 802 SetCOMInterrupts(self, TRUE); 803 804 IRDA_DEBUG(1, "%s(), ----------------- End ---------------\n", __FUNCTION__); 805 return IRQ_RETVAL(eir); 806} 807 808/* 809 * Function ali_ircc_sir_interrupt (irq, self, eir) 810 * 811 * Handle SIR interrupt 812 * 813 */ 814static irqreturn_t ali_ircc_sir_interrupt(struct ali_ircc_cb *self) 815{ 816 int iobase; 817 int iir, lsr; 818 819 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 820 821 iobase = self->io.sir_base; 822 823 iir = inb(iobase+UART_IIR) & UART_IIR_ID; 824 if (iir) { 825 /* Clear interrupt */ 826 lsr = inb(iobase+UART_LSR); 827 828 IRDA_DEBUG(4, "%s(), iir=%02x, lsr=%02x, iobase=%#x\n", __FUNCTION__, 829 iir, lsr, iobase); 830 831 switch (iir) 832 { 833 case UART_IIR_RLSI: 834 IRDA_DEBUG(2, "%s(), RLSI\n", __FUNCTION__); 835 break; 836 case UART_IIR_RDI: 837 /* Receive interrupt */ 838 ali_ircc_sir_receive(self); 839 break; 840 case UART_IIR_THRI: 841 if (lsr & UART_LSR_THRE) 842 { 843 /* Transmitter ready for data */ 844 ali_ircc_sir_write_wakeup(self); 845 } 846 break; 847 default: 848 IRDA_DEBUG(0, "%s(), unhandled IIR=%#x\n", __FUNCTION__, iir); 849 break; 850 } 851 852 } 853 854 855 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__); 856 857 return IRQ_RETVAL(iir); 858} 859 860 861/* 862 * Function ali_ircc_sir_receive (self) 863 * 864 * Receive one frame from the infrared port 865 * 866 */ 867static void ali_ircc_sir_receive(struct ali_ircc_cb *self) 868{ 869 int boguscount = 0; 870 int iobase; 871 872 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__); 873 IRDA_ASSERT(self != NULL, return;); 874 875 iobase = self->io.sir_base; 876 877 /* 878 * Receive all characters in Rx FIFO, unwrap and unstuff them. 879 * async_unwrap_char will deliver all found frames 880 */ 881 do { 882 async_unwrap_char(self->netdev, &self->stats, &self->rx_buff, 883 inb(iobase+UART_RX)); 884 885 /* Make sure we don't stay here too long */ 886 if (boguscount++ > 32) { 887 IRDA_DEBUG(2,"%s(), breaking!\n", __FUNCTION__); 888 break; 889 } 890 } while (inb(iobase+UART_LSR) & UART_LSR_DR); 891 892 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 893} 894 895/* 896 * Function ali_ircc_sir_write_wakeup (tty) 897 * 898 * Called by the driver when there's room for more data. If we have 899 * more packets to send, we send them here. 900 * 901 */ 902static void ali_ircc_sir_write_wakeup(struct ali_ircc_cb *self) 903{ 904 int actual = 0; 905 int iobase; 906 907 IRDA_ASSERT(self != NULL, return;); 908 909 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 910 911 iobase = self->io.sir_base; 912 913 /* Finished with frame? */ 914 if (self->tx_buff.len > 0) 915 { 916 /* Write data left in transmit buffer */ 917 actual = ali_ircc_sir_write(iobase, self->io.fifo_size, 918 self->tx_buff.data, self->tx_buff.len); 919 self->tx_buff.data += actual; 920 self->tx_buff.len -= actual; 921 } 922 else 923 { 924 if (self->new_speed) 925 { 926 /* We must wait until all data are gone */ 927 while(!(inb(iobase+UART_LSR) & UART_LSR_TEMT)) 928 IRDA_DEBUG(1, "%s(), UART_LSR_THRE\n", __FUNCTION__ ); 929 930 IRDA_DEBUG(1, "%s(), Changing speed! self->new_speed = %d\n", __FUNCTION__ , self->new_speed); 931 ali_ircc_change_speed(self, self->new_speed); 932 self->new_speed = 0; 933 934 // benjamin 2000/11/10 06:32PM 935 if (self->io.speed > 115200) 936 { 937 IRDA_DEBUG(2, "%s(), ali_ircc_change_speed from UART_LSR_TEMT \n", __FUNCTION__ ); 938 939 self->ier = IER_EOM; 940 // SetCOMInterrupts(self, TRUE); 941 return; 942 } 943 } 944 else 945 { 946 netif_wake_queue(self->netdev); 947 } 948 949 self->stats.tx_packets++; 950 951 /* Turn on receive interrupts */ 952 outb(UART_IER_RDI, iobase+UART_IER); 953 } 954 955 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 956} 957 958static void ali_ircc_change_speed(struct ali_ircc_cb *self, __u32 baud) 959{ 960 struct net_device *dev = self->netdev; 961 int iobase; 962 963 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 964 965 IRDA_DEBUG(2, "%s(), setting speed = %d \n", __FUNCTION__ , baud); 966 967 /* This function *must* be called with irq off and spin-lock. 968 * - Jean II */ 969 970 iobase = self->io.fir_base; 971 972 SetCOMInterrupts(self, FALSE); // 2000/11/24 11:43AM 973 974 /* Go to MIR, FIR Speed */ 975 if (baud > 115200) 976 { 977 978 979 ali_ircc_fir_change_speed(self, baud); 980 981 /* Install FIR xmit handler*/ 982 dev->hard_start_xmit = ali_ircc_fir_hard_xmit; 983 984 /* Enable Interuupt */ 985 self->ier = IER_EOM; // benjamin 2000/11/20 07:24PM 986 987 /* Be ready for incomming frames */ 988 ali_ircc_dma_receive(self); // benajmin 2000/11/8 07:46PM not complete 989 } 990 /* Go to SIR Speed */ 991 else 992 { 993 ali_ircc_sir_change_speed(self, baud); 994 995 /* Install SIR xmit handler*/ 996 dev->hard_start_xmit = ali_ircc_sir_hard_xmit; 997 } 998 999 1000 SetCOMInterrupts(self, TRUE); // 2000/11/24 11:43AM 1001 1002 netif_wake_queue(self->netdev); 1003 1004 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1005} 1006 1007static void ali_ircc_fir_change_speed(struct ali_ircc_cb *priv, __u32 baud) 1008{ 1009 1010 int iobase; 1011 struct ali_ircc_cb *self = (struct ali_ircc_cb *) priv; 1012 struct net_device *dev; 1013 1014 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1015 1016 IRDA_ASSERT(self != NULL, return;); 1017 1018 dev = self->netdev; 1019 iobase = self->io.fir_base; 1020 1021 IRDA_DEBUG(1, "%s(), self->io.speed = %d, change to speed = %d\n", __FUNCTION__ ,self->io.speed,baud); 1022 1023 /* Come from SIR speed */ 1024 if(self->io.speed <=115200) 1025 { 1026 SIR2FIR(iobase); 1027 } 1028 1029 /* Update accounting for new speed */ 1030 self->io.speed = baud; 1031 1032 // Set Dongle Speed mode 1033 ali_ircc_change_dongle_speed(self, baud); 1034 1035 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1036} 1037 1038/* 1039 * Function ali_sir_change_speed (self, speed) 1040 * 1041 * Set speed of IrDA port to specified baudrate 1042 * 1043 */ 1044static void ali_ircc_sir_change_speed(struct ali_ircc_cb *priv, __u32 speed) 1045{ 1046 struct ali_ircc_cb *self = (struct ali_ircc_cb *) priv; 1047 unsigned long flags; 1048 int iobase; 1049 int fcr; /* FIFO control reg */ 1050 int lcr; /* Line control reg */ 1051 int divisor; 1052 1053 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1054 1055 IRDA_DEBUG(1, "%s(), Setting speed to: %d\n", __FUNCTION__ , speed); 1056 1057 IRDA_ASSERT(self != NULL, return;); 1058 1059 iobase = self->io.sir_base; 1060 1061 /* Come from MIR or FIR speed */ 1062 if(self->io.speed >115200) 1063 { 1064 // Set Dongle Speed mode first 1065 ali_ircc_change_dongle_speed(self, speed); 1066 1067 FIR2SIR(iobase); 1068 } 1069 1070 // Clear Line and Auxiluary status registers 2000/11/24 11:47AM 1071 1072 inb(iobase+UART_LSR); 1073 inb(iobase+UART_SCR); 1074 1075 /* Update accounting for new speed */ 1076 self->io.speed = speed; 1077 1078 spin_lock_irqsave(&self->lock, flags); 1079 1080 divisor = 115200/speed; 1081 1082 fcr = UART_FCR_ENABLE_FIFO; 1083 1084 /* 1085 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and 1086 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget 1087 * about this timeout since it will always be fast enough. 1088 */ 1089 if (self->io.speed < 38400) 1090 fcr |= UART_FCR_TRIGGER_1; 1091 else 1092 fcr |= UART_FCR_TRIGGER_14; 1093 1094 /* IrDA ports use 8N1 */ 1095 lcr = UART_LCR_WLEN8; 1096 1097 outb(UART_LCR_DLAB | lcr, iobase+UART_LCR); /* Set DLAB */ 1098 outb(divisor & 0xff, iobase+UART_DLL); /* Set speed */ 1099 outb(divisor >> 8, iobase+UART_DLM); 1100 outb(lcr, iobase+UART_LCR); /* Set 8N1 */ 1101 outb(fcr, iobase+UART_FCR); /* Enable FIFO's */ 1102 1103 /* without this, the conection will be broken after come back from FIR speed, 1104 but with this, the SIR connection is harder to established */ 1105 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase+UART_MCR); 1106 1107 spin_unlock_irqrestore(&self->lock, flags); 1108 1109 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1110} 1111 1112static void ali_ircc_change_dongle_speed(struct ali_ircc_cb *priv, int speed) 1113{ 1114 1115 struct ali_ircc_cb *self = (struct ali_ircc_cb *) priv; 1116 int iobase,dongle_id; 1117 int tmp = 0; 1118 1119 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1120 1121 iobase = self->io.fir_base; /* or iobase = self->io.sir_base; */ 1122 dongle_id = self->io.dongle_id; 1123 1124 /* We are already locked, no need to do it again */ 1125 1126 IRDA_DEBUG(1, "%s(), Set Speed for %s , Speed = %d\n", __FUNCTION__ , dongle_types[dongle_id], speed); 1127 1128 switch_bank(iobase, BANK2); 1129 tmp = inb(iobase+FIR_IRDA_CR); 1130 1131 /* IBM type dongle */ 1132 if(dongle_id == 0) 1133 { 1134 if(speed == 4000000) 1135 { 1136 // __ __ 1137 // SD/MODE __| |__ __ 1138 // __ __ 1139 // IRTX __ __| |__ 1140 // T1 T2 T3 T4 T5 1141 1142 tmp &= ~IRDA_CR_HDLC; // HDLC=0 1143 tmp |= IRDA_CR_CRC; // CRC=1 1144 1145 switch_bank(iobase, BANK2); 1146 outb(tmp, iobase+FIR_IRDA_CR); 1147 1148 // T1 -> SD/MODE:0 IRTX:0 1149 tmp &= ~0x09; 1150 tmp |= 0x02; 1151 outb(tmp, iobase+FIR_IRDA_CR); 1152 udelay(2); 1153 1154 // T2 -> SD/MODE:1 IRTX:0 1155 tmp &= ~0x01; 1156 tmp |= 0x0a; 1157 outb(tmp, iobase+FIR_IRDA_CR); 1158 udelay(2); 1159 1160 // T3 -> SD/MODE:1 IRTX:1 1161 tmp |= 0x0b; 1162 outb(tmp, iobase+FIR_IRDA_CR); 1163 udelay(2); 1164 1165 // T4 -> SD/MODE:0 IRTX:1 1166 tmp &= ~0x08; 1167 tmp |= 0x03; 1168 outb(tmp, iobase+FIR_IRDA_CR); 1169 udelay(2); 1170 1171 // T5 -> SD/MODE:0 IRTX:0 1172 tmp &= ~0x09; 1173 tmp |= 0x02; 1174 outb(tmp, iobase+FIR_IRDA_CR); 1175 udelay(2); 1176 1177 // reset -> Normal TX output Signal 1178 outb(tmp & ~0x02, iobase+FIR_IRDA_CR); 1179 } 1180 else /* speed <=1152000 */ 1181 { 1182 // __ 1183 // SD/MODE __| |__ 1184 // 1185 // IRTX ________ 1186 // T1 T2 T3 1187 1188 /* MIR 115200, 57600 */ 1189 if (speed==1152000) 1190 { 1191 tmp |= 0xA0; //HDLC=1, 1.152Mbps=1 1192 } 1193 else 1194 { 1195 tmp &=~0x80; //HDLC 0.576Mbps 1196 tmp |= 0x20; //HDLC=1, 1197 } 1198 1199 tmp |= IRDA_CR_CRC; // CRC=1 1200 1201 switch_bank(iobase, BANK2); 1202 outb(tmp, iobase+FIR_IRDA_CR); 1203 1204 /* MIR 115200, 57600 */ 1205 1206 //switch_bank(iobase, BANK2); 1207 // T1 -> SD/MODE:0 IRTX:0 1208 tmp &= ~0x09; 1209 tmp |= 0x02; 1210 outb(tmp, iobase+FIR_IRDA_CR); 1211 udelay(2); 1212 1213 // T2 -> SD/MODE:1 IRTX:0 1214 tmp &= ~0x01; 1215 tmp |= 0x0a; 1216 outb(tmp, iobase+FIR_IRDA_CR); 1217 1218 // T3 -> SD/MODE:0 IRTX:0 1219 tmp &= ~0x09; 1220 tmp |= 0x02; 1221 outb(tmp, iobase+FIR_IRDA_CR); 1222 udelay(2); 1223 1224 // reset -> Normal TX output Signal 1225 outb(tmp & ~0x02, iobase+FIR_IRDA_CR); 1226 } 1227 } 1228 else if (dongle_id == 1) /* HP HDSL-3600 */ 1229 { 1230 switch(speed) 1231 { 1232 case 4000000: 1233 tmp &= ~IRDA_CR_HDLC; // HDLC=0 1234 break; 1235 1236 case 1152000: 1237 tmp |= 0xA0; // HDLC=1, 1.152Mbps=1 1238 break; 1239 1240 case 576000: 1241 tmp &=~0x80; // HDLC 0.576Mbps 1242 tmp |= 0x20; // HDLC=1, 1243 break; 1244 } 1245 1246 tmp |= IRDA_CR_CRC; // CRC=1 1247 1248 switch_bank(iobase, BANK2); 1249 outb(tmp, iobase+FIR_IRDA_CR); 1250 } 1251 else /* HP HDSL-1100 */ 1252 { 1253 if(speed <= 115200) /* SIR */ 1254 { 1255 1256 tmp &= ~IRDA_CR_FIR_SIN; // HP sin select = 0 1257 1258 switch_bank(iobase, BANK2); 1259 outb(tmp, iobase+FIR_IRDA_CR); 1260 } 1261 else /* MIR FIR */ 1262 { 1263 1264 switch(speed) 1265 { 1266 case 4000000: 1267 tmp &= ~IRDA_CR_HDLC; // HDLC=0 1268 break; 1269 1270 case 1152000: 1271 tmp |= 0xA0; // HDLC=1, 1.152Mbps=1 1272 break; 1273 1274 case 576000: 1275 tmp &=~0x80; // HDLC 0.576Mbps 1276 tmp |= 0x20; // HDLC=1, 1277 break; 1278 } 1279 1280 tmp |= IRDA_CR_CRC; // CRC=1 1281 tmp |= IRDA_CR_FIR_SIN; // HP sin select = 1 1282 1283 switch_bank(iobase, BANK2); 1284 outb(tmp, iobase+FIR_IRDA_CR); 1285 } 1286 } 1287 1288 switch_bank(iobase, BANK0); 1289 1290 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1291} 1292 1293/* 1294 * Function ali_ircc_sir_write (driver) 1295 * 1296 * Fill Tx FIFO with transmit data 1297 * 1298 */ 1299static int ali_ircc_sir_write(int iobase, int fifo_size, __u8 *buf, int len) 1300{ 1301 int actual = 0; 1302 1303 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1304 1305 /* Tx FIFO should be empty! */ 1306 if (!(inb(iobase+UART_LSR) & UART_LSR_THRE)) { 1307 IRDA_DEBUG(0, "%s(), failed, fifo not empty!\n", __FUNCTION__ ); 1308 return 0; 1309 } 1310 1311 /* Fill FIFO with current frame */ 1312 while ((fifo_size-- > 0) && (actual < len)) { 1313 /* Transmit next byte */ 1314 outb(buf[actual], iobase+UART_TX); 1315 1316 actual++; 1317 } 1318 1319 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1320 return actual; 1321} 1322 1323/* 1324 * Function ali_ircc_net_open (dev) 1325 * 1326 * Start the device 1327 * 1328 */ 1329static int ali_ircc_net_open(struct net_device *dev) 1330{ 1331 struct ali_ircc_cb *self; 1332 int iobase; 1333 char hwname[32]; 1334 1335 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1336 1337 IRDA_ASSERT(dev != NULL, return -1;); 1338 1339 self = (struct ali_ircc_cb *) dev->priv; 1340 1341 IRDA_ASSERT(self != NULL, return 0;); 1342 1343 iobase = self->io.fir_base; 1344 1345 /* Request IRQ and install Interrupt Handler */ 1346 if (request_irq(self->io.irq, ali_ircc_interrupt, 0, dev->name, dev)) 1347 { 1348 IRDA_WARNING("%s, unable to allocate irq=%d\n", 1349 ALI_IRCC_DRIVER_NAME, 1350 self->io.irq); 1351 return -EAGAIN; 1352 } 1353 1354 /* 1355 * Always allocate the DMA channel after the IRQ, and clean up on 1356 * failure. 1357 */ 1358 if (request_dma(self->io.dma, dev->name)) { 1359 IRDA_WARNING("%s, unable to allocate dma=%d\n", 1360 ALI_IRCC_DRIVER_NAME, 1361 self->io.dma); 1362 free_irq(self->io.irq, self); 1363 return -EAGAIN; 1364 } 1365 1366 /* Turn on interrups */ 1367 outb(UART_IER_RDI , iobase+UART_IER); 1368 1369 /* Ready to play! */ 1370 netif_start_queue(dev); //benjamin by irport 1371 1372 /* Give self a hardware name */ 1373 sprintf(hwname, "ALI-FIR @ 0x%03x", self->io.fir_base); 1374 1375 /* 1376 * Open new IrLAP layer instance, now that everything should be 1377 * initialized properly 1378 */ 1379 self->irlap = irlap_open(dev, &self->qos, hwname); 1380 1381 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1382 1383 return 0; 1384} 1385 1386/* 1387 * Function ali_ircc_net_close (dev) 1388 * 1389 * Stop the device 1390 * 1391 */ 1392static int ali_ircc_net_close(struct net_device *dev) 1393{ 1394 1395 struct ali_ircc_cb *self; 1396 //int iobase; 1397 1398 IRDA_DEBUG(4, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1399 1400 IRDA_ASSERT(dev != NULL, return -1;); 1401 1402 self = (struct ali_ircc_cb *) dev->priv; 1403 IRDA_ASSERT(self != NULL, return 0;); 1404 1405 /* Stop device */ 1406 netif_stop_queue(dev); 1407 1408 /* Stop and remove instance of IrLAP */ 1409 if (self->irlap) 1410 irlap_close(self->irlap); 1411 self->irlap = NULL; 1412 1413 disable_dma(self->io.dma); 1414 1415 /* Disable interrupts */ 1416 SetCOMInterrupts(self, FALSE); 1417 1418 free_irq(self->io.irq, dev); 1419 free_dma(self->io.dma); 1420 1421 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1422 1423 return 0; 1424} 1425 1426/* 1427 * Function ali_ircc_fir_hard_xmit (skb, dev) 1428 * 1429 * Transmit the frame 1430 * 1431 */ 1432static int ali_ircc_fir_hard_xmit(struct sk_buff *skb, struct net_device *dev) 1433{ 1434 struct ali_ircc_cb *self; 1435 unsigned long flags; 1436 int iobase; 1437 __u32 speed; 1438 int mtt, diff; 1439 1440 IRDA_DEBUG(1, "%s(), ---------------- Start -----------------\n", __FUNCTION__ ); 1441 1442 self = (struct ali_ircc_cb *) dev->priv; 1443 iobase = self->io.fir_base; 1444 1445 netif_stop_queue(dev); 1446 1447 /* Make sure tests *& speed change are atomic */ 1448 spin_lock_irqsave(&self->lock, flags); 1449 1450 /* Note : you should make sure that speed changes are not going 1451 * to corrupt any outgoing frame. Look at nsc-ircc for the gory 1452 * details - Jean II */ 1453 1454 /* Check if we need to change the speed */ 1455 speed = irda_get_next_speed(skb); 1456 if ((speed != self->io.speed) && (speed != -1)) { 1457 /* Check for empty frame */ 1458 if (!skb->len) { 1459 ali_ircc_change_speed(self, speed); 1460 dev->trans_start = jiffies; 1461 spin_unlock_irqrestore(&self->lock, flags); 1462 dev_kfree_skb(skb); 1463 return 0; 1464 } else 1465 self->new_speed = speed; 1466 } 1467 1468 /* Register and copy this frame to DMA memory */ 1469 self->tx_fifo.queue[self->tx_fifo.free].start = self->tx_fifo.tail; 1470 self->tx_fifo.queue[self->tx_fifo.free].len = skb->len; 1471 self->tx_fifo.tail += skb->len; 1472 1473 self->stats.tx_bytes += skb->len; 1474 1475 memcpy(self->tx_fifo.queue[self->tx_fifo.free].start, skb->data, 1476 skb->len); 1477 1478 self->tx_fifo.len++; 1479 self->tx_fifo.free++; 1480 1481 /* Start transmit only if there is currently no transmit going on */ 1482 if (self->tx_fifo.len == 1) 1483 { 1484 /* Check if we must wait the min turn time or not */ 1485 mtt = irda_get_mtt(skb); 1486 1487 if (mtt) 1488 { 1489 /* Check how much time we have used already */ 1490 do_gettimeofday(&self->now); 1491 1492 diff = self->now.tv_usec - self->stamp.tv_usec; 1493 /* self->stamp is set from ali_ircc_dma_receive_complete() */ 1494 1495 IRDA_DEBUG(1, "%s(), ******* diff = %d ******* \n", __FUNCTION__ , diff); 1496 1497 if (diff < 0) 1498 diff += 1000000; 1499 1500 /* Check if the mtt is larger than the time we have 1501 * already used by all the protocol processing 1502 */ 1503 if (mtt > diff) 1504 { 1505 mtt -= diff; 1506 1507 /* 1508 * Use timer if delay larger than 1000 us, and 1509 * use udelay for smaller values which should 1510 * be acceptable 1511 */ 1512 if (mtt > 500) 1513 { 1514 /* Adjust for timer resolution */ 1515 mtt = (mtt+250) / 500; /* 4 discard, 5 get advanced, Let's round off */ 1516 1517 IRDA_DEBUG(1, "%s(), ************** mtt = %d ***********\n", __FUNCTION__ , mtt); 1518 1519 /* Setup timer */ 1520 if (mtt == 1) /* 500 us */ 1521 { 1522 switch_bank(iobase, BANK1); 1523 outb(TIMER_IIR_500, iobase+FIR_TIMER_IIR); 1524 } 1525 else if (mtt == 2) /* 1 ms */ 1526 { 1527 switch_bank(iobase, BANK1); 1528 outb(TIMER_IIR_1ms, iobase+FIR_TIMER_IIR); 1529 } 1530 else /* > 2ms -> 4ms */ 1531 { 1532 switch_bank(iobase, BANK1); 1533 outb(TIMER_IIR_2ms, iobase+FIR_TIMER_IIR); 1534 } 1535 1536 1537 /* Start timer */ 1538 outb(inb(iobase+FIR_CR) | CR_TIMER_EN, iobase+FIR_CR); 1539 self->io.direction = IO_XMIT; 1540 1541 /* Enable timer interrupt */ 1542 self->ier = IER_TIMER; 1543 SetCOMInterrupts(self, TRUE); 1544 1545 /* Timer will take care of the rest */ 1546 goto out; 1547 } 1548 else 1549 udelay(mtt); 1550 } // if (if (mtt > diff) 1551 }// if (mtt) 1552 1553 /* Enable EOM interrupt */ 1554 self->ier = IER_EOM; 1555 SetCOMInterrupts(self, TRUE); 1556 1557 /* Transmit frame */ 1558 ali_ircc_dma_xmit(self); 1559 } // if (self->tx_fifo.len == 1) 1560 1561 out: 1562 1563 /* Not busy transmitting anymore if window is not full */ 1564 if (self->tx_fifo.free < MAX_TX_WINDOW) 1565 netif_wake_queue(self->netdev); 1566 1567 /* Restore bank register */ 1568 switch_bank(iobase, BANK0); 1569 1570 dev->trans_start = jiffies; 1571 spin_unlock_irqrestore(&self->lock, flags); 1572 dev_kfree_skb(skb); 1573 1574 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1575 return 0; 1576} 1577 1578 1579static void ali_ircc_dma_xmit(struct ali_ircc_cb *self) 1580{ 1581 int iobase, tmp; 1582 unsigned char FIFO_OPTI, Hi, Lo; 1583 1584 1585 IRDA_DEBUG(1, "%s(), ---------------- Start -----------------\n", __FUNCTION__ ); 1586 1587 iobase = self->io.fir_base; 1588 1589 /* FIFO threshold , this method comes from NDIS5 code */ 1590 1591 if(self->tx_fifo.queue[self->tx_fifo.ptr].len < TX_FIFO_Threshold) 1592 FIFO_OPTI = self->tx_fifo.queue[self->tx_fifo.ptr].len-1; 1593 else 1594 FIFO_OPTI = TX_FIFO_Threshold; 1595 1596 /* Disable DMA */ 1597 switch_bank(iobase, BANK1); 1598 outb(inb(iobase+FIR_CR) & ~CR_DMA_EN, iobase+FIR_CR); 1599 1600 self->io.direction = IO_XMIT; 1601 1602 irda_setup_dma(self->io.dma, 1603 ((u8 *)self->tx_fifo.queue[self->tx_fifo.ptr].start - 1604 self->tx_buff.head) + self->tx_buff_dma, 1605 self->tx_fifo.queue[self->tx_fifo.ptr].len, 1606 DMA_TX_MODE); 1607 1608 /* Reset Tx FIFO */ 1609 switch_bank(iobase, BANK0); 1610 outb(LCR_A_FIFO_RESET, iobase+FIR_LCR_A); 1611 1612 /* Set Tx FIFO threshold */ 1613 if (self->fifo_opti_buf!=FIFO_OPTI) 1614 { 1615 switch_bank(iobase, BANK1); 1616 outb(FIFO_OPTI, iobase+FIR_FIFO_TR) ; 1617 self->fifo_opti_buf=FIFO_OPTI; 1618 } 1619 1620 /* Set Tx DMA threshold */ 1621 switch_bank(iobase, BANK1); 1622 outb(TX_DMA_Threshold, iobase+FIR_DMA_TR); 1623 1624 /* Set max Tx frame size */ 1625 Hi = (self->tx_fifo.queue[self->tx_fifo.ptr].len >> 8) & 0x0f; 1626 Lo = self->tx_fifo.queue[self->tx_fifo.ptr].len & 0xff; 1627 switch_bank(iobase, BANK2); 1628 outb(Hi, iobase+FIR_TX_DSR_HI); 1629 outb(Lo, iobase+FIR_TX_DSR_LO); 1630 1631 /* Disable SIP , Disable Brick Wall (we don't support in TX mode), Change to TX mode */ 1632 switch_bank(iobase, BANK0); 1633 tmp = inb(iobase+FIR_LCR_B); 1634 tmp &= ~0x20; // Disable SIP 1635 outb(((unsigned char)(tmp & 0x3f) | LCR_B_TX_MODE) & ~LCR_B_BW, iobase+FIR_LCR_B); 1636 IRDA_DEBUG(1, "%s(), ******* Change to TX mode: FIR_LCR_B = 0x%x ******* \n", __FUNCTION__ , inb(iobase+FIR_LCR_B)); 1637 1638 outb(0, iobase+FIR_LSR); 1639 1640 /* Enable DMA and Burst Mode */ 1641 switch_bank(iobase, BANK1); 1642 outb(inb(iobase+FIR_CR) | CR_DMA_EN | CR_DMA_BURST, iobase+FIR_CR); 1643 1644 switch_bank(iobase, BANK0); 1645 1646 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1647} 1648 1649static int ali_ircc_dma_xmit_complete(struct ali_ircc_cb *self) 1650{ 1651 int iobase; 1652 int ret = TRUE; 1653 1654 IRDA_DEBUG(1, "%s(), ---------------- Start -----------------\n", __FUNCTION__ ); 1655 1656 iobase = self->io.fir_base; 1657 1658 /* Disable DMA */ 1659 switch_bank(iobase, BANK1); 1660 outb(inb(iobase+FIR_CR) & ~CR_DMA_EN, iobase+FIR_CR); 1661 1662 /* Check for underrun! */ 1663 switch_bank(iobase, BANK0); 1664 if((inb(iobase+FIR_LSR) & LSR_FRAME_ABORT) == LSR_FRAME_ABORT) 1665 1666 { 1667 IRDA_ERROR("%s(), ********* LSR_FRAME_ABORT *********\n", __FUNCTION__); 1668 self->stats.tx_errors++; 1669 self->stats.tx_fifo_errors++; 1670 } 1671 else 1672 { 1673 self->stats.tx_packets++; 1674 } 1675 1676 /* Check if we need to change the speed */ 1677 if (self->new_speed) 1678 { 1679 ali_ircc_change_speed(self, self->new_speed); 1680 self->new_speed = 0; 1681 } 1682 1683 /* Finished with this frame, so prepare for next */ 1684 self->tx_fifo.ptr++; 1685 self->tx_fifo.len--; 1686 1687 /* Any frames to be sent back-to-back? */ 1688 if (self->tx_fifo.len) 1689 { 1690 ali_ircc_dma_xmit(self); 1691 1692 /* Not finished yet! */ 1693 ret = FALSE; 1694 } 1695 else 1696 { /* Reset Tx FIFO info */ 1697 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; 1698 self->tx_fifo.tail = self->tx_buff.head; 1699 } 1700 1701 /* Make sure we have room for more frames */ 1702 if (self->tx_fifo.free < MAX_TX_WINDOW) { 1703 /* Not busy transmitting anymore */ 1704 /* Tell the network layer, that we can accept more frames */ 1705 netif_wake_queue(self->netdev); 1706 } 1707 1708 switch_bank(iobase, BANK0); 1709 1710 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1711 return ret; 1712} 1713 1714/* 1715 * Function ali_ircc_dma_receive (self) 1716 * 1717 * Get ready for receiving a frame. The device will initiate a DMA 1718 * if it starts to receive a frame. 1719 * 1720 */ 1721static int ali_ircc_dma_receive(struct ali_ircc_cb *self) 1722{ 1723 int iobase, tmp; 1724 1725 IRDA_DEBUG(1, "%s(), ---------------- Start -----------------\n", __FUNCTION__ ); 1726 1727 iobase = self->io.fir_base; 1728 1729 /* Reset Tx FIFO info */ 1730 self->tx_fifo.len = self->tx_fifo.ptr = self->tx_fifo.free = 0; 1731 self->tx_fifo.tail = self->tx_buff.head; 1732 1733 /* Disable DMA */ 1734 switch_bank(iobase, BANK1); 1735 outb(inb(iobase+FIR_CR) & ~CR_DMA_EN, iobase+FIR_CR); 1736 1737 /* Reset Message Count */ 1738 switch_bank(iobase, BANK0); 1739 outb(0x07, iobase+FIR_LSR); 1740 1741 self->rcvFramesOverflow = FALSE; 1742 1743 self->LineStatus = inb(iobase+FIR_LSR) ; 1744 1745 /* Reset Rx FIFO info */ 1746 self->io.direction = IO_RECV; 1747 self->rx_buff.data = self->rx_buff.head; 1748 1749 /* Reset Rx FIFO */ 1750 // switch_bank(iobase, BANK0); 1751 outb(LCR_A_FIFO_RESET, iobase+FIR_LCR_A); 1752 1753 self->st_fifo.len = self->st_fifo.pending_bytes = 0; 1754 self->st_fifo.tail = self->st_fifo.head = 0; 1755 1756 irda_setup_dma(self->io.dma, self->rx_buff_dma, self->rx_buff.truesize, 1757 DMA_RX_MODE); 1758 1759 /* Set Receive Mode,Brick Wall */ 1760 //switch_bank(iobase, BANK0); 1761 tmp = inb(iobase+FIR_LCR_B); 1762 outb((unsigned char)(tmp &0x3f) | LCR_B_RX_MODE | LCR_B_BW , iobase + FIR_LCR_B); // 2000/12/1 05:16PM 1763 IRDA_DEBUG(1, "%s(), *** Change To RX mode: FIR_LCR_B = 0x%x *** \n", __FUNCTION__ , inb(iobase+FIR_LCR_B)); 1764 1765 /* Set Rx Threshold */ 1766 switch_bank(iobase, BANK1); 1767 outb(RX_FIFO_Threshold, iobase+FIR_FIFO_TR); 1768 outb(RX_DMA_Threshold, iobase+FIR_DMA_TR); 1769 1770 /* Enable DMA and Burst Mode */ 1771 // switch_bank(iobase, BANK1); 1772 outb(CR_DMA_EN | CR_DMA_BURST, iobase+FIR_CR); 1773 1774 switch_bank(iobase, BANK0); 1775 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1776 return 0; 1777} 1778 1779static int ali_ircc_dma_receive_complete(struct ali_ircc_cb *self) 1780{ 1781 struct st_fifo *st_fifo; 1782 struct sk_buff *skb; 1783 __u8 status, MessageCount; 1784 int len, i, iobase, val; 1785 1786 IRDA_DEBUG(1, "%s(), ---------------- Start -----------------\n", __FUNCTION__ ); 1787 1788 st_fifo = &self->st_fifo; 1789 iobase = self->io.fir_base; 1790 1791 switch_bank(iobase, BANK0); 1792 MessageCount = inb(iobase+ FIR_LSR)&0x07; 1793 1794 if (MessageCount > 0) 1795 IRDA_DEBUG(0, "%s(), Messsage count = %d,\n", __FUNCTION__ , MessageCount); 1796 1797 for (i=0; i<=MessageCount; i++) 1798 { 1799 /* Bank 0 */ 1800 switch_bank(iobase, BANK0); 1801 status = inb(iobase+FIR_LSR); 1802 1803 switch_bank(iobase, BANK2); 1804 len = inb(iobase+FIR_RX_DSR_HI) & 0x0f; 1805 len = len << 8; 1806 len |= inb(iobase+FIR_RX_DSR_LO); 1807 1808 IRDA_DEBUG(1, "%s(), RX Length = 0x%.2x,\n", __FUNCTION__ , len); 1809 IRDA_DEBUG(1, "%s(), RX Status = 0x%.2x,\n", __FUNCTION__ , status); 1810 1811 if (st_fifo->tail >= MAX_RX_WINDOW) { 1812 IRDA_DEBUG(0, "%s(), window is full!\n", __FUNCTION__ ); 1813 continue; 1814 } 1815 1816 st_fifo->entries[st_fifo->tail].status = status; 1817 st_fifo->entries[st_fifo->tail].len = len; 1818 st_fifo->pending_bytes += len; 1819 st_fifo->tail++; 1820 st_fifo->len++; 1821 } 1822 1823 for (i=0; i<=MessageCount; i++) 1824 { 1825 /* Get first entry */ 1826 status = st_fifo->entries[st_fifo->head].status; 1827 len = st_fifo->entries[st_fifo->head].len; 1828 st_fifo->pending_bytes -= len; 1829 st_fifo->head++; 1830 st_fifo->len--; 1831 1832 /* Check for errors */ 1833 if ((status & 0xd8) || self->rcvFramesOverflow || (len==0)) 1834 { 1835 IRDA_DEBUG(0,"%s(), ************* RX Errors ************ \n", __FUNCTION__ ); 1836 1837 /* Skip frame */ 1838 self->stats.rx_errors++; 1839 1840 self->rx_buff.data += len; 1841 1842 if (status & LSR_FIFO_UR) 1843 { 1844 self->stats.rx_frame_errors++; 1845 IRDA_DEBUG(0,"%s(), ************* FIFO Errors ************ \n", __FUNCTION__ ); 1846 } 1847 if (status & LSR_FRAME_ERROR) 1848 { 1849 self->stats.rx_frame_errors++; 1850 IRDA_DEBUG(0,"%s(), ************* FRAME Errors ************ \n", __FUNCTION__ ); 1851 } 1852 1853 if (status & LSR_CRC_ERROR) 1854 { 1855 self->stats.rx_crc_errors++; 1856 IRDA_DEBUG(0,"%s(), ************* CRC Errors ************ \n", __FUNCTION__ ); 1857 } 1858 1859 if(self->rcvFramesOverflow) 1860 { 1861 self->stats.rx_frame_errors++; 1862 IRDA_DEBUG(0,"%s(), ************* Overran DMA buffer ************ \n", __FUNCTION__ ); 1863 } 1864 if(len == 0) 1865 { 1866 self->stats.rx_frame_errors++; 1867 IRDA_DEBUG(0,"%s(), ********** Receive Frame Size = 0 ********* \n", __FUNCTION__ ); 1868 } 1869 } 1870 else 1871 { 1872 1873 if (st_fifo->pending_bytes < 32) 1874 { 1875 switch_bank(iobase, BANK0); 1876 val = inb(iobase+FIR_BSR); 1877 if ((val& BSR_FIFO_NOT_EMPTY)== 0x80) 1878 { 1879 IRDA_DEBUG(0, "%s(), ************* BSR_FIFO_NOT_EMPTY ************ \n", __FUNCTION__ ); 1880 1881 /* Put this entry back in fifo */ 1882 st_fifo->head--; 1883 st_fifo->len++; 1884 st_fifo->pending_bytes += len; 1885 st_fifo->entries[st_fifo->head].status = status; 1886 st_fifo->entries[st_fifo->head].len = len; 1887 1888 /* 1889 * DMA not finished yet, so try again 1890 * later, set timer value, resolution 1891 * 500 us 1892 */ 1893 1894 switch_bank(iobase, BANK1); 1895 outb(TIMER_IIR_500, iobase+FIR_TIMER_IIR); // 2001/1/2 05:07PM 1896 1897 /* Enable Timer */ 1898 outb(inb(iobase+FIR_CR) | CR_TIMER_EN, iobase+FIR_CR); 1899 1900 return FALSE; /* I'll be back! */ 1901 } 1902 } 1903 1904 /* 1905 * Remember the time we received this frame, so we can 1906 * reduce the min turn time a bit since we will know 1907 * how much time we have used for protocol processing 1908 */ 1909 do_gettimeofday(&self->stamp); 1910 1911 skb = dev_alloc_skb(len+1); 1912 if (skb == NULL) 1913 { 1914 IRDA_WARNING("%s(), memory squeeze, " 1915 "dropping frame.\n", 1916 __FUNCTION__); 1917 self->stats.rx_dropped++; 1918 1919 return FALSE; 1920 } 1921 1922 /* Make sure IP header gets aligned */ 1923 skb_reserve(skb, 1); 1924 1925 /* Copy frame without CRC, CRC is removed by hardware*/ 1926 skb_put(skb, len); 1927 memcpy(skb->data, self->rx_buff.data, len); 1928 1929 /* Move to next frame */ 1930 self->rx_buff.data += len; 1931 self->stats.rx_bytes += len; 1932 self->stats.rx_packets++; 1933 1934 skb->dev = self->netdev; 1935 skb->mac.raw = skb->data; 1936 skb->protocol = htons(ETH_P_IRDA); 1937 netif_rx(skb); 1938 self->netdev->last_rx = jiffies; 1939 } 1940 } 1941 1942 switch_bank(iobase, BANK0); 1943 1944 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 1945 return TRUE; 1946} 1947 1948 1949 1950/* 1951 * Function ali_ircc_sir_hard_xmit (skb, dev) 1952 * 1953 * Transmit the frame! 1954 * 1955 */ 1956static int ali_ircc_sir_hard_xmit(struct sk_buff *skb, struct net_device *dev) 1957{ 1958 struct ali_ircc_cb *self; 1959 unsigned long flags; 1960 int iobase; 1961 __u32 speed; 1962 1963 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 1964 1965 IRDA_ASSERT(dev != NULL, return 0;); 1966 1967 self = (struct ali_ircc_cb *) dev->priv; 1968 IRDA_ASSERT(self != NULL, return 0;); 1969 1970 iobase = self->io.sir_base; 1971 1972 netif_stop_queue(dev); 1973 1974 /* Make sure tests *& speed change are atomic */ 1975 spin_lock_irqsave(&self->lock, flags); 1976 1977 /* Note : you should make sure that speed changes are not going 1978 * to corrupt any outgoing frame. Look at nsc-ircc for the gory 1979 * details - Jean II */ 1980 1981 /* Check if we need to change the speed */ 1982 speed = irda_get_next_speed(skb); 1983 if ((speed != self->io.speed) && (speed != -1)) { 1984 /* Check for empty frame */ 1985 if (!skb->len) { 1986 ali_ircc_change_speed(self, speed); 1987 dev->trans_start = jiffies; 1988 spin_unlock_irqrestore(&self->lock, flags); 1989 dev_kfree_skb(skb); 1990 return 0; 1991 } else 1992 self->new_speed = speed; 1993 } 1994 1995 /* Init tx buffer */ 1996 self->tx_buff.data = self->tx_buff.head; 1997 1998 /* Copy skb to tx_buff while wrapping, stuffing and making CRC */ 1999 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, 2000 self->tx_buff.truesize); 2001 2002 self->stats.tx_bytes += self->tx_buff.len; 2003 2004 /* Turn on transmit finished interrupt. Will fire immediately! */ 2005 outb(UART_IER_THRI, iobase+UART_IER); 2006 2007 dev->trans_start = jiffies; 2008 spin_unlock_irqrestore(&self->lock, flags); 2009 2010 dev_kfree_skb(skb); 2011 2012 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2013 2014 return 0; 2015} 2016 2017 2018/* 2019 * Function ali_ircc_net_ioctl (dev, rq, cmd) 2020 * 2021 * Process IOCTL commands for this device 2022 * 2023 */ 2024static int ali_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 2025{ 2026 struct if_irda_req *irq = (struct if_irda_req *) rq; 2027 struct ali_ircc_cb *self; 2028 unsigned long flags; 2029 int ret = 0; 2030 2031 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 2032 2033 IRDA_ASSERT(dev != NULL, return -1;); 2034 2035 self = dev->priv; 2036 2037 IRDA_ASSERT(self != NULL, return -1;); 2038 2039 IRDA_DEBUG(2, "%s(), %s, (cmd=0x%X)\n", __FUNCTION__ , dev->name, cmd); 2040 2041 switch (cmd) { 2042 case SIOCSBANDWIDTH: /* Set bandwidth */ 2043 IRDA_DEBUG(1, "%s(), SIOCSBANDWIDTH\n", __FUNCTION__ ); 2044 /* 2045 * This function will also be used by IrLAP to change the 2046 * speed, so we still must allow for speed change within 2047 * interrupt context. 2048 */ 2049 if (!in_interrupt() && !capable(CAP_NET_ADMIN)) 2050 return -EPERM; 2051 2052 spin_lock_irqsave(&self->lock, flags); 2053 ali_ircc_change_speed(self, irq->ifr_baudrate); 2054 spin_unlock_irqrestore(&self->lock, flags); 2055 break; 2056 case SIOCSMEDIABUSY: /* Set media busy */ 2057 IRDA_DEBUG(1, "%s(), SIOCSMEDIABUSY\n", __FUNCTION__ ); 2058 if (!capable(CAP_NET_ADMIN)) 2059 return -EPERM; 2060 irda_device_set_media_busy(self->netdev, TRUE); 2061 break; 2062 case SIOCGRECEIVING: /* Check if we are receiving right now */ 2063 IRDA_DEBUG(2, "%s(), SIOCGRECEIVING\n", __FUNCTION__ ); 2064 /* This is protected */ 2065 irq->ifr_receiving = ali_ircc_is_receiving(self); 2066 break; 2067 default: 2068 ret = -EOPNOTSUPP; 2069 } 2070 2071 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2072 2073 return ret; 2074} 2075 2076/* 2077 * Function ali_ircc_is_receiving (self) 2078 * 2079 * Return TRUE is we are currently receiving a frame 2080 * 2081 */ 2082static int ali_ircc_is_receiving(struct ali_ircc_cb *self) 2083{ 2084 unsigned long flags; 2085 int status = FALSE; 2086 int iobase; 2087 2088 IRDA_DEBUG(2, "%s(), ---------------- Start -----------------\n", __FUNCTION__ ); 2089 2090 IRDA_ASSERT(self != NULL, return FALSE;); 2091 2092 spin_lock_irqsave(&self->lock, flags); 2093 2094 if (self->io.speed > 115200) 2095 { 2096 iobase = self->io.fir_base; 2097 2098 switch_bank(iobase, BANK1); 2099 if((inb(iobase+FIR_FIFO_FR) & 0x3f) != 0) 2100 { 2101 /* We are receiving something */ 2102 IRDA_DEBUG(1, "%s(), We are receiving something\n", __FUNCTION__ ); 2103 status = TRUE; 2104 } 2105 switch_bank(iobase, BANK0); 2106 } 2107 else 2108 { 2109 status = (self->rx_buff.state != OUTSIDE_FRAME); 2110 } 2111 2112 spin_unlock_irqrestore(&self->lock, flags); 2113 2114 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2115 2116 return status; 2117} 2118 2119static struct net_device_stats *ali_ircc_net_get_stats(struct net_device *dev) 2120{ 2121 struct ali_ircc_cb *self = (struct ali_ircc_cb *) dev->priv; 2122 2123 IRDA_DEBUG(2, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 2124 2125 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2126 2127 return &self->stats; 2128} 2129 2130static int ali_ircc_suspend(struct platform_device *dev, pm_message_t state) 2131{ 2132 struct ali_ircc_cb *self = platform_get_drvdata(dev); 2133 2134 IRDA_MESSAGE("%s, Suspending\n", ALI_IRCC_DRIVER_NAME); 2135 2136 if (self->io.suspended) 2137 return 0; 2138 2139 ali_ircc_net_close(self->netdev); 2140 2141 self->io.suspended = 1; 2142 2143 return 0; 2144} 2145 2146static int ali_ircc_resume(struct platform_device *dev) 2147{ 2148 struct ali_ircc_cb *self = platform_get_drvdata(dev); 2149 2150 if (!self->io.suspended) 2151 return 0; 2152 2153 ali_ircc_net_open(self->netdev); 2154 2155 IRDA_MESSAGE("%s, Waking up\n", ALI_IRCC_DRIVER_NAME); 2156 2157 self->io.suspended = 0; 2158 2159 return 0; 2160} 2161 2162/* ALi Chip Function */ 2163 2164static void SetCOMInterrupts(struct ali_ircc_cb *self , unsigned char enable) 2165{ 2166 2167 unsigned char newMask; 2168 2169 int iobase = self->io.fir_base; /* or sir_base */ 2170 2171 IRDA_DEBUG(2, "%s(), -------- Start -------- ( Enable = %d )\n", __FUNCTION__ , enable); 2172 2173 /* Enable the interrupt which we wish to */ 2174 if (enable){ 2175 if (self->io.direction == IO_XMIT) 2176 { 2177 if (self->io.speed > 115200) /* FIR, MIR */ 2178 { 2179 newMask = self->ier; 2180 } 2181 else /* SIR */ 2182 { 2183 newMask = UART_IER_THRI | UART_IER_RDI; 2184 } 2185 } 2186 else { 2187 if (self->io.speed > 115200) /* FIR, MIR */ 2188 { 2189 newMask = self->ier; 2190 } 2191 else /* SIR */ 2192 { 2193 newMask = UART_IER_RDI; 2194 } 2195 } 2196 } 2197 else /* Disable all the interrupts */ 2198 { 2199 newMask = 0x00; 2200 2201 } 2202 2203 //SIR and FIR has different registers 2204 if (self->io.speed > 115200) 2205 { 2206 switch_bank(iobase, BANK0); 2207 outb(newMask, iobase+FIR_IER); 2208 } 2209 else 2210 outb(newMask, iobase+UART_IER); 2211 2212 IRDA_DEBUG(2, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2213} 2214 2215static void SIR2FIR(int iobase) 2216{ 2217 //unsigned char tmp; 2218 2219 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 2220 2221 /* Already protected (change_speed() or setup()), no need to lock. 2222 * Jean II */ 2223 2224 outb(0x28, iobase+UART_MCR); 2225 outb(0x68, iobase+UART_MCR); 2226 outb(0x88, iobase+UART_MCR); 2227 2228 outb(0x60, iobase+FIR_MCR); /* Master Reset */ 2229 outb(0x20, iobase+FIR_MCR); /* Master Interrupt Enable */ 2230 2231 //tmp = inb(iobase+FIR_LCR_B); /* SIP enable */ 2232 //tmp |= 0x20; 2233 //outb(tmp, iobase+FIR_LCR_B); 2234 2235 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2236} 2237 2238static void FIR2SIR(int iobase) 2239{ 2240 unsigned char val; 2241 2242 IRDA_DEBUG(1, "%s(), ---------------- Start ----------------\n", __FUNCTION__ ); 2243 2244 /* Already protected (change_speed() or setup()), no need to lock. 2245 * Jean II */ 2246 2247 outb(0x20, iobase+FIR_MCR); /* IRQ to low */ 2248 outb(0x00, iobase+UART_IER); 2249 2250 outb(0xA0, iobase+FIR_MCR); /* Don't set master reset */ 2251 outb(0x00, iobase+UART_FCR); 2252 outb(0x07, iobase+UART_FCR); 2253 2254 val = inb(iobase+UART_RX); 2255 val = inb(iobase+UART_LSR); 2256 val = inb(iobase+UART_MSR); 2257 2258 IRDA_DEBUG(1, "%s(), ----------------- End ------------------\n", __FUNCTION__ ); 2259} 2260 2261MODULE_AUTHOR("Benjamin Kong <benjamin_kong@ali.com.tw>"); 2262MODULE_DESCRIPTION("ALi FIR Controller Driver"); 2263MODULE_LICENSE("GPL"); 2264 2265 2266module_param_array(io, int, NULL, 0); 2267MODULE_PARM_DESC(io, "Base I/O addresses"); 2268module_param_array(irq, int, NULL, 0); 2269MODULE_PARM_DESC(irq, "IRQ lines"); 2270module_param_array(dma, int, NULL, 0); 2271MODULE_PARM_DESC(dma, "DMA channels"); 2272 2273module_init(ali_ircc_init); 2274module_exit(ali_ircc_cleanup); 2275