Merge branches 'topic/fix/hda' and 'topic/fix/sound-core' into for-linus
[linux-2.6] / drivers / s390 / scsi / zfcp_cfdc.c
1 /*
2  * zfcp device driver
3  *
4  * Userspace interface for accessing the
5  * Access Control Lists / Control File Data Channel
6  *
7  * Copyright IBM Corporation 2008
8  */
9
10 #include <linux/types.h>
11 #include <linux/miscdevice.h>
12 #include <asm/ccwdev.h>
13 #include "zfcp_def.h"
14 #include "zfcp_ext.h"
15 #include "zfcp_fsf.h"
16
17 #define ZFCP_CFDC_CMND_DOWNLOAD_NORMAL          0x00010001
18 #define ZFCP_CFDC_CMND_DOWNLOAD_FORCE           0x00010101
19 #define ZFCP_CFDC_CMND_FULL_ACCESS              0x00000201
20 #define ZFCP_CFDC_CMND_RESTRICTED_ACCESS        0x00000401
21 #define ZFCP_CFDC_CMND_UPLOAD                   0x00010002
22
23 #define ZFCP_CFDC_DOWNLOAD                      0x00000001
24 #define ZFCP_CFDC_UPLOAD                        0x00000002
25 #define ZFCP_CFDC_WITH_CONTROL_FILE             0x00010000
26
27 #define ZFCP_CFDC_IOC_MAGIC                     0xDD
28 #define ZFCP_CFDC_IOC \
29         _IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_data)
30
31 /**
32  * struct zfcp_cfdc_data - data for ioctl cfdc interface
33  * @signature: request signature
34  * @devno: FCP adapter device number
35  * @command: command code
36  * @fsf_status: returns status of FSF command to userspace
37  * @fsf_status_qual: returned to userspace
38  * @payloads: access conflicts list
39  * @control_file: access control table
40  */
41 struct zfcp_cfdc_data {
42         u32 signature;
43         u32 devno;
44         u32 command;
45         u32 fsf_status;
46         u8  fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
47         u8  payloads[256];
48         u8  control_file[0];
49 };
50
51 static int zfcp_cfdc_copy_from_user(struct scatterlist *sg,
52                                     void __user *user_buffer)
53 {
54         unsigned int length;
55         unsigned int size = ZFCP_CFDC_MAX_SIZE;
56
57         while (size) {
58                 length = min((unsigned int)size, sg->length);
59                 if (copy_from_user(sg_virt(sg++), user_buffer, length))
60                         return -EFAULT;
61                 user_buffer += length;
62                 size -= length;
63         }
64         return 0;
65 }
66
67 static int zfcp_cfdc_copy_to_user(void __user  *user_buffer,
68                                   struct scatterlist *sg)
69 {
70         unsigned int length;
71         unsigned int size = ZFCP_CFDC_MAX_SIZE;
72
73         while (size) {
74                 length = min((unsigned int) size, sg->length);
75                 if (copy_to_user(user_buffer, sg_virt(sg++), length))
76                         return -EFAULT;
77                 user_buffer += length;
78                 size -= length;
79         }
80         return 0;
81 }
82
83 static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno)
84 {
85         struct zfcp_adapter *adapter = NULL, *cur_adapter;
86         struct ccw_dev_id dev_id;
87
88         read_lock_irq(&zfcp_data.config_lock);
89         list_for_each_entry(cur_adapter, &zfcp_data.adapter_list_head, list) {
90                 ccw_device_get_id(cur_adapter->ccw_device, &dev_id);
91                 if (dev_id.devno == devno) {
92                         adapter = cur_adapter;
93                         zfcp_adapter_get(adapter);
94                         break;
95                 }
96         }
97         read_unlock_irq(&zfcp_data.config_lock);
98         return adapter;
99 }
100
101 static int zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc *fsf_cfdc, int command)
102 {
103         switch (command) {
104         case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL:
105                 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
106                 fsf_cfdc->option = FSF_CFDC_OPTION_NORMAL_MODE;
107                 break;
108         case ZFCP_CFDC_CMND_DOWNLOAD_FORCE:
109                 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
110                 fsf_cfdc->option = FSF_CFDC_OPTION_FORCE;
111                 break;
112         case ZFCP_CFDC_CMND_FULL_ACCESS:
113                 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
114                 fsf_cfdc->option = FSF_CFDC_OPTION_FULL_ACCESS;
115                 break;
116         case ZFCP_CFDC_CMND_RESTRICTED_ACCESS:
117                 fsf_cfdc->command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
118                 fsf_cfdc->option = FSF_CFDC_OPTION_RESTRICTED_ACCESS;
119                 break;
120         case ZFCP_CFDC_CMND_UPLOAD:
121                 fsf_cfdc->command = FSF_QTCB_UPLOAD_CONTROL_FILE;
122                 fsf_cfdc->option = 0;
123                 break;
124         default:
125                 return -EINVAL;
126         }
127
128         return 0;
129 }
130
131 static int zfcp_cfdc_sg_setup(int command, struct scatterlist *sg,
132                               u8 __user *control_file)
133 {
134         int retval;
135         retval = zfcp_sg_setup_table(sg, ZFCP_CFDC_PAGES);
136         if (retval)
137                 return retval;
138
139         sg[ZFCP_CFDC_PAGES - 1].length = ZFCP_CFDC_MAX_SIZE % PAGE_SIZE;
140
141         if (command & ZFCP_CFDC_WITH_CONTROL_FILE &&
142             command & ZFCP_CFDC_DOWNLOAD) {
143                 retval = zfcp_cfdc_copy_from_user(sg, control_file);
144                 if (retval) {
145                         zfcp_sg_free_table(sg, ZFCP_CFDC_PAGES);
146                         return -EFAULT;
147                 }
148         }
149
150         return 0;
151 }
152
153 static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data,
154                                    struct zfcp_fsf_req *req)
155 {
156         data->fsf_status = req->qtcb->header.fsf_status;
157         memcpy(&data->fsf_status_qual, &req->qtcb->header.fsf_status_qual,
158                sizeof(union fsf_status_qual));
159         memcpy(&data->payloads, &req->qtcb->bottom.support.els,
160                sizeof(req->qtcb->bottom.support.els));
161 }
162
163 static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
164                                 unsigned long buffer)
165 {
166         struct zfcp_cfdc_data *data;
167         struct zfcp_cfdc_data __user *data_user;
168         struct zfcp_adapter *adapter;
169         struct zfcp_fsf_req *req;
170         struct zfcp_fsf_cfdc *fsf_cfdc;
171         int retval;
172
173         if (command != ZFCP_CFDC_IOC)
174                 return -ENOTTY;
175
176         data_user = (void __user *) buffer;
177         if (!data_user)
178                 return -EINVAL;
179
180         fsf_cfdc = kmalloc(sizeof(struct zfcp_fsf_cfdc), GFP_KERNEL);
181         if (!fsf_cfdc)
182                 return -ENOMEM;
183
184         data = kmalloc(sizeof(struct zfcp_cfdc_data), GFP_KERNEL);
185         if (!data) {
186                 retval = -ENOMEM;
187                 goto no_mem_sense;
188         }
189
190         retval = copy_from_user(data, data_user, sizeof(*data));
191         if (retval) {
192                 retval = -EFAULT;
193                 goto free_buffer;
194         }
195
196         if (data->signature != 0xCFDCACDF) {
197                 retval = -EINVAL;
198                 goto free_buffer;
199         }
200
201         retval = zfcp_cfdc_set_fsf(fsf_cfdc, data->command);
202
203         adapter = zfcp_cfdc_get_adapter(data->devno);
204         if (!adapter) {
205                 retval = -ENXIO;
206                 goto free_buffer;
207         }
208
209         retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
210                                     data_user->control_file);
211         if (retval)
212                 goto adapter_put;
213         req = zfcp_fsf_control_file(adapter, fsf_cfdc);
214         if (IS_ERR(req)) {
215                 retval = PTR_ERR(req);
216                 goto free_sg;
217         }
218
219         if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
220                 retval = -ENXIO;
221                 goto free_fsf;
222         }
223
224         zfcp_cfdc_req_to_sense(data, req);
225         retval = copy_to_user(data_user, data, sizeof(*data_user));
226         if (retval) {
227                 retval = -EFAULT;
228                 goto free_fsf;
229         }
230
231         if (data->command & ZFCP_CFDC_UPLOAD)
232                 retval = zfcp_cfdc_copy_to_user(&data_user->control_file,
233                                                 fsf_cfdc->sg);
234
235  free_fsf:
236         zfcp_fsf_req_free(req);
237  free_sg:
238         zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
239  adapter_put:
240         zfcp_adapter_put(adapter);
241  free_buffer:
242         kfree(data);
243  no_mem_sense:
244         kfree(fsf_cfdc);
245         return retval;
246 }
247
248 static const struct file_operations zfcp_cfdc_fops = {
249         .unlocked_ioctl = zfcp_cfdc_dev_ioctl,
250 #ifdef CONFIG_COMPAT
251         .compat_ioctl = zfcp_cfdc_dev_ioctl
252 #endif
253 };
254
255 struct miscdevice zfcp_cfdc_misc = {
256         .minor = MISC_DYNAMIC_MINOR,
257         .name = "zfcp_cfdc",
258         .fops = &zfcp_cfdc_fops,
259 };