emlxs_mem.c (82527734) emlxs_mem.c (a9800beb)
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 6 unchanged lines hidden (view full) ---

15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 6 unchanged lines hidden (view full) ---

15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2009 Emulex. All rights reserved.
23 * Copyright 2010 Emulex. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27
28#include <emlxs.h>
29
30EMLXS_MSG_DEF(EMLXS_MEM_C);
31

--- 18 unchanged lines hidden (view full) ---

50
51 bzero(hba->memseg, sizeof (hba->memseg));
52
53 /*
54 * Initialize fc_table
55 */
56 cnt = cfg[CFG_NUM_IOTAGS].current;
57 if (cnt) {
24 * Use is subject to license terms.
25 */
26
27
28#include <emlxs.h>
29
30EMLXS_MSG_DEF(EMLXS_MEM_C);
31

--- 18 unchanged lines hidden (view full) ---

50
51 bzero(hba->memseg, sizeof (hba->memseg));
52
53 /*
54 * Initialize fc_table
55 */
56 cnt = cfg[CFG_NUM_IOTAGS].current;
57 if (cnt) {
58 hba->max_iotag = cnt;
58 hba->max_iotag = (uint16_t)cnt;
59 }
60 /* ioatg 0 is not used, iotags 1 thru max_iotag-1 are used */
61
62 /* Allocate the fc_table */
63 bzero(buf_info, sizeof (MBUF_INFO));
64 buf_info->size = (hba->max_iotag * sizeof (emlxs_buf_t *));
65
66 (void) emlxs_mem_alloc(hba, buf_info);

--- 225 unchanged lines hidden (view full) ---

292 (j == hba->CHANNEL_FCT) ||
293#endif /* SFCT_SUPPORT */
294 (j == hba->channel_ip)) {
295 addr = mp->phys;
296 }
297
298 if ((mp = emlxs_mem_get_vaddr(hba, rp, addr))) {
299 if (j == hba->channel_els) {
59 }
60 /* ioatg 0 is not used, iotags 1 thru max_iotag-1 are used */
61
62 /* Allocate the fc_table */
63 bzero(buf_info, sizeof (MBUF_INFO));
64 buf_info->size = (hba->max_iotag * sizeof (emlxs_buf_t *));
65
66 (void) emlxs_mem_alloc(hba, buf_info);

--- 225 unchanged lines hidden (view full) ---

292 (j == hba->CHANNEL_FCT) ||
293#endif /* SFCT_SUPPORT */
294 (j == hba->channel_ip)) {
295 addr = mp->phys;
296 }
297
298 if ((mp = emlxs_mem_get_vaddr(hba, rp, addr))) {
299 if (j == hba->channel_els) {
300 (void) emlxs_mem_put(hba,
301 MEM_ELSBUF, (uint8_t *)mp);
300 emlxs_mem_put(hba,
301 MEM_ELSBUF, (void *)mp);
302 } else if (j == hba->channel_ct) {
302 } else if (j == hba->channel_ct) {
303 (void) emlxs_mem_put(hba,
304 MEM_CTBUF, (uint8_t *)mp);
303 emlxs_mem_put(hba,
304 MEM_CTBUF, (void *)mp);
305 } else if (j == hba->channel_ip) {
305 } else if (j == hba->channel_ip) {
306 (void) emlxs_mem_put(hba,
307 MEM_IPBUF, (uint8_t *)mp);
306 emlxs_mem_put(hba,
307 MEM_IPBUF, (void *)mp);
308 }
309#ifdef SFCT_SUPPORT
310 else if (j == hba->CHANNEL_FCT) {
308 }
309#ifdef SFCT_SUPPORT
310 else if (j == hba->CHANNEL_FCT) {
311 (void) emlxs_mem_put(hba,
312 MEM_FCTBUF, (uint8_t *)mp);
311 emlxs_mem_put(hba,
312 MEM_FCTBUF, (void *)mp);
313 }
314#endif /* SFCT_SUPPORT */
315
316 }
317 }
318 }
319 }
320

--- 108 unchanged lines hidden (view full) ---

429 if (buf_info->virt == NULL) {
430 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
431 "%s buffer[%d]. size=%d", seg->fc_label, i,
432 buf_info->size);
433
434 /* Free the mp object */
435 bzero(buf_info, sizeof (MBUF_INFO));
436 buf_info->size = sizeof (MATCHMAP);
313 }
314#endif /* SFCT_SUPPORT */
315
316 }
317 }
318 }
319 }
320

--- 108 unchanged lines hidden (view full) ---

429 if (buf_info->virt == NULL) {
430 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
431 "%s buffer[%d]. size=%d", seg->fc_label, i,
432 buf_info->size);
433
434 /* Free the mp object */
435 bzero(buf_info, sizeof (MBUF_INFO));
436 buf_info->size = sizeof (MATCHMAP);
437 buf_info->virt = (uint32_t *)mp;
437 buf_info->virt = (void *)mp;
438 emlxs_mem_free(hba, buf_info);
439
440 goto failed;
441 }
442 bp = (uint8_t *)buf_info->virt;
443 bzero(bp, seg->fc_memsize);
444
445 mp->virt = buf_info->virt;

