drivers/s390/cio/eadm_sch.c

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