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