drivers/ieee1394/ohci1394.c

   1 /*
   2  * ohci1394.c - driver for OHCI 1394 boards
   3  * Copyright (C)1999,2000 Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>
   4  *                        Gord Peters <GordPeters@smarttech.com>
   5  *              2001      Ben Collins <bcollins@debian.org>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 /*
  23  * Things known to be working:
  24  * . Async Request Transmit
  25  * . Async Response Receive
  26  * . Async Request Receive
  27  * . Async Response Transmit
  28  * . Iso Receive
  29  * . DMA mmap for iso receive
  30  * . Config ROM generation
  31  *
  32  * Things implemented, but still in test phase:
  33  * . Iso Transmit
  34  * . Async Stream Packets Transmit (Receive done via Iso interface)
  35  *
  36  * Things not implemented:
  37  * . DMA error recovery
  38  *
  39  * Known bugs:
  40  * . devctl BUS_RESET arg confusion (reset type or root holdoff?)
  41  *   added LONG_RESET_ROOT and SHORT_RESET_ROOT for root holdoff --kk
  42  */
  43
  44 /*
  45  * Acknowledgments:
  46  *
  47  * Adam J Richter <adam@yggdrasil.com>
  48  *  . Use of pci_class to find device
  49  *
  50  * Emilie Chung <emilie.chung@axis.com>
  51  *  . Tip on Async Request Filter
  52  *
  53  * Pascal Drolet <pascal.drolet@informission.ca>
  54  *  . Various tips for optimization and functionnalities
  55  *
  56  * Robert Ficklin <rficklin@westengineering.com>
  57  *  . Loop in irq_handler
  58  *
  59  * James Goodwin <jamesg@Filanet.com>
  60  *  . Various tips on initialization, self-id reception, etc.
  61  *
  62  * Albrecht Dress <ad@mpifr-bonn.mpg.de>
  63  *  . Apple PowerBook detection
  64  *
  65  * Daniel Kobras <daniel.kobras@student.uni-tuebingen.de>
  66  *  . Reset the board properly before leaving + misc cleanups
  67  *
  68  * Leon van Stuivenberg <leonvs@iae.nl>
  69  *  . Bug fixes
  70  *
  71  * Ben Collins <bcollins@debian.org>
  72  *  . Working big-endian support
  73  *  . Updated to 2.4.x module scheme (PCI aswell)
  74  *  . Config ROM generation
  75  *
  76  * Manfred Weihs <weihs@ict.tuwien.ac.at>
  77  *  . Reworked code for initiating bus resets
  78  *    (long, short, with or without hold-off)
  79  *
  80  * Nandu Santhi <contactnandu@users.sourceforge.net>
  81  *  . Added support for nVidia nForce2 onboard Firewire chipset
  82  *
  83  */
  84
  85 #include <linux/kernel.h>
  86 #include <linux/list.h>
  87 #include <linux/slab.h>
  88 #include <linux/interrupt.h>
  89 #include <linux/wait.h>
  90 #include <linux/errno.h>
  91 #include <linux/module.h>
  92 #include <linux/moduleparam.h>
  93 #include <linux/pci.h>
  94 #include <linux/fs.h>
  95 #include <linux/poll.h>
  96 #include <asm/byteorder.h>
  97 #include <asm/atomic.h>
  98 #include <asm/uaccess.h>
  99 #include <linux/delay.h>
 100 #include <linux/spinlock.h>
 101
 102 #include <asm/pgtable.h>
 103 #include <asm/page.h>
 104 #include <asm/irq.h>
 105 #include <linux/types.h>
 106 #include <linux/vmalloc.h>
 107 #include <linux/init.h>
 108
 109 #ifdef CONFIG_PPC_PMAC
 110 #include <asm/machdep.h>
 111 #include <asm/pmac_feature.h>
 112 #include <asm/prom.h>
 113 #include <asm/pci-bridge.h>
 114 #endif
 115
 116 #include "csr1212.h"
 117 #include "ieee1394.h"
 118 #include "ieee1394_types.h"
 119 #include "hosts.h"
 120 #include "dma.h"
 121 #include "iso.h"
 122 #include "ieee1394_core.h"
 123 #include "highlevel.h"
 124 #include "ohci1394.h"
 125
 126 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
 127 #define OHCI1394_DEBUG
 128 #endif
 129
 130 #ifdef DBGMSG
 131 #undef DBGMSG
 132 #endif
 133
 134 #ifdef OHCI1394_DEBUG
 135 #define DBGMSG(fmt, args...) \
 136 printk(KERN_INFO "%s: fw-host%d: " fmt "\n" , OHCI1394_DRIVER_NAME, ohci->host->id , ## args)
 137 #else
 138 #define DBGMSG(fmt, args...) do {} while (0)
 139 #endif
 140
 141 /* print general (card independent) information */
 142 #define PRINT_G(level, fmt, args...) \
 143 printk(level "%s: " fmt "\n" , OHCI1394_DRIVER_NAME , ## args)
 144
 145 /* print card specific information */
 146 #define PRINT(level, fmt, args...) \
 147 printk(level "%s: fw-host%d: " fmt "\n" , OHCI1394_DRIVER_NAME, ohci->host->id , ## args)
 148
 149 /* Module Parameters */
 150 static int phys_dma = 1;
 151 module_param(phys_dma, int, 0444);
 152 MODULE_PARM_DESC(phys_dma, "Enable physical dma (default = 1).");
 153
 154 static void dma_trm_tasklet(unsigned long data);
 155 static void dma_trm_reset(struct dma_trm_ctx *d);
 156
 157 static int alloc_dma_rcv_ctx(struct ti_ohci *ohci, struct dma_rcv_ctx *d,
 158                              enum context_type type, int ctx, int num_desc,
 159                              int buf_size, int split_buf_size, int context_base);
 160 static void free_dma_rcv_ctx(struct dma_rcv_ctx *d);
 161
 162 static int alloc_dma_trm_ctx(struct ti_ohci *ohci, struct dma_trm_ctx *d,
 163                              enum context_type type, int ctx, int num_desc,
 164                              int context_base);
 165
 166 static void ohci1394_pci_remove(struct pci_dev *pdev);
 167
 168 #ifndef __LITTLE_ENDIAN
 169 static const size_t hdr_sizes[] = {
 170         3,      /* TCODE_WRITEQ */
 171         4,      /* TCODE_WRITEB */
 172         3,      /* TCODE_WRITE_RESPONSE */
 173         0,      /* reserved */
 174         3,      /* TCODE_READQ */
 175         4,      /* TCODE_READB */
 176         3,      /* TCODE_READQ_RESPONSE */
 177         4,      /* TCODE_READB_RESPONSE */
 178         1,      /* TCODE_CYCLE_START */
 179         4,      /* TCODE_LOCK_REQUEST */
 180         2,      /* TCODE_ISO_DATA */
 181         4,      /* TCODE_LOCK_RESPONSE */
 182                 /* rest is reserved or link-internal */
 183 };
 184
 185 static inline void header_le32_to_cpu(quadlet_t *data, unsigned char tcode)
 186 {
 187         size_t size;
 188
 189         if (unlikely(tcode >= ARRAY_SIZE(hdr_sizes)))
 190                 return;
 191
 192         size = hdr_sizes[tcode];
 193         while (size--)
 194                 data[size] = le32_to_cpu(data[size]);
 195 }
 196 #else
 197 #define header_le32_to_cpu(w,x) do {} while (0)
 198 #endif /* !LITTLE_ENDIAN */
 199
 200 /***********************************
 201  * IEEE-1394 functionality section *
 202  ***********************************/
 203
 204 static u8 get_phy_reg(struct ti_ohci *ohci, u8 addr)
 205 {
 206         int i;
 207         unsigned long flags;
 208         quadlet_t r;
 209
 210         spin_lock_irqsave (&ohci->phy_reg_lock, flags);
 211
 212         reg_write(ohci, OHCI1394_PhyControl, (addr << 8) | 0x00008000);
 213
 214         for (i = 0; i < OHCI_LOOP_COUNT; i++) {
 215                 if (reg_read(ohci, OHCI1394_PhyControl) & 0x80000000)
 216                         break;
 217
 218                 mdelay(1);
 219         }
 220
 221         r = reg_read(ohci, OHCI1394_PhyControl);
 222
 223         if (i >= OHCI_LOOP_COUNT)
 224                 PRINT (KERN_ERR, "Get PHY Reg timeout [0x%08x/0x%08x/%d]",
 225                        r, r & 0x80000000, i);
 226
 227         spin_unlock_irqrestore (&ohci->phy_reg_lock, flags);
 228
 229         return (r & 0x00ff0000) >> 16;
 230 }
 231
 232 static void set_phy_reg(struct ti_ohci *ohci, u8 addr, u8 data)
 233 {
 234         int i;
 235         unsigned long flags;
 236         u32 r = 0;
 237
 238         spin_lock_irqsave (&ohci->phy_reg_lock, flags);
 239
 240         reg_write(ohci, OHCI1394_PhyControl, (addr << 8) | data | 0x00004000);
 241
 242         for (i = 0; i < OHCI_LOOP_COUNT; i++) {
 243                 r = reg_read(ohci, OHCI1394_PhyControl);
 244                 if (!(r & 0x00004000))
 245                         break;
 246
 247                 mdelay(1);
 248         }
 249
 250         if (i == OHCI_LOOP_COUNT)
 251                 PRINT (KERN_ERR, "Set PHY Reg timeout [0x%08x/0x%08x/%d]",
 252                        r, r & 0x00004000, i);
 253
 254         spin_unlock_irqrestore (&ohci->phy_reg_lock, flags);
 255
 256         return;
 257 }
 258
 259 /* Or's our value into the current value */
 260 static void set_phy_reg_mask(struct ti_ohci *ohci, u8 addr, u8 data)
 261 {
 262         u8 old;
 263
 264         old = get_phy_reg (ohci, addr);
 265         old |= data;
 266         set_phy_reg (ohci, addr, old);
 267
 268         return;
 269 }
 270
 271 static void handle_selfid(struct ti_ohci *ohci, struct hpsb_host *host,
 272                                 int phyid, int isroot)
 273 {
 274         quadlet_t *q = ohci->selfid_buf_cpu;
 275         quadlet_t self_id_count=reg_read(ohci, OHCI1394_SelfIDCount);
 276         size_t size;
 277         quadlet_t q0, q1;
 278
 279         /* Check status of self-id reception */
 280
 281         if (ohci->selfid_swap)
 282                 q0 = le32_to_cpu(q[0]);
 283         else
 284                 q0 = q[0];
 285
 286         if ((self_id_count & 0x80000000) ||
 287             ((self_id_count & 0x00FF0000) != (q0 & 0x00FF0000))) {
 288                 PRINT(KERN_ERR,
 289                       "Error in reception of SelfID packets [0x%08x/0x%08x] (count: %d)",
 290                       self_id_count, q0, ohci->self_id_errors);
 291
 292                 /* Tip by James Goodwin <jamesg@Filanet.com>:
 293                  * We had an error, generate another bus reset in response.  */
 294                 if (ohci->self_id_errors<OHCI1394_MAX_SELF_ID_ERRORS) {
 295                         set_phy_reg_mask (ohci, 1, 0x40);
 296                         ohci->self_id_errors++;
 297                 } else {
 298                         PRINT(KERN_ERR,
 299                               "Too many errors on SelfID error reception, giving up!");
 300                 }
 301                 return;
 302         }
 303
 304         /* SelfID Ok, reset error counter. */
 305         ohci->self_id_errors = 0;
 306
 307         size = ((self_id_count & 0x00001FFC) >> 2) - 1;
 308         q++;
 309
 310         while (size > 0) {
 311                 if (ohci->selfid_swap) {
 312                         q0 = le32_to_cpu(q[0]);
 313                         q1 = le32_to_cpu(q[1]);
 314                 } else {
 315                         q0 = q[0];
 316                         q1 = q[1];
 317                 }
 318
 319                 if (q0 == ~q1) {
 320                         DBGMSG ("SelfID packet 0x%x received", q0);
 321                         hpsb_selfid_received(host, cpu_to_be32(q0));
 322                         if (((q0 & 0x3f000000) >> 24) == phyid)
 323                                 DBGMSG ("SelfID for this node is 0x%08x", q0);
 324                 } else {
 325                         PRINT(KERN_ERR,
 326                               "SelfID is inconsistent [0x%08x/0x%08x]", q0, q1);
 327                 }
 328                 q += 2;
 329                 size -= 2;
 330         }
 331
 332         DBGMSG("SelfID complete");
 333
 334         return;
 335 }
 336
 337 static void ohci_soft_reset(struct ti_ohci *ohci) {
 338         int i;
 339
 340         reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_softReset);
 341
 342         for (i = 0; i < OHCI_LOOP_COUNT; i++) {
 343                 if (!(reg_read(ohci, OHCI1394_HCControlSet) & OHCI1394_HCControl_softReset))
 344                         break;
 345                 mdelay(1);
 346         }
 347         DBGMSG ("Soft reset finished");
 348 }
 349
 350
 351 /* Generate the dma receive prgs and start the context */
 352 static void initialize_dma_rcv_ctx(struct dma_rcv_ctx *d, int generate_irq)
 353 {
 354         struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
 355         int i;
 356
 357         ohci1394_stop_context(ohci, d->ctrlClear, NULL);
 358
 359         for (i=0; i<d->num_desc; i++) {
 360                 u32 c;
 361
 362                 c = DMA_CTL_INPUT_MORE | DMA_CTL_UPDATE | DMA_CTL_BRANCH;
 363                 if (generate_irq)
 364                         c |= DMA_CTL_IRQ;
 365
 366                 d->prg_cpu[i]->control = cpu_to_le32(c | d->buf_size);
 367
 368                 /* End of descriptor list? */
 369                 if (i + 1 < d->num_desc) {
 370                         d->prg_cpu[i]->branchAddress =
 371                                 cpu_to_le32((d->prg_bus[i+1] & 0xfffffff0) | 0x1);
 372                 } else {
 373                         d->prg_cpu[i]->branchAddress =
 374                                 cpu_to_le32((d->prg_bus[0] & 0xfffffff0));
 375                 }
 376
 377                 d->prg_cpu[i]->address = cpu_to_le32(d->buf_bus[i]);
 378                 d->prg_cpu[i]->status = cpu_to_le32(d->buf_size);
 379         }
 380
 381         d->buf_ind = 0;
 382         d->buf_offset = 0;
 383
 384         if (d->type == DMA_CTX_ISO) {
 385                 /* Clear contextControl */
 386                 reg_write(ohci, d->ctrlClear, 0xffffffff);
 387
 388                 /* Set bufferFill, isochHeader, multichannel for IR context */
 389                 reg_write(ohci, d->ctrlSet, 0xd0000000);
 390
 391                 /* Set the context match register to match on all tags */
 392                 reg_write(ohci, d->ctxtMatch, 0xf0000000);
 393
 394                 /* Clear the multi channel mask high and low registers */
 395                 reg_write(ohci, OHCI1394_IRMultiChanMaskHiClear, 0xffffffff);
 396                 reg_write(ohci, OHCI1394_IRMultiChanMaskLoClear, 0xffffffff);
 397
 398                 /* Set up isoRecvIntMask to generate interrupts */
 399                 reg_write(ohci, OHCI1394_IsoRecvIntMaskSet, 1 << d->ctx);
 400         }
 401
 402         /* Tell the controller where the first AR program is */
 403         reg_write(ohci, d->cmdPtr, d->prg_bus[0] | 0x1);
 404
 405         /* Run context */
 406         reg_write(ohci, d->ctrlSet, 0x00008000);
 407
 408         DBGMSG("Receive DMA ctx=%d initialized", d->ctx);
 409 }
 410
 411 /* Initialize the dma transmit context */
 412 static void initialize_dma_trm_ctx(struct dma_trm_ctx *d)
 413 {
 414         struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
 415
 416         /* Stop the context */
 417         ohci1394_stop_context(ohci, d->ctrlClear, NULL);
 418
 419         d->prg_ind = 0;
 420         d->sent_ind = 0;
 421         d->free_prgs = d->num_desc;
 422         d->branchAddrPtr = NULL;
 423         INIT_LIST_HEAD(&d->fifo_list);
 424         INIT_LIST_HEAD(&d->pending_list);
 425
 426         if (d->type == DMA_CTX_ISO) {
 427                 /* enable interrupts */
 428                 reg_write(ohci, OHCI1394_IsoXmitIntMaskSet, 1 << d->ctx);
 429         }
 430
 431         DBGMSG("Transmit DMA ctx=%d initialized", d->ctx);
 432 }
 433
 434 /* Count the number of available iso contexts */
 435 static int get_nb_iso_ctx(struct ti_ohci *ohci, int reg)
 436 {
 437         int i,ctx=0;
 438         u32 tmp;
 439
 440         reg_write(ohci, reg, 0xffffffff);
 441         tmp = reg_read(ohci, reg);
 442
 443         DBGMSG("Iso contexts reg: %08x implemented: %08x", reg, tmp);
 444
 445         /* Count the number of contexts */
 446         for (i=0; i<32; i++) {
 447                 if (tmp & 1) ctx++;
 448                 tmp >>= 1;
 449         }
 450         return ctx;
 451 }
 452
 453 /* Global initialization */
 454 static void ohci_initialize(struct ti_ohci *ohci)
 455 {
 456         quadlet_t buf;
 457         int num_ports, i;
 458
 459         spin_lock_init(&ohci->phy_reg_lock);
 460
 461         /* Put some defaults to these undefined bus options */
 462         buf = reg_read(ohci, OHCI1394_BusOptions);
 463         buf |=  0x60000000; /* Enable CMC and ISC */
 464         if (hpsb_disable_irm)
 465                 buf &= ~0x80000000;
 466         else
 467                 buf |=  0x80000000; /* Enable IRMC */
 468         buf &= ~0x00ff0000; /* XXX: Set cyc_clk_acc to zero for now */
 469         buf &= ~0x18000000; /* Disable PMC and BMC */
 470         reg_write(ohci, OHCI1394_BusOptions, buf);
 471
 472         /* Set the bus number */
 473         reg_write(ohci, OHCI1394_NodeID, 0x0000ffc0);
 474
 475         /* Enable posted writes */
 476         reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_postedWriteEnable);
 477
 478         /* Clear link control register */
 479         reg_write(ohci, OHCI1394_LinkControlClear, 0xffffffff);
 480
 481         /* Enable cycle timer and cycle master and set the IRM
 482          * contender bit in our self ID packets if appropriate. */
 483         reg_write(ohci, OHCI1394_LinkControlSet,
 484                   OHCI1394_LinkControl_CycleTimerEnable |
 485                   OHCI1394_LinkControl_CycleMaster);
 486         i = get_phy_reg(ohci, 4) | PHY_04_LCTRL;
 487         if (hpsb_disable_irm)
 488                 i &= ~PHY_04_CONTENDER;
 489         else
 490                 i |= PHY_04_CONTENDER;
 491         set_phy_reg(ohci, 4, i);
 492
 493         /* Set up self-id dma buffer */
 494         reg_write(ohci, OHCI1394_SelfIDBuffer, ohci->selfid_buf_bus);
 495
 496         /* enable self-id */
 497         reg_write(ohci, OHCI1394_LinkControlSet, OHCI1394_LinkControl_RcvSelfID);
 498
 499         /* Set the Config ROM mapping register */
 500         reg_write(ohci, OHCI1394_ConfigROMmap, ohci->csr_config_rom_bus);
 501
 502         /* Now get our max packet size */
 503         ohci->max_packet_size =
 504                 1<<(((reg_read(ohci, OHCI1394_BusOptions)>>12)&0xf)+1);
 505
 506         /* Clear the interrupt mask */
 507         reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 0xffffffff);
 508         reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 0xffffffff);
 509
 510         /* Clear the interrupt mask */
 511         reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 0xffffffff);
 512         reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 0xffffffff);
 513
 514         /* Initialize AR dma */
 515         initialize_dma_rcv_ctx(&ohci->ar_req_context, 0);
 516         initialize_dma_rcv_ctx(&ohci->ar_resp_context, 0);
 517
 518         /* Initialize AT dma */
 519         initialize_dma_trm_ctx(&ohci->at_req_context);
 520         initialize_dma_trm_ctx(&ohci->at_resp_context);
 521
 522         /* Accept AR requests from all nodes */
 523         reg_write(ohci, OHCI1394_AsReqFilterHiSet, 0x80000000);
 524
 525         /* Set the address range of the physical response unit.
 526          * Most controllers do not implement it as a writable register though.
 527          * They will keep a hardwired offset of 0x00010000 and show 0x0 as
 528          * register content.
 529          * To actually enable physical responses is the job of our interrupt
 530          * handler which programs the physical request filter. */
 531         reg_write(ohci, OHCI1394_PhyUpperBound,
 532                   OHCI1394_PHYS_UPPER_BOUND_PROGRAMMED >> 16);
 533
 534         DBGMSG("physUpperBoundOffset=%08x",
 535                reg_read(ohci, OHCI1394_PhyUpperBound));
 536
 537         /* Specify AT retries */
 538         reg_write(ohci, OHCI1394_ATRetries,
 539                   OHCI1394_MAX_AT_REQ_RETRIES |
 540                   (OHCI1394_MAX_AT_RESP_RETRIES<<4) |
 541                   (OHCI1394_MAX_PHYS_RESP_RETRIES<<8));
 542
 543         /* We don't want hardware swapping */
 544         reg_write(ohci, OHCI1394_HCControlClear, OHCI1394_HCControl_noByteSwap);
 545
 546         /* Enable interrupts */
 547         reg_write(ohci, OHCI1394_IntMaskSet,
 548                   OHCI1394_unrecoverableError |
 549                   OHCI1394_masterIntEnable |
 550                   OHCI1394_busReset |
 551                   OHCI1394_selfIDComplete |
 552                   OHCI1394_RSPkt |
 553                   OHCI1394_RQPkt |
 554                   OHCI1394_respTxComplete |
 555                   OHCI1394_reqTxComplete |
 556                   OHCI1394_isochRx |
 557                   OHCI1394_isochTx |
 558                   OHCI1394_postedWriteErr |
 559                   OHCI1394_cycleTooLong |
 560                   OHCI1394_cycleInconsistent);
 561
 562         /* Enable link */
 563         reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_linkEnable);
 564
 565         buf = reg_read(ohci, OHCI1394_Version);
 566         PRINT(KERN_INFO, "OHCI-1394 %d.%d (PCI): IRQ=[%d]  "
 567               "MMIO=[%llx-%llx]  Max Packet=[%d]  IR/IT contexts=[%d/%d]",
 568               ((((buf) >> 16) & 0xf) + (((buf) >> 20) & 0xf) * 10),
 569               ((((buf) >> 4) & 0xf) + ((buf) & 0xf) * 10), ohci->dev->irq,
 570               (unsigned long long)pci_resource_start(ohci->dev, 0),
 571               (unsigned long long)pci_resource_start(ohci->dev, 0) + OHCI1394_REGISTER_SIZE - 1,
 572               ohci->max_packet_size,
 573               ohci->nb_iso_rcv_ctx, ohci->nb_iso_xmit_ctx);
 574
 575         /* Check all of our ports to make sure that if anything is
 576          * connected, we enable that port. */
 577         num_ports = get_phy_reg(ohci, 2) & 0xf;
 578         for (i = 0; i < num_ports; i++) {
 579                 unsigned int status;
 580
 581                 set_phy_reg(ohci, 7, i);
 582                 status = get_phy_reg(ohci, 8);
 583
 584                 if (status & 0x20)
 585                         set_phy_reg(ohci, 8, status & ~1);
 586         }
 587
 588         /* Serial EEPROM Sanity check. */
 589         if ((ohci->max_packet_size < 512) ||
 590             (ohci->max_packet_size > 4096)) {
 591                 /* Serial EEPROM contents are suspect, set a sane max packet
 592                  * size and print the raw contents for bug reports if verbose
 593                  * debug is enabled. */
 594 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
 595                 int i;
 596 #endif
 597
 598                 PRINT(KERN_DEBUG, "Serial EEPROM has suspicious values, "
 599                       "attempting to set max_packet_size to 512 bytes");
 600                 reg_write(ohci, OHCI1394_BusOptions,
 601                           (reg_read(ohci, OHCI1394_BusOptions) & 0xf007) | 0x8002);
 602                 ohci->max_packet_size = 512;
 603 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
 604                 PRINT(KERN_DEBUG, "    EEPROM Present: %d",
 605                       (reg_read(ohci, OHCI1394_Version) >> 24) & 0x1);
 606                 reg_write(ohci, OHCI1394_GUID_ROM, 0x80000000);
 607
 608                 for (i = 0;
 609                      ((i < 1000) &&
 610                       (reg_read(ohci, OHCI1394_GUID_ROM) & 0x80000000)); i++)
 611                         udelay(10);
 612
 613                 for (i = 0; i < 0x20; i++) {
 614                         reg_write(ohci, OHCI1394_GUID_ROM, 0x02000000);
 615                         PRINT(KERN_DEBUG, "    EEPROM %02x: %02x", i,
 616                               (reg_read(ohci, OHCI1394_GUID_ROM) >> 16) & 0xff);
 617                 }
 618 #endif
 619         }
 620 }
 621
 622 /*
 623  * Insert a packet in the DMA fifo and generate the DMA prg
 624  * FIXME: rewrite the program in order to accept packets crossing
 625  *        page boundaries.
 626  *        check also that a single dma descriptor doesn't cross a
 627  *        page boundary.
 628  */
 629 static void insert_packet(struct ti_ohci *ohci,
 630                           struct dma_trm_ctx *d, struct hpsb_packet *packet)
 631 {
 632         u32 cycleTimer;
 633         int idx = d->prg_ind;
 634
 635         DBGMSG("Inserting packet for node " NODE_BUS_FMT
 636                ", tlabel=%d, tcode=0x%x, speed=%d",
 637                NODE_BUS_ARGS(ohci->host, packet->node_id), packet->tlabel,
 638                packet->tcode, packet->speed_code);
 639
 640         d->prg_cpu[idx]->begin.address = 0;
 641         d->prg_cpu[idx]->begin.branchAddress = 0;
 642
 643         if (d->type == DMA_CTX_ASYNC_RESP) {
 644                 /*
 645                  * For response packets, we need to put a timeout value in
 646                  * the 16 lower bits of the status... let's try 1 sec timeout
 647                  */
 648                 cycleTimer = reg_read(ohci, OHCI1394_IsochronousCycleTimer);
 649                 d->prg_cpu[idx]->begin.status = cpu_to_le32(
 650                         (((((cycleTimer>>25)&0x7)+1)&0x7)<<13) |
 651                         ((cycleTimer&0x01fff000)>>12));
 652
 653                 DBGMSG("cycleTimer: %08x timeStamp: %08x",
 654                        cycleTimer, d->prg_cpu[idx]->begin.status);
 655         } else
 656                 d->prg_cpu[idx]->begin.status = 0;
 657
 658         if ( (packet->type == hpsb_async) || (packet->type == hpsb_raw) ) {
 659
 660                 if (packet->type == hpsb_raw) {
 661                         d->prg_cpu[idx]->data[0] = cpu_to_le32(OHCI1394_TCODE_PHY<<4);
 662                         d->prg_cpu[idx]->data[1] = cpu_to_le32(packet->header[0]);
 663                         d->prg_cpu[idx]->data[2] = cpu_to_le32(packet->header[1]);
 664                 } else {
 665                         d->prg_cpu[idx]->data[0] = packet->speed_code<<16 |
 666                                 (packet->header[0] & 0xFFFF);
 667
 668                         if (packet->tcode == TCODE_ISO_DATA) {
 669                                 /* Sending an async stream packet */
 670                                 d->prg_cpu[idx]->data[1] = packet->header[0] & 0xFFFF0000;
 671                         } else {
 672                                 /* Sending a normal async request or response */
 673                                 d->prg_cpu[idx]->data[1] =
 674                                         (packet->header[1] & 0xFFFF) |
 675                                         (packet->header[0] & 0xFFFF0000);
 676                                 d->prg_cpu[idx]->data[2] = packet->header[2];
 677                                 d->prg_cpu[idx]->data[3] = packet->header[3];
 678                         }
 679                         header_le32_to_cpu(d->prg_cpu[idx]->data, packet->tcode);
 680                 }
 681
 682                 if (packet->data_size) { /* block transmit */
 683                         if (packet->tcode == TCODE_STREAM_DATA){
 684                                 d->prg_cpu[idx]->begin.control =
 685                                         cpu_to_le32(DMA_CTL_OUTPUT_MORE |
 686                                                     DMA_CTL_IMMEDIATE | 0x8);
 687                         } else {
 688                                 d->prg_cpu[idx]->begin.control =
 689                                         cpu_to_le32(DMA_CTL_OUTPUT_MORE |
 690                                                     DMA_CTL_IMMEDIATE | 0x10);
 691                         }
 692                         d->prg_cpu[idx]->end.control =
 693                                 cpu_to_le32(DMA_CTL_OUTPUT_LAST |
 694                                             DMA_CTL_IRQ |
 695                                             DMA_CTL_BRANCH |
 696                                             packet->data_size);
 697                         /*
 698                          * Check that the packet data buffer
 699                          * does not cross a page boundary.
 700                          *
 701                          * XXX Fix this some day. eth1394 seems to trigger
 702                          * it, but ignoring it doesn't seem to cause a
 703                          * problem.
 704                          */
 705 #if 0
 706                         if (cross_bound((unsigned long)packet->data,
 707                                         packet->data_size)>0) {
 708                                 /* FIXME: do something about it */
 709                                 PRINT(KERN_ERR,
 710                                       "%s: packet data addr: %p size %Zd bytes "
 711                                       "cross page boundary", __FUNCTION__,
 712                                       packet->data, packet->data_size);
 713                         }
 714 #endif
 715                         d->prg_cpu[idx]->end.address = cpu_to_le32(
 716                                 pci_map_single(ohci->dev, packet->data,
 717                                                packet->data_size,
 718                                                PCI_DMA_TODEVICE));
 719
 720                         d->prg_cpu[idx]->end.branchAddress = 0;
 721                         d->prg_cpu[idx]->end.status = 0;
 722                         if (d->branchAddrPtr)
 723                                 *(d->branchAddrPtr) =
 724                                         cpu_to_le32(d->prg_bus[idx] | 0x3);
 725                         d->branchAddrPtr =
 726                                 &(d->prg_cpu[idx]->end.branchAddress);
 727                 } else { /* quadlet transmit */
 728                         if (packet->type == hpsb_raw)
 729                                 d->prg_cpu[idx]->begin.control =
 730                                         cpu_to_le32(DMA_CTL_OUTPUT_LAST |
 731                                                     DMA_CTL_IMMEDIATE |
 732                                                     DMA_CTL_IRQ |
 733                                                     DMA_CTL_BRANCH |
 734                                                     (packet->header_size + 4));
 735                         else
 736                                 d->prg_cpu[idx]->begin.control =
 737                                         cpu_to_le32(DMA_CTL_OUTPUT_LAST |
 738                                                     DMA_CTL_IMMEDIATE |
 739                                                     DMA_CTL_IRQ |
 740                                                     DMA_CTL_BRANCH |
 741                                                     packet->header_size);
 742
 743                         if (d->branchAddrPtr)
 744                                 *(d->branchAddrPtr) =
 745                                         cpu_to_le32(d->prg_bus[idx] | 0x2);
 746                         d->branchAddrPtr =
 747                                 &(d->prg_cpu[idx]->begin.branchAddress);
 748                 }
 749
 750         } else { /* iso packet */
 751                 d->prg_cpu[idx]->data[0] = packet->speed_code<<16 |
 752                         (packet->header[0] & 0xFFFF);
 753                 d->prg_cpu[idx]->data[1] = packet->header[0] & 0xFFFF0000;
 754                 header_le32_to_cpu(d->prg_cpu[idx]->data, packet->tcode);
 755
 756                 d->prg_cpu[idx]->begin.control =
 757                         cpu_to_le32(DMA_CTL_OUTPUT_MORE |
 758                                     DMA_CTL_IMMEDIATE | 0x8);
 759                 d->prg_cpu[idx]->end.control =
 760                         cpu_to_le32(DMA_CTL_OUTPUT_LAST |
 761                                     DMA_CTL_UPDATE |
 762                                     DMA_CTL_IRQ |
 763                                     DMA_CTL_BRANCH |
 764                                     packet->data_size);
 765                 d->prg_cpu[idx]->end.address = cpu_to_le32(
 766                                 pci_map_single(ohci->dev, packet->data,
 767                                 packet->data_size, PCI_DMA_TODEVICE));
 768
 769                 d->prg_cpu[idx]->end.branchAddress = 0;
 770                 d->prg_cpu[idx]->end.status = 0;
 771                 DBGMSG("Iso xmit context info: header[%08x %08x]\n"
 772                        "                       begin=%08x %08x %08x %08x\n"
 773                        "                             %08x %08x %08x %08x\n"
 774                        "                       end  =%08x %08x %08x %08x",
 775                        d->prg_cpu[idx]->data[0], d->prg_cpu[idx]->data[1],
 776                        d->prg_cpu[idx]->begin.control,
 777                        d->prg_cpu[idx]->begin.address,
 778                        d->prg_cpu[idx]->begin.branchAddress,
 779                        d->prg_cpu[idx]->begin.status,
 780                        d->prg_cpu[idx]->data[0],
 781                        d->prg_cpu[idx]->data[1],
 782                        d->prg_cpu[idx]->data[2],
 783                        d->prg_cpu[idx]->data[3],
 784                        d->prg_cpu[idx]->end.control,
 785                        d->prg_cpu[idx]->end.address,
 786                        d->prg_cpu[idx]->end.branchAddress,
 787                        d->prg_cpu[idx]->end.status);
 788                 if (d->branchAddrPtr)
 789                         *(d->branchAddrPtr) = cpu_to_le32(d->prg_bus[idx] | 0x3);
 790                 d->branchAddrPtr = &(d->prg_cpu[idx]->end.branchAddress);
 791         }
 792         d->free_prgs--;
 793
 794         /* queue the packet in the appropriate context queue */
 795         list_add_tail(&packet->driver_list, &d->fifo_list);
 796         d->prg_ind = (d->prg_ind + 1) % d->num_desc;
 797 }
 798
 799 /*
 800  * This function fills the FIFO with the (eventual) pending packets
 801  * and runs or wakes up the DMA prg if necessary.
 802  *
 803  * The function MUST be called with the d->lock held.
 804  */
 805 static void dma_trm_flush(struct ti_ohci *ohci, struct dma_trm_ctx *d)
 806 {
 807         struct hpsb_packet *packet, *ptmp;
 808         int idx = d->prg_ind;
 809         int z = 0;
 810
 811         /* insert the packets into the dma fifo */
 812         list_for_each_entry_safe(packet, ptmp, &d->pending_list, driver_list) {
 813                 if (!d->free_prgs)
 814                         break;
 815
 816                 /* For the first packet only */
 817                 if (!z)
 818                         z = (packet->data_size) ? 3 : 2;
 819
 820                 /* Insert the packet */
 821                 list_del_init(&packet->driver_list);
 822                 insert_packet(ohci, d, packet);
 823         }
 824
 825         /* Nothing must have been done, either no free_prgs or no packets */
 826         if (z == 0)
 827                 return;
 828
 829         /* Is the context running ? (should be unless it is
 830            the first packet to be sent in this context) */
 831         if (!(reg_read(ohci, d->ctrlSet) & 0x8000)) {
 832                 u32 nodeId = reg_read(ohci, OHCI1394_NodeID);
 833
 834                 DBGMSG("Starting transmit DMA ctx=%d",d->ctx);
 835                 reg_write(ohci, d->cmdPtr, d->prg_bus[idx] | z);
 836
 837                 /* Check that the node id is valid, and not 63 */
 838                 if (!(nodeId & 0x80000000) || (nodeId & 0x3f) == 63)
 839                         PRINT(KERN_ERR, "Running dma failed because Node ID is not valid");
 840                 else
 841                         reg_write(ohci, d->ctrlSet, 0x8000);
 842         } else {
 843                 /* Wake up the dma context if necessary */
 844                 if (!(reg_read(ohci, d->ctrlSet) & 0x400))
 845                         DBGMSG("Waking transmit DMA ctx=%d",d->ctx);
 846
 847                 /* do this always, to avoid race condition */
 848                 reg_write(ohci, d->ctrlSet, 0x1000);
 849         }
 850
 851         return;
 852 }
 853
 854 /* Transmission of an async or iso packet */
 855 static int ohci_transmit(struct hpsb_host *host, struct hpsb_packet *packet)
 856 {
 857         struct ti_ohci *ohci = host->hostdata;
 858         struct dma_trm_ctx *d;
 859         unsigned long flags;
 860
 861         if (packet->data_size > ohci->max_packet_size) {
 862                 PRINT(KERN_ERR,
 863                       "Transmit packet size %Zd is too big",
 864                       packet->data_size);
 865                 return -EOVERFLOW;
 866         }
 867
 868         if (packet->type == hpsb_raw)
 869                 d = &ohci->at_req_context;
 870         else if ((packet->tcode & 0x02) && (packet->tcode != TCODE_ISO_DATA))
 871                 d = &ohci->at_resp_context;
 872         else
 873                 d = &ohci->at_req_context;
 874
 875         spin_lock_irqsave(&d->lock,flags);
 876
 877         list_add_tail(&packet->driver_list, &d->pending_list);
 878
 879         dma_trm_flush(ohci, d);
 880
 881         spin_unlock_irqrestore(&d->lock,flags);
 882
 883         return 0;
 884 }
 885
 886 static int ohci_devctl(struct hpsb_host *host, enum devctl_cmd cmd, int arg)
 887 {
 888         struct ti_ohci *ohci = host->hostdata;
 889         int retval = 0, phy_reg;
 890
 891         switch (cmd) {
 892         case RESET_BUS:
 893                 switch (arg) {
 894                 case SHORT_RESET:
 895                         phy_reg = get_phy_reg(ohci, 5);
 896                         phy_reg |= 0x40;
 897                         set_phy_reg(ohci, 5, phy_reg); /* set ISBR */
 898                         break;
 899                 case LONG_RESET:
 900                         phy_reg = get_phy_reg(ohci, 1);
 901                         phy_reg |= 0x40;
 902                         set_phy_reg(ohci, 1, phy_reg); /* set IBR */
 903                         break;
 904                 case SHORT_RESET_NO_FORCE_ROOT:
 905                         phy_reg = get_phy_reg(ohci, 1);
 906                         if (phy_reg & 0x80) {
 907                                 phy_reg &= ~0x80;
 908                                 set_phy_reg(ohci, 1, phy_reg); /* clear RHB */
 909                         }
 910
 911                         phy_reg = get_phy_reg(ohci, 5);
 912                         phy_reg |= 0x40;
 913                         set_phy_reg(ohci, 5, phy_reg); /* set ISBR */
 914                         break;
 915                 case LONG_RESET_NO_FORCE_ROOT:
 916                         phy_reg = get_phy_reg(ohci, 1);
 917                         phy_reg &= ~0x80;
 918                         phy_reg |= 0x40;
 919                         set_phy_reg(ohci, 1, phy_reg); /* clear RHB, set IBR */
 920                         break;
 921                 case SHORT_RESET_FORCE_ROOT:
 922                         phy_reg = get_phy_reg(ohci, 1);
 923                         if (!(phy_reg & 0x80)) {
 924                                 phy_reg |= 0x80;
 925                                 set_phy_reg(ohci, 1, phy_reg); /* set RHB */
 926                         }
 927
 928                         phy_reg = get_phy_reg(ohci, 5);
 929                         phy_reg |= 0x40;
 930                         set_phy_reg(ohci, 5, phy_reg); /* set ISBR */
 931                         break;
 932                 case LONG_RESET_FORCE_ROOT:
 933                         phy_reg = get_phy_reg(ohci, 1);
 934                         phy_reg |= 0xc0;
 935                         set_phy_reg(ohci, 1, phy_reg); /* set RHB and IBR */
 936                         break;
 937                 default:
 938                         retval = -1;
 939                 }
 940                 break;
 941
 942         case GET_CYCLE_COUNTER:
 943                 retval = reg_read(ohci, OHCI1394_IsochronousCycleTimer);
 944                 break;
 945
 946         case SET_CYCLE_COUNTER:
 947                 reg_write(ohci, OHCI1394_IsochronousCycleTimer, arg);
 948                 break;
 949
 950         case SET_BUS_ID:
 951                 PRINT(KERN_ERR, "devctl command SET_BUS_ID err");
 952                 break;
 953
 954         case ACT_CYCLE_MASTER:
 955                 if (arg) {
 956                         /* check if we are root and other nodes are present */
 957                         u32 nodeId = reg_read(ohci, OHCI1394_NodeID);
 958                         if ((nodeId & (1<<30)) && (nodeId & 0x3f)) {
 959                                 /*
 960                                  * enable cycleTimer, cycleMaster
 961                                  */
 962                                 DBGMSG("Cycle master enabled");
 963                                 reg_write(ohci, OHCI1394_LinkControlSet,
 964                                           OHCI1394_LinkControl_CycleTimerEnable |
 965                                           OHCI1394_LinkControl_CycleMaster);
 966                         }
 967                 } else {
 968                         /* disable cycleTimer, cycleMaster, cycleSource */
 969                         reg_write(ohci, OHCI1394_LinkControlClear,
 970                                   OHCI1394_LinkControl_CycleTimerEnable |
 971                                   OHCI1394_LinkControl_CycleMaster |
 972                                   OHCI1394_LinkControl_CycleSource);
 973                 }
 974                 break;
 975
 976         case CANCEL_REQUESTS:
 977                 DBGMSG("Cancel request received");
 978                 dma_trm_reset(&ohci->at_req_context);
 979                 dma_trm_reset(&ohci->at_resp_context);
 980                 break;
 981
 982         default:
 983                 PRINT_G(KERN_ERR, "ohci_devctl cmd %d not implemented yet",
 984                         cmd);
 985                 break;
 986         }
 987         return retval;
 988 }
 989
 990 /***********************************
 991  * rawiso ISO reception            *
 992  ***********************************/
 993
 994 /*
 995   We use either buffer-fill or packet-per-buffer DMA mode. The DMA
 996   buffer is split into "blocks" (regions described by one DMA
 997   descriptor). Each block must be one page or less in size, and
 998   must not cross a page boundary.
 999
1000   There is one little wrinkle with buffer-fill mode: a packet that
1001   starts in the final block may wrap around into the first block. But
1002   the user API expects all packets to be contiguous. Our solution is
1003   to keep the very last page of the DMA buffer in reserve - if a
1004   packet spans the gap, we copy its tail into this page.
1005 */
1006
1007 struct ohci_iso_recv {
1008         struct ti_ohci *ohci;
1009
1010         struct ohci1394_iso_tasklet task;
1011         int task_active;
1012
1013         enum { BUFFER_FILL_MODE = 0,
1014                PACKET_PER_BUFFER_MODE = 1 } dma_mode;
1015
1016         /* memory and PCI mapping for the DMA descriptors */
1017         struct dma_prog_region prog;
1018         struct dma_cmd *block; /* = (struct dma_cmd*) prog.virt */
1019
1020         /* how many DMA blocks fit in the buffer */
1021         unsigned int nblocks;
1022
1023         /* stride of DMA blocks */
1024         unsigned int buf_stride;
1025
1026         /* number of blocks to batch between interrupts */
1027         int block_irq_interval;
1028
1029         /* block that DMA will finish next */
1030         int block_dma;
1031
1032         /* (buffer-fill only) block that the reader will release next */
1033         int block_reader;
1034
1035         /* (buffer-fill only) bytes of buffer the reader has released,
1036            less than one block */
1037         int released_bytes;
1038
1039         /* (buffer-fill only) buffer offset at which the next packet will appear */
1040         int dma_offset;
1041
1042         /* OHCI DMA context control registers */
1043         u32 ContextControlSet;
1044         u32 ContextControlClear;
1045         u32 CommandPtr;
1046         u32 ContextMatch;
1047 };
1048
1049 static void ohci_iso_recv_task(unsigned long data);
1050 static void ohci_iso_recv_stop(struct hpsb_iso *iso);
1051 static void ohci_iso_recv_shutdown(struct hpsb_iso *iso);
1052 static int  ohci_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync);
1053 static void ohci_iso_recv_program(struct hpsb_iso *iso);
1054
1055 static int ohci_iso_recv_init(struct hpsb_iso *iso)
1056 {
1057         struct ti_ohci *ohci = iso->host->hostdata;
1058         struct ohci_iso_recv *recv;
1059         int ctx;
1060         int ret = -ENOMEM;
1061
1062         recv = kmalloc(sizeof(*recv), GFP_KERNEL);
1063         if (!recv)
1064                 return -ENOMEM;
1065
1066         iso->hostdata = recv;
1067         recv->ohci = ohci;
1068         recv->task_active = 0;
1069         dma_prog_region_init(&recv->prog);
1070         recv->block = NULL;
1071
1072         /* use buffer-fill mode, unless irq_interval is 1
1073            (note: multichannel requires buffer-fill) */
1074
1075         if (((iso->irq_interval == 1 && iso->dma_mode == HPSB_ISO_DMA_OLD_ABI) ||
1076              iso->dma_mode == HPSB_ISO_DMA_PACKET_PER_BUFFER) && iso->channel != -1) {
1077                 recv->dma_mode = PACKET_PER_BUFFER_MODE;
1078         } else {
1079                 recv->dma_mode = BUFFER_FILL_MODE;
1080         }
1081
1082         /* set nblocks, buf_stride, block_irq_interval */
1083
1084         if (recv->dma_mode == BUFFER_FILL_MODE) {
1085                 recv->buf_stride = PAGE_SIZE;
1086
1087                 /* one block per page of data in the DMA buffer, minus the final guard page */
1088                 recv->nblocks = iso->buf_size/PAGE_SIZE - 1;
1089                 if (recv->nblocks < 3) {
1090                         DBGMSG("ohci_iso_recv_init: DMA buffer too small");
1091                         goto err;
1092                 }
1093
1094                 /* iso->irq_interval is in packets - translate that to blocks */
1095                 if (iso->irq_interval == 1)
1096                         recv->block_irq_interval = 1;
1097                 else
1098                         recv->block_irq_interval = iso->irq_interval *
1099                                                         ((recv->nblocks+1)/iso->buf_packets);
1100                 if (recv->block_irq_interval*4 > recv->nblocks)
1101                         recv->block_irq_interval = recv->nblocks/4;
1102                 if (recv->block_irq_interval < 1)
1103                         recv->block_irq_interval = 1;
1104
1105         } else {
1106                 int max_packet_size;
1107
1108                 recv->nblocks = iso->buf_packets;
1109                 recv->block_irq_interval = iso->irq_interval;
1110                 if (recv->block_irq_interval * 4 > iso->buf_packets)
1111                         recv->block_irq_interval = iso->buf_packets / 4;
1112                 if (recv->block_irq_interval < 1)
1113                 recv->block_irq_interval = 1;
1114
1115                 /* choose a buffer stride */
1116                 /* must be a power of 2, and <= PAGE_SIZE */
1117
1118                 max_packet_size = iso->buf_size / iso->buf_packets;
1119
1120                 for (recv->buf_stride = 8; recv->buf_stride < max_packet_size;
1121                     recv->buf_stride *= 2);
1122
1123                 if (recv->buf_stride*iso->buf_packets > iso->buf_size ||
1124                    recv->buf_stride > PAGE_SIZE) {
1125                         /* this shouldn't happen, but anyway... */
1126                         DBGMSG("ohci_iso_recv_init: problem choosing a buffer stride");
1127                         goto err;
1128                 }
1129         }
1130
1131         recv->block_reader = 0;
1132         recv->released_bytes = 0;
1133         recv->block_dma = 0;
1134         recv->dma_offset = 0;
1135
1136         /* size of DMA program = one descriptor per block */
1137         if (dma_prog_region_alloc(&recv->prog,
1138                                  sizeof(struct dma_cmd) * recv->nblocks,
1139                                  recv->ohci->dev))
1140                 goto err;
1141
1142         recv->block = (struct dma_cmd*) recv->prog.kvirt;
1143
1144         ohci1394_init_iso_tasklet(&recv->task,
1145                                   iso->channel == -1 ? OHCI_ISO_MULTICHANNEL_RECEIVE :
1146                                                        OHCI_ISO_RECEIVE,
1147                                   ohci_iso_recv_task, (unsigned long) iso);
1148
1149         if (ohci1394_register_iso_tasklet(recv->ohci, &recv->task) < 0) {
1150                 ret = -EBUSY;
1151                 goto err;
1152         }
1153
1154         recv->task_active = 1;
1155
1156         /* recv context registers are spaced 32 bytes apart */
1157         ctx = recv->task.context;
1158         recv->ContextControlSet = OHCI1394_IsoRcvContextControlSet + 32 * ctx;
1159         recv->ContextControlClear = OHCI1394_IsoRcvContextControlClear + 32 * ctx;
1160         recv->CommandPtr = OHCI1394_IsoRcvCommandPtr + 32 * ctx;
1161         recv->ContextMatch = OHCI1394_IsoRcvContextMatch + 32 * ctx;
1162
1163         if (iso->channel == -1) {
1164                 /* clear multi-channel selection mask */
1165                 reg_write(recv->ohci, OHCI1394_IRMultiChanMaskHiClear, 0xFFFFFFFF);
1166                 reg_write(recv->ohci, OHCI1394_IRMultiChanMaskLoClear, 0xFFFFFFFF);
1167         }
1168
1169         /* write the DMA program */
1170         ohci_iso_recv_program(iso);
1171
1172         DBGMSG("ohci_iso_recv_init: %s mode, DMA buffer is %lu pages"
1173                " (%u bytes), using %u blocks, buf_stride %u, block_irq_interval %d",
1174                recv->dma_mode == BUFFER_FILL_MODE ?
1175                "buffer-fill" : "packet-per-buffer",
1176                iso->buf_size/PAGE_SIZE, iso->buf_size,
1177                recv->nblocks, recv->buf_stride, recv->block_irq_interval);
1178
1179         return 0;
1180
1181 err:
1182         ohci_iso_recv_shutdown(iso);
1183         return ret;
1184 }
1185
1186 static void ohci_iso_recv_stop(struct hpsb_iso *iso)
1187 {
1188         struct ohci_iso_recv *recv = iso->hostdata;
1189
1190         /* disable interrupts */
1191         reg_write(recv->ohci, OHCI1394_IsoRecvIntMaskClear, 1 << recv->task.context);
1192
1193         /* halt DMA */
1194         ohci1394_stop_context(recv->ohci, recv->ContextControlClear, NULL);
1195 }
1196
1197 static void ohci_iso_recv_shutdown(struct hpsb_iso *iso)
1198 {
1199         struct ohci_iso_recv *recv = iso->hostdata;
1200
1201         if (recv->task_active) {
1202                 ohci_iso_recv_stop(iso);
1203                 ohci1394_unregister_iso_tasklet(recv->ohci, &recv->task);
1204                 recv->task_active = 0;
1205         }
1206
1207         dma_prog_region_free(&recv->prog);
1208         kfree(recv);
1209         iso->hostdata = NULL;
1210 }
1211
1212 /* set up a "gapped" ring buffer DMA program */
1213 static void ohci_iso_recv_program(struct hpsb_iso *iso)
1214 {
1215         struct ohci_iso_recv *recv = iso->hostdata;
1216         int blk;
1217
1218         /* address of 'branch' field in previous DMA descriptor */
1219         u32 *prev_branch = NULL;
1220
1221         for (blk = 0; blk < recv->nblocks; blk++) {
1222                 u32 control;
1223
1224                 /* the DMA descriptor */
1225                 struct dma_cmd *cmd = &recv->block[blk];
1226
1227                 /* offset of the DMA descriptor relative to the DMA prog buffer */
1228                 unsigned long prog_offset = blk * sizeof(struct dma_cmd);
1229
1230                 /* offset of this packet's data within the DMA buffer */
1231                 unsigned long buf_offset = blk * recv->buf_stride;
1232
1233                 if (recv->dma_mode == BUFFER_FILL_MODE) {
1234                         control = 2 << 28; /* INPUT_MORE */
1235                 } else {
1236                         control = 3 << 28; /* INPUT_LAST */
1237                 }
1238
1239                 control |= 8 << 24; /* s = 1, update xferStatus and resCount */
1240
1241                 /* interrupt on last block, and at intervals */
1242                 if (blk == recv->nblocks-1 || (blk % recv->block_irq_interval) == 0) {
1243                         control |= 3 << 20; /* want interrupt */
1244                 }
1245
1246                 control |= 3 << 18; /* enable branch to address */
1247                 control |= recv->buf_stride;
1248
1249                 cmd->control = cpu_to_le32(control);
1250                 cmd->address = cpu_to_le32(dma_region_offset_to_bus(&iso->data_buf, buf_offset));
1251                 cmd->branchAddress = 0; /* filled in on next loop */
1252                 cmd->status = cpu_to_le32(recv->buf_stride);
1253
1254                 /* link the previous descriptor to this one */
1255                 if (prev_branch) {
1256                         *prev_branch = cpu_to_le32(dma_prog_region_offset_to_bus(&recv->prog, prog_offset) | 1);
1257                 }
1258
1259                 prev_branch = &cmd->branchAddress;
1260         }
1261
1262         /* the final descriptor's branch address and Z should be left at 0 */
1263 }
1264
1265 /* listen or unlisten to a specific channel (multi-channel mode only) */
1266 static void ohci_iso_recv_change_channel(struct hpsb_iso *iso, unsigned char channel, int listen)
1267 {
1268         struct ohci_iso_recv *recv = iso->hostdata;
1269         int reg, i;
1270
1271         if (channel < 32) {
1272                 reg = listen ? OHCI1394_IRMultiChanMaskLoSet : OHCI1394_IRMultiChanMaskLoClear;
1273                 i = channel;
1274         } else {
1275                 reg = listen ? OHCI1394_IRMultiChanMaskHiSet : OHCI1394_IRMultiChanMaskHiClear;
1276                 i = channel - 32;
1277         }
1278
1279         reg_write(recv->ohci, reg, (1 << i));
1280
1281         /* issue a dummy read to force all PCI writes to be posted immediately */
1282         mb();
1283         reg_read(recv->ohci, OHCI1394_IsochronousCycleTimer);
1284 }
1285
1286 static void ohci_iso_recv_set_channel_mask(struct hpsb_iso *iso, u64 mask)
1287 {
1288         struct ohci_iso_recv *recv = iso->hostdata;
1289         int i;
1290
1291         for (i = 0; i < 64; i++) {
1292                 if (mask & (1ULL << i)) {
1293                         if (i < 32)
1294                                 reg_write(recv->ohci, OHCI1394_IRMultiChanMaskLoSet, (1 << i));
1295                         else
1296                                 reg_write(recv->ohci, OHCI1394_IRMultiChanMaskHiSet, (1 << (i-32)));
1297                 } else {
1298                         if (i < 32)
1299                                 reg_write(recv->ohci, OHCI1394_IRMultiChanMaskLoClear, (1 << i));
1300                         else
1301                                 reg_write(recv->ohci, OHCI1394_IRMultiChanMaskHiClear, (1 << (i-32)));
1302                 }
1303         }
1304
1305         /* issue a dummy read to force all PCI writes to be posted immediately */
1306         mb();
1307         reg_read(recv->ohci, OHCI1394_IsochronousCycleTimer);
1308 }
1309
1310 static int ohci_iso_recv_start(struct hpsb_iso *iso, int cycle, int tag_mask, int sync)
1311 {
1312         struct ohci_iso_recv *recv = iso->hostdata;
1313         struct ti_ohci *ohci = recv->ohci;
1314         u32 command, contextMatch;
1315
1316         reg_write(recv->ohci, recv->ContextControlClear, 0xFFFFFFFF);
1317         wmb();
1318
1319         /* always keep ISO headers */
1320         command = (1 << 30);
1321
1322         if (recv->dma_mode == BUFFER_FILL_MODE)
1323                 command |= (1 << 31);
1324
1325         reg_write(recv->ohci, recv->ContextControlSet, command);
1326
1327         /* match on specified tags */
1328         contextMatch = tag_mask << 28;
1329
1330         if (iso->channel == -1) {
1331                 /* enable multichannel reception */
1332                 reg_write(recv->ohci, recv->ContextControlSet, (1 << 28));
1333         } else {
1334                 /* listen on channel */
1335                 contextMatch |= iso->channel;
1336         }
1337
1338         if (cycle != -1) {
1339                 u32 seconds;
1340
1341                 /* enable cycleMatch */
1342                 reg_write(recv->ohci, recv->ContextControlSet, (1 << 29));
1343
1344                 /* set starting cycle */
1345                 cycle &= 0x1FFF;
1346
1347                 /* 'cycle' is only mod 8000, but we also need two 'seconds' bits -
1348                    just snarf them from the current time */
1349                 seconds = reg_read(recv->ohci, OHCI1394_IsochronousCycleTimer) >> 25;
1350
1351                 /* advance one second to give some extra time for DMA to start */
1352                 seconds += 1;
1353
1354                 cycle |= (seconds & 3) << 13;
1355
1356                 contextMatch |= cycle << 12;
1357         }
1358
1359         if (sync != -1) {
1360                 /* set sync flag on first DMA descriptor */
1361                 struct dma_cmd *cmd = &recv->block[recv->block_dma];
1362                 cmd->control |= cpu_to_le32(DMA_CTL_WAIT);
1363
1364                 /* match sync field */
1365                 contextMatch |= (sync&0xf)<<8;
1366         }
1367
1368         reg_write(recv->ohci, recv->ContextMatch, contextMatch);
1369
1370         /* address of first descriptor block */
1371         command = dma_prog_region_offset_to_bus(&recv->prog,
1372                                                 recv->block_dma * sizeof(struct dma_cmd));
1373         command |= 1; /* Z=1 */
1374
1375         reg_write(recv->ohci, recv->CommandPtr, command);
1376
1377         /* enable interrupts */
1378         reg_write(recv->ohci, OHCI1394_IsoRecvIntMaskSet, 1 << recv->task.context);
1379
1380         wmb();
1381
1382         /* run */
1383         reg_write(recv->ohci, recv->ContextControlSet, 0x8000);
1384
1385         /* issue a dummy read of the cycle timer register to force
1386            all PCI writes to be posted immediately */
1387         mb();
1388         reg_read(recv->ohci, OHCI1394_IsochronousCycleTimer);
1389
1390         /* check RUN */
1391         if (!(reg_read(recv->ohci, recv->ContextControlSet) & 0x8000)) {
1392                 PRINT(KERN_ERR,
1393                       "Error starting IR DMA (ContextControl 0x%08x)\n",
1394                       reg_read(recv->ohci, recv->ContextControlSet));
1395                 return -1;
1396         }
1397
1398         return 0;
1399 }
1400
1401 static void ohci_iso_recv_release_block(struct ohci_iso_recv *recv, int block)
1402 {
1403         /* re-use the DMA descriptor for the block */
1404         /* by linking the previous descriptor to it */
1405
1406         int next_i = block;
1407         int prev_i = (next_i == 0) ? (recv->nblocks - 1) : (next_i - 1);
1408
1409         struct dma_cmd *next = &recv->block[next_i];
1410         struct dma_cmd *prev = &recv->block[prev_i];
1411
1412         /* ignore out-of-range requests */
1413         if ((block < 0) || (block > recv->nblocks))
1414                 return;
1415
1416         /* 'next' becomes the new end of the DMA chain,
1417            so disable branch and enable interrupt */
1418         next->branchAddress = 0;
1419         next->control |= cpu_to_le32(3 << 20);
1420         next->status = cpu_to_le32(recv->buf_stride);
1421
1422         /* link prev to next */
1423         prev->branchAddress = cpu_to_le32(dma_prog_region_offset_to_bus(&recv->prog,
1424                                                                         sizeof(struct dma_cmd) * next_i)
1425                                           | 1); /* Z=1 */
1426
1427         /* disable interrupt on previous DMA descriptor, except at intervals */
1428         if ((prev_i % recv->block_irq_interval) == 0) {
1429                 prev->control |= cpu_to_le32(3 << 20); /* enable interrupt */
1430         } else {
1431                 prev->control &= cpu_to_le32(~(3<<20)); /* disable interrupt */
1432         }
1433         wmb();
1434
1435         /* wake up DMA in case it fell asleep */
1436         reg_write(recv->ohci, recv->ContextControlSet, (1 << 12));
1437 }
1438
1439 static void ohci_iso_recv_bufferfill_release(struct ohci_iso_recv *recv,
1440                                              struct hpsb_iso_packet_info *info)
1441 {
1442         /* release the memory where the packet was */
1443         recv->released_bytes += info->total_len;
1444
1445         /* have we released enough memory for one block? */
1446         while (recv->released_bytes > recv->buf_stride) {
1447                 ohci_iso_recv_release_block(recv, recv->block_reader);
1448                 recv->block_reader = (recv->block_reader + 1) % recv->nblocks;
1449                 recv->released_bytes -= recv->buf_stride;
1450         }
1451 }
1452
1453 static inline void ohci_iso_recv_release(struct hpsb_iso *iso, struct hpsb_iso_packet_info *info)
1454 {
1455         struct ohci_iso_recv *recv = iso->hostdata;
1456         if (recv->dma_mode == BUFFER_FILL_MODE) {
1457                 ohci_iso_recv_bufferfill_release(recv, info);
1458         } else {
1459                 ohci_iso_recv_release_block(recv, info - iso->infos);
1460         }
1461 }
1462
1463 /* parse all packets from blocks that have been fully received */
1464 static void ohci_iso_recv_bufferfill_parse(struct hpsb_iso *iso, struct ohci_iso_recv *recv)
1465 {
1466         int wake = 0;
1467         int runaway = 0;
1468         struct ti_ohci *ohci = recv->ohci;
1469
1470         while (1) {
1471                 /* we expect the next parsable packet to begin at recv->dma_offset */
1472                 /* note: packet layout is as shown in section 10.6.1.1 of the OHCI spec */
1473
1474                 unsigned int offset;
1475                 unsigned short len, cycle, total_len;
1476                 unsigned char channel, tag, sy;
1477
1478                 unsigned char *p = iso->data_buf.kvirt;
1479
1480                 unsigned int this_block = recv->dma_offset/recv->buf_stride;
1481
1482                 /* don't loop indefinitely */
1483                 if (runaway++ > 100000) {
1484                         atomic_inc(&iso->overflows);
1485                         PRINT(KERN_ERR,
1486                               "IR DMA error - Runaway during buffer parsing!\n");
1487                         break;
1488                 }
1489
1490                 /* stop parsing once we arrive at block_dma (i.e. don't get ahead of DMA) */
1491                 if (this_block == recv->block_dma)
1492                         break;
1493
1494                 wake = 1;
1495
1496                 /* parse data length, tag, channel, and sy */
1497
1498                 /* note: we keep our own local copies of 'len' and 'offset'
1499                    so the user can't mess with them by poking in the mmap area */
1500
1501                 len = p[recv->dma_offset+2] | (p[recv->dma_offset+3] << 8);
1502
1503                 if (len > 4096) {
1504                         PRINT(KERN_ERR,
1505                               "IR DMA error - bogus 'len' value %u\n", len);
1506                 }
1507
1508                 channel = p[recv->dma_offset+1] & 0x3F;
1509                 tag = p[recv->dma_offset+1] >> 6;
1510                 sy = p[recv->dma_offset+0] & 0xF;
1511
1512                 /* advance to data payload */
1513                 recv->dma_offset += 4;
1514
1515                 /* check for wrap-around */
1516                 if (recv->dma_offset >= recv->buf_stride*recv->nblocks) {
1517                         recv->dma_offset -= recv->buf_stride*recv->nblocks;
1518                 }
1519
1520                 /* dma_offset now points to the first byte of the data payload */
1521                 offset = recv->dma_offset;
1522
1523                 /* advance to xferStatus/timeStamp */
1524                 recv->dma_offset += len;
1525
1526                 total_len = len + 8; /* 8 bytes header+trailer in OHCI packet */
1527                 /* payload is padded to 4 bytes */
1528                 if (len % 4) {
1529                         recv->dma_offset += 4 - (len%4);
1530                         total_len += 4 - (len%4);
1531                 }
1532
1533                 /* check for wrap-around */
1534                 if (recv->dma_offset >= recv->buf_stride*recv->nblocks) {
1535                         /* uh oh, the packet data wraps from the last
1536                            to the first DMA block - make the packet
1537                            contiguous by copying its "tail" into the
1538                            guard page */
1539
1540                         int guard_off = recv->buf_stride*recv->nblocks;
1541                         int tail_len = len - (guard_off - offset);
1542
1543                         if (tail_len > 0  && tail_len < recv->buf_stride) {
1544                                 memcpy(iso->data_buf.kvirt + guard_off,
1545                                        iso->data_buf.kvirt,
1546                                        tail_len);
1547                         }
1548
1549                         recv->dma_offset -= recv->buf_stride*recv->nblocks;
1550                 }
1551
1552                 /* parse timestamp */
1553                 cycle = p[recv->dma_offset+0] | (p[recv->dma_offset+1]<<8);
1554                 cycle &= 0x1FFF;
1555
1556                 /* advance to next packet */
1557                 recv->dma_offset += 4;
1558
1559                 /* check for wrap-around */
1560                 if (recv->dma_offset >= recv->buf_stride*recv->nblocks) {
1561                         recv->dma_offset -= recv->buf_stride*recv->nblocks;
1562                 }
1563
1564                 hpsb_iso_packet_received(iso, offset, len, total_len, cycle, channel, tag, sy);
1565         }
1566
1567         if (wake)
1568                 hpsb_iso_wake(iso);
1569 }
1570
1571 static void ohci_iso_recv_bufferfill_task(struct hpsb_iso *iso, struct ohci_iso_recv *recv)
1572 {
1573         int loop;
1574         struct ti_ohci *ohci = recv->ohci;
1575
1576         /* loop over all blocks */
1577         for (loop = 0; loop < recv->nblocks; loop++) {
1578
1579                 /* check block_dma to see if it's done */
1580                 struct dma_cmd *im = &recv->block[recv->block_dma];
1581
1582                 /* check the DMA descriptor for new writes to xferStatus */
1583                 u16 xferstatus = le32_to_cpu(im->status) >> 16;
1584
1585                 /* rescount is the number of bytes *remaining to be written* in the block */
1586                 u16 rescount = le32_to_cpu(im->status) & 0xFFFF;
1587
1588                 unsigned char event = xferstatus & 0x1F;
1589
1590                 if (!event) {
1591                         /* nothing has happened to this block yet */
1592                         break;
1593                 }
1594
1595                 if (event != 0x11) {
1596                         atomic_inc(&iso->overflows);
1597                         PRINT(KERN_ERR,
1598                               "IR DMA error - OHCI error code 0x%02x\n", event);
1599                 }
1600
1601                 if (rescount != 0) {
1602                         /* the card is still writing to this block;
1603                            we can't touch it until it's done */
1604                         break;
1605                 }
1606
1607                 /* OK, the block is finished... */
1608
1609                 /* sync our view of the block */
1610                 dma_region_sync_for_cpu(&iso->data_buf, recv->block_dma*recv->buf_stride, recv->buf_stride);
1611
1612                 /* reset the DMA descriptor */
1613                 im->status = recv->buf_stride;
1614
1615                 /* advance block_dma */
1616                 recv->block_dma = (recv->block_dma + 1) % recv->nblocks;
1617
1618                 if ((recv->block_dma+1) % recv->nblocks == recv->block_reader) {
1619                         atomic_inc(&iso->overflows);
1620                         DBGMSG("ISO reception overflow - "
1621                                "ran out of DMA blocks");
1622                 }
1623         }
1624
1625         /* parse any packets that have arrived */
1626         ohci_iso_recv_bufferfill_parse(iso, recv);
1627 }
1628
1629 static void ohci_iso_recv_packetperbuf_task(struct hpsb_iso *iso, struct ohci_iso_recv *recv)
1630 {
1631         int count;
1632         int wake = 0;
1633         struct ti_ohci *ohci = recv->ohci;
1634
1635         /* loop over the entire buffer */
1636         for (count = 0; count < recv->nblocks; count++) {
1637                 u32 packet_len = 0;
1638
1639                 /* pointer to the DMA descriptor */
1640                 struct dma_cmd *il = ((struct dma_cmd*) recv->prog.kvirt) + iso->pkt_dma;
1641
1642                 /* check the DMA descriptor for new writes to xferStatus */
1643                 u16 xferstatus = le32_to_cpu(il->status) >> 16;
1644                 u16 rescount = le32_to_cpu(il->status) & 0xFFFF;
1645
1646                 unsigned char event = xferstatus & 0x1F;
1647
1648                 if (!event) {
1649                         /* this packet hasn't come in yet; we are done for now */
1650                         goto out;
1651                 }
1652
1653                 if (event == 0x11) {
1654                         /* packet received successfully! */
1655
1656                         /* rescount is the number of bytes *remaining* in the packet buffer,
1657                            after the packet was written */
1658                         packet_len = recv->buf_stride - rescount;
1659
1660                 } else if (event == 0x02) {
1661                         PRINT(KERN_ERR, "IR DMA error - packet too long for buffer\n");
1662                 } else if (event) {
1663                         PRINT(KERN_ERR, "IR DMA error - OHCI error code 0x%02x\n", event);
1664                 }
1665
1666                 /* sync our view of the buffer */
1667                 dma_region_sync_for_cpu(&iso->data_buf, iso->pkt_dma * recv->buf_stride, recv->buf_stride);
1668
1669                 /* record the per-packet info */
1670                 {
1671                         /* iso header is 8 bytes ahead of the data payload */
1672                         unsigned char *hdr;
1673
1674                         unsigned int offset;
1675                         unsigned short cycle;
1676                         unsigned char channel, tag, sy;
1677
1678                         offset = iso->pkt_dma * recv->buf_stride;
1679                         hdr = iso->data_buf.kvirt + offset;
1680
1681                         /* skip iso header */
1682                         offset += 8;
1683                         packet_len -= 8;
1684
1685                         cycle = (hdr[0] | (hdr[1] << 8)) & 0x1FFF;
1686                         channel = hdr[5] & 0x3F;
1687                         tag = hdr[5] >> 6;
1688                         sy = hdr[4] & 0xF;
1689
1690                         hpsb_iso_packet_received(iso, offset, packet_len,
1691                                         recv->buf_stride, cycle, channel, tag, sy);
1692                 }
1693
1694                 /* reset the DMA descriptor */
1695                 il->status = recv->buf_stride;
1696
1697                 wake = 1;
1698                 recv->block_dma = iso->pkt_dma;
1699         }
1700
1701 out:
1702         if (wake)
1703                 hpsb_iso_wake(iso);
1704 }
1705
1706 static void ohci_iso_recv_task(unsigned long data)
1707 {
1708         struct hpsb_iso *iso = (struct hpsb_iso*) data;
1709         struct ohci_iso_recv *recv = iso->hostdata;
1710
1711         if (recv->dma_mode == BUFFER_FILL_MODE)
1712                 ohci_iso_recv_bufferfill_task(iso, recv);
1713         else
1714                 ohci_iso_recv_packetperbuf_task(iso, recv);
1715 }
1716
1717 /***********************************
1718  * rawiso ISO transmission         *
1719  ***********************************/
1720
1721 struct ohci_iso_xmit {
1722         struct ti_ohci *ohci;
1723         struct dma_prog_region prog;
1724         struct ohci1394_iso_tasklet task;
1725         int task_active;
1726
1727         u32 ContextControlSet;
1728         u32 ContextControlClear;
1729         u32 CommandPtr;
1730 };
1731
1732 /* transmission DMA program:
1733    one OUTPUT_MORE_IMMEDIATE for the IT header
1734    one OUTPUT_LAST for the buffer data */
1735
1736 struct iso_xmit_cmd {
1737         struct dma_cmd output_more_immediate;
1738         u8 iso_hdr[8];
1739         u32 unused[2];
1740         struct dma_cmd output_last;
1741 };
1742
1743 static int ohci_iso_xmit_init(struct hpsb_iso *iso);
1744 static int ohci_iso_xmit_start(struct hpsb_iso *iso, int cycle);
1745 static void ohci_iso_xmit_shutdown(struct hpsb_iso *iso);
1746 static void ohci_iso_xmit_task(unsigned long data);
1747
1748 static int ohci_iso_xmit_init(struct hpsb_iso *iso)
1749 {
1750         struct ohci_iso_xmit *xmit;
1751         unsigned int prog_size;
1752         int ctx;
1753         int ret = -ENOMEM;
1754
1755         xmit = kmalloc(sizeof(*xmit), GFP_KERNEL);
1756         if (!xmit)
1757                 return -ENOMEM;
1758
1759         iso->hostdata = xmit;
1760         xmit->ohci = iso->host->hostdata;
1761         xmit->task_active = 0;
1762
1763         dma_prog_region_init(&xmit->prog);
1764
1765         prog_size = sizeof(struct iso_xmit_cmd) * iso->buf_packets;
1766
1767         if (dma_prog_region_alloc(&xmit->prog, prog_size, xmit->ohci->dev))
1768                 goto err;
1769
1770         ohci1394_init_iso_tasklet(&xmit->task, OHCI_ISO_TRANSMIT,
1771                                   ohci_iso_xmit_task, (unsigned long) iso);
1772
1773         if (ohci1394_register_iso_tasklet(xmit->ohci, &xmit->task) < 0) {
1774                 ret = -EBUSY;
1775                 goto err;
1776         }
1777
1778         xmit->task_active = 1;
1779
1780         /* xmit context registers are spaced 16 bytes apart */
1781         ctx = xmit->task.context;
1782         xmit->ContextControlSet = OHCI1394_IsoXmitContextControlSet + 16 * ctx;
1783         xmit->ContextControlClear = OHCI1394_IsoXmitContextControlClear + 16 * ctx;
1784         xmit->CommandPtr = OHCI1394_IsoXmitCommandPtr + 16 * ctx;
1785
1786         return 0;
1787
1788 err:
1789         ohci_iso_xmit_shutdown(iso);
1790         return ret;
1791 }
1792
1793 static void ohci_iso_xmit_stop(struct hpsb_iso *iso)
1794 {
1795         struct ohci_iso_xmit *xmit = iso->hostdata;
1796         struct ti_ohci *ohci = xmit->ohci;
1797
1798         /* disable interrupts */
1799         reg_write(xmit->ohci, OHCI1394_IsoXmitIntMaskClear, 1 << xmit->task.context);
1800
1801         /* halt DMA */
1802         if (ohci1394_stop_context(xmit->ohci, xmit->ContextControlClear, NULL)) {
1803                 /* XXX the DMA context will lock up if you try to send too much data! */
1804                 PRINT(KERN_ERR,
1805                       "you probably exceeded the OHCI card's bandwidth limit - "
1806                       "reload the module and reduce xmit bandwidth");
1807         }
1808 }
1809
1810 static void ohci_iso_xmit_shutdown(struct hpsb_iso *iso)
1811 {
1812         struct ohci_iso_xmit *xmit = iso->hostdata;
1813
1814         if (xmit->task_active) {
1815                 ohci_iso_xmit_stop(iso);
1816                 ohci1394_unregister_iso_tasklet(xmit->ohci, &xmit->task);
1817                 xmit->task_active = 0;
1818         }
1819
1820         dma_prog_region_free(&xmit->prog);
1821         kfree(xmit);
1822         iso->hostdata = NULL;
1823 }
1824
1825 static void ohci_iso_xmit_task(unsigned long data)
1826 {
1827         struct hpsb_iso *iso = (struct hpsb_iso*) data;
1828         struct ohci_iso_xmit *xmit = iso->hostdata;
1829         struct ti_ohci *ohci = xmit->ohci;
1830         int wake = 0;
1831         int count;
1832
1833         /* check the whole buffer if necessary, starting at pkt_dma */
1834         for (count = 0; count < iso->buf_packets; count++) {
1835                 int cycle;
1836
1837                 /* DMA descriptor */
1838                 struct iso_xmit_cmd *cmd = dma_region_i(&xmit->prog, struct iso_xmit_cmd, iso->pkt_dma);
1839
1840                 /* check for new writes to xferStatus */
1841                 u16 xferstatus = le32_to_cpu(cmd->output_last.status) >> 16;
1842                 u8  event = xferstatus & 0x1F;
1843
1844                 if (!event) {
1845                         /* packet hasn't been sent yet; we are done for now */
1846                         break;
1847                 }
1848
1849                 if (event != 0x11)
1850                         PRINT(KERN_ERR,
1851                               "IT DMA error - OHCI error code 0x%02x\n", event);
1852
1853                 /* at least one packet went out, so wake up the writer */
1854                 wake = 1;
1855
1856                 /* parse cycle */
1857                 cycle = le32_to_cpu(cmd->output_last.status) & 0x1FFF;
1858
1859                 /* tell the subsystem the packet has gone out */
1860                 hpsb_iso_packet_sent(iso, cycle, event != 0x11);
1861
1862                 /* reset the DMA descriptor for next time */
1863                 cmd->output_last.status = 0;
1864         }
1865
1866         if (wake)
1867                 hpsb_iso_wake(iso);
1868 }
1869
1870 static int ohci_iso_xmit_queue(struct hpsb_iso *iso, struct hpsb_iso_packet_info *info)
1871 {
1872         struct ohci_iso_xmit *xmit = iso->hostdata;
1873         struct ti_ohci *ohci = xmit->ohci;
1874
1875         int next_i, prev_i;
1876         struct iso_xmit_cmd *next, *prev;
1877
1878         unsigned int offset;
1879         unsigned short len;
1880         unsigned char tag, sy;
1881
1882         /* check that the packet doesn't cross a page boundary
1883            (we could allow this if we added OUTPUT_MORE descriptor support) */
1884         if (cross_bound(info->offset, info->len)) {
1885                 PRINT(KERN_ERR,
1886                       "rawiso xmit: packet %u crosses a page boundary",
1887                       iso->first_packet);
1888                 return -EINVAL;
1889         }
1890
1891         offset = info->offset;
1892         len = info->len;
1893         tag = info->tag;
1894         sy = info->sy;
1895
1896         /* sync up the card's view of the buffer */
1897         dma_region_sync_for_device(&iso->data_buf, offset, len);
1898
1899         /* append first_packet to the DMA chain */
1900         /* by linking the previous descriptor to it */
1901         /* (next will become the new end of the DMA chain) */
1902
1903         next_i = iso->first_packet;
1904         prev_i = (next_i == 0) ? (iso->buf_packets - 1) : (next_i - 1);
1905
1906         next = dma_region_i(&xmit->prog, struct iso_xmit_cmd, next_i);
1907         prev = dma_region_i(&xmit->prog, struct iso_xmit_cmd, prev_i);
1908
1909         /* set up the OUTPUT_MORE_IMMEDIATE descriptor */
1910         memset(next, 0, sizeof(struct iso_xmit_cmd));
1911         next->output_more_immediate.control = cpu_to_le32(0x02000008);
1912
1913         /* ISO packet header is embedded in the OUTPUT_MORE_IMMEDIATE */
1914
1915         /* tcode = 0xA, and sy */
1916         next->iso_hdr[0] = 0xA0 | (sy & 0xF);
1917
1918         /* tag and channel number */
1919         next->iso_hdr[1] = (tag << 6) | (iso->channel & 0x3F);
1920
1921         /* transmission speed */
1922         next->iso_hdr[2] = iso->speed & 0x7;
1923
1924         /* payload size */
1925         next->iso_hdr[6] = len & 0xFF;
1926         next->iso_hdr[7] = len >> 8;
1927
1928         /* set up the OUTPUT_LAST */
1929         next->output_last.control = cpu_to_le32(1 << 28);
1930         next->output_last.control |= cpu_to_le32(1 << 27); /* update timeStamp */
1931         next->output_last.control |= cpu_to_le32(3 << 20); /* want interrupt */
1932         next->output_last.control |= cpu_to_le32(3 << 18); /* enable branch */
1933         next->output_last.control |= cpu_to_le32(len);
1934
1935         /* payload bus address */
1936         next->output_last.address = cpu_to_le32(dma_region_offset_to_bus(&iso->data_buf, offset));
1937
1938         /* leave branchAddress at zero for now */
1939
1940         /* re-write the previous DMA descriptor to chain to this one */
1941
1942         /* set prev branch address to point to next (Z=3) */
1943         prev->output_last.branchAddress = cpu_to_le32(
1944                 dma_prog_region_offset_to_bus(&xmit->prog, sizeof(struct iso_xmit_cmd) * next_i) | 3);
1945
1946         /* disable interrupt, unless required by the IRQ interval */
1947         if (prev_i % iso->irq_interval) {
1948                 prev->output_last.control &= cpu_to_le32(~(3 << 20)); /* no interrupt */
1949         } else {
1950                 prev->output_last.control |= cpu_to_le32(3 << 20); /* enable interrupt */
1951         }
1952
1953         wmb();
1954
1955         /* wake DMA in case it is sleeping */
1956         reg_write(xmit->ohci, xmit->ContextControlSet, 1 << 12);
1957
1958         /* issue a dummy read of the cycle timer to force all PCI
1959            writes to be posted immediately */
1960         mb();
1961         reg_read(xmit->ohci, OHCI1394_IsochronousCycleTimer);
1962
1963         return 0;
1964 }
1965
1966 static int ohci_iso_xmit_start(struct hpsb_iso *iso, int cycle)
1967 {
1968         struct ohci_iso_xmit *xmit = iso->hostdata;
1969         struct ti_ohci *ohci = xmit->ohci;
1970
1971         /* clear out the control register */
1972         reg_write(xmit->ohci, xmit->ContextControlClear, 0xFFFFFFFF);
1973         wmb();
1974
1975         /* address and length of first descriptor block (Z=3) */
1976         reg_write(xmit->ohci, xmit->CommandPtr,
1977                   dma_prog_region_offset_to_bus(&xmit->prog, iso->pkt_dma * sizeof(struct iso_xmit_cmd)) | 3);
1978
1979         /* cycle match */
1980         if (cycle != -1) {
1981                 u32 start = cycle & 0x1FFF;
1982
1983                 /* 'cycle' is only mod 8000, but we also need two 'seconds' bits -
1984                    just snarf them from the current time */
1985                 u32 seconds = reg_read(xmit->ohci, OHCI1394_IsochronousCycleTimer) >> 25;
1986
1987                 /* advance one second to give some extra time for DMA to start */
1988                 seconds += 1;
1989
1990                 start |= (seconds & 3) << 13;
1991
1992                 reg_write(xmit->ohci, xmit->ContextControlSet, 0x80000000 | (start << 16));
1993         }
1994
1995         /* enable interrupts */
1996         reg_write(xmit->ohci, OHCI1394_IsoXmitIntMaskSet, 1 << xmit->task.context);
1997
1998         /* run */
1999         reg_write(xmit->ohci, xmit->ContextControlSet, 0x8000);
2000         mb();
2001
2002         /* wait 100 usec to give the card time to go active */
2003         udelay(100);
2004
2005         /* check the RUN bit */
2006         if (!(reg_read(xmit->ohci, xmit->ContextControlSet) & 0x8000)) {
2007                 PRINT(KERN_ERR, "Error starting IT DMA (ContextControl 0x%08x)\n",
2008                       reg_read(xmit->ohci, xmit->ContextControlSet));
2009                 return -1;
2010         }
2011
2012         return 0;
2013 }
2014
2015 static int ohci_isoctl(struct hpsb_iso *iso, enum isoctl_cmd cmd, unsigned long arg)
2016 {
2017
2018         switch(cmd) {
2019         case XMIT_INIT:
2020                 return ohci_iso_xmit_init(iso);
2021         case XMIT_START:
2022                 return ohci_iso_xmit_start(iso, arg);
2023         case XMIT_STOP:
2024                 ohci_iso_xmit_stop(iso);
2025                 return 0;
2026         case XMIT_QUEUE:
2027                 return ohci_iso_xmit_queue(iso, (struct hpsb_iso_packet_info*) arg);
2028         case XMIT_SHUTDOWN:
2029                 ohci_iso_xmit_shutdown(iso);
2030                 return 0;
2031
2032         case RECV_INIT:
2033                 return ohci_iso_recv_init(iso);
2034         case RECV_START: {
2035                 int *args = (int*) arg;
2036                 return ohci_iso_recv_start(iso, args[0], args[1], args[2]);
2037         }
2038         case RECV_STOP:
2039                 ohci_iso_recv_stop(iso);
2040                 return 0;
2041         case RECV_RELEASE:
2042                 ohci_iso_recv_release(iso, (struct hpsb_iso_packet_info*) arg);
2043                 return 0;
2044         case RECV_FLUSH:
2045                 ohci_iso_recv_task((unsigned long) iso);
2046                 return 0;
2047         case RECV_SHUTDOWN:
2048                 ohci_iso_recv_shutdown(iso);
2049                 return 0;
2050         case RECV_LISTEN_CHANNEL:
2051                 ohci_iso_recv_change_channel(iso, arg, 1);
2052                 return 0;
2053         case RECV_UNLISTEN_CHANNEL:
2054                 ohci_iso_recv_change_channel(iso, arg, 0);
2055                 return 0;
2056         case RECV_SET_CHANNEL_MASK:
2057                 ohci_iso_recv_set_channel_mask(iso, *((u64*) arg));
2058                 return 0;
2059
2060         default:
2061                 PRINT_G(KERN_ERR, "ohci_isoctl cmd %d not implemented yet",
2062                         cmd);
2063                 break;
2064         }
2065         return -EINVAL;
2066 }
2067
2068 /***************************************
2069  * IEEE-1394 functionality section END *
2070  ***************************************/
2071
2072
2073 /********************************************************
2074  * Global stuff (interrupt handler, init/shutdown code) *
2075  ********************************************************/
2076
2077 static void dma_trm_reset(struct dma_trm_ctx *d)
2078 {
2079         unsigned long flags;
2080         LIST_HEAD(packet_list);
2081         struct ti_ohci *ohci = d->ohci;
2082         struct hpsb_packet *packet, *ptmp;
2083
2084         ohci1394_stop_context(ohci, d->ctrlClear, NULL);
2085
2086         /* Lock the context, reset it and release it. Move the packets
2087          * that were pending in the context to packet_list and free
2088          * them after releasing the lock. */
2089
2090         spin_lock_irqsave(&d->lock, flags);
2091
2092         list_splice(&d->fifo_list, &packet_list);
2093         list_splice(&d->pending_list, &packet_list);
2094         INIT_LIST_HEAD(&d->fifo_list);
2095         INIT_LIST_HEAD(&d->pending_list);
2096
2097         d->branchAddrPtr = NULL;
2098         d->sent_ind = d->prg_ind;
2099         d->free_prgs = d->num_desc;
2100
2101         spin_unlock_irqrestore(&d->lock, flags);
2102
2103         if (list_empty(&packet_list))
2104                 return;
2105
2106         PRINT(KERN_INFO, "AT dma reset ctx=%d, aborting transmission", d->ctx);
2107
2108         /* Now process subsystem callbacks for the packets from this
2109          * context. */
2110         list_for_each_entry_safe(packet, ptmp, &packet_list, driver_list) {
2111                 list_del_init(&packet->driver_list);
2112                 hpsb_packet_sent(ohci->host, packet, ACKX_ABORTED);
2113         }
2114 }
2115
2116 static void ohci_schedule_iso_tasklets(struct ti_ohci *ohci,
2117                                        quadlet_t rx_event,
2118                                        quadlet_t tx_event)
2119 {
2120         struct ohci1394_iso_tasklet *t;
2121         unsigned long mask;
2122         unsigned long flags;
2123
2124         spin_lock_irqsave(&ohci->iso_tasklet_list_lock, flags);
2125
2126         list_for_each_entry(t, &ohci->iso_tasklet_list, link) {
2127                 mask = 1 << t->context;
2128
2129                 if (t->type == OHCI_ISO_TRANSMIT && tx_event & mask)
2130                         tasklet_schedule(&t->tasklet);
2131                 else if (rx_event & mask)
2132                         tasklet_schedule(&t->tasklet);
2133         }
2134
2135         spin_unlock_irqrestore(&ohci->iso_tasklet_list_lock, flags);
2136 }
2137
2138 static irqreturn_t ohci_irq_handler(int irq, void *dev_id)
2139 {
2140         quadlet_t event, node_id;
2141         struct ti_ohci *ohci = (struct ti_ohci *)dev_id;
2142         struct hpsb_host *host = ohci->host;
2143         int phyid = -1, isroot = 0;
2144         unsigned long flags;
2145
2146         /* Read and clear the interrupt event register.  Don't clear
2147          * the busReset event, though. This is done when we get the
2148          * selfIDComplete interrupt. */
2149         spin_lock_irqsave(&ohci->event_lock, flags);
2150         event = reg_read(ohci, OHCI1394_IntEventClear);
2151         reg_write(ohci, OHCI1394_IntEventClear, event & ~OHCI1394_busReset);
2152         spin_unlock_irqrestore(&ohci->event_lock, flags);
2153
2154         if (!event)
2155                 return IRQ_NONE;
2156
2157         /* If event is ~(u32)0 cardbus card was ejected.  In this case
2158          * we just return, and clean up in the ohci1394_pci_remove
2159          * function. */
2160         if (event == ~(u32) 0) {
2161                 DBGMSG("Device removed.");
2162                 return IRQ_NONE;
2163         }
2164
2165         DBGMSG("IntEvent: %08x", event);
2166
2167         if (event & OHCI1394_unrecoverableError) {
2168                 int ctx;
2169                 PRINT(KERN_ERR, "Unrecoverable error!");
2170
2171                 if (reg_read(ohci, OHCI1394_AsReqTrContextControlSet) & 0x800)
2172                         PRINT(KERN_ERR, "Async Req Tx Context died: "
2173                                 "ctrl[%08x] cmdptr[%08x]",
2174                                 reg_read(ohci, OHCI1394_AsReqTrContextControlSet),
2175                                 reg_read(ohci, OHCI1394_AsReqTrCommandPtr));
2176
2177                 if (reg_read(ohci, OHCI1394_AsRspTrContextControlSet) & 0x800)
2178                         PRINT(KERN_ERR, "Async Rsp Tx Context died: "
2179                                 "ctrl[%08x] cmdptr[%08x]",
2180                                 reg_read(ohci, OHCI1394_AsRspTrContextControlSet),
2181                                 reg_read(ohci, OHCI1394_AsRspTrCommandPtr));
2182
2183                 if (reg_read(ohci, OHCI1394_AsReqRcvContextControlSet) & 0x800)
2184                         PRINT(KERN_ERR, "Async Req Rcv Context died: "
2185                                 "ctrl[%08x] cmdptr[%08x]",
2186                                 reg_read(ohci, OHCI1394_AsReqRcvContextControlSet),
2187                                 reg_read(ohci, OHCI1394_AsReqRcvCommandPtr));
2188
2189                 if (reg_read(ohci, OHCI1394_AsRspRcvContextControlSet) & 0x800)
2190                         PRINT(KERN_ERR, "Async Rsp Rcv Context died: "
2191                                 "ctrl[%08x] cmdptr[%08x]",
2192                                 reg_read(ohci, OHCI1394_AsRspRcvContextControlSet),
2193                                 reg_read(ohci, OHCI1394_AsRspRcvCommandPtr));
2194
2195                 for (ctx = 0; ctx < ohci->nb_iso_xmit_ctx; ctx++) {
2196                         if (reg_read(ohci, OHCI1394_IsoXmitContextControlSet + (16 * ctx)) & 0x800)
2197                                 PRINT(KERN_ERR, "Iso Xmit %d Context died: "
2198                                         "ctrl[%08x] cmdptr[%08x]", ctx,
2199                                         reg_read(ohci, OHCI1394_IsoXmitContextControlSet + (16 * ctx)),
2200                                         reg_read(ohci, OHCI1394_IsoXmitCommandPtr + (16 * ctx)));
2201                 }
2202
2203                 for (ctx = 0; ctx < ohci->nb_iso_rcv_ctx; ctx++) {
2204                         if (reg_read(ohci, OHCI1394_IsoRcvContextControlSet + (32 * ctx)) & 0x800)
2205                                 PRINT(KERN_ERR, "Iso Recv %d Context died: "
2206                                         "ctrl[%08x] cmdptr[%08x] match[%08x]", ctx,
2207                                         reg_read(ohci, OHCI1394_IsoRcvContextControlSet + (32 * ctx)),
2208                                         reg_read(ohci, OHCI1394_IsoRcvCommandPtr + (32 * ctx)),
2209                                         reg_read(ohci, OHCI1394_IsoRcvContextMatch + (32 * ctx)));
2210                 }
2211
2212                 event &= ~OHCI1394_unrecoverableError;
2213         }
2214         if (event & OHCI1394_postedWriteErr) {
2215                 PRINT(KERN_ERR, "physical posted write error");
2216                 /* no recovery strategy yet, had to involve protocol drivers */
2217                 event &= ~OHCI1394_postedWriteErr;
2218         }
2219         if (event & OHCI1394_cycleTooLong) {
2220                 if(printk_ratelimit())
2221                         PRINT(KERN_WARNING, "isochronous cycle too long");
2222                 else
2223                         DBGMSG("OHCI1394_cycleTooLong");
2224                 reg_write(ohci, OHCI1394_LinkControlSet,
2225                           OHCI1394_LinkControl_CycleMaster);
2226                 event &= ~OHCI1394_cycleTooLong;
2227         }
2228         if (event & OHCI1394_cycleInconsistent) {
2229                 /* We subscribe to the cycleInconsistent event only to
2230                  * clear the corresponding event bit... otherwise,
2231                  * isochronous cycleMatch DMA won't work. */
2232                 DBGMSG("OHCI1394_cycleInconsistent");
2233                 event &= ~OHCI1394_cycleInconsistent;
2234         }
2235         if (event & OHCI1394_busReset) {
2236                 /* The busReset event bit can't be cleared during the
2237                  * selfID phase, so we disable busReset interrupts, to
2238                  * avoid burying the cpu in interrupt requests. */
2239                 spin_lock_irqsave(&ohci->event_lock, flags);
2240                 reg_write(ohci, OHCI1394_IntMaskClear, OHCI1394_busReset);
2241
2242                 if (ohci->check_busreset) {
2243                         int loop_count = 0;
2244
2245                         udelay(10);
2246
2247                         while (reg_read(ohci, OHCI1394_IntEventSet) & OHCI1394_busReset) {
2248                                 reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
2249
2250                                 spin_unlock_irqrestore(&ohci->event_lock, flags);
2251                                 udelay(10);
2252                                 spin_lock_irqsave(&ohci->event_lock, flags);
2253
2254                                 /* The loop counter check is to prevent the driver
2255                                  * from remaining in this state forever. For the
2256                                  * initial bus reset, the loop continues for ever
2257                                  * and the system hangs, until some device is plugged-in
2258                                  * or out manually into a port! The forced reset seems
2259                                  * to solve this problem. This mainly effects nForce2. */
2260                                 if (loop_count > 10000) {
2261                                         ohci_devctl(host, RESET_BUS, LONG_RESET);
2262                                         DBGMSG("Detected bus-reset loop. Forced a bus reset!");
2263                                         loop_count = 0;
2264                                 }
2265
2266                                 loop_count++;
2267                         }
2268                 }
2269                 spin_unlock_irqrestore(&ohci->event_lock, flags);
2270                 if (!host->in_bus_reset) {
2271                         DBGMSG("irq_handler: Bus reset requested");
2272
2273                         /* Subsystem call */
2274                         hpsb_bus_reset(ohci->host);
2275                 }
2276                 event &= ~OHCI1394_busReset;
2277         }
2278         if (event & OHCI1394_reqTxComplete) {
2279                 struct dma_trm_ctx *d = &ohci->at_req_context;
2280                 DBGMSG("Got reqTxComplete interrupt "
2281                        "status=0x%08X", reg_read(ohci, d->ctrlSet));
2282                 if (reg_read(ohci, d->ctrlSet) & 0x800)
2283                         ohci1394_stop_context(ohci, d->ctrlClear,
2284                                               "reqTxComplete");
2285                 else
2286                         dma_trm_tasklet((unsigned long)d);
2287                         //tasklet_schedule(&d->task);
2288                 event &= ~OHCI1394_reqTxComplete;
2289         }
2290         if (event & OHCI1394_respTxComplete) {
2291                 struct dma_trm_ctx *d = &ohci->at_resp_context;
2292                 DBGMSG("Got respTxComplete interrupt "
2293                        "status=0x%08X", reg_read(ohci, d->ctrlSet));
2294                 if (reg_read(ohci, d->ctrlSet) & 0x800)
2295                         ohci1394_stop_context(ohci, d->ctrlClear,
2296                                               "respTxComplete");
2297                 else
2298                         tasklet_schedule(&d->task);
2299                 event &= ~OHCI1394_respTxComplete;
2300         }
2301         if (event & OHCI1394_RQPkt) {
2302                 struct dma_rcv_ctx *d = &ohci->ar_req_context;
2303                 DBGMSG("Got RQPkt interrupt status=0x%08X",
2304                        reg_read(ohci, d->ctrlSet));
2305                 if (reg_read(ohci, d->ctrlSet) & 0x800)
2306                         ohci1394_stop_context(ohci, d->ctrlClear, "RQPkt");
2307                 else
2308                         tasklet_schedule(&d->task);
2309                 event &= ~OHCI1394_RQPkt;
2310         }
2311         if (event & OHCI1394_RSPkt) {
2312                 struct dma_rcv_ctx *d = &ohci->ar_resp_context;
2313                 DBGMSG("Got RSPkt interrupt status=0x%08X",
2314                        reg_read(ohci, d->ctrlSet));
2315                 if (reg_read(ohci, d->ctrlSet) & 0x800)
2316                         ohci1394_stop_context(ohci, d->ctrlClear, "RSPkt");
2317                 else
2318                         tasklet_schedule(&d->task);
2319                 event &= ~OHCI1394_RSPkt;
2320         }
2321         if (event & OHCI1394_isochRx) {
2322                 quadlet_t rx_event;
2323
2324                 rx_event = reg_read(ohci, OHCI1394_IsoRecvIntEventSet);
2325                 reg_write(ohci, OHCI1394_IsoRecvIntEventClear, rx_event);
2326                 ohci_schedule_iso_tasklets(ohci, rx_event, 0);
2327                 event &= ~OHCI1394_isochRx;
2328         }
2329         if (event & OHCI1394_isochTx) {
2330                 quadlet_t tx_event;
2331
2332                 tx_event = reg_read(ohci, OHCI1394_IsoXmitIntEventSet);
2333                 reg_write(ohci, OHCI1394_IsoXmitIntEventClear, tx_event);
2334                 ohci_schedule_iso_tasklets(ohci, 0, tx_event);
2335                 event &= ~OHCI1394_isochTx;
2336         }
2337         if (event & OHCI1394_selfIDComplete) {
2338                 if (host->in_bus_reset) {
2339                         node_id = reg_read(ohci, OHCI1394_NodeID);
2340
2341                         if (!(node_id & 0x80000000)) {
2342                                 PRINT(KERN_ERR,
2343                                       "SelfID received, but NodeID invalid "
2344                                       "(probably new bus reset occurred): %08X",
2345                                       node_id);
2346                                 goto selfid_not_valid;
2347                         }
2348
2349                         phyid =  node_id & 0x0000003f;
2350                         isroot = (node_id & 0x40000000) != 0;
2351
2352                         DBGMSG("SelfID interrupt received "
2353                               "(phyid %d, %s)", phyid,
2354                               (isroot ? "root" : "not root"));
2355
2356                         handle_selfid(ohci, host, phyid, isroot);
2357
2358                         /* Clear the bus reset event and re-enable the
2359                          * busReset interrupt.  */
2360                         spin_lock_irqsave(&ohci->event_lock, flags);
2361                         reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
2362                         reg_write(ohci, OHCI1394_IntMaskSet, OHCI1394_busReset);
2363                         spin_unlock_irqrestore(&ohci->event_lock, flags);
2364
2365                         /* Turn on phys dma reception.
2366                          *
2367                          * TODO: Enable some sort of filtering management.
2368                          */
2369                         if (phys_dma) {
2370                                 reg_write(ohci, OHCI1394_PhyReqFilterHiSet,
2371                                           0xffffffff);
2372                                 reg_write(ohci, OHCI1394_PhyReqFilterLoSet,
2373                                           0xffffffff);
2374                         }
2375
2376                         DBGMSG("PhyReqFilter=%08x%08x",
2377                                reg_read(ohci, OHCI1394_PhyReqFilterHiSet),
2378                                reg_read(ohci, OHCI1394_PhyReqFilterLoSet));
2379
2380                         hpsb_selfid_complete(host, phyid, isroot);
2381                 } else
2382                         PRINT(KERN_ERR,
2383                               "SelfID received outside of bus reset sequence");
2384
2385 selfid_not_valid:
2386                 event &= ~OHCI1394_selfIDComplete;
2387         }
2388
2389         /* Make sure we handle everything, just in case we accidentally
2390          * enabled an interrupt that we didn't write a handler for.  */
2391         if (event)
2392                 PRINT(KERN_ERR, "Unhandled interrupt(s) 0x%08x",
2393                       event);
2394
2395         return IRQ_HANDLED;
2396 }
2397
2398 /* Put the buffer back into the dma context */
2399 static void insert_dma_buffer(struct dma_rcv_ctx *d, int idx)
2400 {
2401         struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
2402         DBGMSG("Inserting dma buf ctx=%d idx=%d", d->ctx, idx);
2403
2404         d->prg_cpu[idx]->status = cpu_to_le32(d->buf_size);
2405         d->prg_cpu[idx]->branchAddress &= le32_to_cpu(0xfffffff0);
2406         idx = (idx + d->num_desc - 1 ) % d->num_desc;
2407         d->prg_cpu[idx]->branchAddress |= le32_to_cpu(0x00000001);
2408
2409         /* To avoid a race, ensure 1394 interface hardware sees the inserted
2410          * context program descriptors before it sees the wakeup bit set. */
2411         wmb();
2412
2413         /* wake up the dma context if necessary */
2414         if (!(reg_read(ohci, d->ctrlSet) & 0x400)) {
2415                 PRINT(KERN_INFO,
2416                       "Waking dma ctx=%d ... processing is probably too slow",
2417                       d->ctx);
2418         }
2419
2420         /* do this always, to avoid race condition */
2421         reg_write(ohci, d->ctrlSet, 0x1000);
2422 }
2423
2424 #define cond_le32_to_cpu(data, noswap) \
2425         (noswap ? data : le32_to_cpu(data))
2426
2427 static const int TCODE_SIZE[16] = {20, 0, 16, -1, 16, 20, 20, 0,
2428                             -1, 0, -1, 0, -1, -1, 16, -1};
2429
2430 /*
2431  * Determine the length of a packet in the buffer
2432  * Optimization suggested by Pascal Drolet <pascal.drolet@informission.ca>
2433  */
2434 static inline int packet_length(struct dma_rcv_ctx *d, int idx,
2435                                 quadlet_t *buf_ptr, int offset,
2436                                 unsigned char tcode, int noswap)
2437 {
2438         int length = -1;
2439
2440         if (d->type == DMA_CTX_ASYNC_REQ || d->type == DMA_CTX_ASYNC_RESP) {
2441                 length = TCODE_SIZE[tcode];
2442                 if (length == 0) {
2443                         if (offset + 12 >= d->buf_size) {
2444                                 length = (cond_le32_to_cpu(d->buf_cpu[(idx + 1) % d->num_desc]
2445                                                 [3 - ((d->buf_size - offset) >> 2)], noswap) >> 16);
2446                         } else {
2447                                 length = (cond_le32_to_cpu(buf_ptr[3], noswap) >> 16);
2448                         }
2449                         length += 20;
2450                 }
2451         } else if (d->type == DMA_CTX_ISO) {
2452                 /* Assumption: buffer fill mode with header/trailer */
2453                 length = (cond_le32_to_cpu(buf_ptr[0], noswap) >> 16) + 8;
2454         }
2455
2456         if (length > 0 && length % 4)
2457                 length += 4 - (length % 4);
2458
2459         return length;
2460 }
2461
2462 /* Tasklet that processes dma receive buffers */
2463 static void dma_rcv_tasklet (unsigned long data)
2464 {
2465         struct dma_rcv_ctx *d = (struct dma_rcv_ctx*)data;
2466         struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
2467         unsigned int split_left, idx, offset, rescount;
2468         unsigned char tcode;
2469         int length, bytes_left, ack;
2470         unsigned long flags;
2471         quadlet_t *buf_ptr;
2472         char *split_ptr;
2473         char msg[256];
2474
2475         spin_lock_irqsave(&d->lock, flags);
2476
2477         idx = d->buf_ind;
2478         offset = d->buf_offset;
2479         buf_ptr = d->buf_cpu[idx] + offset/4;
2480
2481         rescount = le32_to_cpu(d->prg_cpu[idx]->status) & 0xffff;
2482         bytes_left = d->buf_size - rescount - offset;
2483
2484         while (bytes_left > 0) {
2485                 tcode = (cond_le32_to_cpu(buf_ptr[0], ohci->no_swap_incoming) >> 4) & 0xf;
2486
2487                 /* packet_length() will return < 4 for an error */
2488                 length = packet_length(d, idx, buf_ptr, offset, tcode, ohci->no_swap_incoming);
2489
2490                 if (length < 4) { /* something is wrong */
2491                         sprintf(msg,"Unexpected tcode 0x%x(0x%08x) in AR ctx=%d, length=%d",
2492                                 tcode, cond_le32_to_cpu(buf_ptr[0], ohci->no_swap_incoming),
2493                                 d->ctx, length);
2494                         ohci1394_stop_context(ohci, d->ctrlClear, msg);
2495                         spin_unlock_irqrestore(&d->lock, flags);
2496                         return;
2497                 }
2498
2499                 /* The first case is where we have a packet that crosses
2500                  * over more than one descriptor. The next case is where
2501                  * it's all in the first descriptor.  */
2502                 if ((offset + length) > d->buf_size) {
2503                         DBGMSG("Split packet rcv'd");
2504                         if (length > d->split_buf_size) {
2505                                 ohci1394_stop_context(ohci, d->ctrlClear,
2506                                              "Split packet size exceeded");
2507                                 d->buf_ind = idx;
2508                                 d->buf_offset = offset;
2509                                 spin_unlock_irqrestore(&d->lock, flags);
2510                                 return;
2511                         }
2512
2513                         if (le32_to_cpu(d->prg_cpu[(idx+1)%d->num_desc]->status)
2514                             == d->buf_size) {
2515                                 /* Other part of packet not written yet.
2516                                  * this should never happen I think
2517                                  * anyway we'll get it on the next call.  */
2518                                 PRINT(KERN_INFO,
2519                                       "Got only half a packet!");
2520                                 d->buf_ind = idx;
2521                                 d->buf_offset = offset;
2522                                 spin_unlock_irqrestore(&d->lock, flags);
2523                                 return;
2524                         }
2525
2526                         split_left = length;
2527                         split_ptr = (char *)d->spb;
2528                         memcpy(split_ptr,buf_ptr,d->buf_size-offset);
2529                         split_left -= d->buf_size-offset;
2530                         split_ptr += d->buf_size-offset;
2531                         insert_dma_buffer(d, idx);
2532                         idx = (idx+1) % d->num_desc;
2533                         buf_ptr = d->buf_cpu[idx];
2534                         offset=0;
2535
2536                         while (split_left >= d->buf_size) {
2537                                 memcpy(split_ptr,buf_ptr,d->buf_size);
2538                                 split_ptr += d->buf_size;
2539                                 split_left -= d->buf_size;
2540                                 insert_dma_buffer(d, idx);
2541                                 idx = (idx+1) % d->num_desc;
2542                                 buf_ptr = d->buf_cpu[idx];
2543                         }
2544
2545                         if (split_left > 0) {
2546                                 memcpy(split_ptr, buf_ptr, split_left);
2547                                 offset = split_left;
2548                                 buf_ptr += offset/4;
2549                         }
2550                 } else {
2551                         DBGMSG("Single packet rcv'd");
2552                         memcpy(d->spb, buf_ptr, length);
2553                         offset += length;
2554                         buf_ptr += length/4;
2555                         if (offset==d->buf_size) {
2556                                 insert_dma_buffer(d, idx);
2557                                 idx = (idx+1) % d->num_desc;
2558                                 buf_ptr = d->buf_cpu[idx];
2559                                 offset=0;
2560                         }
2561                 }
2562
2563                 /* We get one phy packet to the async descriptor for each
2564                  * bus reset. We always ignore it.  */
2565                 if (tcode != OHCI1394_TCODE_PHY) {
2566                         if (!ohci->no_swap_incoming)
2567                                 header_le32_to_cpu(d->spb, tcode);
2568                         DBGMSG("Packet received from node"
2569                                 " %d ack=0x%02X spd=%d tcode=0x%X"
2570                                 " length=%d ctx=%d tlabel=%d",
2571                                 (d->spb[1]>>16)&0x3f,
2572                                 (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>16)&0x1f,
2573                                 (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>21)&0x3,
2574                                 tcode, length, d->ctx,
2575                                 (d->spb[0]>>10)&0x3f);
2576
2577                         ack = (((cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>16)&0x1f)
2578                                 == 0x11) ? 1 : 0;
2579
2580                         hpsb_packet_received(ohci->host, d->spb,
2581                                              length-4, ack);
2582                 }
2583 #ifdef OHCI1394_DEBUG
2584                 else
2585                         PRINT (KERN_DEBUG, "Got phy packet ctx=%d ... discarded",
2586                                d->ctx);
2587 #endif
2588
2589                 rescount = le32_to_cpu(d->prg_cpu[idx]->status) & 0xffff;
2590
2591                 bytes_left = d->buf_size - rescount - offset;
2592
2593         }
2594
2595         d->buf_ind = idx;
2596         d->buf_offset = offset;
2597
2598         spin_unlock_irqrestore(&d->lock, flags);
2599 }
2600
2601 /* Bottom half that processes sent packets */
2602 static void dma_trm_tasklet (unsigned long data)
2603 {
2604         struct dma_trm_ctx *d = (struct dma_trm_ctx*)data;
2605         struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
2606         struct hpsb_packet *packet, *ptmp;
2607         unsigned long flags;
2608         u32 status, ack;
2609         size_t datasize;
2610
2611         spin_lock_irqsave(&d->lock, flags);
2612
2613         list_for_each_entry_safe(packet, ptmp, &d->fifo_list, driver_list) {
2614                 datasize = packet->data_size;
2615                 if (datasize && packet->type != hpsb_raw)
2616                         status = le32_to_cpu(
2617                                 d->prg_cpu[d->sent_ind]->end.status) >> 16;
2618                 else
2619                         status = le32_to_cpu(
2620                                 d->prg_cpu[d->sent_ind]->begin.status) >> 16;
2621
2622                 if (status == 0)
2623                         /* this packet hasn't been sent yet*/
2624                         break;
2625
2626 #ifdef OHCI1394_DEBUG
2627                 if (datasize)
2628                         if (((le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])>>4)&0xf) == 0xa)
2629                                 DBGMSG("Stream packet sent to channel %d tcode=0x%X "
2630                                        "ack=0x%X spd=%d dataLength=%d ctx=%d",
2631                                        (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])>>8)&0x3f,
2632                                        (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])>>4)&0xf,
2633                                        status&0x1f, (status>>5)&0x3,
2634                                        le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])>>16,
2635                                        d->ctx);
2636                         else
2637                                 DBGMSG("Packet sent to node %d tcode=0x%X tLabel="
2638                                        "%d ack=0x%X spd=%d dataLength=%d ctx=%d",
2639                                        (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])>>16)&0x3f,
2640                                        (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])>>4)&0xf,
2641                                        (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])>>10)&0x3f,
2642                                        status&0x1f, (status>>5)&0x3,
2643                                        le32_to_cpu(d->prg_cpu[d->sent_ind]->data[3])>>16,
2644                                        d->ctx);
2645                 else
2646                         DBGMSG("Packet sent to node %d tcode=0x%X tLabel="
2647                                "%d ack=0x%X spd=%d data=0x%08X ctx=%d",
2648                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])
2649                                         >>16)&0x3f,
2650                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
2651                                         >>4)&0xf,
2652                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
2653                                         >>10)&0x3f,
2654                                 status&0x1f, (status>>5)&0x3,
2655                                 le32_to_cpu(d->prg_cpu[d->sent_ind]->data[3]),
2656                                 d->ctx);
2657 #endif
2658
2659                 if (status & 0x10) {
2660                         ack = status & 0xf;
2661                 } else {
2662                         switch (status & 0x1f) {
2663                         case EVT_NO_STATUS: /* that should never happen */
2664                         case EVT_RESERVED_A: /* that should never happen */
2665                         case EVT_LONG_PACKET: /* that should never happen */
2666                                 PRINT(KERN_WARNING, "Received OHCI evt_* error 0x%x", status & 0x1f);
2667                                 ack = ACKX_SEND_ERROR;
2668                                 break;
2669                         case EVT_MISSING_ACK:
2670                                 ack = ACKX_TIMEOUT;
2671                                 break;
2672                         case EVT_UNDERRUN:
2673                                 ack = ACKX_SEND_ERROR;
2674                                 break;
2675                         case EVT_OVERRUN: /* that should never happen */
2676                                 PRINT(KERN_WARNING, "Received OHCI evt_* error 0x%x", status & 0x1f);
2677                                 ack = ACKX_SEND_ERROR;
2678                                 break;
2679                         case EVT_DESCRIPTOR_READ:
2680                         case EVT_DATA_READ:
2681                         case EVT_DATA_WRITE:
2682                                 ack = ACKX_SEND_ERROR;
2683                                 break;
2684                         case EVT_BUS_RESET: /* that should never happen */
2685                                 PRINT(KERN_WARNING, "Received OHCI evt_* error 0x%x", status & 0x1f);
2686                                 ack = ACKX_SEND_ERROR;
2687                                 break;
2688                         case EVT_TIMEOUT:
2689                                 ack = ACKX_TIMEOUT;
2690                                 break;
2691                         case EVT_TCODE_ERR:
2692                                 ack = ACKX_SEND_ERROR;
2693                                 break;
2694                         case EVT_RESERVED_B: /* that should never happen */
2695                         case EVT_RESERVED_C: /* that should never happen */
2696                                 PRINT(KERN_WARNING, "Received OHCI evt_* error 0x%x", status & 0x1f);
2697                                 ack = ACKX_SEND_ERROR;
2698                                 break;
2699                         case EVT_UNKNOWN:
2700                         case EVT_FLUSHED:
2701                                 ack = ACKX_SEND_ERROR;
2702                                 break;
2703                         default:
2704                                 PRINT(KERN_ERR, "Unhandled OHCI evt_* error 0x%x", status & 0x1f);
2705                                 ack = ACKX_SEND_ERROR;
2706                                 BUG();
2707                         }
2708                 }
2709
2710                 list_del_init(&packet->driver_list);
2711                 hpsb_packet_sent(ohci->host, packet, ack);
2712
2713                 if (datasize)
2714                         pci_unmap_single(ohci->dev,
2715                                          cpu_to_le32(d->prg_cpu[d->sent_ind]->end.address),
2716                                          datasize, PCI_DMA_TODEVICE);
2717
2718                 d->sent_ind = (d->sent_ind+1)%d->num_desc;
2719                 d->free_prgs++;
2720         }
2721
2722         dma_trm_flush(ohci, d);
2723
2724         spin_unlock_irqrestore(&d->lock, flags);
2725 }
2726
2727 static void free_dma_rcv_ctx(struct dma_rcv_ctx *d)
2728 {
2729         int i;
2730         struct ti_ohci *ohci = d->ohci;
2731
2732         if (ohci == NULL)
2733                 return;
2734
2735         DBGMSG("Freeing dma_rcv_ctx %d", d->ctx);
2736
2737         if (d->buf_cpu) {
2738                 for (i=0; i<d->num_desc; i++)
2739                         if (d->buf_cpu[i] && d->buf_bus[i])
2740                                 pci_free_consistent(
2741                                         ohci->dev, d->buf_size,
2742                                         d->buf_cpu[i], d->buf_bus[i]);
2743                 kfree(d->buf_cpu);
2744                 kfree(d->buf_bus);
2745         }
2746         if (d->prg_cpu) {
2747                 for (i=0; i<d->num_desc; i++)
2748                         if (d->prg_cpu[i] && d->prg_bus[i])
2749                                 pci_pool_free(d->prg_pool, d->prg_cpu[i],
2750                                               d->prg_bus[i]);
2751                 pci_pool_destroy(d->prg_pool);
2752                 kfree(d->prg_cpu);
2753                 kfree(d->prg_bus);
2754         }
2755         kfree(d->spb);
2756
2757         /* Mark this context as freed. */
2758         d->ohci = NULL;
2759 }
2760
2761 static int
2762 alloc_dma_rcv_ctx(struct ti_ohci *ohci, struct dma_rcv_ctx *d,
2763                   enum context_type type, int ctx, int num_desc,
2764                   int buf_size, int split_buf_size, int context_base)
2765 {
2766         int i, len;
2767         static int num_allocs;
2768         static char pool_name[20];
2769
2770         d->ohci = ohci;
2771         d->type = type;
2772         d->ctx = ctx;
2773
2774         d->num_desc = num_desc;
2775         d->buf_size = buf_size;
2776         d->split_buf_size = split_buf_size;
2777
2778         d->ctrlSet = 0;
2779         d->ctrlClear = 0;
2780         d->cmdPtr = 0;
2781
2782         d->buf_cpu = kzalloc(d->num_desc * sizeof(*d->buf_cpu), GFP_ATOMIC);
2783         d->buf_bus = kzalloc(d->num_desc * sizeof(*d->buf_bus), GFP_ATOMIC);
2784
2785         if (d->buf_cpu == NULL || d->buf_bus == NULL) {
2786                 PRINT(KERN_ERR, "Failed to allocate dma buffer");
2787                 free_dma_rcv_ctx(d);
2788                 return -ENOMEM;
2789         }
2790
2791         d->prg_cpu = kzalloc(d->num_desc * sizeof(*d->prg_cpu), GFP_ATOMIC);
2792         d->prg_bus = kzalloc(d->num_desc * sizeof(*d->prg_bus), GFP_ATOMIC);
2793
2794         if (d->prg_cpu == NULL || d->prg_bus == NULL) {
2795                 PRINT(KERN_ERR, "Failed to allocate dma prg");
2796                 free_dma_rcv_ctx(d);
2797                 return -ENOMEM;
2798         }
2799
2800         d->spb = kmalloc(d->split_buf_size, GFP_ATOMIC);
2801
2802         if (d->spb == NULL) {
2803                 PRINT(KERN_ERR, "Failed to allocate split buffer");
2804                 free_dma_rcv_ctx(d);
2805                 return -ENOMEM;
2806         }
2807
2808         len = sprintf(pool_name, "ohci1394_rcv_prg");
2809         sprintf(pool_name+len, "%d", num_allocs);
2810         d->prg_pool = pci_pool_create(pool_name, ohci->dev,
2811                                 sizeof(struct dma_cmd), 4, 0);
2812         if(d->prg_pool == NULL)
2813         {
2814                 PRINT(KERN_ERR, "pci_pool_create failed for %s", pool_name);
2815                 free_dma_rcv_ctx(d);
2816                 return -ENOMEM;
2817         }
2818         num_allocs++;
2819
2820         for (i=0; i<d->num_desc; i++) {
2821                 d->buf_cpu[i] = pci_alloc_consistent(ohci->dev,
2822                                                      d->buf_size,
2823                                                      d->buf_bus+i);
2824
2825                 if (d->buf_cpu[i] != NULL) {
2826                         memset(d->buf_cpu[i], 0, d->buf_size);
2827                 } else {
2828                         PRINT(KERN_ERR,
2829                               "Failed to allocate dma buffer");
2830                         free_dma_rcv_ctx(d);
2831                         return -ENOMEM;
2832                 }
2833
2834                 d->prg_cpu[i] = pci_pool_alloc(d->prg_pool, GFP_KERNEL, d->prg_bus+i);
2835
2836                 if (d->prg_cpu[i] != NULL) {
2837                         memset(d->prg_cpu[i], 0, sizeof(struct dma_cmd));
2838                 } else {
2839                         PRINT(KERN_ERR,
2840                               "Failed to allocate dma prg");
2841                         free_dma_rcv_ctx(d);
2842                         return -ENOMEM;
2843                 }
2844         }
2845
2846         spin_lock_init(&d->lock);
2847
2848         d->ctrlSet = context_base + OHCI1394_ContextControlSet;
2849         d->ctrlClear = context_base + OHCI1394_ContextControlClear;
2850         d->cmdPtr = context_base + OHCI1394_ContextCommandPtr;
2851
2852         tasklet_init(&d->task, dma_rcv_tasklet, (unsigned long) d);
2853         return 0;
2854 }
2855
2856 static void free_dma_trm_ctx(struct dma_trm_ctx *d)
2857 {
2858         int i;
2859         struct ti_ohci *ohci = d->ohci;
2860
2861         if (ohci == NULL)
2862                 return;
2863
2864         DBGMSG("Freeing dma_trm_ctx %d", d->ctx);
2865
2866         if (d->prg_cpu) {
2867                 for (i=0; i<d->num_desc; i++)
2868                         if (d->prg_cpu[i] && d->prg_bus[i])
2869                                 pci_pool_free(d->prg_pool, d->prg_cpu[i],
2870                                               d->prg_bus[i]);
2871                 pci_pool_destroy(d->prg_pool);
2872                 kfree(d->prg_cpu);
2873                 kfree(d->prg_bus);
2874         }
2875
2876         /* Mark this context as freed. */
2877         d->ohci = NULL;
2878 }
2879
2880 static int
2881 alloc_dma_trm_ctx(struct ti_ohci *ohci, struct dma_trm_ctx *d,
2882                   enum context_type type, int ctx, int num_desc,
2883                   int context_base)
2884 {
2885         int i, len;
2886         static char pool_name[20];
2887         static int num_allocs=0;
2888
2889         d->ohci = ohci;
2890         d->type = type;
2891         d->ctx = ctx;
2892         d->num_desc = num_desc;
2893         d->ctrlSet = 0;
2894         d->ctrlClear = 0;
2895         d->cmdPtr = 0;
2896
2897         d->prg_cpu = kzalloc(d->num_desc * sizeof(*d->prg_cpu), GFP_KERNEL);
2898         d->prg_bus = kzalloc(d->num_desc * sizeof(*d->prg_bus), GFP_KERNEL);
2899
2900         if (d->prg_cpu == NULL || d->prg_bus == NULL) {
2901                 PRINT(KERN_ERR, "Failed to allocate at dma prg");
2902                 free_dma_trm_ctx(d);
2903                 return -ENOMEM;
2904         }
2905
2906         len = sprintf(pool_name, "ohci1394_trm_prg");
2907         sprintf(pool_name+len, "%d", num_allocs);
2908         d->prg_pool = pci_pool_create(pool_name, ohci->dev,
2909                                 sizeof(struct at_dma_prg), 4, 0);
2910         if (d->prg_pool == NULL) {
2911                 PRINT(KERN_ERR, "pci_pool_create failed for %s", pool_name);
2912                 free_dma_trm_ctx(d);
2913                 return -ENOMEM;
2914         }
2915         num_allocs++;
2916
2917         for (i = 0; i < d->num_desc; i++) {
2918                 d->prg_cpu[i] = pci_pool_alloc(d->prg_pool, GFP_KERNEL, d->prg_bus+i);
2919
2920                 if (d->prg_cpu[i] != NULL) {
2921                         memset(d->prg_cpu[i], 0, sizeof(struct at_dma_prg));
2922                 } else {
2923                         PRINT(KERN_ERR,
2924                               "Failed to allocate at dma prg");
2925                         free_dma_trm_ctx(d);
2926                         return -ENOMEM;
2927                 }
2928         }
2929
2930         spin_lock_init(&d->lock);
2931
2932         /* initialize tasklet */
2933         d->ctrlSet = context_base + OHCI1394_ContextControlSet;
2934         d->ctrlClear = context_base + OHCI1394_ContextControlClear;
2935         d->cmdPtr = context_base + OHCI1394_ContextCommandPtr;
2936         tasklet_init(&d->task, dma_trm_tasklet, (unsigned long)d);
2937         return 0;
2938 }
2939
2940 static void ohci_set_hw_config_rom(struct hpsb_host *host, quadlet_t *config_rom)
2941 {
2942         struct ti_ohci *ohci = host->hostdata;
2943
2944         reg_write(ohci, OHCI1394_ConfigROMhdr, be32_to_cpu(config_rom[0]));
2945         reg_write(ohci, OHCI1394_BusOptions, be32_to_cpu(config_rom[2]));
2946
2947         memcpy(ohci->csr_config_rom_cpu, config_rom, OHCI_CONFIG_ROM_LEN);
2948 }
2949
2950
2951 static quadlet_t ohci_hw_csr_reg(struct hpsb_host *host, int reg,
2952                                  quadlet_t data, quadlet_t compare)
2953 {
2954         struct ti_ohci *ohci = host->hostdata;
2955         int i;
2956
2957         reg_write(ohci, OHCI1394_CSRData, data);
2958         reg_write(ohci, OHCI1394_CSRCompareData, compare);
2959         reg_write(ohci, OHCI1394_CSRControl, reg & 0x3);
2960
2961         for (i = 0; i < OHCI_LOOP_COUNT; i++) {
2962                 if (reg_read(ohci, OHCI1394_CSRControl) & 0x80000000)
2963                         break;
2964
2965                 mdelay(1);
2966         }
2967
2968         return reg_read(ohci, OHCI1394_CSRData);
2969 }
2970
2971 static struct hpsb_host_driver ohci1394_driver = {
2972         .owner =                THIS_MODULE,
2973         .name =                 OHCI1394_DRIVER_NAME,
2974         .set_hw_config_rom =    ohci_set_hw_config_rom,
2975         .transmit_packet =      ohci_transmit,
2976         .devctl =               ohci_devctl,
2977         .isoctl =               ohci_isoctl,
2978         .hw_csr_reg =           ohci_hw_csr_reg,
2979 };
2980
2981 /***********************************
2982  * PCI Driver Interface functions  *
2983  ***********************************/
2984
2985 #define FAIL(err, fmt, args...)                 \
2986 do {                                            \
2987         PRINT_G(KERN_ERR, fmt , ## args);       \
2988         ohci1394_pci_remove(dev);               \
2989         return err;                             \
2990 } while (0)
2991
2992 static int __devinit ohci1394_pci_probe(struct pci_dev *dev,
2993                                         const struct pci_device_id *ent)
2994 {
2995         struct hpsb_host *host;
2996         struct ti_ohci *ohci;   /* shortcut to currently handled device */
2997         resource_size_t ohci_base;
2998
2999 #ifdef CONFIG_PPC_PMAC
3000         /* Necessary on some machines if ohci1394 was loaded/ unloaded before */
3001         if (machine_is(powermac)) {
3002                 struct device_node *ofn = pci_device_to_OF_node(dev);
3003
3004                 if (ofn) {
3005                         pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, ofn, 0, 1);
3006                         pmac_call_feature(PMAC_FTR_1394_ENABLE, ofn, 0, 1);
3007                 }
3008         }
3009 #endif /* CONFIG_PPC_PMAC */
3010
3011         if (pci_enable_device(dev))
3012                 FAIL(-ENXIO, "Failed to enable OHCI hardware");
3013         pci_set_master(dev);
3014
3015         host = hpsb_alloc_host(&ohci1394_driver, sizeof(struct ti_ohci), &dev->dev);
3016         if (!host) FAIL(-ENOMEM, "Failed to allocate host structure");
3017
3018         ohci = host->hostdata;
3019         ohci->dev = dev;
3020         ohci->host = host;
3021         ohci->init_state = OHCI_INIT_ALLOC_HOST;
3022         host->pdev = dev;
3023         pci_set_drvdata(dev, ohci);
3024
3025         /* We don't want hardware swapping */
3026         pci_write_config_dword(dev, OHCI1394_PCI_HCI_Control, 0);
3027
3028         /* Some oddball Apple controllers do not order the selfid
3029          * properly, so we make up for it here.  */
3030 #ifndef __LITTLE_ENDIAN
3031         /* XXX: Need a better way to check this. I'm wondering if we can
3032          * read the values of the OHCI1394_PCI_HCI_Control and the
3033          * noByteSwapData registers to see if they were not cleared to
3034          * zero. Should this work? Obviously it's not defined what these
3035          * registers will read when they aren't supported. Bleh! */
3036         if (dev->vendor == PCI_VENDOR_ID_APPLE &&
3037             dev->device == PCI_DEVICE_ID_APPLE_UNI_N_FW) {
3038                 ohci->no_swap_incoming = 1;
3039                 ohci->selfid_swap = 0;
3040         } else
3041                 ohci->selfid_swap = 1;
3042 #endif
3043
3044
3045 #ifndef PCI_DEVICE_ID_NVIDIA_NFORCE2_FW
3046 #define PCI_DEVICE_ID_NVIDIA_NFORCE2_FW 0x006e
3047 #endif
3048
3049         /* These chipsets require a bit of extra care when checking after
3050          * a busreset.  */
3051         if ((dev->vendor == PCI_VENDOR_ID_APPLE &&
3052              dev->device == PCI_DEVICE_ID_APPLE_UNI_N_FW) ||
3053             (dev->vendor ==  PCI_VENDOR_ID_NVIDIA &&
3054              dev->device == PCI_DEVICE_ID_NVIDIA_NFORCE2_FW))
3055                 ohci->check_busreset = 1;
3056
3057         /* We hardwire the MMIO length, since some CardBus adaptors
3058          * fail to report the right length.  Anyway, the ohci spec
3059          * clearly says it's 2kb, so this shouldn't be a problem. */
3060         ohci_base = pci_resource_start(dev, 0);
3061         if (pci_resource_len(dev, 0) < OHCI1394_REGISTER_SIZE)
3062                 PRINT(KERN_WARNING, "PCI resource length of 0x%llx too small!",
3063                       (unsigned long long)pci_resource_len(dev, 0));
3064
3065         if (!request_mem_region(ohci_base, OHCI1394_REGISTER_SIZE,
3066                                 OHCI1394_DRIVER_NAME))
3067                 FAIL(-ENOMEM, "MMIO resource (0x%llx - 0x%llx) unavailable",
3068                         (unsigned long long)ohci_base,
3069                         (unsigned long long)ohci_base + OHCI1394_REGISTER_SIZE);
3070         ohci->init_state = OHCI_INIT_HAVE_MEM_REGION;
3071
3072         ohci->registers = ioremap(ohci_base, OHCI1394_REGISTER_SIZE);
3073         if (ohci->registers == NULL)
3074                 FAIL(-ENXIO, "Failed to remap registers - card not accessible");
3075         ohci->init_state = OHCI_INIT_HAVE_IOMAPPING;
3076         DBGMSG("Remapped memory spaces reg 0x%p", ohci->registers);
3077
3078         /* csr_config rom allocation */
3079         ohci->csr_config_rom_cpu =
3080                 pci_alloc_consistent(ohci->dev, OHCI_CONFIG_ROM_LEN,
3081                                      &ohci->csr_config_rom_bus);
3082         if (ohci->csr_config_rom_cpu == NULL)
3083                 FAIL(-ENOMEM, "Failed to allocate buffer config rom");
3084         ohci->init_state = OHCI_INIT_HAVE_CONFIG_ROM_BUFFER;
3085
3086         /* self-id dma buffer allocation */
3087         ohci->selfid_buf_cpu =
3088                 pci_alloc_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE,
3089                       &ohci->selfid_buf_bus);
3090         if (ohci->selfid_buf_cpu == NULL)
3091                 FAIL(-ENOMEM, "Failed to allocate DMA buffer for self-id packets");
3092         ohci->init_state = OHCI_INIT_HAVE_SELFID_BUFFER;
3093
3094         if ((unsigned long)ohci->selfid_buf_cpu & 0x1fff)
3095                 PRINT(KERN_INFO, "SelfID buffer %p is not aligned on "
3096                       "8Kb boundary... may cause problems on some CXD3222 chip",
3097                       ohci->selfid_buf_cpu);
3098
3099         /* No self-id errors at startup */
3100         ohci->self_id_errors = 0;
3101
3102         ohci->init_state = OHCI_INIT_HAVE_TXRX_BUFFERS__MAYBE;
3103         /* AR DMA request context allocation */
3104         if (alloc_dma_rcv_ctx(ohci, &ohci->ar_req_context,
3105                               DMA_CTX_ASYNC_REQ, 0, AR_REQ_NUM_DESC,
3106                               AR_REQ_BUF_SIZE, AR_REQ_SPLIT_BUF_SIZE,
3107                               OHCI1394_AsReqRcvContextBase) < 0)
3108                 FAIL(-ENOMEM, "Failed to allocate AR Req context");
3109
3110         /* AR DMA response context allocation */
3111         if (alloc_dma_rcv_ctx(ohci, &ohci->ar_resp_context,
3112                               DMA_CTX_ASYNC_RESP, 0, AR_RESP_NUM_DESC,
3113                               AR_RESP_BUF_SIZE, AR_RESP_SPLIT_BUF_SIZE,
3114                               OHCI1394_AsRspRcvContextBase) < 0)
3115                 FAIL(-ENOMEM, "Failed to allocate AR Resp context");
3116
3117         /* AT DMA request context */
3118         if (alloc_dma_trm_ctx(ohci, &ohci->at_req_context,
3119                               DMA_CTX_ASYNC_REQ, 0, AT_REQ_NUM_DESC,
3120                               OHCI1394_AsReqTrContextBase) < 0)
3121                 FAIL(-ENOMEM, "Failed to allocate AT Req context");
3122
3123         /* AT DMA response context */
3124         if (alloc_dma_trm_ctx(ohci, &ohci->at_resp_context,
3125                               DMA_CTX_ASYNC_RESP, 1, AT_RESP_NUM_DESC,
3126                               OHCI1394_AsRspTrContextBase) < 0)
3127                 FAIL(-ENOMEM, "Failed to allocate AT Resp context");
3128
3129         /* Start off with a soft reset, to clear everything to a sane
3130          * state. */
3131         ohci_soft_reset(ohci);
3132
3133         /* Now enable LPS, which we need in order to start accessing
3134          * most of the registers.  In fact, on some cards (ALI M5251),
3135          * accessing registers in the SClk domain without LPS enabled
3136          * will lock up the machine.  Wait 50msec to make sure we have
3137          * full link enabled.  */
3138         reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_LPS);
3139
3140         /* Disable and clear interrupts */
3141         reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
3142         reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);
3143
3144         mdelay(50);
3145
3146         /* Determine the number of available IR and IT contexts. */
3147         ohci->nb_iso_rcv_ctx =
3148                 get_nb_iso_ctx(ohci, OHCI1394_IsoRecvIntMaskSet);
3149         ohci->nb_iso_xmit_ctx =
3150                 get_nb_iso_ctx(ohci, OHCI1394_IsoXmitIntMaskSet);
3151
3152         /* Set the usage bits for non-existent contexts so they can't
3153          * be allocated */
3154         ohci->ir_ctx_usage = ~0 << ohci->nb_iso_rcv_ctx;
3155         ohci->it_ctx_usage = ~0 << ohci->nb_iso_xmit_ctx;
3156
3157         INIT_LIST_HEAD(&ohci->iso_tasklet_list);
3158         spin_lock_init(&ohci->iso_tasklet_list_lock);
3159         ohci->ISO_channel_usage = 0;
3160         spin_lock_init(&ohci->IR_channel_lock);
3161
3162         spin_lock_init(&ohci->event_lock);
3163
3164         /*
3165          * interrupts are disabled, all right, but... due to IRQF_SHARED we
3166          * might get called anyway.  We'll see no event, of course, but
3167          * we need to get to that "no event", so enough should be initialized
3168          * by that point.
3169          */
3170         if (request_irq(dev->irq, ohci_irq_handler, IRQF_SHARED,
3171                          OHCI1394_DRIVER_NAME, ohci))
3172                 FAIL(-ENOMEM, "Failed to allocate shared interrupt %d", dev->irq);
3173
3174         ohci->init_state = OHCI_INIT_HAVE_IRQ;
3175         ohci_initialize(ohci);
3176
3177         /* Set certain csr values */
3178         host->csr.guid_hi = reg_read(ohci, OHCI1394_GUIDHi);
3179         host->csr.guid_lo = reg_read(ohci, OHCI1394_GUIDLo);
3180         host->csr.cyc_clk_acc = 100;  /* how do we determine clk accuracy? */
3181         host->csr.max_rec = (reg_read(ohci, OHCI1394_BusOptions) >> 12) & 0xf;
3182         host->csr.lnk_spd = reg_read(ohci, OHCI1394_BusOptions) & 0x7;
3183
3184         if (phys_dma) {
3185                 host->low_addr_space =
3186                         (u64) reg_read(ohci, OHCI1394_PhyUpperBound) << 16;
3187                 if (!host->low_addr_space)
3188                         host->low_addr_space = OHCI1394_PHYS_UPPER_BOUND_FIXED;
3189         }
3190         host->middle_addr_space = OHCI1394_MIDDLE_ADDRESS_SPACE;
3191
3192         /* Tell the highlevel this host is ready */
3193         if (hpsb_add_host(host))
3194                 FAIL(-ENOMEM, "Failed to register host with highlevel");
3195
3196         ohci->init_state = OHCI_INIT_DONE;
3197
3198         return 0;
3199 #undef FAIL
3200 }
3201
3202 static void ohci1394_pci_remove(struct pci_dev *pdev)
3203 {
3204         struct ti_ohci *ohci;
3205         struct device *dev;
3206
3207         ohci = pci_get_drvdata(pdev);
3208         if (!ohci)
3209                 return;
3210
3211         dev = get_device(&ohci->host->device);
3212
3213         switch (ohci->init_state) {
3214         case OHCI_INIT_DONE:
3215                 hpsb_remove_host(ohci->host);
3216
3217                 /* Clear out BUS Options */
3218                 reg_write(ohci, OHCI1394_ConfigROMhdr, 0);
3219                 reg_write(ohci, OHCI1394_BusOptions,
3220                           (reg_read(ohci, OHCI1394_BusOptions) & 0x0000f007) |
3221                           0x00ff0000);
3222                 memset(ohci->csr_config_rom_cpu, 0, OHCI_CONFIG_ROM_LEN);
3223
3224         case OHCI_INIT_HAVE_IRQ:
3225                 /* Clear interrupt registers */
3226                 reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);
3227                 reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
3228                 reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 0xffffffff);
3229                 reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 0xffffffff);
3230                 reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 0xffffffff);
3231                 reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 0xffffffff);
3232
3233                 /* Disable IRM Contender */
3234                 set_phy_reg(ohci, 4, ~0xc0 & get_phy_reg(ohci, 4));
3235
3236                 /* Clear link control register */
3237                 reg_write(ohci, OHCI1394_LinkControlClear, 0xffffffff);
3238
3239                 /* Let all other nodes know to ignore us */
3240                 ohci_devctl(ohci->host, RESET_BUS, LONG_RESET_NO_FORCE_ROOT);
3241
3242                 /* Soft reset before we start - this disables
3243                  * interrupts and clears linkEnable and LPS. */
3244                 ohci_soft_reset(ohci);
3245                 free_irq(ohci->dev->irq, ohci);
3246
3247         case OHCI_INIT_HAVE_TXRX_BUFFERS__MAYBE:
3248                 /* The ohci_soft_reset() stops all DMA contexts, so we
3249                  * dont need to do this.  */
3250                 free_dma_rcv_ctx(&ohci->ar_req_context);
3251                 free_dma_rcv_ctx(&ohci->ar_resp_context);
3252                 free_dma_trm_ctx(&ohci->at_req_context);
3253                 free_dma_trm_ctx(&ohci->at_resp_context);
3254
3255         case OHCI_INIT_HAVE_SELFID_BUFFER:
3256                 pci_free_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE,
3257                                     ohci->selfid_buf_cpu,
3258                                     ohci->selfid_buf_bus);
3259
3260         case OHCI_INIT_HAVE_CONFIG_ROM_BUFFER:
3261                 pci_free_consistent(ohci->dev, OHCI_CONFIG_ROM_LEN,
3262                                     ohci->csr_config_rom_cpu,
3263                                     ohci->csr_config_rom_bus);
3264
3265         case OHCI_INIT_HAVE_IOMAPPING:
3266                 iounmap(ohci->registers);
3267
3268         case OHCI_INIT_HAVE_MEM_REGION:
3269                 release_mem_region(pci_resource_start(ohci->dev, 0),
3270                                    OHCI1394_REGISTER_SIZE);
3271
3272 #ifdef CONFIG_PPC_PMAC
3273         /* On UniNorth, power down the cable and turn off the chip clock
3274          * to save power on laptops */
3275         if (machine_is(powermac)) {
3276                 struct device_node* ofn = pci_device_to_OF_node(ohci->dev);
3277
3278                 if (ofn) {
3279                         pmac_call_feature(PMAC_FTR_1394_ENABLE, ofn, 0, 0);
3280                         pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, ofn, 0, 0);
3281                 }
3282         }
3283 #endif /* CONFIG_PPC_PMAC */
3284
3285         case OHCI_INIT_ALLOC_HOST:
3286                 pci_set_drvdata(ohci->dev, NULL);
3287         }
3288
3289         if (dev)
3290                 put_device(dev);
3291 }
3292
3293 #ifdef CONFIG_PM
3294 static int ohci1394_pci_suspend(struct pci_dev *pdev, pm_message_t state)
3295 {
3296         int err;
3297         struct ti_ohci *ohci = pci_get_drvdata(pdev);
3298
3299         if (!ohci) {
3300                 printk(KERN_ERR "%s: tried to suspend nonexisting host\n",
3301                        OHCI1394_DRIVER_NAME);
3302                 return -ENXIO;
3303         }
3304         DBGMSG("suspend called");
3305
3306         /* Clear the async DMA contexts and stop using the controller */
3307         hpsb_bus_reset(ohci->host);
3308
3309         /* See ohci1394_pci_remove() for comments on this sequence */
3310         reg_write(ohci, OHCI1394_ConfigROMhdr, 0);
3311         reg_write(ohci, OHCI1394_BusOptions,
3312                   (reg_read(ohci, OHCI1394_BusOptions) & 0x0000f007) |
3313                   0x00ff0000);
3314         reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);
3315         reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
3316         reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 0xffffffff);
3317         reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 0xffffffff);
3318         reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 0xffffffff);
3319         reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 0xffffffff);
3320         set_phy_reg(ohci, 4, ~0xc0 & get_phy_reg(ohci, 4));
3321         reg_write(ohci, OHCI1394_LinkControlClear, 0xffffffff);
3322         ohci_devctl(ohci->host, RESET_BUS, LONG_RESET_NO_FORCE_ROOT);
3323         ohci_soft_reset(ohci);
3324
3325         err = pci_save_state(pdev);
3326         if (err) {
3327                 PRINT(KERN_ERR, "pci_save_state failed with %d", err);
3328                 return err;
3329         }
3330         err = pci_set_power_state(pdev, pci_choose_state(pdev, state));
3331         if (err)
3332                 DBGMSG("pci_set_power_state failed with %d", err);
3333
3334 /* PowerMac suspend code comes last */
3335 #ifdef CONFIG_PPC_PMAC
3336         if (machine_is(powermac)) {
3337                 struct device_node *ofn = pci_device_to_OF_node(pdev);
3338
3339                 if (ofn)
3340                         pmac_call_feature(PMAC_FTR_1394_ENABLE, ofn, 0, 0);
3341         }
3342 #endif /* CONFIG_PPC_PMAC */
3343
3344         return 0;
3345 }
3346
3347 static int ohci1394_pci_resume(struct pci_dev *pdev)
3348 {
3349         int err;
3350         struct ti_ohci *ohci = pci_get_drvdata(pdev);
3351
3352         if (!ohci) {
3353                 printk(KERN_ERR "%s: tried to resume nonexisting host\n",
3354                        OHCI1394_DRIVER_NAME);
3355                 return -ENXIO;
3356         }
3357         DBGMSG("resume called");
3358
3359 /* PowerMac resume code comes first */
3360 #ifdef CONFIG_PPC_PMAC
3361         if (machine_is(powermac)) {
3362                 struct device_node *ofn = pci_device_to_OF_node(pdev);
3363
3364                 if (ofn)
3365                         pmac_call_feature(PMAC_FTR_1394_ENABLE, ofn, 0, 1);
3366         }
3367 #endif /* CONFIG_PPC_PMAC */
3368
3369         pci_set_power_state(pdev, PCI_D0);
3370         pci_restore_state(pdev);
3371         err = pci_enable_device(pdev);
3372         if (err) {
3373                 PRINT(KERN_ERR, "pci_enable_device failed with %d", err);
3374                 return err;
3375         }
3376
3377         /* See ohci1394_pci_probe() for comments on this sequence */
3378         ohci_soft_reset(ohci);
3379         reg_write(ohci, OHCI1394_HCControlSet, OHCI1394_HCControl_LPS);
3380         reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
3381         reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);
3382         mdelay(50);
3383         ohci_initialize(ohci);
3384
3385         hpsb_resume_host(ohci->host);
3386         return 0;
3387 }
3388 #endif /* CONFIG_PM */
3389
3390 static struct pci_device_id ohci1394_pci_tbl[] = {
3391         {
3392                 .class =        PCI_CLASS_SERIAL_FIREWIRE_OHCI,
3393                 .class_mask =   PCI_ANY_ID,
3394                 .vendor =       PCI_ANY_ID,
3395                 .device =       PCI_ANY_ID,
3396                 .subvendor =    PCI_ANY_ID,
3397                 .subdevice =    PCI_ANY_ID,
3398         },
3399         { 0, },
3400 };
3401
3402 MODULE_DEVICE_TABLE(pci, ohci1394_pci_tbl);
3403
3404 static struct pci_driver ohci1394_pci_driver = {
3405         .name =         OHCI1394_DRIVER_NAME,
3406         .id_table =     ohci1394_pci_tbl,
3407         .probe =        ohci1394_pci_probe,
3408         .remove =       ohci1394_pci_remove,
3409 #ifdef CONFIG_PM
3410         .resume =       ohci1394_pci_resume,
3411         .suspend =      ohci1394_pci_suspend,
3412 #endif
3413 };
3414
3415 /***********************************
3416  * OHCI1394 Video Interface        *
3417  ***********************************/
3418
3419 /* essentially the only purpose of this code is to allow another
3420    module to hook into ohci's interrupt handler */
3421
3422 /* returns zero if successful, one if DMA context is locked up */
3423 int ohci1394_stop_context(struct ti_ohci *ohci, int reg, char *msg)
3424 {
3425         int i=0;
3426
3427         /* stop the channel program if it's still running */
3428         reg_write(ohci, reg, 0x8000);
3429
3430         /* Wait until it effectively stops */
3431         while (reg_read(ohci, reg) & 0x400) {
3432                 i++;
3433                 if (i>5000) {
3434                         PRINT(KERN_ERR,
3435                               "Runaway loop while stopping context: %s...", msg ? msg : "");
3436                         return 1;
3437                 }
3438
3439                 mb();
3440                 udelay(10);
3441         }
3442         if (msg) PRINT(KERN_ERR, "%s: dma prg stopped", msg);
3443         return 0;
3444 }
3445
3446 void ohci1394_init_iso_tasklet(struct ohci1394_iso_tasklet *tasklet, int type,
3447                                void (*func)(unsigned long), unsigned long data)
3448 {
3449         tasklet_init(&tasklet->tasklet, func, data);
3450         tasklet->type = type;
3451         /* We init the tasklet->link field, so we can list_del() it
3452          * without worrying whether it was added to the list or not. */
3453         INIT_LIST_HEAD(&tasklet->link);
3454 }
3455
3456 int ohci1394_register_iso_tasklet(struct ti_ohci *ohci,
3457                                   struct ohci1394_iso_tasklet *tasklet)
3458 {
3459         unsigned long flags, *usage;
3460         int n, i, r = -EBUSY;
3461
3462         if (tasklet->type == OHCI_ISO_TRANSMIT) {
3463                 n = ohci->nb_iso_xmit_ctx;
3464                 usage = &ohci->it_ctx_usage;
3465         }
3466         else {
3467                 n = ohci->nb_iso_rcv_ctx;
3468                 usage = &ohci->ir_ctx_usage;
3469
3470                 /* only one receive context can be multichannel (OHCI sec 10.4.1) */
3471                 if (tasklet->type == OHCI_ISO_MULTICHANNEL_RECEIVE) {
3472                         if (test_and_set_bit(0, &ohci->ir_multichannel_used)) {
3473                                 return r;
3474                         }
3475                 }
3476         }
3477
3478         spin_lock_irqsave(&ohci->iso_tasklet_list_lock, flags);
3479
3480         for (i = 0; i < n; i++)
3481                 if (!test_and_set_bit(i, usage)) {
3482                         tasklet->context = i;
3483                         list_add_tail(&tasklet->link, &ohci->iso_tasklet_list);
3484                         r = 0;
3485                         break;
3486                 }
3487
3488         spin_unlock_irqrestore(&ohci->iso_tasklet_list_lock, flags);
3489
3490         return r;
3491 }
3492
3493 void ohci1394_unregister_iso_tasklet(struct ti_ohci *ohci,
3494                                      struct ohci1394_iso_tasklet *tasklet)
3495 {
3496         unsigned long flags;
3497
3498         tasklet_kill(&tasklet->tasklet);
3499
3500         spin_lock_irqsave(&ohci->iso_tasklet_list_lock, flags);
3501
3502         if (tasklet->type == OHCI_ISO_TRANSMIT)
3503                 clear_bit(tasklet->context, &ohci->it_ctx_usage);
3504         else {
3505                 clear_bit(tasklet->context, &ohci->ir_ctx_usage);
3506
3507                 if (tasklet->type == OHCI_ISO_MULTICHANNEL_RECEIVE) {
3508                         clear_bit(0, &ohci->ir_multichannel_used);
3509                 }
3510         }
3511
3512         list_del(&tasklet->link);
3513
3514         spin_unlock_irqrestore(&ohci->iso_tasklet_list_lock, flags);
3515 }
3516
3517 EXPORT_SYMBOL(ohci1394_stop_context);
3518 EXPORT_SYMBOL(ohci1394_init_iso_tasklet);
3519 EXPORT_SYMBOL(ohci1394_register_iso_tasklet);
3520 EXPORT_SYMBOL(ohci1394_unregister_iso_tasklet);
3521
3522 /***********************************
3523  * General module initialization   *
3524  ***********************************/
3525
3526 MODULE_AUTHOR("Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>");
3527 MODULE_DESCRIPTION("Driver for PCI OHCI IEEE-1394 controllers");
3528 MODULE_LICENSE("GPL");
3529
3530 static void __exit ohci1394_cleanup (void)
3531 {
3532         pci_unregister_driver(&ohci1394_pci_driver);
3533 }
3534
3535 static int __init ohci1394_init(void)
3536 {
3537         return pci_register_driver(&ohci1394_pci_driver);
3538 }
3539
3540 /* Register before most other device drivers.
3541  * Useful for remote debugging via physical DMA, e.g. using firescope. */
3542 fs_initcall(ohci1394_init);
3543 module_exit(ohci1394_cleanup);