[deliverable/linux.git] / drivers / staging / csr / os.c

/*
 * ---------------------------------------------------------------------------
 *  FILE:     os.c
 *
 *  PURPOSE:
 *      Routines to fulfil the OS-abstraction for the HIP lib.
 *      It is part of the porting exercise.
 *
 * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
 *
 * Refer to LICENSE.txt included with this source code for details on
 * the license terms.
 *
 * ---------------------------------------------------------------------------
 */

/**
 * The HIP lib OS abstraction consists of the implementation
 * of the functions in this file. It is part of the porting exercise.
 */

#include "unifi_priv.h"


/*
 * ---------------------------------------------------------------------------
 *  unifi_net_data_malloc
 *
 *      Allocate an OS specific net data buffer of "size" bytes.
 *      The bulk_data_slot.os_data_ptr must be initialised to point
 *      to the buffer allocated. The bulk_data_slot.length must be
 *      initialised to the requested size, zero otherwise.
 *      The bulk_data_slot.os_net_buf_ptr can be initialised to
 *      an OS specific pointer to be used in the unifi_net_data_free().
 *
 *
 *  Arguments:
 *      ospriv              Pointer to device private context struct.
 *      bulk_data_slot      Pointer to the bulk data structure to initialise.
 *      size                Size of the buffer to be allocated.
 *
 *  Returns:
 *      CSR_RESULT_SUCCESS on success, CSR_RESULT_FAILURE otherwise.
 * ---------------------------------------------------------------------------
 */
CsrResult
unifi_net_data_malloc(void *ospriv, bulk_data_desc_t *bulk_data_slot, unsigned int size)
{
    struct sk_buff *skb;
    unifi_priv_t *priv = (unifi_priv_t*)ospriv;
    int rounded_length;

    if (priv->card_info.sdio_block_size == 0) {
        unifi_error(priv, "unifi_net_data_malloc: Invalid SDIO block size\n");
        return CSR_RESULT_FAILURE;
    }

    rounded_length = (size + priv->card_info.sdio_block_size - 1) & ~(priv->card_info.sdio_block_size - 1);

    /*
     * (ETH_HLEN + 2) bytes tailroom for header manipulation
     * CSR_WIFI_ALIGN_BYTES bytes headroom for alignment manipulation
     */
    skb = dev_alloc_skb(rounded_length + 2 + ETH_HLEN + CSR_WIFI_ALIGN_BYTES);
    if (! skb) {
        unifi_error(ospriv, "alloc_skb failed.\n");
        bulk_data_slot->os_net_buf_ptr = NULL;
        bulk_data_slot->net_buf_length = 0;
        bulk_data_slot->os_data_ptr = NULL;
        bulk_data_slot->data_length = 0;
        return CSR_RESULT_FAILURE;
    }

    bulk_data_slot->os_net_buf_ptr = (const unsigned char*)skb;
    bulk_data_slot->net_buf_length = rounded_length + 2 + ETH_HLEN + CSR_WIFI_ALIGN_BYTES;
    bulk_data_slot->os_data_ptr = (const void*)skb->data;
    bulk_data_slot->data_length = size;

    return CSR_RESULT_SUCCESS;
} /* unifi_net_data_malloc() */

/*
 * ---------------------------------------------------------------------------
 *  unifi_net_data_free
 *
 *      Free an OS specific net data buffer.
 *      The bulk_data_slot.length must be initialised to 0.
 *
 *
 *  Arguments:
 *      ospriv              Pointer to device private context struct.
 *      bulk_data_slot      Pointer to the bulk data structure that
 *                          holds the data to be freed.
 *
 *  Returns:
 *      None.
 * ---------------------------------------------------------------------------
 */
