OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [kernel/] [power/] [power.h] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
#include <linux/suspend.h>
2
#include <linux/utsname.h>
3
 
4
struct swsusp_info {
5
        struct new_utsname      uts;
6
        u32                     version_code;
7
        unsigned long           num_physpages;
8
        int                     cpus;
9
        unsigned long           image_pages;
10
        unsigned long           pages;
11
        unsigned long           size;
12
} __attribute__((aligned(PAGE_SIZE)));
13
 
14
#ifdef CONFIG_HIBERNATION
15
#ifdef CONFIG_ARCH_HIBERNATION_HEADER
16
/* Maximum size of architecture specific data in a hibernation header */
17
#define MAX_ARCH_HEADER_SIZE    (sizeof(struct new_utsname) + 4)
18
 
19
extern int arch_hibernation_header_save(void *addr, unsigned int max_size);
20
extern int arch_hibernation_header_restore(void *addr);
21
 
22
static inline int init_header_complete(struct swsusp_info *info)
23
{
24
        return arch_hibernation_header_save(info, MAX_ARCH_HEADER_SIZE);
25
}
26
 
27
static inline char *check_image_kernel(struct swsusp_info *info)
28
{
29
        return arch_hibernation_header_restore(info) ?
30
                        "architecture specific data" : NULL;
31
}
32
#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
33
 
34
/*
35
 * Keep some memory free so that I/O operations can succeed without paging
36
 * [Might this be more than 4 MB?]
37
 */
38
#define PAGES_FOR_IO    ((4096 * 1024) >> PAGE_SHIFT)
39
 
40
/*
41
 * Keep 1 MB of memory free so that device drivers can allocate some pages in
42
 * their .suspend() routines without breaking the suspend to disk.
43
 */
44
#define SPARE_PAGES     ((1024 * 1024) >> PAGE_SHIFT)
45
 
46
/* kernel/power/disk.c */
47
extern int hibernation_snapshot(int platform_mode);
48
extern int hibernation_restore(int platform_mode);
49
extern int hibernation_platform_enter(void);
50
#endif
51
 
52
extern int pfn_is_nosave(unsigned long);
53
 
54
extern struct mutex pm_mutex;
55
 
56
#define power_attr(_name) \
57
static struct subsys_attribute _name##_attr = { \
58
        .attr   = {                             \
59
                .name = __stringify(_name),     \
60
                .mode = 0644,                   \
61
        },                                      \
62
        .show   = _name##_show,                 \
63
        .store  = _name##_store,                \
64
}
65
 
66
extern struct kset power_subsys;
67
 
68
/* Preferred image size in bytes (default 500 MB) */
69
extern unsigned long image_size;
70
extern int in_suspend;
71
extern dev_t swsusp_resume_device;
72
extern sector_t swsusp_resume_block;
73
 
74
extern asmlinkage int swsusp_arch_suspend(void);
75
extern asmlinkage int swsusp_arch_resume(void);
76
 
77
extern int create_basic_memory_bitmaps(void);
78
extern void free_basic_memory_bitmaps(void);
79
extern unsigned int count_data_pages(void);
80
 
81
/**
82
 *      Auxiliary structure used for reading the snapshot image data and
83
 *      metadata from and writing them to the list of page backup entries
84
 *      (PBEs) which is the main data structure of swsusp.
85
 *
86
 *      Using struct snapshot_handle we can transfer the image, including its
87
 *      metadata, as a continuous sequence of bytes with the help of
88
 *      snapshot_read_next() and snapshot_write_next().
89
 *
90
 *      The code that writes the image to a storage or transfers it to
91
 *      the user land is required to use snapshot_read_next() for this
92
 *      purpose and it should not make any assumptions regarding the internal
93
 *      structure of the image.  Similarly, the code that reads the image from
94
 *      a storage or transfers it from the user land is required to use
95
 *      snapshot_write_next().
96
 *
97
 *      This may allow us to change the internal structure of the image
98
 *      in the future with considerably less effort.
99
 */
100
 
101
struct snapshot_handle {
102
        loff_t          offset; /* number of the last byte ready for reading
103
                                 * or writing in the sequence
104
                                 */
105
        unsigned int    cur;    /* number of the block of PAGE_SIZE bytes the
106
                                 * next operation will refer to (ie. current)
107
                                 */
108
        unsigned int    cur_offset;     /* offset with respect to the current
109
                                         * block (for the next operation)
110
                                         */
111
        unsigned int    prev;   /* number of the block of PAGE_SIZE bytes that
112
                                 * was the current one previously
113
                                 */
114
        void            *buffer;        /* address of the block to read from
115
                                         * or write to
116
                                         */
117
        unsigned int    buf_offset;     /* location to read from or write to,
118
                                         * given as a displacement from 'buffer'
119
                                         */
120
        int             sync_read;      /* Set to one to notify the caller of
121
                                         * snapshot_write_next() that it may
122
                                         * need to call wait_on_bio_chain()
123
                                         */
124
};
125
 
