1 /* 2 * Virtio driver bits 3 * 4 * Copyright (c) 2013 Alexander Graf <agraf@suse.de> 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or (at 7 * your option) any later version. See the COPYING file in the top-level 8 * directory. 9 */ 10 11 #include "s390-ccw.h" 12 #include "virtio.h" 13 14 struct vring block; 15 16 static long kvm_hypercall(unsigned long nr, unsigned long param1, 17 unsigned long param2) 18 { 19 register ulong r_nr asm("1") = nr; 20 register ulong r_param1 asm("2") = param1; 21 register ulong r_param2 asm("3") = param2; 22 register long retval asm("2"); 23 24 asm volatile ("diag 2,4,0x500" 25 : "=d" (retval) 26 : "d" (r_nr), "0" (r_param1), "r"(r_param2) 27 : "memory", "cc"); 28 29 return retval; 30 } 31 32 static void virtio_notify(struct subchannel_id schid) 33 { 34 kvm_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY, *(u32*)&schid, 0); 35 } 36 37 /*********************************************** 38 * Virtio functions * 39 ***********************************************/ 40 41 static int drain_irqs(struct subchannel_id schid) 42 { 43 struct irb irb = {}; 44 int r = 0; 45 46 while (1) { 47 /* FIXME: make use of TPI, for that enable subchannel and isc */ 48 if (tsch(schid, &irb)) { 49 /* Might want to differentiate error codes later on. */ 50 if (irb.scsw.cstat) { 51 r = -EIO; 52 } else if (irb.scsw.dstat != 0xc) { 53 r = -EIO; 54 } 55 return r; 56 } 57 } 58 } 59 60 static int run_ccw(struct subchannel_id schid, int cmd, void *ptr, int len) 61 { 62 struct ccw1 ccw = {}; 63 struct cmd_orb orb = {}; 64 struct schib schib; 65 int r; 66 67 /* start command processing */ 68 stsch_err(schid, &schib); 69 schib.scsw.ctrl = SCSW_FCTL_START_FUNC; 70 msch(schid, &schib); 71 72 /* start subchannel command */ 73 orb.fmt = 1; 74 orb.cpa = (u32)(long)&ccw; 75 orb.lpm = 0x80; 76 77 ccw.cmd_code = cmd; 78 ccw.cda = (long)ptr; 79 ccw.count = len; 80 81 r = ssch(schid, &orb); 82 /* 83 * XXX Wait until device is done processing the CCW. For now we can 84 * assume that a simple tsch will have finished the CCW processing, 85 * but the architecture allows for asynchronous operation 86 */ 87 if (!r) { 88 r = drain_irqs(schid); 89 } 90 return r; 91 } 92 93 static void virtio_set_status(struct subchannel_id schid, 94 unsigned long dev_addr) 95 { 96 unsigned char status = dev_addr; 97 if (run_ccw(schid, CCW_CMD_WRITE_STATUS, &status, sizeof(status))) { 98 virtio_panic("Could not write status to host!\n"); 99 } 100 } 101 102 static void virtio_reset(struct subchannel_id schid) 103 { 104 run_ccw(schid, CCW_CMD_VDEV_RESET, NULL, 0); 105 } 106 107 static void vring_init(struct vring *vr, unsigned int num, void *p, 108 unsigned long align) 109 { 110 debug_print_addr("init p", p); 111 vr->num = num; 112 vr->desc = p; 113 vr->avail = p + num*sizeof(struct vring_desc); 114 vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + align-1) 115 & ~(align - 1)); 116 117 /* Zero out all relevant field */ 118 vr->avail->flags = 0; 119 vr->avail->idx = 0; 120 121 /* We're running with interrupts off anyways, so don't bother */ 122 vr->used->flags = VRING_USED_F_NO_NOTIFY; 123 vr->used->idx = 0; 124 125 debug_print_addr("init vr", vr); 126 } 127 128 static void vring_notify(struct subchannel_id schid) 129 { 130 virtio_notify(schid); 131 } 132 133 static void vring_send_buf(struct vring *vr, void *p, int len, int flags) 134 { 135 /* For follow-up chains we need to keep the first entry point */ 136 if (!(flags & VRING_HIDDEN_IS_CHAIN)) { 137 vr->avail->ring[vr->avail->idx % vr->num] = vr->next_idx; 138 } 139 140 vr->desc[vr->next_idx].addr = (ulong)p; 141 vr->desc[vr->next_idx].len = len; 142 vr->desc[vr->next_idx].flags = flags & ~VRING_HIDDEN_IS_CHAIN; 143 vr->desc[vr->next_idx].next = vr->next_idx; 144 vr->desc[vr->next_idx].next++; 145 vr->next_idx++; 146 147 /* Chains only have a single ID */ 148 if (!(flags & VRING_DESC_F_NEXT)) { 149 vr->avail->idx++; 150 } 151 152 vr->used->idx = vr->next_idx; 153 } 154 155 static u64 get_clock(void) 156 { 157 u64 r; 158 159 asm volatile("stck %0" : "=Q" (r) : : "cc"); 160 return r; 161 } 162 163 static ulong get_second(void) 164 { 165 return (get_clock() >> 12) / 1000000; 166 } 167 168 /* 169 * Wait for the host to reply. 170 * 171 * timeout is in seconds if > 0. 172 * 173 * Returns 0 on success, 1 on timeout. 174 */ 175 static int vring_wait_reply(struct vring *vr, int timeout) 176 { 177 ulong target_second = get_second() + timeout; 178 struct subchannel_id schid = vr->schid; 179 int r = 0; 180 181 while (vr->used->idx == vr->next_idx) { 182 vring_notify(schid); 183 if (timeout && (get_second() >= target_second)) { 184 r = 1; 185 break; 186 } 187 yield(); 188 } 189 190 vr->next_idx = 0; 191 vr->desc[0].len = 0; 192 vr->desc[0].flags = 0; 193 194 return r; 195 } 196 197 /*********************************************** 198 * Virtio block * 199 ***********************************************/ 200 201 static int virtio_read_many(ulong sector, void *load_addr, int sec_num) 202 { 203 struct virtio_blk_outhdr out_hdr; 204 u8 status; 205 int r; 206 207 /* Tell the host we want to read */ 208 out_hdr.type = VIRTIO_BLK_T_IN; 209 out_hdr.ioprio = 99; 210 out_hdr.sector = sector; 211 212 vring_send_buf(&block, &out_hdr, sizeof(out_hdr), VRING_DESC_F_NEXT); 213 214 /* This is where we want to receive data */ 215 vring_send_buf(&block, load_addr, SECTOR_SIZE * sec_num, 216 VRING_DESC_F_WRITE | VRING_HIDDEN_IS_CHAIN | 217 VRING_DESC_F_NEXT); 218 219 /* status field */ 220 vring_send_buf(&block, &status, sizeof(u8), VRING_DESC_F_WRITE | 221 VRING_HIDDEN_IS_CHAIN); 222 223 /* Now we can tell the host to read */ 224 vring_wait_reply(&block, 0); 225 226 r = drain_irqs(block.schid); 227 if (r) { 228 /* Well, whatever status is supposed to contain... */ 229 status = 1; 230 } 231 return status; 232 } 233 234 unsigned long virtio_load_direct(ulong rec_list1, ulong rec_list2, 235 ulong subchan_id, void *load_addr) 236 { 237 u8 status; 238 int sec = rec_list1; 239 int sec_num = (((rec_list2 >> 32)+ 1) & 0xffff); 240 int sec_len = rec_list2 >> 48; 241 ulong addr = (ulong)load_addr; 242 243 if (sec_len != SECTOR_SIZE) { 244 return -1; 245 } 246 247 sclp_print("."); 248 status = virtio_read_many(sec, (void*)addr, sec_num); 249 if (status) { 250 virtio_panic("I/O Error"); 251 } 252 addr += sec_num * SECTOR_SIZE; 253 254 return addr; 255 } 256 257 int virtio_read(ulong sector, void *load_addr) 258 { 259 return virtio_read_many(sector, load_addr, 1); 260 } 261 262 void virtio_setup_block(struct subchannel_id schid) 263 { 264 struct vq_info_block info; 265 struct vq_config_block config = {}; 266 267 virtio_reset(schid); 268 269 config.index = 0; 270 if (run_ccw(schid, CCW_CMD_READ_VQ_CONF, &config, sizeof(config))) { 271 virtio_panic("Could not get block device configuration\n"); 272 } 273 vring_init(&block, config.num, (void*)(100 * 1024 * 1024), 274 KVM_S390_VIRTIO_RING_ALIGN); 275 276 info.queue = (100ULL * 1024ULL* 1024ULL); 277 info.align = KVM_S390_VIRTIO_RING_ALIGN; 278 info.index = 0; 279 info.num = config.num; 280 block.schid = schid; 281 282 if (!run_ccw(schid, CCW_CMD_SET_VQ, &info, sizeof(info))) { 283 virtio_set_status(schid, VIRTIO_CONFIG_S_DRIVER_OK); 284 } 285 } 286 287 bool virtio_is_blk(struct subchannel_id schid) 288 { 289 int r; 290 struct senseid senseid = {}; 291 292 /* run sense id command */ 293 r = run_ccw(schid, CCW_CMD_SENSE_ID, &senseid, sizeof(senseid)); 294 if (r) { 295 return false; 296 } 297 if ((senseid.cu_type != 0x3832) || (senseid.cu_model != VIRTIO_ID_BLOCK)) { 298 return false; 299 } 300 301 return true; 302 } 303 304