--- 121 unchanged lines hidden (view full) ---

567 buf_info->phys = mp->phys;
568 buf_info->dma_handle = mp->dma_handle;
569 buf_info->data_handle = mp->data_handle;
570 buf_info->flags = seg->fc_memflag;
571 emlxs_mem_free(hba, buf_info);
572
573 bzero(buf_info, sizeof (MBUF_INFO));
574 buf_info->size = sizeof (MATCHMAP);
438 emlxs_mem_free(hba, buf_info);
439
440 goto failed;
441 }
442 bp = (uint8_t *)buf_info->virt;
443 bzero(bp, seg->fc_memsize);
444
445 mp->virt = buf_info->virt;

--- 121 unchanged lines hidden (view full) ---

567 buf_info->phys = mp->phys;
568 buf_info->dma_handle = mp->dma_handle;
569 buf_info->data_handle = mp->data_handle;
570 buf_info->flags = seg->fc_memflag;
571 emlxs_mem_free(hba, buf_info);
572
573 bzero(buf_info, sizeof (MBUF_INFO));
574 buf_info->size = sizeof (MATCHMAP);
575 buf_info->virt = (uint32_t *)mp;
575 buf_info->virt = (void *)mp;
576 emlxs_mem_free(hba, buf_info);
577 }
578
579 /* Free memory associated with all buffers on put buffer pool */
580 while ((bp = seg->fc_memput_ptr) != NULL) {
581 seg->fc_memput_ptr = *((uint8_t **)bp);
582 mp = (MATCHMAP *)bp;
583
584 bzero(buf_info, sizeof (MBUF_INFO));
585 buf_info->size = mp->size;
586 buf_info->virt = mp->virt;
587 buf_info->phys = mp->phys;
588 buf_info->dma_handle = mp->dma_handle;
589 buf_info->data_handle = mp->data_handle;
590 buf_info->flags = seg->fc_memflag;
591 emlxs_mem_free(hba, buf_info);
592
593 bzero(buf_info, sizeof (MBUF_INFO));
594 buf_info->size = sizeof (MATCHMAP);
576 emlxs_mem_free(hba, buf_info);
577 }
578
579 /* Free memory associated with all buffers on put buffer pool */
580 while ((bp = seg->fc_memput_ptr) != NULL) {
581 seg->fc_memput_ptr = *((uint8_t **)bp);
582 mp = (MATCHMAP *)bp;
583
584 bzero(buf_info, sizeof (MBUF_INFO));
585 buf_info->size = mp->size;
586 buf_info->virt = mp->virt;
587 buf_info->phys = mp->phys;
588 buf_info->dma_handle = mp->dma_handle;
589 buf_info->data_handle = mp->data_handle;
590 buf_info->flags = seg->fc_memflag;
591 emlxs_mem_free(hba, buf_info);
592
593 bzero(buf_info, sizeof (MBUF_INFO));
594 buf_info->size = sizeof (MATCHMAP);
595 buf_info->virt = (uint32_t *)mp;
595 buf_info->virt = (void *)mp;
596 emlxs_mem_free(hba, buf_info);
597 }
598
599 return;
600
601} /* emlxs_mem_pool_free() */
602
603
596 emlxs_mem_free(hba, buf_info);
597 }
598
599 return;
600
601} /* emlxs_mem_pool_free() */
602
603
604extern uint8_t *
604extern void *
605emlxs_mem_pool_get(emlxs_hba_t *hba, MEMSEG *seg, uint32_t priority)
606{
605emlxs_mem_pool_get(emlxs_hba_t *hba, MEMSEG *seg, uint32_t priority)
606{
607 emlxs_port_t *port = &PPORT;
608 uint8_t *bp = NULL;
609 MATCHMAP *mp;
610 uint32_t free;
607 emlxs_port_t *port = &PPORT;
608 void *bp = NULL;
609 MATCHMAP *mp;
610 uint32_t free;
611
612 mutex_enter(&EMLXS_MEMGET_LOCK);
613
614 /* Check if memory segment destroyed! */
615 if (seg->fc_total_memsize == 0) {
616 mutex_exit(&EMLXS_MEMGET_LOCK);
617 return (NULL);
618 }

--- 60 unchanged lines hidden (view full) ---

679
680 mutex_exit(&EMLXS_MEMGET_LOCK);
681
682 return (bp);
683
684} /* emlxs_mem_pool_get() */
685
686
611
612 mutex_enter(&EMLXS_MEMGET_LOCK);
613
614 /* Check if memory segment destroyed! */
615 if (seg->fc_total_memsize == 0) {
616 mutex_exit(&EMLXS_MEMGET_LOCK);
617 return (NULL);
618 }

--- 60 unchanged lines hidden (view full) ---

679
680 mutex_exit(&EMLXS_MEMGET_LOCK);
681
682 return (bp);
683
684} /* emlxs_mem_pool_get() */
685
686
687extern MEMSEG *
688emlxs_mem_pool_put(emlxs_hba_t *hba, MEMSEG *seg, uint8_t *bp)
687extern void
688emlxs_mem_pool_put(emlxs_hba_t *hba, MEMSEG *seg, void *bp)
689{
689{
690 emlxs_port_t *port = &PPORT;
691 MATCHMAP *mp;
692 uint8_t *base;
693 uint8_t *end;
690 emlxs_port_t *port = &PPORT;
691 MATCHMAP *mp;
692 void *base;
693 void *end;
694
695 /* Free the pool object */
696 mutex_enter(&EMLXS_MEMPUT_LOCK);
697
698 /* Check if memory segment destroyed! */
699 if (seg->fc_total_memsize == 0) {
700 mutex_exit(&EMLXS_MEMPUT_LOCK);
694
695 /* Free the pool object */
696 mutex_enter(&EMLXS_MEMPUT_LOCK);
697
698 /* Check if memory segment destroyed! */
699 if (seg->fc_total_memsize == 0) {
700 mutex_exit(&EMLXS_MEMPUT_LOCK);
701 return (NULL);
701 return;
702 }
703
704 /* Check if buffer was just freed */
705 if (seg->fc_memput_ptr == bp) {
706 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
707 "%s: Freeing free object: bp=%p", seg->fc_label, bp);
708
709 mutex_exit(&EMLXS_MEMPUT_LOCK);
702 }
703
704 /* Check if buffer was just freed */
705 if (seg->fc_memput_ptr == bp) {
706 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
707 "%s: Freeing free object: bp=%p", seg->fc_label, bp);
708
709 mutex_exit(&EMLXS_MEMPUT_LOCK);
710 return (NULL);
710 return;
711 }
712
713 /* Validate the buffer belongs to this pool */
714 if (seg->fc_memflag & FC_MBUF_DMA) {
715 mp = (MATCHMAP *)bp;
716
717 if (!(mp->flag & MAP_POOL_ALLOCATED) ||
718 (mp->segment != seg)) {

--- 4 unchanged lines hidden (view full) ---

723
724 EMLXS_STATE_CHANGE(hba, FC_ERROR);
725
726 mutex_exit(&EMLXS_MEMPUT_LOCK);
727
728 emlxs_thread_spawn(hba, emlxs_shutdown_thread,
729 NULL, NULL);
730
711 }
712
713 /* Validate the buffer belongs to this pool */
714 if (seg->fc_memflag & FC_MBUF_DMA) {
715 mp = (MATCHMAP *)bp;
716
717 if (!(mp->flag & MAP_POOL_ALLOCATED) ||
718 (mp->segment != seg)) {

--- 4 unchanged lines hidden (view full) ---

723
724 EMLXS_STATE_CHANGE(hba, FC_ERROR);
725
726 mutex_exit(&EMLXS_MEMPUT_LOCK);
727
728 emlxs_thread_spawn(hba, emlxs_shutdown_thread,
729 NULL, NULL);
730
731 return (NULL);
731 return;
732 }
733
734 } else { /* Vmem_pool */
735 base = seg->fc_memstart_virt;
732 }
733
734 } else { /* Vmem_pool */
735 base = seg->fc_memstart_virt;
736 end = seg->fc_memstart_virt + seg->fc_total_memsize;
736 end = (void *)((uint8_t *)seg->fc_memstart_virt +
737 seg->fc_total_memsize);
737
738 if (bp < base || bp >= end) {
739 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
740 "emlxs_mem_pool_put: %s Invalid: bp=%p base=%p " \
741 "end=%p", seg->fc_label,
742 bp, base, end);
743
744 EMLXS_STATE_CHANGE(hba, FC_ERROR);
745
746 mutex_exit(&EMLXS_MEMPUT_LOCK);
747
748 emlxs_thread_spawn(hba, emlxs_shutdown_thread,
749 NULL, NULL);
750
738
739 if (bp < base || bp >= end) {
740 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
741 "emlxs_mem_pool_put: %s Invalid: bp=%p base=%p " \
742 "end=%p", seg->fc_label,
743 bp, base, end);
744
745 EMLXS_STATE_CHANGE(hba, FC_ERROR);
746
747 mutex_exit(&EMLXS_MEMPUT_LOCK);
748
749 emlxs_thread_spawn(hba, emlxs_shutdown_thread,
750 NULL, NULL);
751
751 return (NULL);
752 return;
752 }
753 }
754
755 /* Release buffer to the end of the freelist */
756 if (seg->fc_memput_end == NULL) {
757 seg->fc_memput_ptr = bp;
758 seg->fc_memput_cnt = 1;
759 } else {
753 }
754 }
755
756 /* Release buffer to the end of the freelist */
757 if (seg->fc_memput_end == NULL) {
758 seg->fc_memput_ptr = bp;
759 seg->fc_memput_cnt = 1;
760 } else {
760 *((uint8_t **)(seg->fc_memput_end)) = bp;
761 *((void **)(seg->fc_memput_end)) = bp;
761 seg->fc_memput_cnt++;
762 }
763 seg->fc_memput_end = bp;
762 seg->fc_memput_cnt++;
763 }
764 seg->fc_memput_end = bp;
764 *((uint8_t **)(bp)) = NULL;
765 *((void **)(bp)) = NULL;
765
766 mutex_exit(&EMLXS_MEMPUT_LOCK);
767
766
767 mutex_exit(&EMLXS_MEMPUT_LOCK);
768
768 return (seg);
769 return;
769
770} /* emlxs_mem_pool_put() */
771
772
773extern MATCHMAP *
774emlxs_mem_buf_alloc(emlxs_hba_t *hba, uint32_t size)
775{
776 emlxs_port_t *port = &PPORT;

--- 28 unchanged lines hidden (view full) ---

805 if (buf_info->virt == NULL) {
806
807 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
808 "MEM_BUF_ALLOC DMA buffer.");
809
810 /* Free the mp object */
811 bzero(buf_info, sizeof (MBUF_INFO));
812 buf_info->size = sizeof (MATCHMAP);
770
771} /* emlxs_mem_pool_put() */
772
773
774extern MATCHMAP *
775emlxs_mem_buf_alloc(emlxs_hba_t *hba, uint32_t size)
776{
777 emlxs_port_t *port = &PPORT;

--- 28 unchanged lines hidden (view full) ---

806 if (buf_info->virt == NULL) {
807
808 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg,
809 "MEM_BUF_ALLOC DMA buffer.");
810
811 /* Free the mp object */
812 bzero(buf_info, sizeof (MBUF_INFO));
813 buf_info->size = sizeof (MATCHMAP);
813 buf_info->virt = (uint32_t *)mp;
814 buf_info->virt = (void *)mp;
814 emlxs_mem_free(hba, buf_info);
815
816 return (0);
817 }
818 bp = (uint8_t *)buf_info->virt;
819 bzero(bp, MEM_BUF_SIZE);
820
821 mp->virt = buf_info->virt;

