aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--fs/btrfs/file.c3
-rw-r--r--fs/btrfs/inode.c4
2 files changed, 6 insertions, 1 deletions
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 85841c53880..4119f9a9532 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -244,16 +244,17 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
244 244
245 split->start = start + len; 245 split->start = start + len;
246 split->len = em->start + em->len - (start + len); 246 split->len = em->start + em->len - (start + len);
247 split->orig_start = em->orig_start;
248 split->bdev = em->bdev; 247 split->bdev = em->bdev;
249 split->flags = flags; 248 split->flags = flags;
250 249
251 if (compressed) { 250 if (compressed) {
252 split->block_len = em->block_len; 251 split->block_len = em->block_len;
253 split->block_start = em->block_start; 252 split->block_start = em->block_start;
253 split->orig_start = em->orig_start;
254 } else { 254 } else {
255 split->block_len = split->len; 255 split->block_len = split->len;
256 split->block_start = em->block_start + diff; 256 split->block_start = em->block_start + diff;
257 split->orig_start = split->start;
257 } 258 }
258 259
259 ret = add_extent_mapping(em_tree, split); 260 ret = add_extent_mapping(em_tree, split);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 59660293d29..5ca9c067237 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -610,6 +610,7 @@ static noinline int submit_compressed_extents(struct inode *inode,
610 em = alloc_extent_map(GFP_NOFS); 610 em = alloc_extent_map(GFP_NOFS);
611 em->start = async_extent->start; 611 em->start = async_extent->start;
612 em->len = async_extent->ram_size; 612 em->len = async_extent->ram_size;
613 em->orig_start = em->start;
613 614
614 em->block_start = ins.objectid; 615 em->block_start = ins.objectid;
615 em->block_len = ins.offset; 616 em->block_len = ins.offset;
@@ -743,6 +744,7 @@ static noinline int cow_file_range(struct inode *inode,
743 } 744 }
744 em = alloc_extent_map(GFP_NOFS); 745 em = alloc_extent_map(GFP_NOFS);
745 em->start = start; 746 em->start = start;
747 em->orig_start = em->start;
746 748
747 ram_size = ins.offset; 749 ram_size = ins.offset;
748 em->len = ins.offset; 750 em->len = ins.offset;
@@ -1057,6 +1059,7 @@ out_check:
1057 em_tree = &BTRFS_I(inode)->extent_tree; 1059 em_tree = &BTRFS_I(inode)->extent_tree;
1058 em = alloc_extent_map(GFP_NOFS); 1060 em = alloc_extent_map(GFP_NOFS);
1059 em->start = cur_offset; 1061 em->start = cur_offset;
1062 em->orig_start = em->start;
1060 em->len = num_bytes; 1063 em->len = num_bytes;
1061 em->block_len = num_bytes; 1064 em->block_len = num_bytes;
1062 em->block_start = disk_bytenr; 1065 em->block_start = disk_bytenr;
@@ -3876,6 +3879,7 @@ again:
3876 } 3879 }
3877 em->bdev = root->fs_info->fs_devices->latest_bdev; 3880 em->bdev = root->fs_info->fs_devices->latest_bdev;
3878 em->start = EXTENT_MAP_HOLE; 3881 em->start = EXTENT_MAP_HOLE;
3882 em->orig_start = EXTENT_MAP_HOLE;
3879 em->len = (u64)-1; 3883 em->len = (u64)-1;
3880 em->block_len = (u64)-1; 3884 em->block_len = (u64)-1;
3881 3885
class='sha1'>a0a22cf14472
99bf2e68988f
a0a22cf14472


99bf2e68988f

65b2849a0220
a0a22cf14472
99bf2e68988f
a0a22cf14472


99bf2e68988f
a0a22cf14472
65b2849a0220
a0a22cf14472
99bf2e68988f
a0a22cf14472
99bf2e68988f

a0a22cf14472


99bf2e68988f

65b2849a0220
a0a22cf14472




65b2849a0220




a0a22cf14472
a0a22cf14472



6a1d55ccd8bc


a0a22cf14472
a0a22cf14472
a0a22cf14472




6a1d55ccd8bc
a0a22cf14472
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


                                           
                                                                   














                                                                  

                      
 
                     






                                                    


                                    
















                                                               
                                                             













                                                              
                                                      



                                                                             


                                                                    





                                                           
                                                             



                                                 
                                                         

                                   


                                                                 


                                           
                                                                             


                                                                      
                                




                                                                     
                                   


                                                        
 






























                                                                           
                                                                       


                        

                                                                 
                               
         
 





                                                                              


                                                        
                                                               
                                         
                                    
         
                           


                                  

                                                                         
                                    
         
                               


                                  

                                                                         
                                    
         
                               


                                                            
                                                               
                                             
                                    
         
                               
 

                                            


                                                            

                                                                        
                           




                                                                     




                                                                         
 



                                                      


                                      
                                         
          




                                                         
                                               
                      
/*
 * CPU Frequency Scaling for Loongson 1 SoC
 *
 * Copyright (C) 2014-2016 Zhang, Keguang <keguang.zhang@gmail.com>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/cpu.h>
#include <linux/cpufreq.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

#include <cpufreq.h>
#include <loongson1.h>

struct ls1x_cpufreq {
	struct device *dev;
	struct clk *clk;	/* CPU clk */
	struct clk *mux_clk;	/* MUX of CPU clk */
	struct clk *pll_clk;	/* PLL clk */
	struct clk *osc_clk;	/* OSC clk */
	unsigned int max_freq;
	unsigned int min_freq;
};

