git.oblomov.eu Git - linux-2.6/blob - drivers/ieee1394/pcilynx.c

   1 /*
   2  * pcilynx.c - Texas Instruments PCILynx driver
   3  * Copyright (C) 1999,2000 Andreas Bombe <andreas.bombe@munich.netsurf.de>,
   4  *                         Stephan Linz <linz@mazet.de>
   5  *                         Manfred Weihs <weihs@ict.tuwien.ac.at>
   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  * Contributions:
  24  *
  25  * Manfred Weihs <weihs@ict.tuwien.ac.at>
  26  *        reading bus info block (containing GUID) from serial
  27  *            eeprom via i2c and storing it in config ROM
  28  *        Reworked code for initiating bus resets
  29  *            (long, short, with or without hold-off)
  30  *        Enhancements in async and iso send code
  31  */
  32
  33 #include <linux/config.h>
  34 #include <linux/kernel.h>
  35 #include <linux/slab.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/wait.h>
  38 #include <linux/errno.h>
  39 #include <linux/module.h>
  40 #include <linux/moduleparam.h>
  41 #include <linux/init.h>
  42 #include <linux/pci.h>
  43 #include <linux/fs.h>
  44 #include <linux/poll.h>
  45 #include <linux/kdev_t.h>
  46 #include <linux/dma-mapping.h>
  47 #include <asm/byteorder.h>
  48 #include <asm/atomic.h>
  49 #include <asm/io.h>
  50 #include <asm/uaccess.h>
  51 #include <asm/irq.h>
  52
  53 #include "csr1212.h"
  54 #include "ieee1394.h"
  55 #include "ieee1394_types.h"
  56 #include "hosts.h"
  57 #include "ieee1394_core.h"
  58 #include "highlevel.h"
  59 #include "pcilynx.h"
  60
  61 #include <linux/i2c.h>
  62 #include <linux/i2c-algo-bit.h>
  63
  64 /* print general (card independent) information */
  65 #define PRINT_G(level, fmt, args...) printk(level "pcilynx: " fmt "\n" , ## args)
  66 /* print card specific information */
  67 #define PRINT(level, card, fmt, args...) printk(level "pcilynx%d: " fmt "\n" , card , ## args)
  68
  69 #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  70 #define PRINT_GD(level, fmt, args...) printk(level "pcilynx: " fmt "\n" , ## args)
  71 #define PRINTD(level, card, fmt, args...) printk(level "pcilynx%d: " fmt "\n" , card , ## args)
  72 #else
  73 #define PRINT_GD(level, fmt, args...) do {} while (0)
  74 #define PRINTD(level, card, fmt, args...) do {} while (0)
  75 #endif
  76
  77
  78 /* Module Parameters */
  79 static int skip_eeprom;
  80 module_param(skip_eeprom, int, 0444);
  81 MODULE_PARM_DESC(skip_eeprom, "Use generic bus info block instead of serial eeprom (default = 0).");
  82
  83
  84 static struct hpsb_host_driver lynx_driver;
  85 static unsigned int card_id;
  86
  87
  88
  89 /*
  90  * I2C stuff
  91  */
  92
  93 /* the i2c stuff was inspired by i2c-philips-par.c */
  94
  95 static void bit_setscl(void *data, int state)
  96 {
  97         if (state) {
  98                   ((struct ti_lynx *) data)->i2c_driven_state |= 0x00000040;
  99         } else {
 100                   ((struct ti_lynx *) data)->i2c_driven_state &= ~0x00000040;
 101         }
 102         reg_write((struct ti_lynx *) data, SERIAL_EEPROM_CONTROL, ((struct ti_lynx *) data)->i2c_driven_state);
 103 }
 104
 105 static void bit_setsda(void *data, int state)
 106 {
 107         if (state) {
 108                   ((struct ti_lynx *) data)->i2c_driven_state |= 0x00000010;
 109         } else {
 110                   ((struct ti_lynx *) data)->i2c_driven_state &= ~0x00000010;
 111         }
 112         reg_write((struct ti_lynx *) data, SERIAL_EEPROM_CONTROL, ((struct ti_lynx *) data)->i2c_driven_state);
 113 }
 114
 115 static int bit_getscl(void *data)
 116 {
 117         return reg_read((struct ti_lynx *) data, SERIAL_EEPROM_CONTROL) & 0x00000040;
 118 }
 119
 120 static int bit_getsda(void *data)
 121 {
 122         return reg_read((struct ti_lynx *) data, SERIAL_EEPROM_CONTROL) & 0x00000010;
 123 }
 124
 125 static int bit_reg(struct i2c_client *client)
 126 {
 127         return 0;
 128 }
 129
 130 static int bit_unreg(struct i2c_client *client)
 131 {
 132         return 0;
 133 }
 134
 135 static struct i2c_algo_bit_data bit_data = {
 136         .setsda                 = bit_setsda,
 137         .setscl                 = bit_setscl,
 138         .getsda                 = bit_getsda,
 139         .getscl                 = bit_getscl,
 140         .udelay                 = 5,
 141         .mdelay                 = 5,
 142         .timeout                = 100,
 143 };
 144
 145 static struct i2c_adapter bit_ops = {
 146         .id                     = 0xAA, //FIXME: probably we should get an id in i2c-id.h
 147         .client_register        = bit_reg,
 148         .client_unregister      = bit_unreg,
 149         .name                   = "PCILynx I2C",
 150 };
 151
 152
 153
 154 /*
 155  * PCL handling functions.
 156  */
 157
 158 static pcl_t alloc_pcl(struct ti_lynx *lynx)
 159 {
 160         u8 m;
 161         int i, j;
 162
 163         spin_lock(&lynx->lock);
 164         /* FIXME - use ffz() to make this readable */
 165         for (i = 0; i < (LOCALRAM_SIZE / 1024); i++) {
 166                 m = lynx->pcl_bmap[i];
 167                 for (j = 0; j < 8; j++) {
 168                         if (m & 1<<j) {
 169                                 continue;
 170                         }
 171                         m |= 1<<j;
 172                         lynx->pcl_bmap[i] = m;
 173                         spin_unlock(&lynx->lock);
 174                         return 8 * i + j;
 175                 }
 176         }
 177         spin_unlock(&lynx->lock);
 178
 179         return -1;
 180 }
 181
 182
 183 #if 0
 184 static void free_pcl(struct ti_lynx *lynx, pcl_t pclid)
 185 {
 186         int off, bit;
 187
 188         off = pclid / 8;
 189         bit = pclid % 8;
 190
 191         if (pclid < 0) {
 192                 return;
 193         }
 194
 195         spin_lock(&lynx->lock);
 196         if (lynx->pcl_bmap[off] & 1<<bit) {
 197                 lynx->pcl_bmap[off] &= ~(1<<bit);
 198         } else {
 199                 PRINT(KERN_ERR, lynx->id,
 200                       "attempted to free unallocated PCL %d", pclid);
 201         }
 202         spin_unlock(&lynx->lock);
 203 }
 204
 205 /* functions useful for debugging */
 206 static void pretty_print_pcl(const struct ti_pcl *pcl)
 207 {
 208         int i;
 209
 210         printk("PCL next %08x, userdata %08x, status %08x, remtrans %08x, nextbuf %08x\n",
 211                pcl->next, pcl->user_data, pcl->pcl_status,
 212                pcl->remaining_transfer_count, pcl->next_data_buffer);
 213
 214         printk("PCL");
 215         for (i=0; i<13; i++) {
 216                 printk(" c%x:%08x d%x:%08x",
 217                        i, pcl->buffer[i].control, i, pcl->buffer[i].pointer);
 218                 if (!(i & 0x3) && (i != 12)) printk("\nPCL");
 219         }
 220         printk("\n");
 221 }
 222
 223 static void print_pcl(const struct ti_lynx *lynx, pcl_t pclid)
 224 {
 225         struct ti_pcl pcl;
 226
 227         get_pcl(lynx, pclid, &pcl);
 228         pretty_print_pcl(&pcl);
 229 }
 230 #endif
 231
 232
 233
 234 /***********************************
 235  * IEEE-1394 functionality section *
 236  ***********************************/
 237
 238
 239 static int get_phy_reg(struct ti_lynx *lynx, int addr)
 240 {
 241         int retval;
 242         int i = 0;
 243
 244         unsigned long flags;
 245
 246         if (addr > 15) {
 247                 PRINT(KERN_ERR, lynx->id,
 248                       "%s: PHY register address %d out of range",
 249                       __FUNCTION__, addr);
 250                 return -1;
 251         }
 252
 253         spin_lock_irqsave(&lynx->phy_reg_lock, flags);
 254
 255         reg_write(lynx, LINK_PHY, LINK_PHY_READ | LINK_PHY_ADDR(addr));
 256         do {
 257                 retval = reg_read(lynx, LINK_PHY);
 258
 259                 if (i > 10000) {
 260                         PRINT(KERN_ERR, lynx->id, "%s: runaway loop, aborting",
 261                               __FUNCTION__);
 262                         retval = -1;
 263                         break;
 264                 }
 265                 i++;
 266         } while ((retval & 0xf00) != LINK_PHY_RADDR(addr));
 267
 268         reg_write(lynx, LINK_INT_STATUS, LINK_INT_PHY_REG_RCVD);
 269         spin_unlock_irqrestore(&lynx->phy_reg_lock, flags);
 270
 271         if (retval != -1) {
 272                 return retval & 0xff;
 273         } else {
 274                 return -1;
 275         }
 276 }
 277
 278 static int set_phy_reg(struct ti_lynx *lynx, int addr, int val)
 279 {
 280         unsigned long flags;
 281
 282         if (addr > 15) {
 283                 PRINT(KERN_ERR, lynx->id,
 284                       "%s: PHY register address %d out of range", __FUNCTION__, addr);
 285                 return -1;
 286         }
 287
 288         if (val > 0xff) {
 289                 PRINT(KERN_ERR, lynx->id,
 290                       "%s: PHY register value %d out of range", __FUNCTION__, val);
 291                 return -1;
 292         }
 293
 294         spin_lock_irqsave(&lynx->phy_reg_lock, flags);
 295
 296         reg_write(lynx, LINK_PHY, LINK_PHY_WRITE | LINK_PHY_ADDR(addr)
 297                   | LINK_PHY_WDATA(val));
 298
 299         spin_unlock_irqrestore(&lynx->phy_reg_lock, flags);
 300
 301         return 0;
 302 }
 303
 304 static int sel_phy_reg_page(struct ti_lynx *lynx, int page)
 305 {
 306         int reg;
 307
 308         if (page > 7) {
 309                 PRINT(KERN_ERR, lynx->id,
 310                       "%s: PHY page %d out of range", __FUNCTION__, page);
 311                 return -1;
 312         }
 313
 314         reg = get_phy_reg(lynx, 7);
 315         if (reg != -1) {
 316                 reg &= 0x1f;
 317                 reg |= (page << 5);
 318                 set_phy_reg(lynx, 7, reg);
 319                 return 0;
 320         } else {
 321                 return -1;
 322         }
 323 }
 324
 325 #if 0 /* not needed at this time */
 326 static int sel_phy_reg_port(struct ti_lynx *lynx, int port)
 327 {
 328         int reg;
 329
 330         if (port > 15) {
 331                 PRINT(KERN_ERR, lynx->id,
 332                       "%s: PHY port %d out of range", __FUNCTION__, port);
 333                 return -1;
 334         }
 335
 336         reg = get_phy_reg(lynx, 7);
 337         if (reg != -1) {
 338                 reg &= 0xf0;
 339                 reg |= port;
 340                 set_phy_reg(lynx, 7, reg);
 341                 return 0;
 342         } else {
 343                 return -1;
 344         }
 345 }
 346 #endif
 347
 348 static u32 get_phy_vendorid(struct ti_lynx *lynx)
 349 {
 350         u32 pvid = 0;
 351         sel_phy_reg_page(lynx, 1);
 352         pvid |= (get_phy_reg(lynx, 10) << 16);
 353         pvid |= (get_phy_reg(lynx, 11) << 8);
 354         pvid |= get_phy_reg(lynx, 12);
 355         PRINT(KERN_INFO, lynx->id, "PHY vendor id 0x%06x", pvid);
 356         return pvid;
 357 }
 358
 359 static u32 get_phy_productid(struct ti_lynx *lynx)
 360 {
 361         u32 id = 0;
 362         sel_phy_reg_page(lynx, 1);
 363         id |= (get_phy_reg(lynx, 13) << 16);
 364         id |= (get_phy_reg(lynx, 14) << 8);
 365         id |= get_phy_reg(lynx, 15);
 366         PRINT(KERN_INFO, lynx->id, "PHY product id 0x%06x", id);
 367         return id;
 368 }
 369
 370 static quadlet_t generate_own_selfid(struct ti_lynx *lynx,
 371                                      struct hpsb_host *host)
 372 {
 373         quadlet_t lsid;
 374         char phyreg[7];
 375         int i;
 376
 377         phyreg[0] = lynx->phy_reg0;
 378         for (i = 1; i < 7; i++) {
 379                 phyreg[i] = get_phy_reg(lynx, i);
 380         }
 381
 382         /* FIXME? We assume a TSB21LV03A phy here.  This code doesn't support
 383            more than 3 ports on the PHY anyway. */
 384
 385         lsid = 0x80400000 | ((phyreg[0] & 0xfc) << 22);
 386         lsid |= (phyreg[1] & 0x3f) << 16; /* gap count */
 387         lsid |= (phyreg[2] & 0xc0) << 8; /* max speed */
 388         if (!hpsb_disable_irm)
 389                 lsid |= (phyreg[6] & 0x01) << 11; /* contender (phy dependent) */
 390         /* lsid |= 1 << 11; *//* set contender (hack) */
 391         lsid |= (phyreg[6] & 0x10) >> 3; /* initiated reset */
 392
 393         for (i = 0; i < (phyreg[2] & 0xf); i++) { /* ports */
 394                 if (phyreg[3 + i] & 0x4) {
 395                         lsid |= (((phyreg[3 + i] & 0x8) | 0x10) >> 3)
 396                                 << (6 - i*2);
 397                 } else {
 398                         lsid |= 1 << (6 - i*2);
 399                 }
 400         }
 401
 402         cpu_to_be32s(&lsid);
 403         PRINT(KERN_DEBUG, lynx->id, "generated own selfid 0x%x", lsid);
 404         return lsid;
 405 }
 406
 407 static void handle_selfid(struct ti_lynx *lynx, struct hpsb_host *host)
 408 {
 409         quadlet_t *q = lynx->rcv_page;
 410         int phyid, isroot, size;
 411         quadlet_t lsid = 0;
 412         int i;
 413
 414         if (lynx->phy_reg0 == -1 || lynx->selfid_size == -1) return;
 415
 416         size = lynx->selfid_size;
 417         phyid = lynx->phy_reg0;
 418
 419         i = (size > 16 ? 16 : size) / 4 - 1;
 420         while (i >= 0) {
 421                 cpu_to_be32s(&q[i]);
 422                 i--;
 423         }
 424
 425         if (!lynx->phyic.reg_1394a) {
 426                 lsid = generate_own_selfid(lynx, host);
 427         }
 428
 429         isroot = (phyid & 2) != 0;
 430         phyid >>= 2;
 431         PRINT(KERN_INFO, lynx->id, "SelfID process finished (phyid %d, %s)",
 432               phyid, (isroot ? "root" : "not root"));
 433         reg_write(lynx, LINK_ID, (0xffc0 | phyid) << 16);
 434
 435         if (!lynx->phyic.reg_1394a && !size) {
 436                 hpsb_selfid_received(host, lsid);
 437         }
 438
 439         while (size > 0) {
 440                 struct selfid *sid = (struct selfid *)q;
 441
 442                 if (!lynx->phyic.reg_1394a && !sid->extended
 443                     && (sid->phy_id == (phyid + 1))) {
 444                         hpsb_selfid_received(host, lsid);
 445                 }
 446
 447                 if (q[0] == ~q[1]) {
 448                         PRINT(KERN_DEBUG, lynx->id, "SelfID packet 0x%x rcvd",
 449                               q[0]);
 450                         hpsb_selfid_received(host, q[0]);
 451                 } else {
 452                         PRINT(KERN_INFO, lynx->id,
 453                               "inconsistent selfid 0x%x/0x%x", q[0], q[1]);
 454                 }
 455                 q += 2;
 456                 size -= 8;
 457         }
 458
 459         if (!lynx->phyic.reg_1394a && isroot && phyid != 0) {
 460                 hpsb_selfid_received(host, lsid);
 461         }
 462
 463         hpsb_selfid_complete(host, phyid, isroot);
 464
 465         if (host->in_bus_reset) return; /* in bus reset again */
 466
 467         if (isroot) reg_set_bits(lynx, LINK_CONTROL, LINK_CONTROL_CYCMASTER); //FIXME: I do not think, we need this here
 468         reg_set_bits(lynx, LINK_CONTROL,
 469                      LINK_CONTROL_RCV_CMP_VALID | LINK_CONTROL_TX_ASYNC_EN
 470                      | LINK_CONTROL_RX_ASYNC_EN | LINK_CONTROL_CYCTIMEREN);
 471 }
 472
 473
 474
 475 /* This must be called with the respective queue_lock held. */
 476 static void send_next(struct ti_lynx *lynx, int what)
 477 {
 478         struct ti_pcl pcl;
 479         struct lynx_send_data *d;
 480         struct hpsb_packet *packet;
 481
 482         d = (what == hpsb_iso ? &lynx->iso_send : &lynx->async);
 483         if (!list_empty(&d->pcl_queue)) {
 484                 PRINT(KERN_ERR, lynx->id, "trying to queue a new packet in nonempty fifo");
 485                 BUG();
 486         }
 487
 488         packet = driver_packet(d->queue.next);
 489         list_move_tail(&packet->driver_list, &d->pcl_queue);
 490
 491         d->header_dma = pci_map_single(lynx->dev, packet->header,
 492                                        packet->header_size, PCI_DMA_TODEVICE);
 493         if (packet->data_size) {
 494                 d->data_dma = pci_map_single(lynx->dev, packet->data,
 495                                              packet->data_size,
 496                                              PCI_DMA_TODEVICE);
 497         } else {
 498                 d->data_dma = 0;
 499         }
 500
 501         pcl.next = PCL_NEXT_INVALID;
 502         pcl.async_error_next = PCL_NEXT_INVALID;
 503         pcl.pcl_status = 0;
 504         pcl.buffer[0].control = packet->speed_code << 14 | packet->header_size;
 505 #ifndef __BIG_ENDIAN
 506         pcl.buffer[0].control |= PCL_BIGENDIAN;
 507 #endif
 508         pcl.buffer[0].pointer = d->header_dma;
 509         pcl.buffer[1].control = PCL_LAST_BUFF | packet->data_size;
 510         pcl.buffer[1].pointer = d->data_dma;
 511
 512         switch (packet->type) {
 513         case hpsb_async:
 514                 pcl.buffer[0].control |= PCL_CMD_XMT;
 515                 break;
 516         case hpsb_iso:
 517                 pcl.buffer[0].control |= PCL_CMD_XMT | PCL_ISOMODE;
 518                 break;
 519         case hpsb_raw:
 520                 pcl.buffer[0].control |= PCL_CMD_UNFXMT;
 521                 break;
 522         }
 523
 524         put_pcl(lynx, d->pcl, &pcl);
 525         run_pcl(lynx, d->pcl_start, d->channel);
 526 }
 527
 528
 529 /* called from subsystem core */
 530 static int lynx_transmit(struct hpsb_host *host, struct hpsb_packet *packet)
 531 {
 532         struct ti_lynx *lynx = host->hostdata;
 533         struct lynx_send_data *d;
 534         unsigned long flags;
 535
 536         if (packet->data_size >= 4096) {
 537                 PRINT(KERN_ERR, lynx->id, "transmit packet data too big (%Zd)",
 538                       packet->data_size);
 539                 return -EOVERFLOW;
 540         }
 541
 542         switch (packet->type) {
 543         case hpsb_async:
 544         case hpsb_raw:
 545                 d = &lynx->async;
 546                 break;
 547         case hpsb_iso:
 548                 d = &lynx->iso_send;
 549                 break;
 550         default:
 551                 PRINT(KERN_ERR, lynx->id, "invalid packet type %d",
 552                       packet->type);
 553                 return -EINVAL;
 554         }
 555
 556         if (packet->tcode == TCODE_WRITEQ
 557             || packet->tcode == TCODE_READQ_RESPONSE) {
 558                 cpu_to_be32s(&packet->header[3]);
 559         }
 560
 561         spin_lock_irqsave(&d->queue_lock, flags);
 562
 563         list_add_tail(&packet->driver_list, &d->queue);
 564         if (list_empty(&d->pcl_queue))
 565                 send_next(lynx, packet->type);
 566
 567         spin_unlock_irqrestore(&d->queue_lock, flags);
 568
 569         return 0;
 570 }
 571
 572
 573 /* called from subsystem core */
 574 static int lynx_devctl(struct hpsb_host *host, enum devctl_cmd cmd, int arg)
 575 {
 576         struct ti_lynx *lynx = host->hostdata;
 577         int retval = 0;
 578         struct hpsb_packet *packet;
 579         LIST_HEAD(packet_list);
 580         unsigned long flags;
 581         int phy_reg;
 582
 583         switch (cmd) {
 584         case RESET_BUS:
 585                 if (reg_read(lynx, LINK_INT_STATUS) & LINK_INT_PHY_BUSRESET) {
 586                         retval = 0;
 587                         break;
 588                 }
 589
 590                 switch (arg) {
 591                 case SHORT_RESET:
 592                         if (lynx->phyic.reg_1394a) {
 593                                 phy_reg = get_phy_reg(lynx, 5);
 594                                 if (phy_reg == -1) {
 595                                         PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 596                                         retval = -1;
 597                                         break;
 598                                 }
 599                                 phy_reg |= 0x40;
 600
 601                                 PRINT(KERN_INFO, lynx->id, "resetting bus (short bus reset) on request");
 602
 603                                 lynx->selfid_size = -1;
 604                                 lynx->phy_reg0 = -1;
 605                                 set_phy_reg(lynx, 5, phy_reg); /* set ISBR */
 606                                 break;
 607                         } else {
 608                                 PRINT(KERN_INFO, lynx->id, "cannot do short bus reset, because of old phy");
 609                                 /* fall through to long bus reset */
 610                         }
 611                 case LONG_RESET:
 612                         phy_reg = get_phy_reg(lynx, 1);
 613                         if (phy_reg == -1) {
 614                                 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 615                                 retval = -1;
 616                                 break;
 617                         }
 618                         phy_reg |= 0x40;
 619
 620                         PRINT(KERN_INFO, lynx->id, "resetting bus (long bus reset) on request");
 621
 622                         lynx->selfid_size = -1;
 623                         lynx->phy_reg0 = -1;
 624                         set_phy_reg(lynx, 1, phy_reg); /* clear RHB, set IBR */
 625                         break;
 626                 case SHORT_RESET_NO_FORCE_ROOT:
 627                         if (lynx->phyic.reg_1394a) {
 628                                 phy_reg = get_phy_reg(lynx, 1);
 629                                 if (phy_reg == -1) {
 630                                         PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 631                                         retval = -1;
 632                                         break;
 633                                 }
 634                                 if (phy_reg & 0x80) {
 635                                         phy_reg &= ~0x80;
 636                                         set_phy_reg(lynx, 1, phy_reg); /* clear RHB */
 637                                 }
 638
 639                                 phy_reg = get_phy_reg(lynx, 5);
 640                                 if (phy_reg == -1) {
 641                                         PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 642                                         retval = -1;
 643                                         break;
 644                                 }
 645                                 phy_reg |= 0x40;
 646
 647                                 PRINT(KERN_INFO, lynx->id, "resetting bus (short bus reset, no force_root) on request");
 648
 649                                 lynx->selfid_size = -1;
 650                                 lynx->phy_reg0 = -1;
 651                                 set_phy_reg(lynx, 5, phy_reg); /* set ISBR */
 652                                 break;
 653                         } else {
 654                                 PRINT(KERN_INFO, lynx->id, "cannot do short bus reset, because of old phy");
 655                                 /* fall through to long bus reset */
 656                         }
 657                 case LONG_RESET_NO_FORCE_ROOT:
 658                         phy_reg = get_phy_reg(lynx, 1);
 659                         if (phy_reg == -1) {
 660                                 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 661                                 retval = -1;
 662                                 break;
 663                         }
 664                         phy_reg &= ~0x80;
 665                         phy_reg |= 0x40;
 666
 667                         PRINT(KERN_INFO, lynx->id, "resetting bus (long bus reset, no force_root) on request");
 668
 669                         lynx->selfid_size = -1;
 670                         lynx->phy_reg0 = -1;
 671                         set_phy_reg(lynx, 1, phy_reg); /* clear RHB, set IBR */
 672                         break;
 673                 case SHORT_RESET_FORCE_ROOT:
 674                         if (lynx->phyic.reg_1394a) {
 675                                 phy_reg = get_phy_reg(lynx, 1);
 676                                 if (phy_reg == -1) {
 677                                         PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 678                                         retval = -1;
 679                                         break;
 680                                 }
 681                                 if (!(phy_reg & 0x80)) {
 682                                         phy_reg |= 0x80;
 683                                         set_phy_reg(lynx, 1, phy_reg); /* set RHB */
 684                                 }
 685
 686                                 phy_reg = get_phy_reg(lynx, 5);
 687                                 if (phy_reg == -1) {
 688                                         PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 689                                         retval = -1;
 690                                         break;
 691                                 }
 692                                 phy_reg |= 0x40;
 693
 694                                 PRINT(KERN_INFO, lynx->id, "resetting bus (short bus reset, force_root set) on request");
 695
 696                                 lynx->selfid_size = -1;
 697                                 lynx->phy_reg0 = -1;
 698                                 set_phy_reg(lynx, 5, phy_reg); /* set ISBR */
 699                                 break;
 700                         } else {
 701                                 PRINT(KERN_INFO, lynx->id, "cannot do short bus reset, because of old phy");
 702                                 /* fall through to long bus reset */
 703                         }
 704                 case LONG_RESET_FORCE_ROOT:
 705                         phy_reg = get_phy_reg(lynx, 1);
 706                         if (phy_reg == -1) {
 707                                 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
 708                                 retval = -1;
 709                                 break;
 710                         }
 711                         phy_reg |= 0xc0;
 712
 713                         PRINT(KERN_INFO, lynx->id, "resetting bus (long bus reset, force_root set) on request");
 714
 715                         lynx->selfid_size = -1;
 716                         lynx->phy_reg0 = -1;
 717                         set_phy_reg(lynx, 1, phy_reg); /* set IBR and RHB */
 718                         break;
 719                 default:
 720                         PRINT(KERN_ERR, lynx->id, "unknown argument for reset_bus command %d", arg);
 721                         retval = -1;
 722                 }
 723
 724                 break;
 725
 726         case GET_CYCLE_COUNTER:
 727                 retval = reg_read(lynx, CYCLE_TIMER);
 728                 break;
 729
 730         case SET_CYCLE_COUNTER:
 731                 reg_write(lynx, CYCLE_TIMER, arg);
 732                 break;
 733
 734         case SET_BUS_ID:
 735                 reg_write(lynx, LINK_ID,
 736                           (arg << 22) | (reg_read(lynx, LINK_ID) & 0x003f0000));
 737                 break;
 738
 739         case ACT_CYCLE_MASTER:
 740                 if (arg) {
 741                         reg_set_bits(lynx, LINK_CONTROL,
 742                                      LINK_CONTROL_CYCMASTER);
 743                 } else {
 744                         reg_clear_bits(lynx, LINK_CONTROL,
 745                                        LINK_CONTROL_CYCMASTER);
 746                 }
 747                 break;
 748
 749         case CANCEL_REQUESTS:
 750                 spin_lock_irqsave(&lynx->async.queue_lock, flags);
 751
 752                 reg_write(lynx, DMA_CHAN_CTRL(CHANNEL_ASYNC_SEND), 0);
 753                 list_splice(&lynx->async.queue, &packet_list);
 754                 INIT_LIST_HEAD(&lynx->async.queue);
 755
 756                 if (list_empty(&lynx->async.pcl_queue)) {
 757                         spin_unlock_irqrestore(&lynx->async.queue_lock, flags);
 758                         PRINTD(KERN_DEBUG, lynx->id, "no async packet in PCL to cancel");
 759                 } else {
 760                         struct ti_pcl pcl;
 761                         u32 ack;
 762                         struct hpsb_packet *packet;
 763
 764                         PRINT(KERN_INFO, lynx->id, "cancelling async packet, that was already in PCL");
 765
 766                         get_pcl(lynx, lynx->async.pcl, &pcl);
 767
 768                         packet = driver_packet(lynx->async.pcl_queue.next);
 769                         list_del_init(&packet->driver_list);
 770
 771                         pci_unmap_single(lynx->dev, lynx->async.header_dma,
 772                                          packet->header_size, PCI_DMA_TODEVICE);
 773                         if (packet->data_size) {
 774                                 pci_unmap_single(lynx->dev, lynx->async.data_dma,
 775                                                  packet->data_size, PCI_DMA_TODEVICE);
 776                         }
 777
 778                         spin_unlock_irqrestore(&lynx->async.queue_lock, flags);
 779
 780                         if (pcl.pcl_status & DMA_CHAN_STAT_PKTCMPL) {
 781                                 if (pcl.pcl_status & DMA_CHAN_STAT_SPECIALACK) {
 782                                         ack = (pcl.pcl_status >> 15) & 0xf;
 783                                         PRINTD(KERN_INFO, lynx->id, "special ack %d", ack);
 784                                         ack = (ack == 1 ? ACKX_TIMEOUT : ACKX_SEND_ERROR);
 785                                 } else {
 786                                         ack = (pcl.pcl_status >> 15) & 0xf;
 787                                 }
 788                         } else {
 789                                 PRINT(KERN_INFO, lynx->id, "async packet was not completed");
 790                                 ack = ACKX_ABORTED;
 791                         }
 792                         hpsb_packet_sent(host, packet, ack);
 793                 }
 794
 795                 while (!list_empty(&packet_list)) {
 796                         packet = driver_packet(packet_list.next);
 797                         list_del_init(&packet->driver_list);
 798                         hpsb_packet_sent(host, packet, ACKX_ABORTED);
 799                 }
 800
 801                 break;
 802
 803         case ISO_LISTEN_CHANNEL:
 804                 spin_lock_irqsave(&lynx->iso_rcv.lock, flags);
 805
 806                 if (lynx->iso_rcv.chan_count++ == 0) {
 807                         reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV),
 808                                   DMA_WORD1_CMP_ENABLE_MASTER);
 809                 }
 810
 811                 spin_unlock_irqrestore(&lynx->iso_rcv.lock, flags);
 812                 break;
 813
 814         case ISO_UNLISTEN_CHANNEL:
 815                 spin_lock_irqsave(&lynx->iso_rcv.lock, flags);
 816
 817                 if (--lynx->iso_rcv.chan_count == 0) {
 818                         reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV),
 819                                   0);
 820                 }
 821
 822                 spin_unlock_irqrestore(&lynx->iso_rcv.lock, flags);
 823                 break;
 824
 825         default:
 826                 PRINT(KERN_ERR, lynx->id, "unknown devctl command %d", cmd);
 827                 retval = -1;
 828         }
 829
 830         return retval;
 831 }
 832
 833
 834 /***************************************
 835  * IEEE-1394 functionality section END *
 836  ***************************************/
 837
 838
 839 /********************************************************
 840  * Global stuff (interrupt handler, init/shutdown code) *
 841  ********************************************************/
 842
 843
 844 static irqreturn_t lynx_irq_handler(int irq, void *dev_id,
 845                              struct pt_regs *regs_are_unused)
 846 {
 847         struct ti_lynx *lynx = (struct ti_lynx *)dev_id;
 848         struct hpsb_host *host = lynx->host;
 849         u32 intmask;
 850         u32 linkint;
 851
 852         linkint = reg_read(lynx, LINK_INT_STATUS);
 853         intmask = reg_read(lynx, PCI_INT_STATUS);
 854
 855         if (!(intmask & PCI_INT_INT_PEND))
 856                 return IRQ_NONE;
 857
 858         PRINTD(KERN_DEBUG, lynx->id, "interrupt: 0x%08x / 0x%08x", intmask,
 859                linkint);
 860
 861         reg_write(lynx, LINK_INT_STATUS, linkint);
 862         reg_write(lynx, PCI_INT_STATUS, intmask);
 863
 864         if (intmask & PCI_INT_1394) {
 865                 if (linkint & LINK_INT_PHY_TIMEOUT) {
 866                         PRINT(KERN_INFO, lynx->id, "PHY timeout occurred");
 867                 }
 868                 if (linkint & LINK_INT_PHY_BUSRESET) {
 869                         PRINT(KERN_INFO, lynx->id, "bus reset interrupt");
 870                         lynx->selfid_size = -1;
 871                         lynx->phy_reg0 = -1;
 872                         if (!host->in_bus_reset)
 873                                 hpsb_bus_reset(host);
 874                 }
 875                 if (linkint & LINK_INT_PHY_REG_RCVD) {
 876                         u32 reg;
 877
 878                         spin_lock(&lynx->phy_reg_lock);
 879                         reg = reg_read(lynx, LINK_PHY);
 880                         spin_unlock(&lynx->phy_reg_lock);
 881
 882                         if (!host->in_bus_reset) {
 883                                 PRINT(KERN_INFO, lynx->id,
 884                                       "phy reg received without reset");
 885                         } else if (reg & 0xf00) {
 886                                 PRINT(KERN_INFO, lynx->id,
 887                                       "unsolicited phy reg %d received",
 888                                       (reg >> 8) & 0xf);
 889                         } else {
 890                                 lynx->phy_reg0 = reg & 0xff;
 891                                 handle_selfid(lynx, host);
 892                         }
 893                 }
 894                 if (linkint & LINK_INT_ISO_STUCK) {
 895                         PRINT(KERN_INFO, lynx->id, "isochronous transmitter stuck");
 896                 }
 897                 if (linkint & LINK_INT_ASYNC_STUCK) {
 898                         PRINT(KERN_INFO, lynx->id, "asynchronous transmitter stuck");
 899                 }
 900                 if (linkint & LINK_INT_SENT_REJECT) {
 901                         PRINT(KERN_INFO, lynx->id, "sent reject");
 902                 }
 903                 if (linkint & LINK_INT_TX_INVALID_TC) {
 904                         PRINT(KERN_INFO, lynx->id, "invalid transaction code");
 905                 }
 906                 if (linkint & LINK_INT_GRF_OVERFLOW) {
 907                         /* flush FIFO if overflow happens during reset */
 908                         if (host->in_bus_reset)
 909                                 reg_write(lynx, FIFO_CONTROL,
 910                                           FIFO_CONTROL_GRF_FLUSH);
 911                         PRINT(KERN_INFO, lynx->id, "GRF overflow");
 912                 }
 913                 if (linkint & LINK_INT_ITF_UNDERFLOW) {
 914                         PRINT(KERN_INFO, lynx->id, "ITF underflow");
 915                 }
 916                 if (linkint & LINK_INT_ATF_UNDERFLOW) {
 917                         PRINT(KERN_INFO, lynx->id, "ATF underflow");
 918                 }
 919         }
 920
 921         if (intmask & PCI_INT_DMA_HLT(CHANNEL_ISO_RCV)) {
 922                 PRINTD(KERN_DEBUG, lynx->id, "iso receive");
 923
 924                 spin_lock(&lynx->iso_rcv.lock);
 925
 926                 lynx->iso_rcv.stat[lynx->iso_rcv.next] =
 927                         reg_read(lynx, DMA_CHAN_STAT(CHANNEL_ISO_RCV));
 928
 929                 lynx->iso_rcv.used++;
 930                 lynx->iso_rcv.next = (lynx->iso_rcv.next + 1) % NUM_ISORCV_PCL;
 931
 932                 if ((lynx->iso_rcv.next == lynx->iso_rcv.last)
 933                     || !lynx->iso_rcv.chan_count) {
 934                         PRINTD(KERN_DEBUG, lynx->id, "stopped");
 935                         reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV), 0);
 936                 }
 937
 938                 run_sub_pcl(lynx, lynx->iso_rcv.pcl_start, lynx->iso_rcv.next,
 939                             CHANNEL_ISO_RCV);
 940
 941                 spin_unlock(&lynx->iso_rcv.lock);
 942
 943                 tasklet_schedule(&lynx->iso_rcv.tq);
 944         }
 945
 946         if (intmask & PCI_INT_DMA_HLT(CHANNEL_ASYNC_SEND)) {
 947                 PRINTD(KERN_DEBUG, lynx->id, "async sent");
 948                 spin_lock(&lynx->async.queue_lock);
 949
 950                 if (list_empty(&lynx->async.pcl_queue)) {
 951                         spin_unlock(&lynx->async.queue_lock);
 952                         PRINT(KERN_WARNING, lynx->id, "async dma halted, but no queued packet (maybe it was cancelled)");
 953                 } else {
 954                         struct ti_pcl pcl;
 955                         u32 ack;
 956                         struct hpsb_packet *packet;
 957
 958                         get_pcl(lynx, lynx->async.pcl, &pcl);
 959
 960                         packet = driver_packet(lynx->async.pcl_queue.next);
 961                         list_del_init(&packet->driver_list);
 962
 963                         pci_unmap_single(lynx->dev, lynx->async.header_dma,
 964                                          packet->header_size, PCI_DMA_TODEVICE);
 965                         if (packet->data_size) {
 966                                 pci_unmap_single(lynx->dev, lynx->async.data_dma,
 967                                                  packet->data_size, PCI_DMA_TODEVICE);
 968                         }
 969
 970                         if (!list_empty(&lynx->async.queue)) {
 971                                 send_next(lynx, hpsb_async);
 972                         }
 973
 974                         spin_unlock(&lynx->async.queue_lock);
 975
 976                         if (pcl.pcl_status & DMA_CHAN_STAT_PKTCMPL) {
 977                                 if (pcl.pcl_status & DMA_CHAN_STAT_SPECIALACK) {
 978                                         ack = (pcl.pcl_status >> 15) & 0xf;
 979                                         PRINTD(KERN_INFO, lynx->id, "special ack %d", ack);
 980                                         ack = (ack == 1 ? ACKX_TIMEOUT : ACKX_SEND_ERROR);
 981                                 } else {
 982                                         ack = (pcl.pcl_status >> 15) & 0xf;
 983                                 }
 984                         } else {
 985                                 PRINT(KERN_INFO, lynx->id, "async packet was not completed");
 986                                 ack = ACKX_SEND_ERROR;
 987                         }
 988                         hpsb_packet_sent(host, packet, ack);
 989                 }
 990         }
 991
 992         if (intmask & PCI_INT_DMA_HLT(CHANNEL_ISO_SEND)) {
 993                 PRINTD(KERN_DEBUG, lynx->id, "iso sent");
 994                 spin_lock(&lynx->iso_send.queue_lock);
 995
 996                 if (list_empty(&lynx->iso_send.pcl_queue)) {
 997                         spin_unlock(&lynx->iso_send.queue_lock);
 998                         PRINT(KERN_ERR, lynx->id, "iso send dma halted, but no queued packet");
 999                 } else {
1000                         struct ti_pcl pcl;
1001                         u32 ack;
1002                         struct hpsb_packet *packet;
1003
1004                         get_pcl(lynx, lynx->iso_send.pcl, &pcl);
1005
1006                         packet = driver_packet(lynx->iso_send.pcl_queue.next);
1007                         list_del_init(&packet->driver_list);
1008
1009                         pci_unmap_single(lynx->dev, lynx->iso_send.header_dma,
1010                                          packet->header_size, PCI_DMA_TODEVICE);
1011                         if (packet->data_size) {
1012                                 pci_unmap_single(lynx->dev, lynx->iso_send.data_dma,
1013                                                  packet->data_size, PCI_DMA_TODEVICE);
1014                         }
1015
1016                         if (!list_empty(&lynx->iso_send.queue)) {
1017                                 send_next(lynx, hpsb_iso);
1018                         }
1019
1020                         spin_unlock(&lynx->iso_send.queue_lock);
1021
1022                         if (pcl.pcl_status & DMA_CHAN_STAT_PKTCMPL) {
1023                                 if (pcl.pcl_status & DMA_CHAN_STAT_SPECIALACK) {
1024                                         ack = (pcl.pcl_status >> 15) & 0xf;
1025                                         PRINTD(KERN_INFO, lynx->id, "special ack %d", ack);
1026                                         ack = (ack == 1 ? ACKX_TIMEOUT : ACKX_SEND_ERROR);
1027                                 } else {
1028                                         ack = (pcl.pcl_status >> 15) & 0xf;
1029                                 }
1030                         } else {
1031                                 PRINT(KERN_INFO, lynx->id, "iso send packet was not completed");
1032                                 ack = ACKX_SEND_ERROR;
1033                         }
1034
1035                         hpsb_packet_sent(host, packet, ack); //FIXME: maybe we should just use ACK_COMPLETE and ACKX_SEND_ERROR
1036                 }
1037         }
1038
1039         if (intmask & PCI_INT_DMA_HLT(CHANNEL_ASYNC_RCV)) {
1040                 /* general receive DMA completed */
1041                 int stat = reg_read(lynx, DMA_CHAN_STAT(CHANNEL_ASYNC_RCV));
1042
1043                 PRINTD(KERN_DEBUG, lynx->id, "received packet size %d",
1044                        stat & 0x1fff);
1045
1046                 if (stat & DMA_CHAN_STAT_SELFID) {
1047                         lynx->selfid_size = stat & 0x1fff;
1048                         handle_selfid(lynx, host);
1049                 } else {
1050                         quadlet_t *q_data = lynx->rcv_page;
1051                         if ((*q_data >> 4 & 0xf) == TCODE_READQ_RESPONSE
1052                             || (*q_data >> 4 & 0xf) == TCODE_WRITEQ) {
1053                                 cpu_to_be32s(q_data + 3);
1054                         }
1055                         hpsb_packet_received(host, q_data, stat & 0x1fff, 0);
1056                 }
1057
1058                 run_pcl(lynx, lynx->rcv_pcl_start, CHANNEL_ASYNC_RCV);
1059         }
1060
1061         return IRQ_HANDLED;
1062 }
1063
1064
1065 static void iso_rcv_bh(struct ti_lynx *lynx)
1066 {
1067         unsigned int idx;
1068         quadlet_t *data;
1069         unsigned long flags;
1070
1071         spin_lock_irqsave(&lynx->iso_rcv.lock, flags);
1072
1073         while (lynx->iso_rcv.used) {
1074                 idx = lynx->iso_rcv.last;
1075                 spin_unlock_irqrestore(&lynx->iso_rcv.lock, flags);
1076
1077                 data = lynx->iso_rcv.page[idx / ISORCV_PER_PAGE]
1078                         + (idx % ISORCV_PER_PAGE) * MAX_ISORCV_SIZE;
1079
1080                 if ((*data >> 16) + 4 != (lynx->iso_rcv.stat[idx] & 0x1fff)) {
1081                         PRINT(KERN_ERR, lynx->id,
1082                               "iso length mismatch 0x%08x/0x%08x", *data,
1083                               lynx->iso_rcv.stat[idx]);
1084                 }
1085
1086                 if (lynx->iso_rcv.stat[idx]
1087                     & (DMA_CHAN_STAT_PCIERR | DMA_CHAN_STAT_PKTERR)) {
1088                         PRINT(KERN_INFO, lynx->id,
1089                               "iso receive error on %d to 0x%p", idx, data);
1090                 } else {
1091                         hpsb_packet_received(lynx->host, data,
1092                                              lynx->iso_rcv.stat[idx] & 0x1fff,
1093                                              0);
1094                 }
1095
1096                 spin_lock_irqsave(&lynx->iso_rcv.lock, flags);
1097                 lynx->iso_rcv.last = (idx + 1) % NUM_ISORCV_PCL;
1098                 lynx->iso_rcv.used--;
1099         }
1100
1101         if (lynx->iso_rcv.chan_count) {
1102                 reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV),
1103                           DMA_WORD1_CMP_ENABLE_MASTER);
1104         }
1105         spin_unlock_irqrestore(&lynx->iso_rcv.lock, flags);
1106 }
1107
1108
1109 static void remove_card(struct pci_dev *dev)
1110 {
1111         struct ti_lynx *lynx;
1112         struct device *lynx_dev;
1113         int i;
1114
1115         lynx = pci_get_drvdata(dev);
1116         if (!lynx) return;
1117         pci_set_drvdata(dev, NULL);
1118
1119         lynx_dev = get_device(&lynx->host->device);
1120
1121         switch (lynx->state) {
1122         case is_host:
1123                 reg_write(lynx, PCI_INT_ENABLE, 0);
1124                 hpsb_remove_host(lynx->host);
1125         case have_intr:
1126                 reg_write(lynx, PCI_INT_ENABLE, 0);
1127                 free_irq(lynx->dev->irq, lynx);
1128
1129                 /* Disable IRM Contender and LCtrl */
1130                 if (lynx->phyic.reg_1394a)
1131                         set_phy_reg(lynx, 4, ~0xc0 & get_phy_reg(lynx, 4));
1132
1133                 /* Let all other nodes know to ignore us */
1134                 lynx_devctl(lynx->host, RESET_BUS, LONG_RESET_NO_FORCE_ROOT);
1135
1136         case have_iomappings:
1137                 reg_set_bits(lynx, MISC_CONTROL, MISC_CONTROL_SWRESET);
1138                 /* Fix buggy cards with autoboot pin not tied low: */
1139                 reg_write(lynx, DMA0_CHAN_CTRL, 0);
1140                 iounmap(lynx->registers);
1141                 iounmap(lynx->local_rom);
1142                 iounmap(lynx->local_ram);
1143                 iounmap(lynx->aux_port);
1144         case have_1394_buffers:
1145                 for (i = 0; i < ISORCV_PAGES; i++) {
1146                         if (lynx->iso_rcv.page[i]) {
1147                                 pci_free_consistent(lynx->dev, PAGE_SIZE,
1148                                                     lynx->iso_rcv.page[i],
1149                                                     lynx->iso_rcv.page_dma[i]);
1150                         }
1151                 }
1152                 pci_free_consistent(lynx->dev, PAGE_SIZE, lynx->rcv_page,
1153                                     lynx->rcv_page_dma);
1154         case have_aux_buf:
1155         case have_pcl_mem:
1156                 pci_free_consistent(lynx->dev, LOCALRAM_SIZE, lynx->pcl_mem,
1157                                     lynx->pcl_mem_dma);
1158         case clear:
1159                 /* do nothing - already freed */
1160                 ;
1161         }
1162
1163         tasklet_kill(&lynx->iso_rcv.tq);
1164
1165         if (lynx_dev)
1166                 put_device(lynx_dev);
1167 }
1168
1169
1170 static int __devinit add_card(struct pci_dev *dev,
1171                               const struct pci_device_id *devid_is_unused)
1172 {
1173 #define FAIL(fmt, args...) do { \
1174         PRINT_G(KERN_ERR, fmt , ## args); \
1175         remove_card(dev); \
1176         return error; \
1177         } while (0)
1178
1179         char irq_buf[16];
1180         struct hpsb_host *host;
1181         struct ti_lynx *lynx; /* shortcut to currently handled device */
1182         struct ti_pcl pcl;
1183         u32 *pcli;
1184         int i;
1185         int error;
1186
1187         error = -ENXIO;
1188
1189         if (pci_set_dma_mask(dev, DMA_32BIT_MASK))
1190                 FAIL("DMA address limits not supported for PCILynx hardware");
1191         if (pci_enable_device(dev))
1192                 FAIL("failed to enable PCILynx hardware");
1193         pci_set_master(dev);
1194
1195         error = -ENOMEM;
1196
1197         host = hpsb_alloc_host(&lynx_driver, sizeof(struct ti_lynx), &dev->dev);
1198         if (!host) FAIL("failed to allocate control structure memory");
1199
1200         lynx = host->hostdata;
1201         lynx->id = card_id++;
1202         lynx->dev = dev;
1203         lynx->state = clear;
1204         lynx->host = host;
1205         host->pdev = dev;
1206         pci_set_drvdata(dev, lynx);
1207
1208         spin_lock_init(&lynx->lock);
1209         spin_lock_init(&lynx->phy_reg_lock);
1210
1211         lynx->pcl_mem = pci_alloc_consistent(dev, LOCALRAM_SIZE,
1212                                              &lynx->pcl_mem_dma);
1213
1214         if (lynx->pcl_mem != NULL) {
1215                 lynx->state = have_pcl_mem;
1216                 PRINT(KERN_INFO, lynx->id,
1217                       "allocated PCL memory %d Bytes @ 0x%p", LOCALRAM_SIZE,
1218                       lynx->pcl_mem);
1219         } else {
1220                 FAIL("failed to allocate PCL memory area");
1221         }
1222
1223         lynx->rcv_page = pci_alloc_consistent(dev, PAGE_SIZE,
1224                                               &lynx->rcv_page_dma);
1225         if (lynx->rcv_page == NULL) {
1226                 FAIL("failed to allocate receive buffer");
1227         }
1228         lynx->state = have_1394_buffers;
1229
1230         for (i = 0; i < ISORCV_PAGES; i++) {
1231                 lynx->iso_rcv.page[i] =
1232                         pci_alloc_consistent(dev, PAGE_SIZE,
1233                                              &lynx->iso_rcv.page_dma[i]);
1234                 if (lynx->iso_rcv.page[i] == NULL) {
1235                         FAIL("failed to allocate iso receive buffers");
1236                 }
1237         }
1238
1239         lynx->registers = ioremap_nocache(pci_resource_start(dev,0),
1240                                           PCILYNX_MAX_REGISTER);
1241         lynx->local_ram = ioremap(pci_resource_start(dev,1), PCILYNX_MAX_MEMORY);
1242         lynx->aux_port  = ioremap(pci_resource_start(dev,2), PCILYNX_MAX_MEMORY);
1243         lynx->local_rom = ioremap(pci_resource_start(dev,PCI_ROM_RESOURCE),
1244                                   PCILYNX_MAX_MEMORY);
1245         lynx->state = have_iomappings;
1246
1247         if (lynx->registers == NULL) {
1248                 FAIL("failed to remap registers - card not accessible");
1249         }
1250
1251         reg_set_bits(lynx, MISC_CONTROL, MISC_CONTROL_SWRESET);
1252         /* Fix buggy cards with autoboot pin not tied low: */
1253         reg_write(lynx, DMA0_CHAN_CTRL, 0);
1254
1255 #ifndef __sparc__
1256         sprintf (irq_buf, "%d", dev->irq);
1257 #else
1258         sprintf (irq_buf, "%s", __irq_itoa(dev->irq));
1259 #endif
1260
1261         if (!request_irq(dev->irq, lynx_irq_handler, SA_SHIRQ,
1262                          PCILYNX_DRIVER_NAME, lynx)) {
1263                 PRINT(KERN_INFO, lynx->id, "allocated interrupt %s", irq_buf);
1264                 lynx->state = have_intr;
1265         } else {
1266                 FAIL("failed to allocate shared interrupt %s", irq_buf);
1267         }
1268
1269         /* alloc_pcl return values are not checked, it is expected that the
1270          * provided PCL space is sufficient for the initial allocations */
1271         lynx->rcv_pcl = alloc_pcl(lynx);
1272         lynx->rcv_pcl_start = alloc_pcl(lynx);
1273         lynx->async.pcl = alloc_pcl(lynx);
1274         lynx->async.pcl_start = alloc_pcl(lynx);
1275         lynx->iso_send.pcl = alloc_pcl(lynx);
1276         lynx->iso_send.pcl_start = alloc_pcl(lynx);
1277
1278         for (i = 0; i < NUM_ISORCV_PCL; i++) {
1279                 lynx->iso_rcv.pcl[i] = alloc_pcl(lynx);
1280         }
1281         lynx->iso_rcv.pcl_start = alloc_pcl(lynx);
1282
1283         /* all allocations successful - simple init stuff follows */
1284
1285         reg_write(lynx, PCI_INT_ENABLE, PCI_INT_DMA_ALL);
1286
1287         tasklet_init(&lynx->iso_rcv.tq, (void (*)(unsigned long))iso_rcv_bh,
1288                      (unsigned long)lynx);
1289
1290         spin_lock_init(&lynx->iso_rcv.lock);
1291
1292         spin_lock_init(&lynx->async.queue_lock);
1293         lynx->async.channel = CHANNEL_ASYNC_SEND;
1294         spin_lock_init(&lynx->iso_send.queue_lock);
1295         lynx->iso_send.channel = CHANNEL_ISO_SEND;
1296
1297         PRINT(KERN_INFO, lynx->id, "remapped memory spaces reg 0x%p, rom 0x%p, "
1298               "ram 0x%p, aux 0x%p", lynx->registers, lynx->local_rom,
1299               lynx->local_ram, lynx->aux_port);
1300
1301         /* now, looking for PHY register set */
1302         if ((get_phy_reg(lynx, 2) & 0xe0) == 0xe0) {
1303                 lynx->phyic.reg_1394a = 1;
1304                 PRINT(KERN_INFO, lynx->id,
1305                       "found 1394a conform PHY (using extended register set)");
1306                 lynx->phyic.vendor = get_phy_vendorid(lynx);
1307                 lynx->phyic.product = get_phy_productid(lynx);
1308         } else {
1309                 lynx->phyic.reg_1394a = 0;
1310                 PRINT(KERN_INFO, lynx->id, "found old 1394 PHY");
1311         }
1312
1313         lynx->selfid_size = -1;
1314         lynx->phy_reg0 = -1;
1315
1316         INIT_LIST_HEAD(&lynx->async.queue);
1317         INIT_LIST_HEAD(&lynx->async.pcl_queue);
1318         INIT_LIST_HEAD(&lynx->iso_send.queue);
1319         INIT_LIST_HEAD(&lynx->iso_send.pcl_queue);
1320
1321         pcl.next = pcl_bus(lynx, lynx->rcv_pcl);
1322         put_pcl(lynx, lynx->rcv_pcl_start, &pcl);
1323
1324         pcl.next = PCL_NEXT_INVALID;
1325         pcl.async_error_next = PCL_NEXT_INVALID;
1326
1327         pcl.buffer[0].control = PCL_CMD_RCV | 16;
1328 #ifndef __BIG_ENDIAN
1329         pcl.buffer[0].control |= PCL_BIGENDIAN;
1330 #endif
1331         pcl.buffer[1].control = PCL_LAST_BUFF | 4080;
1332
1333         pcl.buffer[0].pointer = lynx->rcv_page_dma;
1334         pcl.buffer[1].pointer = lynx->rcv_page_dma + 16;
1335         put_pcl(lynx, lynx->rcv_pcl, &pcl);
1336
1337         pcl.next = pcl_bus(lynx, lynx->async.pcl);
1338         pcl.async_error_next = pcl_bus(lynx, lynx->async.pcl);
1339         put_pcl(lynx, lynx->async.pcl_start, &pcl);
1340
1341         pcl.next = pcl_bus(lynx, lynx->iso_send.pcl);
1342         pcl.async_error_next = PCL_NEXT_INVALID;
1343         put_pcl(lynx, lynx->iso_send.pcl_start, &pcl);
1344
1345         pcl.next = PCL_NEXT_INVALID;
1346         pcl.async_error_next = PCL_NEXT_INVALID;
1347         pcl.buffer[0].control = PCL_CMD_RCV | 4;
1348 #ifndef __BIG_ENDIAN
1349         pcl.buffer[0].control |= PCL_BIGENDIAN;
1350 #endif
1351         pcl.buffer[1].control = PCL_LAST_BUFF | 2044;
1352
1353         for (i = 0; i < NUM_ISORCV_PCL; i++) {
1354                 int page = i / ISORCV_PER_PAGE;
1355                 int sec = i % ISORCV_PER_PAGE;
1356
1357                 pcl.buffer[0].pointer = lynx->iso_rcv.page_dma[page]
1358                         + sec * MAX_ISORCV_SIZE;
1359                 pcl.buffer[1].pointer = pcl.buffer[0].pointer + 4;
1360                 put_pcl(lynx, lynx->iso_rcv.pcl[i], &pcl);
1361         }
1362
1363         pcli = (u32 *)&pcl;
1364         for (i = 0; i < NUM_ISORCV_PCL; i++) {
1365                 pcli[i] = pcl_bus(lynx, lynx->iso_rcv.pcl[i]);
1366         }
1367         put_pcl(lynx, lynx->iso_rcv.pcl_start, &pcl);
1368
1369         /* FIFO sizes from left to right: ITF=48 ATF=48 GRF=160 */
1370         reg_write(lynx, FIFO_SIZES, 0x003030a0);
1371         /* 20 byte threshold before triggering PCI transfer */
1372         reg_write(lynx, DMA_GLOBAL_REGISTER, 0x2<<24);
1373         /* threshold on both send FIFOs before transmitting:
1374            FIFO size - cache line size - 1 */
1375         i = reg_read(lynx, PCI_LATENCY_CACHELINE) & 0xff;
1376         i = 0x30 - i - 1;
1377         reg_write(lynx, FIFO_XMIT_THRESHOLD, (i << 8) | i);
1378
1379         reg_set_bits(lynx, PCI_INT_ENABLE, PCI_INT_1394);
1380
1381         reg_write(lynx, LINK_INT_ENABLE, LINK_INT_PHY_TIMEOUT
1382                   | LINK_INT_PHY_REG_RCVD  | LINK_INT_PHY_BUSRESET
1383                   | LINK_INT_ISO_STUCK     | LINK_INT_ASYNC_STUCK
1384                   | LINK_INT_SENT_REJECT   | LINK_INT_TX_INVALID_TC
1385                   | LINK_INT_GRF_OVERFLOW  | LINK_INT_ITF_UNDERFLOW
1386                   | LINK_INT_ATF_UNDERFLOW);
1387
1388         reg_write(lynx, DMA_WORD0_CMP_VALUE(CHANNEL_ASYNC_RCV), 0);
1389         reg_write(lynx, DMA_WORD0_CMP_ENABLE(CHANNEL_ASYNC_RCV), 0xa<<4);
1390         reg_write(lynx, DMA_WORD1_CMP_VALUE(CHANNEL_ASYNC_RCV), 0);
1391         reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ASYNC_RCV),
1392                   DMA_WORD1_CMP_MATCH_LOCAL_NODE | DMA_WORD1_CMP_MATCH_BROADCAST
1393                   | DMA_WORD1_CMP_MATCH_EXACT    | DMA_WORD1_CMP_MATCH_BUS_BCAST
1394                   | DMA_WORD1_CMP_ENABLE_SELF_ID | DMA_WORD1_CMP_ENABLE_MASTER);
1395
1396         run_pcl(lynx, lynx->rcv_pcl_start, CHANNEL_ASYNC_RCV);
1397
1398         reg_write(lynx, DMA_WORD0_CMP_VALUE(CHANNEL_ISO_RCV), 0);
1399         reg_write(lynx, DMA_WORD0_CMP_ENABLE(CHANNEL_ISO_RCV), 0x9<<4);
1400         reg_write(lynx, DMA_WORD1_CMP_VALUE(CHANNEL_ISO_RCV), 0);
1401         reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV), 0);
1402
1403         run_sub_pcl(lynx, lynx->iso_rcv.pcl_start, 0, CHANNEL_ISO_RCV);
1404
1405         reg_write(lynx, LINK_CONTROL, LINK_CONTROL_RCV_CMP_VALID
1406                   | LINK_CONTROL_TX_ISO_EN   | LINK_CONTROL_RX_ISO_EN
1407                   | LINK_CONTROL_TX_ASYNC_EN | LINK_CONTROL_RX_ASYNC_EN
1408                   | LINK_CONTROL_RESET_TX    | LINK_CONTROL_RESET_RX);
1409
1410         if (!lynx->phyic.reg_1394a) {
1411                 if (!hpsb_disable_irm) {
1412                         /* attempt to enable contender bit -FIXME- would this
1413                          * work elsewhere? */
1414                         reg_set_bits(lynx, GPIO_CTRL_A, 0x1);
1415                         reg_write(lynx, GPIO_DATA_BASE + 0x3c, 0x1);
1416                 }
1417         } else {
1418                 /* set the contender (if appropriate) and LCtrl bit in the
1419                  * extended PHY register set. (Should check that PHY_02_EXTENDED
1420                  * is set in register 2?)
1421                  */
1422                 i = get_phy_reg(lynx, 4);
1423                 i |= PHY_04_LCTRL;
1424                 if (hpsb_disable_irm)
1425                         i &= ~PHY_04_CONTENDER;
1426                 else
1427                         i |= PHY_04_CONTENDER;
1428                 if (i != -1) set_phy_reg(lynx, 4, i);
1429         }
1430
1431         if (!skip_eeprom)
1432         {
1433                 /* needed for i2c communication with serial eeprom */
1434                 struct i2c_adapter *i2c_ad;
1435                 struct i2c_algo_bit_data i2c_adapter_data;
1436
1437                 error = -ENOMEM;
1438                 i2c_ad = kmalloc(sizeof(*i2c_ad), SLAB_KERNEL);
1439                 if (!i2c_ad) FAIL("failed to allocate I2C adapter memory");
1440
1441                 memcpy(i2c_ad, &bit_ops, sizeof(struct i2c_adapter));
1442                 i2c_adapter_data = bit_data;
1443                 i2c_ad->algo_data = &i2c_adapter_data;
1444                 i2c_adapter_data.data = lynx;
1445
1446                 PRINTD(KERN_DEBUG, lynx->id,"original eeprom control: %d",
1447                        reg_read(lynx, SERIAL_EEPROM_CONTROL));
1448
1449                 /* reset hardware to sane state */
1450                 lynx->i2c_driven_state = 0x00000070;
1451                 reg_write(lynx, SERIAL_EEPROM_CONTROL, lynx->i2c_driven_state);
1452
1453                 if (i2c_bit_add_bus(i2c_ad) < 0)
1454                 {
1455                         kfree(i2c_ad);
1456                         error = -ENXIO;
1457                         FAIL("unable to register i2c");
1458                 }
1459                 else
1460                 {
1461                         /* do i2c stuff */
1462                         unsigned char i2c_cmd = 0x10;
1463                         struct i2c_msg msg[2] = { { 0x50, 0, 1, &i2c_cmd },
1464                                                   { 0x50, I2C_M_RD, 20, (unsigned char*) lynx->bus_info_block }
1465                                                 };
1466
1467                         /* we use i2c_transfer, because i2c_smbus_read_block_data does not work properly and we
1468                            do it more efficiently in one transaction rather then using several reads */
1469                         if (i2c_transfer(i2c_ad, msg, 2) < 0) {
1470                                 PRINT(KERN_ERR, lynx->id, "unable to read bus info block from i2c");
1471                         } else {
1472                                 int i;
1473
1474                                 PRINT(KERN_INFO, lynx->id, "got bus info block from serial eeprom");
1475                                 /* FIXME: probably we shoud rewrite the max_rec, max_ROM(1394a),
1476                                  * generation(1394a) and link_spd(1394a) field and recalculate
1477                                  * the CRC */
1478
1479                                 for (i = 0; i < 5 ; i++)
1480                                         PRINTD(KERN_DEBUG, lynx->id, "Businfo block quadlet %i: %08x",
1481                                                i, be32_to_cpu(lynx->bus_info_block[i]));
1482
1483                                 /* info_length, crc_length and 1394 magic number to check, if it is really a bus info block */
1484                                 if (((be32_to_cpu(lynx->bus_info_block[0]) & 0xffff0000) == 0x04040000) &&
1485                                     (lynx->bus_info_block[1] == __constant_cpu_to_be32(0x31333934)))
1486                                 {
1487                                         PRINT(KERN_DEBUG, lynx->id, "read a valid bus info block from");
1488                                 } else {
1489                                         kfree(i2c_ad);
1490                                         error = -ENXIO;
1491                                         FAIL("read something from serial eeprom, but it does not seem to be a valid bus info block");
1492                                 }
1493
1494                         }
1495
1496                         i2c_bit_del_bus(i2c_ad);
1497                         kfree(i2c_ad);
1498                 }
1499         }
1500
1501         host->csr.guid_hi = be32_to_cpu(lynx->bus_info_block[3]);
1502         host->csr.guid_lo = be32_to_cpu(lynx->bus_info_block[4]);
1503         host->csr.cyc_clk_acc = (be32_to_cpu(lynx->bus_info_block[2]) >> 16) & 0xff;
1504         host->csr.max_rec = (be32_to_cpu(lynx->bus_info_block[2]) >> 12) & 0xf;
1505         if (!lynx->phyic.reg_1394a)
1506                 host->csr.lnk_spd = (get_phy_reg(lynx, 2) & 0xc0) >> 6;
1507         else
1508                 host->csr.lnk_spd = be32_to_cpu(lynx->bus_info_block[2]) & 0x7;
1509
1510         if (hpsb_add_host(host)) {
1511                 error = -ENOMEM;
1512                 FAIL("Failed to register host with highlevel");
1513         }
1514
1515         lynx->state = is_host;
1516
1517         return 0;
1518 #undef FAIL
1519 }
1520
1521
1522 static struct pci_device_id pci_table[] = {
1523         {
1524                 .vendor =    PCI_VENDOR_ID_TI,
1525                 .device =    PCI_DEVICE_ID_TI_PCILYNX,
1526                 .subvendor = PCI_ANY_ID,
1527                 .subdevice = PCI_ANY_ID,
1528         },
1529         { }                     /* Terminating entry */
1530 };
1531
1532 static struct pci_driver lynx_pci_driver = {
1533         .name =     PCILYNX_DRIVER_NAME,
1534         .id_table = pci_table,
1535         .probe =    add_card,
1536         .remove =   remove_card,
1537 };
1538
1539 static struct hpsb_host_driver lynx_driver = {
1540         .owner =           THIS_MODULE,
1541         .name =            PCILYNX_DRIVER_NAME,
1542         .set_hw_config_rom = NULL,
1543         .transmit_packet = lynx_transmit,
1544         .devctl =          lynx_devctl,
1545         .isoctl =          NULL,
1546 };
1547
1548 MODULE_AUTHOR("Andreas E. Bombe <andreas.bombe@munich.netsurf.de>");
1549 MODULE_DESCRIPTION("driver for Texas Instruments PCI Lynx IEEE-1394 controller");
1550 MODULE_LICENSE("GPL");
1551 MODULE_SUPPORTED_DEVICE("pcilynx");
1552 MODULE_DEVICE_TABLE(pci, pci_table);
1553
1554 static int __init pcilynx_init(void)
1555 {
1556         int ret;
1557
1558         ret = pci_register_driver(&lynx_pci_driver);
1559         if (ret < 0) {
1560                 PRINT_G(KERN_ERR, "PCI module init failed");
1561                 return ret;
1562         }
1563
1564         return 0;
1565 }
1566
1567 static void __exit pcilynx_cleanup(void)
1568 {
1569         pci_unregister_driver(&lynx_pci_driver);
1570 }
1571
1572
1573 module_init(pcilynx_init);
1574 module_exit(pcilynx_cleanup);