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