--- 4 unchanged lines hidden (view full) ---

826 mp->tag = MEM_BUF;
827 mp->flag |= MAP_BUF_ALLOCATED;
828
829 return (mp);
830
831} /* emlxs_mem_buf_alloc() */
832
833
815 emlxs_mem_free(hba, buf_info);
816
817 return (0);
818 }
819 bp = (uint8_t *)buf_info->virt;
820 bzero(bp, MEM_BUF_SIZE);
821
822 mp->virt = buf_info->virt;

--- 4 unchanged lines hidden (view full) ---

827 mp->tag = MEM_BUF;
828 mp->flag |= MAP_BUF_ALLOCATED;
829
830 return (mp);
831
832} /* emlxs_mem_buf_alloc() */
833
834
834extern MATCHMAP *
835extern void
835emlxs_mem_buf_free(emlxs_hba_t *hba, MATCHMAP *mp)
836{
837 MBUF_INFO bufinfo;
838 MBUF_INFO *buf_info;
839
840 buf_info = &bufinfo;
841
842 if (!(mp->flag & MAP_BUF_ALLOCATED)) {
836emlxs_mem_buf_free(emlxs_hba_t *hba, MATCHMAP *mp)
837{
838 MBUF_INFO bufinfo;
839 MBUF_INFO *buf_info;
840
841 buf_info = &bufinfo;
842
843 if (!(mp->flag & MAP_BUF_ALLOCATED)) {
843 return (NULL);
844 return;
844 }
845
846 bzero(buf_info, sizeof (MBUF_INFO));
847 buf_info->size = mp->size;
848 buf_info->virt = mp->virt;
849 buf_info->phys = mp->phys;
850 buf_info->dma_handle = mp->dma_handle;
851 buf_info->data_handle = mp->data_handle;
852 buf_info->flags = FC_MBUF_DMA;
853 emlxs_mem_free(hba, buf_info);
854
855 bzero(buf_info, sizeof (MBUF_INFO));
856 buf_info->size = sizeof (MATCHMAP);
845 }
846
847 bzero(buf_info, sizeof (MBUF_INFO));
848 buf_info->size = mp->size;
849 buf_info->virt = mp->virt;
850 buf_info->phys = mp->phys;
851 buf_info->dma_handle = mp->dma_handle;
852 buf_info->data_handle = mp->data_handle;
853 buf_info->flags = FC_MBUF_DMA;
854 emlxs_mem_free(hba, buf_info);
855
856 bzero(buf_info, sizeof (MBUF_INFO));
857 buf_info->size = sizeof (MATCHMAP);
857 buf_info->virt = (uint32_t *)mp;
858 buf_info->virt = (void *)mp;
858 emlxs_mem_free(hba, buf_info);
859
859 emlxs_mem_free(hba, buf_info);
860
860 return (mp);
861 return;
861
862} /* emlxs_mem_buf_free() */
863
864
862
863} /* emlxs_mem_buf_free() */
864
865
865extern uint8_t *
866extern void *
866emlxs_mem_get(emlxs_hba_t *hba, uint32_t seg_id, uint32_t priority)
867{
867emlxs_mem_get(emlxs_hba_t *hba, uint32_t seg_id, uint32_t priority)
868{
868 emlxs_port_t *port = &PPORT;
869 uint8_t *bp;
870 MAILBOXQ *mbq;
871 IOCBQ *iocbq;
872 NODELIST *node;
873 MEMSEG *seg;
869 emlxs_port_t *port = &PPORT;
870 void *bp;
871 MAILBOXQ *mbq;
872 IOCBQ *iocbq;
873 NODELIST *node;
874 MEMSEG *seg;
874
875 if (seg_id >= FC_MAX_SEG) {
876
877 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
878 "emlxs_mem_get: Invalid segment id = %d",
879 seg_id);
880
881 return (NULL);

--- 22 unchanged lines hidden (view full) ---

904 }
905 }
906
907 return (bp);
908
909} /* emlxs_mem_get() */
910
911
875
876 if (seg_id >= FC_MAX_SEG) {
877
878 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
879 "emlxs_mem_get: Invalid segment id = %d",
880 seg_id);
881
882 return (NULL);

