summaryrefslogtreecommitdiffstats
path: root/include/linux/nvram.h
blob: d29d9c93a9270a0cbdcd5b3ff3c90910d263dff5 (plain)
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
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_NVRAM_H
#define _LINUX_NVRAM_H

#include <linux/errno.h>
#include <uapi/linux/nvram.h>

#ifdef CONFIG_PPC
#include <asm/machdep.h>
#endif

/**
 * struct nvram_ops - NVRAM functionality made available to drivers
 * @read: validate checksum (if any) then load a range of bytes from NVRAM
 * @write: store a range of bytes to NVRAM then update checksum (if any)
 * @read_byte: load a single byte from NVRAM
 * @write_byte: store a single byte to NVRAM
 * @get_size: return the fixed number of bytes in the NVRAM
 *
 * Architectures which provide an nvram ops struct need not implement all
 * of these methods. If the NVRAM hardware can be accessed only one byte
 * at a time then it may be sufficient to provide .read_byte and .write_byte.
 * If the NVRAM has a checksum (and it is to be checked) the .read and
 * .write methods can be used to implement that efficiently.
 *
 * Portable drivers may use the wrapper functions defined here.
 * The nvram_read() and nvram_write() functions call the .read and .write
 * methods when available and fall back on the .read_byte and .write_byte
 * methods otherwise.
 */

struct nvram_ops {
	ssize_t         (*get_size)(void);
	unsigned char   (*read_byte)(int);
	void            (*write_byte)(unsigned char, int);
	ssize_t         (*read)(char *, size_t, loff_t *);
	ssize_t         (*write)(char *, size_t, loff_t *);
#if defined(CONFIG_X86) || defined(CONFIG_M68K)
	long            (*initialize)(void);
	long            (*set_checksum)(void);
#endif
};

extern const struct nvram_ops arch_nvram_ops;

static inline ssize_t nvram_get_size(void)
{
#ifdef CONFIG_PPC
	if (ppc_md.nvram_size)
		return ppc_md.nvram_size();
#else
	if (arch_nvram_ops.get_size)
		return arch_nvram_ops.get_size();
#endif
	return -ENODEV;
}

static inline unsigned char nvram_read_byte(int addr)
{
#ifdef CONFIG_PPC
	if (ppc_md.nvram_read_val)
		return ppc_md.nvram_read_val(addr);
#else
	if (arch_nvram_ops.read_byte)
		return arch_nvram_ops.read_byte(addr);
#endif
	return 0xFF;
}

static inline void nvram_write_byte(unsigned char val, int addr)
{
#ifdef CONFIG_PPC
	if (ppc_md.nvram_write_val)
		ppc_md.nvram_write_val(addr, val);
#else
	if (arch_nvram_ops.write_byte)
		arch_nvram_ops.write_byte(val, addr);
#endif
}

static inline ssize_t nvram_read_bytes(char *buf, size_t count, loff_t *ppos)
{
	ssize_t nvram_size = nvram_get_size();
	loff_t i;
	char *p = buf;

	if (nvram_size < 0)
		return nvram_size;
	for (i = *ppos; count > 0 && i < nvram_size; ++i, ++p, --count)
		*p = nvram_read_byte(i);
	*ppos = i;
	return p - buf;
}

static inline ssize_t nvram_write_bytes(char *buf, size_t count, loff_t *ppos)
{
	ssize_t nvram_size = nvram_get_size();
	loff_t i;
	char *p = buf;

	if (nvram_size < 0)
		return nvram_size;
	for (i = *ppos; count > 0 && i < nvram_size; ++i, ++p, --count)
		nvram_write_byte(*p, i);
	*ppos = i;
	return p - buf;
}

static inline ssize_t nvram_read(char *buf, size_t count, loff_t *ppos)
{
#ifdef CONFIG_PPC
	if (ppc_md.nvram_read)
		return ppc_md.nvram_read(buf, count, ppos);
#else
	if (arch_nvram_ops.read)
		return arch_nvram_ops.read(buf, count, ppos);
#endif
	return nvram_read_bytes(buf, count, ppos);
}

static inline ssize_t nvram_write(char *buf, size_t count, loff_t *ppos)
{
#ifdef CONFIG_PPC
	if (ppc_md.nvram_write)
		return ppc_md.nvram_write(buf, count, ppos);
#else
	if (arch_nvram_ops.write)
		return arch_nvram_ops.write(buf, count, ppos);
#endif
	return nvram_write_bytes(buf, count, ppos);
}

#endif  /* _LINUX_NVRAM_H */
OpenPOWER on IntegriCloud