void
unifi_net_data_free(void *ospriv, bulk_data_desc_t *bulk_data_slot)
{
    struct sk_buff *skb;
    CSR_UNUSED(ospriv);

    skb = (struct sk_buff *)bulk_data_slot->os_net_buf_ptr;
    dev_kfree_skb(skb);

    bulk_data_slot->net_buf_length = 0;
    bulk_data_slot->data_length = 0;
    bulk_data_slot->os_data_ptr = bulk_data_slot->os_net_buf_ptr = NULL;

} /* unifi_net_data_free() */


/*
* ---------------------------------------------------------------------------
*  unifi_net_dma_align
*
*      DMA align an OS specific net data buffer.
*      The buffer must be empty.
*
*
*  Arguments:
*      ospriv              Pointer to device private context struct.
*      bulk_data_slot      Pointer to the bulk data structure that
*                          holds the data to be aligned.
*
*  Returns:
*      None.
* ---------------------------------------------------------------------------
*/
CsrResult
unifi_net_dma_align(void *ospriv, bulk_data_desc_t *bulk_data_slot)
{
    struct sk_buff *skb;
    unsigned long buf_address;
    int offset;
    unifi_priv_t *priv = (unifi_priv_t*)ospriv;

    if ((bulk_data_slot == NULL) || (CSR_WIFI_ALIGN_BYTES == 0)) {
        return CSR_RESULT_SUCCESS;
    }

    if ((bulk_data_slot->os_data_ptr == NULL) || (bulk_data_slot->data_length == 0)) {
        return CSR_RESULT_SUCCESS;
    }

    buf_address = (unsigned long)(bulk_data_slot->os_data_ptr) & (CSR_WIFI_ALIGN_BYTES - 1);

    unifi_trace(priv, UDBG5,
                "unifi_net_dma_align: Allign buffer (0x%p) by %d bytes\n",
                bulk_data_slot->os_data_ptr, buf_address);

    offset = CSR_WIFI_ALIGN_BYTES - buf_address;
    if (offset < 0) {
        unifi_error(priv, "unifi_net_dma_align: Failed (offset=%d)\n", offset);
        return CSR_RESULT_FAILURE;
    }

    skb = (struct sk_buff*)(bulk_data_slot->os_net_buf_ptr);
    skb_reserve(skb, offset);
    bulk_data_slot->os_net_buf_ptr = (const unsigned char*)skb;
    bulk_data_slot->os_data_ptr = (const void*)(skb->data);

    return CSR_RESULT_SUCCESS;

} /* unifi_net_dma_align() */

#ifdef ANDROID_TIMESTAMP
static volatile unsigned int printk_cpu = UINT_MAX;
char tbuf[30];

char* print_time(void )
{
    unsigned long long t;
    unsigned long nanosec_rem;

    t = cpu_clock(printk_cpu);
    nanosec_rem = do_div(t, 1000000000);
    sprintf(tbuf, "[%5lu.%06lu] ",
                    (unsigned long) t,
                    nanosec_rem / 1000);

    return tbuf;
}
#endif


/* Module parameters */
extern int unifi_debug;

#ifdef UNIFI_DEBUG
#define DEBUG_BUFFER_SIZE       120

#define FORMAT_TRACE(_s, _len, _args, _fmt)             \
    do {                                                \
        va_start(_args, _fmt);                          \
        _len += vsnprintf(&(_s)[_len],                  \
                         (DEBUG_BUFFER_SIZE - _len),    \
                         _fmt, _args);                  \
        va_end(_args);                                  \
        if (_len >= DEBUG_BUFFER_SIZE) {                \
            (_s)[DEBUG_BUFFER_SIZE - 2] = '\n';         \
            (_s)[DEBUG_BUFFER_SIZE - 1] = 0;            \
        }                                               \
    } while (0)

void
unifi_error(void* ospriv, const char *fmt, ...)
{
    unifi_priv_t *priv = (unifi_priv_t*) ospriv;
    char s[DEBUG_BUFFER_SIZE];
    va_list args;
    unsigned int len;
#ifdef ANDROID_TIMESTAMP
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi%d: ", print_time(), priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi: ", print_time());
    }
#else
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi%d: ", priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi: ");
    }
