fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / drivers / s390 / char / con3215.c

diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 606f6ad..25b5d7a 100644 (file)
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -11,7 +11,6 @@
  *            Dan Morrison, IBM Corporation (dmorriso@cse.buffalo.edu)
  */
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kdev_t.h>
@@ -300,14 +299,14 @@ raw3215_timeout(unsigned long __data)
        struct raw3215_info *raw = (struct raw3215_info *) __data;
        unsigned long flags;
 
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        if (raw->flags & RAW3215_TIMER_RUNS) {
                del_timer(&raw->timer);
                raw->flags &= ~RAW3215_TIMER_RUNS;
                raw3215_mk_write_req(raw);
                raw3215_start_io(raw);
        }
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
 }
 
 /*
@@ -356,10 +355,10 @@ raw3215_tasklet(void *data)
        unsigned long flags;
 
        raw = (struct raw3215_info *) data;
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        raw3215_mk_write_req(raw);
        raw3215_try_io(raw);
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
        /* Check for pending message from raw3215_irq */
        if (raw->message != NULL) {
                printk(raw->message, raw->msg_dstat, raw->msg_cstat);
@@ -513,9 +512,9 @@ raw3215_make_room(struct raw3215_info *raw, unsigned int length)
                if (RAW3215_BUFFER_SIZE - raw->count >= length)
                        break;
                /* there might be another cpu waiting for the lock */
-               spin_unlock(raw->lock);
+               spin_unlock(get_ccwdev_lock(raw->cdev));
                udelay(100);
-               spin_lock(raw->lock);
+               spin_lock(get_ccwdev_lock(raw->cdev));
        }
 }
 
@@ -529,7 +528,7 @@ raw3215_write(struct raw3215_info *raw, const char *str, unsigned int length)
        int c, count;
 
        while (length > 0) {
-               spin_lock_irqsave(raw->lock, flags);
+               spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
                count = (length > RAW3215_BUFFER_SIZE) ?
                                             RAW3215_BUFFER_SIZE : length;
                length -= count;
@@ -556,7 +555,7 @@ raw3215_write(struct raw3215_info *raw, const char *str, unsigned int length)
                        /* start or queue request */
                        raw3215_try_io(raw);
                }
-               spin_unlock_irqrestore(raw->lock, flags);
+               spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
        }
 }
 
@@ -569,7 +568,7 @@ raw3215_putchar(struct raw3215_info *raw, unsigned char ch)
        unsigned long flags;
        unsigned int length, i;
 
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        if (ch == '\t') {
                length = TAB_STOP_SIZE - (raw->line_pos%TAB_STOP_SIZE);
                raw->line_pos += length;
@@ -593,7 +592,7 @@ raw3215_putchar(struct raw3215_info *raw, unsigned char ch)
                /* start or queue request */
                raw3215_try_io(raw);
        }
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
 }
 
 /*
@@ -605,13 +604,13 @@ raw3215_flush_buffer(struct raw3215_info *raw)
 {
        unsigned long flags;
 
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        if (raw->count > 0) {
                raw->flags |= RAW3215_FLUSHING;
                raw3215_try_io(raw);
                raw->flags &= ~RAW3215_FLUSHING;
        }
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
 }
 
 /*
@@ -626,9 +625,9 @@ raw3215_startup(struct raw3215_info *raw)
                return 0;
        raw->line_pos = 0;
        raw->flags |= RAW3215_ACTIVE;
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        raw3215_try_io(raw);
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
 
        return 0;
 }
@@ -645,21 +644,21 @@ raw3215_shutdown(struct raw3215_info *raw)
        if (!(raw->flags & RAW3215_ACTIVE) || (raw->flags & RAW3215_FIXED))
                return;
        /* Wait for outstanding requests, then free irq */
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        if ((raw->flags & RAW3215_WORKING) ||
            raw->queued_write != NULL ||
            raw->queued_read != NULL) {
                raw->flags |= RAW3215_CLOSING;
                add_wait_queue(&raw->empty_wait, &wait);
                set_current_state(TASK_INTERRUPTIBLE);
-               spin_unlock_irqrestore(raw->lock, flags);
+               spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
                schedule();
-               spin_lock_irqsave(raw->lock, flags);
+               spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
                remove_wait_queue(&raw->empty_wait, &wait);
                set_current_state(TASK_RUNNING);
                raw->flags &= ~(RAW3215_ACTIVE | RAW3215_CLOSING);
        }
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
 }
 
 static int
@@ -687,14 +686,13 @@ raw3215_probe (struct ccw_device *cdev)
        }
 
        raw->cdev = cdev;
-       raw->lock = get_ccwdev_lock(cdev);
        raw->inbuf = (char *) raw + sizeof(struct raw3215_info);
        memset(raw, 0, sizeof(struct raw3215_info));
-       raw->buffer = (char *) kmalloc(RAW3215_BUFFER_SIZE,
+       raw->buffer = kmalloc(RAW3215_BUFFER_SIZE,
                                       GFP_KERNEL|GFP_DMA);
        if (raw->buffer == NULL) {
                spin_lock(&raw3215_device_lock);
-               raw3215[line] = 0;
+               raw3215[line] = NULL;
                spin_unlock(&raw3215_device_lock);
                kfree(raw);
                return -ENOMEM;
@@ -810,9 +808,9 @@ con3215_unblank(void)
        unsigned long flags;
 
        raw = raw3215[0];  /* console 3215 is the first one */
-       spin_lock_irqsave(raw->lock, flags);
+       spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
        raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
-       spin_unlock_irqrestore(raw->lock, flags);
+       spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
 }
 
 static int __init 
@@ -874,7 +872,6 @@ con3215_init(void)
        raw->buffer = (char *) alloc_bootmem_low(RAW3215_BUFFER_SIZE);
        raw->inbuf = (char *) alloc_bootmem_low(RAW3215_INBUF_SIZE);
        raw->cdev = cdev;
-       raw->lock = get_ccwdev_lock(cdev);
        cdev->dev.driver_data = raw;
        cdev->handler = raw3215_irq;
 
@@ -1067,10 +1064,10 @@ tty3215_unthrottle(struct tty_struct * tty)
 
        raw = (struct raw3215_info *) tty->driver_data;
        if (raw->flags & RAW3215_THROTTLED) {
-               spin_lock_irqsave(raw->lock, flags);
+               spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
                raw->flags &= ~RAW3215_THROTTLED;
                raw3215_try_io(raw);
-               spin_unlock_irqrestore(raw->lock, flags);
+               spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
        }
 }
 
@@ -1097,14 +1094,14 @@ tty3215_start(struct tty_struct *tty)
 
        raw = (struct raw3215_info *) tty->driver_data;
        if (raw->flags & RAW3215_STOPPED) {
-               spin_lock_irqsave(raw->lock, flags);
+               spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
                raw->flags &= ~RAW3215_STOPPED;
                raw3215_try_io(raw);
-               spin_unlock_irqrestore(raw->lock, flags);
+               spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
        }
 }
 
-static struct tty_operations tty3215_ops = {
+static const struct tty_operations tty3215_ops = {
        .open = tty3215_open,
        .close = tty3215_close,
        .write = tty3215_write,