]> nv-tegra.nvidia Code Review - linux-3.10.git/commitdiff
Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
authorLinus Torvalds <torvalds@g5.osdl.org>
Mon, 7 Nov 2005 21:26:58 +0000 (13:26 -0800)
committerLinus Torvalds <torvalds@g5.osdl.org>
Mon, 7 Nov 2005 21:26:58 +0000 (13:26 -0800)
16 files changed:
drivers/char/agp/ali-agp.c
drivers/char/agp/amd-k7-agp.c
drivers/char/agp/amd64-agp.c
drivers/char/agp/ati-agp.c
drivers/char/agp/backend.c
drivers/char/agp/efficeon-agp.c
drivers/char/agp/frontend.c
drivers/char/agp/generic.c
drivers/char/agp/i460-agp.c
drivers/char/agp/intel-agp.c
drivers/char/agp/nvidia-agp.c
drivers/char/agp/sgi-agp.c
drivers/char/agp/sis-agp.c
drivers/char/agp/sworks-agp.c
drivers/char/agp/uninorth-agp.c
drivers/char/agp/via-agp.c

index b02fc2267159675c32e8e6a58c27ab8173a9161f..ba54b58725781e4678a41409318c0e45ff72b7ad 100644 (file)
@@ -389,6 +389,7 @@ static struct pci_device_id agp_ali_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_ali_pci_table);
 
 static struct pci_driver agp_ali_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-ali",
        .id_table       = agp_ali_pci_table,
        .probe          = agp_ali_probe,
index 3a41672e4d6682112f19a19ee8ceae2752984be0..40fcd88b2ceac6dbd759300b930bb8f62153d520 100644 (file)
@@ -94,19 +94,16 @@ static int amd_create_gatt_pages(int nr_tables)
        int retval = 0;
        int i;
 
-       tables = kmalloc((nr_tables + 1) * sizeof(struct amd_page_map *),
-                        GFP_KERNEL);
+       tables = kzalloc((nr_tables + 1) * sizeof(struct amd_page_map *),GFP_KERNEL);
        if (tables == NULL)
                return -ENOMEM;
 
-       memset (tables, 0, sizeof(struct amd_page_map *) * (nr_tables + 1));
        for (i = 0; i < nr_tables; i++) {
-               entry = kmalloc(sizeof(struct amd_page_map), GFP_KERNEL);
+               entry = kzalloc(sizeof(struct amd_page_map), GFP_KERNEL);
                if (entry == NULL) {
                        retval = -ENOMEM;
                        break;
                }
-               memset (entry, 0, sizeof(struct amd_page_map));
                tables[i] = entry;
                retval = amd_create_page_map(entry);
                if (retval != 0)
@@ -518,6 +515,7 @@ static struct pci_device_id agp_amdk7_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_amdk7_pci_table);
 
 static struct pci_driver agp_amdk7_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-amdk7",
        .id_table       = agp_amdk7_pci_table,
        .probe          = agp_amdk7_probe,
index 78ce98a69f37044dfe17c98d6f264f3989535a23..8f748fddca9456d9cdb591d63d67aea049dc3e27 100644 (file)
@@ -703,6 +703,7 @@ static struct pci_device_id agp_amd64_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_amd64_pci_table);
 
 static struct pci_driver agp_amd64_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-amd64",
        .id_table       = agp_amd64_pci_table,
        .probe          = agp_amd64_probe,
index 0b6e72642d6e5a0126038d5cd553f39fd87d4d0c..fbd415565463426bf299188b47d5b482f6d4d47f 100644 (file)
@@ -118,14 +118,12 @@ static int ati_create_gatt_pages(int nr_tables)
        int retval = 0;
        int i;
 
-       tables = kmalloc((nr_tables + 1) * sizeof(ati_page_map *),
-                        GFP_KERNEL);
+       tables = kzalloc((nr_tables + 1) * sizeof(ati_page_map *),GFP_KERNEL);
        if (tables == NULL)
                return -ENOMEM;
 
