PM: Remove CONFIG_PM_OPS
[linux-2.6.git] / drivers / scsi / scsi_tgt_if.c
1 /*
2  * SCSI target kernel/user interface functions
3  *
4  * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org>
5  * Copyright (C) 2005 Mike Christie <michaelc@cs.wisc.edu>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2 of the
10  * License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  */
22 #include <linux/miscdevice.h>
23 #include <linux/gfp.h>
24 #include <linux/file.h>
25 #include <net/tcp.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_cmnd.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_host.h>
30 #include <scsi/scsi_tgt.h>
31 #include <scsi/scsi_tgt_if.h>
32
33 #include <asm/cacheflush.h>
34
35 #include "scsi_tgt_priv.h"
36
37 #if TGT_RING_SIZE < PAGE_SIZE
38 #  define TGT_RING_SIZE PAGE_SIZE
39 #endif
40
41 #define TGT_RING_PAGES (TGT_RING_SIZE >> PAGE_SHIFT)
42 #define TGT_EVENT_PER_PAGE (PAGE_SIZE / sizeof(struct tgt_event))
43 #define TGT_MAX_EVENTS (TGT_EVENT_PER_PAGE * TGT_RING_PAGES)
44
45 struct tgt_ring {
46         u32 tr_idx;
47         unsigned long tr_pages[TGT_RING_PAGES];
48         spinlock_t tr_lock;
49 };
50
51 /* tx_ring : kernel->user, rx_ring : user->kernel */
52 static struct tgt_ring tx_ring, rx_ring;
53 static DECLARE_WAIT_QUEUE_HEAD(tgt_poll_wait);
54
55 static inline void tgt_ring_idx_inc(struct tgt_ring *ring)
56 {
57         if (ring->tr_idx == TGT_MAX_EVENTS - 1)
58                 ring->tr_idx = 0;
59         else
60                 ring->tr_idx++;
61 }
62
63 static struct tgt_event *tgt_head_event(struct tgt_ring *ring, u32 idx)
64 {
65         u32 pidx, off;
66
67         pidx = idx / TGT_EVENT_PER_PAGE;
68         off = idx % TGT_EVENT_PER_PAGE;
69
70         return (struct tgt_event *)
71                 (ring->tr_pages[pidx] + sizeof(struct tgt_event) * off);
72 }
73
74 static int tgt_uspace_send_event(u32 type, struct tgt_event *p)
75 {
76         struct tgt_event *ev;
77         struct tgt_ring *ring = &tx_ring;
78         unsigned long flags;
79         int err = 0;
80
81         spin_lock_irqsave(&ring->tr_lock, flags);
82
83         ev = tgt_head_event(ring, ring->tr_idx);
84         if (!ev->hdr.status)
85                 tgt_ring_idx_inc(ring);
86         else
87                 err = -BUSY;
88
89         spin_unlock_irqrestore(&ring->tr_lock, flags);
90
91         if (err)
92                 return err;
93
94         memcpy(ev, p, sizeof(*ev));
95         ev->hdr.type = type;
96         mb();
97         ev->hdr.status = 1;
98
99         flush_dcache_page(virt_to_page(ev));
100
101         wake_up_interruptible(&tgt_poll_wait);
102
103         return 0;
104 }
105
106 int scsi_tgt_uspace_send_cmd(struct scsi_cmnd *cmd, u64 itn_id,
107                              struct scsi_lun *lun, u64 tag)
108 {
109         struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
110         struct tgt_event ev;
111         int err;
112
113         memset(&ev, 0, sizeof(ev));
114         ev.p.cmd_req.host_no = shost->host_no;
115         ev.p.cmd_req.itn_id = itn_id;
116         ev.p.cmd_req.data_len = scsi_bufflen(cmd);
117         memcpy(ev.p.cmd_req.scb, cmd->cmnd, sizeof(ev.p.cmd_req.scb));
118         memcpy(ev.p.cmd_req.lun, lun, sizeof(ev.p.cmd_req.lun));
119         ev.p.cmd_req.attribute = cmd->tag;
120         ev.p.cmd_req.tag = tag;
121
122         dprintk("%p %d %u %x %llx\n", cmd, shost->host_no,
123                 ev.p.cmd_req.data_len, cmd->tag,
124                 (unsigned long long) ev.p.cmd_req.tag);
125
126         err = tgt_uspace_send_event(TGT_KEVENT_CMD_REQ, &ev);
127         if (err)
128                 eprintk("tx buf is full, could not send\n");
129
130         return err;
131 }
132
133 int scsi_tgt_uspace_send_status(struct scsi_cmnd *cmd, u64 itn_id, u64 tag)
134 {
135         struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
136         struct tgt_event ev;
137         int err;
138
139         memset(&ev, 0, sizeof(ev));
140         ev.p.cmd_done.host_no = shost->host_no;
141         ev.p.cmd_done.itn_id = itn_id;
142         ev.p.cmd_done.tag = tag;
143         ev.p.cmd_done.result = cmd->result;
144
145         dprintk("%p %d %llu %u %x\n", cmd, shost->host_no,
146                 (unsigned long long) ev.p.cmd_req.tag,
147                 ev.p.cmd_req.data_len, cmd->tag);
148
149         err = tgt_uspace_send_event(TGT_KEVENT_CMD_DONE, &ev);
150         if (err)
151                 eprintk("tx buf is full, could not send\n");
152
153         return err;
154 }
155
156 int scsi_tgt_uspace_send_tsk_mgmt(int host_no, u64 itn_id, int function,
157                                   u64 tag, struct scsi_lun *scsilun, void *data)
158 {
159         struct tgt_event ev;
160         int err;
161
162         memset(&ev, 0, sizeof(ev));
163         ev.p.tsk_mgmt_req.host_no = host_no;
164         ev.p.tsk_mgmt_req.itn_id = itn_id;
165         ev.p.tsk_mgmt_req.function = function;
166         ev.p.tsk_mgmt_req.tag = tag;
167         memcpy(ev.p.tsk_mgmt_req.lun, scsilun, sizeof(ev.p.tsk_mgmt_req.lun));
168         ev.p.tsk_mgmt_req.mid = (u64) (unsigned long) data;
169
170         dprintk("%d %x %llx %llx\n", host_no, function, (unsigned long long) tag,
171                 (unsigned long long) ev.p.tsk_mgmt_req.mid);
172
173         err = tgt_uspace_send_event(TGT_KEVENT_TSK_MGMT_REQ, &ev);
174         if (err)
175                 eprintk("tx buf is full, could not send\n");
176
177         return err;
178 }
179
180 int scsi_tgt_uspace_send_it_nexus_request(int host_no, u64 itn_id,
181                                           int function, char *initiator_id)
182 {
183         struct tgt_event ev;
184         int err;
185
186         memset(&ev, 0, sizeof(ev));
187         ev.p.it_nexus_req.host_no = host_no;
188         ev.p.it_nexus_req.function = function;
189         ev.p.it_nexus_req.itn_id = itn_id;
190         if (initiator_id)
191                 strncpy(ev.p.it_nexus_req.initiator_id, initiator_id,
192                         sizeof(ev.p.it_nexus_req.initiator_id));
193
194         dprintk("%d %x %llx\n", host_no, function, (unsigned long long)itn_id);
195
196         err = tgt_uspace_send_event(TGT_KEVENT_IT_NEXUS_REQ, &ev);
197         if (err)
198                 eprintk("tx buf is full, could not send\n");
199
200         return err;
201 }
202
203 static int event_recv_msg(struct tgt_event *ev)
204 {
205         int err = 0;
206
207         switch (ev->hdr.type) {
208         case TGT_UEVENT_CMD_RSP:
209                 err = scsi_tgt_kspace_exec(ev->p.cmd_rsp.host_no,
210                                            ev->p.cmd_rsp.itn_id,
211                                            ev->p.cmd_rsp.result,
212                                            ev->p.cmd_rsp.tag,
213                                            ev->p.cmd_rsp.uaddr,
214                                            ev->p.cmd_rsp.len,
215                                            ev->p.cmd_rsp.sense_uaddr,
216                                            ev->p.cmd_rsp.sense_len,
217                                            ev->p.cmd_rsp.rw);
218                 break;
219         case TGT_UEVENT_TSK_MGMT_RSP:
220                 err = scsi_tgt_kspace_tsk_mgmt(ev->p.tsk_mgmt_rsp.host_no,
221                                                ev->p.tsk_mgmt_rsp.itn_id,
222                                                ev->p.tsk_mgmt_rsp.mid,
223                                                ev->p.tsk_mgmt_rsp.result);
224                 break;
225         case TGT_UEVENT_IT_NEXUS_RSP:
226                 err = scsi_tgt_kspace_it_nexus_rsp(ev->p.it_nexus_rsp.host_no,
227                                                    ev->p.it_nexus_rsp.itn_id,
228                                                    ev->p.it_nexus_rsp.result);
229                 break;
230         default:
231                 eprintk("unknown type %d\n", ev->hdr.type);
232                 err = -EINVAL;
233         }
234
235         return err;
236 }
237
238 static ssize_t tgt_write(struct file *file, const char __user * buffer,
239                          size_t count, loff_t * ppos)
240 {
241         struct tgt_event *ev;
242         struct tgt_ring *ring = &rx_ring;
243
244         while (1) {
245                 ev = tgt_head_event(ring, ring->tr_idx);
246                 /* do we need this? */
247                 flush_dcache_page(virt_to_page(ev));
248
249                 if (!ev->hdr.status)
250                         break;
251
252                 tgt_ring_idx_inc(ring);
253                 event_recv_msg(ev);
254                 ev->hdr.status = 0;
255         };
256
257         return count;
258 }
259
260 static unsigned int tgt_poll(struct file * file, struct poll_table_struct *wait)
261 {
262         struct tgt_event *ev;
263         struct tgt_ring *ring = &tx_ring;
264         unsigned long flags;
265         unsigned int mask = 0;
266         u32 idx;
267
268         poll_wait(file, &tgt_poll_wait, wait);
269
270         spin_lock_irqsave(&ring->tr_lock, flags);
271
272         idx = ring->tr_idx ? ring->tr_idx - 1 : TGT_MAX_EVENTS - 1;
273         ev = tgt_head_event(ring, idx);
274         if (ev->hdr.status)
275                 mask |= POLLIN | POLLRDNORM;
276
277         spin_unlock_irqrestore(&ring->tr_lock, flags);
278
279         return mask;
280 }
281
282 static int uspace_ring_map(struct vm_area_struct *vma, unsigned long addr,
283                            struct tgt_ring *ring)
284 {
285         int i, err;
286
287         for (i = 0; i < TGT_RING_PAGES; i++) {
288                 struct page *page = virt_to_page(ring->tr_pages[i]);
289                 err = vm_insert_page(vma, addr, page);
290                 if (err)
291                         return err;
292                 addr += PAGE_SIZE;
293         }
294
295         return 0;
296 }
297
298 static int tgt_mmap(struct file *filp, struct vm_area_struct *vma)
299 {
300         unsigned long addr;
301         int err;
302
303         if (vma->vm_pgoff)
304                 return -EINVAL;
305
306         if (vma->vm_end - vma->vm_start != TGT_RING_SIZE * 2) {
307                 eprintk("mmap size must be %lu, not %lu \n",
308                         TGT_RING_SIZE * 2, vma->vm_end - vma->vm_start);
309                 return -EINVAL;
310         }
311
312         addr = vma->vm_start;
313         err = uspace_ring_map(vma, addr, &tx_ring);
314         if (err)
315                 return err;
316         err = uspace_ring_map(vma, addr + TGT_RING_SIZE, &rx_ring);
317
318         return err;
319 }
320
321 static int tgt_open(struct inode *inode, struct file *file)
322 {
323         tx_ring.tr_idx = rx_ring.tr_idx = 0;
324
325         return 0;
326 }
327
328 static const struct file_operations tgt_fops = {
329         .owner          = THIS_MODULE,
330         .open           = tgt_open,
331         .poll           = tgt_poll,
332         .write          = tgt_write,
333         .mmap           = tgt_mmap,
334         .llseek         = noop_llseek,
335 };
336
337 static struct miscdevice tgt_miscdev = {
338         .minor = MISC_DYNAMIC_MINOR,
339         .name = "tgt",
340         .fops = &tgt_fops,
341 };
342
343 static void tgt_ring_exit(struct tgt_ring *ring)
344 {
345         int i;
346
347         for (i = 0; i < TGT_RING_PAGES; i++)
348                 free_page(ring->tr_pages[i]);
349 }
350
351 static int tgt_ring_init(struct tgt_ring *ring)
352 {
353         int i;
354
355         spin_lock_init(&ring->tr_lock);
356
357         for (i = 0; i < TGT_RING_PAGES; i++) {
358                 ring->tr_pages[i] = get_zeroed_page(GFP_KERNEL);
359                 if (!ring->tr_pages[i]) {
360                         eprintk("out of memory\n");
361                         return -ENOMEM;
362                 }
363         }
364
365         return 0;
366 }
367
368 void scsi_tgt_if_exit(void)
369 {
370         tgt_ring_exit(&tx_ring);
371         tgt_ring_exit(&rx_ring);
372         misc_deregister(&tgt_miscdev);
373 }
374
375 int scsi_tgt_if_init(void)
376 {
377         int err;
378
379         err = tgt_ring_init(&tx_ring);
380         if (err)
381                 return err;
382
383         err = tgt_ring_init(&rx_ring);
384         if (err)
385                 goto free_tx_ring;
386
387         err = misc_register(&tgt_miscdev);
388         if (err)
389                 goto free_rx_ring;
390
391         return 0;
392 free_rx_ring:
393         tgt_ring_exit(&rx_ring);
394 free_tx_ring:
395         tgt_ring_exit(&tx_ring);
396
397         return err;
398 }