#endif /* ANDROID_TIMESTAMP */
    FORMAT_TRACE(s, len, args, fmt);

    printk("%s", s);
}

void
unifi_warning(void* ospriv, const char *fmt, ...)
{
    unifi_priv_t *priv = (unifi_priv_t*) ospriv;
    char s[DEBUG_BUFFER_SIZE];
    va_list args;
    unsigned int len;

#ifdef ANDROID_TIMESTAMP
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "%s unifi%d: ", print_time(), priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "%s unifi: ", print_time());
    }
#else
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "unifi%d: ", priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "unifi: ");
    }
#endif /* ANDROID_TIMESTAMP */

    FORMAT_TRACE(s, len, args, fmt);

    printk("%s", s);
}


void
unifi_notice(void* ospriv, const char *fmt, ...)
{
    unifi_priv_t *priv = (unifi_priv_t*) ospriv;
    char s[DEBUG_BUFFER_SIZE];
    va_list args;
    unsigned int len;

#ifdef ANDROID_TIMESTAMP
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "%s unifi%d: ", print_time(), priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "%s unifi: ", print_time());
    }
#else
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "unifi%d: ", priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "unifi: ");
    }
#endif /* ANDROID_TIMESTAMP */

    FORMAT_TRACE(s, len, args, fmt);

    printk("%s", s);
}


void
unifi_info(void* ospriv, const char *fmt, ...)
{
    unifi_priv_t *priv = (unifi_priv_t*) ospriv;
    char s[DEBUG_BUFFER_SIZE];
    va_list args;
    unsigned int len;

#ifdef ANDROID_TIMESTAMP
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "%s unifi%d: ", print_time(), priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "%s unifi: ", print_time());
    }
#else
    if (priv != NULL) {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "unifi%d: ", priv->instance);
    } else {
        len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "unifi: ");
    }
#endif /* ANDROID_TIMESTAMP */

    FORMAT_TRACE(s, len, args, fmt);

    printk("%s", s);
}

/* debugging */
void
unifi_trace(void* ospriv, int level, const char *fmt, ...)
{
    unifi_priv_t *priv = (unifi_priv_t*) ospriv;
    char s[DEBUG_BUFFER_SIZE];
    va_list args;
    unsigned int len;

    if (unifi_debug >= level) {
#ifdef ANDROID_TIMESTAMP
        if (priv != NULL) {
            len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi%d: ", print_time(), priv->instance);
        } else {
            len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi: ", print_time());
        }
#else
        if (priv != NULL) {
            len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi%d: ", priv->instance);
        } else {
            len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi: ");
        }
#endif /* ANDROID_TIMESTAMP */

        FORMAT_TRACE(s, len, args, fmt);

        printk("%s", s);
    }
}

#else

void
unifi_error_nop(void* ospriv, const char *fmt, ...)
{
}

void
unifi_trace_nop(void* ospriv, int level, const char *fmt, ...)
{
}

#endif /* UNIFI_DEBUG */


/*
 * ---------------------------------------------------------------------------
 *
 *      Debugging support.
 *
 * ---------------------------------------------------------------------------
 */

#ifdef UNIFI_DEBUG

/* Memory dump with level filter controlled by unifi_debug */
void
unifi_dump(void *ospriv, int level, const char *msg, void *mem, u16 len)
{
    unifi_priv_t *priv = (unifi_priv_t*) ospriv;

    if (unifi_debug >= level) {
#ifdef ANDROID_TIMESTAMP
        if (priv != NULL) {
            printk(KERN_ERR "%s unifi%d: --- dump: %s ---\n", print_time(), priv->instance, msg ? msg : "");
        } else {
            printk(KERN_ERR "%s unifi: --- dump: %s ---\n", print_time(), msg ? msg : "");
        }
#else
        if (priv != NULL) {
            printk(KERN_ERR "unifi%d: --- dump: %s ---\n", priv->instance, msg ? msg : "");
        } else {
            printk(KERN_ERR "unifi: --- dump: %s ---\n", msg ? msg : "");
        }
#endif /* ANDROID_TIMESTAMP */
        dump(mem, len);

        if (priv != NULL) {
            printk(KERN_ERR "unifi%d: --- end of dump ---\n", priv->instance);
        } else {
            printk(KERN_ERR "unifi: --- end of dump ---\n");
        }
    }
}

