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