开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ohci1394.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：68k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ohci1394.c：源码内容
  1. /*
  2.  * ohci1394.c - driver for OHCI 1394 boards
  3.  * Copyright (C)1999,2000 Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>
  4.  *                        Gord Peters <GordPeters@smarttech.com>
  5.  *              2001      Ben Collins <bcollins@debian.org>
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; if not, write to the Free Software Foundation,
  19.  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20.  */
  22. /*
  23.  * Things known to be working:
  24.  * . Async Request Transmit
  25.  * . Async Response Receive
  26.  * . Async Request Receive
  27.  * . Async Response Transmit
  28.  * . Iso Receive
  29.  * . DMA mmap for iso receive
  30.  * . Config ROM generation
  31.  *
  32.  * Things implemented, but still in test phase:
  33.  * . Iso Transmit
  34.  * 
  35.  * Things not implemented:
  36.  * . Async Stream Packets
  37.  * . DMA error recovery
  38.  *
  39.  * Known bugs:
  40.  * . Apple PowerBook detected but not working yet (still true?)
  41.  */
  43. /* 
  44.  * Acknowledgments:
  45.  *
  46.  * Adam J Richter <adam@yggdrasil.com>
  47.  *  . Use of pci_class to find device
  48.  *
  49.  * Andreas Tobler <toa@pop.agri.ch>
  50.  *  . Updated proc_fs calls
  51.  *
  52.  * Emilie Chung <emilie.chung@axis.com>
  53.  *  . Tip on Async Request Filter
  54.  *
  55.  * Pascal Drolet <pascal.drolet@informission.ca>
  56.  *  . Various tips for optimization and functionnalities
  57.  *
  58.  * Robert Ficklin <rficklin@westengineering.com>
  59.  *  . Loop in irq_handler
  60.  *
  61.  * James Goodwin <jamesg@Filanet.com>
  62.  *  . Various tips on initialization, self-id reception, etc.
  63.  *
  64.  * Albrecht Dress <ad@mpifr-bonn.mpg.de>
  65.  *  . Apple PowerBook detection
  66.  *
  67.  * Daniel Kobras <daniel.kobras@student.uni-tuebingen.de>
  68.  *  . Reset the board properly before leaving + misc cleanups
  69.  *
  70.  * Leon van Stuivenberg <leonvs@iae.nl>
  71.  *  . Bug fixes
  72.  *
  73.  * Ben Collins <bcollins@debian.org>
  74.  *  . Working big-endian support
  75.  *  . Updated to 2.4.x module scheme (PCI aswell)
  76.  *  . Removed procfs support since it trashes random mem
  77.  *  . Config ROM generation
  78.  */
  80. #include <linux/config.h>
  81. #include <linux/kernel.h>
  82. #include <linux/list.h>
  83. #include <linux/slab.h>
  84. #include <linux/interrupt.h>
  85. #include <linux/wait.h>
  86. #include <linux/errno.h>
  87. #include <linux/module.h>
  88. #include <linux/pci.h>
  89. #include <linux/fs.h>
  90. #include <linux/poll.h>
  91. #include <asm/byteorder.h>
  92. #include <asm/atomic.h>
  93. #include <asm/io.h>
  94. #include <asm/uaccess.h>
  95. #include <linux/tqueue.h>
  96. #include <linux/delay.h>
  97. #include <linux/spinlock.h>
  99. #include <asm/pgtable.h>
  100. #include <asm/page.h>
  101. #include <linux/sched.h>
  102. #include <asm/segment.h>
  103. #include <linux/types.h>
  104. #include <linux/wrapper.h>
  105. #include <linux/vmalloc.h>
  106. #include <linux/init.h>
  108. #ifdef CONFIG_ALL_PPC
  109. #include <asm/machdep.h>
  110. #include <asm/pmac_feature.h>
  111. #include <asm/prom.h>
  112. #include <asm/pci-bridge.h>
  113. #endif
  115. #include "ieee1394.h"
  116. #include "ieee1394_types.h"
  117. #include "hosts.h"
  118. #include "ieee1394_core.h"
  119. #include "highlevel.h"
  120. #include "ohci1394.h"
  122. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  123. #define OHCI1394_DEBUG
  124. #endif
  126. #ifdef DBGMSG
  127. #undef DBGMSG
  128. #endif
  130. #ifdef OHCI1394_DEBUG
  131. #define DBGMSG(card, fmt, args...) 
  132. printk(KERN_INFO "%s_%d: " fmt "n" , OHCI1394_DRIVER_NAME, card , ## args)
  133. #else
  134. #define DBGMSG(card, fmt, args...)
  135. #endif
  137. #ifdef CONFIG_IEEE1394_OHCI_DMA_DEBUG
  138. #define OHCI_DMA_ALLOC(fmt, args...) 
  139. HPSB_ERR("%s("__FUNCTION__")alloc(%d): "fmt, OHCI1394_DRIVER_NAME, 
  140. ++global_outstanding_dmas, ## args)
  141. #define OHCI_DMA_FREE(fmt, args...) 
  142. HPSB_ERR("%s("__FUNCTION__")free(%d): "fmt, OHCI1394_DRIVER_NAME, 
  143. --global_outstanding_dmas, ## args)
  144. u32 global_outstanding_dmas = 0;
  145. #else
  146. #define OHCI_DMA_ALLOC(fmt, args...)
  147. #define OHCI_DMA_FREE(fmt, args...)
  148. #endif
  150. /* print general (card independent) information */
  151. #define PRINT_G(level, fmt, args...) 
  152. printk(level "%s: " fmt "n" , OHCI1394_DRIVER_NAME , ## args)
  154. /* print card specific information */
  155. #define PRINT(level, card, fmt, args...) 
  156. printk(level "%s_%d: " fmt "n" , OHCI1394_DRIVER_NAME, card , ## args)
  158. #define PCI_CLASS_FIREWIRE_OHCI     ((PCI_CLASS_SERIAL_FIREWIRE << 8) | 0x10)
  160. static struct pci_device_id ohci1394_pci_tbl[] __devinitdata = {
  161. {
  162. class:  PCI_CLASS_FIREWIRE_OHCI,
  163. class_mask:  0x00ffffff,
  164. vendor: PCI_ANY_ID,
  165. device: PCI_ANY_ID,
  166. subvendor: PCI_ANY_ID,
  167. subdevice: PCI_ANY_ID,
  168. },
  169. { 0, },
  170. };
  171. MODULE_DEVICE_TABLE(pci, ohci1394_pci_tbl);
  173. static char version[] __devinitdata =
  174. "$Revision: 1.80 $ Ben Collins <bcollins@debian.org>";
  176. /* Module Parameters */
  177. MODULE_PARM(attempt_root,"i");
  178. MODULE_PARM_DESC(attempt_root, "Attempt to make the host root.");
  179. static int attempt_root = 0;
  181. static unsigned int card_id_counter = 0;
  183. static void dma_trm_tasklet(unsigned long data);
  184. static void remove_card(struct ti_ohci *ohci);
  185. static void dma_trm_reset(struct dma_trm_ctx *d);
  187. #ifndef __LITTLE_ENDIAN
  188. /* Swap a series of quads inplace. */
  189. static __inline__ void block_swab32(quadlet_t *data, size_t size) {
  190. while (size--)
  191. data[size] = swab32(data[size]);
  192. }
  194. static unsigned hdr_sizes[] = 
  195. {
  196. 3, /* TCODE_WRITEQ */
  197. 4, /* TCODE_WRITEB */
  198. 3, /* TCODE_WRITE_RESPONSE */
  199. 0, /* ??? */
  200. 3, /* TCODE_READQ */
  201. 4, /* TCODE_READB */
  202. 3, /* TCODE_READQ_RESPONSE */
  203. 4, /* TCODE_READB_RESPONSE */
  204. 1, /* TCODE_CYCLE_START (???) */
  205. 4, /* TCODE_LOCK_REQUEST */
  206. 2, /* TCODE_ISO_DATA */
  207. 4, /* TCODE_LOCK_RESPONSE */
  208. };
  210. /* Swap headers */
  211. static inline void packet_swab(quadlet_t *data, int tcode, int len)
  212. {
  213. if (tcode > TCODE_LOCK_RESPONSE || hdr_sizes[tcode] == 0)
  214. return;
  215. block_swab32(data, hdr_sizes[tcode]);
  216. }
  217. #else
  218. /* Don't waste cycles on same sex byte swaps */
  219. #define packet_swab(w,x,y)
  220. #define block_swab32(x,y)
  221. #endif /* !LITTLE_ENDIAN */
  223. /***********************************
  224.  * IEEE-1394 functionality section *
  225.  ***********************************/
  227. static u8 get_phy_reg(struct ti_ohci *ohci, u8 addr) 
  228. {
  229. int i;
  230. unsigned long flags;
  231. quadlet_t r;
  233. spin_lock_irqsave (&ohci->phy_reg_lock, flags);
  235. reg_write(ohci, OHCI1394_PhyControl, (((u16)addr << 8) & 0x00000f00) | 0x00008000);
  237. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  238. if (reg_read(ohci, OHCI1394_PhyControl) & 0x80000000)
  239. break;
  241. mdelay(1);
  242. }
  244. r = reg_read(ohci, OHCI1394_PhyControl);
  246. if (i >= OHCI_LOOP_COUNT)
  247. PRINT (KERN_ERR, ohci->id, "Get PHY Reg timeout [0x%08x/0x%08x/%d]",
  248.        r, r & 0x80000000, i);
  249.   
  250. spin_unlock_irqrestore (&ohci->phy_reg_lock, flags);
  251.      
  252. return (r & 0x00ff0000) >> 16;
  253. }
  255. static void set_phy_reg(struct ti_ohci *ohci, u8 addr, u8 data)
  256. {
  257. int i;
  258. unsigned long flags;
  259. u32 r = 0;
  261. spin_lock_irqsave (&ohci->phy_reg_lock, flags);
  263. reg_write(ohci, OHCI1394_PhyControl, 0x00004000 | (((u16)addr << 8) & 0x00000f00) | data);
  265. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  266. r = reg_read(ohci, OHCI1394_PhyControl);
  267. if (!(r & 0x00004000))
  268. break;
  270. mdelay(1);
  271. }
  273. if (i == OHCI_LOOP_COUNT)
  274. PRINT (KERN_ERR, ohci->id, "Set PHY Reg timeout [0x%08x/0x%08x/%d]",
  275.        r, r & 0x00004000, i);
  277. spin_unlock_irqrestore (&ohci->phy_reg_lock, flags);
  279. return;
  280. }
  282. /* Or's our value into the current value */
  283. static void set_phy_reg_mask(struct ti_ohci *ohci, u8 addr, u8 data)
  284. {
  285. u8 old;
  287. old = get_phy_reg (ohci, addr);
  288. old |= data;
  289. set_phy_reg (ohci, addr, old);
  291. return;
  292. }
  294. static void handle_selfid(struct ti_ohci *ohci, struct hpsb_host *host,
  295. int phyid, int isroot)
  296. {
  297. quadlet_t *q = ohci->selfid_buf_cpu;
  298. quadlet_t self_id_count=reg_read(ohci, OHCI1394_SelfIDCount);
  299. size_t size;
  300. quadlet_t q0, q1;
  302. mdelay(10);
  304. /* Check status of self-id reception */
  306. if (ohci->selfid_swap)
  307. q0 = le32_to_cpu(q[0]);
  308. else
  309. q0 = q[0];
  311. if ((self_id_count & 0x80000000) || 
  312.     ((self_id_count & 0x00FF0000) != (q0 & 0x00FF0000))) {
  313. PRINT(KERN_ERR, ohci->id, 
  314.       "Error in reception of SelfID packets [0x%08x/0x%08x]",
  315.       self_id_count, q0);
  317. /* Tip by James Goodwin <jamesg@Filanet.com>:
  318.  * We had an error, generate another bus reset in response.  */
  319. if (ohci->self_id_errors<OHCI1394_MAX_SELF_ID_ERRORS) {
  320. set_phy_reg_mask (ohci, 1, 0x40);
  321. ohci->self_id_errors++;
  322. } else {
  323. PRINT(KERN_ERR, ohci->id, 
  324.       "Too many errors on SelfID error reception, giving up!");
  325. }
  326. return;
  327. }
  329. size = ((self_id_count & 0x00001FFC) >> 2) - 1;
  330. q++;
  332. while (size > 0) {
  333. if (ohci->selfid_swap) {
  334. q0 = le32_to_cpu(q[0]);
  335. q1 = le32_to_cpu(q[1]);
  336. } else {
  337. q0 = q[0];
  338. q1 = q[1];
  339. }
  341. if (q0 == ~q1) {
  342. DBGMSG (ohci->id, "SelfID packet 0x%x received", q0);
  343. hpsb_selfid_received(host, cpu_to_be32(q0));
  344. if (((q0 & 0x3f000000) >> 24) == phyid)
  345. DBGMSG (ohci->id, "SelfID for this node is 0x%08x", q0);
  346. } else {
  347. PRINT(KERN_ERR, ohci->id,
  348.       "SelfID is inconsistent [0x%08x/0x%08x]", q0, q1);
  349. }
  350. q += 2;
  351. size -= 2;
  352. }
  354. DBGMSG(ohci->id, "SelfID complete");
  356. hpsb_selfid_complete(host, phyid, isroot);
  358. return;
  359. }
  361. static int ohci_soft_reset(struct ti_ohci *ohci) {
  362. int i;
  364. reg_write(ohci, OHCI1394_HCControlSet, 0x00010000);
  365.   
  366. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  367. if (reg_read(ohci, OHCI1394_HCControlSet) & 0x00010000)
  368. break;
  369. mdelay(1);
  370. }
  372. DBGMSG (ohci->id, "Soft reset finished");
  374. return 0;
  375. }
  377. static int run_context(struct ti_ohci *ohci, int reg, char *msg)
  378. {
  379. u32 nodeId;
  381. /* check that the node id is valid */
  382. nodeId = reg_read(ohci, OHCI1394_NodeID);
  383. if (!(nodeId&0x80000000)) {
  384. PRINT(KERN_ERR, ohci->id, 
  385.       "Running dma failed because Node ID is not valid");
  386. return -1;
  387. }
  389. /* check that the node number != 63 */
  390. if ((nodeId&0x3f)==63) {
  391. PRINT(KERN_ERR, ohci->id, 
  392.       "Running dma failed because Node ID == 63");
  393. return -1;
  394. }
  396. /* Run the dma context */
  397. reg_write(ohci, reg, 0x8000);
  399. if (msg) PRINT(KERN_DEBUG, ohci->id, "%s", msg);
  401. return 0;
  402. }
  404. /* Generate the dma receive prgs and start the context */
  405. static void initialize_dma_rcv_ctx(struct dma_rcv_ctx *d, int generate_irq)
  406. {
  407. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  408. int i;
  410. ohci1394_stop_context(ohci, d->ctrlClear, NULL);
  412. for (i=0; i<d->num_desc; i++) {
  413. u32 c;
  415. c = DMA_CTL_INPUT_MORE | DMA_CTL_UPDATE |
  416. DMA_CTL_BRANCH;
  417. if (generate_irq)
  418. c |= DMA_CTL_IRQ;
  420. d->prg_cpu[i]->control = cpu_to_le32(c | d->buf_size);
  422. /* End of descriptor list? */
  423. if (i + 1 < d->num_desc) {
  424. d->prg_cpu[i]->branchAddress =
  425. cpu_to_le32((d->prg_bus[i+1] & 0xfffffff0) | 0x1);
  426. } else {
  427. d->prg_cpu[i]->branchAddress =
  428. cpu_to_le32((d->prg_bus[0] & 0xfffffff0));
  429. }
  431. d->prg_cpu[i]->address = cpu_to_le32(d->buf_bus[i]);
  432. d->prg_cpu[i]->status = cpu_to_le32(d->buf_size);
  433. }
  435.         d->buf_ind = 0;
  436.         d->buf_offset = 0;
  438. /* Tell the controller where the first AR program is */
  439. reg_write(ohci, d->cmdPtr, d->prg_bus[0] | 0x1);
  441. /* Run AR context */
  442. reg_write(ohci, d->ctrlSet, 0x00008000);
  444. DBGMSG(ohci->id, "Receive DMA ctx=%d initialized", d->ctx);
  445. }
  447. /* Initialize the dma transmit context */
  448. static void initialize_dma_trm_ctx(struct dma_trm_ctx *d)
  449. {
  450. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  452. /* Stop the context */
  453. ohci1394_stop_context(ohci, d->ctrlClear, NULL);
  455.         d->prg_ind = 0;
  456. d->sent_ind = 0;
  457. d->free_prgs = d->num_desc;
  458.         d->branchAddrPtr = NULL;
  459. d->fifo_first = NULL;
  460. d->fifo_last = NULL;
  461. d->pending_first = NULL;
  462. d->pending_last = NULL;
  464. DBGMSG(ohci->id, "Transmit DMA ctx=%d initialized", d->ctx);
  465. }
  467. /* Count the number of available iso contexts */
  468. static int get_nb_iso_ctx(struct ti_ohci *ohci, int reg)
  469. {
  470. int i,ctx=0;
  471. u32 tmp;
  473. reg_write(ohci, reg, 0xffffffff);
  474. tmp = reg_read(ohci, reg);
  476. DBGMSG(ohci->id,"Iso contexts reg: %08x implemented: %08x", reg, tmp);
  478. /* Count the number of contexts */
  479. for(i=0; i<32; i++) {
  480.      if(tmp & 1) ctx++;
  481. tmp >>= 1;
  482. }
  483. return ctx;
  484. }
  486. static void ohci_init_config_rom(struct ti_ohci *ohci);
  488. /* Global initialization */
  489. static int ohci_initialize(struct hpsb_host *host)
  490. {
  491. struct ti_ohci *ohci=host->hostdata;
  492. int retval, i;
  493. quadlet_t buf;
  495. spin_lock_init(&ohci->phy_reg_lock);
  496. spin_lock_init(&ohci->event_lock);
  497.   
  498. /* Soft reset */
  499. if ((retval = ohci_soft_reset(ohci)) < 0)
  500. return retval;
  502. /* Put some defaults to these undefined bus options */
  503. buf = reg_read(ohci, OHCI1394_BusOptions);
  504. buf |=  0x60000000; /* Enable CMC and ISC */
  505. buf &= ~0x00ff0000; /* XXX: Set cyc_clk_acc to zero for now */
  506. buf &= ~0x98000000; /* Disable PMC, IRMC and BMC */
  507. reg_write(ohci, OHCI1394_BusOptions, buf);
  509. /* Set Link Power Status (LPS) */
  510. reg_write(ohci, OHCI1394_HCControlSet, 0x00080000);
  512. /* After enabling LPS, we need to wait for the connection
  513.  * between phy and link to be established.  This should be
  514.  * signaled by the LPS bit becoming 1, but this happens
  515.  * immediately.  There seems to be no consistent way to wait
  516.  * for this, but 50ms seems to be enough. */
  517. mdelay(50);
  519. /* Set the bus number */
  520. reg_write(ohci, OHCI1394_NodeID, 0x0000ffc0);
  522. /* Enable posted writes */
  523. reg_write(ohci, OHCI1394_HCControlSet, 0x00040000);
  525. /* Clear link control register */
  526. reg_write(ohci, OHCI1394_LinkControlClear, 0xffffffff);
  527.   
  528. /* Enable cycle timer and cycle master */
  529. reg_write(ohci, OHCI1394_LinkControlSet, 0x00300000);
  531. /* Clear interrupt registers */
  532. reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);
  533. reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
  535. /* Set up self-id dma buffer */
  536. reg_write(ohci, OHCI1394_SelfIDBuffer, ohci->selfid_buf_bus);
  538. /* enable self-id dma */
  539. reg_write(ohci, OHCI1394_LinkControlSet, 0x00000200);
  541. /* Set the Config ROM mapping register */
  542. reg_write(ohci, OHCI1394_ConfigROMmap, ohci->csr_config_rom_bus);
  544. /* Initialize the Config ROM */
  545. ohci_init_config_rom(ohci);
  547. /* Now get our max packet size */
  548. ohci->max_packet_size = 
  549. 1<<(((reg_read(ohci, OHCI1394_BusOptions)>>12)&0xf)+1);
  551. /* Don't accept phy packets into AR request context */ 
  552. reg_write(ohci, OHCI1394_LinkControlClear, 0x00000400);
  554. /* Initialize IR dma */
  555. ohci->nb_iso_rcv_ctx = 
  556. get_nb_iso_ctx(ohci, OHCI1394_IsoRecvIntMaskSet);
  557. DBGMSG(ohci->id, "%d iso receive contexts available",
  558.        ohci->nb_iso_rcv_ctx);
  559. for (i=0;i<ohci->nb_iso_rcv_ctx;i++) {
  560. reg_write(ohci, OHCI1394_IsoRcvContextControlClear+32*i,
  561.   0xffffffff);
  562. reg_write(ohci, OHCI1394_IsoRcvContextMatch+32*i, 0);
  563. reg_write(ohci, OHCI1394_IsoRcvCommandPtr+32*i, 0);
  564. }
  566. /* Set bufferFill, isochHeader, multichannel for IR context */
  567. reg_write(ohci, OHCI1394_IsoRcvContextControlSet, 0xd0000000);
  569. /* Set the context match register to match on all tags */
  570. reg_write(ohci, OHCI1394_IsoRcvContextMatch, 0xf0000000);
  572. /* Clear the interrupt mask */
  573. reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 0xffffffff);
  574. reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 0xffffffff);
  576. /* Initialize IT dma */
  577. ohci->nb_iso_xmit_ctx = 
  578. get_nb_iso_ctx(ohci, OHCI1394_IsoXmitIntMaskSet);
  579. DBGMSG(ohci->id, "%d iso transmit contexts available",
  580.        ohci->nb_iso_xmit_ctx);
  581. for (i=0;i<ohci->nb_iso_xmit_ctx;i++) {
  582. reg_write(ohci, OHCI1394_IsoXmitContextControlClear+32*i,
  583.   0xffffffff);
  584. reg_write(ohci, OHCI1394_IsoXmitCommandPtr+32*i, 0);
  585. }
  587. /* Clear the interrupt mask */
  588. reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 0xffffffff);
  589. reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 0xffffffff);
  591. /* Clear the multi channel mask high and low registers */
  592. reg_write(ohci, OHCI1394_IRMultiChanMaskHiClear, 0xffffffff);
  593. reg_write(ohci, OHCI1394_IRMultiChanMaskLoClear, 0xffffffff);
  595. /* Initialize AR dma */
  596. initialize_dma_rcv_ctx(ohci->ar_req_context, 0);
  597. initialize_dma_rcv_ctx(ohci->ar_resp_context, 0);
  599. /* Initialize AT dma */
  600. initialize_dma_trm_ctx(ohci->at_req_context);
  601. initialize_dma_trm_ctx(ohci->at_resp_context);
  603. /* Initialize IR dma */
  604. initialize_dma_rcv_ctx(ohci->ir_context, 1);
  606.         /* Initialize IT dma */
  607.         initialize_dma_trm_ctx(ohci->it_context);
  609. /* Set up isoRecvIntMask to generate interrupts for context 0
  610.    (thanks to Michael Greger for seeing that I forgot this) */
  611. reg_write(ohci, OHCI1394_IsoRecvIntMaskSet, 0x00000001);
  613. /* Set up isoXmitIntMask to generate interrupts for context 0 */
  614. reg_write(ohci, OHCI1394_IsoXmitIntMaskSet, 0x00000001);
  616. /* 
  617.  * Accept AT requests from all nodes. This probably 
  618.  * will have to be controlled from the subsystem
  619.  * on a per node basis.
  620.  */
  621. reg_write(ohci,OHCI1394_AsReqFilterHiSet, 0x80000000);
  623. /* Specify AT retries */
  624. reg_write(ohci, OHCI1394_ATRetries, 
  625.   OHCI1394_MAX_AT_REQ_RETRIES |
  626.   (OHCI1394_MAX_AT_RESP_RETRIES<<4) |
  627.   (OHCI1394_MAX_PHYS_RESP_RETRIES<<8));
  629. /* We don't want hardware swapping */
  630. reg_write(ohci, OHCI1394_HCControlClear, 0x40000000);
  632. /* Enable interrupts */
  633. reg_write(ohci, OHCI1394_IntMaskSet, 
  634.   OHCI1394_masterIntEnable | 
  635.   OHCI1394_busReset | 
  636.   OHCI1394_selfIDComplete |
  637.   OHCI1394_RSPkt |
  638.   OHCI1394_RQPkt |
  639.   OHCI1394_respTxComplete |
  640.   OHCI1394_reqTxComplete |
  641.   OHCI1394_isochRx |
  642.   OHCI1394_isochTx |
  643.   OHCI1394_unrecoverableError
  644. );
  646. /* Enable link */
  647. reg_write(ohci, OHCI1394_HCControlSet, 0x00020000);
  649. buf = reg_read(ohci, OHCI1394_Version);
  650. PRINT(KERN_INFO, ohci->id, "OHCI-1394 %d.%d (PCI): IRQ=[%d]  MMIO=[%lx-%lx]"
  651.       "  Max Packet=[%d]", ((((buf) >> 16) & 0xf) + (((buf) >> 20) & 0xf) * 10),
  652.       ((((buf) >> 4) & 0xf) + ((buf) & 0xf) * 10), ohci->dev->irq,
  653.       pci_resource_start(ohci->dev, 0),
  654.       pci_resource_start(ohci->dev, 0) + pci_resource_len(ohci->dev, 0),
  655.       ohci->max_packet_size);
  657. return 1;
  658. }
  660. static void ohci_remove(struct hpsb_host *host)
  661. {
  662. struct ti_ohci *ohci;
  664. if (host != NULL) {
  665. ohci = host->hostdata;
  666. remove_card(ohci);
  667. }
  668. }
  670. /* 
  671.  * Insert a packet in the AT DMA fifo and generate the DMA prg
  672.  * FIXME: rewrite the program in order to accept packets crossing
  673.  *        page boundaries.
  674.  *        check also that a single dma descriptor doesn't cross a 
  675.  *        page boundary.
  676.  */
  677. static void insert_packet(struct ti_ohci *ohci,
  678.   struct dma_trm_ctx *d, struct hpsb_packet *packet)
  679. {
  680. u32 cycleTimer;
  681. int idx = d->prg_ind;
  683. DBGMSG(ohci->id, "Inserting packet for node %d, tlabel=%d, tcode=0x%x, speed=%d",
  684. packet->node_id, packet->tlabel, packet->tcode, packet->speed_code);
  686. d->prg_cpu[idx]->begin.address = 0;
  687. d->prg_cpu[idx]->begin.branchAddress = 0;
  689. if (d->ctx==1) {
  690. /* 
  691.  * For response packets, we need to put a timeout value in
  692.  * the 16 lower bits of the status... let's try 1 sec timeout 
  693.  */ 
  694. cycleTimer = reg_read(ohci, OHCI1394_IsochronousCycleTimer);
  695. d->prg_cpu[idx]->begin.status = cpu_to_le32(
  696. (((((cycleTimer>>25)&0x7)+1)&0x7)<<13) | 
  697. ((cycleTimer&0x01fff000)>>12));
  699. DBGMSG(ohci->id, "cycleTimer: %08x timeStamp: %08x",
  700.        cycleTimer, d->prg_cpu[idx]->begin.status);
  701. } else 
  702. d->prg_cpu[idx]->begin.status = 0;
  704.         if ( (packet->type == hpsb_async) || (packet->type == hpsb_raw) ) {
  706.                 if (packet->type == hpsb_raw) {
  707. d->prg_cpu[idx]->data[0] = cpu_to_le32(OHCI1394_TCODE_PHY<<4);
  708.                         d->prg_cpu[idx]->data[1] = packet->header[0];
  709.                         d->prg_cpu[idx]->data[2] = packet->header[1];
  710.                 } else {
  711.                         d->prg_cpu[idx]->data[0] = packet->speed_code<<16 |
  712.                                 (packet->header[0] & 0xFFFF);
  713.                         d->prg_cpu[idx]->data[1] =
  714.                                 (packet->header[1] & 0xFFFF) | 
  715.                                 (packet->header[0] & 0xFFFF0000);
  716.                         d->prg_cpu[idx]->data[2] = packet->header[2];
  717.                         d->prg_cpu[idx]->data[3] = packet->header[3];
  718. packet_swab(d->prg_cpu[idx]->data, packet->tcode,
  719. packet->header_size>>2);
  720.                 }
  722.                 if (packet->data_size) { /* block transmit */
  723.                         d->prg_cpu[idx]->begin.control =
  724.                                 cpu_to_le32(DMA_CTL_OUTPUT_MORE |
  725.     DMA_CTL_IMMEDIATE | 0x10);
  726.                         d->prg_cpu[idx]->end.control =
  727.                                 cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  728.     DMA_CTL_IRQ | 
  729.     DMA_CTL_BRANCH |
  730.     packet->data_size);
  731.                         /* 
  732.                          * Check that the packet data buffer
  733.                          * does not cross a page boundary.
  734.                          */
  735.                         if (cross_bound((unsigned long)packet->data, 
  736.                                         packet->data_size)>0) {
  737.                                 /* FIXME: do something about it */
  738.                                 PRINT(KERN_ERR, ohci->id, __FUNCTION__
  739.                                       ": packet data addr: %p size %Zd bytes "
  740.                                       "cross page boundary", 
  741.                                       packet->data, packet->data_size);
  742.                         }
  744.                         d->prg_cpu[idx]->end.address = cpu_to_le32(
  745.                                 pci_map_single(ohci->dev, packet->data,
  746.                                                packet->data_size,
  747.                                                PCI_DMA_TODEVICE));
  748. OHCI_DMA_ALLOC("single, block transmit packet");
  750.                         d->prg_cpu[idx]->end.branchAddress = 0;
  751.                         d->prg_cpu[idx]->end.status = 0;
  752.                         if (d->branchAddrPtr) 
  753.                                 *(d->branchAddrPtr) =
  754. cpu_to_le32(d->prg_bus[idx] | 0x3);
  755.                         d->branchAddrPtr =
  756.                                 &(d->prg_cpu[idx]->end.branchAddress);
  757.                 } else { /* quadlet transmit */
  758.                         if (packet->type == hpsb_raw)
  759.                                 d->prg_cpu[idx]->begin.control = 
  760. cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  761.     DMA_CTL_IMMEDIATE |
  762.     DMA_CTL_IRQ | 
  763.     DMA_CTL_BRANCH |
  764.     (packet->header_size + 4));
  765.                         else
  766.                                 d->prg_cpu[idx]->begin.control =
  767. cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  768.     DMA_CTL_IMMEDIATE |
  769.     DMA_CTL_IRQ | 
  770.     DMA_CTL_BRANCH |
  771.     packet->header_size);
  773.                         if (d->branchAddrPtr) 
  774.                                 *(d->branchAddrPtr) =
  775. cpu_to_le32(d->prg_bus[idx] | 0x2);
  776.                         d->branchAddrPtr =
  777.                                 &(d->prg_cpu[idx]->begin.branchAddress);
  778.                 }
  780.         } else { /* iso packet */
  781.                 d->prg_cpu[idx]->data[0] = packet->speed_code<<16 |
  782.                         (packet->header[0] & 0xFFFF);
  783.                 d->prg_cpu[idx]->data[1] = packet->header[0] & 0xFFFF0000;
  784. packet_swab(d->prg_cpu[idx]->data, packet->tcode, packet->header_size>>2);
  785.   
  786.                 d->prg_cpu[idx]->begin.control = 
  787. cpu_to_le32(DMA_CTL_OUTPUT_MORE | 
  788.     DMA_CTL_IMMEDIATE | 0x8);
  789.                 d->prg_cpu[idx]->end.control = 
  790. cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  791.     DMA_CTL_UPDATE |
  792.     DMA_CTL_IRQ |
  793.     DMA_CTL_BRANCH |
  794.     packet->data_size);
  795.                 d->prg_cpu[idx]->end.address = cpu_to_le32(
  796. pci_map_single(ohci->dev, packet->data,
  797. packet->data_size, PCI_DMA_TODEVICE));
  798. OHCI_DMA_ALLOC("single, iso transmit packet");
  800.                 d->prg_cpu[idx]->end.branchAddress = 0;
  801.                 d->prg_cpu[idx]->end.status = 0;
  802.                 DBGMSG(ohci->id, "Iso xmit context info: header[%08x %08x]n"
  803.                        "                       begin=%08x %08x %08x %08xn"
  804.                        "                             %08x %08x %08x %08xn"
  805.                        "                       end  =%08x %08x %08x %08x",
  806.                        d->prg_cpu[idx]->data[0], d->prg_cpu[idx]->data[1],
  807.                        d->prg_cpu[idx]->begin.control,
  808.                        d->prg_cpu[idx]->begin.address,
  809.                        d->prg_cpu[idx]->begin.branchAddress,
  810.                        d->prg_cpu[idx]->begin.status,
  811.                        d->prg_cpu[idx]->data[0],
  812.                        d->prg_cpu[idx]->data[1],
  813.                        d->prg_cpu[idx]->data[2],
  814.                        d->prg_cpu[idx]->data[3],
  815.                        d->prg_cpu[idx]->end.control,
  816.                        d->prg_cpu[idx]->end.address,
  817.                        d->prg_cpu[idx]->end.branchAddress,
  818.                        d->prg_cpu[idx]->end.status);
  819.                 if (d->branchAddrPtr) 
  820.            *(d->branchAddrPtr) = cpu_to_le32(d->prg_bus[idx] | 0x3);
  821.                 d->branchAddrPtr = &(d->prg_cpu[idx]->end.branchAddress);
  822.         }
  823. d->free_prgs--;
  825. /* queue the packet in the appropriate context queue */
  826. if (d->fifo_last) {
  827. d->fifo_last->xnext = packet;
  828. d->fifo_last = packet;
  829. } else {
  830. d->fifo_first = packet;
  831. d->fifo_last = packet;
  832. }
  833. d->prg_ind = (d->prg_ind+1)%d->num_desc;
  834. }
  836. /*
  837.  * This function fills the AT FIFO with the (eventual) pending packets
  838.  * and runs or wakes up the AT DMA prg if necessary.
  839.  *
  840.  * The function MUST be called with the d->lock held.
  841.  */ 
  842. static int dma_trm_flush(struct ti_ohci *ohci, struct dma_trm_ctx *d)
  843. {
  844. int idx,z;
  846. if (d->pending_first == NULL || d->free_prgs == 0) 
  847. return 0;
  849. idx = d->prg_ind;
  850. z = (d->pending_first->data_size) ? 3 : 2;
  852. /* insert the packets into the at dma fifo */
  853. while (d->free_prgs>0 && d->pending_first) {
  854. insert_packet(ohci, d, d->pending_first);
  855. d->pending_first = d->pending_first->xnext;
  856. }
  857. if (d->pending_first == NULL) 
  858. d->pending_last = NULL;
  859. else
  860. PRINT(KERN_INFO, ohci->id, 
  861.       "Transmit DMA FIFO ctx=%d is full... waiting",d->ctx);
  863. /* Is the context running ? (should be unless it is 
  864.    the first packet to be sent in this context) */
  865. if (!(reg_read(ohci, d->ctrlSet) & 0x8000)) {
  866. DBGMSG(ohci->id,"Starting transmit DMA ctx=%d",d->ctx);
  867. reg_write(ohci, d->cmdPtr, d->prg_bus[idx]|z);
  868. run_context(ohci, d->ctrlSet, NULL);
  869. }
  870. else {
  871. /* Wake up the dma context if necessary */
  872. if (!(reg_read(ohci, d->ctrlSet) & 0x400)) {
  873. DBGMSG(ohci->id,"Waking transmit DMA ctx=%d",d->ctx);
  874. reg_write(ohci, d->ctrlSet, 0x1000);
  875. }
  876. }
  877. return 1;
  878. }
  880. /* Transmission of an async packet */
  881. static int ohci_transmit(struct hpsb_host *host, struct hpsb_packet *packet)
  882. {
  883. struct ti_ohci *ohci = host->hostdata;
  884. struct dma_trm_ctx *d;
  885. unsigned char tcode;
  886. unsigned long flags;
  888. if (packet->data_size > ohci->max_packet_size) {
  889. PRINT(KERN_ERR, ohci->id, 
  890.       "Transmit packet size %Zd is too big",
  891.       packet->data_size);
  892. return 0;
  893. }
  894. packet->xnext = NULL;
  896. /* Decide wether we have an iso, a request, or a response packet */
  897. tcode = (packet->header[0]>>4)&0xf;
  898. if (tcode == TCODE_ISO_DATA) d = ohci->it_context;
  899. else if (tcode & 0x02) d = ohci->at_resp_context;
  900. else d = ohci->at_req_context;
  902. spin_lock_irqsave(&d->lock,flags);
  904. /* queue the packet for later insertion into the dma fifo */
  905. if (d->pending_last) {
  906. d->pending_last->xnext = packet;
  907. d->pending_last = packet;
  908. }
  909. else {
  910. d->pending_first = packet;
  911. d->pending_last = packet;
  912. }
  914. dma_trm_flush(ohci, d);
  916. spin_unlock_irqrestore(&d->lock,flags);
  918. return 1;
  919. }
  921. static int ohci_devctl(struct hpsb_host *host, enum devctl_cmd cmd, int arg)
  922. {
  923. struct ti_ohci *ohci = host->hostdata;
  924. int retval = 0;
  925. unsigned long flags;
  927. switch (cmd) {
  928. case RESET_BUS:
  929. DBGMSG(ohci->id, "devctl: Bus reset requested%s",
  930.        ((host->attempt_root || attempt_root) ? 
  931.        " and attempting to become root" : ""));
  932. set_phy_reg_mask (ohci, 1, 0x40 | ((host->attempt_root || attempt_root) ?
  933.   0x80 : 0));
  934. break;
  936. case GET_CYCLE_COUNTER:
  937. retval = reg_read(ohci, OHCI1394_IsochronousCycleTimer);
  938. break;
  940. case SET_CYCLE_COUNTER:
  941. reg_write(ohci, OHCI1394_IsochronousCycleTimer, arg);
  942. break;
  944. case SET_BUS_ID:
  945. PRINT(KERN_ERR, ohci->id, "devctl command SET_BUS_ID err");
  946. break;
  948. case ACT_CYCLE_MASTER:
  949. if (arg) {
  950. /* check if we are root and other nodes are present */
  951. u32 nodeId = reg_read(ohci, OHCI1394_NodeID);
  952. if ((nodeId & (1<<30)) && (nodeId & 0x3f)) {
  953. /*
  954.  * enable cycleTimer, cycleMaster
  955.  */
  956. DBGMSG(ohci->id, "Cycle master enabled");
  957. reg_write(ohci, OHCI1394_LinkControlSet, 
  958.   0x00300000);
  959. }
  960. } else {
  961. /* disable cycleTimer, cycleMaster, cycleSource */
  962. reg_write(ohci, OHCI1394_LinkControlClear, 0x00700000);
  963. }
  964. break;
  966. case CANCEL_REQUESTS:
  967. DBGMSG(ohci->id, "Cancel request received");
  968. dma_trm_reset(ohci->at_req_context);
  969. dma_trm_reset(ohci->at_resp_context);
  970. break;
  972. case MODIFY_USAGE:
  973.                 if (arg) {
  974.                         MOD_INC_USE_COUNT;
  975.                 } else {
  976.                         MOD_DEC_USE_COUNT;
  977.                 }
  978.                 break;
  980. case ISO_LISTEN_CHANNEL:
  981.         {
  982. u64 mask;
  984. if (arg<0 || arg>63) {
  985. PRINT(KERN_ERR, ohci->id, __FUNCTION__
  986.       "IS0 listen channel %d is out of range", 
  987.       arg);
  988. return -EFAULT;
  989. }
  991. mask = (u64)0x1<<arg;
  993.                 spin_lock_irqsave(&ohci->IR_channel_lock, flags);
  995. if (ohci->ISO_channel_usage & mask) {
  996. PRINT(KERN_ERR, ohci->id, __FUNCTION__
  997.       "IS0 listen channel %d is already used", 
  998.       arg);
  999. spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  1000. return -EFAULT;
  1001. }
  1003. ohci->ISO_channel_usage |= mask;
  1005. if (arg>31) 
  1006. reg_write(ohci, OHCI1394_IRMultiChanMaskHiSet, 
  1007.   1<<(arg-32));
  1008. else
  1009. reg_write(ohci, OHCI1394_IRMultiChanMaskLoSet, 
  1010.   1<<arg);
  1012.                 spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  1013.                 DBGMSG(ohci->id, "Listening enabled on channel %d", arg);
  1014.                 break;
  1015.         }
  1016. case ISO_UNLISTEN_CHANNEL:
  1017.         {
  1018. u64 mask;
  1020. if (arg<0 || arg>63) {
  1021. PRINT(KERN_ERR, ohci->id, __FUNCTION__
  1022.       "IS0 unlisten channel %d is out of range", 
  1023.       arg);
  1024. return -EFAULT;
  1025. }
  1027. mask = (u64)0x1<<arg;
  1029.                 spin_lock_irqsave(&ohci->IR_channel_lock, flags);
  1031. if (!(ohci->ISO_channel_usage & mask)) {
  1032. PRINT(KERN_ERR, ohci->id, __FUNCTION__
  1033.       "IS0 unlisten channel %d is not used", 
  1034.       arg);
  1035. spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  1036. return -EFAULT;
  1037. }
  1039. ohci->ISO_channel_usage &= ~mask;
  1041. if (arg>31) 
  1042. reg_write(ohci, OHCI1394_IRMultiChanMaskHiClear, 
  1043.   1<<(arg-32));
  1044. else
  1045. reg_write(ohci, OHCI1394_IRMultiChanMaskLoClear, 
  1046.   1<<arg);
  1048.                 spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  1049.                 DBGMSG(ohci->id, "Listening disabled on channel %d", arg);
  1050.                 break;
  1051.         }
  1052. default:
  1053. PRINT_G(KERN_ERR, "ohci_devctl cmd %d not implemented yet",
  1054. cmd);
  1055. break;
  1056. }
  1057. return retval;
  1058. }
  1060. /***************************************
  1061.  * IEEE-1394 functionality section END *
  1062.  ***************************************/
  1065. /********************************************************
  1066.  * Global stuff (interrupt handler, init/shutdown code) *
  1067.  ********************************************************/
  1069. static void dma_trm_reset(struct dma_trm_ctx *d)
  1070. {
  1071. struct ti_ohci *ohci;
  1072. unsigned long flags;
  1073.         struct hpsb_packet *nextpacket;
  1075. if (d==NULL) {
  1076. PRINT_G(KERN_ERR, "dma_trm_reset called with NULL arg");
  1077. return;
  1078. }
  1079. ohci = (struct ti_ohci *)(d->ohci);
  1080. ohci1394_stop_context(ohci, d->ctrlClear, NULL);
  1082. spin_lock_irqsave(&d->lock,flags);
  1084. /* Is there still any packet pending in the fifo ? */
  1085. while(d->fifo_first) {
  1086. PRINT(KERN_INFO, ohci->id, 
  1087.       "AT dma reset ctx=%d, aborting transmission", 
  1088.       d->ctx);
  1089.                 nextpacket = d->fifo_first->xnext;
  1090. hpsb_packet_sent(ohci->host, d->fifo_first, ACKX_ABORTED);
  1091. d->fifo_first = nextpacket;
  1092. }
  1093. d->fifo_first = d->fifo_last = NULL;
  1095. /* is there still any packet pending ? */
  1096. while(d->pending_first) {
  1097. PRINT(KERN_INFO, ohci->id, 
  1098.       "AT dma reset ctx=%d, aborting transmission", 
  1099.       d->ctx);
  1100.                 nextpacket = d->pending_first->xnext;
  1101. hpsb_packet_sent(ohci->host, d->pending_first, 
  1102.  ACKX_ABORTED);
  1103. d->pending_first = nextpacket;
  1104. }
  1105. d->pending_first = d->pending_last = NULL;
  1107. d->branchAddrPtr=NULL;
  1108. d->sent_ind = d->prg_ind;
  1109. d->free_prgs = d->num_desc;
  1110. spin_unlock_irqrestore(&d->lock,flags);
  1111. }
  1113. static void ohci_irq_handler(int irq, void *dev_id,
  1114.                              struct pt_regs *regs_are_unused)
  1115. {
  1116. quadlet_t event, node_id;
  1117. struct ti_ohci *ohci = (struct ti_ohci *)dev_id;
  1118. struct hpsb_host *host = ohci->host;
  1119. int phyid = -1, isroot = 0;
  1120. unsigned long flags;
  1122. /* Read and clear the interrupt event register.  Don't clear
  1123.  * the busReset event, though, this is done when we get the
  1124.  * selfIDComplete interrupt. */
  1125. spin_lock_irqsave(&ohci->event_lock, flags);
  1126. event = reg_read(ohci, OHCI1394_IntEventClear);
  1127. reg_write(ohci, OHCI1394_IntEventClear, event & ~OHCI1394_busReset);
  1128. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1130. if (!event) return;
  1132. DBGMSG(ohci->id, "IntEvent: %08x", event);
  1134. /* Die right here an now */
  1135. if (event & OHCI1394_unrecoverableError) {
  1136. PRINT(KERN_ERR, ohci->id, "Unrecoverable error, shutting down card!");
  1137. remove_card(ohci);
  1138. return;
  1139. }
  1141. if (event & OHCI1394_busReset) {
  1142. /* The busReset event bit can't be cleared during the
  1143.  * selfID phase, so we disable busReset interrupts, to
  1144.  * avoid burying the cpu in interrupt requests. */
  1145. spin_lock_irqsave(&ohci->event_lock, flags);
  1146.    reg_write(ohci, OHCI1394_IntMaskClear, OHCI1394_busReset);
  1147. if (ohci->dev->vendor == PCI_VENDOR_ID_APPLE && 
  1148.     ohci->dev->device == PCI_DEVICE_ID_APPLE_UNI_N_FW) {
  1149.    udelay(10);
  1150.    while(reg_read(ohci, OHCI1394_IntEventSet) & OHCI1394_busReset) {
  1151.    reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
  1152. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1153.    udelay(10);
  1154. spin_lock_irqsave(&ohci->event_lock, flags);
  1155.    }
  1156.    }
  1157. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1158. if (!host->in_bus_reset) {
  1159. DBGMSG(ohci->id, "irq_handler: Bus reset requested%s",
  1160.       ((host->attempt_root || attempt_root) ?
  1161.       " and attempting to become root" : ""));
  1163. /* Subsystem call */
  1164. hpsb_bus_reset(ohci->host);
  1165. }
  1166. event &= ~OHCI1394_busReset;
  1167. }
  1169. /* XXX: We need a way to also queue the OHCI1394_reqTxComplete,
  1170.  * but for right now we simply run it upon reception, to make sure
  1171.  * we get sent acks before response packets. This sucks mainly
  1172.  * because it halts the interrupt handler.  */
  1173. if (event & OHCI1394_reqTxComplete) {
  1174. struct dma_trm_ctx *d = ohci->at_req_context;
  1175. DBGMSG(ohci->id, "Got reqTxComplete interrupt "
  1176.        "status=0x%08X", reg_read(ohci, d->ctrlSet));
  1177. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1178. ohci1394_stop_context(ohci, d->ctrlClear,
  1179.       "reqTxComplete");
  1180. else
  1181. dma_trm_tasklet ((unsigned long)d);
  1182. event &= ~OHCI1394_reqTxComplete;
  1183. }
  1184. if (event & OHCI1394_respTxComplete) {
  1185. struct dma_trm_ctx *d = ohci->at_resp_context;
  1186. DBGMSG(ohci->id, "Got respTxComplete interrupt "
  1187.        "status=0x%08X", reg_read(ohci, d->ctrlSet));
  1188. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1189. ohci1394_stop_context(ohci, d->ctrlClear,
  1190.       "respTxComplete");
  1191. else
  1192. tasklet_schedule(&d->task);
  1193. event &= ~OHCI1394_respTxComplete;
  1194. }
  1195. if (event & OHCI1394_RQPkt) {
  1196. struct dma_rcv_ctx *d = ohci->ar_req_context;
  1197. DBGMSG(ohci->id, "Got RQPkt interrupt status=0x%08X",
  1198.        reg_read(ohci, d->ctrlSet));
  1199. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1200. ohci1394_stop_context(ohci, d->ctrlClear, "RQPkt");
  1201. else
  1202. tasklet_schedule(&d->task);
  1203. event &= ~OHCI1394_RQPkt;
  1204. }
  1205. if (event & OHCI1394_RSPkt) {
  1206. struct dma_rcv_ctx *d = ohci->ar_resp_context;
  1207. DBGMSG(ohci->id, "Got RSPkt interrupt status=0x%08X",
  1208.        reg_read(ohci, d->ctrlSet));
  1209. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1210. ohci1394_stop_context(ohci, d->ctrlClear, "RSPkt");
  1211. else
  1212. tasklet_schedule(&d->task);
  1213. event &= ~OHCI1394_RSPkt;
  1214. }
  1215. if (event & OHCI1394_isochRx) {
  1216. quadlet_t isoRecvIntEvent;
  1217. struct dma_rcv_ctx *d = ohci->ir_context;
  1218. isoRecvIntEvent = 
  1219. reg_read(ohci, OHCI1394_IsoRecvIntEventSet);
  1220. reg_write(ohci, OHCI1394_IsoRecvIntEventClear,
  1221.   isoRecvIntEvent);
  1222. DBGMSG(ohci->id, "Got isochRx interrupt "
  1223.        "status=0x%08X isoRecvIntEvent=%08x", 
  1224.        reg_read(ohci, d->ctrlSet), isoRecvIntEvent);
  1225. if (isoRecvIntEvent & 0x1) {
  1226. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1227. ohci1394_stop_context(ohci, d->ctrlClear, 
  1228.      "isochRx");
  1229. else
  1230. tasklet_schedule(&d->task);
  1231. }
  1232. if (ohci->video_tmpl) 
  1233. ohci->video_tmpl->irq_handler(ohci->id, isoRecvIntEvent,
  1234.       0);
  1235. event &= ~OHCI1394_isochRx;
  1236. }
  1237. if (event & OHCI1394_isochTx) {
  1238. quadlet_t isoXmitIntEvent;
  1239. struct dma_trm_ctx *d = ohci->it_context;
  1240. isoXmitIntEvent = 
  1241. reg_read(ohci, OHCI1394_IsoXmitIntEventSet);
  1242. reg_write(ohci, OHCI1394_IsoXmitIntEventClear,
  1243.   isoXmitIntEvent);
  1244.                        DBGMSG(ohci->id, "Got isochTx interrupt "
  1245.                                "status=0x%08x isoXmitIntEvent=%08x",
  1246.                               reg_read(ohci, d->ctrlSet), isoXmitIntEvent);
  1247. if (ohci->video_tmpl) 
  1248. ohci->video_tmpl->irq_handler(ohci->id, 0,
  1249.       isoXmitIntEvent);
  1250. if (isoXmitIntEvent & 0x1) {
  1251. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1252. ohci1394_stop_context(ohci, d->ctrlClear, "isochTx");
  1253. else
  1254. tasklet_schedule(&d->task);
  1255. }
  1256. event &= ~OHCI1394_isochTx;
  1257. }
  1258. if (event & OHCI1394_selfIDComplete) {
  1259. if (host->in_bus_reset) {
  1260. node_id = reg_read(ohci, OHCI1394_NodeID); 
  1262. /* If our nodeid is not valid, give a msec delay
  1263.  * to let it settle in and try again.  */
  1264. if (!(node_id & 0x80000000)) {
  1265. mdelay(1);
  1266. node_id = reg_read(ohci, OHCI1394_NodeID);
  1267. }
  1269. if (node_id & 0x80000000) { /* NodeID valid */
  1270. phyid =  node_id & 0x0000003f;
  1271. isroot = (node_id & 0x40000000) != 0;
  1273. DBGMSG(ohci->id,
  1274.       "SelfID interrupt received "
  1275.       "(phyid %d, %s)", phyid, 
  1276.       (isroot ? "root" : "not root"));
  1278. handle_selfid(ohci, host, 
  1279.       phyid, isroot);
  1280. } else {
  1281. PRINT(KERN_ERR, ohci->id, 
  1282.       "SelfID interrupt received, but "
  1283.       "NodeID is not valid: %08X",
  1284.       node_id);
  1285. }
  1287. /* Accept Physical requests from all nodes. */
  1288. reg_write(ohci,OHCI1394_AsReqFilterHiSet, 
  1289.   0xffffffff);
  1290. reg_write(ohci,OHCI1394_AsReqFilterLoSet, 
  1291.   0xffffffff);
  1292. /* Turn on phys dma reception. We should
  1293.  * probably manage the filtering somehow, 
  1294.  * instead of blindly turning it on.  */
  1295. reg_write(ohci,OHCI1394_PhyReqFilterHiSet,
  1296.   0xffffffff);
  1297. reg_write(ohci,OHCI1394_PhyReqFilterLoSet,
  1298.   0xffffffff);
  1299.                         reg_write(ohci,OHCI1394_PhyUpperBound,
  1300.   0xffff0000);
  1301. } else
  1302. PRINT(KERN_ERR, ohci->id, 
  1303.       "SelfID received outside of bus reset sequence");
  1305. /* Finally, we clear the busReset event and reenable
  1306.  * the busReset interrupt. */
  1307. spin_lock_irqsave(&ohci->event_lock, flags);
  1308. reg_write(ohci, OHCI1394_IntMaskSet, OHCI1394_busReset); 
  1309. reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
  1310. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1311. event &= ~OHCI1394_selfIDComplete;
  1312. }
  1314. /* Make sure we handle everything, just in case we accidentally
  1315.  * enabled an interrupt that we didn't write a handler for.  */
  1316. if (event)
  1317. PRINT(KERN_ERR, ohci->id, "Unhandled interrupt(s) 0x%08x",
  1318.       event);
  1319. }
  1321. /* Put the buffer back into the dma context */
  1322. static void insert_dma_buffer(struct dma_rcv_ctx *d, int idx)
  1323. {
  1324. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  1325. DBGMSG(ohci->id, "Inserting dma buf ctx=%d idx=%d", d->ctx, idx);
  1327. d->prg_cpu[idx]->status = cpu_to_le32(d->buf_size);
  1328. d->prg_cpu[idx]->branchAddress &= le32_to_cpu(0xfffffff0);
  1329. idx = (idx + d->num_desc - 1 ) % d->num_desc;
  1330. d->prg_cpu[idx]->branchAddress |= le32_to_cpu(0x00000001);
  1332. /* wake up the dma context if necessary */
  1333. if (!(reg_read(ohci, d->ctrlSet) & 0x400)) {
  1334. PRINT(KERN_INFO, ohci->id, 
  1335.       "Waking dma ctx=%d ... processing is probably too slow",
  1336.       d->ctx);
  1337. reg_write(ohci, d->ctrlSet, 0x1000);
  1338. }
  1339. }
  1341. #define cond_le32_to_cpu(data, noswap) 
  1342. (noswap ? data : le32_to_cpu(data))
  1344. static const int TCODE_SIZE[16] = {20, 0, 16, -1, 16, 20, 20, 0, 
  1345.     -1, 0, -1, 0, -1, -1, 16, -1};
  1347. /* 
  1348.  * Determine the length of a packet in the buffer
  1349.  * Optimization suggested by Pascal Drolet <pascal.drolet@informission.ca>
  1350.  */
  1351. static __inline__ int packet_length(struct dma_rcv_ctx *d, int idx, quadlet_t *buf_ptr,
  1352.  int offset, unsigned char tcode, int noswap)
  1353. {
  1354. int length = -1;
  1356. if (d->ctx < 2) { /* Async Receive Response/Request */
  1357. length = TCODE_SIZE[tcode];
  1358. if (length == 0) {
  1359. if (offset + 12 >= d->buf_size) {
  1360. length = (cond_le32_to_cpu(d->buf_cpu[(idx + 1) % d->num_desc]
  1361. [3 - ((d->buf_size - offset) >> 2)], noswap) >> 16);
  1362. } else {
  1363. length = (cond_le32_to_cpu(buf_ptr[3], noswap) >> 16);
  1364. }
  1365. length += 20;
  1366. }
  1367. } else if (d->ctx == 2) { /* Iso receive */
  1368. /* Assumption: buffer fill mode with header/trailer */
  1369. length = (cond_le32_to_cpu(buf_ptr[0], noswap) >> 16) + 8;
  1370. }
  1372. if (length > 0 && length % 4)
  1373. length += 4 - (length % 4);
  1375. return length;
  1376. }
  1378. /* Tasklet that processes dma receive buffers */
  1379. static void dma_rcv_tasklet (unsigned long data)
  1380. {
  1381. struct dma_rcv_ctx *d = (struct dma_rcv_ctx*)data;
  1382. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  1383. unsigned int split_left, idx, offset, rescount;
  1384. unsigned char tcode;
  1385. int length, bytes_left, ack;
  1386. unsigned long flags;
  1387. quadlet_t *buf_ptr;
  1388. char *split_ptr;
  1389. char msg[256];
  1391. spin_lock_irqsave(&d->lock, flags);
  1393. idx = d->buf_ind;
  1394. offset = d->buf_offset;
  1395. buf_ptr = d->buf_cpu[idx] + offset/4;
  1397. dma_cache_wback_inv(&(d->prg_cpu[idx]->status), sizeof(d->prg_cpu[idx]->status));
  1398. rescount = le32_to_cpu(d->prg_cpu[idx]->status) & 0xffff;
  1400. bytes_left = d->buf_size - rescount - offset;
  1401. dma_cache_wback_inv(buf_ptr, bytes_left);
  1403. while (bytes_left > 0) {
  1404. tcode = (cond_le32_to_cpu(buf_ptr[0], ohci->no_swap_incoming) >> 4) & 0xf;
  1406. /* packet_length() will return < 4 for an error */
  1407. length = packet_length(d, idx, buf_ptr, offset, tcode, ohci->no_swap_incoming);
  1409. if (length < 4) { /* something is wrong */
  1410. sprintf(msg,"Unexpected tcode 0x%x(0x%08x) in AR ctx=%d, length=%d",
  1411. tcode, cond_le32_to_cpu(buf_ptr[0], ohci->no_swap_incoming),
  1412. d->ctx, length);
  1413. ohci1394_stop_context(ohci, d->ctrlClear, msg);
  1414. spin_unlock_irqrestore(&d->lock, flags);
  1415. return;
  1416. }
  1418. /* The first case is where we have a packet that crosses
  1419.  * over more than one descriptor. The next case is where
  1420.  * it's all in the first descriptor.  */
  1421. if ((offset + length) > d->buf_size) {
  1422. DBGMSG(ohci->id,"Split packet rcv'd");
  1423. if (length > d->split_buf_size) {
  1424. ohci1394_stop_context(ohci, d->ctrlClear,
  1425.      "Split packet size exceeded");
  1426. d->buf_ind = idx;
  1427. d->buf_offset = offset;
  1428. spin_unlock_irqrestore(&d->lock, flags);
  1429. return;
  1430. }
  1432. if (le32_to_cpu(d->prg_cpu[(idx+1)%d->num_desc]->status)
  1433.     == d->buf_size) {
  1434. /* Other part of packet not written yet.
  1435.  * this should never happen I think
  1436.  * anyway we'll get it on the next call.  */
  1437. PRINT(KERN_INFO, ohci->id,
  1438.       "Got only half a packet!");
  1439. d->buf_ind = idx;
  1440. d->buf_offset = offset;
  1441. spin_unlock_irqrestore(&d->lock, flags);
  1442. return;
  1443. }
  1445. split_left = length;
  1446. split_ptr = (char *)d->spb;
  1447. memcpy(split_ptr,buf_ptr,d->buf_size-offset);
  1448. split_left -= d->buf_size-offset;
  1449. split_ptr += d->buf_size-offset;
  1450. insert_dma_buffer(d, idx);
  1451. idx = (idx+1) % d->num_desc;
  1452. buf_ptr = d->buf_cpu[idx];
  1453. dma_cache_wback_inv(buf_ptr, d->buf_size);
  1454. offset=0;
  1456. while (split_left >= d->buf_size) {
  1457. memcpy(split_ptr,buf_ptr,d->buf_size);
  1458. split_ptr += d->buf_size;
  1459. split_left -= d->buf_size;
  1460. insert_dma_buffer(d, idx);
  1461. idx = (idx+1) % d->num_desc;
  1462. buf_ptr = d->buf_cpu[idx];
  1463.                                 dma_cache_wback_inv(buf_ptr, d->buf_size);
  1464. }
  1466. if (split_left > 0) {
  1467. memcpy(split_ptr, buf_ptr, split_left);
  1468. offset = split_left;
  1469. buf_ptr += offset/4;
  1470. }
  1471. } else {
  1472. DBGMSG(ohci->id,"Single packet rcv'd");
  1473. memcpy(d->spb, buf_ptr, length);
  1474. offset += length;
  1475. buf_ptr += length/4;
  1476. if (offset==d->buf_size) {
  1477. insert_dma_buffer(d, idx);
  1478. idx = (idx+1) % d->num_desc;
  1479. buf_ptr = d->buf_cpu[idx];
  1480. offset=0;
  1481. }
  1482. }
  1484. /* We get one phy packet to the async descriptor for each
  1485.  * bus reset. We always ignore it.  */
  1486. if (tcode != OHCI1394_TCODE_PHY) {
  1487. if (!ohci->no_swap_incoming)
  1488. packet_swab(d->spb, tcode, (length - 4) >> 2);
  1489. DBGMSG(ohci->id, "Packet received from node"
  1490. " %d ack=0x%02X spd=%d tcode=0x%X"
  1491. " length=%d ctx=%d tlabel=%d",
  1492. (d->spb[1]>>16)&0x3f,
  1493. (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>16)&0x1f,
  1494. (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>21)&0x3,
  1495. tcode, length, d->ctx,
  1496. (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>10)&0x3f);
  1498. ack = (((cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>16)&0x1f)
  1499. == 0x11) ? 1 : 0;
  1501. hpsb_packet_received(ohci->host, d->spb, 
  1502.      length-4, ack);
  1503. }
  1504. #ifdef OHCI1394_DEBUG
  1505. else
  1506. PRINT (KERN_DEBUG, ohci->id, "Got phy packet ctx=%d ... discarded",
  1507.        d->ctx);
  1508. #endif
  1510.                 dma_cache_wback_inv(&(d->prg_cpu[idx]->status),
  1511.                         sizeof(d->prg_cpu[idx]->status));
  1512.         rescount = le32_to_cpu(d->prg_cpu[idx]->status) & 0xffff;
  1514. bytes_left = d->buf_size - rescount - offset;
  1516. }
  1518. d->buf_ind = idx;
  1519. d->buf_offset = offset;
  1521. spin_unlock_irqrestore(&d->lock, flags);
  1522. }
  1524. /* Bottom half that processes sent packets */
  1525. static void dma_trm_tasklet (unsigned long data)
  1526. {
  1527. struct dma_trm_ctx *d = (struct dma_trm_ctx*)data;
  1528. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  1529. struct hpsb_packet *packet, *nextpacket;
  1530. unsigned long flags;
  1531. u32 ack;
  1532.         size_t datasize;
  1534. spin_lock_irqsave(&d->lock, flags);
  1536. if (d->fifo_first == NULL) {
  1537. #if 0
  1538. ohci1394_stop_context(ohci, d->ctrlClear, 
  1539.      "Packet sent ack received but queue is empty");
  1540. #endif
  1541. spin_unlock_irqrestore(&d->lock, flags);
  1542. return;
  1543. }
  1545. while (d->fifo_first) {
  1546. packet = d->fifo_first;
  1547.                 datasize = d->fifo_first->data_size;
  1548. if (datasize && packet->type != hpsb_raw)
  1549. ack = le32_to_cpu(
  1550. d->prg_cpu[d->sent_ind]->end.status) >> 16;
  1551. else 
  1552. ack = le32_to_cpu(
  1553. d->prg_cpu[d->sent_ind]->begin.status) >> 16;
  1555. if (ack == 0) 
  1556. /* this packet hasn't been sent yet*/
  1557. break;
  1559. #ifdef OHCI1394_DEBUG
  1560. if (datasize)
  1561. DBGMSG(ohci->id,
  1562.        "Packet sent to node %d tcode=0x%X tLabel="
  1563.        "0x%02X ack=0x%X spd=%d dataLength=%d ctx=%d", 
  1564.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])
  1565.                                         >>16)&0x3f,
  1566.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1567.                                         >>4)&0xf,
  1568.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1569.                                         >>10)&0x3f,
  1570.                                 ack&0x1f, (ack>>5)&0x3, 
  1571.                                 le32_to_cpu(d->prg_cpu[d->sent_ind]->data[3])
  1572.                                         >>16,
  1573.                                 d->ctx);
  1574. else 
  1575. DBGMSG(ohci->id,
  1576.        "Packet sent to node %d tcode=0x%X tLabel="
  1577.        "0x%02X ack=0x%X spd=%d data=0x%08X ctx=%d", 
  1578.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])
  1579.                                         >>16)&0x3f,
  1580.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1581.                                         >>4)&0xf,
  1582.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1583.                                         >>10)&0x3f,
  1584.                                 ack&0x1f, (ack>>5)&0x3, 
  1585.                                 le32_to_cpu(d->prg_cpu[d->sent_ind]->data[3]),
  1586.                                 d->ctx);
  1587. #endif
  1589.                 nextpacket = packet->xnext;
  1590. hpsb_packet_sent(ohci->host, packet, ack & 0xf);
  1592. if (datasize) {
  1593. pci_unmap_single(ohci->dev, 
  1594.  cpu_to_le32(d->prg_cpu[d->sent_ind]->end.address),
  1595.  datasize, PCI_DMA_TODEVICE);
  1596. OHCI_DMA_FREE("single Xmit data packet");
  1597. }
  1599. d->sent_ind = (d->sent_ind+1)%d->num_desc;
  1600. d->free_prgs++;
  1601. d->fifo_first = nextpacket;
  1602. }
  1603. if (d->fifo_first == NULL)
  1604. d->fifo_last = NULL;
  1606. dma_trm_flush(ohci, d);
  1608. spin_unlock_irqrestore(&d->lock, flags);
  1609. }
  1611. static int free_dma_rcv_ctx(struct dma_rcv_ctx **d)
  1612. {
  1613. int i;
  1614. struct ti_ohci *ohci;
  1616. if (*d==NULL) return -1;
  1618. ohci = (struct ti_ohci *)(*d)->ohci;
  1620. DBGMSG(ohci->id, "Freeing dma_rcv_ctx %d",(*d)->ctx);
  1622. ohci1394_stop_context(ohci, (*d)->ctrlClear, NULL);
  1624. tasklet_kill(&(*d)->task);
  1626. if ((*d)->buf_cpu) {
  1627. for (i=0; i<(*d)->num_desc; i++)
  1628. if ((*d)->buf_cpu[i] && (*d)->buf_bus[i]) {
  1629. pci_free_consistent(
  1630. ohci->dev, (*d)->buf_size, 
  1631. (*d)->buf_cpu[i], (*d)->buf_bus[i]);
  1632. OHCI_DMA_FREE("consistent dma_rcv buf[%d]", i);
  1633. }
  1634. kfree((*d)->buf_cpu);
  1635. kfree((*d)->buf_bus);
  1636. }
  1637. if ((*d)->prg_cpu) {
  1638. for (i=0; i<(*d)->num_desc; i++) 
  1639. if ((*d)->prg_cpu[i] && (*d)->prg_bus[i]) {
  1640. pci_free_consistent(
  1641. ohci->dev, sizeof(struct dma_cmd), 
  1642. (*d)->prg_cpu[i], (*d)->prg_bus[i]);
  1643. OHCI_DMA_FREE("consistent dma_rcv prg[%d]", i);
  1644. }
  1645. kfree((*d)->prg_cpu);
  1646. kfree((*d)->prg_bus);
  1647. }
  1648. if ((*d)->spb) kfree((*d)->spb);
  1650. kfree(*d);
  1651. *d = NULL;
  1653. return 0;
  1654. }
  1656. static struct dma_rcv_ctx *
  1657. alloc_dma_rcv_ctx(struct ti_ohci *ohci, int ctx, int num_desc,
  1658.   int buf_size, int split_buf_size, 
  1659.   int ctrlSet, int ctrlClear, int cmdPtr)
  1660. {
  1661. struct dma_rcv_ctx *d=NULL;
  1662. int i;
  1664. d = (struct dma_rcv_ctx *)kmalloc(sizeof(struct dma_rcv_ctx), 
  1665.   GFP_KERNEL);
  1667. if (d == NULL) {
  1668. PRINT(KERN_ERR, ohci->id, "Failed to allocate dma_rcv_ctx");
  1669. return NULL;
  1670. }
  1672. memset (d, 0, sizeof (struct dma_rcv_ctx));
  1674. d->ohci = (void *)ohci;
  1675. d->ctx = ctx;
  1677. d->num_desc = num_desc;
  1678. d->buf_size = buf_size;
  1679. d->split_buf_size = split_buf_size;
  1680. d->ctrlSet = ctrlSet;
  1681. d->ctrlClear = ctrlClear;
  1682. d->cmdPtr = cmdPtr;
  1684. d->buf_cpu = NULL;
  1685. d->buf_bus = NULL;
  1686. d->prg_cpu = NULL;
  1687. d->prg_bus = NULL;
  1688. d->spb = NULL;
  1690. d->buf_cpu = kmalloc(d->num_desc * sizeof(quadlet_t*), GFP_KERNEL);
  1691. d->buf_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
  1693. if (d->buf_cpu == NULL || d->buf_bus == NULL) {
  1694. PRINT(KERN_ERR, ohci->id, "Failed to allocate dma buffer");
  1695. free_dma_rcv_ctx(&d);
  1696. return NULL;
  1697. }
  1698. memset(d->buf_cpu, 0, d->num_desc * sizeof(quadlet_t*));
  1699. memset(d->buf_bus, 0, d->num_desc * sizeof(dma_addr_t));
  1701. d->prg_cpu = kmalloc(d->num_desc * sizeof(struct dma_cmd*), 
  1702.      GFP_KERNEL);
  1703. d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
  1705. if (d->prg_cpu == NULL || d->prg_bus == NULL) {
  1706. PRINT(KERN_ERR, ohci->id, "Failed to allocate dma prg");
  1707. free_dma_rcv_ctx(&d);
  1708. return NULL;
  1709. }
  1710. memset(d->prg_cpu, 0, d->num_desc * sizeof(struct dma_cmd*));
  1711. memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t));
  1713. d->spb = kmalloc(d->split_buf_size, GFP_KERNEL);
  1715. if (d->spb == NULL) {
  1716. PRINT(KERN_ERR, ohci->id, "Failed to allocate split buffer");
  1717. free_dma_rcv_ctx(&d);
  1718. return NULL;
  1719. }
  1721. for (i=0; i<d->num_desc; i++) {
  1722. d->buf_cpu[i] = pci_alloc_consistent(ohci->dev, 
  1723.      d->buf_size,
  1724.      d->buf_bus+i);
  1725. OHCI_DMA_ALLOC("consistent dma_rcv buf[%d]", i);
  1727. if (d->buf_cpu[i] != NULL) {
  1728. memset(d->buf_cpu[i], 0, d->buf_size);
  1729. } else {
  1730. PRINT(KERN_ERR, ohci->id, 
  1731.       "Failed to allocate dma buffer");
  1732. free_dma_rcv_ctx(&d);
  1733. return NULL;
  1734. }
  1737.                 d->prg_cpu[i] = pci_alloc_consistent(ohci->dev, 
  1738.      sizeof(struct dma_cmd),
  1739.      d->prg_bus+i);
  1740. OHCI_DMA_ALLOC("consistent dma_rcv prg[%d]", i);
  1742.                 if (d->prg_cpu[i] != NULL) {
  1743.                         memset(d->prg_cpu[i], 0, sizeof(struct dma_cmd));
  1744. } else {
  1745. PRINT(KERN_ERR, ohci->id, 
  1746.       "Failed to allocate dma prg");
  1747. free_dma_rcv_ctx(&d);
  1748. return NULL;
  1749. }
  1750. }
  1752.         spin_lock_init(&d->lock);
  1754. /* initialize tasklet */
  1755. tasklet_init (&d->task, dma_rcv_tasklet, (unsigned long)d);
  1757. return d;
  1758. }
  1760. static int free_dma_trm_ctx(struct dma_trm_ctx **d)
  1761. {
  1762. struct ti_ohci *ohci;
  1763. int i;
  1765. if (*d==NULL) return -1;
  1767. ohci = (struct ti_ohci *)(*d)->ohci;
  1769. DBGMSG(ohci->id, "Freeing dma_trm_ctx %d",(*d)->ctx);
  1771. ohci1394_stop_context(ohci, (*d)->ctrlClear, NULL);
  1773. tasklet_kill(&(*d)->task);
  1775. if ((*d)->prg_cpu) {
  1776. for (i=0; i<(*d)->num_desc; i++) 
  1777. if ((*d)->prg_cpu[i] && (*d)->prg_bus[i]) {
  1778. pci_free_consistent(
  1779. ohci->dev, sizeof(struct at_dma_prg), 
  1780. (*d)->prg_cpu[i], (*d)->prg_bus[i]);
  1781. OHCI_DMA_FREE("consistent dma_trm prg[%d]", i);
  1782. }
  1783. kfree((*d)->prg_cpu);
  1784. kfree((*d)->prg_bus);
  1785. }
  1787. kfree(*d);
  1788. *d = NULL;
  1789. return 0;
  1790. }
  1792. static struct dma_trm_ctx *
  1793. alloc_dma_trm_ctx(struct ti_ohci *ohci, int ctx, int num_desc,
  1794.   int ctrlSet, int ctrlClear, int cmdPtr)
  1795. {
  1796. struct dma_trm_ctx *d=NULL;
  1797. int i;
  1799. d = (struct dma_trm_ctx *)kmalloc(sizeof(struct dma_trm_ctx), 
  1800.   GFP_KERNEL);
  1802. if (d==NULL) {
  1803. PRINT(KERN_ERR, ohci->id, "Failed to allocate dma_trm_ctx");
  1804. return NULL;
  1805. }
  1807. memset (d, 0, sizeof (struct dma_trm_ctx));
  1809. d->ohci = (void *)ohci;
  1810. d->ctx = ctx;
  1811. d->num_desc = num_desc;
  1812. d->ctrlSet = ctrlSet;
  1813. d->ctrlClear = ctrlClear;
  1814. d->cmdPtr = cmdPtr;
  1815. d->prg_cpu = NULL;
  1816. d->prg_bus = NULL;
  1818. d->prg_cpu = kmalloc(d->num_desc * sizeof(struct at_dma_prg*), 
  1819.      GFP_KERNEL);
  1820. d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
  1822. if (d->prg_cpu == NULL || d->prg_bus == NULL) {
  1823. PRINT(KERN_ERR, ohci->id, "Failed to allocate at dma prg");
  1824. free_dma_trm_ctx(&d);
  1825. return NULL;
  1826. }
  1827. memset(d->prg_cpu, 0, d->num_desc * sizeof(struct at_dma_prg*));
  1828. memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t));
  1830. for (i=0; i<d->num_desc; i++) {
  1831.                 d->prg_cpu[i] = pci_alloc_consistent(ohci->dev, 
  1832.      sizeof(struct at_dma_prg),
  1833.      d->prg_bus+i);
  1834. OHCI_DMA_ALLOC("consistent dma_trm prg[%d]", i);
  1836.                 if (d->prg_cpu[i] != NULL) {
  1837.                         memset(d->prg_cpu[i], 0, sizeof(struct at_dma_prg));
  1838. } else {
  1839. PRINT(KERN_ERR, ohci->id, 
  1840.       "Failed to allocate at dma prg");
  1841. free_dma_trm_ctx(&d);
  1842. return NULL;
  1843. }
  1844. }
  1846.         spin_lock_init(&d->lock);
  1848.         /* initialize bottom handler */
  1849. tasklet_init (&d->task, dma_trm_tasklet, (unsigned long)d);
  1851. return d;
  1852. }
  1854. static u16 ohci_crc16 (u32 *ptr, int length)
  1855. {
  1856. int shift;
  1857. u32 crc, sum, data;
  1859. crc = 0;
  1860. for (; length > 0; length--) {
  1861. data = *ptr++;
  1862. for (shift = 28; shift >= 0; shift -= 4) {
  1863. sum = ((crc >> 12) ^ (data >> shift)) & 0x000f;
  1864. crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ sum;
  1865. }
  1866. crc &= 0xffff;
  1867. }
  1868. return crc;
  1869. }
  1871. /* Config ROM macro implementation influenced by NetBSD OHCI driver */
  1873. struct config_rom_unit {
  1874. u32 *start;
  1875. u32 *refer;
  1876. int length;
  1877. int refunit;
  1878. };
  1880. struct config_rom_ptr {
  1881. u32 *data;
  1882. int unitnum;
  1883. struct config_rom_unit unitdir[10];
  1884. };
  1886. #define cf_put_1quad(cr, q) (((cr)->data++)[0] = cpu_to_be32(q))
  1888. #define cf_put_4bytes(cr, b1, b2, b3, b4) 
  1889. (((cr)->data++)[0] = cpu_to_be32(((b1) << 24) | ((b2) << 16) | ((b3) << 8) | (b4)))
  1891. #define cf_put_keyval(cr, key, val) (((cr)->data++)[0] = cpu_to_be32(((key) << 24) | (val)))
  1893. static inline void cf_put_crc16(struct config_rom_ptr *cr, int unit)
  1894. {
  1895. *cr->unitdir[unit].start =
  1896. cpu_to_be32((cr->unitdir[unit].length << 16) |
  1897.     ohci_crc16(cr->unitdir[unit].start + 1,
  1898.        cr->unitdir[unit].length));
  1899. }
  1901. static inline void cf_unit_begin(struct config_rom_ptr *cr, int unit)
  1902. {
  1903. if (cr->unitdir[unit].refer != NULL) {
  1904. *cr->unitdir[unit].refer |=
  1905. cpu_to_be32 (cr->data - cr->unitdir[unit].refer);
  1906. cf_put_crc16(cr, cr->unitdir[unit].refunit);
  1907. }
  1908. cr->unitnum = unit;
  1909. cr->unitdir[unit].start = cr->data++;
  1910. }
  1912. static inline void cf_put_refer(struct config_rom_ptr *cr, char key, int unit)
  1913. {
  1914. cr->unitdir[unit].refer = cr->data;
  1915. cr->unitdir[unit].refunit = cr->unitnum;
  1916. (cr->data++)[0] = cpu_to_be32(key << 24);
  1917. }
  1919. static inline void cf_unit_end(struct config_rom_ptr *cr)
  1920. {
  1921. cr->unitdir[cr->unitnum].length = cr->data -
  1922. (cr->unitdir[cr->unitnum].start + 1);
  1923. cf_put_crc16(cr, cr->unitnum);
  1924. }
  1926. /* End of NetBSD derived code.  */
  1928. static void ohci_init_config_rom(struct ti_ohci *ohci)
  1929. {
  1930. struct config_rom_ptr cr;
  1932. memset(&cr, 0, sizeof(cr));
  1933. memset(ohci->csr_config_rom_cpu, 0, sizeof (ohci->csr_config_rom_cpu));
  1935. cr.data = ohci->csr_config_rom_cpu;
  1937. /* Bus info block */
  1938. cf_unit_begin(&cr, 0);
  1939. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_BusID));
  1940. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_BusOptions));
  1941. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_GUIDHi));
  1942. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_GUIDLo));
  1943. cf_unit_end(&cr);
  1945. DBGMSG(ohci->id, "GUID: %08x:%08x", reg_read(ohci, OHCI1394_GUIDHi),
  1946. reg_read(ohci, OHCI1394_GUIDLo));
  1948. /* IEEE P1212 suggests the initial ROM header CRC should only
  1949.  * cover the header itself (and not the entire ROM). Since we do
  1950.  * this, then we can make our bus_info_len the same as the CRC
  1951.  * length.  */
  1952. ohci->csr_config_rom_cpu[0] |= cpu_to_be32(
  1953. (be32_to_cpu(ohci->csr_config_rom_cpu[0]) & 0x00ff0000) << 8);
  1954. reg_write(ohci, OHCI1394_ConfigROMhdr,
  1955.   be32_to_cpu(ohci->csr_config_rom_cpu[0]));
  1957. /* Root directory */
  1958. cf_unit_begin(&cr, 1);
  1959. cf_put_keyval(&cr, 0x03, 0x00005e); /* Vendor ID */
  1960. cf_put_refer(&cr, 0x81, 2); /* Textual description unit */
  1961. cf_put_keyval(&cr, 0x0c, 0x0083c0); /* Node capabilities */
  1962. /* NOTE: Add other unit referers here, and append at bottom */
  1963. cf_unit_end(&cr);
  1965. /* Textual description - "Linux 1394" */
  1966. cf_unit_begin(&cr, 2);
  1967. cf_put_keyval(&cr, 0, 0);
  1968. cf_put_1quad(&cr, 0);
  1969. cf_put_4bytes(&cr, 'L', 'i', 'n', 'u');
  1970. cf_put_4bytes(&cr, 'x', ' ', '1', '3');
  1971. cf_put_4bytes(&cr, '9', '4', 0x0, 0x0);
  1972. cf_unit_end(&cr);
  1974. ohci->csr_config_rom_length = cr.data - ohci->csr_config_rom_cpu;
  1975. }
  1977. static size_t ohci_get_rom(struct hpsb_host *host, const quadlet_t **ptr)
  1978. {
  1979. struct ti_ohci *ohci=host->hostdata;
  1981. DBGMSG(ohci->id, "request csr_rom address: %p",
  1982. ohci->csr_config_rom_cpu);
  1984. *ptr = ohci->csr_config_rom_cpu;
  1986. return ohci->csr_config_rom_length * 4;
  1987. }
  1989. int ohci_compare_swap(struct ti_ohci *ohci, quadlet_t *data,
  1990.                       quadlet_t compare, int sel)
  1991. {
  1992. int i;
  1993. reg_write(ohci, OHCI1394_CSRData, *data);
  1994. reg_write(ohci, OHCI1394_CSRCompareData, compare);
  1995. reg_write(ohci, OHCI1394_CSRControl, sel & 0x3);
  1997. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  1998. if (reg_read(ohci, OHCI1394_CSRControl) & 0x80000000)
  1999. break;
  2001. mdelay(1);
  2002. }
  2004. *data = reg_read(ohci, OHCI1394_CSRData);
  2005. return 0;
  2006. }
  2008. static quadlet_t ohci_hw_csr_reg(struct hpsb_host *host, int reg,
  2009.                                  quadlet_t data, quadlet_t compare)
  2010. {
  2011. struct ti_ohci *ohci=host->hostdata;
  2013. ohci_compare_swap (ohci, &data, compare, reg);
  2015. return data;
  2016. }
  2018. static struct hpsb_host_template ohci_template = {
  2019. name: OHCI1394_DRIVER_NAME,
  2020. initialize_host: ohci_initialize,
  2021. release_host: ohci_remove,
  2022. get_rom: ohci_get_rom,
  2023. transmit_packet: ohci_transmit,
  2024. devctl: ohci_devctl,
  2025. hw_csr_reg: ohci_hw_csr_reg,
  2026. };
  2029. #define FAIL(fmt, args...)
  2030. do {
  2031. PRINT_G(KERN_ERR, fmt , ## args);
  2032. remove_card(ohci);
  2033. return 1;
  2034. } while(0)
  2036. static int __devinit ohci1394_add_one(struct pci_dev *dev, const struct pci_device_id *ent)
  2037. {
  2038. struct ti_ohci *ohci; /* shortcut to currently handled device */
  2039. struct hpsb_host *host;
  2040. unsigned long ohci_base, ohci_len;
  2041. static int version_printed = 0;
  2043. if (version_printed++ == 0)
  2044. PRINT_G(KERN_INFO, "%s", version);
  2046.         if (pci_enable_device(dev)) {
  2047. /* Skip ID's that fail */
  2048. PRINT_G(KERN_NOTICE, "Failed to enable OHCI hardware %d",
  2049. card_id_counter++);
  2050. return -ENXIO;
  2051.         }
  2052.         pci_set_master(dev);
  2054. host = hpsb_get_host(&ohci_template, sizeof (struct ti_ohci));
  2055. if (!host) {
  2056. PRINT_G(KERN_ERR, "Out of memory trying to allocate host structure");
  2057. return -ENOMEM;
  2058. }
  2059. ohci = host->hostdata;
  2060. ohci->host = host;
  2061. INIT_LIST_HEAD(&ohci->list);
  2062. ohci->id = card_id_counter++;
  2063. ohci->dev = dev;
  2064. host->pdev = dev;
  2065. ohci->host = host;
  2066. pci_set_drvdata(dev, ohci);
  2068. /* We don't want hardware swapping */
  2069. pci_write_config_dword(dev, OHCI1394_PCI_HCI_Control, 0);
  2071. /* Some oddball Apple controllers do not order the selfid
  2072.  * properly, so we make up for it here.  */
  2073. #ifndef __LITTLE_ENDIAN
  2074. /* XXX: Need a better way to check this. I'm wondering if we can
  2075.  * read the values of the OHCI1394_PCI_HCI_Control and the
  2076.  * noByteSwapData registers to see if they were not cleared to
  2077.  * zero. Should this work? Obviously it's not defined what these
  2078.  * registers will read when they aren't supported. Bleh! */
  2079. if (dev->vendor == PCI_VENDOR_ID_APPLE && 
  2080. dev->device == PCI_DEVICE_ID_APPLE_UNI_N_FW) {
  2081. ohci->no_swap_incoming = 1;
  2082. ohci->selfid_swap = 0;
  2083. } else
  2084. ohci->selfid_swap = 1;
  2085. #endif
  2087. /* csr_config rom allocation */
  2088. ohci->csr_config_rom_cpu = 
  2089. pci_alloc_consistent(ohci->dev, OHCI_CONFIG_ROM_LEN,
  2090.      &ohci->csr_config_rom_bus);
  2091. OHCI_DMA_ALLOC("consistent csr_config_rom");
  2092. if (ohci->csr_config_rom_cpu == NULL)
  2093. FAIL("Failed to allocate buffer config rom");
  2095. /* 
  2096.  * self-id dma buffer allocation
  2097.  */
  2098. ohci->selfid_buf_cpu = 
  2099. pci_alloc_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE,
  2100.                       &ohci->selfid_buf_bus);
  2101. OHCI_DMA_ALLOC("consistent selfid_buf");
  2102. if (ohci->selfid_buf_cpu == NULL)
  2103. FAIL("Failed to allocate DMA buffer for self-id packets");
  2105. if ((unsigned long)ohci->selfid_buf_cpu & 0x1fff)
  2106. PRINT(KERN_INFO, ohci->id, "SelfID buffer %p is not aligned on "
  2107.       "8Kb boundary... may cause problems on some CXD3222 chip", 
  2108.       ohci->selfid_buf_cpu);  
  2110. ohci->it_context =
  2111. alloc_dma_trm_ctx(ohci, 2, IT_NUM_DESC,
  2112.   OHCI1394_IsoXmitContextControlSet,
  2113.   OHCI1394_IsoXmitContextControlClear,
  2114.   OHCI1394_IsoXmitCommandPtr);
  2116. if (ohci->it_context == NULL)
  2117. FAIL("Failed to allocate IT context");
  2119. ohci_base = pci_resource_start(dev, 0);
  2120. ohci_len = pci_resource_len(dev, 0);
  2122. if (!request_mem_region (ohci_base, ohci_len, host->template->name))
  2123. FAIL("MMIO resource (0x%lx@0x%lx) unavailable, aborting.",
  2124.      ohci_base, ohci_len);
  2126. ohci->registers = ioremap(ohci_base, ohci_len);
  2128. if (ohci->registers == NULL)
  2129. FAIL("Failed to remap registers - card not accessible");
  2131. DBGMSG(ohci->id, "Remapped memory spaces reg 0x%p",
  2132.       ohci->registers);
  2134. ohci->ar_req_context = 
  2135. alloc_dma_rcv_ctx(ohci, 0, AR_REQ_NUM_DESC,
  2136.   AR_REQ_BUF_SIZE, AR_REQ_SPLIT_BUF_SIZE,
  2137.   OHCI1394_AsReqRcvContextControlSet,
  2138.   OHCI1394_AsReqRcvContextControlClear,
  2139.   OHCI1394_AsReqRcvCommandPtr);
  2141. if (ohci->ar_req_context == NULL)
  2142. FAIL("Failed to allocate AR Req context");
  2144. ohci->ar_resp_context = 
  2145. alloc_dma_rcv_ctx(ohci, 1, AR_RESP_NUM_DESC,
  2146.   AR_RESP_BUF_SIZE, AR_RESP_SPLIT_BUF_SIZE,
  2147.   OHCI1394_AsRspRcvContextControlSet,
  2148.   OHCI1394_AsRspRcvContextControlClear,
  2149.   OHCI1394_AsRspRcvCommandPtr);
  2151. if (ohci->ar_resp_context == NULL)
  2152. FAIL("Failed to allocate AR Resp context");
  2154. ohci->at_req_context = 
  2155. alloc_dma_trm_ctx(ohci, 0, AT_REQ_NUM_DESC,
  2156.   OHCI1394_AsReqTrContextControlSet,
  2157.   OHCI1394_AsReqTrContextControlClear,
  2158.   OHCI1394_AsReqTrCommandPtr);
  2160. if (ohci->at_req_context == NULL)
  2161. FAIL("Failed to allocate AT Req context");
  2163. ohci->at_resp_context = 
  2164. alloc_dma_trm_ctx(ohci, 1, AT_RESP_NUM_DESC,
  2165.   OHCI1394_AsRspTrContextControlSet,
  2166.   OHCI1394_AsRspTrContextControlClear,
  2167.   OHCI1394_AsRspTrCommandPtr);
  2169. if (ohci->at_resp_context == NULL)
  2170. FAIL("Failed to allocate AT Resp context");
  2172. ohci->ir_context =
  2173. alloc_dma_rcv_ctx(ohci, 2, IR_NUM_DESC,
  2174.   IR_BUF_SIZE, IR_SPLIT_BUF_SIZE,
  2175.   OHCI1394_IsoRcvContextControlSet,
  2176.   OHCI1394_IsoRcvContextControlClear,
  2177.   OHCI1394_IsoRcvCommandPtr);
  2179. if (ohci->ir_context == NULL)
  2180. FAIL("Failed to allocate IR context");
  2182. ohci->ISO_channel_usage = 0;
  2183.         spin_lock_init(&ohci->IR_channel_lock);
  2185. if (request_irq(dev->irq, ohci_irq_handler, SA_SHIRQ,
  2186.  OHCI1394_DRIVER_NAME, ohci))
  2187. FAIL("Failed to allocate shared interrupt %d", dev->irq);
  2189. /* Tell the highlevel this host is ready */
  2190. highlevel_add_one_host (host);
  2192. return 0;
  2193. #undef FAIL
  2194. }
  2196. static void remove_card(struct ti_ohci *ohci)
  2197. {
  2198. quadlet_t buf;
  2200. /* Soft reset before we start */
  2201. ohci_soft_reset(ohci);
  2203. /* Free AR dma */
  2204. free_dma_rcv_ctx(&ohci->ar_req_context);
  2205. free_dma_rcv_ctx(&ohci->ar_resp_context);
  2207. /* Free AT dma */
  2208. free_dma_trm_ctx(&ohci->at_req_context);
  2209. free_dma_trm_ctx(&ohci->at_resp_context);
  2211. /* Free IR dma */
  2212. free_dma_rcv_ctx(&ohci->ir_context);
  2214.         /* Free IT dma */
  2215.         free_dma_trm_ctx(&ohci->it_context);
  2217. /* Disable all interrupts */
  2218. reg_write(ohci, OHCI1394_IntMaskClear, 0x80000000);
  2219. free_irq(ohci->dev->irq, ohci);
  2221. /* Free self-id buffer */
  2222. if (ohci->selfid_buf_cpu) {
  2223. pci_free_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE, 
  2224.     ohci->selfid_buf_cpu,
  2225.     ohci->selfid_buf_bus);
  2226. OHCI_DMA_FREE("consistent selfid_buf");
  2227. }
  2229. /* Free config rom */
  2230. if (ohci->csr_config_rom_cpu) {
  2231. pci_free_consistent(ohci->dev, OHCI_CONFIG_ROM_LEN,
  2232.     ohci->csr_config_rom_cpu, 
  2233.     ohci->csr_config_rom_bus);
  2234. OHCI_DMA_FREE("consistent csr_config_rom");
  2235. }
  2237. /* Disable our bus options */
  2238. buf = reg_read(ohci, OHCI1394_BusOptions);
  2239. buf &= ~0xf8000000;
  2240. buf |=  0x00ff0000;
  2241. reg_write(ohci, OHCI1394_BusOptions, buf);
  2243. /* Clear LinkEnable and LPS */
  2244. reg_write(ohci, OHCI1394_HCControlClear, 0x000a0000);
  2246. if (ohci->registers)
  2247. iounmap(ohci->registers);
  2249. release_mem_region (pci_resource_start(ohci->dev, 0),
  2250.     pci_resource_len(ohci->dev, 0));
  2252. #ifdef CONFIG_ALL_PPC
  2253. /* On UniNorth, power down the cable and turn off the
  2254.  * chip clock when the module is removed to save power
  2255.  * on laptops. Turning it back ON is done by the arch
  2256.  * code when pci_enable_device() is called
  2257.  */
  2258. {
  2259. struct device_node* of_node;
  2261. of_node = pci_device_to_OF_node(ohci->dev);
  2262. if (of_node) {
  2263. pmac_call_feature(PMAC_FTR_1394_ENABLE, of_node, 0, 0);
  2264. pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, of_node, 0, 0);
  2265. }
  2266. }
  2267. #endif /* CONFIG_ALL_PPC */
  2269. pci_set_drvdata(ohci->dev, NULL);
  2270. }
  2272. void ohci1394_stop_context(struct ti_ohci *ohci, int reg, char *msg)
  2273. {
  2274. int i=0;
  2276. /* stop the channel program if it's still running */
  2277. reg_write(ohci, reg, 0x8000);
  2278.    
  2279. /* Wait until it effectively stops */
  2280. while (reg_read(ohci, reg) & 0x400) {
  2281. i++;
  2282. if (i>5000) {
  2283. PRINT(KERN_ERR, ohci->id, 
  2284.       "Runaway loop while stopping context...");
  2285. break;
  2286. }
  2287. }
  2288. if (msg) PRINT(KERN_ERR, ohci->id, "%s: dma prg stopped", msg);
  2289. }
  2291. int ohci1394_register_video(struct ti_ohci *ohci,
  2292.     struct video_template *tmpl)
  2293. {
  2294. if (ohci->video_tmpl)
  2295. return -ENFILE;
  2296. ohci->video_tmpl = tmpl;
  2297. MOD_INC_USE_COUNT;
  2298. return 0;
  2299. }
  2301. void ohci1394_unregister_video(struct ti_ohci *ohci,
  2302.        struct video_template *tmpl)
  2303. {
  2304. if (ohci->video_tmpl != tmpl) {
  2305. PRINT(KERN_ERR, ohci->id, 
  2306.       "Trying to unregister wrong video device");
  2307. } else {
  2308. ohci->video_tmpl = NULL;
  2309. MOD_DEC_USE_COUNT;
  2310. }
  2311. }
  2313. #if 0
  2314. int ohci1394_request_channel(struct ti_ohci *ohci, int channel)
  2315. {
  2316. int csrSel;
  2317. quadlet_t chan, data1=0, data2=0;
  2318. int timeout = 32;
  2320. if (channel<32) {
  2321. chan = 1<<channel;
  2322. csrSel = 2;
  2323. }
  2324. else {
  2325. chan = 1<<(channel-32);
  2326. csrSel = 3;
  2327. }
  2328. if (ohci_compare_swap(ohci, &data1, 0, csrSel)<0) {
  2329. PRINT(KERN_INFO, ohci->id, "request_channel timeout");
  2330. return -1;
  2331. }
  2332. while (timeout--) {
  2333. if (data1 & chan) {
  2334. PRINT(KERN_INFO, ohci->id, 
  2335.       "request channel %d failed", channel);
  2336. return -1;
  2337. }
  2338. data2 = data1;
  2339. data1 |= chan;
  2340. if (ohci_compare_swap(ohci, &data1, data2, csrSel)<0) {
  2341. PRINT(KERN_INFO, ohci->id, "request_channel timeout");
  2342. return -1;
  2343. }
  2344. if (data1==data2) {
  2345. PRINT(KERN_INFO, ohci->id, 
  2346.       "request channel %d succeded", channel);
  2347. return 0;
  2348. }
  2349. }
  2350. PRINT(KERN_INFO, ohci->id, "request channel %d failed", channel);
  2351. return -1;
  2352. }
  2353. #endif
  2355. EXPORT_SYMBOL(ohci1394_stop_context);
  2356. EXPORT_SYMBOL(ohci1394_register_video);
  2357. EXPORT_SYMBOL(ohci1394_unregister_video);
  2359. MODULE_AUTHOR("Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>");
  2360. MODULE_DESCRIPTION("Driver for PCI OHCI IEEE-1394 controllers");
  2361. MODULE_LICENSE("GPL");
  2363. static void __devexit ohci1394_remove_one(struct pci_dev *pdev)
  2364. {
  2365. struct ti_ohci *ohci = pci_get_drvdata(pdev);
  2367. if (ohci) {
  2368. remove_card (ohci);
  2369. pci_set_drvdata(pdev, NULL);
  2370. }
  2371. }
  2373. static struct pci_driver ohci1394_driver = {
  2374. name: OHCI1394_DRIVER_NAME,
  2375. id_table: ohci1394_pci_tbl,
  2376. probe: ohci1394_add_one,
  2377. remove: __devexit_p(ohci1394_remove_one),
  2378. };
  2380. static void __exit ohci1394_cleanup (void)
  2381. {
  2382. hpsb_unregister_lowlevel(&ohci_template);
  2383. pci_unregister_driver(&ohci1394_driver);
  2384. }
  2386. static int __init ohci1394_init(void)
  2387. {
  2388. int ret;
  2389. if (hpsb_register_lowlevel(&ohci_template)) {
  2390. PRINT_G(KERN_ERR, "Registering failed");
  2391. return -ENXIO;
  2392. }
  2393. if ((ret = pci_module_init(&ohci1394_driver))) {
  2394. PRINT_G(KERN_ERR, "PCI module init failed");
  2395. hpsb_unregister_lowlevel(&ohci_template);
  2396. return ret;
  2397. }
  2398. return ret;
  2399. }
  2401. module_init(ohci1394_init);
  2402. module_exit(ohci1394_cleanup);