/* Memory dump that appears all the time, use sparingly */
void
dump(void *mem, u16 len)
{
    int i, col = 0;
    unsigned char *pdata = (unsigned char *)mem;
#ifdef ANDROID_TIMESTAMP
    printk("timestamp %s \n", print_time());
#endif /* ANDROID_TIMESTAMP */
    if (mem == NULL) {
        printk("(null dump)\n");
        return;
    }
    for (i = 0; i < len; i++) {
        if (col == 0)
            printk("0x%02X: ", i);

        printk(" %02X", pdata[i]);

        if (++col == 16) {
            printk("\n");
            col = 0;
        }
    }
    if (col)
        printk("\n");
} /* dump() */


void
dump16(void *mem, u16 len)
{
    int i, col=0;
    unsigned short *p = (unsigned short *)mem;
#ifdef ANDROID_TIMESTAMP
    printk("timestamp %s \n", print_time());
#endif /* ANDROID_TIMESTAMP */
    for (i = 0; i < len; i+=2) {
        if (col == 0)
            printk("0x%02X: ", i);

        printk(" %04X", *p++);

        if (++col == 8) {
            printk("\n");
            col = 0;
        }
    }
    if (col)
        printk("\n");
}


#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
void
dump_str(void *mem, u16 len)
{
    int i;
    unsigned char *pdata = (unsigned char *)mem;
#ifdef ANDROID_TIMESTAMP
    printk("timestamp %s \n", print_time());
#endif /* ANDROID_TIMESTAMP */
    for (i = 0; i < len; i++) {
        printk("%c", pdata[i]);
    }
	printk("\n");

} /* dump_str() */
#endif /* CSR_ONLY_NOTES */


#endif /* UNIFI_DEBUG */


/* ---------------------------------------------------------------------------
 *                              - End -
 * ------------------------------------------------------------------------- */
