/****************************************************************************
*
*      Copyright (c) 2003,2004 by EMS Dr. Thomas Wuensche
*
*                  - All rights reserved -
*
* This code is provided "as is" without warranty of any kind, either
* expressed or implied, including but not limited to the liability
* concerning the freedom from material defects, the fitness for parti-
* cular purposes or the freedom of proprietary rights of third parties.
*
*****************************************************************************
* Module name.: cpcusb
*****************************************************************************
* Include file: cpc.h
*****************************************************************************
* Project.....: Windows Driver Development Kit
* Filename....: sja2m16c.cpp
* Authors.....: (GU) Gerhard Uttenthaler
*               (CS) Christian Schoett
*****************************************************************************
* Short descr.: converts baudrate between SJA1000 and M16C
*****************************************************************************
* Description.: handles the baudrate conversion from SJA1000 parameters to
*               M16C parameters
*****************************************************************************
* Address     : EMS Dr. Thomas Wuensche
*               Sonnenhang 3
*               D-85304 Ilmmuenster
*               Tel. : +49-8441-490260
*               Fax. : +49-8441-81860
*               email: support@ems-wuensche.com
*****************************************************************************
*                            History
*****************************************************************************
* Version  Date        Auth Remark
*
* 01.00    ??          GU   - initial release
* 01.10    ??????????  CS   - adapted to fit into the USB Windows driver
* 02.00    18.08.2004  GU   - improved the baudrate calculating algorithm
*                           - implemented acceptance filtering
* 02.10    10.09.2004  CS   - adapted to fit into the USB Windows driver
*****************************************************************************
*                            ToDo's
*****************************************************************************
*/

/****************************************************************************/
/*     I N C L U D E S
*/
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/smp_lock.h>
#include <linux/completion.h>
#include <asm/uaccess.h>
#include <linux/usb.h>

#include "cpc.h"
#include "cpc_int.h"
#include "cpcusb.h"

#include "sja2m16c.h"

/*********************************************************************/
int baudrate_m16c(int clk, int brp, int pr, int ph1, int ph2)
{
	return (16000000 / (1 << clk)) / 2 / (brp + 1) / (1 + pr + 1 +
							    ph1 + 1 + ph2 +
							    1);
}


/*********************************************************************/
int samplepoint_m16c(int brp, int pr, int ph1, int ph2)
{
	return (100 * (1 + pr + 1 + ph1 + 1)) / (1 + pr + 1 + ph1 + 1 +
						  ph2 + 1);
}


