Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

Conflicts:

	drivers/pcmcia/ds.c

Fix up merge failures with Linus's head and fix new compile failures.

Signed-Off-By: David Howells <dhowells@redhat.com>

1 files changed, 352 insertions, 0 deletions

diff --git a/drivers/scsi/scsi_tgt_if.c b/drivers/scsi/scsi_tgt_if.c
new file mode 100644
index 000000000000..37bbfbdb870f
--- /dev/null
+++ b/drivers/scsi/scsi_tgt_if.c
@@ -0,0 +1,352 @@
+/*
+ * SCSI target kernel/user interface functions
+ *
+ * Copyright (C) 2005 FUJITA Tomonori <tomof@acm.org>
+ * Copyright (C) 2005 Mike Christie <michaelc@cs.wisc.edu>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+#include <linux/miscdevice.h>
+#include <linux/file.h>
+#include <net/tcp.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_tgt.h>
+#include <scsi/scsi_tgt_if.h>
+
+#include <asm/cacheflush.h>
+
+#include "scsi_tgt_priv.h"
+
+struct tgt_ring {
+        u32 tr_idx;
+        unsigned long tr_pages[TGT_RING_PAGES];
+        spinlock_t tr_lock;
+};
+
+/* tx_ring : kernel->user, rx_ring : user->kernel */
+static struct tgt_ring tx_ring, rx_ring;
+static DECLARE_WAIT_QUEUE_HEAD(tgt_poll_wait);
+
+static inline void tgt_ring_idx_inc(struct tgt_ring *ring)
+{
+        if (ring->tr_idx == TGT_MAX_EVENTS - 1)
+                ring->tr_idx = 0;
+        else
+                ring->tr_idx++;
+}
+
+static struct tgt_event *tgt_head_event(struct tgt_ring *ring, u32 idx)
+{
+        u32 pidx, off;
+
+        pidx = idx / TGT_EVENT_PER_PAGE;
+        off = idx % TGT_EVENT_PER_PAGE;
+
+        return (struct tgt_event *)
+                (ring->tr_pages[pidx] + sizeof(struct tgt_event) * off);
+}
+
+static int tgt_uspace_send_event(u32 type, struct tgt_event *p)
+{
+        struct tgt_event *ev;
+        struct tgt_ring *ring = &tx_ring;
+        unsigned long flags;
+        int err = 0;
+
+        spin_lock_irqsave(&ring->tr_lock, flags);
+
+        ev = tgt_head_event(ring, ring->tr_idx);
+        if (!ev->hdr.status)
+                tgt_ring_idx_inc(ring);
+        else
+                err = -BUSY;
+
+        spin_unlock_irqrestore(&ring->tr_lock, flags);
+
+        if (err)
+                return err;
+
+        memcpy(ev, p, sizeof(*ev));
+        ev->hdr.type = type;
+        mb();
+        ev->hdr.status = 1;
+
+        flush_dcache_page(virt_to_page(ev));
+
+        wake_up_interruptible(&tgt_poll_wait);
+
+        return 0;
+}
+
+int scsi_tgt_uspace_send_cmd(struct scsi_cmnd *cmd, struct scsi_lun *lun, u64 tag)
+{
+        struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
+        struct tgt_event ev;
+        int err;
+
+        memset(&ev, 0, sizeof(ev));
+        ev.p.cmd_req.host_no = shost->host_no;
+        ev.p.cmd_req.data_len = cmd->request_bufflen;
+        memcpy(ev.p.cmd_req.scb, cmd->cmnd, sizeof(ev.p.cmd_req.scb));
+        memcpy(ev.p.cmd_req.lun, lun, sizeof(ev.p.cmd_req.lun));
+        ev.p.cmd_req.attribute = cmd->tag;
+        ev.p.cmd_req.tag = tag;
+
+        dprintk("%p %d %u %x %llx\n", cmd, shost->host_no,
+                ev.p.cmd_req.data_len, cmd->tag,
+                (unsigned long long) ev.p.cmd_req.tag);
+
+        err = tgt_uspace_send_event(TGT_KEVENT_CMD_REQ, &ev);
+        if (err)
+                eprintk("tx buf is full, could not send\n");
+
+        return err;
+}
+
+int scsi_tgt_uspace_send_status(struct scsi_cmnd *cmd, u64 tag)
+{
+        struct Scsi_Host *shost = scsi_tgt_cmd_to_host(cmd);
+        struct tgt_event ev;
+        int err;
+
+        memset(&ev, 0, sizeof(ev));
+        ev.p.cmd_done.host_no = shost->host_no;
+        ev.p.cmd_done.tag = tag;
+        ev.p.cmd_done.result = cmd->result;
+
+        dprintk("%p %d %llu %u %x\n", cmd, shost->host_no,
+                (unsigned long long) ev.p.cmd_req.tag,
+                ev.p.cmd_req.data_len, cmd->tag);
+
+        err = tgt_uspace_send_event(TGT_KEVENT_CMD_DONE, &ev);
+        if (err)
+                eprintk("tx buf is full, could not send\n");
+
+        return err;
+}
+
+int scsi_tgt_uspace_send_tsk_mgmt(int host_no, int function, u64 tag,
+                                  struct scsi_lun *scsilun, void *data)
+{
+        struct tgt_event ev;
+        int err;
+
+        memset(&ev, 0, sizeof(ev));
+        ev.p.tsk_mgmt_req.host_no = host_no;
+        ev.p.tsk_mgmt_req.function = function;
+        ev.p.tsk_mgmt_req.tag = tag;
+        memcpy(ev.p.tsk_mgmt_req.lun, scsilun, sizeof(ev.p.tsk_mgmt_req.lun));
+        ev.p.tsk_mgmt_req.mid = (u64) (unsigned long) data;
+
+        dprintk("%d %x %llx %llx\n", host_no, function, (unsigned long long) tag,
+                (unsigned long long) ev.p.tsk_mgmt_req.mid);
+
+        err = tgt_uspace_send_event(TGT_KEVENT_TSK_MGMT_REQ, &ev);
+        if (err)
+                eprintk("tx buf is full, could not send\n");
+
+        return err;
+}
+
+static int event_recv_msg(struct tgt_event *ev)
+{
+        int err = 0;
+
+        switch (ev->hdr.type) {
+        case TGT_UEVENT_CMD_RSP:
+                err = scsi_tgt_kspace_exec(ev->p.cmd_rsp.host_no,
+                                           ev->p.cmd_rsp.tag,
+                                           ev->p.cmd_rsp.result,
+                                           ev->p.cmd_rsp.len,
+                                           ev->p.cmd_rsp.uaddr,
+                                           ev->p.cmd_rsp.rw);
+                break;
+        case TGT_UEVENT_TSK_MGMT_RSP:
+                err = scsi_tgt_kspace_tsk_mgmt(ev->p.tsk_mgmt_rsp.host_no,
+                                               ev->p.tsk_mgmt_rsp.mid,
+                                               ev->p.tsk_mgmt_rsp.result);
+                break;
+        default:
+                eprintk("unknown type %d\n", ev->hdr.type);
+                err = -EINVAL;
+        }
+
+        return err;
+}
+
+static ssize_t tgt_write(struct file *file, const char __user * buffer,
+                         size_t count, loff_t * ppos)
+{
+        struct tgt_event *ev;
+        struct tgt_ring *ring = &rx_ring;
+
+        while (1) {
+                ev = tgt_head_event(ring, ring->tr_idx);
+                /* do we need this? */
+                flush_dcache_page(virt_to_page(ev));
+
+                if (!ev->hdr.status)
+                        break;
+
+                tgt_ring_idx_inc(ring);
+                event_recv_msg(ev);
+                ev->hdr.status = 0;
+        };
+
+        return count;
+}
+
+static unsigned int tgt_poll(struct file * file, struct poll_table_struct *wait)
+{
+        struct tgt_event *ev;
+        struct tgt_ring *ring = &tx_ring;
+        unsigned long flags;
+        unsigned int mask = 0;
+        u32 idx;
+
+        poll_wait(file, &tgt_poll_wait, wait);
+
+        spin_lock_irqsave(&ring->tr_lock, flags);
+
+        idx = ring->tr_idx ? ring->tr_idx - 1 : TGT_MAX_EVENTS - 1;
+        ev = tgt_head_event(ring, idx);
+        if (ev->hdr.status)
+                mask |= POLLIN | POLLRDNORM;
+
+        spin_unlock_irqrestore(&ring->tr_lock, flags);
+
+        return mask;
+}
+
+static int uspace_ring_map(struct vm_area_struct *vma, unsigned long addr,
+                           struct tgt_ring *ring)
+{
+        int i, err;
+
+        for (i = 0; i < TGT_RING_PAGES; i++) {
+                struct page *page = virt_to_page(ring->tr_pages[i]);
+                err = vm_insert_page(vma, addr, page);
+                if (err)
+                        return err;
+                addr += PAGE_SIZE;
+        }
+
+        return 0;
+}
+
+static int tgt_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+        unsigned long addr;
+        int err;
+
+        if (vma->vm_pgoff)
+                return -EINVAL;
+
+        if (vma->vm_end - vma->vm_start != TGT_RING_SIZE * 2) {
+                eprintk("mmap size must be %lu, not %lu \n",
+                        TGT_RING_SIZE * 2, vma->vm_end - vma->vm_start);
+                return -EINVAL;
+        }
+
+        addr = vma->vm_start;
+        err = uspace_ring_map(vma, addr, &tx_ring);
+        if (err)
+                return err;
+        err = uspace_ring_map(vma, addr + TGT_RING_SIZE, &rx_ring);
+
+        return err;
+}
+
+static int tgt_open(struct inode *inode, struct file *file)
+{
+        tx_ring.tr_idx = rx_ring.tr_idx = 0;
+
+        return 0;
+}
+
+static struct file_operations tgt_fops = {
+        .owner          = THIS_MODULE,
+        .open           = tgt_open,
+        .poll           = tgt_poll,
+        .write          = tgt_write,
+        .mmap           = tgt_mmap,
+};
+
+static struct miscdevice tgt_miscdev = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = "tgt",
+        .fops = &tgt_fops,
+};
+
+static void tgt_ring_exit(struct tgt_ring *ring)
+{
+        int i;
+
+        for (i = 0; i < TGT_RING_PAGES; i++)
+                free_page(ring->tr_pages[i]);
+}
+
+static int tgt_ring_init(struct tgt_ring *ring)
+{
+        int i;
+
+        spin_lock_init(&ring->tr_lock);
+
+        for (i = 0; i < TGT_RING_PAGES; i++) {
+                ring->tr_pages[i] = get_zeroed_page(GFP_KERNEL);
+                if (!ring->tr_pages[i]) {
+                        eprintk("out of memory\n");
+                        return -ENOMEM;
+                }
+        }
+
+        return 0;
+}
+
+void scsi_tgt_if_exit(void)
+{
+        tgt_ring_exit(&tx_ring);
+        tgt_ring_exit(&rx_ring);
+        misc_deregister(&tgt_miscdev);
+}
+
+int scsi_tgt_if_init(void)
+{
+        int err;
+
+        err = tgt_ring_init(&tx_ring);
+        if (err)
+                return err;
+
+        err = tgt_ring_init(&rx_ring);
+        if (err)
+                goto free_tx_ring;
+
+        err = misc_register(&tgt_miscdev);
+        if (err)
+                goto free_rx_ring;
+
+        return 0;
+free_rx_ring:
+        tgt_ring_exit(&rx_ring);
+free_tx_ring:
+        tgt_ring_exit(&tx_ring);
+
+        return err;
+}