Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * IUCV special message driver |
| 3 | * |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 4 | * Copyright IBM Corp. 2003, 2009 |
| 5 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 27 | #include <linux/slab.h> |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 28 | #include <net/iucv/iucv.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <asm/cpcmd.h> |
| 30 | #include <asm/ebcdic.h> |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 31 | #include "smsgiucv.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | |
| 33 | struct smsg_callback { |
| 34 | struct list_head list; |
Hendrik Brueckner | 09003ed | 2010-03-08 12:26:25 +0100 | [diff] [blame] | 35 | const char *prefix; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | int len; |
Hendrik Brueckner | 09003ed | 2010-03-08 12:26:25 +0100 | [diff] [blame] | 37 | void (*callback)(const char *from, char *str); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 44 | static struct iucv_path *smsg_path; |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 45 | /* dummy device used as trigger for PM functions */ |
| 46 | static struct device *smsg_dev; |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 47 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | static DEFINE_SPINLOCK(smsg_list_lock); |
Denis Cheng | c11ca97 | 2008-01-26 14:11:13 +0100 | [diff] [blame] | 49 | static LIST_HEAD(smsg_list); |
Ursula Braun | 59b60e9 | 2010-06-21 22:57:02 +0000 | [diff] [blame] | 50 | static int iucv_path_connected; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 52 | static int smsg_path_pending(struct iucv_path *, u8 ipvmid[8], u8 ipuser[16]); |
| 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[8], |
| 61 | u8 ipuser[16]) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | { |
Stefan Weil | 08b0183 | 2011-02-02 06:04:36 +0000 | [diff] [blame] | 63 | if (strncmp(ipvmid, "*MSG ", 8) != 0) |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 64 | return -EINVAL; |
| 65 | /* Path pending from *MSG. */ |
| 66 | return iucv_path_accept(path, &smsg_handler, "SMSGIUCV ", NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | } |
| 68 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 69 | static void smsg_message_pending(struct iucv_path *path, |
| 70 | struct iucv_message *msg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | { |
| 72 | struct smsg_callback *cb; |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 73 | unsigned char *buffer; |
Martin Schwidefsky | 15439d7 | 2005-05-01 08:58:58 -0700 | [diff] [blame] | 74 | unsigned char sender[9]; |
Martin Schwidefsky | 15439d7 | 2005-05-01 08:58:58 -0700 | [diff] [blame] | 75 | int rc, i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 77 | buffer = kmalloc(msg->length + 1, GFP_ATOMIC | GFP_DMA); |
| 78 | if (!buffer) { |
| 79 | iucv_message_reject(path, msg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | return; |
| 81 | } |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 82 | rc = iucv_message_receive(path, msg, 0, buffer, msg->length, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | if (rc == 0) { |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 84 | buffer[msg->length] = 0; |
| 85 | EBCASC(buffer, msg->length); |
| 86 | memcpy(sender, buffer, 8); |
Martin Schwidefsky | 15439d7 | 2005-05-01 08:58:58 -0700 | [diff] [blame] | 87 | sender[8] = 0; |
| 88 | /* Remove trailing whitespace from the sender name. */ |
| 89 | for (i = 7; i >= 0; i--) { |
| 90 | if (sender[i] != ' ' && sender[i] != '\t') |
| 91 | break; |
| 92 | sender[i] = 0; |
| 93 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | spin_lock(&smsg_list_lock); |
| 95 | list_for_each_entry(cb, &smsg_list, list) |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 96 | if (strncmp(buffer + 8, cb->prefix, cb->len) == 0) { |
| 97 | cb->callback(sender, buffer + 8); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | break; |
| 99 | } |
| 100 | spin_unlock(&smsg_list_lock); |
| 101 | } |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 102 | kfree(buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | } |
| 104 | |
Hendrik Brueckner | 09003ed | 2010-03-08 12:26:25 +0100 | [diff] [blame] | 105 | int smsg_register_callback(const char *prefix, |
| 106 | void (*callback)(const char *from, char *str)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | { |
| 108 | struct smsg_callback *cb; |
| 109 | |
| 110 | cb = kmalloc(sizeof(struct smsg_callback), GFP_KERNEL); |
| 111 | if (!cb) |
| 112 | return -ENOMEM; |
| 113 | cb->prefix = prefix; |
| 114 | cb->len = strlen(prefix); |
| 115 | cb->callback = callback; |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 116 | spin_lock_bh(&smsg_list_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | list_add_tail(&cb->list, &smsg_list); |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 118 | spin_unlock_bh(&smsg_list_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | return 0; |
| 120 | } |
| 121 | |
Hendrik Brueckner | 09003ed | 2010-03-08 12:26:25 +0100 | [diff] [blame] | 122 | void smsg_unregister_callback(const char *prefix, |
| 123 | void (*callback)(const char *from, |
| 124 | char *str)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | { |
| 126 | struct smsg_callback *cb, *tmp; |
| 127 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 128 | spin_lock_bh(&smsg_list_lock); |
Heiko Carstens | d2c993d | 2006-07-12 16:41:55 +0200 | [diff] [blame] | 129 | cb = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | list_for_each_entry(tmp, &smsg_list, list) |
| 131 | if (tmp->callback == callback && |
| 132 | strcmp(tmp->prefix, prefix) == 0) { |
| 133 | cb = tmp; |
| 134 | list_del(&cb->list); |
| 135 | break; |
| 136 | } |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 137 | spin_unlock_bh(&smsg_list_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | kfree(cb); |
| 139 | } |
| 140 | |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 141 | static int smsg_pm_freeze(struct device *dev) |
| 142 | { |
| 143 | #ifdef CONFIG_PM_DEBUG |
| 144 | printk(KERN_WARNING "smsg_pm_freeze\n"); |
| 145 | #endif |
Ursula Braun | 59b60e9 | 2010-06-21 22:57:02 +0000 | [diff] [blame] | 146 | if (smsg_path && iucv_path_connected) { |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 147 | iucv_path_sever(smsg_path, NULL); |
Ursula Braun | 59b60e9 | 2010-06-21 22:57:02 +0000 | [diff] [blame] | 148 | iucv_path_connected = 0; |
| 149 | } |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 150 | return 0; |
| 151 | } |
| 152 | |
| 153 | static int smsg_pm_restore_thaw(struct device *dev) |
| 154 | { |
| 155 | int rc; |
| 156 | |
| 157 | #ifdef CONFIG_PM_DEBUG |
| 158 | printk(KERN_WARNING "smsg_pm_restore_thaw\n"); |
| 159 | #endif |
Hendrik Brueckner | 1c8161a | 2012-10-15 19:21:17 +0000 | [diff] [blame] | 160 | if (smsg_path && !iucv_path_connected) { |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 161 | memset(smsg_path, 0, sizeof(*smsg_path)); |
| 162 | smsg_path->msglim = 255; |
| 163 | smsg_path->flags = 0; |
| 164 | rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ", |
| 165 | NULL, NULL, NULL); |
Martin Schwidefsky | 8ca4566 | 2009-10-29 15:04:08 +0100 | [diff] [blame] | 166 | #ifdef CONFIG_PM_DEBUG |
| 167 | if (rc) |
| 168 | printk(KERN_ERR |
| 169 | "iucv_path_connect returned with rc %i\n", rc); |
| 170 | #endif |
Ursula Braun | 59b60e9 | 2010-06-21 22:57:02 +0000 | [diff] [blame] | 171 | if (!rc) |
| 172 | iucv_path_connected = 1; |
Martin Schwidefsky | 8ca4566 | 2009-10-29 15:04:08 +0100 | [diff] [blame] | 173 | cpcmd("SET SMSG IUCV", NULL, 0, NULL); |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 174 | } |
| 175 | return 0; |
| 176 | } |
| 177 | |
Alexey Dobriyan | 4714521 | 2009-12-14 18:00:08 -0800 | [diff] [blame] | 178 | static const struct dev_pm_ops smsg_pm_ops = { |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 179 | .freeze = smsg_pm_freeze, |
| 180 | .thaw = smsg_pm_restore_thaw, |
| 181 | .restore = smsg_pm_restore_thaw, |
| 182 | }; |
| 183 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 184 | static struct device_driver smsg_driver = { |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 185 | .owner = THIS_MODULE, |
Hendrik Brueckner | 1ffaa64 | 2010-03-08 12:26:26 +0100 | [diff] [blame] | 186 | .name = SMSGIUCV_DRV_NAME, |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 187 | .bus = &iucv_bus, |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 188 | .pm = &smsg_pm_ops, |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 189 | }; |
| 190 | |
| 191 | static void __exit smsg_exit(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | { |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 193 | cpcmd("SET SMSG IUCV", NULL, 0, NULL); |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 194 | device_unregister(smsg_dev); |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 195 | iucv_unregister(&smsg_handler, 1); |
| 196 | driver_unregister(&smsg_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | } |
| 198 | |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 199 | static int __init smsg_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | int rc; |
| 202 | |
Christian Borntraeger | 0fc3ddd | 2007-11-05 11:10:08 +0100 | [diff] [blame] | 203 | if (!MACHINE_IS_VM) { |
| 204 | rc = -EPROTONOSUPPORT; |
| 205 | goto out; |
| 206 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | rc = driver_register(&smsg_driver); |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 208 | if (rc != 0) |
| 209 | goto out; |
| 210 | rc = iucv_register(&smsg_handler, 1); |
Martin Schwidefsky | d5ddc80 | 2008-07-14 09:59:33 +0200 | [diff] [blame] | 211 | if (rc) |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 212 | goto out_driver; |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 213 | smsg_path = iucv_path_alloc(255, 0, GFP_KERNEL); |
| 214 | if (!smsg_path) { |
| 215 | rc = -ENOMEM; |
| 216 | goto out_register; |
| 217 | } |
| 218 | rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ", |
| 219 | NULL, NULL, NULL); |
Martin Schwidefsky | d5ddc80 | 2008-07-14 09:59:33 +0200 | [diff] [blame] | 220 | if (rc) |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 221 | goto out_free_path; |
Ursula Braun | 59b60e9 | 2010-06-21 22:57:02 +0000 | [diff] [blame] | 222 | else |
| 223 | iucv_path_connected = 1; |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 224 | smsg_dev = kzalloc(sizeof(struct device), GFP_KERNEL); |
| 225 | if (!smsg_dev) { |
| 226 | rc = -ENOMEM; |
| 227 | goto out_free_path; |
| 228 | } |
| 229 | dev_set_name(smsg_dev, "smsg_iucv"); |
| 230 | smsg_dev->bus = &iucv_bus; |
| 231 | smsg_dev->parent = iucv_root; |
| 232 | smsg_dev->release = (void (*)(struct device *))kfree; |
| 233 | smsg_dev->driver = &smsg_driver; |
| 234 | rc = device_register(smsg_dev); |
| 235 | if (rc) |
Sebastian Ott | c630493 | 2009-09-11 10:28:38 +0200 | [diff] [blame] | 236 | goto out_put; |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 237 | |
Christian Borntraeger | 6b979de | 2005-06-25 14:55:32 -0700 | [diff] [blame] | 238 | cpcmd("SET SMSG IUCV", NULL, 0, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | return 0; |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 240 | |
Sebastian Ott | c630493 | 2009-09-11 10:28:38 +0200 | [diff] [blame] | 241 | out_put: |
| 242 | put_device(smsg_dev); |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 243 | out_free_path: |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 244 | iucv_path_free(smsg_path); |
Martin Schwidefsky | 6a1d96d | 2009-06-16 10:30:46 +0200 | [diff] [blame] | 245 | smsg_path = NULL; |
Martin Schwidefsky | 5da5e65 | 2007-02-08 13:51:11 -0800 | [diff] [blame] | 246 | out_register: |
| 247 | iucv_unregister(&smsg_handler, 1); |
| 248 | out_driver: |
| 249 | driver_unregister(&smsg_driver); |
| 250 | out: |
| 251 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | module_init(smsg_init); |
| 255 | module_exit(smsg_exit); |
| 256 | MODULE_LICENSE("GPL"); |
| 257 | |
| 258 | EXPORT_SYMBOL(smsg_register_callback); |
| 259 | EXPORT_SYMBOL(smsg_unregister_callback); |