2 * Copyright (c) 2002-2007 Neterion, Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <dev/nxge/include/xgehal-channel.h>
30 #include <dev/nxge/include/xgehal-fifo.h>
31 #include <dev/nxge/include/xgehal-ring.h>
32 #include <dev/nxge/include/xgehal-device.h>
33 #include <dev/nxge/include/xgehal-regs.h>
36 * __hal_channel_dtr_next_reservelist
38 * Walking through the all available DTRs.
40 static xge_hal_status_e
41 __hal_channel_dtr_next_reservelist(xge_hal_channel_h channelh,
44 xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
46 if (channel->reserve_top >= channel->reserve_length) {
47 return XGE_HAL_INF_NO_MORE_FREED_DESCRIPTORS;
50 *dtrh = channel->reserve_arr[channel->reserve_top++];
56 * __hal_channel_dtr_next_freelist
58 * Walking through the "freed" DTRs.
60 static xge_hal_status_e
61 __hal_channel_dtr_next_freelist(xge_hal_channel_h channelh, xge_hal_dtr_h *dtrh)
63 xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
65 if (channel->reserve_initial == channel->free_length) {
66 return XGE_HAL_INF_NO_MORE_FREED_DESCRIPTORS;
69 *dtrh = channel->free_arr[channel->free_length++];
75 * __hal_channel_dtr_next_not_completed - Get the _next_ posted but
76 * not completed descriptor.
78 * Walking through the "not completed" DTRs.
80 static xge_hal_status_e
81 __hal_channel_dtr_next_not_completed(xge_hal_channel_h channelh,
84 xge_hal_ring_rxd_1_t *rxdp; /* doesn't matter 1, 3 or 5... */
85 __hal_channel_dtr_try_complete(channelh, dtrh);
87 return XGE_HAL_INF_NO_MORE_COMPLETED_DESCRIPTORS;
90 rxdp = (xge_hal_ring_rxd_1_t *)*dtrh;
91 xge_assert(rxdp->host_control!=0);
93 __hal_channel_dtr_complete(channelh);
99 __hal_channel_allocate(xge_hal_device_h devh, int post_qid,
100 xge_hal_channel_type_e type)
102 xge_hal_device_t *hldev = (xge_hal_device_t*)devh;
103 xge_hal_channel_t *channel;
107 case XGE_HAL_CHANNEL_TYPE_FIFO:
108 xge_assert(post_qid + 1 >= XGE_HAL_MIN_FIFO_NUM &&
109 post_qid + 1 <= XGE_HAL_MAX_FIFO_NUM);
110 size = sizeof(xge_hal_fifo_t);
112 case XGE_HAL_CHANNEL_TYPE_RING:
113 xge_assert(post_qid + 1 >= XGE_HAL_MIN_RING_NUM &&
114 post_qid + 1 <= XGE_HAL_MAX_RING_NUM);
115 size = sizeof(xge_hal_ring_t);
124 /* allocate FIFO channel */
125 channel = (xge_hal_channel_t *) xge_os_malloc(hldev->pdev, size);
126 if (channel == NULL) {
129 xge_os_memzero(channel, size);
131 channel->pdev = hldev->pdev;
132 channel->regh0 = hldev->regh0;
133 channel->regh1 = hldev->regh1;
134 channel->type = type;
135 channel->devh = devh;
136 channel->post_qid = post_qid;
137 channel->compl_qid = 0;
142 void __hal_channel_free(xge_hal_channel_t *channel)
146 xge_assert(channel->pdev);
148 switch(channel->type) {
149 case XGE_HAL_CHANNEL_TYPE_FIFO:
150 size = sizeof(xge_hal_fifo_t);
152 case XGE_HAL_CHANNEL_TYPE_RING:
153 size = sizeof(xge_hal_ring_t);
155 case XGE_HAL_CHANNEL_TYPE_SEND_QUEUE:
156 case XGE_HAL_CHANNEL_TYPE_RECEIVE_QUEUE:
157 case XGE_HAL_CHANNEL_TYPE_COMPLETION_QUEUE:
158 case XGE_HAL_CHANNEL_TYPE_UP_MESSAGE_QUEUE:
159 case XGE_HAL_CHANNEL_TYPE_DOWN_MESSAGE_QUEUE:
166 xge_os_free(channel->pdev, channel, size);
170 __hal_channel_initialize (xge_hal_channel_h channelh,
171 xge_hal_channel_attr_t *attr, void **reserve_arr,
172 int reserve_initial, int reserve_max, int reserve_threshold)
174 xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
175 xge_hal_device_t *hldev;
177 hldev = (xge_hal_device_t *)channel->devh;
179 channel->dtr_term = attr->dtr_term;
180 channel->dtr_init = attr->dtr_init;
181 channel->callback = attr->callback;
182 channel->userdata = attr->userdata;
183 channel->flags = attr->flags;
184 channel->per_dtr_space = attr->per_dtr_space;
186 channel->reserve_arr = reserve_arr;
187 channel->reserve_initial = reserve_initial;
188 channel->reserve_max = reserve_max;
189 channel->reserve_length = channel->reserve_initial;
190 channel->reserve_threshold = reserve_threshold;
191 channel->reserve_top = 0;
192 channel->saved_arr = (void **) xge_os_malloc(hldev->pdev,
193 sizeof(void*)*channel->reserve_max);
194 if (channel->saved_arr == NULL) {
195 return XGE_HAL_ERR_OUT_OF_MEMORY;
197 xge_os_memzero(channel->saved_arr, sizeof(void*)*channel->reserve_max);
198 channel->free_arr = channel->saved_arr;
199 channel->free_length = channel->reserve_initial;
200 channel->work_arr = (void **) xge_os_malloc(hldev->pdev,
201 sizeof(void*)*channel->reserve_max);
202 if (channel->work_arr == NULL) {
203 return XGE_HAL_ERR_OUT_OF_MEMORY;
205 xge_os_memzero(channel->work_arr,
206 sizeof(void*)*channel->reserve_max);
207 channel->post_index = 0;
208 channel->compl_index = 0;
209 channel->length = channel->reserve_initial;
211 channel->orig_arr = (void **) xge_os_malloc(hldev->pdev,
212 sizeof(void*)*channel->reserve_max);
213 if (channel->orig_arr == NULL)
214 return XGE_HAL_ERR_OUT_OF_MEMORY;
216 xge_os_memzero(channel->orig_arr, sizeof(void*)*channel->reserve_max);
218 #if defined(XGE_HAL_RX_MULTI_FREE_IRQ) || defined(XGE_HAL_TX_MULTI_FREE_IRQ)
219 xge_os_spin_lock_init_irq(&channel->free_lock, hldev->irqh);
220 #elif defined(XGE_HAL_RX_MULTI_FREE) || defined(XGE_HAL_TX_MULTI_FREE)
221 xge_os_spin_lock_init(&channel->free_lock, hldev->pdev);
227 void __hal_channel_terminate(xge_hal_channel_h channelh)
229 xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
230 xge_hal_device_t *hldev;
232 hldev = (xge_hal_device_t *)channel->devh;
234 xge_assert(channel->pdev);
235 /* undo changes made at channel_initialize() */
236 if (channel->work_arr) {
237 xge_os_free(channel->pdev, channel->work_arr,
238 sizeof(void*)*channel->reserve_max);
239 channel->work_arr = NULL;
242 if (channel->saved_arr) {
243 xge_os_free(channel->pdev, channel->saved_arr,
244 sizeof(void*)*channel->reserve_max);
245 channel->saved_arr = NULL;
248 if (channel->orig_arr) {
249 xge_os_free(channel->pdev, channel->orig_arr,
250 sizeof(void*)*channel->reserve_max);
251 channel->orig_arr = NULL;
254 #if defined(XGE_HAL_RX_MULTI_FREE_IRQ) || defined(XGE_HAL_TX_MULTI_FREE_IRQ)
255 xge_os_spin_lock_destroy_irq(&channel->free_lock, hldev->irqh);
256 #elif defined(XGE_HAL_RX_MULTI_FREE) || defined(XGE_HAL_TX_MULTI_FREE)
257 xge_os_spin_lock_destroy(&channel->free_lock, hldev->pdev);
262 * xge_hal_channel_open - Open communication channel.
263 * @devh: HAL device, pointer to xge_hal_device_t structure.
264 * @attr: Contains attributes required to open
266 * @channelh: The channel handle. On success (XGE_HAL_OK) HAL fills
267 * this "out" parameter with a valid channel handle.
268 * @reopen: See xge_hal_channel_reopen_e{}.
270 * Open communication channel with the device.
272 * HAL uses (persistent) channel configuration to allocate both channel
273 * and Xframe Tx and Rx descriptors.
275 * 1) The channel config data is fed into HAL prior to
276 * xge_hal_channel_open().
278 * 2) The corresponding hardware queues must be already configured and
281 * 3) Either down or up queue may be omitted, in which case the channel
282 * is treated as _unidirectional_.
284 * 4) Post and completion queue may be the same, in which case the channel
285 * is said to have "in-band completions".
287 * Note that free_channels list is not protected. i.e. caller must provide
290 * Returns: XGE_HAL_OK - success.
291 * XGE_HAL_ERR_CHANNEL_NOT_FOUND - Unable to locate the channel.
292 * XGE_HAL_ERR_OUT_OF_MEMORY - Memory allocation failed.
294 * See also: xge_hal_channel_attr_t{}.
295 * Usage: See ex_open{}.
298 xge_hal_channel_open(xge_hal_device_h devh,
299 xge_hal_channel_attr_t *attr,
300 xge_hal_channel_h *channelh,
301 xge_hal_channel_reopen_e reopen)
305 xge_hal_status_e status = XGE_HAL_OK;
306 xge_hal_channel_t *channel = NULL;
307 xge_hal_device_t *device = (xge_hal_device_t *)devh;
315 xge_list_for_each(item, &device->free_channels) {
316 xge_hal_channel_t *tmp;
318 tmp = xge_container_of(item, xge_hal_channel_t, item);
319 if (tmp->type == attr->type &&
320 tmp->post_qid == attr->post_qid &&
321 tmp->compl_qid == attr->compl_qid) {
327 if (channel == NULL) {
328 return XGE_HAL_ERR_CHANNEL_NOT_FOUND;
331 xge_assert((channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) ||
332 (channel->type == XGE_HAL_CHANNEL_TYPE_RING));
334 if (reopen == XGE_HAL_CHANNEL_OC_NORMAL) {
335 /* allocate memory, initialize pointers, etc */
336 switch(channel->type) {
337 case XGE_HAL_CHANNEL_TYPE_FIFO:
338 status = __hal_fifo_open(channel, attr);
340 case XGE_HAL_CHANNEL_TYPE_RING:
341 status = __hal_ring_open(channel, attr);
343 case XGE_HAL_CHANNEL_TYPE_SEND_QUEUE:
344 case XGE_HAL_CHANNEL_TYPE_RECEIVE_QUEUE:
345 case XGE_HAL_CHANNEL_TYPE_COMPLETION_QUEUE:
346 case XGE_HAL_CHANNEL_TYPE_UP_MESSAGE_QUEUE:
347 case XGE_HAL_CHANNEL_TYPE_DOWN_MESSAGE_QUEUE:
348 status = XGE_HAL_FAIL;
354 if (status == XGE_HAL_OK) {
355 for (i = 0; i < channel->reserve_initial; i++) {
356 channel->orig_arr[i] =
357 channel->reserve_arr[i];
363 xge_assert(reopen == XGE_HAL_CHANNEL_RESET_ONLY);
365 for (i = 0; i < channel->reserve_initial; i++) {
366 channel->reserve_arr[i] = channel->orig_arr[i];
367 channel->free_arr[i] = NULL;
369 channel->free_length = channel->reserve_initial;
370 channel->reserve_length = channel->reserve_initial;
371 channel->reserve_top = 0;
372 channel->post_index = 0;
373 channel->compl_index = 0;
374 if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
375 status = __hal_ring_initial_replenish(channel,
377 if (status != XGE_HAL_OK)
382 /* move channel to the open state list */
384 switch(channel->type) {
385 case XGE_HAL_CHANNEL_TYPE_FIFO:
386 xge_list_remove(&channel->item);
387 xge_list_insert(&channel->item, &device->fifo_channels);
389 case XGE_HAL_CHANNEL_TYPE_RING:
390 xge_list_remove(&channel->item);
391 xge_list_insert(&channel->item, &device->ring_channels);
393 case XGE_HAL_CHANNEL_TYPE_SEND_QUEUE:
394 case XGE_HAL_CHANNEL_TYPE_RECEIVE_QUEUE:
395 case XGE_HAL_CHANNEL_TYPE_COMPLETION_QUEUE:
396 case XGE_HAL_CHANNEL_TYPE_UP_MESSAGE_QUEUE:
397 case XGE_HAL_CHANNEL_TYPE_DOWN_MESSAGE_QUEUE:
398 xge_assert(channel->type == XGE_HAL_CHANNEL_TYPE_FIFO ||
399 channel->type == XGE_HAL_CHANNEL_TYPE_RING);
404 channel->is_open = 1;
405 channel->terminating = 0;
407 * The magic check the argument validity, has to be
408 * removed before 03/01/2005.
410 channel->magic = XGE_HAL_MAGIC;
418 * xge_hal_channel_abort - Abort the channel.
419 * @channelh: Channel handle.
420 * @reopen: See xge_hal_channel_reopen_e{}.
422 * Terminate (via xge_hal_channel_dtr_term_f{}) all channel descriptors.
423 * Currently used internally only by HAL, as part of its
424 * xge_hal_channel_close() and xge_hal_channel_open() in case
427 * See also: xge_hal_channel_dtr_term_f{}.
429 void xge_hal_channel_abort(xge_hal_channel_h channelh,
430 xge_hal_channel_reopen_e reopen)
432 xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
434 #ifdef XGE_OS_MEMORY_CHECK
440 if (channel->dtr_term == NULL) {
444 free_length_sav = channel->free_length;
445 while (__hal_channel_dtr_next_freelist(channelh, &dtr) == XGE_HAL_OK) {
446 #ifdef XGE_OS_MEMORY_CHECK
447 #ifdef XGE_DEBUG_ASSERT
448 if (channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) {
449 xge_assert(!__hal_fifo_txdl_priv(dtr)->allocated);
451 if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
452 xge_assert(!__hal_ring_rxd_priv((xge_hal_ring_t * ) channelh, dtr)->allocated);
458 channel->dtr_term(channel, dtr, XGE_HAL_DTR_STATE_FREED,
459 channel->userdata, reopen);
461 channel->free_length = free_length_sav;
463 while (__hal_channel_dtr_next_not_completed(channelh, &dtr) ==
465 #ifdef XGE_OS_MEMORY_CHECK
466 #ifdef XGE_DEBUG_ASSERT
467 if (channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) {
468 xge_assert(__hal_fifo_txdl_priv(dtr)->allocated);
470 if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
471 xge_assert(__hal_ring_rxd_priv((xge_hal_ring_t * ) channelh, dtr)
478 channel->dtr_term(channel, dtr, XGE_HAL_DTR_STATE_POSTED,
479 channel->userdata, reopen);
483 reserve_top_sav = channel->reserve_top;
484 while (__hal_channel_dtr_next_reservelist(channelh, &dtr) ==
486 #ifdef XGE_OS_MEMORY_CHECK
487 #ifdef XGE_DEBUG_ASSERT
488 if (channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) {
489 xge_assert(!__hal_fifo_txdl_priv(dtr)->allocated);
491 if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
492 xge_assert(!__hal_ring_rxd_priv((xge_hal_ring_t * ) channelh, dtr)->allocated);
498 channel->dtr_term(channel, dtr, XGE_HAL_DTR_STATE_AVAIL,
499 channel->userdata, reopen);
501 channel->reserve_top = reserve_top_sav;
503 xge_assert(channel->reserve_length ==
504 (channel->free_length + channel->reserve_top));
506 #ifdef XGE_OS_MEMORY_CHECK
507 xge_assert(check_cnt == channel->reserve_initial);
513 * xge_hal_channel_close - Close communication channel.
514 * @channelh: The channel handle.
515 * @reopen: See xge_hal_channel_reopen_e{}.
517 * Will close previously opened channel and deallocate associated resources.
518 * Channel must be opened otherwise assert will be generated.
519 * Note that free_channels list is not protected. i.e. caller must provide
522 void xge_hal_channel_close(xge_hal_channel_h channelh,
523 xge_hal_channel_reopen_e reopen)
525 xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
526 xge_hal_device_t *hldev;
529 xge_assert(channel->type < XGE_HAL_CHANNEL_TYPE_MAX);
531 hldev = (xge_hal_device_t *)channel->devh;
532 channel->is_open = 0;
533 channel->magic = XGE_HAL_DEAD;
535 /* sanity check: make sure channel is not in free list */
536 xge_list_for_each(item, &hldev->free_channels) {
537 xge_hal_channel_t *tmp;
539 tmp = xge_container_of(item, xge_hal_channel_t, item);
540 xge_assert(!tmp->is_open);
541 if (channel == tmp) {
546 xge_hal_channel_abort(channel, reopen);
548 xge_assert((channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) ||
549 (channel->type == XGE_HAL_CHANNEL_TYPE_RING));
551 if (reopen == XGE_HAL_CHANNEL_OC_NORMAL) {
553 switch(channel->type) {
554 case XGE_HAL_CHANNEL_TYPE_FIFO:
555 __hal_fifo_close(channelh);
557 case XGE_HAL_CHANNEL_TYPE_RING:
558 __hal_ring_close(channelh);
560 case XGE_HAL_CHANNEL_TYPE_SEND_QUEUE:
561 case XGE_HAL_CHANNEL_TYPE_RECEIVE_QUEUE:
562 case XGE_HAL_CHANNEL_TYPE_COMPLETION_QUEUE:
563 case XGE_HAL_CHANNEL_TYPE_UP_MESSAGE_QUEUE:
564 case XGE_HAL_CHANNEL_TYPE_DOWN_MESSAGE_QUEUE:
565 xge_assert(channel->type == XGE_HAL_CHANNEL_TYPE_FIFO ||
566 channel->type == XGE_HAL_CHANNEL_TYPE_RING);
573 xge_assert(reopen == XGE_HAL_CHANNEL_RESET_ONLY);
575 /* move channel back to free state list */
576 xge_list_remove(&channel->item);
577 xge_list_insert(&channel->item, &hldev->free_channels);
579 if (xge_list_is_empty(&hldev->fifo_channels) &&
580 xge_list_is_empty(&hldev->ring_channels)) {
581 /* clear msix_idx in case of following HW reset */
582 hldev->reset_needed_after_close = 1;