1/*****************************************************************
   2 *
   3 * Filename:		donauboe.c
   4 * Version: 		2.17
   5 * Description:   Driver for the Toshiba OBOE (or type-O or 701)
   6 *                FIR Chipset, also supports the DONAUOBOE (type-DO
   7 *                or d01) FIR chipset which as far as I know is
   8 *                register compatible.
   9 * Documentation: http://libxg.free.fr/irda/lib-irda.html
  10 * Status:        Experimental.
  11 * Author:        James McKenzie <james@fishsoup.dhs.org>
  12 * Created at:    Sat May 8  12:35:27 1999
  13 * Modified:      Paul Bristow <paul.bristow@technologist.com>
  14 * Modified:      Mon Nov 11 19:10:05 1999
  15 * Modified:      James McKenzie <james@fishsoup.dhs.org>
  16 * Modified:      Thu Mar 16 12:49:00 2000 (Substantial rewrite)
  17 * Modified:      Sat Apr 29 00:23:03 2000 (Added DONAUOBOE support)
  18 * Modified:      Wed May 24 23:45:02 2000 (Fixed chipio_t structure)
  19 * Modified: 2.13 Christian Gennerat <christian.gennerat@polytechnique.org>
  20 * Modified: 2.13 dim jan 07 21:57:39 2001 (tested with kernel 2.4 & irnet/ppp)
  21 * Modified: 2.14 Christian Gennerat <christian.gennerat@polytechnique.org>
  22 * Modified: 2.14 lun fev 05 17:55:59 2001 (adapted to patch-2.4.1-pre8-irda1)
  23 * Modified: 2.15 Martin Lucina <mato@kotelna.sk>
  24 * Modified: 2.15 Fri Jun 21 20:40:59 2002 (sync with 2.4.18, substantial fixes)
  25 * Modified: 2.16 Martin Lucina <mato@kotelna.sk>
  26 * Modified: 2.16 Sat Jun 22 18:54:29 2002 (fix freeregion, default to verbose)
  27 * Modified: 2.17 Christian Gennerat <christian.gennerat@polytechnique.org>
  28 * Modified: 2.17 jeu sep 12 08:50:20 2002 (save_flags();cli(); replaced by spinlocks)
  29 * Modified: 2.18 Christian Gennerat <christian.gennerat@polytechnique.org>
  30 * Modified: 2.18 ven jan 10 03:14:16 2003 Change probe default options
  31 *
  32 *     Copyright (c) 1999 James McKenzie, All Rights Reserved.
  33 *
  34 *     This program is free software; you can redistribute it and/or
  35 *     modify it under the terms of the GNU General Public License as
  36 *     published by the Free Software Foundation; either version 2 of
  37 *     the License, or (at your option) any later version.
  38 *
  39 *     Neither James McKenzie nor Cambridge University admit liability nor
  40 *     provide warranty for any of this software. This material is
  41 *     provided "AS-IS" and at no charge.
  42 *
  43 *     Applicable Models : Libretto 100/110CT and many more.
  44 *     Toshiba refers to this chip as the type-O IR port,
  45 *     or the type-DO IR port.
  46 *
  47 ********************************************************************/
  48
  49/* Look at toshoboe.h (currently in include/net/irda) for details of */
  50/* Where to get documentation on the chip         */
  51
  52/* See below for a description of the logic in this driver */
  53
  54/* User servicable parts */
  55/* USE_PROBE Create the code which probes the chip and does a few tests */
  56/* do_probe module parameter Enable this code */
  57/* Probe code is very useful for understanding how the hardware works */
  58/* Use it with various combinations of TT_LEN, RX_LEN */
  59/* Strongly recommended, disable if the probe fails on your machine */
  60/* and send me <james@fishsoup.dhs.org> the output of dmesg */
  61#define USE_PROBE 1
  62#undef  USE_PROBE
  63
  64/* Trace Transmit ring, interrupts, Receive ring or not ? */
  65#define PROBE_VERBOSE 1
  66
  67/* Debug option, examine sent and received raw data */
  68/* Irdadump is better, but does not see all packets. enable it if you want. */
  69#undef DUMP_PACKETS
  70
  71/* MIR mode has not been tested. Some behaviour is different */
  72/* Seems to work against an Ericsson R520 for me. -Martin */
  73#define USE_MIR
  74
  75/* Schedule back to back hardware transmits wherever possible, otherwise */
  76/* we need an interrupt for every frame, unset if oboe works for a bit and */
  77/* then hangs */
  78#define OPTIMIZE_TX
  79
  80/* Set the number of slots in the rings */
  81/* If you get rx/tx fifo overflows at high bitrates, you can try increasing */
  82/* these */
  83
  84#define RING_SIZE (OBOE_RING_SIZE_RX8 | OBOE_RING_SIZE_TX8)
  85#define TX_SLOTS    8
  86#define RX_SLOTS    8
  87
  88
  89/* Less user servicable parts below here */
  90
  91/* Test, Transmit and receive buffer sizes, adjust at your peril */
  92/* remarks: nfs usually needs 1k blocks */
  93/* remarks: in SIR mode, CRC is received, -> RX_LEN=TX_LEN+2 */
  94/* remarks: test accepts large blocks. Standard is 0x80 */
  95/* When TT_LEN > RX_LEN (SIR mode) data is stored in successive slots. */
  96/* When 3 or more slots are needed for each test packet, */
  97/* data received in the first slots is overwritten, even */
  98/* if OBOE_CTL_RX_HW_OWNS is not set, without any error! */
  99#define TT_LEN      0x80
 100#define TX_LEN      0xc00
 101#define RX_LEN      0xc04
 102/* Real transmitted length (SIR mode) is about 14+(2%*TX_LEN) more */
 103/* long than user-defined length (see async_wrap_skb) and is less then 4K */
 104/* Real received length is (max RX_LEN) differs from user-defined */
 105/* length only b the CRC (2 or 4 bytes) */
 106#define BUF_SAFETY  0x7a
 107#define RX_BUF_SZ   (RX_LEN)
 108#define TX_BUF_SZ   (TX_LEN+BUF_SAFETY)
 109
 110
 111/* Logic of the netdev part of this driver                             */
 112
 113/* The RX ring is filled with buffers, when a packet arrives           */
 114/* it is DMA'd into the buffer which is marked used and RxDone called  */
 115/* RxDone forms an skb (and checks the CRC if in SIR mode) and ships   */
 116/* the packet off upstairs */
 117
 118/* The transmitter on the oboe chip can work in one of two modes       */
 119/* for each ring->tx[] the transmitter can either                      */
 120/* a) transmit the packet, leave the trasmitter enabled and proceed to */
 121/*    the next ring                                                    */
 122/* OR                                                                  */
 123/* b) transmit the packet, switch off the transmitter and issue TxDone */
 124
 125/* All packets are entered into the ring in mode b), if the ring was   */
 126/* empty the transmitter is started.                                   */
 127
 128/* If OPTIMIZE_TX is defined then in TxDone if the ring contains       */
 129/* more than one packet, all but the last are set to mode a) [HOWEVER  */
 130/* the hardware may not notice this, this is why we start in mode b) ] */
 131/* then restart the transmitter                                        */
 132
 133/* If OPTIMIZE_TX is not defined then we just restart the transmitter  */
 134/* if the ring isn't empty */
 135
 136/* Speed changes are delayed until the TxRing is empty                 */
 137/* mtt is handled by generating packets with bad CRCs, before the data */
 138
 139/* TODO: */
 140/* check the mtt works ok      */
 141/* finish the watchdog         */
 142
 143/* No user servicable parts below here */
 144
 145#include <linux/module.h>
 146
 147#include <linux/kernel.h>
 148#include <linux/types.h>
 149#include <linux/skbuff.h>
 150#include <linux/netdevice.h>
 151#include <linux/ioport.h>
 152#include <linux/delay.h>
 153#include <linux/slab.h>
 154#include <linux/init.h>
 155#include <linux/interrupt.h>
 156#include <linux/pci.h>
 157#include <linux/rtnetlink.h>
 158
 159#include <asm/system.h>
 160#include <asm/io.h>
 161
 162#include <net/irda/wrapper.h>
 163#include <net/irda/irda.h>
 164//#include <net/irda/irmod.h>
 165//#include <net/irda/irlap_frame.h>
 166#include <net/irda/irda_device.h>
 167#include <net/irda/crc.h>
 168
 169#include "donauboe.h"
 170
 171#define INB(port)       inb_p(port)
 172#define OUTB(val,port)  outb_p(val,port)
 173#define OUTBP(val,port) outb_p(val,port)
 174
 175#define PROMPT  OUTB(OBOE_PROMPT_BIT,OBOE_PROMPT);
 176
 177#if PROBE_VERBOSE
 178#define PROBE_DEBUG(args...) (printk (args))
 179#else
 180#define PROBE_DEBUG(args...) ;
 181#endif
 182
 183/* Set the DMA to be byte at a time */
 184#define CONFIG0H_DMA_OFF OBOE_CONFIG0H_RCVANY
 185#define CONFIG0H_DMA_ON_NORX CONFIG0H_DMA_OFF| OBOE_CONFIG0H_ENDMAC
 186#define CONFIG0H_DMA_ON CONFIG0H_DMA_ON_NORX | OBOE_CONFIG0H_ENRX
 187
 188static DEFINE_PCI_DEVICE_TABLE(toshoboe_pci_tbl) = {
 189	{ PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_FIR701, PCI_ANY_ID, PCI_ANY_ID, },
 190	{ PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_FIRD01, PCI_ANY_ID, PCI_ANY_ID, },
 191	{ }			/* Terminating entry */
 192};
 193MODULE_DEVICE_TABLE(pci, toshoboe_pci_tbl);
 194
 195#define DRIVER_NAME "toshoboe"
 196static char *driver_name = DRIVER_NAME;
 197
 198static int max_baud = 4000000;
 199#ifdef USE_PROBE
 200static int do_probe = 0;
 201#endif
 202
 203
 204/**********************************************************************/
 205static int
 206toshoboe_checkfcs (unsigned char *buf, int len)
 207{
 208  int i;
 209  union
 210  {
 211    __u16 value;
 212    __u8 bytes[2];
 213  }
 214  fcs;
 215
 216  fcs.value = INIT_FCS;
 217
 218  for (i = 0; i < len; ++i)
 219    fcs.value = irda_fcs (fcs.value, *(buf++));
 220
 221  return fcs.value == GOOD_FCS;
 222}
 223
 224/***********************************************************************/
 225/* Generic chip handling code */
 226#ifdef DUMP_PACKETS
 227static unsigned char dump[50];
 228static void
 229_dumpbufs (unsigned char *data, int len, char tete)
 230{
 231int i,j;
 232char head=tete;
 233for (i=0;i<len;i+=16) {
 234    for (j=0;j<16 && i+j<len;j++) { sprintf(&dump[3*j],"%02x.",data[i+j]); }
 235    dump [3*j]=0;
 236    IRDA_DEBUG (2, "%c%s\n",head , dump);
 237    head='+';
 238    }
 239}
 240#endif
 241
 242#ifdef USE_PROBE
 243/* Dump the registers */
 244static void
 245toshoboe_dumpregs (struct toshoboe_cb *self)
 246{
 247  __u32 ringbase;
 248
 249  IRDA_DEBUG (4, "%s()\n", __func__);
 250
 251  ringbase = INB (OBOE_RING_BASE0) << 10;
 252  ringbase |= INB (OBOE_RING_BASE1) << 18;
 253  ringbase |= INB (OBOE_RING_BASE2) << 26;
 254
 255  printk (KERN_ERR DRIVER_NAME ": Register dump:\n");
 256  printk (KERN_ERR "Interrupts: Tx:%d Rx:%d TxUnder:%d RxOver:%d Sip:%d\n",
 257          self->int_tx, self->int_rx, self->int_txunder, self->int_rxover,
 258          self->int_sip);
 259  printk (KERN_ERR "RX %02x TX %02x RingBase %08x\n",
 260          INB (OBOE_RXSLOT), INB (OBOE_TXSLOT), ringbase);
 261  printk (KERN_ERR "RING_SIZE %02x IER %02x ISR %02x\n",
 262          INB (OBOE_RING_SIZE), INB (OBOE_IER), INB (OBOE_ISR));
 263  printk (KERN_ERR "CONFIG1 %02x STATUS %02x\n",
 264          INB (OBOE_CONFIG1), INB (OBOE_STATUS));
 265  printk (KERN_ERR "CONFIG0 %02x%02x ENABLE %02x%02x\n",
 266          INB (OBOE_CONFIG0H), INB (OBOE_CONFIG0L),
 267          INB (OBOE_ENABLEH), INB (OBOE_ENABLEL));
 268  printk (KERN_ERR "NEW_PCONFIG %02x%02x CURR_PCONFIG %02x%02x\n",
 269          INB (OBOE_NEW_PCONFIGH), INB (OBOE_NEW_PCONFIGL),
 270          INB (OBOE_CURR_PCONFIGH), INB (OBOE_CURR_PCONFIGL));
 271  printk (KERN_ERR "MAXLEN %02x%02x RXCOUNT %02x%02x\n",
 272          INB (OBOE_MAXLENH), INB (OBOE_MAXLENL),
 273          INB (OBOE_RXCOUNTL), INB (OBOE_RXCOUNTH));
 274
 275  if (self->ring)
 276    {
 277      int i;
 278      ringbase = virt_to_bus (self->ring);
 279      printk (KERN_ERR "Ring at %08x:\n", ringbase);
 280      printk (KERN_ERR "RX:");
 281      for (i = 0; i < RX_SLOTS; ++i)
 282        printk (" (%d,%02x)",self->ring->rx[i].len,self->ring->rx[i].control);
 283      printk ("\n");
 284      printk (KERN_ERR "TX:");
 285      for (i = 0; i < RX_SLOTS; ++i)
 286        printk (" (%d,%02x)",self->ring->tx[i].len,self->ring->tx[i].control);
 287      printk ("\n");
 288    }
 289}
 290#endif
 291
 292/*Don't let the chip look at memory */
 293static void
 294toshoboe_disablebm (struct toshoboe_cb *self)
 295{
 296  __u8 command;
 297  IRDA_DEBUG (4, "%s()\n", __func__);
 298
 299  pci_read_config_byte (self->pdev, PCI_COMMAND, &command);
 300  command &= ~PCI_COMMAND_MASTER;
 301  pci_write_config_byte (self->pdev, PCI_COMMAND, command);
 302
 303}
 304
 305/* Shutdown the chip and point the taskfile reg somewhere else */
 306static void
 307toshoboe_stopchip (struct toshoboe_cb *self)
 308{
 309  IRDA_DEBUG (4, "%s()\n", __func__);
 310
 311  /*Disable interrupts */
 312  OUTB (0x0, OBOE_IER);
 313  /*Disable DMA, Disable Rx, Disable Tx */
 314  OUTB (CONFIG0H_DMA_OFF, OBOE_CONFIG0H);
 315  /*Disable SIR MIR FIR, Tx and Rx */
 316  OUTB (0x00, OBOE_ENABLEH);
 317  /*Point the ring somewhere safe */
 318  OUTB (0x3f, OBOE_RING_BASE2);
 319  OUTB (0xff, OBOE_RING_BASE1);
 320  OUTB (0xff, OBOE_RING_BASE0);
 321
 322  OUTB (RX_LEN >> 8, OBOE_MAXLENH);
 323  OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
 324
 325  /*Acknoledge any pending interrupts */
 326  OUTB (0xff, OBOE_ISR);
 327
 328  /*Why */
 329  OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
 330
 331  /*switch it off */
 332  OUTB (OBOE_CONFIG1_OFF, OBOE_CONFIG1);
 333
 334  toshoboe_disablebm (self);
 335}
 336
 337/* Transmitter initialization */
 338static void
 339toshoboe_start_DMA (struct toshoboe_cb *self, int opts)
 340{
 341  OUTB (0x0, OBOE_ENABLEH);
 342  OUTB (CONFIG0H_DMA_ON | opts,  OBOE_CONFIG0H);
 343  OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
 344  PROMPT;
 345}
 346
 347/*Set the baud rate */
 348static void
 349toshoboe_setbaud (struct toshoboe_cb *self)
 350{
 351  __u16 pconfig = 0;
 352  __u8 config0l = 0;
 353
 354  IRDA_DEBUG (2, "%s(%d/%d)\n", __func__, self->speed, self->io.speed);
 355
 356  switch (self->speed)
 357    {
 358    case 2400:
 359    case 4800:
 360    case 9600:
 361    case 19200:
 362    case 38400:
 363    case 57600:
 364    case 115200:
 365#ifdef USE_MIR
 366    case 1152000:
 367#endif
 368    case 4000000:
 369      break;
 370    default:
 371
 372      printk (KERN_ERR DRIVER_NAME ": switch to unsupported baudrate %d\n",
 373              self->speed);
 374      return;
 375    }
 376
 377  switch (self->speed)
 378    {
 379      /* For SIR the preamble is done by adding XBOFs */
 380      /* to the packet */
 381      /* set to filtered SIR mode, filter looks for BOF and EOF */
 382    case 2400:
 383      pconfig |= 47 << OBOE_PCONFIG_BAUDSHIFT;
 384      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 385      break;
 386    case 4800:
 387      pconfig |= 23 << OBOE_PCONFIG_BAUDSHIFT;
 388      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 389      break;
 390    case 9600:
 391      pconfig |= 11 << OBOE_PCONFIG_BAUDSHIFT;
 392      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 393      break;
 394    case 19200:
 395      pconfig |= 5 << OBOE_PCONFIG_BAUDSHIFT;
 396      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 397      break;
 398    case 38400:
 399      pconfig |= 2 << OBOE_PCONFIG_BAUDSHIFT;
 400      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 401      break;
 402    case 57600:
 403      pconfig |= 1 << OBOE_PCONFIG_BAUDSHIFT;
 404      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 405      break;
 406    case 115200:
 407      pconfig |= 0 << OBOE_PCONFIG_BAUDSHIFT;
 408      pconfig |= 25 << OBOE_PCONFIG_WIDTHSHIFT;
 409      break;
 410    default:
 411      /*Set to packet based reception */
 412      OUTB (RX_LEN >> 8, OBOE_MAXLENH);
 413      OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
 414      break;
 415    }
 416
 417  switch (self->speed)
 418    {
 419    case 2400:
 420    case 4800:
 421    case 9600:
 422    case 19200:
 423    case 38400:
 424    case 57600:
 425    case 115200:
 426      config0l = OBOE_CONFIG0L_ENSIR;
 427      if (self->async)
 428        {
 429          /*Set to character based reception */
 430          /*System will lock if MAXLEN=0 */
 431          /*so have to be careful */
 432          OUTB (0x01, OBOE_MAXLENH);
 433          OUTB (0x01, OBOE_MAXLENL);
 434          OUTB (0x00, OBOE_MAXLENH);
 435        }
 436      else
 437        {
 438          /*Set to packet based reception */
 439          config0l |= OBOE_CONFIG0L_ENSIRF;
 440          OUTB (RX_LEN >> 8, OBOE_MAXLENH);
 441          OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
 442        }
 443      break;
 444
 445#ifdef USE_MIR
 446      /* MIR mode */
 447      /* Set for 16 bit CRC and enable MIR */
 448      /* Preamble now handled by the chip */
 449    case 1152000:
 450      pconfig |= 0 << OBOE_PCONFIG_BAUDSHIFT;
 451      pconfig |= 8 << OBOE_PCONFIG_WIDTHSHIFT;
 452      pconfig |= 1 << OBOE_PCONFIG_PREAMBLESHIFT;
 453      config0l = OBOE_CONFIG0L_CRC16 | OBOE_CONFIG0L_ENMIR;
 454      break;
 455#endif
 456      /* FIR mode */
 457      /* Set for 32 bit CRC and enable FIR */
 458      /* Preamble handled by the chip */
 459    case 4000000:
 460      pconfig |= 0 << OBOE_PCONFIG_BAUDSHIFT;
 461      /* Documentation says 14, but toshiba use 15 in their drivers */
 462      pconfig |= 15 << OBOE_PCONFIG_PREAMBLESHIFT;
 463      config0l = OBOE_CONFIG0L_ENFIR;
 464      break;
 465    }
 466
 467  /* Copy into new PHY config buffer */
 468  OUTBP (pconfig >> 8, OBOE_NEW_PCONFIGH);
 469  OUTB (pconfig & 0xff, OBOE_NEW_PCONFIGL);
 470  OUTB (config0l, OBOE_CONFIG0L);
 471
 472  /* Now make OBOE copy from new PHY to current PHY */
 473  OUTB (0x0, OBOE_ENABLEH);
 474  OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
 475  PROMPT;
 476
 477  /* speed change executed */
 478  self->new_speed = 0;
 479  self->io.speed = self->speed;
 480}
 481
 482/*Let the chip look at memory */
 483static void
 484toshoboe_enablebm (struct toshoboe_cb *self)
 485{
 486  IRDA_DEBUG (4, "%s()\n", __func__);
 487  pci_set_master (self->pdev);
 488}
 489
 490/*setup the ring */
 491static void
 492toshoboe_initring (struct toshoboe_cb *self)
 493{
 494  int i;
 495
 496  IRDA_DEBUG (4, "%s()\n", __func__);
 497
 498  for (i = 0; i < TX_SLOTS; ++i)
 499    {
 500      self->ring->tx[i].len = 0;
 501      self->ring->tx[i].control = 0x00;
 502      self->ring->tx[i].address = virt_to_bus (self->tx_bufs[i]);
 503    }
 504
 505  for (i = 0; i < RX_SLOTS; ++i)
 506    {
 507      self->ring->rx[i].len = RX_LEN;
 508      self->ring->rx[i].len = 0;
 509      self->ring->rx[i].address = virt_to_bus (self->rx_bufs[i]);
 510      self->ring->rx[i].control = OBOE_CTL_RX_HW_OWNS;
 511    }
 512}
 513
 514static void
 515toshoboe_resetptrs (struct toshoboe_cb *self)
 516{
 517  /* Can reset pointers by twidling DMA */
 518  OUTB (0x0, OBOE_ENABLEH);
 519  OUTBP (CONFIG0H_DMA_OFF, OBOE_CONFIG0H);
 520  OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
 521
 522  self->rxs = inb_p (OBOE_RXSLOT) & OBOE_SLOT_MASK;
 523  self->txs = inb_p (OBOE_TXSLOT) & OBOE_SLOT_MASK;
 524}
 525
 526/* Called in locked state */
 527static void
 528toshoboe_initptrs (struct toshoboe_cb *self)
 529{
 530
 531  /* spin_lock_irqsave(self->spinlock, flags); */
 532  /* save_flags (flags); */
 533
 534  /* Can reset pointers by twidling DMA */
 535  toshoboe_resetptrs (self);
 536
 537  OUTB (0x0, OBOE_ENABLEH);
 538  OUTB (CONFIG0H_DMA_ON, OBOE_CONFIG0H);
 539  OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
 540
 541  self->txpending = 0;
 542
 543  /* spin_unlock_irqrestore(self->spinlock, flags); */
 544  /* restore_flags (flags); */
 545}
 546
 547/* Wake the chip up and get it looking at the rings */
 548/* Called in locked state */
 549static void
 550toshoboe_startchip (struct toshoboe_cb *self)
 551{
 552  __u32 physaddr;
 553
 554  IRDA_DEBUG (4, "%s()\n", __func__);
 555
 556  toshoboe_initring (self);
 557  toshoboe_enablebm (self);
 558  OUTBP (OBOE_CONFIG1_RESET, OBOE_CONFIG1);
 559  OUTBP (OBOE_CONFIG1_ON, OBOE_CONFIG1);
 560
 561  /* Stop the clocks */
 562  OUTB (0, OBOE_ENABLEH);
 563
 564  /*Set size of rings */
 565  OUTB (RING_SIZE, OBOE_RING_SIZE);
 566
 567  /*Acknoledge any pending interrupts */
 568  OUTB (0xff, OBOE_ISR);
 569
 570  /*Enable ints */
 571  OUTB (OBOE_INT_TXDONE  | OBOE_INT_RXDONE |
 572        OBOE_INT_TXUNDER | OBOE_INT_RXOVER | OBOE_INT_SIP , OBOE_IER);
 573
 574  /*Acknoledge any pending interrupts */
 575  OUTB (0xff, OBOE_ISR);
 576
 577  /*Set the maximum packet length to 0xfff (4095) */
 578  OUTB (RX_LEN >> 8, OBOE_MAXLENH);
 579  OUTB (RX_LEN & 0xff, OBOE_MAXLENL);
 580
 581  /*Shutdown DMA */
 582  OUTB (CONFIG0H_DMA_OFF, OBOE_CONFIG0H);
 583
 584  /*Find out where the rings live */
 585  physaddr = virt_to_bus (self->ring);
 586
 587  IRDA_ASSERT ((physaddr & 0x3ff) == 0,
 588	       printk (KERN_ERR DRIVER_NAME "ring not correctly aligned\n");
 589	       return;);
 590
 591  OUTB ((physaddr >> 10) & 0xff, OBOE_RING_BASE0);
 592  OUTB ((physaddr >> 18) & 0xff, OBOE_RING_BASE1);
 593  OUTB ((physaddr >> 26) & 0x3f, OBOE_RING_BASE2);
 594
 595  /*Enable DMA controller in byte mode and RX */
 596  OUTB (CONFIG0H_DMA_ON, OBOE_CONFIG0H);
 597
 598  /* Start up the clocks */
 599  OUTB (OBOE_ENABLEH_PHYANDCLOCK, OBOE_ENABLEH);
 600
 601  /*set to sensible speed */
 602  self->speed = 9600;
 603  toshoboe_setbaud (self);
 604  toshoboe_initptrs (self);
 605}
 606
 607static void
 608toshoboe_isntstuck (struct toshoboe_cb *self)
 609{
 610}
 611
 612static void
 613toshoboe_checkstuck (struct toshoboe_cb *self)
 614{
 615  unsigned long flags;
 616
 617  if (0)
 618    {
 619      spin_lock_irqsave(&self->spinlock, flags);
 620
 621      /* This will reset the chip completely */
 622      printk (KERN_ERR DRIVER_NAME ": Resetting chip\n");
 623
 624      toshoboe_stopchip (self);
 625      toshoboe_startchip (self);
 626      spin_unlock_irqrestore(&self->spinlock, flags);
 627    }
 628}
 629
 630/*Generate packet of about mtt us long */
 631static int
 632toshoboe_makemttpacket (struct toshoboe_cb *self, void *buf, int mtt)
 633{
 634  int xbofs;
 635
 636  xbofs = ((int) (mtt/100)) * (int) (self->speed);
 637  xbofs=xbofs/80000; /*Eight bits per byte, and mtt is in us*/
 638  xbofs++;
 639
 640  IRDA_DEBUG (2, DRIVER_NAME
 641      ": generated mtt of %d bytes for %d us at %d baud\n"
 642	  , xbofs,mtt,self->speed);
 643
 644  if (xbofs > TX_LEN)
 645    {
 646      printk (KERN_ERR DRIVER_NAME ": wanted %d bytes MTT but TX_LEN is %d\n",
 647              xbofs, TX_LEN);
 648      xbofs = TX_LEN;
 649    }
 650
 651  /*xbofs will do for SIR, MIR and FIR,SIR mode doesn't generate a checksum anyway */
 652  memset (buf, XBOF, xbofs);
 653
 654  return xbofs;
 655}
 656
 657#ifdef USE_PROBE
 658/***********************************************************************/
 659/* Probe code */
 660
 661static void
 662toshoboe_dumptx (struct toshoboe_cb *self)
 663{
 664  int i;
 665  PROBE_DEBUG(KERN_WARNING "TX:");
 666  for (i = 0; i < RX_SLOTS; ++i)
 667    PROBE_DEBUG(" (%d,%02x)",self->ring->tx[i].len,self->ring->tx[i].control);
 668  PROBE_DEBUG(" [%d]\n",self->speed);
 669}
 670
 671static void
 672toshoboe_dumprx (struct toshoboe_cb *self, int score)
 673{
 674  int i;
 675  PROBE_DEBUG(" %d\nRX:",score);
 676  for (i = 0; i < RX_SLOTS; ++i)
 677    PROBE_DEBUG(" (%d,%02x)",self->ring->rx[i].len,self->ring->rx[i].control);
 678  PROBE_DEBUG("\n");
 679}
 680
 681static inline int
 682stuff_byte (__u8 byte, __u8 * buf)
 683{
 684  switch (byte)
 685    {
 686    case BOF:                  /* FALLTHROUGH */
 687    case EOF:                  /* FALLTHROUGH */
 688    case CE:
 689      /* Insert transparently coded */
 690      buf[0] = CE;              /* Send link escape */
 691      buf[1] = byte ^ IRDA_TRANS; /* Complement bit 5 */
 692      return 2;
 693      /* break; */
 694    default:
 695      /* Non-special value, no transparency required */
 696      buf[0] = byte;
 697      return 1;
 698      /* break; */
 699    }
 700}
 701
 702static irqreturn_t
 703toshoboe_probeinterrupt (int irq, void *dev_id)
 704{
 705  struct toshoboe_cb *self = dev_id;
 706  __u8 irqstat;
 707
 708  irqstat = INB (OBOE_ISR);
 709
 710/* was it us */
 711  if (!(irqstat & OBOE_INT_MASK))
 712    return IRQ_NONE;
 713
 714/* Ack all the interrupts */
 715  OUTB (irqstat, OBOE_ISR);
 716
 717  if (irqstat & OBOE_INT_TXDONE)
 718    {
 719      int txp;
 720
 721      self->int_tx++;
 722      PROBE_DEBUG("T");
 723
 724      txp = INB (OBOE_TXSLOT) & OBOE_SLOT_MASK;
 725      if (self->ring->tx[txp].control & OBOE_CTL_TX_HW_OWNS)
 726        {
 727          self->int_tx+=100;
 728          PROBE_DEBUG("S");
 729          toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
 730        }
 731    }
 732
 733  if (irqstat & OBOE_INT_RXDONE) {
 734    self->int_rx++;
 735    PROBE_DEBUG("R"); }
 736  if (irqstat & OBOE_INT_TXUNDER) {
 737    self->int_txunder++;
 738    PROBE_DEBUG("U"); }
 739  if (irqstat & OBOE_INT_RXOVER) {
 740    self->int_rxover++;
 741    PROBE_DEBUG("O"); }
 742  if (irqstat & OBOE_INT_SIP) {
 743    self->int_sip++;
 744    PROBE_DEBUG("I"); }
 745  return IRQ_HANDLED;
 746}
 747
 748static int
 749toshoboe_maketestpacket (unsigned char *buf, int badcrc, int fir)
 750{
 751  int i;
 752  int len = 0;
 753  union
 754  {
 755    __u16 value;
 756    __u8 bytes[2];
 757  }
 758  fcs;
 759
 760  if (fir)
 761    {
 762      memset (buf, 0, TT_LEN);
 763      return TT_LEN;
 764    }
 765
 766  fcs.value = INIT_FCS;
 767
 768  memset (buf, XBOF, 10);
 769  len += 10;
 770  buf[len++] = BOF;
 771
 772  for (i = 0; i < TT_LEN; ++i)
 773    {
 774      len += stuff_byte (i, buf + len);
 775      fcs.value = irda_fcs (fcs.value, i);
 776    }
 777
 778  len += stuff_byte (fcs.bytes[0] ^ badcrc, buf + len);
 779  len += stuff_byte (fcs.bytes[1] ^ badcrc, buf + len);
 780  buf[len++] = EOF;
 781  len++;
 782  return len;
 783}
 784
 785static int
 786toshoboe_probefail (struct toshoboe_cb *self, char *msg)
 787{
 788  printk (KERN_ERR DRIVER_NAME "probe(%d) failed %s\n",self-> speed, msg);
 789  toshoboe_dumpregs (self);
 790  toshoboe_stopchip (self);
 791  free_irq (self->io.irq, (void *) self);
 792  return 0;
 793}
 794
 795static int
 796toshoboe_numvalidrcvs (struct toshoboe_cb *self)
 797{
 798  int i, ret = 0;
 799  for (i = 0; i < RX_SLOTS; ++i)
 800    if ((self->ring->rx[i].control & 0xe0) == 0)
 801      ret++;
 802
 803  return ret;
 804}
 805
 806static int
 807toshoboe_numrcvs (struct toshoboe_cb *self)
 808{
 809  int i, ret = 0;
 810  for (i = 0; i < RX_SLOTS; ++i)
 811    if (!(self->ring->rx[i].control & OBOE_CTL_RX_HW_OWNS))
 812      ret++;
 813
 814  return ret;
 815}
 816
 817static int
 818toshoboe_probe (struct toshoboe_cb *self)
 819{
 820  int i, j, n;
 821#ifdef USE_MIR
 822  static const int bauds[] = { 9600, 115200, 4000000, 1152000 };
 823#else
 824  static const int bauds[] = { 9600, 115200, 4000000 };
 825#endif
 826  unsigned long flags;
 827
 828  IRDA_DEBUG (4, "%s()\n", __func__);
 829
 830  if (request_irq (self->io.irq, toshoboe_probeinterrupt,
 831                   self->io.irqflags, "toshoboe", (void *) self))
 832    {
 833      printk (KERN_ERR DRIVER_NAME ": probe failed to allocate irq %d\n",
 834              self->io.irq);
 835      return 0;
 836    }
 837
 838  /* test 1: SIR filter and back to back */
 839
 840  for (j = 0; j < ARRAY_SIZE(bauds); ++j)
 841    {
 842      int fir = (j > 1);
 843      toshoboe_stopchip (self);
 844
 845
 846      spin_lock_irqsave(&self->spinlock, flags);
 847      /*Address is already setup */
 848      toshoboe_startchip (self);
 849      self->int_rx = self->int_tx = 0;
 850      self->speed = bauds[j];
 851      toshoboe_setbaud (self);
 852      toshoboe_initptrs (self);
 853      spin_unlock_irqrestore(&self->spinlock, flags);
 854
 855      self->ring->tx[self->txs].control =
 856/*   (FIR only) OBOE_CTL_TX_SIP needed for switching to next slot */
 857/*    MIR: all received data is stored in one slot */
 858        (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX
 859              : OBOE_CTL_TX_HW_OWNS ;
 860      self->ring->tx[self->txs].len =
 861        toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
 862      self->txs++;
 863      self->txs %= TX_SLOTS;
 864
 865      self->ring->tx[self->txs].control =
 866        (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_SIP
 867              : OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX ;
 868      self->ring->tx[self->txs].len =
 869        toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
 870      self->txs++;
 871      self->txs %= TX_SLOTS;
 872
 873      self->ring->tx[self->txs].control =
 874        (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX
 875              : OBOE_CTL_TX_HW_OWNS ;
 876      self->ring->tx[self->txs].len =
 877        toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
 878      self->txs++;
 879      self->txs %= TX_SLOTS;
 880
 881      self->ring->tx[self->txs].control =
 882        (fir) ? OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX
 883              | OBOE_CTL_TX_SIP     | OBOE_CTL_TX_BAD_CRC
 884              : OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX ;
 885      self->ring->tx[self->txs].len =
 886        toshoboe_maketestpacket (self->tx_bufs[self->txs], 0, fir);
 887      self->txs++;
 888      self->txs %= TX_SLOTS;
 889
 890      toshoboe_dumptx (self);
 891      /* Turn on TX and RX and loopback */
 892      toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
 893
 894      i = 0;
 895      n = fir ? 1 : 4;
 896      while (toshoboe_numvalidrcvs (self) != n)
 897        {
 898          if (i > 4800)
 899              return toshoboe_probefail (self, "filter test");
 900          udelay ((9600*(TT_LEN+16))/self->speed);
 901          i++;
 902        }
 903
 904      n = fir ? 203 : 102;
 905      while ((toshoboe_numrcvs(self) != self->int_rx) || (self->int_tx != n))
 906        {
 907          if (i > 4800)
 908              return toshoboe_probefail (self, "interrupt test");
 909          udelay ((9600*(TT_LEN+16))/self->speed);
 910          i++;
 911        }
 912     toshoboe_dumprx (self,i);
 913
 914     }
 915
 916  /* test 2: SIR in char at a time */
 917
 918  toshoboe_stopchip (self);
 919  self->int_rx = self->int_tx = 0;
 920
 921  spin_lock_irqsave(&self->spinlock, flags);
 922  toshoboe_startchip (self);
 923  spin_unlock_irqrestore(&self->spinlock, flags);
 924
 925  self->async = 1;
 926  self->speed = 115200;
 927  toshoboe_setbaud (self);
 928  self->ring->tx[self->txs].control =
 929    OBOE_CTL_TX_RTCENTX | OBOE_CTL_TX_HW_OWNS;
 930  self->ring->tx[self->txs].len = 4;
 931
 932  ((unsigned char *) self->tx_bufs[self->txs])[0] = 'f';
 933  ((unsigned char *) self->tx_bufs[self->txs])[1] = 'i';
 934  ((unsigned char *) self->tx_bufs[self->txs])[2] = 's';
 935  ((unsigned char *) self->tx_bufs[self->txs])[3] = 'h';
 936  toshoboe_dumptx (self);
 937  toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
 938
 939  i = 0;
 940  while (toshoboe_numvalidrcvs (self) != 4)
 941    {
 942      if (i > 100)
 943          return toshoboe_probefail (self, "Async test");
 944      udelay (100);
 945      i++;
 946    }
 947
 948  while ((toshoboe_numrcvs (self) != self->int_rx) || (self->int_tx != 1))
 949    {
 950      if (i > 100)
 951          return toshoboe_probefail (self, "Async interrupt test");
 952      udelay (100);
 953      i++;
 954    }
 955  toshoboe_dumprx (self,i);
 956
 957  self->async = 0;
 958  self->speed = 9600;
 959  toshoboe_setbaud (self);
 960  toshoboe_stopchip (self);
 961
 962  free_irq (self->io.irq, (void *) self);
 963
 964  printk (KERN_WARNING DRIVER_NAME ": Self test passed ok\n");
 965
 966  return 1;
 967}
 968#endif
 969
 970/******************************************************************/
 971/* Netdev style code */
 972
 973/* Transmit something */
 974static netdev_tx_t
 975toshoboe_hard_xmit (struct sk_buff *skb, struct net_device *dev)
 976{
 977  struct toshoboe_cb *self;
 978  __s32 speed;
 979  int mtt, len, ctl;
 980  unsigned long flags;
 981  struct irda_skb_cb *cb = (struct irda_skb_cb *) skb->cb;
 982
 983  self = netdev_priv(dev);
 984
 985  IRDA_ASSERT (self != NULL, return NETDEV_TX_OK; );
 986
 987  IRDA_DEBUG (1, "%s.tx:%x(%x)%x\n", __func__
 988      ,skb->len,self->txpending,INB (OBOE_ENABLEH));
 989  if (!cb->magic) {
 990      IRDA_DEBUG (2, "%s.Not IrLAP:%x\n", __func__, cb->magic);
 991#ifdef DUMP_PACKETS
 992      _dumpbufs(skb->data,skb->len,'>');
 993#endif
 994    }
 995
 996  /* change speed pending, wait for its execution */
 997  if (self->new_speed)
 998      return NETDEV_TX_BUSY;
 999
1000  /* device stopped (apm) wait for restart */
1001  if (self->stopped)
1002      return NETDEV_TX_BUSY;
1003
1004  toshoboe_checkstuck (self);
1005
1006 /* Check if we need to change the speed */
1007  /* But not now. Wait after transmission if mtt not required */
1008  speed=irda_get_next_speed(skb);
1009  if ((speed != self->io.speed) && (speed != -1))
1010    {
1011      spin_lock_irqsave(&self->spinlock, flags);
1012
1013      if (self->txpending || skb->len)
1014        {
1015          self->new_speed = speed;
1016          IRDA_DEBUG (1, "%s: Queued TxDone scheduled speed change %d\n" ,
1017		      __func__, speed);
1018          /* if no data, that's all! */
1019          if (!skb->len)
1020            {
1021	      spin_unlock_irqrestore(&self->spinlock, flags);
1022              dev_kfree_skb (skb);
1023              return NETDEV_TX_OK;
1024            }
1025          /* True packet, go on, but */
1026          /* do not accept anything before change speed execution */
1027          netif_stop_queue(dev);
1028          /* ready to process TxDone interrupt */
1029	  spin_unlock_irqrestore(&self->spinlock, flags);
1030        }
1031      else
1032        {
1033          /* idle and no data, change speed now */
1034          self->speed = speed;
1035          toshoboe_setbaud (self);
1036	  spin_unlock_irqrestore(&self->spinlock, flags);
1037          dev_kfree_skb (skb);
1038          return NETDEV_TX_OK;
1039        }
1040
1041    }
1042
1043  if ((mtt = irda_get_mtt(skb)))
1044    {
1045      /* This is fair since the queue should be empty anyway */
1046      spin_lock_irqsave(&self->spinlock, flags);
1047
1048      if (self->txpending)
1049        {
1050	  spin_unlock_irqrestore(&self->spinlock, flags);
1051          return NETDEV_TX_BUSY;
1052        }
1053
1054      /* If in SIR mode we need to generate a string of XBOFs */
1055      /* In MIR and FIR we need to generate a string of data */
1056      /* which we will add a wrong checksum to */
1057
1058      mtt = toshoboe_makemttpacket (self, self->tx_bufs[self->txs], mtt);
1059      IRDA_DEBUG (1, "%s.mtt:%x(%x)%d\n", __func__
1060          ,skb->len,mtt,self->txpending);
1061      if (mtt)
1062        {
1063          self->ring->tx[self->txs].len = mtt & 0xfff;
1064
1065          ctl = OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX;
1066          if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_FIRON)
1067            {
1068              ctl |= OBOE_CTL_TX_BAD_CRC | OBOE_CTL_TX_SIP ;
1069            }
1070#ifdef USE_MIR
1071          else if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_MIRON)
1072            {
1073              ctl |= OBOE_CTL_TX_BAD_CRC;
1074            }
1075#endif
1076          self->ring->tx[self->txs].control = ctl;
1077
1078          OUTB (0x0, OBOE_ENABLEH);
1079          /* It is only a timer. Do not send mtt packet outside! */
1080          toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX | OBOE_CONFIG0H_LOOP);
1081
1082          self->txpending++;
1083
1084          self->txs++;
1085          self->txs %= TX_SLOTS;
1086
1087        }
1088      else
1089        {
1090          printk(KERN_ERR DRIVER_NAME ": problem with mtt packet - ignored\n");
1091        }
1092      spin_unlock_irqrestore(&self->spinlock, flags);
1093    }
1094
1095#ifdef DUMP_PACKETS
1096dumpbufs(skb->data,skb->len,'>');
1097#endif
1098
1099  spin_lock_irqsave(&self->spinlock, flags);
1100
1101  if (self->ring->tx[self->txs].control & OBOE_CTL_TX_HW_OWNS)
1102    {
1103      IRDA_DEBUG (0, "%s.ful:%x(%x)%x\n", __func__
1104          ,skb->len, self->ring->tx[self->txs].control, self->txpending);
 
1105      toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
1106      spin_unlock_irqrestore(&self->spinlock, flags);
1107      return NETDEV_TX_BUSY;
1108    }
1109
1110  if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_SIRON)
1111    {
1112      len = async_wrap_skb (skb, self->tx_bufs[self->txs], TX_BUF_SZ);
1113    }
1114  else
1115    {
1116      len = skb->len;
1117      skb_copy_from_linear_data(skb, self->tx_bufs[self->txs], len);
1118    }
1119  self->ring->tx[self->txs].len = len & 0x0fff;
1120
1121  /*Sometimes the HW doesn't see us assert RTCENTX in the interrupt code */
1122  /*later this plays safe, we garuntee the last packet to be transmitted */
1123  /*has RTCENTX set */
1124
1125  ctl = OBOE_CTL_TX_HW_OWNS | OBOE_CTL_TX_RTCENTX;
1126  if (INB (OBOE_ENABLEH) & OBOE_ENABLEH_FIRON)
1127    {
1128      ctl |= OBOE_CTL_TX_SIP ;
1129    }
1130  self->ring->tx[self->txs].control = ctl;
1131
1132  /* If transmitter is idle start in one-shot mode */
1133
1134  if (!self->txpending)
1135      toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
1136
1137  self->txpending++;
1138
1139  self->txs++;
1140  self->txs %= TX_SLOTS;
1141
1142  spin_unlock_irqrestore(&self->spinlock, flags);
1143  dev_kfree_skb (skb);
1144
1145  return NETDEV_TX_OK;
1146}
1147
1148/*interrupt handler */
1149static irqreturn_t
1150toshoboe_interrupt (int irq, void *dev_id)
1151{
1152  struct toshoboe_cb *self = dev_id;
1153  __u8 irqstat;
1154  struct sk_buff *skb = NULL;
1155
1156  irqstat = INB (OBOE_ISR);
1157
1158/* was it us */
1159  if (!(irqstat & OBOE_INT_MASK))
1160      return IRQ_NONE;
1161
1162/* Ack all the interrupts */
1163  OUTB (irqstat, OBOE_ISR);
1164
1165  toshoboe_isntstuck (self);
1166
1167/* Txdone */
1168  if (irqstat & OBOE_INT_TXDONE)
1169    {
1170      int txp, txpc;
1171      int i;
1172
1173      txp = self->txpending;
1174      self->txpending = 0;
1175
1176      for (i = 0; i < TX_SLOTS; ++i)
1177        {
1178          if (self->ring->tx[i].control & OBOE_CTL_TX_HW_OWNS)
1179              self->txpending++;
1180        }
1181      IRDA_DEBUG (1, "%s.txd(%x)%x/%x\n", __func__
1182          ,irqstat,txp,self->txpending);
1183
1184      txp = INB (OBOE_TXSLOT) & OBOE_SLOT_MASK;
1185
1186      /* Got anything queued ? start it together */
1187      if (self->ring->tx[txp].control & OBOE_CTL_TX_HW_OWNS)
1188        {
1189          txpc = txp;
1190#ifdef OPTIMIZE_TX
1191          while (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS)
1192            {
1193              txp = txpc;
1194              txpc++;
1195              txpc %= TX_SLOTS;
1196              self->netdev->stats.tx_packets++;
1197              if (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS)
1198                  self->ring->tx[txp].control &= ~OBOE_CTL_TX_RTCENTX;
1199            }
1200          self->netdev->stats.tx_packets--;
1201#else
1202          self->netdev->stats.tx_packets++;
1203#endif
1204          toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
1205        }
1206
1207      if ((!self->txpending) && (self->new_speed))
1208        {
1209          self->speed = self->new_speed;
1210          IRDA_DEBUG (1, "%s: Executed TxDone scheduled speed change %d\n",
1211		      __func__, self->speed);
1212          toshoboe_setbaud (self);
1213        }
1214
1215      /* Tell network layer that we want more frames */
1216      if (!self->new_speed)
1217          netif_wake_queue(self->netdev);
1218    }
1219
1220  if (irqstat & OBOE_INT_RXDONE)
1221    {
1222      while (!(self->ring->rx[self->rxs].control & OBOE_CTL_RX_HW_OWNS))
1223        {
1224          int len = self->ring->rx[self->rxs].len;
1225          skb = NULL;
1226          IRDA_DEBUG (3, "%s.rcv:%x(%x)\n", __func__
1227		      ,len,self->ring->rx[self->rxs].control);
1228
1229#ifdef DUMP_PACKETS
1230dumpbufs(self->rx_bufs[self->rxs],len,'<');
1231#endif
1232
1233          if (self->ring->rx[self->rxs].control == 0)
1234            {
1235              __u8 enable = INB (OBOE_ENABLEH);
1236
1237              /* In SIR mode we need to check the CRC as this */
1238              /* hasn't been done by the hardware */
1239              if (enable & OBOE_ENABLEH_SIRON)
1240                {
1241                  if (!toshoboe_checkfcs (self->rx_bufs[self->rxs], len))
1242                      len = 0;
1243                  /*Trim off the CRC */
1244                  if (len > 1)
1245                      len -= 2;
1246                  else
1247                      len = 0;
1248                  IRDA_DEBUG (1, "%s.SIR:%x(%x)\n", __func__, len,enable);
1249                }
1250
1251#ifdef USE_MIR
1252              else if (enable & OBOE_ENABLEH_MIRON)
1253                {
1254                  if (len > 1)
1255                      len -= 2;
1256                  else
1257                      len = 0;
1258                  IRDA_DEBUG (2, "%s.MIR:%x(%x)\n", __func__, len,enable);
1259                }
1260#endif
1261              else if (enable & OBOE_ENABLEH_FIRON)
1262                {
1263                  if (len > 3)
1264                      len -= 4;   /*FIXME: check this */
1265                  else
1266                      len = 0;
1267                  IRDA_DEBUG (1, "%s.FIR:%x(%x)\n", __func__, len,enable);
1268                }
1269              else
1270                  IRDA_DEBUG (0, "%s.?IR:%x(%x)\n", __func__, len,enable);
1271
1272              if (len)
1273                {
1274                  skb = dev_alloc_skb (len + 1);
1275                  if (skb)
1276                    {
1277                      skb_reserve (skb, 1);
1278
1279                      skb_put (skb, len);
1280                      skb_copy_to_linear_data(skb, self->rx_bufs[self->rxs],
1281					      len);
1282                      self->netdev->stats.rx_packets++;
1283                      skb->dev = self->netdev;
1284                      skb_reset_mac_header(skb);
1285                      skb->protocol = htons (ETH_P_IRDA);
1286                    }
1287                  else
1288                    {
1289                      printk (KERN_INFO
1290                              "%s(), memory squeeze, dropping frame.\n",
1291			      __func__);
1292                    }
1293                }
1294            }
1295          else
1296            {
1297            /* TODO: =========================================== */
1298            /*  if OBOE_CTL_RX_LENGTH, our buffers are too small */
1299            /* (MIR or FIR) data is lost. */
1300            /* (SIR) data is splitted in several slots. */
1301            /* we have to join all the received buffers received */
1302            /*in a large buffer before checking CRC. */
1303            IRDA_DEBUG (0, "%s.err:%x(%x)\n", __func__
1304                ,len,self->ring->rx[self->rxs].control);
1305            }
1306
1307          self->ring->rx[self->rxs].len = 0x0;
1308          self->ring->rx[self->rxs].control = OBOE_CTL_RX_HW_OWNS;
1309
1310          self->rxs++;
1311          self->rxs %= RX_SLOTS;
1312
1313          if (skb)
1314              netif_rx (skb);
1315
1316        }
1317    }
1318
1319  if (irqstat & OBOE_INT_TXUNDER)
1320    {
1321      printk (KERN_WARNING DRIVER_NAME ": tx fifo underflow\n");
1322    }
1323  if (irqstat & OBOE_INT_RXOVER)
1324    {
1325      printk (KERN_WARNING DRIVER_NAME ": rx fifo overflow\n");
1326    }
1327/* This must be useful for something... */
1328  if (irqstat & OBOE_INT_SIP)
1329    {
1330      self->int_sip++;
1331      IRDA_DEBUG (1, "%s.sip:%x(%x)%x\n", __func__
1332	      ,self->int_sip,irqstat,self->txpending);
1333    }
1334  return IRQ_HANDLED;
1335}
1336
1337
1338static int
1339toshoboe_net_open (struct net_device *dev)
1340{
1341  struct toshoboe_cb *self;
1342  unsigned long flags;
1343  int rc;
1344
1345  IRDA_DEBUG (4, "%s()\n", __func__);
1346
1347  self = netdev_priv(dev);
1348
1349  if (self->async)
1350    return -EBUSY;
1351
1352  if (self->stopped)
1353    return 0;
1354
1355  rc = request_irq (self->io.irq, toshoboe_interrupt,
1356                    IRQF_SHARED | IRQF_DISABLED, dev->name, self);
1357  if (rc)
1358  	return rc;
1359
1360  spin_lock_irqsave(&self->spinlock, flags);
1361  toshoboe_startchip (self);
1362  spin_unlock_irqrestore(&self->spinlock, flags);
1363
1364  /* Ready to play! */
1365  netif_start_queue(dev);
1366
1367  /*
1368   * Open new IrLAP layer instance, now that everything should be
1369   * initialized properly
1370   */
1371  self->irlap = irlap_open (dev, &self->qos, driver_name);
1372
1373  self->irdad = 1;
1374
1375  return 0;
1376}
1377
1378static int
1379toshoboe_net_close (struct net_device *dev)
1380{
1381  struct toshoboe_cb *self;
1382
1383  IRDA_DEBUG (4, "%s()\n", __func__);
1384
1385  IRDA_ASSERT (dev != NULL, return -1; );
1386  self = netdev_priv(dev);
1387
1388  /* Stop device */
1389  netif_stop_queue(dev);
1390
1391  /* Stop and remove instance of IrLAP */
1392  if (self->irlap)
1393    irlap_close (self->irlap);
1394  self->irlap = NULL;
1395
1396  self->irdad = 0;
1397
1398  free_irq (self->io.irq, (void *) self);
1399
1400  if (!self->stopped)
1401    {
1402      toshoboe_stopchip (self);
1403    }
1404
1405  return 0;
1406}
1407
1408/*
1409 * Function toshoboe_net_ioctl (dev, rq, cmd)
1410 *
1411 *    Process IOCTL commands for this device
1412 *
1413 */
1414static int
1415toshoboe_net_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1416{
1417  struct if_irda_req *irq = (struct if_irda_req *) rq;
1418  struct toshoboe_cb *self;
1419  unsigned long flags;
1420  int ret = 0;
1421
1422  IRDA_ASSERT (dev != NULL, return -1; );
1423
1424  self = netdev_priv(dev);
1425
1426  IRDA_ASSERT (self != NULL, return -1; );
1427
1428  IRDA_DEBUG (5, "%s(), %s, (cmd=0x%X)\n", __func__, dev->name, cmd);
1429
1430  /* Disable interrupts & save flags */
1431  spin_lock_irqsave(&self->spinlock, flags);
1432
1433  switch (cmd)
1434    {
1435    case SIOCSBANDWIDTH:       /* Set bandwidth */
1436      /* This function will also be used by IrLAP to change the
1437       * speed, so we still must allow for speed change within
1438       * interrupt context.
1439       */
1440      IRDA_DEBUG (1, "%s(BANDWIDTH), %s, (%X/%ld\n", __func__
1441          ,dev->name, INB (OBOE_STATUS), irq->ifr_baudrate );
1442      if (!in_interrupt () && !capable (CAP_NET_ADMIN)) {
1443	ret = -EPERM;
1444	goto out;
1445      }
1446
1447      /* self->speed=irq->ifr_baudrate; */
1448      /* toshoboe_setbaud(self); */
1449      /* Just change speed once - inserted by Paul Bristow */
1450      self->new_speed = irq->ifr_baudrate;
1451      break;
1452    case SIOCSMEDIABUSY:       /* Set media busy */
1453      IRDA_DEBUG (1, "%s(MEDIABUSY), %s, (%X/%x)\n", __func__
1454          ,dev->name, INB (OBOE_STATUS), capable (CAP_NET_ADMIN) );
 
1455      if (!capable (CAP_NET_ADMIN)) {
1456	ret = -EPERM;
1457	goto out;
1458      }
1459      irda_device_set_media_busy (self->netdev, TRUE);
1460      break;
1461    case SIOCGRECEIVING:       /* Check if we are receiving right now */
1462      irq->ifr_receiving = (INB (OBOE_STATUS) & OBOE_STATUS_RXBUSY) ? 1 : 0;
1463      IRDA_DEBUG (3, "%s(RECEIVING), %s, (%X/%x)\n", __func__
1464          ,dev->name, INB (OBOE_STATUS), irq->ifr_receiving );
1465      break;
1466    default:
1467      IRDA_DEBUG (1, "%s(?), %s, (cmd=0x%X)\n", __func__, dev->name, cmd);
1468      ret = -EOPNOTSUPP;
1469    }
1470out:
1471  spin_unlock_irqrestore(&self->spinlock, flags);
1472  return ret;
1473
1474}
1475
1476MODULE_DESCRIPTION("Toshiba OBOE IrDA Device Driver");
1477MODULE_AUTHOR("James McKenzie <james@fishsoup.dhs.org>");
1478MODULE_LICENSE("GPL");
1479
1480module_param (max_baud, int, 0);
1481MODULE_PARM_DESC(max_baud, "Maximum baud rate");
1482
1483#ifdef USE_PROBE
1484module_param (do_probe, bool, 0);
1485MODULE_PARM_DESC(do_probe, "Enable/disable chip probing and self-test");
1486#endif
1487
1488static void
1489toshoboe_close (struct pci_dev *pci_dev)
1490{
1491  int i;
1492  struct toshoboe_cb *self = (struct toshoboe_cb*)pci_get_drvdata(pci_dev);
1493
1494  IRDA_DEBUG (4, "%s()\n", __func__);
1495
1496  IRDA_ASSERT (self != NULL, return; );
1497
1498  if (!self->stopped)
1499    {
1500      toshoboe_stopchip (self);
1501    }
1502
1503  release_region (self->io.fir_base, self->io.fir_ext);
1504
1505  for (i = 0; i < TX_SLOTS; ++i)
1506    {
1507      kfree (self->tx_bufs[i]);
1508      self->tx_bufs[i] = NULL;
1509    }
1510
1511  for (i = 0; i < RX_SLOTS; ++i)
1512    {
1513      kfree (self->rx_bufs[i]);
1514      self->rx_bufs[i] = NULL;
1515    }
1516
1517  unregister_netdev(self->netdev);
1518
1519  kfree (self->ringbuf);
1520  self->ringbuf = NULL;
1521  self->ring = NULL;
1522
1523  free_netdev(self->netdev);
1524}
1525
1526static const struct net_device_ops toshoboe_netdev_ops = {
1527	.ndo_open	= toshoboe_net_open,
1528	.ndo_stop	= toshoboe_net_close,
1529	.ndo_start_xmit	= toshoboe_hard_xmit,
1530	.ndo_do_ioctl	= toshoboe_net_ioctl,
1531};
1532
1533static int
1534toshoboe_open (struct pci_dev *pci_dev, const struct pci_device_id *pdid)
1535{
1536  struct toshoboe_cb *self;
1537  struct net_device *dev;
1538  int i = 0;
1539  int ok = 0;
1540  int err;
1541
1542  IRDA_DEBUG (4, "%s()\n", __func__);
1543
1544  if ((err=pci_enable_device(pci_dev)))
1545    return err;
1546
1547  dev = alloc_irdadev(sizeof (struct toshoboe_cb));
1548  if (dev == NULL)
1549    {
1550      printk (KERN_ERR DRIVER_NAME ": can't allocate memory for "
1551              "IrDA control block\n");
1552      return -ENOMEM;
1553    }
1554
1555  self = netdev_priv(dev);
1556  self->netdev = dev;
1557  self->pdev = pci_dev;
1558  self->base = pci_resource_start(pci_dev,0);
1559
1560  self->io.fir_base = self->base;
1561  self->io.fir_ext = OBOE_IO_EXTENT;
1562  self->io.irq = pci_dev->irq;
1563  self->io.irqflags = IRQF_SHARED | IRQF_DISABLED;
1564
1565  self->speed = self->io.speed = 9600;
1566  self->async = 0;
1567
1568  /* Lock the port that we need */
1569  if (NULL==request_region (self->io.fir_base, self->io.fir_ext, driver_name))
1570    {
1571      printk (KERN_ERR DRIVER_NAME ": can't get iobase of 0x%03x\n"
1572	      ,self->io.fir_base);
1573      err = -EBUSY;
1574      goto freeself;
1575    }
1576
1577  spin_lock_init(&self->spinlock);
1578
1579  irda_init_max_qos_capabilies (&self->qos);
1580  self->qos.baud_rate.bits = 0;
1581
1582  if (max_baud >= 2400)
1583    self->qos.baud_rate.bits |= IR_2400;
1584  /*if (max_baud>=4800) idev->qos.baud_rate.bits|=IR_4800; */
1585  if (max_baud >= 9600)
1586    self->qos.baud_rate.bits |= IR_9600;
1587  if (max_baud >= 19200)
1588    self->qos.baud_rate.bits |= IR_19200;
1589  if (max_baud >= 115200)
1590    self->qos.baud_rate.bits |= IR_115200;
1591#ifdef USE_MIR
1592  if (max_baud >= 1152000)
1593    {
1594      self->qos.baud_rate.bits |= IR_1152000;
1595    }
1596#endif
1597  if (max_baud >= 4000000)
1598    {
1599      self->qos.baud_rate.bits |= (IR_4000000 << 8);
1600    }
1601
1602  /*FIXME: work this out... */
1603  self->qos.min_turn_time.bits = 0xff;
1604
1605  irda_qos_bits_to_value (&self->qos);
1606
1607  /* Allocate twice the size to guarantee alignment */
1608  self->ringbuf = kmalloc(OBOE_RING_LEN << 1, GFP_KERNEL);
1609  if (!self->ringbuf)
1610    {
1611      printk (KERN_ERR DRIVER_NAME ": can't allocate DMA buffers\n");
1612      err = -ENOMEM;
1613      goto freeregion;
1614    }
1615
1616#if (BITS_PER_LONG == 64)
1617#error broken on 64-bit:  casts pointer to 32-bit, and then back to pointer.
1618#endif
1619
1620  /*We need to align the taskfile on a taskfile size boundary */
1621  {
1622    unsigned long addr;
1623
1624    addr = (__u32) self->ringbuf;
1625    addr &= ~(OBOE_RING_LEN - 1);
1626    addr += OBOE_RING_LEN;
1627    self->ring = (struct OboeRing *) addr;
1628  }
1629
1630  memset (self->ring, 0, OBOE_RING_LEN);
1631  self->io.mem_base = (__u32) self->ring;
1632
1633  ok = 1;
1634  for (i = 0; i < TX_SLOTS; ++i)
1635    {
1636      self->tx_bufs[i] = kmalloc (TX_BUF_SZ, GFP_KERNEL);
1637      if (!self->tx_bufs[i])
1638        ok = 0;
1639    }
1640
1641  for (i = 0; i < RX_SLOTS; ++i)
1642    {
1643      self->rx_bufs[i] = kmalloc (RX_BUF_SZ, GFP_KERNEL);
1644      if (!self->rx_bufs[i])
1645        ok = 0;
1646    }
1647
1648  if (!ok)
1649    {
1650      printk (KERN_ERR DRIVER_NAME ": can't allocate rx/tx buffers\n");
1651      err = -ENOMEM;
1652      goto freebufs;
1653    }
1654
1655
1656#ifdef USE_PROBE
1657  if (do_probe)
1658    if (!toshoboe_probe (self))
1659      {
1660        err = -ENODEV;
1661        goto freebufs;
1662      }
1663#endif
1664
1665  SET_NETDEV_DEV(dev, &pci_dev->dev);
1666  dev->netdev_ops = &toshoboe_netdev_ops;
1667
1668  err = register_netdev(dev);
1669  if (err)
1670    {
1671      printk (KERN_ERR DRIVER_NAME ": register_netdev() failed\n");
1672      err = -ENOMEM;
1673      goto freebufs;
1674    }
1675  printk (KERN_INFO "IrDA: Registered device %s\n", dev->name);
1676
1677  pci_set_drvdata(pci_dev,self);
1678
1679  printk (KERN_INFO DRIVER_NAME ": Using multiple tasks\n");
1680
1681  return 0;
1682
1683freebufs:
1684  for (i = 0; i < TX_SLOTS; ++i)
1685    kfree (self->tx_bufs[i]);
1686  for (i = 0; i < RX_SLOTS; ++i)
1687    kfree (self->rx_bufs[i]);
1688  kfree(self->ringbuf);
1689
1690freeregion:
1691  release_region (self->io.fir_base, self->io.fir_ext);
1692
1693freeself:
1694  free_netdev(dev);
1695
1696  return err;
1697}
1698
1699static int
1700toshoboe_gotosleep (struct pci_dev *pci_dev, pm_message_t crap)
1701{
1702  struct toshoboe_cb *self = (struct toshoboe_cb*)pci_get_drvdata(pci_dev);
1703  unsigned long flags;
1704  int i = 10;
1705
1706  IRDA_DEBUG (4, "%s()\n", __func__);
1707
1708  if (!self || self->stopped)
1709    return 0;
1710
1711  if ((!self->irdad) && (!self->async))
1712    return 0;
1713
1714/* Flush all packets */
1715  while ((i--) && (self->txpending))
1716    udelay (10000);
1717
1718  spin_lock_irqsave(&self->spinlock, flags);
1719
1720  toshoboe_stopchip (self);
1721  self->stopped = 1;
1722  self->txpending = 0;
1723
1724  spin_unlock_irqrestore(&self->spinlock, flags);
1725  return 0;
1726}
1727
1728static int
1729toshoboe_wakeup (struct pci_dev *pci_dev)
1730{
1731  struct toshoboe_cb *self = (struct toshoboe_cb*)pci_get_drvdata(pci_dev);
1732  unsigned long flags;
1733
1734  IRDA_DEBUG (4, "%s()\n", __func__);
1735
1736  if (!self || !self->stopped)
1737    return 0;
1738
1739  if ((!self->irdad) && (!self->async))
1740    return 0;
1741
1742  spin_lock_irqsave(&self->spinlock, flags);
1743
1744  toshoboe_startchip (self);
1745  self->stopped = 0;
1746
1747  netif_wake_queue(self->netdev);
1748  spin_unlock_irqrestore(&self->spinlock, flags);
1749  return 0;
1750}
1751
1752static struct pci_driver donauboe_pci_driver = {
1753	.name		= "donauboe",
1754	.id_table	= toshoboe_pci_tbl,
1755	.probe		= toshoboe_open,
1756	.remove		= toshoboe_close,
1757	.suspend	= toshoboe_gotosleep,
1758	.resume		= toshoboe_wakeup 
1759};
1760
1761static int __init
1762donauboe_init (void)
1763{
1764  return pci_register_driver(&donauboe_pci_driver);
1765}
1766
1767static void __exit
1768donauboe_cleanup (void)
1769{
1770  pci_unregister_driver(&donauboe_pci_driver);
1771}
1772
1773module_init(donauboe_init);
1774module_exit(donauboe_cleanup);