--- 22 unchanged lines hidden (view full) ---

905 }
906 }
907
908 return (bp);
909
910} /* emlxs_mem_get() */
911
912
912extern uint8_t *
913emlxs_mem_put(emlxs_hba_t *hba, uint32_t seg_id, uint8_t *bp)
913extern void
914emlxs_mem_put(emlxs_hba_t *hba, uint32_t seg_id, void *bp)
914{
915{
915 emlxs_port_t *port = &PPORT;
916 MAILBOXQ *mbq;
917 IOCBQ *iocbq;
918 NODELIST *node;
919 MEMSEG *seg;
920 MATCHMAP *mp;
916 emlxs_port_t *port = &PPORT;
917 MAILBOXQ *mbq;
918 IOCBQ *iocbq;
919 NODELIST *node;
920 MEMSEG *seg;
921 MATCHMAP *mp;
921
922 if (seg_id >= FC_MAX_SEG) {
923
924 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
925 "emlxs_mem_put: Invalid segment id = %d: bp=%p",
926 seg_id, bp);
927
922
923 if (seg_id >= FC_MAX_SEG) {
924
925 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pool_error_msg,
926 "emlxs_mem_put: Invalid segment id = %d: bp=%p",
927 seg_id, bp);
928
928 return (NULL);
929 return;
929 }
930 seg = &hba->memseg[seg_id];
931
932 /* Verify buffer */
933 switch (seg_id) {
934 case MEM_MBOX:
935 mbq = (MAILBOXQ *)bp;
936
937 if (!(mbq->flag & MBQ_POOL_ALLOCATED)) {
930 }
931 seg = &hba->memseg[seg_id];
932
933 /* Verify buffer */
934 switch (seg_id) {
935 case MEM_MBOX:
936 mbq = (MAILBOXQ *)bp;
937
938 if (!(mbq->flag & MBQ_POOL_ALLOCATED)) {
938 return (NULL);
939 return;
939 }
940 break;
941
942 case MEM_IOCB:
943 iocbq = (IOCBQ *)bp;
944
945 if (!(iocbq->flag & IOCB_POOL_ALLOCATED)) {
940 }
941 break;
942
943 case MEM_IOCB:
944 iocbq = (IOCBQ *)bp;
945
946 if (!(iocbq->flag & IOCB_POOL_ALLOCATED)) {
946 return (NULL);
947 return;
947 }
948
949 /* Any IOCBQ with a packet attached did not come */
950 /* from our pool */
951 if (iocbq->sbp) {
948 }
949
950 /* Any IOCBQ with a packet attached did not come */
951 /* from our pool */
952 if (iocbq->sbp) {
952 return (NULL);
953 return;
953 }
954 break;
955
956 case MEM_NLP:
957 node = (NODELIST *)bp;
958
959 if (!(node->flag & NODE_POOL_ALLOCATED)) {
954 }
955 break;
956
957 case MEM_NLP:
958 node = (NODELIST *)bp;
959
960 if (!(node->flag & NODE_POOL_ALLOCATED)) {
960 return (NULL);
961 return;
961 }
962 break;
963
964 default:
965 mp = (MATCHMAP *)bp;
966
967 if (mp->flag & MAP_BUF_ALLOCATED) {
962 }
963 break;
964
965 default:
966 mp = (MATCHMAP *)bp;
967
968 if (mp->flag & MAP_BUF_ALLOCATED) {
968 return ((uint8_t *)emlxs_mem_buf_free(hba, mp));
969 emlxs_mem_buf_free(hba, mp);
970 return;
969 }
970
971 if (mp->flag & MAP_TABLE_ALLOCATED) {
971 }
972
973 if (mp->flag & MAP_TABLE_ALLOCATED) {
972 return (bp);
974 return;
973 }
974
975 if (!(mp->flag & MAP_POOL_ALLOCATED)) {
975 }
976
977 if (!(mp->flag & MAP_POOL_ALLOCATED)) {
976 return (NULL);
978 return;
977 }
978 break;
979 }
980
981 /* Free a buffer to the pool */
979 }
980 break;
981 }
982
983 /* Free a buffer to the pool */
982 if (emlxs_mem_pool_put(hba, seg, bp) == NULL) {
983 return (NULL);
984 }
984 emlxs_mem_pool_put(hba, seg, bp);
985
985
986 return (bp);
986 return;
987
988} /* emlxs_mem_put() */
989
990
991/*
992 * Look up the virtual address given a mapped address
993 */
994/* SLI3 */