Commit	Line	Data
635d2b00 GKH	1	/*
	2	* ---------------------------------------------------------------------------
	3	* FILE: os.c
	4	*
	5	* PURPOSE:
	6	* Routines to fulfil the OS-abstraction for the HIP lib.
	7	* It is part of the porting exercise.
	8	*
	9	* Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
	10	*
	11	* Refer to LICENSE.txt included with this source code for details on
	12	* the license terms.
	13	*
	14	* ---------------------------------------------------------------------------
	15	*/
	16
	17	/**
	18	* The HIP lib OS abstraction consists of the implementation
	19	* of the functions in this file. It is part of the porting exercise.
	20	*/
	21
	22	#include "unifi_priv.h"
	23
	24
	25	/*
	26	* ---------------------------------------------------------------------------
	27	* unifi_net_data_malloc
	28	*
	29	* Allocate an OS specific net data buffer of "size" bytes.
	30	* The bulk_data_slot.os_data_ptr must be initialised to point
	31	* to the buffer allocated. The bulk_data_slot.length must be
	32	* initialised to the requested size, zero otherwise.
	33	* The bulk_data_slot.os_net_buf_ptr can be initialised to
	34	* an OS specific pointer to be used in the unifi_net_data_free().
	35	*
	36	*
	37	* Arguments:
	38	* ospriv Pointer to device private context struct.
	39	* bulk_data_slot Pointer to the bulk data structure to initialise.
	40	* size Size of the buffer to be allocated.
	41	*
	42	* Returns:
	43	* CSR_RESULT_SUCCESS on success, CSR_RESULT_FAILURE otherwise.
	44	* ---------------------------------------------------------------------------
	45	*/
	46	CsrResult
	47	unifi_net_data_malloc(void ospriv, bulk_data_desc_t bulk_data_slot, unsigned int size)
	48	{
	49	struct sk_buff *skb;
	50	unifi_priv_t priv = (unifi_priv_t)ospriv;
	51	int rounded_length;
	52
	53	if (priv->card_info.sdio_block_size == 0) {
	54	unifi_error(priv, "unifi_net_data_malloc: Invalid SDIO block size\n");
	55	return CSR_RESULT_FAILURE;
	56	}
	57
	58	rounded_length = (size + priv->card_info.sdio_block_size - 1) & ~(priv->card_info.sdio_block_size - 1);
	59
	60	/*
	61	* (ETH_HLEN + 2) bytes tailroom for header manipulation
	62	* CSR_WIFI_ALIGN_BYTES bytes headroom for alignment manipulation
	63	*/
	64	skb = dev_alloc_skb(rounded_length + 2 + ETH_HLEN + CSR_WIFI_ALIGN_BYTES);
65	if (! skb) {
66	unifi_error(ospriv, "alloc_skb failed.\n");
67	bulk_data_slot->os_net_buf_ptr = NULL;
68	bulk_data_slot->net_buf_length = 0;
69	bulk_data_slot->os_data_ptr = NULL;
70	bulk_data_slot->data_length = 0;
71	return CSR_RESULT_FAILURE;
72	}
73
74	bulk_data_slot->os_net_buf_ptr = (const unsigned char*)skb;
75	bulk_data_slot->net_buf_length = rounded_length + 2 + ETH_HLEN + CSR_WIFI_ALIGN_BYTES;
76	bulk_data_slot->os_data_ptr = (const void*)skb->data;
77	bulk_data_slot->data_length = size;
78
79	return CSR_RESULT_SUCCESS;
80	} /* unifi_net_data_malloc() */
81
82	/*
83	* ---------------------------------------------------------------------------
84	* unifi_net_data_free
85	*
86	* Free an OS specific net data buffer.
87	* The bulk_data_slot.length must be initialised to 0.
88	*
89	*
90	* Arguments:
91	* ospriv Pointer to device private context struct.
92	* bulk_data_slot Pointer to the bulk data structure that
93	* holds the data to be freed.
94	*
95	* Returns:
96	* None.
97	* ---------------------------------------------------------------------------
98	*/
99	void
100	unifi_net_data_free(void ospriv, bulk_data_desc_t bulk_data_slot)
101	{
102	struct sk_buff *skb;
103	CSR_UNUSED(ospriv);
104
105	skb = (struct sk_buff *)bulk_data_slot->os_net_buf_ptr;
106	dev_kfree_skb(skb);
107
108	bulk_data_slot->net_buf_length = 0;
109	bulk_data_slot->data_length = 0;
110	bulk_data_slot->os_data_ptr = bulk_data_slot->os_net_buf_ptr = NULL;
111
112	} /* unifi_net_data_free() */
113
114
115	/*
116	* ---------------------------------------------------------------------------
117	* unifi_net_dma_align
118	*
119	* DMA align an OS specific net data buffer.
120	* The buffer must be empty.
121	*
122	*
123	* Arguments:
124	* ospriv Pointer to device private context struct.
125	* bulk_data_slot Pointer to the bulk data structure that
126	* holds the data to be aligned.
127	*
128	* Returns:
129	* None.
130	* ---------------------------------------------------------------------------
131	*/
132	CsrResult
133	unifi_net_dma_align(void ospriv, bulk_data_desc_t bulk_data_slot)
134	{
135	struct sk_buff *skb;
136	unsigned long buf_address;
137	int offset;
138	unifi_priv_t priv = (unifi_priv_t)ospriv;
139
140	if ((bulk_data_slot == NULL) \|\| (CSR_WIFI_ALIGN_BYTES == 0)) {
141	return CSR_RESULT_SUCCESS;
142	}
143
144	if ((bulk_data_slot->os_data_ptr == NULL) \|\| (bulk_data_slot->data_length == 0)) {
145	return CSR_RESULT_SUCCESS;
146	}
147
148	buf_address = (unsigned long)(bulk_data_slot->os_data_ptr) & (CSR_WIFI_ALIGN_BYTES - 1);
149
150	unifi_trace(priv, UDBG5,
151	"unifi_net_dma_align: Allign buffer (0x%p) by %d bytes\n",
152	bulk_data_slot->os_data_ptr, buf_address);
153
154	offset = CSR_WIFI_ALIGN_BYTES - buf_address;
155	if (offset < 0) {
156	unifi_error(priv, "unifi_net_dma_align: Failed (offset=%d)\n", offset);
157	return CSR_RESULT_FAILURE;
158	}
159
160	skb = (struct sk_buff*)(bulk_data_slot->os_net_buf_ptr);
161	skb_reserve(skb, offset);
162	bulk_data_slot->os_net_buf_ptr = (const unsigned char*)skb;
163	bulk_data_slot->os_data_ptr = (const void*)(skb->data);
164
165	return CSR_RESULT_SUCCESS;
166
167	} /* unifi_net_dma_align() */
168
169	#ifdef ANDROID_TIMESTAMP
170	static volatile unsigned int printk_cpu = UINT_MAX;
171	char tbuf[30];
172
173	char* print_time(void )
174	{
175	unsigned long long t;
176	unsigned long nanosec_rem;
177
178	t = cpu_clock(printk_cpu);
179	nanosec_rem = do_div(t, 1000000000);
180	sprintf(tbuf, "[%5lu.%06lu] ",
181	(unsigned long) t,
182	nanosec_rem / 1000);
183
184	return tbuf;
185	}
186	#endif
187
188
189	/* Module parameters */
190	extern int unifi_debug;
191
192	#ifdef UNIFI_DEBUG
193	#define DEBUG_BUFFER_SIZE 120
194
195	#define FORMAT_TRACE(_s, _len, _args, _fmt) \
196	do { \
197	va_start(_args, _fmt); \
198	_len += vsnprintf(&(_s)[_len], \
199	(DEBUG_BUFFER_SIZE - _len), \
200	_fmt, _args); \
201	va_end(_args); \
202	if (_len >= DEBUG_BUFFER_SIZE) { \
203	(_s)[DEBUG_BUFFER_SIZE - 2] = '\n'; \
204	(_s)[DEBUG_BUFFER_SIZE - 1] = 0; \
205	} \
206	} while (0)
635d2b00 GKH	207
	208	void
	209	unifi_error(void* ospriv, const char *fmt, ...)
	210	{
635d2b00 GKH	211	unifi_priv_t priv = (unifi_priv_t) ospriv;
	212	char s[DEBUG_BUFFER_SIZE];
	213	va_list args;
	214	unsigned int len;
	215	#ifdef ANDROID_TIMESTAMP
	216	if (priv != NULL) {
	217	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi%d: ", print_time(), priv->instance);
	218	} else {
	219	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi: ", print_time());
	220	}
	221	#else
	222	if (priv != NULL) {
	223	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi%d: ", priv->instance);
	224	} else {
	225	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi: ");
	226	}
	227	#endif /* ANDROID_TIMESTAMP */
	228	FORMAT_TRACE(s, len, args, fmt);
	229
	230	printk("%s", s);
635d2b00 GKH	231	}
	232
	233	void
	234	unifi_warning(void* ospriv, const char *fmt, ...)
	235	{
635d2b00 GKH	236	unifi_priv_t priv = (unifi_priv_t) ospriv;
	237	char s[DEBUG_BUFFER_SIZE];
	238	va_list args;
	239	unsigned int len;
	240
	241	#ifdef ANDROID_TIMESTAMP
	242	if (priv != NULL) {
	243	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "%s unifi%d: ", print_time(), priv->instance);
	244	} else {
	245	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "%s unifi: ", print_time());
	246	}
	247	#else
	248	if (priv != NULL) {
	249	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "unifi%d: ", priv->instance);
	250	} else {
	251	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "unifi: ");
	252	}
	253	#endif /* ANDROID_TIMESTAMP */
	254
	255	FORMAT_TRACE(s, len, args, fmt);
	256
	257	printk("%s", s);
