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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ohci1394.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：68k
源码类别：

Linux/Unix编程

开发平台：

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.  * . devctl BUS_RESET arg confusion (reset type or root holdoff?)
  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/uaccess.h>
  94. #include <linux/tqueue.h>
  95. #include <linux/delay.h>
  96. #include <linux/spinlock.h>
  98. #include <asm/pgtable.h>
  99. #include <asm/page.h>
  100. #include <linux/sched.h>
  101. #include <linux/types.h>
  102. #include <linux/wrapper.h>
  103. #include <linux/vmalloc.h>
  104. #include <linux/init.h>
  106. #ifdef CONFIG_ALL_PPC
  107. #include <asm/machdep.h>
  108. #include <asm/pmac_feature.h>
  109. #include <asm/prom.h>
  110. #include <asm/pci-bridge.h>
  111. #endif
  113. #include "ieee1394.h"
  114. #include "ieee1394_types.h"
  115. #include "hosts.h"
  116. #include "ieee1394_core.h"
  117. #include "highlevel.h"
  118. #include "ohci1394.h"
  120. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  121. #define OHCI1394_DEBUG
  122. #endif
  124. #ifdef DBGMSG
  125. #undef DBGMSG
  126. #endif
  128. #ifdef OHCI1394_DEBUG
  129. #define DBGMSG(card, fmt, args...) 
  130. printk(KERN_INFO "%s_%d: " fmt "n" , OHCI1394_DRIVER_NAME, card , ## args)
  131. #else
  132. #define DBGMSG(card, fmt, args...)
  133. #endif
  135. #ifdef CONFIG_IEEE1394_OHCI_DMA_DEBUG
  136. #define OHCI_DMA_ALLOC(fmt, args...) 
  137. HPSB_ERR("%s(%s)alloc(%d): "fmt, OHCI1394_DRIVER_NAME, __FUNCTION__, 
  138. ++global_outstanding_dmas, ## args)
  139. #define OHCI_DMA_FREE(fmt, args...) 
  140. HPSB_ERR("%s(%s)free(%d): "fmt, OHCI1394_DRIVER_NAME, __FUNCTION__, 
  141. --global_outstanding_dmas, ## args)
  142. u32 global_outstanding_dmas = 0;
  143. #else
  144. #define OHCI_DMA_ALLOC(fmt, args...)
  145. #define OHCI_DMA_FREE(fmt, args...)
  146. #endif
  148. /* print general (card independent) information */
  149. #define PRINT_G(level, fmt, args...) 
  150. printk(level "%s: " fmt "n" , OHCI1394_DRIVER_NAME , ## args)
  152. /* print card specific information */
  153. #define PRINT(level, card, fmt, args...) 
  154. printk(level "%s_%d: " fmt "n" , OHCI1394_DRIVER_NAME, card , ## args)
  156. static char version[] __devinitdata =
  157. "$Rev: 578 $ Ben Collins <bcollins@debian.org>";
  159. /* Module Parameters */
  160. MODULE_PARM(attempt_root,"i");
  161. MODULE_PARM_DESC(attempt_root, "Attempt to make the host root (default = 0).");
  162. static int attempt_root = 0;
  164. MODULE_PARM(phys_dma,"i");
  165. MODULE_PARM_DESC(phys_dma, "Enable physical dma (default = 1).");
  166. static int phys_dma = 1;
  168. static void dma_trm_tasklet(unsigned long data);
  169. static void dma_trm_reset(struct dma_trm_ctx *d);
  171. static void ohci1394_pci_remove(struct pci_dev *pdev);
  173. #ifndef __LITTLE_ENDIAN
  174. /* Swap a series of quads inplace. */
  175. static __inline__ void block_swab32(quadlet_t *data, size_t size) {
  176. while (size--)
  177. data[size] = swab32(data[size]);
  178. }
  180. static unsigned hdr_sizes[] = 
  181. {
  182. 3, /* TCODE_WRITEQ */
  183. 4, /* TCODE_WRITEB */
  184. 3, /* TCODE_WRITE_RESPONSE */
  185. 0, /* ??? */
  186. 3, /* TCODE_READQ */
  187. 4, /* TCODE_READB */
  188. 3, /* TCODE_READQ_RESPONSE */
  189. 4, /* TCODE_READB_RESPONSE */
  190. 1, /* TCODE_CYCLE_START (???) */
  191. 4, /* TCODE_LOCK_REQUEST */
  192. 2, /* TCODE_ISO_DATA */
  193. 4, /* TCODE_LOCK_RESPONSE */
  194. };
  196. /* Swap headers */
  197. static inline void packet_swab(quadlet_t *data, int tcode, int len)
  198. {
  199. if (tcode > TCODE_LOCK_RESPONSE || hdr_sizes[tcode] == 0)
  200. return;
  201. block_swab32(data, hdr_sizes[tcode]);
  202. }
  203. #else
  204. /* Don't waste cycles on same sex byte swaps */
  205. #define packet_swab(w,x,y)
  206. #define block_swab32(x,y)
  207. #endif /* !LITTLE_ENDIAN */
  209. /***********************************
  210.  * IEEE-1394 functionality section *
  211.  ***********************************/
  213. static u8 get_phy_reg(struct ti_ohci *ohci, u8 addr) 
  214. {
  215. int i;
  216. unsigned long flags;
  217. quadlet_t r;
  219. spin_lock_irqsave (&ohci->phy_reg_lock, flags);
  221. reg_write(ohci, OHCI1394_PhyControl, (addr << 8) | 0x00008000);
  223. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  224. if (reg_read(ohci, OHCI1394_PhyControl) & 0x80000000)
  225. break;
  227. mdelay(1);
  228. }
  230. r = reg_read(ohci, OHCI1394_PhyControl);
  232. if (i >= OHCI_LOOP_COUNT)
  233. PRINT (KERN_ERR, ohci->id, "Get PHY Reg timeout [0x%08x/0x%08x/%d]",
  234.        r, r & 0x80000000, i);
  235.   
  236. spin_unlock_irqrestore (&ohci->phy_reg_lock, flags);
  237.      
  238. return (r & 0x00ff0000) >> 16;
  239. }
  241. static void set_phy_reg(struct ti_ohci *ohci, u8 addr, u8 data)
  242. {
  243. int i;
  244. unsigned long flags;
  245. u32 r = 0;
  247. spin_lock_irqsave (&ohci->phy_reg_lock, flags);
  249. reg_write(ohci, OHCI1394_PhyControl, (addr << 8) | data | 0x00004000);
  251. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  252. r = reg_read(ohci, OHCI1394_PhyControl);
  253. if (!(r & 0x00004000))
  254. break;
  256. mdelay(1);
  257. }
  259. if (i == OHCI_LOOP_COUNT)
  260. PRINT (KERN_ERR, ohci->id, "Set PHY Reg timeout [0x%08x/0x%08x/%d]",
  261.        r, r & 0x00004000, i);
  263. spin_unlock_irqrestore (&ohci->phy_reg_lock, flags);
  265. return;
  266. }
  268. /* Or's our value into the current value */
  269. static void set_phy_reg_mask(struct ti_ohci *ohci, u8 addr, u8 data)
  270. {
  271. u8 old;
  273. old = get_phy_reg (ohci, addr);
  274. old |= data;
  275. set_phy_reg (ohci, addr, old);
  277. return;
  278. }
  280. static void handle_selfid(struct ti_ohci *ohci, struct hpsb_host *host,
  281. int phyid, int isroot)
  282. {
  283. quadlet_t *q = ohci->selfid_buf_cpu;
  284. quadlet_t self_id_count=reg_read(ohci, OHCI1394_SelfIDCount);
  285. size_t size;
  286. quadlet_t q0, q1;
  288. /* Check status of self-id reception */
  290. if (ohci->selfid_swap)
  291. q0 = le32_to_cpu(q[0]);
  292. else
  293. q0 = q[0];
  295. if ((self_id_count & 0x80000000) || 
  296.     ((self_id_count & 0x00FF0000) != (q0 & 0x00FF0000))) {
  297. PRINT(KERN_ERR, ohci->id, 
  298.       "Error in reception of SelfID packets [0x%08x/0x%08x] (count: %d)",
  299.       self_id_count, q0, ohci->self_id_errors);
  301. /* Tip by James Goodwin <jamesg@Filanet.com>:
  302.  * We had an error, generate another bus reset in response.  */
  303. if (ohci->self_id_errors<OHCI1394_MAX_SELF_ID_ERRORS) {
  304. set_phy_reg_mask (ohci, 1, 0x40);
  305. ohci->self_id_errors++;
  306. } else {
  307. PRINT(KERN_ERR, ohci->id, 
  308.       "Too many errors on SelfID error reception, giving up!");
  309. }
  310. return;
  311. }
  313. /* SelfID Ok, reset error counter. */
  314. ohci->self_id_errors = 0;
  316. size = ((self_id_count & 0x00001FFC) >> 2) - 1;
  317. q++;
  319. while (size > 0) {
  320. if (ohci->selfid_swap) {
  321. q0 = le32_to_cpu(q[0]);
  322. q1 = le32_to_cpu(q[1]);
  323. } else {
  324. q0 = q[0];
  325. q1 = q[1];
  326. }
  328. if (q0 == ~q1) {
  329. DBGMSG (ohci->id, "SelfID packet 0x%x received", q0);
  330. hpsb_selfid_received(host, cpu_to_be32(q0));
  331. if (((q0 & 0x3f000000) >> 24) == phyid)
  332. DBGMSG (ohci->id, "SelfID for this node is 0x%08x", q0);
  333. } else {
  334. PRINT(KERN_ERR, ohci->id,
  335.       "SelfID is inconsistent [0x%08x/0x%08x]", q0, q1);
  336. }
  337. q += 2;
  338. size -= 2;
  339. }
  341. DBGMSG(ohci->id, "SelfID complete");
  343. hpsb_selfid_complete(host, phyid, isroot);
  345. return;
  346. }
  348. static void ohci_soft_reset(struct ti_ohci *ohci) {
  349. int i;
  351. reg_write(ohci, OHCI1394_HCControlSet, 0x00010000);
  352.   
  353. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  354. if (reg_read(ohci, OHCI1394_HCControlSet) & 0x00010000)
  355. break;
  356. mdelay(1);
  357. }
  358. DBGMSG (ohci->id, "Soft reset finished");
  359. }
  361. static int run_context(struct ti_ohci *ohci, int reg, char *msg)
  362. {
  363. u32 nodeId;
  365. /* check that the node id is valid */
  366. nodeId = reg_read(ohci, OHCI1394_NodeID);
  367. if (!(nodeId&0x80000000)) {
  368. PRINT(KERN_ERR, ohci->id, 
  369.       "Running dma failed because Node ID is not valid");
  370. return -1;
  371. }
  373. /* check that the node number != 63 */
  374. if ((nodeId&0x3f)==63) {
  375. PRINT(KERN_ERR, ohci->id, 
  376.       "Running dma failed because Node ID == 63");
  377. return -1;
  378. }
  380. /* Run the dma context */
  381. reg_write(ohci, reg, 0x8000);
  383. if (msg) PRINT(KERN_DEBUG, ohci->id, "%s", msg);
  385. return 0;
  386. }
  388. /* Generate the dma receive prgs and start the context */
  389. static void initialize_dma_rcv_ctx(struct dma_rcv_ctx *d, int generate_irq)
  390. {
  391. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  392. int i;
  394. ohci1394_stop_context(ohci, d->ctrlClear, NULL);
  396. for (i=0; i<d->num_desc; i++) {
  397. u32 c;
  399. c = DMA_CTL_INPUT_MORE | DMA_CTL_UPDATE | DMA_CTL_BRANCH;
  400. if (generate_irq)
  401. c |= DMA_CTL_IRQ;
  403. d->prg_cpu[i]->control = cpu_to_le32(c | d->buf_size);
  405. /* End of descriptor list? */
  406. if (i + 1 < d->num_desc) {
  407. d->prg_cpu[i]->branchAddress =
  408. cpu_to_le32((d->prg_bus[i+1] & 0xfffffff0) | 0x1);
  409. } else {
  410. d->prg_cpu[i]->branchAddress =
  411. cpu_to_le32((d->prg_bus[0] & 0xfffffff0));
  412. }
  414. d->prg_cpu[i]->address = cpu_to_le32(d->buf_bus[i]);
  415. d->prg_cpu[i]->status = cpu_to_le32(d->buf_size);
  416. }
  418.         d->buf_ind = 0;
  419.         d->buf_offset = 0;
  421. /* Tell the controller where the first AR program is */
  422. reg_write(ohci, d->cmdPtr, d->prg_bus[0] | 0x1);
  424. /* Run AR context */
  425. reg_write(ohci, d->ctrlSet, 0x00008000);
  427. DBGMSG(ohci->id, "Receive DMA ctx=%d initialized", d->ctx);
  428. }
  430. /* Initialize the dma transmit context */
  431. static void initialize_dma_trm_ctx(struct dma_trm_ctx *d)
  432. {
  433. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  435. /* Stop the context */
  436. ohci1394_stop_context(ohci, d->ctrlClear, NULL);
  438.         d->prg_ind = 0;
  439. d->sent_ind = 0;
  440. d->free_prgs = d->num_desc;
  441.         d->branchAddrPtr = NULL;
  442. INIT_LIST_HEAD(&d->fifo_list);
  443. INIT_LIST_HEAD(&d->pending_list);
  445. DBGMSG(ohci->id, "Transmit DMA ctx=%d initialized", d->ctx);
  446. }
  448. /* Count the number of available iso contexts */
  449. static int get_nb_iso_ctx(struct ti_ohci *ohci, int reg)
  450. {
  451. int i,ctx=0;
  452. u32 tmp;
  454. reg_write(ohci, reg, 0xffffffff);
  455. tmp = reg_read(ohci, reg);
  457. DBGMSG(ohci->id,"Iso contexts reg: %08x implemented: %08x", reg, tmp);
  459. /* Count the number of contexts */
  460. for(i=0; i<32; i++) {
  461.      if(tmp & 1) ctx++;
  462. tmp >>= 1;
  463. }
  464. return ctx;
  465. }
  467. static void ohci_init_config_rom(struct ti_ohci *ohci);
  469. /* Global initialization */
  470. static void ohci_initialize(struct ti_ohci *ohci)
  471. {
  472. quadlet_t buf;
  474. spin_lock_init(&ohci->phy_reg_lock);
  475. spin_lock_init(&ohci->event_lock);
  476.   
  477. /* Put some defaults to these undefined bus options */
  478. buf = reg_read(ohci, OHCI1394_BusOptions);
  479. buf |=  0xE0000000; /* Enable IRMC, CMC and ISC */
  480. buf &= ~0x00ff0000; /* XXX: Set cyc_clk_acc to zero for now */
  481. buf &= ~0x18000000; /* Disable PMC and BMC */
  482. reg_write(ohci, OHCI1394_BusOptions, buf);
  484. /* Set the bus number */
  485. reg_write(ohci, OHCI1394_NodeID, 0x0000ffc0);
  487. /* Enable posted writes */
  488. reg_write(ohci, OHCI1394_HCControlSet, 0x00040000);
  490. /* Clear link control register */
  491. reg_write(ohci, OHCI1394_LinkControlClear, 0xffffffff);
  492.   
  493. /* Enable cycle timer and cycle master and set the IRM
  494.  * contender bit in our self ID packets. */
  495. reg_write(ohci, OHCI1394_LinkControlSet, 0x00300000);
  496. set_phy_reg_mask(ohci, 4, 0xc0);
  498. /* Clear interrupt registers */
  499. reg_write(ohci, OHCI1394_IntMaskClear, 0xffffffff);
  500. reg_write(ohci, OHCI1394_IntEventClear, 0xffffffff);
  502. /* Set up self-id dma buffer */
  503. reg_write(ohci, OHCI1394_SelfIDBuffer, ohci->selfid_buf_bus);
  505. /* enable self-id dma */
  506. reg_write(ohci, OHCI1394_LinkControlSet, 0x00000200);
  508. /* Set the Config ROM mapping register */
  509. reg_write(ohci, OHCI1394_ConfigROMmap, ohci->csr_config_rom_bus);
  511. /* Initialize the Config ROM */
  512. ohci_init_config_rom(ohci);
  514. /* Now get our max packet size */
  515. ohci->max_packet_size = 
  516. 1<<(((reg_read(ohci, OHCI1394_BusOptions)>>12)&0xf)+1);
  518. /* Don't accept phy packets into AR request context */ 
  519. reg_write(ohci, OHCI1394_LinkControlClear, 0x00000400);
  521. /* Set bufferFill, isochHeader, multichannel for IR context */
  522. reg_write(ohci, OHCI1394_IsoRcvContextControlSet, 0xd0000000);
  524. /* Set the context match register to match on all tags */
  525. reg_write(ohci, OHCI1394_IsoRcvContextMatch, 0xf0000000);
  527. /* Clear the interrupt mask */
  528. reg_write(ohci, OHCI1394_IsoRecvIntMaskClear, 0xffffffff);
  529. reg_write(ohci, OHCI1394_IsoRecvIntEventClear, 0xffffffff);
  531. /* Clear the interrupt mask */
  532. reg_write(ohci, OHCI1394_IsoXmitIntMaskClear, 0xffffffff);
  533. reg_write(ohci, OHCI1394_IsoXmitIntEventClear, 0xffffffff);
  535. /* Clear the multi channel mask high and low registers */
  536. reg_write(ohci, OHCI1394_IRMultiChanMaskHiClear, 0xffffffff);
  537. reg_write(ohci, OHCI1394_IRMultiChanMaskLoClear, 0xffffffff);
  539. /* Initialize AR dma */
  540. initialize_dma_rcv_ctx(&ohci->ar_req_context, 0);
  541. initialize_dma_rcv_ctx(&ohci->ar_resp_context, 0);
  543. /* Initialize AT dma */
  544. initialize_dma_trm_ctx(&ohci->at_req_context);
  545. initialize_dma_trm_ctx(&ohci->at_resp_context);
  547. /* Initialize IR dma */
  548. initialize_dma_rcv_ctx(&ohci->ir_context, 1);
  550.         /* Initialize IT dma */
  551.         initialize_dma_trm_ctx(&ohci->it_context);
  553. /* Set up isoRecvIntMask to generate interrupts for context 0
  554.    (thanks to Michael Greger for seeing that I forgot this) */
  555. reg_write(ohci, OHCI1394_IsoRecvIntMaskSet, 0x00000001);
  557. /* Set up isoXmitIntMask to generate interrupts for context 0 */
  558. reg_write(ohci, OHCI1394_IsoXmitIntMaskSet, 0x00000001);
  560. /* 
  561.  * Accept AT requests from all nodes. This probably 
  562.  * will have to be controlled from the subsystem
  563.  * on a per node basis.
  564.  */
  565. reg_write(ohci,OHCI1394_AsReqFilterHiSet, 0x80000000);
  567. /* Specify AT retries */
  568. reg_write(ohci, OHCI1394_ATRetries, 
  569.   OHCI1394_MAX_AT_REQ_RETRIES |
  570.   (OHCI1394_MAX_AT_RESP_RETRIES<<4) |
  571.   (OHCI1394_MAX_PHYS_RESP_RETRIES<<8));
  573. /* We don't want hardware swapping */
  574. reg_write(ohci, OHCI1394_HCControlClear, 0x40000000);
  576. /* Enable interrupts */
  577. reg_write(ohci, OHCI1394_IntMaskSet, 
  578.   OHCI1394_masterIntEnable | 
  579.   OHCI1394_busReset | 
  580.   OHCI1394_selfIDComplete |
  581.   OHCI1394_RSPkt |
  582.   OHCI1394_RQPkt |
  583.   OHCI1394_respTxComplete |
  584.   OHCI1394_reqTxComplete |
  585.   OHCI1394_isochRx |
  586.   OHCI1394_isochTx |
  587.   OHCI1394_cycleInconsistent);
  589. /* Enable link */
  590. reg_write(ohci, OHCI1394_HCControlSet, 0x00020000);
  592. buf = reg_read(ohci, OHCI1394_Version);
  593. PRINT(KERN_INFO, ohci->id, "OHCI-1394 %d.%d (PCI): IRQ=[%d]  "
  594.       "MMIO=[%lx-%lx]  Max Packet=[%d]",
  595.       ((((buf) >> 16) & 0xf) + (((buf) >> 20) & 0xf) * 10),
  596.       ((((buf) >> 4) & 0xf) + ((buf) & 0xf) * 10), ohci->dev->irq,
  597.       pci_resource_start(ohci->dev, 0),
  598.       pci_resource_start(ohci->dev, 0) + OHCI1394_REGISTER_SIZE - 1,
  599.       ohci->max_packet_size);
  600. }
  602. /* 
  603.  * Insert a packet in the AT DMA fifo and generate the DMA prg
  604.  * FIXME: rewrite the program in order to accept packets crossing
  605.  *        page boundaries.
  606.  *        check also that a single dma descriptor doesn't cross a 
  607.  *        page boundary.
  608.  */
  609. static void insert_packet(struct ti_ohci *ohci,
  610.   struct dma_trm_ctx *d, struct hpsb_packet *packet)
  611. {
  612. u32 cycleTimer;
  613. int idx = d->prg_ind;
  615. DBGMSG(ohci->id, "Inserting packet for node %d, tlabel=%d, tcode=0x%x, speed=%d",
  616. packet->node_id, packet->tlabel, packet->tcode, packet->speed_code);
  618. d->prg_cpu[idx]->begin.address = 0;
  619. d->prg_cpu[idx]->begin.branchAddress = 0;
  621. if (d->type == DMA_CTX_ASYNC_RESP) {
  622. /* 
  623.  * For response packets, we need to put a timeout value in
  624.  * the 16 lower bits of the status... let's try 1 sec timeout 
  625.  */ 
  626. cycleTimer = reg_read(ohci, OHCI1394_IsochronousCycleTimer);
  627. d->prg_cpu[idx]->begin.status = cpu_to_le32(
  628. (((((cycleTimer>>25)&0x7)+1)&0x7)<<13) | 
  629. ((cycleTimer&0x01fff000)>>12));
  631. DBGMSG(ohci->id, "cycleTimer: %08x timeStamp: %08x",
  632.        cycleTimer, d->prg_cpu[idx]->begin.status);
  633. } else 
  634. d->prg_cpu[idx]->begin.status = 0;
  636.         if ( (packet->type == hpsb_async) || (packet->type == hpsb_raw) ) {
  638.                 if (packet->type == hpsb_raw) {
  639. d->prg_cpu[idx]->data[0] = cpu_to_le32(OHCI1394_TCODE_PHY<<4);
  640.                         d->prg_cpu[idx]->data[1] = packet->header[0];
  641.                         d->prg_cpu[idx]->data[2] = packet->header[1];
  642.                 } else {
  643.                         d->prg_cpu[idx]->data[0] = packet->speed_code<<16 |
  644.                                 (packet->header[0] & 0xFFFF);
  645.                         d->prg_cpu[idx]->data[1] =
  646.                                 (packet->header[1] & 0xFFFF) | 
  647.                                 (packet->header[0] & 0xFFFF0000);
  648.                         d->prg_cpu[idx]->data[2] = packet->header[2];
  649.                         d->prg_cpu[idx]->data[3] = packet->header[3];
  650. packet_swab(d->prg_cpu[idx]->data, packet->tcode,
  651. packet->header_size>>2);
  652.                 }
  654.                 if (packet->data_size) { /* block transmit */
  655.                         d->prg_cpu[idx]->begin.control =
  656.                                 cpu_to_le32(DMA_CTL_OUTPUT_MORE |
  657.     DMA_CTL_IMMEDIATE | 0x10);
  658.                         d->prg_cpu[idx]->end.control =
  659.                                 cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  660.     DMA_CTL_IRQ | 
  661.     DMA_CTL_BRANCH |
  662.     packet->data_size);
  663.                         /* 
  664.                          * Check that the packet data buffer
  665.                          * does not cross a page boundary.
  666.                          */
  667.                         if (cross_bound((unsigned long)packet->data, 
  668.                                         packet->data_size)>0) {
  669.                                 /* FIXME: do something about it */
  670.                                 PRINT(KERN_ERR, ohci->id,
  671.                                       "%s: packet data addr: %p size %Zd bytes "
  672.                                       "cross page boundary", __FUNCTION__,
  673.                                       packet->data, packet->data_size);
  674.                         }
  676.                         d->prg_cpu[idx]->end.address = cpu_to_le32(
  677.                                 pci_map_single(ohci->dev, packet->data,
  678.                                                packet->data_size,
  679.                                                PCI_DMA_TODEVICE));
  680. OHCI_DMA_ALLOC("single, block transmit packet");
  682.                         d->prg_cpu[idx]->end.branchAddress = 0;
  683.                         d->prg_cpu[idx]->end.status = 0;
  684.                         if (d->branchAddrPtr) 
  685.                                 *(d->branchAddrPtr) =
  686. cpu_to_le32(d->prg_bus[idx] | 0x3);
  687.                         d->branchAddrPtr =
  688.                                 &(d->prg_cpu[idx]->end.branchAddress);
  689.                 } else { /* quadlet transmit */
  690.                         if (packet->type == hpsb_raw)
  691.                                 d->prg_cpu[idx]->begin.control = 
  692. cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  693.     DMA_CTL_IMMEDIATE |
  694.     DMA_CTL_IRQ | 
  695.     DMA_CTL_BRANCH |
  696.     (packet->header_size + 4));
  697.                         else
  698.                                 d->prg_cpu[idx]->begin.control =
  699. cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  700.     DMA_CTL_IMMEDIATE |
  701.     DMA_CTL_IRQ | 
  702.     DMA_CTL_BRANCH |
  703.     packet->header_size);
  705.                         if (d->branchAddrPtr) 
  706.                                 *(d->branchAddrPtr) =
  707. cpu_to_le32(d->prg_bus[idx] | 0x2);
  708.                         d->branchAddrPtr =
  709.                                 &(d->prg_cpu[idx]->begin.branchAddress);
  710.                 }
  712.         } else { /* iso packet */
  713.                 d->prg_cpu[idx]->data[0] = packet->speed_code<<16 |
  714.                         (packet->header[0] & 0xFFFF);
  715.                 d->prg_cpu[idx]->data[1] = packet->header[0] & 0xFFFF0000;
  716. packet_swab(d->prg_cpu[idx]->data, packet->tcode, packet->header_size>>2);
  717.   
  718.                 d->prg_cpu[idx]->begin.control = 
  719. cpu_to_le32(DMA_CTL_OUTPUT_MORE | 
  720.     DMA_CTL_IMMEDIATE | 0x8);
  721.                 d->prg_cpu[idx]->end.control = 
  722. cpu_to_le32(DMA_CTL_OUTPUT_LAST |
  723.     DMA_CTL_UPDATE |
  724.     DMA_CTL_IRQ |
  725.     DMA_CTL_BRANCH |
  726.     packet->data_size);
  727.                 d->prg_cpu[idx]->end.address = cpu_to_le32(
  728. pci_map_single(ohci->dev, packet->data,
  729. packet->data_size, PCI_DMA_TODEVICE));
  730. OHCI_DMA_ALLOC("single, iso transmit packet");
  732.                 d->prg_cpu[idx]->end.branchAddress = 0;
  733.                 d->prg_cpu[idx]->end.status = 0;
  734.                 DBGMSG(ohci->id, "Iso xmit context info: header[%08x %08x]n"
  735.                        "                       begin=%08x %08x %08x %08xn"
  736.                        "                             %08x %08x %08x %08xn"
  737.                        "                       end  =%08x %08x %08x %08x",
  738.                        d->prg_cpu[idx]->data[0], d->prg_cpu[idx]->data[1],
  739.                        d->prg_cpu[idx]->begin.control,
  740.                        d->prg_cpu[idx]->begin.address,
  741.                        d->prg_cpu[idx]->begin.branchAddress,
  742.                        d->prg_cpu[idx]->begin.status,
  743.                        d->prg_cpu[idx]->data[0],
  744.                        d->prg_cpu[idx]->data[1],
  745.                        d->prg_cpu[idx]->data[2],
  746.                        d->prg_cpu[idx]->data[3],
  747.                        d->prg_cpu[idx]->end.control,
  748.                        d->prg_cpu[idx]->end.address,
  749.                        d->prg_cpu[idx]->end.branchAddress,
  750.                        d->prg_cpu[idx]->end.status);
  751.                 if (d->branchAddrPtr) 
  752.            *(d->branchAddrPtr) = cpu_to_le32(d->prg_bus[idx] | 0x3);
  753.                 d->branchAddrPtr = &(d->prg_cpu[idx]->end.branchAddress);
  754.         }
  755. d->free_prgs--;
  757. /* queue the packet in the appropriate context queue */
  758. list_add_tail(&packet->driver_list, &d->fifo_list);
  759. d->prg_ind = (d->prg_ind+1)%d->num_desc;
  760. }
  762. /*
  763.  * This function fills the AT FIFO with the (eventual) pending packets
  764.  * and runs or wakes up the AT DMA prg if necessary.
  765.  *
  766.  * The function MUST be called with the d->lock held.
  767.  */ 
  768. static int dma_trm_flush(struct ti_ohci *ohci, struct dma_trm_ctx *d)
  769. {
  770. struct hpsb_packet *p;
  771. int idx,z;
  773. if (list_empty(&d->pending_list) || d->free_prgs == 0)
  774. return 0;
  776. p = driver_packet(d->pending_list.next);
  777. idx = d->prg_ind;
  778. z = (p->data_size) ? 3 : 2;
  780. /* insert the packets into the at dma fifo */
  781. while (d->free_prgs > 0 && !list_empty(&d->pending_list)) {
  782. struct hpsb_packet *p = driver_packet(d->pending_list.next);
  783. list_del(&p->driver_list);
  784. insert_packet(ohci, d, p);
  785. }
  787. if (d->free_prgs == 0)
  788. PRINT(KERN_INFO, ohci->id, 
  789.       "Transmit DMA FIFO ctx=%d is full... waiting",d->ctx);
  791. /* Is the context running ? (should be unless it is 
  792.    the first packet to be sent in this context) */
  793. if (!(reg_read(ohci, d->ctrlSet) & 0x8000)) {
  794. DBGMSG(ohci->id,"Starting transmit DMA ctx=%d",d->ctx);
  795. reg_write(ohci, d->cmdPtr, d->prg_bus[idx]|z);
  796. run_context(ohci, d->ctrlSet, NULL);
  797. }
  798. else {
  799. /* Wake up the dma context if necessary */
  800. if (!(reg_read(ohci, d->ctrlSet) & 0x400)) {
  801. DBGMSG(ohci->id,"Waking transmit DMA ctx=%d",d->ctx);
  802. reg_write(ohci, d->ctrlSet, 0x1000);
  803. }
  804. }
  805. return 1;
  806. }
  808. /* Transmission of an async packet */
  809. static int ohci_transmit(struct hpsb_host *host, struct hpsb_packet *packet)
  810. {
  811. struct ti_ohci *ohci = host->hostdata;
  812. struct dma_trm_ctx *d;
  813. unsigned long flags;
  815. if (packet->data_size > ohci->max_packet_size) {
  816. PRINT(KERN_ERR, ohci->id, 
  817.       "Transmit packet size %Zd is too big",
  818.       packet->data_size);
  819. return 0;
  820. }
  822. /* Decide wether we have an iso, a request, or a response packet */
  823. if (packet->type == hpsb_raw)
  824. d = &ohci->at_req_context;
  825. else if (packet->tcode == TCODE_ISO_DATA)
  826. d = &ohci->it_context;
  827. else if (packet->tcode & 0x02)
  828. d = &ohci->at_resp_context;
  829. else 
  830. d = &ohci->at_req_context;
  832. spin_lock_irqsave(&d->lock,flags);
  834. list_add_tail(&packet->driver_list, &d->pending_list);
  836. dma_trm_flush(ohci, d);
  838. spin_unlock_irqrestore(&d->lock,flags);
  840. return 1;
  841. }
  843. static int ohci_devctl(struct hpsb_host *host, enum devctl_cmd cmd, int arg)
  844. {
  845. struct ti_ohci *ohci = host->hostdata;
  846. int retval = 0;
  847. unsigned long flags;
  849. switch (cmd) {
  850. case RESET_BUS:
  851. DBGMSG(ohci->id, "devctl: Bus reset requested%s",
  852.        attempt_root ? " and attempting to become root" : "");
  853. set_phy_reg_mask (ohci, 1, 0x40 | (attempt_root ? 0x80 : 0));
  854. break;
  856. case GET_CYCLE_COUNTER:
  857. retval = reg_read(ohci, OHCI1394_IsochronousCycleTimer);
  858. break;
  860. case SET_CYCLE_COUNTER:
  861. reg_write(ohci, OHCI1394_IsochronousCycleTimer, arg);
  862. break;
  864. case SET_BUS_ID:
  865. PRINT(KERN_ERR, ohci->id, "devctl command SET_BUS_ID err");
  866. break;
  868. case ACT_CYCLE_MASTER:
  869. if (arg) {
  870. /* check if we are root and other nodes are present */
  871. u32 nodeId = reg_read(ohci, OHCI1394_NodeID);
  872. if ((nodeId & (1<<30)) && (nodeId & 0x3f)) {
  873. /*
  874.  * enable cycleTimer, cycleMaster
  875.  */
  876. DBGMSG(ohci->id, "Cycle master enabled");
  877. reg_write(ohci, OHCI1394_LinkControlSet, 
  878.   0x00300000);
  879. }
  880. } else {
  881. /* disable cycleTimer, cycleMaster, cycleSource */
  882. reg_write(ohci, OHCI1394_LinkControlClear, 0x00700000);
  883. }
  884. break;
  886. case CANCEL_REQUESTS:
  887. DBGMSG(ohci->id, "Cancel request received");
  888. dma_trm_reset(&ohci->at_req_context);
  889. dma_trm_reset(&ohci->at_resp_context);
  890. break;
  892. case MODIFY_USAGE:
  893.                 if (arg) {
  894.                         MOD_INC_USE_COUNT;
  895.                 } else {
  896.                         MOD_DEC_USE_COUNT;
  897.                 }
  898. retval = 1;
  899.                 break;
  901. case ISO_LISTEN_CHANNEL:
  902.         {
  903. u64 mask;
  905. if (arg<0 || arg>63) {
  906. PRINT(KERN_ERR, ohci->id,
  907.       "%s: IS0 listen channel %d is out of range", 
  908.       __FUNCTION__, arg);
  909. return -EFAULT;
  910. }
  912. mask = (u64)0x1<<arg;
  914.                 spin_lock_irqsave(&ohci->IR_channel_lock, flags);
  916. if (ohci->ISO_channel_usage & mask) {
  917. PRINT(KERN_ERR, ohci->id,
  918.       "%s: IS0 listen channel %d is already used", 
  919.       __FUNCTION__, arg);
  920. spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  921. return -EFAULT;
  922. }
  924. ohci->ISO_channel_usage |= mask;
  926. if (arg>31) 
  927. reg_write(ohci, OHCI1394_IRMultiChanMaskHiSet, 
  928.   1<<(arg-32));
  929. else
  930. reg_write(ohci, OHCI1394_IRMultiChanMaskLoSet, 
  931.   1<<arg);
  933.                 spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  934.                 DBGMSG(ohci->id, "Listening enabled on channel %d", arg);
  935.                 break;
  936.         }
  937. case ISO_UNLISTEN_CHANNEL:
  938.         {
  939. u64 mask;
  941. if (arg<0 || arg>63) {
  942. PRINT(KERN_ERR, ohci->id,
  943.       "%s: IS0 unlisten channel %d is out of range", 
  944.       __FUNCTION__, arg);
  945. return -EFAULT;
  946. }
  948. mask = (u64)0x1<<arg;
  950.                 spin_lock_irqsave(&ohci->IR_channel_lock, flags);
  952. if (!(ohci->ISO_channel_usage & mask)) {
  953. PRINT(KERN_ERR, ohci->id,
  954.       "%s: IS0 unlisten channel %d is not used", 
  955.       __FUNCTION__, arg);
  956. spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  957. return -EFAULT;
  958. }
  960. ohci->ISO_channel_usage &= ~mask;
  962. if (arg>31) 
  963. reg_write(ohci, OHCI1394_IRMultiChanMaskHiClear, 
  964.   1<<(arg-32));
  965. else
  966. reg_write(ohci, OHCI1394_IRMultiChanMaskLoClear, 
  967.   1<<arg);
  969.                 spin_unlock_irqrestore(&ohci->IR_channel_lock, flags);
  970.                 DBGMSG(ohci->id, "Listening disabled on channel %d", arg);
  971.                 break;
  972.         }
  973. default:
  974. PRINT_G(KERN_ERR, "ohci_devctl cmd %d not implemented yet",
  975. cmd);
  976. break;
  977. }
  978. return retval;
  979. }
  981. /***************************************
  982.  * IEEE-1394 functionality section END *
  983.  ***************************************/
  986. /********************************************************
  987.  * Global stuff (interrupt handler, init/shutdown code) *
  988.  ********************************************************/
  990. static void dma_trm_reset(struct dma_trm_ctx *d)
  991. {
  992. unsigned long flags;
  993. LIST_HEAD(packet_list);
  995. ohci1394_stop_context(d->ohci, d->ctrlClear, NULL);
  997. /* Lock the context, reset it and release it. Move the packets
  998.  * that were pending in the context to packet_list and free
  999.  * them after releasing the lock. */
  1001. spin_lock_irqsave(&d->lock, flags);
  1003. list_splice(&d->fifo_list, &packet_list);
  1004. list_splice(&d->pending_list, &packet_list);
  1005. INIT_LIST_HEAD(&d->fifo_list);
  1006. INIT_LIST_HEAD(&d->pending_list);
  1008. d->branchAddrPtr = NULL;
  1009. d->sent_ind = d->prg_ind;
  1010. d->free_prgs = d->num_desc;
  1012. spin_unlock_irqrestore(&d->lock, flags);
  1014. /* Now process subsystem callbacks for the packets from the
  1015.  * context. */
  1017. while (!list_empty(&packet_list)) {
  1018. struct hpsb_packet *p = driver_packet(packet_list.next);
  1019. PRINT(KERN_INFO, d->ohci->id, 
  1020.       "AT dma reset ctx=%d, aborting transmission", d->ctx);
  1021. list_del(&p->driver_list);
  1022. hpsb_packet_sent(d->ohci->host, p, ACKX_ABORTED);
  1023. }
  1024. }
  1026. static void ohci_schedule_iso_tasklets(struct ti_ohci *ohci, 
  1027.        quadlet_t rx_event,
  1028.        quadlet_t tx_event)
  1029. {
  1030. struct list_head *lh;
  1031. struct ohci1394_iso_tasklet *t;
  1032. unsigned long mask;
  1034. spin_lock(&ohci->iso_tasklet_list_lock);
  1036. list_for_each(lh, &ohci->iso_tasklet_list) {
  1037. t = list_entry(lh, struct ohci1394_iso_tasklet, link);
  1038. mask = 1 << t->context;
  1040. if (t->type == OHCI_ISO_TRANSMIT && tx_event & mask)
  1041. tasklet_schedule(&t->tasklet);
  1042. if (t->type == OHCI_ISO_RECEIVE && rx_event & mask)
  1043. tasklet_schedule(&t->tasklet);
  1044. }
  1046. spin_unlock(&ohci->iso_tasklet_list_lock);
  1048. }
  1050. static void ohci_irq_handler(int irq, void *dev_id,
  1051.                              struct pt_regs *regs_are_unused)
  1052. {
  1053. quadlet_t event, node_id;
  1054. struct ti_ohci *ohci = (struct ti_ohci *)dev_id;
  1055. struct hpsb_host *host = ohci->host;
  1056. int phyid = -1, isroot = 0;
  1057. unsigned long flags;
  1059. /* Read and clear the interrupt event register.  Don't clear
  1060.  * the busReset event, though, this is done when we get the
  1061.  * selfIDComplete interrupt. */
  1062. spin_lock_irqsave(&ohci->event_lock, flags);
  1063. event = reg_read(ohci, OHCI1394_IntEventClear);
  1064. reg_write(ohci, OHCI1394_IntEventClear, event & ~OHCI1394_busReset);
  1065. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1067. if (!event) return;
  1069. DBGMSG(ohci->id, "IntEvent: %08x", event);
  1071. /* Die right here an now */
  1072. if (event & OHCI1394_unrecoverableError) {
  1073. PRINT(KERN_ERR, ohci->id, "Unrecoverable error, shutting down card!");
  1074. return;
  1075. }
  1077. if (event & OHCI1394_cycleInconsistent) {
  1078. /* We subscribe to the cycleInconsistent event only to
  1079.  * clear the corresponding event bit... otherwise,
  1080.  * isochronous cycleMatch DMA wont work. */
  1081. DBGMSG(ohci->id, "OHCI1394_cycleInconsistent");
  1082. event &= ~OHCI1394_cycleInconsistent;
  1083. }
  1085. if (event & OHCI1394_busReset) {
  1086. /* The busReset event bit can't be cleared during the
  1087.  * selfID phase, so we disable busReset interrupts, to
  1088.  * avoid burying the cpu in interrupt requests. */
  1089. spin_lock_irqsave(&ohci->event_lock, flags);
  1090.    reg_write(ohci, OHCI1394_IntMaskClear, OHCI1394_busReset);
  1091. if (ohci->dev->vendor == PCI_VENDOR_ID_APPLE && 
  1092.     ohci->dev->device == PCI_DEVICE_ID_APPLE_UNI_N_FW) {
  1093.    udelay(10);
  1094.    while(reg_read(ohci, OHCI1394_IntEventSet) & OHCI1394_busReset) {
  1095.    reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
  1096. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1097.    udelay(10);
  1098. spin_lock_irqsave(&ohci->event_lock, flags);
  1099.    }
  1100.    }
  1101. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1102. if (!host->in_bus_reset) {
  1103. DBGMSG(ohci->id, "irq_handler: Bus reset requested%s",
  1104.       (attempt_root) ? " and attempting to become root"
  1105.        : "");
  1107. /* Subsystem call */
  1108. hpsb_bus_reset(ohci->host);
  1109. }
  1110. event &= ~OHCI1394_busReset;
  1111. }
  1113. /* XXX: We need a way to also queue the OHCI1394_reqTxComplete,
  1114.  * but for right now we simply run it upon reception, to make sure
  1115.  * we get sent acks before response packets. This sucks mainly
  1116.  * because it halts the interrupt handler.  */
  1117. if (event & OHCI1394_reqTxComplete) {
  1118. struct dma_trm_ctx *d = &ohci->at_req_context;
  1119. DBGMSG(ohci->id, "Got reqTxComplete interrupt "
  1120.        "status=0x%08X", reg_read(ohci, d->ctrlSet));
  1121. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1122. ohci1394_stop_context(ohci, d->ctrlClear,
  1123.       "reqTxComplete");
  1124. else
  1125. dma_trm_tasklet ((unsigned long)d);
  1126. event &= ~OHCI1394_reqTxComplete;
  1127. }
  1128. if (event & OHCI1394_respTxComplete) {
  1129. struct dma_trm_ctx *d = &ohci->at_resp_context;
  1130. DBGMSG(ohci->id, "Got respTxComplete interrupt "
  1131.        "status=0x%08X", reg_read(ohci, d->ctrlSet));
  1132. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1133. ohci1394_stop_context(ohci, d->ctrlClear,
  1134.       "respTxComplete");
  1135. else
  1136. tasklet_schedule(&d->task);
  1137. event &= ~OHCI1394_respTxComplete;
  1138. }
  1139. if (event & OHCI1394_RQPkt) {
  1140. struct dma_rcv_ctx *d = &ohci->ar_req_context;
  1141. DBGMSG(ohci->id, "Got RQPkt interrupt status=0x%08X",
  1142.        reg_read(ohci, d->ctrlSet));
  1143. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1144. ohci1394_stop_context(ohci, d->ctrlClear, "RQPkt");
  1145. else
  1146. tasklet_schedule(&d->task);
  1147. event &= ~OHCI1394_RQPkt;
  1148. }
  1149. if (event & OHCI1394_RSPkt) {
  1150. struct dma_rcv_ctx *d = &ohci->ar_resp_context;
  1151. DBGMSG(ohci->id, "Got RSPkt interrupt status=0x%08X",
  1152.        reg_read(ohci, d->ctrlSet));
  1153. if (reg_read(ohci, d->ctrlSet) & 0x800)
  1154. ohci1394_stop_context(ohci, d->ctrlClear, "RSPkt");
  1155. else
  1156. tasklet_schedule(&d->task);
  1157. event &= ~OHCI1394_RSPkt;
  1158. }
  1159. if (event & OHCI1394_isochRx) {
  1160. quadlet_t rx_event;
  1162. rx_event = reg_read(ohci, OHCI1394_IsoRecvIntEventSet);
  1163. reg_write(ohci, OHCI1394_IsoRecvIntEventClear, rx_event);
  1164. ohci_schedule_iso_tasklets(ohci, rx_event, 0);
  1165. event &= ~OHCI1394_isochRx;
  1166. }
  1167. if (event & OHCI1394_isochTx) {
  1168. quadlet_t tx_event;
  1170. tx_event = reg_read(ohci, OHCI1394_IsoXmitIntEventSet);
  1171. reg_write(ohci, OHCI1394_IsoXmitIntEventClear, tx_event);
  1172. ohci_schedule_iso_tasklets(ohci, 0, tx_event);
  1173. event &= ~OHCI1394_isochTx;
  1174. }
  1175. if (event & OHCI1394_selfIDComplete) {
  1176. if (host->in_bus_reset) {
  1177. node_id = reg_read(ohci, OHCI1394_NodeID); 
  1179. /* If our nodeid is not valid, give a msec delay
  1180.  * to let it settle in and try again.  */
  1181. if (!(node_id & 0x80000000)) {
  1182. mdelay(1);
  1183. node_id = reg_read(ohci, OHCI1394_NodeID);
  1184. }
  1186. if (node_id & 0x80000000) { /* NodeID valid */
  1187. phyid =  node_id & 0x0000003f;
  1188. isroot = (node_id & 0x40000000) != 0;
  1190. DBGMSG(ohci->id,
  1191.       "SelfID interrupt received "
  1192.       "(phyid %d, %s)", phyid, 
  1193.       (isroot ? "root" : "not root"));
  1195. handle_selfid(ohci, host, 
  1196.       phyid, isroot);
  1197. } else {
  1198. PRINT(KERN_ERR, ohci->id, 
  1199.       "SelfID interrupt received, but "
  1200.       "NodeID is not valid: %08X",
  1201.       node_id);
  1202. }
  1204. /* Accept Physical requests from all nodes. */
  1205. reg_write(ohci,OHCI1394_AsReqFilterHiSet, 
  1206.   0xffffffff);
  1207. reg_write(ohci,OHCI1394_AsReqFilterLoSet, 
  1208.   0xffffffff);
  1209. } else
  1210. PRINT(KERN_ERR, ohci->id, 
  1211.       "SelfID received outside of bus reset sequence");
  1213. /* Finally, we clear the busReset event and reenable
  1214.  * the busReset interrupt. */
  1215. spin_lock_irqsave(&ohci->event_lock, flags);
  1216. reg_write(ohci, OHCI1394_IntEventClear, OHCI1394_busReset);
  1217. reg_write(ohci, OHCI1394_IntMaskSet, OHCI1394_busReset); 
  1218. spin_unlock_irqrestore(&ohci->event_lock, flags);
  1219. event &= ~OHCI1394_selfIDComplete;
  1221. /* Turn on phys dma reception. We should
  1222.  * probably manage the filtering somehow, 
  1223.  * instead of blindly turning it on.  */
  1225. /*
  1226.  * CAUTION!
  1227.  * Some chips (TI TSB43AB22) won't take a value in
  1228.  * the PhyReqFilter register until after the IntEvent
  1229.  * is cleared for bus reset, and even then a short
  1230.  * delay is required.
  1231.  */
  1232. if (phys_dma) {
  1233. mdelay(1);
  1234. reg_write(ohci,OHCI1394_PhyReqFilterHiSet,
  1235.   0xffffffff);
  1236. reg_write(ohci,OHCI1394_PhyReqFilterLoSet,
  1237.   0xffffffff);
  1238. reg_write(ohci,OHCI1394_PhyUpperBound,
  1239.   0xffff0000);
  1240. }
  1242. DBGMSG(ohci->id, "PhyReqFilter=%08x%08xn",
  1243.        reg_read(ohci,OHCI1394_PhyReqFilterHiSet),
  1244.        reg_read(ohci,OHCI1394_PhyReqFilterLoSet));
  1245. }
  1247. /* Make sure we handle everything, just in case we accidentally
  1248.  * enabled an interrupt that we didn't write a handler for.  */
  1249. if (event)
  1250. PRINT(KERN_ERR, ohci->id, "Unhandled interrupt(s) 0x%08x",
  1251.       event);
  1252. }
  1254. /* Put the buffer back into the dma context */
  1255. static void insert_dma_buffer(struct dma_rcv_ctx *d, int idx)
  1256. {
  1257. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  1258. DBGMSG(ohci->id, "Inserting dma buf ctx=%d idx=%d", d->ctx, idx);
  1260. d->prg_cpu[idx]->status = cpu_to_le32(d->buf_size);
  1261. d->prg_cpu[idx]->branchAddress &= le32_to_cpu(0xfffffff0);
  1262. idx = (idx + d->num_desc - 1 ) % d->num_desc;
  1263. d->prg_cpu[idx]->branchAddress |= le32_to_cpu(0x00000001);
  1265. /* wake up the dma context if necessary */
  1266. if (!(reg_read(ohci, d->ctrlSet) & 0x400)) {
  1267. PRINT(KERN_INFO, ohci->id, 
  1268.       "Waking dma ctx=%d ... processing is probably too slow",
  1269.       d->ctx);
  1270. reg_write(ohci, d->ctrlSet, 0x1000);
  1271. }
  1272. }
  1274. #define cond_le32_to_cpu(data, noswap) 
  1275. (noswap ? data : le32_to_cpu(data))
  1277. static const int TCODE_SIZE[16] = {20, 0, 16, -1, 16, 20, 20, 0, 
  1278.     -1, 0, -1, 0, -1, -1, 16, -1};
  1280. /* 
  1281.  * Determine the length of a packet in the buffer
  1282.  * Optimization suggested by Pascal Drolet <pascal.drolet@informission.ca>
  1283.  */
  1284. static __inline__ int packet_length(struct dma_rcv_ctx *d, int idx, quadlet_t *buf_ptr,
  1285.  int offset, unsigned char tcode, int noswap)
  1286. {
  1287. int length = -1;
  1289. if (d->type == DMA_CTX_ASYNC_REQ || d->type == DMA_CTX_ASYNC_RESP) {
  1290. length = TCODE_SIZE[tcode];
  1291. if (length == 0) {
  1292. if (offset + 12 >= d->buf_size) {
  1293. length = (cond_le32_to_cpu(d->buf_cpu[(idx + 1) % d->num_desc]
  1294. [3 - ((d->buf_size - offset) >> 2)], noswap) >> 16);
  1295. } else {
  1296. length = (cond_le32_to_cpu(buf_ptr[3], noswap) >> 16);
  1297. }
  1298. length += 20;
  1299. }
  1300. } else if (d->type == DMA_CTX_ISO) {
  1301. /* Assumption: buffer fill mode with header/trailer */
  1302. length = (cond_le32_to_cpu(buf_ptr[0], noswap) >> 16) + 8;
  1303. }
  1305. if (length > 0 && length % 4)
  1306. length += 4 - (length % 4);
  1308. return length;
  1309. }
  1311. /* Tasklet that processes dma receive buffers */
  1312. static void dma_rcv_tasklet (unsigned long data)
  1313. {
  1314. struct dma_rcv_ctx *d = (struct dma_rcv_ctx*)data;
  1315. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  1316. unsigned int split_left, idx, offset, rescount;
  1317. unsigned char tcode;
  1318. int length, bytes_left, ack;
  1319. unsigned long flags;
  1320. quadlet_t *buf_ptr;
  1321. char *split_ptr;
  1322. char msg[256];
  1324. spin_lock_irqsave(&d->lock, flags);
  1326. idx = d->buf_ind;
  1327. offset = d->buf_offset;
  1328. buf_ptr = d->buf_cpu[idx] + offset/4;
  1330. rescount = le32_to_cpu(d->prg_cpu[idx]->status) & 0xffff;
  1331. bytes_left = d->buf_size - rescount - offset;
  1333. while (bytes_left > 0) {
  1334. tcode = (cond_le32_to_cpu(buf_ptr[0], ohci->no_swap_incoming) >> 4) & 0xf;
  1336. /* packet_length() will return < 4 for an error */
  1337. length = packet_length(d, idx, buf_ptr, offset, tcode, ohci->no_swap_incoming);
  1339. if (length < 4) { /* something is wrong */
  1340. sprintf(msg,"Unexpected tcode 0x%x(0x%08x) in AR ctx=%d, length=%d",
  1341. tcode, cond_le32_to_cpu(buf_ptr[0], ohci->no_swap_incoming),
  1342. d->ctx, length);
  1343. ohci1394_stop_context(ohci, d->ctrlClear, msg);
  1344. spin_unlock_irqrestore(&d->lock, flags);
  1345. return;
  1346. }
  1348. /* The first case is where we have a packet that crosses
  1349.  * over more than one descriptor. The next case is where
  1350.  * it's all in the first descriptor.  */
  1351. if ((offset + length) > d->buf_size) {
  1352. DBGMSG(ohci->id,"Split packet rcv'd");
  1353. if (length > d->split_buf_size) {
  1354. ohci1394_stop_context(ohci, d->ctrlClear,
  1355.      "Split packet size exceeded");
  1356. d->buf_ind = idx;
  1357. d->buf_offset = offset;
  1358. spin_unlock_irqrestore(&d->lock, flags);
  1359. return;
  1360. }
  1362. if (le32_to_cpu(d->prg_cpu[(idx+1)%d->num_desc]->status)
  1363.     == d->buf_size) {
  1364. /* Other part of packet not written yet.
  1365.  * this should never happen I think
  1366.  * anyway we'll get it on the next call.  */
  1367. PRINT(KERN_INFO, ohci->id,
  1368.       "Got only half a packet!");
  1369. d->buf_ind = idx;
  1370. d->buf_offset = offset;
  1371. spin_unlock_irqrestore(&d->lock, flags);
  1372. return;
  1373. }
  1375. split_left = length;
  1376. split_ptr = (char *)d->spb;
  1377. memcpy(split_ptr,buf_ptr,d->buf_size-offset);
  1378. split_left -= d->buf_size-offset;
  1379. split_ptr += d->buf_size-offset;
  1380. insert_dma_buffer(d, idx);
  1381. idx = (idx+1) % d->num_desc;
  1382. buf_ptr = d->buf_cpu[idx];
  1383. offset=0;
  1385. while (split_left >= d->buf_size) {
  1386. memcpy(split_ptr,buf_ptr,d->buf_size);
  1387. split_ptr += d->buf_size;
  1388. split_left -= d->buf_size;
  1389. insert_dma_buffer(d, idx);
  1390. idx = (idx+1) % d->num_desc;
  1391. buf_ptr = d->buf_cpu[idx];
  1392. }
  1394. if (split_left > 0) {
  1395. memcpy(split_ptr, buf_ptr, split_left);
  1396. offset = split_left;
  1397. buf_ptr += offset/4;
  1398. }
  1399. } else {
  1400. DBGMSG(ohci->id,"Single packet rcv'd");
  1401. memcpy(d->spb, buf_ptr, length);
  1402. offset += length;
  1403. buf_ptr += length/4;
  1404. if (offset==d->buf_size) {
  1405. insert_dma_buffer(d, idx);
  1406. idx = (idx+1) % d->num_desc;
  1407. buf_ptr = d->buf_cpu[idx];
  1408. offset=0;
  1409. }
  1410. }
  1412. /* We get one phy packet to the async descriptor for each
  1413.  * bus reset. We always ignore it.  */
  1414. if (tcode != OHCI1394_TCODE_PHY) {
  1415. if (!ohci->no_swap_incoming)
  1416. packet_swab(d->spb, tcode, (length - 4) >> 2);
  1417. DBGMSG(ohci->id, "Packet received from node"
  1418. " %d ack=0x%02X spd=%d tcode=0x%X"
  1419. " length=%d ctx=%d tlabel=%d",
  1420. (d->spb[1]>>16)&0x3f,
  1421. (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>16)&0x1f,
  1422. (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>21)&0x3,
  1423. tcode, length, d->ctx,
  1424. (cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>10)&0x3f);
  1426. ack = (((cond_le32_to_cpu(d->spb[length/4-1], ohci->no_swap_incoming)>>16)&0x1f)
  1427. == 0x11) ? 1 : 0;
  1429. hpsb_packet_received(ohci->host, d->spb, 
  1430.      length-4, ack);
  1431. }
  1432. #ifdef OHCI1394_DEBUG
  1433. else
  1434. PRINT (KERN_DEBUG, ohci->id, "Got phy packet ctx=%d ... discarded",
  1435.        d->ctx);
  1436. #endif
  1438.         rescount = le32_to_cpu(d->prg_cpu[idx]->status) & 0xffff;
  1440. bytes_left = d->buf_size - rescount - offset;
  1442. }
  1444. d->buf_ind = idx;
  1445. d->buf_offset = offset;
  1447. spin_unlock_irqrestore(&d->lock, flags);
  1448. }
  1450. /* Bottom half that processes sent packets */
  1451. static void dma_trm_tasklet (unsigned long data)
  1452. {
  1453. struct dma_trm_ctx *d = (struct dma_trm_ctx*)data;
  1454. struct ti_ohci *ohci = (struct ti_ohci*)(d->ohci);
  1455. struct hpsb_packet *packet;
  1456. unsigned long flags;
  1457. u32 ack;
  1458.         size_t datasize;
  1460. spin_lock_irqsave(&d->lock, flags);
  1462. while (!list_empty(&d->fifo_list)) {
  1463. packet = driver_packet(d->fifo_list.next);
  1464.                 datasize = packet->data_size;
  1465. if (datasize && packet->type != hpsb_raw)
  1466. ack = le32_to_cpu(
  1467. d->prg_cpu[d->sent_ind]->end.status) >> 16;
  1468. else 
  1469. ack = le32_to_cpu(
  1470. d->prg_cpu[d->sent_ind]->begin.status) >> 16;
  1472. if (ack == 0) 
  1473. /* this packet hasn't been sent yet*/
  1474. break;
  1476. if (!(ack & 0x10)) {
  1477. /* XXX: This is an OHCI evt_* code. We need to handle
  1478.  * this specially! For right now, we just fake an
  1479.  * ackx_send_error. */
  1480. PRINT(KERN_DEBUG, ohci->id, "Received OHCI evt_* error 0x%x",
  1481.        ack & 0xf);
  1482. ack = (ack & 0xffe0) | ACK_BUSY_A;
  1483. }
  1485. #ifdef OHCI1394_DEBUG
  1486. if (datasize)
  1487. DBGMSG(ohci->id,
  1488.        "Packet sent to node %d tcode=0x%X tLabel="
  1489.        "0x%02X ack=0x%X spd=%d dataLength=%d ctx=%d", 
  1490.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])
  1491.                                         >>16)&0x3f,
  1492.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1493.                                         >>4)&0xf,
  1494.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1495.                                         >>10)&0x3f,
  1496.                                 ack&0x1f, (ack>>5)&0x3, 
  1497.                                 le32_to_cpu(d->prg_cpu[d->sent_ind]->data[3])
  1498.                                         >>16,
  1499.                                 d->ctx);
  1500. else 
  1501. DBGMSG(ohci->id,
  1502.        "Packet sent to node %d tcode=0x%X tLabel="
  1503.        "0x%02X ack=0x%X spd=%d data=0x%08X ctx=%d", 
  1504.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[1])
  1505.                                         >>16)&0x3f,
  1506.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1507.                                         >>4)&0xf,
  1508.                                 (le32_to_cpu(d->prg_cpu[d->sent_ind]->data[0])
  1509.                                         >>10)&0x3f,
  1510.                                 ack&0x1f, (ack>>5)&0x3, 
  1511.                                 le32_to_cpu(d->prg_cpu[d->sent_ind]->data[3]),
  1512.                                 d->ctx);
  1513. #endif
  1515.                 list_del(&packet->driver_list);
  1516. hpsb_packet_sent(ohci->host, packet, ack & 0xf);
  1518. if (datasize) {
  1519. pci_unmap_single(ohci->dev, 
  1520.  cpu_to_le32(d->prg_cpu[d->sent_ind]->end.address),
  1521.  datasize, PCI_DMA_TODEVICE);
  1522. OHCI_DMA_FREE("single Xmit data packet");
  1523. }
  1525. d->sent_ind = (d->sent_ind+1)%d->num_desc;
  1526. d->free_prgs++;
  1527. }
  1529. dma_trm_flush(ohci, d);
  1531. spin_unlock_irqrestore(&d->lock, flags);
  1532. }
  1534. static void free_dma_rcv_ctx(struct dma_rcv_ctx *d)
  1535. {
  1536. int i;
  1538. if (d->ohci == NULL)
  1539. return;
  1541. DBGMSG(d->ohci->id, "Freeing dma_rcv_ctx %d", d->ctx);
  1543. ohci1394_stop_context(d->ohci, d->ctrlClear, NULL);
  1545. if (d->type == DMA_CTX_ISO)
  1546. ohci1394_unregister_iso_tasklet(d->ohci, &d->ohci->ir_tasklet);
  1547. else
  1548. tasklet_kill(&d->task);
  1550. if (d->buf_cpu) {
  1551. for (i=0; i<d->num_desc; i++)
  1552. if (d->buf_cpu[i] && d->buf_bus[i]) {
  1553. pci_free_consistent(
  1554. d->ohci->dev, d->buf_size, 
  1555. d->buf_cpu[i], d->buf_bus[i]);
  1556. OHCI_DMA_FREE("consistent dma_rcv buf[%d]", i);
  1557. }
  1558. kfree(d->buf_cpu);
  1559. kfree(d->buf_bus);
  1560. }
  1561. if (d->prg_cpu) {
  1562. for (i=0; i<d->num_desc; i++) 
  1563. if (d->prg_cpu[i] && d->prg_bus[i]) {
  1564. pci_free_consistent(
  1565. d->ohci->dev, sizeof(struct dma_cmd), 
  1566. d->prg_cpu[i], d->prg_bus[i]);
  1567. OHCI_DMA_FREE("consistent dma_rcv prg[%d]", i);
  1568. }
  1569. kfree(d->prg_cpu);
  1570. kfree(d->prg_bus);
  1571. }
  1572. if (d->spb) kfree(d->spb);
  1574. /* Mark this context as freed. */
  1575. d->ohci = NULL;
  1576. }
  1578. static int
  1579. alloc_dma_rcv_ctx(struct ti_ohci *ohci, struct dma_rcv_ctx *d,
  1580.   enum context_type type, int ctx, int num_desc,
  1581.   int buf_size, int split_buf_size, int context_base)
  1582. {
  1583. int i;
  1585. d->ohci = ohci;
  1586. d->type = type;
  1587. d->ctx = ctx;
  1589. d->num_desc = num_desc;
  1590. d->buf_size = buf_size;
  1591. d->split_buf_size = split_buf_size;
  1593. d->ctrlSet = context_base + OHCI1394_ContextControlSet;
  1594. d->ctrlClear = context_base + OHCI1394_ContextControlClear;
  1595. d->cmdPtr = context_base + OHCI1394_ContextCommandPtr;
  1597. d->buf_cpu = kmalloc(d->num_desc * sizeof(quadlet_t*), GFP_KERNEL);
  1598. d->buf_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
  1600. if (d->buf_cpu == NULL || d->buf_bus == NULL) {
  1601. PRINT(KERN_ERR, ohci->id, "Failed to allocate dma buffer");
  1602. free_dma_rcv_ctx(d);
  1603. return -ENOMEM;
  1604. }
  1605. memset(d->buf_cpu, 0, d->num_desc * sizeof(quadlet_t*));
  1606. memset(d->buf_bus, 0, d->num_desc * sizeof(dma_addr_t));
  1608. d->prg_cpu = kmalloc(d->num_desc * sizeof(struct dma_cmd*), 
  1609.      GFP_KERNEL);
  1610. d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
  1612. if (d->prg_cpu == NULL || d->prg_bus == NULL) {
  1613. PRINT(KERN_ERR, ohci->id, "Failed to allocate dma prg");
  1614. free_dma_rcv_ctx(d);
  1615. return -ENOMEM;
  1616. }
  1617. memset(d->prg_cpu, 0, d->num_desc * sizeof(struct dma_cmd*));
  1618. memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t));
  1620. d->spb = kmalloc(d->split_buf_size, GFP_KERNEL);
  1622. if (d->spb == NULL) {
  1623. PRINT(KERN_ERR, ohci->id, "Failed to allocate split buffer");
  1624. free_dma_rcv_ctx(d);
  1625. return -ENOMEM;
  1626. }
  1628. for (i=0; i<d->num_desc; i++) {
  1629. d->buf_cpu[i] = pci_alloc_consistent(ohci->dev, 
  1630.      d->buf_size,
  1631.      d->buf_bus+i);
  1632. OHCI_DMA_ALLOC("consistent dma_rcv buf[%d]", i);
  1634. if (d->buf_cpu[i] != NULL) {
  1635. memset(d->buf_cpu[i], 0, d->buf_size);
  1636. } else {
  1637. PRINT(KERN_ERR, ohci->id, 
  1638.       "Failed to allocate dma buffer");
  1639. free_dma_rcv_ctx(d);
  1640. return -ENOMEM;
  1641. }
  1644.                 d->prg_cpu[i] = pci_alloc_consistent(ohci->dev, 
  1645.      sizeof(struct dma_cmd),
  1646.      d->prg_bus+i);
  1647. OHCI_DMA_ALLOC("consistent dma_rcv prg[%d]", i);
  1649.                 if (d->prg_cpu[i] != NULL) {
  1650.                         memset(d->prg_cpu[i], 0, sizeof(struct dma_cmd));
  1651. } else {
  1652. PRINT(KERN_ERR, ohci->id, 
  1653.       "Failed to allocate dma prg");
  1654. free_dma_rcv_ctx(d);
  1655. return -ENOMEM;
  1656. }
  1657. }
  1659.         spin_lock_init(&d->lock);
  1661. if (type == DMA_CTX_ISO) {
  1662. ohci1394_init_iso_tasklet(&ohci->ir_tasklet, OHCI_ISO_RECEIVE,
  1663.   dma_rcv_tasklet, (unsigned long) d);
  1664. if (ohci1394_register_iso_tasklet(ohci,
  1665.   &ohci->ir_tasklet) < 0) {
  1666. PRINT(KERN_ERR, ohci->id, "No IR DMA context available");
  1667. free_dma_rcv_ctx(d);
  1668. return -EBUSY;
  1669. }
  1670. }
  1671. else
  1672. tasklet_init (&d->task, dma_rcv_tasklet, (unsigned long) d);
  1674. return 0;
  1675. }
  1677. static void free_dma_trm_ctx(struct dma_trm_ctx *d)
  1678. {
  1679. int i;
  1681. if (d->ohci == NULL)
  1682. return;
  1684. DBGMSG(d->ohci->id, "Freeing dma_trm_ctx %d", d->ctx);
  1686. ohci1394_stop_context(d->ohci, d->ctrlClear, NULL);
  1688. if (d->type == DMA_CTX_ISO)
  1689. ohci1394_unregister_iso_tasklet(d->ohci, &d->ohci->it_tasklet);
  1690. else
  1691. tasklet_kill(&d->task);
  1693. if (d->prg_cpu) {
  1694. for (i=0; i<d->num_desc; i++) 
  1695. if (d->prg_cpu[i] && d->prg_bus[i]) {
  1696. pci_free_consistent(
  1697. d->ohci->dev, sizeof(struct at_dma_prg), 
  1698. d->prg_cpu[i], d->prg_bus[i]);
  1699. OHCI_DMA_FREE("consistent dma_trm prg[%d]", i);
  1700. }
  1701. kfree(d->prg_cpu);
  1702. kfree(d->prg_bus);
  1703. }
  1705. /* Mark this context as freed. */
  1706. d->ohci = NULL;
  1707. }
  1709. static int
  1710. alloc_dma_trm_ctx(struct ti_ohci *ohci, struct dma_trm_ctx *d,
  1711.   enum context_type type, int ctx, int num_desc,
  1712.   int context_base)
  1713. {
  1714. int i;
  1716. d->ohci = ohci;
  1717. d->type = type;
  1718. d->ctx = ctx;
  1719. d->num_desc = num_desc;
  1720. d->ctrlSet = context_base + OHCI1394_ContextControlSet;
  1721. d->ctrlClear = context_base + OHCI1394_ContextControlClear;
  1722. d->cmdPtr = context_base + OHCI1394_ContextCommandPtr;
  1724. d->prg_cpu = kmalloc(d->num_desc * sizeof(struct at_dma_prg*), 
  1725.      GFP_KERNEL);
  1726. d->prg_bus = kmalloc(d->num_desc * sizeof(dma_addr_t), GFP_KERNEL);
  1728. if (d->prg_cpu == NULL || d->prg_bus == NULL) {
  1729. PRINT(KERN_ERR, ohci->id, "Failed to allocate at dma prg");
  1730. free_dma_trm_ctx(d);
  1731. return -ENOMEM;
  1732. }
  1733. memset(d->prg_cpu, 0, d->num_desc * sizeof(struct at_dma_prg*));
  1734. memset(d->prg_bus, 0, d->num_desc * sizeof(dma_addr_t));
  1736. for (i = 0; i < d->num_desc; i++) {
  1737.                 d->prg_cpu[i] = pci_alloc_consistent(ohci->dev, 
  1738.      sizeof(struct at_dma_prg),
  1739.      d->prg_bus+i);
  1740. OHCI_DMA_ALLOC("consistent dma_trm prg[%d]", i);
  1742.                 if (d->prg_cpu[i] != NULL) {
  1743.                         memset(d->prg_cpu[i], 0, sizeof(struct at_dma_prg));
  1744. } else {
  1745. PRINT(KERN_ERR, ohci->id, 
  1746.       "Failed to allocate at dma prg");
  1747. free_dma_trm_ctx(d);
  1748. return -ENOMEM;
  1749. }
  1750. }
  1752.         spin_lock_init(&d->lock);
  1754. /* initialize tasklet */
  1755. if (type == DMA_CTX_ISO) {
  1756. ohci1394_init_iso_tasklet(&ohci->it_tasklet, OHCI_ISO_TRANSMIT,
  1757.   dma_rcv_tasklet, (unsigned long) d);
  1758. if (ohci1394_register_iso_tasklet(ohci,
  1759.   &ohci->it_tasklet) < 0) {
  1760. PRINT(KERN_ERR, ohci->id, "No IT DMA context available");
  1761. free_dma_trm_ctx(d);
  1762. return -EBUSY;
  1763. }
  1764. }
  1765. else
  1766. tasklet_init (&d->task, dma_trm_tasklet, (unsigned long)d);
  1768. return 0;
  1769. }
  1771. static u16 ohci_crc16 (u32 *ptr, int length)
  1772. {
  1773. int shift;
  1774. u32 crc, sum, data;
  1776. crc = 0;
  1777. for (; length > 0; length--) {
  1778. data = be32_to_cpu(*ptr++);
  1779. for (shift = 28; shift >= 0; shift -= 4) {
  1780. sum = ((crc >> 12) ^ (data >> shift)) & 0x000f;
  1781. crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ sum;
  1782. }
  1783. crc &= 0xffff;
  1784. }
  1785. return crc;
  1786. }
  1788. /* Config ROM macro implementation influenced by NetBSD OHCI driver */
  1790. struct config_rom_unit {
  1791. u32 *start;
  1792. u32 *refer;
  1793. int length;
  1794. int refunit;
  1795. };
  1797. struct config_rom_ptr {
  1798. u32 *data;
  1799. int unitnum;
  1800. struct config_rom_unit unitdir[10];
  1801. };
  1803. #define cf_put_1quad(cr, q) (((cr)->data++)[0] = cpu_to_be32(q))
  1805. #define cf_put_4bytes(cr, b1, b2, b3, b4) 
  1806. (((cr)->data++)[0] = cpu_to_be32(((b1) << 24) | ((b2) << 16) | ((b3) << 8) | (b4)))
  1808. #define cf_put_keyval(cr, key, val) (((cr)->data++)[0] = cpu_to_be32(((key) << 24) | (val)))
  1810. static inline void cf_put_str(struct config_rom_ptr *cr, const char *str)
  1811. {
  1812. int t;
  1813. char fourb[4];
  1815. while (str[0]) {
  1816. memset(fourb, 0, 4);
  1817. for (t = 0; t < 4 && str[t]; t++)
  1818. fourb[t] = str[t];
  1819. cf_put_4bytes(cr, fourb[0], fourb[1], fourb[2], fourb[3]);
  1820. str += strlen(str) < 4 ? strlen(str) : 4;
  1821. }
  1822. return;
  1823. }
  1825. static inline void cf_put_crc16(struct config_rom_ptr *cr, int unit)
  1826. {
  1827. *cr->unitdir[unit].start =
  1828. cpu_to_be32((cr->unitdir[unit].length << 16) |
  1829.     ohci_crc16(cr->unitdir[unit].start + 1,
  1830.        cr->unitdir[unit].length));
  1831. }
  1833. static inline void cf_unit_begin(struct config_rom_ptr *cr, int unit)
  1834. {
  1835. if (cr->unitdir[unit].refer != NULL) {
  1836. *cr->unitdir[unit].refer |=
  1837. cpu_to_be32 (cr->data - cr->unitdir[unit].refer);
  1838. cf_put_crc16(cr, cr->unitdir[unit].refunit);
  1839. }
  1840. cr->unitnum = unit;
  1841. cr->unitdir[unit].start = cr->data++;
  1842. }
  1844. static inline void cf_put_refer(struct config_rom_ptr *cr, char key, int unit)
  1845. {
  1846. cr->unitdir[unit].refer = cr->data;
  1847. cr->unitdir[unit].refunit = cr->unitnum;
  1848. (cr->data++)[0] = cpu_to_be32(key << 24);
  1849. }
  1851. static inline void cf_unit_end(struct config_rom_ptr *cr)
  1852. {
  1853. cr->unitdir[cr->unitnum].length = cr->data -
  1854. (cr->unitdir[cr->unitnum].start + 1);
  1855. cf_put_crc16(cr, cr->unitnum);
  1856. }
  1858. /* End of NetBSD derived code.  */
  1860. static void ohci_init_config_rom(struct ti_ohci *ohci)
  1861. {
  1862. struct config_rom_ptr cr;
  1864. memset(&cr, 0, sizeof(cr));
  1865. memset(ohci->csr_config_rom_cpu, 0, sizeof (ohci->csr_config_rom_cpu));
  1867. cr.data = ohci->csr_config_rom_cpu;
  1869. /* Bus info block */
  1870. cf_unit_begin(&cr, 0);
  1871. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_BusID));
  1872. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_BusOptions));
  1873. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_GUIDHi));
  1874. cf_put_1quad(&cr, reg_read(ohci, OHCI1394_GUIDLo));
  1875. cf_unit_end(&cr);
  1877. DBGMSG(ohci->id, "GUID: %08x:%08x", reg_read(ohci, OHCI1394_GUIDHi),
  1878. reg_read(ohci, OHCI1394_GUIDLo));
  1880. /* IEEE P1212 suggests the initial ROM header CRC should only
  1881.  * cover the header itself (and not the entire ROM). Since we do
  1882.  * this, then we can make our bus_info_len the same as the CRC
  1883.  * length.  */
  1884. ohci->csr_config_rom_cpu[0] |= cpu_to_be32(
  1885. (be32_to_cpu(ohci->csr_config_rom_cpu[0]) & 0x00ff0000) << 8);
  1886. reg_write(ohci, OHCI1394_ConfigROMhdr,
  1887.   be32_to_cpu(ohci->csr_config_rom_cpu[0]));
  1889. /* Root directory */
  1890. cf_unit_begin(&cr, 1);
  1891. /* Vendor ID */
  1892. cf_put_keyval(&cr, 0x03, reg_read(ohci,OHCI1394_VendorID) & 0xFFFFFF);
  1893. cf_put_refer(&cr, 0x81, 2); /* Textual description unit */
  1894. cf_put_keyval(&cr, 0x0c, 0x0083c0); /* Node capabilities */
  1895. /* NOTE: Add other unit referers here, and append at bottom */
  1896. cf_unit_end(&cr);
  1898. /* Textual description - "Linux 1394" */
  1899. cf_unit_begin(&cr, 2);
  1900. cf_put_keyval(&cr, 0, 0);
  1901. cf_put_1quad(&cr, 0);
  1902. cf_put_str(&cr, "Linux OHCI-1394");
  1903. cf_unit_end(&cr);
  1905. ohci->csr_config_rom_length = cr.data - ohci->csr_config_rom_cpu;
  1906. }
  1908. static size_t ohci_get_rom(struct hpsb_host *host, const quadlet_t **ptr)
  1909. {
  1910. struct ti_ohci *ohci=host->hostdata;
  1912. DBGMSG(ohci->id, "request csr_rom address: %p",
  1913. ohci->csr_config_rom_cpu);
  1915. *ptr = ohci->csr_config_rom_cpu;
  1917. return ohci->csr_config_rom_length * 4;
  1918. }
  1920. static quadlet_t ohci_hw_csr_reg(struct hpsb_host *host, int reg,
  1921.                                  quadlet_t data, quadlet_t compare)
  1922. {
  1923. struct ti_ohci *ohci = host->hostdata;
  1924. int i;
  1926. reg_write(ohci, OHCI1394_CSRData, data);
  1927. reg_write(ohci, OHCI1394_CSRCompareData, compare);
  1928. reg_write(ohci, OHCI1394_CSRControl, reg & 0x3);
  1930. for (i = 0; i < OHCI_LOOP_COUNT; i++) {
  1931. if (reg_read(ohci, OHCI1394_CSRControl) & 0x80000000)
  1932. break;
  1934. mdelay(1);
  1935. }
  1937. return reg_read(ohci, OHCI1394_CSRData);
  1938. }
  1940. static struct hpsb_host_driver ohci1394_driver = {
  1941. .name = OHCI1394_DRIVER_NAME,
  1942. .get_rom = ohci_get_rom,
  1943. .transmit_packet = ohci_transmit,
  1944. .devctl = ohci_devctl,
  1945. .hw_csr_reg = ohci_hw_csr_reg,
  1946. };
  1950. /***********************************
  1951.  * PCI Driver Interface functions  *
  1952.  ***********************************/
  1954. #define FAIL(err, fmt, args...)
  1955. do {
  1956. PRINT_G(KERN_ERR, fmt , ## args);
  1957.         ohci1394_pci_remove(dev);               
  1958. return err;
  1959. } while(0)
  1961. static int __devinit ohci1394_pci_probe(struct pci_dev *dev,
  1962. const struct pci_device_id *ent)
  1963. {
  1964. static unsigned int card_id_counter = 0;
  1965. static int version_printed = 0;
  1967. struct hpsb_host *host;
  1968. struct ti_ohci *ohci; /* shortcut to currently handled device */
  1969. unsigned long ohci_base;
  1971. if (version_printed++ == 0)
  1972. PRINT_G(KERN_INFO, "%s", version);
  1974.         if (pci_enable_device(dev))
  1975. FAIL(-ENXIO, "Failed to enable OHCI hardware %d",
  1976.         card_id_counter++);
  1977.         pci_set_master(dev);
  1979. host = hpsb_alloc_host(&ohci1394_driver, sizeof(struct ti_ohci));
  1980. if (!host) FAIL(-ENOMEM, "Failed to allocate host structure");
  1982. ohci = host->hostdata;
  1983. ohci->id = card_id_counter++;
  1984. ohci->dev = dev;
  1985. ohci->host = host;
  1986. ohci->init_state = OHCI_INIT_ALLOC_HOST;
  1987. host->pdev = dev;
  1988. pci_set_drvdata(dev, ohci);
  1990. /* We don't want hardware swapping */
  1991. pci_write_config_dword(dev, OHCI1394_PCI_HCI_Control, 0);
  1993. /* Some oddball Apple controllers do not order the selfid
  1994.  * properly, so we make up for it here.  */
  1995. #ifndef __LITTLE_ENDIAN
  1996. /* XXX: Need a better way to check this. I'm wondering if we can
  1997.  * read the values of the OHCI1394_PCI_HCI_Control and the
  1998.  * noByteSwapData registers to see if they were not cleared to
  1999.  * zero. Should this work? Obviously it's not defined what these
  2000.  * registers will read when they aren't supported. Bleh! */
  2001. if (dev->vendor == PCI_VENDOR_ID_APPLE && 
  2002.     dev->device == PCI_DEVICE_ID_APPLE_UNI_N_FW) {
  2003. ohci->no_swap_incoming = 1;
  2004. ohci->selfid_swap = 0;
  2005. } else
  2006. ohci->selfid_swap = 1;
  2007. #endif
  2009. /* We hardwire the MMIO length, since some CardBus adaptors
  2010.  * fail to report the right length.  Anyway, the ohci spec
  2011.  * clearly says it's 2kb, so this shouldn't be a problem. */ 
  2012. ohci_base = pci_resource_start(dev, 0);
  2013. if (pci_resource_len(dev, 0) != OHCI1394_REGISTER_SIZE)
  2014. PRINT(KERN_WARNING, ohci->id, "Unexpected PCI resource length of %lx!",
  2015.       pci_resource_len(dev, 0));
  2017. /* Seems PCMCIA handles this internally. Not sure why. Seems
  2018.  * pretty bogus to force a driver to special case this.  */
  2019. #ifndef PCMCIA
  2020. if (!request_mem_region (ohci_base, OHCI1394_REGISTER_SIZE, OHCI1394_DRIVER_NAME))
  2021. FAIL(-ENOMEM, "MMIO resource (0x%lx - 0x%lx) unavailable",
  2022.      ohci_base, ohci_base + OHCI1394_REGISTER_SIZE);
  2023. #endif
  2024. ohci->init_state = OHCI_INIT_HAVE_MEM_REGION;
  2026. ohci->registers = ioremap(ohci_base, OHCI1394_REGISTER_SIZE);
  2027. if (ohci->registers == NULL)
  2028. FAIL(-ENXIO, "Failed to remap registers - card not accessible");
  2029. ohci->init_state = OHCI_INIT_HAVE_IOMAPPING;
  2030. DBGMSG(ohci->id, "Remapped memory spaces reg 0x%p", ohci->registers);
  2032. /* csr_config rom allocation */
  2033. ohci->csr_config_rom_cpu =
  2034. pci_alloc_consistent(ohci->dev, OHCI_CONFIG_ROM_LEN,
  2035.      &ohci->csr_config_rom_bus);
  2036. OHCI_DMA_ALLOC("consistent csr_config_rom");
  2037. if (ohci->csr_config_rom_cpu == NULL)
  2038. FAIL(-ENOMEM, "Failed to allocate buffer config rom");
  2039. ohci->init_state = OHCI_INIT_HAVE_CONFIG_ROM_BUFFER;
  2041. /* self-id dma buffer allocation */
  2042. ohci->selfid_buf_cpu = 
  2043. pci_alloc_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE,
  2044.                       &ohci->selfid_buf_bus);
  2045. OHCI_DMA_ALLOC("consistent selfid_buf");
  2047. if (ohci->selfid_buf_cpu == NULL)
  2048. FAIL(-ENOMEM, "Failed to allocate DMA buffer for self-id packets");
  2049. ohci->init_state = OHCI_INIT_HAVE_SELFID_BUFFER;
  2051. if ((unsigned long)ohci->selfid_buf_cpu & 0x1fff)
  2052. PRINT(KERN_INFO, ohci->id, "SelfID buffer %p is not aligned on "
  2053.       "8Kb boundary... may cause problems on some CXD3222 chip", 
  2054.       ohci->selfid_buf_cpu);  
  2056. /* No self-id errors at startup */
  2057. ohci->self_id_errors = 0;
  2059. ohci->init_state = OHCI_INIT_HAVE_TXRX_BUFFERS__MAYBE;
  2060. /* AR DMA request context allocation */
  2061. if (alloc_dma_rcv_ctx(ohci, &ohci->ar_req_context,
  2062.       DMA_CTX_ASYNC_REQ, 0, AR_REQ_NUM_DESC,
  2063.       AR_REQ_BUF_SIZE, AR_REQ_SPLIT_BUF_SIZE,
  2064.       OHCI1394_AsReqRcvContextBase) < 0)
  2065. FAIL(-ENOMEM, "Failed to allocate AR Req context");
  2067. /* AR DMA response context allocation */
  2068. if (alloc_dma_rcv_ctx(ohci, &ohci->ar_resp_context,
  2069.       DMA_CTX_ASYNC_RESP, 0, AR_RESP_NUM_DESC,
  2070.       AR_RESP_BUF_SIZE, AR_RESP_SPLIT_BUF_SIZE,
  2071.       OHCI1394_AsRspRcvContextBase) < 0)
  2072. FAIL(-ENOMEM, "Failed to allocate AR Resp context");
  2074. /* AT DMA request context */
  2075. if (alloc_dma_trm_ctx(ohci, &ohci->at_req_context,
  2076.       DMA_CTX_ASYNC_REQ, 0, AT_REQ_NUM_DESC,
  2077.       OHCI1394_AsReqTrContextBase) < 0)
  2078. FAIL(-ENOMEM, "Failed to allocate AT Req context");
  2080. /* AT DMA response context */
  2081. if (alloc_dma_trm_ctx(ohci, &ohci->at_resp_context,
  2082.       DMA_CTX_ASYNC_RESP, 1, AT_RESP_NUM_DESC,
  2083.       OHCI1394_AsRspTrContextBase) < 0)
  2084. FAIL(-ENOMEM, "Failed to allocate AT Resp context");
  2086. /* Start off with a soft reset, to clear everything to a sane
  2087.  * state. */
  2088. ohci_soft_reset(ohci);
  2090. /* Now enable LPS, which we need in order to start accessing
  2091.  * most of the registers.  In fact, on some cards (ALI M5251),
  2092.  * accessing registers in the SClk domain without LPS enabled
  2093.  * will lock up the machine.  Wait 50msec to make sure we have
  2094.  * full link enabled.  */
  2095. reg_write(ohci, OHCI1394_HCControlSet, 0x00080000);
  2096. mdelay(50);
  2098. /* Determine the number of available IR and IT contexts. */
  2099. ohci->nb_iso_rcv_ctx =
  2100. get_nb_iso_ctx(ohci, OHCI1394_IsoRecvIntMaskSet);
  2101. DBGMSG(ohci->id, "%d iso receive contexts available",
  2102.        ohci->nb_iso_rcv_ctx);
  2104. ohci->nb_iso_xmit_ctx =
  2105. get_nb_iso_ctx(ohci, OHCI1394_IsoXmitIntMaskSet);
  2106. DBGMSG(ohci->id, "%d iso transmit contexts available",
  2107.        ohci->nb_iso_xmit_ctx);
  2109. /* Set the usage bits for non-existent contexts so they can't
  2110.  * be allocated */
  2111. ohci->ir_ctx_usage = ~0 << ohci->nb_iso_rcv_ctx;
  2112. ohci->it_ctx_usage = ~0 << ohci->nb_iso_xmit_ctx;
  2114. INIT_LIST_HEAD(&ohci->iso_tasklet_list);
  2115. spin_lock_init(&ohci->iso_tasklet_list_lock);
  2116. ohci->ISO_channel_usage = 0;
  2117.         spin_lock_init(&ohci->IR_channel_lock);
  2119. /* IR DMA context */
  2120. if (alloc_dma_rcv_ctx(ohci, &ohci->ir_context,
  2121.       DMA_CTX_ISO, 0, IR_NUM_DESC,
  2122.       IR_BUF_SIZE, IR_SPLIT_BUF_SIZE,
  2123.       OHCI1394_IsoRcvContextBase) < 0)
  2124. FAIL(-ENOMEM, "Failed to allocate IR context");
  2127. /* IT DMA context allocation */
  2128. if (alloc_dma_trm_ctx(ohci, &ohci->it_context,
  2129.       DMA_CTX_ISO, 0, IT_NUM_DESC,
  2130.       OHCI1394_IsoXmitContextBase) < 0)
  2131. FAIL(-ENOMEM, "Failed to allocate IT context");
  2133. if (request_irq(dev->irq, ohci_irq_handler, SA_SHIRQ,
  2134.  OHCI1394_DRIVER_NAME, ohci))
  2135. FAIL(-ENOMEM, "Failed to allocate shared interrupt %d", dev->irq);
  2137. ohci->init_state = OHCI_INIT_HAVE_IRQ;
  2138. ohci_initialize(ohci);
  2140. /* Tell the highlevel this host is ready */
  2141. hpsb_add_host(host);
  2142. ohci->init_state = OHCI_INIT_DONE;
  2144. return 0;
  2145. #undef FAIL
  2146. }
  2148. static void ohci1394_pci_remove(struct pci_dev *pdev)
  2149. {
  2150. struct ti_ohci *ohci;
  2152. ohci = pci_get_drvdata(pdev);
  2153. if (!ohci)
  2154. return;
  2156. switch (ohci->init_state) {
  2157. case OHCI_INIT_DONE:
  2158. hpsb_remove_host(ohci->host);
  2160. case OHCI_INIT_HAVE_IRQ:
  2161. /* Soft reset before we start - this disables
  2162.  * interrupts and clears linkEnable and LPS. */
  2163. ohci_soft_reset(ohci);
  2164. free_irq(ohci->dev->irq, ohci);
  2166. case OHCI_INIT_HAVE_TXRX_BUFFERS__MAYBE:
  2167. /* Free AR dma */
  2168. free_dma_rcv_ctx(&ohci->ar_req_context);
  2169. free_dma_rcv_ctx(&ohci->ar_resp_context);
  2171. /* Free AT dma */
  2172. free_dma_trm_ctx(&ohci->at_req_context);
  2173. free_dma_trm_ctx(&ohci->at_resp_context);
  2175. /* Free IR dma */
  2176. free_dma_rcv_ctx(&ohci->ir_context);
  2178. /* Free IT dma */
  2179. free_dma_trm_ctx(&ohci->it_context);
  2181. case OHCI_INIT_HAVE_SELFID_BUFFER:
  2182. pci_free_consistent(ohci->dev, OHCI1394_SI_DMA_BUF_SIZE, 
  2183.     ohci->selfid_buf_cpu,
  2184.     ohci->selfid_buf_bus);
  2185. OHCI_DMA_FREE("consistent selfid_buf");
  2187. case OHCI_INIT_HAVE_CONFIG_ROM_BUFFER:
  2188. pci_free_consistent(ohci->dev, OHCI_CONFIG_ROM_LEN,
  2189.     ohci->csr_config_rom_cpu,
  2190.     ohci->csr_config_rom_bus);
  2191. OHCI_DMA_FREE("consistent csr_config_rom");
  2193. case OHCI_INIT_HAVE_IOMAPPING:
  2194. iounmap(ohci->registers);
  2196. case OHCI_INIT_HAVE_MEM_REGION:
  2197. #ifndef PCMCIA
  2198. release_mem_region(pci_resource_start(ohci->dev, 0),
  2199.    OHCI1394_REGISTER_SIZE);
  2200. #endif
  2202. #ifdef CONFIG_ALL_PPC
  2203. /* On UniNorth, power down the cable and turn off the chip
  2204.  * clock when the module is removed to save power on
  2205.  * laptops. Turning it back ON is done by the arch code when
  2206.  * pci_enable_device() is called */
  2207. {
  2208. struct device_node* of_node;
  2210. of_node = pci_device_to_OF_node(ohci->dev);
  2211. if (of_node) {
  2212. pmac_call_feature(PMAC_FTR_1394_ENABLE, of_node, 0, 0);
  2213. pmac_call_feature(PMAC_FTR_1394_CABLE_POWER, of_node, 0, 0);
  2214. }
  2215. }
  2216. #endif /* CONFIG_ALL_PPC */
  2218. case OHCI_INIT_ALLOC_HOST:
  2219. pci_set_drvdata(ohci->dev, NULL);
  2220. hpsb_unref_host(ohci->host);
  2221. }
  2222. }
  2224. #define PCI_CLASS_FIREWIRE_OHCI     ((PCI_CLASS_SERIAL_FIREWIRE << 8) | 0x10)
  2226. static struct pci_device_id ohci1394_pci_tbl[] __devinitdata = {
  2227. {
  2228. .class =  PCI_CLASS_FIREWIRE_OHCI,
  2229. .class_mask =  0x00ffffff,
  2230. .vendor = PCI_ANY_ID,
  2231. .device = PCI_ANY_ID,
  2232. .subvendor = PCI_ANY_ID,
  2233. .subdevice = PCI_ANY_ID,
  2234. },
  2235. { 0, },
  2236. };
  2238. MODULE_DEVICE_TABLE(pci, ohci1394_pci_tbl);
  2240. static struct pci_driver ohci1394_pci_driver = {
  2241. .name = OHCI1394_DRIVER_NAME,
  2242. .id_table = ohci1394_pci_tbl,
  2243. .probe = ohci1394_pci_probe,
  2244. .remove = ohci1394_pci_remove,
  2245. };
  2249. /***********************************
  2250.  * OHCI1394 Video Interface        *
  2251.  ***********************************/
  2253. /* essentially the only purpose of this code is to allow another
  2254.    module to hook into ohci's interrupt handler */
  2256. void ohci1394_stop_context(struct ti_ohci *ohci, int reg, char *msg)
  2257. {
  2258. int i=0;
  2260. /* stop the channel program if it's still running */
  2261. reg_write(ohci, reg, 0x8000);
  2262.    
  2263. /* Wait until it effectively stops */
  2264. while (reg_read(ohci, reg) & 0x400) {
  2265. i++;
  2266. if (i>5000) {
  2267. PRINT(KERN_ERR, ohci->id, 
  2268.       "Runaway loop while stopping context...");
  2269. break;
  2270. }
  2271. }
  2272. if (msg) PRINT(KERN_ERR, ohci->id, "%s: dma prg stopped", msg);
  2273. }
  2275. void ohci1394_init_iso_tasklet(struct ohci1394_iso_tasklet *tasklet, int type,
  2276.        void (*func)(unsigned long), unsigned long data)
  2277. {
  2278. tasklet_init(&tasklet->tasklet, func, data);
  2279. tasklet->type = type;
  2280. /* We init the tasklet->link field, so we can list_del() it
  2281.  * without worrying wether it was added to the list or not. */
  2282. INIT_LIST_HEAD(&tasklet->link);
  2283. }
  2285. int ohci1394_register_iso_tasklet(struct ti_ohci *ohci,
  2286.   struct ohci1394_iso_tasklet *tasklet)
  2287. {
  2288. unsigned long flags, *usage;
  2289. int n, i, r = -EBUSY;
  2291. if (tasklet->type == OHCI_ISO_TRANSMIT) {
  2292. n = ohci->nb_iso_xmit_ctx;
  2293. usage = &ohci->it_ctx_usage;
  2294. }
  2295. else {
  2296. n = ohci->nb_iso_rcv_ctx;
  2297. usage = &ohci->ir_ctx_usage;
  2298. }
  2300. spin_lock_irqsave(&ohci->iso_tasklet_list_lock, flags);
  2302. for (i = 0; i < n; i++)
  2303. if (!test_and_set_bit(i, usage)) {
  2304. tasklet->context = i;
  2305. list_add_tail(&tasklet->link, &ohci->iso_tasklet_list);
  2306. r = 0;
  2307. break;
  2308. }
  2310. spin_unlock_irqrestore(&ohci->iso_tasklet_list_lock, flags);
  2312. return r;
  2313. }
  2315. void ohci1394_unregister_iso_tasklet(struct ti_ohci *ohci,
  2316.      struct ohci1394_iso_tasklet *tasklet)
  2317. {
  2318. unsigned long flags;
  2320. tasklet_kill(&tasklet->tasklet);
  2322. spin_lock_irqsave(&ohci->iso_tasklet_list_lock, flags);
  2324. if (tasklet->type == OHCI_ISO_TRANSMIT)
  2325. clear_bit(tasklet->context, &ohci->it_ctx_usage);
  2326. else
  2327. clear_bit(tasklet->context, &ohci->ir_ctx_usage);
  2329. list_del(&tasklet->link);
  2331. spin_unlock_irqrestore(&ohci->iso_tasklet_list_lock, flags);
  2332. }
  2334. EXPORT_SYMBOL(ohci1394_stop_context);
  2335. EXPORT_SYMBOL(ohci1394_init_iso_tasklet);
  2336. EXPORT_SYMBOL(ohci1394_register_iso_tasklet);
  2337. EXPORT_SYMBOL(ohci1394_unregister_iso_tasklet);
  2340. /***********************************
  2341.  * General module initialization   *
  2342.  ***********************************/
  2344. MODULE_AUTHOR("Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>");
  2345. MODULE_DESCRIPTION("Driver for PCI OHCI IEEE-1394 controllers");
  2346. MODULE_LICENSE("GPL");
  2348. static void __exit ohci1394_cleanup (void)
  2349. {
  2350. pci_unregister_driver(&ohci1394_pci_driver);
  2351. }
  2353. static int __init ohci1394_init(void)
  2354. {
  2355. return pci_module_init(&ohci1394_pci_driver);
  2356. }
  2358. module_init(ohci1394_init);
  2359. module_exit(ohci1394_cleanup);