1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/* Copyright 2018 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "cec.h"
#include "console.h"
#include "task.h"
#define CPRINTF(format, args...) cprintf(CC_CEC, format, ## args)
#define CPRINTS(format, args...) cprints(CC_CEC, format, ## args)
/*
* Mutex for the read-offset of the rx queue. Needed since the
* queue is read and flushed from different contexts
*/
static struct mutex rx_queue_readoffset_mutex;
int cec_transfer_get_bit(const struct cec_msg_transfer *transfer)
{
if (transfer->byte >= MAX_CEC_MSG_LEN)
return 0;
return transfer->buf[transfer->byte] & (0x80 >> transfer->bit);
}
void cec_transfer_set_bit(struct cec_msg_transfer *transfer, int val)
{
uint8_t bit_flag;
if (transfer->byte >= MAX_CEC_MSG_LEN)
return;
bit_flag = 0x80 >> transfer->bit;
transfer->buf[transfer->byte] &= ~bit_flag;
if (val)
transfer->buf[transfer->byte] |= bit_flag;
}
void cec_transfer_inc_bit(struct cec_msg_transfer *transfer)
{
if (++(transfer->bit) == 8) {
if (transfer->byte >= MAX_CEC_MSG_LEN)
return;
transfer->bit = 0;
transfer->byte++;
}
}
int cec_transfer_is_eom(const struct cec_msg_transfer *transfer, int len)
{
if (transfer->bit)
return 0;
return (transfer->byte == len);
}
void cec_rx_queue_flush(struct cec_rx_queue *queue)
{
mutex_lock(&rx_queue_readoffset_mutex);
queue->read_offset = 0;
mutex_unlock(&rx_queue_readoffset_mutex);
queue->write_offset = 0;
}
int cec_rx_queue_push(struct cec_rx_queue *queue, const uint8_t *msg,
uint8_t msg_len)
{
int i;
uint32_t offset;
if (msg_len > MAX_CEC_MSG_LEN || msg_len == 0)
return EC_ERROR_INVAL;
offset = queue->write_offset;
/* Fill in message length last, if successful. Set to zero for now */
queue->buf[offset] = 0;
offset = (offset + 1) % CEC_RX_BUFFER_SIZE;
for (i = 0 ; i < msg_len; i++) {
if (offset == queue->read_offset) {
/* Buffer full */
return EC_ERROR_OVERFLOW;
}
queue->buf[offset] = msg[i];
offset = (offset + 1) % CEC_RX_BUFFER_SIZE;
}
/*
* Don't commit if we caught up with read-offset
* since that would indicate an empty buffer
*/
if (offset == queue->read_offset) {
/* Buffer full */
return EC_ERROR_OVERFLOW;
}
/* Commit the push */
queue->buf[queue->write_offset] = msg_len;
queue->write_offset = offset;
return EC_SUCCESS;
}
int cec_rx_queue_pop(struct cec_rx_queue *queue, uint8_t *msg,
uint8_t *msg_len)
{
int i;
mutex_lock(&rx_queue_readoffset_mutex);
if (queue->read_offset == queue->write_offset) {
/* Queue empty */
mutex_unlock(&rx_queue_readoffset_mutex);
*msg_len = 0;
return -1;
}
/* The first byte in the buffer is the message length */
*msg_len = queue->buf[queue->read_offset];
if (*msg_len == 0 || *msg_len > MAX_CEC_MSG_LEN) {
mutex_unlock(&rx_queue_readoffset_mutex);
*msg_len = 0;
CPRINTF("Invalid CEC msg size: %u\n", *msg_len);
return -1;
}
queue->read_offset = (queue->read_offset + 1) % CEC_RX_BUFFER_SIZE;
for (i = 0; i < *msg_len; i++) {
msg[i] = queue->buf[queue->read_offset];
queue->read_offset = (queue->read_offset + 1) %
CEC_RX_BUFFER_SIZE;
}
mutex_unlock(&rx_queue_readoffset_mutex);
return 0;
}
|
