V2ProtocolParams.c 6.53 KB
Newer Older
1
2
/*
             LUFA Library
Dean Camera's avatar
Dean Camera committed
3
     Copyright (C) Dean Camera, 2010.
4
5
6
7
8
9
              
  dean [at] fourwalledcubicle [dot] com
      www.fourwalledcubicle.com
*/

/*
Dean Camera's avatar
Dean Camera committed
10
  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11

12
13
14
15
16
17
18
  Permission to use, copy, modify, distribute, and sell this 
  software and its documentation for any purpose is hereby granted
  without fee, provided that the above copyright notice appear in 
  all copies and that both that the copyright notice and this
  permission notice and warranty disclaimer appear in supporting 
  documentation, and that the name of the author not be used in 
  advertising or publicity pertaining to distribution of the 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
  software without specific, written prior permission.

  The author disclaim all warranties with regard to this
  software, including all implied warranties of merchantability
  and fitness.  In no event shall the author be liable for any
  special, indirect or consequential damages or any damages
  whatsoever resulting from loss of use, data or profits, whether
  in an action of contract, negligence or other tortious action,
  arising out of or in connection with the use or performance of
  this software.
*/

/** \file
 *
 *  V2Protocol parameter handler, to process V2 Protocol device parameters.
 */

#define  INCLUDE_FROM_V2PROTOCOL_PARAMS_C
#include "V2ProtocolParams.h"

/* Non-Volatile Parameter Values for EEPROM storage */
40
uint8_t EEMEM EEPROM_Rest_Polarity = 0x00;
41
42
43
44
45

/* Volatile Parameter Values for RAM storage */
static ParameterItem_t ParameterTable[] = 
	{
		{ .ParamID          = PARAM_BUILD_NUMBER_LOW,
46
47
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = (LUFA_VERSION_INTEGER >> 8)        },
48
49

		{ .ParamID          = PARAM_BUILD_NUMBER_HIGH,
50
51
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = (LUFA_VERSION_INTEGER & 0xFF),     },
52
53

		{ .ParamID          = PARAM_HW_VER,
54
55
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = 0x00                               },
56
57

		{ .ParamID          = PARAM_SW_MAJOR,
58
59
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = 0x01                               },
60
61

		{ .ParamID          = PARAM_SW_MINOR,
62
63
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = 0x0D                               },
64
65

		{ .ParamID          = PARAM_VTARGET,
66
67
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = 0x32                               },
68
69

		{ .ParamID          = PARAM_SCK_DURATION,
70
71
		  .ParamPrivileges  = PARAM_PRIV_READ | PARAM_PRIV_WRITE,
		  .ParamValue       = (TOTAL_ISP_PROGRAMMING_SPEEDS - 1) },
72
73

		{ .ParamID          = PARAM_RESET_POLARITY,
74
75
		  .ParamPrivileges  = PARAM_PRIV_WRITE,
		  .ParamValue       = 0x00                               },
76
77

		{ .ParamID          = PARAM_STATUS_TGT_CONN,
78
79
		  .ParamPrivileges  = PARAM_PRIV_READ,
		  .ParamValue       = 0x00                               },
80
81

		{ .ParamID          = PARAM_DISCHARGEDELAY,
82
83
		  .ParamPrivileges  = PARAM_PRIV_WRITE,
		  .ParamValue       = 0x00                               },
84
85
86
	};


87
/** Loads saved non-volatile parameter values from the EEPROM into the parameter table, as needed. */
88
void V2Params_LoadNonVolatileParamValues(void)
89
{
90
	/* Target RESET line polarity is a non-volatile value, retrieve current parameter value from EEPROM -
91
	 *   NB: Cannot call V2Protocol_SetParameterValue() here, as that will cause another EEPROM write! */
92
93
94
	V2Params_GetParamFromTable(PARAM_RESET_POLARITY)->ParamValue = eeprom_read_byte(&EEPROM_Rest_Polarity);
}

95
96
97
98
99
100
101
102
103
104
105
/** Updates any parameter values that are sourced from hardware rather than explicitly set by the host, such as
 *  VTARGET levels from the ADC on supported AVR models.
 */
void V2Params_UpdateParamValues(void)
{
	#if defined(ADC)
	/* Update VTARGET parameter with the latest ADC conversion of VTARGET on supported AVR models */
	V2Params_GetParamFromTable(PARAM_VTARGET)->ParamValue = ((5 * 10 * ADC_GetResult()) / 1024);
	#endif
}

106
/** Retrieves the host PC read/write privileges for a given parameter in the parameter table. This should
107
108
109
 *  be called before calls to \ref V2Params_GetParameterValue() or \ref V2Params_SetParameterValue() when
 *  getting or setting parameter values in response to requests from the host.
 *
110
 *  \param[in] ParamID  Parameter ID whose privileges are to be retrieved from the table
111
 *
112
 *  \return Privileges for the requested parameter, as a mask of PARAM_PRIV_* masks
113
 */ 
114
uint8_t V2Params_GetParameterPrivileges(const uint8_t ParamID)
115
116
117
118
119
120
{
	ParameterItem_t* ParamInfo = V2Params_GetParamFromTable(ParamID);
	
	if (ParamInfo == NULL)
	  return 0;

121
	return ParamInfo->ParamPrivileges;
122
123
}

124
125
/** Retrieves the current value for a given parameter in the parameter table.
 *
126
 *  \param[in] ParamID  Parameter ID whose value is to be retrieved from the table
127
128
129
 *
 *  \return Current value of the parameter in the table, or 0 if not found
 */ 
130
uint8_t V2Params_GetParameterValue(const uint8_t ParamID)
131
132
133
{
	ParameterItem_t* ParamInfo = V2Params_GetParamFromTable(ParamID);
	
134
	if (ParamInfo == NULL)
135
136
137
138
139
	  return 0;
	
	return ParamInfo->ParamValue;
}

140
141
/** Sets the value for a given parameter in the parameter table.
 *
142
 *  \param[in] ParamID  Parameter ID whose value is to be set in the table
143
 *  \param[in] Value    New value to set the parameter to
144
145
146
 *
 *  \return Pointer to the associated parameter information from the parameter table if found, NULL otherwise
 */
147
void V2Params_SetParameterValue(const uint8_t ParamID, const uint8_t Value)
148
149
150
{
	ParameterItem_t* ParamInfo = V2Params_GetParamFromTable(ParamID);

151
	if (ParamInfo == NULL)
152
153
154
155
156
157
	  return;

	ParamInfo->ParamValue = Value;

	/* The target RESET line polarity is a non-volatile parameter, save to EEPROM when changed */
	if (ParamID == PARAM_RESET_POLARITY)
158
	  eeprom_write_byte(&EEPROM_Rest_Polarity, Value);  
159
}
160

161
/** Retrieves a parameter entry (including ID, value and privileges) from the parameter table that matches the given
162
163
 *  parameter ID.
 *
164
 *  \param[in] ParamID  Parameter ID to find in the table
165
166
167
 *
 *  \return Pointer to the associated parameter information from the parameter table if found, NULL otherwise
 */
168
static ParameterItem_t* V2Params_GetParamFromTable(const uint8_t ParamID)
169
{
170
171
	ParameterItem_t* CurrTableItem = ParameterTable;

172
	/* Find the parameter in the parameter table if present */
173
	for (uint8_t TableIndex = 0; TableIndex < TABLE_PARAM_COUNT; TableIndex++)
174
	{
175
176
177
178
		if (ParamID == CurrTableItem->ParamID)
		  return CurrTableItem;
		
		CurrTableItem++;
179
	}
180

181
182
	return NULL;
}