126
/* This macro returns the address from/to which the caller of
127
 * snapshot_read_next()/snapshot_write_next() is allowed to
128
 * read/write data after the function returns
129
 */
130
#define data_of(handle) ((handle).buffer + (handle).buf_offset)
131
 
132
extern unsigned int snapshot_additional_pages(struct zone *zone);
133
extern int snapshot_read_next(struct snapshot_handle *handle, size_t count);
134
extern int snapshot_write_next(struct snapshot_handle *handle, size_t count);
135
extern void snapshot_write_finalize(struct snapshot_handle *handle);
136
extern int snapshot_image_loaded(struct snapshot_handle *handle);
137
 
138
/*
139
 * This structure is used to pass the values needed for the identification
140
 * of the resume swap area from a user space to the kernel via the
141
 * SNAPSHOT_SET_SWAP_AREA ioctl
142
 */
143
struct resume_swap_area {
144
        loff_t offset;
145
        u_int32_t dev;
146
} __attribute__((packed));
147
 
148
#define SNAPSHOT_IOC_MAGIC      '3'
149
#define SNAPSHOT_FREEZE                 _IO(SNAPSHOT_IOC_MAGIC, 1)
150
#define SNAPSHOT_UNFREEZE               _IO(SNAPSHOT_IOC_MAGIC, 2)
151
#define SNAPSHOT_ATOMIC_SNAPSHOT        _IOW(SNAPSHOT_IOC_MAGIC, 3, void *)
152
#define SNAPSHOT_ATOMIC_RESTORE         _IO(SNAPSHOT_IOC_MAGIC, 4)
153
#define SNAPSHOT_FREE                   _IO(SNAPSHOT_IOC_MAGIC, 5)
154
#define SNAPSHOT_SET_IMAGE_SIZE         _IOW(SNAPSHOT_IOC_MAGIC, 6, unsigned long)
155
#define SNAPSHOT_AVAIL_SWAP             _IOR(SNAPSHOT_IOC_MAGIC, 7, void *)
156
#define SNAPSHOT_GET_SWAP_PAGE          _IOR(SNAPSHOT_IOC_MAGIC, 8, void *)
157
#define SNAPSHOT_FREE_SWAP_PAGES        _IO(SNAPSHOT_IOC_MAGIC, 9)
158
#define SNAPSHOT_SET_SWAP_FILE          _IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int)
159
#define SNAPSHOT_S2RAM                  _IO(SNAPSHOT_IOC_MAGIC, 11)
160
#define SNAPSHOT_PMOPS                  _IOW(SNAPSHOT_IOC_MAGIC, 12, unsigned int)
161
#define SNAPSHOT_SET_SWAP_AREA          _IOW(SNAPSHOT_IOC_MAGIC, 13, \
162
                                                        struct resume_swap_area)
163
#define SNAPSHOT_IOC_MAXNR      13
164
 
165
#define PMOPS_PREPARE   1
166
#define PMOPS_ENTER     2
167
#define PMOPS_FINISH    3
168
 
169
/* If unset, the snapshot device cannot be open. */
170
extern atomic_t snapshot_device_available;
171
 
172
extern sector_t alloc_swapdev_block(int swap);
173
extern void free_all_swap_pages(int swap);
174
extern int swsusp_swap_in_use(void);
175
 
176
/*
177
 * Flags that can be passed from the hibernatig hernel to the "boot" kernel in
178
 * the image header.
179
 */
180
#define SF_PLATFORM_MODE        1
181
 
182
/* kernel/power/disk.c */
183
extern int swsusp_check(void);
184
extern int swsusp_shrink_memory(void);
185
extern void swsusp_free(void);
186
extern int swsusp_resume(void);
187
extern int swsusp_read(unsigned int *flags_p);
188
extern int swsusp_write(unsigned int flags);
189
extern void swsusp_close(void);
190
 
191
struct timeval;
192
/* kernel/power/swsusp.c */
193
extern void swsusp_show_speed(struct timeval *, struct timeval *,
194
                                unsigned int, char *);
195
 
196
#ifdef CONFIG_SUSPEND
197
/* kernel/power/main.c */
198
extern int suspend_devices_and_enter(suspend_state_t state);
199
#else /* !CONFIG_SUSPEND */
200
static inline int suspend_devices_and_enter(suspend_state_t state)
201
{
202
        return -ENOSYS;
203
}
204
#endif /* !CONFIG_SUSPEND */
205
 
206
/* kernel/power/common.c */
207
extern struct blocking_notifier_head pm_chain_head;
208
 
209
static inline int pm_notifier_call_chain(unsigned long val)
210
{
211
        return (blocking_notifier_call_chain(&pm_chain_head, val, NULL)
212
                        == NOTIFY_BAD) ? -EINVAL : 0;
213
}

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.