1 /* 2 * Sclp "store data in absolut storage" 3 * 4 * Copyright IBM Corp. 2003, 2007 5 * Author(s): Michael Holzheu 6 */ 7 8 #define KMSG_COMPONENT "sclp_sdias" 9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 10 11 #include <linux/completion.h> 12 #include <linux/sched.h> 13 #include <asm/sclp.h> 14 #include <asm/debug.h> 15 #include <asm/ipl.h> 16 17 #include "sclp.h" 18 #include "sclp_rw.h" 19 20 #define TRACE(x...) debug_sprintf_event(sdias_dbf, 1, x) 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 = { 37 .send_mask = EVTYP_SDIAS_MASK, 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))); 66 static struct sdias_evbuf sdias_evbuf; 67 68 static DECLARE_COMPLETION(evbuf_accepted); 69 static DECLARE_COMPLETION(evbuf_done); 70 static DEFINE_MUTEX(sdias_mutex); 71 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 */ 86 static void sdias_callback(struct sclp_req *request, void *data) 87 { 88 complete(&evbuf_accepted); 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--) { 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 */ 108 wait_for_completion(&evbuf_accepted); 109 if (req->status == SCLP_REQ_FAILED) { 110 TRACE("sclp request failed\n"); 111 continue; 112 } 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); 129 TRACE("request done\n"); 130 return 0; 131 } 132 return -EIO; 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); 150 sccb.evbuf.hdr.type = EVTYP_SDIAS; 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) { 163 pr_err("sclp_send failed for get_nr_blocks\n"); 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 172 switch (sdias_evbuf.event_status) { 173 case 0: 174 rc = sdias_evbuf.blk_cnt; 175 break; 176 default: 177 pr_err("SCLP error: %x\n", sdias_evbuf.event_status); 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); 209 sccb.evbuf.hdr.type = EVTYP_SDIAS; 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; 214 #ifdef CONFIG_64BIT 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) { 233 pr_err("sclp_send failed: %x\n", rc); 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 242 switch (sdias_evbuf.event_status) { 243 case EVSTATE_ALL_STORED: 244 TRACE("all stored\n"); 245 break; 246 case EVSTATE_PART_STORED: 247 TRACE("part stored: %i\n", sdias_evbuf.blk_cnt); 248 break; 249 case EVSTATE_NO_DATA: 250 TRACE("no data\n"); 251 /* fall through */ 252 default: 253 pr_err("Error from SCLP while copying hsa. " 254 "Event status = %x\n", 255 sdias_evbuf.event_status); 256 rc = -EIO; 257 } 258 out: 259 mutex_unlock(&sdias_mutex); 260 return rc; 261 } 262 263 static int __init sclp_sdias_register_check(void) 264 { 265 int rc; 266 267 rc = sclp_register(&sclp_sdias_register); 268 if (rc) 269 return rc; 270 if (sclp_sdias_blk_count() == 0) { 271 sclp_unregister(&sclp_sdias_register); 272 return -ENODEV; 273 } 274 return 0; 275 } 276 277 static int __init sclp_sdias_init_sync(void) 278 { 279 TRACE("Try synchronous mode\n"); 280 sclp_sdias_register.receive_mask = 0; 281 sclp_sdias_register.receiver_fn = NULL; 282 return sclp_sdias_register_check(); 283 } 284 285 static int __init sclp_sdias_init_async(void) 286 { 287 TRACE("Try asynchronous mode\n"); 288 sclp_sdias_register.receive_mask = EVTYP_SDIAS_MASK; 289 sclp_sdias_register.receiver_fn = sclp_sdias_receiver_fn; 290 return sclp_sdias_register_check(); 291 } 292 293 int __init sclp_sdias_init(void) 294 { 295 if (ipl_info.type != IPL_TYPE_FCP_DUMP) 296 return 0; 297 sdias_dbf = debug_register("dump_sdias", 4, 1, 4 * sizeof(long)); 298 debug_register_view(sdias_dbf, &debug_sprintf_view); 299 debug_set_level(sdias_dbf, 6); 300 if (sclp_sdias_init_sync() == 0) 301 goto out; 302 if (sclp_sdias_init_async() == 0) 303 goto out; 304 TRACE("init failed\n"); 305 return -ENODEV; 306 out: 307 TRACE("init done\n"); 308 return 0; 309 } 310 311 void __exit sclp_sdias_exit(void) 312 { 313 debug_unregister(sdias_dbf); 314 sclp_unregister(&sclp_sdias_register); 315 } 316