--- 11 unchanged lines hidden (view full) ---

1006 while (mp) {
1007 if (mp->phys == mapbp) {
1008 if (prev == 0) {
1009 rp->fc_mpoff = mp->fc_mptr;
1010 } else {
1011 prev->fc_mptr = mp->fc_mptr;
1012 }
1013
987
988} /* emlxs_mem_put() */
989
990
991/*
992 * Look up the virtual address given a mapped address
993 */
994/* SLI3 */

--- 11 unchanged lines hidden (view full) ---

1006 while (mp) {
1007 if (mp->phys == mapbp) {
1008 if (prev == 0) {
1009 rp->fc_mpoff = mp->fc_mptr;
1010 } else {
1011 prev->fc_mptr = mp->fc_mptr;
1012 }
1013
1014 if (rp->fc_mpon == (uint8_t *)mp) {
1015 rp->fc_mpon = (uint8_t *)prev;
1014 if (rp->fc_mpon == mp) {
1015 rp->fc_mpon = (void *)prev;
1016 }
1017
1016 }
1017
1018 mp->fc_mptr = 0;
1018 mp->fc_mptr = NULL;
1019
1020 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1021 DDI_DMA_SYNC_FORKERNEL);
1022
1023 HBASTATS.ElsUbPosted--;
1024
1025 return (mp);
1026 }

--- 14 unchanged lines hidden (view full) ---

1041 while (mp) {
1042 if (mp->phys == mapbp) {
1043 if (prev == 0) {
1044 rp->fc_mpoff = mp->fc_mptr;
1045 } else {
1046 prev->fc_mptr = mp->fc_mptr;
1047 }
1048
1019
1020 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1021 DDI_DMA_SYNC_FORKERNEL);
1022
1023 HBASTATS.ElsUbPosted--;
1024
1025 return (mp);
1026 }

--- 14 unchanged lines hidden (view full) ---

1041 while (mp) {
1042 if (mp->phys == mapbp) {
1043 if (prev == 0) {
1044 rp->fc_mpoff = mp->fc_mptr;
1045 } else {
1046 prev->fc_mptr = mp->fc_mptr;
1047 }
1048
1049 if (rp->fc_mpon == (uint8_t *)mp) {
1050 rp->fc_mpon = (uint8_t *)prev;
1049 if (rp->fc_mpon == mp) {
1050 rp->fc_mpon = (void *)prev;
1051 }
1052
1051 }
1052
1053 mp->fc_mptr = 0;
1053 mp->fc_mptr = NULL;
1054
1055 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1056 DDI_DMA_SYNC_FORKERNEL);
1057
1058 HBASTATS.CtUbPosted--;
1059
1060 return (mp);
1061 }

--- 14 unchanged lines hidden (view full) ---

1076 while (mp) {
1077 if (mp->phys == mapbp) {
1078 if (prev == 0) {
1079 rp->fc_mpoff = mp->fc_mptr;
1080 } else {
1081 prev->fc_mptr = mp->fc_mptr;
1082 }
1083
1054
1055 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1056 DDI_DMA_SYNC_FORKERNEL);
1057
1058 HBASTATS.CtUbPosted--;
1059
1060 return (mp);
1061 }

--- 14 unchanged lines hidden (view full) ---

1076 while (mp) {
1077 if (mp->phys == mapbp) {
1078 if (prev == 0) {
1079 rp->fc_mpoff = mp->fc_mptr;
1080 } else {
1081 prev->fc_mptr = mp->fc_mptr;
1082 }
1083
1084 if (rp->fc_mpon == (uint8_t *)mp) {
1085 rp->fc_mpon = (uint8_t *)prev;
1084 if (rp->fc_mpon == mp) {
1085 rp->fc_mpon = (void *)prev;
1086 }
1087
1086 }
1087
1088 mp->fc_mptr = 0;
1088 mp->fc_mptr = NULL;
1089
1090 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1091 DDI_DMA_SYNC_FORKERNEL);
1092
1093 HBASTATS.IpUbPosted--;
1094
1095 return (mp);
1096 }

--- 14 unchanged lines hidden (view full) ---

1111 while (mp) {
1112 if (mp->phys == mapbp) {
1113 if (prev == 0) {
1114 rp->fc_mpoff = mp->fc_mptr;
1115 } else {
1116 prev->fc_mptr = mp->fc_mptr;
1117 }
1118
1089
1090 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1091 DDI_DMA_SYNC_FORKERNEL);
1092
1093 HBASTATS.IpUbPosted--;
1094
1095 return (mp);
1096 }

--- 14 unchanged lines hidden (view full) ---

1111 while (mp) {
1112 if (mp->phys == mapbp) {
1113 if (prev == 0) {
1114 rp->fc_mpoff = mp->fc_mptr;
1115 } else {
1116 prev->fc_mptr = mp->fc_mptr;
1117 }
1118
1119 if (rp->fc_mpon == (uint8_t *)mp) {
1120 rp->fc_mpon = (uint8_t *)prev;
1119 if (rp->fc_mpon == mp) {
1120 rp->fc_mpon = (void *)prev;
1121 }
1122
1121 }
1122
1123 mp->fc_mptr = 0;
1123 mp->fc_mptr = NULL;
1124
1125 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1126 DDI_DMA_SYNC_FORKERNEL);
1127
1128 HBASTATS.FctUbPosted--;
1129
1130 return (mp);
1131 }

--- 24 unchanged lines hidden (view full) ---

1156 uint32_t *haddr, uint32_t *laddr)
1157{
1158 if (rp->ringno == hba->channel_els) {
1159 /*
1160 * Update slot fc_mpon points to then bump it
1161 * fc_mpoff is pointer head of the list.
1162 * fc_mpon is pointer tail of the list.
1163 */
1124
1125 EMLXS_MPDATA_SYNC(mp->dma_handle, 0, mp->size,
1126 DDI_DMA_SYNC_FORKERNEL);
1127
1128 HBASTATS.FctUbPosted--;
1129
1130 return (mp);
1131 }

--- 24 unchanged lines hidden (view full) ---

1156 uint32_t *haddr, uint32_t *laddr)
1157{
1158 if (rp->ringno == hba->channel_els) {
1159 /*
1160 * Update slot fc_mpon points to then bump it
1161 * fc_mpoff is pointer head of the list.
1162 * fc_mpon is pointer tail of the list.
1163 */
1164 mp->fc_mptr = 0;
1164 mp->fc_mptr = NULL;
1165 if (rp->fc_mpoff == 0) {
1165 if (rp->fc_mpoff == 0) {
1166 rp->fc_mpoff = (uint8_t *)mp;
1167 rp->fc_mpon = (uint8_t *)mp;
1166 rp->fc_mpoff = (void *)mp;
1167 rp->fc_mpon = (void *)mp;
1168 } else {
1169 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1168 } else {
1169 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1170 (uint8_t *)mp;
1171 rp->fc_mpon = (uint8_t *)mp;
1170 (void *)mp;
1171 rp->fc_mpon = (void *)mp;
1172 }
1173
1174 if (hba->flag & FC_SLIM2_MODE) {
1175
1176 /* return mapped address */
1177 *haddr = PADDR_HI(mp->phys);
1178 /* return mapped address */
1179 *laddr = PADDR_LO(mp->phys);

--- 5 unchanged lines hidden (view full) ---

1185 HBASTATS.ElsUbPosted++;
1186
1187 } else if (rp->ringno == hba->channel_ct) {
1188 /*
1189 * Update slot fc_mpon points to then bump it
1190 * fc_mpoff is pointer head of the list.
1191 * fc_mpon is pointer tail of the list.
1192 */
1172 }
1173
1174 if (hba->flag & FC_SLIM2_MODE) {
1175
1176 /* return mapped address */
1177 *haddr = PADDR_HI(mp->phys);
1178 /* return mapped address */
1179 *laddr = PADDR_LO(mp->phys);

--- 5 unchanged lines hidden (view full) ---

1185 HBASTATS.ElsUbPosted++;
1186
1187 } else if (rp->ringno == hba->channel_ct) {
1188 /*
1189 * Update slot fc_mpon points to then bump it
1190 * fc_mpoff is pointer head of the list.
1191 * fc_mpon is pointer tail of the list.
1192 */
1193 mp->fc_mptr = 0;
1193 mp->fc_mptr = NULL;
1194 if (rp->fc_mpoff == 0) {
1194 if (rp->fc_mpoff == 0) {
1195 rp->fc_mpoff = (uint8_t *)mp;
1196 rp->fc_mpon = (uint8_t *)mp;
1195 rp->fc_mpoff = (void *)mp;
1196 rp->fc_mpon = (void *)mp;
1197 } else {
1198 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1197 } else {
1198 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1199 (uint8_t *)mp;
1200 rp->fc_mpon = (uint8_t *)mp;
1199 (void *)mp;
1200 rp->fc_mpon = (void *)mp;
1201 }
1202
1203 if (hba->flag & FC_SLIM2_MODE) {
1204 /* return mapped address */
1205 *haddr = PADDR_HI(mp->phys);
1206 /* return mapped address */
1207 *laddr = PADDR_LO(mp->phys);
1208 } else {

--- 5 unchanged lines hidden (view full) ---

1214
1215
1216 } else if (rp->ringno == hba->channel_ip) {
1217 /*
1218 * Update slot fc_mpon points to then bump it
1219 * fc_mpoff is pointer head of the list.
1220 * fc_mpon is pointer tail of the list.
1221 */
1201 }
1202
1203 if (hba->flag & FC_SLIM2_MODE) {
1204 /* return mapped address */
1205 *haddr = PADDR_HI(mp->phys);
1206 /* return mapped address */
1207 *laddr = PADDR_LO(mp->phys);
1208 } else {

--- 5 unchanged lines hidden (view full) ---

1214
1215
1216 } else if (rp->ringno == hba->channel_ip) {
1217 /*
1218 * Update slot fc_mpon points to then bump it
1219 * fc_mpoff is pointer head of the list.
1220 * fc_mpon is pointer tail of the list.
1221 */
1222 mp->fc_mptr = 0;
1222 mp->fc_mptr = NULL;
1223 if (rp->fc_mpoff == 0) {
1223 if (rp->fc_mpoff == 0) {
1224 rp->fc_mpoff = (uint8_t *)mp;
1225 rp->fc_mpon = (uint8_t *)mp;
1224 rp->fc_mpoff = (void *)mp;
1225 rp->fc_mpon = (void *)mp;
1226 } else {
1227 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1226 } else {
1227 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1228 (uint8_t *)mp;
1229 rp->fc_mpon = (uint8_t *)mp;
1228 (void *)mp;
1229 rp->fc_mpon = (void *)mp;
1230 }
1231
1232 if (hba->flag & FC_SLIM2_MODE) {
1233 /* return mapped address */
1234 *haddr = PADDR_HI(mp->phys);
1235 *laddr = PADDR_LO(mp->phys);
1236 } else {
1237 *laddr = PADDR_LO(mp->phys);

--- 4 unchanged lines hidden (view full) ---

1242
1243#ifdef SFCT_SUPPORT
1244 } else if (rp->ringno == hba->CHANNEL_FCT) {
1245 /*
1246 * Update slot fc_mpon points to then bump it
1247 * fc_mpoff is pointer head of the list.
1248 * fc_mpon is pointer tail of the list.
1249 */
1230 }
1231
1232 if (hba->flag & FC_SLIM2_MODE) {
1233 /* return mapped address */
1234 *haddr = PADDR_HI(mp->phys);
1235 *laddr = PADDR_LO(mp->phys);
1236 } else {
1237 *laddr = PADDR_LO(mp->phys);

--- 4 unchanged lines hidden (view full) ---

1242
1243#ifdef SFCT_SUPPORT
1244 } else if (rp->ringno == hba->CHANNEL_FCT) {
1245 /*
1246 * Update slot fc_mpon points to then bump it
1247 * fc_mpoff is pointer head of the list.
1248 * fc_mpon is pointer tail of the list.
1249 */
1250 mp->fc_mptr = 0;
1250 mp->fc_mptr = NULL;
1251 if (rp->fc_mpoff == 0) {
1251 if (rp->fc_mpoff == 0) {
1252 rp->fc_mpoff = (uint8_t *)mp;
1253 rp->fc_mpon = (uint8_t *)mp;
1252 rp->fc_mpoff = (void *)mp;
1253 rp->fc_mpon = (void *)mp;
1254 } else {
1255 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1254 } else {
1255 ((MATCHMAP *)(rp->fc_mpon))->fc_mptr =
1256 (uint8_t *)mp;
1257 rp->fc_mpon = (uint8_t *)mp;
1256 (void *)mp;
1257 rp->fc_mpon = (void *)mp;
1258 }
1259
1260 if (hba->flag & FC_SLIM2_MODE) {
1261 /* return mapped address */
1262 *haddr = PADDR_HI(mp->phys);
1263 /* return mapped address */
1264 *laddr = PADDR_LO(mp->phys);
1265 } else {

--- 31 unchanged lines hidden (view full) ---

1297 (void) emlxs_mem_alloc(hba, buf_info);
1298
1299 if (buf_info->virt == NULL) {
1300 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_msg,
1301 "Unable to alloc HBQ.");
1302 return (ENOMEM);
1303 }
1304
1258 }
1259
1260 if (hba->flag & FC_SLIM2_MODE) {
1261 /* return mapped address */
1262 *haddr = PADDR_HI(mp->phys);
1263 /* return mapped address */
1264 *laddr = PADDR_LO(mp->phys);
1265 } else {

--- 31 unchanged lines hidden (view full) ---

1297 (void) emlxs_mem_alloc(hba, buf_info);
1298
1299 if (buf_info->virt == NULL) {
1300 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_msg,
1301 "Unable to alloc HBQ.");
1302 return (ENOMEM);
1303 }
1304
1305 hbq->HBQ_host_buf.virt = (void *)buf_info->virt;
1305 hbq->HBQ_host_buf.virt = buf_info->virt;
1306 hbq->HBQ_host_buf.phys = buf_info->phys;
1307 hbq->HBQ_host_buf.data_handle = buf_info->data_handle;
1308 hbq->HBQ_host_buf.dma_handle = buf_info->dma_handle;
1309 hbq->HBQ_host_buf.size = buf_info->size;
1310 hbq->HBQ_host_buf.tag = hbq_id;
1311
1312 bzero((char *)hbq->HBQ_host_buf.virt, buf_info->size);
1313 }
1314
1315 return (0);
1316
1317} /* emlxs_hbq_alloc() */
1306 hbq->HBQ_host_buf.phys = buf_info->phys;
1307 hbq->HBQ_host_buf.data_handle = buf_info->data_handle;
1308 hbq->HBQ_host_buf.dma_handle = buf_info->dma_handle;
1309 hbq->HBQ_host_buf.size = buf_info->size;
1310 hbq->HBQ_host_buf.tag = hbq_id;
1311
1312 bzero((char *)hbq->HBQ_host_buf.virt, buf_info->size);
1313 }
1314
1315 return (0);
1316
1317} /* emlxs_hbq_alloc() */