1 /* 2 * Driver for s390 eadm subchannels 3 * 4 * Copyright IBM Corp. 2012 5 * Author(s): Sebastian Ott <sebott@linux.vnet.ibm.com> 6 */ 7 8 #include <linux/kernel_stat.h> 9 #include <linux/workqueue.h> 10 #include <linux/spinlock.h> 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/timer.h> 14 #include <linux/slab.h> 15 #include <linux/list.h> 16 17 #include <asm/css_chars.h> 18 #include <asm/debug.h> 19 #include <asm/isc.h> 20 #include <asm/cio.h> 21 #include <asm/scsw.h> 22 #include <asm/eadm.h> 23 24 #include "eadm_sch.h" 25 #include "ioasm.h" 26 #include "cio.h" 27 #include "css.h" 28 #include "orb.h" 29 30 MODULE_DESCRIPTION("driver for s390 eadm subchannels"); 31 MODULE_LICENSE("GPL"); 32 33 #define EADM_TIMEOUT (5 * HZ) 34 static DEFINE_SPINLOCK(list_lock); 35 static LIST_HEAD(eadm_list); 36 37 static debug_info_t *eadm_debug; 38 39 #define EADM_LOG(imp, txt) do { \ 40 debug_text_event(eadm_debug, imp, txt); \ 41 } while (0) 42 43 static void EADM_LOG_HEX(int level, void *data, int length) 44 { 45 if (level > eadm_debug->level) 46 return; 47 while (length > 0) { 48 debug_event(eadm_debug, level, data, length); 49 length -= eadm_debug->buf_size; 50 data += eadm_debug->buf_size; 51 } 52 } 53 54 static void orb_init(union orb *orb) 55 { 56 memset(orb, 0, sizeof(union orb)); 57 orb->eadm.compat1 = 1; 58 orb->eadm.compat2 = 1; 59 orb->eadm.fmt = 1; 60 orb->eadm.x = 1; 61 } 62 63 static int eadm_subchannel_start(struct subchannel *sch, struct aob *aob) 64 { 65 union orb *orb = &get_eadm_private(sch)->orb; 66 int cc; 67 68 orb_init(orb); 69 orb->eadm.aob = (u32)__pa(aob); 70 orb->eadm.intparm = (u32)(addr_t)sch; 71 orb->eadm.key = PAGE_DEFAULT_KEY >> 4; 72 73 EADM_LOG(6, "start"); 74 EADM_LOG_HEX(6, &sch->schid, sizeof(sch->schid)); 75 76 cc = ssch(sch->schid, orb); 77 switch (cc) { 78 case 0: 79 sch->schib.scsw.eadm.actl |= SCSW_ACTL_START_PEND; 80 break; 81 case 1: /* status pending */ 82 case 2: /* busy */ 83 return -EBUSY; 84 case 3: /* not operational */ 85 return -ENODEV; 86 } 87 return 0; 88 } 89 90 static int eadm_subchannel_clear(struct subchannel *sch) 91 { 92 int cc; 93 94 cc = csch(sch->schid); 95 if (cc) 96 return -ENODEV; 97 98 sch->schib.scsw.eadm.actl |= SCSW_ACTL_CLEAR_PEND; 99 return 0; 100 } 101 102 static void eadm_subchannel_timeout(unsigned long data) 103 { 104 struct subchannel *sch = (struct subchannel *) data; 105 106 spin_lock_irq(sch->lock); 107 EADM_LOG(1, "timeout"); 108 EADM_LOG_HEX(1, &sch->schid, sizeof(sch->schid)); 109 if (eadm_subchannel_clear(sch)) 110 EADM_LOG(0, "clear failed"); 111 spin_unlock_irq(sch->lock); 112 } 113 114 static void eadm_subchannel_set_timeout(struct subchannel *sch, int expires) 115 { 116 struct eadm_private *private = get_eadm_private(sch); 117 118 if (expires == 0) { 119 del_timer(&private->timer); 120 return; 121 } 122 if (timer_pending(&private->timer)) { 123 if (mod_timer(&private->timer, jiffies + expires)) 124 return; 125 } 126 private->timer.function = eadm_subchannel_timeout; 127 private->timer.data = (unsigned long) sch; 128 private->timer.expires = jiffies + expires; 129 add_timer(&private->timer); 130 } 131 132 static void eadm_subchannel_irq(struct subchannel *sch) 133 { 134 struct eadm_private *private = get_eadm_private(sch); 135 struct eadm_scsw *scsw = &sch->schib.scsw.eadm; 136 struct irb *irb = (struct irb *)&S390_lowcore.irb; 137 int error = 0; 138 139 EADM_LOG(6, "irq"); 140 EADM_LOG_HEX(6, irb, sizeof(*irb)); 141 142 kstat_cpu(smp_processor_id()).irqs[IOINT_ADM]++; 143 144 if ((scsw->stctl & (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND)) 145 && scsw->eswf == 1 && irb->esw.eadm.erw.r) 146 error = -EIO; 147 148 if (scsw->fctl & SCSW_FCTL_CLEAR_FUNC) 149 error = -ETIMEDOUT; 150 151 eadm_subchannel_set_timeout(sch, 0); 152 153 if (private->state != EADM_BUSY) { 154 EADM_LOG(1, "irq unsol"); 155 EADM_LOG_HEX(1, irb, sizeof(*irb)); 156 private->state = EADM_NOT_OPER; 157 css_sched_sch_todo(sch, SCH_TODO_EVAL); 158 return; 159 } 160 scm_irq_handler((struct aob *)(unsigned long)scsw->aob, error); 161 private->state = EADM_IDLE; 162 } 163 164 static struct subchannel *eadm_get_idle_sch(void) 165 { 166 struct eadm_private *private; 167 struct subchannel *sch; 168 unsigned long flags; 169 170 spin_lock_irqsave(&list_lock, flags); 171 list_for_each_entry(private, &eadm_list, head) { 172 sch = private->sch; 173 spin_lock(sch->lock); 174 if (private->state == EADM_IDLE) { 175 private->state = EADM_BUSY; 176 list_move_tail(&private->head, &eadm_list); 177 spin_unlock(sch->lock); 178 spin_unlock_irqrestore(&list_lock, flags); 179 180 return sch; 181 } 182 spin_unlock(sch->lock); 183 } 184 spin_unlock_irqrestore(&list_lock, flags); 185 186 return NULL; 187 } 188 189 static int eadm_start_aob(struct aob *aob) 190 { 191 struct eadm_private *private; 192 struct subchannel *sch; 193 unsigned long flags; 194 int ret; 195 196 sch = eadm_get_idle_sch(); 197 if (!sch) 198 return -EBUSY; 199 200 spin_lock_irqsave(sch->lock, flags); 201 eadm_subchannel_set_timeout(sch, EADM_TIMEOUT); 202 ret = eadm_subchannel_start(sch, aob); 203 if (!ret) 204 goto out_unlock; 205 206 /* Handle start subchannel failure. */ 207 eadm_subchannel_set_timeout(sch, 0); 208 private = get_eadm_private(sch); 209 private->state = EADM_NOT_OPER; 210 css_sched_sch_todo(sch, SCH_TODO_EVAL); 211 212 out_unlock: 213 spin_unlock_irqrestore(sch->lock, flags); 214 215 return ret; 216 } 217 218 static int eadm_subchannel_probe(struct subchannel *sch) 219 { 220 struct eadm_private *private; 221 int ret; 222 223 private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA); 224 if (!private) 225 return -ENOMEM; 226 227 INIT_LIST_HEAD(&private->head); 228 init_timer(&private->timer); 229 230 spin_lock_irq(sch->lock); 231 set_eadm_private(sch, private); 232 private->state = EADM_IDLE; 233 private->sch = sch; 234 sch->isc = EADM_SCH_ISC; 235 ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch); 236 if (ret) { 237 set_eadm_private(sch, NULL); 238 spin_unlock_irq(sch->lock); 239 kfree(private); 240 goto out; 241 } 242 spin_unlock_irq(sch->lock); 243 244 spin_lock_irq(&list_lock); 245 list_add(&private->head, &eadm_list); 246 spin_unlock_irq(&list_lock); 247 248 if (dev_get_uevent_suppress(&sch->dev)) { 249 dev_set_uevent_suppress(&sch->dev, 0); 250 kobject_uevent(&sch->dev.kobj, KOBJ_ADD); 251 } 252 out: 253 return ret; 254 } 255 256 static void eadm_quiesce(struct subchannel *sch) 257 { 258 int ret; 259 260 do { 261 spin_lock_irq(sch->lock); 262 ret = cio_disable_subchannel(sch); 263 spin_unlock_irq(sch->lock); 264 } while (ret == -EBUSY); 265 } 266 267 static int eadm_subchannel_remove(struct subchannel *sch) 268 { 269 struct eadm_private *private = get_eadm_private(sch); 270 271 spin_lock_irq(&list_lock); 272 list_del(&private->head); 273 spin_unlock_irq(&list_lock); 274 275 eadm_quiesce(sch); 276 277 spin_lock_irq(sch->lock); 278 set_eadm_private(sch, NULL); 279 spin_unlock_irq(sch->lock); 280 281 kfree(private); 282 283 return 0; 284 } 285 286 static void eadm_subchannel_shutdown(struct subchannel *sch) 287 { 288 eadm_quiesce(sch); 289 } 290 291 static int eadm_subchannel_freeze(struct subchannel *sch) 292 { 293 return cio_disable_subchannel(sch); 294 } 295 296 static int eadm_subchannel_restore(struct subchannel *sch) 297 { 298 return cio_enable_subchannel(sch, (u32)(unsigned long)sch); 299 } 300 301 /** 302 * eadm_subchannel_sch_event - process subchannel event 303 * @sch: subchannel 304 * @process: non-zero if function is called in process context 305 * 306 * An unspecified event occurred for this subchannel. Adjust data according 307 * to the current operational state of the subchannel. Return zero when the 308 * event has been handled sufficiently or -EAGAIN when this function should 309 * be called again in process context. 310 */ 311 static int eadm_subchannel_sch_event(struct subchannel *sch, int process) 312 { 313 struct eadm_private *private; 314 unsigned long flags; 315 int ret = 0; 316 317 spin_lock_irqsave(sch->lock, flags); 318 if (!device_is_registered(&sch->dev)) 319 goto out_unlock; 320 321 if (work_pending(&sch->todo_work)) 322 goto out_unlock; 323 324 if (cio_update_schib(sch)) { 325 css_sched_sch_todo(sch, SCH_TODO_UNREG); 326 goto out_unlock; 327 } 328 private = get_eadm_private(sch); 329 if (private->state == EADM_NOT_OPER) 330 private->state = EADM_IDLE; 331 332 out_unlock: 333 spin_unlock_irqrestore(sch->lock, flags); 334 335 return ret; 336 } 337 338 static struct css_device_id eadm_subchannel_ids[] = { 339 { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_ADM, }, 340 { /* end of list */ }, 341 }; 342 MODULE_DEVICE_TABLE(css, eadm_subchannel_ids); 343 344 static struct css_driver eadm_subchannel_driver = { 345 .drv = { 346 .name = "eadm_subchannel", 347 .owner = THIS_MODULE, 348 }, 349 .subchannel_type = eadm_subchannel_ids, 350 .irq = eadm_subchannel_irq, 351 .probe = eadm_subchannel_probe, 352 .remove = eadm_subchannel_remove, 353 .shutdown = eadm_subchannel_shutdown, 354 .sch_event = eadm_subchannel_sch_event, 355 .freeze = eadm_subchannel_freeze, 356 .thaw = eadm_subchannel_restore, 357 .restore = eadm_subchannel_restore, 358 }; 359 360 static struct eadm_ops eadm_ops = { 361 .eadm_start = eadm_start_aob, 362 .owner = THIS_MODULE, 363 }; 364 365 static int __init eadm_sch_init(void) 366 { 367 int ret; 368 369 if (!css_general_characteristics.eadm) 370 return -ENXIO; 371 372 eadm_debug = debug_register("eadm_log", 16, 1, 16); 373 if (!eadm_debug) 374 return -ENOMEM; 375 376 debug_register_view(eadm_debug, &debug_hex_ascii_view); 377 debug_set_level(eadm_debug, 2); 378 379 isc_register(EADM_SCH_ISC); 380 ret = css_driver_register(&eadm_subchannel_driver); 381 if (ret) 382 goto cleanup; 383 384 register_eadm_ops(&eadm_ops); 385 return ret; 386 387 cleanup: 388 isc_unregister(EADM_SCH_ISC); 389 debug_unregister(eadm_debug); 390 return ret; 391 } 392 393 static void __exit eadm_sch_exit(void) 394 { 395 unregister_eadm_ops(&eadm_ops); 396 css_driver_unregister(&eadm_subchannel_driver); 397 isc_unregister(EADM_SCH_ISC); 398 debug_unregister(eadm_debug); 399 } 400 module_init(eadm_sch_init); 401 module_exit(eadm_sch_exit); 402