nxge/xgehal/xgehal-channel.c

29 #include <dev/nxge/include/xgehal-channel.h>
44 	xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
46 	if (channel->reserve_top >= channel->reserve_length) {
50 	*dtrh = channel->reserve_arr[channel->reserve_top++];
63 	xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
65 	if (channel->reserve_initial == channel->free_length) {
69 	*dtrh = channel->free_arr[channel->free_length++];
103 	xge_hal_channel_t *channel;
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;
139 	return channel;
142 void __hal_channel_free(xge_hal_channel_t *channel)
146 	xge_assert(channel->pdev);
148 	switch(channel->type) {
166 	xge_os_free(channel->pdev, channel, size);
174 	xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
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) {
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) {
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)
216 	xge_os_memzero(channel->orig_arr, sizeof(void*)*channel->reserve_max);
219 	xge_os_spin_lock_init_irq(&channel->free_lock, hldev->irqh);
221 	xge_os_spin_lock_init(&channel->free_lock, hldev->pdev);
229 	xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
232 	hldev = (xge_hal_device_t *)channel->devh;
234 	xge_assert(channel->pdev);
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;
255 	xge_os_spin_lock_destroy_irq(&channel->free_lock, hldev->irqh);
257 	xge_os_spin_lock_destroy(&channel->free_lock, hldev->pdev);
262  * xge_hal_channel_open - Open communication channel.
265  *        the channel.
266  * @channelh:  The channel handle. On success (XGE_HAL_OK) HAL fills
267  * this "out" parameter with a valid channel handle.
270  * Open communication channel with the device.
272  * HAL uses (persistent) channel configuration to allocate both channel
275  *     1) The channel config data is fed into HAL prior to
281  *     3) Either down or up queue may be omitted, in which case the channel
284  *     4) Post and completion queue may be the same, in which case the channel
291  * XGE_HAL_ERR_CHANNEL_NOT_FOUND - Unable to locate the channel.
306 	xge_hal_channel_t *channel = NULL;
314 	/* find channel */
322 	        channel = tmp;
327 	if (channel == NULL) {
331 	xge_assert((channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) ||
332 	    (channel->type == XGE_HAL_CHANNEL_TYPE_RING));
336 	    switch(channel->type) {
338 	            status = __hal_fifo_open(channel, attr);
341 	            status = __hal_ring_open(channel, attr);
355 	        for (i = 0; i < channel->reserve_initial; i++) {
356 	            channel->orig_arr[i] =
357 	                channel->reserve_arr[i];
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,
382 	/* move channel to the open state list */
384 	switch(channel->type) {
386 	        xge_list_remove(&channel->item);
387 	        xge_list_insert(&channel->item, &device->fifo_channels);
390 	        xge_list_remove(&channel->item);
391 	        xge_list_insert(&channel->item, &device->ring_channels);
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;
410 	channel->magic = XGE_HAL_MAGIC;
412 	*channelh = channel;
418  * xge_hal_channel_abort - Abort the channel.
422  * Terminate (via xge_hal_channel_dtr_term_f{}) all channel descriptors.
432 	xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
440 	if (channel->dtr_term == NULL) {
444 	free_length_sav = channel->free_length;
448 	    if (channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) {
451 	        if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
458 	    channel->dtr_term(channel, dtr, XGE_HAL_DTR_STATE_FREED,
459 	              channel->userdata, reopen);
461 	channel->free_length = free_length_sav;
467 	    if (channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) {
470 	        if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
478 	    channel->dtr_term(channel, dtr, XGE_HAL_DTR_STATE_POSTED,
479 	              channel->userdata, reopen);
483 	reserve_top_sav = channel->reserve_top;
488 	    if (channel->type == XGE_HAL_CHANNEL_TYPE_FIFO) {
491 	        if (channel->type == XGE_HAL_CHANNEL_TYPE_RING) {
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));
507 	xge_assert(check_cnt == channel->reserve_initial);
513  * xge_hal_channel_close - Close communication channel.
514  * @channelh: The channel handle.
517  * Will close previously opened channel and deallocate associated resources.
525 	xge_hal_channel_t *channel = (xge_hal_channel_t *)channelh;
528 	xge_assert(channel);
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 */
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));
553 	    switch(channel->type) {
565 	            xge_assert(channel->type == XGE_HAL_CHANNEL_TYPE_FIFO ||
566 	                   channel->type == XGE_HAL_CHANNEL_TYPE_RING);
575 	/* move channel back to free state list */
576 	xge_list_remove(&channel->item);
577 	xge_list_insert(&channel->item, &hldev->free_channels);