Merge branch 'linus' into timers/hpet

10 files changed, 199 insertions, 28 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 595a925c62a9..2d854bb9373e 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -118,8 +118,8 @@ config COMPUTONE
           order to become a dial-in server. If you have a card like that, say
           Y here and read <file:Documentation/computone.txt>.
 
-          To compile this driver as modules, choose M here: the
-          modules will be called ip2 and ip2main.
+          To compile this driver as module, choose M here: the
+          module will be called ip2.
 
 config ROCKETPORT
         tristate "Comtrol RocketPort support"
@@ -749,7 +749,7 @@ config NVRAM
 if RTC_LIB=n
 
 config RTC
-        tristate "Enhanced Real Time Clock Support"
+        tristate "Enhanced Real Time Clock Support (legacy PC RTC driver)"
         depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV \
                         && !ARM && !SUPERH && !S390 && !AVR32
         ---help---
@@ -1036,9 +1036,9 @@ config HPET
           non-periodic and/or periodic.
 
 config HPET_RTC_IRQ
-        bool "HPET Control RTC IRQ" if !HPET_EMULATE_RTC
-        default n
-        depends on HPET
+        bool
+        default HPET_EMULATE_RTC
+        depends on RTC && HPET
         help
           If you say Y here, you will disable RTC_IRQ in drivers/char/rtc.c. It
           is assumed the platform called hpet_alloc with the RTC IRQ values for
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index 55c97f623242..07b4d8ff56e5 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -458,6 +458,10 @@ static struct agp_device_ids ati_agp_device_ids[] __devinitdata =
                 .chipset_name   = "IGP9100/M",
         },
         {
+                .device_id      = PCI_DEVICE_ID_ATI_RS350_133,
+                .chipset_name   = "IGP9000/M",
+        },
+        {
                 .device_id      = PCI_DEVICE_ID_ATI_RS350_200,
                 .chipset_name   = "IGP9100/M",
         },
