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 51 static int smsg_path_pending(struct iucv_path *, u8 ipvmid[8], u8 ipuser[16]); 52 static void smsg_message_pending(struct iucv_path *, struct iucv_message *); 53 54 static struct iucv_handler smsg_handler = { 55 .path_pending = smsg_path_pending, 56 .message_pending = smsg_message_pending, 57 }; 58 59 static int smsg_path_pending(struct iucv_path *path, u8 ipvmid[8], 60 u8 ipuser[16]) 61 { 62 if (strncmp(ipvmid, "*MSG ", sizeof(ipvmid)) != 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) 146 iucv_path_sever(smsg_path, NULL); 147 return 0; 148 } 149 150 static int smsg_pm_restore_thaw(struct device *dev) 151 { 152 int rc; 153 154 #ifdef CONFIG_PM_DEBUG 155 printk(KERN_WARNING "smsg_pm_restore_thaw\n"); 156 #endif 157 if (smsg_path) { 158 memset(smsg_path, 0, sizeof(*smsg_path)); 159 smsg_path->msglim = 255; 160 smsg_path->flags = 0; 161 rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ", 162 NULL, NULL, NULL); 163 #ifdef CONFIG_PM_DEBUG 164 if (rc) 165 printk(KERN_ERR 166 "iucv_path_connect returned with rc %i\n", rc); 167 #endif 168 cpcmd("SET SMSG IUCV", NULL, 0, NULL); 169 } 170 return 0; 171 } 172 173 static const struct dev_pm_ops smsg_pm_ops = { 174 .freeze = smsg_pm_freeze, 175 .thaw = smsg_pm_restore_thaw, 176 .restore = smsg_pm_restore_thaw, 177 }; 178 179 static struct device_driver smsg_driver = { 180 .owner = THIS_MODULE, 181 .name = SMSGIUCV_DRV_NAME, 182 .bus = &iucv_bus, 183 .pm = &smsg_pm_ops, 184 }; 185 186 static void __exit smsg_exit(void) 187 { 188 cpcmd("SET SMSG IUCV", NULL, 0, NULL); 189 device_unregister(smsg_dev); 190 iucv_unregister(&smsg_handler, 1); 191 driver_unregister(&smsg_driver); 192 } 193 194 static int __init smsg_init(void) 195 { 196 int rc; 197 198 if (!MACHINE_IS_VM) { 199 rc = -EPROTONOSUPPORT; 200 goto out; 201 } 202 rc = driver_register(&smsg_driver); 203 if (rc != 0) 204 goto out; 205 rc = iucv_register(&smsg_handler, 1); 206 if (rc) 207 goto out_driver; 208 smsg_path = iucv_path_alloc(255, 0, GFP_KERNEL); 209 if (!smsg_path) { 210 rc = -ENOMEM; 211 goto out_register; 212 } 213 rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ", 214 NULL, NULL, NULL); 215 if (rc) 216 goto out_free_path; 217 smsg_dev = kzalloc(sizeof(struct device), GFP_KERNEL); 218 if (!smsg_dev) { 219 rc = -ENOMEM; 220 goto out_free_path; 221 } 222 dev_set_name(smsg_dev, "smsg_iucv"); 223 smsg_dev->bus = &iucv_bus; 224 smsg_dev->parent = iucv_root; 225 smsg_dev->release = (void (*)(struct device *))kfree; 226 smsg_dev->driver = &smsg_driver; 227 rc = device_register(smsg_dev); 228 if (rc) 229 goto out_put; 230 231 cpcmd("SET SMSG IUCV", NULL, 0, NULL); 232 return 0; 233 234 out_put: 235 put_device(smsg_dev); 236 out_free_path: 237 iucv_path_free(smsg_path); 238 smsg_path = NULL; 239 out_register: 240 iucv_unregister(&smsg_handler, 1); 241 out_driver: 242 driver_unregister(&smsg_driver); 243 out: 244 return rc; 245 } 246 247 module_init(smsg_init); 248 module_exit(smsg_exit); 249 MODULE_LICENSE("GPL"); 250 251 EXPORT_SYMBOL(smsg_register_callback); 252 EXPORT_SYMBOL(smsg_unregister_callback); 253