-       memset(tables, 0, sizeof(ati_page_map *) * (nr_tables + 1));
        for (i = 0; i < nr_tables; i++) {
-               entry = kmalloc(sizeof(ati_page_map), GFP_KERNEL);
+               entry = kzalloc(sizeof(ati_page_map), GFP_KERNEL);
                if (entry == NULL) {
                        while (i>0) {
                                kfree (tables[i-1]);
@@ -136,7 +134,6 @@ static int ati_create_gatt_pages(int nr_tables)
                        retval = -ENOMEM;
                        break;
                }
-               memset(entry, 0, sizeof(ati_page_map));
                tables[i] = entry;
                retval = ati_create_page_map(entry);
                if (retval != 0) break;
@@ -524,6 +521,7 @@ static struct pci_device_id agp_ati_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_ati_pci_table);
 
 static struct pci_driver agp_ati_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-ati",
        .id_table       = agp_ati_pci_table,
        .probe          = agp_ati_probe,
index 82b43c541c8dca52ad90c0ea6c6b984a50c455ee..73f333f491bde21a3cd14656e15c8d7d740450b5 100644 (file)
@@ -222,12 +222,12 @@ static void agp_backend_cleanup(struct agp_bridge_data *bridge)
 
 struct agp_bridge_data *agp_alloc_bridge(void)
 {
-       struct agp_bridge_data *bridge = kmalloc(sizeof(*bridge), GFP_KERNEL);
-
+       struct agp_bridge_data *bridge;
+       
+       bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
        if (!bridge)
                return NULL;
 
-       memset(bridge, 0, sizeof(*bridge));
        atomic_set(&bridge->agp_in_use, 0);
        atomic_set(&bridge->current_memory_agp, 0);
 
index ac19fdcd21c1c7583246256edba92157b42d278e..d41e0a62e32efe77017abf86570d2f4147b75e7b 100644 (file)
@@ -219,7 +219,7 @@ static int efficeon_create_gatt_table(struct agp_bridge_data *bridge)
 
                efficeon_private.l1_table[index] = page;
 
-               value = virt_to_gart(page) | pati | present | index;
+               value = virt_to_gart((unsigned long *)page) | pati | present | index;
 
                pci_write_config_dword(agp_bridge->dev,
                        EFFICEON_ATTPAGE, value);
@@ -429,6 +429,7 @@ static struct pci_device_id agp_efficeon_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_efficeon_pci_table);
 
 static struct pci_driver agp_efficeon_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-efficeon",
        .id_table       = agp_efficeon_pci_table,
        .probe          = agp_efficeon_probe,
index 3dfb6648547bb8d3e854abd31f492f554e8bc2ee..17f520c9d4714aa90a145f200c31675b38699882 100644 (file)
@@ -189,13 +189,12 @@ static int agp_create_segment(struct agp_client *client, struct agp_region *regi
        struct agp_segment *user_seg;
        size_t i;
 
-       seg = kmalloc((sizeof(struct agp_segment_priv) * region->seg_count), GFP_KERNEL);
+       seg = kzalloc((sizeof(struct agp_segment_priv) * region->seg_count), GFP_KERNEL);
        if (seg == NULL) {
                kfree(region->seg_list);
                region->seg_list = NULL;
                return -ENOMEM;
        }
-       memset(seg, 0, (sizeof(struct agp_segment_priv) * region->seg_count));
        user_seg = region->seg_list;
 
        for (i = 0; i < region->seg_count; i++) {
@@ -332,14 +331,11 @@ static struct agp_controller *agp_create_controller(pid_t id)
 {
        struct agp_controller *controller;
 
-       controller = kmalloc(sizeof(struct agp_controller), GFP_KERNEL);
-
+       controller = kzalloc(sizeof(struct agp_controller), GFP_KERNEL);
        if (controller == NULL)
                return NULL;
 
-       memset(controller, 0, sizeof(struct agp_controller));
        controller->pid = id;
-
        return controller;
 }
 
@@ -540,12 +536,10 @@ static struct agp_client *agp_create_client(pid_t id)
 {
        struct agp_client *new_client;
 
-       new_client = kmalloc(sizeof(struct agp_client), GFP_KERNEL);
-
+       new_client = kzalloc(sizeof(struct agp_client), GFP_KERNEL);
        if (new_client == NULL)
                return NULL;
 
-       memset(new_client, 0, sizeof(struct agp_client));
        new_client->pid = id;
        agp_insert_client(new_client);
        return new_client;
@@ -709,11 +703,10 @@ static int agp_open(struct inode *inode, struct file *file)
        if (minor != AGPGART_MINOR)
                goto err_out;
 
-       priv = kmalloc(sizeof(struct agp_file_private), GFP_KERNEL);
+       priv = kzalloc(sizeof(struct agp_file_private), GFP_KERNEL);
        if (priv == NULL)
                goto err_out_nomem;
 
-       memset(priv, 0, sizeof(struct agp_file_private));
        set_bit(AGP_FF_ALLOW_CLIENT, &priv->access_flags);
        priv->my_pid = current->pid;
 
index ac9da0ca36b7b1425a679ab74f3277e008ba661b..c4a38715c6f9751c3127497e2592b5717f1a2f32 100644 (file)
@@ -105,12 +105,10 @@ struct agp_memory *agp_create_memory(int scratch_pages)
 {
        struct agp_memory *new;
 
-       new = kmalloc(sizeof(struct agp_memory), GFP_KERNEL);
-
+       new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
        if (new == NULL)
                return NULL;
 
-       memset(new, 0, sizeof(struct agp_memory));
        new->key = agp_get_key();
 
        if (new->key < 0) {
@@ -414,7 +412,8 @@ static void agp_v2_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_
        u32 tmp;
 
        if (*requested_mode & AGP2_RESERVED_MASK) {
-               printk(KERN_INFO PFX "reserved bits set in mode 0x%x. Fixed.\n", *requested_mode);
+               printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
+                       *requested_mode & AGP2_RESERVED_MASK, *requested_mode);
                *requested_mode &= ~AGP2_RESERVED_MASK;
        }
 
@@ -492,7 +491,8 @@ static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_
        u32 tmp;
 
        if (*requested_mode & AGP3_RESERVED_MASK) {
-               printk(KERN_INFO PFX "reserved bits set in mode 0x%x. Fixed.\n", *requested_mode);
+               printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
+                       *requested_mode & AGP3_RESERVED_MASK, *requested_mode);
                *requested_mode &= ~AGP3_RESERVED_MASK;
        }
 
index a2d9e5e48bbeeff576bb7f0ac953b837017695b3..58944cd271ead9c55120a43ffa014bd5f34ac9cf 100644 (file)
@@ -227,10 +227,9 @@ static int i460_configure (void)
         */
        if (I460_IO_PAGE_SHIFT > PAGE_SHIFT) {
                size = current_size->num_entries * sizeof(i460.lp_desc[0]);
-               i460.lp_desc = kmalloc(size, GFP_KERNEL);
+               i460.lp_desc = kzalloc(size, GFP_KERNEL);
                if (!i460.lp_desc)
                        return -ENOMEM;
-               memset(i460.lp_desc, 0, size);
        }
        return 0;
 }
@@ -366,13 +365,12 @@ static int i460_alloc_large_page (struct lp_desc *lp)
        }
 
        map_size = ((I460_KPAGES_PER_IOPAGE + BITS_PER_LONG - 1) & -BITS_PER_LONG)/8;
-       lp->alloced_map = kmalloc(map_size, GFP_KERNEL);
+       lp->alloced_map = kzalloc(map_size, GFP_KERNEL);
        if (!lp->alloced_map) {
                free_pages((unsigned long) lpage, order);
                printk(KERN_ERR PFX "Out of memory, we're in trouble...\n");
                return -ENOMEM;
        }
-       memset(lp->alloced_map, 0, map_size);
 
        lp->paddr = virt_to_gart(lpage);
        lp->refcount = 0;
@@ -619,6 +617,7 @@ static struct pci_device_id agp_intel_i460_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_intel_i460_pci_table);
 
 static struct pci_driver agp_intel_i460_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-intel-i460",
        .id_table       = agp_intel_i460_pci_table,
        .probe          = agp_intel_i460_probe,
index 1f7d415f432ca4f94a7b9f6dc0b3f531df3fa52d..bf4cc9ffd5b1dd737f0921b8319f3efeabdc2b77 100644 (file)
@@ -1824,6 +1824,7 @@ static struct pci_device_id agp_intel_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_intel_pci_table);
 
 static struct pci_driver agp_intel_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-intel",
        .id_table       = agp_intel_pci_table,
        .probe          = agp_intel_probe,
