1 /* 2 * IUCV special message driver 3 * 4 * Copyright IBM Corp. 2003, 2009 5 * 6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com) 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2, or (at your option) 11 * any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include <linux/module.h> 24 #include <linux/init.h> 25 #include <linux/errno.h> 26 #include <linux/device.h> 27 #include <linux/slab.h> 28 #include <net/iucv/iucv.h> 29 #include <asm/cpcmd.h> 30 #include <asm/ebcdic.h> 31 #include "smsgiucv.h" 32 33 struct smsg_callback { 34 struct list_head list; 35 const char *prefix; 36 int len; 37 void (*callback)(const char *from, char *str); 38 }; 39 40 MODULE_AUTHOR 41 ("(C) 2003 IBM Corporation by Martin Schwidefsky (schwidefsky@de.ibm.com)"); 42 MODULE_DESCRIPTION ("Linux for S/390 IUCV special message driver"); 43 44 static struct iucv_path *smsg_path; 45 /* dummy device used as trigger for PM functions */ 46 static struct device *smsg_dev; 47 48 static DEFINE_SPINLOCK(smsg_list_lock); 49 static LIST_HEAD(smsg_list); 50 static int iucv_path_connected; 51 52 static int smsg_path_pending(struct iucv_path *, u8 *, u8 *); 53 static void smsg_message_pending(struct iucv_path *, struct iucv_message *); 54 55 static struct iucv_handler smsg_handler = { 56 .path_pending = smsg_path_pending, 57 .message_pending = smsg_message_pending, 58 }; 59 60 static int smsg_path_pending(struct iucv_path *path, u8 *ipvmid, u8 *ipuser) 61 { 62 if (strncmp(ipvmid, "*MSG ", 8) != 0) 63 return -EINVAL; 64 /* Path pending from *MSG. */ 65 return iucv_path_accept(path, &smsg_handler, "SMSGIUCV ", NULL); 66 } 67 68 static void smsg_message_pending(struct iucv_path *path, 69 struct iucv_message *msg) 70 { 71 struct smsg_callback *cb; 72 unsigned char *buffer; 73 unsigned char sender[9]; 74 int rc, i; 75 76 buffer = kmalloc(msg->length + 1, GFP_ATOMIC | GFP_DMA); 77 if (!buffer) { 78 iucv_message_reject(path, msg); 79 return; 80 } 81 rc = iucv_message_receive(path, msg, 0, buffer, msg->length, NULL); 82 if (rc == 0) { 83 buffer[msg->length] = 0; 84 EBCASC(buffer, msg->length); 85 memcpy(sender, buffer, 8); 86 sender[8] = 0; 87 /* Remove trailing whitespace from the sender name. */ 88 for (i = 7; i >= 0; i--) { 89 if (sender[i] != ' ' && sender[i] != '\t') 90 break; 91 sender[i] = 0; 92 } 93 spin_lock(&smsg_list_lock); 94 list_for_each_entry(cb, &smsg_list, list) 95 if (strncmp(buffer + 8, cb->prefix, cb->len) == 0) { 96 cb->callback(sender, buffer + 8); 97 break; 98 } 99 spin_unlock(&smsg_list_lock); 100 } 101 kfree(buffer); 102 } 103 104 int smsg_register_callback(const char *prefix, 105 void (*callback)(const char *from, char *str)) 106 { 107 struct smsg_callback *cb; 108 109 cb = kmalloc(sizeof(struct smsg_callback), GFP_KERNEL); 110 if (!cb) 111 return -ENOMEM; 112 cb->prefix = prefix; 113 cb->len = strlen(prefix); 114 cb->callback = callback; 115 spin_lock_bh(&smsg_list_lock); 116 list_add_tail(&cb->list, &smsg_list); 117 spin_unlock_bh(&smsg_list_lock); 118 return 0; 119 } 120 121 void smsg_unregister_callback(const char *prefix, 122 void (*callback)(const char *from, 123 char *str)) 124 { 125 struct smsg_callback *cb, *tmp; 126 127 spin_lock_bh(&smsg_list_lock); 128 cb = NULL; 129 list_for_each_entry(tmp, &smsg_list, list) 130 if (tmp->callback == callback && 131 strcmp(tmp->prefix, prefix) == 0) { 132 cb = tmp; 133 list_del(&cb->list); 134 break; 135 } 136 spin_unlock_bh(&smsg_list_lock); 137 kfree(cb); 138 } 139 140 static int smsg_pm_freeze(struct device *dev) 141 { 142 #ifdef CONFIG_PM_DEBUG 143 printk(KERN_WARNING "smsg_pm_freeze\n"); 144 #endif 145 if (smsg_path && iucv_path_connected) { 146 iucv_path_sever(smsg_path, NULL); 147 iucv_path_connected = 0; 148 } 149 return 0; 150 } 151 152 static int smsg_pm_restore_thaw(struct device *dev) 153 { 154 int rc; 155 156 #ifdef CONFIG_PM_DEBUG 157 printk(KERN_WARNING "smsg_pm_restore_thaw\n"); 158 #endif 159 if (smsg_path && !iucv_path_connected) { 160 memset(smsg_path, 0, sizeof(*smsg_path)); 161 smsg_path->msglim = 255; 162 smsg_path->flags = 0; 163 rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ", 164 NULL, NULL, NULL); 165 #ifdef CONFIG_PM_DEBUG 166 if (rc) 167 printk(KERN_ERR 168 "iucv_path_connect returned with rc %i\n", rc); 169 #endif 170 if (!rc) 171 iucv_path_connected = 1; 172 cpcmd("SET SMSG IUCV", NULL, 0, NULL); 173 } 174 return 0; 175 } 176 177 static const struct dev_pm_ops smsg_pm_ops = { 178 .freeze = smsg_pm_freeze, 179 .thaw = smsg_pm_restore_thaw, 180 .restore = smsg_pm_restore_thaw, 181 }; 182 183 static struct device_driver smsg_driver = { 184 .owner = THIS_MODULE, 185 .name = SMSGIUCV_DRV_NAME, 186 .bus = &iucv_bus, 187 .pm = &smsg_pm_ops, 188 }; 189 190 static void __exit smsg_exit(void) 191 { 192 cpcmd("SET SMSG IUCV", NULL, 0, NULL); 193 device_unregister(smsg_dev); 194 iucv_unregister(&smsg_handler, 1); 195 driver_unregister(&smsg_driver); 196 } 197 198 static int __init smsg_init(void) 199 { 200 int rc; 201 202 if (!MACHINE_IS_VM) { 203 rc = -EPROTONOSUPPORT; 204 goto out; 205 } 206 rc = driver_register(&smsg_driver); 207 if (rc != 0) 208 goto out; 209 rc = iucv_register(&smsg_handler, 1); 210 if (rc) 211 goto out_driver; 212 smsg_path = iucv_path_alloc(255, 0, GFP_KERNEL); 213 if (!smsg_path) { 214 rc = -ENOMEM; 215 goto out_register; 216 } 217 rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ", 218 NULL, NULL, NULL); 219 if (rc) 220 goto out_free_path; 221 else 222 iucv_path_connected = 1; 223 smsg_dev = kzalloc(sizeof(struct device), GFP_KERNEL); 224 if (!smsg_dev) { 225 rc = -ENOMEM; 226 goto out_free_path; 227 } 228 dev_set_name(smsg_dev, "smsg_iucv"); 229 smsg_dev->bus = &iucv_bus; 230 smsg_dev->parent = iucv_root; 231 smsg_dev->release = (void (*)(struct device *))kfree; 232 smsg_dev->driver = &smsg_driver; 233 rc = device_register(smsg_dev); 234 if (rc) 235 goto out_put; 236 237 cpcmd("SET SMSG IUCV", NULL, 0, NULL); 238 return 0; 239 240 out_put: 241 put_device(smsg_dev); 242 out_free_path: 243 iucv_path_free(smsg_path); 244 smsg_path = NULL; 245 out_register: 246 iucv_unregister(&smsg_handler, 1); 247 out_driver: 248 driver_unregister(&smsg_driver); 249 out: 250 return rc; 251 } 252 253 module_init(smsg_init); 254 module_exit(smsg_exit); 255 MODULE_LICENSE("GPL"); 256 257 EXPORT_SYMBOL(smsg_register_callback); 258 EXPORT_SYMBOL(smsg_unregister_callback); 259