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
|
// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2018 Rockchip Electronics Co. Ltd. */
#include <asm/cacheflush.h>
#include <linux/bootmem.h>
#include <linux/clk.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/slab.h>
#ifdef CONFIG_OF
#include <linux/of.h>
#endif
#include "nandc.h"
#include "rkflash_api.h"
#include "rkflash_blk.h"
#define RKNANDC_VERSION_AND_DATE "rknandc_base v1.1 2017-01-11"
#define RKNANDC_CLK_SET_RATE (150 * 1000 * 1000)
struct rknandc_info {
void __iomem *reg_base;
int irq;
int clk_rate;
struct clk *clk; /* controller's clk*/
struct clk *ahb_clk; /* ahb clk gate*/
struct clk *g_clk; /* clk_src_en gate*/
};
static struct rknandc_info g_nandc_info;
static struct device *g_nandc_dev;
static struct completion nandc_irq_complete;
unsigned long rknandc_dma_map_single(unsigned long ptr, int size, int dir)
{
#ifdef CONFIG_ARM64
__dma_map_area((void *)ptr, size, dir);
return ((unsigned long)virt_to_phys((void *)ptr));
#else
return dma_map_single(NULL, (void *)ptr, size
, dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
#endif
}
void rknandc_dma_unmap_single(unsigned long ptr, int size, int dir)
{
#ifdef CONFIG_ARM64
__dma_unmap_area(phys_to_virt(ptr), size, dir);
#else
dma_unmap_single(NULL, (dma_addr_t)ptr, size
, dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
#endif
}
static irqreturn_t rknandc_interrupt(int irq, void *dev_id)
{
nandc_clean_irq();
complete(&nandc_irq_complete);
return IRQ_HANDLED;
}
static int rknandc_irq_config(int mode, void *pfun)
{
int ret = 0;
int irq = g_nandc_info.irq;
if (mode)
ret = request_irq(irq, pfun, 0, "rknandc",
g_nandc_info.reg_base);
else
free_irq(irq, NULL);
return ret;
}
static int rknandc_irq_init(void)
{
init_completion(&nandc_irq_complete);
rknandc_irq_config(1, rknandc_interrupt);
return 0;
}
static int rknandc_irq_deinit(void)
{
rknandc_irq_config(0, rknandc_interrupt);
return 0;
}
static int rknandc_probe(struct platform_device *pdev)
{
int irq;
struct resource *mem;
void __iomem *membase;
int ret;
g_nandc_dev = &pdev->dev;
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
membase = devm_ioremap_resource(&pdev->dev, mem);
if (!membase) {
dev_err(&pdev->dev, "no reg resource?\n");
return -1;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "no irq resource?\n");
return irq;
}
g_nandc_info.irq = irq;
g_nandc_info.reg_base = membase;
g_nandc_info.ahb_clk = devm_clk_get(&pdev->dev, "hclk_nandc");
g_nandc_info.clk = devm_clk_get(&pdev->dev, "clk_nandc");
g_nandc_info.g_clk = devm_clk_get(&pdev->dev, "g_clk_nandc");
if (unlikely(IS_ERR(g_nandc_info.clk)) ||
unlikely(IS_ERR(g_nandc_info.ahb_clk))) {
dev_err(&pdev->dev, "%s get clk error\n", __func__);
return -1;
}
clk_prepare_enable(g_nandc_info.ahb_clk);
if (!(IS_ERR(g_nandc_info.g_clk)))
clk_prepare_enable(g_nandc_info.g_clk);
clk_set_rate(g_nandc_info.clk, RKNANDC_CLK_SET_RATE);
g_nandc_info.clk_rate = clk_get_rate(g_nandc_info.clk);
clk_prepare_enable(g_nandc_info.clk);
dev_info(&pdev->dev,
"%s clk rate = %d\n",
__func__,
g_nandc_info.clk_rate);
rknandc_irq_init();
ret = rkflash_dev_init(g_nandc_info.reg_base, FLASH_CON_TYPE_NANDC);
return ret;
}
static int rknandc_suspend(struct platform_device *pdev, pm_message_t state)
{
return rkflash_dev_suspend();
}
static int rknandc_resume(struct platform_device *pdev)
{
return rkflash_dev_resume(g_nandc_info.reg_base);
}
static void rknandc_shutdown(struct platform_device *pdev)
{
rkflash_dev_shutdown();
}
#ifdef CONFIG_OF
static const struct of_device_id of_rknandc_match[] = {
{.compatible = "rockchip,rk-nandc"},
{.compatible = "rockchip,nandc"},
{}
};
#endif
static struct platform_driver rknandc_driver = {
.probe = rknandc_probe,
.suspend = rknandc_suspend,
.resume = rknandc_resume,
.shutdown = rknandc_shutdown,
.driver = {
.name = "rknandc",
#ifdef CONFIG_OF
.of_match_table = of_rknandc_match,
#endif
},
};
static void __exit rknandc_driver_exit(void)
{
rkflash_dev_exit();
rknandc_irq_deinit();
platform_driver_unregister(&rknandc_driver);
}
static int __init rknandc_driver_init(void)
{
int ret = 0;
pr_err("%s\n", RKNANDC_VERSION_AND_DATE);
ret = platform_driver_register(&rknandc_driver);
return ret;
}
module_init(rknandc_driver_init);
module_exit(rknandc_driver_exit);
MODULE_ALIAS(DRIVER_NAME);
|
