/* Buffered USB debug output
 * (C) 2007 Henryk Plötz <henryk@ploetzli.ch>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <FreeRTOS.h>
#include <task.h> 
#include <semphr.h>
#include <USB-CDC.h>
#include <string.h>

#include "usb_print.h"

#define BUFLEN (2*1024)

static char ringbuffer[BUFLEN];
static int ringstart, ringstop;
static int default_flush = 1, forced_silence = 0;
static xSemaphoreHandle print_semaphore;

void usb_print_buffer(const char* buffer, int start, int stop) {
	usb_print_buffer_f(buffer,start,stop,default_flush);
}
int usb_print_buffer_f(const char* buffer, int start, int stop, int flush)
{
	int pos=start, endpos=stop;
	while(pos<stop) {
		int available = BUFLEN-1 - (((ringstop+BUFLEN)-ringstart) % BUFLEN);
		if(available == 0 && flush) { 
			usb_print_flush();
			continue;
		}
		if((endpos-pos)>available) endpos=pos+available;
		
		while(pos < endpos) {
			ringbuffer[ringstop] = buffer[pos];
			pos++;
			available--;
			ringstop = (ringstop+1) % BUFLEN;
		}
		
		if(flush) usb_print_flush();
		else if(available==0)
			return 0;
		endpos=stop;
		if(pos>=stop)
			return (available > 0);
	}
	return 0;
}

void usb_print_string(const char *string) {
	usb_print_string_f(string, default_flush);
}
int usb_print_string_f(const char* string, int flush)
{
	int start = 0, stop = strlen(string);
	return usb_print_buffer_f(string, start, stop, flush);
}

void usb_print_char(const char c) {
	usb_print_char_f(c, default_flush);
}
int usb_print_char_f(const char c, int flush)
{
	return usb_print_buffer_f(&c, 0, 1, flush);
}

int usb_print_get_default_flush(void)
{
	return default_flush;
}

int usb_print_set_default_flush(int flush)
{
	int old_flush = default_flush;
	default_flush = flush;
	return old_flush;
}

int usb_print_set_force_silence(int silence)
{
	int old_silence = forced_silence;
	forced_silence = silence;
	return old_silence;
}


/* Must NOT be called from ISR context */
void usb_print_flush(void)
{
	int oldstop, newstart;
	if(forced_silence) return;
	
	taskENTER_CRITICAL();
	if(print_semaphore == NULL)
		usb_print_init();
	if(print_semaphore == NULL) {
		taskEXIT_CRITICAL();
		return;
	}
	taskEXIT_CRITICAL();
	
	xSemaphoreTake(print_semaphore, portMAX_DELAY);
	
	taskENTER_CRITICAL();
	oldstop = ringstop;
	newstart = ringstart;
	taskEXIT_CRITICAL();
	 
	while(newstart != oldstop) {
		vUSBSendByte_blocking(ringbuffer[newstart], 5*portTICK_RATE_MS);
		newstart = (newstart+1) % BUFLEN;
	}
	
	taskENTER_CRITICAL();
	ringstart = newstart;
	taskEXIT_CRITICAL();
	
	xSemaphoreGive(print_semaphore);
}

void usb_print_init(void)
{
	memset(ringbuffer, 0, BUFLEN);
	ringstart = ringstop = 0;
	vSemaphoreCreateBinary( print_semaphore );
}