index 80dafa3030bd5433a9e128dc62820ea6cc95f180..3aed0c5e2f9256ebadcf6670caa91d8b393d6842 100644 (file)
@@ -398,6 +398,7 @@ static struct pci_device_id agp_nvidia_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_nvidia_pci_table);
 
 static struct pci_driver agp_nvidia_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-nvidia",
        .id_table       = agp_nvidia_pci_table,
        .probe          = agp_nvidia_probe,
index 7957fc91f6ada9faad5df39d4381e52e90267ce4..4df7734b51c2b37824715038e5e0f9eb1c38fa00 100644 (file)
@@ -289,6 +289,8 @@ static int __devinit agp_sgi_init(void)
        j = 0;
        list_for_each_entry(info, &tioca_list, ca_list) {
                struct list_head *tmp;
+               if (list_empty(info->ca_devices))
+                       continue;
                list_for_each(tmp, info->ca_devices) {
                        u8 cap_ptr;
                        pdev = pci_dev_b(tmp);
index ebc05554045c73b16f099d81aad774ad3b478fb6..a701361a889084b20278a4c55aa0676516778143 100644 (file)
@@ -332,6 +332,7 @@ static struct pci_device_id agp_sis_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_sis_pci_table);
 
 static struct pci_driver agp_sis_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-sis",
        .id_table       = agp_sis_pci_table,
        .probe          = agp_sis_probe,
index 71ea59a1dbebf982fecbd86cc06fa516d2bcd152..5a5392dd1254765de3b7345e317bbe9dac5878a4 100644 (file)
@@ -102,19 +102,17 @@ static int serverworks_create_gatt_pages(int nr_tables)
        int retval = 0;
        int i;
 
-       tables = kmalloc((nr_tables + 1) * sizeof(struct serverworks_page_map *), 
+       tables = kzalloc((nr_tables + 1) * sizeof(struct serverworks_page_map *), 
                         GFP_KERNEL);
-       if (tables == NULL) {
+       if (tables == NULL)
                return -ENOMEM;
-       }
-       memset(tables, 0, sizeof(struct serverworks_page_map *) * (nr_tables + 1));
+
        for (i = 0; i < nr_tables; i++) {
-               entry = kmalloc(sizeof(struct serverworks_page_map), GFP_KERNEL);
+               entry = kzalloc(sizeof(struct serverworks_page_map), GFP_KERNEL);
                if (entry == NULL) {
                        retval = -ENOMEM;
                        break;
                }
-               memset(entry, 0, sizeof(struct serverworks_page_map));
                tables[i] = entry;
                retval = serverworks_create_page_map(entry);
                if (retval != 0) break;
@@ -244,13 +242,27 @@ static int serverworks_fetch_size(void)
  */
 static void serverworks_tlbflush(struct agp_memory *temp)
 {
+       unsigned long timeout;
+
        writeb(1, serverworks_private.registers+SVWRKS_POSTFLUSH);
-       while (readb(serverworks_private.registers+SVWRKS_POSTFLUSH) == 1)
+       timeout = jiffies + 3*HZ;
+       while (readb(serverworks_private.registers+SVWRKS_POSTFLUSH) == 1) {
                cpu_relax();
+               if (time_after(jiffies, timeout)) {
+                       printk(KERN_ERR PFX "TLB post flush took more than 3 seconds\n");
+                       break;
+               }
+       }
 
        writel(1, serverworks_private.registers+SVWRKS_DIRFLUSH);
-       while(readl(serverworks_private.registers+SVWRKS_DIRFLUSH) == 1)
+       timeout = jiffies + 3*HZ;
+       while (readl(serverworks_private.registers+SVWRKS_DIRFLUSH) == 1) {
                cpu_relax();
+               if (time_after(jiffies, timeout)) {
+                       printk(KERN_ERR PFX "TLB Dir flush took more than 3 seconds\n");
+                       break;
+               }
+       }
 }
 
 static int serverworks_configure(void)
@@ -533,6 +545,7 @@ static struct pci_device_id agp_serverworks_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_serverworks_pci_table);
 
 static struct pci_driver agp_serverworks_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-serverworks",
        .id_table       = agp_serverworks_pci_table,
        .probe          = agp_serverworks_probe,
index c8255312b8c1f3728fb608928ebf554913cff4d2..183c50acab279860a9a3b399c3de277b9df60f49 100644 (file)
@@ -658,6 +658,7 @@ static struct pci_device_id agp_uninorth_pci_table[] = {
 MODULE_DEVICE_TABLE(pci, agp_uninorth_pci_table);
 
 static struct pci_driver agp_uninorth_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-uninorth",
        .id_table       = agp_uninorth_pci_table,
        .probe          = agp_uninorth_probe,
index c847df575cf5b96437b73dfb64311122a16326bf..5d9a13700074401ddf98e14b52ab249e69ab3d2c 100644 (file)
@@ -518,6 +518,7 @@ MODULE_DEVICE_TABLE(pci, agp_via_pci_table);
 
 
 static struct pci_driver agp_via_pci_driver = {
+       .owner          = THIS_MODULE,
        .name           = "agpgart-via",
        .id_table       = agp_via_pci_table,
        .probe          = agp_via_probe,