635d2b00 GKH	258	}
	259
	260
	261	void
	262	unifi_notice(void* ospriv, const char *fmt, ...)
	263	{
635d2b00 GKH	264	unifi_priv_t priv = (unifi_priv_t) ospriv;
	265	char s[DEBUG_BUFFER_SIZE];
	266	va_list args;
	267	unsigned int len;
	268
	269	#ifdef ANDROID_TIMESTAMP
	270	if (priv != NULL) {
	271	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "%s unifi%d: ", print_time(), priv->instance);
	272	} else {
	273	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "%s unifi: ", print_time());
	274	}
	275	#else
	276	if (priv != NULL) {
	277	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "unifi%d: ", priv->instance);
	278	} else {
	279	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "unifi: ");
	280	}
	281	#endif /* ANDROID_TIMESTAMP */
	282
	283	FORMAT_TRACE(s, len, args, fmt);
	284
	285	printk("%s", s);
635d2b00 GKH	286	}
	287
	288
	289	void
	290	unifi_info(void* ospriv, const char *fmt, ...)
	291	{
635d2b00 GKH	292	unifi_priv_t priv = (unifi_priv_t) ospriv;
	293	char s[DEBUG_BUFFER_SIZE];
	294	va_list args;
	295	unsigned int len;
	296
	297	#ifdef ANDROID_TIMESTAMP
	298	if (priv != NULL) {
	299	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "%s unifi%d: ", print_time(), priv->instance);
	300	} else {
	301	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "%s unifi: ", print_time());
	302	}
	303	#else
	304	if (priv != NULL) {
	305	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "unifi%d: ", priv->instance);
	306	} else {
	307	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "unifi: ");
	308	}
	309	#endif /* ANDROID_TIMESTAMP */
	310
	311	FORMAT_TRACE(s, len, args, fmt);
	312
	313	printk("%s", s);
