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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
|
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017-11-02 勤为本 first version
* 2018-06-09 zhuangwei add spi0 cs0 support,remove msd_init
*/
#include <rtthread.h>
#include <drivers/spi.h>
#include <rthw.h>
#include "drv_spi.h"
#include "ls1c_public.h"
#include "spi_msd.h"
#include "dfs_fs.h"
#include "../libraries/ls1c_pin.h"
#ifdef RT_USING_SPI
#ifdef DEBUG
#define DEBUG_PRINTF(...) rt_kprintf(__VA_ARGS__)
#else
#define DEBUG_PRINTF(...)
#endif
static rt_err_t configure(struct rt_spi_device *device, struct rt_spi_configuration *configuration);
static rt_uint32_t xfer(struct rt_spi_device *device, struct rt_spi_message *message);
static struct rt_spi_ops ls1c_spi_ops =
{
.configure = configure,
.xfer = xfer
};
static rt_err_t configure(struct rt_spi_device *device,
struct rt_spi_configuration *configuration)
{
struct rt_spi_bus *spi_bus = NULL;
struct ls1c_spi *ls1c_spi = NULL;
unsigned char SPIx = 0;
void *spi_base = NULL;
unsigned char cpol = 0;
unsigned char cpha = 0;
unsigned char val = 0;
RT_ASSERT(NULL != device);
RT_ASSERT(NULL != configuration);
spi_bus = device->bus;
ls1c_spi = (struct ls1c_spi *)spi_bus->parent.user_data;
SPIx = ls1c_spi->SPIx;
spi_base = ls1c_spi_get_base(SPIx);
{
// 使能SPI控制器，master模式，关闭中断
reg_write_8(0x53, spi_base + LS1C_SPI_SPCR_OFFSET);
// 清空状态寄存器
reg_write_8(0xc0, spi_base + LS1C_SPI_SPSR_OFFSET);
// 1字节产生中断，采样(读)与发送(写)时机同时
reg_write_8(0x03, spi_base + LS1C_SPI_SPER_OFFSET);
// 关闭SPI flash
val = reg_read_8(spi_base + LS1C_SPI_SFC_PARAM_OFFSET);
val &= 0xfe;
reg_write_8(val, spi_base + LS1C_SPI_SFC_PARAM_OFFSET);
// spi flash时序控制寄存器
reg_write_8(0x05, spi_base + LS1C_SPI_SFC_TIMING_OFFSET);
}
// baudrate
ls1c_spi_set_clock(spi_base, configuration->max_hz);
// 设置通信模式(时钟极性和相位)
if (configuration->mode & RT_SPI_CPOL) // cpol
{
cpol = SPI_CPOL_1;
}
else
{
cpol = SPI_CPOL_0;
}
if (configuration->mode & RT_SPI_CPHA) // cpha
{
cpha = SPI_CPHA_1;
}
else
{
cpha = SPI_CPHA_0;
}
ls1c_spi_set_mode(spi_base, cpol, cpha);
DEBUG_PRINTF("ls1c spi%d configuration\n", SPIx);
return RT_EOK;
}
static rt_uint32_t xfer(struct rt_spi_device *device,
struct rt_spi_message *message)
{
struct rt_spi_bus *spi_bus = NULL;
struct ls1c_spi *ls1c_spi = NULL;
void *spi_base = NULL;
unsigned char SPIx = 0;
struct ls1c_spi_cs *ls1c_spi_cs = NULL;
unsigned char cs = 0;
rt_uint32_t size = 0;
const rt_uint8_t *send_ptr = NULL;
rt_uint8_t *recv_ptr = NULL;
rt_uint8_t data = 0;
RT_ASSERT(NULL != device);
RT_ASSERT(NULL != message);
spi_bus = device->bus;
ls1c_spi = spi_bus->parent.user_data;
SPIx = ls1c_spi->SPIx;
spi_base = ls1c_spi_get_base(SPIx);
ls1c_spi_cs = device->parent.user_data;
cs = ls1c_spi_cs->cs;
size = message->length;
DEBUG_PRINTF("[%s] SPIx=%d, cs=%d\n", __FUNCTION__, SPIx, cs);
// take cs
if (message->cs_take)
{
ls1c_spi_set_cs(spi_base, cs, 0);
}
// 收发数据
send_ptr = message->send_buf;
recv_ptr = message->recv_buf;
while (size--)
{
data = 0xFF;
if (NULL != send_ptr)
{
data = *send_ptr++;
}
if (NULL != recv_ptr)
{
*recv_ptr++ = ls1c_spi_txrx_byte(spi_base, data);
}
else
{
ls1c_spi_txrx_byte(spi_base, data);
}
}
// release cs
if (message->cs_release)
{
ls1c_spi_set_cs(spi_base, cs, 1);
}
return message->length;
}
#ifdef RT_USING_SPI0
struct ls1c_spi ls1c_spi0 =
{
.SPIx = LS1C_SPI_0,
};
static struct rt_spi_bus spi0_bus;
#endif
#ifdef RT_USING_SPI1
struct ls1c_spi ls1c_spi1 =
{
.SPIx = LS1C_SPI_1,
};
static struct rt_spi_bus spi1_bus;
#endif
/*
* 初始化并注册龙芯1c的spi总线
* @SPI SPI总线，比如LS1C_SPI_0， LS1C_SPI_1
* @spi_bus_name 总线名字
* @ret
*/
rt_err_t ls1c_spi_bus_register(rt_uint8_t SPI, const char *spi_bus_name)
{
struct rt_spi_bus *spi_bus = NULL;
#ifdef RT_USING_SPI0
if (LS1C_SPI_0 == SPI)
{
spi_bus = &spi0_bus;
spi_bus->parent.user_data = &ls1c_spi0;
}
#endif
#ifdef RT_USING_SPI1
if (LS1C_SPI_1 == SPI)
{
spi_bus = &spi1_bus;
spi_bus->parent.user_data = &ls1c_spi1;
}
#endif
return rt_spi_bus_register(spi_bus, spi_bus_name, &ls1c_spi_ops);
}
int ls1c_hw_spi_init(void)
{
#ifdef RT_USING_SPI0
pin_set_purpose(78, PIN_PURPOSE_OTHER);
pin_set_purpose(79, PIN_PURPOSE_OTHER);
pin_set_purpose(80, PIN_PURPOSE_OTHER);
pin_set_purpose(83, PIN_PURPOSE_OTHER);//cs2 - SD card
pin_set_purpose(82, PIN_PURPOSE_OTHER);//cs1
pin_set_purpose(81, PIN_PURPOSE_OTHER);//cs0
pin_set_remap(78, PIN_REMAP_DEFAULT);
pin_set_remap(79, PIN_REMAP_DEFAULT);
pin_set_remap(80, PIN_REMAP_DEFAULT);
pin_set_remap(83, PIN_REMAP_DEFAULT);//cs2 - SD card
pin_set_remap(82, PIN_REMAP_DEFAULT);//CS1
pin_set_remap(81, PIN_REMAP_DEFAULT);//cs0
ls1c_spi_bus_register(LS1C_SPI_0, "spi0");
#endif
#ifdef RT_USING_SPI1
pin_set_purpose(46, PIN_PURPOSE_OTHER);
pin_set_purpose(47, PIN_PURPOSE_OTHER);
pin_set_purpose(48, PIN_PURPOSE_OTHER);
pin_set_purpose(49, PIN_PURPOSE_OTHER);//CS0 - touch screen
pin_set_remap(46, PIN_REMAP_THIRD);
pin_set_remap(47, PIN_REMAP_THIRD);
pin_set_remap(48, PIN_REMAP_THIRD);
pin_set_remap(49, PIN_REMAP_THIRD);//CS0 - touch screen
ls1c_spi_bus_register(LS1C_SPI_1, "spi1");
#endif
#ifdef RT_USING_SPI0
/* attach cs */
{
static struct rt_spi_device spi_device0;
static struct rt_spi_device spi_device1;
static struct rt_spi_device spi_device2;
static struct rt_spi_device spi_device3;
static struct ls1c_spi_cs spi_cs0;
static struct ls1c_spi_cs spi_cs1;
static struct ls1c_spi_cs spi_cs2;
static struct ls1c_spi_cs spi_cs3;
/* spi02: CS2 SD Card*/
spi_cs2.cs = LS1C_SPI_CS_2;
rt_spi_bus_attach_device(&spi_device2, "spi02", "spi0", (void *)&spi_cs2);
spi_cs1.cs = LS1C_SPI_CS_1;
rt_spi_bus_attach_device(&spi_device1, "spi01", "spi0", (void *)&spi_cs1);
spi_cs0.cs = LS1C_SPI_CS_0;
rt_spi_bus_attach_device(&spi_device0, "spi00", "spi0", (void *)&spi_cs0);
spi_cs3.cs = LS1C_SPI_CS_3;
rt_spi_bus_attach_device(&spi_device3, "spi03", "spi0", (void*)&spi_cs3);
msd_init("sd0", "spi02");
}
#endif
#ifdef RT_USING_SPI1
{
static struct rt_spi_device spi_device;
static struct ls1c_spi_cs spi_cs;
/* spi10: CS0 Touch*/
spi_cs.cs = LS1C_SPI_CS_0;
rt_spi_bus_attach_device(&spi_device, "spi10", "spi1", (void *)&spi_cs);
}
#endif
}
INIT_BOARD_EXPORT(ls1c_hw_spi_init);
static int board_sd_init(void)
{
#if defined(RT_USING_DFS) && defined(RT_USING_DFS_ELMFAT)
/* mount sd card fat partition 1 as root directory */
if( dfs_mount("sd0", "/", "elm", 0, 0) == 0)
{
rt_kprintf("File System initialized!\n");
}
else
{
rt_kprintf("File System initialzation failed!\n");
}
#endif /* RT_USING_DFS && RT_USING_DFS_ELMFAT */
}
INIT_APP_EXPORT(board_sd_init);
#endif
|
