1/* Copyright (c) 2008-2012 Freescale Semiconductor, Inc 2 * All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above copyright 9 * notice, this list of conditions and the following disclaimer in the 10 * documentation and/or other materials provided with the distribution. 11 * * Neither the name of Freescale Semiconductor nor the 12 * names of its contributors may be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * 16 * ALTERNATIVELY, this software may be distributed under the terms of the 17 * GNU General Public License ("GPL") as published by the Free Software 18 * Foundation, either version 2 of that License or (at your option) any 19 * later version. 20 * 21 * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY 22 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 23 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY 25 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 28 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 34/**************************************************************************//** 35 @File ncsw_ext.h 36 37 @Description General NetCommSw Standard Definitions 38*//***************************************************************************/ 39 40#ifndef __NCSW_EXT_H 41#define __NCSW_EXT_H 42 43 44#include "memcpy_ext.h" 45 46#define WRITE_BLOCK IOMemSet32 /* include memcpy_ext.h */ 47#define COPY_BLOCK Mem2IOCpy32 /* include memcpy_ext.h */ 48 49#define PTR_TO_UINT(_ptr) ((uintptr_t)(_ptr)) 50#define UINT_TO_PTR(_val) ((void*)(uintptr_t)(_val)) 51 52#define PTR_MOVE(_ptr, _offset) (void*)((uint8_t*)(_ptr) + (_offset)) 53 54 55#define WRITE_UINT8_UINT24(arg, data08, data24) \ 56 WRITE_UINT32(arg,((uint32_t)(data08)<<24)|((uint32_t)(data24)&0x00FFFFFF)) 57#define WRITE_UINT24_UINT8(arg, data24, data08) \ 58 WRITE_UINT32(arg,((uint32_t)(data24)<< 8)|((uint32_t)(data08)&0x000000FF)) 59 60/* Little-Endian access macros */ 61 62#define WRITE_UINT16_LE(arg, data) \ 63 WRITE_UINT16((arg), SwapUint16(data)) 64 65#define WRITE_UINT32_LE(arg, data) \ 66 WRITE_UINT32((arg), SwapUint32(data)) 67 68#define WRITE_UINT64_LE(arg, data) \ 69 WRITE_UINT64((arg), SwapUint64(data)) 70 71#define GET_UINT16_LE(arg) \ 72 SwapUint16(GET_UINT16(arg)) 73 74#define GET_UINT32_LE(arg) \ 75 SwapUint32(GET_UINT32(arg)) 76 77#define GET_UINT64_LE(arg) \ 78 SwapUint64(GET_UINT64(arg)) 79 80/* Write and Read again macros */ 81#define WRITE_UINT_SYNC(size, arg, data) \ 82 do { \ 83 WRITE_UINT##size((arg), (data)); \ 84 CORE_MemoryBarrier(); \ 85 } while (0) 86 87#define WRITE_UINT8_SYNC(arg, data) WRITE_UINT_SYNC(8, (arg), (data)) 88 89#define WRITE_UINT16_SYNC(arg, data) WRITE_UINT_SYNC(16, (arg), (data)) 90#define WRITE_UINT32_SYNC(arg, data) WRITE_UINT_SYNC(32, (arg), (data)) 91 92#define MAKE_UINT64(high32, low32) (((uint64_t)high32 << 32) | (low32)) 93 94 95/*----------------------*/ 96/* Miscellaneous macros */ 97/*----------------------*/ 98 99#define UNUSED(_x) ((void)(_x)) 100 101#define KILOBYTE 0x400UL /* 1024 */ 102#define MEGABYTE (KILOBYTE * KILOBYTE) /* 1024*1024 */ 103#define GIGABYTE ((uint64_t)(KILOBYTE * MEGABYTE)) /* 1024*1024*1024 */ 104#define TERABYTE ((uint64_t)(KILOBYTE * GIGABYTE)) /* 1024*1024*1024*1024 */ 105 106#ifndef NO_IRQ 107#define NO_IRQ (0) 108#endif 109#define NCSW_MASTER_ID (0) 110 111/* Macro for checking if a number is a power of 2 */ 112#define POWER_OF_2(n) (!((n) & ((n)-1))) 113 114/* Macro for calculating log of base 2 */ 115#define LOG2(num, log2Num) \ 116 do \ 117 { \ 118 uint64_t tmp = (num); \ 119 log2Num = 0; \ 120 while (tmp > 1) \ 121 { \ 122 log2Num++; \ 123 tmp >>= 1; \ 124 } \ 125 } while (0) 126 127#define NEXT_POWER_OF_2(_num, _nextPow) \ 128do \ 129{ \ 130 if (POWER_OF_2(_num)) \ 131 _nextPow = (_num); \ 132 else \ 133 { \ 134 uint64_t tmp = (_num); \ 135 _nextPow = 1; \ 136 while (tmp) \ 137 { \ 138 _nextPow <<= 1; \ 139 tmp >>= 1; \ 140 } \ 141 } \ 142} while (0) 143 144/* Ceiling division - not the fastest way, but safer in terms of overflow */ 145#define DIV_CEIL(x,y) (((x)/(y)) + (((((x)/(y))*(y)) == (x)) ? 0 : 1)) 146 147/* Round up a number to be a multiple of a second number */ 148#define ROUND_UP(x,y) ((((x) + (y) - 1) / (y)) * (y)) 149 150/* Timing macro for converting usec units to number of ticks. */ 151/* (number of usec * clock_Hz) / 1,000,000) - since */ 152/* clk is in MHz units, no division needed. */ 153#define USEC_TO_CLK(usec,clk) ((usec) * (clk)) 154#define CYCLES_TO_USEC(cycles,clk) ((cycles) / (clk)) 155 156/* Timing macros for converting between nsec units and number of clocks. */ 157#define NSEC_TO_CLK(nsec,clk) DIV_CEIL(((nsec) * (clk)), 1000) 158#define CYCLES_TO_NSEC(cycles,clk) (((cycles) * 1000) / (clk)) 159 160/* Timing macros for converting between psec units and number of clocks. */ 161#define PSEC_TO_CLK(psec,clk) DIV_CEIL(((psec) * (clk)), 1000000) 162#define CYCLES_TO_PSEC(cycles,clk) (((cycles) * 1000000) / (clk)) 163 164/* Min, Max macros */ 165#define IN_RANGE(min,val,max) ((min)<=(val) && (val)<=(max)) 166 167#define ABS(a) ((a<0)?(a*-1):a) 168 169#if !(defined(ARRAY_SIZE)) 170#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) 171#endif /* !defined(ARRAY_SIZE) */ 172 173 174/* possible alignments */ 175#define HALF_WORD_ALIGNMENT 2 176#define WORD_ALIGNMENT 4 177#define DOUBLE_WORD_ALIGNMENT 8 178#define BURST_ALIGNMENT 32 179 180#define HALF_WORD_ALIGNED 0x00000001 181#define WORD_ALIGNED 0x00000003 182#define DOUBLE_WORD_ALIGNED 0x00000007 183#define BURST_ALIGNED 0x0000001f 184#ifndef IS_ALIGNED 185#define IS_ALIGNED(n,align) (!((uint32_t)(n) & (align - 1))) 186#endif /* IS_ALIGNED */ 187 188 189#define LAST_BUF 1 190#define FIRST_BUF 2 191#define SINGLE_BUF (LAST_BUF | FIRST_BUF) 192#define MIDDLE_BUF 4 193 194#define ARRAY_END -1 195 196#define ILLEGAL_BASE (~0) 197 198#define BUF_POSITION(first, last) state[(!!(last))<<1 | !!(first)] 199#define DECLARE_POSITION static uint8_t state[4] = { (uint8_t)MIDDLE_BUF, (uint8_t)FIRST_BUF, (uint8_t)LAST_BUF, (uint8_t)SINGLE_BUF }; 200 201 202/**************************************************************************//** 203 @Description Timers operation mode 204*//***************************************************************************/ 205typedef enum e_TimerMode 206{ 207 e_TIMER_MODE_INVALID = 0, 208 e_TIMER_MODE_FREE_RUN, /**< Free run - counter continues to increase 209 after reaching the reference value. */ 210 e_TIMER_MODE_PERIODIC, /**< Periodic - counter restarts counting from 0 211 after reaching the reference value. */ 212 e_TIMER_MODE_SINGLE /**< Single (one-shot) - counter stops counting 213 after reaching the reference value. */ 214} e_TimerMode; 215 216 217/**************************************************************************//** 218 @Description Enumeration (bit flags) of communication modes (Transmit, 219 receive or both). 220*//***************************************************************************/ 221typedef enum e_CommMode 222{ 223 e_COMM_MODE_NONE = 0, /**< No transmit/receive communication */ 224 e_COMM_MODE_RX = 1, /**< Only receive communication */ 225 e_COMM_MODE_TX = 2, /**< Only transmit communication */ 226 e_COMM_MODE_RX_AND_TX = 3 /**< Both transmit and receive communication */ 227} e_CommMode; 228 229/**************************************************************************//** 230 @Description General Diagnostic Mode 231*//***************************************************************************/ 232typedef enum e_DiagMode 233{ 234 e_DIAG_MODE_NONE = 0, /**< Normal operation; no diagnostic mode */ 235 e_DIAG_MODE_CTRL_LOOPBACK, /**< Loopback in the controller */ 236 e_DIAG_MODE_CHIP_LOOPBACK, /**< Loopback in the chip but not in the 237 controller; e.g. IO-pins, SerDes, etc. */ 238 e_DIAG_MODE_PHY_LOOPBACK, /**< Loopback in the external PHY */ 239 e_DIAG_MODE_EXT_LOOPBACK, /**< Loopback in the external line (beyond the PHY) */ 240 e_DIAG_MODE_CTRL_ECHO, /**< Echo incoming data by the controller */ 241 e_DIAG_MODE_PHY_ECHO /**< Echo incoming data by the PHY */ 242} e_DiagMode; 243 244/**************************************************************************//** 245 @Description Possible RxStore callback responses. 246*//***************************************************************************/ 247typedef enum e_RxStoreResponse 248{ 249 e_RX_STORE_RESPONSE_PAUSE /**< Pause invoking callback with received data; 250 in polling mode, start again invoking callback 251 only next time user invokes the receive routine; 252 in interrupt mode, start again invoking callback 253 only next time a receive event triggers an interrupt; 254 in all cases, received data that are pending are not 255 lost, rather, their processing is temporarily deferred; 256 in all cases, received data are processed in the order 257 in which they were received. */ 258 , e_RX_STORE_RESPONSE_CONTINUE /**< Continue invoking callback with received data. */ 259} e_RxStoreResponse; 260 261 262/**************************************************************************//** 263 @Description General Handle 264*//***************************************************************************/ 265typedef void * t_Handle; /**< handle, used as object's descriptor */ 266 267/**************************************************************************//** 268 @Description MUTEX type 269*//***************************************************************************/ 270typedef uint32_t t_Mutex; 271 272/**************************************************************************//** 273 @Description Error Code. 274 275 The high word of the error code is the code of the software 276 module (driver). The low word is the error type (e_ErrorType). 277 To get the values from the error code, use GET_ERROR_TYPE() 278 and GET_ERROR_MODULE(). 279*//***************************************************************************/ 280typedef uint32_t t_Error; 281 282/**************************************************************************//** 283 @Description General prototype of interrupt service routine (ISR). 284 285 @Param[in] handle - Optional handle of the module handling the interrupt. 286 287 @Return None 288 *//***************************************************************************/ 289typedef void (t_Isr)(t_Handle handle); 290 291/**************************************************************************//** 292 @Anchor mem_attr 293 294 @Collection Memory Attributes 295 296 Various attributes of memory partitions. These values may be 297 or'ed together to create a mask of all memory attributes. 298 @{ 299*//***************************************************************************/ 300#define MEMORY_ATTR_CACHEABLE 0x00000001 301 /**< Memory is cacheable */ 302#define MEMORY_ATTR_QE_2ND_BUS_ACCESS 0x00000002 303 /**< Memory can be accessed by QUICC Engine 304 through its secondary bus interface */ 305 306/* @} */ 307 308 309/**************************************************************************//** 310 @Function t_GetBufFunction 311 312 @Description User callback function called by driver to get data buffer. 313 314 User provides this function. Driver invokes it. 315 316 @Param[in] h_BufferPool - A handle to buffer pool manager 317 @Param[out] p_BufContextHandle - Returns the user's private context that 318 should be associated with the buffer 319 320 @Return Pointer to data buffer, NULL if error 321 *//***************************************************************************/ 322typedef uint8_t * (t_GetBufFunction)(t_Handle h_BufferPool, 323 t_Handle *p_BufContextHandle); 324 325/**************************************************************************//** 326 @Function t_PutBufFunction 327 328 @Description User callback function called by driver to return data buffer. 329 330 User provides this function. Driver invokes it. 331 332 @Param[in] h_BufferPool - A handle to buffer pool manager 333 @Param[in] p_Buffer - A pointer to buffer to return 334 @Param[in] h_BufContext - The user's private context associated with 335 the returned buffer 336 337 @Return E_OK on success; Error code otherwise 338 *//***************************************************************************/ 339typedef t_Error (t_PutBufFunction)(t_Handle h_BufferPool, 340 uint8_t *p_Buffer, 341 t_Handle h_BufContext); 342 343/**************************************************************************//** 344 @Function t_PhysToVirt 345 346 @Description Translates a physical address to the matching virtual address. 347 348 @Param[in] addr - The physical address to translate. 349 350 @Return Virtual address. 351*//***************************************************************************/ 352typedef void * t_PhysToVirt(physAddress_t addr); 353 354/**************************************************************************//** 355 @Function t_VirtToPhys 356 357 @Description Translates a virtual address to the matching physical address. 358 359 @Param[in] addr - The virtual address to translate. 360 361 @Return Physical address. 362*//***************************************************************************/ 363typedef physAddress_t t_VirtToPhys(void *addr); 364 365/**************************************************************************//** 366 @Description Buffer Pool Information Structure. 367*//***************************************************************************/ 368typedef struct t_BufferPoolInfo 369{ 370 t_Handle h_BufferPool; /**< A handle to the buffer pool manager */ 371 t_GetBufFunction *f_GetBuf; /**< User callback to get a free buffer */ 372 t_PutBufFunction *f_PutBuf; /**< User callback to return a buffer */ 373 uint16_t bufferSize; /**< Buffer size (in bytes) */ 374 375 t_PhysToVirt *f_PhysToVirt; /**< User callback to translate pool buffers 376 physical addresses to virtual addresses */ 377 t_VirtToPhys *f_VirtToPhys; /**< User callback to translate pool buffers 378 virtual addresses to physical addresses */ 379} t_BufferPoolInfo; 380 381 382/**************************************************************************//** 383 @Description User callback function called by driver when transmit completed. 384 385 User provides this function. Driver invokes it. 386 387 @Param[in] h_App - Application's handle, as was provided to the 388 driver by the user 389 @Param[in] queueId - Transmit queue ID 390 @Param[in] p_Data - Pointer to the data buffer 391 @Param[in] h_BufContext - The user's private context associated with 392 the given data buffer 393 @Param[in] status - Transmit status and errors 394 @Param[in] flags - Driver-dependent information 395 *//***************************************************************************/ 396typedef void (t_TxConfFunction)(t_Handle h_App, 397 uint32_t queueId, 398 uint8_t *p_Data, 399 t_Handle h_BufContext, 400 uint16_t status, 401 uint32_t flags); 402 403/**************************************************************************//** 404 @Description User callback function called by driver with receive data. 405 406 User provides this function. Driver invokes it. 407 408 @Param[in] h_App - Application's handle, as was provided to the 409 driver by the user 410 @Param[in] queueId - Receive queue ID 411 @Param[in] p_Data - Pointer to the buffer with received data 412 @Param[in] h_BufContext - The user's private context associated with 413 the given data buffer 414 @Param[in] length - Length of received data 415 @Param[in] status - Receive status and errors 416 @Param[in] position - Position of buffer in frame 417 @Param[in] flags - Driver-dependent information 418 419 @Retval e_RX_STORE_RESPONSE_CONTINUE - order the driver to continue Rx 420 operation for all ready data. 421 @Retval e_RX_STORE_RESPONSE_PAUSE - order the driver to stop Rx operation. 422 *//***************************************************************************/ 423typedef e_RxStoreResponse (t_RxStoreFunction)(t_Handle h_App, 424 uint32_t queueId, 425 uint8_t *p_Data, 426 t_Handle h_BufContext, 427 uint32_t length, 428 uint16_t status, 429 uint8_t position, 430 uint32_t flags); 431 432 433#endif /* __NCSW_EXT_H */ 434