1/***************************************************************************** 2* Copyright 2004 - 2008 Broadcom Corporation. All rights reserved. 3* 4* Unless you and Broadcom execute a separate written software license 5* agreement governing use of this software, this software is licensed to you 6* under the terms of the GNU General Public License version 2, available at 7* http://www.broadcom.com/licenses/GPLv2.php (the "GPL"). 8* 9* Notwithstanding the above, under no circumstances may you combine this 10* software in any way with any other Broadcom software provided under a 11* license other than the GPL, without Broadcom's express prior written 12* consent. 13*****************************************************************************/ 14 15/****************************************************************************/ 16/** 17* @file dma.h 18* 19* @brief API definitions for the linux DMA interface. 20*/ 21/****************************************************************************/ 22 23#if !defined(ASM_ARM_ARCH_BCMRING_DMA_H) 24#define ASM_ARM_ARCH_BCMRING_DMA_H 25 26/* ---- Include Files ---------------------------------------------------- */ 27 28#include <linux/kernel.h> 29#include <linux/semaphore.h> 30#include <csp/dmacHw.h> 31#include <mach/timer.h> 32 33/* ---- Constants and Types ---------------------------------------------- */ 34 35/* If DMA_DEBUG_TRACK_RESERVATION is set to a non-zero value, then the filename */ 36/* and line number of the reservation request will be recorded in the channel table */ 37 38#define DMA_DEBUG_TRACK_RESERVATION 1 39 40#define DMA_NUM_CONTROLLERS 2 41#define DMA_NUM_CHANNELS 8 /* per controller */ 42 43typedef enum { 44 DMA_DEVICE_MEM_TO_MEM, /* For memory to memory transfers */ 45 DMA_DEVICE_I2S0_DEV_TO_MEM, 46 DMA_DEVICE_I2S0_MEM_TO_DEV, 47 DMA_DEVICE_I2S1_DEV_TO_MEM, 48 DMA_DEVICE_I2S1_MEM_TO_DEV, 49 DMA_DEVICE_APM_CODEC_A_DEV_TO_MEM, 50 DMA_DEVICE_APM_CODEC_A_MEM_TO_DEV, 51 DMA_DEVICE_APM_CODEC_B_DEV_TO_MEM, 52 DMA_DEVICE_APM_CODEC_B_MEM_TO_DEV, 53 DMA_DEVICE_APM_CODEC_C_DEV_TO_MEM, /* Additional mic input for beam-forming */ 54 DMA_DEVICE_APM_PCM0_DEV_TO_MEM, 55 DMA_DEVICE_APM_PCM0_MEM_TO_DEV, 56 DMA_DEVICE_APM_PCM1_DEV_TO_MEM, 57 DMA_DEVICE_APM_PCM1_MEM_TO_DEV, 58 DMA_DEVICE_SPUM_DEV_TO_MEM, 59 DMA_DEVICE_SPUM_MEM_TO_DEV, 60 DMA_DEVICE_SPIH_DEV_TO_MEM, 61 DMA_DEVICE_SPIH_MEM_TO_DEV, 62 DMA_DEVICE_UART_A_DEV_TO_MEM, 63 DMA_DEVICE_UART_A_MEM_TO_DEV, 64 DMA_DEVICE_UART_B_DEV_TO_MEM, 65 DMA_DEVICE_UART_B_MEM_TO_DEV, 66 DMA_DEVICE_PIF_MEM_TO_DEV, 67 DMA_DEVICE_PIF_DEV_TO_MEM, 68 DMA_DEVICE_ESW_DEV_TO_MEM, 69 DMA_DEVICE_ESW_MEM_TO_DEV, 70 DMA_DEVICE_VPM_MEM_TO_MEM, 71 DMA_DEVICE_CLCD_MEM_TO_MEM, 72 DMA_DEVICE_NAND_MEM_TO_MEM, 73 DMA_DEVICE_MEM_TO_VRAM, 74 DMA_DEVICE_VRAM_TO_MEM, 75 76 /* Add new entries before this line. */ 77 78 DMA_NUM_DEVICE_ENTRIES, 79 DMA_DEVICE_NONE = 0xff, /* Special value to indicate that no device is currently assigned. */ 80 81} DMA_Device_t; 82 83/**************************************************************************** 84* 85* The DMA_Handle_t is the primary object used by callers of the API. 86* 87*****************************************************************************/ 88 89#define DMA_INVALID_HANDLE ((DMA_Handle_t) -1) 90 91typedef int DMA_Handle_t; 92 93/**************************************************************************** 94* 95* The DMA_DescriptorRing_t contains a ring of descriptors which is used 96* to point to regions of memory. 97* 98*****************************************************************************/ 99 100typedef struct { 101 void *virtAddr; /* Virtual Address of the descriptor ring */ 102 dma_addr_t physAddr; /* Physical address of the descriptor ring */ 103 int descriptorsAllocated; /* Number of descriptors allocated in the descriptor ring */ 104 size_t bytesAllocated; /* Number of bytes allocated in the descriptor ring */ 105 106} DMA_DescriptorRing_t; 107 108/**************************************************************************** 109* 110* The DMA_DeviceAttribute_t contains information which describes a 111* particular DMA device (or peripheral). 112* 113* It is anticipated that the arrary of DMA_DeviceAttribute_t's will be 114* statically initialized. 115* 116*****************************************************************************/ 117 118/* The device handler is called whenever a DMA operation completes. The reaon */ 119/* for it to be called will be a bitmask with one or more of the following bits */ 120/* set. */ 121 122#define DMA_HANDLER_REASON_BLOCK_COMPLETE dmacHw_INTERRUPT_STATUS_BLOCK 123#define DMA_HANDLER_REASON_TRANSFER_COMPLETE dmacHw_INTERRUPT_STATUS_TRANS 124#define DMA_HANDLER_REASON_ERROR dmacHw_INTERRUPT_STATUS_ERROR 125 126typedef void (*DMA_DeviceHandler_t) (DMA_Device_t dev, int reason, 127 void *userData); 128 129#define DMA_DEVICE_FLAG_ON_DMA0 0x00000001 130#define DMA_DEVICE_FLAG_ON_DMA1 0x00000002 131#define DMA_DEVICE_FLAG_PORT_PER_DMAC 0x00000004 /* If set, it means that the port used on DMAC0 is different from the port used on DMAC1 */ 132#define DMA_DEVICE_FLAG_ALLOC_DMA1_FIRST 0x00000008 /* If set, allocate from DMA1 before allocating from DMA0 */ 133#define DMA_DEVICE_FLAG_IS_DEDICATED 0x00000100 134#define DMA_DEVICE_FLAG_NO_ISR 0x00000200 135#define DMA_DEVICE_FLAG_ALLOW_LARGE_FIFO 0x00000400 136#define DMA_DEVICE_FLAG_IN_USE 0x00000800 /* If set, device is in use on a channel */ 137 138/* Note: Some DMA devices can be used from multiple DMA Controllers. The bitmask is used to */ 139/* determine which DMA controllers a given device can be used from, and the interface */ 140/* array determeines the actual interface number to use for a given controller. */ 141 142typedef struct { 143 uint32_t flags; /* Bitmask of DMA_DEVICE_FLAG_xxx constants */ 144 uint8_t dedicatedController; /* Controller number to use if DMA_DEVICE_FLAG_IS_DEDICATED is set. */ 145 uint8_t dedicatedChannel; /* Channel number to use if DMA_DEVICE_FLAG_IS_DEDICATED is set. */ 146 const char *name; /* Will show up in the /proc entry */ 147 148 uint32_t dmacPort[DMA_NUM_CONTROLLERS]; /* Specifies the port number when DMA_DEVICE_FLAG_PORT_PER_DMAC flag is set */ 149 150 dmacHw_CONFIG_t config; /* Configuration to use when DMA'ing using this device */ 151 152 void *userData; /* Passed to the devHandler */ 153 DMA_DeviceHandler_t devHandler; /* Called when DMA operations finish. */ 154 155 timer_tick_count_t transferStartTime; /* Time the current transfer was started */ 156 157 /* The following statistical information will be collected and presented in a proc entry. */ 158 /* Note: With a contiuous bandwidth of 1 Gb/sec, it would take 584 years to overflow */ 159 /* a 64 bit counter. */ 160 161 uint64_t numTransfers; /* Number of DMA transfers performed */ 162 uint64_t transferTicks; /* Total time spent doing DMA transfers (measured in timer_tick_count_t's) */ 163 uint64_t transferBytes; /* Total bytes transferred */ 164 uint32_t timesBlocked; /* Number of times a channel was unavailable */ 165 uint32_t numBytes; /* Last transfer size */ 166 167 /* It's not possible to free memory which is allocated for the descriptors from within */ 168 /* the ISR. So make the presumption that a given device will tend to use the */ 169 /* same sized buffers over and over again, and we keep them around. */ 170 171 DMA_DescriptorRing_t ring; /* Ring of descriptors allocated for this device */ 172 173 /* We stash away some of the information from the previous transfer. If back-to-back */ 174 /* transfers are performed from the same buffer, then we don't have to keep re-initializing */ 175 /* the descriptor buffers. */ 176 177 uint32_t prevNumBytes; 178 dma_addr_t prevSrcData; 179 dma_addr_t prevDstData; 180 181} DMA_DeviceAttribute_t; 182 183/**************************************************************************** 184* 185* DMA_Channel_t, DMA_Controller_t, and DMA_State_t are really internal 186* data structures and don't belong in this header file, but are included 187* merely for discussion. 188* 189* By the time this is implemented, these structures will be moved out into 190* the appropriate C source file instead. 191* 192*****************************************************************************/ 193 194/**************************************************************************** 195* 196* The DMA_Channel_t contains state information about each DMA channel. Some 197* of the channels are dedicated. Non-dedicated channels are shared 198* amongst the other devices. 199* 200*****************************************************************************/ 201 202#define DMA_CHANNEL_FLAG_IN_USE 0x00000001 203#define DMA_CHANNEL_FLAG_IS_DEDICATED 0x00000002 204#define DMA_CHANNEL_FLAG_NO_ISR 0x00000004 205#define DMA_CHANNEL_FLAG_LARGE_FIFO 0x00000008 206 207typedef struct { 208 uint32_t flags; /* bitmask of DMA_CHANNEL_FLAG_xxx constants */ 209 DMA_Device_t devType; /* Device this channel is currently reserved for */ 210 DMA_Device_t lastDevType; /* Device type that used this previously */ 211 char name[20]; /* Name passed onto request_irq */ 212 213#if (DMA_DEBUG_TRACK_RESERVATION) 214 const char *fileName; /* Place where channel reservation took place */ 215 int lineNum; /* Place where channel reservation took place */ 216#endif 217 dmacHw_HANDLE_t dmacHwHandle; /* low level channel handle. */ 218 219} DMA_Channel_t; 220 221/**************************************************************************** 222* 223* The DMA_Controller_t contains state information about each DMA controller. 224* 225* The freeChannelQ is stored in the controller data structure rather than 226* the channel data structure since several of the devices are accessible 227* from multiple controllers, and there is no way to know which controller 228* will become available first. 229* 230*****************************************************************************/ 231 232typedef struct { 233 DMA_Channel_t channel[DMA_NUM_CHANNELS]; 234 235} DMA_Controller_t; 236 237/**************************************************************************** 238* 239* The DMA_Global_t contains all of the global state information used by 240* the DMA code. 241* 242* Callers which need to allocate a shared channel will be queued up 243* on the freeChannelQ until a channel becomes available. 244* 245*****************************************************************************/ 246 247typedef struct { 248 struct semaphore lock; /* acquired when manipulating table entries */ 249 wait_queue_head_t freeChannelQ; 250 251 DMA_Controller_t controller[DMA_NUM_CONTROLLERS]; 252 253} DMA_Global_t; 254 255/* ---- Variable Externs ------------------------------------------------- */ 256 257extern DMA_DeviceAttribute_t DMA_gDeviceAttribute[DMA_NUM_DEVICE_ENTRIES]; 258 259/* ---- Function Prototypes ---------------------------------------------- */ 260 261#if defined(__KERNEL__) 262 263/****************************************************************************/ 264/** 265* Initializes the DMA module. 266* 267* @return 268* 0 - Success 269* < 0 - Error 270*/ 271/****************************************************************************/ 272 273int dma_init(void); 274 275#if (DMA_DEBUG_TRACK_RESERVATION) 276DMA_Handle_t dma_request_channel_dbg(DMA_Device_t dev, const char *fileName, 277 int lineNum); 278#define dma_request_channel(dev) dma_request_channel_dbg(dev, __FILE__, __LINE__) 279#else 280 281/****************************************************************************/ 282/** 283* Reserves a channel for use with @a dev. If the device is setup to use 284* a shared channel, then this function will block until a free channel 285* becomes available. 286* 287* @return 288* >= 0 - A valid DMA Handle. 289* -EBUSY - Device is currently being used. 290* -ENODEV - Device handed in is invalid. 291*/ 292/****************************************************************************/ 293 294DMA_Handle_t dma_request_channel(DMA_Device_t dev /* Device to use with the allocated channel. */ 295 ); 296#endif 297 298/****************************************************************************/ 299/** 300* Frees a previously allocated DMA Handle. 301* 302* @return 303* 0 - DMA Handle was released successfully. 304* -EINVAL - Invalid DMA handle 305*/ 306/****************************************************************************/ 307 308int dma_free_channel(DMA_Handle_t channel /* DMA handle. */ 309 ); 310 311/****************************************************************************/ 312/** 313* Determines if a given device has been configured as using a shared 314* channel. 315* 316* @return boolean 317* 0 Device uses a dedicated channel 318* non-zero Device uses a shared channel 319*/ 320/****************************************************************************/ 321 322int dma_device_is_channel_shared(DMA_Device_t dev /* Device to check. */ 323 ); 324 325/****************************************************************************/ 326/** 327* Allocates memory to hold a descriptor ring. The descriptor ring then 328* needs to be populated by making one or more calls to 329* dna_add_descriptors. 330* 331* The returned descriptor ring will be automatically initialized. 332* 333* @return 334* 0 Descriptor ring was allocated successfully 335* -ENOMEM Unable to allocate memory for the desired number of descriptors. 336*/ 337/****************************************************************************/ 338 339int dma_alloc_descriptor_ring(DMA_DescriptorRing_t *ring, /* Descriptor ring to populate */ 340 int numDescriptors /* Number of descriptors that need to be allocated. */ 341 ); 342 343/****************************************************************************/ 344/** 345* Releases the memory which was previously allocated for a descriptor ring. 346*/ 347/****************************************************************************/ 348 349void dma_free_descriptor_ring(DMA_DescriptorRing_t *ring /* Descriptor to release */ 350 ); 351 352/****************************************************************************/ 353/** 354* Initializes a descriptor ring, so that descriptors can be added to it. 355* Once a descriptor ring has been allocated, it may be reinitialized for 356* use with additional/different regions of memory. 357* 358* Note that if 7 descriptors are allocated, it's perfectly acceptable to 359* initialize the ring with a smaller number of descriptors. The amount 360* of memory allocated for the descriptor ring will not be reduced, and 361* the descriptor ring may be reinitialized later 362* 363* @return 364* 0 Descriptor ring was initialized successfully 365* -ENOMEM The descriptor which was passed in has insufficient space 366* to hold the desired number of descriptors. 367*/ 368/****************************************************************************/ 369 370int dma_init_descriptor_ring(DMA_DescriptorRing_t *ring, /* Descriptor ring to initialize */ 371 int numDescriptors /* Number of descriptors to initialize. */ 372 ); 373 374/****************************************************************************/ 375/** 376* Determines the number of descriptors which would be required for a 377* transfer of the indicated memory region. 378* 379* This function also needs to know which DMA device this transfer will 380* be destined for, so that the appropriate DMA configuration can be retrieved. 381* DMA parameters such as transfer width, and whether this is a memory-to-memory 382* or memory-to-peripheral, etc can all affect the actual number of descriptors 383* required. 384* 385* @return 386* > 0 Returns the number of descriptors required for the indicated transfer 387* -EINVAL Invalid device type for this kind of transfer 388* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM) 389* -ENOMEM Memory exhausted 390*/ 391/****************************************************************************/ 392 393int dma_calculate_descriptor_count(DMA_Device_t device, /* DMA Device that this will be associated with */ 394 dma_addr_t srcData, /* Place to get data to write to device */ 395 dma_addr_t dstData, /* Pointer to device data address */ 396 size_t numBytes /* Number of bytes to transfer to the device */ 397 ); 398 399/****************************************************************************/ 400/** 401* Adds a region of memory to the descriptor ring. Note that it may take 402* multiple descriptors for each region of memory. It is the callers 403* responsibility to allocate a sufficiently large descriptor ring. 404* 405* @return 406* 0 Descriptors were added successfully 407* -EINVAL Invalid device type for this kind of transfer 408* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM) 409* -ENOMEM Memory exhausted 410*/ 411/****************************************************************************/ 412 413int dma_add_descriptors(DMA_DescriptorRing_t *ring, /* Descriptor ring to add descriptors to */ 414 DMA_Device_t device, /* DMA Device that descriptors are for */ 415 dma_addr_t srcData, /* Place to get data (memory or device) */ 416 dma_addr_t dstData, /* Place to put data (memory or device) */ 417 size_t numBytes /* Number of bytes to transfer to the device */ 418 ); 419 420/****************************************************************************/ 421/** 422* Sets the descriptor ring associated with a device. 423* 424* Once set, the descriptor ring will be associated with the device, even 425* across channel request/free calls. Passing in a NULL descriptor ring 426* will release any descriptor ring currently associated with the device. 427* 428* Note: If you call dma_transfer, or one of the other dma_alloc_ functions 429* the descriptor ring may be released and reallocated. 430* 431* Note: This function will release the descriptor memory for any current 432* descriptor ring associated with this device. 433*/ 434/****************************************************************************/ 435 436int dma_set_device_descriptor_ring(DMA_Device_t device, /* Device to update the descriptor ring for. */ 437 DMA_DescriptorRing_t *ring /* Descriptor ring to add descriptors to */ 438 ); 439 440/****************************************************************************/ 441/** 442* Retrieves the descriptor ring associated with a device. 443*/ 444/****************************************************************************/ 445 446int dma_get_device_descriptor_ring(DMA_Device_t device, /* Device to retrieve the descriptor ring for. */ 447 DMA_DescriptorRing_t *ring /* Place to store retrieved ring */ 448 ); 449 450/****************************************************************************/ 451/** 452* Allocates buffers for the descriptors. This is normally done automatically 453* but needs to be done explicitly when initiating a dma from interrupt 454* context. 455* 456* @return 457* 0 Descriptors were allocated successfully 458* -EINVAL Invalid device type for this kind of transfer 459* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM) 460* -ENOMEM Memory exhausted 461*/ 462/****************************************************************************/ 463 464int dma_alloc_descriptors(DMA_Handle_t handle, /* DMA Handle */ 465 dmacHw_TRANSFER_TYPE_e transferType, /* Type of transfer being performed */ 466 dma_addr_t srcData, /* Place to get data to write to device */ 467 dma_addr_t dstData, /* Pointer to device data address */ 468 size_t numBytes /* Number of bytes to transfer to the device */ 469 ); 470 471/****************************************************************************/ 472/** 473* Allocates and sets up descriptors for a double buffered circular buffer. 474* 475* This is primarily intended to be used for things like the ingress samples 476* from a microphone. 477* 478* @return 479* > 0 Number of descriptors actually allocated. 480* -EINVAL Invalid device type for this kind of transfer 481* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM) 482* -ENOMEM Memory exhausted 483*/ 484/****************************************************************************/ 485 486int dma_alloc_double_dst_descriptors(DMA_Handle_t handle, /* DMA Handle */ 487 dma_addr_t srcData, /* Physical address of source data */ 488 dma_addr_t dstData1, /* Physical address of first destination buffer */ 489 dma_addr_t dstData2, /* Physical address of second destination buffer */ 490 size_t numBytes /* Number of bytes in each destination buffer */ 491 ); 492 493/****************************************************************************/ 494/** 495* Initiates a transfer when the descriptors have already been setup. 496* 497* This is a special case, and normally, the dma_transfer_xxx functions should 498* be used. 499* 500* @return 501* 0 Transfer was started successfully 502* -ENODEV Invalid handle 503*/ 504/****************************************************************************/ 505 506int dma_start_transfer(DMA_Handle_t handle); 507 508/****************************************************************************/ 509/** 510* Stops a previously started DMA transfer. 511* 512* @return 513* 0 Transfer was stopped successfully 514* -ENODEV Invalid handle 515*/ 516/****************************************************************************/ 517 518int dma_stop_transfer(DMA_Handle_t handle); 519 520/****************************************************************************/ 521/** 522* Waits for a DMA to complete by polling. This function is only intended 523* to be used for testing. Interrupts should be used for most DMA operations. 524*/ 525/****************************************************************************/ 526 527int dma_wait_transfer_done(DMA_Handle_t handle); 528 529/****************************************************************************/ 530/** 531* Initiates a DMA transfer 532* 533* @return 534* 0 Transfer was started successfully 535* -EINVAL Invalid device type for this kind of transfer 536* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM) 537*/ 538/****************************************************************************/ 539 540int dma_transfer(DMA_Handle_t handle, /* DMA Handle */ 541 dmacHw_TRANSFER_TYPE_e transferType, /* Type of transfer being performed */ 542 dma_addr_t srcData, /* Place to get data to write to device */ 543 dma_addr_t dstData, /* Pointer to device data address */ 544 size_t numBytes /* Number of bytes to transfer to the device */ 545 ); 546 547/****************************************************************************/ 548/** 549* Initiates a transfer from memory to a device. 550* 551* @return 552* 0 Transfer was started successfully 553* -EINVAL Invalid device type for this kind of transfer 554* (i.e. the device is _DEV_TO_MEM and not _MEM_TO_DEV) 555*/ 556/****************************************************************************/ 557 558static inline int dma_transfer_to_device(DMA_Handle_t handle, /* DMA Handle */ 559 dma_addr_t srcData, /* Place to get data to write to device (physical address) */ 560 dma_addr_t dstData, /* Pointer to device data address (physical address) */ 561 size_t numBytes /* Number of bytes to transfer to the device */ 562 ) { 563 return dma_transfer(handle, 564 dmacHw_TRANSFER_TYPE_MEM_TO_PERIPHERAL, 565 srcData, dstData, numBytes); 566} 567 568/****************************************************************************/ 569/** 570* Initiates a transfer from a device to memory. 571* 572* @return 573* 0 Transfer was started successfully 574* -EINVAL Invalid device type for this kind of transfer 575* (i.e. the device is _MEM_TO_DEV and not _DEV_TO_MEM) 576*/ 577/****************************************************************************/ 578 579static inline int dma_transfer_from_device(DMA_Handle_t handle, /* DMA Handle */ 580 dma_addr_t srcData, /* Pointer to the device data address (physical address) */ 581 dma_addr_t dstData, /* Place to store data retrieved from the device (physical address) */ 582 size_t numBytes /* Number of bytes to retrieve from the device */ 583 ) { 584 return dma_transfer(handle, 585 dmacHw_TRANSFER_TYPE_PERIPHERAL_TO_MEM, 586 srcData, dstData, numBytes); 587} 588 589/****************************************************************************/ 590/** 591* Initiates a memory to memory transfer. 592* 593* @return 594* 0 Transfer was started successfully 595* -EINVAL Invalid device type for this kind of transfer 596* (i.e. the device wasn't DMA_DEVICE_MEM_TO_MEM) 597*/ 598/****************************************************************************/ 599 600static inline int dma_transfer_mem_to_mem(DMA_Handle_t handle, /* DMA Handle */ 601 dma_addr_t srcData, /* Place to transfer data from (physical address) */ 602 dma_addr_t dstData, /* Place to transfer data to (physical address) */ 603 size_t numBytes /* Number of bytes to transfer */ 604 ) { 605 return dma_transfer(handle, 606 dmacHw_TRANSFER_TYPE_MEM_TO_MEM, 607 srcData, dstData, numBytes); 608} 609 610/****************************************************************************/ 611/** 612* Set the callback function which will be called when a transfer completes. 613* If a NULL callback function is set, then no callback will occur. 614* 615* @note @a devHandler will be called from IRQ context. 616* 617* @return 618* 0 - Success 619* -ENODEV - Device handed in is invalid. 620*/ 621/****************************************************************************/ 622 623int dma_set_device_handler(DMA_Device_t dev, /* Device to set the callback for. */ 624 DMA_DeviceHandler_t devHandler, /* Function to call when the DMA completes */ 625 void *userData /* Pointer which will be passed to devHandler. */ 626 ); 627 628#endif 629 630#endif /* ASM_ARM_ARCH_BCMRING_DMA_H */ 631