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