Lines Matching refs:lynx
138 static pcl_t alloc_pcl(struct ti_lynx *lynx)
143 spin_lock(&lynx->lock);
145 m = lynx->pcl_bmap[i];
151 lynx->pcl_bmap[i] = m;
152 spin_unlock(&lynx->lock);
156 spin_unlock(&lynx->lock);
170 static int get_phy_reg(struct ti_lynx *lynx, int addr)
178 PRINT(KERN_ERR, lynx->id,
184 spin_lock_irqsave(&lynx->phy_reg_lock, flags);
186 reg_write(lynx, LINK_PHY, LINK_PHY_READ | LINK_PHY_ADDR(addr));
188 retval = reg_read(lynx, LINK_PHY);
191 PRINT(KERN_ERR, lynx->id, "%s: runaway loop, aborting",
199 reg_write(lynx, LINK_INT_STATUS, LINK_INT_PHY_REG_RCVD);
200 spin_unlock_irqrestore(&lynx->phy_reg_lock, flags);
209 static int set_phy_reg(struct ti_lynx *lynx, int addr, int val)
214 PRINT(KERN_ERR, lynx->id,
220 PRINT(KERN_ERR, lynx->id,
225 spin_lock_irqsave(&lynx->phy_reg_lock, flags);
227 reg_write(lynx, LINK_PHY, LINK_PHY_WRITE | LINK_PHY_ADDR(addr)
230 spin_unlock_irqrestore(&lynx->phy_reg_lock, flags);
235 static int sel_phy_reg_page(struct ti_lynx *lynx, int page)
240 PRINT(KERN_ERR, lynx->id,
245 reg = get_phy_reg(lynx, 7);
249 set_phy_reg(lynx, 7, reg);
257 static u32 get_phy_vendorid(struct ti_lynx *lynx)
260 sel_phy_reg_page(lynx, 1);
261 pvid |= (get_phy_reg(lynx, 10) << 16);
262 pvid |= (get_phy_reg(lynx, 11) << 8);
263 pvid |= get_phy_reg(lynx, 12);
264 PRINT(KERN_INFO, lynx->id, "PHY vendor id 0x%06x", pvid);
268 static u32 get_phy_productid(struct ti_lynx *lynx)
271 sel_phy_reg_page(lynx, 1);
272 id |= (get_phy_reg(lynx, 13) << 16);
273 id |= (get_phy_reg(lynx, 14) << 8);
274 id |= get_phy_reg(lynx, 15);
275 PRINT(KERN_INFO, lynx->id, "PHY product id 0x%06x", id);
279 static quadlet_t generate_own_selfid(struct ti_lynx *lynx,
286 phyreg[0] = lynx->phy_reg0;
288 phyreg[i] = get_phy_reg(lynx, i);
310 PRINT(KERN_DEBUG, lynx->id, "generated own selfid 0x%x", lsid);
314 static void handle_selfid(struct ti_lynx *lynx, struct hpsb_host *host)
316 quadlet_t *q = lynx->rcv_page;
321 if (lynx->phy_reg0 == -1 || lynx->selfid_size == -1) return;
323 size = lynx->selfid_size;
324 phyid = lynx->phy_reg0;
332 if (!lynx->phyic.reg_1394a) {
333 lsid = generate_own_selfid(lynx, host);
338 PRINT(KERN_INFO, lynx->id, "SelfID process finished (phyid %d, %s)",
340 reg_write(lynx, LINK_ID, (0xffc0 | phyid) << 16);
342 if (!lynx->phyic.reg_1394a && !size) {
349 if (!lynx->phyic.reg_1394a && !sid->extended
355 PRINT(KERN_DEBUG, lynx->id, "SelfID packet 0x%x rcvd",
359 PRINT(KERN_INFO, lynx->id,
366 if (!lynx->phyic.reg_1394a && isroot && phyid != 0) {
374 if (isroot) reg_set_bits(lynx, LINK_CONTROL, LINK_CONTROL_CYCMASTER);
375 reg_set_bits(lynx, LINK_CONTROL,
383 static void send_next(struct ti_lynx *lynx, int what)
389 d = &lynx->async;
391 PRINT(KERN_ERR, lynx->id, "trying to queue a new packet in nonempty fifo");
398 d->header_dma = pci_map_single(lynx->dev, packet->header,
401 d->data_dma = pci_map_single(lynx->dev, packet->data,
428 put_pcl(lynx, d->pcl, &pcl);
429 run_pcl(lynx, d->pcl_start, d->channel);
436 struct ti_lynx *lynx = host->hostdata;
441 PRINT(KERN_ERR, lynx->id, "transmit packet data too big (%Zd)",
449 d = &lynx->async;
452 PRINT(KERN_ERR, lynx->id, "invalid packet type %d",
466 send_next(lynx, packet->type);
477 struct ti_lynx *lynx = host->hostdata;
486 if (reg_read(lynx, LINK_INT_STATUS) & LINK_INT_PHY_BUSRESET) {
493 if (lynx->phyic.reg_1394a) {
494 phy_reg = get_phy_reg(lynx, 5);
496 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
502 PRINT(KERN_INFO, lynx->id, "resetting bus (short bus reset) on request");
504 lynx->selfid_size = -1;
505 lynx->phy_reg0 = -1;
506 set_phy_reg(lynx, 5, phy_reg); /* set ISBR */
509 PRINT(KERN_INFO, lynx->id, "cannot do short bus reset, because of old phy");
513 phy_reg = get_phy_reg(lynx, 1);
515 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
521 PRINT(KERN_INFO, lynx->id, "resetting bus (long bus reset) on request");
523 lynx->selfid_size = -1;
524 lynx->phy_reg0 = -1;
525 set_phy_reg(lynx, 1, phy_reg); /* clear RHB, set IBR */
528 if (lynx->phyic.reg_1394a) {
529 phy_reg = get_phy_reg(lynx, 1);
531 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
537 set_phy_reg(lynx, 1, phy_reg); /* clear RHB */
540 phy_reg = get_phy_reg(lynx, 5);
542 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
548 PRINT(KERN_INFO, lynx->id, "resetting bus (short bus reset, no force_root) on request");
550 lynx->selfid_size = -1;
551 lynx->phy_reg0 = -1;
552 set_phy_reg(lynx, 5, phy_reg); /* set ISBR */
555 PRINT(KERN_INFO, lynx->id, "cannot do short bus reset, because of old phy");
559 phy_reg = get_phy_reg(lynx, 1);
561 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
568 PRINT(KERN_INFO, lynx->id, "resetting bus (long bus reset, no force_root) on request");
570 lynx->selfid_size = -1;
571 lynx->phy_reg0 = -1;
572 set_phy_reg(lynx, 1, phy_reg); /* clear RHB, set IBR */
575 if (lynx->phyic.reg_1394a) {
576 phy_reg = get_phy_reg(lynx, 1);
578 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
584 set_phy_reg(lynx, 1, phy_reg); /* set RHB */
587 phy_reg = get_phy_reg(lynx, 5);
589 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
595 PRINT(KERN_INFO, lynx->id, "resetting bus (short bus reset, force_root set) on request");
597 lynx->selfid_size = -1;
598 lynx->phy_reg0 = -1;
599 set_phy_reg(lynx, 5, phy_reg); /* set ISBR */
602 PRINT(KERN_INFO, lynx->id, "cannot do short bus reset, because of old phy");
606 phy_reg = get_phy_reg(lynx, 1);
608 PRINT(KERN_ERR, lynx->id, "cannot reset bus, because read phy reg failed");
614 PRINT(KERN_INFO, lynx->id, "resetting bus (long bus reset, force_root set) on request");
616 lynx->selfid_size = -1;
617 lynx->phy_reg0 = -1;
618 set_phy_reg(lynx, 1, phy_reg); /* set IBR and RHB */
621 PRINT(KERN_ERR, lynx->id, "unknown argument for reset_bus command %d", arg);
628 retval = reg_read(lynx, CYCLE_TIMER);
632 reg_write(lynx, CYCLE_TIMER, arg);
636 reg_write(lynx, LINK_ID,
637 (arg << 22) | (reg_read(lynx, LINK_ID) & 0x003f0000));
642 reg_set_bits(lynx, LINK_CONTROL,
645 reg_clear_bits(lynx, LINK_CONTROL,
651 spin_lock_irqsave(&lynx->async.queue_lock, flags);
653 reg_write(lynx, DMA_CHAN_CTRL(CHANNEL_ASYNC_SEND), 0);
654 list_splice_init(&lynx->async.queue, &packet_list);
656 if (list_empty(&lynx->async.pcl_queue)) {
657 spin_unlock_irqrestore(&lynx->async.queue_lock, flags);
658 PRINTD(KERN_DEBUG, lynx->id, "no async packet in PCL to cancel");
663 PRINT(KERN_INFO, lynx->id, "cancelling async packet, that was already in PCL");
665 get_pcl(lynx, lynx->async.pcl, &pcl);
667 packet = driver_packet(lynx->async.pcl_queue.next);
670 pci_unmap_single(lynx->dev, lynx->async.header_dma,
673 pci_unmap_single(lynx->dev, lynx->async.data_dma,
677 spin_unlock_irqrestore(&lynx->async.queue_lock, flags);
682 PRINTD(KERN_INFO, lynx->id, "special ack %d", ack);
688 PRINT(KERN_INFO, lynx->id, "async packet was not completed");
702 PRINT(KERN_ERR, lynx->id, "unknown devctl command %d", cmd);
722 struct ti_lynx *lynx = (struct ti_lynx *)dev_id;
723 struct hpsb_host *host = lynx->host;
727 linkint = reg_read(lynx, LINK_INT_STATUS);
728 intmask = reg_read(lynx, PCI_INT_STATUS);
733 PRINTD(KERN_DEBUG, lynx->id, "interrupt: 0x%08x / 0x%08x", intmask,
736 reg_write(lynx, LINK_INT_STATUS, linkint);
737 reg_write(lynx, PCI_INT_STATUS, intmask);
741 PRINT(KERN_INFO, lynx->id, "PHY timeout occurred");
744 PRINT(KERN_INFO, lynx->id, "bus reset interrupt");
745 lynx->selfid_size = -1;
746 lynx->phy_reg0 = -1;
753 spin_lock(&lynx->phy_reg_lock);
754 reg = reg_read(lynx, LINK_PHY);
755 spin_unlock(&lynx->phy_reg_lock);
758 PRINT(KERN_INFO, lynx->id,
761 PRINT(KERN_INFO, lynx->id,
765 lynx->phy_reg0 = reg & 0xff;
766 handle_selfid(lynx, host);
770 PRINT(KERN_INFO, lynx->id, "isochronous transmitter stuck");
773 PRINT(KERN_INFO, lynx->id, "asynchronous transmitter stuck");
776 PRINT(KERN_INFO, lynx->id, "sent reject");
779 PRINT(KERN_INFO, lynx->id, "invalid transaction code");
784 reg_write(lynx, FIFO_CONTROL,
786 PRINT(KERN_INFO, lynx->id, "GRF overflow");
789 PRINT(KERN_INFO, lynx->id, "ITF underflow");
792 PRINT(KERN_INFO, lynx->id, "ATF underflow");
797 PRINTD(KERN_DEBUG, lynx->id, "iso receive");
799 spin_lock(&lynx->iso_rcv.lock);
801 lynx->iso_rcv.stat[lynx->iso_rcv.next] =
802 reg_read(lynx, DMA_CHAN_STAT(CHANNEL_ISO_RCV));
804 lynx->iso_rcv.used++;
805 lynx->iso_rcv.next = (lynx->iso_rcv.next + 1) % NUM_ISORCV_PCL;
807 if ((lynx->iso_rcv.next == lynx->iso_rcv.last)
808 || !lynx->iso_rcv.chan_count) {
809 PRINTD(KERN_DEBUG, lynx->id, "stopped");
810 reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV), 0);
813 run_sub_pcl(lynx, lynx->iso_rcv.pcl_start, lynx->iso_rcv.next,
816 spin_unlock(&lynx->iso_rcv.lock);
818 tasklet_schedule(&lynx->iso_rcv.tq);
822 PRINTD(KERN_DEBUG, lynx->id, "async sent");
823 spin_lock(&lynx->async.queue_lock);
825 if (list_empty(&lynx->async.pcl_queue)) {
826 spin_unlock(&lynx->async.queue_lock);
827 PRINT(KERN_WARNING, lynx->id, "async dma halted, but no queued packet (maybe it was cancelled)");
833 get_pcl(lynx, lynx->async.pcl, &pcl);
835 packet = driver_packet(lynx->async.pcl_queue.next);
838 pci_unmap_single(lynx->dev, lynx->async.header_dma,
841 pci_unmap_single(lynx->dev, lynx->async.data_dma,
845 if (!list_empty(&lynx->async.queue)) {
846 send_next(lynx, hpsb_async);
849 spin_unlock(&lynx->async.queue_lock);
854 PRINTD(KERN_INFO, lynx->id, "special ack %d", ack);
860 PRINT(KERN_INFO, lynx->id, "async packet was not completed");
868 PRINTD(KERN_DEBUG, lynx->id, "iso sent");
869 spin_lock(&lynx->iso_send.queue_lock);
871 if (list_empty(&lynx->iso_send.pcl_queue)) {
872 spin_unlock(&lynx->iso_send.queue_lock);
873 PRINT(KERN_ERR, lynx->id, "iso send dma halted, but no queued packet");
879 get_pcl(lynx, lynx->iso_send.pcl, &pcl);
881 packet = driver_packet(lynx->iso_send.pcl_queue.next);
884 pci_unmap_single(lynx->dev, lynx->iso_send.header_dma,
887 pci_unmap_single(lynx->dev, lynx->iso_send.data_dma,
890 spin_unlock(&lynx->iso_send.queue_lock);
895 PRINTD(KERN_INFO, lynx->id, "special ack %d", ack);
901 PRINT(KERN_INFO, lynx->id, "iso send packet was not completed");
911 int stat = reg_read(lynx, DMA_CHAN_STAT(CHANNEL_ASYNC_RCV));
913 PRINTD(KERN_DEBUG, lynx->id, "received packet size %d",
917 lynx->selfid_size = stat & 0x1fff;
918 handle_selfid(lynx, host);
920 quadlet_t *q_data = lynx->rcv_page;
928 run_pcl(lynx, lynx->rcv_pcl_start, CHANNEL_ASYNC_RCV);
935 static void iso_rcv_bh(struct ti_lynx *lynx)
941 spin_lock_irqsave(&lynx->iso_rcv.lock, flags);
943 while (lynx->iso_rcv.used) {
944 idx = lynx->iso_rcv.last;
945 spin_unlock_irqrestore(&lynx->iso_rcv.lock, flags);
947 data = lynx->iso_rcv.page[idx / ISORCV_PER_PAGE]
950 if ((*data >> 16) + 4 != (lynx->iso_rcv.stat[idx] & 0x1fff)) {
951 PRINT(KERN_ERR, lynx->id,
953 lynx->iso_rcv.stat[idx]);
956 if (lynx->iso_rcv.stat[idx]
958 PRINT(KERN_INFO, lynx->id,
961 hpsb_packet_received(lynx->host, data,
962 lynx->iso_rcv.stat[idx] & 0x1fff,
966 spin_lock_irqsave(&lynx->iso_rcv.lock, flags);
967 lynx->iso_rcv.last = (idx + 1) % NUM_ISORCV_PCL;
968 lynx->iso_rcv.used--;
971 if (lynx->iso_rcv.chan_count) {
972 reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV),
975 spin_unlock_irqrestore(&lynx->iso_rcv.lock, flags);
981 struct ti_lynx *lynx;
985 lynx = pci_get_drvdata(dev);
986 if (!lynx) return;
989 lynx_dev = get_device(&lynx->host->device);
991 switch (lynx->state) {
993 reg_write(lynx, PCI_INT_ENABLE, 0);
994 hpsb_remove_host(lynx->host);
996 reg_write(lynx, PCI_INT_ENABLE, 0);
997 free_irq(lynx->dev->irq, lynx);
1000 if (lynx->phyic.reg_1394a)
1001 set_phy_reg(lynx, 4, ~0xc0 & get_phy_reg(lynx, 4));
1004 lynx_devctl(lynx->host, RESET_BUS, LONG_RESET_NO_FORCE_ROOT);
1007 reg_set_bits(lynx, MISC_CONTROL, MISC_CONTROL_SWRESET);
1009 reg_write(lynx, DMA0_CHAN_CTRL, 0);
1010 iounmap(lynx->registers);
1011 iounmap(lynx->local_rom);
1012 iounmap(lynx->local_ram);
1013 iounmap(lynx->aux_port);
1016 if (lynx->iso_rcv.page[i]) {
1017 pci_free_consistent(lynx->dev, PAGE_SIZE,
1018 lynx->iso_rcv.page[i],
1019 lynx->iso_rcv.page_dma[i]);
1022 pci_free_consistent(lynx->dev, PAGE_SIZE, lynx->rcv_page,
1023 lynx->rcv_page_dma);
1026 pci_free_consistent(lynx->dev, LOCALRAM_SIZE, lynx->pcl_mem,
1027 lynx->pcl_mem_dma);
1033 tasklet_kill(&lynx->iso_rcv.tq);
1051 struct ti_lynx *lynx; /* shortcut to currently handled device */
1070 lynx = host->hostdata;
1071 lynx->id = card_id++;
1072 lynx->dev = dev;
1073 lynx->state = clear;
1074 lynx->host = host;
1076 pci_set_drvdata(dev, lynx);
1078 spin_lock_init(&lynx->lock);
1079 spin_lock_init(&lynx->phy_reg_lock);
1081 lynx->pcl_mem = pci_alloc_consistent(dev, LOCALRAM_SIZE,
1082 &lynx->pcl_mem_dma);
1084 if (lynx->pcl_mem != NULL) {
1085 lynx->state = have_pcl_mem;
1086 PRINT(KERN_INFO, lynx->id,
1088 lynx->pcl_mem);
1093 lynx->rcv_page = pci_alloc_consistent(dev, PAGE_SIZE,
1094 &lynx->rcv_page_dma);
1095 if (lynx->rcv_page == NULL) {
1098 lynx->state = have_1394_buffers;
1101 lynx->iso_rcv.page[i] =
1103 &lynx->iso_rcv.page_dma[i]);
1104 if (lynx->iso_rcv.page[i] == NULL) {
1109 lynx->registers = ioremap_nocache(pci_resource_start(dev,0),
1111 lynx->local_ram = ioremap(pci_resource_start(dev,1), PCILYNX_MAX_MEMORY);
1112 lynx->aux_port = ioremap(pci_resource_start(dev,2), PCILYNX_MAX_MEMORY);
1113 lynx->local_rom = ioremap(pci_resource_start(dev,PCI_ROM_RESOURCE),
1115 lynx->state = have_iomappings;
1117 if (lynx->registers == NULL) {
1121 reg_set_bits(lynx, MISC_CONTROL, MISC_CONTROL_SWRESET);
1123 reg_write(lynx, DMA0_CHAN_CTRL, 0);
1128 PCILYNX_DRIVER_NAME, lynx)) {
1129 PRINT(KERN_INFO, lynx->id, "allocated interrupt %s", irq_buf);
1130 lynx->state = have_intr;
1137 lynx->rcv_pcl = alloc_pcl(lynx);
1138 lynx->rcv_pcl_start = alloc_pcl(lynx);
1139 lynx->async.pcl = alloc_pcl(lynx);
1140 lynx->async.pcl_start = alloc_pcl(lynx);
1141 lynx->iso_send.pcl = alloc_pcl(lynx);
1142 lynx->iso_send.pcl_start = alloc_pcl(lynx);
1145 lynx->iso_rcv.pcl[i] = alloc_pcl(lynx);
1147 lynx->iso_rcv.pcl_start = alloc_pcl(lynx);
1151 reg_write(lynx, PCI_INT_ENABLE, PCI_INT_DMA_ALL);
1153 tasklet_init(&lynx->iso_rcv.tq, (void (*)(unsigned long))iso_rcv_bh,
1154 (unsigned long)lynx);
1156 spin_lock_init(&lynx->iso_rcv.lock);
1158 spin_lock_init(&lynx->async.queue_lock);
1159 lynx->async.channel = CHANNEL_ASYNC_SEND;
1160 spin_lock_init(&lynx->iso_send.queue_lock);
1161 lynx->iso_send.channel = CHANNEL_ISO_SEND;
1163 PRINT(KERN_INFO, lynx->id, "remapped memory spaces reg 0x%p, rom 0x%p, "
1164 "ram 0x%p, aux 0x%p", lynx->registers, lynx->local_rom,
1165 lynx->local_ram, lynx->aux_port);
1168 if ((get_phy_reg(lynx, 2) & 0xe0) == 0xe0) {
1169 lynx->phyic.reg_1394a = 1;
1170 PRINT(KERN_INFO, lynx->id,
1172 lynx->phyic.vendor = get_phy_vendorid(lynx);
1173 lynx->phyic.product = get_phy_productid(lynx);
1175 lynx->phyic.reg_1394a = 0;
1176 PRINT(KERN_INFO, lynx->id, "found old 1394 PHY");
1179 lynx->selfid_size = -1;
1180 lynx->phy_reg0 = -1;
1182 INIT_LIST_HEAD(&lynx->async.queue);
1183 INIT_LIST_HEAD(&lynx->async.pcl_queue);
1184 INIT_LIST_HEAD(&lynx->iso_send.queue);
1185 INIT_LIST_HEAD(&lynx->iso_send.pcl_queue);
1187 pcl.next = pcl_bus(lynx, lynx->rcv_pcl);
1188 put_pcl(lynx, lynx->rcv_pcl_start, &pcl);
1199 pcl.buffer[0].pointer = lynx->rcv_page_dma;
1200 pcl.buffer[1].pointer = lynx->rcv_page_dma + 16;
1201 put_pcl(lynx, lynx->rcv_pcl, &pcl);
1203 pcl.next = pcl_bus(lynx, lynx->async.pcl);
1204 pcl.async_error_next = pcl_bus(lynx, lynx->async.pcl);
1205 put_pcl(lynx, lynx->async.pcl_start, &pcl);
1207 pcl.next = pcl_bus(lynx, lynx->iso_send.pcl);
1209 put_pcl(lynx, lynx->iso_send.pcl_start, &pcl);
1223 pcl.buffer[0].pointer = lynx->iso_rcv.page_dma[page]
1226 put_pcl(lynx, lynx->iso_rcv.pcl[i], &pcl);
1231 pcli[i] = pcl_bus(lynx, lynx->iso_rcv.pcl[i]);
1233 put_pcl(lynx, lynx->iso_rcv.pcl_start, &pcl);
1236 reg_write(lynx, FIFO_SIZES, 0x003030a0);
1238 reg_write(lynx, DMA_GLOBAL_REGISTER, 0x2<<24);
1241 i = reg_read(lynx, PCI_LATENCY_CACHELINE) & 0xff;
1243 reg_write(lynx, FIFO_XMIT_THRESHOLD, (i << 8) | i);
1245 reg_set_bits(lynx, PCI_INT_ENABLE, PCI_INT_1394);
1247 reg_write(lynx, LINK_INT_ENABLE, LINK_INT_PHY_TIMEOUT
1254 reg_write(lynx, DMA_WORD0_CMP_VALUE(CHANNEL_ASYNC_RCV), 0);
1255 reg_write(lynx, DMA_WORD0_CMP_ENABLE(CHANNEL_ASYNC_RCV), 0xa<<4);
1256 reg_write(lynx, DMA_WORD1_CMP_VALUE(CHANNEL_ASYNC_RCV), 0);
1257 reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ASYNC_RCV),
1262 run_pcl(lynx, lynx->rcv_pcl_start, CHANNEL_ASYNC_RCV);
1264 reg_write(lynx, DMA_WORD0_CMP_VALUE(CHANNEL_ISO_RCV), 0);
1265 reg_write(lynx, DMA_WORD0_CMP_ENABLE(CHANNEL_ISO_RCV), 0x9<<4);
1266 reg_write(lynx, DMA_WORD1_CMP_VALUE(CHANNEL_ISO_RCV), 0);
1267 reg_write(lynx, DMA_WORD1_CMP_ENABLE(CHANNEL_ISO_RCV), 0);
1269 run_sub_pcl(lynx, lynx->iso_rcv.pcl_start, 0, CHANNEL_ISO_RCV);
1271 reg_write(lynx, LINK_CONTROL, LINK_CONTROL_RCV_CMP_VALID
1276 if (!lynx->phyic.reg_1394a) {
1278 reg_set_bits(lynx, GPIO_CTRL_A, 0x1);
1279 reg_write(lynx, GPIO_DATA_BASE + 0x3c, 0x1);
1286 i = get_phy_reg(lynx, 4);
1292 if (i != -1) set_phy_reg(lynx, 4, i);
1308 i2c_adapter_data.data = lynx;
1311 PRINTD(KERN_DEBUG, lynx->id,"original eeprom control: %d",
1312 reg_read(lynx, SERIAL_EEPROM_CONTROL));
1315 lynx->i2c_driven_state = 0x00000070;
1316 reg_write(lynx, SERIAL_EEPROM_CONTROL, lynx->i2c_driven_state);
1329 { 0x50, I2C_M_RD, 20, (unsigned char*) lynx->bus_info_block }
1335 PRINT(KERN_ERR, lynx->id, "unable to read bus info block from i2c");
1337 PRINT(KERN_INFO, lynx->id, "got bus info block from serial eeprom");
1340 PRINTD(KERN_DEBUG, lynx->id, "Businfo block quadlet %i: %08x",
1341 i, be32_to_cpu(lynx->bus_info_block[i]));
1344 if (((be32_to_cpu(lynx->bus_info_block[0]) & 0xffff0000) == 0x04040000) &&
1345 (lynx->bus_info_block[1] == IEEE1394_BUSID_MAGIC))
1347 PRINT(KERN_DEBUG, lynx->id, "read a valid bus info block from");
1361 host->csr.guid_hi = be32_to_cpu(lynx->bus_info_block[3]);
1362 host->csr.guid_lo = be32_to_cpu(lynx->bus_info_block[4]);
1363 host->csr.cyc_clk_acc = (be32_to_cpu(lynx->bus_info_block[2]) >> 16) & 0xff;
1364 host->csr.max_rec = (be32_to_cpu(lynx->bus_info_block[2]) >> 12) & 0xf;
1365 if (!lynx->phyic.reg_1394a)
1366 host->csr.lnk_spd = (get_phy_reg(lynx, 2) & 0xc0) >> 6;
1368 host->csr.lnk_spd = be32_to_cpu(lynx->bus_info_block[2]) & 0x7;
1375 lynx->state = is_host;