Commit | Line | Data |
---|---|---|
411ed322 | 1 | /* |
f8049e3e | 2 | * SCLP "store data in absolute storage" |
411ed322 | 3 | * |
f8049e3e | 4 | * Copyright IBM Corp. 2003, 2013 |
411ed322 MH |
5 | * Author(s): Michael Holzheu |
6 | */ | |
7 | ||
b3ff088b MS |
8 | #define KMSG_COMPONENT "sclp_sdias" |
9 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
10 | ||
e3c652b5 | 11 | #include <linux/completion.h> |
411ed322 MH |
12 | #include <linux/sched.h> |
13 | #include <asm/sclp.h> | |
14 | #include <asm/debug.h> | |
15 | #include <asm/ipl.h> | |
b3ff088b | 16 | |
f8049e3e | 17 | #include "sclp_sdias.h" |
411ed322 MH |
18 | #include "sclp.h" |
19 | #include "sclp_rw.h" | |
20 | ||
21 | #define TRACE(x...) debug_sprintf_event(sdias_dbf, 1, x) | |
411ed322 MH |
22 | |
23 | #define SDIAS_RETRIES 300 | |
411ed322 | 24 | |
411ed322 MH |
25 | static struct debug_info *sdias_dbf; |
26 | ||
27 | static struct sclp_register sclp_sdias_register = { | |
6d4740c8 | 28 | .send_mask = EVTYP_SDIAS_MASK, |
411ed322 MH |
29 | }; |
30 | ||
411ed322 | 31 | static struct sdias_sccb sccb __attribute__((aligned(4096))); |
e3c652b5 | 32 | static struct sdias_evbuf sdias_evbuf; |
411ed322 | 33 | |
e3c652b5 MH |
34 | static DECLARE_COMPLETION(evbuf_accepted); |
35 | static DECLARE_COMPLETION(evbuf_done); | |
411ed322 MH |
36 | static DEFINE_MUTEX(sdias_mutex); |
37 | ||
e3c652b5 MH |
38 | /* |
39 | * Called by SCLP base when read event data has been completed (async mode only) | |
40 | */ | |
41 | static void sclp_sdias_receiver_fn(struct evbuf_header *evbuf) | |
42 | { | |
43 | memcpy(&sdias_evbuf, evbuf, | |
44 | min_t(unsigned long, sizeof(sdias_evbuf), evbuf->length)); | |
45 | complete(&evbuf_done); | |
46 | TRACE("sclp_sdias_receiver_fn done\n"); | |
47 | } | |
48 | ||
49 | /* | |
50 | * Called by SCLP base when sdias event has been accepted | |
51 | */ | |
411ed322 MH |
52 | static void sdias_callback(struct sclp_req *request, void *data) |
53 | { | |
e3c652b5 | 54 | complete(&evbuf_accepted); |
411ed322 MH |
55 | TRACE("callback done\n"); |
56 | } | |
57 | ||
58 | static int sdias_sclp_send(struct sclp_req *req) | |
59 | { | |
60 | int retries; | |
61 | int rc; | |
62 | ||
63 | for (retries = SDIAS_RETRIES; retries; retries--) { | |
411ed322 MH |
64 | TRACE("add request\n"); |
65 | rc = sclp_add_request(req); | |
66 | if (rc) { | |
67 | /* not initiated, wait some time and retry */ | |
68 | set_current_state(TASK_INTERRUPTIBLE); | |
69 | TRACE("add request failed: rc = %i\n",rc); | |
2e4aa2f2 | 70 | schedule_timeout(msecs_to_jiffies(500)); |
411ed322 MH |
71 | continue; |
72 | } | |
73 | /* initiated, wait for completion of service call */ | |
e3c652b5 | 74 | wait_for_completion(&evbuf_accepted); |
411ed322 MH |
75 | if (req->status == SCLP_REQ_FAILED) { |
76 | TRACE("sclp request failed\n"); | |
411ed322 MH |
77 | continue; |
78 | } | |
e3c652b5 MH |
79 | /* if not accepted, retry */ |
80 | if (!(sccb.evbuf.hdr.flags & 0x80)) { | |
81 | TRACE("sclp request failed: flags=%x\n", | |
82 | sccb.evbuf.hdr.flags); | |
83 | continue; | |
84 | } | |
85 | /* | |
86 | * for the sync interface the response is in the initial sccb | |
87 | */ | |
88 | if (!sclp_sdias_register.receiver_fn) { | |
89 | memcpy(&sdias_evbuf, &sccb.evbuf, sizeof(sdias_evbuf)); | |
90 | TRACE("sync request done\n"); | |
91 | return 0; | |
92 | } | |
93 | /* otherwise we wait for completion */ | |
94 | wait_for_completion(&evbuf_done); | |
411ed322 | 95 | TRACE("request done\n"); |
e3c652b5 | 96 | return 0; |
411ed322 | 97 | } |
e3c652b5 | 98 | return -EIO; |
411ed322 MH |
99 | } |
100 | ||
101 | /* | |
102 | * Get number of blocks (4K) available in the HSA | |
103 | */ | |
104 | int sclp_sdias_blk_count(void) | |
105 | { | |
106 | struct sclp_req request; | |
107 | int rc; | |
108 | ||
109 | mutex_lock(&sdias_mutex); | |
110 | ||
111 | memset(&sccb, 0, sizeof(sccb)); | |
112 | memset(&request, 0, sizeof(request)); | |
113 | ||
114 | sccb.hdr.length = sizeof(sccb); | |
115 | sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf); | |
6d4740c8 | 116 | sccb.evbuf.hdr.type = EVTYP_SDIAS; |
f8049e3e MH |
117 | sccb.evbuf.event_qual = SDIAS_EQ_SIZE; |
118 | sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP; | |
411ed322 MH |
119 | sccb.evbuf.event_id = 4712; |
120 | sccb.evbuf.dbs = 1; | |
121 | ||
122 | request.sccb = &sccb; | |
123 | request.command = SCLP_CMDW_WRITE_EVENT_DATA; | |
124 | request.status = SCLP_REQ_FILLED; | |
125 | request.callback = sdias_callback; | |
126 | ||
127 | rc = sdias_sclp_send(&request); | |
128 | if (rc) { | |
b3ff088b | 129 | pr_err("sclp_send failed for get_nr_blocks\n"); |
411ed322 MH |
130 | goto out; |
131 | } | |
132 | if (sccb.hdr.response_code != 0x0020) { | |
133 | TRACE("send failed: %x\n", sccb.hdr.response_code); | |
134 | rc = -EIO; | |
135 | goto out; | |
136 | } | |
137 | ||
e3c652b5 | 138 | switch (sdias_evbuf.event_status) { |
411ed322 | 139 | case 0: |
e3c652b5 | 140 | rc = sdias_evbuf.blk_cnt; |
411ed322 MH |
141 | break; |
142 | default: | |
e3c652b5 | 143 | pr_err("SCLP error: %x\n", sdias_evbuf.event_status); |
411ed322 MH |
144 | rc = -EIO; |
145 | goto out; | |
146 | } | |
147 | TRACE("%i blocks\n", rc); | |
148 | out: | |
149 | mutex_unlock(&sdias_mutex); | |
150 | return rc; | |
151 | } | |
152 | ||
153 | /* | |
154 | * Copy from HSA to absolute storage (not reentrant): | |
155 | * | |
156 | * @dest : Address of buffer where data should be copied | |
157 | * @start_blk: Start Block (beginning with 1) | |
158 | * @nr_blks : Number of 4K blocks to copy | |
159 | * | |
160 | * Return Value: 0 : Requested 'number' of blocks of data copied | |
161 | * <0: ERROR - negative event status | |
162 | */ | |
163 | int sclp_sdias_copy(void *dest, int start_blk, int nr_blks) | |
164 | { | |
165 | struct sclp_req request; | |
166 | int rc; | |
167 | ||
168 | mutex_lock(&sdias_mutex); | |
169 | ||
170 | memset(&sccb, 0, sizeof(sccb)); | |
171 | memset(&request, 0, sizeof(request)); | |
172 | ||
173 | sccb.hdr.length = sizeof(sccb); | |
174 | sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf); | |
6d4740c8 | 175 | sccb.evbuf.hdr.type = EVTYP_SDIAS; |
411ed322 | 176 | sccb.evbuf.hdr.flags = 0; |
f8049e3e MH |
177 | sccb.evbuf.event_qual = SDIAS_EQ_STORE_DATA; |
178 | sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP; | |
411ed322 | 179 | sccb.evbuf.event_id = 4712; |
f8049e3e | 180 | sccb.evbuf.asa_size = SDIAS_ASA_SIZE_64; |
411ed322 MH |
181 | sccb.evbuf.event_status = 0; |
182 | sccb.evbuf.blk_cnt = nr_blks; | |
183 | sccb.evbuf.asa = (unsigned long)dest; | |
184 | sccb.evbuf.fbn = start_blk; | |
185 | sccb.evbuf.lbn = 0; | |
186 | sccb.evbuf.dbs = 1; | |
187 | ||
188 | request.sccb = &sccb; | |
189 | request.command = SCLP_CMDW_WRITE_EVENT_DATA; | |
190 | request.status = SCLP_REQ_FILLED; | |
191 | request.callback = sdias_callback; | |
192 | ||
193 | rc = sdias_sclp_send(&request); | |
194 | if (rc) { | |
b3ff088b | 195 | pr_err("sclp_send failed: %x\n", rc); |
411ed322 MH |
196 | goto out; |
197 | } | |
198 | if (sccb.hdr.response_code != 0x0020) { | |
199 | TRACE("copy failed: %x\n", sccb.hdr.response_code); | |
200 | rc = -EIO; | |
201 | goto out; | |
202 | } | |
203 | ||
e3c652b5 | 204 | switch (sdias_evbuf.event_status) { |
f8049e3e MH |
205 | case SDIAS_EVSTATE_ALL_STORED: |
206 | TRACE("all stored\n"); | |
207 | break; | |
208 | case SDIAS_EVSTATE_PART_STORED: | |
209 | TRACE("part stored: %i\n", sdias_evbuf.blk_cnt); | |
210 | break; | |
211 | case SDIAS_EVSTATE_NO_DATA: | |
212 | TRACE("no data\n"); | |
213 | /* fall through */ | |
214 | default: | |
215 | pr_err("Error from SCLP while copying hsa. Event status = %x\n", | |
216 | sdias_evbuf.event_status); | |
217 | rc = -EIO; | |
411ed322 MH |
218 | } |
219 | out: | |
220 | mutex_unlock(&sdias_mutex); | |
221 | return rc; | |
222 | } | |
223 | ||
e3c652b5 | 224 | static int __init sclp_sdias_register_check(void) |
411ed322 MH |
225 | { |
226 | int rc; | |
227 | ||
e3c652b5 MH |
228 | rc = sclp_register(&sclp_sdias_register); |
229 | if (rc) | |
230 | return rc; | |
231 | if (sclp_sdias_blk_count() == 0) { | |
232 | sclp_unregister(&sclp_sdias_register); | |
233 | return -ENODEV; | |
234 | } | |
235 | return 0; | |
236 | } | |
237 | ||
238 | static int __init sclp_sdias_init_sync(void) | |
239 | { | |
240 | TRACE("Try synchronous mode\n"); | |
241 | sclp_sdias_register.receive_mask = 0; | |
242 | sclp_sdias_register.receiver_fn = NULL; | |
243 | return sclp_sdias_register_check(); | |
244 | } | |
245 | ||
246 | static int __init sclp_sdias_init_async(void) | |
247 | { | |
248 | TRACE("Try asynchronous mode\n"); | |
249 | sclp_sdias_register.receive_mask = EVTYP_SDIAS_MASK; | |
250 | sclp_sdias_register.receiver_fn = sclp_sdias_receiver_fn; | |
251 | return sclp_sdias_register_check(); | |
252 | } | |
253 | ||
254 | int __init sclp_sdias_init(void) | |
255 | { | |
411ed322 MH |
256 | if (ipl_info.type != IPL_TYPE_FCP_DUMP) |
257 | return 0; | |
258 | sdias_dbf = debug_register("dump_sdias", 4, 1, 4 * sizeof(long)); | |
259 | debug_register_view(sdias_dbf, &debug_sprintf_view); | |
260 | debug_set_level(sdias_dbf, 6); | |
e3c652b5 MH |
261 | if (sclp_sdias_init_sync() == 0) |
262 | goto out; | |
263 | if (sclp_sdias_init_async() == 0) | |
264 | goto out; | |
265 | TRACE("init failed\n"); | |
266 | return -ENODEV; | |
267 | out: | |
411ed322 MH |
268 | TRACE("init done\n"); |
269 | return 0; | |
270 | } | |
271 | ||
763968e2 | 272 | void __exit sclp_sdias_exit(void) |
411ed322 MH |
273 | { |
274 | debug_unregister(sdias_dbf); | |
275 | sclp_unregister(&sclp_sdias_register); | |
276 | } |