;*****************************************************
;*
;*	MEM Entry Points
;*
;*****************************************************

	; Format of Memory Control Block used
	; in CP/M-86 Memory Calls (53 - 58)
	;
	;     +-----------+-----------+-----+
	; MCB |   Base    |   Length  | ext |
	;     +-----------+-----------+-----+
	;

mcb_base	equ	word ptr 0
mcb_length	equ	word ptr mcb_base + word
mcb_ext		equ	byte ptr mcb_length + word
mcblen		equ	mcb_ext + byte


;============		=====================
maxmem_entry:		; 53 - Get Max Memory
;============		=====================
;	input:	DX = address of MCB in u_wrkseg
;	output:	BX = 0ffffh if failure
;			 0h if success
;		CX = Error Code
;		mcb_ext = 0 if no additional mem
;			  1 if more available

	mov si,dx
	push ds ! mov ds,u_wrkseg
	mov dx,mcb_length[si] ! pop ds
	sub ax,ax ! mov bx,ax
	call getmemory ! jcxz mm_gm
	    mov bx,0ffffh ! ret
mm_gm:	push ds ! mov ds,u_wrkseg
	mov mcb_length[si],dx
	mov mcb_base[si],ax
	mov mcb_ext[si],1
	pop ds ! sub bx,bx ! ret

;============
absmax_entry:		; 54 - Get Abs Max Mem
;============
; Allocate the largest absolute memory region which
; is less than or equal mcb_length
;	input:	DX = address of MCB in u_wrkseg
;	output:	BX = 0ffffh if failure
;			 0h if success
;		CX = Error Code

	mov si,dx
	push ds ! mov ds,u_wrkseg
	mov ax,mcb_base[si]
	mov dx,mcb_length[si] ! pop ds
	sub bx,bx
	call getmemory ! jcxz am_gm
	    mov bx,0ffffh ! ret
am_gm:	push ds ! mov ds,u_wrkseg
	mov mcb_length[si],dx
	mov mcb_base[si],ax
	pop ds ! sub bx,bx ! ret

;==============
cpmalloc_entry:		; 55 - Alloc Mem
;==============
; Allocate a memory region which is equal to mcb_length
;
;	input:	DX = address of MCB in u_wrkseg
;	output:	BX = 0ffffh if failure
;			 0h if success
;		CX = Error Code

	mov si,dx
	push ds ! mov ds,u_wrkseg
	sub ax,ax ! mov bx,mcb_length[si]
	mov dx,bx ! pop ds
	call getmemory ! jcxz ca_gm
	    mov bx,0ffffh ! ret
ca_gm:	push ds ! mov ds,u_wrkseg
	mov mcb_length[si],dx
	mov mcb_base[si],ax
	pop ds ! sub bx,bx ! ret


;=============
cpmabsa_entry:		; 56 - Alloc Abs Mem
;=============
; Allocate an absolut memory region which is
; equal to mcb_length
;
;	input:	DX = address of MCB in u_wrkseg
;	output:	BX = 0ffffh if failure
;			 0h if success
;		CX = Error Code

	mov si,dx
	push ds ! mov ds,u_wrkseg
	mov ax,mcb_base[si]
	mov bx,mcb_length[si]
	mov dx,bx ! pop ds
	call getmemory ! jcxz caa_gm
	    mov bx,0ffffh ! ret
caa_gm:	push ds ! mov ds,u_wrkseg
	mov mcb_length[si],dx
	mov mcb_base[si],ax
	pop ds ! sub bx,bx ! ret

getmemory:
;---------
;	input:	AX = start
;		BX = min
;		DX = max
;	output:	AX = start
;		DX = length
;		CX = error code
;	  preserve SI

	push si
	sub cx,cx ! push cx ! push cx ! push dx ! push bx
	push ax ! mov dx,sp
	push ds ! mov cx,ss ! mov ds,cx
	mov cx,f_malloc ! call mpmif
	pop ds ! pop ax ! pop dx ! pop bx ! pop bx ! pop bx
	pop si ! ret

;=============
cpmfree_entry:		; 57 - Free Mem
;=============
; Free memory as specified in MCB
;	input:	DX = offset of MCB in u_wrkseg
;		mcb_ext = 0ffh = free all but load mem
;			else as specified by mcb_base.
;		mcb_base = seg addr of memory segment
;			to free.  IF in middle of
;			existing segment then just free
;			the end of the segment.

	push ds ! mov ds,u_wrkseg
	mov si,dx
	mov al,mcb_ext[si]
	mov dx,mcb_base[si] ! pop ds
	cmp al,0ffh ! jne free_memory
cpmf_root:  mov bx,rlr
	    add bx,p_mem-ms_link
cpmf_next:  mov si,ms_link[bx]
	    cmp si,0 ! jne try_seg
		sub bx,bx ! mov cx,bx ! ret
try_seg:    and ms_flags[si],mf_load ! jz free_seg
		mov bx,si ! jmps cpmf_next
free_seg:   mov dx,ms_start[si]
	    push si ! call free_memory ! pop si
	    jcxz cpmf_root
		jmps cpmf_next

free_memory:
;-----------
;	input:	DX = start
;	output:	BX = 0,0ffffh (success,fail)
;		CX = Error Code

	push ds ! push ss ! pop ds
	sub cx,cx ! push cx ! push dx
	mov dx,sp
	mov cx,f_memfree ! call mpmif
	pop dx ! pop dx ! pop ds
	ret

;=============
freeall_entry:		; 58 - Free All Mem
;=============
	mov cx,f_terminate ! sub dx,dx
	jmp mpmif