/****************************************************************************
* Function.....: SJA1000_TO_M16C_BASIC_Params
*
* Task.........: This routine converts SJA1000 CAN btr parameters into M16C
*                parameters based on the sample point and the error. In
*                addition it converts the acceptance filter parameters to
*                suit the M16C parameters
*
* Parameters...: None
*
* Return values: None
*
* Comments.....:
*****************************************************************************
*                History
*****************************************************************************
* 19.01.2005  CS   - modifed the conversion of SJA1000 filter params into
*                    M16C params. Due to compatibility reasons with the
*                    older 82C200 CAN controller the SJA1000
****************************************************************************/
int SJA1000_TO_M16C_BASIC_Params(CPC_MSG_T * in)
{
	int sjaBaudrate;
	int sjaSamplepoint;
	int *baudrate_error;	// BRP[0..15], PR[0..7], PH1[0..7], PH2[0..7]
	int *samplepoint_error;	// BRP[0..15], PR[0..7], PH1[0..7], PH2[0..7]
	int baudrate_error_merk;
	int clk, brp, pr, ph1, ph2;
	int clk_merk, brp_merk, pr_merk, ph1_merk, ph2_merk;
	int index;
	unsigned char acc_code0, acc_code1, acc_code2, acc_code3;
	unsigned char acc_mask0, acc_mask1, acc_mask2, acc_mask3;
	CPC_MSG_T * out;
	C0CONR_T c0con;
	C1CONR_T c1con;
	int tmpAccCode;
	int tmpAccMask;

	    // we have to convert the parameters into M16C parameters
	    CPC_SJA1000_PARAMS_T * pParams;

	    // check if the type is CAN parameters and if we have to convert the given params
	    if (in->type != CPC_CMD_T_CAN_PRMS
		|| in->msg.canparams.cc_type != SJA1000)
		return 0;
	pParams =
	    (CPC_SJA1000_PARAMS_T *) & in->msg.canparams.cc_params.sja1000;
	acc_code0 = pParams->acc_code0;
	acc_code1 = pParams->acc_code1;
	acc_code2 = pParams->acc_code2;
	acc_code3 = pParams->acc_code3;
	acc_mask0 = pParams->acc_mask0;
	acc_mask1 = pParams->acc_mask1;
	acc_mask2 = pParams->acc_mask2;
	acc_mask3 = pParams->acc_mask3;

#ifdef _DEBUG_OUTPUT_CAN_PARAMS
	    info("acc_code0: %2.2Xh\n", acc_code0);
	info("acc_code1: %2.2Xh\n", acc_code1);
	info("acc_code2: %2.2Xh\n", acc_code2);
	info("acc_code3: %2.2Xh\n", acc_code3);
	info("acc_mask0: %2.2Xh\n", acc_mask0);
	info("acc_mask1: %2.2Xh\n", acc_mask1);
	info("acc_mask2: %2.2Xh\n", acc_mask2);
	info("acc_mask3: %2.2Xh\n", acc_mask3);

#endif	/*  */
	    if (!
		 (baudrate_error =
		  (int *) vmalloc(sizeof(int) * 16 * 8 * 8 * 8 * 5))) {
		err("Could not allocate memory\n");
		return -3;
	}
	if (!
	      (samplepoint_error =
	       (int *) vmalloc(sizeof(int) * 16 * 8 * 8 * 8 * 5))) {
		err("Could not allocate memory\n");
		vfree(baudrate_error);
		return -3;
	}
	memset(baudrate_error, 0xff, sizeof(baudrate_error));
	memset(samplepoint_error, 0xff, sizeof(baudrate_error));
	sjaBaudrate =
	    16000000 / 2 / SJA_BRP / (1 + SJA_TSEG1 + SJA_TSEG2);
	sjaSamplepoint =
	    100 * (1 + SJA_TSEG1) / (1 + SJA_TSEG1 + SJA_TSEG2);
	if (sjaBaudrate == 0) {
		vfree(baudrate_error);
		vfree(samplepoint_error);
		return -2;
	}

#ifdef _DEBUG_OUTPUT_CAN_PARAMS
	    info("\nStarting SJA CAN params\n");
	info("-------------------------\n");
	info("TS1     : %2.2Xh TS2 : %2.2Xh\n", SJA_TSEG1, SJA_TSEG2);
	info("BTR0    : %2.2Xh BTR1: %2.2Xh\n", pParams->btr0,
	      pParams->btr1);
	info("Baudrate: %d.%dkBaud\n", sjaBaudrate / 1000,
	      sjaBaudrate % 1000);
	info("Sample P: 0.%d\n", sjaSamplepoint);
	info("\n");

#endif	/*  */
	    c0con.bc0con.sam = SJA_SAM;
	c1con.bc1con.sjw = SJA_SJW;

	    // calculate errors for all baudrates
	    index = 0;
	for (clk = 0; clk < 5; clk++) {
		for (brp = 0; brp < 16; brp++) {
			for (pr = 0; pr < 8; pr++) {
				for (ph1 = 0; ph1 < 8; ph1++) {
					for (ph2 = 0; ph2 < 8; ph2++) {
						baudrate_error[index] =
						    100 *
						    abs(baudrate_m16c
							(clk, brp, pr, ph1,
							 ph2) -
							sjaBaudrate) /
						    sjaBaudrate;
						samplepoint_error[index] =
						    abs(samplepoint_m16c
							(brp, pr, ph1,
							 ph2) -
							sjaSamplepoint);

#if 0
						    info
						    ("Baudrate      : %d kBaud\n",
						     baudrate_m16c(clk,
								   brp, pr,
								   ph1,
								   ph2));
						info
						    ("Baudrate Error: %d\n",
						     baudrate_error
						     [index]);
						info
						    ("Sample P Error: %d\n",
						     samplepoint_error
						     [index]);
						info
						    ("clk           : %d\n",
						     clk);

#endif	/*  */
						    index++;
					}
				}
			}
		}
	}

	    // mark all baudrate_error entries which are outer limits
	    index = 0;
	for (clk = 0; clk < 5; clk++) {
		for (brp = 0; brp < 16; brp++) {
			for (pr = 0; pr < 8; pr++) {
				for (ph1 = 0; ph1 < 8; ph1++) {
					for (ph2 = 0; ph2 < 8; ph2++) {
						if ((baudrate_error[index]
						      >
						      BAUDRATE_TOLERANCE_PERCENT)
						     ||
						     (samplepoint_error
						       [index] >
						       SAMPLEPOINT_TOLERANCE_PERCENT)
						     ||
						     (samplepoint_m16c
						       (brp, pr, ph1,
							ph2) >
						       SAMPLEPOINT_UPPER_LIMIT))
						{
							baudrate_error
							    [index] = -1;
						} else
						    if (((1 + pr + 1 +
							  ph1 + 1 + ph2 +
							  1) < 8)
							||
							((1 + pr + 1 +
							  ph1 + 1 + ph2 +
							  1) > 25)) {
							baudrate_error
							    [index] = -1;
						}

#if 0
						    else {
							info
							    ("Baudrate      : %d kBaud\n",
							     baudrate_m16c
							     (clk, brp, pr,
							      ph1, ph2));
							info
							    ("Baudrate Error: %d\n",
							     baudrate_error
							     [index]);
							info
							    ("Sample P Error: %d\n",
							     samplepoint_error
							     [index]);
						}

#endif	/*  */
						    index++;
					}
				}
			}
		}
	}

	    // find list of minimum of baudrate_error within unmarked entries
	    clk_merk = brp_merk = pr_merk = ph1_merk = ph2_merk = 0;
	baudrate_error_merk = 100;
	index = 0;
	for (clk = 0; clk < 5; clk++) {
		for (brp = 0; brp < 16; brp++) {
			for (pr = 0; pr < 8; pr++) {
				for (ph1 = 0; ph1 < 8; ph1++) {
					for (ph2 = 0; ph2 < 8; ph2++) {
						if (baudrate_error[index]
						     != -1) {
							if (baudrate_error
							     [index] <
							     baudrate_error_merk)
							{
								baudrate_error_merk
								    =
								    baudrate_error
								    [index];
								brp_merk =
								    brp;
								pr_merk =
								    pr;
								ph1_merk =
								    ph1;
								ph2_merk =
								    ph2;
								clk_merk =
								    clk;

#if 0
								    info
								    ("brp: %2.2Xh pr: %2.2Xh ph1: %2.2Xh ph2: %2.2Xh\n",
								     brp,
								     pr,
								     ph1,
								     ph2);
								info
								    ("Baudrate      : %d kBaud\n",
								     baudrate_m16c
								     (clk,
								      brp,
								      pr,
								      ph1,
								      ph2));
								info
								    ("Baudrate Error: %d\n",
								     baudrate_error
								     [index]);
								info
								    ("Sample P Error: %d\n",
								     samplepoint_error
								     [index]);

#endif	/*  */
							}
						}
						index++;
					}
				}
			}
		}
	}
	if (baudrate_error_merk == 100) {
		info("ERROR: Could not convert CAN init parameter\n");
		vfree(baudrate_error);
		vfree(samplepoint_error);
		return -1;
	}

	    // setting m16c CAN parameter
	    c0con.bc0con.brp = brp_merk;
	c0con.bc0con.pr = pr_merk;
	c1con.bc1con.ph1 = ph1_merk;
	c1con.bc1con.ph2 = ph2_merk;

#ifdef _DEBUG_OUTPUT_CAN_PARAMS
	    info("\nResulting M16C CAN params\n");
	info("-------------------------\n");
	info("clk     : %2.2Xh\n", clk_merk);
	info("ph1     : %2.2Xh ph2: %2.2Xh\n", c1con.bc1con.ph1 + 1,
	      c1con.bc1con.ph2 + 1);
	info("pr      : %2.2Xh brp: %2.2Xh\n", c0con.bc0con.pr + 1,
	      c0con.bc0con.brp + 1);
	info("sjw     : %2.2Xh sam: %2.2Xh\n", c1con.bc1con.sjw,
	      c0con.bc0con.sam);
	info("co1     : %2.2Xh co0: %2.2Xh\n", c1con.c1con, c0con.c0con);
	info("Baudrate: %d.%dBaud\n",
	       baudrate_m16c(clk_merk, c0con.bc0con.brp, c0con.bc0con.pr,
			     c1con.bc1con.ph1, c1con.bc1con.ph2) / 1000,
	       baudrate_m16c(clk_merk, c0con.bc0con.brp, c0con.bc0con.pr,
			      c1con.bc1con.ph1, c1con.bc1con.ph2) % 1000);
	info("Sample P: 0.%d\n",
	      samplepoint_m16c(c0con.bc0con.brp, c0con.bc0con.pr,
			       c1con.bc1con.ph1, c1con.bc1con.ph2));
	info("\n");

#endif	/*  */
	    out = in;
	out->type = 6;
	out->length = sizeof(CPC_M16C_BASIC_PARAMS_T) + 1;
	out->msg.canparams.cc_type = M16C_BASIC;
	out->msg.canparams.cc_params.m16c_basic.con0 = c0con.c0con;
	out->msg.canparams.cc_params.m16c_basic.con1 = c1con.c1con;
	out->msg.canparams.cc_params.m16c_basic.ctlr0 = 0x4C;
	out->msg.canparams.cc_params.m16c_basic.ctlr1 = 0x00;
	out->msg.canparams.cc_params.m16c_basic.clk = clk_merk;
	out->msg.canparams.cc_params.m16c_basic.acc_std_code0 =
	    acc_code0;
	out->msg.canparams.cc_params.m16c_basic.acc_std_code1 = acc_code1;

//      info("code0: 0x%2.2X, code1: 0x%2.2X\n", out->msg.canparams.cc_params.m16c_basic.acc_std_code0, out->msg.canparams.cc_params.m16c_basic.acc_std_code1);
	    tmpAccCode = (acc_code1 >> 5) + (acc_code0 << 3);
	out->msg.canparams.cc_params.m16c_basic.acc_std_code0 =
	    (unsigned char) tmpAccCode;
	out->msg.canparams.cc_params.m16c_basic.acc_std_code1 =
	    (unsigned char) (tmpAccCode >> 8);

//      info("code0: 0x%2.2X, code1: 0x%2.2X\n", out->msg.canparams.cc_params.m16c_basic.acc_std_code0, out->msg.canparams.cc_params.m16c_basic.acc_std_code1);
	    out->msg.canparams.cc_params.m16c_basic.acc_std_mask0 =
	    ~acc_mask0;
	out->msg.canparams.cc_params.m16c_basic.acc_std_mask1 =
	    ~acc_mask1;

//      info("mask0: 0x%2.2X, mask1: 0x%2.2X\n", out->msg.canparams.cc_params.m16c_basic.acc_std_mask0, out->msg.canparams.cc_params.m16c_basic.acc_std_mask1);
	    tmpAccMask = ((acc_mask1) >> 5) + ((acc_mask0) << 3);

//      info("tmpAccMask: 0x%4.4X\n", tmpAccMask);
	    out->msg.canparams.cc_params.m16c_basic.acc_std_mask0 =
	    (unsigned char) ~tmpAccMask;
	out->msg.canparams.cc_params.m16c_basic.acc_std_mask1 =
	    (unsigned char) ~(tmpAccMask >> 8);

//      info("mask0: 0x%2.2X, mask1: 0x%2.2X\n", out->msg.canparams.cc_params.m16c_basic.acc_std_mask0, out->msg.canparams.cc_params.m16c_basic.acc_std_mask1);
	    out->msg.canparams.cc_params.m16c_basic.acc_ext_code0 =
	    (unsigned char) tmpAccCode;
	out->msg.canparams.cc_params.m16c_basic.acc_ext_code1 =
	    (unsigned char) (tmpAccCode >> 8);
	out->msg.canparams.cc_params.m16c_basic.acc_ext_code2 = acc_code2;
	out->msg.canparams.cc_params.m16c_basic.acc_ext_code3 = acc_code3;
	out->msg.canparams.cc_params.m16c_basic.acc_ext_mask0 =
	    (unsigned char) ~tmpAccMask;
	out->msg.canparams.cc_params.m16c_basic.acc_ext_mask1 =
	    (unsigned char) ~(tmpAccMask >> 8);
	out->msg.canparams.cc_params.m16c_basic.acc_ext_mask2 =
	    ~acc_mask2;
	out->msg.canparams.cc_params.m16c_basic.acc_ext_mask3 =
	    ~acc_mask3;
	vfree(baudrate_error);
	vfree(samplepoint_error);
	return 0;
}