diff --git a/drivers/char/generic_nvram.c b/drivers/char/generic_nvram.c
index 2398e864c28d..a00869c650d5 100644
--- a/drivers/char/generic_nvram.c
+++ b/drivers/char/generic_nvram.c
@@ -133,7 +133,7 @@ static struct miscdevice nvram_dev = {
 
 int __init nvram_init(void)
 {
-        printk(KERN_INFO "Macintosh non-volatile memory driver v%s\n",
+        printk(KERN_INFO "Generic non-volatile memory driver v%s\n",
                 NVRAM_VERSION);
         return misc_register(&nvram_dev);
 }
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 8d6c2089d2a8..efd0b4db7c8e 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -112,3 +112,12 @@ config HW_RANDOM_PASEMI
 
           If unsure, say Y.
 
+config HW_RANDOM_VIRTIO
+        tristate "VirtIO Random Number Generator support"
+        depends on HW_RANDOM && VIRTIO
+        ---help---
+          This driver provides kernel-side support for the virtual Random Number
+          Generator hardware.
+
+          To compile this driver as a module, choose M here: the
+          module will be called virtio-rng.  If unsure, say N.
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index c8b7300e2fb1..b4940ddbb35f 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -11,3 +11,4 @@ obj-$(CONFIG_HW_RANDOM_VIA) += via-rng.o
 obj-$(CONFIG_HW_RANDOM_IXP4XX) += ixp4xx-rng.o
 obj-$(CONFIG_HW_RANDOM_OMAP) += omap-rng.o
 obj-$(CONFIG_HW_RANDOM_PASEMI) += pasemi-rng.o
+obj-$(CONFIG_HW_RANDOM_VIRTIO) += virtio-rng.o
diff --git a/drivers/char/hw_random/intel-rng.c b/drivers/char/hw_random/intel-rng.c
index 5cc651ef75eb..27fdc0866496 100644
--- a/drivers/char/hw_random/intel-rng.c
+++ b/drivers/char/hw_random/intel-rng.c
@@ -273,7 +273,7 @@ static int __init intel_rng_hw_init(void *_intel_rng_hw)
         if (mfc != INTEL_FWH_MANUFACTURER_CODE ||
             (dvc != INTEL_FWH_DEVICE_CODE_8M &&
              dvc != INTEL_FWH_DEVICE_CODE_4M)) {
-                printk(KERN_ERR PFX "FWH not detected\n");
+                printk(KERN_NOTICE PFX "FWH not detected\n");
                 return -ENODEV;
         }
 
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
new file mode 100644
index 000000000000..d0e563e4fc39
--- /dev/null
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -0,0 +1,155 @@
+/*
+ * Randomness driver for virtio
+ *  Copyright (C) 2007, 2008 Rusty Russell IBM Corporation
+ *
+ *  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/err.h>
+#include <linux/hw_random.h>
+#include <linux/scatterlist.h>
+#include <linux/spinlock.h>
+#include <linux/virtio.h>
+#include <linux/virtio_rng.h>
+
+/* The host will fill any buffer we give it with sweet, sweet randomness.  We
+ * give it 64 bytes at a time, and the hwrng framework takes it 4 bytes at a
+ * time. */
+#define RANDOM_DATA_SIZE 64
+
+static struct virtqueue *vq;
+static u32 *random_data;
+static unsigned int data_left;
+static DECLARE_COMPLETION(have_data);
+
+static void random_recv_done(struct virtqueue *vq)
+{
+        int len;
+
+        /* We never get spurious callbacks. */
+        if (!vq->vq_ops->get_buf(vq, &len))
+                BUG();
+
+        data_left = len / sizeof(random_data[0]);
+        complete(&have_data);
+}
+
+static void register_buffer(void)
+{
+        struct scatterlist sg;
+
+        sg_init_one(&sg, random_data, RANDOM_DATA_SIZE);
+        /* There should always be room for one buffer. */
+        if (vq->vq_ops->add_buf(vq, &sg, 0, 1, random_data) != 0)
+                BUG();
+        vq->vq_ops->kick(vq);
+}
+
+/* At least we don't udelay() in a loop like some other drivers. */
+static int virtio_data_present(struct hwrng *rng, int wait)
+{
+        if (data_left)
+                return 1;
+
+        if (!wait)
+                return 0;
+
+        wait_for_completion(&have_data);
+        return 1;
+}
+
+/* virtio_data_present() must have succeeded before this is called. */
+static int virtio_data_read(struct hwrng *rng, u32 *data)
+{
+        BUG_ON(!data_left);
+
+        *data = random_data[--data_left];
+
+        if (!data_left) {
+                init_completion(&have_data);
+                register_buffer();
+        }
+        return sizeof(*data);
+}
+
+static struct hwrng virtio_hwrng = {
+        .name = "virtio",
+        .data_present = virtio_data_present,
+        .data_read = virtio_data_read,
+};
+
+static int virtrng_probe(struct virtio_device *vdev)
+{
+        int err;
+
+        /* We expect a single virtqueue. */
+        vq = vdev->config->find_vq(vdev, 0, random_recv_done);
+        if (IS_ERR(vq))
+                return PTR_ERR(vq);
+
+        err = hwrng_register(&virtio_hwrng);
+        if (err) {
+                vdev->config->del_vq(vq);
+                return err;
+        }
+
+        register_buffer();
+        return 0;
+}
+
+static void virtrng_remove(struct virtio_device *vdev)
+{
+        vdev->config->reset(vdev);
+        hwrng_unregister(&virtio_hwrng);
+        vdev->config->del_vq(vq);
+}
+
+static struct virtio_device_id id_table[] = {
+        { VIRTIO_ID_RNG, VIRTIO_DEV_ANY_ID },
+        { 0 },
+};
+
+static struct virtio_driver virtio_rng = {
+        .driver.name =  KBUILD_MODNAME,
+        .driver.owner = THIS_MODULE,
+        .id_table =     id_table,
+        .probe =        virtrng_probe,
+        .remove =       __devexit_p(virtrng_remove),
+};
+
+static int __init init(void)
+{
+        int err;
+
+        random_data = kmalloc(RANDOM_DATA_SIZE, GFP_KERNEL);
+        if (!random_data)
+                return -ENOMEM;
+
+        err = register_virtio_driver(&virtio_rng);
+        if (err)
+                kfree(random_data);
+        return err;
+}
+
+static void __exit fini(void)
+{
+        kfree(random_data);
+        unregister_virtio_driver(&virtio_rng);
+}
+module_init(init);
+module_exit(fini);
+
+MODULE_DEVICE_TABLE(virtio, id_table);
+MODULE_DESCRIPTION("Virtio random number driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 7f7e798c1384..d9a0a53c842d 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -677,12 +677,7 @@ static void k_deadunicode(struct vc_data *vc, unsigned int value, char up_flag)
 
 static void k_self(struct vc_data *vc, unsigned char value, char up_flag)
 {
-        unsigned int uni;
-        if (kbd->kbdmode == VC_UNICODE)
-                uni = value;
-        else
-                uni = conv_8bit_to_uni(value);
-        k_unicode(vc, uni, up_flag);
+        k_unicode(vc, conv_8bit_to_uni(value), up_flag);
 }
 
 static void k_dead2(struct vc_data *vc, unsigned char value, char up_flag)
diff --git a/drivers/char/pcmcia/ipwireless/hardware.c b/drivers/char/pcmcia/ipwireless/hardware.c
index fa9d3c945f31..ba6340ae98af 100644
--- a/drivers/char/pcmcia/ipwireless/hardware.c
+++ b/drivers/char/pcmcia/ipwireless/hardware.c
@@ -251,10 +251,11 @@ struct ipw_hardware {
         int init_loops;
         struct timer_list setup_timer;
 
+        /* Flag if hw is ready to send next packet */
         int tx_ready;
-        struct list_head tx_queue[NL_NUM_OF_PRIORITIES];
-        /* True if any packets are queued for transmission */
+        /* Count of pending packets to be sent */
         int tx_queued;
+        struct list_head tx_queue[NL_NUM_OF_PRIORITIES];
 
         int rx_bytes_queued;
         struct list_head rx_queue;
@@ -404,6 +405,8 @@ static int do_send_fragment(struct ipw_hardware *hw, const unsigned char *data,
 
         spin_lock_irqsave(&hw->spinlock, flags);
 
+        hw->tx_ready = 0;
+
         if (hw->hw_version == HW_VERSION_1) {
                 outw((unsigned short) length, hw->base_port + IODWR);
 
@@ -492,6 +495,7 @@ static int do_send_packet(struct ipw_hardware *hw, struct ipw_tx_packet *packet)
 
                 spin_lock_irqsave(&hw->spinlock, flags);
                 list_add(&packet->queue, &hw->tx_queue[0]);
+                hw->tx_queued++;
                 spin_unlock_irqrestore(&hw->spinlock, flags);
         } else {
                 if (packet->packet_callback)
@@ -949,12 +953,10 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
         unsigned long flags;
 
         spin_lock_irqsave(&hw->spinlock, flags);
-        if (hw->tx_queued && hw->tx_ready != 0) {
+        if (hw->tx_queued && hw->tx_ready) {
                 int priority;
                 struct ipw_tx_packet *packet = NULL;
 
-                hw->tx_ready--;
-
                 /* Pick a packet */
                 for (priority = 0; priority < priority_limit; priority++) {
                         if (!list_empty(&hw->tx_queue[priority])) {
@@ -963,6 +965,7 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
                                                 struct ipw_tx_packet,
                                                 queue);
 
+                                hw->tx_queued--;
                                 list_del(&packet->queue);
 
                                 break;
@@ -973,6 +976,7 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
                         spin_unlock_irqrestore(&hw->spinlock, flags);
                         return 0;
                 }
+
                 spin_unlock_irqrestore(&hw->spinlock, flags);
 
                 /* Send */
@@ -1063,7 +1067,7 @@ static irqreturn_t ipwireless_handle_v1_interrupt(int irq,
                 if (irqn & IR_TXINTR) {
                         ack |= IR_TXINTR;
                         spin_lock_irqsave(&hw->spinlock, flags);
-                        hw->tx_ready++;
+                        hw->tx_ready = 1;
                         spin_unlock_irqrestore(&hw->spinlock, flags);
                 }
                 /* Received data */
@@ -1170,7 +1174,7 @@ static irqreturn_t ipwireless_handle_v2_v3_interrupt(int irq,
         if (memrxdone & MEMRX_RX_DONE) {
                 writew(0, &hw->memory_info_regs->memreg_rx_done);
                 spin_lock_irqsave(&hw->spinlock, flags);
-                hw->tx_ready++;
+                hw->tx_ready = 1;
                 spin_unlock_irqrestore(&hw->spinlock, flags);
                 tx = 1;
         }
@@ -1234,7 +1238,7 @@ static void send_packet(struct ipw_hardware *hw, int priority,
 
         spin_lock_irqsave(&hw->spinlock, flags);
         list_add_tail(&packet->queue, &hw->tx_queue[priority]);
-        hw->tx_queued = 1;
+        hw->tx_queued++;
         spin_unlock_irqrestore(&hw->spinlock, flags);
 
         flush_packets_to_hw(hw);
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index fa1ffbf2c621..935f1c207a1f 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -434,7 +434,7 @@ static void update_attr(struct vc_data *vc)
                       vc->vc_blink, vc->vc_underline,
                       vc->vc_reverse ^ vc->vc_decscnm, vc->vc_italic);
         vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm, 0) << 8) | ' ';
-        vc->vc_scrl_erase_char = (build_attr(vc, vc->vc_def_color, 1, false, false, false, false) << 8) | ' ';
+        vc->vc_scrl_erase_char = (build_attr(vc, vc->vc_def_color, 1, false, false, vc->vc_decscnm, false) << 8) | ' ';
 }
 
 /* Note: inverting the screen twice should revert to the original state */
@@ -909,7 +909,7 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
 
         if (vc->vc_tty) {
                 struct winsize ws, *cws = &vc->vc_tty->winsize;
-                unsigned long flags;
+                struct pid *pgrp = NULL;
 
                 memset(&ws, 0, sizeof(ws));
                 ws.ws_row = vc->vc_rows;
@@ -917,11 +917,14 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
                 ws.ws_ypixel = vc->vc_scan_lines;
 
                 mutex_lock(&vc->vc_tty->termios_mutex);
-                spin_lock_irqsave(&vc->vc_tty->ctrl_lock, flags);
-                if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col) &&
-                    vc->vc_tty->pgrp)
+                spin_lock_irq(&vc->vc_tty->ctrl_lock);
+                if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col))
+                        pgrp = get_pid(vc->vc_tty->pgrp);
+                spin_unlock_irq(&vc->vc_tty->ctrl_lock);
+                if (pgrp) {
                         kill_pgrp(vc->vc_tty->pgrp, SIGWINCH, 1);
-                spin_unlock_irqrestore(&vc->vc_tty->ctrl_lock, flags);
+                        put_pid(pgrp);
+                }
                 *cws = ws;
                 mutex_unlock(&vc->vc_tty->termios_mutex);
         }