1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Channel report handling code 4 * 5 * Copyright IBM Corp. 2000, 2009 6 * Author(s): Ingo Adlung <adlung@de.ibm.com>, 7 * Martin Schwidefsky <schwidefsky@de.ibm.com>, 8 * Cornelia Huck <cornelia.huck@de.ibm.com>, 9 * Heiko Carstens <heiko.carstens@de.ibm.com>, 10 */ 11 12#include <linux/mutex.h> 13#include <linux/kthread.h> 14#include <linux/init.h> 15#include <linux/wait.h> 16#include <asm/crw.h> 17#include <asm/ctl_reg.h> 18#include "ioasm.h" 19 20static DEFINE_MUTEX(crw_handler_mutex); 21static crw_handler_t crw_handlers[NR_RSCS]; 22static atomic_t crw_nr_req = ATOMIC_INIT(0); 23static DECLARE_WAIT_QUEUE_HEAD(crw_handler_wait_q); 24 25/** 26 * crw_register_handler() - register a channel report word handler 27 * @rsc: reporting source code to handle 28 * @handler: handler to be registered 29 * 30 * Returns %0 on success and a negative error value otherwise. 31 */ 32int crw_register_handler(int rsc, crw_handler_t handler) 33{ 34 int rc = 0; 35 36 if ((rsc < 0) || (rsc >= NR_RSCS)) 37 return -EINVAL; 38 mutex_lock(&crw_handler_mutex); 39 if (crw_handlers[rsc]) 40 rc = -EBUSY; 41 else 42 crw_handlers[rsc] = handler; 43 mutex_unlock(&crw_handler_mutex); 44 return rc; 45} 46 47/** 48 * crw_unregister_handler() - unregister a channel report word handler 49 * @rsc: reporting source code to handle 50 */ 51void crw_unregister_handler(int rsc) 52{ 53 if ((rsc < 0) || (rsc >= NR_RSCS)) 54 return; 55 mutex_lock(&crw_handler_mutex); 56 crw_handlers[rsc] = NULL; 57 mutex_unlock(&crw_handler_mutex); 58} 59 60/* 61 * Retrieve CRWs and call function to handle event. 62 */ 63static int crw_collect_info(void *unused) 64{ 65 struct crw crw[2]; 66 int ccode, signal; 67 unsigned int chain; 68 69repeat: 70 signal = wait_event_interruptible(crw_handler_wait_q, 71 atomic_read(&crw_nr_req) > 0); 72 if (unlikely(signal)) 73 atomic_inc(&crw_nr_req); 74 chain = 0; 75 while (1) { 76 crw_handler_t handler; 77 78 if (unlikely(chain > 1)) { 79 struct crw tmp_crw; 80 81 printk(KERN_WARNING"%s: Code does not support more " 82 "than two chained crws; please report to " 83 "linux390@de.ibm.com!\n", __func__); 84 ccode = stcrw(&tmp_crw); 85 printk(KERN_WARNING"%s: crw reports slct=%d, oflw=%d, " 86 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n", 87 __func__, tmp_crw.slct, tmp_crw.oflw, 88 tmp_crw.chn, tmp_crw.rsc, tmp_crw.anc, 89 tmp_crw.erc, tmp_crw.rsid); 90 printk(KERN_WARNING"%s: This was crw number %x in the " 91 "chain\n", __func__, chain); 92 if (ccode != 0) 93 break; 94 chain = tmp_crw.chn ? chain + 1 : 0; 95 continue; 96 } 97 ccode = stcrw(&crw[chain]); 98 if (ccode != 0) 99 break; 100 printk(KERN_DEBUG "crw_info : CRW reports slct=%d, oflw=%d, " 101 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n", 102 crw[chain].slct, crw[chain].oflw, crw[chain].chn, 103 crw[chain].rsc, crw[chain].anc, crw[chain].erc, 104 crw[chain].rsid); 105 /* Check for overflows. */ 106 if (crw[chain].oflw) { 107 int i; 108 109 pr_debug("%s: crw overflow detected!\n", __func__); 110 mutex_lock(&crw_handler_mutex); 111 for (i = 0; i < NR_RSCS; i++) { 112 if (crw_handlers[i]) 113 crw_handlers[i](NULL, NULL, 1); 114 } 115 mutex_unlock(&crw_handler_mutex); 116 chain = 0; 117 continue; 118 } 119 if (crw[0].chn && !chain) { 120 chain++; 121 continue; 122 } 123 mutex_lock(&crw_handler_mutex); 124 handler = crw_handlers[crw[chain].rsc]; 125 if (handler) 126 handler(&crw[0], chain ? &crw[1] : NULL, 0); 127 mutex_unlock(&crw_handler_mutex); 128 /* chain is always 0 or 1 here. */ 129 chain = crw[chain].chn ? chain + 1 : 0; 130 } 131 if (atomic_dec_and_test(&crw_nr_req)) 132 wake_up(&crw_handler_wait_q); 133 goto repeat; 134 return 0; 135} 136 137void crw_handle_channel_report(void) 138{ 139 atomic_inc(&crw_nr_req); 140 wake_up(&crw_handler_wait_q); 141} 142 143void crw_wait_for_channel_report(void) 144{ 145 crw_handle_channel_report(); 146 wait_event(crw_handler_wait_q, atomic_read(&crw_nr_req) == 0); 147} 148 149/* 150 * Machine checks for the channel subsystem must be enabled 151 * after the channel subsystem is initialized 152 */ 153static int __init crw_machine_check_init(void) 154{ 155 struct task_struct *task; 156 157 task = kthread_run(crw_collect_info, NULL, "kmcheck"); 158 if (IS_ERR(task)) 159 return PTR_ERR(task); 160 ctl_set_bit(14, 28); /* enable channel report MCH */ 161 return 0; 162} 163device_initcall(crw_machine_check_init); 164