635d2b00 GKH	314	}
	315
	316	/* debugging */
	317	void
	318	unifi_trace(void* ospriv, int level, const char *fmt, ...)
	319	{
635d2b00 GKH	320	unifi_priv_t priv = (unifi_priv_t) ospriv;
	321	char s[DEBUG_BUFFER_SIZE];
	322	va_list args;
	323	unsigned int len;
	324
	325	if (unifi_debug >= level) {
	326	#ifdef ANDROID_TIMESTAMP
	327	if (priv != NULL) {
	328	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi%d: ", print_time(), priv->instance);
	329	} else {
	330	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi: ", print_time());
	331	}
	332	#else
	333	if (priv != NULL) {
	334	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi%d: ", priv->instance);
	335	} else {
	336	len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi: ");
	337	}
	338	#endif /* ANDROID_TIMESTAMP */
	339
	340	FORMAT_TRACE(s, len, args, fmt);
	341
	342	printk("%s", s);
	343	}
635d2b00 GKH	344	}
635d2b00 GKH	345
95edd09e GKH	346	#else
	347
	348	void
	349	unifi_error_nop(void* ospriv, const char *fmt, ...)
	350	{
	351	}
	352
	353	void
	354	unifi_trace_nop(void* ospriv, int level, const char *fmt, ...)
	355	{
	356	}
	357
	358	#endif /* UNIFI_DEBUG */
	359
	360
635d2b00 GKH	361	/*
	362	* ---------------------------------------------------------------------------
	363	*
	364	* Debugging support.
	365	*
	366	* ---------------------------------------------------------------------------
	367	*/
	368
	369	#ifdef UNIFI_DEBUG
	370
	371	/* Memory dump with level filter controlled by unifi_debug */
	372	void