static struct ls1x_cpufreq *cpufreq;

static int ls1x_cpufreq_notifier(struct notifier_block *nb,
				 unsigned long val, void *data)
{
	if (val == CPUFREQ_POSTCHANGE)
		current_cpu_data.udelay_val = loops_per_jiffy;

	return NOTIFY_OK;
}

static struct notifier_block ls1x_cpufreq_notifier_block = {
	.notifier_call = ls1x_cpufreq_notifier
};

static int ls1x_cpufreq_target(struct cpufreq_policy *policy,
			       unsigned int index)
{
	struct device *cpu_dev = get_cpu_device(policy->cpu);
	unsigned int old_freq, new_freq;

	old_freq = policy->cur;
	new_freq = policy->freq_table[index].frequency;

	/*
	 * The procedure of reconfiguring CPU clk is as below.
	 *
	 *  - Reparent CPU clk to OSC clk
	 *  - Reset CPU clock (very important)
	 *  - Reconfigure CPU DIV
	 *  - Reparent CPU clk back to CPU DIV clk
	 */

	clk_set_parent(policy->clk, cpufreq->osc_clk);
	__raw_writel(__raw_readl(LS1X_CLK_PLL_DIV) | RST_CPU_EN | RST_CPU,
		     LS1X_CLK_PLL_DIV);
	__raw_writel(__raw_readl(LS1X_CLK_PLL_DIV) & ~(RST_CPU_EN | RST_CPU),
		     LS1X_CLK_PLL_DIV);
	clk_set_rate(cpufreq->mux_clk, new_freq * 1000);
	clk_set_parent(policy->clk, cpufreq->mux_clk);
	dev_dbg(cpu_dev, "%u KHz --> %u KHz\n", old_freq, new_freq);

	return 0;
}

static int ls1x_cpufreq_init(struct cpufreq_policy *policy)
{
	struct device *cpu_dev = get_cpu_device(policy->cpu);
	struct cpufreq_frequency_table *freq_tbl;
	unsigned int pll_freq, freq;
	int steps, i, ret;

	pll_freq = clk_get_rate(cpufreq->pll_clk) / 1000;

	steps = 1 << DIV_CPU_WIDTH;
	freq_tbl = kcalloc(steps, sizeof(*freq_tbl), GFP_KERNEL);
	if (!freq_tbl)
		return -ENOMEM;

	for (i = 0; i < (steps - 1); i++) {
		freq = pll_freq / (i + 1);
		if ((freq < cpufreq->min_freq) || (freq > cpufreq->max_freq))
			freq_tbl[i].frequency = CPUFREQ_ENTRY_INVALID;
		else
			freq_tbl[i].frequency = freq;
		dev_dbg(cpu_dev,
			"cpufreq table: index %d: frequency %d\n", i,
			freq_tbl[i].frequency);
	}
	freq_tbl[i].frequency = CPUFREQ_TABLE_END;

	policy->clk = cpufreq->clk;
	ret = cpufreq_generic_init(policy, freq_tbl, 0);
	if (ret)
		kfree(freq_tbl);

	return ret;
}

static int ls1x_cpufreq_exit(struct cpufreq_policy *policy)
{
	kfree(policy->freq_table);
	return 0;
}

static struct cpufreq_driver ls1x_cpufreq_driver = {
	.name		= "cpufreq-ls1x",
	.flags		= CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
	.verify		= cpufreq_generic_frequency_table_verify,
	.target_index	= ls1x_cpufreq_target,
	.get		= cpufreq_generic_get,
	.init		= ls1x_cpufreq_init,
	.exit		= ls1x_cpufreq_exit,
	.attr		= cpufreq_generic_attr,
};

static int ls1x_cpufreq_remove(struct platform_device *pdev)
{
	cpufreq_unregister_notifier(&ls1x_cpufreq_notifier_block,
				    CPUFREQ_TRANSITION_NOTIFIER);
	cpufreq_unregister_driver(&ls1x_cpufreq_driver);

	return 0;
}

static int ls1x_cpufreq_probe(struct platform_device *pdev)
{
	struct plat_ls1x_cpufreq *pdata = dev_get_platdata(&pdev->dev);
	struct clk *clk;
	int ret;

	if (!pdata || !pdata->clk_name || !pdata->osc_clk_name) {
		dev_err(&pdev->dev, "platform data missing\n");
		return -EINVAL;
	}

	cpufreq =
	    devm_kzalloc(&pdev->dev, sizeof(struct ls1x_cpufreq), GFP_KERNEL);
	if (!cpufreq)
		return -ENOMEM;

	cpufreq->dev = &pdev->dev;

	clk = devm_clk_get(&pdev->dev, pdata->clk_name);
	if (IS_ERR(clk)) {
		dev_err(&pdev->dev, "unable to get %s clock\n",
			pdata->clk_name);
		return PTR_ERR(clk);
	}
	cpufreq->clk = clk;

	clk = clk_get_parent(clk);
	if (IS_ERR(clk)) {
		dev_err(&pdev->dev, "unable to get parent of %s clock\n",
			__clk_get_name(cpufreq->clk));
		return PTR_ERR(clk);
	}
	cpufreq->mux_clk = clk;

	clk = clk_get_parent(clk);
	if (IS_ERR(clk)) {
		dev_err(&pdev->dev, "unable to get parent of %s clock\n",
			__clk_get_name(cpufreq->mux_clk));
		return PTR_ERR(clk);
	}