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