8c87f69a	373	unifi_dump(void ospriv, int level, const char msg, void *mem, u16 len)
635d2b00 GKH	374	{
	375	unifi_priv_t priv = (unifi_priv_t) ospriv;
	376
	377	if (unifi_debug >= level) {
	378	#ifdef ANDROID_TIMESTAMP
	379	if (priv != NULL) {
	380	printk(KERN_ERR "%s unifi%d: --- dump: %s ---\n", print_time(), priv->instance, msg ? msg : "");
	381	} else {
	382	printk(KERN_ERR "%s unifi: --- dump: %s ---\n", print_time(), msg ? msg : "");
	383	}
	384	#else
	385	if (priv != NULL) {
	386	printk(KERN_ERR "unifi%d: --- dump: %s ---\n", priv->instance, msg ? msg : "");
	387	} else {
	388	printk(KERN_ERR "unifi: --- dump: %s ---\n", msg ? msg : "");
	389	}
	390	#endif /* ANDROID_TIMESTAMP */
	391	dump(mem, len);
	392
	393	if (priv != NULL) {
	394	printk(KERN_ERR "unifi%d: --- end of dump ---\n", priv->instance);
	395	} else {
	396	printk(KERN_ERR "unifi: --- end of dump ---\n");
	397	}
	398	}
	399	}
	400
	401	/* Memory dump that appears all the time, use sparingly */
	402	void
8c87f69a	403	dump(void *mem, u16 len)
635d2b00 GKH	404	{
	405	int i, col = 0;
	406	unsigned char pdata = (unsigned char )mem;
	407	#ifdef ANDROID_TIMESTAMP
	408	printk("timestamp %s \n", print_time());
	409	#endif /* ANDROID_TIMESTAMP */
	410	if (mem == NULL) {
	411	printk("(null dump)\n");
	412	return;
	413	}
	414	for (i = 0; i < len; i++) {
4933d393	415	if (col == 0)
635d2b00	416	printk("0x%02X: ", i);
635d2b00 GKH	417
	418	printk(" %02X", pdata[i]);
	419
	420	if (++col == 16) {
	421	printk("\n");
	422	col = 0;
	423	}
	424	}
4933d393	425	if (col)
635d2b00	426	printk("\n");
635d2b00 GKH	427	} /* dump() */
	428
	429
	430	void
8c87f69a	431	dump16(void *mem, u16 len)
635d2b00 GKH	432	{
	433	int i, col=0;
	434	unsigned short p = (unsigned short )mem;
	435	#ifdef ANDROID_TIMESTAMP
	436	printk("timestamp %s \n", print_time());
	437	#endif /* ANDROID_TIMESTAMP */
	438	for (i = 0; i < len; i+=2) {
4933d393	439	if (col == 0)
635d2b00	440	printk("0x%02X: ", i);
635d2b00 GKH	441
	442	printk(" %04X", *p++);
	443
	444	if (++col == 8) {
	445	printk("\n");
	446	col = 0;
	447	}
	448	}
4933d393	449	if (col)
635d2b00	450	printk("\n");
635d2b00 GKH	451	}
	452
	453
	454	#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
	455	void
8c87f69a	456	dump_str(void *mem, u16 len)
635d2b00	457	{
958bcf5b	458	int i;
635d2b00 GKH	459	unsigned char pdata = (unsigned char )mem;
	460	#ifdef ANDROID_TIMESTAMP
	461	printk("timestamp %s \n", print_time());
	462	#endif /* ANDROID_TIMESTAMP */
	463	for (i = 0; i < len; i++) {
	464	printk("%c", pdata[i]);
	465	}
958bcf5b	466	printk("\n");
635d2b00 GKH	467
	468	} /* dump_str() */
	469	#endif /* CSR_ONLY_NOTES */
	470
	471
	472	#endif /* UNIFI_DEBUG */
	473
	474
	475	/* ---------------------------------------------------------------------------
	476	* - End -
	477	* ------------------------------------------------------------------------- */